Function do_inlining

cranelift/codegen/src/inline.rs:112–256

Walk the given function, invoke the `Inline` implementation for each call instruction, and inline the callee when directed to do so. Returns whether any call was inlined.

(
    func: &mut ir::Function,
    mut inliner: impl Inline,
)

///
/// Returns whether any call was inlined.
pub(crate) fn do_inlining(
    func: &mut ir::Function,
    mut inliner: impl Inline,
) -> CodegenResult<bool> {
    trace!("function {} before inlining: {}", func.name, func);

    let mut inlined_any = false;
    let mut allocs = InliningAllocs::default();

    let mut cursor = FuncCursor::new(func);
    'block_loop: while let Some(block) = cursor.next_block() {
        // Always keep track of our previous cursor position. Assuming that the
        // current position is a function call that we will inline, then the
        // previous position is just before the inlined callee function. After
        // inlining a call, the Cranelift user can decide whether to consider
        // any function calls in the inlined callee for further inlining or
        // not. When they do, then we back up to this previous cursor position
        // so that our traversal will then continue over the inlined body.
        let mut prev_pos;

        while let Some(inst) = {
            prev_pos = cursor.position();
            cursor.next_inst()
        } {
            // Make sure that `block` is always `inst`'s block, even with all of
            // our cursor-position-updating and block-splitting-during-inlining
            // shenanigans below.
            debug_assert_eq!(Some(block), cursor.func.layout.inst_block(inst));

            match cursor.func.dfg.insts[inst] {
                ir::InstructionData::Call { func_ref, .. }
                    if cursor.func.dfg.ext_funcs[func_ref].patchable =>
                {
                    // Can't inline patchable calls; they need to
                    // remain patchable and inlining the whole body is
                    // decidedly *not* patchable!
                }

                ir::InstructionData::Call {
                    opcode: opcode @ ir::Opcode::Call | opcode @ ir::Opcode::ReturnCall,
                    args: _,
                    func_ref,
                } => {
                    trace!(
                        "considering call site for inlining: {inst}: {}",
                        cursor.func.dfg.display_inst(inst),
                    );
                    let args = cursor.func.dfg.inst_args(inst);
                    match inliner.inline(&cursor.func, inst, opcode, func_ref, args) {
                        InlineCommand::KeepCall => {
                            trace!("  --> keeping call");
                        }
                        InlineCommand::Inline {
                            callee,
                            visit_callee,
                        } => {
                            let last_inlined_block = inline_one(
                                &mut allocs,