Remove redundant __deps entries and autoAddDeps calls across JS libraries

Remove all `autoAddDeps` calls and redundant `__deps` entries across
`src/lib/*.js` and the test suite.

Fixes: #19098

Author: sbc100

src/jsifier.mjs

@@ -20,7 +20,6 @@ import {
   ATPOSTRUNS,
   defineI64Param,
   indentify,
-  isSymbolNeeded,
   makeReturn64,
   modifyJSFunction,
   preprocess,
@@ -47,6 +46,8 @@ import {
 import {extraExports, LibraryManager, librarySymbols, nativeAliases} from './modules.mjs';
 
 const addedLibraryItems = {};
+const emittedLibraryItems = new Set();
+const deferredAliases = {};
 
 // Some JS-implemented library functions are proxied to be called on the main
 // browser thread, if the Emscripten runtime is executing in a Web Worker.
@@ -301,15 +302,17 @@ function calculateDeps(snippet, deps, symbol, symbolsOnly = false) {
       dep = name.slice(1);
     }
 
-    if (dep && dep !== symbol) {
+    // $noExitRuntime cannot be referenced via __deps (it must be included via
+    // DEFAULT_LIBRARY_FUNCS_TO_INCLUDE or EXPORTED_RUNTIME_METHODS).
+    if (dep && dep !== symbol && dep !== '$noExitRuntime') {
       found.add(dep);
     }
   }
 
   const isUserSymbol = symbol && LibraryManager.library[symbol + '__user'];
   for (const dep of found) {
     if (deps.includes(dep)) {
-      if (!symbolsOnly && symbol && isUserSymbol && STRICT && LibraryManager.library[symbol] !== dep) {
+      if (!symbolsOnly && symbol && (STRICT || !isUserSymbol) && LibraryManager.library[symbol] !== dep) {
         warn(`${symbol}: redundant __deps entry: ${dep}`);
       }
     } else {
@@ -771,11 +774,12 @@ function(${args}) {
         }
       }
 
+      let aliasTarget;
       if (LibraryManager.isAlias(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;
+        aliasTarget = snippet;
         if (WASM_EXPORTS.has(aliasTarget)) {
           debugLog(`native alias: ${mangled} -> ${aliasTarget}`);
           nativeAliases[mangled] = aliasTarget;
@@ -818,8 +822,10 @@ function(${args}) {
 
       const isUserSymbol = LibraryManager.library[symbol + '__user'];
       // Check for dependencies on `__internal` symbols from user libraries.
+      // Exclude `implicitSnippetDeps` (such as `$getWasmTableEntry`, which is
+      // injected by the `{{{ makeDynCall }}}` macro).
       for (const dep of deps) {
-        if (isUserSymbol && LibraryManager.library[dep + '__internal']) {
+        if (isUserSymbol && LibraryManager.library[dep + '__internal'] && !implicitSnippetDeps.has(dep.slice(1))) {
           warn(`user library symbol '${symbol}' depends on internal symbol '${dep}'`);
         }
       }
@@ -833,7 +839,7 @@ function(${args}) {
         // $noExitRuntime is special since there are conditional usages of it
         // in libcore.js and libpthread.js.  These happen before deps are
         // processed so depending on it via `__deps` doesn't work.
-        if (dep === '$noExitRuntime' && !isSymbolNeeded('$noExitRuntime')) {
+        if (dep === '$noExitRuntime') {
           error('noExitRuntime cannot be referenced via __deps mechanism.  Use DEFAULT_LIBRARY_FUNCS_TO_INCLUDE or EXPORTED_RUNTIME_METHODS');
         }
         return addFromLibrary(dep, `${symbol}, referenced by ${dependent}`);
@@ -938,7 +944,23 @@ function(${args}) {
             .filter((x) => x != '')
             .join('\n') + '\n'
         : '';
-      return depsText + commentText + contentText;
+      if (aliasTarget && !isNativeAlias && !isFunction && !emittedLibraryItems.has(aliasTarget)) {
+        // If `aliasTarget` is not yet emitted, we are in a dependency cycle
+        // where `aliasTarget` is an ancestor on the recursion stack. Defer
+        // emitting `var _alias = _target;` until immediately after `_target`
+        // is defined so `_target` is not referenced before its initialization.
+        (deferredAliases[aliasTarget] ??= []).push({symbol, text: commentText + contentText});
+        return depsText.trim();
+      }
+      function flushDeferred(sym) {
+        emittedLibraryItems.add(sym);
+        let res = '';
+        for (const item of deferredAliases[sym] ?? []) {
+          res += '\n' + item.text + flushDeferred(item.symbol);
+        }
+        return res;
+      }
+      return depsText + commentText + contentText + flushDeferred(symbol);
     }
 
     const JS = addFromLibrary(symbol, 'root reference (e.g. compiled C/C++ code)');

src/lib/libaddfunction.js

@@ -35,7 +35,6 @@ addToLibrary({
   }`,
 
   $generateTypePack__internal: true,
-  $generateTypePack__deps: ['$uleb128EncodeWithLen', '$wasmTypeCodes'],
   $generateTypePack: (types) => uleb128EncodeWithLen(Array.from(types, (type) => {
     var code = wasmTypeCodes[type];
 #if ASSERTIONS
@@ -46,10 +45,6 @@ addToLibrary({
 
 #if !WASM2JS || WASM == 2
   // Wraps a JS function as a wasm function with a given signature.
-  $convertJsFunctionToWasm__deps: [
-    '$uleb128EncodeWithLen',
-    '$generateTypePack'
-  ],
   $convertJsFunctionToWasm: (func, sig) => {
 #if ASSERTIONS && !WASM_BIGINT
     assert(!sig.includes('j'), 'i64 not permitted in function signatures when WASM_BIGINT is disabled');
@@ -93,7 +88,6 @@ addToLibrary({
   // Weak map of functions in the table to their indexes, created on first use.
   $functionsInTableMap: undefined,
 
-  $getEmptyTableSlot__deps: ['$freeTableIndexes', '$wasmTable'],
   $getEmptyTableSlot: () => {
     // Reuse a free index if there is one, otherwise grow.
     if (freeTableIndexes.length) {
@@ -114,7 +108,6 @@ addToLibrary({
 #endif
   },
 
-  $updateTableMap__deps: ['$getWasmTableEntry'],
   $updateTableMap: (offset, count) => {
     if (functionsInTableMap) {
       for (var i = offset; i < offset + count; i++) {
@@ -127,7 +120,6 @@ addToLibrary({
     }
   },
 
-  $getFunctionAddress__deps: ['$updateTableMap', '$functionsInTableMap', '$wasmTable'],
   $getFunctionAddress: (func) => {
     // First, create the map if this is the first use.
     if (!functionsInTableMap) {
@@ -142,16 +134,6 @@ addToLibrary({
    * 'sig' parameter is required if the function being added is a JS function.
    */
   $addFunction__docs: '/** @param {string=} sig */',
-  $addFunction__deps: ['$getFunctionAddress',
-                       '$functionsInTableMap', '$getEmptyTableSlot',
-                       '$setWasmTableEntry',
-#if !WASM2JS || WASM == 2
-                       '$convertJsFunctionToWasm',
-#endif
-#if ASSERTIONS >= 2
-                       '$getWasmTableEntry', '$wasmTable',
-#endif
-  ],
 
   $addFunction: (func, sig) => {
 #if ASSERTIONS
@@ -201,8 +183,6 @@ addToLibrary({
     return ret;
   },
 
-  $removeFunction__deps: ['$functionsInTableMap', '$freeTableIndexes',
-                          '$getWasmTableEntry', '$setWasmTableEntry'],
   $removeFunction: (index) => {
     functionsInTableMap.delete(getWasmTableEntry(index));
     setWasmTableEntry(index, null);

src/lib/libasync.js

@@ -21,19 +21,10 @@ addToLibrary({
 
 #if ASYNCIFY
   $Asyncify__force: true,
-  $Asyncify__deps: [
-#if useRuntimeKeepaliveStack()
-    '$runtimeKeepalivePush', '$runtimeKeepalivePop',
-#endif
 #if ASYNCIFY == 1
-    '$runAndAbortIfError', '$callUserCallback',
-#if ASSERTIONS
-    '$createNamedFunction',
-#endif
-    // Needed by allocateData and handleSleep respectively
-    'malloc', 'free',
+  // Needed by allocateData and handleSleep respectively
+  $Asyncify__deps: ['malloc', 'free'],
 #endif
-  ],
 
   $Asyncify: {
     //
@@ -484,7 +475,7 @@ addToLibrary({
   emscripten_sleep__async: 'auto',
   emscripten_sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
 
-  emscripten_wget_data__deps: ['$asyncLoad', 'malloc'],
+  emscripten_wget_data__deps: ['malloc'],
   emscripten_wget_data__async: 'auto',
   emscripten_wget_data: async (url, pbuffer, pnum, perror) => {
     /* no need for run dependency, this is async but will not do any prepare etc. step */
@@ -501,7 +492,6 @@ addToLibrary({
     }
   },
 
-  emscripten_scan_registers__deps: ['$safeSetTimeout'],
   emscripten_scan_registers__async: true,
   emscripten_scan_registers: (func) => {
     return Asyncify.handleSleep((wakeUp) => {
@@ -518,7 +508,7 @@ addToLibrary({
     });
   },
 
-  $Fibers__deps: ['$Asyncify', 'emscripten_stack_set_limits', '$stackRestore'],
+  $Fibers__deps: ['emscripten_stack_set_limits'],
   $Fibers: {
     nextFiber: 0,
     trampolineRunning: false,
@@ -578,7 +568,6 @@ addToLibrary({
     },
   },
 
-  emscripten_fiber_swap__deps: ['$Asyncify', '$Fibers', '$stackSave'],
   emscripten_fiber_swap__async: true,
   emscripten_fiber_swap: (oldFiber, newFiber) => {
     if (ABORT) return;

src/lib/libatomic.js

@@ -69,7 +69,7 @@ addToLibrary({
   },
 
 #if ASYNCIFY
-  _emscripten_atomic_wait_promise__deps: ['$polyfillWaitAsync', '$atomicWaitStates', '$addPromise'],
+  _emscripten_atomic_wait_promise__deps: ['$polyfillWaitAsync'],
   _emscripten_atomic_wait_promise: (addr, val, maxWaitMilliseconds) => {
     var wait = Atomics.waitAsync(HEAP32, {{{ getHeapOffset('addr', 'i32') }}}, val, maxWaitMilliseconds);
     if (wait.async) {
@@ -94,7 +94,7 @@ addToLibrary({
   $liveAtomicWaitAsyncCounter: 0,
   $liveAtomicWaitAsyncCounter__internal: true,
 
-  emscripten_atomic_wait_async__deps: ['$atomicWaitStates', '$liveAtomicWaitAsyncs', '$liveAtomicWaitAsyncCounter', '$polyfillWaitAsync', '$callUserCallback'],
+  emscripten_atomic_wait_async__deps: ['$polyfillWaitAsync'],
   emscripten_atomic_wait_async: (addr, val, asyncWaitFinished, userData, maxWaitMilliseconds) => {
     let wait = Atomics.waitAsync(HEAP32, {{{ getHeapOffset('addr', 'i32') }}}, val, maxWaitMilliseconds);
     if (!wait.async) return atomicWaitStates.indexOf(wait.value);
@@ -116,7 +116,6 @@ addToLibrary({
     return -counter;
   },
 
-  emscripten_atomic_cancel_wait_async__deps: ['$liveAtomicWaitAsyncs'],
   emscripten_atomic_cancel_wait_async: (waitToken) => {
 #if ASSERTIONS
     if (waitToken == {{{ cDefs.ATOMICS_WAIT_NOT_EQUAL }}}) {
@@ -143,7 +142,6 @@ addToLibrary({
     return {{{ cDefs.EMSCRIPTEN_RESULT_INVALID_PARAM }}};
   },
 
-  emscripten_atomic_cancel_all_wait_asyncs__deps: ['$liveAtomicWaitAsyncs'],
   emscripten_atomic_cancel_all_wait_asyncs: () => {
     let waitAsyncs = Object.values(liveAtomicWaitAsyncs);
     for (var address of waitAsyncs) {
@@ -153,7 +151,6 @@ addToLibrary({
     return waitAsyncs.length;
   },
 
-  emscripten_atomic_cancel_all_wait_asyncs_at_address__deps: ['$liveAtomicWaitAsyncs'],
   emscripten_atomic_cancel_all_wait_asyncs_at_address: (address) => {
     let numCancelled = 0;
     for (var [waitToken, waitAddress] of Object.entries(liveAtomicWaitAsyncs)) {

src/lib/libautodebug.js

@@ -15,7 +15,6 @@ const LibraryAutodebug = {
     dbg('get_i32 ' + [loc, index, value]);
     return value;
   },
-  $get_i64__deps: ['setTempRet0'],
   $get_i64: (loc, index, low, high) => {
     dbg('get_i64 ' + [loc, index, low, high]);
     _setTempRet0(high);
@@ -49,7 +48,6 @@ const LibraryAutodebug = {
     dbg('set_i32 ' + [loc, index, value]);
     return value;
   },
-  $set_i64__deps: ['setTempRet0'],
   $set_i64: (loc, index, low, high) => {
     dbg('set_i64 ' + [loc, index, low, high]);
     _setTempRet0(high);
@@ -87,7 +85,6 @@ const LibraryAutodebug = {
     dbg('load_val_i32 ' + [loc, value]);
     return value;
   },
-  $load_val_i64__deps: ['setTempRet0'],
   $load_val_i64: (loc, low, high) => {
     dbg('load_val_i64 ' + [loc, low, high]);
     _setTempRet0(high);
@@ -109,7 +106,6 @@ const LibraryAutodebug = {
     dbg('store_val_i32 ' + [loc, value]);
     return value;
   },
-  $store_val_i64__deps: ['setTempRet0'],
   $store_val_i64: (loc, low, high) => {
     dbg('store_val_i64 ' + [loc, low, high]);
     _setTempRet0(high);

src/lib/libbootstrap.js

@@ -38,7 +38,6 @@ addToLibrary({
     }
   },
 
-  $exitJS__deps: ['$ExitStatus'],
   $exitJS: (code) => quit_(code, new ExitStatus(code)),
 
   $handleException: (e) => {