test(jsc-stress): port the DataView JIT stress tests from JSTests

test/js/bun/jsc-stress/fixtures/dataview-get-cse.js

@@ -0,0 +1,158 @@
+// @bun
+"use strict";
+
+function assert(b) {
+    if (!b)
+        throw new Error;
+}
+
+function getIsLittleEndian() {
+    let ab = new ArrayBuffer(2);
+    let ta = new Int16Array(ab);
+    ta[0] = 0x0102;
+    let dv = new DataView(ab);
+    return dv.getInt16(0, true) === 0x0102;
+}
+
+let isLittleEndian = getIsLittleEndian();
+
+function adjustForEndianess(value) {
+    if (isLittleEndian)
+        return value;
+
+    let ab = new ArrayBuffer(8);
+    let ta = new Float64Array(ab);
+    ta[0] = value;
+    let dv = new DataView(ab);
+    return dv.getFloat64(0, true);
+}
+
+function test1() {
+    function foo(dv) {
+        return [dv.getFloat32(0), dv.getFloat64(0)];
+    }
+    noInline(foo);
+
+    let ab = new ArrayBuffer(8);
+    let dv = new DataView(ab);
+    dv.setFloat64(0, 128431.42342189432, false);
+    for (let i = 0; i < testLoopCount; ++i) {
+        let result = foo(dv);
+        assert(result[0] !== result[1]);
+    }
+}
+test1();
+
+function test2() {
+    function foo(dv) {
+        return [dv.getFloat32(0), dv.getFloat32(0)];
+    }
+    noInline(foo);
+
+    let ab = new ArrayBuffer(8);
+    let dv = new DataView(ab);
+    dv.setFloat64(0, 128431.42342189432, false);
+    for (let i = 0; i < testLoopCount; ++i) {
+        let result = foo(dv);
+        assert(result[0] === result[1]);
+    }
+}
+test2();
+
+function test3() {
+    function foo(dv, ta) {
+        let a = dv.getFloat64(0, true);
+        ta[0] = adjustForEndianess(Math.PI);
+        let b = dv.getFloat64(0, true);
+        return [a, b];
+    }
+    noInline(foo);
+
+    let ab = new ArrayBuffer(8);
+    let dv = new DataView(ab);
+    let ta = new Float64Array(ab);
+    for (let i = 0; i < 40000; ++i) {
+        dv.setFloat64(0, 0.0, true);
+        let result = foo(dv, ta);
+        assert(result[0] === 0.0);
+        assert(result[1] === Math.PI);
+    }
+}
+test3();
+
+function test4() {
+    function foo(dv) {
+        let a = dv.getInt32(0, true);
+        let b = dv.getInt32(0, false);
+        return [a, b];
+    }
+    noInline(foo);
+
+    let ab = new ArrayBuffer(8);
+    let dv = new DataView(ab);
+    dv.setInt32(0, 0x11223344, true);
+    for (let i = 0; i < 40000; ++i) {
+        let result = foo(dv);
+        assert(result[0] === 0x11223344);
+        assert(result[1] === 0x44332211)
+    }
+}
+test4();
+
+function test5() {
+    function foo(dv, littleEndian) {
+        let a = dv.getInt32(0, littleEndian);
+        let b = dv.getInt32(0, !littleEndian);
+        return [a, b];
+    }
+    noInline(foo);
+
+    let ab = new ArrayBuffer(8);
+    let dv = new DataView(ab);
+    dv.setInt32(0, 0x11223344, true);
+    for (let i = 0; i < 40000; ++i) {
+        let result = foo(dv, true);
+        assert(result[0] === 0x11223344);
+        assert(result[1] === 0x44332211)
+    }
+}
+test5();
+
+function test6() {
+    function foo(dv, littleEndian) {
+        let a = dv.getInt32(0, littleEndian);
+        let b = dv.getInt32(0, littleEndian);
+        return [a, b];
+    }
+    noInline(foo);
+
+    let ab = new ArrayBuffer(8);
+    let dv = new DataView(ab);
+    dv.setInt32(0, 0x11223344, true);
+    for (let i = 0; i < 40000; ++i) {
+        let result = foo(dv, true);
+        assert(result[0] === 0x11223344);
+        assert(result[1] === 0x11223344)
+    }
+}
+test6();
+
+function test7() {
+    function foo(dv) {
+        let a = dv.getInt32(0, true);
+        let b = dv.getInt32(4, true);
+        return [a, b];
+    }
+    noInline(foo);
+
+    let ab = new ArrayBuffer(8);
+    let dv = new DataView(ab);
+    dv.setInt32(0, 0x11223344, true);
+    dv.setInt32(4, 0x12121212, true);
+    for (let i = 0; i < 40000; ++i) {
+        let result = foo(dv, true);
+        assert(result[0] === 0x11223344);
+        assert(result[1] === 0x12121212);
+    }
+}
+test7();

test/js/bun/jsc-stress/fixtures/dataview-jit-bigint64-byte-offset.js

