Struct FunctionBody

pub struct FunctionBody {
    pub n_params: usize,
    pub rets: Vec<Type>,
    pub locals: EntityVec<Local, Type>,
    pub entry: Block,
    pub blocks: EntityVec<Block, BlockDef>,
    pub values: EntityVec<Value, ValueDef>,
    pub type_pool: ListPool<Type>,
    pub single_type_dedup: FxHashMap<Type, ListRef<Type>>,
    pub arg_pool: ListPool<Value>,
    pub value_blocks: PerEntity<Value, Block>,
    pub value_locals: PerEntity<Value, Option<Local>>,
    pub source_locs: PerEntity<Value, SourceLoc>,
}

The body of a function, as an SSA-based intermediate representation.

Fields

n_params: usize

How many parameters the function has. (Their types are the first n_params values in locals.)

rets: Vec<Type>

Return types of the function.

locals: EntityVec<Local, Type>

Local types, including args.

entry: Block

Entry block.

blocks: EntityVec<Block, BlockDef>

Block bodies.

values: EntityVec<Value, ValueDef>

Value definitions, indexed by Value.

type_pool: ListPool<Type>

Pool of types for ValueDefs’ result type lists.

single_type_dedup: FxHashMap<Type, ListRef<Type>>

Deduplication for type-lists of single types.

arg_pool: ListPool<Value>

Pool of values for ValueDefs’ arg lists.

value_blocks: PerEntity<Value, Block>

Blocks in which values are computed. Each may be Block::invalid() if not placed.

value_locals: PerEntity<Value, Option<Local>>

Wasm locals that values correspond to, if any.

source_locs: PerEntity<Value, SourceLoc>

Debug source locations of each value.

Implementations

impl FunctionBody

