tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

bigint-or.js (3066B)

      1 // |jit-test| test-join=--spectre-mitigations=off
      2 
      3 // These do not test atomicity, just that code generation for BigInt values
      4 // works correctly.
      5 
      6 const bigIntValues = [
      7  // Definitely heap digits.
      8  -(2n ** 2000n),
      9  -(2n ** 1000n),
     10 
     11  // -(2n**64n)
     12  -18446744073709551617n,
     13  -18446744073709551616n,
     14  -18446744073709551615n,
     15 
     16  // -(2n**63n)
     17  -9223372036854775809n,
     18  -9223372036854775808n,
     19  -9223372036854775807n,
     20 
     21  // -(2**32)
     22  -4294967297n,
     23  -4294967296n,
     24  -4294967295n,
     25 
     26  // -(2**31)
     27  -2147483649n,
     28  -2147483648n,
     29  -2147483647n,
     30 
     31  -1n,
     32  0n,
     33  1n,
     34 
     35  // 2**31
     36  2147483647n,
     37  2147483648n,
     38  2147483649n,
     39 
     40  // 2**32
     41  4294967295n,
     42  4294967296n,
     43  4294967297n,
     44 
     45  // 2n**63n
     46  9223372036854775807n,
     47  9223372036854775808n,
     48  9223372036854775809n,
     49 
     50  // 2n**64n
     51  18446744073709551615n,
     52  18446744073709551616n,
     53  18446744073709551617n,
     54 
     55  // Definitely heap digits.
     56  2n ** 1000n,
     57  2n ** 2000n,
     58 ];
     59 
     60 function testOr() {
     61  const int64 = new BigInt64Array(2);
     62  const uint64 = new BigUint64Array(2);
     63 
     64  const int64All = -1n;
     65  const uint64All = 0xffff_ffff_ffff_ffffn;
     66 
     67  // Test with constant index.
     68  for (let i = 0; i < 20; ++i) {
     69    for (let j = 0; j < bigIntValues.length; ++j) {
     70      let value = bigIntValues[j];
     71 
     72      // x | 0 == x
     73      assertEq(Atomics.or(int64, 0, value), 0n);
     74      assertEq(int64[0], BigInt.asIntN(64, value));
     75 
     76      assertEq(Atomics.or(uint64, 0, value), 0n);
     77      assertEq(uint64[0], BigInt.asUintN(64, value));
     78 
     79      // 0 | x == x
     80      assertEq(Atomics.or(int64, 0, 0n), BigInt.asIntN(64, value));
     81      assertEq(int64[0], BigInt.asIntN(64, value));
     82 
     83      assertEq(Atomics.or(uint64, 0, 0n), BigInt.asUintN(64, value));
     84      assertEq(uint64[0], BigInt.asUintN(64, value));
     85 
     86      // x | ~x == -1
     87      assertEq(Atomics.or(int64, 0, ~value), BigInt.asIntN(64, value));
     88      assertEq(int64[0], int64All);
     89 
     90      assertEq(Atomics.or(uint64, 0, ~value), BigInt.asUintN(64, value));
     91      assertEq(uint64[0], uint64All);
     92 
     93      int64[0] = 0n;
     94      uint64[0] = 0n;
     95    }
     96  }
     97 
     98  // Test with variable index.
     99  for (let i = 0; i < 20; ++i) {
    100    for (let j = 0; j < bigIntValues.length; ++j) {
    101      let value = bigIntValues[j];
    102      let idx = j & 1;
    103 
    104      // x | 0 == x
    105      assertEq(Atomics.or(int64, idx, value), 0n);
    106      assertEq(int64[idx], BigInt.asIntN(64, value));
    107 
    108      assertEq(Atomics.or(uint64, idx, value), 0n);
    109      assertEq(uint64[idx], BigInt.asUintN(64, value));
    110 
    111      // 0 | x == x
    112      assertEq(Atomics.or(int64, idx, 0n), BigInt.asIntN(64, value));
    113      assertEq(int64[idx], BigInt.asIntN(64, value));
    114 
    115      assertEq(Atomics.or(uint64, idx, 0n), BigInt.asUintN(64, value));
    116      assertEq(uint64[idx], BigInt.asUintN(64, value));
    117 
    118      // x | ~x == -1
    119      assertEq(Atomics.or(int64, idx, ~value), BigInt.asIntN(64, value));
    120      assertEq(int64[idx], int64All);
    121 
    122      assertEq(Atomics.or(uint64, idx, ~value), BigInt.asUintN(64, value));
    123      assertEq(uint64[idx], uint64All);
    124 
    125      int64[idx] = 0n;
    126      uint64[idx] = 0n;
    127    }
    128  }
    129 }
    130 for (let i = 0; i < 2; ++i) testOr();