negative offset

Author: dimitropoulos

packages/conformance-tests/from-wat/memory-offset-negative.dump

@@ -0,0 +1,123 @@
+Module {
+    span: Span {
+        offset: 1,
+    },
+    id: None,
+    name: None,
+    kind: Text(
+        [
+            Memory(
+                Memory {
+                    span: Span {
+                        offset: 11,
+                    },
+                    id: Some(
+                        "memory",
+                    ),
+                    name: None,
+                    exports: InlineExport {
+                        names: [
+                            "memory",
+                        ],
+                    },
+                    kind: Normal(
+                        B32 {
+                            limits: Limits {
+                                min: 1,
+                                max: None,
+                            },
+                            shared: false,
+                        },
+                    ),
+                },
+            ),
+            Func(
+                Func {
+                    span: Span {
+                        offset: 51,
+                    },
+                    id: Some(
+                        "entry",
+                    ),
+                    name: None,
+                    exports: InlineExport {
+                        names: [
+                            "entry",
+                        ],
+                    },
+                    kind: Inline {
+                        locals: [],
+                        expression: Expression {
+                            instrs: [
+                                I32Const(
+                                    0,
+                                ),
+                                LocalGet(
+                                    Id(
+                                        "value",
+                                    ),
+                                ),
+                                I32Store(
+                                    MemArg {
+                                        align: 4,
+                                        offset: 20,
+                                        memory: Num(
+                                            0,
+                                            Span {
+                                                offset: 162,
+                                            },
+                                        ),
+                                    },
+                                ),
+                                I32Const(
+                                    0,
+                                ),
+                                I32Load(
+                                    MemArg {
+                                        align: 4,
+                                        offset: 20,
+                                        memory: Num(
+                                            0,
+                                            Span {
+                                                offset: 202,
+                                            },
+                                        ),
+                                    },
+                                ),
+                            ],
+                        },
+                    },
+                    ty: TypeUse {
+                        index: None,
+                        inline: Some(
+                            FunctionType {
+                                params: [
+                                    (
+                                        Some(
+                                            "value",
+                                        ),
+                                        None,
+                                        I32,
+                                    ),
+                                ],
+                                results: [
+                                    I32,
+                                ],
+                            },
+                        ),
+                    },
+                },
+            ),
+        ],
+    ),
+}
+
+
+
+
+{
+    "I32Const": 2,
+    "LocalGet": 1,
+    "I32Store": 1,
+    "I32Load": 1,
+}

packages/conformance-tests/from-wat/memory-offset-negative.test.ts

@@ -0,0 +1,25 @@
+import type { Expect, Equal } from 'type-testing';
+import type { entry } from "./memory-offset-negative"
+
+import { getWasm } from '../utils'
+import { expect, test } from 'vitest';
+
+const name = 'memory-offset-negative';
+test(name, async () => {
+  const entry = await getWasm("from-wat", name);
+  expect(entry(-2)).toStrictEqual(-2);
+  expect(entry(-1)).toStrictEqual(-1);
+  expect(entry( 0)).toStrictEqual( 0);
+  expect(entry( 1)).toStrictEqual( 1);
+  expect(entry( 2)).toStrictEqual( 2);
+});
+
+type testCases = [
+  Expect<Equal<entry<[-2]>, -2>>,
+  Expect<Equal<entry<[-1]>, -1>>,
+  Expect<Equal<entry<[0]>,   0>>,
+  Expect<Equal<entry<[1]>,   1>>,
+  Expect<Equal<entry<[2]>,   2>>,
+  // Expect<Equal<entry<[-1, -100, 10]>, -89>>,
+  // Expect<Equal<entry<[-1, -2, -3]>, -4>>,
+]

packages/conformance-tests/from-wat/memory-offset-negative.ts

@@ -0,0 +1,37 @@
+import type { Func, bootstrap } from 'wasm-to-typescript-types'
+
+type $entry = Satisfies<Func, {
+  kind: 'func';
+  params: ['$value'];
+  paramsTypes: ['i32'];
+  resultTypes: ['i32'];
+  locals: [];
+  instructions: [
+    { kind: 'Const'; value: '00000000000000000000000000000000' },
+    { kind: 'LocalGet'; id: '$value' },
+    { kind: 'Store'; subkind: 'I32Store'; offset: '00000000000000000000000000010100' },
+    { kind: 'Const'; value: '00000000000000000000000000000000' },
+    { kind: 'Load'; subkind: 'I32Load'; offset: '00000000000000000000000000010100' },
+  ];
+}>
+
+export type funcs = {
+  $entry: $entry;
+}
+
+export type entry<
+  arguments extends [number],
+  debugMode extends boolean = false,
+  stopAt extends number = number,
+> = bootstrap<
+  {
+    arguments: arguments;
+    funcs: funcs;
+    globals: {};
+    memory: {};
+    memorySize: '00000000000000000000000000000001';
+    indirect: {};
+  },
+  debugMode,
+  stopAt
+>

packages/conformance-tests/from-wat/memory-offset-negative.wasm

@@ -0,0 +1,12 @@
+(module
+  (memory $memory (export "memory") 1)
+
+  (func $entry (export "entry") (param $value i32) (result i32)
+    i32.const -1
+    local.get $value
+    i32.store offset=20
+
+    i32.const -1
+    i32.load offset=20
+  )
+)