1 // Copyright 2014 the V8 project authors. All rights reserved. Use of this 2 // source code is governed by a BSD-style license that can be found in the 3 // LICENSE file. 4 5 #include <cmath> 6 #include <functional> 7 #include <limits> 8 9 #include "src/base/bits.h" 10 #include "src/base/ieee754.h" 11 #include "src/base/utils/random-number-generator.h" 12 #include "src/codegen.h" 13 #include "test/cctest/cctest.h" 14 #include "test/cctest/compiler/codegen-tester.h" 15 #include "test/cctest/compiler/graph-builder-tester.h" 16 #include "test/cctest/compiler/value-helper.h" 17 18 using namespace v8::base; 19 20 namespace v8 { 21 namespace internal { 22 namespace compiler { 23 24 25 TEST(RunInt32Add) { 26 RawMachineAssemblerTester<int32_t> m; 27 Node* add = m.Int32Add(m.Int32Constant(0), m.Int32Constant(1)); 28 m.Return(add); 29 CHECK_EQ(1, m.Call()); 30 } 31 32 static int RunInt32AddShift(bool is_left, int32_t add_left, int32_t add_right, 33 int32_t shift_left, int32_t shit_right) { 34 RawMachineAssemblerTester<int32_t> m; 35 Node* shift = 36 m.Word32Shl(m.Int32Constant(shift_left), m.Int32Constant(shit_right)); 37 Node* add = m.Int32Add(m.Int32Constant(add_left), m.Int32Constant(add_right)); 38 Node* lsa = is_left ? m.Int32Add(shift, add) : m.Int32Add(add, shift); 39 m.Return(lsa); 40 return m.Call(); 41 } 42 43 TEST(RunInt32AddShift) { 44 struct Test_case { 45 int32_t add_left, add_right, shift_left, shit_right, expected; 46 }; 47 48 Test_case tc[] = { 49 {20, 22, 4, 2, 58}, 50 {20, 22, 4, 1, 50}, 51 {20, 22, 1, 6, 106}, 52 {INT_MAX - 2, 1, 1, 1, INT_MIN}, // INT_MAX - 2 + 1 + (1 << 1), overflow. 53 }; 54 const size_t tc_size = sizeof(tc) / sizeof(Test_case); 55 56 for (size_t i = 0; i < tc_size; ++i) { 57 CHECK_EQ(tc[i].expected, 58 RunInt32AddShift(false, tc[i].add_left, tc[i].add_right, 59 tc[i].shift_left, tc[i].shit_right)); 60 CHECK_EQ(tc[i].expected, 61 RunInt32AddShift(true, tc[i].add_left, tc[i].add_right, 62 tc[i].shift_left, tc[i].shit_right)); 63 } 64 } 65 66 TEST(RunWord32ReverseBits) { 67 BufferedRawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 68 if (!m.machine()->Word32ReverseBits().IsSupported()) { 69 // We can only test the operator if it exists on the testing platform. 70 return; 71 } 72 m.Return(m.AddNode(m.machine()->Word32ReverseBits().op(), m.Parameter(0))); 73 74 CHECK_EQ(uint32_t(0x00000000), m.Call(uint32_t(0x00000000))); 75 CHECK_EQ(uint32_t(0x12345678), m.Call(uint32_t(0x1e6a2c48))); 76 CHECK_EQ(uint32_t(0xfedcba09), m.Call(uint32_t(0x905d3b7f))); 77 CHECK_EQ(uint32_t(0x01010101), m.Call(uint32_t(0x80808080))); 78 CHECK_EQ(uint32_t(0x01020408), m.Call(uint32_t(0x10204080))); 79 CHECK_EQ(uint32_t(0xf0703010), m.Call(uint32_t(0x080c0e0f))); 80 CHECK_EQ(uint32_t(0x1f8d0a3a), m.Call(uint32_t(0x5c50b1f8))); 81 CHECK_EQ(uint32_t(0xffffffff), m.Call(uint32_t(0xffffffff))); 82 } 83 84 85 TEST(RunWord32Ctz) { 86 BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32()); 87 if (!m.machine()->Word32Ctz().IsSupported()) { 88 // We can only test the operator if it exists on the testing platform. 89 return; 90 } 91 m.Return(m.AddNode(m.machine()->Word32Ctz().op(), m.Parameter(0))); 92 93 CHECK_EQ(32, m.Call(uint32_t(0x00000000))); 94 CHECK_EQ(31, m.Call(uint32_t(0x80000000))); 95 CHECK_EQ(30, m.Call(uint32_t(0x40000000))); 96 CHECK_EQ(29, m.Call(uint32_t(0x20000000))); 97 CHECK_EQ(28, m.Call(uint32_t(0x10000000))); 98 CHECK_EQ(27, m.Call(uint32_t(0xa8000000))); 99 CHECK_EQ(26, m.Call(uint32_t(0xf4000000))); 100 CHECK_EQ(25, m.Call(uint32_t(0x62000000))); 101 CHECK_EQ(24, m.Call(uint32_t(0x91000000))); 102 CHECK_EQ(23, m.Call(uint32_t(0xcd800000))); 103 CHECK_EQ(22, m.Call(uint32_t(0x09400000))); 104 CHECK_EQ(21, m.Call(uint32_t(0xaf200000))); 105 CHECK_EQ(20, m.Call(uint32_t(0xac100000))); 106 CHECK_EQ(19, m.Call(uint32_t(0xe0b80000))); 107 CHECK_EQ(18, m.Call(uint32_t(0x9ce40000))); 108 CHECK_EQ(17, m.Call(uint32_t(0xc7920000))); 109 CHECK_EQ(16, m.Call(uint32_t(0xb8f10000))); 110 CHECK_EQ(15, m.Call(uint32_t(0x3b9f8000))); 111 CHECK_EQ(14, m.Call(uint32_t(0xdb4c4000))); 112 CHECK_EQ(13, m.Call(uint32_t(0xe9a32000))); 113 CHECK_EQ(12, m.Call(uint32_t(0xfca61000))); 114 CHECK_EQ(11, m.Call(uint32_t(0x6c8a7800))); 115 CHECK_EQ(10, m.Call(uint32_t(0x8ce5a400))); 116 CHECK_EQ(9, m.Call(uint32_t(0xcb7d0200))); 117 CHECK_EQ(8, m.Call(uint32_t(0xcb4dc100))); 118 CHECK_EQ(7, m.Call(uint32_t(0xdfbec580))); 119 CHECK_EQ(6, m.Call(uint32_t(0x27a9db40))); 120 CHECK_EQ(5, m.Call(uint32_t(0xde3bcb20))); 121 CHECK_EQ(4, m.Call(uint32_t(0xd7e8a610))); 122 CHECK_EQ(3, m.Call(uint32_t(0x9afdbc88))); 123 CHECK_EQ(2, m.Call(uint32_t(0x9afdbc84))); 124 CHECK_EQ(1, m.Call(uint32_t(0x9afdbc82))); 125 CHECK_EQ(0, m.Call(uint32_t(0x9afdbc81))); 126 } 127 128 TEST(RunWord32Clz) { 129 BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32()); 130 m.Return(m.Word32Clz(m.Parameter(0))); 131 132 CHECK_EQ(0, m.Call(uint32_t(0x80001000))); 133 CHECK_EQ(1, m.Call(uint32_t(0x40000500))); 134 CHECK_EQ(2, m.Call(uint32_t(0x20000300))); 135 CHECK_EQ(3, m.Call(uint32_t(0x10000003))); 136 CHECK_EQ(4, m.Call(uint32_t(0x08050000))); 137 CHECK_EQ(5, m.Call(uint32_t(0x04006000))); 138 CHECK_EQ(6, m.Call(uint32_t(0x02000000))); 139 CHECK_EQ(7, m.Call(uint32_t(0x010000a0))); 140 CHECK_EQ(8, m.Call(uint32_t(0x00800c00))); 141 CHECK_EQ(9, m.Call(uint32_t(0x00400000))); 142 CHECK_EQ(10, m.Call(uint32_t(0x0020000d))); 143 CHECK_EQ(11, m.Call(uint32_t(0x00100f00))); 144 CHECK_EQ(12, m.Call(uint32_t(0x00080000))); 145 CHECK_EQ(13, m.Call(uint32_t(0x00041000))); 146 CHECK_EQ(14, m.Call(uint32_t(0x00020020))); 147 CHECK_EQ(15, m.Call(uint32_t(0x00010300))); 148 CHECK_EQ(16, m.Call(uint32_t(0x00008040))); 149 CHECK_EQ(17, m.Call(uint32_t(0x00004005))); 150 CHECK_EQ(18, m.Call(uint32_t(0x00002050))); 151 CHECK_EQ(19, m.Call(uint32_t(0x00001700))); 152 CHECK_EQ(20, m.Call(uint32_t(0x00000870))); 153 CHECK_EQ(21, m.Call(uint32_t(0x00000405))); 154 CHECK_EQ(22, m.Call(uint32_t(0x00000203))); 155 CHECK_EQ(23, m.Call(uint32_t(0x00000101))); 156 CHECK_EQ(24, m.Call(uint32_t(0x00000089))); 157 CHECK_EQ(25, m.Call(uint32_t(0x00000041))); 158 CHECK_EQ(26, m.Call(uint32_t(0x00000022))); 159 CHECK_EQ(27, m.Call(uint32_t(0x00000013))); 160 CHECK_EQ(28, m.Call(uint32_t(0x00000008))); 161 CHECK_EQ(29, m.Call(uint32_t(0x00000004))); 162 CHECK_EQ(30, m.Call(uint32_t(0x00000002))); 163 CHECK_EQ(31, m.Call(uint32_t(0x00000001))); 164 CHECK_EQ(32, m.Call(uint32_t(0x00000000))); 165 } 166 167 168 TEST(RunWord32Popcnt) { 169 BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32()); 170 if (!m.machine()->Word32Popcnt().IsSupported()) { 171 // We can only test the operator if it exists on the testing platform. 172 return; 173 } 174 m.Return(m.AddNode(m.machine()->Word32Popcnt().op(), m.Parameter(0))); 175 176 CHECK_EQ(0, m.Call(uint32_t(0x00000000))); 177 CHECK_EQ(1, m.Call(uint32_t(0x00000001))); 178 CHECK_EQ(1, m.Call(uint32_t(0x80000000))); 179 CHECK_EQ(32, m.Call(uint32_t(0xffffffff))); 180 CHECK_EQ(6, m.Call(uint32_t(0x000dc100))); 181 CHECK_EQ(9, m.Call(uint32_t(0xe00dc100))); 182 CHECK_EQ(11, m.Call(uint32_t(0xe00dc103))); 183 CHECK_EQ(9, m.Call(uint32_t(0x000dc107))); 184 } 185 186 187 #if V8_TARGET_ARCH_64_BIT 188 TEST(RunWord64ReverseBits) { 189 RawMachineAssemblerTester<uint64_t> m(MachineType::Uint64()); 190 if (!m.machine()->Word64ReverseBits().IsSupported()) { 191 return; 192 } 193 194 m.Return(m.AddNode(m.machine()->Word64ReverseBits().op(), m.Parameter(0))); 195 196 CHECK_EQ(uint64_t(0x0000000000000000), m.Call(uint64_t(0x0000000000000000))); 197 CHECK_EQ(uint64_t(0x1234567890abcdef), m.Call(uint64_t(0xf7b3d5091e6a2c48))); 198 CHECK_EQ(uint64_t(0xfedcba0987654321), m.Call(uint64_t(0x84c2a6e1905d3b7f))); 199 CHECK_EQ(uint64_t(0x0101010101010101), m.Call(uint64_t(0x8080808080808080))); 200 CHECK_EQ(uint64_t(0x0102040803060c01), m.Call(uint64_t(0x803060c010204080))); 201 CHECK_EQ(uint64_t(0xf0703010e060200f), m.Call(uint64_t(0xf0040607080c0e0f))); 202 CHECK_EQ(uint64_t(0x2f8a6df01c21fa3b), m.Call(uint64_t(0xdc5f84380fb651f4))); 203 CHECK_EQ(uint64_t(0xffffffffffffffff), m.Call(uint64_t(0xffffffffffffffff))); 204 } 205 206 207 TEST(RunWord64Clz) { 208 BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint64()); 209 m.Return(m.Word64Clz(m.Parameter(0))); 210 211 CHECK_EQ(0, m.Call(uint64_t(0x8000100000000000))); 212 CHECK_EQ(1, m.Call(uint64_t(0x4000050000000000))); 213 CHECK_EQ(2, m.Call(uint64_t(0x2000030000000000))); 214 CHECK_EQ(3, m.Call(uint64_t(0x1000000300000000))); 215 CHECK_EQ(4, m.Call(uint64_t(0x0805000000000000))); 216 CHECK_EQ(5, m.Call(uint64_t(0x0400600000000000))); 217 CHECK_EQ(6, m.Call(uint64_t(0x0200000000000000))); 218 CHECK_EQ(7, m.Call(uint64_t(0x010000a000000000))); 219 CHECK_EQ(8, m.Call(uint64_t(0x00800c0000000000))); 220 CHECK_EQ(9, m.Call(uint64_t(0x0040000000000000))); 221 CHECK_EQ(10, m.Call(uint64_t(0x0020000d00000000))); 222 CHECK_EQ(11, m.Call(uint64_t(0x00100f0000000000))); 223 CHECK_EQ(12, m.Call(uint64_t(0x0008000000000000))); 224 CHECK_EQ(13, m.Call(uint64_t(0x0004100000000000))); 225 CHECK_EQ(14, m.Call(uint64_t(0x0002002000000000))); 226 CHECK_EQ(15, m.Call(uint64_t(0x0001030000000000))); 227 CHECK_EQ(16, m.Call(uint64_t(0x0000804000000000))); 228 CHECK_EQ(17, m.Call(uint64_t(0x0000400500000000))); 229 CHECK_EQ(18, m.Call(uint64_t(0x0000205000000000))); 230 CHECK_EQ(19, m.Call(uint64_t(0x0000170000000000))); 231 CHECK_EQ(20, m.Call(uint64_t(0x0000087000000000))); 232 CHECK_EQ(21, m.Call(uint64_t(0x0000040500000000))); 233 CHECK_EQ(22, m.Call(uint64_t(0x0000020300000000))); 234 CHECK_EQ(23, m.Call(uint64_t(0x0000010100000000))); 235 CHECK_EQ(24, m.Call(uint64_t(0x0000008900000000))); 236 CHECK_EQ(25, m.Call(uint64_t(0x0000004100000000))); 237 CHECK_EQ(26, m.Call(uint64_t(0x0000002200000000))); 238 CHECK_EQ(27, m.Call(uint64_t(0x0000001300000000))); 239 CHECK_EQ(28, m.Call(uint64_t(0x0000000800000000))); 240 CHECK_EQ(29, m.Call(uint64_t(0x0000000400000000))); 241 CHECK_EQ(30, m.Call(uint64_t(0x0000000200000000))); 242 CHECK_EQ(31, m.Call(uint64_t(0x0000000100000000))); 243 CHECK_EQ(32, m.Call(uint64_t(0x0000000080001000))); 244 CHECK_EQ(33, m.Call(uint64_t(0x0000000040000500))); 245 CHECK_EQ(34, m.Call(uint64_t(0x0000000020000300))); 246 CHECK_EQ(35, m.Call(uint64_t(0x0000000010000003))); 247 CHECK_EQ(36, m.Call(uint64_t(0x0000000008050000))); 248 CHECK_EQ(37, m.Call(uint64_t(0x0000000004006000))); 249 CHECK_EQ(38, m.Call(uint64_t(0x0000000002000000))); 250 CHECK_EQ(39, m.Call(uint64_t(0x00000000010000a0))); 251 CHECK_EQ(40, m.Call(uint64_t(0x0000000000800c00))); 252 CHECK_EQ(41, m.Call(uint64_t(0x0000000000400000))); 253 CHECK_EQ(42, m.Call(uint64_t(0x000000000020000d))); 254 CHECK_EQ(43, m.Call(uint64_t(0x0000000000100f00))); 255 CHECK_EQ(44, m.Call(uint64_t(0x0000000000080000))); 256 CHECK_EQ(45, m.Call(uint64_t(0x0000000000041000))); 257 CHECK_EQ(46, m.Call(uint64_t(0x0000000000020020))); 258 CHECK_EQ(47, m.Call(uint64_t(0x0000000000010300))); 259 CHECK_EQ(48, m.Call(uint64_t(0x0000000000008040))); 260 CHECK_EQ(49, m.Call(uint64_t(0x0000000000004005))); 261 CHECK_EQ(50, m.Call(uint64_t(0x0000000000002050))); 262 CHECK_EQ(51, m.Call(uint64_t(0x0000000000001700))); 263 CHECK_EQ(52, m.Call(uint64_t(0x0000000000000870))); 264 CHECK_EQ(53, m.Call(uint64_t(0x0000000000000405))); 265 CHECK_EQ(54, m.Call(uint64_t(0x0000000000000203))); 266 CHECK_EQ(55, m.Call(uint64_t(0x0000000000000101))); 267 CHECK_EQ(56, m.Call(uint64_t(0x0000000000000089))); 268 CHECK_EQ(57, m.Call(uint64_t(0x0000000000000041))); 269 CHECK_EQ(58, m.Call(uint64_t(0x0000000000000022))); 270 CHECK_EQ(59, m.Call(uint64_t(0x0000000000000013))); 271 CHECK_EQ(60, m.Call(uint64_t(0x0000000000000008))); 272 CHECK_EQ(61, m.Call(uint64_t(0x0000000000000004))); 273 CHECK_EQ(62, m.Call(uint64_t(0x0000000000000002))); 274 CHECK_EQ(63, m.Call(uint64_t(0x0000000000000001))); 275 CHECK_EQ(64, m.Call(uint64_t(0x0000000000000000))); 276 } 277 278 279 TEST(RunWord64Ctz) { 280 RawMachineAssemblerTester<int32_t> m(MachineType::Uint64()); 281 if (!m.machine()->Word64Ctz().IsSupported()) { 282 return; 283 } 284 285 m.Return(m.AddNode(m.machine()->Word64Ctz().op(), m.Parameter(0))); 286 287 CHECK_EQ(64, m.Call(uint64_t(0x0000000000000000))); 288 CHECK_EQ(63, m.Call(uint64_t(0x8000000000000000))); 289 CHECK_EQ(62, m.Call(uint64_t(0x4000000000000000))); 290 CHECK_EQ(61, m.Call(uint64_t(0x2000000000000000))); 291 CHECK_EQ(60, m.Call(uint64_t(0x1000000000000000))); 292 CHECK_EQ(59, m.Call(uint64_t(0xa800000000000000))); 293 CHECK_EQ(58, m.Call(uint64_t(0xf400000000000000))); 294 CHECK_EQ(57, m.Call(uint64_t(0x6200000000000000))); 295 CHECK_EQ(56, m.Call(uint64_t(0x9100000000000000))); 296 CHECK_EQ(55, m.Call(uint64_t(0xcd80000000000000))); 297 CHECK_EQ(54, m.Call(uint64_t(0x0940000000000000))); 298 CHECK_EQ(53, m.Call(uint64_t(0xaf20000000000000))); 299 CHECK_EQ(52, m.Call(uint64_t(0xac10000000000000))); 300 CHECK_EQ(51, m.Call(uint64_t(0xe0b8000000000000))); 301 CHECK_EQ(50, m.Call(uint64_t(0x9ce4000000000000))); 302 CHECK_EQ(49, m.Call(uint64_t(0xc792000000000000))); 303 CHECK_EQ(48, m.Call(uint64_t(0xb8f1000000000000))); 304 CHECK_EQ(47, m.Call(uint64_t(0x3b9f800000000000))); 305 CHECK_EQ(46, m.Call(uint64_t(0xdb4c400000000000))); 306 CHECK_EQ(45, m.Call(uint64_t(0xe9a3200000000000))); 307 CHECK_EQ(44, m.Call(uint64_t(0xfca6100000000000))); 308 CHECK_EQ(43, m.Call(uint64_t(0x6c8a780000000000))); 309 CHECK_EQ(42, m.Call(uint64_t(0x8ce5a40000000000))); 310 CHECK_EQ(41, m.Call(uint64_t(0xcb7d020000000000))); 311 CHECK_EQ(40, m.Call(uint64_t(0xcb4dc10000000000))); 312 CHECK_EQ(39, m.Call(uint64_t(0xdfbec58000000000))); 313 CHECK_EQ(38, m.Call(uint64_t(0x27a9db4000000000))); 314 CHECK_EQ(37, m.Call(uint64_t(0xde3bcb2000000000))); 315 CHECK_EQ(36, m.Call(uint64_t(0xd7e8a61000000000))); 316 CHECK_EQ(35, m.Call(uint64_t(0x9afdbc8800000000))); 317 CHECK_EQ(34, m.Call(uint64_t(0x9afdbc8400000000))); 318 CHECK_EQ(33, m.Call(uint64_t(0x9afdbc8200000000))); 319 CHECK_EQ(32, m.Call(uint64_t(0x9afdbc8100000000))); 320 CHECK_EQ(31, m.Call(uint64_t(0x0000000080000000))); 321 CHECK_EQ(30, m.Call(uint64_t(0x0000000040000000))); 322 CHECK_EQ(29, m.Call(uint64_t(0x0000000020000000))); 323 CHECK_EQ(28, m.Call(uint64_t(0x0000000010000000))); 324 CHECK_EQ(27, m.Call(uint64_t(0x00000000a8000000))); 325 CHECK_EQ(26, m.Call(uint64_t(0x00000000f4000000))); 326 CHECK_EQ(25, m.Call(uint64_t(0x0000000062000000))); 327 CHECK_EQ(24, m.Call(uint64_t(0x0000000091000000))); 328 CHECK_EQ(23, m.Call(uint64_t(0x00000000cd800000))); 329 CHECK_EQ(22, m.Call(uint64_t(0x0000000009400000))); 330 CHECK_EQ(21, m.Call(uint64_t(0x00000000af200000))); 331 CHECK_EQ(20, m.Call(uint64_t(0x00000000ac100000))); 332 CHECK_EQ(19, m.Call(uint64_t(0x00000000e0b80000))); 333 CHECK_EQ(18, m.Call(uint64_t(0x000000009ce40000))); 334 CHECK_EQ(17, m.Call(uint64_t(0x00000000c7920000))); 335 CHECK_EQ(16, m.Call(uint64_t(0x00000000b8f10000))); 336 CHECK_EQ(15, m.Call(uint64_t(0x000000003b9f8000))); 337 CHECK_EQ(14, m.Call(uint64_t(0x00000000db4c4000))); 338 CHECK_EQ(13, m.Call(uint64_t(0x00000000e9a32000))); 339 CHECK_EQ(12, m.Call(uint64_t(0x00000000fca61000))); 340 CHECK_EQ(11, m.Call(uint64_t(0x000000006c8a7800))); 341 CHECK_EQ(10, m.Call(uint64_t(0x000000008ce5a400))); 342 CHECK_EQ(9, m.Call(uint64_t(0x00000000cb7d0200))); 343 CHECK_EQ(8, m.Call(uint64_t(0x00000000cb4dc100))); 344 CHECK_EQ(7, m.Call(uint64_t(0x00000000dfbec580))); 345 CHECK_EQ(6, m.Call(uint64_t(0x0000000027a9db40))); 346 CHECK_EQ(5, m.Call(uint64_t(0x00000000de3bcb20))); 347 CHECK_EQ(4, m.Call(uint64_t(0x00000000d7e8a610))); 348 CHECK_EQ(3, m.Call(uint64_t(0x000000009afdbc88))); 349 CHECK_EQ(2, m.Call(uint64_t(0x000000009afdbc84))); 350 CHECK_EQ(1, m.Call(uint64_t(0x000000009afdbc82))); 351 CHECK_EQ(0, m.Call(uint64_t(0x000000009afdbc81))); 352 } 353 354 355 TEST(RunWord64Popcnt) { 356 BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint64()); 357 if (!m.machine()->Word64Popcnt().IsSupported()) { 358 return; 359 } 360 361 m.Return(m.AddNode(m.machine()->Word64Popcnt().op(), m.Parameter(0))); 362 363 CHECK_EQ(0, m.Call(uint64_t(0x0000000000000000))); 364 CHECK_EQ(1, m.Call(uint64_t(0x0000000000000001))); 365 CHECK_EQ(1, m.Call(uint64_t(0x8000000000000000))); 366 CHECK_EQ(64, m.Call(uint64_t(0xffffffffffffffff))); 367 CHECK_EQ(12, m.Call(uint64_t(0x000dc100000dc100))); 368 CHECK_EQ(18, m.Call(uint64_t(0xe00dc100e00dc100))); 369 CHECK_EQ(22, m.Call(uint64_t(0xe00dc103e00dc103))); 370 CHECK_EQ(18, m.Call(uint64_t(0x000dc107000dc107))); 371 } 372 #endif // V8_TARGET_ARCH_64_BIT 373 374 375 static Node* Int32Input(RawMachineAssemblerTester<int32_t>* m, int index) { 376 switch (index) { 377 case 0: 378 return m->Parameter(0); 379 case 1: 380 return m->Parameter(1); 381 case 2: 382 return m->Int32Constant(0); 383 case 3: 384 return m->Int32Constant(1); 385 case 4: 386 return m->Int32Constant(-1); 387 case 5: 388 return m->Int32Constant(0xff); 389 case 6: 390 return m->Int32Constant(0x01234567); 391 case 7: 392 return m->Load(MachineType::Int32(), m->PointerConstant(NULL)); 393 default: 394 return NULL; 395 } 396 } 397 398 399 TEST(CodeGenInt32Binop) { 400 RawMachineAssemblerTester<void> m; 401 402 const Operator* kOps[] = { 403 m.machine()->Word32And(), m.machine()->Word32Or(), 404 m.machine()->Word32Xor(), m.machine()->Word32Shl(), 405 m.machine()->Word32Shr(), m.machine()->Word32Sar(), 406 m.machine()->Word32Equal(), m.machine()->Int32Add(), 407 m.machine()->Int32Sub(), m.machine()->Int32Mul(), 408 m.machine()->Int32MulHigh(), m.machine()->Int32Div(), 409 m.machine()->Uint32Div(), m.machine()->Int32Mod(), 410 m.machine()->Uint32Mod(), m.machine()->Uint32MulHigh(), 411 m.machine()->Int32LessThan(), m.machine()->Int32LessThanOrEqual(), 412 m.machine()->Uint32LessThan(), m.machine()->Uint32LessThanOrEqual()}; 413 414 for (size_t i = 0; i < arraysize(kOps); ++i) { 415 for (int j = 0; j < 8; j++) { 416 for (int k = 0; k < 8; k++) { 417 RawMachineAssemblerTester<int32_t> m(MachineType::Int32(), 418 MachineType::Int32()); 419 Node* a = Int32Input(&m, j); 420 Node* b = Int32Input(&m, k); 421 m.Return(m.AddNode(kOps[i], a, b)); 422 m.GenerateCode(); 423 } 424 } 425 } 426 } 427 428 429 TEST(CodeGenNop) { 430 RawMachineAssemblerTester<void> m; 431 m.Return(m.Int32Constant(0)); 432 m.GenerateCode(); 433 } 434 435 436 #if V8_TARGET_ARCH_64_BIT 437 static Node* Int64Input(RawMachineAssemblerTester<int64_t>* m, int index) { 438 switch (index) { 439 case 0: 440 return m->Parameter(0); 441 case 1: 442 return m->Parameter(1); 443 case 2: 444 return m->Int64Constant(0); 445 case 3: 446 return m->Int64Constant(1); 447 case 4: 448 return m->Int64Constant(-1); 449 case 5: 450 return m->Int64Constant(0xff); 451 case 6: 452 return m->Int64Constant(0x0123456789abcdefLL); 453 case 7: 454 return m->Load(MachineType::Int64(), m->PointerConstant(NULL)); 455 default: 456 return NULL; 457 } 458 } 459 460 461 TEST(CodeGenInt64Binop) { 462 RawMachineAssemblerTester<void> m; 463 464 const Operator* kOps[] = { 465 m.machine()->Word64And(), m.machine()->Word64Or(), 466 m.machine()->Word64Xor(), m.machine()->Word64Shl(), 467 m.machine()->Word64Shr(), m.machine()->Word64Sar(), 468 m.machine()->Word64Equal(), m.machine()->Int64Add(), 469 m.machine()->Int64Sub(), m.machine()->Int64Mul(), m.machine()->Int64Div(), 470 m.machine()->Uint64Div(), m.machine()->Int64Mod(), 471 m.machine()->Uint64Mod(), m.machine()->Int64LessThan(), 472 m.machine()->Int64LessThanOrEqual(), m.machine()->Uint64LessThan(), 473 m.machine()->Uint64LessThanOrEqual()}; 474 475 for (size_t i = 0; i < arraysize(kOps); ++i) { 476 for (int j = 0; j < 8; j++) { 477 for (int k = 0; k < 8; k++) { 478 RawMachineAssemblerTester<int64_t> m(MachineType::Int64(), 479 MachineType::Int64()); 480 Node* a = Int64Input(&m, j); 481 Node* b = Int64Input(&m, k); 482 m.Return(m.AddNode(kOps[i], a, b)); 483 m.GenerateCode(); 484 } 485 } 486 } 487 } 488 489 490 TEST(RunInt64AddWithOverflowP) { 491 int64_t actual_val = -1; 492 RawMachineAssemblerTester<int32_t> m; 493 Int64BinopTester bt(&m); 494 Node* add = m.Int64AddWithOverflow(bt.param0, bt.param1); 495 Node* val = m.Projection(0, add); 496 Node* ovf = m.Projection(1, add); 497 m.StoreToPointer(&actual_val, MachineRepresentation::kWord64, val); 498 bt.AddReturn(ovf); 499 FOR_INT64_INPUTS(i) { 500 FOR_INT64_INPUTS(j) { 501 int64_t expected_val; 502 int expected_ovf = bits::SignedAddOverflow64(*i, *j, &expected_val); 503 CHECK_EQ(expected_ovf, bt.call(*i, *j)); 504 CHECK_EQ(expected_val, actual_val); 505 } 506 } 507 } 508 509 510 TEST(RunInt64AddWithOverflowImm) { 511 int64_t actual_val = -1, expected_val = 0; 512 FOR_INT64_INPUTS(i) { 513 { 514 RawMachineAssemblerTester<int32_t> m(MachineType::Int64()); 515 Node* add = m.Int64AddWithOverflow(m.Int64Constant(*i), m.Parameter(0)); 516 Node* val = m.Projection(0, add); 517 Node* ovf = m.Projection(1, add); 518 m.StoreToPointer(&actual_val, MachineRepresentation::kWord64, val); 519 m.Return(ovf); 520 FOR_INT64_INPUTS(j) { 521 int expected_ovf = bits::SignedAddOverflow64(*i, *j, &expected_val); 522 CHECK_EQ(expected_ovf, m.Call(*j)); 523 CHECK_EQ(expected_val, actual_val); 524 } 525 } 526 { 527 RawMachineAssemblerTester<int32_t> m(MachineType::Int64()); 528 Node* add = m.Int64AddWithOverflow(m.Parameter(0), m.Int64Constant(*i)); 529 Node* val = m.Projection(0, add); 530 Node* ovf = m.Projection(1, add); 531 m.StoreToPointer(&actual_val, MachineRepresentation::kWord64, val); 532 m.Return(ovf); 533 FOR_INT64_INPUTS(j) { 534 int expected_ovf = bits::SignedAddOverflow64(*i, *j, &expected_val); 535 CHECK_EQ(expected_ovf, m.Call(*j)); 536 CHECK_EQ(expected_val, actual_val); 537 } 538 } 539 FOR_INT64_INPUTS(j) { 540 RawMachineAssemblerTester<int32_t> m; 541 Node* add = 542 m.Int64AddWithOverflow(m.Int64Constant(*i), m.Int64Constant(*j)); 543 Node* val = m.Projection(0, add); 544 Node* ovf = m.Projection(1, add); 545 m.StoreToPointer(&actual_val, MachineRepresentation::kWord64, val); 546 m.Return(ovf); 547 int expected_ovf = bits::SignedAddOverflow64(*i, *j, &expected_val); 548 CHECK_EQ(expected_ovf, m.Call()); 549 CHECK_EQ(expected_val, actual_val); 550 } 551 } 552 } 553 554 555 TEST(RunInt64AddWithOverflowInBranchP) { 556 int constant = 911777; 557 RawMachineLabel blocka, blockb; 558 RawMachineAssemblerTester<int32_t> m; 559 Int64BinopTester bt(&m); 560 Node* add = m.Int64AddWithOverflow(bt.param0, bt.param1); 561 Node* ovf = m.Projection(1, add); 562 m.Branch(ovf, &blocka, &blockb); 563 m.Bind(&blocka); 564 bt.AddReturn(m.Int64Constant(constant)); 565 m.Bind(&blockb); 566 Node* val = m.Projection(0, add); 567 Node* truncated = m.TruncateInt64ToInt32(val); 568 bt.AddReturn(truncated); 569 FOR_INT64_INPUTS(i) { 570 FOR_INT64_INPUTS(j) { 571 int32_t expected = constant; 572 int64_t result; 573 if (!bits::SignedAddOverflow64(*i, *j, &result)) { 574 expected = static_cast<int32_t>(result); 575 } 576 CHECK_EQ(expected, bt.call(*i, *j)); 577 } 578 } 579 } 580 581 582 TEST(RunInt64SubWithOverflowP) { 583 int64_t actual_val = -1; 584 RawMachineAssemblerTester<int32_t> m; 585 Int64BinopTester bt(&m); 586 Node* add = m.Int64SubWithOverflow(bt.param0, bt.param1); 587 Node* val = m.Projection(0, add); 588 Node* ovf = m.Projection(1, add); 589 m.StoreToPointer(&actual_val, MachineRepresentation::kWord64, val); 590 bt.AddReturn(ovf); 591 FOR_INT64_INPUTS(i) { 592 FOR_INT64_INPUTS(j) { 593 int64_t expected_val; 594 int expected_ovf = bits::SignedSubOverflow64(*i, *j, &expected_val); 595 CHECK_EQ(expected_ovf, bt.call(*i, *j)); 596 CHECK_EQ(expected_val, actual_val); 597 } 598 } 599 } 600 601 602 TEST(RunInt64SubWithOverflowImm) { 603 int64_t actual_val = -1, expected_val = 0; 604 FOR_INT64_INPUTS(i) { 605 { 606 RawMachineAssemblerTester<int32_t> m(MachineType::Int64()); 607 Node* add = m.Int64SubWithOverflow(m.Int64Constant(*i), m.Parameter(0)); 608 Node* val = m.Projection(0, add); 609 Node* ovf = m.Projection(1, add); 610 m.StoreToPointer(&actual_val, MachineRepresentation::kWord64, val); 611 m.Return(ovf); 612 FOR_INT64_INPUTS(j) { 613 int expected_ovf = bits::SignedSubOverflow64(*i, *j, &expected_val); 614 CHECK_EQ(expected_ovf, m.Call(*j)); 615 CHECK_EQ(expected_val, actual_val); 616 } 617 } 618 { 619 RawMachineAssemblerTester<int32_t> m(MachineType::Int64()); 620 Node* add = m.Int64SubWithOverflow(m.Parameter(0), m.Int64Constant(*i)); 621 Node* val = m.Projection(0, add); 622 Node* ovf = m.Projection(1, add); 623 m.StoreToPointer(&actual_val, MachineRepresentation::kWord64, val); 624 m.Return(ovf); 625 FOR_INT64_INPUTS(j) { 626 int expected_ovf = bits::SignedSubOverflow64(*j, *i, &expected_val); 627 CHECK_EQ(expected_ovf, m.Call(*j)); 628 CHECK_EQ(expected_val, actual_val); 629 } 630 } 631 FOR_INT64_INPUTS(j) { 632 RawMachineAssemblerTester<int32_t> m; 633 Node* add = 634 m.Int64SubWithOverflow(m.Int64Constant(*i), m.Int64Constant(*j)); 635 Node* val = m.Projection(0, add); 636 Node* ovf = m.Projection(1, add); 637 m.StoreToPointer(&actual_val, MachineRepresentation::kWord64, val); 638 m.Return(ovf); 639 int expected_ovf = bits::SignedSubOverflow64(*i, *j, &expected_val); 640 CHECK_EQ(expected_ovf, m.Call()); 641 CHECK_EQ(expected_val, actual_val); 642 } 643 } 644 } 645 646 647 TEST(RunInt64SubWithOverflowInBranchP) { 648 int constant = 911999; 649 RawMachineLabel blocka, blockb; 650 RawMachineAssemblerTester<int32_t> m; 651 Int64BinopTester bt(&m); 652 Node* sub = m.Int64SubWithOverflow(bt.param0, bt.param1); 653 Node* ovf = m.Projection(1, sub); 654 m.Branch(ovf, &blocka, &blockb); 655 m.Bind(&blocka); 656 bt.AddReturn(m.Int64Constant(constant)); 657 m.Bind(&blockb); 658 Node* val = m.Projection(0, sub); 659 Node* truncated = m.TruncateInt64ToInt32(val); 660 bt.AddReturn(truncated); 661 FOR_INT64_INPUTS(i) { 662 FOR_INT64_INPUTS(j) { 663 int32_t expected = constant; 664 int64_t result; 665 if (!bits::SignedSubOverflow64(*i, *j, &result)) { 666 expected = static_cast<int32_t>(result); 667 } 668 CHECK_EQ(expected, static_cast<int32_t>(bt.call(*i, *j))); 669 } 670 } 671 } 672 673 static int64_t RunInt64AddShift(bool is_left, int64_t add_left, 674 int64_t add_right, int64_t shift_left, 675 int64_t shit_right) { 676 RawMachineAssemblerTester<int64_t> m; 677 Node* shift = m.Word64Shl(m.Int64Constant(4), m.Int64Constant(2)); 678 Node* add = m.Int64Add(m.Int64Constant(20), m.Int64Constant(22)); 679 Node* dlsa = is_left ? m.Int64Add(shift, add) : m.Int64Add(add, shift); 680 m.Return(dlsa); 681 return m.Call(); 682 } 683 684 TEST(RunInt64AddShift) { 685 struct Test_case { 686 int64_t add_left, add_right, shift_left, shit_right, expected; 687 }; 688 689 Test_case tc[] = { 690 {20, 22, 4, 2, 58}, 691 {20, 22, 4, 1, 50}, 692 {20, 22, 1, 6, 106}, 693 {INT64_MAX - 2, 1, 1, 1, 694 INT64_MIN}, // INT64_MAX - 2 + 1 + (1 << 1), overflow. 695 }; 696 const size_t tc_size = sizeof(tc) / sizeof(Test_case); 697 698 for (size_t i = 0; i < tc_size; ++i) { 699 CHECK_EQ(58, RunInt64AddShift(false, tc[i].add_left, tc[i].add_right, 700 tc[i].shift_left, tc[i].shit_right)); 701 CHECK_EQ(58, RunInt64AddShift(true, tc[i].add_left, tc[i].add_right, 702 tc[i].shift_left, tc[i].shit_right)); 703 } 704 } 705 706 // TODO(titzer): add tests that run 64-bit integer operations. 707 #endif // V8_TARGET_ARCH_64_BIT 708 709 710 TEST(RunGoto) { 711 RawMachineAssemblerTester<int32_t> m; 712 int constant = 99999; 713 714 RawMachineLabel next; 715 m.Goto(&next); 716 m.Bind(&next); 717 m.Return(m.Int32Constant(constant)); 718 719 CHECK_EQ(constant, m.Call()); 720 } 721 722 723 TEST(RunGotoMultiple) { 724 RawMachineAssemblerTester<int32_t> m; 725 int constant = 9999977; 726 727 RawMachineLabel labels[10]; 728 for (size_t i = 0; i < arraysize(labels); i++) { 729 m.Goto(&labels[i]); 730 m.Bind(&labels[i]); 731 } 732 m.Return(m.Int32Constant(constant)); 733 734 CHECK_EQ(constant, m.Call()); 735 } 736 737 738 TEST(RunBranch) { 739 RawMachineAssemblerTester<int32_t> m; 740 int constant = 999777; 741 742 RawMachineLabel blocka, blockb; 743 m.Branch(m.Int32Constant(0), &blocka, &blockb); 744 m.Bind(&blocka); 745 m.Return(m.Int32Constant(0 - constant)); 746 m.Bind(&blockb); 747 m.Return(m.Int32Constant(constant)); 748 749 CHECK_EQ(constant, m.Call()); 750 } 751 752 753 TEST(RunDiamond2) { 754 RawMachineAssemblerTester<int32_t> m; 755 756 int constant = 995666; 757 758 RawMachineLabel blocka, blockb, end; 759 m.Branch(m.Int32Constant(0), &blocka, &blockb); 760 m.Bind(&blocka); 761 m.Goto(&end); 762 m.Bind(&blockb); 763 m.Goto(&end); 764 m.Bind(&end); 765 m.Return(m.Int32Constant(constant)); 766 767 CHECK_EQ(constant, m.Call()); 768 } 769 770 771 TEST(RunLoop) { 772 RawMachineAssemblerTester<int32_t> m; 773 int constant = 999555; 774 775 RawMachineLabel header, body, exit; 776 m.Goto(&header); 777 m.Bind(&header); 778 m.Branch(m.Int32Constant(0), &body, &exit); 779 m.Bind(&body); 780 m.Goto(&header); 781 m.Bind(&exit); 782 m.Return(m.Int32Constant(constant)); 783 784 CHECK_EQ(constant, m.Call()); 785 } 786 787 788 template <typename R> 789 static void BuildDiamondPhi(RawMachineAssemblerTester<R>* m, Node* cond_node, 790 MachineRepresentation rep, Node* true_node, 791 Node* false_node) { 792 RawMachineLabel blocka, blockb, end; 793 m->Branch(cond_node, &blocka, &blockb); 794 m->Bind(&blocka); 795 m->Goto(&end); 796 m->Bind(&blockb); 797 m->Goto(&end); 798 799 m->Bind(&end); 800 Node* phi = m->Phi(rep, true_node, false_node); 801 m->Return(phi); 802 } 803 804 805 TEST(RunDiamondPhiConst) { 806 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 807 int false_val = 0xFF666; 808 int true_val = 0x00DDD; 809 Node* true_node = m.Int32Constant(true_val); 810 Node* false_node = m.Int32Constant(false_val); 811 BuildDiamondPhi(&m, m.Parameter(0), MachineRepresentation::kWord32, true_node, 812 false_node); 813 CHECK_EQ(false_val, m.Call(0)); 814 CHECK_EQ(true_val, m.Call(1)); 815 } 816 817 818 TEST(RunDiamondPhiNumber) { 819 RawMachineAssemblerTester<Object*> m(MachineType::Int32()); 820 double false_val = -11.1; 821 double true_val = 200.1; 822 Node* true_node = m.NumberConstant(true_val); 823 Node* false_node = m.NumberConstant(false_val); 824 BuildDiamondPhi(&m, m.Parameter(0), MachineRepresentation::kTagged, true_node, 825 false_node); 826 m.CheckNumber(false_val, m.Call(0)); 827 m.CheckNumber(true_val, m.Call(1)); 828 } 829 830 831 TEST(RunDiamondPhiString) { 832 RawMachineAssemblerTester<Object*> m(MachineType::Int32()); 833 const char* false_val = "false"; 834 const char* true_val = "true"; 835 Node* true_node = m.StringConstant(true_val); 836 Node* false_node = m.StringConstant(false_val); 837 BuildDiamondPhi(&m, m.Parameter(0), MachineRepresentation::kTagged, true_node, 838 false_node); 839 m.CheckString(false_val, m.Call(0)); 840 m.CheckString(true_val, m.Call(1)); 841 } 842 843 844 TEST(RunDiamondPhiParam) { 845 RawMachineAssemblerTester<int32_t> m( 846 MachineType::Int32(), MachineType::Int32(), MachineType::Int32()); 847 BuildDiamondPhi(&m, m.Parameter(0), MachineRepresentation::kWord32, 848 m.Parameter(1), m.Parameter(2)); 849 int32_t c1 = 0x260cb75a; 850 int32_t c2 = 0xcd3e9c8b; 851 int result = m.Call(0, c1, c2); 852 CHECK_EQ(c2, result); 853 result = m.Call(1, c1, c2); 854 CHECK_EQ(c1, result); 855 } 856 857 858 TEST(RunLoopPhiConst) { 859 RawMachineAssemblerTester<int32_t> m; 860 int true_val = 0x44000; 861 int false_val = 0x00888; 862 863 Node* cond_node = m.Int32Constant(0); 864 Node* true_node = m.Int32Constant(true_val); 865 Node* false_node = m.Int32Constant(false_val); 866 867 // x = false_val; while(false) { x = true_val; } return x; 868 RawMachineLabel body, header, end; 869 870 m.Goto(&header); 871 m.Bind(&header); 872 Node* phi = m.Phi(MachineRepresentation::kWord32, false_node, true_node); 873 m.Branch(cond_node, &body, &end); 874 m.Bind(&body); 875 m.Goto(&header); 876 m.Bind(&end); 877 m.Return(phi); 878 879 CHECK_EQ(false_val, m.Call()); 880 } 881 882 883 TEST(RunLoopPhiParam) { 884 RawMachineAssemblerTester<int32_t> m( 885 MachineType::Int32(), MachineType::Int32(), MachineType::Int32()); 886 887 RawMachineLabel blocka, blockb, end; 888 889 m.Goto(&blocka); 890 891 m.Bind(&blocka); 892 Node* phi = 893 m.Phi(MachineRepresentation::kWord32, m.Parameter(1), m.Parameter(2)); 894 Node* cond = 895 m.Phi(MachineRepresentation::kWord32, m.Parameter(0), m.Int32Constant(0)); 896 m.Branch(cond, &blockb, &end); 897 898 m.Bind(&blockb); 899 m.Goto(&blocka); 900 901 m.Bind(&end); 902 m.Return(phi); 903 904 int32_t c1 = 0xa81903b4; 905 int32_t c2 = 0x5a1207da; 906 int result = m.Call(0, c1, c2); 907 CHECK_EQ(c1, result); 908 result = m.Call(1, c1, c2); 909 CHECK_EQ(c2, result); 910 } 911 912 913 TEST(RunLoopPhiInduction) { 914 RawMachineAssemblerTester<int32_t> m; 915 916 int false_val = 0x10777; 917 918 // x = false_val; while(false) { x++; } return x; 919 RawMachineLabel header, body, end; 920 Node* false_node = m.Int32Constant(false_val); 921 922 m.Goto(&header); 923 924 m.Bind(&header); 925 Node* phi = m.Phi(MachineRepresentation::kWord32, false_node, false_node); 926 m.Branch(m.Int32Constant(0), &body, &end); 927 928 m.Bind(&body); 929 Node* add = m.Int32Add(phi, m.Int32Constant(1)); 930 phi->ReplaceInput(1, add); 931 m.Goto(&header); 932 933 m.Bind(&end); 934 m.Return(phi); 935 936 CHECK_EQ(false_val, m.Call()); 937 } 938 939 940 TEST(RunLoopIncrement) { 941 RawMachineAssemblerTester<int32_t> m; 942 Int32BinopTester bt(&m); 943 944 // x = 0; while(x ^ param) { x++; } return x; 945 RawMachineLabel header, body, end; 946 Node* zero = m.Int32Constant(0); 947 948 m.Goto(&header); 949 950 m.Bind(&header); 951 Node* phi = m.Phi(MachineRepresentation::kWord32, zero, zero); 952 m.Branch(m.WordXor(phi, bt.param0), &body, &end); 953 954 m.Bind(&body); 955 phi->ReplaceInput(1, m.Int32Add(phi, m.Int32Constant(1))); 956 m.Goto(&header); 957 958 m.Bind(&end); 959 bt.AddReturn(phi); 960 961 CHECK_EQ(11, bt.call(11, 0)); 962 CHECK_EQ(110, bt.call(110, 0)); 963 CHECK_EQ(176, bt.call(176, 0)); 964 } 965 966 967 TEST(RunLoopIncrement2) { 968 RawMachineAssemblerTester<int32_t> m; 969 Int32BinopTester bt(&m); 970 971 // x = 0; while(x < param) { x++; } return x; 972 RawMachineLabel header, body, end; 973 Node* zero = m.Int32Constant(0); 974 975 m.Goto(&header); 976 977 m.Bind(&header); 978 Node* phi = m.Phi(MachineRepresentation::kWord32, zero, zero); 979 m.Branch(m.Int32LessThan(phi, bt.param0), &body, &end); 980 981 m.Bind(&body); 982 phi->ReplaceInput(1, m.Int32Add(phi, m.Int32Constant(1))); 983 m.Goto(&header); 984 985 m.Bind(&end); 986 bt.AddReturn(phi); 987 988 CHECK_EQ(11, bt.call(11, 0)); 989 CHECK_EQ(110, bt.call(110, 0)); 990 CHECK_EQ(176, bt.call(176, 0)); 991 CHECK_EQ(0, bt.call(-200, 0)); 992 } 993 994 995 TEST(RunLoopIncrement3) { 996 RawMachineAssemblerTester<int32_t> m; 997 Int32BinopTester bt(&m); 998 999 // x = 0; while(x < param) { x++; } return x; 1000 RawMachineLabel header, body, end; 1001 Node* zero = m.Int32Constant(0); 1002 1003 m.Goto(&header); 1004 1005 m.Bind(&header); 1006 Node* phi = m.Phi(MachineRepresentation::kWord32, zero, zero); 1007 m.Branch(m.Uint32LessThan(phi, bt.param0), &body, &end); 1008 1009 m.Bind(&body); 1010 phi->ReplaceInput(1, m.Int32Add(phi, m.Int32Constant(1))); 1011 m.Goto(&header); 1012 1013 m.Bind(&end); 1014 bt.AddReturn(phi); 1015 1016 CHECK_EQ(11, bt.call(11, 0)); 1017 CHECK_EQ(110, bt.call(110, 0)); 1018 CHECK_EQ(176, bt.call(176, 0)); 1019 CHECK_EQ(200, bt.call(200, 0)); 1020 } 1021 1022 1023 TEST(RunLoopDecrement) { 1024 RawMachineAssemblerTester<int32_t> m; 1025 Int32BinopTester bt(&m); 1026 1027 // x = param; while(x) { x--; } return x; 1028 RawMachineLabel header, body, end; 1029 1030 m.Goto(&header); 1031 1032 m.Bind(&header); 1033 Node* phi = 1034 m.Phi(MachineRepresentation::kWord32, bt.param0, m.Int32Constant(0)); 1035 m.Branch(phi, &body, &end); 1036 1037 m.Bind(&body); 1038 phi->ReplaceInput(1, m.Int32Sub(phi, m.Int32Constant(1))); 1039 m.Goto(&header); 1040 1041 m.Bind(&end); 1042 bt.AddReturn(phi); 1043 1044 CHECK_EQ(0, bt.call(11, 0)); 1045 CHECK_EQ(0, bt.call(110, 0)); 1046 CHECK_EQ(0, bt.call(197, 0)); 1047 } 1048 1049 1050 TEST(RunLoopIncrementFloat32) { 1051 RawMachineAssemblerTester<int32_t> m; 1052 1053 // x = -3.0f; while(x < 10f) { x = x + 0.5f; } return (int) (double) x; 1054 RawMachineLabel header, body, end; 1055 Node* minus_3 = m.Float32Constant(-3.0f); 1056 Node* ten = m.Float32Constant(10.0f); 1057 1058 m.Goto(&header); 1059 1060 m.Bind(&header); 1061 Node* phi = m.Phi(MachineRepresentation::kFloat32, minus_3, ten); 1062 m.Branch(m.Float32LessThan(phi, ten), &body, &end); 1063 1064 m.Bind(&body); 1065 phi->ReplaceInput(1, m.Float32Add(phi, m.Float32Constant(0.5f))); 1066 m.Goto(&header); 1067 1068 m.Bind(&end); 1069 m.Return(m.ChangeFloat64ToInt32(m.ChangeFloat32ToFloat64(phi))); 1070 1071 CHECK_EQ(10, m.Call()); 1072 } 1073 1074 1075 TEST(RunLoopIncrementFloat64) { 1076 RawMachineAssemblerTester<int32_t> m; 1077 1078 // x = -3.0; while(x < 10) { x = x + 0.5; } return (int) x; 1079 RawMachineLabel header, body, end; 1080 Node* minus_3 = m.Float64Constant(-3.0); 1081 Node* ten = m.Float64Constant(10.0); 1082 1083 m.Goto(&header); 1084 1085 m.Bind(&header); 1086 Node* phi = m.Phi(MachineRepresentation::kFloat64, minus_3, ten); 1087 m.Branch(m.Float64LessThan(phi, ten), &body, &end); 1088 1089 m.Bind(&body); 1090 phi->ReplaceInput(1, m.Float64Add(phi, m.Float64Constant(0.5))); 1091 m.Goto(&header); 1092 1093 m.Bind(&end); 1094 m.Return(m.ChangeFloat64ToInt32(phi)); 1095 1096 CHECK_EQ(10, m.Call()); 1097 } 1098 1099 1100 TEST(RunSwitch1) { 1101 RawMachineAssemblerTester<int32_t> m; 1102 1103 int constant = 11223344; 1104 1105 RawMachineLabel block0, block1, def, end; 1106 RawMachineLabel* case_labels[] = {&block0, &block1}; 1107 int32_t case_values[] = {0, 1}; 1108 m.Switch(m.Int32Constant(0), &def, case_values, case_labels, 1109 arraysize(case_labels)); 1110 m.Bind(&block0); 1111 m.Goto(&end); 1112 m.Bind(&block1); 1113 m.Goto(&end); 1114 m.Bind(&def); 1115 m.Goto(&end); 1116 m.Bind(&end); 1117 m.Return(m.Int32Constant(constant)); 1118 1119 CHECK_EQ(constant, m.Call()); 1120 } 1121 1122 1123 TEST(RunSwitch2) { 1124 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 1125 1126 RawMachineLabel blocka, blockb, blockc; 1127 RawMachineLabel* case_labels[] = {&blocka, &blockb}; 1128 int32_t case_values[] = {std::numeric_limits<int32_t>::min(), 1129 std::numeric_limits<int32_t>::max()}; 1130 m.Switch(m.Parameter(0), &blockc, case_values, case_labels, 1131 arraysize(case_labels)); 1132 m.Bind(&blocka); 1133 m.Return(m.Int32Constant(-1)); 1134 m.Bind(&blockb); 1135 m.Return(m.Int32Constant(1)); 1136 m.Bind(&blockc); 1137 m.Return(m.Int32Constant(0)); 1138 1139 CHECK_EQ(1, m.Call(std::numeric_limits<int32_t>::max())); 1140 CHECK_EQ(-1, m.Call(std::numeric_limits<int32_t>::min())); 1141 for (int i = -100; i < 100; i += 25) { 1142 CHECK_EQ(0, m.Call(i)); 1143 } 1144 } 1145 1146 1147 TEST(RunSwitch3) { 1148 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 1149 1150 RawMachineLabel blocka, blockb, blockc; 1151 RawMachineLabel* case_labels[] = {&blocka, &blockb}; 1152 int32_t case_values[] = {std::numeric_limits<int32_t>::min() + 0, 1153 std::numeric_limits<int32_t>::min() + 1}; 1154 m.Switch(m.Parameter(0), &blockc, case_values, case_labels, 1155 arraysize(case_labels)); 1156 m.Bind(&blocka); 1157 m.Return(m.Int32Constant(0)); 1158 m.Bind(&blockb); 1159 m.Return(m.Int32Constant(1)); 1160 m.Bind(&blockc); 1161 m.Return(m.Int32Constant(2)); 1162 1163 CHECK_EQ(0, m.Call(std::numeric_limits<int32_t>::min() + 0)); 1164 CHECK_EQ(1, m.Call(std::numeric_limits<int32_t>::min() + 1)); 1165 for (int i = -100; i < 100; i += 25) { 1166 CHECK_EQ(2, m.Call(i)); 1167 } 1168 } 1169 1170 1171 TEST(RunSwitch4) { 1172 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 1173 1174 const size_t kNumCases = 512; 1175 const size_t kNumValues = kNumCases + 1; 1176 int32_t values[kNumValues]; 1177 m.main_isolate()->random_number_generator()->NextBytes(values, 1178 sizeof(values)); 1179 RawMachineLabel end, def; 1180 int32_t case_values[kNumCases]; 1181 RawMachineLabel* case_labels[kNumCases]; 1182 Node* results[kNumValues]; 1183 for (size_t i = 0; i < kNumCases; ++i) { 1184 case_values[i] = static_cast<int32_t>(i); 1185 case_labels[i] = 1186 new (m.main_zone()->New(sizeof(RawMachineLabel))) RawMachineLabel; 1187 } 1188 m.Switch(m.Parameter(0), &def, case_values, case_labels, 1189 arraysize(case_labels)); 1190 for (size_t i = 0; i < kNumCases; ++i) { 1191 m.Bind(case_labels[i]); 1192 results[i] = m.Int32Constant(values[i]); 1193 m.Goto(&end); 1194 } 1195 m.Bind(&def); 1196 results[kNumCases] = m.Int32Constant(values[kNumCases]); 1197 m.Goto(&end); 1198 m.Bind(&end); 1199 const int num_results = static_cast<int>(arraysize(results)); 1200 Node* phi = 1201 m.AddNode(m.common()->Phi(MachineRepresentation::kWord32, num_results), 1202 num_results, results); 1203 m.Return(phi); 1204 1205 for (size_t i = 0; i < kNumValues; ++i) { 1206 CHECK_EQ(values[i], m.Call(static_cast<int>(i))); 1207 } 1208 } 1209 1210 1211 TEST(RunInt32AddP) { 1212 RawMachineAssemblerTester<int32_t> m; 1213 Int32BinopTester bt(&m); 1214 1215 bt.AddReturn(m.Int32Add(bt.param0, bt.param1)); 1216 1217 FOR_INT32_INPUTS(i) { 1218 FOR_INT32_INPUTS(j) { 1219 // Use uint32_t because signed overflow is UB in C. 1220 int expected = static_cast<int32_t>(*i + *j); 1221 CHECK_EQ(expected, bt.call(*i, *j)); 1222 } 1223 } 1224 } 1225 1226 1227 TEST(RunInt32AddAndWord32EqualP) { 1228 { 1229 RawMachineAssemblerTester<int32_t> m( 1230 MachineType::Int32(), MachineType::Int32(), MachineType::Int32()); 1231 m.Return(m.Int32Add(m.Parameter(0), 1232 m.Word32Equal(m.Parameter(1), m.Parameter(2)))); 1233 FOR_INT32_INPUTS(i) { 1234 FOR_INT32_INPUTS(j) { 1235 FOR_INT32_INPUTS(k) { 1236 // Use uint32_t because signed overflow is UB in C. 1237 int32_t const expected = 1238 bit_cast<int32_t>(bit_cast<uint32_t>(*i) + (*j == *k)); 1239 CHECK_EQ(expected, m.Call(*i, *j, *k)); 1240 } 1241 } 1242 } 1243 } 1244 { 1245 RawMachineAssemblerTester<int32_t> m( 1246 MachineType::Int32(), MachineType::Int32(), MachineType::Int32()); 1247 m.Return(m.Int32Add(m.Word32Equal(m.Parameter(0), m.Parameter(1)), 1248 m.Parameter(2))); 1249 FOR_INT32_INPUTS(i) { 1250 FOR_INT32_INPUTS(j) { 1251 FOR_INT32_INPUTS(k) { 1252 // Use uint32_t because signed overflow is UB in C. 1253 int32_t const expected = 1254 bit_cast<int32_t>((*i == *j) + bit_cast<uint32_t>(*k)); 1255 CHECK_EQ(expected, m.Call(*i, *j, *k)); 1256 } 1257 } 1258 } 1259 } 1260 } 1261 1262 1263 TEST(RunInt32AddAndWord32EqualImm) { 1264 { 1265 FOR_INT32_INPUTS(i) { 1266 RawMachineAssemblerTester<int32_t> m(MachineType::Int32(), 1267 MachineType::Int32()); 1268 m.Return(m.Int32Add(m.Int32Constant(*i), 1269 m.Word32Equal(m.Parameter(0), m.Parameter(1)))); 1270 FOR_INT32_INPUTS(j) { 1271 FOR_INT32_INPUTS(k) { 1272 // Use uint32_t because signed overflow is UB in C. 1273 int32_t const expected = 1274 bit_cast<int32_t>(bit_cast<uint32_t>(*i) + (*j == *k)); 1275 CHECK_EQ(expected, m.Call(*j, *k)); 1276 } 1277 } 1278 } 1279 } 1280 { 1281 FOR_INT32_INPUTS(i) { 1282 RawMachineAssemblerTester<int32_t> m(MachineType::Int32(), 1283 MachineType::Int32()); 1284 m.Return(m.Int32Add(m.Word32Equal(m.Int32Constant(*i), m.Parameter(0)), 1285 m.Parameter(1))); 1286 FOR_INT32_INPUTS(j) { 1287 FOR_INT32_INPUTS(k) { 1288 // Use uint32_t because signed overflow is UB in C. 1289 int32_t const expected = 1290 bit_cast<int32_t>((*i == *j) + bit_cast<uint32_t>(*k)); 1291 CHECK_EQ(expected, m.Call(*j, *k)); 1292 } 1293 } 1294 } 1295 } 1296 } 1297 1298 1299 TEST(RunInt32AddAndWord32NotEqualP) { 1300 { 1301 RawMachineAssemblerTester<int32_t> m( 1302 MachineType::Int32(), MachineType::Int32(), MachineType::Int32()); 1303 m.Return(m.Int32Add(m.Parameter(0), 1304 m.Word32NotEqual(m.Parameter(1), m.Parameter(2)))); 1305 FOR_INT32_INPUTS(i) { 1306 FOR_INT32_INPUTS(j) { 1307 FOR_INT32_INPUTS(k) { 1308 // Use uint32_t because signed overflow is UB in C. 1309 int32_t const expected = 1310 bit_cast<int32_t>(bit_cast<uint32_t>(*i) + (*j != *k)); 1311 CHECK_EQ(expected, m.Call(*i, *j, *k)); 1312 } 1313 } 1314 } 1315 } 1316 { 1317 RawMachineAssemblerTester<int32_t> m( 1318 MachineType::Int32(), MachineType::Int32(), MachineType::Int32()); 1319 m.Return(m.Int32Add(m.Word32NotEqual(m.Parameter(0), m.Parameter(1)), 1320 m.Parameter(2))); 1321 FOR_INT32_INPUTS(i) { 1322 FOR_INT32_INPUTS(j) { 1323 FOR_INT32_INPUTS(k) { 1324 // Use uint32_t because signed overflow is UB in C. 1325 int32_t const expected = 1326 bit_cast<int32_t>((*i != *j) + bit_cast<uint32_t>(*k)); 1327 CHECK_EQ(expected, m.Call(*i, *j, *k)); 1328 } 1329 } 1330 } 1331 } 1332 } 1333 1334 1335 TEST(RunInt32AddAndWord32NotEqualImm) { 1336 { 1337 FOR_INT32_INPUTS(i) { 1338 RawMachineAssemblerTester<int32_t> m(MachineType::Int32(), 1339 MachineType::Int32()); 1340 m.Return(m.Int32Add(m.Int32Constant(*i), 1341 m.Word32NotEqual(m.Parameter(0), m.Parameter(1)))); 1342 FOR_INT32_INPUTS(j) { 1343 FOR_INT32_INPUTS(k) { 1344 // Use uint32_t because signed overflow is UB in C. 1345 int32_t const expected = 1346 bit_cast<int32_t>(bit_cast<uint32_t>(*i) + (*j != *k)); 1347 CHECK_EQ(expected, m.Call(*j, *k)); 1348 } 1349 } 1350 } 1351 } 1352 { 1353 FOR_INT32_INPUTS(i) { 1354 RawMachineAssemblerTester<int32_t> m(MachineType::Int32(), 1355 MachineType::Int32()); 1356 m.Return(m.Int32Add(m.Word32NotEqual(m.Int32Constant(*i), m.Parameter(0)), 1357 m.Parameter(1))); 1358 FOR_INT32_INPUTS(j) { 1359 FOR_INT32_INPUTS(k) { 1360 // Use uint32_t because signed overflow is UB in C. 1361 int32_t const expected = 1362 bit_cast<int32_t>((*i != *j) + bit_cast<uint32_t>(*k)); 1363 CHECK_EQ(expected, m.Call(*j, *k)); 1364 } 1365 } 1366 } 1367 } 1368 } 1369 1370 1371 TEST(RunInt32AddAndWord32SarP) { 1372 { 1373 RawMachineAssemblerTester<int32_t> m( 1374 MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32()); 1375 m.Return(m.Int32Add(m.Parameter(0), 1376 m.Word32Sar(m.Parameter(1), m.Parameter(2)))); 1377 FOR_UINT32_INPUTS(i) { 1378 FOR_INT32_INPUTS(j) { 1379 FOR_UINT32_SHIFTS(shift) { 1380 // Use uint32_t because signed overflow is UB in C. 1381 int32_t expected = *i + (*j >> shift); 1382 CHECK_EQ(expected, m.Call(*i, *j, shift)); 1383 } 1384 } 1385 } 1386 } 1387 { 1388 RawMachineAssemblerTester<int32_t> m( 1389 MachineType::Int32(), MachineType::Uint32(), MachineType::Uint32()); 1390 m.Return(m.Int32Add(m.Word32Sar(m.Parameter(0), m.Parameter(1)), 1391 m.Parameter(2))); 1392 FOR_INT32_INPUTS(i) { 1393 FOR_UINT32_SHIFTS(shift) { 1394 FOR_UINT32_INPUTS(k) { 1395 // Use uint32_t because signed overflow is UB in C. 1396 int32_t expected = (*i >> shift) + *k; 1397 CHECK_EQ(expected, m.Call(*i, shift, *k)); 1398 } 1399 } 1400 } 1401 } 1402 } 1403 1404 1405 TEST(RunInt32AddAndWord32ShlP) { 1406 { 1407 RawMachineAssemblerTester<int32_t> m( 1408 MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32()); 1409 m.Return(m.Int32Add(m.Parameter(0), 1410 m.Word32Shl(m.Parameter(1), m.Parameter(2)))); 1411 FOR_UINT32_INPUTS(i) { 1412 FOR_INT32_INPUTS(j) { 1413 FOR_UINT32_SHIFTS(shift) { 1414 // Use uint32_t because signed overflow is UB in C. 1415 int32_t expected = *i + (*j << shift); 1416 CHECK_EQ(expected, m.Call(*i, *j, shift)); 1417 } 1418 } 1419 } 1420 } 1421 { 1422 RawMachineAssemblerTester<int32_t> m( 1423 MachineType::Int32(), MachineType::Uint32(), MachineType::Uint32()); 1424 m.Return(m.Int32Add(m.Word32Shl(m.Parameter(0), m.Parameter(1)), 1425 m.Parameter(2))); 1426 FOR_INT32_INPUTS(i) { 1427 FOR_UINT32_SHIFTS(shift) { 1428 FOR_UINT32_INPUTS(k) { 1429 // Use uint32_t because signed overflow is UB in C. 1430 int32_t expected = (*i << shift) + *k; 1431 CHECK_EQ(expected, m.Call(*i, shift, *k)); 1432 } 1433 } 1434 } 1435 } 1436 } 1437 1438 1439 TEST(RunInt32AddAndWord32ShrP) { 1440 { 1441 RawMachineAssemblerTester<int32_t> m( 1442 MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32()); 1443 m.Return(m.Int32Add(m.Parameter(0), 1444 m.Word32Shr(m.Parameter(1), m.Parameter(2)))); 1445 FOR_UINT32_INPUTS(i) { 1446 FOR_UINT32_INPUTS(j) { 1447 FOR_UINT32_SHIFTS(shift) { 1448 // Use uint32_t because signed overflow is UB in C. 1449 int32_t expected = *i + (*j >> shift); 1450 CHECK_EQ(expected, m.Call(*i, *j, shift)); 1451 } 1452 } 1453 } 1454 } 1455 { 1456 RawMachineAssemblerTester<int32_t> m( 1457 MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32()); 1458 m.Return(m.Int32Add(m.Word32Shr(m.Parameter(0), m.Parameter(1)), 1459 m.Parameter(2))); 1460 FOR_UINT32_INPUTS(i) { 1461 FOR_UINT32_SHIFTS(shift) { 1462 FOR_UINT32_INPUTS(k) { 1463 // Use uint32_t because signed overflow is UB in C. 1464 int32_t expected = (*i >> shift) + *k; 1465 CHECK_EQ(expected, m.Call(*i, shift, *k)); 1466 } 1467 } 1468 } 1469 } 1470 } 1471 1472 1473 TEST(RunInt32AddInBranch) { 1474 static const int32_t constant = 987654321; 1475 { 1476 RawMachineAssemblerTester<int32_t> m; 1477 Int32BinopTester bt(&m); 1478 RawMachineLabel blocka, blockb; 1479 m.Branch( 1480 m.Word32Equal(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)), 1481 &blocka, &blockb); 1482 m.Bind(&blocka); 1483 bt.AddReturn(m.Int32Constant(constant)); 1484 m.Bind(&blockb); 1485 bt.AddReturn(m.Int32Constant(0 - constant)); 1486 FOR_UINT32_INPUTS(i) { 1487 FOR_UINT32_INPUTS(j) { 1488 int32_t expected = (*i + *j) == 0 ? constant : 0 - constant; 1489 CHECK_EQ(expected, bt.call(*i, *j)); 1490 } 1491 } 1492 } 1493 { 1494 RawMachineAssemblerTester<int32_t> m; 1495 Int32BinopTester bt(&m); 1496 RawMachineLabel blocka, blockb; 1497 m.Branch( 1498 m.Word32NotEqual(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)), 1499 &blocka, &blockb); 1500 m.Bind(&blocka); 1501 bt.AddReturn(m.Int32Constant(constant)); 1502 m.Bind(&blockb); 1503 bt.AddReturn(m.Int32Constant(0 - constant)); 1504 FOR_UINT32_INPUTS(i) { 1505 FOR_UINT32_INPUTS(j) { 1506 int32_t expected = (*i + *j) != 0 ? constant : 0 - constant; 1507 CHECK_EQ(expected, bt.call(*i, *j)); 1508 } 1509 } 1510 } 1511 { 1512 FOR_UINT32_INPUTS(i) { 1513 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 1514 RawMachineLabel blocka, blockb; 1515 m.Branch(m.Word32Equal(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)), 1516 m.Int32Constant(0)), 1517 &blocka, &blockb); 1518 m.Bind(&blocka); 1519 m.Return(m.Int32Constant(constant)); 1520 m.Bind(&blockb); 1521 m.Return(m.Int32Constant(0 - constant)); 1522 FOR_UINT32_INPUTS(j) { 1523 uint32_t expected = (*i + *j) == 0 ? constant : 0 - constant; 1524 CHECK_EQ(expected, m.Call(*j)); 1525 } 1526 } 1527 } 1528 { 1529 FOR_UINT32_INPUTS(i) { 1530 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 1531 RawMachineLabel blocka, blockb; 1532 m.Branch(m.Word32NotEqual(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)), 1533 m.Int32Constant(0)), 1534 &blocka, &blockb); 1535 m.Bind(&blocka); 1536 m.Return(m.Int32Constant(constant)); 1537 m.Bind(&blockb); 1538 m.Return(m.Int32Constant(0 - constant)); 1539 FOR_UINT32_INPUTS(j) { 1540 uint32_t expected = (*i + *j) != 0 ? constant : 0 - constant; 1541 CHECK_EQ(expected, m.Call(*j)); 1542 } 1543 } 1544 } 1545 { 1546 RawMachineAssemblerTester<void> m; 1547 const Operator* shops[] = {m.machine()->Word32Sar(), 1548 m.machine()->Word32Shl(), 1549 m.machine()->Word32Shr()}; 1550 for (size_t n = 0; n < arraysize(shops); n++) { 1551 RawMachineAssemblerTester<int32_t> m( 1552 MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32()); 1553 RawMachineLabel blocka, blockb; 1554 m.Branch(m.Word32Equal(m.Int32Add(m.Parameter(0), 1555 m.AddNode(shops[n], m.Parameter(1), 1556 m.Parameter(2))), 1557 m.Int32Constant(0)), 1558 &blocka, &blockb); 1559 m.Bind(&blocka); 1560 m.Return(m.Int32Constant(constant)); 1561 m.Bind(&blockb); 1562 m.Return(m.Int32Constant(0 - constant)); 1563 FOR_UINT32_INPUTS(i) { 1564 FOR_INT32_INPUTS(j) { 1565 FOR_UINT32_SHIFTS(shift) { 1566 int32_t right; 1567 switch (shops[n]->opcode()) { 1568 default: 1569 UNREACHABLE(); 1570 case IrOpcode::kWord32Sar: 1571 right = *j >> shift; 1572 break; 1573 case IrOpcode::kWord32Shl: 1574 right = *j << shift; 1575 break; 1576 case IrOpcode::kWord32Shr: 1577 right = static_cast<uint32_t>(*j) >> shift; 1578 break; 1579 } 1580 int32_t expected = ((*i + right) == 0) ? constant : 0 - constant; 1581 CHECK_EQ(expected, m.Call(*i, *j, shift)); 1582 } 1583 } 1584 } 1585 } 1586 } 1587 } 1588 1589 1590 TEST(RunInt32AddInComparison) { 1591 { 1592 RawMachineAssemblerTester<int32_t> m; 1593 Uint32BinopTester bt(&m); 1594 bt.AddReturn( 1595 m.Word32Equal(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0))); 1596 FOR_UINT32_INPUTS(i) { 1597 FOR_UINT32_INPUTS(j) { 1598 uint32_t expected = (*i + *j) == 0; 1599 CHECK_EQ(expected, bt.call(*i, *j)); 1600 } 1601 } 1602 } 1603 { 1604 RawMachineAssemblerTester<int32_t> m; 1605 Uint32BinopTester bt(&m); 1606 bt.AddReturn( 1607 m.Word32Equal(m.Int32Constant(0), m.Int32Add(bt.param0, bt.param1))); 1608 FOR_UINT32_INPUTS(i) { 1609 FOR_UINT32_INPUTS(j) { 1610 uint32_t expected = (*i + *j) == 0; 1611 CHECK_EQ(expected, bt.call(*i, *j)); 1612 } 1613 } 1614 } 1615 { 1616 FOR_UINT32_INPUTS(i) { 1617 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 1618 m.Return(m.Word32Equal(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)), 1619 m.Int32Constant(0))); 1620 FOR_UINT32_INPUTS(j) { 1621 uint32_t expected = (*i + *j) == 0; 1622 CHECK_EQ(expected, m.Call(*j)); 1623 } 1624 } 1625 } 1626 { 1627 FOR_UINT32_INPUTS(i) { 1628 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 1629 m.Return(m.Word32Equal(m.Int32Add(m.Parameter(0), m.Int32Constant(*i)), 1630 m.Int32Constant(0))); 1631 FOR_UINT32_INPUTS(j) { 1632 uint32_t expected = (*j + *i) == 0; 1633 CHECK_EQ(expected, m.Call(*j)); 1634 } 1635 } 1636 } 1637 { 1638 RawMachineAssemblerTester<void> m; 1639 const Operator* shops[] = {m.machine()->Word32Sar(), 1640 m.machine()->Word32Shl(), 1641 m.machine()->Word32Shr()}; 1642 for (size_t n = 0; n < arraysize(shops); n++) { 1643 RawMachineAssemblerTester<int32_t> m( 1644 MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32()); 1645 m.Return(m.Word32Equal( 1646 m.Int32Add(m.Parameter(0), 1647 m.AddNode(shops[n], m.Parameter(1), m.Parameter(2))), 1648 m.Int32Constant(0))); 1649 FOR_UINT32_INPUTS(i) { 1650 FOR_INT32_INPUTS(j) { 1651 FOR_UINT32_SHIFTS(shift) { 1652 int32_t right; 1653 switch (shops[n]->opcode()) { 1654 default: 1655 UNREACHABLE(); 1656 case IrOpcode::kWord32Sar: 1657 right = *j >> shift; 1658 break; 1659 case IrOpcode::kWord32Shl: 1660 right = *j << shift; 1661 break; 1662 case IrOpcode::kWord32Shr: 1663 right = static_cast<uint32_t>(*j) >> shift; 1664 break; 1665 } 1666 int32_t expected = (*i + right) == 0; 1667 CHECK_EQ(expected, m.Call(*i, *j, shift)); 1668 } 1669 } 1670 } 1671 } 1672 } 1673 } 1674 1675 1676 TEST(RunInt32SubP) { 1677 RawMachineAssemblerTester<int32_t> m; 1678 Uint32BinopTester bt(&m); 1679 1680 m.Return(m.Int32Sub(bt.param0, bt.param1)); 1681 1682 FOR_UINT32_INPUTS(i) { 1683 FOR_UINT32_INPUTS(j) { 1684 uint32_t expected = static_cast<int32_t>(*i - *j); 1685 CHECK_EQ(expected, bt.call(*i, *j)); 1686 } 1687 } 1688 } 1689 1690 TEST(RunInt32SubImm) { 1691 { 1692 FOR_UINT32_INPUTS(i) { 1693 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 1694 m.Return(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0))); 1695 FOR_UINT32_INPUTS(j) { 1696 uint32_t expected = *i - *j; 1697 CHECK_EQ(expected, m.Call(*j)); 1698 } 1699 } 1700 } 1701 { 1702 FOR_UINT32_INPUTS(i) { 1703 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 1704 m.Return(m.Int32Sub(m.Parameter(0), m.Int32Constant(*i))); 1705 FOR_UINT32_INPUTS(j) { 1706 uint32_t expected = *j - *i; 1707 CHECK_EQ(expected, m.Call(*j)); 1708 } 1709 } 1710 } 1711 } 1712 1713 TEST(RunInt32SubImm2) { 1714 BufferedRawMachineAssemblerTester<int32_t> r; 1715 r.Return(r.Int32Sub(r.Int32Constant(-1), r.Int32Constant(0))); 1716 CHECK_EQ(-1, r.Call()); 1717 } 1718 1719 TEST(RunInt32SubAndWord32SarP) { 1720 { 1721 RawMachineAssemblerTester<int32_t> m( 1722 MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32()); 1723 m.Return(m.Int32Sub(m.Parameter(0), 1724 m.Word32Sar(m.Parameter(1), m.Parameter(2)))); 1725 FOR_UINT32_INPUTS(i) { 1726 FOR_INT32_INPUTS(j) { 1727 FOR_UINT32_SHIFTS(shift) { 1728 int32_t expected = *i - (*j >> shift); 1729 CHECK_EQ(expected, m.Call(*i, *j, shift)); 1730 } 1731 } 1732 } 1733 } 1734 { 1735 RawMachineAssemblerTester<int32_t> m( 1736 MachineType::Int32(), MachineType::Uint32(), MachineType::Uint32()); 1737 m.Return(m.Int32Sub(m.Word32Sar(m.Parameter(0), m.Parameter(1)), 1738 m.Parameter(2))); 1739 FOR_INT32_INPUTS(i) { 1740 FOR_UINT32_SHIFTS(shift) { 1741 FOR_UINT32_INPUTS(k) { 1742 int32_t expected = (*i >> shift) - *k; 1743 CHECK_EQ(expected, m.Call(*i, shift, *k)); 1744 } 1745 } 1746 } 1747 } 1748 } 1749 1750 1751 TEST(RunInt32SubAndWord32ShlP) { 1752 { 1753 RawMachineAssemblerTester<int32_t> m( 1754 MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32()); 1755 m.Return(m.Int32Sub(m.Parameter(0), 1756 m.Word32Shl(m.Parameter(1), m.Parameter(2)))); 1757 FOR_UINT32_INPUTS(i) { 1758 FOR_INT32_INPUTS(j) { 1759 FOR_UINT32_SHIFTS(shift) { 1760 int32_t expected = *i - (*j << shift); 1761 CHECK_EQ(expected, m.Call(*i, *j, shift)); 1762 } 1763 } 1764 } 1765 } 1766 { 1767 RawMachineAssemblerTester<int32_t> m( 1768 MachineType::Int32(), MachineType::Uint32(), MachineType::Uint32()); 1769 m.Return(m.Int32Sub(m.Word32Shl(m.Parameter(0), m.Parameter(1)), 1770 m.Parameter(2))); 1771 FOR_INT32_INPUTS(i) { 1772 FOR_UINT32_SHIFTS(shift) { 1773 FOR_UINT32_INPUTS(k) { 1774 // Use uint32_t because signed overflow is UB in C. 1775 int32_t expected = (*i << shift) - *k; 1776 CHECK_EQ(expected, m.Call(*i, shift, *k)); 1777 } 1778 } 1779 } 1780 } 1781 } 1782 1783 1784 TEST(RunInt32SubAndWord32ShrP) { 1785 { 1786 RawMachineAssemblerTester<uint32_t> m( 1787 MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32()); 1788 m.Return(m.Int32Sub(m.Parameter(0), 1789 m.Word32Shr(m.Parameter(1), m.Parameter(2)))); 1790 FOR_UINT32_INPUTS(i) { 1791 FOR_UINT32_INPUTS(j) { 1792 FOR_UINT32_SHIFTS(shift) { 1793 // Use uint32_t because signed overflow is UB in C. 1794 uint32_t expected = *i - (*j >> shift); 1795 CHECK_EQ(expected, m.Call(*i, *j, shift)); 1796 } 1797 } 1798 } 1799 } 1800 { 1801 RawMachineAssemblerTester<uint32_t> m( 1802 MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32()); 1803 m.Return(m.Int32Sub(m.Word32Shr(m.Parameter(0), m.Parameter(1)), 1804 m.Parameter(2))); 1805 FOR_UINT32_INPUTS(i) { 1806 FOR_UINT32_SHIFTS(shift) { 1807 FOR_UINT32_INPUTS(k) { 1808 // Use uint32_t because signed overflow is UB in C. 1809 uint32_t expected = (*i >> shift) - *k; 1810 CHECK_EQ(expected, m.Call(*i, shift, *k)); 1811 } 1812 } 1813 } 1814 } 1815 } 1816 1817 1818 TEST(RunInt32SubInBranch) { 1819 static const int constant = 987654321; 1820 { 1821 RawMachineAssemblerTester<int32_t> m; 1822 Int32BinopTester bt(&m); 1823 RawMachineLabel blocka, blockb; 1824 m.Branch( 1825 m.Word32Equal(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)), 1826 &blocka, &blockb); 1827 m.Bind(&blocka); 1828 bt.AddReturn(m.Int32Constant(constant)); 1829 m.Bind(&blockb); 1830 bt.AddReturn(m.Int32Constant(0 - constant)); 1831 FOR_UINT32_INPUTS(i) { 1832 FOR_UINT32_INPUTS(j) { 1833 int32_t expected = (*i - *j) == 0 ? constant : 0 - constant; 1834 CHECK_EQ(expected, bt.call(*i, *j)); 1835 } 1836 } 1837 } 1838 { 1839 RawMachineAssemblerTester<int32_t> m; 1840 Int32BinopTester bt(&m); 1841 RawMachineLabel blocka, blockb; 1842 m.Branch( 1843 m.Word32NotEqual(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)), 1844 &blocka, &blockb); 1845 m.Bind(&blocka); 1846 bt.AddReturn(m.Int32Constant(constant)); 1847 m.Bind(&blockb); 1848 bt.AddReturn(m.Int32Constant(0 - constant)); 1849 FOR_UINT32_INPUTS(i) { 1850 FOR_UINT32_INPUTS(j) { 1851 int32_t expected = (*i - *j) != 0 ? constant : 0 - constant; 1852 CHECK_EQ(expected, bt.call(*i, *j)); 1853 } 1854 } 1855 } 1856 { 1857 FOR_UINT32_INPUTS(i) { 1858 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 1859 RawMachineLabel blocka, blockb; 1860 m.Branch(m.Word32Equal(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)), 1861 m.Int32Constant(0)), 1862 &blocka, &blockb); 1863 m.Bind(&blocka); 1864 m.Return(m.Int32Constant(constant)); 1865 m.Bind(&blockb); 1866 m.Return(m.Int32Constant(0 - constant)); 1867 FOR_UINT32_INPUTS(j) { 1868 uint32_t expected = (*i - *j) == 0 ? constant : 0 - constant; 1869 CHECK_EQ(expected, m.Call(*j)); 1870 } 1871 } 1872 } 1873 { 1874 FOR_UINT32_INPUTS(i) { 1875 RawMachineAssemblerTester<int32_t> m(MachineType::Uint32()); 1876 RawMachineLabel blocka, blockb; 1877 m.Branch(m.Word32NotEqual(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)), 1878 m.Int32Constant(0)), 1879 &blocka, &blockb); 1880 m.Bind(&blocka); 1881 m.Return(m.Int32Constant(constant)); 1882 m.Bind(&blockb); 1883 m.Return(m.Int32Constant(0 - constant)); 1884 FOR_UINT32_INPUTS(j) { 1885 int32_t expected = (*i - *j) != 0 ? constant : 0 - constant; 1886 CHECK_EQ(expected, m.Call(*j)); 1887 } 1888 } 1889 } 1890 { 1891 RawMachineAssemblerTester<void> m; 1892 const Operator* shops[] = {m.machine()->Word32Sar(), 1893 m.machine()->Word32Shl(), 1894 m.machine()->Word32Shr()}; 1895 for (size_t n = 0; n < arraysize(shops); n++) { 1896 RawMachineAssemblerTester<int32_t> m( 1897 MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32()); 1898 RawMachineLabel blocka, blockb; 1899 m.Branch(m.Word32Equal(m.Int32Sub(m.Parameter(0), 1900 m.AddNode(shops[n], m.Parameter(1), 1901 m.Parameter(2))), 1902 m.Int32Constant(0)), 1903 &blocka, &blockb); 1904 m.Bind(&blocka); 1905 m.Return(m.Int32Constant(constant)); 1906 m.Bind(&blockb); 1907 m.Return(m.Int32Constant(0 - constant)); 1908 FOR_UINT32_INPUTS(i) { 1909 FOR_INT32_INPUTS(j) { 1910 FOR_UINT32_SHIFTS(shift) { 1911 int32_t right; 1912 switch (shops[n]->opcode()) { 1913 default: 1914 UNREACHABLE(); 1915 case IrOpcode::kWord32Sar: 1916 right = *j >> shift; 1917 break; 1918 case IrOpcode::kWord32Shl: 1919 right = *j << shift; 1920 break; 1921 case IrOpcode::kWord32Shr: 1922 right = static_cast<uint32_t>(*j) >> shift; 1923 break; 1924 } 1925 int32_t expected = ((*i - right) == 0) ? constant : 0 - constant; 1926 CHECK_EQ(expected, m.Call(*i, *j, shift)); 1927 } 1928 } 1929 } 1930 } 1931 } 1932 } 1933 1934 1935 TEST(RunInt32SubInComparison) { 1936 { 1937 RawMachineAssemblerTester<int32_t> m; 1938 Uint32BinopTester bt(&m); 1939 bt.AddReturn( 1940 m.Word32Equal(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0))); 1941 FOR_UINT32_INPUTS(i) { 1942 FOR_UINT32_INPUTS(j) { 1943 uint32_t expected = (*i - *j) == 0; 1944 CHECK_EQ(expected, bt.call(*i, *j)); 1945 } 1946 } 1947 } 1948 { 1949 RawMachineAssemblerTester<int32_t> m; 1950 Uint32BinopTester bt(&m); 1951 bt.AddReturn( 1952 m.Word32Equal(m.Int32Constant(0), m.Int32Sub(bt.param0, bt.param1))); 1953 FOR_UINT32_INPUTS(i) { 1954 FOR_UINT32_INPUTS(j) { 1955 uint32_t expected = (*i - *j) == 0; 1956 CHECK_EQ(expected, bt.call(*i, *j)); 1957 } 1958 } 1959 } 1960 { 1961 FOR_UINT32_INPUTS(i) { 1962 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 1963 m.Return(m.Word32Equal(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)), 1964 m.Int32Constant(0))); 1965 FOR_UINT32_INPUTS(j) { 1966 uint32_t expected = (*i - *j) == 0; 1967 CHECK_EQ(expected, m.Call(*j)); 1968 } 1969 } 1970 } 1971 { 1972 FOR_UINT32_INPUTS(i) { 1973 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 1974 m.Return(m.Word32Equal(m.Int32Sub(m.Parameter(0), m.Int32Constant(*i)), 1975 m.Int32Constant(0))); 1976 FOR_UINT32_INPUTS(j) { 1977 uint32_t expected = (*j - *i) == 0; 1978 CHECK_EQ(expected, m.Call(*j)); 1979 } 1980 } 1981 } 1982 { 1983 RawMachineAssemblerTester<void> m; 1984 const Operator* shops[] = {m.machine()->Word32Sar(), 1985 m.machine()->Word32Shl(), 1986 m.machine()->Word32Shr()}; 1987 for (size_t n = 0; n < arraysize(shops); n++) { 1988 RawMachineAssemblerTester<int32_t> m( 1989 MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32()); 1990 m.Return(m.Word32Equal( 1991 m.Int32Sub(m.Parameter(0), 1992 m.AddNode(shops[n], m.Parameter(1), m.Parameter(2))), 1993 m.Int32Constant(0))); 1994 FOR_UINT32_INPUTS(i) { 1995 FOR_INT32_INPUTS(j) { 1996 FOR_UINT32_SHIFTS(shift) { 1997 int32_t right; 1998 switch (shops[n]->opcode()) { 1999 default: 2000 UNREACHABLE(); 2001 case IrOpcode::kWord32Sar: 2002 right = *j >> shift; 2003 break; 2004 case IrOpcode::kWord32Shl: 2005 right = *j << shift; 2006 break; 2007 case IrOpcode::kWord32Shr: 2008 right = static_cast<uint32_t>(*j) >> shift; 2009 break; 2010 } 2011 int32_t expected = (*i - right) == 0; 2012 CHECK_EQ(expected, m.Call(*i, *j, shift)); 2013 } 2014 } 2015 } 2016 } 2017 } 2018 } 2019 2020 2021 TEST(RunInt32MulP) { 2022 { 2023 RawMachineAssemblerTester<int32_t> m; 2024 Int32BinopTester bt(&m); 2025 bt.AddReturn(m.Int32Mul(bt.param0, bt.param1)); 2026 FOR_INT32_INPUTS(i) { 2027 FOR_INT32_INPUTS(j) { 2028 int expected = static_cast<int32_t>(*i * *j); 2029 CHECK_EQ(expected, bt.call(*i, *j)); 2030 } 2031 } 2032 } 2033 { 2034 RawMachineAssemblerTester<int32_t> m; 2035 Uint32BinopTester bt(&m); 2036 bt.AddReturn(m.Int32Mul(bt.param0, bt.param1)); 2037 FOR_UINT32_INPUTS(i) { 2038 FOR_UINT32_INPUTS(j) { 2039 uint32_t expected = *i * *j; 2040 CHECK_EQ(expected, bt.call(*i, *j)); 2041 } 2042 } 2043 } 2044 } 2045 2046 2047 TEST(RunInt32MulHighP) { 2048 RawMachineAssemblerTester<int32_t> m; 2049 Int32BinopTester bt(&m); 2050 bt.AddReturn(m.Int32MulHigh(bt.param0, bt.param1)); 2051 FOR_INT32_INPUTS(i) { 2052 FOR_INT32_INPUTS(j) { 2053 int32_t expected = static_cast<int32_t>( 2054 (static_cast<int64_t>(*i) * static_cast<int64_t>(*j)) >> 32); 2055 CHECK_EQ(expected, bt.call(*i, *j)); 2056 } 2057 } 2058 } 2059 2060 2061 TEST(RunInt32MulImm) { 2062 { 2063 FOR_UINT32_INPUTS(i) { 2064 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 2065 m.Return(m.Int32Mul(m.Int32Constant(*i), m.Parameter(0))); 2066 FOR_UINT32_INPUTS(j) { 2067 uint32_t expected = *i * *j; 2068 CHECK_EQ(expected, m.Call(*j)); 2069 } 2070 } 2071 } 2072 { 2073 FOR_UINT32_INPUTS(i) { 2074 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 2075 m.Return(m.Int32Mul(m.Parameter(0), m.Int32Constant(*i))); 2076 FOR_UINT32_INPUTS(j) { 2077 uint32_t expected = *j * *i; 2078 CHECK_EQ(expected, m.Call(*j)); 2079 } 2080 } 2081 } 2082 } 2083 2084 2085 TEST(RunInt32MulAndInt32AddP) { 2086 { 2087 FOR_INT32_INPUTS(i) { 2088 FOR_INT32_INPUTS(j) { 2089 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 2090 int32_t p0 = *i; 2091 int32_t p1 = *j; 2092 m.Return(m.Int32Add(m.Int32Constant(p0), 2093 m.Int32Mul(m.Parameter(0), m.Int32Constant(p1)))); 2094 FOR_INT32_INPUTS(k) { 2095 int32_t p2 = *k; 2096 int expected = p0 + static_cast<int32_t>(p1 * p2); 2097 CHECK_EQ(expected, m.Call(p2)); 2098 } 2099 } 2100 } 2101 } 2102 { 2103 RawMachineAssemblerTester<int32_t> m( 2104 MachineType::Int32(), MachineType::Int32(), MachineType::Int32()); 2105 m.Return( 2106 m.Int32Add(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2)))); 2107 FOR_INT32_INPUTS(i) { 2108 FOR_INT32_INPUTS(j) { 2109 FOR_INT32_INPUTS(k) { 2110 int32_t p0 = *i; 2111 int32_t p1 = *j; 2112 int32_t p2 = *k; 2113 int expected = p0 + static_cast<int32_t>(p1 * p2); 2114 CHECK_EQ(expected, m.Call(p0, p1, p2)); 2115 } 2116 } 2117 } 2118 } 2119 { 2120 RawMachineAssemblerTester<int32_t> m( 2121 MachineType::Int32(), MachineType::Int32(), MachineType::Int32()); 2122 m.Return( 2123 m.Int32Add(m.Int32Mul(m.Parameter(0), m.Parameter(1)), m.Parameter(2))); 2124 FOR_INT32_INPUTS(i) { 2125 FOR_INT32_INPUTS(j) { 2126 FOR_INT32_INPUTS(k) { 2127 int32_t p0 = *i; 2128 int32_t p1 = *j; 2129 int32_t p2 = *k; 2130 int expected = static_cast<int32_t>(p0 * p1) + p2; 2131 CHECK_EQ(expected, m.Call(p0, p1, p2)); 2132 } 2133 } 2134 } 2135 } 2136 { 2137 FOR_INT32_INPUTS(i) { 2138 RawMachineAssemblerTester<int32_t> m; 2139 Int32BinopTester bt(&m); 2140 bt.AddReturn( 2141 m.Int32Add(m.Int32Constant(*i), m.Int32Mul(bt.param0, bt.param1))); 2142 FOR_INT32_INPUTS(j) { 2143 FOR_INT32_INPUTS(k) { 2144 int32_t p0 = *j; 2145 int32_t p1 = *k; 2146 int expected = *i + static_cast<int32_t>(p0 * p1); 2147 CHECK_EQ(expected, bt.call(p0, p1)); 2148 } 2149 } 2150 } 2151 } 2152 } 2153 2154 2155 TEST(RunInt32MulAndInt32SubP) { 2156 { 2157 RawMachineAssemblerTester<int32_t> m( 2158 MachineType::Uint32(), MachineType::Int32(), MachineType::Int32()); 2159 m.Return( 2160 m.Int32Sub(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2)))); 2161 FOR_UINT32_INPUTS(i) { 2162 FOR_INT32_INPUTS(j) { 2163 FOR_INT32_INPUTS(k) { 2164 uint32_t p0 = *i; 2165 int32_t p1 = *j; 2166 int32_t p2 = *k; 2167 // Use uint32_t because signed overflow is UB in C. 2168 int expected = p0 - static_cast<uint32_t>(p1 * p2); 2169 CHECK_EQ(expected, m.Call(p0, p1, p2)); 2170 } 2171 } 2172 } 2173 } 2174 { 2175 FOR_UINT32_INPUTS(i) { 2176 RawMachineAssemblerTester<int32_t> m; 2177 Int32BinopTester bt(&m); 2178 bt.AddReturn( 2179 m.Int32Sub(m.Int32Constant(*i), m.Int32Mul(bt.param0, bt.param1))); 2180 FOR_INT32_INPUTS(j) { 2181 FOR_INT32_INPUTS(k) { 2182 int32_t p0 = *j; 2183 int32_t p1 = *k; 2184 // Use uint32_t because signed overflow is UB in C. 2185 int expected = *i - static_cast<uint32_t>(p0 * p1); 2186 CHECK_EQ(expected, bt.call(p0, p1)); 2187 } 2188 } 2189 } 2190 } 2191 } 2192 2193 2194 TEST(RunUint32MulHighP) { 2195 RawMachineAssemblerTester<int32_t> m; 2196 Int32BinopTester bt(&m); 2197 bt.AddReturn(m.Uint32MulHigh(bt.param0, bt.param1)); 2198 FOR_UINT32_INPUTS(i) { 2199 FOR_UINT32_INPUTS(j) { 2200 int32_t expected = bit_cast<int32_t>(static_cast<uint32_t>( 2201 (static_cast<uint64_t>(*i) * static_cast<uint64_t>(*j)) >> 32)); 2202 CHECK_EQ(expected, bt.call(bit_cast<int32_t>(*i), bit_cast<int32_t>(*j))); 2203 } 2204 } 2205 } 2206 2207 2208 TEST(RunInt32DivP) { 2209 { 2210 RawMachineAssemblerTester<int32_t> m; 2211 Int32BinopTester bt(&m); 2212 bt.AddReturn(m.Int32Div(bt.param0, bt.param1)); 2213 FOR_INT32_INPUTS(i) { 2214 FOR_INT32_INPUTS(j) { 2215 int p0 = *i; 2216 int p1 = *j; 2217 if (p1 != 0 && (static_cast<uint32_t>(p0) != 0x80000000 || p1 != -1)) { 2218 int expected = static_cast<int32_t>(p0 / p1); 2219 CHECK_EQ(expected, bt.call(p0, p1)); 2220 } 2221 } 2222 } 2223 } 2224 { 2225 RawMachineAssemblerTester<int32_t> m; 2226 Int32BinopTester bt(&m); 2227 bt.AddReturn(m.Int32Add(bt.param0, m.Int32Div(bt.param0, bt.param1))); 2228 FOR_INT32_INPUTS(i) { 2229 FOR_INT32_INPUTS(j) { 2230 int p0 = *i; 2231 int p1 = *j; 2232 if (p1 != 0 && (static_cast<uint32_t>(p0) != 0x80000000 || p1 != -1)) { 2233 int expected = static_cast<int32_t>(p0 + (p0 / p1)); 2234 CHECK_EQ(expected, bt.call(p0, p1)); 2235 } 2236 } 2237 } 2238 } 2239 } 2240 2241 2242 TEST(RunUint32DivP) { 2243 { 2244 RawMachineAssemblerTester<int32_t> m; 2245 Int32BinopTester bt(&m); 2246 bt.AddReturn(m.Uint32Div(bt.param0, bt.param1)); 2247 FOR_UINT32_INPUTS(i) { 2248 FOR_UINT32_INPUTS(j) { 2249 uint32_t p0 = *i; 2250 uint32_t p1 = *j; 2251 if (p1 != 0) { 2252 int32_t expected = bit_cast<int32_t>(p0 / p1); 2253 CHECK_EQ(expected, bt.call(p0, p1)); 2254 } 2255 } 2256 } 2257 } 2258 { 2259 RawMachineAssemblerTester<int32_t> m; 2260 Int32BinopTester bt(&m); 2261 bt.AddReturn(m.Int32Add(bt.param0, m.Uint32Div(bt.param0, bt.param1))); 2262 FOR_UINT32_INPUTS(i) { 2263 FOR_UINT32_INPUTS(j) { 2264 uint32_t p0 = *i; 2265 uint32_t p1 = *j; 2266 if (p1 != 0) { 2267 int32_t expected = bit_cast<int32_t>(p0 + (p0 / p1)); 2268 CHECK_EQ(expected, bt.call(p0, p1)); 2269 } 2270 } 2271 } 2272 } 2273 } 2274 2275 2276 TEST(RunInt32ModP) { 2277 { 2278 RawMachineAssemblerTester<int32_t> m; 2279 Int32BinopTester bt(&m); 2280 bt.AddReturn(m.Int32Mod(bt.param0, bt.param1)); 2281 FOR_INT32_INPUTS(i) { 2282 FOR_INT32_INPUTS(j) { 2283 int p0 = *i; 2284 int p1 = *j; 2285 if (p1 != 0 && (static_cast<uint32_t>(p0) != 0x80000000 || p1 != -1)) { 2286 int expected = static_cast<int32_t>(p0 % p1); 2287 CHECK_EQ(expected, bt.call(p0, p1)); 2288 } 2289 } 2290 } 2291 } 2292 { 2293 RawMachineAssemblerTester<int32_t> m; 2294 Int32BinopTester bt(&m); 2295 bt.AddReturn(m.Int32Add(bt.param0, m.Int32Mod(bt.param0, bt.param1))); 2296 FOR_INT32_INPUTS(i) { 2297 FOR_INT32_INPUTS(j) { 2298 int p0 = *i; 2299 int p1 = *j; 2300 if (p1 != 0 && (static_cast<uint32_t>(p0) != 0x80000000 || p1 != -1)) { 2301 int expected = static_cast<int32_t>(p0 + (p0 % p1)); 2302 CHECK_EQ(expected, bt.call(p0, p1)); 2303 } 2304 } 2305 } 2306 } 2307 } 2308 2309 2310 TEST(RunUint32ModP) { 2311 { 2312 RawMachineAssemblerTester<int32_t> m; 2313 Uint32BinopTester bt(&m); 2314 bt.AddReturn(m.Uint32Mod(bt.param0, bt.param1)); 2315 FOR_UINT32_INPUTS(i) { 2316 FOR_UINT32_INPUTS(j) { 2317 uint32_t p0 = *i; 2318 uint32_t p1 = *j; 2319 if (p1 != 0) { 2320 uint32_t expected = static_cast<uint32_t>(p0 % p1); 2321 CHECK_EQ(expected, bt.call(p0, p1)); 2322 } 2323 } 2324 } 2325 } 2326 { 2327 RawMachineAssemblerTester<int32_t> m; 2328 Uint32BinopTester bt(&m); 2329 bt.AddReturn(m.Int32Add(bt.param0, m.Uint32Mod(bt.param0, bt.param1))); 2330 FOR_UINT32_INPUTS(i) { 2331 FOR_UINT32_INPUTS(j) { 2332 uint32_t p0 = *i; 2333 uint32_t p1 = *j; 2334 if (p1 != 0) { 2335 uint32_t expected = static_cast<uint32_t>(p0 + (p0 % p1)); 2336 CHECK_EQ(expected, bt.call(p0, p1)); 2337 } 2338 } 2339 } 2340 } 2341 } 2342 2343 2344 TEST(RunWord32AndP) { 2345 { 2346 RawMachineAssemblerTester<int32_t> m; 2347 Int32BinopTester bt(&m); 2348 bt.AddReturn(m.Word32And(bt.param0, bt.param1)); 2349 FOR_UINT32_INPUTS(i) { 2350 FOR_UINT32_INPUTS(j) { 2351 int32_t expected = *i & *j; 2352 CHECK_EQ(expected, bt.call(*i, *j)); 2353 } 2354 } 2355 } 2356 { 2357 RawMachineAssemblerTester<int32_t> m; 2358 Int32BinopTester bt(&m); 2359 bt.AddReturn(m.Word32And(bt.param0, m.Word32Not(bt.param1))); 2360 FOR_UINT32_INPUTS(i) { 2361 FOR_UINT32_INPUTS(j) { 2362 int32_t expected = *i & ~(*j); 2363 CHECK_EQ(expected, bt.call(*i, *j)); 2364 } 2365 } 2366 } 2367 { 2368 RawMachineAssemblerTester<int32_t> m; 2369 Int32BinopTester bt(&m); 2370 bt.AddReturn(m.Word32And(m.Word32Not(bt.param0), bt.param1)); 2371 FOR_UINT32_INPUTS(i) { 2372 FOR_UINT32_INPUTS(j) { 2373 int32_t expected = ~(*i) & *j; 2374 CHECK_EQ(expected, bt.call(*i, *j)); 2375 } 2376 } 2377 } 2378 } 2379 2380 2381 TEST(RunWord32AndAndWord32ShlP) { 2382 { 2383 RawMachineAssemblerTester<int32_t> m; 2384 Uint32BinopTester bt(&m); 2385 bt.AddReturn( 2386 m.Word32Shl(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1f)))); 2387 FOR_UINT32_INPUTS(i) { 2388 FOR_UINT32_INPUTS(j) { 2389 uint32_t expected = *i << (*j & 0x1f); 2390 CHECK_EQ(expected, bt.call(*i, *j)); 2391 } 2392 } 2393 } 2394 { 2395 RawMachineAssemblerTester<int32_t> m; 2396 Uint32BinopTester bt(&m); 2397 bt.AddReturn( 2398 m.Word32Shl(bt.param0, m.Word32And(m.Int32Constant(0x1f), bt.param1))); 2399 FOR_UINT32_INPUTS(i) { 2400 FOR_UINT32_INPUTS(j) { 2401 uint32_t expected = *i << (0x1f & *j); 2402 CHECK_EQ(expected, bt.call(*i, *j)); 2403 } 2404 } 2405 } 2406 } 2407 2408 2409 TEST(RunWord32AndAndWord32ShrP) { 2410 { 2411 RawMachineAssemblerTester<int32_t> m; 2412 Uint32BinopTester bt(&m); 2413 bt.AddReturn( 2414 m.Word32Shr(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1f)))); 2415 FOR_UINT32_INPUTS(i) { 2416 FOR_UINT32_INPUTS(j) { 2417 uint32_t expected = *i >> (*j & 0x1f); 2418 CHECK_EQ(expected, bt.call(*i, *j)); 2419 } 2420 } 2421 } 2422 { 2423 RawMachineAssemblerTester<int32_t> m; 2424 Uint32BinopTester bt(&m); 2425 bt.AddReturn( 2426 m.Word32Shr(bt.param0, m.Word32And(m.Int32Constant(0x1f), bt.param1))); 2427 FOR_UINT32_INPUTS(i) { 2428 FOR_UINT32_INPUTS(j) { 2429 uint32_t expected = *i >> (0x1f & *j); 2430 CHECK_EQ(expected, bt.call(*i, *j)); 2431 } 2432 } 2433 } 2434 } 2435 2436 2437 TEST(RunWord32AndAndWord32SarP) { 2438 { 2439 RawMachineAssemblerTester<int32_t> m; 2440 Int32BinopTester bt(&m); 2441 bt.AddReturn( 2442 m.Word32Sar(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1f)))); 2443 FOR_INT32_INPUTS(i) { 2444 FOR_INT32_INPUTS(j) { 2445 int32_t expected = *i >> (*j & 0x1f); 2446 CHECK_EQ(expected, bt.call(*i, *j)); 2447 } 2448 } 2449 } 2450 { 2451 RawMachineAssemblerTester<int32_t> m; 2452 Int32BinopTester bt(&m); 2453 bt.AddReturn( 2454 m.Word32Sar(bt.param0, m.Word32And(m.Int32Constant(0x1f), bt.param1))); 2455 FOR_INT32_INPUTS(i) { 2456 FOR_INT32_INPUTS(j) { 2457 int32_t expected = *i >> (0x1f & *j); 2458 CHECK_EQ(expected, bt.call(*i, *j)); 2459 } 2460 } 2461 } 2462 } 2463 2464 2465 TEST(RunWord32AndImm) { 2466 { 2467 FOR_UINT32_INPUTS(i) { 2468 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 2469 m.Return(m.Word32And(m.Int32Constant(*i), m.Parameter(0))); 2470 FOR_UINT32_INPUTS(j) { 2471 uint32_t expected = *i & *j; 2472 CHECK_EQ(expected, m.Call(*j)); 2473 } 2474 } 2475 } 2476 { 2477 FOR_UINT32_INPUTS(i) { 2478 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 2479 m.Return(m.Word32And(m.Int32Constant(*i), m.Word32Not(m.Parameter(0)))); 2480 FOR_UINT32_INPUTS(j) { 2481 uint32_t expected = *i & ~(*j); 2482 CHECK_EQ(expected, m.Call(*j)); 2483 } 2484 } 2485 } 2486 } 2487 2488 2489 TEST(RunWord32AndInBranch) { 2490 static const int constant = 987654321; 2491 { 2492 RawMachineAssemblerTester<int32_t> m; 2493 Int32BinopTester bt(&m); 2494 RawMachineLabel blocka, blockb; 2495 m.Branch( 2496 m.Word32Equal(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)), 2497 &blocka, &blockb); 2498 m.Bind(&blocka); 2499 bt.AddReturn(m.Int32Constant(constant)); 2500 m.Bind(&blockb); 2501 bt.AddReturn(m.Int32Constant(0 - constant)); 2502 FOR_UINT32_INPUTS(i) { 2503 FOR_UINT32_INPUTS(j) { 2504 int32_t expected = (*i & *j) == 0 ? constant : 0 - constant; 2505 CHECK_EQ(expected, bt.call(*i, *j)); 2506 } 2507 } 2508 } 2509 { 2510 RawMachineAssemblerTester<int32_t> m; 2511 Int32BinopTester bt(&m); 2512 RawMachineLabel blocka, blockb; 2513 m.Branch( 2514 m.Word32NotEqual(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)), 2515 &blocka, &blockb); 2516 m.Bind(&blocka); 2517 bt.AddReturn(m.Int32Constant(constant)); 2518 m.Bind(&blockb); 2519 bt.AddReturn(m.Int32Constant(0 - constant)); 2520 FOR_UINT32_INPUTS(i) { 2521 FOR_UINT32_INPUTS(j) { 2522 int32_t expected = (*i & *j) != 0 ? constant : 0 - constant; 2523 CHECK_EQ(expected, bt.call(*i, *j)); 2524 } 2525 } 2526 } 2527 { 2528 FOR_UINT32_INPUTS(i) { 2529 RawMachineAssemblerTester<int32_t> m(MachineType::Uint32()); 2530 RawMachineLabel blocka, blockb; 2531 m.Branch(m.Word32Equal(m.Word32And(m.Int32Constant(*i), m.Parameter(0)), 2532 m.Int32Constant(0)), 2533 &blocka, &blockb); 2534 m.Bind(&blocka); 2535 m.Return(m.Int32Constant(constant)); 2536 m.Bind(&blockb); 2537 m.Return(m.Int32Constant(0 - constant)); 2538 FOR_UINT32_INPUTS(j) { 2539 int32_t expected = (*i & *j) == 0 ? constant : 0 - constant; 2540 CHECK_EQ(expected, m.Call(*j)); 2541 } 2542 } 2543 } 2544 { 2545 FOR_UINT32_INPUTS(i) { 2546 RawMachineAssemblerTester<int32_t> m(MachineType::Uint32()); 2547 RawMachineLabel blocka, blockb; 2548 m.Branch( 2549 m.Word32NotEqual(m.Word32And(m.Int32Constant(*i), m.Parameter(0)), 2550 m.Int32Constant(0)), 2551 &blocka, &blockb); 2552 m.Bind(&blocka); 2553 m.Return(m.Int32Constant(constant)); 2554 m.Bind(&blockb); 2555 m.Return(m.Int32Constant(0 - constant)); 2556 FOR_UINT32_INPUTS(j) { 2557 int32_t expected = (*i & *j) != 0 ? constant : 0 - constant; 2558 CHECK_EQ(expected, m.Call(*j)); 2559 } 2560 } 2561 } 2562 { 2563 RawMachineAssemblerTester<void> m; 2564 const Operator* shops[] = {m.machine()->Word32Sar(), 2565 m.machine()->Word32Shl(), 2566 m.machine()->Word32Shr()}; 2567 for (size_t n = 0; n < arraysize(shops); n++) { 2568 RawMachineAssemblerTester<int32_t> m( 2569 MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32()); 2570 RawMachineLabel blocka, blockb; 2571 m.Branch(m.Word32Equal(m.Word32And(m.Parameter(0), 2572 m.AddNode(shops[n], m.Parameter(1), 2573 m.Parameter(2))), 2574 m.Int32Constant(0)), 2575 &blocka, &blockb); 2576 m.Bind(&blocka); 2577 m.Return(m.Int32Constant(constant)); 2578 m.Bind(&blockb); 2579 m.Return(m.Int32Constant(0 - constant)); 2580 FOR_UINT32_INPUTS(i) { 2581 FOR_INT32_INPUTS(j) { 2582 FOR_UINT32_SHIFTS(shift) { 2583 int32_t right; 2584 switch (shops[n]->opcode()) { 2585 default: 2586 UNREACHABLE(); 2587 case IrOpcode::kWord32Sar: 2588 right = *j >> shift; 2589 break; 2590 case IrOpcode::kWord32Shl: 2591 right = *j << shift; 2592 break; 2593 case IrOpcode::kWord32Shr: 2594 right = static_cast<uint32_t>(*j) >> shift; 2595 break; 2596 } 2597 int32_t expected = ((*i & right) == 0) ? constant : 0 - constant; 2598 CHECK_EQ(expected, m.Call(*i, *j, shift)); 2599 } 2600 } 2601 } 2602 } 2603 } 2604 } 2605 2606 2607 TEST(RunWord32AndInComparison) { 2608 { 2609 RawMachineAssemblerTester<int32_t> m; 2610 Uint32BinopTester bt(&m); 2611 bt.AddReturn( 2612 m.Word32Equal(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0))); 2613 FOR_UINT32_INPUTS(i) { 2614 FOR_UINT32_INPUTS(j) { 2615 uint32_t expected = (*i & *j) == 0; 2616 CHECK_EQ(expected, bt.call(*i, *j)); 2617 } 2618 } 2619 } 2620 { 2621 RawMachineAssemblerTester<int32_t> m; 2622 Uint32BinopTester bt(&m); 2623 bt.AddReturn( 2624 m.Word32Equal(m.Int32Constant(0), m.Word32And(bt.param0, bt.param1))); 2625 FOR_UINT32_INPUTS(i) { 2626 FOR_UINT32_INPUTS(j) { 2627 uint32_t expected = (*i & *j) == 0; 2628 CHECK_EQ(expected, bt.call(*i, *j)); 2629 } 2630 } 2631 } 2632 { 2633 FOR_UINT32_INPUTS(i) { 2634 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 2635 m.Return(m.Word32Equal(m.Word32And(m.Int32Constant(*i), m.Parameter(0)), 2636 m.Int32Constant(0))); 2637 FOR_UINT32_INPUTS(j) { 2638 uint32_t expected = (*i & *j) == 0; 2639 CHECK_EQ(expected, m.Call(*j)); 2640 } 2641 } 2642 } 2643 { 2644 FOR_UINT32_INPUTS(i) { 2645 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 2646 m.Return(m.Word32Equal(m.Word32And(m.Parameter(0), m.Int32Constant(*i)), 2647 m.Int32Constant(0))); 2648 FOR_UINT32_INPUTS(j) { 2649 uint32_t expected = (*j & *i) == 0; 2650 CHECK_EQ(expected, m.Call(*j)); 2651 } 2652 } 2653 } 2654 } 2655 2656 2657 TEST(RunWord32OrP) { 2658 { 2659 RawMachineAssemblerTester<int32_t> m; 2660 Uint32BinopTester bt(&m); 2661 bt.AddReturn(m.Word32Or(bt.param0, bt.param1)); 2662 FOR_UINT32_INPUTS(i) { 2663 FOR_UINT32_INPUTS(j) { 2664 uint32_t expected = *i | *j; 2665 CHECK_EQ(expected, bt.call(*i, *j)); 2666 } 2667 } 2668 } 2669 { 2670 RawMachineAssemblerTester<int32_t> m; 2671 Uint32BinopTester bt(&m); 2672 bt.AddReturn(m.Word32Or(bt.param0, m.Word32Not(bt.param1))); 2673 FOR_UINT32_INPUTS(i) { 2674 FOR_UINT32_INPUTS(j) { 2675 uint32_t expected = *i | ~(*j); 2676 CHECK_EQ(expected, bt.call(*i, *j)); 2677 } 2678 } 2679 } 2680 { 2681 RawMachineAssemblerTester<int32_t> m; 2682 Uint32BinopTester bt(&m); 2683 bt.AddReturn(m.Word32Or(m.Word32Not(bt.param0), bt.param1)); 2684 FOR_UINT32_INPUTS(i) { 2685 FOR_UINT32_INPUTS(j) { 2686 uint32_t expected = ~(*i) | *j; 2687 CHECK_EQ(expected, bt.call(*i, *j)); 2688 } 2689 } 2690 } 2691 } 2692 2693 2694 TEST(RunWord32OrImm) { 2695 { 2696 FOR_UINT32_INPUTS(i) { 2697 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 2698 m.Return(m.Word32Or(m.Int32Constant(*i), m.Parameter(0))); 2699 FOR_UINT32_INPUTS(j) { 2700 uint32_t expected = *i | *j; 2701 CHECK_EQ(expected, m.Call(*j)); 2702 } 2703 } 2704 } 2705 { 2706 FOR_UINT32_INPUTS(i) { 2707 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 2708 m.Return(m.Word32Or(m.Int32Constant(*i), m.Word32Not(m.Parameter(0)))); 2709 FOR_UINT32_INPUTS(j) { 2710 uint32_t expected = *i | ~(*j); 2711 CHECK_EQ(expected, m.Call(*j)); 2712 } 2713 } 2714 } 2715 } 2716 2717 2718 TEST(RunWord32OrInBranch) { 2719 static const int constant = 987654321; 2720 { 2721 RawMachineAssemblerTester<int32_t> m; 2722 Int32BinopTester bt(&m); 2723 RawMachineLabel blocka, blockb; 2724 m.Branch( 2725 m.Word32Equal(m.Word32Or(bt.param0, bt.param1), m.Int32Constant(0)), 2726 &blocka, &blockb); 2727 m.Bind(&blocka); 2728 bt.AddReturn(m.Int32Constant(constant)); 2729 m.Bind(&blockb); 2730 bt.AddReturn(m.Int32Constant(0 - constant)); 2731 FOR_INT32_INPUTS(i) { 2732 FOR_INT32_INPUTS(j) { 2733 int32_t expected = (*i | *j) == 0 ? constant : 0 - constant; 2734 CHECK_EQ(expected, bt.call(*i, *j)); 2735 } 2736 } 2737 } 2738 { 2739 RawMachineAssemblerTester<int32_t> m; 2740 Int32BinopTester bt(&m); 2741 RawMachineLabel blocka, blockb; 2742 m.Branch( 2743 m.Word32NotEqual(m.Word32Or(bt.param0, bt.param1), m.Int32Constant(0)), 2744 &blocka, &blockb); 2745 m.Bind(&blocka); 2746 bt.AddReturn(m.Int32Constant(constant)); 2747 m.Bind(&blockb); 2748 bt.AddReturn(m.Int32Constant(0 - constant)); 2749 FOR_INT32_INPUTS(i) { 2750 FOR_INT32_INPUTS(j) { 2751 int32_t expected = (*i | *j) != 0 ? constant : 0 - constant; 2752 CHECK_EQ(expected, bt.call(*i, *j)); 2753 } 2754 } 2755 } 2756 { 2757 FOR_INT32_INPUTS(i) { 2758 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 2759 RawMachineLabel blocka, blockb; 2760 m.Branch(m.Word32Equal(m.Word32Or(m.Int32Constant(*i), m.Parameter(0)), 2761 m.Int32Constant(0)), 2762 &blocka, &blockb); 2763 m.Bind(&blocka); 2764 m.Return(m.Int32Constant(constant)); 2765 m.Bind(&blockb); 2766 m.Return(m.Int32Constant(0 - constant)); 2767 FOR_INT32_INPUTS(j) { 2768 int32_t expected = (*i | *j) == 0 ? constant : 0 - constant; 2769 CHECK_EQ(expected, m.Call(*j)); 2770 } 2771 } 2772 } 2773 { 2774 FOR_INT32_INPUTS(i) { 2775 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 2776 RawMachineLabel blocka, blockb; 2777 m.Branch(m.Word32NotEqual(m.Word32Or(m.Int32Constant(*i), m.Parameter(0)), 2778 m.Int32Constant(0)), 2779 &blocka, &blockb); 2780 m.Bind(&blocka); 2781 m.Return(m.Int32Constant(constant)); 2782 m.Bind(&blockb); 2783 m.Return(m.Int32Constant(0 - constant)); 2784 FOR_INT32_INPUTS(j) { 2785 int32_t expected = (*i | *j) != 0 ? constant : 0 - constant; 2786 CHECK_EQ(expected, m.Call(*j)); 2787 } 2788 } 2789 } 2790 { 2791 RawMachineAssemblerTester<void> m; 2792 const Operator* shops[] = {m.machine()->Word32Sar(), 2793 m.machine()->Word32Shl(), 2794 m.machine()->Word32Shr()}; 2795 for (size_t n = 0; n < arraysize(shops); n++) { 2796 RawMachineAssemblerTester<int32_t> m( 2797 MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32()); 2798 RawMachineLabel blocka, blockb; 2799 m.Branch(m.Word32Equal(m.Word32Or(m.Parameter(0), 2800 m.AddNode(shops[n], m.Parameter(1), 2801 m.Parameter(2))), 2802 m.Int32Constant(0)), 2803 &blocka, &blockb); 2804 m.Bind(&blocka); 2805 m.Return(m.Int32Constant(constant)); 2806 m.Bind(&blockb); 2807 m.Return(m.Int32Constant(0 - constant)); 2808 FOR_UINT32_INPUTS(i) { 2809 FOR_INT32_INPUTS(j) { 2810 FOR_UINT32_SHIFTS(shift) { 2811 int32_t right; 2812 switch (shops[n]->opcode()) { 2813 default: 2814 UNREACHABLE(); 2815 case IrOpcode::kWord32Sar: 2816 right = *j >> shift; 2817 break; 2818 case IrOpcode::kWord32Shl: 2819 right = *j << shift; 2820 break; 2821 case IrOpcode::kWord32Shr: 2822 right = static_cast<uint32_t>(*j) >> shift; 2823 break; 2824 } 2825 int32_t expected = ((*i | right) == 0) ? constant : 0 - constant; 2826 CHECK_EQ(expected, m.Call(*i, *j, shift)); 2827 } 2828 } 2829 } 2830 } 2831 } 2832 } 2833 2834 2835 TEST(RunWord32OrInComparison) { 2836 { 2837 RawMachineAssemblerTester<int32_t> m; 2838 Int32BinopTester bt(&m); 2839 bt.AddReturn( 2840 m.Word32Equal(m.Word32Or(bt.param0, bt.param1), m.Int32Constant(0))); 2841 FOR_UINT32_INPUTS(i) { 2842 FOR_UINT32_INPUTS(j) { 2843 int32_t expected = (*i | *j) == 0; 2844 CHECK_EQ(expected, bt.call(*i, *j)); 2845 } 2846 } 2847 } 2848 { 2849 RawMachineAssemblerTester<int32_t> m; 2850 Int32BinopTester bt(&m); 2851 bt.AddReturn( 2852 m.Word32Equal(m.Int32Constant(0), m.Word32Or(bt.param0, bt.param1))); 2853 FOR_UINT32_INPUTS(i) { 2854 FOR_UINT32_INPUTS(j) { 2855 int32_t expected = (*i | *j) == 0; 2856 CHECK_EQ(expected, bt.call(*i, *j)); 2857 } 2858 } 2859 } 2860 { 2861 FOR_UINT32_INPUTS(i) { 2862 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 2863 m.Return(m.Word32Equal(m.Word32Or(m.Int32Constant(*i), m.Parameter(0)), 2864 m.Int32Constant(0))); 2865 FOR_UINT32_INPUTS(j) { 2866 uint32_t expected = (*i | *j) == 0; 2867 CHECK_EQ(expected, m.Call(*j)); 2868 } 2869 } 2870 } 2871 { 2872 FOR_UINT32_INPUTS(i) { 2873 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 2874 m.Return(m.Word32Equal(m.Word32Or(m.Parameter(0), m.Int32Constant(*i)), 2875 m.Int32Constant(0))); 2876 FOR_UINT32_INPUTS(j) { 2877 uint32_t expected = (*j | *i) == 0; 2878 CHECK_EQ(expected, m.Call(*j)); 2879 } 2880 } 2881 } 2882 } 2883 2884 2885 TEST(RunWord32XorP) { 2886 { 2887 FOR_UINT32_INPUTS(i) { 2888 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 2889 m.Return(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0))); 2890 FOR_UINT32_INPUTS(j) { 2891 uint32_t expected = *i ^ *j; 2892 CHECK_EQ(expected, m.Call(*j)); 2893 } 2894 } 2895 } 2896 { 2897 RawMachineAssemblerTester<int32_t> m; 2898 Uint32BinopTester bt(&m); 2899 bt.AddReturn(m.Word32Xor(bt.param0, bt.param1)); 2900 FOR_UINT32_INPUTS(i) { 2901 FOR_UINT32_INPUTS(j) { 2902 uint32_t expected = *i ^ *j; 2903 CHECK_EQ(expected, bt.call(*i, *j)); 2904 } 2905 } 2906 } 2907 { 2908 RawMachineAssemblerTester<int32_t> m; 2909 Int32BinopTester bt(&m); 2910 bt.AddReturn(m.Word32Xor(bt.param0, m.Word32Not(bt.param1))); 2911 FOR_INT32_INPUTS(i) { 2912 FOR_INT32_INPUTS(j) { 2913 int32_t expected = *i ^ ~(*j); 2914 CHECK_EQ(expected, bt.call(*i, *j)); 2915 } 2916 } 2917 } 2918 { 2919 RawMachineAssemblerTester<int32_t> m; 2920 Int32BinopTester bt(&m); 2921 bt.AddReturn(m.Word32Xor(m.Word32Not(bt.param0), bt.param1)); 2922 FOR_INT32_INPUTS(i) { 2923 FOR_INT32_INPUTS(j) { 2924 int32_t expected = ~(*i) ^ *j; 2925 CHECK_EQ(expected, bt.call(*i, *j)); 2926 } 2927 } 2928 } 2929 { 2930 FOR_UINT32_INPUTS(i) { 2931 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 2932 m.Return(m.Word32Xor(m.Int32Constant(*i), m.Word32Not(m.Parameter(0)))); 2933 FOR_UINT32_INPUTS(j) { 2934 uint32_t expected = *i ^ ~(*j); 2935 CHECK_EQ(expected, m.Call(*j)); 2936 } 2937 } 2938 } 2939 } 2940 2941 2942 TEST(RunWord32XorInBranch) { 2943 static const uint32_t constant = 987654321; 2944 { 2945 RawMachineAssemblerTester<int32_t> m; 2946 Uint32BinopTester bt(&m); 2947 RawMachineLabel blocka, blockb; 2948 m.Branch( 2949 m.Word32Equal(m.Word32Xor(bt.param0, bt.param1), m.Int32Constant(0)), 2950 &blocka, &blockb); 2951 m.Bind(&blocka); 2952 bt.AddReturn(m.Int32Constant(constant)); 2953 m.Bind(&blockb); 2954 bt.AddReturn(m.Int32Constant(0 - constant)); 2955 FOR_UINT32_INPUTS(i) { 2956 FOR_UINT32_INPUTS(j) { 2957 uint32_t expected = (*i ^ *j) == 0 ? constant : 0 - constant; 2958 CHECK_EQ(expected, bt.call(*i, *j)); 2959 } 2960 } 2961 } 2962 { 2963 RawMachineAssemblerTester<int32_t> m; 2964 Uint32BinopTester bt(&m); 2965 RawMachineLabel blocka, blockb; 2966 m.Branch( 2967 m.Word32NotEqual(m.Word32Xor(bt.param0, bt.param1), m.Int32Constant(0)), 2968 &blocka, &blockb); 2969 m.Bind(&blocka); 2970 bt.AddReturn(m.Int32Constant(constant)); 2971 m.Bind(&blockb); 2972 bt.AddReturn(m.Int32Constant(0 - constant)); 2973 FOR_UINT32_INPUTS(i) { 2974 FOR_UINT32_INPUTS(j) { 2975 uint32_t expected = (*i ^ *j) != 0 ? constant : 0 - constant; 2976 CHECK_EQ(expected, bt.call(*i, *j)); 2977 } 2978 } 2979 } 2980 { 2981 FOR_UINT32_INPUTS(i) { 2982 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 2983 RawMachineLabel blocka, blockb; 2984 m.Branch(m.Word32Equal(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0)), 2985 m.Int32Constant(0)), 2986 &blocka, &blockb); 2987 m.Bind(&blocka); 2988 m.Return(m.Int32Constant(constant)); 2989 m.Bind(&blockb); 2990 m.Return(m.Int32Constant(0 - constant)); 2991 FOR_UINT32_INPUTS(j) { 2992 uint32_t expected = (*i ^ *j) == 0 ? constant : 0 - constant; 2993 CHECK_EQ(expected, m.Call(*j)); 2994 } 2995 } 2996 } 2997 { 2998 FOR_UINT32_INPUTS(i) { 2999 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 3000 RawMachineLabel blocka, blockb; 3001 m.Branch( 3002 m.Word32NotEqual(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0)), 3003 m.Int32Constant(0)), 3004 &blocka, &blockb); 3005 m.Bind(&blocka); 3006 m.Return(m.Int32Constant(constant)); 3007 m.Bind(&blockb); 3008 m.Return(m.Int32Constant(0 - constant)); 3009 FOR_UINT32_INPUTS(j) { 3010 uint32_t expected = (*i ^ *j) != 0 ? constant : 0 - constant; 3011 CHECK_EQ(expected, m.Call(*j)); 3012 } 3013 } 3014 } 3015 { 3016 RawMachineAssemblerTester<void> m; 3017 const Operator* shops[] = {m.machine()->Word32Sar(), 3018 m.machine()->Word32Shl(), 3019 m.machine()->Word32Shr()}; 3020 for (size_t n = 0; n < arraysize(shops); n++) { 3021 RawMachineAssemblerTester<int32_t> m( 3022 MachineType::Uint32(), MachineType::Int32(), MachineType::Uint32()); 3023 RawMachineLabel blocka, blockb; 3024 m.Branch(m.Word32Equal(m.Word32Xor(m.Parameter(0), 3025 m.AddNode(shops[n], m.Parameter(1), 3026 m.Parameter(2))), 3027 m.Int32Constant(0)), 3028 &blocka, &blockb); 3029 m.Bind(&blocka); 3030 m.Return(m.Int32Constant(constant)); 3031 m.Bind(&blockb); 3032 m.Return(m.Int32Constant(0 - constant)); 3033 FOR_UINT32_INPUTS(i) { 3034 FOR_INT32_INPUTS(j) { 3035 FOR_UINT32_SHIFTS(shift) { 3036 int32_t right; 3037 switch (shops[n]->opcode()) { 3038 default: 3039 UNREACHABLE(); 3040 case IrOpcode::kWord32Sar: 3041 right = *j >> shift; 3042 break; 3043 case IrOpcode::kWord32Shl: 3044 right = *j << shift; 3045 break; 3046 case IrOpcode::kWord32Shr: 3047 right = static_cast<uint32_t>(*j) >> shift; 3048 break; 3049 } 3050 int32_t expected = ((*i ^ right) == 0) ? constant : 0 - constant; 3051 CHECK_EQ(expected, m.Call(*i, *j, shift)); 3052 } 3053 } 3054 } 3055 } 3056 } 3057 } 3058 3059 3060 TEST(RunWord32ShlP) { 3061 { 3062 FOR_UINT32_SHIFTS(shift) { 3063 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 3064 m.Return(m.Word32Shl(m.Parameter(0), m.Int32Constant(shift))); 3065 FOR_UINT32_INPUTS(j) { 3066 uint32_t expected = *j << shift; 3067 CHECK_EQ(expected, m.Call(*j)); 3068 } 3069 } 3070 } 3071 { 3072 RawMachineAssemblerTester<int32_t> m; 3073 Uint32BinopTester bt(&m); 3074 bt.AddReturn(m.Word32Shl(bt.param0, bt.param1)); 3075 FOR_UINT32_INPUTS(i) { 3076 FOR_UINT32_SHIFTS(shift) { 3077 uint32_t expected = *i << shift; 3078 CHECK_EQ(expected, bt.call(*i, shift)); 3079 } 3080 } 3081 } 3082 } 3083 3084 3085 TEST(RunWord32ShlInComparison) { 3086 { 3087 RawMachineAssemblerTester<int32_t> m; 3088 Uint32BinopTester bt(&m); 3089 bt.AddReturn( 3090 m.Word32Equal(m.Word32Shl(bt.param0, bt.param1), m.Int32Constant(0))); 3091 FOR_UINT32_INPUTS(i) { 3092 FOR_UINT32_SHIFTS(shift) { 3093 uint32_t expected = 0 == (*i << shift); 3094 CHECK_EQ(expected, bt.call(*i, shift)); 3095 } 3096 } 3097 } 3098 { 3099 RawMachineAssemblerTester<int32_t> m; 3100 Uint32BinopTester bt(&m); 3101 bt.AddReturn( 3102 m.Word32Equal(m.Int32Constant(0), m.Word32Shl(bt.param0, bt.param1))); 3103 FOR_UINT32_INPUTS(i) { 3104 FOR_UINT32_SHIFTS(shift) { 3105 uint32_t expected = 0 == (*i << shift); 3106 CHECK_EQ(expected, bt.call(*i, shift)); 3107 } 3108 } 3109 } 3110 { 3111 FOR_UINT32_SHIFTS(shift) { 3112 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 3113 m.Return( 3114 m.Word32Equal(m.Int32Constant(0), 3115 m.Word32Shl(m.Parameter(0), m.Int32Constant(shift)))); 3116 FOR_UINT32_INPUTS(i) { 3117 uint32_t expected = 0 == (*i << shift); 3118 CHECK_EQ(expected, m.Call(*i)); 3119 } 3120 } 3121 } 3122 { 3123 FOR_UINT32_SHIFTS(shift) { 3124 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 3125 m.Return( 3126 m.Word32Equal(m.Word32Shl(m.Parameter(0), m.Int32Constant(shift)), 3127 m.Int32Constant(0))); 3128 FOR_UINT32_INPUTS(i) { 3129 uint32_t expected = 0 == (*i << shift); 3130 CHECK_EQ(expected, m.Call(*i)); 3131 } 3132 } 3133 } 3134 } 3135 3136 3137 TEST(RunWord32ShrP) { 3138 { 3139 FOR_UINT32_SHIFTS(shift) { 3140 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 3141 m.Return(m.Word32Shr(m.Parameter(0), m.Int32Constant(shift))); 3142 FOR_UINT32_INPUTS(j) { 3143 uint32_t expected = *j >> shift; 3144 CHECK_EQ(expected, m.Call(*j)); 3145 } 3146 } 3147 } 3148 { 3149 RawMachineAssemblerTester<int32_t> m; 3150 Uint32BinopTester bt(&m); 3151 bt.AddReturn(m.Word32Shr(bt.param0, bt.param1)); 3152 FOR_UINT32_INPUTS(i) { 3153 FOR_UINT32_SHIFTS(shift) { 3154 uint32_t expected = *i >> shift; 3155 CHECK_EQ(expected, bt.call(*i, shift)); 3156 } 3157 } 3158 CHECK_EQ(0x00010000u, bt.call(0x80000000, 15)); 3159 } 3160 } 3161 3162 3163 TEST(RunWord32ShrInComparison) { 3164 { 3165 RawMachineAssemblerTester<int32_t> m; 3166 Uint32BinopTester bt(&m); 3167 bt.AddReturn( 3168 m.Word32Equal(m.Word32Shr(bt.param0, bt.param1), m.Int32Constant(0))); 3169 FOR_UINT32_INPUTS(i) { 3170 FOR_UINT32_SHIFTS(shift) { 3171 uint32_t expected = 0 == (*i >> shift); 3172 CHECK_EQ(expected, bt.call(*i, shift)); 3173 } 3174 } 3175 } 3176 { 3177 RawMachineAssemblerTester<int32_t> m; 3178 Uint32BinopTester bt(&m); 3179 bt.AddReturn( 3180 m.Word32Equal(m.Int32Constant(0), m.Word32Shr(bt.param0, bt.param1))); 3181 FOR_UINT32_INPUTS(i) { 3182 FOR_UINT32_SHIFTS(shift) { 3183 uint32_t expected = 0 == (*i >> shift); 3184 CHECK_EQ(expected, bt.call(*i, shift)); 3185 } 3186 } 3187 } 3188 { 3189 FOR_UINT32_SHIFTS(shift) { 3190 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 3191 m.Return( 3192 m.Word32Equal(m.Int32Constant(0), 3193 m.Word32Shr(m.Parameter(0), m.Int32Constant(shift)))); 3194 FOR_UINT32_INPUTS(i) { 3195 uint32_t expected = 0 == (*i >> shift); 3196 CHECK_EQ(expected, m.Call(*i)); 3197 } 3198 } 3199 } 3200 { 3201 FOR_UINT32_SHIFTS(shift) { 3202 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 3203 m.Return( 3204 m.Word32Equal(m.Word32Shr(m.Parameter(0), m.Int32Constant(shift)), 3205 m.Int32Constant(0))); 3206 FOR_UINT32_INPUTS(i) { 3207 uint32_t expected = 0 == (*i >> shift); 3208 CHECK_EQ(expected, m.Call(*i)); 3209 } 3210 } 3211 } 3212 } 3213 3214 3215 TEST(RunWord32SarP) { 3216 { 3217 FOR_INT32_SHIFTS(shift) { 3218 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 3219 m.Return(m.Word32Sar(m.Parameter(0), m.Int32Constant(shift))); 3220 FOR_INT32_INPUTS(j) { 3221 int32_t expected = *j >> shift; 3222 CHECK_EQ(expected, m.Call(*j)); 3223 } 3224 } 3225 } 3226 { 3227 RawMachineAssemblerTester<int32_t> m; 3228 Int32BinopTester bt(&m); 3229 bt.AddReturn(m.Word32Sar(bt.param0, bt.param1)); 3230 FOR_INT32_INPUTS(i) { 3231 FOR_INT32_SHIFTS(shift) { 3232 int32_t expected = *i >> shift; 3233 CHECK_EQ(expected, bt.call(*i, shift)); 3234 } 3235 } 3236 CHECK_EQ(bit_cast<int32_t>(0xFFFF0000), bt.call(0x80000000, 15)); 3237 } 3238 } 3239 3240 3241 TEST(RunWord32SarInComparison) { 3242 { 3243 RawMachineAssemblerTester<int32_t> m; 3244 Int32BinopTester bt(&m); 3245 bt.AddReturn( 3246 m.Word32Equal(m.Word32Sar(bt.param0, bt.param1), m.Int32Constant(0))); 3247 FOR_INT32_INPUTS(i) { 3248 FOR_INT32_SHIFTS(shift) { 3249 int32_t expected = 0 == (*i >> shift); 3250 CHECK_EQ(expected, bt.call(*i, shift)); 3251 } 3252 } 3253 } 3254 { 3255 RawMachineAssemblerTester<int32_t> m; 3256 Int32BinopTester bt(&m); 3257 bt.AddReturn( 3258 m.Word32Equal(m.Int32Constant(0), m.Word32Sar(bt.param0, bt.param1))); 3259 FOR_INT32_INPUTS(i) { 3260 FOR_INT32_SHIFTS(shift) { 3261 int32_t expected = 0 == (*i >> shift); 3262 CHECK_EQ(expected, bt.call(*i, shift)); 3263 } 3264 } 3265 } 3266 { 3267 FOR_INT32_SHIFTS(shift) { 3268 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 3269 m.Return( 3270 m.Word32Equal(m.Int32Constant(0), 3271 m.Word32Sar(m.Parameter(0), m.Int32Constant(shift)))); 3272 FOR_INT32_INPUTS(i) { 3273 int32_t expected = 0 == (*i >> shift); 3274 CHECK_EQ(expected, m.Call(*i)); 3275 } 3276 } 3277 } 3278 { 3279 FOR_INT32_SHIFTS(shift) { 3280 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 3281 m.Return( 3282 m.Word32Equal(m.Word32Sar(m.Parameter(0), m.Int32Constant(shift)), 3283 m.Int32Constant(0))); 3284 FOR_INT32_INPUTS(i) { 3285 int32_t expected = 0 == (*i >> shift); 3286 CHECK_EQ(expected, m.Call(*i)); 3287 } 3288 } 3289 } 3290 } 3291 3292 3293 TEST(RunWord32RorP) { 3294 { 3295 FOR_UINT32_SHIFTS(shift) { 3296 RawMachineAssemblerTester<int32_t> m(MachineType::Uint32()); 3297 m.Return(m.Word32Ror(m.Parameter(0), m.Int32Constant(shift))); 3298 FOR_UINT32_INPUTS(j) { 3299 int32_t expected = bits::RotateRight32(*j, shift); 3300 CHECK_EQ(expected, m.Call(*j)); 3301 } 3302 } 3303 } 3304 { 3305 RawMachineAssemblerTester<int32_t> m; 3306 Uint32BinopTester bt(&m); 3307 bt.AddReturn(m.Word32Ror(bt.param0, bt.param1)); 3308 FOR_UINT32_INPUTS(i) { 3309 FOR_UINT32_SHIFTS(shift) { 3310 uint32_t expected = bits::RotateRight32(*i, shift); 3311 CHECK_EQ(expected, bt.call(*i, shift)); 3312 } 3313 } 3314 } 3315 } 3316 3317 3318 TEST(RunWord32RorInComparison) { 3319 { 3320 RawMachineAssemblerTester<int32_t> m; 3321 Uint32BinopTester bt(&m); 3322 bt.AddReturn( 3323 m.Word32Equal(m.Word32Ror(bt.param0, bt.param1), m.Int32Constant(0))); 3324 FOR_UINT32_INPUTS(i) { 3325 FOR_UINT32_SHIFTS(shift) { 3326 uint32_t expected = 0 == bits::RotateRight32(*i, shift); 3327 CHECK_EQ(expected, bt.call(*i, shift)); 3328 } 3329 } 3330 } 3331 { 3332 RawMachineAssemblerTester<int32_t> m; 3333 Uint32BinopTester bt(&m); 3334 bt.AddReturn( 3335 m.Word32Equal(m.Int32Constant(0), m.Word32Ror(bt.param0, bt.param1))); 3336 FOR_UINT32_INPUTS(i) { 3337 FOR_UINT32_SHIFTS(shift) { 3338 uint32_t expected = 0 == bits::RotateRight32(*i, shift); 3339 CHECK_EQ(expected, bt.call(*i, shift)); 3340 } 3341 } 3342 } 3343 { 3344 FOR_UINT32_SHIFTS(shift) { 3345 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 3346 m.Return( 3347 m.Word32Equal(m.Int32Constant(0), 3348 m.Word32Ror(m.Parameter(0), m.Int32Constant(shift)))); 3349 FOR_UINT32_INPUTS(i) { 3350 uint32_t expected = 0 == bits::RotateRight32(*i, shift); 3351 CHECK_EQ(expected, m.Call(*i)); 3352 } 3353 } 3354 } 3355 { 3356 FOR_UINT32_SHIFTS(shift) { 3357 RawMachineAssemblerTester<uint32_t> m(MachineType::Uint32()); 3358 m.Return( 3359 m.Word32Equal(m.Word32Ror(m.Parameter(0), m.Int32Constant(shift)), 3360 m.Int32Constant(0))); 3361 FOR_UINT32_INPUTS(i) { 3362 uint32_t expected = 0 == bits::RotateRight32(*i, shift); 3363 CHECK_EQ(expected, m.Call(*i)); 3364 } 3365 } 3366 } 3367 } 3368 3369 3370 TEST(RunWord32NotP) { 3371 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 3372 m.Return(m.Word32Not(m.Parameter(0))); 3373 FOR_INT32_INPUTS(i) { 3374 int expected = ~(*i); 3375 CHECK_EQ(expected, m.Call(*i)); 3376 } 3377 } 3378 3379 3380 TEST(RunInt32NegP) { 3381 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 3382 m.Return(m.Int32Neg(m.Parameter(0))); 3383 FOR_INT32_INPUTS(i) { 3384 int expected = -*i; 3385 CHECK_EQ(expected, m.Call(*i)); 3386 } 3387 } 3388 3389 3390 TEST(RunWord32EqualAndWord32SarP) { 3391 { 3392 RawMachineAssemblerTester<int32_t> m( 3393 MachineType::Int32(), MachineType::Int32(), MachineType::Uint32()); 3394 m.Return(m.Word32Equal(m.Parameter(0), 3395 m.Word32Sar(m.Parameter(1), m.Parameter(2)))); 3396 FOR_INT32_INPUTS(i) { 3397 FOR_INT32_INPUTS(j) { 3398 FOR_UINT32_SHIFTS(shift) { 3399 int32_t expected = (*i == (*j >> shift)); 3400 CHECK_EQ(expected, m.Call(*i, *j, shift)); 3401 } 3402 } 3403 } 3404 } 3405 { 3406 RawMachineAssemblerTester<int32_t> m( 3407 MachineType::Int32(), MachineType::Uint32(), MachineType::Int32()); 3408 m.Return(m.Word32Equal(m.Word32Sar(m.Parameter(0), m.Parameter(1)), 3409 m.Parameter(2))); 3410 FOR_INT32_INPUTS(i) { 3411 FOR_UINT32_SHIFTS(shift) { 3412 FOR_INT32_INPUTS(k) { 3413 int32_t expected = ((*i >> shift) == *k); 3414 CHECK_EQ(expected, m.Call(*i, shift, *k)); 3415 } 3416 } 3417 } 3418 } 3419 } 3420 3421 3422 TEST(RunWord32EqualAndWord32ShlP) { 3423 { 3424 RawMachineAssemblerTester<int32_t> m( 3425 MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32()); 3426 m.Return(m.Word32Equal(m.Parameter(0), 3427 m.Word32Shl(m.Parameter(1), m.Parameter(2)))); 3428 FOR_UINT32_INPUTS(i) { 3429 FOR_UINT32_INPUTS(j) { 3430 FOR_UINT32_SHIFTS(shift) { 3431 int32_t expected = (*i == (*j << shift)); 3432 CHECK_EQ(expected, m.Call(*i, *j, shift)); 3433 } 3434 } 3435 } 3436 } 3437 { 3438 RawMachineAssemblerTester<int32_t> m( 3439 MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32()); 3440 m.Return(m.Word32Equal(m.Word32Shl(m.Parameter(0), m.Parameter(1)), 3441 m.Parameter(2))); 3442 FOR_UINT32_INPUTS(i) { 3443 FOR_UINT32_SHIFTS(shift) { 3444 FOR_UINT32_INPUTS(k) { 3445 int32_t expected = ((*i << shift) == *k); 3446 CHECK_EQ(expected, m.Call(*i, shift, *k)); 3447 } 3448 } 3449 } 3450 } 3451 } 3452 3453 3454 TEST(RunWord32EqualAndWord32ShrP) { 3455 { 3456 RawMachineAssemblerTester<int32_t> m( 3457 MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32()); 3458 m.Return(m.Word32Equal(m.Parameter(0), 3459 m.Word32Shr(m.Parameter(1), m.Parameter(2)))); 3460 FOR_UINT32_INPUTS(i) { 3461 FOR_UINT32_INPUTS(j) { 3462 FOR_UINT32_SHIFTS(shift) { 3463 int32_t expected = (*i == (*j >> shift)); 3464 CHECK_EQ(expected, m.Call(*i, *j, shift)); 3465 } 3466 } 3467 } 3468 } 3469 { 3470 RawMachineAssemblerTester<int32_t> m( 3471 MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32()); 3472 m.Return(m.Word32Equal(m.Word32Shr(m.Parameter(0), m.Parameter(1)), 3473 m.Parameter(2))); 3474 FOR_UINT32_INPUTS(i) { 3475 FOR_UINT32_SHIFTS(shift) { 3476 FOR_UINT32_INPUTS(k) { 3477 int32_t expected = ((*i >> shift) == *k); 3478 CHECK_EQ(expected, m.Call(*i, shift, *k)); 3479 } 3480 } 3481 } 3482 } 3483 } 3484 3485 3486 TEST(RunDeadNodes) { 3487 for (int i = 0; true; i++) { 3488 RawMachineAssemblerTester<int32_t> m(i == 5 ? MachineType::Int32() 3489 : MachineType::None()); 3490 int constant = 0x55 + i; 3491 switch (i) { 3492 case 0: 3493 m.Int32Constant(44); 3494 break; 3495 case 1: 3496 m.StringConstant("unused"); 3497 break; 3498 case 2: 3499 m.NumberConstant(11.1); 3500 break; 3501 case 3: 3502 m.PointerConstant(&constant); 3503 break; 3504 case 4: 3505 m.LoadFromPointer(&constant, MachineType::Int32()); 3506 break; 3507 case 5: 3508 m.Parameter(0); 3509 break; 3510 default: 3511 return; 3512 } 3513 m.Return(m.Int32Constant(constant)); 3514 if (i != 5) { 3515 CHECK_EQ(constant, m.Call()); 3516 } else { 3517 CHECK_EQ(constant, m.Call(0)); 3518 } 3519 } 3520 } 3521 3522 3523 TEST(RunDeadInt32Binops) { 3524 RawMachineAssemblerTester<int32_t> m; 3525 3526 const Operator* kOps[] = { 3527 m.machine()->Word32And(), m.machine()->Word32Or(), 3528 m.machine()->Word32Xor(), m.machine()->Word32Shl(), 3529 m.machine()->Word32Shr(), m.machine()->Word32Sar(), 3530 m.machine()->Word32Ror(), m.machine()->Word32Equal(), 3531 m.machine()->Int32Add(), m.machine()->Int32Sub(), 3532 m.machine()->Int32Mul(), m.machine()->Int32MulHigh(), 3533 m.machine()->Int32Div(), m.machine()->Uint32Div(), 3534 m.machine()->Int32Mod(), m.machine()->Uint32Mod(), 3535 m.machine()->Uint32MulHigh(), m.machine()->Int32LessThan(), 3536 m.machine()->Int32LessThanOrEqual(), m.machine()->Uint32LessThan(), 3537 m.machine()->Uint32LessThanOrEqual()}; 3538 3539 for (size_t i = 0; i < arraysize(kOps); ++i) { 3540 RawMachineAssemblerTester<int32_t> m(MachineType::Int32(), 3541 MachineType::Int32()); 3542 int32_t constant = static_cast<int32_t>(0x55555 + i); 3543 m.AddNode(kOps[i], m.Parameter(0), m.Parameter(1)); 3544 m.Return(m.Int32Constant(constant)); 3545 3546 CHECK_EQ(constant, m.Call(1, 1)); 3547 } 3548 } 3549 3550 3551 TEST(RunFloat32Add) { 3552 BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(), 3553 MachineType::Float32()); 3554 m.Return(m.Float32Add(m.Parameter(0), m.Parameter(1))); 3555 3556 FOR_FLOAT32_INPUTS(i) { 3557 FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(*i + *j, m.Call(*i, *j)); } 3558 } 3559 } 3560 3561 3562 TEST(RunFloat32Sub) { 3563 BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(), 3564 MachineType::Float32()); 3565 m.Return(m.Float32Sub(m.Parameter(0), m.Parameter(1))); 3566 3567 FOR_FLOAT32_INPUTS(i) { 3568 FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(*i - *j, m.Call(*i, *j)); } 3569 } 3570 } 3571 3572 TEST(RunFloat32Neg) { 3573 BufferedRawMachineAssemblerTester<float> m(MachineType::Float32()); 3574 if (!m.machine()->Float32Neg().IsSupported()) return; 3575 m.Return(m.AddNode(m.machine()->Float32Neg().op(), m.Parameter(0))); 3576 FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(-0.0f - *i, m.Call(*i)); } 3577 } 3578 3579 TEST(RunFloat32Mul) { 3580 BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(), 3581 MachineType::Float32()); 3582 m.Return(m.Float32Mul(m.Parameter(0), m.Parameter(1))); 3583 3584 FOR_FLOAT32_INPUTS(i) { 3585 FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(*i * *j, m.Call(*i, *j)); } 3586 } 3587 } 3588 3589 3590 TEST(RunFloat32Div) { 3591 BufferedRawMachineAssemblerTester<float> m(MachineType::Float32(), 3592 MachineType::Float32()); 3593 m.Return(m.Float32Div(m.Parameter(0), m.Parameter(1))); 3594 3595 FOR_FLOAT32_INPUTS(i) { 3596 FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(*i / *j, m.Call(*i, *j)); } 3597 } 3598 } 3599 3600 3601 TEST(RunFloat64Add) { 3602 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(), 3603 MachineType::Float64()); 3604 m.Return(m.Float64Add(m.Parameter(0), m.Parameter(1))); 3605 3606 FOR_FLOAT64_INPUTS(i) { 3607 FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(*i + *j, m.Call(*i, *j)); } 3608 } 3609 } 3610 3611 3612 TEST(RunFloat64Sub) { 3613 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(), 3614 MachineType::Float64()); 3615 m.Return(m.Float64Sub(m.Parameter(0), m.Parameter(1))); 3616 3617 FOR_FLOAT64_INPUTS(i) { 3618 FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(*i - *j, m.Call(*i, *j)); } 3619 } 3620 } 3621 3622 TEST(RunFloat64Neg) { 3623 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 3624 if (!m.machine()->Float64Neg().IsSupported()) return; 3625 m.Return(m.AddNode(m.machine()->Float64Neg().op(), m.Parameter(0))); 3626 FOR_FLOAT64_INPUTS(i) { CHECK_FLOAT_EQ(-0.0 - *i, m.Call(*i)); } 3627 } 3628 3629 TEST(RunFloat64Mul) { 3630 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(), 3631 MachineType::Float64()); 3632 m.Return(m.Float64Mul(m.Parameter(0), m.Parameter(1))); 3633 3634 FOR_FLOAT64_INPUTS(i) { 3635 FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(*i * *j, m.Call(*i, *j)); } 3636 } 3637 } 3638 3639 3640 TEST(RunFloat64Div) { 3641 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(), 3642 MachineType::Float64()); 3643 m.Return(m.Float64Div(m.Parameter(0), m.Parameter(1))); 3644 3645 FOR_FLOAT64_INPUTS(i) { 3646 FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(*i / *j, m.Call(*i, *j)); } 3647 } 3648 } 3649 3650 3651 TEST(RunFloat64Mod) { 3652 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(), 3653 MachineType::Float64()); 3654 m.Return(m.Float64Mod(m.Parameter(0), m.Parameter(1))); 3655 3656 FOR_FLOAT64_INPUTS(i) { 3657 FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(modulo(*i, *j), m.Call(*i, *j)); } 3658 } 3659 } 3660 3661 3662 TEST(RunDeadFloat32Binops) { 3663 RawMachineAssemblerTester<int32_t> m; 3664 3665 const Operator* ops[] = {m.machine()->Float32Add(), m.machine()->Float32Sub(), 3666 m.machine()->Float32Mul(), m.machine()->Float32Div(), 3667 NULL}; 3668 3669 for (int i = 0; ops[i] != NULL; i++) { 3670 RawMachineAssemblerTester<int32_t> m; 3671 int constant = 0x53355 + i; 3672 m.AddNode(ops[i], m.Float32Constant(0.1f), m.Float32Constant(1.11f)); 3673 m.Return(m.Int32Constant(constant)); 3674 CHECK_EQ(constant, m.Call()); 3675 } 3676 } 3677 3678 3679 TEST(RunDeadFloat64Binops) { 3680 RawMachineAssemblerTester<int32_t> m; 3681 3682 const Operator* ops[] = {m.machine()->Float64Add(), m.machine()->Float64Sub(), 3683 m.machine()->Float64Mul(), m.machine()->Float64Div(), 3684 m.machine()->Float64Mod(), NULL}; 3685 3686 for (int i = 0; ops[i] != NULL; i++) { 3687 RawMachineAssemblerTester<int32_t> m; 3688 int constant = 0x53355 + i; 3689 m.AddNode(ops[i], m.Float64Constant(0.1), m.Float64Constant(1.11)); 3690 m.Return(m.Int32Constant(constant)); 3691 CHECK_EQ(constant, m.Call()); 3692 } 3693 } 3694 3695 3696 TEST(RunFloat32AddP) { 3697 RawMachineAssemblerTester<int32_t> m; 3698 Float32BinopTester bt(&m); 3699 3700 bt.AddReturn(m.Float32Add(bt.param0, bt.param1)); 3701 3702 FOR_FLOAT32_INPUTS(pl) { 3703 FOR_FLOAT32_INPUTS(pr) { CHECK_FLOAT_EQ(*pl + *pr, bt.call(*pl, *pr)); } 3704 } 3705 } 3706 3707 3708 TEST(RunFloat64AddP) { 3709 RawMachineAssemblerTester<int32_t> m; 3710 Float64BinopTester bt(&m); 3711 3712 bt.AddReturn(m.Float64Add(bt.param0, bt.param1)); 3713 3714 FOR_FLOAT64_INPUTS(pl) { 3715 FOR_FLOAT64_INPUTS(pr) { CHECK_DOUBLE_EQ(*pl + *pr, bt.call(*pl, *pr)); } 3716 } 3717 } 3718 3719 3720 TEST(RunFloa32MaxP) { 3721 RawMachineAssemblerTester<int32_t> m; 3722 Float32BinopTester bt(&m); 3723 if (!m.machine()->Float32Max().IsSupported()) return; 3724 3725 bt.AddReturn(m.Float32Max(bt.param0, bt.param1)); 3726 3727 FOR_FLOAT32_INPUTS(pl) { 3728 FOR_FLOAT32_INPUTS(pr) { 3729 CHECK_DOUBLE_EQ(*pl > *pr ? *pl : *pr, bt.call(*pl, *pr)); 3730 } 3731 } 3732 } 3733 3734 3735 TEST(RunFloat64MaxP) { 3736 RawMachineAssemblerTester<int32_t> m; 3737 Float64BinopTester bt(&m); 3738 if (!m.machine()->Float64Max().IsSupported()) return; 3739 3740 bt.AddReturn(m.Float64Max(bt.param0, bt.param1)); 3741 3742 FOR_FLOAT64_INPUTS(pl) { 3743 FOR_FLOAT64_INPUTS(pr) { 3744 CHECK_DOUBLE_EQ(*pl > *pr ? *pl : *pr, bt.call(*pl, *pr)); 3745 } 3746 } 3747 } 3748 3749 3750 TEST(RunFloat32MinP) { 3751 RawMachineAssemblerTester<int32_t> m; 3752 Float32BinopTester bt(&m); 3753 if (!m.machine()->Float32Min().IsSupported()) return; 3754 3755 bt.AddReturn(m.Float32Min(bt.param0, bt.param1)); 3756 3757 FOR_FLOAT32_INPUTS(pl) { 3758 FOR_FLOAT32_INPUTS(pr) { 3759 CHECK_DOUBLE_EQ(*pl < *pr ? *pl : *pr, bt.call(*pl, *pr)); 3760 } 3761 } 3762 } 3763 3764 3765 TEST(RunFloat64MinP) { 3766 RawMachineAssemblerTester<int32_t> m; 3767 Float64BinopTester bt(&m); 3768 if (!m.machine()->Float64Min().IsSupported()) return; 3769 3770 bt.AddReturn(m.Float64Min(bt.param0, bt.param1)); 3771 3772 FOR_FLOAT64_INPUTS(pl) { 3773 FOR_FLOAT64_INPUTS(pr) { 3774 CHECK_DOUBLE_EQ(*pl < *pr ? *pl : *pr, bt.call(*pl, *pr)); 3775 } 3776 } 3777 } 3778 3779 3780 TEST(RunFloat32SubP) { 3781 RawMachineAssemblerTester<int32_t> m; 3782 Float32BinopTester bt(&m); 3783 3784 bt.AddReturn(m.Float32Sub(bt.param0, bt.param1)); 3785 3786 FOR_FLOAT32_INPUTS(pl) { 3787 FOR_FLOAT32_INPUTS(pr) { CHECK_FLOAT_EQ(*pl - *pr, bt.call(*pl, *pr)); } 3788 } 3789 } 3790 3791 3792 TEST(RunFloat32SubImm1) { 3793 FOR_FLOAT32_INPUTS(i) { 3794 BufferedRawMachineAssemblerTester<float> m(MachineType::Float32()); 3795 m.Return(m.Float32Sub(m.Float32Constant(*i), m.Parameter(0))); 3796 3797 FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(*i - *j, m.Call(*j)); } 3798 } 3799 } 3800 3801 3802 TEST(RunFloat32SubImm2) { 3803 FOR_FLOAT32_INPUTS(i) { 3804 BufferedRawMachineAssemblerTester<float> m(MachineType::Float32()); 3805 m.Return(m.Float32Sub(m.Parameter(0), m.Float32Constant(*i))); 3806 3807 FOR_FLOAT32_INPUTS(j) { CHECK_FLOAT_EQ(*j - *i, m.Call(*j)); } 3808 } 3809 } 3810 3811 3812 TEST(RunFloat64SubImm1) { 3813 FOR_FLOAT64_INPUTS(i) { 3814 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 3815 m.Return(m.Float64Sub(m.Float64Constant(*i), m.Parameter(0))); 3816 3817 FOR_FLOAT64_INPUTS(j) { CHECK_FLOAT_EQ(*i - *j, m.Call(*j)); } 3818 } 3819 } 3820 3821 3822 TEST(RunFloat64SubImm2) { 3823 FOR_FLOAT64_INPUTS(i) { 3824 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 3825 m.Return(m.Float64Sub(m.Parameter(0), m.Float64Constant(*i))); 3826 3827 FOR_FLOAT64_INPUTS(j) { CHECK_FLOAT_EQ(*j - *i, m.Call(*j)); } 3828 } 3829 } 3830 3831 3832 TEST(RunFloat64SubP) { 3833 RawMachineAssemblerTester<int32_t> m; 3834 Float64BinopTester bt(&m); 3835 3836 bt.AddReturn(m.Float64Sub(bt.param0, bt.param1)); 3837 3838 FOR_FLOAT64_INPUTS(pl) { 3839 FOR_FLOAT64_INPUTS(pr) { 3840 double expected = *pl - *pr; 3841 CHECK_DOUBLE_EQ(expected, bt.call(*pl, *pr)); 3842 } 3843 } 3844 } 3845 3846 3847 TEST(RunFloat32MulP) { 3848 RawMachineAssemblerTester<int32_t> m; 3849 Float32BinopTester bt(&m); 3850 3851 bt.AddReturn(m.Float32Mul(bt.param0, bt.param1)); 3852 3853 FOR_FLOAT32_INPUTS(pl) { 3854 FOR_FLOAT32_INPUTS(pr) { CHECK_FLOAT_EQ(*pl * *pr, bt.call(*pl, *pr)); } 3855 } 3856 } 3857 3858 3859 TEST(RunFloat64MulP) { 3860 RawMachineAssemblerTester<int32_t> m; 3861 Float64BinopTester bt(&m); 3862 3863 bt.AddReturn(m.Float64Mul(bt.param0, bt.param1)); 3864 3865 FOR_FLOAT64_INPUTS(pl) { 3866 FOR_FLOAT64_INPUTS(pr) { 3867 double expected = *pl * *pr; 3868 CHECK_DOUBLE_EQ(expected, bt.call(*pl, *pr)); 3869 } 3870 } 3871 } 3872 3873 3874 TEST(RunFloat64MulAndFloat64Add1) { 3875 BufferedRawMachineAssemblerTester<double> m( 3876 MachineType::Float64(), MachineType::Float64(), MachineType::Float64()); 3877 m.Return(m.Float64Add(m.Float64Mul(m.Parameter(0), m.Parameter(1)), 3878 m.Parameter(2))); 3879 3880 FOR_FLOAT64_INPUTS(i) { 3881 FOR_FLOAT64_INPUTS(j) { 3882 FOR_FLOAT64_INPUTS(k) { 3883 CHECK_DOUBLE_EQ((*i * *j) + *k, m.Call(*i, *j, *k)); 3884 } 3885 } 3886 } 3887 } 3888 3889 3890 TEST(RunFloat64MulAndFloat64Add2) { 3891 BufferedRawMachineAssemblerTester<double> m( 3892 MachineType::Float64(), MachineType::Float64(), MachineType::Float64()); 3893 m.Return(m.Float64Add(m.Parameter(0), 3894 m.Float64Mul(m.Parameter(1), m.Parameter(2)))); 3895 3896 FOR_FLOAT64_INPUTS(i) { 3897 FOR_FLOAT64_INPUTS(j) { 3898 FOR_FLOAT64_INPUTS(k) { 3899 CHECK_DOUBLE_EQ(*i + (*j * *k), m.Call(*i, *j, *k)); 3900 } 3901 } 3902 } 3903 } 3904 3905 3906 TEST(RunFloat64MulAndFloat64Sub1) { 3907 BufferedRawMachineAssemblerTester<double> m( 3908 MachineType::Float64(), MachineType::Float64(), MachineType::Float64()); 3909 m.Return(m.Float64Sub(m.Float64Mul(m.Parameter(0), m.Parameter(1)), 3910 m.Parameter(2))); 3911 3912 FOR_FLOAT64_INPUTS(i) { 3913 FOR_FLOAT64_INPUTS(j) { 3914 FOR_FLOAT64_INPUTS(k) { 3915 CHECK_DOUBLE_EQ((*i * *j) - *k, m.Call(*i, *j, *k)); 3916 } 3917 } 3918 } 3919 } 3920 3921 3922 TEST(RunFloat64MulAndFloat64Sub2) { 3923 BufferedRawMachineAssemblerTester<double> m( 3924 MachineType::Float64(), MachineType::Float64(), MachineType::Float64()); 3925 m.Return(m.Float64Sub(m.Parameter(0), 3926 m.Float64Mul(m.Parameter(1), m.Parameter(2)))); 3927 3928 FOR_FLOAT64_INPUTS(i) { 3929 FOR_FLOAT64_INPUTS(j) { 3930 FOR_FLOAT64_INPUTS(k) { 3931 CHECK_DOUBLE_EQ(*i - (*j * *k), m.Call(*i, *j, *k)); 3932 } 3933 } 3934 } 3935 } 3936 3937 3938 TEST(RunFloat64MulImm1) { 3939 FOR_FLOAT64_INPUTS(i) { 3940 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 3941 m.Return(m.Float64Mul(m.Float64Constant(*i), m.Parameter(0))); 3942 3943 FOR_FLOAT64_INPUTS(j) { CHECK_FLOAT_EQ(*i * *j, m.Call(*j)); } 3944 } 3945 } 3946 3947 3948 TEST(RunFloat64MulImm2) { 3949 FOR_FLOAT64_INPUTS(i) { 3950 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 3951 m.Return(m.Float64Mul(m.Parameter(0), m.Float64Constant(*i))); 3952 3953 FOR_FLOAT64_INPUTS(j) { CHECK_FLOAT_EQ(*j * *i, m.Call(*j)); } 3954 } 3955 } 3956 3957 3958 TEST(RunFloat32DivP) { 3959 RawMachineAssemblerTester<int32_t> m; 3960 Float32BinopTester bt(&m); 3961 3962 bt.AddReturn(m.Float32Div(bt.param0, bt.param1)); 3963 3964 FOR_FLOAT32_INPUTS(pl) { 3965 FOR_FLOAT32_INPUTS(pr) { CHECK_FLOAT_EQ(*pl / *pr, bt.call(*pl, *pr)); } 3966 } 3967 } 3968 3969 3970 TEST(RunFloat64DivP) { 3971 RawMachineAssemblerTester<int32_t> m; 3972 Float64BinopTester bt(&m); 3973 3974 bt.AddReturn(m.Float64Div(bt.param0, bt.param1)); 3975 3976 FOR_FLOAT64_INPUTS(pl) { 3977 FOR_FLOAT64_INPUTS(pr) { CHECK_DOUBLE_EQ(*pl / *pr, bt.call(*pl, *pr)); } 3978 } 3979 } 3980 3981 3982 TEST(RunFloat64ModP) { 3983 RawMachineAssemblerTester<int32_t> m; 3984 Float64BinopTester bt(&m); 3985 3986 bt.AddReturn(m.Float64Mod(bt.param0, bt.param1)); 3987 3988 FOR_FLOAT64_INPUTS(i) { 3989 FOR_FLOAT64_INPUTS(j) { CHECK_DOUBLE_EQ(modulo(*i, *j), bt.call(*i, *j)); } 3990 } 3991 } 3992 3993 3994 TEST(RunChangeInt32ToFloat64_A) { 3995 int32_t magic = 0x986234; 3996 BufferedRawMachineAssemblerTester<double> m; 3997 m.Return(m.ChangeInt32ToFloat64(m.Int32Constant(magic))); 3998 CHECK_DOUBLE_EQ(static_cast<double>(magic), m.Call()); 3999 } 4000 4001 4002 TEST(RunChangeInt32ToFloat64_B) { 4003 BufferedRawMachineAssemblerTester<double> m(MachineType::Int32()); 4004 m.Return(m.ChangeInt32ToFloat64(m.Parameter(0))); 4005 4006 FOR_INT32_INPUTS(i) { CHECK_DOUBLE_EQ(static_cast<double>(*i), m.Call(*i)); } 4007 } 4008 4009 4010 TEST(RunChangeUint32ToFloat64) { 4011 BufferedRawMachineAssemblerTester<double> m(MachineType::Uint32()); 4012 m.Return(m.ChangeUint32ToFloat64(m.Parameter(0))); 4013 4014 FOR_UINT32_INPUTS(i) { CHECK_DOUBLE_EQ(static_cast<double>(*i), m.Call(*i)); } 4015 } 4016 4017 4018 TEST(RunTruncateFloat32ToInt32) { 4019 BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Float32()); 4020 m.Return(m.TruncateFloat32ToInt32(m.Parameter(0))); 4021 FOR_FLOAT32_INPUTS(i) { 4022 if (*i <= static_cast<float>(std::numeric_limits<int32_t>::max()) && 4023 *i >= static_cast<float>(std::numeric_limits<int32_t>::min())) { 4024 CHECK_FLOAT_EQ(static_cast<int32_t>(*i), m.Call(*i)); 4025 } 4026 } 4027 } 4028 4029 4030 TEST(RunTruncateFloat32ToUint32) { 4031 BufferedRawMachineAssemblerTester<uint32_t> m(MachineType::Float32()); 4032 m.Return(m.TruncateFloat32ToUint32(m.Parameter(0))); 4033 { 4034 FOR_UINT32_INPUTS(i) { 4035 volatile float input = static_cast<float>(*i); 4036 // This condition on 'input' is required because 4037 // static_cast<float>(std::numeric_limits<uint32_t>::max()) results in a 4038 // value outside uint32 range. 4039 if (input < static_cast<float>(std::numeric_limits<uint32_t>::max())) { 4040 CHECK_EQ(static_cast<uint32_t>(input), m.Call(input)); 4041 } 4042 } 4043 } 4044 { 4045 FOR_FLOAT32_INPUTS(i) { 4046 if (*i <= static_cast<float>(std::numeric_limits<uint32_t>::max()) && 4047 *i >= static_cast<float>(std::numeric_limits<uint32_t>::min())) { 4048 CHECK_FLOAT_EQ(static_cast<uint32_t>(*i), m.Call(*i)); 4049 } 4050 } 4051 } 4052 } 4053 4054 4055 TEST(RunChangeFloat64ToInt32_A) { 4056 BufferedRawMachineAssemblerTester<int32_t> m; 4057 double magic = 11.1; 4058 m.Return(m.ChangeFloat64ToInt32(m.Float64Constant(magic))); 4059 CHECK_EQ(static_cast<int32_t>(magic), m.Call()); 4060 } 4061 4062 4063 TEST(RunChangeFloat64ToInt32_B) { 4064 BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Float64()); 4065 m.Return(m.ChangeFloat64ToInt32(m.Parameter(0))); 4066 4067 // Note we don't check fractional inputs, or inputs outside the range of 4068 // int32, because these Convert operators really should be Change operators. 4069 FOR_INT32_INPUTS(i) { CHECK_EQ(*i, m.Call(static_cast<double>(*i))); } 4070 4071 for (int32_t n = 1; n < 31; ++n) { 4072 CHECK_EQ(1 << n, m.Call(static_cast<double>(1 << n))); 4073 } 4074 4075 for (int32_t n = 1; n < 31; ++n) { 4076 CHECK_EQ(3 << n, m.Call(static_cast<double>(3 << n))); 4077 } 4078 } 4079 4080 4081 TEST(RunChangeFloat64ToUint32) { 4082 BufferedRawMachineAssemblerTester<uint32_t> m(MachineType::Float64()); 4083 m.Return(m.ChangeFloat64ToUint32(m.Parameter(0))); 4084 4085 { 4086 FOR_UINT32_INPUTS(i) { CHECK_EQ(*i, m.Call(static_cast<double>(*i))); } 4087 } 4088 4089 // Check various powers of 2. 4090 for (int32_t n = 1; n < 31; ++n) { 4091 { CHECK_EQ(1u << n, m.Call(static_cast<double>(1u << n))); } 4092 4093 { CHECK_EQ(3u << n, m.Call(static_cast<double>(3u << n))); } 4094 } 4095 // Note we don't check fractional inputs, because these Convert operators 4096 // really should be Change operators. 4097 } 4098 4099 4100 TEST(RunTruncateFloat64ToFloat32) { 4101 BufferedRawMachineAssemblerTester<float> m(MachineType::Float64()); 4102 4103 m.Return(m.TruncateFloat64ToFloat32(m.Parameter(0))); 4104 4105 FOR_FLOAT64_INPUTS(i) { CHECK_FLOAT_EQ(DoubleToFloat32(*i), m.Call(*i)); } 4106 } 4107 4108 uint64_t ToInt64(uint32_t low, uint32_t high) { 4109 return (static_cast<uint64_t>(high) << 32) | static_cast<uint64_t>(low); 4110 } 4111 4112 #if V8_TARGET_ARCH_32_BIT && !V8_TARGET_ARCH_X87 4113 TEST(RunInt32PairAdd) { 4114 BufferedRawMachineAssemblerTester<int32_t> m( 4115 MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32(), 4116 MachineType::Uint32()); 4117 4118 uint32_t high; 4119 uint32_t low; 4120 4121 Node* PairAdd = m.Int32PairAdd(m.Parameter(0), m.Parameter(1), m.Parameter(2), 4122 m.Parameter(3)); 4123 4124 m.StoreToPointer(&low, MachineRepresentation::kWord32, 4125 m.Projection(0, PairAdd)); 4126 m.StoreToPointer(&high, MachineRepresentation::kWord32, 4127 m.Projection(1, PairAdd)); 4128 m.Return(m.Int32Constant(74)); 4129 4130 FOR_UINT64_INPUTS(i) { 4131 FOR_UINT64_INPUTS(j) { 4132 m.Call(static_cast<uint32_t>(*i & 0xffffffff), 4133 static_cast<uint32_t>(*i >> 32), 4134 static_cast<uint32_t>(*j & 0xffffffff), 4135 static_cast<uint32_t>(*j >> 32)); 4136 CHECK_EQ(*i + *j, ToInt64(low, high)); 4137 } 4138 } 4139 } 4140 4141 void TestInt32PairAddWithSharedInput(int a, int b, int c, int d) { 4142 BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32(), 4143 MachineType::Uint32()); 4144 4145 uint32_t high; 4146 uint32_t low; 4147 4148 Node* PairAdd = m.Int32PairAdd(m.Parameter(a), m.Parameter(b), m.Parameter(c), 4149 m.Parameter(d)); 4150 4151 m.StoreToPointer(&low, MachineRepresentation::kWord32, 4152 m.Projection(0, PairAdd)); 4153 m.StoreToPointer(&high, MachineRepresentation::kWord32, 4154 m.Projection(1, PairAdd)); 4155 m.Return(m.Int32Constant(74)); 4156 4157 FOR_UINT32_INPUTS(i) { 4158 FOR_UINT32_INPUTS(j) { 4159 m.Call(*i, *j); 4160 uint32_t inputs[] = {*i, *j}; 4161 CHECK_EQ(ToInt64(inputs[a], inputs[b]) + ToInt64(inputs[c], inputs[d]), 4162 ToInt64(low, high)); 4163 } 4164 } 4165 } 4166 4167 TEST(RunInt32PairAddWithSharedInput) { 4168 TestInt32PairAddWithSharedInput(0, 0, 0, 0); 4169 TestInt32PairAddWithSharedInput(1, 0, 0, 0); 4170 TestInt32PairAddWithSharedInput(0, 1, 0, 0); 4171 TestInt32PairAddWithSharedInput(0, 0, 1, 0); 4172 TestInt32PairAddWithSharedInput(0, 0, 0, 1); 4173 TestInt32PairAddWithSharedInput(1, 1, 0, 0); 4174 } 4175 4176 TEST(RunInt32PairSub) { 4177 BufferedRawMachineAssemblerTester<int32_t> m( 4178 MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32(), 4179 MachineType::Uint32()); 4180 4181 uint32_t high; 4182 uint32_t low; 4183 4184 Node* PairSub = m.Int32PairSub(m.Parameter(0), m.Parameter(1), m.Parameter(2), 4185 m.Parameter(3)); 4186 4187 m.StoreToPointer(&low, MachineRepresentation::kWord32, 4188 m.Projection(0, PairSub)); 4189 m.StoreToPointer(&high, MachineRepresentation::kWord32, 4190 m.Projection(1, PairSub)); 4191 m.Return(m.Int32Constant(74)); 4192 4193 FOR_UINT64_INPUTS(i) { 4194 FOR_UINT64_INPUTS(j) { 4195 m.Call(static_cast<uint32_t>(*i & 0xffffffff), 4196 static_cast<uint32_t>(*i >> 32), 4197 static_cast<uint32_t>(*j & 0xffffffff), 4198 static_cast<uint32_t>(*j >> 32)); 4199 CHECK_EQ(*i - *j, ToInt64(low, high)); 4200 } 4201 } 4202 } 4203 4204 void TestInt32PairSubWithSharedInput(int a, int b, int c, int d) { 4205 BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32(), 4206 MachineType::Uint32()); 4207 4208 uint32_t high; 4209 uint32_t low; 4210 4211 Node* PairSub = m.Int32PairSub(m.Parameter(a), m.Parameter(b), m.Parameter(c), 4212 m.Parameter(d)); 4213 4214 m.StoreToPointer(&low, MachineRepresentation::kWord32, 4215 m.Projection(0, PairSub)); 4216 m.StoreToPointer(&high, MachineRepresentation::kWord32, 4217 m.Projection(1, PairSub)); 4218 m.Return(m.Int32Constant(74)); 4219 4220 FOR_UINT32_INPUTS(i) { 4221 FOR_UINT32_INPUTS(j) { 4222 m.Call(*i, *j); 4223 uint32_t inputs[] = {*i, *j}; 4224 CHECK_EQ(ToInt64(inputs[a], inputs[b]) - ToInt64(inputs[c], inputs[d]), 4225 ToInt64(low, high)); 4226 } 4227 } 4228 } 4229 4230 TEST(RunInt32PairSubWithSharedInput) { 4231 TestInt32PairSubWithSharedInput(0, 0, 0, 0); 4232 TestInt32PairSubWithSharedInput(1, 0, 0, 0); 4233 TestInt32PairSubWithSharedInput(0, 1, 0, 0); 4234 TestInt32PairSubWithSharedInput(0, 0, 1, 0); 4235 TestInt32PairSubWithSharedInput(0, 0, 0, 1); 4236 TestInt32PairSubWithSharedInput(1, 1, 0, 0); 4237 } 4238 4239 TEST(RunInt32PairMul) { 4240 BufferedRawMachineAssemblerTester<int32_t> m( 4241 MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32(), 4242 MachineType::Uint32()); 4243 4244 uint32_t high; 4245 uint32_t low; 4246 4247 Node* PairMul = m.Int32PairMul(m.Parameter(0), m.Parameter(1), m.Parameter(2), 4248 m.Parameter(3)); 4249 4250 m.StoreToPointer(&low, MachineRepresentation::kWord32, 4251 m.Projection(0, PairMul)); 4252 m.StoreToPointer(&high, MachineRepresentation::kWord32, 4253 m.Projection(1, PairMul)); 4254 m.Return(m.Int32Constant(74)); 4255 4256 FOR_UINT64_INPUTS(i) { 4257 FOR_UINT64_INPUTS(j) { 4258 m.Call(static_cast<uint32_t>(*i & 0xffffffff), 4259 static_cast<uint32_t>(*i >> 32), 4260 static_cast<uint32_t>(*j & 0xffffffff), 4261 static_cast<uint32_t>(*j >> 32)); 4262 CHECK_EQ(*i * *j, ToInt64(low, high)); 4263 } 4264 } 4265 } 4266 4267 void TestInt32PairMulWithSharedInput(int a, int b, int c, int d) { 4268 BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32(), 4269 MachineType::Uint32()); 4270 4271 uint32_t high; 4272 uint32_t low; 4273 4274 Node* PairMul = m.Int32PairMul(m.Parameter(a), m.Parameter(b), m.Parameter(c), 4275 m.Parameter(d)); 4276 4277 m.StoreToPointer(&low, MachineRepresentation::kWord32, 4278 m.Projection(0, PairMul)); 4279 m.StoreToPointer(&high, MachineRepresentation::kWord32, 4280 m.Projection(1, PairMul)); 4281 m.Return(m.Int32Constant(74)); 4282 4283 FOR_UINT32_INPUTS(i) { 4284 FOR_UINT32_INPUTS(j) { 4285 m.Call(*i, *j); 4286 uint32_t inputs[] = {*i, *j}; 4287 CHECK_EQ(ToInt64(inputs[a], inputs[b]) * ToInt64(inputs[c], inputs[d]), 4288 ToInt64(low, high)); 4289 } 4290 } 4291 } 4292 4293 TEST(RunInt32PairMulWithSharedInput) { 4294 TestInt32PairMulWithSharedInput(0, 0, 0, 0); 4295 TestInt32PairMulWithSharedInput(1, 0, 0, 0); 4296 TestInt32PairMulWithSharedInput(0, 1, 0, 0); 4297 TestInt32PairMulWithSharedInput(0, 0, 1, 0); 4298 TestInt32PairMulWithSharedInput(0, 0, 0, 1); 4299 TestInt32PairMulWithSharedInput(1, 1, 0, 0); 4300 TestInt32PairMulWithSharedInput(0, 1, 1, 0); 4301 } 4302 4303 TEST(RunWord32PairShl) { 4304 BufferedRawMachineAssemblerTester<int32_t> m( 4305 MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32()); 4306 4307 uint32_t high; 4308 uint32_t low; 4309 4310 Node* PairAdd = 4311 m.Word32PairShl(m.Parameter(0), m.Parameter(1), m.Parameter(2)); 4312 4313 m.StoreToPointer(&low, MachineRepresentation::kWord32, 4314 m.Projection(0, PairAdd)); 4315 m.StoreToPointer(&high, MachineRepresentation::kWord32, 4316 m.Projection(1, PairAdd)); 4317 m.Return(m.Int32Constant(74)); 4318 4319 FOR_UINT64_INPUTS(i) { 4320 for (uint32_t j = 0; j < 64; j++) { 4321 m.Call(static_cast<uint32_t>(*i & 0xffffffff), 4322 static_cast<uint32_t>(*i >> 32), j); 4323 CHECK_EQ(*i << j, ToInt64(low, high)); 4324 } 4325 } 4326 } 4327 4328 void TestWord32PairShlWithSharedInput(int a, int b) { 4329 BufferedRawMachineAssemblerTester<int32_t> m(MachineType::Uint32(), 4330 MachineType::Uint32()); 4331 4332 uint32_t high; 4333 uint32_t low; 4334 4335 Node* PairAdd = 4336 m.Word32PairShl(m.Parameter(a), m.Parameter(b), m.Parameter(1)); 4337 4338 m.StoreToPointer(&low, MachineRepresentation::kWord32, 4339 m.Projection(0, PairAdd)); 4340 m.StoreToPointer(&high, MachineRepresentation::kWord32, 4341 m.Projection(1, PairAdd)); 4342 m.Return(m.Int32Constant(74)); 4343 4344 FOR_UINT32_INPUTS(i) { 4345 for (uint32_t j = 0; j < 64; j++) { 4346 m.Call(*i, j); 4347 uint32_t inputs[] = {*i, j}; 4348 CHECK_EQ(ToInt64(inputs[a], inputs[b]) << j, ToInt64(low, high)); 4349 } 4350 } 4351 } 4352 4353 TEST(RunWord32PairShlWithSharedInput) { 4354 TestWord32PairShlWithSharedInput(0, 0); 4355 TestWord32PairShlWithSharedInput(0, 1); 4356 TestWord32PairShlWithSharedInput(1, 0); 4357 TestWord32PairShlWithSharedInput(1, 1); 4358 } 4359 4360 TEST(RunWord32PairShr) { 4361 BufferedRawMachineAssemblerTester<int32_t> m( 4362 MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32()); 4363 4364 uint32_t high; 4365 uint32_t low; 4366 4367 Node* PairAdd = 4368 m.Word32PairShr(m.Parameter(0), m.Parameter(1), m.Parameter(2)); 4369 4370 m.StoreToPointer(&low, MachineRepresentation::kWord32, 4371 m.Projection(0, PairAdd)); 4372 m.StoreToPointer(&high, MachineRepresentation::kWord32, 4373 m.Projection(1, PairAdd)); 4374 m.Return(m.Int32Constant(74)); 4375 4376 FOR_UINT64_INPUTS(i) { 4377 for (uint32_t j = 0; j < 64; j++) { 4378 m.Call(static_cast<uint32_t>(*i & 0xffffffff), 4379 static_cast<uint32_t>(*i >> 32), j); 4380 CHECK_EQ(*i >> j, ToInt64(low, high)); 4381 } 4382 } 4383 } 4384 4385 TEST(RunWord32PairSar) { 4386 BufferedRawMachineAssemblerTester<int32_t> m( 4387 MachineType::Uint32(), MachineType::Uint32(), MachineType::Uint32()); 4388 4389 uint32_t high; 4390 uint32_t low; 4391 4392 Node* PairAdd = 4393 m.Word32PairSar(m.Parameter(0), m.Parameter(1), m.Parameter(2)); 4394 4395 m.StoreToPointer(&low, MachineRepresentation::kWord32, 4396 m.Projection(0, PairAdd)); 4397 m.StoreToPointer(&high, MachineRepresentation::kWord32, 4398 m.Projection(1, PairAdd)); 4399 m.Return(m.Int32Constant(74)); 4400 4401 FOR_INT64_INPUTS(i) { 4402 for (uint32_t j = 0; j < 64; j++) { 4403 m.Call(static_cast<uint32_t>(*i & 0xffffffff), 4404 static_cast<uint32_t>(*i >> 32), j); 4405 CHECK_EQ(*i >> j, ToInt64(low, high)); 4406 } 4407 } 4408 } 4409 4410 #endif 4411 4412 TEST(RunDeadChangeFloat64ToInt32) { 4413 RawMachineAssemblerTester<int32_t> m; 4414 const int magic = 0x88abcda4; 4415 m.ChangeFloat64ToInt32(m.Float64Constant(999.78)); 4416 m.Return(m.Int32Constant(magic)); 4417 CHECK_EQ(magic, m.Call()); 4418 } 4419 4420 4421 TEST(RunDeadChangeInt32ToFloat64) { 4422 RawMachineAssemblerTester<int32_t> m; 4423 const int magic = 0x8834abcd; 4424 m.ChangeInt32ToFloat64(m.Int32Constant(magic - 6888)); 4425 m.Return(m.Int32Constant(magic)); 4426 CHECK_EQ(magic, m.Call()); 4427 } 4428 4429 4430 TEST(RunLoopPhiInduction2) { 4431 RawMachineAssemblerTester<int32_t> m; 4432 4433 int false_val = 0x10777; 4434 4435 // x = false_val; while(false) { x++; } return x; 4436 RawMachineLabel header, body, end; 4437 Node* false_node = m.Int32Constant(false_val); 4438 m.Goto(&header); 4439 m.Bind(&header); 4440 Node* phi = m.Phi(MachineRepresentation::kWord32, false_node, false_node); 4441 m.Branch(m.Int32Constant(0), &body, &end); 4442 m.Bind(&body); 4443 Node* add = m.Int32Add(phi, m.Int32Constant(1)); 4444 phi->ReplaceInput(1, add); 4445 m.Goto(&header); 4446 m.Bind(&end); 4447 m.Return(phi); 4448 4449 CHECK_EQ(false_val, m.Call()); 4450 } 4451 4452 4453 TEST(RunFloatDiamond) { 4454 RawMachineAssemblerTester<int32_t> m; 4455 4456 const int magic = 99645; 4457 float buffer = 0.1f; 4458 float constant = 99.99f; 4459 4460 RawMachineLabel blocka, blockb, end; 4461 Node* k1 = m.Float32Constant(constant); 4462 Node* k2 = m.Float32Constant(0 - constant); 4463 m.Branch(m.Int32Constant(0), &blocka, &blockb); 4464 m.Bind(&blocka); 4465 m.Goto(&end); 4466 m.Bind(&blockb); 4467 m.Goto(&end); 4468 m.Bind(&end); 4469 Node* phi = m.Phi(MachineRepresentation::kFloat32, k2, k1); 4470 m.Store(MachineRepresentation::kFloat32, m.PointerConstant(&buffer), 4471 m.IntPtrConstant(0), phi, kNoWriteBarrier); 4472 m.Return(m.Int32Constant(magic)); 4473 4474 CHECK_EQ(magic, m.Call()); 4475 CHECK(constant == buffer); 4476 } 4477 4478 4479 TEST(RunDoubleDiamond) { 4480 RawMachineAssemblerTester<int32_t> m; 4481 4482 const int magic = 99645; 4483 double buffer = 0.1; 4484 double constant = 99.99; 4485 4486 RawMachineLabel blocka, blockb, end; 4487 Node* k1 = m.Float64Constant(constant); 4488 Node* k2 = m.Float64Constant(0 - constant); 4489 m.Branch(m.Int32Constant(0), &blocka, &blockb); 4490 m.Bind(&blocka); 4491 m.Goto(&end); 4492 m.Bind(&blockb); 4493 m.Goto(&end); 4494 m.Bind(&end); 4495 Node* phi = m.Phi(MachineRepresentation::kFloat64, k2, k1); 4496 m.Store(MachineRepresentation::kFloat64, m.PointerConstant(&buffer), 4497 m.Int32Constant(0), phi, kNoWriteBarrier); 4498 m.Return(m.Int32Constant(magic)); 4499 4500 CHECK_EQ(magic, m.Call()); 4501 CHECK_EQ(constant, buffer); 4502 } 4503 4504 4505 TEST(RunRefDiamond) { 4506 RawMachineAssemblerTester<int32_t> m; 4507 4508 const int magic = 99644; 4509 Handle<String> rexpected = 4510 CcTest::i_isolate()->factory()->InternalizeUtf8String("A"); 4511 String* buffer; 4512 4513 RawMachineLabel blocka, blockb, end; 4514 Node* k1 = m.StringConstant("A"); 4515 Node* k2 = m.StringConstant("B"); 4516 m.Branch(m.Int32Constant(0), &blocka, &blockb); 4517 m.Bind(&blocka); 4518 m.Goto(&end); 4519 m.Bind(&blockb); 4520 m.Goto(&end); 4521 m.Bind(&end); 4522 Node* phi = m.Phi(MachineRepresentation::kTagged, k2, k1); 4523 m.Store(MachineRepresentation::kTagged, m.PointerConstant(&buffer), 4524 m.Int32Constant(0), phi, kNoWriteBarrier); 4525 m.Return(m.Int32Constant(magic)); 4526 4527 CHECK_EQ(magic, m.Call()); 4528 CHECK(rexpected->SameValue(buffer)); 4529 } 4530 4531 4532 TEST(RunDoubleRefDiamond) { 4533 RawMachineAssemblerTester<int32_t> m; 4534 4535 const int magic = 99648; 4536 double dbuffer = 0.1; 4537 double dconstant = 99.99; 4538 Handle<String> rexpected = 4539 CcTest::i_isolate()->factory()->InternalizeUtf8String("AX"); 4540 String* rbuffer; 4541 4542 RawMachineLabel blocka, blockb, end; 4543 Node* d1 = m.Float64Constant(dconstant); 4544 Node* d2 = m.Float64Constant(0 - dconstant); 4545 Node* r1 = m.StringConstant("AX"); 4546 Node* r2 = m.StringConstant("BX"); 4547 m.Branch(m.Int32Constant(0), &blocka, &blockb); 4548 m.Bind(&blocka); 4549 m.Goto(&end); 4550 m.Bind(&blockb); 4551 m.Goto(&end); 4552 m.Bind(&end); 4553 Node* dphi = m.Phi(MachineRepresentation::kFloat64, d2, d1); 4554 Node* rphi = m.Phi(MachineRepresentation::kTagged, r2, r1); 4555 m.Store(MachineRepresentation::kFloat64, m.PointerConstant(&dbuffer), 4556 m.Int32Constant(0), dphi, kNoWriteBarrier); 4557 m.Store(MachineRepresentation::kTagged, m.PointerConstant(&rbuffer), 4558 m.Int32Constant(0), rphi, kNoWriteBarrier); 4559 m.Return(m.Int32Constant(magic)); 4560 4561 CHECK_EQ(magic, m.Call()); 4562 CHECK_EQ(dconstant, dbuffer); 4563 CHECK(rexpected->SameValue(rbuffer)); 4564 } 4565 4566 4567 TEST(RunDoubleRefDoubleDiamond) { 4568 RawMachineAssemblerTester<int32_t> m; 4569 4570 const int magic = 99649; 4571 double dbuffer = 0.1; 4572 double dconstant = 99.997; 4573 Handle<String> rexpected = 4574 CcTest::i_isolate()->factory()->InternalizeUtf8String("AD"); 4575 String* rbuffer; 4576 4577 RawMachineLabel blocka, blockb, mid, blockd, blocke, end; 4578 Node* d1 = m.Float64Constant(dconstant); 4579 Node* d2 = m.Float64Constant(0 - dconstant); 4580 Node* r1 = m.StringConstant("AD"); 4581 Node* r2 = m.StringConstant("BD"); 4582 m.Branch(m.Int32Constant(0), &blocka, &blockb); 4583 m.Bind(&blocka); 4584 m.Goto(&mid); 4585 m.Bind(&blockb); 4586 m.Goto(&mid); 4587 m.Bind(&mid); 4588 Node* dphi1 = m.Phi(MachineRepresentation::kFloat64, d2, d1); 4589 Node* rphi1 = m.Phi(MachineRepresentation::kTagged, r2, r1); 4590 m.Branch(m.Int32Constant(0), &blockd, &blocke); 4591 4592 m.Bind(&blockd); 4593 m.Goto(&end); 4594 m.Bind(&blocke); 4595 m.Goto(&end); 4596 m.Bind(&end); 4597 Node* dphi2 = m.Phi(MachineRepresentation::kFloat64, d1, dphi1); 4598 Node* rphi2 = m.Phi(MachineRepresentation::kTagged, r1, rphi1); 4599 4600 m.Store(MachineRepresentation::kFloat64, m.PointerConstant(&dbuffer), 4601 m.Int32Constant(0), dphi2, kNoWriteBarrier); 4602 m.Store(MachineRepresentation::kTagged, m.PointerConstant(&rbuffer), 4603 m.Int32Constant(0), rphi2, kNoWriteBarrier); 4604 m.Return(m.Int32Constant(magic)); 4605 4606 CHECK_EQ(magic, m.Call()); 4607 CHECK_EQ(dconstant, dbuffer); 4608 CHECK(rexpected->SameValue(rbuffer)); 4609 } 4610 4611 4612 TEST(RunDoubleLoopPhi) { 4613 RawMachineAssemblerTester<int32_t> m; 4614 RawMachineLabel header, body, end; 4615 4616 int magic = 99773; 4617 double buffer = 0.99; 4618 double dconstant = 777.1; 4619 4620 Node* zero = m.Int32Constant(0); 4621 Node* dk = m.Float64Constant(dconstant); 4622 4623 m.Goto(&header); 4624 m.Bind(&header); 4625 Node* phi = m.Phi(MachineRepresentation::kFloat64, dk, dk); 4626 phi->ReplaceInput(1, phi); 4627 m.Branch(zero, &body, &end); 4628 m.Bind(&body); 4629 m.Goto(&header); 4630 m.Bind(&end); 4631 m.Store(MachineRepresentation::kFloat64, m.PointerConstant(&buffer), 4632 m.Int32Constant(0), phi, kNoWriteBarrier); 4633 m.Return(m.Int32Constant(magic)); 4634 4635 CHECK_EQ(magic, m.Call()); 4636 } 4637 4638 4639 TEST(RunCountToTenAccRaw) { 4640 RawMachineAssemblerTester<int32_t> m; 4641 4642 Node* zero = m.Int32Constant(0); 4643 Node* ten = m.Int32Constant(10); 4644 Node* one = m.Int32Constant(1); 4645 4646 RawMachineLabel header, body, body_cont, end; 4647 4648 m.Goto(&header); 4649 4650 m.Bind(&header); 4651 Node* i = m.Phi(MachineRepresentation::kWord32, zero, zero); 4652 Node* j = m.Phi(MachineRepresentation::kWord32, zero, zero); 4653 m.Goto(&body); 4654 4655 m.Bind(&body); 4656 Node* next_i = m.Int32Add(i, one); 4657 Node* next_j = m.Int32Add(j, one); 4658 m.Branch(m.Word32Equal(next_i, ten), &end, &body_cont); 4659 4660 m.Bind(&body_cont); 4661 i->ReplaceInput(1, next_i); 4662 j->ReplaceInput(1, next_j); 4663 m.Goto(&header); 4664 4665 m.Bind(&end); 4666 m.Return(ten); 4667 4668 CHECK_EQ(10, m.Call()); 4669 } 4670 4671 4672 TEST(RunCountToTenAccRaw2) { 4673 RawMachineAssemblerTester<int32_t> m; 4674 4675 Node* zero = m.Int32Constant(0); 4676 Node* ten = m.Int32Constant(10); 4677 Node* one = m.Int32Constant(1); 4678 4679 RawMachineLabel header, body, body_cont, end; 4680 4681 m.Goto(&header); 4682 4683 m.Bind(&header); 4684 Node* i = m.Phi(MachineRepresentation::kWord32, zero, zero); 4685 Node* j = m.Phi(MachineRepresentation::kWord32, zero, zero); 4686 Node* k = m.Phi(MachineRepresentation::kWord32, zero, zero); 4687 m.Goto(&body); 4688 4689 m.Bind(&body); 4690 Node* next_i = m.Int32Add(i, one); 4691 Node* next_j = m.Int32Add(j, one); 4692 Node* next_k = m.Int32Add(j, one); 4693 m.Branch(m.Word32Equal(next_i, ten), &end, &body_cont); 4694 4695 m.Bind(&body_cont); 4696 i->ReplaceInput(1, next_i); 4697 j->ReplaceInput(1, next_j); 4698 k->ReplaceInput(1, next_k); 4699 m.Goto(&header); 4700 4701 m.Bind(&end); 4702 m.Return(ten); 4703 4704 CHECK_EQ(10, m.Call()); 4705 } 4706 4707 4708 TEST(RunAddTree) { 4709 RawMachineAssemblerTester<int32_t> m; 4710 int32_t inputs[] = {11, 12, 13, 14, 15, 16, 17, 18}; 4711 4712 Node* base = m.PointerConstant(inputs); 4713 Node* n0 = 4714 m.Load(MachineType::Int32(), base, m.Int32Constant(0 * sizeof(int32_t))); 4715 Node* n1 = 4716 m.Load(MachineType::Int32(), base, m.Int32Constant(1 * sizeof(int32_t))); 4717 Node* n2 = 4718 m.Load(MachineType::Int32(), base, m.Int32Constant(2 * sizeof(int32_t))); 4719 Node* n3 = 4720 m.Load(MachineType::Int32(), base, m.Int32Constant(3 * sizeof(int32_t))); 4721 Node* n4 = 4722 m.Load(MachineType::Int32(), base, m.Int32Constant(4 * sizeof(int32_t))); 4723 Node* n5 = 4724 m.Load(MachineType::Int32(), base, m.Int32Constant(5 * sizeof(int32_t))); 4725 Node* n6 = 4726 m.Load(MachineType::Int32(), base, m.Int32Constant(6 * sizeof(int32_t))); 4727 Node* n7 = 4728 m.Load(MachineType::Int32(), base, m.Int32Constant(7 * sizeof(int32_t))); 4729 4730 Node* i1 = m.Int32Add(n0, n1); 4731 Node* i2 = m.Int32Add(n2, n3); 4732 Node* i3 = m.Int32Add(n4, n5); 4733 Node* i4 = m.Int32Add(n6, n7); 4734 4735 Node* i5 = m.Int32Add(i1, i2); 4736 Node* i6 = m.Int32Add(i3, i4); 4737 4738 Node* i7 = m.Int32Add(i5, i6); 4739 4740 m.Return(i7); 4741 4742 CHECK_EQ(116, m.Call()); 4743 } 4744 4745 4746 static const int kFloat64CompareHelperTestCases = 15; 4747 static const int kFloat64CompareHelperNodeType = 4; 4748 4749 static int Float64CompareHelper(RawMachineAssemblerTester<int32_t>* m, 4750 int test_case, int node_type, double x, 4751 double y) { 4752 static double buffer[2]; 4753 buffer[0] = x; 4754 buffer[1] = y; 4755 CHECK(0 <= test_case && test_case < kFloat64CompareHelperTestCases); 4756 CHECK(0 <= node_type && node_type < kFloat64CompareHelperNodeType); 4757 CHECK(x < y); 4758 bool load_a = node_type / 2 == 1; 4759 bool load_b = node_type % 2 == 1; 4760 Node* a = 4761 load_a ? m->Load(MachineType::Float64(), m->PointerConstant(&buffer[0])) 4762 : m->Float64Constant(x); 4763 Node* b = 4764 load_b ? m->Load(MachineType::Float64(), m->PointerConstant(&buffer[1])) 4765 : m->Float64Constant(y); 4766 Node* cmp = NULL; 4767 bool expected = false; 4768 switch (test_case) { 4769 // Equal tests. 4770 case 0: 4771 cmp = m->Float64Equal(a, b); 4772 expected = false; 4773 break; 4774 case 1: 4775 cmp = m->Float64Equal(a, a); 4776 expected = true; 4777 break; 4778 // LessThan tests. 4779 case 2: 4780 cmp = m->Float64LessThan(a, b); 4781 expected = true; 4782 break; 4783 case 3: 4784 cmp = m->Float64LessThan(b, a); 4785 expected = false; 4786 break; 4787 case 4: 4788 cmp = m->Float64LessThan(a, a); 4789 expected = false; 4790 break; 4791 // LessThanOrEqual tests. 4792 case 5: 4793 cmp = m->Float64LessThanOrEqual(a, b); 4794 expected = true; 4795 break; 4796 case 6: 4797 cmp = m->Float64LessThanOrEqual(b, a); 4798 expected = false; 4799 break; 4800 case 7: 4801 cmp = m->Float64LessThanOrEqual(a, a); 4802 expected = true; 4803 break; 4804 // NotEqual tests. 4805 case 8: 4806 cmp = m->Float64NotEqual(a, b); 4807 expected = true; 4808 break; 4809 case 9: 4810 cmp = m->Float64NotEqual(b, a); 4811 expected = true; 4812 break; 4813 case 10: 4814 cmp = m->Float64NotEqual(a, a); 4815 expected = false; 4816 break; 4817 // GreaterThan tests. 4818 case 11: 4819 cmp = m->Float64GreaterThan(a, a); 4820 expected = false; 4821 break; 4822 case 12: 4823 cmp = m->Float64GreaterThan(a, b); 4824 expected = false; 4825 break; 4826 // GreaterThanOrEqual tests. 4827 case 13: 4828 cmp = m->Float64GreaterThanOrEqual(a, a); 4829 expected = true; 4830 break; 4831 case 14: 4832 cmp = m->Float64GreaterThanOrEqual(b, a); 4833 expected = true; 4834 break; 4835 default: 4836 UNREACHABLE(); 4837 } 4838 m->Return(cmp); 4839 return expected; 4840 } 4841 4842 4843 TEST(RunFloat64Compare) { 4844 double inf = V8_INFINITY; 4845 // All pairs (a1, a2) are of the form a1 < a2. 4846 double inputs[] = {0.0, 1.0, -1.0, 0.22, -1.22, 0.22, 4847 -inf, 0.22, 0.22, inf, -inf, inf}; 4848 4849 for (int test = 0; test < kFloat64CompareHelperTestCases; test++) { 4850 for (int node_type = 0; node_type < kFloat64CompareHelperNodeType; 4851 node_type++) { 4852 for (size_t input = 0; input < arraysize(inputs); input += 2) { 4853 RawMachineAssemblerTester<int32_t> m; 4854 int expected = Float64CompareHelper(&m, test, node_type, inputs[input], 4855 inputs[input + 1]); 4856 CHECK_EQ(expected, m.Call()); 4857 } 4858 } 4859 } 4860 } 4861 4862 4863 TEST(RunFloat64UnorderedCompare) { 4864 RawMachineAssemblerTester<int32_t> m; 4865 4866 const Operator* operators[] = {m.machine()->Float64Equal(), 4867 m.machine()->Float64LessThan(), 4868 m.machine()->Float64LessThanOrEqual()}; 4869 4870 double nan = std::numeric_limits<double>::quiet_NaN(); 4871 4872 FOR_FLOAT64_INPUTS(i) { 4873 for (size_t o = 0; o < arraysize(operators); ++o) { 4874 for (int j = 0; j < 2; j++) { 4875 RawMachineAssemblerTester<int32_t> m; 4876 Node* a = m.Float64Constant(*i); 4877 Node* b = m.Float64Constant(nan); 4878 if (j == 1) std::swap(a, b); 4879 m.Return(m.AddNode(operators[o], a, b)); 4880 CHECK_EQ(0, m.Call()); 4881 } 4882 } 4883 } 4884 } 4885 4886 4887 TEST(RunFloat64Equal) { 4888 double input_a = 0.0; 4889 double input_b = 0.0; 4890 4891 RawMachineAssemblerTester<int32_t> m; 4892 Node* a = m.LoadFromPointer(&input_a, MachineType::Float64()); 4893 Node* b = m.LoadFromPointer(&input_b, MachineType::Float64()); 4894 m.Return(m.Float64Equal(a, b)); 4895 4896 CompareWrapper cmp(IrOpcode::kFloat64Equal); 4897 FOR_FLOAT64_INPUTS(pl) { 4898 FOR_FLOAT64_INPUTS(pr) { 4899 input_a = *pl; 4900 input_b = *pr; 4901 int32_t expected = cmp.Float64Compare(input_a, input_b) ? 1 : 0; 4902 CHECK_EQ(expected, m.Call()); 4903 } 4904 } 4905 } 4906 4907 4908 TEST(RunFloat64LessThan) { 4909 double input_a = 0.0; 4910 double input_b = 0.0; 4911 4912 RawMachineAssemblerTester<int32_t> m; 4913 Node* a = m.LoadFromPointer(&input_a, MachineType::Float64()); 4914 Node* b = m.LoadFromPointer(&input_b, MachineType::Float64()); 4915 m.Return(m.Float64LessThan(a, b)); 4916 4917 CompareWrapper cmp(IrOpcode::kFloat64LessThan); 4918 FOR_FLOAT64_INPUTS(pl) { 4919 FOR_FLOAT64_INPUTS(pr) { 4920 input_a = *pl; 4921 input_b = *pr; 4922 int32_t expected = cmp.Float64Compare(input_a, input_b) ? 1 : 0; 4923 CHECK_EQ(expected, m.Call()); 4924 } 4925 } 4926 } 4927 4928 4929 static void IntPtrCompare(intptr_t left, intptr_t right) { 4930 for (int test = 0; test < 7; test++) { 4931 RawMachineAssemblerTester<bool> m(MachineType::Pointer(), 4932 MachineType::Pointer()); 4933 Node* p0 = m.Parameter(0); 4934 Node* p1 = m.Parameter(1); 4935 Node* res = NULL; 4936 bool expected = false; 4937 switch (test) { 4938 case 0: 4939 res = m.IntPtrLessThan(p0, p1); 4940 expected = true; 4941 break; 4942 case 1: 4943 res = m.IntPtrLessThanOrEqual(p0, p1); 4944 expected = true; 4945 break; 4946 case 2: 4947 res = m.IntPtrEqual(p0, p1); 4948 expected = false; 4949 break; 4950 case 3: 4951 res = m.IntPtrGreaterThanOrEqual(p0, p1); 4952 expected = false; 4953 break; 4954 case 4: 4955 res = m.IntPtrGreaterThan(p0, p1); 4956 expected = false; 4957 break; 4958 case 5: 4959 res = m.IntPtrEqual(p0, p0); 4960 expected = true; 4961 break; 4962 case 6: 4963 res = m.IntPtrNotEqual(p0, p1); 4964 expected = true; 4965 break; 4966 default: 4967 UNREACHABLE(); 4968 break; 4969 } 4970 m.Return(res); 4971 CHECK_EQ(expected, m.Call(reinterpret_cast<int32_t*>(left), 4972 reinterpret_cast<int32_t*>(right))); 4973 } 4974 } 4975 4976 4977 TEST(RunIntPtrCompare) { 4978 intptr_t min = std::numeric_limits<intptr_t>::min(); 4979 intptr_t max = std::numeric_limits<intptr_t>::max(); 4980 // An ascending chain of intptr_t 4981 intptr_t inputs[] = {min, min / 2, -1, 0, 1, max / 2, max}; 4982 for (size_t i = 0; i < arraysize(inputs) - 1; i++) { 4983 IntPtrCompare(inputs[i], inputs[i + 1]); 4984 } 4985 } 4986 4987 4988 TEST(RunTestIntPtrArithmetic) { 4989 static const int kInputSize = 10; 4990 int32_t inputs[kInputSize]; 4991 int32_t outputs[kInputSize]; 4992 for (int i = 0; i < kInputSize; i++) { 4993 inputs[i] = i; 4994 outputs[i] = -1; 4995 } 4996 RawMachineAssemblerTester<int32_t*> m; 4997 Node* input = m.PointerConstant(&inputs[0]); 4998 Node* output = m.PointerConstant(&outputs[kInputSize - 1]); 4999 Node* elem_size = m.IntPtrConstant(sizeof(inputs[0])); 5000 for (int i = 0; i < kInputSize; i++) { 5001 m.Store(MachineRepresentation::kWord32, output, 5002 m.Load(MachineType::Int32(), input), kNoWriteBarrier); 5003 input = m.IntPtrAdd(input, elem_size); 5004 output = m.IntPtrSub(output, elem_size); 5005 } 5006 m.Return(input); 5007 CHECK_EQ(&inputs[kInputSize], m.Call()); 5008 for (int i = 0; i < kInputSize; i++) { 5009 CHECK_EQ(i, inputs[i]); 5010 CHECK_EQ(kInputSize - i - 1, outputs[i]); 5011 } 5012 } 5013 5014 5015 TEST(RunSpillLotsOfThings) { 5016 static const int kInputSize = 1000; 5017 RawMachineAssemblerTester<int32_t> m; 5018 Node* accs[kInputSize]; 5019 int32_t outputs[kInputSize]; 5020 Node* one = m.Int32Constant(1); 5021 Node* acc = one; 5022 for (int i = 0; i < kInputSize; i++) { 5023 acc = m.Int32Add(acc, one); 5024 accs[i] = acc; 5025 } 5026 for (int i = 0; i < kInputSize; i++) { 5027 m.StoreToPointer(&outputs[i], MachineRepresentation::kWord32, accs[i]); 5028 } 5029 m.Return(one); 5030 m.Call(); 5031 for (int i = 0; i < kInputSize; i++) { 5032 CHECK_EQ(outputs[i], i + 2); 5033 } 5034 } 5035 5036 5037 TEST(RunSpillConstantsAndParameters) { 5038 static const int kInputSize = 1000; 5039 static const int32_t kBase = 987; 5040 RawMachineAssemblerTester<int32_t> m(MachineType::Int32(), 5041 MachineType::Int32()); 5042 int32_t outputs[kInputSize]; 5043 Node* csts[kInputSize]; 5044 Node* accs[kInputSize]; 5045 Node* acc = m.Int32Constant(0); 5046 for (int i = 0; i < kInputSize; i++) { 5047 csts[i] = m.Int32Constant(static_cast<int32_t>(kBase + i)); 5048 } 5049 for (int i = 0; i < kInputSize; i++) { 5050 acc = m.Int32Add(acc, csts[i]); 5051 accs[i] = acc; 5052 } 5053 for (int i = 0; i < kInputSize; i++) { 5054 m.StoreToPointer(&outputs[i], MachineRepresentation::kWord32, accs[i]); 5055 } 5056 m.Return(m.Int32Add(acc, m.Int32Add(m.Parameter(0), m.Parameter(1)))); 5057 FOR_INT32_INPUTS(i) { 5058 FOR_INT32_INPUTS(j) { 5059 int32_t expected = *i + *j; 5060 for (int k = 0; k < kInputSize; k++) { 5061 expected += kBase + k; 5062 } 5063 CHECK_EQ(expected, m.Call(*i, *j)); 5064 expected = 0; 5065 for (int k = 0; k < kInputSize; k++) { 5066 expected += kBase + k; 5067 CHECK_EQ(expected, outputs[k]); 5068 } 5069 } 5070 } 5071 } 5072 5073 5074 TEST(RunNewSpaceConstantsInPhi) { 5075 RawMachineAssemblerTester<Object*> m(MachineType::Int32()); 5076 5077 Isolate* isolate = CcTest::i_isolate(); 5078 Handle<HeapNumber> true_val = isolate->factory()->NewHeapNumber(11.2); 5079 Handle<HeapNumber> false_val = isolate->factory()->NewHeapNumber(11.3); 5080 Node* true_node = m.HeapConstant(true_val); 5081 Node* false_node = m.HeapConstant(false_val); 5082 5083 RawMachineLabel blocka, blockb, end; 5084 m.Branch(m.Parameter(0), &blocka, &blockb); 5085 m.Bind(&blocka); 5086 m.Goto(&end); 5087 m.Bind(&blockb); 5088 m.Goto(&end); 5089 5090 m.Bind(&end); 5091 Node* phi = m.Phi(MachineRepresentation::kTagged, true_node, false_node); 5092 m.Return(phi); 5093 5094 CHECK_EQ(*false_val, m.Call(0)); 5095 CHECK_EQ(*true_val, m.Call(1)); 5096 } 5097 5098 5099 TEST(RunInt32AddWithOverflowP) { 5100 int32_t actual_val = -1; 5101 RawMachineAssemblerTester<int32_t> m; 5102 Int32BinopTester bt(&m); 5103 Node* add = m.Int32AddWithOverflow(bt.param0, bt.param1); 5104 Node* val = m.Projection(0, add); 5105 Node* ovf = m.Projection(1, add); 5106 m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val); 5107 bt.AddReturn(ovf); 5108 FOR_INT32_INPUTS(i) { 5109 FOR_INT32_INPUTS(j) { 5110 int32_t expected_val; 5111 int expected_ovf = bits::SignedAddOverflow32(*i, *j, &expected_val); 5112 CHECK_EQ(expected_ovf, bt.call(*i, *j)); 5113 CHECK_EQ(expected_val, actual_val); 5114 } 5115 } 5116 } 5117 5118 5119 TEST(RunInt32AddWithOverflowImm) { 5120 int32_t actual_val = -1, expected_val = 0; 5121 FOR_INT32_INPUTS(i) { 5122 { 5123 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 5124 Node* add = m.Int32AddWithOverflow(m.Int32Constant(*i), m.Parameter(0)); 5125 Node* val = m.Projection(0, add); 5126 Node* ovf = m.Projection(1, add); 5127 m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val); 5128 m.Return(ovf); 5129 FOR_INT32_INPUTS(j) { 5130 int expected_ovf = bits::SignedAddOverflow32(*i, *j, &expected_val); 5131 CHECK_EQ(expected_ovf, m.Call(*j)); 5132 CHECK_EQ(expected_val, actual_val); 5133 } 5134 } 5135 { 5136 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 5137 Node* add = m.Int32AddWithOverflow(m.Parameter(0), m.Int32Constant(*i)); 5138 Node* val = m.Projection(0, add); 5139 Node* ovf = m.Projection(1, add); 5140 m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val); 5141 m.Return(ovf); 5142 FOR_INT32_INPUTS(j) { 5143 int expected_ovf = bits::SignedAddOverflow32(*i, *j, &expected_val); 5144 CHECK_EQ(expected_ovf, m.Call(*j)); 5145 CHECK_EQ(expected_val, actual_val); 5146 } 5147 } 5148 FOR_INT32_INPUTS(j) { 5149 RawMachineAssemblerTester<int32_t> m; 5150 Node* add = 5151 m.Int32AddWithOverflow(m.Int32Constant(*i), m.Int32Constant(*j)); 5152 Node* val = m.Projection(0, add); 5153 Node* ovf = m.Projection(1, add); 5154 m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val); 5155 m.Return(ovf); 5156 int expected_ovf = bits::SignedAddOverflow32(*i, *j, &expected_val); 5157 CHECK_EQ(expected_ovf, m.Call()); 5158 CHECK_EQ(expected_val, actual_val); 5159 } 5160 } 5161 } 5162 5163 5164 TEST(RunInt32AddWithOverflowInBranchP) { 5165 int constant = 911777; 5166 RawMachineLabel blocka, blockb; 5167 RawMachineAssemblerTester<int32_t> m; 5168 Int32BinopTester bt(&m); 5169 Node* add = m.Int32AddWithOverflow(bt.param0, bt.param1); 5170 Node* ovf = m.Projection(1, add); 5171 m.Branch(ovf, &blocka, &blockb); 5172 m.Bind(&blocka); 5173 bt.AddReturn(m.Int32Constant(constant)); 5174 m.Bind(&blockb); 5175 Node* val = m.Projection(0, add); 5176 bt.AddReturn(val); 5177 FOR_INT32_INPUTS(i) { 5178 FOR_INT32_INPUTS(j) { 5179 int32_t expected; 5180 if (bits::SignedAddOverflow32(*i, *j, &expected)) expected = constant; 5181 CHECK_EQ(expected, bt.call(*i, *j)); 5182 } 5183 } 5184 } 5185 5186 5187 TEST(RunInt32SubWithOverflowP) { 5188 int32_t actual_val = -1; 5189 RawMachineAssemblerTester<int32_t> m; 5190 Int32BinopTester bt(&m); 5191 Node* add = m.Int32SubWithOverflow(bt.param0, bt.param1); 5192 Node* val = m.Projection(0, add); 5193 Node* ovf = m.Projection(1, add); 5194 m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val); 5195 bt.AddReturn(ovf); 5196 FOR_INT32_INPUTS(i) { 5197 FOR_INT32_INPUTS(j) { 5198 int32_t expected_val; 5199 int expected_ovf = bits::SignedSubOverflow32(*i, *j, &expected_val); 5200 CHECK_EQ(expected_ovf, bt.call(*i, *j)); 5201 CHECK_EQ(expected_val, actual_val); 5202 } 5203 } 5204 } 5205 5206 5207 TEST(RunInt32SubWithOverflowImm) { 5208 int32_t actual_val = -1, expected_val = 0; 5209 FOR_INT32_INPUTS(i) { 5210 { 5211 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 5212 Node* add = m.Int32SubWithOverflow(m.Int32Constant(*i), m.Parameter(0)); 5213 Node* val = m.Projection(0, add); 5214 Node* ovf = m.Projection(1, add); 5215 m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val); 5216 m.Return(ovf); 5217 FOR_INT32_INPUTS(j) { 5218 int expected_ovf = bits::SignedSubOverflow32(*i, *j, &expected_val); 5219 CHECK_EQ(expected_ovf, m.Call(*j)); 5220 CHECK_EQ(expected_val, actual_val); 5221 } 5222 } 5223 { 5224 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 5225 Node* add = m.Int32SubWithOverflow(m.Parameter(0), m.Int32Constant(*i)); 5226 Node* val = m.Projection(0, add); 5227 Node* ovf = m.Projection(1, add); 5228 m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val); 5229 m.Return(ovf); 5230 FOR_INT32_INPUTS(j) { 5231 int expected_ovf = bits::SignedSubOverflow32(*j, *i, &expected_val); 5232 CHECK_EQ(expected_ovf, m.Call(*j)); 5233 CHECK_EQ(expected_val, actual_val); 5234 } 5235 } 5236 FOR_INT32_INPUTS(j) { 5237 RawMachineAssemblerTester<int32_t> m; 5238 Node* add = 5239 m.Int32SubWithOverflow(m.Int32Constant(*i), m.Int32Constant(*j)); 5240 Node* val = m.Projection(0, add); 5241 Node* ovf = m.Projection(1, add); 5242 m.StoreToPointer(&actual_val, MachineRepresentation::kWord32, val); 5243 m.Return(ovf); 5244 int expected_ovf = bits::SignedSubOverflow32(*i, *j, &expected_val); 5245 CHECK_EQ(expected_ovf, m.Call()); 5246 CHECK_EQ(expected_val, actual_val); 5247 } 5248 } 5249 } 5250 5251 5252 TEST(RunInt32SubWithOverflowInBranchP) { 5253 int constant = 911999; 5254 RawMachineLabel blocka, blockb; 5255 RawMachineAssemblerTester<int32_t> m; 5256 Int32BinopTester bt(&m); 5257 Node* sub = m.Int32SubWithOverflow(bt.param0, bt.param1); 5258 Node* ovf = m.Projection(1, sub); 5259 m.Branch(ovf, &blocka, &blockb); 5260 m.Bind(&blocka); 5261 bt.AddReturn(m.Int32Constant(constant)); 5262 m.Bind(&blockb); 5263 Node* val = m.Projection(0, sub); 5264 bt.AddReturn(val); 5265 FOR_INT32_INPUTS(i) { 5266 FOR_INT32_INPUTS(j) { 5267 int32_t expected; 5268 if (bits::SignedSubOverflow32(*i, *j, &expected)) expected = constant; 5269 CHECK_EQ(expected, bt.call(*i, *j)); 5270 } 5271 } 5272 } 5273 5274 5275 TEST(RunWord64EqualInBranchP) { 5276 int64_t input; 5277 RawMachineLabel blocka, blockb; 5278 RawMachineAssemblerTester<int64_t> m; 5279 if (!m.machine()->Is64()) return; 5280 Node* value = m.LoadFromPointer(&input, MachineType::Int64()); 5281 m.Branch(m.Word64Equal(value, m.Int64Constant(0)), &blocka, &blockb); 5282 m.Bind(&blocka); 5283 m.Return(m.Int32Constant(1)); 5284 m.Bind(&blockb); 5285 m.Return(m.Int32Constant(2)); 5286 input = V8_INT64_C(0); 5287 CHECK_EQ(1, m.Call()); 5288 input = V8_INT64_C(1); 5289 CHECK_EQ(2, m.Call()); 5290 input = V8_INT64_C(0x100000000); 5291 CHECK_EQ(2, m.Call()); 5292 } 5293 5294 5295 TEST(RunChangeInt32ToInt64P) { 5296 if (kPointerSize < 8) return; 5297 int64_t actual = -1; 5298 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 5299 m.StoreToPointer(&actual, MachineRepresentation::kWord64, 5300 m.ChangeInt32ToInt64(m.Parameter(0))); 5301 m.Return(m.Int32Constant(0)); 5302 FOR_INT32_INPUTS(i) { 5303 int64_t expected = *i; 5304 CHECK_EQ(0, m.Call(*i)); 5305 CHECK_EQ(expected, actual); 5306 } 5307 } 5308 5309 5310 TEST(RunChangeUint32ToUint64P) { 5311 if (kPointerSize < 8) return; 5312 int64_t actual = -1; 5313 RawMachineAssemblerTester<int32_t> m(MachineType::Uint32()); 5314 m.StoreToPointer(&actual, MachineRepresentation::kWord64, 5315 m.ChangeUint32ToUint64(m.Parameter(0))); 5316 m.Return(m.Int32Constant(0)); 5317 FOR_UINT32_INPUTS(i) { 5318 int64_t expected = static_cast<uint64_t>(*i); 5319 CHECK_EQ(0, m.Call(*i)); 5320 CHECK_EQ(expected, actual); 5321 } 5322 } 5323 5324 5325 TEST(RunTruncateInt64ToInt32P) { 5326 if (kPointerSize < 8) return; 5327 int64_t expected = -1; 5328 RawMachineAssemblerTester<int32_t> m; 5329 m.Return(m.TruncateInt64ToInt32( 5330 m.LoadFromPointer(&expected, MachineType::Int64()))); 5331 FOR_UINT32_INPUTS(i) { 5332 FOR_UINT32_INPUTS(j) { 5333 expected = (static_cast<uint64_t>(*j) << 32) | *i; 5334 CHECK_EQ(static_cast<int32_t>(expected), m.Call()); 5335 } 5336 } 5337 } 5338 5339 TEST(RunTruncateFloat64ToWord32P) { 5340 struct { 5341 double from; 5342 double raw; 5343 } kValues[] = {{0, 0}, 5344 {0.5, 0}, 5345 {-0.5, 0}, 5346 {1.5, 1}, 5347 {-1.5, -1}, 5348 {5.5, 5}, 5349 {-5.0, -5}, 5350 {std::numeric_limits<double>::quiet_NaN(), 0}, 5351 {std::numeric_limits<double>::infinity(), 0}, 5352 {-std::numeric_limits<double>::quiet_NaN(), 0}, 5353 {-std::numeric_limits<double>::infinity(), 0}, 5354 {4.94065645841e-324, 0}, 5355 {-4.94065645841e-324, 0}, 5356 {0.9999999999999999, 0}, 5357 {-0.9999999999999999, 0}, 5358 {4294967296.0, 0}, 5359 {-4294967296.0, 0}, 5360 {9223372036854775000.0, 4294966272.0}, 5361 {-9223372036854775000.0, -4294966272.0}, 5362 {4.5036e+15, 372629504}, 5363 {-4.5036e+15, -372629504}, 5364 {287524199.5377777, 0x11234567}, 5365 {-287524199.5377777, -0x11234567}, 5366 {2300193596.302222, 2300193596.0}, 5367 {-2300193596.302222, -2300193596.0}, 5368 {4600387192.604444, 305419896}, 5369 {-4600387192.604444, -305419896}, 5370 {4823855600872397.0, 1737075661}, 5371 {-4823855600872397.0, -1737075661}, 5372 {4503603922337791.0, -1}, 5373 {-4503603922337791.0, 1}, 5374 {4503601774854143.0, 2147483647}, 5375 {-4503601774854143.0, -2147483647}, 5376 {9007207844675582.0, -2}, 5377 {-9007207844675582.0, 2}, 5378 {2.4178527921507624e+24, -536870912}, 5379 {-2.4178527921507624e+24, 536870912}, 5380 {2.417853945072267e+24, -536870912}, 5381 {-2.417853945072267e+24, 536870912}, 5382 {4.8357055843015248e+24, -1073741824}, 5383 {-4.8357055843015248e+24, 1073741824}, 5384 {4.8357078901445341e+24, -1073741824}, 5385 {-4.8357078901445341e+24, 1073741824}, 5386 {2147483647.0, 2147483647.0}, 5387 {-2147483648.0, -2147483648.0}, 5388 {9.6714111686030497e+24, -2147483648.0}, 5389 {-9.6714111686030497e+24, -2147483648.0}, 5390 {9.6714157802890681e+24, -2147483648.0}, 5391 {-9.6714157802890681e+24, -2147483648.0}, 5392 {1.9342813113834065e+25, 2147483648.0}, 5393 {-1.9342813113834065e+25, 2147483648.0}, 5394 {3.868562622766813e+25, 0}, 5395 {-3.868562622766813e+25, 0}, 5396 {1.7976931348623157e+308, 0}, 5397 {-1.7976931348623157e+308, 0}}; 5398 double input = -1.0; 5399 RawMachineAssemblerTester<int32_t> m; 5400 m.Return(m.TruncateFloat64ToWord32( 5401 m.LoadFromPointer(&input, MachineType::Float64()))); 5402 for (size_t i = 0; i < arraysize(kValues); ++i) { 5403 input = kValues[i].from; 5404 uint64_t expected = static_cast<int64_t>(kValues[i].raw); 5405 CHECK_EQ(static_cast<int>(expected), m.Call()); 5406 } 5407 } 5408 5409 TEST(RunTruncateFloat64ToWord32SignExtension) { 5410 BufferedRawMachineAssemblerTester<int32_t> r; 5411 r.Return(r.Int32Sub(r.TruncateFloat64ToWord32(r.Float64Constant(-1.0)), 5412 r.Int32Constant(0))); 5413 CHECK_EQ(-1, r.Call()); 5414 } 5415 5416 TEST(RunChangeFloat32ToFloat64) { 5417 BufferedRawMachineAssemblerTester<double> m(MachineType::Float32()); 5418 5419 m.Return(m.ChangeFloat32ToFloat64(m.Parameter(0))); 5420 5421 FOR_FLOAT32_INPUTS(i) { 5422 CHECK_DOUBLE_EQ(static_cast<double>(*i), m.Call(*i)); 5423 } 5424 } 5425 5426 5427 TEST(RunFloat32Constant) { 5428 FOR_FLOAT32_INPUTS(i) { 5429 BufferedRawMachineAssemblerTester<float> m; 5430 m.Return(m.Float32Constant(*i)); 5431 CHECK_FLOAT_EQ(*i, m.Call()); 5432 } 5433 } 5434 5435 5436 TEST(RunFloat64ExtractLowWord32) { 5437 BufferedRawMachineAssemblerTester<uint32_t> m(MachineType::Float64()); 5438 m.Return(m.Float64ExtractLowWord32(m.Parameter(0))); 5439 FOR_FLOAT64_INPUTS(i) { 5440 uint32_t expected = static_cast<uint32_t>(bit_cast<uint64_t>(*i)); 5441 CHECK_EQ(expected, m.Call(*i)); 5442 } 5443 } 5444 5445 5446 TEST(RunFloat64ExtractHighWord32) { 5447 BufferedRawMachineAssemblerTester<uint32_t> m(MachineType::Float64()); 5448 m.Return(m.Float64ExtractHighWord32(m.Parameter(0))); 5449 FOR_FLOAT64_INPUTS(i) { 5450 uint32_t expected = static_cast<uint32_t>(bit_cast<uint64_t>(*i) >> 32); 5451 CHECK_EQ(expected, m.Call(*i)); 5452 } 5453 } 5454 5455 5456 TEST(RunFloat64InsertLowWord32) { 5457 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(), 5458 MachineType::Int32()); 5459 m.Return(m.Float64InsertLowWord32(m.Parameter(0), m.Parameter(1))); 5460 FOR_FLOAT64_INPUTS(i) { 5461 FOR_INT32_INPUTS(j) { 5462 double expected = bit_cast<double>( 5463 (bit_cast<uint64_t>(*i) & ~(V8_UINT64_C(0xFFFFFFFF))) | 5464 (static_cast<uint64_t>(bit_cast<uint32_t>(*j)))); 5465 CHECK_DOUBLE_EQ(expected, m.Call(*i, *j)); 5466 } 5467 } 5468 } 5469 5470 5471 TEST(RunFloat64InsertHighWord32) { 5472 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(), 5473 MachineType::Uint32()); 5474 m.Return(m.Float64InsertHighWord32(m.Parameter(0), m.Parameter(1))); 5475 FOR_FLOAT64_INPUTS(i) { 5476 FOR_UINT32_INPUTS(j) { 5477 uint64_t expected = (bit_cast<uint64_t>(*i) & 0xFFFFFFFF) | 5478 (static_cast<uint64_t>(*j) << 32); 5479 5480 CHECK_DOUBLE_EQ(bit_cast<double>(expected), m.Call(*i, *j)); 5481 } 5482 } 5483 } 5484 5485 5486 TEST(RunFloat32Abs) { 5487 BufferedRawMachineAssemblerTester<float> m(MachineType::Float32()); 5488 m.Return(m.Float32Abs(m.Parameter(0))); 5489 FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(std::abs(*i), m.Call(*i)); } 5490 } 5491 5492 5493 TEST(RunFloat64Abs) { 5494 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5495 m.Return(m.Float64Abs(m.Parameter(0))); 5496 FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(std::abs(*i), m.Call(*i)); } 5497 } 5498 5499 TEST(RunFloat64Atan) { 5500 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5501 m.Return(m.Float64Atan(m.Parameter(0))); 5502 CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN()))); 5503 CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN()))); 5504 CHECK_DOUBLE_EQ(-0.0, m.Call(-0.0)); 5505 CHECK_DOUBLE_EQ(0.0, m.Call(0.0)); 5506 FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::atan(*i), m.Call(*i)); } 5507 } 5508 5509 TEST(RunFloat64Atan2) { 5510 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64(), 5511 MachineType::Float64()); 5512 m.Return(m.Float64Atan2(m.Parameter(0), m.Parameter(1))); 5513 FOR_FLOAT64_INPUTS(i) { 5514 FOR_FLOAT64_INPUTS(j) { 5515 CHECK_DOUBLE_EQ(ieee754::atan2(*i, *j), m.Call(*i, *j)); 5516 } 5517 } 5518 } 5519 5520 TEST(RunFloat64Atanh) { 5521 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5522 m.Return(m.Float64Atanh(m.Parameter(0))); 5523 CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN()))); 5524 CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN()))); 5525 CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(), m.Call(1.0)); 5526 CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-1.0)); 5527 CHECK_DOUBLE_EQ(-0.0, m.Call(-0.0)); 5528 CHECK_DOUBLE_EQ(0.0, m.Call(0.0)); 5529 FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::atanh(*i), m.Call(*i)); } 5530 } 5531 5532 TEST(RunFloat64Cos) { 5533 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5534 m.Return(m.Float64Cos(m.Parameter(0))); 5535 CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN()))); 5536 CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN()))); 5537 FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::cos(*i), m.Call(*i)); } 5538 } 5539 5540 TEST(RunFloat64Exp) { 5541 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5542 m.Return(m.Float64Exp(m.Parameter(0))); 5543 CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN()))); 5544 CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN()))); 5545 CHECK_EQ(0.0, m.Call(-std::numeric_limits<double>::infinity())); 5546 CHECK_DOUBLE_EQ(1.0, m.Call(-0.0)); 5547 CHECK_DOUBLE_EQ(1.0, m.Call(0.0)); 5548 CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(), 5549 m.Call(std::numeric_limits<double>::infinity())); 5550 FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::exp(*i), m.Call(*i)); } 5551 } 5552 5553 TEST(RunFloat64Expm1) { 5554 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5555 m.Return(m.Float64Expm1(m.Parameter(0))); 5556 CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN()))); 5557 CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN()))); 5558 CHECK_EQ(-1.0, m.Call(-std::numeric_limits<double>::infinity())); 5559 CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(), 5560 m.Call(std::numeric_limits<double>::infinity())); 5561 FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::expm1(*i), m.Call(*i)); } 5562 } 5563 5564 TEST(RunFloat64Log) { 5565 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5566 m.Return(m.Float64Log(m.Parameter(0))); 5567 CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN()))); 5568 CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN()))); 5569 CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity()))); 5570 CHECK(std::isnan(m.Call(-1.0))); 5571 CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-0.0)); 5572 CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(0.0)); 5573 CHECK_DOUBLE_EQ(0.0, m.Call(1.0)); 5574 CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(), 5575 m.Call(std::numeric_limits<double>::infinity())); 5576 FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::log(*i), m.Call(*i)); } 5577 } 5578 5579 TEST(RunFloat64Log1p) { 5580 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5581 m.Return(m.Float64Log1p(m.Parameter(0))); 5582 CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN()))); 5583 CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN()))); 5584 CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity()))); 5585 CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-1.0)); 5586 CHECK_DOUBLE_EQ(0.0, m.Call(0.0)); 5587 CHECK_DOUBLE_EQ(-0.0, m.Call(-0.0)); 5588 CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(), 5589 m.Call(std::numeric_limits<double>::infinity())); 5590 FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::log1p(*i), m.Call(*i)); } 5591 } 5592 5593 TEST(RunFloat64Log2) { 5594 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5595 m.Return(m.Float64Log2(m.Parameter(0))); 5596 CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN()))); 5597 CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN()))); 5598 CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity()))); 5599 CHECK(std::isnan(m.Call(-1.0))); 5600 CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-0.0)); 5601 CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(0.0)); 5602 CHECK_DOUBLE_EQ(0.0, m.Call(1.0)); 5603 CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(), 5604 m.Call(std::numeric_limits<double>::infinity())); 5605 FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::log2(*i), m.Call(*i)); } 5606 } 5607 5608 TEST(RunFloat64Log10) { 5609 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5610 m.Return(m.Float64Log10(m.Parameter(0))); 5611 CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN()))); 5612 CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN()))); 5613 CHECK(std::isnan(m.Call(-std::numeric_limits<double>::infinity()))); 5614 CHECK(std::isnan(m.Call(-1.0))); 5615 CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(-0.0)); 5616 CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), m.Call(0.0)); 5617 CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(), 5618 m.Call(std::numeric_limits<double>::infinity())); 5619 FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::log10(*i), m.Call(*i)); } 5620 } 5621 5622 TEST(RunFloat64Cbrt) { 5623 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5624 m.Return(m.Float64Cbrt(m.Parameter(0))); 5625 CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN()))); 5626 CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN()))); 5627 CHECK_DOUBLE_EQ(std::numeric_limits<double>::infinity(), 5628 m.Call(std::numeric_limits<double>::infinity())); 5629 CHECK_DOUBLE_EQ(-std::numeric_limits<double>::infinity(), 5630 m.Call(-std::numeric_limits<double>::infinity())); 5631 FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::cbrt(*i), m.Call(*i)); } 5632 } 5633 5634 TEST(RunFloat64Sin) { 5635 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5636 m.Return(m.Float64Sin(m.Parameter(0))); 5637 CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN()))); 5638 CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN()))); 5639 FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::sin(*i), m.Call(*i)); } 5640 } 5641 5642 TEST(RunFloat64Tan) { 5643 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5644 m.Return(m.Float64Tan(m.Parameter(0))); 5645 CHECK(std::isnan(m.Call(std::numeric_limits<double>::quiet_NaN()))); 5646 CHECK(std::isnan(m.Call(std::numeric_limits<double>::signaling_NaN()))); 5647 FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ieee754::tan(*i), m.Call(*i)); } 5648 } 5649 5650 static double two_30 = 1 << 30; // 2^30 is a smi boundary. 5651 static double two_52 = two_30 * (1 << 22); // 2^52 is a precision boundary. 5652 static double kValues[] = {0.1, 5653 0.2, 5654 0.49999999999999994, 5655 0.5, 5656 0.7, 5657 1.0 - std::numeric_limits<double>::epsilon(), 5658 -0.1, 5659 -0.49999999999999994, 5660 -0.5, 5661 -0.7, 5662 1.1, 5663 1.0 + std::numeric_limits<double>::epsilon(), 5664 1.5, 5665 1.7, 5666 -1, 5667 -1 + std::numeric_limits<double>::epsilon(), 5668 -1 - std::numeric_limits<double>::epsilon(), 5669 -1.1, 5670 -1.5, 5671 -1.7, 5672 std::numeric_limits<double>::min(), 5673 -std::numeric_limits<double>::min(), 5674 std::numeric_limits<double>::max(), 5675 -std::numeric_limits<double>::max(), 5676 std::numeric_limits<double>::infinity(), 5677 -std::numeric_limits<double>::infinity(), 5678 two_30, 5679 two_30 + 0.1, 5680 two_30 + 0.5, 5681 two_30 + 0.7, 5682 two_30 - 1, 5683 two_30 - 1 + 0.1, 5684 two_30 - 1 + 0.5, 5685 two_30 - 1 + 0.7, 5686 -two_30, 5687 -two_30 + 0.1, 5688 -two_30 + 0.5, 5689 -two_30 + 0.7, 5690 -two_30 + 1, 5691 -two_30 + 1 + 0.1, 5692 -two_30 + 1 + 0.5, 5693 -two_30 + 1 + 0.7, 5694 two_52, 5695 two_52 + 0.1, 5696 two_52 + 0.5, 5697 two_52 + 0.5, 5698 two_52 + 0.7, 5699 two_52 + 0.7, 5700 two_52 - 1, 5701 two_52 - 1 + 0.1, 5702 two_52 - 1 + 0.5, 5703 two_52 - 1 + 0.7, 5704 -two_52, 5705 -two_52 + 0.1, 5706 -two_52 + 0.5, 5707 -two_52 + 0.7, 5708 -two_52 + 1, 5709 -two_52 + 1 + 0.1, 5710 -two_52 + 1 + 0.5, 5711 -two_52 + 1 + 0.7, 5712 two_30, 5713 two_30 - 0.1, 5714 two_30 - 0.5, 5715 two_30 - 0.7, 5716 two_30 - 1, 5717 two_30 - 1 - 0.1, 5718 two_30 - 1 - 0.5, 5719 two_30 - 1 - 0.7, 5720 -two_30, 5721 -two_30 - 0.1, 5722 -two_30 - 0.5, 5723 -two_30 - 0.7, 5724 -two_30 + 1, 5725 -two_30 + 1 - 0.1, 5726 -two_30 + 1 - 0.5, 5727 -two_30 + 1 - 0.7, 5728 two_52, 5729 two_52 - 0.1, 5730 two_52 - 0.5, 5731 two_52 - 0.5, 5732 two_52 - 0.7, 5733 two_52 - 0.7, 5734 two_52 - 1, 5735 two_52 - 1 - 0.1, 5736 two_52 - 1 - 0.5, 5737 two_52 - 1 - 0.7, 5738 -two_52, 5739 -two_52 - 0.1, 5740 -two_52 - 0.5, 5741 -two_52 - 0.7, 5742 -two_52 + 1, 5743 -two_52 + 1 - 0.1, 5744 -two_52 + 1 - 0.5, 5745 -two_52 + 1 - 0.7}; 5746 5747 5748 TEST(RunFloat32RoundDown) { 5749 BufferedRawMachineAssemblerTester<float> m(MachineType::Float32()); 5750 if (!m.machine()->Float32RoundDown().IsSupported()) return; 5751 5752 m.Return(m.Float32RoundDown(m.Parameter(0))); 5753 5754 FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(floorf(*i), m.Call(*i)); } 5755 } 5756 5757 5758 TEST(RunFloat64RoundDown1) { 5759 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5760 if (!m.machine()->Float64RoundDown().IsSupported()) return; 5761 5762 m.Return(m.Float64RoundDown(m.Parameter(0))); 5763 5764 FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(floor(*i), m.Call(*i)); } 5765 } 5766 5767 5768 TEST(RunFloat64RoundDown2) { 5769 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5770 if (!m.machine()->Float64RoundDown().IsSupported()) return; 5771 m.Return(m.Float64Sub(m.Float64Constant(-0.0), 5772 m.Float64RoundDown(m.Float64Sub(m.Float64Constant(-0.0), 5773 m.Parameter(0))))); 5774 5775 for (size_t i = 0; i < arraysize(kValues); ++i) { 5776 CHECK_EQ(ceil(kValues[i]), m.Call(kValues[i])); 5777 } 5778 } 5779 5780 5781 TEST(RunFloat32RoundUp) { 5782 BufferedRawMachineAssemblerTester<float> m(MachineType::Float32()); 5783 if (!m.machine()->Float32RoundUp().IsSupported()) return; 5784 m.Return(m.Float32RoundUp(m.Parameter(0))); 5785 5786 FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(ceilf(*i), m.Call(*i)); } 5787 } 5788 5789 5790 TEST(RunFloat64RoundUp) { 5791 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5792 if (!m.machine()->Float64RoundUp().IsSupported()) return; 5793 m.Return(m.Float64RoundUp(m.Parameter(0))); 5794 5795 FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(ceil(*i), m.Call(*i)); } 5796 } 5797 5798 5799 TEST(RunFloat32RoundTiesEven) { 5800 BufferedRawMachineAssemblerTester<float> m(MachineType::Float32()); 5801 if (!m.machine()->Float32RoundTiesEven().IsSupported()) return; 5802 m.Return(m.Float32RoundTiesEven(m.Parameter(0))); 5803 5804 FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(nearbyint(*i), m.Call(*i)); } 5805 } 5806 5807 5808 TEST(RunFloat64RoundTiesEven) { 5809 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5810 if (!m.machine()->Float64RoundTiesEven().IsSupported()) return; 5811 m.Return(m.Float64RoundTiesEven(m.Parameter(0))); 5812 5813 FOR_FLOAT64_INPUTS(i) { CHECK_DOUBLE_EQ(nearbyint(*i), m.Call(*i)); } 5814 } 5815 5816 5817 TEST(RunFloat32RoundTruncate) { 5818 BufferedRawMachineAssemblerTester<float> m(MachineType::Float32()); 5819 if (!m.machine()->Float32RoundTruncate().IsSupported()) return; 5820 5821 m.Return(m.Float32RoundTruncate(m.Parameter(0))); 5822 5823 FOR_FLOAT32_INPUTS(i) { CHECK_FLOAT_EQ(truncf(*i), m.Call(*i)); } 5824 } 5825 5826 5827 TEST(RunFloat64RoundTruncate) { 5828 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5829 if (!m.machine()->Float64RoundTruncate().IsSupported()) return; 5830 m.Return(m.Float64RoundTruncate(m.Parameter(0))); 5831 for (size_t i = 0; i < arraysize(kValues); ++i) { 5832 CHECK_EQ(trunc(kValues[i]), m.Call(kValues[i])); 5833 } 5834 } 5835 5836 5837 TEST(RunFloat64RoundTiesAway) { 5838 BufferedRawMachineAssemblerTester<double> m(MachineType::Float64()); 5839 if (!m.machine()->Float64RoundTiesAway().IsSupported()) return; 5840 m.Return(m.Float64RoundTiesAway(m.Parameter(0))); 5841 for (size_t i = 0; i < arraysize(kValues); ++i) { 5842 CHECK_EQ(round(kValues[i]), m.Call(kValues[i])); 5843 } 5844 } 5845 5846 5847 #if !USE_SIMULATOR 5848 5849 namespace { 5850 5851 int32_t const kMagicFoo0 = 0xdeadbeef; 5852 5853 5854 int32_t foo0() { return kMagicFoo0; } 5855 5856 5857 int32_t foo1(int32_t x) { return x; } 5858 5859 5860 int32_t foo2(int32_t x, int32_t y) { return x - y; } 5861 5862 5863 int32_t foo8(int32_t a, int32_t b, int32_t c, int32_t d, int32_t e, int32_t f, 5864 int32_t g, int32_t h) { 5865 return a + b + c + d + e + f + g + h; 5866 } 5867 5868 } // namespace 5869 5870 5871 TEST(RunCallCFunction0) { 5872 auto* foo0_ptr = &foo0; 5873 RawMachineAssemblerTester<int32_t> m; 5874 Node* function = m.LoadFromPointer(&foo0_ptr, MachineType::Pointer()); 5875 m.Return(m.CallCFunction0(MachineType::Int32(), function)); 5876 CHECK_EQ(kMagicFoo0, m.Call()); 5877 } 5878 5879 5880 TEST(RunCallCFunction1) { 5881 auto* foo1_ptr = &foo1; 5882 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 5883 Node* function = m.LoadFromPointer(&foo1_ptr, MachineType::Pointer()); 5884 m.Return(m.CallCFunction1(MachineType::Int32(), MachineType::Int32(), 5885 function, m.Parameter(0))); 5886 FOR_INT32_INPUTS(i) { 5887 int32_t const expected = *i; 5888 CHECK_EQ(expected, m.Call(expected)); 5889 } 5890 } 5891 5892 5893 TEST(RunCallCFunction2) { 5894 auto* foo2_ptr = &foo2; 5895 RawMachineAssemblerTester<int32_t> m(MachineType::Int32(), 5896 MachineType::Int32()); 5897 Node* function = m.LoadFromPointer(&foo2_ptr, MachineType::Pointer()); 5898 m.Return(m.CallCFunction2(MachineType::Int32(), MachineType::Int32(), 5899 MachineType::Int32(), function, m.Parameter(0), 5900 m.Parameter(1))); 5901 FOR_INT32_INPUTS(i) { 5902 int32_t const x = *i; 5903 FOR_INT32_INPUTS(j) { 5904 int32_t const y = *j; 5905 CHECK_EQ(x - y, m.Call(x, y)); 5906 } 5907 } 5908 } 5909 5910 5911 TEST(RunCallCFunction8) { 5912 auto* foo8_ptr = &foo8; 5913 RawMachineAssemblerTester<int32_t> m(MachineType::Int32()); 5914 Node* function = m.LoadFromPointer(&foo8_ptr, MachineType::Pointer()); 5915 Node* param = m.Parameter(0); 5916 m.Return(m.CallCFunction8( 5917 MachineType::Int32(), MachineType::Int32(), MachineType::Int32(), 5918 MachineType::Int32(), MachineType::Int32(), MachineType::Int32(), 5919 MachineType::Int32(), MachineType::Int32(), MachineType::Int32(), 5920 function, param, param, param, param, param, param, param, param)); 5921 FOR_INT32_INPUTS(i) { 5922 int32_t const x = *i; 5923 CHECK_EQ(x * 8, m.Call(x)); 5924 } 5925 } 5926 #endif // USE_SIMULATOR 5927 5928 #if V8_TARGET_ARCH_64_BIT 5929 // TODO(titzer): run int64 tests on all platforms when supported. 5930 5931 TEST(RunBitcastInt64ToFloat64) { 5932 int64_t input = 1; 5933 double output = 0.0; 5934 RawMachineAssemblerTester<int32_t> m; 5935 m.StoreToPointer( 5936 &output, MachineRepresentation::kFloat64, 5937 m.BitcastInt64ToFloat64(m.LoadFromPointer(&input, MachineType::Int64()))); 5938 m.Return(m.Int32Constant(11)); 5939 FOR_INT64_INPUTS(i) { 5940 input = *i; 5941 CHECK_EQ(11, m.Call()); 5942 double expected = bit_cast<double>(input); 5943 CHECK_EQ(bit_cast<int64_t>(expected), bit_cast<int64_t>(output)); 5944 } 5945 } 5946 5947 5948 TEST(RunBitcastFloat64ToInt64) { 5949 BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float64()); 5950 5951 m.Return(m.BitcastFloat64ToInt64(m.Parameter(0))); 5952 FOR_FLOAT64_INPUTS(i) { CHECK_EQ(bit_cast<int64_t>(*i), m.Call(*i)); } 5953 } 5954 5955 5956 TEST(RunTryTruncateFloat32ToInt64WithoutCheck) { 5957 BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float32()); 5958 m.Return(m.TryTruncateFloat32ToInt64(m.Parameter(0))); 5959 5960 FOR_INT64_INPUTS(i) { 5961 float input = static_cast<float>(*i); 5962 if (input < static_cast<float>(INT64_MAX) && 5963 input >= static_cast<float>(INT64_MIN)) { 5964 CHECK_EQ(static_cast<int64_t>(input), m.Call(input)); 5965 } 5966 } 5967 } 5968 5969 5970 TEST(RunTryTruncateFloat32ToInt64WithCheck) { 5971 int64_t success = 0; 5972 BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float32()); 5973 Node* trunc = m.TryTruncateFloat32ToInt64(m.Parameter(0)); 5974 Node* val = m.Projection(0, trunc); 5975 Node* check = m.Projection(1, trunc); 5976 m.StoreToPointer(&success, MachineRepresentation::kWord64, check); 5977 m.Return(val); 5978 5979 FOR_FLOAT32_INPUTS(i) { 5980 if (*i < static_cast<float>(INT64_MAX) && 5981 *i >= static_cast<float>(INT64_MIN)) { 5982 CHECK_EQ(static_cast<int64_t>(*i), m.Call(*i)); 5983 CHECK_NE(0, success); 5984 } else { 5985 m.Call(*i); 5986 CHECK_EQ(0, success); 5987 } 5988 } 5989 } 5990 5991 5992 TEST(RunTryTruncateFloat64ToInt64WithoutCheck) { 5993 BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float64()); 5994 m.Return(m.TryTruncateFloat64ToInt64(m.Parameter(0))); 5995 5996 FOR_INT64_INPUTS(i) { 5997 double input = static_cast<double>(*i); 5998 CHECK_EQ(static_cast<int64_t>(input), m.Call(input)); 5999 } 6000 } 6001 6002 6003 TEST(RunTryTruncateFloat64ToInt64WithCheck) { 6004 int64_t success = 0; 6005 BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float64()); 6006 Node* trunc = m.TryTruncateFloat64ToInt64(m.Parameter(0)); 6007 Node* val = m.Projection(0, trunc); 6008 Node* check = m.Projection(1, trunc); 6009 m.StoreToPointer(&success, MachineRepresentation::kWord64, check); 6010 m.Return(val); 6011 6012 FOR_FLOAT64_INPUTS(i) { 6013 if (*i < static_cast<double>(INT64_MAX) && 6014 *i >= static_cast<double>(INT64_MIN)) { 6015 // Conversions within this range should succeed. 6016 CHECK_EQ(static_cast<int64_t>(*i), m.Call(*i)); 6017 CHECK_NE(0, success); 6018 } else { 6019 m.Call(*i); 6020 CHECK_EQ(0, success); 6021 } 6022 } 6023 } 6024 6025 6026 TEST(RunTryTruncateFloat32ToUint64WithoutCheck) { 6027 BufferedRawMachineAssemblerTester<uint64_t> m(MachineType::Float32()); 6028 m.Return(m.TryTruncateFloat32ToUint64(m.Parameter(0))); 6029 6030 FOR_UINT64_INPUTS(i) { 6031 float input = static_cast<float>(*i); 6032 // This condition on 'input' is required because 6033 // static_cast<float>(UINT64_MAX) results in a value outside uint64 range. 6034 if (input < static_cast<float>(UINT64_MAX)) { 6035 CHECK_EQ(static_cast<uint64_t>(input), m.Call(input)); 6036 } 6037 } 6038 } 6039 6040 6041 TEST(RunTryTruncateFloat32ToUint64WithCheck) { 6042 int64_t success = 0; 6043 BufferedRawMachineAssemblerTester<uint64_t> m(MachineType::Float32()); 6044 Node* trunc = m.TryTruncateFloat32ToUint64(m.Parameter(0)); 6045 Node* val = m.Projection(0, trunc); 6046 Node* check = m.Projection(1, trunc); 6047 m.StoreToPointer(&success, MachineRepresentation::kWord64, check); 6048 m.Return(val); 6049 6050 FOR_FLOAT32_INPUTS(i) { 6051 if (*i < static_cast<float>(UINT64_MAX) && *i > -1.0) { 6052 // Conversions within this range should succeed. 6053 CHECK_EQ(static_cast<uint64_t>(*i), m.Call(*i)); 6054 CHECK_NE(0, success); 6055 } else { 6056 m.Call(*i); 6057 CHECK_EQ(0, success); 6058 } 6059 } 6060 } 6061 6062 6063 TEST(RunTryTruncateFloat64ToUint64WithoutCheck) { 6064 BufferedRawMachineAssemblerTester<uint64_t> m(MachineType::Float64()); 6065 m.Return(m.TryTruncateFloat64ToUint64(m.Parameter(0))); 6066 6067 FOR_UINT64_INPUTS(j) { 6068 double input = static_cast<double>(*j); 6069 6070 if (input < static_cast<float>(UINT64_MAX)) { 6071 CHECK_EQ(static_cast<uint64_t>(input), m.Call(input)); 6072 } 6073 } 6074 } 6075 6076 6077 TEST(RunTryTruncateFloat64ToUint64WithCheck) { 6078 int64_t success = 0; 6079 BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Float64()); 6080 Node* trunc = m.TryTruncateFloat64ToUint64(m.Parameter(0)); 6081 Node* val = m.Projection(0, trunc); 6082 Node* check = m.Projection(1, trunc); 6083 m.StoreToPointer(&success, MachineRepresentation::kWord64, check); 6084 m.Return(val); 6085 6086 FOR_FLOAT64_INPUTS(i) { 6087 if (*i < 18446744073709551616.0 && *i > -1) { 6088 // Conversions within this range should succeed. 6089 CHECK_EQ(static_cast<uint64_t>(*i), m.Call(*i)); 6090 CHECK_NE(0, success); 6091 } else { 6092 m.Call(*i); 6093 CHECK_EQ(0, success); 6094 } 6095 } 6096 } 6097 6098 6099 TEST(RunRoundInt64ToFloat32) { 6100 BufferedRawMachineAssemblerTester<float> m(MachineType::Int64()); 6101 m.Return(m.RoundInt64ToFloat32(m.Parameter(0))); 6102 FOR_INT64_INPUTS(i) { CHECK_EQ(static_cast<float>(*i), m.Call(*i)); } 6103 } 6104 6105 6106 TEST(RunRoundInt64ToFloat64) { 6107 BufferedRawMachineAssemblerTester<double> m(MachineType::Int64()); 6108 m.Return(m.RoundInt64ToFloat64(m.Parameter(0))); 6109 FOR_INT64_INPUTS(i) { CHECK_EQ(static_cast<double>(*i), m.Call(*i)); } 6110 } 6111 6112 6113 TEST(RunRoundUint64ToFloat64) { 6114 struct { 6115 uint64_t input; 6116 uint64_t expected; 6117 } values[] = {{0x0, 0x0}, 6118 {0x1, 0x3ff0000000000000}, 6119 {0xffffffff, 0x41efffffffe00000}, 6120 {0x1b09788b, 0x41bb09788b000000}, 6121 {0x4c5fce8, 0x419317f3a0000000}, 6122 {0xcc0de5bf, 0x41e981bcb7e00000}, 6123 {0x2, 0x4000000000000000}, 6124 {0x3, 0x4008000000000000}, 6125 {0x4, 0x4010000000000000}, 6126 {0x5, 0x4014000000000000}, 6127 {0x8, 0x4020000000000000}, 6128 {0x9, 0x4022000000000000}, 6129 {0xffffffffffffffff, 0x43f0000000000000}, 6130 {0xfffffffffffffffe, 0x43f0000000000000}, 6131 {0xfffffffffffffffd, 0x43f0000000000000}, 6132 {0x100000000, 0x41f0000000000000}, 6133 {0xffffffff00000000, 0x43efffffffe00000}, 6134 {0x1b09788b00000000, 0x43bb09788b000000}, 6135 {0x4c5fce800000000, 0x439317f3a0000000}, 6136 {0xcc0de5bf00000000, 0x43e981bcb7e00000}, 6137 {0x200000000, 0x4200000000000000}, 6138 {0x300000000, 0x4208000000000000}, 6139 {0x400000000, 0x4210000000000000}, 6140 {0x500000000, 0x4214000000000000}, 6141 {0x800000000, 0x4220000000000000}, 6142 {0x900000000, 0x4222000000000000}, 6143 {0x273a798e187937a3, 0x43c39d3cc70c3c9c}, 6144 {0xece3af835495a16b, 0x43ed9c75f06a92b4}, 6145 {0xb668ecc11223344, 0x43a6cd1d98224467}, 6146 {0x9e, 0x4063c00000000000}, 6147 {0x43, 0x4050c00000000000}, 6148 {0xaf73, 0x40e5ee6000000000}, 6149 {0x116b, 0x40b16b0000000000}, 6150 {0x658ecc, 0x415963b300000000}, 6151 {0x2b3b4c, 0x41459da600000000}, 6152 {0x88776655, 0x41e10eeccaa00000}, 6153 {0x70000000, 0x41dc000000000000}, 6154 {0x7200000, 0x419c800000000000}, 6155 {0x7fffffff, 0x41dfffffffc00000}, 6156 {0x56123761, 0x41d5848dd8400000}, 6157 {0x7fffff00, 0x41dfffffc0000000}, 6158 {0x761c4761eeeeeeee, 0x43dd8711d87bbbbc}, 6159 {0x80000000eeeeeeee, 0x43e00000001dddde}, 6160 {0x88888888dddddddd, 0x43e11111111bbbbc}, 6161 {0xa0000000dddddddd, 0x43e40000001bbbbc}, 6162 {0xddddddddaaaaaaaa, 0x43ebbbbbbbb55555}, 6163 {0xe0000000aaaaaaaa, 0x43ec000000155555}, 6164 {0xeeeeeeeeeeeeeeee, 0x43edddddddddddde}, 6165 {0xfffffffdeeeeeeee, 0x43efffffffbdddde}, 6166 {0xf0000000dddddddd, 0x43ee0000001bbbbc}, 6167 {0x7fffffdddddddd, 0x435ffffff7777777}, 6168 {0x3fffffaaaaaaaa, 0x434fffffd5555555}, 6169 {0x1fffffaaaaaaaa, 0x433fffffaaaaaaaa}, 6170 {0xfffff, 0x412ffffe00000000}, 6171 {0x7ffff, 0x411ffffc00000000}, 6172 {0x3ffff, 0x410ffff800000000}, 6173 {0x1ffff, 0x40fffff000000000}, 6174 {0xffff, 0x40efffe000000000}, 6175 {0x7fff, 0x40dfffc000000000}, 6176 {0x3fff, 0x40cfff8000000000}, 6177 {0x1fff, 0x40bfff0000000000}, 6178 {0xfff, 0x40affe0000000000}, 6179 {0x7ff, 0x409ffc0000000000}, 6180 {0x3ff, 0x408ff80000000000}, 6181 {0x1ff, 0x407ff00000000000}, 6182 {0x3fffffffffff, 0x42cfffffffffff80}, 6183 {0x1fffffffffff, 0x42bfffffffffff00}, 6184 {0xfffffffffff, 0x42affffffffffe00}, 6185 {0x7ffffffffff, 0x429ffffffffffc00}, 6186 {0x3ffffffffff, 0x428ffffffffff800}, 6187 {0x1ffffffffff, 0x427ffffffffff000}, 6188 {0x8000008000000000, 0x43e0000010000000}, 6189 {0x8000008000000001, 0x43e0000010000000}, 6190 {0x8000000000000400, 0x43e0000000000000}, 6191 {0x8000000000000401, 0x43e0000000000001}}; 6192 6193 BufferedRawMachineAssemblerTester<double> m(MachineType::Uint64()); 6194 m.Return(m.RoundUint64ToFloat64(m.Parameter(0))); 6195 6196 for (size_t i = 0; i < arraysize(values); i++) { 6197 CHECK_EQ(bit_cast<double>(values[i].expected), m.Call(values[i].input)); 6198 } 6199 } 6200 6201 6202 TEST(RunRoundUint64ToFloat32) { 6203 struct { 6204 uint64_t input; 6205 uint32_t expected; 6206 } values[] = {{0x0, 0x0}, 6207 {0x1, 0x3f800000}, 6208 {0xffffffff, 0x4f800000}, 6209 {0x1b09788b, 0x4dd84bc4}, 6210 {0x4c5fce8, 0x4c98bf9d}, 6211 {0xcc0de5bf, 0x4f4c0de6}, 6212 {0x2, 0x40000000}, 6213 {0x3, 0x40400000}, 6214 {0x4, 0x40800000}, 6215 {0x5, 0x40a00000}, 6216 {0x8, 0x41000000}, 6217 {0x9, 0x41100000}, 6218 {0xffffffffffffffff, 0x5f800000}, 6219 {0xfffffffffffffffe, 0x5f800000}, 6220 {0xfffffffffffffffd, 0x5f800000}, 6221 {0x0, 0x0}, 6222 {0x100000000, 0x4f800000}, 6223 {0xffffffff00000000, 0x5f800000}, 6224 {0x1b09788b00000000, 0x5dd84bc4}, 6225 {0x4c5fce800000000, 0x5c98bf9d}, 6226 {0xcc0de5bf00000000, 0x5f4c0de6}, 6227 {0x200000000, 0x50000000}, 6228 {0x300000000, 0x50400000}, 6229 {0x400000000, 0x50800000}, 6230 {0x500000000, 0x50a00000}, 6231 {0x800000000, 0x51000000}, 6232 {0x900000000, 0x51100000}, 6233 {0x273a798e187937a3, 0x5e1ce9e6}, 6234 {0xece3af835495a16b, 0x5f6ce3b0}, 6235 {0xb668ecc11223344, 0x5d3668ed}, 6236 {0x9e, 0x431e0000}, 6237 {0x43, 0x42860000}, 6238 {0xaf73, 0x472f7300}, 6239 {0x116b, 0x458b5800}, 6240 {0x658ecc, 0x4acb1d98}, 6241 {0x2b3b4c, 0x4a2ced30}, 6242 {0x88776655, 0x4f087766}, 6243 {0x70000000, 0x4ee00000}, 6244 {0x7200000, 0x4ce40000}, 6245 {0x7fffffff, 0x4f000000}, 6246 {0x56123761, 0x4eac246f}, 6247 {0x7fffff00, 0x4efffffe}, 6248 {0x761c4761eeeeeeee, 0x5eec388f}, 6249 {0x80000000eeeeeeee, 0x5f000000}, 6250 {0x88888888dddddddd, 0x5f088889}, 6251 {0xa0000000dddddddd, 0x5f200000}, 6252 {0xddddddddaaaaaaaa, 0x5f5dddde}, 6253 {0xe0000000aaaaaaaa, 0x5f600000}, 6254 {0xeeeeeeeeeeeeeeee, 0x5f6eeeef}, 6255 {0xfffffffdeeeeeeee, 0x5f800000}, 6256 {0xf0000000dddddddd, 0x5f700000}, 6257 {0x7fffffdddddddd, 0x5b000000}, 6258 {0x3fffffaaaaaaaa, 0x5a7fffff}, 6259 {0x1fffffaaaaaaaa, 0x59fffffd}, 6260 {0xfffff, 0x497ffff0}, 6261 {0x7ffff, 0x48ffffe0}, 6262 {0x3ffff, 0x487fffc0}, 6263 {0x1ffff, 0x47ffff80}, 6264 {0xffff, 0x477fff00}, 6265 {0x7fff, 0x46fffe00}, 6266 {0x3fff, 0x467ffc00}, 6267 {0x1fff, 0x45fff800}, 6268 {0xfff, 0x457ff000}, 6269 {0x7ff, 0x44ffe000}, 6270 {0x3ff, 0x447fc000}, 6271 {0x1ff, 0x43ff8000}, 6272 {0x3fffffffffff, 0x56800000}, 6273 {0x1fffffffffff, 0x56000000}, 6274 {0xfffffffffff, 0x55800000}, 6275 {0x7ffffffffff, 0x55000000}, 6276 {0x3ffffffffff, 0x54800000}, 6277 {0x1ffffffffff, 0x54000000}, 6278 {0x8000008000000000, 0x5f000000}, 6279 {0x8000008000000001, 0x5f000001}, 6280 {0x8000000000000400, 0x5f000000}, 6281 {0x8000000000000401, 0x5f000000}}; 6282 6283 BufferedRawMachineAssemblerTester<float> m(MachineType::Uint64()); 6284 m.Return(m.RoundUint64ToFloat32(m.Parameter(0))); 6285 6286 for (size_t i = 0; i < arraysize(values); i++) { 6287 CHECK_EQ(bit_cast<float>(values[i].expected), m.Call(values[i].input)); 6288 } 6289 } 6290 6291 6292 #endif 6293 6294 6295 TEST(RunBitcastFloat32ToInt32) { 6296 float input = 32.25; 6297 RawMachineAssemblerTester<int32_t> m; 6298 m.Return(m.BitcastFloat32ToInt32( 6299 m.LoadFromPointer(&input, MachineType::Float32()))); 6300 FOR_FLOAT32_INPUTS(i) { 6301 input = *i; 6302 int32_t expected = bit_cast<int32_t>(input); 6303 CHECK_EQ(expected, m.Call()); 6304 } 6305 } 6306 6307 6308 TEST(RunRoundInt32ToFloat32) { 6309 BufferedRawMachineAssemblerTester<float> m(MachineType::Int32()); 6310 m.Return(m.RoundInt32ToFloat32(m.Parameter(0))); 6311 FOR_INT32_INPUTS(i) { 6312 volatile float expected = static_cast<float>(*i); 6313 CHECK_EQ(expected, m.Call(*i)); 6314 } 6315 } 6316 6317 6318 TEST(RunRoundUint32ToFloat32) { 6319 BufferedRawMachineAssemblerTester<float> m(MachineType::Uint32()); 6320 m.Return(m.RoundUint32ToFloat32(m.Parameter(0))); 6321 FOR_UINT32_INPUTS(i) { 6322 volatile float expected = static_cast<float>(*i); 6323 CHECK_EQ(expected, m.Call(*i)); 6324 } 6325 } 6326 6327 6328 TEST(RunBitcastInt32ToFloat32) { 6329 int32_t input = 1; 6330 float output = 0.0; 6331 RawMachineAssemblerTester<int32_t> m; 6332 m.StoreToPointer( 6333 &output, MachineRepresentation::kFloat32, 6334 m.BitcastInt32ToFloat32(m.LoadFromPointer(&input, MachineType::Int32()))); 6335 m.Return(m.Int32Constant(11)); 6336 FOR_INT32_INPUTS(i) { 6337 input = *i; 6338 CHECK_EQ(11, m.Call()); 6339 float expected = bit_cast<float>(input); 6340 CHECK_EQ(bit_cast<int32_t>(expected), bit_cast<int32_t>(output)); 6341 } 6342 } 6343 6344 6345 TEST(RunComputedCodeObject) { 6346 GraphBuilderTester<int32_t> a; 6347 a.Return(a.Int32Constant(33)); 6348 a.End(); 6349 Handle<Code> code_a = a.GetCode(); 6350 6351 GraphBuilderTester<int32_t> b; 6352 b.Return(b.Int32Constant(44)); 6353 b.End(); 6354 Handle<Code> code_b = b.GetCode(); 6355 6356 RawMachineAssemblerTester<int32_t> r(MachineType::Int32()); 6357 RawMachineLabel tlabel; 6358 RawMachineLabel flabel; 6359 RawMachineLabel merge; 6360 r.Branch(r.Parameter(0), &tlabel, &flabel); 6361 r.Bind(&tlabel); 6362 Node* fa = r.HeapConstant(code_a); 6363 r.Goto(&merge); 6364 r.Bind(&flabel); 6365 Node* fb = r.HeapConstant(code_b); 6366 r.Goto(&merge); 6367 r.Bind(&merge); 6368 Node* phi = r.Phi(MachineRepresentation::kWord32, fa, fb); 6369 6370 // TODO(titzer): all this descriptor hackery is just to call the above 6371 // functions as code objects instead of direct addresses. 6372 CSignature0<int32_t> sig; 6373 CallDescriptor* c = Linkage::GetSimplifiedCDescriptor(r.zone(), &sig); 6374 LinkageLocation ret[] = {c->GetReturnLocation(0)}; 6375 Signature<LinkageLocation> loc(1, 0, ret); 6376 CallDescriptor* desc = new (r.zone()) CallDescriptor( // -- 6377 CallDescriptor::kCallCodeObject, // kind 6378 MachineType::AnyTagged(), // target_type 6379 c->GetInputLocation(0), // target_loc 6380 &sig, // machine_sig 6381 &loc, // location_sig 6382 0, // stack count 6383 Operator::kNoProperties, // properties 6384 c->CalleeSavedRegisters(), // callee saved 6385 c->CalleeSavedFPRegisters(), // callee saved FP 6386 CallDescriptor::kNoFlags, // flags 6387 "c-call-as-code"); 6388 Node* call = r.AddNode(r.common()->Call(desc), phi); 6389 r.Return(call); 6390 6391 CHECK_EQ(33, r.Call(1)); 6392 CHECK_EQ(44, r.Call(0)); 6393 } 6394 6395 TEST(ParentFramePointer) { 6396 RawMachineAssemblerTester<int32_t> r(MachineType::Int32()); 6397 RawMachineLabel tlabel; 6398 RawMachineLabel flabel; 6399 RawMachineLabel merge; 6400 Node* frame = r.LoadFramePointer(); 6401 Node* parent_frame = r.LoadParentFramePointer(); 6402 frame = r.Load(MachineType::IntPtr(), frame); 6403 r.Branch(r.WordEqual(frame, parent_frame), &tlabel, &flabel); 6404 r.Bind(&tlabel); 6405 Node* fa = r.Int32Constant(1); 6406 r.Goto(&merge); 6407 r.Bind(&flabel); 6408 Node* fb = r.Int32Constant(0); 6409 r.Goto(&merge); 6410 r.Bind(&merge); 6411 Node* phi = r.Phi(MachineRepresentation::kWord32, fa, fb); 6412 r.Return(phi); 6413 CHECK_EQ(1, r.Call(1)); 6414 } 6415 6416 } // namespace compiler 6417 } // namespace internal 6418 } // namespace v8 6419
