Extract portable AS to its own definition and polyfill; Try running flatten/ssa before default optimizations, see WebAssembly/binaryen#1331

Author: dcodeIO

assembly.d.ts

@@ -1,4 +1,6 @@
-// types
+// Definitions for the "AssemblyScript" subset.
+
+// Types
 
 /** An 8-bit signed integer. */
 declare type i8 = number;
@@ -27,7 +29,7 @@ declare type f32 = number;
 /** A 64-bit float. */
 declare type f64 = number;
 
-// built-ins
+// Built-ins
 
 /** Performs the sign-agnostic count leading zero bits operation on a 32-bit or 64-bit integer. All zero bits are considered leading if the value is zero. */
 declare function clz<T = i32 | i64>(value: T): T;
@@ -84,10 +86,10 @@ declare function changetype<T1,T2>(value: T1): T2;
 declare function isNaN<T = f32 | f64>(value: T): bool;
 /** Tests if a 32-bit or 64-bit float is finite, that is not NaN or +/-Infinity. */
 declare function isFinite<T = f32 | f64>(value: T): bool;
-/** Traps if the specified value is `false`. */
+/** Traps if the specified value evaluates to `false`. */
 declare function assert(isTrue: bool): void;
 
-// internal decorators
+// Internal decorators
 
 /** Annotates an element being part of the global namespace. */
 declare function global(): any;
@@ -96,7 +98,7 @@ declare function inline(): any;
 /** Annotates a class using a C-style memory layout. */
 declare function struct(): any;
 
-// standard library
+// Standard library
 
 /// <reference path="./std/carray.d.ts" />
 /// <reference path="./std/cstring.d.ts" />

portable-assembly.d.ts

@@ -0,0 +1,48 @@
+// Definitions for the "portable AssemblyScript" subset.
+
+// Portable types
+
+// Note that semantics differences require additional explicit conversions for full compatibility.
+// For example, when casting an i32 to an u8, doing `<u8>(someI32 & 0xff)` will yield the same
+// result when compiling to WebAssembly or JS while `<u8>someI32` alone does nothing in JS.
+
+// Note that i64's are not portable (JS numbers are IEEE754 doubles with a maximum safe integer value
+// of 2^53-1) and instead require a compatibility layer to work in JS as well. See: src/util/i64.ts
+
+declare type i8 = number;
+declare type u8 = number;
+declare type i16 = number;
+declare type u16 = number;
+declare type i32 = number;
+declare type u32 = number;
+declare type isize = number;
+declare type usize = number;
+declare type f32 = number;
+declare type f64 = number;
+declare type bool = boolean;
+
+// Portable built-ins
+
+/** Performs the sign-agnostic count leading zero bits operation on a 32-bit or 64-bit integer. All zero bits are considered leading if the value is zero. */
+declare function clz<T = i32>(value: T): T;
+/** Computes the absolute value of an integer or float. */
+declare function abs<T = i32 | f32 | f64>(value: T): T;
+/** Determines the maximum of two integers or floats. If either operand is `NaN`, returns `NaN`. */
+declare function max<T = i32 | f32 | f64>(left: T, right: T): T;
+/** Determines the minimum of two integers or floats. If either operand is `NaN`, returns `NaN`. */
+declare function min<T = i32 | f32 | f64>(left: T, right: T): T;
+/** Performs the ceiling operation on a 32-bit or 64-bit float. */
+declare function ceil<T = f32 | f64>(value: T): T;
+/** Performs the floor operation on a 32-bit or 64-bit float. */
+declare function floor<T = f32 | f64>(value: T): T;
+/** Selects one of two pre-evaluated values depending on the condition. */
+declare function select<T>(ifTrue: T, ifFalse: T, condition: bool): T;
+/** Calculates the square root of a 32-bit or 64-bit float. */
+declare function sqrt<T = f32 | f64>(value: T): T;
+/** Rounds to the nearest integer towards zero of a 32-bit or 64-bit float. */
+declare function trunc<T = f32 | f64>(value: T): T;
+/** Emits an unreachable operation that results in a runtime error when executed. */
+declare function unreachable(): any; // sic
+
+/** Traps if the specified value evaluates to `false`. */
+declare function assert(isTrue: bool): void;

portable-assembly.js

