RFC: Fix dyncalls api

emcc.py

@@ -1282,6 +1282,10 @@ def default_setting(name, new_default):
     if shared.Settings.CLOSURE_WARNINGS not in ['quiet', 'warn', 'error']:
       exit_with_error('Invalid option -s CLOSURE_WARNINGS=%s specified! Allowed values are "quiet", "warn" or "error".' % shared.Settings.CLOSURE_WARNINGS)
 
+    # Calling function pointers from JS libraries is default runtime functionality, so always include the functionality. (to be DCEd if not used)
+    if shared.Settings.WASM_DYNCALLS:
+      shared.Settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE += ['$dynCall']
+
     if shared.Settings.MAIN_MODULE:
       assert not shared.Settings.SIDE_MODULE
       if shared.Settings.MAIN_MODULE == 1:
@@ -1707,7 +1711,7 @@ def check_memory_setting(setting):
     if shared.Settings.USE_PTHREADS or shared.Settings.RELOCATABLE or shared.Settings.ASYNCIFY_LAZY_LOAD_CODE or shared.Settings.WASM2JS:
       shared.Settings.IMPORTED_MEMORY = 1
 
-    if shared.Settings.WASM_BIGINT:
+    if shared.Settings.WASM_BIGINT and not shared.Settings.WASM_DYNCALLS:
       shared.Settings.LEGALIZE_JS_FFI = 0
 
     shared.Settings.GENERATE_SOURCE_MAP = shared.Settings.DEBUG_LEVEL >= 4 and not shared.Settings.SINGLE_FILE
@@ -2420,11 +2424,13 @@ def consume_arg_file():
         options.llvm_opts = ['-Os']
         options.requested_level = 2
         shared.Settings.SHRINK_LEVEL = 1
+        shared.Settings.USE_LEGACY_DYNCALLS = 0 # In -Os builds, use a more size compact, but slower 'wasmTable.get()' method of accessing function pointers
         settings_changes.append('INLINING_LIMIT=50')
       elif options.requested_level == 'z':
         options.llvm_opts = ['-Oz']
         options.requested_level = 2
         shared.Settings.SHRINK_LEVEL = 2
+        shared.Settings.USE_LEGACY_DYNCALLS = 0 # In -Oz builds, use a more size compact, but slower 'wasmTable.get()' method of accessing function pointers
         settings_changes.append('INLINING_LIMIT=25')
       shared.Settings.OPT_LEVEL = validate_arg_level(options.requested_level, 3, 'Invalid optimization level: ' + arg, clamp=True)
     elif check_arg('--js-opts'):

emscripten.py

@@ -37,14 +37,46 @@
 WASM_INIT_FUNC = '__wasm_call_ctors'
 
 
+def make_wasm_table_static_dyncaller(func):
+  sig = func.replace('dynCall_', '')
+  ret = '' if sig[0] == 'v' else 'return '
+  args = '' # 'a0, a1, a2, ..., aN'
+  ptr_args = '' # 'ptr, a0, a1, a2, ..., aN'
+  i = 0
+  while i < len(sig)-1:
+    if i > 0: args += ', '
+    args += 'a' + str(i)
+    i += 1
+  ptr_args = ('ptr, ' + args) if len(args) > 0 else 'ptr'
+
+  dyncall = ('dyncalls["' + sig + '"]') if shared.Settings.MINIMAL_RUNTIME else ('Module["' + func + '"]')
+  wasmTableGet = 'wasmTableGet' if shared.Settings.SHRINK_LEVEL == 0 else 'wasmTable.get'
+  return 'function ' + func + '(' + ptr_args + ') { ' + ret + dyncall + '(' + ptr_args + '); }\n'
+
+
 def compute_minimal_runtime_initializer_and_exports(post, exports, receiving):
   # Declare all exports out to global JS scope so that JS library functions can access them in a
   # way that minifies well with Closure
   # e.g. var a,b,c,d,e,f;
   exports_that_are_not_initializers = [x for x in exports if x not in WASM_INIT_FUNC]
   # In Wasm backend the exports are still unmangled at this point, so mangle the names here
   exports_that_are_not_initializers = [asmjs_mangle(x) for x in exports_that_are_not_initializers]
