[turbofan] Make MachineType a pair of enums.

test/cctest/compiler/test-machine-operator-reducer.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 "src/base/utils/random-number-generator.h"
 #include "src/codegen.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/machine-operator-reducer.h"
 #include "src/compiler/operator-properties.h"
 #include "src/compiler/typer.h"
@@ skipping 38 matching lines @@
 
 
 class ReducerTester : public HandleAndZoneScope {
  public:
   explicit ReducerTester(
       int num_parameters = 0,
       MachineOperatorBuilder::Flags flags = MachineOperatorBuilder::kNoFlags)
       : isolate(main_isolate()),
         binop(NULL),
         unop(NULL),
-        machine(main_zone(), kMachPtr, flags),
+        machine(main_zone(), MachineType::PointerRepresentation(), flags),
         common(main_zone()),
         graph(main_zone()),
         javascript(main_zone()),
         typer(isolate, &graph),
         jsgraph(isolate, &graph, &common, &javascript, nullptr, &machine),
         maxuint32(Constant<int32_t>(kMaxUInt32)) {
     Node* s = graph.NewNode(common.Start(num_parameters));
     graph.SetStart(s);
   }
 
@@ skipping 626 matching lines @@
   R.CheckFoldBinop<int32_t>(1, zero, x);  // 0 <= x  => 1
   R.CheckFoldBinop<int32_t>(1, x, x);     // x <= x  => 1
 }
 
 
 TEST(ReduceLoadStore) {
   ReducerTester R;
 
   Node* base = R.Constant<int32_t>(11);
   Node* index = R.Constant<int32_t>(4);
-  Node* load = R.graph.NewNode(R.machine.Load(kMachInt32), base, index,
-                               R.graph.start(), R.graph.start());
+  Node* load = R.graph.NewNode(R.machine.Load(MachineType::Int32()), base,
+                               index, R.graph.start(), R.graph.start());
 
   {
     MachineOperatorReducer reducer(&R.jsgraph);
     Reduction reduction = reducer.Reduce(load);
     CHECK(!reduction.Changed());  // loads should not be reduced.
   }
 
   {
-    Node* store = R.graph.NewNode(
-        R.machine.Store(StoreRepresentation(kMachInt32, kNoWriteBarrier)), base,
-        index, load, load, R.graph.start());
+    Node* store = R.graph.NewNode(R.machine.Store(StoreRepresentation(
+                                      MachineType::Int32(), kNoWriteBarrier)),
+                                  base, index, load, load, R.graph.start());
     MachineOperatorReducer reducer(&R.jsgraph);
     Reduction reduction = reducer.Reduce(store);
     CHECK(!reduction.Changed());  // stores should not be reduced.
   }
 }
 
 
 // TODO(titzer): test MachineOperatorReducer for Word64And
 // TODO(titzer): test MachineOperatorReducer for Word64Or
 // TODO(titzer): test MachineOperatorReducer for Word64Xor
@@ skipping 16 matching lines @@
 // TODO(titzer): test MachineOperatorReducer for Float64Compare
 // TODO(titzer): test MachineOperatorReducer for Float64Add
 // TODO(titzer): test MachineOperatorReducer for Float64Sub
 // TODO(titzer): test MachineOperatorReducer for Float64Mul
 // TODO(titzer): test MachineOperatorReducer for Float64Div
 // TODO(titzer): test MachineOperatorReducer for Float64Mod
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8