bigint64-to-intptr-bailout.js (4856B)
1 // Int64 always in range of Int32. No Int64ToBigIntPtr bailout on 32- and 64-bit. 2 function i64InI32Range() { 3 var ta = new BigInt64Array([ 4 -0x8000_0000n, 5 -0x7fff_ffffn, 6 -2n, 7 -1n, 8 0n, 9 1n, 10 2n, 11 0x7fff_fffen, 12 0x7fff_ffffn, 13 ]); 14 15 // Add operation to trigger BigIntPtr code path. Don't use constant 0n to 16 // ensure compiler doesn't optimize away the addition. 17 var zero = new BigInt64Array([ 18 0n, 0n, 19 ]); 20 21 var N = 200; 22 for (var i = 0; i < N; ++i) { 23 var x = ta[i % ta.length]; 24 var y = zero[i & 1]; 25 var z = x + y; 26 assertEq(z, x); 27 } 28 } 29 for (var i = 0; i < 2; ++i) i64InI32Range(); 30 31 // Int64 not in range of Int32. Int64ToBigIntPtr bailout on 32-bit. 32 function i64NotInI32RangeBailout() { 33 var ta = new BigInt64Array([ 34 // Ensure not interpreted as signed Int32 value. 35 0x8000_0000n, 36 37 -0x8000_0000n, 38 -0x7fff_ffffn, 39 -2n, 40 -1n, 41 0n, 42 1n, 43 2n, 44 0x7fff_fffen, 45 0x7fff_ffffn, 46 ]); 47 48 // Add operation to trigger BigIntPtr code path. Don't use constant 0n to 49 // ensure compiler doesn't optimize away the addition. 50 var zero = new BigInt64Array([ 51 0n, 0n, 52 ]); 53 54 var N = 200; 55 for (var i = 0; i <= N; ++i) { 56 // Use index zero when |i == N|, but make sure all code paths are always 57 // executed to ensure there are no cold path bailouts. 58 var index = ((1 + (i % (ta.length - 1))) * (i < N))|0; 59 60 var x = ta[index]; 61 var y = zero[i & 1]; 62 var z = x + y; 63 assertEq(z, x); 64 } 65 assertEq(index, 0); 66 assertEq(x, 0x8000_0000n); 67 } 68 for (var i = 0; i < 2; ++i) i64NotInI32RangeBailout(); 69 70 // Int64 not in range of Int32. Int64ToBigIntPtr bailout on 32-bit. 71 function i64NotInI32RangeBailout2() { 72 var ta = new BigInt64Array([ 73 0x8000_0000_0000_0000n, 74 75 -0x8000_0000n, 76 -0x7fff_ffffn, 77 -2n, 78 -1n, 79 0n, 80 1n, 81 2n, 82 0x7fff_fffen, 83 0x7fff_ffffn, 84 ]); 85 86 // Add operation to trigger BigIntPtr code path. Don't use constant 0n to 87 // ensure compiler doesn't optimize away the addition. 88 var zero = new BigInt64Array([ 89 0n, 0n, 90 ]); 91 92 var N = 200; 93 for (var i = 0; i <= N; ++i) { 94 // Use index zero when |i == N|, but make sure all code paths are always 95 // executed to ensure there are no cold path bailouts. 96 var index = ((1 + (i % (ta.length - 1))) * (i < N))|0; 97 98 var x = ta[index]; 99 var y = zero[i & 1]; 100 var z = x + y; 101 assertEq(z, x); 102 } 103 assertEq(index, 0); 104 assertEq(x, -0x8000_0000_0000_0000n); 105 } 106 for (var i = 0; i < 2; ++i) i64NotInI32RangeBailout2(); 107 108 // UInt64 always in range of Int32. No Int64ToBigIntPtr bailout on 32- and 64-bit. 109 function u64InI32Range() { 110 var ta = new BigUint64Array([ 111 0n, 112 1n, 113 2n, 114 0x7fff_fffen, 115 0x7fff_ffffn, 116 ]); 117 118 // Add operation to trigger BigIntPtr code path. Don't use constant 0n to 119 // ensure compiler doesn't optimize away the addition. 120 var zero = new BigUint64Array([ 121 0n, 0n, 122 ]); 123 124 var N = 200; 125 for (var i = 0; i < N; ++i) { 126 var x = ta[i % ta.length]; 127 var y = zero[i & 1]; 128 var z = x + y; 129 assertEq(z, x); 130 } 131 } 132 for (var i = 0; i < 2; ++i) u64InI32Range(); 133 134 // UInt64 not in range of Int32. Int64ToBigIntPtr bailout on 32-bit. 135 function u64NotInI32RangeBailout() { 136 var ta = new BigUint64Array([ 137 0x8000_0000n, 138 139 0n, 140 1n, 141 2n, 142 0x7fff_fffen, 143 0x7fff_ffffn, 144 ]); 145 146 // Add operation to trigger BigIntPtr code path. Don't use constant 0n to 147 // ensure compiler doesn't optimize away the addition. 148 var zero = new BigUint64Array([ 149 0n, 0n, 150 ]); 151 152 var N = 200; 153 for (var i = 0; i <= N; ++i) { 154 // Use index zero when |i == N|, but make sure all code paths are always 155 // executed to ensure there are no cold path bailouts. 156 var index = ((1 + (i % (ta.length - 1))) * (i < N))|0; 157 158 var x = ta[index]; 159 var y = zero[i & 1]; 160 var z = x + y; 161 assertEq(z, x); 162 } 163 assertEq(index, 0); 164 assertEq(x, 0x8000_0000n); 165 } 166 for (var i = 0; i < 2; ++i) u64NotInI32RangeBailout(); 167 168 // UInt64 not in range of Int64. Int64ToBigIntPtr bailout on 32- and 64-bit. 169 function u64NotInI64RangeBailout() { 170 var ta = new BigUint64Array([ 171 0x8000_0000_0000_0000n, 172 173 0n, 174 1n, 175 2n, 176 0x7fff_fffen, 177 0x7fff_ffffn, 178 ]); 179 180 // Add operation to trigger BigIntPtr code path. Don't use constant 0n to 181 // ensure compiler doesn't optimize away the addition. 182 var zero = new BigUint64Array([ 183 0n, 0n, 184 ]); 185 186 var N = 200; 187 for (var i = 0; i <= N; ++i) { 188 // Use index zero when |i == N|, but make sure all code paths are always 189 // executed to ensure there are no cold path bailouts. 190 var index = ((1 + (i % (ta.length - 1))) * (i < N))|0; 191 192 var x = ta[index]; 193 var y = zero[i & 1]; 194 var z = x + y; 195 assertEq(z, x); 196 } 197 assertEq(index, 0); 198 assertEq(x, 0x8000_0000_0000_0000n); 199 } 200 for (var i = 0; i < 2; ++i) u64NotInI64RangeBailout();