diff options
Diffstat (limited to 'js/src/jit-test/tests/xdr')
45 files changed, 1464 insertions, 0 deletions
diff --git a/js/src/jit-test/tests/xdr/asm.js b/js/src/jit-test/tests/xdr/asm.js new file mode 100644 index 0000000000..5e28e9da00 --- /dev/null +++ b/js/src/jit-test/tests/xdr/asm.js @@ -0,0 +1,19 @@ +load(libdir + 'bytecode-cache.js'); + +var test = (function () { + function f() { + var x = function inner() { + "use asm"; + function g() {} + return g; + }; + }; + return f.toString(); +})(); + +try { + evalWithCache(test, {}); +} catch (x) { + assertEq(x.message.includes("Asm.js is not supported by XDR") || + x.message.includes("XDR encoding failure"), true); +} diff --git a/js/src/jit-test/tests/xdr/async-lazy.js b/js/src/jit-test/tests/xdr/async-lazy.js new file mode 100644 index 0000000000..8f8c5acccc --- /dev/null +++ b/js/src/jit-test/tests/xdr/async-lazy.js @@ -0,0 +1,24 @@ +async function f1(a, b) { + let x = await 10; + return x; +}; +var toStringResult = f1.toString(); + +async function f2(a, b) { + // arguments.callee gets wrapped function from unwrapped function. + return arguments.callee; +}; + +relazifyFunctions(); + +// toString gets unwrapped function from wrapped function. +assertEq(f1.toString(), toStringResult); + +var ans = 0; +f1().then(x => { ans = x; }); +drainJobQueue(); +assertEq(ans, 10); + +f2().then(x => { ans = x; }); +drainJobQueue(); +assertEq(ans, f2); diff --git a/js/src/jit-test/tests/xdr/async.js b/js/src/jit-test/tests/xdr/async.js new file mode 100644 index 0000000000..2c75c89a98 --- /dev/null +++ b/js/src/jit-test/tests/xdr/async.js @@ -0,0 +1,35 @@ +load(libdir + 'bytecode-cache.js'); + +// Prevent relazification triggered by some zeal modes. +gczeal(0); + +async function f1(a, b) { + let x = await 10; + return x; +}; +var toStringResult = f1.toString(); + +var test = ` +async function f1(a, b) { + let x = await 10; + return x; +}; +// toString gets unwrapped function from wrapped function. +assertEq(f1.toString(), \`${toStringResult}\`); + +var ans = 0; +f1().then(x => { ans = x; }); +drainJobQueue(); +assertEq(ans, 10); + +async function f2(a, b) { + // arguments.callee gets wrapped function from unwrapped function. + return arguments.callee; +}; + +f2().then(x => { ans = x; }); +drainJobQueue(); +assertEq(ans, f2); +`; + +evalWithCache(test, { assertEqBytecode: true, checkFrozen: true}); diff --git a/js/src/jit-test/tests/xdr/bigint.js b/js/src/jit-test/tests/xdr/bigint.js new file mode 100644 index 0000000000..f15d0f317a --- /dev/null +++ b/js/src/jit-test/tests/xdr/bigint.js @@ -0,0 +1,10 @@ +// |jit-test| skip-if: !('BigInt' in this) +load(libdir + 'bytecode-cache.js'); + +let test = ` + assertEq(2n**64n - 1n, BigInt("0xffffFFFFffffFFFF")); +`; +evalWithCache(test, { + assertEqBytecode: true, + assertEqResult : true +}); diff --git a/js/src/jit-test/tests/xdr/bug1186973.js b/js/src/jit-test/tests/xdr/bug1186973.js new file mode 100644 index 0000000000..b6949799c1 --- /dev/null +++ b/js/src/jit-test/tests/xdr/bug1186973.js @@ -0,0 +1,17 @@ +// |jit-test| error: cache does not have the same size; skip-if: isLcovEnabled() + + +load(libdir + 'bytecode-cache.js'); + +var test = (function () { + function f(x) { + function ifTrue() {}; + function ifFalse() {}; + + if (generation % 2 == 0) + return ifTrue(); + return ifFalse(); + } + return f.toString() + "; f()"; +})(); +evalWithCache(test, { assertEqBytecode: true, assertEqResult : true }); diff --git a/js/src/jit-test/tests/xdr/bug1390856.js b/js/src/jit-test/tests/xdr/bug1390856.js new file mode 100644 index 0000000000..1af0bc30dd --- /dev/null +++ b/js/src/jit-test/tests/xdr/bug1390856.js @@ -0,0 +1,26 @@ +// |jit-test| skip-if: !('oomTest' in this) || helperThreadCount() === 0 + +let THREAD_TYPE_PARSE = 4; + +// Test main thread encode/decode OOM +oomTest(function() { + let t = cacheEntry(`function f() { function g() { }; return 3; };`); + + evaluate(t, { sourceIsLazy: true, saveIncrementalBytecode: true }); + evaluate(t, { sourceIsLazy: true, readBytecode: true }); +}); + +// Test helper thread decode OOM +let t = cacheEntry(`function f() { function g() { }; return 3; };`); +evaluate(t, { sourceIsLazy: true, saveIncrementalBytecode: true }); +for (var i = 1; i < 100; ++i) { + try { + oomAtAllocation(i, THREAD_TYPE_PARSE); + offThreadDecodeStencil(t, { sourceIsLazy: true }); + var stencil = finishOffThreadStencil(); + evalStencil(stencil); + } + catch (e) { + assertEq(e, "out of memory"); + } +} diff --git a/js/src/jit-test/tests/xdr/bug1427860.js b/js/src/jit-test/tests/xdr/bug1427860.js new file mode 100644 index 0000000000..fd6d6f0411 --- /dev/null +++ b/js/src/jit-test/tests/xdr/bug1427860.js @@ -0,0 +1,12 @@ +// |jit-test| --code-coverage; skip-if: !('oomAtAllocation' in this) + +let x = cacheEntry("function inner() { return 3; }; inner()"); +evaluate(x, { saveIncrementalBytecode: true }); + +try { + // Fail XDR decode with partial script + oomAtAllocation(20); + evaluate(x, { loadBytecode: true }); +} catch { } + +getLcovInfo(); diff --git a/js/src/jit-test/tests/xdr/bug1503722.js b/js/src/jit-test/tests/xdr/bug1503722.js new file mode 100644 index 0000000000..bf663e183f --- /dev/null +++ b/js/src/jit-test/tests/xdr/bug1503722.js @@ -0,0 +1,10 @@ +// |jit-test| skip-if: !('oomAtAllocation' in this) || helperThreadCount() === 0 + +let THREAD_TYPE_PARSE = 4; +let t = cacheEntry("function f() { function g() { }; return 3; };"); +evaluate(t, { sourceIsLazy: true, saveIncrementalBytecode: true }); +for (var i = 1; i < 20; ++i) { + oomAtAllocation(i, THREAD_TYPE_PARSE); + offThreadDecodeStencil(t, { sourceIsLazy: true }); + gc(); +} diff --git a/js/src/jit-test/tests/xdr/bug1585158.js b/js/src/jit-test/tests/xdr/bug1585158.js new file mode 100644 index 0000000000..a64d5cf7aa --- /dev/null +++ b/js/src/jit-test/tests/xdr/bug1585158.js @@ -0,0 +1,12 @@ +gczeal(4); +evalWithCache(` + var obj = { a: 1, b: 2 }; + obj.a++; + assertEq(obj.a, 2); +`); +function evalWithCache(code) { + code = cacheEntry(code); + ctx_save = Object.create({}, { saveIncrementalBytecode: { value: true } }); + var res1 = evaluate(code, ctx_save); + var res2 = evaluate(code, Object.create(ctx_save, {})); +} diff --git a/js/src/jit-test/tests/xdr/bug1607895.js b/js/src/jit-test/tests/xdr/bug1607895.js new file mode 100644 index 0000000000..74050bddbd --- /dev/null +++ b/js/src/jit-test/tests/xdr/bug1607895.js @@ -0,0 +1,7 @@ +code = cacheEntry(` + function f() { + (function () {}) + }; + f() + `); +evaluate(code, { saveIncrementalBytecode: { value: true } }); diff --git a/js/src/jit-test/tests/xdr/bug1790615.js b/js/src/jit-test/tests/xdr/bug1790615.js new file mode 100644 index 0000000000..39a914345a --- /dev/null +++ b/js/src/jit-test/tests/xdr/bug1790615.js @@ -0,0 +1,19 @@ +// |jit-test| --fuzzing-safe; --cpu-count=2; --ion-offthread-compile=off; skip-if: !isAsmJSCompilationAvailable() + +load(libdir + "asserts.js"); + +function asmCompile() { + var f = Function.apply(null, arguments); + return f; +} +var code = asmCompile('glob', 'imp', 'b', ` +"use asm"; +function f(i,j) { + i=i|0; + j=j|0; +} +return f +`); +let g80 = newGlobal({newCompartment: true}); +// Compiling to a Stencil XDR should fail because XDR encoding does not support asm.js +assertThrowsInstanceOf(() => g80.compileToStencilXDR(code, {}), g80.Error);
\ No newline at end of file diff --git a/js/src/jit-test/tests/xdr/class-relazify.js b/js/src/jit-test/tests/xdr/class-relazify.js new file mode 100644 index 0000000000..290202208f --- /dev/null +++ b/js/src/jit-test/tests/xdr/class-relazify.js @@ -0,0 +1,15 @@ +var code = cacheEntry(` +function f() { + class A { + constructor() {} + } + new A(); + relazifyFunctions(); + new A(); + relazifyFunctions(); +} +f(); +`); + +evaluate(code, {saveIncrementalBytecode: { value: true } }); +evaluate(code, {loadBytecode: { value: true } }); diff --git a/js/src/jit-test/tests/xdr/classes.js b/js/src/jit-test/tests/xdr/classes.js new file mode 100644 index 0000000000..3b83e41a48 --- /dev/null +++ b/js/src/jit-test/tests/xdr/classes.js @@ -0,0 +1,36 @@ +load(libdir + 'bytecode-cache.js'); + +// Prevent relazification triggered by some zeal modes. Relazification can cause +// test failures because lazy functions are XDR'd differently. +gczeal(0); + +var test = "new class extends class { } { constructor() { super(); } }()"; +evalWithCache(test, { assertEqBytecode : true }); + +var test = "new class { method() { super.toString(); } }().method()"; +evalWithCache(test, { assertEqBytecode : true }); + +// Test class constructor in lazy function +var test = ` + function f(delazify) { + function inner1() { + class Y { + constructor() {} + } + } + + function inner2() { + class Y { + constructor() {} + field1 = ""; + } + } + + if (delazify) { + inner1(); + inner2(); + } + } + f(generation > 0); +`; +evalWithCache(test, {}); diff --git a/js/src/jit-test/tests/xdr/debug-hook.js b/js/src/jit-test/tests/xdr/debug-hook.js new file mode 100644 index 0000000000..3abb138a80 --- /dev/null +++ b/js/src/jit-test/tests/xdr/debug-hook.js @@ -0,0 +1,20 @@ +var g = newGlobal({ newCompartment: true }); +var dbg = new Debugger(g); +var count = 0; + +dbg.onNewScript = script => { + count++; +}; + +var stencil = g.compileToStencil(`"a"`); +g.evalStencil(stencil); +assertEq(count, 1); + +count = 0; +dbg.onNewScript = script => { + count++; +}; + +var stencilXDR = g.compileToStencilXDR(`"b"`); +g.evalStencilXDR(stencilXDR); +assertEq(count, 1); diff --git a/js/src/jit-test/tests/xdr/debug-lazy.js b/js/src/jit-test/tests/xdr/debug-lazy.js new file mode 100644 index 0000000000..8c0405742d --- /dev/null +++ b/js/src/jit-test/tests/xdr/debug-lazy.js @@ -0,0 +1,19 @@ +load(libdir + 'bytecode-cache.js'); + +// Ensure that if a function is encoded when non-lazy but relazifiable, then +// decoded, the resulting script is marked as being non-lazy so that when the +// debugger tries to delazify things it doesn't get all confused. We just use +// findScripts() to trigger debugger delazification; we don't really care about +// the scripts themselves. +function checkAfter(ctx) { + var dbg = new Debugger(ctx.global); + var allScripts = dbg.findScripts(); + assertEq(allScripts.length == 0, false); +} + +test = ` + function f() { return true; }; + f(); + ` +evalWithCache(test, { assertEqBytecode: true, assertEqResult: true, + checkAfter: checkAfter, newCompartment: true}); diff --git a/js/src/jit-test/tests/xdr/decode-off-thread.js b/js/src/jit-test/tests/xdr/decode-off-thread.js new file mode 100644 index 0000000000..cacef62e46 --- /dev/null +++ b/js/src/jit-test/tests/xdr/decode-off-thread.js @@ -0,0 +1,54 @@ +// |jit-test| skip-if: helperThreadCount() === 0 + +function evalWithCacheLoadOffThread(code, ctx) { + ctx = ctx || {}; + ctx = Object.create(ctx, { + fileName: { value: "evalWithCacheCode.js" }, + lineNumber: { value: 0 } + }); + code = code instanceof Object ? code : cacheEntry(code); + + // We create a new global ... + if (!("global" in ctx)) + ctx.global = newGlobal(); + + var ctx_save = Object.create(ctx, { + saveIncrementalBytecode: { value: true } + }); + + ctx.global.generation = 0; + evaluate(code, ctx_save); + + offThreadDecodeStencil(code, ctx); + ctx.global.eval(` +stencil = finishOffThreadStencil(); +evalStencil(stencil); +`); +} + +var test; + +// Decode a constant. +test = ` + 1; +`; +evalWithCacheLoadOffThread(test, {}); + +// Decode object literals. +test = ` + var obj = { a: 1, b: 2 }; + obj.a++; + assertEq(obj.a, 2); +`; +evalWithCacheLoadOffThread(test, {}); + +// Decode functions. +test = ` + function g() { + return function f() { return 1; }; + }; + assertEq(g()(), 1); +`; +evalWithCacheLoadOffThread(test, {}); + + diff --git a/js/src/jit-test/tests/xdr/delazifications-atoms.js b/js/src/jit-test/tests/xdr/delazifications-atoms.js new file mode 100644 index 0000000000..91b9603a5b --- /dev/null +++ b/js/src/jit-test/tests/xdr/delazifications-atoms.js @@ -0,0 +1,14 @@ +let s = ` +function f1() { return "Atom_f1"; } +function f2() { return "Atom_f2"; } +function f3() { return "Atom_f3"; } + +assertEq(f1(), "Atom_f1"); +assertEq(f2(), "Atom_f2"); +assertEq(f3(), "Atom_f3"); +`; + +let c = cacheEntry(s); +let g = newGlobal(); +evaluate(c, {saveIncrementalBytecode:true}); +evaluate(c, {global:g, loadBytecode:true}); diff --git a/js/src/jit-test/tests/xdr/delazifications-nest.js b/js/src/jit-test/tests/xdr/delazifications-nest.js new file mode 100644 index 0000000000..0a8fc23a58 --- /dev/null +++ b/js/src/jit-test/tests/xdr/delazifications-nest.js @@ -0,0 +1,70 @@ +load(libdir + 'bytecode-cache.js'); + +let test = ` +// Put some unused atoms in the initial stencil, to verify that atoms are +// correctly mapped while merging stencils. +if (false) { + "unused text1"; + "unused text2"; + "unused text3"; + "unused text4"; + "unused text5"; +} + +var result = 0; + +function func() { + var anonFunc = function() { + // Method/accessor as inner-inner function. + var obj = { + method(name) { + // Test object literal. + var object = { + propA: 9, + propB: 10, + propC: 11, + }; + + // Test object property access. + return object["prop" + name]; + }, + get prop1() { + return 200; + }, + set prop2(value) { + result += value; + } + }; + result += obj.prop1; + obj.prop2 = 3000; + result += obj.method("B"); + }; + + function anotherFunc() { + return 40000; + } + + function unused() { + } + + class MyClass { + constructor() { + result += 500000; + } + } + + // Functions inside arrow parameters, that are parsed multiple times. + const arrow = (a = (b = c => { result += 6000000 }) => b) => a()(); + + // Delazify in the different order as definition. + new MyClass(); + anonFunc(); + result += anotherFunc(); + arrow(); +} +func(); + +result; +`; + +evalWithCache(test, { incremental: true, oassertEqResult : true }); diff --git a/js/src/jit-test/tests/xdr/delazify-findScript-lineCount.js b/js/src/jit-test/tests/xdr/delazify-findScript-lineCount.js new file mode 100644 index 0000000000..7846f1128b --- /dev/null +++ b/js/src/jit-test/tests/xdr/delazify-findScript-lineCount.js @@ -0,0 +1,54 @@ +function testDelazify(i) { + var g = newGlobal({ newCompartment: true }); + var dbg = new Debugger(g); + + dbg.onDebuggerStatement = (frame) => { + var allScripts = dbg.findScripts(); + var j = 0; + for (let script of allScripts) { + if (i == -1 || i == j) { + // Delazify. + try { + script.lineCount; + } catch (e) { + } + } + j++; + } + }; + + var cache = cacheEntry(` +function f( + a = ( + b = ( + c = function g() { + }, + ) => { + }, + d = ( + e = ( + f = ( + ) => { + }, + ) => { + }, + ) => { + }, + ) => { + }, +) { +} +debugger; +`); + + evaluate(cache, { global: g, saveIncrementalBytecode: true }); + evaluate(cache, { global: g, loadBytecode: true }); +} + +// Delazify all. +testDelazify(-1); + +// Delazify specific function and its ancestor. +for (var i = 0; i < 30; i++) { + testDelazify(i); +} diff --git a/js/src/jit-test/tests/xdr/delazify-findScript-parameterNames.js b/js/src/jit-test/tests/xdr/delazify-findScript-parameterNames.js new file mode 100644 index 0000000000..5ee955a40b --- /dev/null +++ b/js/src/jit-test/tests/xdr/delazify-findScript-parameterNames.js @@ -0,0 +1,54 @@ +function testDelazify(i) { + var g = newGlobal({ newCompartment: true }); + var dbg = new Debugger(g); + + dbg.onDebuggerStatement = (frame) => { + var allScripts = dbg.findScripts(); + var j = 0; + for (let script of allScripts) { + if (i == -1 || i == j) { + // Delazify. + try { + script.parameterNames; + } catch (e) { + } + } + j++; + } + }; + + var cache = cacheEntry(` +function f( + a = ( + b = ( + c = function g() { + }, + ) => { + }, + d = ( + e = ( + f = ( + ) => { + }, + ) => { + }, + ) => { + }, + ) => { + }, +) { +} +debugger; +`); + + evaluate(cache, { global: g, saveIncrementalBytecode: true }); + evaluate(cache, { global: g, loadBytecode: true }); +} + +// Delazify all. +testDelazify(-1); + +// Delazify specific function and its ancestor. +for (var i = 0; i < 30; i++) { + testDelazify(i); +} diff --git a/js/src/jit-test/tests/xdr/force-full-parse.js b/js/src/jit-test/tests/xdr/force-full-parse.js new file mode 100644 index 0000000000..4012677055 --- /dev/null +++ b/js/src/jit-test/tests/xdr/force-full-parse.js @@ -0,0 +1,19 @@ +load(libdir + 'bytecode-cache.js'); + +var test = ` +function f() { + function f1() { + return 1; + } + function f2() { + return 20; + } + return f1() + f2(); +} +function g() { + return 300; +} +f() + g(); +`; +evalWithCache(test, { assertEqBytecode: true, assertEqResult : true, + forceFullParse: true, }); diff --git a/js/src/jit-test/tests/xdr/function-flags.js b/js/src/jit-test/tests/xdr/function-flags.js new file mode 100644 index 0000000000..62c69752b7 --- /dev/null +++ b/js/src/jit-test/tests/xdr/function-flags.js @@ -0,0 +1,40 @@ +load(libdir + 'bytecode-cache.js'); + +var test; + +// Ensure that if a function is encoded we don't encode its "name +// resolved" flag. +test = ` + function f() { delete f.name; return f.hasOwnProperty('name'); } + f(); + ` +evalWithCache(test, { assertEqBytecode: true, assertEqResult: true }); + +test = ` + function f() { return f.hasOwnProperty('name'); } + f(); + ` +evalWithCache(test, { assertEqBytecode: true, assertEqResult: true }); + +// Ensure that if a function is encoded we don't encode its "length +// resolved" flag. +test = ` + function f() { delete f.length; return f.hasOwnProperty('length'); } + f(); + ` +evalWithCache(test, { assertEqBytecode: true, assertEqResult: true }); + +test = ` + function f() { return f.hasOwnProperty('length'); } + f(); + ` +evalWithCache(test, { assertEqBytecode: true, assertEqResult: true }); + +// And make sure our bytecode is actually not reflecting the flags, +// not that we ignore them on decode. +test = ` + function f() { return f.hasOwnProperty('length') || f.hasOwnProperty('name'); } + f(); + ` +evalWithCache(test, { assertEqBytecode: true, assertEqResult: true }); + diff --git a/js/src/jit-test/tests/xdr/incremental-encoder.js b/js/src/jit-test/tests/xdr/incremental-encoder.js new file mode 100644 index 0000000000..d8a97f6327 --- /dev/null +++ b/js/src/jit-test/tests/xdr/incremental-encoder.js @@ -0,0 +1,66 @@ +// |jit-test| skip-if: isLcovEnabled() + +load(libdir + 'bytecode-cache.js'); +var test = ""; + +// Check that without cloneSingleton, we can safely encode object literal which +// have mutations. +test = ` + var obj = { a: 1, b: 2 }; + obj.a++; + assertEq(obj.a, 2); +`; +evalWithCache(test, { + incremental: true, + assertEqResult : true +}); + + +// Encode lazy functions. +test = ` + function f() { return 1; }; + 1; +`; +evalWithCache(test, { + incremental: true, + assertEqResult : true +}); + + +// Encode delazified functions. +test = ` + function f() { return 1; }; + f(); +`; +evalWithCache(test, { + incremental: true, + assertEqResult : true +}); + +// Encode inner functions. +test = ` + function g() { + return function f() { return 1; }; + }; + g()(); +`; +evalWithCache(test, { + incremental: true, + assertEqResult : true +}); + +// Extra zeal GCs can cause isRelazifiableFunction() to become true after we +// record its value by throwing away JIT code for the function. +gczeal(0); + +// Relazified functions are encoded as non-lazy-script, when the encoding is +// incremental. +test = ` + assertEq(isLazyFunction(f), generation == 0 || generation == 3); + function f() { return isRelazifiableFunction(f); }; + expect = f(); + assertEq(isLazyFunction(f), false); + relazifyFunctions(f); + assertEq(isLazyFunction(f), expect); +`; +evalWithCache(test, { incremental: true }); diff --git a/js/src/jit-test/tests/xdr/incremental-oom.js b/js/src/jit-test/tests/xdr/incremental-oom.js new file mode 100644 index 0000000000..ef202d112d --- /dev/null +++ b/js/src/jit-test/tests/xdr/incremental-oom.js @@ -0,0 +1,10 @@ +// |jit-test| skip-if: !('oomTest' in this) + +// Delazify a function while encoding bytecode. +oomTest(() => { + let code = cacheEntry(` + function f() { } + f(); + `); + evaluate(code, { saveIncrementalBytecode: true }); +}); diff --git a/js/src/jit-test/tests/xdr/lazy-class-definition.js b/js/src/jit-test/tests/xdr/lazy-class-definition.js new file mode 100644 index 0000000000..ac29c9acf0 --- /dev/null +++ b/js/src/jit-test/tests/xdr/lazy-class-definition.js @@ -0,0 +1,51 @@ +load(libdir + 'bytecode-cache.js'); + +// Bury the class definition deep in a lazy function to hit edge cases of lazy +// script handling. + +test = ` + function f1() { + function f2() { + function f3() { + class C { + constructor() { + this.x = 42; + } + } + return new C; + } + return f3(); + } + return f2(); + } + if (generation >= 2) { + assertEq(f1().x, 42); + } +`; +evalWithCache(test, {}); + +// NOTE: Fields currently force full parsing, but this test may be more +// interesting in future. +test = ` + function f1() { + function f2() { + function f3() { + class C { + y = 12; + + constructor() { + this.x = 42; + } + } + return new C; + } + return f3(); + } + return f2(); + } + if (generation >= 2) { + assertEq(f1().x, 42); + assertEq(f1().y, 12); + } +`; +evalWithCache(test, {}); diff --git a/js/src/jit-test/tests/xdr/lazy.js b/js/src/jit-test/tests/xdr/lazy.js new file mode 100644 index 0000000000..00bcf1e306 --- /dev/null +++ b/js/src/jit-test/tests/xdr/lazy.js @@ -0,0 +1,164 @@ +load(libdir + 'bytecode-cache.js'); +var test = ""; +var checkAfter; + +// code a function which has both used and unused inner functions. +test = (function () { + function f(x) { + function ifTrue() { + return true; + }; + function ifFalse() { + return false; + }; + + if (x) return ifTrue(); + else return ifFalse(); + } + + return f.toString() + "; f(true)"; +})(); +evalWithCache(test, { assertEqBytecode: true, assertEqResult : true }); + +// code a function which uses different inner functions based on the generation. +test = (function () { + function f(x) { + function ifTrue() { + return true; + }; + function ifFalse() { + return false; + }; + + if (x) return ifTrue(); + else return ifFalse(); + } + + return f.toString() + "; f((generation % 2) == 0)"; +})(); +evalWithCache(test, { }); + +// Code a function which has an enclosing scope. +test = (function () { + function f() { + var upvar = ""; + function g() { upvar += ""; return upvar; } + return g; + } + + return f.toString() + "; f()();"; +})(); +evalWithCache(test, { assertEqBytecode: true, assertEqResult : true }); + +// Code a lazy function which has an enclosing scope. +test = (function () { + function f() { + var upvar = ""; + function g() { upvar += ""; return upvar; } + return g; + } + + return f.toString() + "; f();"; +})(); +evalWithCache(test, { assertEqBytecode: true }); + +// (basic/bug535930) Code an enclosing scope which is a Call object. +test = (function () { + return "(" + (function () { + p = function () { + Set() + }; + var Set = function () {}; + for (var x = 0; x < 5; x++) { + Set = function (z) { + return function () { + [z] + } + } (x) + } + }).toString() + ")()"; +})(); +evalWithCache(test, { assertEqBytecode: true }); + +// Code an arrow function, and execute it. +test = (function () { + function f() { + var g = (a) => a + a; + return g; + } + + return f.toString() + "; f()(1);"; +})(); +evalWithCache(test, { assertEqBytecode: true, assertEqResult : true }); + +// Code an arrow function, and do not execute it. +test = (function () { + function f() { + var g = (a) => a + a; + return g; + } + + return f.toString() + "; f();"; +})(); +evalWithCache(test, { assertEqBytecode: true }); + +// Extra zeal GCs can cause isRelazifiableFunction() to become true after we +// record its value by throwing away JIT code for the function. +gczeal(0); + +// Ensure that decoded functions can be relazified. +test = "function f() { }; f();" + + "assertEq(isLazyFunction(f), false);" + + "var expect = isRelazifiableFunction(f);"; +checkAfter = function (ctx) { + relazifyFunctions(); // relazify f, if possible. + evaluate("assertEq(isLazyFunction(f), expect);", ctx); +}; +evalWithCache(test, { + assertEqBytecode: true, // Check that we re-encode the same thing. + assertEqResult: true, // The function should remain relazifiable, if it was + // during the first run. + checkAfter: checkAfter // Check that relazifying the restored function works + // if the original was relazifiable. +}); + +// Ensure that decoded functions can be relazified, even if they have free +// variables. +test = "function f() { return isRelazifiableFunction(f) }; var expect = f();" + + "assertEq(isLazyFunction(f), false);" + + "expect"; +checkAfter = function (ctx) { + relazifyFunctions(); // relazify f, if possible. + evaluate("assertEq(isLazyFunction(f), expect);", ctx); +}; +evalWithCache(test, { + assertEqBytecode: true, // Check that we re-encode the same thing. + assertEqResult: true, // The function should remain relazifiable, if it was + // during the first run. + checkAfter: checkAfter // Check that relazifying the restored function works + // if the original was relazifiable. +}); + +// Ensure that if a function is encoded when non-lazy but relazifiable, then +// decoded, relazified, and then delazified, the result actually works. +test = ` + function f() { return true; }; + var canBeLazy = isRelazifiableFunction(f) || isLazyFunction(f); + relazifyFunctions(); + assertEq(isLazyFunction(f), canBeLazy); + f()` +evalWithCache(test, { assertEqBytecode: true, assertEqResult: true }); + +// And more of the same, in a slightly different way +var g1 = newGlobal({ cloneSingletons: true }); +var g2 = newGlobal(); +var res = "function f(){}"; +var code = cacheEntry(res + "; f();"); +evaluate(code, {global:g1, saveIncrementalBytecode: {value: true}}); +evaluate(code, {global:g2, loadBytecode: true}); +gc(); +assertEq(g2.f.toString(), res); + +// Another relazification case. +var src = "function f() { return 3; }; f(); relazifyFunctions(); 4"; +evalWithCache(src, {assertEqBytecode: true, assertEqResult: true}); diff --git a/js/src/jit-test/tests/xdr/load-nonsyntactic.js b/js/src/jit-test/tests/xdr/load-nonsyntactic.js new file mode 100644 index 0000000000..a5a2e838ce --- /dev/null +++ b/js/src/jit-test/tests/xdr/load-nonsyntactic.js @@ -0,0 +1,55 @@ +var nonSyntacticEnvironment = { field: 10 }; + +var source = ` +function f() { + function g() { + function h() { + // Load out of non syntactic environment. + return field; + } + return h(); + } + return g(); +} + +f()` + +function check(before, after) { + var code = cacheEntry(source); + var res = evaluate(code, before); + assertEq(res, 10); + res = evaluate(code, after); + assertEq(res, 10); +} + + +check({ envChainObject: nonSyntacticEnvironment, saveIncrementalBytecode: true, }, + { envChainObject: nonSyntacticEnvironment, loadBytecode: true }) + + +try { + var global = newGlobal(); + global.field = 10; + check({ envChainObject: nonSyntacticEnvironment, saveIncrementalBytecode: true, }, + { global: global, loadBytecode: true }) + + // Should have thrown + assertEq(false, true) +} catch (e) { + assertEq(/Incompatible cache contents/.test(e.message), true); +} + +try { + check({ global: global, saveIncrementalBytecode: true }, + { envChainObject: nonSyntacticEnvironment, loadBytecode: true }) + + // Should have thrown + assertEq(false, true) +} catch (e) { + assertEq(/Incompatible cache contents/.test(e.message), true); +} + + +var nonSyntacticEnvironmentTwo = { field: 10 }; +check({ envChainObject: nonSyntacticEnvironment, saveIncrementalBytecode: true, }, + { envChainObject: nonSyntacticEnvironmentTwo, loadBytecode: true }) diff --git a/js/src/jit-test/tests/xdr/module-exports.js b/js/src/jit-test/tests/xdr/module-exports.js new file mode 100644 index 0000000000..2c1bff3172 --- /dev/null +++ b/js/src/jit-test/tests/xdr/module-exports.js @@ -0,0 +1,19 @@ +const count = 10; + +let s = ""; +for (let i = 0; i < count; i++) + s += "export let e" + i + " = " + (i * i) + ";\n"; +let stencil = compileToStencilXDR(s, {module: true}); +let m = instantiateModuleStencilXDR(stencil); +let a = registerModule('a', m); + +stencil = compileToStencilXDR("import * as ns from 'a'", {module: true}); +m = instantiateModuleStencilXDR(stencil); +let b = registerModule('b', m); + +moduleLink(b); +moduleEvaluate(b); + +let ns = a.namespace; +for (let i = 0; i < count; i++) + assertEq(ns["e" + i], i * i); diff --git a/js/src/jit-test/tests/xdr/module-imports.js b/js/src/jit-test/tests/xdr/module-imports.js new file mode 100644 index 0000000000..2e77268917 --- /dev/null +++ b/js/src/jit-test/tests/xdr/module-imports.js @@ -0,0 +1,25 @@ +const count = 10; + +let stencil = compileToStencilXDR("export let a = 1;", {module: true}); +let m = instantiateModuleStencilXDR(stencil); +let a = registerModule('a', m); + +let s = ""; +for (let i = 0; i < count; i++) { + s += "import { a as i" + i + " } from 'a';\n"; + s += "assertEq(i" + i + ", 1);\n"; +} + +stencil = compileToStencilXDR(s, {module: true}); +m = instantiateModuleStencilXDR(stencil); +let b = registerModule('b', m); + +moduleLink(b); +moduleEvaluate(b); + + +stencil = compileToStencilXDR("import * as nsa from 'a'; import * as nsb from 'b';", {module: true}); +m = instantiateModuleStencilXDR(stencil); + +moduleLink(m); +moduleEvaluate(m); diff --git a/js/src/jit-test/tests/xdr/module-oom.js b/js/src/jit-test/tests/xdr/module-oom.js new file mode 100644 index 0000000000..14aef8e0af --- /dev/null +++ b/js/src/jit-test/tests/xdr/module-oom.js @@ -0,0 +1,26 @@ +// |jit-test| skip-if: !('oomTest' in this) + +// OOM tests for xdr module parsing. + +const sa = +`export default 20; + export let a = 22; + export function f(x, y) { return x + y } +`; + +const sb = +`import x from "a"; + import { a as y } from "a"; + import * as ns from "a"; + ns.f(x, y); +`; + +oomTest(() => { + let stencil = compileToStencilXDR(sa, {module: true}); + let m = instantiateModuleStencilXDR(stencil); + let a = registerModule('a', m); + + stencil = compileToStencilXDR(sb, {module: true}); + m = instantiateModuleStencilXDR(stencil); + let b = registerModule('b', m); +}); diff --git a/js/src/jit-test/tests/xdr/module.js b/js/src/jit-test/tests/xdr/module.js new file mode 100644 index 0000000000..ef518bcf85 --- /dev/null +++ b/js/src/jit-test/tests/xdr/module.js @@ -0,0 +1,92 @@ +// |jit-test| + +load(libdir + "asserts.js"); + +async function parseAndEvaluate(source) { + let stencil = compileToStencilXDR(source, {module: true}); + let m = instantiateModuleStencilXDR(stencil); + moduleLink(m); + await moduleEvaluate(m); + return m; +} + +(async () => { + // Check the evaluation of an empty module succeeds. + await parseAndEvaluate(""); +})(); + +(async () => { + // Check that evaluation returns evaluation promise, + // and promise is always the same. + let stencil = compileToStencilXDR("1", {module: true}); + let m = instantiateModuleStencilXDR(stencil); + moduleLink(m); + assertEq(typeof moduleEvaluate(m), "object"); + assertEq(moduleEvaluate(m) instanceof Promise, true); + assertEq(moduleEvaluate(m), moduleEvaluate(m)); +})(); + +(async () => { + // Check top level variables are initialized by evaluation. + let stencil = compileToStencilXDR("export var x = 2 + 2;", {module: true}); + let m = instantiateModuleStencilXDR(stencil); + assertEq(typeof getModuleEnvironmentValue(m, "x"), "undefined"); + moduleLink(m); + await moduleEvaluate(m); + assertEq(getModuleEnvironmentValue(m, "x"), 4); +})(); + +(async () => { + let m = await parseAndEvaluate("export let x = 2 * 3;"); + assertEq(getModuleEnvironmentValue(m, "x"), 6); + + // Set up a module to import from. + let stencil = compileToStencilXDR( + `var x = 1; + export { x }; + export default 2; + export function f(x) { return x + 1; }`, + {module: true}); + let mod = instantiateModuleStencilXDR(stencil); + let a = registerModule('a', mod); + + // Check we can evaluate top level definitions. + await parseAndEvaluate("var foo = 1;"); + await parseAndEvaluate("let foo = 1;"); + await parseAndEvaluate("const foo = 1"); + await parseAndEvaluate("function foo() {}"); + await parseAndEvaluate("class foo { constructor() {} }"); + + // Check we can evaluate all module-related syntax. + await parseAndEvaluate("export var foo = 1;"); + await parseAndEvaluate("export let foo = 1;"); + await parseAndEvaluate("export const foo = 1;"); + await parseAndEvaluate("var x = 1; export { x };"); + await parseAndEvaluate("export default 1"); + await parseAndEvaluate("export default function() {};"); + await parseAndEvaluate("export default function foo() {};"); + await parseAndEvaluate("import a from 'a';"); + await parseAndEvaluate("import { x } from 'a';"); + await parseAndEvaluate("import * as ns from 'a';"); + await parseAndEvaluate("export * from 'a'"); + await parseAndEvaluate("export default class { constructor() {} };"); + await parseAndEvaluate("export default class foo { constructor() {} };"); + + // Test default import + m = await parseAndEvaluate("import a from 'a'; export { a };") + assertEq(getModuleEnvironmentValue(m, "a"), 2); + + // Test named import + m = await parseAndEvaluate("import { x as y } from 'a'; export { y };") + assertEq(getModuleEnvironmentValue(m, "y"), 1); + + // Call exported function + m = await parseAndEvaluate("import { f } from 'a'; export let x = f(3);") + assertEq(getModuleEnvironmentValue(m, "x"), 4); + + // Import access in functions + m = await parseAndEvaluate("import { x } from 'a'; function f() { return x; }") + let f = getModuleEnvironmentValue(m, "f"); + assertEq(f(), 1); +})(); +drainJobQueue(); diff --git a/js/src/jit-test/tests/xdr/off-thread-inner-fcn.js b/js/src/jit-test/tests/xdr/off-thread-inner-fcn.js new file mode 100644 index 0000000000..4112428092 --- /dev/null +++ b/js/src/jit-test/tests/xdr/off-thread-inner-fcn.js @@ -0,0 +1,11 @@ +// |jit-test| skip-if: helperThreadCount() === 0 + +offThreadCompileToStencil(`function outer() { + // enough inner functions to make JS::Vector realloc + let inner1 = () => {}; + let inner2 = () => {}; + let inner3 = () => {}; + let inner4 = () => {}; + let inner5 = () => {}; +} `); +const stencil = finishOffThreadStencil(); diff --git a/js/src/jit-test/tests/xdr/option-mismatch.js b/js/src/jit-test/tests/xdr/option-mismatch.js new file mode 100644 index 0000000000..b6b27fffe5 --- /dev/null +++ b/js/src/jit-test/tests/xdr/option-mismatch.js @@ -0,0 +1,23 @@ +var source = ` +function f() { + function g() { + return 10; + } + return g(); +} + +f()` + +var code = cacheEntry(source); + + +var res = evaluate(code, { saveIncrementalBytecode: true, }) +assertEq(res, 10) + +try { + // We should throw here because we have incompatible options! + res = evaluate(code, { loadBytecode: true, sourceIsLazy: true }) + assertEq(true, false); +} catch (e) { + assertEq(/Incompatible cache contents/.test(e.message), true); +}
\ No newline at end of file diff --git a/js/src/jit-test/tests/xdr/private-fields.js b/js/src/jit-test/tests/xdr/private-fields.js new file mode 100644 index 0000000000..52b7bdd5aa --- /dev/null +++ b/js/src/jit-test/tests/xdr/private-fields.js @@ -0,0 +1,9 @@ +load(libdir + 'bytecode-cache.js'); + +function test() { + class A { + #x; + } +}; + +evalWithCache(test.toString(), { assertEqBytecode: true, assertEqResult: true }); diff --git a/js/src/jit-test/tests/xdr/relazify.js b/js/src/jit-test/tests/xdr/relazify.js new file mode 100644 index 0000000000..f867071d88 --- /dev/null +++ b/js/src/jit-test/tests/xdr/relazify.js @@ -0,0 +1,31 @@ +// |jit-test| skip-if: isLcovEnabled() + +load(libdir + 'bytecode-cache.js'); +var test = ""; +gczeal(0); + +// Check that a GC can relazify decoded functions. +// +// Generations 0 and 3 are executed from the source, thus f is not executed yet. +// Generations 1 and 2 are decoded, thus we recorded the delazified f function. +test = ` + function f() { return 1; }; + assertEq(isLazyFunction(f), generation == 0 || generation == 3); + f(); + expect = isRelazifiableFunction(f); + assertEq(isLazyFunction(f), false); +`; +evalWithCache(test, { + checkAfter: function (ctx) { + relazifyFunctions(); // relazify f, if possible. + evaluate("assertEq(isLazyFunction(f), expect);", ctx); + } +}); + +evalWithCache(test, { + incremental: true, + checkAfter: function (ctx) { + relazifyFunctions(); // relazify f, if possible. + evaluate("assertEq(isLazyFunction(f), expect);", ctx); + } +}); diff --git a/js/src/jit-test/tests/xdr/runonce.js b/js/src/jit-test/tests/xdr/runonce.js new file mode 100644 index 0000000000..b9e154ba0b --- /dev/null +++ b/js/src/jit-test/tests/xdr/runonce.js @@ -0,0 +1,6 @@ +load(libdir + "asserts.js") + +// Incremental XDR doesn't have run-once script restrictions. +evaluate(cacheEntry(""), { saveIncrementalBytecode: true }); +evaluate(cacheEntry(""), { saveIncrementalBytecode: true, isRunOnce: false }); +evaluate(cacheEntry(""), { saveIncrementalBytecode: true, isRunOnce: true }); diff --git a/js/src/jit-test/tests/xdr/scope.js b/js/src/jit-test/tests/xdr/scope.js new file mode 100644 index 0000000000..02a135509a --- /dev/null +++ b/js/src/jit-test/tests/xdr/scope.js @@ -0,0 +1,19 @@ +load(libdir + 'bytecode-cache.js'); +var test = ""; + +// code a function which has both used and unused inner functions. +test = (function () { + function f() { + var x = 3; + (function() { + with(obj) { + (function() { + assertEq(x, 2); + })(); + } + })(); + }; + + return "var obj = { x : 2 };" + f.toString() + "; f()"; +})(); +evalWithCache(test, { assertEqBytecode: true, assertEqResult : true }); diff --git a/js/src/jit-test/tests/xdr/script-source-fields.js b/js/src/jit-test/tests/xdr/script-source-fields.js new file mode 100644 index 0000000000..68d4f3d2a6 --- /dev/null +++ b/js/src/jit-test/tests/xdr/script-source-fields.js @@ -0,0 +1,23 @@ +const code = ` +debugger; +`; +let g = newGlobal({newCompartment: true}); +let dbg = new Debugger(g); +const bytes = g.compileToStencilXDR(code, { + fileName: "test-filename.js", + lineNumber: 12, + forceFullParse: true, + displayURL: "display-url.js", + sourceMapURL: "source-map-url.js", +}); +let hit = false; +dbg.onDebuggerStatement = frame => { + hit = true; + const source = frame.script.source; + assertEq(source.url, "test-filename.js"); + assertEq(source.displayURL, "display-url.js"); + assertEq(source.sourceMapURL, "source-map-url.js"); + assertEq(source.startLine, 12); +}; +g.evalStencilXDR(bytes, {}); +assertEq(hit, true); diff --git a/js/src/jit-test/tests/xdr/share-bytecode.js b/js/src/jit-test/tests/xdr/share-bytecode.js new file mode 100644 index 0000000000..d139c94cfa --- /dev/null +++ b/js/src/jit-test/tests/xdr/share-bytecode.js @@ -0,0 +1,12 @@ + +let entry = cacheEntry(` + function f() { } + f() // Delazify + f // Return function object +`); + +let f1 = evaluate(entry, {saveIncrementalBytecode: true}); +let f2 = evaluate(entry, {loadBytecode: true}); + +// Reading from XDR should still deduplicate to same bytecode +assertEq(hasSameBytecodeData(f1, f2), true) diff --git a/js/src/jit-test/tests/xdr/stencil-can-lazily-parse-mismatch.js b/js/src/jit-test/tests/xdr/stencil-can-lazily-parse-mismatch.js new file mode 100644 index 0000000000..351dbc9648 --- /dev/null +++ b/js/src/jit-test/tests/xdr/stencil-can-lazily-parse-mismatch.js @@ -0,0 +1,71 @@ +// |jit-test| skip-if: isLcovEnabled() +// Code coverage forces full-parse. + +load(libdir + 'asserts.js'); + +const code = `var a = 10;`; + +function testCompile(sourceIsLazy1, sourceIsLazy2, + forceFullParse1, forceFullParse2) { + const stencil = compileToStencil(code, { sourceIsLazy: sourceIsLazy1, + forceFullParse: forceFullParse1 }); + // The laziness options are ignored for instantiation, and no error is thrown. + evalStencil(stencil, { sourceIsLazy: sourceIsLazy2, + forceFullParse: forceFullParse2 }); +} + +function testOffThreadCompile(sourceIsLazy1, sourceIsLazy2, + forceFullParse1, forceFullParse2) { + offThreadCompileToStencil(code, { sourceIsLazy: sourceIsLazy1, + forceFullParse: forceFullParse1 }); + const stencil = finishOffThreadStencil(); + // The laziness options are ignored for instantiation, and no error is thrown. + evalStencil(stencil, { sourceIsLazy: sourceIsLazy2, + forceFullParse: forceFullParse2 }); +} + +function testXDR(sourceIsLazy1, sourceIsLazy2, + forceFullParse1, forceFullParse2) { + const xdr = compileToStencilXDR(code, { sourceIsLazy: sourceIsLazy1, + forceFullParse: forceFullParse1 }); + // The compile options are ignored when decoding, and no error is thrown. + evalStencilXDR(xdr, { sourceIsLazy: sourceIsLazy2, + forceFullParse: forceFullParse2 }); +} + +function testOffThreadXDR(sourceIsLazy1, sourceIsLazy2, + forceFullParse1, forceFullParse2) { + const t = cacheEntry(code); + evaluate(t, { sourceIsLazy: sourceIsLazy1, + forceFullParse: forceFullParse1, + saveIncrementalBytecode: true }); + + // The compile options are ignored when decoding, and no error is thrown. + offThreadDecodeStencil(t, { sourceIsLazy: sourceIsLazy2, + forceFullParse: forceFullParse2 }); + const stencil = finishOffThreadStencil(); + + // The laziness options are ignored for instantiation, and no error is thrown. + evalStencil(stencil, { sourceIsLazy: sourceIsLazy2, + forceFullParse: forceFullParse2 }); +} + +const optionsList = [ + [true, false, false, false], + [false, true, false, false], + [false, false, true, false], + [false, false, false, true], + [true, false, true, false], + [false, true, false, true], +]; + +for (const options of optionsList) { + testCompile(...options); + if (helperThreadCount() > 0) { + testOffThreadCompile(...options); + } + testXDR(...options); + if (helperThreadCount() > 0) { + testOffThreadXDR(...options); + } +} diff --git a/js/src/jit-test/tests/xdr/stencil-oom.js b/js/src/jit-test/tests/xdr/stencil-oom.js new file mode 100644 index 0000000000..f57e8f82f8 --- /dev/null +++ b/js/src/jit-test/tests/xdr/stencil-oom.js @@ -0,0 +1,12 @@ +// |jit-test| skip-if: !('oomTest' in this) + +const sa = ` +function f(x, y) { return x + y } +let a = 10, b = 20; +f(a, b); +`; + +oomTest(() => { + let stencil = compileToStencilXDR(sa); + evalStencilXDR(stencil); +}); diff --git a/js/src/jit-test/tests/xdr/stencil.js b/js/src/jit-test/tests/xdr/stencil.js new file mode 100644 index 0000000000..f7ac1c4012 --- /dev/null +++ b/js/src/jit-test/tests/xdr/stencil.js @@ -0,0 +1,99 @@ + +load(libdir + "asserts.js"); + +/* + * This exercises stencil XDR encoding and decoding using a broad + * smoke testing. + * + * A set of scripts exercising various codepaths are XDR-encoded, + * then decoded, and then executed. Their output is compared to + * the execution of the scripts through a normal path and the + * outputs checked. + */ + +/* + * Exercises global scope access and object literals, as well as some + * simple object destructuring. + */ +const testGlobal0 = 13; +let testGlobal1 = undefined; +var testGlobal2 = undefined; + +const SCRIPT_0 = ` +testGlobal1 = 123456789012345678901234567890n; +testGlobal2 = {'foo':3, 'bar': [1, 2, 3], + '4': 'zing'}; +var testGlobal3 = /NewlyDefinedGlobal/; +function testGlobal4(a, {b}) { + return a + b.foo + b['bar'].reduce((a,b) => (a+b), 0); + + b[4].length + + + testGlobal3.toString().length; +}; +testGlobal4(Number(testGlobal1), {b:testGlobal2}) +`; + +/* + * Exercises function scopes, lexical scopes, var and let + * within them, and some longer identifiers, and array destructuring in + * arguments. Also contains some tiny atoms and globls access. + */ +const SCRIPT_1 = ` +function foo(a, b, c) { + var q = a * (b + c); + let bix = function (d, e) { + let x = a + d; + var y = e * b; + const a0 = q + x + y; + for (let i = 0; i < 3; i++) { + y = a0 + Math.PI + y; + } + return y; + }; + function bang(d, [e, f]) { + let reallyLongIdentifierName = a + d; + var y = e * b; + const z = reallyLongIdentifierName + f; + return z; + } + return bix(1, 2) + bang(3, [4, 5, 6]); +} +foo(1, 2, 3) +`; + +/* + * Exercises eval and with scopes, object destructuring, function rest + * arguments. + */ +const SCRIPT_2 = ` +function foo(with_obj, ...xs) { + const [x0, x1, ...xrest] = xs; + eval('var x2 = x0 + x1'); + var sum = []; + with (with_obj) { + sum.push(x2 + xrest.length); + } + sum.push(x2 + xrest.length); + return sum; +} +foo({x2: 99}, 1, 2, 3, 4, 5, 6) +`; + +function test_script(script_str) { + const eval_f = eval; + const options = { + fileName: "compileToStencilXDR-DATA.js", + lineNumber: 1, + forceFullParse: true, + }; + const bytes = compileToStencilXDR(script_str, options); + const result = evalStencilXDR(bytes, options); + assertDeepEq(result, eval_f(script_str)); +} + +function tests() { + test_script(SCRIPT_0); + test_script(SCRIPT_1); + test_script(SCRIPT_2); +} + +tests() diff --git a/js/src/jit-test/tests/xdr/tagged-template-literals-2.js b/js/src/jit-test/tests/xdr/tagged-template-literals-2.js new file mode 100644 index 0000000000..901d20017c --- /dev/null +++ b/js/src/jit-test/tests/xdr/tagged-template-literals-2.js @@ -0,0 +1,4 @@ +var code = cacheEntry("(x => JSON.stringify(x))`bar`;"); +var g = newGlobal({ cloneSingletons: true }); +assertEq("[\"bar\"]", evaluate(code, { global: g, saveIncrementalBytecode: true })); +assertEq("[\"bar\"]", evaluate(code, { global: g, saveIncrementalBytecode: true })); diff --git a/js/src/jit-test/tests/xdr/tagged-template-literals.js b/js/src/jit-test/tests/xdr/tagged-template-literals.js new file mode 100644 index 0000000000..b37f3bbbf3 --- /dev/null +++ b/js/src/jit-test/tests/xdr/tagged-template-literals.js @@ -0,0 +1,4 @@ +var code = cacheEntry("assertEq('bar', String.raw`bar`);"); +var g = newGlobal({ cloneSingletons: true }); +evaluate(code, { global: g, saveIncrementalBytecode: true }); +evaluate(code, { global: g, loadBytecode: true }) diff --git a/js/src/jit-test/tests/xdr/trivial.js b/js/src/jit-test/tests/xdr/trivial.js new file mode 100644 index 0000000000..52ec42f397 --- /dev/null +++ b/js/src/jit-test/tests/xdr/trivial.js @@ -0,0 +1,46 @@ +load(libdir + 'bytecode-cache.js'); +var test = ""; + +// code a constant. +test = "1;"; +evalWithCache(test, { assertEqBytecode: true, assertEqResult : true }); + +// code a string constant. +test = "'string';"; +evalWithCache(test, { assertEqBytecode: true, assertEqResult : true }); + +// code a global variable access. +test = "generation;"; +evalWithCache(test, { assertEqBytecode: true }); + +// code an object constant. +test = "var obj = { a: 1, b: 2 };"; +evalWithCache(test, { assertEqBytecode: true, assertEqResult : true }); + +// code object literal with mutations. +test = "var obj = { a: 1, b: 2 }; obj.a++; assertEq(obj.a, 2);"; +evalWithCache(test, { assertEqBytecode: true, assertEqResult : true }); + +// code object literals with mutations. +test = "var obj = { a: 1, b: { c: 3, d: 4 } }; obj.b.c++; assertEq(obj.b.c, 4);"; +evalWithCache(test, { assertEqBytecode: true, assertEqResult : true }); + +// code a function which is used. +test = "function f() { return 1; }; f();"; +evalWithCache(test, { assertEqBytecode: true, assertEqResult : true }); + +// code a function which is not used. +test = "function f() { return 1; }; 1;"; +evalWithCache(test, { assertEqBytecode: true, assertEqResult : true }); + +// code a function which has an object literal. +test = "function f() { return { x: 2 }; }; f();"; +evalWithCache(test, { assertEqBytecode: true }); + +// code call site object +test = "function f(a) { return a; }; f`a${4}b`;"; +evalWithCache(test, { assertEqBytecode: true, checkFrozen: true}); + +// code RegExp constants. +test = "'fooooooo'.match(/(f.+)/)[1].replace(/o/g, 'O')"; +evalWithCache(test, { assertEqBytecode: true, assertEqResult : true }); |