Upgrade to 34.0.1

Breaking changes to C-api:

* Layout and size of structs in extern.h has changed
* Trap codes have been added and the enum value for OutOfFuel has changed from 11 to 12

Due to externs having different sizes, we can no longer
used the same ConcurrentDictionary for caching externals
because the key size differs. Different dictionaries
are now used depending on the extern type.

Author: Bas Geertsema

Directory.Build.props

@@ -1,11 +1,9 @@
 <Project>
   <PropertyGroup>
-    <DevBuild Condition="'$(DevBuild)'==''">false</DevBuild>
-    <WasmtimeVersion Condition="'$(WasmtimeVersion)'==''">33.0.1</WasmtimeVersion>
+    <DevBuild Condition="'$(DevBuild)'==''">true</DevBuild>
+    <WasmtimeVersion Condition="'$(WasmtimeVersion)'==''">34.0.1</WasmtimeVersion>
     <WasmtimeDotnetVersion Condition="'$(WasmtimeDotnetVersion)'==''"></WasmtimeDotnetVersion>
-    <WasmtimePackageVersion Condition="'$(DevBuild)'=='true'">
-      $(WasmtimeVersion)$(WasmtimeDotnetVersion)-dev</WasmtimePackageVersion>
-    <WasmtimePackageVersion Condition="'$(WasmtimePackageVersion)'==''">
-      $(WasmtimeVersion)$(WasmtimeDotnetVersion)</WasmtimePackageVersion>
+    <WasmtimePackageVersion Condition="'$(DevBuild)'=='true'">$(WasmtimeVersion)$(WasmtimeDotnetVersion)-dev</WasmtimePackageVersion>
+    <WasmtimePackageVersion Condition="'$(WasmtimePackageVersion)'==''">$(WasmtimeVersion)$(WasmtimeDotnetVersion)</WasmtimePackageVersion>
   </PropertyGroup>
 </Project>

src/Externs.cs

