Struct sway_ir::block::Block

pub struct Block(pub Index);

A wrapper around an ECS handle into the Context.

Tuple Fields

0: Index

Implementations

impl Block

pub fn new( context: &mut Context, function: Function, label: Option<String> ) -> Block

Return a new block handle.

Creates a new Block belonging to function in the context and returns its handle. label is optional and is used only when printing the IR.

pub fn get_function(&self, context: &Context) -> Function

Get the parent function for this block.

pub fn ins<'a>(&self, context: &'a mut Context) -> InstructionInserter<'a>

Create a new InstructionIterator to more easily append instructions to this block.

pub fn get_label(&self, context: &Context) -> String

Get the label of this block. If it wasn’t given one upon creation it will be a generated label.

pub fn num_instructions(&self, context: &Context) -> usize

Get the number of instructions in this block

pub fn get_arg(&self, context: &Context, index: usize) -> Option<Value>

Get the i’th block arg.

pub fn num_predecessors(&self, context: &Context) -> usize

Get the number of predecessor blocks, i.e., blocks which branch to this one.

pub fn new_arg(&self, context: &mut Context, ty: Type, by_ref: bool) -> usize

Add a new block argument of type ty. Returns its index.

pub fn add_arg(&self, context: &mut Context, arg: Value)

Add a block argument, asserts that arg is suitable here.

pub fn arg_iter<'a>( &'a self, context: &'a Context ) -> impl Iterator<Item = &Value>

Get an iterator over this block’s args.

pub fn num_args(&self, context: &Context) -> usize

How many args does this block have?

pub fn pred_iter<'a>( &'a self, context: &'a Context ) -> impl Iterator<Item = &Block>

Get an iterator over this block’s predecessor blocks.

pub fn add_pred(&self, context: &mut Context, from_block: &Block)

Add from_block to the set of predecessors of this block.

pub fn remove_pred(&self, context: &mut Context, from_block: &Block)

Remove from_block from the set of predecessors of this block.

pub fn replace_pred( &self, context: &mut Context, old_source: &Block, new_source: &Block )

Replace a old_source with new_source as a predecessor.

pub fn get_terminator<'a>(&self, context: &'a Context) -> Option<&'a Instruction>

Get a reference to the block terminator.

Returns None if block is empty.

pub fn get_terminator_mut<'a>( &self, context: &'a mut Context ) -> Option<&'a mut Instruction>

Get a mut reference to the block terminator.

Returns None if block is empty.

pub fn get_succ_params(&self, context: &Context, succ: &Block) -> Vec<Value>

For a particular successor (if it indeed is one), get the arguments passed.

pub fn get_succ_params_mut<'a>( &'a self, context: &'a mut Context, succ: &Block ) -> Option<&'a mut Vec<Value>>

For a particular successor (if it indeed is one), get a mut ref to parameters passed.

pub fn is_terminated(&self, context: &Context) -> bool

Return whether this block is already terminated. Checks if the final instruction, if it exists, is a terminator.

pub fn is_terminated_by_ret_or_revert(&self, context: &Context) -> bool

Return whether this block is already terminated specifically by a Ret instruction.

pub fn replace_values( &self, context: &mut Context, replace_map: &FxHashMap<Value, Value> )

Replace a value within this block.

For every instruction within the block, any reference to old_val is replaced with new_val.

pub fn remove_instruction(&self, context: &mut Context, instr_val: Value)

Remove an instruction from this block.

NOTE: We must be very careful! We mustn’t remove the phi or the terminator. Some extra checks should probably be performed here to avoid corruption! Ideally we use get a user/uses system implemented. Using Vec::remove() is also O(n) which we may want to avoid someday.

pub fn replace_instruction( &self, context: &mut Context, old_instr_val: Value, new_instr_val: Value ) -> Result<(), IrError>

Replace an instruction in this block with another. Will return a ValueNotFound on error. Any use of the old instruction value will also be replaced by the new value throughout the owning function.

pub fn split_at(&self, context: &mut Context, split_idx: usize) -> (Block, Block)

Split the block into two.

This will create a new block and move the instructions at and following split_idx to it. Returns both blocks.

pub fn instruction_iter(&self, context: &Context) -> InstructionIterator

Return an instruction iterator for each instruction in this block.

Trait Implementations

impl Clone for Block

fn clone(&self) -> Block

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Block

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

Formats the value using the given formatter.

impl DebugWithContext for Block

fn fmt_with_context<'a, 'c>( &'a self, formatter: &mut Formatter<'_>, context: &'c Context ) -> Result

fn with_context<'a, 'c>( &'a self, context: &'c Context ) -> WithContext<'a, 'c, Self>

impl Hash for Block

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

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

impl Eq for Block

impl StructuralEq for Block

impl StructuralPartialEq for Block