Run the fuzzer with all register classes (#152)

* Run the fuzzer with all register classes

* Don't share spill slots between register classes

The parallel move resolvers runs separately for each register class and
can't handle parallel moves involving a single stack slot used by two
register classes.

Author: Amanieu

src/fuzzing/func.rs

@@ -30,18 +30,6 @@ pub struct InstData {
 }
 
 impl InstData {
-    pub fn op(def: usize, uses: &[usize]) -> InstData {
-        let mut operands = vec![Operand::reg_def(VReg::new(def, RegClass::Int))];
-        for &u in uses {
-            operands.push(Operand::reg_use(VReg::new(u, RegClass::Int)));
-        }
-        InstData {
-            op: InstOpcode::Op,
-            operands,
-            clobbers: vec![],
-            is_safepoint: false,
-        }
-    }
     pub fn branch() -> InstData {
         InstData {
             op: InstOpcode::Branch,
@@ -145,8 +133,10 @@ impl Function for Func {
 
     fn spillslot_size(&self, regclass: RegClass) -> usize {
         match regclass {
+            // Test the case where 2 classes share the same
             RegClass::Int => 1,
-            RegClass::Float | RegClass::Vector => 2,
+            RegClass::Float => 1,
+            RegClass::Vector => 2,
         }
     }
 }
@@ -234,6 +224,12 @@ impl FuncBuilder {
     }
 }
 
+impl Arbitrary<'_> for RegClass {
+    fn arbitrary(u: &mut Unstructured) -> ArbitraryResult<Self> {
+        Ok(*u.choose(&[RegClass::Int, RegClass::Float, RegClass::Vector])?)
+    }
+}
+
 impl Arbitrary<'_> for OperandConstraint {
     fn arbitrary(u: &mut Unstructured) -> ArbitraryResult<Self> {
         Ok(*u.choose(&[OperandConstraint::Any, OperandConstraint::Reg])?)
@@ -380,7 +376,7 @@ impl Func {
         for block in 0..num_blocks {
             let mut vregs = vec![];
             for _ in 0..u.int_in_range(5..=15)? {
-                let vreg = VReg::new(builder.f.num_vregs, RegClass::Int);
+                let vreg = VReg::new(builder.f.num_vregs, RegClass::arbitrary(u)?);
                 builder.f.num_vregs += 1;
                 vregs.push(vreg);
                 if opts.reftypes && bool::arbitrary(u)? {
@@ -476,28 +472,30 @@ impl Func {
                     let op = operands[0];
                     debug_assert_eq!(op.kind(), OperandKind::Def);
                     let reused = u.int_in_range(1..=(operands.len() - 1))?;
-                    operands[0] = Operand::new(
-                        op.vreg(),
-                        OperandConstraint::Reuse(reused),
-                        op.kind(),
-                        OperandPos::Late,
-                    );
-                    // Make sure reused input is a Reg.
-                    let op = operands[reused];
-                    operands[reused] = Operand::new(
-                        op.vreg(),
-                        OperandConstraint::Reg,
-                        op.kind(),
-                        OperandPos::Early,
-                    );
+                    if op.class() == operands[reused].class() {
+                        operands[0] = Operand::new(
+                            op.vreg(),
+                            OperandConstraint::Reuse(reused),
+                            op.kind(),
+                            OperandPos::Late,
+                        );
+                        // Make sure reused input is a Reg.
+                        let op = operands[reused];
+                        operands[reused] = Operand::new(
+                            op.vreg(),
+                            OperandConstraint::Reg,
+                            op.kind(),
+                            OperandPos::Early,
+                        );
+                    }
                 } else if opts.fixed_regs && bool::arbitrary(u)? {
                     let mut fixed_early = vec![];
                     let mut fixed_late = vec![];
                     for _ in 0..u.int_in_range(0..=operands.len() - 1)? {
                         // Pick an operand and make it a fixed reg.
                         let i = u.int_in_range(0..=(operands.len() - 1))?;
                         let op = operands[i];
-                        let fixed_reg = PReg::new(u.int_in_range(0..=62)?, RegClass::Int);
+                        let fixed_reg = PReg::new(u.int_in_range(0..=62)?, op.class());
                         let fixed_list = match op.pos() {
                             OperandPos::Early => &mut fixed_early,
                             OperandPos::Late => &mut fixed_late,
@@ -535,10 +533,13 @@ impl Func {
                         if clobbers.iter().any(|r| r.hw_enc() == reg) {
                             break;
                         }
-                        clobbers.push(PReg::new(reg, RegClass::Int));
+                        clobbers.push(PReg::new(reg, RegClass::arbitrary(u)?));
                     }
                 } else if opts.fixed_nonallocatable && bool::arbitrary(u)? {
-                    operands.push(Operand::fixed_nonallocatable(PReg::new(63, RegClass::Int)));
+                    operands.push(Operand::fixed_nonallocatable(PReg::new(
+                        63,
+                        RegClass::arbitrary(u)?,
+                    )));
                 }
 
                 let is_safepoint = opts.reftypes
@@ -565,18 +566,30 @@ impl Func {
                 let mut params = vec![];
                 for &succ in &builder.f.block_succs[block] {
                     let mut args = vec![];
-                    for _ in 0..builder.f.block_params_in[succ.index()].len() {
+                    for i in 0..builder.f.block_params_in[succ.index()].len() {
                         let dom_block = choose_dominating_block(
                             &builder.idom[..],
                             Block::new(block),
                             false,
                             u,
                         )?;
-                        let vreg = if dom_block.is_valid() && bool::arbitrary(u)? {
-                            u.choose(&vregs_by_block[dom_block.index()][..])?
+
+                        // Look for a vreg with a suitable class. If no
+                        // suitable vreg is available then we error out, which
+                        // causes the fuzzer to skip this function.
+                        let vregs = if dom_block.is_valid() && bool::arbitrary(u)? {
+                            &vregs_by_block[dom_block.index()][..]
                         } else {
-                            u.choose(&avail[..])?
+                            &avail[..]
                         };
+                        let suitable_vregs: Vec<_> = vregs
+                            .iter()
+                            .filter(|vreg| {
+                                vreg.class() == builder.f.block_params_in[succ.index()][i].class()
+                            })
+                            .copied()
+                            .collect();
+                        let vreg = u.choose(&suitable_vregs)?;
                         args.push(*vreg);
                     }
                     params.push(args);
@@ -656,13 +669,29 @@ impl core::fmt::Debug for Func {
 }
 
 pub fn machine_env() -> MachineEnv {
-    fn regs(r: core::ops::Range<usize>) -> Vec<PReg> {
-        r.map(|i| PReg::new(i, RegClass::Int)).collect()
-    }
-    let preferred_regs_by_class: [Vec<PReg>; 3] = [regs(0..24), vec![], vec![]];
-    let non_preferred_regs_by_class: [Vec<PReg>; 3] = [regs(24..32), vec![], vec![]];
+    fn regs(r: core::ops::Range<usize>, c: RegClass) -> Vec<PReg> {
+        r.map(|i| PReg::new(i, c)).collect()
+    }
+    let preferred_regs_by_class: [Vec<PReg>; 3] = [
+        regs(0..24, RegClass::Int),
+        regs(0..24, RegClass::Float),
+        regs(0..24, RegClass::Vector),
+    ];
+    let non_preferred_regs_by_class: [Vec<PReg>; 3] = [
+        regs(24..32, RegClass::Int),
+        regs(24..32, RegClass::Float),
+        regs(24..32, RegClass::Vector),
+    ];
     let scratch_by_class: [Option<PReg>; 3] = [None, None, None];
-    let fixed_stack_slots = regs(32..63);
+    let fixed_stack_slots = (32..63)
+        .flat_map(|i| {
+            [
+                PReg::new(i, RegClass::Int),
+                PReg::new(i, RegClass::Float),
+                PReg::new(i, RegClass::Vector),
+            ]
+        })
+        .collect();
     // Register 63 is reserved for use as a fixed non-allocatable register.
     MachineEnv {
         preferred_regs_by_class,

src/ion/data_structures.rs

@@ -300,7 +300,6 @@ pub struct SpillSet {
     pub class: RegClass,
     pub spill_bundle: LiveBundleIndex,
     pub required: bool,
-    pub size: u8,
     pub splits: u8,
 
     /// The aggregate [`CodeRange`] of all involved [`LiveRange`]s. The effect of this abstraction
@@ -466,7 +465,7 @@ pub struct Env<'a, F: Function> {
 
     pub spilled_bundles: Vec<LiveBundleIndex>,
     pub spillslots: Vec<SpillSlotData>,
-    pub slots_by_size: Vec<SpillSlotList>,
+    pub slots_by_class: [SpillSlotList; 3],
 
     pub extra_spillslots_by_class: [SmallVec<[Allocation; 2]>; 3],
     pub preferred_victim_by_class: [PReg; 3],
@@ -554,6 +553,13 @@ pub struct SpillSlotList {
 }
 
 impl SpillSlotList {
+    pub fn new() -> Self {
+        SpillSlotList {
+            slots: smallvec![],
+            probe_start: 0,
+        }
+    }
+
     /// Get the next spillslot index in probing order, wrapping around
     /// at the end of the slots list.
     pub(crate) fn next_index(&self, index: usize) -> usize {

src/ion/merge.rs

@@ -277,10 +277,8 @@ impl<'a, F: Function> Env<'a, F> {
 
             // Create a spillslot for this bundle.
             let reg = self.vreg(vreg);
-            let size = self.func.spillslot_size(reg.class()) as u8;
             let ssidx = self.spillsets.push(SpillSet {
                 slot: SpillSlotIndex::invalid(),
-                size,
                 required: false,
                 class: reg.class(),
                 reg_hint: PReg::invalid(),

src/ion/mod.rs

@@ -67,7 +67,11 @@ impl<'a, F: Function> Env<'a, F> {
             safepoints_per_vreg: HashMap::new(),
             spilled_bundles: vec![],
             spillslots: vec![],
-            slots_by_size: vec![],
+            slots_by_class: [
+                SpillSlotList::new(),
+                SpillSlotList::new(),
+                SpillSlotList::new(),
+            ],
             allocated_bundle_count: 0,
 
             extra_spillslots_by_class: [smallvec![], smallvec![], smallvec![]],

src/ion/spill.rs

@@ -14,10 +14,9 @@
 
 use super::{
     AllocRegResult, Env, LiveRangeKey, PReg, PRegIndex, RegTraversalIter, SpillSetIndex,
-    SpillSlotData, SpillSlotIndex, SpillSlotList,
+    SpillSlotData, SpillSlotIndex,
 };
 use crate::{ion::data_structures::SpillSetRanges, Allocation, Function, SpillSlot};
-use smallvec::smallvec;
 
 impl<'a, F: Function> Env<'a, F> {
     pub fn try_allocating_regs_for_spilled_bundles(&mut self) {
@@ -99,40 +98,31 @@ impl<'a, F: Function> Env<'a, F> {
             if !self.spillsets[spillset].required {
                 continue;
             }
-            // Get or create the spillslot list for this size.
-            let size = self.spillsets[spillset].size as usize;
-            if size >= self.slots_by_size.len() {
-                self.slots_by_size.resize(
-                    size + 1,
-                    SpillSlotList {
-                        slots: smallvec![],
-                        probe_start: 0,
-                    },
-                );
-            }
+            let class = self.spillsets[spillset].class as usize;
             // Try a few existing spillslots.
-            let mut i = self.slots_by_size[size].probe_start;
+            let mut i = self.slots_by_class[class].probe_start;
             let mut success = false;
             // Never probe the same element more than once: limit the
             // attempt count to the number of slots in existence.
-            for _attempt in 0..core::cmp::min(self.slots_by_size[size].slots.len(), MAX_ATTEMPTS) {
+            for _attempt in 0..core::cmp::min(self.slots_by_class[class].slots.len(), MAX_ATTEMPTS)
+            {
                 // Note: this indexing of `slots` is always valid
                 // because either the `slots` list is empty and the
                 // iteration limit above consequently means we don't
                 // run this loop at all, or else `probe_start` is
                 // in-bounds (because it is made so below when we add
                 // a slot, and it always takes on the last index `i`
                 // after this loop).
-                let spillslot = self.slots_by_size[size].slots[i];
+                let spillslot = self.slots_by_class[class].slots[i];
 
                 if self.spillslot_can_fit_spillset(spillslot, spillset) {
                     self.allocate_spillset_to_spillslot(spillset, spillslot);
                     success = true;
-                    self.slots_by_size[size].probe_start = i;
+                    self.slots_by_class[class].probe_start = i;
                     break;
                 }
 
-                i = self.slots_by_size[size].next_index(i);
+                i = self.slots_by_class[class].next_index(i);
             }
 
             if !success {
@@ -141,10 +131,10 @@ impl<'a, F: Function> Env<'a, F> {
                 self.spillslots.push(SpillSlotData {
                     ranges: SpillSetRanges::new(),
                     alloc: Allocation::none(),
-                    slots: size as u32,
+                    slots: self.func.spillslot_size(self.spillsets[spillset].class) as u32,
                 });
-                self.slots_by_size[size].slots.push(spillslot);
-                self.slots_by_size[size].probe_start = self.slots_by_size[size].slots.len() - 1;
+                self.slots_by_class[class].slots.push(spillslot);
+                self.slots_by_class[class].probe_start = self.slots_by_class[class].slots.len() - 1;
 
                 self.allocate_spillset_to_spillslot(spillset, spillslot);
             }