Struct Block 

pub struct Block { /* private fields */ }

Represents a basic block in the IR.

Basic blocks are used in SSA regions to provide the structure of the control-flow graph. Operations within a basic block appear in the order they will be executed.

A block must have a traits::Terminator, an operation which transfers control to another block in the same region, or out of the containing operation (e.g. returning from a function).

Blocks have predecessors and successors, representing the inbound and outbound edges (respectively) formed by operations that transfer control between blocks. A block can have zero or more predecessors and/or successors. A well-formed region will generally only have a single block (the entry block) with no predecessors (i.e. no unreachable blocks), and no blocks with both multiple predecessors and multiple successors (i.e. no critical edges). It is valid to have both unreachable blocks and critical edges in the IR, but they must be removed during the course of compilation.

Implementations

impl Block

pub fn print(&self, flags: &OpPrintingFlags) -> Document

impl Block

pub fn new(id: BlockId) -> Self

pub fn as_block_ref(&self) -> BlockRef

pub fn parent(&self) -> Option<RegionRef>

Get a handle to the containing Region of this block, if it is attached to one

pub fn parent_op(&self) -> Option<OperationRef>

Get a handle to the containing Operation of this block, if it is attached to one

pub fn parent_block(&self) -> Option<BlockRef>

Get a handle to the ancestor Block of this block, if one is present

pub fn is_entry_block(&self) -> bool

Returns true if this block is the entry block for its containing region

pub fn front(&self) -> Option<OperationRef>

Get the first operation in the body of this block

pub fn back(&self) -> Option<OperationRef>

Get the last operation in the body of this block

pub fn body(&self) -> &OpList

Get the list of Operation comprising the body of this block

pub fn body_mut(&mut self) -> &mut OpList

Get a mutable reference to the list of Operation comprising the body of this block

impl Block

Arguments

pub fn has_arguments(&self) -> bool

pub fn num_arguments(&self) -> usize

pub fn arguments(&self) -> &[BlockArgumentRef]

pub fn arguments_mut(&mut self) -> &mut Vec<BlockArgumentRef>

pub fn argument_values(&self) -> impl ExactSizeIterator<Item = ValueRef> + '_

pub fn argument_types(&self) -> impl ExactSizeIterator<Item = Type> + '_

pub fn get_argument(&self, index: usize) -> BlockArgumentRef

pub fn erase_argument(&mut self, index: usize)

Erase the block argument at index

Panics if the argument still has uses.

pub fn erase_arguments<F>(&mut self, should_erase: F)

where F: Fn(&BlockArgument) -> bool,

Erase every parameter of this block for which should_erase returns true.

Panics if any argument to be erased still has uses.

pub fn erase(&mut self)

impl Block

Placement

pub fn insert_after(&mut self, after: BlockRef)

Insert this block after after in its containing region.

Panics if this block is already attached to a region, or if after is not attached.

pub fn insert_before(&mut self, before: BlockRef)

Insert this block before before in its containing region.

Panics if this block is already attached to a region, or if before is not attached.

pub fn insert_at_end(&mut self, region: RegionRef)

Insert this block at the end of region.

Panics if this block is already attached to a region.

pub fn move_before(&mut self, before: BlockRef)

Unlink this block from its current region and insert it right before before

pub fn splice_block(&mut self, block: &mut Self)

Splice the body of block to the end of self, updating the parent of all spliced ops.

It is up to the caller to ensure that this operation produces valid IR.

pub fn splice_block_before(&mut self, block: &mut Self, ip: OperationRef)

Splice the body of block to self before ip, updating the parent of all spliced ops.

It is up to the caller to ensure that this operation produces valid IR.

pub fn splice_block_after(&mut self, block: &mut Self, ip: OperationRef)

Splice the body of block to self after ip, updating the parent of all spliced ops.

It is up to the caller to ensure that this operation produces valid IR.

pub fn split_block(&mut self, before: OperationRef) -> BlockRef

Split this block into two blocks before the specified operation

Note that all operations in the block prior to before stay as part of the original block, and the rest are moved to the new block, including the old terminator. The original block is thus left without a terminator.

