Function split_copy_memory

crates/rustc_codegen_spirv/src/linker/mem2reg.rs:308–357

Splits an OpCopyMemory into an OpLoad followed by an OpStore. This is because we want to be able to mem2reg variables used in OpCopyMemory, but analysis becomes very difficult: we only analyze one variable at a time, but OpCopyMemory can copy between two local variables (both of which are getting mem2reg'd), requiring cross-analysis shenanigans. So, if we know at least one side of the OpCopyMemory

(
    header: &mut ModuleHeader,
    blocks: &mut [Block],
    var_map: &FxHashMap<Word, VarInfo>,
)

// Finally, an edge case to keep in mind is that an OpCopyMemory can happen between two vars in the
// same var map (e.g. `s.x = s.y;`).
fn split_copy_memory(
    header: &mut ModuleHeader,
    blocks: &mut [Block],
    var_map: &FxHashMap<Word, VarInfo>,
) {
    for block in blocks {
        let mut inst_index = 0;
        while inst_index < block.instructions.len() {
            let inst = &block.instructions[inst_index];
            if inst.class.opcode == Op::CopyMemory {
                let target = inst.operands[0].id_ref_any().unwrap();
                let source = inst.operands[1].id_ref_any().unwrap();
                if inst.operands.len() > 2 {
                    // TODO: Copy the memory operands to the load/store
                    bug!("mem2reg OpCopyMemory doesn't support memory operands yet");
                }
                let ty = match (var_map.get(&target), var_map.get(&source)) {
                    (None, None) => {
                        inst_index += 1;
                        continue;
                    }
                    (Some(target), None) => target.ty,
                    (None, Some(source)) => source.ty,
                    (Some(target), Some(source)) => {
                        assert_eq!(target.ty, source.ty);
                        target.ty
                    }
                };
                let temp_id = id(header);
                block.instructions[inst_index] = Instruction::new(
                    Op::Load,
                    Some(ty),
                    Some(temp_id),
                    vec![Operand::IdRef(source)],
                );
                inst_index += 1;
                block.instructions.insert(
                    inst_index,
                    Instruction::new(
                        Op::Store,
                        None,
                        None,
                        vec![Operand::IdRef(target), Operand::IdRef(temp_id)],
                    ),
                );
            }
            inst_index += 1;
        }
    }
}

fn has_store(block: &Block, var_map: &FxHashMap<Word, VarInfo>) -> bool {
    block.instructions.iter().any(|inst| {