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 src/glue/binaryen-c.d.tssrc/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 {