Returns the newly created block.

pub fn clear(&mut self)

impl Block

Ancestors

pub fn is_legal_to_hoist_into(&self) -> bool

pub fn has_ssa_dominance(&self) -> bool

pub fn traverse_ancestors<F>(block: BlockRef, f: F) -> Option<BlockRef>

where F: FnMut(BlockRef) -> bool,

Walk up the ancestor blocks of block, until f returns true for a block.

NOTE: block is visited before any of its ancestors.

pub fn get_blocks_in_same_region( a: BlockRef, b: BlockRef, ) -> Option<(BlockRef, BlockRef)>

Try to get a pair of blocks, starting with the given pair, which live in the same region, by exploring the relationships of both blocks with respect to their regions.

The returned block pair will either be the same input blocks, or some combination of those blocks or their ancestors.

impl Block

Predecessors and Successors

pub fn has_predecessors(&self) -> bool

Returns true if this block has predecessors

pub fn predecessors(&self) -> EntityIter<'_, BlockOperand>

Get an iterator over the predecessors of this block

pub fn get_single_predecessor(&self) -> Option<BlockRef>

If this block has exactly one predecessor, return it, otherwise None

NOTE: A predecessor block with multiple edges, e.g. a conditional branch that has this block as the destination for both true/false branches is not considered a single predecessor by this function.

pub fn get_unique_predecessor(&self) -> Option<BlockRef>

If this block has a unique predecessor, i.e. all incoming edges originate from one block, return it, otherwise None

pub fn has_successors(&self) -> bool

Returns true if this block has any successors

pub fn num_successors(&self) -> usize

Get the number of successors of this block in the CFG

pub fn get_successor(&self, index: usize) -> BlockRef

Get the indexth successor of this block’s terminator operation

pub fn drop_all_references(&mut self)

This drops all operand uses from operations within this block, which is an essential step in breaking cyclic dependences between references when they are to be deleted.

pub fn drop_all_defined_value_uses(&mut self)

This drops all uses of values defined in this block or in the blocks of nested regions wherever the uses are located.

pub fn drop_all_uses(&mut self)

Drop all uses of this block via BlockOperand

pub fn replace_all_uses_with(&mut self, replacement: BlockRef)

pub fn terminator(&self) -> Option<OperationRef>

Get the terminator operation of this block, or None if the block does not have one.

pub fn has_terminator(&self) -> bool

Returns true if this block has a terminator

Trait Implementations

impl Debug for Block

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

Formats the value using the given formatter.

impl Display for Block

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

Formats the value using the given formatter.

impl Dominates for Block

The dominance relationship between two blocks.

fn dominates(&self, other: &Self, dom_info: &DominanceInfo) -> bool

Returns true if a == b or a properly dominates b.

fn properly_dominates(&self, other: &Self, dom_info: &DominanceInfo) -> bool

Returns true if a != b and:

• a is an ancestor of b
• The region containing a also contains b or some ancestor of b, and a dominates that block in that kind of region.
• In SSA regions, a properly dominates b if all control flow paths from the entry block to b, flow through a.
• In graph regions, all blocks dominate all other blocks.

impl EntityListItem for Block

