Wasm2.0

.claude/settings.local.json

@@ -0,0 +1,61 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(dotnet build *)",
+      "Bash(dotnet test *)",
+      "Bash(python3 *)",
+      "Bash(xargs grep *)",
+      "Bash(python gen_tests.py)",
+      "Bash(git add *)",
+      "Bash(git commit -m ' *)",
+      "Bash(git -c gpg.program= commit -m ' *)",
+      "Bash(git config *)",
+      "Bash(python gen_float_instrs.py)",
+      "Bash(git commit *)",
+      "Bash(grep -vE \"//|^$\" /c/Users/mreed/source/repos/dotnet-webassembly/WebAssembly/SimdOpCode.cs)",
+      "Bash(grep -v \"^{$\\\\|^}$\\\\|namespace\\\\|enum\\\\|summary\\\\|<\\\\|=>\")",
+      "Bash(sort comm *)",
+      "Bash(python gen_remaining_instrs.py)",
+      "Bash(git stash *)",
+      "Bash(git remote *)",
+      "Bash(git push *)",
+      "Bash(where wast2json *)",
+      "Bash(wast2json --version)",
+      "Bash(where wabt *)",
+      "Read(//c/Program Files/**)",
+      "Read(//c/tools/**)",
+      "WebFetch(domain:github.com)",
+      "Bash(curl -L -o /tmp/wabt.zip \"https://github.com/WebAssembly/wabt/releases/download/1.0.40/wabt-1.0.40-windows-x64.zip\")",
+      "Bash(curl -sI \"https://github.com/WebAssembly/wabt/releases/latest\")",
+      "Bash(curl -sL \"https://api.github.com/repos/WebAssembly/wabt/releases/latest\")",
+      "Bash(curl -L -o /tmp/wabt.tar.gz \"https://github.com/WebAssembly/wabt/releases/download/1.0.40/wabt-1.0.40-windows-x64.tar.gz\")",
+      "Bash(tar -xzf /tmp/wabt.tar.gz -C /tmp/wabt)",
+      "Bash(/tmp/wabt/wabt-1.0.40/bin/wast2json.exe *)",
+      "Bash(curl -sL \"https://api.github.com/repos/WebAssembly/testsuite/git/trees/main?recursive=1\")",
+      "Bash(curl -sL \"https://api.github.com/repos/WebAssembly/testsuite/contents/proposals/simd\")",
+      "Bash(curl -sL \"https://api.github.com/repos/WebAssembly/testsuite/contents\")",
+      "Bash(curl -sL \"https://api.github.com/repos/WebAssembly/testsuite/commits/main\")",
+      "Bash(curl -sf \"https://raw.githubusercontent.com/WebAssembly/testsuite/51279a9d02cbba193cb25142d115388d7b83299c/bulk.wast\" -o /tmp/simd_wast/bulk.wast)",
+      "Bash(/tmp/wabt/bin/wasm-objdump.exe -d /c/Users/mreed/source/repos/dotnet-webassembly/WebAssembly.Tests/Runtime/SpecTestData/simd_align/simd_align.44.wasm)",
+      "Bash(grep -v \"message NETSDK\\\\|warning\\\\|^$\")",
+      "Bash(dotnet run *)",
+      "Bash(xxd \"WebAssembly.Tests\\\\Runtime\\\\SpecTestData\\\\traps\\\\traps.3.wasm\")",
+      "Bash(xxd *)",
+      "WebFetch(domain:raw.githubusercontent.com)",
+      "Bash(wasm-dis unreached-invalid.__TRACKED_VAR__.wasm)",
+      "Bash(wasm-objdump -d \"C:/Users/mreed/source/repos/dotnet-webassembly/WebAssembly.Tests/Runtime/SpecTestData/labels/labels.0.wasm\")",
+      "Bash(wasm2wat \"C:/Users/mreed/source/repos/dotnet-webassembly/WebAssembly.Tests/Runtime/SpecTestData/labels/labels.0.wasm\")",
+      "Bash(dotnet script -e ' *)",
+      "Bash(wasm2wat \"C:/Users/mreed/source/repos/dotnet-webassembly/WebAssembly.Tests/Runtime/SpecTestData/unreached-invalid/unreached-invalid.17.wasm\")",
+      "Bash(linking\\\\.[23]\")",
+      "Bash(bash /tmp/inspect_linking.sh)",
+      "Bash(awk '{print $NF}')",
+      "Bash(echo \"EXIT:$?\")",
+      "Bash(taskkill /F /IM testhost.exe)",
+      "Bash(taskkill //F //IM testhost.exe)",
+      "Bash(tasklist)",
+      "Bash(tasklist *)",
+      "Bash(taskkill //F //IM dotnet.exe //FI \"MEMUSAGE gt 100000\")"
+    ]
+  }
+}

