src/v8/test/cctest/compiler/test-simplified-lowering.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 <limits>
   6
   7 #include "src/compiler/access-builder.h"
   8 #include "src/compiler/control-builders.h"
   9 #include "src/compiler/generic-node-inl.h"
  10 #include "src/compiler/graph-visualizer.h"
  11 #include "src/compiler/node-properties-inl.h"
  12 #include "src/compiler/pipeline.h"
  13 #include "src/compiler/representation-change.h"
  14 #include "src/compiler/simplified-lowering.h"
  15 #include "src/compiler/typer.h"
  16 #include "src/compiler/verifier.h"
  17 #include "src/execution.h"
  18 #include "src/parser.h"
  19 #include "src/rewriter.h"
  20 #include "src/scopes.h"
  21 #include "test/cctest/cctest.h"
  22 #include "test/cctest/compiler/codegen-tester.h"
  23 #include "test/cctest/compiler/graph-builder-tester.h"
  24 #include "test/cctest/compiler/value-helper.h"
  25
  26 using namespace v8::internal;
  27 using namespace v8::internal::compiler;
  28
  29 template <typename ReturnType>
  30 class SimplifiedLoweringTester : public GraphBuilderTester<ReturnType> {
  31  public:
  32   SimplifiedLoweringTester(MachineType p0 = kMachNone,
  33                            MachineType p1 = kMachNone,
  34                            MachineType p2 = kMachNone,
  35                            MachineType p3 = kMachNone,
  36                            MachineType p4 = kMachNone)
  37       : GraphBuilderTester<ReturnType>(p0, p1, p2, p3, p4),
  38         typer(this->zone()),
  39         javascript(this->zone()),
  40         jsgraph(this->graph(), this->common(), &javascript, &typer,
  41                 this->machine()),
  42         lowering(&jsgraph) {}
  43
  44   Typer typer;
  45   JSOperatorBuilder javascript;
  46   JSGraph jsgraph;
  47   SimplifiedLowering lowering;
  48
  49   void LowerAllNodes() {
  50     this->End();
  51     lowering.LowerAllNodes();
  52   }
  53
  54   Factory* factory() { return this->isolate()->factory(); }
  55   Heap* heap() { return this->isolate()->heap(); }
  56 };
  57
  58
  59 #ifndef V8_TARGET_ARCH_ARM64
  60 // TODO(titzer): these result in a stub call that doesn't work on ARM64.
  61 // TODO(titzer): factor these tests out to test-run-simplifiedops.cc.
  62 // TODO(titzer): test tagged representation for input to NumberToInt32.
  63 TEST(RunNumberToInt32_float64) {
  64   // TODO(titzer): explicit load/stores here are only because of representations
  65   double input;
  66   int32_t result;
  67   SimplifiedLoweringTester<Object*> t;
  68   FieldAccess load = {kUntaggedBase, 0, Handle<Name>(), Type::Number(),
  69                       kMachFloat64};
  70   Node* loaded = t.LoadField(load, t.PointerConstant(&input));
  71   Node* convert = t.NumberToInt32(loaded);
  72   FieldAccess store = {kUntaggedBase, 0, Handle<Name>(), Type::Signed32(),
  73                        kMachInt32};
  74   t.StoreField(store, t.PointerConstant(&result), convert);
  75   t.Return(t.jsgraph.TrueConstant());
  76   t.LowerAllNodes();
  77   t.GenerateCode();
  78
  79   if (Pipeline::SupportedTarget()) {
  80     FOR_FLOAT64_INPUTS(i) {
  81       input = *i;
  82       int32_t expected = DoubleToInt32(*i);
  83       t.Call();
  84       CHECK_EQ(expected, result);
  85     }
  86   }
  87 }
  88
  89
  90 // TODO(titzer): test tagged representation for input to NumberToUint32.
  91 TEST(RunNumberToUint32_float64) {
  92   // TODO(titzer): explicit load/stores here are only because of representations
  93   double input;
  94   uint32_t result;
  95   SimplifiedLoweringTester<Object*> t;
  96   FieldAccess load = {kUntaggedBase, 0, Handle<Name>(), Type::Number(),
  97                       kMachFloat64};
  98   Node* loaded = t.LoadField(load, t.PointerConstant(&input));
  99   Node* convert = t.NumberToUint32(loaded);
 100   FieldAccess store = {kUntaggedBase, 0, Handle<Name>(), Type::Unsigned32(),
 101                        kMachUint32};
 102   t.StoreField(store, t.PointerConstant(&result), convert);
 103   t.Return(t.jsgraph.TrueConstant());
 104   t.LowerAllNodes();
 105   t.GenerateCode();
 106
 107   if (Pipeline::SupportedTarget()) {
 108     FOR_FLOAT64_INPUTS(i) {
 109       input = *i;
 110       uint32_t expected = DoubleToUint32(*i);
 111       t.Call();
 112       CHECK_EQ(static_cast<int32_t>(expected), static_cast<int32_t>(result));
 113     }
 114   }
 115 }
 116 #endif
 117
 118
 119 // Create a simple JSObject with a unique map.
 120 static Handle<JSObject> TestObject() {
 121   static int index = 0;
 122   char buffer[50];
 123   v8::base::OS::SNPrintF(buffer, 50, "({'a_%d':1})", index++);
 124   return Handle<JSObject>::cast(v8::Utils::OpenHandle(*CompileRun(buffer)));
 125 }
 126
 127
 128 TEST(RunLoadMap) {
 129   SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
 130   FieldAccess access = AccessBuilder::ForMap();
 131   Node* load = t.LoadField(access, t.Parameter(0));
 132   t.Return(load);
 133
 134   t.LowerAllNodes();
 135   t.GenerateCode();
 136
 137   if (Pipeline::SupportedTarget()) {
 138     Handle<JSObject> src = TestObject();
 139     Handle<Map> src_map(src->map());
 140     Object* result = t.Call(*src);  // TODO(titzer): raw pointers in call
 141     CHECK_EQ(*src_map, result);
 142   }
 143 }
 144
 145
 146 TEST(RunStoreMap) {
 147   SimplifiedLoweringTester<int32_t> t(kMachAnyTagged, kMachAnyTagged);
 148   FieldAccess access = AccessBuilder::ForMap();
 149   t.StoreField(access, t.Parameter(1), t.Parameter(0));
 150   t.Return(t.jsgraph.TrueConstant());
 151
 152   t.LowerAllNodes();
 153   t.GenerateCode();
 154
 155   if (Pipeline::SupportedTarget()) {
 156     Handle<JSObject> src = TestObject();
 157     Handle<Map> src_map(src->map());
 158     Handle<JSObject> dst = TestObject();
 159     CHECK(src->map() != dst->map());
 160     t.Call(*src_map, *dst);  // TODO(titzer): raw pointers in call
 161     CHECK(*src_map == dst->map());
 162   }
 163 }
 164
 165
 166 TEST(RunLoadProperties) {
 167   SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
 168   FieldAccess access = AccessBuilder::ForJSObjectProperties();
 169   Node* load = t.LoadField(access, t.Parameter(0));
 170   t.Return(load);
 171
 172   t.LowerAllNodes();
 173   t.GenerateCode();
 174
 175   if (Pipeline::SupportedTarget()) {
 176     Handle<JSObject> src = TestObject();
 177     Handle<FixedArray> src_props(src->properties());
 178     Object* result = t.Call(*src);  // TODO(titzer): raw pointers in call
 179     CHECK_EQ(*src_props, result);
 180   }
 181 }
 182
 183
 184 TEST(RunLoadStoreMap) {
 185   SimplifiedLoweringTester<Object*> t(kMachAnyTagged, kMachAnyTagged);
 186   FieldAccess access = AccessBuilder::ForMap();
 187   Node* load = t.LoadField(access, t.Parameter(0));
 188   t.StoreField(access, t.Parameter(1), load);
 189   t.Return(load);
 190
 191   t.LowerAllNodes();
 192   t.GenerateCode();
 193
 194   if (Pipeline::SupportedTarget()) {
 195     Handle<JSObject> src = TestObject();
 196     Handle<Map> src_map(src->map());
 197     Handle<JSObject> dst = TestObject();
 198     CHECK(src->map() != dst->map());
 199     Object* result = t.Call(*src, *dst);  // TODO(titzer): raw pointers in call
 200     CHECK(result->IsMap());
 201     CHECK_EQ(*src_map, result);
 202     CHECK(*src_map == dst->map());
 203   }
 204 }
 205
 206
 207 TEST(RunLoadStoreFixedArrayIndex) {
 208   SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
 209   ElementAccess access = AccessBuilder::ForFixedArrayElement();
 210   Node* load = t.LoadElement(access, t.Parameter(0), t.Int32Constant(0),
 211                              t.Int32Constant(2));
 212   t.StoreElement(access, t.Parameter(0), t.Int32Constant(1), t.Int32Constant(2),
 213                  load);
 214   t.Return(load);
 215
 216   t.LowerAllNodes();
 217   t.GenerateCode();
 218
 219   if (Pipeline::SupportedTarget()) {
 220     Handle<FixedArray> array = t.factory()->NewFixedArray(2);
 221     Handle<JSObject> src = TestObject();
 222     Handle<JSObject> dst = TestObject();
 223     array->set(0, *src);
 224     array->set(1, *dst);
 225     Object* result = t.Call(*array);
 226     CHECK_EQ(*src, result);
 227     CHECK_EQ(*src, array->get(0));
 228     CHECK_EQ(*src, array->get(1));
 229   }
 230 }
 231
 232
 233 TEST(RunLoadStoreArrayBuffer) {
 234   SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
 235   const int index = 12;
 236   const int array_length = 2 * index;
 237   ElementAccess buffer_access =
 238       AccessBuilder::ForBackingStoreElement(kMachInt8);
 239   Node* backing_store = t.LoadField(
 240       AccessBuilder::ForJSArrayBufferBackingStore(), t.Parameter(0));
 241   Node* load =
 242       t.LoadElement(buffer_access, backing_store, t.Int32Constant(index),
 243                     t.Int32Constant(array_length));
 244   t.StoreElement(buffer_access, backing_store, t.Int32Constant(index + 1),
 245                  t.Int32Constant(array_length), load);
 246   t.Return(t.jsgraph.TrueConstant());
 247
 248   t.LowerAllNodes();
 249   t.GenerateCode();
 250
 251   if (Pipeline::SupportedTarget()) {
 252     Handle<JSArrayBuffer> array = t.factory()->NewJSArrayBuffer();
 253     Runtime::SetupArrayBufferAllocatingData(t.isolate(), array, array_length);
 254     uint8_t* data = reinterpret_cast<uint8_t*>(array->backing_store());
 255     for (int i = 0; i < array_length; i++) {
 256       data[i] = i;
 257     }
 258
 259     // TODO(titzer): raw pointers in call
 260     Object* result = t.Call(*array);
 261     CHECK_EQ(t.isolate()->heap()->true_value(), result);
 262     for (int i = 0; i < array_length; i++) {
 263       uint8_t expected = i;
 264       if (i == (index + 1)) expected = index;
 265       CHECK_EQ(data[i], expected);
 266     }
 267   }
 268 }
 269
 270
 271 TEST(RunLoadFieldFromUntaggedBase) {
 272   Smi* smis[] = {Smi::FromInt(1), Smi::FromInt(2), Smi::FromInt(3)};
 273
 274   for (size_t i = 0; i < arraysize(smis); i++) {
 275     int offset = static_cast<int>(i * sizeof(Smi*));
 276     FieldAccess access = {kUntaggedBase, offset, Handle<Name>(),
 277                           Type::Integral32(), kMachAnyTagged};
 278
 279     SimplifiedLoweringTester<Object*> t;
 280     Node* load = t.LoadField(access, t.PointerConstant(smis));
 281     t.Return(load);
 282     t.LowerAllNodes();
 283
 284     if (!Pipeline::SupportedTarget()) continue;
 285
 286     for (int j = -5; j <= 5; j++) {
 287       Smi* expected = Smi::FromInt(j);
 288       smis[i] = expected;
 289       CHECK_EQ(expected, t.Call());
 290     }
 291   }
 292 }
 293
 294
 295 TEST(RunStoreFieldToUntaggedBase) {
 296   Smi* smis[] = {Smi::FromInt(1), Smi::FromInt(2), Smi::FromInt(3)};
 297
 298   for (size_t i = 0; i < arraysize(smis); i++) {
 299     int offset = static_cast<int>(i * sizeof(Smi*));
 300     FieldAccess access = {kUntaggedBase, offset, Handle<Name>(),
 301                           Type::Integral32(), kMachAnyTagged};
 302
 303     SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
 304     Node* p0 = t.Parameter(0);
 305     t.StoreField(access, t.PointerConstant(smis), p0);
 306     t.Return(p0);
 307     t.LowerAllNodes();
 308
 309     if (!Pipeline::SupportedTarget()) continue;
 310
 311     for (int j = -5; j <= 5; j++) {
 312       Smi* expected = Smi::FromInt(j);
 313       smis[i] = Smi::FromInt(-100);
 314       CHECK_EQ(expected, t.Call(expected));
 315       CHECK_EQ(expected, smis[i]);
 316     }
 317   }
 318 }
 319
 320
 321 TEST(RunLoadElementFromUntaggedBase) {
 322   Smi* smis[] = {Smi::FromInt(1), Smi::FromInt(2), Smi::FromInt(3),
 323                  Smi::FromInt(4), Smi::FromInt(5)};
 324
 325   for (size_t i = 0; i < arraysize(smis); i++) {    // for header sizes
 326     for (size_t j = 0; (i + j) < arraysize(smis); j++) {  // for element index
 327       int offset = static_cast<int>(i * sizeof(Smi*));
 328       ElementAccess access = {kUntaggedBase, offset, Type::Integral32(),
 329                               kMachAnyTagged};
 330
 331       SimplifiedLoweringTester<Object*> t;
 332       Node* load = t.LoadElement(
 333           access, t.PointerConstant(smis), t.Int32Constant(static_cast<int>(j)),
 334           t.Int32Constant(static_cast<int>(arraysize(smis))));
 335       t.Return(load);
 336       t.LowerAllNodes();
 337
 338       if (!Pipeline::SupportedTarget()) continue;
 339
 340       for (int k = -5; k <= 5; k++) {
 341         Smi* expected = Smi::FromInt(k);
 342         smis[i + j] = expected;
 343         CHECK_EQ(expected, t.Call());
 344       }
 345     }
 346   }
 347 }
 348
 349
 350 TEST(RunStoreElementFromUntaggedBase) {
 351   Smi* smis[] = {Smi::FromInt(1), Smi::FromInt(2), Smi::FromInt(3),
 352                  Smi::FromInt(4), Smi::FromInt(5)};
 353
 354   for (size_t i = 0; i < arraysize(smis); i++) {    // for header sizes
 355     for (size_t j = 0; (i + j) < arraysize(smis); j++) {  // for element index
 356       int offset = static_cast<int>(i * sizeof(Smi*));
 357       ElementAccess access = {kUntaggedBase, offset, Type::Integral32(),
 358                               kMachAnyTagged};
 359
 360       SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
 361       Node* p0 = t.Parameter(0);
 362       t.StoreElement(access, t.PointerConstant(smis),
 363                      t.Int32Constant(static_cast<int>(j)),
 364                      t.Int32Constant(static_cast<int>(arraysize(smis))), p0);
 365       t.Return(p0);
 366       t.LowerAllNodes();
 367
 368       if (!Pipeline::SupportedTarget()) continue;
 369
 370       for (int k = -5; k <= 5; k++) {
 371         Smi* expected = Smi::FromInt(k);
 372         smis[i + j] = Smi::FromInt(-100);
 373         CHECK_EQ(expected, t.Call(expected));
 374         CHECK_EQ(expected, smis[i + j]);
 375       }
 376
 377       // TODO(titzer): assert the contents of the array.
 378     }
 379   }
 380 }
 381
 382
 383 // A helper class for accessing fields and elements of various types, on both
 384 // tagged and untagged base pointers. Contains both tagged and untagged buffers
 385 // for testing direct memory access from generated code.
 386 template <typename E>
 387 class AccessTester : public HandleAndZoneScope {
 388  public:
 389   bool tagged;
 390   MachineType rep;
 391   E* original_elements;
 392   size_t num_elements;
 393   E* untagged_array;
 394   Handle<ByteArray> tagged_array;  // TODO(titzer): use FixedArray for tagged.
 395
 396   AccessTester(bool t, MachineType r, E* orig, size_t num)
 397       : tagged(t),
 398         rep(r),
 399         original_elements(orig),
 400         num_elements(num),
 401         untagged_array(static_cast<E*>(malloc(ByteSize()))),
 402         tagged_array(main_isolate()->factory()->NewByteArray(
 403             static_cast<int>(ByteSize()))) {
 404     Reinitialize();
 405   }
 406
 407   ~AccessTester() { free(untagged_array); }
 408
 409   size_t ByteSize() { return num_elements * sizeof(E); }
 410
 411   // Nuke both {untagged_array} and {tagged_array} with {original_elements}.
 412   void Reinitialize() {
 413     memcpy(untagged_array, original_elements, ByteSize());
 414     CHECK_EQ(static_cast<int>(ByteSize()), tagged_array->length());
 415     E* raw = reinterpret_cast<E*>(tagged_array->GetDataStartAddress());
 416     memcpy(raw, original_elements, ByteSize());
 417   }
 418
 419   // Create and run code that copies the element in either {untagged_array}
 420   // or {tagged_array} at index {from_index} to index {to_index}.
 421   void RunCopyElement(int from_index, int to_index) {
 422     // TODO(titzer): test element and field accesses where the base is not
 423     // a constant in the code.
 424     BoundsCheck(from_index);
 425     BoundsCheck(to_index);
 426     ElementAccess access = GetElementAccess();
 427
 428     SimplifiedLoweringTester<Object*> t;
 429     Node* ptr = GetBaseNode(&t);
 430     Node* load = t.LoadElement(access, ptr, t.Int32Constant(from_index),
 431                                t.Int32Constant(static_cast<int>(num_elements)));
 432     t.StoreElement(access, ptr, t.Int32Constant(to_index),
 433                    t.Int32Constant(static_cast<int>(num_elements)), load);
 434     t.Return(t.jsgraph.TrueConstant());
 435     t.LowerAllNodes();
 436     t.GenerateCode();
 437
 438     if (Pipeline::SupportedTarget()) {
 439       Object* result = t.Call();
 440       CHECK_EQ(t.isolate()->heap()->true_value(), result);
 441     }
 442   }
 443
 444   // Create and run code that copies the field in either {untagged_array}
 445   // or {tagged_array} at index {from_index} to index {to_index}.
 446   void RunCopyField(int from_index, int to_index) {
 447     BoundsCheck(from_index);
 448     BoundsCheck(to_index);
 449     FieldAccess from_access = GetFieldAccess(from_index);
 450     FieldAccess to_access = GetFieldAccess(to_index);
 451
 452     SimplifiedLoweringTester<Object*> t;
 453     Node* ptr = GetBaseNode(&t);
 454     Node* load = t.LoadField(from_access, ptr);
 455     t.StoreField(to_access, ptr, load);
 456     t.Return(t.jsgraph.TrueConstant());
 457     t.LowerAllNodes();
 458     t.GenerateCode();
 459
 460     if (Pipeline::SupportedTarget()) {
 461       Object* result = t.Call();
 462       CHECK_EQ(t.isolate()->heap()->true_value(), result);
 463     }
 464   }
 465
 466   // Create and run code that copies the elements from {this} to {that}.
 467   void RunCopyElements(AccessTester<E>* that) {
 468 // TODO(titzer): Rewrite this test without StructuredGraphBuilder support.
 469 #if 0
 470     SimplifiedLoweringTester<Object*> t;
 471
 472     Node* one = t.Int32Constant(1);
 473     Node* index = t.Int32Constant(0);
 474     Node* limit = t.Int32Constant(static_cast<int>(num_elements));
 475     t.environment()->Push(index);
 476     Node* src = this->GetBaseNode(&t);
 477     Node* dst = that->GetBaseNode(&t);
 478     {
 479       LoopBuilder loop(&t);
 480       loop.BeginLoop();
 481       // Loop exit condition
 482       index = t.environment()->Top();
 483       Node* condition = t.Int32LessThan(index, limit);
 484       loop.BreakUnless(condition);
 485       // dst[index] = src[index]
 486       index = t.environment()->Pop();
 487       Node* load = t.LoadElement(this->GetElementAccess(), src, index);
 488       t.StoreElement(that->GetElementAccess(), dst, index, load);
 489       // index++
 490       index = t.Int32Add(index, one);
 491       t.environment()->Push(index);
 492       // continue
 493       loop.EndBody();
 494       loop.EndLoop();
 495     }
 496     index = t.environment()->Pop();
 497     t.Return(t.jsgraph.TrueConstant());
 498     t.LowerAllNodes();
 499     t.GenerateCode();
 500
 501     if (Pipeline::SupportedTarget()) {
 502       Object* result = t.Call();
 503       CHECK_EQ(t.isolate()->heap()->true_value(), result);
 504     }
 505 #endif
 506   }
 507
 508   E GetElement(int index) {
 509     BoundsCheck(index);
 510     if (tagged) {
 511       E* raw = reinterpret_cast<E*>(tagged_array->GetDataStartAddress());
 512       return raw[index];
 513     } else {
 514       return untagged_array[index];
 515     }
 516   }
 517
 518  private:
 519   ElementAccess GetElementAccess() {
 520     ElementAccess access = {tagged ? kTaggedBase : kUntaggedBase,
 521                             tagged ? FixedArrayBase::kHeaderSize : 0,
 522                             Type::Any(), rep};
 523     return access;
 524   }
 525
 526   FieldAccess GetFieldAccess(int field) {
 527     int offset = field * sizeof(E);
 528     FieldAccess access = {tagged ? kTaggedBase : kUntaggedBase,
 529                           offset + (tagged ? FixedArrayBase::kHeaderSize : 0),
 530                           Handle<Name>(), Type::Any(), rep};
 531     return access;
 532   }
 533
 534   template <typename T>
 535   Node* GetBaseNode(SimplifiedLoweringTester<T>* t) {
 536     return tagged ? t->HeapConstant(tagged_array)
 537                   : t->PointerConstant(untagged_array);
 538   }
 539
 540   void BoundsCheck(int index) {
 541     CHECK_GE(index, 0);
 542     CHECK_LT(index, static_cast<int>(num_elements));
 543     CHECK_EQ(static_cast<int>(ByteSize()), tagged_array->length());
 544   }
 545 };
 546
 547
 548 template <typename E>
 549 static void RunAccessTest(MachineType rep, E* original_elements, size_t num) {
 550   int num_elements = static_cast<int>(num);
 551
 552   for (int taggedness = 0; taggedness < 2; taggedness++) {
 553     AccessTester<E> a(taggedness == 1, rep, original_elements, num);
 554     for (int field = 0; field < 2; field++) {
 555       for (int i = 0; i < num_elements - 1; i++) {
 556         a.Reinitialize();
 557         if (field == 0) {
 558           a.RunCopyField(i, i + 1);  // Test field read/write.
 559         } else {
 560           a.RunCopyElement(i, i + 1);  // Test element read/write.
 561         }
 562         if (Pipeline::SupportedTarget()) {  // verify.
 563           for (int j = 0; j < num_elements; j++) {
 564             E expect =
 565                 j == (i + 1) ? original_elements[i] : original_elements[j];
 566             CHECK_EQ(expect, a.GetElement(j));
 567           }
 568         }
 569       }
 570     }
 571   }
 572   // Test array copy.
 573   for (int tf = 0; tf < 2; tf++) {
 574     for (int tt = 0; tt < 2; tt++) {
 575       AccessTester<E> a(tf == 1, rep, original_elements, num);
 576       AccessTester<E> b(tt == 1, rep, original_elements, num);
 577       a.RunCopyElements(&b);
 578       if (Pipeline::SupportedTarget()) {  // verify.
 579         for (int i = 0; i < num_elements; i++) {
 580           CHECK_EQ(a.GetElement(i), b.GetElement(i));
 581         }
 582       }
 583     }
 584   }
 585 }
 586
 587
 588 TEST(RunAccessTests_uint8) {
 589   uint8_t data[] = {0x07, 0x16, 0x25, 0x34, 0x43, 0x99,
 590                     0xab, 0x78, 0x89, 0x19, 0x2b, 0x38};
 591   RunAccessTest<uint8_t>(kMachInt8, data, arraysize(data));
 592 }
 593
 594
 595 TEST(RunAccessTests_uint16) {
 596   uint16_t data[] = {0x071a, 0x162b, 0x253c, 0x344d, 0x435e, 0x7777};
 597   RunAccessTest<uint16_t>(kMachInt16, data, arraysize(data));
 598 }
 599
 600
 601 TEST(RunAccessTests_int32) {
 602   int32_t data[] = {-211, 211, 628347, 2000000000, -2000000000, -1, -100000034};
 603   RunAccessTest<int32_t>(kMachInt32, data, arraysize(data));
 604 }
 605
 606
 607 #define V8_2PART_INT64(a, b) (((static_cast<int64_t>(a) << 32) + 0x##b##u))
 608
 609
 610 TEST(RunAccessTests_int64) {
 611   if (kPointerSize != 8) return;
 612   int64_t data[] = {V8_2PART_INT64(0x10111213, 14151617),
 613                     V8_2PART_INT64(0x20212223, 24252627),
 614                     V8_2PART_INT64(0x30313233, 34353637),
 615                     V8_2PART_INT64(0xa0a1a2a3, a4a5a6a7),
 616                     V8_2PART_INT64(0xf0f1f2f3, f4f5f6f7)};
 617   RunAccessTest<int64_t>(kMachInt64, data, arraysize(data));
 618 }
 619
 620
 621 TEST(RunAccessTests_float64) {
 622   double data[] = {1.25, -1.25, 2.75, 11.0, 11100.8};
 623   RunAccessTest<double>(kMachFloat64, data, arraysize(data));
 624 }
 625
 626
 627 TEST(RunAccessTests_Smi) {
 628   Smi* data[] = {Smi::FromInt(-1),    Smi::FromInt(-9),
 629                  Smi::FromInt(0),     Smi::FromInt(666),
 630                  Smi::FromInt(77777), Smi::FromInt(Smi::kMaxValue)};
 631   RunAccessTest<Smi*>(kMachAnyTagged, data, arraysize(data));
 632 }
 633
 634
 635 // Fills in most of the nodes of the graph in order to make tests shorter.
 636 class TestingGraph : public HandleAndZoneScope, public GraphAndBuilders {
 637  public:
 638   Typer typer;
 639   JSOperatorBuilder javascript;
 640   JSGraph jsgraph;
 641   Node* p0;
 642   Node* p1;
 643   Node* p2;
 644   Node* start;
 645   Node* end;
 646   Node* ret;
 647
 648   explicit TestingGraph(Type* p0_type, Type* p1_type = Type::None(),
 649                         Type* p2_type = Type::None())
 650       : GraphAndBuilders(main_zone()),
 651         typer(main_zone()),
 652         javascript(main_zone()),
 653         jsgraph(graph(), common(), &javascript, &typer, machine()) {
 654     start = graph()->NewNode(common()->Start(2));
 655     graph()->SetStart(start);
 656     ret =
 657         graph()->NewNode(common()->Return(), jsgraph.Constant(0), start, start);
 658     end = graph()->NewNode(common()->End(), ret);
 659     graph()->SetEnd(end);
 660     p0 = graph()->NewNode(common()->Parameter(0), start);
 661     p1 = graph()->NewNode(common()->Parameter(1), start);
 662     p2 = graph()->NewNode(common()->Parameter(2), start);
 663     NodeProperties::SetBounds(p0, Bounds(p0_type));
 664     NodeProperties::SetBounds(p1, Bounds(p1_type));
 665     NodeProperties::SetBounds(p2, Bounds(p2_type));
 666   }
 667
 668   void CheckLoweringBinop(IrOpcode::Value expected, const Operator* op) {
 669     Node* node = Return(graph()->NewNode(op, p0, p1));
 670     Lower();
 671     CHECK_EQ(expected, node->opcode());
 672   }
 673
 674   void CheckLoweringTruncatedBinop(IrOpcode::Value expected, const Operator* op,
 675                                    const Operator* trunc) {
 676     Node* node = graph()->NewNode(op, p0, p1);
 677     Return(graph()->NewNode(trunc, node));
 678     Lower();
 679     CHECK_EQ(expected, node->opcode());
 680   }
 681
 682   void Lower() {
 683     SimplifiedLowering lowering(&jsgraph);
 684     lowering.LowerAllNodes();
 685   }
 686
 687   // Inserts the node as the return value of the graph.
 688   Node* Return(Node* node) {
 689     ret->ReplaceInput(0, node);
 690     return node;
 691   }
 692
 693   // Inserts the node as the effect input to the return of the graph.
 694   void Effect(Node* node) { ret->ReplaceInput(1, node); }
 695
 696   Node* ExampleWithOutput(MachineType type) {
 697     // TODO(titzer): use parameters with guaranteed representations.
 698     if (type & kTypeInt32) {
 699       return graph()->NewNode(machine()->Int32Add(), jsgraph.Int32Constant(1),
 700                               jsgraph.Int32Constant(1));
 701     } else if (type & kTypeUint32) {
 702       return graph()->NewNode(machine()->Word32Shr(), jsgraph.Int32Constant(1),
 703                               jsgraph.Int32Constant(1));
 704     } else if (type & kRepFloat64) {
 705       return graph()->NewNode(machine()->Float64Add(),
 706                               jsgraph.Float64Constant(1),
 707                               jsgraph.Float64Constant(1));
 708     } else if (type & kRepBit) {
 709       return graph()->NewNode(machine()->Word32Equal(),
 710                               jsgraph.Int32Constant(1),
 711                               jsgraph.Int32Constant(1));
 712     } else if (type & kRepWord64) {
 713       return graph()->NewNode(machine()->Int64Add(), Int64Constant(1),
 714                               Int64Constant(1));
 715     } else {
 716       CHECK(type & kRepTagged);
 717       return p0;
 718     }
 719   }
 720
 721   Node* Use(Node* node, MachineType type) {
 722     if (type & kTypeInt32) {
 723       return graph()->NewNode(machine()->Int32LessThan(), node,
 724                               jsgraph.Int32Constant(1));
 725     } else if (type & kTypeUint32) {
 726       return graph()->NewNode(machine()->Uint32LessThan(), node,
 727                               jsgraph.Int32Constant(1));
 728     } else if (type & kRepFloat64) {
 729       return graph()->NewNode(machine()->Float64Add(), node,
 730                               jsgraph.Float64Constant(1));
 731     } else if (type & kRepWord64) {
 732       return graph()->NewNode(machine()->Int64LessThan(), node,
 733                               Int64Constant(1));
 734     } else {
 735       return graph()->NewNode(simplified()->ReferenceEqual(Type::Any()), node,
 736                               jsgraph.TrueConstant());
 737     }
 738   }
 739
 740   Node* Branch(Node* cond) {
 741     Node* br = graph()->NewNode(common()->Branch(), cond, start);
 742     Node* tb = graph()->NewNode(common()->IfTrue(), br);
 743     Node* fb = graph()->NewNode(common()->IfFalse(), br);
 744     Node* m = graph()->NewNode(common()->Merge(2), tb, fb);
 745     NodeProperties::ReplaceControlInput(ret, m);
 746     return br;
 747   }
 748
 749   Node* Int64Constant(int64_t v) {
 750     return graph()->NewNode(common()->Int64Constant(v));
 751   }
 752
 753   SimplifiedOperatorBuilder* simplified() { return &main_simplified_; }
 754   MachineOperatorBuilder* machine() { return &main_machine_; }
 755   CommonOperatorBuilder* common() { return &main_common_; }
 756   Graph* graph() { return main_graph_; }
 757 };
 758
 759
 760 TEST(LowerBooleanNot_bit_bit) {
 761   // BooleanNot(x: kRepBit) used as kRepBit
 762   TestingGraph t(Type::Boolean());
 763   Node* b = t.ExampleWithOutput(kRepBit);
 764   Node* inv = t.graph()->NewNode(t.simplified()->BooleanNot(), b);
 765   Node* use = t.Branch(inv);
 766   t.Lower();
 767   Node* cmp = use->InputAt(0);
 768   CHECK_EQ(t.machine()->WordEqual()->opcode(), cmp->opcode());
 769   CHECK(b == cmp->InputAt(0) || b == cmp->InputAt(1));
 770   Node* f = t.jsgraph.Int32Constant(0);
 771   CHECK(f == cmp->InputAt(0) || f == cmp->InputAt(1));
 772 }
 773
 774
 775 TEST(LowerBooleanNot_bit_tagged) {
 776   // BooleanNot(x: kRepBit) used as kRepTagged
 777   TestingGraph t(Type::Boolean());
 778   Node* b = t.ExampleWithOutput(kRepBit);
 779   Node* inv = t.graph()->NewNode(t.simplified()->BooleanNot(), b);
 780   Node* use = t.Use(inv, kRepTagged);
 781   t.Return(use);
 782   t.Lower();
 783   CHECK_EQ(IrOpcode::kChangeBitToBool, use->InputAt(0)->opcode());
 784   Node* cmp = use->InputAt(0)->InputAt(0);
 785   CHECK_EQ(t.machine()->WordEqual()->opcode(), cmp->opcode());
 786   CHECK(b == cmp->InputAt(0) || b == cmp->InputAt(1));
 787   Node* f = t.jsgraph.Int32Constant(0);
 788   CHECK(f == cmp->InputAt(0) || f == cmp->InputAt(1));
 789 }
 790
 791
 792 TEST(LowerBooleanNot_tagged_bit) {
 793   // BooleanNot(x: kRepTagged) used as kRepBit
 794   TestingGraph t(Type::Boolean());
 795   Node* b = t.p0;
 796   Node* inv = t.graph()->NewNode(t.simplified()->BooleanNot(), b);
 797   Node* use = t.Branch(inv);
 798   t.Lower();
 799   Node* cmp = use->InputAt(0);
 800   CHECK_EQ(t.machine()->WordEqual()->opcode(), cmp->opcode());
 801   CHECK(b == cmp->InputAt(0) || b == cmp->InputAt(1));
 802   Node* f = t.jsgraph.FalseConstant();
 803   CHECK(f == cmp->InputAt(0) || f == cmp->InputAt(1));
 804 }
 805
 806
 807 TEST(LowerBooleanNot_tagged_tagged) {
 808   // BooleanNot(x: kRepTagged) used as kRepTagged
 809   TestingGraph t(Type::Boolean());
 810   Node* b = t.p0;
 811   Node* inv = t.graph()->NewNode(t.simplified()->BooleanNot(), b);
 812   Node* use = t.Use(inv, kRepTagged);
 813   t.Return(use);
 814   t.Lower();
 815   CHECK_EQ(IrOpcode::kChangeBitToBool, use->InputAt(0)->opcode());
 816   Node* cmp = use->InputAt(0)->InputAt(0);
 817   CHECK_EQ(t.machine()->WordEqual()->opcode(), cmp->opcode());
 818   CHECK(b == cmp->InputAt(0) || b == cmp->InputAt(1));
 819   Node* f = t.jsgraph.FalseConstant();
 820   CHECK(f == cmp->InputAt(0) || f == cmp->InputAt(1));
 821 }
 822
 823
 824 TEST(LowerBooleanToNumber_bit_int32) {
 825   // BooleanToNumber(x: kRepBit) used as kMachInt32
 826   TestingGraph t(Type::Boolean());
 827   Node* b = t.ExampleWithOutput(kRepBit);
 828   Node* cnv = t.graph()->NewNode(t.simplified()->BooleanToNumber(), b);
 829   Node* use = t.Use(cnv, kMachInt32);
 830   t.Return(use);
 831   t.Lower();
 832   CHECK_EQ(b, use->InputAt(0));
 833 }
 834
 835
 836 TEST(LowerBooleanToNumber_tagged_int32) {
 837   // BooleanToNumber(x: kRepTagged) used as kMachInt32
 838   TestingGraph t(Type::Boolean());
 839   Node* b = t.p0;
 840   Node* cnv = t.graph()->NewNode(t.simplified()->BooleanToNumber(), b);
 841   Node* use = t.Use(cnv, kMachInt32);
 842   t.Return(use);
 843   t.Lower();
 844   CHECK_EQ(t.machine()->WordEqual()->opcode(), cnv->opcode());
 845   CHECK(b == cnv->InputAt(0) || b == cnv->InputAt(1));
 846   Node* c = t.jsgraph.TrueConstant();
 847   CHECK(c == cnv->InputAt(0) || c == cnv->InputAt(1));
 848 }
 849
 850
 851 TEST(LowerBooleanToNumber_bit_tagged) {
 852   // BooleanToNumber(x: kRepBit) used as kMachAnyTagged
 853   TestingGraph t(Type::Boolean());
 854   Node* b = t.ExampleWithOutput(kRepBit);
 855   Node* cnv = t.graph()->NewNode(t.simplified()->BooleanToNumber(), b);
 856   Node* use = t.Use(cnv, kMachAnyTagged);
 857   t.Return(use);
 858   t.Lower();
 859   CHECK_EQ(b, use->InputAt(0)->InputAt(0));
 860   CHECK_EQ(IrOpcode::kChangeInt32ToTagged, use->InputAt(0)->opcode());
 861 }
 862
 863
 864 TEST(LowerBooleanToNumber_tagged_tagged) {
 865   // BooleanToNumber(x: kRepTagged) used as kMachAnyTagged
 866   TestingGraph t(Type::Boolean());
 867   Node* b = t.p0;
 868   Node* cnv = t.graph()->NewNode(t.simplified()->BooleanToNumber(), b);
 869   Node* use = t.Use(cnv, kMachAnyTagged);
 870   t.Return(use);
 871   t.Lower();
 872   CHECK_EQ(cnv, use->InputAt(0)->InputAt(0));
 873   CHECK_EQ(IrOpcode::kChangeInt32ToTagged, use->InputAt(0)->opcode());
 874   CHECK_EQ(t.machine()->WordEqual()->opcode(), cnv->opcode());
 875   CHECK(b == cnv->InputAt(0) || b == cnv->InputAt(1));
 876   Node* c = t.jsgraph.TrueConstant();
 877   CHECK(c == cnv->InputAt(0) || c == cnv->InputAt(1));
 878 }
 879
 880
 881 static Type* test_types[] = {Type::Signed32(), Type::Unsigned32(),
 882                              Type::Number(), Type::Any()};
 883
 884
 885 TEST(LowerNumberCmp_to_int32) {
 886   TestingGraph t(Type::Signed32(), Type::Signed32());
 887
 888   t.CheckLoweringBinop(IrOpcode::kWord32Equal, t.simplified()->NumberEqual());
 889   t.CheckLoweringBinop(IrOpcode::kInt32LessThan,
 890                        t.simplified()->NumberLessThan());
 891   t.CheckLoweringBinop(IrOpcode::kInt32LessThanOrEqual,
 892                        t.simplified()->NumberLessThanOrEqual());
 893 }
 894
 895
 896 TEST(LowerNumberCmp_to_uint32) {
 897   TestingGraph t(Type::Unsigned32(), Type::Unsigned32());
 898
 899   t.CheckLoweringBinop(IrOpcode::kWord32Equal, t.simplified()->NumberEqual());
 900   t.CheckLoweringBinop(IrOpcode::kUint32LessThan,
 901                        t.simplified()->NumberLessThan());
 902   t.CheckLoweringBinop(IrOpcode::kUint32LessThanOrEqual,
 903                        t.simplified()->NumberLessThanOrEqual());
 904 }
 905
 906
 907 TEST(LowerNumberCmp_to_float64) {
 908   static Type* types[] = {Type::Number(), Type::Any()};
 909
 910   for (size_t i = 0; i < arraysize(types); i++) {
 911     TestingGraph t(types[i], types[i]);
 912
 913     t.CheckLoweringBinop(IrOpcode::kFloat64Equal,
 914                          t.simplified()->NumberEqual());
 915     t.CheckLoweringBinop(IrOpcode::kFloat64LessThan,
 916                          t.simplified()->NumberLessThan());
 917     t.CheckLoweringBinop(IrOpcode::kFloat64LessThanOrEqual,
 918                          t.simplified()->NumberLessThanOrEqual());
 919   }
 920 }
 921
 922
 923 TEST(LowerNumberAddSub_to_int32) {
 924   TestingGraph t(Type::Signed32(), Type::Signed32());
 925   t.CheckLoweringTruncatedBinop(IrOpcode::kInt32Add,
 926                                 t.simplified()->NumberAdd(),
 927                                 t.simplified()->NumberToInt32());
 928   t.CheckLoweringTruncatedBinop(IrOpcode::kInt32Sub,
 929                                 t.simplified()->NumberSubtract(),
 930                                 t.simplified()->NumberToInt32());
 931 }
 932
 933
 934 TEST(LowerNumberAddSub_to_uint32) {
 935   TestingGraph t(Type::Unsigned32(), Type::Unsigned32());
 936   t.CheckLoweringTruncatedBinop(IrOpcode::kInt32Add,
 937                                 t.simplified()->NumberAdd(),
 938                                 t.simplified()->NumberToUint32());
 939   t.CheckLoweringTruncatedBinop(IrOpcode::kInt32Sub,
 940                                 t.simplified()->NumberSubtract(),
 941                                 t.simplified()->NumberToUint32());
 942 }
 943
 944
 945 TEST(LowerNumberAddSub_to_float64) {
 946   for (size_t i = 0; i < arraysize(test_types); i++) {
 947     TestingGraph t(test_types[i], test_types[i]);
 948
 949     t.CheckLoweringBinop(IrOpcode::kFloat64Add, t.simplified()->NumberAdd());
 950     t.CheckLoweringBinop(IrOpcode::kFloat64Sub,
 951                          t.simplified()->NumberSubtract());
 952   }
 953 }
 954
 955
 956 TEST(LowerNumberDivMod_to_float64) {
 957   for (size_t i = 0; i < arraysize(test_types); i++) {
 958     TestingGraph t(test_types[i], test_types[i]);
 959
 960     t.CheckLoweringBinop(IrOpcode::kFloat64Div, t.simplified()->NumberDivide());
 961     t.CheckLoweringBinop(IrOpcode::kFloat64Mod,
 962                          t.simplified()->NumberModulus());
 963   }
 964 }
 965
 966
 967 static void CheckChangeOf(IrOpcode::Value change, Node* of, Node* node) {
 968   CHECK_EQ(change, node->opcode());
 969   CHECK_EQ(of, node->InputAt(0));
 970 }
 971
 972
 973 TEST(LowerNumberToInt32_to_nop) {
 974   // NumberToInt32(x: kRepTagged | kTypeInt32) used as kRepTagged
 975   TestingGraph t(Type::Signed32());
 976   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), t.p0);
 977   Node* use = t.Use(trunc, kRepTagged);
 978   t.Return(use);
 979   t.Lower();
 980   CHECK_EQ(t.p0, use->InputAt(0));
 981 }
 982
 983
 984 TEST(LowerNumberToInt32_to_ChangeTaggedToFloat64) {
 985   // NumberToInt32(x: kRepTagged | kTypeInt32) used as kRepFloat64
 986   TestingGraph t(Type::Signed32());
 987   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), t.p0);
 988   Node* use = t.Use(trunc, kRepFloat64);
 989   t.Return(use);
 990   t.Lower();
 991   CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p0, use->InputAt(0));
 992 }
 993
 994
 995 TEST(LowerNumberToInt32_to_ChangeTaggedToInt32) {
 996   // NumberToInt32(x: kRepTagged | kTypeInt32) used as kRepWord32
 997   TestingGraph t(Type::Signed32());
 998   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), t.p0);
 999   Node* use = t.Use(trunc, kTypeInt32);
