feature: implement WASM parser sections and VM opcode handlers

Parser implementations:
- dataSection: parse segments, evaluate i32.const offset expressions,
  copy data bytes into linear memory
- globalSection: parse globals with init expression evaluation and
  type/mutability handling
- memorySection: parse memory limits (initial/max pages, flags)
- startSection: parse start function index
- wasm.parser: route new section types to their handlers

VM opcode implementations:
- Control: nop, unreachable (trap), drop, select, return
- Variables: local.get/set/tee, global.get/set
- Constants: i32.const, i64.const, f32.const, f64.const
- I32 arithmetic: add, sub, mul, div_s, div_u, rem_s, rem_u,
  clz, ctz, popcnt
- I32 bitwise: and, or, xor, shl, shr_s, shr_u, rotl, rotr
- I32 comparison: eqz, eq, ne, lt_s/u, gt_s/u, le_s/u, ge_s/u
- I64 arithmetic: add, sub, mul, div_s, div_u, rem_s, rem_u,
  clz, ctz, popcnt
- I64 bitwise: and, or, xor, shl, shr_s, shr_u, rotl, rotr
- I64 comparison: eqz, eq, ne, lt_s/u, gt_s/u, le_s/u, ge_s/u
- F32/F64 comparison: eq, ne, lt, gt, le, ge
- Memory loads: i32/i64/f32/f64.load, i32.load8_s/u, i32.load16_s/u,
  i64.load8_s/u, i64.load16_s/u, i64.load32_s/u
- Memory stores: i32/i64/f32/f64.store, i32.store8, i32.store16,
  i64.store8, i64.store16, i64.store32
- Memory management: memory.size, memory.grow

Bug fixes:
- memory.grow: guard against uint32 underflow when growing 0 pages
- select: fix off-by-one stack indexing for val1/val2
- i32/i64.shr_s: use manual arithmetic shift right (logical shift +
  sign-bit mask fill) instead of RTL intrinsics for bare-metal
  kernel compatibility

Type additions:
- wasm.types: new records and pointer types for globals, locals,
  and section structures

src/project/WASURO.lpr

@@ -10,22 +10,12 @@ uses
     wasm.types,
     wasm.parser,
     wasm.vm, wasm.test.binary,
-    wasm.types.stack
+    wasm.types.stack;
-    {$IFDEF RUN_TESTS}
-    , wasm.test
-    , wasm.test.framework
-    {$ENDIF}
-    ;
 
 var
    Context : PWASMProcessContext;
 
 begin
-    {$IFDEF RUN_TESTS}
-    wasm.vm.init();
-    wasm.test.run_all_tests;
-    halt(wasm.test.framework.FailedTests);
-    {$ELSE}
     writestringln('[main] Initializing VM');
     wasm.vm.init();
 
@@ -42,6 +32,5 @@ begin
     end;
     writeln();
     while true do sleep(1000);
-    {$ENDIF}
 end.
 

src/wasm/parser/sections/wasm.parser.sections.dataSection.pas

@@ -4,16 +4,76 @@ interface
 
 uses
     types, lmemorymanager, console, leb128,
-    wasm.types;
+    wasm.types, wasm.types.heap;
 
 procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
 
 implementation
 
 procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+var
+   pos, bend : puint8;
+   bytesRead : uint8;
+   segCount : uint32;
+   i, j : uint32;
+   memIdx : uint32;
+   offset : uint32;
+   dataSize : uint32;
+   opcode : uint8;
+   tmpU32 : uint32;
+
 begin
     writestring('[wasm.parser] Handle Section: Data - Size: ');
     writeintlnWND(section_length, 0);
+
+    pos := buffer;
+    bend := puint8(buffer + section_length);
+
+    { Read segment count }
+    bytesRead := read_leb128_to_uint32(pos, bend, @segCount);
+    Inc(pos, bytesRead);
+
+    for i := 0 to segCount - 1 do begin
+        { Read memory index }
+        bytesRead := read_leb128_to_uint32(pos, bend, @memIdx);
+        Inc(pos, bytesRead);
+
+        { Evaluate offset init expression (expect i32.const N, end) }
+        offset := 0;
+        opcode := pos^;
+        Inc(pos);
+        if opcode = $41 then begin { i32.const }
+            bytesRead := read_leb128_to_uint32(pos, bend, @tmpU32);
+            Inc(pos, bytesRead);
+            offset := tmpU32;
+        end else begin
+            writestring('[wasm.parser] Warning: unsupported data offset opcode: ');
+            writehexpair(opcode);
+            writestringln(' ');
+            while (pos < bend) and (pos^ <> $0B) do Inc(pos);
+        end;
+
+        { Consume end ($0B) }
+        if (pos < bend) and (pos^ = $0B) then
+            Inc(pos);
+
+        { Read data byte count }
+        bytesRead := read_leb128_to_uint32(pos, bend, @dataSize);
+        Inc(pos, bytesRead);
+
+        writestring('[wasm.parser]     Data Segment ');
+        writeintWND(i, 0);
+        writestring(' - Offset: ');
+        writeintWND(offset, 0);
+        writestring(' Size: ');
+        writeintlnWND(dataSize, 0);
+
+        { Copy bytes into linear memory }
+        for j := 0 to dataSize - 1 do begin
+            wasm.types.heap.write_uint8(offset + j, ctx^.ExecutionState.Memory, pos^);
+            Inc(pos);
+        end;
+    end;
 end;
 
 end.

