Merge branch 'main' into update_libcxx_libcxxabi_19

Author: aheejin

src/closure-externs/node-externs.js

@@ -119,3 +119,15 @@ fs.Stats.prototype.mtimeMs;
  * @type {number}
  */
 fs.Stats.prototype.ctimeMs;
+
+/**
+ * @param {string} p
+ * @return {boolean}
+ * @nosideeffects
+ */
+path.isAbsolute;
+
+/**
+ * @type {Object.<string,*>}
+ */
+path.posix;

src/library_fs.js

@@ -193,8 +193,18 @@ FS.staticInit();
             break;
           }
 
-          current = FS.lookupNode(current, parts[i]);
           current_path = PATH.join2(current_path, parts[i]);
+          try {
+            current = FS.lookupNode(current, parts[i]);
+          } catch (e) {
+            // if noent_okay is true, suppress a ENOENT in the last component
+            // and return an object with an undefined node. This is needed for
+            // resolving symlinks in the path when creating a file.
+            if ((e?.errno === {{{ cDefs.ENOENT }}}) && islast && opts.noent_okay) {
+              return { path: current_path };
+            }
+            throw e;
+          }
 
           // jump to the mount's root node if this is a mountpoint
           if (FS.isMountpoint(current) && (!islast || opts.follow_mount)) {
@@ -1036,14 +1046,15 @@ FS.staticInit();
         node = path;
       } else {
         path = PATH.normalize(path);
-        try {
-          var lookup = FS.lookupPath(path, {
-            follow: !(flags & {{{ cDefs.O_NOFOLLOW }}})
-          });
-          node = lookup.node;
-        } catch (e) {
-          // ignore
-        }
+        // 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.
+        var lookup = FS.lookupPath(path, {
+          follow: !(flags & {{{ cDefs.O_NOFOLLOW }}}),
+          noent_okay: true
+        });
+        node = lookup.node;
+        path = lookup.path;
       }
       // perhaps we need to create the node
       var created = false;

src/library_memfs.js