+
+  static_dyncall_sig_functions = ''
+
+  if shared.Settings.WASM_DYNCALLS:
+    if len([x for x in exports_that_are_not_initializers if x.startswith('dynCall_')]) > 0:
+      exports_that_are_not_initializers += ['dynCalls = {}']
+  else:
+    for x in exports_that_are_not_initializers:
+      if x.startswith('dynCall_'):
+        static_dyncall_sig_functions += make_wasm_table_static_dyncaller(x) + '\n'
+
+    exports_that_are_not_initializers = [x for x in exports_that_are_not_initializers if not x.startswith('dynCall_')]
+
   post = post.replace('/*** ASM_MODULE_EXPORTS_DECLARES ***/', 'var ' + ',\n  '.join(exports_that_are_not_initializers) + ';')
+# TODO: Check codegen again
+#  post = post.replace('/*** STATIC_DYNCALL_SIG_FUNCTIONS ***/', static_dyncall_sig_functions)
 
   # Generate assignments from all asm.js/wasm exports out to the JS variables above: e.g. a = asm['a']; b = asm['b'];
   post = post.replace('/*** ASM_MODULE_EXPORTS ***/', receiving)
@@ -399,9 +431,9 @@ def finalize_wasm(infile, outfile, memfile, DEBUG):
   # (which matches what llvm+lld has given us)
   if shared.Settings.DEBUG_LEVEL >= 2 or shared.Settings.ASYNCIFY_ADD or shared.Settings.ASYNCIFY_ADVISE or shared.Settings.ASYNCIFY_ONLY or shared.Settings.ASYNCIFY_REMOVE or shared.Settings.EMIT_SYMBOL_MAP or shared.Settings.PROFILING_FUNCS:
     args.append('-g')
-  if shared.Settings.WASM_BIGINT:
+  if shared.Settings.WASM_BIGINT and not shared.Settings.WASM_DYNCALLS: # TODO: This may be troublematic?
     args.append('--bigint')
-  if shared.Settings.USE_LEGACY_DYNCALLS:
+  if True:##shared.Settings.USE_LEGACY_DYNCALLS:
     # we need to add all dyncalls to the wasm
     modify_wasm = True
   else:
@@ -698,6 +730,10 @@ def create_receiving(exports):
 
   exports_that_are_not_initializers = [x for x in exports if x != WASM_INIT_FUNC]
 
+  # If we are not building with dynCall() support, filter out all the dynCall_ exports.
+  if not shared.Settings.WASM_DYNCALLS:
+    exports_that_are_not_initializers = [x for x in exports_that_are_not_initializers if not x.startswith('dynCall_')]
+
   receiving = []
 
   # with WASM_ASYNC_COMPILATION that asm object may not exist at this point in time
@@ -710,7 +746,10 @@ def create_receiving(exports):
       # WebAssembly.instantiate(Module["wasm"], imports).then((function(output) {
       # var asm = output.instance.exports;
       # _main = asm["_main"];
-      receiving += [asmjs_mangle(s) + ' = asm["' + s + '"];' for s in exports_that_are_not_initializers]
+      for s in exports_that_are_not_initializers:
+        mangled = asmjs_mangle(s)
+        dynCallAssignment = ('dynCalls["' + s.replace('dynCall_', '') + '"] = ') if shared.Settings.WASM_DYNCALLS and mangled.startswith('dynCall_') else ''
+        receiving += [dynCallAssignment + mangled + ' = asm["' + s + '"];']
     else:
       if shared.Settings.MINIMAL_RUNTIME:
         # In wasm2js exports can be directly processed at top level, i.e.

src/library.js

@@ -3696,62 +3696,6 @@ LibraryManager.library = {
     });
   },
 
