Struct cranelift_codegen::flowgraph::BlockPredecessor

pub struct BlockPredecessor {
    pub block: Block,
    pub inst: Inst,
}

A basic block denoted by its enclosing Block and last instruction.

Fields

block: Block

Enclosing Block key.

inst: Inst

Last instruction in the basic block.

Implementations

impl BlockPredecessor

pub fn new(block: Block, inst: Inst) -> Self

Convenient method to construct new BlockPredecessor.

Examples found in repository

src/flowgraph.rs (line 205)

    fn next(&mut self) -> Option<BlockPredecessor> {
        self.0.next().map(|(i, e)| BlockPredecessor::new(e, i))
    }

src/dominator_tree.rs (lines 186-189)

    pub fn common_dominator(
        &self,
        mut a: BlockPredecessor,
        mut b: BlockPredecessor,
        layout: &Layout,
    ) -> BlockPredecessor {
        loop {
            match self.rpo_cmp_block(a.block, b.block) {
                Ordering::Less => {
                    // `a` comes before `b` in the RPO. Move `b` up.
                    let idom = self.nodes[b.block].idom.expect("Unreachable basic block?");
                    b = BlockPredecessor::new(
                        layout.inst_block(idom).expect("Dangling idom instruction"),
                        idom,
                    );
                }
                Ordering::Greater => {
                    // `b` comes before `a` in the RPO. Move `a` up.
                    let idom = self.nodes[a.block].idom.expect("Unreachable basic block?");
                    a = BlockPredecessor::new(
                        layout.inst_block(idom).expect("Dangling idom instruction"),
                        idom,
                    );
                }
                Ordering::Equal => break,
            }
        }

        debug_assert_eq!(
            a.block, b.block,
            "Unreachable block passed to common_dominator?"
        );

        // We're in the same block. The common dominator is the earlier instruction.
        if layout.cmp(a.inst, b.inst) == Ordering::Less {
            a
        } else {
            b
        }
    }

Trait Implementations

impl Debug for BlockPredecessor

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

Formats the value using the given formatter.

impl PartialEq<BlockPredecessor> for BlockPredecessor

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

impl StructuralEq for BlockPredecessor

impl StructuralPartialEq for BlockPredecessor