wasm2asm: Fix and enable a large number of spec tests (#1558)

* Import `abort` from the environment

* Add passing spec tests

* Bind the abort function

* wasm2asm: Fix name collisions

Currently function names and local names can collide in namespaces, causing
buggy results when a function intends to call another function but ends up using
a local value as the target!

This fix was required to enable the `fac` spec test

* wasm2asm: Get multiple modules in one file working

The spec tests seem to have multiple modules defined in some tests and the
invocations all use the most recently defined module. This commit updates the
`--allow-asserts` mode of wasm2asm to work with this mode of tests, enabling us
to enable more spec tests for wasm2asm.

* wasm2asm: Enable the float_literals spec test

This needed to be modified to account for how JS engines don't work with NaN
bits the same way, but it's otherwise largely the same test. Additionally it
turns out that asm.js doesn't accept either `Infinity` or `NaN` ambient globals
so they needed to get imported through the `global` variable rather than defined
as literals in code

* wasm2asm: Fix function pointer invocations

This commit fixes invocations of functions through function pointers as
previously the table names on lookup and definition were mismatched. Both tables
now go through signature-based namification rather than athe name of the type
itself.

Overall this enables a slew of spec tests

* wasm2asm: Enable the left-to-right spec test

There were two small bugs in the order of evaluation of operators with
wasm2asm. The `select` instruction would sometimes evaluate the condition first
when it was supposed to be last. Similarly a `call_indirect` instruction would
evaluate the function pointer first when it was supposed to be evaluated last.

The `select` instruction case was a relatively small fix but the one for
`call_indirect` was a bit more pessimized to generate some temporaries.
Hopefully if this becomes up a problem it can be tightened up.

* wasm2asm: Fix signed load promotions of 64-bit ints

This commit enables the `endianness` spec test which revealed a bug in 64-bit
loads from smaller sizes which were signed. Previously the upper bits of the
64-bit number were all set to zero but the fix was for signed loads to have all
the upper bits match the highest bit of the low 32 bits that we load.

* wasm2asm: Enable the `stack` spec test

Internally the spec test uses a mixture of the s-expression syntax and the wat
syntax, so this is copied over into the `wasm2asm` folder after going through
`wat2wasm` to ensure it's consistent for binaryen.

* wasm2asm: Fix unaligned loads/stores of floats

Replace these operations in `RemoveNonJSOps` by using reinterpretation to
translate floats to integers and then use the existing code for unaligned
loads/stores of integers.

* wasm2asm: Fix a tricky grow_memory codegen bug

This commit fixes a tricky codegen bug found in the `grow_memory` instruction.
Specifically if you stored the result of `grow_memory` immediately into memory
it would look like:

    HEAP32[..] = __wasm_grow_memory(..);

Here though it looks like JS evaluates the destination *before* the grow
function is called, but the grow function will invalidate the destination!
Furthermore this is actually generalizable to all function calls:

    HEAP32[..] = foo(..);

Because any function could transitively call `grow_memory`. This commit fixes
the issue by ensuring that store instructions are always considered statements,
unconditionally evaluating the value into a temporary and then storing that into
the destination. While a bit of a pessmimization for now it should hopefully fix
the bug here.

* wasm2asm: Handle offsets in tables

This commit fixes initializing tables whose elements have an initial offset.
This should hopefully help fix some more Rust code which has all function
pointers offset by default!

* Update tests

* Tweak * location on types

* Rename entries of NameScope and document fromName

* Comment on lowercase names

* Update compiled JS

* Update js test output expectation

* Rename NameScope::Global to NameScope::Top

* Switch to `enum class`

* Switch to `Fatal()`

* Add TODO for when asm.js is no longer generated

1 files changed, 389 insertions, 0 deletions

diff --git a/test/wasm2asm/stack-modified.2asm.js b/test/wasm2asm/stack-modified.2asm.js
new file mode 100644
index 000000000..18418d8b0
--- /dev/null
+++ b/test/wasm2asm/stack-modified.2asm.js
@@ -0,0 +1,389 @@
+function asmFunc(global, env, buffer) {
+ "use asm";
+ var HEAP8 = new global.Int8Array(buffer);
+ var HEAP16 = new global.Int16Array(buffer);
+ var HEAP32 = new global.Int32Array(buffer);
+ var HEAPU8 = new global.Uint8Array(buffer);
+ var HEAPU16 = new global.Uint16Array(buffer);
+ var HEAPU32 = new global.Uint32Array(buffer);
+ var HEAPF32 = new global.Float32Array(buffer);
+ var HEAPF64 = new global.Float64Array(buffer);
+ var Math_imul = global.Math.imul;
+ var Math_fround = global.Math.fround;
+ var Math_abs = global.Math.abs;
+ var Math_clz32 = global.Math.clz32;
+ var Math_min = global.Math.min;
+ var Math_max = global.Math.max;
+ var Math_floor = global.Math.floor;
+ var Math_ceil = global.Math.ceil;
+ var Math_sqrt = global.Math.sqrt;
+ var abort = env.abort;
+ var nan = global.NaN;
+ var infinity = global.Infinity;
+ var i64toi32_i32$HIGH_BITS = 0;
+ function $0(var$0, var$0$hi) {
+  var$0 = var$0 | 0;
+  var$0$hi = var$0$hi | 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$2 = 0, i64toi32_i32$5 = 0, i64toi32_i32$3 = 0, var$1$hi = 0, var$1 = 0, var$2$hi = 0, i64toi32_i32$1 = 0, var$2 = 0;
+  i64toi32_i32$0 = var$0$hi;
+  i64toi32_i32$0 = i64toi32_i32$0;
+  var$1 = var$0;
+  var$1$hi = i64toi32_i32$0;
+  i64toi32_i32$0 = 0;
+  var$2 = 1;
+  var$2$hi = i64toi32_i32$0;
+  label$1 : {
+   label$2 : do {
+    i64toi32_i32$0 = var$1$hi;
+    i64toi32_i32$0 = i64toi32_i32$0;
+    i64toi32_i32$2 = var$1;
+    i64toi32_i32$1 = 0;
+    i64toi32_i32$3 = 0;
+    if ((i64toi32_i32$2 | 0) == (i64toi32_i32$3 | 0) & (i64toi32_i32$0 | 0) == (i64toi32_i32$1 | 0) | 0) break label$1; else label$5 : {
+     i64toi32_i32$2 = var$1$hi;
+     i64toi32_i32$2 = var$2$hi;
+     i64toi32_i32$2 = var$1$hi;
+     i64toi32_i32$0 = var$2$hi;
+     i64toi32_i32$0 = __wasm_i64_mul(var$1 | 0, i64toi32_i32$2 | 0, var$2 | 0, i64toi32_i32$0 | 0) | 0;
+     i64toi32_i32$2 = i64toi32_i32$HIGH_BITS;
+     i64toi32_i32$2 = i64toi32_i32$2;
+     var$2 = i64toi32_i32$0;
+     var$2$hi = i64toi32_i32$2;
+     i64toi32_i32$2 = var$1$hi;
+     i64toi32_i32$2 = i64toi32_i32$2;
+     i64toi32_i32$3 = var$1;
+     i64toi32_i32$0 = 0;
+     i64toi32_i32$1 = 1;
+     i64toi32_i32$5 = (i64toi32_i32$3 >>> 0 < i64toi32_i32$1 >>> 0) + i64toi32_i32$0 | 0;
+     i64toi32_i32$5 = i64toi32_i32$2 - i64toi32_i32$5 | 0;
+     i64toi32_i32$5 = i64toi32_i32$5;
+     var$1 = i64toi32_i32$3 - i64toi32_i32$1 | 0;
+     var$1$hi = i64toi32_i32$5;
+    };
+    continue label$2;
+    break label$2;
+   } while (1);
+  };
+  i64toi32_i32$5 = var$2$hi;
+  i64toi32_i32$5 = i64toi32_i32$5;
+  i64toi32_i32$5 = i64toi32_i32$5;
+  i64toi32_i32$5 = i64toi32_i32$5;
+  i64toi32_i32$3 = var$2;
+  i64toi32_i32$HIGH_BITS = i64toi32_i32$5;
+  return i64toi32_i32$3 | 0;
+ }
+ 
+ function $1(var$0, var$0$hi) {
+  var$0 = var$0 | 0;
+  var$0$hi = var$0$hi | 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$2 = 0, i64toi32_i32$5 = 0, i64toi32_i32$3 = 0, var$1$hi = 0, var$1 = 0, var$2$hi = 0, i64toi32_i32$1 = 0, var$2 = 0;
+  i64toi32_i32$0 = var$0$hi;
+  i64toi32_i32$0 = i64toi32_i32$0;
+  var$1 = var$0;
+  var$1$hi = i64toi32_i32$0;
+  i64toi32_i32$0 = 0;
+  var$2 = 1;
+  var$2$hi = i64toi32_i32$0;
+  label$1 : {
+   label$2 : do {
+    i64toi32_i32$0 = var$1$hi;
+    i64toi32_i32$0 = i64toi32_i32$0;
+    i64toi32_i32$2 = var$1;
+    i64toi32_i32$1 = 0;
+    i64toi32_i32$3 = 0;
+    if ((i64toi32_i32$2 | 0) == (i64toi32_i32$3 | 0) & (i64toi32_i32$0 | 0) == (i64toi32_i32$1 | 0) | 0) break label$1; else block : {
+     i64toi32_i32$2 = var$1$hi;
+     i64toi32_i32$2 = var$2$hi;
+     i64toi32_i32$2 = var$1$hi;
+     i64toi32_i32$0 = var$2$hi;
+     i64toi32_i32$0 = __wasm_i64_mul(var$1 | 0, i64toi32_i32$2 | 0, var$2 | 0, i64toi32_i32$0 | 0) | 0;
+     i64toi32_i32$2 = i64toi32_i32$HIGH_BITS;
+     i64toi32_i32$2 = i64toi32_i32$2;
+     var$2 = i64toi32_i32$0;
+     var$2$hi = i64toi32_i32$2;
+     i64toi32_i32$2 = var$1$hi;
+     i64toi32_i32$2 = i64toi32_i32$2;
+     i64toi32_i32$3 = var$1;
+     i64toi32_i32$0 = 0;
+     i64toi32_i32$1 = 1;
+     i64toi32_i32$5 = (i64toi32_i32$3 >>> 0 < i64toi32_i32$1 >>> 0) + i64toi32_i32$0 | 0;
+     i64toi32_i32$5 = i64toi32_i32$2 - i64toi32_i32$5 | 0;
+     i64toi32_i32$5 = i64toi32_i32$5;
+     var$1 = i64toi32_i32$3 - i64toi32_i32$1 | 0;
+     var$1$hi = i64toi32_i32$5;
+    };
+    continue label$2;
+    break label$2;
+   } while (1);
+  };
+  i64toi32_i32$5 = var$2$hi;
+  i64toi32_i32$5 = i64toi32_i32$5;
+  i64toi32_i32$5 = i64toi32_i32$5;
+  i64toi32_i32$5 = i64toi32_i32$5;
+  i64toi32_i32$3 = var$2;
+  i64toi32_i32$HIGH_BITS = i64toi32_i32$5;
+  return i64toi32_i32$3 | 0;
+ }
+ 
+ function $2(var$0, var$0$hi) {
+  var$0 = var$0 | 0;
+  var$0$hi = var$0$hi | 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$2 = 0, i64toi32_i32$5 = 0, i64toi32_i32$3 = 0, var$1$hi = 0, var$1 = 0, var$2$hi = 0, i64toi32_i32$1 = 0, var$2 = 0;
+  i64toi32_i32$0 = var$0$hi;
+  i64toi32_i32$0 = i64toi32_i32$0;
+  var$1 = var$0;
+  var$1$hi = i64toi32_i32$0;
+  i64toi32_i32$0 = 0;
+  var$2 = 1;
+  var$2$hi = i64toi32_i32$0;
+  label$1 : {
+   label$2 : do {
+    i64toi32_i32$0 = var$1$hi;
+    i64toi32_i32$0 = i64toi32_i32$0;
+    i64toi32_i32$2 = var$1;
+    i64toi32_i32$1 = 0;
+    i64toi32_i32$3 = 0;
+    if ((i64toi32_i32$2 | 0) == (i64toi32_i32$3 | 0) & (i64toi32_i32$0 | 0) == (i64toi32_i32$1 | 0) | 0) break label$1; else block : {
+     i64toi32_i32$2 = var$1$hi;
+     i64toi32_i32$2 = var$2$hi;
+     i64toi32_i32$2 = var$1$hi;
+     i64toi32_i32$0 = var$2$hi;
+     i64toi32_i32$0 = __wasm_i64_mul(var$1 | 0, i64toi32_i32$2 | 0, var$2 | 0, i64toi32_i32$0 | 0) | 0;
+     i64toi32_i32$2 = i64toi32_i32$HIGH_BITS;
+     i64toi32_i32$2 = i64toi32_i32$2;
+     var$2 = i64toi32_i32$0;
+     var$2$hi = i64toi32_i32$2;
+     i64toi32_i32$2 = var$1$hi;
+     i64toi32_i32$2 = i64toi32_i32$2;
+     i64toi32_i32$3 = var$1;
+     i64toi32_i32$0 = 0;
+     i64toi32_i32$1 = 1;
+     i64toi32_i32$5 = (i64toi32_i32$3 >>> 0 < i64toi32_i32$1 >>> 0) + i64toi32_i32$0 | 0;
+     i64toi32_i32$5 = i64toi32_i32$2 - i64toi32_i32$5 | 0;
+     i64toi32_i32$5 = i64toi32_i32$5;
+     var$1 = i64toi32_i32$3 - i64toi32_i32$1 | 0;
+     var$1$hi = i64toi32_i32$5;
+    };
+    continue label$2;
+    break label$2;
+   } while (1);
+  };
+  i64toi32_i32$5 = var$2$hi;
+  i64toi32_i32$5 = i64toi32_i32$5;
+  i64toi32_i32$5 = i64toi32_i32$5;
+  i64toi32_i32$5 = i64toi32_i32$5;
+  i64toi32_i32$3 = var$2;
+  i64toi32_i32$HIGH_BITS = i64toi32_i32$5;
+  return i64toi32_i32$3 | 0;
+ }
+ 
+ function $3(var$0, var$0$hi) {
+  var$0 = var$0 | 0;
+  var$0$hi = var$0$hi | 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$2 = 0, i64toi32_i32$5 = 0, i64toi32_i32$3 = 0, var$1$hi = 0, var$1 = 0, var$2$hi = 0, i64toi32_i32$1 = 0, var$2 = 0;
+  i64toi32_i32$0 = var$0$hi;
+  i64toi32_i32$0 = i64toi32_i32$0;
+  var$1 = var$0;
+  var$1$hi = i64toi32_i32$0;
+  i64toi32_i32$0 = 0;
+  var$2 = 1;
+  var$2$hi = i64toi32_i32$0;
+  label$1 : {
+   label$2 : do {
+    i64toi32_i32$0 = var$1$hi;
+    i64toi32_i32$0 = i64toi32_i32$0;
+    i64toi32_i32$2 = var$1;
+    i64toi32_i32$1 = 0;
+    i64toi32_i32$3 = 0;
+    if ((i64toi32_i32$2 | 0) == (i64toi32_i32$3 | 0) & (i64toi32_i32$0 | 0) == (i64toi32_i32$1 | 0) | 0) break label$1; else block : {
+     i64toi32_i32$2 = var$1$hi;
+     i64toi32_i32$2 = var$2$hi;
+     i64toi32_i32$2 = var$1$hi;
+     i64toi32_i32$0 = var$2$hi;
+     i64toi32_i32$0 = __wasm_i64_mul(var$1 | 0, i64toi32_i32$2 | 0, var$2 | 0, i64toi32_i32$0 | 0) | 0;
+     i64toi32_i32$2 = i64toi32_i32$HIGH_BITS;
+     i64toi32_i32$2 = i64toi32_i32$2;
+     var$2 = i64toi32_i32$0;
+     var$2$hi = i64toi32_i32$2;
+     i64toi32_i32$2 = var$1$hi;
+     i64toi32_i32$2 = i64toi32_i32$2;
+     i64toi32_i32$3 = var$1;
+     i64toi32_i32$0 = 0;
+     i64toi32_i32$1 = 1;
+     i64toi32_i32$5 = (i64toi32_i32$3 >>> 0 < i64toi32_i32$1 >>> 0) + i64toi32_i32$0 | 0;
+     i64toi32_i32$5 = i64toi32_i32$2 - i64toi32_i32$5 | 0;
+     i64toi32_i32$5 = i64toi32_i32$5;
+     var$1 = i64toi32_i32$3 - i64toi32_i32$1 | 0;
+     var$1$hi = i64toi32_i32$5;
+    };
+    continue label$2;
+    break label$2;
+   } while (1);
+  };
+  i64toi32_i32$5 = var$2$hi;
+  i64toi32_i32$5 = i64toi32_i32$5;
+  i64toi32_i32$5 = i64toi32_i32$5;
+  i64toi32_i32$5 = i64toi32_i32$5;
+  i64toi32_i32$3 = var$2;
+  i64toi32_i32$HIGH_BITS = i64toi32_i32$5;
+  return i64toi32_i32$3 | 0;
+ }
+ 
+ function $4(var$0, var$0$hi) {
+  var$0 = var$0 | 0;
+  var$0$hi = var$0$hi | 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$2 = 0, i64toi32_i32$5 = 0, i64toi32_i32$3 = 0, var$1$hi = 0, var$1 = 0, var$2$hi = 0, i64toi32_i32$1 = 0, var$2 = 0;
+  i64toi32_i32$0 = var$0$hi;
+  i64toi32_i32$0 = i64toi32_i32$0;
+  var$1 = var$0;
+  var$1$hi = i64toi32_i32$0;
+  i64toi32_i32$0 = 0;
+  var$2 = 1;
+  var$2$hi = i64toi32_i32$0;
+  label$1 : {
+   label$2 : do {
+    i64toi32_i32$0 = var$1$hi;
+    i64toi32_i32$0 = i64toi32_i32$0;
+    i64toi32_i32$2 = var$1;
+    i64toi32_i32$1 = 0;
+    i64toi32_i32$3 = 0;
+    if ((i64toi32_i32$2 | 0) == (i64toi32_i32$3 | 0) & (i64toi32_i32$0 | 0) == (i64toi32_i32$1 | 0) | 0) break label$1; else block : {
+     i64toi32_i32$2 = var$1$hi;
+     i64toi32_i32$2 = var$2$hi;
+     i64toi32_i32$2 = var$1$hi;
+     i64toi32_i32$0 = var$2$hi;
+     i64toi32_i32$0 = __wasm_i64_mul(var$1 | 0, i64toi32_i32$2 | 0, var$2 | 0, i64toi32_i32$0 | 0) | 0;
+     i64toi32_i32$2 = i64toi32_i32$HIGH_BITS;
+     i64toi32_i32$2 = i64toi32_i32$2;
+     var$2 = i64toi32_i32$0;
+     var$2$hi = i64toi32_i32$2;
+     i64toi32_i32$2 = var$1$hi;
+     i64toi32_i32$2 = i64toi32_i32$2;
+     i64toi32_i32$3 = var$1;
+     i64toi32_i32$0 = 0;
+     i64toi32_i32$1 = 1;
+     i64toi32_i32$5 = (i64toi32_i32$3 >>> 0 < i64toi32_i32$1 >>> 0) + i64toi32_i32$0 | 0;
+     i64toi32_i32$5 = i64toi32_i32$2 - i64toi32_i32$5 | 0;
+     i64toi32_i32$5 = i64toi32_i32$5;
+     var$1 = i64toi32_i32$3 - i64toi32_i32$1 | 0;
+     var$1$hi = i64toi32_i32$5;
+    };
+    continue label$2;
+    break label$2;
+   } while (1);
+  };
+  i64toi32_i32$5 = var$2$hi;
+  i64toi32_i32$5 = i64toi32_i32$5;
+  i64toi32_i32$5 = i64toi32_i32$5;
+  i64toi32_i32$5 = i64toi32_i32$5;
+  i64toi32_i32$3 = var$2;
+  i64toi32_i32$HIGH_BITS = i64toi32_i32$5;
+  return i64toi32_i32$3 | 0;
+ }
+ 
+ function _ZN17compiler_builtins3int3mul3Mul3mul17h070e9a1c69faec5bE(var$0, var$0$hi, var$1, var$1$hi) {
+  var$0 = var$0 | 0;
+  var$0$hi = var$0$hi | 0;
+  var$1 = var$1 | 0;
+  var$1$hi = var$1$hi | 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0, i64toi32_i32$4 = 0, i64toi32_i32$2 = 0, var$2 = 0, i64toi32_i32$3 = 0, var$3 = 0, var$4 = 0, var$5 = 0, $21 = 0, $22 = 0, var$6 = 0, $24 = 0, $17 = 0, $18 = 0, $23 = 0, $29 = 0, $45 = 0, $56$hi = 0, $62$hi = 0;
+  i64toi32_i32$0 = var$1$hi;
+  i64toi32_i32$0 = i64toi32_i32$0;
+  var$2 = var$1;
+  var$4 = var$2 >>> 16 | 0;
+  i64toi32_i32$0 = var$0$hi;
+  i64toi32_i32$0 = i64toi32_i32$0;
+  var$3 = var$0;
+  var$5 = var$3 >>> 16 | 0;
+  $17 = Math_imul(var$4, var$5);
+  $18 = var$2;
+  i64toi32_i32$0 = i64toi32_i32$0;
+  i64toi32_i32$0 = i64toi32_i32$0;
+  i64toi32_i32$2 = var$3;
+  i64toi32_i32$1 = 0;
+  i64toi32_i32$3 = 32;
+  i64toi32_i32$4 = i64toi32_i32$3 & 31 | 0;
+  if (32 >>> 0 <= (i64toi32_i32$3 & 63 | 0) >>> 0) {
+   i64toi32_i32$1 = 0;
+   $21 = i64toi32_i32$0 >>> i64toi32_i32$4 | 0;
+  } else {
+   i64toi32_i32$1 = i64toi32_i32$0 >>> i64toi32_i32$4 | 0;
+   $21 = (((1 << i64toi32_i32$4 | 0) - 1 | 0) & i64toi32_i32$0 | 0) << (32 - i64toi32_i32$4 | 0) | 0 | (i64toi32_i32$2 >>> i64toi32_i32$4 | 0) | 0;
+  }
+  i64toi32_i32$1 = i64toi32_i32$1;
+  $23 = $17 + Math_imul($18, $21) | 0;
+  i64toi32_i32$1 = var$1$hi;
+  i64toi32_i32$1 = i64toi32_i32$1;
+  i64toi32_i32$0 = var$1;
+  i64toi32_i32$2 = 0;
+  i64toi32_i32$3 = 32;
+  i64toi32_i32$4 = i64toi32_i32$3 & 31 | 0;
+  if (32 >>> 0 <= (i64toi32_i32$3 & 63 | 0) >>> 0) {
+   i64toi32_i32$2 = 0;
+   $22 = i64toi32_i32$1 >>> i64toi32_i32$4 | 0;
+  } else {
+   i64toi32_i32$2 = i64toi32_i32$1 >>> i64toi32_i32$4 | 0;
+   $22 = (((1 << i64toi32_i32$4 | 0) - 1 | 0) & i64toi32_i32$1 | 0) << (32 - i64toi32_i32$4 | 0) | 0 | (i64toi32_i32$0 >>> i64toi32_i32$4 | 0) | 0;
+  }
+  i64toi32_i32$2 = i64toi32_i32$2;
+  $29 = $23 + Math_imul($22, var$3) | 0;
+  var$2 = var$2 & 65535 | 0;
+  var$3 = var$3 & 65535 | 0;
+  var$6 = Math_imul(var$2, var$3);
+  var$2 = (var$6 >>> 16 | 0) + Math_imul(var$2, var$5) | 0;
+  $45 = $29 + (var$2 >>> 16 | 0) | 0;
+  var$2 = (var$2 & 65535 | 0) + Math_imul(var$4, var$3) | 0;
+  i64toi32_i32$2 = 0;
+  i64toi32_i32$2 = i64toi32_i32$2;
+  i64toi32_i32$1 = $45 + (var$2 >>> 16 | 0) | 0;
+  i64toi32_i32$0 = 0;
+  i64toi32_i32$3 = 32;
+  i64toi32_i32$4 = i64toi32_i32$3 & 31 | 0;
+  if (32 >>> 0 <= (i64toi32_i32$3 & 63 | 0) >>> 0) {
+   i64toi32_i32$0 = i64toi32_i32$1 << i64toi32_i32$4 | 0;
+   $24 = 0;
+  } else {
+   i64toi32_i32$0 = ((1 << i64toi32_i32$4 | 0) - 1 | 0) & (i64toi32_i32$1 >>> (32 - i64toi32_i32$4 | 0) | 0) | 0 | (i64toi32_i32$2 << i64toi32_i32$4 | 0) | 0;
+   $24 = i64toi32_i32$1 << i64toi32_i32$4 | 0;
+  }
+  $56$hi = i64toi32_i32$0;
+  i64toi32_i32$0 = 0;
+  $62$hi = i64toi32_i32$0;
+  i64toi32_i32$0 = $56$hi;
+  i64toi32_i32$2 = $24;
+  i64toi32_i32$1 = $62$hi;
+  i64toi32_i32$3 = var$2 << 16 | 0 | (var$6 & 65535 | 0) | 0;
+  i64toi32_i32$1 = i64toi32_i32$0 | i64toi32_i32$1 | 0;
+  i64toi32_i32$1 = i64toi32_i32$1;
+  i64toi32_i32$2 = i64toi32_i32$2 | i64toi32_i32$3 | 0;
+  i64toi32_i32$HIGH_BITS = i64toi32_i32$1;
+  return i64toi32_i32$2 | 0;
+ }
+ 
+ function __wasm_i64_mul(var$0, var$0$hi, var$1, var$1$hi) {
+  var$0 = var$0 | 0;
+  var$0$hi = var$0$hi | 0;
+  var$1 = var$1 | 0;
+  var$1$hi = var$1$hi | 0;
+  var i64toi32_i32$0 = 0, i64toi32_i32$1 = 0;
+  i64toi32_i32$0 = var$0$hi;
+  i64toi32_i32$0 = var$1$hi;
+  i64toi32_i32$0 = var$0$hi;
+  i64toi32_i32$1 = var$1$hi;
+  i64toi32_i32$1 = _ZN17compiler_builtins3int3mul3Mul3mul17h070e9a1c69faec5bE(var$0 | 0, i64toi32_i32$0 | 0, var$1 | 0, i64toi32_i32$1 | 0) | 0;
+  i64toi32_i32$0 = i64toi32_i32$HIGH_BITS;
+  i64toi32_i32$0 = i64toi32_i32$0;
+  i64toi32_i32$1 = i64toi32_i32$1;
+  i64toi32_i32$HIGH_BITS = i64toi32_i32$0;
+  return i64toi32_i32$1 | 0;
+ }
+ 
+ return {
+  fac_expr: $0, 
+  fac_stack: $1, 
+  fac_stack_raw: $2, 
+  fac_mixed: $3, 
+  fac_mixed_raw: $4
+ };
+}
+