Function inline_small_or_no_lineno_blocks

crates/codegen/src/ir.rs:2570–2624

flowgraph.c inline_small_or_no_lineno_blocks

(blocks: &mut [Block])

/// flowgraph.c inline_small_or_no_lineno_blocks
fn inline_small_or_no_lineno_blocks(blocks: &mut [Block]) {
    const MAX_COPY_SIZE: usize = 4;

    let block_exits_scope = |block: &Block| {
        block
            .instructions
            .last()
            .is_some_and(|ins| ins.instr.is_scope_exit())
    };
    let block_has_no_lineno = |block: &Block| {
        block
            .instructions
            .iter()
            .all(|ins| !instruction_has_lineno(ins))
    };

    loop {
        let mut changes = false;
        let mut current = BlockIdx(0);
        while current != BlockIdx::NULL {
            let next = blocks[current.idx()].next;
            let Some(last) = blocks[current.idx()].instructions.last().copied() else {
                current = next;
                continue;
            };
            if !last.instr.is_unconditional_jump() || last.target == BlockIdx::NULL {
                current = next;
                continue;
            }

            let target = last.target;
            let small_exit_block = block_exits_scope(&blocks[target.idx()])
                && blocks[target.idx()].instructions.len() <= MAX_COPY_SIZE;
            let no_lineno_no_fallthrough = block_has_no_lineno(&blocks[target.idx()])
                && !block_has_fallthrough(&blocks[target.idx()]);

            if small_exit_block || no_lineno_no_fallthrough {
                if let Some(last_instr) = blocks[current.idx()].instructions.last_mut() {
                    last_instr.instr = Instruction::Nop.into();
                    last_instr.arg = OpArg::new(0);
                    last_instr.target = BlockIdx::NULL;
                }
                let appended = blocks[target.idx()].instructions.clone();
                blocks[current.idx()].instructions.extend(appended);
                changes = true;
            }

            current = next;
        }

        if !changes {
            break;
        }
    }
}

/// Follow chain of empty blocks to find first non-empty block.
fn next_nonempty_block(blocks: &[Block], mut idx: BlockIdx) -> BlockIdx {