Unify more of the minimal runtime and normal runtime initialization code.

This is a first step in trying to unify more of the code used by minimal
runtime and the normal runtime and also move all addOn* functions into
a library.

First, make the call to the static constructors use the same code for both
modes. With this change, it becomes necessary to have an injection point
that runs before ctors and after ctors. To achieved that, I've replaced
the unused ATMAIN with new ATPOSTINIT code injection point. The new
ATPOSTINIT is similar to the old ATMAIN in that it runs after the static
constructors, but it now runs even if there is no main function.

Second, the FS initialization is now split into two parts (similar to how
it used to be before a refactoring).
1) atInit the std<X> stream are setup. This allows ctors to use printf etc.
2) atPostInit the FS is locked down as late as possible but before main is
run.

Third, switch embind code generation to use the POSTINIT so it can run
after the ctors have setup the bindings.

Fourth, minimal runtime changes slightly in that ATINIT runs before ctors.
This makes it consistent with the normal mode, but there is now POSTINIT
if anyone needs the old behavior.

Author: brendandahl

src/jsifier.mjs

@@ -10,7 +10,7 @@
 import {
   ATEXITS,
   ATINITS,
-  ATMAINS,
+  ATPOSTINITS,
   defineI64Param,
   indentify,
   makeReturn64,
@@ -774,7 +774,7 @@ var proxiedFunctionTable = [
           asyncFuncs,
           libraryDefinitions: LibraryManager.libraryDefinitions,
           ATINITS: ATINITS.join('\n'),
-          ATMAINS: STRICT ? '' : ATMAINS.join('\n'),
+          ATPOSTINITS: ATPOSTINITS.join('\n'),
           ATEXITS: ATEXITS.join('\n'),
         }),
     );

src/lib/libembind_gen.js

