[turbofan] Make MachineType a pair of enums.

test/cctest/compiler/codegen-tester.cc

Index: test/cctest/compiler/codegen-tester.cc
diff --git a/test/cctest/compiler/codegen-tester.cc b/test/cctest/compiler/codegen-tester.cc
index ba73822d32a455de16162a1af7db404ad28dccd5..8e1ec0bfbb492683f032e2a0f9e14ee7f14aca54 100644
--- a/test/cctest/compiler/codegen-tester.cc
+++ b/test/cctest/compiler/codegen-tester.cc
@@ -291,7 +291,8 @@ void Int32BinopInputShapeTester::TestAllInputShapes() {
   for (int i = -2; i < num_int_inputs; i++) {    // for all left shapes
     for (int j = -2; j < num_int_inputs; j++) {  // for all right shapes
       if (i >= 0 && j >= 0) break;               // No constant/constant combos
-      RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
+      RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
+                                           MachineType::Int32());
       Node* p0 = m.Parameter(0);
       Node* p1 = m.Parameter(1);
       Node* n0;
@@ -301,7 +302,7 @@ void Int32BinopInputShapeTester::TestAllInputShapes() {
       if (i == -2) {
         n0 = p0;
       } else if (i == -1) {
-        n0 = m.LoadFromPointer(&input_a, kMachInt32);
+        n0 = m.LoadFromPointer(&input_a, MachineType::Int32());
       } else {
         n0 = m.Int32Constant(inputs[i]);
       }
@@ -310,7 +311,7 @@ void Int32BinopInputShapeTester::TestAllInputShapes() {
       if (j == -2) {
         n1 = p1;
       } else if (j == -1) {
-        n1 = m.LoadFromPointer(&input_b, kMachInt32);
+        n1 = m.LoadFromPointer(&input_b, MachineType::Int32());
       } else {
         n1 = m.Int32Constant(inputs[j]);
       }
@@ -368,7 +369,8 @@ void Int32BinopInputShapeTester::RunRight(
 
 
 TEST(ParametersEqual) {
-  RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
+  RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
+                                       MachineType::Int32());
   Node* p1 = m.Parameter(1);
   CHECK(p1);
   Node* p0 = m.Parameter(0);
@@ -482,7 +484,7 @@ TEST(RunHeapNumberConstant) {
 
 
 TEST(RunParam1) {
-  RawMachineAssemblerTester<int32_t> m(kMachInt32);
+  RawMachineAssemblerTester<int32_t> m(MachineType::Int32());
   m.Return(m.Parameter(0));
 
   FOR_INT32_INPUTS(i) {
@@ -493,7 +495,8 @@ TEST(RunParam1) {
 
 
 TEST(RunParam2_1) {
-  RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
+  RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
+                                       MachineType::Int32());
   Node* p0 = m.Parameter(0);
   Node* p1 = m.Parameter(1);
   m.Return(p0);
@@ -507,7 +510,8 @@ TEST(RunParam2_1) {
 
 
 TEST(RunParam2_2) {
-  RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32);
+  RawMachineAssemblerTester<int32_t> m(MachineType::Int32(),
+                                       MachineType::Int32());
   Node* p0 = m.Parameter(0);
   Node* p1 = m.Parameter(1);
   m.Return(p1);
@@ -522,7 +526,8 @@ TEST(RunParam2_2) {
 
 TEST(RunParam3) {
   for (int i = 0; i < 3; i++) {
-    RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
+    RawMachineAssemblerTester<int32_t> m(
+        MachineType::Int32(), MachineType::Int32(), MachineType::Int32());
     Node* nodes[] = {m.Parameter(0), m.Parameter(1), m.Parameter(2)};
     m.Return(nodes[i]);
 
@@ -580,12 +585,13 @@ TEST(RunBufferedRawMachineAssemblerTesterTester) {
     CHECK_EQ(0x12500000000, m.Call());
   }
   {
-    BufferedRawMachineAssemblerTester<double> m(kMachFloat64);
+    BufferedRawMachineAssemblerTester<double> m(MachineType::Float64());
     m.Return(m.Parameter(0));
     FOR_FLOAT64_INPUTS(i) { CheckDoubleEq(*i, m.Call(*i)); }
   }
   {
-    BufferedRawMachineAssemblerTester<int64_t> m(kMachInt64, kMachInt64);
+    BufferedRawMachineAssemblerTester<int64_t> m(MachineType::Int64(),
+                                                 MachineType::Int64());
     m.Return(m.Int64Add(m.Parameter(0), m.Parameter(1)));
     FOR_INT64_INPUTS(i) {
       FOR_INT64_INPUTS(j) {
@@ -595,8 +601,8 @@ TEST(RunBufferedRawMachineAssemblerTesterTester) {
     }
   }
   {
-    BufferedRawMachineAssemblerTester<int64_t> m(kMachInt64, kMachInt64,
-                                                 kMachInt64);
+    BufferedRawMachineAssemblerTester<int64_t> m(
+        MachineType::Int64(), MachineType::Int64(), MachineType::Int64());
     m.Return(
         m.Int64Add(m.Int64Add(m.Parameter(0), m.Parameter(1)), m.Parameter(2)));
     FOR_INT64_INPUTS(i) {
@@ -608,8 +614,9 @@ TEST(RunBufferedRawMachineAssemblerTesterTester) {
     }
   }
   {
-    BufferedRawMachineAssemblerTester<int64_t> m(kMachInt64, kMachInt64,
-                                                 kMachInt64, kMachInt64);
+    BufferedRawMachineAssemblerTester<int64_t> m(
+        MachineType::Int64(), MachineType::Int64(), MachineType::Int64(),
+        MachineType::Int64());
     m.Return(m.Int64Add(
         m.Int64Add(m.Int64Add(m.Parameter(0), m.Parameter(1)), m.Parameter(2)),
         m.Parameter(3)));
@@ -632,7 +639,7 @@ TEST(RunBufferedRawMachineAssemblerTesterTester) {
     CHECK_EQ(0x12500000000, result);
   }
   {
-    BufferedRawMachineAssemblerTester<void> m(kMachFloat64);
+    BufferedRawMachineAssemblerTester<void> m(MachineType::Float64());
     double result;
     m.Store(MachineTypeForC<double>(), m.PointerConstant(&result),
             m.Parameter(0), kNoWriteBarrier);
@@ -643,7 +650,8 @@ TEST(RunBufferedRawMachineAssemblerTesterTester) {
     }
   }
   {
-    BufferedRawMachineAssemblerTester<void> m(kMachInt64, kMachInt64);
+    BufferedRawMachineAssemblerTester<void> m(MachineType::Int64(),
+                                              MachineType::Int64());
     int64_t result;
     m.Store(MachineTypeForC<int64_t>(), m.PointerConstant(&result),
             m.Int64Add(m.Parameter(0), m.Parameter(1)), kNoWriteBarrier);
@@ -659,8 +667,8 @@ TEST(RunBufferedRawMachineAssemblerTesterTester) {
     }
   }
   {
-    BufferedRawMachineAssemblerTester<void> m(kMachInt64, kMachInt64,
-                                              kMachInt64);
+    BufferedRawMachineAssemblerTester<void> m(
+        MachineType::Int64(), MachineType::Int64(), MachineType::Int64());
     int64_t result;
     m.Store(
         MachineTypeForC<int64_t>(), m.PointerConstant(&result),
@@ -681,8 +689,9 @@ TEST(RunBufferedRawMachineAssemblerTesterTester) {
     }
   }
   {
-    BufferedRawMachineAssemblerTester<void> m(kMachInt64, kMachInt64,
-                                              kMachInt64, kMachInt64);
+    BufferedRawMachineAssemblerTester<void> m(
+        MachineType::Int64(), MachineType::Int64(), MachineType::Int64(),
+        MachineType::Int64());
     int64_t result;
     m.Store(MachineTypeForC<int64_t>(), m.PointerConstant(&result),
             m.Int64Add(m.Int64Add(m.Int64Add(m.Parameter(0), m.Parameter(1)),