-#if USE_LEGACY_DYNCALLS || !WASM_BIGINT
-  $dynCallLegacy: function(sig, ptr, args) {
-#if ASSERTIONS
-    assert(('dynCall_' + sig) in Module, 'bad function pointer type - no table for sig \'' + sig + '\'');
-    if (args && args.length) {
-      // j (64-bit integer) must be passed in as two numbers [low 32, high 32].
-      assert(args.length === sig.substring(1).replace(/j/g, '--').length);
-    } else {
-      assert(sig.length == 1);
-    }
-#endif
-    if (args && args.length) {
-      return Module['dynCall_' + sig].apply(null, [ptr].concat(args));
-    }
-    return Module['dynCall_' + sig].call(null, ptr);
-  },
-  $dynCall__deps: ['$dynCallLegacy'],
-
-  // Used in library code to get JS function from wasm function pointer.
-  // All callers should use direct table access where possible and only fall
-  // back to this function if needed.
-  $getDynCaller__deps: ['$dynCall'],
-  $getDynCaller: function(sig, ptr) {
-#if !USE_LEGACY_DYNCALLS
-    assert(sig.indexOf('j') >= 0, 'getDynCaller should only be called with i64 sigs')
-#endif
-    var argCache = [];
-    return function() {
-      argCache.length = arguments.length;
-      for (var i = 0; i < arguments.length; i++) {
-        argCache[i] = arguments[i];
-      }
-      return dynCall(sig, ptr, argCache);
-    };
-  },
-#endif
-
-  $dynCall: function(sig, ptr, args) {
-#if USE_LEGACY_DYNCALLS
-    return dynCallLegacy(sig, ptr, args);
-#else
-#if !WASM_BIGINT
-    // Without WASM_BIGINT support we cannot directly call function with i64 as
-    // part of thier signature, so we rely the dynCall functions generated by
-    // wasm-emscripten-finalize
-    if (sig.indexOf('j') != -1) {
-      return dynCallLegacy(sig, ptr, args);
-    }
-#endif
-#if ASSERTIONS
-    assert(wasmTable.get(ptr), 'missing table entry in dynCall: ' + ptr);
-#endif
-    return wasmTable.get(ptr).apply(null, args)
-#endif
-  },
-
   $callRuntimeCallbacks: function(callbacks) {
     while(callbacks.length > 0) {
       var callback = callbacks.shift();

src/library_dyncall.js

@@ -0,0 +1,78 @@
+mergeInto(LibraryManager.library, {
+  {{{ (function() { global.wbind = function() { return SHRINK_LEVEL == 0 ? 'wbind' : 'wasmTable.get'; }; return null; })(); }}}
+  {{{ (function() { global.getDynCaller = function(sig) { return MINIMAL_RUNTIME ? `dynCalls[${sig}]` : `Module["dynCall_"+${sig}]`; }; return null; })(); }}}
+
+#if SHRINK_LEVEL == 0
+  // A mirror copy of contents of wasmTable in JS side, to avoid relatively
+  // slow wasmTable.get() call. Only used when not compiling with -Os or -Oz.
+  _wasmTableMirror: [],
+
+  $wbind__deps: ['_wasmTableMirror'],
+  $wbind: function(funcPtr) {
+    var func = __wasmTableMirror[funcPtr];
+    if (!func) {
+      if (funcPtr >= __wasmTableMirror.length) __wasmTableMirror.length = funcPtr + 1;
+      __wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
+    }
+    return func;
+  },
+
+#if WASM_DYNCALLS
+  $dynCall__deps: ['$wbind'],
+  $bindDynCall__deps: ['$wbind'],
+#endif
+  $wbindArray__deps: ['$wbind'],
+#else
+  $wbind: function(funcPtr) {
+    // In -Os and -Oz builds, do not implement a JS side wasm table mirror for small
+    // code size, but directly access wasmTable, which is a bit slower.
+    return wasmTable.get(funcPtr);
+  },
+#endif
+
+  // A helper that binds a wasm function into a form that can be called by passing all
+  // the parameters in an array, e.g. wbindArray(func)([param1, param2, ..., paramN]).
+  $wbindArray: function(funcPtr) {
+    var func = {{{wbind()}}}(funcPtr);
+    return func.length
+      ? function(args) { return func.apply(null, args); }
+      : function() { return func(); }
+  },
+
+#if WASM_DYNCALLS
+  // A helper that returns a function that can be used to invoke function pointers, i.e.
+  // getDynCaller('vi')(funcPtr, myInt);
+  $getDynCaller: function(sig, funcPtr) {
+    return {{{getDynCaller('sig')}}};
+  },
+
+  $bindDynCall: function(sig, funcPtr) {
+    // For int64 signatures, use the dynCall_sig dispatch mechanism.
+    if (sig.includes('j')) return function(args) {
+      return {{{getDynCaller('sig')}}}.apply(null, [funcPtr].concat(args));
+    }
+    // For non-int64 signatures, invoke via the wasm table.
+    var func = {{{wbind()}}}(funcPtr);
+    return func.length
+      ? function(args) { return func.apply(null, args); }
+      : function() { return func(); }
+  },
+
+#if SHRINK_LEVEL
+  $dynCall__deps: ['$bindDynCall'],
+#endif
+  $dynCall: function(sig, funcPtr, args) {
+#if SHRINK_LEVEL
+    return bindDynCall(sig, funcPtr)(args);
+#else
+    // For int64 signatures, use the dynCall_sig dispatch mechanism.
+    if (sig.includes('j')) {
+      return {{{getDynCaller('sig')}}}.apply(null, [funcPtr].concat(args));
+    }
+
+    // For non-int64 signatures, invoke via the wasm table.
+    return {{{wbind()}}}(funcPtr).apply(null, args);
+#endif
+  },
+#endif
+});

src/modules.js

@@ -62,6 +62,7 @@ var LibraryManager = {
     // Core system libraries (always linked against)
     var libraries = [
       'library.js',
+      'library_dyncall.js',
       'library_stack.js',
       'library_formatString.js',
       'library_math.js',

src/postamble_minimal.js

@@ -123,6 +123,9 @@ function loadWasmModuleToWorkers() {
 /*** ASM_MODULE_EXPORTS_DECLARES ***/
 #endif
 
+/*** STATIC_DYNCALL_SIG_FUNCTIONS ***/
+
+
 #if MINIMAL_RUNTIME_STREAMING_WASM_INSTANTIATION
 // https://caniuse.com/#feat=wasm and https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming
 // Firefox 52 added Wasm support, but only Firefox 58 added instantiateStreaming.
@@ -222,7 +225,7 @@ WebAssembly.instantiate(Module['wasm'], imports).then(function(output) {
   initRuntime(asm);
 #if USE_PTHREADS && PTHREAD_POOL_SIZE
   if (!ENVIRONMENT_IS_PTHREAD) loadWasmModuleToWorkers();
-#if !PTHREAD_POOL_DELAY_LOAD  
+#if !PTHREAD_POOL_DELAY_LOAD
   else
 #endif
     ready();

src/settings.js

@@ -1145,6 +1145,10 @@ var BINARYEN_EXTRA_PASSES = "";
 // (This option was formerly called BINARYEN_ASYNC_COMPILATION)
 var WASM_ASYNC_COMPILATION = 1;
 
+// If true, enables emitting dynCall() and dynCall_sig() based function pointer
+// invokers to call function pointers from JS to Wasm.
+var WASM_DYNCALLS = 1;
+
 // WebAssembly integration with JavaScript BigInt. When enabled we don't need
 // to legalize i64s into pairs of i32s, as the wasm VM will use a BigInt where
 // an i64 is used.

src/settings_internal.js

@@ -175,7 +175,7 @@ var EXPECT_MAIN = 1;
 // MODULARIZE, and returned from the factory function.
 var EXPORT_READY_PROMISE = 1;
 
-var USE_LEGACY_DYNCALLS = 0;
+var USE_LEGACY_DYNCALLS = 1;
 
 // struct_info that is either generated or cached
 var STRUCT_INFO = '';