Method new

cranelift/codegen/src/machinst/blockorder.rs:148–311

Compute and return a lowered block order for `f`.

(
        f: &Function,
        domtree: &DominatorTree,
        ctrl_plane: &mut ControlPlane,
    )

impl BlockLoweringOrder {
    /// Compute and return a lowered block order for `f`.
    pub fn new(
        f: &Function,
        domtree: &DominatorTree,
        ctrl_plane: &mut ControlPlane,
    ) -> BlockLoweringOrder {
        trace!("BlockLoweringOrder: function body {:?}", f);

        // Step 1: compute the in-edge and out-edge count of every block.
        let mut block_in_count = SecondaryMap::with_default(0);
        let mut block_out_count = SecondaryMap::with_default(0);

        // Block successors are stored as `LoweredBlocks` to simplify the construction of
        // `lowered_succs` in the final result. Initially, all entries are `Orig` values, and are
        // updated to be `CriticalEdge` when those cases are identified in step 2 below.
        let mut block_succs: SmallVec<[LoweredBlock; 128]> = SmallVec::new();
        let mut block_succ_range = SecondaryMap::with_default(0..0);

        let mut indirect_branch_target_clif_blocks = FxHashSet::default();

        for block in f.layout.blocks() {
            let start = block_succs.len();
            visit_block_succs(f, block, |_, succ, from_table| {
                block_out_count[block] += 1;
                block_in_count[succ] += 1;
                block_succs.push(LoweredBlock::Orig { block: succ });

                if from_table {
                    indirect_branch_target_clif_blocks.insert(succ);
                }
            });

            // Ensure that blocks terminated by br_table instructions
            // with an empty jump table are still treated like
            // conditional blocks from the point of view of critical
            // edge splitting. Also do the same for TryCall and
            // TryCallIndirect: we cannot have edge moves before the
            // branch, even if they have empty handler tables and thus
            // would otherwise have only one successor.
            if let Some(inst) = f.layout.last_inst(block) {
                match f.dfg.insts[inst].opcode() {
                    Opcode::BrTable | Opcode::TryCall | Opcode::TryCallIndirect => {
                        block_out_count[block] = block_out_count[block].max(2);
                    }
                    _ => {}
                }
            }

            let end = block_succs.len();
            block_succ_range[block] = start..end;
        }

        // Step 2: walk the postorder from the domtree in reverse to produce our desired node
        // lowering order, identifying critical edges to split along the way.

        let mut lowered_order = Vec::new();
        let mut blockindex_by_block = SecondaryMap::with_default(BlockIndex::invalid());
        for &block in domtree.cfg_rpo() {
            let idx = BlockIndex::new(lowered_order.len());