CLAUDE.md

@@ -0,0 +1,87 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Commands
+
+```bash
+# Build
+dotnet build WebAssembly.sln
+
+# Test (all frameworks, run sequentially to avoid timeout flakiness)
+dotnet test --framework net8.0 && dotnet test --framework net9.0 && dotnet test --framework net10.0
+
+# Run all frameworks at once (may see flaky Loop_Compiled / Branch_LoopValue timeouts under load)
+dotnet test
+
+# Run a specific test class
+dotnet test --filter "ClassName=WebAssembly.Instructions.Int32AddTests"
+
+# Run a specific spec test
+dotnet test --filter "FullyQualifiedName~SpecTest_globals"
+
+# Build/test specific configuration (both Debug and Release are tested in CI — conditional compilation differs)
+dotnet build --configuration Release
+dotnet test --configuration Release
+```
+
+## Architecture
+
+This library reads, writes, modifies, and executes WebAssembly (WASM 2.0) files entirely in C#, using `System.Reflection.Emit` to JIT-compile WASM to .NET IL — no external interpreter.
+
+### Three layers
+
+**1. Module layer** (`WebAssembly` namespace)  
+`Module` is the root object representing a WASM binary. It holds typed collections: `Types`, `Imports`, `Functions`, `Tables`, `Memories`, `Globals`, `Exports`, `Codes`, `Data`, `Elements`, `CustomSections`. `Module.ReadFromBinary()` / `WriteToBinary()` handle serialization.
+
+**2. Instructions layer** (`WebAssembly.Instructions` namespace)  
+200+ classes, one per WASM opcode, each inheriting from `Instruction` (or `BlockTypeInstruction`/`OperandInstruction`). A `FunctionBody.Code` is a `List<Instruction>`. You build or inspect WASM logic by constructing these objects directly.  
+Prefixed opcode families use separate enums: `MiscellaneousOpCode` (0xFC prefix: non-trapping conversions, bulk memory), `SimdOpCode` (0xFD prefix: SIMD).
+
+**3. Runtime/Compilation layer** (`WebAssembly.Runtime` namespace)  
+`Compile.FromBinary<T>()` and `Compile.FromModule<T>()` are the main entry points. They take a generic abstract class `T` (whose abstract methods map to WASM exports) and an `ImportDictionary`, and return a factory that produces instances of `T`. Internally, `Runtime/Compilation/CompilationContext.cs` drives IL emission. An experimental `Compile.ToAssembly()` path (requires .NET 9+) uses `PersistedAssemblyBuilder` to emit a .NET DLL instead.
+
+### Import system
+
+`ImportDictionary` maps `"module"/"field"` names to:
+- `FunctionImport` — wraps a delegate
+- `MemoryImport` — provides linear memory
+- `GlobalImport` — provides a mutable or immutable global
+- `TableImport` — provides a function table
+
+### Test project
+
+Uses **MSTest**. Base classes (`CompilerTestBase<T>`, `ComparisonTestBase`, `ConversionTestBase`, etc.) reduce boilerplate for instruction tests. Each instruction class in `WebAssembly.Instructions/` has a corresponding `*Tests.cs` in `WebAssembly.Tests/Instructions/`. WASM spec test data lives in `WebAssembly.Tests/Runtime/SpecTestData/` — all 62 WASM spec test suites pass (712/713 tests), including 45 SIMD suites. The only permanently skipped test is `skip-stack-guard-page` which crashes the CLR test host by design.
+
+## Code style
+
+Enforced via `.editorconfig` and treated as build errors:
+- File-scoped namespaces (`namespace Foo;`)
+- Expression-bodied members preferred
+- `var` for apparent and built-in types
+- Nullable reference types enabled
+- All warnings are errors
+
+## Important constraints
+
+- **WASM 2.0.** All WASM 2.0 opcodes are implemented: non-trapping conversions (0xFC), bulk memory (0xFC), reference types (`ref.null`, `ref.is_null`, `ref.func`, `table.get/set`), typed select, and SIMD (0xFD, 200+ sub-opcodes).
+- **Strong-named assembly.** The SNK file (`Properties/WebAssembly.snk`) must remain in place; do not remove it.
+- **Multi-framework targets.** The library targets `netstandard2.0`, `net8.0`, and `net9.0`. Tests target `net8.0`, `net9.0`, and `net10.0`. CI tests both Debug and Release.
+- **Flaky timeout tests:** `Loop_Compiled` and `Branch_LoopValue` occasionally time out when all three framework test runs execute concurrently (resource contention). Run frameworks sequentially to avoid this.
+- **Tail-call optimization and stack exhaustion:** The CLR JIT tail-call-optimizes simple self-recursion into a true loop, so `EnsureSufficientExecutionStack()` never fires for those functions. The `assert_exhaustion` tests for `runaway`/`mutual-runaway` work around this by running the function on a background thread with a 100ms timeout — a function that hasn't returned within the timeout is treated as exhausted (infinite recursion = effectively exhausted per WASM spec). True stack exhaustion from deep non-tail-call recursion is caught via `InsufficientExecutionStackException`.
+
+## CLR workarounds already in place
+
+These issues were fixed and should not be regressed:
+
+- **NaN payload preservation in constants:** `Float32Constant`/`Float64Constant` emit `ldc.i4`/`ldc.i8` + `FloatHelper.UInt32BitsToFloat`/`UInt64BitsToDouble` for NaN values instead of `ldc.r4`/`ldc.r8`, which would let the JIT canonicalize the payload.
+- **NaN payload preservation in memory:** `MemoryReadInstruction` loads float data as integer bits (`Ldind_I4`/`Ldind_I8`) then reinterprets; `MemoryWriteInstruction` reinterprets float to integer bits (`FloatHelper.FloatToUInt32Bits`/`DoubleToUInt64Bits`) before storing with `Stind_I4`/`Stind_I8`.
+- **Canonical NaN from arithmetic:** `ValueTwoToOneInstruction.Compile` calls `FloatHelper.CanonicalizeFloat32`/`CanonicalizeFloat64` after float32/float64 binary ops (add/sub/mul/div) to replace non-canonical NaN payloads from sNaN inputs with the WASM canonical qNaN. `Float32DemoteFloat64` and `Float64PromoteFloat32` do the same after conversion.
+- **`rem_s` INT_MIN % -1:** `Int32RemainderSigned`/`Int64RemainderSigned` emit a helper that returns 0 when divisor is −1 (CLR `Rem` would throw `OverflowException`; WASM spec requires 0).
+- **SIMD f32x4/f64x2 min/max on .NET 8:** `Vector128.Min`/`Max` maps to `MINPS`/`MAXPS` on .NET 8, which has wrong NaN-propagation and ±0 semantics. `V128Helper.Float32x4Min/Max` and `Float64x2Min/Max` use a scalar per-lane fallback on .NET < 9 that implements WASM spec precisely.
+
+## Permanently skipped spec tests
+
+| Test | Reason |
+|------|--------|
+| `skip-stack-guard-page` | Invoking this WASM causes an uncatchable `StackOverflowException` that crashes the CLR test host |

