Method add_indirect_remat

src/debug_utils/generic_function/arbitrary.rs:571–622

Adds an indirect rematerialization recipe for a value defined at the current program point.

(
        &mut self,
        value: Value,
        block: Block,
        is_first_inst: bool,
    )

    /// Adds an indirect rematerialization recipe for a value defined at
    /// the current program point.
    fn add_indirect_remat(
        &mut self,
        value: Value,
        block: Block,
        is_first_inst: bool,
    ) -> Result<()> {
        let saved_early_fixed = self.early_fixed;
        let saved_late_fixed = self.late_fixed;
        self.early_fixed.clear();
        self.late_fixed.clear();

        let allow_destination_overlap: bool = self.u.arbitrary()?;
        let bank = self.func.values[value].bank;
        let mut constraint = OperandConstraint::Class(self.reginfo.top_level_class(bank));
        if self.u.arbitrary()? {
            let reg = *self.u.choose(&self.reg_per_bank[bank])?;
            if self.check_fixed_conflict(reg, !allow_destination_overlap, true) {
                constraint = OperandConstraint::Fixed(reg);
            }
        }

        let input_count = self.u.int_in_range(self.config.uses_per_inst.clone())?;
        if input_count != 0 {
            let mut inputs = vec![];
            for _ in 0..input_count {
                let input_idx = inputs.len();
                let input = self.gen_use(block, is_first_inst, input_idx != 0, |this| {
                    let OperandConstraint::Class(class) = constraint else {
                        return Ok(None);
                    };
                    if this.u.arbitrary()? {
                        constraint = OperandConstraint::Reuse(input_idx);
                        Ok(Some(class))
                    } else {
                        Ok(None)
                    }
                })?;
                inputs.push(input);
            }

            self.func.values[value].indirect_remat = Some(IndirectRematData {
                constraint,
                inputs,
                allow_destination_overlap,
            });
        }

        self.early_fixed = saved_early_fixed;
        self.late_fixed = saved_late_fixed;

        Ok(())
    }

    /// Generates an operand which defines a value.
    fn gen_def(