Implement support for reading argc and argv in MINIMAL_RUNTIME. (#25307)

Implement support for reading argc and argv in MINIMAL_RUNTIME. With the
help of the existing MAIN_READS_PARAMS machinery (thanks to
#9064), this is
only-pay-for-what-you-use.

Note that unlike the regular runtime that locates `argv[0]` to be the
script name, MINIMAL_RUNTIME will place the shell interpreter name in
`argv[0]` and the script name in `argv[1]`, to align with Node.js and
Python `process.argv` and `sys.argv` behavior.

In a browser run, regular runtime has a dummy `"./this.program"` in
`argv[0]`. Instead of a hardcoded mock value in `argv[0]`, the current
page URL (e.g. `"https://localhost:5932/foo/bar/baz.html"`) is located
in `argv[0]` instead, followed by the search query parameters in
`argv[1]` onwards.

Author: juj

src/postamble_minimal.js

@@ -26,28 +26,64 @@ function exitRuntime(ret) {
 }
 #endif
 
+{{{ globalThis.argc_argv = function(condition) {
+    if (!MAIN_READS_PARAMS) return '';
+    return `argc, ${to64('argv')}`;
+  }
+  globalThis.HEAPptr = MEMORY64 ? 'HEAPU64' : 'HEAPU32';
+  null;
+}}}
+
 function run() {
 #if MEMORYPROFILER
   emscriptenMemoryProfiler.onPreloadComplete();
 #endif
 
   <<< ATMAINS >>>
 
+#if MAIN_READS_PARAMS
+  var args =
+#if ENVIRONMENT_MAY_BE_NODE
+    // Remove Node.js executable name from argc/argv to emulate C/C++ standards.
+    ENVIRONMENT_IS_NODE ? process.argv.slice(1) :
+#endif
+    [location.href.split('?')[0], ...location.search.slice(1).split('&').map(decodeURIComponent)];
+
+  // C standard (C17 §5.1.2.2.1/5): "The parameters argc and argv and the
+  // strings pointed to by the argv array shall be modifiable by the program,
+  // and retain their last-stored values between program startup and program
+  // termination."
+  // -> in particular this means that the stackAlloc() that we do below shall
+  // never be undone, and ideally should no longer be considered to be part of
+  // the stack. Though currently it will be. (TODO: figure if this will ever be
+  // a problem)
+  var arg,
+    argc = args.length,
+    argv = stackAlloc(argc * {{{ POINTER_SIZE }}} + {{{ POINTER_SIZE }}}),
+    argvIndex = argv / {{{ POINTER_SIZE }}};
+
+  for (arg of args) {{{ HEAPptr }}}[argvIndex++] = {{{ to64('stringToUTF8OnStack(arg)') }}};
+
+  // C standard (C17 §5.1.2.2.1/2): "argv[argc] shall be a null pointer."
+  {{{ HEAPptr }}}[argvIndex] = {{{ to64(0) }}};
+
+#endif
+
 #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
   // the application.
-  __emscripten_proxy_main();
+  __emscripten_proxy_main({{{ argc_argv() }}});
 #elif ASYNCIFY == 2 && EXIT_RUNTIME
   // In JSPI-enabled build mode, the main() function will return a Promise,
   // which resolves to the process exit code.
-  _main().then(exitRuntime);
+  _main({{{ argc_argv() }}}).then(exitRuntime);
 #elif EXIT_RUNTIME
   // In regular exitRuntime mode, exit with the given return code from main().
-  exitRuntime(_main());
+  exitRuntime(_main({{{ argc_argv() }}}));
 #else
   // Run a persistent (never-exiting) application starting at main().
-  _main();
+  _main({{{ argc_argv() }}});
 #endif 
 
 #if STACK_OVERFLOW_CHECK

test/codesize/test_minimal_runtime_code_size_math.json

@@ -1,10 +1,10 @@
 {
   "a.html": 552,
   "a.html.gz": 373,
-  "a.js": 112,
-  "a.js.gz": 121,
-  "a.wasm": 2678,
-  "a.wasm.gz": 1648,
-  "total": 3342,
-  "total_gz": 2142
+  "a.js": 849,
+  "a.js.gz": 506,
+  "a.wasm": 2715,
+  "a.wasm.gz": 1674,
+  "total": 4116,
+  "total_gz": 2553
 }