Remove ASYNCIFY_LAZY_LOAD_CODE (#25236)

sbc100 · web-flow · commit 58938a31f4ac · 2025-09-09T16:44:22.000-07:00
This was marked a deprecated in #24383 and nobody has chimed in that they are using it. Fixes: #16828
diff --git a/ChangeLog.md b/ChangeLog.md
@@ -23,6 +23,8 @@ See docs/process.md for more on how version tagging works.
 
 4.0.14 - 09/02/25
 -----------------
+- The `-sASYNCIFY_LAZY_LOAD_CODE` setting and the corresponding C function
+  `emscripten_lazy_load_code` were removed. (#25236)
 - The `addRunDependency` and `removeRunDependency` API are now optional and need
   to be included and/or exported using, for example,
   `DEFAULT_LIBRARY_FUNCS_TO_INCLUDE` or `EXPORTED_RUNTIME_METHODS`. (#24974)
diff --git a/site/source/docs/api_reference/emscripten.h.rst b/site/source/docs/api_reference/emscripten.h.rst
@@ -1434,22 +1434,6 @@ Functions
     local state all the way up the stack. As a result, it will add overhead
     to your program.
 
-.. c:function:: void emscripten_lazy_load_code()
-
-    This creates two Wasm files at compile time: the first Wasm which is
-    downloaded and run normally, and a second that is lazy-loaded. When an
-    ``emscripten_lazy_load_code()`` call is reached, we load the second Wasm
-    and resume execution using it.
-
-    The idea here is that the initial download can be quite small, if you
-    place enough ``emscripten_lazy_load_code()`` calls in your codebase, as
-    the optimizer can remove code from the first Wasm if it sees it can't
-    be reached. The second downloaded Wasm can contain your full codebase,
-    including rarely-used functions, in which case the lazy-loading may
-    not happen at all.
-
-  .. note:: This requires building with ``-sASYNCIFY_LAZY_LOAD_CODE``.
-
 ABI functions
 =============
 
diff --git a/site/source/docs/compiling/Modularized-Output.rst b/site/source/docs/compiling/Modularized-Output.rst
@@ -123,9 +123,6 @@ fix in future releses.  Current limitations include:
 
 * `ccall`/`cwrap` are not supported (depends on the ``Module`` global).
 
-* :ref:`asyncify_lazy_load_code` is not supported (depends on ``wasmExports``
-  global)
-
 * :ref:`minimal_runtime` is not supported.
 
 * The output of file_packager is not compatible so :ref:`emcc-preload-file` and
diff --git a/site/source/docs/tools_reference/settings_reference.rst b/site/source/docs/tools_reference/settings_reference.rst
@@ -1348,18 +1348,6 @@ If enabled will output which functions have been instrumented and why.
 
 Default value: false
 
-.. _asyncify_lazy_load_code:
-
-ASYNCIFY_LAZY_LOAD_CODE
-=======================
-
-Allows lazy code loading: where emscripten_lazy_load_code() is written, we
-will pause execution, load the rest of the code, and then resume.
-
-.. note:: This setting is deprecated
-
-Default value: false
-
 .. _asyncify_debug:
 
 ASYNCIFY_DEBUG
diff --git a/src/lib/libasync.js b/src/lib/libasync.js
@@ -141,7 +141,7 @@ addToLibrary({
 #if ASYNCIFY == 1
       Asyncify.funcWrappers.set(original, wrapper);
 #endif
-#if MAIN_MODULE || ASYNCIFY_LAZY_LOAD_CODE
+#if MAIN_MODULE
       wrapper.orig = original;
 #endif
       return wrapper;
@@ -171,18 +171,12 @@ addToLibrary({
           }
 #endif
           var wrapper = Asyncify.instrumentFunction(original);
-#if ASYNCIFY_LAZY_LOAD_CODE
-          original.exportName = x;
-#endif
           ret[x] = wrapper;
 
        } else {
           ret[x] = original;
         }
       }
-#if ASYNCIFY_LAZY_LOAD_CODE
-      Asyncify.updateFunctionMapping(ret);
-#endif
       return ret;
     },
 
@@ -217,34 +211,6 @@ addToLibrary({
     asyncPromiseHandlers: null, // { resolve, reject } pair for when *all* asynchronicity is done
     sleepCallbacks: [], // functions to call every time we sleep
 
-#if ASYNCIFY_LAZY_LOAD_CODE
-    updateFunctionMapping(newExports) {
-#if ASYNCIFY_DEBUG
-      dbg('updateFunctionMapping', Asyncify.callStackIdToFunc);
-#endif
-#if ASSERTIONS
-      assert(!Asyncify.exportCallStack.length);
-#endif
-      Asyncify.callStackIdToFunc.forEach((func, id) => {
-#if ASSERTIONS
-        assert(func.exportName);
-        assert(newExports[func.exportName]);
-        assert(newExports[func.exportName].orig);
-#endif
-        var newFunc = newExports[func.exportName].orig;
-        Asyncify.callStackIdToFunc.set(id, newFunc)
-        Asyncify.callstackFuncToId.set(newFunc, id);
-#if MEMORY64
-        var args = Asyncify.rewindArguments.get(func);
-        if (args) {
-          Asyncify.rewindArguments.set(newFunc, args);
-          Asyncify.rewindArguments.delete(func);
-        }
-#endif
-      });
-    },
-#endif
-
     getCallStackId(func) {
 #if ASSERTIONS
       assert(func);
@@ -546,16 +512,6 @@ addToLibrary({
     });
   },
 
-#if ASYNCIFY_LAZY_LOAD_CODE
-  emscripten_lazy_load_code__async: true,
-  emscripten_lazy_load_code: () => Asyncify.handleSleep((wakeUp) => {
-    // Update the expected wasm binary file to be the lazy one.
-    wasmBinaryFile += '.lazy.wasm';
-    // Load the new wasm. The resulting Promise will resolve once the async loading is done.
-    createWasm().then(() => wakeUp());
-  }),
-#endif
-
   _load_secondary_module__sig: 'v',
   _load_secondary_module__async: true,
   _load_secondary_module: async function() {
diff --git a/src/lib/libsigs.js b/src/lib/libsigs.js
@@ -678,7 +678,6 @@ sigs = {
   emscripten_idb_store__sig: 'vpppip',
   emscripten_idb_store_blob__sig: 'vpppip',
   emscripten_is_webgl_context_lost__sig: 'ip',
-  emscripten_lazy_load_code__sig: 'v',
   emscripten_lock_async_acquire__sig: 'vpppd',
   emscripten_lock_orientation__sig: 'ii',
   emscripten_math_acos__sig: 'dd',
diff --git a/src/preamble.js b/src/preamble.js
@@ -642,7 +642,7 @@ function getWasmImports() {
   // instrumenting imports is used in asyncify in two ways: to add assertions
   // that check for proper import use, and for ASYNCIFY=2 we use them to set up
   // the Promise API on the import side.
-#if PTHREADS || ASYNCIFY_LAZY_LOAD_CODE
+#if PTHREADS
   // In pthreads builds getWasmImports is called more than once but we only
   // and the instrument the imports once.
   if (!wasmImports.__instrumented) {
diff --git a/src/settings.js b/src/settings.js
@@ -915,12 +915,6 @@ var ASYNCIFY_ONLY = [];
 // [link]
 var ASYNCIFY_ADVISE = false;
 
-// Allows lazy code loading: where emscripten_lazy_load_code() is written, we
-// will pause execution, load the rest of the code, and then resume.
-// [link]
-// [deprecated]
-var ASYNCIFY_LAZY_LOAD_CODE = false;
-
 // Runtime debug logging from asyncify internals.
 //
 // - 1: Minimal logging.
@@ -2275,4 +2269,5 @@ var LEGACY_SETTINGS = [
   ['MAYBE_WASM2JS', [0], 'No longer supported (use -sWASM=2)'],
   ['HEADLESS', [0], 'No longer supported, use headless browsers or Node.js with JSDOM'],
   ['USE_OFFSET_COVERTER', [0], 'No longer supported, not needed with modern v8 versions'],
+  ['ASYNCIFY_LAZY_LOAD_CODE', [0], 'No longer supported'],
 ];
diff --git a/system/include/emscripten/emscripten.h b/system/include/emscripten/emscripten.h
@@ -117,8 +117,6 @@ int emscripten_run_preload_plugins(const char* file, em_str_callback_func onload
 typedef void (*em_run_preload_plugins_data_onload_func)(void*, const char*);
 void emscripten_run_preload_plugins_data(char* data, int size, const char *suffix, void *arg, em_run_preload_plugins_data_onload_func onload, em_arg_callback_func onerror);
 
-void emscripten_lazy_load_code(void);
-
 // show an error on some renamed methods
 #define emscripten_async_prepare(...) _Pragma("GCC error(\"emscripten_async_prepare has been replaced by emscripten_run_preload_plugins\")")
 #define emscripten_async_prepare_data(...) _Pragma("GCC error(\"emscripten_async_prepare_data has been replaced by emscripten_run_preload_plugins_data\")")
diff --git a/test/core/emscripten_lazy_load_code.c b/test/core/emscripten_lazy_load_code.c
diff --git a/test/test_core.py b/test/test_core.py
@@ -8496,101 +8496,6 @@ def test_pthread_join_and_asyncify(self):
                             '-sEXIT_RUNTIME=1',
                             '-pthread', '-sPROXY_TO_PTHREAD'])
 
-  @no_asan('asyncify stack operations confuse asan')
-  @no_modularize_instance('ASYNCIFY_LAZY_LOAD_CODE is not compatible with MODULARIZE=instance')
-  @no_wasm2js('TODO: lazy loading in wasm2js')
-  @parameterized({
-    '': (False,),
-    'conditional': (True,),
-  })
-  def test_emscripten_lazy_load_code(self, conditional):
-    if self.get_setting('STACK_OVERFLOW_CHECK'):
-      self.skipTest('https://github.com/emscripten-core/emscripten/issues/16828')
-    self.set_setting('ASYNCIFY_LAZY_LOAD_CODE')
-    self.set_setting('ASYNCIFY_IGNORE_INDIRECT')
-    self.set_setting('MALLOC', 'emmalloc')
-    self.cflags += ['-Wno-deprecated', '--profiling-funcs'] # so that we can find the functions for the changes below
-    if conditional:
-      self.cflags += ['-DCONDITIONAL']
-    self.do_core_test('emscripten_lazy_load_code.c', args=['0'])
-
-    first_size = os.path.getsize('emscripten_lazy_load_code.wasm')
-    second_size = os.path.getsize('emscripten_lazy_load_code.wasm.lazy.wasm')
-    print('first wasm size', first_size)
-    print('second wasm size', second_size)
-
-    # For the purposes of this test we don't consider O1 to be optimizing
-    is_optimizing = self.is_optimizing() and '-O1' not in self.cflags
-
-    if not conditional and is_optimizing and \
-       '-g' not in self.cflags and \
-       '-fsanitize=leak' not in self.cflags and \
-       not self.get_setting('WASMFS'):
-      # TODO: WasmFS has not yet been optimized for code size, and the general
-      #       increase it causes mixes up code size measurements like this.
-      #       See https://github.com/emscripten-core/emscripten/issues/16005
-      # If the call to lazy-load is unconditional, then the optimizer can dce
-      # out more than half
-      self.assertLess(first_size, 0.6 * second_size)
-
-    wasm1 = read_binary('emscripten_lazy_load_code.wasm')
-    wasm2 = read_binary('emscripten_lazy_load_code.wasm.lazy.wasm')
-    self.assertNotEqual(wasm1, wasm2)
-
-    # attempts to "break" the wasm by adding an unreachable in $foo_end. returns whether we found it.
-    def break_wasm(name):
-      wat = self.get_wasm_text(name)
-      lines = wat.splitlines()
-      wat = None
-      for i in range(len(lines)):
-        if '(func $foo_end ' in lines[i]:
-          j = i + 1
-          while '(local ' in lines[j]:
-            j += 1
-          # we found the first line after the local defs
-          lines[j] = '(unreachable)' + lines[j]
-          wat = '\n'.join(lines)
-          break
-      if wat is None:
-        # $foo_end is not present in the wasm, nothing to break
-        shutil.copy(name, name + '.orig')
-        return False
-      create_file('wat.wat', wat)
-      shutil.move(name, name + '.orig')
-      self.run_process([os.path.join(building.get_binaryen_bin(), 'wasm-as'), 'wat.wat', '-o', name, '-g', '--all-features'])
-      return True
-
-    def verify_working(args):
-      self.assertContained('foo_end\n', self.run_js('emscripten_lazy_load_code.js', args=args))
-
-    def verify_broken(args):
-      self.assertNotContained('foo_end\n', self.run_js('emscripten_lazy_load_code.js', args=args, assert_returncode=NON_ZERO))
-
-    # the first-loaded wasm will not reach the second call, since we call it after lazy-loading.
-    # verify that by changing the first wasm to throw in that function
-    found_foo_end = break_wasm('emscripten_lazy_load_code.wasm')
-    if not conditional and is_optimizing:
-      self.assertFalse(found_foo_end, 'should have optimized out $foo_end')
-    verify_working(['0'])
-    # but breaking the second wasm actually breaks us
-    if not break_wasm('emscripten_lazy_load_code.wasm.lazy.wasm'):
-      raise Exception('could not break lazy wasm - missing expected code')
-    verify_broken(['0'])
-
-    # restore
-    shutil.copy('emscripten_lazy_load_code.wasm.orig', 'emscripten_lazy_load_code.wasm')
-    shutil.copy('emscripten_lazy_load_code.wasm.lazy.wasm.orig', 'emscripten_lazy_load_code.wasm.lazy.wasm')
-    verify_working(['0'])
-
-    if conditional:
-      # if we do not call the lazy load function, then we do not need the lazy wasm,
-      # and we do the second call in the first wasm
-      os.remove('emscripten_lazy_load_code.wasm.lazy.wasm')
-      verify_broken(['0'])
-      verify_working(['42'])
-      break_wasm('emscripten_lazy_load_code.wasm')
-      verify_broken(['0'])
-
   # Test basic wasm2js functionality in all core compilation modes.
   @no_sanitize('no wasm2js support yet in sanitizers')
   @requires_wasm2js
diff --git a/tools/building.py b/tools/building.py
@@ -902,32 +902,6 @@ def metadce(js_file, wasm_file, debug_info, last):
   return acorn_optimizer(js_file, passes, extra_info=json.dumps(extra_info))
 
 
-def asyncify_lazy_load_code(wasm_target, debug):
-  # Create the lazy-loaded wasm. Remove any active memory segments and the
-  # start function from it (as these will segments have already been applied
-  # by the initial wasm) and apply the knowledge that it will only rewind,
-  # after which optimizations can remove some code
-  args = ['--remove-memory-init', '--mod-asyncify-never-unwind']
-  if settings.OPT_LEVEL > 0:
-    args.append(opt_level_to_str(settings.OPT_LEVEL, settings.SHRINK_LEVEL))
-  run_wasm_opt(wasm_target,
-               wasm_target + '.lazy.wasm',
-               args=args,
-               debug=debug)
-  # re-optimize the original, by applying the knowledge that imports will
-  # definitely unwind, and we never rewind, after which optimizations can remove
-  # a lot of code
-  # TODO: support other asyncify stuff, imports that don't always unwind?
-  # TODO: source maps etc.
-  args = ['--mod-asyncify-always-and-only-unwind']
-  if settings.OPT_LEVEL > 0:
-    args.append(opt_level_to_str(settings.OPT_LEVEL, settings.SHRINK_LEVEL))
-  run_wasm_opt(infile=wasm_target,
-               outfile=wasm_target,
-               args=args,
-               debug=debug)
-
-
 def minify_wasm_imports_and_exports(js_file, wasm_file, minify_exports, debug_info):
   logger.debug('minifying wasm imports and exports')
   # run the pass
diff --git a/tools/link.py b/tools/link.py
diff --git a/tools/maint/gen_sig_info.py b/tools/maint/gen_sig_info.py
diff --git a/tools/settings.py b/tools/settings.py
