Optimize call_indirect operators for (table 0) (#2019)

* add Table0 type to wasmi_ir

* add FieldTy::is_unit helper

* add FieldTy::Table0

* add specialized call_indirect variants for table 0

* adjust expected generated file sizes

* add table0 to InstanceEntityHeader

* add LoadEntity trait and impls

* make executor use new trait and impls for tables

* remove unused load_table helper

* add execution helpers for new table 0 variants

* add support for new table0 variants in the translator

* move return exec handler in front of call_{imported,indirect}

* remove unused handle of table0 cache

* remove old load utils from executor

* fix broken doc link

Author: Robbepop

crates/ir/build/display/constructors.rs

@@ -21,7 +21,6 @@ use crate::build::{
         UnaryOp,
         V128ExtractLaneOp,
     },
-    ty::FieldTy,
 };
 use core::fmt::{self, Display};
 
@@ -56,17 +55,15 @@ impl<'a, T> DisplayConstructor<&'a T> {
             fields
                 .iter()
                 .filter_map(Option::as_ref)
-                .filter(|field| !field.ty.is_reg() && !matches!(field.ty, FieldTy::Local(_))),
+                .filter(|field| !field.ty.is_reg() && !field.ty.is_unit()),
         );
         let struct_params = DisplaySequence::new(
             ", ",
             fields
                 .iter()
                 .filter_map(Option::as_ref)
                 .map(|param| match param.ty {
-                    FieldTy::RegInt | FieldTy::RegF32 | FieldTy::RegF64 | FieldTy::Local(_) => {
-                        DisplayConstructorInit::Default(*param)
-                    }
+                    ty if ty.is_unit() => DisplayConstructorInit::Default(*param),
                     _ => DisplayConstructorInit::Param(param.ident),
                 }),
         );

crates/ir/build/display/decode.rs

@@ -260,7 +260,11 @@ impl Display for DisplayDecode<&'_ CallIndirectOp> {
         let op = self.value;
         let camel_ident = DisplayIdent::camel(op);
         let index_ty = op.index_field().ty;
-        writeln!(f, "pub type {camel_ident} = CallIndirect<{index_ty}>;")
+        let table = FieldTy::from(op.table);
+        writeln!(
+            f,
+            "pub type {camel_ident} = CallIndirect<{table}, {index_ty}>;"
+        )
     }
 }
 

crates/ir/build/display/ident.rs

@@ -19,6 +19,7 @@ use crate::build::{
         SelectOp,
         StoreOp,
         TableGetOp,
+        TableOperand,
         TableSetOp,
         TernaryOp,
         UnaryOp,
@@ -525,8 +526,13 @@ impl Display for DisplayIdent<&'_ CallIndirectOp> {
             CallKind::Tail => Some(DisplayConcat((return_ident, sep))),
         }
         .display_maybe();
+        let table_suffix = match op.table {
+            TableOperand::Table0 => Some(DisplayConcat((sep, case.wrap(Ident::Table0)))),
+            TableOperand::Table => None,
+        }
+        .display_maybe();
         let index_suffix = case.wrap(Suffix(op.index));
-        write!(f, "{prefix}{ident}_{index_suffix}")
+        write!(f, "{prefix}{ident}{table_suffix}_{index_suffix}")
     }
 }
 

crates/ir/build/ident.rs

@@ -140,6 +140,7 @@ define_ident!(
     Reinterpret: reinterpret,
 
     Table: table,
+    Table0: table0,
     Memory: memory,
     Func: func,
     FuncType: func_type,

crates/ir/build/isa.rs

@@ -24,6 +24,7 @@ use crate::build::{
         StoreKind,
         StoreOp,
         TableGetOp,
+        TableOperand,
         TableSetOp,
         TernaryOp,
         TernaryOpKind,
@@ -623,10 +624,6 @@ fn add_call_ops(isa: &mut Isa) {
                 Field::new(Ident::Func, FieldTy::FuncAddr),
             ],
         )),
