feat: replace RefNull with new FuncRef and ExternRef structs

Signed-off-by: Henry Gressmann <[email protected]>

Author: explodingcamera

CHANGELOG.md

@@ -14,6 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - **Breaking:**: New backwards-incompatible version of the twasm format (upgraded `rkyv` to 0.8.0)
+- **Breaking:**: `RefNull` has been removed and replaced with new `FuncRef` and `ExternRef` structs
 - Increased MSRV to 1.83.0
 
 ### Fixed

Cargo.lock

@@ -251,8 +251,12 @@ pub(crate) fn process_const_operators(ops: OperatorsReader<'_>) -> Result<ConstI
     assert!(matches!(ops[ops.len() - 1], wasmparser::Operator::End));
 
     match &ops[ops.len() - 2] {
-        wasmparser::Operator::RefNull { hty } => Ok(ConstInstruction::RefNull(convert_heaptype(*hty))),
-        wasmparser::Operator::RefFunc { function_index } => Ok(ConstInstruction::RefFunc(*function_index)),
+        wasmparser::Operator::RefNull { hty } => match convert_heaptype(*hty) {
+            ValType::RefFunc => Ok(ConstInstruction::RefFunc(None)),
+            ValType::RefExtern => Ok(ConstInstruction::RefExtern(None)),
+            _ => unimplemented!("Unsupported heap type: {:?}", hty),
+        },
+        wasmparser::Operator::RefFunc { function_index } => Ok(ConstInstruction::RefFunc(Some(*function_index))),
         wasmparser::Operator::I32Const { value } => Ok(ConstInstruction::I32Const(*value)),
         wasmparser::Operator::I64Const { value } => Ok(ConstInstruction::I64Const(*value)),
         wasmparser::Operator::F32Const { value } => Ok(ConstInstruction::F32Const(f32::from_bits(value.bits()))),

crates/parser/src/conversion.rs

@@ -65,6 +65,7 @@ impl Parser {
             memory64: true,
             custom_page_sizes: true,
 
+            extended_const: false,
             wide_arithmetic: false,
             gc_types: true,
             stack_switching: false,
@@ -73,7 +74,6 @@ impl Parser {
             component_model_values: false,
             component_model_more_flags: false,
             exceptions: false,
-            extended_const: false,
             gc: false,
             memory_control: false,
             relaxed_simd: false,

crates/parser/src/lib.rs

@@ -2,7 +2,7 @@ use crate::interpreter::stack::{CallFrame, Stack};
 use crate::{log, unlikely, Function};
 use crate::{Error, FuncContext, Result, Store};
 use alloc::{boxed::Box, format, string::String, string::ToString, vec, vec::Vec};
-use tinywasm_types::{FuncType, ModuleInstanceAddr, ValType, WasmValue};
+use tinywasm_types::{ExternRef, FuncRef, FuncType, ModuleInstanceAddr, ValType, WasmValue};
 
 #[derive(Debug)]
 /// A function handle
@@ -219,6 +219,18 @@ impl ToValType for f64 {
     }
 }
 
+impl ToValType for FuncRef {
+    fn to_val_type() -> ValType {
+        ValType::RefFunc
+    }
+}
+
+impl ToValType for ExternRef {
+    fn to_val_type() -> ValType {
+        ValType::RefExtern
+    }
+}
+
 macro_rules! impl_val_types_from_tuple {
     ($($t:ident),+) => {
         impl<$($t),+> ValTypesFromTuple for ($($t,)+)
@@ -251,11 +263,15 @@ impl_from_wasm_value_tuple_single!(i32);
 impl_from_wasm_value_tuple_single!(i64);
 impl_from_wasm_value_tuple_single!(f32);
 impl_from_wasm_value_tuple_single!(f64);
+impl_from_wasm_value_tuple_single!(FuncRef);
+impl_from_wasm_value_tuple_single!(ExternRef);
 
 impl_into_wasm_value_tuple_single!(i32);
 impl_into_wasm_value_tuple_single!(i64);
 impl_into_wasm_value_tuple_single!(f32);
 impl_into_wasm_value_tuple_single!(f64);
+impl_into_wasm_value_tuple_single!(FuncRef);
+impl_into_wasm_value_tuple_single!(ExternRef);
 
 impl_val_types_from_tuple!(T1);
 impl_val_types_from_tuple!(T1, T2);

crates/tinywasm/src/func.rs

@@ -1,5 +1,5 @@
 use alloc::vec::Vec;
-use tinywasm_types::{ValType, ValueCounts, ValueCountsSmall, WasmValue};
+use tinywasm_types::{ExternRef, FuncRef, ValType, ValueCounts, ValueCountsSmall, WasmValue};
 
 use crate::{interpreter::*, Result};
 
@@ -173,14 +173,8 @@ impl ValueStack {
             ValType::V128 => WasmValue::V128(self.pop()),
             ValType::F32 => WasmValue::F32(self.pop()),
             ValType::F64 => WasmValue::F64(self.pop()),
-            ValType::RefExtern => match self.pop() {
-                Some(v) => WasmValue::RefExtern(v),
-                None => WasmValue::RefNull(ValType::RefExtern),
-            },
-            ValType::RefFunc => match self.pop() {
-                Some(v) => WasmValue::RefFunc(v),
-                None => WasmValue::RefNull(ValType::RefFunc),
-            },
+            ValType::RefExtern => WasmValue::RefExtern(ExternRef::new(self.pop())),
+            ValType::RefFunc => WasmValue::RefFunc(FuncRef::new(self.pop())),
         }
     }
 

crates/tinywasm/src/interpreter/stack/value_stack.rs

@@ -1,5 +1,5 @@
 use crate::Result;
-use tinywasm_types::{LocalAddr, ValType, WasmValue};
+use tinywasm_types::{ExternRef, FuncRef, LocalAddr, ValType, WasmValue};
 
 use super::stack::{Locals, ValueStack};
 
@@ -107,14 +107,8 @@ impl TinyWasmValue {
             ValType::F32 => WasmValue::F32(f32::from_bits(self.unwrap_32())),
             ValType::F64 => WasmValue::F64(f64::from_bits(self.unwrap_64())),
             ValType::V128 => WasmValue::V128(self.unwrap_128()),
-            ValType::RefExtern => match self.unwrap_ref() {
-                Some(v) => WasmValue::RefExtern(v),
-                None => WasmValue::RefNull(ValType::RefExtern),
-            },
-            ValType::RefFunc => match self.unwrap_ref() {
-                Some(v) => WasmValue::RefFunc(v),
-                None => WasmValue::RefNull(ValType::RefFunc),
-            },
+            ValType::RefExtern => WasmValue::RefExtern(ExternRef::new(self.unwrap_ref())),
+            ValType::RefFunc => WasmValue::RefFunc(FuncRef::new(self.unwrap_ref())),
         }
     }
 }
@@ -127,8 +121,8 @@ impl From<&WasmValue> for TinyWasmValue {
             WasmValue::V128(v) => TinyWasmValue::Value128(*v),
             WasmValue::F32(v) => TinyWasmValue::Value32(v.to_bits()),
             WasmValue::F64(v) => TinyWasmValue::Value64(v.to_bits()),
-            WasmValue::RefFunc(v) | WasmValue::RefExtern(v) => TinyWasmValue::ValueRef(Some(*v)),
-            WasmValue::RefNull(_) => TinyWasmValue::ValueRef(None),
+            WasmValue::RefExtern(v) => TinyWasmValue::ValueRef(v.addr()),
+            WasmValue::RefFunc(v) => TinyWasmValue::ValueRef(v.addr()),
         }
     }
 }

