Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

6 files changed, 388 insertions, 0 deletions

diff --git a/js/src/jit-test/tests/large-buffers/atomics.js b/js/src/jit-test/tests/large-buffers/atomics.js
new file mode 100644
index 0000000000..0e108db3b7
--- /dev/null
+++ b/js/src/jit-test/tests/large-buffers/atomics.js
@@ -0,0 +1,57 @@
+// |jit-test| skip-if: !this.SharedArrayBuffer || !this.Atomics
+
+let gb = 1 * 1024 * 1024 * 1024;
+let buflen = 4 * gb + 64;
+let sab = new SharedArrayBuffer(buflen);
+assertEq(sab.byteLength, buflen);
+
+function testBasic(base) {
+    var uint8 = new Uint8Array(sab);
+    var uint8Part = new Uint8Array(sab, base, 64);
+
+    for (var i = 0; i < 50; i++) {
+        var index = base + i;
+        uint8Part[i] = 123;
+        assertEq(uint8[index], 123);
+
+        // Binary ops.
+        assertEq(Atomics.add(uint8, index, 1), 123);
+        assertEq(Atomics.and(uint8, index, 0xf), 124);
+        assertEq(Atomics.or(uint8, index, 0xf), 12);
+        assertEq(Atomics.xor(uint8, index, 0xee), 0xf);
+        assertEq(Atomics.sub(uint8, index, 100), 225);
+        assertEq(uint8Part[i], 125);
+
+        // compareExchange.
+        assertEq(Atomics.compareExchange(uint8, index, 125, 90), 125);
+        assertEq(Atomics.compareExchange(uint8, index, 125, 90), 90);
+        assertEq(uint8Part[i], 90);
+
+        // exchange.
+        assertEq(Atomics.exchange(uint8, index, 42), 90);
+        assertEq(uint8Part[i], 42);
+
+        // load/store.
+        assertEq(Atomics.load(uint8, index), 42);
+        assertEq(Atomics.store(uint8, index, 99), 99);
+        assertEq(uint8Part[i], 99);
+    }
+}
+for (let i = 0; i <= 4; i++) {
+    testBasic(i * gb);
+}
+
+function testWait() {
+    let int32 = new Int32Array(sab);
+    let index = int32.length - 1;
+    assertEq(int32[index], 0);
+    assertEq(Atomics.wait(int32, index, 1), "not-equal");
+    int32[index] = 12345;
+    assertEq(Atomics.wait(int32, index, 12345, 1), "timed-out");
+    assertEq(Atomics.notify(int32, index), 0);
+
+    let int32WithOffset = new Int32Array(sab, int32.byteLength - 4);
+    assertEq(int32WithOffset[0], 12345);
+    assertEq(Atomics.wait(int32WithOffset, 0, 12345, 1), "timed-out");
+}
+testWait();
diff --git a/js/src/jit-test/tests/large-buffers/basic.js b/js/src/jit-test/tests/large-buffers/basic.js
new file mode 100644
index 0000000000..58db1ee128
--- /dev/null
+++ b/js/src/jit-test/tests/large-buffers/basic.js
@@ -0,0 +1,50 @@
+// Basic smoke tests for large ArrayBuffers.
+
+let gb = 1 * 1024 * 1024 * 1024;
+
+function test1() {
+    let ab = new ArrayBuffer(7 * gb);
+    assertEq(ab.byteLength, 7 * gb);
+
+    let taInt16 = new Int16Array(ab);
+    assertEq(taInt16.byteOffset, 0);
+    assertEq(taInt16.byteLength, 7 * gb);
+    assertEq(taInt16.length, 3.5 * gb);
+
+    let taInt16LastGb = new Int16Array(ab, 6 * gb);
+    assertEq(taInt16LastGb.byteOffset, 6 * gb);
+    assertEq(taInt16LastGb.byteLength, 1 * gb);
+    assertEq(taInt16LastGb.length, 0.5 * gb);
+
+    taInt16LastGb[0] = -99;
+    assertEq(taInt16[3 * gb], -99);
+
+    let taUint8 = new Uint8Array(ab);
+    assertEq(taUint8.length, 7 * gb);
+    assertEq(taUint8[7 * gb - 1], 0);
+
+    taUint8[7 * gb - 1] = 42;
+    taUint8[7 * gb - 1]++;
+    ++taUint8[7 * gb - 1];
+    assertEq(taUint8[7 * gb - 1], 44);
+
+    let dv = new DataView(ab);
+    assertEq(dv.getInt16(6 * gb, true), -99);
+    assertEq(dv.getUint8(7 * gb - 1, true), 44);
+
+    dv.setInt16(6 * gb + 2, 123, true);
+    assertEq(taInt16LastGb[1], 123);
+}
+test1();
+
+function test2() {
+    let taInt8 = new Int8Array(4 * gb);
+    assertEq(taInt8.length, 4 * gb);
+    taInt8[4 * gb - 4] = 42;
+    assertEq(taInt8[4 * gb - 4], 42);
+
+    let dv = new DataView(taInt8.buffer);
+    assertEq(dv.getInt32(4 * gb - 4, true), 42);
+    assertEq(dv.getBigInt64(4 * gb - 8, true), 180388626432n);
+}
+test2();
diff --git a/js/src/jit-test/tests/large-buffers/directives.txt b/js/src/jit-test/tests/large-buffers/directives.txt
new file mode 100644
index 0000000000..67942e858f
--- /dev/null
+++ b/js/src/jit-test/tests/large-buffers/directives.txt
@@ -0,0 +1 @@
+|jit-test| --enable-large-buffers; --no-blinterp; skip-if: (getBuildConfiguration()["pointer-byte-size"] === 4)
diff --git a/js/src/jit-test/tests/large-buffers/shared-array-buffer.js b/js/src/jit-test/tests/large-buffers/shared-array-buffer.js
new file mode 100644
index 0000000000..608744b392
--- /dev/null
+++ b/js/src/jit-test/tests/large-buffers/shared-array-buffer.js
@@ -0,0 +1,40 @@
+// |jit-test| skip-if: !this.SharedArrayBuffer
+
+var gb = 1 * 1024 * 1024 * 1024;
+var sab = new SharedArrayBuffer(4 * gb + 10);
+var ta = new Uint8Array(sab);
+
+function testSlice() {
+    // Large |start| and |end|.
+    ta[4 * gb + 0] = 11;
+    ta[4 * gb + 1] = 22;
+    ta[4 * gb + 2] = 33;
+    ta[4 * gb + 3] = 44;
+    var ta2 = new Uint8Array(sab.slice(4 * gb, 4 * gb + 4));
+    assertEq(ta2.toString(), "11,22,33,44");
+
+    // Large |start|.
+    ta[ta.length - 3] = 99;
+    ta[ta.length - 2] = 88;
+    ta[ta.length - 1] = 77;
+    ta2 = new Uint8Array(sab.slice(4 * gb + 8));
+    assertEq(ta2.toString(), "88,77");
+
+    // Relative values.
+    ta2 = new Uint8Array(sab.slice(-3, -1));
+    assertEq(ta2.toString(), "99,88");
+
+    // Large relative values.
+    ta[0] = 100;
+    ta[1] = 101;
+    ta[2] = 102;
+    ta2 = new Uint8Array(sab.slice(-ta.length, -ta.length + 3));
+    assertEq(ta2.toString(), "100,101,102");
+}
+testSlice();
+
+function testSharedMailbox() {
+    setSharedObject(sab);
+    assertEq(getSharedObject().byteLength, 4 * gb + 10);
+}
+testSharedMailbox();
diff --git a/js/src/jit-test/tests/large-buffers/structured-clone.js b/js/src/jit-test/tests/large-buffers/structured-clone.js
new file mode 100644
index 0000000000..b9d3c70cb5
--- /dev/null
+++ b/js/src/jit-test/tests/large-buffers/structured-clone.js
@@ -0,0 +1,74 @@
+var gb = 1 * 1024 * 1024 * 1024;
+var ab = new ArrayBuffer(5 * gb);
+
+var ta1 = new Uint8Array(ab);
+
+for (var i = 0; i < 5; i++) {
+    ta1[i * gb + 0] = i + 1;
+    ta1[i * gb + 1] = i + 2;
+    ta1[i * gb + 2] = i + 3;
+    ta1[i * gb + 3] = i + 4;
+}
+
+function test(transferables, scope) {
+    var ta2 = new Int32Array(ab, ab.byteLength - 8, 2);
+    ta2[0] = 1234567;
+    var dv1 = new DataView(ab);
+    var dv2 = new DataView(ab, ab.byteLength - 8);
+    dv2.setInt32(4, -987654);
+    var objects = [ab, ta1, ta2, dv1, dv2];
+
+    var clonebuf = serialize(objects, transferables, {scope});
+    check(clonebuf);
+}
+
+function check(clonebuf) {
+    var objects = deserialize(clonebuf);
+    assertEq(objects.length, 5);
+
+    var ab = objects[0];
+    assertEq(ab instanceof ArrayBuffer, true);
+    assertEq(ab.byteLength, 5 * gb);
+
+    var ta1 = objects[1];
+    assertEq(ta1 instanceof Uint8Array, true);
+    assertEq(ta1.buffer, ab);
+    assertEq(ta1.byteOffset, 0);
+    assertEq(ta1.length, 5 * gb);
+
+    for (var i = 0; i < 5; i++) {
+        assertEq(ta1[i * gb + 0], i + 1);
+        assertEq(ta1[i * gb + 1], i + 2);
+        assertEq(ta1[i * gb + 2], i + 3);
+        assertEq(ta1[i * gb + 3], i + 4);
+    }
+
+    var ta2 = objects[2];
+    assertEq(ta2 instanceof Int32Array, true);
+    assertEq(ta2.buffer, ab);
+    assertEq(ta2.byteOffset, 5 * gb - 8);
+    assertEq(ta2.length, 2);
+    assertEq(ta2[0], 1234567);
+
+    var dv1 = objects[3];
+    assertEq(dv1 instanceof DataView, true);
+    assertEq(dv1.buffer, ab);
+    assertEq(dv1.byteOffset, 0);
+    assertEq(dv1.byteLength, 5 * gb);
+
+    var dv2 = objects[4];
+    assertEq(dv2 instanceof DataView, true);
+    assertEq(dv2.buffer, ab);
+    assertEq(dv2.byteOffset, 5 * gb - 8);
+    assertEq(dv2.byteLength, 8);
+    assertEq(dv2.getInt32(4), -987654);
+}
+
+// It would be nice to test serialization of the ArrayBuffer's contents, but it
+// causes OOMs and/or timeouts in automation so for now only test the more
+// efficient version that transfers the underlying buffer.
+//test([], "DifferentProcessForIndexedDB");
+//assertEq(ab.byteLength, 5 * gb);
+
+test([ab], "SameProcess");
+assertEq(ab.byteLength, 0);
diff --git a/js/src/jit-test/tests/large-buffers/typed-array.js b/js/src/jit-test/tests/large-buffers/typed-array.js
new file mode 100644
index 0000000000..4c7f816c06
--- /dev/null
+++ b/js/src/jit-test/tests/large-buffers/typed-array.js
@@ -0,0 +1,166 @@
+var gb = 1 * 1024 * 1024 * 1024;
+
+var ta = new Uint8Array(4 * gb + 10);
+
+function testSetFromTyped() {
+    var ta2 = new Int8Array(10);
+    ta2[0] = 23;
+    ta2[9] = -10;
+    ta.set(ta2, 4 * gb);
+    assertEq(ta[4 * gb + 0], 23);
+    assertEq(ta[4 * gb + 9], 246);
+}
+testSetFromTyped();
+
+function testSetFromOther() {
+    ta.set([12, 34], 4 * gb + 4);
+    assertEq(ta[4 * gb + 4], 12);
+    assertEq(ta[4 * gb + 5], 34);
+}
+testSetFromOther();
+
+function testCopyWithin() {
+    // Large |start|.
+    ta[ta.length - 1] = 3;
+    ta.copyWithin(0, 4 * gb);
+    assertEq(ta[9], 3);
+
+    // Large relative |start|.
+    ta[ta.length - 1] = 4;
+    ta.copyWithin(0, -10);
+    assertEq(ta[9], 4);
+
+    // Large |start| and |end|.
+    ta[ta.length - 3] = 5;
+    ta[ta.length - 2] = 66;
+    ta[1] = 1;
+    ta.copyWithin(0, ta.length - 3, ta.length - 2);
+    assertEq(ta[0], 5);
+    assertEq(ta[1], 1);
+
+    // Large |target| and |start|.
+    ta.copyWithin(4 * gb + 5, 4 * gb + 7);
+    assertEq(ta[4 * gb + 6], 66);
+
+    // Large |target|.
+    ta[6] = 117;
+    ta.copyWithin(4 * gb);
+    assertEq(ta[4 * gb + 6], 117);
+}
+testCopyWithin();
+
+function testSlice() {
+    // Large |start| and |end|.
+    ta[4 * gb + 0] = 11;
+    ta[4 * gb + 1] = 22;
+    ta[4 * gb + 2] = 33;
+    ta[4 * gb + 3] = 44;
+    var ta2 = ta.slice(4 * gb, 4 * gb + 4);
+    assertEq(ta2.toString(), "11,22,33,44");
+
+    // Large |start|.
+    ta[ta.length - 3] = 99;
+    ta[ta.length - 2] = 88;
+    ta[ta.length - 1] = 77;
+    ta2 = ta.slice(4 * gb + 8);
+    assertEq(ta2.toString(), "88,77");
+
+    // Relative values.
+    ta2 = ta.slice(-3, -1);
+    assertEq(ta2.toString(), "99,88");
+
+    // Large relative values.
+    ta[0] = 100;
+    ta[1] = 101;
+    ta[2] = 102;
+    ta2 = ta.slice(-ta.length, -ta.length + 3);
+    assertEq(ta2.toString(), "100,101,102");
+}
+testSlice();
+
+function testIterators() {
+    var ex;
+
+    ex = null;
+    try {
+        for (var p in ta) {}
+    } catch (e) {
+        ex = e;
+    }
+    assertEq(ex, "out of memory");
+
+    ex = null;
+    try {
+        Object.getOwnPropertyNames(ta);
+    } catch (e) {
+        ex = e;
+    }
+    assertEq(ex, "out of memory");
+}
+testIterators();
+
+function testArraySliceSparse() {
+    // Length mustn't exceed UINT32_MAX.
+    var len = 4 * gb - 1;
+    var ta2 = new Int8Array(ta.buffer, 0, len);
+    ta2[len - 1] = 1;
+
+    // The SliceSparse optimisation is only used for native objects which have the
+    // "indexed" flag set.
+    var o = {
+        length: len,
+        100000: 0, // sparse + indexed
+        __proto__: ta2,
+    };
+
+    // Collect sufficient elements to trigger the SliceSparse optimisation.
+    var r = Array.prototype.slice.call(o, -2000);
+    assertEq(r.length, 2000);
+    assertEq(r[r.length - 1], 1);
+}
+testArraySliceSparse();
+
+function testArrayIterator() {
+    for (var i = 0; i < 20; i++) {
+        ta[i] = i;
+    }
+    var sum = 0;
+    var i = 0;
+    for (var x of ta) {
+        if (i++ > 20) {
+            break;
+        }
+        sum += x;
+    }
+    assertEq(sum, 190);
+}
+testArrayIterator();
+
+function testArrayBufferSlice() {
+    // Large |start| and |end|.
+    ta[4 * gb + 0] = 11;
+    ta[4 * gb + 1] = 22;
+    ta[4 * gb + 2] = 33;
+    ta[4 * gb + 3] = 44;
+    var ta2 = new Uint8Array(ta.buffer.slice(4 * gb, 4 * gb + 4));
+    assertEq(ta2.toString(), "11,22,33,44");
+
+    // Large |start|.
+    ta[ta.length - 3] = 99;
+    ta[ta.length - 2] = 88;
+    ta[ta.length - 1] = 77;
+    ta2 = new Uint8Array(ta.buffer.slice(4 * gb + 8));
+    assertEq(ta2.toString(), "88,77");
+
+    // Relative values.
+    ta2 = new Uint8Array(ta.buffer.slice(-3, -1));
+    assertEq(ta2.toString(), "99,88");
+
+    // Large relative values.
+    ta[0] = 100;
+    ta[1] = 101;
+    ta[2] = 102;
+    ta2 = new Uint8Array(ta.buffer.slice(-ta.length, -ta.length + 3));
+    assertEq(ta2.toString(), "100,101,102");
+}
+testArrayBufferSlice();