Give RegClassData a reference to its parent RegInfo.

This makes it possible to materialize new RegClass references without
requiring a RegInfo reference to be passed around.

- Move the RegInfo::toprc() method to RegClassData.
- Rename RegClassData::intersect() to intersect_index() and provide a
  new intersect() which returns a register class.
- Remove some &RegInfo parameters that are no longer needed.

lib/cretonne/src/isa/intel/registers.rs

@@ -49,14 +49,14 @@ mod tests {
 
     #[test]
     fn regclasses() {
-        assert_eq!(GPR.intersect(GPR), Some(GPR.into()));
-        assert_eq!(GPR.intersect(ABCD), Some(ABCD.into()));
-        assert_eq!(GPR.intersect(FPR), None);
-        assert_eq!(ABCD.intersect(GPR), Some(ABCD.into()));
-        assert_eq!(ABCD.intersect(ABCD), Some(ABCD.into()));
-        assert_eq!(ABCD.intersect(FPR), None);
-        assert_eq!(FPR.intersect(FPR), Some(FPR.into()));
-        assert_eq!(FPR.intersect(GPR), None);
-        assert_eq!(FPR.intersect(ABCD), None);
+        assert_eq!(GPR.intersect_index(GPR), Some(GPR.into()));
+        assert_eq!(GPR.intersect_index(ABCD), Some(ABCD.into()));
+        assert_eq!(GPR.intersect_index(FPR), None);
+        assert_eq!(ABCD.intersect_index(GPR), Some(ABCD.into()));
+        assert_eq!(ABCD.intersect_index(ABCD), Some(ABCD.into()));
+        assert_eq!(ABCD.intersect_index(FPR), None);
+        assert_eq!(FPR.intersect_index(FPR), Some(FPR.into()));
+        assert_eq!(FPR.intersect_index(GPR), None);
+        assert_eq!(FPR.intersect_index(ABCD), None);
     }
 }

lib/cretonne/src/isa/registers.rs

@@ -145,14 +145,17 @@ pub struct RegClassData {
     /// Mask of register units in the class. If `width > 1`, the mask only has a bit set for the
     /// first register unit in each allocatable register.
     pub mask: RegUnitMask,
+
+    /// The global `RegInfo` instance containing that this register class.
+    pub info: &'static RegInfo,
 }
 
 impl RegClassData {
-    /// Get the register class corresponding to the intersection of `self` and `other`.
+    /// Get the register class index corresponding to the intersection of `self` and `other`.
     ///
     /// This register class is guaranteed to exist if the register classes overlap. If the register
     /// classes don't overlap, returns `None`.
-    pub fn intersect(&self, other: RegClass) -> Option<RegClassIndex> {
+    pub fn intersect_index(&self, other: RegClass) -> Option<RegClassIndex> {
         // Compute the set of common subclasses.
         let mask = self.subclasses & other.subclasses;
 
@@ -166,12 +169,22 @@ impl RegClassData {
         }
     }
 
+    /// Get the intersection of `self` and `other`.
+    pub fn intersect(&self, other: RegClass) -> Option<RegClass> {
+        self.intersect_index(other).map(|rci| self.info.rc(rci))
+    }
+
     /// Returns true if `other` is a subclass of this register class.
     /// A register class is considered to be a subclass of itself.
     pub fn has_subclass<RCI: Into<RegClassIndex>>(&self, other: RCI) -> bool {
         self.subclasses & (1 << other.into().0) != 0
     }
 
+    /// Get the top-level register class containing this class.
+    pub fn toprc(&self) -> RegClass {
+        self.info.rc(RegClassIndex(self.toprc))
+    }
+
     /// Get a specific register unit in this class.
     pub fn unit(&self, offset: usize) -> RegUnit {
         let uoffset = offset * usize::from(self.width);
@@ -246,7 +259,7 @@ pub struct RegInfo {
     pub banks: &'static [RegBank],
 
     /// All register classes ordered topologically so a sub-class always follows its parent.
-    pub classes: &'static [RegClassData],
+    pub classes: &'static [RegClass],
 }
 
 impl RegInfo {
@@ -274,12 +287,7 @@ impl RegInfo {
 
     /// Get the register class corresponding to `idx`.
     pub fn rc(&self, idx: RegClassIndex) -> RegClass {
-        &self.classes[idx.index()]
-    }
-
-    /// Get the top-level register class containing `rc`.
-    pub fn toprc(&self, rc: RegClass) -> RegClass {
-        &self.classes[rc.toprc as usize]
+        self.classes[idx.index()]
     }
 }