chore: more superinstructions, cleanup

Signed-off-by: Henry <mail@henrygressmann.de>

Author: explodingcamera

crates/parser/src/conversion.rs

@@ -440,8 +440,7 @@ fn convert_heap_type_with_group(
                     )));
                 }
             };
-            RefType::new_concrete(nullable, index)
-                .ok_or_else(|| crate::ParseError::Other(format!("heap type index is too large: {index}")))
+            Ok(RefType::new_concrete(nullable, index))
         }
         wasmparser::HeapType::Abstract { shared: true, .. } | wasmparser::HeapType::Exact(_) => {
             Err(crate::ParseError::UnsupportedOperator(format!("Unsupported heap type: {heap:?}")))

crates/parser/src/optimize.rs

@@ -31,10 +31,7 @@ impl HostFunction {
             let canonical = *type_addrs
                 .get(module_addr as usize)
                 .ok_or_else(|| crate::Error::other("host function signature contains an invalid concrete type"))?;
-            Ok(WasmType::Ref(
-                tinywasm_types::RefType::new_concrete(ref_ty.is_nullable(), canonical)
-                    .expect("canonical type addresses fit in references"),
-            ))
+            Ok(WasmType::Ref(tinywasm_types::RefType::new_concrete(ref_ty.is_nullable(), canonical)))
         };
         let params = self.0.ty.params().iter().copied().map(resolve).collect::<Result<Vec<_>>>()?;
         let results = self.0.ty.results().iter().copied().map(resolve).collect::<Result<Vec<_>>>()?;

crates/tinywasm/src/func/host.rs

@@ -271,23 +271,20 @@ impl State {
         if expected_func {
             let Some(func_addr) = value.addr() else { return false };
             let Some(func) = self.funcs.get(func_addr as usize) else { return false };
-            let actual = RefType::new_concrete(false, func.type_addr).expect("canonical type fits");
-            return self.ref_type_is_subtype(actual, expected);
+            return self.ref_type_is_subtype(RefType::new_concrete(false, func.type_addr), expected);
         }
         if expected.abstract_heap_type() == Some(AbstractHeapType::Exn) {
             return value.addr().is_some_and(|addr| self.exceptions.get(addr as usize).is_some());
         }
         if value.is_i31() {
-            let actual = RefType::new_abstract(false, AbstractHeapType::I31);
-            return self.ref_type_is_subtype(actual, expected);
+            return self.ref_type_is_subtype(RefType::new_abstract(false, AbstractHeapType::I31), expected);
         }
         if value.is_host_any() {
-            let actual = RefType::new_abstract(false, AbstractHeapType::Any);
-            return self.ref_type_is_subtype(actual, expected);
+            return self.ref_type_is_subtype(RefType::new_abstract(false, AbstractHeapType::Any), expected);
         }
 
         let Some(object) = self.gc.get(value) else { return false };
-        let actual = RefType::new_concrete(false, object.type_addr).expect("canonical type fits");
+        let actual = RefType::new_concrete(false, object.type_addr);
         self.ref_type_is_subtype(actual, expected)
     }
 
@@ -309,12 +306,10 @@ impl State {
     pub(crate) fn value_matches_type(&self, value: WasmValue, expected: WasmType) -> bool {
         match (value, expected) {
             (WasmValue::Ref(RefValue::Null), WasmType::Ref(expected)) => expected.is_nullable(),
-            (WasmValue::Ref(RefValue::Func(func)), WasmType::Ref(expected)) => {
-                self.funcs.get(func.addr() as usize).is_some_and(|func| {
-                    let actual = RefType::new_concrete(false, func.type_addr).expect("canonical type fits");
-                    self.ref_type_is_subtype(actual, expected)
-                })
-            }
+            (WasmValue::Ref(RefValue::Func(func)), WasmType::Ref(expected)) => self
+                .funcs
+                .get(func.addr() as usize)
+                .is_some_and(|func| self.ref_type_is_subtype(RefType::new_concrete(false, func.type_addr), expected)),
             (WasmValue::Ref(RefValue::Any(_)), WasmType::Ref(expected))
                 if expected.is_func() || expected.is_extern() || expected.is_exn() =>
             {

crates/tinywasm/src/interpreter/executor.rs

@@ -6,7 +6,7 @@ use super::Store;
 pub(crate) fn canonicalize_ref_type(ty: RefType, type_addrs: &[TypeAddr]) -> RefType {
     let Some(type_addr) = ty.type_index() else { return ty };
     let canonical = *type_addrs.get(type_addr as usize).expect("validated type address should exist");
-    RefType::new_concrete(ty.is_nullable(), canonical).expect("canonical type addresses fit in references")
+    RefType::new_concrete(ty.is_nullable(), canonical)
 }
 
 pub(crate) fn canonicalize_value_type(ty: WasmType, type_addrs: &[TypeAddr]) -> WasmType {
@@ -18,12 +18,10 @@ pub(crate) fn canonicalize_value_type(ty: WasmType, type_addrs: &[TypeAddr]) ->
 
 fn map_value_type(ty: WasmType, resolve: &mut impl FnMut(TypeAddr) -> TypeAddr) -> WasmType {
     match ty {
-        WasmType::Ref(ty) if ty.is_concrete() => {
-            let addr = resolve(ty.type_index().expect("concrete reference has a type index"));
-            WasmType::Ref(
-                RefType::new_concrete(ty.is_nullable(), addr).expect("canonical type addresses fit in references"),
-            )
-        }
+        WasmType::Ref(ty) if ty.is_concrete() => WasmType::Ref(RefType::new_concrete(
+            ty.is_nullable(),
+            resolve(ty.type_index().expect("concrete reference has a type index")),
+        )),
         ty => ty,
     }
 }

crates/tinywasm/src/store/state.rs

@@ -155,7 +155,7 @@ fn imported_host_functions_resolve_concrete_types() -> Result<(), Box<dyn core::
         "#,
     )?;
     let module = tinywasm::parse_bytes(&wasm)?;
-    let concrete = RefType::new_concrete(true, 0).expect("valid module-local type index");
+    let concrete = RefType::new_concrete(true, 0);
     let host_ty = FuncType::new(&[WasmType::Ref(concrete)], &[]);
     let host = HostFunction::from_untyped(&host_ty, |_, args| {
         assert_eq!(args, &[WasmValue::Ref(RefValue::Null)]);

crates/tinywasm/src/store/types.rs

@@ -194,6 +194,8 @@ pub enum Instruction {
     BinOpLocalLocalTee64(BinOp, LocalAddr, LocalAddr, LocalAddr),
     BinOpLocalLocalTee128(BinOp128, LocalAddr, LocalAddr, LocalAddr),
     BinOpLocalConst32(BinOp, LocalAddr, i32), BinOpLocalConst64(BinOp, LocalAddr, i64),
+    BinOpGlobalConst32(BinOp, GlobalAddr, i32), BinOpGlobalConst64(BinOp, GlobalAddr, i64),
+    BinOpGlobalConst128(BinOp128, GlobalAddr, ConstIdx),
     BinOpLocalConst128(BinOp128, LocalAddr, ConstIdx),
     BinOpLocalConstSet32(BinOp, LocalAddr, i32, LocalAddr),
     BinOpLocalConstSet64(BinOp, LocalAddr, i64, LocalAddr),
@@ -258,7 +260,13 @@ pub enum Instruction {
     JumpCmpStackConst64 { target_ip: u32, imm: i64, op: CmpOp },
     JumpCmpStackLocal32 { target_ip: u32, local: LocalAddr, op: CmpOp },
     JumpCmpStackLocal64 { target_ip: u32, local: LocalAddr, op: CmpOp },
+    BinOpLocalConstJump32 { target_ip: u32, local: LocalAddr, imm: i32, op: BinOp, on_zero: bool },
+    BinOpLocalConstJumpCmpLocal32 { target_ip: u32, local: LocalAddr, imm: i32, binop: BinOp, right: LocalAddr, cmp: CmpOp },
+    BinOpStackConstTeeLocalJump32 { target_ip: u32, local: LocalAddr, imm: i32, op: BinOp, on_zero: bool },
+    BinOpGlobalConstJump32 { target_ip: u32, global: GlobalAddr, imm: i32, op: BinOp, on_zero: bool },
     IncLocalJump32 { target_ip: u32, local: LocalAddr, delta: i32, on_zero: bool },
+    IncStackTeeLocalJump32 { target_ip: u32, local: LocalAddr, delta: i32, on_zero: bool },
+    IncGlobalJump32 { target_ip: u32, global: GlobalAddr, delta: i32, on_zero: bool },
     IncLocalJumpCmpLocal32 { target_ip: u32, local: LocalAddr, delta: i32, right: LocalAddr, op: CmpOp },
     JumpCmpLocalConst32 { target_ip: u32, local: LocalAddr, imm: i32, op: CmpOp },
     JumpCmpLocalConst64 { target_ip: u32, local: LocalAddr, imm: i32, op: CmpOp },
@@ -291,9 +299,9 @@ pub enum Instruction {
 
     // > Variable Instructions
     // See <https://webassembly.github.io/spec/core/binary/instructions.html#variable-instructions>
-    GlobalGet32(GlobalAddr), LocalGet32(LocalAddr), LocalSet32(LocalAddr), LocalTee32(LocalAddr), GlobalSet32(GlobalAddr),
-    GlobalGet64(GlobalAddr), LocalGet64(LocalAddr), LocalSet64(LocalAddr), LocalTee64(LocalAddr), GlobalSet64(GlobalAddr),
-    GlobalGet128(GlobalAddr), LocalGet128(LocalAddr), LocalSet128(LocalAddr), LocalTee128(LocalAddr), GlobalSet128(GlobalAddr),
+    GlobalGet32(GlobalAddr), GlobalSet32(GlobalAddr), GlobalTee32(GlobalAddr), LocalGet32(LocalAddr), LocalSet32(LocalAddr), LocalTee32(LocalAddr),
+    GlobalGet64(GlobalAddr), GlobalSet64(GlobalAddr), GlobalTee64(GlobalAddr), LocalGet64(LocalAddr), LocalSet64(LocalAddr), LocalTee64(LocalAddr),
+    GlobalGet128(GlobalAddr), GlobalSet128(GlobalAddr), GlobalTee128(GlobalAddr), LocalGet128(LocalAddr), LocalSet128(LocalAddr), LocalTee128(LocalAddr),
 
     // > Memory Instructions
     I32Load(MemoryArg),

crates/tinywasm/tests/host_func_signature_check.rs

@@ -73,12 +73,9 @@ impl RefType {
     }
 
     #[inline]
-    pub const fn new_concrete(nullable: bool, type_index: u32) -> Option<Self> {
-        if type_index <= Self::PAYLOAD_MASK {
-            Some(Self(((nullable as u32) << 31) | Self::CONCRETE | type_index))
-        } else {
-            None
-        }
+    pub const fn new_concrete(nullable: bool, type_index: u32) -> Self {
+        assert!(type_index <= Self::PAYLOAD_MASK, "type index is too large for a reference type");
+        Self(((nullable as u32) << 31) | Self::CONCRETE | type_index)
     }
 
     #[inline]
@@ -193,7 +190,7 @@ impl ExternRef {
     #[inline]
     pub const fn try_new(addr: u32) -> Option<Self> {
         match encode_host_ref(addr) {
-            Some(raw) => Some(Self(raw)),
+            Some(encoded) => Some(Self(encoded)),
             None => None,
         }
     }
@@ -251,7 +248,7 @@ impl AnyRef {
     #[inline]
     pub const fn from_host(addr: u32) -> Option<Self> {
         match encode_host_ref(addr) {
-            Some(raw) => Some(Self(raw)),
+            Some(encoded) => Some(Self(encoded)),
             None => None,
         }
     }

crates/types/src/instructions.rs

@@ -81,7 +81,7 @@ mod tests {
 
     #[test]
     fn concrete_references_require_store_type_information() {
-        let concrete = WasmType::Ref(RefType::new_concrete(false, 0).unwrap());
+        let concrete = WasmType::Ref(RefType::new_concrete(false, 0));
 
         assert!(!WasmValue::from(FuncRef::new(0)).matches_type(concrete));
         assert!(!WasmValue::from(AnyRef::from_host(0).unwrap()).matches_type(concrete));