src/v8/test/cctest/compiler/test-run-machops.cc

   1 // Copyright 2014 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <functional>
   6 #include <limits>
   7
   8 #include "src/base/bits.h"
   9 #include "src/compiler/generic-node-inl.h"
  10 #include "test/cctest/cctest.h"
  11 #include "test/cctest/compiler/codegen-tester.h"
  12 #include "test/cctest/compiler/value-helper.h"
  13
  14 #if V8_TURBOFAN_TARGET
  15
  16 using namespace v8::base;
  17
  18 #define CHECK_UINT32_EQ(x, y) \
  19   CHECK_EQ(static_cast<int32_t>(x), static_cast<int32_t>(y))
  20
  21 using namespace v8::internal;
  22 using namespace v8::internal::compiler;
  23
  24 typedef RawMachineAssembler::Label MLabel;
  25
  26 TEST(RunInt32Add) {
  27   RawMachineAssemblerTester<int32_t> m;
  28   Node* add = m.Int32Add(m.Int32Constant(0), m.Int32Constant(1));
  29   m.Return(add);
  30   CHECK_EQ(1, m.Call());
  31 }
  32
  33
  34 static Node* Int32Input(RawMachineAssemblerTester<int32_t>* m, int index) {
  35   switch (index) {
  36     case 0:
  37       return m->Parameter(0);
  38     case 1:
  39       return m->Parameter(1);
  40     case 2:
  41       return m->Int32Constant(0);
  42     case 3:
  43       return m->Int32Constant(1);
  44     case 4:
  45       return m->Int32Constant(-1);
  46     case 5:
  47       return m->Int32Constant(0xff);
  48     case 6:
  49       return m->Int32Constant(0x01234567);
  50     case 7:
  51       return m->Load(kMachInt32, m->PointerConstant(NULL));
  52     default:
  53       return NULL;
  54   }
  55 }
  56
  57
  58 TEST(CodeGenInt32Binop) {
  59   RawMachineAssemblerTester<void> m;
  60
  61   const Operator* ops[] = {
  62       m.machine()->Word32And(),      m.machine()->Word32Or(),
  63       m.machine()->Word32Xor(),      m.machine()->Word32Shl(),
  64       m.machine()->Word32Shr(),      m.machine()->Word32Sar(),
  65       m.machine()->Word32Equal(),    m.machine()->Int32Add(),
  66       m.machine()->Int32Sub(),       m.machine()->Int32Mul(),
  67       m.machine()->Int32Div(),       m.machine()->Int32UDiv(),
  68       m.machine()->Int32Mod(),       m.machine()->Int32UMod(),
  69       m.machine()->Int32LessThan(),  m.machine()->Int32LessThanOrEqual(),
  70       m.machine()->Uint32LessThan(), m.machine()->Uint32LessThanOrEqual(),
  71       NULL};
  72
  73   for (int i = 0; ops[i] != NULL; i++) {
  74     for (int j = 0; j < 8; j++) {
  75       for (int k = 0; k < 8; k++) {
  76         RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
  77         Node* a = Int32Input(&m, j);
  78         Node* b = Int32Input(&m, k);
  79         m.Return(m.NewNode(ops[i], a, b));
  80         m.GenerateCode();
  81       }
  82     }
  83   }
  84 }
  85
  86
  87 TEST(RunGoto) {
  88   RawMachineAssemblerTester<int32_t> m;
  89   int constant = 99999;
  90
  91   MLabel next;
  92   m.Goto(&next);
  93   m.Bind(&next);
  94   m.Return(m.Int32Constant(constant));
  95
  96   CHECK_EQ(constant, m.Call());
  97 }
  98
  99
 100 TEST(RunGotoMultiple) {
 101   RawMachineAssemblerTester<int32_t> m;
 102   int constant = 9999977;
 103
 104   MLabel labels[10];
 105   for (size_t i = 0; i < arraysize(labels); i++) {
 106     m.Goto(&labels[i]);
 107     m.Bind(&labels[i]);
 108   }
 109   m.Return(m.Int32Constant(constant));
 110
 111   CHECK_EQ(constant, m.Call());
 112 }
 113
 114
 115 TEST(RunBranch) {
 116   RawMachineAssemblerTester<int32_t> m;
 117   int constant = 999777;
 118
 119   MLabel blocka, blockb;
 120   m.Branch(m.Int32Constant(0), &blocka, &blockb);
 121   m.Bind(&blocka);
 122   m.Return(m.Int32Constant(0 - constant));
 123   m.Bind(&blockb);
 124   m.Return(m.Int32Constant(constant));
 125
 126   CHECK_EQ(constant, m.Call());
 127 }
 128
 129
 130 TEST(RunRedundantBranch1) {
 131   RawMachineAssemblerTester<int32_t> m;
 132   int constant = 944777;
 133
 134   MLabel blocka;
 135   m.Branch(m.Int32Constant(0), &blocka, &blocka);
 136   m.Bind(&blocka);
 137   m.Return(m.Int32Constant(constant));
 138
 139   CHECK_EQ(constant, m.Call());
 140 }
 141
 142
 143 TEST(RunRedundantBranch2) {
 144   RawMachineAssemblerTester<int32_t> m;
 145   int constant = 955777;
 146
 147   MLabel blocka, blockb;
 148   m.Branch(m.Int32Constant(0), &blocka, &blocka);
 149   m.Bind(&blockb);
 150   m.Goto(&blocka);
 151   m.Bind(&blocka);
 152   m.Return(m.Int32Constant(constant));
 153
 154   CHECK_EQ(constant, m.Call());
 155 }
 156
 157
 158 TEST(RunRedundantBranch3) {
 159   RawMachineAssemblerTester<int32_t> m;
 160   int constant = 966777;
 161
 162   MLabel blocka, blockb, blockc;
 163   m.Branch(m.Int32Constant(0), &blocka, &blockc);
 164   m.Bind(&blocka);
 165   m.Branch(m.Int32Constant(0), &blockb, &blockb);
 166   m.Bind(&blockc);
 167   m.Goto(&blockb);
 168   m.Bind(&blockb);
 169   m.Return(m.Int32Constant(constant));
 170
 171   CHECK_EQ(constant, m.Call());
 172 }
 173
 174
 175 TEST(RunDiamond2) {
 176   RawMachineAssemblerTester<int32_t> m;
 177
 178   int constant = 995666;
 179
 180   MLabel blocka, blockb, end;
 181   m.Branch(m.Int32Constant(0), &blocka, &blockb);
 182   m.Bind(&blocka);
 183   m.Goto(&end);
 184   m.Bind(&blockb);
 185   m.Goto(&end);
 186   m.Bind(&end);
 187   m.Return(m.Int32Constant(constant));
 188
 189   CHECK_EQ(constant, m.Call());
 190 }
 191
 192
 193 TEST(RunLoop) {
 194   RawMachineAssemblerTester<int32_t> m;
 195   int constant = 999555;
 196
 197   MLabel header, body, exit;
 198   m.Goto(&header);
 199   m.Bind(&header);
 200   m.Branch(m.Int32Constant(0), &body, &exit);
 201   m.Bind(&body);
 202   m.Goto(&header);
 203   m.Bind(&exit);
 204   m.Return(m.Int32Constant(constant));
 205
 206   CHECK_EQ(constant, m.Call());
 207 }
 208
 209
 210 template <typename R>
 211 static void BuildDiamondPhi(RawMachineAssemblerTester<R>* m, Node* cond_node,
 212                             MachineType type, Node* true_node,
 213                             Node* false_node) {
 214   MLabel blocka, blockb;
 215   MLabel* end = m->Exit();
 216   m->Branch(cond_node, &blocka, &blockb);
 217   m->Bind(&blocka);
 218   m->Goto(end);
 219   m->Bind(&blockb);
 220   m->Goto(end);
 221
 222   m->Bind(end);
 223   Node* phi = m->Phi(type, true_node, false_node);
 224   m->Return(phi);
 225 }
 226
 227
 228 TEST(RunDiamondPhiConst) {
 229   RawMachineAssemblerTester<int32_t> m(kMachInt32);
 230   int false_val = 0xFF666;
 231   int true_val = 0x00DDD;
 232   Node* true_node = m.Int32Constant(true_val);
 233   Node* false_node = m.Int32Constant(false_val);
 234   BuildDiamondPhi(&m, m.Parameter(0), kMachInt32, true_node, false_node);
 235   CHECK_EQ(false_val, m.Call(0));
 236   CHECK_EQ(true_val, m.Call(1));
 237 }
 238
 239
 240 TEST(RunDiamondPhiNumber) {
 241   RawMachineAssemblerTester<Object*> m(kMachInt32);
 242   double false_val = -11.1;
 243   double true_val = 200.1;
 244   Node* true_node = m.NumberConstant(true_val);
 245   Node* false_node = m.NumberConstant(false_val);
 246   BuildDiamondPhi(&m, m.Parameter(0), kMachAnyTagged, true_node, false_node);
 247   m.CheckNumber(false_val, m.Call(0));
 248   m.CheckNumber(true_val, m.Call(1));
 249 }
 250
 251
 252 TEST(RunDiamondPhiString) {
 253   RawMachineAssemblerTester<Object*> m(kMachInt32);
 254   const char* false_val = "false";
 255   const char* true_val = "true";
 256   Node* true_node = m.StringConstant(true_val);
 257   Node* false_node = m.StringConstant(false_val);
 258   BuildDiamondPhi(&m, m.Parameter(0), kMachAnyTagged, true_node, false_node);
 259   m.CheckString(false_val, m.Call(0));
 260   m.CheckString(true_val, m.Call(1));
 261 }
 262
 263
 264 TEST(RunDiamondPhiParam) {
 265   RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
 266   BuildDiamondPhi(&m, m.Parameter(0), kMachInt32, m.Parameter(1),
 267                   m.Parameter(2));
 268   int32_t c1 = 0x260cb75a;
 269   int32_t c2 = 0xcd3e9c8b;
 270   int result = m.Call(0, c1, c2);
 271   CHECK_EQ(c2, result);
 272   result = m.Call(1, c1, c2);
 273   CHECK_EQ(c1, result);
 274 }
 275
 276
 277 TEST(RunLoopPhiConst) {
 278   RawMachineAssemblerTester<int32_t> m;
 279   int true_val = 0x44000;
 280   int false_val = 0x00888;
 281
 282   Node* cond_node = m.Int32Constant(0);
 283   Node* true_node = m.Int32Constant(true_val);
 284   Node* false_node = m.Int32Constant(false_val);
 285
 286   // x = false_val; while(false) { x = true_val; } return x;
 287   MLabel body, header;
 288   MLabel* end = m.Exit();
 289
 290   m.Goto(&header);
 291   m.Bind(&header);
 292   Node* phi = m.Phi(kMachInt32, false_node, true_node);
 293   m.Branch(cond_node, &body, end);
 294   m.Bind(&body);
 295   m.Goto(&header);
 296   m.Bind(end);
 297   m.Return(phi);
 298
 299   CHECK_EQ(false_val, m.Call());
 300 }
 301
 302
 303 TEST(RunLoopPhiParam) {
 304   RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
 305
 306   MLabel blocka, blockb;
 307   MLabel* end = m.Exit();
 308
 309   m.Goto(&blocka);
 310
 311   m.Bind(&blocka);
 312   Node* phi = m.Phi(kMachInt32, m.Parameter(1), m.Parameter(2));
 313   Node* cond = m.Phi(kMachInt32, m.Parameter(0), m.Int32Constant(0));
 314   m.Branch(cond, &blockb, end);
 315
 316   m.Bind(&blockb);
 317   m.Goto(&blocka);
 318
 319   m.Bind(end);
 320   m.Return(phi);
 321
 322   int32_t c1 = 0xa81903b4;
 323   int32_t c2 = 0x5a1207da;
 324   int result = m.Call(0, c1, c2);
 325   CHECK_EQ(c1, result);
 326   result = m.Call(1, c1, c2);
 327   CHECK_EQ(c2, result);
 328 }
 329
 330
 331 TEST(RunLoopPhiInduction) {
 332   RawMachineAssemblerTester<int32_t> m;
 333
 334   int false_val = 0x10777;
 335
 336   // x = false_val; while(false) { x++; } return x;
 337   MLabel header, body;
 338   MLabel* end = m.Exit();
 339   Node* false_node = m.Int32Constant(false_val);
 340
 341   m.Goto(&header);
 342
 343   m.Bind(&header);
 344   Node* phi = m.Phi(kMachInt32, false_node, false_node);
 345   m.Branch(m.Int32Constant(0), &body, end);
 346
 347   m.Bind(&body);
 348   Node* add = m.Int32Add(phi, m.Int32Constant(1));
 349   phi->ReplaceInput(1, add);
 350   m.Goto(&header);
 351
 352   m.Bind(end);
 353   m.Return(phi);
 354
 355   CHECK_EQ(false_val, m.Call());
 356 }
 357
 358
 359 TEST(RunLoopIncrement) {
 360   RawMachineAssemblerTester<int32_t> m;
 361   Int32BinopTester bt(&m);
 362
 363   // x = 0; while(x ^ param) { x++; } return x;
 364   MLabel header, body;
 365   MLabel* end = m.Exit();
 366   Node* zero = m.Int32Constant(0);
 367
 368   m.Goto(&header);
 369
 370   m.Bind(&header);
 371   Node* phi = m.Phi(kMachInt32, zero, zero);
 372   m.Branch(m.WordXor(phi, bt.param0), &body, end);
 373
 374   m.Bind(&body);
 375   phi->ReplaceInput(1, m.Int32Add(phi, m.Int32Constant(1)));
 376   m.Goto(&header);
 377
 378   m.Bind(end);
 379   bt.AddReturn(phi);
 380
 381   CHECK_EQ(11, bt.call(11, 0));
 382   CHECK_EQ(110, bt.call(110, 0));
 383   CHECK_EQ(176, bt.call(176, 0));
 384 }
 385
 386
 387 TEST(RunLoopIncrement2) {
 388   RawMachineAssemblerTester<int32_t> m;
 389   Int32BinopTester bt(&m);
 390
 391   // x = 0; while(x < param) { x++; } return x;
 392   MLabel header, body;
 393   MLabel* end = m.Exit();
 394   Node* zero = m.Int32Constant(0);
 395
 396   m.Goto(&header);
 397
 398   m.Bind(&header);
 399   Node* phi = m.Phi(kMachInt32, zero, zero);
 400   m.Branch(m.Int32LessThan(phi, bt.param0), &body, end);
 401
 402   m.Bind(&body);
 403   phi->ReplaceInput(1, m.Int32Add(phi, m.Int32Constant(1)));
 404   m.Goto(&header);
 405
 406   m.Bind(end);
 407   bt.AddReturn(phi);
 408
 409   CHECK_EQ(11, bt.call(11, 0));
 410   CHECK_EQ(110, bt.call(110, 0));
 411   CHECK_EQ(176, bt.call(176, 0));
 412   CHECK_EQ(0, bt.call(-200, 0));
 413 }
 414
 415
 416 TEST(RunLoopIncrement3) {
 417   RawMachineAssemblerTester<int32_t> m;
 418   Int32BinopTester bt(&m);
 419
 420   // x = 0; while(x < param) { x++; } return x;
 421   MLabel header, body;
 422   MLabel* end = m.Exit();
 423   Node* zero = m.Int32Constant(0);
 424
 425   m.Goto(&header);
 426
 427   m.Bind(&header);
 428   Node* phi = m.Phi(kMachInt32, zero, zero);
 429   m.Branch(m.Uint32LessThan(phi, bt.param0), &body, end);
 430
 431   m.Bind(&body);
 432   phi->ReplaceInput(1, m.Int32Add(phi, m.Int32Constant(1)));
 433   m.Goto(&header);
 434
 435   m.Bind(end);
 436   bt.AddReturn(phi);
 437
 438   CHECK_EQ(11, bt.call(11, 0));
 439   CHECK_EQ(110, bt.call(110, 0));
 440   CHECK_EQ(176, bt.call(176, 0));
 441   CHECK_EQ(200, bt.call(200, 0));
 442 }
 443
 444
 445 TEST(RunLoopDecrement) {
 446   RawMachineAssemblerTester<int32_t> m;
 447   Int32BinopTester bt(&m);
 448
 449   // x = param; while(x) { x--; } return x;
 450   MLabel header, body;
 451   MLabel* end = m.Exit();
 452
 453   m.Goto(&header);
 454
 455   m.Bind(&header);
 456   Node* phi = m.Phi(kMachInt32, bt.param0, m.Int32Constant(0));
 457   m.Branch(phi, &body, end);
 458
 459   m.Bind(&body);
 460   phi->ReplaceInput(1, m.Int32Sub(phi, m.Int32Constant(1)));
 461   m.Goto(&header);
 462
 463   m.Bind(end);
 464   bt.AddReturn(phi);
 465
 466   CHECK_EQ(0, bt.call(11, 0));
 467   CHECK_EQ(0, bt.call(110, 0));
 468   CHECK_EQ(0, bt.call(197, 0));
 469 }
 470
 471
 472 TEST(RunLoopIncrementFloat64) {
 473   RawMachineAssemblerTester<int32_t> m;
 474
 475   // x = -3.0; while(x < 10) { x = x + 0.5; } return (int) x;
 476   MLabel header, body;
 477   MLabel* end = m.Exit();
 478   Node* minus_3 = m.Float64Constant(-3.0);
 479   Node* ten = m.Float64Constant(10.0);
 480
 481   m.Goto(&header);
 482
 483   m.Bind(&header);
 484   Node* phi = m.Phi(kMachFloat64, minus_3, ten);
 485   m.Branch(m.Float64LessThan(phi, ten), &body, end);
 486
 487   m.Bind(&body);
 488   phi->ReplaceInput(1, m.Float64Add(phi, m.Float64Constant(0.5)));
 489   m.Goto(&header);
 490
 491   m.Bind(end);
 492   m.Return(m.ChangeFloat64ToInt32(phi));
 493
 494   CHECK_EQ(10, m.Call());
 495 }
 496
 497
 498 TEST(RunLoadInt32) {
 499   RawMachineAssemblerTester<int32_t> m;
 500
 501   int32_t p1 = 0;  // loads directly from this location.
 502   m.Return(m.LoadFromPointer(&p1, kMachInt32));
 503
 504   FOR_INT32_INPUTS(i) {
 505     p1 = *i;
 506     CHECK_EQ(p1, m.Call());
 507   }
 508 }
 509
 510
 511 TEST(RunLoadInt32Offset) {
 512   int32_t p1 = 0;  // loads directly from this location.
 513
 514   int32_t offsets[] = {-2000000, -100, -101, 1,          3,
 515                        7,        120,  2000, 2000000000, 0xff};
 516
 517   for (size_t i = 0; i < arraysize(offsets); i++) {
 518     RawMachineAssemblerTester<int32_t> m;
 519     int32_t offset = offsets[i];
 520     byte* pointer = reinterpret_cast<byte*>(&p1) - offset;
 521     // generate load [#base + #index]
 522     m.Return(m.LoadFromPointer(pointer, kMachInt32, offset));
 523
 524     FOR_INT32_INPUTS(j) {
 525       p1 = *j;
 526       CHECK_EQ(p1, m.Call());
 527     }
 528   }
 529 }
 530
 531
 532 TEST(RunLoadStoreFloat64Offset) {
 533   double p1 = 0;  // loads directly from this location.
 534   double p2 = 0;  // and stores directly into this location.
 535
 536   FOR_INT32_INPUTS(i) {
 537     int32_t magic = 0x2342aabb + *i * 3;
 538     RawMachineAssemblerTester<int32_t> m;
 539     int32_t offset = *i;
 540     byte* from = reinterpret_cast<byte*>(&p1) - offset;
 541     byte* to = reinterpret_cast<byte*>(&p2) - offset;
 542     // generate load [#base + #index]
 543     Node* load =
 544         m.Load(kMachFloat64, m.PointerConstant(from), m.Int32Constant(offset));
 545     m.Store(kMachFloat64, m.PointerConstant(to), m.Int32Constant(offset), load);
 546     m.Return(m.Int32Constant(magic));
 547
 548     FOR_FLOAT64_INPUTS(j) {
 549       p1 = *j;
 550       p2 = *j - 5;
 551       CHECK_EQ(magic, m.Call());
 552       CHECK_EQ(p1, p2);
 553     }
 554   }
 555 }
 556
 557
 558 TEST(RunInt32AddP) {
 559   RawMachineAssemblerTester<int32_t> m;
 560   Int32BinopTester bt(&m);
 561
 562   bt.AddReturn(m.Int32Add(bt.param0, bt.param1));
 563
 564   FOR_INT32_INPUTS(i) {
 565     FOR_INT32_INPUTS(j) {
 566       // Use uint32_t because signed overflow is UB in C.
 567       int expected = static_cast<int32_t>(*i + *j);
 568       CHECK_EQ(expected, bt.call(*i, *j));
 569     }
 570   }
 571 }
 572
 573
 574 TEST(RunInt32AddAndWord32SarP) {
 575   {
 576     RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, kMachUint32);
 577     m.Return(m.Int32Add(m.Parameter(0),
 578                         m.Word32Sar(m.Parameter(1), m.Parameter(2))));
 579     FOR_UINT32_INPUTS(i) {
 580       FOR_INT32_INPUTS(j) {
 581         FOR_UINT32_SHIFTS(shift) {
 582           // Use uint32_t because signed overflow is UB in C.
 583           int32_t expected = *i + (*j >> shift);
 584           CHECK_EQ(expected, m.Call(*i, *j, shift));
 585         }
 586       }
 587     }
 588   }
 589   {
 590     RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachUint32, kMachUint32);
 591     m.Return(m.Int32Add(m.Word32Sar(m.Parameter(0), m.Parameter(1)),
 592                         m.Parameter(2)));
 593     FOR_INT32_INPUTS(i) {
 594       FOR_UINT32_SHIFTS(shift) {
 595         FOR_UINT32_INPUTS(k) {
 596           // Use uint32_t because signed overflow is UB in C.
 597           int32_t expected = (*i >> shift) + *k;
 598           CHECK_EQ(expected, m.Call(*i, shift, *k));
 599         }
 600       }
 601     }
 602   }
 603 }
 604
 605
 606 TEST(RunInt32AddAndWord32ShlP) {
 607   {
 608     RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, kMachUint32);
 609     m.Return(m.Int32Add(m.Parameter(0),
 610                         m.Word32Shl(m.Parameter(1), m.Parameter(2))));
 611     FOR_UINT32_INPUTS(i) {
 612       FOR_INT32_INPUTS(j) {
 613         FOR_UINT32_SHIFTS(shift) {
 614           // Use uint32_t because signed overflow is UB in C.
 615           int32_t expected = *i + (*j << shift);
 616           CHECK_EQ(expected, m.Call(*i, *j, shift));
 617         }
 618       }
 619     }
 620   }
 621   {
 622     RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachUint32, kMachUint32);
 623     m.Return(m.Int32Add(m.Word32Shl(m.Parameter(0), m.Parameter(1)),
 624                         m.Parameter(2)));
 625     FOR_INT32_INPUTS(i) {
 626       FOR_UINT32_SHIFTS(shift) {
 627         FOR_UINT32_INPUTS(k) {
 628           // Use uint32_t because signed overflow is UB in C.
 629           int32_t expected = (*i << shift) + *k;
 630           CHECK_EQ(expected, m.Call(*i, shift, *k));
 631         }
 632       }
 633     }
 634   }
 635 }
 636
 637
 638 TEST(RunInt32AddAndWord32ShrP) {
 639   {
 640     RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachUint32, kMachUint32);
 641     m.Return(m.Int32Add(m.Parameter(0),
 642                         m.Word32Shr(m.Parameter(1), m.Parameter(2))));
 643     FOR_UINT32_INPUTS(i) {
 644       FOR_UINT32_INPUTS(j) {
 645         FOR_UINT32_SHIFTS(shift) {
 646           // Use uint32_t because signed overflow is UB in C.
 647           int32_t expected = *i + (*j >> shift);
 648           CHECK_EQ(expected, m.Call(*i, *j, shift));
 649         }
 650       }
 651     }
 652   }
 653   {
 654     RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachUint32, kMachUint32);
 655     m.Return(m.Int32Add(m.Word32Shr(m.Parameter(0), m.Parameter(1)),
 656                         m.Parameter(2)));
 657     FOR_UINT32_INPUTS(i) {
 658       FOR_UINT32_SHIFTS(shift) {
 659         FOR_UINT32_INPUTS(k) {
 660           // Use uint32_t because signed overflow is UB in C.
 661           int32_t expected = (*i >> shift) + *k;
 662           CHECK_EQ(expected, m.Call(*i, shift, *k));
 663         }
 664       }
 665     }
 666   }
 667 }
 668
 669
 670 TEST(RunInt32AddInBranch) {
 671   static const int32_t constant = 987654321;
 672   {
 673     RawMachineAssemblerTester<int32_t> m;
 674     Uint32BinopTester bt(&m);
 675     MLabel blocka, blockb;
 676     m.Branch(
 677         m.Word32Equal(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)),
 678         &blocka, &blockb);
 679     m.Bind(&blocka);
 680     bt.AddReturn(m.Int32Constant(constant));
 681     m.Bind(&blockb);
 682     bt.AddReturn(m.Int32Constant(0 - constant));
 683     FOR_UINT32_INPUTS(i) {
 684       FOR_UINT32_INPUTS(j) {
 685         int32_t expected = (*i + *j) == 0 ? constant : 0 - constant;
 686         CHECK_EQ(expected, bt.call(*i, *j));
 687       }
 688     }
 689   }
 690   {
 691     RawMachineAssemblerTester<int32_t> m;
 692     Uint32BinopTester bt(&m);
 693     MLabel blocka, blockb;
 694     m.Branch(
 695         m.Word32NotEqual(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)),
 696         &blocka, &blockb);
 697     m.Bind(&blocka);
 698     bt.AddReturn(m.Int32Constant(constant));
 699     m.Bind(&blockb);
 700     bt.AddReturn(m.Int32Constant(0 - constant));
 701     FOR_UINT32_INPUTS(i) {
 702       FOR_UINT32_INPUTS(j) {
 703         int32_t expected = (*i + *j) != 0 ? constant : 0 - constant;
 704         CHECK_EQ(expected, bt.call(*i, *j));
 705       }
 706     }
 707   }
 708   {
 709     FOR_UINT32_INPUTS(i) {
 710       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
 711       MLabel blocka, blockb;
 712       m.Branch(m.Word32Equal(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)),
 713                              m.Int32Constant(0)),
 714                &blocka, &blockb);
 715       m.Bind(&blocka);
 716       m.Return(m.Int32Constant(constant));
 717       m.Bind(&blockb);
 718       m.Return(m.Int32Constant(0 - constant));
 719       FOR_UINT32_INPUTS(j) {
 720         uint32_t expected = (*i + *j) == 0 ? constant : 0 - constant;
 721         CHECK_UINT32_EQ(expected, m.Call(*j));
 722       }
 723     }
 724   }
 725   {
 726     FOR_UINT32_INPUTS(i) {
 727       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
 728       MLabel blocka, blockb;
 729       m.Branch(m.Word32NotEqual(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)),
 730                                 m.Int32Constant(0)),
 731                &blocka, &blockb);
 732       m.Bind(&blocka);
 733       m.Return(m.Int32Constant(constant));
 734       m.Bind(&blockb);
 735       m.Return(m.Int32Constant(0 - constant));
 736       FOR_UINT32_INPUTS(j) {
 737         uint32_t expected = (*i + *j) != 0 ? constant : 0 - constant;
 738         CHECK_UINT32_EQ(expected, m.Call(*j));
 739       }
 740     }
 741   }
 742   {
 743     RawMachineAssemblerTester<void> m;
 744     const Operator* shops[] = {m.machine()->Word32Sar(),
 745                                m.machine()->Word32Shl(),
 746                                m.machine()->Word32Shr()};
 747     for (size_t n = 0; n < arraysize(shops); n++) {
 748       RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
 749                                            kMachUint32);
 750       MLabel blocka, blockb;
 751       m.Branch(m.Word32Equal(m.Int32Add(m.Parameter(0),
 752                                         m.NewNode(shops[n], m.Parameter(1),
 753                                                   m.Parameter(2))),
 754                              m.Int32Constant(0)),
 755                &blocka, &blockb);
 756       m.Bind(&blocka);
 757       m.Return(m.Int32Constant(constant));
 758       m.Bind(&blockb);
 759       m.Return(m.Int32Constant(0 - constant));
 760       FOR_UINT32_INPUTS(i) {
 761         FOR_INT32_INPUTS(j) {
 762           FOR_UINT32_SHIFTS(shift) {
 763             int32_t right;
 764             switch (shops[n]->opcode()) {
 765               default:
 766                 UNREACHABLE();
 767               case IrOpcode::kWord32Sar:
 768                 right = *j >> shift;
 769                 break;
 770               case IrOpcode::kWord32Shl:
 771                 right = *j << shift;
 772                 break;
 773               case IrOpcode::kWord32Shr:
 774                 right = static_cast<uint32_t>(*j) >> shift;
 775                 break;
 776             }
 777             int32_t expected = ((*i + right) == 0) ? constant : 0 - constant;
 778             CHECK_EQ(expected, m.Call(*i, *j, shift));
 779           }
 780         }
 781       }
 782     }
 783   }
 784 }
 785
 786
 787 TEST(RunInt32AddInComparison) {
 788   {
 789     RawMachineAssemblerTester<int32_t> m;
 790     Uint32BinopTester bt(&m);
 791     bt.AddReturn(
 792         m.Word32Equal(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)));
 793     FOR_UINT32_INPUTS(i) {
 794       FOR_UINT32_INPUTS(j) {
 795         uint32_t expected = (*i + *j) == 0;
 796         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
 797       }
 798     }
 799   }
 800   {
 801     RawMachineAssemblerTester<int32_t> m;
 802     Uint32BinopTester bt(&m);
 803     bt.AddReturn(
 804         m.Word32Equal(m.Int32Constant(0), m.Int32Add(bt.param0, bt.param1)));
 805     FOR_UINT32_INPUTS(i) {
 806       FOR_UINT32_INPUTS(j) {
 807         uint32_t expected = (*i + *j) == 0;
 808         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
 809       }
 810     }
 811   }
 812   {
 813     FOR_UINT32_INPUTS(i) {
 814       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
 815       m.Return(m.Word32Equal(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)),
 816                              m.Int32Constant(0)));
 817       FOR_UINT32_INPUTS(j) {
 818         uint32_t expected = (*i + *j) == 0;
 819         CHECK_UINT32_EQ(expected, m.Call(*j));
 820       }
 821     }
 822   }
 823   {
 824     FOR_UINT32_INPUTS(i) {
 825       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
 826       m.Return(m.Word32Equal(m.Int32Add(m.Parameter(0), m.Int32Constant(*i)),
 827                              m.Int32Constant(0)));
 828       FOR_UINT32_INPUTS(j) {
 829         uint32_t expected = (*j + *i) == 0;
 830         CHECK_UINT32_EQ(expected, m.Call(*j));
 831       }
 832     }
 833   }
 834   {
 835     RawMachineAssemblerTester<void> m;
 836     const Operator* shops[] = {m.machine()->Word32Sar(),
 837                                m.machine()->Word32Shl(),
 838                                m.machine()->Word32Shr()};
 839     for (size_t n = 0; n < arraysize(shops); n++) {
 840       RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
 841                                            kMachUint32);
 842       m.Return(m.Word32Equal(
 843           m.Int32Add(m.Parameter(0),
 844                      m.NewNode(shops[n], m.Parameter(1), m.Parameter(2))),
 845           m.Int32Constant(0)));
 846       FOR_UINT32_INPUTS(i) {
 847         FOR_INT32_INPUTS(j) {
 848           FOR_UINT32_SHIFTS(shift) {
 849             int32_t right;
 850             switch (shops[n]->opcode()) {
 851               default:
 852                 UNREACHABLE();
 853               case IrOpcode::kWord32Sar:
 854                 right = *j >> shift;
 855                 break;
 856               case IrOpcode::kWord32Shl:
 857                 right = *j << shift;
 858                 break;
 859               case IrOpcode::kWord32Shr:
 860                 right = static_cast<uint32_t>(*j) >> shift;
 861                 break;
 862             }
 863             int32_t expected = (*i + right) == 0;
 864             CHECK_EQ(expected, m.Call(*i, *j, shift));
 865           }
 866         }
 867       }
 868     }
 869   }
 870 }
 871
 872
 873 TEST(RunInt32SubP) {
 874   RawMachineAssemblerTester<int32_t> m;
 875   Uint32BinopTester bt(&m);
 876
 877   m.Return(m.Int32Sub(bt.param0, bt.param1));
 878
 879   FOR_UINT32_INPUTS(i) {
 880     FOR_UINT32_INPUTS(j) {
 881       uint32_t expected = static_cast<int32_t>(*i - *j);
 882       CHECK_UINT32_EQ(expected, bt.call(*i, *j));
 883     }
 884   }
 885 }
 886
 887
 888 TEST(RunInt32SubImm) {
 889   {
 890     FOR_UINT32_INPUTS(i) {
 891       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
 892       m.Return(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)));
 893       FOR_UINT32_INPUTS(j) {
 894         uint32_t expected = *i - *j;
 895         CHECK_UINT32_EQ(expected, m.Call(*j));
 896       }
 897     }
 898   }
 899   {
 900     FOR_UINT32_INPUTS(i) {
 901       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
 902       m.Return(m.Int32Sub(m.Parameter(0), m.Int32Constant(*i)));
 903       FOR_UINT32_INPUTS(j) {
 904         uint32_t expected = *j - *i;
 905         CHECK_UINT32_EQ(expected, m.Call(*j));
 906       }
 907     }
 908   }
 909 }
 910
 911
 912 TEST(RunInt32SubAndWord32SarP) {
 913   {
 914     RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, kMachUint32);
 915     m.Return(m.Int32Sub(m.Parameter(0),
 916                         m.Word32Sar(m.Parameter(1), m.Parameter(2))));
 917     FOR_UINT32_INPUTS(i) {
 918       FOR_INT32_INPUTS(j) {
 919         FOR_UINT32_SHIFTS(shift) {
 920           int32_t expected = *i - (*j >> shift);
 921           CHECK_EQ(expected, m.Call(*i, *j, shift));
 922         }
 923       }
 924     }
 925   }
 926   {
 927     RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachUint32, kMachUint32);
 928     m.Return(m.Int32Sub(m.Word32Sar(m.Parameter(0), m.Parameter(1)),
 929                         m.Parameter(2)));
 930     FOR_INT32_INPUTS(i) {
 931       FOR_UINT32_SHIFTS(shift) {
 932         FOR_UINT32_INPUTS(k) {
 933           int32_t expected = (*i >> shift) - *k;
 934           CHECK_EQ(expected, m.Call(*i, shift, *k));
 935         }
 936       }
 937     }
 938   }
 939 }
 940
 941
 942 TEST(RunInt32SubAndWord32ShlP) {
 943   {
 944     RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, kMachUint32);
 945     m.Return(m.Int32Sub(m.Parameter(0),
 946                         m.Word32Shl(m.Parameter(1), m.Parameter(2))));
 947     FOR_UINT32_INPUTS(i) {
 948       FOR_INT32_INPUTS(j) {
 949         FOR_UINT32_SHIFTS(shift) {
 950           int32_t expected = *i - (*j << shift);
 951           CHECK_EQ(expected, m.Call(*i, *j, shift));
 952         }
 953       }
 954     }
 955   }
 956   {
 957     RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachUint32, kMachUint32);
 958     m.Return(m.Int32Sub(m.Word32Shl(m.Parameter(0), m.Parameter(1)),
 959                         m.Parameter(2)));
 960     FOR_INT32_INPUTS(i) {
 961       FOR_UINT32_SHIFTS(shift) {
 962         FOR_UINT32_INPUTS(k) {
 963           // Use uint32_t because signed overflow is UB in C.
 964           int32_t expected = (*i << shift) - *k;
 965           CHECK_EQ(expected, m.Call(*i, shift, *k));
 966         }
 967       }
 968     }
 969   }
 970 }
 971
 972
 973 TEST(RunInt32SubAndWord32ShrP) {
 974   {
 975     RawMachineAssemblerTester<uint32_t> m(kMachUint32, kMachUint32,
 976                                           kMachUint32);
 977     m.Return(m.Int32Sub(m.Parameter(0),
 978                         m.Word32Shr(m.Parameter(1), m.Parameter(2))));
 979     FOR_UINT32_INPUTS(i) {
 980       FOR_UINT32_INPUTS(j) {
 981         FOR_UINT32_SHIFTS(shift) {
 982           // Use uint32_t because signed overflow is UB in C.
 983           int32_t expected = *i - (*j >> shift);
 984           CHECK_UINT32_EQ(expected, m.Call(*i, *j, shift));
 985         }
 986       }
 987     }
 988   }
 989   {
 990     RawMachineAssemblerTester<uint32_t> m(kMachUint32, kMachUint32,
 991                                           kMachUint32);
 992     m.Return(m.Int32Sub(m.Word32Shr(m.Parameter(0), m.Parameter(1)),
 993                         m.Parameter(2)));
 994     FOR_UINT32_INPUTS(i) {
 995       FOR_UINT32_SHIFTS(shift) {
 996         FOR_UINT32_INPUTS(k) {
 997           // Use uint32_t because signed overflow is UB in C.
 998           int32_t expected = (*i >> shift) - *k;
 999           CHECK_EQ(expected, m.Call(*i, shift, *k));
1000         }
1001       }
1002     }
1003   }
1004 }
1005
1006
1007 TEST(RunInt32SubInBranch) {
1008   static const int constant = 987654321;
1009   {
1010     RawMachineAssemblerTester<int32_t> m;
1011     Uint32BinopTester bt(&m);
1012     MLabel blocka, blockb;
1013     m.Branch(
1014         m.Word32Equal(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)),
1015         &blocka, &blockb);
1016     m.Bind(&blocka);
1017     bt.AddReturn(m.Int32Constant(constant));
1018     m.Bind(&blockb);
1019     bt.AddReturn(m.Int32Constant(0 - constant));
1020     FOR_UINT32_INPUTS(i) {
1021       FOR_UINT32_INPUTS(j) {
1022         int32_t expected = (*i - *j) == 0 ? constant : 0 - constant;
1023         CHECK_EQ(expected, bt.call(*i, *j));
1024       }
1025     }
1026   }
1027   {
1028     RawMachineAssemblerTester<int32_t> m;
1029     Uint32BinopTester bt(&m);
1030     MLabel blocka, blockb;
1031     m.Branch(
1032         m.Word32NotEqual(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)),
1033         &blocka, &blockb);
1034     m.Bind(&blocka);
1035     bt.AddReturn(m.Int32Constant(constant));
1036     m.Bind(&blockb);
1037     bt.AddReturn(m.Int32Constant(0 - constant));
1038     FOR_UINT32_INPUTS(i) {
1039       FOR_UINT32_INPUTS(j) {
1040         int32_t expected = (*i - *j) != 0 ? constant : 0 - constant;
1041         CHECK_EQ(expected, bt.call(*i, *j));
1042       }
1043     }
1044   }
1045   {
1046     FOR_UINT32_INPUTS(i) {
1047       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
1048       MLabel blocka, blockb;
1049       m.Branch(m.Word32Equal(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)),
1050                              m.Int32Constant(0)),
1051                &blocka, &blockb);
1052       m.Bind(&blocka);
1053       m.Return(m.Int32Constant(constant));
1054       m.Bind(&blockb);
1055       m.Return(m.Int32Constant(0 - constant));
1056       FOR_UINT32_INPUTS(j) {
1057         int32_t expected = (*i - *j) == 0 ? constant : 0 - constant;
1058         CHECK_EQ(expected, m.Call(*j));
1059       }
1060     }
1061   }
1062   {
1063     FOR_UINT32_INPUTS(i) {
1064       RawMachineAssemblerTester<int32_t> m(kMachUint32);
1065       MLabel blocka, blockb;
1066       m.Branch(m.Word32NotEqual(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)),
1067                                 m.Int32Constant(0)),
1068                &blocka, &blockb);
1069       m.Bind(&blocka);
1070       m.Return(m.Int32Constant(constant));
1071       m.Bind(&blockb);
1072       m.Return(m.Int32Constant(0 - constant));
1073       FOR_UINT32_INPUTS(j) {
1074         int32_t expected = (*i - *j) != 0 ? constant : 0 - constant;
1075         CHECK_EQ(expected, m.Call(*j));
1076       }
1077     }
1078   }
1079   {
1080     RawMachineAssemblerTester<void> m;
1081     const Operator* shops[] = {m.machine()->Word32Sar(),
1082                                m.machine()->Word32Shl(),
1083                                m.machine()->Word32Shr()};
1084     for (size_t n = 0; n < arraysize(shops); n++) {
1085       RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
1086                                            kMachUint32);
1087       MLabel blocka, blockb;
1088       m.Branch(m.Word32Equal(m.Int32Sub(m.Parameter(0),
1089                                         m.NewNode(shops[n], m.Parameter(1),
1090                                                   m.Parameter(2))),
1091                              m.Int32Constant(0)),
1092                &blocka, &blockb);
1093       m.Bind(&blocka);
1094       m.Return(m.Int32Constant(constant));
1095       m.Bind(&blockb);
1096       m.Return(m.Int32Constant(0 - constant));
1097       FOR_UINT32_INPUTS(i) {
1098         FOR_INT32_INPUTS(j) {
1099           FOR_UINT32_SHIFTS(shift) {
1100             int32_t right;
1101             switch (shops[n]->opcode()) {
1102               default:
1103                 UNREACHABLE();
1104               case IrOpcode::kWord32Sar:
1105                 right = *j >> shift;
1106                 break;
1107               case IrOpcode::kWord32Shl:
1108                 right = *j << shift;
1109                 break;
1110               case IrOpcode::kWord32Shr:
1111                 right = static_cast<uint32_t>(*j) >> shift;
1112                 break;
1113             }
1114             int32_t expected = ((*i - right) == 0) ? constant : 0 - constant;
1115             CHECK_EQ(expected, m.Call(*i, *j, shift));
1116           }
1117         }
1118       }
1119     }
1120   }
1121 }
1122
1123
1124 TEST(RunInt32SubInComparison) {
1125   {
1126     RawMachineAssemblerTester<int32_t> m;
1127     Uint32BinopTester bt(&m);
1128     bt.AddReturn(
1129         m.Word32Equal(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)));
1130     FOR_UINT32_INPUTS(i) {
1131       FOR_UINT32_INPUTS(j) {
1132         uint32_t expected = (*i - *j) == 0;
1133         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
1134       }
1135     }
1136   }
1137   {
1138     RawMachineAssemblerTester<int32_t> m;
1139     Uint32BinopTester bt(&m);
1140     bt.AddReturn(
1141         m.Word32Equal(m.Int32Constant(0), m.Int32Sub(bt.param0, bt.param1)));
1142     FOR_UINT32_INPUTS(i) {
1143       FOR_UINT32_INPUTS(j) {
1144         uint32_t expected = (*i - *j) == 0;
1145         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
1146       }
1147     }
1148   }
1149   {
1150     FOR_UINT32_INPUTS(i) {
1151       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
1152       m.Return(m.Word32Equal(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)),
1153                              m.Int32Constant(0)));
1154       FOR_UINT32_INPUTS(j) {
1155         uint32_t expected = (*i - *j) == 0;
1156         CHECK_UINT32_EQ(expected, m.Call(*j));
1157       }
1158     }
1159   }
1160   {
1161     FOR_UINT32_INPUTS(i) {
1162       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
1163       m.Return(m.Word32Equal(m.Int32Sub(m.Parameter(0), m.Int32Constant(*i)),
1164                              m.Int32Constant(0)));
1165       FOR_UINT32_INPUTS(j) {
1166         uint32_t expected = (*j - *i) == 0;
1167         CHECK_UINT32_EQ(expected, m.Call(*j));
1168       }
1169     }
1170   }
1171   {
1172     RawMachineAssemblerTester<void> m;
1173     const Operator* shops[] = {m.machine()->Word32Sar(),
1174                                m.machine()->Word32Shl(),
1175                                m.machine()->Word32Shr()};
1176     for (size_t n = 0; n < arraysize(shops); n++) {
1177       RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
1178                                            kMachUint32);
1179       m.Return(m.Word32Equal(
1180           m.Int32Sub(m.Parameter(0),
1181                      m.NewNode(shops[n], m.Parameter(1), m.Parameter(2))),
1182           m.Int32Constant(0)));
1183       FOR_UINT32_INPUTS(i) {
1184         FOR_INT32_INPUTS(j) {
1185           FOR_UINT32_SHIFTS(shift) {
1186             int32_t right;
1187             switch (shops[n]->opcode()) {
1188               default:
1189                 UNREACHABLE();
1190               case IrOpcode::kWord32Sar:
1191                 right = *j >> shift;
1192                 break;
1193               case IrOpcode::kWord32Shl:
1194                 right = *j << shift;
1195                 break;
1196               case IrOpcode::kWord32Shr:
1197                 right = static_cast<uint32_t>(*j) >> shift;
1198                 break;
1199             }
1200             int32_t expected = (*i - right) == 0;
1201             CHECK_EQ(expected, m.Call(*i, *j, shift));
1202           }
1203         }
1204       }
1205     }
1206   }
1207 }
1208
1209
1210 TEST(RunInt32MulP) {
1211   {
1212     RawMachineAssemblerTester<int32_t> m;
1213     Int32BinopTester bt(&m);
1214     bt.AddReturn(m.Int32Mul(bt.param0, bt.param1));
1215     FOR_INT32_INPUTS(i) {
1216       FOR_INT32_INPUTS(j) {
1217         int expected = static_cast<int32_t>(*i * *j);
1218         CHECK_EQ(expected, bt.call(*i, *j));
1219       }
1220     }
1221   }
1222   {
1223     RawMachineAssemblerTester<int32_t> m;
1224     Uint32BinopTester bt(&m);
1225     bt.AddReturn(m.Int32Mul(bt.param0, bt.param1));
1226     FOR_UINT32_INPUTS(i) {
1227       FOR_UINT32_INPUTS(j) {
1228         uint32_t expected = *i * *j;
1229         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
1230       }
1231     }
1232   }
1233 }
1234
1235
1236 TEST(RunInt32MulImm) {
1237   {
1238     FOR_UINT32_INPUTS(i) {
1239       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
1240       m.Return(m.Int32Mul(m.Int32Constant(*i), m.Parameter(0)));
1241       FOR_UINT32_INPUTS(j) {
1242         uint32_t expected = *i * *j;
1243         CHECK_UINT32_EQ(expected, m.Call(*j));
1244       }
1245     }
1246   }
1247   {
1248     FOR_UINT32_INPUTS(i) {
1249       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
1250       m.Return(m.Int32Mul(m.Parameter(0), m.Int32Constant(*i)));
1251       FOR_UINT32_INPUTS(j) {
1252         uint32_t expected = *j * *i;
1253         CHECK_UINT32_EQ(expected, m.Call(*j));
1254       }
1255     }
1256   }
1257 }
1258
1259
1260 TEST(RunInt32MulAndInt32AddP) {
1261   {
1262     RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
1263     m.Return(
1264         m.Int32Add(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2))));
1265     FOR_INT32_INPUTS(i) {
1266       FOR_INT32_INPUTS(j) {
1267         FOR_INT32_INPUTS(k) {
1268           int32_t p0 = *i;
1269           int32_t p1 = *j;
1270           int32_t p2 = *k;
1271           int expected = p0 + static_cast<int32_t>(p1 * p2);
1272           CHECK_EQ(expected, m.Call(p0, p1, p2));
1273         }
1274       }
1275     }
1276   }
1277   {
1278     RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
1279     m.Return(
1280         m.Int32Add(m.Int32Mul(m.Parameter(0), m.Parameter(1)), m.Parameter(2)));
1281     FOR_INT32_INPUTS(i) {
1282       FOR_INT32_INPUTS(j) {
1283         FOR_INT32_INPUTS(k) {
1284           int32_t p0 = *i;
1285           int32_t p1 = *j;
1286           int32_t p2 = *k;
1287           int expected = static_cast<int32_t>(p0 * p1) + p2;
1288           CHECK_EQ(expected, m.Call(p0, p1, p2));
1289         }
1290       }
1291     }
1292   }
1293   {
1294     FOR_INT32_INPUTS(i) {
1295       RawMachineAssemblerTester<int32_t> m;
1296       Int32BinopTester bt(&m);
1297       bt.AddReturn(
1298           m.Int32Add(m.Int32Constant(*i), m.Int32Mul(bt.param0, bt.param1)));
1299       FOR_INT32_INPUTS(j) {
1300         FOR_INT32_INPUTS(k) {
1301           int32_t p0 = *j;
1302           int32_t p1 = *k;
1303           int expected = *i + static_cast<int32_t>(p0 * p1);
1304           CHECK_EQ(expected, bt.call(p0, p1));
1305         }
1306       }
1307     }
1308   }
1309 }
1310
1311
1312 TEST(RunInt32MulAndInt32SubP) {
1313   {
1314     RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, kMachInt32);
1315     m.Return(
1316         m.Int32Sub(m.Parameter(0), m.Int32Mul(m.Parameter(1), m.Parameter(2))));
1317     FOR_UINT32_INPUTS(i) {
1318       FOR_INT32_INPUTS(j) {
1319         FOR_INT32_INPUTS(k) {
1320           uint32_t p0 = *i;
1321           int32_t p1 = *j;
1322           int32_t p2 = *k;
1323           // Use uint32_t because signed overflow is UB in C.
1324           int expected = p0 - static_cast<uint32_t>(p1 * p2);
1325           CHECK_EQ(expected, m.Call(p0, p1, p2));
1326         }
1327       }
1328     }
1329   }
1330   {
1331     FOR_UINT32_INPUTS(i) {
1332       RawMachineAssemblerTester<int32_t> m;
1333       Int32BinopTester bt(&m);
1334       bt.AddReturn(
1335           m.Int32Sub(m.Int32Constant(*i), m.Int32Mul(bt.param0, bt.param1)));
1336       FOR_INT32_INPUTS(j) {
1337         FOR_INT32_INPUTS(k) {
1338           int32_t p0 = *j;
1339           int32_t p1 = *k;
1340           // Use uint32_t because signed overflow is UB in C.
1341           int expected = *i - static_cast<uint32_t>(p0 * p1);
1342           CHECK_EQ(expected, bt.call(p0, p1));
1343         }
1344       }
1345     }
1346   }
1347 }
1348
1349
1350 TEST(RunInt32DivP) {
1351   {
1352     RawMachineAssemblerTester<int32_t> m;
1353     Int32BinopTester bt(&m);
1354     bt.AddReturn(m.Int32Div(bt.param0, bt.param1));
1355     FOR_INT32_INPUTS(i) {
1356       FOR_INT32_INPUTS(j) {
1357         int p0 = *i;
1358         int p1 = *j;
1359         if (p1 != 0 && (static_cast<uint32_t>(p0) != 0x80000000 || p1 != -1)) {
1360           int expected = static_cast<int32_t>(p0 / p1);
1361           CHECK_EQ(expected, bt.call(p0, p1));
1362         }
1363       }
1364     }
1365   }
1366   {
1367     RawMachineAssemblerTester<int32_t> m;
1368     Int32BinopTester bt(&m);
1369     bt.AddReturn(m.Int32Add(bt.param0, m.Int32Div(bt.param0, bt.param1)));
1370     FOR_INT32_INPUTS(i) {
1371       FOR_INT32_INPUTS(j) {
1372         int p0 = *i;
1373         int p1 = *j;
1374         if (p1 != 0 && (static_cast<uint32_t>(p0) != 0x80000000 || p1 != -1)) {
1375           int expected = static_cast<int32_t>(p0 + (p0 / p1));
1376           CHECK_EQ(expected, bt.call(p0, p1));
1377         }
1378       }
1379     }
1380   }
1381 }
1382
1383
1384 TEST(RunInt32UDivP) {
1385   {
1386     RawMachineAssemblerTester<int32_t> m;
1387     Int32BinopTester bt(&m);
1388     bt.AddReturn(m.Int32UDiv(bt.param0, bt.param1));
1389     FOR_UINT32_INPUTS(i) {
1390       FOR_UINT32_INPUTS(j) {
1391         uint32_t p0 = *i;
1392         uint32_t p1 = *j;
1393         if (p1 != 0) {
1394           uint32_t expected = static_cast<uint32_t>(p0 / p1);
1395           CHECK_EQ(expected, bt.call(p0, p1));
1396         }
1397       }
1398     }
1399   }
1400   {
1401     RawMachineAssemblerTester<int32_t> m;
1402     Int32BinopTester bt(&m);
1403     bt.AddReturn(m.Int32Add(bt.param0, m.Int32UDiv(bt.param0, bt.param1)));
1404     FOR_UINT32_INPUTS(i) {
1405       FOR_UINT32_INPUTS(j) {
1406         uint32_t p0 = *i;
1407         uint32_t p1 = *j;
1408         if (p1 != 0) {
1409           uint32_t expected = static_cast<uint32_t>(p0 + (p0 / p1));
1410           CHECK_EQ(expected, bt.call(p0, p1));
1411         }
1412       }
1413     }
1414   }
1415 }
1416
1417
1418 TEST(RunInt32ModP) {
1419   {
1420     RawMachineAssemblerTester<int32_t> m;
1421     Int32BinopTester bt(&m);
1422     bt.AddReturn(m.Int32Mod(bt.param0, bt.param1));
1423     FOR_INT32_INPUTS(i) {
1424       FOR_INT32_INPUTS(j) {
1425         int p0 = *i;
1426         int p1 = *j;
1427         if (p1 != 0 && (static_cast<uint32_t>(p0) != 0x80000000 || p1 != -1)) {
1428           int expected = static_cast<int32_t>(p0 % p1);
1429           CHECK_EQ(expected, bt.call(p0, p1));
1430         }
1431       }
1432     }
1433   }
1434   {
1435     RawMachineAssemblerTester<int32_t> m;
1436     Int32BinopTester bt(&m);
1437     bt.AddReturn(m.Int32Add(bt.param0, m.Int32Mod(bt.param0, bt.param1)));
1438     FOR_INT32_INPUTS(i) {
1439       FOR_INT32_INPUTS(j) {
1440         int p0 = *i;
1441         int p1 = *j;
1442         if (p1 != 0 && (static_cast<uint32_t>(p0) != 0x80000000 || p1 != -1)) {
1443           int expected = static_cast<int32_t>(p0 + (p0 % p1));
1444           CHECK_EQ(expected, bt.call(p0, p1));
1445         }
1446       }
1447     }
1448   }
1449 }
1450
1451
1452 TEST(RunInt32UModP) {
1453   {
1454     RawMachineAssemblerTester<int32_t> m;
1455     Int32BinopTester bt(&m);
1456     bt.AddReturn(m.Int32UMod(bt.param0, bt.param1));
1457     FOR_UINT32_INPUTS(i) {
1458       FOR_UINT32_INPUTS(j) {
1459         uint32_t p0 = *i;
1460         uint32_t p1 = *j;
1461         if (p1 != 0) {
1462           uint32_t expected = static_cast<uint32_t>(p0 % p1);
1463           CHECK_EQ(expected, bt.call(p0, p1));
1464         }
1465       }
1466     }
1467   }
1468   {
1469     RawMachineAssemblerTester<int32_t> m;
1470     Int32BinopTester bt(&m);
1471     bt.AddReturn(m.Int32Add(bt.param0, m.Int32UMod(bt.param0, bt.param1)));
1472     FOR_UINT32_INPUTS(i) {
1473       FOR_UINT32_INPUTS(j) {
1474         uint32_t p0 = *i;
1475         uint32_t p1 = *j;
1476         if (p1 != 0) {
1477           uint32_t expected = static_cast<uint32_t>(p0 + (p0 % p1));
1478           CHECK_EQ(expected, bt.call(p0, p1));
1479         }
1480       }
1481     }
1482   }
1483 }
1484
1485
1486 TEST(RunWord32AndP) {
1487   {
1488     RawMachineAssemblerTester<int32_t> m;
1489     Int32BinopTester bt(&m);
1490     bt.AddReturn(m.Word32And(bt.param0, bt.param1));
1491     FOR_UINT32_INPUTS(i) {
1492       FOR_UINT32_INPUTS(j) {
1493         uint32_t expected = *i & *j;
1494         CHECK_EQ(expected, bt.call(*i, *j));
1495       }
1496     }
1497   }
1498   {
1499     RawMachineAssemblerTester<int32_t> m;
1500     Int32BinopTester bt(&m);
1501     bt.AddReturn(m.Word32And(bt.param0, m.Word32Not(bt.param1)));
1502     FOR_UINT32_INPUTS(i) {
1503       FOR_UINT32_INPUTS(j) {
1504         uint32_t expected = *i & ~(*j);
1505         CHECK_EQ(expected, bt.call(*i, *j));
1506       }
1507     }
1508   }
1509   {
1510     RawMachineAssemblerTester<int32_t> m;
1511     Int32BinopTester bt(&m);
1512     bt.AddReturn(m.Word32And(m.Word32Not(bt.param0), bt.param1));
1513     FOR_UINT32_INPUTS(i) {
1514       FOR_UINT32_INPUTS(j) {
1515         uint32_t expected = ~(*i) & *j;
1516         CHECK_EQ(expected, bt.call(*i, *j));
1517       }
1518     }
1519   }
1520 }
1521
1522
1523 TEST(RunWord32AndAndWord32ShlP) {
1524   {
1525     RawMachineAssemblerTester<int32_t> m;
1526     Uint32BinopTester bt(&m);
1527     bt.AddReturn(
1528         m.Word32Shl(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1f))));
1529     FOR_UINT32_INPUTS(i) {
1530       FOR_UINT32_INPUTS(j) {
1531         uint32_t expected = *i << (*j & 0x1f);
1532         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
1533       }
1534     }
1535   }
1536   {
1537     RawMachineAssemblerTester<int32_t> m;
1538     Uint32BinopTester bt(&m);
1539     bt.AddReturn(
1540         m.Word32Shl(bt.param0, m.Word32And(m.Int32Constant(0x1f), bt.param1)));
1541     FOR_UINT32_INPUTS(i) {
1542       FOR_UINT32_INPUTS(j) {
1543         uint32_t expected = *i << (0x1f & *j);
1544         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
1545       }
1546     }
1547   }
1548 }
1549
1550
1551 TEST(RunWord32AndAndWord32ShrP) {
1552   {
1553     RawMachineAssemblerTester<int32_t> m;
1554     Uint32BinopTester bt(&m);
1555     bt.AddReturn(
1556         m.Word32Shr(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1f))));
1557     FOR_UINT32_INPUTS(i) {
1558       FOR_UINT32_INPUTS(j) {
1559         uint32_t expected = *i >> (*j & 0x1f);
1560         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
1561       }
1562     }
1563   }
1564   {
1565     RawMachineAssemblerTester<int32_t> m;
1566     Uint32BinopTester bt(&m);
1567     bt.AddReturn(
1568         m.Word32Shr(bt.param0, m.Word32And(m.Int32Constant(0x1f), bt.param1)));
1569     FOR_UINT32_INPUTS(i) {
1570       FOR_UINT32_INPUTS(j) {
1571         uint32_t expected = *i >> (0x1f & *j);
1572         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
1573       }
1574     }
1575   }
1576 }
1577
1578
1579 TEST(RunWord32AndAndWord32SarP) {
1580   {
1581     RawMachineAssemblerTester<int32_t> m;
1582     Int32BinopTester bt(&m);
1583     bt.AddReturn(
1584         m.Word32Sar(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1f))));
1585     FOR_INT32_INPUTS(i) {
1586       FOR_INT32_INPUTS(j) {
1587         int32_t expected = *i >> (*j & 0x1f);
1588         CHECK_EQ(expected, bt.call(*i, *j));
1589       }
1590     }
1591   }
1592   {
1593     RawMachineAssemblerTester<int32_t> m;
1594     Int32BinopTester bt(&m);
1595     bt.AddReturn(
1596         m.Word32Sar(bt.param0, m.Word32And(m.Int32Constant(0x1f), bt.param1)));
1597     FOR_INT32_INPUTS(i) {
1598       FOR_INT32_INPUTS(j) {
1599         uint32_t expected = *i >> (0x1f & *j);
1600         CHECK_EQ(expected, bt.call(*i, *j));
1601       }
1602     }
1603   }
1604 }
1605
1606
1607 TEST(RunWord32AndImm) {
1608   {
1609     FOR_UINT32_INPUTS(i) {
1610       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
1611       m.Return(m.Word32And(m.Int32Constant(*i), m.Parameter(0)));
1612       FOR_UINT32_INPUTS(j) {
1613         uint32_t expected = *i & *j;
1614         CHECK_UINT32_EQ(expected, m.Call(*j));
1615       }
1616     }
1617   }
1618   {
1619     FOR_UINT32_INPUTS(i) {
1620       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
1621       m.Return(m.Word32And(m.Int32Constant(*i), m.Word32Not(m.Parameter(0))));
1622       FOR_UINT32_INPUTS(j) {
1623         uint32_t expected = *i & ~(*j);
1624         CHECK_UINT32_EQ(expected, m.Call(*j));
1625       }
1626     }
1627   }
1628 }
1629
1630
1631 TEST(RunWord32AndInBranch) {
1632   static const int constant = 987654321;
1633   {
1634     RawMachineAssemblerTester<int32_t> m;
1635     Uint32BinopTester bt(&m);
1636     MLabel blocka, blockb;
1637     m.Branch(
1638         m.Word32Equal(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)),
1639         &blocka, &blockb);
1640     m.Bind(&blocka);
1641     bt.AddReturn(m.Int32Constant(constant));
1642     m.Bind(&blockb);
1643     bt.AddReturn(m.Int32Constant(0 - constant));
1644     FOR_UINT32_INPUTS(i) {
1645       FOR_UINT32_INPUTS(j) {
1646         int32_t expected = (*i & *j) == 0 ? constant : 0 - constant;
1647         CHECK_EQ(expected, bt.call(*i, *j));
1648       }
1649     }
1650   }
1651   {
1652     RawMachineAssemblerTester<int32_t> m;
1653     Uint32BinopTester bt(&m);
1654     MLabel blocka, blockb;
1655     m.Branch(
1656         m.Word32NotEqual(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)),
1657         &blocka, &blockb);
1658     m.Bind(&blocka);
1659     bt.AddReturn(m.Int32Constant(constant));
1660     m.Bind(&blockb);
1661     bt.AddReturn(m.Int32Constant(0 - constant));
1662     FOR_UINT32_INPUTS(i) {
1663       FOR_UINT32_INPUTS(j) {
1664         int32_t expected = (*i & *j) != 0 ? constant : 0 - constant;
1665         CHECK_EQ(expected, bt.call(*i, *j));
1666       }
1667     }
1668   }
1669   {
1670     FOR_UINT32_INPUTS(i) {
1671       RawMachineAssemblerTester<int32_t> m(kMachUint32);
1672       MLabel blocka, blockb;
1673       m.Branch(m.Word32Equal(m.Word32And(m.Int32Constant(*i), m.Parameter(0)),
1674                              m.Int32Constant(0)),
1675                &blocka, &blockb);
1676       m.Bind(&blocka);
1677       m.Return(m.Int32Constant(constant));
1678       m.Bind(&blockb);
1679       m.Return(m.Int32Constant(0 - constant));
1680       FOR_UINT32_INPUTS(j) {
1681         int32_t expected = (*i & *j) == 0 ? constant : 0 - constant;
1682         CHECK_EQ(expected, m.Call(*j));
1683       }
1684     }
1685   }
1686   {
1687     FOR_UINT32_INPUTS(i) {
1688       RawMachineAssemblerTester<int32_t> m(kMachUint32);
1689       MLabel blocka, blockb;
1690       m.Branch(
1691           m.Word32NotEqual(m.Word32And(m.Int32Constant(*i), m.Parameter(0)),
1692                            m.Int32Constant(0)),
1693           &blocka, &blockb);
1694       m.Bind(&blocka);
1695       m.Return(m.Int32Constant(constant));
1696       m.Bind(&blockb);
1697       m.Return(m.Int32Constant(0 - constant));
1698       FOR_UINT32_INPUTS(j) {
1699         int32_t expected = (*i & *j) != 0 ? constant : 0 - constant;
1700         CHECK_EQ(expected, m.Call(*j));
1701       }
1702     }
1703   }
1704   {
1705     RawMachineAssemblerTester<void> m;
1706     const Operator* shops[] = {m.machine()->Word32Sar(),
1707                                m.machine()->Word32Shl(),
1708                                m.machine()->Word32Shr()};
1709     for (size_t n = 0; n < arraysize(shops); n++) {
1710       RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
1711                                            kMachUint32);
1712       MLabel blocka, blockb;
1713       m.Branch(m.Word32Equal(m.Word32And(m.Parameter(0),
1714                                          m.NewNode(shops[n], m.Parameter(1),
1715                                                    m.Parameter(2))),
1716                              m.Int32Constant(0)),
1717                &blocka, &blockb);
1718       m.Bind(&blocka);
1719       m.Return(m.Int32Constant(constant));
1720       m.Bind(&blockb);
1721       m.Return(m.Int32Constant(0 - constant));
1722       FOR_UINT32_INPUTS(i) {
1723         FOR_INT32_INPUTS(j) {
1724           FOR_UINT32_SHIFTS(shift) {
1725             int32_t right;
1726             switch (shops[n]->opcode()) {
1727               default:
1728                 UNREACHABLE();
1729               case IrOpcode::kWord32Sar:
1730                 right = *j >> shift;
1731                 break;
1732               case IrOpcode::kWord32Shl:
1733                 right = *j << shift;
1734                 break;
1735               case IrOpcode::kWord32Shr:
1736                 right = static_cast<uint32_t>(*j) >> shift;
1737                 break;
1738             }
1739             int32_t expected = ((*i & right) == 0) ? constant : 0 - constant;
1740             CHECK_EQ(expected, m.Call(*i, *j, shift));
1741           }
1742         }
1743       }
1744     }
1745   }
1746 }
1747
1748
1749 TEST(RunWord32AndInComparison) {
1750   {
1751     RawMachineAssemblerTester<int32_t> m;
1752     Uint32BinopTester bt(&m);
1753     bt.AddReturn(
1754         m.Word32Equal(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)));
1755     FOR_UINT32_INPUTS(i) {
1756       FOR_UINT32_INPUTS(j) {
1757         uint32_t expected = (*i & *j) == 0;
1758         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
1759       }
1760     }
1761   }
1762   {
1763     RawMachineAssemblerTester<int32_t> m;
1764     Uint32BinopTester bt(&m);
1765     bt.AddReturn(
1766         m.Word32Equal(m.Int32Constant(0), m.Word32And(bt.param0, bt.param1)));
1767     FOR_UINT32_INPUTS(i) {
1768       FOR_UINT32_INPUTS(j) {
1769         uint32_t expected = (*i & *j) == 0;
1770         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
1771       }
1772     }
1773   }
1774   {
1775     FOR_UINT32_INPUTS(i) {
1776       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
1777       m.Return(m.Word32Equal(m.Word32And(m.Int32Constant(*i), m.Parameter(0)),
1778                              m.Int32Constant(0)));
1779       FOR_UINT32_INPUTS(j) {
1780         uint32_t expected = (*i & *j) == 0;
1781         CHECK_UINT32_EQ(expected, m.Call(*j));
1782       }
1783     }
1784   }
1785   {
1786     FOR_UINT32_INPUTS(i) {
1787       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
1788       m.Return(m.Word32Equal(m.Word32And(m.Parameter(0), m.Int32Constant(*i)),
1789                              m.Int32Constant(0)));
1790       FOR_UINT32_INPUTS(j) {
1791         uint32_t expected = (*j & *i) == 0;
1792         CHECK_UINT32_EQ(expected, m.Call(*j));
1793       }
1794     }
1795   }
1796 }
1797
1798
1799 TEST(RunWord32OrP) {
1800   {
1801     RawMachineAssemblerTester<int32_t> m;
1802     Uint32BinopTester bt(&m);
1803     bt.AddReturn(m.Word32Or(bt.param0, bt.param1));
1804     FOR_UINT32_INPUTS(i) {
1805       FOR_UINT32_INPUTS(j) {
1806         uint32_t expected = *i | *j;
1807         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
1808       }
1809     }
1810   }
1811   {
1812     RawMachineAssemblerTester<int32_t> m;
1813     Uint32BinopTester bt(&m);
1814     bt.AddReturn(m.Word32Or(bt.param0, m.Word32Not(bt.param1)));
1815     FOR_UINT32_INPUTS(i) {
1816       FOR_UINT32_INPUTS(j) {
1817         uint32_t expected = *i | ~(*j);
1818         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
1819       }
1820     }
1821   }
1822   {
1823     RawMachineAssemblerTester<int32_t> m;
1824     Uint32BinopTester bt(&m);
1825     bt.AddReturn(m.Word32Or(m.Word32Not(bt.param0), bt.param1));
1826     FOR_UINT32_INPUTS(i) {
1827       FOR_UINT32_INPUTS(j) {
1828         uint32_t expected = ~(*i) | *j;
1829         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
1830       }
1831     }
1832   }
1833 }
1834
1835
1836 TEST(RunWord32OrImm) {
1837   {
1838     FOR_UINT32_INPUTS(i) {
1839       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
1840       m.Return(m.Word32Or(m.Int32Constant(*i), m.Parameter(0)));
1841       FOR_UINT32_INPUTS(j) {
1842         uint32_t expected = *i | *j;
1843         CHECK_UINT32_EQ(expected, m.Call(*j));
1844       }
1845     }
1846   }
1847   {
1848     FOR_UINT32_INPUTS(i) {
1849       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
1850       m.Return(m.Word32Or(m.Int32Constant(*i), m.Word32Not(m.Parameter(0))));
1851       FOR_UINT32_INPUTS(j) {
1852         uint32_t expected = *i | ~(*j);
1853         CHECK_UINT32_EQ(expected, m.Call(*j));
1854       }
1855     }
1856   }
1857 }
1858
1859
1860 TEST(RunWord32OrInBranch) {
1861   static const int constant = 987654321;
1862   {
1863     RawMachineAssemblerTester<int32_t> m;
1864     Int32BinopTester bt(&m);
1865     MLabel blocka, blockb;
1866     m.Branch(
1867         m.Word32Equal(m.Word32Or(bt.param0, bt.param1), m.Int32Constant(0)),
1868         &blocka, &blockb);
1869     m.Bind(&blocka);
1870     bt.AddReturn(m.Int32Constant(constant));
1871     m.Bind(&blockb);
1872     bt.AddReturn(m.Int32Constant(0 - constant));
1873     FOR_INT32_INPUTS(i) {
1874       FOR_INT32_INPUTS(j) {
1875         int32_t expected = (*i | *j) == 0 ? constant : 0 - constant;
1876         CHECK_EQ(expected, bt.call(*i, *j));
1877       }
1878     }
1879   }
1880   {
1881     RawMachineAssemblerTester<int32_t> m;
1882     Int32BinopTester bt(&m);
1883     MLabel blocka, blockb;
1884     m.Branch(
1885         m.Word32NotEqual(m.Word32Or(bt.param0, bt.param1), m.Int32Constant(0)),
1886         &blocka, &blockb);
1887     m.Bind(&blocka);
1888     bt.AddReturn(m.Int32Constant(constant));
1889     m.Bind(&blockb);
1890     bt.AddReturn(m.Int32Constant(0 - constant));
1891     FOR_INT32_INPUTS(i) {
1892       FOR_INT32_INPUTS(j) {
1893         int32_t expected = (*i | *j) != 0 ? constant : 0 - constant;
1894         CHECK_EQ(expected, bt.call(*i, *j));
1895       }
1896     }
1897   }
1898   {
1899     FOR_INT32_INPUTS(i) {
1900       RawMachineAssemblerTester<int32_t> m(kMachInt32);
1901       MLabel blocka, blockb;
1902       m.Branch(m.Word32Equal(m.Word32Or(m.Int32Constant(*i), m.Parameter(0)),
1903                              m.Int32Constant(0)),
1904                &blocka, &blockb);
1905       m.Bind(&blocka);
1906       m.Return(m.Int32Constant(constant));
1907       m.Bind(&blockb);
1908       m.Return(m.Int32Constant(0 - constant));
1909       FOR_INT32_INPUTS(j) {
1910         int32_t expected = (*i | *j) == 0 ? constant : 0 - constant;
1911         CHECK_EQ(expected, m.Call(*j));
1912       }
1913     }
1914   }
1915   {
1916     FOR_INT32_INPUTS(i) {
1917       RawMachineAssemblerTester<int32_t> m(kMachInt32);
1918       MLabel blocka, blockb;
1919       m.Branch(m.Word32NotEqual(m.Word32Or(m.Int32Constant(*i), m.Parameter(0)),
1920                                 m.Int32Constant(0)),
1921                &blocka, &blockb);
1922       m.Bind(&blocka);
1923       m.Return(m.Int32Constant(constant));
1924       m.Bind(&blockb);
1925       m.Return(m.Int32Constant(0 - constant));
1926       FOR_INT32_INPUTS(j) {
1927         int32_t expected = (*i | *j) != 0 ? constant : 0 - constant;
1928         CHECK_EQ(expected, m.Call(*j));
1929       }
1930     }
1931   }
1932   {
1933     RawMachineAssemblerTester<void> m;
1934     const Operator* shops[] = {m.machine()->Word32Sar(),
1935                                m.machine()->Word32Shl(),
1936                                m.machine()->Word32Shr()};
1937     for (size_t n = 0; n < arraysize(shops); n++) {
1938       RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
1939                                            kMachUint32);
1940       MLabel blocka, blockb;
1941       m.Branch(m.Word32Equal(m.Word32Or(m.Parameter(0),
1942                                         m.NewNode(shops[n], m.Parameter(1),
1943                                                   m.Parameter(2))),
1944                              m.Int32Constant(0)),
1945                &blocka, &blockb);
1946       m.Bind(&blocka);
1947       m.Return(m.Int32Constant(constant));
1948       m.Bind(&blockb);
1949       m.Return(m.Int32Constant(0 - constant));
1950       FOR_UINT32_INPUTS(i) {
1951         FOR_INT32_INPUTS(j) {
1952           FOR_UINT32_SHIFTS(shift) {
1953             int32_t right;
1954             switch (shops[n]->opcode()) {
1955               default:
1956                 UNREACHABLE();
1957               case IrOpcode::kWord32Sar:
1958                 right = *j >> shift;
1959                 break;
1960               case IrOpcode::kWord32Shl:
1961                 right = *j << shift;
1962                 break;
1963               case IrOpcode::kWord32Shr:
1964                 right = static_cast<uint32_t>(*j) >> shift;
1965                 break;
1966             }
1967             int32_t expected = ((*i | right) == 0) ? constant : 0 - constant;
1968             CHECK_EQ(expected, m.Call(*i, *j, shift));
1969           }
1970         }
1971       }
1972     }
1973   }
1974 }
1975
1976
1977 TEST(RunWord32OrInComparison) {
1978   {
1979     RawMachineAssemblerTester<int32_t> m;
1980     Uint32BinopTester bt(&m);
1981     bt.AddReturn(
1982         m.Word32Equal(m.Word32Or(bt.param0, bt.param1), m.Int32Constant(0)));
1983     FOR_UINT32_INPUTS(i) {
1984       FOR_UINT32_INPUTS(j) {
1985         int32_t expected = (*i | *j) == 0;
1986         CHECK_EQ(expected, bt.call(*i, *j));
1987       }
1988     }
1989   }
1990   {
1991     RawMachineAssemblerTester<int32_t> m;
1992     Uint32BinopTester bt(&m);
1993     bt.AddReturn(
1994         m.Word32Equal(m.Int32Constant(0), m.Word32Or(bt.param0, bt.param1)));
1995     FOR_UINT32_INPUTS(i) {
1996       FOR_UINT32_INPUTS(j) {
1997         int32_t expected = (*i | *j) == 0;
1998         CHECK_EQ(expected, bt.call(*i, *j));
1999       }
2000     }
2001   }
2002   {
2003     FOR_UINT32_INPUTS(i) {
2004       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
2005       m.Return(m.Word32Equal(m.Word32Or(m.Int32Constant(*i), m.Parameter(0)),
2006                              m.Int32Constant(0)));
2007       FOR_UINT32_INPUTS(j) {
2008         uint32_t expected = (*i | *j) == 0;
2009         CHECK_UINT32_EQ(expected, m.Call(*j));
2010       }
2011     }
2012   }
2013   {
2014     FOR_UINT32_INPUTS(i) {
2015       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
2016       m.Return(m.Word32Equal(m.Word32Or(m.Parameter(0), m.Int32Constant(*i)),
2017                              m.Int32Constant(0)));
2018       FOR_UINT32_INPUTS(j) {
2019         uint32_t expected = (*j | *i) == 0;
2020         CHECK_UINT32_EQ(expected, m.Call(*j));
2021       }
2022     }
2023   }
2024 }
2025
2026
2027 TEST(RunWord32XorP) {
2028   {
2029     FOR_UINT32_INPUTS(i) {
2030       RawMachineAssemblerTester<int32_t> m(kMachUint32);
2031       m.Return(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0)));
2032       FOR_UINT32_INPUTS(j) {
2033         uint32_t expected = *i ^ *j;
2034         CHECK_UINT32_EQ(expected, m.Call(*j));
2035       }
2036     }
2037   }
2038   {
2039     RawMachineAssemblerTester<int32_t> m;
2040     Uint32BinopTester bt(&m);
2041     bt.AddReturn(m.Word32Xor(bt.param0, bt.param1));
2042     FOR_UINT32_INPUTS(i) {
2043       FOR_UINT32_INPUTS(j) {
2044         int32_t expected = *i ^ *j;
2045         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
2046       }
2047     }
2048   }
2049   {
2050     RawMachineAssemblerTester<int32_t> m;
2051     Int32BinopTester bt(&m);
2052     bt.AddReturn(m.Word32Xor(bt.param0, m.Word32Not(bt.param1)));
2053     FOR_INT32_INPUTS(i) {
2054       FOR_INT32_INPUTS(j) {
2055         int32_t expected = *i ^ ~(*j);
2056         CHECK_EQ(expected, bt.call(*i, *j));
2057       }
2058     }
2059   }
2060   {
2061     RawMachineAssemblerTester<int32_t> m;
2062     Int32BinopTester bt(&m);
2063     bt.AddReturn(m.Word32Xor(m.Word32Not(bt.param0), bt.param1));
2064     FOR_INT32_INPUTS(i) {
2065       FOR_INT32_INPUTS(j) {
2066         int32_t expected = ~(*i) ^ *j;
2067         CHECK_EQ(expected, bt.call(*i, *j));
2068       }
2069     }
2070   }
2071   {
2072     FOR_UINT32_INPUTS(i) {
2073       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
2074       m.Return(m.Word32Xor(m.Int32Constant(*i), m.Word32Not(m.Parameter(0))));
2075       FOR_UINT32_INPUTS(j) {
2076         uint32_t expected = *i ^ ~(*j);
2077         CHECK_UINT32_EQ(expected, m.Call(*j));
2078       }
2079     }
2080   }
2081 }
2082
2083
2084 TEST(RunWord32XorInBranch) {
2085   static const uint32_t constant = 987654321;
2086   {
2087     RawMachineAssemblerTester<int32_t> m;
2088     Uint32BinopTester bt(&m);
2089     MLabel blocka, blockb;
2090     m.Branch(
2091         m.Word32Equal(m.Word32Xor(bt.param0, bt.param1), m.Int32Constant(0)),
2092         &blocka, &blockb);
2093     m.Bind(&blocka);
2094     bt.AddReturn(m.Int32Constant(constant));
2095     m.Bind(&blockb);
2096     bt.AddReturn(m.Int32Constant(0 - constant));
2097     FOR_UINT32_INPUTS(i) {
2098       FOR_UINT32_INPUTS(j) {
2099         uint32_t expected = (*i ^ *j) == 0 ? constant : 0 - constant;
2100         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
2101       }
2102     }
2103   }
2104   {
2105     RawMachineAssemblerTester<int32_t> m;
2106     Uint32BinopTester bt(&m);
2107     MLabel blocka, blockb;
2108     m.Branch(
2109         m.Word32NotEqual(m.Word32Xor(bt.param0, bt.param1), m.Int32Constant(0)),
2110         &blocka, &blockb);
2111     m.Bind(&blocka);
2112     bt.AddReturn(m.Int32Constant(constant));
2113     m.Bind(&blockb);
2114     bt.AddReturn(m.Int32Constant(0 - constant));
2115     FOR_UINT32_INPUTS(i) {
2116       FOR_UINT32_INPUTS(j) {
2117         uint32_t expected = (*i ^ *j) != 0 ? constant : 0 - constant;
2118         CHECK_UINT32_EQ(expected, bt.call(*i, *j));
2119       }
2120     }
2121   }
2122   {
2123     FOR_UINT32_INPUTS(i) {
2124       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
2125       MLabel blocka, blockb;
2126       m.Branch(m.Word32Equal(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0)),
2127                              m.Int32Constant(0)),
2128                &blocka, &blockb);
2129       m.Bind(&blocka);
2130       m.Return(m.Int32Constant(constant));
2131       m.Bind(&blockb);
2132       m.Return(m.Int32Constant(0 - constant));
2133       FOR_UINT32_INPUTS(j) {
2134         uint32_t expected = (*i ^ *j) == 0 ? constant : 0 - constant;
2135         CHECK_UINT32_EQ(expected, m.Call(*j));
2136       }
2137     }
2138   }
2139   {
2140     FOR_UINT32_INPUTS(i) {
2141       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
2142       MLabel blocka, blockb;
2143       m.Branch(
2144           m.Word32NotEqual(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0)),
2145                            m.Int32Constant(0)),
2146           &blocka, &blockb);
2147       m.Bind(&blocka);
2148       m.Return(m.Int32Constant(constant));
2149       m.Bind(&blockb);
2150       m.Return(m.Int32Constant(0 - constant));
2151       FOR_UINT32_INPUTS(j) {
2152         uint32_t expected = (*i ^ *j) != 0 ? constant : 0 - constant;
2153         CHECK_UINT32_EQ(expected, m.Call(*j));
2154       }
2155     }
2156   }
2157   {
2158     RawMachineAssemblerTester<void> m;
2159     const Operator* shops[] = {m.machine()->Word32Sar(),
2160                                m.machine()->Word32Shl(),
2161                                m.machine()->Word32Shr()};
2162     for (size_t n = 0; n < arraysize(shops); n++) {
2163       RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
2164                                            kMachUint32);
2165       MLabel blocka, blockb;
2166       m.Branch(m.Word32Equal(m.Word32Xor(m.Parameter(0),
2167                                          m.NewNode(shops[n], m.Parameter(1),
2168                                                    m.Parameter(2))),
2169                              m.Int32Constant(0)),
2170                &blocka, &blockb);
2171       m.Bind(&blocka);
2172       m.Return(m.Int32Constant(constant));
2173       m.Bind(&blockb);
2174       m.Return(m.Int32Constant(0 - constant));
2175       FOR_UINT32_INPUTS(i) {
2176         FOR_INT32_INPUTS(j) {
2177           FOR_UINT32_SHIFTS(shift) {
2178             int32_t right;
2179             switch (shops[n]->opcode()) {
2180               default:
2181                 UNREACHABLE();
2182               case IrOpcode::kWord32Sar:
2183                 right = *j >> shift;
2184                 break;
2185               case IrOpcode::kWord32Shl:
2186                 right = *j << shift;
2187                 break;
2188               case IrOpcode::kWord32Shr:
2189                 right = static_cast<uint32_t>(*j) >> shift;
2190                 break;
2191             }
2192             int32_t expected = ((*i ^ right) == 0) ? constant : 0 - constant;
2193             CHECK_EQ(expected, m.Call(*i, *j, shift));
2194           }
2195         }
2196       }
2197     }
2198   }
2199 }
2200
2201
2202 TEST(RunWord32ShlP) {
2203   {
2204     FOR_UINT32_SHIFTS(shift) {
2205       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
2206       m.Return(m.Word32Shl(m.Parameter(0), m.Int32Constant(shift)));
2207       FOR_UINT32_INPUTS(j) {
2208         uint32_t expected = *j << shift;
2209         CHECK_UINT32_EQ(expected, m.Call(*j));
2210       }
2211     }
2212   }
2213   {
2214     RawMachineAssemblerTester<int32_t> m;
2215     Uint32BinopTester bt(&m);
2216     bt.AddReturn(m.Word32Shl(bt.param0, bt.param1));
2217     FOR_UINT32_INPUTS(i) {
2218       FOR_UINT32_SHIFTS(shift) {
2219         uint32_t expected = *i << shift;
2220         CHECK_UINT32_EQ(expected, bt.call(*i, shift));
2221       }
2222     }
2223   }
2224 }
2225
2226
2227 TEST(RunWord32ShlInComparison) {
2228   {
2229     RawMachineAssemblerTester<int32_t> m;
2230     Uint32BinopTester bt(&m);
2231     bt.AddReturn(
2232         m.Word32Equal(m.Word32Shl(bt.param0, bt.param1), m.Int32Constant(0)));
2233     FOR_UINT32_INPUTS(i) {
2234       FOR_UINT32_SHIFTS(shift) {
2235         uint32_t expected = 0 == (*i << shift);
2236         CHECK_UINT32_EQ(expected, bt.call(*i, shift));
2237       }
2238     }
2239   }
2240   {
2241     RawMachineAssemblerTester<int32_t> m;
2242     Uint32BinopTester bt(&m);
2243     bt.AddReturn(
2244         m.Word32Equal(m.Int32Constant(0), m.Word32Shl(bt.param0, bt.param1)));
2245     FOR_UINT32_INPUTS(i) {
2246       FOR_UINT32_SHIFTS(shift) {
2247         uint32_t expected = 0 == (*i << shift);
2248         CHECK_UINT32_EQ(expected, bt.call(*i, shift));
2249       }
2250     }
2251   }
2252   {
2253     FOR_UINT32_SHIFTS(shift) {
2254       RawMachineAssemblerTester<int32_t> m(kMachUint32);
2255       m.Return(
2256           m.Word32Equal(m.Int32Constant(0),
2257                         m.Word32Shl(m.Parameter(0), m.Int32Constant(shift))));
2258       FOR_UINT32_INPUTS(i) {
2259         uint32_t expected = 0 == (*i << shift);
2260         CHECK_UINT32_EQ(expected, m.Call(*i));
2261       }
2262     }
2263   }
2264   {
2265     FOR_UINT32_SHIFTS(shift) {
2266       RawMachineAssemblerTester<int32_t> m(kMachUint32);
2267       m.Return(
2268           m.Word32Equal(m.Word32Shl(m.Parameter(0), m.Int32Constant(shift)),
2269                         m.Int32Constant(0)));
2270       FOR_UINT32_INPUTS(i) {
2271         uint32_t expected = 0 == (*i << shift);
2272         CHECK_UINT32_EQ(expected, m.Call(*i));
2273       }
2274     }
2275   }
2276 }
2277
2278
2279 TEST(RunWord32ShrP) {
2280   {
2281     FOR_UINT32_SHIFTS(shift) {
2282       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
2283       m.Return(m.Word32Shr(m.Parameter(0), m.Int32Constant(shift)));
2284       FOR_UINT32_INPUTS(j) {
2285         uint32_t expected = *j >> shift;
2286         CHECK_UINT32_EQ(expected, m.Call(*j));
2287       }
2288     }
2289   }
2290   {
2291     RawMachineAssemblerTester<int32_t> m;
2292     Uint32BinopTester bt(&m);
2293     bt.AddReturn(m.Word32Shr(bt.param0, bt.param1));
2294     FOR_UINT32_INPUTS(i) {
2295       FOR_UINT32_SHIFTS(shift) {
2296         uint32_t expected = *i >> shift;
2297         CHECK_UINT32_EQ(expected, bt.call(*i, shift));
2298       }
2299     }
2300     CHECK_EQ(0x00010000, bt.call(0x80000000, 15));
2301   }
2302 }
2303
2304
2305 TEST(RunWord32ShrInComparison) {
2306   {
2307     RawMachineAssemblerTester<int32_t> m;
2308     Uint32BinopTester bt(&m);
2309     bt.AddReturn(
2310         m.Word32Equal(m.Word32Shr(bt.param0, bt.param1), m.Int32Constant(0)));
2311     FOR_UINT32_INPUTS(i) {
2312       FOR_UINT32_SHIFTS(shift) {
2313         uint32_t expected = 0 == (*i >> shift);
2314         CHECK_UINT32_EQ(expected, bt.call(*i, shift));
2315       }
2316     }
2317   }
2318   {
2319     RawMachineAssemblerTester<int32_t> m;
2320     Uint32BinopTester bt(&m);
2321     bt.AddReturn(
2322         m.Word32Equal(m.Int32Constant(0), m.Word32Shr(bt.param0, bt.param1)));
2323     FOR_UINT32_INPUTS(i) {
2324       FOR_UINT32_SHIFTS(shift) {
2325         uint32_t expected = 0 == (*i >> shift);
2326         CHECK_UINT32_EQ(expected, bt.call(*i, shift));
2327       }
2328     }
2329   }
2330   {
2331     FOR_UINT32_SHIFTS(shift) {
2332       RawMachineAssemblerTester<int32_t> m(kMachUint32);
2333       m.Return(
2334           m.Word32Equal(m.Int32Constant(0),
2335                         m.Word32Shr(m.Parameter(0), m.Int32Constant(shift))));
2336       FOR_UINT32_INPUTS(i) {
2337         uint32_t expected = 0 == (*i >> shift);
2338         CHECK_UINT32_EQ(expected, m.Call(*i));
2339       }
2340     }
2341   }
2342   {
2343     FOR_UINT32_SHIFTS(shift) {
2344       RawMachineAssemblerTester<int32_t> m(kMachUint32);
2345       m.Return(
2346           m.Word32Equal(m.Word32Shr(m.Parameter(0), m.Int32Constant(shift)),
2347                         m.Int32Constant(0)));
2348       FOR_UINT32_INPUTS(i) {
2349         uint32_t expected = 0 == (*i >> shift);
2350         CHECK_UINT32_EQ(expected, m.Call(*i));
2351       }
2352     }
2353   }
2354 }
2355
2356
2357 TEST(RunWord32SarP) {
2358   {
2359     FOR_INT32_SHIFTS(shift) {
2360       RawMachineAssemblerTester<int32_t> m(kMachInt32);
2361       m.Return(m.Word32Sar(m.Parameter(0), m.Int32Constant(shift)));
2362       FOR_INT32_INPUTS(j) {
2363         int32_t expected = *j >> shift;
2364         CHECK_EQ(expected, m.Call(*j));
2365       }
2366     }
2367   }
2368   {
2369     RawMachineAssemblerTester<int32_t> m;
2370     Int32BinopTester bt(&m);
2371     bt.AddReturn(m.Word32Sar(bt.param0, bt.param1));
2372     FOR_INT32_INPUTS(i) {
2373       FOR_INT32_SHIFTS(shift) {
2374         int32_t expected = *i >> shift;
2375         CHECK_EQ(expected, bt.call(*i, shift));
2376       }
2377     }
2378     CHECK_EQ(0xFFFF0000, bt.call(0x80000000, 15));
2379   }
2380 }
2381
2382
2383 TEST(RunWord32SarInComparison) {
2384   {
2385     RawMachineAssemblerTester<int32_t> m;
2386     Int32BinopTester bt(&m);
2387     bt.AddReturn(
2388         m.Word32Equal(m.Word32Sar(bt.param0, bt.param1), m.Int32Constant(0)));
2389     FOR_INT32_INPUTS(i) {
2390       FOR_INT32_SHIFTS(shift) {
2391         int32_t expected = 0 == (*i >> shift);
2392         CHECK_EQ(expected, bt.call(*i, shift));
2393       }
2394     }
2395   }
2396   {
2397     RawMachineAssemblerTester<int32_t> m;
2398     Int32BinopTester bt(&m);
2399     bt.AddReturn(
2400         m.Word32Equal(m.Int32Constant(0), m.Word32Sar(bt.param0, bt.param1)));
2401     FOR_INT32_INPUTS(i) {
2402       FOR_INT32_SHIFTS(shift) {
2403         int32_t expected = 0 == (*i >> shift);
2404         CHECK_EQ(expected, bt.call(*i, shift));
2405       }
2406     }
2407   }
2408   {
2409     FOR_INT32_SHIFTS(shift) {
2410       RawMachineAssemblerTester<int32_t> m(kMachInt32);
2411       m.Return(
2412           m.Word32Equal(m.Int32Constant(0),
2413                         m.Word32Sar(m.Parameter(0), m.Int32Constant(shift))));
2414       FOR_INT32_INPUTS(i) {
2415         int32_t expected = 0 == (*i >> shift);
2416         CHECK_EQ(expected, m.Call(*i));
2417       }
2418     }
2419   }
2420   {
2421     FOR_INT32_SHIFTS(shift) {
2422       RawMachineAssemblerTester<int32_t> m(kMachInt32);
2423       m.Return(
2424           m.Word32Equal(m.Word32Sar(m.Parameter(0), m.Int32Constant(shift)),
2425                         m.Int32Constant(0)));
2426       FOR_INT32_INPUTS(i) {
2427         uint32_t expected = 0 == (*i >> shift);
2428         CHECK_EQ(expected, m.Call(*i));
2429       }
2430     }
2431   }
2432 }
2433
2434
2435 TEST(RunWord32RorP) {
2436   {
2437     FOR_UINT32_SHIFTS(shift) {
2438       RawMachineAssemblerTester<int32_t> m(kMachUint32);
2439       m.Return(m.Word32Ror(m.Parameter(0), m.Int32Constant(shift)));
2440       FOR_UINT32_INPUTS(j) {
2441         int32_t expected = bits::RotateRight32(*j, shift);
2442         CHECK_EQ(expected, m.Call(*j));
2443       }
2444     }
2445   }
2446   {
2447     RawMachineAssemblerTester<int32_t> m;
2448     Uint32BinopTester bt(&m);
2449     bt.AddReturn(m.Word32Ror(bt.param0, bt.param1));
2450     FOR_UINT32_INPUTS(i) {
2451       FOR_UINT32_SHIFTS(shift) {
2452         uint32_t expected = bits::RotateRight32(*i, shift);
2453         CHECK_UINT32_EQ(expected, bt.call(*i, shift));
2454       }
2455     }
2456   }
2457 }
2458
2459
2460 TEST(RunWord32RorInComparison) {
2461   {
2462     RawMachineAssemblerTester<int32_t> m;
2463     Uint32BinopTester bt(&m);
2464     bt.AddReturn(
2465         m.Word32Equal(m.Word32Ror(bt.param0, bt.param1), m.Int32Constant(0)));
2466     FOR_UINT32_INPUTS(i) {
2467       FOR_UINT32_SHIFTS(shift) {
2468         uint32_t expected = 0 == bits::RotateRight32(*i, shift);
2469         CHECK_UINT32_EQ(expected, bt.call(*i, shift));
2470       }
2471     }
2472   }
2473   {
2474     RawMachineAssemblerTester<int32_t> m;
2475     Uint32BinopTester bt(&m);
2476     bt.AddReturn(
2477         m.Word32Equal(m.Int32Constant(0), m.Word32Ror(bt.param0, bt.param1)));
2478     FOR_UINT32_INPUTS(i) {
2479       FOR_UINT32_SHIFTS(shift) {
2480         uint32_t expected = 0 == bits::RotateRight32(*i, shift);
2481         CHECK_UINT32_EQ(expected, bt.call(*i, shift));
2482       }
2483     }
2484   }
2485   {
2486     FOR_UINT32_SHIFTS(shift) {
2487       RawMachineAssemblerTester<int32_t> m(kMachUint32);
2488       m.Return(
2489           m.Word32Equal(m.Int32Constant(0),
2490                         m.Word32Ror(m.Parameter(0), m.Int32Constant(shift))));
2491       FOR_UINT32_INPUTS(i) {
2492         uint32_t expected = 0 == bits::RotateRight32(*i, shift);
2493         CHECK_UINT32_EQ(expected, m.Call(*i));
2494       }
2495     }
2496   }
2497   {
2498     FOR_UINT32_SHIFTS(shift) {
2499       RawMachineAssemblerTester<int32_t> m(kMachUint32);
2500       m.Return(
2501           m.Word32Equal(m.Word32Ror(m.Parameter(0), m.Int32Constant(shift)),
2502                         m.Int32Constant(0)));
2503       FOR_UINT32_INPUTS(i) {
2504         uint32_t expected = 0 == bits::RotateRight32(*i, shift);
2505         CHECK_UINT32_EQ(expected, m.Call(*i));
2506       }
2507     }
2508   }
2509 }
2510
2511
2512 TEST(RunWord32NotP) {
2513   RawMachineAssemblerTester<int32_t> m(kMachInt32);
2514   m.Return(m.Word32Not(m.Parameter(0)));
2515   FOR_INT32_INPUTS(i) {
2516     int expected = ~(*i);
2517     CHECK_EQ(expected, m.Call(*i));
2518   }
2519 }
2520
2521
2522 TEST(RunInt32NegP) {
2523   RawMachineAssemblerTester<int32_t> m(kMachInt32);
2524   m.Return(m.Int32Neg(m.Parameter(0)));
2525   FOR_INT32_INPUTS(i) {
2526     int expected = -*i;
2527     CHECK_EQ(expected, m.Call(*i));
2528   }
2529 }
2530
2531
2532 TEST(RunWord32EqualAndWord32SarP) {
2533   {
2534     RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachUint32);
2535     m.Return(m.Word32Equal(m.Parameter(0),
2536                            m.Word32Sar(m.Parameter(1), m.Parameter(2))));
2537     FOR_INT32_INPUTS(i) {
2538       FOR_INT32_INPUTS(j) {
2539         FOR_UINT32_SHIFTS(shift) {
2540           int32_t expected = (*i == (*j >> shift));
2541           CHECK_EQ(expected, m.Call(*i, *j, shift));
2542         }
2543       }
2544     }
2545   }
2546   {
2547     RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachUint32, kMachInt32);
2548     m.Return(m.Word32Equal(m.Word32Sar(m.Parameter(0), m.Parameter(1)),
2549                            m.Parameter(2)));
2550     FOR_INT32_INPUTS(i) {
2551       FOR_UINT32_SHIFTS(shift) {
2552         FOR_INT32_INPUTS(k) {
2553           int32_t expected = ((*i >> shift) == *k);
2554           CHECK_EQ(expected, m.Call(*i, shift, *k));
2555         }
2556       }
2557     }
2558   }
2559 }
2560
2561
2562 TEST(RunWord32EqualAndWord32ShlP) {
2563   {
2564     RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachUint32, kMachUint32);
2565     m.Return(m.Word32Equal(m.Parameter(0),
2566                            m.Word32Shl(m.Parameter(1), m.Parameter(2))));
2567     FOR_UINT32_INPUTS(i) {
2568       FOR_UINT32_INPUTS(j) {
2569         FOR_UINT32_SHIFTS(shift) {
2570           int32_t expected = (*i == (*j << shift));
2571           CHECK_EQ(expected, m.Call(*i, *j, shift));
2572         }
2573       }
2574     }
2575   }
2576   {
2577     RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachUint32, kMachUint32);
2578     m.Return(m.Word32Equal(m.Word32Shl(m.Parameter(0), m.Parameter(1)),
2579                            m.Parameter(2)));
2580     FOR_UINT32_INPUTS(i) {
2581       FOR_UINT32_SHIFTS(shift) {
2582         FOR_UINT32_INPUTS(k) {
2583           int32_t expected = ((*i << shift) == *k);
2584           CHECK_EQ(expected, m.Call(*i, shift, *k));
2585         }
2586       }
2587     }
2588   }
2589 }
2590
2591
2592 TEST(RunWord32EqualAndWord32ShrP) {
2593   {
2594     RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachUint32, kMachUint32);
2595     m.Return(m.Word32Equal(m.Parameter(0),
2596                            m.Word32Shr(m.Parameter(1), m.Parameter(2))));
2597     FOR_UINT32_INPUTS(i) {
2598       FOR_UINT32_INPUTS(j) {
2599         FOR_UINT32_SHIFTS(shift) {
2600           int32_t expected = (*i == (*j >> shift));
2601           CHECK_EQ(expected, m.Call(*i, *j, shift));
2602         }
2603       }
2604     }
2605   }
2606   {
2607     RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachUint32, kMachUint32);
2608     m.Return(m.Word32Equal(m.Word32Shr(m.Parameter(0), m.Parameter(1)),
2609                            m.Parameter(2)));
2610     FOR_UINT32_INPUTS(i) {
2611       FOR_UINT32_SHIFTS(shift) {
2612         FOR_UINT32_INPUTS(k) {
2613           int32_t expected = ((*i >> shift) == *k);
2614           CHECK_EQ(expected, m.Call(*i, shift, *k));
2615         }
2616       }
2617     }
2618   }
2619 }
2620
2621
2622 TEST(RunDeadNodes) {
2623   for (int i = 0; true; i++) {
2624     RawMachineAssemblerTester<int32_t> m(i == 5 ? kMachInt32 : kMachNone);
2625     int constant = 0x55 + i;
2626     switch (i) {
2627       case 0:
2628         m.Int32Constant(44);
2629         break;
2630       case 1:
2631         m.StringConstant("unused");
2632         break;
2633       case 2:
2634         m.NumberConstant(11.1);
2635         break;
2636       case 3:
2637         m.PointerConstant(&constant);
2638         break;
2639       case 4:
2640         m.LoadFromPointer(&constant, kMachInt32);
2641         break;
2642       case 5:
2643         m.Parameter(0);
2644         break;
2645       default:
2646         return;
2647     }
2648     m.Return(m.Int32Constant(constant));
2649     if (i != 5) {
2650       CHECK_EQ(constant, m.Call());
2651     } else {
2652       CHECK_EQ(constant, m.Call(0));
2653     }
2654   }
2655 }
2656
2657
2658 TEST(RunDeadInt32Binops) {
2659   RawMachineAssemblerTester<int32_t> m;
2660
2661   const Operator* ops[] = {
2662       m.machine()->Word32And(),             m.machine()->Word32Or(),
2663       m.machine()->Word32Xor(),             m.machine()->Word32Shl(),
2664       m.machine()->Word32Shr(),             m.machine()->Word32Sar(),
2665       m.machine()->Word32Ror(),             m.machine()->Word32Equal(),
2666       m.machine()->Int32Add(),              m.machine()->Int32Sub(),
2667       m.machine()->Int32Mul(),              m.machine()->Int32Div(),
2668       m.machine()->Int32UDiv(),             m.machine()->Int32Mod(),
2669       m.machine()->Int32UMod(),             m.machine()->Int32LessThan(),
2670       m.machine()->Int32LessThanOrEqual(),  m.machine()->Uint32LessThan(),
2671       m.machine()->Uint32LessThanOrEqual(), NULL};
2672
2673   for (int i = 0; ops[i] != NULL; i++) {
2674     RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
2675     int constant = 0x55555 + i;
2676     m.NewNode(ops[i], m.Parameter(0), m.Parameter(1));
2677     m.Return(m.Int32Constant(constant));
2678
2679     CHECK_EQ(constant, m.Call(1, 1));
2680   }
2681 }
2682
2683
2684 template <typename Type>
2685 static void RunLoadImmIndex(MachineType rep) {
2686   const int kNumElems = 3;
2687   Type buffer[kNumElems];
2688
2689   // initialize the buffer with raw data.
2690   byte* raw = reinterpret_cast<byte*>(buffer);
2691   for (size_t i = 0; i < sizeof(buffer); i++) {
2692     raw[i] = static_cast<byte>((i + sizeof(buffer)) ^ 0xAA);
2693   }
2694
2695   // Test with various large and small offsets.
2696   for (int offset = -1; offset <= 200000; offset *= -5) {
2697     for (int i = 0; i < kNumElems; i++) {
2698       RawMachineAssemblerTester<Type> m;
2699       Node* base = m.PointerConstant(buffer - offset);
2700       Node* index = m.Int32Constant((offset + i) * sizeof(buffer[0]));
2701       m.Return(m.Load(rep, base, index));
2702
2703       Type expected = buffer[i];
2704       Type actual = m.Call();
2705       CHECK(expected == actual);
2706     }
2707   }
2708 }
2709
2710
2711 TEST(RunLoadImmIndex) {
2712   RunLoadImmIndex<int8_t>(kMachInt8);
2713   RunLoadImmIndex<uint8_t>(kMachUint8);
2714   RunLoadImmIndex<int16_t>(kMachInt16);
2715   RunLoadImmIndex<uint16_t>(kMachUint16);
2716   RunLoadImmIndex<int32_t>(kMachInt32);
2717   RunLoadImmIndex<uint32_t>(kMachUint32);
2718   RunLoadImmIndex<int32_t*>(kMachAnyTagged);
2719
2720   // TODO(titzer): test kRepBit loads
2721   // TODO(titzer): test kMachFloat64 loads
2722   // TODO(titzer): test various indexing modes.
2723 }
2724
2725
2726 template <typename CType>
2727 static void RunLoadStore(MachineType rep) {
2728   const int kNumElems = 4;
2729   CType buffer[kNumElems];
2730
2731   for (int32_t x = 0; x < kNumElems; x++) {
2732     int32_t y = kNumElems - x - 1;
2733     // initialize the buffer with raw data.
2734     byte* raw = reinterpret_cast<byte*>(buffer);
2735     for (size_t i = 0; i < sizeof(buffer); i++) {
2736       raw[i] = static_cast<byte>((i + sizeof(buffer)) ^ 0xAA);
2737     }
2738
2739     RawMachineAssemblerTester<int32_t> m;
2740     int32_t OK = 0x29000 + x;
2741     Node* base = m.PointerConstant(buffer);
2742     Node* index0 = m.Int32Constant(x * sizeof(buffer[0]));
2743     Node* load = m.Load(rep, base, index0);
2744     Node* index1 = m.Int32Constant(y * sizeof(buffer[0]));
2745     m.Store(rep, base, index1, load);
2746     m.Return(m.Int32Constant(OK));
2747
2748     CHECK(buffer[x] != buffer[y]);
2749     CHECK_EQ(OK, m.Call());
2750     CHECK(buffer[x] == buffer[y]);
2751   }
2752 }
2753
2754
2755 TEST(RunLoadStore) {
2756   RunLoadStore<int8_t>(kMachInt8);
2757   RunLoadStore<uint8_t>(kMachUint8);
2758   RunLoadStore<int16_t>(kMachInt16);
2759   RunLoadStore<uint16_t>(kMachUint16);
2760   RunLoadStore<int32_t>(kMachInt32);
2761   RunLoadStore<uint32_t>(kMachUint32);
2762   RunLoadStore<void*>(kMachAnyTagged);
2763   RunLoadStore<float>(kMachFloat32);
2764   RunLoadStore<double>(kMachFloat64);
2765 }
2766
2767
2768 TEST(RunFloat64Binop) {
2769   RawMachineAssemblerTester<int32_t> m;
2770   double result;
2771
2772   const Operator* ops[] = {m.machine()->Float64Add(), m.machine()->Float64Sub(),
2773                            m.machine()->Float64Mul(), m.machine()->Float64Div(),
2774                            m.machine()->Float64Mod(), NULL};
2775
2776   double inf = V8_INFINITY;
2777   const Operator* inputs[] = {
2778       m.common()->Float64Constant(0),     m.common()->Float64Constant(1),
2779       m.common()->Float64Constant(1),     m.common()->Float64Constant(0),
2780       m.common()->Float64Constant(0),     m.common()->Float64Constant(-1),
2781       m.common()->Float64Constant(-1),    m.common()->Float64Constant(0),
2782       m.common()->Float64Constant(0.22),  m.common()->Float64Constant(-1.22),
2783       m.common()->Float64Constant(-1.22), m.common()->Float64Constant(0.22),
2784       m.common()->Float64Constant(inf),   m.common()->Float64Constant(0.22),
2785       m.common()->Float64Constant(inf),   m.common()->Float64Constant(-inf),
2786       NULL};
2787
2788   for (int i = 0; ops[i] != NULL; i++) {
2789     for (int j = 0; inputs[j] != NULL; j += 2) {
2790       RawMachineAssemblerTester<int32_t> m;
2791       Node* a = m.NewNode(inputs[j]);
2792       Node* b = m.NewNode(inputs[j + 1]);
2793       Node* binop = m.NewNode(ops[i], a, b);
2794       Node* base = m.PointerConstant(&result);
2795       Node* zero = m.Int32Constant(0);
2796       m.Store(kMachFloat64, base, zero, binop);
2797       m.Return(m.Int32Constant(i + j));
2798       CHECK_EQ(i + j, m.Call());
2799     }
2800   }
2801 }
2802
2803
2804 TEST(RunDeadFloat64Binops) {
2805   RawMachineAssemblerTester<int32_t> m;
2806
2807   const Operator* ops[] = {m.machine()->Float64Add(), m.machine()->Float64Sub(),
2808                            m.machine()->Float64Mul(), m.machine()->Float64Div(),
2809                            m.machine()->Float64Mod(), NULL};
2810
2811   for (int i = 0; ops[i] != NULL; i++) {
2812     RawMachineAssemblerTester<int32_t> m;
2813     int constant = 0x53355 + i;
2814     m.NewNode(ops[i], m.Float64Constant(0.1), m.Float64Constant(1.11));
2815     m.Return(m.Int32Constant(constant));
2816     CHECK_EQ(constant, m.Call());
2817   }
2818 }
2819
2820
2821 TEST(RunFloat64AddP) {
2822   RawMachineAssemblerTester<int32_t> m;
2823   Float64BinopTester bt(&m);
2824
2825   bt.AddReturn(m.Float64Add(bt.param0, bt.param1));
2826
2827   FOR_FLOAT64_INPUTS(pl) {
2828     FOR_FLOAT64_INPUTS(pr) {
2829       double expected = *pl + *pr;
2830       CHECK_EQ(expected, bt.call(*pl, *pr));
2831     }
2832   }
2833 }
2834
2835
2836 TEST(RunFloat64SubP) {
2837   RawMachineAssemblerTester<int32_t> m;
2838   Float64BinopTester bt(&m);
2839
2840   bt.AddReturn(m.Float64Sub(bt.param0, bt.param1));
2841
2842   FOR_FLOAT64_INPUTS(pl) {
2843     FOR_FLOAT64_INPUTS(pr) {
2844       double expected = *pl - *pr;
2845       CHECK_EQ(expected, bt.call(*pl, *pr));
2846     }
2847   }
2848 }
2849
2850
2851 TEST(RunFloat64SubImm1) {
2852   double input = 0.0;
2853   double output = 0.0;
2854
2855   FOR_FLOAT64_INPUTS(i) {
2856     RawMachineAssemblerTester<int32_t> m;
2857     Node* t0 = m.LoadFromPointer(&input, kMachFloat64);
2858     Node* t1 = m.Float64Sub(m.Float64Constant(*i), t0);
2859     m.StoreToPointer(&output, kMachFloat64, t1);
2860     m.Return(m.Int32Constant(0));
2861     FOR_FLOAT64_INPUTS(j) {
2862       input = *j;
2863       double expected = *i - input;
2864       CHECK_EQ(0, m.Call());
2865       CHECK_EQ(expected, output);
2866     }
2867   }
2868 }
2869
2870
2871 TEST(RunFloat64SubImm2) {
2872   double input = 0.0;
2873   double output = 0.0;
2874
2875   FOR_FLOAT64_INPUTS(i) {
2876     RawMachineAssemblerTester<int32_t> m;
2877     Node* t0 = m.LoadFromPointer(&input, kMachFloat64);
2878     Node* t1 = m.Float64Sub(t0, m.Float64Constant(*i));
2879     m.StoreToPointer(&output, kMachFloat64, t1);
2880     m.Return(m.Int32Constant(0));
2881     FOR_FLOAT64_INPUTS(j) {
2882       input = *j;
2883       double expected = input - *i;
2884       CHECK_EQ(0, m.Call());
2885       CHECK_EQ(expected, output);
2886     }
2887   }
2888 }
2889
2890
2891 TEST(RunFloat64MulP) {
2892   RawMachineAssemblerTester<int32_t> m;
2893   Float64BinopTester bt(&m);
2894
2895   bt.AddReturn(m.Float64Mul(bt.param0, bt.param1));
2896
2897   FOR_FLOAT64_INPUTS(pl) {
2898     FOR_FLOAT64_INPUTS(pr) {
2899       double expected = *pl * *pr;
2900       CHECK_EQ(expected, bt.call(*pl, *pr));
2901     }
2902   }
2903 }
2904
2905
2906 TEST(RunFloat64MulAndFloat64AddP) {
2907   double input_a = 0.0;
2908   double input_b = 0.0;
2909   double input_c = 0.0;
2910   double output = 0.0;
2911
2912   {
2913     RawMachineAssemblerTester<int32_t> m;
2914     Node* a = m.LoadFromPointer(&input_a, kMachFloat64);
2915     Node* b = m.LoadFromPointer(&input_b, kMachFloat64);
2916     Node* c = m.LoadFromPointer(&input_c, kMachFloat64);
2917     m.StoreToPointer(&output, kMachFloat64,
2918                      m.Float64Add(m.Float64Mul(a, b), c));
2919     m.Return(m.Int32Constant(0));
2920     FOR_FLOAT64_INPUTS(i) {
2921       FOR_FLOAT64_INPUTS(j) {
2922         FOR_FLOAT64_INPUTS(k) {
2923           input_a = *i;
2924           input_b = *j;
2925           input_c = *k;
2926           volatile double temp = input_a * input_b;
2927           volatile double expected = temp + input_c;
2928           CHECK_EQ(0, m.Call());
2929           CHECK_EQ(expected, output);
2930         }
2931       }
2932     }
2933   }
2934   {
2935     RawMachineAssemblerTester<int32_t> m;
2936     Node* a = m.LoadFromPointer(&input_a, kMachFloat64);
2937     Node* b = m.LoadFromPointer(&input_b, kMachFloat64);
2938     Node* c = m.LoadFromPointer(&input_c, kMachFloat64);
2939     m.StoreToPointer(&output, kMachFloat64,
2940                      m.Float64Add(a, m.Float64Mul(b, c)));
2941     m.Return(m.Int32Constant(0));
2942     FOR_FLOAT64_INPUTS(i) {
2943       FOR_FLOAT64_INPUTS(j) {
2944         FOR_FLOAT64_INPUTS(k) {
2945           input_a = *i;
2946           input_b = *j;
2947           input_c = *k;
2948           volatile double temp = input_b * input_c;
2949           volatile double expected = input_a + temp;
2950           CHECK_EQ(0, m.Call());
2951           CHECK_EQ(expected, output);
2952         }
2953       }
2954     }
2955   }
2956 }
2957
2958
2959 TEST(RunFloat64MulAndFloat64SubP) {
2960   double input_a = 0.0;
2961   double input_b = 0.0;
2962   double input_c = 0.0;
2963   double output = 0.0;
2964
2965   RawMachineAssemblerTester<int32_t> m;
2966   Node* a = m.LoadFromPointer(&input_a, kMachFloat64);
2967   Node* b = m.LoadFromPointer(&input_b, kMachFloat64);
2968   Node* c = m.LoadFromPointer(&input_c, kMachFloat64);
2969   m.StoreToPointer(&output, kMachFloat64, m.Float64Sub(a, m.Float64Mul(b, c)));
2970   m.Return(m.Int32Constant(0));
2971
2972   FOR_FLOAT64_INPUTS(i) {
2973     FOR_FLOAT64_INPUTS(j) {
2974       FOR_FLOAT64_INPUTS(k) {
2975         input_a = *i;
2976         input_b = *j;
2977         input_c = *k;
2978         volatile double temp = input_b * input_c;
2979         volatile double expected = input_a - temp;
2980         CHECK_EQ(0, m.Call());
2981         CHECK_EQ(expected, output);
2982       }
2983     }
2984   }
2985 }
2986
2987
2988 TEST(RunFloat64MulImm) {
2989   double input = 0.0;
2990   double output = 0.0;
2991
2992   {
2993     FOR_FLOAT64_INPUTS(i) {
2994       RawMachineAssemblerTester<int32_t> m;
2995       Node* t0 = m.LoadFromPointer(&input, kMachFloat64);
2996       Node* t1 = m.Float64Mul(m.Float64Constant(*i), t0);
2997       m.StoreToPointer(&output, kMachFloat64, t1);
2998       m.Return(m.Int32Constant(0));
2999       FOR_FLOAT64_INPUTS(j) {
3000         input = *j;
3001         double expected = *i * input;
3002         CHECK_EQ(0, m.Call());
3003         CHECK_EQ(expected, output);
3004       }
3005     }
3006   }
3007   {
3008     FOR_FLOAT64_INPUTS(i) {
3009       RawMachineAssemblerTester<int32_t> m;
3010       Node* t0 = m.LoadFromPointer(&input, kMachFloat64);
3011       Node* t1 = m.Float64Mul(t0, m.Float64Constant(*i));
3012       m.StoreToPointer(&output, kMachFloat64, t1);
3013       m.Return(m.Int32Constant(0));
3014       FOR_FLOAT64_INPUTS(j) {
3015         input = *j;
3016         double expected = input * *i;
3017         CHECK_EQ(0, m.Call());
3018         CHECK_EQ(expected, output);
3019       }
3020     }
3021   }
3022 }
3023
3024
3025 TEST(RunFloat64DivP) {
3026   RawMachineAssemblerTester<int32_t> m;
3027   Float64BinopTester bt(&m);
3028
3029   bt.AddReturn(m.Float64Div(bt.param0, bt.param1));
3030
3031   FOR_FLOAT64_INPUTS(pl) {
3032     FOR_FLOAT64_INPUTS(pr) {
3033       double expected = *pl / *pr;
3034       CHECK_EQ(expected, bt.call(*pl, *pr));
3035     }
3036   }
3037 }
3038
3039
3040 TEST(RunFloat64ModP) {
3041   RawMachineAssemblerTester<int32_t> m;
3042   Float64BinopTester bt(&m);
3043
3044   bt.AddReturn(m.Float64Mod(bt.param0, bt.param1));
3045
3046   FOR_FLOAT64_INPUTS(i) {
3047     FOR_FLOAT64_INPUTS(j) {
3048       double expected = modulo(*i, *j);
3049       double found = bt.call(*i, *j);
3050       CHECK_EQ(expected, found);
3051     }
3052   }
3053 }
3054
3055
3056 TEST(RunChangeInt32ToFloat64_A) {
3057   RawMachineAssemblerTester<int32_t> m;
3058   int32_t magic = 0x986234;
3059   double result = 0;
3060
3061   Node* convert = m.ChangeInt32ToFloat64(m.Int32Constant(magic));
3062   m.Store(kMachFloat64, m.PointerConstant(&result), m.Int32Constant(0),
3063           convert);
3064   m.Return(m.Int32Constant(magic));
3065
3066   CHECK_EQ(magic, m.Call());
3067   CHECK_EQ(static_cast<double>(magic), result);
3068 }
3069
3070
3071 TEST(RunChangeInt32ToFloat64_B) {
3072   RawMachineAssemblerTester<int32_t> m(kMachInt32);
3073   double output = 0;
3074
3075   Node* convert = m.ChangeInt32ToFloat64(m.Parameter(0));
3076   m.Store(kMachFloat64, m.PointerConstant(&output), m.Int32Constant(0),
3077           convert);
3078   m.Return(m.Parameter(0));
3079
3080   FOR_INT32_INPUTS(i) {
3081     int32_t expect = *i;
3082     CHECK_EQ(expect, m.Call(expect));
3083     CHECK_EQ(static_cast<double>(expect), output);
3084   }
3085 }
3086
3087
3088 TEST(RunChangeUint32ToFloat64_B) {
3089   RawMachineAssemblerTester<int32_t> m(kMachUint32);
3090   double output = 0;
3091
3092   Node* convert = m.ChangeUint32ToFloat64(m.Parameter(0));
3093   m.Store(kMachFloat64, m.PointerConstant(&output), m.Int32Constant(0),
3094           convert);
3095   m.Return(m.Parameter(0));
3096
3097   FOR_UINT32_INPUTS(i) {
3098     uint32_t expect = *i;
3099     CHECK_EQ(expect, m.Call(expect));
3100     CHECK_EQ(static_cast<double>(expect), output);
3101   }
3102 }
3103
3104
3105 TEST(RunChangeFloat64ToInt32_A) {
3106   RawMachineAssemblerTester<int32_t> m;
3107   int32_t magic = 0x786234;
3108   double input = 11.1;
3109   int32_t result = 0;
3110
3111   m.Store(kMachInt32, m.PointerConstant(&result), m.Int32Constant(0),
3112           m.ChangeFloat64ToInt32(m.Float64Constant(input)));
3113   m.Return(m.Int32Constant(magic));
3114
3115   CHECK_EQ(magic, m.Call());
3116   CHECK_EQ(static_cast<int32_t>(input), result);
3117 }
3118
3119
3120 TEST(RunChangeFloat64ToInt32_B) {
3121   RawMachineAssemblerTester<int32_t> m;
3122   double input = 0;
3123   int32_t output = 0;
3124
3125   Node* load =
3126       m.Load(kMachFloat64, m.PointerConstant(&input), m.Int32Constant(0));
3127   Node* convert = m.ChangeFloat64ToInt32(load);
3128   m.Store(kMachInt32, m.PointerConstant(&output), m.Int32Constant(0), convert);
3129   m.Return(convert);
3130
3131   {
3132     FOR_INT32_INPUTS(i) {
3133       input = *i;
3134       int32_t expect = *i;
3135       CHECK_EQ(expect, m.Call());
3136       CHECK_EQ(expect, output);
3137     }
3138   }
3139
3140   // Check various powers of 2.
3141   for (int32_t n = 1; n < 31; ++n) {
3142     {
3143       input = 1 << n;
3144       int32_t expect = static_cast<int32_t>(input);
3145       CHECK_EQ(expect, m.Call());
3146       CHECK_EQ(expect, output);
3147     }
3148
3149     {
3150       input = 3 << n;
3151       int32_t expect = static_cast<int32_t>(input);
3152       CHECK_EQ(expect, m.Call());
3153       CHECK_EQ(expect, output);
3154     }
3155   }
3156   // Note we don't check fractional inputs, because these Convert operators
3157   // really should be Change operators.
3158 }
3159
3160
3161 TEST(RunChangeFloat64ToUint32_B) {
3162   RawMachineAssemblerTester<int32_t> m;
3163   double input = 0;
3164   int32_t output = 0;
3165
3166   Node* load =
3167       m.Load(kMachFloat64, m.PointerConstant(&input), m.Int32Constant(0));
3168   Node* convert = m.ChangeFloat64ToUint32(load);
3169   m.Store(kMachInt32, m.PointerConstant(&output), m.Int32Constant(0), convert);
3170   m.Return(convert);
3171
3172   {
3173     FOR_UINT32_INPUTS(i) {
3174       input = *i;
3175       // TODO(titzer): add a CheckEqualsHelper overload for uint32_t.
3176       int32_t expect = static_cast<int32_t>(*i);
3177       CHECK_EQ(expect, m.Call());
3178       CHECK_EQ(expect, output);
3179     }
3180   }
3181
3182   // Check various powers of 2.
3183   for (int32_t n = 1; n < 31; ++n) {
3184     {
3185       input = 1u << n;
3186       int32_t expect = static_cast<int32_t>(static_cast<uint32_t>(input));
3187       CHECK_EQ(expect, m.Call());
3188       CHECK_EQ(expect, output);
3189     }
3190
3191     {
3192       input = 3u << n;
3193       int32_t expect = static_cast<int32_t>(static_cast<uint32_t>(input));
3194       CHECK_EQ(expect, m.Call());
3195       CHECK_EQ(expect, output);
3196     }
3197   }
3198   // Note we don't check fractional inputs, because these Convert operators
3199   // really should be Change operators.
3200 }
3201
3202
3203 TEST(RunChangeFloat64ToInt32_spilled) {
3204   RawMachineAssemblerTester<int32_t> m;
3205   const int kNumInputs = 32;
3206   int32_t magic = 0x786234;
3207   double input[kNumInputs];
3208   int32_t result[kNumInputs];
3209   Node* input_node[kNumInputs];
3210
3211   for (int i = 0; i < kNumInputs; i++) {
3212     input_node[i] =
3213         m.Load(kMachFloat64, m.PointerConstant(&input), m.Int32Constant(i * 8));
3214   }
3215
3216   for (int i = 0; i < kNumInputs; i++) {
3217     m.Store(kMachInt32, m.PointerConstant(&result), m.Int32Constant(i * 4),
3218             m.ChangeFloat64ToInt32(input_node[i]));
3219   }
3220
3221   m.Return(m.Int32Constant(magic));
3222
3223   for (int i = 0; i < kNumInputs; i++) {
3224     input[i] = 100.9 + i;
3225   }
3226
3227   CHECK_EQ(magic, m.Call());
3228
3229   for (int i = 0; i < kNumInputs; i++) {
3230     CHECK_EQ(result[i], 100 + i);
3231   }
3232 }
3233
3234
3235 TEST(RunChangeFloat64ToUint32_spilled) {
3236   RawMachineAssemblerTester<uint32_t> m;
3237   const int kNumInputs = 32;
3238   int32_t magic = 0x786234;
3239   double input[kNumInputs];
3240   uint32_t result[kNumInputs];
3241   Node* input_node[kNumInputs];
3242
3243   for (int i = 0; i < kNumInputs; i++) {
3244     input_node[i] =
3245         m.Load(kMachFloat64, m.PointerConstant(&input), m.Int32Constant(i * 8));
3246   }
3247
3248   for (int i = 0; i < kNumInputs; i++) {
3249     m.Store(kMachUint32, m.PointerConstant(&result), m.Int32Constant(i * 4),
3250             m.ChangeFloat64ToUint32(input_node[i]));
3251   }
3252
3253   m.Return(m.Int32Constant(magic));
3254
3255   for (int i = 0; i < kNumInputs; i++) {
3256     if (i % 2) {
3257       input[i] = 100 + i + 2147483648u;
3258     } else {
3259       input[i] = 100 + i;
3260     }
3261   }
3262
3263   CHECK_EQ(magic, m.Call());
3264
3265   for (int i = 0; i < kNumInputs; i++) {
3266     if (i % 2) {
3267       CHECK_UINT32_EQ(result[i], static_cast<uint32_t>(100 + i + 2147483648u));
3268     } else {
3269       CHECK_UINT32_EQ(result[i], static_cast<uint32_t>(100 + i));
3270     }
3271   }
3272 }
3273
3274
3275 TEST(RunDeadChangeFloat64ToInt32) {
3276   RawMachineAssemblerTester<int32_t> m;
3277   const int magic = 0x88abcda4;
3278   m.ChangeFloat64ToInt32(m.Float64Constant(999.78));
3279   m.Return(m.Int32Constant(magic));
3280   CHECK_EQ(magic, m.Call());
3281 }
3282
3283
3284 TEST(RunDeadChangeInt32ToFloat64) {
3285   RawMachineAssemblerTester<int32_t> m;
3286   const int magic = 0x8834abcd;
3287   m.ChangeInt32ToFloat64(m.Int32Constant(magic - 6888));
3288   m.Return(m.Int32Constant(magic));
3289   CHECK_EQ(magic, m.Call());
3290 }
3291
3292
3293 TEST(RunLoopPhiInduction2) {
3294   RawMachineAssemblerTester<int32_t> m;
3295
3296   int false_val = 0x10777;
3297
3298   // x = false_val; while(false) { x++; } return x;
3299   MLabel header, body, end;
3300   Node* false_node = m.Int32Constant(false_val);
3301   m.Goto(&header);
3302   m.Bind(&header);
3303   Node* phi = m.Phi(kMachInt32, false_node, false_node);
3304   m.Branch(m.Int32Constant(0), &body, &end);
3305   m.Bind(&body);
3306   Node* add = m.Int32Add(phi, m.Int32Constant(1));
3307   phi->ReplaceInput(1, add);
3308   m.Goto(&header);
3309   m.Bind(&end);
3310   m.Return(phi);
3311
3312   CHECK_EQ(false_val, m.Call());
3313 }
3314
3315
3316 TEST(RunDoubleDiamond) {
3317   RawMachineAssemblerTester<int32_t> m;
3318
3319   const int magic = 99645;
3320   double buffer = 0.1;
3321   double constant = 99.99;
3322
3323   MLabel blocka, blockb, end;
3324   Node* k1 = m.Float64Constant(constant);
3325   Node* k2 = m.Float64Constant(0 - constant);
3326   m.Branch(m.Int32Constant(0), &blocka, &blockb);
3327   m.Bind(&blocka);
3328   m.Goto(&end);
3329   m.Bind(&blockb);
3330   m.Goto(&end);
3331   m.Bind(&end);
3332   Node* phi = m.Phi(kMachFloat64, k2, k1);
3333   m.Store(kMachFloat64, m.PointerConstant(&buffer), m.Int32Constant(0), phi);
3334   m.Return(m.Int32Constant(magic));
3335
3336   CHECK_EQ(magic, m.Call());
3337   CHECK_EQ(constant, buffer);
3338 }
3339
3340
3341 TEST(RunRefDiamond) {
3342   RawMachineAssemblerTester<int32_t> m;
3343
3344   const int magic = 99644;
3345   Handle<String> rexpected =
3346       CcTest::i_isolate()->factory()->InternalizeUtf8String("A");
3347   String* buffer;
3348
3349   MLabel blocka, blockb, end;
3350   Node* k1 = m.StringConstant("A");
3351   Node* k2 = m.StringConstant("B");
3352   m.Branch(m.Int32Constant(0), &blocka, &blockb);
3353   m.Bind(&blocka);
3354   m.Goto(&end);
3355   m.Bind(&blockb);
3356   m.Goto(&end);
3357   m.Bind(&end);
3358   Node* phi = m.Phi(kMachAnyTagged, k2, k1);
3359   m.Store(kMachAnyTagged, m.PointerConstant(&buffer), m.Int32Constant(0), phi);
3360   m.Return(m.Int32Constant(magic));
3361
3362   CHECK_EQ(magic, m.Call());
3363   CHECK(rexpected->SameValue(buffer));
3364 }
3365
3366
3367 TEST(RunDoubleRefDiamond) {
3368   RawMachineAssemblerTester<int32_t> m;
3369
3370   const int magic = 99648;
3371   double dbuffer = 0.1;
3372   double dconstant = 99.99;
3373   Handle<String> rexpected =
3374       CcTest::i_isolate()->factory()->InternalizeUtf8String("AX");
3375   String* rbuffer;
3376
3377   MLabel blocka, blockb, end;
3378   Node* d1 = m.Float64Constant(dconstant);
3379   Node* d2 = m.Float64Constant(0 - dconstant);
3380   Node* r1 = m.StringConstant("AX");
3381   Node* r2 = m.StringConstant("BX");
3382   m.Branch(m.Int32Constant(0), &blocka, &blockb);
3383   m.Bind(&blocka);
3384   m.Goto(&end);
3385   m.Bind(&blockb);
3386   m.Goto(&end);
3387   m.Bind(&end);
3388   Node* dphi = m.Phi(kMachFloat64, d2, d1);
3389   Node* rphi = m.Phi(kMachAnyTagged, r2, r1);
3390   m.Store(kMachFloat64, m.PointerConstant(&dbuffer), m.Int32Constant(0), dphi);
3391   m.Store(kMachAnyTagged, m.PointerConstant(&rbuffer), m.Int32Constant(0),
3392           rphi);
3393   m.Return(m.Int32Constant(magic));
3394
3395   CHECK_EQ(magic, m.Call());
3396   CHECK_EQ(dconstant, dbuffer);
3397   CHECK(rexpected->SameValue(rbuffer));
3398 }
3399
3400
3401 TEST(RunDoubleRefDoubleDiamond) {
3402   RawMachineAssemblerTester<int32_t> m;
3403
3404   const int magic = 99649;
3405   double dbuffer = 0.1;
3406   double dconstant = 99.997;
3407   Handle<String> rexpected =
3408       CcTest::i_isolate()->factory()->InternalizeUtf8String("AD");
3409   String* rbuffer;
3410
3411   MLabel blocka, blockb, mid, blockd, blocke, end;
3412   Node* d1 = m.Float64Constant(dconstant);
3413   Node* d2 = m.Float64Constant(0 - dconstant);
3414   Node* r1 = m.StringConstant("AD");
3415   Node* r2 = m.StringConstant("BD");
3416   m.Branch(m.Int32Constant(0), &blocka, &blockb);
3417   m.Bind(&blocka);
3418   m.Goto(&mid);
3419   m.Bind(&blockb);
3420   m.Goto(&mid);
3421   m.Bind(&mid);
3422   Node* dphi1 = m.Phi(kMachFloat64, d2, d1);
3423   Node* rphi1 = m.Phi(kMachAnyTagged, r2, r1);
3424   m.Branch(m.Int32Constant(0), &blockd, &blocke);
3425
3426   m.Bind(&blockd);
3427   m.Goto(&end);
3428   m.Bind(&blocke);
3429   m.Goto(&end);
3430   m.Bind(&end);
3431   Node* dphi2 = m.Phi(kMachFloat64, d1, dphi1);
3432   Node* rphi2 = m.Phi(kMachAnyTagged, r1, rphi1);
3433
3434   m.Store(kMachFloat64, m.PointerConstant(&dbuffer), m.Int32Constant(0), dphi2);
3435   m.Store(kMachAnyTagged, m.PointerConstant(&rbuffer), m.Int32Constant(0),
3436           rphi2);
3437   m.Return(m.Int32Constant(magic));
3438
3439   CHECK_EQ(magic, m.Call());
3440   CHECK_EQ(dconstant, dbuffer);
3441   CHECK(rexpected->SameValue(rbuffer));
3442 }
3443
3444
3445 TEST(RunDoubleLoopPhi) {
3446   RawMachineAssemblerTester<int32_t> m;
3447   MLabel header, body, end;
3448
3449   int magic = 99773;
3450   double buffer = 0.99;
3451   double dconstant = 777.1;
3452
3453   Node* zero = m.Int32Constant(0);
3454   Node* dk = m.Float64Constant(dconstant);
3455
3456   m.Goto(&header);
3457   m.Bind(&header);
3458   Node* phi = m.Phi(kMachFloat64, dk, dk);
3459   phi->ReplaceInput(1, phi);
3460   m.Branch(zero, &body, &end);
3461   m.Bind(&body);
3462   m.Goto(&header);
3463   m.Bind(&end);
3464   m.Store(kMachFloat64, m.PointerConstant(&buffer), m.Int32Constant(0), phi);
3465   m.Return(m.Int32Constant(magic));
3466
3467   CHECK_EQ(magic, m.Call());
3468 }
3469
3470
3471 TEST(RunCountToTenAccRaw) {
3472   RawMachineAssemblerTester<int32_t> m;
3473
3474   Node* zero = m.Int32Constant(0);
3475   Node* ten = m.Int32Constant(10);
3476   Node* one = m.Int32Constant(1);
3477
3478   MLabel header, body, body_cont, end;
3479
3480   m.Goto(&header);
3481
3482   m.Bind(&header);
3483   Node* i = m.Phi(kMachInt32, zero, zero);
3484   Node* j = m.Phi(kMachInt32, zero, zero);
3485   m.Goto(&body);
3486
3487   m.Bind(&body);
3488   Node* next_i = m.Int32Add(i, one);
3489   Node* next_j = m.Int32Add(j, one);
3490   m.Branch(m.Word32Equal(next_i, ten), &end, &body_cont);
3491
3492   m.Bind(&body_cont);
3493   i->ReplaceInput(1, next_i);
3494   j->ReplaceInput(1, next_j);
3495   m.Goto(&header);
3496
3497   m.Bind(&end);
3498   m.Return(ten);
3499
3500   CHECK_EQ(10, m.Call());
3501 }
3502
3503
3504 TEST(RunCountToTenAccRaw2) {
3505   RawMachineAssemblerTester<int32_t> m;
3506
3507   Node* zero = m.Int32Constant(0);
3508   Node* ten = m.Int32Constant(10);
3509   Node* one = m.Int32Constant(1);
3510
3511   MLabel header, body, body_cont, end;
3512
3513   m.Goto(&header);
3514
3515   m.Bind(&header);
3516   Node* i = m.Phi(kMachInt32, zero, zero);
3517   Node* j = m.Phi(kMachInt32, zero, zero);
3518   Node* k = m.Phi(kMachInt32, zero, zero);
3519   m.Goto(&body);
3520
3521   m.Bind(&body);
3522   Node* next_i = m.Int32Add(i, one);
3523   Node* next_j = m.Int32Add(j, one);
3524   Node* next_k = m.Int32Add(j, one);
3525   m.Branch(m.Word32Equal(next_i, ten), &end, &body_cont);
3526
3527   m.Bind(&body_cont);
3528   i->ReplaceInput(1, next_i);
3529   j->ReplaceInput(1, next_j);
3530   k->ReplaceInput(1, next_k);
3531   m.Goto(&header);
3532
3533   m.Bind(&end);
3534   m.Return(ten);
3535
3536   CHECK_EQ(10, m.Call());
3537 }
3538
3539
3540 TEST(RunAddTree) {
3541   RawMachineAssemblerTester<int32_t> m;
3542   int32_t inputs[] = {11, 12, 13, 14, 15, 16, 17, 18};
3543
3544   Node* base = m.PointerConstant(inputs);
3545   Node* n0 = m.Load(kMachInt32, base, m.Int32Constant(0 * sizeof(int32_t)));
3546   Node* n1 = m.Load(kMachInt32, base, m.Int32Constant(1 * sizeof(int32_t)));
3547   Node* n2 = m.Load(kMachInt32, base, m.Int32Constant(2 * sizeof(int32_t)));
3548   Node* n3 = m.Load(kMachInt32, base, m.Int32Constant(3 * sizeof(int32_t)));
3549   Node* n4 = m.Load(kMachInt32, base, m.Int32Constant(4 * sizeof(int32_t)));
3550   Node* n5 = m.Load(kMachInt32, base, m.Int32Constant(5 * sizeof(int32_t)));
3551   Node* n6 = m.Load(kMachInt32, base, m.Int32Constant(6 * sizeof(int32_t)));
3552   Node* n7 = m.Load(kMachInt32, base, m.Int32Constant(7 * sizeof(int32_t)));
3553
3554   Node* i1 = m.Int32Add(n0, n1);
3555   Node* i2 = m.Int32Add(n2, n3);
3556   Node* i3 = m.Int32Add(n4, n5);
3557   Node* i4 = m.Int32Add(n6, n7);
3558
3559   Node* i5 = m.Int32Add(i1, i2);
3560   Node* i6 = m.Int32Add(i3, i4);
3561
3562   Node* i7 = m.Int32Add(i5, i6);
3563
3564   m.Return(i7);
3565
3566   CHECK_EQ(116, m.Call());
3567 }
3568
3569
3570 static const int kFloat64CompareHelperTestCases = 15;
3571 static const int kFloat64CompareHelperNodeType = 4;
3572
3573 static int Float64CompareHelper(RawMachineAssemblerTester<int32_t>* m,
3574                                 int test_case, int node_type, double x,
3575                                 double y) {
3576   static double buffer[2];
3577   buffer[0] = x;
3578   buffer[1] = y;
3579   CHECK(0 <= test_case && test_case < kFloat64CompareHelperTestCases);
3580   CHECK(0 <= node_type && node_type < kFloat64CompareHelperNodeType);
3581   CHECK(x < y);
3582   bool load_a = node_type / 2 == 1;
3583   bool load_b = node_type % 2 == 1;
3584   Node* a = load_a ? m->Load(kMachFloat64, m->PointerConstant(&buffer[0]))
3585                    : m->Float64Constant(x);
3586   Node* b = load_b ? m->Load(kMachFloat64, m->PointerConstant(&buffer[1]))
3587                    : m->Float64Constant(y);
3588   Node* cmp = NULL;
3589   bool expected = false;
3590   switch (test_case) {
3591     // Equal tests.
3592     case 0:
3593       cmp = m->Float64Equal(a, b);
3594       expected = false;
3595       break;
3596     case 1:
3597       cmp = m->Float64Equal(a, a);
3598       expected = true;
3599       break;
3600     // LessThan tests.
3601     case 2:
3602       cmp = m->Float64LessThan(a, b);
3603       expected = true;
3604       break;
3605     case 3:
3606       cmp = m->Float64LessThan(b, a);
3607       expected = false;
3608       break;
3609     case 4:
3610       cmp = m->Float64LessThan(a, a);
3611       expected = false;
3612       break;
3613     // LessThanOrEqual tests.
3614     case 5:
3615       cmp = m->Float64LessThanOrEqual(a, b);
3616       expected = true;
3617       break;
3618     case 6:
3619       cmp = m->Float64LessThanOrEqual(b, a);
3620       expected = false;
3621       break;
3622     case 7:
3623       cmp = m->Float64LessThanOrEqual(a, a);
3624       expected = true;
3625       break;
3626     // NotEqual tests.
3627     case 8:
3628       cmp = m->Float64NotEqual(a, b);
3629       expected = true;
3630       break;
3631     case 9:
3632       cmp = m->Float64NotEqual(b, a);
3633       expected = true;
3634       break;
3635     case 10:
3636       cmp = m->Float64NotEqual(a, a);
3637       expected = false;
3638       break;
3639     // GreaterThan tests.
3640     case 11:
3641       cmp = m->Float64GreaterThan(a, a);
3642       expected = false;
3643       break;
3644     case 12:
3645       cmp = m->Float64GreaterThan(a, b);
3646       expected = false;
3647       break;
3648     // GreaterThanOrEqual tests.
3649     case 13:
3650       cmp = m->Float64GreaterThanOrEqual(a, a);
3651       expected = true;
3652       break;
3653     case 14:
3654       cmp = m->Float64GreaterThanOrEqual(b, a);
3655       expected = true;
3656       break;
3657     default:
3658       UNREACHABLE();
3659   }
3660   m->Return(cmp);
3661   return expected;
3662 }
3663
3664
3665 TEST(RunFloat64Compare) {
3666   double inf = V8_INFINITY;
3667   // All pairs (a1, a2) are of the form a1 < a2.
3668   double inputs[] = {0.0,  1.0,  -1.0, 0.22, -1.22, 0.22,
3669                      -inf, 0.22, 0.22, inf,  -inf,  inf};
3670
3671   for (int test = 0; test < kFloat64CompareHelperTestCases; test++) {
3672     for (int node_type = 0; node_type < kFloat64CompareHelperNodeType;
3673          node_type++) {
3674       for (size_t input = 0; input < arraysize(inputs); input += 2) {
3675         RawMachineAssemblerTester<int32_t> m;
3676         int expected = Float64CompareHelper(&m, test, node_type, inputs[input],
3677                                             inputs[input + 1]);
3678         CHECK_EQ(expected, m.Call());
3679       }
3680     }
3681   }
3682 }
3683
3684
3685 TEST(RunFloat64UnorderedCompare) {
3686   RawMachineAssemblerTester<int32_t> m;
3687
3688   const Operator* operators[] = {m.machine()->Float64Equal(),
3689                                  m.machine()->Float64LessThan(),
3690                                  m.machine()->Float64LessThanOrEqual()};
3691
3692   double nan = v8::base::OS::nan_value();
3693
3694   FOR_FLOAT64_INPUTS(i) {
3695     for (size_t o = 0; o < arraysize(operators); ++o) {
3696       for (int j = 0; j < 2; j++) {
3697         RawMachineAssemblerTester<int32_t> m;
3698         Node* a = m.Float64Constant(*i);
3699         Node* b = m.Float64Constant(nan);
3700         if (j == 1) std::swap(a, b);
3701         m.Return(m.NewNode(operators[o], a, b));
3702         CHECK_EQ(0, m.Call());
3703       }
3704     }
3705   }
3706 }
3707
3708
3709 TEST(RunFloat64Equal) {
3710   double input_a = 0.0;
3711   double input_b = 0.0;
3712
3713   RawMachineAssemblerTester<int32_t> m;
3714   Node* a = m.LoadFromPointer(&input_a, kMachFloat64);
3715   Node* b = m.LoadFromPointer(&input_b, kMachFloat64);
3716   m.Return(m.Float64Equal(a, b));
3717
3718   CompareWrapper cmp(IrOpcode::kFloat64Equal);
3719   FOR_FLOAT64_INPUTS(pl) {
3720     FOR_FLOAT64_INPUTS(pr) {
3721       input_a = *pl;
3722       input_b = *pr;
3723       int32_t expected = cmp.Float64Compare(input_a, input_b) ? 1 : 0;
3724       CHECK_EQ(expected, m.Call());
3725     }
3726   }
3727 }
3728
3729
3730 TEST(RunFloat64LessThan) {
3731   double input_a = 0.0;
3732   double input_b = 0.0;
3733
3734   RawMachineAssemblerTester<int32_t> m;
3735   Node* a = m.LoadFromPointer(&input_a, kMachFloat64);
3736   Node* b = m.LoadFromPointer(&input_b, kMachFloat64);
3737   m.Return(m.Float64LessThan(a, b));
3738
3739   CompareWrapper cmp(IrOpcode::kFloat64LessThan);
3740   FOR_FLOAT64_INPUTS(pl) {
3741     FOR_FLOAT64_INPUTS(pr) {
3742       input_a = *pl;
3743       input_b = *pr;
3744       int32_t expected = cmp.Float64Compare(input_a, input_b) ? 1 : 0;
3745       CHECK_EQ(expected, m.Call());
3746     }
3747   }
3748 }
3749
3750
3751 template <typename IntType, MachineType kRepresentation>
3752 static void LoadStoreTruncation() {
3753   IntType input;
3754
3755   RawMachineAssemblerTester<int32_t> m;
3756   Node* a = m.LoadFromPointer(&input, kRepresentation);
3757   Node* ap1 = m.Int32Add(a, m.Int32Constant(1));
3758   m.StoreToPointer(&input, kRepresentation, ap1);
3759   m.Return(ap1);
3760
3761   const IntType max = std::numeric_limits<IntType>::max();
3762   const IntType min = std::numeric_limits<IntType>::min();
3763
3764   // Test upper bound.
3765   input = max;
3766   CHECK_EQ(max + 1, m.Call());
3767   CHECK_EQ(min, input);
3768
3769   // Test lower bound.
3770   input = min;
3771   CHECK_EQ(static_cast<IntType>(max + 2), m.Call());
3772   CHECK_EQ(min + 1, input);
3773
3774   // Test all one byte values that are not one byte bounds.
3775   for (int i = -127; i < 127; i++) {
3776     input = i;
3777     int expected = i >= 0 ? i + 1 : max + (i - min) + 2;
3778     CHECK_EQ(static_cast<IntType>(expected), m.Call());
3779     CHECK_EQ(static_cast<IntType>(i + 1), input);
3780   }
3781 }
3782
3783
3784 TEST(RunLoadStoreTruncation) {
3785   LoadStoreTruncation<int8_t, kMachInt8>();
3786   LoadStoreTruncation<int16_t, kMachInt16>();
3787 }
3788
3789
3790 static void IntPtrCompare(intptr_t left, intptr_t right) {
3791   for (int test = 0; test < 7; test++) {
3792     RawMachineAssemblerTester<bool> m(kMachPtr, kMachPtr);
3793     Node* p0 = m.Parameter(0);
3794     Node* p1 = m.Parameter(1);
3795     Node* res = NULL;
3796     bool expected = false;
3797     switch (test) {
3798       case 0:
3799         res = m.IntPtrLessThan(p0, p1);
3800         expected = true;
3801         break;
3802       case 1:
3803         res = m.IntPtrLessThanOrEqual(p0, p1);
3804         expected = true;
3805         break;
3806       case 2:
3807         res = m.IntPtrEqual(p0, p1);
3808         expected = false;
3809         break;
3810       case 3:
3811         res = m.IntPtrGreaterThanOrEqual(p0, p1);
3812         expected = false;
3813         break;
3814       case 4:
3815         res = m.IntPtrGreaterThan(p0, p1);
3816         expected = false;
3817         break;
3818       case 5:
3819         res = m.IntPtrEqual(p0, p0);
3820         expected = true;
3821         break;
3822       case 6:
3823         res = m.IntPtrNotEqual(p0, p1);
3824         expected = true;
3825         break;
3826       default:
3827         UNREACHABLE();
3828         break;
3829     }
3830     m.Return(res);
3831     CHECK_EQ(expected, m.Call(reinterpret_cast<int32_t*>(left),
3832                               reinterpret_cast<int32_t*>(right)));
3833   }
3834 }
3835
3836
3837 TEST(RunIntPtrCompare) {
3838   intptr_t min = std::numeric_limits<intptr_t>::min();
3839   intptr_t max = std::numeric_limits<intptr_t>::max();
3840   // An ascending chain of intptr_t
3841   intptr_t inputs[] = {min, min / 2, -1, 0, 1, max / 2, max};
3842   for (size_t i = 0; i < arraysize(inputs) - 1; i++) {
3843     IntPtrCompare(inputs[i], inputs[i + 1]);
3844   }
3845 }
3846
3847
3848 TEST(RunTestIntPtrArithmetic) {
3849   static const int kInputSize = 10;
3850   int32_t inputs[kInputSize];
3851   int32_t outputs[kInputSize];
3852   for (int i = 0; i < kInputSize; i++) {
3853     inputs[i] = i;
3854     outputs[i] = -1;
3855   }
3856   RawMachineAssemblerTester<int32_t*> m;
3857   Node* input = m.PointerConstant(&inputs[0]);
3858   Node* output = m.PointerConstant(&outputs[kInputSize - 1]);
3859   Node* elem_size = m.ConvertInt32ToIntPtr(m.Int32Constant(sizeof(inputs[0])));
3860   for (int i = 0; i < kInputSize; i++) {
3861     m.Store(kMachInt32, output, m.Load(kMachInt32, input));
3862     input = m.IntPtrAdd(input, elem_size);
3863     output = m.IntPtrSub(output, elem_size);
3864   }
3865   m.Return(input);
3866   CHECK_EQ(&inputs[kInputSize], m.Call());
3867   for (int i = 0; i < kInputSize; i++) {
3868     CHECK_EQ(i, inputs[i]);
3869     CHECK_EQ(kInputSize - i - 1, outputs[i]);
3870   }
3871 }
3872
3873
3874 TEST(RunSpillLotsOfThings) {
3875   static const int kInputSize = 1000;
3876   RawMachineAssemblerTester<void> m;
3877   Node* accs[kInputSize];
3878   int32_t outputs[kInputSize];
3879   Node* one = m.Int32Constant(1);
3880   Node* acc = one;
3881   for (int i = 0; i < kInputSize; i++) {
3882     acc = m.Int32Add(acc, one);
3883     accs[i] = acc;
3884   }
3885   for (int i = 0; i < kInputSize; i++) {
3886     m.StoreToPointer(&outputs[i], kMachInt32, accs[i]);
3887   }
3888   m.Return(one);
3889   m.Call();
3890   for (int i = 0; i < kInputSize; i++) {
3891     CHECK_EQ(outputs[i], i + 2);
3892   }
3893 }
3894
3895
3896 TEST(RunSpillConstantsAndParameters) {
3897   static const int kInputSize = 1000;
3898   static const int32_t kBase = 987;
3899   RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
3900   int32_t outputs[kInputSize];
3901   Node* csts[kInputSize];
3902   Node* accs[kInputSize];
3903   Node* acc = m.Int32Constant(0);
3904   for (int i = 0; i < kInputSize; i++) {
3905     csts[i] = m.Int32Constant(static_cast<int32_t>(kBase + i));
3906   }
3907   for (int i = 0; i < kInputSize; i++) {
3908     acc = m.Int32Add(acc, csts[i]);
3909     accs[i] = acc;
3910   }
3911   for (int i = 0; i < kInputSize; i++) {
3912     m.StoreToPointer(&outputs[i], kMachInt32, accs[i]);
3913   }
3914   m.Return(m.Int32Add(acc, m.Int32Add(m.Parameter(0), m.Parameter(1))));
3915   FOR_INT32_INPUTS(i) {
3916     FOR_INT32_INPUTS(j) {
3917       int32_t expected = *i + *j;
3918       for (int k = 0; k < kInputSize; k++) {
3919         expected += kBase + k;
3920       }
3921       CHECK_EQ(expected, m.Call(*i, *j));
3922       expected = 0;
3923       for (int k = 0; k < kInputSize; k++) {
3924         expected += kBase + k;
3925         CHECK_EQ(expected, outputs[k]);
3926       }
3927     }
3928   }
3929 }
3930
3931
3932 TEST(RunNewSpaceConstantsInPhi) {
3933   RawMachineAssemblerTester<Object*> m(kMachInt32);
3934
3935   Isolate* isolate = CcTest::i_isolate();
3936   Handle<HeapNumber> true_val = isolate->factory()->NewHeapNumber(11.2);
3937   Handle<HeapNumber> false_val = isolate->factory()->NewHeapNumber(11.3);
3938   Node* true_node = m.HeapConstant(true_val);
3939   Node* false_node = m.HeapConstant(false_val);
3940
3941   MLabel blocka, blockb, end;
3942   m.Branch(m.Parameter(0), &blocka, &blockb);
3943   m.Bind(&blocka);
3944   m.Goto(&end);
3945   m.Bind(&blockb);
3946   m.Goto(&end);
3947
3948   m.Bind(&end);
3949   Node* phi = m.Phi(kMachAnyTagged, true_node, false_node);
3950   m.Return(phi);
3951
3952   CHECK_EQ(*false_val, m.Call(0));
3953   CHECK_EQ(*true_val, m.Call(1));
3954 }
3955
3956
3957 TEST(RunInt32AddWithOverflowP) {
3958   int32_t actual_val = -1;
3959   RawMachineAssemblerTester<int32_t> m;
3960   Int32BinopTester bt(&m);
3961   Node* add = m.Int32AddWithOverflow(bt.param0, bt.param1);
3962   Node* val = m.Projection(0, add);
3963   Node* ovf = m.Projection(1, add);
3964   m.StoreToPointer(&actual_val, kMachInt32, val);
3965   bt.AddReturn(ovf);
3966   FOR_INT32_INPUTS(i) {
3967     FOR_INT32_INPUTS(j) {
3968       int32_t expected_val;
3969       int expected_ovf = bits::SignedAddOverflow32(*i, *j, &expected_val);
3970       CHECK_EQ(expected_ovf, bt.call(*i, *j));
3971       CHECK_EQ(expected_val, actual_val);
3972     }
3973   }
3974 }
3975
3976
3977 TEST(RunInt32AddWithOverflowImm) {
3978   int32_t actual_val = -1, expected_val = 0;
3979   FOR_INT32_INPUTS(i) {
3980     {
3981       RawMachineAssemblerTester<int32_t> m(kMachInt32);
3982       Node* add = m.Int32AddWithOverflow(m.Int32Constant(*i), m.Parameter(0));
3983       Node* val = m.Projection(0, add);
3984       Node* ovf = m.Projection(1, add);
3985       m.StoreToPointer(&actual_val, kMachInt32, val);
3986       m.Return(ovf);
3987       FOR_INT32_INPUTS(j) {
3988         int expected_ovf = bits::SignedAddOverflow32(*i, *j, &expected_val);
3989         CHECK_EQ(expected_ovf, m.Call(*j));
3990         CHECK_EQ(expected_val, actual_val);
3991       }
3992     }
3993     {
3994       RawMachineAssemblerTester<int32_t> m(kMachInt32);
3995       Node* add = m.Int32AddWithOverflow(m.Parameter(0), m.Int32Constant(*i));
3996       Node* val = m.Projection(0, add);
3997       Node* ovf = m.Projection(1, add);
3998       m.StoreToPointer(&actual_val, kMachInt32, val);
3999       m.Return(ovf);
4000       FOR_INT32_INPUTS(j) {
4001         int expected_ovf = bits::SignedAddOverflow32(*i, *j, &expected_val);
4002         CHECK_EQ(expected_ovf, m.Call(*j));
4003         CHECK_EQ(expected_val, actual_val);
4004       }
4005     }
4006     FOR_INT32_INPUTS(j) {
4007       RawMachineAssemblerTester<int32_t> m;
4008       Node* add =
4009           m.Int32AddWithOverflow(m.Int32Constant(*i), m.Int32Constant(*j));
4010       Node* val = m.Projection(0, add);
4011       Node* ovf = m.Projection(1, add);
4012       m.StoreToPointer(&actual_val, kMachInt32, val);
4013       m.Return(ovf);
4014       int expected_ovf = bits::SignedAddOverflow32(*i, *j, &expected_val);
4015       CHECK_EQ(expected_ovf, m.Call());
4016       CHECK_EQ(expected_val, actual_val);
4017     }
4018   }
4019 }
4020
4021
4022 TEST(RunInt32AddWithOverflowInBranchP) {
4023   int constant = 911777;
4024   MLabel blocka, blockb;
4025   RawMachineAssemblerTester<int32_t> m;
4026   Int32BinopTester bt(&m);
4027   Node* add = m.Int32AddWithOverflow(bt.param0, bt.param1);
4028   Node* ovf = m.Projection(1, add);
4029   m.Branch(ovf, &blocka, &blockb);
4030   m.Bind(&blocka);
4031   bt.AddReturn(m.Int32Constant(constant));
4032   m.Bind(&blockb);
4033   Node* val = m.Projection(0, add);
4034   bt.AddReturn(val);
4035   FOR_INT32_INPUTS(i) {
4036     FOR_INT32_INPUTS(j) {
4037       int32_t expected;
4038       if (bits::SignedAddOverflow32(*i, *j, &expected)) expected = constant;
4039       CHECK_EQ(expected, bt.call(*i, *j));
4040     }
4041   }
4042 }
4043
4044
4045 TEST(RunInt32SubWithOverflowP) {
4046   int32_t actual_val = -1;
4047   RawMachineAssemblerTester<int32_t> m;
4048   Int32BinopTester bt(&m);
4049   Node* add = m.Int32SubWithOverflow(bt.param0, bt.param1);
4050   Node* val = m.Projection(0, add);
4051   Node* ovf = m.Projection(1, add);
4052   m.StoreToPointer(&actual_val, kMachInt32, val);
4053   bt.AddReturn(ovf);
4054   FOR_INT32_INPUTS(i) {
4055     FOR_INT32_INPUTS(j) {
4056       int32_t expected_val;
4057       int expected_ovf = bits::SignedSubOverflow32(*i, *j, &expected_val);
4058       CHECK_EQ(expected_ovf, bt.call(*i, *j));
4059       CHECK_EQ(expected_val, actual_val);
4060     }
4061   }
4062 }
4063
4064
4065 TEST(RunInt32SubWithOverflowImm) {
4066   int32_t actual_val = -1, expected_val = 0;
4067   FOR_INT32_INPUTS(i) {
4068     {
4069       RawMachineAssemblerTester<int32_t> m(kMachInt32);
4070       Node* add = m.Int32SubWithOverflow(m.Int32Constant(*i), m.Parameter(0));
4071       Node* val = m.Projection(0, add);
4072       Node* ovf = m.Projection(1, add);
4073       m.StoreToPointer(&actual_val, kMachInt32, val);
4074       m.Return(ovf);
4075       FOR_INT32_INPUTS(j) {
4076         int expected_ovf = bits::SignedSubOverflow32(*i, *j, &expected_val);
4077         CHECK_EQ(expected_ovf, m.Call(*j));
4078         CHECK_EQ(expected_val, actual_val);
4079       }
4080     }
4081     {
4082       RawMachineAssemblerTester<int32_t> m(kMachInt32);
4083       Node* add = m.Int32SubWithOverflow(m.Parameter(0), m.Int32Constant(*i));
4084       Node* val = m.Projection(0, add);
4085       Node* ovf = m.Projection(1, add);
4086       m.StoreToPointer(&actual_val, kMachInt32, val);
4087       m.Return(ovf);
4088       FOR_INT32_INPUTS(j) {
4089         int expected_ovf = bits::SignedSubOverflow32(*j, *i, &expected_val);
4090         CHECK_EQ(expected_ovf, m.Call(*j));
4091         CHECK_EQ(expected_val, actual_val);
4092       }
4093     }
4094     FOR_INT32_INPUTS(j) {
4095       RawMachineAssemblerTester<int32_t> m;
4096       Node* add =
4097           m.Int32SubWithOverflow(m.Int32Constant(*i), m.Int32Constant(*j));
4098       Node* val = m.Projection(0, add);
4099       Node* ovf = m.Projection(1, add);
4100       m.StoreToPointer(&actual_val, kMachInt32, val);
4101       m.Return(ovf);
4102       int expected_ovf = bits::SignedSubOverflow32(*i, *j, &expected_val);
4103       CHECK_EQ(expected_ovf, m.Call());
4104       CHECK_EQ(expected_val, actual_val);
4105     }
4106   }
4107 }
4108
4109
4110 TEST(RunInt32SubWithOverflowInBranchP) {
4111   int constant = 911999;
4112   MLabel blocka, blockb;
4113   RawMachineAssemblerTester<int32_t> m;
4114   Int32BinopTester bt(&m);
4115   Node* sub = m.Int32SubWithOverflow(bt.param0, bt.param1);
4116   Node* ovf = m.Projection(1, sub);
4117   m.Branch(ovf, &blocka, &blockb);
4118   m.Bind(&blocka);
4119   bt.AddReturn(m.Int32Constant(constant));
4120   m.Bind(&blockb);
4121   Node* val = m.Projection(0, sub);
4122   bt.AddReturn(val);
4123   FOR_INT32_INPUTS(i) {
4124     FOR_INT32_INPUTS(j) {
4125       int32_t expected;
4126       if (bits::SignedSubOverflow32(*i, *j, &expected)) expected = constant;
4127       CHECK_EQ(expected, bt.call(*i, *j));
4128     }
4129   }
4130 }
4131
4132
4133 TEST(RunChangeInt32ToInt64P) {
4134   if (kPointerSize < 8) return;
4135   int64_t actual = -1;
4136   RawMachineAssemblerTester<int32_t> m(kMachInt32);
4137   m.StoreToPointer(&actual, kMachInt64, m.ChangeInt32ToInt64(m.Parameter(0)));
4138   m.Return(m.Int32Constant(0));
4139   FOR_INT32_INPUTS(i) {
4140     int64_t expected = *i;
4141     CHECK_EQ(0, m.Call(*i));
4142     CHECK_EQ(expected, actual);
4143   }
4144 }
4145
4146
4147 TEST(RunChangeUint32ToUint64P) {
4148   if (kPointerSize < 8) return;
4149   int64_t actual = -1;
4150   RawMachineAssemblerTester<int32_t> m(kMachUint32);
4151   m.StoreToPointer(&actual, kMachUint64,
4152                    m.ChangeUint32ToUint64(m.Parameter(0)));
4153   m.Return(m.Int32Constant(0));
4154   FOR_UINT32_INPUTS(i) {
4155     int64_t expected = static_cast<uint64_t>(*i);
4156     CHECK_EQ(0, m.Call(*i));
4157     CHECK_EQ(expected, actual);
4158   }
4159 }
4160
4161
4162 TEST(RunTruncateInt64ToInt32P) {
4163   if (kPointerSize < 8) return;
4164   int64_t expected = -1;
4165   RawMachineAssemblerTester<int32_t> m;
4166   m.Return(m.TruncateInt64ToInt32(m.LoadFromPointer(&expected, kMachInt64)));
4167   FOR_UINT32_INPUTS(i) {
4168     FOR_UINT32_INPUTS(j) {
4169       expected = (static_cast<uint64_t>(*j) << 32) | *i;
4170       CHECK_UINT32_EQ(expected, m.Call());
4171     }
4172   }
4173 }
4174
4175
4176 TEST(RunTruncateFloat64ToInt32P) {
4177   struct {
4178     double from;
4179     double raw;
4180   } kValues[] = {{0, 0},
4181                  {0.5, 0},
4182                  {-0.5, 0},
4183                  {1.5, 1},
4184                  {-1.5, -1},
4185                  {5.5, 5},
4186                  {-5.0, -5},
4187                  {v8::base::OS::nan_value(), 0},
4188                  {std::numeric_limits<double>::infinity(), 0},
4189                  {-v8::base::OS::nan_value(), 0},
4190                  {-std::numeric_limits<double>::infinity(), 0},
4191                  {4.94065645841e-324, 0},
4192                  {-4.94065645841e-324, 0},
4193                  {0.9999999999999999, 0},
4194                  {-0.9999999999999999, 0},
4195                  {4294967296.0, 0},
4196                  {-4294967296.0, 0},
4197                  {9223372036854775000.0, 4294966272.0},
4198                  {-9223372036854775000.0, -4294966272.0},
4199                  {4.5036e+15, 372629504},
4200                  {-4.5036e+15, -372629504},
4201                  {287524199.5377777, 0x11234567},
4202                  {-287524199.5377777, -0x11234567},
4203                  {2300193596.302222, 2300193596.0},
4204                  {-2300193596.302222, -2300193596.0},
4205                  {4600387192.604444, 305419896},
4206                  {-4600387192.604444, -305419896},
4207                  {4823855600872397.0, 1737075661},
4208                  {-4823855600872397.0, -1737075661},
4209                  {4503603922337791.0, -1},
4210                  {-4503603922337791.0, 1},
4211                  {4503601774854143.0, 2147483647},
4212                  {-4503601774854143.0, -2147483647},
4213                  {9007207844675582.0, -2},
4214                  {-9007207844675582.0, 2},
4215                  {2.4178527921507624e+24, -536870912},
4216                  {-2.4178527921507624e+24, 536870912},
4217                  {2.417853945072267e+24, -536870912},
4218                  {-2.417853945072267e+24, 536870912},
4219                  {4.8357055843015248e+24, -1073741824},
4220                  {-4.8357055843015248e+24, 1073741824},
4221                  {4.8357078901445341e+24, -1073741824},
4222                  {-4.8357078901445341e+24, 1073741824},
4223                  {2147483647.0, 2147483647.0},
4224                  {-2147483648.0, -2147483648.0},
4225                  {9.6714111686030497e+24, -2147483648.0},
4226                  {-9.6714111686030497e+24, -2147483648.0},
4227                  {9.6714157802890681e+24, -2147483648.0},
4228                  {-9.6714157802890681e+24, -2147483648.0},
4229                  {1.9342813113834065e+25, 2147483648.0},
4230                  {-1.9342813113834065e+25, 2147483648.0},
4231                  {3.868562622766813e+25, 0},
4232                  {-3.868562622766813e+25, 0},
4233                  {1.7976931348623157e+308, 0},
4234                  {-1.7976931348623157e+308, 0}};
4235   double input = -1.0;
4236   RawMachineAssemblerTester<int32_t> m;
4237   m.Return(m.TruncateFloat64ToInt32(m.LoadFromPointer(&input, kMachFloat64)));
4238   for (size_t i = 0; i < arraysize(kValues); ++i) {
4239     input = kValues[i].from;
4240     uint64_t expected = static_cast<int64_t>(kValues[i].raw);
4241     CHECK_EQ(static_cast<int>(expected), m.Call());
4242   }
4243 }
4244
4245 #endif  // V8_TURBOFAN_TARGET