Method check_value

src/debug_utils/validate_func.rs:715–825

(&mut self, value: Value)

    }

    fn check_value(&mut self, value: Value) -> Result<()> {
        let value_bank = self.func.value_bank(value);
        ensure!(
            !self
                .reginfo
                .class_members(self.reginfo.top_level_class(value_bank))
                .is_empty(),
            "{value} cannot be in empty register bank {value_bank}"
        );
        if let Some((_cost, class)) = self.func.can_rematerialize(value) {
            ensure!(
                self.reginfo.class_group_size(class) == 1,
                "{value} direct remat target: Value used with group register class"
            );
            let bank = self.reginfo.bank_for_class(class);
            ensure!(
                bank == value_bank,
                "{value} direct remat target: {value} used with different register banks: {bank} \
                 vs {value_bank}"
            );
            ensure!(
                !self.reginfo.allocation_order(class).is_empty(),
                "{value} direct remat target uses register class {class} with an empty allocation \
                 order"
            );
            for reg in self.reginfo.class_members(class) {
                ensure!(
                    self.reginfo.class_includes_spillslots(class) || !self.reginfo.is_memory(reg),
                    "{value} direct remat target uses register class {class} which has in-memory \
                     members but doesn't include spill slots"
                );
            }
        }
        if let Some(remat) = self.func.can_indirectly_rematerialize(value) {
            ensure!(
                !remat.inputs.is_empty(),
                "{value} cannot have indirect rematerialization with no inputs"
            );
            ensure!(
                remat.inputs.len() <= MAX_INST_OPERANDS,
                "{value} indirect remat has too many inputs: {} (max: {MAX_INST_OPERANDS})",
                remat.inputs.len(),
            );
            ensure!(
                !remat
                    .inputs
                    .iter()
                    .all(|op| matches!(op.kind(), OperandKind::NonAllocatable)),
                "{value} cannot have indirect rematerialization with only NonAllocatable inputs"
            );

            self.early_fixed.clear();
            self.late_fixed.clear();
            self.reuse_targets.clear();
            let source = ConstraintSource::Remat(value);
            let dest = match remat.constraint {
                OperandConstraint::Reuse(_) => {
                    Operand::new(OperandKind::EarlyDef(value), remat.constraint)