Simplify wasmi_ir codegen build scripts (#1831)

* use new scheme to define unary ops

* apply rustfmt

* use new scheme to define binary ops

* remove Ty::S{32,64} variants

* use IdentPrefix in more places

* remove Ty::S* SIMD variants

* dedupe Display code

* add and use From<Ty> for FieldTy

* use new scheme to define cmp+branch ops

* move Ty and FieldTy into their own module

* add MemoryOperand enum and use for load ops

* add OffsetOperand and use it in load ops

* no longer use S prefix

* remove remaining uses of S prefixed identifiers

* use new scheme to define load ops

This also necessitated new identifiers for some load operators. Generally, load operator identifiers should be more uniform now.

* merge LoadLane into LoadOp variant

* move unnecessary LoadKind params

* use {Memory,Offset}Operand in StoreOp

* use Self in match arms

* use new scheme to define store ops

This also necessitated some renamings but all in all the identifiers of store ops are more uniform now.

* refactor LoadKind type

* remove unused Ty variants

* refactor StoreKind type

* remove unused Ty variants

Author: Robbepop

crates/ir/build/display/constructors.rs

@@ -15,7 +15,6 @@ use crate::build::{
         TernaryOp,
         UnaryOp,
         V128ExtractLaneOp,
-        V128LoadLaneOp,
         V128ReplaceLaneOp,
     },
 };
@@ -112,7 +111,6 @@ impl_display_constructor! {
     TableSetOp,
     V128ReplaceLaneOp,
     V128ExtractLaneOp,
-    V128LoadLaneOp,
 }
 
 impl<const N: usize> Display for DisplayConstructor<&'_ GenericOp<N>> {

crates/ir/build/display/decode.rs

@@ -4,15 +4,18 @@ use crate::build::{
         Indent,
         Suffix,
         ident::DisplayIdent,
-        utils::{DisplayConcat, DisplaySequence, IntoDisplayMaybe as _},
+        utils::{DisplayConcat, DisplayMaybe, DisplaySequence, IntoDisplayMaybe as _},
     },
     ident::{CamelCase, Ident, SnakeCase},
     op::{
         BinaryOp,
         CmpBranchOp,
         GenericOp,
         LaneWidth,
+        LoadKind,
         LoadOp,
+        MemoryOperand,
+        OffsetOperand,
         OperandKind,
         SelectOp,
         StoreOp,
@@ -21,9 +24,9 @@ use crate::build::{
         TernaryOp,
         UnaryOp,
         V128ExtractLaneOp,
-        V128LoadLaneOp,
         V128ReplaceLaneOp,
     },
+    ty::FieldTy,
 };
 use core::fmt::{self, Display};
 
@@ -112,14 +115,30 @@ impl Display for DisplayDecode<&'_ LoadOp> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let op = self.value;
         let camel_ident = DisplayIdent::camel(op);
-        let mem0_offset16 = (op.mem0 && op.offset16)
-            .then_some("Mem0Offset16")
-            .display_maybe();
+        let mem0_suffix = match op.mem {
+            MemoryOperand::Immediate => "",
+            MemoryOperand::Mem0 => "Mem0",
+        };
+        let offset16_suffix = match op.offset {
+            OffsetOperand::Offset => "",
+            OffsetOperand::Offset16 => "Offset16",
+        };
+        let (lane_suffix, lane_param) = match op.kind {
+            LoadKind::Lane { width } => {
+                let lane_param = DisplayConcat(('<', FieldTy::from(width), '>'));
+                (
+                    Some(CamelCase(Ident::Lane)),
+                    Some(lane_param).display_maybe(),
+                )
+            }
+            _ => (None, DisplayMaybe::None),
+        };
+        let lane_suffix = lane_suffix.display_maybe();
         let result_suffix = CamelCase(Suffix(OperandKind::Slot));
         let ptr_suffix = SnakeCase(Suffix(op.ptr));
         writeln!(
             f,
-            "pub type {camel_ident} = LoadOp{mem0_offset16}_{result_suffix}{ptr_suffix};"
+            "pub type {camel_ident} = Load{lane_suffix}Op{mem0_suffix}{offset16_suffix}_{result_suffix}{ptr_suffix}{lane_param};"
         )
     }
 }
@@ -132,9 +151,14 @@ impl Display for DisplayDecode<&'_ StoreOp> {
             .laneidx_field()
             .map(|_| CamelCase(Ident::Lane))
             .display_maybe();
-        let mem0_offset16 = (op.mem0 && op.offset16)
-            .then_some("Mem0Offset16")
-            .display_maybe();
+        let mem0_suffix = match op.mem {
+            MemoryOperand::Immediate => "",
+            MemoryOperand::Mem0 => "Mem0",
+        };
+        let offset16_suffix = match op.offset {
+            OffsetOperand::Offset => "",
+            OffsetOperand::Offset16 => "Offset16",
+        };
         let ptr_suffix = CamelCase(Suffix(op.ptr));
         let value_ty = op.value_field().ty;
         let laneidx_ty = op
@@ -144,7 +168,7 @@ impl Display for DisplayDecode<&'_ StoreOp> {
             .display_maybe();
         writeln!(
             f,
-            "pub type {camel_ident} = Store{lane_ident}Op{mem0_offset16}_{ptr_suffix}<{value_ty}{laneidx_ty}>;"
+            "pub type {camel_ident} = Store{lane_ident}Op{mem0_suffix}{offset16_suffix}_{ptr_suffix}<{value_ty}{laneidx_ty}>;"
         )
     }
 }
@@ -238,20 +262,3 @@ impl Display for DisplayDecode<&'_ V128ExtractLaneOp> {
         )
     }
 }
-
-impl Display for DisplayDecode<&'_ V128LoadLaneOp> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let op = self.value;
-        let camel_ident = DisplayIdent::camel(op);
-        let result_suffix = CamelCase(Suffix(OperandKind::Slot));
-        let mem0_offset16 = (op.mem0 && op.offset16)
-            .then_some("Mem0Offset16")
-            .display_maybe();
-        let ptr_suffix = SnakeCase(Suffix(op.ptr));
-        let laneidx = op.width.to_laneidx();
-        writeln!(
-            f,
-            "pub type {camel_ident} = V128LoadLaneOp{mem0_offset16}_{result_suffix}{ptr_suffix}<{laneidx}>;"
-        )
-    }
-}

crates/ir/build/display/encode.rs

@@ -15,7 +15,6 @@ use crate::build::{
         TernaryOp,
         UnaryOp,
         V128ExtractLaneOp,
-        V128LoadLaneOp,
         V128ReplaceLaneOp,
     },
 };
@@ -114,7 +113,6 @@ impl_display_encode! {
     TableSetOp,
     V128ReplaceLaneOp,
     V128ExtractLaneOp,
-    V128LoadLaneOp,
 }
 
 impl<const N: usize> Display for DisplayEncode<&'_ GenericOp<N>> {