@@ -191,18 +191,18 @@ addToLibrary({
         return MEMFS.createNode(parent, name, mode, dev);
       },
       rename(old_node, new_dir, new_name) {
-        // if we're overwriting a directory at new_name, make sure it's empty.
-        if (FS.isDir(old_node.mode)) {
-          var new_node;
-          try {
-            new_node = FS.lookupNode(new_dir, new_name);
-          } catch (e) {
-          }
-          if (new_node) {
+        var new_node;
+        try {
+          new_node = FS.lookupNode(new_dir, new_name);
+        } catch (e) {}
+        if (new_node) {
+          if (FS.isDir(old_node.mode)) {
+            // if we're overwriting a directory at new_name, make sure it's empty.
             for (var i in new_node.contents) {
               throw new FS.ErrnoError({{{ cDefs.ENOTEMPTY }}});
             }
           }
+          FS.hashRemoveNode(new_node);
         }
         // do the internal rewiring
         delete old_node.parent.contents[old_node.name];
@@ -223,11 +223,7 @@ addToLibrary({
         parent.ctime = parent.mtime = Date.now();
       },
       readdir(node) {
-        var entries = ['.', '..'];
-        for (var key of Object.keys(node.contents)) {
-          entries.push(key);
-        }
-        return entries;
+        return ['.', '..', ...Object.keys(node.contents)];
       },
       symlink(parent, newname, oldpath) {
         var node = MEMFS.createNode(parent, newname, 0o777 | {{{ cDefs.S_IFLNK }}}, 0);

src/library_nodefs.js

@@ -197,6 +197,9 @@ addToLibrary({
       rename(oldNode, newDir, newName) {
         var oldPath = NODEFS.realPath(oldNode);
         var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
+        try {
+          FS.unlink(newPath);
+        } catch(e) {}
         NODEFS.tryFSOperation(() => fs.renameSync(oldPath, newPath));
         oldNode.name = newName;
       },

src/library_nodepath.js

@@ -12,23 +12,23 @@
 // operations. Hence, using `nodePath` should be safe here.
 
 addToLibrary({
-  $PATH: {
-    isAbs: (path) => nodePath['isAbsolute'](path),
-    normalize: (path) => nodePath['normalize'](path),
-    dirname: (path) => nodePath['dirname'](path),
-    basename: (path) => nodePath['basename'](path),
-    join: (...args) => nodePath['join'](...args),
-    join2: (l, r) => nodePath['join'](l, r),
-  },
+  $PATH: `{
+    isAbs: nodePath.isAbsolute,
+    normalize: nodePath.normalize,
+    dirname: nodePath.dirname,
+    basename: nodePath.basename,
+    join: nodePath.join,
+    join2: nodePath.join,
+  }`,
   // The FS-using parts are split out into a separate object, so simple path
   // usage does not require the FS.
   $PATH_FS__deps: ['$FS'],
   $PATH_FS__docs: '/** @type{{resolve: function(...*)}} */',
   $PATH_FS: {
     resolve: (...paths) => {
       paths.unshift(FS.cwd());
-      return nodePath['posix']['resolve'](...paths);
+      return nodePath.posix.resolve(...paths);
     },
-    relative: (from, to) => nodePath['posix']['relative'](from || FS.cwd(), to || FS.cwd()),
+    relative: (from, to) => nodePath.posix.relative(from || FS.cwd(), to || FS.cwd()),
   }
 });

src/library_noderawfs.js

@@ -40,7 +40,7 @@ addToLibrary({
     },
     lookupPath(path, opts = {}) {
       if (opts.parent) {
-        path = nodePath.dirname(path);
+        path = PATH.dirname(path);
       }
       var st = fs.lstatSync(path);
       var mode = NODEFS.getMode(path);

src/node_shell_read.js

@@ -5,9 +5,8 @@
  */
 
 readBinary = (filename) => {
-  // We need to re-wrap `file://` strings to URLs. Normalizing isn't
-  // necessary in that case, the path should already be absolute.
-  filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
+  // We need to re-wrap `file://` strings to URLs.
+  filename = isFileURI(filename) ? new URL(filename) : filename;
   var ret = fs.readFileSync(filename);
 #if ASSERTIONS
   assert(ret.buffer);
@@ -17,7 +16,7 @@ readBinary = (filename) => {
 
 readAsync = (filename, binary = true) => {
   // See the comment in the `readBinary` function.
-  filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
+  filename = isFileURI(filename) ? new URL(filename) : filename;
   return new Promise((resolve, reject) => {
     fs.readFile(filename, binary ? undefined : 'utf8', (err, data) => {
       if (err) reject(err);

test/benchmark/benchmark_utf16.cpp

@@ -54,7 +54,6 @@ unsigned short *randomString(int len) {
 }
 
 int main() {
-  srand(time(NULL));
   double t = 0;
   double t2 = emscripten_get_now();
   for(int i = 0; i < 10; ++i) {

test/benchmark/benchmark_utf8.c

@@ -54,9 +54,6 @@ char *randomString(int len) {
 }
 
 int main() {
-  time_t seed = time(NULL);
-  printf("Random seed: %lld\n", seed);
-  srand(seed);
   double t = 0;
   double t2 = emscripten_get_now();
   for (int i = 0; i < 100000; ++i) {

test/code_size/random_printf_wasm.json

@@ -1,6 +1,6 @@
 {
-  "a.html": 12686,
-  "a.html.gz": 6930,
-  "total": 12686,
-  "total_gz": 6930
+  "a.html": 12597,
+  "a.html.gz": 6882,
+  "total": 12597,
+  "total_gz": 6882
 }

test/code_size/random_printf_wasm2js.json

@@ -1,6 +1,6 @@
 {
-  "a.html": 17266,
-  "a.html.gz": 7515,
-  "total": 17266,
-  "total_gz": 7515
+  "a.html": 17195,
+  "a.html.gz": 7478,
+  "total": 17195,
+  "total_gz": 7478
 }

test/core/test_emmalloc.c

@@ -178,7 +178,6 @@ void randoms() {
   for (int i = 0; i < BINS; i++) {
     bins[i] = NULL;
   }
-  srandom(1337101);
   for (int i = 0; i < RANDOM_ITERS; i++) {
     unsigned int r = random();
     int alloc = r & 1;

test/core/test_rand.c

@@ -0,0 +1,42 @@
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <assert.h>
+
+int main() {
+  // We need RAND_MAX to be a bitmask (power of 2 minus 1).  This assertion will
+  // error if RAND_MAX ever changes, so we don't miss that.
+  assert(RAND_MAX == 0x7fffffff);
+
+  srand(0xdeadbeef);
+  for (int i = 0; i < 10; ++i) {
+    printf("%d\n", rand());
+  }
+
+  unsigned int seed = 0xdeadbeef;
+  for (int i = 0; i < 10; ++i) {
+    printf("%d\n", rand_r(&seed));
+  }
+
+  bool haveEvenAndOdd = true;
+  for (int i = 1; i <= 30; ++i) {
+    int mask = 1 << i;
+    if (mask > RAND_MAX) break;
+    bool haveEven = false;
+    bool haveOdd = false;
+    for (int j = 0; j < 1000 && (!haveEven || !haveOdd); ++j) {
+      if ((rand() & mask) == 0) {
+        haveEven = true;
+      } else {
+        haveOdd = true;
+      }
+    }
+    haveEvenAndOdd = haveEvenAndOdd && haveEven && haveOdd;
+  }
+
+  if (haveEvenAndOdd) {
+    printf("Have even and odd!\n");
+  }
+
+  return 0;
+}

test/core/test_rand.out

@@ -0,0 +1,21 @@
+490242850
+2074599277
+1480056542
+1912638067
+931112055
+2110392489
+2053422194
+1614832492
+216117595
+174823244
+760368382
+602359081
+1121118963
+1291018924
+1608306807
+352705809
+958258461
+1182561381
+114276303
+1481323674
+Have even and odd!

test/fetch/test_fetch_idb_store.c

@@ -38,7 +38,6 @@ int main()
 {
   // Create data
   uint8_t *data = (uint8_t*)malloc(10240);
-  srand(time(NULL));
   for(int i = 0; i < 10240; ++i) data[i] = (uint8_t)rand();
 
   persistFileToIndexedDB("outputfile.dat", data, 10240);

test/fetch/test_fetch_idb_store.cpp

@@ -21,7 +21,6 @@ int main()
   strcpy(attr.requestMethod, "EM_IDB_STORE");
   attr.attributes = EMSCRIPTEN_FETCH_REPLACE | EMSCRIPTEN_FETCH_SYNCHRONOUS | EMSCRIPTEN_FETCH_PERSIST_FILE;
   uint8_t *data = (uint8_t*)malloc(TEST_SIZE);
-  srand(time(NULL));
   for(int i = 0; i < TEST_SIZE; ++i)
     data[i] = (uint8_t)rand() | 0x40;
   attr.requestData = (char *)data;

test/fs/test_fs_rename_on_existing.c

@@ -0,0 +1,55 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <assert.h>
+#include <fcntl.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <assert.h>
+#include <errno.h>
+#include <string.h>
+
+
+#if defined(__EMSCRIPTEN__)
+#include <emscripten.h>
+#endif
+
+void makedir(const char *dir) {
+  int rtn = mkdir(dir, 0777);
+  assert(rtn == 0);
+}
+
+void changedir(const char *dir) {
+  int rtn = chdir(dir);
+  assert(rtn == 0);
+}
+
+static void create_file(const char *path, const char *buffer) {
+  printf("creating: %s\n", path);
+  int fd = open(path, O_WRONLY | O_CREAT | O_EXCL, 0666);
+  printf("error: %s\n", strerror(errno));
+  assert(fd >= 0);
+
+  int err = write(fd, buffer, sizeof(char) * strlen(buffer));
+  assert(err ==  (sizeof(char) * strlen(buffer)));
+
+  close(fd);
+}
+
+
+void setup() {
+#if defined(__EMSCRIPTEN__) && defined(NODEFS)
+  makedir("working");
+  EM_ASM(FS.mount(NODEFS, { root: '.' }, 'working'));
+  changedir("working");
+#endif
+}
+
+int main() {
+    setup();
+    create_file("a", "abc");
+    create_file("b", "xyz");
+    assert(rename("a", "b") == 0);
+    assert(unlink("b") == 0);
+    create_file("b", "xyz");
+    printf("success\n");
+}

test/hello_random_printf.c

@@ -4,7 +4,7 @@
 #include <emscripten.h>
 
 int main() {
-  srand(time(NULL));
+  srand(0);
 
   printf("hello: a random string: %s, an integer: %d, a float: %f. Time now: %f\n",
     emscripten_random() > 0.5 ? "test" : "test2",

test/malloc_bench.c

@@ -29,7 +29,6 @@ const bool USE_MEMORY = true;
 const bool USE_SHIFTS = false;
 
 void randoms() {
-  srandom(1);
   size_t before = (size_t)sbrk(0);
   double sum_sbrk = 0;
   size_t max_sbrk = before;

test/other/codesize/test_codesize_cxx_ctors1.gzsize

@@ -1 +1 @@
-8534
+8577

test/other/codesize/test_codesize_cxx_ctors1.jssize

@@ -1 +1 @@
-20856
+20952

test/other/codesize/test_codesize_cxx_ctors2.gzsize

@@ -1 +1 @@
-8518
+8561

test/other/codesize/test_codesize_cxx_ctors2.jssize

@@ -1 +1 @@
-20824
+20920

test/other/codesize/test_codesize_cxx_except.gzsize

@@ -1 +1 @@
-9563
+9610

test/other/codesize/test_codesize_cxx_except.jssize

@@ -1 +1 @@
-24699
+24795

test/other/codesize/test_codesize_cxx_except_wasm.gzsize

@@ -1 +1 @@
-8500
+8551

test/other/codesize/test_codesize_cxx_except_wasm.jssize

@@ -1 +1 @@
-20750
+20845