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