Merge remote-tracking branch 'origin/master' into release

Author: actions-user

bin/asc

@@ -18,5 +18,5 @@ try { require("source-map-support").install(); } catch (e) {}
 
 const asc = module.exports = require("../cli/asc.js");
 if (/\basc$/.test(process.argv[1])) {
-  process.exitCode = asc.main(process.argv.slice(2));
+  asc.ready.then(() => process.exitCode = asc.main(process.argv.slice(2)));
 }

cli/README.md

@@ -17,19 +17,21 @@ The API accepts the same options as the CLI but also lets you override stdout an
 
 ```js
 const asc = require("assemblyscript/cli/asc");
-asc.main([
-  "myModule.ts",
-  "--binaryFile", "myModule.wasm",
-  "--optimize",
-  "--sourceMap",
-  "--measure"
-], {
-  stdout: process.stdout,
-  stderr: process.stderr
-}, function(err) {
-  if (err)
-    throw err;
-  ...
+asc.ready.then(() => {
+  asc.main([
+    "myModule.ts",
+    "--binaryFile", "myModule.wasm",
+    "--optimize",
+    "--sourceMap",
+    "--measure"
+  ], {
+    stdout: process.stdout,
+    stderr: process.stderr
+  }, function(err) {
+    if (err)
+      throw err;
+    ...
+  });
 });
 ```
 
@@ -43,6 +45,9 @@ const options = require("assemblyscript/cli/asc.json");
 You can also compile a source string directly, for example in a browser environment:
 
 ```js
-const { binary, text, stdout, stderr } = asc.compileString(`...`, { optimize: 2 });
+const asc = require("assemblyscript/cli/asc");
+asc.ready.then(() => {
+  const { binary, text, stdout, stderr } = asc.compileString(`...`, { optimize: 2 });
+});
 ...
 ```

cli/asc.d.ts

@@ -1,6 +1,9 @@
 import { OptionDescription } from "./util/options";
 export { OptionDescription };
 
+/** Ready promise resolved once/if the compiler is ready. */
+export const ready: Promise<void>;
+
 /** Whether this is a webpack bundle or not. */
 export const isBundle: boolean;
 

cli/asc.js

@@ -24,37 +24,39 @@ const mkdirp = require("./util/mkdirp");
 const find = require("./util/find");
 const EOL = process.platform === "win32" ? "\r\n" : "\n";
 const SEP = process.platform === "win32" ? "\\" : "/";
+const binaryen = global.Binaryen || (global.Binaryen = require("binaryen"));
 
-// global.Binaryen = require("../lib/binaryen");
+// Proxy Binaryen's ready event
+Object.defineProperty(exports, "ready", {
+  get: function() { return binaryen.ready; }
+});
 
 // Emscripten adds an `uncaughtException` listener to Binaryen that results in an additional
 // useless code fragment on top of an actual error. suppress this:
 if (process.removeAllListeners) process.removeAllListeners("uncaughtException");
 
 // Use distribution files if present, otherwise run the sources directly
 var assemblyscript, isDev = false;
