Allow DECLARE_ASM_MODULE_EXPORTS=0 + WASM_ASYNC_COMPILATION (#10348)

Fixes: #10217

Author: sbc100

emcc.py

@@ -1674,12 +1674,6 @@ def is_supported_link_flag(f):
         # async compilation requires a swappable module - we swap it in when it's ready
         shared.Settings.SWAPPABLE_ASM_MODULE = 1
 
-      if shared.Settings.SWAPPABLE_ASM_MODULE and not shared.Settings.DECLARE_ASM_MODULE_EXPORTS:
-        # Swappable wasm module/asynchronous wasm compilation requires an indirect stub
-        # function generated to each function export from wasm module, so cannot use the
-        # concise form of grabbing exports that does not need to refer to each export individually.
-        exit_with_error('DECLARE_ASM_MODULE_EXPORTS=0 is not comptabible with SWAPPABLE_ASM_MODULE')
-
       # wasm side modules have suffix .wasm
       if shared.Settings.SIDE_MODULE and target.endswith('.js'):
         shared.warning('output suffix .js requested, but wasm side modules are just wasm files; emitting only a .wasm, no .js')

emscripten.py

@@ -1719,23 +1719,24 @@ def create_receiving(function_table_data, function_tables_defs, exported_impleme
   module_exports = exported_implemented_functions + function_tables(function_table_data)
   shared.Settings.MODULE_EXPORTS = [(f, f) for f in module_exports]
 
-  if not shared.Settings.SWAPPABLE_ASM_MODULE:
-    if runtime_assertions:
-      # assert on the runtime being in a valid state when calling into compiled code. The only
-      # exceptions are some support code.
-      receiving_functions = [f for f in exported_implemented_functions if f not in ('_memcpy', '_memset', '_emscripten_replace_memory', '__start_module')]
-
-      wrappers = []
-      for name in receiving_functions:
-        wrappers.append('''\
-var real_%(name)s = asm["%(name)s"];
-asm["%(name)s"] = function() {%(runtime_assertions)s
-  return real_%(name)s.apply(null, arguments);
-};
-''' % {'name': name, 'runtime_assertions': runtime_assertions})
-      receiving += '\n'.join(wrappers)
+  if not shared.Settings.DECLARE_ASM_MODULE_EXPORTS:
+    receiving += 'exportAsmFunctions(asm);'
+  else:
+    if not shared.Settings.SWAPPABLE_ASM_MODULE:
+      if runtime_assertions:
+        # assert on the runtime being in a valid state when calling into compiled code. The only
+        # exceptions are some support code.
+        receiving_functions = [f for f in exported_implemented_functions if f not in ('_memcpy', '_memset', '_emscripten_replace_memory', '__start_module')]
+        wrappers = []
+        for name in receiving_functions:
+          wrappers.append('''\
+  var real_%(name)s = asm["%(name)s"];
+  asm["%(name)s"] = function() {%(runtime_assertions)s
+    return real_%(name)s.apply(null, arguments);
+  };
+  ''' % {'name': name, 'runtime_assertions': runtime_assertions})
+        receiving += '\n'.join(wrappers)
 
-    if shared.Settings.DECLARE_ASM_MODULE_EXPORTS:
       imported_exports = [s for s in module_exports if s not in initializers]
 
       if shared.Settings.WASM and shared.Settings.MINIMAL_RUNTIME:
@@ -1754,18 +1755,16 @@ def create_receiving(function_table_data, function_tables_defs, exported_impleme
         else:
           receiving += '\n'.join(['var ' + s + ' = Module["' + s + '"] = asm["' + s + '"];' for s in module_exports]) + '\n'
     else:
-      receiving += 'exportAsmFunctions(asm);'
-  else:
-    receiving += 'Module["asm"] = asm;\n'
-    wrappers = []
-    for name in module_exports:
-      wrappers.append('''\
+      receiving += 'Module["asm"] = asm;\n'
+      wrappers = []
+      for name in module_exports:
+        wrappers.append('''\
 var %(name)s = Module["%(name)s"] = function() {%(runtime_assertions)s
   return Module["asm"]["%(name)s"].apply(null, arguments)
 };
 ''' % {'name': name, 'runtime_assertions': runtime_assertions})
 
-    receiving += '\n'.join(wrappers)
+      receiving += '\n'.join(wrappers)
 
   if shared.Settings.EXPORT_FUNCTION_TABLES and not shared.Settings.WASM:
     for table in function_table_data.values():
@@ -2613,6 +2612,11 @@ def fix_import_name(g):
 
 
 def create_receiving_wasm(exports, initializers):
+  # When not declaring asm exports this section is empty and we instead programatically export
+  # synbols on the global object by calling exportAsmFunctions after initialization
+  if not shared.Settings.DECLARE_ASM_MODULE_EXPORTS:
+    return ''
+
   exports_that_are_not_initializers = [x for x in exports if x not in initializers]
 
   receiving = []
@@ -2631,24 +2635,21 @@ def create_receiving_wasm(exports, initializers):
   return real_%(mangled)s.apply(null, arguments);
 };
 ''' % {'mangled': asmjs_mangle(e), 'e': e, 'assertions': runtime_assertions})
-    if shared.Settings.DECLARE_ASM_MODULE_EXPORTS:
-      if shared.Settings.WASM and shared.Settings.MINIMAL_RUNTIME:
-        # In Wasm exports are assigned inside a function to variables existing in top level JS scope, i.e.
-        # var _main;
-        # 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]
-      else:
-        if shared.Settings.MINIMAL_RUNTIME:
-          # In wasm2js exports can be directly processed at top level, i.e.
-          # var asm = Module["asm"](asmGlobalArg, asmLibraryArg, buffer);
-          # var _main = asm["_main"];
-          receiving += ['var ' + asmjs_mangle(s) + ' = asm["' + asmjs_mangle(s) + '"];' for s in exports_that_are_not_initializers]
-        else:
-          receiving += ['var ' + asmjs_mangle(s) + ' = Module["' + asmjs_mangle(s) + '"] = asm["' + s + '"];' for s in exports]
+    if shared.Settings.WASM and shared.Settings.MINIMAL_RUNTIME:
+      # In Wasm exports are assigned inside a function to variables existing in top level JS scope, i.e.
+      # var _main;
+      # 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]
     else:
-      receiving.append('exportAsmFunctions(asm);')
+      if shared.Settings.MINIMAL_RUNTIME:
+        # In wasm2js exports can be directly processed at top level, i.e.
+        # var asm = Module["asm"](asmGlobalArg, asmLibraryArg, buffer);
+        # var _main = asm["_main"];
+        receiving += ['var ' + asmjs_mangle(s) + ' = asm["' + asmjs_mangle(s) + '"];' for s in exports_that_are_not_initializers]
+      else:
+        receiving += ['var ' + asmjs_mangle(s) + ' = Module["' + asmjs_mangle(s) + '"] = asm["' + s + '"];' for s in exports]
   else:
     receiving.append('Module["asm"] = asm;')
     for e in exports:

src/postamble_minimal.js

@@ -129,12 +129,14 @@ WebAssembly.instantiate(Module['wasm'], imports).then(function(output) {
 #else
   asm = output.instance.exports;
 #endif
-
 #if USE_OFFSET_CONVERTER
   wasmOffsetConverter = new WasmOffsetConverter(Module['wasm'], output.module);
 #endif
-
+#if !DECLARE_ASM_MODULE_EXPORTS
+  exportAsmFunctions(asm);
+#else
   /*** ASM_MODULE_EXPORTS ***/
+#endif
   initRuntime(asm);
   ready();
 })

src/preamble.js

@@ -909,6 +909,11 @@ function createWasm() {
     exports = Asyncify.instrumentWasmExports(exports);
 #endif
     Module['asm'] = exports;
+#if !DECLARE_ASM_MODULE_EXPORTS
+    // If we didn't declare the asm exports as top level enties this function
+    // is in charge of programatically exporting them on the global object.
+    exportAsmFunctions(exports);
+#endif
 #if STANDALONE_WASM
     // In pure wasm mode the memory is created in the wasm (not imported), and
     // then exported.

tests/test_core.py

@@ -3646,7 +3646,7 @@ def dylink_test(self, main, side, expected=None, header=None, main_emcc_args=[],
       print('flip')
       self.dylink_test(side, main, expected, header, main_emcc_args, force_c, need_reverse=False, **kwargs)
 
-  def do_basic_dylink_test(self):
+  def do_basic_dylink_test(self, need_reverse=True):
     self.dylink_test(r'''
       #include <stdio.h>
       #include "header.h"
@@ -3661,12 +3661,17 @@ def do_basic_dylink_test(self):
       int sidey() {
         return 11;
       }
-    ''', 'other says 11.', 'extern "C" int sidey();')
+    ''', 'other says 11.', 'extern "C" int sidey();', need_reverse=need_reverse)
 
   @needs_dlfcn
   def test_dylink_basics(self):
     self.do_basic_dylink_test()
 
+  @needs_dlfcn
+  def test_dylink_no_export(self):
+    self.set_setting('NO_DECLARE_ASM_MODULE_EXPORTS')
+    self.do_basic_dylink_test()
+
   @needs_dlfcn
   def test_dylink_memory_growth(self):
     if not self.is_wasm():
@@ -8305,7 +8310,6 @@ def test_minimal_runtime_hello_world(self, args):
 
   # Test that printf() works in MINIMAL_RUNTIME=1
   @no_emterpreter
-  @no_wasm_backend('MINIMAL_RUNTIME not yet available in Wasm backend')
   @parameterized({
     'fs': (['-s', 'FORCE_FILESYSTEM=1'],),
     'nofs': (['-s', 'NO_FILESYSTEM=1'],),

tests/test_other.py

@@ -9536,10 +9536,6 @@ def test_add_emscripten_metadata_not_emitted(self):
   def test_function_exports_are_small(self):
     def test(wasm, closure, opt):
       extra_args = wasm + opt + closure
-      if self.is_wasm_backend() and 'WASM_ASYNC_COMPILATION=0' not in extra_args:
-        # TODO: re-enable once we allow WASM_ASYNC_COMPILATION+DECLARE_ASM_MODULE_EXPORTS
-        # https://github.com/emscripten-core/emscripten/issues/10217
-        return
       print(extra_args)
       args = [PYTHON, EMCC, path_from_root('tests', 'long_function_name_in_export.c'), '-o', 'a.html', '-s', 'ENVIRONMENT=web', '-s', 'DECLARE_ASM_MODULE_EXPORTS=0', '-Werror'] + extra_args
       run_process(args)