Allow to specify functions using untyped callbacks, which allows to specify a callback of any type without the need to use a specific delegate type.

The untyped callback will receive arguments and can set results as a span of ValueBox.

For example, this allows to define trapping functions for a module's import without having to know the function time at compile-time, similar to Wasmtime's define_unknown_imports_as_traps.

Author: kpreisser

src/Function.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Buffers;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -14,6 +15,14 @@ namespace Wasmtime
     /// </summary>
     public partial class Function : IExternal
     {
+        /// <summary>
+        /// Encapsulates an untyped method that receives arguments and can set results via a span of <see cref="ValueBox"/>.
+        /// </summary>
+        /// <param name="caller">The caller.</param>
+        /// <param name="arguments">The function arguments.</param>
+        /// <param name="results">The function results. These must be set (using the correct type) before returning, except when the method throws (in which case they are ignored).</param>
+        public delegate void UntypedCallbackDelegate(Caller caller, ReadOnlySpan<ValueBox> arguments, Span<ValueBox> results);
+
         #region FromCallback
         /// <summary>
         /// Creates a function given a callback.
@@ -57,6 +66,51 @@ out var externFunc
                 return new Function(store, externFunc, parameterKinds, resultKinds);
             }
         }
+
+        /// <summary>
+        /// Creates an function given an untyped callback.
+        /// </summary>
+        /// <param name="store">The store to create the function in.</param>
+        /// <param name="callback">The callback for when the function is invoked.</param>
+        /// <param name="parameters">The function parameter kinds.</param>
+        /// <param name="results">The function result kinds.</param>
+        public static Function FromCallback(IStore store, UntypedCallbackDelegate callback, IReadOnlyList<ValueKind> parameters, IReadOnlyList<ValueKind> results)
+        {
+            if (store is null)
+            {
+                throw new ArgumentNullException(nameof(store));
+            }
+
+            if (callback is null)
+            {
+                throw new ArgumentNullException(nameof(callback));
+            }
+
+            // Copy the lists to ensure they are not externally modified.
+            var parameterKinds = new List<ValueKind>(parameters);
+            var resultKinds = new List<ValueKind>(results);
+
+            using var funcType = GetFunctionType(parameterKinds, resultKinds);
+
+            unsafe
+            {
+                Native.WasmtimeFuncCallback func = (env, callerPtr, args, nargs, results, nresults) =>
+                {
+                    return InvokeUntypedCallback(callback, callerPtr, args, nargs, results, nresults, resultKinds);
+                };
+
+                Native.wasmtime_func_new(
+                    store.Context.handle,
+                    funcType,
+                    func,
+                    GCHandle.ToIntPtr(GCHandle.Alloc(func)),
+                    Finalizer,
+                    out var externFunc
+                );
+
+                return new Function(store, externFunc, parameterKinds, resultKinds);
+            }
+        }
         #endregion
 
         /// <summary>
@@ -563,6 +617,11 @@ private static bool IsTuple(Type type)
                 return null;
             }
 
+            return GetFunctionType(parameters, results);
+        }
+
+        internal static TypeHandle GetFunctionType(IReadOnlyList<ValueKind> parameters, IReadOnlyList<ValueKind> results)
+        {
             return new Function.TypeHandle(Function.Native.wasm_functype_new(new ValueTypeArray(parameters), new ValueTypeArray(results)));
         }
 
@@ -611,6 +670,52 @@ internal unsafe static IntPtr InvokeCallback(Delegate callback, MethodInfo callb
             }
         }
 