WebAssembly.Tests/AssemblyBuilder.cs

@@ -83,6 +83,32 @@ public static TExport CreateInstance<TExport>(string name, WebAssemblyValueType?
         return compiled.Exports;
     }
 
+    public static TExport CreateInstance<TExport>(string name, IList<WebAssemblyValueType> returns, IList<WebAssemblyValueType> parameters, params Instruction[] code)
+    where TExport : class
+    {
+        Assert.IsNotNull(name);
+        Assert.IsNotNull(returns);
+        Assert.IsNotNull(parameters);
+        Assert.IsNotNull(code);
+
+        var module = new Module();
+        module.Types.Add(new WebAssemblyType
+        {
+            Returns = returns,
+            Parameters = parameters,
+        });
+        module.Functions.Add(new Function());
+        module.Exports.Add(new Export { Name = name });
+        module.Codes.Add(new FunctionBody { Code = code });
+
+        var compiled = module.ToInstance<TExport>();
+
+        Assert.IsNotNull(compiled);
+        Assert.IsNotNull(compiled.Exports);
+
+        return compiled.Exports;
+    }
+
     private static readonly Dictionary<System.Type, WebAssemblyValueType> map = new(4)
     {
         { typeof(int), WebAssemblyValueType.Int32 },

WebAssembly.Tests/CompilerTests.cs

@@ -610,9 +610,7 @@ public void Compiler_DataMemoryMinimumTooSmall()
             RawData = [2],
         });
 