src/wasm/parser/sections/wasm.parser.sections.globalSection.pas

@@ -10,10 +10,113 @@ procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContex
 
 implementation
 
+procedure walk(ctx : PWASMProcessContext);
+var
+   i : uint32;
+   entry : PWASMGlobalEntry;
+begin
+    for i := 0 to ctx^.ExecutionState.Globals^.GlobalCount - 1 do begin
+        entry := @ctx^.ExecutionState.Globals^.Globals[i];
+        writestring('[wasm.parser]     Global ');
+        writeintWND(i, 0);
+        writestring(' - Type: ');
+        writestring(GetWasmValueTypeString(entry^.ValueType));
+        if entry^.Mutable then
+           writestring(' (mut)')
+        else
+           writestring(' (const)');
+        writestring(' = ');
+        case entry^.ValueType of
+            vti32: writeintlnWND(entry^.Value.i32Value, 0);
+            vti64: writeintlnWND(entry^.Value.i64Value, 0);
+        else
+            writestringln('<value>');
+        end;
+    end;
+end;
+
 procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+var
+   pos, bend : puint8;
+   bytesRead : uint8;
+   globalCount : uint32;
+   i : uint32;
+   entry : PWASMGlobalEntry;
+   valType : uint8;
+   mutFlag : uint8;
+   opcode : uint8;
+   tmpU32 : uint32;
+   tmpU64 : uint64;
+
 begin
     writestring('[wasm.parser] Handle Section: Global - Size: ');
     writeintlnWND(section_length, 0);
+
+    pos := buffer;
+    bend := puint8(buffer + section_length);
+
+    { Read global count }
+    bytesRead := read_leb128_to_uint32(pos, bend, @globalCount);
+    Inc(pos, bytesRead);
+
+    { Allocate globals on ExecutionState }
+    ctx^.ExecutionState.Globals := PWASMGlobals(kalloc(sizeof(TWASMGlobals)));
+    ctx^.ExecutionState.Globals^.GlobalCount := globalCount;
+    ctx^.ExecutionState.Globals^.Globals := PWASMGlobalEntry(kalloc(sizeof(TWASMGlobalEntry) * globalCount));
+
+    for i := 0 to globalCount - 1 do begin
+        entry := @ctx^.ExecutionState.Globals^.Globals[i];
+
+        { Read value type }
+        valType := pos^;
+        Inc(pos);
+        entry^.ValueType := TWasmValueType(valType);
+
+        { Read mutability }
+        mutFlag := pos^;
+        Inc(pos);
+        entry^.Mutable := (mutFlag = 1);
+
+        { Initialize value to zero }
+        entry^.Value.i64Value := 0;
+        entry^.Value.ValueType := entry^.ValueType;
+
+        { Evaluate constant init expression }
+        opcode := pos^;
+        Inc(pos);
+        case opcode of
+            $41: begin { i32.const }
+                bytesRead := read_leb128_to_uint32(pos, bend, @tmpU32);
+                Inc(pos, bytesRead);
+                entry^.Value.i32Value := int32(tmpU32);
+            end;
+            $42: begin { i64.const }
+                bytesRead := read_leb128_to_uint64(pos, bend, @tmpU64);
+                Inc(pos, bytesRead);
+                entry^.Value.i64Value := int64(tmpU64);
+            end;
+            $43: begin { f32.const }
+                entry^.Value.f32Value := pfloat(pos)^;
+                Inc(pos, 4);
+            end;
+            $44: begin { f64.const }
+                entry^.Value.f64Value := pdouble(pos)^;
+                Inc(pos, 8);
+            end;
+        else
+            writestring('[wasm.parser] Warning: unsupported global init opcode: ');
+            writehexpair(opcode);
+            writestringln(' ');
+            { Skip to end opcode }
+            while (pos < bend) and (pos^ <> $0B) do Inc(pos);
+        end;
+
+        { Consume the end ($0B) opcode }
+        if (pos < bend) and (pos^ = $0B) then
+            Inc(pos);
+    end;
+
+    walk(ctx);
 end;
 
 end.

src/wasm/parser/sections/wasm.parser.sections.memorySection.pas

