Struct Options 

#[non_exhaustive]
pub struct Options {

    pub target: Triple,
    pub opt_level: OptLevel,
    pub emit: EmitKind,
    pub debug_info: bool,
    pub frame_pointer: bool,
    pub red_zone: bool,
    pub warnings_are_errors: bool,
    pub error_limit: u32,
    pub std: Std,
    pub gnu_extensions: bool,
    pub pedantic: bool,
    pub gnuc: GnucVersion,
    pub hosted: bool,
    pub defines: Vec<String>,
    pub undefines: Vec<String>,
    pub search: SearchPath,
    pub line_markers: bool,
    pub dumps: Dumps,
    pub passes: Vec<(String, bool)>,
    pub pass_fuel: Vec<(String, u32)>,
    pub dump_ir: Vec<String>,
    pub verify_each: bool,
    pub rule_coverage: Option<String>,
}

Everything a compilation was asked to do.

Options are a plain value with no interior mutability, so a caller can build one, clone it, tweak one field and run a second compilation, which is exactly what the differential testing in spec/15-testing.md needs.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

target: Triple

The target to generate code for.

opt_level: OptLevel

The optimisation level.

emit: EmitKind

What to produce.

debug_info: bool

Whether to emit debug information.

frame_pointer: bool

Whether every function keeps a frame pointer, from -fno-omit-frame-pointer.

Off by default, which is what gcc does at every level above -O0 and what leaves the register free for the allocator. A profiler that walks the stack by following saved frame pointers needs it on, and so does any code a debugger has to unwind without unwind tables.

red_zone: bool

Whether the red zone may be used, from -mno-red-zone turned around.

The 128 bytes below the stack pointer that the System V psABI promises no signal handler will touch, which lets a small leaf function keep its locals without moving the stack pointer at all. A kernel turns this off, because an interrupt taken on the kernel stack makes the promise false, and every kernel build in the wild passes -mno-red-zone for exactly that reason. A convention without a red zone ignores this.

warnings_are_errors: bool

Whether warnings are errors.

error_limit: u32

How many diagnostics to print before giving up. Past a certain point the output is noise from a single earlier mistake, and GCC’s default of no limit is not a kindness.

std: Std

The dialect, from -std=.

gnu_extensions: bool

Whether the GNU extensions are on, which is -std=gnu23 rather than -std=c23.

pedantic: bool

Whether -pedantic was given, which is what turns a use of an extension from silence into a diagnostic. It is not the same knob as the dialect: -std=c17 -pedantic warns about a construct that -std=c17 alone accepts without a word.

gnuc: GnucVersion

The GCC release claimed, from -fgnuc-version=.

hosted: bool

Whether there is a standard library, which is -ffreestanding turned around.

defines: Vec<String>

-D in command line order. FOO means FOO=1, as GCC has it.

undefines: Vec<String>

-U in command line order, applied after the defines because -U wins.

search: SearchPath

Where a header is looked for.

line_markers: bool

Whether -E writes line markers, which -P turns off.

dumps: Dumps

What the -d family asks for.

passes: Vec<(String, bool)>

What -f<pass> and -fno-<pass> said about an optimizer pass, in the order the command line said it, so that the last mention of a pass is the one that decides.

The pipeline the level chose is the starting point and this is what is added to and taken away from it. The names are checked against the pass list while the arguments are parsed, so anything in here is a pass the compiler has.

pass_fuel: Vec<(String, u32)>

What -fpass-fuel=<pass>=<n> limited a pass to, by pass name.

A pass with an entry here performs exactly that many transformations and then stops transforming, which is what bisects a miscompilation to one rewrite. See section 9.10 of spec/09-optimizer.md.

dump_ir: Vec<String>

What -fdump-ir= asked to see, as it was written, which is all, before-<pass> or after-<pass>.

verify_each: bool

Whether the IR verifier runs after every pass that changed anything.

On in a debug build without being asked, since that is where a broken pass should be caught. -Zverify-each turns it on in a release build, which is what CI wants.

rule_coverage: Option<String>

Where -Zrule-coverage=FILE writes which lowering rules fired, if it was given.

A measurement rather than a thing a build asks for, which is why it is spelled with a -Z the way an unstable option is everywhere else: it is here for the harness in tamnd/rucc-compat to union over a corpus and report, and nothing about the code that comes out changes when it is on. One file per run of the compiler, holding the whole rule set with the rules this run reached marked, whatever the run compiled and however many files it was.

Implementations

impl Options

pub fn new(target: Triple) -> Self

Default options for target.

Trait Implementations

impl Clone for Options

fn clone(&self) -> Options

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Options

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Options

impl PartialEq for Options

fn eq(&self, other: &Options) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Options