Struct wasmtime_environ::ir::StackMap

pub struct StackMap { /* fields omitted */ }

Stack maps record which words in a stack frame contain live GC references at a given instruction pointer.

Logically, a set of stack maps for a function record a table of the form:

+---------------------+-------------------------------------------+
| Instruction Pointer | SP-Relative Offsets of Live GC References |
+---------------------+-------------------------------------------+
| 0x12345678          | 2, 6, 12                                  |
| 0x1234abcd          | 2, 6                                      |
| ...                 | ...                                       |
+---------------------+-------------------------------------------+

Where “instruction pointer” is an instruction pointer within the function, and “offsets of live GC references” contains the offsets (in units of words) from the frame’s stack pointer where live GC references are stored on the stack. Instruction pointers within the function that do not have an entry in this table are not GC safepoints.

Because

• offsets of live GC references are relative from the stack pointer, and
• stack frames grow down from higher addresses to lower addresses,

to get a pointer to a live reference at offset x within a stack frame, you add x from the frame’s stack pointer.

For example, to calculate the pointer to the live GC reference inside “frame 1” below, you would do frame_1_sp + x:

          Stack
        +-------------------+
        | Frame 0           |
        |                   |
   |    |                   |
   |    +-------------------+ <--- Frame 0's SP
   |    | Frame 1           |
 Grows  |                   |
 down   |                   |
   |    | Live GC reference | --+--
   |    |                   |   |
   |    |                   |   |
   V    |                   |   x = offset of live GC reference
        |                   |   |
        |                   |   |
        +-------------------+ --+--  <--- Frame 1's SP
        | Frame 2           |
        | ...               |

An individual StackMap is associated with just one instruction pointer within the function, contains the size of the stack frame, and represents the stack frame as a bitmap. There is one bit per word in the stack frame, and if the bit is set, then the word contains a live GC reference.

Note that a caller’s OutgoingArg stack slots and callee’s IncomingArg stack slots overlap, so we must choose which function’s stack maps record live GC references in these slots. We record the IncomingArgs in the callee’s stack map.

Implementations

impl StackMap

pub fn from_values(
    args: &[Value],
    func: &Function,
    isa: &dyn TargetIsa
) -> StackMap

Create a StackMap based on where references are located on a function’s stack.

pub fn from_slice(vec: &[bool]) -> StackMap

Create a vec of Bitsets from a slice of bools.

pub fn get_bit(&self, bit_index: usize) -> bool

Returns a specified bit.

pub fn as_slice(&self) -> &[BitSet<u32>]

Returns the raw bitmap that represents this stack map.

pub fn mapped_words(&self) -> u32

Returns the number of words represented by this stack map.

Trait Implementations

impl Clone for StackMap

pub fn clone(&self) -> StackMap

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StackMap

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StackMap

pub fn deserialize<__D>(
    __deserializer: __D
) -> Result<StackMap, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl PartialEq<StackMap> for StackMap

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

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

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

This method tests for !=.

impl Serialize for StackMap

pub fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl Eq for StackMap

impl StructuralEq for StackMap

impl StructuralPartialEq for StackMap