Struct Flags 

pub struct Flags(/* private fields */);

The flags on one instruction.

A bitset rather than a struct of bools, because it rides along in the instruction table and two bytes there is two bytes per instruction in every function in the program.

Implementations

impl Flags

pub const NONE: Self

No flags, which is what -O0 and -fwrapv and a plain unsigned addition all produce.

pub const NSW: Self

No signed wrap. Signed overflow is undefined, so the optimizer may assume it does not happen. -fwrapv stops the frontend setting this and nothing else changes.

pub const NUW: Self

No unsigned wrap. Set only where the frontend knows it from the source, since C’s unsigned arithmetic wraps by definition and most unsigned arithmetic does not get this.

pub const EXACT: Self

The shift or division is exact, so no bits are discarded and no remainder is dropped.

pub const NNAN: Self

No NaN operands or results.

pub const NINF: Self

No infinite operands or results.

pub const NSZ: Self

The sign of a zero does not matter.

pub const ARCP: Self

A division may become a multiplication by the reciprocal.

pub const CONTRACT: Self

A multiplication and an addition may be contracted into one rounding.

pub const REASSOC: Self

The operation may be reassociated, which is the one that changes results the most.

pub const VOLATILE: Self

The access is volatile, so it happens exactly once and is never moved or merged.

pub const NOALIAS: Self

The result does not alias anything else reachable, which is what restrict gives.

pub const NOFREE: Self

Nothing this call reaches ends the lifetime of any storage.

The nofree summary of spec/safe-memory/07-check-elimination.md section 7.5, written onto the call site by a module-level analysis rather than by the frontend. A pass carrying what an earlier safety check established keeps it across a call that has this and gives it up across a call that does not.

pub const STATIC: Self

The bytes this safety check is about lie inside one object of static storage duration whose extent this module knows.

Section 7.2 of spec/safe-memory/07-check-elimination.md puts the frontend first of the four sources of a discharge, because most accesses in real C are to a local or a global at a constant offset and how big either one is is not something anybody has to work out. The local half is read straight off the alloca by the pass that removes the check. The global half is this flag, because a global’s size lives on the module and a pass is given one function, so a module-level analysis works it out before the pipeline starts and writes it onto the check.

A fact rather than a licence, like Flags::NOFREE and unlike everything above it. It says what is true of the bytes, and whether that is enough for the check to go is a rule.

pub const FAST: Self

Every fast-math flag, which is what -ffast-math sets on an expression.

pub const fn bits(self) -> u16

The underlying bits, for the printer and for hashing an instruction.

pub const fn is_empty(self) -> bool

Whether nothing is set.

pub const fn contains(self, other: Self) -> bool

Whether every flag in other is set here.

pub const fn union(self, other: Self) -> Self

Both sets.

pub const fn intersection(self, other: Self) -> Self

The flags in both sets.

This is what a rewrite does when it replaces two instructions with one: a licence granted on one of them and not the other is not a licence over the result.

pub const fn without(self, other: Self) -> Self

This set without the flags in other.

pub const fn legal_on(opcode: Opcode) -> Self

The flags that mean anything on that opcode.

Anything outside this is a verifier failure rather than something ignored, because a flag on an instruction that does not read it is a flag somebody meant to put somewhere else.

pub fn iter(self) -> impl Iterator<Item = (Self, &'static str)>

Every flag that is set, with its name, in the order the printer writes them.

pub fn from_name(name: &str) -> Option<Self>

The flag with that name, if there is one.

Trait Implementations

impl BitOr for Flags

type Output = Flags

The resulting type after applying the | operator.

fn bitor(self, other: Self) -> Self

Performs the | operation.

impl BitOrAssign for Flags

fn bitor_assign(&mut self, other: Self)

Performs the |= operation.

impl Clone for Flags

fn clone(&self) -> Flags

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Flags

impl Debug for Flags

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

Formats the value using the given formatter.

impl Default for Flags

fn default() -> Flags

Returns the “default value” for a type.

impl Display for Flags

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

The suffix form the textual IR uses, add.nsw, with a leading dot on each flag and nothing at all when the set is empty.

impl Eq for Flags

impl Hash for Flags

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Flags

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Flags