Method gen_block_start_defs

src/debug_utils/generic_function/arbitrary.rs:697–739

Generates instructions containing the remaining defs in a block after other instructions have been emitted.

(&mut self, block: Block)

    /// Generates instructions containing the remaining defs in a block after
    /// other instructions have been emitted.
    fn gen_block_start_defs(&mut self, block: Block) -> Result<()> {
        // We may need to emit multiple instructions due to MAX_INST_OPERANDS.
        while !self.defs_by_blocks[block].is_empty() {
            self.early_fixed.clear();
            self.late_fixed.clear();
            self.reuse_operands.clear();

            let mut inst = InstData {
                operands: vec![],
                clobbers: vec![],
                block,
                terminator_kind: None,
                is_pure: self.u.arbitrary()?,
            };

            let mut defined_values = vec![];
            while inst.operands.len() < MAX_INST_OPERANDS {
                let Some(value) = self.defs_by_blocks[block].pop() else {
                    break;
                };
                let op = self.gen_def(
                    block,
                    value,
                    false,
                    inst.operands.len(),
                    &mut defined_values,
                )?;
                inst.operands.push(op);
            }

            if self.domtree.immediate_dominator(block).is_some() {
                for value in defined_values {
                    if !self.u.arbitrary()? {
                        self.add_indirect_remat(value, block, true)?;
                    }
                }
            }

            self.block_insts[block].push(inst);
        }

        Ok(())
    }

    /// Generates a single instruction in the given block.
    fn gen_inst(&mut self, block: Block, is_first_inst: bool, is_ret: bool) -> Result<InstData> {