1000   t.Return(use);
1001   t.Lower();
1002   CheckChangeOf(IrOpcode::kChangeTaggedToInt32, t.p0, use->InputAt(0));
1003 }
1004
1005
1006 TEST(LowerNumberToInt32_to_TruncateFloat64ToInt32) {
1007   // NumberToInt32(x: kRepFloat64) used as kMachInt32
1008   TestingGraph t(Type::Number());
1009   Node* p0 = t.ExampleWithOutput(kMachFloat64);
1010   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), p0);
1011   Node* use = t.Use(trunc, kMachInt32);
1012   t.Return(use);
1013   t.Lower();
1014   CheckChangeOf(IrOpcode::kTruncateFloat64ToInt32, p0, use->InputAt(0));
1015 }
1016
1017
1018 TEST(LowerNumberToInt32_to_TruncateFloat64ToInt32_with_change) {
1019   // NumberToInt32(x: kTypeNumber | kRepTagged) used as kMachInt32
1020   TestingGraph t(Type::Number());
1021   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), t.p0);
1022   Node* use = t.Use(trunc, kMachInt32);
1023   t.Return(use);
1024   t.Lower();
1025   Node* node = use->InputAt(0);
1026   CHECK_EQ(IrOpcode::kTruncateFloat64ToInt32, node->opcode());
1027   Node* of = node->InputAt(0);
1028   CHECK_EQ(IrOpcode::kChangeTaggedToFloat64, of->opcode());
1029   CHECK_EQ(t.p0, of->InputAt(0));
1030 }
1031
1032
1033 TEST(LowerNumberToInt32_to_ChangeFloat64ToTagged) {
1034   // TODO(titzer): NumberToInt32(x: kRepFloat64 | kTypeInt32) used as kRepTagged
1035 }
1036
1037
1038 TEST(LowerNumberToInt32_to_ChangeFloat64ToInt32) {
1039   // TODO(titzer): NumberToInt32(x: kRepFloat64 | kTypeInt32) used as kRepWord32
1040   // | kTypeInt32
1041 }
1042
1043
1044 TEST(LowerNumberToUint32_to_nop) {
1045   // NumberToUint32(x: kRepTagged | kTypeUint32) used as kRepTagged
1046   TestingGraph t(Type::Unsigned32());
1047   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), t.p0);
1048   Node* use = t.Use(trunc, kRepTagged);
1049   t.Return(use);
1050   t.Lower();
1051   CHECK_EQ(t.p0, use->InputAt(0));
1052 }
1053
1054
1055 TEST(LowerNumberToUint32_to_ChangeTaggedToFloat64) {
1056   // NumberToUint32(x: kRepTagged | kTypeUint32) used as kRepWord32
1057   TestingGraph t(Type::Unsigned32());
1058   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), t.p0);
1059   Node* use = t.Use(trunc, kRepFloat64);
1060   t.Return(use);
1061   t.Lower();
1062   CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p0, use->InputAt(0));
1063 }
1064
1065
1066 TEST(LowerNumberToUint32_to_ChangeTaggedToUint32) {
1067   // NumberToUint32(x: kRepTagged | kTypeUint32) used as kRepWord32
1068   TestingGraph t(Type::Unsigned32());
1069   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), t.p0);
1070   Node* use = t.Use(trunc, kTypeUint32);
1071   t.Return(use);
1072   t.Lower();
1073   CheckChangeOf(IrOpcode::kChangeTaggedToUint32, t.p0, use->InputAt(0));
1074 }
1075
1076
1077 TEST(LowerNumberToUint32_to_TruncateFloat64ToInt32) {
1078   // NumberToUint32(x: kRepFloat64) used as kMachUint32
1079   TestingGraph t(Type::Number());
1080   Node* p0 = t.ExampleWithOutput(kMachFloat64);
1081   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), p0);
1082   Node* use = t.Use(trunc, kMachUint32);
1083   t.Return(use);
1084   t.Lower();
1085   CheckChangeOf(IrOpcode::kTruncateFloat64ToInt32, p0, use->InputAt(0));
1086 }
1087
1088
1089 TEST(LowerNumberToUint32_to_TruncateFloat64ToInt32_with_change) {
1090   // NumberToInt32(x: kTypeNumber | kRepTagged) used as kMachUint32
1091   TestingGraph t(Type::Number());
1092   Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), t.p0);
1093   Node* use = t.Use(trunc, kMachUint32);
1094   t.Return(use);
1095   t.Lower();
1096   Node* node = use->InputAt(0);
1097   CHECK_EQ(IrOpcode::kTruncateFloat64ToInt32, node->opcode());
1098   Node* of = node->InputAt(0);
1099   CHECK_EQ(IrOpcode::kChangeTaggedToFloat64, of->opcode());
1100   CHECK_EQ(t.p0, of->InputAt(0));
1101 }
1102
1103
1104 TEST(LowerNumberToUint32_to_ChangeFloat64ToTagged) {
1105   // TODO(titzer): NumberToUint32(x: kRepFloat64 | kTypeUint32) used as
1106   // kRepTagged
1107 }
1108
1109
1110 TEST(LowerNumberToUint32_to_ChangeFloat64ToUint32) {
1111   // TODO(titzer): NumberToUint32(x: kRepFloat64 | kTypeUint32) used as
1112   // kRepWord32
1113 }
1114
1115
1116 TEST(LowerNumberToUint32_to_TruncateFloat64ToUint32) {
1117   // TODO(titzer): NumberToUint32(x: kRepFloat64) used as kRepWord32
1118 }
1119
1120
1121 TEST(LowerReferenceEqual_to_wordeq) {
1122   TestingGraph t(Type::Any(), Type::Any());
1123   IrOpcode::Value opcode =
1124       static_cast<IrOpcode::Value>(t.machine()->WordEqual()->opcode());
1125   t.CheckLoweringBinop(opcode, t.simplified()->ReferenceEqual(Type::Any()));
1126 }
1127
1128
1129 TEST(LowerStringOps_to_call_and_compare) {
1130   if (Pipeline::SupportedTarget()) {
1131     // These tests need linkage for the calls.
1132     TestingGraph t(Type::String(), Type::String());
1133     IrOpcode::Value compare_eq =
1134         static_cast<IrOpcode::Value>(t.machine()->WordEqual()->opcode());
1135     IrOpcode::Value compare_lt =
1136         static_cast<IrOpcode::Value>(t.machine()->IntLessThan()->opcode());
1137     IrOpcode::Value compare_le = static_cast<IrOpcode::Value>(
1138         t.machine()->IntLessThanOrEqual()->opcode());
1139     t.CheckLoweringBinop(compare_eq, t.simplified()->StringEqual());
1140     t.CheckLoweringBinop(compare_lt, t.simplified()->StringLessThan());
1141     t.CheckLoweringBinop(compare_le, t.simplified()->StringLessThanOrEqual());
1142     t.CheckLoweringBinop(IrOpcode::kCall, t.simplified()->StringAdd());
1143   }
1144 }
1145
1146
1147 void CheckChangeInsertion(IrOpcode::Value expected, MachineType from,
1148                           MachineType to) {
1149   TestingGraph t(Type::Any());
1150   Node* in = t.ExampleWithOutput(from);
1151   Node* use = t.Use(in, to);
1152   t.Return(use);
1153   t.Lower();
1154   CHECK_EQ(expected, use->InputAt(0)->opcode());
1155   CHECK_EQ(in, use->InputAt(0)->InputAt(0));
1156 }
1157
1158
1159 TEST(InsertBasicChanges) {
1160   CheckChangeInsertion(IrOpcode::kChangeFloat64ToInt32, kRepFloat64,
1161                        kTypeInt32);
1162   CheckChangeInsertion(IrOpcode::kChangeFloat64ToUint32, kRepFloat64,
1163                        kTypeUint32);
1164   CheckChangeInsertion(IrOpcode::kChangeTaggedToInt32, kRepTagged, kTypeInt32);
1165   CheckChangeInsertion(IrOpcode::kChangeTaggedToUint32, kRepTagged,
1166                        kTypeUint32);
1167
1168   CheckChangeInsertion(IrOpcode::kChangeFloat64ToTagged, kRepFloat64,
1169                        kRepTagged);
1170   CheckChangeInsertion(IrOpcode::kChangeTaggedToFloat64, kRepTagged,
1171                        kRepFloat64);
1172
1173   CheckChangeInsertion(IrOpcode::kChangeInt32ToFloat64, kTypeInt32,
1174                        kRepFloat64);
1175   CheckChangeInsertion(IrOpcode::kChangeInt32ToTagged, kTypeInt32, kRepTagged);
1176
1177   CheckChangeInsertion(IrOpcode::kChangeUint32ToFloat64, kTypeUint32,
1178                        kRepFloat64);
1179   CheckChangeInsertion(IrOpcode::kChangeUint32ToTagged, kTypeUint32,
1180                        kRepTagged);
1181 }
1182
1183
1184 static void CheckChangesAroundBinop(TestingGraph* t, const Operator* op,
1185                                     IrOpcode::Value input_change,
1186                                     IrOpcode::Value output_change) {
1187   Node* binop = t->graph()->NewNode(op, t->p0, t->p1);
1188   t->Return(binop);
1189   t->Lower();
1190   CHECK_EQ(input_change, binop->InputAt(0)->opcode());
1191   CHECK_EQ(input_change, binop->InputAt(1)->opcode());
1192   CHECK_EQ(t->p0, binop->InputAt(0)->InputAt(0));
1193   CHECK_EQ(t->p1, binop->InputAt(1)->InputAt(0));
1194   CHECK_EQ(output_change, t->ret->InputAt(0)->opcode());
1195   CHECK_EQ(binop, t->ret->InputAt(0)->InputAt(0));
1196 }
1197
1198
1199 TEST(InsertChangesAroundInt32Binops) {
1200   TestingGraph t(Type::Signed32(), Type::Signed32());
1201
1202   const Operator* ops[] = {t.machine()->Int32Add(),  t.machine()->Int32Sub(),
1203                            t.machine()->Int32Mul(),  t.machine()->Int32Div(),
1204                            t.machine()->Int32Mod(),  t.machine()->Word32And(),
1205                            t.machine()->Word32Or(),  t.machine()->Word32Xor(),
1206                            t.machine()->Word32Shl(), t.machine()->Word32Sar()};
1207
1208   for (size_t i = 0; i < arraysize(ops); i++) {
1209     CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToInt32,
1210                             IrOpcode::kChangeInt32ToTagged);
1211   }
1212 }
1213
1214
1215 TEST(InsertChangesAroundInt32Cmp) {
1216   TestingGraph t(Type::Signed32(), Type::Signed32());
1217
1218   const Operator* ops[] = {t.machine()->Int32LessThan(),
1219                            t.machine()->Int32LessThanOrEqual()};
1220
1221   for (size_t i = 0; i < arraysize(ops); i++) {
1222     CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToInt32,
1223                             IrOpcode::kChangeBitToBool);
1224   }
1225 }
1226
1227
1228 TEST(InsertChangesAroundUint32Cmp) {
1229   TestingGraph t(Type::Unsigned32(), Type::Unsigned32());
1230
1231   const Operator* ops[] = {t.machine()->Uint32LessThan(),
1232                            t.machine()->Uint32LessThanOrEqual()};
1233
1234   for (size_t i = 0; i < arraysize(ops); i++) {
1235     CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToUint32,
1236                             IrOpcode::kChangeBitToBool);
1237   }
1238 }
1239
1240
1241 TEST(InsertChangesAroundFloat64Binops) {
1242   TestingGraph t(Type::Number(), Type::Number());
1243
1244   const Operator* ops[] = {
1245       t.machine()->Float64Add(), t.machine()->Float64Sub(),
1246       t.machine()->Float64Mul(), t.machine()->Float64Div(),
1247       t.machine()->Float64Mod(),
1248   };
1249
1250   for (size_t i = 0; i < arraysize(ops); i++) {
1251     CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToFloat64,
1252                             IrOpcode::kChangeFloat64ToTagged);
1253   }
1254 }
1255
1256
1257 TEST(InsertChangesAroundFloat64Cmp) {
1258   TestingGraph t(Type::Number(), Type::Number());
1259
1260   const Operator* ops[] = {t.machine()->Float64Equal(),
1261                            t.machine()->Float64LessThan(),
1262                            t.machine()->Float64LessThanOrEqual()};
1263
1264   for (size_t i = 0; i < arraysize(ops); i++) {
1265     CheckChangesAroundBinop(&t, ops[i], IrOpcode::kChangeTaggedToFloat64,
1266                             IrOpcode::kChangeBitToBool);
1267   }
1268 }
1269
1270
1271 void CheckFieldAccessArithmetic(FieldAccess access, Node* load_or_store) {
1272   Int32Matcher index = Int32Matcher(load_or_store->InputAt(1));
1273   CHECK(index.Is(access.offset - access.tag()));
1274 }
1275
1276
1277 Node* CheckElementAccessArithmetic(ElementAccess access, Node* load_or_store) {
1278   Int32BinopMatcher index(load_or_store->InputAt(1));
1279   CHECK_EQ(IrOpcode::kInt32Add, index.node()->opcode());
1280   CHECK(index.right().Is(access.header_size - access.tag()));
1281
1282   int element_size = ElementSizeOf(access.machine_type);
1283
1284   if (element_size != 1) {
1285     Int32BinopMatcher mul(index.left().node());
1286     CHECK_EQ(IrOpcode::kInt32Mul, mul.node()->opcode());
1287     CHECK(mul.right().Is(element_size));
1288     return mul.left().node();
1289   } else {
1290     return index.left().node();
1291   }
1292 }
1293
1294
1295 static const MachineType machine_reps[] = {
1296     kRepBit,    kMachInt8,    kMachInt16,    kMachInt32,
1297     kMachInt64, kMachFloat64, kMachAnyTagged};
1298
1299
1300 TEST(LowerLoadField_to_load) {
1301   TestingGraph t(Type::Any(), Type::Signed32());
1302
1303   for (size_t i = 0; i < arraysize(machine_reps); i++) {
1304     FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
1305                           Handle<Name>::null(), Type::Any(), machine_reps[i]};
1306
1307     Node* load =
1308         t.graph()->NewNode(t.simplified()->LoadField(access), t.p0, t.start);
1309     Node* use = t.Use(load, machine_reps[i]);
1310     t.Return(use);
1311     t.Lower();
1312     CHECK_EQ(IrOpcode::kLoad, load->opcode());
1313     CHECK_EQ(t.p0, load->InputAt(0));
1314     CheckFieldAccessArithmetic(access, load);
1315
1316     MachineType rep = OpParameter<MachineType>(load);
1317     CHECK_EQ(machine_reps[i], rep);
1318   }
1319 }
1320
1321
1322 TEST(LowerStoreField_to_store) {
1323   TestingGraph t(Type::Any(), Type::Signed32());
1324
1325   for (size_t i = 0; i < arraysize(machine_reps); i++) {
1326     FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
1327                           Handle<Name>::null(), Type::Any(), machine_reps[i]};
1328
1329
1330     Node* val = t.ExampleWithOutput(machine_reps[i]);
1331     Node* store = t.graph()->NewNode(t.simplified()->StoreField(access), t.p0,
1332                                      val, t.start, t.start);
1333     t.Effect(store);
1334     t.Lower();
1335     CHECK_EQ(IrOpcode::kStore, store->opcode());
1336     CHECK_EQ(val, store->InputAt(2));
1337     CheckFieldAccessArithmetic(access, store);
1338
1339     StoreRepresentation rep = OpParameter<StoreRepresentation>(store);
1340     if (machine_reps[i] & kRepTagged) {
1341       CHECK_EQ(kFullWriteBarrier, rep.write_barrier_kind());
1342     }
1343     CHECK_EQ(machine_reps[i], rep.machine_type());
1344   }
1345 }
1346
1347
1348 TEST(LowerLoadElement_to_load) {
1349   TestingGraph t(Type::Any(), Type::Signed32());
1350
1351   for (size_t i = 0; i < arraysize(machine_reps); i++) {
1352     ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
1353                             Type::Any(), machine_reps[i]};
1354
1355     Node* load =
1356         t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0, t.p1,
1357                            t.jsgraph.Int32Constant(1024), t.start);
1358     Node* use = t.Use(load, machine_reps[i]);
1359     t.Return(use);
1360     t.Lower();
1361     CHECK_EQ(IrOpcode::kLoad, load->opcode());
1362     CHECK_EQ(t.p0, load->InputAt(0));
1363     CheckElementAccessArithmetic(access, load);
1364
1365     MachineType rep = OpParameter<MachineType>(load);
1366     CHECK_EQ(machine_reps[i], rep);
1367   }
1368 }
1369
1370
1371 TEST(LowerStoreElement_to_store) {
1372   TestingGraph t(Type::Any(), Type::Signed32());
1373
1374   for (size_t i = 0; i < arraysize(machine_reps); i++) {
1375     ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
1376                             Type::Any(), machine_reps[i]};
1377
1378     Node* val = t.ExampleWithOutput(machine_reps[i]);
1379     Node* store = t.graph()->NewNode(t.simplified()->StoreElement(access), t.p0,
1380                                      t.p1, t.jsgraph.Int32Constant(1024), val,
1381                                      t.start, t.start);
1382     t.Effect(store);
1383     t.Lower();
1384     CHECK_EQ(IrOpcode::kStore, store->opcode());
1385     CHECK_EQ(val, store->InputAt(2));
1386     CheckElementAccessArithmetic(access, store);
1387
1388     StoreRepresentation rep = OpParameter<StoreRepresentation>(store);
1389     if (machine_reps[i] & kRepTagged) {
1390       CHECK_EQ(kFullWriteBarrier, rep.write_barrier_kind());
1391     }
1392     CHECK_EQ(machine_reps[i], rep.machine_type());
1393   }
1394 }
1395
1396
1397 TEST(InsertChangeForLoadElementIndex) {
1398   // LoadElement(obj: Tagged, index: kTypeInt32 | kRepTagged, length) =>
1399   //   Load(obj, Int32Add(Int32Mul(ChangeTaggedToInt32(index), #k), #k))
1400   TestingGraph t(Type::Any(), Type::Signed32(), Type::Any());
1401   ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
1402                           kMachAnyTagged};
1403
1404   Node* load = t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0,
1405                                   t.p1, t.p2, t.start);
1406   t.Return(load);
1407   t.Lower();
1408   CHECK_EQ(IrOpcode::kLoad, load->opcode());
1409   CHECK_EQ(t.p0, load->InputAt(0));
1410
1411   Node* index = CheckElementAccessArithmetic(access, load);
1412   CheckChangeOf(IrOpcode::kChangeTaggedToInt32, t.p1, index);
1413 }
1414
1415
1416 TEST(InsertChangeForStoreElementIndex) {
1417   // StoreElement(obj: Tagged, index: kTypeInt32 | kRepTagged, length, val) =>
1418   //   Store(obj, Int32Add(Int32Mul(ChangeTaggedToInt32(index), #k), #k), val)
1419   TestingGraph t(Type::Any(), Type::Signed32(), Type::Any());
1420   ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
1421                           kMachAnyTagged};
1422
1423   Node* store =
1424       t.graph()->NewNode(t.simplified()->StoreElement(access), t.p0, t.p1, t.p2,
1425                          t.jsgraph.TrueConstant(), t.start, t.start);
1426   t.Effect(store);
1427   t.Lower();
1428   CHECK_EQ(IrOpcode::kStore, store->opcode());
1429   CHECK_EQ(t.p0, store->InputAt(0));
1430
1431   Node* index = CheckElementAccessArithmetic(access, store);
1432   CheckChangeOf(IrOpcode::kChangeTaggedToInt32, t.p1, index);
1433 }
1434
1435
1436 TEST(InsertChangeForLoadElement) {
1437   // TODO(titzer): test all load/store representation change insertions.
1438   TestingGraph t(Type::Any(), Type::Signed32(), Type::Any());
1439   ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
1440                           kMachFloat64};
1441
1442   Node* load = t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0,
1443                                   t.p1, t.p1, t.start);
1444   t.Return(load);
1445   t.Lower();
1446   CHECK_EQ(IrOpcode::kLoad, load->opcode());
1447   CHECK_EQ(t.p0, load->InputAt(0));
1448   CheckChangeOf(IrOpcode::kChangeFloat64ToTagged, load, t.ret->InputAt(0));
1449 }
1450
1451
1452 TEST(InsertChangeForLoadField) {
1453   // TODO(titzer): test all load/store representation change insertions.
1454   TestingGraph t(Type::Any(), Type::Signed32());
1455   FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
1456                         Handle<Name>::null(), Type::Any(), kMachFloat64};
1457
1458   Node* load =
1459       t.graph()->NewNode(t.simplified()->LoadField(access), t.p0, t.start);
1460   t.Return(load);
1461   t.Lower();
1462   CHECK_EQ(IrOpcode::kLoad, load->opcode());
1463   CHECK_EQ(t.p0, load->InputAt(0));
1464   CheckChangeOf(IrOpcode::kChangeFloat64ToTagged, load, t.ret->InputAt(0));
1465 }
1466
1467
1468 TEST(InsertChangeForStoreElement) {
1469   // TODO(titzer): test all load/store representation change insertions.
1470   TestingGraph t(Type::Any(), Type::Signed32(), Type::Any());
1471   ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
1472                           kMachFloat64};
1473
1474   Node* store = t.graph()->NewNode(t.simplified()->StoreElement(access), t.p0,
1475                                    t.jsgraph.Int32Constant(0), t.p2, t.p1,
1476                                    t.start, t.start);
1477   t.Effect(store);
1478   t.Lower();
1479
1480   CHECK_EQ(IrOpcode::kStore, store->opcode());
1481   CHECK_EQ(t.p0, store->InputAt(0));
1482   CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p1, store->InputAt(2));
1483 }
1484
1485
1486 TEST(InsertChangeForStoreField) {
1487   // TODO(titzer): test all load/store representation change insertions.
1488   TestingGraph t(Type::Any(), Type::Signed32());
1489   FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
1490                         Handle<Name>::null(), Type::Any(), kMachFloat64};
1491
1492   Node* store = t.graph()->NewNode(t.simplified()->StoreField(access), t.p0,
1493                                    t.p1, t.start, t.start);
1494   t.Effect(store);
1495   t.Lower();
1496
1497   CHECK_EQ(IrOpcode::kStore, store->opcode());
1498   CHECK_EQ(t.p0, store->InputAt(0));
1499   CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p1, store->InputAt(2));
1500 }
1501
1502
1503 TEST(UpdatePhi) {
1504   TestingGraph t(Type::Any(), Type::Signed32());
1505   static const MachineType kMachineTypes[] = {kMachInt32, kMachUint32,
1506                                               kMachFloat64};
1507
1508   for (size_t i = 0; i < arraysize(kMachineTypes); i++) {
1509     FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
1510                           Handle<Name>::null(), Type::Any(), kMachineTypes[i]};
1511
1512     Node* load0 =
1513         t.graph()->NewNode(t.simplified()->LoadField(access), t.p0, t.start);
1514     Node* load1 =
1515         t.graph()->NewNode(t.simplified()->LoadField(access), t.p1, t.start);
1516     Node* phi = t.graph()->NewNode(t.common()->Phi(kMachAnyTagged, 2), load0,
1517                                    load1, t.start);
1518     t.Return(t.Use(phi, kMachineTypes[i]));
1519     t.Lower();
1520
1521     CHECK_EQ(IrOpcode::kPhi, phi->opcode());
1522     CHECK_EQ(RepresentationOf(kMachineTypes[i]),
1523              RepresentationOf(OpParameter<MachineType>(phi)));
1524   }
1525 }
1526
1527
1528 // TODO(titzer): this tests current behavior of assuming an implicit
1529 // representation change in loading float32s. Fix when float32 is fully
1530 // supported.
1531 TEST(ImplicitFloat32ToFloat64InLoads) {
1532   TestingGraph t(Type::Any());
1533
1534   FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
1535                         Handle<Name>::null(), Type::Any(), kMachFloat32};
1536
1537   Node* load =
1538       t.graph()->NewNode(t.simplified()->LoadField(access), t.p0, t.start);
1539   t.Return(load);
1540   t.Lower();
1541   CHECK_EQ(IrOpcode::kLoad, load->opcode());
1542   CHECK_EQ(t.p0, load->InputAt(0));
1543   CheckChangeOf(IrOpcode::kChangeFloat64ToTagged, load, t.ret->InputAt(0));
1544 }
1545
1546
1547 TEST(ImplicitFloat64ToFloat32InStores) {
1548   TestingGraph t(Type::Any(), Type::Signed32());
1549   FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
1550                         Handle<Name>::null(), Type::Any(), kMachFloat32};
1551
1552   Node* store = t.graph()->NewNode(t.simplified()->StoreField(access), t.p0,
1553                                    t.p1, t.start, t.start);
1554   t.Effect(store);
1555   t.Lower();
1556
1557   CHECK_EQ(IrOpcode::kStore, store->opcode());
1558   CHECK_EQ(t.p0, store->InputAt(0));
1559   CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p1, store->InputAt(2));
1560 }