ZJIT: Double-check this

Author: nirvdrum

zjit/src/backend/lir.rs

@@ -152,14 +152,14 @@ pub struct Mem
 
 impl fmt::Display for Mem {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if self.num_bits != 64 {
+        if self.num_bits != VALUE_BITS {
             write!(f, "Mem{}", self.num_bits)?;
         }
         write!(f, "[")?;
         match self.base {
             MemBase::Reg(reg_no) => write!(f, "{}", mem_base_reg(reg_no))?,
             MemBase::VReg(idx) => write!(f, "v{idx}")?,
-            MemBase::Stack { stack_idx, num_bits } if num_bits == 64 => write!(f, "Stack[{stack_idx}]")?,
+            MemBase::Stack { stack_idx, num_bits } if num_bits == VALUE_BITS => write!(f, "Stack[{stack_idx}]")?,
             MemBase::Stack { stack_idx, num_bits } => write!(f, "Stack{num_bits}[{stack_idx}]")?,
         }
         if self.disp != 0 {
@@ -212,7 +212,7 @@ impl fmt::Display for Opnd {
             None => write!(f, "None"),
             Value(VALUE(value)) if *value < 10 => write!(f, "Value({value:x})"),
             Value(VALUE(value)) => write!(f, "Value(0x{value:x})"),
-            VReg { idx, num_bits } if *num_bits == 64 => write!(f, "v{idx}"),
+            VReg { idx, num_bits } if *num_bits == VALUE_BITS => write!(f, "v{idx}"),
             VReg { idx, num_bits } => write!(f, "VReg{num_bits}(v{idx})"),
             Imm(value) if value.abs() < 10 => write!(f, "Imm({value:x})"),
             Imm(value) => write!(f, "Imm(0x{value:x})"),
@@ -230,7 +230,7 @@ impl fmt::Debug for Opnd {
         match self {
             Self::None => write!(fmt, "None"),
             Value(val) => write!(fmt, "Value({val:?})"),
-            VReg { idx, num_bits } if *num_bits == 64 => write!(fmt, "VReg({idx})"),
+            VReg { idx, num_bits } if *num_bits == VALUE_BITS => write!(fmt, "VReg({idx})"),
             VReg { idx, num_bits } => write!(fmt, "VReg{num_bits}({idx})"),
             Imm(signed) => write!(fmt, "{signed:x}_i64"),
             UImm(unsigned) => write!(fmt, "{unsigned:x}_u64"),
@@ -247,7 +247,7 @@ impl Opnd
     pub fn mem(num_bits: u8, base: Opnd, disp: i32) -> Self {
         match base {
             Opnd::Reg(base_reg) => {
-                assert!(base_reg.num_bits == 64);
+                assert!(base_reg.num_bits == VALUE_BITS);
                 Opnd::Mem(Mem {
                     base: MemBase::Reg(base_reg.reg_no),
                     disp,
@@ -302,7 +302,7 @@ impl Opnd
     /// Return Opnd with a given num_bits if self has num_bits. Panic otherwise.
     #[track_caller]
     pub fn with_num_bits(&self, num_bits: u8) -> Opnd {
-        assert!(num_bits == 8 || num_bits == 16 || num_bits == 32 || num_bits == 64);
+        assert!(num_bits == 8 || num_bits == 16 || num_bits == 32 || num_bits == VALUE_BITS);
         match *self {
             Opnd::Reg(reg) => Opnd::Reg(reg.with_num_bits(num_bits)),
             Opnd::Mem(Mem { base, disp, .. }) => Opnd::Mem(Mem { base, disp, num_bits }),
@@ -332,7 +332,7 @@ impl Opnd
 
     /// When there aren't any operands to check against, this is the number of
     /// bits that should be used for any given output variable.
-    const DEFAULT_NUM_BITS: u8 = 64;
+    const DEFAULT_NUM_BITS: u8 = VALUE_BITS;
 
     /// Determine the size in bits from the iterator of operands. If any of them
     /// are different sizes this will panic.