[turbofan] Make MachineType a pair of enums.

src/compiler/escape-analysis.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/escape-analysis.h"
 
 #include "src/base/flags.h"
 #include "src/bootstrapper.h"
 #include "src/compilation-dependencies.h"
 #include "src/compiler/common-operator.h"
@@ skipping 267 matching lines @@
           if (FLAG_trace_turbo_escape && ls->GetField(i)) {
             PrintF("    Field %zu agree on rep #%d\n", i,
                    ls->GetField(i)->id());
           }
         } else if (ls->GetField(i) != nullptr && rs->GetField(i) != nullptr) {
           Node* rep = mergeObject->GetField(i);
           if (!rep || rep->opcode() != IrOpcode::kPhi ||
               NodeProperties::GetValueInput(rep, 0) != ls->GetField(i) ||
               NodeProperties::GetValueInput(rep, 1) != rs->GetField(i)) {
             Node* phi =
-                graph->NewNode(common->Phi(kMachAnyTagged, 2), ls->GetField(i),
-                               rs->GetField(i), control);
+                graph->NewNode(common->Phi(MachineRepresentation::kTagged, 2),
+                               ls->GetField(i), rs->GetField(i), control);
             if (mergeObject->SetField(i, phi)) {
               if (FLAG_trace_turbo_escape) {
                 PrintF("    Creating Phi #%d as merge of #%d and #%d\n",
                        phi->id(), ls->GetField(i)->id(), rs->GetField(i)->id());
               }
               changed = true;
             }
           } else {
             if (FLAG_trace_turbo_escape) {
               PrintF("    Retaining Phi #%d as merge of #%d and #%d\n",
@@ skipping 645 matching lines @@
     Node* rv = r->GetField(offset);
     if (lv && rv) {
       if (!state->GetVirtualObject(node)) {
         state->SetVirtualObject(node->id(),
                                 new (zone()) VirtualObject(node->id(), zone()));
       }
       Node* rep = state->GetVirtualObject(node)->GetReplacement();
       if (!rep || rep->opcode() != IrOpcode::kPhi ||
           NodeProperties::GetValueInput(rep, 0) != lv ||
           NodeProperties::GetValueInput(rep, 1) != rv) {
-        Node* phi = graph()->NewNode(common()->Phi(kMachAnyTagged, 2), lv, rv,
-                                     NodeProperties::GetControlInput(from));
+        Node* phi =
+            graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                             lv, rv, NodeProperties::GetControlInput(from));
         state->GetVirtualObject(node)->SetReplacement(phi);
         state->LastChangedAt(node);
         if (FLAG_trace_turbo_escape) {
           PrintF(" got phi of #%d is #%d created.\n", lv->id(), rv->id());
         }
       } else if (FLAG_trace_turbo_escape) {
         PrintF(" has already the right phi representation.\n");
       }
     } else if (FLAG_trace_turbo_escape) {
       PrintF(" has incomplete field info: %p %p\n", static_cast<void*>(lv),
@@ skipping 34 matching lines @@
 
 void EscapeAnalysis::ProcessLoadElement(Node* node) {
   DCHECK_EQ(node->opcode(), IrOpcode::kLoadElement);
   ForwardVirtualState(node);
   Node* from = NodeProperties::GetValueInput(node, 0);
   VirtualState* state = virtual_states_[node->id()];
   if (VirtualObject* object = state->ResolveVirtualObject(from)) {
     NumberMatcher index(node->InputAt(1));
     ElementAccess access = OpParameter<ElementAccess>(node);
     if (index.HasValue()) {
-      CHECK_EQ(ElementSizeLog2Of(access.machine_type), kPointerSizeLog2);
+      CHECK_EQ(ElementSizeLog2Of(access.machine_type.representation()),
+               kPointerSizeLog2);
       CHECK_EQ(access.header_size % kPointerSize, 0);
       int offset = index.Value() + access.header_size / kPointerSize;
       if (!object->IsTracked()) return;
       Node* value = object->GetField(offset);
       if (value) {
         value = state->ResolveReplacement(value);
         // Record that the load has this alias.
         state->UpdateReplacement(node, value, zone());
       } else if (FLAG_trace_turbo_escape) {
         PrintF("No field %d on record for #%d\n", offset, from->id());
@@ skipping 29 matching lines @@
 
 
 void EscapeAnalysis::ProcessStoreElement(Node* node) {
   DCHECK_EQ(node->opcode(), IrOpcode::kStoreElement);
   ForwardVirtualState(node);
   Node* to = NodeProperties::GetValueInput(node, 0);
   NumberMatcher index(node->InputAt(1));
   ElementAccess access = OpParameter<ElementAccess>(node);
   Node* val = NodeProperties::GetValueInput(node, 2);
   if (index.HasValue()) {
-    CHECK_EQ(ElementSizeLog2Of(access.machine_type), kPointerSizeLog2);
+    CHECK_EQ(ElementSizeLog2Of(access.machine_type.representation()),
+             kPointerSizeLog2);
     CHECK_EQ(access.header_size % kPointerSize, 0);
     int offset = index.Value() + access.header_size / kPointerSize;
     VirtualState* states = virtual_states_[node->id()];
     if (VirtualObject* obj = states->ResolveVirtualObject(to)) {
       if (!obj->IsTracked()) return;
       if (obj->SetField(offset, states->ResolveReplacement(val))) {
         states->LastChangedAt(node);
       }
     }
   }
@@ skipping 39 matching lines @@
     }
   }
   for (size_t n = 0; n < object_states.size(); n++) {
     DebugPrintState(object_states[n]);
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8