[turbofan] Make MachineType a pair of enums.

src/compiler/js-generic-lowering.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/code-factory.h"
 #include "src/code-stubs.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/js-generic-lowering.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/machine-operator.h"
@@ skipping 141 matching lines @@
                      ? NodeProperties::GetEffectInput(node)
                      : graph()->start();
   inputs.push_back(effect);
   Node* control = (node->op()->ControlInputCount() > 0)
                       ? NodeProperties::GetControlInput(node)
                       : graph()->start();
   inputs.push_back(control);
   CallDescriptor* desc_compare = Linkage::GetStubCallDescriptor(
       isolate(), zone(), callable.descriptor(), 0,
       CallDescriptor::kPatchableCallSiteWithNop | FlagsForNode(node),
-      Operator::kNoProperties, kMachIntPtr);
+      Operator::kNoProperties, MachineType::IntPtr());
   Node* compare =
       graph()->NewNode(common()->Call(desc_compare),
                        static_cast<int>(inputs.size()), &inputs.front());
 
   // Decide how the return value from the above CompareIC can be converted into
   // a JavaScript boolean oddball depending on the given token.
   Node* false_value = jsgraph()->FalseConstant();
   Node* true_value = jsgraph()->TrueConstant();
   const Operator* op = nullptr;
   switch (token) {
@@ skipping 24 matching lines @@
       UNREACHABLE();
   }
   Node* booleanize = graph()->NewNode(op, compare, jsgraph()->ZeroConstant());
 
   // Finally patch the original node to select a boolean.
   NodeProperties::ReplaceUses(node, node, compare, compare, compare);
   node->TrimInputCount(3);
   node->ReplaceInput(0, booleanize);
   node->ReplaceInput(1, true_value);
   node->ReplaceInput(2, false_value);
