[turbofan] Make MachineType a pair of enums.

src/compiler/js-native-context-specialization.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/js-native-context-specialization.h"
 
 #include "src/accessors.h"
 #include "src/code-factory.h"
 #include "src/compilation-dependencies.h"
 #include "src/compiler/access-builder.h"
@@ skipping 236 matching lines @@
           access_info.holder().ToHandle(&holder)) {
         this_receiver = jsgraph()->Constant(holder);
       }
       Node* this_storage = this_receiver;
       if (!field_index.is_inobject()) {
         this_storage = this_effect = graph()->NewNode(
             simplified()->LoadField(AccessBuilder::ForJSObjectProperties()),
             this_storage, this_effect, this_control);
       }
       FieldAccess field_access = {kTaggedBase, field_index.offset(), name,
-                                  field_type, kMachAnyTagged};
+                                  field_type, MachineType::AnyTagged()};
       if (access_mode == AccessMode::kLoad) {
         if (field_type->Is(Type::UntaggedFloat64())) {
           if (!field_index.is_inobject() || field_index.is_hidden_field() ||
               !FLAG_unbox_double_fields) {
             this_storage = this_effect =
                 graph()->NewNode(simplified()->LoadField(field_access),
                                  this_storage, this_effect, this_control);
             field_access.offset = HeapNumber::kValueOffset;
             field_access.name = MaybeHandle<Name>();
           }
-          field_access.machine_type = kMachFloat64;
+          field_access.machine_type = MachineType::Float64();
         }
         this_value = this_effect =
             graph()->NewNode(simplified()->LoadField(field_access),
                              this_storage, this_effect, this_control);
       } else {
         DCHECK_EQ(AccessMode::kStore, access_mode);
         if (field_type->Is(Type::UntaggedFloat64())) {
           Node* check =
               graph()->NewNode(simplified()->ObjectIsNumber(), this_value);
           Node* branch = graph()->NewNode(common()->Branch(BranchHint::kTrue),
@@ skipping 23 matching lines @@
               this_value = this_box;
 
               field_access.type = Type::TaggedPointer();
             } else {
               // We just store directly to the MutableHeapNumber.
               this_storage = this_effect =
                   graph()->NewNode(simplified()->LoadField(field_access),
                                    this_storage, this_effect, this_control);
               field_access.offset = HeapNumber::kValueOffset;
               field_access.name = MaybeHandle<Name>();
-              field_access.machine_type = kMachFloat64;
+              field_access.machine_type = MachineType::Float64();
             }
           } else {
             // Unboxed double field, we store directly to the field.
-            field_access.machine_type = kMachFloat64;
+            field_access.machine_type = MachineType::Float64();
           }
         } else if (field_type->Is(Type::TaggedSigned())) {
           Node* check =
               graph()->NewNode(simplified()->ObjectIsSmi(), this_value);
           Node* branch = graph()->NewNode(common()->Branch(BranchHint::kTrue),
                                           check, this_control);
           exit_controls.push_back(
               graph()->NewNode(common()->IfFalse(), branch));
           this_control = graph()->NewNode(common()->IfTrue(), branch);
         } else if (field_type->Is(Type::TaggedPointer())) {
@@ skipping 95 matching lines @@
   if (control_count == 0) {
     value = effect = control = jsgraph()->Dead();
   } else if (control_count == 1) {
     value = values.front();
     effect = effects.front();
     control = controls.front();
   } else {
     control = graph()->NewNode(common()->Merge(control_count), control_count,
                                &controls.front());
     values.push_back(control);
-    value = graph()->NewNode(common()->Phi(kMachAnyTagged, control_count),
-                             control_count + 1, &values.front());
+    value = graph()->NewNode(
+        common()->Phi(MachineRepresentation::kTagged, control_count),
+        control_count + 1, &values.front());
     effects.push_back(control);
     effect = graph()->NewNode(common()->EffectPhi(control_count),
                               control_count + 1, &effects.front());
   }
   ReplaceWithValue(node, value, effect, control);
   return Replace(value);
 }
 
 
 Reduction JSNativeContextSpecialization::ReduceJSLoadNamed(Node* node) {
@@ skipping 249 matching lines @@
     // Check that the {index} is in the valid range for the {receiver}.
     Node* check = graph()->NewNode(simplified()->NumberLessThan(), this_index,
                                    this_length);
     Node* branch = graph()->NewNode(common()->Branch(BranchHint::kTrue), check,
                                     this_control);
     exit_controls.push_back(graph()->NewNode(common()->IfFalse(), branch));
     this_control = graph()->NewNode(common()->IfTrue(), branch);
 
     // Compute the element access.
     Type* element_type = Type::Any();
-    MachineType element_machine_type = kMachAnyTagged;
+    MachineType element_machine_type = MachineType::AnyTagged();
     if (IsFastDoubleElementsKind(elements_kind)) {
       element_type = type_cache_.kFloat64;
-      element_machine_type = kMachFloat64;
+      element_machine_type = MachineType::Float64();
     } else if (IsFastSmiElementsKind(elements_kind)) {
       element_type = type_cache_.kSmi;
     }
     ElementAccess element_access = {kTaggedBase, FixedArray::kHeaderSize,
                                     element_type, element_machine_type};
 
     // Access the actual element.
     // TODO(bmeurer): Refactor this into separate methods or even a separate
     // class that deals with the elements access.
     if (access_mode == AccessMode::kLoad) {
@@ skipping 28 matching lines @@
             graph()->zone());
         if (receiver_type->NowIs(initial_holey_array_type) &&
             isolate()->IsFastArrayConstructorPrototypeChainIntact()) {
           // Add a code dependency on the array protector cell.
           AssumePrototypesStable(receiver_type, native_context,
                                  isolate()->initial_object_prototype());
           dependencies()->AssumePropertyCell(factory()->array_protector());
           // Turn the hole into undefined.
           this_control =
               graph()->NewNode(common()->Merge(2), if_true, if_false);
-          this_value = graph()->NewNode(common()->Phi(kMachAnyTagged, 2),
-                                        jsgraph()->UndefinedConstant(),
-                                        this_value, this_control);
+          this_value = graph()->NewNode(
+              common()->Phi(MachineRepresentation::kTagged, 2),
+              jsgraph()->UndefinedConstant(), this_value, this_control);
           element_type =
               Type::Union(element_type, Type::Undefined(), graph()->zone());
         } else {
           // Deoptimize in case of the hole.
           exit_controls.push_back(if_true);
           this_control = if_false;
         }
         // Rename the result to represent the actual type (not polluted by the
         // hole).
         this_value = graph()->NewNode(common()->Guard(element_type), this_value,
                                       this_control);
       } else if (elements_kind == FAST_HOLEY_DOUBLE_ELEMENTS) {
         // Perform the hole check on the result.
         Node* check =
             graph()->NewNode(simplified()->NumberIsHoleNaN(), this_value);
         // Check if we are allowed to return the hole directly.
         Type* initial_holey_array_type = Type::Class(
             handle(isolate()->get_initial_js_array_map(elements_kind)),
             graph()->zone());
         if (receiver_type->NowIs(initial_holey_array_type) &&
             isolate()->IsFastArrayConstructorPrototypeChainIntact()) {
           // Add a code dependency on the array protector cell.
           AssumePrototypesStable(receiver_type, native_context,
                                  isolate()->initial_object_prototype());
           dependencies()->AssumePropertyCell(factory()->array_protector());
           // Turn the hole into undefined.
           this_value = graph()->NewNode(
-              common()->Select(kMachAnyTagged, BranchHint::kFalse), check,
-              jsgraph()->UndefinedConstant(), this_value);
+              common()->Select(MachineRepresentation::kTagged,
+                               BranchHint::kFalse),
+              check, jsgraph()->UndefinedConstant(), this_value);
         } else {
           // Deoptimize in case of the hole.
           Node* branch = graph()->NewNode(common()->Branch(BranchHint::kFalse),
                                           check, this_control);
           this_control = graph()->NewNode(common()->IfFalse(), branch);
           exit_controls.push_back(graph()->NewNode(common()->IfTrue(), branch));
         }
       }
     } else {
       DCHECK_EQ(AccessMode::kStore, access_mode);
@@ skipping 53 matching lines @@
   if (control_count == 0) {
     value = effect = control = jsgraph()->Dead();
   } else if (control_count == 1) {
     value = values.front();
     effect = effects.front();
     control = controls.front();
   } else {
     control = graph()->NewNode(common()->Merge(control_count), control_count,
                                &controls.front());
     values.push_back(control);
-    value = graph()->NewNode(common()->Phi(kMachAnyTagged, control_count),
-                             control_count + 1, &values.front());
+    value = graph()->NewNode(
+        common()->Phi(MachineRepresentation::kTagged, control_count),
+        control_count + 1, &values.front());
     effects.push_back(control);
     effect = graph()->NewNode(common()->EffectPhi(control_count),
                               control_count + 1, &effects.front());
   }
   ReplaceWithValue(node, value, effect, control);
   return Replace(value);
 }
 
 
 Reduction JSNativeContextSpecialization::ReduceKeyedAccess(
@@ skipping 145 matching lines @@
 }
 
 
 SimplifiedOperatorBuilder* JSNativeContextSpecialization::simplified() const {
   return jsgraph()->simplified();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8