// |jit-test| skip-if: !wasmCustomPageSizesEnabled()

for (const addrtype of ["i32", "i64"]) {
  console.log(`Address type: ${addrtype}`);

  function addr(n) {
    return addrtype === "i64" ? BigInt(n) : n;
  }

  // Dynamic i8 accesses
  {
    let instance = wasmEvalText(`(module
      (memory ${addrtype} 10 10 (pagesize 1))
      (func (export "f_off0") (param ${addrtype}) (result i32)
        (i32.store8 (local.get 0) (i32.const 42))
        (i32.load8_u (local.get 0))
      )
      (func (export "f_off2") (param ${addrtype}) (result i32)
        (i32.store8 offset=2 (local.get 0) (i32.const 42))
        (i32.load8_u offset=2 (local.get 0))
      )
    )`);

    assertEq(instance.exports.f_off0(addr(0)), 42);
    assertEq(instance.exports.f_off2(addr(0)), 42);
    assertEq(instance.exports.f_off0(addr(1)), 42);
    assertEq(instance.exports.f_off2(addr(1)), 42);
    assertEq(instance.exports.f_off0(addr(7)), 42);
    assertEq(instance.exports.f_off2(addr(7)), 42);
    assertEq(instance.exports.f_off0(addr(8)), 42);
    assertErrorMessage(() => instance.exports.f_off2(addr(8)), WebAssembly.RuntimeError, "index out of bounds");
    assertEq(instance.exports.f_off0(addr(9)), 42);
    assertErrorMessage(() => instance.exports.f_off2(addr(9)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(10)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(10)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(2**32-3)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(2**32-3)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    if (addrtype === "i64") {
      assertErrorMessage(() => instance.exports.f_off0(2n**64n-3n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off2(2n**64n-3n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off0(2n**64n-1n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off2(2n**64n-1n), WebAssembly.RuntimeError, "index out of bounds");
    }
  }

  // Constant i8 accesses
  {
    function f(n, name = null) {
      return `
        (func (export "f${name ?? n}_stk") (result i32)
          (i32.store8 (${addrtype}.const ${n}) (i32.const 42))
          (i32.load8_u (${addrtype}.const ${n}))
        )
        (func (export "f${name ?? n}_off") (result i32)
          (i32.store8 offset=${n} (${addrtype}.const 0) (i32.const 42))
          (i32.load8_u offset=${n} (${addrtype}.const 0))
        )
      `;
    }

    let instance = wasmEvalText(`(module
      (memory ${addrtype} 10 10 (pagesize 1))
      ${f(0)}
      ${f(1)}
      ${f(9)}
      ${f(10)}
      ${f(2**32-1, "32m1")}
      ${addrtype !== "i64" ? "" : `
        ${f(2n**64n-1n, "64m1")}
      `}
    )`);

    assertEq(instance.exports.f0_stk(), 42);
    assertEq(instance.exports.f0_off(), 42);
    assertEq(instance.exports.f1_stk(), 42);
    assertEq(instance.exports.f1_off(), 42);
    assertEq(instance.exports.f9_stk(), 42);
    assertEq(instance.exports.f9_off(), 42);
    assertErrorMessage(() => instance.exports.f10_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f10_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m1_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m1_off(), WebAssembly.RuntimeError, "index out of bounds");
    if (addrtype === "i64") {
      assertErrorMessage(() => instance.exports.f64m1_stk(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m1_off(), WebAssembly.RuntimeError, "index out of bounds");
    }
  }

  // Dynamic i16 accesses
  {
    let instance = wasmEvalText(`(module
      (memory ${addrtype} 10 10 (pagesize 1))
      (func (export "f_off0") (param ${addrtype}) (result i32)
        (i32.store16 (local.get 0) (i32.const 42))
        (i32.load16_u (local.get 0))
      )
      (func (export "f_off2") (param ${addrtype}) (result i32)
        (i32.store16 offset=2 (local.get 0) (i32.const 42))
        (i32.load16_u offset=2 (local.get 0))
      )
    )`);

    assertEq(instance.exports.f_off0(addr(0)), 42);
    assertEq(instance.exports.f_off2(addr(0)), 42);
    assertEq(instance.exports.f_off0(addr(1)), 42);
    assertEq(instance.exports.f_off2(addr(1)), 42);
    assertEq(instance.exports.f_off0(addr(7)), 42);
    assertErrorMessage(() => instance.exports.f_off2(addr(7)), WebAssembly.RuntimeError, "index out of bounds");
    assertEq(instance.exports.f_off0(addr(8)), 42);
    assertErrorMessage(() => instance.exports.f_off2(addr(8)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(9)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(9)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(10)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(10)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(2**32-4)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(2**32-4)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(2**32-2)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(2**32-2)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    if (addrtype === "i64") {
      assertErrorMessage(() => instance.exports.f_off0(2n**64n-4n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off2(2n**64n-4n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off0(2n**64n-2n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off2(2n**64n-2n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off0(2n**64n-1n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off2(2n**64n-1n), WebAssembly.RuntimeError, "index out of bounds");
    }
  }

  // Constant i16 accesses
  {
    function f(n, name = null) {
      return `
        (func (export "f${name ?? n}_stk") (result i32)
          (i32.store16 (${addrtype}.const ${n}) (i32.const 42))
          (i32.load16_u (${addrtype}.const ${n}))
        )
        (func (export "f${name ?? n}_off") (result i32)
          (i32.store16 offset=${n} (${addrtype}.const 0) (i32.const 42))
          (i32.load16_u offset=${n} (${addrtype}.const 0))
        )
      `;
    }

    let instance = wasmEvalText(`(module
      (memory ${addrtype} 10 10 (pagesize 1))
      ${f(0)}
      ${f(1)}
      ${f(8)}
      ${f(9)}
      ${f(10)}
      ${f(2**32-4, "32m4")}
      ${f(2**32-2, "32m2")}
      ${f(2**32-1, "32m1")}
      ${addrtype !== "i64" ? "" : `
        ${f(2n**64n-4n, "64m4")}
        ${f(2n**64n-2n, "64m2")}
        ${f(2n**64n-1n, "64m1")}
      `}
    )`);

    assertEq(instance.exports.f0_stk(), 42);
    assertEq(instance.exports.f0_off(), 42);
    assertEq(instance.exports.f1_stk(), 42);
    assertEq(instance.exports.f1_off(), 42);
    assertEq(instance.exports.f8_stk(), 42);
    assertEq(instance.exports.f8_off(), 42);
    assertErrorMessage(() => instance.exports.f9_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f9_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f10_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f10_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m4_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m4_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m2_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m2_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m1_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m1_off(), WebAssembly.RuntimeError, "index out of bounds");
    if (addrtype === "i64") {
      assertErrorMessage(() => instance.exports.f64m4_stk(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m4_off(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m2_stk(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m2_off(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m1_stk(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m1_off(), WebAssembly.RuntimeError, "index out of bounds");
    }
  }

  // Dynamic i32 accesses
  {
    let instance = wasmEvalText(`(module
      (memory ${addrtype} 10 10 (pagesize 1))
      (func (export "f_off0") (param ${addrtype}) (result i32)
        (i32.store (local.get 0) (i32.const 42))
        (i32.load (local.get 0))
      )
      (func (export "f_off2") (param ${addrtype}) (result i32)
        (i32.store offset=2 (local.get 0) (i32.const 42))
        (i32.load offset=2 (local.get 0))
      )
    )`);

    assertEq(instance.exports.f_off0(addr(0)), 42);
    assertEq(instance.exports.f_off2(addr(0)), 42);
    assertEq(instance.exports.f_off0(addr(1)), 42);
    assertEq(instance.exports.f_off2(addr(1)), 42);
    assertEq(instance.exports.f_off0(addr(4)), 42);
    assertEq(instance.exports.f_off2(addr(4)), 42);
    assertEq(instance.exports.f_off0(addr(5)), 42);
    assertErrorMessage(() => instance.exports.f_off2(addr(5)), WebAssembly.RuntimeError, "index out of bounds");
    assertEq(instance.exports.f_off0(addr(6)), 42);
    assertErrorMessage(() => instance.exports.f_off2(addr(6)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(7)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(7)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(8)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(8)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(9)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(9)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(10)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(10)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(2**32-6)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(2**32-6)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(2**32-4)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(2**32-4)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    if (addrtype === "i64") {
      assertErrorMessage(() => instance.exports.f_off0(2n**64n-6n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off2(2n**64n-6n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off0(2n**64n-4n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off2(2n**64n-4n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off0(2n**64n-1n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off2(2n**64n-1n), WebAssembly.RuntimeError, "index out of bounds");
    }
  }

  // Constant i32 accesses
  {
    function f(n, name = null) {
      return `
        (func (export "f${name ?? n}_stk") (result i32)
          (i32.store (${addrtype}.const ${n}) (i32.const 42))
          (i32.load (${addrtype}.const ${n}))
        )
        (func (export "f${name ?? n}_off") (result i32)
          (i32.store offset=${n} (${addrtype}.const 0) (i32.const 42))
          (i32.load offset=${n} (${addrtype}.const 0))
        )
      `;
    }

    let instance = wasmEvalText(`(module
      (memory ${addrtype} 10 10 (pagesize 1))
      ${f(0)}
      ${f(1)}
      ${f(6)}
      ${f(7)}
      ${f(8)}
      ${f(9)}
      ${f(10)}
      ${f(2**32-4, "32m4")}
      ${f(2**32-1, "32m1")}
      ${addrtype !== "i64" ? "" : `
        ${f(2n**64n-4n, "64m4")}
        ${f(2n**64n-1n, "64m1")}
      `}
    )`);

    assertEq(instance.exports.f0_stk(), 42);
    assertEq(instance.exports.f0_off(), 42);
    assertEq(instance.exports.f1_stk(), 42);
    assertEq(instance.exports.f1_off(), 42);
    assertEq(instance.exports.f6_stk(), 42);
    assertEq(instance.exports.f6_off(), 42);
    assertErrorMessage(() => instance.exports.f7_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f7_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f8_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f8_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f9_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f9_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f10_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f10_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m4_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m4_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m1_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m1_off(), WebAssembly.RuntimeError, "index out of bounds");
    if (addrtype === "i64") {
      assertErrorMessage(() => instance.exports.f64m4_stk(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m4_off(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m1_stk(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m1_off(), WebAssembly.RuntimeError, "index out of bounds");
    }
  }

  // Dynamic i64 accesses
  {
    let instance = wasmEvalText(`(module
      (memory ${addrtype} 10 10 (pagesize 1))
      (func (export "f_off0") (param ${addrtype}) (result i64)
        (i64.store (local.get 0) (i64.const 42))
        (i64.load (local.get 0))
      )
      (func (export "f_off2") (param ${addrtype}) (result i64)
        (i64.store offset=2 (local.get 0) (i64.const 42))
        (i64.load offset=2 (local.get 0))
      )
    )`);

    assertEq(instance.exports.f_off0(addr(0)), 42n);
    assertEq(instance.exports.f_off2(addr(0)), 42n);
    assertEq(instance.exports.f_off0(addr(1)), 42n);
    assertErrorMessage(() => instance.exports.f_off2(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertEq(instance.exports.f_off0(addr(2)), 42n);
    assertErrorMessage(() => instance.exports.f_off2(addr(2)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(3)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(3)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(6)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(6)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(7)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(7)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(8)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(8)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(9)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(9)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(10)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(10)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(2**32-10)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(2**32-10)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(2**32-8)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(2**32-8)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    if (addrtype === "i64") {
      assertErrorMessage(() => instance.exports.f_off0(2n**64n-10n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off2(2n**64n-10n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off0(2n**64n-8n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off2(2n**64n-8n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off0(2n**64n-1n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off2(2n**64n-1n), WebAssembly.RuntimeError, "index out of bounds");
    }
  }

  // Constant i64 accesses
  {
    function f(n, name = null) {
      return `
        (func (export "f${name ?? n}_stk") (result i64)
          (i64.store (${addrtype}.const ${n}) (i64.const 42))
          (i64.load (${addrtype}.const ${n}))
        )
        (func (export "f${name ?? n}_off") (result i64)
          (i64.store offset=${n} (${addrtype}.const 0) (i64.const 42))
          (i64.load offset=${n} (${addrtype}.const 0))
        )
      `;
    }

    let instance = wasmEvalText(`(module
      (memory ${addrtype} 10 10 (pagesize 1))
      ${f(0)}
      ${f(1)}
      ${f(2)}
      ${f(3)}
      ${f(6)}
      ${f(7)}
      ${f(8)}
      ${f(9)}
      ${f(10)}
      ${f(2**32-10, "32m10")}
      ${f(2**32-8, "32m8")}
      ${f(2**32-1, "32m1")}
      ${addrtype !== "i64" ? "" : `
        ${f(2n**64n-10n, "64m10")}
        ${f(2n**64n-8n, "64m8")}
        ${f(2n**64n-1n, "64m1")}
      `}
    )`);

    assertEq(instance.exports.f0_stk(), 42n);
    assertEq(instance.exports.f0_off(), 42n);
    assertEq(instance.exports.f1_stk(), 42n);
    assertEq(instance.exports.f1_off(), 42n);
    assertEq(instance.exports.f2_stk(), 42n);
    assertEq(instance.exports.f2_off(), 42n);
    assertErrorMessage(() => instance.exports.f3_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f3_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f6_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f6_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f7_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f7_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f8_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f8_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f9_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f9_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f10_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f10_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m10_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m10_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m8_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m8_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m1_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m1_off(), WebAssembly.RuntimeError, "index out of bounds");
    if (addrtype === "i64") {
      assertErrorMessage(() => instance.exports.f64m10_stk(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m10_off(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m8_stk(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m8_off(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m1_stk(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m1_off(), WebAssembly.RuntimeError, "index out of bounds");
    }
  }

  // Dynamic v128 accesses
  {
    let instance = wasmEvalText(`(module
      (memory ${addrtype} 20 20 (pagesize 1))

      (func $init
        (memory.fill (${addrtype}.const 0) (i32.const 0x2B) (${addrtype}.const 20))
      )
      (func (export "f_off0") (param ${addrtype}) (result i32)
        (i32x4.extract_lane 0 (v128.load (local.get 0)))
      )
      (func (export "f_off2") (param ${addrtype}) (result i32)
        (i32x4.extract_lane 0 (v128.load offset=2 (local.get 0)))
      )

      (start $init)
    )`);

    assertEq(instance.exports.f_off0(addr(0)), 0x2B2B2B2B);
    assertEq(instance.exports.f_off2(addr(0)), 0x2B2B2B2B);
    assertEq(instance.exports.f_off0(addr(1)), 0x2B2B2B2B);
    assertEq(instance.exports.f_off2(addr(1)), 0x2B2B2B2B);
    assertEq(instance.exports.f_off0(addr(2)), 0x2B2B2B2B);
    assertEq(instance.exports.f_off2(addr(2)), 0x2B2B2B2B);
    assertEq(instance.exports.f_off0(addr(3)), 0x2B2B2B2B);
    assertErrorMessage(() => instance.exports.f_off2(addr(3)), WebAssembly.RuntimeError, "index out of bounds");
    assertEq(instance.exports.f_off0(addr(4)), 0x2B2B2B2B);
    assertErrorMessage(() => instance.exports.f_off2(addr(4)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(5)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(5)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(17)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(17)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(18)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(18)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(19)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(19)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(20)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(20)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(2**32-18)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(2**32-18)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(2**32-16)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(2**32-16)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off0(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f_off2(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    if (addrtype === "i64") {
      assertErrorMessage(() => instance.exports.f_off0(2n**64n-18n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off2(2n**64n-18n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off0(2n**64n-16n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off2(2n**64n-16n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off0(2n**64n-1n), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f_off2(2n**64n-1n), WebAssembly.RuntimeError, "index out of bounds");
    }
  }

  // Constant v128 accesses
  {
    function f(n, name = null) {
      return `
        (func (export "f${name ?? n}_stk") (result i32)
          (i32x4.extract_lane 0 (v128.load (${addrtype}.const ${n})))
        )
        (func (export "f${name ?? n}_off") (result i32)
          (i32x4.extract_lane 0 (v128.load offset=${n} (${addrtype}.const 0)))
        )
      `;
    }

    let instance = wasmEvalText(`(module
      (memory ${addrtype} 20 20 (pagesize 1))

      (func $init
        (memory.fill (${addrtype}.const 0) (i32.const 0x2B) (${addrtype}.const 20))
      )
      (start $init)

      ${f(0)}
      ${f(1)}
      ${f(4)}
      ${f(5)}
      ${f(17)}
      ${f(18)}
      ${f(19)}
      ${f(20)}
      ${f(2**32-18, "32m18")}
      ${f(2**32-16, "32m16")}
      ${f(2**32-1, "32m1")}
      ${addrtype !== "i64" ? "" : `
        ${f(2n**64n-18n, "64m18")}
        ${f(2n**64n-16n, "64m16")}
        ${f(2n**64n-1n, "64m1")}
      `}
    )`);

    assertEq(instance.exports.f0_stk(), 0x2B2B2B2B);
    assertEq(instance.exports.f0_off(), 0x2B2B2B2B);
    assertEq(instance.exports.f1_stk(), 0x2B2B2B2B);
    assertEq(instance.exports.f1_off(), 0x2B2B2B2B);
    assertEq(instance.exports.f4_stk(), 0x2B2B2B2B);
    assertEq(instance.exports.f4_off(), 0x2B2B2B2B);
    assertErrorMessage(() => instance.exports.f5_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f5_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f17_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f17_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f18_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f18_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f19_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f19_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f20_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f20_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m18_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m18_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m16_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m16_off(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m1_stk(), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32m1_off(), WebAssembly.RuntimeError, "index out of bounds");
    if (addrtype === "i64") {
      assertErrorMessage(() => instance.exports.f64m18_stk(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m18_off(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m16_stk(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m16_off(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m1_stk(), WebAssembly.RuntimeError, "index out of bounds");
      assertErrorMessage(() => instance.exports.f64m1_off(), WebAssembly.RuntimeError, "index out of bounds");
    }
  }

  // Tiny memories: 0
  {
    let instance = wasmEvalText(`(module
      (memory ${addrtype} 0 0 (pagesize 1))
      (func (export "f8") (param ${addrtype})
        (i32.store8 (local.get 0) (i32.const 42))
      )
      (func (export "f16") (param ${addrtype})
        (i32.store16 (local.get 0) (i32.const 42))
      )
      (func (export "f32") (param ${addrtype})
        (i32.store (local.get 0) (i32.const 42))
      )
      (func (export "f64") (param ${addrtype})
        (i64.store (local.get 0) (i64.const 42))
      )
      (func (export "f128") (param ${addrtype})
        (v128.store (local.get 0) (v128.const i32x4 42 42 42 42))
      )
    )`);

    assertErrorMessage(() => instance.exports.f8(addr(0)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f8(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f8(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f16(addr(0)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f16(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f16(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32(addr(0)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f64(addr(0)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f64(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f64(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f128(addr(0)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f128(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f128(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
  }

  // Tiny memories: 1
  {
    let instance = wasmEvalText(`(module
      (memory ${addrtype} 1 1 (pagesize 1))
      (func (export "f8") (param ${addrtype})
        (i32.store8 (local.get 0) (i32.const 42))
      )
      (func (export "f16") (param ${addrtype})
        (i32.store16 (local.get 0) (i32.const 42))
      )
      (func (export "f32") (param ${addrtype})
        (i32.store (local.get 0) (i32.const 42))
      )
      (func (export "f64") (param ${addrtype})
        (i64.store (local.get 0) (i64.const 42))
      )
      (func (export "f128") (param ${addrtype})
        (v128.store (local.get 0) (v128.const i32x4 42 42 42 42))
      )
    )`);

    instance.exports.f8(addr(0));
    assertErrorMessage(() => instance.exports.f8(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f8(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f16(addr(0)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f16(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f16(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32(addr(0)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f64(addr(0)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f64(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f64(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f128(addr(0)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f128(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f128(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
  }

  // Tiny memories: 2
  {
    let instance = wasmEvalText(`(module
      (memory ${addrtype} 2 2 (pagesize 1))
      (func (export "f8") (param ${addrtype})
        (i32.store8 (local.get 0) (i32.const 42))
      )
      (func (export "f16") (param ${addrtype})
        (i32.store16 (local.get 0) (i32.const 42))
      )
      (func (export "f32") (param ${addrtype})
        (i32.store (local.get 0) (i32.const 42))
      )
      (func (export "f64") (param ${addrtype})
        (i64.store (local.get 0) (i64.const 42))
      )
      (func (export "f128") (param ${addrtype})
        (v128.store (local.get 0) (v128.const i32x4 42 42 42 42))
      )
    )`);

    instance.exports.f8(addr(0));
    instance.exports.f8(addr(1));
    assertErrorMessage(() => instance.exports.f8(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    instance.exports.f16(addr(0));
    assertErrorMessage(() => instance.exports.f16(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f16(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32(addr(0)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f64(addr(0)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f64(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f64(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f128(addr(0)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f128(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f128(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
  }

  // Tiny memories: 4
  {
    let instance = wasmEvalText(`(module
      (memory ${addrtype} 4 4 (pagesize 1))
      (func (export "f8") (param ${addrtype})
        (i32.store8 (local.get 0) (i32.const 42))
      )
      (func (export "f16") (param ${addrtype})
        (i32.store16 (local.get 0) (i32.const 42))
      )
      (func (export "f32") (param ${addrtype})
        (i32.store (local.get 0) (i32.const 42))
      )
      (func (export "f64") (param ${addrtype})
        (i64.store (local.get 0) (i64.const 42))
      )
      (func (export "f128") (param ${addrtype})
        (v128.store (local.get 0) (v128.const i32x4 42 42 42 42))
      )
    )`);

    instance.exports.f8(addr(0));
    instance.exports.f8(addr(1));
    assertErrorMessage(() => instance.exports.f8(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    instance.exports.f16(addr(0));
    instance.exports.f16(addr(1));
    assertErrorMessage(() => instance.exports.f16(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    instance.exports.f32(addr(0));
    assertErrorMessage(() => instance.exports.f32(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f32(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f64(addr(0)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f64(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f64(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f128(addr(0)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f128(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f128(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
  }

  // Tiny memories: 8
  {
    let instance = wasmEvalText(`(module
      (memory ${addrtype} 8 8 (pagesize 1))
      (func (export "f8") (param ${addrtype})
        (i32.store8 (local.get 0) (i32.const 42))
      )
      (func (export "f16") (param ${addrtype})
        (i32.store16 (local.get 0) (i32.const 42))
      )
      (func (export "f32") (param ${addrtype})
        (i32.store (local.get 0) (i32.const 42))
      )
      (func (export "f64") (param ${addrtype})
        (i64.store (local.get 0) (i64.const 42))
      )
      (func (export "f128") (param ${addrtype})
        (v128.store (local.get 0) (v128.const i32x4 42 42 42 42))
      )
    )`);

    instance.exports.f8(addr(0));
    instance.exports.f8(addr(1));
    assertErrorMessage(() => instance.exports.f8(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    instance.exports.f16(addr(0));
    instance.exports.f16(addr(1));
    assertErrorMessage(() => instance.exports.f16(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    instance.exports.f32(addr(0));
    instance.exports.f32(addr(1));
    assertErrorMessage(() => instance.exports.f32(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    instance.exports.f64(addr(0));
    assertErrorMessage(() => instance.exports.f64(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f64(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f128(addr(0)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f128(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f128(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
  }

  // Tiny memories: 16
  {
    let instance = wasmEvalText(`(module
      (memory ${addrtype} 16 16 (pagesize 1))
      (func (export "f8") (param ${addrtype})
        (i32.store8 (local.get 0) (i32.const 42))
      )
      (func (export "f16") (param ${addrtype})
        (i32.store16 (local.get 0) (i32.const 42))
      )
      (func (export "f32") (param ${addrtype})
        (i32.store (local.get 0) (i32.const 42))
      )
      (func (export "f64") (param ${addrtype})
        (i64.store (local.get 0) (i64.const 42))
      )
      (func (export "f128") (param ${addrtype})
        (v128.store (local.get 0) (v128.const i32x4 42 42 42 42))
      )
    )`);

    instance.exports.f8(addr(0));
    instance.exports.f8(addr(1));
    assertErrorMessage(() => instance.exports.f8(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    instance.exports.f16(addr(0));
    instance.exports.f16(addr(1));
    assertErrorMessage(() => instance.exports.f16(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    instance.exports.f32(addr(0));
    instance.exports.f32(addr(1));
    assertErrorMessage(() => instance.exports.f32(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    instance.exports.f64(addr(0));
    instance.exports.f64(addr(1));
    assertErrorMessage(() => instance.exports.f64(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
    instance.exports.f128(addr(0));
    assertErrorMessage(() => instance.exports.f128(addr(1)), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f128(addr(2**32-1)), WebAssembly.RuntimeError, "index out of bounds");
  }
}

// Test ARM-related cases
{
  let instance = wasmEvalText(`(module
      (memory i32 69648 69648 (pagesize 1))
      (func (export "f") (param i32)
        (i32.store8 (local.get 0) (i32.const 42))
      )
    )
  `);

  instance.exports.f(0)
  instance.exports.f(69647)
  assertErrorMessage(() => instance.exports.f(69648), WebAssembly.RuntimeError, "index out of bounds");
  assertErrorMessage(() => instance.exports.f(69649), WebAssembly.RuntimeError, "index out of bounds");
}

{
  let instance = wasmEvalText(`(module
      (memory i64 69648 69648 (pagesize 1))
      (func (export "f") (param i64)
        (i32.store8 (local.get 0) (i32.const 42))
      )
    )
  `);

  instance.exports.f(0n)
  instance.exports.f(69647n)
  assertErrorMessage(() => instance.exports.f(69648n), WebAssembly.RuntimeError, "index out of bounds");
  assertErrorMessage(() => instance.exports.f(69649n), WebAssembly.RuntimeError, "index out of bounds");
}

// Test bounds checking under 4GB.
{
  let instance = wasmEvalText(`(module
      (memory i64 5000 10000 (pagesize 1))
      (func (export "f")
        (i32.store (i64.const 11000) (i32.const 42))
      )
    )
  `);

  assertErrorMessage(() => instance.exports.f(), WebAssembly.RuntimeError, "index out of bounds");
}

{
  let instance = wasmEvalText(`(module
      (memory i64 5000 (pagesize 1))
      (func (export "f")
        (i32.store (i64.const 11000) (i32.const 42))
      )
    )
  `);

  assertErrorMessage(() => instance.exports.f(), WebAssembly.RuntimeError, "index out of bounds");
}

{
  let instance = wasmEvalText(`(module
      (memory i64 5000 128000 (pagesize 1))
      (func (export "f")
        (i32.store (i64.const 64000) (i32.const 42))
      )
    )
  `);

  assertErrorMessage(() => instance.exports.f(), WebAssembly.RuntimeError, "index out of bounds");
}

{
  let instance = wasmEvalText(`(module
      (memory i64 5000 10000 (pagesize 1))
      (func (export "f")
        (i32.store (i64.const 6000) (i32.const 42))
      )
    )
  `);

  assertErrorMessage(() => instance.exports.f(), WebAssembly.RuntimeError, "index out of bounds");
}

{
  let instance = wasmEvalText(`(module
      (memory i32 5000 10000 (pagesize 1))
      (func (export "f")
        (i32.store (i32.const 11000) (i32.const 42))
      )
    )
  `);

  assertErrorMessage(() => instance.exports.f(), WebAssembly.RuntimeError, "index out of bounds");
}

{
  let instance = wasmEvalText(`(module
      (memory i32 5000 128000 (pagesize 1))
      (func (export "f")
        (i32.store (i32.const 64000) (i32.const 42))
      )
    )
  `);

  assertErrorMessage(() => instance.exports.f(), WebAssembly.RuntimeError, "index out of bounds");
}

{
  let instance = wasmEvalText(`(module
      (memory i32 5000 10000 (pagesize 1))
      (func (export "f")
        (i32.store (i32.const 6000) (i32.const 42))
      )
    )
  `);

  assertErrorMessage(() => instance.exports.f(), WebAssembly.RuntimeError, "index out of bounds");
}

if (getBuildConfiguration("x86")) {
  assertErrorMessage(
    () => wasmEvalText(`(module
        (memory i32 4294967295 4294967295 (pagesize 1))
        (func (export "f") (param i32)
          (i32.store8 (local.get 0) (i32.const 42))
        )
      )
    `),
    WebAssembly.RuntimeError,
    "too many memory pages"
  );
} else {
  {
    let instance = wasmEvalText(`(module
        (memory i32 4294967295 4294967295 (pagesize 1))
        (func (export "f") (param i32)
          (i32.store8 (local.get 0) (i32.const 42))
        )
      )
    `);

    instance.exports.f(1);
    instance.exports.f(3000);
    instance.exports.f(4294967292);
    instance.exports.f(4294967293);
    instance.exports.f(4294967294);
    assertErrorMessage(() => instance.exports.f(4294967295), WebAssembly.RuntimeError, "index out of bounds");
  }

  {
    let instance = wasmEvalText(`(module
        (memory i32 4294967295 4294967295 (pagesize 1))
        (func (export "f") (param i32)
          (i32.store16 (local.get 0) (i32.const 42))
        )
      )
    `);

    instance.exports.f(1);
    instance.exports.f(3000);
    instance.exports.f(4294967292);
    instance.exports.f(4294967293);
    assertErrorMessage(() => instance.exports.f(4294967294), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f(4294967295), WebAssembly.RuntimeError, "index out of bounds");
  }

  {
    let instance = wasmEvalText(`(module
        (memory i32 4294967295 (pagesize 1))
        (func (export "f") (param i32)
          (i32.store16 (local.get 0) (i32.const 42))
        )
      )
    `);

    instance.exports.f(1);
    instance.exports.f(3000);
    instance.exports.f(4294967292);
    instance.exports.f(4294967293);
    assertErrorMessage(() => instance.exports.f(4294967294), WebAssembly.RuntimeError, "index out of bounds");
    assertErrorMessage(() => instance.exports.f(4294967295), WebAssembly.RuntimeError, "index out of bounds");
  }
}

// Ensure bounds checking above 4GB works as expected.
if (getBuildConfiguration("x86")) {
  assertErrorMessage(
    () => wasmEvalText(`(module
        (memory i64 4294967299 4294967299 (pagesize 1))
        (func (export "f")
          (i32.store (i64.const 4294967300) (i32.const 42))
        )
      )
    `),
    WebAssembly.RuntimeError,
    "too many memory pages"
  );
} else {
  let instance = wasmEvalText(`(module
      (memory i64 4294967299 4294967299 (pagesize 1))
      (func (export "f")
        (i32.store (i64.const 4294967300) (i32.const 42))
      )
    )
  `);

  assertErrorMessage(() => instance.exports.f(), WebAssembly.RuntimeError, "index out of bounds");
}