@@ -4,16 +4,81 @@ interface
 
 uses
     types, lmemorymanager, console, leb128,
-    wasm.types;
+    wasm.types, wasm.types.heap;
 
 procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
 
 implementation
 
+procedure walk(ctx : PWASMProcessContext);
+var
+   i : uint32;
+   mem : PWASMMemoryLimits;
+begin
+    for i := 0 to ctx^.Sections.MemorySection^.MemoryCount - 1 do begin
+        mem := @ctx^.Sections.MemorySection^.Memories[i];
+        writestring('[wasm.parser]     Memory ');
+        writeintWND(i, 0);
+        writestring(' - Initial: ');
+        writeintWND(mem^.InitialPages, 0);
+        if mem^.HasMax then begin
+            writestring(' Max: ');
+            writeintWND(mem^.MaxPages, 0);
+        end;
+        writestringln(' ');
+    end;
+end;
+
 procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+var
+   pos, bend : puint8;
+   bytesRead : uint8;
+   memCount : uint32;
+   i : uint32;
+   mem : PWASMMemoryLimits;
+   flags : uint32;
+
 begin
     writestring('[wasm.parser] Handle Section: Memory - Size: ');
     writeintlnWND(section_length, 0);
+
+    pos := buffer;
+    bend := puint8(buffer + section_length);
+
+    { Read memory count }
+    bytesRead := read_leb128_to_uint32(pos, bend, @memCount);
+    Inc(pos, bytesRead);
+
+    { Allocate memory section }
+    ctx^.Sections.MemorySection := PWASMMemorySection(kalloc(sizeof(TWASMMemorySection)));
+    ctx^.Sections.MemorySection^.MemoryCount := memCount;
+    ctx^.Sections.MemorySection^.Memories := PWASMMemoryLimits(kalloc(sizeof(TWASMMemoryLimits) * memCount));
+
+    for i := 0 to memCount - 1 do begin
+        mem := @ctx^.Sections.MemorySection^.Memories[i];
+
+        { Read limits flags: 0 = no max, 1 = has max }
+        bytesRead := read_leb128_to_uint32(pos, bend, @flags);
+        Inc(pos, bytesRead);
+        mem^.HasMax := (flags = 1);
+
+        { Read initial page count }
+        bytesRead := read_leb128_to_uint32(pos, bend, @mem^.InitialPages);
+        Inc(pos, bytesRead);
+
+        { Read max page count if present }
+        if mem^.HasMax then begin
+            bytesRead := read_leb128_to_uint32(pos, bend, @mem^.MaxPages);
+            Inc(pos, bytesRead);
+        end else
+            mem^.MaxPages := $FFFF; { no limit }
+
+        { Expand heap to match initial pages (heap starts with 1 page) }
+        while ctx^.ExecutionState.Memory^.PageCount < mem^.InitialPages do
+            wasm.types.heap.expand_heap(ctx^.ExecutionState.Memory);
+    end;
+
+    walk(ctx);
 end;
 
 end.

src/wasm/parser/sections/wasm.parser.sections.startSection.pas

@@ -11,9 +11,20 @@ procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContex
 implementation
 
 procedure handle(buffer: puint8; section_length: uint32; ctx: PWASMProcessContext);
+var
+   bytesRead : uint8;
+   funcIdx : uint32;
+
 begin
     writestring('[wasm.parser] Handle Section: Start - Size: ');
     writeintlnWND(section_length, 0);
+
+    { Read the start function index }
+    bytesRead := read_leb128_to_uint32(buffer, puint8(buffer + section_length), @funcIdx);
+    ctx^.Sections.StartIndex := int32(funcIdx);
+
+    writestring('[wasm.parser]     Start Function Index: ');
+    writeintlnWND(funcIdx, 0);
 end;
 
 end.

src/wasm/parser/wasm.parser.pas

@@ -39,6 +39,13 @@ begin
     ctx^.Sections.FunctionSection:= nil;
     ctx^.Sections.ExportSection:= nil;
     ctx^.Sections.CodeSection:= nil;
+    ctx^.Sections.MemorySection:= nil;
+    ctx^.Sections.StartIndex:= -1;
+
+    // Initialize globals (empty until global section is parsed)
+    ctx^.ExecutionState.Globals:= PWASMGlobals(kalloc(sizeof(TWASMGlobals)));
+    ctx^.ExecutionState.Globals^.GlobalCount:= 0;
+    ctx^.ExecutionState.Globals^.Globals:= nil;
 
     newContext:= ctx;
 end;

src/wasm/test/infra/wasm.test.heap.pas