@@ -0,0 +1,29 @@
+var globalScope = typeof window !== "undefined" && window || typeof global !== "undefined" && global || self;
+
+globalScope["clz"] = Math.clz32;
+globalScope["abs"] = Math.abs;
+globalScope["max"] = Math.max;
+globalScope["min"] = Math.min;
+globalScope["ceil"] = Math.ceil;
+globalScope["floor"] = Math.floor;
+globalScope["select"] = function select(ifTrue, ifFalse, condition) { return condition ? ifTrue : ifFalse; };
+globalScope["sqrt"] = Math.sqrt;
+globalScope["trunc"] = Math.trunc;
+
+function UnreachableError() {
+  this.stack = new Error().stack;
+}
+UnreachableError.prototype = new Error;
+UnreachableError.prototype.name = "UnreachableError";
+UnreachableError.prototype.message = "unreachable";
+
+globalScope["unreachable"] = function unreachable() { throw new UnreachableError(); };
+
+function AssertionError() {
+  this.stack = new Error().stack;
+}
+AssertionError.prototype = new Error;
+AssertionError.prototype.name = "AssertionError";
+AssertionError.prototype.message = "assertion failed";
+
+globalScope["assert"] = function assert(isTrue) { if (!isTrue) throw new AssertionError(); };

src/compiler.ts

