Changes from review comments.

Author: cfallin

fuzz/.gitignore

@@ -1,4 +1,3 @@
-
 target
 corpus
 artifacts

fuzz/Cargo.toml

@@ -1,4 +1,3 @@
-
 [package]
 name = "regalloc2-fuzz"
 version = "0.0.0"

fuzz/fuzz_targets/domtree.rs

@@ -1,3 +1,8 @@
+/*
+ * Released under the terms of the Apache 2.0 license with LLVM
+ * exception. See `LICENSE` for details.
+ */
+
 #![no_main]
 use libfuzzer_sys::arbitrary::{Arbitrary, Result, Unstructured};
 use libfuzzer_sys::fuzz_target;

fuzz/fuzz_targets/ion.rs

@@ -1,3 +1,8 @@
+/*
+ * Released under the terms of the Apache 2.0 license with LLVM
+ * exception. See `LICENSE` for details.
+ */
+
 #![no_main]
 use libfuzzer_sys::fuzz_target;
 

fuzz/fuzz_targets/ion_checker.rs

@@ -1,3 +1,8 @@
+/*
+ * Released under the terms of the Apache 2.0 license with LLVM
+ * exception. See `LICENSE` for details.
+ */
+
 #![no_main]
 use libfuzzer_sys::fuzz_target;
 use libfuzzer_sys::arbitrary::{Arbitrary, Unstructured, Result};

fuzz/fuzz_targets/moves.rs

@@ -1,3 +1,8 @@
+/*
+ * Released under the terms of the Apache 2.0 license with LLVM
+ * exception. See `LICENSE` for details.
+ */
+
 #![no_main]
 use libfuzzer_sys::arbitrary::{Arbitrary, Result, Unstructured};
 use libfuzzer_sys::fuzz_target;

fuzz/fuzz_targets/ssagen.rs

@@ -1,3 +1,8 @@
+/*
+ * Released under the terms of the Apache 2.0 license with LLVM
+ * exception. See `LICENSE` for details.
+ */
+
 #![no_main]
 use libfuzzer_sys::arbitrary::{Arbitrary, Result, Unstructured};
 use libfuzzer_sys::fuzz_target;
@@ -23,6 +28,8 @@ impl Arbitrary for TestCase {
                     control_flow: true,
                     reducible: false,
                     always_local_uses: false,
+                    block_params: true,
+                    reftypes: true,
                 },
             )?,
         })

src/bin/test.rs

@@ -1,3 +1,8 @@
+/*
+ * Released under the terms of the Apache 2.0 license with LLVM
+ * exception. See `LICENSE` for details.
+ */
+
 use arbitrary::{Arbitrary, Unstructured};
 use rand::{Rng, SeedableRng};
 use rand_chacha::ChaCha8Rng;

src/bitvec.rs

@@ -1,3 +1,8 @@
+/*
+ * Released under the terms of the Apache 2.0 license with LLVM
+ * exception. See `LICENSE` for details.
+ */
+
 //! Bit vectors.
 
 use smallvec::{smallvec, SmallVec};

src/cfg.rs

@@ -1,3 +1,8 @@
+/*
+ * Released under the terms of the Apache 2.0 license with LLVM
+ * exception. See `LICENSE` for details.
+ */
+
 //! Lightweight CFG analyses.
 
 use crate::{domtree, postorder, Block, Function, Inst, OperandKind, ProgPoint};

src/fuzzing/func.rs

