[turbofan] Make MachineType a pair of enums.

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/ast/scopes.h"
 #include "src/compiler/change-lowering.h"
 #include "src/compiler/control-builders.h"
 #include "src/compiler/js-graph.h"
@@ skipping 13 matching lines @@
 #include "test/cctest/compiler/graph-builder-tester.h"
 #include "test/cctest/compiler/value-helper.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 template <typename ReturnType>
 class ChangesLoweringTester : public GraphBuilderTester<ReturnType> {
  public:
-  explicit ChangesLoweringTester(MachineType p0 = kMachNone)
+  explicit ChangesLoweringTester(MachineType p0 = MachineType::None())
       : GraphBuilderTester<ReturnType>(p0),
         javascript(this->zone()),
         jsgraph(this->isolate(), this->graph(), this->common(), &javascript,
                 nullptr, this->machine()),
         function(Handle<JSFunction>::null()) {}
 
   JSOperatorBuilder javascript;
   JSGraph jsgraph;
   Handle<JSFunction> function;
 
   Node* start() { return this->graph()->start(); }
 
   template <typename T>
   T* CallWithPotentialGC() {
     // TODO(titzer): we wrap the code in a JSFunction here to reuse the
     // JSEntryStub; that could be done with a special prologue or other stub.
     if (function.is_null()) {
       function = FunctionTester::ForMachineGraph(this->graph());
     }
     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(kMachFloat64, ptr_node, node);
+    this->Store(MachineType::Float64(), ptr_node, node);
   }
 
   Node* LoadInt32(int32_t* ptr) {
     Node* ptr_node = this->PointerConstant(ptr);
-    return this->Load(kMachInt32, ptr_node);
+    return this->Load(MachineType::Int32(), ptr_node);
   }
 
   Node* LoadUint32(uint32_t* ptr) {
     Node* ptr_node = this->PointerConstant(ptr);
-    return this->Load(kMachUint32, ptr_node);
+    return this->Load(MachineType::Uint32(), ptr_node);
   }
 
   Node* LoadFloat64(double* ptr) {
     Node* ptr_node = this->PointerConstant(ptr);
-    return this->Load(kMachFloat64, ptr_node);
+    return this->Load(MachineType::Float64(), ptr_node);
   }
 
   void CheckNumber(double expected, Object* number) {
     CHECK(this->isolate()->factory()->NewNumber(expected)->SameValue(number));
   }
 
   void BuildAndLower(const 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 49 matching lines @@
     Verifier::Run(this->graph(), Verifier::UNTYPED);
   }
 
   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(kMachAnyTagged);
+  ChangesLoweringTester<int32_t> t(MachineType::AnyTagged());
   t.BuildAndLower(t.simplified()->ChangeTaggedToInt32());
 
     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(kMachAnyTagged);
+  ChangesLoweringTester<uint32_t> t(MachineType::AnyTagged());
   t.BuildAndLower(t.simplified()->ChangeTaggedToUint32());
 
     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(kMachAnyTagged);
+  ChangesLoweringTester<int32_t> t(MachineType::AnyTagged());
   double result;
 
-  t.BuildStoreAndLower(
-      t.simplified()->ChangeTaggedToFloat64(),
-      t.machine()->Store(StoreRepresentation(kMachFloat64, kNoWriteBarrier)),
-      &result);
+  t.BuildStoreAndLower(t.simplified()->ChangeTaggedToFloat64(),
+                       t.machine()->Store(StoreRepresentation(
+                           MachineType::Float64(), kNoWriteBarrier)),
+                       &result);
 
   {
     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 24 matching lines @@
         Handle<HeapNumber> number = t.factory()->NewHeapNumber(input);
         t.Call(*number);
         CheckDoubleEq(input, result);
       }
     }
   }
 }
 
 
 TEST(RunChangeBoolToBit) {
-  ChangesLoweringTester<int32_t> t(kMachAnyTagged);
+  ChangesLoweringTester<int32_t> t(MachineType::AnyTagged());
   t.BuildAndLower(t.simplified()->ChangeBoolToBit());
 
   {
     Object* true_obj = t.heap()->true_value();
     int32_t result = t.Call(true_obj);
     CHECK_EQ(1, result);
   }
 
   {
     Object* false_obj = t.heap()->false_value();
     int32_t result = t.Call(false_obj);
     CHECK_EQ(0, result);
   }
 }
 
 
 TEST(RunChangeBitToBool) {
-  ChangesLoweringTester<Object*> t(kMachInt32);
+  ChangesLoweringTester<Object*> t(MachineType::Int32());
   t.BuildAndLower(t.simplified()->ChangeBitToBool());
 
   {
     Object* result = t.Call(1);
     Object* true_obj = t.heap()->true_value();
     CHECK_EQ(true_obj, result);
   }
 
   {
     Object* result = t.Call(0);
     Object* false_obj = t.heap()->false_value();
     CHECK_EQ(false_obj, result);
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8