pub struct MemFlags { /* private fields */ }
Expand description

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

Create a new empty set of flags.

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

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.

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.

Set endianness of the memory access.

Set endianness of the memory access, returning new flags.

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.

Set the notrap flag.

Set the notrap flag, returning new flags.

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.

Set the aligned flag.

Set the aligned flag, returning new flags.

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.

Set the readonly flag.

Set the readonly flag, returning new flags.

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.

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

Set the heap bit, returning new flags.

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.

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

Set the table bit, returning new flags.

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.

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

Set the vmctx bit, returning new flags.

Trait Implementations

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Formats the value using the given formatter. Read more

Feeds this value into the given Hasher. Read more

Feeds a slice of this type into the given Hasher. Read more

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

This method tests for !=.

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Compare self to key and return true if they are equal.

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

🔬 This is a nightly-only experimental API. (toowned_clone_into)

Uses borrowed data to replace owned data, usually by cloning. Read more

Converts the given value to a String. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.