Remove ENVIRONMENT_IS_PTHREAD variable. The existence of this variable predates to the time when pthreads still supported --proxy-to-worker mode (and --proxy-to-pthread did not exist). After --proxy-to-pthread has proven itself as a more usable method and USE_PTHREADS + --proxy-to-worker was deprecated, there is no longer need to distinguish between "am I a worker" or "am I a pthread", as all workers are pthreads, and the scenario "worker that is the proxied main thread so not a pthread" no longer happens.

Author: juj

emscripten.py

@@ -827,7 +827,7 @@ def memory_and_global_initializers(pre, metadata, mem_init):
 
   pthread = ''
   if shared.Settings.USE_PTHREADS:
-    pthread = 'if (!ENVIRONMENT_IS_PTHREAD)'
+    pthread = 'if (!ENVIRONMENT_IS_WORKER)'
 
   global_initializers = ''
   if not shared.Settings.MINIMAL_RUNTIME:
@@ -977,7 +977,7 @@ def include_asm_consts(pre, forwarded_json, metadata):
         # indices to EM_ASM() blocks, so remap the EM_ASM() indices from 0, 1, 2,
         # ... over to the negative integers starting at -1.
         proxy_args = ['-1 - code', str(int(sync_proxy))] + args
-        pre_asm_const += '  if (ENVIRONMENT_IS_PTHREAD) { ' + proxy_debug_print(sync_proxy) + 'return _emscripten_proxy_to_main_thread_js(' + ', '.join(proxy_args) + '); }\n'
+        pre_asm_const += '  if (ENVIRONMENT_IS_WORKER) { ' + proxy_debug_print(sync_proxy) + 'return _emscripten_proxy_to_main_thread_js(' + ', '.join(proxy_args) + '); }\n'
 
     if shared.Settings.EMTERPRETIFY_ASYNC and shared.Settings.ASSERTIONS:
       # we cannot have an EM_ASM on the stack when saving/loading