+        internal static unsafe IntPtr InvokeUntypedCallback(UntypedCallbackDelegate callback, IntPtr callerPtr, Value* args, UIntPtr nargs, Value* results, UIntPtr nresults, IReadOnlyList<ValueKind> resultKinds)
+        {
+            try
+            {
+                using var caller = new Caller(callerPtr);
+
+                // Rent ValueBox arrays from the array pool (as it's not possible to
+                // stackalloc a managed type).
+                var argumentsBuffer = ArrayPool<ValueBox>.Shared.Rent((int)nargs);
+                var resultsBuffer = ArrayPool<ValueBox>.Shared.Rent((int)nresults);
+
+                try
+                {
+                    var argumentsSpan = argumentsBuffer.AsSpan()[..(int)nargs];
+                    var resultsSpan = resultsBuffer.AsSpan()[..(int)nresults];
+
+                    // Clear the results span to avoid the callback being able to observe
+                    // non-deterministic values.
+                    resultsSpan.Clear();
+
+                    for (int i = 0; i < argumentsSpan.Length; i++)
+                    {
+                        argumentsSpan[i] = args[i].ToValueBox();
+                    }
+
+                    callback(caller, argumentsSpan, resultsSpan);
+
+                    for (int i = 0; i < resultsSpan.Length; i++)
+                    {
+                        results[i] = resultsSpan[i].ToValue(resultKinds[i]);
+                    }
+                }
+                finally
+                {
+                    ArrayPool<ValueBox>.Shared.Return(argumentsBuffer);
+                    ArrayPool<ValueBox>.Shared.Return(resultsBuffer);
+                }
+
+                return IntPtr.Zero;
+            }
+            catch (Exception ex)
+            {
+                return HandleCallbackException(ex);
+            }
+        }
+
         internal static unsafe IntPtr HandleCallbackException(Exception ex)
         {
             try

src/Linker.cs

@@ -389,6 +389,69 @@ public void DefineFunction(string module, string name, Delegate callback)
             }
         }
 
+        /// <summary>
+        /// Defines an function in the linker given an untyped callback.
+        /// </summary>
+        /// <remarks>Functions defined with this method are store-independent.</remarks>
+        /// <param name="module">The module name of the function.</param>
+        /// <param name="name">The name of the function.</param>
+        /// <param name="callback">The callback for when the function is invoked.</param>
+        /// <param name="parameters">The function parameter kinds.</param>
+        /// <param name="results">The function result kinds.</param>
+        public void DefineFunction(string module, string name, Function.UntypedCallbackDelegate callback, IReadOnlyList<ValueKind> parameters, IReadOnlyList<ValueKind> results)
+        {
+            if (module is null)
+            {
+                throw new ArgumentNullException(nameof(module));
+            }
+
+            if (name is null)
+            {
+                throw new ArgumentNullException(nameof(name));
+            }
+
+            if (callback is null)
+            {
+                throw new ArgumentNullException(nameof(callback));
+            }
+
+            // Copy the lists to ensure they are not externally modified.
+            var parameterKinds = new List<ValueKind>(parameters);
+            var resultKinds = new List<ValueKind>(results);
+
+            using var funcType = Function.GetFunctionType(parameterKinds, resultKinds);
+
+            unsafe
+            {
+                Function.Native.WasmtimeFuncCallback func = (env, callerPtr, args, nargs, results, nresults) =>
+                {
+                    return Function.InvokeUntypedCallback(callback, callerPtr, args, nargs, results, nresults, resultKinds);
+                };
+
+                var moduleBytes = Encoding.UTF8.GetBytes(module);
+                var nameBytes = Encoding.UTF8.GetBytes(name);
+                fixed (byte* modulePtr = moduleBytes, namePtr = nameBytes)
+                {
+                    var error = Native.wasmtime_linker_define_func(
+                        handle,
+                        modulePtr,
+                        (nuint)moduleBytes.Length,
+                        namePtr,
+                        (nuint)nameBytes.Length,
+                        funcType,
+                        func,
+                        GCHandle.ToIntPtr(GCHandle.Alloc(func)),
+                        Function.Finalizer
+                    );
+
+                    if (error != IntPtr.Zero)
+                    {
+                        throw WasmtimeException.FromOwnedError(error);
+                    }
+                }
+            }
+        }
+
         private bool TryGetExtern(StoreContext context, string module, string name, out Extern ext)
         {
             unsafe

src/Value.cs

@@ -287,11 +287,7 @@ public static Value FromObject(object? o, ValueKind kind)
                     case ValueKind.V128:
                         if (o is null)
                             throw new WasmtimeException($"The value `null` is not valid for WebAssembly type {kind}.");
-                        var bytes = (V128)o;
-                        unsafe
-                        {
-                            bytes.CopyTo(value.of.v128);
-                        }
+                        value.of.v128 = (V128)o;
                         break;
 
                     case ValueKind.ExternRef:
@@ -351,13 +347,7 @@ public static Value FromObject(object? o, ValueKind kind)
                     return of.f64;
 
                 case ValueKind.V128:
-                    unsafe
-                    {
-                        fixed (byte* v128 = of.v128)
-                        {
-                            return new V128(v128);
-                        }
-                    }
+                    return of.v128;
 
                 case ValueKind.ExternRef:
                     return ResolveExternRef();
@@ -435,6 +425,6 @@ internal unsafe struct ValueUnion
         public IntPtr externref;
 
         [FieldOffset(0)]
-        public fixed byte v128[16];
+        public V128 v128;
     }
 }