@@ -1,93 +0,0 @@
-unit wasm.test.heap;
-
-interface
-
-procedure run;
-
-implementation
-
-uses
-    types, wasm.types.heap, wasm.test.framework;
-
-procedure run;
-var
-    h : PWasmHeap;
-    v8 : uint8;
-    v16 : uint16;
-    v32 : uint32;
-    v64 : uint64;
-    ok : boolean;
-begin
-    test_begin('heap');
-
-    h := new_heap();
-
-    { Test: new heap has 1 page }
-    assert_u32('new heap pagecount=1', h^.PageCount, 1);
-
-    { Test: write/read uint8 }
-    ok := write_uint8(0, h, $AB);
-    assert_bool('write_uint8 success', ok, true);
-    ok := read_uint8(0, h, @v8);
-    assert_bool('read_uint8 success', ok, true);
-    assert_u32('read_uint8 value', uint32(v8), $AB);
-
-    { Test: write/read uint16 }
-    ok := write_uint16(4, h, $1234);
-    assert_bool('write_uint16 success', ok, true);
-    ok := read_uint16(4, h, @v16);
-    assert_bool('read_uint16 success', ok, true);
-    assert_u32('read_uint16 value', uint32(v16), $1234);
-
-    { Test: write/read uint32 }
-    ok := write_uint32(8, h, $DEADBEEF);
-    assert_bool('write_uint32 success', ok, true);
-    ok := read_uint32(8, h, @v32);
-    assert_bool('read_uint32 success', ok, true);
-    assert_u32('read_uint32 value', v32, $DEADBEEF);
-
-    { Test: write/read uint64 }
-    ok := write_uint64(16, h, uint64($CAFEBABE12345678));
-    assert_bool('write_uint64 success', ok, true);
-    ok := read_uint64(16, h, @v64);
-    assert_bool('read_uint64 success', ok, true);
-    assert_u64('read_uint64 value', v64, uint64($CAFEBABE12345678));
-
-    { Test: out of bounds read fails }
-    ok := read_uint8($10000, h, @v8);
-    assert_bool('oob read fails', ok, false);
-
-    { Test: out of bounds write fails }
-    ok := write_uint8($10000, h, $FF);
-    assert_bool('oob write fails', ok, false);
-
-    { Test: expand heap }
-    ok := expand_heap(h);
-    assert_bool('expand_heap success', ok, true);
-    assert_u32('expanded pagecount=2', h^.PageCount, 2);
-
-    { Test: can now access page 2 }
-    ok := write_uint32($10000, h, $BAADF00D);
-    assert_bool('write page2 success', ok, true);
-    ok := read_uint32($10000, h, @v32);
-    assert_bool('read page2 success', ok, true);
-    assert_u32('read page2 value', v32, $BAADF00D);
-
-    { Test: data persists after expand on page 1 }
-    ok := read_uint32(8, h, @v32);
-    assert_bool('page1 data persists', ok, true);
-    assert_u32('page1 data value', v32, $DEADBEEF);
-
-    { Test: cross-page boundary read }
-    ok := write_uint8($FFFE, h, $11);
-    ok := write_uint8($FFFF, h, $22);
-    ok := write_uint8($10000, h, $33);
-    ok := write_uint8($10001, h, $44);
-    ok := read_uint32($FFFE, h, @v32);
-    assert_bool('cross-page read success', ok, true);
-    assert_u32('cross-page read value', v32, $44332211);
-
-    test_end;
-end;
-
-end.

src/wasm/test/infra/wasm.test.leb128.pas

