summaryrefslogtreecommitdiffstats
path: root/js/src/jit-test/tests/wasm/globals.js
diff options
context:
space:
mode:
Diffstat (limited to 'js/src/jit-test/tests/wasm/globals.js')
-rw-r--r--js/src/jit-test/tests/wasm/globals.js556
1 files changed, 556 insertions, 0 deletions
diff --git a/js/src/jit-test/tests/wasm/globals.js b/js/src/jit-test/tests/wasm/globals.js
new file mode 100644
index 0000000000..186ceb6350
--- /dev/null
+++ b/js/src/jit-test/tests/wasm/globals.js
@@ -0,0 +1,556 @@
+// |jit-test| test-also=--wasm-extended-const; test-also=--no-wasm-extended-const
+
+const { Instance, Module, LinkError } = WebAssembly;
+
+// Locally-defined globals
+assertErrorMessage(() => wasmEvalText(`(module (global))`), SyntaxError, /wasm text error/);
+// A global field in the text format is valid with an empty expression, but this produces an invalid module
+assertErrorMessage(() => wasmEvalText(`(module (global i32))`), WebAssembly.CompileError, /popping value/);
+assertErrorMessage(() => wasmEvalText(`(module (global (mut i32)))`), WebAssembly.CompileError, /popping value/);
+
+// Initializer expressions.
+wasmFailValidateText(`(module (global i32 (f32.const 13.37)))`, /type mismatch/);
+wasmFailValidateText(`(module (global f64 (f32.const 13.37)))`, /type mismatch/);
+
+wasmFailValidateText(`(module (global i32 (global.get 0)))`, /out of range/);
+wasmFailValidateText(`(module (global i32 (global.get 1)) (global i32 (i32.const 1)))`, /out of range/);
+
+// Test a well-defined global section.
+function testInner(type, initialValue, nextValue, coercion)
+{
+ var module = wasmEvalText(`(module
+ (global (mut ${type}) (${type}.const ${initialValue}))
+ (global ${type} (${type}.const ${initialValue}))
+
+ (func $get (result ${type}) (global.get 0))
+ (func $set (param ${type}) (global.set 0 (local.get 0)))
+
+ (func $get_cst (result ${type}) (global.get 1))
+
+ (export "get" (func $get))
+ (export "get_cst" (func $get_cst))
+
+ (export "set" (func $set))
+ )`).exports;
+
+ assertEq(module.get(), coercion(initialValue));
+ assertEq(module.set(coercion(nextValue)), undefined);
+ assertEq(module.get(), coercion(nextValue));
+
+ assertEq(module.get_cst(), coercion(initialValue));
+}
+
+testInner('i32', 13, 37, x => x|0);
+testInner('f32', 13.37, 0.1989, Math.fround);
+testInner('f64', 13.37, 0.1989, x => +x);
+
+// Extended const stuff
+if (wasmExtendedConstEnabled()) {
+ // Basic global shenanigans
+ {
+ const module = wasmEvalText(`(module
+ ;; -2 * (5 - (-10 + 20)) = 10
+ (global i32 (i32.mul (i32.const -2) (i32.sub (i32.const 5) (i32.add (i32.const -10) (i32.const 20)))))
+ ;; ((1 + 2) - (3 * 4)) = -9
+ (global i64 (i64.sub (i64.add (i64.const 1) (i64.const 2)) (i64.mul (i64.const 3) (i64.const 4))))
+
+ (func (export "get0") (result i32) global.get 0)
+ (func (export "get1") (result i64) global.get 1)
+ )`).exports;
+
+ assertEq(module.get0(), 10);
+ assertEq(module.get1(), -9n);
+ }
+
+ // Example use of dynamic linking
+ {
+ // Make a memory for two dynamically-linked modules to share. Each module gets five pages.
+ const mem = new WebAssembly.Memory({ initial: 15, maximum: 15 });
+
+ const mod1 = new WebAssembly.Module(wasmTextToBinary(`(module
+ (memory (import "env" "memory") 15 15)
+ (global $memBase (import "env" "__memory_base") i32)
+ (data (offset (global.get $memBase)) "Hello from module 1.")
+ (data (offset (i32.add (global.get $memBase) (i32.const 65536))) "Goodbye from module 1.")
+ )`));
+ const instance1 = new WebAssembly.Instance(mod1, {
+ env: {
+ memory: mem,
+ __memory_base: 65536 * 5, // this module's memory starts at page 5
+ },
+ });
+
+ const mod2 = new WebAssembly.Module(wasmTextToBinary(`(module
+ (memory (import "env" "memory") 15 15)
+ (global $memBase (import "env" "__memory_base") i32)
+ (data (offset (global.get $memBase)) "Hello from module 2.")
+ (data (offset (i32.add (global.get $memBase) (i32.const 65536))) "Goodbye from module 2.")
+ )`));
+ const instance2 = new WebAssembly.Instance(mod2, {
+ env: {
+ memory: mem,
+ __memory_base: 65536 * 10, // this module's memory starts at page 10
+ },
+ });
+
+ // All four strings should now be present in the memory.
+
+ function assertStringInMem(mem, str, addr) {
+ const bytes = new Uint8Array(mem.buffer).slice(addr, addr + str.length);
+ let memStr = String.fromCharCode(...bytes);
+ assertEq(memStr, str);
+ }
+
+ assertStringInMem(mem, "Hello from module 1.", 65536 * 5);
+ assertStringInMem(mem, "Goodbye from module 1.", 65536 * 6);
+ assertStringInMem(mem, "Hello from module 2.", 65536 * 10);
+ assertStringInMem(mem, "Goodbye from module 2.", 65536 * 11);
+ }
+}
+
+// Semantic errors.
+wasmFailValidateText(`(module (global (mut i32) (i32.const 1337)) (func (global.set 1 (i32.const 0))))`, /(out of range)|(global index out of bounds)/);
+wasmFailValidateText(`(module (global i32 (i32.const 1337)) (func (global.set 0 (i32.const 0))))`, /(can't write an immutable global)|(global is immutable)/);
+
+// Big module with many variables: test that setting one doesn't overwrite the
+// other ones.
+function get_set(i, type) {
+ return `
+ (func $get_${i} (result ${type}) (global.get ${i}))
+ (func $set_${i} (param ${type}) (global.set ${i} (local.get 0)))
+ `;
+}
+
+var module = wasmEvalText(`(module
+ (global (mut i32) (i32.const 42))
+ (global (mut i32) (i32.const 10))
+ (global (mut f32) (f32.const 13.37))
+ (global (mut f64) (f64.const 13.37))
+ (global (mut i32) (i32.const -18))
+
+ ${get_set(0, 'i32')}
+ ${get_set(1, 'i32')}
+ ${get_set(2, 'f32')}
+ ${get_set(3, 'f64')}
+ ${get_set(4, 'i32')}
+
+ (export "get0" (func $get_0)) (export "set0" (func $set_0))
+ (export "get1" (func $get_1)) (export "set1" (func $set_1))
+ (export "get2" (func $get_2)) (export "set2" (func $set_2))
+ (export "get3" (func $get_3)) (export "set3" (func $set_3))
+ (export "get4" (func $get_4)) (export "set4" (func $set_4))
+)`).exports;
+
+let values = [42, 10, Math.fround(13.37), 13.37, -18];
+let nextValues = [13, 37, Math.fround(-17.89), 9.3, -13];
+for (let i = 0; i < 5; i++) {
+ assertEq(module[`get${i}`](), values[i]);
+ assertEq(module[`set${i}`](nextValues[i]), undefined);
+ assertEq(module[`get${i}`](), nextValues[i]);
+ for (let j = 0; j < 5; j++) {
+ if (i === j)
+ continue;
+ assertEq(module[`get${j}`](), values[j]);
+ }
+ assertEq(module[`set${i}`](values[i]), undefined);
+ assertEq(module[`get${i}`](), values[i]);
+}
+
+// Initializer expressions can also be used in elem section initializers.
+wasmFailValidateText(`(module (import "globals" "a" (global f32)) (table 4 funcref) (elem (global.get 0) $f) (func $f))`, /type mismatch/);
+
+module = wasmEvalText(`(module
+ (import "globals" "a" (global i32))
+ (table (export "tbl") 4 funcref)
+ (elem (global.get 0) $f)
+ (func $f)
+ (export "f" (func $f))
+)`, {
+ globals: {
+ a: 1
+ }
+}).exports;
+assertEq(module.f, module.tbl.get(1));
+
+// Import/export semantics.
+module = wasmEvalText(`(module
+ (import "globals" "x" (global $g i32))
+ (func $get (result i32) (global.get $g))
+ (export "getter" (func $get))
+ (export "value" (global 0))
+)`, { globals: {x: 42} }).exports;
+
+assertEq(module.getter(), 42);
+
+// assertEq() will not trigger @@toPrimitive, so we must have a cast here.
+assertEq(Number(module.value), 42);
+
+// Can only import numbers (no implicit coercions).
+module = new Module(wasmTextToBinary(`(module
+ (global (import "globs" "i32") i32)
+ (global (import "globs" "f32") f32)
+ (global (import "globs" "f64") f32)
+)`));
+
+const assertLinkFails = (m, imp, err) => {
+ assertErrorMessage(() => new Instance(m, imp), LinkError, err);
+}
+
+var imp = {
+ globs: {
+ i32: 0,
+ f32: Infinity,
+ f64: NaN
+ }
+};
+
+let i = new Instance(module, imp);
+
+for (let v of [
+ null,
+ {},
+ "42",
+ /not a number/,
+ false,
+ undefined,
+ Symbol(),
+ { valueOf() { return 42; } }
+]) {
+ imp.globs.i32 = v;
+ assertLinkFails(module, imp, /not a Number/);
+
+ imp.globs.i32 = 0;
+ imp.globs.f32 = v;
+ assertLinkFails(module, imp, /not a Number/);
+
+ imp.globs.f32 = Math.fround(13.37);
+ imp.globs.f64 = v;
+ assertLinkFails(module, imp, /not a Number/);
+
+ imp.globs.f64 = 13.37;
+}
+
+// Imported globals and locally defined globals use the same index space.
+module = wasmEvalText(`(module
+ (import "globals" "x" (global i32))
+ (global i32 (i32.const 1337))
+ (export "imported" (global 0))
+ (export "defined" (global 1))
+)`, { globals: {x: 42} }).exports;
+
+assertEq(Number(module.imported), 42);
+assertEq(Number(module.defined), 1337);
+
+// Initializer expressions can reference an imported immutable global.
+wasmFailValidateText(`(module (global f32 (f32.const 13.37)) (global i32 (global.get 0)))`, /must reference a global immutable import/);
+wasmFailValidateText(`(module (global (mut f32) (f32.const 13.37)) (global i32 (global.get 0)))`, /must reference a global immutable import/);
+wasmFailValidateText(`(module (global (mut i32) (i32.const 0)) (global i32 (global.get 0)))`, /must reference a global immutable import/);
+
+wasmFailValidateText(`(module (import "globals" "a" (global f32)) (global i32 (global.get 0)))`, /type mismatch/);
+
+function testInitExpr(type, initialValue, nextValue, coercion, assertFunc = assertEq) {
+ var module = wasmEvalText(`(module
+ (import "globals" "a" (global ${type}))
+
+ (global $glob_mut (mut ${type}) (global.get 0))
+ (global $glob_imm ${type} (global.get 0))
+
+ (func $get0 (result ${type}) (global.get 0))
+
+ (func $get1 (result ${type}) (global.get 1))
+ (func $set1 (param ${type}) (global.set 1 (local.get 0)))
+
+ (func $get_cst (result ${type}) (global.get 2))
+
+ (export "get0" (func $get0))
+ (export "get1" (func $get1))
+ (export "get_cst" (func $get_cst))
+
+ (export "set1" (func $set1))
+ (export "global_imm" (global $glob_imm))
+ )`, {
+ globals: {
+ a: coercion(initialValue)
+ }
+ }).exports;
+
+ assertFunc(module.get0(), coercion(initialValue));
+ assertFunc(module.get1(), coercion(initialValue));
+ assertFunc(Number(module.global_imm), coercion(initialValue));
+
+ assertEq(module.set1(coercion(nextValue)), undefined);
+ assertFunc(module.get1(), coercion(nextValue));
+ assertFunc(module.get0(), coercion(initialValue));
+ assertFunc(Number(module.global_imm), coercion(initialValue));
+
+ assertFunc(module.get_cst(), coercion(initialValue));
+}
+
+testInitExpr('i32', 13, 37, x => x|0);
+testInitExpr('f32', 13.37, 0.1989, Math.fround);
+testInitExpr('f64', 13.37, 0.1989, x => +x);
+
+// Int64.
+
+// Import and export
+
+// Test inner
+var initialValue = '0x123456789abcdef0';
+var nextValue = '0x531642753864975F';
+wasmAssert(`(module
+ (global (mut i64) (i64.const ${initialValue}))
+ (global i64 (i64.const ${initialValue}))
+ (func $get (result i64) (global.get 0))
+ (func $set (param i64) (global.set 0 (local.get 0)))
+ (func $get_cst (result i64) (global.get 1))
+ (export "get" (func $get))
+ (export "get_cst" (func $get_cst))
+ (export "set" (func $set))
+)`, [
+ {type: 'i64', func: '$get', expected: initialValue},
+ {type: 'i64', func: '$set', args: [`i64.const ${nextValue}`]},
+ {type: 'i64', func: '$get', expected: nextValue},
+ {type: 'i64', func: '$get_cst', expected: initialValue},
+]);
+
+// Custom NaN.
+{
+ let dv = new DataView(new ArrayBuffer(8));
+ module = wasmEvalText(`(module
+ (global $g f64 (f64.const -nan:0xe7ffff1591120))
+ (global $h f32 (f32.const -nan:0x651234))
+ (export "nan64" (global $g))(export "nan32" (global $h))
+ )`, {}).exports;
+
+ dv.setFloat64(0, module.nan64, true);
+ assertEq(dv.getUint32(4, true), 0x7ff80000);
+ assertEq(dv.getUint32(0, true), 0x00000000);
+
+ dv.setFloat32(0, module.nan32, true);
+ assertEq(dv.getUint32(0, true), 0x7fc00000);
+}
+
+// WebAssembly.Global
+{
+ const Global = WebAssembly.Global;
+
+ // These types should work:
+ assertEq(new Global({value: "i32"}) instanceof Global, true);
+ assertEq(new Global({value: "f32"}) instanceof Global, true);
+ assertEq(new Global({value: "f64"}) instanceof Global, true);
+ assertEq(new Global({value: "i64"}) instanceof Global, true); // No initial value works
+
+ // Coercion of init value; ".value" accessor
+ assertEq((new Global({value: "i32"}, 3.14)).value, 3);
+ assertEq((new Global({value: "f32"}, { valueOf: () => 33.5 })).value, 33.5);
+ assertEq((new Global({value: "f64"}, "3.25")).value, 3.25);
+
+ // Nothing special about NaN, it coerces just fine
+ assertEq((new Global({value: "i32"}, NaN)).value, 0);
+
+ // The default init value is zero.
+ assertEq((new Global({value: "i32"})).value, 0);
+ assertEq((new Global({value: "f32"})).value, 0);
+ assertEq((new Global({value: "f64"})).value, 0);
+ let mod = wasmEvalText(`(module
+ (import "" "g" (global i64))
+ (func (export "f") (result i32)
+ (i64.eqz (global.get 0))))`,
+ {"":{g: new Global({value: "i64"})}});
+ assertEq(mod.exports.f(), 1);
+
+ {
+ // "value" is enumerable
+ let x = new Global({value: "i32"});
+ let s = "";
+ for ( let i in x )
+ s = s + i + ",";
+ if (getBuildConfiguration().release_or_beta) {
+ assertEq(s, "valueOf,value,");
+ } else {
+ assertEq(s, "type,valueOf,value,");
+ }
+ }
+
+ // "value" is defined on the prototype, not on the object
+ assertEq("value" in Global.prototype, true);
+
+ // Can't set the value of an immutable global
+ assertErrorMessage(() => (new Global({value: "i32"})).value = 10,
+ TypeError,
+ /can't set value of immutable global/);
+
+ {
+ // Can set the value of a mutable global
+ let g = new Global({value: "i32", mutable: true}, 37);
+ g.value = 10;
+ assertEq(g.value, 10);
+ }
+
+ {
+ // Misc internal conversions
+ let g = new Global({value: "i32"}, 42);
+
+ // valueOf
+ assertEq(g - 5, 37);
+
+ // @@toStringTag
+ assertEq(g.toString(), "[object WebAssembly.Global]");
+ }
+
+ {
+ // An exported global should appear as a Global instance:
+ let i = wasmEvalText(`(module (global (export "g") i32 (i32.const 42)))`);
+
+ assertEq(typeof i.exports.g, "object");
+ assertEq(i.exports.g instanceof Global, true);
+
+ // An exported global can be imported into another instance even if
+ // it is an object:
+ let j = wasmEvalText(`(module
+ (global (import "" "g") i32)
+ (func (export "f") (result i32)
+ (global.get 0)))`,
+ { "": { "g": i.exports.g }});
+
+ // And when it is then accessed it has the right value:
+ assertEq(j.exports.f(), 42);
+ }
+
+ // Identity of Global objects (independent of mutablity).
+ {
+ // When a global is exported twice, the two objects are the same.
+ let i = wasmEvalText(`(module
+ (global i32 (i32.const 0))
+ (export "a" (global 0))
+ (export "b" (global 0)))`);
+ assertEq(i.exports.a, i.exports.b);
+
+ // When a global is imported and then exported, the exported object is
+ // the same as the imported object.
+ let j = wasmEvalText(`(module
+ (import "" "a" (global i32))
+ (export "x" (global 0)))`,
+ { "": {a: i.exports.a}});
+
+ assertEq(i.exports.a, j.exports.x);
+
+ // When a global is imported twice (ie aliased) and then exported twice,
+ // the exported objects are the same, and are also the same as the
+ // imported object.
+ let k = wasmEvalText(`(module
+ (import "" "a" (global i32))
+ (import "" "b" (global i32))
+ (export "x" (global 0))
+ (export "y" (global 1)))`,
+ { "": {a: i.exports.a,
+ b: i.exports.a}});
+
+ assertEq(i.exports.a, k.exports.x);
+ assertEq(k.exports.x, k.exports.y);
+ }
+
+ // Mutability
+ {
+ let i = wasmEvalText(`(module
+ (global (export "g") (mut i32) (i32.const 37))
+ (func (export "getter") (result i32)
+ (global.get 0))
+ (func (export "setter") (param i32)
+ (global.set 0 (local.get 0))))`);
+
+ let j = wasmEvalText(`(module
+ (import "" "g" (global (mut i32)))
+ (func (export "getter") (result i32)
+ (global.get 0))
+ (func (export "setter") (param i32)
+ (global.set 0 (local.get 0))))`,
+ {"": {g: i.exports.g}});
+
+ // Initial values
+ assertEq(i.exports.g.value, 37);
+ assertEq(i.exports.getter(), 37);
+ assertEq(j.exports.getter(), 37);
+
+ // Set in i, observe everywhere
+ i.exports.setter(42);
+
+ assertEq(i.exports.g.value, 42);
+ assertEq(i.exports.getter(), 42);
+ assertEq(j.exports.getter(), 42);
+
+ // Set in j, observe everywhere
+ j.exports.setter(78);
+
+ assertEq(i.exports.g.value, 78);
+ assertEq(i.exports.getter(), 78);
+ assertEq(j.exports.getter(), 78);
+
+ // Set on global object, observe everywhere
+ i.exports.g.value = 197;
+
+ assertEq(i.exports.g.value, 197);
+ assertEq(i.exports.getter(), 197);
+ assertEq(j.exports.getter(), 197);
+ }
+
+ // Mutability of import declaration and imported value have to match
+ {
+ const mutErr = /imported global mutability mismatch/;
+
+ let m1 = new Module(wasmTextToBinary(`(module
+ (import "m" "g" (global i32)))`));
+
+ // Mutable Global matched to immutable import
+ let gm = new Global({value: "i32", mutable: true}, 42);
+ assertErrorMessage(() => new Instance(m1, {m: {g: gm}}),
+ LinkError,
+ mutErr);
+
+ let m2 = new Module(wasmTextToBinary(`(module
+ (import "m" "g" (global (mut i32))))`));
+
+ // Immutable Global matched to mutable import
+ let gi = new Global({value: "i32", mutable: false}, 42);
+ assertErrorMessage(() => new Instance(m2, {m: {g: gi}}),
+ LinkError,
+ mutErr);
+
+ // Constant value is the same as immutable Global
+ assertErrorMessage(() => new Instance(m2, {m: {g: 42}}),
+ LinkError,
+ mutErr);
+ }
+
+ // TEST THIS LAST
+
+ // "value" is deletable
+ assertEq(delete Global.prototype.value, true);
+ assertEq("value" in Global.prototype, false);
+
+ // ADD NO MORE TESTS HERE!
+}
+
+// Standard wat syntax: the parens around the initializer expression are
+// optional.
+{
+ let i1 = wasmEvalText(
+ `(module
+ (global $g i32 i32.const 37)
+ (func (export "f") (result i32) (global.get $g)))`);
+ assertEq(i1.exports.f(), 37);
+
+ let i2 = wasmEvalText(
+ `(module
+ (global $g (mut f64) f64.const 42.0)
+ (func (export "f") (result f64) (global.get $g)))`);
+ assertEq(i2.exports.f(), 42);
+
+ let i3 = wasmEvalText(
+ `(module
+ (global $x (import "m" "x") i32)
+ (global $g i32 global.get $x)
+ (func (export "f") (result i32) (global.get $g)))`,
+ {m:{x:86}});
+ assertEq(i3.exports.f(), 86);
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-16 03:28:10 +0000