Add BigInt64Array shim for Safari 14

ChangeLog.md

@@ -20,6 +20,8 @@ See docs/process.md for more on how version tagging works.
 
 3.1.15
 ------
+- Added a shim for `BigInt64Array` so `-sWASM_BIGINT` can be used in Safari
+  v14. (#17103)
 
 3.1.14 - 06/20/2022
 -------------------

src/polyfill/bigint64array.js

@@ -0,0 +1,115 @@
+#if !POLYFILL
+assert(false, "this file should never be included unless POLYFILL is set");
+#endif
+
+if (typeof globalThis.BigInt64Array === "undefined") {
+  // BigInt64Array polyfill for Safari versions between v14.0 and v15.0.
+  // All browsers other than Safari added BigInt and BigInt64Array at the same
+  // time, but Safari introduced BigInt in v14.0 and introduced BigInt64Array in
+  // v15.0
+
+  function partsToBigIntSigned(lower, upper) {
+    return BigInt(lower) | (BigInt(upper + 2 * (upper & 0x80000000)) << 32n);
+  }
+
+  function partsToBigIntUnsigned(lower, upper) {
+    return BigInt(lower) | (BigInt(upper) << 32n);
+  }
+
+  function bigIntToParts(value) {
+    var lower = Number(BigInt(value) & BigInt(0xffffffff)) | 0;
+    var upper = Number(BigInt(value) >> 32n) | 0;
+    return [lower, upper];
+  }
+
+  function createBigIntArrayShim(partsToBigInt) {
+    function createBigInt64Array(array) {
+      if (typeof array === "number") {
+        array = new Uint32Array(2 * array);
+      }
+      var orig_array;
+      if (!ArrayBuffer.isView(array)) {
+        if (array.constructor && array.constructor.name === "ArrayBuffer") {
+          array = new Uint32Array(array);
+        } else {
+          orig_array = array;
+          array = new Uint32Array(array.length * 2);
+        }
+      }
+      var proxy = new Proxy(
+        {
+          slice: function (min, max) {
+            if (max === undefined) {
+              max = array.length;
+            }
+            var new_buf = array.slice(min * 2, max * 2);
+            return createBigInt64Array(new_buf);
+          },
+          subarray: function (min, max) {
+            var new_buf = array.subarray(min * 2, max * 2);
+            return createBigInt64Array(new_buf);
+          },
+          [Symbol.iterator]: function* () {
+            for (var i = 0; i < array.length / 2; i++) {
+              yield partsToBigInt(array[2 * i], array[2 * i + 1]);
+            }
+          },
+          BYTES_PER_ELEMENT: 2 * array.BYTES_PER_ELEMENT,
+          buffer: array.buffer,
+          byteLength: array.byteLength,
+          byteOffset: array.byteOffset,
+          length: array.length / 2,
+          copyWithin: function (target, start, end) {
+            array.copyWithin(target * 2, start * 2, end * 2);
+            return proxy;
+          },
+          set: function (source, targetOffset) {
+            if (targetOffset === undefined) {
+              targetOffset = 0;
+            }
+            if (2 * (source.length + targetOffset) > array.length) {
+              // This is the Chrome error message
+              // Firefox: "invalid or out-of-range index"
+              throw new RangeError("offset is out of bounds");
+            }
+            for (var i = 0; i < source.length; i++) {
+              var value = source[i];
+              var pair = bigIntToParts(value);
+              array.set(pair, 2 * (targetOffset + i));
+            }
+          },
+        },
+        {
+          get: function (target, idx, receiver) {
+            if (typeof idx !== "string" || !/^\d+$/.test(idx)) {
+              return Reflect.get(target, idx, receiver);
+            }
+            var lower = array[idx * 2];
+            var upper = array[idx * 2 + 1];
+            return partsToBigInt(lower, upper);
+          },
+          set: function (target, idx, value, receiver) {
+            if (typeof idx !== "string" || !/^\d+$/.test(idx)) {
+              return Reflect.set(target, idx, value, receiver);
+            }
+            if (typeof value !== "bigint") {
+              // Chrome error message, Firefox has no "a" in front if "BigInt".
+              throw new TypeError(`Cannot convert ${value} to a BigInt`);
+            }
+            var pair = bigIntToParts(value);
+            array.set(pair, 2 * idx);
+            return true;
+          },
+        }
+      );
+      if (orig_array) {
+        proxy.set(orig_array);
+      }
+      return proxy;
+    }
+    return createBigInt64Array;
+  }
+
+  globalThis.BigUint64Array = createBigIntArrayShim(partsToBigIntUnsigned);
+  globalThis.BigInt64Array = createBigIntArrayShim(partsToBigIntSigned);
+}

src/shell.js

@@ -51,6 +51,11 @@ var Module = typeof {{{ EXPORT_NAME }}} != 'undefined' ? {{{ EXPORT_NAME }}} : {
 #if MIN_CHROME_VERSION < 45 || MIN_EDGE_VERSION < 12 || MIN_FIREFOX_VERSION < 34 || MIN_IE_VERSION != TARGET_NOT_SUPPORTED || MIN_SAFARI_VERSION < 90000
 #include "polyfill/objassign.js"
 #endif
+
+// See https://caniuse.com/mdn-javascript_builtins_bigint64array
+#if WASM_BIGINT && MIN_SAFARI_VERSION < 150000
+#include "polyfill/bigint64array.js"
+#endif
 #endif // POLYFILL
 
 #if MODULARIZE

tests/test_bigint64array_polyfill.js

@@ -0,0 +1,96 @@
+let result = {};
+result.BigInt64Array_name = BigInt64Array.name;
+let arr2signed = new BigInt64Array(arr1signed.buffer);
+let arr2unsigned = new BigUint64Array(arr1unsigned.buffer);
+
+result.arr1_to_arr1_signed = [];
+for(let x of bigint_list){
+  arr1signed[0] = x;
+  result.arr1_to_arr1_signed.push(arr1signed[0]);
+}
+
+result.arr1_to_arr1_unsigned = [];
+for(let x of bigint_list){
+  arr1unsigned[0] = x;
+  result.arr1_to_arr1_unsigned.push(arr1unsigned[0]);
+}
+
+result.arr1_to_arr2_signed = [];
+for(let x of bigint_list){
+  arr1signed[0] = x;
+  result.arr1_to_arr2_signed.push(arr2signed[0]);
+}
+
+result.arr1_to_arr2_unsigned = [];
+for(let x of bigint_list){
+  arr1unsigned[0] = x;
+  result.arr1_to_arr2_unsigned.push(arr2unsigned[0]);
+}
+
+result.arr2_to_arr1_signed = [];
+for(let x of bigint_list){
+  arr2signed[0] = x;
+  result.arr2_to_arr1_signed.push(arr1signed[0]);
+}
+
+result.arr2_to_arr1_unsigned = [];
+for(let x of bigint_list){
+  arr2unsigned[0] = x;
+  result.arr2_to_arr1_unsigned.push(arr1unsigned[0]);
+}
+
+
+result.assertEquals = [];
+function assertEqual(cb){
+  result.assertEquals.push([cb.toString(), cb()]);
+}
+
+let arr1 = arr1unsigned;
+let arr2 = arr2unsigned;
+assertEqual(() => [arr2.BYTES_PER_ELEMENT, arr1.BYTES_PER_ELEMENT]);
+assertEqual(() => [arr2.byteLength, arr1.byteLength]);
+assertEqual(() => [arr2.length, arr1.length]);
+assertEqual(() => [arr2.slice().length, arr1.slice().length]);
+assertEqual(() => [arr2.slice(1, 5).length, arr1.slice(1, 5).length]);
+
+arr1[0] = 1n; arr1[1] = 2n; arr1[2] = 3n; arr1[3] = 4n; arr1[4] = 5n;
+
+result.arr2_slice = Array.from(arr2.slice(1, 5));
+result.arr2_subarray = Array.from(arr2.subarray(1, 5));
+let reducer = (k, v) => typeof v  === 'bigint' ? v.toString() + 'n' : v;
+function arraytostring(arr){
+  return JSON.stringify(Array.from(Array.from(arr)), reducer);
+}
+
+let sub = arr2.subarray(1, 5);
+assertEqual(() => [sub.byteOffset, 8]);
+sub[0] = 7n; sub[1] = 77n; sub[2] = 3n; sub[3] = 66n;
+assertEqual(() => [arraytostring(arr1.slice(0, 5)), '["1n","7n","77n","3n","66n"]']);
+
+arr1[2] = 62n;
+assertEqual(() => [sub[1], 62n]);
+
+let slice = arr2.slice(1, 5);
+assertEqual(() => [slice.byteOffset, 0]);
+
+slice[0] = 777n; slice[1] = 666n; slice[2] = 555n;
+assertEqual(() => [arraytostring(arr1.slice(0, 5)), '["1n","7n","62n","3n","66n"]']);
+
+arr2.set([2n, 4n, 8n]);
+assertEqual(() => [arraytostring(arr1.slice(0, 3)), '["2n","4n","8n"]']);
+
+arr2.set([1n, 3n, 7n], 6);
+assertEqual(() => [arraytostring(arr1.slice(6, 9)), '["1n","3n","7n"]']);
+
+arr1[15] = 111n; arr1[18] = 171n; arr1[19] = 629n;
+
+assertEqual(() => [arraytostring(arr2.slice(-1)), '["629n"]']);
+assertEqual(() => [arraytostring(arr2.slice(-5, -1)), '["111n","0n","0n","171n"]']);
+assertEqual(() => [arraytostring(arr2.slice(-5, -6)), '[]']);
+
+arr3 = new BigUint64Array(Array.from({length:5}, (_, idx) => BigInt(idx)));
+assertEqual(() => [arraytostring(arr3), '["0n","1n","2n","3n","4n"]']);
+arr3.copyWithin(0, 2, 10);
+assertEqual(() => [arraytostring(arr3), '["2n","3n","4n","3n","4n"]']);
+
+console.log(JSON.stringify(result, reducer));

tests/test_other.py

@@ -12226,3 +12226,53 @@ def test_rust_gxx_personality_v0(self):
         }
       }
     ''', assert_returncode=NON_ZERO)
+
+  def test_bigint64array_polyfill(self):
+    bigint64array = read_file(path_from_root('src/polyfill/bigint64array.js'))
+    test_code = read_file(test_file('test_bigint64array_polyfill.js'))
+    bigint_list = [
+      0,
+      1,
+      -1,
+      5,
+      (1 << 64),
+      (1 << 64) - 1,
+      (1 << 64) + 1,
+      (1 << 63),
+      (1 << 63) - 1,
+      (1 << 63) + 1,
+    ]
+    bigint_list_strs = [str(x) for x in bigint_list]
+
+    bigint_list_unsigned = [x % (1 << 64) for x in bigint_list]
+    bigint_list_signed = [
+      x if x < 0 else (x % (1 << 64)) - 2 * (x & (1 << 63)) for x in bigint_list
+    ]
+    bigint_list_unsigned_n = [f'{x}n' for x in bigint_list_unsigned]
+    bigint_list_signed_n = [f'{x}n' for x in bigint_list_signed]
+
+    bigint64array = '\n'.join(bigint64array.splitlines()[3:])
+
+    create_file(
+      'test.js',
+      f'''
+      let bigint_list = {bigint_list_strs}.map(x => BigInt(x));
+      let arr1signed = new BigInt64Array(20);
+      let arr1unsigned = new BigUint64Array(20);
+      delete globalThis.BigInt64Array;
+      ''' + bigint64array + test_code
+    )
+    output = json.loads(self.run_js('test.js'))
+    self.assertEqual(output['BigInt64Array_name'], 'createBigInt64Array')
+    for key in ['arr1_to_arr1', 'arr1_to_arr2', 'arr2_to_arr1']:
+      print(key + '_unsigned')
+      self.assertEqual(output[key + '_unsigned'], bigint_list_unsigned_n)
+    for key in ['arr1_to_arr1', 'arr1_to_arr2', 'arr2_to_arr1']:
+      print(key + '_signed')
+      self.assertEqual(output[key + '_signed'], bigint_list_signed_n)
+
+    self.assertEqual(output['arr2_slice'], ['2n', '3n', '4n', '5n'])
+    self.assertEqual(output['arr2_subarray'], ['2n', '3n', '4n', '5n'])
+
+    for m, [v1, v2] in output['assertEquals']:
+      self.assertEqual(v1, v2, msg=m)