@@ -1424,6 +1424,7 @@ export class Compiler extends DiagnosticEmitter {
       case Token.AMPERSAND_AMPERSAND: // left && right
         left = this.compileExpression(expression.left, contextualType, contextualType == Type.void ? ConversionKind.NONE : ConversionKind.IMPLICIT);
         right = this.compileExpression(expression.right, this.currentType);
+        // TODO: once it's possible to clone 'left', we could check if it is a Const, GetLocal, GetGlobal or Load and avoid the tempLocal
         tempLocal = this.currentFunction.addLocal(this.currentType);
         return this.module.createIf(
           this.currentType.isLongInteger
@@ -1440,6 +1441,7 @@ export class Compiler extends DiagnosticEmitter {
       case Token.BAR_BAR: // left || right
         left = this.compileExpression(expression.left, contextualType, contextualType == Type.void ? ConversionKind.NONE : ConversionKind.IMPLICIT);
         right = this.compileExpression(expression.right, this.currentType);
+        // TODO: same as above
         tempLocal = this.currentFunction.addLocal(this.currentType);
         return this.module.createIf(
           this.currentType.isLongInteger

src/glue/binaryen.d.ts renamed to src/glue/binaryen-c.d.ts

@@ -1,20 +1,6 @@
-// Aliased AssemblyScript types. Beware of semantic differences.
-declare type i8 = number;
-declare type u8 = number;
-declare type i16 = number;
-declare type u16 = number;
-declare type i32 = number;
-declare type u32 = number;
-declare type isize = number;
-declare type usize = number;
-declare type f32 = number;
-declare type f64 = number;
-declare type bool = boolean;
+/// <reference path="../../portable-assembly.d.ts" />
+/// <reference path="./binaryen-c.d.ts" />
 
-// Raw memory access (here: Binaryen memory)
+// Raw memory accesses to Binaryen memory
 declare function store<T = u8>(ptr: usize, val: T): void;
 declare function load<T = u8>(ptr: usize): T;
-declare function assert(isTrue: bool): void;
-
-// Other things that might or might not be useful
-declare function select<T>(ifTrue: T, ifFalse: T, condition: bool): T;

src/glue/js.d.ts

@@ -0,0 +1,42 @@
+require("../../portable-assembly");
+
+var globalScope = typeof window !== "undefined" && window || typeof global !== "undefined" && global || self;
+
+var binaryen;
+try {
+  binaryen = require("binaryen");
+} catch (e) {
+  binaryen = globalScope["Binaryen"];
+}
+for (var key in binaryen)
+  if (/^_(?:Binaryen|Relooper|malloc$|free$)/.test(key))
+    globalScope[key] = binaryen[key];
+
+globalScope["store"] = function store(ptr, val) {
+  binaryen.HEAPU8[ptr] = val;
+};
+
+globalScope["load"] = function load_u8(ptr) {
+  return binaryen.HEAPU8[ptr];
+};
+
+var Module = require("../module").Module;
+
+Module.prototype.toBinary = function toBinary(bufferSize) {
+  if (!bufferSize) bufferSize = 1024 * 1024;
+  var ptr = _malloc(bufferSize);
+  var len = this.write(ptr, bufferSize);
+  var ret = new Uint8Array(len);
+  ret.set(binaryen.HEAPU8.subarray(ptr, ptr + len));
+  _free(ptr);
+  return ret;
+}
+
+Module.prototype.toText = function toText() {
+  var previousPrint = binaryen.print;
+  var ret = "";
+  binaryen.print = function print(x) { ret += x + "\n" };
+  this.print();
+  binaryen.print = previousPrint;
+  return ret;
+}

src/glue/js.js

@@ -701,10 +701,13 @@ export class Module {
   }
 
   optimize(func: FunctionRef = 0): void {
-    if (func)
+    // see: https://github.com/WebAssembly/binaryen/issues/1331#issuecomment-350328175
+    this.runPasses([ "flatten", "ssa" ], func);
+    if (func) {
       _BinaryenFunctionOptimize(func, this.ref);
-    else
+    } else {
       _BinaryenModuleOptimize(this.ref);
+    }
   }
 
   runPasses(passes: string[], func: FunctionRef = 0): void {

src/glue/js.ts

@@ -27,9 +27,7 @@
     "diagnosticMessages.generated.ts",
     "diagnostics.ts",
     "evaluator.ts",
-    "glue/binaryen.d.ts",
     "glue/js.d.ts",
-    "glue/js.ts",
     "index.ts",
     "module.ts",
     "parser.ts",
@@ -43,11 +41,7 @@
   ],
   "assembly": {
     "exclude": [
-      "glue/js.d.ts",
-      "glue/js.ts"
-    ],
-    "include": [
-      "glue/wasm.ts"
+      "glue/js.d.ts"
     ]
   }
 }

src/glue/wasm.ts

@@ -42,7 +42,7 @@ class Heap {
     let w: u32, x: u32;
 
     // copy 1 byte each until src is aligned to 4 bytes
-    while (n != 0 && src % 4 != 0) {
+    while (n && src % 4) {
       store<u8>(dst++, load<u8>(src++));
       n--;
     }

src/module.ts

@@ -1,4 +1,4 @@
-/// <reference path="../src/glue/binaryen.d.ts" />
+/// <reference path="../lib/binaryen.d.ts" />
 
 import "../src/glue/js";
 import { NativeType, Module, MemorySegment, BinaryOp } from "../src/module";
@@ -19,13 +19,13 @@ mod.addFunction("add", add, [], mod.createReturn(
     mod.createGetLocal(1, NativeType.I32)
   )
 ));
-mod.addExport("add", "add");
+mod.addFunctionExport("add", "add");
 
 const lit = mod.addFunctionType("I", NativeType.I64, []);
 mod.addFunction("lit", lit, [], mod.createReturn(
   mod.createI64(0, 0x80000000) // I64_MIN
 ));
-mod.addExport("lit", "lit");
+mod.addFunctionExport("lit", "lit");
 
 mod.addGlobal("42", NativeType.I32, false, mod.createI32(42));
 
@@ -42,7 +42,7 @@ mod.addFunction("aSwitch", aSwitch, [ NativeType.I32 ], mod.createBlock(null, [
   rl.renderAndDispose(b0, 1),
   mod.createUnreachable()
 ]));
-mod.addExport("aSwitch", "aSwitch");
+mod.addFunctionExport("aSwitch", "aSwitch");
 
 // mod.optimize();
 if (mod.validate())

src/tsconfig.json

@@ -1,5 +1,3 @@
-/// <reference path="../src/glue/binaryen.d.ts" />
-
 import * as fs from "fs";
 import * as path from "path";
 import * as chalk from "chalk";

std/impl/heap.ts

@@ -5,37 +5,47 @@
  (export "loopDoInDo" (func $do/loopDoInDo))
  (export "memory" (memory $0))
  (func $do/loopDo (; 0 ;) (type $iv) (param $0 i32)
+  (local $1 i32)
+  (set_local $1
+   (get_local $0)
+  )
   (loop $continue|0
    (br_if $continue|0
-    (tee_local $0
+    (tee_local $1
      (i32.sub
-      (get_local $0)
+      (get_local $1)
       (i32.const 1)
      )
     )
    )
   )
  )
  (func $do/loopDoInDo (; 1 ;) (type $iv) (param $0 i32)
+  (local $1 i32)
+  (local $2 i32)
   (loop $continue|0
-   (set_local $0
+   (set_local $1
     (i32.sub
      (get_local $0)
      (i32.const 1)
     )
    )
    (loop $continue|1
     (br_if $continue|1
-     (tee_local $0
-      (i32.sub
-       (get_local $0)
-       (i32.const 1)
+     (tee_local $2
+      (tee_local $1
+       (tee_local $0
+        (i32.sub
+         (get_local $1)
+         (i32.const 1)
+        )
+       )
       )
      )
     )
    )
    (br_if $continue|0
-    (get_local $0)
+    (get_local $2)
    )
   )
  )