Merge branch 'main' into anonymous-file-descriptors

Author: hoodmane

.github/workflows/ci.yml

@@ -28,6 +28,7 @@ jobs:
 
   check-expectations:
     runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request'
     steps:
       - name: Checkout repo
         uses: actions/checkout@v4
@@ -52,14 +53,15 @@ jobs:
           echo "JS_ENGINES = [NODE_JS]" >> $EM_CONFIG
           echo "final config:"
           cat $EM_CONFIG
-      - name: Check test expectations on main
+      - name: Check test expectations on target branch
         run: |
-          git checkout origin/main
+          git checkout ${{ github.base_ref }}
+          git rev-parse HEAD
           # Hack to honor changes to rebaseline_tests.py in the current PR
           git checkout - ./tools/maint/rebaseline_tests.py
           ./bootstrap
           if ! ./tools/maint/rebaseline_tests.py --check-only; then
-            echo "Test expectations are out-of-date on the main branch."
+            echo "Test expectations are out-of-date on the target branch."
             echo "You can run `./tools/maint/rebaseline_tests.py --new-branch`"
             echo "and use it to create a seperate PR."
             exit 1

ChangeLog.md

@@ -4,7 +4,7 @@ Note that version numbers do not necessarily reflect the amount of changes
 between versions. A version number reflects a release that is known to pass all
 tests, and versions may be tagged more or less frequently at different times.
 
-Note that there is *no* ABI compatibility guarantee between versions - the ABI
+nNote that there is *no* ABI compatibility guarantee between versions - the ABI
 may change, so that we can keep improving and optimizing it. The compiler will
 automatically invalidate system caches when the version number updates, so that
 libc etc. are rebuilt for you. You should also rebuild object files and
@@ -20,11 +20,25 @@ See docs/process.md for more on how version tagging works.
 
 3.1.75 (in development)
 -----------------------
