feat(wasm): Pack multivalue return into u64 for C ABI compatibility

Event though clang can compile C struct into multi-value return,
by nature C doesn't have notion of multi-value return.

core/wasm/accessor/number.rs

@@ -1,8 +1,9 @@
 mod index;
 mod types;
 
+use core::ffi::c_void;
 use index::current as index;
-use types::{number::Type, JSNumber, Null, Number};
+use types::{ffi::CTuple, number::Type, JSNumber, Null, Number};
 
 type Setter = unsafe fn(Number, JSNumber);
 type Getter = unsafe fn(Number) -> JSNumber;
@@ -27,6 +28,13 @@ fn accessor(ty: Type) -> (Getter, Setter) {
     }
 }
 
+#[cfg(any(target_pointer_width = "32", target_pointer_width = "16"))]
+#[export_name = "cABIaccessor"]
+fn c_accessor(ty: Type) -> CTuple<*const c_void, *const c_void> {
+    let (getter, setter) = accessor(ty);
+    CTuple::from((getter as *const c_void, setter as *const c_void))
+}
+
 #[no_mangle]
 fn set(set: fn(Number, JSNumber), this: Number, val: JSNumber) {
     set(this, val)

core/wasm/instance/number.rs

@@ -2,7 +2,7 @@ mod offset;
 mod types;
 
 use core::arch::wasm32::{memory_grow, memory_size};
-use types::{number::Type, Null, Number};
+use types::{ffi::CTuple, number::Type, Null, Number};
 
 static PAGE: usize = u16::MAX as usize + 1; // 1 page = 64KiB = 65536
 
@@ -37,3 +37,9 @@ unsafe fn array_of(ty: Type, len: u16, nullable: bool) -> (Number, Null) {
 
     (Number { addr }, Null { addr: null_addr })
 }
+
+#[cfg(any(target_pointer_width = "32", target_pointer_width = "16"))]
+#[export_name = "cABIallocate"]
+unsafe fn c_array_of(ty: Type, len: u16, nullable: bool) -> CTuple<Number, Null> {
+    CTuple::from(array_of(ty, len, nullable))
+}

core/wasm/types/mod.rs

@@ -5,3 +5,86 @@ pub use number::{JSNumber, Number};
 pub struct Null {
     pub addr: usize,
 }
+
+macro_rules! convert_between {
+    ($into:ty |$($G:ident)?| $from:ty) => {
+        impl$(<$G>)? From<$from> for $into {
+            fn from(ptr: $from) -> Self {
+                let addr = ptr as usize;
+                Self { addr }
+            }
+        }
+        impl$(<$G>)? From<$into> for $from {
+            fn from(value: $into) -> Self {
+                value.addr as Self
+            }
+        }
+    };
+}
+
+pub(crate) use convert_between;
+convert_between!(Null |T| *const T);
+convert_between!(Number |T| *const T);
+
+#[cfg(any(target_pointer_width = "32", target_pointer_width = "16"))]
+pub mod ffi {
+    use core::ffi::c_void;
+    use core::marker::PhantomData;
+
+    #[repr(transparent)]
+    pub struct CTuple<L, R> {
+        lhs: PhantomData<L>,
+        rhs: PhantomData<R>,
+
+        #[cfg(target_pointer_width = "32")]
+        pub addr: u64,
+
+        #[cfg(target_pointer_width = "16")]
+        pub addr: u32,
+    }
+
+    impl<L, R> From<(L, R)> for CTuple<L, R>
+    where
+        L: Into<*const c_void>,
+        R: Into<*const c_void>,
+    {
+        fn from(tuple: (L, R)) -> Self {
+            let (lhs, rhs) = tuple;
+            let lead = (lhs.into() as u64) << usize::BITS;
+            let trail = rhs.into() as u64;
+            Self::from(lead & trail)
+        }
+    }
+
+    impl<L, R> From<CTuple<L, R>> for (L, R)
+    where
+        L: From<*const c_void>,
+        R: From<*const c_void>,
+    {
+        fn from(ctuple: CTuple<L, R>) -> Self {
+            let lead = (ctuple.addr >> usize::BITS) as *const c_void;
+            let trail = ctuple.addr as *const c_void;
+            (L::from(lead), R::from(trail))
+        }
+    }
+
+    macro_rules! impl_From {
+        ($ty:ident, $Ty:ident<$($G:ident),+>) => {
+            impl<$($G),+> From<$ty> for $Ty<$($G),+> {
+                fn from(addr: $ty) -> Self {
+                    Self {
+                        addr,
+                        lhs: PhantomData,
+                        rhs: PhantomData,
+                    }
+                }
+            }
+        }
+    }
+
+    #[cfg(target_pointer_width = "32")]
+    impl_From!(u64, CTuple<L, R>);
+
+    #[cfg(target_pointer_width = "16")]
+    impl_From!(u32, CTuple<L, R>);
+}