Struct cranelift_codegen::ir::MemFlags

pub struct MemFlags { /* private fields */ }

Flags for memory operations like load/store.

Each of these flags introduce a limited form of undefined behavior. The flags each enable certain optimizations that need to make additional assumptions. Generally, the semantics of a program does not change when a flag is removed, but adding a flag will.

In addition, the flags determine the endianness of the memory access. By default, any memory access uses the native endianness determined by the target ISA. This can be overridden for individual accesses by explicitly specifying little- or big-endian semantics via the flags.

Implementations

impl MemFlags

pub const fn new() -> Self

Create a new empty set of flags.

pub const fn trusted() -> Self

Create a set of flags representing an access from a “trusted” address, meaning it’s known to be aligned and non-trapping.

pub fn set_by_name(&mut self, name: &str) -> bool

Set a flag bit by name.

Returns true if the flag was found and set, false for an unknown flag name. Will also return false when trying to set inconsistent endianness flags.

pub const fn endianness(self, native_endianness: Endianness) -> Endianness

Return endianness of the memory access. This will return the endianness explicitly specified by the flags if any, and will default to the native endianness otherwise. The native endianness has to be provided by the caller since it is not explicitly encoded in CLIF IR – this allows a front end to create IR without having to know the target endianness.

pub fn set_endianness(&mut self, endianness: Endianness)

Set endianness of the memory access.

pub const fn with_endianness(self, endianness: Endianness) -> Self

Set endianness of the memory access, returning new flags.

pub const fn notrap(self) -> bool

Test if the notrap flag is set.

Normally, trapping is part of the semantics of a load/store operation. If the platform would cause a trap when accessing the effective address, the Cranelift memory operation is also required to trap.

The notrap flag tells Cranelift that the memory is accessible, which means that accesses will not trap. This makes it possible to delete an unused load or a dead store instruction.

pub fn set_notrap(&mut self)

Set the notrap flag.

pub const fn with_notrap(self) -> Self

Set the notrap flag, returning new flags.

pub const fn aligned(self) -> bool

Test if the aligned flag is set.

By default, Cranelift memory instructions work with any unaligned effective address. If the aligned flag is set, the instruction is permitted to trap or return a wrong result if the effective address is misaligned.

pub fn set_aligned(&mut self)

Set the aligned flag.

pub const fn with_aligned(self) -> Self

Set the aligned flag, returning new flags.

pub const fn readonly(self) -> bool

Test if the readonly flag is set.

Loads with this flag have no memory dependencies. This results in undefined behavior if the dereferenced memory is mutated at any time between when the function is called and when it is exited.

pub fn set_readonly(&mut self)

Set the readonly flag.

pub const fn with_readonly(self) -> Self

Set the readonly flag, returning new flags.

pub const fn heap(self) -> bool

Test if the heap bit is set.

Loads and stores with this flag accesses the “heap” part of abstract state. This is disjoint from the “table”, “vmctx”, and “other” parts of abstract state. In concrete terms, this means that behavior is undefined if the same memory is also accessed by another load/store with one of the other alias-analysis bits (table, vmctx) set, or heap not set.

pub fn set_heap(&mut self)

Set the heap bit. See the notes about mutual exclusion with other bits in heap().

pub const fn with_heap(self) -> Self

Set the heap bit, returning new flags.

pub const fn table(self) -> bool

Test if the table bit is set.

Loads and stores with this flag accesses the “table” part of abstract state. This is disjoint from the “heap”, “vmctx”, and “other” parts of abstract state. In concrete terms, this means that behavior is undefined if the same memory is also accessed by another load/store with one of the other alias-analysis bits (heap, vmctx) set, or table not set.

pub fn set_table(&mut self)

Set the table bit. See the notes about mutual exclusion with other bits in table().

pub const fn with_table(self) -> Self

Set the table bit, returning new flags.

pub const fn vmctx(self) -> bool

Test if the vmctx bit is set.

Loads and stores with this flag accesses the “vmctx” part of abstract state. This is disjoint from the “heap”, “table”, and “other” parts of abstract state. In concrete terms, this means that behavior is undefined if the same memory is also accessed by another load/store with one of the other alias-analysis bits (heap, table) set, or vmctx not set.

pub fn set_vmctx(&mut self)

Set the vmctx bit. See the notes about mutual exclusion with other bits in vmctx().

pub const fn with_vmctx(self) -> Self

Set the vmctx bit, returning new flags.

pub const fn checked(self) -> bool

Test if the checked bit is set.

Loads and stores with this flag are verified to access pointers only with a validated PointsTo fact attached, and with that fact validated, when using the proof-carrying-code framework. If initial facts on program inputs are correct (i.e., correctly denote the shape and types of data structures in memory), and if PCC validates the compiled output, then all checked-marked memory accesses are guaranteed (up to the checker’s correctness) to access valid memory. This can be used to ensure memory safety and sandboxing.

pub fn set_checked(&mut self)

Set the checked bit.

pub const fn with_checked(self) -> Self

Set the checked bit, returning new flags.

Trait Implementations

impl Clone for MemFlags

fn clone(&self) -> MemFlags

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for MemFlags

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

Formats the value using the given formatter.

impl Display for MemFlags

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

Formats the value using the given formatter.

impl Hash for MemFlags

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 MemFlags

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for MemFlags

impl Eq for MemFlags

impl StructuralPartialEq for MemFlags