fn on_inserted( this: UnsafeIntrusiveEntityRef<Self>, cursor: &mut EntityCursorMut<'_, Self>, )

Invoked when this entity type is inserted into an intrusive list

fn on_removed( this: UnsafeIntrusiveEntityRef<Self>, list: &mut EntityCursorMut<'_, Self>, )

Invoked when this entity type is removed from an intrusive list

fn on_transfer( this: UnsafeIntrusiveEntityRef<Self>, from: &mut EntityList<Self>, to: &mut EntityList<Self>, )

Invoked when a set of entities is moved from one intrusive list to another

impl EntityParent<Block> for Region

fn offset() -> usize

Statically compute the offset of the EntityList within Self that is used to store children of type Child.

impl EntityParent<BlockOperand> for Block

fn offset() -> usize

Statically compute the offset of the EntityList within Self that is used to store children of type Child.

impl EntityParent<Operation> for Block

fn offset() -> usize

Statically compute the offset of the EntityList within Self that is used to store children of type Child.

impl EntityWithId for Block

type Id = BlockId

fn id(&self) -> Self::Id

impl EntityWithParent for Block

type Parent = Region

The parent entity that this entity logically belongs to.

impl From<&Block> for ProgramPoint

Construct a ProgramPoint referring to the point at entry to block

fn from(block: &Block) -> Self

Converts to this type from the input type.

impl Graph for Block

type ChildEdgeIter = BlockSuccessorEdgesIter

Type used to iterate over child edges of a node in the graph.

type ChildIter = BlockSuccessorIter

Type used to iterate over children of a node in the graph.

type Edge = RawEntityRef<BlockOperand, IntrusiveLink>

The type used to represent an edge in the graph.

type Node = RawEntityRef<Block, IntrusiveLink>

The type of node represented in the graph.

fn size(&self) -> usize

Get the number of nodes in this graph

fn entry_node(&self) -> Self::Node

Get the entry node of the graph.

fn children(parent: Self::Node) -> Self::ChildIter

Get an iterator over the children of parent

fn children_edges(parent: Self::Node) -> Self::ChildEdgeIter

Get an iterator over the children edges of parent

fn edge_dest(edge: Self::Edge) -> Self::Node

Return the destination node of an edge.

fn is_empty(&self) -> bool

An empty graph has no nodes.

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<'a> InvertibleGraph for &'a Block

type Inverse = Inverse<&'a Block>

The type of this graph’s inversion

type InvertibleChildEdgeIter = BlockPredecessorEdgesIter

The type of iterator used to obtain the set of “inverted” children edges of a node in this graph, i.e. the predecessor edges.

type InvertibleChildIter = BlockPredecessorIter

The type of iterator used to visit “inverted” children of a node in this graph, i.e. the predecessors.

fn inverse(self) -> Self::Inverse

Obtain the inversion of this graph

fn inverse_children(parent: Self::Node) -> Self::InvertibleChildIter

Get an iterator over the predecessors of parent.

fn inverse_children_edges(parent: Self::Node) -> Self::InvertibleChildEdgeIter

Get an iterator over the predecessor edges of parent.

impl PartialEq for Block

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PostDominates for Block

The post-dominance relationship between two blocks.

fn properly_post_dominates( &self, other: &Self, dom_info: &PostDominanceInfo, ) -> bool

Returns true if a != b and:

• a is an ancestor of b
• The region containing a also contains b or some ancestor of b, and a dominates that block in that kind of region.
• In SSA regions, a properly post-dominates b if all control flow paths from b to an exit node, flow through a.
• In graph regions, all blocks post-dominate all other blocks.

fn post_dominates(&self, other: &Self, dom_info: &PostDominanceInfo) -> bool

Returns true if self post-dominates other.

impl PrettyPrint for Block

fn render(&self) -> Document

The core of the PrettyPrint functionality.

fn to_pretty_string(&self) -> String

Produce a String containing the results of pretty-printing this object.

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

Pretty-print this object to the given core::fmt::Formatter.

impl Spanned for Block

fn span(&self) -> SourceSpan

impl Usable for Block

type Use = BlockOperand

The type associated with each unique use, e.g. OpOperand

fn uses(&self) -> &EntityList<BlockOperand>

Get a list of uses of this definition

fn uses_mut(&mut self) -> &mut EntityList<BlockOperand>

Get a mutable list of uses of this definition

fn is_used(&self) -> bool

Returns true if this definition is used

fn iter_uses(&self) -> EntityIter<'_, Self::Use>

Get an iterator over the uses of this definition

fn first_use(&self) -> EntityCursor<'_, Self::Use>

Get a cursor positioned on the first use of this definition, or the null cursor if unused.

fn first_use_mut(&mut self) -> EntityCursorMut<'_, Self::Use>

Get a mutable cursor positioned on the first use of this definition, or the null cursor if unused.

fn insert_use(&mut self, user: UnsafeIntrusiveEntityRef<Self::Use>)

Add user to the set of uses of this definition

impl Entity for Block

impl Eq for Block