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

Author: alexcrichton

bin/binaryen.js

@@ -836,17 +836,25 @@ struct JSPrinter {
   }
 
   static char* numToString(double d, bool finalize=true) {
+    // If this number is NaN or infinite then things are a bit tricky. In JS we
+    // want to eventually use `NaN` and/or `Infinity`, but neither of those
+    // identifiers are valid in asm.js. Instead we have to explicitly import
+    // `NaN` and `Infinity` from the global environment, and those names are
+    // bound locally in an asm function as `nan` and `infinity`.
+    //
+    // TODO: the JS names of `NaN` and `Infinity` should be used once literal
+    // asm.js code isn't generated any more
     if (std::isnan(d)) {
       if (std::signbit(d)) {
-        return (char*) "-NaN";
+        return (char*) "-nan";
       } else {
-        return (char*) "NaN";
+        return (char*) "nan";
       }
     } else if (!std::isfinite(d)) {
       if (std::signbit(d)) {
-        return (char*) "-Infinity";
+        return (char*) "-infinity";
       } else {
-        return (char*) "Infinity";
+        return (char*) "infinity";
       }
     }
     bool neg = d < 0;
@@ -1059,8 +1067,8 @@ struct JSPrinter {
       ensure(1); // we temporarily append a 0
       char *curr = buffer + last; // ensure might invalidate
       buffer[used] = 0;
-      if (strstr(curr, "Infinity")) return;
-      if (strstr(curr, "NaN")) return;
+      if (strstr(curr, "infinity")) return;
+      if (strstr(curr, "nan")) return;
       if (strchr(curr, '.')) return; // already a decimal point, all good
       char *e = strchr(curr, 'e');
       if (!e) {

bin/wasm.js

@@ -449,6 +449,7 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> {
   void visitLoad(Load* curr) {
     if (curr->type != i64) return;
     assert(!curr->isAtomic && "atomic load not implemented");
+    TempVar lowBits = getTemp();
     TempVar highBits = getTemp();
     TempVar ptrTemp = getTemp();
     SetLocal* setPtr = builder->makeSetLocal(ptrTemp, curr->ptr);
@@ -465,6 +466,15 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> {
           i32
         )
       );
+    } else if (curr->signed_) {
+      loadHigh = builder->makeSetLocal(
+        highBits,
+        builder->makeBinary(
+          ShrSInt32,
+          builder->makeGetLocal(lowBits, i32),
+          builder->makeConst(Literal(int32_t(31)))
+        )
+      );
     } else {
       loadHigh = builder->makeSetLocal(
         highBits,
@@ -475,7 +485,12 @@ struct I64ToI32Lowering : public WalkerPass<PostWalker<I64ToI32Lowering>> {
     curr->bytes = std::min(curr->bytes, uint8_t(4));
     curr->align = std::min(uint32_t(curr->align), uint32_t(4));
     curr->ptr = builder->makeGetLocal(ptrTemp, i32);
-    Block* result = builder->blockify(setPtr, loadHigh, curr);
+    Block* result = builder->blockify(
+      setPtr,
+      builder->makeSetLocal(lowBits, curr),
+      loadHigh,
+      builder->makeGetLocal(lowBits, i32)
+    );
     replaceCurrent(result);
     setOutParam(result, std::move(highBits));
   }

src/emscripten-optimizer/simple_ast.h

@@ -113,6 +113,50 @@ struct RemoveNonJSOpsPass : public WalkerPass<PostWalker<RemoveNonJSOpsPass>> {
     PostWalker<RemoveNonJSOpsPass>::doWalkFunction(func);
   }
 
+  void visitLoad(Load *curr) {
+    if (curr->align == 0 || curr->align >= curr->bytes) {
+      return;
+    }
+
+    // Switch unaligned loads of floats to unaligned loads of integers (which we
+    // can actually implement) and then use reinterpretation to get the float
+    // back out.
+    switch (curr->type) {
+      case f32:
+        curr->type = i32;
+        replaceCurrent(builder->makeUnary(ReinterpretInt32, curr));
+        break;
+      case f64:
+        curr->type = i64;
+        replaceCurrent(builder->makeUnary(ReinterpretInt64, curr));
+        break;
+      default:
+        break;
+    }
+  }
+
+  void visitStore(Store *curr) {
+    if (curr->align == 0 || curr->align >= curr->bytes) {
+      return;
+    }
+
+    // Switch unaligned stores of floats to unaligned stores of integers (which
+    // we can actually implement) and then use reinterpretation to store the
+    // right value.
+    switch (curr->valueType) {
+      case f32:
+        curr->valueType = i32;
+        curr->value = builder->makeUnary(ReinterpretFloat32, curr->value);
+        break;
+      case f64:
+        curr->valueType = i64;
+        curr->value = builder->makeUnary(ReinterpretFloat64, curr->value);
+        break;
+      default:
+        break;
+    }
+  }
+
   void visitBinary(Binary *curr) {
     Name name;
     switch (curr->op) {

src/passes/I64ToI32Lowering.cpp

@@ -76,7 +76,7 @@ int main(int argc, const char *argv[]) {
 
     if (options.extra["asserts"] == "1") {
       if (options.debug) std::cerr << "asserting..." << std::endl;
-      flattenAppend(asmjs, wasm2asm.processAsserts(*root, builder));
+      flattenAppend(asmjs, wasm2asm.processAsserts(&wasm, *root, builder));
     }
   } catch (ParseException& p) {
     p.dump(std::cerr);