Minor refactoring of library_wasm_worker.js/wasm_worker.h. NFC (#20109)

- Format comment blocks to 80 chars
- Use {{{ cDefs }} rather than hardcoded numbers and comments
- Rename atomicLiveWaitAsyncs and liveAtomicWaitCounter for clarity.

Split out from #20099.

Author: sbc100

src/generated_struct_info32.json

@@ -37,6 +37,8 @@
         "AL_STOPPED": 4116,
         "AL_TRUE": 1,
         "AL_VELOCITY": 4102,
+        "ATOMICS_WAIT_NOT_EQUAL": 1,
+        "ATOMICS_WAIT_TIMED_OUT": 2,
         "AT_EMPTY_PATH": 4096,
         "AT_FDCWD": -100,
         "AT_NO_AUTOMOUNT": 2048,

src/generated_struct_info64.json

@@ -37,6 +37,8 @@
         "AL_STOPPED": 4116,
         "AL_TRUE": 1,
         "AL_VELOCITY": 4102,
+        "ATOMICS_WAIT_NOT_EQUAL": 1,
+        "ATOMICS_WAIT_TIMED_OUT": 2,
         "AT_EMPTY_PATH": 4096,
         "AT_FDCWD": -100,
         "AT_NO_AUTOMOUNT": 2048,

src/library_wasm_worker.js

@@ -33,9 +33,10 @@ addToLibrary({
   $_wasmWorkers: {},
   $_wasmWorkersID: 1,
 
-  // Starting up a Wasm Worker is an asynchronous operation, hence if the parent thread performs any
-  // postMessage()-based wasm function calls s to the Worker, they must be delayed until the async
-  // startup has finished, after which these postponed function calls can be dispatched.
+  // Starting up a Wasm Worker is an asynchronous operation, hence if the parent
+  // thread performs any postMessage()-based wasm function calls s to the
+  // Worker, they must be delayed until the async startup has finished, after
+  // which these postponed function calls can be dispatched.
   $_wasmWorkerDelayedMessageQueue: [],
 
   $_wasmWorkerAppendToQueue: (e) => {
@@ -44,12 +45,14 @@ addToLibrary({
 
   // Executes a wasm function call received via a postMessage.
   $_wasmWorkerRunPostMessage: (e) => {
-    let data = e.data, wasmCall = data['_wsc']; // '_wsc' is short for 'wasm call', trying to use an identifier name that will never conflict with user code
+    // '_wsc' is short for 'wasm call', trying to use an identifier name that
+    // will never conflict with user code
+    let data = e.data, wasmCall = data['_wsc'];
     wasmCall && getWasmTableEntry(wasmCall)(...data['x']);
   },
 
-  // src/postamble_minimal.js brings this symbol in to the build, and calls this function synchronously
-  // from main JS file at the startup of each Worker.
+  // src/postamble_minimal.js brings this symbol in to the build, and calls this
+  // function synchronously from main JS file at the startup of each Worker.
   $_wasmWorkerInitializeRuntime__deps: ['$_wasmWorkerDelayedMessageQueue', '$_wasmWorkerRunPostMessage', '$_wasmWorkerAppendToQueue', 'emscripten_wasm_worker_initialize'],
   $_wasmWorkerInitializeRuntime: () => {
     let m = Module;
@@ -59,13 +62,13 @@ addToLibrary({
 #endif
 
 #if STACK_OVERFLOW_CHECK >= 2
-    // _emscripten_wasm_worker_initialize() initializes the stack for this Worker,
-    // but it cannot call to extern __set_stack_limits() function, or Binaryen breaks
-    // with "Fatal: Module::addFunction: __set_stack_limits already exists".
-    // So for now, invoke this function from JS side. TODO: remove this in the future.
-    // Note that this call is not exactly correct, since this limit will include
-    // the TLS slot, that will be part of the region between m['sb'] and m['sz'],
-    // so we need to fix up the call below.
+    // _emscripten_wasm_worker_initialize() initializes the stack for this
+    // Worker, but it cannot call to extern __set_stack_limits() function, or
+    // Binaryen breaks with "Fatal: Module::addFunction: __set_stack_limits
+    // already exists".  So for now, invoke this function from JS side. TODO:
+    // remove this in the future.  Note that this call is not exactly correct,
+    // since this limit will include the TLS slot, that will be part of the
+    // region between m['sb'] and m['sz'], so we need to fix up the call below.
     ___set_stack_limits(m['sb'] + m['sz'], m['sb']);
 #endif
     // Run the C side Worker initialization for stack and TLS.
@@ -100,33 +103,47 @@ addToLibrary({
   },
 
 #if WASM_WORKERS == 2
-  // In WASM_WORKERS == 2 build mode, we create the Wasm Worker global scope script from a string bundled in the main application JS file. This simplifies the number of deployed JS files with the app,
-  // but has a downside that the generated build output will no longer be csp-eval compliant. https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src#unsafe_eval_expressions
+  // In WASM_WORKERS == 2 build mode, we create the Wasm Worker global scope
+  // script from a string bundled in the main application JS file. This
+  // simplifies the number of deployed JS files with the app, but has a downside
+  // that the generated build output will no longer be csp-eval compliant.
+  // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src#unsafe_eval_expressions
   $_wasmWorkerBlobUrl: "URL.createObjectURL(new Blob(['onmessage=function(d){onmessage=null;d=d.data;{{{ captureModuleArg() }}}{{{ instantiateWasm() }}}importScripts(d.js);{{{ instantiateModule() }}}d.wasm=d.mem=d.js=0;}'],{type:'application/javascript'}))",
 #endif
 
-  _emscripten_create_wasm_worker__deps: ['$_wasmWorkers', '$_wasmWorkersID', '$_wasmWorkerAppendToQueue', '$_wasmWorkerRunPostMessage'
+  _emscripten_create_wasm_worker__deps: [
+    '$_wasmWorkers', '$_wasmWorkersID',
+    '$_wasmWorkerAppendToQueue', '$_wasmWorkerRunPostMessage',
 #if WASM_WORKERS == 2
-    , '$_wasmWorkerBlobUrl'
+    '$_wasmWorkerBlobUrl',
 #endif
   ],
-  _emscripten_create_wasm_worker__postset: 'if (ENVIRONMENT_IS_WASM_WORKER) {\n'
-    + '_wasmWorkers[0] = this;\n'
-    + 'addEventListener("message", _wasmWorkerAppendToQueue);\n'
-    + '}\n',
+  _emscripten_create_wasm_worker__postset: `
+if (ENVIRONMENT_IS_WASM_WORKER) {
+  _wasmWorkers[0] = this;
+  addEventListener("message", _wasmWorkerAppendToQueue);
+}`,
   _emscripten_create_wasm_worker: (stackLowestAddress, stackSize) => {
     let worker = _wasmWorkers[_wasmWorkersID] = new Worker(
-#if WASM_WORKERS == 2 // WASM_WORKERS=2 mode embeds .ww.js file contents into the main .js file as a Blob URL. (convenient, but not CSP security safe, since this is eval-like)
+#if WASM_WORKERS == 2
+      // WASM_WORKERS=2 mode embeds .ww.js file contents into the main .js file
+      // as a Blob URL. (convenient, but not CSP security safe, since this is
+      // eval-like)
       _wasmWorkerBlobUrl
-#elif MINIMAL_RUNTIME // MINIMAL_RUNTIME has a structure where the .ww.js file is loaded from the main HTML file in parallel to all other files for best performance
+#elif MINIMAL_RUNTIME
+      // MINIMAL_RUNTIME has a structure where the .ww.js file is loaded from
+      // the main HTML file in parallel to all other files for best performance
       Module['$wb'] // $wb="Wasm worker Blob", abbreviated since not DCEable
-#else // default runtime loads the .ww.js file on demand.
+#else
+      // default runtime loads the .ww.js file on demand.
       locateFile('{{{ WASM_WORKER_FILE }}}')
 #endif
     );
     // Craft the Module object for the Wasm Worker scope:
     worker.postMessage({
-      '$ww': _wasmWorkersID, // Signal with a non-zero value that this Worker will be a Wasm Worker, and not the main browser thread.
+      // Signal with a non-zero value that this Worker will be a Wasm Worker,
+      // and not the main browser thread.
+      '$ww': _wasmWorkersID,
 #if MINIMAL_RUNTIME
       'wasm': Module['wasm'],
       'js': Module['js'],
@@ -221,10 +238,12 @@ addToLibrary({
 // And at the time of writing, no other browser has it either.
 #if MIN_EDGE_VERSION < 91 || MIN_CHROME_VERSION < 91 || MIN_SAFARI_VERSION != TARGET_NOT_SUPPORTED || MIN_FIREFOX_VERSION != TARGET_NOT_SUPPORTED || ENVIRONMENT_MAY_BE_NODE
   // Partially polyfill Atomics.waitAsync() if not available in the browser.
-  // Also polyfill for old Chrome-based browsers, where Atomics.waitAsync is broken until Chrome 91,
-  // see https://bugs.chromium.org/p/chromium/issues/detail?id=1167541
+  // Also polyfill for old Chrome-based browsers, where Atomics.waitAsync is
+  // broken until Chrome 91, see
+  // https://bugs.chromium.org/p/chromium/issues/detail?id=1167541
   // https://github.com/tc39/proposal-atomics-wait-async/blob/master/PROPOSAL.md
-  // This polyfill performs polling with setTimeout() to observe a change in the target memory location.
+  // This polyfill performs polling with setTimeout() to observe a change in the
+  // target memory location.
   emscripten_atomic_wait_async__postset: `if (!Atomics.waitAsync || (typeof navigator !== 'undefined' && jstoi_q((navigator.userAgent.match(/Chrom(e|ium)\\/([0-9]+)\\./)||[])[2]) < 91)) {
 let __Atomics_waitAsyncAddresses = [/*[i32a, index, value, maxWaitMilliseconds, promiseResolve]*/];
 function __Atomics_pollWaitAsyncAddresses() {
@@ -261,74 +280,82 @@ Atomics.waitAsync = (i32a, index, value, maxWaitMilliseconds) => {
 };
 }`,
 
-  // These dependencies are artificial, issued so that we still get the waitAsync polyfill emitted
-  // if code only calls emscripten_lock/semaphore_async_acquire()
-  // but not emscripten_atomic_wait_async() directly.
+  // These dependencies are artificial, issued so that we still get the
+  // waitAsync polyfill emitted if code only calls
+  // emscripten_lock/semaphore_async_acquire() but not
+  // emscripten_atomic_wait_async() directly.
   emscripten_lock_async_acquire__deps: ['emscripten_atomic_wait_async'],
   emscripten_semaphore_async_acquire__deps: ['emscripten_atomic_wait_async'],
 
 #endif
 
-  $atomicLiveWaitAsyncs: '{}',
-  $atomicLiveWaitAsyncsCounter: '0',
+  $liveAtomicWaitAsyncs: '{}',
+  $liveAtomicWaitAsyncCounter: '0',
 
-  emscripten_atomic_wait_async__deps: ['$atomicWaitStates', '$atomicLiveWaitAsyncs', '$atomicLiveWaitAsyncsCounter', '$jstoi_q'],
+  emscripten_atomic_wait_async__deps: ['$atomicWaitStates', '$liveAtomicWaitAsyncs', '$liveAtomicWaitAsyncCounter', '$jstoi_q'],
   emscripten_atomic_wait_async: (addr, val, asyncWaitFinished, userData, maxWaitMilliseconds) => {
     let wait = Atomics.waitAsync(HEAP32, addr >> 2, val, maxWaitMilliseconds);
     if (!wait.async) return atomicWaitStates.indexOf(wait.value);
-    // Increment waitAsync generation counter, account for wraparound in case application does huge amounts of waitAsyncs per second (not sure if possible?)
+    // Increment waitAsync generation counter, account for wraparound in case
+    // application does huge amounts of waitAsyncs per second (not sure if
+    // possible?)
     // Valid counterrange: 0...2^31-1
-    let counter = atomicLiveWaitAsyncsCounter;
-    atomicLiveWaitAsyncsCounter = Math.max(0, (atomicLiveWaitAsyncsCounter+1)|0);
-    atomicLiveWaitAsyncs[counter] = addr >> 2;
+    let counter = liveAtomicWaitAsyncCounter;
+    liveAtomicWaitAsyncCounter = Math.max(0, (liveAtomicWaitAsyncCounter+1)|0);
+    liveAtomicWaitAsyncs[counter] = addr >> 2;
     wait.value.then((value) => {
-      if (atomicLiveWaitAsyncs[counter]) {
-        delete atomicLiveWaitAsyncs[counter];
+      if (liveAtomicWaitAsyncs[counter]) {
+        delete liveAtomicWaitAsyncs[counter];
         {{{ makeDynCall('vpiip', 'asyncWaitFinished') }}}(addr, val, atomicWaitStates.indexOf(value), userData);
       }
     });
     return -counter;
   },
 
-  emscripten_atomic_cancel_wait_async__deps: ['$atomicLiveWaitAsyncs'],
+  emscripten_atomic_cancel_wait_async__deps: ['$liveAtomicWaitAsyncs'],
   emscripten_atomic_cancel_wait_async: (waitToken) => {
 #if ASSERTIONS
-    if (waitToken == 1 /* ATOMICS_WAIT_NOT_EQUAL */) warnOnce('Attempted to call emscripten_atomic_cancel_wait_async() with a value ATOMICS_WAIT_NOT_EQUAL (1) that is not a valid wait token! Check success in return value from call to emscripten_atomic_wait_async()');
-    else if (waitToken == 2 /* ATOMICS_WAIT_TIMED_OUT */) warnOnce('Attempted to call emscripten_atomic_cancel_wait_async() with a value ATOMICS_WAIT_TIMED_OUT (2) that is not a valid wait token! Check success in return value from call to emscripten_atomic_wait_async()');
-    else if (waitToken > 0) warnOnce('Attempted to call emscripten_atomic_cancel_wait_async() with an invalid wait token value ' + waitToken);
+    if (waitToken == {{{ cDefs.ATOMICS_WAIT_NOT_EQUAL }}}) {
+      warnOnce('Attempted to call emscripten_atomic_cancel_wait_async() with a value ATOMICS_WAIT_NOT_EQUAL (1) that is not a valid wait token! Check success in return value from call to emscripten_atomic_wait_async()');
+    } else if (waitToken == {{{ cDefs.ATOMICS_WAIT_TIMED_OUT }}}) {
+      warnOnce('Attempted to call emscripten_atomic_cancel_wait_async() with a value ATOMICS_WAIT_TIMED_OUT (2) that is not a valid wait token! Check success in return value from call to emscripten_atomic_wait_async()');
+    } else if (waitToken > 0) {
+      warnOnce(`Attempted to call emscripten_atomic_cancel_wait_async() with an invalid wait token value ${waitToken}`);
+    }
 #endif
-    if (atomicLiveWaitAsyncs[waitToken]) {
-      // Notify the waitAsync waiters on the memory location, so that JavaScript garbage collection can occur
+    if (liveAtomicWaitAsyncs[waitToken]) {
+      // Notify the waitAsync waiters on the memory location, so that JavaScript
+      // garbage collection can occur.
       // See https://github.com/WebAssembly/threads/issues/176
-      // This has the unfortunate effect of causing spurious wakeup of all other waiters at the address (which
-      // causes a small performance loss)
-      Atomics.notify(HEAP32, atomicLiveWaitAsyncs[waitToken]);
-      delete atomicLiveWaitAsyncs[waitToken];
-      return 0 /* EMSCRIPTEN_RESULT_SUCCESS */;
+      // This has the unfortunate effect of causing spurious wakeup of all other
+      // waiters at the address (which causes a small performance loss).
+      Atomics.notify(HEAP32, liveAtomicWaitAsyncs[waitToken]);
+      delete liveAtomicWaitAsyncs[waitToken];
+      return {{{ cDefs.EMSCRIPTEN_RESULT_SUCCESS }}};
     }
     // This waitToken does not exist.
-    return -5 /* EMSCRIPTEN_RESULT_INVALID_PARAM */;
+    return {{{ cDefs.EMSCRIPTEN_RESULT_INVALID_PARAM }}};
   },
 
-  emscripten_atomic_cancel_all_wait_asyncs__deps: ['$atomicLiveWaitAsyncs'],
+  emscripten_atomic_cancel_all_wait_asyncs__deps: ['$liveAtomicWaitAsyncs'],
   emscripten_atomic_cancel_all_wait_asyncs: () => {
-    let waitAsyncs = Object.values(atomicLiveWaitAsyncs);
+    let waitAsyncs = Object.values(liveAtomicWaitAsyncs);
     waitAsyncs.forEach((address) => {
       Atomics.notify(HEAP32, address);
     });
-    atomicLiveWaitAsyncs = {};
+    liveAtomicWaitAsyncs = {};
     return waitAsyncs.length;
   },
 
-  emscripten_atomic_cancel_all_wait_asyncs_at_address__deps: ['$atomicLiveWaitAsyncs'],
+  emscripten_atomic_cancel_all_wait_asyncs_at_address__deps: ['$liveAtomicWaitAsyncs'],
   emscripten_atomic_cancel_all_wait_asyncs_at_address: (address) => {
     address >>= 2;
     let numCancelled = 0;
-    Object.keys(atomicLiveWaitAsyncs).forEach((waitToken) => {
-      if (atomicLiveWaitAsyncs[waitToken] == address) {
+    Object.keys(liveAtomicWaitAsyncs).forEach((waitToken) => {
+      if (liveAtomicWaitAsyncs[waitToken] == address) {
         Atomics.notify(HEAP32, address);
-        delete atomicLiveWaitAsyncs[waitToken];
-        ++numCancelled;
+        delete liveAtomicWaitAsyncs[waitToken];
+        numCancelled++;
       }
     });
     return numCancelled;

src/struct_info.json

@@ -967,6 +967,13 @@
             "EM_FUNC_SIG_PARAM_F2I"
         ]
     },
+    {
+        "file": "emscripten/wasm_worker.h",
+        "defines": [
+            "ATOMICS_WAIT_NOT_EQUAL",
+            "ATOMICS_WAIT_TIMED_OUT"
+        ]
+    },
     {
         "file": "emscripten/emscripten.h",
         "defines": [