feat: Add __getFunction method for loader

lib/loader/index.d.ts

@@ -82,6 +82,9 @@ export interface ASUtil {
   /** Gets a live view on a Float64Array's values in the module's memory. */
   __getFloat64ArrayView(ptr: number): Float64Array;
 
+  /** Gets a function from poiner which contain table's index. */
+  __getFunction(ptr: number): ((...args: unknown[]) => unknown) | null;
+
   /** Tests whether a managed object is an instance of the class represented by the specified base id. */
   __instanceof(ptr: number, baseId: number): boolean;
   /** Allocates a new string in the module's memory and returns a reference (pointer) to it. */

lib/loader/index.js

@@ -34,6 +34,10 @@ const ARRAYBUFFERVIEW_SIZE = 12;
 const ARRAY_LENGTH_OFFSET = 12;
 const ARRAY_SIZE = 16;
 
+const E_NO_EXPORT_TABLE   = "Operation requires compiling with --exportTable";
+const E_NO_EXPORT_RUNTIME = "Operation requires compiling with --exportRuntime";
+const F_NO_EXPORT_RUNTIME = function() { throw Error(E_NO_EXPORT_RUNTIME); };
+
 const BIGINT = typeof BigUint64Array !== "undefined";
 const THIS = Symbol();
 
@@ -83,51 +87,39 @@ function preInstantiate(imports) {
   return extendedExports;
 }
 
-const E_NOEXPORTRUNTIME = "Operation requires compiling with --exportRuntime";
-const F_NOEXPORTRUNTIME = function() { throw Error(E_NOEXPORTRUNTIME); };
-
 /** Prepares the final module once instantiation is complete. */
 function postInstantiate(extendedExports, instance) {
   const exports = instance.exports;
   const memory = exports.memory;
   const table = exports.table;
-  const __new = exports.__new || F_NOEXPORTRUNTIME;
-  const __pin = exports.__pin || F_NOEXPORTRUNTIME;
-  const __unpin = exports.__unpin || F_NOEXPORTRUNTIME;
-  const __collect = exports.__collect || F_NOEXPORTRUNTIME;
+  const __new = exports.__new || F_NO_EXPORT_RUNTIME;
+  const __pin = exports.__pin || F_NO_EXPORT_RUNTIME;
+  const __unpin = exports.__unpin || F_NO_EXPORT_RUNTIME;
+  const __collect = exports.__collect || F_NO_EXPORT_RUNTIME;
   const __rtti_base = exports.__rtti_base;
-  const getRttiCount = __rtti_base
+  const getRttCount = __rtti_base
     ? function (arr) { return arr[__rtti_base >>> 2]; }
-    : F_NOEXPORTRUNTIME;
+    : F_NO_EXPORT_RUNTIME;
 
   extendedExports.__new = __new;
   extendedExports.__pin = __pin;
   extendedExports.__unpin = __unpin;
   extendedExports.__collect = __collect;
 
-  /** Gets the runtime type info for the given id. */
-  function getInfo(id) {
+  /** Gets the runtime type info for the given id and specific field. */
+  function getRtt(id, field = 0) {
     const U32 = new Uint32Array(memory.buffer);
-    const count = getRttiCount(U32);
-    if ((id >>>= 0) >= count) throw Error(`invalid id: ${id}`);
-    return U32[(__rtti_base + 4 >>> 2) + id * 2];
+    if ((id >>>= 0) >= getRttCount(U32)) throw Error(`invalid id: ${id}`);
+    return U32[(__rtti_base + 4 >>> 2) + (id << 1) + field];
   }
 
   /** Gets and validate runtime type info for the given id for array like objects */
   function getArrayInfo(id) {
-    const info = getInfo(id);
+    const info = getRtt(id);
     if (!(info & (ARRAYBUFFERVIEW | ARRAY | STATICARRAY))) throw Error(`not an array: ${id}, flags=${info}`);
     return info;
   }
 
-  /** Gets the runtime base id for the given id. */
-  function getBase(id) {
-    const U32 = new Uint32Array(memory.buffer);
-    const count = getRttiCount(U32);
-    if ((id >>>= 0) >= count) throw Error(`invalid id: ${id}`);
-    return U32[(__rtti_base + 4 >>> 2) + id * 2 + 1];
-  }
-
   /** Gets the runtime alignment of a collection's values. */
   function getValueAlign(info) {
     return 31 - Math.clz32((info >>> VAL_ALIGN_OFFSET) & 31); // -1 if none
@@ -263,6 +255,15 @@ function postInstantiate(extendedExports, instance) {
 
   extendedExports.__getArrayBuffer = __getArrayBuffer;
 
+  /** Gets a function from poiner which contain table's index. */
+  function __getFunction(ptr) {
+    if (!table) throw Error(E_NO_EXPORT_TABLE);
+    const index = new Uint32Array(memory.buffer)[ptr >>> 2];
+    return table.get(index);
+  }
+
+  extendedExports.__getFunction = __getFunction;
+
   /** Copies a typed array's values from the module's memory. */
   function getTypedArray(Type, alignLog2, ptr) {
     return new Type(getTypedArrayView(Type, alignLog2, ptr));
@@ -306,10 +307,10 @@ function postInstantiate(extendedExports, instance) {
   function __instanceof(ptr, baseId) {
     const U32 = new Uint32Array(memory.buffer);
     let id = U32[ptr + ID_OFFSET >>> 2];
-    if (id <= getRttiCount(U32)) {
+    if (id <= getRttCount(U32)) {
       do {
         if (id == baseId) return true;
-        id = getBase(id);
+        id = getRtt(id, 1); // gets runtime base
       } while (id);
     }
     return false;

lib/loader/package.json

@@ -11,6 +11,9 @@
   ],
   "version": "0.0.0",
   "author": "Daniel Wirtz <[email protected]>",
+  "contributors": [
+    "MaxGraey <[email protected]>"
+  ],
   "license": "Apache-2.0",
   "homepage": "https://assemblyscript.org",
   "repository": {
@@ -30,8 +33,8 @@
   },
   "scripts": {
     "asbuild": "npm run asbuild:default && npm run asbuild:legacy",
-    "asbuild:default": "node ../../bin/asc tests/assembly/index.ts --binaryFile tests/build/default.wasm --exportRuntime",
-    "asbuild:legacy": "node ../../bin/asc tests/assembly/index.ts --disable mutable-globals --binaryFile tests/build/legacy.wasm --exportRuntime",
+    "asbuild:default": "node ../../bin/asc tests/assembly/index.ts --binaryFile tests/build/default.wasm --exportRuntime --exportTable",
+    "asbuild:legacy": "node ../../bin/asc tests/assembly/index.ts --disable mutable-globals --binaryFile tests/build/legacy.wasm --exportRuntime --exportTable",
     "build": "npx esm2umd loader index.js > umd/index.js",
     "test": "node tests && node tests/umd"
   },

lib/loader/tests/assembly/index.ts

@@ -69,6 +69,10 @@ export function dotrace(num: f64): void {
   trace("The answer is", 1, num);
 }
 
+export function getVaraddFunc(): (a: i32, b: i32) => i32 {
+  return varadd;
+}
+
 export const UINT8ARRAY_ID = idof<Uint8Array>();
 export const INT16ARRAY_ID = idof<Int16Array>();
 export const UINT16ARRAY_ID = idof<Uint16Array>();

lib/loader/tests/index.js

@@ -231,6 +231,16 @@ function test(file) {
   assert.strictEqual(car.isDoorsOpen, 0);
   assert(typeof +car === "number"); // uses Car.prototype.valueOf to obtain `thisPtr`
 
+  // should be able to return a function
+  {
+    const addFunc = exports.__getFunction(exports.getVaraddFunc());
+    assert(typeof addFunc === "function");
+    assert.strictEqual(addFunc(1, 2), 3);
+
+    const invalidFunc = exports.__getFunction(0);
+    assert(invalidFunc == null);
+  }
+
   // should be able to use trace
   exports.dotrace(42);
 
@@ -261,32 +271,43 @@ function test(file) {
 function testInstantiate(file) {
   // should be able to instantiate from a buffer
   (async () => {
-    const { exports, instance, module } = await loader.instantiate(fs.readFileSync(__dirname + "/build/" + file), {});
+    const { exports, instance, module } = await loader.instantiate(
+      fs.readFileSync(__dirname + "/build/" + file),
+      {}
+    );
     assert(exports.memory);
     assert(instance && instance instanceof WebAssembly.Instance);
     assert(module   && module instanceof WebAssembly.Module);
   })();
 
   // should be able to instantiate from a wasm module
   (async () => {
-    const wasmModule = new WebAssembly.Module(fs.readFileSync(__dirname + "/build/" + file));
-    const { exports, instance, module } = await loader.instantiate(wasmModule, {});
+    const { exports, instance, module } = await loader.instantiate(
+      new WebAssembly.Module(fs.readFileSync(__dirname + "/build/" + file)),
+      {}
+    );
     assert(exports.memory);
     assert(instance && instance instanceof WebAssembly.Instance);
     assert(module   && module instanceof WebAssembly.Module);
   })();
 
   // should be able to instantiate from a promise yielding a buffer
   (async () => {
-    const { exports, instance, module } = await loader.instantiate(fs.promises.readFile(__dirname + "/build/" + file), {});
+    const { exports, instance, module } = await loader.instantiate(
+      fs.promises.readFile(__dirname + "/build/" + file),
+      {}
+    );
     assert(exports.memory);
     assert(instance && instance instanceof WebAssembly.Instance);
     assert(module   && module instanceof WebAssembly.Module);
   })();
 
   // should be able to mimic instantiateStreaming under node (for now)
   (async () => {
-    const { exports, instance, module } = await loader.instantiateStreaming(fs.promises.readFile(__dirname + "/build/" + file), {});
+    const { exports, instance, module } = await loader.instantiateStreaming(
+      fs.promises.readFile(__dirname + "/build/" + file),
+      {}
+    );
     assert(exports.memory);
     assert(instance && instance instanceof WebAssembly.Instance);
     assert(module   && module instanceof WebAssembly.Module);