[turbofan] Make MachineType a pair of enums.

test/cctest/compiler/test-osr.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/codegen.h"
 #include "src/compiler/all-nodes.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/diamond.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/js-graph.h"
@@ skipping 73 matching lines @@
     CHECK_EQ(loop->InputCount(), count);
     CHECK_EQ(osr_loop_entry, loop->InputAt(1));
 
     Node* inputs[6];
     inputs[0] = incoming;
     inputs[1] = osr_values[osr_value];
     if (count > 2) inputs[2] = back1;
     if (count > 3) inputs[3] = back2;
     if (count > 4) inputs[4] = back3;
     inputs[count] = loop;
-    return graph.NewNode(common.Phi(kMachAnyTagged, count), count + 1, inputs);
+    return graph.NewNode(common.Phi(MachineRepresentation::kTagged, count),
+                         count + 1, inputs);
   }
 
   Node* NewLoop(bool is_osr, int num_backedges, Node* entry = nullptr) {
     if (entry == nullptr) entry = osr_normal_entry;
     Node* loop = graph.NewNode(common.Loop(1), entry);
     if (is_osr) {
       loop->AppendInput(graph.zone(), osr_loop_entry);
     }
     for (int i = 0; i < num_backedges; i++) {
       loop->AppendInput(graph.zone(), loop);
@@ skipping 202 matching lines @@
     loop->ReplaceInput(loop->InputCount() - 1, if_true);
   }
 
   void Nest(While& that) {
     that.loop->ReplaceInput(that.loop->InputCount() - 1, exit);
     this->loop->ReplaceInput(0, that.if_true);
   }
 
   Node* Phi(Node* i1, Node* i2, Node* i3) {
     if (loop->InputCount() == 2) {
-      return t.graph.NewNode(t.common.Phi(kMachAnyTagged, 2), i1, i2, loop);
+      return t.graph.NewNode(t.common.Phi(MachineRepresentation::kTagged, 2),
+                             i1, i2, loop);
     } else {
-      return t.graph.NewNode(t.common.Phi(kMachAnyTagged, 3), i1, i2, i3, loop);
+      return t.graph.NewNode(t.common.Phi(MachineRepresentation::kTagged, 3),
+                             i1, i2, i3, loop);
     }
   }
 };
 
 
 static Node* FindSuccessor(Node* node, IrOpcode::Value opcode) {
   for (Node* use : node->uses()) {
     if (use->opcode() == opcode) return use;
   }
   UNREACHABLE();  // should have been found.
@@ skipping 136 matching lines @@
 
 Node* MakeCounter(JSGraph* jsgraph, Node* start, Node* loop) {
   int count = loop->InputCount();
   NodeVector tmp_inputs(jsgraph->graph()->zone());
   for (int i = 0; i < count; i++) {
     tmp_inputs.push_back(start);
   }
   tmp_inputs.push_back(loop);
 
   Node* phi = jsgraph->graph()->NewNode(
-      jsgraph->common()->Phi(kMachInt32, count), count + 1, &tmp_inputs[0]);
+      jsgraph->common()->Phi(MachineRepresentation::kWord32, count), count + 1,
+      &tmp_inputs[0]);
   Node* inc = jsgraph->graph()->NewNode(&kIntAdd, phi, jsgraph->OneConstant());
 
   for (int i = 1; i < count; i++) {
     phi->ReplaceInput(i, inc);
   }
   return phi;
 }
 
 
 TEST(Deconstruct_osr_nested3) {
   OsrDeconstructorTester T(1);
 
   // outermost loop.
   While loop0(T, T.p0, false, 1);
   Node* loop0_cntr = MakeCounter(&T.jsgraph, T.p0, loop0.loop);
   loop0.branch->ReplaceInput(0, loop0_cntr);
 
   // middle loop.
   Node* loop1 = T.graph.NewNode(T.common.Loop(1), loop0.if_true);
-  Node* loop1_phi = T.graph.NewNode(T.common.Phi(kMachAnyTagged, 2), loop0_cntr,
-                                    loop0_cntr, loop1);
+  Node* loop1_phi =
+      T.graph.NewNode(T.common.Phi(MachineRepresentation::kTagged, 2),
+                      loop0_cntr, loop0_cntr, loop1);
 
   // innermost (OSR) loop.
   While loop2(T, T.p0, true, 1);
   loop2.loop->ReplaceInput(0, loop1);
 
   Node* loop2_cntr = MakeCounter(&T.jsgraph, loop1_phi, loop2.loop);
   loop2_cntr->ReplaceInput(1, T.osr_values[0]);
   Node* osr_phi = loop2_cntr;
   Node* loop2_inc = loop2_cntr->InputAt(2);
   loop2.branch->ReplaceInput(0, loop2_cntr);
@@ skipping 53 matching lines @@
   CHECK_EQ(new_loop0_phi, FindSuccessor(new_loop0_loop, IrOpcode::kPhi));
 
   // Check that the return returns the phi from the OSR loop and control
   // depends on the copy of the outer loop0.
   CheckInputs(new_ret, new_loop0_phi, T.graph.start(), new_loop0_exit);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8