mirror of
https://github.com/roytam1/palemoon27.git
synced 2026-05-26 14:30:27 +00:00
roytam1
cc81aca6b2
- Bug 1236321 - Annotate intentional switch fallthroughs to suppress -Wimplicit-fallthrough warnings in js/. r=luke (32d46328ef) - Bug 1236552 - Odin: handle unfinished AsmJSModuleObject in addSizeOfMisc (r=bbouvier) (dafbd77b10) - Bug 1229399: Make writing the IR fallible, provide a fallible readingAPI; r=luke (cbc536c3fa) - Bug 1237272 - Only for Coverity - check arg1, arg2 and arg3 for validity. r=luke (1456e58951) - Bug 1229399: Split FuncIR into Bytecode/Encoder/Decoder/FuncBytecode; r=luke (9f438b4d5f) - Bug 1237508 - Odin: make AsmJSModule derive wasm::Module (r=bbouvier) (0186bf908b) - Bug 1238195 - Switch over some AutoVectorRooters to Rooted<TraceableVector>s and fill in some missing support (r=terrence) (b556fdc27e) - Bug 1234193 - IsRelazifiableFunction: Return false when we report an error. r=jandem (bd3c33e1e6) - Bug 1221361: Mark SetARMHwCapFlags as unsafe for fuzzing; r=jolesen (3134febc32) - Bug 1236564 - Fix various minor issues with getting/setting GC parameters r=terrence (45e251eba7) - Bug 1235237 - Annotate intentional switch fallthrough to suppress -Wimplicit-fallthrough warning in storage/. r=mak (f81714fdab) - Bug 1235236 - Annotate intentional switch fallthrough to suppress -Wimplicit-fallthrough warning in modules/libjar/. r=aklotz (f3a210802b) - Bug 1236324 - Annotate intentional switch fallthroughs to suppress -Wimplicit-fallthrough warnings in toolkit/components/places/. r=mak (f2d09b5041) - Bug 1238711 - Rename TraceableVector to GCVector; r=sfink Bug 1237153 - Fix gcparam() parameter verification to not allow negative numbers r=terrence (deccfd7f01) - Bug 1235092 - Part 1: Optimize spread call with rest parameter. r=efaust (e6cc1294d1) - Bug 1235092 - Part 2: Support allowContentSpread in the optimization for spread call with rest parameter. r=efaust (31c881893d) - Bug 1235092 - Part 3: Root function in BytecodeEmitter::isRestParameter. r=bustage (ede37f48b6) - Bug 1233152 - Use PersistentRooted for ParseTask script and sourceObject. r=terrence (d99d9b81fb) - Bug 1236476: Report out of memory in ExpandErrorArgumentsVA; r=jandem (6a2327222c) - Bug 1239601 - improve the UniquePtr situation (r=jorendorff) (640322c8c1) - Bug 1239724: Introduce RegExp registers to non-ion builds; r=arai (f2d837e65b) - Bug 1137624 - Remove ArrayJoin code duplication, and use a correct alias set. r=jandem (ab8a98a5e3) - Bug 1237284: Make SIMD names more consistent in MCallOptimize; r=jolesen (d50f74a31e) - Bug 1238582 - Fix spurious assertion failure in array sort due to over-eager OOM simulation r=jandem (587f4976e5) - Bug 1235874 - handle null filename in DescribeScriptedCaller (r=sunfish) (b347469108) - Bug 1239601 - improve the UniquePtr situation (r=jandem) (a8b9f15dcb)
168 lines
11 KiB
JavaScript
168 lines
11 KiB
JavaScript
// |jit-test| test-also-noasmjs
|
|
load(libdir + "asm.js");
|
|
load(libdir + "asserts.js");
|
|
|
|
assertAsmTypeFail(USE_ASM);
|
|
assertAsmTypeFail(USE_ASM + 'return');
|
|
assertAsmTypeFail(USE_ASM + 'function f() 0');
|
|
assertAsmTypeFail(USE_ASM + 'function f(){}');
|
|
assertAsmTypeFail(USE_ASM + 'function f(){} return 0');
|
|
assertAsmTypeFail(USE_ASM + 'function f() 0; return 0');
|
|
assertAsmTypeFail(USE_ASM + 'function f(){} return g');
|
|
assertAsmTypeFail(USE_ASM + 'function f(){} function f(){} return f');
|
|
assertAsmTypeFail(USE_ASM + 'function f(){}; function g(){}; return {f, g}');
|
|
assertAsmTypeFail(USE_ASM + 'var f = f;');
|
|
assertAsmTypeFail(USE_ASM + 'var f=0; function f(){} return f');
|
|
assertAsmTypeFail(USE_ASM + 'var f=glob.Math.imul; return {}');
|
|
assertAsmTypeFail('glob', USE_ASM + 'var f=glob.Math.imul; function f(){} return f');
|
|
assertAsmTypeFail('glob','foreign', USE_ASM + 'var f=foreign.foo; function f(){} return f');
|
|
assertAsmTypeFail(USE_ASM + 'function f(){} var f=[f,f]; return f');
|
|
assertAsmTypeFail(USE_ASM + 'function f() 0; return f');
|
|
assertAsmTypeFail('"use strict";' + USE_ASM + 'function f() {} return f');
|
|
assertAsmTypeFail(USE_ASM + '"use strict"; function f() {} return f');
|
|
assertAsmTypeFail(USE_ASM + '"use foopy" + 1; function f() {} return f');
|
|
assertAsmTypeFail(USE_ASM + 'function f() { "use strict"; } return f');
|
|
assertEq(asmLink(asmCompile(USE_ASM + '"use asm"; function f() {} return f'))(), undefined);
|
|
assertEq(asmLink(asmCompile(USE_ASM + '"use foopy"; function f() {} return f'))(), undefined);
|
|
assertEq(asmLink(asmCompile(USE_ASM + '"use foopy"; "use blarg"; function f() {} return f'))(), undefined);
|
|
assertEq(asmLink(asmCompile(USE_ASM + 'function f() { "use asm"; } return f'))(), undefined);
|
|
assertEq(asmLink(asmCompile(USE_ASM + 'function f() { "use foopy"; } return f'))(), undefined);
|
|
assertEq(asmLink(asmCompile(USE_ASM + 'function f() { "use foopy"; "use blarg"; } return f'))(), undefined);
|
|
assertEq(asmLink(asmCompile(USE_ASM + 'function f(i) { "use foopy"; i=i|0; } return f'))(), undefined);
|
|
assertEq(asmLink(asmCompile(USE_ASM + 'function f(i) { "use foopy"; "use asm"; i=i|0; } return f'))(), undefined);
|
|
assertEq(asmLink(asmCompile(USE_ASM + '"use warm"; function f(i) { "use cold"; i=i|0 } function g() { "use hot"; return 0 } return f'))(), undefined);
|
|
assertEq(asmLink(asmCompile(USE_ASM + '"use warm"; function f(i) { "use cold"; i=i|0 } function g() { "use asm"; return 0 } return f'))(), undefined);
|
|
assertEq(asmLink(asmCompile(USE_ASM + 'function f(){} return f'))(), undefined);
|
|
assertEq(asmLink(asmCompile(USE_ASM + 'function f(){;} return f'))(), undefined);
|
|
assertAsmTypeFail(USE_ASM + 'function f(i,j){;} return f');
|
|
assertEq(asmLink(asmCompile('"use asm";; function f(){};;; return f;;'))(), undefined);
|
|
assertAsmTypeFail(USE_ASM + 'function f(x){} return f');
|
|
assertAsmTypeFail(USE_ASM + 'function f(){if (0) return; return 1} return f');
|
|
assertEq(asmLink(asmCompile(USE_ASM + 'function f(x){x=x|0} return f'))(42), undefined);
|
|
assertEq(asmLink(asmCompile(USE_ASM + 'function f(x){x=x|0; return x|0} return f'))(42), 42);
|
|
assertEq(asmLink(asmCompile(USE_ASM + 'function f(x){x=x|0; return x|0;;;} return f'))(42), 42);
|
|
assertEq(asmLink(asmCompile(USE_ASM + 'function f(x,y){x=x|0;y=y|0; return (x+y)|0} return f'))(44, -2), 42);
|
|
assertAsmTypeFail('a', USE_ASM + 'function a(){} return a');
|
|
assertAsmTypeFail('a','b','c', USE_ASM + 'var c');
|
|
assertAsmTypeFail('a','b','c', USE_ASM + 'var c=0');
|
|
assertAsmTypeFail(USE_ASM + 'c=0;return {}');
|
|
assertAsmTypeFail('x','x', USE_ASM + 'function a(){} return a');
|
|
assertAsmTypeFail('x','y','x', USE_ASM + 'function a(){} return a');
|
|
assertEq(asmLink(asmCompile('x', USE_ASM + 'function a(){} return a'))(), undefined);
|
|
assertEq(asmLink(asmCompile('x','y', USE_ASM + 'function a(){} return a'))(), undefined);
|
|
assertEq(asmLink(asmCompile('x','y','z', USE_ASM + 'function a(){} return a'))(), undefined);
|
|
assertAsmTypeFail('x','y', USE_ASM + 'function y(){} return f');
|
|
assertEq(asmLink(asmCompile('x', USE_ASM + 'function f(){} return f'), 1, 2, 3)(), undefined);
|
|
assertEq(asmLink(asmCompile('x', USE_ASM + 'function f(){} return f'), 1)(), undefined);
|
|
assertEq(asmLink(asmCompile('x','y', USE_ASM + 'function f(){} return f'), 1, 2)(), undefined);
|
|
|
|
assertEq(asmLink(asmCompile(USE_ASM + 'function f(i) {i=i|0} return f'))(42), undefined);
|
|
assertEq(asmLink(asmCompile(USE_ASM + 'function f() {var i=0;; var j=1;} return f'))(), undefined); // bug 877965 second part
|
|
assertAsmTypeFail(USE_ASM + 'function f(i) {i=i|0;var i} return f');
|
|
assertAsmTypeFail(USE_ASM + 'function f(i) {i=i|0;var i=0} return f');
|
|
|
|
assertAsmTypeFail('glob', USE_ASM + 'var im=glob.imul; function f() {} return f');
|
|
assertAsmLinkAlwaysFail(asmCompile('glob', USE_ASM + 'var im=glob.Math.imul; function f(i,j) {i=i|0;j=j|0; return im(i,j)|0} return f'), null);
|
|
assertAsmLinkAlwaysFail(asmCompile('glob', USE_ASM + 'var im=glob.Math.imul; function f(i,j) {i=i|0;j=j|0; return im(i,j)|0} return f'), {});
|
|
assertAsmLinkAlwaysFail(asmCompile('glob', USE_ASM + 'var im=glob.Math.imul; function f(i,j) {i=i|0;j=j|0; return im(i,j)|0} return f'), {imul:Math.imul});
|
|
assertEq(asmLink(asmCompile('glob', USE_ASM + 'var im=glob.Math.imul; function f(i,j) {i=i|0;j=j|0; return im(i,j)|0} return f'), {Math:{imul:Math.imul}})(2,3), 6);
|
|
assertEq(asmLink(asmCompile('glob', USE_ASM + 'var im=glob.Math.imul; function f(i,j) {i=i|0;j=j|0; return im(i,j)|0} return f'), this)(8,4), 32);
|
|
|
|
var module = asmCompile('glob','i','b', USE_ASM + 'var i32=new glob.Int32Array(b); function f(){} return f');
|
|
assertAsmLinkAlwaysFail(module, null, null);
|
|
assertAsmLinkAlwaysFail(module, this, null, null);
|
|
assertAsmLinkAlwaysFail(module, this, null, null);
|
|
assertAsmLinkAlwaysFail(module, this, null, new ArrayBuffer(1));
|
|
assertAsmLinkFail(module, this, null, new ArrayBuffer(4));
|
|
assertAsmLinkFail(module, this, null, new ArrayBuffer(100));
|
|
assertAsmLinkFail(module, this, null, new ArrayBuffer(4092));
|
|
assertAsmLinkFail(module, this, null, new ArrayBuffer(64000));
|
|
assertAsmLinkFail(module, this, null, new ArrayBuffer(BUF_MIN+4));
|
|
assertAsmLinkDeprecated(module, this, null, new ArrayBuffer(4096));
|
|
assertAsmLinkDeprecated(module, this, null, new ArrayBuffer(2*4096));
|
|
assertAsmLinkDeprecated(module, this, null, new ArrayBuffer(4*4096));
|
|
assertAsmLinkDeprecated(module, this, null, new ArrayBuffer(32*1024));
|
|
assertEq(asmLink(module, this, null, new ArrayBuffer(BUF_MIN))(), undefined);
|
|
|
|
assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + HEAP_IMPORTS + 'function f(i) {i=i|0; i = i32[i]|0; return i|0}; return f');
|
|
assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + HEAP_IMPORTS + 'function f(i) {i=i|0; i = i32[i>>1]|0; return i|0}; return f');
|
|
assertAsmTypeFail('glob', 'imp', 'b', USE_ASM + HEAP_IMPORTS + 'function f(i) {i=i|0; i = i32[i>>1]|0; return i|0}; return f');
|
|
assertAsmLinkAlwaysFail(asmCompile('glob', 'imp', 'b', USE_ASM + HEAP_IMPORTS + 'function f(i) {i=i|0; i = i32[i>>2]|0; return i|0}; return f'), this, null, new ArrayBuffer(BUF_MIN-1));
|
|
assertEq(asmCompile('glob', 'imp', 'b', USE_ASM + HEAP_IMPORTS + 'function f(i) {i=i|0; i = i32[i>>2]|0; return i|0}; return f')(this, null, new ArrayBuffer(BUF_MIN))(), 0);
|
|
|
|
var exp = asmLink(asmCompile(USE_ASM + "return {}"));
|
|
assertEq(Object.keys(exp).length, 0);
|
|
|
|
var exp = asmLink(asmCompile(USE_ASM + "function f() { return 3 } return {f:f,f:f}"));
|
|
assertEq(exp.f(), 3);
|
|
assertEq(Object.keys(exp).join(), 'f');
|
|
|
|
var exp = asmLink(asmCompile(USE_ASM + "function f() { return 4 } return {f1:f,f2:f}"));
|
|
assertEq(exp.f1(), 4);
|
|
assertEq(exp.f2(), 4);
|
|
assertEq(Object.keys(exp).sort().join(), 'f1,f2');
|
|
assertEq(exp.f1, exp.f2);
|
|
|
|
assertAsmTypeFail(USE_ASM + "function f() { return 3 } return {1:f}");
|
|
assertAsmTypeFail(USE_ASM + "function f() { return 3 } return {__proto__:f}");
|
|
assertAsmTypeFail(USE_ASM + "function f() { return 3 } return {get x() {} }");
|
|
|
|
var exp = asmLink(asmCompile(USE_ASM + 'function internal() { return ((g()|0)+2)|0 } function f() { return 1 } function g() { return 2 } function h() { return internal()|0 } return {f:f,g1:g,h1:h}'));
|
|
assertEq(exp.f(), 1);
|
|
assertEq(exp.g1(), 2);
|
|
assertEq(exp.h1(), 4);
|
|
assertEq(Object.keys(exp).join(), 'f,g1,h1');
|
|
|
|
// can't test destructuring args with Function constructor
|
|
function assertTypeFailInEval(str)
|
|
{
|
|
if (!isAsmJSCompilationAvailable())
|
|
return;
|
|
|
|
var caught = false;
|
|
var oldOpts = options("werror");
|
|
assertEq(oldOpts.indexOf("werror"), -1);
|
|
try {
|
|
eval(str);
|
|
} catch (e) {
|
|
assertEq((''+e).indexOf(ASM_TYPE_FAIL_STRING) == -1, false);
|
|
caught = true;
|
|
}
|
|
assertEq(caught, true);
|
|
options("werror");
|
|
}
|
|
assertTypeFailInEval('function f({}) { "use asm"; function g() {} return g }');
|
|
assertTypeFailInEval('function f({global}) { "use asm"; function g() {} return g }');
|
|
assertTypeFailInEval('function f(global, {imports}) { "use asm"; function g() {} return g }');
|
|
assertTypeFailInEval('function f(g = 2) { "use asm"; function g() {} return g }');
|
|
assertTypeFailInEval('function *f() { "use asm"; function g() {} return g }');
|
|
assertTypeFailInEval('f => { "use asm"; function g() {} return g }');
|
|
assertTypeFailInEval('class f { constructor() {"use asm"; return {}} }');
|
|
assertTypeFailInEval('var f = { method() {"use asm"; return {}} }');
|
|
assertAsmTypeFail(USE_ASM + 'class c { constructor() {}}; return c;');
|
|
assertAsmTypeFail(USE_ASM + 'return {m() {}};');
|
|
|
|
assertAsmTypeFail(USE_ASM + 'function f(i) {i=i|0; (i for (x in [1,2,3])) } return f');
|
|
assertAsmTypeFail(USE_ASM + 'function f(i) {i=i|0; [i for (x in [1,2,3])] } return f');
|
|
assertAsmTypeFail(USE_ASM + 'function f() { (x for (x in [1,2,3])) } return f');
|
|
assertAsmTypeFail(USE_ASM + 'function f() { [x for (x in [1,2,3])] } return f');
|
|
assertTypeFailInEval('function f() { "use asm"; function g(i) {i=i|0; (i for (x in [1,2,3])) } return g }');
|
|
assertTypeFailInEval('function f() { "use asm"; function g(i) {i=i|0; [i for (x in [1,2,3])] } return g }');
|
|
assertTypeFailInEval('function f() { "use asm"; function g() { (x for (x in [1,2,3])) } return g }');
|
|
assertTypeFailInEval('function f() { "use asm"; function g() { [x for (x in [1,2,3])] } return g }');
|
|
|
|
assertThrowsInstanceOf(function() { new Function(USE_ASM + 'var)') }, SyntaxError);
|
|
assertThrowsInstanceOf(function() { new Function(USE_ASM + 'return)') }, SyntaxError);
|
|
assertThrowsInstanceOf(function() { new Function(USE_ASM + 'var z=-2w') }, SyntaxError);
|
|
assertThrowsInstanceOf(function() { new Function(USE_ASM + 'var z=-2w;') }, SyntaxError);
|
|
assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function') }, SyntaxError);
|
|
assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function f') }, SyntaxError);
|
|
assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function f(') }, SyntaxError);
|
|
assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function f()') }, SyntaxError);
|
|
assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function f() {') }, SyntaxError);
|
|
assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function f() {} var') }, SyntaxError);
|
|
assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function f() {} var TBL=-2w; return f') }, SyntaxError);
|
|
assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function f() {} var TBL=-2w return f') }, SyntaxError);
|
|
assertThrowsInstanceOf(function() { new Function(USE_ASM + 'function () {}') }, SyntaxError);
|
|
assertNoWarning(function() { parse("function f() { 'use asm'; function g() {} return g }") });
|