Struct Machine 

pub struct Machine { /* private fields */ }

The target a pass is compiling for, and which of its two cost tables applies.

Implementations

impl Machine

pub fn of(module: &Module, level: OptLevel) -> Self

The machine a module is being compiled for at that level.

Both halves come from things the pipeline already has, which is why no flag was added for this. The architecture is on the module, because a module is built for a target and says so, and the goal is whether the level optimizes for size, which is one call on the level.

pub const fn with(costs: Option<&'static dyn TargetCosts>, goal: Goal) -> Self

The machine for costs already in hand.

What Machine::of is written in terms of, and what a caller that resolved a target some other way uses. None is a target with no cost table, which is every architecture rucc has no back end for.

pub const fn unknown() -> Self

A machine nobody has a cost table for, which is what a test that does not care wants.

Named for what it is rather than called default, because a default machine is the thing this module exists to avoid: a pass that got one silently would be optimizing for a target that does not exist.

pub fn costs(self) -> Option<&'static dyn TargetCosts>

The costs for this target, or nothing for one with no table.

pub const fn goal(self) -> Goal

Which table applies, which is the goal the level asked for.

pub fn table(self) -> Option<&'static CostTable>

The cost table for this target and goal, or nothing for a target with no table.

pub fn tune(self, flag: TuneFlag) -> bool

What this target answers for a tuning flag, and the flag’s documented default without one.

A default is right here and wrong for a number, which is the asymmetry Tuning::untuned already records: a tuning flag is a question whose safe answer is written down, and a cost is a measurement of a machine.

pub fn allocatable(self, class: RegClass) -> Option<u32>

How many registers of that bank the allocator hands out, or nothing without a target.

pub fn branch_cost(self, predictable: bool) -> Option<Cycles>

What a branch of that predictability costs, or nothing without a target.

pub fn name(self) -> &'static str

What the machine is called in a dump, and unknown for a target with no table.

Trait Implementations

impl Clone for Machine

fn clone(&self) -> Machine

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Machine

impl Debug for Machine

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

The name and the goal, because a dyn TargetCosts has no Debug and the pointer would say nothing to anybody reading a dump.