diff --git a/test/js/bun/jsc-stress/LICENSE b/test/js/bun/jsc-stress/LICENSE new file mode 100644 index 0000000000..5130d62d0b --- /dev/null +++ b/test/js/bun/jsc-stress/LICENSE @@ -0,0 +1,30 @@ +The test fixtures in this directory are derived from WebKit's JSTests: + - fixtures/*.js from WebKit/JSTests/stress/ + - fixtures/wasm/*.js from WebKit/JSTests/wasm/stress/ + +These files are licensed under the BSD 2-Clause License, per WebKit's +contribution policy for new code. + +--- + +Copyright (C) 2014-2024 Apple Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND ANY +EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/test/js/bun/jsc-stress/bunfig.toml b/test/js/bun/jsc-stress/bunfig.toml new file mode 100644 index 0000000000..01cab3dd11 --- /dev/null +++ b/test/js/bun/jsc-stress/bunfig.toml @@ -0,0 +1,5 @@ +[run] +preload = "./preload.js" + +[test] +preload = "./preload.js" diff --git a/test/js/bun/jsc-stress/fixtures/dfg-ai-fold-bigint.js b/test/js/bun/jsc-stress/fixtures/dfg-ai-fold-bigint.js new file mode 100644 index 0000000000..2cb59acd03 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/dfg-ai-fold-bigint.js @@ -0,0 +1,91 @@ +// @bun +function shouldBe(actual, expected) { + if (actual !== expected) + throw new Error('bad value: ' + actual); +} + +function allAreTrue(list) +{ + for (let item of list) + shouldBe(item, true); +} + +function allAreFalse(list) +{ + for (let item of list) + shouldBe(item, false); +} + +function lessThan() +{ + return [0n < 2n, -10n < 20n, -10n < -2n, -100000000000000n < 0n, -100000000000000n < 10000n, -100000000000000n < -10000n, -1000000000000000000000n < -100000000000n, 1000000000000000000000n < 1000000000000000000000000n]; +} +noInline(lessThan); + +function lessThanFalse() +{ + return [100000000000000000000n < 100000000000000000000n, 0n < 0n, 2n < 0n, 2n < 2n, -10n < -10n, 20n < -20n, -2n < -10n, 0n < -100000000000000n, -10000n < -100000000000000n, -100000000000n < -1000000000000000000000n, 1000000000000000000000000n < 1000000000000000000000n ]; +} +noInline(lessThanFalse); + +function lessThanEqual() +{ + return [100000000000000000000n <= 100000000000000000000n, 0n <= 0n, 0n <= 2n, 2n <= 2n, -10n <= -10n, -20n <= 20n, -10n <= -2n, -100000000000000n <= 0n, -100000000000000n <= -10000n, -1000000000000000000000n <= -100000000000n, 1000000000000000000000n <= 1000000000000000000000000n ]; +} +noInline(lessThanEqual); + +function lessThanEqualFalse() +{ + return [100000000000000000001n <= 100000000000000000000n, 1n <= 0n, 2n <= 0n, 3n <= 2n, -10n <= -11n, 20n <= -20n, -2n <= -10n, 0n <= -100000000000000n, -10000n <= -100000000000000n, -100000000000n <= -1000000000000000000000n, 1000000000000000000000000n <= 1000000000000000000000n ]; +} +noInline(lessThanEqualFalse); + +function greaterThan() +{ + return [2n > 0n, 20n > -10n, -2n > -10n, 0n > -100000000000000n, 10000n > -100000000000000n, -10000n > -100000000000000n, -100000000000n > -1000000000000000000000n, 1000000000000000000000000n > 1000000000000000000000n ]; +} +noInline(greaterThan); + +function greaterThanFalse() +{ + return [100000000000000000000n > 100000000000000000000n, 0n > 0n, 0n > 2n, 2n > 2n, -10n > -10n, -20n > 20n, -10n > -2n, -100000000000000n > 0n, -100000000000000n > -10000n, -1000000000000000000000n > -100000000000n, 1000000000000000000000n > 1000000000000000000000000n ]; +} +noInline(greaterThanFalse); + +function greaterThanEqual() +{ + return [100000000000000000000n >= 100000000000000000000n, 0n >= 0n, 2n >= 0n, 2n >= 2n, -10n >= -10n, 20n >= -20n, -2n >= -10n, 0n >= -100000000000000n, -10000n >= -100000000000000n, -100000000000n >= -1000000000000000000000n, 1000000000000000000000000n >= 1000000000000000000000n ]; +} +noInline(greaterThanEqual); + +function greaterThanEqualFalse() +{ + return [100000000000000000000n >= 100000000000000000001n, 0n >= 1n, 0n >= 2n, 2n >= 3n, -11n >= -10n, -20n >= 20n, -10n >= -2n, -100000000000000n >= 0n, -100000000000000n >= -10000n, -1000000000000000000000n >= -100000000000n, 1000000000000000000000n >= 1000000000000000000000000n ]; +} +noInline(greaterThanEqualFalse); + +function equal() +{ + return [100000000000000000000n == 100000000000000000000n, 0n == 0n, 2n == 2n, -2n == -2n, -20n == -20n, -100000000000000n == -100000000000000n]; +} +noInline(equal); + +function equalFalse() +{ + return [100000000000000000001n == 100000000000000000000n, 1n == 0n, -2n == 2n, 2n == -2n, -20n == 20n, -100000000000000n == 100000000000000n, 100000000000000n == -100000000000000n, -100000000000001n == -100000000000000n, 100000000000001n == 100000000000000n, -100000000000000n == 1n, 100000000000000n == 1n, -1n == 100000000000000n, 1n == -100000000000000n, -1n == -100000000000000n]; +} +noInline(equalFalse); + +for (var i = 0; i < 1e4; ++i) { + allAreTrue(lessThan()); + allAreTrue(lessThanEqual()); + allAreTrue(greaterThan()); + allAreTrue(greaterThanEqual()); + allAreTrue(equal()); + + allAreFalse(lessThanFalse()); + allAreFalse(lessThanEqualFalse()); + allAreFalse(greaterThanFalse()); + allAreFalse(greaterThanEqualFalse()); + allAreFalse(equalFalse()); +} diff --git a/test/js/bun/jsc-stress/fixtures/dfg-call-class-constructor.js b/test/js/bun/jsc-stress/fixtures/dfg-call-class-constructor.js new file mode 100644 index 0000000000..867d6432c9 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/dfg-call-class-constructor.js @@ -0,0 +1,15 @@ +// @bun +class Foo extends Promise { } + +noInline(Foo); + +for (var i = 0; i < testLoopCount; ++i) { + var completed = false; + try { + Foo(); + completed = true; + } catch (e) { + } + if (completed) + throw "Error: completed without throwing"; +} diff --git a/test/js/bun/jsc-stress/fixtures/dfg-create-arguments-inline-alloc.js b/test/js/bun/jsc-stress/fixtures/dfg-create-arguments-inline-alloc.js new file mode 100644 index 0000000000..68dafba46f --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/dfg-create-arguments-inline-alloc.js @@ -0,0 +1,20 @@ +// @bun +var foo = function(o) { + var a = Array.prototype.slice.call(arguments); + var sum = 0; + for (var i = 0; i < a.length; ++i) + sum += a[i].x; + return sum; +}; + +noInline(foo); + +var niters = 10000; +var total = 0; +var o = {x: 42}; +for (var i = 0; i < niters; ++i) { + total += foo(o, o, o); +} + +if (total != 42 * 3 * niters) + throw new Error("Incorrect result!"); diff --git a/test/js/bun/jsc-stress/fixtures/dfg-exception-try-catch-in-constructor-with-inlined-throw.js b/test/js/bun/jsc-stress/fixtures/dfg-exception-try-catch-in-constructor-with-inlined-throw.js new file mode 100644 index 0000000000..304f888dc4 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/dfg-exception-try-catch-in-constructor-with-inlined-throw.js @@ -0,0 +1,28 @@ +// @bun +function f() { + return 20; +} +noInline(f); + +function bar(b) { + if (b) + throw new Error("blah!"); +} + +function Foo(b) { + try { + this.value = bar(b); + } catch(e) { + this.value = e.toString(); + } + + f(this.value, b); +} +noInline(Foo); + + +for (var i = 1; i < 1000; i++) { + let value = new Foo(i % 3 === 0); + if (i % 3 === 0 && value.value !== "Error: blah!") + throw new Error("bad value: " + value.value); +} diff --git a/test/js/bun/jsc-stress/fixtures/dfg-internal-function-call.js b/test/js/bun/jsc-stress/fixtures/dfg-internal-function-call.js new file mode 100644 index 0000000000..a2437c1dac --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/dfg-internal-function-call.js @@ -0,0 +1,15 @@ +// @bun +function shouldBe(actual, expected) { + if (actual !== expected) + throw new Error('bad value: ' + actual); +} +noInline(shouldBe); + +function target(func) +{ + return func(); +} +noInline(target); + +for (var i = 0; i < 1e4; ++i) + shouldBe(target(Array).length, 0); diff --git a/test/js/bun/jsc-stress/fixtures/dfg-internal-function-construct.js b/test/js/bun/jsc-stress/fixtures/dfg-internal-function-construct.js new file mode 100644 index 0000000000..49a5807de6 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/dfg-internal-function-construct.js @@ -0,0 +1,15 @@ +// @bun +function shouldBe(actual, expected) { + if (actual !== expected) + throw new Error('bad value: ' + actual); +} +noInline(shouldBe); + +function target(func) +{ + return new func(); +} +noInline(target); + +for (var i = 0; i < 1e4; ++i) + shouldBe(target(Array).length, 0); diff --git a/test/js/bun/jsc-stress/fixtures/dfg-node-convert-to-constant-must-clear-varargs-flags.js b/test/js/bun/jsc-stress/fixtures/dfg-node-convert-to-constant-must-clear-varargs-flags.js new file mode 100644 index 0000000000..3bca326e13 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/dfg-node-convert-to-constant-must-clear-varargs-flags.js @@ -0,0 +1,15 @@ +// @bun +function doIndexOf(a) { + a.indexOf(a); +} + +function bar(f) { + f(); +} + +let array = [20]; +for (let i = 0; i < testLoopCount; ++i) { + bar(() => { + return doIndexOf(array.concat()); + }); +} diff --git a/test/js/bun/jsc-stress/fixtures/dfg-osr-entry-should-not-use-callframe-argument.js b/test/js/bun/jsc-stress/fixtures/dfg-osr-entry-should-not-use-callframe-argument.js new file mode 100644 index 0000000000..e38029d3d0 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/dfg-osr-entry-should-not-use-callframe-argument.js @@ -0,0 +1,22 @@ +// @bun +//@ runDefault("--useConcurrentJIT=0", "--jitPolicyScale=0.001") + +function shouldBe(actual, expected) { + if (String(actual) !== expected) + throw new Error('bad value: ' + actual); +} +noInline(shouldBe); + +const arr = [[11, 22, 33]]; +class CC { + constructor(a) { + [a] = arr; + for (let i = 0; i < 8; i++) { + shouldBe(a, `11,22,33`); + } + const c = [53255]; + c[8] = 2; + } +} +new CC(); +new CC(); diff --git a/test/js/bun/jsc-stress/fixtures/dfg-put-by-val-direct-with-edge-numbers.js b/test/js/bun/jsc-stress/fixtures/dfg-put-by-val-direct-with-edge-numbers.js new file mode 100644 index 0000000000..fbdfabe410 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/dfg-put-by-val-direct-with-edge-numbers.js @@ -0,0 +1,105 @@ +// @bun +// Test that a object accepts DFG PutByValueDirect operation with edge numbers. + +function lookupWithKey(key) { + var object = { + [key]: 42 + }; + return object[key]; +} +noInline(lookupWithKey); + +for (var i = 0; i < testLoopCount; ++i) { + [ + // integers + -0x80000001, // out of int32_t + -0x80000000, // int32_t min + -1, // negative + 0, // zero + 1, // positive + 0x7fffffff, // int32_t max + 0x80000000, // out of int32_t + 0xfffffffd, // less than array max in JSObject + 0xfffffffe, // array max in JSObject + 0xffffffff, // uint32_t max, not array index + 0x100000000, // out of uint32_t + + // stringified integers + (-0x80000001).toString(), // out of int32_t + (-0x80000000).toString(), // int32_t min + (-1).toString(), // negative + (0).toString(), // zero + (1).toString(), // positive + (0x7fffffff).toString(), // int32_t max + (0x80000000).toString(), // out of int32_t + (0xfffffffd).toString(), // less than array max in JSObject + (0xfffffffe).toString(), // array max in JSObject + (0xffffffff).toString(), // (uint32_t max).toString() + (0x100000000).toString(), // out of uint32_t + + // doubles + Number.MIN_VALUE, + Number.MAX_VALUE, + Number.MIN_SAFE_INTEGER, + Number.MAX_SAFE_INTEGER, + Number.POSITIVE_INFINITY, + Number.NEGATIVE_INFINITY, + Number.NaN, + Number.EPSILON, + +0.0, + -0.0, + 0.1, + -0.1, + 4.2, + -4.2, + 0x80000000 + 0.5, // out of int32_t, double + + // stringified doules + (Number.MIN_VALUE).toString(), + (Number.MAX_VALUE).toString(), + (Number.MIN_SAFE_INTEGER).toString(), + (Number.MAX_SAFE_INTEGER).toString(), + (Number.POSITIVE_INFINITY).toString(), + (Number.NEGATIVE_INFINITY).toString(), + "NaN", + (Number.EPSILON).toString(), + "+0.0", + "-0.0", + "0.1", + "-0.1", + "4.2", + "-4.2", + (0x80000000 + 0.5).toString() + ].forEach(function (key) { + var value = lookupWithKey(key); + if (value !== 42) + throw new Error('bad value: ' + value); + }); +} + +function lookupWithKey2(key) { + var object = { + [key]: 42 + }; + return object[key]; +} +noInline(lookupWithKey2); + +var toStringThrowsError = { + toString: function () { + throw new Error('ng'); + } +}; + +for (var i = 0; i < testLoopCount; ++i) { + var error = null; + try { + lookupWithKey2(toStringThrowsError); + } catch (e) { + error = e; + } + if (!error) + throw new Error('not thrown'); + if (String(error) !== 'Error: ng') + throw new Error('bad error: ' + String(error)); +} diff --git a/test/js/bun/jsc-stress/fixtures/dfg-rare-data.js b/test/js/bun/jsc-stress/fixtures/dfg-rare-data.js new file mode 100644 index 0000000000..502b95a0ae --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/dfg-rare-data.js @@ -0,0 +1,10 @@ +// @bun +function F () { this.inner = 42; }; + +for (var i = 0; i < testLoopCount; ++i) { + var x = new F(false); + F.prototype = Object; // Force clearing of the function's rare data + var result = x.inner; + if (result !== 42) + throw "Expected 42, got: " + result; +} diff --git a/test/js/bun/jsc-stress/fixtures/dfg-ssa-swap.js b/test/js/bun/jsc-stress/fixtures/dfg-ssa-swap.js new file mode 100644 index 0000000000..faa8efc1a1 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/dfg-ssa-swap.js @@ -0,0 +1,9 @@ +// @bun +var i,c=0; +function foo() +{ + var a=1,b;for(i=0;i<2;++i){[a,b]=[b,a];c++}if(!a^b)throw c +} +noInline(foo); +for(var k = 0; k < testLoopCount; ++k) + foo() diff --git a/test/js/bun/jsc-stress/fixtures/dfg-strength-reduction-on-mod-should-handle-INT_MIN.js b/test/js/bun/jsc-stress/fixtures/dfg-strength-reduction-on-mod-should-handle-INT_MIN.js new file mode 100644 index 0000000000..45fc830f51 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/dfg-strength-reduction-on-mod-should-handle-INT_MIN.js @@ -0,0 +1,12 @@ +// @bun +function foo(num) { + num |= 0; + let x1 = num % -2147483648; + let x2 = x1 % 5; + + if (x2 > 5) + throw "Error"; +} + +for (let i = 0; i < testLoopCount; i++) + foo(i); diff --git a/test/js/bun/jsc-stress/fixtures/dfg-to-primitive-pass-symbol.js b/test/js/bun/jsc-stress/fixtures/dfg-to-primitive-pass-symbol.js new file mode 100644 index 0000000000..711506fc50 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/dfg-to-primitive-pass-symbol.js @@ -0,0 +1,36 @@ +// @bun +var shouldThrow = false; + +// str concat generates op_to_primitive. +function toPrimitiveTarget() { + if (shouldThrow) { + return Symbol('Cocoa'); + } + return 'Cocoa'; +} +noInline(toPrimitiveTarget); + +function doToPrimitive() { + var value = toPrimitiveTarget(); + return value + "Cappuccino" + value; +} +noInline(doToPrimitive); + +for (var i = 0; i < testLoopCount; ++i) { + var result = doToPrimitive(); + if (result !== "CocoaCappuccinoCocoa") + throw "Error: bad result: " + result; +} + +shouldThrow = true; + +var didThrow; +try { + shouldThrow = true; + doToPrimitive(); +} catch (e) { + didThrow = e; +} + +if (String(didThrow) !== "TypeError: Cannot convert a symbol to a string") + throw "Error: didn't throw or threw wrong exception: " + didThrow; diff --git a/test/js/bun/jsc-stress/fixtures/dfg-try-catch-wrong-value-recovery-on-ic-miss.js b/test/js/bun/jsc-stress/fixtures/dfg-try-catch-wrong-value-recovery-on-ic-miss.js new file mode 100644 index 0000000000..d2477034df --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/dfg-try-catch-wrong-value-recovery-on-ic-miss.js @@ -0,0 +1,51 @@ +// @bun +function assert(b) { + if (!b) + throw new Error("bad value") +} +noInline(assert); + +let oThrow = { + x: 20, + y: 40, + z: 50, + get f() { throw new Error("Hello World!"); } +}; + +let o1 = { + x: 20, + f: 40 +}; + +let o2 = { + x: 20, + y: 50, + f: 500, + get f() { return 20; } +}; + +function foo(f) { + let o = f(); + try { + o = o.f; + } catch(e) { + assert(o === oThrow); // Make sure this is not undefined. + } +} +noInline(foo); + +let i; +let flag = false; +function f() { + if (flag) + return oThrow; + if (i % 2) + return o1; + return o2; +} +noInline(f); +for (i = 0; i < testLoopCount; i++) { + foo(f); +} +flag = true; +foo(f); diff --git a/test/js/bun/jsc-stress/fixtures/ftl-arithcos.js b/test/js/bun/jsc-stress/fixtures/ftl-arithcos.js new file mode 100644 index 0000000000..9a6a56e145 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-arithcos.js @@ -0,0 +1,17 @@ +// @bun +//@ skip if $hostOS == "windows" + +function foo(x) { + return Math.cos(x); +} + +noInline(foo); + +let expected = foo(testLoopCount - 1); +var j = 0; +for (var i = 0; i < testLoopCount; ++i) + j = foo(i); + +if (expected != j) { + throw "Error" +} diff --git a/test/js/bun/jsc-stress/fixtures/ftl-arithsin.js b/test/js/bun/jsc-stress/fixtures/ftl-arithsin.js new file mode 100644 index 0000000000..de1ee24152 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-arithsin.js @@ -0,0 +1,15 @@ +// @bun +function foo(x) { + return Math.sin(x); +} + +noInline(foo); + +var j = 0; +let expected = foo(testLoopCount - 1); +for (var i = 0; i < testLoopCount; ++i) + j = foo(i); + +if (expected != j) { + throw "Error" +} diff --git a/test/js/bun/jsc-stress/fixtures/ftl-arithsqrt.js b/test/js/bun/jsc-stress/fixtures/ftl-arithsqrt.js new file mode 100644 index 0000000000..fe0a14f292 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-arithsqrt.js @@ -0,0 +1,15 @@ +// @bun +function foo(x) { + return Math.sqrt(x); +} + +noInline(foo); + +let expected = foo(testLoopCount - 1); +var j = 0; +for (var i = 0; i < testLoopCount; ++i) + j = foo(i); + +if (expected != j) { + throw "Error" +} diff --git a/test/js/bun/jsc-stress/fixtures/ftl-arithtan.js b/test/js/bun/jsc-stress/fixtures/ftl-arithtan.js new file mode 100644 index 0000000000..32ee1cb567 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-arithtan.js @@ -0,0 +1,15 @@ +// @bun +function foo(x) { + return Math.tan(x); +} + +noInline(foo); + +var expected = foo(testLoopCount - 1); +var j = 0; +for (var i = 0; i < testLoopCount; ++i) + j = foo(i); + +if (expected != j){ + throw `Error: ${j}`; +} diff --git a/test/js/bun/jsc-stress/fixtures/ftl-call-exception-no-catch.js b/test/js/bun/jsc-stress/fixtures/ftl-call-exception-no-catch.js new file mode 100644 index 0000000000..bb52e5bca2 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-call-exception-no-catch.js @@ -0,0 +1,52 @@ +// @bun +function foo(f, p) { + var x = 100; + var result = 101; + x = 102; + p = 103; + result = f(); + f = 104; + p = 105; + x = 106; + return {outcome: "return", values: [f, p, x, result]}; +} + +noInline(foo); + +function bar() { + return 107; +} + +noInline(bar); + +// Warm up foo(). +for (var i = 0; i < testLoopCount; ++i) { + var result = foo(bar); + if (result.outcome !== "return") + throw "Error in loop: bad outcome: " + result.outcome; + if (result.values.length !== 4) + throw "Error in loop: bad number of values: " + result.values.length; + if (result.values[0] !== 104) + throw "Error in loop: bad values[0]: " + result.values[0]; + if (result.values[1] !== 105) + throw "Error in loop: bad values[1]: " + result.values[1]; + if (result.values[2] !== 106) + throw "Error in loop: bad values[2]: " + result.values[2]; + if (result.values[3] !== 107) + throw "Error in loop: bad values[3]: " + result.values[3]; +} + +// Now throw an exception. +var result; +try { + bar = function() { + throw "Error42"; + } + var result = foo(bar, 108); +} catch (e) { + if (e != "Error42") + throw "Error at end: bad exception: " + e; + result = {outcome: "exception"}; +} +if (result.outcome !== "exception") + throw "Error at end: bad outcome: " + result.outcome; diff --git a/test/js/bun/jsc-stress/fixtures/ftl-call-exception.js b/test/js/bun/jsc-stress/fixtures/ftl-call-exception.js new file mode 100644 index 0000000000..85a5876f07 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-call-exception.js @@ -0,0 +1,60 @@ +// @bun +function foo(f, p, args) { + var x = 100; + var result = 101; + try { + x = 102; + p = 103; + result = f.apply(this, args); + f = 104; + p = 105; + x = 106; + } catch (e) { + return {outcome: "exception", values: [f, p, x, result]}; + } + return {outcome: "return", values: [f, p, x, result]}; +} + +noInline(foo); + +function bar(a, b, c) { + return a + b + c; +} + +noInline(bar); + +// Warm up foo(). +for (var i = 0; i < testLoopCount; ++i) { + var result = foo(bar, null, [105, 1, 1]); + if (result.outcome !== "return") + throw "Error in loop: bad outcome: " + result.outcome; + if (result.values.length !== 4) + throw "Error in loop: bad number of values: " + result.values.length; + if (result.values[0] !== 104) + throw "Error in loop: bad values[0]: " + result.values[0]; + if (result.values[1] !== 105) + throw "Error in loop: bad values[1]: " + result.values[1]; + if (result.values[2] !== 106) + throw "Error in loop: bad values[2]: " + result.values[2]; + if (result.values[3] !== 107) + throw "Error in loop: bad values[3]: " + result.values[3]; +} + +// Now throw an exception. +bar = function() { + throw "Error42"; +} +var result = foo(bar, 108, [105, 1, 1]); +if (result.outcome !== "exception") + throw "Error at end: bad outcome: " + result.outcome; +if (result.values.length !== 4) + throw "Error at end: bad number of values: " + result.values.length; +if (result.values[0] !== bar) + throw "Error at end: bad values[0]: " + result.values[0]; +if (result.values[1] !== 103) + throw "Error at end: bad values[1]: " + result.values[1]; +if (result.values[2] !== 102) + throw "Error at end: bad values[2]: " + result.values[2]; +if (result.values[3] !== 101) + throw "Error at end: bad values[3]: " + result.values[3]; + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-call-varargs-exception.js b/test/js/bun/jsc-stress/fixtures/ftl-call-varargs-exception.js new file mode 100644 index 0000000000..644229ce2c --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-call-varargs-exception.js @@ -0,0 +1,60 @@ +// @bun +function foo(f, p) { + var x = 100; + var result = 101; + try { + x = 102; + p = 103; + result = f(); + f = 104; + p = 105; + x = 106; + } catch (e) { + return {outcome: "exception", values: [f, p, x, result]}; + } + return {outcome: "return", values: [f, p, x, result]}; +} + +noInline(foo); + +function bar() { + return 107; +} + +noInline(bar); + +// Warm up foo(). +for (var i = 0; i < testLoopCount; ++i) { + var result = foo(bar); + if (result.outcome !== "return") + throw "Error in loop: bad outcome: " + result.outcome; + if (result.values.length !== 4) + throw "Error in loop: bad number of values: " + result.values.length; + if (result.values[0] !== 104) + throw "Error in loop: bad values[0]: " + result.values[0]; + if (result.values[1] !== 105) + throw "Error in loop: bad values[1]: " + result.values[1]; + if (result.values[2] !== 106) + throw "Error in loop: bad values[2]: " + result.values[2]; + if (result.values[3] !== 107) + throw "Error in loop: bad values[3]: " + result.values[3]; +} + +// Now throw an exception. +bar = function() { + throw "Error42"; +} +var result = foo(bar, 108); +if (result.outcome !== "exception") + throw "Error at end: bad outcome: " + result.outcome; +if (result.values.length !== 4) + throw "Error at end: bad number of values: " + result.values.length; +if (result.values[0] !== bar) + throw "Error at end: bad values[0]: " + result.values[0]; +if (result.values[1] !== 103) + throw "Error at end: bad values[1]: " + result.values[1]; +if (result.values[2] !== 102) + throw "Error at end: bad values[2]: " + result.values[2]; +if (result.values[3] !== 101) + throw "Error at end: bad values[3]: " + result.values[3]; + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-checkin-variable.js b/test/js/bun/jsc-stress/fixtures/ftl-checkin-variable.js new file mode 100644 index 0000000000..7b894687e6 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-checkin-variable.js @@ -0,0 +1,18 @@ +// @bun +function foo(l,x){ + var t = l in x; + return t; +} + +noInline(foo); + +var r; +for (var i = 0; i < testLoopCount; ++i) { + var z = { 'y' : i, 's' : i + 1 }; + z.s = 10; + r = foo("s",z); +} + +if (!r) { + print ("Error: " + r); +} diff --git a/test/js/bun/jsc-stress/fixtures/ftl-checkin.js b/test/js/bun/jsc-stress/fixtures/ftl-checkin.js new file mode 100644 index 0000000000..2594655a00 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-checkin.js @@ -0,0 +1,18 @@ +// @bun +function foo(x){ + var t = "s" in x; + return t; +} + +noInline(foo); + +var r; +for (var i = 0; i < testLoopCount; ++i) { + var z = { 'y' : i, 's' : i + 1 }; + z.s = 10; + r = foo(z); +} + +if (!r) { + print ("Error: " + r); +} diff --git a/test/js/bun/jsc-stress/fixtures/ftl-force-osr-exit.js b/test/js/bun/jsc-stress/fixtures/ftl-force-osr-exit.js new file mode 100644 index 0000000000..e3366531dd --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-force-osr-exit.js @@ -0,0 +1,22 @@ +// @bun +function foo(p, o) { + var q = o.q; + if (p) + return q.f; + return q.g; +} + +noInline(foo); + +var o = {q: {f: 41, g: 42}}; + +for (var i = 0; i < testLoopCount; ++i) { + var result = foo(false, o); + if (result != 42) + throw "Error: bad result: " + result; +} + +var result = foo(true, o); +if (result != 41) + throw "Error: bad result at end: " + result; + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-get-by-id-getter-exception.js b/test/js/bun/jsc-stress/fixtures/ftl-get-by-id-getter-exception.js new file mode 100644 index 0000000000..9b8a2787a9 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-get-by-id-getter-exception.js @@ -0,0 +1,61 @@ +// @bun +function foo(o, p) { + var x = 100; + var result = 101; + try { + x = 102; + p = 103; + result = o.f; + o = 104; + p = 105; + x = 106; + } catch (e) { + return {outcome: "exception", values: [o, p, x, result]}; + } + return {outcome: "return", values: [o, p, x, result]}; +} + +noInline(foo); + +// Warm up foo() with polymorphic objects and getters. +for (var i = 0; i < testLoopCount; ++i) { + var o = {}; + o.__defineGetter__("f", function() { + return 107; + }); + if (i & 1) + o["i" + i] = i; // Make it polymorphic. + var result = foo(o); + if (result.outcome !== "return") + throw "Error in loop: bad outcome: " + result.outcome; + if (result.values.length !== 4) + throw "Error in loop: bad number of values: " + result.values.length; + if (result.values[0] !== 104) + throw "Error in loop: bad values[0]: " + result.values[0]; + if (result.values[1] !== 105) + throw "Error in loop: bad values[1]: " + result.values[1]; + if (result.values[2] !== 106) + throw "Error in loop: bad values[2]: " + result.values[2]; + if (result.values[3] !== 107) + throw "Error in loop: bad values[3]: " + result.values[3]; +} + +// Now throw an exception. +var o = {}; +o.__defineGetter__("f", function() { + throw "Error42"; +}); +var result = foo(o, 108); +if (result.outcome !== "exception") + throw "Error at end: bad outcome: " + result.outcome; +if (result.values.length !== 4) + throw "Error at end: bad number of values: " + result.values.length; +if (result.values[0] !== o) + throw "Error at end: bad values[0]: " + result.values[0]; +if (result.values[1] !== 103) + throw "Error at end: bad values[1]: " + result.values[1]; +if (result.values[2] !== 102) + throw "Error at end: bad values[2]: " + result.values[2]; +if (result.values[3] !== 101) + throw "Error at end: bad values[3]: " + result.values[3]; + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-get-by-id-slow-exception.js b/test/js/bun/jsc-stress/fixtures/ftl-get-by-id-slow-exception.js new file mode 100644 index 0000000000..f4b846a384 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-get-by-id-slow-exception.js @@ -0,0 +1,58 @@ +// @bun +function foo(o, p) { + var x = 100; + var result = 101; + try { + x = 102; + p = 103; + result = o.f; + o = 104; + p = 105; + x = 106; + } catch (e) { + return {outcome: "exception", values: [o, p, x, result]}; + } + return {outcome: "return", values: [o, p, x, result]}; +} + +noInline(foo); + +// Warm up foo() with polymorphic objects. +for (var i = 0; i < testLoopCount; ++i) { + var o; + o = {f:107}; + o["i" + i] = i; // Make it polymorphic. + var result = foo(o); + if (result.outcome !== "return") + throw "Error in loop: bad outcome: " + result.outcome; + if (result.values.length !== 4) + throw "Error in loop: bad number of values: " + result.values.length; + if (result.values[0] !== 104) + throw "Error in loop: bad values[0]: " + result.values[0]; + if (result.values[1] !== 105) + throw "Error in loop: bad values[1]: " + result.values[1]; + if (result.values[2] !== 106) + throw "Error in loop: bad values[2]: " + result.values[2]; + if (result.values[3] !== 107) + throw "Error in loop: bad values[3]: " + result.values[3]; +} + +// Now throw an exception. +var o = {}; +o.__defineGetter__("f", function() { + throw "Error42"; +}); +var result = foo(o, 108); +if (result.outcome !== "exception") + throw "Error at end: bad outcome: " + result.outcome; +if (result.values.length !== 4) + throw "Error at end: bad number of values: " + result.values.length; +if (result.values[0] !== o) + throw "Error at end: bad values[0]: " + result.values[0]; +if (result.values[1] !== 103) + throw "Error at end: bad values[1]: " + result.values[1]; +if (result.values[2] !== 102) + throw "Error at end: bad values[2]: " + result.values[2]; +if (result.values[3] !== 101) + throw "Error at end: bad values[3]: " + result.values[3]; + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-get-my-argument-by-val-inlined-and-not-inlined.js b/test/js/bun/jsc-stress/fixtures/ftl-get-my-argument-by-val-inlined-and-not-inlined.js new file mode 100644 index 0000000000..21b62ee4e6 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-get-my-argument-by-val-inlined-and-not-inlined.js @@ -0,0 +1,28 @@ +// @bun +function foo(i) { + return arguments[i]; +} + +function bar(i) { + return [arguments[i], foo(i, "one", 2, "three"), arguments[i]]; +} + +noInline(bar); + +function arraycmp(a, b) { + if (a.length != b.length) + return false; + for (var i = 0; i < a.length; ++i) { + if (a[i] != b[i]) + return false; + } + return true; +} + +for (var i = 0; i < testLoopCount; ++i) { + var thingies = [i % 4, "one", 2, "three"]; + var otherThingies = [i % 4, "five", 6, "seven"]; + var result = bar(i % 4, "five", 6, "seven"); + if (!arraycmp(result, [otherThingies[i % 4], thingies[i % 4], otherThingies[i % 4]])) + throw "Error: bad result for i = " + i + ": " + result; +} diff --git a/test/js/bun/jsc-stress/fixtures/ftl-get-my-argument-by-val-inlined.js b/test/js/bun/jsc-stress/fixtures/ftl-get-my-argument-by-val-inlined.js new file mode 100644 index 0000000000..ca185196ea --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-get-my-argument-by-val-inlined.js @@ -0,0 +1,17 @@ +// @bun +function foo(i) { + return arguments[i]; +} + +function bar(i) { + return foo(i, "one", 2, "three"); +} + +noInline(bar); + +for (var i = 0; i < testLoopCount; ++i) { + var thingies = [i % 4, "one", 2, "three"]; + var result = bar(i % 4, "five", 6, "seven"); + if (result != thingies[i % 4]) + throw "Error: bad result for i = " + i + ": " + result; +} diff --git a/test/js/bun/jsc-stress/fixtures/ftl-get-my-argument-by-val.js b/test/js/bun/jsc-stress/fixtures/ftl-get-my-argument-by-val.js new file mode 100644 index 0000000000..e3f44760dc --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-get-my-argument-by-val.js @@ -0,0 +1,13 @@ +// @bun +function foo(i) { + return arguments[i]; +} + +noInline(foo); + +for (var i = 0; i < testLoopCount; ++i) { + var thingies = [i % 4, "one", 2, "three"]; + var result = foo(i % 4, "one", 2, "three"); + if (result != thingies[i % 4]) + throw "Error: bad result for i = " + i + ": " + result; +} diff --git a/test/js/bun/jsc-stress/fixtures/ftl-getmyargumentslength-inline.js b/test/js/bun/jsc-stress/fixtures/ftl-getmyargumentslength-inline.js new file mode 100644 index 0000000000..573d1d551d --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-getmyargumentslength-inline.js @@ -0,0 +1,10 @@ +// @bun +function foo(){ + return arguments.length; +} + +for (var i = 0; i < testLoopCount; ++i) { + var r = foo(11, 12, 13, 18, 19, 20); + if (r != 6) throw "Error: "+r; +} + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-getmyargumentslength.js b/test/js/bun/jsc-stress/fixtures/ftl-getmyargumentslength.js new file mode 100644 index 0000000000..cc64302d6d --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-getmyargumentslength.js @@ -0,0 +1,12 @@ +// @bun +function foo(){ + return arguments.length; +} + +noInline(foo); + +for (var i = 0; i < testLoopCount; ++i) { + var r = foo(11, 12, 13, 18, 19, 20); + if (r != 6) throw "Error: "+r; +} + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-has-a-bad-time.js b/test/js/bun/jsc-stress/fixtures/ftl-has-a-bad-time.js new file mode 100644 index 0000000000..9df5dc02b3 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-has-a-bad-time.js @@ -0,0 +1,19 @@ +// @bun +function foo(p) { + return p ? [42] : null; +} + +noInline(foo); + +// Make sure we think that foo() allocates int arrays. +for (var i = 0; i < 100; ++i) + foo(true); + +// Now have a bad time. +var array = new Array(); +Array.prototype.__defineSetter__("0", function() { }); + +// Finally, get foo() to compile in the FTL. But don't allocate anymore arrays. +for (var i = 0; i < testLoopCount; ++i) + foo(false); + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-in-overflow.js b/test/js/bun/jsc-stress/fixtures/ftl-in-overflow.js new file mode 100644 index 0000000000..c070655a73 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-in-overflow.js @@ -0,0 +1,14 @@ +// @bun +function foo(o) { + return "foo" in o; +} + +noInline(foo); + +for (var i = 0; i < testLoopCount; ++i) { + var o = {}; + o["i" + i] = 42; + o.foo = 43; + foo(o); +} + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-library-inlining-loops.js b/test/js/bun/jsc-stress/fixtures/ftl-library-inlining-loops.js new file mode 100644 index 0000000000..85ade5f4f9 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-library-inlining-loops.js @@ -0,0 +1,29 @@ +// @bun +function foo(){ + var count = 100; + var d = new DataView(new ArrayBuffer(count)); + + for (var i = 0; i < count / 4; i++){ + d.setInt32(i, i); + } + + for (var i = 0; i < count; i++){ + d.setInt8(i, i); + } + var result = 0; + for (var i = 0; i < count; i++){ + result += d.getInt8(i); + } + return result; +} + +noInline(foo); + +var r = 0; +for (var i = 0 ; i < 50000; i++){ + r += foo(); +} + +if (r != 247500000) + throw "Bad result: " + r; + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-library-inlining-random.js b/test/js/bun/jsc-stress/fixtures/ftl-library-inlining-random.js new file mode 100644 index 0000000000..08fce06eb8 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-library-inlining-random.js @@ -0,0 +1,12 @@ +// @bun +function foo(x){ + return Math.random(x); +} + +noInline(foo); + +var x = 0; + +for (var i = 0 ; i < testLoopCount; i++){ + x = foo(i); +} diff --git a/test/js/bun/jsc-stress/fixtures/ftl-library-substring.js b/test/js/bun/jsc-stress/fixtures/ftl-library-substring.js new file mode 100644 index 0000000000..4e5201c676 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-library-substring.js @@ -0,0 +1,16 @@ +// @bun +function foo(i, x){ + return x.substring( 2 , 5); +} + +noInline(foo); + +var x = ""; + +for (var i = 0 ; i < testLoopCount; i++){ + x = foo(i, "lkajsx"); +} + +if (x != "ajs") + throw "Error: bad substring: "+ x; + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-materialize-new-array-buffer.js b/test/js/bun/jsc-stress/fixtures/ftl-materialize-new-array-buffer.js new file mode 100644 index 0000000000..fcefea91bf --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-materialize-new-array-buffer.js @@ -0,0 +1,13 @@ +// @bun +'use strict'; + +const object = {}; + +function opt() { + return Object.keys(object); +} + +for (let i = 0; i < testLoopCount; i++) + opt(); + +const tmp = new Array(); diff --git a/test/js/bun/jsc-stress/fixtures/ftl-negate-zero.js b/test/js/bun/jsc-stress/fixtures/ftl-negate-zero.js new file mode 100644 index 0000000000..9084740d66 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-negate-zero.js @@ -0,0 +1,13 @@ +// @bun +function foo(x) { + return -x; +} + +noInline(foo); + +for (var i = 0; i < testLoopCount; ++i) { + var result = foo(0); + if (1 / result != "-Infinity") + throw "Error: bad result: " + result; +} + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-new-negative-array-size.js b/test/js/bun/jsc-stress/fixtures/ftl-new-negative-array-size.js new file mode 100644 index 0000000000..dce0c0d4de --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-new-negative-array-size.js @@ -0,0 +1,21 @@ +// @bun +function foo(arg) { + try { + return new Array(arg); + } catch (e) { + return "error42"; + } +} + +noInline(foo); + +for (var i = 0; i < testLoopCount; ++i) { + var result = foo(1); + if (result.length != 1) + throw "Error: bad result: " + result; +} + +var result = foo(-1); +if (result != "error42") + throw "Error: bad result at end: " + result; + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-operation-exception.js b/test/js/bun/jsc-stress/fixtures/ftl-operation-exception.js new file mode 100644 index 0000000000..f81fcecfc4 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-operation-exception.js @@ -0,0 +1,63 @@ +// @bun +function foo(o, p) { + var x = 100; + var result = 101; + try { + x = 102; + p = 103; + result = o.f; + o = 104; + p = 105; + x = 106; + } catch (e) { + return {outcome: "exception", values: [o, p, x, result]}; + } + return {outcome: "return", values: [o, p, x, result]}; +} + +noInline(foo); + +// Warm up foo() with polymorphic objects and non-object types. +for (var i = 0; i < testLoopCount; ++i) { + var o; + var isObject = i & 1; + if (isObject) { + o = {f:107}; + o["i" + i] = i; // Make it polymorphic. + } else + o = 42; + var result = foo(o); + if (result.outcome !== "return") + throw "Error in loop: bad outcome: " + result.outcome; + if (result.values.length !== 4) + throw "Error in loop: bad number of values: " + result.values.length; + if (result.values[0] !== 104) + throw "Error in loop: bad values[0]: " + result.values[0]; + if (result.values[1] !== 105) + throw "Error in loop: bad values[1]: " + result.values[1]; + if (result.values[2] !== 106) + throw "Error in loop: bad values[2]: " + result.values[2]; + if (isObject) { + if (result.values[3] !== 107) + throw "Error in loop: bad values[3]: " + result.values[3]; + } else { + if (result.values[3] !== void 0) + throw "Error in loop: bad values[3]: " + result.values[3]; + } +} + +// Now throw an exception. +var result = foo(null, 108); +if (result.outcome !== "exception") + throw "Error at end: bad outcome: " + result.outcome; +if (result.values.length !== 4) + throw "Error at end: bad number of values: " + result.values.length; +if (result.values[0] !== null) + throw "Error at end: bad values[0]: " + result.values[0]; +if (result.values[1] !== 103) + throw "Error at end: bad values[1]: " + result.values[1]; +if (result.values[2] !== 102) + throw "Error at end: bad values[2]: " + result.values[2]; +if (result.values[3] !== 101) + throw "Error at end: bad values[3]: " + result.values[3]; + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-put-by-id-setter-exception.js b/test/js/bun/jsc-stress/fixtures/ftl-put-by-id-setter-exception.js new file mode 100644 index 0000000000..1bd66322c5 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-put-by-id-setter-exception.js @@ -0,0 +1,61 @@ +// @bun +function foo(o, p) { + var x = 100; + var result = 101; + try { + x = 102; + p = 103; + o.f = x + p; + o = 104; + p = 105; + x = 106; + } catch (e) { + return {outcome: "exception", values: [o, p, x]}; + } + return {outcome: "return", values: [o, p, x]}; +} + +noInline(foo); + +// Warm up foo() with polymorphic objects and getters. +for (var i = 0; i < testLoopCount; ++i) { + var o = {}; + o.__defineSetter__("f", function(value) { + this._f = value; + }); + if (i & 1) + o["i" + i] = i; // Make it polymorphic. + var result = foo(o); + if (result.outcome !== "return") + throw "Error in loop: bad outcome: " + result.outcome; + if (result.values.length !== 3) + throw "Error in loop: bad number of values: " + result.values.length; + if (result.values[0] !== 104) + throw "Error in loop: bad values[0]: " + result.values[0]; + if (result.values[1] !== 105) + throw "Error in loop: bad values[1]: " + result.values[1]; + if (result.values[2] !== 106) + throw "Error in loop: bad values[2]: " + result.values[2]; + if (o._f != 102 + 103) + throw "Error in loop: bad value of o._f: " + o._f; +} + +// Now throw an exception. +var o = {}; +o.__defineSetter__("f", function() { + throw "Error42"; +}); +var result = foo(o, 108); +if (result.outcome !== "exception") + throw "Error at end: bad outcome: " + result.outcome; +if (result.values.length !== 3) + throw "Error at end: bad number of values: " + result.values.length; +if (result.values[0] !== o) + throw "Error at end: bad values[0]: " + result.values[0]; +if (result.values[1] !== 103) + throw "Error at end: bad values[1]: " + result.values[1]; +if (result.values[2] !== 102) + throw "Error at end: bad values[2]: " + result.values[2]; +if ("_f" in o) + throw "Error at end: o has _f."; + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-put-by-id-slow-exception.js b/test/js/bun/jsc-stress/fixtures/ftl-put-by-id-slow-exception.js new file mode 100644 index 0000000000..d388615fe4 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-put-by-id-slow-exception.js @@ -0,0 +1,56 @@ +// @bun + function foo(o, p) { + var x = 100; + var result = 101; + try { + x = 102; + p = 103; + o.f = x + p; + o = 104; + p = 105; + x = 106; + } catch (e) { + return {outcome: "exception", values: [o, p, x]}; + } + return {outcome: "return", values: [o, p, x]}; +} + +noInline(foo); + +// Warm up foo() with polymorphic objects and getters. +for (var i = 0; i < testLoopCount; ++i) { + var o = {}; + if (i & 1) + o["i" + i] = i; // Make it polymorphic. + var result = foo(o); + if (result.outcome !== "return") + throw "Error in loop: bad outcome: " + result.outcome; + if (result.values.length !== 3) + throw "Error in loop: bad number of values: " + result.values.length; + if (result.values[0] !== 104) + throw "Error in loop: bad values[0]: " + result.values[0]; + if (result.values[1] !== 105) + throw "Error in loop: bad values[1]: " + result.values[1]; + if (result.values[2] !== 106) + throw "Error in loop: bad values[2]: " + result.values[2]; + if (o.f != 102 + 103) + throw "Error in loop: bad value of o.f: " + o.f; +} + +// Now throw an exception. +var o = {}; +o.__defineSetter__("f", function() { + throw "Error42"; +}); +var result = foo(o, 108); +if (result.outcome !== "exception") + throw "Error at end: bad outcome: " + result.outcome; +if (result.values.length !== 3) + throw "Error at end: bad number of values: " + result.values.length; +if (result.values[0] !== o) + throw "Error at end: bad values[0]: " + result.values[0]; +if (result.values[1] !== 103) + throw "Error at end: bad values[1]: " + result.values[1]; +if (result.values[2] !== 102) + throw "Error at end: bad values[2]: " + result.values[2]; + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-reallocatepropertystorage.js b/test/js/bun/jsc-stress/fixtures/ftl-reallocatepropertystorage.js new file mode 100644 index 0000000000..5876940979 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-reallocatepropertystorage.js @@ -0,0 +1,29 @@ +// @bun +function foo(x){ + x.a0 = 0; + x.a1 = 1; + x.a2 = 2; + x.a3 = 3; + x.a4 = 4; + x.a5 = 5; + x.a6 = 6; + x.a7 = 7; + x.a8 = 8; + x.a9 = 9; + x.a10 = 10; +} + +noInline(foo); + +var c = {}; +for (var i = 0; i < testLoopCount; ++i) { + var b = {}; + foo(b); + c = b; +} + +for (var j = 0; j <= 10 ; ++j) + if (c['a'+j] != j) + throw "Error "+c['a'+j]; + + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-regexp-exec.js b/test/js/bun/jsc-stress/fixtures/ftl-regexp-exec.js new file mode 100644 index 0000000000..1a43eb2192 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-regexp-exec.js @@ -0,0 +1,18 @@ +// @bun +function foo(s) { + return /foo/.exec(s); +} + +noInline(foo); + +for (var i = 0; i < testLoopCount; ++i) { + var result = foo("foo"); + if (!result) + throw "Error: bad result for foo"; + if (result.length != 1) + throw "Error: bad result for foo: " + result; + if (result[0] != "foo") + throw "Error: bad result for foo: " + result; + if (foo("bar")) + throw "Error: bad result for bar"; +} diff --git a/test/js/bun/jsc-stress/fixtures/ftl-regexp-test.js b/test/js/bun/jsc-stress/fixtures/ftl-regexp-test.js new file mode 100644 index 0000000000..7746cd7d98 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-regexp-test.js @@ -0,0 +1,13 @@ +// @bun +function foo(s) { + return /foo/.test(s); +} + +noInline(foo); + +for (var i = 0; i < testLoopCount; ++i) { + if (!foo("foo")) + throw "Error: bad result for foo"; + if (foo("bar")) + throw "Error: bad result for bar"; +} diff --git a/test/js/bun/jsc-stress/fixtures/ftl-shr-exception.js b/test/js/bun/jsc-stress/fixtures/ftl-shr-exception.js new file mode 100644 index 0000000000..80f693cda9 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-shr-exception.js @@ -0,0 +1,20 @@ +// @bun +function foo(a, b) { + try { + return a >> b; + } catch (e) { + return e; + } +} + +noInline(foo); + +for (var i = 0; i < testLoopCount; ++i) { + var result = foo((i & 1) ? 32 : "32", 2); + if (result !== 8) + throw "Error: bad result: " + result; +} + +var result = foo({valueOf: function() { throw "error42"; }}, 2); +if (result !== "error42") + throw "Error: bad result at end: " + result; diff --git a/test/js/bun/jsc-stress/fixtures/ftl-string-equality.js b/test/js/bun/jsc-stress/fixtures/ftl-string-equality.js new file mode 100644 index 0000000000..8c29dd0caf --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-string-equality.js @@ -0,0 +1,36 @@ +// @bun +function makeString(char) { + var result = ""; + for (var i = 0; i < 10; ++i) + result += char; + return result; +} + +var array = [ "a", "b", "c", "d" ]; + +for (var i = 0; i < array.length; ++i) + array[i] = makeString(array[i]); + +function foo(array, s) { + for (var i = 0; i < array.length; ++i) { + if (array[i] == s) + return i; + } + return null; +} + +noInline(foo); + +var array2 = [ "a", "b", "c", "d", "e" ]; + +for (var i = 0; i < array2.length; ++i) + array2[i] = makeString(array2[i]); + +for (var i = 0; i < testLoopCount; ++i) { + var index = i % array2.length; + var result = foo(array, array2[index]); + var expected = index >= array.length ? null : index + if (result !== expected) + throw "Error: bad result: " + result; +} + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-string-ident-equality.js b/test/js/bun/jsc-stress/fixtures/ftl-string-ident-equality.js new file mode 100644 index 0000000000..4dc831bbb4 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-string-ident-equality.js @@ -0,0 +1,19 @@ +// @bun +var array = [ "a", "b", "c", "d" ]; + +function foo(array, s) { + for (var i = 0; i < array.length; ++i) { + if (array[i] == s) + return true; + } + return false; +} + +noInline(foo); + +var result = 0; +for (var i = 0; i < testLoopCount; ++i) + result += foo(array, "d"); + +if (result != testLoopCount) + throw "Bad result: " + result; diff --git a/test/js/bun/jsc-stress/fixtures/ftl-string-strict-equality.js b/test/js/bun/jsc-stress/fixtures/ftl-string-strict-equality.js new file mode 100644 index 0000000000..d95188cfcc --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-string-strict-equality.js @@ -0,0 +1,36 @@ +// @bun +function makeString(char) { + var result = ""; + for (var i = 0; i < 10; ++i) + result += char; + return result; +} + +var array = [ "a", "b", "c", "d" ]; + +for (var i = 0; i < array.length; ++i) + array[i] = makeString(array[i]); + +function foo(array, s) { + for (var i = 0; i < array.length; ++i) { + if (array[i] === s) + return i; + } + return null; +} + +noInline(foo); + +var array2 = [ "a", "b", "c", "d", "e" ]; + +for (var i = 0; i < array2.length; ++i) + array2[i] = makeString(array2[i]); + +for (var i = 0; i < testLoopCount; ++i) { + var index = i % array2.length; + var result = foo(array, array2[index]); + var expected = index >= array.length ? null : index + if (result !== expected) + throw "Error: bad result: " + result + " but expected " + expected; +} + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-sub-exception.js b/test/js/bun/jsc-stress/fixtures/ftl-sub-exception.js new file mode 100644 index 0000000000..db326cf12b --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-sub-exception.js @@ -0,0 +1,20 @@ +// @bun +function foo(a, b) { + try { + return a - b; + } catch (e) { + return e; + } +} + +noInline(foo); + +for (var i = 0; i < testLoopCount; ++i) { + var result = foo((i & 1) ? 32 : "32", 10); + if (result !== 22) + throw "Error: bad result: " + result; +} + +var result = foo({valueOf: function() { throw "error42"; }}, 10); +if (result !== "error42") + throw "Error: bad result at end: " + result; diff --git a/test/js/bun/jsc-stress/fixtures/ftl-tail-call.js b/test/js/bun/jsc-stress/fixtures/ftl-tail-call.js new file mode 100644 index 0000000000..6ba1eebb10 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-tail-call.js @@ -0,0 +1,21 @@ +// @bun +"use strict"; + +function foo(a, b, c) { + return a + b * 2 + c * 3; +} + +noInline(foo); + +function bar(a, b, c) { + return foo(a.f, b.g, c.h); +} + +noInline(bar); + +for (var i = 0; i < testLoopCount; ++i) { + var result = bar({f: 4}, {g: 5}, {h: 6}); + if (result != 4 + 5 * 2 + 6 * 3) + throw "Error: bad result: " + result; +} + diff --git a/test/js/bun/jsc-stress/fixtures/ftl-try-catch-arith-sub-exception.js b/test/js/bun/jsc-stress/fixtures/ftl-try-catch-arith-sub-exception.js new file mode 100644 index 0000000000..ef5a4cf0d5 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-try-catch-arith-sub-exception.js @@ -0,0 +1,60 @@ +// @bun +function assert(b) { + if (!b) + throw new Error("uh oh"); +} + +let flag = false; +let o = { + valueOf() { + if (flag) + throw new Error("by by"); + return 13.5; + } +}; +noInline(o.valueOf); + +function baz() { return 1.5; } +noInline(baz); + +function foo(x, o) { + let r = baz(); + try { + r = x - o - r; + } catch(e) { } + return r; +} +noInline(foo); + +let x = 20.5; +for (let i = 0; i < testLoopCount; i++) { + assert(foo(x, o) === 5.5); +} +flag = true; +assert(foo(x, o) === 1.5); + + +function bar(x, o) { + let caughtException = false; + var r = null; + try { + // This tests aliasing of left/right with result register in a SubGenerator + // and ensures that the sub will spill the register properly and that we value + // recover properly. + r = x - o; + } catch(e) { + caughtException = true; + assert(r === null); + } + if (!caughtException) + assert(r === 7); + return caughtException; +} +noInline(bar); + +flag = false; +for (let i = 0; i < testLoopCount; i++) { + assert(bar(x, o) === false); +} +flag = true; +assert(bar(x, o) === true); diff --git a/test/js/bun/jsc-stress/fixtures/ftl-try-catch-getter-throw-interesting-value-recovery.js b/test/js/bun/jsc-stress/fixtures/ftl-try-catch-getter-throw-interesting-value-recovery.js new file mode 100644 index 0000000000..286590be06 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-try-catch-getter-throw-interesting-value-recovery.js @@ -0,0 +1,66 @@ +// @bun +function assert(b) { + if (!b) + throw new Error("bad value") +} +noInline(assert); + +function random() { + return "blah"; +} +noInline(random); + +function identity(x) { + return x; +} +noInline(identity); + +let o1 = { + g: 20, + y: 40, + f: "get f" +}; + +let o2 = { + g: "g", + y: "y", + get f() { + return "get f"; + } +} + +let o4 = {}; + +let o3 = { + get f() { + throw new Error("blah"); + } +} + +function foo(o, a) { + let x = o.g; + let y = o.y; + let oo = identity(o); + let j = random(); + try { + j = o.f; + } catch(e) { + assert(j === "blah"); + assert(oo === o3); + return x + y + 1; + } + return x + y; +} + +noInline(foo); +for (let i = 0; i < testLoopCount; i++) { + if (i % 3 == 0) { + assert(foo(o1) === 60); + } else if (i % 3 === 1) { + assert(foo(o2) === "gy"); + } else { + foo(o4); + } +} + +foo(o3); diff --git a/test/js/bun/jsc-stress/fixtures/ftl-try-catch-getter-throw.js b/test/js/bun/jsc-stress/fixtures/ftl-try-catch-getter-throw.js new file mode 100644 index 0000000000..091060cb0f --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-try-catch-getter-throw.js @@ -0,0 +1,58 @@ +// @bun +function assert(b) { + if (!b) + throw new Error("bad value") +} +noInline(assert); + +function random() { + return "blah"; +} +noInline(random); + +function foo(o, a) { + let x = o.g; + let y = o.y; + let j = random(); + try { + j = o.f; + } catch(e) { + assert(j === "blah"); + return x + y + 1; + } + return x + y; +} + +noInline(foo); +var flag = false; +function f(arg1, arg2, arg3) { + if (flag) + throw new Error("blah") + return arg1; +} +noInline(f); +let o1 = { + g: 20, + y: 40, + f: "get f" +}; + +let o2 = { + g: "g", + y: "y", + get f() { + if (flag) + throw new Error("blah"); + return "get f"; + } +} + +for (let i = 0; i < testLoopCount; i++) { + if (i % 2) { + assert(foo(o1) === 60); + } else { + assert(foo(o2) === "gy"); + } +} +flag = true; +assert(foo(o2) === "gy1"); diff --git a/test/js/bun/jsc-stress/fixtures/ftl-try-catch-patchpoint-with-volatile-registers.js b/test/js/bun/jsc-stress/fixtures/ftl-try-catch-patchpoint-with-volatile-registers.js new file mode 100644 index 0000000000..986392e4d0 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-try-catch-patchpoint-with-volatile-registers.js @@ -0,0 +1,74 @@ +// @bun +function assert(b) { + if (!b) + throw new Error("Bad value.") +} +noInline(assert); + +var v1 = 100; +var v2 = 200; +var flag = false; +var o1 = { + get f() { + if (flag) + throw new Error("gotcha!"); + return v1; + } +} + +function a() { return "a"; } +noInline(a); +function b() { return "b"; } +noInline(b); +function c() { return "c"; } +noInline(c); +function d() { return "d"; } +noInline(d); +function e() { return "e"; } +noInline(e); +function f() { return "f"; } +noInline(f); +function g() { return "g"; } +noInline(g); + +var o2 = { + get f() { + assert(true); + assert(true); + assert(true); + assert(true); + assert(true); + assert(true); + assert(true); + return v2; + } +} + +function foo(o) { + try { + var _a = a(); + var _b = b(); + var _c = c(); + var _d = d(); + var _e = e(); + var _f = f(); + var _g = g(); + + o = o.f; + + } catch(e) { + assert(o === o1); + assert(_b === "b"); + assert(_c === "c"); + assert(_d === "d"); + assert(_e === "e"); + assert(_f === "f"); + assert(_g === "g"); + } +} +noInline(foo); + +for (var i = 0; i < testLoopCount; i++) + foo(i % 2 ? o1 : o2); +flag = true; +foo(o1); diff --git a/test/js/bun/jsc-stress/fixtures/ftl-try-catch-setter-throw.js b/test/js/bun/jsc-stress/fixtures/ftl-try-catch-setter-throw.js new file mode 100644 index 0000000000..82bedc5104 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-try-catch-setter-throw.js @@ -0,0 +1,47 @@ +// @bun +function foo(o, a) { + let x = o.g; + let y = o.y; + try { + o.f = 20; + } catch(e) { + return x + y + 1; + } + return x + y; +} + +function assert(b) { + if (!b) + throw new Error("bad value") +} +noInline(assert); + +noInline(foo); +var flag = false; +function f(arg1, arg2, arg3) { + if (flag) + throw new Error("blah") + return arg1; +} +noInline(f); +let o1 = { + g: 20, + y: 40, + f: null +}; + +let o2 = { + g: "g", + y: "y", + set f(v) { if (flag) throw new Error("blah"); } +} + +for (let i = 0; i < testLoopCount; i++) { + if (i % 2) { + assert(foo(o1) === 60); + } else { + assert(foo(o2) === "gy"); + } +} +flag = true; +assert(foo(o2) === "gy1"); diff --git a/test/js/bun/jsc-stress/fixtures/ftl-try-catch-varargs-call-throws.js b/test/js/bun/jsc-stress/fixtures/ftl-try-catch-varargs-call-throws.js new file mode 100644 index 0000000000..38d15648fa --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-try-catch-varargs-call-throws.js @@ -0,0 +1,33 @@ +// @bun +function foo(o, a) { + let resetFlag = false; + if (flag) { + resetFlag = true; + flag = false; + } + let x = o(10); + let y = o(20); + if (resetFlag) + flag = true; + try { + o.apply(null, a); + } catch(e) { + if (x !== 10) + throw new Error("Not 10") + return x + y; + } +} +noInline(foo); +var flag = false; +function f(arg1, arg2, arg3) { + if (flag) + throw new Error("blah") + return arg1; +} +noInline(f); + +for (let i = 0; i < testLoopCount; i++) { + foo(f, [10, 20, 30]); +} +flag = true; +foo(f, [10, 20, 30]); diff --git a/test/js/bun/jsc-stress/fixtures/ftl-xor-exception.js b/test/js/bun/jsc-stress/fixtures/ftl-xor-exception.js new file mode 100644 index 0000000000..77ae8c5e77 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/ftl-xor-exception.js @@ -0,0 +1,20 @@ +// @bun +function foo(a, b) { + try { + return a ^ b; + } catch (e) { + return e; + } +} + +noInline(foo); + +for (var i = 0; i < testLoopCount; ++i) { + var result = foo((i & 1) ? 32 : "32", 10); + if (result !== 42) + throw "Error: bad result: " + result; +} + +var result = foo({valueOf: function() { throw "error42"; }}, 10); +if (result !== "error42") + throw "Error: bad result at end: " + result; diff --git a/test/js/bun/jsc-stress/fixtures/licm-no-pre-header.js b/test/js/bun/jsc-stress/fixtures/licm-no-pre-header.js new file mode 100644 index 0000000000..40fa15c8e3 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/licm-no-pre-header.js @@ -0,0 +1,18 @@ +// @bun +//@ runFTLNoCJIT("--createPreHeaders=false") + +function foo(array) { + var result = 0; + var i = 0; + if (!array.length) + array = [1]; + do { + result += array[i++]; + } while (i < array.length) + return result; +} + +noInline(foo); + +for (var i = 0; i < testLoopCount; ++i) + foo([1, 2, 3]); diff --git a/test/js/bun/jsc-stress/fixtures/loop-unrolling.js b/test/js/bun/jsc-stress/fixtures/loop-unrolling.js new file mode 100644 index 0000000000..f450770e7b --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/loop-unrolling.js @@ -0,0 +1,93 @@ +// @bun +function assert(actual, expected) { + for (let i = 0; i < actual.length; i++) { + if (actual[i] != expected[i]) + throw new Error("bad actual=" + actual[i] + " but expected=" + expected[i]); + } +} + +function func1(a) { + for (let i = 0; i < 4; i++) { + a[i] = 1; + } + return a; +} +noInline(func1); + +function func2(a) { + for (let i = 0; i < 4; i++) { + a[i] = 1; + for (let i = 0; i < 4; i++) { + a[i] = 1; + } + } + return a; +} +noInline(func2); + +function func3(a) { + for (let i = 0; i < 4; i++) { + if (i % 2 == 0) + a[i] = 1; + else + a[i] = 2; + } + return a; +} +noInline(func3); + +function func4(s) { + let len = 4; + var a = new Array(len); + for (var i = 0; i < len; i++) { + a[i] = s[i]; + } + s[0] = a[0] ^ a[1]; + return s; +} +noInline(func4); + +function func5(a) { + for (let i = 0; i < 4;) { + a[i] = 1; + if (i > -1) + i += 1; + } + return a; +} +noInline(func5); + +function func6(a) { + for (let i = 3; i > 1; i /= 2) { + a[i] = 1; + } + return a; +} +noInline(func6); + +function func7(a) { + for (let i = 3; i < 4; i /= 0) { + a[i] = 1; + } + return a; +} +noInline(func7); + +function test(func) { + let expected; + for (let i = 0; i < testLoopCount; i++) { + let a = [0, 0, 0, 0]; + let res = func(a); + if (i == 0) + expected = res; + assert(res, expected); + } +} + +test(func1); +test(func2); +test(func3); +test(func4); +test(func5); +test(func6); +test(func7); diff --git a/test/js/bun/jsc-stress/fixtures/varargs-inlined-simple-exit.js b/test/js/bun/jsc-stress/fixtures/varargs-inlined-simple-exit.js new file mode 100644 index 0000000000..44fcfedcee --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/varargs-inlined-simple-exit.js @@ -0,0 +1,29 @@ +// @bun +function foo(a, b) { + return a + b; +} + +var global; +function bar() { + var a = arguments; + var tmp = global + 1; + return tmp + foo.apply(null, a); +} + +function baz(a, b) { + return bar(a, b); +} + +noInline(baz); + +for (var i = 0; i < testLoopCount; ++i) { + global = i; + var result = baz(1, 2); + if (result != i + 1 + 1 + 2) + throw "Error: bad result: " + result; +} + +global = 1.5; +var result = baz(1, 2); +if (result != 1.5 + 1 + 1 + 2) + throw "Error: bad result at end: " + result; diff --git a/test/js/bun/jsc-stress/fixtures/wasm/bbq-fusedif-register-alloc.js b/test/js/bun/jsc-stress/fixtures/wasm/bbq-fusedif-register-alloc.js new file mode 100644 index 0000000000..0371403691 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/bbq-fusedif-register-alloc.js @@ -0,0 +1,186 @@ +// @bun +//@ runDefaultWasm("--useDollarVM=1", "--jitPolicyScale=0.1") +function instantiate(moduleBase64, importObject) { + let bytes = Uint8Array.fromBase64(moduleBase64); + return WebAssembly.instantiate(bytes, importObject); + } + const log = function (msg) { }; + const report = $.agent.report; + const isJIT = callerIsBBQOrOMGCompiled; +const extra = {isJIT}; +(async function () { +let memory0 = new WebAssembly.Memory({initial: 3782, shared: true, maximum: 4702}); +/** +@param {I32} a0 +@param {FuncRef} a1 +@param {ExternRef} a2 +@returns {[I32, FuncRef, ExternRef]} + */ +let fn0 = function (a0, a1, a2) { +a0?.toString(); a1?.toString(); a2?.toString(); +return [13, a1, a2]; +}; +/** +@returns {void} + */ +let fn1 = function () { +}; +/** +@returns {void} + */ +let fn2 = function () { +}; +/** +@param {FuncRef} a0 +@param {ExternRef} a1 +@returns {[FuncRef, ExternRef]} + */ +let fn3 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [a0, a1]; +}; +/** +@returns {void} + */ +let fn4 = function () { +}; +/** +@returns {void} + */ +let fn5 = function () { +}; +/** +@param {FuncRef} a0 +@param {ExternRef} a1 +@returns {[FuncRef, ExternRef]} + */ +let fn6 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [a0, a1]; +}; +/** +@param {FuncRef} a0 +@param {ExternRef} a1 +@returns {void} + */ +let fn7 = function (a0, a1) { +a0?.toString(); a1?.toString(); +}; +/** +@returns {void} + */ +let fn8 = function () { +}; +let tag2 = new WebAssembly.Tag({parameters: ['anyfunc', 'externref']}); +let tag3 = new WebAssembly.Tag({parameters: []}); +let global0 = new WebAssembly.Global({value: 'i32', mutable: true}, 295824777); +let global1 = new WebAssembly.Global({value: 'i64', mutable: true}, 451227669n); +let global2 = new WebAssembly.Global({value: 'f64', mutable: true}, 43550.49195598054); +let global4 = new WebAssembly.Global({value: 'anyfunc', mutable: true}, null); +let global6 = new WebAssembly.Global({value: 'i32', mutable: true}, 2736504614); +let m1 = {fn0, fn6, fn8, global0, global6, memory0, tag6: tag3}; +let m2 = {fn1, fn2, fn3, fn5, global1, global5: global0, global7: new WebAssembly.Global({value: 'externref', mutable: false}, {}), tag2, tag3, tag4: tag3, tag5: tag3}; +let m0 = {fn4, fn7, global2, global3: new WebAssembly.Global({value: 'externref', mutable: false}, {}), global4}; +let importObject0 = /** @type {Imports2} */ ({extra, m0, m1, m2}); +let i0 = await instantiate('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', importObject0); +let {fn9, fn10, global8, global9, global10, global11, memory1, table0, table1, tag0, tag1} = /** + @type {{ +fn9: (a0: I32, a1: FuncRef, a2: ExternRef) => [I32, FuncRef, ExternRef], +fn10: (a0: FuncRef, a1: ExternRef) => [FuncRef, ExternRef], +global8: WebAssembly.Global, +global9: WebAssembly.Global, +global10: WebAssembly.Global, +global11: WebAssembly.Global, +memory1: WebAssembly.Memory, +table0: WebAssembly.Table, +table1: WebAssembly.Table, +tag0: WebAssembly.Tag, +tag1: WebAssembly.Tag + }} */ (i0.instance.exports); +table0.set(37, table0); +table0.set(22, table0); +table0.set(23, table0); +table0.set(25, table0); +table0.set(15, table0); +table0.set(3, table0); +table0.set(51, table0); +log('calling fn9'); +report('progress'); +try { + for (let k=0; k<10; k++) { + let zzz = fn9(global6.value, fn10, {}); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn10'); +report('progress'); +try { + for (let k=0; k<25; k++) { + let zzz = fn10(fn9, {}); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn10'); +report('progress'); +try { + for (let k=0; k<10; k++) { + let zzz = fn10(fn9, {}); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn9'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn9(global6.value, fn10, {}); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +let tables = [table0, table1]; +for (let table of tables) { +for (let k=0; k < table.length; k++) { table.get(k)?.toString(); } +} +})().then(() => { + log('after') + report('after'); +}).catch(e => { + log(e) + log('error') + report('error'); +}) diff --git a/test/js/bun/jsc-stress/fixtures/wasm/bbq-osr-with-exceptions.js b/test/js/bun/jsc-stress/fixtures/wasm/bbq-osr-with-exceptions.js new file mode 100644 index 0000000000..cff5b67eef --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/bbq-osr-with-exceptions.js @@ -0,0 +1,37 @@ +// @bun +//@ runDefaultWasm("--useDollarVM=1", "--jitPolicyScale=0.1") +function instantiate(moduleBase64, importObject) { + var bytes = Uint8Array.fromBase64(moduleBase64); + return WebAssembly.instantiate(bytes, importObject); +} +var isJIT = callerIsBBQOrOMGCompiled; +const extra = { isJIT }; +(async function () { + let memory0 = new WebAssembly.Memory({ initial: 563, shared: true, maximum: 969 }); + /** + */ + let fn0 = function () {}; + let tag1 = new WebAssembly.Tag({ parameters: [] }); + let tag2 = new WebAssembly.Tag({ parameters: ["externref", "i64", "anyfunc"] }); + let tag4 = new WebAssembly.Tag({ parameters: ["externref", "i64", "anyfunc"] }); + let global0 = new WebAssembly.Global({ value: "f64", mutable: true }, 213370.7581944168); + let global1 = new WebAssembly.Global({ value: "externref", mutable: true }, {}); + let global3 = new WebAssembly.Global({ value: "i32", mutable: true }, 925192733); + let m2 = { memory0, tag2, tag3: tag1 }; + let m1 = { fn0, global1, global2: global1, global3, global5: 5, tag1, tag4, tag6: tag1 }; + let m0 = { global0, global4: 23, tag5: tag1, tag7: tag4 }; + let importObject0 = /** */ { extra, m0, m1, m2 }; + let i0 = await instantiate( + "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", + importObject0, + ); + let { fn1, fn2, fn3, global7, global9, global11, tag0 } = i0.instance.exports; + try { + for (let k = 0; k < 14; k++) { + let r = fn2(global1.value, global11.value, fn3); + } + } catch (e) { + if (e instanceof RangeError) { + } + } +})().then(() => {}); diff --git a/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-check-try-implicit-slot-overlap.js b/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-check-try-implicit-slot-overlap.js new file mode 100644 index 0000000000..3103d23f7d --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-check-try-implicit-slot-overlap.js @@ -0,0 +1,141 @@ +// @bun +function instantiate(moduleBase64, importObject) { + let bytes = Uint8Array.fromBase64(moduleBase64); + return WebAssembly.instantiate(bytes, importObject); + } + const report = $.agent.report; + const isJIT = callerIsBBQOrOMGCompiled; +const extra = {isJIT}; +(async function () { +let memory0 = new WebAssembly.Memory({initial: 1850, shared: true, maximum: 2731}); +/** +@param {I32} a0 +@param {F32} a1 +@returns {void} + */ +let fn0 = function (a0, a1) { +a0?.toString(); a1?.toString(); +}; +/** +@returns {void} + */ +let fn1 = function () { +}; +/** +@param {I32} a0 +@param {F32} a1 +@returns {[I32, F32]} + */ +let fn2 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [36, 8.433544074882645e1]; +}; +/** +@param {I32} a0 +@param {FuncRef} a1 +@returns {void} + */ +let fn3 = function (a0, a1) { +a0?.toString(); a1?.toString(); +}; +let tag5 = new WebAssembly.Tag({parameters: []}); +let tag6 = new WebAssembly.Tag({parameters: ['i32', 'f32']}); +let tag9 = new WebAssembly.Tag({parameters: []}); +let global0 = new WebAssembly.Global({value: 'i32', mutable: true}, 3721432472); +let global1 = new WebAssembly.Global({value: 'f64', mutable: true}, 548636.1280581957); +let global3 = new WebAssembly.Global({value: 'f32', mutable: true}, 52810.0658290932); +let global4 = new WebAssembly.Global({value: 'i64', mutable: true}, 1872919390n); +let global7 = new WebAssembly.Global({value: 'anyfunc', mutable: true}, null); +let global8 = new WebAssembly.Global({value: 'externref', mutable: true}, {}); +let table0 = new WebAssembly.Table({initial: 48, element: 'externref', maximum: 347}); +let table1 = new WebAssembly.Table({initial: 37, element: 'anyfunc'}); +let table2 = new WebAssembly.Table({initial: 51, element: 'externref', maximum: 276}); +let table3 = new WebAssembly.Table({initial: 77, element: 'externref'}); +let m2 = {fn3, global0, global2: global0, global7, memory0, tag5, tag6, tag9}; +let m1 = {fn0, fn1, fn2, global1, global6: global3, global8, table0, table1, table3, tag8: tag5, tag12: tag9}; +let m0 = {global3, global4, global5: global4, table2, table4: table3, tag7: tag5, tag10: tag9, tag11: tag6}; +let importObject0 = /** @type {Imports2} */ ({extra, m0, m1, m2}); +/* + (func (;5;) (param ) (result ) + (local i32 i32) + loop ;; label = @1 + local.get 1 + i32.const 1 + i32.add + local.tee 1 + i32.const 43 + i32.lt_u + br_if 0 (;@1;) + ;; BEGIN IMPORTANT + i32.const 1 + i32.const 6 + table.get 1 + ;; BEGIN VERY IMPORTANT + loop (param i32 funcref) (result i32 funcref) ;; label = @3 + try (param i32 funcref) (result i32 funcref) ;; label = @4 + local.get 0 + i32.const 1 + i32.add + local.tee 0 + i32.const 36 + i32.lt_u + if (param i32 funcref) (result i32 funcref) ;; label = @5 + br 2 (;@3;) + end + end + end + ;; END VERY IMPORTANT + table.set 1 + ;; END IMPORTANT + end + ) + (func (;6;) (type 18) (param i32 f32) + call 5 + return) + +*/ +let i0 = await instantiate( +'AGFzbQEAAAABgAETYAABf2ACf3AJcH1/cHt9f3t9YAJ/cAJ/cGACf3AAYANvcHsAYANvcHsDb3B7YANvcHsAYAN7fn8De317YAN7fn8De35/YAN7fn8AYANwfnsDfXB/YANwfnsDcH57YANwfnsAYAAAYAAAYAAAYAJ/fQJ7f2ACf30Cf31gAn99AALnAhwCbTIHbWVtb3J5MAIDug6rFQJtMQNmbjAAEgJtMQNmbjEADQJtMQNmbjIAEQJtMgNmbjMAAwVleHRyYQVpc0pJVAAAAm0yBHRhZzUEAA4CbTIEdGFnNgQAEgJtMAR0YWc3BAAPAm0xBHRhZzgEAA0CbTIEdGFnOQQADgJtMAV0YWcxMAQADwJtMAV0YWcxMQQAEgJtMQV0YWcxMgQADwJtMgdnbG9iYWwwA38BAm0xB2dsb2JhbDEDfAECbTIHZ2xvYmFsMgN/AQJtMAdnbG9iYWwzA30BAm0wB2dsb2JhbDQDfgECbTAHZ2xvYmFsNQN+AQJtMQdnbG9iYWw2A30BAm0yB2dsb2JhbDcDcAECbTEHZ2xvYmFsOANvAQJtMQZ0YWJsZTABbwEw2wICbTEGdGFibGUxAXAAJQJtMAZ0YWJsZTIBbwEzlAICbTEGdGFibGUzAW8ATQJtMAZ0YWJsZTQBbwA7AwMCDRIEFgVvAFhvARTTBm8BE6kGcABObwFNygYNFwsADwAOAAYADQAOAAwADQAJAA0ABgANBl4KfQFDC0JCjAt8AUTD6W+dAQahrQt+AULEAAt/AUHfAAt8AESAU9orGbwSsgt/AUEBC30BQ0MnTH8LfgFC7ZHWnwwLfwFBxwALewH9DIFrswgU3AOrzNvkUWHqRLwLB74BFQR0YWczBAcIZ2xvYmFsMTYDEgR0YWcwBAIDZm41AAYEdGFnMgQGBnRhYmxlOAEIBnRhYmxlNwEHB21lbW9yeTECAAhnbG9iYWwxNQMRBHRhZzEEBQNmbjQABQhnbG9iYWwxMQMKBHRhZzQECghnbG9iYWwxMAMJBnRhYmxlNgEGCGdsb2JhbDE0AxAGdGFibGU5AQkHZ2xvYmFsOQMACGdsb2JhbDEzAwwGdGFibGU1AQUIZ2xvYmFsMTIDCwnyAQkDAE4BBQEDAgUCAwAFAwEGBAQDAwIGBgEAAwADAQEFBAEBBQYFBgUBAwYEAgQABgACBQYFBAYEAAIBBQYGBQIFAgYGAQADBgAFAgEGAQUGBQUBAFQAAwUCAQIFBgYAAgAABQYEBAMDAgADAgEABgEBBAIAAQQCAAQGAQAFAQICAwUEAAYBAgAEAAYFBAYDAwUABgUGBgEAAQEAAAMFBAQBAgYGAwMGBgMCAUEUCwARAwIFAwYABQIAAwIGAwYCBQUCAUEeCwACAAYCCEEMCwABAQIIQSILAAECAghBEgsAAQMCCEELCwABBAIBQQELAAEFCjgCMAECfwNAIAFBAWoiAUErSQ0AQQFBBiUBAwIGAiAAQQFqIgBBJEkEAgwCCwsLJgELCwUAEAUPCwsZAwEHnzQg5BrOxgBBiscACwSuJgPYAQKQxA==' + , importObject0); +let {fn4, fn5, global9, global10, global11, global12, global13, global14, global15, global16, memory1, table5, table6, table7, table8, table9, tag0, tag1, tag2, tag3, tag4} = /** + @type {{ +fn4: (a0: FuncRef, a1: I64, a2: V128) => [FuncRef, I64, V128], +fn5: (a0: I32, a1: F32) => void, +global9: WebAssembly.Global, +global10: WebAssembly.Global, +global11: WebAssembly.Global, +global12: WebAssembly.Global, +global13: WebAssembly.Global, +global14: WebAssembly.Global, +global15: WebAssembly.Global, +global16: WebAssembly.Global, +memory1: WebAssembly.Memory, +table5: WebAssembly.Table, +table6: WebAssembly.Table, +table7: WebAssembly.Table, +table8: WebAssembly.Table, +table9: WebAssembly.Table, +tag0: WebAssembly.Tag, +tag1: WebAssembly.Tag, +tag2: WebAssembly.Tag, +tag3: WebAssembly.Tag, +tag4: WebAssembly.Tag + }} */ (i0.instance.exports); +report('progress'); +try { + for (let k=0; k<27; k++) { + let zzz = fn5(global9.value, global3.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +})().then(() => { + report('after'); +}).catch(e => { + report('error'); +}) + diff --git a/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-check-try-implicit-slot-overlap2.js b/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-check-try-implicit-slot-overlap2.js new file mode 100644 index 0000000000..841ce91a31 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-check-try-implicit-slot-overlap2.js @@ -0,0 +1,128 @@ +// @bun +function instantiate(moduleBase64, importObject) { + let bytes = Uint8Array.fromBase64(moduleBase64); + return WebAssembly.instantiate(bytes, importObject); + } + const report = $.agent.report; + const isJIT = callerIsBBQOrOMGCompiled; +const extra = {isJIT}; +(async function () { +/** +@param {F32} a0 +@returns {[F32, FuncRef, FuncRef, FuncRef, I32, FuncRef, ExternRef, I64, FuncRef]} + */ +let fn0 = function (a0) { +a0?.toString(); +return [0.2697611813864502e-3, null, null, null, 46, null, {f:42}, -16n, null]; +}; +/** +@param {F32} a0 +@returns {[F32, FuncRef, FuncRef, FuncRef, I32, FuncRef, ExternRef, I64, FuncRef]} + */ +let fn1 = function (a0) { +a0?.toString(); +return [7.596667970342176e-20, null, null, null, -3, null, {f:42}, 161n, null]; +}; +/** +@param {F32} a0 +@returns {F32} + */ +let fn2 = function (a0) { +a0?.toString(); +return 8.396890054479867e41; +}; +/** +@param {F32} a0 +@returns {void} + */ +let fn3 = function (a0) { +a0?.toString(); +}; +/** +@param {F32} a0 +@returns {[F32, FuncRef, FuncRef, FuncRef, I32, FuncRef, ExternRef, I64, FuncRef]} + */ +let fn4 = function (a0) { +a0?.toString(); +return [6.847558592395531e-29, null, null, null, 82, null, {f:42}, 1199n, null]; +}; +/** +@param {F32} a0 +@returns {[F32, FuncRef, FuncRef, FuncRef, I32, FuncRef, ExternRef, I64, FuncRef]} + */ +let fn5 = function (a0) { +a0?.toString(); +return [2.6183507069067624e42, null, null, null, 42, null, {f:42}, 454n, null]; +}; +let tag6 = new WebAssembly.Tag({parameters: ['f32']}); +let global0 = new WebAssembly.Global({value: 'i32', mutable: true}, 2448256965); +let global1 = new WebAssembly.Global({value: 'f32', mutable: true}, 250514.00700778005); +let table0 = new WebAssembly.Table({initial: 27, element: 'anyfunc'}); +let table1 = new WebAssembly.Table({initial: 88, element: 'anyfunc'}); +let table3 = new WebAssembly.Table({initial: 16, element: 'externref'}); +let table5 = new WebAssembly.Table({initial: 91, element: 'anyfunc', maximum: 313}); +let table8 = new WebAssembly.Table({initial: 11, element: 'anyfunc', maximum: 191}); +let m0 = {fn0, global1, table7: table1}; +let m1 = {fn1, fn3, fn4, global0, table0, table1, table2: table0, table3, table4: table0, tag6}; +let m2 = {fn2, fn5, table5, table6: table3, table8}; +let importObject0 = /** @type {Imports2} */ ({extra, m0, m1, m2}); +let i0 = await instantiate('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', importObject0); +let {fn6, fn7, global2, global3, global4, global5, global6, memory0, table9, table10, tag0, tag1, tag2, tag3, tag4, tag5} = /** + @type {{ +fn6: (a0: F32) => void, +fn7: (a0: I32, a1: V128, a2: F32) => [I32, V128, F32], +global2: WebAssembly.Global, +global3: WebAssembly.Global, +global4: WebAssembly.Global, +global5: WebAssembly.Global, +global6: WebAssembly.Global, +memory0: WebAssembly.Memory, +table9: WebAssembly.Table, +table10: WebAssembly.Table, +tag0: WebAssembly.Tag, +tag1: WebAssembly.Tag, +tag2: WebAssembly.Tag, +tag3: WebAssembly.Tag, +tag4: WebAssembly.Tag, +tag5: WebAssembly.Tag + }} */ (i0.instance.exports); +table3.set(9, table3); +table9.set(1, table3); +global0.value = 0; +global4.value = 0n; +global1.value = 0; +global3.value = 0; +global5.value = 'a'; +report('progress'); +try { + for (let k=0; k<25; k++) { + let zzz = fn6(global1.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +report('progress'); +try { + for (let k=0; k<17; k++) { + let zzz = fn6(global1.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +let tables = [table3, table9, table1, table0, table5, table8, table10]; +for (let table of tables) { +for (let k=0; k < table.length; k++) { table.get(k)?.toString(); } +} +})().then(() => { + report('after'); +}).catch(e => { + report('error'); +}) diff --git a/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try.js b/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try.js new file mode 100644 index 0000000000..a3154e1219 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try.js @@ -0,0 +1,216 @@ +// @bun +//@ runDefaultWasm("--useDollarVM=1", "--jitPolicyScale=0.1") +function instantiate(moduleBase64, importObject) { + let bytes = Uint8Array.fromBase64(moduleBase64); + return WebAssembly.instantiate(bytes, importObject); + } + const report = $.agent.report; + const isJIT = callerIsBBQOrOMGCompiled; +const extra = {isJIT}; +(async function () { +let memory0 = new WebAssembly.Memory({initial: 728, shared: true, maximum: 1820}); +/** +@returns {void} + */ +let fn0 = function () { +}; +/** +@returns {void} + */ +let fn1 = function () { +}; +/** +@param {ExternRef} a0 +@param {FuncRef} a1 +@returns {[ExternRef, FuncRef]} + */ +let fn2 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [a0, a1]; +}; +/** +@returns {void} + */ +let fn3 = function () { +}; +/** +@returns {void} + */ +let fn4 = function () { +}; +/** +@param {ExternRef} a0 +@param {FuncRef} a1 +@returns {[ExternRef, FuncRef]} + */ +let fn5 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [a0, a1]; +}; +/** +@param {ExternRef} a0 +@param {FuncRef} a1 +@returns {void} + */ +let fn6 = function (a0, a1) { +a0?.toString(); a1?.toString(); +}; +/** +@param {ExternRef} a0 +@param {FuncRef} a1 +@returns {void} + */ +let fn7 = function (a0, a1) { +a0?.toString(); a1?.toString(); +}; +/** +@returns {void} + */ +let fn8 = function () { +}; +let tag4 = new WebAssembly.Tag({parameters: ['externref', 'anyfunc']}); +let tag5 = new WebAssembly.Tag({parameters: []}); +let global0 = new WebAssembly.Global({value: 'externref', mutable: true}, {}); +let global1 = new WebAssembly.Global({value: 'f32', mutable: true}, -53278.38197474244); +let m2 = {fn1, fn4, global2: global0, global4: global0, global6: global0, memory0}; +let m0 = {fn0, fn5, fn7, fn8, global0, global5: global1, tag7: tag5}; +let m1 = {fn2, fn3, fn6, global1, global3: global0, tag4, tag5, tag6: tag4, tag8: tag5, tag9: tag4}; +let importObject0 = /** @type {Imports2} */ ({m0, m1, m2}); +let i0 = await instantiate('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', importObject0); +let {fn9, fn10, fn11, global7, global8, global9, global10, global11, global12, global13, global14, global15, global16, global17, global18, memory1, table0, table1, table2, table3, table4, table5, tag0, tag1, tag2, tag3} = /** + @type {{ +fn9: () => void, +fn10: (a0: ExternRef, a1: FuncRef) => [ExternRef, FuncRef], +fn11: (a0: ExternRef, a1: FuncRef) => [ExternRef, FuncRef], +global7: WebAssembly.Global, +global8: WebAssembly.Global, +global9: WebAssembly.Global, +global10: WebAssembly.Global, +global11: WebAssembly.Global, +global12: WebAssembly.Global, +global13: WebAssembly.Global, +global14: WebAssembly.Global, +global15: WebAssembly.Global, +global16: WebAssembly.Global, +global17: WebAssembly.Global, +global18: WebAssembly.Global, +memory1: WebAssembly.Memory, +table0: WebAssembly.Table, +table1: WebAssembly.Table, +table2: WebAssembly.Table, +table3: WebAssembly.Table, +table4: WebAssembly.Table, +table5: WebAssembly.Table, +tag0: WebAssembly.Tag, +tag1: WebAssembly.Tag, +tag2: WebAssembly.Tag, +tag3: WebAssembly.Tag + }} */ (i0.instance.exports); +table1.set(24, table0); +table1.set(13, table0); +table0.set(31, table0); +table0.set(11, table0); +table0.set(1, table1); +table1.set(2, table0); +table1.set(27, table0); +table1.set(17, table0); +table0.set(5, table0); +table1.set(48, table0); +table1.set(42, table0); +table1.set(12, table0); +global15.value = 0n; +global18.value = 0; +global13.value = 'a'; +report('progress'); +try { + for (let k=0; k<14; k++) { + let zzz = fn11(global13.value, null); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +report('progress'); +try { + for (let k=0; k<18; k++) { + let zzz = fn10(global13.value, null); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +report('progress'); +try { + for (let k=0; k<15; k++) { + let zzz = fn9(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +report('progress'); +try { + for (let k=0; k<25; k++) { + let zzz = fn10(global13.value, null); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +report('progress'); +try { + for (let k=0; k<25; k++) { + let zzz = fn11(global13.value, null); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +report('progress'); +try { + for (let k=0; k<10; k++) { + let zzz = fn9(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +let tables = [table0, table1, table4, table3, table2, table5]; +for (let table of tables) { +for (let k=0; k < table.length; k++) { table.get(k)?.toString(); } +} +})().then(() => { + report('after'); +}).catch(e => { + report('error'); +}) diff --git a/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try2.js b/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try2.js new file mode 100644 index 0000000000..38b9b715fc --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try2.js @@ -0,0 +1,97 @@ +// @bun +function instantiate(moduleBase64, importObject) { + let bytes = Uint8Array.fromBase64(moduleBase64); + return WebAssembly.instantiate(bytes, importObject); + } + const report = $.agent.report; + const isJIT = callerIsBBQOrOMGCompiled; +const extra = {isJIT}; +(async function () { +let tag4 = new WebAssembly.Tag({parameters: ['i64', 'i64']}); +let global0 = new WebAssembly.Global({value: 'i64', mutable: true}, 3499732511n); +let global1 = new WebAssembly.Global({value: 'anyfunc', mutable: true}, null); +let global2 = new WebAssembly.Global({value: 'i32', mutable: true}, 2571545964); +let global3 = new WebAssembly.Global({value: 'anyfunc', mutable: true}, global1.value); +let global4 = new WebAssembly.Global({value: 'f32', mutable: true}, 364166.8042332507); +let global7 = new WebAssembly.Global({value: 'f64', mutable: true}, 213733.71202709377); +let global8 = new WebAssembly.Global({value: 'f32', mutable: true}, 616331.2736008756); +let table0 = new WebAssembly.Table({initial: 0, element: 'externref'}); +let table1 = new WebAssembly.Table({initial: 9, element: 'anyfunc'}); +let table2 = new WebAssembly.Table({initial: 49, element: 'anyfunc'}); +let table3 = new WebAssembly.Table({initial: 26, element: 'externref', maximum: 430}); +let table4 = new WebAssembly.Table({initial: 28, element: 'externref'}); +let table5 = new WebAssembly.Table({initial: 49, element: 'externref', maximum: 474}); +let table6 = new WebAssembly.Table({initial: 15, element: 'anyfunc', maximum: 280}); +let m2 = {global3, global4, global5: global0, table0, table2, table4, tag4}; +let m1 = {global0, global1, global7, table6, tag5: tag4}; +let m0 = {global2, global6: 364324.50814459583, global8, table1, table3, table5}; +let importObject0 = /** @type {Imports2} */ ({extra, m0, m1, m2}); +let i0 = await instantiate('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', importObject0); +let {fn0, global9, global10, global11, global12, global13, global14, global15, global16, global17, global18, memory0, table7, table8, table9, tag0, tag1, tag2, tag3} = /** + @type {{ +fn0: (a0: I64, a1: I64) => [I64, I64], +global9: WebAssembly.Global, +global10: WebAssembly.Global, +global11: WebAssembly.Global, +global12: WebAssembly.Global, +global13: WebAssembly.Global, +global14: WebAssembly.Global, +global15: WebAssembly.Global, +global16: WebAssembly.Global, +global17: WebAssembly.Global, +global18: WebAssembly.Global, +memory0: WebAssembly.Memory, +table7: WebAssembly.Table, +table8: WebAssembly.Table, +table9: WebAssembly.Table, +tag0: WebAssembly.Tag, +tag1: WebAssembly.Tag, +tag2: WebAssembly.Tag, +tag3: WebAssembly.Tag + }} */ (i0.instance.exports); +table3.set(6, table0); +table8.set(24, table3); +table8.set(11, table3); +table5.set(46, table8); +table3.set(5, table8); +global16.value = 0n; +global1.value = null; +report('progress'); +try { + for (let k=0; k<29; k++) { + let zzz = fn0(global0.value, global16.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +report('progress'); +try { + for (let k=0; k<27; k++) { + let zzz = fn0(global0.value, global16.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +let tables = [table0, table4, table3, table5, table8, table1, table2, table6, table9, table7]; +for (let table of tables) { +for (let k=0; k < table.length; k++) { table.get(k)?.toString(); } +} +})().then(() => { + report('after'); +}).catch(e => { + report('error'); +}) diff --git a/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try3.js b/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try3.js new file mode 100644 index 0000000000..5fec8234f4 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try3.js @@ -0,0 +1,163 @@ +// @bun +//@ $skipModes << "wasm-no-jit".to_sym +//@ $skipModes << "wasm-no-wasm-jit".to_sym +// Too slow without JIT + +function instantiate(moduleBase64, importObject) { + let bytes = Uint8Array.fromBase64(moduleBase64); + return WebAssembly.instantiate(bytes, importObject); + } + const report = $.agent.report; + const isJIT = callerIsBBQOrOMGCompiled; +const extra = {isJIT}; +(async function () { +let memory0 = new WebAssembly.Memory({initial: 64, shared: true, maximum: 385}); +/** +@param {F32} a0 +@param {FuncRef} a1 +@returns {[F32, FuncRef]} + */ +let fn0 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [7.379721330814865e-7, a1]; +}; +/** +@returns {I32} + */ +let fn1 = function () { + +return 44; +}; +/** +@returns {[FuncRef, ExternRef]} + */ +let fn2 = function () { + +return [null, {f:42}]; +}; +/** +@param {F32} a0 +@param {FuncRef} a1 +@returns {[F32, FuncRef]} + */ +let fn3 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [5.672612013030605e25, a1]; +}; +let tag0 = new WebAssembly.Tag({parameters: []}); +let tag1 = new WebAssembly.Tag({parameters: ['f32', 'anyfunc']}); +let tag2 = new WebAssembly.Tag({parameters: ['f32', 'anyfunc']}); +let global0 = new WebAssembly.Global({value: 'i32', mutable: true}, 456597103); +let global1 = new WebAssembly.Global({value: 'i32', mutable: true}, 3266924630); +let global2 = new WebAssembly.Global({value: 'externref', mutable: true}, {}); +let global3 = new WebAssembly.Global({value: 'f64', mutable: true}, 461131.2504203794); +let global4 = new WebAssembly.Global({value: 'f32', mutable: true}, 783663.6145011102); +let global6 = new WebAssembly.Global({value: 'i32', mutable: true}, 169917961); +let global7 = new WebAssembly.Global({value: 'anyfunc', mutable: true}, null); +let table0 = new WebAssembly.Table({initial: 99, element: 'anyfunc'}); +let table1 = new WebAssembly.Table({initial: 19, element: 'externref'}); +let table2 = new WebAssembly.Table({initial: 36, element: 'externref', maximum: 841}); +let table3 = new WebAssembly.Table({initial: 94, element: 'externref'}); +let table5 = new WebAssembly.Table({initial: 48, element: 'externref', maximum: 536}); +let m1 = {fn0, fn1, fn3, global4, global5: global2, memory0, table0, table4: table0, tag0, tag1}; +let m0 = {fn2, global0, global1, global2, table2, tag2}; +let m2 = {global3, global6, global7, table1, table3, table5}; +let importObject0 = /** @type {Imports2} */ ({extra, m0, m1, m2}); +let i0 = await instantiate('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', importObject0); +let {fn4, fn5, fn6, global8, global9, global10, global11, global12, global13, global14, global15, memory1} = /** + @type {{ +fn4: (a0: ExternRef, a1: V128, a2: FuncRef) => void, +fn5: () => I32, +fn6: () => void, +global8: WebAssembly.Global, +global9: WebAssembly.Global, +global10: WebAssembly.Global, +global11: WebAssembly.Global, +global12: WebAssembly.Global, +global13: WebAssembly.Global, +global14: WebAssembly.Global, +global15: WebAssembly.Global, +memory1: WebAssembly.Memory + }} */ (i0.instance.exports); +table3.set(36, table2); +table5.set(31, table3); +table1.set(4, table3); +table5.set(27, table2); +table2.set(3, table1); +table3.set(1, table5); +table5.set(11, table3); +table5.set(13, table3); +table2.set(18, table2); +table2.set(35, table3); +table5.set(9, table5); +table3.set(46, table2); +table5.set(34, table3); +table5.set(11, table1); +table1.set(8, table5); +table1.set(13, table2); +table1.set(10, table1); +table5.set(36, table1); +table2.set(4, table1); +table1.set(9, table5); +table1.set(9, table3); +table3.set(13, table5); +global8.value = 0n; +global3.value = 0; +global2.value = 'a'; +report('progress'); +try { + for (let k=0; k<26; k++) { + let zzz = fn5(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +report('progress'); +try { + for (let k=0; k<18; k++) { + let zzz = fn6(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +report('progress'); +try { + for (let k=0; k<27; k++) { + let zzz = fn5(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +report('progress'); +try { + for (let k=0; k<14; k++) { + let zzz = fn6(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +let tables = [table1, table2, table3, table5, table0]; +for (let table of tables) { +for (let k=0; k < table.length; k++) { table.get(k)?.toString(); } +} +})().then(() => { + report('after'); +}).catch(e => { + report('error'); +}) diff --git a/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try4.js b/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try4.js new file mode 100644 index 0000000000..56cf90624f --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try4.js @@ -0,0 +1,142 @@ +// @bun +//@ $skipModes << "wasm-no-jit".to_sym +//@ $skipModes << "wasm-no-wasm-jit".to_sym +// Too slow without JIT + +function instantiate(moduleBase64, importObject) { + let bytes = Uint8Array.fromBase64(moduleBase64); + return WebAssembly.instantiate(bytes, importObject); + } + const report = $.agent.report; + const isJIT = callerIsBBQOrOMGCompiled; +const extra = {isJIT}; +(async function () { +let memory0 = new WebAssembly.Memory({initial: 1850, shared: true, maximum: 2731}); +/** +@param {I32} a0 +@param {F32} a1 +@returns {void} + */ +let fn0 = function (a0, a1) { +a0?.toString(); a1?.toString(); +}; +/** +@returns {void} + */ +let fn1 = function () { +}; +/** +@param {I32} a0 +@param {F32} a1 +@returns {[I32, F32]} + */ +let fn2 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [36, 8.433544074882645e1]; +}; +/** +@param {I32} a0 +@param {FuncRef} a1 +@returns {void} + */ +let fn3 = function (a0, a1) { +a0?.toString(); a1?.toString(); +}; +let tag5 = new WebAssembly.Tag({parameters: []}); +let tag6 = new WebAssembly.Tag({parameters: ['i32', 'f32']}); +let tag9 = new WebAssembly.Tag({parameters: []}); +let global0 = new WebAssembly.Global({value: 'i32', mutable: true}, 3721432472); +let global1 = new WebAssembly.Global({value: 'f64', mutable: true}, 548636.1280581957); +let global3 = new WebAssembly.Global({value: 'f32', mutable: true}, 52810.0658290932); +let global4 = new WebAssembly.Global({value: 'i64', mutable: true}, 1872919390n); +let global7 = new WebAssembly.Global({value: 'anyfunc', mutable: true}, null); +let global8 = new WebAssembly.Global({value: 'externref', mutable: true}, {}); +let table0 = new WebAssembly.Table({initial: 48, element: 'externref', maximum: 347}); +let table1 = new WebAssembly.Table({initial: 37, element: 'anyfunc'}); +let table2 = new WebAssembly.Table({initial: 51, element: 'externref', maximum: 276}); +let table3 = new WebAssembly.Table({initial: 77, element: 'externref'}); +let m2 = {fn3, global0, global2: global0, global7, memory0, tag5, tag6, tag9}; +let m1 = {fn0, fn1, fn2, global1, global6: global3, global8, table0, table1, table3, tag8: tag5, tag12: tag9}; +let m0 = {global3, global4, global5: global4, table2, table4: table3, tag7: tag5, tag10: tag9, tag11: tag6}; +let importObject0 = /** @type {Imports2} */ ({extra, m0, m1, m2}); +let i0 = await instantiate('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', importObject0); +let {fn4, fn5, global9, global10, global11, global12, global13, global14, global15, global16, memory1, table5, table6, table7, table8, table9, tag0, tag1, tag2, tag3, tag4} = /** + @type {{ +fn4: (a0: FuncRef, a1: I64, a2: V128) => [FuncRef, I64, V128], +fn5: (a0: I32, a1: F32) => void, +global9: WebAssembly.Global, +global10: WebAssembly.Global, +global11: WebAssembly.Global, +global12: WebAssembly.Global, +global13: WebAssembly.Global, +global14: WebAssembly.Global, +global15: WebAssembly.Global, +global16: WebAssembly.Global, +memory1: WebAssembly.Memory, +table5: WebAssembly.Table, +table6: WebAssembly.Table, +table7: WebAssembly.Table, +table8: WebAssembly.Table, +table9: WebAssembly.Table, +tag0: WebAssembly.Tag, +tag1: WebAssembly.Tag, +tag2: WebAssembly.Tag, +tag3: WebAssembly.Tag, +tag4: WebAssembly.Tag + }} */ (i0.instance.exports); +table5.set(16, table2); +table3.set(2, table9); +table6.set(5, table3); +table3.set(54, table5); +table5.set(37, table9); +table5.set(83, table0); +table9.set(16, table3); +table0.set(5, table9); +table2.set(23, table5); +table2.set(27, table9); +table9.set(60, table6); +table6.set(9, table2); +table7.set(8, table7); +table5.set(46, table7); +table2.set(43, table3); +table6.set(18, table6); +table3.set(23, table2); +table0.set(21, table2); +table6.set(8, table0); +table6.set(6, table7); +global13.value = 0; +global12.value = 0n; +global8.value = 'a'; +report('progress'); +try { + for (let k=0; k<27; k++) { + let zzz = fn5(global9.value, global3.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +report('progress'); +try { + for (let k=0; k<9; k++) { + let zzz = fn5(k, global10.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +let tables = [table0, table3, table2, table7, table6, table9, table5, table1, table8]; +for (let table of tables) { +for (let k=0; k < table.length; k++) { table.get(k)?.toString(); } +} +})().then(() => { + report('after'); +}).catch(e => { + report('error'); +}) diff --git a/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try5.js b/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try5.js new file mode 100644 index 0000000000..517a3ce53a --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/ipint-bbq-osr-with-try5.js @@ -0,0 +1,162 @@ +// @bun +function instantiate(moduleBase64, importObject) { + let bytes = Uint8Array.fromBase64(moduleBase64); + return WebAssembly.instantiate(bytes, importObject); + } + const report = $.agent.report; + const isJIT = callerIsBBQOrOMGCompiled; +const extra = {isJIT}; +(async function () { +/** +@param {FuncRef} a0 +@param {I64} a1 +@returns {[I64, FuncRef, FuncRef]} + */ +let fn0 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [1840n, a0, a0]; +}; +/** +@param {I32} a0 +@param {FuncRef} a1 +@returns {[I32, FuncRef]} + */ +let fn1 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [66, a1]; +}; +/** +@param {I32} a0 +@param {FuncRef} a1 +@returns {FuncRef} + */ +let fn2 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return a1; +}; +/** +@param {FuncRef} a0 +@param {I64} a1 +@returns {[I64, FuncRef, FuncRef]} + */ +let fn3 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [1451n, a0, a0]; +}; +/** +@param {I32} a0 +@param {FuncRef} a1 +@returns {[I32, FuncRef]} + */ +let fn4 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [83, a1]; +}; +/** +@param {FuncRef} a0 +@param {I64} a1 +@returns {[I64, FuncRef, FuncRef]} + */ +let fn5 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [1325n, a0, a0]; +}; +/** +@param {FuncRef} a0 +@param {I64} a1 +@returns {[I64, FuncRef, FuncRef]} + */ +let fn6 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [1669n, a0, a0]; +}; +/** +@param {I32} a0 +@param {FuncRef} a1 +@returns {[I32, FuncRef]} + */ +let fn7 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [56, a1]; +}; +let tag6 = new WebAssembly.Tag({parameters: ['anyfunc', 'i64']}); +let tag7 = new WebAssembly.Tag({parameters: ['anyfunc', 'i64']}); +let tag9 = new WebAssembly.Tag({parameters: ['i32', 'anyfunc']}); +let global0 = new WebAssembly.Global({value: 'i64', mutable: true}, 440044811n); +let table0 = new WebAssembly.Table({initial: 84, element: 'externref', maximum: 859}); +let table2 = new WebAssembly.Table({initial: 39, element: 'externref', maximum: 210}); +let table3 = new WebAssembly.Table({initial: 20, element: 'externref', maximum: 202}); +let table7 = new WebAssembly.Table({initial: 86, element: 'externref'}); +let table8 = new WebAssembly.Table({initial: 27, element: 'anyfunc', maximum: 687}); +let m2 = {fn0, fn7, table3, table5: table0, tag8: tag6}; +let m0 = {fn1, fn2, fn3, fn6, global0, table0, table2, table6: table0, table7, table8, tag6, tag9, tag12: tag9, tag13: tag9, tag14: tag9}; +let m1 = {fn4, fn5, table1: table0, table4: table0, tag7, tag10: tag9, tag11: tag7}; +let importObject0 = /** @type {Imports2} */ ({m0, m1, m2}); +let i0 = await instantiate('AGFzbQEAAAABJwZgAn9wAXBgAn9wAn9wYAJ/cABgAnB+A35wcGACcH4CcH5gAnB+AALFAhsCbTIDZm4wAAMCbTADZm4xAAECbTADZm4yAAACbTADZm4zAAMCbTEDZm40AAECbTEDZm41AAMCbTADZm42AAMCbTIDZm43AAECbTAEdGFnNgQABQJtMQR0YWc3BAAFAm0yBHRhZzgEAAUCbTAEdGFnOQQAAgJtMQV0YWcxMAQAAgJtMQV0YWcxMQQABQJtMAV0YWcxMgQAAgJtMAV0YWcxMwQAAgJtMAV0YWcxNAQAAgJtMAdnbG9iYWwwA34BAm0wBnRhYmxlMAFvAVTbBgJtMQZ0YWJsZTEBbwAxAm0wBnRhYmxlMgFvASfSAQJtMgZ0YWJsZTMBbwEUygECbTEGdGFibGU0AW8AQQJtMgZ0YWJsZTUBbwApAm0wBnRhYmxlNgFvAEgCbTAGdGFibGU3AW8AVgJtMAZ0YWJsZTgBcAEbrwUDAwIBAQQEAXAALgUGAQOGGJQlDRUKAAUABQACAAIAAgAFAAIAAgACAAUGJQV8AUSB0pcVv2VyNwtwAdIIC30AQ+hJ9NALfwFBtwELbwDQbwsHbA0EdGFnMgQDBHRhZzEEAgR0YWcwBAAHZ2xvYmFsMQMCB2dsb2JhbDMDBAdnbG9iYWwyAwMGdGFibGU5AQcEdGFnNQQIB21lbW9yeTACAAR0YWc0BAcDZm44AAgHZ2xvYmFsNAMFBHRhZzMEBgmtAgcBAEIAAAEGAQIFBAEHBgcJBwcCBQEAAgAFBwIABggAAQkABQkDAgMFCQICAAMAAQQHAwcFBggICQIAAAUCBgQCAgUGCQEGCUEWC3AY0gYL0gAL0gUL0gYL0gcL0gYL0gQL0gcL0gYL0gUL0gEL0gML0gUL0ggL0gUL0gML0gEL0gAL0gcL0gML0gIL0gUL0gAL0gILAQBTCAkCAgQEAQcFBQYABwcIAgUCAQMEAAQJAQEBBgkEBwcHBAcHAAkBAAgCBwgBBQEBBAMGAQIFAwECAAgEAgkFCAMGAQEIBQQIBAQAAAcEAgQGAwkGCUEoC3AG0gcL0gAL0gEL0gIL0gkL0gILBglBKQtwBNIAC9IDC9IFC9IGCwIJQRoLAAUBBAcICQYIQQsLcAHSAgsMAQQK9UACuBMKAXAAfwFwAHAAfAF8A38BfgF9AXwjBEEkJQkQCQMCIwLSAER9g3fvuUW2JyEE0gUgAyMF0gJDeyssryMFAn1BA0HLAEEG/AwCCPwQAQN+Q9tQRSMCQCAJQwAAgD+SIglDAAA0Ql0EQAwCC0Ra6SdAmL6oT/wHIAAjAgYBGAQGASAIQgF8IghCA1QEAQwFCwwAAQsQAiIB0gAgAiQCQb+9DUEBcA4BAAALDAEACwALIwMgASQCIwMjBBvSAyAD/BAJJAQGcAZ8QtwA/BAIQQJwBG8gBAwBAAXSCAZ80gH8EABB//8DcTEAhwbSCSMB/Ab8EAEiAGj8EAZB//8DcTMA2gMkAEECcARADAAABQwAAAtBEULM0Yz8C9IBIwIhAkQKxy9ar3VS3dICQT5B//8DcTAA2AT8EAkkBPwQBiEARCgke+rVXLzSIwAjAwJADAAAC9IARPC0VcRlnnRUBnDSCSABIQJDOCcnoSACDAALIAH8EAkOAQMDC0MNyEUTIAIkAkHuGiIAAn9B0BNB/AAMAAAL0gQjAgJ/Bn1BugNnJARBvJsbIQDSAj8AIgAMAQAAAQsjBPwQAgwAAAv8EAZBAnAEfCAEDAIABQJ/IwTSAtIBIwQMAAALQQJwBH/SA0NWk4F//BADDAAABfwQBQwAAAtBAnAEcCAAIAIgCkQAAAAAAADwP6AiCkQAAAAAAAAYQGMNBSAKRAAAAAAAAPA/oCIKRAAAAAAAACxAYwQBDAYLDAAABUTUQDN8r1spxCEEQr/xVCAEmQZ9IAQCfdIDRM3yu4qtKv1/IAMMAgALDAAAC0KMAfwQBQN90gMgAQwFAAsDfNIGIAMMBQALDAELIgMkAgJ9Q6dM57QgACQEQd/qzJl+QQFwDgEAAAsCfiMBvXkMAAALJABCLCQARNkLWPIT3ULRIgRBBw0AmvwQBUECcARw0gMGcCMF0gPSACAAIAIGcAZ8IANBoAFBBHAOAwIBAwcL0gcGbyMEJAQgASED/BAJJAQjA48GfEOh4kzTQR1BAnAEfgZwIwFDRPDh00GMpfSoBkHDrf3jA0ECcAR9QzxHIo8gAA0ADAAFQ8yPtxREoHXaG7d4sNdDHI7ffwwAAAtCtfrq1sH3568PIABBAXAOAQEBCyEDAnwGfEH4gAFB+ti2gwFB3bQD/AsABn3SAyMEQQJwBH3SAEKTzY9/JAAjAENGVa/oQYXeqhBBAnAOAgEAAQUgAkHwAQ0JDAkACwwAC9IBQS1BJ0EA/AwCCdIF0gRDS31vZkRbkN76c4i4JAwACwZvQqa6egZ9IABB/P8Dcf4QAgAkBEEeQSxBBPwMAglB8ABBAnAEQAUMAAALA35COAwEAAsMAwuPQpSw7tDMv+60ArkMAQtD5pJjT/wQBfwQCXAlCQwFCwwBBdIAQ1zlIFE/ACEAAm9CggEGfgZ8Q4A2aY4GcPwQAkECcARw0gVEqxc/z/peEh4MAgAFREz/wArZau2YQuEBDAUACyABDAcACwZw0gP8EAlBAwZ8QbbQkogHBn9BgAFBAnAEfiMBnp38A0ECcAR80gUjA0TFcr+ILSyIjQwQAAUCbyAEmyIEDAEACwALDAgABUQUNR5WlSYikvwHJAACcESCq2Fa6FhLhCEE0gfSASMCDAwACwALDAYLIQACfCACQcvd4M4EDQIgAgJADAAACyMDRGdXD8MwUHo2DA4ACwNAIAMiAwwCAAtE0yL+LXuBjHwMAgsMCgALDAcLQeqSqbMBQ1oKz4hCigH8EAdBAnAOAgACAgt5iSAEIQT8EAYhAEMAAAAA0gnSASABQwAAgP8Gf0KmkPrFv4fl/QIMAgtBK0EXQQL8DAIJ0ghBOCABAn0Cb0P9zrfKjyABDAgACwALAAsMBwsjBUHQAWcgAwYCDwvSAD8A/BAH/BABIQBB/P8DcSAA/iUCACQEIAQkAUECcARwQoLHz7TX18QAJABCvAEkACAAQQJwBHAgBNICQxnewKH8BNIHIAIkAtIH0gf8EAVBAnAEfCAB0SMEQQpBPkEG/AwCCCEAQf//A3EgAP4gAAAkBELqEENnfZP/Q5gtYAdDnS4mviAAIgBBAnAEfUSF1Hw0OX9jECQB0gVBCCMETAJA/BACQQFwDgEAAAELIgAGf/wQAgwACyAABkAMAAsCb/wQBiQEAnwjANIDIwAgAKxVBnwjAfwDJAQgASADIQIMCQsMCwALAAsABSADDAcAC18iACADIAVBAWoiBUElSQ0MEAL8EAEjAQwAAAUgBAwAAAv8AiABBgEMBgsGAQwFCwYBCwwBAAVE1AHMySD7DpkMBwALDAkFQc8VQe663QRHQQJwBEAMAAAF0gEGfEK4y/gBIwBB7//BAEEBcA4AAQsMCQtBECUJAm/SBD8AIwH8EAANCQwHAAsACwwICwwGC0Ht2/A5QQFwDgQEBAQEBAsMAAvSBCMFIAL8EANBAnAOAgQABAUjAgwEAAvRIwIMBQsMAQtCYEEIQTlBB/wMAAgkABpDyByfTxpETVJH9n/0TZQkAcRQJAREJNJ5HyCi8b9CjJh/vwwACyQBIAEkAkOe86LuQjMkABogACQEQwFiCJ1BPdIFQRtBAnAEfkLX+DoMAAAFQt2km8tYIwRBAXAOAQAAAQALJAAjBAR/IwQiAAU/AAwAAAvSBiMDGiME0gQCfAZ+IwEMAQsgAyQCRGsFKmcz5BYGDAALBm9CNyAArSAEIwIMAQALPwDSBwJvQqrDlYxiJABBDiUDCwNvQQUlBSAEBnACfURPH6p6dvoIIyQBAm9BCSUBC0EHQSdBAPwMAggjAwZ/Bm8gCUMAAIA/kiIJQwAAmEFdBEAMBQtBsLflgX0kBEGfhZXdAAwBCxogAAsOAQAAC0LxAUL70PYAhgJ+BnwgAD8AJARBAnAEcEEFJQlDCKMg6RoMBQAFIAdBAWoiB0EESQRADAULQ4Un4ZhBwvsFs0PmKCQiXiQEIAACftIDRMxxBKOmKbfJDAIACwALQZ8CQQJwDgICBAILJAHSAgJ8RO+fcOGpmRUnIAMMBAALAAtWIwH8B0GfASEAQejXrgFEXmoZOWHGcepDxahIiD8AGiAB/BAFDgIAAgILDAEACz8AJAQgAwwAC/wQBSQE0gMaJAIkAiADIwAkANIHBn0/APwQCSQEQQ5BGkEQ/AwCCSEAQ5LZbiELIABB//8DcTEAISQAPwBBAnAEf0GzkooUDAAABSMEAnAgAgwAAAsCAfwQA0ECcA4CAwADCwwCAAuzQuN+JAD8EAMgAAZwQcXusAwhACACGAEiAgIADAIACwAL0gcaQcEBIAMLuC0HAXABfwJ/A38BfgF9AXw/ALICfSACJAL8EAgiA/wQASMF/BAE/BAJSD8ATCQEQYXg0QFB+gMgBbNBkgL8EAUhACEF/AAhAEH//wNxIAD+NQAAJAQiAEECcAR/0gMGbyMDBn38EAEMAgtDmta1/vwQCEEBcA4BAgILIwBEPR0TNcwtriJBtLCk7wAkBPwHJAC1IABBAXAOAQEBAQVDlHe1ZNIGAn5E4wedWseCkoycJAFB3fcBDAEACwALQQJwBH38EAIkBANwQQf8EAICbyAGQQFqIgZBI0kNAdIE/BAFQw69ROcMAgALAAsABdICIwLSByMBIAMjAbZDC7YK1Y9B3AECfdIJIwNC58zRwtu354gBIAAkBKcEb/wQACEEIAP8EAJ0QQJwBH0jBQwBAAUCfD8A/BAAIwBEAAAAAAAAAIAGQEHptAFBAXAOAQAACwwAAAsjASMC0ghBy6CFhwFBAnAEcCMEJAQgAwN8IAHSAkPh3VifIAEjBQwDAAsABUIIIwMMAwALQgcCfvwQAEEDQRtBHvwMAAkkBCABIgEhAkQGL06n5A19O0P0bAfyPwANAQwBAAvSAdIGQvEAJADSCdIDQwjYD55E1G0PxQJMIxD8ByADBm8jAPwQCSQEJAAgA7j8EAACcNIGQa3Ug88FBH0gAkEFQQNBBvwMAggMAQAFQYnQiZF+IgREFQTCJczE/akjAwwGAAsgAA0CQYeyAQJwQQFBGkEU/AwACQZv/BAH0gEgA0ECcAR90gfSANIAQpb+wfajv6PJACAC0gQjAT8AIgQGcD8AIgNELgCOx8A+dLjSBgJw/BAFJAQGfSMA/BAHIgT8EARzIwMMDAv8EAQNCwwHAAsMAwsPAAUgACMFAm9DTJa/f48MCAALAAsjAgwCC0EDQR1BCPwMAggMAgskAkEEcA4EBAUCBgQLDAYLDAEBAAsMAgUjBEECcAR8IAQCfNIHQxEyf1ZEZpEqHoo0NNgMAQALAAVE11NLy6cAFJUMAAALQfrgvNABQQJwBHDSByMDjiMCDAAABQZ/PwAgAw0A/BADIAEDAgNw0gj8EAgMAgALAAu+DAUACyQEQf+9+eN5QQJwBHwCb0S4qK7n5WgjECQBAn/8EAIiAwwAAAtBAnAEQD8AQQJwBH4MAQAFDAEAC7okAUOK+27lQQIiBEECcARA0gcgAPwQBHAlBEEaDQIDcEELQTJBDvwMAAggA7O8DQIMAgALAAXSACABIAVBAnAOAQABAQsjBdIH0gREyNMOtlzXZ95CLfwQCA0AJAAgAQwDAAsgBLIjA0Sj9e5w/y0AqQwBCyAAQQFwDgECAgVC/AC6DAAACwJwIwMDQERbrfZkcKL3/yQBQ2nK5X9EBDT8c27nSP8kAYwgBA0EDAQACwAL0gAjASQB0gLSCEMefk1IDAQBCyQCJAEgAANw0gFDsW8/9/wFJAAjASMFDAEACw8L0gY/ACQEQr7i0fHHAAJ+RKYvquUlNfR/Qs8BIwUCfSAAQQJwBHBClEMMAgAFIAPSBEEAQRJBAfwMAAkCQEPJkkU/DAIACwALIQIjAkMhfBgNQwAAAIAMAguQ0glChQFD99qkwT8AQQNwDgMDAgECAQskAELSASADBHwGf9IBQdDO5a8HDAALQrWv4oqWmH4kAPwQBXAlBQJwPwD8EAf8CQMhBUH+/wNxIAX+GgEAAn5EvE1ovBZD/eogAQwBAAsAC/wQAQZADAABAAskBCIBQdkRPwAkBPwQCCMBDAAABSMEIAIPAAsjBUHMu8aLfqz8EAZCvu6g0dHhAETz1MJIHzrzVUTOpOMxCF7y/yADaCIFAkBBqwUgAxpBCQ4BAAALBEAFIAMjBSACIARBAnAEbwJ9QucB0gdBzooBQQJBAPwIAgBCooDR6vergwYgAEEBcA4BAgILDAQABQwBAAtChNGH2+X8nH9EQyVNSsFpBG1CFCQA/BAA/BABRIpggZQUf35fmSQBQQFwDgEAAAALo9IBIAQ/AEH//wNxKwLhBCMFBn38EAUGbyABIwRDIty4J0IOJAD8BCAEQQJwBH9EVRPadvYhSZXSBPwQAgwAAAXSBUSnIUVJhfgwxgN80gNC/AEjBQwCAAsACyQEJAAjACMCQz5zL0vSBkEKQQpBCfwMAAhBC0EpQQr8DAAI/BAEQRBBzQBBBPwMAgj8EAFwJQFDhp8yD0HWiyRnQQRwDgQEAgMBAQvSAyAA/BAHBnBDp4trlAJ8IwEMAAALQzIEHY3SCAZ8Q7te+rsjAdIBIwMMAgskAQZ8IAAkBNIBIAEMAQsjAWQEQERc86W1GDn6/yADRE9+HKJqVV25JAHSCSMEIQAgAEEBcA4BAAALIAEMAAtBjNOKwwQGcEEBQQlBFvwMAAgGQAwACwJwAn3SByADQf//A3H+FAAAIwQDfQJ8IAtEAAAAAAAA8D+gIgtEAAAAAAAAPEBjBEAMAgsgCUIBfCIJQhZUDQFDAAAAgAwCAAsACwALA0DSAyMB0gMDfyAKQwAAgD+SIgpDAADwQV0NAUNGz87/DAcACwALAAsYBA8LDAELDAEAAQuL/BAHAkAMAAALQQFwDgEAAAtBx7+vGiIAAm8Gf9IJ/BAHDAALQa74gsx8RAAAAAAAAACA0gFDLDLpGEOYcpP/0gBE5CmAxSChzyj8AkMC5NXI0gMgBCQEIwIgBAZAQuUABn0gAw4BAQEHDgIDA0D8EAAjAT8AQQJwBH8JAwUgBkEBaiIGQRFJBEAMAgsgASQCIwQMAAALQcEAQS1ByQBBAPwMAgkiA0EBcA4BAwMLIAAiBUEBcA4BAgILIQIiAvwQBQ0B/BAEQQFwDgEBARn8EAXSAkQIxJfPULJnJz8ADQFDmbJQnAwACyAE/BAEA38gCkMAAIA/kiIKQwAABEJdDQAMAQALQQFwDgEAAAsEQPwQBw0ARFOcqNRwg0wO/BAADgEAAAshAfwQA0K86o3FASMCIAIGf/wQAgwACwJwQ5SDwn9BswFBCUE3QQH8DAAIIgQGcNII0gc/ACEAIwQgBHEEb9IIQdrXAUHx0o2hA0HA/gP8CwDSBEOj++7+/BAGQQJwBHA/AER9t+O8BolUJwJA0gBB/eSgGyAAIAIPAAsABUTrFy5mFCqVJ/wQCPwQBwZ9IwEkAQZ+Qd+gA0EFQQD8CAEAIAHSBUQlgGBYD1m/TyQBQf4EQQJwBEAFBn8MAQsGfSAFQQFwDgEBAQsMAgsjBSABIAUiA0EDcA4DAgUEBQskACMBniAFBEAMAAAFDAAAC7Y/AA0ABn5BjIWslAYhAwJ+Q9YgXWkMAgALJAD8EAkjBLe2IAVB1AAjAKdBAnAEcEI8/BAJQQFwDgEBAQEFA3DSCQNv0ggjAgwCAAsACwALDAUACyQABwpQQQNwDgMBAwQDAAsgA0OEMlQrIwACfENPSqn10gYgAiQCRAAAAAAAAACADAAAC0R8nmFRAQEXJ9IDAn0gAEPtJrHd0gD8EAUGfD8A/BAEcCUEDAYBC0R4NwYk4LnJACAFBH8CcNIAIAQkBEEmRJ4QXy/HZMZBBm9C1wC6Q+3RuQEMAwtETMGZI9OPYN+9RJgnJr1nzSvfAkBBBUEOQQn8DAAJIwFDCKAzpgwDAAsACwAFRKEdkFDGH7xk0gZEFLHYWo7L/iVECFUTSalcGqtkDAAACyMEQQJwBHz8EAckBEIX0gnSBiAFQQJwBH9BC0EmQQz8DAIIAkBD0P2bf/wAQQFwDgAAC0LegsH1idVvwrQgBQwAAAUgAEECcAR/0gJD2JVitAwDAAUgBQwBAAsMAAsiA0ECcARAIwUMBAAFIwBEdA7BaeG8aKEMAQAL0gkgBCEEIwIjAAIFEAYkAgwDAAsjBQwGBT8AQQJwBG8gBQJADAAAC0MY3Sr9DAIABSMEIQREjQNxSq9draMMAQALDAMLQeABQRpBOUEI/AwACQJ90gH8DQbSBkKCzp7WAdIE0gQCcD8AQQJwBG9B+QAGb0TxPKo0QMWucL0CfiAAQQJwBH3SCNIHQ8MVZhsgAfwQCUEEcA4EBAoJBwcBBUG1wfu6fQRv0gHSBPwQBEGeAfwQBnAlBkPlPgfPBnwgAtEgBUECcARwIAVBAHcGfyADQQJwBG8Gf9IIQRVBL0EC/AwACNIIIAAMAgtBAnAEQAJAAn0MAQALAAsMAAAFDAAACyMBnQwDAAXSCPwQBgR8/BAIDAIABdIB0gFCleWxCAZ8Qqu8qNggIAANCAwICyQBJAAgAkEfDAIACyAEDAEACyAEQQVwDgUGBwwPAwwLQQJwBHAgAQwOAAXSCAZ9IwVDxk+sDgwKAQsMCQALDA8ABSAEJAQjAdIJQ5FbwdEGQCMADAULQ1+T14UMCAALAgIGAQwQC9IHQfC72wANAEJ7DAQLIAIMBgskASAEQ9xsmf8Gf/wQBQwAC0ECcARAIABBAXAOAQAACwwGBfwQA0ECcARwA34jBEECcAR8RIadXSXXAIXM/ANBAnAEfURhRKUfXd1Aw5kCbz8AJAQjBANwIAhBAWoiCEEbSQ0EIARBAnAEb0NP+Ck0IwIkAkSSk3DVeRrmW0KMASQADAQABUEEJQYMAgALIABBBnAOBg8SCgYBCQ8BCwMBCwYBJAIgA0ECcARvQcW7AUGcrbK1e0GcEfwLACAHQQFqIgdBK0kEQAwGCwZ/RJV23JIv5eKx0gga/AMMAAsEcAZ+PwDSBSAFJAQjAiMEDQEiASMADAAACwJADAAAC9IJQxdb4Pn8AQR9An4gBkEBaiIGQSlJDQggCEEBaiIIQQRJDQhDF3qYCAwRAAsABUQyJV0+VG4foPwQB/wQBQRAIAlCAXwiCUIqVA0IQtcBIAL8EAPSAyACDAkABQsNBgwGAAvSA/wQBiQERMhZ6UCQINoMRCkuXNi9RRQmDAUFIwUMCAALBn9DTNxCKETJz2LqSohjSpwMBQtBBXAOBRIRBgwPDAUjAyAAQQRwDgQOCA0DAwtBtAHSAkIHJAAaQQZwDgYPBgkBChIJAQALAgECcERrojTkLZo62QwEAAsACwwPAQsMBAVDbGNPQyADQQRwDgQACwUKCwALROI6kuZyzJbvIAANAAwABdIIIAIMDgALPwBBAnAEb9ICIAIMDgAFQ1W71/sgASQCkJAjAwJ8IwQGfiAJQgF8IglCFlQEQAwECyALRAAAAAAAAPA/oCILRAAAAAAAAD5AYw0DIAE/AA0EAnDSA9IJ0gIa/BAEBkAgB0EBaiIHQQ9JDQUGQCAJQgF8IglCE1QEQAwHCyABIgIMEAtDAAAAACMDDA0LBH4gCkMAAIA/kiIKQwAAqEFdBEAMBgtC8AAjBERmMsSzdocypiACIwQaQQIOBgwGEQ8SARIFQjkLpyQEGiAAJAQgAEH//wNx/hQAALkMAgALJAIMDwsMBgtDPwwfSQJ9/BABJATSCCABDAwACwALDAIAC0HmAEEBcA4DAwMDAwUGfyMEDAABC0ECcAR8QawBQQJwBG/SB0L5AQwFAAUGfEIZJABE4UVdnvVdXaUCQAwAAAsYDQwBAAsgA/wQAPwQBCQE0gEaskK7XPwQAtII/BAAJATSBgZw/BACQQJwBH/8EANBAnAEfUM0yW5zDAYABSAADAEAC0Gd05+RfwwAAQEFBn8gAAwBCwwAAQskBPwQCQJ8Q46zfrqL0gQDf0L86M20j/1yDAcACwALQgAMBQtE4bhv1r6ikJAjAwwIBQNAQiEMBQALAAskAQJw0gXSCCMCQdixA0EDQQD8CAIAAn1B45jGKUECcAR9Qy52COQFQegAQQJwBH0gBEHN/qDUAUH8/wNx/hYCACMCQQBBBnAOBg8QAwQKDQ0AAQVEltCVk1uMvWEkASACDBAACwwLAAsjBEEEcA4EAAQJCgoLDAgLDAABCwwICwJAC0RdUl/Dec9/c0NLBdXZQvDarobmr4wKDAEBAAu7/BAEuJ1lQQJwBHwjBQZvQrqWEQwCCwJ/Q88c7lWMAkACfwwBAAsACyMABm/SAiADRHbHmrL3UkwVJAEjAAwDC/wQACMFDAMACwAFQuqLpPKGBgZ/IAMLQQFwDgEBAQsaIANBAnAEb0Gxl/QFBHDSCCACIQJC8pTT4NO75noMAgAF0gYaQQQlCQskAvwQCSADIQBB/P8DcSAA/iUCACMB0gFBCEHJAEEH/AwCCBpDTzmEQQwFAAVEOC0qjkE39H+dBn9ETIkvIETOXQBDhAdZ2ULCo4fuq4cGDAILIwUMAAALDAILJAAgBUECcAR+RNREV0+fFl32IwNC/qOi5qJ/DAAABfwQAUECcAR9QwKqFGcMBQAFIAAkBAZ9IAQkBEMrpaLkCwwFAAsMBQALIwLSBhoMBwsMAAUjBUHqzR9BA3AOAwgABQgLQZ0BQQJwDgEHBAsMBAsMAAsaQsABJABBm7zx7QRBAnAEQAwAAAUMAAAL/BAFQYnwG3YkBAJvIwULDAQLPwAiACIEDQIMAQVB+gA/ALfSCEPljY+nQ4ktHM4GfCMBAn0jAtFB//8DcSwAOiQERBiQX0F9Q7M8An1D1WuEAAvSCdIHAn5EfDfX2T6aKZxCPgwAAAsCfyADwQshALX8EAJBAXAOAgAAAAEL/AQkAJwL/BADQQJwBH78EAEkBAZ+Q+420I/8BQsMAAAFRFiGtzDFu27nJAEgACIFJAQgAQwDAAsgBUH//wNxKQOMBrlB8IMkRSQEJAEkACQBk4waQ3yWbCIaA38/APwQBnAlBvwQCQ4BBAELQf//A3EtAK4GQfz/A3H+EAIA/BAIJAQiBEECcAR/IwEkASAEDAAABUHvqaC6B0G/tcecBgwAAAshBRokASEDIwUMAwEACwwCAQsPCwwBCwZ+BnBDR0Kr/0T52VAyuNvfVSQBQhQkAEMXUE7TGhoCfUPMDgRNCxpBJUEkQQX8DAAJIwI/AA4BAAALIwQkBCQCIwALAn9BCUECQSD8DAAJIwQLQQJwBH8/AAwAAAVBAAskBAZADAALv7ZDqRJgcly+ROS8xPLBCrYEJAEaGiADciQE0gf8EAMkBBoaBn9BsJ/NAgvSBtIJPwBBx4KRIyMFGkYkBEEIQTRBAPwMAAg/AEECcAR+QvcBJAAgANIJGiQEIAAjASQBJARCtvvzsNd8IAREw4GZan6PsjICfyMF0gIgBAwAAAsEfkSzjj9KVQgyUdIF/BAEBH8jBQJA0gT8EAkMAQALAAUjAiAADAAACyQE/BAAJAQaGkKsgeuo1NySNiQARM1jVsFb4DWRIwGm/AYMAAAFIAQgAgIBDAAACwwCAAu1/BADIAIPAAVC3QEkAEMAAIB/IAIkAgZ/QenGlO0CCyQE/AEiAyEDQuIACyQA0gcGfCMBC/wDIQAaGgZ8QwVwqf8a0gUaRCOj9wv7AGLwCz8A0ggaJAT8B0EdQcEAQQL8DAIJJAAaIQUgAiQCu5kkASMDGiMCIgIhASMEIwIDQCAGQQFqIgZBEEkEQAwBC0HMAUH4/wNx/hEDAEHw/8oAQqoBwyMFGiMFGiQAJAQ/AEECcARvQfWtAyABIARBAXAOAQICBUH8xgYhA/wQBiQEIwUgBUEBcA4BAAALQfwAQQJwBHAgCEEBaiIIQS9JBEAMAgtD2mrvf0RjhpI9tsRNkxogAkTTjF5qI4BfnSQBDAAABfwQAb5Dgqc0wdIAGmAkBEErJQnSCNIBGkNpq6WfGtIJ0gQ/AEHukqbQeSACDAAACyQCAm9BlQEkBPwQBiABDwALAAsPCwsfBAED6+9WAQajoAPxVNcBB8c9RIP3qjIBBp1bDMIVIw==', importObject0); +let {fn8, global1, global2, global3, global4, memory0, table9, tag0, tag1, tag2, tag3, tag4, tag5} = /** + @type {{ +fn8: (a0: I32, a1: FuncRef) => [I32, FuncRef], +global1: WebAssembly.Global, +global2: WebAssembly.Global, +global3: WebAssembly.Global, +global4: WebAssembly.Global, +memory0: WebAssembly.Memory, +table9: WebAssembly.Table, +tag0: WebAssembly.Tag, +tag1: WebAssembly.Tag, +tag2: WebAssembly.Tag, +tag3: WebAssembly.Tag, +tag4: WebAssembly.Tag, +tag5: WebAssembly.Tag + }} */ (i0.instance.exports); +table0.set(41, table9); +table9.set(65, table0); +table0.set(39, table7); +table7.set(30, table2); +table7.set(36, table0); +table9.set(59, table0); +table0.set(28, table2); +table0.set(35, table3); +table9.set(10, table2); +table9.set(60, table2); +global3.value = 0; +global0.value = 0n; +report('progress'); +try { + for (let k=0; k<20; k++) { + let zzz = fn8(global3.value, fn8); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +report('progress'); +try { + for (let k=0; k<28; k++) { + let zzz = fn8(k, fn8); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} +let tables = [table2, table3, table0, table7, table9, table8]; +for (let table of tables) { +for (let k=0; k < table.length; k++) { table.get(k)?.toString(); } +} +})().then(() => { + report('after'); +}).catch(e => { + report('error'); +}) diff --git a/test/js/bun/jsc-stress/fixtures/wasm/omg-osr-stack-check-2.js b/test/js/bun/jsc-stress/fixtures/wasm/omg-osr-stack-check-2.js new file mode 100644 index 0000000000..3f951a8b4a --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/omg-osr-stack-check-2.js @@ -0,0 +1,114 @@ +// @bun +//@ runDefaultWasm("--jitPolicyScale=0", "--useConcurrentJIT=0") +import fs from "fs"; +import path from "path"; +async function instantiate(filename, importObject) { + const bytes = fs.readFileSync(path.join(import.meta.dirname, filename)); + return WebAssembly.instantiate(bytes, importObject); +} +const log = function () {}; +const report = function () {}; +const isJIT = callerIsBBQOrOMGCompiled; +const extra = { isJIT }; +(async function () { + let memory0 = new WebAssembly.Memory({ initial: 3947, shared: false, maximum: 6209 }); + let tag3 = new WebAssembly.Tag({ parameters: [] }); + let global0 = new WebAssembly.Global({ value: "f64", mutable: true }, 882640.3220068762); + let global1 = new WebAssembly.Global({ value: "f32", mutable: true }, 162294.89036678328); + let global2 = new WebAssembly.Global({ value: "f64", mutable: true }, 50173.96827009934); + let table0 = new WebAssembly.Table({ initial: 6, element: "externref" }); + let m1 = { global0, memory0, tag3 }; + let m0 = { global1, global2 }; + let m2 = { table0 }; + let importObject0 = /** @type {Imports2} */ ({ m0, m1, m2 }); + let i0 = await instantiate("omg-osr-stack-check-2.wasm", importObject0); + let { fn0, global3, global4, memory1, table1, table2, table3, table4, table5, table6, table7, tag0, tag1, tag2 } = /** + @type {{ +fn0: () => void, +global3: WebAssembly.Global, +global4: WebAssembly.Global, +memory1: WebAssembly.Memory, +table1: WebAssembly.Table, +table2: WebAssembly.Table, +table3: WebAssembly.Table, +table4: WebAssembly.Table, +table5: WebAssembly.Table, +table6: WebAssembly.Table, +table7: WebAssembly.Table, +tag0: WebAssembly.Tag, +tag1: WebAssembly.Tag, +tag2: WebAssembly.Tag + }} */ (i0.instance.exports); + table4.set(6, table7); + table4.set(44, table1); + global4.value = 0; + log("calling fn0"); + report("progress"); + try { + for (let k = 0; k < 21; k++) { + let zzz = fn0(); + if (zzz !== undefined) { + throw new Error("expected undefined but return value is " + zzz); + } + } + } catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); + if (e.stack) { + log(e.stack); + } + } else if (e instanceof TypeError) { + if (e.message === "an exported wasm function cannot contain a v128 parameter or return value") { + log(e); + } else { + throw e; + } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { + log(e); + } else { + throw e; + } + } + log("calling fn0"); + report("progress"); + try { + for (let k = 0; k < 19; k++) { + let zzz = fn0(); + if (zzz !== undefined) { + throw new Error("expected undefined but return value is " + zzz); + } + } + } catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); + if (e.stack) { + log(e.stack); + } + } else if (e instanceof TypeError) { + if (e.message === "an exported wasm function cannot contain a v128 parameter or return value") { + log(e); + } else { + throw e; + } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { + log(e); + } else { + throw e; + } + } + let tables = [table0, table7, table5, table1, table4, table3, table6, table2]; + for (let table of tables) { + for (let k = 0; k < table.length; k++) { + table.get(k)?.toString(); + } + } +})() + .then(() => { + log("after"); + report("after"); + }) + .catch(e => { + log(e); + log("error"); + report("error"); + }); diff --git a/test/js/bun/jsc-stress/fixtures/wasm/omg-osr-stack-check-2.wasm b/test/js/bun/jsc-stress/fixtures/wasm/omg-osr-stack-check-2.wasm new file mode 100644 index 0000000000..2ff168bcd7 Binary files /dev/null and b/test/js/bun/jsc-stress/fixtures/wasm/omg-osr-stack-check-2.wasm differ diff --git a/test/js/bun/jsc-stress/fixtures/wasm/omg-osr-stack-slot-positioning.js b/test/js/bun/jsc-stress/fixtures/wasm/omg-osr-stack-slot-positioning.js new file mode 100644 index 0000000000..f1a3c9c8db --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/omg-osr-stack-slot-positioning.js @@ -0,0 +1,119 @@ +// @bun +//@ skip if !$isWasmPlatform or $buildType == "debug" + +function instantiate(moduleBase64, importObject) { + let bytes = Uint8Array.fromBase64(moduleBase64); + return WebAssembly.instantiate(bytes, importObject); + } + const report = $.agent.report; + const isJIT = callerIsBBQOrOMGCompiled; +const extra = {isJIT}; +(async function () { +let memory0 = new WebAssembly.Memory({initial: 2657, shared: true, maximum: 5930}); +/** +@param {I64} a0 +@param {FuncRef} a1 +@param {FuncRef} a2 +@returns {[I64, FuncRef, FuncRef]} + */ +let fn0 = function (a0, a1, a2) { +a0?.toString(); a1?.toString(); a2?.toString(); +return [230n, a1, a2]; +}; +/** +@returns {void} + */ +let fn1 = function () { +}; +/** +@returns {void} + */ +let fn2 = function () { +}; +/** +@param {I64} a0 +@param {FuncRef} a1 +@param {FuncRef} a2 +@returns {[I64, FuncRef, FuncRef]} + */ +let fn3 = function (a0, a1, a2) { +a0?.toString(); a1?.toString(); a2?.toString(); +return [1376n, a1, a1]; +}; +/** +@param {I64} a0 +@param {FuncRef} a1 +@param {FuncRef} a2 +@returns {void} + */ +let fn4 = function (a0, a1, a2) { +a0?.toString(); a1?.toString(); a2?.toString(); +}; +let tag2 = new WebAssembly.Tag({parameters: ['i64', 'anyfunc', 'anyfunc']}); +let tag4 = new WebAssembly.Tag({parameters: []}); +let global0 = new WebAssembly.Global({value: 'i64', mutable: true}, 2544446354n); +let table0 = new WebAssembly.Table({initial: 90, element: 'externref'}); +let table2 = new WebAssembly.Table({initial: 80, element: 'anyfunc', maximum: 80}); +let table4 = new WebAssembly.Table({initial: 21, element: 'externref', maximum: 557}); +let table6 = new WebAssembly.Table({initial: 12, element: 'externref', maximum: 541}); +let m1 = {fn0, fn1, memory0, table5: table2, table6, table7: table4, table8: table4, tag3: tag2, tag5: tag2}; +let m0 = {fn2, fn4, table4, tag2}; +let m2 = {fn3, global0, table0, table1: table0, table2, table3: table0, tag4}; +let importObject0 = /** @type {Imports2} */ ({extra, m0, m1, m2}); +let i0 = await instantiate('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', importObject0); +let {fn5, fn6, global1, global2, global3, global4, global5, global6, global7, global8, global9, global10, global11, global12, global13, global14, memory1, table9, table10, table11, table12, table13, table14, table15, tag0, tag1} = /** + @type {{ +fn5: () => I32, +fn6: () => [I64, FuncRef], +global1: WebAssembly.Global, +global2: WebAssembly.Global, +global3: WebAssembly.Global, +global4: WebAssembly.Global, +global5: WebAssembly.Global, +global6: WebAssembly.Global, +global7: WebAssembly.Global, +global8: WebAssembly.Global, +global9: WebAssembly.Global, +global10: WebAssembly.Global, +global11: WebAssembly.Global, +global12: WebAssembly.Global, +global13: WebAssembly.Global, +global14: WebAssembly.Global, +memory1: WebAssembly.Memory, +table9: WebAssembly.Table, +table10: WebAssembly.Table, +table11: WebAssembly.Table, +table12: WebAssembly.Table, +table13: WebAssembly.Table, +table14: WebAssembly.Table, +table15: WebAssembly.Table, +tag0: WebAssembly.Tag, +tag1: WebAssembly.Tag + }} */ (i0.instance.exports); +table0.set(34, table10); +table11.set(22, table4); +table0.set(53, table0); +table10.set(3, table10); +table4.set(14, table9); +table15.set(68, table10); +global2.value = 'a'; +global10.value = null; + +try { + for (let k=0; k<16; k++) { + let zzz = fn6(); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } + if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } + let [r0, r1] = zzz; + r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') {} else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) {} else { throw e; } +} + +})().then(() => { +}).catch(e => { +}) diff --git a/test/js/bun/jsc-stress/fixtures/wasm/omg-recompile-from-two-bbq.js b/test/js/bun/jsc-stress/fixtures/wasm/omg-recompile-from-two-bbq.js new file mode 100644 index 0000000000..07961645dd --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/omg-recompile-from-two-bbq.js @@ -0,0 +1,34 @@ +// @bun +function instantiate(moduleBase64, importObject) { + let bytes = Uint8Array.fromBase64(moduleBase64); + return WebAssembly.instantiate(bytes, importObject); + } + const report = $.agent.report; + const isJIT = callerIsBBQOrOMGCompiled; +const extra = {isJIT}; +(async function () { +let tag4 = new WebAssembly.Tag({parameters: []}); +let tag5 = new WebAssembly.Tag({parameters: ['f64', 'externref']}); +let tag6 = new WebAssembly.Tag({parameters: ['anyfunc']}); +let global0 = new WebAssembly.Global({value: 'i32', mutable: true}, 1131948438); +let global1 = new WebAssembly.Global({value: 'anyfunc', mutable: true}, null); +let global2 = new WebAssembly.Global({value: 'i32', mutable: true}, 3536421988); +let global3 = new WebAssembly.Global({value: 'f64', mutable: true}, 218369.39111889654); +let global4 = new WebAssembly.Global({value: 'i64', mutable: true}, 1876304460n); +let table0 = new WebAssembly.Table({initial: 67, element: 'anyfunc'}); +let table2 = new WebAssembly.Table({initial: 66, element: 'anyfunc', maximum: 901}); +let m0 = {global0, global1, global4, table1: table0, table2, tag4, tag5}; +let m2 = {global2, table0, tag6}; +let m1 = {global3, tag7: tag6}; +let importObject0 = /** @type {Imports2} */ ({extra, m0, m1, m2}); +let i0 = await instantiate('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', importObject0); +let {fn0, fn1, global5, global6, global7, global8, table3, table4, table5, table6, table7, table8, table9, table10, table11, table12, table13, tag0, tag1, tag2, tag3} = /** + }} */ (i0.instance.exports); +try { + for (let k=0; k<24; k++) { + let zzz = fn0(fn1); + } +} catch (e) { +} +})().then(() => { +}) \ No newline at end of file diff --git a/test/js/bun/jsc-stress/fixtures/wasm/omg-tail-call-clobber-pinned-registers.js b/test/js/bun/jsc-stress/fixtures/wasm/omg-tail-call-clobber-pinned-registers.js new file mode 100644 index 0000000000..2ebd32a384 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/omg-tail-call-clobber-pinned-registers.js @@ -0,0 +1,4033 @@ +// @bun +//@ runDefaultWasm("--useDollarVM=1", "--jitPolicyScale=0.1") +function instantiate(moduleBase64, importObject) { + let bytes = Uint8Array.fromBase64(moduleBase64); + return WebAssembly.instantiate(bytes, importObject); + } + const log = function (msg) { }; + const report = $.agent.report; + const isJIT = callerIsBBQOrOMGCompiled; +const extra = {isJIT}; +(async function () { +/** +@returns {I32} + */ +let fn0 = function () { + +return 85; +}; +/** +@returns {void} + */ +let fn1 = function () { +}; +/** +@returns {[I32, F32, FuncRef]} + */ +let fn2 = function () { + +return [12, 3.8201190663768596e40, null]; +}; +/** +@returns {void} + */ +let fn3 = function () { +}; +/** +@returns {void} + */ +let fn4 = function () { +}; +/** +@returns {void} + */ +let fn5 = function () { +}; +/** +@returns {void} + */ +let fn6 = function () { +}; +/** +@returns {void} + */ +let fn7 = function () { +}; +/** +@returns {I32} + */ +let fn8 = function () { + +return 6; +}; +let tag0 = new WebAssembly.Tag({parameters: []}); +let global0 = new WebAssembly.Global({value: 'i64', mutable: true}, 2880611662n); +let m0 = {fn0, fn2, fn5, fn7, fn8, tag5: tag0}; +let m2 = {fn1, fn3, fn6, global0, tag1: tag0, tag2: tag0, tag4: tag0}; +let m1 = {fn4, tag0, tag3: tag0, tag6: tag0}; +let importObject0 = /** @type {Imports2} */ ({extra, m0, m1, m2}); +let i0 = await instantiate('AGFzbQEAAAABMAdgAAF/YAV/e317fQJ+fWAFf3t9e30Ff3t9e31gBX97fXt9AGAAA399cGAAAGAAAAK7ARICbTADZm4wAAACbTIDZm4xAAUCbTADZm4yAAQCbTIDZm4zAAUCbTEDZm40AAUCbTADZm41AAUCbTIDZm42AAUCbTADZm43AAYCbTADZm44AAAFZXh0cmEFaXNKSVQAAAJtMQR0YWcwBAAFAm0yBHRhZzEEAAYCbTIEdGFnMgQABQJtMQR0YWczBAAGAm0yBHRhZzQEAAYCbTAEdGFnNQQABQJtMQR0YWc2BAAGAm0yB2dsb2JhbDADfgEDAgEGBBcGbwBScABFbwFS4wZwAEJvAUOPA28AKwUGAQOxH/o1DQMBAAUGcAx8AUTSEtihRfjL4Qt7Af0MZVyVM3bkzBQzb6lpqv4ffwtvAdBvC3AB0gMLcAHSCQt9AEMlg2NaC3wBRB7fkCdqwiCTC30BQx+/gdoLfAFEa+y2v9axOssLbwHQbwtwAdIGC34AQrOx64vx2NCJfgsHyQEVA2ZuOQAEBnRhYmxlMwEDB2dsb2JhbDgDCAhnbG9iYWwxMQMLB2dsb2JhbDIDAgZ0YWJsZTABAAZ0YWJsZTQBBAZ0YWJsZTUBBQdtZW1vcnkwAgAIZ2xvYmFsMTADCgdnbG9iYWwzAwMHZ2xvYmFsNgMGCGdsb2JhbDEyAwwEZm4xMAAKB2dsb2JhbDcDBwdnbG9iYWw1AwUGdGFibGUyAQIGdGFibGUxAQEHZ2xvYmFsOQMJB2dsb2JhbDEDAQdnbG9iYWw0AwQJwgMGBXBV0gML0gML0gEL0gcL0gcL0gUL0gML0gAL0gQL0gQL0goL0gIL0gUL0gIL0gML0gIL0gEL0gEL0gAL0gAL0gEL0gYL0gQL0gEL0gQL0gEL0gkL0gQL0gEL0gML0gAL0goL0gUL0gUL0gkL0gYL0ggL0gAL0gYL0gEL0gEL0gkL0gIL0gUL0ggL0gAL0gYL0gIL0gAL0gAL0goL0gAL0gQL0gAL0gYL0ggL0goL0goL0gYL0gIL0gkL0gQL0ggL0goL0gEL0gkL0gUL0gUL0gIL0gAL0gQL0gcL0gML0gUL0gUL0gAL0gAL0gkL0gYL0gEL0goL0gIL0gAL0gML0goLB3Ar0gAL0gML0goL0gQL0gUL0gcL0goL0gQL0gYL0gEL0gcL0goL0gcL0gUL0gkL0gIL0gQL0gQL0gcL0goL0gAL0gML0gcL0ggL0gcL0ggL0gQL0gAL0gYL0ggL0gkL0gcL0gIL0gIL0gIL0gAL0gcL0gcL0gcL0gIL0ggL0gIL0gELAwAYBgMFCQEABQcICAcIBQcIAAEAAgQFAgYIAgNBNwsAAwAICQIBQTILAAcBAwQFBgcKAgNBGAsAAQIMAQEKRQFDBAN/AX4BfQF8IwckCQYADAELDQAjCwJ+IwwMAAALUCMGi9IEBn0PC5GPuyQJQtjS7ol+JABChQH8EAJBAXAOAQAACwsDAQEA', importObject0); +let {fn9, fn10, global1, global2, global3, global4, global5, global6, global7, global8, global9, global10, global11, global12, memory0, table0, table1, table2, table3, table4, table5} = /** + @type {{ +fn9: () => void, +fn10: () => void, +global1: WebAssembly.Global, +global2: WebAssembly.Global, +global3: WebAssembly.Global, +global4: WebAssembly.Global, +global5: WebAssembly.Global, +global6: WebAssembly.Global, +global7: WebAssembly.Global, +global8: WebAssembly.Global, +global9: WebAssembly.Global, +global10: WebAssembly.Global, +global11: WebAssembly.Global, +global12: WebAssembly.Global, +memory0: WebAssembly.Memory, +table0: WebAssembly.Table, +table1: WebAssembly.Table, +table2: WebAssembly.Table, +table3: WebAssembly.Table, +table4: WebAssembly.Table, +table5: WebAssembly.Table + }} */ (i0.instance.exports); +table0.set(18, table4); +table2.set(39, table5); +table0.set(53, table4); +table0.set(61, table5); +table4.set(17, table4); +table5.set(26, table5); +table4.set(11, table5); +table0.set(32, table2); +table0.set(33, table0); +table0.set(13, table5); +table4.set(46, table0); +table5.set(6, table4); +table5.set(2, table5); +table2.set(27, table0); +table5.set(17, table4); +table4.set(21, table5); +table4.set(46, table5); +table5.set(7, table5); +global8.value = 0; +log('calling fn9'); +report('progress'); +try { + for (let k=0; k<23; k++) { + let zzz = fn9(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn10'); +report('progress'); +try { + for (let k=0; k<13; k++) { + let zzz = fn10(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +/** +@param {FuncRef} a0 +@returns {FuncRef} + */ +let fn11 = function (a0) { +a0?.toString(); +return a0; +}; +/** +@param {FuncRef} a0 +@returns {void} + */ +let fn12 = function (a0) { +a0?.toString(); +}; +/** +@param {FuncRef} a0 +@returns {void} + */ +let fn13 = function (a0) { +a0?.toString(); +}; +/** +@param {FuncRef} a0 +@returns {void} + */ +let fn14 = function (a0) { +a0?.toString(); +}; +/** +@param {FuncRef} a0 +@returns {void} + */ +let fn15 = function (a0) { +a0?.toString(); +}; +let tag13 = new WebAssembly.Tag({parameters: ['anyfunc']}); +let global13 = new WebAssembly.Global({value: 'anyfunc', mutable: true}, global11.value); +let m4 = {fn14, fn15, global14: global0, memory1: memory0, table8: table5, tag18: tag13, tag19: tag13}; +let m5 = {fn11, fn12, global13, global15: global9, global16: global2, table6: table0, table7: table5, tag13, tag14: tag13, tag15: tag13, tag16: tag13, tag17: tag13}; +let m3 = {fn13}; +let importObject1 = /** @type {Imports2} */ ({m3, m4, m5}); +let i1 = await instantiate('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', importObject1); +let {global17, global18, global19, global20, global21, global22, global23, global24, global25, global26, global27, global28, memory2, table9, table10, table11, table12, table13, tag7, tag8, tag9, tag10, tag11, tag12} = /** + @type {{ +global17: WebAssembly.Global, +global18: WebAssembly.Global, +global19: WebAssembly.Global, +global20: WebAssembly.Global, +global21: WebAssembly.Global, +global22: WebAssembly.Global, +global23: WebAssembly.Global, +global24: WebAssembly.Global, +global25: WebAssembly.Global, +global26: WebAssembly.Global, +global27: WebAssembly.Global, +global28: WebAssembly.Global, +memory2: WebAssembly.Memory, +table9: WebAssembly.Table, +table10: WebAssembly.Table, +table11: WebAssembly.Table, +table12: WebAssembly.Table, +table13: WebAssembly.Table, +tag7: WebAssembly.Tag, +tag8: WebAssembly.Tag, +tag9: WebAssembly.Tag, +tag10: WebAssembly.Tag, +tag11: WebAssembly.Tag, +tag12: WebAssembly.Tag + }} */ (i1.instance.exports); +table4.set(13, table2); +table2.set(74, table4); +table5.set(16, table10); +table10.set(37, table2); +table5.set(14, table10); +table5.set(5, table4); +table9.set(1, table0); +global22.value = 0; +global8.value = 0; +global9.value = 0; +global4.value = null; +log('calling fn9'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn9(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn10'); +report('progress'); +try { + for (let k=0; k<25; k++) { + let zzz = fn10(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn9'); +report('progress'); +try { + for (let k=0; k<23; k++) { + let zzz = fn9(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn9'); +report('progress'); +try { + for (let k=0; k<22; k++) { + let zzz = fn9(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn9'); +report('progress'); +try { + for (let k=0; k<12; k++) { + let zzz = fn9(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +/** +@param {I32} a0 +@param {FuncRef} a1 +@returns {[F64, I32]} + */ +let fn16 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [3.13448624161907e-43, 87]; +}; +/** +@param {I32} a0 +@param {FuncRef} a1 +@returns {[I32, FuncRef]} + */ +let fn18 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [75, a1]; +}; +/** +@param {I32} a0 +@param {FuncRef} a1 +@returns {[F64, I32]} + */ +let fn20 = function (a0, a1) { +a0?.toString(); a1?.toString(); +return [4.0698352600600405e-23, 65]; +}; +/** +@returns {void} + */ +let fn21 = function () { + +return fn10(); +}; +/** +@returns {void} + */ +let fn22 = function () { + +return fn10(); +}; +let tag25 = new WebAssembly.Tag({parameters: []}); +let global29 = new WebAssembly.Global({value: 'i32', mutable: true}, 3346018448); +let table15 = new WebAssembly.Table({initial: 99, element: 'anyfunc'}); +let table16 = new WebAssembly.Table({initial: 98, element: 'anyfunc', maximum: 435}); +let table17 = new WebAssembly.Table({initial: 98, element: 'externref'}); +let m6 = {fn16, fn21, global30: global27, table14: table3, table15}; +let m7 = {fn17: fn10, fn18, fn19: fn9, fn22, global31: global2, table16, table17}; +let m8 = {fn20, global29, tag25}; +let importObject2 = /** @type {Imports2} */ ({extra, m6, m7, m8}); +let i2 = await instantiate('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', importObject2); +let {fn23, fn24, global32, global33, global34, memory3, table18, table19, table20, tag20, tag21, tag22, tag23, tag24} = /** + @type {{ +fn23: () => void, +fn24: (a0: FuncRef, a1: FuncRef, a2: F32) => [ExternRef, FuncRef, I32], +global32: WebAssembly.Global, +global33: WebAssembly.Global, +global34: WebAssembly.Global, +memory3: WebAssembly.Memory, +table18: WebAssembly.Table, +table19: WebAssembly.Table, +table20: WebAssembly.Table, +tag20: WebAssembly.Tag, +tag21: WebAssembly.Tag, +tag22: WebAssembly.Tag, +tag23: WebAssembly.Tag, +tag24: WebAssembly.Tag + }} */ (i2.instance.exports); +table2.set(48, table17); +table19.set(22, table10); +table2.set(71, table5); +table10.set(14, table4); +table20.set(27, table12); +table19.set(19, table4); +table20.set(15, table17); +global28.value = null; +log('calling fn10'); +report('progress'); +try { + for (let k=0; k<17; k++) { + let zzz = fn10(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn23'); +report('progress'); +try { + for (let k=0; k<26; k++) { + let zzz = fn23(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn23'); +report('progress'); +try { + for (let k=0; k<17; k++) { + let zzz = fn23(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn23'); +report('progress'); +try { + for (let k=0; k<21; k++) { + let zzz = fn23(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn24'); +report('progress'); +try { + for (let k=0; k<22; k++) { + let zzz = fn24(fn23, fn9, global8.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn23'); +report('progress'); +try { + for (let k=0; k<16; k++) { + let zzz = fn23(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn23'); +report('progress'); +try { + for (let k=0; k<10; k++) { + let zzz = fn23(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn24'); +report('progress'); +try { + for (let k=0; k<28; k++) { + let zzz = fn24(fn9, fn9, global8.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn23'); +report('progress'); +try { + for (let k=0; k<23; k++) { + let zzz = fn23(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +let memory4 = new WebAssembly.Memory({initial: 2991, shared: true, maximum: 6859}); +/** +@param {FuncRef} a0 +@param {FuncRef} a1 +@param {F32} a2 +@returns {[ExternRef, FuncRef, I32]} + */ +let fn25 = function (a0, a1, a2) { +a0?.toString(); a1?.toString(); a2?.toString(); +return fn24(a0, a1, a2); +}; +/** +@param {FuncRef} a0 +@param {FuncRef} a1 +@param {F32} a2 +@returns {[ExternRef, FuncRef, I32]} + */ +let fn26 = function (a0, a1, a2) { +a0?.toString(); a1?.toString(); a2?.toString(); +return fn24(a0, a1, a2); +}; +/** +@returns {I32} + */ +let fn27 = function () { + +return 39; +}; +/** +@returns {I32} + */ +let fn28 = function () { + +return 33; +}; +/** +@param {FuncRef} a0 +@param {FuncRef} a1 +@param {F32} a2 +@returns {[FuncRef, FuncRef, F32]} + */ +let fn29 = function (a0, a1, a2) { +a0?.toString(); a1?.toString(); a2?.toString(); +return [a0, a0, 2.9504893834097072e-36]; +}; +let tag30 = new WebAssembly.Tag({parameters: []}); +let tag34 = new WebAssembly.Tag({parameters: []}); +let global35 = new WebAssembly.Global({value: 'anyfunc', mutable: true}, fn10); +let table25 = new WebAssembly.Table({initial: 98, element: 'anyfunc', maximum: 98}); +let table28 = new WebAssembly.Table({initial: 81, element: 'anyfunc', maximum: 81}); +let table29 = new WebAssembly.Table({initial: 99, element: 'externref', maximum: 226}); +let m9 = {fn26, fn27, global35, memory4, table29, tag31: tag24}; +let m10 = {fn25, fn28, fn29, table22: table20, table23: table18, table24: table3, table27: table10, tag30, tag33: tag0}; +let m11 = {table21: table16, table25, table26: table20, table28, tag32: tag20, tag34, tag35: tag34}; +let importObject3 = /** @type {Imports2} */ ({extra, m9, m10, m11}); +let i3 = await instantiate('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', importObject3); +let {fn30, fn31, global36, global37, global38, global39, global40, global41, global42, global43, global44, global45, memory5, table30, table31, tag26, tag27, tag28, tag29} = /** + @type {{ +fn30: (a0: FuncRef, a1: FuncRef, a2: F32) => [ExternRef, FuncRef, I32], +fn31: () => I32, +global36: WebAssembly.Global, +global37: WebAssembly.Global, +global38: WebAssembly.Global, +global39: WebAssembly.Global, +global40: WebAssembly.Global, +global41: WebAssembly.Global, +global42: WebAssembly.Global, +global43: WebAssembly.Global, +global44: WebAssembly.Global, +global45: WebAssembly.Global, +memory5: WebAssembly.Memory, +table30: WebAssembly.Table, +table31: WebAssembly.Table, +tag26: WebAssembly.Tag, +tag27: WebAssembly.Tag, +tag28: WebAssembly.Tag, +tag29: WebAssembly.Tag + }} */ (i3.instance.exports); +table10.set(15, table10); +table29.set(42, table10); +table5.set(20, table5); +table4.set(25, table30); +table10.set(38, table29); +table5.set(3, table30); +table0.set(70, table29); +table12.set(26, table17); +table12.set(30, table5); +table10.set(20, table5); +table17.set(34, table12); +table5.set(27, table5); +table20.set(10, table0); +table17.set(89, table4); +table2.set(19, table17); +table2.set(60, table12); +table4.set(54, table5); +table29.set(61, table30); +table4.set(46, table17); +table0.set(74, table30); +table19.set(1, table9); +table9.set(3, table12); +table20.set(73, table29); +global29.value = 0; +global20.value = 0n; +global28.value = null; +log('calling fn23'); +report('progress'); +try { + for (let k=0; k<10; k++) { + let zzz = fn23(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn30'); +report('progress'); +try { + for (let k=0; k<24; k++) { + let zzz = fn30(fn9, fn30, global8.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn31'); +report('progress'); +try { + for (let k=0; k<17; k++) { + let zzz = fn31(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn31'); +report('progress'); +try { + for (let k=0; k<19; k++) { + let zzz = fn31(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn31'); +report('progress'); +try { + for (let k=0; k<10; k++) { + let zzz = fn31(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn9'); +report('progress'); +try { + for (let k=0; k<18; k++) { + let zzz = fn9(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn31'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn31(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn31'); +report('progress'); +try { + for (let k=0; k<5; k++) { + let zzz = fn31(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +/** +@returns {I32} + */ +let fn32 = function () { + +return fn31(); +}; +/** +@param {F32} a0 +@param {F32} a1 +@param {FuncRef} a2 +@returns {void} + */ +let fn33 = function (a0, a1, a2) { +a0?.toString(); a1?.toString(); a2?.toString(); +}; +/** +@param {I64} a0 +@returns {void} + */ +let fn34 = function (a0) { +a0?.toString(); +}; +/** +@returns {void} + */ +let fn35 = function () { + +return fn9(); +}; +/** +@param {I64} a0 +@returns {void} + */ +let fn36 = function (a0) { +a0?.toString(); +}; +let tag39 = new WebAssembly.Tag({parameters: ['i64']}); +let tag43 = new WebAssembly.Tag({parameters: []}); +let global51 = new WebAssembly.Global({value: 'externref', mutable: true}, {}); +let global52 = new WebAssembly.Global({value: 'f32', mutable: true}, 460834.7580894743); +let m12 = {fn32, fn35, global46: global25, global48: global34, global49: global19, global50: global38, tag40: tag22, tag41: tag39, tag42: tag0, tag43}; +let m14 = {fn33, fn37: fn31, global51, tag39}; +let m13 = {fn34, fn36, global47: 451249.3192625079, global52}; +let importObject4 = /** @type {Imports2} */ ({extra, m12, m13, m14}); +let i4 = await instantiate('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', importObject4); +let {fn38, fn39, global53, global54, global55, memory6, table32, table33, table34, table35, tag36, tag37, tag38} = /** + @type {{ +fn38: () => void, +fn39: () => I32, +global53: WebAssembly.Global, +global54: WebAssembly.Global, +global55: WebAssembly.Global, +memory6: WebAssembly.Memory, +table32: WebAssembly.Table, +table33: WebAssembly.Table, +table34: WebAssembly.Table, +table35: WebAssembly.Table, +tag36: WebAssembly.Tag, +tag37: WebAssembly.Tag, +tag38: WebAssembly.Tag + }} */ (i4.instance.exports); +table2.set(22, table32); +table5.set(5, table33); +table2.set(31, table10); +table19.set(22, table5); +table29.set(12, table5); +table33.set(18, table2); +table30.set(26, table10); +table0.set(17, table32); +table19.set(13, table29); +table33.set(49, table0); +table9.set(6, table10); +table0.set(51, table20); +table29.set(48, table19); +table34.set(16, table2); +table33.set(54, table30); +table19.set(19, table2); +table19.set(0, table29); +table32.set(24, table34); +table10.set(26, table17); +table33.set(6, table4); +global29.value = 0; +global9.value = 0; +global51.value = 'a'; +log('calling fn30'); +report('progress'); +try { + for (let k=0; k<17; k++) { + let zzz = fn30(fn10, fn23, global44.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn38'); +report('progress'); +try { + for (let k=0; k<10; k++) { + let zzz = fn38(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn38'); +report('progress'); +try { + for (let k=0; k<23; k++) { + let zzz = fn38(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn38'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn38(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn39'); +report('progress'); +try { + for (let k=0; k<12; k++) { + let zzz = fn39(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn30'); +report('progress'); +try { + for (let k=0; k<6; k++) { + let zzz = fn30(fn10, fn39, global44.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn31'); +report('progress'); +try { + for (let k=0; k<13; k++) { + let zzz = fn31(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn24'); +report('progress'); +try { + for (let k=0; k<17; k++) { + let zzz = fn24(fn24, fn30, global44.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn23'); +report('progress'); +try { + for (let k=0; k<21; k++) { + let zzz = fn23(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn30'); +report('progress'); +try { + for (let k=0; k<13; k++) { + let zzz = fn30(fn23, fn39, global52.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn24'); +report('progress'); +try { + for (let k=0; k<15; k++) { + let zzz = fn24(fn24, fn24, global44.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn38'); +report('progress'); +try { + for (let k=0; k<23; k++) { + let zzz = fn38(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn38'); +report('progress'); +try { + for (let k=0; k<12; k++) { + let zzz = fn38(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +/** +@returns {void} + */ +let fn40 = function () { + +return fn9(); +}; +/** +@returns {void} + */ +let fn41 = function () { + +return fn38(); +}; +let global58 = new WebAssembly.Global({value: 'f32', mutable: true}, 13099.37117734089); +let global59 = new WebAssembly.Global({value: 'anyfunc', mutable: true}, global4.value); +let global60 = new WebAssembly.Global({value: 'f32', mutable: true}, -31170.70987303669); +let global62 = new WebAssembly.Global({value: 'i32', mutable: true}, 1893196422); +let global63 = new WebAssembly.Global({value: 'i32', mutable: true}, 1889181766); +let table37 = new WebAssembly.Table({initial: 61, element: 'externref', maximum: 78}); +let m16 = {fn40, fn42: fn9, global58, global62, table37, tag47: tag36}; +let m17 = {fn41, global57: global42, global60, global61: global36, table36: table33}; +let m15 = {global56: 388380.2152370508, global59, global63, tag48: tag22}; +let importObject5 = /** @type {Imports2} */ ({extra, m15, m16, m17}); +let i5 = await instantiate('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', importObject5); +let {global64, global65, global66, global67, global68, global69, memory7, table38, table39, tag44, tag45, tag46} = /** + @type {{ +global64: WebAssembly.Global, +global65: WebAssembly.Global, +global66: WebAssembly.Global, +global67: WebAssembly.Global, +global68: WebAssembly.Global, +global69: WebAssembly.Global, +memory7: WebAssembly.Memory, +table38: WebAssembly.Table, +table39: WebAssembly.Table, +tag44: WebAssembly.Tag, +tag45: WebAssembly.Tag, +tag46: WebAssembly.Tag + }} */ (i5.instance.exports); +table0.set(64, table39); +table5.set(5, table4); +table32.set(11, table29); +table19.set(18, table29); +table33.set(65, table17); +table9.set(10, table4); +table17.set(35, table29); +table5.set(1, table12); +table10.set(29, table33); +table4.set(30, table37); +table2.set(55, table20); +table9.set(11, table2); +table10.set(46, table37); +table10.set(20, table33); +table30.set(82, table17); +table32.set(2, table0); +table29.set(30, table34); +table5.set(14, table5); +table20.set(48, table29); +global54.value = 0n; +global36.value = 'a'; +global17.value = null; +log('calling fn24'); +report('progress'); +try { + for (let k=0; k<12; k++) { + let zzz = fn24(fn23, fn10, global8.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +/** +@param {I64} a0 +@param {ExternRef} a1 +@returns {void} + */ +let fn45 = function (a0, a1) { +a0?.toString(); a1?.toString(); +}; +/** +@param {ExternRef} a0 +@returns {ExternRef} + */ +let fn46 = function (a0) { +a0?.toString(); +return a0; +}; +/** +@returns {I32} + */ +let fn47 = function () { + +return fn31(); +}; +let tag54 = new WebAssembly.Tag({parameters: ['i64', 'externref']}); +let tag58 = new WebAssembly.Tag({parameters: ['externref']}); +let tag60 = new WebAssembly.Tag({parameters: ['anyfunc', 'anyfunc', 'i64']}); +let m20 = {fn43: fn39, table43: table25, table46: table30, table47: table35, tag54, tag56: tag38, tag59: tag58, tag60}; +let m19 = {fn44: fn31, fn47, table42: table38, table45: table10, tag57: tag36, tag58}; +let m18 = {fn45, fn46, table40: table20, table41: table1, table44: table28, table48: table10, tag55: tag20}; +let importObject6 = /** @type {Imports2} */ ({extra, m18, m19, m20}); +let i6 = await instantiate('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', importObject6); +let {fn48, fn49, fn50, global70, global71, global72, global73, global74, global75, global76, global77, global78, global79, global80, global81, memory8, table49, table50, table51, table52, table53, table54, table55, table56, tag49, tag50, tag51, tag52, tag53} = /** + @type {{ +fn48: (a0: ExternRef) => ExternRef, +fn49: (a0: FuncRef, a1: FuncRef, a2: I64) => void, +fn50: (a0: I64, a1: ExternRef) => void, +global70: WebAssembly.Global, +global71: WebAssembly.Global, +global72: WebAssembly.Global, +global73: WebAssembly.Global, +global74: WebAssembly.Global, +global75: WebAssembly.Global, +global76: WebAssembly.Global, +global77: WebAssembly.Global, +global78: WebAssembly.Global, +global79: WebAssembly.Global, +global80: WebAssembly.Global, +global81: WebAssembly.Global, +memory8: WebAssembly.Memory, +table49: WebAssembly.Table, +table50: WebAssembly.Table, +table51: WebAssembly.Table, +table52: WebAssembly.Table, +table53: WebAssembly.Table, +table54: WebAssembly.Table, +table55: WebAssembly.Table, +table56: WebAssembly.Table, +tag49: WebAssembly.Tag, +tag50: WebAssembly.Tag, +tag51: WebAssembly.Tag, +tag52: WebAssembly.Tag, +tag53: WebAssembly.Tag + }} */ (i6.instance.exports); +table29.set(75, table20); +table9.set(9, table55); +table33.set(70, table4); +table34.set(3, table9); +global0.value = 0n; +global7.value = 0; +global59.value = null; +log('calling fn9'); +report('progress'); +try { + for (let k=0; k<22; k++) { + let zzz = fn9(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn38'); +report('progress'); +try { + for (let k=0; k<20; k++) { + let zzz = fn38(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn49'); +report('progress'); +try { + for (let k=0; k<15; k++) { + let zzz = fn49(fn38, fn24, global78.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn48'); +report('progress'); +try { + for (let k=0; k<19; k++) { + let zzz = fn48(global34.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn49'); +report('progress'); +try { + for (let k=0; k<21; k++) { + let zzz = fn49(fn24, fn10, global64.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn38'); +report('progress'); +try { + for (let k=0; k<29; k++) { + let zzz = fn38(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn48'); +report('progress'); +try { + for (let k=0; k<9; k++) { + let zzz = fn48(global75.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn50'); +report('progress'); +try { + for (let k=0; k<29; k++) { + let zzz = fn50(global54.value, global81.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +/** +@returns {ExternRef} + */ +let fn53 = function () { + +return {f:42}; +}; +/** +@returns {void} + */ +let fn54 = function () { + +return fn10(); +}; +/** +@returns {void} + */ +let fn55 = function () { + +return fn10(); +}; +/** +@param {ExternRef} a0 +@param {F32} a1 +@returns {void} + */ +let fn58 = function (a0, a1) { +a0?.toString(); a1?.toString(); +}; +/** +@returns {void} + */ +let fn59 = function () { + +return fn10(); +}; +/** +@param {ExternRef} a0 +@param {F32} a1 +@returns {void} + */ +let fn60 = function (a0, a1) { +a0?.toString(); a1?.toString(); +}; +/** +@returns {void} + */ +let fn61 = function () { + +return fn9(); +}; +let tag61 = new WebAssembly.Tag({parameters: ['i32']}); +let tag65 = new WebAssembly.Tag({parameters: ['externref', 'f32']}); +let tag68 = new WebAssembly.Tag({parameters: []}); +let global82 = new WebAssembly.Global({value: 'f64', mutable: true}, 654475.7097073357); +let global83 = new WebAssembly.Global({value: 'anyfunc', mutable: true}, fn9); +let global87 = new WebAssembly.Global({value: 'anyfunc', mutable: true}, global68.value); +let m21 = {fn51: fn23, fn52: fn39, fn59, global82, global83, global86: global55, table58: table16, tag62: tag38, tag64: tag45, tag68}; +let m22 = {fn53, fn54, fn57: fn23, fn60, fn61, table57: table37, tag63: tag50, tag65, tag66: tag0, tag67: tag61}; +let m23 = {fn55, fn56: fn31, fn58, fn62: fn39, global84: global44, global85: global26, global87, table59: table31, tag61}; +let importObject7 = /** @type {Imports2} */ ({extra, m21, m22, m23}); +let i7 = await instantiate('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', importObject7); +let {fn63, fn64, fn65, fn66, fn67, fn68, global88, global89, global90, global91, global92, global93, global94, global95, global96, global97, global98, table60, table61, table62} = /** + @type {{ +fn63: () => ExternRef, +fn64: () => void, +fn65: () => void, +fn66: () => void, +fn67: (a0: I32) => void, +fn68: (a0: ExternRef) => ExternRef, +global88: WebAssembly.Global, +global89: WebAssembly.Global, +global90: WebAssembly.Global, +global91: WebAssembly.Global, +global92: WebAssembly.Global, +global93: WebAssembly.Global, +global94: WebAssembly.Global, +global95: WebAssembly.Global, +global96: WebAssembly.Global, +global97: WebAssembly.Global, +global98: WebAssembly.Global, +table60: WebAssembly.Table, +table61: WebAssembly.Table, +table62: WebAssembly.Table + }} */ (i7.instance.exports); +table2.set(46, table20); +table37.set(25, table10); +table49.set(2, table29); +table4.set(20, table55); +table9.set(12, table9); +table5.set(19, table61); +table37.set(46, table5); +table10.set(34, table52); +table2.set(45, table19); +table32.set(2, table4); +table33.set(63, table37); +table29.set(28, table37); +table20.set(17, table0); +table17.set(20, table20); +table33.set(9, table30); +table0.set(75, table10); +table34.set(18, table19); +table12.set(9, table9); +table10.set(39, table30); +table4.set(43, table2); +table39.set(69, table49); +table19.set(11, table5); +global60.value = 0; +global1.value = 0; +log('calling fn63'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn63(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn65'); +report('progress'); +try { + for (let k=0; k<28; k++) { + let zzz = fn65(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn66'); +report('progress'); +try { + for (let k=0; k<23; k++) { + let zzz = fn66(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn63'); +report('progress'); +try { + for (let k=0; k<17; k++) { + let zzz = fn63(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn68'); +report('progress'); +try { + for (let k=0; k<14; k++) { + let zzz = fn68(global91.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn24'); +report('progress'); +try { + for (let k=0; k<19; k++) { + let zzz = fn24(fn9, fn68, global58.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn67'); +report('progress'); +try { + for (let k=0; k<24; k++) { + let zzz = fn67(global66.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn64'); +report('progress'); +try { + for (let k=0; k<20; k++) { + let zzz = fn64(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn50'); +report('progress'); +try { + for (let k=0; k<20; k++) { + let zzz = fn50(global78.value, global81.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn50'); +report('progress'); +try { + for (let k=0; k<8; k++) { + let zzz = fn50(global69.value, global3.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn63'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn63(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +/** +@param {FuncRef} a0 +@param {FuncRef} a1 +@param {F32} a2 +@returns {[FuncRef, FuncRef, F32]} + */ +let fn69 = function (a0, a1, a2) { +a0?.toString(); a1?.toString(); a2?.toString(); +return [a1, a0, 9.29983885129791e-33]; +}; +/** +@returns {I32} + */ +let fn70 = function () { + +return fn31(); +}; +/** +@returns {I32} + */ +let fn71 = function () { + +return fn31(); +}; +/** +@param {FuncRef} a0 +@param {FuncRef} a1 +@param {F32} a2 +@returns {[ExternRef, FuncRef, I32]} + */ +let fn73 = function (a0, a1, a2) { +a0?.toString(); a1?.toString(); a2?.toString(); +return fn24(a0, a1, a2); +}; +/** +@param {FuncRef} a0 +@param {FuncRef} a1 +@param {F32} a2 +@returns {[FuncRef, FuncRef, F32]} + */ +let fn75 = function (a0, a1, a2) { +a0?.toString(); a1?.toString(); a2?.toString(); +return [a0, a1, 0.47701066743035864e16]; +}; +/** +@param {ExternRef} a0 +@returns {void} + */ +let fn77 = function (a0) { +a0?.toString(); +}; +/** +@param {ExternRef} a0 +@returns {void} + */ +let fn78 = function (a0) { +a0?.toString(); +}; +let global100 = new WebAssembly.Global({value: 'anyfunc', mutable: true}, global89.value); +let global102 = new WebAssembly.Global({value: 'f32', mutable: true}, 565151.8639143361); +let global104 = new WebAssembly.Global({value: 'externref', mutable: true}, {}); +let global106 = new WebAssembly.Global({value: 'f32', mutable: true}, 249230.90880255518); +let m26 = {fn70, fn71, fn72: fn39, global104, global106, memory9: memory2, table69: table4}; +let m25 = {fn69, fn74: fn49, global99: global97, global101: global55, table63: table39, table64: table28}; +let m24 = {fn73, fn75, fn76: fn31, fn77, fn78, global100, global102, global103: global82, global105: global26, table65: table29, table66: table16, table67: table25, table68: table19}; +let importObject8 = /** @type {Imports2} */ ({extra, m24, m25, m26}); +let i8 = await instantiate('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', importObject8); +let {fn79, fn80, fn81, global107, global108, global109, global110, memory10, table70, table71, table72, table73, table74, table75, table76, tag69, tag70} = /** + @type {{ +fn79: () => I32, +fn80: (a0: ExternRef) => void, +fn81: (a0: I64, a1: ExternRef) => [I64, ExternRef], +global107: WebAssembly.Global, +global108: WebAssembly.Global, +global109: WebAssembly.Global, +global110: WebAssembly.Global, +memory10: WebAssembly.Memory, +table70: WebAssembly.Table, +table71: WebAssembly.Table, +table72: WebAssembly.Table, +table73: WebAssembly.Table, +table74: WebAssembly.Table, +table75: WebAssembly.Table, +table76: WebAssembly.Table, +tag69: WebAssembly.Tag, +tag70: WebAssembly.Tag + }} */ (i8.instance.exports); +table9.set(21, table10); +table74.set(48, table33); +table19.set(16, table32); +table39.set(70, table0); +table34.set(9, table2); +table5.set(31, table30); +table55.set(78, table30); +table19.set(1, table20); +table49.set(18, table12); +table37.set(53, table9); +global23.value = 0; +global78.value = 0n; +global1.value = 0; +global79.value = 'a'; +global94.value = null; +log('calling fn31'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn31(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn81'); +report('progress'); +try { + for (let k=0; k<17; k++) { + let zzz = fn81(global78.value, global51.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn79'); +report('progress'); +try { + for (let k=0; k<14; k++) { + let zzz = fn79(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn63'); +report('progress'); +try { + for (let k=0; k<19; k++) { + let zzz = fn63(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn80'); +report('progress'); +try { + for (let k=0; k<10; k++) { + let zzz = fn80(global51.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +/** +@param {FuncRef} a0 +@param {FuncRef} a1 +@param {F32} a2 +@returns {[FuncRef, FuncRef, F32]} + */ +let fn82 = function (a0, a1, a2) { +a0?.toString(); a1?.toString(); a2?.toString(); +return [a1, a0, 7.890085854430748e38]; +}; +/** +@param {I32} a0 +@returns {I32} + */ +let fn86 = function (a0) { +a0?.toString(); +return 69; +}; +/** +@param {I32} a0 +@returns {I32} + */ +let fn89 = function (a0) { +a0?.toString(); +return 56; +}; +/** +@returns {void} + */ +let fn92 = function () { + +return fn9(); +}; +/** +@param {FuncRef} a0 +@param {FuncRef} a1 +@param {I64} a2 +@returns {void} + */ +let fn95 = function (a0, a1, a2) { +a0?.toString(); a1?.toString(); a2?.toString(); +return fn49(a0, a1, a2); +}; +/** +@returns {void} + */ +let fn98 = function () { + +return fn64(); +}; +/** +@param {FuncRef} a0 +@param {FuncRef} a1 +@param {I64} a2 +@returns {[FuncRef, FuncRef, I64]} + */ +let fn99 = function (a0, a1, a2) { +a0?.toString(); a1?.toString(); a2?.toString(); +return [a1, a1, 944n]; +}; +/** +@returns {I32} + */ +let fn100 = function () { + +return fn31(); +}; +let tag76 = new WebAssembly.Tag({parameters: []}); +let global112 = new WebAssembly.Global({value: 'f32', mutable: true}, 301414.7342333485); +let table81 = new WebAssembly.Table({initial: 55, element: 'anyfunc', maximum: 55}); +let m29 = {fn82, fn83: fn10, fn84: fn81, fn86, fn87: fn10, fn89, fn91: fn67, fn93: fn10, fn96: fn48, fn100, global111: -18796.199513700125, table78: table18, table80: table12}; +let m27 = {fn85: fn79, fn88: fn48, fn90: fn23, fn95, fn97: fn24, fn98, table81}; +let m28 = {fn92, fn94: fn63, fn99, global112, table77: table16, table79: table37, table82: table28, tag76}; +let importObject9 = /** @type {Imports2} */ ({extra, m27, m28, m29}); +let i9 = await instantiate('AGFzbQEAAAABpgEbYAABf2AAAGAAAGAAAGAJfXtwfX57cH5/AGAJfXtwfX57cH5/CX17cH1+e3B+f2AJfXtwfX57cH5/AGAAAGAAAGADcHB9A29wf2ADcHB9A3BwfWAAAX9gAABgAn5vAGACfm8Cfm9gAW8Bb2ABbwFvYANwcH4AYANwcH4DcHB+YAF/AGABfwF/YAABb2AAAGABbwBgAW8Bb2ACfm8Cfm9gAn5vAn5vAvcCHQNtMjkEZm44MgAKA20yOQRmbjgzAAcDbTI5BGZuODQADgNtMjcEZm44NQAAA20yOQRmbjg2ABQDbTI5BGZuODcAFgNtMjcEZm44OAAPA20yOQRmbjg5ABQDbTI3BGZuOTAAAwNtMjkEZm45MQATA20yOARmbjkyAAEDbTI5BGZuOTMACANtMjgEZm45NAAVA20yNwRmbjk1ABEDbTI5BGZuOTYAGANtMjcEZm45NwAJA20yNwRmbjk4ABYDbTI4BGZuOTkAEgNtMjkFZm4xMDAACwVleHRyYQVpc0pJVAAAA20yOAV0YWc3NgQADANtMjkJZ2xvYmFsMTExA30AA20yOAlnbG9iYWwxMTIDfQEDbTI4B3RhYmxlNzcBcAFJ+gYDbTI5B3RhYmxlNzgBcAEQoAYDbTI4B3RhYmxlNzkBbwEwmAcDbTI5B3RhYmxlODABbwAAA20yNwd0YWJsZTgxAXABNzcDbTI4B3RhYmxlODIBcAAUAwMCGQ4EEgRvAGFvAQ3UBG8BOcYGbwErcAUGAQOrCY8ODRsNAA0ABAADABcADAAEAAIAAQAIAAEACAAXABMGLQZ9AUPCCax2C3wBRHNNMhDWMsCVC28B0G8LbwHQbwtwAdIMC34BQufezfwECweeARAFdGFnNzMECQd0YWJsZTg1AQkFdGFnNzEEAglnbG9iYWwxMTMDAgV0YWc3NQQMBWZuMTAxABEFZm4xMDIAFAlnbG9iYWwxMTYDBgV0YWc3MgQECG1lbW9yeTExAgAHdGFibGU4NAEIBXRhZzc0BAoHdGFibGU4MwEHCWdsb2JhbDExNAMECWdsb2JhbDExNQMFCWdsb2JhbDExNwMHCYICDgEAFQMGFQwUCA4UAQ4UDgUIEREFCgYEAQEAYhQCDwYDDQcNAwUPAwAQFQMIDw8SAQkMEhIADRISCQsIChUEEggFAAIODw8CDBQRAAITBgwUChMCFQgQBxIQEgoLFAgCAwAQBwkQChMEAAQCCxMADAYOAwkHAgwGEAoTExADAgVBBAsAEA0ACxADEA0DEg4FCRMQCwMGAEEmC3AB0gALAgFBAAsABgEFCAoLEAYBQQYLcAPSAgvSFAvSFQsCBEEjCwADAxITAgRBHgsAAgQHAgFBBwsAAgYOAgVBBAsAAQkCBEEcCwABDAIBQQsLAAENBgVBDQtwAdIPCwIBQQoLAAERDAEFCqA/ArQVBAN/AX4BfQF8QvYBQQQlBxAV0UECcAQBAghDFCKKJPwQBQZwDAILJAYNAEIUBn3SD/0MjqpKozOBwhySFbg0Qr8GqiMAJAFEJ78SqEpcKbgjBQIXAhcQDgYXBhAYBhAGQ5OMX10MAwvSDAN9EBNFDQD8EAFBAnAEFQIIDAMACwAFAm8CCyAEQQFqIgRBGkkNAwwEAAsACwALAhgGFwYYBg8YAfwQB7gGewYMBgsgBkMAAIA/kiIGQwAABEJdBEAMBwsMBAELQQZwDgYAAwYJBwoJCxAQEAgQE0UNBNIG/BABQQVwDgYFAgYICQUCAQtCxwAkB0EAQQdBAvwMAAH97AFCASQH/QxNGvcbsHlqV1LekyZQ1eK1/BABQQVwDgQECAUBBwELDAELBnxCO3sjACQCJAcMAwvSFQZ8/BAHQQRwDgQGAwQHBgubRM9HYlfAH3CS0ghB/PoBQ9+Lvt0MBAsCGAJ9BgEgBUIBfCIFQitUDQMCAULhIXoCewwHAAsACxgIDAcACwALAAsMAgsjAiMBDAEBAQtCBEPuXS4TQ3ZAKSEMAAtBB0EWQQH8DAEFJAEiANIEIwUhAQJABkACfwwEAAsNARgDDAELQdbUoAENAEOOyASCJAFETC/QnmPCtggkA/wQA0ECcA4HAAABAAAAAAALDAALJAcGBwJ+DAEACyQHEAMNAPwQAA0AIwckBwIHBggCCAYLDAMLAhQaQQwOBAIEAwEEC0Og/MM0IwP8EABBBHAOBAIDAQABCwYIDAIL/BAIQQNwDgMBAAICCwYHAgsMAwALQQJwBAgFEAsgAD8ABhMNABgDIQADfAwEAAsACwMVBgMMAwELDAEACyMCJAECGAIXIwAkAQwBAAsAC0PGkk6vBnsgASQF/BABBhQGEw0A0g0DfdIFQQRBBHAOBAUGAQQFC/wQAEEEcA4EAAMFBAMLDAMLBhMNAgwECwwDCwJAEAz8EAgCFAwAAAsGFA0BAgsCFhAMIwAkAkHx+AJBAEEG/AgEAAYPAnwgAQwBAAsgAQZ7Qem+A0EEQQP8CAQADAUHCgMC0gcgAQwCAAsCASMB/QzYXKgQnjQoIrHsoc0VijPHDAEACxAMBhdBCBEPAUHulQFBo4QDQezDAfwKAAAMAgELQxHQkJv8EAQMBAv8EAYGE0ECcAQW0gEjBNIVQ3KdZ6zSD0NFL2Z3AnwQCwYDDAoLDAcACwAFQxXwwM4jB0H6AA0JJAfSACAAUA4HCAkDAQAHBgkLBhYMAwsCbwYIDAALDAMACyEB0gIGfwwHC0EGcA4FAgUIAAcGCwNADAYACyMEBn/8EAhBBXAOBQUHCAYCBQtBAXAOAQAACyQFBgvSCQZwBn0QCgwICyQBEBAMBwsgACEAJAZEK7ONFsjzbi9EznkhqGKUFXWjJAPSAtIB/QwK5upHpEtwSV7BfuiUaf7pIAD8EAEMAgsCE0EGcA4GAAQHAQYFAQsMBAsGcCMFBhAMAAvSECAA/RLSFP0MuFXjNIPZbjnM1t2CsiGxJkNXi+1/Bn0CbwwFAAshAUHUBQwCAQsjBSQEIwRCrE/SCwJ/AgsMBwALAAtBBHAOBAQDBQYFCyQGDAILDQQGCENOCcy50gcCfwwEAAsjBCEBDAEBCwwEC0EEcA4EAwIBAAML/BAGQQNwDgMAAgEAC/0M3jpbDsFJWyZjKB6koV99Dv0hAEHFAkECcA4CAQAACwwAC9IRIADSFEPtmdd/jf0TBn1BBREBAUEAEQEBAggMAAALAgIQCyMCJAEMAAALBgAjAQZvAggQEwwCAAsCBwwAAAsjBAwACyMADAELQQJwBAcCfAwBAAsABQYIGAJBBBEWAQYLIAHSDgZvPwAMAQv9DK0tjhLrC7fYFnjGuVWVx9wDfwICDAMACwALQQFwDgEBAQELQQFwDgMAAAAAC0LVvsP0gM4BIgAkBxATQQJwBAsDfiACQQFqIgJBLkkEQAwBCyAAQgm6vX0iACEA/BADDAEACwAFRN8em7F0OmJlIwAkAgNvEAM/AAYTQQFwDgEAAAALEAkjBSEBQ+ev0S4MAgALAAtBAnAEbwYLIwYCfQYAA3sgAkEBaiICQQFJDQBDGH9/CiAA0gsaJAcMBQALIwEMAQsMAQALJAEkBiAAIwYkBsIkBwYIGABDAAAAAD8ADQLSEf0M4Y//DNnmmSzKywCQsIGsphoGbwJ9/Qy0sEPJ3kjrQnZF7TCK++rDQZ/q6RtBAnAECwZ+IwQMAwALIQAgAfwQBg4EBAIEBAIF0g0aBhUjBQIPBhAMAAcHQR8CFAN/0gL8EAkMAQALAAtBAnAEQBASQQFwDgEAAAsGfCMDDAALIAACe0PwlHSH0gtBoAHBBhNBAXAOAQAACz8ADAcAC/1eCQALCwsCFyQEIwb9DAmZT2nWAvTzBWyT4DQnDqhDtLupawwCAAsACwwCCwwDCwwBC0ECcAR9AgBBiAEMAAAL/BAAGkHGAgMTQQJwBH9EAAAAAAAA8H8kA0Ht2ZUwDAAABUGp1oABQQJwBAMMAAAFCwIBCwIDDAAACwZ9IwQCbyMECyQEJAVBA0ELQQP8DAABBhYMABkGewwBCxoMAAsDfwJ/BgvSCP0MU/spiisti6vztk64z8mM9P0MCR2yCJA4mz75vFTgLEoMEyABQQcRDwEMBwALDAMACwALBhT9DJcRZicC/sPTmiysSsLtRFL9qQH9YER2zFnV2o2mlv0iAf0fAfwQAw0BDAYLIAJBAWoiAkEqSQ0CDAEBC0H6AyADQQFqIgNBCUkNAUECcA4CAgQCAAALAhNBAXAOAQAAAQELRApWCnwcLQ1S/RRB7+QBIAJBAWoiAkEnSQQUDAELEARBAnAEAgsgAQwCAAtBAnAEfQYCDAALIwE/AEEDcA4DAAMBAAVEAXGxm5S6s6EkAwIICwJw0ggaQsDy7MTBjZjcAnskB0EPJQELQfYBIwAMAwALBULBjePrZyQHEAVD3RsfWQwCAAv9DAp3gxRv92ShKcAeLbcvIVwaDAEFQQQlAgsGQAsGGAshAURIPFXr/ZvxHpskAxATGiMAC/0gAiMC/SADRG03NJys+IWb/SIAQcQARLT885+ILff/A30CFvwQBUEBcA4BAAAAAAtDQ0XjWSAABm9BrrMoGiADQQFqIgNBI0kNASMECwwBAAskAiQDQgokBwN+IwQGbyABCxAGQvq62N7QuwMkB0HDubwCQqjb/rqL8gAkBz8ABhQCEwYUDAILDAEAC0GwjqfLAAYUCwITDAEAC0EWC0ECcAR/Qc75sOh4BkAGAAIAIAdEAAAAAAAA8D+gIgdEAAAAAAAALEBjDQQGDAMWQQAMBQALAgIgAQIPCwYQRFUa13lMA+7WJAML0goaQQcRGAEhAQsCAwsLIAZDAACAP5IiBkMAAIA/XQRADAULDAIACwtCET8ADAELQQJwBAIFC0G46oAHDAAFIARBAWoiBEEPSQ0BQuoARFYZe+NhCVXM0gYaJAMkB0EA/BADDAAAC0ECcAQUIwQkBf0ML/nMB88/mT691zRr+72N4wJ+QpOF65GSzc19DAAACyEAQQxBE0EA/AwAARoMAAAFC0ECcAQBBRATRQRADAILCyQFQeCAu94AEAcGE0EBcA4BAAALIQFC8wELIAEPC+cpBQB+A38BfgF9AXxBBBEIAUSXmelD/7llNyMGRAAAAAAAAAAAIwBDURmD3SABAxf8EAIGE0ECcAQHEANBAnAOAgEAAAsGFQwBCyAGQwAAgD+SIgZDAABwQV0NAQYQBhhBBxEYAQwACyMFBhADDxAGEAYCDwZADAULDAAACyIBIAJBAWoiAkESSQQPDAELDAIACyIBBwgjAiMFQ4XfPgW7BnAGAAwEC0EBcA4BAwMLQwWSjTi7IwJBogEQBw0CQ/4KFUQ/AAZA0gRDluxxcbwNANIEIAD9EkEEQTlBCPwMAQEjA9IL/BAAIAD9DAVAEtDmVxa1ZEz6lmBosyVBy+Wo2wQNA9ID0hQjBSQFIwNDlZvRf40JAQscAX0gAdIBQ5LB15wkAT8AQQFwDgECAgALDAALIwQkBSEBBgAMAQELBhMOAwEAAAELIwL9DEBoWRJnnYACK1I0H6ivOI/SBkE0QQVBAPwMAATSBkSmACz+jaelVwJwBgEGeyMABnv8EAhEI1tov/2X0vBE4erx9yg68/9BEw0EoUHlAA0CQRkOAgIEBAsgACQHDAAL/Qx/90KPbYmgmtv1MJkJFIlwAn7SEkLKNQwAAAs/AEECcA4CAAICAAtB7gANAQwBAAtEVF8hllHhKIIDfUSKQj0RAHnn6QJw0gUgANICRNdFp8+P+oVS0gTSAdIVIwICbwwDAAsACwALJAEGQAwBCz8AQQFwDgEAAAALIANBAWoiA0EaSQQPDAELEAYGDyAFQgF8IgVCD1QNAUNHqsv/JAIMAAsDDyIBBhckBSMA/BACQQFwDgEAAAvSBEGMAQYTQQFwDgEAAAsgARAOJAVEcwVOdIKW+X+9IQBBABAHAhMNAEEJQeEAQQD8DAEBDAALIAEQBiIBAnzSAUHV0t8iAnAGDAwACyABBntC156KkH+6DAILQ4qGpLL9IALSA0G4sPzaeP0Q/foBQaHgvwSz/QzduIe2HCoRsvsz6rjqx+oj/f4BIwEGfv0MMAFZkqvM6x6qiQu+2hwOH9INQt6W16rm/N8AIwHSFCMAQhkMAAALQRFB0gBBAfwMAQXDIwUhASQHJAJCvQHSAiMB/BADQQJwBHACAAJ+0gUgAfwQBwwBAAsAC0ECcARwBgsGCwYDBgACQAwCAAsCfQYI/QyvJlzSN2hbIuVObDwCao+b0gRDrhgfPAwBCwwCC9IOQQcgAAJwAwtEmMz9+euVppgMCQALAAsMBAsMAQEL0gBE0HGUzgwn2foMBQtEnNtU/kiS9v8kA/wQBnAlBiAEQQFqIgRBAEkNBiQEAnv8EAf8EAJwJQL9DL2dF9sMW6Vy6dyzSyV4KHkMAAAL/ZQB/SEB/BAIDQQMBAvSBESF8zKouYnu2wwDBRAIAgL8EAZBAXAOAQAACwYDAhUMAQALEAYgB0QAAAAAAADwP6AiB0QAAAAAAAAwQGMEDwwHCwMQRLWHiSlV/9Pn/BAJQykBuST9E/0VAkEBcA4BAQELIwJDWvKP4f0T0gbSAkQR+8GbjWtTxAwEAAALBgEMAAsQAwZAA0BD8YLu9PwA/Qz/32i2aYt5Cp8oEcZWKxPcIAH9DPUhSECuQq867N34zOWG39pB9p+8tQFBAXAOAQEBCwZ7AnAMAgALDAMLBnwjACQCAgIgAAZ+DAML/BAAEAdBAnAOAgACAgvSEEH6AUEBcA4BAQELJAP97wH8EAMNAP1/IADSAyMFIwKLBm8MAQsgBEEBaiIEQQVJDQYQE0UNBhAGJAT8BSQHJAVDokEwp/wQAkEBcA4BAAABC0ECcAQWAnvSAdIUIAE/AEEBcA4BAQELQbPTvdICQQFwDgEAAAsCCAwAAAsjBkPgknB60gHSBSAA/BAIBhMOAQAAC0EFQT5BDPwMAQUkByMEIAVCAXwiBUIOVA0FAg/8EAYNANIFIAHSB/wQASMEIANBAWoiA0EHSQQPDAYLQQ1BOEEk/AwBBCAEQQFqIgRBFkkNBSAGQwAAgD+SIgZDAABAQV0NBSQFIwckB0ECcAQHDAAABQwAAAsgAQYQDAALEBNFBA8MBwsQE0UNBSAFQgF8IgVCIFQEDwwHCz8AQ31u98MCcAYCDAAL/BAHAhNBAXAOAQAAC0H7wquhAkKfys2aya2h9RFEXIKEuoNG8UVBCRAJQwhgbQEkAgwFAAv8EAkCbyABA29Epz1q3hfWMDMMBgALAAsGFyADQQFqIgNBHUkEDwwHCyADQQFqIgNBLUkEDwwHCyAHRAAAAAAAAPA/oCIHRAAAAAAAADZAYwQPDAgLIAJBAWoiAkEdSQ0HQQgREAEGFwIPBhAYASAAtCMD0gv9DFxXSKHSK2bHnbF0XskRmU5B84PinwEGFEECcAR9Qsu759a5r9u8BadBAnAOAgQDAwUgAP0SPwAMAQALJAL8EAECEwYTDgQFAAQBBQv8EAZBA3AOBgMDBAMEAAALDAMLQQJwDgECAQsgBEEBaiIEQQlJDQggAkEBaiICQSlJBA8MCQsgBUIBfCIFQgFUBA8MCQs/AEP0wt9D0gj9DJH7xYebsMKoh8P2TNxK9GtDfx2tVwNADAIAC/0gAgJ7BggZ/BAEBn4GfUEUDgMEBQIFCyQBQgwYAiQHQQJwBBYjAyAA/BAEQQRwDggDBAQEAQEAAAQAC0Hj7QFBA3AOAwIAAwILDAIACyMEAw8CQBATDgMAAgMCAQsgB0QAAAAAAADwP6AiB0QAAAAAAAAqQGMNCCAEQQFqIgRBBUkNCSQEDAEAC0RodJQeH0eQhwwGAAsMAAtBA3AOAwEDAgELAm/9DGiSlLewzyC/BW26sJ/MMRdBE0ELQQD8DAAF/RUBQQJwBAL9DG1yevRExC0UUMFWJbbcyP0gACQHPwAGFCMFIAVCAXwiBUIxVAQPDAkLEAYgAkEBaiICQQNJBA8MCAtEiKfo1QYZNYgMBgALQQFwDgAAC9IFIAAkB0HHDgYUQxj2RQdCLvwQBUMWDvKZ0hAgANIMIwNBDkEDQQD8DAABJAP9DBG58T1gHL1lDWMKch1Y5pgjAwZ80g7SB0Oonq6W/BABDAELIwZBmNUAAnwGB9IT/BAIDAILIAEGEAN7EAsQEwwDAAsGf0LI4O3KkajQk7p/tCMHJAckAj8ABn/9DKOIIpev7H7pH6QwpTrJmt0jAEHAvMa7f0H//wNx/QcAbCMH/R4A/foB0hP8EAMGE0EBcA4BAAALA3sgA0EBaiIDQS9JDQBC3gAgAQwDAAsjACQC/QwmiCdgJs1fs6NhlntMV9Yp/f0BIwZBAAwAAAsCfRAIQlwkBwIA0gHSB/wQBwwAAAsGFCMEBg8/AENdTcACDAIHCQYDBn4Ge0SrYgpxRpE9xAwIC/2UAdID0gzSBEH5AEEBcA4BAQEBCyQHQfiTAQwHCyAAIwcCcAYB0grSEQZ9IwQGGERkI22aDDGIjSQDEA4hAQIWEAgMAAALAhZD2X9WFiQCAgIQDAZ+/QyFbztArp0SLQJS09fL9py2RLeE8V65+ip1DAwLIwJCHSAA0gr8EAYMCQALAAsJBAALIgEMCgALDAQBC0EGQdkAQQP8DAEBBhZEE/Xjb8OYfuvSC0K5yZyRDiQH/Qwqt+fxnU0BbIYT3L885XBpBn8MAQcD0gBDZ/Pv39IA0gxBGAwACw4BAAAL0gMjBwZvQQMRAQEGf0QQTaufIB6dwyQD0g5DwmcSgwwFAQsGFAwGCwwFCwYYAw8MAQALGAQgBEEBaiIEQRJJBA8MDwv8EABBAnAEFwYPGUHj5gQMCQALEA4GfAMDIANBAWoiA0ErSQ0ABkAGcAIWIANBAWoiA0EXSQRADAQLQQQRAgEMAgALAgAMBQALDAkLDA8LDAIACyAAQeIBQQFwDgEBAQskAyAEQQFqIgRBFUkNDiADQQFqIgNBFEkEDwwQCwZ7EAMaQQkOAAELRCBKy3xHfFx9A3z8EAUNASMDDAgACwwHBUK5f/wQAAwDAAs/AAwCAAv8EAkNCNIE0gbSAdIKQZs7IAAgACEAJAcDFAwHAAtC+sbq8wEhAEH//wNxIAA9AYMB0gnSEELDAAkAC/wQBQwAC0ECcAQLBgsCBwwAAAsGewYIDAALRMOhFfHlYL+FDAwBC/2AARoGAgwAC0Hw88IAIAECDwYXIwEGbwwBAAABC/0MT0uzRy+3qz0PuwA8N81zvP0WCAwICxALBggCFQwBAAsQDgIQDAcACyMFRBKxcvQmi5ssQRNBBkEA/AwABQwNCwIWDAAAC0EjQf//A3EuAf0HBhQGfyMH/Qx2oqMKEcrsMWvP1iPsYHHl/QwOy04DCAk+DO34lPz40P4gIAEhASMEAg/SE/0MHWao329Iy4hwc9Git5vTRkGt0S39DI6KCf3nya8vofN7J4r1BTgGfUQC3QaWZEdk7gwKC/wQAQwKAAsQE0UNDwNv0hBDNhwdygwGAAs/AEEDcA4DBwIKBwtBBXAOBQIIAwUAAgELQQJwBBUGAgsjBUEHERgBAxACEAsL/BACDAgABQIDDAAAC0Gz7/ifBwQDDAAABUQ83aHcxWSNmkEADQj8EAj8EARBBHAODQkJBAQGCQQEAwYJBAkEC0EDQRhBCPwMAQEjBkSgubA7YRy82QwHAAsLDAcLQQJwBEACDAN+Bn8gB0QAAAAAAADwP6AiB0QAAAAAAADwP2MEQAwCCwIHDAQACwYAQv6svK7wAvwQBgwFC/wQAkEEcA4EBAYACQkABwQCEBAOCwwKAQsOBwEBAgIBAgECCyQHCwsGe/0MMA0T/3WYVZTHKlETgbN2FAwACwZ7/QxsWquTBeATFZe35Vfd2pWK/QygmlTi+kKeJ7FuPBx6KdKv/ToMAAvSAANwBgEMAAsgAkEBaiICQRdJBEAMAQsGfwJ+EAsGfkK1yOfu4eR6DAALCwZA/Qy7BHZxxW7unw+BB2lFoTAV0g5EVFlby6tCZvjSB0ENQcIAQQL8DAEFIwEjBv0MEKrsv1wWlT9L0OQZxCaLdESTYw++S9dgwP0iAf3BAfwQAUEBcA4BAAABAQELQ3YcvX8GQAv8EAIMAAtBAnAEDAIBDAAACwULBgD8EAYHC0HiqN09CwwBAAsMCQUQBUHoAUQAAAAAAADwfwwKAAv9DCGX/9Xcg9UIPnnEZJgCCn0gASIBIAEMAgtCvAkkB/0MXUbcwMcs3f9NfipwkenOlxpETd3EzoP+DuAMAgELAxMGFAsCcPwQACADQQFqIgNBJUkEFAwCCwwEAAsACxoYCSAFQgF8IgVCElQNCAwCCwwFGQJ/AgNB2LaTGUEBcA4BAAABCwNvQQBBAEEC/AwABAZ8AgsGCxATRQ0DQfIAGAEMAwALDAMAC/wQBwwCAAvSDT8ADAELBhMMAQsjApEkASABEAYgBUIBfCIFQhRUBA8MBwsgA0EBaiIDQRdJDQYgBkMAAIA/kiIGQwAAUEFdBA8MCAsMAQALQgUkBwYUQQJwBHDSFAJ90gT9DHEp7SlM6bucizIOFXOJcmfSEyMADAAACyQBPwAgAQIYDAAAC0EHEQ8BQQcRGAEMAgAFQQIlAPwQBQwBAAvSBRr8CQQMBAtBAnAEAxAIDAAABf0MvYmPxrG42ZaGMbep3ULTiBpBugFBAXAOAAALQ69ohACR0gpEcpiIqTs+atRB8I3J6gVBAXAOBQQEBAQEBAsDGPwQBUECcAR/QTkCE0EBcA4BAAABAQsGQAIVDAEACyAFQgF8IgVCAlQEDwwDCyQE0gUaDAAAAQALQdkCDAAABdIB0g9EiRneIUw7C+skA9IUGiAAIwEkASQHGiABIwQGEAYPCxkjBAtDH2lke/0MG7UKEnldBw6IKsXsWfdJNkHgpQJB0AFBtPQD/AsA/BAIAhMMAQALAAsCfgYLQSILGgJ70gsaQdoABhNBAXAOAQAAC/wQCUECcAR9Q39NeQoMAAAFQ8Ei3DcLJAH9DJA/CE0VB3S0XzUwaoxCJapCy379HgAMAAAL/BAAIwcMAAALxCEAGkHzERoGEAskBCMFCyACQQFqIgJBGEkEDwwFCyADQQFqIgNBLEkEDwwFCyIBAxALJAUjAUSMLNefuGlmskHQLw4BAwMLDAAFBnwjAwv9FP3tAUOPPyDF/SACGgMMIwL9ExoQECABBhggAkEBaiICQRpJDQYgBEEBaiIEQRVJDQULJAQLAgL8EAFBAXAOBwAAAAAAAAAACwIHIAAGQAYLDAELBhNBA3AOAwEAAAILCyEABgMLAhYCFiABEAYkBAsLCwZ8IwMLDAIAC0LciNmcwYKtEf0MWujFj6m+Na2JewZ10ihi3T8AGv0fAdIHIwQjAUHUuQFB0L8CQaHZAfwLAP0T/BAC/RoCGiQEGvwAEAdBAnAEDAULJAcGfPwQBBoQCP0MxGhMRHS2iOuI/NZsNKWf9RpE3wgSssV8XI8/AEECcA4CAAIAAQsjASQCDAELJAb8EABwIwYmABpENCgF7qzVBBcL/RQaIQEgARATRQ0ABg8GGCACQQFqIgJBJkkNAxgDCwJvBhYMAAtBzgAGFEECcAQMDAAABQYICwtBid3tgwUEf0HWAEH/BUIiJAcMAAAFAn0jAowLGv0MjAFjwL8XRxejopg5sC8xgCMFBn0CQAIVDAEACwALIADDJAcGBxgAQ+Q+yj4MAAuQBkAMAAskAiACQQFqIgJBHUkEDwwFCyAHRAAAAAAAAPA/oCIHRAAAAAAAAChAYwQPDAQLBn0jAAwAAAALJAIGbyMFDAALIAZDAACAP5IiBkMAADBBXQ0EQdbB1LJ5DAAACwYUBwIMAQsL/BAIcCUIIANBAWoiA0EmSQ0BAhALCyEBEBNFBA8MAQskBSMFJAVDySLufyQBGkERJQgiAQsgBEEBaiIEQQxJDQBCLP0S/Qx8UxUR6Inij0BT11XyEBic/bYB/QxZX1C/CRwN8Nu9BFEAnta+0gYaGtIHQaetzwgaQoKZqM6s1o2KpX8hABojBhpB1QHSDhpBAnAEAwwAAAULGiQECyQB/BAJGkSfZmzvJrDCmCQDJAIkAyQGBnzSCRoCbwJAC0EAJQMLBhcjASQBIQEZC0Ru+9H26Y3xfwvSEUKKASEAQeLcCQYUDAALAkAMAAALGtIHGhokA/0UGggHAQsLOAUCAEHgsQMLBNM5EHMCAEHbmgILAAIAQdKKAwsE6TvhXQIAQaTuAAsFKmmYtKEBCAILfLBmvsiW', importObject9); +let {fn101, fn102, global113, global114, global115, global116, global117, memory11, table83, table84, table85, tag71, tag72, tag73, tag74, tag75} = /** + @type {{ +fn101: (a0: FuncRef, a1: FuncRef, a2: I64) => [FuncRef, FuncRef, I64], +fn102: (a0: I64, a1: ExternRef) => [I64, ExternRef], +global113: WebAssembly.Global, +global114: WebAssembly.Global, +global115: WebAssembly.Global, +global116: WebAssembly.Global, +global117: WebAssembly.Global, +memory11: WebAssembly.Memory, +table83: WebAssembly.Table, +table84: WebAssembly.Table, +table85: WebAssembly.Table, +tag71: WebAssembly.Tag, +tag72: WebAssembly.Tag, +tag73: WebAssembly.Tag, +tag74: WebAssembly.Tag, +tag75: WebAssembly.Tag + }} */ (i9.instance.exports); +table39.set(73, table37); +table74.set(19, table84); +table74.set(42, table84); +table70.set(11, table84); +table71.set(23, table4); +table30.set(57, table74); +table2.set(80, table32); +global4.value = null; +log('calling fn67'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn67(global63.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn101'); +report('progress'); +try { + for (let k=0; k<15; k++) { + let zzz = fn101(fn31, fn102, global117.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn65'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn65(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn63'); +report('progress'); +try { + for (let k=0; k<8; k++) { + let zzz = fn63(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn49'); +report('progress'); +try { + for (let k=0; k<26; k++) { + let zzz = fn49(fn102, fn101, global64.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn101'); +report('progress'); +try { + for (let k=0; k<27; k++) { + let zzz = fn101(fn79, fn101, global38.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn102'); +report('progress'); +try { + for (let k=0; k<21; k++) { + let zzz = fn102(global38.value, global81.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn68'); +report('progress'); +try { + for (let k=0; k<18; k++) { + let zzz = fn68(global91.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn64'); +report('progress'); +try { + for (let k=0; k<12; k++) { + let zzz = fn64(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn67'); +report('progress'); +try { + for (let k=0; k<15; k++) { + let zzz = fn67(global63.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn80'); +report('progress'); +try { + for (let k=0; k<28; k++) { + let zzz = fn80(global114.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn50'); +report('progress'); +try { + for (let k=0; k<19; k++) { + let zzz = fn50(global0.value, global18.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn101'); +report('progress'); +try { + for (let k=0; k<27; k++) { + let zzz = fn101(fn48, fn50, global96.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn63'); +report('progress'); +try { + for (let k=0; k<22; k++) { + let zzz = fn63(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn9'); +report('progress'); +try { + for (let k=0; k<9; k++) { + let zzz = fn9(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn68'); +report('progress'); +try { + for (let k=0; k<12; k++) { + let zzz = fn68(global81.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn24'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn24(fn65, fn30, global107.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn66'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn66(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn49'); +report('progress'); +try { + for (let k=0; k<18; k++) { + let zzz = fn49(fn64, fn23, global20.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn68'); +report('progress'); +try { + for (let k=0; k<19; k++) { + let zzz = fn68(global109.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn79'); +report('progress'); +try { + for (let k=0; k<18; k++) { + let zzz = fn79(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn102'); +report('progress'); +try { + for (let k=0; k<16; k++) { + let zzz = fn102(global20.value, global3.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn23'); +report('progress'); +try { + for (let k=0; k<12; k++) { + let zzz = fn23(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn66'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn66(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn23'); +report('progress'); +try { + for (let k=0; k<23; k++) { + let zzz = fn23(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn64'); +report('progress'); +try { + for (let k=0; k<18; k++) { + let zzz = fn64(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn31'); +report('progress'); +try { + for (let k=0; k<22; k++) { + let zzz = fn31(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn79'); +report('progress'); +try { + for (let k=0; k<24; k++) { + let zzz = fn79(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn63'); +report('progress'); +try { + for (let k=0; k<25; k++) { + let zzz = fn63(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn67'); +report('progress'); +try { + for (let k=0; k<19; k++) { + let zzz = fn67(global29.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn50'); +report('progress'); +try { + for (let k=0; k<20; k++) { + let zzz = fn50(global54.value, global81.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn31'); +report('progress'); +try { + for (let k=0; k<7; k++) { + let zzz = fn31(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn38'); +report('progress'); +try { + for (let k=0; k<16; k++) { + let zzz = fn38(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn101'); +report('progress'); +try { + for (let k=0; k<20; k++) { + let zzz = fn101(fn48, fn81, global20.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn38'); +report('progress'); +try { + for (let k=0; k<29; k++) { + let zzz = fn38(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn65'); +report('progress'); +try { + for (let k=0; k<19; k++) { + let zzz = fn65(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn66'); +report('progress'); +try { + for (let k=0; k<17; k++) { + let zzz = fn66(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn80'); +report('progress'); +try { + for (let k=0; k<13; k++) { + let zzz = fn80(global114.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn66'); +report('progress'); +try { + for (let k=0; k<9; k++) { + let zzz = fn66(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn30'); +report('progress'); +try { + for (let k=0; k<10; k++) { + let zzz = fn30(fn101, fn23, global107.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn48'); +report('progress'); +try { + for (let k=0; k<15; k++) { + let zzz = fn48(global115.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn63'); +report('progress'); +try { + for (let k=0; k<7; k++) { + let zzz = fn63(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn38'); +report('progress'); +try { + for (let k=0; k<24; k++) { + let zzz = fn38(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn102'); +report('progress'); +try { + for (let k=0; k<13; k++) { + let zzz = fn102(global70.value, global81.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn50'); +report('progress'); +try { + for (let k=0; k<8; k++) { + let zzz = fn50(global70.value, global18.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn68'); +report('progress'); +try { + for (let k=0; k<29; k++) { + let zzz = fn68(global91.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn81'); +report('progress'); +try { + for (let k=0; k<17; k++) { + let zzz = fn81(global70.value, global91.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn68'); +report('progress'); +try { + for (let k=0; k<5; k++) { + let zzz = fn68(global79.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn24'); +report('progress'); +try { + for (let k=0; k<23; k++) { + let zzz = fn24(fn24, fn24, global97.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn80'); +report('progress'); +try { + for (let k=0; k<6; k++) { + let zzz = fn80(global75.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn65'); +report('progress'); +try { + for (let k=0; k<22; k++) { + let zzz = fn65(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn81'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn81(global64.value, global91.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn65'); +report('progress'); +try { + for (let k=0; k<10; k++) { + let zzz = fn65(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn38'); +report('progress'); +try { + for (let k=0; k<24; k++) { + let zzz = fn38(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn67'); +report('progress'); +try { + for (let k=0; k<12; k++) { + let zzz = fn67(global40.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn81'); +report('progress'); +try { + for (let k=0; k<5; k++) { + let zzz = fn81(global0.value, global75.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn49'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn49(fn50, fn10, global95.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn49'); +report('progress'); +try { + for (let k=0; k<27; k++) { + let zzz = fn49(fn81, fn65, global92.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn64'); +report('progress'); +try { + for (let k=0; k<8; k++) { + let zzz = fn64(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn102'); +report('progress'); +try { + for (let k=0; k<14; k++) { + let zzz = fn102(global98.value, global115.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn67'); +report('progress'); +try { + for (let k=0; k<28; k++) { + let zzz = fn67(global63.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn65'); +report('progress'); +try { + for (let k=0; k<13; k++) { + let zzz = fn65(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn48'); +report('progress'); +try { + for (let k=0; k<6; k++) { + let zzz = fn48(global88.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn23'); +report('progress'); +try { + for (let k=0; k<26; k++) { + let zzz = fn23(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn102'); +report('progress'); +try { + for (let k=0; k<25; k++) { + let zzz = fn102(global54.value, global91.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn39'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn39(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn68'); +report('progress'); +try { + for (let k=0; k<15; k++) { + let zzz = fn68(global75.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn48'); +report('progress'); +try { + for (let k=0; k<29; k++) { + let zzz = fn48(global51.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn101'); +report('progress'); +try { + for (let k=0; k<7; k++) { + let zzz = fn101(fn81, fn68, global95.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn65'); +report('progress'); +try { + for (let k=0; k<22; k++) { + let zzz = fn65(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn81'); +report('progress'); +try { + for (let k=0; k<8; k++) { + let zzz = fn81(global38.value, global114.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn80'); +report('progress'); +try { + for (let k=0; k<14; k++) { + let zzz = fn80(global10.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn101'); +report('progress'); +try { + for (let k=0; k<5; k++) { + let zzz = fn101(fn38, fn9, global117.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn39'); +report('progress'); +try { + for (let k=0; k<18; k++) { + let zzz = fn39(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn79'); +report('progress'); +try { + for (let k=0; k<27; k++) { + let zzz = fn79(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn68'); +report('progress'); +try { + for (let k=0; k<10; k++) { + let zzz = fn68(global91.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn65'); +report('progress'); +try { + for (let k=0; k<14; k++) { + let zzz = fn65(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn64'); +report('progress'); +try { + for (let k=0; k<14; k++) { + let zzz = fn64(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn63'); +report('progress'); +try { + for (let k=0; k<21; k++) { + let zzz = fn63(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn80'); +report('progress'); +try { + for (let k=0; k<5; k++) { + let zzz = fn80(global36.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn102'); +report('progress'); +try { + for (let k=0; k<25; k++) { + let zzz = fn102(global20.value, global81.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn50'); +report('progress'); +try { + for (let k=0; k<12; k++) { + let zzz = fn50(global38.value, global3.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn101'); +report('progress'); +try { + for (let k=0; k<10; k++) { + let zzz = fn101(fn101, fn67, global98.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn39'); +report('progress'); +try { + for (let k=0; k<17; k++) { + let zzz = fn39(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn79'); +report('progress'); +try { + for (let k=0; k<10; k++) { + let zzz = fn79(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn50'); +report('progress'); +try { + for (let k=0; k<13; k++) { + let zzz = fn50(global0.value, global36.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn81'); +report('progress'); +try { + for (let k=0; k<17; k++) { + let zzz = fn81(global70.value, global34.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn101'); +report('progress'); +try { + for (let k=0; k<25; k++) { + let zzz = fn101(fn30, fn31, global38.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn10'); +report('progress'); +try { + for (let k=0; k<18; k++) { + let zzz = fn10(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn30'); +report('progress'); +try { + for (let k=0; k<27; k++) { + let zzz = fn30(fn64, fn49, global60.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn80'); +report('progress'); +try { + for (let k=0; k<13; k++) { + let zzz = fn80(global51.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn101'); +report('progress'); +try { + for (let k=0; k<18; k++) { + let zzz = fn101(fn81, fn67, global69.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn48'); +report('progress'); +try { + for (let k=0; k<6; k++) { + let zzz = fn48(global115.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn49'); +report('progress'); +try { + for (let k=0; k<17; k++) { + let zzz = fn49(fn23, fn50, global20.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn80'); +report('progress'); +try { + for (let k=0; k<21; k++) { + let zzz = fn80(global3.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn80'); +report('progress'); +try { + for (let k=0; k<25; k++) { + let zzz = fn80(global91.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn79'); +report('progress'); +try { + for (let k=0; k<28; k++) { + let zzz = fn79(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn48'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn48(global115.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn31'); +report('progress'); +try { + for (let k=0; k<24; k++) { + let zzz = fn31(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn39'); +report('progress'); +try { + for (let k=0; k<13; k++) { + let zzz = fn39(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn80'); +report('progress'); +try { + for (let k=0; k<23; k++) { + let zzz = fn80(global91.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn67'); +report('progress'); +try { + for (let k=0; k<15; k++) { + let zzz = fn67(global63.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn66'); +report('progress'); +try { + for (let k=0; k<16; k++) { + let zzz = fn66(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn79'); +report('progress'); +try { + for (let k=0; k<6; k++) { + let zzz = fn79(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn101'); +report('progress'); +try { + for (let k=0; k<9; k++) { + let zzz = fn101(fn65, fn30, global64.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn48'); +report('progress'); +try { + for (let k=0; k<10; k++) { + let zzz = fn48(global10.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn68'); +report('progress'); +try { + for (let k=0; k<27; k++) { + let zzz = fn68(global114.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn79'); +report('progress'); +try { + for (let k=0; k<24; k++) { + let zzz = fn79(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn102'); +report('progress'); +try { + for (let k=0; k<20; k++) { + let zzz = fn102(global95.value, global75.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn66'); +report('progress'); +try { + for (let k=0; k<29; k++) { + let zzz = fn66(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn68'); +report('progress'); +try { + for (let k=0; k<14; k++) { + let zzz = fn68(global81.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn79'); +report('progress'); +try { + for (let k=0; k<13; k++) { + let zzz = fn79(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn102'); +report('progress'); +try { + for (let k=0; k<26; k++) { + let zzz = fn102(global20.value, global18.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn50'); +report('progress'); +try { + for (let k=0; k<13; k++) { + let zzz = fn50(global69.value, global81.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn49'); +report('progress'); +try { + for (let k=0; k<22; k++) { + let zzz = fn49(fn38, fn10, global69.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn66'); +report('progress'); +try { + for (let k=0; k<16; k++) { + let zzz = fn66(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn101'); +report('progress'); +try { + for (let k=0; k<29; k++) { + let zzz = fn101(fn9, fn67, global20.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn102'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn102(global54.value, global115.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn63'); +report('progress'); +try { + for (let k=0; k<28; k++) { + let zzz = fn63(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn81'); +report('progress'); +try { + for (let k=0; k<11; k++) { + let zzz = fn81(global20.value, global10.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn48'); +report('progress'); +try { + for (let k=0; k<15; k++) { + let zzz = fn48(global10.value); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn79'); +report('progress'); +try { + for (let k=0; k<27; k++) { + let zzz = fn79(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn102'); +report('progress'); +try { + for (let k=0; k<15; k++) { + let zzz = fn102(global98.value, global3.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn49'); +report('progress'); +try { + for (let k=0; k<19; k++) { + let zzz = fn49(fn101, fn9, global0.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn102'); +report('progress'); +try { + for (let k=0; k<6; k++) { + let zzz = fn102(global117.value, global3.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn64'); +report('progress'); +try { + for (let k=0; k<7; k++) { + let zzz = fn64(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn67'); +report('progress'); +try { + for (let k=0; k<7; k++) { + let zzz = fn67(global29.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn81'); +report('progress'); +try { + for (let k=0; k<13; k++) { + let zzz = fn81(global20.value, global88.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn31'); +report('progress'); +try { + for (let k=0; k<23; k++) { + let zzz = fn31(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn64'); +report('progress'); +try { + for (let k=0; k<25; k++) { + let zzz = fn64(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn49'); +report('progress'); +try { + for (let k=0; k<23; k++) { + let zzz = fn49(fn30, fn38, global117.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn30'); +report('progress'); +try { + for (let k=0; k<21; k++) { + let zzz = fn30(fn79, fn50, global65.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn30'); +report('progress'); +try { + for (let k=0; k<23; k++) { + let zzz = fn30(fn66, fn101, global97.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn67'); +report('progress'); +try { + for (let k=0; k<29; k++) { + let zzz = fn67(k); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn67'); +report('progress'); +try { + for (let k=0; k<12; k++) { + let zzz = fn67(global66.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn50'); +report('progress'); +try { + for (let k=0; k<12; k++) { + let zzz = fn50(global20.value, global75.value); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn66'); +report('progress'); +try { + for (let k=0; k<18; k++) { + let zzz = fn66(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn101'); +report('progress'); +try { + for (let k=0; k<18; k++) { + let zzz = fn101(fn10, fn24, global117.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn24'); +report('progress'); +try { + for (let k=0; k<25; k++) { + let zzz = fn24(fn39, fn80, global97.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 3) { throw new Error('expected array of length 3 but return value is '+zzz); } +let [r0, r1, r2] = zzz; +r0?.toString(); r1?.toString(); r2?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn64'); +report('progress'); +try { + for (let k=0; k<23; k++) { + let zzz = fn64(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn38'); +report('progress'); +try { + for (let k=0; k<25; k++) { + let zzz = fn38(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn63'); +report('progress'); +try { + for (let k=0; k<25; k++) { + let zzz = fn63(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn63'); +report('progress'); +try { + for (let k=0; k<13; k++) { + let zzz = fn63(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn65'); +report('progress'); +try { + for (let k=0; k<5; k++) { + let zzz = fn65(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn81'); +report('progress'); +try { + for (let k=0; k<12; k++) { + let zzz = fn81(global78.value, global18.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn81'); +report('progress'); +try { + for (let k=0; k<12; k++) { + let zzz = fn81(global69.value, global10.value); + if (!(zzz instanceof Array)) { throw new Error('expected array but return value is '+zzz); } +if (zzz.length != 2) { throw new Error('expected array of length 2 but return value is '+zzz); } +let [r0, r1] = zzz; +r0?.toString(); r1?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn64'); +report('progress'); +try { + for (let k=0; k<26; k++) { + let zzz = fn64(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn65'); +report('progress'); +try { + for (let k=0; k<26; k++) { + let zzz = fn65(); + if (zzz !== undefined) { throw new Error('expected undefined but return value is '+zzz); } + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn63'); +report('progress'); +try { + for (let k=0; k<16; k++) { + let zzz = fn63(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +log('calling fn39'); +report('progress'); +try { + for (let k=0; k<28; k++) { + let zzz = fn39(); + zzz?.toString(); + } +} catch (e) { + if (e instanceof WebAssembly.Exception) { + log(e); if (e.stack) { log(e.stack); } + } else if (e instanceof TypeError) { + if (e.message === 'an exported wasm function cannot contain a v128 parameter or return value') { log(e); } else { throw e; } + } else if (e instanceof WebAssembly.RuntimeError || e instanceof RangeError) { log(e); } else { throw e; } +} +let tables = [table12, table17, table2, table55, table39, table0, table19, table74, table9, table70, table72, table49, table52, table30, table33, table37, table5, table32, table34, table61, table53, table10, table4, table20, table71, table29, table85, table84, table83, table28, table13, table18, table1, table56, table15, table11, table75, table31, table38, table25, table81, table62, table3, table76, table73, table51, table16, table60, table50, table35, table54]; +for (let table of tables) { +for (let k=0; k < table.length; k++) { table.get(k)?.toString(); } +} +})().then(() => { + log('after') + report('after'); +}).catch(e => { + log(e) + log('error') + report('error'); +}) diff --git a/test/js/bun/jsc-stress/fixtures/wasm/omg-tail-call-clobber-scratch-register.js b/test/js/bun/jsc-stress/fixtures/wasm/omg-tail-call-clobber-scratch-register.js new file mode 100644 index 0000000000..62280c630c --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/omg-tail-call-clobber-scratch-register.js @@ -0,0 +1,35 @@ +// @bun +//@ skip if $architecture == "arm" +//@ runDefault("--jitPolicyScale=0") +const v39 = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([ + 0x00, 0x61, 0x73, 0x6D, 0x01, 0x00, 0x00, 0x00, 0x01, 0x23, + 0x03, 0x60, 0x00, 0x00, 0x60, 0x09, 0x7E, 0x63, 0x6C, 0x7E, + 0x7F, 0x63, 0x6F, 0x7E, 0x63, 0x71, 0x63, 0x6F, 0x7E, 0x03, + 0x7E, 0x63, 0x71, 0x63, 0x72, 0x60, 0x01, 0x63, 0x6C, 0x03, + 0x7E, 0x63, 0x71, 0x63, 0x72, 0x03, 0x03, 0x02, 0x01, 0x02, + 0x04, 0x05, 0x01, 0x63, 0x70, 0x00, 0x0A, 0x05, 0x01, 0x00, + 0x06, 0x01, 0x00, 0x07, 0x11, 0x03, 0x02, 0x77, 0x30, 0x00, + 0x00, 0x02, 0x77, 0x31, 0x00, 0x01, 0x03, 0x77, 0x74, 0x30, + 0x01, 0x00, 0x09, 0x09, 0x01, 0x02, 0x00, 0x41, 0x00, 0x0B, + 0x00, 0x01, 0x00, 0x00, 0x20, 0x19, 0x6D, 0x65, 0x74, 0x61, + 0x64, 0x61, 0x74, 0x61, 0x2E, 0x63, 0x6F, 0x64, 0x65, 0x2E, + 0x62, 0x72, 0x61, 0x6E, 0x63, 0x68, 0x5F, 0x68, 0x69, 0x6E, + 0x74, 0x01, 0x01, 0x01, 0x30, 0x01, 0x01, 0x0A, 0x92, 0x01, + 0x02, 0x1D, 0x03, 0x01, 0x7B, 0x01, 0x7E, 0x01, 0x63, 0x72, + 0x20, 0x00, 0xFD, 0x12, 0x21, 0x09, 0x42, 0x07, 0x21, 0x0A, + 0xD0, 0x72, 0x21, 0x0B, 0x20, 0x0A, 0x20, 0x06, 0x20, 0x0B, + 0x0B, 0x72, 0x0A, 0x01, 0x7F, 0x01, 0x7F, 0x01, 0x7F, 0x01, + 0x7F, 0x01, 0x63, 0x72, 0x01, 0x63, 0x71, 0x01, 0x7E, 0x01, + 0x7E, 0x01, 0x7E, 0x01, 0x7F, 0x41, 0x94, 0xFD, 0x01, 0x21, + 0x01, 0x03, 0x00, 0x41, 0x01, 0x21, 0x02, 0x20, 0x01, 0x20, + 0x02, 0x6B, 0x21, 0x03, 0x20, 0x03, 0x21, 0x01, 0x20, 0x01, + 0x0D, 0x00, 0x0B, 0x41, 0x00, 0x21, 0x04, 0xD0, 0x72, 0x21, + 0x05, 0xD0, 0x71, 0x21, 0x06, 0x42, 0xFF, 0x00, 0x21, 0x07, + 0x42, 0xE7, 0xFF, 0xFF, 0xFF, 0x01, 0x21, 0x08, 0x42, 0x09, + 0x21, 0x09, 0x41, 0x00, 0x21, 0x0A, 0x20, 0x09, 0x20, 0x00, + 0x20, 0x08, 0x20, 0x04, 0x20, 0x05, 0x20, 0x07, 0x20, 0x06, + 0x20, 0x05, 0x20, 0x08, 0x20, 0x0A, 0x13, 0x01, 0x00, 0x20, + 0x09, 0x20, 0x06, 0x20, 0x05, 0x0B, +]))); +// Don't crash. +v39.exports.w1(-900879769); diff --git a/test/js/bun/jsc-stress/fixtures/wasm/omg-tail-call-to-function-with-less-arguments.js b/test/js/bun/jsc-stress/fixtures/wasm/omg-tail-call-to-function-with-less-arguments.js new file mode 100644 index 0000000000..492d405fd0 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/omg-tail-call-to-function-with-less-arguments.js @@ -0,0 +1,9 @@ +// @bun +//@ runDefaultWasm("--jitPolicyScale=0", "--useConcurrentJIT=0") + var wasm_code = new Uint8Array([ + 0x00,0x61,0x73,0x6d,0x01,0x00,0x00,0x00,0x01,0xa7,0x80,0x80,0x80,0x00,0x03,0x60,0x02,0x7f,0x7f,0x01,0x7f,0x60,0x00,0x00,0x60,0x1a,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x7d,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x7e,0x00,0x03,0x84,0x80,0x80,0x80,0x00,0x03,0x00,0x02,0x01,0x04,0x85,0x80,0x80,0x80,0x00,0x01,0x70,0x01,0x01,0x01,0x05,0x84,0x80,0x80,0x80,0x00,0x01,0x01,0x01,0x01,0x07,0x88,0x80,0x80,0x80,0x00,0x01,0x04,0x6d,0x61,0x69,0x6e,0x00,0x00,0x09,0x89,0x80,0x80,0x80,0x00,0x01,0x04,0x41,0x00,0x0b,0x01,0xd2,0x02,0x0b,0x0a,0x92,0x82,0x80,0x80,0x00,0x03,0xf9,0x81,0x80,0x80,0x00,0x00,0x03,0x40,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xf8,0xac,0xd1,0x91,0x01,0x42,0xf8,0xac,0xd1,0x91,0x01,0x42,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xf8,0xac,0xd1,0x91,0x01,0x42,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x43,0xb4,0xa2,0x91,0x4d,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x42,0xef,0x9b,0xaf,0xcd,0xf8,0xac,0xd1,0x91,0x01,0x10,0x01,0x20,0x00,0x41,0x01,0x6b,0x22,0x00,0x0d,0x00,0x0b,0x41,0x00,0x0b,0x87,0x80,0x80,0x80,0x00,0x00,0x41,0x00,0x13,0x01,0x00,0x0b,0x82,0x80,0x80,0x80,0x00,0x00,0x0b, +]); + var wasm_module = new WebAssembly.Module(wasm_code); + var wasm_instance = new WebAssembly.Instance(wasm_module); + var f = wasm_instance.exports.main; + f(100000); diff --git a/test/js/bun/jsc-stress/fixtures/wasm/tail-call-should-consume-stack-in-bbq.js b/test/js/bun/jsc-stress/fixtures/wasm/tail-call-should-consume-stack-in-bbq.js new file mode 100644 index 0000000000..9a1ddf3851 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/tail-call-should-consume-stack-in-bbq.js @@ -0,0 +1,152 @@ +// @bun +/* +(module + (tag $nonzero (param)) + (tag $zero (param)) + + (type $i32-i32 (func (param i32) (result i32))) + (table $countdown-table funcref (elem $countdown-indirect)) + + (func $countdown (param i32) (result i32) (local f32) + f32.const 42 + local.set 1 + + try + local.get 0 + i32.const 0 + i32.eq + if + throw $zero + else + throw $nonzero + end + catch $nonzero + local.get 0 + local.get 0 + i32.add + + local.get 0 + i32.const 1 + i32.sub + return_call $countdown + catch_all + end + + f32.const 0 + local.get 1 + f32.add + i32.trunc_f32_u + ) + + (func $countdown-indirect (param i32) (result i32) (local f32) + f32.const 42 + local.set 1 + + try + local.get 0 + i32.const 0 + i32.eq + if + throw $zero + else + throw $nonzero + end + catch $nonzero + local.get 0 + local.get 0 + i32.add + + local.get 0 + i32.const 1 + i32.sub + i32.const 0 + return_call_indirect $countdown-table (type $i32-i32) + catch_all + end + + f32.const 0 + local.get 1 + f32.add + i32.trunc_f32_u + ) + + (func $countdown-ref (param i32) (result i32) (local f32) + f32.const 42 + local.set 1 + + try + local.get 0 + i32.const 0 + i32.eq + if + throw $zero + else + throw $nonzero + end + catch $nonzero + local.get 0 + local.get 0 + i32.add + + local.get 0 + i32.const 1 + i32.sub + ref.func $countdown-ref + return_call_ref $i32-i32 + catch_all + end + + f32.const 0 + local.get 1 + f32.add + i32.trunc_f32_u + ) + + (func (export "main") + block + block + i32.const 100000 + call $countdown + i32.const 42 + i32.eq + br_if 0 + unreachable + end + i32.const 100000 + call $countdown-indirect + i32.const 42 + i32.eq + br_if 0 + unreachable + end + i32.const 100000 + call $countdown-ref + i32.const 42 + i32.eq + br_if 0 + unreachable + ) +) +*/ + +var code = new Uint8Array([ + 0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x09, 0x02, 0x60, 0x01, 0x7f, 0x01, 0x7f, 0x60, 0x00, 0x00, + 0x03, 0x05, 0x04, 0x00, 0x00, 0x00, 0x01, 0x04, 0x05, 0x01, 0x70, 0x01, 0x01, 0x01, 0x0d, 0x05, 0x02, 0x00, 0x01, + 0x00, 0x01, 0x07, 0x08, 0x01, 0x04, 0x6d, 0x61, 0x69, 0x6e, 0x00, 0x03, 0x09, 0x0b, 0x02, 0x00, 0x41, 0x00, 0x0b, + 0x01, 0x01, 0x03, 0x00, 0x01, 0x02, 0x0a, 0xdb, 0x01, 0x04, 0x36, 0x01, 0x01, 0x7d, 0x43, 0x00, 0x00, 0x28, 0x42, + 0x21, 0x01, 0x06, 0x40, 0x20, 0x00, 0x41, 0x00, 0x46, 0x04, 0x40, 0x08, 0x01, 0x05, 0x08, 0x00, 0x0b, 0x00, 0x07, + 0x00, 0x20, 0x00, 0x20, 0x00, 0x6a, 0x1a, 0x20, 0x00, 0x41, 0x01, 0x6b, 0x12, 0x00, 0x19, 0x01, 0x0b, 0x43, 0x00, + 0x00, 0x00, 0x00, 0x20, 0x01, 0x92, 0xa9, 0x0b, 0x39, 0x01, 0x01, 0x7d, 0x43, 0x00, 0x00, 0x28, 0x42, 0x21, 0x01, + 0x06, 0x40, 0x20, 0x00, 0x41, 0x00, 0x46, 0x04, 0x40, 0x08, 0x01, 0x05, 0x08, 0x00, 0x0b, 0x00, 0x07, 0x00, 0x20, + 0x00, 0x20, 0x00, 0x6a, 0x1a, 0x20, 0x00, 0x41, 0x01, 0x6b, 0x41, 0x00, 0x13, 0x00, 0x00, 0x19, 0x01, 0x0b, 0x43, + 0x00, 0x00, 0x00, 0x00, 0x20, 0x01, 0x92, 0xa9, 0x0b, 0x38, 0x01, 0x01, 0x7d, 0x43, 0x00, 0x00, 0x28, 0x42, 0x21, + 0x01, 0x06, 0x40, 0x20, 0x00, 0x41, 0x00, 0x46, 0x04, 0x40, 0x08, 0x01, 0x05, 0x08, 0x00, 0x0b, 0x00, 0x07, 0x00, + 0x20, 0x00, 0x20, 0x00, 0x6a, 0x1a, 0x20, 0x00, 0x41, 0x01, 0x6b, 0xd2, 0x02, 0x15, 0x00, 0x19, 0x01, 0x0b, 0x43, + 0x00, 0x00, 0x00, 0x00, 0x20, 0x01, 0x92, 0xa9, 0x0b, 0x2f, 0x00, 0x02, 0x40, 0x02, 0x40, 0x02, 0x40, 0x41, 0xa0, + 0x8d, 0x06, 0x10, 0x00, 0x41, 0x2a, 0x46, 0x0d, 0x00, 0x00, 0x0b, 0x41, 0xa0, 0x8d, 0x06, 0x10, 0x01, 0x41, 0x2a, + 0x46, 0x0d, 0x00, 0x00, 0x0b, 0x41, 0xa0, 0x8d, 0x06, 0x10, 0x02, 0x41, 0x2a, 0x46, 0x0d, 0x00, 0x00, 0x0b, 0x0b +]); + +var module = new WebAssembly.Module(code); +var instance = new WebAssembly.Instance(module); +instance.exports.main() diff --git a/test/js/bun/jsc-stress/fixtures/wasm/zero-clear-bbq-address.js b/test/js/bun/jsc-stress/fixtures/wasm/zero-clear-bbq-address.js new file mode 100644 index 0000000000..0eef3a4fd3 --- /dev/null +++ b/test/js/bun/jsc-stress/fixtures/wasm/zero-clear-bbq-address.js @@ -0,0 +1,44 @@ +// @bun +/* +(module + (import "env" "memory" (memory 1 1)) + (import "env" "getOffset" (func $getOffset (result i32 i32))) + + (func (export "load") (result i32) + (call $getOffset) + (drop) + (i32.load) + ) +) +*/ +const WASM_MODULE_CODE = new Uint8Array([0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x01, 0x0a, 0x02, 0x60, 0x00, 0x02, 0x7f, 0x7f, 0x60, 0x00, 0x01, 0x7f, 0x02, 0x20, 0x02, 0x03, 0x65, 0x6e, 0x76, 0x06, 0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x02, 0x01, 0x01, 0x01, 0x03, 0x65, 0x6e, 0x76, 0x09, 0x67, 0x65, 0x74, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74, 0x00, 0x00, 0x03, 0x02, 0x01, 0x01, 0x07, 0x08, 0x01, 0x04, 0x6c, 0x6f, 0x61, 0x64, 0x00, 0x01, 0x0a, 0x0a, 0x01, 0x08, 0x00, 0x10, 0x00, 0x1a, 0x28, 0x02, 0x00, 0x0b, 0x00, 0x13, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x01, 0x0c, 0x01, 0x00, 0x09, 0x67, 0x65, 0x74, 0x4f, 0x66, 0x66, 0x73, 0x65, 0x74]); + +function main() { + const module = new WebAssembly.Module(WASM_MODULE_CODE); + + const memory = new WebAssembly.Memory({ + initial: 1, + maximum: 1 + }); + + const instance = new WebAssembly.Instance(module, { + env: { + memory, + getOffset: () => [-0x80000000, 1] + } + }); + + for (let i = 0; i < testLoopCount; i++) { + try { + // Should throw an exception + const value = instance.exports.load(); + + print(value); + return; + } catch { + + } + } +} + +main(); diff --git a/test/js/bun/jsc-stress/jsc-stress.test.ts b/test/js/bun/jsc-stress/jsc-stress.test.ts new file mode 100644 index 0000000000..c1d1973a9e --- /dev/null +++ b/test/js/bun/jsc-stress/jsc-stress.test.ts @@ -0,0 +1,202 @@ +import { describe, expect, test } from "bun:test"; +import fs from "fs"; +import { bunEnv, bunExe } from "harness"; +import path from "path"; + +const fixturesDir = path.join(import.meta.dir, "fixtures"); +const wasmFixturesDir = path.join(fixturesDir, "wasm"); + +/** + * Parse JSC option flags from //@ directives at the top of a test file. + * Converts --flag=value to BUN_JSC_flag=value environment variables. + * + * Supported directives: + * //@ runDefault("--flag=value", ...) + * //@ runFTLNoCJIT("--flag=value", ...) + * //@ runDefaultWasm("--flag=value", ...) + */ +function parseJSCFlags(filePath: string): Record { + const content = fs.readFileSync(filePath, "utf-8"); + const env: Record = {}; + + for (const line of content.split("\n")) { + if (line === "// @bun" || line.trim() === "") continue; + if (!line.startsWith("//@")) break; + + const match = line.match(/^\/\/@ (runDefault|runFTLNoCJIT|runDefaultWasm)\((.*)\)/); + if (!match) continue; + + const [, mode, argsStr] = match; + + // runFTLNoCJIT implies these flags (from WebKit's run-jsc-stress-tests) + if (mode === "runFTLNoCJIT") { + env["BUN_JSC_useFTLJIT"] = "true"; + env["BUN_JSC_useConcurrentJIT"] = "false"; + } + + // Parse explicit flags: "--key=value" + const flagPattern = /"--(\w+)=([^"]+)"/g; + let flagMatch; + while ((flagMatch = flagPattern.exec(argsStr)) !== null) { + env[`BUN_JSC_${flagMatch[1]}`] = flagMatch[2]; + } + } + + return env; +} + +const jsFixtures = [ + // FTL - Math intrinsics + "ftl-arithsin.js", + "ftl-arithcos.js", + "ftl-arithsqrt.js", + "ftl-arithtan.js", + // FTL - String ops + "ftl-string-equality.js", + "ftl-string-strict-equality.js", + "ftl-string-ident-equality.js", + "ftl-library-substring.js", + // FTL - RegExp + "ftl-regexp-exec.js", + "ftl-regexp-test.js", + // FTL - Arguments + "ftl-getmyargumentslength.js", + "ftl-getmyargumentslength-inline.js", + "ftl-get-my-argument-by-val.js", + "ftl-get-my-argument-by-val-inlined.js", + "ftl-get-my-argument-by-val-inlined-and-not-inlined.js", + // FTL - Exceptions + "ftl-call-exception.js", + "ftl-call-exception-no-catch.js", + "ftl-call-varargs-exception.js", + "ftl-try-catch-arith-sub-exception.js", + "ftl-try-catch-getter-throw.js", + "ftl-try-catch-setter-throw.js", + "ftl-try-catch-patchpoint-with-volatile-registers.js", + "ftl-try-catch-varargs-call-throws.js", + "ftl-try-catch-getter-throw-interesting-value-recovery.js", + "ftl-get-by-id-getter-exception.js", + "ftl-get-by-id-slow-exception.js", + "ftl-put-by-id-setter-exception.js", + "ftl-put-by-id-slow-exception.js", + "ftl-operation-exception.js", + "ftl-shr-exception.js", + "ftl-sub-exception.js", + "ftl-xor-exception.js", + // FTL - Property access + "ftl-reallocatepropertystorage.js", + "ftl-checkin.js", + "ftl-checkin-variable.js", + // FTL - OSR / Numeric / Misc + "ftl-force-osr-exit.js", + "ftl-negate-zero.js", + "ftl-has-a-bad-time.js", + "ftl-materialize-new-array-buffer.js", + "ftl-tail-call.js", + "ftl-library-inlining-random.js", + "ftl-library-inlining-loops.js", + "ftl-new-negative-array-size.js", + "ftl-in-overflow.js", + // DFG + "dfg-ssa-swap.js", + "dfg-to-primitive-pass-symbol.js", + "dfg-strength-reduction-on-mod-should-handle-INT_MIN.js", + "dfg-put-by-val-direct-with-edge-numbers.js", + "dfg-create-arguments-inline-alloc.js", + "dfg-internal-function-call.js", + "dfg-internal-function-construct.js", + "dfg-rare-data.js", + "dfg-ai-fold-bigint.js", + "dfg-node-convert-to-constant-must-clear-varargs-flags.js", + "dfg-try-catch-wrong-value-recovery-on-ic-miss.js", + "dfg-exception-try-catch-in-constructor-with-inlined-throw.js", + "dfg-call-class-constructor.js", + "dfg-osr-entry-should-not-use-callframe-argument.js", + // Allocation sinking / OSR / LICM + "varargs-inlined-simple-exit.js", + "loop-unrolling.js", + "licm-no-pre-header.js", +]; + +const wasmFixtures = [ + // BBQ + "bbq-fusedif-register-alloc.js", + "bbq-osr-with-exceptions.js", + "ipint-bbq-osr-with-try.js", + "ipint-bbq-osr-with-try2.js", + "ipint-bbq-osr-with-try3.js", + "ipint-bbq-osr-with-try4.js", + "ipint-bbq-osr-with-try5.js", + "ipint-bbq-osr-check-try-implicit-slot-overlap.js", + "ipint-bbq-osr-check-try-implicit-slot-overlap2.js", + "zero-clear-bbq-address.js", + "tail-call-should-consume-stack-in-bbq.js", + // OMG + "omg-recompile-from-two-bbq.js", + "omg-osr-stack-slot-positioning.js", + "omg-tail-call-clobber-pinned-registers.js", + "omg-tail-call-to-function-with-less-arguments.js", + "omg-tail-call-clobber-scratch-register.js", + "omg-osr-stack-check-2.js", +]; + +const preloadPath = path.join(import.meta.dir, "preload.js"); + +describe.concurrent("JSC JIT Stress Tests", () => { + describe("JS (Baseline/DFG/FTL)", () => { + for (const fixture of jsFixtures) { + test(fixture, async () => { + const fixturePath = path.join(fixturesDir, fixture); + const jscEnv = parseJSCFlags(fixturePath); + + await using proc = Bun.spawn({ + cmd: [bunExe(), "--preload", preloadPath, fixturePath], + env: { ...bunEnv, ...jscEnv }, + stdout: "pipe", + stderr: "pipe", + }); + + const [stdout, stderr, exitCode] = await Promise.all([ + new Response(proc.stdout).text(), + new Response(proc.stderr).text(), + proc.exited, + ]); + + if (exitCode !== 0) { + console.log("stdout:", stdout); + console.log("stderr:", stderr); + } + expect(exitCode).toBe(0); + }); + } + }); + + describe("Wasm (BBQ/OMG)", () => { + for (const fixture of wasmFixtures) { + test(fixture, async () => { + const fixturePath = path.join(wasmFixturesDir, fixture); + const jscEnv = parseJSCFlags(fixturePath); + + await using proc = Bun.spawn({ + cmd: [bunExe(), "--preload", preloadPath, fixturePath], + env: { ...bunEnv, ...jscEnv }, + cwd: wasmFixturesDir, + stdout: "pipe", + stderr: "pipe", + }); + + const [stdout, stderr, exitCode] = await Promise.all([ + new Response(proc.stdout).text(), + new Response(proc.stderr).text(), + proc.exited, + ]); + + if (exitCode !== 0) { + console.log("stdout:", stdout); + console.log("stderr:", stderr); + } + expect(exitCode).toBe(0); + }); + } + }); +}); diff --git a/test/js/bun/jsc-stress/preload.js b/test/js/bun/jsc-stress/preload.js new file mode 100644 index 0000000000..1e13b29452 --- /dev/null +++ b/test/js/bun/jsc-stress/preload.js @@ -0,0 +1,18 @@ +// JSC test harness polyfills for Bun +// These globals are used by JSC stress tests but are not available in Bun. + +// noInline: hints JSC to not inline the function. No-op in Bun. +globalThis.noInline = require("bun:jsc").noInline; + +// testLoopCount: iteration count to trigger JIT tier-up (Baseline -> DFG -> FTL). +globalThis.testLoopCount = 10000; + +// print: JSC's output function, mapped to console.log. +globalThis.print = console.log; + +// Wasm test polyfills +globalThis.callerIsBBQOrOMGCompiled = function () { + return 1; +}; +if (!globalThis.$) globalThis.$ = {}; +if (!$.agent) $.agent = { report: function () {} };