@@ -835,7 +835,7 @@ var LibraryEmbind = {
 
 #if EMBIND_AOT
   $embindEmitAotJs__deps: ['$awaitingDependencies', '$throwBindingError', '$getTypeName', '$moduleDefinitions', '$JsPrinter'],
-  $embindEmitAotJs__postset: 'addOnInit(embindEmitAotJs);',
+  $embindEmitAotJs__postset: () => { addAtPostInit('embindEmitAotJs()'); },
   $embindEmitAotJs: () => {
     for (const typeId in awaitingDependencies) {
       throwBindingError(`Missing binding for type: '${getTypeName(typeId)}' typeId: ${typeId}`);
@@ -845,7 +845,7 @@ var LibraryEmbind = {
   },
 #else // EMBIND_AOT
   $embindEmitTypes__deps: ['$awaitingDependencies', '$throwBindingError', '$getTypeName', '$moduleDefinitions', '$TsPrinter'],
-  $embindEmitTypes__postset: 'addOnInit(embindEmitTypes);',
+  $embindEmitTypes__postset: () => { addAtPostInit('embindEmitTypes()'); },
   $embindEmitTypes: () => {
     for (const typeId in awaitingDependencies) {
       throwBindingError(`Missing binding for type: '${getTypeName(typeId)}' typeId: ${typeId}`);

src/lib/libfs.js

@@ -36,8 +36,8 @@ addToLibrary({
     addAtInit(`
 if (!Module['noFSInit'] && !FS.initialized)
   FS.init();
-FS.ignorePermissions = false;
-`)
+`);
+    addAtPostInit('FS.ignorePermissions = false;');
     addAtExit('FS.quit();');
     return `
 FS.createPreloadedFile = FS_createPreloadedFile;

src/parseTools.mjs

@@ -731,14 +731,22 @@ function makeEval(code) {
   return ret;
 }
 
-export const ATMAINS = [];
-
 export const ATINITS = [];
 
+// Add code to run after the Wasm module is loaded, but before static
+// constructors and main (if applicable). The code will be executed before the
+// runtime `__ATINIT__` callbacks.
 function addAtInit(code) {
   ATINITS.push(code);
 }
 
+export const ATPOSTINITS = [];
+
+// Add code to run after static constructors, but before main (if applicable).
+function addAtPostInit(code) {
+  ATPOSTINITS.push(code);
+}
+
 export const ATEXITS = [];
 
 function addAtExit(code) {
@@ -1086,6 +1094,7 @@ function ENVIRONMENT_IS_WORKER_THREAD() {
 addToCompileTimeContext({
   ATEXITS,
   ATINITS,
+  ATPOSTINITS,
   FOUR_GB,
   LONG_TYPE,
   POINTER_HEAP,
@@ -1104,6 +1113,7 @@ addToCompileTimeContext({
   ENVIRONMENT_IS_WORKER_THREAD,
   addAtExit,
   addAtInit,
+  addAtPostInit,
   asyncIf,
   awaitIf,
   buildStringArray,

src/parseTools_legacy.mjs

@@ -5,7 +5,7 @@
  */
 
 import {warn, addToCompileTimeContext} from './utility.mjs';
-import {ATMAINS, POINTER_SIZE, runIfMainThread} from './parseTools.mjs';
+import {ATPOSTINITS, POINTER_SIZE, runIfMainThread} from './parseTools.mjs';
 
 // Replaced (at least internally) with receiveI64ParamAsI53 that does
 // bounds checking.
@@ -42,7 +42,7 @@ const Runtime = {
 const runOnMainThread = runIfMainThread;
 
 addToCompileTimeContext({
-  ATMAINS,
+  ATPOSTINITS,
   Runtime,
   makeMalloc,
   receiveI64ParamAsDouble,

src/postamble_minimal.js

@@ -13,8 +13,6 @@ function run() {
   emscriptenMemoryProfiler.onPreloadComplete();
 #endif
 
-  <<< ATMAINS >>>
-
 #if PROXY_TO_PTHREAD
   // User requested the PROXY_TO_PTHREAD option, so call a stub main which
   // pthread_create()s a new thread that will call the user's real main() for
@@ -73,11 +71,13 @@ function initRuntime(wasmExports) {
   PThread.tlsInitFunctions.push(wasmExports['_emscripten_tls_init']);
 #endif
 
+  <<< ATINITS >>>
+
 #if hasExportedSymbol('__wasm_call_ctors')
   wasmExports['__wasm_call_ctors']();
 #endif
 
-  <<< ATINITS >>>
+  <<< ATPOSTINITS >>>
 }
 
 // Initialize wasm (asynchronous)

src/preamble.js

@@ -217,16 +217,22 @@ function initRuntime() {
 #if RELOCATABLE
   callRuntimeCallbacks(__RELOC_FUNCS__);
 #endif
+
   <<< ATINITS >>>
   callRuntimeCallbacks(__ATINIT__);
+
+#if hasExportedSymbol('__wasm_call_ctors')
+  wasmExports['__wasm_call_ctors']();
+#endif
+
+  <<< ATPOSTINITS >>>
 }
 
 #if HAS_MAIN
 function preMain() {
 #if STACK_OVERFLOW_CHECK
   checkStackCookie();
 #endif
-  <<< ATMAINS >>>
   callRuntimeCallbacks(__ATMAIN__);
 }
 #endif
@@ -951,10 +957,6 @@ function getWasmImports() {
 #endif
 #endif
 
-#if hasExportedSymbol('__wasm_call_ctors')
-    addOnInit(wasmExports['__wasm_call_ctors']);
-#endif
-
 #if hasExportedSymbol('__wasm_apply_data_relocs')
     __RELOC_FUNCS__.push(wasmExports['__wasm_apply_data_relocs']);
 #endif

test/test_other.py

@@ -8431,6 +8431,30 @@ def test_binaryen_stack_ir(self, opts, disable_and_enable):
     self.assertLess(err.count(DISABLE), 2)
     self.assertLess(err.count(ENABLE), 2)
 
+  @also_with_minimal_runtime
+  def test_run_order(self):
+    create_file('lib.js', r'''
+addToLibrary({
+  foo__postset: () => {
+    addAtPostInit("console.log(`addAtPostInit`);");
+    addAtInit("console.log(`addAtInit`);");
+  },
+  foo: () => {},
+});
+''')
+    create_file('src.c', r'''
+    #include <stdio.h>
+    void foo();
+    __attribute__((constructor)) void ctor() {
+      printf("ctor\n");
+    }
+    int main() {
+      printf("main\n");
+      foo();
+    }
+    ''')
+    self.do_runf('src.c', 'addAtInit\nctor\naddAtPostInit\nmain\n', emcc_args=['--js-library', 'lib.js'])
+
   def test_override_js_execution_environment(self):
     create_file('main.c', r'''
       #include <emscripten.h>

tools/building.py

@@ -393,10 +393,7 @@ def acorn_optimizer(filename, passes, extra_info=None, return_output=False, work
 # evals ctors. if binaryen_bin is provided, it is the dir of the binaryen tool
 # for this, and we are in wasm mode
 def eval_ctors(js_file, wasm_file, debug_info):
-  if settings.MINIMAL_RUNTIME:
-    CTOR_ADD_PATTERN = f"wasmExports['{WASM_CALL_CTORS}']();" # TODO test
-  else:
-    CTOR_ADD_PATTERN = f"addOnInit(wasmExports['{WASM_CALL_CTORS}']);"
+  CTOR_ADD_PATTERN = f"wasmExports['{WASM_CALL_CTORS}']();"
 
   js = utils.read_file(js_file)
 

tools/emscripten.py

@@ -162,8 +162,7 @@ def update_settings_glue(wasm_file, metadata, base_metadata):
 
 def apply_static_code_hooks(forwarded_json, code):
   code = shared.do_replace(code, '<<< ATINITS >>>', str(forwarded_json['ATINITS']))
-  if settings.HAS_MAIN:
-    code = shared.do_replace(code, '<<< ATMAINS >>>', str(forwarded_json['ATMAINS']))
+  code = shared.do_replace(code, '<<< ATPOSTINITS >>>', str(forwarded_json['ATPOSTINITS']))
   if settings.EXIT_RUNTIME and (not settings.MINIMAL_RUNTIME or settings.HAS_MAIN):
     code = shared.do_replace(code, '<<< ATEXITS >>>', str(forwarded_json['ATEXITS']))
   return code