Struct llhd::ir::FunctionLayout

pub struct FunctionLayout { /* fields omitted */ }

Determines the order of instructions and BBs in a Function or Process.

Methods

impl FunctionLayout

pub fn new() -> Self

Create a new function layout.

impl FunctionLayout

Basic block arrangement.

The following functions are used for laying out the basic blocks within a Function or Process.

pub fn append_block(&mut self, bb: Block)

Append a BB to the end of the function.

pub fn prepend_block(&mut self, bb: Block)

Prepend a BB to the beginning of a function.

This effectively makes bb the new entry block.

pub fn insert_block_after(&mut self, bb: Block, after: Block)

Insert a BB after another BB.

pub fn insert_block_before(&mut self, bb: Block, before: Block)

Insert a BB before another BB.

pub fn remove_block(&mut self, bb: Block)

Remove a BB from the function.

pub fn swap_blocks(&mut self, bb0: Block, bb1: Block)

Swap the position of two BBs.

pub fn blocks<'a>(&'a self) -> impl Iterator<Item = Block> + 'a

Return an iterator over all BBs in layout order.

pub fn first_block(&self) -> Option<Block>

Get the first BB in the layout. This is the entry block.

pub fn last_block(&self) -> Option<Block>

Get the last BB in the layout.

pub fn prev_block(&self, bb: Block) -> Option<Block>

Get the BB preceding bb in the layout.

pub fn next_block(&self, bb: Block) -> Option<Block>

Get the BB following bb in the layout.

pub fn entry(&self) -> Block

Get the entry block in the layout.

The fallible alternative is first_block(bb).

impl FunctionLayout

Instruction arrangement.

The following functions are used for laying out the instructions within a Function or Process.

pub fn inst_block(&self, inst: Inst) -> Option<Block>

Get the BB which contains inst, or None if inst is not inserted.

pub fn append_inst(&mut self, inst: Inst, bb: Block)

Append an instruction to the end of a BB.

pub fn prepend_inst(&mut self, inst: Inst, bb: Block)

Prepend an instruction to the beginning of a BB.

pub fn insert_inst_after(&mut self, inst: Inst, after: Inst)

Insert an instruction after another instruction.

pub fn insert_inst_before(&mut self, inst: Inst, before: Inst)

Insert an instruction before another instruction.

pub fn remove_inst(&mut self, inst: Inst)

Remove an instruction from the function.

pub fn insts<'a>(&'a self, bb: Block) -> impl Iterator<Item = Inst> + 'a

Return an iterator over all instructions in a block in layout order.

pub fn first_inst(&self, bb: Block) -> Option<Inst>

Get the first instruction in the layout.

pub fn last_inst(&self, bb: Block) -> Option<Inst>

Get the last instruction in the layout.

pub fn prev_inst(&self, inst: Inst) -> Option<Inst>

Get the instruction preceding inst in the layout.

pub fn next_inst(&self, inst: Inst) -> Option<Inst>

Get the instruction following inst in the layout.

pub fn terminator(&self, bb: Block) -> Inst

Get the terminator instruction in the layout.

The fallible alternative is last_inst(bb).

Trait Implementations

impl Default for FunctionLayout

fn default() -> FunctionLayout

Returns the "default value" for a type.

impl<'de> Deserialize<'de> for FunctionLayout

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

Deserialize this value from the given Serde deserializer.

impl Layout for FunctionLayout

fn is_inst_inserted(&self, inst: Inst) -> bool

Check if an instruction is inserted.

fn is_block_inserted(&self, bb: Block) -> bool

Check if a block is inserted.

impl Serialize for FunctionLayout

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

Serialize this value into the given Serde serializer.