chore: add initial typed reference types types

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

Author: explodingcamera

crates/types/src/instructions.rs

@@ -1,5 +1,5 @@
 use super::{FuncAddr, GlobalAddr, LocalAddr, TableAddr, TypeAddr, ValueCounts, WasmType};
-use crate::{ConstIdx, DataAddr, ElemAddr, ExternAddr, MemAddr};
+use crate::{ConstIdx, DataAddr, ElemAddr, MemAddr, RefValue};
 
 /// Represents a memory immediate in a WebAssembly memory instruction.
 #[derive(Copy, Clone, PartialEq, Eq)]
@@ -53,8 +53,7 @@ pub enum ConstInstruction {
     F64Const(f64),
     V128Const([u8; 16]),
     GlobalGet(GlobalAddr),
-    RefFunc(Option<FuncAddr>),
-    RefExtern(Option<ExternAddr>),
+    Ref(RefValue),
     I32Add,
     I32Sub,
     I32Mul,

crates/types/src/lib.rs

@@ -408,7 +408,7 @@ impl<'a> FromIterator<&'a WasmType> for ValueCounts {
 
         for ty in iter {
             match ty {
-                WasmType::I32 | WasmType::F32 | WasmType::RefExtern | WasmType::RefFunc => counts.c32 += 1,
+                WasmType::I32 | WasmType::F32 | WasmType::Ref(_) => counts.c32 += 1,
                 WasmType::I64 | WasmType::F64 => counts.c64 += 1,
                 WasmType::V128 => counts.c128 += 1,
             }
@@ -511,7 +511,7 @@ pub struct TableType {
 
 impl TableType {
     pub const fn empty() -> Self {
-        Self::new(WasmType::RefFunc, 0, None)
+        Self::new(WasmType::Ref(RefType::FUNCREF), 0, None)
     }
 
     /// Create a table with 32-bit indices.

crates/types/src/reference.rs

@@ -1,112 +1,185 @@
-use crate::{ExternAddr, FuncAddr};
-
-const NULL_REF: u32 = u32::MAX;
+/// An abstract WebAssembly heap type.
+///
+/// This contains exactly the abstract heap types in core Wasm 3.0.
+#[repr(u8)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "archive", derive(serde::Serialize, serde::Deserialize))]
+pub enum AbstractHeapType {
+    Any,
+    Eq,
+    I31,
+    Struct,
+    Array,
+    None,
+
+    Func,
+    NoFunc,
+
+    Exn,
+    NoExn,
+
+    Extern,
+    NoExtern,
+}
 
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub struct ExternRef(u32);
-
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub struct FuncRef(u32);
+/// A WebAssembly reference type.
+///
+/// Packed as:
+///
+/// ```text
+/// [nullable:1 concrete:1 payload:30]
+/// ```
+///
+/// For concrete types, `payload` is a module type index.
+/// Otherwise, it is an [`AbstractHeapType`].
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "archive", derive(serde::Serialize, serde::Deserialize))]
+pub struct RefType(u32);
 
 #[cfg(feature = "debug")]
-impl core::fmt::Debug for ExternRef {
+impl core::fmt::Debug for RefType {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        match self.addr() {
-            Some(addr) => write!(f, "extern({addr:?})"),
-            None => write!(f, "extern(null)"),
+        if self.is_concrete() {
+            write!(f, "concrete({})", self.type_index().unwrap())
+        } else {
+            write!(f, "abstract({:?})", self.abstract_heap_type().unwrap())
         }
     }
 }
 
-#[cfg(feature = "debug")]
-impl core::fmt::Debug for FuncRef {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        match self.addr() {
-            Some(addr) => write!(f, "func({addr:?})"),
-            None => write!(f, "func(null)"),
-        }
+impl RefType {
+    const NULLABLE: u32 = 1 << 31;
+    const CONCRETE: u32 = 1 << 30;
+    const PAYLOAD_MASK: u32 = Self::CONCRETE - 1;
+
+    pub const FUNCREF: Self = Self::abstract_(true, AbstractHeapType::Func);
+    pub const EXTERNREF: Self = Self::abstract_(true, AbstractHeapType::Extern);
+    pub const EXNREF: Self = Self::abstract_(true, AbstractHeapType::Exn);
+
+    #[inline]
+    pub const fn abstract_(nullable: bool, heap_type: AbstractHeapType) -> Self {
+        Self((nullable as u32) << 31 | heap_type as u32)
     }
-}
 
-impl FuncRef {
     #[inline]
-    /// Create a new [`FuncRef`] from a [`FuncAddr`].
-    pub const fn new(addr: Option<FuncAddr>) -> Self {
-        match addr {
-            Some(addr) => Self(addr),
-            None => Self::null(),
+    pub const fn 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
         }
     }
 
     #[inline]
-    /// Create a null [`FuncRef`].
-    pub const fn null() -> Self {
-        Self(NULL_REF)
+    pub const fn is_nullable(self) -> bool {
+        self.0 & Self::NULLABLE != 0
     }
 
     #[inline]
-    /// Check if the [`FuncRef`] is null.
-    pub const fn is_null(&self) -> bool {
-        self.0 == NULL_REF
+    pub const fn is_concrete(self) -> bool {
+        self.0 & Self::CONCRETE != 0
     }
 
     #[inline]
-    /// Get the [`FuncAddr`] from the [`FuncRef`].
-    pub const fn addr(&self) -> Option<FuncAddr> {
-        if self.is_null() { None } else { Some(self.0) }
+    pub const fn type_index(self) -> Option<u32> {
+        if self.is_concrete() { Some(self.0 & Self::PAYLOAD_MASK) } else { None }
     }
 
     #[inline]
-    #[doc(hidden)]
-    pub const fn from_raw(raw: u32) -> Self {
-        Self(raw)
+    pub const fn abstract_heap_type(self) -> Option<AbstractHeapType> {
+        if self.is_concrete() {
+            return None;
+        }
+
+        match self.0 & Self::PAYLOAD_MASK {
+            0 => Some(AbstractHeapType::Any),
+            1 => Some(AbstractHeapType::Eq),
+            2 => Some(AbstractHeapType::I31),
+            3 => Some(AbstractHeapType::Struct),
+            4 => Some(AbstractHeapType::Array),
+            5 => Some(AbstractHeapType::None),
+            6 => Some(AbstractHeapType::Func),
+            7 => Some(AbstractHeapType::NoFunc),
+            8 => Some(AbstractHeapType::Exn),
+            9 => Some(AbstractHeapType::NoExn),
+            10 => Some(AbstractHeapType::Extern),
+            11 => Some(AbstractHeapType::NoExtern),
+            _ => None,
+        }
     }
 
     #[inline]
-    #[doc(hidden)]
-    pub const fn raw(&self) -> u32 {
-        self.0
+    pub const fn with_nullability(self, nullable: bool) -> Self {
+        Self((self.0 & !Self::NULLABLE) | ((nullable as u32) << 31))
     }
 }
 
-impl ExternRef {
-    #[inline]
-    /// Create a new [`ExternRef`] from an [`ExternAddr`].
-    /// Should only be used by the runtime.
-    pub const fn new(addr: Option<ExternAddr>) -> Self {
-        match addr {
-            Some(addr) => Self(addr),
-            None => Self::null(),
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "archive", derive(serde::Serialize, serde::Deserialize))]
+pub enum RefValue {
+    Null,
+    Func(FuncRef),
+    Extern(ExternRef),
+    Any(AnyRef),
+    Exn(ExnRef),
+}
+
+#[cfg(feature = "debug")]
+impl core::fmt::Debug for RefValue {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Null => write!(f, "null"),
+            Self::Func(_i) => write!(f, "func()"),
+            Self::Extern(_i) => write!(f, "extern()"),
+            Self::Any(_i) => write!(f, "any()"),
+            Self::Exn(_i) => write!(f, "exn()"),
         }
     }
+}
 
-    /// Create a null [`ExternRef`].
-    #[inline]
-    pub const fn null() -> Self {
-        Self(NULL_REF)
-    }
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "archive", derive(serde::Serialize, serde::Deserialize))]
+pub struct FuncRef(u32);
 
-    /// Check if the [`ExternRef`] is null.
-    #[inline]
-    pub const fn is_null(&self) -> bool {
-        self.0 == NULL_REF
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "archive", derive(serde::Serialize, serde::Deserialize))]
+pub struct ExternRef(u32);
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "archive", derive(serde::Serialize, serde::Deserialize))]
+pub struct ExnRef(u32);
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "archive", derive(serde::Serialize, serde::Deserialize))]
+pub struct AnyRef(u32);
+
+impl AnyRef {
+    // Odd values are inline i31s.
+    // Even values are GC object handles.
+
+    pub const fn from_i31(value: i32) -> Option<Self> {
+        if value < -(1 << 30) || value >= (1 << 30) {
+            return None;
+        }
+
+        Some(Self(((value as u32) << 1) | 1))
     }
 
-    /// Get the [`ExternAddr`] from the [`ExternRef`].
-    #[inline]
-    pub const fn addr(&self) -> Option<ExternAddr> {
-        if self.is_null() { None } else { Some(self.0) }
+    pub const fn as_i31(self) -> Option<i32> {
+        if self.0 & 1 == 1 { Some((self.0 as i32) >> 1) } else { None }
     }
 
-    #[inline]
-    #[doc(hidden)]
-    pub const fn from_raw(raw: u32) -> Self {
-        Self(raw)
+    pub const fn from_gc_addr(addr: u32) -> Option<Self> {
+        match addr.checked_add(1) {
+            Some(raw) => match raw.checked_mul(2) {
+                Some(raw) => Some(Self(raw)),
+                None => None,
+            },
+            None => None,
+        }
     }
 
-    #[inline]
-    #[doc(hidden)]
-    pub const fn raw(&self) -> u32 {
-        self.0
+    pub const fn gc_addr(self) -> Option<u32> {
+        if self.0 != 0 && self.0 & 1 == 0 { Some(self.0 / 2 - 1) } else { None }
     }
 }