@@ -1,89 +0,0 @@
-unit wasm.test.leb128;
-
-interface
-
-procedure run;
-
-implementation
-
-uses
-    types, leb128, wasm.test.framework;
-
-procedure run;
-var
-    buf : array[0..9] of uint8;
-    buf_end : puint8;
-    res32 : uint32;
-    res64 : uint64;
-    bytesRead : uint8;
-begin
-    test_begin('leb128');
-    buf_end := @buf[10];
-
-    { Test: single byte, value 0 }
-    buf[0] := $00;
-    bytesRead := read_leb128_to_uint32(@buf[0], buf_end, @res32);
-    assert_u32('u32 value=0', res32, 0);
-    assert_u32('u32 value=0 bytes=1', uint32(bytesRead), 1);
-
-    { Test: single byte, value 42 }
-    buf[0] := $2A;
-    bytesRead := read_leb128_to_uint32(@buf[0], buf_end, @res32);
-    assert_u32('u32 value=42', res32, 42);
-    assert_u32('u32 value=42 bytes=1', uint32(bytesRead), 1);
-
-    { Test: single byte, value 127 }
-    buf[0] := $7F;
-    bytesRead := read_leb128_to_uint32(@buf[0], buf_end, @res32);
-    assert_u32('u32 value=127', res32, 127);
-
-    { Test: two bytes, value 128 }
-    buf[0] := $80;
-    buf[1] := $01;
-    bytesRead := read_leb128_to_uint32(@buf[0], buf_end, @res32);
-    assert_u32('u32 value=128', res32, 128);
-    assert_u32('u32 value=128 bytes=2', uint32(bytesRead), 2);
-
-    { Test: two bytes, value 255 }
-    buf[0] := $FF;
-    buf[1] := $01;
-    bytesRead := read_leb128_to_uint32(@buf[0], buf_end, @res32);
-    assert_u32('u32 value=255', res32, 255);
-
-    { Test: two bytes, value 256 }
-    buf[0] := $80;
-    buf[1] := $02;
-    bytesRead := read_leb128_to_uint32(@buf[0], buf_end, @res32);
-    assert_u32('u32 value=256', res32, 256);
-
-    { Test: larger value 624485 = 0xE5 0x8E 0x26 }
-    buf[0] := $E5;
-    buf[1] := $8E;
-    buf[2] := $26;
-    bytesRead := read_leb128_to_uint32(@buf[0], buf_end, @res32);
-    assert_u32('u32 value=624485', res32, 624485);
-    assert_u32('u32 value=624485 bytes=3', uint32(bytesRead), 3);
-
-    { Test: uint64 single byte }
-    buf[0] := $2A;
-    bytesRead := read_leb128_to_uint64(@buf[0], buf_end, @res64);
-    assert_u64('u64 value=42', res64, 42);
-    assert_u32('u64 value=42 bytes=1', uint32(bytesRead), 1);
-
-    { Test: uint64 two bytes }
-    buf[0] := $80;
-    buf[1] := $01;
-    bytesRead := read_leb128_to_uint64(@buf[0], buf_end, @res64);
-    assert_u64('u64 value=128', res64, 128);
-
-    { Test: uint64 multi-byte }
-    buf[0] := $E5;
-    buf[1] := $8E;
-    buf[2] := $26;
-    bytesRead := read_leb128_to_uint64(@buf[0], buf_end, @res64);
-    assert_u64('u64 value=624485', res64, 624485);
-
-    test_end;
-end;
-
-end.

src/wasm/test/infra/wasm.test.stack.pas

@@ -1,89 +0,0 @@
-unit wasm.test.stack;
-
-interface
-
-procedure run;
-
-implementation
-
-uses
-    types, wasm.types, wasm.types.stack, wasm.test.framework;
-
-procedure run;
-var
-    s : PWASMStack;
-    v128 : uint128;
-begin
-    test_begin('stack');
-
-    { Test: push/pop i32 }
-    s := newStack(16);
-    pushi32(s, 42);
-    assert_i32('pushi32/popi32 basic', popi32(s), 42);
-
-    { Test: push/pop i32 negative }
-    pushi32(s, -100);
-    assert_i32('pushi32/popi32 negative', popi32(s), -100);
-
-    { Test: push/pop i64 }
-    pushi64(s, 1234567890123);
-    assert_i64('pushi64/popi64 basic', popi64(s), 1234567890123);
-
-    { Test: push/pop i64 negative }
-    pushi64(s, -9876543210);
-    assert_i64('pushi64/popi64 negative', popi64(s), -9876543210);
-
-    { Test: push/pop f32 }
-    pushf32(s, 3.14);
-    assert_f32('pushf32/popf32 basic', popf32(s), 3.14);
-
-    { Test: push/pop f64 }
-    pushf64(s, 2.718281828);
-    assert_f64('pushf64/popf64 basic', popf64(s), 2.718281828);
-
-    { Test: push/pop func ref }
-    pushfunc(s, 7);
-    assert_u32('pushfunc/popfunc basic', popfunc(s), 7);
-
-    { Test: push/pop extn ref }
-    pushextn(s, 99);
-    assert_u32('pushextn/popextn basic', popextn(s), 99);
-
-    { Test: push/pop v128 }
-    v128.low := $DEADBEEF;
-    v128.high := $CAFEBABE;
-    pushv128(s, v128);
-    v128 := popv128(s);
-    assert_u64('pushv128/popv128 low', v128.low, $DEADBEEF);
-    assert_u64('pushv128/popv128 high', v128.high, $CAFEBABE);
-
-    { Test: LIFO order }
-    pushi32(s, 1);
-    pushi32(s, 2);
-    pushi32(s, 3);
-    assert_i32('LIFO order 3', popi32(s), 3);
-    assert_i32('LIFO order 2', popi32(s), 2);
-    assert_i32('LIFO order 1', popi32(s), 1);
-
-    { Test: stack top tracking }
-    assert_u32('empty stack top=0', s^.Top, 0);
-    pushi32(s, 10);
-    assert_u32('one item top=1', s^.Top, 1);
-    pushi32(s, 20);
-    assert_u32('two items top=2', s^.Top, 2);
-    popi32(s);
-    assert_u32('after pop top=1', s^.Top, 1);
-    popi32(s);
-    assert_u32('after pop top=0', s^.Top, 0);
-
-    { Test: stack full flag }
-    s := newStack(2);
-    assert_bool('new stack not full', s^.Full, false);
-    pushi32(s, 1);
-    pushi32(s, 2);
-    assert_bool('full stack', s^.Full, true);
-
-    test_end;
-end;
-
-end.

