Method check_block

src/debug_utils/validate_func.rs:417–598

Check a basic block.

(&mut self, block: Block)

    /// Check a basic block.
    fn check_block(&mut self, block: Block) -> Result<()> {
        let insts = self.func.block_insts(block);
        self.check_inst_range(insts)?;

        // Block frequency must be positive. This also excludes zero and NaN.
        ensure!(
            self.func.block_frequency(block) > 0.0,
            "{block}: Frequency must be positive and non-zero"
        );

        // Instruction indicies must be ordered by block and with no gaps.
        if block.index() != 0 {
            let prev_block = Block::new(block.index() - 1);
            let prev_insts = self.func.block_insts(prev_block);
            ensure!(
                insts.from == prev_insts.to,
                "{block}: Instructions are not ordered by block"
            );
        } else {
            ensure!(
                insts.from.index() == 0,
                "{block}: Instructions are not ordered by block"
            );
        }
        if block.index() != self.func.num_blocks() - 1 {
            let next_block = Block::new(block.index() + 1);
            let next_insts = self.func.block_insts(next_block);
            ensure!(
                next_insts.from == insts.to,
                "{block}: Instructions are not ordered by block"
            );
        } else {
            ensure!(
                insts.to.index() == self.func.num_insts(),
                "{block}: Instructions are not ordered by block"
            );
        }

        // Check consistency of successors & predecessors.
        for &pred in self.func.block_preds(block) {
            self.check_entity(Entity::Block(pred))?;
            ensure!(
                self.func.block_succs(pred).contains(&block),
                "Inconsistent predecessors and successors between {pred} and {block}"
            );
        }
        for &succ in self.func.block_succs(block) {
            self.check_entity(Entity::Block(succ))?;
            ensure!(
                self.func.block_preds(succ).contains(&block),
                "Inconsistent predecessors and successors between {block} and {succ}"
            );
        }

        // Check for crtical edges. If we have more than one predecessors, those
        // must only have one successor (this block).
        if self.func.block_preds(block).len() > 1 {
            for &pred in self.func.block_preds(block) {