+- The `WASM_BIGINT` feature has been enabled by default. This has the effect that
+  Wasm i64 values are passed and returned between Wasm and JS as BigInt values
+  rather than being split by Binaryen into pairs of Numbers. (#22993)
+- When using `-sMODULARIZE` we now assert if the factory function is called with
+  the JS `new` keyword.  e.g. `a = new Module()` rather than `b = Module()`.
+  This paves the way for marking the function as `async` which does not allow
+  `new` to be used.  This usage of `new` here was never documented and is
+  considered and antipattern. (#23210)
 - `PATH.basename()` no longer calls `PATH.normalize()`, so that
   `PATH.basename("a/.")` returns `"."` instead of `"a"` and
   `PATH.basename("a/b/..")` returns `".."` instead of `"a"`. This is in line with
   the behaviour of both node and coreutils, and is already the case when using
   NODERAWFS". (#23180)
+- The factory function exposed in `-sMODULARIZE` mode is now marked as `async`
+  when `WASM_ASYNC_COMPILATION` is enabled (the default). This allows us to use
+  `await` during module creation.  One side effect of this is that code in
+  `--post-js` files will now be delayed until after module creation and after
+  `main` runs.  This matches the existing behaviour when using sync instantation
+  (`-sWASM_ASYNC_COMPILATION=0`) but is an observable difference. (#23157)
 
 3.1.74 - 12/14/24
 -----------------

site/source/docs/tools_reference/settings_reference.rst

@@ -2189,7 +2189,7 @@ legalize i64s into pairs of i32s, as the wasm VM will use a BigInt where an
 i64 is used. If WASM_BIGINT is present, the default minimum supported browser
 versions will be increased to the min version that supports BigInt.
 
-Default value: false
+Default value: true
 
 .. _emit_producers_section:
 

src/library_fs.js

@@ -182,7 +182,7 @@ FS.staticInit();
       // 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 && (p !== '.'));
+        var parts = path.split('/').filter((p) => !!p);
 
         // start at the root
         var current = FS.root;
@@ -195,6 +195,10 @@ FS.staticInit();
             break;
           }
 
+          if (parts[i] === '.') {
+            continue;
+          }
+
           if (parts[i] === '..') {
             current_path = PATH.dirname(current_path);
             current = current.parent;
@@ -422,8 +426,8 @@ FS.staticInit();
       if (FS.isLink(node.mode)) {
         return {{{ cDefs.ELOOP }}};
       } else if (FS.isDir(node.mode)) {
-        if (FS.flagsToPermissionString(flags) !== 'r' || // opening for write
-            (flags & {{{ cDefs.O_TRUNC }}})) { // TODO: check for O_SEARCH? (== search for dir only)
+        if (FS.flagsToPermissionString(flags) !== 'r' // opening for write
+            || (flags & ({{{ cDefs.O_TRUNC }}} | {{{ cDefs.O_CREAT }}}))) { // TODO: check for O_SEARCH? (== search for dir only)
           return {{{ cDefs.EISDIR }}};
         }
       }
@@ -665,9 +669,12 @@ FS.staticInit();
       var lookup = FS.lookupPath(path, { parent: true });
       var parent = lookup.node;
       var name = PATH.basename(path);
-      if (!name || name === '.' || name === '..') {
+      if (!name) {
         throw new FS.ErrnoError({{{ cDefs.EINVAL }}});
       }
+      if (name === '.' || name === '..') {
+        throw new FS.ErrnoError({{{ cDefs.EEXIST }}});
+      }
       var errCode = FS.mayCreate(parent, name);
       if (errCode) {
         throw new FS.ErrnoError(errCode);
@@ -1091,9 +1098,11 @@ FS.staticInit();
         mode = 0;
       }
       var node;
+      var isDirPath;
       if (typeof path == 'object') {
         node = path;
       } else {
+        isDirPath = path.endsWith("/");
         // noent_okay makes it so that if the final component of the path
         // doesn't exist, lookupPath returns `node: undefined`. `path` will be
         // updated to point to the target of all symlinks.
@@ -1112,9 +1121,14 @@ FS.staticInit();
           if ((flags & {{{ cDefs.O_EXCL }}})) {
             throw new FS.ErrnoError({{{ cDefs.EEXIST }}});
           }
+        } else if (isDirPath) {
+          throw new FS.ErrnoError({{{ cDefs.EISDIR }}});
         } else {
           // node doesn't exist, try to create it
-          node = FS.mknod(path, mode, 0);
+          // Ignore the permission bits here to ensure we can `open` this new
+          // file below. We use chmod below the apply the permissions once the
+          // file is open.
+          node = FS.mknod(path, mode | 0o777, 0);
           created = true;
         }
       }
@@ -1164,6 +1178,9 @@ FS.staticInit();
       if (stream.stream_ops.open) {
         stream.stream_ops.open(stream);
       }
+      if (created) {
+        FS.chmod(node, mode & 0o777);
+      }
 #if expectToReceiveOnModule('logReadFiles')
       if (Module['logReadFiles'] && !(flags & {{{ cDefs.O_WRONLY}}})) {
         if (!(path in FS.readFiles)) {

src/library_nodefs.js

@@ -116,7 +116,7 @@ addToLibrary({
       }
       return newFlags;
     },
-    getattr(func) {
+    getattr(func, node) {
       var stat = NODEFS.tryFSOperation(func);
       if (NODEFS.isWindows) {
         // node.js v0.10.20 doesn't report blksize and blocks on Windows. Fake
@@ -134,7 +134,7 @@ addToLibrary({
       }
       return {
         dev: stat.dev,
-        ino: stat.ino,
+        ino: node.ino,
         mode: stat.mode,
         nlink: stat.nlink,
         uid: stat.uid,
@@ -171,7 +171,7 @@ addToLibrary({
         if (attr.atime || attr.mtime) {
           var atime = attr.atime && new Date(attr.atime);
           var mtime = attr.mtime && new Date(attr.mtime);
-          fs.utimesSync(arg, atime, mtime);
+          utimes(arg, atime, mtime);
         }
         if (attr.size !== undefined) {
           truncate(arg, attr.size);
@@ -181,7 +181,7 @@ addToLibrary({
     node_ops: {
       getattr(node) {
         var path = NODEFS.realPath(node);
-        return NODEFS.getattr(() => fs.lstatSync(path));
+        return NODEFS.getattr(() => fs.lstatSync(path), node);
       },
       setattr(node, attr) {
         var path = NODEFS.realPath(node);
@@ -244,7 +244,7 @@ addToLibrary({
     },
     stream_ops: {
       getattr(stream) {
-        return NODEFS.getattr(() => fs.fstatSync(stream.nfd));
+        return NODEFS.getattr(() => fs.fstatSync(stream.nfd), stream.node);
       },
       setattr(stream, attr) {
         NODEFS.setattr(stream.nfd, stream.node, attr, fs.fchmodSync, fs.futimesSync, fs.ftruncateSync);

src/library_path.js

@@ -63,14 +63,9 @@ addToLibrary({
       }
       return root + dir;
     },
-    basename: (path) => {
-      // EMSCRIPTEN return '/' for '/', not an empty string
-      if (path === '/') return '/';
-      path = path.replace(/\/+$/g, "");
-      var lastSlash = path.lastIndexOf('/');
-      if (lastSlash === -1) return path;
-      return path.substr(lastSlash+1);
-    },
+    // This differs from node's path.basename in that it returns '/' for '/'
+    // rather than the empty string.
+    basename: (path) => path && path.match(/([^\/]+|\/)\/*$/)[1],
     join: (...paths) => PATH.normalize(paths.join('/')),
     join2: (l, r) => PATH.normalize(l + '/' + r),
   },

src/library_pipefs.js

@@ -77,6 +77,9 @@ addToLibrary({
 
         return 0;
       },
+      dup(stream) {
+        stream.node.pipe.refcnt++;
+      },
       ioctl(stream, request, varargs) {
         return {{{ cDefs.EINVAL }}};
       },

src/preamble.js

@@ -1036,11 +1036,11 @@ function getWasmImports() {
     trueModule = null;
 #endif
 #if SHARED_MEMORY || RELOCATABLE
-    receiveInstance(result['instance'], result['module']);
+    return receiveInstance(result['instance'], result['module']);
 #else
     // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
     // When the regression is fixed, can restore the above PTHREADS-enabled path.
-    receiveInstance(result['instance']);
+    return receiveInstance(result['instance']);
 #endif
   }
 #endif // WASM_ASYNC_COMPILATION
@@ -1076,8 +1076,7 @@ function getWasmImports() {
         // Instantiate from the module posted from the main thread.
         // We can just use sync instantiation in the worker.
         var instance = new WebAssembly.Instance(module, getWasmImports());
-        receiveInstance(instance, module);
-        resolve();
+        resolve(receiveInstance(instance, module));
       };
     });
   }
@@ -1095,16 +1094,16 @@ function getWasmImports() {
   try {
 #endif
     var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
-    receiveInstantiationResult(result);
+    var exports = receiveInstantiationResult(result);
 #if LOAD_SOURCE_MAP
     receiveSourceMapJSON(await getSourceMapAsync());
 #endif
-    return result;
+    return exports;
 #if MODULARIZE
   } catch (e) {
     // If instantiation fails, reject the module ready promise.
     readyPromiseReject(e);
-    return;
+    return Promise.reject(e);
   }
 #endif
 #else // WASM_ASYNC_COMPILATION

src/settings.js

@@ -1498,7 +1498,7 @@ var DYNCALLS = false;
 // i64 is used. If WASM_BIGINT is present, the default minimum supported browser
 // versions will be increased to the min version that supports BigInt.
 // [link]
-var WASM_BIGINT = false;
+var WASM_BIGINT = true;
 
 // WebAssembly defines a "producers section" which compilers and tools can
 // annotate themselves in, and LLVM emits this by default.

src/shell.js

@@ -34,7 +34,8 @@ var Module = typeof {{{ EXPORT_NAME }}} != 'undefined' ? {{{ EXPORT_NAME }}} : {
 #endif // USE_CLOSURE_COMPILER
 
 #if POLYFILL
-#if WASM_BIGINT && MIN_SAFARI_VERSION < 150000
+#if WASM_BIGINT && MIN_SAFARI_VERSION < 140100
+// TODO(https://github.com/emscripten-core/emscripten/issues/23184): Fix this back to 150000
 // See https://caniuse.com/mdn-javascript_builtins_bigint64array
 #include "polyfill/bigint64array.js"
 #endif