@@ -0,0 +1,41 @@
+// @bun
+function shouldBe(actual, expected) {
+    if (actual !== expected)
+        throw new Error("bad value: " + actual + " expected: " + expected);
+}
+
+function shouldThrow(func, errorType) {
+    let error = null;
+    try {
+        func();
+    } catch (e) {
+        error = e;
+    }
+    if (!(error instanceof errorType))
+        throw new Error("bad error: " + error);
+}
+
+function get(dv, offset) { return dv.getBigUint64(offset, true); }
+function set(dv, offset, value) { dv.setBigUint64(offset, value, true); }
+noInline(get);
+noInline(set);
+
+const buffer = new ArrayBuffer(32);
+const bytes = new Uint8Array(buffer);
+const dv = new DataView(buffer, 8, 16);
+
+for (let i = 0; i < testLoopCount; i++) {
+    set(dv, 0, 0x0807060504030201n);
+    for (let j = 0; j < 8; j++)
+        shouldBe(bytes[8 + j], j + 1);
+    shouldBe(get(dv, 0), 0x0807060504030201n);
+
+    set(dv, 8, BigInt(i));
+    shouldBe(get(dv, 8), BigInt(i));
+    for (let j = 0; j < 8; j++)
+        shouldBe(bytes[16 + j], Number((BigInt(i) >> BigInt(8 * j)) & 0xffn));
+}
+
+shouldThrow(() => get(dv, 9), RangeError);
+shouldThrow(() => set(dv, 16, 1n), RangeError);
+shouldThrow(() => get(dv, -1), RangeError);

test/js/bun/jsc-stress/fixtures/dataview-jit-bigint64-cse-and-aliasing.js

@@ -0,0 +1,51 @@
+// @bun
+function shouldBe(actual, expected) {
+    if (actual !== expected)
+        throw new Error("bad value: " + actual + " expected: " + expected);
+}
+
+function getSetGet(dv, offset, value) {
+    let before = dv.getBigInt64(offset, true);
+    dv.setBigInt64(offset, value, true);
+    let after = dv.getBigInt64(offset, true);
+    return [before, after];
+}
+noInline(getSetGet);
+
+function getTwice(dv, offset) {
+    let a = dv.getBigUint64(offset, false);
+    let b = dv.getBigUint64(offset, false);
+    return [a, b];
+}
+noInline(getTwice);
+
+function getArrayStoreGet(dv, array, index, value) {
+    let before = dv.getBigUint64(index * 8, true);
+    array[index] = value;
+    let after = dv.getBigUint64(index * 8, true);
+    return [before, after];
+}
+noInline(getArrayStoreGet);
+
+const dv = new DataView(new ArrayBuffer(64));
+for (let i = 0; i < testLoopCount; i++) {
+    dv.setBigInt64(8, BigInt(i), true);
+    let [before, after] = getSetGet(dv, 8, BigInt(-i) - 1n);
+    shouldBe(before, BigInt(i));
+    shouldBe(after, BigInt(-i) - 1n);
+
+    dv.setBigUint64(16, BigInt(i) * 3n, false);
+    let [a, b] = getTwice(dv, 16);
+    shouldBe(a, BigInt(i) * 3n);
+    shouldBe(b, BigInt(i) * 3n);
+}
+
+const buffer = new ArrayBuffer(64);
+const aliasedView = new DataView(buffer);
+const array = new BigUint64Array(buffer);
+for (let i = 0; i < testLoopCount; i++) {
+    array[2] = BigInt(i);
+    let [before, after] = getArrayStoreGet(aliasedView, array, 2, BigInt(i) + (1n << 40n));
+    shouldBe(before, BigInt(i));
+    shouldBe(after, BigInt(i) + (1n << 40n));
+}

test/js/bun/jsc-stress/fixtures/dataview-jit-bigint64-type-check-failures.js

@@ -0,0 +1,51 @@
+// @bun
+function shouldBe(actual, expected) {
+    if (actual !== expected)
+        throw new Error("bad value: " + actual + " expected: " + expected);
+}
+
+function shouldThrow(func, errorType) {
+    let error = null;
+    try {
+        func();
+    } catch (e) {
+        error = e;
+    }
+    if (!(error instanceof errorType))
+        throw new Error("bad error: " + error);
+}
+
+function get(dv, offset, littleEndian) { return dv.getBigUint64(offset, littleEndian); }
+function set(dv, offset, value, littleEndian) { dv.setBigUint64(offset, value, littleEndian); }
+noInline(get);
+noInline(set);
+
+const dv = new DataView(new ArrayBuffer(64));
+for (let i = 0; i < testLoopCount; i++) {
+    set(dv, 8, 0x0102030405060708n, true);
+    shouldBe(get(dv, 8, true), 0x0102030405060708n);
+}
+
+shouldBe(get(dv, 8.9, true), 0x0102030405060708n);
+shouldBe(get(dv, "8", true), 0x0102030405060708n);
+shouldBe(get(dv, [8], true), 0x0102030405060708n);
+shouldThrow(() => get(dv, 8n, true), TypeError);
+shouldThrow(() => get(dv, Symbol("8"), true), TypeError);
+shouldBe(get(dv, NaN, true), 0n);
+
+set(dv, 16.7, 0xa1a2a3a4a5a6a7a8n, true);
+shouldBe(get(dv, 16, true), 0xa1a2a3a4a5a6a7a8n);
+shouldThrow(() => set(dv, 8n, 1n, true), TypeError);
+
+shouldBe(get(dv, 8, 1), 0x0102030405060708n);
+shouldBe(get(dv, 8, "yes"), 0x0102030405060708n);
+shouldBe(get(dv, 8, undefined), 0x0807060504030201n);
+shouldBe(get(dv, 8, null), 0x0807060504030201n);
+shouldBe(get(dv, 8, {}), 0x0102030405060708n);
+set(dv, 24, 0x1112131415161718n, 0);
+shouldBe(get(dv, 24, false), 0x1112131415161718n);
+
+shouldThrow(() => get({}, 0, true), TypeError);
+shouldThrow(() => get(new Uint8Array(64), 0, true), TypeError);
+shouldThrow(() => set(null, 0, 1n, true), TypeError);
+shouldThrow(() => get.call(undefined, DataView.prototype, 0, true), TypeError);