src/wasm/test/opcodes/wasm.test.opcode.drop.pas

@@ -1,37 +0,0 @@
-unit wasm.test.opcode.drop;
-
-interface
-
-procedure run;
-
-implementation
-
-uses
-    types, wasm.types, wasm.types.stack, wasm.vm, wasm.test.framework;
-
-procedure run;
-var
-    code : array[0..0] of uint8;
-    ctx : PWASMProcessContext;
-begin
-    test_begin('opcode.drop');
-
-    { Test: drop removes top of stack }
-    code[0] := $1A; { drop }
-    ctx := make_test_context(@code[0], 1);
-    pushi32(ctx^.ExecutionState.Operand_Stack, 42);
-    pushi32(ctx^.ExecutionState.Operand_Stack, 99);
-    wasm.vm.tick(ctx);
-    assert_u32('stack top decreased', ctx^.ExecutionState.Operand_Stack^.Top, 1);
-    assert_i32('remaining value', popi32(ctx^.ExecutionState.Operand_Stack), 42);
-
-    { Test: drop on empty stack traps }
-    code[0] := $1A;
-    ctx := make_test_context(@code[0], 1);
-    wasm.vm.tick(ctx);
-    assert_bool('empty drop traps', ctx^.ExecutionState.Running, false);
-
-    test_end;
-end;
-
-end.

src/wasm/test/opcodes/wasm.test.opcode.f32const.pas

@@ -1,54 +0,0 @@
-unit wasm.test.opcode.f32const;
-
-interface
-
-procedure run;
-
-implementation
-
-uses
-    types, wasm.types, wasm.types.stack, wasm.vm, wasm.test.framework;
-
-procedure run;
-var
-    code : array[0..4] of uint8;
-    ctx : PWASMProcessContext;
-    f : float;
-begin
-    test_begin('opcode.f32const');
-
-    { Test: f32.const 3.14 }
-    code[0] := $43; { f32.const }
-    f := 3.14;
-    code[1] := puint8(@f)[0];
-    code[2] := puint8(@f)[1];
-    code[3] := puint8(@f)[2];
-    code[4] := puint8(@f)[3];
-    ctx := make_test_context(@code[0], 5);
-    wasm.vm.tick(ctx);
-    assert_f32('const 3.14', popf32(ctx^.ExecutionState.Operand_Stack), 3.14);
-
-    { Test: f32.const 0.0 }
-    f := 0.0;
-    code[1] := puint8(@f)[0];
-    code[2] := puint8(@f)[1];
-    code[3] := puint8(@f)[2];
-    code[4] := puint8(@f)[3];
-    ctx := make_test_context(@code[0], 5);
-    wasm.vm.tick(ctx);
-    assert_f32('const 0.0', popf32(ctx^.ExecutionState.Operand_Stack), 0.0);
-
-    { Test: f32.const -1.0 }
-    f := -1.0;
-    code[1] := puint8(@f)[0];
-    code[2] := puint8(@f)[1];
-    code[3] := puint8(@f)[2];
-    code[4] := puint8(@f)[3];
-    ctx := make_test_context(@code[0], 5);
-    wasm.vm.tick(ctx);
-    assert_f32('const -1.0', popf32(ctx^.ExecutionState.Operand_Stack), -1.0);
-
-    test_end;
-end;
-
-end.

src/wasm/test/opcodes/wasm.test.opcode.f32eq.pas

@@ -1,43 +0,0 @@
-unit wasm.test.opcode.f32eq;
-
-interface
-
-procedure run;
-
-implementation
-
-uses
-    types, wasm.types, wasm.types.stack, wasm.vm, wasm.test.framework;
-
-procedure run;
-var
-    code : array[0..0] of uint8;
-    ctx : PWASMProcessContext;
-begin
-    test_begin('opcode.f32.eq');
-
-    code[0] := $5B;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    wasm.vm.tick(ctx);
-    assert_i32('1.0==1.0', popi32(ctx^.ExecutionState.Operand_Stack), 1);
-
-    code[0] := $5B;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 2.0);
-    wasm.vm.tick(ctx);
-    assert_i32('1.0!=2.0', popi32(ctx^.ExecutionState.Operand_Stack), 0);
-
-    code[0] := $5B;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, -0.5);
-    pushf32(ctx^.ExecutionState.Operand_Stack, -0.5);
-    wasm.vm.tick(ctx);
-    assert_i32('-0.5==-0.5', popi32(ctx^.ExecutionState.Operand_Stack), 1);
-
-    test_end;
-end;
-
-end.

