Unify MachineType and RepType.

test/cctest/compiler/test-changes-lowering.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <limits>
 
 #include "src/compiler/control-builders.h"
 #include "src/compiler/generic-node-inl.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/pipeline.h"
 #include "src/compiler/simplified-lowering.h"
 #include "src/compiler/simplified-node-factory.h"
 #include "src/compiler/typer.h"
 #include "src/compiler/verifier.h"
 #include "src/execution.h"
 #include "src/parser.h"
 #include "src/rewriter.h"
 #include "src/scopes.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/codegen-tester.h"
 #include "test/cctest/compiler/graph-builder-tester.h"
 #include "test/cctest/compiler/value-helper.h"
 
 using namespace v8::internal;
 using namespace v8::internal::compiler;
 
 template <typename ReturnType>
 class ChangesLoweringTester : public GraphBuilderTester<ReturnType> {
  public:
-  explicit ChangesLoweringTester(MachineType p0 = kMachineLast)
+  explicit ChangesLoweringTester(MachineType p0 = kMachNone)
       : GraphBuilderTester<ReturnType>(p0),
         typer(this->zone()),
         source_positions(this->graph()),
         jsgraph(this->graph(), this->common(), &typer),
         lowering(&jsgraph, &source_positions),
         function(Handle<JSFunction>::null()) {}
 
   Typer typer;
   SourcePositionTable source_positions;
   JSGraph jsgraph;
@@ skipping 29 matching lines @@
     }
     Handle<Object>* args = NULL;
     MaybeHandle<Object> result =
         Execution::Call(this->isolate(), function, factory()->undefined_value(),
                         0, args, false);
     return T::cast(*result.ToHandleChecked());
   }
 
   void StoreFloat64(Node* node, double* ptr) {
     Node* ptr_node = this->PointerConstant(ptr);
-    this->Store(kMachineFloat64, ptr_node, node);
+    this->Store(kMachFloat64, ptr_node, node);
   }
 
   Node* LoadInt32(int32_t* ptr) {
     Node* ptr_node = this->PointerConstant(ptr);
-    return this->Load(kMachineWord32, ptr_node);
+    return this->Load(kMachInt32, ptr_node);
   }
 
   Node* LoadUint32(uint32_t* ptr) {
     Node* ptr_node = this->PointerConstant(ptr);
-    return this->Load(kMachineWord32, ptr_node);
+    return this->Load(kMachUint32, ptr_node);
   }
 
   Node* LoadFloat64(double* ptr) {
     Node* ptr_node = this->PointerConstant(ptr);
-    return this->Load(kMachineFloat64, ptr_node);
+    return this->Load(kMachFloat64, ptr_node);
   }
 
   void CheckNumber(double expected, Object* number) {
     CHECK(this->isolate()->factory()->NewNumber(expected)->SameValue(number));
   }
 
   void BuildAndLower(Operator* op) {
     // We build a graph by hand here, because the raw machine assembler
     // does not add the correct control and effect nodes.
     Node* p0 = this->Parameter(0);
@@ skipping 37 matching lines @@
     Verifier::Run(this->graph());
   }
 
   Factory* factory() { return this->isolate()->factory(); }
   Heap* heap() { return this->isolate()->heap(); }
 };
 
 
 TEST(RunChangeTaggedToInt32) {
   // Build and lower a graph by hand.
-  ChangesLoweringTester<int32_t> t(kMachineTagged);
+  ChangesLoweringTester<int32_t> t(kMachAnyTagged);
   t.BuildAndLower(t.simplified()->ChangeTaggedToInt32());
 
   if (Pipeline::SupportedTarget()) {
     FOR_INT32_INPUTS(i) {
       int32_t input = *i;
 
       if (Smi::IsValid(input)) {
         int32_t result = t.Call(Smi::FromInt(input));
         CHECK_EQ(input, result);
       }
 
       {
         Handle<Object> number = t.factory()->NewNumber(input);
         int32_t result = t.Call(*number);
         CHECK_EQ(input, result);
       }
 
       {
         Handle<HeapNumber> number = t.factory()->NewHeapNumber(input);
         int32_t result = t.Call(*number);
         CHECK_EQ(input, result);
       }
     }
   }
 }
 
 
 TEST(RunChangeTaggedToUint32) {
   // Build and lower a graph by hand.
-  ChangesLoweringTester<uint32_t> t(kMachineTagged);
+  ChangesLoweringTester<uint32_t> t(kMachAnyTagged);
   t.BuildAndLower(t.simplified()->ChangeTaggedToUint32());
 
   if (Pipeline::SupportedTarget()) {
     FOR_UINT32_INPUTS(i) {
       uint32_t input = *i;
 
       if (Smi::IsValid(input)) {
         uint32_t result = t.Call(Smi::FromInt(input));
         CHECK_EQ(static_cast<int32_t>(input), static_cast<int32_t>(result));
       }
 
       {
         Handle<Object> number = t.factory()->NewNumber(input);
         uint32_t result = t.Call(*number);
         CHECK_EQ(static_cast<int32_t>(input), static_cast<int32_t>(result));
       }
 
       {
         Handle<HeapNumber> number = t.factory()->NewHeapNumber(input);
         uint32_t result = t.Call(*number);
         CHECK_EQ(static_cast<int32_t>(input), static_cast<int32_t>(result));
       }
     }
   }
 }
 
 
 TEST(RunChangeTaggedToFloat64) {
-  ChangesLoweringTester<int32_t> t(kMachineTagged);
+  ChangesLoweringTester<int32_t> t(kMachAnyTagged);
   double result;
 
   t.BuildStoreAndLower(t.simplified()->ChangeTaggedToFloat64(),
-                       t.machine()->Store(kMachineFloat64, kNoWriteBarrier),
+                       t.machine()->Store(kMachFloat64, kNoWriteBarrier),
                        &result);
 
   if (Pipeline::SupportedTarget()) {
     FOR_INT32_INPUTS(i) {
       int32_t input = *i;
 
       if (Smi::IsValid(input)) {
         t.Call(Smi::FromInt(input));
         CHECK_EQ(input, static_cast<int32_t>(result));
       }
@@ skipping 25 matching lines @@
         Handle<HeapNumber> number = t.factory()->NewHeapNumber(input);
         t.Call(*number);
         CHECK_EQ(input, result);
       }
     }
   }
 }
 
 
 TEST(RunChangeBoolToBit) {
-  ChangesLoweringTester<int32_t> t(kMachineTagged);
+  ChangesLoweringTester<int32_t> t(kMachAnyTagged);
   t.BuildAndLower(t.simplified()->ChangeBoolToBit());
 
   if (Pipeline::SupportedTarget()) {
     Object* true_obj = t.heap()->true_value();
     int32_t result = t.Call(true_obj);
     CHECK_EQ(1, result);
   }
 
   if (Pipeline::SupportedTarget()) {
     Object* false_obj = t.heap()->false_value();
     int32_t result = t.Call(false_obj);
     CHECK_EQ(0, result);
   }
 }
 
 
 TEST(RunChangeBitToBool) {
-  ChangesLoweringTester<Object*> t(kMachineWord32);
+  ChangesLoweringTester<Object*> t(kMachInt32);
   t.BuildAndLower(t.simplified()->ChangeBitToBool());
 
   if (Pipeline::SupportedTarget()) {
     Object* result = t.Call(1);
     Object* true_obj = t.heap()->true_value();
     CHECK_EQ(true_obj, result);
   }
 
   if (Pipeline::SupportedTarget()) {
     Object* result = t.Call(0);
@@ skipping 14 matching lines @@
   // TODO(titzer): enable all UI32 -> Tagged checking when inline allocation
   // works.
   return v <= static_cast<uint32_t>(Smi::kMaxValue);
 }
 
 
 TEST(RunChangeInt32ToTagged) {
   ChangesLoweringTester<Object*> t;
   int32_t input;
   t.BuildLoadAndLower(t.simplified()->ChangeInt32ToTagged(),
-                      t.machine()->Load(kMachineWord32), &input);
+                      t.machine()->Load(kMachInt32), &input);
 
   if (Pipeline::SupportedTarget()) {
     FOR_INT32_INPUTS(i) {
       input = *i;
       Object* result = t.CallWithPotentialGC<Object>();
       if (TODO_INT32_TO_TAGGED_WILL_WORK(input)) {
         t.CheckNumber(static_cast<double>(input), result);
       }
     }
   }
 
   if (Pipeline::SupportedTarget()) {
     FOR_INT32_INPUTS(i) {
       input = *i;
       SimulateFullSpace(CcTest::heap()->new_space());
       Object* result = t.CallWithPotentialGC<Object>();
       if (TODO_INT32_TO_TAGGED_WILL_WORK(input)) {
         t.CheckNumber(static_cast<double>(input), result);
       }
     }
   }
 }
 
 
 TEST(RunChangeUint32ToTagged) {
   ChangesLoweringTester<Object*> t;
   uint32_t input;
   t.BuildLoadAndLower(t.simplified()->ChangeUint32ToTagged(),
-                      t.machine()->Load(kMachineWord32), &input);
+                      t.machine()->Load(kMachUint32), &input);
 
   if (Pipeline::SupportedTarget()) {
     FOR_UINT32_INPUTS(i) {
       input = *i;
       Object* result = t.CallWithPotentialGC<Object>();
       double expected = static_cast<double>(input);
       if (TODO_UINT32_TO_TAGGED_WILL_WORK(input)) {
         t.CheckNumber(expected, result);
       }
     }
@@ skipping 13 matching lines @@
 }
 
 
 // TODO(titzer): lowering of Float64->Tagged needs inline allocation.
 #define TODO_FLOAT64_TO_TAGGED false
 
 TEST(RunChangeFloat64ToTagged) {
   ChangesLoweringTester<Object*> t;
   double input;
   t.BuildLoadAndLower(t.simplified()->ChangeFloat64ToTagged(),
-                      t.machine()->Load(kMachineFloat64), &input);
+                      t.machine()->Load(kMachFloat64), &input);
 
   // TODO(titzer): need inline allocation to change float to tagged.
   if (TODO_FLOAT64_TO_TAGGED && Pipeline::SupportedTarget()) {
     FOR_FLOAT64_INPUTS(i) {
       input = *i;
       Object* result = t.CallWithPotentialGC<Object>();
       t.CheckNumber(input, result);
     }
   }
 
   if (TODO_FLOAT64_TO_TAGGED && Pipeline::SupportedTarget()) {
     FOR_FLOAT64_INPUTS(i) {
       input = *i;
       SimulateFullSpace(CcTest::heap()->new_space());
       Object* result = t.CallWithPotentialGC<Object>();
       t.CheckNumber(input, result);
     }
   }
 }