-  NodeProperties::ChangeOp(node, common()->Select(kMachAnyTagged));
+  NodeProperties::ChangeOp(node,
+                           common()->Select(MachineRepresentation::kTagged));
 }
 
 
 void JSGenericLowering::ReplaceWithStubCall(Node* node, Callable callable,
                                             CallDescriptor::Flags flags) {
   Operator::Properties properties = node->op()->properties();
   CallDescriptor* desc = Linkage::GetStubCallDescriptor(
       isolate(), zone(), callable.descriptor(), 0, flags, properties);
   Node* stub_code = jsgraph()->HeapConstant(callable.code());
   node->InsertInput(zone(), 0, stub_code);
@@ skipping 82 matching lines @@
 
 void JSGenericLowering::LowerJSLoadGlobal(Node* node) {
   Node* context = NodeProperties::GetContextInput(node);
   Node* effect = NodeProperties::GetEffectInput(node);
   CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
   const LoadGlobalParameters& p = LoadGlobalParametersOf(node->op());
   Callable callable = CodeFactory::LoadICInOptimizedCode(
       isolate(), p.typeof_mode(), SLOPPY, UNINITIALIZED);
   // Load global object from the context.
   Node* native_context =
-      graph()->NewNode(machine()->Load(kMachAnyTagged), context,
+      graph()->NewNode(machine()->Load(MachineType::AnyTagged()), context,
                        jsgraph()->IntPtrConstant(
                            Context::SlotOffset(Context::NATIVE_CONTEXT_INDEX)),
                        effect, graph()->start());
   Node* global = graph()->NewNode(
-      machine()->Load(kMachAnyTagged), native_context,
+      machine()->Load(MachineType::AnyTagged()), native_context,
       jsgraph()->IntPtrConstant(Context::SlotOffset(Context::EXTENSION_INDEX)),
       effect, graph()->start());
   node->InsertInput(zone(), 0, global);
   node->InsertInput(zone(), 1, jsgraph()->HeapConstant(p.name()));
   node->InsertInput(zone(), 2, jsgraph()->SmiConstant(p.feedback().index()));
   ReplaceWithStubCall(node, callable, flags);
 }
 
 
 void JSGenericLowering::LowerJSStoreProperty(Node* node) {
@@ skipping 24 matching lines @@
 
 void JSGenericLowering::LowerJSStoreGlobal(Node* node) {
   Node* context = NodeProperties::GetContextInput(node);
   Node* effect = NodeProperties::GetEffectInput(node);
   CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
   const StoreGlobalParameters& p = StoreGlobalParametersOf(node->op());
   Callable callable = CodeFactory::StoreICInOptimizedCode(
       isolate(), p.language_mode(), UNINITIALIZED);
   // Load global object from the context.
   Node* native_context =
-      graph()->NewNode(machine()->Load(kMachAnyTagged), context,
+      graph()->NewNode(machine()->Load(MachineType::AnyTagged()), context,
                        jsgraph()->IntPtrConstant(
                            Context::SlotOffset(Context::NATIVE_CONTEXT_INDEX)),
                        effect, graph()->start());
   Node* global = graph()->NewNode(
-      machine()->Load(kMachAnyTagged), native_context,
+      machine()->Load(MachineType::AnyTagged()), native_context,
       jsgraph()->IntPtrConstant(Context::SlotOffset(Context::EXTENSION_INDEX)),
       effect, graph()->start());
   node->InsertInput(zone(), 0, global);
   node->InsertInput(zone(), 1, jsgraph()->HeapConstant(p.name()));
   DCHECK(p.feedback().index() != -1);
   node->InsertInput(zone(), 3, jsgraph()->SmiConstant(p.feedback().index()));
   ReplaceWithStubCall(node, callable,
                       CallDescriptor::kPatchableCallSite | flags);
 }
 
@@ skipping 15 matching lines @@
   CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
   Callable callable = CodeFactory::InstanceOf(isolate());
   ReplaceWithStubCall(node, callable, flags);
 }
 
 
 void JSGenericLowering::LowerJSLoadContext(Node* node) {
   const ContextAccess& access = ContextAccessOf(node->op());
   for (size_t i = 0; i < access.depth(); ++i) {
     node->ReplaceInput(
-        0, graph()->NewNode(machine()->Load(kMachAnyTagged),
+        0, graph()->NewNode(machine()->Load(MachineType::AnyTagged()),
                             NodeProperties::GetValueInput(node, 0),
                             jsgraph()->Int32Constant(
                                 Context::SlotOffset(Context::PREVIOUS_INDEX)),
                             NodeProperties::GetEffectInput(node),
                             graph()->start()));
   }
   node->ReplaceInput(1, jsgraph()->Int32Constant(Context::SlotOffset(
                             static_cast<int>(access.index()))));
   node->AppendInput(zone(), graph()->start());
-  NodeProperties::ChangeOp(node, machine()->Load(kMachAnyTagged));
+  NodeProperties::ChangeOp(node, machine()->Load(MachineType::AnyTagged()));
 }
 
 
 void JSGenericLowering::LowerJSStoreContext(Node* node) {
   const ContextAccess& access = ContextAccessOf(node->op());
   for (size_t i = 0; i < access.depth(); ++i) {
     node->ReplaceInput(
-        0, graph()->NewNode(machine()->Load(kMachAnyTagged),
+        0, graph()->NewNode(machine()->Load(MachineType::AnyTagged()),
                             NodeProperties::GetValueInput(node, 0),
                             jsgraph()->Int32Constant(
                                 Context::SlotOffset(Context::PREVIOUS_INDEX)),
                             NodeProperties::GetEffectInput(node),
                             graph()->start()));
   }
   node->ReplaceInput(2, NodeProperties::GetValueInput(node, 1));
   node->ReplaceInput(1, jsgraph()->Int32Constant(Context::SlotOffset(
                             static_cast<int>(access.index()))));
-  NodeProperties::ChangeOp(node, machine()->Store(StoreRepresentation(
-                                     kMachAnyTagged, kFullWriteBarrier)));
+  NodeProperties::ChangeOp(
+      node, machine()->Store(StoreRepresentation(MachineType::AnyTagged(),
+                                                 kFullWriteBarrier)));
 }
 
 
 void JSGenericLowering::LowerJSLoadDynamic(Node* node) {
   const DynamicAccess& access = DynamicAccessOf(node->op());
   Runtime::FunctionId function_id =
       (access.typeof_mode() == NOT_INSIDE_TYPEOF)
           ? Runtime::kLoadLookupSlot
           : Runtime::kLoadLookupSlotNoReferenceError;
   Node* projection = graph()->NewNode(common()->Projection(0), node);
@@ skipping 178 matching lines @@
       zone(), function->function_id, 1, Operator::kNoProperties,
       CallDescriptor::kNeedsFrameState);
   Node* cache_type = effect = graph()->NewNode(
       common()->Call(descriptor),
       jsgraph()->CEntryStubConstant(function->result_size), object,
       jsgraph()->ExternalConstant(function->function_id),
       jsgraph()->Int32Constant(1), context, frame_state, effect, control);
   control = graph()->NewNode(common()->IfSuccess(), cache_type);
 
   Node* object_map = effect = graph()->NewNode(
-      machine()->Load(kMachAnyTagged), object,
+      machine()->Load(MachineType::AnyTagged()), object,
       jsgraph()->IntPtrConstant(HeapObject::kMapOffset - kHeapObjectTag),
       effect, control);
   Node* cache_type_map = effect = graph()->NewNode(
-      machine()->Load(kMachAnyTagged), cache_type,
+      machine()->Load(MachineType::AnyTagged()), cache_type,
       jsgraph()->IntPtrConstant(HeapObject::kMapOffset - kHeapObjectTag),
       effect, control);
   Node* meta_map = jsgraph()->HeapConstant(isolate()->factory()->meta_map());
 
   // If we got a map from the GetPropertyNamesFast runtime call, we can do a
   // fast modification check. Otherwise, we got a fixed array, and we have to
   // perform a slow check on every iteration.
   Node* check0 =
       graph()->NewNode(machine()->WordEqual(), cache_type_map, meta_map);
   Node* branch0 =
       graph()->NewNode(common()->Branch(BranchHint::kTrue), check0, control);
 
   Node* if_true0 = graph()->NewNode(common()->IfTrue(), branch0);
   Node* cache_array_true0;
   Node* cache_length_true0;
   Node* cache_type_true0;
   Node* etrue0;
   {
     // Enum cache case.
     Node* cache_type_enum_length = etrue0 = graph()->NewNode(
-        machine()->Load(kMachUint32), cache_type,
+        machine()->Load(MachineType::Uint32()), cache_type,
         jsgraph()->IntPtrConstant(Map::kBitField3Offset - kHeapObjectTag),
         effect, if_true0);
     cache_type_enum_length =
         graph()->NewNode(machine()->Word32And(), cache_type_enum_length,
                          jsgraph()->Uint32Constant(Map::EnumLengthBits::kMask));
 
     Node* check1 =
         graph()->NewNode(machine()->Word32Equal(), cache_type_enum_length,
                          jsgraph()->Int32Constant(0));
     Node* branch1 =
         graph()->NewNode(common()->Branch(BranchHint::kTrue), check1, if_true0);
 
     Node* if_true1 = graph()->NewNode(common()->IfTrue(), branch1);
     Node* cache_array_true1;
     Node* etrue1;
     {
       // No properties to enumerate.
       cache_array_true1 =
           jsgraph()->HeapConstant(isolate()->factory()->empty_fixed_array());
       etrue1 = etrue0;
     }
 
     Node* if_false1 = graph()->NewNode(common()->IfFalse(), branch1);
     Node* cache_array_false1;
     Node* efalse1;
     {
       // Load the enumeration cache from the instance descriptors of {object}.
       Node* object_map_descriptors = efalse1 = graph()->NewNode(
-          machine()->Load(kMachAnyTagged), object_map,
+          machine()->Load(MachineType::AnyTagged()), object_map,
           jsgraph()->IntPtrConstant(Map::kDescriptorsOffset - kHeapObjectTag),
           etrue0, if_false1);
       Node* object_map_enum_cache = efalse1 = graph()->NewNode(
-          machine()->Load(kMachAnyTagged), object_map_descriptors,
+          machine()->Load(MachineType::AnyTagged()), object_map_descriptors,
           jsgraph()->IntPtrConstant(DescriptorArray::kEnumCacheOffset -
                                     kHeapObjectTag),
           efalse1, if_false1);
       cache_array_false1 = efalse1 = graph()->NewNode(
-          machine()->Load(kMachAnyTagged), object_map_enum_cache,
+          machine()->Load(MachineType::AnyTagged()), object_map_enum_cache,
           jsgraph()->IntPtrConstant(
               DescriptorArray::kEnumCacheBridgeCacheOffset - kHeapObjectTag),
           efalse1, if_false1);
     }
 
     if_true0 = graph()->NewNode(common()->Merge(2), if_true1, if_false1);
     etrue0 =
         graph()->NewNode(common()->EffectPhi(2), etrue1, efalse1, if_true0);
     cache_array_true0 =
-        graph()->NewNode(common()->Phi(kMachAnyTagged, 2), cache_array_true1,
-                         cache_array_false1, if_true0);
+        graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                         cache_array_true1, cache_array_false1, if_true0);
 
     cache_length_true0 = graph()->NewNode(
         machine()->WordShl(),
         machine()->Is64()
             ? graph()->NewNode(machine()->ChangeUint32ToUint64(),
                                cache_type_enum_length)
             : cache_type_enum_length,
         jsgraph()->Int32Constant(kSmiShiftSize + kSmiTagSize));
     cache_type_true0 = cache_type;
   }
 
   Node* if_false0 = graph()->NewNode(common()->IfFalse(), branch0);
   Node* cache_array_false0;
   Node* cache_length_false0;
   Node* cache_type_false0;
   Node* efalse0;
   {
     // FixedArray case.
     Node* object_instance_type = efalse0 = graph()->NewNode(
-        machine()->Load(kMachUint8), object_map,
+        machine()->Load(MachineType::Uint8()), object_map,
         jsgraph()->IntPtrConstant(Map::kInstanceTypeOffset - kHeapObjectTag),
         effect, if_false0);
 
     Node* check1 =
         graph()->NewNode(machine()->Word32Equal(), object_instance_type,
                          jsgraph()->Uint32Constant(JS_PROXY_TYPE));
     Node* branch1 = graph()->NewNode(common()->Branch(BranchHint::kFalse),
                                      check1, if_false0);
 
     Node* if_true1 = graph()->NewNode(common()->IfTrue(), branch1);
     Node* cache_type_true1 = jsgraph()->ZeroConstant();  // Zero indicates proxy
 
     Node* if_false1 = graph()->NewNode(common()->IfFalse(), branch1);
     Node* cache_type_false1 = jsgraph()->OneConstant();  // One means slow check
 
     if_false0 = graph()->NewNode(common()->Merge(2), if_true1, if_false1);
     cache_type_false0 =
-        graph()->NewNode(common()->Phi(kMachAnyTagged, 2), cache_type_true1,
-                         cache_type_false1, if_false0);
+        graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                         cache_type_true1, cache_type_false1, if_false0);
 
     cache_array_false0 = cache_type;
     cache_length_false0 = efalse0 = graph()->NewNode(
-        machine()->Load(kMachAnyTagged), cache_array_false0,
+        machine()->Load(MachineType::AnyTagged()), cache_array_false0,
         jsgraph()->IntPtrConstant(FixedArray::kLengthOffset - kHeapObjectTag),
         efalse0, if_false0);
   }
 
   control = graph()->NewNode(common()->Merge(2), if_true0, if_false0);
   effect = graph()->NewNode(common()->EffectPhi(2), etrue0, efalse0, control);
   Node* cache_array =
-      graph()->NewNode(common()->Phi(kMachAnyTagged, 2), cache_array_true0,
-                       cache_array_false0, control);
+      graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                       cache_array_true0, cache_array_false0, control);
   Node* cache_length =
-      graph()->NewNode(common()->Phi(kMachAnyTagged, 2), cache_length_true0,
-                       cache_length_false0, control);
-  cache_type = graph()->NewNode(common()->Phi(kMachAnyTagged, 2),
-                                cache_type_true0, cache_type_false0, control);
+      graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                       cache_length_true0, cache_length_false0, control);
+  cache_type =
+      graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                       cache_type_true0, cache_type_false0, control);
 
   for (auto edge : node->use_edges()) {
     if (NodeProperties::IsEffectEdge(edge)) {
       edge.UpdateTo(effect);
     } else if (NodeProperties::IsControlEdge(edge)) {
       Node* const use = edge.from();
       if (use->opcode() == IrOpcode::kIfSuccess) {
         use->ReplaceUses(control);
         use->Kill();
       } else if (use->opcode() == IrOpcode::kIfException) {
@@ skipping 29 matching lines @@
   ReplaceWithRuntimeCall(node, Runtime::kForInStep);
 }
 
 
 void JSGenericLowering::LowerJSLoadMessage(Node* node) {
   ExternalReference message_address =
       ExternalReference::address_of_pending_message_obj(isolate());
   node->RemoveInput(NodeProperties::FirstContextIndex(node));
   node->InsertInput(zone(), 0, jsgraph()->ExternalConstant(message_address));
   node->InsertInput(zone(), 1, jsgraph()->IntPtrConstant(0));
-  NodeProperties::ChangeOp(node, machine()->Load(kMachAnyTagged));
+  NodeProperties::ChangeOp(node, machine()->Load(MachineType::AnyTagged()));
 }
 
 
 void JSGenericLowering::LowerJSStoreMessage(Node* node) {
   ExternalReference message_address =
       ExternalReference::address_of_pending_message_obj(isolate());
   node->RemoveInput(NodeProperties::FirstContextIndex(node));
   node->InsertInput(zone(), 0, jsgraph()->ExternalConstant(message_address));
   node->InsertInput(zone(), 1, jsgraph()->IntPtrConstant(0));
-  StoreRepresentation representation(kMachAnyTagged, kNoWriteBarrier);
+  StoreRepresentation representation(MachineType::AnyTagged(), kNoWriteBarrier);
   NodeProperties::ChangeOp(node, machine()->Store(representation));
 }
 
 
 void JSGenericLowering::LowerJSYield(Node* node) { UNIMPLEMENTED(); }
 
 
 void JSGenericLowering::LowerJSStackCheck(Node* node) {
   Node* effect = NodeProperties::GetEffectInput(node);
   Node* control = NodeProperties::GetControlInput(node);
 
   Node* limit = graph()->NewNode(
-      machine()->Load(kMachPtr),
+      machine()->Load(MachineType::Pointer()),
       jsgraph()->ExternalConstant(
           ExternalReference::address_of_stack_limit(isolate())),
       jsgraph()->IntPtrConstant(0), effect, control);
   Node* pointer = graph()->NewNode(machine()->LoadStackPointer());
 
   Node* check = graph()->NewNode(machine()->UintLessThan(), limit, pointer);
   Node* branch =
       graph()->NewNode(common()->Branch(BranchHint::kTrue), check, control);
 
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
@@ skipping 38 matching lines @@
 }
 
 
 MachineOperatorBuilder* JSGenericLowering::machine() const {
   return jsgraph()->machine();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8