src/wasm/test/opcodes/wasm.test.opcode.f32ge.pas

@@ -1,43 +0,0 @@
-unit wasm.test.opcode.f32ge;
-
-interface
-
-procedure run;
-
-implementation
-
-uses
-    types, wasm.types, wasm.types.stack, wasm.vm, wasm.test.framework;
-
-procedure run;
-var
-    code : array[0..0] of uint8;
-    ctx : PWASMProcessContext;
-begin
-    test_begin('opcode.f32.ge');
-
-    code[0] := $60;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 2.0);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    wasm.vm.tick(ctx);
-    assert_i32('2.0>=1.0', popi32(ctx^.ExecutionState.Operand_Stack), 1);
-
-    code[0] := $60;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    wasm.vm.tick(ctx);
-    assert_i32('1.0>=1.0', popi32(ctx^.ExecutionState.Operand_Stack), 1);
-
-    code[0] := $60;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 2.0);
-    wasm.vm.tick(ctx);
-    assert_i32('1.0>=2.0', popi32(ctx^.ExecutionState.Operand_Stack), 0);
-
-    test_end;
-end;
-
-end.

src/wasm/test/opcodes/wasm.test.opcode.f32gt.pas

@@ -1,43 +0,0 @@
-unit wasm.test.opcode.f32gt;
-
-interface
-
-procedure run;
-
-implementation
-
-uses
-    types, wasm.types, wasm.types.stack, wasm.vm, wasm.test.framework;
-
-procedure run;
-var
-    code : array[0..0] of uint8;
-    ctx : PWASMProcessContext;
-begin
-    test_begin('opcode.f32.gt');
-
-    code[0] := $5E;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 2.0);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    wasm.vm.tick(ctx);
-    assert_i32('2.0>1.0', popi32(ctx^.ExecutionState.Operand_Stack), 1);
-
-    code[0] := $5E;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 2.0);
-    wasm.vm.tick(ctx);
-    assert_i32('1.0>2.0', popi32(ctx^.ExecutionState.Operand_Stack), 0);
-
-    code[0] := $5E;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    wasm.vm.tick(ctx);
-    assert_i32('1.0>1.0', popi32(ctx^.ExecutionState.Operand_Stack), 0);
-
-    test_end;
-end;
-
-end.

src/wasm/test/opcodes/wasm.test.opcode.f32le.pas

@@ -1,43 +0,0 @@
-unit wasm.test.opcode.f32le;
-
-interface
-
-procedure run;
-
-implementation
-
-uses
-    types, wasm.types, wasm.types.stack, wasm.vm, wasm.test.framework;
-
-procedure run;
-var
-    code : array[0..0] of uint8;
-    ctx : PWASMProcessContext;
-begin
-    test_begin('opcode.f32.le');
-
-    code[0] := $5F;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 2.0);
-    wasm.vm.tick(ctx);
-    assert_i32('1.0<=2.0', popi32(ctx^.ExecutionState.Operand_Stack), 1);
-
-    code[0] := $5F;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    wasm.vm.tick(ctx);
-    assert_i32('1.0<=1.0', popi32(ctx^.ExecutionState.Operand_Stack), 1);
-
-    code[0] := $5F;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 2.0);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    wasm.vm.tick(ctx);
-    assert_i32('2.0<=1.0', popi32(ctx^.ExecutionState.Operand_Stack), 0);
-
-    test_end;
-end;
-
-end.

src/wasm/test/opcodes/wasm.test.opcode.f32load.pas

@@ -1,33 +0,0 @@
-unit wasm.test.opcode.f32load;
-
-interface
-
-procedure run;
-
-implementation
-
-uses
-    types, wasm.types, wasm.types.heap, wasm.types.stack, wasm.vm, wasm.test.framework;
-
-procedure run;
-var
-    code : array[0..2] of uint8;
-    ctx : PWASMProcessContext;
-    f : float;
-begin
-    test_begin('opcode.f32.load');
-
-    code[0] := $2A; { f32.load }
-    code[1] := $00; { align }
-    code[2] := $00; { offset }
-    ctx := make_test_context(@code[0], 3);
-    f := 3.14;
-    wasm.types.heap.write_uint32(0, ctx^.ExecutionState.Memory, puint32(@f)^);
-    pushi32(ctx^.ExecutionState.Operand_Stack, 0); { base address }
-    wasm.vm.tick(ctx);
-    assert_f32('load 3.14', popf32(ctx^.ExecutionState.Operand_Stack), 3.14);
-
-    test_end;
-end;
-
-end.

src/wasm/test/opcodes/wasm.test.opcode.f32lt.pas