crates/tinywasm/src/interpreter/values.rs

@@ -47,6 +47,7 @@ impl Module {
     /// Instantiate the module in the given store
     ///
     /// Runs the start function if it exists
+    ///
     /// If you want to run the start function yourself, use `ModuleInstance::instantiate`
     ///
     /// See <https://webassembly.github.io/spec/core/exec/modules.html#exec-instantiation>

crates/tinywasm/src/module.rs

@@ -278,12 +278,13 @@ impl Store {
 
     fn elem_addr(&self, item: &ElementItem, globals: &[Addr], funcs: &[FuncAddr]) -> Result<Option<u32>> {
         let res = match item {
-            ElementItem::Func(addr) | ElementItem::Expr(ConstInstruction::RefFunc(addr)) => {
+            ElementItem::Func(addr) | ElementItem::Expr(ConstInstruction::RefFunc(Some(addr))) => {
                 Some(funcs.get(*addr as usize).copied().ok_or_else(|| {
                     Error::Other(format!("function {addr} not found. This should have been caught by the validator"))
                 })?)
             }
-            ElementItem::Expr(ConstInstruction::RefNull(_ty)) => None,
+            ElementItem::Expr(ConstInstruction::RefFunc(None)) => None,
+            ElementItem::Expr(ConstInstruction::RefExtern(None)) => None,
             ElementItem::Expr(ConstInstruction::GlobalGet(addr)) => {
                 let addr = globals.get(*addr as usize).copied().ok_or_else(|| {
                     Error::Other(format!("global {addr} not found. This should have been caught by the validator"))
@@ -450,10 +451,14 @@ impl Store {
                     self.data.globals.get(*addr as usize).expect("global not found. This should be unreachable");
                 global.value.get()
             }
-            RefNull(t) => t.default_value().into(),
-            RefFunc(idx) => TinyWasmValue::ValueRef(Some(*module_func_addrs.get(*idx as usize).ok_or_else(|| {
-                Error::Other(format!("function {idx} not found. This should have been caught by the validator"))
-            })?)),
+            RefFunc(None) => TinyWasmValue::ValueRef(None),
+            RefExtern(None) => TinyWasmValue::ValueRef(None),
+            RefFunc(Some(idx)) => {
+                TinyWasmValue::ValueRef(Some(*module_func_addrs.get(*idx as usize).ok_or_else(|| {
+                    Error::Other(format!("function {idx} not found. This should have been caught by the validator"))
+                })?))
+            }
+            _ => return Err(Error::Other("unsupported const instruction".to_string())),
         };
         Ok(val)
     }

crates/tinywasm/src/store/mod.rs

@@ -30,8 +30,8 @@ impl TableInstance {
         let val = self.get(addr)?.addr();
 
         Ok(match self.kind.element_type {
-            ValType::RefFunc => val.map_or(WasmValue::RefNull(ValType::RefFunc), WasmValue::RefFunc),
-            ValType::RefExtern => val.map_or(WasmValue::RefNull(ValType::RefExtern), WasmValue::RefExtern),
+            ValType::RefFunc => WasmValue::RefFunc(FuncRef::new(val)),
+            ValType::RefExtern => WasmValue::RefExtern(ExternRef::new(val)),
             _ => Err(Error::UnsupportedFeature("non-ref table".into()))?,
         })
     }
@@ -211,7 +211,7 @@ mod tests {
         }
 
         match table_instance.get_wasm_val(1) {
-            Ok(WasmValue::RefNull(ValType::RefFunc)) => {}
+            Ok(WasmValue::RefFunc(f)) if f.is_null() => {}
             _ => panic!("get_wasm_val failed to return the correct WasmValue"),
         }