Method check_class

src/debug_utils/validate_reginfo.rs:157–317

Check a register class.

(&mut self, class: RegClass)

    /// Check a register class.
    fn check_class(&mut self, class: RegClass) -> Result<()> {
        let bank = self.reginfo.bank_for_class(class);
        self.check_entity(Entity::RegBank(bank))?;

        let group_size = self.reginfo.class_group_size(class);
        ensure!(
            group_size <= MAX_GROUP_SIZE,
            "{class}: Group size {group_size} too large (max: {MAX_GROUP_SIZE})"
        );
        ensure!(group_size != 0, "{class}: Invalid group size of 0");
        if group_size != 1 {
            ensure!(
                !self.reginfo.class_includes_spillslots(class),
                "{class}: Group class cannot include spillslots"
            );
        }

        if group_size != 1 {
            let mut regs_per_index = [PhysRegSet::new(); MAX_GROUP_SIZE];
            for group in self.reginfo.class_group_members(class) {
                // Check that class members have the same group size as the class.
                let members = self.reginfo.reg_group_members(group);
                ensure!(
                    members.len() == group_size,
                    "{group} group size ({}) doesn't match {class} group size ({group_size})",
                    members.len()
                );

                for (group_index, &reg) in members.iter().enumerate() {
                    // Check that class members are in the same bank as the class.
                    ensure!(
                        self.reginfo.bank_for_reg(reg) == Some(bank),
                        "{class} contains {reg} which is outside {bank}"
                    );

                    // Check that, at each index, each register is unique within the class.
                    ensure!(
                        !regs_per_index[group_index].contains(reg),
                        "{class} has duplicate register {reg} at group index {group_index}"
                    );
                    regs_per_index[group_index].insert(reg);

                    // Check the reverse mapping in group_for_reg.
                    ensure!(
                        self.reginfo.group_for_reg(reg, group_index, class) == Some(group),
                        "Inconsistent group_for_reg({reg}, {group_index}, {class}): got {:?} \
                         expected {:?}",
                        self.reginfo.group_for_reg(reg, group_index, class),
                        Some(group)
                    );
                }
            }
        } else {
            for reg in self.reginfo.class_members(class) {
                // Check that class members are in the same bank as the class.
                ensure!(
                    self.reginfo.bank_for_reg(reg) == Some(bank),
                    "{class} contains {reg} which is outside {bank}"