@@ -2211,7 +2211,7 @@ def emscript_wasm_backend(infile, outfile, memfile, compiler_engine,
   pre = pre.replace('STATICTOP = STATIC_BASE + 0;', '''STATICTOP = STATIC_BASE + %d;
 /* global initializers */ %s __ATINIT__.push(%s);
 ''' % (staticbump,
-       'if (!ENVIRONMENT_IS_PTHREAD)' if shared.Settings.USE_PTHREADS else '',
+       'if (!ENVIRONMENT_IS_WORKER)' if shared.Settings.USE_PTHREADS else '',
        global_initializers))
 
   pre = apply_memory(pre)
@@ -2402,7 +2402,7 @@ def create_asm_consts_wasm(forwarded_json, metadata):
         # to regular C compiled functions. Negative integers -1, -2, -3, ... denote
         # indices to EM_ASM() blocks, so remap the EM_ASM() indices from 0, 1, 2,
         # ... over to the negative integers starting at -1.
-        preamble += ('\n  if (ENVIRONMENT_IS_PTHREAD) { ' +
+        preamble += ('\n  if (ENVIRONMENT_IS_WORKER) { ' +
                      proxy_debug_print(sync_proxy) +
                      'return _emscripten_proxy_to_main_thread_js(-1 - code, ' +
                      str(int(sync_proxy)) +

src/Fetch.js

@@ -52,7 +52,7 @@ var Fetch = {
 
   staticInit: function() {
 #if USE_FETCH_WORKER
-    var isMainThread = (typeof ENVIRONMENT_IS_FETCH_WORKER === 'undefined' && !ENVIRONMENT_IS_PTHREAD);
+    var isMainThread = (typeof ENVIRONMENT_IS_FETCH_WORKER === 'undefined' && !ENVIRONMENT_IS_WORKER);
 #else
     var isMainThread = (typeof ENVIRONMENT_IS_FETCH_WORKER === 'undefined');
 #endif

src/emrun_postjs.js

@@ -3,7 +3,7 @@
 // University of Illinois/NCSA Open Source License.  Both these licenses can be
 // found in the LICENSE file.
 
-if (typeof window === "object" && (typeof ENVIRONMENT_IS_PTHREAD === 'undefined' || !ENVIRONMENT_IS_PTHREAD)) {
+if (typeof window === "object" && (typeof ENVIRONMENT_IS_WORKER === 'undefined' || !ENVIRONMENT_IS_WORKER)) {
   function emrun_register_handlers() {
     // When C code exit()s, we may still have remaining stdout and stderr messages in flight. In that case, we can't close
     // the browser until all those XHRs have finished, so the following state variables track that all communication is done,

src/fetch-worker.js

@@ -47,7 +47,6 @@ function store4(ptr, value) { HEAP32[ptr>>2] = value; }
 
 var ENVIRONMENT_IS_FETCH_WORKER = true;
 var ENVIRONMENT_IS_WORKER = true;
-var ENVIRONMENT_IS_PTHREAD = true;
 var __pthread_is_main_runtime_thread=0;
 var DYNAMICTOP_PTR = 0;
 var nan = NaN;

src/jsifier.js

@@ -281,7 +281,7 @@ function JSify(data, functionsOnly) {
           assert(typeof original === 'function');
           contentText = modifyFunction(snippet, function(name, args, body) {
             return 'function ' + name + '(' + args + ') {\n' +
-                   'if (ENVIRONMENT_IS_PTHREAD) return _emscripten_proxy_to_main_thread_js(' + proxiedFunctionTable.length + ', ' + (+sync) + (args ? ', ' : '') + args + ');\n' + body + '}\n';
+                   'if (ENVIRONMENT_IS_WORKER) return _emscripten_proxy_to_main_thread_js(' + proxiedFunctionTable.length + ', ' + (+sync) + (args ? ', ' : '') + args + ');\n' + body + '}\n';
           });
           proxiedFunctionTable.push(finalName);
         } else {
@@ -411,7 +411,7 @@ function JSify(data, functionsOnly) {
         });
         // write out the singleton big memory initialization value
         if (USE_PTHREADS) {
-          print('if (!ENVIRONMENT_IS_PTHREAD) {') // Pthreads should not initialize memory again, since it's shared with the main thread.
+          print('if (!ENVIRONMENT_IS_WORKER) {') // Pthreads should not initialize memory again, since it's shared with the main thread.
         }
         print('/* memory initializer */ ' + makePointer(memoryInitialization, null, 'ALLOC_NONE', 'i8', 'GLOBAL_BASE' + (SIDE_MODULE ? '+H_BASE' : ''), true));
         if (USE_PTHREADS) {
@@ -424,7 +424,7 @@ function JSify(data, functionsOnly) {
       if (!SIDE_MODULE && !WASM_BACKEND) {
         if (USE_PTHREADS) {
           print('var tempDoublePtr;');
-          print('if (!ENVIRONMENT_IS_PTHREAD) tempDoublePtr = ' + makeStaticAlloc(12) + ';');
+          print('if (!ENVIRONMENT_IS_WORKER) tempDoublePtr = ' + makeStaticAlloc(12) + ';');
         } else {
           print('var tempDoublePtr = ' + makeStaticAlloc(8) + '');
         }

src/library.js

@@ -4006,7 +4006,7 @@ LibraryManager.library = {
 #endif
 #if USE_PTHREADS
 // Pthreads need their clocks synchronized to the execution of the main thread, so give them a special form of the function.
-                               "if (ENVIRONMENT_IS_PTHREAD) {\n" +
+                               "if (ENVIRONMENT_IS_WORKER) {\n" +
                                "  _emscripten_get_now = function() { return performance['now']() - __performance_now_clock_drift; };\n" +
                                "} else " +
 #endif

src/library_browser.js

@@ -1082,7 +1082,7 @@ var LibraryBrowser = {
     onerror = getFuncWrapper(onerror, 'v');
 
 #if USE_PTHREADS
-    if (ENVIRONMENT_IS_PTHREAD) {
+    if (ENVIRONMENT_IS_WORKER) {
       console.error('emscripten_async_load_script("' + UTF8ToString(url) + '") failed, emscripten_async_load_script is currently not available in pthreads!');
       return onerror ? onerror() : undefined;
     }

src/library_fetch.js

@@ -7,7 +7,7 @@
 
 var LibraryFetch = {
 #if USE_PTHREADS
-  $Fetch__postset: 'if (!ENVIRONMENT_IS_PTHREAD) Fetch.staticInit();',
+  $Fetch__postset: 'if (!ENVIRONMENT_IS_WORKER) Fetch.staticInit();',
 #else
   $Fetch__postset: 'Fetch.staticInit();',
 #endif

src/library_html5.js

@@ -2399,7 +2399,7 @@ var LibraryJSEvents = {
 
 #if (USE_PTHREADS && OFFSCREEN_FRAMEBUFFER)
     // Create a WebGL context that is proxied to main thread if canvas was not found on worker, or if explicitly requested to do so.
-    if (ENVIRONMENT_IS_PTHREAD) {
+    if (ENVIRONMENT_IS_WORKER) {
       if (contextAttributes.proxyContextToMainThread === {{{ cDefine('EMSCRIPTEN_WEBGL_CONTEXT_PROXY_ALWAYS') }}} ||
          (!canvas && contextAttributes.proxyContextToMainThread === {{{ cDefine('EMSCRIPTEN_WEBGL_CONTEXT_PROXY_FALLBACK') }}})) {
         // When WebGL context is being proxied via the main thread, we must render using an offscreen FBO render target to avoid WebGL's
@@ -2722,7 +2722,7 @@ var LibraryJSEvents = {
 #if USE_PTHREADS && ASSERTIONS && OFFSCREENCANVAS_SUPPORT
     // TODO: for Offscreencanvas case, must first search locally in the calling thread if the given context is an OffscreenCanvas context on the calling thread,
     // and only if it's not, then try to proxy the call to main thread. I.e. this function cannot be unconditionally 'sync' proxied.
-    if (ENVIRONMENT_IS_PTHREAD) warnOnce('TODO: emscripten_is_webgl_context_lost() does not yet work properly in pthreads with OffscreenCanvas contexts');
+    if (ENVIRONMENT_IS_WORKER) warnOnce('TODO: emscripten_is_webgl_context_lost() does not yet work properly in pthreads with OffscreenCanvas contexts');
 #endif
     return !GL.contexts[target] || GL.contexts[target].GLctx.isContextLost(); // No context ~> lost context.
   },

src/library_pthread.js

@@ -4,7 +4,7 @@
 // found in the LICENSE file.
 
 var LibraryPThread = {
-  $PThread__postset: 'if (!ENVIRONMENT_IS_PTHREAD) PThread.initMainThreadBlock(); else PThread.initWorker();',
+  $PThread__postset: 'if (!ENVIRONMENT_IS_WORKER) PThread.initMainThreadBlock(); else PThread.initWorker();',
   $PThread__deps: ['$PROCINFO', '_register_pthread_ptr',
                    'emscripten_main_thread_process_queued_calls',
                    '$ERRNO_CODES', 'emscripten_futex_wake', '_kill_thread',
@@ -35,7 +35,7 @@ var LibraryPThread = {
       _emscripten_register_main_browser_thread_id(PThread.mainThreadBlock);
     },
     initMainThreadBlock: function() {
-      if (ENVIRONMENT_IS_PTHREAD) return undefined;
+      if (ENVIRONMENT_IS_WORKER) return undefined;
 
 #if PTHREAD_POOL_SIZE > 0
       var requestedPoolSize = {{{ PTHREAD_POOL_SIZE }}};
@@ -161,7 +161,7 @@ var LibraryPThread = {
       }
 
       // Call into the musl function that runs destructors of all thread-specific data.
-      if (ENVIRONMENT_IS_PTHREAD && threadInfoStruct) ___pthread_tsd_run_dtors();
+      if (ENVIRONMENT_IS_WORKER && threadInfoStruct) ___pthread_tsd_run_dtors();
     },
 
     // Called when we are performing a pthread_exit(), either explicitly called by programmer,
@@ -188,7 +188,7 @@ var LibraryPThread = {
         _emscripten_futex_wake(tb + {{{ C_STRUCTS.pthread.threadStatus }}}, {{{ cDefine('INT_MAX') }}});
         __register_pthread_ptr(0, 0, 0); // Unregister the thread block also inside the asm.js scope.
         threadInfoStruct = 0;
-        if (ENVIRONMENT_IS_PTHREAD) {
+        if (ENVIRONMENT_IS_WORKER) {
           // Note: in theory we would like to return any offscreen canvases back to the main thread,
           // but if we ever fetched a rendering context for them that would not be valid, so we don't try.
           postMessage({ 'cmd': 'exit' });
@@ -483,7 +483,7 @@ var LibraryPThread = {
   },
 
   _kill_thread: function(pthread_ptr) {
-    if (ENVIRONMENT_IS_PTHREAD) throw 'Internal Error! _kill_thread() can only ever be called from main application thread!';
+    if (ENVIRONMENT_IS_WORKER) throw 'Internal Error! _kill_thread() can only ever be called from main application thread!';
     if (!pthread_ptr) throw 'Internal Error! Null pthread_ptr in _kill_thread!';
     {{{ makeSetValue('pthread_ptr', C_STRUCTS.pthread.self, 0, 'i32') }}};
     var pthread = PThread.pthreads[pthread_ptr];
@@ -496,7 +496,7 @@ var LibraryPThread = {
   },
 
   _cleanup_thread: function(pthread_ptr) {
-    if (ENVIRONMENT_IS_PTHREAD) throw 'Internal Error! _cleanup_thread() can only ever be called from main application thread!';
+    if (ENVIRONMENT_IS_WORKER) throw 'Internal Error! _cleanup_thread() can only ever be called from main application thread!';
     if (!pthread_ptr) throw 'Internal Error! Null pthread_ptr in _cleanup_thread!';
     {{{ makeSetValue('pthread_ptr', C_STRUCTS.pthread.self, 0, 'i32') }}};
     var pthread = PThread.pthreads[pthread_ptr];
@@ -507,14 +507,14 @@ var LibraryPThread = {
   },
 
   _cancel_thread: function(pthread_ptr) {
-    if (ENVIRONMENT_IS_PTHREAD) throw 'Internal Error! _cancel_thread() can only ever be called from main application thread!';
+    if (ENVIRONMENT_IS_WORKER) throw 'Internal Error! _cancel_thread() can only ever be called from main application thread!';
     if (!pthread_ptr) throw 'Internal Error! Null pthread_ptr in _cancel_thread!';
     var pthread = PThread.pthreads[pthread_ptr];
     pthread.worker.postMessage({ 'cmd': 'cancel' });
   },
 
   _spawn_thread: function(threadParams) {
-    if (ENVIRONMENT_IS_PTHREAD) throw 'Internal Error! _spawn_thread() can only ever be called from main application thread!';
+    if (ENVIRONMENT_IS_WORKER) throw 'Internal Error! _spawn_thread() can only ever be called from main application thread!';
 
     var worker = PThread.getNewWorker();
 
@@ -703,7 +703,7 @@ var LibraryPThread = {
 
     // Synchronously proxy the thread creation to main thread if possible. If we need to transfer ownership of objects, then
     // proxy asynchronously via postMessage.
-    if (ENVIRONMENT_IS_PTHREAD && (transferList.length === 0 || error)) {
+    if (ENVIRONMENT_IS_WORKER && (transferList.length === 0 || error)) {
       return _emscripten_sync_run_in_main_thread_4({{{ cDefine('EM_PROXIED_PTHREAD_CREATE') }}}, pthread_ptr, attr, start_routine, arg);
     }
 
@@ -792,7 +792,7 @@ var LibraryPThread = {
       transferList: transferList
     };
 
-    if (ENVIRONMENT_IS_PTHREAD) {
+    if (ENVIRONMENT_IS_WORKER) {
       // The prepopulated pool of web workers that can host pthreads is stored in the main JS thread. Therefore if a
       // pthread is attempting to spawn a new thread, the thread creation must be deferred to the main JS thread.
       threadParams.cmd = 'spawnThread';
@@ -809,7 +809,7 @@ var LibraryPThread = {
   // TODO HACK! Remove this function, it is a JS side copy of the function pthread_testcancel() in library_pthread.c.
   // Just call pthread_testcancel() everywhere.
   _pthread_testcancel_js: function() {
-    if (!ENVIRONMENT_IS_PTHREAD) return;
+    if (!ENVIRONMENT_IS_WORKER) return;
     if (!threadInfoStruct) return;
     var cancelDisabled = Atomics.load(HEAPU32, (threadInfoStruct + {{{ C_STRUCTS.pthread.canceldisable }}} ) >> 2);
     if (cancelDisabled) return;
@@ -833,11 +833,11 @@ var LibraryPThread = {
       err('pthread_join attempted on a null thread pointer!');
       return ERRNO_CODES.ESRCH;
     }
-    if (ENVIRONMENT_IS_PTHREAD && selfThreadId == thread) {
+    if (ENVIRONMENT_IS_WORKER && selfThreadId == thread) {
       err('PThread ' + thread + ' is attempting to join to itself!');
       return ERRNO_CODES.EDEADLK;
     }
-    else if (!ENVIRONMENT_IS_PTHREAD && PThread.mainThreadBlock == thread) {
+    else if (!ENVIRONMENT_IS_WORKER && PThread.mainThreadBlock == thread) {
       err('Main thread ' + thread + ' is attempting to join to itself!');
       return ERRNO_CODES.EDEADLK;
     }
@@ -864,7 +864,7 @@ var LibraryPThread = {
         if (status) {{{ makeSetValue('status', 0, 'threadExitCode', 'i32') }}};
         Atomics.store(HEAPU32, (thread + {{{ C_STRUCTS.pthread.detached }}} ) >> 2, 1); // Mark the thread as detached.
 
-        if (!ENVIRONMENT_IS_PTHREAD) __cleanup_thread(thread);
+        if (!ENVIRONMENT_IS_WORKER) __cleanup_thread(thread);
         else postMessage({ 'cmd': 'cleanupThread', 'thread': thread });
         return 0;
       }
@@ -876,8 +876,8 @@ var LibraryPThread = {
       __pthread_testcancel_js();
       // In main runtime thread (the thread that initialized the Emscripten C runtime and launched main()), assist pthreads in performing operations
       // that they need to access the Emscripten main runtime for.
-      if (!ENVIRONMENT_IS_PTHREAD) _emscripten_main_thread_process_queued_calls();
-      _emscripten_futex_wait(thread + {{{ C_STRUCTS.pthread.threadStatus }}}, threadStatus, ENVIRONMENT_IS_PTHREAD ? 100 : 1);
+      if (!ENVIRONMENT_IS_WORKER) _emscripten_main_thread_process_queued_calls();
+      _emscripten_futex_wait(thread + {{{ C_STRUCTS.pthread.threadStatus }}}, threadStatus, ENVIRONMENT_IS_WORKER ? 100 : 1);
     }
   },
 
@@ -909,7 +909,7 @@ var LibraryPThread = {
       return ERRNO_CODES.ESRCH;
     }
     if (signal != 0) {
-      if (!ENVIRONMENT_IS_PTHREAD) __kill_thread(thread);
+      if (!ENVIRONMENT_IS_WORKER) __kill_thread(thread);
       else postMessage({ 'cmd': 'killThread', 'thread': thread});
     }
     return 0;
@@ -931,7 +931,7 @@ var LibraryPThread = {
       return ERRNO_CODES.ESRCH;
     }
     Atomics.compareExchange(HEAPU32, (thread + {{{ C_STRUCTS.pthread.threadStatus }}} ) >> 2, 0, 2); // Signal the thread that it needs to cancel itself.
-    if (!ENVIRONMENT_IS_PTHREAD) __cancel_thread(thread);
+    if (!ENVIRONMENT_IS_WORKER) __cancel_thread(thread);
     else postMessage({ 'cmd': 'cancelThread', 'thread': thread});
     return 0;
   },
@@ -955,7 +955,7 @@ var LibraryPThread = {
 
   pthread_exit__deps: ['exit'],
   pthread_exit: function(status) {
-    if (!ENVIRONMENT_IS_PTHREAD) _exit(status);
+    if (!ENVIRONMENT_IS_WORKER) _exit(status);
     else PThread.threadExit(status);
 #if WASM_BACKEND
     // pthread_exit is marked noReturn, so we must not return from it.
@@ -996,7 +996,7 @@ var LibraryPThread = {
   emscripten_is_main_runtime_thread__sig: 'i',
   emscripten_is_main_runtime_thread__deps: ['_pthread_is_main_runtime_thread'],
   emscripten_is_main_runtime_thread: function() {
-    return __pthread_is_main_runtime_thread|0; // Semantically the same as testing "!ENVIRONMENT_IS_PTHREAD" outside the asm.js scope
+    return __pthread_is_main_runtime_thread|0; // Semantically the same as testing "!ENVIRONMENT_IS_WORKER" outside the asm.js scope
   },
 
   emscripten_is_main_browser_thread__asm: true,
@@ -1105,7 +1105,7 @@ var LibraryPThread = {
   pthread_cleanup_push: function(routine, arg) {
     if (PThread.exitHandlers === null) {
       PThread.exitHandlers = [];
-      if (!ENVIRONMENT_IS_PTHREAD) {
+      if (!ENVIRONMENT_IS_WORKER) {
         __ATEXIT__.push(function() { PThread.runExitHandlers(); });
       }
     }
@@ -1135,13 +1135,13 @@ var LibraryPThread = {
   emscripten_futex_wait__deps: ['_main_thread_futex_wait_address', 'emscripten_main_thread_process_queued_calls'],
   emscripten_futex_wait: function(addr, val, timeout) {
     if (addr <= 0 || addr > HEAP8.length || addr&3 != 0) return -{{{ cDefine('EINVAL') }}};
-//    dump('futex_wait addr:' + addr + ' by thread: ' + _pthread_self() + (ENVIRONMENT_IS_PTHREAD?'(pthread)':'') + '\n');
+//    dump('futex_wait addr:' + addr + ' by thread: ' + _pthread_self() + (ENVIRONMENT_IS_WORKER?'(pthread)':'') + '\n');
     if (ENVIRONMENT_IS_WORKER) {
 #if PTHREADS_PROFILING
       PThread.setThreadStatusConditional(_pthread_self(), {{{ cDefine('EM_THREAD_STATUS_RUNNING') }}}, {{{ cDefine('EM_THREAD_STATUS_WAITFUTEX') }}});
 #endif
       var ret = Atomics.wait(HEAP32, addr >> 2, val, timeout);
-//    dump('futex_wait done by thread: ' + _pthread_self() + (ENVIRONMENT_IS_PTHREAD?'(pthread)':'') + '\n');
+//    dump('futex_wait done by thread: ' + _pthread_self() + (ENVIRONMENT_IS_WORKER?'(pthread)':'') + '\n');
 #if PTHREADS_PROFILING
       PThread.setThreadStatusConditional(_pthread_self(), {{{ cDefine('EM_THREAD_STATUS_WAITFUTEX') }}}, {{{ cDefine('EM_THREAD_STATUS_RUNNING') }}});
 #endif
@@ -1192,7 +1192,7 @@ var LibraryPThread = {
     // Waking (at least) INT_MAX waiters is defined to mean wake all callers.
     // For Atomics.notify() API Infinity is to be passed in that case.
     if (count >= {{{ cDefine('INT_MAX') }}}) count = Infinity;
-//    dump('futex_wake addr:' + addr + ' by thread: ' + _pthread_self() + (ENVIRONMENT_IS_PTHREAD?'(pthread)':'') + '\n');
+//    dump('futex_wake addr:' + addr + ' by thread: ' + _pthread_self() + (ENVIRONMENT_IS_WORKER?'(pthread)':'') + '\n');
 
     // See if main thread is waiting on this address? If so, wake it up by resetting its wake location to zero.
     // Note that this is not a fair procedure, since we always wake main thread first before any workers, so

src/parseTools.js

@@ -1573,7 +1573,7 @@ function modifyFunction(text, func) {
 
 function runOnMainThread(text) {
   if (USE_PTHREADS) {
-    return 'if (!ENVIRONMENT_IS_PTHREAD) { ' + text + ' }';
+    return 'if (!ENVIRONMENT_IS_WORKER) { ' + text + ' }';
   } else {
     return text;
   }