[turbofan] Make MachineType a pair of enums.

test/unittests/compiler/branch-elimination-unittest.cc

 // Copyright 2015 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/compiler/branch-elimination.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/node-properties.h"
 #include "test/unittests/compiler/compiler-test-utils.h"
 #include "test/unittests/compiler/graph-unittest.h"
 #include "test/unittests/compiler/node-test-utils.h"
 #include "testing/gmock-support.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 class BranchEliminationTest : public TypedGraphTest {
  public:
   BranchEliminationTest()
-      : machine_(zone(), kMachPtr, MachineOperatorBuilder::kNoFlags) {}
+      : machine_(zone(), MachineType::PointerRepresentation(),
+                 MachineOperatorBuilder::kNoFlags) {}
 
   MachineOperatorBuilder* machine() { return &machine_; }
 
   void Reduce() {
     JSOperatorBuilder javascript(zone());
     JSGraph jsgraph(isolate(), graph(), common(), &javascript, nullptr,
                     machine());
     GraphReducer graph_reducer(zone(), graph(), jsgraph.Dead());
     BranchElimination branch_condition_elimination(&graph_reducer, &jsgraph,
                                                    zone());
@@ skipping 15 matching lines @@
       graph()->NewNode(common()->Branch(), condition, graph()->start());
 
   Node* outer_if_true = graph()->NewNode(common()->IfTrue(), outer_branch);
   Node* inner_branch =
       graph()->NewNode(common()->Branch(), condition, outer_if_true);
   Node* inner_if_true = graph()->NewNode(common()->IfTrue(), inner_branch);
   Node* inner_if_false = graph()->NewNode(common()->IfFalse(), inner_branch);
   Node* inner_merge =
       graph()->NewNode(common()->Merge(2), inner_if_true, inner_if_false);
   Node* inner_phi =
-      graph()->NewNode(common()->Phi(kMachInt32, 2), Int32Constant(1),
-                       Int32Constant(2), inner_merge);
+      graph()->NewNode(common()->Phi(MachineRepresentation::kWord32, 2),
+                       Int32Constant(1), Int32Constant(2), inner_merge);
 
   Node* outer_if_false = graph()->NewNode(common()->IfFalse(), outer_branch);
   Node* outer_merge =
       graph()->NewNode(common()->Merge(2), inner_merge, outer_if_false);
-  Node* outer_phi = graph()->NewNode(common()->Phi(kMachInt32, 2), inner_phi,
-                                     Int32Constant(3), outer_merge);
+  Node* outer_phi =
+      graph()->NewNode(common()->Phi(MachineRepresentation::kWord32, 2),
+                       inner_phi, Int32Constant(3), outer_merge);
 
   Node* ret = graph()->NewNode(common()->Return(), outer_phi, graph()->start(),
                                outer_merge);
   graph()->SetEnd(graph()->NewNode(common()->End(1), ret));
 
   Reduce();
 
   // Outer branch should not be rewritten, the inner branch should be discarded.
   EXPECT_THAT(outer_branch, IsBranch(condition, graph()->start()));
   EXPECT_THAT(inner_phi,
-              IsPhi(kMachInt32, IsInt32Constant(1), IsInt32Constant(2),
-                    IsMerge(outer_if_true, IsDead())));
+              IsPhi(MachineRepresentation::kWord32, IsInt32Constant(1),
+                    IsInt32Constant(2), IsMerge(outer_if_true, IsDead())));
 }
 
 
 TEST_F(BranchEliminationTest, NestedBranchSameFalse) {
   // { return (x ? 1 : (x ? 2 : 3); }
   // should be reduced to
   // { return (x ? 1 : 3; }
   Node* condition = Parameter(0);
   Node* outer_branch =
       graph()->NewNode(common()->Branch(), condition, graph()->start());
 
   Node* outer_if_true = graph()->NewNode(common()->IfTrue(), outer_branch);
 
   Node* outer_if_false = graph()->NewNode(common()->IfFalse(), outer_branch);
   Node* inner_branch =
       graph()->NewNode(common()->Branch(), condition, outer_if_false);
   Node* inner_if_true = graph()->NewNode(common()->IfTrue(), inner_branch);
   Node* inner_if_false = graph()->NewNode(common()->IfFalse(), inner_branch);
   Node* inner_merge =
       graph()->NewNode(common()->Merge(2), inner_if_true, inner_if_false);
   Node* inner_phi =
-      graph()->NewNode(common()->Phi(kMachInt32, 2), Int32Constant(2),
-                       Int32Constant(3), inner_merge);
+      graph()->NewNode(common()->Phi(MachineRepresentation::kWord32, 2),
+                       Int32Constant(2), Int32Constant(3), inner_merge);
 
   Node* outer_merge =
       graph()->NewNode(common()->Merge(2), outer_if_true, inner_merge);
-  Node* outer_phi = graph()->NewNode(common()->Phi(kMachInt32, 2),
-                                     Int32Constant(1), inner_phi, outer_merge);
+  Node* outer_phi =
+      graph()->NewNode(common()->Phi(MachineRepresentation::kWord32, 2),
+                       Int32Constant(1), inner_phi, outer_merge);
 
   Node* ret = graph()->NewNode(common()->Return(), outer_phi, graph()->start(),
                                outer_merge);
   graph()->SetEnd(graph()->NewNode(common()->End(1), ret));
 
   Reduce();
 
   // Outer branch should not be rewritten, the inner branch should be discarded.
   EXPECT_THAT(outer_branch, IsBranch(condition, graph()->start()));
   EXPECT_THAT(inner_phi,
-              IsPhi(kMachInt32, IsInt32Constant(2), IsInt32Constant(3),
-                    IsMerge(IsDead(), outer_if_false)));
+              IsPhi(MachineRepresentation::kWord32, IsInt32Constant(2),
+                    IsInt32Constant(3), IsMerge(IsDead(), outer_if_false)));
 }
 
 
 TEST_F(BranchEliminationTest, BranchAfterDiamond) {
   // { var y = x ? 1 : 2; return y + x ? 3 : 4; }
   // should not be reduced.
   Node* condition = Parameter(0);
 
   Node* branch1 =
       graph()->NewNode(common()->Branch(), condition, graph()->start());
   Node* if_true1 = graph()->NewNode(common()->IfTrue(), branch1);
   Node* if_false1 = graph()->NewNode(common()->IfFalse(), branch1);
   Node* merge1 = graph()->NewNode(common()->Merge(2), if_true1, if_false1);
-  Node* phi1 = graph()->NewNode(common()->Phi(kMachInt32, 2), Int32Constant(1),
-                                Int32Constant(2), merge1);
+  Node* phi1 =
+      graph()->NewNode(common()->Phi(MachineRepresentation::kWord32, 2),
+                       Int32Constant(1), Int32Constant(2), merge1);
 
   Node* branch2 = graph()->NewNode(common()->Branch(), condition, merge1);
   Node* if_true2 = graph()->NewNode(common()->IfTrue(), branch2);
   Node* if_false2 = graph()->NewNode(common()->IfFalse(), branch2);
   Node* merge2 = graph()->NewNode(common()->Merge(2), if_true2, if_false2);
-  Node* phi2 = graph()->NewNode(common()->Phi(kMachInt32, 2), Int32Constant(3),
-                                Int32Constant(4), merge1);
+  Node* phi2 =
+      graph()->NewNode(common()->Phi(MachineRepresentation::kWord32, 2),
+                       Int32Constant(3), Int32Constant(4), merge1);
 
 
   Node* add = graph()->NewNode(machine()->Int32Add(), phi1, phi2);
   Node* ret =
       graph()->NewNode(common()->Return(), add, graph()->start(), merge2);
   graph()->SetEnd(graph()->NewNode(common()->End(1), ret));
 
   Reduce();
 
   // Outer branch should not be rewritten, the inner branch condition should
@@ skipping 46 matching lines @@
   Reduce();
 
   // Outer branch should not be rewritten, the inner branch should be discarded.
   EXPECT_THAT(outer_branch, IsBranch(condition, graph()->start()));
   EXPECT_THAT(ret1, IsReturn(IsInt32Constant(2), effect, loop));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8