From d486dc187d3dffe91cdf26e784e1054240383a92 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Fri, 6 Dec 2019 18:40:47 +0200
Subject: [PATCH 01/27] Add pthreads support to MINIMAL_RUNTIME.

---
 emcc.py                                    | 13 ++--
 src/library.js                             | 12 ++++
 src/library_pthread.js                     | 24 +++++--
 src/modules.js                             | 20 ++++--
 src/parseTools.js                          | 10 +++
 src/postamble_minimal.js                   | 25 ++++++-
 src/preamble_minimal.js                    | 49 ++++++++++---
 src/settings.js                            |  6 ++
 src/shell_minimal.js                       | 32 ++++++---
 src/shell_minimal_runtime.html             |  6 +-
 src/worker.js                              | 82 ++++++++++++++++++----
 tests/pthread/call_async_on_main_thread.js |  2 +-
 tests/pthread/test_pthread_run_script.cpp  | 12 ++--
 tools/minimal_runtime_shell.py             | 11 ++-
 14 files changed, 248 insertions(+), 56 deletions(-)

diff --git a/emcc.py b/emcc.py
index d83fbf9f49a9a..a5aad7639453c 100755
--- a/emcc.py
+++ b/emcc.py
@@ -1538,6 +1538,9 @@ def is_supported_link_flag(f):
       # consider it a user export, i.e., one which can never be removed).
       shared.Building.user_requested_exports += ['dynCall_ii']
 
+      if shared.Settings.MINIMAL_RUNTIME:
+        shared.Building.user_requested_exports += ['exit']
+
       if shared.Settings.PROXY_TO_PTHREAD:
         shared.Settings.EXPORTED_FUNCTIONS += ['_proxy_main']
 
@@ -1554,7 +1557,12 @@ def include_and_export(name):
         # can access them:
 
         # general threading variables:
-        shared.Settings.EXPORTED_RUNTIME_METHODS += ['PThread', 'ExitStatus']
+        shared.Settings.EXPORTED_RUNTIME_METHODS += ['PThread']
+
+        # To keep code size to minimum, MINIMAL_RUNTIME does not utilize the global ExitStatus
+        # object, only regular runtime has it.
+        if not shared.Settings.MINIMAL_RUNTIME:
+          shared.Settings.EXPORTED_RUNTIME_METHODS += ['ExitStatus']
 
         # stack check:
         if shared.Settings.STACK_OVERFLOW_CHECK:
@@ -1921,9 +1929,6 @@ def check_human_readable_list(items):
       if shared.Settings.EMTERPRETIFY:
         exit_with_error('-s EMTERPRETIFY=1 is not supported with -s MINIMAL_RUNTIME=1')
 
-      if shared.Settings.USE_PTHREADS:
-        exit_with_error('-s USE_PTHREADS=1 is not yet supported with -s MINIMAL_RUNTIME=1')
-
       if shared.Settings.PRECISE_F32 == 2:
         exit_with_error('-s PRECISE_F32=2 is not supported with -s MINIMAL_RUNTIME=1')
 