@@ -1,3 +1,8 @@
+/*
+ * Released under the terms of the Apache 2.0 license with LLVM
+ * exception. See `LICENSE` for details.
+ */
+
 use crate::{
     domtree, postorder, Allocation, Block, Function, Inst, InstRange, MachineEnv, Operand,
     OperandKind, OperandPolicy, OperandPos, PReg, RegClass, VReg,

src/fuzzing/mod.rs

@@ -1,3 +1,8 @@
+/*
+ * Released under the terms of the Apache 2.0 license with LLVM
+ * exception. See `LICENSE` for details.
+ */
+
 //! Utilities for fuzzing.
 
 pub mod func;

src/lib.rs

@@ -355,6 +355,7 @@ impl Operand {
 
     #[inline(always)]
     pub fn from_bits(bits: u32) -> Self {
+        debug_assert!(bits >> 29 <= 4);
         Operand { bits }
     }
 }
@@ -429,9 +430,9 @@ pub struct Allocation {
     /// `policy` field in `Operand`, and we are careful to use
     /// disjoint ranges of values in this field for each type. We also
     /// leave the def-or-use bit (`kind` for `Operand`) unused here so
-    /// that the client may use it to mark `Allocation`s on
-    /// instructions as read or write when it edits instructions
-    /// (which is sometimes useful for post-allocation analyses).
+    /// that we can use it below in `OperandOrAllocation` to record
+    /// whether `Allocation`s are defs or uses (which is often useful
+    /// to know).
     ///
     /// kind:3 unused:1 index:28
     bits: u32,
@@ -532,6 +533,7 @@ impl Allocation {
 
     #[inline(always)]
     pub fn from_bits(bits: u32) -> Self {
+        debug_assert!(bits >> 29 >= 5);
         Self { bits }
     }
 }
@@ -566,11 +568,13 @@ pub struct OperandOrAllocation {
 
 impl OperandOrAllocation {
     pub fn from_operand(operand: Operand) -> Self {
+        debug_assert!(operand.bits() >> 29 <= 4);
         Self {
             bits: operand.bits(),
         }
     }
     pub fn from_alloc(alloc: Allocation) -> Self {
+        debug_assert!(alloc.bits() >> 29 >= 5);
         Self { bits: alloc.bits() }
     }
     pub fn is_operand(&self) -> bool {
@@ -588,6 +592,10 @@ impl OperandOrAllocation {
     }
     pub fn as_allocation(&self) -> Option<Allocation> {
         if self.is_allocation() {
+            // Remove the def/use bit -- the canonical `Allocation`
+            // does not have this, and we want allocs to continue to
+            // be comparable whether they are used for reads or
+            // writes.
             Some(Allocation::from_bits(self.bits & !(1 << 28)))
         } else {
             None
@@ -612,6 +620,9 @@ impl OperandOrAllocation {
 
 /// A trait defined by the regalloc client to provide access to its
 /// machine-instruction / CFG representation.
+///
+/// (This trait's design is inspired by, and derives heavily from, the
+/// trait of the same name in regalloc.rs.)
 pub trait Function {
     // -------------
     // CFG traversal
@@ -669,10 +680,7 @@ pub trait Function {
     /// Get the clobbers for an instruction.
     fn inst_clobbers(&self, insn: Inst) -> &[PReg];
 
-    /// Get the precise number of `VReg` in use in this function, to allow
-    /// preallocating data structures. This number *must* be a correct
-    /// lower-bound, otherwise invalid index failures may happen; it is of
-    /// course better if it is exact.
+    /// Get the number of `VReg` in use in this function.
     fn num_vregs(&self) -> usize;
 
     /// Get the VRegs that are pointer/reference types. This has the
@@ -724,6 +732,9 @@ pub trait Function {
     /// but we also use them for F32 and F64 values, we may use a different
     /// store-slot size and smaller-operand store/load instructions for an F64
     /// than for a true V128.
+    ///
+    /// (This trait method's design and doc text derives from
+    /// regalloc.rs' trait of the same name.)
     fn spillslot_size(&self, regclass: RegClass, for_vreg: VReg) -> usize;
 
     /// When providing a spillslot number for a multi-slot spillslot,

src/moves.rs

@@ -1,3 +1,8 @@
+/*
+ * Released under the terms of the Apache 2.0 license with LLVM
+ * exception. See `LICENSE` for details.
+ */
+
 use crate::Allocation;
 use smallvec::{smallvec, SmallVec};
 

src/postorder.rs

@@ -1,3 +1,8 @@
+/*
+ * Released under the terms of the Apache 2.0 license with LLVM
+ * exception. See `LICENSE` for details.
+ */
+
 //! Fast postorder computation with no allocations (aside from result).
 
 use crate::Block;

src/ssa.rs

@@ -1,3 +1,8 @@
+/*
+ * Released under the terms of the Apache 2.0 license with LLVM
+ * exception. See `LICENSE` for details.
+ */
+
 //! SSA-related utilities.
 
 use crate::cfg::CFGInfo;