src/ValueBox.cs

@@ -30,6 +30,76 @@ internal ValueBox(object? externref)
             ExternRefObject = externref;
         }
 
+        /// <summary>
+        /// "Unbox" an <see cref="int"/> value.
+        /// </summary>
+        /// <returns></returns>
+        public int AsInt32()
+        {
+            return ConvertTo(ValueKind.Int32).Union.i32;
+        }
+
+        /// <summary>
+        /// "Unbox" a <see cref="long"/> value.
+        /// </summary>
+        /// <returns></returns>
+        public long AsInt64()
+        {
+            return ConvertTo(ValueKind.Int64).Union.i64;
+        }
+
+        /// <summary>
+        /// "Unbox" a <see cref="float"/> value.
+        /// </summary>
+        /// <returns></returns>
+        public float AsSingle()
+        {
+            return ConvertTo(ValueKind.Float32).Union.f32;
+        }
+
+        /// <summary>
+        /// "Unbox" a <see cref="double"/> value.
+        /// </summary>
+        /// <returns></returns>
+        public double AsDouble()
+        {
+            return ConvertTo(ValueKind.Float64).Union.f64;
+        }
+
+        /// <summary>
+        /// "Unbox" a <see cref="V128"/> value.
+        /// </summary>
+        /// <returns></returns>
+        public V128 AsV128()
+        {
+            ThrowIfNotOfCorrectKind(ValueKind.V128);
+
+            return Union.v128;
+        }
+
+        /// <summary>
+        /// "Unbox" a <see cref="Function"/> value.
+        /// </summary>
+        /// <returns></returns>
+        public Function AsFunction(IStore store)
+        {
+            ThrowIfNotOfCorrectKind(ValueKind.FuncRef);
+
+            return new Function(store, Union.funcref);
+        }
+
+        /// <summary>
+        /// "Unbox" a reference type.
+        /// </summary>
+        /// <returns></returns>
+        public T? As<T>()
+            where T : class
+        {
+            ThrowIfNotOfCorrectKind(ValueKind.ExternRef);
+
+            return (T?)ExternRefObject;
+        }
+
         internal Value ToValue(ValueKind convertTo)
         {
             if (convertTo != Kind)
@@ -66,6 +136,12 @@ private ValueBox ConvertTo(ValueKind convertTo)
             };
         }
 
+        private void ThrowIfNotOfCorrectKind(ValueKind expectedKind)
+        {
+            if (Kind != expectedKind)
+                throw new InvalidCastException($"Cannot convert from `{Kind}` to `{expectedKind}`");
+        }
+
         /// <summary>
         /// "Box" an int without any heap allocations
         /// </summary>
@@ -108,13 +184,7 @@ public static implicit operator ValueBox(double value)
         /// <param name="value"></param>
         public static implicit operator ValueBox(V128 value)
         {
-            var union = new ValueUnion();
-            unsafe
-            {
-                value.CopyTo(union.v128);
-            }
-
-            return new ValueBox(ValueKind.V128, union);
+            return new ValueBox(ValueKind.V128, new ValueUnion { v128 = value });
         }
 
         /// <summary>
@@ -138,7 +208,7 @@ public static explicit operator ValueBox(ReadOnlySpan<byte> value)
             var union = new ValueUnion();
             unsafe
             {
-                value.CopyTo(new Span<byte>(union.v128, 16));
+                value.CopyTo(union.v128.AsSpan());
             }
 
             return new ValueBox(ValueKind.V128, union);
@@ -338,10 +408,7 @@ public ValueBox Box(V128 value)
 
         public V128 Unbox(IStore store, ValueBox value)
         {
-            unsafe
-            {
-                return new V128(value.Union.v128);
-            }
+            return value.Union.v128;
         }
     }