[turbofan] Make MachineType a pair of enums.

src/compiler/change-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/compiler/change-lowering.h"
 
 #include "src/address-map.h"
 #include "src/code-factory.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/linkage.h"
@@ skipping 69 matching lines @@
   Node* context = jsgraph()->NoContextConstant();
   Node* effect = graph()->NewNode(common()->BeginRegion(), graph()->start());
   if (!allocate_heap_number_operator_.is_set()) {
     CallDescriptor* descriptor = Linkage::GetStubCallDescriptor(
         isolate(), jsgraph()->zone(), callable.descriptor(), 0,
         CallDescriptor::kNoFlags, Operator::kNoThrow);
     allocate_heap_number_operator_.set(common()->Call(descriptor));
   }
   Node* heap_number = graph()->NewNode(allocate_heap_number_operator_.get(),
                                        target, context, effect, control);
-  Node* store = graph()->NewNode(
-      machine()->Store(StoreRepresentation(kMachFloat64, kNoWriteBarrier)),
-      heap_number, HeapNumberValueIndexConstant(), value, heap_number, control);
+  Node* store = graph()->NewNode(machine()->Store(StoreRepresentation(
+                                     MachineType::Float64(), kNoWriteBarrier)),
+                                 heap_number, HeapNumberValueIndexConstant(),
+                                 value, heap_number, control);
   return graph()->NewNode(common()->FinishRegion(), heap_number, store);
 }
 
 
 Node* ChangeLowering::ChangeInt32ToFloat64(Node* value) {
   return graph()->NewNode(machine()->ChangeInt32ToFloat64(), value);
 }
 
 
 Node* ChangeLowering::ChangeInt32ToSmi(Node* value) {
@@ skipping 25 matching lines @@
 
 Node* ChangeLowering::ChangeUint32ToSmi(Node* value) {
   if (machine()->Is64()) {
     value = graph()->NewNode(machine()->ChangeUint32ToUint64(), value);
   }
   return graph()->NewNode(machine()->WordShl(), value, SmiShiftBitsConstant());
 }
 
 
 Node* ChangeLowering::LoadHeapNumberValue(Node* value, Node* control) {
-  return graph()->NewNode(machine()->Load(kMachFloat64), value,
+  return graph()->NewNode(machine()->Load(MachineType::Float64()), value,
                           HeapNumberValueIndexConstant(), graph()->start(),
                           control);
 }
 
 
 Node* ChangeLowering::TestNotSmi(Node* value) {
   STATIC_ASSERT(kSmiTag == 0);
   STATIC_ASSERT(kSmiTagMask == 1);
   return graph()->NewNode(machine()->WordAnd(), value,
                           jsgraph()->IntPtrConstant(kSmiTagMask));
 }
 
 
 Reduction ChangeLowering::ChangeBitToBool(Node* value, Node* control) {
-  return Replace(graph()->NewNode(common()->Select(kMachAnyTagged), value,
-                                  jsgraph()->TrueConstant(),
-                                  jsgraph()->FalseConstant()));
+  return Replace(
+      graph()->NewNode(common()->Select(MachineRepresentation::kTagged), value,
+                       jsgraph()->TrueConstant(), jsgraph()->FalseConstant()));
 }
 
 
 Reduction ChangeLowering::ChangeBoolToBit(Node* value) {
   return Replace(graph()->NewNode(machine()->WordEqual(), value,
                                   jsgraph()->TrueConstant()));
 }
 
 
 Reduction ChangeLowering::ChangeFloat64ToTagged(Node* value, Node* control) {
@@ skipping 59 matching lines @@
     if_box = graph()->NewNode(common()->Merge(2), if_ovf, if_box);
 
     if_smi = graph()->NewNode(common()->IfFalse(), branch_ovf);
     vsmi = graph()->NewNode(common()->Projection(0), smi_tag);
   }
 
   // Allocate the box for the {value}.
   vbox = AllocateHeapNumberWithValue(value, if_box);
 
   control = graph()->NewNode(common()->Merge(2), if_smi, if_box);
-  value =
-      graph()->NewNode(common()->Phi(kMachAnyTagged, 2), vsmi, vbox, control);
+  value = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                           vsmi, vbox, control);
   return Replace(value);
 }
 
 
 Reduction ChangeLowering::ChangeInt32ToTagged(Node* value, Node* control) {
   if (machine()->Is64() ||
       NodeProperties::GetType(value)->Is(Type::SignedSmall())) {
     return Replace(ChangeInt32ToSmi(value));
   }
 
   Node* add = graph()->NewNode(machine()->Int32AddWithOverflow(), value, value);
 
   Node* ovf = graph()->NewNode(common()->Projection(1), add);
   Node* branch =
       graph()->NewNode(common()->Branch(BranchHint::kFalse), ovf, control);
 
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* vtrue =
       AllocateHeapNumberWithValue(ChangeInt32ToFloat64(value), if_true);
 
   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
   Node* vfalse = graph()->NewNode(common()->Projection(0), add);
 
   Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
-  Node* phi =
-      graph()->NewNode(common()->Phi(kMachAnyTagged, 2), vtrue, vfalse, merge);
+  Node* phi = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                               vtrue, vfalse, merge);
 
   return Replace(phi);
 }
 
 
 Reduction ChangeLowering::ChangeTaggedToUI32(Node* value, Node* control,
                                              Signedness signedness) {
   if (NodeProperties::GetType(value)->Is(Type::TaggedSigned())) {
     return Replace(ChangeSmiToInt32(value));
   }
 
-  const MachineType type = (signedness == kSigned) ? kMachInt32 : kMachUint32;
   const Operator* op = (signedness == kSigned)
                            ? machine()->ChangeFloat64ToInt32()
                            : machine()->ChangeFloat64ToUint32();
 
   if (NodeProperties::GetType(value)->Is(Type::TaggedPointer())) {
     return Replace(graph()->NewNode(op, LoadHeapNumberValue(value, control)));
   }
 
   Node* check = TestNotSmi(value);
   Node* branch =
       graph()->NewNode(common()->Branch(BranchHint::kFalse), check, control);
 
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* vtrue = graph()->NewNode(op, LoadHeapNumberValue(value, if_true));
 
   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
   Node* vfalse = ChangeSmiToInt32(value);
 
   Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
-  Node* phi = graph()->NewNode(common()->Phi(type, 2), vtrue, vfalse, merge);
+  Node* phi = graph()->NewNode(common()->Phi(MachineRepresentation::kWord32, 2),
+                               vtrue, vfalse, merge);
 
   return Replace(phi);
 }
 
 
 namespace {
 
 bool CanCover(Node* value, IrOpcode::Value opcode) {
   if (value->opcode() != opcode) return false;
   bool first = true;
@@ skipping 18 matching lines @@
     //     if IsSmi(y) then ChangeSmiToFloat64(y)
     //     else LoadHeapNumberValue(y)
     Node* const object = NodeProperties::GetValueInput(value, 0);
     Node* const context = NodeProperties::GetContextInput(value);
     Node* const frame_state = NodeProperties::GetFrameStateInput(value, 0);
     Node* const effect = NodeProperties::GetEffectInput(value);
     Node* const control = NodeProperties::GetControlInput(value);
 
     const Operator* merge_op = common()->Merge(2);
     const Operator* ephi_op = common()->EffectPhi(2);
-    const Operator* phi_op = common()->Phi(kMachFloat64, 2);
+    const Operator* phi_op = common()->Phi(MachineRepresentation::kFloat64, 2);
 
     Node* check1 = TestNotSmi(object);
     Node* branch1 =
         graph()->NewNode(common()->Branch(BranchHint::kFalse), check1, control);
 
     Node* if_true1 = graph()->NewNode(common()->IfTrue(), branch1);
     Node* vtrue1 = graph()->NewNode(value->op(), object, context, frame_state,
                                     effect, if_true1);
     Node* etrue1 = vtrue1;
 
@@ skipping 36 matching lines @@
   Node* branch =
       graph()->NewNode(common()->Branch(BranchHint::kFalse), check, control);
 
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* vtrue = LoadHeapNumberValue(value, if_true);
 
   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
   Node* vfalse = ChangeSmiToFloat64(value);
 
   Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
-  Node* phi =
-      graph()->NewNode(common()->Phi(kMachFloat64, 2), vtrue, vfalse, merge);
+  Node* phi = graph()->NewNode(
+      common()->Phi(MachineRepresentation::kFloat64, 2), vtrue, vfalse, merge);
 
   return Replace(phi);
 }
 
 
 Reduction ChangeLowering::ChangeUint32ToTagged(Node* value, Node* control) {
   if (NodeProperties::GetType(value)->Is(Type::UnsignedSmall())) {
     return Replace(ChangeUint32ToSmi(value));
   }
 
   Node* check = graph()->NewNode(machine()->Uint32LessThanOrEqual(), value,
                                  SmiMaxValueConstant());
   Node* branch =
       graph()->NewNode(common()->Branch(BranchHint::kTrue), check, control);
 
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* vtrue = ChangeUint32ToSmi(value);
 
   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
   Node* vfalse =
       AllocateHeapNumberWithValue(ChangeUint32ToFloat64(value), if_false);
 
   Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
-  Node* phi =
-      graph()->NewNode(common()->Phi(kMachAnyTagged, 2), vtrue, vfalse, merge);
+  Node* phi = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
+                               vtrue, vfalse, merge);
 
   return Replace(phi);
 }
 
 
 namespace {
 
 WriteBarrierKind ComputeWriteBarrierKind(BaseTaggedness base_is_tagged,
-                                         MachineType representation,
+                                         MachineRepresentation representation,
                                          Type* field_type, Type* input_type) {
   if (field_type->Is(Type::TaggedSigned()) ||
       input_type->Is(Type::TaggedSigned())) {
     // Write barriers are only for writes of heap objects.
     return kNoWriteBarrier;
   }
   if (input_type->Is(Type::BooleanOrNullOrUndefined())) {
     // Write barriers are not necessary when storing true, false, null or
     // undefined, because these special oddballs are always in the root set.
     return kNoWriteBarrier;
   }
   if (base_is_tagged == kTaggedBase &&
-      RepresentationOf(representation) == kRepTagged) {
+      representation == MachineRepresentation::kTagged) {
     if (input_type->IsConstant() &&
         input_type->AsConstant()->Value()->IsHeapObject()) {
       Handle<HeapObject> input =
           Handle<HeapObject>::cast(input_type->AsConstant()->Value());
       if (input->IsMap()) {
         // Write barriers for storing maps are cheaper.
         return kMapWriteBarrier;
       }
       Isolate* const isolate = input->GetIsolate();
       RootIndexMap root_index_map(isolate);
@@ skipping 24 matching lines @@
   node->InsertInput(graph()->zone(), 1, offset);
   NodeProperties::ChangeOp(node, machine()->Load(access.machine_type));
   return Changed(node);
 }
 
 
 Reduction ChangeLowering::StoreField(Node* node) {
   const FieldAccess& access = FieldAccessOf(node->op());
   Type* type = NodeProperties::GetType(node->InputAt(1));
   WriteBarrierKind kind = ComputeWriteBarrierKind(
-      access.base_is_tagged, access.machine_type, access.type, type);
+      access.base_is_tagged, access.machine_type.representation(), access.type,
+      type);
   Node* offset = jsgraph()->IntPtrConstant(access.offset - access.tag());
   node->InsertInput(graph()->zone(), 1, offset);
   NodeProperties::ChangeOp(
       node, machine()->Store(StoreRepresentation(access.machine_type, kind)));
   return Changed(node);
 }
 
 
 Node* ChangeLowering::ComputeIndex(const ElementAccess& access,
                                    Node* const key) {
   Node* index = key;
-  const int element_size_shift = ElementSizeLog2Of(access.machine_type);
+  const int element_size_shift =
+      ElementSizeLog2Of(access.machine_type.representation());
   if (element_size_shift) {
     index = graph()->NewNode(machine()->Word32Shl(), index,
                              jsgraph()->Int32Constant(element_size_shift));
   }
   const int fixed_offset = access.header_size - access.tag();
   if (fixed_offset) {
     index = graph()->NewNode(machine()->Int32Add(), index,
                              jsgraph()->Int32Constant(fixed_offset));
   }
   if (machine()->Is64()) {
@@ skipping 12 matching lines @@
   NodeProperties::ChangeOp(node, machine()->Load(access.machine_type));
   return Changed(node);
 }
 
 
 Reduction ChangeLowering::StoreElement(Node* node) {
   const ElementAccess& access = ElementAccessOf(node->op());
   Type* type = NodeProperties::GetType(node->InputAt(2));
   node->ReplaceInput(1, ComputeIndex(access, node->InputAt(1)));
   NodeProperties::ChangeOp(
-      node,
-      machine()->Store(StoreRepresentation(
-          access.machine_type,
-          ComputeWriteBarrierKind(access.base_is_tagged, access.machine_type,
-                                  access.type, type))));
+      node, machine()->Store(StoreRepresentation(
+                access.machine_type,
+                ComputeWriteBarrierKind(access.base_is_tagged,
+                                        access.machine_type.representation(),
+                                        access.type, type))));
   return Changed(node);
 }
 
 
 Reduction ChangeLowering::Allocate(Node* node) {
   PretenureFlag pretenure = OpParameter<PretenureFlag>(node->op());
   if (pretenure == NOT_TENURED) {
     Callable callable = CodeFactory::AllocateInNewSpace(isolate());
     Node* target = jsgraph()->HeapConstant(callable.code());
     CallDescriptor* descriptor = Linkage::GetStubCallDescriptor(
@@ skipping 34 matching lines @@
 }
 
 
 MachineOperatorBuilder* ChangeLowering::machine() const {
   return jsgraph()->machine();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8