-        Op::from(CallIndirectOp::new(CallKind::Nested, OperandKind::Reg)),
-        Op::from(CallIndirectOp::new(CallKind::Nested, OperandKind::Slot)),
-        Op::from(CallIndirectOp::new(CallKind::Tail, OperandKind::Reg)),
-        Op::from(CallIndirectOp::new(CallKind::Tail, OperandKind::Slot)),
         Op::from(GenericOp::new(
             Ident::ReturnCallInternal,
             [
@@ -643,6 +640,14 @@ fn add_call_ops(isa: &mut Isa) {
         )),
     ];
     isa.push_ops(ops);
+    // call_indirect ops
+    for call_kind in [CallKind::Nested, CallKind::Tail] {
+        for index in [OperandKind::Reg, OperandKind::Slot] {
+            for table in [TableOperand::Table0, TableOperand::Table] {
+                isa.push_op(CallIndirectOp::new(call_kind, index, table));
+            }
+        }
+    }
 }
 
 fn add_global_ops(isa: &mut Isa) {

crates/ir/build/mod.rs

@@ -78,7 +78,7 @@ pub fn generate_code(config: &Config) -> Result<(), Error> {
 fn generate_op_rs(config: &Config, isa: &Isa, contents: &mut String) -> Result<(), Error> {
     let expected_size = match config.simd {
         true => 505_000,
-        false => 385_000,
+        false => 390_000,
     };
     write_to_buffer(contents, expected_size, |buffer| {
         write!(

crates/ir/build/op.rs

@@ -863,19 +863,38 @@ pub enum CallKind {
 pub struct CallIndirectOp {
     pub kind: CallKind,
     pub index: OperandKind,
+    pub table: TableOperand,
+}
+
+/// The table operand kind.
+#[derive(Copy, Clone)]
+pub enum TableOperand {
+    /// Always uses `(table 0)`.
+    Table0,
+    /// Encodes a 32-bit table address.
+    Table,
+}
+
+impl From<TableOperand> for FieldTy {
+    fn from(value: TableOperand) -> Self {
+        match value {
+            TableOperand::Table0 => FieldTy::Table0,
+            TableOperand::Table => FieldTy::TableAddr,
+        }
+    }
 }
 
 impl CallIndirectOp {
-    pub fn new(kind: CallKind, index: OperandKind) -> Self {
-        Self { kind, index }
+    pub fn new(kind: CallKind, index: OperandKind, table: TableOperand) -> Self {
+        Self { kind, index, table }
     }
 
     pub fn func_type_field(&self) -> Field {
         Field::new(Ident::FuncType, FieldTy::FuncType)
     }
 
     pub fn table_field(&self) -> Field {
-        Field::new(Ident::Table, FieldTy::TableAddr)
+        Field::new(Ident::Table, self.table.into())
     }
 
     pub fn params_field(&self) -> Field {

crates/ir/build/ty.rs

@@ -196,6 +196,7 @@ pub enum FieldTy {
     Offset,
     Offset16,
     BranchOffset,
+    Table0,
     MemoryAddr,
     TableAddr,
     GlobalAddr,
@@ -222,6 +223,15 @@ impl FieldTy {
     pub fn is_reg(&self) -> bool {
         matches!(self, Self::RegInt | Self::RegF32 | Self::RegF64)
     }
+
+    /// Returns `true` if the field type is like a unit type and
+    /// doesn't need to provide a value for construction.
+    pub fn is_unit(&self) -> bool {
+        matches!(
+            self,
+            Self::Local(_) | Self::Table0 | Self::RegInt | Self::RegF32 | Self::RegF64
+        )
+    }
 }
 
 impl From<Ty> for FieldTy {
@@ -297,6 +307,7 @@ impl Display for FieldTy {
             Self::Offset => "Offset",
             Self::Offset16 => "Offset16",
             Self::BranchOffset => "BranchOffset",
+            Self::Table0 => "Table0",
             Self::MemoryAddr => "MemoryAddr",
             Self::TableAddr => "TableAddr",
             Self::GlobalAddr => "GlobalAddr",

crates/ir/src/decode/mod.rs

@@ -47,6 +47,7 @@ use crate::{
     Slot,
     SlotAndReg,
     SlotSpan,
+    Table0,
     core::{ShiftAmount, TrapCode},
     index::{
         DataAddr,
@@ -266,6 +267,13 @@ impl<const N: u16> Decode for Local<N> {
     }
 }
 
+impl Decode for Table0 {
+    #[inline]
+    fn decode<D: Decoder>(_decoder: &mut D) -> Result<Self, DecodeError> {
+        Ok(Self::default())
+    }
+}
+
 impl<T> Decode for SlotAndReg<T> {
     #[inline]
     fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {

crates/ir/src/decode/op.rs

@@ -376,14 +376,14 @@ impl<I: Decode, V: Decode> Decode for TableSet<I, V> {
 }
 
 #[derive(Copy, Clone)]
-pub struct CallIndirect<I> {
-    pub table: TableAddr,
+pub struct CallIndirect<Table, Idx> {
+    pub table: Table,
     pub func_type: FuncType,
     pub params: BoundedSlotSpan,
-    pub index: I,
+    pub index: Idx,
 }
 
-impl<I: Decode> Decode for CallIndirect<I> {
+impl<Table: Decode, Idx: Decode> Decode for CallIndirect<Table, Idx> {
     fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
         Ok(Self {
             table: Decode::decode(decoder)?,