Method gen_def

src/debug_utils/generic_function/arbitrary.rs:625–693

Generates an operand which defines a value.

(
        &mut self,
        block: Block,
        value: Value,
        is_ret: bool,
        op_idx: usize,
        defined_values: &mut Vec<Value>,
    )

    /// Generates an operand which defines a value.
    fn gen_def(
        &mut self,
        block: Block,
        value: Value,
        is_ret: bool,
        op_idx: usize,
        defined_values: &mut Vec<Value>,
    ) -> Result<Operand> {
        let bank = self.func.values[value].bank;

        // Try to use a fixed register.
        if self.u.arbitrary()? {
            let reg = *self.u.choose(&self.reg_per_bank[bank])?;
            let kind = if !is_ret && self.u.arbitrary()? {
                OperandKind::Def(value)
            } else {
                OperandKind::EarlyDef(value)
            };
            if self.check_fixed_conflict(reg, matches!(kind, OperandKind::EarlyDef(_)), true) {
                defined_values.push(value);
                return Ok(Operand::new(kind, OperandConstraint::Fixed(reg)));
            }
        }

        // Pick a register class to use.
        let class = *self.u.choose(&self.class_per_bank[bank])?;
        let group_size = self.reginfo.class_group_size(class);
        let kind = if group_size > 1 {
            let mut values = vec![value];
            for _ in 1..group_size {
                // Try to find another definition from the definition list in
                // the current block.
                let value = if !self.defs_by_blocks[block].is_empty() && self.u.arbitrary()? {
                    let value_idx = self.u.choose_index(self.defs_by_blocks[block].len())?;
                    if self.func.values[self.defs_by_blocks[block][value_idx]].bank == bank {
                        self.defs_by_blocks[block].remove(value_idx)
                    } else {
                        self.new_value(bank)?
                    }
                } else {
                    self.new_value(bank)?
                };
                values.push(value);
            }
            if self.u.arbitrary()? {
                // Later change this into a Reuse.
                self.reuse_operands.push(op_idx);
            }
            defined_values.extend_from_slice(&values);
            let value_group = self.func.value_groups.push(values);
            if !is_ret && self.u.arbitrary()? {
                OperandKind::DefGroup(value_group)
            } else {
                OperandKind::EarlyDefGroup(value_group)
            }
        } else {
            if self.u.arbitrary()? {
                // Later change this into a Reuse.