@@ -1,41 +1,69 @@
 using System;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 
 namespace Wasmtime
 {
     [StructLayout(LayoutKind.Sequential)]
-    internal struct ExternFunc
+    internal record struct ExternFunc
     {
+        static ExternFunc() => Debug.Assert(Marshal.SizeOf(typeof(ExternFunc)) == 16);
+
         public ulong store;
-        public nuint __private;
+        public IntPtr __private;
     }
 
-    [StructLayout(LayoutKind.Sequential)]
-    internal struct ExternTable
+    [StructLayout(LayoutKind.Explicit)]
+    internal record struct ExternTable
     {
+        static ExternTable() => Debug.Assert(Marshal.SizeOf(typeof(ExternTable)) == 24);
+
+        // Use explicit offsets because the struct in the C api has extra padding
+        // due to field alignments. The total struct size is 24 bytes.
+        
+        [FieldOffset(0)]
         public ulong store;
-        public nuint __private;
+        [FieldOffset(8)]
+        public uint __private1;
+        [FieldOffset(16)]
+        public uint __private2;
     }
 
-    [StructLayout(LayoutKind.Sequential)]
-    internal struct ExternMemory
+    
+    [StructLayout(LayoutKind.Explicit)]
+    internal record struct ExternMemory
     {
+        static ExternMemory() => Debug.Assert(Marshal.SizeOf(typeof(ExternMemory)) == 24);
+
+        // Use explicit offsets because the struct in the C api has extra padding
+        // due to field alignments. The total struct size is 24 bytes.
+        
+        [FieldOffset(0)]
         public ulong store;
-        public nuint __private;
+        [FieldOffset(8)]
+        public uint __private1;
+        [FieldOffset(16)]
+        public uint __private2;
     }
 
     [StructLayout(LayoutKind.Sequential)]
-    internal struct ExternInstance
+    internal record struct ExternInstance
     {
+        static ExternInstance() => Debug.Assert(Marshal.SizeOf(typeof(ExternInstance)) == 16);
+
         public ulong store;
         public nuint __private;
     }
 
     [StructLayout(LayoutKind.Sequential)]
-    internal struct ExternGlobal
+    internal record struct ExternGlobal
     {
+        static ExternGlobal() => Debug.Assert(Marshal.SizeOf(typeof(ExternMemory)) == 24);
+
         public ulong store;
-        public nuint __private;
+        public uint __private1;
+        public uint __private2;
+        public uint __private3;
     }
 
     internal enum ExternKind : byte
@@ -50,6 +78,8 @@ internal enum ExternKind : byte
     [StructLayout(LayoutKind.Explicit)]
     internal struct ExternUnion
     {
+        static ExternUnion() => Debug.Assert(Marshal.SizeOf(typeof(ExternUnion)) == 24);
+
         [FieldOffset(0)]
         public ExternFunc func;
 
@@ -69,6 +99,8 @@ internal struct ExternUnion
     [StructLayout(LayoutKind.Sequential)]
     internal struct Extern : IDisposable
     {
+        static Extern() => Debug.Assert(Marshal.SizeOf(typeof(Extern)) == 32);
+        
         public ExternKind kind;
         public ExternUnion of;
 

src/Store.cs

@@ -339,52 +339,44 @@ private static class Native
         private object? data;
 
         private static readonly Native.Finalizer Finalizer = (p) => GCHandle.FromIntPtr(p).Free();
-
-        private readonly ConcurrentDictionary<(ExternKind kind, ulong store, nuint __private), object> _externCache = new();
+        
+        // The caches below use the external struct type as key type. These structs contain
+        // __private fields, but these are not interpreted and merely used for value comparison.
+        private readonly ConcurrentDictionary<ExternFunc, Function> _externFunctionCache = new();
+        private readonly ConcurrentDictionary<ExternMemory, Memory> _externMemoryCache = new();
+        private readonly ConcurrentDictionary<ExternGlobal, Global> _externGlobalCache = new();
 
         internal Function GetCachedExtern(ExternFunc @extern)
         {
-            // We use a `ValueTuple` as key, consisting of the extern type and the both
-            // struct fields, which works since all `Extern...` structs have the same
-            // fields.
-            // Even though the second field is named "__private", it should be Ok to
-            // access it since we won't interpret the value in any way, but just use it
-            // to compare it to other values.
-            var key = (ExternKind.Func, @extern.store, @extern.__private);
-
-            if (!_externCache.TryGetValue(key, out var func))
+            if (!_externFunctionCache.TryGetValue(@extern, out var func))
             {
                 func = new Function(this, @extern);
-                func = _externCache.GetOrAdd(key, func);
+                func = _externFunctionCache.GetOrAdd(@extern, func);
             }
 
-            return (Function)func;
+            return func;
         }
 
         internal Memory GetCachedExtern(ExternMemory @extern)
         {
-            var key = (ExternKind.Memory, @extern.store, @extern.__private);
-
-            if (!_externCache.TryGetValue(key, out var mem))
+            if (!_externMemoryCache.TryGetValue(@extern, out var mem))
             {
                 mem = new Memory(this, @extern);
-                mem = _externCache.GetOrAdd(key, mem);
+                mem = _externMemoryCache.GetOrAdd(@extern, mem);
             }
 
-            return (Memory)mem;
+            return mem;
         }
 
         internal Global GetCachedExtern(ExternGlobal @extern)
         {
-            var key = (ExternKind.Global, @extern.store, @extern.__private);
-
-            if (!_externCache.TryGetValue(key, out var global))
+            if (!_externGlobalCache.TryGetValue(@extern, out var global))
             {
                 global = new Global(this, @extern);
-                global = _externCache.GetOrAdd(key, global);
+                global = _externGlobalCache.GetOrAdd(@extern, global);
             }
 
-            return (Global)global;
+            return global;
         }
     }
 }

src/TrapException.cs

@@ -37,8 +37,53 @@ public enum TrapCode
         Unreachable = 9,
         /// <summary>The trap was the result of interrupting execution.</summary>
         Interrupt = 10,
+        /// <summary>
+        /// The trap was the result of executing a function that was `canon lift`'d, then `canonlower`'d, then called. 
+        /// </summary>
+        /// <remarks>
+        /// When the component model feature is enabled this trap represents a function that was `canon lift`'d,
+        /// then `canonlower`'d, then called. This combination of creation of a function in the component model
+        /// generates a function that always traps and, when called, produces this flavor of trap.
+        /// </remarks>
+        AlwaysTrapAdapter = 11,
         /// <summary>The trap was the result of running out of the configured fuel amount.</summary>
-        OutOfFuel = 11,
+        OutOfFuel = 12,
+        /// <summary>
+        /// The trap was the result of atomic wait operations on non-shared memory.
+        /// </summary>
+        AtomicWaitNonSharedMemory = 13,
+        /// <summary>
+        /// The trap was the result of a call to a null reference.
+        /// </summary>
+        NullReference = 14,
+        /// <summary>
+        /// The trap was the result of an attempt to access beyond the bounds of an array.
+        /// </summary>
+        ArrayOutOfBounds = 15,
+        /// <summary>
+        /// The trap was the result of an allocation that was too large to succeed.
+        /// </summary>
+        AllocationTooLarge = 16,
+        /// <summary>
+        /// The trap was the result of an attempt to cast a reference to a type that it is not an instance of.
+        /// </summary>
+        CastFailure = 17,
+        /// <summary>
+        /// The trap was the result of a component calling another component that would have violated the reentrance rules.
+        /// </summary>
+        CannotEnterComponent = 18,
+        /// <summary>
+        /// The trap was the result of an async-lifted export failing to return a valid async result.
+        /// </summary>
+        /// <remarks>
+        /// An async-lifted export failed to produce a result by calling `task.return` before returning `STATUS_DONE`
+        /// and/or after all host tasks completed.
+        /// </remarks>
+        NoAsyncResult = 19,
+        /// <summary>
+        /// The trap was the result of a Pulley opcode executed at runtime when the opcode was disabled at compile time.
+        /// </summary>
+        DisabledOpCode = 20
     }
 
     /// <summary>