diff --git a/src/library.js b/src/library.js
index 8c89ff1170873..8903f55c27533 100644
--- a/src/library.js
+++ b/src/library.js
@@ -275,6 +275,12 @@ LibraryManager.library = {
   _Exit__sig: 'vi',
   _Exit: 'exit',
 
+#if MINIMAL_RUNTIME
+  $exit: function(status) {
+    throw 'exit(' + status + ')';
+  },
+#endif
+
   fork__deps: ['__setErrNo'],
   fork: function() {
     // pid_t fork(void);
@@ -1357,10 +1363,16 @@ LibraryManager.library = {
   $establishStackSpace__asm: true,
   $establishStackSpace__sig: 'vii',
   $establishStackSpace: function(stackBase, stackMax) {
+#if WASM_BACKEND
+    // The wasm backend path does not have a way to set the stack max, so ignore
+    // the stack max parameter, this function only resets the stack base.
+    stackRestore(stackBase);
+#else
     stackBase = stackBase|0;
     stackMax = stackMax|0;
     STACKTOP = stackBase;
     STACK_MAX = stackMax;
+#endif
   },
 #endif
 
diff --git a/src/library_pthread.js b/src/library_pthread.js
index 74e3a655bc779..a20276efd0ff6 100644
--- a/src/library_pthread.js
+++ b/src/library_pthread.js
@@ -389,7 +389,11 @@ var LibraryPThread = {
         'urlOrBlob': Module['mainScriptUrlOrBlob'] || _scriptDir,
 #if WASM
         'wasmMemory': wasmMemory,
-        'wasmModule': wasmModule,
+#if MINIMAL_RUNTIME
+        wasmModule: Module['wasm'],
+#else
+        wasmModule: wasmModule,
+#endif
 #if LOAD_SOURCE_MAP
         'wasmSourceMap': wasmSourceMap,
 #endif
@@ -400,17 +404,23 @@ var LibraryPThread = {
         'buffer': HEAPU8.buffer,
         'asmJsUrlOrBlob': Module["asmJsUrlOrBlob"],
 #endif
+#if !MINIMAL_RUNTIME
         'DYNAMIC_BASE': DYNAMIC_BASE,
+#endif
         'DYNAMICTOP_PTR': DYNAMICTOP_PTR
       });
     },
 
     // Creates a new web Worker and places it in the unused worker pool to wait for its use.
     allocateUnusedWorker: function() {
+#if MINIMAL_RUNTIME
+      var pthreadMainJs = Module['worker'];
+#else
       // Allow HTML module to configure the location where the 'worker.js' file will be loaded from,
       // via Module.locateFile() function. If not specified, then the default URL 'worker.js' relative
       // to the main html file is loaded.
       var pthreadMainJs = locateFile('{{{ PTHREAD_WORKER_FILE }}}');
+#endif
 #if PTHREADS_DEBUG
       out('Allocating a new web worker from ' + pthreadMainJs);
 #endif
@@ -769,17 +779,21 @@ var LibraryPThread = {
     if (canceled == 2) throw 'Canceled!';
   },
 
-  emscripten_check_blocking_allowed: function() {
 #if ASSERTIONS
+  emscripten_check_blocking_allowed: function() {
     assert(ENVIRONMENT_IS_WEB);
     warnOnce('Blocking on the main thread is very dangerous, see https://emscripten.org/docs/porting/pthreads.html#blocking-on-the-main-browser-thread');
-#endif
 #if !ALLOW_BLOCKING_ON_MAIN_THREAD
     abort('Blocking on the main thread is not allowed by default. See https://emscripten.org/docs/porting/pthreads.html#blocking-on-the-main-browser-thread');
 #endif
   },
+#endif
 
-  _emscripten_do_pthread_join__deps: ['_cleanup_thread', '_pthread_testcancel_js', 'emscripten_main_thread_process_queued_calls', 'emscripten_futex_wait', 'emscripten_check_blocking_allowed'],
+  _emscripten_do_pthread_join__deps: ['_cleanup_thread', '_pthread_testcancel_js', 'emscripten_main_thread_process_queued_calls', 'emscripten_futex_wait',
+#if ASSERTIONS
+  'emscripten_check_blocking_allowed'
+#endif
+  ],
   _emscripten_do_pthread_join: function(thread, status, block) {
     if (!thread) {
       err('pthread_join attempted on a null thread pointer!');
@@ -805,9 +819,11 @@ var LibraryPThread = {
       return ERRNO_CODES.EINVAL; // The thread is already detached, can no longer join it!
     }
 
+#if ASSERTIONS
     if (block && ENVIRONMENT_IS_WEB) {
       _emscripten_check_blocking_allowed();
     }
+#endif
 
     for (;;) {
       var threadStatus = Atomics.load(HEAPU32, (thread + {{{ C_STRUCTS.pthread.threadStatus }}} ) >> 2);
diff --git a/src/modules.js b/src/modules.js
index f7a35003263ff..0f7caf645a9ce 100644
--- a/src/modules.js
+++ b/src/modules.js
@@ -87,6 +87,10 @@ var LibraryManager = {
       libraries.push('library_browser.js');
     }
 
+    if (USE_PTHREADS) { // TODO: Currently WebGL proxying makes pthreads library depend on WebGL.
+      libraries.push('library_webgl.js');
+    }
+
     if (FILESYSTEM) {
       // Core filesystem libraries (always linked against, unless -s FILESYSTEM=0 is specified)
       libraries = libraries.concat([
@@ -472,10 +476,13 @@ function exportRuntime() {
     // In pthreads mode, the following functions always need to be exported to
     // Module for closure compiler, and also for MODULARIZE (so worker.js can
     // access them).
-    var threadExports = ['PThread', 'ExitStatus', '_pthread_self'];
+    var threadExports = ['PThread', '_pthread_self'];
     if (WASM) {
       threadExports.push('wasmMemory');
     }
+    if (!MINIMAL_RUNTIME) {
+      threadExports.push('ExitStatus');
+    }
 
     threadExports.forEach(function(x) {
       EXPORTED_RUNTIME_METHODS_SET[x] = 1;
@@ -512,11 +519,16 @@ function exportRuntime() {
       }
     }
   }
-  return runtimeElements.map(function(name) {
+  function removeEmptyElements(x) {
+    return x.filter(function(e) {
+      return e != null;
+    })
+  }
+  return removeEmptyElements(runtimeElements.map(function(name) {
     return maybeExport(name);
-  }).join('\n') + runtimeNumbers.map(function(name) {
+  })).join('\n') + removeEmptyElements(runtimeNumbers.map(function(name) {
     return maybeExportNumber(name);
-  }).join('\n');
+  })).join('\n');
 }
 
 var PassManager = {
diff --git a/src/parseTools.js b/src/parseTools.js
index 9c9ead903e57f..12d8acad0c24e 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -1658,3 +1658,13 @@ function buildStringArray(array) {
     return '[]';
   }
 }
+
+// Generates access to a JS global scope variable in pthreads worker.js. In MODULARIZE mode the JS scope is not directly accessible, so all the relevant variables
+// are exported via Module. In non-MODULARIZE mode, we can directly access the variables in global scope.
+function makeAsmGlobalAccessInPthread(variable) {
+  if (MODULARIZE || !MINIMAL_RUNTIME) {
+    return "Module['" + variable + "']"; // 'Module' is defined in worker.js local scope, so not EXPORT_NAME in this case.
+  } else {
+    return variable;
+  }
+}
diff --git a/src/postamble_minimal.js b/src/postamble_minimal.js
index c004eff1c6f41..b6bb17e0161c4 100644
--- a/src/postamble_minimal.js
+++ b/src/postamble_minimal.js
@@ -118,6 +118,10 @@ WebAssembly.instantiateStreaming(fetch('{{{ TARGET_BASENAME }}}.wasm'), imports)
 // Module['wasm'] should contain a typed array of the Wasm object data, or a precompiled WebAssembly Module.
 if (!Module['wasm']) throw 'Must load WebAssembly Module in to variable Module.wasm before adding compiled output .js script to the DOM';
 #endif
+#if USE_PTHREADS
+// Store the Wasm instance to be able to post it to pthreads.
+Module['wasmInstance'] =
+#endif
 WebAssembly.instantiate(Module['wasm'], imports).then(function(output) {
 #endif
 
@@ -132,13 +136,15 @@ WebAssembly.instantiate(Module['wasm'], imports).then(function(output) {
 // output object will have an output.instance and output.module objects. But if Module['wasm']
 // is an already compiled WebAssembly module, then output is the WebAssembly instance itself.
 // Depending on the build mode, Module['wasm'] can mean a different thing.
-#if MINIMAL_RUNTIME_STREAMING_WASM_COMPILATION || MINIMAL_RUNTIME_STREAMING_WASM_INSTANTIATION
+#if MINIMAL_RUNTIME_STREAMING_WASM_COMPILATION || MINIMAL_RUNTIME_STREAMING_WASM_INSTANTIATION || USE_PTHREADS
 // https://caniuse.com/#feat=wasm and https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/instantiateStreaming
 // Firefox 52 added Wasm support, but only Firefox 58 added compileStreaming & instantiateStreaming.
 // Chrome 57 added Wasm support, but only Chrome 61 added compileStreaming & instantiateStreaming.
 // Node.js and Safari do not support compileStreaming or instantiateStreaming.
-#if MIN_FIREFOX_VERSION < 58 || MIN_CHROME_VERSION < 61 || ENVIRONMENT_MAY_BE_NODE || MIN_SAFARI_VERSION != TARGET_NOT_SUPPORTED
-  asm = output.instance ? output.instance.exports : output.exports;
+#if MIN_FIREFOX_VERSION < 58 || MIN_CHROME_VERSION < 61 || ENVIRONMENT_MAY_BE_NODE || MIN_SAFARI_VERSION != TARGET_NOT_SUPPORTED || USE_PTHREADS
+  // In pthreads, Module['wasm'] is an already compiled WebAssembly.Module. In that case, 'output' is a WebAssembly.Instance.
+  // In main thread, Module['wasm'] is either a typed array or a fetch stream. In that case, 'output.instance' is the WebAssembly.Instance.
+  var asm = (output.instance || output).exports;
 #else
   asm = output.exports;
 #endif
@@ -153,8 +159,14 @@ WebAssembly.instantiate(Module['wasm'], imports).then(function(output) {
 #else
   /*** ASM_MODULE_EXPORTS ***/
 #endif
+
   initRuntime(asm);
+#if PTHREAD_POOL_SIZE
+  if (!ENVIRONMENT_IS_PTHREAD) PThread.allocateUnusedWorkers({{{PTHREAD_POOL_SIZE}}}, ready);
+  else ready();
+#else
   ready();
+#endif
 })
 #if ASSERTIONS
 .catch(function(error) {
@@ -167,8 +179,15 @@ WebAssembly.instantiate(Module['wasm'], imports).then(function(output) {
 
 // Initialize asm.js (synchronous)
 initRuntime(asm);
+
+#if PTHREAD_POOL_SIZE
+if (!ENVIRONMENT_IS_PTHREAD) PThread.allocateUnusedWorkers({{{PTHREAD_POOL_SIZE}}}, ready);
+else ready();
+#else
 ready();
+#endif
 
 #endif
 
 {{GLOBAL_VARS}}
+
diff --git a/src/preamble_minimal.js b/src/preamble_minimal.js
index 2b2f5b4ac53df..66254379f1152 100644
--- a/src/preamble_minimal.js
+++ b/src/preamble_minimal.js
@@ -12,7 +12,11 @@ function assert(condition, text) {
 #endif
 
 function abort(what) {
+#if ASSERTIONS
+  throw new Error(what);
+#else
   throw what;
+#endif
 }
 
 var tempRet0 = 0;
@@ -50,12 +54,16 @@ Module['wasm'] = base64Decode('{{{ getQuoted("WASM_BINARY_DATA") }}}');
 #include "runtime_sab_polyfill.js"
 
 #if USE_PTHREADS
+var STATIC_BASE = {{{ GLOBAL_BASE }}};
+
 if (!ENVIRONMENT_IS_PTHREAD) {
 #endif
 
 var GLOBAL_BASE = {{{ GLOBAL_BASE }}},
     TOTAL_STACK = {{{ TOTAL_STACK }}},
+#if !USE_PTHREADS
     STATIC_BASE = {{{ GLOBAL_BASE }}},
+#endif
     STACK_BASE = {{{ getQuoted('STACK_BASE') }}},
     STACKTOP = STACK_BASE,
     STACK_MAX = {{{ getQuoted('STACK_MAX') }}}
@@ -82,6 +90,15 @@ var wasmMemory = new WebAssembly.Memory({
 #endif
   });
 
+var buffer = wasmMemory.buffer;
+
+#if USE_PTHREADS
+}
+#if ASSERTIONS
+assert(buffer instanceof SharedArrayBuffer, 'requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag');
+#endif
+#endif
+
 var wasmTable = new WebAssembly.Table({
   'initial': {{{ getQuoted('WASM_TABLE_SIZE') }}},
 #if !ALLOW_TABLE_GROWTH
@@ -94,12 +111,6 @@ var wasmTable = new WebAssembly.Table({
   'element': 'anyfunc'
 });
 
-var buffer = wasmMemory.buffer;
-
-#if USE_PTHREADS && ASSERTIONS
-assert(buffer instanceof SharedArrayBuffer, 'requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag');
-#endif
-
 #else
 
 #if USE_PTHREADS
@@ -116,14 +127,20 @@ var buffer = new ArrayBuffer({{{ TOTAL_MEMORY }}});
 
 #if ASSERTIONS
 var WASM_PAGE_SIZE = 65536;
-assert(STACK_BASE % 16 === 0, 'stack must start aligned');
-assert(({{{ getQuoted('DYNAMIC_BASE') }}}) % 16 === 0, 'heap must start aligned');
+#if USE_PTHREADS
+if (!ENVIRONMENT_IS_PTHREAD) {
+#endif
+assert(STACK_BASE % 16 === 0, 'stack must start aligned to 16 bytes, STACK_BASE==' + STACK_BASE);
+assert(({{{ getQuoted('DYNAMIC_BASE') }}}) % 16 === 0, 'heap must start aligned to 16 bytes, DYNAMIC_BASE==' + {{{ getQuoted('DYNAMIC_BASE') }}});
 assert({{{ TOTAL_MEMORY }}} >= TOTAL_STACK, 'TOTAL_MEMORY should be larger than TOTAL_STACK, was ' + {{{ TOTAL_MEMORY }}} + '! (TOTAL_STACK=' + TOTAL_STACK + ')');
 assert({{{ TOTAL_MEMORY }}} % WASM_PAGE_SIZE === 0);
 #if WASM_MEM_MAX != -1
 assert({{{ WASM_MEM_MAX }}} % WASM_PAGE_SIZE == 0);
 #endif
 assert(buffer.byteLength === {{{ TOTAL_MEMORY }}});
+#if USE_PTHREADS
+}
+#endif
 #endif // ASSERTIONS
 
 #if ALLOW_MEMORY_GROWTH
@@ -157,10 +174,20 @@ var HEAPF64 = new Float64Array(buffer);
 #endif
 
 #if MEM_INIT_METHOD == 1 && !MEM_INIT_IN_WASM && !SINGLE_FILE
+
+#if USE_PTHREADS
+if (!ENVIRONMENT_IS_PTHREAD) {
+#endif
+
 #if ASSERTIONS
 if (!Module['mem']) throw 'Must load memory initializer as an ArrayBuffer in to variable Module.mem before adding compiled output .js script to the DOM';
 #endif
 HEAPU8.set(new Uint8Array(Module['mem']), GLOBAL_BASE);
+
+#if USE_PTHREADS
+}
+#endif
+
 #endif
 
 #if SINGLE_FILE && !WASM && !WASM_BACKEND
@@ -169,7 +196,11 @@ HEAPU8.set(base64Decode('{{{ getQuoted("BASE64_MEMORY_INITIALIZER") }}}'), GLOBA
 #endif
 
 #if USES_DYNAMIC_ALLOC
-HEAP32[DYNAMICTOP_PTR>>2] = {{{ getQuoted('DYNAMIC_BASE') }}};
+  HEAP32[DYNAMICTOP_PTR>>2] = {{{ getQuoted('DYNAMIC_BASE') }}};
+#endif
+
+#if USE_PTHREADS
+}
 #endif
 
 #include "runtime_stack_check.js"
diff --git a/src/settings.js b/src/settings.js
index badeb2e65b8e3..c0c36cd0dfce1 100644
--- a/src/settings.js
+++ b/src/settings.js
@@ -1291,6 +1291,12 @@ var WASM_MEM_MAX = -1;
 // (This option was formerly called BINARYEN_ASYNC_COMPILATION)
 var WASM_ASYNC_COMPILATION = 1;
 
+// If set to 1, MINIMAL_RUNTIME will utilize streaming WebAssembly compilation
+// (via WebAssembly.instantiateStreaming). This requires the MIME type of the
+// application to be set correctly. If set to 0, non-streaming compilation
+// (via WebAssembly.instantiate) will be used.
+var STREAMING_WASM_COMPILATION = 1;
+
 // WebAssembly defines a "producers section" which compilers and tools can
 // annotate themselves in. Emscripten does not emit this by default, as it
 // increases code size, and some users may not want information about their tools
diff --git a/src/shell_minimal.js b/src/shell_minimal.js
index 1c9935181455d..f159d34810641 100644
--- a/src/shell_minimal.js
+++ b/src/shell_minimal.js
@@ -21,6 +21,18 @@ var ENVIRONMENT_IS_NODE = typeof process === 'object';
 var ENVIRONMENT_IS_SHELL = typeof read === 'function';
 #endif
 
+#if ASSERTIONS
+#if !ENVIRONMENT_MAY_BE_NODE && !ENVIRONMENT_MAY_BE_SHELL
+var ENVIRONMENT_IS_WEB = true
+#else
+#if ENVIRONMENT && ENVIRONMENT.indexOf(',') < 0
+var ENVIRONMENT_IS_WEB = {{{ ENVIRONMENT === 'web' }}};
+#else
+var ENVIRONMENT_IS_WEB = !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_SHELL;
+#endif
+#endif
+#endif
+
 #if ASSERTIONS && ENVIRONMENT_MAY_BE_NODE && ENVIRONMENT_MAY_BE_SHELL
 if (ENVIRONMENT_IS_NODE && ENVIRONMENT_IS_SHELL) {
   throw 'unclear environment';
@@ -117,7 +129,13 @@ function err(text) {
 // compilation is ready. In that callback, call the function run() to start
 // the program.
 function ready() {
-  run();
+#if USE_PTHREADS
+  if (!ENVIRONMENT_IS_PTHREAD) {
+#endif
+    run();
+#if USE_PTHREADS
+  }
+#endif
 }
 
 // --pre-jses are emitted after the Module integration code, so that they can
@@ -133,16 +151,12 @@ function ready() {
 var _scriptDir = (typeof document !== 'undefined' && document.currentScript) ? document.currentScript.src : undefined;
 #endif
 
-var ENVIRONMENT_IS_PTHREAD;
-if (!ENVIRONMENT_IS_PTHREAD) ENVIRONMENT_IS_PTHREAD = false; // ENVIRONMENT_IS_PTHREAD=true will have been preset in pthread-main.js. Make it false in the main runtime thread.
+// MINIMAL_RUNTIME does not support --proxy-to-worker option, so Worker and Pthread environments
+// coincide.
+var ENVIRONMENT_IS_WORKER = ENVIRONMENT_IS_PTHREAD = typeof importScripts === 'function';
 
-if (typeof ENVIRONMENT_IS_PTHREAD === 'undefined') {
-  // ENVIRONMENT_IS_PTHREAD=true will have been preset in pthread-main.js. Make it false in the main runtime thread. 
-  // N.B. this line needs to appear without 'var' keyword to avoid 'var hoisting' from occurring. (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/var)
-  ENVIRONMENT_IS_PTHREAD = false;
-}
 #if MODULARIZE
-else {
+if (ENVIRONMENT_IS_WORKER) {
   var buffer = {{{EXPORT_NAME}}}.buffer;
   var STATICTOP = {{{EXPORT_NAME}}}.STATICTOP;
   var DYNAMICTOP_PTR = {{{EXPORT_NAME}}}.DYNAMICTOP_PTR;
diff --git a/src/shell_minimal_runtime.html b/src/shell_minimal_runtime.html
index a42604bc73a31..711102b5ecef9 100644
--- a/src/shell_minimal_runtime.html
+++ b/src/shell_minimal_runtime.html
@@ -3,7 +3,11 @@
 <canvas style='display:block; margin:auto;'></canvas>
 <script>
 #if !MODULARIZE
-  var Module = {};
+  var Module = {
+#if USE_PTHREADS
+    worker: '{{{ PTHREAD_WORKER_FILE }}}'
+#endif
+};
 #endif
 
 #if WASM == 2
diff --git a/src/worker.js b/src/worker.js
index 05593f15b4180..7ab21ec1e51ac 100644
--- a/src/worker.js
+++ b/src/worker.js
@@ -17,7 +17,7 @@ var parentThreadId = 0; // The ID of the parent pthread that launched this threa
 var Module = {};
 
 // These modes need to assign to these variables because of how scoping works in them.
-#if EXPORT_ES6 || MODULARIZE
+#if (EXPORT_ES6 || MODULARIZE) && !MINIMAL_RUNTIME
 var PThread;
 var HEAPU32;
 #endif
@@ -40,6 +40,7 @@ function threadAlert() {
 var err = threadPrintErr;
 this.alert = threadAlert;
 
+#if LOAD_SOURCE_MAP || USE_OFFSET_CONVERTER
 // When using postMessage to send an object, it is processed by the structured clone algorithm.
 // The prototype, and hence methods, on that object is then lost. This function adds back the lost prototype.
 // This does not work with nested objects that has prototypes, but it suffices for WasmSourceMap and WasmOffsetConverter.
@@ -52,8 +53,9 @@ function resetPrototype(constructor, attrs) {
   }
   return object;
 }
+#endif
 
-#if WASM
+#if WASM && !MINIMAL_RUNTIME
 Module['instantiateWasm'] = function(info, receiveInstance) {
   // Instantiate from the module posted from the main thread.
   // We can just use sync instantiation in the worker.
@@ -81,23 +83,42 @@ var wasmOffsetData;
 this.onmessage = function(e) {
   try {
     if (e.data.cmd === 'load') { // Preload command that is called once per worker to parse and load the Emscripten code.
+#if !WASM_BACKEND
+      // Initialize the thread-local field(s):
+#if MINIMAL_RUNTIME
+      var imports = {};
+#endif
+#endif
+
       // Initialize the global "process"-wide fields:
+#if !MINIMAL_RUNTIME
       Module['DYNAMIC_BASE'] = e.data.DYNAMIC_BASE;
-      Module['DYNAMICTOP_PTR'] = e.data.DYNAMICTOP_PTR;
+#endif
+
+#if USES_DYNAMIC_ALLOC
+      {{{ makeAsmGlobalAccessInPthread('DYNAMICTOP_PTR') }}} = e.data.DYNAMICTOP_PTR;
+#endif
 
 #if WASM
       // Module and memory were sent from main thread
+#if MINIMAL_RUNTIME
+      Module['wasm'] = e.data.wasmModule;
+#else
       Module['wasmModule'] = e.data.wasmModule;
-      Module['wasmMemory'] = e.data.wasmMemory;
+#endif
+
+      {{{ makeAsmGlobalAccessInPthread('wasmMemory') }}} = e.data.wasmMemory;
+
 #if LOAD_SOURCE_MAP
       wasmSourceMapData = e.data.wasmSourceMap;
 #endif
 #if USE_OFFSET_CONVERTER
       wasmOffsetData = e.data.wasmOffsetConverter;
 #endif
-      Module['buffer'] = Module['wasmMemory'].buffer;
-#else
-      Module['buffer'] = e.data.buffer;
+
+      {{{ makeAsmGlobalAccessInPthread('buffer') }}} = {{{ makeAsmGlobalAccessInPthread('wasmMemory') }}}.buffer;
+#else // asm.js:
+      {{{ makeAsmGlobalAccessInPthread('buffer') }}} = e.data.buffer;
 
 #if SEPARATE_ASM
       // load the separated-out asm.js
@@ -113,7 +134,9 @@ this.onmessage = function(e) {
 
 #endif
 
+#if !MINIMAL_RUNTIME
       Module['ENVIRONMENT_IS_PTHREAD'] = true;
+#endif
 
 #if MODULARIZE && EXPORT_ES6
       import(e.data.urlOrBlob).then(function({{{ EXPORT_NAME }}}) {
@@ -131,11 +154,24 @@ this.onmessage = function(e) {
         URL.revokeObjectURL(objectUrl);
       }
 #if MODULARIZE && !MODULARIZE_INSTANCE
+#if MINIMAL_RUNTIME
+      Module = {{{ EXPORT_NAME }}}(imports);
+#else
       Module = {{{ EXPORT_NAME }}}(Module);
 #endif
+#endif
+#if !MINIMAL_RUNTIME
       PThread = Module['PThread'];
       HEAPU32 = Module['HEAPU32'];
-      postMessage({ cmd: 'loaded' });
+#endif
+
+#if MINIMAL_RUNTIME && WASM
+      Module['wasmInstance'].then(() => {
+#endif
+        postMessage({ cmd: 'loaded' });
+#if MINIMAL_RUNTIME && WASM
+      });
+#endif
 #endif
     } else if (e.data.cmd === 'objectTransfer') {
       PThread.receiveObjectTransfer(e.data);
@@ -152,7 +188,10 @@ this.onmessage = function(e) {
       // (+/- 0.1msecs in testing).
       Module['__performance_now_clock_drift'] = performance.now() - e.data.time;
       threadInfoStruct = e.data.threadInfoStruct;
-      Module['__register_pthread_ptr'](threadInfoStruct, /*isMainBrowserThread=*/0, /*isMainRuntimeThread=*/0); // Pass the thread address inside the asm.js scope to store it for fast access that avoids the need for a FFI out.
+
+      // Pass the thread address inside the asm.js scope to store it for fast access that avoids the need for a FFI out.
+      {{{ makeAsmGlobalAccessInPthread('__register_pthread_ptr') }}}(threadInfoStruct, /*isMainBrowserThread=*/0, /*isMainRuntimeThread=*/0);
+
       selfThreadId = e.data.selfThreadId;
       parentThreadId = e.data.parentThreadId;
       // Establish the stack frame for this thread in global scope
@@ -169,7 +208,7 @@ this.onmessage = function(e) {
       assert(selfThreadId);
       assert(parentThreadId);
       assert(top != 0);
-      assert(e.data.stackSize > 0);
+      assert(max != 0);
 #if WASM_BACKEND
       assert(top > max);
 #else
@@ -179,10 +218,14 @@ this.onmessage = function(e) {
       // Also call inside JS module to set up the stack frame for this pthread in JS module scope
       Module['establishStackSpaceInJsModule'](top, max);
 #if WASM_BACKEND
-      Module['_emscripten_tls_init']();
+      {{{ makeAsmGlobalAccessInPthread('_emscripten_tls_init') }}}();
 #endif
+#if STACK_OVERFLOW_CHECK
+      {{{ makeAsmGlobalAccessInPthread('writeStackCookie') }}}();
+#endif
+
       PThread.receiveObjectTransfer(e.data);
-      PThread.setThreadStatus(Module['_pthread_self'](), 1/*EM_THREAD_STATUS_RUNNING*/);
+      PThread.setThreadStatus({{{ makeAsmGlobalAccessInPthread('_pthread_self') }}}(), 1/*EM_THREAD_STATUS_RUNNING*/);
 
       try {
         // pthread entry points are always of signature 'void *ThreadMain(void *arg)'
@@ -192,10 +235,10 @@ this.onmessage = function(e) {
         // enable that to work. If you find the following line to crash, either change the signature
         // to "proper" void *ThreadMain(void *arg) form, or try linking with the Emscripten linker
         // flag -s EMULATE_FUNCTION_POINTER_CASTS=1 to add in emulation for this x86 ABI extension.
-        var result = Module['dynCall_ii'](e.data.start_routine, e.data.arg);
+        var result = {{{ makeAsmGlobalAccessInPthread('dynCall_ii') }}}(e.data.start_routine, e.data.arg);
 
 #if STACK_OVERFLOW_CHECK
-        Module['checkStackCookie']();
+        {{{ makeAsmGlobalAccessInPthread('checkStackCookie') }}}();
 #endif
         // The thread might have finished without calling pthread_exit(). If so, then perform the exit operation ourselves.
         // (This is a no-op if explicit pthread_exit() had been called prior.)
@@ -204,7 +247,13 @@ this.onmessage = function(e) {
         if (ex === 'Canceled!') {
           PThread.threadCancel();
         } else if (ex != 'unwind') {
+#if MINIMAL_RUNTIME
+          // ExitStatus not present in MINIMAL_RUNTIME
+          Atomics.store(HEAPU32, (threadInfoStruct + 4 /*C_STRUCTS.pthread.threadExitCode*/ ) >> 2, -2 /*A custom entry specific to Emscripten denoting that the thread crashed.*/);
+#else
           Atomics.store(HEAPU32, (threadInfoStruct + 4 /*C_STRUCTS.pthread.threadExitCode*/ ) >> 2, (ex instanceof Module['ExitStatus']) ? ex.status : -2 /*A custom entry specific to Emscripten denoting that the thread crashed.*/);
+#endif
+
           Atomics.store(HEAPU32, (threadInfoStruct + 0 /*C_STRUCTS.pthread.threadStatus*/ ) >> 2, 1); // Mark the thread as no longer running.
 #if ASSERTIONS
           if (typeof(Module['_emscripten_futex_wake']) !== "function") {
@@ -213,11 +262,16 @@ this.onmessage = function(e) {
           }
 #endif
           Module['_emscripten_futex_wake'](threadInfoStruct + 0 /*C_STRUCTS.pthread.threadStatus*/, 0x7FFFFFFF/*INT_MAX*/); // Wake all threads waiting on this thread to finish.
+#if MINIMAL_RUNTIME
+          throw e; // ExitStatus not present in MINIMAL_RUNTIME
+#else
           if (!(ex instanceof Module['ExitStatus'])) throw ex;
+#endif
 #if ASSERTIONS
         } else {
           // else e == 'unwind', and we should fall through here and keep the pthread alive for asynchronous events.
           out('Pthread 0x' + threadInfoStruct.toString(16) + ' completed its pthread main entry point with an unwind, keeping the pthread worker alive for asynchronous operation.');
+#endif
 #endif
         }
       }
diff --git a/tests/pthread/call_async_on_main_thread.js b/tests/pthread/call_async_on_main_thread.js
index f70198dc5ddd7..aa9eb5c55f186 100644
--- a/tests/pthread/call_async_on_main_thread.js
+++ b/tests/pthread/call_async_on_main_thread.js
@@ -3,7 +3,7 @@ mergeInto(LibraryManager.library, {
   report_result__proxy: 'async',
   report_result__sig: 'viii',
   report_result: function(param1, param2, param3) {
-    if (ENVIRONMENT_IS_WORKER) {
+    if (typeof ENVIRONMENT_IS_WORKER !== 'undefined' && ENVIRONMENT_IS_WORKER) {
       console.error('This function should be getting called on the main thread!');
     }
     console.log('got ' + param1 + ' ' + param2 + ' ' + param3);
diff --git a/tests/pthread/test_pthread_run_script.cpp b/tests/pthread/test_pthread_run_script.cpp
index 83bde387b5b0b..c67f4c0abf694 100644
--- a/tests/pthread/test_pthread_run_script.cpp
+++ b/tests/pthread/test_pthread_run_script.cpp
@@ -20,9 +20,9 @@ void TestAsyncRunScript()
 {
   // 5. Test emscripten_async_run_script() runs in a pthread.
 #if __EMSCRIPTEN_PTHREADS__
-  emscripten_async_run_script("Module['_FinishTest'](ENVIRONMENT_IS_PTHREAD && ENVIRONMENT_IS_WORKER);", 1);
+  emscripten_async_run_script("Module['_FinishTest'](ENVIRONMENT_IS_PTHREAD && (typeof ENVIRONMENT_IS_WORKER !== 'undefined' && ENVIRONMENT_IS_WORKER));", 1);
 #else
-  emscripten_async_run_script("Module['_FinishTest'](!ENVIRONMENT_IS_WORKER);", 1);
+  emscripten_async_run_script("Module['_FinishTest'](!(typeof ENVIRONMENT_IS_WORKER !== 'undefined' && ENVIRONMENT_IS_WORKER));", 1);
 #endif
 }
 
@@ -42,14 +42,14 @@ int main() {
 
   // 1. Test that emscripten_run_script() works in a pthread, and it gets executed in the web worker and not on the main thread.
 #if __EMSCRIPTEN_PTHREADS__
-  emscripten_run_script("Module['ranScript'] = ENVIRONMENT_IS_PTHREAD && ENVIRONMENT_IS_WORKER;");
+  emscripten_run_script("Module['ranScript'] = ENVIRONMENT_IS_PTHREAD && (typeof ENVIRONMENT_IS_WORKER !== 'undefined' && ENVIRONMENT_IS_WORKER);");
 #else
   emscripten_run_script("Module['ranScript'] = true;");
 #endif
 
   // 2. Test that emscripten_run_script_int() works in a pthread and it gets executed in the web worker and not on the main thread.
 #if __EMSCRIPTEN_PTHREADS__
-  int result = emscripten_run_script_int("Module['ranScript'] && ENVIRONMENT_IS_PTHREAD && ENVIRONMENT_IS_WORKER;");
+  int result = emscripten_run_script_int("Module['ranScript'] && ENVIRONMENT_IS_PTHREAD && (typeof ENVIRONMENT_IS_WORKER !== 'undefined' && ENVIRONMENT_IS_WORKER);");
 #else
   int result = emscripten_run_script_int("Module['ranScript'];");
 #endif
@@ -58,11 +58,11 @@ int main() {
 
   // 3. Test emscripten_run_script_string() runs in a pthread.
 #if __EMSCRIPTEN_PTHREADS__
-  char *data = emscripten_run_script_string("ENVIRONMENT_IS_PTHREAD && ENVIRONMENT_IS_WORKER ? 'in pthread' : 'not in pthread';");
+  char *data = emscripten_run_script_string("ENVIRONMENT_IS_PTHREAD && (typeof ENVIRONMENT_IS_WORKER !== 'undefined' && ENVIRONMENT_IS_WORKER) ? 'in pthread' : 'not in pthread';");
   printf("%s\n", data);
   assert(!strcmp(data, "in pthread"));
 #else
-  char *data = emscripten_run_script_string("ENVIRONMENT_IS_WORKER ? 'in worker' : 'not in worker';");
+  char *data = emscripten_run_script_string("(typeof ENVIRONMENT_IS_WORKER !== 'undefined' && ENVIRONMENT_IS_WORKER) ? 'in worker' : 'not in worker';");
   printf("%s\n", data);
   assert(!strcmp(data, "not in worker"));
 #endif
diff --git a/tools/minimal_runtime_shell.py b/tools/minimal_runtime_shell.py
index f7831f435931f..8bfa2d43c77dd 100644
--- a/tools/minimal_runtime_shell.py
+++ b/tools/minimal_runtime_shell.py
@@ -62,6 +62,9 @@ def generate_minimal_runtime_load_statement(target_basename):
     if download_wasm:
       files_to_load += [download_wasm]
 
+  if shared.Settings.MODULARIZE and shared.Settings.USE_PTHREADS:
+    modularize_imports += ["worker: '{{{ PTHREAD_WORKER_FILE }}}'"]
+
   # Download Wasm2JS code if target browser does not support WebAssembly
   if shared.Settings.WASM == 2:
     if shared.Settings.MODULARIZE:
@@ -132,9 +135,14 @@ def generate_minimal_runtime_load_statement(target_basename):
     # script load from direct script() load to a binary() load so we can still
     # immediately start the download, but can control when we add the script to the
     # DOM.
+    if shared.Settings.USE_PTHREADS:
+      script_load = "script(url)";
+    else:
+      script_load = "script(url).then(() => { URL.revokeObjectURL(url) });";
+
     files_to_load[0] = "binary('%s')" % (target_basename + '.js')
     then_statements += ["var url = URL.createObjectURL(new Blob([r[0]], { type: 'application/javascript' }));",
-                        "script(url).then(() => { URL.revokeObjectURL(url) });"]
+                        script_load]
 
   # Add in binary() XHR loader if used:
   if any("binary(" in s for s in files_to_load + then_statements):
@@ -171,6 +179,7 @@ def generate_minimal_runtime_html(target, options, js_target, target_basename,
 
   shell = shell.replace('{{{ TARGET_BASENAME }}}', target_basename)
   shell = shell.replace('{{{ EXPORT_NAME }}}', shared.Settings.EXPORT_NAME)
+  shell = shell.replace('{{{ PTHREAD_WORKER_FILE }}}', shared.Settings.PTHREAD_WORKER_FILE)
 
   # In SINGLE_FILE build, embed the main .js file into the .html output
   if shared.Settings.SINGLE_FILE:

From 4a787fe448d34f2c99f68ea535e07c87c91706c0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Sun, 29 Dec 2019 16:01:11 +0200
Subject: [PATCH 02/27] Multithreaded MINIMAL_RUNTIME builds working with
 MODULARIZE.

---
 emcc.py               |  5 +++--
 emscripten.py         |  8 +++++++-
 src/parseTools.js     | 20 ++++++++++++++++++--
 src/worker.js         | 39 ++++++++++++++++++++++-----------------
 tests/test_browser.py |  5 +++++
 5 files changed, 55 insertions(+), 22 deletions(-)

diff --git a/emcc.py b/emcc.py
index a5aad7639453c..94cc2374621cf 100755
--- a/emcc.py
+++ b/emcc.py
@@ -3332,8 +3332,9 @@ def modularize():
   logger.debug('Modularizing, assigning to var ' + shared.Settings.EXPORT_NAME)
   src = open(final).read()
 
-  # TODO: exports object generation for MINIMAL_RUNTIME
-  exports_object = '{}' if shared.Settings.MINIMAL_RUNTIME else shared.Settings.EXPORT_NAME
+  # TODO: exports object generation for MINIMAL_RUNTIME. As a temp measure, multithreaded MINIMAL_RUNTIME builds export like regular
+  # runtime does, so that worker.js can see the JS module contents.
+  exports_object = '{}' if shared.Settings.MINIMAL_RUNTIME and not shared.Settings.USE_PTHREADS else shared.Settings.EXPORT_NAME
 
   src = '''
 function(%(EXPORT_NAME)s) {
diff --git a/emscripten.py b/emscripten.py
index 53b14d6297368..4ed3a48a653c5 100644
--- a/emscripten.py
+++ b/emscripten.py
@@ -2645,7 +2645,13 @@ def create_receiving_wasm(exports, initializers):
         # In wasm2js exports can be directly processed at top level, i.e.
         # var asm = Module["asm"](asmGlobalArg, asmLibraryArg, buffer);
         # var _main = asm["_main"];
-        receiving += ['var ' + asmjs_mangle(s) + ' = asm["' + asmjs_mangle(s) + '"];' for s in exports_that_are_not_initializers]
+        if shared.Settings.USE_PTHREADS and shared.Settings.MODULARIZE:
+          # TODO: As a temp solution, multithreaded MODULARIZEd MINIMAL_RUNTIME builds export all symbols like regular runtime does.
+          # Fix this by migrating worker.js code to reside inside the Module so it is in the same scope as the rest of the JS code, or
+          # by defining an export syntax to MINIMAL_RUNTIME that multithreaded MODULARIZEd builds can export on.
+          receiving += [asmjs_mangle(s) + ' = Module["' + asmjs_mangle(s) + '"] = asm["' + s + '"];' for s in exports_that_are_not_initializers]
+        else:
+          receiving += ['var ' + asmjs_mangle(s) + ' = asm["' + asmjs_mangle(s) + '"];' for s in exports_that_are_not_initializers]
       else:
         receiving += ['var ' + asmjs_mangle(s) + ' = Module["' + asmjs_mangle(s) + '"] = asm["' + s + '"];' for s in exports]
   else:
diff --git a/src/parseTools.js b/src/parseTools.js
index 12d8acad0c24e..63248e41988c3 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -1659,12 +1659,28 @@ function buildStringArray(array) {
   }
 }
 
-// Generates access to a JS global scope variable in pthreads worker.js. In MODULARIZE mode the JS scope is not directly accessible, so all the relevant variables
+// Generates access to a JS exports scope variable in pthreads worker.js. In MODULARIZE mode the JS scope is not directly accessible, so all the relevant variables
 // are exported via Module. In non-MODULARIZE mode, we can directly access the variables in global scope.
-function makeAsmGlobalAccessInPthread(variable) {
+function makeAsmExportsAccessInPthread(variable) {
   if (MODULARIZE || !MINIMAL_RUNTIME) {
     return "Module['" + variable + "']"; // 'Module' is defined in worker.js local scope, so not EXPORT_NAME in this case.
   } else {
     return variable;
   }
 }
+
+// Generates access to a JS imports scope variable in pthreads worker.js. In MODULARIZE mode these flow into the imports object for the Module.
+// In non-MODULARIZE mode, we can directly access the variables in global scope.
+function makeAsmImportsAccessInPthread(variable) {
+  if (!MINIMAL_RUNTIME) {
+    // Regular runtime uses the name "Module" for both imports and exports.
+    return "Module['" + variable + "']";
+  }
+  if (MODULARIZE) {
+    // MINIMAL_RUNTIME uses 'imports' as the name for the imports object in MODULARIZE builds.
+    return "imports['" + variable + "']";
+  } else {
+    // In non-MODULARIZE builds, can access the imports from global scope.
+    return variable;
+  }
+}
diff --git a/src/worker.js b/src/worker.js
index 7ab21ec1e51ac..876ad70a2869f 100644
--- a/src/worker.js
+++ b/src/worker.js
@@ -83,6 +83,10 @@ var wasmOffsetData;
 this.onmessage = function(e) {
   try {
     if (e.data.cmd === 'load') { // Preload command that is called once per worker to parse and load the Emscripten code.
+#if MINIMAL_RUNTIME && MODULARIZE
+      var imports = {};
+#endif
+
 #if !WASM_BACKEND
       // Initialize the thread-local field(s):
 #if MINIMAL_RUNTIME
@@ -96,18 +100,22 @@ this.onmessage = function(e) {
 #endif
 
 #if USES_DYNAMIC_ALLOC
-      {{{ makeAsmGlobalAccessInPthread('DYNAMICTOP_PTR') }}} = e.data.DYNAMICTOP_PTR;
+      {{{ makeAsmImportsAccessInPthread('DYNAMICTOP_PTR') }}} = e.data.DYNAMICTOP_PTR;
 #endif
 
 #if WASM
       // Module and memory were sent from main thread
 #if MINIMAL_RUNTIME
-      Module['wasm'] = e.data.wasmModule;
+#if MODULARIZE
+      imports['wasm'] = e.data.wasmModule; // Pass the shared Wasm module in an imports object for the MODULARIZEd build.
+#else
+      Module['wasm'] = e.data.wasmModule; // Pass the shared Wasm module in the Module object for MINIMAL_RUNTIME.
+#endif
 #else
       Module['wasmModule'] = e.data.wasmModule;
 #endif
 
-      {{{ makeAsmGlobalAccessInPthread('wasmMemory') }}} = e.data.wasmMemory;
+      {{{ makeAsmImportsAccessInPthread('wasmMemory') }}} = e.data.wasmMemory;
 
 #if LOAD_SOURCE_MAP
       wasmSourceMapData = e.data.wasmSourceMap;
@@ -116,9 +124,9 @@ this.onmessage = function(e) {
       wasmOffsetData = e.data.wasmOffsetConverter;
 #endif
 
-      {{{ makeAsmGlobalAccessInPthread('buffer') }}} = {{{ makeAsmGlobalAccessInPthread('wasmMemory') }}}.buffer;
+      {{{ makeAsmImportsAccessInPthread('buffer') }}} = {{{ makeAsmImportsAccessInPthread('wasmMemory') }}}.buffer;
 #else // asm.js:
-      {{{ makeAsmGlobalAccessInPthread('buffer') }}} = e.data.buffer;
+      {{{ makeAsmImportsAccessInPthread('buffer') }}} = e.data.buffer;
 
 #if SEPARATE_ASM
       // load the separated-out asm.js
@@ -134,15 +142,13 @@ this.onmessage = function(e) {
 
 #endif
 
-#if !MINIMAL_RUNTIME
-      Module['ENVIRONMENT_IS_PTHREAD'] = true;
+#if !MINIMAL_RUNTIME || MODULARIZE
+      {{{ makeAsmImportsAccessInPthread('ENVIRONMENT_IS_PTHREAD') }}} = true;
 #endif
 
 #if MODULARIZE && EXPORT_ES6
       import(e.data.urlOrBlob).then(function({{{ EXPORT_NAME }}}) {
         Module = {{{ EXPORT_NAME }}}.default(Module);
-        PThread = Module['PThread'];
-        HEAPU32 = Module['HEAPU32'];
         postMessage({ cmd: 'loaded' });
       });
 #else
@@ -160,7 +166,7 @@ this.onmessage = function(e) {
       Module = {{{ EXPORT_NAME }}}(Module);
 #endif
 #endif
-#if !MINIMAL_RUNTIME
+#if !MINIMAL_RUNTIME || MODULARIZE
       PThread = Module['PThread'];
       HEAPU32 = Module['HEAPU32'];
 #endif
@@ -190,7 +196,7 @@ this.onmessage = function(e) {
       threadInfoStruct = e.data.threadInfoStruct;
 
       // Pass the thread address inside the asm.js scope to store it for fast access that avoids the need for a FFI out.
-      {{{ makeAsmGlobalAccessInPthread('__register_pthread_ptr') }}}(threadInfoStruct, /*isMainBrowserThread=*/0, /*isMainRuntimeThread=*/0);
+      {{{ makeAsmExportsAccessInPthread('__register_pthread_ptr') }}}(threadInfoStruct, /*isMainBrowserThread=*/0, /*isMainRuntimeThread=*/0);
 
       selfThreadId = e.data.selfThreadId;
       parentThreadId = e.data.parentThreadId;
@@ -218,14 +224,14 @@ this.onmessage = function(e) {
       // Also call inside JS module to set up the stack frame for this pthread in JS module scope
       Module['establishStackSpaceInJsModule'](top, max);
 #if WASM_BACKEND
-      {{{ makeAsmGlobalAccessInPthread('_emscripten_tls_init') }}}();
+      {{{ makeAsmExportsAccessInPthread('_emscripten_tls_init') }}}();
 #endif
 #if STACK_OVERFLOW_CHECK
-      {{{ makeAsmGlobalAccessInPthread('writeStackCookie') }}}();
+      {{{ makeAsmExportsAccessInPthread('writeStackCookie') }}}();
 #endif
 
       PThread.receiveObjectTransfer(e.data);
-      PThread.setThreadStatus({{{ makeAsmGlobalAccessInPthread('_pthread_self') }}}(), 1/*EM_THREAD_STATUS_RUNNING*/);
+      PThread.setThreadStatus({{{ makeAsmExportsAccessInPthread('_pthread_self') }}}(), 1/*EM_THREAD_STATUS_RUNNING*/);
 
       try {
         // pthread entry points are always of signature 'void *ThreadMain(void *arg)'
@@ -235,10 +241,10 @@ this.onmessage = function(e) {
         // enable that to work. If you find the following line to crash, either change the signature
         // to "proper" void *ThreadMain(void *arg) form, or try linking with the Emscripten linker
         // flag -s EMULATE_FUNCTION_POINTER_CASTS=1 to add in emulation for this x86 ABI extension.
-        var result = {{{ makeAsmGlobalAccessInPthread('dynCall_ii') }}}(e.data.start_routine, e.data.arg);
+        var result = {{{ makeAsmExportsAccessInPthread('dynCall_ii') }}}(e.data.start_routine, e.data.arg);
 
 #if STACK_OVERFLOW_CHECK
-        {{{ makeAsmGlobalAccessInPthread('checkStackCookie') }}}();
+        {{{ makeAsmExportsAccessInPthread('checkStackCookie') }}}();
 #endif
         // The thread might have finished without calling pthread_exit(). If so, then perform the exit operation ourselves.
         // (This is a no-op if explicit pthread_exit() had been called prior.)
@@ -271,7 +277,6 @@ this.onmessage = function(e) {
         } else {
           // else e == 'unwind', and we should fall through here and keep the pthread alive for asynchronous events.
           out('Pthread 0x' + threadInfoStruct.toString(16) + ' completed its pthread main entry point with an unwind, keeping the pthread worker alive for asynchronous operation.');
-#endif
 #endif
         }
       }
diff --git a/tests/test_browser.py b/tests/test_browser.py
index c8d42dc61026e..c9d3ccc3f5125 100644
--- a/tests/test_browser.py
+++ b/tests/test_browser.py
@@ -4926,6 +4926,11 @@ def test_minimal_runtime_hello_world(self):
     for args in [[], ['-s', 'MINIMAL_RUNTIME_STREAMING_WASM_COMPILATION=1', '--closure', '1'], ['-s', 'MINIMAL_RUNTIME_STREAMING_WASM_INSTANTIATION=1', '--closure', '1']]:
       self.btest(path_from_root('tests', 'small_hello_world.c'), '0', args=args + ['-s', 'MINIMAL_RUNTIME=1'])
 
+  # Tests that a pthreads build of -s MINIMAL_RUNTIME=1 works well in different build modes
+  def test_minimal_runtime_hello_pthread(self):
+    for args in [[], ['-s', 'MODULARIZE=1']]:
+      self.btest(path_from_root('tests', 'pthread', 'hello_thread.c'), '1', args=args + ['-s', 'MINIMAL_RUNTIME=1', '-s', 'USE_PTHREADS=1'])
+
   @requires_threads
   @no_fastcomp('offset converter is not supported on fastcomp')
   def test_offset_converter(self, *args):

From 4b8db00c5da15b7bd4f93b527bc5402eac5ef7d9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Wed, 5 Feb 2020 14:43:25 +0200
Subject: [PATCH 03/27] Fix up MINIMAL_RUNTIME pthreads

---
 emscripten.py            | 16 ++++++++--------
 src/library_pthread.js   | 10 +++-------
 src/modules.js           |  6 +++---
 src/postamble_minimal.js | 11 ++++++++++-
 src/preamble_minimal.js  | 12 ++++--------
 tests/test_browser.py    |  1 +
 6 files changed, 29 insertions(+), 27 deletions(-)

diff --git a/emscripten.py b/emscripten.py
index 4ed3a48a653c5..dff838a61f3f8 100644
--- a/emscripten.py
+++ b/emscripten.py
@@ -943,8 +943,8 @@ def get_exported_implemented_functions(all_exported_functions, all_implemented,
     funcs.append('_emscripten_replace_memory')
   if not shared.Settings.SIDE_MODULE and not shared.Settings.MINIMAL_RUNTIME:
     funcs += ['stackAlloc', 'stackSave', 'stackRestore']
-    if shared.Settings.USE_PTHREADS:
-      funcs += ['establishStackSpace']
+  if shared.Settings.USE_PTHREADS:
+    funcs += ['establishStackSpace']
 
   if shared.Settings.EMTERPRETIFY:
     funcs += ['emterpret']
@@ -1675,8 +1675,8 @@ def create_asm_runtime_funcs():
   funcs = []
   if not (shared.Settings.WASM and shared.Settings.SIDE_MODULE) and not shared.Settings.MINIMAL_RUNTIME:
     funcs += ['stackAlloc', 'stackSave', 'stackRestore']
-    if shared.Settings.USE_PTHREADS:
-      funcs += ['establishStackSpace']
+  if shared.Settings.USE_PTHREADS:
+    funcs += ['establishStackSpace']
   return funcs
 
 
@@ -1887,6 +1887,10 @@ def create_runtime_funcs_asmjs(exports, metadata):
 }
 ''' % stack_check]
 
+  if shared.Settings.MINIMAL_RUNTIME:
+    # MINIMAL_RUNTIME moves stack functions to library.
+    funcs = []
+
   if shared.Settings.USE_PTHREADS:
     funcs.append('''
 function establishStackSpace(stackBase, stackMax) {
@@ -1899,10 +1903,6 @@ def create_runtime_funcs_asmjs(exports, metadata):
 }
 ''')
 
-  if shared.Settings.MINIMAL_RUNTIME:
-    # MINIMAL_RUNTIME moves stack functions to library.
-    funcs = []
-
   if shared.Settings.EMTERPRETIFY:
     funcs.append('''
 function emterpret(pc) { // this will be replaced when the emterpreter code is generated; adding it here allows validation until then
diff --git a/src/library_pthread.js b/src/library_pthread.js
index a20276efd0ff6..59d13dd10b993 100644
--- a/src/library_pthread.js
+++ b/src/library_pthread.js
@@ -374,8 +374,8 @@ var LibraryPThread = {
 #endif
 
 #if ASSERTIONS && WASM
-      assert(wasmMemory, 'WebAssembly memory should have been loaded by now!');
-      assert(wasmModule, 'WebAssembly Module should have been loaded by now!');
+      assert(wasmMemory instanceof WebAssembly.Memory, 'WebAssembly memory should have been loaded by now!');
+      assert(wasmModule instanceof WebAssembly.Module, 'WebAssembly Module should have been loaded by now!');
 #endif
 
       // Ask the new worker to load up the Emscripten-compiled page. This is a heavy operation.
@@ -389,11 +389,7 @@ var LibraryPThread = {
         'urlOrBlob': Module['mainScriptUrlOrBlob'] || _scriptDir,
 #if WASM
         'wasmMemory': wasmMemory,
-#if MINIMAL_RUNTIME
-        wasmModule: Module['wasm'],
-#else
-        wasmModule: wasmModule,
-#endif
+        'wasmModule': wasmModule,
 #if LOAD_SOURCE_MAP
         'wasmSourceMap': wasmSourceMap,
 #endif
diff --git a/src/modules.js b/src/modules.js
index 0f7caf645a9ce..cb31f244a8ece 100644
--- a/src/modules.js
+++ b/src/modules.js
@@ -459,9 +459,9 @@ function exportRuntime() {
       'allocateUTF8OnStack'
     ]);
 
-    if (USE_PTHREADS) {
-      runtimeElements.push('establishStackSpace');
-    }
+  }
+  if (USE_PTHREADS) {
+    runtimeElements.push('establishStackSpace');
   }
 
   if (STACK_OVERFLOW_CHECK) {
diff --git a/src/postamble_minimal.js b/src/postamble_minimal.js
index b6bb17e0161c4..764d7ac0555fd 100644
--- a/src/postamble_minimal.js
+++ b/src/postamble_minimal.js
@@ -92,6 +92,10 @@ var imports = {
 var asm;
 #endif
 
+#if USE_PTHREADS && WASM
+var wasmModule;
+#endif
+
 #if DECLARE_ASM_MODULE_EXPORTS
 /*** ASM_MODULE_EXPORTS_DECLARES ***/
 #endif
@@ -125,6 +129,11 @@ Module['wasmInstance'] =
 WebAssembly.instantiate(Module['wasm'], imports).then(function(output) {
 #endif
 
+#if USE_PTHREADS
+  // Export Wasm module for pthread creation to access.
+  wasmModule = output.module || Module['wasm'];
+#endif
+
 #if !(LibraryManager.has('library_exports.js') && (WASM || WASM_BACKEND))
   // If not using the emscripten_get_exported_function() API, keep the 'asm' exports
   // variable in local scope to this instantiate function. (otherwise access it without
@@ -144,7 +153,7 @@ WebAssembly.instantiate(Module['wasm'], imports).then(function(output) {
 #if MIN_FIREFOX_VERSION < 58 || MIN_CHROME_VERSION < 61 || ENVIRONMENT_MAY_BE_NODE || MIN_SAFARI_VERSION != TARGET_NOT_SUPPORTED || USE_PTHREADS
   // In pthreads, Module['wasm'] is an already compiled WebAssembly.Module. In that case, 'output' is a WebAssembly.Instance.
   // In main thread, Module['wasm'] is either a typed array or a fetch stream. In that case, 'output.instance' is the WebAssembly.Instance.
-  var asm = (output.instance || output).exports;
+  asm = (output.instance || output).exports;
 #else
   asm = output.exports;
 #endif
diff --git a/src/preamble_minimal.js b/src/preamble_minimal.js
index 66254379f1152..ad52633caf3ad 100644
--- a/src/preamble_minimal.js
+++ b/src/preamble_minimal.js
@@ -173,21 +173,17 @@ var HEAPF32 = new Float32Array(buffer);
 var HEAPF64 = new Float64Array(buffer);
 #endif
 
-#if MEM_INIT_METHOD == 1 && !MEM_INIT_IN_WASM && !SINGLE_FILE
-
-#if USE_PTHREADS
+#if USE_PTHREADS && ((MEM_INIT_METHOD == 1 && !MEM_INIT_IN_WASM && !SINGLE_FILE) || (SINGLE_FILE && !WASM && !WASM_BACKEND) || USES_DYNAMIC_ALLOC)
 if (!ENVIRONMENT_IS_PTHREAD) {
 #endif
 
+#if MEM_INIT_METHOD == 1 && !MEM_INIT_IN_WASM && !SINGLE_FILE
+
 #if ASSERTIONS
 if (!Module['mem']) throw 'Must load memory initializer as an ArrayBuffer in to variable Module.mem before adding compiled output .js script to the DOM';
 #endif
 HEAPU8.set(new Uint8Array(Module['mem']), GLOBAL_BASE);
 
-#if USE_PTHREADS
-}
-#endif
-
 #endif
 
 #if SINGLE_FILE && !WASM && !WASM_BACKEND
@@ -199,7 +195,7 @@ HEAPU8.set(base64Decode('{{{ getQuoted("BASE64_MEMORY_INITIALIZER") }}}'), GLOBA
   HEAP32[DYNAMICTOP_PTR>>2] = {{{ getQuoted('DYNAMIC_BASE') }}};
 #endif
 
-#if USE_PTHREADS
+#if USE_PTHREADS && ((MEM_INIT_METHOD == 1 && !MEM_INIT_IN_WASM && !SINGLE_FILE) || (SINGLE_FILE && !WASM && !WASM_BACKEND) || USES_DYNAMIC_ALLOC)
 }
 #endif
 
diff --git a/tests/test_browser.py b/tests/test_browser.py
index c9d3ccc3f5125..174fc53dcf416 100644
--- a/tests/test_browser.py
+++ b/tests/test_browser.py
@@ -3701,6 +3701,7 @@ def test(args):
     test([])
     test(['-O3'])
     test(['-s', 'MODULARIZE_INSTANCE=1'])
+    test(['-s', 'MINIMAL_RUNTIME=1'])
 
   # Test that preallocating worker threads work.
   @requires_threads

From f8e47fe7554776bdc3848a050c4640e694e72184 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Wed, 5 Feb 2020 17:02:07 +0200
Subject: [PATCH 04/27] Pthreads fixes in MINIMAL_RUNTIME.

---
 src/library_pthread.js   |  4 +++-
 src/postamble_minimal.js | 33 +++++++++++++++++++++++++++------
 2 files changed, 30 insertions(+), 7 deletions(-)

diff --git a/src/library_pthread.js b/src/library_pthread.js
index 59d13dd10b993..b5b74ec7aa39f 100644
--- a/src/library_pthread.js
+++ b/src/library_pthread.js
@@ -29,7 +29,9 @@ var LibraryPThread = {
       _emscripten_register_main_browser_thread_id(PThread.mainThreadBlock);
     },
     initMainThreadBlock: function() {
-      if (ENVIRONMENT_IS_PTHREAD) return;
+#if ASSERTIONS
+      assert(!ENVIRONMENT_IS_PTHREAD);
+#endif
 
 #if PTHREAD_POOL_SIZE
       var pthreadPoolSize = {{{ PTHREAD_POOL_SIZE }}};
diff --git a/src/postamble_minimal.js b/src/postamble_minimal.js
index 764d7ac0555fd..d43d991b67b45 100644
--- a/src/postamble_minimal.js
+++ b/src/postamble_minimal.js
@@ -94,6 +94,21 @@ var asm;
 
 #if USE_PTHREADS && WASM
 var wasmModule;
+#if PTHREAD_POOL_SIZE > 0
+function loadWasmModuleToWorkers() {
+#if PTHREAD_POOL_DELAY_LOAD
+  PThread.unusedWorkers.forEach(PThread.loadWasmModuleToWorker);
+#else
+  var numWorkersToLoad = PThread.unusedWorkers.length;
+  PThread.unusedWorkers.forEach(function(w) { PThread.loadWasmModuleToWorker(w, function() {
+    // PTHREAD_POOL_DELAY_LOAD==0: we wanted to synchronously wait until the Worker pool
+    // has loaded up. If all Workers have finished loading up the Wasm Module, proceed with main()
+    if (!--numWorkersToLoad) ready();
+  })});
+#endif
+}
+#endif
+
 #endif
 
 #if DECLARE_ASM_MODULE_EXPORTS
@@ -170,9 +185,12 @@ WebAssembly.instantiate(Module['wasm'], imports).then(function(output) {
 #endif
 
   initRuntime(asm);
-#if PTHREAD_POOL_SIZE
-  if (!ENVIRONMENT_IS_PTHREAD) PThread.allocateUnusedWorkers({{{PTHREAD_POOL_SIZE}}}, ready);
-  else ready();
+#if USE_PTHREADS && PTHREAD_POOL_SIZE
+  if (!ENVIRONMENT_IS_PTHREAD) loadWasmModuleToWorkers();
+#if !PTHREAD_POOL_DELAY_LOAD  
+  else
+#endif
+    ready();
 #else
   ready();
 #endif
@@ -189,9 +207,12 @@ WebAssembly.instantiate(Module['wasm'], imports).then(function(output) {
 // Initialize asm.js (synchronous)
 initRuntime(asm);
 
-#if PTHREAD_POOL_SIZE
-if (!ENVIRONMENT_IS_PTHREAD) PThread.allocateUnusedWorkers({{{PTHREAD_POOL_SIZE}}}, ready);
-else ready();
+#if USE_PTHREADS && PTHREAD_POOL_SIZE
+if (!ENVIRONMENT_IS_PTHREAD) loadWasmModuleToWorkers();
+#if !PTHREAD_POOL_DELAY_LOAD  
+else
+#endif
+  ready();
 #else
 ready();
 #endif

From fa9759a6de909d70da414e2c6684402a2a059900 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Wed, 5 Feb 2020 17:03:03 +0200
Subject: [PATCH 05/27] MINIMAL_RUNTIME fixes to pthreads.

---
 emcc.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/emcc.py b/emcc.py
index 94cc2374621cf..6a2d772d12a05 100755
--- a/emcc.py
+++ b/emcc.py
@@ -1528,10 +1528,11 @@ def is_supported_link_flag(f):
       ]
 
     if shared.Settings.USE_PTHREADS:
-      shared.Settings.EXPORTED_RUNTIME_METHODS += ['establishStackSpace']
+      if not shared.Settings.MINIMAL_RUNTIME:
+        shared.Settings.EXPORTED_RUNTIME_METHODS += ['establishStackSpace']
 
       # memalign is used to ensure allocated thread stacks are aligned.
-      shared.Settings.EXPORTED_FUNCTIONS += ['_memalign']
+      shared.Settings.EXPORTED_FUNCTIONS += ['_memalign', '_malloc']
 
       # dynCall_ii is used to call pthread entry points in worker.js (as
       # metadce does not consider worker.js, which is external, we must

From ae6f617eb5d63c6b37bbde1d6fd59bb4c99ae4ac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Wed, 5 Feb 2020 19:51:51 +0200
Subject: [PATCH 06/27] Add threading related closure externs

---
 src/closure-externs.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/closure-externs.js b/src/closure-externs.js
index 56173c900ec9f..a2423605d00db 100644
--- a/src/closure-externs.js
+++ b/src/closure-externs.js
@@ -975,3 +975,16 @@ var outerWidth;
 var outerHeight;
 var event;
 var devicePixelRatio;
+
+// TODO: Use Closure's multifile support and/or migrate worker.js onmessage handler to inside the MODULARIZEd block
+// to be able to remove all the variables below:
+
+// Variables that are present in both output runtime .js file/JS lib files, and worker.js, so cannot be minified because
+// the names need to match:
+// BUG: None of these variables work properly with USE_PTHREADS + MODULARIZE builds.
+var threadInfoStruct;
+var selfThreadId;
+var noExitRuntime;
+
+// Technically only needed for MINIMAL_RUNTIME use of USE_PTHREADS + !MODULARIZE, but enabled here for all modes for now.
+var ENVIRONMENT_IS_PTHREAD;

From 8a215be6718b6a5f5b2215ab71322c99509e777e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Thu, 6 Feb 2020 18:56:45 +0200
Subject: [PATCH 07/27] Remove 'establishStackSpace' variable.

---
 emcc.py                  |  3 ---
 emscripten.py            | 16 ----------------
 src/library.js           | 17 -----------------
 src/library_pthread.js   |  2 +-
 src/modules.js           |  3 ---
 src/settings_internal.js |  2 +-
 src/support.js           |  6 ------
 7 files changed, 2 insertions(+), 47 deletions(-)

diff --git a/emcc.py b/emcc.py
index 6a2d772d12a05..706e405cd47e2 100755
--- a/emcc.py
+++ b/emcc.py
@@ -1528,9 +1528,6 @@ def is_supported_link_flag(f):
       ]
 
     if shared.Settings.USE_PTHREADS:
-      if not shared.Settings.MINIMAL_RUNTIME:
-        shared.Settings.EXPORTED_RUNTIME_METHODS += ['establishStackSpace']
-
       # memalign is used to ensure allocated thread stacks are aligned.
       shared.Settings.EXPORTED_FUNCTIONS += ['_memalign', '_malloc']
 
diff --git a/emscripten.py b/emscripten.py
index dff838a61f3f8..9efbe7a4fc930 100644
--- a/emscripten.py
+++ b/emscripten.py
@@ -943,8 +943,6 @@ def get_exported_implemented_functions(all_exported_functions, all_implemented,
     funcs.append('_emscripten_replace_memory')
   if not shared.Settings.SIDE_MODULE and not shared.Settings.MINIMAL_RUNTIME:
     funcs += ['stackAlloc', 'stackSave', 'stackRestore']
-  if shared.Settings.USE_PTHREADS:
-    funcs += ['establishStackSpace']
 
   if shared.Settings.EMTERPRETIFY:
     funcs += ['emterpret']
@@ -1675,8 +1673,6 @@ def create_asm_runtime_funcs():
   funcs = []
   if not (shared.Settings.WASM and shared.Settings.SIDE_MODULE) and not shared.Settings.MINIMAL_RUNTIME:
     funcs += ['stackAlloc', 'stackSave', 'stackRestore']
-  if shared.Settings.USE_PTHREADS:
-    funcs += ['establishStackSpace']
   return funcs
 
 
@@ -1891,18 +1887,6 @@ def create_runtime_funcs_asmjs(exports, metadata):
     # MINIMAL_RUNTIME moves stack functions to library.
     funcs = []
 
-  if shared.Settings.USE_PTHREADS:
-    funcs.append('''
-function establishStackSpace(stackBase, stackMax) {
-  stackBase = stackBase|0;
-  stackMax = stackMax|0;
-  STACKTOP = stackBase;
-  STACK_MAX = stackMax;
-  tempDoublePtr = STACKTOP;
-  STACKTOP = (STACKTOP + 8)|0;
-}
-''')
-
   if shared.Settings.EMTERPRETIFY:
     funcs.append('''
 function emterpret(pc) { // this will be replaced when the emterpreter code is generated; adding it here allows validation until then
diff --git a/src/library.js b/src/library.js
index 8903f55c27533..4887615dc0b62 100644
--- a/src/library.js
+++ b/src/library.js
@@ -1359,23 +1359,6 @@ LibraryManager.library = {
   },
 #endif
 
-#if USE_PTHREADS
-  $establishStackSpace__asm: true,
-  $establishStackSpace__sig: 'vii',
-  $establishStackSpace: function(stackBase, stackMax) {
-#if WASM_BACKEND
-    // The wasm backend path does not have a way to set the stack max, so ignore
-    // the stack max parameter, this function only resets the stack base.
-    stackRestore(stackBase);
-#else
-    stackBase = stackBase|0;
-    stackMax = stackMax|0;
-    STACKTOP = stackBase;
-    STACK_MAX = stackMax;
-#endif
-  },
-#endif
-
 #if WASM_BACKEND == 0
   $setThrew__asm: true,
   $setThrew__sig: 'vii',
diff --git a/src/library_pthread.js b/src/library_pthread.js
index b5b74ec7aa39f..616fc65ead859 100644
--- a/src/library_pthread.js
+++ b/src/library_pthread.js
@@ -1333,7 +1333,7 @@ var LibraryPThread = {
     writeStackCookie();
 #endif
     // Call inside asm.js/wasm module to set up the stack frame for this pthread in asm.js/wasm module scope
-    establishStackSpace(stackTop, stackMax);
+    stackRestore(stackTop);
   },
 
   // allow pthreads to check if noExitRuntime from worker.js
diff --git a/src/modules.js b/src/modules.js
index cb31f244a8ece..2b18d4dfa8de6 100644
--- a/src/modules.js
+++ b/src/modules.js
@@ -460,9 +460,6 @@ function exportRuntime() {
     ]);
 
   }
-  if (USE_PTHREADS) {
-    runtimeElements.push('establishStackSpace');
-  }
 
   if (STACK_OVERFLOW_CHECK) {
     runtimeElements.push('writeStackCookie');
diff --git a/src/settings_internal.js b/src/settings_internal.js
index c6c977480428c..aa7fb9f651ca6 100644
--- a/src/settings_internal.js
+++ b/src/settings_internal.js
@@ -169,4 +169,4 @@ var TARGET_NOT_SUPPORTED = 0x7FFFFFFF;
 // Wasm backend does not apply C name mangling (== prefix with an underscore) to
 // the following functions. (it also does not mangle any function that starts with
 // string "dynCall_")
-var WASM_FUNCTIONS_THAT_ARE_NOT_NAME_MANGLED = ['setTempRet0', 'getTempRet0', 'stackAlloc', 'stackSave', 'stackRestore', 'establishStackSpace', '__growWasmMemory', '__heap_base', '__data_end'];
+var WASM_FUNCTIONS_THAT_ARE_NOT_NAME_MANGLED = ['setTempRet0', 'getTempRet0', 'stackAlloc', 'stackSave', 'stackRestore', '__growWasmMemory', '__heap_base', '__data_end'];
diff --git a/src/support.js b/src/support.js
index 5a5e3dd99fd35..09b92a667d668 100644
--- a/src/support.js
+++ b/src/support.js
@@ -815,12 +815,6 @@ GLOBAL_BASE = alignMemory(GLOBAL_BASE, {{{ MAX_GLOBAL_ALIGN || 1 }}});
 #endif
 
 #if WASM_BACKEND && USE_PTHREADS
-// The wasm backend path does not have a way to set the stack max, so ignore
-// the stack max parameter, this function only resets the stack base.
-function establishStackSpace(base/*, max*/) {
-  stackRestore(base);
-}
-
 // JS library code refers to Atomics in the manner used from asm.js, provide
 // the same API here.
 var Atomics_load = Atomics.load;

From b532545feed162b6b1468f1eeb95a35e0a213d14 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Thu, 6 Feb 2020 18:57:55 +0200
Subject: [PATCH 08/27] Rename establishStackSpaceInJsModule to
 establishStackSpace.

---
 emcc.py                | 2 +-
 src/library_pthread.js | 2 +-
 src/preamble.js        | 2 +-
 src/worker.js          | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/emcc.py b/emcc.py
index 706e405cd47e2..d84554425d20c 100755
--- a/emcc.py
+++ b/emcc.py
@@ -1547,7 +1547,7 @@ def include_and_export(name):
         shared.Settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE += ['$' + name]
         shared.Settings.EXPORTED_FUNCTIONS += [name]
 
-      include_and_export('establishStackSpaceInJsModule')
+      include_and_export('establishStackSpace')
       include_and_export('getNoExitRuntime')
 
       if shared.Settings.MODULARIZE:
diff --git a/src/library_pthread.js b/src/library_pthread.js
index 616fc65ead859..3060709a751a3 100644
--- a/src/library_pthread.js
+++ b/src/library_pthread.js
@@ -1311,7 +1311,7 @@ var LibraryPThread = {
     return func.apply(null, _emscripten_receive_on_main_thread_js_callArgs);
   },
 
-  $establishStackSpaceInJsModule: function(stackTop, stackMax) {
+  $establishStackSpace: function(stackTop, stackMax) {
     STACK_BASE = STACKTOP = stackTop;
     STACK_MAX = stackMax;
 
diff --git a/src/preamble.js b/src/preamble.js
index b93e5ff114a53..05a7f5c185aaf 100644
--- a/src/preamble.js
+++ b/src/preamble.js
@@ -373,7 +373,7 @@ if (ENVIRONMENT_IS_PTHREAD) {
   // At the 'load' stage of Worker startup, we are just loading this script
   // but not ready to run yet. At 'run' we receive proper values for the stack
   // etc. and can launch a pthread. Set some fake values there meanwhile to
-  // catch bugs, then set the real values in establishStackSpaceInJsModule later.
+  // catch bugs, then set the real values in establishStackSpace later.
 #if ASSERTIONS || STACK_OVERFLOW_CHECK >= 2
   STACK_MAX = STACKTOP = STACK_MAX = 0x7FFFFFFF;
 #endif
diff --git a/src/worker.js b/src/worker.js
index 876ad70a2869f..06d3a3b0fd852 100644
--- a/src/worker.js
+++ b/src/worker.js
@@ -222,7 +222,7 @@ this.onmessage = function(e) {
 #endif
 #endif
       // Also call inside JS module to set up the stack frame for this pthread in JS module scope
-      Module['establishStackSpaceInJsModule'](top, max);
+      Module['establishStackSpace'](top, max);
 #if WASM_BACKEND
       {{{ makeAsmExportsAccessInPthread('_emscripten_tls_init') }}}();
 #endif

From 8713949df9c817bbc34a61b6c1fa3e06d72bfb4a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Sun, 9 Feb 2020 18:21:16 +0200
Subject: [PATCH 09/27] flake

---
 tools/minimal_runtime_shell.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/minimal_runtime_shell.py b/tools/minimal_runtime_shell.py
index 8bfa2d43c77dd..639c9e0feaec2 100644
--- a/tools/minimal_runtime_shell.py
+++ b/tools/minimal_runtime_shell.py
@@ -136,9 +136,9 @@ def generate_minimal_runtime_load_statement(target_basename):
     # immediately start the download, but can control when we add the script to the
     # DOM.
     if shared.Settings.USE_PTHREADS:
-      script_load = "script(url)";
+      script_load = "script(url)"
     else:
-      script_load = "script(url).then(() => { URL.revokeObjectURL(url) });";
+      script_load = "script(url).then(() => { URL.revokeObjectURL(url) });"
 
     files_to_load[0] = "binary('%s')" % (target_basename + '.js')
     then_statements += ["var url = URL.createObjectURL(new Blob([r[0]], { type: 'application/javascript' }));",

From 405d731feb28d409390d1cdb1edfee6e8b6aa87a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Sun, 9 Feb 2020 18:21:42 +0200
Subject: [PATCH 10/27] pthread_cleanup_push needs ATEXIT registration only if
 EXIT_RUNTIME=1.

---
 src/library_pthread.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/library_pthread.js b/src/library_pthread.js
index 3060709a751a3..e21d7d9f4bc17 100644
--- a/src/library_pthread.js
+++ b/src/library_pthread.js
@@ -1071,9 +1071,11 @@ var LibraryPThread = {
   pthread_cleanup_push: function(routine, arg) {
     if (PThread.exitHandlers === null) {
       PThread.exitHandlers = [];
+#if EXIT_RUNTIME
       if (!ENVIRONMENT_IS_PTHREAD) {
         __ATEXIT__.push(function() { PThread.runExitHandlers(); });
       }
+#endif
     }
     PThread.exitHandlers.push(function() { {{{ makeDynCall('vi') }}}(routine, arg) });
   },

From e91ee95bed0ec1e8d023402204a9a98529bc8b96 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Sun, 9 Feb 2020 19:12:03 +0200
Subject: [PATCH 11/27] Offset Converter loading for MINIMAL_RUNTIME pthreads

---
 src/library_pthread.js   | 15 ++++++++++++++-
 src/postamble_minimal.js | 20 +++++++++++++++-----
 src/worker.js            | 24 +++---------------------
 3 files changed, 32 insertions(+), 27 deletions(-)

diff --git a/src/library_pthread.js b/src/library_pthread.js
index e21d7d9f4bc17..72239677c8168 100644
--- a/src/library_pthread.js
+++ b/src/library_pthread.js
@@ -558,7 +558,7 @@ var LibraryPThread = {
     return navigator['hardwareConcurrency'];
   },
 
-  {{{ USE_LSAN || USE_ASAN ? 'emscripten_builtin_' : '' }}}pthread_create__deps: ['_spawn_thread', 'pthread_getschedparam', 'pthread_self', 'memalign'],
+  {{{ USE_LSAN || USE_ASAN ? 'emscripten_builtin_' : '' }}}pthread_create__deps: ['_spawn_thread', 'pthread_getschedparam', 'pthread_self', 'memalign', '$resetPrototype'],
   {{{ USE_LSAN || USE_ASAN ? 'emscripten_builtin_' : '' }}}pthread_create: function(pthread_ptr, attr, start_routine, arg) {
     if (typeof SharedArrayBuffer === 'undefined') {
       err('Current environment does not support SharedArrayBuffer, pthreads are not available!');
@@ -1343,6 +1343,19 @@ var LibraryPThread = {
     return noExitRuntime;
   },
 
+  // When using postMessage to send an object, it is processed by the structured clone algorithm.
+  // The prototype, and hence methods, on that object is then lost. This function adds back the lost prototype.
+  // This does not work with nested objects that has prototypes, but it suffices for WasmSourceMap and WasmOffsetConverter.
+  $resetPrototype: function(constructor, attrs) {
+    var object = Object.create(constructor.prototype);
+    for (var key in attrs) {
+      if (attrs.hasOwnProperty(key)) {
+        object[key] = attrs[key];
+      }
+    }
+    return object;
+  },
+
   // This function is called internally to notify target thread ID that it has messages it needs to
   // process in its message queue inside the Wasm heap. As a helper, the caller must also pass the
   // ID of the main browser thread to this function, to avoid needlessly ping-ponging between JS and
diff --git a/src/postamble_minimal.js b/src/postamble_minimal.js
index d43d991b67b45..c0e3637a3dc10 100644
--- a/src/postamble_minimal.js
+++ b/src/postamble_minimal.js
@@ -137,10 +137,6 @@ WebAssembly.instantiateStreaming(fetch('{{{ TARGET_BASENAME }}}.wasm'), imports)
 // Module['wasm'] should contain a typed array of the Wasm object data, or a precompiled WebAssembly Module.
 if (!Module['wasm']) throw 'Must load WebAssembly Module in to variable Module.wasm before adding compiled output .js script to the DOM';
 #endif
-#if USE_PTHREADS
-// Store the Wasm instance to be able to post it to pthreads.
-Module['wasmInstance'] =
-#endif
 WebAssembly.instantiate(Module['wasm'], imports).then(function(output) {
 #endif
 
@@ -175,9 +171,15 @@ WebAssembly.instantiate(Module['wasm'], imports).then(function(output) {
 #else
   asm = output.instance.exports;
 #endif
+
 #if USE_OFFSET_CONVERTER
-  wasmOffsetConverter = new WasmOffsetConverter(Module['wasm'], output.module);
+  wasmOffsetConverter =
+#if USE_PTHREADS
+    ENVIRONMENT_IS_PTHREAD ? resetPrototype(WasmOffsetConverter, wasmOffsetData) :
+#endif
+    new WasmOffsetConverter(Module['wasm'], output.module);
 #endif
+
 #if !DECLARE_ASM_MODULE_EXPORTS
   exportAsmFunctions(asm);
 #else
@@ -194,6 +196,14 @@ WebAssembly.instantiate(Module['wasm'], imports).then(function(output) {
 #else
   ready();
 #endif
+
+#if USE_PTHREADS
+  // This Worker is now ready to host pthreads, tell the main thread we can proceed.
+  if (ENVIRONMENT_IS_PTHREAD) {
+    postMessage({ cmd: 'loaded' });
+  }
+#endif
+
 })
 #if ASSERTIONS
 .catch(function(error) {
diff --git a/src/worker.js b/src/worker.js
index 06d3a3b0fd852..1330cfb607c1c 100644
--- a/src/worker.js
+++ b/src/worker.js
@@ -40,21 +40,6 @@ function threadAlert() {
 var err = threadPrintErr;
 this.alert = threadAlert;
 
-#if LOAD_SOURCE_MAP || USE_OFFSET_CONVERTER
-// When using postMessage to send an object, it is processed by the structured clone algorithm.
-// The prototype, and hence methods, on that object is then lost. This function adds back the lost prototype.
-// This does not work with nested objects that has prototypes, but it suffices for WasmSourceMap and WasmOffsetConverter.
-function resetPrototype(constructor, attrs) {
-  var object = Object.create(constructor.prototype);
-  for (var key in attrs) {
-    if (attrs.hasOwnProperty(key)) {
-      object[key] = attrs[key];
-    }
-  }
-  return object;
-}
-#endif
-
 #if WASM && !MINIMAL_RUNTIME
 Module['instantiateWasm'] = function(info, receiveInstance) {
   // Instantiate from the module posted from the main thread.
@@ -171,13 +156,10 @@ this.onmessage = function(e) {
       HEAPU32 = Module['HEAPU32'];
 #endif
 
-#if MINIMAL_RUNTIME && WASM
-      Module['wasmInstance'].then(() => {
-#endif
-        postMessage({ cmd: 'loaded' });
-#if MINIMAL_RUNTIME && WASM
-      });
+#if !MINIMAL_RUNTIME || !WASM
+      postMessage({ cmd: 'loaded' });
 #endif
+
 #endif
     } else if (e.data.cmd === 'objectTransfer') {
       PThread.receiveObjectTransfer(e.data);

From cbb28db01cbce706f0e9efbe35deef278d534473 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Sun, 9 Feb 2020 19:17:28 +0200
Subject: [PATCH 12/27] Add note about MODULARIZE_INSTANCE with
 MINIMAL_RUNTIME=1

---
 emcc.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/emcc.py b/emcc.py
index d84554425d20c..32617a5eecf09 100755
--- a/emcc.py
+++ b/emcc.py
@@ -1300,6 +1300,8 @@ def is_supported_link_flag(f):
     if shared.Settings.MODULARIZE_INSTANCE:
       shared.Settings.MODULARIZE = 1
 
+      assert not shared.Settings.MINIMAL_RUNTIME, 'MINIMAL_RUNTIME does not support -s MODULARIZE_INSTANCE=1 (Minimal runtime loader shell already behaves like MODULARIZE_INSTANCE=1, follow that pattern for the same effect)'
+
     if shared.Settings.MODULARIZE:
       assert not options.proxy_to_worker, '-s MODULARIZE=1 and -s MODULARIZE_INSTANCE=1 are not compatible with --proxy-to-worker (if you want to run in a worker with -s MODULARIZE=1, you likely want to do the worker side setup manually)'
       # MODULARIZE's .then() method uses onRuntimeInitialized currently, so make sure

From 8c7e3d3ae82dab654953c06eb96aeef1cbce5451 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Mon, 10 Feb 2020 15:32:44 +0200
Subject: [PATCH 13/27] MODULARIZE_INSTANCE working with MINIMAL_RUNTIME.

---
 emcc.py                                       | 10 ++--
 src/closure-externs.js                        |  3 +-
 src/library_pthread.js                        | 19 +++++--
 src/library_syscall.js                        |  4 ++
 src/memoryprofiler.js                         |  4 ++
 src/postamble_minimal.js                      | 13 ++++-
 src/preamble.js                               |  2 -
 src/preamble_minimal.js                       |  4 +-
 src/runtime_debug.js                          | 51 +++++++++++++++++
 src/shell_minimal.js                          |  2 +-
 src/shell_minimal_runtime.html                |  4 +-
 src/support.js                                | 52 +-----------------
 src/worker.js                                 | 55 +++++++++----------
 .../musl/src/thread/pthread_cond_timedwait.c  |  1 +
 tests/pthread/call_sync_on_main_thread.c      | 10 ++--
 tests/pthread/call_sync_on_main_thread.js     | 16 +++---
 tests/pthread/test_pthread_mutex.cpp          |  7 ++-
 tests/test_browser.py                         |  5 ++
 tools/minimal_runtime_shell.py                | 20 ++++---
 19 files changed, 156 insertions(+), 126 deletions(-)
 create mode 100644 src/runtime_debug.js

diff --git a/emcc.py b/emcc.py
index 32617a5eecf09..d37c0193bfa51 100755
--- a/emcc.py
+++ b/emcc.py
@@ -1294,14 +1294,13 @@ def is_supported_link_flag(f):
     if shared.Settings.STACK_OVERFLOW_CHECK:
       if shared.Settings.MINIMAL_RUNTIME:
         shared.Settings.DEFAULT_LIBRARY_FUNCS_TO_INCLUDE += ['$abortStackOverflow']
+        shared.Settings.EXPORTED_RUNTIME_METHODS += ['writeStackCookie', 'checkStackCookie']
       else:
         shared.Settings.EXPORTED_RUNTIME_METHODS += ['writeStackCookie', 'checkStackCookie', 'abortStackOverflow']
 
     if shared.Settings.MODULARIZE_INSTANCE:
       shared.Settings.MODULARIZE = 1
 
-      assert not shared.Settings.MINIMAL_RUNTIME, 'MINIMAL_RUNTIME does not support -s MODULARIZE_INSTANCE=1 (Minimal runtime loader shell already behaves like MODULARIZE_INSTANCE=1, follow that pattern for the same effect)'
-
     if shared.Settings.MODULARIZE:
       assert not options.proxy_to_worker, '-s MODULARIZE=1 and -s MODULARIZE_INSTANCE=1 are not compatible with --proxy-to-worker (if you want to run in a worker with -s MODULARIZE=1, you likely want to do the worker side setup manually)'
       # MODULARIZE's .then() method uses onRuntimeInitialized currently, so make sure
@@ -1550,7 +1549,9 @@ def include_and_export(name):
         shared.Settings.EXPORTED_FUNCTIONS += [name]
 
       include_and_export('establishStackSpace')
-      include_and_export('getNoExitRuntime')
+      if not shared.Settings.MINIMAL_RUNTIME:
+        # noExitRuntime does not apply to MINIMAL_RUNTIME.
+        include_and_export('getNoExitRuntime')
 
       if shared.Settings.MODULARIZE:
         # MODULARIZE+USE_PTHREADS mode requires extra exports out to Module so that worker.js
@@ -3430,8 +3431,7 @@ def module_export_name_substitution():
     src = src.replace(shared.JS.module_export_name_substitution_pattern, replacement)
     # For Node.js and other shell environments, create an unminified Module object so that
     # loading external .asm.js file that assigns to Module['asm'] works even when Closure is used.
-    if shared.Settings.MINIMAL_RUNTIME and (shared.Settings.target_environment_may_be('node') or
-                                            shared.Settings.target_environment_may_be('shell')):
+    if shared.Settings.MINIMAL_RUNTIME and not shared.Settings.MODULARIZE_INSTANCE and (shared.Settings.target_environment_may_be('node') or shared.Settings.target_environment_may_be('shell')):
       src = 'if(typeof Module==="undefined"){var Module={};}' + src
     f.write(src)
   save_intermediate('module_export_name_substitution')
diff --git a/src/closure-externs.js b/src/closure-externs.js
index a2423605d00db..6f8b8ccdb97fc 100644
--- a/src/closure-externs.js
+++ b/src/closure-externs.js
@@ -981,10 +981,11 @@ var devicePixelRatio;
 
 // Variables that are present in both output runtime .js file/JS lib files, and worker.js, so cannot be minified because
 // the names need to match:
-// BUG: None of these variables work properly with USE_PTHREADS + MODULARIZE builds.
 var threadInfoStruct;
 var selfThreadId;
 var noExitRuntime;
 
 // Technically only needed for MINIMAL_RUNTIME use of USE_PTHREADS + !MODULARIZE, but enabled here for all modes for now.
 var ENVIRONMENT_IS_PTHREAD;
+/** @suppress {duplicate} */
+var wasmMemory;
diff --git a/src/library_pthread.js b/src/library_pthread.js
index 72239677c8168..4946ceb6c3cd8 100644
--- a/src/library_pthread.js
+++ b/src/library_pthread.js
@@ -777,18 +777,25 @@ var LibraryPThread = {
     if (canceled == 2) throw 'Canceled!';
   },
 
-#if ASSERTIONS
+#if MINIMAL_RUNTIME
+  emscripten_check_blocking_allowed__deps: ['$warnOnce'],
+#endif
   emscripten_check_blocking_allowed: function() {
-    assert(ENVIRONMENT_IS_WEB);
+#if ASSERTIONS || IN_TEST_HARNESS || !MINIMAL_RUNTIME || !ALLOW_BLOCKING_ON_MAIN_THREAD
+#if ENVIRONMENT_MAY_BE_NODE
+    if (ENVIRONMENT_IS_NODE) return;
+#endif
+
     warnOnce('Blocking on the main thread is very dangerous, see https://emscripten.org/docs/porting/pthreads.html#blocking-on-the-main-browser-thread');
 #if !ALLOW_BLOCKING_ON_MAIN_THREAD
     abort('Blocking on the main thread is not allowed by default. See https://emscripten.org/docs/porting/pthreads.html#blocking-on-the-main-browser-thread');
 #endif
-  },
+
 #endif
+  },
 
   _emscripten_do_pthread_join__deps: ['_cleanup_thread', '_pthread_testcancel_js', 'emscripten_main_thread_process_queued_calls', 'emscripten_futex_wait',
-#if ASSERTIONS
+#if ASSERTIONS || IN_TEST_HARNESS || !MINIMAL_RUNTIME || !ALLOW_BLOCKING_ON_MAIN_THREAD
   'emscripten_check_blocking_allowed'
 #endif
   ],
@@ -817,8 +824,8 @@ var LibraryPThread = {
       return ERRNO_CODES.EINVAL; // The thread is already detached, can no longer join it!
     }
 
-#if ASSERTIONS
-    if (block && ENVIRONMENT_IS_WEB) {
+#if ASSERTIONS || IN_TEST_HARNESS || !MINIMAL_RUNTIME || !ALLOW_BLOCKING_ON_MAIN_THREAD
+    if (block) {
       _emscripten_check_blocking_allowed();
     }
 #endif
diff --git a/src/library_syscall.js b/src/library_syscall.js
index afaa6518742d7..52f174451e720 100644
--- a/src/library_syscall.js
+++ b/src/library_syscall.js
@@ -1153,6 +1153,10 @@ var SyscallsLibrary = {
     }
 #endif // SYSCALLS_REQUIRE_FILESYSTEM
   },
+  
+#if MINIMAL_RUNTIME
+  __syscall252__deps: ['$exit'],
+#endif
   __syscall252: function(which, varargs) { // exit_group
     var status = SYSCALLS.get();
     exit(status);
diff --git a/src/memoryprofiler.js b/src/memoryprofiler.js
index 6b02884f778b3..b50bfcd06921b 100644
--- a/src/memoryprofiler.js
+++ b/src/memoryprofiler.js
@@ -1,3 +1,5 @@
+#if MEMORYPROFILER
+
 // Copyright 2015 The Emscripten Authors.  All rights reserved.
 // Emscripten is available under two separate licenses, the MIT license and the
 // University of Illinois/NCSA Open Source License.  Both these licenses can be
@@ -597,3 +599,5 @@ var emscriptenMemoryProfiler = {
 function memoryprofiler_add_hooks() { emscriptenMemoryProfiler.initialize(); }
 
 if (typeof Module !== 'undefined' && typeof document !== 'undefined' && typeof window !== 'undefined' && typeof process === 'undefined') emscriptenMemoryProfiler.initialize();
+
+#endif
diff --git a/src/postamble_minimal.js b/src/postamble_minimal.js
index c0e3637a3dc10..d7a121083fc3d 100644
--- a/src/postamble_minimal.js
+++ b/src/postamble_minimal.js
@@ -94,7 +94,7 @@ var asm;
 
 #if USE_PTHREADS && WASM
 var wasmModule;
-#if PTHREAD_POOL_SIZE > 0
+#if PTHREAD_POOL_SIZE
 function loadWasmModuleToWorkers() {
 #if PTHREAD_POOL_DELAY_LOAD
   PThread.unusedWorkers.forEach(PThread.loadWasmModuleToWorker);
@@ -186,6 +186,15 @@ WebAssembly.instantiate(Module['wasm'], imports).then(function(output) {
   /*** ASM_MODULE_EXPORTS ***/
 #endif
 
+#if USE_PTHREADS
+  //Export needed variables that worker.js needs to Module.
+#if WASM_BACKEND
+  Module['_emscripten_tls_init'] = _emscripten_tls_init;
+#endif
+  Module['HEAPU32'] = HEAPU32;
+  Module['dynCall_ii'] = dynCall_ii;
+#endif
+
   initRuntime(asm);
 #if USE_PTHREADS && PTHREAD_POOL_SIZE
   if (!ENVIRONMENT_IS_PTHREAD) loadWasmModuleToWorkers();
@@ -200,7 +209,7 @@ WebAssembly.instantiate(Module['wasm'], imports).then(function(output) {
 #if USE_PTHREADS
   // This Worker is now ready to host pthreads, tell the main thread we can proceed.
   if (ENVIRONMENT_IS_PTHREAD) {
-    postMessage({ cmd: 'loaded' });
+    postMessage({ 'cmd': 'loaded' });
   }
 #endif
 
diff --git a/src/preamble.js b/src/preamble.js
index 05a7f5c185aaf..a7414cae92515 100644
--- a/src/preamble.js
+++ b/src/preamble.js
@@ -777,9 +777,7 @@ function lookupSymbol(ptr) { // for a pointer, print out all symbols that resolv
 
 var memoryInitializer = null;
 
-#if MEMORYPROFILER
 #include "memoryprofiler.js"
-#endif
 
 #if ASSERTIONS && !('$FS' in addedLibraryItems) && !ASMFS
 // show errors on likely calls to FS when it was not included
diff --git a/src/preamble_minimal.js b/src/preamble_minimal.js
index ad52633caf3ad..82b6448d9f5a0 100644
--- a/src/preamble_minimal.js
+++ b/src/preamble_minimal.js
@@ -251,8 +251,8 @@ var runtimeExited = false;
 
 var memoryInitializer = null;
 
-#if MEMORYPROFILER
 #include "memoryprofiler.js"
-#endif
+
+#include "runtime_debug.js"
 
 // === Body ===
diff --git a/src/runtime_debug.js b/src/runtime_debug.js
new file mode 100644
index 0000000000000..9456ed23b7b68
--- /dev/null
+++ b/src/runtime_debug.js
@@ -0,0 +1,51 @@
+#if RUNTIME_DEBUG
+var runtimeDebug = true; // Switch to false at runtime to disable logging at the right times
+
+var printObjectList = [];
+
+function prettyPrint(arg) {
+  if (typeof arg == 'undefined') return '!UNDEFINED!';
+  if (typeof arg == 'boolean') arg = arg + 0;
+  if (!arg) return arg;
+  var index = printObjectList.indexOf(arg);
+  if (index >= 0) return '<' + arg + '|' + index + '>';
+  if (arg.toString() == '[object HTMLImageElement]') {
+    return arg + '\n\n';
+  }
+  if (arg.byteLength) {
+    return '{' + Array.prototype.slice.call(arg, 0, Math.min(arg.length, 400)) + '}'; // Useful for correct arrays, less so for compiled arrays, see the code below for that
+    var buf = new ArrayBuffer(32);
+    var i8buf = new Int8Array(buf);
+    var i16buf = new Int16Array(buf);
+    var f32buf = new Float32Array(buf);
+    switch(arg.toString()) {
+      case '[object Uint8Array]':
+        i8buf.set(arg.subarray(0, 32));
+        break;
+      case '[object Float32Array]':
+        f32buf.set(arg.subarray(0, 5));
+        break;
+      case '[object Uint16Array]':
+        i16buf.set(arg.subarray(0, 16));
+        break;
+      default:
+        alert('unknown array for debugging: ' + arg);
+        throw 'see alert';
+    }
+    var ret = '{' + arg.byteLength + ':\n';
+    var arr = Array.prototype.slice.call(i8buf);
+    ret += 'i8:' + arr.toString().replace(/,/g, ',') + '\n';
+    arr = Array.prototype.slice.call(f32buf, 0, 8);
+    ret += 'f32:' + arr.toString().replace(/,/g, ',') + '}';
+    return ret;
+  }
+  if (typeof arg == 'object') {
+    printObjectList.push(arg);
+    return '<' + arg + '|' + (printObjectList.length-1) + '>';
+  }
+  if (typeof arg == 'number') {
+    if (arg > 0) return '0x' + arg.toString(16) + ' (' + arg + ')';
+  }
+  return arg;
+}
+#endif
diff --git a/src/shell_minimal.js b/src/shell_minimal.js
index f159d34810641..aacf8912d7fe8 100644
--- a/src/shell_minimal.js
+++ b/src/shell_minimal.js
@@ -145,7 +145,7 @@ function ready() {
 
 #if USE_PTHREADS
 
-#if !MODULARIZE
+#if !MODULARIZE || MODULARIZE_INSTANCE
 // In MODULARIZE mode _scriptDir needs to be captured already at the very top of the page immediately when the page is parsed, so it is generated there
 // before the page load. In non-MODULARIZE modes generate it here.
 var _scriptDir = (typeof document !== 'undefined' && document.currentScript) ? document.currentScript.src : undefined;
diff --git a/src/shell_minimal_runtime.html b/src/shell_minimal_runtime.html
index 711102b5ecef9..9c6f0c8e8a1d1 100644
--- a/src/shell_minimal_runtime.html
+++ b/src/shell_minimal_runtime.html
@@ -2,7 +2,7 @@
 <body>
 <canvas style='display:block; margin:auto;'></canvas>
 <script>
-#if !MODULARIZE
+#if !MODULARIZE || MODULARIZE_INSTANCE
   var Module = {
 #if USE_PTHREADS
     worker: '{{{ PTHREAD_WORKER_FILE }}}'
@@ -23,7 +23,7 @@
 // If we are doing a SINGLE_FILE=1 build, inlined JS runtime code follows here:
 {{{ JS_CONTENTS_IN_SINGLE_FILE_BUILD }}}
 
-#if MODULARIZE
+#if MODULARIZE && !MODULARIZE_INSTANCE
 // Launch the MODULARIZEd build.
 {{{ EXPORT_NAME }}}({});
 #endif
diff --git a/src/support.js b/src/support.js
index 09b92a667d668..6ab95057bf657 100644
--- a/src/support.js
+++ b/src/support.js
@@ -693,57 +693,7 @@ function getFuncWrapper(func, sig) {
   return sigCache[func];
 }
 
-#if RUNTIME_DEBUG
-var runtimeDebug = true; // Switch to false at runtime to disable logging at the right times
-
-var printObjectList = [];
-
-function prettyPrint(arg) {
-  if (typeof arg == 'undefined') return '!UNDEFINED!';
-  if (typeof arg == 'boolean') arg = arg + 0;
-  if (!arg) return arg;
-  var index = printObjectList.indexOf(arg);
-  if (index >= 0) return '<' + arg + '|' + index + '>';
-  if (arg.toString() == '[object HTMLImageElement]') {
-    return arg + '\n\n';
-  }
-  if (arg.byteLength) {
-    return '{' + Array.prototype.slice.call(arg, 0, Math.min(arg.length, 400)) + '}'; // Useful for correct arrays, less so for compiled arrays, see the code below for that
-    var buf = new ArrayBuffer(32);
-    var i8buf = new Int8Array(buf);
-    var i16buf = new Int16Array(buf);
-    var f32buf = new Float32Array(buf);
-    switch(arg.toString()) {
-      case '[object Uint8Array]':
-        i8buf.set(arg.subarray(0, 32));
-        break;
-      case '[object Float32Array]':
-        f32buf.set(arg.subarray(0, 5));
-        break;
-      case '[object Uint16Array]':
-        i16buf.set(arg.subarray(0, 16));
-        break;
-      default:
-        alert('unknown array for debugging: ' + arg);
-        throw 'see alert';
-    }
-    var ret = '{' + arg.byteLength + ':\n';
-    var arr = Array.prototype.slice.call(i8buf);
-    ret += 'i8:' + arr.toString().replace(/,/g, ',') + '\n';
-    arr = Array.prototype.slice.call(f32buf, 0, 8);
-    ret += 'f32:' + arr.toString().replace(/,/g, ',') + '}';
-    return ret;
-  }
-  if (typeof arg == 'object') {
-    printObjectList.push(arg);
-    return '<' + arg + '|' + (printObjectList.length-1) + '>';
-  }
-  if (typeof arg == 'number') {
-    if (arg > 0) return '0x' + arg.toString(16) + ' (' + arg + ')';
-  }
-  return arg;
-}
-#endif
+#include "runtime_debug.js"
 
 function makeBigInt(low, high, unsigned) {
   return unsigned ? ((+((low>>>0)))+((+((high>>>0)))*4294967296.0)) : ((+((low>>>0)))+((+((high|0)))*4294967296.0));
diff --git a/src/worker.js b/src/worker.js
index 1330cfb607c1c..a9e64bf82086b 100644
--- a/src/worker.js
+++ b/src/worker.js
@@ -16,12 +16,6 @@ var parentThreadId = 0; // The ID of the parent pthread that launched this threa
 // Therefore implement custom logging facility for threads running in a worker, which queue the messages to main thread to print.
 var Module = {};
 
-// These modes need to assign to these variables because of how scoping works in them.
-#if (EXPORT_ES6 || MODULARIZE) && !MINIMAL_RUNTIME
-var PThread;
-var HEAPU32;
-#endif
-
 #if ASSERTIONS
 function assert(condition, text) {
   if (!condition) abort('Assertion failed: ' + text);
@@ -68,9 +62,13 @@ var wasmOffsetData;
 this.onmessage = function(e) {
   try {
     if (e.data.cmd === 'load') { // Preload command that is called once per worker to parse and load the Emscripten code.
-#if MINIMAL_RUNTIME && MODULARIZE
+#if MINIMAL_RUNTIME
+#if MODULARIZE_INSTANCE
+      var imports = Module;
+#else
       var imports = {};
 #endif
+#endif
 
 #if !WASM_BACKEND
       // Initialize the thread-local field(s):
@@ -134,7 +132,7 @@ this.onmessage = function(e) {
 #if MODULARIZE && EXPORT_ES6
       import(e.data.urlOrBlob).then(function({{{ EXPORT_NAME }}}) {
         Module = {{{ EXPORT_NAME }}}.default(Module);
-        postMessage({ cmd: 'loaded' });
+        postMessage({ 'cmd': 'loaded' });
       });
 #else
       if (typeof e.data.urlOrBlob === 'string') {
@@ -151,18 +149,14 @@ this.onmessage = function(e) {
       Module = {{{ EXPORT_NAME }}}(Module);
 #endif
 #endif
-#if !MINIMAL_RUNTIME || MODULARIZE
-      PThread = Module['PThread'];
-      HEAPU32 = Module['HEAPU32'];
-#endif
 
 #if !MINIMAL_RUNTIME || !WASM
-      postMessage({ cmd: 'loaded' });
+      postMessage({ 'cmd': 'loaded' });
 #endif
 
 #endif
     } else if (e.data.cmd === 'objectTransfer') {
-      PThread.receiveObjectTransfer(e.data);
+      Module['PThread'].receiveObjectTransfer(e.data);
     } else if (e.data.cmd === 'run') {
       // This worker was idle, and now should start executing its pthread entry
       // point.
@@ -178,7 +172,7 @@ this.onmessage = function(e) {
       threadInfoStruct = e.data.threadInfoStruct;
 
       // Pass the thread address inside the asm.js scope to store it for fast access that avoids the need for a FFI out.
-      {{{ makeAsmExportsAccessInPthread('__register_pthread_ptr') }}}(threadInfoStruct, /*isMainBrowserThread=*/0, /*isMainRuntimeThread=*/0);
+      Module['__register_pthread_ptr'](threadInfoStruct, /*isMainBrowserThread=*/0, /*isMainRuntimeThread=*/0);
 
       selfThreadId = e.data.selfThreadId;
       parentThreadId = e.data.parentThreadId;
@@ -206,14 +200,14 @@ this.onmessage = function(e) {
       // Also call inside JS module to set up the stack frame for this pthread in JS module scope
       Module['establishStackSpace'](top, max);
 #if WASM_BACKEND
-      {{{ makeAsmExportsAccessInPthread('_emscripten_tls_init') }}}();
+      Module['_emscripten_tls_init']();
 #endif
 #if STACK_OVERFLOW_CHECK
-      {{{ makeAsmExportsAccessInPthread('writeStackCookie') }}}();
+      Module['writeStackCookie']();
 #endif
 
-      PThread.receiveObjectTransfer(e.data);
-      PThread.setThreadStatus({{{ makeAsmExportsAccessInPthread('_pthread_self') }}}(), 1/*EM_THREAD_STATUS_RUNNING*/);
+      Module['PThread'].receiveObjectTransfer(e.data);
+      Module['PThread'].setThreadStatus(Module['_pthread_self'](), 1/*EM_THREAD_STATUS_RUNNING*/);
 
       try {
         // pthread entry points are always of signature 'void *ThreadMain(void *arg)'
@@ -223,26 +217,29 @@ this.onmessage = function(e) {
         // enable that to work. If you find the following line to crash, either change the signature
         // to "proper" void *ThreadMain(void *arg) form, or try linking with the Emscripten linker
         // flag -s EMULATE_FUNCTION_POINTER_CASTS=1 to add in emulation for this x86 ABI extension.
-        var result = {{{ makeAsmExportsAccessInPthread('dynCall_ii') }}}(e.data.start_routine, e.data.arg);
+        var result = Module['dynCall_ii'](e.data.start_routine, e.data.arg);
 
 #if STACK_OVERFLOW_CHECK
-        {{{ makeAsmExportsAccessInPthread('checkStackCookie') }}}();
+        Module['checkStackCookie']();
 #endif
+#if !MINIMAL_RUNTIME // In MINIMAL_RUNTIME the noExitRuntime concept does not apply to pthreads. To exit a pthread with live runtime, use the function emscripten_unwind_to_js_event_loop() in the pthread body.
         // The thread might have finished without calling pthread_exit(). If so, then perform the exit operation ourselves.
         // (This is a no-op if explicit pthread_exit() had been called prior.)
-        if (!Module['getNoExitRuntime']()) PThread.threadExit(result);
+        if (!Module['getNoExitRuntime']())
+#endif
+          Module['PThread'].threadExit(result);
       } catch(ex) {
         if (ex === 'Canceled!') {
-          PThread.threadCancel();
+          Module['PThread'].threadCancel();
         } else if (ex != 'unwind') {
 #if MINIMAL_RUNTIME
           // ExitStatus not present in MINIMAL_RUNTIME
-          Atomics.store(HEAPU32, (threadInfoStruct + 4 /*C_STRUCTS.pthread.threadExitCode*/ ) >> 2, -2 /*A custom entry specific to Emscripten denoting that the thread crashed.*/);
+          Atomics.store(Module['HEAPU32'], (threadInfoStruct + 4 /*C_STRUCTS.pthread.threadExitCode*/ ) >> 2, -2 /*A custom entry specific to Emscripten denoting that the thread crashed.*/);
 #else
-          Atomics.store(HEAPU32, (threadInfoStruct + 4 /*C_STRUCTS.pthread.threadExitCode*/ ) >> 2, (ex instanceof Module['ExitStatus']) ? ex.status : -2 /*A custom entry specific to Emscripten denoting that the thread crashed.*/);
+          Atomics.store(Module['HEAPU32'], (threadInfoStruct + 4 /*C_STRUCTS.pthread.threadExitCode*/ ) >> 2, (ex instanceof Module['ExitStatus']) ? ex.status : -2 /*A custom entry specific to Emscripten denoting that the thread crashed.*/);
 #endif
 
-          Atomics.store(HEAPU32, (threadInfoStruct + 0 /*C_STRUCTS.pthread.threadStatus*/ ) >> 2, 1); // Mark the thread as no longer running.
+          Atomics.store(Module['HEAPU32'], (threadInfoStruct + 0 /*C_STRUCTS.pthread.threadStatus*/ ) >> 2, 1); // Mark the thread as no longer running.
 #if ASSERTIONS
           if (typeof(Module['_emscripten_futex_wake']) !== "function") {
             err("Thread Initialisation failed.");
@@ -251,7 +248,7 @@ this.onmessage = function(e) {
 #endif
           Module['_emscripten_futex_wake'](threadInfoStruct + 0 /*C_STRUCTS.pthread.threadStatus*/, 0x7FFFFFFF/*INT_MAX*/); // Wake all threads waiting on this thread to finish.
 #if MINIMAL_RUNTIME
-          throw e; // ExitStatus not present in MINIMAL_RUNTIME
+          throw ex; // ExitStatus not present in MINIMAL_RUNTIME
 #else
           if (!(ex instanceof Module['ExitStatus'])) throw ex;
 #endif
@@ -264,7 +261,7 @@ this.onmessage = function(e) {
       }
     } else if (e.data.cmd === 'cancel') { // Main thread is asking for a pthread_cancel() on this thread.
       if (threadInfoStruct) {
-        PThread.threadCancel();
+        Module['PThread'].threadCancel();
       }
     } else if (e.data.target === 'setimmediate') {
       // no-op
@@ -279,7 +276,7 @@ this.onmessage = function(e) {
   } catch(ex) {
     console.error('worker.js onmessage() captured an uncaught exception: ' + ex);
     if (ex.stack) console.error(ex.stack);
-    throw e;
+    throw ex;
   }
 };
 
diff --git a/system/lib/libc/musl/src/thread/pthread_cond_timedwait.c b/system/lib/libc/musl/src/thread/pthread_cond_timedwait.c
index ccb49f92dce07..90869b18a503a 100644
--- a/system/lib/libc/musl/src/thread/pthread_cond_timedwait.c
+++ b/system/lib/libc/musl/src/thread/pthread_cond_timedwait.c
@@ -81,6 +81,7 @@ int __pthread_cond_timedwait(pthread_cond_t *restrict c, pthread_mutex_t *restri
 	volatile int *fut;
 
 #ifdef __EMSCRIPTEN__
+	// TODO: Optimize this away in MINIMAL_RUNTIME.
 	if (pthread_self() == emscripten_main_browser_thread_id()) {
 		emscripten_check_blocking_allowed();
 	}
diff --git a/tests/pthread/call_sync_on_main_thread.c b/tests/pthread/call_sync_on_main_thread.c
index 8add11bdd4a93..380c1635f0910 100644
--- a/tests/pthread/call_sync_on_main_thread.c
+++ b/tests/pthread/call_sync_on_main_thread.c
@@ -9,7 +9,7 @@
 #include <assert.h>
 #include <string.h>
 
-extern void getDomElementParentInnerHTML(const char *domElement, char *dst, int size);
+extern void getDomElementContents(const char *domElementSelector, char *dst, int size);
 extern int isThisInWorker(void);
 extern int isThisInWorkerOnMainThread(void);
 extern int receivesAndReturnsAnInteger(int i);
@@ -19,15 +19,15 @@ extern int receivesAndReturnsAnInteger(int i);
 
 int main()
 {
-	char dst[256];
-	char name[7] = "resize";
-	getDomElementParentInnerHTML(name, dst, sizeof(dst));
+	char dst[8192];
+	char name[7] = "body";
+	getDomElementContents(name, dst, sizeof(dst));
 	memset(name, 0, sizeof(name)); // Try to uncover if there might be a race condition and above line was not synchronously processed, and we could take name string away.
 	int inWorker1 = isThisInWorker(); // Build this application with -s USE_PTHREADS=1 -s PROXY_TO_PTHREAD=1 for this to return 1, otherwise returns 0.
 	int inWorker2 = isThisInWorkerOnMainThread(); // This should always return 0
 	int returnedInt = receivesAndReturnsAnInteger(4);
 	printf("text: \"%s\". inWorker1: %d, inWorker2: %d, returnedInt: %d\n", dst, inWorker1, inWorker2, returnedInt);
-	assert(strstr(dst, "Resize canvas"));
+	assert(strstr(dst, "<canvas"));
 	assert(inWorker1 == PROXY_TO_PTHREAD);
 	assert(inWorker2 == 0);
 	assert(returnedInt == 42 + 4);
diff --git a/tests/pthread/call_sync_on_main_thread.js b/tests/pthread/call_sync_on_main_thread.js
index 066a491367681..d9e6abec05fb2 100644
--- a/tests/pthread/call_sync_on_main_thread.js
+++ b/tests/pthread/call_sync_on_main_thread.js
@@ -1,12 +1,12 @@
 mergeInto(LibraryManager.library, {
   // Test accessing a DOM element on the main thread.
-  // This function returns the inner text of the div by ID "status"
+  // This function returns the inner text of the given element
   // Because it accesses the DOM, it must be called on the main thread.
-  getDomElementParentInnerHTML__proxy: 'sync',
-  getDomElementParentInnerHTML__sig: 'viii',
-  getDomElementParentInnerHTML: function(domElementId, dst, size) {
-    var id = UTF8ToString(domElementId);
-    var text = document.getElementById(id).parentElement.innerHTML;
+  getDomElementContents__proxy: 'sync',
+  getDomElementContents__sig: 'viii',
+  getDomElementContents: function(domElementSelector, dst, size) {
+    var selector = UTF8ToString(domElementSelector);
+    var text = document.querySelector(selector).innerHTML;
     stringToUTF8(text, dst, size);
   },
 
@@ -17,12 +17,12 @@ mergeInto(LibraryManager.library, {
   },
 
   isThisInWorker: function() {
-    return ENVIRONMENT_IS_WORKER;
+    return typeof ENVIRONMENT_IS_WORKER !== 'undefined' && ENVIRONMENT_IS_WORKER;
   },
 
   isThisInWorkerOnMainThread__proxy: 'sync',
   isThisInWorkerOnMainThread__sig: 'i',
   isThisInWorkerOnMainThread: function() {
-    return ENVIRONMENT_IS_WORKER;
+    return typeof ENVIRONMENT_IS_WORKER !== 'undefined' && ENVIRONMENT_IS_WORKER;
   }
 });
diff --git a/tests/pthread/test_pthread_mutex.cpp b/tests/pthread/test_pthread_mutex.cpp
index 68000535f2b57..4d8a2d941b2ab 100644
--- a/tests/pthread/test_pthread_mutex.cpp
+++ b/tests/pthread/test_pthread_mutex.cpp
@@ -56,7 +56,7 @@ void CreateThread(int i, int n)
 }
 
 int threadNum = 0;
-void WaitToJoin()
+EM_BOOL WaitToJoin(double time, void *userData)
 {
 	int threadsRunning = 0;
 	// Join all threads.
@@ -88,8 +88,9 @@ void WaitToJoin()
 #ifdef REPORT_RESULT
 		REPORT_RESULT(counter);
 #endif
-		emscripten_cancel_main_loop();
+		return EM_FALSE;
 	}
+	return EM_TRUE;
 }
 
 int main()
@@ -107,7 +108,7 @@ int main()
 		for(int i = 0; i < NUM_THREADS; ++i)
 			CreateThread(i, threadNum++);
 
-		emscripten_set_main_loop(WaitToJoin, 0, 0);
+		emscripten_set_timeout_loop(WaitToJoin, 100, 0);
 	} else {
 #ifdef REPORT_RESULT
 		REPORT_RESULT(50);
diff --git a/tests/test_browser.py b/tests/test_browser.py
index 174fc53dcf416..57993b3455bc2 100644
--- a/tests/test_browser.py
+++ b/tests/test_browser.py
@@ -4578,6 +4578,11 @@ def test_pthread_hello_thread(self):
       for modularize in [[], ['-s', 'MODULARIZE=1', '-s', 'EXPORT_NAME=MyModule', '--shell-file', path_from_root('tests', 'shell_that_launches_modularize.html')]]:
         self.btest(path_from_root('tests', 'pthread', 'hello_thread.c'), expected='1', args=['-s', 'USE_PTHREADS=1'] + modularize + opts)
 
+  def test_minimal_runtime_pthread_hello_thread(self):
+    for opts in [[], ['-O3']]:
+      for modularize in [[], ['-s', 'MODULARIZE=1', '-s', 'EXPORT_NAME=MyModule', '-s', 'MINIMAL_RUNTIME=1']]:
+        self.btest(path_from_root('tests', 'pthread', 'hello_thread.c'), expected='1', args=['-s', 'USE_PTHREADS=1'] + modularize + opts)
+
   # Tests memory growth in pthreads mode, but still on the main thread.
   @requires_threads
   def test_pthread_growth_mainthread(self):
diff --git a/tools/minimal_runtime_shell.py b/tools/minimal_runtime_shell.py
index 639c9e0feaec2..d8e13ac6e5f6d 100644
--- a/tools/minimal_runtime_shell.py
+++ b/tools/minimal_runtime_shell.py
@@ -16,6 +16,8 @@ def generate_minimal_runtime_load_statement(target_basename):
   then_statements = [] # Statements to appear inside a Promise .then() block after loading has finished
   modularize_imports = [] # Import parameters to call the main JS runtime function with
 
+  modularize_not_instance = shared.Settings.MODULARIZE and not shared.Settings.MODULARIZE_INSTANCE
+
   # Depending on whether streaming Wasm compilation is enabled or not, the minimal sized code to download Wasm looks a bit different.
   # Expand {{{ DOWNLOAD_WASM }}} block from here (if we added #define support, this could be done in the template directly)
   if shared.Settings.MINIMAL_RUNTIME_STREAMING_WASM_COMPILATION:
@@ -43,7 +45,7 @@ def generate_minimal_runtime_load_statement(target_basename):
 
   # Download separate memory initializer file .mem
   if shared.Settings.MEM_INIT_METHOD == 1 and not shared.Settings.MEM_INIT_IN_WASM:
-    if shared.Settings.MODULARIZE:
+    if modularize_not_instance:
       modularize_imports += ['mem: r[%d]' % len(files_to_load)]
     else:
       then_statements += ["Module.mem = r[%d];" % len(files_to_load)]
@@ -55,26 +57,26 @@ def generate_minimal_runtime_load_statement(target_basename):
 
   # Download .wasm file
   if shared.Settings.WASM == 1 or not download_wasm:
-    if shared.Settings.MODULARIZE:
+    if modularize_not_instance:
       modularize_imports += ['wasm: r[%d]' % len(files_to_load)]
     else:
       then_statements += ["Module.wasm = r[%d];" % len(files_to_load)]
     if download_wasm:
       files_to_load += [download_wasm]
 
-  if shared.Settings.MODULARIZE and shared.Settings.USE_PTHREADS:
+  if modularize_not_instance and shared.Settings.USE_PTHREADS:
     modularize_imports += ["worker: '{{{ PTHREAD_WORKER_FILE }}}'"]
 
   # Download Wasm2JS code if target browser does not support WebAssembly
   if shared.Settings.WASM == 2:
-    if shared.Settings.MODULARIZE:
+    if modularize_not_instance:
       modularize_imports += ['wasm: supportsWasm ? r[%d] : 0' % len(files_to_load)]
     else:
       then_statements += ["if (supportsWasm) Module.wasm = r[%d];" % len(files_to_load)]
     files_to_load += ["supportsWasm ? %s : script('%s')" % (download_wasm, target_basename + '.wasm.js')]
 
   # Execute compiled output when building with MODULARIZE
-  if shared.Settings.MODULARIZE:
+  if modularize_not_instance:
     then_statements += ['''// Detour the JS code to a separate variable to avoid instantiating with 'r' array as "this" directly to avoid strict ECMAScript/Firefox GC problems that cause a leak, see https://bugzilla.mozilla.org/show_bug.cgi?id=1540101
   var js = r[0];\n  js({ %s });''' % ',\n  '.join(modularize_imports)]
 
@@ -94,7 +96,7 @@ def generate_minimal_runtime_load_statement(target_basename):
       var s = document.createElement('script');
       s.src = url;
       s.onload = () => {
-#if MODULARIZE && WASM == 2
+#if MODULARIZE && !MODULARIZE_INSTANCE && WASM == 2
         // In MODULARIZEd WASM==2 builds, we use this same function to download
         // both .js and .asm.js that are structured with {{{ EXPORT_NAME }}}
         // at the top level, but also use this function to download the Wasm2JS
@@ -108,7 +110,7 @@ def generate_minimal_runtime_load_statement(target_basename):
           ok();
         }
 #else
-#if MODULARIZE
+#if MODULARIZE && !MODULARIZE_INSTANCE
         var c = {{{ EXPORT_NAME }}};
         delete {{{ EXPORT_NAME }}};
         ok(c);
@@ -124,12 +126,12 @@ def generate_minimal_runtime_load_statement(target_basename):
 
   # Only one file to download - no need to use Promise.all()
   if len(files_to_load) == 1:
-    if shared.Settings.MODULARIZE:
+    if modularize_not_instance:
       return script_xhr + files_to_load[0] + ".then((js) => {\n  js();\n});"
     else:
       return script_xhr + files_to_load[0] + ";"
 
-  if not shared.Settings.MODULARIZE:
+  if not modularize_not_instance:
     # If downloading multiple files like .wasm or .mem, those need to be loaded in
     # before we can add the main runtime script to the DOM, so convert the main .js
     # script load from direct script() load to a binary() load so we can still

From 1a0d4e2b7995cc9f57d724c1ef830143910e354c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Tue, 11 Feb 2020 16:18:38 +0200
Subject: [PATCH 14/27] Fix Closure error

---
 src/closure-externs.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/closure-externs.js b/src/closure-externs.js
index 6f8b8ccdb97fc..2c1a10cb9cd30 100644
--- a/src/closure-externs.js
+++ b/src/closure-externs.js
@@ -983,6 +983,7 @@ var devicePixelRatio;
 // the names need to match:
 var threadInfoStruct;
 var selfThreadId;
+/** @suppress {duplicate} */
 var noExitRuntime;
 
 // Technically only needed for MINIMAL_RUNTIME use of USE_PTHREADS + !MODULARIZE, but enabled here for all modes for now.

From ddd2ff8ecd20ad5adfc668c9f6f22a1b63e670fe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Tue, 11 Feb 2020 16:28:19 +0200
Subject: [PATCH 15/27] Separate MINIMAL_RUNTIME + USE_PTHREADS + !MODULARIZE
 externs to its own file.

---
 src/closure-externs.js                | 5 -----
 src/minimal_runtime_worker_externs.js | 6 ++++++
 tools/shared.py                       | 2 ++
 3 files changed, 8 insertions(+), 5 deletions(-)
 create mode 100644 src/minimal_runtime_worker_externs.js

diff --git a/src/closure-externs.js b/src/closure-externs.js
index 2c1a10cb9cd30..c3ce6e76cabac 100644
--- a/src/closure-externs.js
+++ b/src/closure-externs.js
@@ -985,8 +985,3 @@ var threadInfoStruct;
 var selfThreadId;
 /** @suppress {duplicate} */
 var noExitRuntime;
-
-// Technically only needed for MINIMAL_RUNTIME use of USE_PTHREADS + !MODULARIZE, but enabled here for all modes for now.
-var ENVIRONMENT_IS_PTHREAD;
-/** @suppress {duplicate} */
-var wasmMemory;
diff --git a/src/minimal_runtime_worker_externs.js b/src/minimal_runtime_worker_externs.js
new file mode 100644
index 0000000000000..37bfaa3ee5336
--- /dev/null
+++ b/src/minimal_runtime_worker_externs.js
@@ -0,0 +1,6 @@
+// These externs are needed for MINIMAL_RUNTIME + USE_PTHREADS + !MODULARIZE
+// This file should go away in the future when worker.js is refactored to live inside the JS module.
+
+var ENVIRONMENT_IS_PTHREAD;
+/** @suppress {duplicate} */
+var wasmMemory;
diff --git a/tools/shared.py b/tools/shared.py
index d38bb80b2ce3f..ff41525f916ce 100644
--- a/tools/shared.py
+++ b/tools/shared.py
@@ -2437,6 +2437,8 @@ def add_to_path(dirname):
                              if name.endswith('.js')]
           CLOSURE_EXTERNS += BROWSER_EXTERNS
 
+      if Settings.MINIMAL_RUNTIME and Settings.USE_PTHREADS and not Settings.MODULARIZE:
+        CLOSURE_EXTERNS += [path_from_root('src', 'minimal_runtime_worker_externs.js')]
       outfile = filename + '.cc.js'
 
       args = ['--compilation_level', 'ADVANCED_OPTIMIZATIONS' if advanced else 'SIMPLE_OPTIMIZATIONS',

From ef424d91bc9323b0d7e9f728e68610d6839aa376 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Tue, 11 Feb 2020 16:48:01 +0200
Subject: [PATCH 16/27] Remove unused function makeAsmImportsAccessInPthread

---
 src/parseTools.js | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/src/parseTools.js b/src/parseTools.js
index 63248e41988c3..de2c8cb11281d 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -1659,16 +1659,6 @@ function buildStringArray(array) {
   }
 }
 
-// Generates access to a JS exports scope variable in pthreads worker.js. In MODULARIZE mode the JS scope is not directly accessible, so all the relevant variables
-// are exported via Module. In non-MODULARIZE mode, we can directly access the variables in global scope.
-function makeAsmExportsAccessInPthread(variable) {
-  if (MODULARIZE || !MINIMAL_RUNTIME) {
-    return "Module['" + variable + "']"; // 'Module' is defined in worker.js local scope, so not EXPORT_NAME in this case.
-  } else {
-    return variable;
-  }
-}
-
 // Generates access to a JS imports scope variable in pthreads worker.js. In MODULARIZE mode these flow into the imports object for the Module.
 // In non-MODULARIZE mode, we can directly access the variables in global scope.
 function makeAsmImportsAccessInPthread(variable) {

From e09448fd905d9ecfaa8b9b03f5288fde60fcedb0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Tue, 11 Feb 2020 16:51:03 +0200
Subject: [PATCH 17/27] Remove unused STREAMING_WASM_COMPILATION

---
 src/settings.js | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/settings.js b/src/settings.js
index c0c36cd0dfce1..badeb2e65b8e3 100644
--- a/src/settings.js
+++ b/src/settings.js
@@ -1291,12 +1291,6 @@ var WASM_MEM_MAX = -1;
 // (This option was formerly called BINARYEN_ASYNC_COMPILATION)
 var WASM_ASYNC_COMPILATION = 1;
 
-// If set to 1, MINIMAL_RUNTIME will utilize streaming WebAssembly compilation
-// (via WebAssembly.instantiateStreaming). This requires the MIME type of the
-// application to be set correctly. If set to 0, non-streaming compilation
-// (via WebAssembly.instantiate) will be used.
-var STREAMING_WASM_COMPILATION = 1;
-
 // WebAssembly defines a "producers section" which compilers and tools can
 // annotate themselves in. Emscripten does not emit this by default, as it
 // increases code size, and some users may not want information about their tools

From 46e4e032c8d234e73577dbccf8c0d58f5a37c582 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Tue, 11 Feb 2020 19:35:39 +0200
Subject: [PATCH 18/27] More closure externs

---
 src/closure-externs.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/closure-externs.js b/src/closure-externs.js
index c3ce6e76cabac..b41ed0ba35fc8 100644
--- a/src/closure-externs.js
+++ b/src/closure-externs.js
@@ -981,7 +981,9 @@ var devicePixelRatio;
 
 // Variables that are present in both output runtime .js file/JS lib files, and worker.js, so cannot be minified because
 // the names need to match:
+/** @suppress {duplicate} */
 var threadInfoStruct;
+/** @suppress {duplicate} */
 var selfThreadId;
 /** @suppress {duplicate} */
 var noExitRuntime;

From 374ab6dcb637298662ae45fbd2ef3642f7f21516 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Wed, 12 Feb 2020 10:00:32 +0200
Subject: [PATCH 19/27] Update call_sync_on_main_thread test

---
 tests/pthread/call_sync_on_main_thread.c  | 7 ++++---
 tests/pthread/call_sync_on_main_thread.js | 5 +++--
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/tests/pthread/call_sync_on_main_thread.c b/tests/pthread/call_sync_on_main_thread.c
index 380c1635f0910..227111f8dde99 100644
--- a/tests/pthread/call_sync_on_main_thread.c
+++ b/tests/pthread/call_sync_on_main_thread.c
@@ -8,8 +8,9 @@
 #include <stdio.h>
 #include <assert.h>
 #include <string.h>
+#include <stdlib.h>
 
-extern void getDomElementContents(const char *domElementSelector, char *dst, int size);
+extern const char *getDomElementContents(const char *domElementSelector);
 extern int isThisInWorker(void);
 extern int isThisInWorkerOnMainThread(void);
 extern int receivesAndReturnsAnInteger(int i);
@@ -19,15 +20,15 @@ extern int receivesAndReturnsAnInteger(int i);
 
 int main()
 {
-	char dst[8192];
 	char name[7] = "body";
-	getDomElementContents(name, dst, sizeof(dst));
+	const char *dst = getDomElementContents(name);
 	memset(name, 0, sizeof(name)); // Try to uncover if there might be a race condition and above line was not synchronously processed, and we could take name string away.
 	int inWorker1 = isThisInWorker(); // Build this application with -s USE_PTHREADS=1 -s PROXY_TO_PTHREAD=1 for this to return 1, otherwise returns 0.
 	int inWorker2 = isThisInWorkerOnMainThread(); // This should always return 0
 	int returnedInt = receivesAndReturnsAnInteger(4);
 	printf("text: \"%s\". inWorker1: %d, inWorker2: %d, returnedInt: %d\n", dst, inWorker1, inWorker2, returnedInt);
 	assert(strstr(dst, "<canvas"));
+	free((void*)dst);
 	assert(inWorker1 == PROXY_TO_PTHREAD);
 	assert(inWorker2 == 0);
 	assert(returnedInt == 42 + 4);
diff --git a/tests/pthread/call_sync_on_main_thread.js b/tests/pthread/call_sync_on_main_thread.js
index d9e6abec05fb2..3ffcb2f1639e7 100644
--- a/tests/pthread/call_sync_on_main_thread.js
+++ b/tests/pthread/call_sync_on_main_thread.js
@@ -4,10 +4,11 @@ mergeInto(LibraryManager.library, {
   // Because it accesses the DOM, it must be called on the main thread.
   getDomElementContents__proxy: 'sync',
   getDomElementContents__sig: 'viii',
-  getDomElementContents: function(domElementSelector, dst, size) {
+  getDomElementContents__deps: ['$stringToNewUTF8'],
+  getDomElementContents: function(domElementSelector) {
     var selector = UTF8ToString(domElementSelector);
     var text = document.querySelector(selector).innerHTML;
-    stringToUTF8(text, dst, size);
+    return stringToNewUTF8(text);
   },
 
   receivesAndReturnsAnInteger__proxy: 'sync',

From a2dd850341ca95814c02ec9a197b36ba3bb64027 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Wed, 12 Feb 2020 10:04:58 +0200
Subject: [PATCH 20/27] Fix emscripten_check_blocking_allowed

---
 src/library_pthread.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/library_pthread.js b/src/library_pthread.js
index 4946ceb6c3cd8..aaf37f1ef5db0 100644
--- a/src/library_pthread.js
+++ b/src/library_pthread.js
@@ -786,6 +786,8 @@ var LibraryPThread = {
     if (ENVIRONMENT_IS_NODE) return;
 #endif
 
+    if (ENVIRONMENT_IS_PTHREAD) return; // Blocking in a pthread is fine.
+
     warnOnce('Blocking on the main thread is very dangerous, see https://emscripten.org/docs/porting/pthreads.html#blocking-on-the-main-browser-thread');
 #if !ALLOW_BLOCKING_ON_MAIN_THREAD
     abort('Blocking on the main thread is not allowed by default. See https://emscripten.org/docs/porting/pthreads.html#blocking-on-the-main-browser-thread');

From 4b8e4c5aa0b9574d014a35001187d3ddd14ed8da Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Wed, 12 Feb 2020 14:02:26 +0200
Subject: [PATCH 21/27] Restore asm.js specific function for setting the stack
 frame

---
 emscripten.py          | 14 ++++++++++++++
 src/library_pthread.js |  8 +++++++-
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/emscripten.py b/emscripten.py
index 9efbe7a4fc930..695b08b7f71d2 100644
--- a/emscripten.py
+++ b/emscripten.py
@@ -943,6 +943,8 @@ def get_exported_implemented_functions(all_exported_functions, all_implemented,
     funcs.append('_emscripten_replace_memory')
   if not shared.Settings.SIDE_MODULE and not shared.Settings.MINIMAL_RUNTIME:
     funcs += ['stackAlloc', 'stackSave', 'stackRestore']
+  if shared.Settings.USE_PTHREADS:
+    funcs += ['asmJsEstablishStackFrame']
 
   if shared.Settings.EMTERPRETIFY:
     funcs += ['emterpret']
@@ -1887,6 +1889,18 @@ def create_runtime_funcs_asmjs(exports, metadata):
     # MINIMAL_RUNTIME moves stack functions to library.
     funcs = []
 
+  if shared.Settings.USE_PTHREADS:
+    funcs.append('''
+function asmJsEstablishStackFrame(stackBase, stackMax) {
+  stackBase = stackBase|0;
+  stackMax = stackMax|0;
+  STACKTOP = stackBase;
+  STACK_MAX = stackMax;
+  tempDoublePtr = STACKTOP;
+  STACKTOP = (STACKTOP + 8)|0;
+}
+''')
+
   if shared.Settings.EMTERPRETIFY:
     funcs.append('''
 function emterpret(pc) { // this will be replaced when the emterpreter code is generated; adding it here allows validation until then
diff --git a/src/library_pthread.js b/src/library_pthread.js
index aaf37f1ef5db0..4dfc203095175 100644
--- a/src/library_pthread.js
+++ b/src/library_pthread.js
@@ -1343,8 +1343,14 @@ var LibraryPThread = {
 #if STACK_OVERFLOW_CHECK
     writeStackCookie();
 #endif
-    // Call inside asm.js/wasm module to set up the stack frame for this pthread in asm.js/wasm module scope
+
+#if WASM_BACKEND
+    // Call inside wasm module to set up the stack frame for this pthread in asm.js/wasm module scope
     stackRestore(stackTop);
+#else
+    // In old asm.js backend, use a dedicated function to establish the stack frame.
+    asmJsEstablishStackFrame(stackTop, stackMax);
+#endif
   },
 
   // allow pthreads to check if noExitRuntime from worker.js

From 26395c758bef6e73aec908ce84c241a3c0931984 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Wed, 12 Feb 2020 15:31:45 +0200
Subject: [PATCH 22/27] Add phread exports to MINIMAL_RUNTIME

---
 src/postamble_minimal.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/postamble_minimal.js b/src/postamble_minimal.js
index d7a121083fc3d..2b4023264b579 100644
--- a/src/postamble_minimal.js
+++ b/src/postamble_minimal.js
@@ -193,6 +193,8 @@ WebAssembly.instantiate(Module['wasm'], imports).then(function(output) {
 #endif
   Module['HEAPU32'] = HEAPU32;
   Module['dynCall_ii'] = dynCall_ii;
+  Module['__register_pthread_ptr'] = __register_pthread_ptr;
+  Module['_pthread_self'] = _pthread_self;
 #endif
 
   initRuntime(asm);

From eac77f1b76047ca83259483a89c126c8eea8ebbf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Wed, 12 Feb 2020 16:59:00 +0200
Subject: [PATCH 23/27] Remove removeEmptyElements(x) as redundant

---
 src/modules.js | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/src/modules.js b/src/modules.js
index 2b18d4dfa8de6..ad415979ce271 100644
--- a/src/modules.js
+++ b/src/modules.js
@@ -516,16 +516,11 @@ function exportRuntime() {
       }
     }
   }
-  function removeEmptyElements(x) {
-    return x.filter(function(e) {
-      return e != null;
-    })
-  }
-  return removeEmptyElements(runtimeElements.map(function(name) {
+  return runtimeElements.map(function(name) {
     return maybeExport(name);
-  })).join('\n') + removeEmptyElements(runtimeNumbers.map(function(name) {
+  }).join('\n') + runtimeNumbers.map(function(name) {
     return maybeExportNumber(name);
-  })).join('\n');
+  }).join('\n');
 }
 
 var PassManager = {

From 9188ac7e4de79f84bd00520ce9178020ee1ba299 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Wed, 12 Feb 2020 17:04:59 +0200
Subject: [PATCH 24/27] Remove duplicate MINIMAL_RUNTIME pthread test

---
 tests/test_browser.py | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/tests/test_browser.py b/tests/test_browser.py
index 57993b3455bc2..35c88fd2f7569 100644
--- a/tests/test_browser.py
+++ b/tests/test_browser.py
@@ -4578,7 +4578,8 @@ def test_pthread_hello_thread(self):
       for modularize in [[], ['-s', 'MODULARIZE=1', '-s', 'EXPORT_NAME=MyModule', '--shell-file', path_from_root('tests', 'shell_that_launches_modularize.html')]]:
         self.btest(path_from_root('tests', 'pthread', 'hello_thread.c'), expected='1', args=['-s', 'USE_PTHREADS=1'] + modularize + opts)
 
-  def test_minimal_runtime_pthread_hello_thread(self):
+  # Tests that a pthreads build of -s MINIMAL_RUNTIME=1 works well in different build modes
+  def test_minimal_runtime_hello_pthread(self):
     for opts in [[], ['-O3']]:
       for modularize in [[], ['-s', 'MODULARIZE=1', '-s', 'EXPORT_NAME=MyModule', '-s', 'MINIMAL_RUNTIME=1']]:
         self.btest(path_from_root('tests', 'pthread', 'hello_thread.c'), expected='1', args=['-s', 'USE_PTHREADS=1'] + modularize + opts)
@@ -4932,11 +4933,6 @@ def test_minimal_runtime_hello_world(self):
     for args in [[], ['-s', 'MINIMAL_RUNTIME_STREAMING_WASM_COMPILATION=1', '--closure', '1'], ['-s', 'MINIMAL_RUNTIME_STREAMING_WASM_INSTANTIATION=1', '--closure', '1']]:
       self.btest(path_from_root('tests', 'small_hello_world.c'), '0', args=args + ['-s', 'MINIMAL_RUNTIME=1'])
 
-  # Tests that a pthreads build of -s MINIMAL_RUNTIME=1 works well in different build modes
-  def test_minimal_runtime_hello_pthread(self):
-    for args in [[], ['-s', 'MODULARIZE=1']]:
-      self.btest(path_from_root('tests', 'pthread', 'hello_thread.c'), '1', args=args + ['-s', 'MINIMAL_RUNTIME=1', '-s', 'USE_PTHREADS=1'])
-
   @requires_threads
   @no_fastcomp('offset converter is not supported on fastcomp')
   def test_offset_converter(self, *args):

From ad9e79ceaea8e9b4a9526b18910828016c874c21 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Fri, 14 Feb 2020 08:46:21 +0200
Subject: [PATCH 25/27] Add deduplication of JS library files

---
 src/modules.js | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/modules.js b/src/modules.js
index ad415979ce271..e09e3104fd883 100644
--- a/src/modules.js
+++ b/src/modules.js
@@ -158,7 +158,10 @@ var LibraryManager = {
 
     if (BOOTSTRAPPING_STRUCT_INFO) libraries = ['library_bootstrap_structInfo.js', 'library_formatString.js'];
 
-    // TODO: deduplicate libraries (not needed for correctness, but avoids unnecessary work)
+    // Deduplicate libraries to avoid processing any library file multiple times
+    libraries = libraries.filter(function(item, pos) {
+      return libraries.indexOf(item) == pos;
+    });
 
     // Save the list for has() queries later.
     this.libraries = libraries;

From eea85f6acfedb381af2dffd858ce28ef01c85650 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Fri, 14 Feb 2020 08:50:04 +0200
Subject: [PATCH 26/27] makeAsmImportsAccessInPthread('wasm')

---
 src/worker.js | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/worker.js b/src/worker.js
index a9e64bf82086b..0ed3a410af3d1 100644
--- a/src/worker.js
+++ b/src/worker.js
@@ -89,11 +89,7 @@ this.onmessage = function(e) {
 #if WASM
       // Module and memory were sent from main thread
 #if MINIMAL_RUNTIME
-#if MODULARIZE
-      imports['wasm'] = e.data.wasmModule; // Pass the shared Wasm module in an imports object for the MODULARIZEd build.
-#else
-      Module['wasm'] = e.data.wasmModule; // Pass the shared Wasm module in the Module object for MINIMAL_RUNTIME.
-#endif
+      {{{ makeAsmImportsAccessInPthread('wasm') }}} = e.data.wasmModule;
 #else
       Module['wasmModule'] = e.data.wasmModule;
 #endif

From 61d0ea0bd1ae0ec614155b61b1c149b6321e67f6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jukka=20Jyl=C3=A4nki?= <jujjyl@gmail.com>
Date: Fri, 14 Feb 2020 10:45:56 +0200
Subject: [PATCH 27/27] Address review

---
 src/worker.js | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/worker.js b/src/worker.js
index 0ed3a410af3d1..5c11d3e6fb742 100644
--- a/src/worker.js
+++ b/src/worker.js
@@ -89,7 +89,11 @@ this.onmessage = function(e) {
 #if WASM
       // Module and memory were sent from main thread
 #if MINIMAL_RUNTIME
-      {{{ makeAsmImportsAccessInPthread('wasm') }}} = e.data.wasmModule;
+#if MODULARIZE
+      imports['wasm'] = e.data.wasmModule; // Pass the shared Wasm module in an imports object for the MODULARIZEd build.
+#else
+      Module['wasm'] = e.data.wasmModule; // Pass the shared Wasm module in the Module object for MINIMAL_RUNTIME.
+#endif
 #else
       Module['wasmModule'] = e.data.wasmModule;
 #endif
@@ -147,6 +151,9 @@ this.onmessage = function(e) {
 #endif
 
 #if !MINIMAL_RUNTIME || !WASM
+      // MINIMAL_RUNTIME always compiled Wasm (&Wasm2JS) asynchronously, even in pthreads. But
+      // regular runtime and asm.js are loaded synchronously, so in those cases
+      // we are now loaded, and can post back to main thread.
       postMessage({ 'cmd': 'loaded' });
 #endif