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