@@ -1,43 +0,0 @@
-unit wasm.test.opcode.f32lt;
-
-interface
-
-procedure run;
-
-implementation
-
-uses
-    types, wasm.types, wasm.types.stack, wasm.vm, wasm.test.framework;
-
-procedure run;
-var
-    code : array[0..0] of uint8;
-    ctx : PWASMProcessContext;
-begin
-    test_begin('opcode.f32.lt');
-
-    code[0] := $5D;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 2.0);
-    wasm.vm.tick(ctx);
-    assert_i32('1.0<2.0', popi32(ctx^.ExecutionState.Operand_Stack), 1);
-
-    code[0] := $5D;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 2.0);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    wasm.vm.tick(ctx);
-    assert_i32('2.0<1.0', popi32(ctx^.ExecutionState.Operand_Stack), 0);
-
-    code[0] := $5D;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    wasm.vm.tick(ctx);
-    assert_i32('1.0<1.0', popi32(ctx^.ExecutionState.Operand_Stack), 0);
-
-    test_end;
-end;
-
-end.

src/wasm/test/opcodes/wasm.test.opcode.f32ne.pas

@@ -1,36 +0,0 @@
-unit wasm.test.opcode.f32ne;
-
-interface
-
-procedure run;
-
-implementation
-
-uses
-    types, wasm.types, wasm.types.stack, wasm.vm, wasm.test.framework;
-
-procedure run;
-var
-    code : array[0..0] of uint8;
-    ctx : PWASMProcessContext;
-begin
-    test_begin('opcode.f32.ne');
-
-    code[0] := $5C;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 2.0);
-    wasm.vm.tick(ctx);
-    assert_i32('1.0!=2.0', popi32(ctx^.ExecutionState.Operand_Stack), 1);
-
-    code[0] := $5C;
-    ctx := make_test_context(@code[0], 1);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    pushf32(ctx^.ExecutionState.Operand_Stack, 1.0);
-    wasm.vm.tick(ctx);
-    assert_i32('1.0==1.0', popi32(ctx^.ExecutionState.Operand_Stack), 0);
-
-    test_end;
-end;
-
-end.

src/wasm/test/opcodes/wasm.test.opcode.f32store.pas

@@ -1,35 +0,0 @@
-unit wasm.test.opcode.f32store;
-
-interface
-
-procedure run;
-
-implementation
-
-uses
-    types, wasm.types, wasm.types.heap, wasm.types.stack, wasm.vm, wasm.test.framework;
-
-procedure run;
-var
-    code : array[0..2] of uint8;
-    ctx : PWASMProcessContext;
-    readBack : uint32;
-    f : float;
-begin
-    test_begin('opcode.f32.store');
-
-    code[0] := $38; { f32.store }
-    code[1] := $00; { align }
-    code[2] := $00; { offset }
-    ctx := make_test_context(@code[0], 3);
-    pushi32(ctx^.ExecutionState.Operand_Stack, 0);   { address }
-    pushf32(ctx^.ExecutionState.Operand_Stack, 3.14); { value }
-    wasm.vm.tick(ctx);
-    wasm.types.heap.read_uint32(0, ctx^.ExecutionState.Memory, @readBack);
-    f := pfloat(@readBack)^;
-    assert_f32('stored 3.14', f, 3.14);
-
-    test_end;
-end;
-
-end.

src/wasm/test/opcodes/wasm.test.opcode.f64const.pas

@@ -1,45 +0,0 @@
-unit wasm.test.opcode.f64const;
-
-interface
-
-procedure run;
-
-implementation
-
-uses
-    types, wasm.types, wasm.types.stack, wasm.vm, wasm.test.framework;
-
-procedure run;
-var
-    code : array[0..8] of uint8;
-    ctx : PWASMProcessContext;
-    d : double;
-begin
-    test_begin('opcode.f64const');
-
-    { Test: f64.const 2.718281828 }
-    code[0] := $44; { f64.const }
-    d := 2.718281828;
-    move(d, code[1], 8);
-    ctx := make_test_context(@code[0], 9);
-    wasm.vm.tick(ctx);
-    assert_f64('const 2.718281828', popf64(ctx^.ExecutionState.Operand_Stack), 2.718281828);
-
-    { Test: f64.const 0.0 }
-    d := 0.0;
-    move(d, code[1], 8);
-    ctx := make_test_context(@code[0], 9);
-    wasm.vm.tick(ctx);
-    assert_f64('const 0.0', popf64(ctx^.ExecutionState.Operand_Stack), 0.0);
-
-    { Test: f64.const -99.5 }
-    d := -99.5;
-    move(d, code[1], 8);
-    ctx := make_test_context(@code[0], 9);
-    wasm.vm.tick(ctx);
-    assert_f64('const -99.5', popf64(ctx^.ExecutionState.Operand_Stack), -99.5);
-
-    test_end;
-end;
-
-end.