-        var x = Assert.ThrowsException<MemoryAccessOutOfRangeException>(() => module.ToInstance<dynamic>());
-        Assert.AreEqual(1u, x.Offset);
-        Assert.AreEqual(1u, x.Length);
+        Assert.ThrowsException<MemoryAccessOutOfRangeException>(() => module.ToInstance<dynamic>());
     }
 
     /// <summary>

WebAssembly.Tests/DataSegmentTests.cs

@@ -0,0 +1,69 @@
+using System.IO;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace WebAssembly;
+
+/// <summary>
+/// Tests parsing and round-tripping of WASM 2.0 data segment kinds.
+/// </summary>
+[TestClass]
+public class DataSegmentTests
+{
+    /// <summary>
+    /// Tests that a kind-0 (active) data segment round-trips through Module.
+    /// </summary>
+    [TestMethod]
+    public void DataSegment_Kind0_RoundTrips()
+    {
+        var module = new Module();
+        module.Memories.Add(new Memory(1, 1));
+        module.Types.Add(new WebAssemblyType());
+        module.Functions.Add(new Function());
+        module.Exports.Add(new Export { Name = "test" });
+        module.Codes.Add(new FunctionBody { Code = [new Instructions.End()] });
+
+        var seg = new Data();
+        seg.InitializerExpression.Add(new Instructions.Int32Constant(0));
+        seg.InitializerExpression.Add(new Instructions.End());
+        seg.RawData.Add(1);
+        seg.RawData.Add(2);
+        module.Data.Add(seg);
+
+        using var ms = new MemoryStream();
+        module.WriteToBinary(ms);
+        ms.Position = 0;
+        var rt = Module.ReadFromBinary(ms);
+
+        Assert.AreEqual(1, rt.Data.Count);
+        Assert.AreEqual(0u, rt.Data[0].Kind);
+        Assert.AreEqual(2, rt.Data[0].RawData.Count);
+    }
+
+    /// <summary>
+    /// Tests that a kind-1 (passive) data segment round-trips through Module.
+    /// </summary>
+    [TestMethod]
+    public void DataSegment_Kind1_RoundTrips()
+    {
+        var module = new Module();
+        module.Memories.Add(new Memory(1, 1));
+        module.Types.Add(new WebAssemblyType());
+        module.Functions.Add(new Function());
+        module.Exports.Add(new Export { Name = "test" });
+        module.Codes.Add(new FunctionBody { Code = [new Instructions.End()] });
+
+        var seg = new Data { Kind = 1 };
+        seg.RawData.Add(99);
+        module.Data.Add(seg);
+
+        using var ms = new MemoryStream();
+        module.WriteToBinary(ms);
+        ms.Position = 0;
+        var rt = Module.ReadFromBinary(ms);
+
+        Assert.AreEqual(1, rt.Data.Count);
+        Assert.AreEqual(1u, rt.Data[0].Kind);
+        Assert.AreEqual(1, rt.Data[0].RawData.Count);
+        Assert.AreEqual((byte)99, rt.Data[0].RawData[0]);
+    }
+}

WebAssembly.Tests/Instructions/DataDropTests.cs

