Struct cranelift_codegen::binemit::StackMap

pub struct StackMap { /* private fields */ }

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_slice(vec: &[bool]) -> Self

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

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

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

Formats the value using the given formatter.

impl PartialEq for StackMap

fn eq(&self, other: &StackMap) -> 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 Eq for StackMap

impl StructuralPartialEq for StackMap