Merge branch 'main' into ruff-tools-directory

Author: cclauss

ChangeLog.md

@@ -24,7 +24,6 @@ See docs/process.md for more on how version tagging works.
 3.1.73 - 11/28/24
 -----------------
 - libunwind was updated to LLVM 19.1.4. (#22394)
-- mimalloc was updated to 2.1.7. (#21548)
 
 3.1.72 - 11/19/24
 -----------------

src/library.js

@@ -2182,25 +2182,19 @@ addToLibrary({
   },
 
   $asyncLoad__docs: '/** @param {boolean=} noRunDep */',
-  $asyncLoad: (url, onload, onerror, noRunDep) => {
-    var dep = !noRunDep ? getUniqueRunDependency(`al ${url}`) : '';
-    readAsync(url).then(
-      (arrayBuffer) => {
-#if ASSERTIONS
-        assert(arrayBuffer, `Loading data file "${url}" failed (no arrayBuffer).`);
-#endif
-        onload(new Uint8Array(arrayBuffer));
-        if (dep) removeRunDependency(dep);
-      },
-      (err) => {
-        if (onerror) {
-          onerror();
-        } else {
-          throw `Loading data file "${url}" failed.`;
-        }
-      }
-    );
-    if (dep) addRunDependency(dep);
+  $asyncLoad: (url, noRunDep) => {
+    return new Promise((resolve, reject) => {
+      var dep = !noRunDep ? getUniqueRunDependency(`al ${url}`) : '';
+      if (dep) addRunDependency(dep);
+      readAsync(url).then(
+        (arrayBuffer) => {
+  #if ASSERTIONS
+          assert(arrayBuffer, `Loading data file "${url}" failed (no arrayBuffer).`);
+  #endif
+          resolve(new Uint8Array(arrayBuffer));
+          if (dep) removeRunDependency(dep);
+        }, reject);
+    });
   },
 
   $alignMemory: (size, alignment) => {

src/library_async.js

@@ -470,7 +470,8 @@ addToLibrary({
   emscripten_wget_data__async: true,
   emscripten_wget_data: (url, pbuffer, pnum, perror) => {
     return Asyncify.handleSleep((wakeUp) => {
-      asyncLoad(UTF8ToString(url), (byteArray) => {
+      /* no need for run dependency, this is async but will not do any prepare etc. step */
+      asyncLoad(UTF8ToString(url), /*noRunDep=*/true).then((byteArray) => {
         // can only allocate the buffer after the wakeUp, not during an asyncing
         var buffer = _malloc(byteArray.length); // must be freed by caller!
         HEAPU8.set(byteArray, buffer);
@@ -481,7 +482,7 @@ addToLibrary({
       }, () => {
         {{{ makeSetValue('perror',  0, '1', 'i32') }}};
         wakeUp();
-      }, true /* no need for run dependency, this is async but will not do any prepare etc. step */ );
+      });
     });
   },
 

src/library_dylink.js

@@ -1024,7 +1024,7 @@ var LibraryDylink = {
 
       var libFile = locateFile(libName);
       if (flags.loadAsync) {
-        return new Promise((resolve, reject) => asyncLoad(libFile, resolve, reject));
+        return asyncLoad(libFile);
       }
 
       // load the binary synchronously

src/library_fs.js

@@ -174,60 +174,46 @@ FS.staticInit();
       path = PATH_FS.resolve(path);
 
       if (!path) return { path: '', node: null };
+      opts.follow_mount ??= true
 
-      var defaults = {
-        follow_mount: true,
-        recurse_count: 0
-      };
-      opts = Object.assign(defaults, opts)
-
-      if (opts.recurse_count > 8) {  // max recursive lookup of 8
-        throw new FS.ErrnoError({{{ cDefs.ELOOP }}});
-      }
+      // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
+      linkloop: for (var nlinks = 0; nlinks < 40; nlinks++) {
+        // split the absolute path
+        var parts = path.split('/').filter((p) => !!p);
 
-      // split the absolute path
-      var parts = path.split('/').filter((p) => !!p);
+        // start at the root
+        var current = FS.root;
+        var current_path = '/';
 
-      // start at the root
-      var current = FS.root;
-      var current_path = '/';
-
-      for (var i = 0; i < parts.length; i++) {
-        var islast = (i === parts.length-1);
-        if (islast && opts.parent) {
-          // stop resolving
-          break;
-        }
+        for (var i = 0; i < parts.length; i++) {
+          var islast = (i === parts.length-1);
+          if (islast && opts.parent) {
+            // stop resolving
+            break;
+          }
 
-        current = FS.lookupNode(current, parts[i]);
-        current_path = PATH.join2(current_path, parts[i]);
+          current = FS.lookupNode(current, parts[i]);
+          current_path = PATH.join2(current_path, parts[i]);
 
-        // jump to the mount's root node if this is a mountpoint
-        if (FS.isMountpoint(current)) {
-          if (!islast || (islast && opts.follow_mount)) {
+          // jump to the mount's root node if this is a mountpoint
+          if (FS.isMountpoint(current) && (!islast || opts.follow_mount)) {
             current = current.mounted.root;
           }
-        }
-
-        // by default, lookupPath will not follow a symlink if it is the final path component.
-        // setting opts.follow = true will override this behavior.
-        if (!islast || opts.follow) {
-          var count = 0;
-          while (FS.isLink(current.mode)) {
-            var link = FS.readlink(current_path);
-            current_path = PATH_FS.resolve(PATH.dirname(current_path), link);
 
-            var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count + 1 });
-            current = lookup.node;
-
-            if (count++ > 40) {  // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
-              throw new FS.ErrnoError({{{ cDefs.ELOOP }}});
+          // by default, lookupPath will not follow a symlink if it is the final path component.
+          // setting opts.follow = true will override this behavior.
+          if (FS.isLink(current.mode) && (!islast || opts.follow)) {
+            if (!current.node_ops.readlink) {
+              throw new FS.ErrnoError({{{ cDefs.ENOSYS }}});
             }
+            var link = current.node_ops.readlink(current);
+            path = PATH_FS.resolve(PATH.dirname(current_path), link, ...parts.slice(i + 1));
+            continue linkloop;
           }
         }
+        return { path: current_path, node: current };
       }
-
-      return { path: current_path, node: current };
+      throw new FS.ErrnoError({{{ cDefs.ELOOP }}});
     },
     getPath(node) {
       var path;

src/library_fs_shared.js

@@ -76,7 +76,7 @@ addToLibrary({
     }
     addRunDependency(dep);
     if (typeof url == 'string') {
-      asyncLoad(url, processData, onerror);
+      asyncLoad(url).then(processData, onerror);
     } else {
       processData(url);
     }

src/library_pthread.js

@@ -1000,7 +1000,7 @@ var LibraryPThread = {
   },
 
   $establishStackSpace__internal: true,
-  $establishStackSpace__deps: ['$stackRestore'],
+  $establishStackSpace__deps: ['$stackRestore', 'emscripten_stack_set_limits'],
   $establishStackSpace: (pthread_ptr) => {
 #if ALLOW_MEMORY_GROWTH
     // If memory growth is enabled, the memory views may have gotten out of date,

src/library_wasi.js

@@ -136,41 +136,37 @@ var WasiLibrary = {
   },
 #endif
 
-  $checkWasiClock: (clock_id) => {
-    return clock_id == {{{ cDefs.__WASI_CLOCKID_REALTIME }}} ||
-           clock_id == {{{ cDefs.__WASI_CLOCKID_MONOTONIC }}} ||
-           clock_id == {{{ cDefs.__WASI_CLOCKID_PROCESS_CPUTIME_ID }}} ||
-           clock_id == {{{ cDefs.__WASI_CLOCKID_THREAD_CPUTIME_ID }}};
-  },
+  $checkWasiClock: (clock_id) => clock_id >= {{{ cDefs.__WASI_CLOCKID_REALTIME }}} && clock_id <= {{{ cDefs.__WASI_CLOCKID_THREAD_CPUTIME_ID }}},
 
   // TODO: the i64 in the API here must be legalized for this JS code to run,
   // but the wasm file can't be legalized in standalone mode, which is where
   // this is needed. To get this code to be usable as a JS shim we need to
   // either wait for BigInt support or to legalize on the client.
   clock_time_get__i53abi: true,
   clock_time_get__nothrow: true,
-  clock_time_get__deps: ['emscripten_get_now', '$nowIsMonotonic', '$checkWasiClock'],
+  clock_time_get__proxy: 'none',
+  clock_time_get__deps: ['emscripten_get_now', 'emscripten_date_now', '$nowIsMonotonic', '$checkWasiClock'],
   clock_time_get: (clk_id, ignored_precision, ptime) => {
     if (!checkWasiClock(clk_id)) {
       return {{{ cDefs.EINVAL }}};
     }
     var now;
     // all wasi clocks but realtime are monotonic
     if (clk_id === {{{ cDefs.__WASI_CLOCKID_REALTIME }}}) {
-      now = Date.now();
+      now = _emscripten_date_now();
     } else if (nowIsMonotonic) {
       now = _emscripten_get_now();
     } else {
       return {{{ cDefs.ENOSYS }}};
     }
     // "now" is in ms, and wasi times are in ns.
     var nsec = Math.round(now * 1000 * 1000);
-    {{{ makeSetValue('ptime', 0, 'nsec >>> 0', 'i32') }}};
-    {{{ makeSetValue('ptime', 4, '(nsec / Math.pow(2, 32)) >>> 0', 'i32') }}};
+    {{{ makeSetValue('ptime', 0, 'nsec', 'i64') }}};
     return 0;
   },
 
   clock_res_get__nothrow: true,
+  clock_res_get__proxy: 'none',
   clock_res_get__deps: ['emscripten_get_now', 'emscripten_get_now_res', '$nowIsMonotonic', '$checkWasiClock'],
   clock_res_get: (clk_id, pres) => {
     if (!checkWasiClock(clk_id)) {
@@ -185,8 +181,7 @@ var WasiLibrary = {
     } else {
       return {{{ cDefs.ENOSYS }}};
     }
-    {{{ makeSetValue('pres', 0, 'nsec >>> 0', 'i32') }}};
-    {{{ makeSetValue('pres', 4, '(nsec / Math.pow(2, 32)) >>> 0', 'i32') }}};
+    {{{ makeSetValue('pres', 0, 'nsec', 'i64') }}};
     return 0;
   },
 

src/library_wget.js

@@ -64,7 +64,8 @@ var LibraryWget = {
   emscripten_async_wget_data__proxy: 'sync',
   emscripten_async_wget_data: (url, userdata, onload, onerror) => {
     {{{ runtimeKeepalivePush() }}}
-    asyncLoad(UTF8ToString(url), (byteArray) => {
+    /* no need for run dependency, this is async but will not do any prepare etc. step */
+    asyncLoad(UTF8ToString(url), /*noRunDep=*/true).then((byteArray) => {
       {{{ runtimeKeepalivePop() }}}
       callUserCallback(() => {
         var buffer = _malloc(byteArray.length);
@@ -79,7 +80,7 @@ var LibraryWget = {
           {{{ makeDynCall('vp', 'onerror') }}}(userdata);
         });
       }
-    }, true /* no need for run dependency, this is async but will not do any prepare etc. step */ );
+    });
   },
 
   emscripten_async_wget2__deps: ['$PATH_FS', '$wget', '$stackRestore', '$stringToUTF8OnStack'],

src/preamble_minimal.js

@@ -24,7 +24,7 @@ function abort(what) {
   throw {{{ ASSERTIONS ? 'new Error(what)' : 'what' }}};
 }
 
-#if SAFE_HEAP && !WASM_BIGINT
+#if !WASM_BIGINT
 // Globals used by JS i64 conversions (see makeSetValue)
 var tempDouble;
 var tempI64;