pub fn new(module: &Module<'_>, sig: Signature) -> FunctionBody

Create a new function body with the given signature. The body will have an entry block with blockparams defined that match the function parameters in the signature, but no contents. module is necessary to look up the signature.

pub fn optimize(&mut self, opts: &OptOptions)

Optimize this function given the options in opts.

pub fn convert_to_max_ssa(&mut self, cut_blocks: Option<HashSet<Block>>)

Perform a maximal-SSA transform on this function. See comments on FuncDecl::convert_to_max_ssa() for more.

pub fn add_block(&mut self) -> Block

Add a new, empty block and return its ID.

pub fn single_type_list(&mut self, ty: Type) -> ListRef<Type>

Convenience: intern a single type as a result-type-list. Caches and deduplicates to minimize type-pool growth.

pub fn add_edge(&mut self, from: Block, to: Block)

Add an edge in the succs/preds lists of the respective blocks. These edges must exist once a function has been built; they can be (re)computed in bulk with FunctionBody::recompute_edges() if necessary.

pub fn split_edge(&mut self, from: Block, to: Block, succ_idx: usize) -> Block

Split a given edge (disambiguated with succ_idx since there may be multiple edges from from to to), creating an intermediate block with an unconditional branch and carrying through all blockparams.

pub fn recompute_edges(&mut self)

Recompute all successor/predecessor lists according to the edges implied by terminator instructions. Must be updated after building a function body or mutating its CFG and prior to analyses.

pub fn add_value(&mut self, value: ValueDef) -> Value

Add a new value node to the function (not yet in any block) and return its SSA value number.

pub fn add_op( &mut self, block: Block, op: Operator, args: &[Value], tys: &[Type], ) -> Value

Convenience method: add an operator value to the function in the given block. Creates the argument and type list(s), adds the value node, and appends the value node to the given block.

pub fn set_alias(&mut self, value: Value, to: Value)

Make one value an alias to another. Panics on cycles.

pub fn resolve_alias(&self, value: Value) -> Value

Resolve the value through any alias references to the original value.

pub fn resolve_and_update_alias(&mut self, value: Value) -> Value

Resolve a value through alias references, updating the value definition to short-circuit the (arbitrarily long) alias chain afterward.

pub fn add_blockparam(&mut self, block: Block, ty: Type) -> Value

Add a new blockparam to the given block, returning its SSA value number.

pub fn add_placeholder(&mut self, ty: Type) -> Value

Add a new Placeholder value that can be replaced with an actual definition later. Useful in some algorithms that follow or resolve cycles.

pub fn replace_placeholder_with_blockparam( &mut self, block: Block, value: Value, )

Convert a Placeholder value into a blockparam on the given block.

pub fn mark_value_as_local(&mut self, value: Value, local: Local)

Mark an SSA value as carrying the Wasm local local. This is useful for debugging and manually reading the IR.

pub fn append_to_block(&mut self, block: Block, value: Value)

Append a value to the instruction list in a block.

pub fn set_terminator(&mut self, block: Block, terminator: Terminator)

Set the terminator instruction on a block, updating the edge lists as well.

pub fn display<'a>( &'a self, indent: &'a str, module: Option<&'a Module<'_>>, ) -> FunctionBodyDisplay<'a>

Prety-print this function body. indent is prepended to each line of output. module, if provided, allows printing source locations as comments at each operator.

pub fn display_verbose<'a>( &'a self, indent: &'a str, module: Option<&'a Module<'_>>, ) -> FunctionBodyDisplay<'a>

Pretty-print this function body, with “verbose” format: includes all value nodes, even those not listed in a block’s instruction list. (Roughly doubles output size.)

pub fn validate(&self) -> Result<()>

Validate consistency of the IR against required invariants and properties:

• Block successor and predecessor lists are accurate with respect to terminator instructions.
• SSA is valid: values are used in locations dominated by their uses.

pub fn verify_reducible(&self) -> Result<()>

Verify that the CFG of this function is reducible. (This is not necessary to produce Wasm, as the backend can turn irreducible control flow into reducible control flow via the Reducifier. However, it is a useful property in other situations, so one may want to test for or verify it.)

pub fn compile(&self) -> Result<Function>

Compile this function to Wasm bytecode. See Module::to_wasm_bytes() for the Wasm-level compilation entry point. This is mostly useful for custom per-function compilation flows, e.g. per-function caching.

Trait Implementations

impl Block<FunctionBody> for BlockDef

type Terminator = Terminator

fn term(&self) -> &Self::Terminator

fn term_mut(&mut self) -> &mut Self::Terminator

impl Block<FunctionBody> for BlockDef

fn insts(&self) -> impl Iterator<Item = <FunctionBody as Func>::Value>

fn add_inst( func: &mut FunctionBody, key: <FunctionBody as Func>::Block, v: <FunctionBody as Func>::Value, )

impl Clone for FunctionBody

fn clone(&self) -> FunctionBody

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for FunctionBody

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

Formats the value using the given formatter.

impl Default for FunctionBody

fn default() -> FunctionBody

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FunctionBody

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Func for FunctionBody

type Block = Block

type Blocks = EntityVec<Block, BlockDef>

fn blocks(&self) -> &Self::Blocks

fn blocks_mut(&mut self) -> &mut Self::Blocks

fn entry(&self) -> Self::Block

impl Func for FunctionBody

type Value = Value

type Values = EntityVec<Value, ValueDef>

fn values(&self) -> &Self::Values

fn values_mut(&mut self) -> &mut Self::Values

impl HasValues<FunctionBody> for BlockTarget

fn values<'a>( &'a self, f: &'a FunctionBody, ) -> Box<dyn Iterator<Item = <FunctionBody as Func>::Value> + 'a>

fn values_mut<'a>( &'a mut self, g: &'a mut FunctionBody, ) -> Box<dyn Iterator<Item = &'a mut Value> + 'a>

where FunctionBody: 'a,

impl HasValues<FunctionBody> for ListRef<Value>

fn values<'a>( &'a self, f: &'a FunctionBody, ) -> Box<dyn Iterator<Item = <FunctionBody as Func>::Value> + 'a>

fn values_mut<'a>( &'a mut self, g: &'a mut FunctionBody, ) -> Box<dyn Iterator<Item = &'a mut <FunctionBody as Func>::Value> + 'a>

where FunctionBody: 'a,

impl HasValues<FunctionBody> for Terminator

fn values<'a>( &'a self, f: &'a FunctionBody, ) -> Box<dyn Iterator<Item = <FunctionBody as Func>::Value> + 'a>

fn values_mut<'a>( &'a mut self, g: &'a mut FunctionBody, ) -> Box<dyn Iterator<Item = &'a mut Value> + 'a>

where FunctionBody: 'a,

impl HasValues<FunctionBody> for ValueDef

fn values<'a>( &'a self, f: &'a FunctionBody, ) -> Box<dyn Iterator<Item = <FunctionBody as Func>::Value> + 'a>

fn values_mut<'a>( &'a mut self, g: &'a mut FunctionBody, ) -> Box<dyn Iterator<Item = &'a mut <FunctionBody as Func>::Value> + 'a>

where FunctionBody: 'a,

impl OpValue<FunctionBody, Operator> for ValueDef

type Residue = ValueDef

type Capture = ListRef<Value>

type Spit = Vec<Type>

fn disasm( self, f: &mut FunctionBody, ) -> Result<(Operator, Self::Capture, Self::Spit), Self::Residue>

fn of( f: &mut FunctionBody, o: Operator, c: Self::Capture, s: Self::Spit, ) -> Option<Self>

fn lift(f: &mut FunctionBody, r: Self::Residue) -> Option<Self>

impl OpValue<FunctionBody, u32> for ValueDef

type Residue = ValueDef

type Capture = Val<FunctionBody>

type Spit = Type

fn disasm( self, f: &mut FunctionBody, ) -> Result<(u32, Self::Capture, Self::Spit), Self::Residue>

fn of( f: &mut FunctionBody, o: u32, c: Self::Capture, s: Self::Spit, ) -> Option<Self>

fn lift(f: &mut FunctionBody, r: Self::Residue) -> Option<Self>

impl Serialize for FunctionBody

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Target<FunctionBody> for BlockTarget

fn block(&self) -> <FunctionBody as Func>::Block

fn block_mut(&mut self) -> &mut <FunctionBody as Func>::Block

impl Target<FunctionBody> for BlockTarget

fn push_value(&mut self, v: <FunctionBody as Func>::Value)

fn from_values_and_block( a: impl Iterator<Item = <FunctionBody as Func>::Value>, k: <FunctionBody as Func>::Block, ) -> Self

impl Term<FunctionBody> for BlockTarget

type Target = BlockTarget

fn targets<'a>(&'a self) -> Box<dyn Iterator<Item = &'a BlockTarget> + 'a>

where FunctionBody: 'a,

fn targets_mut<'a>( &'a mut self, ) -> Box<dyn Iterator<Item = &'a mut BlockTarget> + 'a>

where FunctionBody: 'a,

impl Term<FunctionBody> for Terminator

type Target = BlockTarget

fn targets<'a>(&'a self) -> Box<dyn Iterator<Item = &'a BlockTarget> + 'a>

where FunctionBody: 'a,

fn targets_mut<'a>( &'a mut self, ) -> Box<dyn Iterator<Item = &'a mut BlockTarget> + 'a>

where FunctionBody: 'a,

impl Value<FunctionBody> for ValueDef