Method check_inst

src/debug_utils/validate_func.rs:346–414

Check an instruction.

(&mut self, block: Block, inst: Inst)

    /// Check an instruction.
    fn check_inst(&mut self, block: Block, inst: Inst) -> Result<()> {
        // These are temporary for the scope of this instruction.
        self.early_fixed.clear();
        self.late_fixed.clear();
        self.reuse_targets.clear();

        let operands = self.func.inst_operands(inst);
        ensure!(
            operands.len() <= MAX_INST_OPERANDS,
            "{inst}: Too many operands: {} (max: {MAX_INST_OPERANDS})",
            operands.len(),
        );
        let source = ConstraintSource::Inst(inst);
        for &op in operands {
            match op.kind() {
                OperandKind::Def(value) | OperandKind::EarlyDef(value) => {
                    self.check_entity(Entity::Value(value))?;
                    self.check_value_def(value, ValueDef::Inst(block, inst))?;
                    self.check_constraint(source, operands, op, ValueOrGroup::Value(value))?;
                }
                OperandKind::Use(value) => {
                    self.check_entity(Entity::Value(value))?;
                    self.check_constraint(source, operands, op, ValueOrGroup::Value(value))?;
                }
                OperandKind::DefGroup(group) | OperandKind::EarlyDefGroup(group) => {
                    self.check_entity(Entity::ValueGroup(group))?;
                    for &value in self.func.value_group_members(group) {
                        self.check_entity(Entity::Value(value))?;
                        self.check_value_def(value, ValueDef::Inst(block, inst))?;
                    }
                    self.check_constraint(source, operands, op, ValueOrGroup::Group(group))?;
                }
                OperandKind::UseGroup(group) => {
                    self.check_entity(Entity::ValueGroup(group))?;
                    for &value in self.func.value_group_members(group) {
                        self.check_entity(Entity::Value(value))?;
                    }
                    self.check_constraint(source, operands, op, ValueOrGroup::Group(group))?;
                }
                OperandKind::NonAllocatable => match op.constraint() {
                    OperandConstraint::Fixed(reg) => {
                        ensure!(
                            self.reginfo.bank_for_reg(reg).is_none(),
                            "{inst} {op}: NonAllocatable register must be outside a bank"
                        );
                    }
                    OperandConstraint::Class(_) | OperandConstraint::Reuse(_) => {
                        bail!("{inst} {op}: NonAllocatable operand must have a Fixed constraint")
                    }
                },
            }
        }

        // Check that clobbers don't overlap with fixed defs or other clobbers.
        let mut clobbers = RegUnitSet::new();
        for unit in self.func.inst_clobbers(inst) {
            ensure!(
                !clobbers.contains(unit),