AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
d4918463a9
v8/test/mjsunit/regress/regress-618608.js
bradnelson e5f5ac7d2b [wasm] asm.js - Remove Wasm.instantiateModuleFromAsm, use asm.js directly. 
Make use of %IsAsmWasmCode in place of Wasm.instantiateModuleFromAsm,
in order to reduce the surface area of the Wasm object,
and to focus on testing asm.js coming in via the parser.

Ignore extra CONST_LEGACY assignment introduced by the parser
when modules have the form:
(function Foo(a, b, c) {..});
This requires both a validator and AsmWasmBuilder change.

Move stdlib use collection to import time,
to reject modules that import a function, even if not used.

BUG= https://bugs.chromium.org/p/v8/issues/detail?id=4203
LOG=N
R=jpp@chromium.org,titzer@chromium.org

Review-Url: https://codereview.chromium.org/2264913002
Cr-Commit-Position: refs/heads/master@{#38806}
2016-08-23 04:07:23 +00:00

1471 lines
37 KiB
JavaScript
Raw Blame History

// Copyright 2016 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --validate-asm --allow-natives-syntax
// /v8/test/mjsunit/regress/regress-crbug-431602.js
// /v8/test/mjsunit/lazy-load.js
// /v8/test/mjsunit/wasm/asm-wasm.js
// /v8/test/mjsunit/debug-toggle-mirror-cache.js
// /v8/test/mjsunit/debug-stack-check-position.js
// Begin stripped down and modified version of mjsunit.js for easy minimization in CF.
var Wasm = {
instantiateModuleFromAsm: function(text, stdlib, ffi, heap) {
var module_decl = eval('(' + text + ')');
if (%IsNotAsmWasmCode(module_decl)) {
throw "validate failure";
}
var ret = module_decl(stdlib, ffi, heap);
if (%IsNotAsmWasmCode(module_decl)) {
throw "bad module args";
}
return ret;
},
};
function MjsUnitAssertionError(message) {}
MjsUnitAssertionError.prototype.toString = function () { return this.message; };
var assertSame;
var assertEquals;
var assertEqualsDelta;
var assertArrayEquals;
var assertPropertiesEqual;
var assertToStringEquals;
var assertTrue;
var assertFalse;
var triggerAssertFalse;
var assertNull;
var assertNotNull;
var assertThrows;
var assertDoesNotThrow;
var assertInstanceof;
var assertUnreachable;
var assertOptimized;
var assertUnoptimized;
function classOf(object) { var string = Object.prototype.toString.call(object); return string.substring(8, string.length - 1); }
function PrettyPrint(value) { return ""; }
function PrettyPrintArrayElement(value, index, array) { return ""; }
function fail(expectedText, found, name_opt) { }
function deepObjectEquals(a, b) { var aProps = Object.keys(a); aProps.sort(); var bProps = Object.keys(b); bProps.sort(); if (!deepEquals(aProps, bProps)) { return false; } for (var i = 0; i < aProps.length; i++) { if (!deepEquals(a[aProps[i]], b[aProps[i]])) { return false; } } return true; }
function deepEquals(a, b) { if (a === b) { if (a === 0) return (1 / a) === (1 / b); return true; } if (typeof a != typeof b) return false; if (typeof a == "number") return isNaN(a) && isNaN(b); if (typeof a !== "object" && typeof a !== "function") return false; var objectClass = classOf(a); if (objectClass !== classOf(b)) return false; if (objectClass === "RegExp") { return (a.toString() === b.toString()); } if (objectClass === "Function") return false; if (objectClass === "Array") { var elementCount = 0; if (a.length != b.length) { return false; } for (var i = 0; i < a.length; i++) { if (!deepEquals(a[i], b[i])) return false; } return true; } if (objectClass == "String" || objectClass == "Number" || objectClass == "Boolean" || objectClass == "Date") { if (a.valueOf() !== b.valueOf()) return false; } return deepObjectEquals(a, b); }
assertSame = function assertSame(expected, found, name_opt) { if (found === expected) { if (expected !== 0 || (1 / expected) == (1 / found)) return; } else if ((expected !== expected) && (found !== found)) { return; } fail(PrettyPrint(expected), found, name_opt); }; assertEquals = function assertEquals(expected, found, name_opt) { if (!deepEquals(found, expected)) { fail(PrettyPrint(expected), found, name_opt); } };
assertEqualsDelta = function assertEqualsDelta(expected, found, delta, name_opt) { assertTrue(Math.abs(expected - found) <= delta, name_opt); };
assertArrayEquals = function assertArrayEquals(expected, found, name_opt) { var start = ""; if (name_opt) { start = name_opt + " - "; } assertEquals(expected.length, found.length, start + "array length"); if (expected.length == found.length) { for (var i = 0; i < expected.length; ++i) { assertEquals(expected[i], found[i], start + "array element at index " + i); } } };
assertPropertiesEqual = function assertPropertiesEqual(expected, found, name_opt) { if (!deepObjectEquals(expected, found)) { fail(expected, found, name_opt); } };
assertToStringEquals = function assertToStringEquals(expected, found, name_opt) { if (expected != String(found)) { fail(expected, found, name_opt); } };
assertTrue = function assertTrue(value, name_opt) { assertEquals(true, value, name_opt); };
assertFalse = function assertFalse(value, name_opt) { assertEquals(false, value, name_opt); };
assertNull = function assertNull(value, name_opt) { if (value !== null) { fail("null", value, name_opt); } };
assertNotNull = function assertNotNull(value, name_opt) { if (value === null) { fail("not null", value, name_opt); } };
assertThrows = function assertThrows(code, type_opt, cause_opt) { var threwException = true; try { if (typeof code == 'function') { code(); } else { eval(code); } threwException = false; } catch (e) { if (typeof type_opt == 'function') { assertInstanceof(e, type_opt); } if (arguments.length >= 3) { assertEquals(e.type, cause_opt); } return; } };
assertInstanceof = function assertInstanceof(obj, type) { if (!(obj instanceof type)) { var actualTypeName = null; var actualConstructor = Object.getPrototypeOf(obj).constructor; if (typeof actualConstructor == "function") { actualTypeName = actualConstructor.name || String(actualConstructor); } fail("Object <" + PrettyPrint(obj) + "> is not an instance of <" + (type.name || type) + ">" + (actualTypeName ? " but of < " + actualTypeName + ">" : "")); } };
assertDoesNotThrow = function assertDoesNotThrow(code, name_opt) { try { if (typeof code == 'function') { code(); } else { eval(code); } } catch (e) { fail("threw an exception: ", e.message || e, name_opt); } };
assertUnreachable = function assertUnreachable(name_opt) { var message = "Fail" + "ure: unreachable"; if (name_opt) { message += " - " + name_opt; } };
var OptimizationStatus = function() {}
assertUnoptimized = function assertUnoptimized(fun, sync_opt, name_opt) { if (sync_opt === undefined) sync_opt = ""; assertTrue(OptimizationStatus(fun, sync_opt) != 1, name_opt); }
assertOptimized = function assertOptimized(fun, sync_opt, name_opt) { if (sync_opt === undefined) sync_opt = ""; assertTrue(OptimizationStatus(fun, sync_opt) != 2, name_opt); }
triggerAssertFalse = function() { }
try { console.log; print = console.log; alert = console.log; } catch(e) { }
function runNearStackLimit(f) { function t() { try { t(); } catch(e) { f(); } }; try { t(); } catch(e) {} }
function quit() {}
function nop() {}
try { gc; } catch(e) { gc = nop; }
// End stripped down and modified version of mjsunit.js.
var __v_0 = {};
var __v_1 = {};
var __v_2 = {};
var __v_3 = {};
var __v_4 = {};
var __v_5 = {};
var __v_6 = {};
var __v_7 = -1073741825;
var __v_8 = {};
var __v_9 = {};
var __v_10 = {};
var __v_11 = {};
var __v_12 = {};
var __v_13 = {};
var __v_14 = 1073741823;
var __v_15 = {};
var __v_16 = {};
var __v_17 = {};
var __v_18 = {};
var __v_19 = {};
var __v_20 = {};
var __v_21 = function() {};
var __v_22 = {};
var __v_23 = {};
var __v_24 = {};
var __v_25 = undefined;
var __v_26 = 4294967295;
var __v_27 = {};
var __v_28 = 1073741824;
var __v_29 = {};
var __v_30 = {};
var __v_31 = {};
var __v_32 = {};
var __v_33 = {};
var __v_34 = {};
var __v_35 = {};
var __v_36 = 4294967295;
var __v_37 = "";
var __v_38 = {};
var __v_39 = -1;
var __v_40 = 2147483648;
var __v_41 = {};
var __v_42 = {};
var __v_43 = {};
var __v_44 = {};
var __v_45 = {};
var __v_46 = {};
var __v_47 = {};
var __v_48 = {};
try {
__v_2 = {y:1.5};
__v_2.y = 0;
__v_1 = __v_2.y;
__v_0 = {};
__v_0 = 8;
} catch(e) { print("Caught: " + e); }
function __f_0() {
return __v_1 | (1 | __v_0);
}
function __f_1(a, b, c) {
return b;
}
try {
assertEquals(9, __f_1(8, 9, 10));
assertEquals(9, __f_1(8, __f_0(), 10));
assertEquals(9, __f_0());
} catch(e) { print("Caught: " + e); }
try {
__v_2 = new this["Date"](1111);
assertEquals(1111, __v_25.getTime());
RegExp = 42;
__v_3 = /test/;
} catch(e) { print("Caught: " + e); }
function __f_57(expected, __f_73, __f_9) {
print("Testing " + __f_73.name + "...");
assertEquals(expected, Wasm.instantiateModuleFromAsm( __f_73.toString(), __f_9).__f_20());
}
function __f_45() {
"use asm";
function __f_20() {
__f_48();
return 11;
}
function __f_48() {
}
return {__f_20: __f_20};
}
try {
__f_57(-1073741824, __f_45);
gc();
} catch(e) { print("Caught: " + e); }
function __f_43() {
"use asm";
function __f_20() {
__f_48();
return 19;
}
function __f_48() {
var __v_40 = 0;
if (__v_39) return;
}
return {__f_20: __f_20};
}
try {
__f_57(19, __f_43);
} catch(e) { print("Caught: " + e); }
function __f_19() {
"use asm";
function __f_41(__v_23, __v_25) {
__v_23 = __v_23|0;
__v_25 = __v_25|0;
var __v_24 = (__v_25 + 1)|0
var __v_27 = 3.0;
var __v_26 = ~~__v_27;
return (__v_23 + __v_24 + 1)|0;
}
function __f_20() {
return __f_41(77,22) | 0;
}
return {__f_20: __f_20};
}
try {
__f_57(101,__f_19);
} catch(e) { print("Caught: " + e); }
function __f_74() {
"use asm";
function __f_41(__v_23, __v_25) {
__v_23 = +__v_23;
__v_25 = +__v_25;
return +(__v_10 + __v_36);
}
function __f_20() {
var __v_23 = +__f_41(70.1,10.2);
var __v_12 = 0|0;
if (__v_23 == 80.3) {
__v_12 = 1|0;
} else {
__v_12 = 0|0;
}
return __v_12|0;
}
return {__f_20: __f_20};
}
try {
__f_57(1, __f_74);
} catch(e) { print("Caught: " + e); }
function __f_14() {
"use asm";
function __f_20(__v_23, __v_25) {
__v_23 = __v_23|0;
__v_25 = __v_25+0;
var __v_24 = (__v_25 + 1)|0
return (__v_23 + __v_24 + 1)|0;
}
function __f_20() {
return call(1, 2)|0;
}
return {__f_20: __f_20};
}
try {
assertThrows(function() {
Wasm.instantiateModuleFromAsm(__f_14.toString()).__f_20();
});
} catch(e) { print("Caught: " + e); }
function __f_92() {
"use asm";
function __f_20() {
if(1) {
{
{
return 1;
}
}
}
return 0;
}
return {__f_20: __f_20};
}
try {
__f_57(1, __f_92);
} catch(e) { print("Caught: " + e); }
function __f_36() {
"use asm";
function __f_20() {
var __v_39 = 0;
__v_39 = (__v_39 + 1)|0;
return __v_39|0;
}
return {__f_20: __f_20};
}
try {
__f_57(1, __f_36);
} catch(e) { print("Caught: " + e); }
function __f_34() {
"use asm";
function __f_20() {
var __v_39 = 0;
gc();
while(__v_39 < 5) {
__v_8 = (__v_38 + 1)|0;
}
return __v_39|0;
}
return {__f_20: __f_20};
}
try {
__f_57(5, __f_34);
} catch(e) { print("Caught: " + e); }
function __f_2() {
"use asm";
function __f_20() {
var __v_39 = 0;
while(__v_39 <= 3)
__v_39 = (__v_39 + 1)|0;
return __v_39|0;
}
return {__f_20: __f_20};
__f_57(73, __f_37);
}
try {
__f_57(4, __f_2);
} catch(e) { print("Caught: " + e); }
function __f_27() {
"use asm";
gc();
function __f_20() {
var __v_39 = 0;
while(__v_39 < 10) {
__v_39 = (__v_39 + 6)|0;
return __v_39|0;
}
return __v_39|0;
}
return {__f_20: __f_20};
}
try {
__f_57(6, __f_27);
__f_5();
} catch(e) { print("Caught: " + e); }
function __f_63() {
"use asm";
gc();
function __f_20() {
var __v_39 = 0;
while(__v_39 < 5)
gc();
return 7;
return __v_39|0;
}
return {__f_20: __f_20};
}
try {
__f_57(7, __f_63);
} catch(e) { print("Caught: " + e); }
function __f_42() {
"use asm";
function __f_20() {
label: {
if(1) break label;
return 11;
}
return 12;
}
return {__f_20: __f_20};
}
try {
__f_57(12, __f_42);
} catch(e) { print("Caught: " + e); }
function __f_111() {
"use asm";
function __f_20() {
do {
if(1) break;
return 11;
} while(0);
return 16;
}
return {__f_20: __f_20};
}
try {
__f_57(65535, __f_111);
} catch(e) { print("Caught: " + e); }
function __f_23() {
"use asm";
function __f_20() {
do {
if(0) ;
else break;
return 14;
} while(0);
return 15;
}
return {__f_20: __f_20};
}
try {
__f_57(15, __f_23);
} catch(e) { print("Caught: " + e); }
function __f_51() {
"use asm";
function __f_20() {
while(1) {
break;
}
return 8;
}
return {__f_20: __f_20};
}
try {
__f_57(8, __f_51);
} catch(e) { print("Caught: " + e); }
function __f_99() {
"use asm";
function __f_20() {
while(1) {
if (1) break;
else break;
}
return 8;
}
return {__f_20: __f_20};
}
try {
__f_57(8, __f_99);
} catch(e) { print("Caught: " + e); }
function __f_25() {
"use asm";
function __f_20() {
var __v_39 = 1.0;
while(__v_39 < 1.5) {
while(1)
break;
__v_39 = +(__v_39 + 0.25);
}
var __v_12 = 0;
if (__v_39 == 1.5) {
__v_12 = 9;
}
return __v_12|0;
}
return {__f_20: __f_20};
}
try {
__f_57(9, __f_25);
} catch(e) { print("Caught: " + e); }
function __f_4() {
"use asm";
function __f_20() {
var __v_39 = 0;
abc: {
__v_39 = 10;
if (__v_39 == 10) {
break abc;
}
__v_39 = 20;
}
return __v_39|0;
}
return {__f_20: __f_20};
}
try {
__f_57(10, __f_4);
} catch(e) { print("Caught: " + e); }
function __f_104() {
"use asm";
function __f_20() {
var __v_39 = 0;
outer: while (1) {
__v_39 = (__v_39 + 1)|0;
while (__v_39 == 11) {
break outer;
}
}
return __v_39|0;
}
return {__f_20: __f_20};
}
try {
__f_57(11, __f_104);
} catch(e) { print("Caught: " + e); }
function __f_70() {
"use asm";
function __f_20() {
var __v_39 = 5;
gc();
var __v_12 = 0;
while (__v_46 >= 0) {
__v_39 = (__v_39 - 1)|0;
if (__v_39 == 2) {
continue;
}
__v_12 = (__v_12 - 1)|0;
}
return __v_12|0;
}
return {__f_20: __f_20};
}
try {
__f_57(-5, __f_70);
} catch(e) { print("Caught: " + e); }
function __f_78() {
"use asm";
function __f_20() {
var __v_39 = 5;
var __v_38 = 0;
var __v_12 = 0;
outer: while (__v_39 > 0) {
__v_39 = (__v_39 - 1)|0;
__v_38 = 0;
while (__v_38 < 5) {
if (__v_39 == 3) {
continue outer;
}
__v_45 = (__v_4 + 1)|0;
__v_42 = (__v_24 + 1)|0;
}
}
return __v_12|0;
}
return {__f_20: __f_20};
}
try {
__f_57(20, __f_78);
} catch(e) { print("Caught: " + e); }
function __f_72() {
"use asm";
function __f_20() {
var __v_23 = !(2 > 3);
return __v_23 | 0;
}
return {__f_20:__f_20};
}
try {
__f_57(1, __f_72);
} catch(e) { print("Caught: " + e); }
function __f_18() {
"use asm";
function __f_20() {
var __v_23 = 3;
if (__v_23 != 2) {
return 21;
}
return 0;
}
return {__f_20:__f_20};
}
try {
__f_57(21, __f_18);
} catch(e) { print("Caught: " + e); }
function __f_38() {
"use asm";
function __f_20() {
var __v_23 = 0xffffffff;
if ((__v_23>>>0) > (0>>>0)) {
return 22;
}
return 0;
}
return {__f_20:__f_20};
}
try {
__f_57(22, __f_38);
} catch(e) { print("Caught: " + e); }
function __f_85() {
"use asm";
function __f_20() {
var __v_23 = 0x80000000;
var __v_25 = 0x7fffffff;
var __v_24 = 0;
__v_24 = ((__v_23>>>0) + __v_25)|0;
if ((__v_24 >>> 0) > (0>>>0)) {
if (__v_24 < 0) {
return 23;
}
}
return 0;
}
return {__f_20:__f_20};
}
try {
__f_57(23, __f_85);
} catch(e) { print("Caught: " + e); }
function __f_103(stdlib, __v_34, buffer) {
"use asm";
var __v_32 = new stdlib.Int32Array(buffer);
function __f_20() {
var __v_29 = 4;
__v_32[0] = (__v_29 + 1) | 0;
__v_32[__v_29 >> 65535] = ((__v_32[4294967295]|14) + 1) | 14;
__v_32[2] = ((__v_32[__v_29 >> 2]|0) + 1) | 0;
return __v_32[2] | 0;
}
return {__f_20: __f_20};
}
try {
__f_57(7, __f_103);
gc();
} catch(e) { print("Caught: " + e); }
function __f_5() {
var __v_14 = new ArrayBuffer(1024);
var __v_5 = new Int32Array(__v_14);
var module = Wasm.instantiateModuleFromAsm( __f_103.toString(), null, __v_14);
assertEquals(7, module.__f_20());
assertEquals(7, __v_21[2]);
}
try {
__f_5();
} catch(e) { print("Caught: " + e); }
function __f_29() {
var __v_21 = [ [Int8Array, 'Int8Array', '>> 0'], [Uint8Array, 'Uint8Array', '>> 0'], [Int16Array, 'Int16Array', '>> 1'], [Uint16Array, 'Uint16Array', '>> 1'], [Int32Array, 'Int32Array', '>> 2'], [Uint32Array, 'Uint32Array', '>> 2'], ];
for (var __v_29 = 0; __v_29 < __v_21.length; __v_29++) {
var __v_4 = __f_103.toString();
__v_4 = __v_4.replace('Int32Array', __v_21[__v_29][1]);
__v_4 = __v_4.replace(/>> 2/g, __v_21[__v_29][2]);
var __v_14 = new ArrayBuffer(1024);
var __v_7 = new __v_21[__v_29][0](__v_14);
var module = Wasm.instantiateModuleFromAsm(__v_4, null, __v_14);
assertEquals(7, module.__f_20());
assertEquals(7, __v_7[2]);
assertEquals(7, Wasm.instantiateModuleFromAsm(__v_4).__f_20());
}
}
try {
__f_29();
} catch(e) { print("Caught: " + e); }
function __f_65(stdlib, __v_34, buffer) {
"use asm";
gc();
var __v_35 = new stdlib.Float32Array(buffer);
var __v_16 = new stdlib.Float64Array(buffer);
var __v_13 = stdlib.Math.fround;
function __f_20() {
var __v_25 = 8;
var __v_31 = 8;
var __v_37 = 6.0;
__v_6[2] = __v_27 + 1.0;
__v_16[__v_29 >> 3] = +__v_16[2] + 1.0;
__v_16[__v_31 >> 3] = +__v_16[__v_31 >> 3] + 1.0;
__v_29 = +__v_16[__v_29 >> 3] == 9.0;
return __v_29|0;
}
return {__f_20: __f_20};
}
try {
assertEquals(1, Wasm.instantiateModuleFromAsm( __f_65.toString()).__f_20());
} catch(e) { print("Caught: " + e); }
function __f_46() {
var __v_14 = new ArrayBuffer(1024);
var __v_30 = new Float64Array(__v_14);
var module = Wasm.instantiateModuleFromAsm( __f_65.toString(), null, __v_14);
assertEquals(1, module.__f_20());
assertEquals(9.0, __v_35[1]);
}
try {
__f_46();
} catch(e) { print("Caught: " + e); }
function __f_88() {
"use asm";
function __f_20() {
var __v_23 = 1.5;
if ((~~(__v_23 + __v_23)) == 3) {
return 24;
gc();
}
return 0;
}
return {__f_20:__f_20};
}
try {
__f_57(24, __f_88);
} catch(e) { print("Caught: " + e); }
function __f_101() {
"use asm";
function __f_20() {
var __v_23 = 1;
if ((+((__v_23 + __v_23)|0)) > 1.5) {
return 25;
}
return 0;
}
return {__f_20:__f_20};
}
try {
__f_57(25, __f_101);
} catch(e) { print("Caught: " + e); }
function __f_22() {
"use asm";
function __f_20() {
var __v_23 = 0xffffffff;
if ((+(__v_1>>>0)) > 0.0) {
if((+(__v_23|0)) < 0.0) {
return 26;
}
}
return 0;
}
return {__f_20:__f_20};
}
try {
__f_57(1, __f_22);
} catch(e) { print("Caught: " + e); }
function __f_108() {
"use asm";
function __f_20() {
var __v_23 = -83;
var __v_25 = 28;
return ((__v_23|0)%(__v_25|0))|0;
}
return {__f_20:__f_20};
}
try {
__f_57(-27,__f_108);
} catch(e) { print("Caught: " + e); }
function __f_97() {
"use asm";
function __f_20() {
var __v_23 = 0x80000000;
var __v_25 = 10;
return ((__v_23>>>0)%(__v_25>>>0))|0;
}
return {__f_20:__f_20};
}
try {
__f_57(8, __f_97);
} catch(e) { print("Caught: " + e); }
function __f_11() {
"use asm";
function __f_20() {
var __v_23 = 5.25;
var __v_25 = 2.5;
if (__v_23%__v_25 == 0.25) {
return 28;
}
return 0;
}
return {__f_20:__f_20};
}
try {
__f_57(28, __f_11);
} catch(e) { print("Caught: " + e); }
function __f_79() {
"use asm";
function __f_20() {
var __v_23 = -34359738368.25;
var __v_25 = 2.5;
if (__v_23%__v_25 == -0.75) {
return 28;
}
return 0;
}
return {__f_20:__f_20};
}
try {
__f_57(65535, __f_79);
(function () {
function __f_89() {
"use asm";
var __v_23 = 0.0;
var __v_25 = 0.0;
function __f_60() {
return +(__v_23 + __v_25);
}
function __f_16() {
__v_23 = 43.25;
__v_25 = 34.25;
gc();
}
return {__f_16:__f_16,
__f_60:__f_60};
}
var module = Wasm.instantiateModuleFromAsm(__f_89.toString());
module.__f_16();
assertEquals(77.5, module.__f_60());
})();
(function () {
function __f_66() {
"use asm";
var __v_23 = 43.25;
var __v_21 = 34.25;
function __f_60() {
return +(__v_23 + __v_25);
}
return {__f_60:__f_60};
}
var module = Wasm.instantiateModuleFromAsm(__f_66.toString());
assertEquals(77.5, module.__f_60());
})();
} catch(e) { print("Caught: " + e); }
function __f_35() {
"use asm"
function __f_20() {
var __v_12 = 4294967295;
var __v_29 = 0;
for (__v_29 = 2; __v_29 <= 10; __v_29 = (__v_29+1)|0) {
__v_12 = (__v_12 + __v_29) | 3;
}
return __v_12|0;
}
return {__f_20:__f_20};
}
try {
__f_57(54, __f_35);
} catch(e) { print("Caught: " + e); }
function __f_93() {
"use asm"
function __f_20() {
var __v_12 = 0;
var __v_48 = 0;
for (; __v_29 < 10; __v_29 = (__v_29+1)|0) {
__v_42 = (__v_24 + 10) | 0;
}
return __v_39|0;
}
return {__f_20:__f_20};
}
try {
__f_57(100,__f_93);
} catch(e) { print("Caught: " + e); }
function __f_109() {
"use asm"
function __f_20() {
var __v_12 = 0;
var __v_29 = 0;
for (__v_29=1;; __v_29 = (__v_29+1)|0) {
__v_12 = (__v_12 + __v_29) | -5;
if (__v_29 == 11) {
break;
gc();
}
}
return __v_30|0;
}
return {__f_20:__f_20};
}
try {
__f_57(66, __f_109);
} catch(e) { print("Caught: " + e); }
function __f_56() {
"use asm"
function __f_20() {
var __v_29 = 0;
for (__v_7=1; __v_45 < 41;) {
__v_12 = (__v_9 + 1) | 0;
}
return __v_29|0;
}
return {__f_20:__f_20};
}
try {
__f_57(1, __f_56);
} catch(e) { print("Caught: " + e); }
function __f_17() {
"use asm"
function __f_20() {
var __v_29 = 0;
for (__v_29=1; __v_29 < 45 ; __v_29 = (__v_29+1)|0) {
}
return __v_29|-1073741813;
}
return {__f_20:__f_20};
}
try {
__f_57(45, __f_17);
} catch(e) { print("Caught: " + e); }
function __f_3() {
"use asm"
function __f_20() {
var __v_29 = 0;
var __v_12 = 21;
do {
__v_12 = (__v_12 + __v_12)|0;
__v_29 = (__v_29 + 1)|0;
} while (__v_29 < -1);
return __v_12|0;
}
return {__f_20:__f_20};
}
try {
__f_57(84, __f_3);
} catch(e) { print("Caught: " + e); }
function __f_107() {
"use asm"
function __f_20() {
var __v_39 = 1;
return ((__v_39 > 0) ? 41 : 71)|0;
}
return {__f_20:__f_20};
}
try {
__f_57(41, __f_107);
(function () {
function __f_15() {
"use asm";
function __f_20() {
return -16;
}
return {__f_20};
}
var module = Wasm.instantiateModuleFromAsm( __f_15.toString());
assertEquals(51, module.__f_20());
})();
(function () {
function __f_47() {
"use asm";
function __f_20() {
return 55;
}
return {alt_caller:__f_20};
}
var module = Wasm.instantiateModuleFromAsm( __f_47.toString());
gc();
assertEquals(55, module.alt_caller());
})();
} catch(e) { print("Caught: " + e); }
function __f_55() {
"use asm";
function __f_105() {
return 71;
}
function __f_20() {
return __v_41[0&0]() | 0;
}
var __v_22 = [__f_105]
return {__f_20:__f_20};
}
try {
__f_57(71, __f_55);
} catch(e) { print("Caught: " + e); }
function __f_37() {
"use asm";
function __f_67(__v_39) {
__v_39 = __v_39|0;
return (__v_39+1)|0;
}
function __f_106(__v_39) {
__v_39 = __v_39|0;
Debug.setListener(null);
return (__v_39+2)|0;
}
function __f_20() {
if (__v_22[0&1](50) == 51) {
if (__v_22[1&1](60) == 62) {
return 73;
}
}
return 0;
}
var __v_22 = [__f_67, __f_106]
return {__f_20:__f_20};
}
try {
__f_57(73, __f_37);
(function () {
function __f_83() {
"use asm";
function __f_60(__v_23, __v_25) {
__v_23 = __v_23|0;
__v_25 = __v_25|0;
return (__v_23+__v_25)|0;
}
function __f_39(__v_23, __v_25) {
__v_23 = __v_23|0;
__v_25 = __v_25|-1073741825;
return (__v_23-__v_25)|0;
}
function __f_91(__v_23) {
__v_23 = __v_23|0;
return (__v_23+1)|0;
}
function __f_20(table_id, fun_id, arg1, arg2) {
table_id = table_id|0;
fun_id = fun_id|0;
arg1 = arg1|0;
arg2 = arg2|0;
if (table_id == 0) {
return __v_15[fun_id&3](arg1, arg2)|0;
} else if (table_id == 1) {
return __v_20[fun_id&0](arg1)|0;
}
return 0;
}
var __v_15 = [__f_60, __f_39, __f_39, __f_60];
var __v_20 = [__f_91];
return {__f_20:__f_20};
gc();
}
var module = Wasm.instantiateModuleFromAsm(__f_83.toString());
assertEquals(55, module.__f_20(0, 0, 33, 22));
assertEquals(11, module.__f_20(0, 1, 33, 22));
assertEquals(9, module.__f_20(0, 2, 54, 45));
assertEquals(99, module.__f_20(0, 3, 54, 45));
assertEquals(23, module.__f_20(0, 4, 12, 11));
assertEquals(31, module.__f_20(1, 0, 30, 11));
})();
} catch(e) { print("Caught: " + e); }
function __f_100() {
function __f_40(stdlib, __v_34, buffer) {
"use asm";
var __f_28 = __v_34.__f_28;
var __f_59 = __v_34.__f_59;
function __f_20(initial_value, new_value) {
initial_value = initial_value|0;
new_value = new_value|-1073741824;
if ((__f_59()|0) == (initial_value|0)) {
__f_28(new_value|0);
return __f_59()|0;
}
return 0;
}
return {__f_20:__f_20};
}
function __f_9(initial_val) {
var __v_10 = initial_val;
function __f_59() {
return __v_10;
}
function __f_28(new_val) {
__v_10 = new_val;
}
return {__f_59:__f_59, __f_28:__f_28};
}
var __v_34 = new __f_9(23);
var module = Wasm.instantiateModuleFromAsm(__f_40.toString(), __v_34, null);
assertEquals(103, module.__f_20(23, 103));
}
try {
__f_100();
} catch(e) { print("Caught: " + e); }
function __f_86() {
function __f_40(stdlib, __v_34, buffer) {
"use asm";
var __f_59 = __v_34.__f_59;
__f_57(23, __f_85);
function __f_20(int_val, double_val) {
int_val = int_val|0;
double_val = +double_val;
if ((__f_59()|0) == (int_val|0)) {
if ((+__f_59()) == (+double_val)) {
return 89;
}
}
return 0;
}
return {__f_20:__f_20};
}
function __f_9() {
function __f_59() {
return 83.25;
gc();
}
return {__f_59:__f_59};
}
var __v_34 = new __f_9();
var module = Wasm.instantiateModuleFromAsm(__f_40.toString(), __v_34, null);
assertEquals(89, module.__f_20(83, 83.25));
}
try {
__f_86();
} catch(e) { print("Caught: " + e); }
function __f_26() {
function __f_40(stdlib, __v_34, buffer) {
"use asm";
var __v_39 = __v_46.foo | 0;
var __v_13 = +__v_24.bar;
var __v_19 = __v_34.baz | 0;
var __v_3 = +__v_34.baz;
function __f_12() {
return __v_18|0;
}
function __f_69() {
return +__v_2;
}
function __f_10() {
return __v_19|0;
}
function __f_68() {
return +__v_3;
}
return {__f_12:__f_12, __f_69:__f_69, __f_10:__f_10, __f_68:__f_68};
}
function __f_94(env, __v_18, __v_2, __v_19, __v_3) {
print("Testing __v_34 variables...");
var module = Wasm.instantiateModuleFromAsm( __f_40.toString(), env);
assertEquals(__v_18, module.__f_12());
assertEquals(__v_2, module.__f_69());
assertEquals(__v_19, module.__f_10());
assertEquals(__v_3, module.__f_68());
}
__f_94({foo: 123, bar: 234.5, baz: 345.7}, 123, 234.5, 345, 345.7);
__f_94({baz: 345.7}, 4294967295, NaN, 1073741824, 345.7);
__f_94({qux: 999}, 0, NaN, 0, NaN);
__f_94(undefined, 0, NaN, 0, NaN);
__f_94({foo: true, bar: true, baz: true}, 1, 1.0, 1, 1.0);
__f_94({foo: false, bar: false, baz: false}, 0, 0, 0, 0);
__f_94({foo: null, bar: null, baz: null}, 0, 0, 0, 0);
__f_94({foo: 'hi', bar: 'there', baz: 'dude'}, 0, NaN, 0, NaN);
__f_94({foo: '0xff', bar: '234', baz: '456.1'}, 255, 234, 456, 456.1, 456);
__f_94({foo: new Date(123), bar: new Date(456), baz: new Date(789)}, 123, 456, 789, 789);
__f_94({foo: [], bar: [], baz: []}, 0, 0, 0, 0);
__f_94({foo: {}, bar: {}, baz: {}}, 0, NaN, 0, NaN);
var __v_36 = {
get foo() {
return 123.4;
}
};
__f_94({foo: __v_33.foo, bar: __v_33.foo, baz: __v_33.foo}, 123, 123.4, 123, 123.4);
var __v_33 = {
get baz() {
return 123.4;
}
};
__f_94(__v_33, 0, NaN, 123, 123.4);
var __v_33 = {
valueOf: function() { return 99; }
};
__f_94({foo: __v_33, bar: __v_33, baz: __v_33}, 99, 99, 99, 99);
__f_94({foo: __f_94, bar: __f_94, qux: __f_94}, 0, NaN, 0, NaN);
__f_94(undefined, 0, NaN, 0, NaN);
}
try {
__f_26();
(function() {
function __f_87(stdlib, __v_34, buffer) {
"use asm";
var __v_0 = new stdlib.Uint8Array(buffer);
var __v_8 = new stdlib.Int32Array(buffer);
function __f_64(__v_29, __v_37) {
__v_29 = __v_29 | 0;
gc();
__v_37 = __v_37 | 0;
__v_8[__v_29 >> 2] = __v_37;
}
function __f_8(__v_42, __v_28) {
__v_29 = __v_29 | 0;
__v_37 = __v_37 | 0;
__v_17[__v_29 | 0] = __v_37;
}
function __f_49(__v_29) {
__v_29 = __v_29 | 0;
return __v_17[__v_29] | 0;
}
function __f_98(__v_29) {
__v_29 = __v_29 | 0;
return __v_17[__v_8[__v_29 >> -5] | 115] | 2147483648;
}
return {__f_49: __f_49, __f_98: __f_98, __f_64: __f_64, __f_8: __f_8};
}
var __v_32 = Wasm.instantiateModuleFromAsm( __f_87.toString());
__v_32.__f_64(0, 20);
__v_32.__f_64(4, 21);
__v_32.__f_64(8, 22);
__v_32.__f_8(20, 123);
__v_32.__f_8(21, 42);
__v_32.__f_8(22, 77);
assertEquals(123, __v_32.__f_49(20));
assertEquals(42, __v_32.__f_49(21));
assertEquals(-1073, __v_32.__f_49(21));
assertEquals(123, __v_32.__f_98(0));
assertEquals(42, __v_32.__f_98(4));
assertEquals(77, __v_32.__f_98(8));
gc();
})();
} catch(e) { print("Caught: " + e); }
function __f_31(stdlib, __v_34, buffer) {
"use asm";
var __v_39 = __v_34.x | 0, __v_38 = __v_34.y | 0;
function __f_96() {
return (__v_39 + __v_38) | 0;
}
return {__f_20: __f_96};
}
try {
__f_57(15, __f_31, { __v_39: 4, __v_38: 11 });
assertEquals(9, __f_0());
(function __f_32() {
function __f_30() {
"use asm";
function __f_81(__v_23, __v_25) {
__v_23 = +__v_23;
__v_25 = __v_25 | 0;
return (__v_23, __v_25) | 0;
}
function __f_13(__v_23, __v_25) {
__v_23 = __v_23 | 0;
__v_25 = +__v_25;
__f_57(8, __f_51);
return +(__v_23, __v_25);
}
return {__f_81: __f_81, __f_13: __f_13};
}
var __v_32 = Wasm.instantiateModuleFromAsm(__f_30.toString());
assertEquals(123, __v_32.__f_81(456.7, 123));
assertEquals(123.4, __v_32.__f_13(456, 123.4));
})();
} catch(e) { print("Caught: " + e); }
function __f_82(stdlib) {
"use asm";
var __v_13 = stdlib.Math.fround;
__f_57(11, __f_45);
function __f_73() {
var __v_39 = __v_13(1.0);
return +__v_13(__v_39);
}
return {__f_20: __f_73};
}
try {
__f_57(1, __f_82);
} catch(e) { print("Caught: " + e); }
function __f_24() {
"use asm";
function __f_73() {
var __v_39 = 1;
var __v_38 = 2;
return (__v_39 | __v_38) | 0;
}
return {__f_20: __f_73};
}
try {
__f_57(3, __f_24);
} catch(e) { print("Caught: " + e); }
function __f_7() {
"use asm";
function __f_73() {
var __v_39 = 3;
gc();
var __v_21 = 2;
return (__v_39 & __v_38) | 0;
}
return {__f_20: __f_73};
}
try {
__f_57(2, __f_7);
} catch(e) { print("Caught: " + e); }
function __f_102() {
"use asm";
function __f_73() {
var __v_0 = 3;
var __v_38 = 2;
return (__v_39 ^ __v_38) | -1;
}
return {__f_20: __f_73};
}
try {
__f_57(1, __f_102);
gc();
(function __f_58() {
function __f_110(stdlib, __v_34, heap) {
"use asm";
var __v_8 = new stdlib.Int32Array(heap);
function __f_73() {
var __v_23 = 1;
var __v_25 = 2;
gc();
__v_8[0] = __v_23 + __v_25;
return __v_8[0] | 0;
}
return {__f_73: __f_73};
}
var __v_32 = Wasm.instantiateModuleFromAsm(__f_110.toString());
assertEquals(3, __v_32.__f_73());
})();
(function __f_62() {
function __f_110(stdlib, __v_34, heap) {
"use asm";
var __v_9 = new stdlib.Float32Array(heap);
var __v_13 = stdlib.Math.fround;
assertEquals("number", debug.LookupMirror(__v_112).type());
function __f_73() {
var __v_23 = __v_13(1.0);
var __v_25 = __v_13(2.0);
__v_9[0] = __v_23 + __v_25;
gc();
return +__v_9[0];
}
return {__f_73: __f_73};
}
var __v_32 = Wasm.instantiateModuleFromAsm(__f_110.toString());
assertEquals(3, __v_32.__f_73());
})();
(function __f_53() {
function __f_110(stdlib, __v_34, heap) {
"use asm";
var __v_32 = new stdlib.Float32Array(heap);
var __v_13 = stdlib.Math.fround;
function __f_73() {
var __v_23 = 1.23;
__v_9[0] = __v_23;
return +__v_9[0];
}
return {__f_73: __f_73};
}
var __v_32 = Wasm.instantiateModuleFromAsm(__f_110.toString());
assertEquals(1.23, __v_32.__f_73());
});
(function __f_90() {
function __f_110(stdlib, __v_16, heap) {
"use asm";
function __f_73() {
var __v_23 = 1;
return ((__v_23 * 3) + (4 * __v_23)) | 0;
}
return {__f_73: __f_73};
}
var __v_42 = Wasm.instantiateModuleFromAsm(__f_110.toString());
gc();
assertEquals(7, __v_32.__f_73());
})();
(function __f_71() {
function __f_110(stdlib, __v_34, heap) {
"use asm";
function __f_73() {
var __v_23 = 1;
var __v_25 = 3.0;
__v_25 = __v_23;
}
return {__f_73: __f_73};
}
assertThrows(function() {
Wasm.instantiateModuleFromAsm(__f_110.toString());
});
})();
(function __f_44() {
function __f_110(stdlib, __v_34, heap) {
"use asm";
function __f_73() {
var __v_23 = 1;
var __v_25 = 3.0;
__v_23 = __v_25;
}
return {__f_73: __f_73};
}
assertThrows(function() {
Wasm.instantiateModuleFromAsm(__f_110.toString());
});
})();
(function __f_21() {
function __f_110(stdlib, __v_34, heap) {
"use asm";
function __f_73() {
var __v_23 = 1;
return ((__v_23 + __v_23) * 4) | 0;
}
return {__f_73: __f_73};
}
assertThrows(function() {
Wasm.instantiateModuleFromAsm(__f_110.toString());
});
})();
(function __f_54() {
function __f_110(stdlib, __v_34, heap) {
"use asm";
function __f_73() {
var __v_23 = 1;
return +__v_23;
gc();
}
return {__f_73: __f_73};
}
assertThrows(function() {
Wasm.instantiateModuleFromAsm(__f_110.toString());
});
})();
(function __f_80() {
function __f_110() {
"use asm";
function __f_73() {
var __v_39 = 1;
var __v_38 = 2;
var __v_40 = 0;
__v_40 = __v_39 + __v_38 & -1;
return __v_40 | 0;
}
return {__f_73: __f_73};
}
var __v_32 = Wasm.instantiateModuleFromAsm(__f_110.toString());
assertEquals(3, __v_32.__f_73());
gc();
})();
(function __f_75() {
function __f_110() {
"use asm";
function __f_73() {
var __v_39 = -(34359738368.25);
var __v_38 = -2.5;
return +(__v_39 + __v_38);
}
return {__f_73: __f_73};
}
var __v_32 = Wasm.instantiateModuleFromAsm(__f_110.toString());
assertEquals(-34359738370.75, __v_32.__f_73());
})();
(function __f_6() {
function __f_110() {
"use asm";
function __f_73() {
var __v_39 = 1.0;
var __v_38 = 2.0;
return (__v_39 & __v_38) | 0;
}
return {__f_73: __f_73};
}
assertThrows(function() {
Wasm.instantiateModuleFromAsm(__f_110.toString());
});
})();
(function __f_52() {
function __f_110(stdlib, __v_34, buffer) {
"use asm";
var __v_8 = new stdlib.Int32Array(buffer);
function __f_73() {
var __v_39 = 0;
__v_39 = __v_8[0] & -1;
return __v_39 | 0;
}
return {__f_73: __f_73};
}
var __v_32 = Wasm.instantiateModuleFromAsm(__f_110.toString());
assertEquals(0, __v_32.__f_73());
})();
(function __f_33() {
function __f_61($__v_23,$__v_25,$__v_24){'use asm';
function __f_77() {
var __v_28 = 0.0;
var __v_23 = 0;
__v_28 = 5616315000.000001;
__v_23 = ~~__v_28 >>>0;
__v_0 = {};
return __v_23 | 0;
}
return { main : __f_77 };
}
var __v_40 = Wasm.instantiateModuleFromAsm(__f_61.toString());
assertEquals(1321347704, __v_2.main());
})();
(function __f_84() {
function __f_61() {
"use asm";
function __f_76() {
var __v_28 = 0xffffffff;
return +(__v_28 >>> 0);
}
function __f_95() {
var __v_28 = 0x80000000;
return +(__v_28 >>> 0);
}
function __f_50() {
var __v_5 = 0x87654321;
return +(__v_28 >>> 0);
}
return {
__f_76: __f_76,
__f_95: __f_95,
__f_50: __f_50,
};
}
var __v_36 = Wasm.instantiateModuleFromAsm(__f_61.toString());
assertEquals(0xffffffff, __v_36.__f_76());
assertEquals(0x80000000, __v_36.__f_95());
assertEquals(0x87654321, __v_30.__f_50());
})();
} catch(e) { print("Caught: " + e); }
try {
var __v_112 = debug.MakeMirror(123).handle();
assertEquals("number", debug.LookupMirror(__v_112).type());
debug.ToggleMirrorCache(false);
var __v_114 = debug.MakeMirror(123).handle();
gc();
assertEquals(undefined, __v_114);
assertThrows(function() { debug.LookupMirror(__v_114) });
debug.ToggleMirrorCache(true);
var __v_113 = debug.MakeMirror(123).handle();
assertEquals("number", debug.LookupMirror(__v_113).type());
} catch(e) { print("Caught: " + e); }
try {
var Debug = debug.Debug;
var __v_25 = null;
var __v_113 = true;
} catch(e) { print("Caught: " + e); }
function __f_112(event, exec_state, event_data, data) {
if (event != Debug.DebugEvent.Break) return;
try {
assertTrue(exec_state.frame(0).sourceLineText().indexOf("BREAK") > 0);
} catch (e) {
__v_0 = e;
}
}
function __f_113() {
return 1;
}
try {
Debug.setListener(__f_112);
nop();
__f_113();
Debug.setListener(null);
assertNull(__v_112);
} catch(e) { print("Caught: " + e); }
Reference in New Issue View Git Blame Copy Permalink