@@ -0,0 +1,85 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using WebAssembly.Runtime;
+
+namespace WebAssembly.Instructions;
+
+/// <summary>
+/// Tests the <see cref="DataDrop"/> instruction.
+/// </summary>
+[TestClass]
+public class DataDropTests
+{
+    /// <summary>Export that drops a segment then tries to init from it.</summary>
+    public abstract class DataDropExport
+    {
+        /// <summary>Drops segment 0.</summary>
+        public abstract void Drop();
+
+        /// <summary>Tries to memory.init from segment 0; expected to trap after drop.</summary>
+        public abstract void Init(int dst, int srcOffset, int len);
+    }
+
+    private static Module BuildModule()
+    {
+        var module = new Module();
+        module.Memories.Add(new Memory(1, 1));
+
+        var seg = new Data { Kind = 1 };
+        seg.RawData.Add(42);
+        module.Data.Add(seg);
+
+        // Type 0: () → void  (Drop)
+        module.Types.Add(new WebAssemblyType { Parameters = [], Returns = [] });
+        // Type 1: (i32, i32, i32) → void  (Init)
+        module.Types.Add(new WebAssemblyType
+        {
+            Parameters = [WebAssemblyValueType.Int32, WebAssemblyValueType.Int32, WebAssemblyValueType.Int32],
+            Returns = [],
+        });
+
+        module.Functions.Add(new Function { Type = 0 });
+        module.Functions.Add(new Function { Type = 1 });
+
+        module.Exports.Add(new Export { Name = nameof(DataDropExport.Drop), Index = 0 });
+        module.Exports.Add(new Export { Name = nameof(DataDropExport.Init), Index = 1 });
+
+        module.Codes.Add(new FunctionBody
+        {
+            Code = [new DataDrop { SegmentIndex = 0 }, new End()],
+        });
+        module.Codes.Add(new FunctionBody
+        {
+            Code =
+            [
+                new LocalGet(0),
+                new LocalGet(1),
+                new LocalGet(2),
+                new MemoryInit { SegmentIndex = 0, MemIdx = 0 },
+                new End(),
+            ],
+        });
+        return module;
+    }
+
+    /// <summary>
+    /// Tests that data.drop compiles and runs without error.
+    /// </summary>
+    [TestMethod]
+    public void DataDrop_Compiles_AndRuns()
+    {
+        var compiled = BuildModule().ToInstance<DataDropExport>();
+        compiled.Exports.Drop(); // should not throw
+    }
+
+    /// <summary>
+    /// Tests that memory.init after data.drop traps with MemoryAccessOutOfRangeException.
+    /// </summary>
+    [TestMethod]
+    public void DataDrop_MemoryInitAfterDrop_Traps()
+    {
+        var compiled = BuildModule().ToInstance<DataDropExport>();
+        compiled.Exports.Drop();
+        Assert.ThrowsException<WebAssembly.Runtime.MemoryAccessOutOfRangeException>(
+            () => compiled.Exports.Init(0, 0, 1));
+    }
+}

WebAssembly.Tests/Instructions/ElemDropTests.cs

@@ -0,0 +1,42 @@
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace WebAssembly.Instructions;
+
+/// <summary>
+/// Tests the <see cref="ElemDrop"/> instruction.
+/// </summary>
+[TestClass]
+public class ElemDropTests
+{
+    /// <summary>Export with no return.</summary>
+    public abstract class VoidExport
+    {
+        /// <summary>Runs the function.</summary>
+        public abstract void Test();
+    }
+
+    /// <summary>
+    /// Tests that elem.drop on a non-existent (active/dropped) segment compiles without error and runs as a no-op.
+    /// </summary>
+    [TestMethod]
+    public void ElemDrop_NonPassiveSegmentIsNoOp()
+    {
+        var module = new Module();
+        module.Types.Add(new WebAssemblyType { Returns = [], Parameters = [] });
+        module.Functions.Add(new Function());
+        module.Exports.Add(new Export { Name = nameof(VoidExport.Test) });
+        module.Codes.Add(new FunctionBody
+        {
+            Code =
+            [
+                new ElemDrop { SegmentIndex = 0 },
+                new End(),
+            ],
+        });
+
+        // elem.drop on an unknown segment (active or already dropped) is a no-op — should compile and run fine.
+        var instance = module.ToInstance<VoidExport>();
+        instance.Exports.Test(); // Should not throw.
+    }
+}