From 29a587e33e97ee391831a75e5abb28f6158b865b Mon Sep 17 00:00:00 2001
From: Kelvin Nishikawa <kelnishi@gmail.com>
Date: Thu, 14 Nov 2024 23:52:12 -0800
Subject: [PATCH 1/6] Memory optimization pass

Implementing frame/label reuse
Stopping allocations where possible
---
 Wacs.Console/CommandLineOptions.cs            |   3 +
 Wacs.Console/Program.cs                       |  10 +-
 Wacs.Core/Instructions/Control.cs             |  10 +-
 Wacs.Core/Modules/Sections/FunctionSection.cs |   1 -
 Wacs.Core/Modules/Sections/StackRenderer.cs   |  14 +-
 Wacs.Core/Runtime/Delegates.cs                |   2 +-
 Wacs.Core/Runtime/ExecContext.cs              |  81 ++++----
 Wacs.Core/Runtime/Frame.cs                    |  44 +++--
 Wacs.Core/Runtime/InstructionPointer.cs       |  19 +-
 Wacs.Core/Runtime/InvokerOptions.cs           |  46 +++++
 Wacs.Core/Runtime/Label.cs                    |  41 +++--
 Wacs.Core/Runtime/OpStack.cs                  |  14 +-
 Wacs.Core/Runtime/RuntimeAttributes.cs        |  36 ++++
 Wacs.Core/Runtime/RuntimeOptions.cs           |  24 +++
 Wacs.Core/Runtime/WasmRuntime.cs              | 111 ++++-------
 Wacs.Core/Types/Expression.cs                 |   6 +-
 Wacs.Core/Types/IndexSpace.cs                 |  23 ++-
 Wacs.Core/Utilities/IReusable.cs              |  25 +++
 .../Utilities/InstructionLoggingExtension.cs  |  26 +++
 Wacs.Core/Utilities/ReusableStack.cs          | 174 ++++++++++++++++++
 Wacs.Core/Validation/WasmValidationContext.cs |   7 +-
 21 files changed, 539 insertions(+), 178 deletions(-)
 create mode 100644 Wacs.Core/Runtime/InvokerOptions.cs
 create mode 100644 Wacs.Core/Runtime/RuntimeAttributes.cs
 create mode 100644 Wacs.Core/Runtime/RuntimeOptions.cs
 create mode 100644 Wacs.Core/Utilities/IReusable.cs
 create mode 100644 Wacs.Core/Utilities/InstructionLoggingExtension.cs
 create mode 100644 Wacs.Core/Utilities/ReusableStack.cs

diff --git a/Wacs.Console/CommandLineOptions.cs b/Wacs.Console/CommandLineOptions.cs
index e885713..1e337b3 100644
--- a/Wacs.Console/CommandLineOptions.cs
+++ b/Wacs.Console/CommandLineOptions.cs
@@ -40,6 +40,9 @@ public class CommandLineOptions
 
         [Option('g', "log_gas", HelpText = "Print total instructions executed.", Default = false)]
         public bool LogGas { get; set; }
+        
+        [Option('y', "limit_gas", HelpText = "Limit dispatched instructions.", Default = 0)]
+        public int LimitGas { get; set; }
 
         [Option('n',"log_progress", HelpText = "Print a . every n instructions.", Default = -1)]
         public int LogProgressEvery { get; set; }
diff --git a/Wacs.Console/Program.cs b/Wacs.Console/Program.cs
index 9e9f563..6530867 100644
--- a/Wacs.Console/Program.cs
+++ b/Wacs.Console/Program.cs
@@ -211,6 +211,7 @@ static int RunWithOptions(CommandLineOptions opts)
 
             var callOptions = new InvokerOptions {
                 LogGas = opts.LogGas,
+                GasLimit = opts.LimitGas,
                 LogProgressEvery = opts.LogProgressEvery, 
                 LogInstructionExecution = opts.LogInstructionExecution,
                 CalculateLineNumbers = opts.CalculateLineNumbers,
@@ -292,14 +293,15 @@ static int RunWithOptions(CommandLineOptions opts)
                             return 1;
                         }
 
-                        var pVals = new List<Value>();
+                        var pVals = new Value[provided.Count];
                         for (int i = 0; i < provided.Count; i++)
                         {
-                            pVals.Add(new Value(type.ParameterTypes.Types[i], provided[i]));
+                            pVals[i] = new Value(type.ParameterTypes.Types[i], provided[i]);
                         }
-                        var result = caller(pVals.ToArray());
+
+                        Value [] result = caller(pVals);
                         
