Rename wasmi_ir::Reg types to Slot (#1653)

* wasmi_ir: rename Reg -> Slot (+all Reg* types)

* wasmi: adjust after renaming Reg* -> Slot*

* rename Executor::{get,set}_register -> {get,set}_stack_slot

* rename reg -> slot in a few function signatures

* rename len_registers -> len_stack_slots

* rename forgotten snake case identifiers

* rename many instances of reg[s] to slot[s]

Author: Robbepop

crates/ir/src/enum.rs

@@ -106,103 +106,107 @@ impl Clone for Op {
 }
 
 impl Op {
-    /// Creates a new [`Op::ReturnReg2`] for the given [`Reg`] indices.
-    pub fn return_reg2_ext(reg0: impl Into<Reg>, reg1: impl Into<Reg>) -> Self {
+    /// Creates a new [`Op::ReturnSlot2`] for the given [`Slot`] indices.
+    pub fn return_reg2_ext(reg0: impl Into<Slot>, reg1: impl Into<Slot>) -> Self {
         Self::return_reg2([reg0.into(), reg1.into()])
     }
 
-    /// Creates a new [`Op::ReturnReg3`] for the given [`Reg`] indices.
+    /// Creates a new [`Op::ReturnSlot3`] for the given [`Slot`] indices.
     pub fn return_reg3_ext(
-        reg0: impl Into<Reg>,
-        reg1: impl Into<Reg>,
-        reg2: impl Into<Reg>,
+        reg0: impl Into<Slot>,
+        reg1: impl Into<Slot>,
+        reg2: impl Into<Slot>,
     ) -> Self {
         Self::return_reg3([reg0.into(), reg1.into(), reg2.into()])
     }
 
-    /// Creates a new [`Op::ReturnMany`] for the given [`Reg`] indices.
+    /// Creates a new [`Op::ReturnMany`] for the given [`Slot`] indices.
     pub fn return_many_ext(
-        reg0: impl Into<Reg>,
-        reg1: impl Into<Reg>,
-        reg2: impl Into<Reg>,
+        reg0: impl Into<Slot>,
+        reg1: impl Into<Slot>,
+        reg2: impl Into<Slot>,
     ) -> Self {
         Self::return_many([reg0.into(), reg1.into(), reg2.into()])
     }
 
     /// Creates a new [`Op::Copy2`].
-    pub fn copy2_ext(results: RegSpan, value0: impl Into<Reg>, value1: impl Into<Reg>) -> Self {
-        let span = FixedRegSpan::new(results).unwrap_or_else(|_| {
-            panic!("encountered invalid `results` `RegSpan` for `Copy2`: {results:?}")
+    pub fn copy2_ext(results: SlotSpan, value0: impl Into<Slot>, value1: impl Into<Slot>) -> Self {
+        let span = FixedSlotSpan::new(results).unwrap_or_else(|_| {
+            panic!("encountered invalid `results` `SlotSpan` for `Copy2`: {results:?}")
         });
         Self::copy2(span, [value0.into(), value1.into()])
     }
 
     /// Creates a new [`Op::CopyMany`].
-    pub fn copy_many_ext(results: RegSpan, head0: impl Into<Reg>, head1: impl Into<Reg>) -> Self {
+    pub fn copy_many_ext(
+        results: SlotSpan,
+        head0: impl Into<Slot>,
+        head1: impl Into<Slot>,
+    ) -> Self {
         Self::copy_many(results, [head0.into(), head1.into()])
     }
 
-    /// Creates a new [`Op::Register2`] instruction parameter.
-    pub fn register2_ext(reg0: impl Into<Reg>, reg1: impl Into<Reg>) -> Self {
-        Self::register2([reg0.into(), reg1.into()])
+    /// Creates a new [`Op::Slot2`] instruction parameter.
+    pub fn slot2_ext(reg0: impl Into<Slot>, reg1: impl Into<Slot>) -> Self {
+        Self::slot2([reg0.into(), reg1.into()])
     }
 
-    /// Creates a new [`Op::Register3`] instruction parameter.
-    pub fn register3_ext(reg0: impl Into<Reg>, reg1: impl Into<Reg>, reg2: impl Into<Reg>) -> Self {
-        Self::register3([reg0.into(), reg1.into(), reg2.into()])
+    /// Creates a new [`Op::Slot3`] instruction parameter.
+    pub fn slot3_ext(reg0: impl Into<Slot>, reg1: impl Into<Slot>, reg2: impl Into<Slot>) -> Self {
+        Self::slot3([reg0.into(), reg1.into(), reg2.into()])
     }
 
-    /// Creates a new [`Op::RegisterList`] instruction parameter.
-    pub fn register_list_ext(
-        reg0: impl Into<Reg>,
-        reg1: impl Into<Reg>,
-        reg2: impl Into<Reg>,
+    /// Creates a new [`Op::SlotList`] instruction parameter.
+    pub fn slot_list_ext(
+        reg0: impl Into<Slot>,
+        reg1: impl Into<Slot>,
+        reg2: impl Into<Slot>,
     ) -> Self {
-        Self::register_list([reg0.into(), reg1.into(), reg2.into()])
+        Self::slot_list([reg0.into(), reg1.into(), reg2.into()])
     }
 
-    /// Creates a new [`Op::RegisterAndImm32`] from the given `reg` and `offset_hi`.
-    pub fn register_and_offset_hi(reg: impl Into<Reg>, offset_hi: Offset64Hi) -> Self {
-        Self::register_and_imm32(reg, offset_hi.0)
+    /// Creates a new [`Op::SlotAndImm32`] from the given `reg` and `offset_hi`.
+    pub fn slot_and_offset_hi(slot: impl Into<Slot>, offset_hi: Offset64Hi) -> Self {
+        Self::slot_and_imm32(slot, offset_hi.0)
     }
 
-    /// Returns `Some` [`Reg`] and [`Offset64Hi`] if encoded properly.
+    /// Returns `Some` [`Slot`] and [`Offset64Hi`] if encoded properly.
     ///
     /// # Errors
     ///
     /// Returns back `self` if it was an incorrect [`Op`].
     /// This allows for a better error message to inform the user.
-    pub fn filter_register_and_offset_hi(self) -> Result<(Reg, Offset64Hi), Self> {
-        if let Op::RegisterAndImm32 { reg, imm } = self {
-            return Ok((reg, Offset64Hi(u32::from(imm))));
+    pub fn filter_register_and_offset_hi(self) -> Result<(Slot, Offset64Hi), Self> {
+        if let Op::SlotAndImm32 { slot, imm } = self {
+            return Ok((slot, Offset64Hi(u32::from(imm))));
         }
         Err(self)
     }
 
-    /// Creates a new [`Op::RegisterAndImm32`] from the given `reg` and `offset_hi`.
-    pub fn register_and_lane<LaneType>(reg: impl Into<Reg>, lane: LaneType) -> Self
+    /// Creates a new [`Op::SlotAndImm32`] from the given `reg` and `offset_hi`.
+    pub fn slot_and_lane<LaneType>(slot: impl Into<Slot>, lane: LaneType) -> Self
     where
         LaneType: Into<u8>,
     {
-        Self::register_and_imm32(reg, u32::from(lane.into()))
+        Self::slot_and_imm32(slot, u32::from(lane.into()))
     }
 
-    /// Returns `Some` [`Reg`] and a `lane` index if encoded properly.
+    /// Returns `Some` [`Slot`] and a `lane` index if encoded properly.
     ///
     /// # Errors
     ///
     /// Returns back `self` if it was an incorrect [`Op`].
     /// This allows for a better error message to inform the user.
-    pub fn filter_register_and_lane<LaneType>(self) -> Result<(Reg, LaneType), Self>
+    pub fn filter_register_and_lane<LaneType>(self) -> Result<(Slot, LaneType), Self>
     where
         LaneType: TryFrom<u8>,
     {
-        if let Op::RegisterAndImm32 { reg, imm } = self {
+        if let Op::SlotAndImm32 { slot, imm } = self {
             let lane_index = u32::from(imm) as u8;
             let Ok(lane) = LaneType::try_from(lane_index) else {
                 panic!("encountered out of bounds lane index: {}", lane_index)
             };
-            return Ok((reg, lane));
+            return Ok((slot, lane));
         }
         Err(self)
     }
@@ -212,7 +216,7 @@ impl Op {
         Self::imm16_and_imm32(value, offset_hi.0)
     }
 
-    /// Returns `Some` [`Reg`] and [`Offset64Hi`] if encoded properly.
+    /// Returns `Some` [`Slot`] and [`Offset64Hi`] if encoded properly.
     ///
     /// # Errors
     ///

crates/ir/src/error.rs

@@ -3,8 +3,8 @@ use core::fmt;
 /// An error that may be occurred when operating with some Wasmi IR primitives.
 #[derive(Debug)]
 pub enum Error {
-    /// Encountered when trying to create a [`Reg`](crate::Reg) from an out of bounds integer.
-    RegisterOutOfBounds,
+    /// Encountered when trying to create a [`Slot`](crate::Slot) from an out of bounds integer.
+    StackSlotOutOfBounds,
     /// Encountered when trying to create a [`BranchOffset`](crate::BranchOffset) from an out of bounds integer.
     BranchOffsetOutOfBounds,
     /// Encountered when trying to create a [`Comparator`](crate::Comparator) from an out of bounds integer.
@@ -16,7 +16,7 @@ pub enum Error {
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::RegisterOutOfBounds => write!(f, "register out of bounds"),
+            Self::StackSlotOutOfBounds => write!(f, "stack slot index out of bounds"),
             Self::BranchOffsetOutOfBounds => write!(f, "branch offset out of bounds"),
             Self::ComparatorOutOfBounds => write!(f, "comparator out of bounds"),
             Self::BlockFuelOutOfBounds => write!(f, "block fuel out of bounds"),