Support JS symbols that are aliases of native ones (#25376)

We can then use this mechanism to replace the hacky way to we map things
like `memory` -> `wasmMemory` and `__indirect_function_table` =>
`wasmTable`.

Author: sbc100

src/jsifier.mjs

@@ -40,7 +40,7 @@ import {
   warningOccured,
   localFile,
 } from './utility.mjs';
-import {LibraryManager, librarySymbols} from './modules.mjs';
+import {LibraryManager, librarySymbols, nativeAliases} from './modules.mjs';
 
 const addedLibraryItems = {};
 
@@ -128,9 +128,13 @@ function isDefined(symName) {
 }
 
 function resolveAlias(symbol) {
-  var value = LibraryManager.library[symbol];
-  if (typeof value == 'string' && value[0] != '=' && LibraryManager.library.hasOwnProperty(value)) {
-    return value;
+  while (true) {
+    var value = LibraryManager.library[symbol];
+    if (typeof value == 'string' && value[0] != '=' && (LibraryManager.library.hasOwnProperty(value) || WASM_EXPORTS.has(value))) {
+      symbol = value;
+    } else {
+      break;
+    }
   }
   return symbol;
 }
@@ -639,6 +643,7 @@ function(${args}) {
       });
 
       let isFunction = false;
+      let isNativeAlias = false;
 
       const postsetId = symbol + '__postset';
       const postset = LibraryManager.library[postsetId];
@@ -654,13 +659,22 @@ function(${args}) {
 
       if (typeof snippet == 'string') {
         if (snippet[0] != '=') {
-          if (LibraryManager.library[snippet]) {
+          if (LibraryManager.library[snippet] || WASM_EXPORTS.has(snippet)) {
             // Redirection for aliases. We include the parent, and at runtime
             // make ourselves equal to it.  This avoid having duplicate
             // functions with identical content.
-            const aliasTarget = snippet;
-            snippet = mangleCSymbolName(aliasTarget);
-            deps.push(aliasTarget);
+            const aliasTarget = resolveAlias(snippet);
+            if (WASM_EXPORTS.has(aliasTarget)) {
+              //printErr(`native alias: ${mangled} -> ${snippet}`);
+              //console.error(WASM_EXPORTS);
+              nativeAliases[mangled] = aliasTarget;
+              snippet = undefined;
+              isNativeAlias = true;
+            } else {
+              //printErr(`js alias: ${mangled} -> ${snippet}`);
+              deps.push(aliasTarget);
+              snippet = mangleCSymbolName(aliasTarget);
+            }
           }
         }
       } else if (typeof snippet == 'object') {
@@ -728,15 +742,11 @@ function(${args}) {
           contentText += ';';
         }
       } else if (typeof snippet == 'undefined') {
-        // wasmTable is kind of special.  In the normal configuration we export
-        // it from the wasm module under the name `__indirect_function_table`
-        // but we declare it as an 'undefined' in `libcore.js`.
-        // Since the normal export mechanism will declare this variable we don't
-        // want the JS library version of this symbol be declared (otherwise
-        // it would be a duplicate decl).
-        // TODO(sbc): This is kind of hacky, we should come up with a better solution.
-        var isDirectWasmExport = mangled == 'wasmTable';
-        if (isDirectWasmExport) {
+        // For JS library functions that are simply aliases of native symbols,
+        // we don't need to generate anything here.  Instead these get included
+        // and exported alongside native symbols.
+        // See `create_receiving` in `tools/emscripten.py`.
+        if (isNativeAlias) {
           contentText = '';
         } else {
           contentText = `var ${mangled};`;
@@ -752,7 +762,7 @@ function(${args}) {
         contentText = `var ${mangled} = ${snippet};`;
       }
 
-      if (MODULARIZE == 'instance' && (EXPORT_ALL || EXPORTED_FUNCTIONS.has(mangled)) && !isStub) {
+      if (contentText && MODULARIZE == 'instance' && (EXPORT_ALL || EXPORTED_FUNCTIONS.has(mangled)) && !isStub) {
         // In MODULARIZE=instance mode mark JS library symbols are exported at
         // the point of declaration.
         contentText = 'export ' + contentText;
@@ -775,11 +785,11 @@ function(${args}) {
         }
       }
 
-      let commentText = '';
-      let docs = LibraryManager.library[symbol + '__docs'];
       // Add the docs if they exist and if we are actually emitting a declaration.
       // See the TODO about wasmTable above.
-      if (docs && contentText != '') {
+      let docs = LibraryManager.library[symbol + '__docs'];
+      let commentText = '';
+      if (contentText != '' && docs) {
         commentText += docs + '\n';
       }
 
@@ -886,6 +896,7 @@ var proxiedFunctionTable = [
       '//FORWARDED_DATA:' +
         JSON.stringify({
           librarySymbols,
+          nativeAliases,
           warnings: warningOccured(),
           asyncFuncs,
           libraryDefinitions: LibraryManager.libraryDefinitions,

src/lib/libbootstrap.js

@@ -15,6 +15,8 @@ assert(Object.keys(LibraryManager.library).length === 0);
 addToLibrary({
   $callRuntimeCallbacks: () => {},
 
+  $wasmMemory: 'memory',
+
   $ExitStatus: class {
     name = 'ExitStatus';
     constructor(status) {

src/lib/libcore.js

@@ -1641,7 +1641,7 @@ addToLibrary({
 #endif
       }
     }
-
+    exportAliases(wasmExports);
   },
 #endif
 
@@ -2150,8 +2150,6 @@ addToLibrary({
 #endif // MINIMAL_RUNTIME
 
   $asmjsMangle: (x) => {
-    if (x == 'memory') return 'wasmMemory';
-    if (x == '__indirect_function_table') return 'wasmTable';
     if (x == '__main_argc_argv') {
       x = 'main';
     }
@@ -2287,7 +2285,14 @@ addToLibrary({
 });
 `,
 #else
-  $wasmTable: undefined,
+  $wasmTable: '__indirect_function_table',
+#endif
+
+#if IMPORTED_MEMORY
+  // This gets defined in src/runtime_init_memory.js
+  $wasmMemory: undefined,
+#else
+  $wasmMemory: 'memory',
 #endif
 
   $getUniqueRunDependency: (id) => {

src/lib/liblegacy.js

@@ -114,8 +114,8 @@ legacyFuncs = {
   },
 
   // Legacy names for runtime `out`/`err` symbols.
-  $print: 'out',
-  $printErr: 'err',
+  $print: '=out',
+  $printErr: '=err',
 
   // Converts a JS string to an integer base-10. Despite _s, which
   // suggests signaling error handling, this returns NaN on error.

src/modules.mjs

@@ -29,6 +29,9 @@ import {preprocess, processMacros} from './parseTools.mjs';
 
 // List of symbols that were added from the library.
 export const librarySymbols = [];
+// Map of library symbols which are aliases for native symbols
+// e.g. `wasmTable` -> `__indirect_function_table`
+export const nativeAliases = {};
 
 const srcDir = fileURLToPath(new URL('.', import.meta.url));
 const systemLibdir = path.join(srcDir, 'lib');
@@ -448,7 +451,6 @@ function exportRuntimeSymbols() {
     'err',
     'callMain',
     'abort',
-    'wasmMemory',
     'wasmExports',
     'HEAPF32',
     'HEAPF64',
@@ -562,13 +564,7 @@ function exportLibrarySymbols() {
   assert(MODULARIZE != 'instance');
   const results = ['// Begin JS library exports'];
   for (const ident of librarySymbols) {
-    if (EXPORT_ALL || EXPORTED_FUNCTIONS.has(ident)) {
-      // Special case for wasmTable which can be both a JS library symbol but
-      // also a wasm export. See isDirectWasmExport in jsifier.mjs.
-      // FIXME: Remove this hack 
-      if (ident == 'wasmTable' && WASM_EXPORTS.has('__indirect_function_table')) {
-        continue;
-      }
+    if ((EXPORT_ALL || EXPORTED_FUNCTIONS.has(ident)) && !nativeAliases[ident]) {
       results.push(exportSymbol(ident));
     }
   }

src/parseTools.mjs

@@ -24,6 +24,8 @@ import {
   srcDir,
 } from './utility.mjs';
 
+import { nativeAliases } from './modules.mjs';
+
 const FOUR_GB = 4 * 1024 * 1024 * 1024;
 const WASM_PAGE_SIZE = 64 * 1024;
 const FLOAT_TYPES = new Set(['float', 'double']);
@@ -1155,6 +1157,17 @@ function nodeWWDetection() {
   }
 }
 
+function makeExportAliases() {
+  var res = ''
+  for (var [alias, ex] of Object.entries(nativeAliases)) {
+    if (ASSERTIONS) {
+      res += `  assert(wasmExports['${ex}'], 'alias target "${ex}" not found in wasmExports');\n`;
+    }
+    res += `  globalThis['${alias}'] = wasmExports['${ex}'];\n`;
+  }
+  return res;
+}
+
 addToCompileTimeContext({
   ATEXITS,
   ATPRERUNS,
@@ -1204,6 +1217,7 @@ addToCompileTimeContext({
   isSymbolNeeded,
   makeDynCall,
   makeEval,
+  makeExportAliases,
   makeGetValue,
   makeHEAPView,
   makeModuleReceive,

src/runtime_common.js

@@ -174,3 +174,9 @@ if (ENVIRONMENT_IS_NODE) {
 #endif // !IMPORTED_MEMORY && ASSERTIONS
 
 #include "memoryprofiler.js"
+
+#if !DECLARE_ASM_MODULE_EXPORTS
+function exportAliases(wasmExports) {
+{{{ makeExportAliases() }}}
+}
+#endif

src/runtime_init_memory.js

@@ -9,8 +9,6 @@
 #error "this file should not be be included when IMPORTED_MEMORY is set"
 #endif
 
-var wasmMemory;
-
 // check for full engine support (use string 'subarray' to avoid closure compiler confusion)
 
 function initMemory() {

src/settings_internal.js

@@ -275,3 +275,5 @@ var OUTPUT_FORMAT = '';
 // Whether we should load the WASM source map at runtime.
 // This is enabled automatically when using -gsource-map with sanitizers.
 var LOAD_SOURCE_MAP = false;
+
+var ALIASES = [];

test/codesize/test_codesize_file_preload.expected.js

@@ -3154,12 +3154,12 @@ Module["FS_createLazyFile"] = FS_createLazyFile;
 // End JS library exports
 // end include: postlibrary.js
 // Imports from the Wasm binary.
-var _main, wasmMemory, wasmTable;
+var _main, memory, __indirect_function_table, wasmMemory;
 
 function assignWasmExports(wasmExports) {
   _main = Module["_main"] = wasmExports["d"];
-  wasmMemory = wasmExports["b"];
-  wasmTable = wasmExports["__indirect_function_table"];
+  memory = wasmMemory = wasmExports["b"];
+  __indirect_function_table = wasmExports["__indirect_function_table"];
 }
 
 var wasmImports = {