[turbofan] Make MachineType a pair of enums.

test/cctest/compiler/test-loop-analysis.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/compiler/access-builder.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-operator.h"
@@ skipping 93 matching lines @@
   }
 
   Node* SetSelfReferences(Node* node) {
     for (Edge edge : node->input_edges()) {
       if (edge.to() == self) node->ReplaceInput(edge.index(), node);
     }
     return node;
   }
 
   const Operator* op(int count, bool effect) {
-    return effect ? common.EffectPhi(count) : common.Phi(kMachAnyTagged, count);
+    return effect ? common.EffectPhi(count)
+                  : common.Phi(MachineRepresentation::kTagged, count);
   }
 
   Node* Return(Node* val, Node* effect, Node* control) {
     Node* ret = graph.NewNode(common.Return(), val, effect, control);
     end->ReplaceInput(0, ret);
     return ret;
   }
 
   LoopTree* GetLoopTree() {
     if (loop_tree == NULL) {
@@ skipping 134 matching lines @@
   Node* header[] = {w.loop};
   Node* body[] = {w.branch, w.if_true};
   t.CheckLoop(header, 1, body, 2);
 }
 
 
 TEST(LaLoop1phi) {
   // One loop with a simple phi.
   LoopFinderTester t;
   While w(t, t.p0);
-  Node* phi =
-      t.graph.NewNode(t.common.Phi(kMachAnyTagged, 2), t.zero, t.one, w.loop);
+  Node* phi = t.graph.NewNode(t.common.Phi(MachineRepresentation::kTagged, 2),
+                              t.zero, t.one, w.loop);
   t.Return(phi, t.start, w.exit);
 
   Node* chain[] = {w.loop};
   t.CheckNestedLoops(chain, 1);
 
   Node* header[] = {w.loop, phi};
   Node* body[] = {w.branch, w.if_true};
   t.CheckLoop(header, 2, body, 2);
 }
 
@@ skipping 187 matching lines @@
 }
 
 
 TEST(LaNestedLoop1x) {
   // One loop nested in another.
   LoopFinderTester t;
   While w1(t, t.p0);
   While w2(t, t.p0);
   w2.nest(w1);
 
-  const Operator* op = t.common.Phi(kMachInt32, 2);
+  const Operator* op = t.common.Phi(MachineRepresentation::kWord32, 2);
   Node* p1a = t.graph.NewNode(op, t.p0, t.p0, w1.loop);
   Node* p1b = t.graph.NewNode(op, t.p0, t.p0, w1.loop);
   Node* p2a = t.graph.NewNode(op, p1a, t.p0, w2.loop);
   Node* p2b = t.graph.NewNode(op, p1b, t.p0, w2.loop);
 
   p1a->ReplaceInput(1, p2b);
   p1b->ReplaceInput(1, p2a);
 
   p2a->ReplaceInput(1, p2b);
   p2b->ReplaceInput(1, p2a);
@@ skipping 192 matching lines @@
   for (int i = 0; i < 3; i++) {
     for (int j = 0; j < 3; j++) {
       for (int k = 0; k < 3; k++) {
         LoopFinderTester t;
 
         Node* p1 = t.jsgraph.Int32Constant(11);
         Node* p2 = t.jsgraph.Int32Constant(22);
         Node* p3 = t.jsgraph.Int32Constant(33);
 
         Node* loop = t.graph.NewNode(t.common.Loop(2), t.start, t.start);
-        Node* phi =
-            t.graph.NewNode(t.common.Phi(kMachInt32, 2), t.one, p1, loop);
+        Node* phi = t.graph.NewNode(
+            t.common.Phi(MachineRepresentation::kWord32, 2), t.one, p1, loop);
         Node* cond = t.graph.NewNode(&kIntAdd, phi, p2);
         Node* branch = t.graph.NewNode(t.common.Branch(), cond, loop);
         Node* if_true = t.graph.NewNode(t.common.IfTrue(), branch);
         Node* exit = t.graph.NewNode(t.common.IfFalse(), branch);
         loop->ReplaceInput(1, if_true);
         Node* ret = t.graph.NewNode(t.common.Return(), p3, t.start, exit);
         t.graph.SetEnd(ret);
 
         Node* choices[] = {p1, phi, cond};
         p1->ReplaceUses(choices[i]);
@@ skipping 14 matching lines @@
   for (int j = 0; j < 5; j++) {
     for (int k = 0; k < 5; k++) {
       LoopFinderTester t;
 
       Node* p1 = t.jsgraph.Int32Constant(11);
       Node* p2 = t.jsgraph.Int32Constant(22);
       Node* p3 = t.jsgraph.Int32Constant(33);
 
       // outer loop.
       Node* loop1 = t.graph.NewNode(t.common.Loop(2), t.start, t.start);
-      Node* phi1 =
-          t.graph.NewNode(t.common.Phi(kMachInt32, 2), t.one, p1, loop1);
+      Node* phi1 = t.graph.NewNode(
+          t.common.Phi(MachineRepresentation::kWord32, 2), t.one, p1, loop1);
       Node* cond1 = t.graph.NewNode(&kIntAdd, phi1, t.one);
       Node* branch1 = t.graph.NewNode(t.common.Branch(), cond1, loop1);
       Node* if_true1 = t.graph.NewNode(t.common.IfTrue(), branch1);
       Node* exit1 = t.graph.NewNode(t.common.IfFalse(), branch1);
 
       // inner loop.
       Node* loop2 = t.graph.NewNode(t.common.Loop(2), if_true1, t.start);
-      Node* phi2 =
-          t.graph.NewNode(t.common.Phi(kMachInt32, 2), t.one, p2, loop2);
+      Node* phi2 = t.graph.NewNode(
+          t.common.Phi(MachineRepresentation::kWord32, 2), t.one, p2, loop2);
       Node* cond2 = t.graph.NewNode(&kIntAdd, phi2, p3);
       Node* branch2 = t.graph.NewNode(t.common.Branch(), cond2, loop2);
       Node* if_true2 = t.graph.NewNode(t.common.IfTrue(), branch2);
       Node* exit2 = t.graph.NewNode(t.common.IfFalse(), branch2);
       loop2->ReplaceInput(1, if_true2);
       loop1->ReplaceInput(1, exit2);
 
       Node* ret = t.graph.NewNode(t.common.Return(), phi1, t.start, exit1);
       t.graph.SetEnd(ret);
 
@@ skipping 45 matching lines @@
   Node* p1c = t.jsgraph.Int32Constant(33);
   Node* p2a = t.jsgraph.Int32Constant(44);
   Node* p2b = t.jsgraph.Int32Constant(55);
   Node* p2c = t.jsgraph.Int32Constant(66);
   Node* p3a = t.jsgraph.Int32Constant(77);
   Node* p3b = t.jsgraph.Int32Constant(88);
   Node* p3c = t.jsgraph.Int32Constant(99);
 
   // L1 depth = 0
   Node* loop1 = t.graph.NewNode(t.common.Loop(2), t.start, t.start);
-  Node* phi1 = t.graph.NewNode(t.common.Phi(kMachInt32, 2), p1a, p1c, loop1);
+  Node* phi1 = t.graph.NewNode(t.common.Phi(MachineRepresentation::kWord32, 2),
+                               p1a, p1c, loop1);
   Node* cond1 = t.graph.NewNode(&kIntAdd, phi1, p1b);
   Node* branch1 = t.graph.NewNode(t.common.Branch(), cond1, loop1);
   Node* if_true1 = t.graph.NewNode(t.common.IfTrue(), branch1);
   Node* exit1 = t.graph.NewNode(t.common.IfFalse(), branch1);
 
   // L2 depth = 1
   Node* loop2 = t.graph.NewNode(t.common.Loop(2), if_true1, t.start);
-  Node* phi2 = t.graph.NewNode(t.common.Phi(kMachInt32, 2), p2a, p2c, loop2);
+  Node* phi2 = t.graph.NewNode(t.common.Phi(MachineRepresentation::kWord32, 2),
+                               p2a, p2c, loop2);
   Node* cond2 = t.graph.NewNode(&kIntAdd, phi2, p2b);
   Node* branch2 = t.graph.NewNode(t.common.Branch(), cond2, loop2);
   Node* if_true2 = t.graph.NewNode(t.common.IfTrue(), branch2);
   Node* exit2 = t.graph.NewNode(t.common.IfFalse(), branch2);
 
   // L3 depth = 2
   Node* loop3 = t.graph.NewNode(t.common.Loop(2), if_true2, t.start);
-  Node* phi3 = t.graph.NewNode(t.common.Phi(kMachInt32, 2), p3a, p3c, loop3);
+  Node* phi3 = t.graph.NewNode(t.common.Phi(MachineRepresentation::kWord32, 2),
+                               p3a, p3c, loop3);
   Node* cond3 = t.graph.NewNode(&kIntAdd, phi3, p3b);
   Node* branch3 = t.graph.NewNode(t.common.Branch(), cond3, loop3);
   Node* if_true3 = t.graph.NewNode(t.common.IfTrue(), branch3);
   Node* exit3 = t.graph.NewNode(t.common.IfFalse(), branch3);
 
   loop3->ReplaceInput(1, if_true3);
   loop2->ReplaceInput(1, exit3);
   loop1->ReplaceInput(1, exit2);
 
   Node* ret = t.graph.NewNode(t.common.Return(), phi1, t.start, exit1);
@@ skipping 87 matching lines @@
 static void RunManyChainedLoops_i(int count) {
   LoopFinderTester t;
   Node** nodes = t.zone()->NewArray<Node*>(count * 4);
   Node* k11 = t.jsgraph.Int32Constant(11);
   Node* k12 = t.jsgraph.Int32Constant(12);
   Node* last = t.start;
 
   // Build loops.
   for (int i = 0; i < count; i++) {
     Node* loop = t.graph.NewNode(t.common.Loop(2), last, t.start);
-    Node* phi = t.graph.NewNode(t.common.Phi(kMachInt32, 2), k11, k12, loop);
+    Node* phi = t.graph.NewNode(t.common.Phi(MachineRepresentation::kWord32, 2),
+                                k11, k12, loop);
     Node* branch = t.graph.NewNode(t.common.Branch(), phi, loop);
     Node* if_true = t.graph.NewNode(t.common.IfTrue(), branch);
     Node* exit = t.graph.NewNode(t.common.IfFalse(), branch);
     loop->ReplaceInput(1, if_true);
 
     nodes[i * 4 + 0] = loop;
     nodes[i * 4 + 1] = phi;
     nodes[i * 4 + 2] = branch;
     nodes[i * 4 + 3] = if_true;
 
@@ skipping 14 matching lines @@
   LoopFinderTester t;
   Node** nodes = t.zone()->NewArray<Node*>(count * 5);
   Node* k11 = t.jsgraph.Int32Constant(11);
   Node* k12 = t.jsgraph.Int32Constant(12);
   Node* outer = nullptr;
   Node* entry = t.start;
 
   // Build loops.
   for (int i = 0; i < count; i++) {
     Node* loop = t.graph.NewNode(t.common.Loop(2), entry, t.start);
-    Node* phi = t.graph.NewNode(t.common.Phi(kMachInt32, 2), k11, k12, loop);
+    Node* phi = t.graph.NewNode(t.common.Phi(MachineRepresentation::kWord32, 2),
+                                k11, k12, loop);
     Node* branch = t.graph.NewNode(t.common.Branch(), phi, loop);
     Node* if_true = t.graph.NewNode(t.common.IfTrue(), branch);
     Node* exit = t.graph.NewNode(t.common.IfFalse(), branch);
 
     nodes[i * 5 + 0] = exit;     // outside
     nodes[i * 5 + 1] = loop;     // header
     nodes[i * 5 + 2] = phi;      // header
     nodes[i * 5 + 3] = branch;   // body
     nodes[i * 5 + 4] = if_true;  // body
 
@@ skipping 35 matching lines @@
 TEST(LaManyNested_62) { RunManyNestedLoops_i(62); }
 TEST(LaManyNested_63) { RunManyNestedLoops_i(63); }
 TEST(LaManyNested_64) { RunManyNestedLoops_i(64); }
 
 
 TEST(LaPhiTangle) { LoopFinderTester t; }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8