Eine aufbereitete Darstellung der Quelle

 
     
 
 
Anforderungen  |   Konzepte  |   Entwurf  |   Entwicklung  |   Qualitätssicherung  |   Lebenszyklus  |   Steuerung
 
 
 
 
Benutzer

products/Sources/formale Sprachen/C/Firefox/js/src/jit-test/tests/wasm/custom-page-sizes/   (Firefox Browser Version 153.0.1©)  Datei vom 27.6.2026 mit Größe 48 kB image not shown  

Impressum runtime.js

  Sprache: JAVA 		 

// |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");
}

Messung V0.5 in Prozent
C=95 H=96 G=95

¤ Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.0.35Bemerkung:  (vorverarbeitet am  2026-08-26) ¤

*Bot Zugriff




Wurzel

Suchen

PVS Prover

Isabelle Prover

NIST Cobol Testsuite

Cephes Mathematical Library

Vienna Development Method

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.





                                                                                                                                                                                                                                                                                                                                                                                                     

Neuigkeiten

     Aktuelles
     Motto des Tages

Open Source Software

     Quellcodebibliothek
     Eigene Quellcodes
     Fremde Quellcodes
     Suchen
Jenseits des Üblichen ....

Besucherstatistik

Besucherstatistik
Statistik
#Sources=277311
#Domains=752002