Merge branch 'main' into less-fuzz-work

Author: abrown

fuzz/fuzz_targets/fastalloc_checker.rs

@@ -26,6 +26,7 @@ impl Arbitrary<'_> for TestCase {
                     clobbers: true,
                     reftypes: false,
                     callsite_ish_constraints: true,
+                    ..Options::default()
                 },
             )?,
         })
@@ -37,8 +38,8 @@ fuzz_target!(|testcase: TestCase| {
     let _ = env_logger::try_init();
     log::trace!("func:\n{:?}", func);
     let env = regalloc2::fuzzing::func::machine_env();
-    let out =
-        regalloc2::fuzzing::fastalloc::run(&func, &env, true, false).expect("regalloc did not succeed");
+    let out = regalloc2::fuzzing::fastalloc::run(&func, &env, true, false)
+        .expect("regalloc did not succeed");
 
     let mut checker = Checker::new(&func, &env);
     checker.prepare(&out);

fuzz/fuzz_targets/ion_checker.rs

@@ -26,6 +26,7 @@ impl Arbitrary<'_> for TestCase {
                     clobbers: true,
                     reftypes: true,
                     callsite_ish_constraints: true,
+                    ..Options::default()
                 },
             )?,
         })

fuzz/fuzz_targets/ssagen.rs

@@ -27,6 +27,7 @@ impl Arbitrary<'_> for TestCase {
                     clobbers: true,
                     reftypes: true,
                     callsite_ish_constraints: true,
+                    ..Options::default()
                 },
             )?,
         })

src/checker.rs

@@ -104,6 +104,7 @@ use alloc::vec::Vec;
 use alloc::{format, vec};
 use core::default::Default;
 use core::hash::Hash;
+use core::ops::Range;
 use core::result::Result;
 use smallvec::{smallvec, SmallVec};
 
@@ -166,6 +167,12 @@ pub enum CheckerError {
         into: Allocation,
         from: Allocation,
     },
+    AllocationOutsideLimit {
+        inst: Inst,
+        op: Operand,
+        alloc: Allocation,
+        range: Range<usize>,
+    },
 }
 
 /// Abstract state for an allocation.
@@ -669,6 +676,18 @@ impl CheckerState {
                     });
                 }
             }
+            OperandConstraint::Limit(max) => {
+                if let Some(preg) = alloc.as_reg() {
+                    if preg.hw_enc() >= max {
+                        return Err(CheckerError::AllocationOutsideLimit {
+                            inst,
+                            op,
+                            alloc,
+                            range: (0..max),
+                        });
+                    }
+                }
+            }
         }
         Ok(())
     }

src/fastalloc/mod.rs

@@ -618,6 +618,9 @@ impl<'a, F: Function> Env<'a, F> {
             }
 
             OperandConstraint::Stack => self.edits.is_stack(alloc),
+            OperandConstraint::Limit(_) => {
+                todo!("limit constraints are not yet supported in fastalloc")
+            }
         }
     }
 
@@ -773,6 +776,9 @@ impl<'a, F: Function> Env<'a, F> {
             }
 
             OperandConstraint::Stack => Allocation::stack(self.get_spillslot(op.vreg())),
+            OperandConstraint::Limit(_) => {
+                todo!("limit constraints are not yet supported in fastalloc")
+            }
         };
         self.allocs[(inst.index(), op_idx)] = new_alloc;
         Ok(new_alloc)