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

Author: actions-user

cli/asc.js

@@ -662,15 +662,16 @@ exports.main = function main(argv, options, callback) {
       add("remove-unused-brs");
       add("remove-unused-names");
       add("optimize-instructions");
-      if (optimizeLevel >= 2 || shrinkLevel >= 2) {
+      if (optimizeLevel >= 2 || shrinkLevel >= 1) {
         add("pick-load-signs");
+        add("simplify-globals-optimizing"); // differs
       }
       if (optimizeLevel >= 3 || shrinkLevel >= 2) {
         add("precompute-propagate");
       } else {
         add("precompute");
       }
-      // this will be done later
+      // this will be done later (1)
       // if (optimizeLevel >= 2 || shrinkLevel >= 2) {
       //   add("code-pushing");
       // }
@@ -691,15 +692,19 @@ exports.main = function main(argv, options, callback) {
       if (optimizeLevel >= 3 || shrinkLevel >= 1) {
         add("code-folding");
       }
+      if (optimizeLevel >= 2 || shrinkLevel >= 1) { // differs
+        add("simplify-globals-optimizing");
+      }
       add("merge-blocks");
       add("remove-unused-brs");
       add("remove-unused-names");
       add("merge-blocks");
-      if (optimizeLevel >= 3 || shrinkLevel >= 2) {
-        add("precompute-propagate");
-      } else {
-        add("precompute");
-      }
+      // make this later & move to (2)
+      // if (optimizeLevel >= 3 || shrinkLevel >= 2) {
+      //   add("precompute-propagate");
+      // } else {
+      //   add("precompute");
+      // }
       add("optimize-instructions");
       if (optimizeLevel >= 2 || shrinkLevel >= 1) {
         add("rse");
@@ -720,6 +725,13 @@ exports.main = function main(argv, options, callback) {
       } else {
         add("simplify-globals");
       }
+      // moved from (2)
+      // it works better after globals optimizations like simplify-globals, inlining-optimizing and etc
+      if (optimizeLevel >= 2 || shrinkLevel >= 1) { // differs
+        add("precompute-propagate");
+      } else {
+        add("precompute");
+      }
       // replace indirect calls with direct, reduce arity and
       // inline this calls if possible
       add("directize"); // differs
@@ -731,40 +743,44 @@ exports.main = function main(argv, options, callback) {
       }
       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)
+        // moved from (1)
         add("code-pushing");
 
         // this quite expensive so do this only for highest opt level
+        add("simplify-globals-optimizing");
         if (optimizeLevel >= 3) {
           add("simplify-locals-nostructure");
-          add("reorder-locals");
           add("vacuum");
+
+          add("precompute-propagate");
+          add("simplify-locals-nostructure");
+          add("vacuum");
+
+          add("reorder-locals");
+        } else {
+          add("simplify-globals-optimizing");
         }
-        // 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");
-      }
+      // It seems stack-ir unuseful for our needs.
+      // if (optimizeLevel >= 3 || shrinkLevel >= 1) { // differs. was optimizeLevel >= 2
+      //   add("generate-stack-ir");
+      //   add("optimize-stack-ir");
+      // }
     }
 
     // Append additional passes if requested and execute

lib/loader/index.d.ts

@@ -19,42 +19,70 @@ interface ASUtil {
   _start(): void;
   /** Allocates a new string in the module's memory and returns a reference (pointer) to it. */
   __allocString(str: string): number;
-  /** Reads (copies) the value of a string from the module's memory. */
-  __getString(ptr: number): string;
   /** Allocates a new array in the module's memory and returns a reference (pointer) to it. */
   __allocArray(id: number, values: ArrayLike<number>): number;
+
+  /** Reads (copies) the value of a string from the module's memory. */
+  __getString(ptr: number): string;
   /** Reads (copies) the values of an array from the module's memory. */
   __getArray(ptr: number): number[];
   /** Gets a view on the values of an array in the module's memory. */
   __getArrayView(ptr: number): ArrayBufferView;
-  /** Reads the values of Int8Array from the module's memory. */
+
+  /** Reads (copies) the values of Int8Array from the module's memory. */
   __getInt8Array(ptr: number): Int8Array;
-  /** Reads the values of Uint8Array from the module's memory. */
+  /** Reads (copies) the values of Uint8Array from the module's memory. */
   __getUint8Array(ptr: number): Uint8Array;
-  /** Reads the values of Uint8Array from the module's memory. */
+  /** Reads (copies) the values of Uint8Array from the module's memory. */
   __getUint8ClampedArray(ptr: number): Uint8ClampedArray;
-  /** Reads the values of Int16Array from the module's memory. */
+  /** Reads (copies) the values of Int16Array from the module's memory. */
   __getInt16Array(ptr: number): Int16Array;
-  /** Reads the values of Uint16Array from the module's memory. */
+  /** Reads (copies) the values of Uint16Array from the module's memory. */
   __getUint16Array(ptr: number): Uint16Array;
-  /** Reads the values of Int32Array from the module's memory. */
+  /** Reads (copies) the values of Int32Array from the module's memory. */
   __getInt32Array(ptr: number): Int32Array;
-  /** Reads the values of Uint32Array from the module's memory. */
+  /** Reads (copies) the values of Uint32Array from the module's memory. */
   __getUint32Array(ptr: number): Uint32Array;
-  /** Reads the values of Int32Array from the module's memory. */
+  /** Reads (copies) the values of Int32Array from the module's memory. */
   __getInt64Array?(ptr: number): BigInt64Array;
-  /** Reads the values of Uint32Array from the module's memory. */
+  /** Reads (copies) the values of Uint32Array from the module's memory. */
   __getUint64Array?(ptr: number): BigUint64Array;
-  /** Reads the values of Float32Array from the module's memory. */
+  /** Reads (copies) the values of Float32Array from the module's memory. */
   __getFloat32Array(ptr: number): Float32Array;
-    /** Reads the values of Float64Array from the module's memory. */
+  /** Reads (copies) the values of Float64Array from the module's memory. */
   __getFloat64Array(ptr: number): Float64Array;
+
+  /** Reads the values of Int8Array from the module's memory. */
+  __getInt8ArrayView(ptr: number): Int8Array;
+  /** Reads the values of Uint8Array from the module's memory. */
+  __getUint8ArrayView(ptr: number): Uint8Array;
+  /** Reads the values of Uint8Array from the module's memory. */
+  __getUint8ClampedArrayView(ptr: number): Uint8ClampedArray;
+  /** Reads the values of Int16Array from the module's memory. */
+  __getInt16ArrayView(ptr: number): Int16Array;
+  /** Reads the values of Uint16Array from the module's memory. */
+  __getUint16ArrayView(ptr: number): Uint16Array;
+  /** Reads the values of Int32Array from the module's memory. */
+  __getInt32ArrayView(ptr: number): Int32Array;
+  /** Reads the values of Uint32Array from the module's memory. */
+  __getUint32ArrayView(ptr: number): Uint32Array;
+  /** Reads the values of Int32Array from the module's memory. */
+  __getInt64ArrayView?(ptr: number): BigInt64Array;
+  /** Reads the values of Uint32Array from the module's memory. */
+  __getUint64ArrayView?(ptr: number): BigUint64Array;
+  /** Reads the values of Float32Array from the module's memory. */
+  __getFloat32ArrayView(ptr: number): Float32Array;
+  /** Reads the values of Float64Array from the module's memory. */
+  __getFloat64ArrayView(ptr: number): Float64Array;
+
   /** Reads (copies) the data of an ArrayBuffer from the module's memory. */
   __getArrayBuffer(ptr: number): ArrayBuffer;
   /** Retains a reference to a managed object externally, making sure that it doesn't become collected prematurely. Returns the pointer. */
   __retain(ptr: number): number;
   /** Releases a previously retained reference to a managed object, allowing the runtime to collect it once its reference count reaches zero. */
   __release(ptr: number): void;
+  /** Resets base pointer to initial offset. Uses only for stub runtime. */
+  __reset?(): void;
   /** Allocates an instance of the class represented by the specified id. */
   __alloc(size: number, id: number): number;
   /** Tests whether a managed object is an instance of the class represented by the specified base id. */

lib/loader/index.js

@@ -217,37 +217,52 @@ function postInstantiate(baseModule, instance) {
 
   baseModule.__getArrayBuffer = __getArrayBuffer;
 
-  function getTypedArrayImpl(Type, alignLog2, ptr) {
+  function getTypedArrayView(Type, alignLog2, ptr) {
     const buffer = memory.buffer;
     const U32 = new Uint32Array(buffer);
     const bufPtr = U32[ptr + ARRAYBUFFERVIEW_DATASTART_OFFSET >>> 2];
     return new Type(buffer, bufPtr, U32[bufPtr + SIZE_OFFSET >>> 2] >>> alignLog2);
   }
 
+  function getTypedArray(Type, alignLog2, ptr) {
+    return new Type(getTypedArrayView(Type, alignLog2, ptr));
+  }
+
   /** Gets a view on the values of a known-to-be Int8Array in the module's memory. */
-  baseModule.__getInt8Array = getTypedArrayImpl.bind(null, Int8Array, 0);
+  baseModule.__getInt8Array = getTypedArray.bind(null, Int8Array, 0);
+  baseModule.__getInt8ArrayView = getTypedArrayView.bind(null, Int8Array, 0);
   /** Gets a view on the values of a known-to-be Uint8Array in the module's memory. */
-  baseModule.__getUint8Array = getTypedArrayImpl.bind(null, Uint8Array, 0);
+  baseModule.__getUint8Array = getTypedArray.bind(null, Uint8Array, 0);
+  baseModule.__getUint8ArrayView = getTypedArrayView.bind(null, Uint8Array, 0);
   /** Gets a view on the values of a known-to-be Uint8ClampedArray in the module's memory. */
-  baseModule.__getUint8ClampedArray = getTypedArrayImpl.bind(null, Uint8ClampedArray, 0);
+  baseModule.__getUint8ClampedArray = getTypedArray.bind(null, Uint8ClampedArray, 0);
+  baseModule.__getUint8ClampedArrayView = getTypedArrayView.bind(null, Uint8ClampedArray, 0);
   /** Gets a view on the values of a known-to-be Int16Array in the module's memory. */
-  baseModule.__getInt16Array = getTypedArrayImpl.bind(null, Int16Array, 1);
+  baseModule.__getInt16Array = getTypedArray.bind(null, Int16Array, 1);
+  baseModule.__getInt16ArrayView = getTypedArrayView.bind(null, Int16Array, 1);
   /** Gets a view on the values of a known-to-be Uint16Array in the module's memory. */
-  baseModule.__getUint16Array = getTypedArrayImpl.bind(null, Uint16Array, 1);
+  baseModule.__getUint16Array = getTypedArray.bind(null, Uint16Array, 1);
+  baseModule.__getUint16ArrayView = getTypedArrayView.bind(null, Uint16Array, 1);
   /** Gets a view on the values of a known-to-be Int32Array in the module's memory. */
-  baseModule.__getInt32Array = getTypedArrayImpl.bind(null, Int32Array, 2);
+  baseModule.__getInt32Array = getTypedArray.bind(null, Int32Array, 2);
+  baseModule.__getInt32ArrayView = getTypedArrayView.bind(null, Int32Array, 2);
   /** Gets a view on the values of a known-to-be Uint32Array in the module's memory. */
-  baseModule.__getUint32Array = getTypedArrayImpl.bind(null, Uint32Array, 2);
+  baseModule.__getUint32Array = getTypedArray.bind(null, Uint32Array, 2);
+  baseModule.__getUint32ArrayView = getTypedArrayView.bind(null, Uint32Array, 2);
   if (BIGINT) {
     /** Gets a view on the values of a known-to-be-Int64Array in the module's memory. */
-    baseModule.__getInt64Array = getTypedArrayImpl.bind(null, BigInt64Array, 3);
+    baseModule.__getInt64Array = getTypedArray.bind(null, BigInt64Array, 3);
+    baseModule.__getInt64ArrayView = getTypedArrayView.bind(null, BigInt64Array, 3);
     /** Gets a view on the values of a known-to-be-Uint64Array in the module's memory. */
-    baseModule.__getUint64Array = getTypedArrayImpl.bind(null, BigUint64Array, 3);
+    baseModule.__getUint64Array = getTypedArray.bind(null, BigUint64Array, 3);
+    baseModule.__getUint64ArrayView = getTypedArrayView.bind(null, BigUint64Array, 3);
   }
   /** Gets a view on the values of a known-to-be Float32Array in the module's memory. */
-  baseModule.__getFloat32Array = getTypedArrayImpl.bind(null, Float32Array, 2);
+  baseModule.__getFloat32Array = getTypedArray.bind(null, Float32Array, 2);
+  baseModule.__getFloat32ArrayView = getTypedArrayView.bind(null, Float32Array, 2);
   /** Gets a view on the values of a known-to-be Float64Array in the module's memory. */
-  baseModule.__getFloat64Array = getTypedArrayImpl.bind(null, Float64Array, 3);
+  baseModule.__getFloat64Array = getTypedArray.bind(null, Float64Array, 3);
+  baseModule.__getFloat64ArrayView = getTypedArrayView.bind(null, Float64Array, 3);
 
   /** Tests whether an object is an instance of the class represented by the specified base id. */
   function __instanceof(ptr, baseId) {

lib/loader/tests/build/untouched.wasm

@@ -95,6 +95,7 @@ assert.strictEqual(module.__getString(module.COLOR), "red");
   let ref = module.__retain(module.__allocArray(module.UINT32ARRAY_ID, arr));
   assert(module.__instanceof(ref, module.UINT32ARRAY_ID));
   assert.deepEqual(module.__getUint32Array(ref), new Uint32Array(arr));
+  assert.deepEqual(module.__getUint32ArrayView(ref), new Uint32Array(arr));
   assert.deepEqual(module.__getArray(ref), arr);
   module.__release(ref);
   try { module.__release(ref); assert(false); } catch (e) {};
@@ -106,6 +107,7 @@ assert.strictEqual(module.__getString(module.COLOR), "red");
   let ref = module.__retain(module.__allocArray(module.FLOAT32ARRAY_ID, arr));
   assert(module.__instanceof(ref, module.FLOAT32ARRAY_ID));
   assert.deepEqual(module.__getFloat32Array(ref), new Float32Array(arr));
+  assert.deepEqual(module.__getFloat32ArrayView(ref), new Float32Array(arr));
   assert.deepEqual(module.__getArray(ref), arr);
   module.__release(ref);
   try { module.__release(ref); assert(false); } catch (e) {};
@@ -154,7 +156,7 @@ module.dotrace(42);
 
 // should be able to mutate an array in place using getArrayView
 {
-  let ptr = module.__retain(module.__allocArray(module.FLOAT32ARRAY_ID, [ 1, 2, 3]));
+  let ptr = module.__retain(module.__allocArray(module.FLOAT32ARRAY_ID, [1, 2, 3]));
   let view = module.__getArrayView(ptr);
   assert.deepEqual(view, new Float32Array([1, 2, 3]));
   module.modifyFloat32Array(ptr, 0, 4);
@@ -165,12 +167,15 @@ module.dotrace(42);
 // should be able to mutate an array in place using getFloat32Array
 {
   let ptr = module.newFloat32Array(3); // returns are pre-retained
-  let view = module.__getFloat32Array(ptr);
+  let view = module.__getFloat32ArrayView(ptr);
+  let arr = module.__getFloat32Array(ptr);
   assert.deepEqual(view, new Float32Array([0, 0, 0]));
+  assert.deepEqual(arr, new Float32Array([0, 0, 0]));
   module.modifyFloat32Array(ptr, 0, 3);
   module.modifyFloat32Array(ptr, 1, 2);
   module.modifyFloat32Array(ptr, 2, 1);
   assert.deepEqual(view, new Float32Array([3, 2, 1]));
+  assert.deepEqual(arr, new Float32Array([0, 0, 0]));
   module.__release(ptr);
 }
 

lib/loader/tests/index.js

@@ -1417,6 +1417,7 @@ declare class String {
   endsWith(other: string): bool;
   indexOf(other: string, fromIndex?: i32): i32;
   lastIndexOf(other: string, fromIndex?: i32): i32;
+  localeCompare(other: string): i32;
   includes(other: string): bool;
   startsWith(other: string): bool;
   substr(start: i32, length?: i32): string;

std/assembly/index.d.ts

@@ -1,2 +1,2 @@
-export { __alloc, __retain, __release, __collect } from "rt/stub";
+export { __alloc, __retain, __release, __collect, __reset } from "rt/stub";
 export { __rtti_base } from "rt";

std/assembly/rt/index-stub.ts

@@ -260,8 +260,3 @@ export function __retain(ptr: usize): usize {
 export function __release(ptr: usize): void {
   if (ptr > __heap_base) decrement(changetype<Block>(ptr - BLOCK_OVERHEAD));
 }
-
-// @ts-ignore: decorator
-@global @unsafe
-export function __reset(): void {
-}