-(() => {
-  try { // `asc` on the command line
-    assemblyscript = require("../dist/assemblyscript.js");
-  } catch (e) {
-    try { // `asc` on the command line without dist files
-      require("ts-node").register({
-        project: path.join(__dirname, "..", "src", "tsconfig.json"),
-        skipIgnore: true,
-        compilerOptions: { target: "ES2016" }
-      });
-      require("../src/glue/js");
-      assemblyscript = require("../src");
-      isDev = true;
-    } catch (e_ts) {
-      try { // `require("dist/asc.js")` in explicit browser tests
-        assemblyscript = eval("require('./assemblyscript')");
-      } catch (e) {
-        throw Error(e_ts.stack + "\n---\n" + e.stack);
-      }
+try { // `asc` on the command line
+  assemblyscript = require("../dist/assemblyscript.js");
+} catch (e) {
+  try { // `asc` on the command line without dist files
+    require("ts-node").register({
+      project: path.join(__dirname, "..", "src", "tsconfig.json"),
+      skipIgnore: true,
+      compilerOptions: { target: "ES2016" }
+    });
+    require("../src/glue/js");
+    assemblyscript = require("../src");
+    isDev = true;
+  } catch (e_ts) {
+    try { // `require("dist/asc.js")` in explicit browser tests
+      assemblyscript = eval("require('./assemblyscript')");
+    } catch (e) {
+      throw Error(e_ts.stack + "\n---\n" + e.stack);
     }
   }
-})();
+}
 
 /** Whether this is a webpack bundle or not. */
 exports.isBundle = typeof BUNDLE_VERSION === "string";
@@ -646,12 +648,12 @@ exports.main = function main(argv, options, callback) {
       if (optimizeLevel >= 3 || shrinkLevel >= 1) {
         add("ssa-nomerge");
       }
-      if (optimizeLevel >= 4) {
+      if (optimizeLevel >= 3) {
         add("flatten");
         add("local-cse");
       }
       if (hasARC) { // differs
-        if (optimizeLevel < 4) {
+        if (optimizeLevel < 3) {
           add("flatten");
         }
         add("post-assemblyscript");
@@ -668,9 +670,10 @@ exports.main = function main(argv, options, callback) {
       } else {
         add("precompute");
       }
-      if (optimizeLevel >= 2 || shrinkLevel >= 2) {
-        add("code-pushing");
-      }
+      // this will be done later
+      // if (optimizeLevel >= 2 || shrinkLevel >= 2) {
+      //   add("code-pushing");
+      // }
       add("simplify-locals-nostructure");
       add("vacuum");
       add("reorder-locals");
@@ -701,30 +704,64 @@ exports.main = function main(argv, options, callback) {
       if (optimizeLevel >= 2 || shrinkLevel >= 1) {
         add("rse");
       }
-      if (hasARC) { // differs
-        add("post-assemblyscript-finalize");
-      }
       add("vacuum");
-
       // PassRunner::addDefaultGlobalOptimizationPostPasses
       if (optimizeLevel >= 2 || shrinkLevel >= 1) {
         add("dae-optimizing");
       }
       if (optimizeLevel >= 2 || shrinkLevel >= 2) {
         add("inlining-optimizing");
       }
-      add("duplicate-function-elimination");
+      // "duplicate-function-elimination" will better done later
+      // add("duplicate-function-elimination");
       add("duplicate-import-elimination");
       if (optimizeLevel >= 2 || shrinkLevel >= 2) {
         add("simplify-globals-optimizing");
       } else {
         add("simplify-globals");
       }
-      add("remove-unused-module-elements");
-      add("memory-packing");
-      add("directize");
+      // replace indirect calls with direct, reduce arity and
+      // inline this calls if possible
+      add("directize"); // differs
+      add("dae-optimizing"); // differs
       add("inlining-optimizing"); // differs
-      if (optimizeLevel >= 2 || shrinkLevel >= 1) {
+      // ARC finalization should be done exactly after inlining for better release/retain reduction
+      if (hasARC) { // differs
+        add("post-assemblyscript-finalize");
+      }
+      if (optimizeLevel >= 2 || shrinkLevel >= 1) { // differs
+        add("rse");
+        add("vacuum");
+
+        // rearrange / reduce switch cases again
+        add("remove-unused-brs");
+        add("remove-unused-names");
+        add("merge-blocks");
+        add("vacuum");
+
+        // replace indirect calls with direct and inline if possible again.
+        add("directize");
+        add("inlining-optimizing");
+        // move some code after early return which potentially could reduce computations
+        // do this after CFG cleanup (originally it was done before)
+        add("code-pushing");
+
+        // this quite expensive so do this only for highest opt level
+        if (optimizeLevel >= 3) {
+          add("simplify-locals-nostructure");
+          add("reorder-locals");
+          add("vacuum");
+        }
+        // finally optimize all remaining peepholes
+        add("simplify-globals-optimizing");
+        add("optimize-instructions");
+      }
+      // remove unused elements of table and pack / reduce memory
+      add("duplicate-function-elimination"); // differs
+      add("remove-unused-nonfunction-module-elements"); // differs
+      add("memory-packing");
+      add("remove-unused-module-elements"); // differs
+      if (optimizeLevel >= 3 || shrinkLevel >= 1) { // differs. was optimizeLevel >= 2
         add("generate-stack-ir");
         add("optimize-stack-ir");
       }

package-lock.json

@@ -21,7 +21,7 @@
     "url": "https://github.com/AssemblyScript/assemblyscript/issues"
   },
   "dependencies": {
-    "binaryen": "89.0.0-nightly.20191215",
+    "binaryen": "90.0.0-nightly.20191231",
     "long": "^4.0.0",
     "source-map-support": "^0.5.16",
     "ts-node": "^6.2.0"

package.json

@@ -0,0 +1,24 @@
+// Updates the Binaryen constants in src/module.ts
+
+const fs = require("fs");
+const path = require("path");
+const binaryen = require("binaryen");
+
+const srcfile = path.join(__dirname, "..", "src", "module.ts");
+var src = fs.readFileSync(srcfile, "utf8");
+
+binaryen.ready.then(() => {
+  src = src.replace(/enum (\w+) \{([^}]*)\}/g, function($0) {
+    return $0.replace(/(\w+)[ ]+=[ ]+([^,;\n]+)/g, function($0, key, val) {
+      var match = val.match(/\b(_Binaryen\w+)\b/);
+      if (match) {
+        let fn = match[1];
+        let id = binaryen[fn]();
+        console.log(fn + " = " + id);
+        return key + " = " + id + " /* " + fn + " */";
+      }
+      return $0;
+    });
+  });
+  fs.writeFileSync(srcfile, src, "utf8");
+});

scripts/update-constants.js

@@ -2,4 +2,18 @@ Portable compiler sources that compile to both JavaScript using `tsc` and, event
 
 Architecture
 ------------
+
 ![](https://assemblyscript.github.io/assemblyscript/media/architecture.svg)
+
+Usage
+-----
+
+Note that using the compiler as a library requires awaiting Binaryen ready state, like so:
+
+```js
+const binaryen = require("binaryen");
+const assemblyscript = require("assemblyscript");
+binaryen.ready.then(() => {
+  // do something with assemblyscript
+});
+```

src/README.md

@@ -323,6 +323,7 @@ export namespace BuiltinSymbols {
   export const v128_min = "~lib/builtins/v128.min";
   export const v128_max = "~lib/builtins/v128.max";
   export const v128_dot = "~lib/builtins/v128.dot";
+  export const v128_avgr = "~lib/builtins/v128.avgr";
   export const v128_abs = "~lib/builtins/v128.abs";
   export const v128_sqrt = "~lib/builtins/v128.sqrt";
   export const v128_eq = "~lib/builtins/v128.eq";
@@ -357,6 +358,7 @@ export namespace BuiltinSymbols {
   export const i8x16_min_u = "~lib/builtins/i8x16.min_u";
   export const i8x16_max_s = "~lib/builtins/i8x16.max_s";
   export const i8x16_max_u = "~lib/builtins/i8x16.max_u";
+  export const i8x16_avgr_u = "~lib/builtins/i8x16.avgr_u";
   export const i8x16_neg = "~lib/builtins/i8x16.neg";
   export const i8x16_add_saturate_s = "~lib/builtins/i8x16.add_saturate_s";
   export const i8x16_add_saturate_u = "~lib/builtins/i8x16.add_saturate_u";
@@ -391,6 +393,7 @@ export namespace BuiltinSymbols {
   export const i16x8_min_u = "~lib/builtins/i16x8.min_u";
   export const i16x8_max_s = "~lib/builtins/i16x8.max_s";
   export const i16x8_max_u = "~lib/builtins/i16x8.max_u";
+  export const i16x8_avgr_u = "~lib/builtins/i16x8.avgr_u";
   export const i16x8_neg = "~lib/builtins/i16x8.neg";
   export const i16x8_add_saturate_s = "~lib/builtins/i16x8.add_saturate_s";
   export const i16x8_add_saturate_u = "~lib/builtins/i16x8.add_saturate_u";
@@ -850,7 +853,7 @@ export function compileCall(
         }
         offset = (<Field>field).memoryOffset;
       } else {
-        offset = classType.currentMemoryOffset;
+        offset = classType.nextMemoryOffset;
       }
       if (compiler.options.isWasm64) {
         // implicitly wrap if contextual type is a 32-bit integer
@@ -3377,6 +3380,30 @@ export function compileCall(
       );
       return module.unreachable();
     }
+    case BuiltinSymbols.v128_avgr: { // avgr<T!>(a: v128, b: v128) -> v128
+      if (
+        checkFeatureEnabled(Feature.SIMD, reportNode, compiler) |
+        checkTypeRequired(typeArguments, reportNode, compiler) |
+        checkArgsRequired(operands, 2, reportNode, compiler)
+      ) {
+        compiler.currentType = Type.v128;
+        return module.unreachable();
+      }
+      let type = typeArguments![0];
+      let arg0 = compiler.compileExpression(operands[0], Type.v128, Constraints.CONV_IMPLICIT);
+      let arg1 = compiler.compileExpression(operands[1], Type.v128, Constraints.CONV_IMPLICIT);
+      if (!type.is(TypeFlags.REFERENCE)) {
+        switch (type.kind) {
+          case TypeKind.U8:  return module.binary(BinaryOp.AvgrU8x16, arg0, arg1);
+          case TypeKind.U16: return module.binary(BinaryOp.AvgrU16x8, arg0, arg1);
+        }
+      }
+      compiler.error(
+        DiagnosticCode.Operation_0_cannot_be_applied_to_type_1,
+        reportNode.typeArgumentsRange, "v128.avgr", type.toString()
+      );
+      return module.unreachable();
+    }
     case BuiltinSymbols.v128_eq: { // eq<T!>(a: v128, b: v128) -> v128
       if (
         checkFeatureEnabled(Feature.SIMD, reportNode, compiler) |
@@ -4516,6 +4543,7 @@ function tryDeferASM(
     case BuiltinSymbols.i8x16_min_u: return deferASM(BuiltinSymbols.v128_min, compiler, Type.u8, operands, Type.v128, reportNode);
     case BuiltinSymbols.i8x16_max_s: return deferASM(BuiltinSymbols.v128_max, compiler, Type.i8, operands, Type.v128, reportNode);
     case BuiltinSymbols.i8x16_max_u: return deferASM(BuiltinSymbols.v128_max, compiler, Type.u8, operands, Type.v128, reportNode);
+    case BuiltinSymbols.i8x16_avgr_u: return deferASM(BuiltinSymbols.v128_avgr, compiler, Type.u8, operands, Type.v128, reportNode);
     case BuiltinSymbols.i8x16_neg: return deferASM(BuiltinSymbols.v128_neg, compiler, Type.i8, operands, Type.v128, reportNode);
     case BuiltinSymbols.i8x16_add_saturate_s: return deferASM(BuiltinSymbols.v128_add_saturate, compiler, Type.i8, operands, Type.v128, reportNode);
     case BuiltinSymbols.i8x16_add_saturate_u: return deferASM(BuiltinSymbols.v128_add_saturate, compiler, Type.u8, operands, Type.v128, reportNode);
@@ -4550,6 +4578,7 @@ function tryDeferASM(
     case BuiltinSymbols.i16x8_min_u: return deferASM(BuiltinSymbols.v128_min, compiler, Type.u16, operands, Type.v128, reportNode);
     case BuiltinSymbols.i16x8_max_s: return deferASM(BuiltinSymbols.v128_max, compiler, Type.i16, operands, Type.v128, reportNode);
     case BuiltinSymbols.i16x8_max_u: return deferASM(BuiltinSymbols.v128_max, compiler, Type.u16, operands, Type.v128, reportNode);
+    case BuiltinSymbols.i16x8_avgr_u: return deferASM(BuiltinSymbols.v128_avgr, compiler, Type.u16, operands, Type.v128, reportNode);
     case BuiltinSymbols.i16x8_neg: return deferASM(BuiltinSymbols.v128_neg, compiler, Type.i16, operands, Type.v128, reportNode);
     case BuiltinSymbols.i16x8_add_saturate_s: return deferASM(BuiltinSymbols.v128_add_saturate, compiler, Type.i16, operands, Type.v128, reportNode);
     case BuiltinSymbols.i16x8_add_saturate_u: return deferASM(BuiltinSymbols.v128_add_saturate, compiler, Type.u16, operands, Type.v128, reportNode);

src/builtins.ts

@@ -1579,7 +1579,7 @@ export class Compiler extends DiagnosticEmitter {
     var runtimeHeaderSize = program.runtimeHeaderSize;
     var arrayPrototype = assert(program.arrayPrototype);
     var arrayInstance = assert(this.resolver.resolveClass(arrayPrototype, [ elementType ]));
-    var arrayInstanceSize = arrayInstance.currentMemoryOffset;
+    var arrayInstanceSize = arrayInstance.nextMemoryOffset;
     var bufferLength = bufferSegment.buffer.length - runtimeHeaderSize;
     var arrayLength = i32(bufferLength / elementType.byteSize);
 
@@ -9123,8 +9123,8 @@ export class Compiler extends DiagnosticEmitter {
     this.compileFunction(allocInstance);
     return module.call(allocInstance.internalName, [
       options.isWasm64
-        ? module.i64(classInstance.currentMemoryOffset)
-        : module.i32(classInstance.currentMemoryOffset),
+        ? module.i64(classInstance.nextMemoryOffset)
+        : module.i32(classInstance.nextMemoryOffset),
       module.i32(
         classInstance.hasDecorator(DecoratorFlags.UNMANAGED)
           ? 0