Struct cranelift_codegen::ir::function::FunctionStencil

pub struct FunctionStencil {
    pub version_marker: VersionMarker,
    pub signature: Signature,
    pub sized_stack_slots: StackSlots,
    pub dynamic_stack_slots: DynamicStackSlots,
    pub global_values: PrimaryMap<GlobalValue, GlobalValueData>,
    pub tables: PrimaryMap<Table, TableData>,
    pub dfg: DataFlowGraph,
    pub layout: Layout,
    pub srclocs: SecondaryMap<Inst, RelSourceLoc>,
    pub stack_limit: Option<GlobalValue>,
}

Function fields needed when compiling a function.

Additionally, these fields can be the same for two functions that would be compiled the same way, and finalized by applying FunctionParameters onto their CompiledCodeStencil.

Fields

version_marker: VersionMarker

A version marker used to ensure that serialized clif ir is never deserialized with a different version of Cranelift.

signature: Signature

Signature of this function.

sized_stack_slots: StackSlots

Sized stack slots allocated in this function.

dynamic_stack_slots: DynamicStackSlots

Dynamic stack slots allocated in this function.

global_values: PrimaryMap<GlobalValue, GlobalValueData>

Global values referenced.

tables: PrimaryMap<Table, TableData>

Tables referenced.

dfg: DataFlowGraph

Data flow graph containing the primary definition of all instructions, blocks and values.

layout: Layout

Layout of blocks and instructions in the function body.

srclocs: SecondaryMap<Inst, RelSourceLoc>

Source locations.

Track the original source location for each instruction. The source locations are not interpreted by Cranelift, only preserved.

stack_limit: Option<GlobalValue>

An optional global value which represents an expression evaluating to the stack limit for this function. This GlobalValue will be interpreted in the prologue, if necessary, to insert a stack check to ensure that a trap happens if the stack pointer goes below the threshold specified here.

Implementations

impl FunctionStencil

pub fn create_jump_table(&mut self, data: JumpTableData) -> JumpTable

Creates a jump table in the function, to be used by br_table instructions.

pub fn create_sized_stack_slot(&mut self, data: StackSlotData) -> StackSlot

Creates a sized stack slot in the function, to be used by stack_load, stack_store and stack_addr instructions.

pub fn create_dynamic_stack_slot( &mut self, data: DynamicStackSlotData ) -> DynamicStackSlot

Creates a dynamic stack slot in the function, to be used by dynamic_stack_load, dynamic_stack_store and dynamic_stack_addr instructions.

pub fn import_signature(&mut self, signature: Signature) -> SigRef

Adds a signature which can later be used to declare an external function import.

pub fn create_global_value(&mut self, data: GlobalValueData) -> GlobalValue

Declares a global value accessible to the function.

pub fn get_dyn_scale(&self, ty: DynamicType) -> GlobalValue

Find the global dyn_scale value associated with given DynamicType

pub fn get_dynamic_slot_scale(&self, dss: DynamicStackSlot) -> GlobalValue

Find the global dyn_scale for the given stack slot.

pub fn get_concrete_dynamic_ty(&self, ty: DynamicType) -> Option<Type>

Get a concrete Type from a user defined DynamicType.

pub fn create_table(&mut self, data: TableData) -> Table

Declares a table accessible to the function.

pub fn special_param(&self, purpose: ArgumentPurpose) -> Option<Value>

Find a presumed unique special-purpose function parameter value.

Returns the value of the last purpose parameter, or None if no such parameter exists.

pub fn collect_debug_info(&mut self)

Starts collection of debug information.

pub fn rewrite_branch_destination( &mut self, inst: Inst, old_dest: Block, new_dest: Block )

Rewrite the branch destination to new_dest if the destination matches old_dest. Does nothing if called with a non-jump or non-branch instruction.

pub fn is_block_basic(&self, block: Block) -> Result<(), (Inst, &'static str)>

Checks that the specified block can be encoded as a basic block.

On error, returns the first invalid instruction and an error message.

pub fn is_leaf(&self) -> bool

Returns true if the function is function that doesn’t call any other functions. This is not to be confused with a “leaf function” in Windows terminology.

pub fn transplant_inst(&mut self, dst: Inst, src: Inst)

Replace the dst instruction’s data with the src instruction’s data and then remove src.

src and its result values should not be used at all, as any uses would be left dangling after calling this method.

src and dst must have the same number of resulting values, and src’s i^th value must have the same type as dst’s i^th value.

pub fn fixed_stack_size(&self) -> u32

Size occupied by all stack slots associated with this function.

Does not include any padding necessary due to offsets

Trait Implementations

impl Clone for FunctionStencil

fn clone(&self) -> FunctionStencil

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Hash for FunctionStencil

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<FunctionStencil> for FunctionStencil

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