[MINIMAL_RUNTIME] Remove WASM_MODULE_EXPORTS replacement. NFC (#23405)

Followup to #23403

We now generate a new function called `assignWasmExports` which gets
called instead of the `WASM_MODULE_EXPORTS` replacement.

As is evident from the lack of code size changes closure is able to
inline this function.

The motivation for this change is 3-fold:

1. Remove differences between MINIMAL_RUNTIME and regular runtime.
2. Simplifies and logic by removing magic late stage replacement.
3. Sets the stage for regular runtime to use the same technique.

Author: sbc100

src/postamble_minimal.js

@@ -183,7 +183,7 @@ WebAssembly.instantiate(Module['wasm'], imports).then((output) => {
 #if !DECLARE_ASM_MODULE_EXPORTS
   exportWasmSymbols(wasmExports);
 #else
-  <<< WASM_MODULE_EXPORTS >>>
+  assignWasmExports(wasmExports);
 #endif
 #if '$wasmTable' in addedLibraryItems
   wasmTable = wasmExports['__indirect_function_table'];

test/js_optimizer/minimal-runtime-2-emitDCEGraph.js

@@ -65,11 +65,14 @@ var imports = {
  }
 };
 var _main, _unused, wasmExports;
-WebAssembly.instantiate(Module["wasm"], imports).then(((output) => {
- wasmExports = output.instance.exports;
+function assignWasmExports(wasmExports) {
  _main = wasmExports["b"];
  _unused = wasmExports["c"];
- initRuntime();
+}
+WebAssembly.instantiate(Module["wasm"], imports).then(((output) => {
+ wasmExports = output.instance.exports;
+ assignWasmExports(wasmExports);
+ initRuntime(wasmExports);
  ready();
 }));
 

test/js_optimizer/minimal-runtime-emitDCEGraph.js

@@ -36,7 +36,7 @@ var wasmImports = {
 function run() {
  var ret = _main();
 }
-function initRuntime() {
+function initRuntime(wasmExports) {
  for (var i in __ATINIT__) __ATINIT__[i].func();
 }
 var env = wasmImports;
@@ -65,11 +65,15 @@ var imports = {
  }
 };
 var _main, _unused;
-WebAssembly.instantiate(Module["wasm"], imports).then(((output) => {
- var wasmExports = output.instance.exports;
+function assignWasmExports(wasmExports) {
  _main = wasmExports["b"];
  _unused = wasmExports["c"];
- initRuntime();
+}
+
+WebAssembly.instantiate(Module["wasm"], imports).then(((output) => {
+ var wasmExports = output.instance.exports;
+ assignWasmExports(wasmExports);
+ initRuntime(wasmExports);
  ready();
 }));
 

tools/acorn-optimizer.mjs

@@ -674,9 +674,7 @@ function emitDCEGraph(ast) {
   //
   // or, in the minimal runtime, it looks like
   //
-  //  WebAssembly.instantiate(Module["wasm"], imports).then((output) => {
-  //   var wasmExports = output.instance.exports; // may also not have "var", if
-  //                                              // declared outside and used elsewhere
+  //  function assignWasmExports(wasmExports)
   //   ..
   //   _malloc = wasmExports["malloc"];
   //   ..
@@ -801,79 +799,45 @@ function emitDCEGraph(ast) {
           emptyOut(node);
         }
       } else if (node.type === 'FunctionDeclaration') {
-        if (!specialScopes) {
-          defuns.push(node);
-          const name = node.id.name;
-          nameToGraphName[name] = getGraphName(name, 'defun');
-          emptyOut(node); // ignore this in the second pass; we scan defuns separately
-        }
-      } else if (node.type === 'ArrowFunctionExpression') {
-        assert(specialScopes > 0);
-        specialScopes--;
+        const name = node.id.name;
         // Check if this is the minimal runtime exports function, which looks like
-        //   (output) => { var wasmExports = output.instance.exports;
+        //   function assignWasmExports(wasmExports)
         if (
+          name == 'assignWasmExports' &&
           node.params.length === 1 &&
           node.params[0].type === 'Identifier' &&
-          node.params[0].name === 'output' &&
-          node.body.type === 'BlockStatement'
+          node.params[0].name === 'wasmExports'
         ) {
+          // This looks very much like what we are looking for.
           const body = node.body.body;
-          if (body.length >= 1) {
-            const first = body[0];
-            let target;
-            let value; // "(var?) target = value"
-            // Look either for  var wasmExports =  or just   wasmExports =
-            if (first.type === 'VariableDeclaration' && first.declarations.length === 1) {
-              const decl = first.declarations[0];
-              target = decl.id;
-              value = decl.init;
-            } else if (
-              first.type === 'ExpressionStatement' &&
-              first.expression.type === 'AssignmentExpression'
+          assert(!foundMinimalRuntimeExports);
+          foundMinimalRuntimeExports = true;
+          for (let i = 0; i < body.length; i++) {
+            const item = body[i];
+            if (
+              item.type === 'ExpressionStatement' &&
+              item.expression.type === 'AssignmentExpression' &&
+              item.expression.operator === '=' &&
+              item.expression.left.type === 'Identifier' &&
+              item.expression.right.type === 'MemberExpression' &&
+              item.expression.right.object.type === 'Identifier' &&
+              item.expression.right.object.name === 'wasmExports' &&
+              item.expression.right.property.type === 'Literal'
             ) {
-              const assign = first.expression;
-              if (assign.operator === '=') {
-                target = assign.left;
-                value = assign.right;
-              }
-            }
-            if (target && target.type === 'Identifier' && target.name === 'wasmExports' && value) {
-              if (
-                value.type === 'MemberExpression' &&
-                value.object.type === 'MemberExpression' &&
-                value.object.object.type === 'Identifier' &&
-                value.object.object.name === 'output' &&
-                value.object.property.type === 'Identifier' &&
-                value.object.property.name === 'instance' &&
-                value.property.type === 'Identifier' &&
-                value.property.name === 'exports'
-              ) {
-                // This looks very much like what we are looking for.
-                assert(!foundMinimalRuntimeExports);
-                for (let i = 1; i < body.length; i++) {
-                  const item = body[i];
-                  if (
-                    item.type === 'ExpressionStatement' &&
-                    item.expression.type === 'AssignmentExpression' &&
-                    item.expression.operator === '=' &&
-                    item.expression.left.type === 'Identifier' &&
-                    item.expression.right.type === 'MemberExpression' &&
-                    item.expression.right.object.type === 'Identifier' &&
-                    item.expression.right.object.name === 'wasmExports' &&
-                    item.expression.right.property.type === 'Literal'
-                  ) {
-                    const name = item.expression.left.name;
-                    const asmName = item.expression.right.property.value;
-                    saveAsmExport(name, asmName);
-                    emptyOut(item); // ignore all this in the second pass; this does not root
-                  }
-                }
-                foundMinimalRuntimeExports = true;
-              }
+              const name = item.expression.left.name;
+              const asmName = item.expression.right.property.value;
+              saveAsmExport(name, asmName);
+              emptyOut(item); // ignore all this in the second pass; this does not root
             }
           }
+        } else if (!specialScopes) {
+          defuns.push(node);
+          nameToGraphName[name] = getGraphName(name, 'defun');
+          emptyOut(node); // ignore this in the second pass; we scan defuns separately
         }
+      } else if (node.type === 'ArrowFunctionExpression') {
+        assert(specialScopes > 0);
+        specialScopes--;
       } else if (node.type === 'Property' && node.method) {
         assert(specialScopes > 0);
         specialScopes--;

tools/emscripten.py

@@ -53,20 +53,6 @@
 ]
 
 
-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;
-
-  # `receiving` contains all of the assignments from wasm exports to
-  # global JS variables: e.g. a = wasmExports['a']; b = wasmExports['b'];
-  post = shared.do_replace(post, '<<< WASM_MODULE_EXPORTS >>>', receiving)
-
-  exports = [asmjs_mangle(x) for x in exports if x != building.WASM_CALL_CTORS]
-  receiving = 'var ' + ',\n '.join(exports) + ';'
-  return post, receiving
-
-
 def write_output_file(outfile, module):
   for chunk in module:
     outfile.write(chunk)
@@ -459,12 +445,6 @@ def emscript(in_wasm, out_wasm, outfile_js, js_syms, finalize=True, base_metadat
 
     receiving = create_receiving(function_exports)
 
-    if settings.MINIMAL_RUNTIME:
-      if settings.DECLARE_ASM_MODULE_EXPORTS:
-        post, receiving = compute_minimal_runtime_initializer_and_exports(post, function_exports, receiving)
-      else:
-        receiving = ''
-
     module = create_module(receiving, metadata, global_exports, forwarded_json['librarySymbols'])
 
     metadata.library_definitions = forwarded_json['libraryDefinitions']
@@ -964,30 +944,30 @@ def create_receiving(function_exports):
   receiving = []
 
   if settings.MINIMAL_RUNTIME:
-    # In Wasm exports are assigned inside a function to variables
+    # Exports are assigned inside a function to variables
     # existing in top level JS scope, i.e.
     # var _main;
-    # WebAssembly.instantiate(Module['wasm'], imports).then((output) => {
-    #   var wasmExports = output.instance.exports;
+    # function assignWasmExports(wasmExport) {
     #   _main = wasmExports["_main"];
     generate_dyncall_assignment = settings.DYNCALLS and '$dynCall' in settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE
-    exports_that_are_not_initializers = [x for x in function_exports if x != building.WASM_CALL_CTORS]
-
-    for s in exports_that_are_not_initializers:
+    exports = [x for x in function_exports if x != building.WASM_CALL_CTORS]
+    receiving.append('function assignWasmExports(wasmExports) {')
+    for s in exports:
       mangled = asmjs_mangle(s)
       dynCallAssignment = ('dynCalls["' + s.replace('dynCall_', '') + '"] = ') if generate_dyncall_assignment and mangled.startswith('dynCall_') else ''
       should_export = settings.EXPORT_ALL or (settings.EXPORT_KEEPALIVE and mangled in settings.EXPORTED_FUNCTIONS)
       export_assignment = ''
       if settings.MODULARIZE and should_export:
         export_assignment = f"Module['{mangled}'] = "
-      receiving += [f'{export_assignment}{dynCallAssignment}{mangled} = wasmExports["{s}"]']
+      receiving.append(f"  {export_assignment}{dynCallAssignment}{mangled} = wasmExports['{s}'];")
+    receiving.append('}')
+    sep = ',\n  '
+    mangled = [asmjs_mangle(s) for s in exports]
+    receiving.append(f'var {sep.join(mangled)};')
   else:
     receiving += make_export_wrappers(function_exports)
 
-  if settings.MINIMAL_RUNTIME:
-    return '\n  '.join(receiving) + '\n'
-  else:
-    return '\n'.join(receiving) + '\n'
+  return '\n'.join(receiving) + '\n'
 
 
 def create_module(receiving, metadata, global_exports, library_symbols):