-                        System.Console.WriteLine($"Result:[{string.Join(" ",result)}]");
+                        System.Console.WriteLine($"Result:[{string.Join(" ", result)}]");
                     }
                     catch (TrapException exc)
                     {
diff --git a/Wacs.Core/Instructions/Control.cs b/Wacs.Core/Instructions/Control.cs
index eb982fe..9d7d9c5 100644
--- a/Wacs.Core/Instructions/Control.cs
+++ b/Wacs.Core/Instructions/Control.cs
@@ -120,7 +120,7 @@ public static void ExecuteInstruction(ExecContext context, Block block, ByteCode
                 //3.
                 context.Assert(funcType, $"Invalid BlockType: {block.Type}");
                 //4.
-                var label = new Label(funcType.ResultType, context.GetPointer(), inst);
+                // var label = new Label(funcType.ResultType, context.GetPointer(), inst);
                 //5.
                 context.Assert(context.OpStack.Count >= funcType.ParameterTypes.Length,
                     $"Instruction block failed. Operand Stack underflow.");
@@ -129,7 +129,7 @@ public static void ExecuteInstruction(ExecContext context, Block block, ByteCode
                     "Shared temporary stack had values left in it.");
                 context.OpStack.PopResults(funcType.ParameterTypes, ref _asideVals);
                 //7.
-                context.EnterBlock(label, block, _asideVals);
+                context.EnterBlock(block, funcType.ResultType, inst, _asideVals);
             }
             catch (IndexOutOfRangeException exc)
             {
@@ -209,7 +209,7 @@ public override void Execute(ExecContext context)
                 //3.
                 context.Assert(funcType, $"Invalid BlockType: {Block.Type}");
                 //4.
-                var label = new Label(funcType.ParameterTypes, context.GetPointer(), OpCode.Loop);
+                // var label = new Label(funcType.ParameterTypes, context.GetPointer(), OpCode.Loop);
                 //5.
                 context.Assert( context.OpStack.Count >= funcType.ParameterTypes.Length,
                     $"Instruction loop failed. Operand Stack underflow.");
@@ -218,7 +218,7 @@ public override void Execute(ExecContext context)
                     "Shared temporary stack had values left in it.");
                 context.OpStack.PopResults(funcType.ParameterTypes, ref _asideVals);
                 //7.
-                context.EnterBlock(label, Block, _asideVals);
+                context.EnterBlock(Block, funcType.ParameterTypes, OpCode.Loop, _asideVals);
             }
             catch (IndexOutOfRangeException exc)
             {
@@ -485,7 +485,7 @@ public static void ExecuteInstruction(ExecContext context, LabelIdx labelIndex)
             //5.
             context.Assert(_asideVals.Count == 0,
                 "Shared temporary stack had values left in it.");
-            context.OpStack.PopResults(label.Type, ref _asideVals);
+            context.OpStack.PopResults(label.Arity, ref _asideVals);
             //6.
             while (context.OpStack.Count > label.StackHeight)
             {
diff --git a/Wacs.Core/Modules/Sections/FunctionSection.cs b/Wacs.Core/Modules/Sections/FunctionSection.cs
index 29a09ab..073887f 100644
--- a/Wacs.Core/Modules/Sections/FunctionSection.cs
+++ b/Wacs.Core/Modules/Sections/FunctionSection.cs
@@ -199,7 +199,6 @@ public Validator()
                             var funcType = types[func.TypeIndex];
                             vContext.FunctionIndex = func.Index;
                             vContext.SetExecFrame(funcType, func.Locals);
-                            // vContext.Unreachable = false;
                             
                             //*Expression Validator also validates result types
                             var exprValidator = new Expression.Validator(funcType.ResultType);
diff --git a/Wacs.Core/Modules/Sections/StackRenderer.cs b/Wacs.Core/Modules/Sections/StackRenderer.cs
index e385500..488b68b 100644
--- a/Wacs.Core/Modules/Sections/StackRenderer.cs
+++ b/Wacs.Core/Modules/Sections/StackRenderer.cs
@@ -141,14 +141,8 @@ public FakeContext(Module module, Module.Function func)
             
             var funcType = Types[func.TypeIndex];
             var fakeType = new FunctionType(ResultType.Empty, funcType.ResultType);
-            var locals = new LocalsSpace(funcType.ParameterTypes.Types, func.Locals);
-            var execFrame = new Frame(ModuleInst, fakeType)
-            {
-                Locals = locals,
-                Index = func.Index
-            };
 
-            DummyContext = BuildDummyContext(module, ModuleInst, execFrame);
+            DummyContext = BuildDummyContext(module, ModuleInst, func);
 
             ReturnType = funcType.ResultType;
             PushControlFrame(OpCode.Block, fakeType);
@@ -226,7 +220,7 @@ public void SetUnreachable()
         public ElementsSpace Elements { get; set; }
         public DataValidationSpace Datas { get; set; }
 
-        private ExecContext BuildDummyContext(Module module, ModuleInstance moduleInst, Frame execFrame)
+        private ExecContext BuildDummyContext(Module module, ModuleInstance moduleInst, Module.Function modFunc)
         {
             var store = new Store();
             store.OpenTransaction();
@@ -266,7 +260,11 @@ private ExecContext BuildDummyContext(Module module, ModuleInstance moduleInst,
                 }
             }
             
+            var funcType = Types[modFunc.TypeIndex];
             var dummyContext = new ExecContext(store, new RuntimeAttributes { Live = false } );
+            var execFrame = dummyContext.ReserveFrame(ModuleInst, new FunctionType(ResultType.Empty, funcType.ResultType), modFunc.Index);
+            execFrame.Locals = new LocalsSpace(funcType.ParameterTypes.Types, modFunc.Locals);
+            
             dummyContext.PushFrame(execFrame);
             return dummyContext;
         }
diff --git a/Wacs.Core/Runtime/Delegates.cs b/Wacs.Core/Runtime/Delegates.cs
index 11e21f0..c8ce967 100644
--- a/Wacs.Core/Runtime/Delegates.cs
+++ b/Wacs.Core/Runtime/Delegates.cs
@@ -26,7 +26,7 @@ public static class Delegates
     {
         public delegate object GenericFunc(params object[] args);
 
-        public delegate object[] GenericFuncs(params object[] args);
+        public delegate Value[] GenericFuncs(params object[] args);
 
         public delegate Value[] StackFunc(Value[] parameters);
 
diff --git a/Wacs.Core/Runtime/ExecContext.cs b/Wacs.Core/Runtime/ExecContext.cs
index fc1ed74..9fff7d7 100644
--- a/Wacs.Core/Runtime/ExecContext.cs
+++ b/Wacs.Core/Runtime/ExecContext.cs
@@ -24,21 +24,10 @@
 using Wacs.Core.Runtime.Exceptions;
 using Wacs.Core.Runtime.Types;
 using Wacs.Core.Types;
+using Wacs.Core.Utilities;
 
 namespace Wacs.Core.Runtime
 {
-    public class RuntimeAttributes
-    {
-        public bool Configure_RefTypes = false;
-        public bool Live = true;
-
-        public int MaxCallStack = 1024;
-        public int MaxFunctionLocals = 2048;
-
-        public int MaxOpStack = 1024;
-        public IInstructionFactory InstructionFactory { get; set; } = SpecFactory.Factory;
-    }
-
     public struct ExecStat
     {
         public long duration;
@@ -61,13 +50,16 @@ public ExecContext(Store store, RuntimeAttributes? attributes = default)
         {
             Store = store;
             Attributes = attributes ?? new RuntimeAttributes();
+            FrameStack = new(Attributes.InitialCallStack, Attributes.GrowCallStack);
+            LabelStack = new(Attributes.InitialCallStack * 2, Attributes.GrowCallStack);
+            CallStack = FrameStack.GetSubStack();
             _hostReturnSequence = new InstructionSequence(
                 InstructionFactory.CreateInstruction<InstFuncReturn>(OpCode.Func)
             );
             _currentSequence = _hostReturnSequence;
             _sequenceIndex = -1;
 
-            OpStack = new(Attributes.MaxCallStack);
+            OpStack = new(Attributes.MaxOpStack);
         }
 
         public Stopwatch ProcessTimer { get; set; } = new();
@@ -77,7 +69,10 @@ public ExecContext(Store store, RuntimeAttributes? attributes = default)
 
         public Store Store { get; }
         public OpStack OpStack { get; }
-        private Stack<Frame> CallStack { get; } = new();
+
+        private ReusableStack<Frame> FrameStack { get; }
+        private SubStack<Frame> CallStack { get; }
+        private ReusableStack<Label> LabelStack { get; }
 
         public Frame Frame => CallStack.Peek();
 
@@ -97,17 +92,36 @@ public void Assert(bool assertion, string message)
                 throw new TrapException(message);
         }
 
+        public Frame ReserveFrame(
+            ModuleInstance module,
+            FunctionType type,
+            FuncIdx index
+        )
+        {
+            var frame = CallStack.Reserve();
+            frame.Module = module;
+            frame.Type = type;
+            frame.Labels = LabelStack.GetSubStack();
+            frame.Index = index;
+            frame.ContinuationAddress = GetPointer();
+            
+            return frame;
+        }
+
         public void PushFrame(Frame frame)
         {
             if (CallStack.Count >= Attributes.MaxCallStack)
                 throw new WasmRuntimeException($"Runtime call stack exhausted {CallStack.Count}");
             
             CallStack.Push(frame);
+            frame.Labels = LabelStack.GetSubStack();
         }
 
         public Frame PopFrame()
         {
-            return CallStack.Pop();
+            var frame = CallStack.Pop();
+            frame.Labels.Drop();
+            return frame;
         }
 
         public void ResetStack(Label label)
@@ -151,10 +165,11 @@ public void RewindSequence()
         public InstructionPointer GetPointer() => new(_currentSequence, _sequenceIndex);
 
         // @Spec 4.4.9.1. Enter Block
-        public void EnterBlock(Label label, Block block, Stack<Value> vals)
+        public void EnterBlock(Block block, ResultType resultType, ByteCode inst, Stack<Value> vals)
         {
-            label.StackHeight = OpStack.Count;
             OpStack.Push(vals);
+            var label = Frame.ReserveLabel();
+            label.Set(resultType, this.GetPointer(), inst, OpStack.Count);
             Frame.Labels.Push(label);
             //Sets the Pointer to the start of the block sequence
             EnterSequence(block.Instructions);
@@ -174,7 +189,7 @@ public void Invoke(FuncAddr addr)
         {
             //1.
             Assert( Store.Contains(addr),
-                 $"Failure in Function Invocation. Address does not exist {addr}");
+                $"Failure in Function Invocation. Address does not exist {addr}");
             //2.
             var funcInst = Store[addr];
             switch (funcInst)
@@ -198,19 +213,17 @@ private void Invoke(FunctionInstance wasmFunc, FuncIdx idx)
             //var seq = wasmFunc.Definition.Body;
             //6.
             Assert( OpStack.Count >= funcType.ParameterTypes.Arity,
-                 $"Function invocation failed. Operand Stack underflow.");
+                $"Function invocation failed. Operand Stack underflow.");
             //7.
             Assert(_asideVals.Count == 0,
                 $"Shared temporary stack had values left in it.");
             OpStack.PopResults(funcType.ParameterTypes, ref _asideVals);
             //8.
-            var frame = new Frame(wasmFunc.Module, funcType)
-            {
-                ContinuationAddress = GetPointer(),
-                Locals = new LocalsSpace(funcType.ParameterTypes.Types, t),
-                Index = idx,
-                FuncId = wasmFunc.Id,
-            };
+            //Push the frame and operate on the frame on the stack.
+            var frame = ReserveFrame(wasmFunc.Module, funcType, idx);
+            frame.Locals = new LocalsSpace(funcType.ParameterTypes.Types, t);
+            // frame.FuncId = wasmFunc.Id;
+                
             int li = 0;
             int localCount = funcType.ParameterTypes.Arity + t.Length;
             //Load parameters
@@ -227,11 +240,10 @@ private void Invoke(FunctionInstance wasmFunc, FuncIdx idx)
 
             //9.
             PushFrame(frame);
+            
             //10.
-            var label = new Label(funcType.ResultType, GetPointer(), OpCode.Expr)
-            {
-                StackHeight = OpStack.Count,
-            };
+            var label = frame.ReserveLabel();
+            label.Set(funcType.ResultType, GetPointer(), OpCode.Expr, OpStack.Count);
             frame.Labels.Push(label);
             EnterSequence(wasmFunc.Definition.Body.Instructions);
         }
@@ -255,7 +267,7 @@ public void FunctionReturn()
         {
             //3.
             Assert( OpStack.Count >= Frame.Arity,
-                 $"Function Return failed. Stack did not contain return values");
+                $"Function Return failed. Stack did not contain return values");
             //4. Since we have a split stack, we can leave the results in place.
             // var vals = OpStack.PopResults(Frame.Type.ResultType);
             //5.
@@ -311,13 +323,6 @@ public void FunctionReturn()
             return ascent.Select(a => a).ToList();
         }
 
-        public void SetFrame(Frame frame)
-        {
-            while (CallStack.Count > 0)
-                CallStack.Pop();
-            CallStack.Push(frame);
-        }
-
         public void ResetStats()
         {
             Stats.Clear();
diff --git a/Wacs.Core/Runtime/Frame.cs b/Wacs.Core/Runtime/Frame.cs
index d9b5e5f..f355ea8 100644
--- a/Wacs.Core/Runtime/Frame.cs
+++ b/Wacs.Core/Runtime/Frame.cs
@@ -14,45 +14,53 @@
 //  * limitations under the License.
 //  */
 
-using System.Collections.Generic;
 using Wacs.Core.OpCodes;
 using Wacs.Core.Runtime.Types;
 using Wacs.Core.Types;
+using Wacs.Core.Utilities;
 
 namespace Wacs.Core.Runtime
 {
-    public class Frame
+    public class Frame : IReusable<Frame>
     {
-        public readonly Stack<Label> Labels = new();
-
-        public Frame(ModuleInstance moduleInstance, FunctionType type) =>
-            (Module, Type) = (moduleInstance, type);
-
-        public ModuleInstance Module { get; }
-        public LocalsSpace Locals { get; set; } = new();
+        public SubStack<Label> Labels;
+        public ModuleInstance Module { get; set; } = null!;
+        public LocalsSpace Locals { get; set; } = null!;
         public InstructionPointer ContinuationAddress { get; set; } = InstructionPointer.Nil;
-
-        public Label Label => Labels.Peek();
-
-        public FunctionType Type { get; }
-
+        public FunctionType Type { get; set; } = null!;
         public FuncIdx Index { get; set; }
-
         public string FuncId { get; set; } = "";
 
+        public Label Label => Labels.Peek();
         public int Arity => (int)Type.ResultType.Length;
 
-        //For validation
-        public bool ConditionallyReachable { get; set; }
+        public void Clear()
+        {
+            Labels = default;
+            Module = default!;
+            Locals = default!;
+            ContinuationAddress = default;
+            Type = default!;
+            Index = default!;
+            FuncId = string.Empty;
+        }
+
+        public bool Equals(Frame other)
+        {
+            return ReferenceEquals(this, other);
+        }
 
         public bool Contains(LabelIdx index) =>
             index.Value < Labels.Count;
 
+        public Label ReserveLabel() => Labels.Reserve();
+
         public void ForceLabels(int depth)
         {
             while (Labels.Count < depth)
             {
-                var fakeLabel = new Label(ResultType.Empty, InstructionPointer.Nil, OpCode.Nop);
+                var fakeLabel = ReserveLabel();
+                fakeLabel.Set(ResultType.Empty, InstructionPointer.Nil, OpCode.Nop, 0);
                 Labels.Push(fakeLabel);
             }
 
diff --git a/Wacs.Core/Runtime/InstructionPointer.cs b/Wacs.Core/Runtime/InstructionPointer.cs
index 7aa4a74..b44d124 100644
--- a/Wacs.Core/Runtime/InstructionPointer.cs
+++ b/Wacs.Core/Runtime/InstructionPointer.cs
@@ -14,9 +14,11 @@
 //  * limitations under the License.
 //  */
 
+using System;
+
 namespace Wacs.Core.Runtime
 {
-    public struct InstructionPointer
+    public readonly struct InstructionPointer : IEquatable<InstructionPointer>
     {
         public readonly InstructionSequence Sequence;
         public readonly int Index;
@@ -27,5 +29,20 @@ public InstructionPointer(InstructionSequence seq, int index) =>
         public static InstructionPointer Nil = new(InstructionSequence.Empty, 0);
 
         public InstructionPointer Previous => new(Sequence, Index - 1);
+
+        public bool Equals(InstructionPointer other)
+        {
+            return ReferenceEquals(Sequence, other.Sequence) && Index == other.Index;
+        }
+
+        public override bool Equals(object? obj)
+        {
+            return obj is InstructionPointer other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Sequence, Index);
+        }
     }
 }
\ No newline at end of file
diff --git a/Wacs.Core/Runtime/InvokerOptions.cs b/Wacs.Core/Runtime/InvokerOptions.cs
new file mode 100644
index 0000000..e15565a
--- /dev/null
+++ b/Wacs.Core/Runtime/InvokerOptions.cs
@@ -0,0 +1,46 @@
+// /*
+//  * Copyright 2024 Kelvin Nishikawa
+//  *
+//  * Licensed under the Apache License, Version 2.0 (the "License");
+//  * you may not use this file except in compliance with the License.
+//  * You may obtain a copy of the License at
+//  *
+//  *     http://www.apache.org/licenses/LICENSE-2.0
+//  *
+//  * Unless required by applicable law or agreed to in writing, software
+//  * distributed under the License is distributed on an "AS IS" BASIS,
+//  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  * See the License for the specific language governing permissions and
+//  * limitations under the License.
+//  */
+
+using System;
+
+namespace Wacs.Core.Runtime
+{
+    [Flags]
+    public enum InstructionLogging
+    {
+        None = 0,
+        Calls = 1 << 0,
+        Blocks = 1 << 1,
+        Branches = 1 << 2,
+        Computes = 1 << 3,
+        Binds = 1 << 4,
+        
+        Control = Calls | Blocks | Branches | Binds,
+        All = Calls | Blocks | Branches | Computes | Binds,
+    }
+    
+    public class InvokerOptions
+    {
+        public bool CalculateLineNumbers = false;
+
+        public bool CollectStats = false;
+        public int GasLimit = 0;
+        public bool LogGas = false;
+        public InstructionLogging LogInstructionExecution = InstructionLogging.None;
+        public int LogProgressEvery = -1;
+        public bool ShowPath = false;
+    }
+}
\ No newline at end of file
diff --git a/Wacs.Core/Runtime/Label.cs b/Wacs.Core/Runtime/Label.cs
index 36fac7f..60d9875 100644
--- a/Wacs.Core/Runtime/Label.cs
+++ b/Wacs.Core/Runtime/Label.cs
@@ -16,27 +16,42 @@
 
 using Wacs.Core.OpCodes;
 using Wacs.Core.Types;
+using Wacs.Core.Utilities;
 
 namespace Wacs.Core.Runtime
 {
-    public struct Label
+    public class Label : IReusable<Label>
     {
         public int StackHeight;
+        
+        public int Arity;
 
-        public Label(ResultType type, InstructionPointer continuationAddress, ByteCode inst)
+        public ByteCode Instruction;
+
+        public InstructionPointer ContinuationAddress;
+
+        public void Set(ResultType type, InstructionPointer address, ByteCode inst, int stackHeight)
         {
-            Type = type;
-            ContinuationAddress = continuationAddress;
+            StackHeight = stackHeight;
+            Arity = type.Arity;
             Instruction = inst;
-            StackHeight = 0;
+            ContinuationAddress = address;
+        }
+        
+        public void Clear()
+        {
+            Arity = default;
+            Instruction = default;
+            ContinuationAddress = default;
+            StackHeight = default;
+        }
+        
+        public bool Equals(Label other)
+        {
+            return StackHeight == other.StackHeight &&
+                   Arity == other.Arity &&
+                   Instruction.Equals(other.Instruction) &&
+                   ContinuationAddress.Equals(other.ContinuationAddress);
         }
-
-        public ResultType Type { get; }
-
-        public int Arity => Type.Arity;
-
-        public ByteCode Instruction { get; }
-
-        public InstructionPointer ContinuationAddress { get; } // The instruction index to jump to on branch
     }
 }
\ No newline at end of file
diff --git a/Wacs.Core/Runtime/OpStack.cs b/Wacs.Core/Runtime/OpStack.cs
index 7bb1d54..60bfa39 100644
--- a/Wacs.Core/Runtime/OpStack.cs
+++ b/Wacs.Core/Runtime/OpStack.cs
@@ -98,9 +98,11 @@ public Value PopType(ValType type)
 
         public Value Peek() => _stack.Peek();
 
-        public void PopResults(ResultType type, ref Stack<Value> results)
+        public void PopResults(ResultType type, ref Stack<Value> results) => PopResults(type.Arity, ref results);
+
+        public void PopResults(int arity, ref Stack<Value> results)
         {
-            for (int i = 0, l = type.Arity; i < l; ++i)
+            for (int i = 0, l = arity; i < l; ++i)
             {
                 //We could check the types here, but the spec just says to YOLO it.
                 results.Push(PopAny());
@@ -115,6 +117,14 @@ public void PopScalars(ResultType type, Span<object> targetBuf)
             }
         }
 
+        public void PopScalars(ResultType type, Span<Value> targetBuf)
+        {
+            for (int i = type.Arity - 1; i >= 0; --i)
+            {
+                targetBuf[i] = PopAny();
+            }
+        }
+
         public void PushScalars(ResultType type, object[] scalars)
         {
             for (int i = 0, l = type.Arity; i < l; ++i)
diff --git a/Wacs.Core/Runtime/RuntimeAttributes.cs b/Wacs.Core/Runtime/RuntimeAttributes.cs
new file mode 100644
index 0000000..3776577
--- /dev/null
+++ b/Wacs.Core/Runtime/RuntimeAttributes.cs
@@ -0,0 +1,36 @@
+// /*
+//  * Copyright 2024 Kelvin Nishikawa
+//  *
+//  * Licensed under the Apache License, Version 2.0 (the "License");
+//  * you may not use this file except in compliance with the License.
+//  * You may obtain a copy of the License at
+//  *
+//  *     http://www.apache.org/licenses/LICENSE-2.0
+//  *
+//  * Unless required by applicable law or agreed to in writing, software
+//  * distributed under the License is distributed on an "AS IS" BASIS,
+//  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  * See the License for the specific language governing permissions and
+//  * limitations under the License.
+//  */
+
+using Wacs.Core.Instructions;
+
+namespace Wacs.Core.Runtime
+{
+    public class RuntimeAttributes
+    {
+        public bool Configure_RefTypes = false;
+        public bool Live = true;
+
+        public int InitialCallStack = 512;
+        public int GrowCallStack = 512;
+        public int MaxCallStack = 2048;
+        
+        public int MaxFunctionLocals = 2048;
+        
+        public int MaxOpStack = 1024;
+        public IInstructionFactory InstructionFactory { get; set; } = SpecFactory.Factory;
+    }
+
+}
\ No newline at end of file
diff --git a/Wacs.Core/Runtime/RuntimeOptions.cs b/Wacs.Core/Runtime/RuntimeOptions.cs
new file mode 100644
index 0000000..ff9acef
--- /dev/null
+++ b/Wacs.Core/Runtime/RuntimeOptions.cs
@@ -0,0 +1,24 @@
+// /*
+//  * Copyright 2024 Kelvin Nishikawa
+//  *
+//  * Licensed under the Apache License, Version 2.0 (the "License");
+//  * you may not use this file except in compliance with the License.
+//  * You may obtain a copy of the License at
+//  *
+//  *     http://www.apache.org/licenses/LICENSE-2.0
+//  *
+//  * Unless required by applicable law or agreed to in writing, software
+//  * distributed under the License is distributed on an "AS IS" BASIS,
+//  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  * See the License for the specific language governing permissions and
+//  * limitations under the License.
+//  */
+
+namespace Wacs.Core.Runtime
+{
+    public class RuntimeOptions
+    {
+        public bool SkipModuleValidation = false;
+        public bool SkipStartFunction = false;
+    }
+}
\ No newline at end of file
diff --git a/Wacs.Core/Runtime/WasmRuntime.cs b/Wacs.Core/Runtime/WasmRuntime.cs
index 76dc40c..f8c5292 100644
--- a/Wacs.Core/Runtime/WasmRuntime.cs
+++ b/Wacs.Core/Runtime/WasmRuntime.cs
@@ -33,38 +33,6 @@
 
 namespace Wacs.Core.Runtime
 {
-    public class RuntimeOptions
-    {
-        public bool SkipModuleValidation = false;
-        public bool SkipStartFunction = false;
-    }
-
-    [Flags]
-    public enum InstructionLogging
-    {
-        None = 0,
-        Calls = 1 << 0,
-        Blocks = 1 << 1,
-        Branches = 1 << 2,
-        Computes = 1 << 3,
-        Binds = 1 << 4,
-        
-        Control = Calls | Blocks | Branches | Binds,
-        All = Calls | Blocks | Branches | Computes | Binds,
-    }
-
-    public class InvokerOptions
-    {
-        public bool CalculateLineNumbers = false;
-
-        public bool CollectStats = false;
-        public int GasLimit = 0;
-        public bool LogGas = false;
-        public InstructionLogging LogInstructionExecution = InstructionLogging.None;
-        public int LogProgressEvery = -1;
-        public bool ShowPath = false;
-    }
-
     public class WasmRuntime
     {
         private static readonly MethodInfo GenericFuncsInvoke = typeof(Delegates.GenericFuncs).GetMethod("Invoke")!;
@@ -243,7 +211,7 @@ public FunctionType GetFunctionType(FuncAddr funcAddr)
         private Delegates.GenericFuncs CreateInvoker(FuncAddr funcAddr, InvokerOptions options)
         {
             return GenericDelegate;
-            object[] GenericDelegate(params object[] args)
+            Value[] GenericDelegate(params object[] args)
             {
                 var funcInst = Context.Store[funcAddr];
                 var funcType = funcInst.Type;
@@ -288,7 +256,7 @@ object[] GenericDelegate(params object[] args)
                 if (options.CollectStats) PrintStats();
                 if (options.LogGas) Console.Error.WriteLine($"Process used {steps} gas. {Context.ProcessTimer.Elapsed}");
 
-                object[] results = new object[funcType.ResultType.Arity];
+                Value[] results = new Value[funcType.ResultType.Arity];
                 var span = results.AsSpan();
                 Context.OpStack.PopScalars(funcType.ResultType, span);
 
@@ -312,9 +280,9 @@ public TDelegate CreateInvoker<TDelegate>(FuncAddr funcAddr, InvokerOptions? opt
             {
                 try
                 {
-                    object[] results = funcType.ParameterTypes.Arity == 0
+                    Value[] results = funcType.ParameterTypes.Arity == 0
                         ? inner()
-                        : (object[])GenericFuncsInvoke.Invoke(inner, args);
+                        : (Value[])GenericFuncsInvoke.Invoke(inner, args);
                     if (funcType.ResultType.Types.Length == 1)
                         return results[0];
                     return results;
@@ -333,18 +301,16 @@ public Delegates.StackFunc CreateStackInvoker(FuncAddr funcAddr, InvokerOptions?
         {
             options ??= new InvokerOptions();
             var invoker = CreateInvoker(funcAddr, options);
-            return parameters =>
+            var funcInst = Context.Store[funcAddr];
+            var funcType = funcInst.Type;
+            object[] p = new object[funcType.ParameterTypes.Arity];
+            
+            return valueParams =>
             {
-                var funcInst = Context.Store[funcAddr];
-                var funcType = funcInst.Type;
-                object[] results = invoker(parameters.Select(v => (object)v).ToArray());
-                var stackResult = new Value[funcType.ResultType.Arity];
-                for (int i = 0, l = funcType.ResultType.Arity; i < l; ++i)
-                {
-                    stackResult[i] = new Value(funcType.ResultType.Types[i], results[i]);
-                }
+                for (int i = 0; i < funcType.ParameterTypes.Arity; ++i)
+                    p[i] = valueParams[i];
 
-                return stackResult;
+                return invoker(p);
             };
         }
 
@@ -378,7 +344,7 @@ public bool ProcessThread(InvokerOptions options, int steps)
                     inst.Execute(Context);
                 }
 
-                if (options.LogInstructionExecution.HasFlag(InstructionLogging.Computes))
+                if (options.LogInstructionExecution.Has(InstructionLogging.Computes))
                 {
                     LogPostInstruction(options, inst);
                 }
@@ -452,30 +418,30 @@ private void LogPreInstruction(InvokerOptions options, IInstruction inst)
                 case var _ when IInstruction.IsVar(inst): break;
                 case var _ when IInstruction.IsLoad(inst): break;
                 
-                case OpCode.Call when options.LogInstructionExecution.HasFlag(InstructionLogging.Binds) && IInstruction.IsBound(Context, inst):
-                case OpCode.CallIndirect when options.LogInstructionExecution.HasFlag(InstructionLogging.Binds) && IInstruction.IsBound(Context, inst):
-                // case OpCode.CallRef when options.LogInstructionExecution.HasFlag(InstructionLogging.Binds) && IInstruction.IsBound(Context, inst):
+                case OpCode.Call when options.LogInstructionExecution.Has(InstructionLogging.Binds) && IInstruction.IsBound(Context, inst):
+                case OpCode.CallIndirect when options.LogInstructionExecution.Has(InstructionLogging.Binds) && IInstruction.IsBound(Context, inst):
+                // case OpCode.CallRef when options.LogInstructionExecution.Has(InstructionLogging.Binds) && IInstruction.IsBound(Context, inst):
                 
-                case OpCode.Call when options.LogInstructionExecution.HasFlag(InstructionLogging.Calls):
-                case OpCode.CallIndirect when options.LogInstructionExecution.HasFlag(InstructionLogging.Calls):
-                // case OpCode.CallRef when options.LogInstructionExecution.HasFlag(InstructionLogging.Calls):
-                case OpCode.Return when options.LogInstructionExecution.HasFlag(InstructionLogging.Calls):
-                case OpCode.ReturnCallIndirect when options.LogInstructionExecution.HasFlag(InstructionLogging.Calls):
-                case OpCode.ReturnCall when options.LogInstructionExecution.HasFlag(InstructionLogging.Calls):
-                case OpCode.End when options.LogInstructionExecution.HasFlag(InstructionLogging.Calls) && Context.GetEndFor() == OpCode.Func:
+                case OpCode.Call when options.LogInstructionExecution.Has(InstructionLogging.Calls):
+                case OpCode.CallIndirect when options.LogInstructionExecution.Has(InstructionLogging.Calls):
+                // case OpCode.CallRef when options.LogInstructionExecution.Has(InstructionLogging.Calls):
+                case OpCode.Return when options.LogInstructionExecution.Has(InstructionLogging.Calls):
+                case OpCode.ReturnCallIndirect when options.LogInstructionExecution.Has(InstructionLogging.Calls):
+                case OpCode.ReturnCall when options.LogInstructionExecution.Has(InstructionLogging.Calls):
+                case OpCode.End when options.LogInstructionExecution.Has(InstructionLogging.Calls) && Context.GetEndFor() == OpCode.Func:
                         
-                case OpCode.Block when options.LogInstructionExecution.HasFlag(InstructionLogging.Blocks):
-                case OpCode.Loop when options.LogInstructionExecution.HasFlag(InstructionLogging.Blocks):
-                case OpCode.If when options.LogInstructionExecution.HasFlag(InstructionLogging.Blocks):
-                case OpCode.Else when options.LogInstructionExecution.HasFlag(InstructionLogging.Blocks):
-                case OpCode.End when options.LogInstructionExecution.HasFlag(InstructionLogging.Blocks) && Context.GetEndFor() == OpCode.Block:
+                case OpCode.Block when options.LogInstructionExecution.Has(InstructionLogging.Blocks):
+                case OpCode.Loop when options.LogInstructionExecution.Has(InstructionLogging.Blocks):
+                case OpCode.If when options.LogInstructionExecution.Has(InstructionLogging.Blocks):
+                case OpCode.Else when options.LogInstructionExecution.Has(InstructionLogging.Blocks):
+                case OpCode.End when options.LogInstructionExecution.Has(InstructionLogging.Blocks) && Context.GetEndFor() == OpCode.Block:
                             
-                case OpCode.Br when options.LogInstructionExecution.HasFlag(InstructionLogging.Branches):
-                case OpCode.BrIf when options.LogInstructionExecution.HasFlag(InstructionLogging.Branches):
-                case OpCode.BrTable when options.LogInstructionExecution.HasFlag(InstructionLogging.Branches):
+                case OpCode.Br when options.LogInstructionExecution.Has(InstructionLogging.Branches):
+                case OpCode.BrIf when options.LogInstructionExecution.Has(InstructionLogging.Branches):
+                case OpCode.BrTable when options.LogInstructionExecution.Has(InstructionLogging.Branches):
                 
-                case var _ when IInstruction.IsBranch(lastInstruction) && options.LogInstructionExecution.HasFlag(InstructionLogging.Branches):
-                case var _ when options.LogInstructionExecution.HasFlag(InstructionLogging.Computes):
+                case var _ when IInstruction.IsBranch(lastInstruction) && options.LogInstructionExecution.Has(InstructionLogging.Branches):
+                case var _ when options.LogInstructionExecution.Has(InstructionLogging.Computes):
                     string location = "";
                     if (options.CalculateLineNumbers)
                     {
@@ -695,11 +661,8 @@ private ModuleInstance AllocateModule(Module module)
             }
 
             //@Spec 4.5.4 Step 7
-            Frame initFrame = new(moduleInstance, FunctionType.Empty)
-            {
-                Locals = new LocalsSpace(),
-                Index = FuncIdx.GlobalInitializers
-            };
+            Frame initFrame = Context.ReserveFrame(moduleInstance, FunctionType.Empty, FuncIdx.GlobalInitializers);
+            initFrame.Locals = new LocalsSpace();
             Context.PushFrame(initFrame);
 
             //5. Allocate Globals and capture their addresses in the Store
@@ -808,8 +771,8 @@ public ModuleInstance InstantiateModule(Module module, RuntimeOptions? options =
                 moduleInstance = AllocateModule(module);
 
                 //12.
-                var auxFrame = new Frame(moduleInstance, FunctionType.Empty) { Locals = new LocalsSpace() };
-                auxFrame.Index = FuncIdx.ElementInitialization;
+                var auxFrame = Context.ReserveFrame(moduleInstance, FunctionType.Empty, FuncIdx.ElementInitialization);
+                auxFrame.Locals = new LocalsSpace();
                 //13.
                 Context.PushFrame(auxFrame);
 
diff --git a/Wacs.Core/Types/Expression.cs b/Wacs.Core/Types/Expression.cs
index 196eb03..4c1b39f 100644
--- a/Wacs.Core/Types/Expression.cs
+++ b/Wacs.Core/Types/Expression.cs
@@ -49,9 +49,9 @@ public Expression(IInstruction single) =>
         /// <param name="context"></param>
         public void Execute(ExecContext context)
         {
-            var frame = new Frame(context.Frame.Module, FunctionType.Empty);
-            frame.Index = FuncIdx.ExpressionEvaluation;
-            var label = new Label(ResultType.Empty, new InstructionPointer(Instructions, 1), OpCode.Nop);
+            var frame = context.ReserveFrame(context.Frame.Module, FunctionType.Empty, FuncIdx.ExpressionEvaluation);
+            var label = frame.ReserveLabel();
+            label.Set(ResultType.Empty, new InstructionPointer(Instructions, 1), OpCode.Nop, context.OpStack.Count);
             frame.Labels.Push(label);
             context.PushFrame(frame);
             foreach (var inst in Instructions)
diff --git a/Wacs.Core/Types/IndexSpace.cs b/Wacs.Core/Types/IndexSpace.cs
index 5bcd4f8..696d0e1 100644
--- a/Wacs.Core/Types/IndexSpace.cs
+++ b/Wacs.Core/Types/IndexSpace.cs
@@ -17,7 +17,6 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
-using System.Linq;
 using Wacs.Core.Runtime;
 
 namespace Wacs.Core.Types
@@ -182,19 +181,25 @@ public override bool Contains(GlobalIdx idx) =>
 
     public class LocalsSpace : AbstractIndexSpace<LocalIdx, Value>
     {
-        private readonly List<Value> _data;
-        private readonly ReadOnlyCollection<ValType> _locals;
+        private readonly Value[] _data;
 
         public LocalsSpace()
         {
-            _locals = Array.Empty<ValType>().ToList().AsReadOnly();
-            _data = Array.Empty<Value>().ToList();
+            _data = Array.Empty<Value>();
         }
 
-        public LocalsSpace(params IEnumerable<ValType>[] types)
+        public LocalsSpace(ValType[] parameters, ValType[] locals)
         {
-            _locals = types.SelectMany(collection => collection).ToList().AsReadOnly();
-            _data = _locals.Select(t => new Value(t)).ToList();
+            _data = new Value[parameters.Length + locals.Length];
+            int i = 0;
+            foreach (var t in parameters)
+            {
+                _data[i++] = new Value(t);
+            }
+            foreach (var t in locals)
+            {
+                _data[i++] = new Value(t);
+            }
         }
 
         public override Value this[LocalIdx idx]
@@ -204,7 +209,7 @@ public override Value this[LocalIdx idx]
         }
 
         public override bool Contains(LocalIdx idx) =>
-            idx.Value < _locals.Count;
+            idx.Value < _data.Length;
     }
 
     public class ElementsSpace : AbstractIndexSpace<ElemIdx, Module.ElementSegment>
diff --git a/Wacs.Core/Utilities/IReusable.cs b/Wacs.Core/Utilities/IReusable.cs
new file mode 100644
index 0000000..ce553d8
--- /dev/null
+++ b/Wacs.Core/Utilities/IReusable.cs
@@ -0,0 +1,25 @@
+// /*
+//  * Copyright 2024 Kelvin Nishikawa
+//  *
+//  * Licensed under the Apache License, Version 2.0 (the "License");
+//  * you may not use this file except in compliance with the License.
+//  * You may obtain a copy of the License at
+//  *
+//  *     http://www.apache.org/licenses/LICENSE-2.0
+//  *
+//  * Unless required by applicable law or agreed to in writing, software
+//  * distributed under the License is distributed on an "AS IS" BASIS,
+//  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  * See the License for the specific language governing permissions and
+//  * limitations under the License.
+//  */
+
+using System;
+
+namespace Wacs.Core.Utilities
+{
+    public interface IReusable<T> : IEquatable<T>
+    {
+        public void Clear();
+    }
+}
\ No newline at end of file
diff --git a/Wacs.Core/Utilities/InstructionLoggingExtension.cs b/Wacs.Core/Utilities/InstructionLoggingExtension.cs
new file mode 100644
index 0000000..d90050f
--- /dev/null
+++ b/Wacs.Core/Utilities/InstructionLoggingExtension.cs
@@ -0,0 +1,26 @@
+// /*
+//  * Copyright 2024 Kelvin Nishikawa
+//  *
+//  * Licensed under the Apache License, Version 2.0 (the "License");
+//  * you may not use this file except in compliance with the License.
+//  * You may obtain a copy of the License at
+//  *
+//  *     http://www.apache.org/licenses/LICENSE-2.0
+//  *
+//  * Unless required by applicable law or agreed to in writing, software
+//  * distributed under the License is distributed on an "AS IS" BASIS,
+//  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  * See the License for the specific language governing permissions and
+//  * limitations under the License.
+//  */
+
+using Wacs.Core.Runtime;
+
+namespace Wacs.Core.Utilities
+{
+    public static class InstructionLoggingExtension
+    {
+        public static bool Has(this InstructionLogging logging, InstructionLogging flags) => 
+            ((int)logging & (int)flags) != 0;
+    }
+}
\ No newline at end of file
diff --git a/Wacs.Core/Utilities/ReusableStack.cs b/Wacs.Core/Utilities/ReusableStack.cs
new file mode 100644
index 0000000..c42d031
--- /dev/null
+++ b/Wacs.Core/Utilities/ReusableStack.cs
@@ -0,0 +1,174 @@
+// /*
+//  * Copyright 2024 Kelvin Nishikawa
+//  *
+//  * Licensed under the Apache License, Version 2.0 (the "License");
+//  * you may not use this file except in compliance with the License.
+//  * You may obtain a copy of the License at
+//  *
+//  *     http://www.apache.org/licenses/LICENSE-2.0
+//  *
+//  * Unless required by applicable law or agreed to in writing, software
+//  * distributed under the License is distributed on an "AS IS" BASIS,
+//  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  * See the License for the specific language governing permissions and
+//  * limitations under the License.
+//  */
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Wacs.Core.Utilities
+{
+    public class ReusableStack<T>
+        where T : IReusable<T>, new()
+    {
+        internal T[] _backingArray;
+        private readonly int _growSize;
+
+        internal int Top;
+
+        public ReusableStack(int initialCapacity, int growSize = 0)
+        {
+            _growSize = growSize > 0 ? growSize : initialCapacity;
+            _backingArray = new T[initialCapacity];
+
+            for (int i = 0; i < initialCapacity; ++i)
+            {
+                _backingArray[i] = new T();
+            }
+
+            Top = -1;
+        }
+
+        internal T Peek()
+        {
+            if (Top < 0)
+                throw new InvalidOperationException("Stack underflow");
+            
+            return _backingArray[Top];
+        }
+
+        internal T Pop()
+        {
+            if (Top < 0)
+                throw new InvalidOperationException("Stack underflow");
+            
+            T top = _backingArray[Top];
+            Top -= 1;
+            return top;
+        }
+
+        internal T Reserve()
+        {
+            if (Top + 1 >= _backingArray.Length)
+            {
+                int i = _backingArray.Length;
+                int l = i + _growSize;
+                Array.Resize(ref _backingArray, l);
+                for (; i < l; ++i)
+                    _backingArray[i] = new T();
+            }
+            return _backingArray[Top+1];
+        }
+
+        internal void Push(T element)
+        {
+            Top += 1;
+            _backingArray[Top] = element;
+        }
+
+        internal void Drop(int toIndex)
+        {
+            if (Top < toIndex)
+                throw new InvalidOperationException("Stack underflow");
+            
+            Top = toIndex;
+        }
+
+        public SubStack<T> GetSubStack()
+        {
+            return new SubStack<T>(this);
+        }
+    }
+
+    public struct SubStack<T> : IEnumerable<T> where T : IReusable<T>, new()
+    {
+        private readonly int _zeroElement;
+        private readonly ReusableStack<T> _stack;
+
+        public SubStack(ReusableStack<T> stack)
+        {
+            _stack = stack;
+            _zeroElement = _stack.Top;
+        }
+
+        public T Peek() => _stack.Peek();
+
+        public T Pop()
+        {
+            if (_stack.Top == _zeroElement)
+                throw new InvalidOperationException("Stack underflow");
+            
+            return _stack.Pop();
+        }
+
+        public void Push(T element)
+        {
+            _stack.Push(element);
+        }
+
+        public int Count => _stack.Top - _zeroElement;
+
+        public T Reserve()
+        {
+            var element = _stack.Reserve();
+            element.Clear();
+            return element;
+        }
+
+        public void Drop() => _stack.Drop(_zeroElement);
+        
+        public Enumerator GetEnumerator() => new Enumerator(this);
+
+        public struct Enumerator : IEnumerator, IEnumerator<T>
+        {
+            private SubStack<T> _subStack;
+            private int _currentIndex;
+
+            public Enumerator(SubStack<T> subStack)
+            {
+                _subStack = subStack;
+                _currentIndex = subStack.Count;
+            }
+
+            public void Reset()
+            {
+                _currentIndex = _subStack.Count;
+            }
+
+            object? IEnumerator.Current => Current;
+
+            public T Current => _subStack._stack._backingArray[_subStack._zeroElement + _currentIndex];
+
+            public bool MoveNext()
+            {
+                if (_currentIndex > 0)
+                {
+                    _currentIndex--;
+                    return true;
+                }
+                return false;
+            }
+
+            public void Dispose()
+            {
+                
+            }
+        }
+
+        IEnumerator<T> IEnumerable<T>.GetEnumerator() => new Enumerator(this);
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+        
+    }
+}
\ No newline at end of file
diff --git a/Wacs.Core/Validation/WasmValidationContext.cs b/Wacs.Core/Validation/WasmValidationContext.cs
index de6ade6..4a3d204 100644
--- a/Wacs.Core/Validation/WasmValidationContext.cs
+++ b/Wacs.Core/Validation/WasmValidationContext.cs
@@ -196,7 +196,12 @@ public ValidationContext<T> PushSubContext<T>(T child, int index = -1)
         public void SetExecFrame(FunctionType funcType, ValType[] localTypes)
         {
             var locals = new LocalsSpace(funcType.ParameterTypes.Types, localTypes);
-            ExecFrame = new Frame(ValidationModule, funcType) { Locals = locals };
+            ExecFrame = new Frame
+            {
+                Module = ValidationModule,
+                Type = funcType,
+                Locals = locals
+            };
         }
 
         public class InstructionValidator : AbstractValidator<IInstruction>

From b3d853ea52d7c33438364a2fa7d62aa97f384757 Mon Sep 17 00:00:00 2001
From: Kelvin Nishikawa <kelnishi@gmail.com>
Date: Fri, 15 Nov 2024 13:04:38 -0800
Subject: [PATCH 2/6] Memory optimization pass

Adding object pool for local variables space
---
 Wacs.Core/Modules/Sections/StackRenderer.cs   |  7 ++--
 Wacs.Core/Runtime/ExecContext.cs              | 22 +++++++++---
 Wacs.Core/Runtime/WasmRuntime.cs              |  2 --
 Wacs.Core/Types/IndexSpace.cs                 | 31 ++++++++++-------
 .../LocalsSpacePooledObjectPolicy.cs          | 34 +++++++++++++++++++
 Wacs.Core/Validation/WasmValidationContext.cs |  3 +-
 Wacs.Core/Wacs.Core.csproj                    |  1 +
 7 files changed, 78 insertions(+), 22 deletions(-)
 create mode 100644 Wacs.Core/Utilities/LocalsSpacePooledObjectPolicy.cs

diff --git a/Wacs.Core/Modules/Sections/StackRenderer.cs b/Wacs.Core/Modules/Sections/StackRenderer.cs
index 488b68b..38bfdea 100644
--- a/Wacs.Core/Modules/Sections/StackRenderer.cs
+++ b/Wacs.Core/Modules/Sections/StackRenderer.cs
@@ -262,8 +262,11 @@ private ExecContext BuildDummyContext(Module module, ModuleInstance moduleInst,
             
             var funcType = Types[modFunc.TypeIndex];
             var dummyContext = new ExecContext(store, new RuntimeAttributes { Live = false } );
-            var execFrame = dummyContext.ReserveFrame(ModuleInst, new FunctionType(ResultType.Empty, funcType.ResultType), modFunc.Index);
-            execFrame.Locals = new LocalsSpace(funcType.ParameterTypes.Types, modFunc.Locals);
+            var execFrame = dummyContext.ReserveFrame(
+                ModuleInst, 
+                new FunctionType(ResultType.Empty, funcType.ResultType), 
+                modFunc.Index,
+                modFunc.Locals);
             
             dummyContext.PushFrame(execFrame);
             return dummyContext;
diff --git a/Wacs.Core/Runtime/ExecContext.cs b/Wacs.Core/Runtime/ExecContext.cs
index 9fff7d7..7306f81 100644
--- a/Wacs.Core/Runtime/ExecContext.cs
+++ b/Wacs.Core/Runtime/ExecContext.cs
@@ -19,6 +19,7 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using Microsoft.Extensions.ObjectPool;
 using Wacs.Core.Instructions;
 using Wacs.Core.OpCodes;
 using Wacs.Core.Runtime.Exceptions;
@@ -53,6 +54,10 @@ public ExecContext(Store store, RuntimeAttributes? attributes = default)
             FrameStack = new(Attributes.InitialCallStack, Attributes.GrowCallStack);
             LabelStack = new(Attributes.InitialCallStack * 2, Attributes.GrowCallStack);
             CallStack = FrameStack.GetSubStack();
+
+            var poolPolicy = new LocalsSpacePooledObjectPolicy();
+            LocalsPool = new DefaultObjectPool<LocalsSpace>(poolPolicy, Attributes.InitialCallStack);
+            
             _hostReturnSequence = new InstructionSequence(
                 InstructionFactory.CreateInstruction<InstFuncReturn>(OpCode.Func)
             );
@@ -73,6 +78,8 @@ public ExecContext(Store store, RuntimeAttributes? attributes = default)
         private ReusableStack<Frame> FrameStack { get; }
         private SubStack<Frame> CallStack { get; }
         private ReusableStack<Label> LabelStack { get; }
+        
+        private DefaultObjectPool<LocalsSpace> LocalsPool { get; }
 
         public Frame Frame => CallStack.Peek();
 
@@ -95,15 +102,19 @@ public void Assert(bool assertion, string message)
         public Frame ReserveFrame(
             ModuleInstance module,
             FunctionType type,
-            FuncIdx index
-        )
+            FuncIdx index,
+            ValType[]? locals = default)
         {
+            locals ??= Array.Empty<ValType>();
+            
             var frame = CallStack.Reserve();
             frame.Module = module;
             frame.Type = type;
             frame.Labels = LabelStack.GetSubStack();
             frame.Index = index;
             frame.ContinuationAddress = GetPointer();
+            frame.Locals = LocalsPool.Get();
+            frame.Locals.Enscribe(type.ParameterTypes.Types, locals);
             
             return frame;
         }
@@ -121,6 +132,10 @@ public Frame PopFrame()
         {
             var frame = CallStack.Pop();
             frame.Labels.Drop();
+            
+            LocalsPool.Return(frame.Locals);
+            frame.Locals = null!;
+            
             return frame;
         }
 
@@ -220,8 +235,7 @@ private void Invoke(FunctionInstance wasmFunc, FuncIdx idx)
             OpStack.PopResults(funcType.ParameterTypes, ref _asideVals);
             //8.
             //Push the frame and operate on the frame on the stack.
-            var frame = ReserveFrame(wasmFunc.Module, funcType, idx);
-            frame.Locals = new LocalsSpace(funcType.ParameterTypes.Types, t);
+            var frame = ReserveFrame(wasmFunc.Module, funcType, idx, t);
             // frame.FuncId = wasmFunc.Id;
                 
             int li = 0;
diff --git a/Wacs.Core/Runtime/WasmRuntime.cs b/Wacs.Core/Runtime/WasmRuntime.cs
index f8c5292..c27de5b 100644
--- a/Wacs.Core/Runtime/WasmRuntime.cs
+++ b/Wacs.Core/Runtime/WasmRuntime.cs
@@ -662,7 +662,6 @@ private ModuleInstance AllocateModule(Module module)
 
             //@Spec 4.5.4 Step 7
             Frame initFrame = Context.ReserveFrame(moduleInstance, FunctionType.Empty, FuncIdx.GlobalInitializers);
-            initFrame.Locals = new LocalsSpace();
             Context.PushFrame(initFrame);
 
             //5. Allocate Globals and capture their addresses in the Store
@@ -772,7 +771,6 @@ public ModuleInstance InstantiateModule(Module module, RuntimeOptions? options =
 
                 //12.
                 var auxFrame = Context.ReserveFrame(moduleInstance, FunctionType.Empty, FuncIdx.ElementInitialization);
-                auxFrame.Locals = new LocalsSpace();
                 //13.
                 Context.PushFrame(auxFrame);
 
diff --git a/Wacs.Core/Types/IndexSpace.cs b/Wacs.Core/Types/IndexSpace.cs
index 696d0e1..6aa501c 100644
--- a/Wacs.Core/Types/IndexSpace.cs
+++ b/Wacs.Core/Types/IndexSpace.cs
@@ -181,27 +181,30 @@ public override bool Contains(GlobalIdx idx) =>
 
     public class LocalsSpace : AbstractIndexSpace<LocalIdx, Value>
     {
-        private readonly Value[] _data;
-
-        public LocalsSpace()
-        {
-            _data = Array.Empty<Value>();
-        }
-
-        public LocalsSpace(ValType[] parameters, ValType[] locals)
+        private readonly List<Value> _data = new();
+        
+        public LocalsSpace() { }
+        
+        public void Enscribe(ValType[] parameters, ValType[] locals)
         {
-            _data = new Value[parameters.Length + locals.Length];
-            int i = 0;
+            _data.Clear();
+            // _data.Capacity = parameters.Length + locals.Length;
+            
             foreach (var t in parameters)
             {
-                _data[i++] = new Value(t);
+                _data.Add(new Value(t));
             }
             foreach (var t in locals)
             {
-                _data[i++] = new Value(t);
+                _data.Add(new Value(t));
             }
         }
 
+        public void Reset()
+        {
+            _data.Clear();
+        }
+
         public override Value this[LocalIdx idx]
         {
             get => _data[(Index)idx];
@@ -209,7 +212,9 @@ public override Value this[LocalIdx idx]
         }
 
         public override bool Contains(LocalIdx idx) =>
-            idx.Value < _data.Length;
+            idx.Value < _data.Count;
+
+        
     }
 
     public class ElementsSpace : AbstractIndexSpace<ElemIdx, Module.ElementSegment>
diff --git a/Wacs.Core/Utilities/LocalsSpacePooledObjectPolicy.cs b/Wacs.Core/Utilities/LocalsSpacePooledObjectPolicy.cs
new file mode 100644
index 0000000..0f5bc4a
--- /dev/null
+++ b/Wacs.Core/Utilities/LocalsSpacePooledObjectPolicy.cs
@@ -0,0 +1,34 @@
+// /*
+//  * Copyright 2024 Kelvin Nishikawa
+//  *
+//  * Licensed under the Apache License, Version 2.0 (the "License");
+//  * you may not use this file except in compliance with the License.
+//  * You may obtain a copy of the License at
+//  *
+//  *     http://www.apache.org/licenses/LICENSE-2.0
+//  *
+//  * Unless required by applicable law or agreed to in writing, software
+//  * distributed under the License is distributed on an "AS IS" BASIS,
+//  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  * See the License for the specific language governing permissions and
+//  * limitations under the License.
+//  */
+
+using Microsoft.Extensions.ObjectPool;
+using Wacs.Core.Types;
+
+namespace Wacs.Core.Utilities
+{
+    public class LocalsSpacePooledObjectPolicy : PooledObjectPolicy<LocalsSpace>
+    {
+        public override LocalsSpace Create() => new LocalsSpace();
+
+        public override bool Return(LocalsSpace? obj)
+        {
+            if (obj == null)
+                return false;
+            obj.Reset();
+            return true; 
+        }
+    }
+}
\ No newline at end of file
diff --git a/Wacs.Core/Validation/WasmValidationContext.cs b/Wacs.Core/Validation/WasmValidationContext.cs
index 4a3d204..9d7a65e 100644
--- a/Wacs.Core/Validation/WasmValidationContext.cs
+++ b/Wacs.Core/Validation/WasmValidationContext.cs
@@ -195,7 +195,8 @@ public ValidationContext<T> PushSubContext<T>(T child, int index = -1)
 
         public void SetExecFrame(FunctionType funcType, ValType[] localTypes)
         {
-            var locals = new LocalsSpace(funcType.ParameterTypes.Types, localTypes);
+            var locals = new LocalsSpace();
+            locals.Enscribe(funcType.ParameterTypes.Types, localTypes);
             ExecFrame = new Frame
             {
                 Module = ValidationModule,
diff --git a/Wacs.Core/Wacs.Core.csproj b/Wacs.Core/Wacs.Core.csproj
index 9cc865c..4a981a7 100644
--- a/Wacs.Core/Wacs.Core.csproj
+++ b/Wacs.Core/Wacs.Core.csproj
@@ -46,6 +46,7 @@
   
   <ItemGroup>
     <PackageReference Include="FluentValidation" Version="11.10.0" />
+    <PackageReference Include="Microsoft.Extensions.ObjectPool" Version="9.0.0" />
   </ItemGroup>
 
 </Project>

From ba953eaff8dc646867c0f80575202c6fce28d57a Mon Sep 17 00:00:00 2001
From: Kelvin Nishikawa <kelnishi@gmail.com>
Date: Fri, 15 Nov 2024 14:57:44 -0800
Subject: [PATCH 3/6] Adding tests for function binding

---
 Spec.Test/BindingTests.cs     | 110 ++++++++++++++++++++++++++++++++++
 Spec.Test/engine/binding.wasm | Bin 0 -> 162 bytes
 Spec.Test/engine/binding.wat  |  46 ++++++++++++++
 3 files changed, 156 insertions(+)
 create mode 100644 Spec.Test/BindingTests.cs
 create mode 100644 Spec.Test/engine/binding.wasm
 create mode 100644 Spec.Test/engine/binding.wat

diff --git a/Spec.Test/BindingTests.cs b/Spec.Test/BindingTests.cs
new file mode 100644
index 0000000..efb92fc
--- /dev/null
+++ b/Spec.Test/BindingTests.cs
@@ -0,0 +1,110 @@
+// /*
+//  * Copyright 2024 Kelvin Nishikawa
+//  *
+//  * Licensed under the Apache License, Version 2.0 (the "License");
+//  * you may not use this file except in compliance with the License.
+//  * You may obtain a copy of the License at
+//  *
+//  *     http://www.apache.org/licenses/LICENSE-2.0
+//  *
+//  * Unless required by applicable law or agreed to in writing, software
+//  * distributed under the License is distributed on an "AS IS" BASIS,
+//  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  * See the License for the specific language governing permissions and
+//  * limitations under the License.
+//  */
+
+using System;
+using System.IO;
+using Wacs.Core;
+using Wacs.Core.Runtime;
+using Xunit;
+
+namespace Spec.Test
+{
+    public class BindingTests
+    {
+        [Fact]
+        public void BindStackBinder()
+        {
+            var runtime = new WasmRuntime();
+            runtime.BindHostFunction<hostInOut>(("env","bound_host"), BoundHost);
+            using var fileStream = new FileStream("../../../engine/binding.wasm", FileMode.Open);
+            var module = BinaryModuleParser.ParseWasm(fileStream);
+            var moduleInst = runtime.InstantiateModule(module);
+            runtime.RegisterModule("binding", moduleInst);
+
+            var fa = runtime.GetExportedFunction(("binding", "4x4"));
+            var invoker = runtime.CreateStackInvoker(fa);
+            
+            var result = invoker(new Value[]{1, 1, 1f, 1.0});
+            
+            Assert.Equal(1 * 2, (int)result[0]);
+            Assert.Equal(1 * 3, (long)result[1]);
+            Assert.Equal(1f * 4f, (float)result[2]);
+            Assert.Equal(1.0 * 5.0, (double)result[3]);
+        }
+
+        [Fact]
+        public void BindParamAndResultI32()
+        {
+            var runtime = new WasmRuntime();
+            runtime.BindHostFunction<hostInOut>(("env","bound_host"), BoundHost);
+            using var fileStream = new FileStream("../../../engine/binding.wasm", FileMode.Open);
+            var module = BinaryModuleParser.ParseWasm(fileStream);
+            var moduleInst = runtime.InstantiateModule(module);
+            runtime.RegisterModule("binding", moduleInst);
+
+            var fa = runtime.GetExportedFunction(("binding", "i32"));
+            var invoker = runtime.CreateInvoker<Func<int, int>>(fa);
+            
+            Assert.Equal(1 * 2, invoker(1));
+            Assert.Equal(2 * 2, invoker(2));
+            Assert.Equal(3 * 2, invoker(3));
+        }
+
+        [Fact]
+        public void BindParamAndResultF32()
+        {
+            var runtime = new WasmRuntime();
+            runtime.BindHostFunction<hostInOut>(("env","bound_host"), BoundHost);
+            using var fileStream = new FileStream("../../../engine/binding.wasm", FileMode.Open);
+            var module = BinaryModuleParser.ParseWasm(fileStream);
+            var moduleInst = runtime.InstantiateModule(module);
+            runtime.RegisterModule("binding", moduleInst);
+
+            var fa = runtime.GetExportedFunction(("binding", "f32"));
+            var invoker = runtime.CreateInvoker<Func<float, float>>(fa);
+            
+            Assert.Equal(1f * 2f, invoker(1f));
+            Assert.Equal(2f * 2f, invoker(2f));
+            Assert.Equal(3f * 2f, invoker(3f));
+        }
+
+        static int BoundHost(int a, out int b)
+        {
+            b = a;
+            int c = a * 2;
+            return c;
+        }
+
+        [Fact]
+        public void BindHostFunction()
+        {
+            var runtime = new WasmRuntime();
+            runtime.BindHostFunction<hostInOut>(("env","bound_host"), BoundHost);
+            
+            using var fileStream = new FileStream("../../../engine/binding.wasm", FileMode.Open);
+            var module = BinaryModuleParser.ParseWasm(fileStream);
+            var moduleInst = runtime.InstantiateModule(module);
+            runtime.RegisterModule("binding", moduleInst);
+
+            var fa = runtime.GetExportedFunction(("binding", "call_host"));
+            var invoker = runtime.CreateInvoker<Func<int, int>>(fa);
+            
+            Assert.Equal(10 + 20, invoker(10));
+        }
+
+        delegate int hostInOut(int a, out int b);
+    }
+}
\ No newline at end of file
diff --git a/Spec.Test/engine/binding.wasm b/Spec.Test/engine/binding.wasm
new file mode 100644
index 0000000000000000000000000000000000000000..cd8289e63a33e2f54d7dabd3d07dcafbfab9119e
GIT binary patch
literal 162
zcmX9%I}XAy6!Xgqsz?S9VniZb0Xn1bxd$yj0SfI<Kn$ee5Iq4WC2Bp`mTk$%t2+Up
ziOgiE{imgj0)>n``RGIlVnlo@UTR-Hi{tK6Ru3@uBuG#)m7Km)5MLK_2tG&V{vmg+
q+ex*QGZ?IdGqmQ~hz;<yjp1#)jTqbCKquWotEjPuZQ5vvoBjhvp&qCJ

literal 0
HcmV?d00001

diff --git a/Spec.Test/engine/binding.wat b/Spec.Test/engine/binding.wat
new file mode 100644
index 0000000..fc2a256
--- /dev/null
+++ b/Spec.Test/engine/binding.wat
@@ -0,0 +1,46 @@
+(module
+(type (;0;) (func (param i32 i64 f32 f64) (result i32 i64 f32 f64)))
+(type (;1;) (func (param i32) (result i32)))
+(type (;2;) (func (param f32) (result f32)))
+(type (;3;) (func (param i32) (result i32 i32)))
+(import (;0;) "env" "bound_host" (func (;0;) (type 3)))
+(func (;1;) (type 0)
+    (param i32 i64 f32 f64) (result i32 i64 f32 f64)
+    local.get 0
+    i32.const 2
+    i32.mul
+    local.get 1
+    i64.const 3
+    i64.mul
+    local.get 2
+    f32.const 4.0
+    f32.mul
+    local.get 3
+    f64.const 5.0
+    f64.mul
+    return
+)
+(func (;2;) (type 1)
+    (param i32) (result i32)
+    local.get 0
+    i32.const 2
+    i32.mul
+)
+(func (;3;) (type 2)
+    (param f32) (result f32)
+    local.get 0
+    f32.const 2
+    f32.mul
+)
+(func (;4;) (type 1)
+    (param i32) (result i32)
+    local.get 0
+    call 0
+    i32.add
+)
+
+(export "4x4" (func 1))
+(export "i32" (func 2))
+(export "f32" (func 3))
+(export "call_host" (func 4))
+)
\ No newline at end of file

From 9fd2207ce5f915dd63eb7271c15b5f29ddb8588b Mon Sep 17 00:00:00 2001
From: Kelvin Nishikawa <kelnishi@gmail.com>
Date: Fri, 15 Nov 2024 14:58:27 -0800
Subject: [PATCH 4/6] Fixing pass-through Value binding

---
 Wacs.Core/Runtime/Value.cs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Wacs.Core/Runtime/Value.cs b/Wacs.Core/Runtime/Value.cs
index 399a744..9c90317 100644
--- a/Wacs.Core/Runtime/Value.cs
+++ b/Wacs.Core/Runtime/Value.cs
@@ -357,6 +357,10 @@ public Value(object externalValue)
                     Type = ValType.V128;
                     V128 = v128;
                     break;
+                case Value value:
+                    Type = value.Type;
+                    V128 = value.V128;
+                    break;
                 default:
                     throw new InvalidDataException(
                         $"Cannot convert object to stack value of type {typeof(ExternalValue)}");

From bcbcad351e3527f42ae88a832207b8219f345e4a Mon Sep 17 00:00:00 2001
From: Kelvin Nishikawa <kelnishi@gmail.com>
Date: Fri, 15 Nov 2024 15:35:56 -0800
Subject: [PATCH 5/6] Code cleanup, warnings and format

---
 Spec.Test/Spec.Test.csproj             |   2 +-
 Spec.Test/WastJson/Actions.cs          |  16 +-
 Spec.Test/WastJson/Argument.cs         |  20 +-
 Spec.Test/WastJson/Commands.cs         | 317 +++++++------------------
 Spec.Test/WastJson/EnumHelper.cs       |   4 +-
 Spec.Test/WastJson/IAction.cs          |   4 -
 Spec.Test/WastJson/WastJson.cs         |   8 +-
 Spec.Test/WastJsonTestData.cs          |   2 +-
 Wacs.Console/CommandLineOptions.cs     |   2 +-
 Wacs.Core/Runtime/Delegates.cs         |   5 +-
 Wacs.Core/Runtime/ExecContext.cs       |   2 +-
 Wacs.Core/Runtime/Label.cs             |  25 +-
 Wacs.Core/Runtime/RuntimeAttributes.cs |   8 +-
 Wacs.Core/Types/IndexSpace.cs          |  18 +-
 Wacs.Core/Utilities/ReusableStack.cs   |   2 +-
 15 files changed, 144 insertions(+), 291 deletions(-)

diff --git a/Spec.Test/Spec.Test.csproj b/Spec.Test/Spec.Test.csproj
index ccd6952..5cee07c 100644
--- a/Spec.Test/Spec.Test.csproj
+++ b/Spec.Test/Spec.Test.csproj
@@ -9,7 +9,7 @@
         <Authors>Kelvin Nishikawa</Authors>
         <Company>Kelvin Nishikawa</Company>
         <Product>Spec.Test</Product>
-        <AssemblyVersion>1.0.0</AssemblyVersion>
+        <AssemblyVersion>1.0.1</AssemblyVersion>
     </PropertyGroup>
 
     <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
diff --git a/Spec.Test/WastJson/Actions.cs b/Spec.Test/WastJson/Actions.cs
index d25dce8..c8fd6e3 100644
--- a/Spec.Test/WastJson/Actions.cs
+++ b/Spec.Test/WastJson/Actions.cs
@@ -28,15 +28,11 @@ namespace Spec.Test.WastJson
     public class InvokeAction : IAction
     {
         [JsonPropertyName("module")] public string Module { get; set; } = "";
-
-        // [JsonPropertyName("expected")] public List<Argument> Expected { get; set; } = new();
+        [JsonPropertyName("args")] public List<Argument> Args { get; set; } = new();
         public ActionType Type => ActionType.Invoke;
-
         [JsonPropertyName("field")] public string Field { get; set; } = "";
 
-        [JsonPropertyName("args")] public List<Argument> Args { get; set; } = new();
-
-        public override string ToString() => $"{Field} - Args: {string.Join(", ", Args)}";
+        public override string ToString() => $"{Field} - Args: {string.Join(", ", Args ?? new List<Argument>())}";
 
         public Value[] Invoke(ref WasmRuntime runtime, ref Module? module)
         {
@@ -68,7 +64,7 @@ public Value[] Invoke(ref WasmRuntime runtime, ref Module? module)
     public class GetAction : IAction
     {
         [JsonPropertyName("expected")]
-        public List<Argument> Expected {
+        public List<Argument>? Expected {
             get => null;
             set => throw new NotSupportedException("GetAction does not support results.");
         }
@@ -76,12 +72,6 @@ public List<Argument> Expected {
         public ActionType Type => ActionType.Get;
 
         [JsonPropertyName("field")] public string Field { get; set; } = "";
-
-        public List<Argument> Args
-        {
-            get => null;
-            set => throw new NotSupportedException("GetAction does not support arguments.");
-        }
     }
     
     public class ActionJsonConverter : JsonConverter<IAction>
diff --git a/Spec.Test/WastJson/Argument.cs b/Spec.Test/WastJson/Argument.cs
index c57911d..b679bfb 100644
--- a/Spec.Test/WastJson/Argument.cs
+++ b/Spec.Test/WastJson/Argument.cs
@@ -28,30 +28,30 @@ namespace Spec.Test.WastJson
     public class Argument
     {
         [JsonPropertyName("type")]
-        public string Type { get; set; }
+        public string? Type { get; set; }
 
         [JsonPropertyName("lane_type")]
-        public string LaneType { get; set; }
+        public string? LaneType { get; set; }
 
         [JsonPropertyName("value")]
-        public object Value { get; set; }
+        public object? Value { get; set; }
 
 
         public Value AsValue =>
             Type switch
             {
-                "i32" => new Value(ValType.I32, Value.ToString()),
-                "i64" => new Value(ValType.I64, Value.ToString()),
-                "f32" => new Value(ValType.F32, Value.ToString()),
-                "f64" => new Value(ValType.F64, Value.ToString()),
+                "i32" => new Value(ValType.I32, Value?.ToString()??""),
+                "i64" => new Value(ValType.I64, Value?.ToString()??""),
+                "f32" => new Value(ValType.F32, Value?.ToString()??""),
+                "f64" => new Value(ValType.F64, Value?.ToString()??""),
                 "v128" => ParseV128(Value),
-                "funcref" => new Value(ValType.Funcref, Value.ToString()),
-                "externref" => new Value(ValType.Externref, Value.ToString()),
+                "funcref" => new Value(ValType.Funcref, Value?.ToString()??"null"),
+                "externref" => new Value(ValType.Externref, Value?.ToString()??"null"),
                 _ => throw new ArgumentException($"Cannot parse value {Value} of type {Type}")
             };
 
 
-        private Value ParseV128(object value)
+        private Value ParseV128(object? value)
         {
             if (value is JsonElement jsonElement && jsonElement.ValueKind == JsonValueKind.Array)
             {
diff --git a/Spec.Test/WastJson/Commands.cs b/Spec.Test/WastJson/Commands.cs
index 4807335..5bd3c6a 100644
--- a/Spec.Test/WastJson/Commands.cs
+++ b/Spec.Test/WastJson/Commands.cs
@@ -44,23 +44,17 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
     public class ModuleCommand : ICommand
     {
         private SpecTestEnv _env = new SpecTestEnv();
-
-        [JsonPropertyName("filename")]
-        public string Filename { get; set; }
-
-        [JsonPropertyName("name")]
-        public string Name { get; set; }
+        [JsonPropertyName("filename")] public string? Filename { get; set; }
+        [JsonPropertyName("name")] public string? Name { get; set; }
 
         public CommandType Type => CommandType.Module;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
             List<Exception> errors = new();
 
-            var filepath = Path.Combine(testDefinition.Path, Filename);
+            var filepath = Path.Combine(testDefinition.Path, Filename!);
             using var fileStream = new FileStream(filepath, FileMode.Open);
             module = BinaryModuleParser.ParseWasm(fileStream);
             var modInst = runtime.InstantiateModule(module);
@@ -78,21 +72,17 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class RegisterCommand : ICommand
     {
-        [JsonPropertyName("name")]
-        public string Name { get; set; }
-
-        [JsonPropertyName("as")]
-        public string As { get; set; }
-
+        [JsonPropertyName("name")] public string? Name { get; set; }
+        [JsonPropertyName("as")] public string? As { get; set; }
         public CommandType Type => CommandType.Module;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
             List<Exception> errors = new();
-
+            if (As == null)
+                throw new ArgumentException("Json missing `as` field");
+            
             var modInst = runtime.GetModule(Name);
             runtime.RegisterModule(As, modInst);
             return errors;
@@ -103,13 +93,9 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
     
     public class ActionCommand : ICommand
     {
-        [JsonPropertyName("action")]
-        public IAction Action { get; set; }
-
+        [JsonPropertyName("action")] public IAction? Action { get; set; }
         public CommandType Type => CommandType.Action;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -128,16 +114,10 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class AssertReturnCommand : ICommand
     {
-        [JsonPropertyName("action")]
-        public IAction Action { get; set; }
-
-        [JsonPropertyName("expected")]
-        public List<Argument> Expected { get; set; }
-
+        [JsonPropertyName("action")] public IAction? Action { get; set; }
+        [JsonPropertyName("expected")] public List<Argument> Expected { get; set; } = new();
         public CommandType Type => CommandType.AssertReturn;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -160,16 +140,10 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
     
     public class AssertTrapCommand : ICommand
     {
-        [JsonPropertyName("action")]
-        public IAction Action { get; set; }
-
-        [JsonPropertyName("text")]
-        public string Text { get; set; }
-
+        [JsonPropertyName("action")] public IAction? Action { get; set; }
+        [JsonPropertyName("text")] public string? Text { get; set; }
         public CommandType Type => CommandType.AssertTrap;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -203,16 +177,10 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class AssertExhaustionCommand : ICommand
     {
-        [JsonPropertyName("action")]
-        public IAction Action { get; set; }
-
-        [JsonPropertyName("text")]
-        public string Text { get; set; }
-
+        [JsonPropertyName("action")] public IAction? Action { get; set; }
+        [JsonPropertyName("text")] public string? Text { get; set; }
         public CommandType Type => CommandType.AssertExhaustion;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -228,10 +196,10 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
                     {
                         var result = invokeAction.Invoke(ref runtime, ref module);
                     }
-                    catch (WasmRuntimeException exc)
+                    catch (WasmRuntimeException)
                     {
                         didThrow = true;
-                        throwMessage = Text;
+                        throwMessage = Text ?? "";
                     }
                     if (!didThrow)
                         throw new TestException($"Test failed {this} \"{throwMessage}\"");
@@ -245,19 +213,11 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class AssertInvalidCommand : ICommand
     {
-        [JsonPropertyName("filename")]
-        public string Filename { get; set; }
-
-        [JsonPropertyName("module_type")]
-        public string ModuleType { get; set; }
-
-        [JsonPropertyName("text")]
-        public string Text { get; set; }
-
+        [JsonPropertyName("filename")] public string? Filename { get; set; }
+        [JsonPropertyName("module_type")] public string? ModuleType { get; set; }
+        [JsonPropertyName("text")] public string? Text { get; set; }
         public CommandType Type => CommandType.AssertInvalid;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -269,6 +229,9 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
                 return errors;
             }
             
+            if (Filename == null)
+                throw new ArgumentException("Json missing `filename` field");
+            
             var filepath = Path.Combine(testDefinition.Path, Filename);
             bool didAssert = false;
             string assertionMessage = "";
@@ -308,19 +271,11 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class AssertMalformedCommand : ICommand
     {
-        [JsonPropertyName("filename")]
-        public string Filename { get; set; }
-
-        [JsonPropertyName("text")]
-        public string Text { get; set; }
-
-        [JsonPropertyName("module_type")]
-        public string ModuleType { get; set; }
-
+        [JsonPropertyName("filename")] public string? Filename { get; set; }
+        [JsonPropertyName("text")] public string? Text { get; set; }
+        [JsonPropertyName("module_type")] public string? ModuleType { get; set; }
         public CommandType Type => CommandType.AssertMalformed;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
@@ -333,9 +288,11 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
                 return errors;
             }
             
+            if (Filename == null)
+                throw new ArgumentException("Json missing `filename` field");
+            
             var filepath = Path.Combine(testDefinition.Path, Filename);
             bool didAssert1 = false;
-            string assertionMessage = "";
             try
             {
                 using var fileStream = new FileStream(filepath, FileMode.Open);
@@ -343,15 +300,13 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
                 stubmodule.SetName(filepath);
                 var modInstInvalid = runtime.InstantiateModule(stubmodule);
             }
-            catch (FormatException exc)
+            catch (FormatException)
             {
                 didAssert1 = true;
-                assertionMessage = exc.Message;
             }
-            catch (NotSupportedException exc)
+            catch (NotSupportedException)
             {
                 didAssert1 = true;
-                assertionMessage = exc.Message;
             }
 
             if (!didAssert1)
@@ -367,19 +322,11 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class AssertUnlinkableCommand : ICommand
     {
-        [JsonPropertyName("filename")]
-        public string Filename { get; set; }
-
-        [JsonPropertyName("text")]
-        public string Text { get; set; }
-
-        [JsonPropertyName("module_type")]
-        public string ModuleType { get; set; }
-
+        [JsonPropertyName("filename")] public string? Filename { get; set; }
+        [JsonPropertyName("text")] public string? Text { get; set; }
+        [JsonPropertyName("module_type")] public string? ModuleType { get; set; }
         public CommandType Type => CommandType.AssertUnlinkable;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -390,10 +337,11 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
                     $"Assert Malformed line {Line}: Skipping assert_malformed. No WAT parsing."));
                 return errors;
             }
+            if (Filename == null)
+                throw new ArgumentException("Json missing `filename` field");
             
             var filepath = Path.Combine(testDefinition.Path, Filename);
             bool didAssert = false;
-            string assertionMessage = "";
             try
             {
                 using var fileStream = new FileStream(filepath, FileMode.Open);
@@ -401,10 +349,9 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
                 stubmodule.SetName(filepath);
                 var modInstInvalid = runtime.InstantiateModule(stubmodule);
             }
-            catch (NotSupportedException exc)
+            catch (NotSupportedException)
             {
                 didAssert = true;
-                assertionMessage = exc.Message;
             }
 
             if (!didAssert)
@@ -420,27 +367,21 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class AssertUninstantiableCommand : ICommand
     {
-        [JsonPropertyName("filename")]
-        public string Filename { get; set; }
-
-        [JsonPropertyName("module_type")]
-        public string ModuleType { get; set; }
-
-        [JsonPropertyName("text")]
-        public string Text { get; set; }
-
+        [JsonPropertyName("filename")] public string? Filename { get; set; }
+        [JsonPropertyName("module_type")] public string? ModuleType { get; set; }
+        [JsonPropertyName("text")] public string? Text { get; set; }
         public CommandType Type => CommandType.AssertUninstantiable;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
             List<Exception> errors = new();
             
+            if (Filename == null)
+                throw new ArgumentException("Json missing `filename` field");
+            
             var filepath = Path.Combine(testDefinition.Path, Filename);
             bool didAssert = false;
-            string assertionMessage = "";
             try
             {
                 using var fileStream = new FileStream(filepath, FileMode.Open);
@@ -448,25 +389,21 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
                 stubmodule.SetName(filepath);
                 var modInst = runtime.InstantiateModule(stubmodule);
             }
-            catch (ValidationException exc)
+            catch (ValidationException)
             {
                 didAssert = true;
-                assertionMessage = exc.Message;
             }
-            catch (InvalidDataException exc)
+            catch (InvalidDataException)
             {
                 didAssert = true;
-                assertionMessage = exc.Message;
             }
-            catch (FormatException exc)
+            catch (FormatException)
             {
                 didAssert = true;
-                assertionMessage = exc.Message;
             }
-            catch (TrapException exc)
+            catch (TrapException)
             {
                 didAssert = true;
-                assertionMessage = exc.Message;
             }
             
             if (!didAssert)
@@ -482,19 +419,11 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class InvokeCommand : ICommand
     {
-        [JsonPropertyName("module")]
-        public string Module { get; set; }
-
-        [JsonPropertyName("name")]
-        public string Name { get; set; }
-
-        [JsonPropertyName("args")]
-        public List<object> Args { get; set; } = new List<object>();
-
+        [JsonPropertyName("module")] public string? Module { get; set; }
+        [JsonPropertyName("name")] public string? Name { get; set; }
+        [JsonPropertyName("args")] public List<object> Args { get; set; } = new List<object>();
         public CommandType Type => CommandType.Invoke;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -506,16 +435,10 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class GetCommand : ICommand
     {
-        [JsonPropertyName("module")]
-        public string Module { get; set; }
-
-        [JsonPropertyName("name")]
-        public string Name { get; set; }
-
+        [JsonPropertyName("module")] public string? Module { get; set; }
+        [JsonPropertyName("name")] public string? Name { get; set; }
         public CommandType Type => CommandType.Get;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -527,19 +450,11 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class SetCommand : ICommand
     {
-        [JsonPropertyName("module")]
-        public string Module { get; set; }
-
-        [JsonPropertyName("name")]
-        public string Name { get; set; }
-
-        [JsonPropertyName("value")]
-        public object Value { get; set; }
-
+        [JsonPropertyName("module")] public string? Module { get; set; }
+        [JsonPropertyName("name")] public string? Name { get; set; }
+        [JsonPropertyName("value")] public object? Value { get; set; }
         public CommandType Type => CommandType.Set;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -551,13 +466,9 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class StartCommand : ICommand
     {
-        [JsonPropertyName("module")]
-        public string Module { get; set; }
-
+        [JsonPropertyName("module")] public string? Module { get; set; }
         public CommandType Type => CommandType.Start;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -569,16 +480,10 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class AssertReturnCanonicalNansCommand : ICommand
     {
-        [JsonPropertyName("action")]
-        public IAction Action { get; set; }
-
-        [JsonPropertyName("expected")]
-        public List<object> Expected { get; set; } = new List<object>();
-
+        [JsonPropertyName("action")] public IAction? Action { get; set; }
+        [JsonPropertyName("expected")] public List<object> Expected { get; set; } = new List<object>();
         public CommandType Type => CommandType.AssertReturnCanonicalNans;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -590,16 +495,10 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class AssertReturnArithmeticNansCommand : ICommand
     {
-        [JsonPropertyName("action")]
-        public IAction Action { get; set; }
-
-        [JsonPropertyName("expected")]
-        public List<object> Expected { get; set; } = new List<object>();
-
+        [JsonPropertyName("action")] public IAction? Action { get; set; }
+        [JsonPropertyName("expected")] public List<object> Expected { get; set; } = new List<object>();
         public CommandType Type => CommandType.AssertReturnArithmeticNans;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -611,13 +510,9 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class AssertReturnDetachedCommand : ICommand
     {
-        [JsonPropertyName("action")]
-        public IAction Action { get; set; }
-
+        [JsonPropertyName("action")] public IAction? Action { get; set; }
         public CommandType Type => CommandType.AssertReturnDetached;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -629,13 +524,9 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class AssertTerminatedCommand : ICommand
     {
-        [JsonPropertyName("module")]
-        public string Module { get; set; }
-
+        [JsonPropertyName("module")] public string? Module { get; set; }
         public CommandType Type => CommandType.AssertTerminated;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -647,13 +538,9 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class AssertUndefinedCommand : ICommand
     {
-        [JsonPropertyName("module")]
-        public string Module { get; set; }
-
+        [JsonPropertyName("module")] public string? Module { get; set; }
         public CommandType Type => CommandType.AssertUndefined;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -665,13 +552,9 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class AssertExcludeFromMustCommand : ICommand
     {
-        [JsonPropertyName("module")]
-        public string Module { get; set; }
-
+        [JsonPropertyName("module")] public string? Module { get; set; }
         public CommandType Type => CommandType.AssertExcludeFromMust;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -683,13 +566,9 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class ModuleInstanceCommand : ICommand
     {
-        [JsonPropertyName("module")]
-        public string Module { get; set; }
-
+        [JsonPropertyName("module")] public string? Module { get; set; }
         public CommandType Type => CommandType.ModuleInstance;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -701,13 +580,9 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class ModuleExclusiveCommand : ICommand
     {
-        [JsonPropertyName("module")]
-        public string Module { get; set; }
-
+        [JsonPropertyName("module")] public string? Module { get; set; }
         public CommandType Type => CommandType.ModuleExclusive;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -719,13 +594,9 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class PumpCommand : ICommand
     {
-        [JsonPropertyName("action")]
-        public IAction Action { get; set; }
-
+        [JsonPropertyName("action")] public IAction? Action { get; set; }
         public CommandType Type => CommandType.Pump;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
@@ -737,13 +608,9 @@ public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime,
 
     public class MaybeCommand : ICommand
     {
-        [JsonPropertyName("command")]
-        public ICommand Command { get; set; }
-
+        [JsonPropertyName("command")] public ICommand? Command { get; set; }
         public CommandType Type => CommandType.Maybe;
-
-        [JsonPropertyName("line")]
-        public int Line { get; set; }
+        [JsonPropertyName("line")] public int Line { get; set; }
 
         public List<Exception> RunTest(WastJson testDefinition, ref WasmRuntime runtime, ref Module? module)
         {
diff --git a/Spec.Test/WastJson/EnumHelper.cs b/Spec.Test/WastJson/EnumHelper.cs
index 906882f..726702b 100644
--- a/Spec.Test/WastJson/EnumHelper.cs
+++ b/Spec.Test/WastJson/EnumHelper.cs
@@ -29,12 +29,12 @@ public static TEnum GetEnumValueFromString<TEnum>(string? value) where TEnum : E
                 if (Attribute.GetCustomAttribute(field, typeof(EnumMemberAttribute)) is EnumMemberAttribute attribute)
                 {
                     if (attribute.Value == value)
-                        return (TEnum)field.GetValue(null);
+                        return (TEnum)field.GetValue(null)!;
                 }
                 else
                 {
                     if (field.Name.Equals(value, StringComparison.OrdinalIgnoreCase))
-                        return (TEnum)field.GetValue(null);
+                        return (TEnum)field.GetValue(null)!;
                 }
             }
             throw new ArgumentException($"Unknown value '{value}' for enum {typeof(TEnum).Name}");
diff --git a/Spec.Test/WastJson/IAction.cs b/Spec.Test/WastJson/IAction.cs
index c8a2149..94394d8 100644
--- a/Spec.Test/WastJson/IAction.cs
+++ b/Spec.Test/WastJson/IAction.cs
@@ -14,8 +14,6 @@
 //  * limitations under the License.
 //  */
 
-using System.Collections.Generic;
-
 namespace Spec.Test.WastJson
 {
     public interface IAction
@@ -23,7 +21,5 @@ public interface IAction
         ActionType Type { get; }
 
         string Field { get; set; }
-
-        List<Argument> Args { get; set; }
     }
 }
\ No newline at end of file
diff --git a/Spec.Test/WastJson/WastJson.cs b/Spec.Test/WastJson/WastJson.cs
index da3fdc2..038b8a9 100644
--- a/Spec.Test/WastJson/WastJson.cs
+++ b/Spec.Test/WastJson/WastJson.cs
@@ -22,15 +22,15 @@ namespace Spec.Test.WastJson
     public class WastJson
     {
         [JsonPropertyName("source_filename")]
-        public string SourceFilename { get; set; }
+        public string? SourceFilename { get; set; }
 
         [JsonPropertyName("commands")]
-        public List<ICommand> Commands { get; set; }
+        public List<ICommand> Commands { get; set; } = null!;
 
         public string TestName => 
-            System.IO.Path.GetFileName(SourceFilename);
+            System.IO.Path.GetFileName(SourceFilename) ?? "";
 
-        public string Path { get; set; }
+        public string Path { get; set; } = "";
 
         public override string ToString() => $"{SourceFilename}";
     }
diff --git a/Spec.Test/WastJsonTestData.cs b/Spec.Test/WastJsonTestData.cs
index a097fed..73458c9 100644
--- a/Spec.Test/WastJsonTestData.cs
+++ b/Spec.Test/WastJsonTestData.cs
@@ -39,7 +39,7 @@ static WastJsonTestData()
                 .Build();
         }
 
-        private static string JsonDirectory => Path.Combine(AppContext.BaseDirectory,Configuration["JsonDirectory"]);
+        private static string JsonDirectory => Path.Combine(AppContext.BaseDirectory, Configuration["JsonDirectory"] ?? "");
 
         public IEnumerator<object[]> GetEnumerator()
         {
diff --git a/Wacs.Console/CommandLineOptions.cs b/Wacs.Console/CommandLineOptions.cs
index 1e337b3..682ff34 100644
--- a/Wacs.Console/CommandLineOptions.cs
+++ b/Wacs.Console/CommandLineOptions.cs
@@ -40,7 +40,7 @@ public class CommandLineOptions
 
         [Option('g', "log_gas", HelpText = "Print total instructions executed.", Default = false)]
         public bool LogGas { get; set; }
-        
+
         [Option('y', "limit_gas", HelpText = "Limit dispatched instructions.", Default = 0)]
         public int LimitGas { get; set; }
 
diff --git a/Wacs.Core/Runtime/Delegates.cs b/Wacs.Core/Runtime/Delegates.cs
index c8ce967..ca0d998 100644
--- a/Wacs.Core/Runtime/Delegates.cs
+++ b/Wacs.Core/Runtime/Delegates.cs
@@ -149,7 +149,10 @@ private static TDelegate CreateTypedDelegateInternal<TDelegate>(Delegate generic
         {
             // Get the 'Invoke' method of the desired delegate type
             var delegateInvokeMethod = typeof(TDelegate).GetMethod("Invoke");
-            var delegateParameters = delegateInvokeMethod?.GetParameters();
+            if (delegateInvokeMethod == null)
+                throw new ArgumentException($"Delegate type {typeof(TDelegate)} did not have Invoke() method");
+            
+            var delegateParameters = delegateInvokeMethod.GetParameters();
 
             if ((delegateParameters?.Length ?? 0) == 0)
             {
diff --git a/Wacs.Core/Runtime/ExecContext.cs b/Wacs.Core/Runtime/ExecContext.cs
index 7306f81..51a1f79 100644
--- a/Wacs.Core/Runtime/ExecContext.cs
+++ b/Wacs.Core/Runtime/ExecContext.cs
@@ -78,7 +78,7 @@ public ExecContext(Store store, RuntimeAttributes? attributes = default)
         private ReusableStack<Frame> FrameStack { get; }
         private SubStack<Frame> CallStack { get; }
         private ReusableStack<Label> LabelStack { get; }
-        
+
         private DefaultObjectPool<LocalsSpace> LocalsPool { get; }
 
         public Frame Frame => CallStack.Peek();
diff --git a/Wacs.Core/Runtime/Label.cs b/Wacs.Core/Runtime/Label.cs
index 60d9875..096055a 100644
--- a/Wacs.Core/Runtime/Label.cs
+++ b/Wacs.Core/Runtime/Label.cs
@@ -22,22 +22,13 @@ namespace Wacs.Core.Runtime
 {
     public class Label : IReusable<Label>
     {
-        public int StackHeight;
-        
         public int Arity;
 
-        public ByteCode Instruction;
-
         public InstructionPointer ContinuationAddress;
 
-        public void Set(ResultType type, InstructionPointer address, ByteCode inst, int stackHeight)
-        {
-            StackHeight = stackHeight;
-            Arity = type.Arity;
-            Instruction = inst;
-            ContinuationAddress = address;
-        }
-        
+        public ByteCode Instruction;
+        public int StackHeight;
+
         public void Clear()
         {
             Arity = default;
@@ -45,7 +36,7 @@ public void Clear()
             ContinuationAddress = default;
             StackHeight = default;
         }
-        
+
         public bool Equals(Label other)
         {
             return StackHeight == other.StackHeight &&
@@ -53,5 +44,13 @@ public bool Equals(Label other)
                    Instruction.Equals(other.Instruction) &&
                    ContinuationAddress.Equals(other.ContinuationAddress);
         }
+
+        public void Set(ResultType type, InstructionPointer address, ByteCode inst, int stackHeight)
+        {
+            StackHeight = stackHeight;
+            Arity = type.Arity;
+            Instruction = inst;
+            ContinuationAddress = address;
+        }
     }
 }
\ No newline at end of file
diff --git a/Wacs.Core/Runtime/RuntimeAttributes.cs b/Wacs.Core/Runtime/RuntimeAttributes.cs
index 3776577..43dc93c 100644
--- a/Wacs.Core/Runtime/RuntimeAttributes.cs
+++ b/Wacs.Core/Runtime/RuntimeAttributes.cs
@@ -21,14 +21,14 @@ namespace Wacs.Core.Runtime
     public class RuntimeAttributes
     {
         public bool Configure_RefTypes = false;
-        public bool Live = true;
+        public int GrowCallStack = 512;
 
         public int InitialCallStack = 512;
-        public int GrowCallStack = 512;
+        public bool Live = true;
         public int MaxCallStack = 2048;
-        
+
         public int MaxFunctionLocals = 2048;
-        
+
         public int MaxOpStack = 1024;
         public IInstructionFactory InstructionFactory { get; set; } = SpecFactory.Factory;
     }
diff --git a/Wacs.Core/Types/IndexSpace.cs b/Wacs.Core/Types/IndexSpace.cs
index 6aa501c..27f8fff 100644
--- a/Wacs.Core/Types/IndexSpace.cs
+++ b/Wacs.Core/Types/IndexSpace.cs
@@ -182,9 +182,15 @@ public override bool Contains(GlobalIdx idx) =>
     public class LocalsSpace : AbstractIndexSpace<LocalIdx, Value>
     {
         private readonly List<Value> _data = new();
-        
+
         public LocalsSpace() { }
-        
+
+        public override Value this[LocalIdx idx]
+        {
+            get => _data[(Index)idx];
+            set => _data[(Index)idx] = value;
+        }
+
         public void Enscribe(ValType[] parameters, ValType[] locals)
         {
             _data.Clear();
@@ -205,16 +211,8 @@ public void Reset()
             _data.Clear();
         }
 
-        public override Value this[LocalIdx idx]
-        {
-            get => _data[(Index)idx];
-            set => _data[(Index)idx] = value;
-        }
-
         public override bool Contains(LocalIdx idx) =>
             idx.Value < _data.Count;
-
-        
     }
 
     public class ElementsSpace : AbstractIndexSpace<ElemIdx, Module.ElementSegment>
diff --git a/Wacs.Core/Utilities/ReusableStack.cs b/Wacs.Core/Utilities/ReusableStack.cs
index c42d031..52a6487 100644
--- a/Wacs.Core/Utilities/ReusableStack.cs
+++ b/Wacs.Core/Utilities/ReusableStack.cs
@@ -23,8 +23,8 @@ namespace Wacs.Core.Utilities
     public class ReusableStack<T>
         where T : IReusable<T>, new()
     {
-        internal T[] _backingArray;
         private readonly int _growSize;
+        internal T[] _backingArray;
 
         internal int Top;
 

From 6023b6904dabd4fecc7dcb3e591ee0de2af81c07 Mon Sep 17 00:00:00 2001
From: Kelvin Nishikawa <kelnishi@gmail.com>
Date: Fri, 15 Nov 2024 15:38:44 -0800
Subject: [PATCH 6/6] WACS-v0.1.4

---
 Wacs.Core/Wacs.Core.csproj | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Wacs.Core/Wacs.Core.csproj b/Wacs.Core/Wacs.Core.csproj
index 4a981a7..8986e07 100644
--- a/Wacs.Core/Wacs.Core.csproj
+++ b/Wacs.Core/Wacs.Core.csproj
@@ -5,9 +5,9 @@
     <ImplicitUsings>disable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <LangVersion>9</LangVersion>
-    <AssemblyVersion>0.1.3</AssemblyVersion>
-    <FileVersion>0.1.3</FileVersion>
-    <Version>0.1.3</Version>
+    <AssemblyVersion>0.1.4</AssemblyVersion>
+    <FileVersion>0.1.4</FileVersion>
+    <Version>0.1.4</Version>
     <Authors>Kelvin Nishikawa</Authors>
     <Description>A Pure C# WebAssembly Interpreter</Description>
     <TrimUnusedDependencies>true</TrimUnusedDependencies>