Unify MachineType and RepType.

src/compiler/simplified-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/simplified-lowering.h"
 
 #include <deque>
 #include <queue>
 
 #include "src/compiler/common-operator.h"
@@ skipping 36 matching lines @@
   //     representation changes between uses that demand a particular
   //     representation and nodes that produce a different representation.
   LOWER
 };
 
 
 class RepresentationSelector {
  public:
   // Information for each node tracked during the fixpoint.
   struct NodeInfo {
-    RepTypeUnion use : 14;     // Union of all usages for the node.
+    MachineTypeUnion use : 14;     // Union of all usages for the node.
     bool queued : 1;           // Bookkeeping for the traversal.
     bool visited : 1;          // Bookkeeping for the traversal.
-    RepTypeUnion output : 14;  // Output type of the node.
+    MachineTypeUnion output : 14;  // Output type of the node.
   };
 
   RepresentationSelector(JSGraph* jsgraph, Zone* zone,
                          RepresentationChanger* changer)
       : jsgraph_(jsgraph),
         count_(jsgraph->graph()->NodeCount()),
         info_(zone->NewArray<NodeInfo>(count_)),
         nodes_(NodeVector::allocator_type(zone)),
         replacements_(NodeVector::allocator_type(zone)),
         contains_js_nodes_(false),
@@ skipping 37 matching lines @@
     for (NodeVector::iterator i = replacements_.begin();
          i != replacements_.end(); ++i) {
       Node* node = *i;
       Node* replacement = *(++i);
       node->ReplaceUses(replacement);
     }
   }
 
   // Enqueue {node} if the {use} contains new information for that node.
   // Add {node} to {nodes_} if this is the first time it's been visited.
-  void Enqueue(Node* node, RepTypeUnion use = 0) {
+  void Enqueue(Node* node, MachineTypeUnion use = 0) {
     if (phase_ != PROPAGATE) return;
     NodeInfo* info = GetInfo(node);
     if (!info->visited) {
       // First visit of this node.
       info->visited = true;
       info->queued = true;
       nodes_.push_back(node);
       queue_.push(node);
       TRACE(("  initial: "));
       info->use |= use;
@@ skipping 11 matching lines @@
       } else {
         TRACE((" inqueue: "));
       }
       info->use |= use;
       PrintUseInfo(node);
     }
   }
 
   bool lower() { return phase_ == LOWER; }
 
-  void Enqueue(Node* node, RepType use) {
-    Enqueue(node, static_cast<RepTypeUnion>(use));
+  void Enqueue(Node* node, MachineType use) {
+    Enqueue(node, static_cast<MachineTypeUnion>(use));
   }
 
-  void SetOutput(Node* node, RepTypeUnion output) {
+  void SetOutput(Node* node, MachineTypeUnion output) {
     // Every node should have at most one output representation. Note that
     // phis can have 0, if they have not been used in a representation-inducing
     // instruction.
     DCHECK((output & rMask) == 0 || IsPowerOf2(output & rMask));
     GetInfo(node)->output = output;
   }
 
   bool BothInputsAre(Node* node, Type* type) {
     DCHECK_EQ(2, node->InputCount());
     return NodeProperties::GetBounds(node->InputAt(0)).upper->Is(type) &&
            NodeProperties::GetBounds(node->InputAt(1)).upper->Is(type);
   }
 
-  void ProcessInput(Node* node, int index, RepTypeUnion use) {
+  void ProcessInput(Node* node, int index, MachineTypeUnion use) {
     Node* input = node->InputAt(index);
     if (phase_ == PROPAGATE) {
       // In the propagate phase, propagate the usage information backward.
       Enqueue(input, use);
     } else {
       // In the change phase, insert a change before the use if necessary.
       if ((use & rMask) == 0) return;  // No input requirement on the use.
-      RepTypeUnion output = GetInfo(input)->output;
+      MachineTypeUnion output = GetInfo(input)->output;
       if ((output & rMask & use) == 0) {
         // Output representation doesn't match usage.
         TRACE(("  change: #%d:%s(@%d #%d:%s) ", node->id(),
                node->op()->mnemonic(), index, input->id(),
                input->op()->mnemonic()));
         TRACE((" from "));
         PrintInfo(output);
         TRACE((" to "));
         PrintInfo(use);
         TRACE(("\n"));
         Node* n = changer_->GetRepresentationFor(input, output, use);
         node->ReplaceInput(index, n);
       }
     }
   }
 
-  static const RepTypeUnion kFloat64 = rFloat64 | tNumber;
-  static const RepTypeUnion kInt32 = rWord32 | tInt32;
-  static const RepTypeUnion kUint32 = rWord32 | tUint32;
-  static const RepTypeUnion kInt64 = rWord64 | tInt64;
-  static const RepTypeUnion kUint64 = rWord64 | tUint64;
-  static const RepTypeUnion kAnyTagged = rTagged | tAny;
-
   // The default, most general visitation case. For {node}, process all value,
   // context, effect, and control inputs, assuming that value inputs should have
   // {rTagged} representation and can observe all output values {tAny}.
   void VisitInputs(Node* node) {
     InputIter i = node->inputs().begin();
     for (int j = OperatorProperties::GetValueInputCount(node->op()); j > 0;
          ++i, j--) {
-      ProcessInput(node, i.index(), kAnyTagged);  // Value inputs
+      ProcessInput(node, i.index(), mAnyTagged);  // Value inputs
     }
     for (int j = OperatorProperties::GetContextInputCount(node->op()); j > 0;
          ++i, j--) {
-      ProcessInput(node, i.index(), kAnyTagged);  // Context inputs
+      ProcessInput(node, i.index(), mAnyTagged);  // Context inputs
     }
     for (int j = OperatorProperties::GetEffectInputCount(node->op()); j > 0;
          ++i, j--) {
       Enqueue(*i);  // Effect inputs: just visit
     }
     for (int j = OperatorProperties::GetControlInputCount(node->op()); j > 0;
          ++i, j--) {
       Enqueue(*i);  // Control inputs: just visit
     }
-    SetOutput(node, kAnyTagged);
+    SetOutput(node, mAnyTagged);
   }
 
   // Helper for binops of the I x I -> O variety.
-  void VisitBinop(Node* node, RepTypeUnion input_use, RepTypeUnion output) {
+  void VisitBinop(Node* node, MachineTypeUnion input_use,
+                  MachineTypeUnion output) {
     DCHECK_EQ(2, node->InputCount());
     ProcessInput(node, 0, input_use);
     ProcessInput(node, 1, input_use);
     SetOutput(node, output);
   }
 
   // Helper for unops of the I -> O variety.
-  void VisitUnop(Node* node, RepTypeUnion input_use, RepTypeUnion output) {
+  void VisitUnop(Node* node, MachineTypeUnion input_use,
+                 MachineTypeUnion output) {
     DCHECK_EQ(1, node->InputCount());
     ProcessInput(node, 0, input_use);
     SetOutput(node, output);
   }
 
   // Helper for leaf nodes.
-  void VisitLeaf(Node* node, RepTypeUnion output) {
+  void VisitLeaf(Node* node, MachineTypeUnion output) {
     DCHECK_EQ(0, node->InputCount());
     SetOutput(node, output);
   }
 
   // Helpers for specific types of binops.
-  void VisitFloat64Binop(Node* node) { VisitBinop(node, kFloat64, kFloat64); }
-  void VisitInt32Binop(Node* node) { VisitBinop(node, kInt32, kInt32); }
-  void VisitUint32Binop(Node* node) { VisitBinop(node, kUint32, kUint32); }
-  void VisitInt64Binop(Node* node) { VisitBinop(node, kInt64, kInt64); }
-  void VisitUint64Binop(Node* node) { VisitBinop(node, kUint64, kUint64); }
-  void VisitFloat64Cmp(Node* node) { VisitBinop(node, kFloat64, rBit); }
-  void VisitInt32Cmp(Node* node) { VisitBinop(node, kInt32, rBit); }
-  void VisitUint32Cmp(Node* node) { VisitBinop(node, kUint32, rBit); }
-  void VisitInt64Cmp(Node* node) { VisitBinop(node, kInt64, rBit); }
-  void VisitUint64Cmp(Node* node) { VisitBinop(node, kUint64, rBit); }
+  void VisitFloat64Binop(Node* node) { VisitBinop(node, mFloat64, mFloat64); }
+  void VisitInt32Binop(Node* node) { VisitBinop(node, mInt32, mInt32); }
+  void VisitUint32Binop(Node* node) { VisitBinop(node, mUint32, mUint32); }
+  void VisitInt64Binop(Node* node) { VisitBinop(node, mInt64, mInt64); }
+  void VisitUint64Binop(Node* node) { VisitBinop(node, mUint64, mUint64); }
+  void VisitFloat64Cmp(Node* node) { VisitBinop(node, mFloat64, rBit); }
+  void VisitInt32Cmp(Node* node) { VisitBinop(node, mInt32, rBit); }
+  void VisitUint32Cmp(Node* node) { VisitBinop(node, mUint32, rBit); }
+  void VisitInt64Cmp(Node* node) { VisitBinop(node, mInt64, rBit); }
+  void VisitUint64Cmp(Node* node) { VisitBinop(node, mUint64, rBit); }
 
   // Helper for handling phis.
-  void VisitPhi(Node* node, RepTypeUnion use) {
+  void VisitPhi(Node* node, MachineTypeUnion use) {
     // First, propagate the usage information to inputs of the phi.
     int values = OperatorProperties::GetValueInputCount(node->op());
     Node::Inputs inputs = node->inputs();
     for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
          ++iter, --values) {
       // Propagate {use} of the phi to value inputs, and 0 to control.
       // TODO(titzer): it'd be nice to have distinguished edge kinds here.
       ProcessInput(node, iter.index(), values > 0 ? use : 0);
     }
     // Phis adapt to whatever output representation their uses demand,
     // pushing representation changes to their inputs.
-    RepTypeUnion use_rep = GetUseInfo(node) & rMask;
-    RepTypeUnion use_type = GetUseInfo(node) & tMask;
-    RepTypeUnion rep = 0;
+    MachineTypeUnion use_rep = GetUseInfo(node) & rMask;
+    MachineTypeUnion use_type = GetUseInfo(node) & tMask;
+    MachineTypeUnion rep = 0;
     if (use_rep & rTagged) {
       rep = rTagged;  // Tagged overrides everything.
     } else if (use_rep & rFloat64) {
       rep = rFloat64;
     } else if (use_rep & rWord64) {
       rep = rWord64;
     } else if (use_rep & rWord32) {
       rep = rWord32;
     } else if (use_rep & rBit) {
       rep = rBit;
@@ skipping 26 matching lines @@
   Operator* Uint32Op(Node* node) {
     return changer_->Uint32OperatorFor(node->opcode());
   }
 
   Operator* Float64Op(Node* node) {
     return changer_->Float64OperatorFor(node->opcode());
   }
 
   // Dispatching routine for visiting the node {node} with the usage {use}.
   // Depending on the operator, propagate new usage info to the inputs.
-  void VisitNode(Node* node, RepTypeUnion use, SimplifiedLowering* lowering) {
+  void VisitNode(Node* node, MachineTypeUnion use,
+                 SimplifiedLowering* lowering) {
     switch (node->opcode()) {
       //------------------------------------------------------------------
       // Common operators.
       //------------------------------------------------------------------
       case IrOpcode::kStart:
       case IrOpcode::kDead:
         return VisitLeaf(node, 0);
       case IrOpcode::kParameter: {
         // TODO(titzer): use representation from linkage.
         Type* upper = NodeProperties::GetBounds(node).upper;
         ProcessInput(node, 0, 0);
         SetOutput(node, rTagged | changer_->TypeFromUpperBound(upper));
         return;
       }
       case IrOpcode::kInt32Constant:
         return VisitLeaf(node, rWord32);
       case IrOpcode::kInt64Constant:
         return VisitLeaf(node, rWord64);
       case IrOpcode::kFloat64Constant:
         return VisitLeaf(node, rFloat64);
       case IrOpcode::kExternalConstant:
-        return VisitLeaf(node, rPtr);
+        return VisitLeaf(node, mPtr);
       case IrOpcode::kNumberConstant:
         return VisitLeaf(node, rTagged);
       case IrOpcode::kHeapConstant:
         return VisitLeaf(node, rTagged);
 
       case IrOpcode::kEnd:
       case IrOpcode::kIfTrue:
       case IrOpcode::kIfFalse:
       case IrOpcode::kReturn:
       case IrOpcode::kMerge:
@@ skipping 20 matching lines @@
 #undef DEFINE_JS_CASE
         contains_js_nodes_ = true;
         VisitInputs(node);
         return SetOutput(node, rTagged);
 
       //------------------------------------------------------------------
       // Simplified operators.
       //------------------------------------------------------------------
       case IrOpcode::kBooleanNot: {
         if (lower()) {
-          RepTypeUnion input = GetInfo(node->InputAt(0))->output;
+          MachineTypeUnion input = GetInfo(node->InputAt(0))->output;
           if (input & rBit) {
             // BooleanNot(x: rBit) => WordEqual(x, #0)
             node->set_op(lowering->machine()->WordEqual());
             node->AppendInput(jsgraph_->zone(), jsgraph_->Int32Constant(0));
           } else {
             // BooleanNot(x: rTagged) => WordEqual(x, #false)
             node->set_op(lowering->machine()->WordEqual());
             node->AppendInput(jsgraph_->zone(), jsgraph_->FalseConstant());
           }
         } else {
@@ skipping 45 matching lines @@
       }
       case IrOpcode::kNumberMultiply:
       case IrOpcode::kNumberDivide:
       case IrOpcode::kNumberModulus: {
         // Float64Mul/Div/Mod
         VisitFloat64Binop(node);
         if (lower()) node->set_op(Float64Op(node));
         break;
       }
       case IrOpcode::kNumberToInt32: {
-        RepTypeUnion use_rep = use & rMask;
+        MachineTypeUnion use_rep = use & rMask;
         if (lower()) {
-          RepTypeUnion in = GetInfo(node->InputAt(0))->output;
+          MachineTypeUnion in = GetInfo(node->InputAt(0))->output;
           if ((in & tMask) == tInt32 || (in & rMask) == rWord32) {
             // If the input has type int32, or is already a word32, just change
             // representation if necessary.
             VisitUnop(node, tInt32 | use_rep, tInt32 | use_rep);
             DeferReplacement(node, node->InputAt(0));
           } else {
             // Require the input in float64 format and perform truncation.
             // TODO(turbofan): could also avoid the truncation with a tag check.
             VisitUnop(node, tInt32 | rFloat64, tInt32 | rWord32);
             // TODO(titzer): should be a truncation.
             node->set_op(lowering->machine()->ChangeFloat64ToInt32());
           }
         } else {
           // Propagate a type to the input, but pass through representation.
           VisitUnop(node, tInt32, tInt32 | use_rep);
         }
         break;
       }
       case IrOpcode::kNumberToUint32: {
-        RepTypeUnion use_rep = use & rMask;
+        MachineTypeUnion use_rep = use & rMask;
         if (lower()) {
-          RepTypeUnion in = GetInfo(node->InputAt(0))->output;
+          MachineTypeUnion in = GetInfo(node->InputAt(0))->output;
           if ((in & tMask) == tUint32 || (in & rMask) == rWord32) {
             // The input has type int32, just change representation.
             VisitUnop(node, tUint32 | use_rep, tUint32 | use_rep);
             DeferReplacement(node, node->InputAt(0));
           } else {
             // Require the input in float64 format to perform truncation.
             // TODO(turbofan): could also avoid the truncation with a tag check.
             VisitUnop(node, tUint32 | rFloat64, tUint32 | rWord32);
             // TODO(titzer): should be a truncation.
             node->set_op(lowering->machine()->ChangeFloat64ToUint32());
           }
         } else {
           // Propagate a type to the input, but pass through representation.
           VisitUnop(node, tUint32, tUint32 | use_rep);
         }
         break;
       }
       case IrOpcode::kReferenceEqual: {
-        VisitBinop(node, kAnyTagged, rBit);
+        VisitBinop(node, mAnyTagged, rBit);
         if (lower()) node->set_op(lowering->machine()->WordEqual());
         break;
       }
       case IrOpcode::kStringEqual: {
-        VisitBinop(node, kAnyTagged, rBit);
+        VisitBinop(node, mAnyTagged, rBit);
         // TODO(titzer): lower StringEqual to stub/runtime call.
         break;
       }
       case IrOpcode::kStringLessThan: {
-        VisitBinop(node, kAnyTagged, rBit);
+        VisitBinop(node, mAnyTagged, rBit);
         // TODO(titzer): lower StringLessThan to stub/runtime call.
         break;
       }
       case IrOpcode::kStringLessThanOrEqual: {
-        VisitBinop(node, kAnyTagged, rBit);
+        VisitBinop(node, mAnyTagged, rBit);
         // TODO(titzer): lower StringLessThanOrEqual to stub/runtime call.
         break;
       }
       case IrOpcode::kStringAdd: {
-        VisitBinop(node, kAnyTagged, kAnyTagged);
+        VisitBinop(node, mAnyTagged, mAnyTagged);
         // TODO(titzer): lower StringAdd to stub/runtime call.
         break;
       }
       case IrOpcode::kLoadField: {
         FieldAccess access = FieldAccessOf(node->op());
         ProcessInput(node, 0, changer_->TypeForBasePointer(access));
-        SetOutput(node, changer_->TypeForField(access));
+        SetOutput(node, access.machine_type);
         if (lower()) lowering->DoLoadField(node);
         break;
       }
       case IrOpcode::kStoreField: {
         FieldAccess access = FieldAccessOf(node->op());
         ProcessInput(node, 0, changer_->TypeForBasePointer(access));
-        ProcessInput(node, 1, changer_->TypeForField(access));
+        ProcessInput(node, 1, access.machine_type);
         SetOutput(node, 0);
         if (lower()) lowering->DoStoreField(node);
         break;
       }
       case IrOpcode::kLoadElement: {
         ElementAccess access = ElementAccessOf(node->op());
         ProcessInput(node, 0, changer_->TypeForBasePointer(access));
-        ProcessInput(node, 1, kInt32);  // element index
-        SetOutput(node, changer_->TypeForElement(access));
+        ProcessInput(node, 1, mInt32);  // element index
+        SetOutput(node, access.machine_type);
         if (lower()) lowering->DoLoadElement(node);
         break;
       }
       case IrOpcode::kStoreElement: {
         ElementAccess access = ElementAccessOf(node->op());
         ProcessInput(node, 0, changer_->TypeForBasePointer(access));
-        ProcessInput(node, 1, kInt32);  // element index
-        ProcessInput(node, 2, changer_->TypeForElement(access));
+        ProcessInput(node, 1, mInt32);  // element index
+        ProcessInput(node, 2, access.machine_type);
         SetOutput(node, 0);
         if (lower()) lowering->DoStoreElement(node);
         break;
       }
 
       //------------------------------------------------------------------
       // Machine-level operators.
       //------------------------------------------------------------------
       case IrOpcode::kLoad: {
         // TODO(titzer): machine loads/stores need to know BaseTaggedness!?
-        RepType tBase = rTagged;
-        MachineType rep = OpParameter<MachineType>(node);
+        MachineType tBase = rTagged;
+        MachineType machine_type = OpParameter<MachineType>(node);
         ProcessInput(node, 0, tBase);   // pointer or object
-        ProcessInput(node, 1, kInt32);  // index
-        SetOutput(node, changer_->TypeForMachineType(rep));
+        ProcessInput(node, 1, mInt32);  // index
+        SetOutput(node, machine_type);
         break;
       }
       case IrOpcode::kStore: {
         // TODO(titzer): machine loads/stores need to know BaseTaggedness!?
-        RepType tBase = rTagged;
+        MachineType tBase = rTagged;
         StoreRepresentation rep = OpParameter<StoreRepresentation>(node);
         ProcessInput(node, 0, tBase);   // pointer or object
-        ProcessInput(node, 1, kInt32);  // index
-        ProcessInput(node, 2, changer_->TypeForMachineType(rep.rep));
+        ProcessInput(node, 1, mInt32);  // index
+        ProcessInput(node, 2, rep.machine_type);
         SetOutput(node, 0);
         break;
       }
       case IrOpcode::kWord32Shr:
         // We output unsigned int32 for shift right because JavaScript.
         return VisitBinop(node, rWord32, rWord32 | tUint32);
       case IrOpcode::kWord32And:
       case IrOpcode::kWord32Or:
       case IrOpcode::kWord32Xor:
       case IrOpcode::kWord32Shl:
@@ skipping 90 matching lines @@
     }
     // TODO(titzer) node->RemoveAllInputs();  // Node is now dead.
   }
 
   void PrintUseInfo(Node* node) {
     TRACE(("#%d:%-20s ", node->id(), node->op()->mnemonic()));
     PrintInfo(GetUseInfo(node));
     TRACE(("\n"));
   }
 
-  void PrintInfo(RepTypeUnion info) {
+  void PrintInfo(MachineTypeUnion info) {
     if (FLAG_trace_representation) {
-      char buf[REP_TYPE_STRLEN];
-      RenderRepTypeUnion(buf, info);
-      TRACE(("%s", buf));
+      OFStream os(stdout);
+      PrintMachineTypeUnionTo(os, info);
     }
   }
 
  private:
   JSGraph* jsgraph_;
   int count_;                       // number of nodes in the graph
   NodeInfo* info_;                  // node id -> usage information
   NodeVector nodes_;                // collected nodes
   NodeVector replacements_;         // replacements to be done after lowering
   bool contains_js_nodes_;          // {true} if a JS operator was seen
   Phase phase_;                     // current phase of algorithm
   RepresentationChanger* changer_;  // for inserting representation changes
 
   std::queue<Node*, std::deque<Node*, NodePtrZoneAllocator> > queue_;
 
   NodeInfo* GetInfo(Node* node) {
     DCHECK(node->id() >= 0);
     DCHECK(node->id() < count_);
     return &info_[node->id()];
   }
 
-  RepTypeUnion GetUseInfo(Node* node) { return GetInfo(node)->use; }
+  MachineTypeUnion GetUseInfo(Node* node) { return GetInfo(node)->use; }
 };
 
 
 Node* SimplifiedLowering::IsTagged(Node* node) {
   // TODO(titzer): factor this out to a TaggingScheme abstraction.
   STATIC_ASSERT(kSmiTagMask == 1);  // Only works if tag is the low bit.
   return graph()->NewNode(machine()->WordAnd(), node,
                           jsgraph()->Int32Constant(kSmiTagMask));
 }
 
@@ skipping 38 matching lines @@
       continue;
     }
     ++iter;
   }
 }
 
 
 void SimplifiedLowering::DoChangeTaggedToUI32(Node* node, Node* effect,
                                               Node* control, bool is_signed) {
   // if (IsTagged(val))
-  // ConvertFloat64To(Int32|Uint32)(Load[kMachineFloat64](input, #value_offset))
+  // ConvertFloat64To(Int32|Uint32)(Load[mFloat64](input, #value_offset))
   // else Untag(val)
   Node* val = node->InputAt(0);
   Node* branch = graph()->NewNode(common()->Branch(), IsTagged(val), control);
 
   // true branch.
   Node* tbranch = graph()->NewNode(common()->IfTrue(), branch);
   Node* loaded = graph()->NewNode(
-      machine()->Load(kMachineFloat64), val,
+      machine()->Load(mFloat64), val,
       OffsetMinusTagConstant(HeapNumber::kValueOffset), effect);
   Operator* op = is_signed ? machine()->ChangeFloat64ToInt32()
                            : machine()->ChangeFloat64ToUint32();
   Node* converted = graph()->NewNode(op, loaded);
 
   // false branch.
   Node* fbranch = graph()->NewNode(common()->IfFalse(), branch);
   Node* untagged = Untag(val);
 
   // merge.
   Node* merge = graph()->NewNode(common()->Merge(2), tbranch, fbranch);
   Node* phi = graph()->NewNode(common()->Phi(2), converted, untagged, merge);
   UpdateControlSuccessors(control, merge);
   branch->ReplaceInput(1, control);
   node->ReplaceUses(phi);
 }
 
 
 void SimplifiedLowering::DoChangeTaggedToFloat64(Node* node, Node* effect,
                                                  Node* control) {
-  // if (IsTagged(input)) Load[kMachineFloat64](input, #value_offset)
+  // if (IsTagged(input)) Load[mFloat64](input, #value_offset)
   // else ConvertFloat64(Untag(input))
   Node* val = node->InputAt(0);
   Node* branch = graph()->NewNode(common()->Branch(), IsTagged(val), control);
 
   // true branch.
   Node* tbranch = graph()->NewNode(common()->IfTrue(), branch);
   Node* loaded = graph()->NewNode(
-      machine()->Load(kMachineFloat64), val,
+      machine()->Load(mFloat64), val,
       OffsetMinusTagConstant(HeapNumber::kValueOffset), effect);
 
   // false branch.
   Node* fbranch = graph()->NewNode(common()->IfFalse(), branch);
   Node* untagged = Untag(val);
   Node* converted =
       graph()->NewNode(machine()->ChangeInt32ToFloat64(), untagged);
 
   // merge.
   Node* merge = graph()->NewNode(common()->Merge(2), tbranch, fbranch);
@@ skipping 80 matching lines @@
   UpdateControlSuccessors(control, merge);
   branch->ReplaceInput(1, control);
   node->ReplaceUses(phi);
 }
 
 
 static WriteBarrierKind ComputeWriteBarrierKind(BaseTaggedness base_is_tagged,
                                                 MachineType representation,
                                                 Type* type) {
   // TODO(turbofan): skip write barriers for Smis, etc.
-  if (base_is_tagged == kTaggedBase && representation == kMachineTagged) {
+  if (base_is_tagged == kTaggedBase &&
+      RepresentationOf(representation) == rTagged) {
     // Write barriers are only for writes into heap objects (i.e. tagged base).
     return kFullWriteBarrier;
   }
   return kNoWriteBarrier;
 }
 
 
 void SimplifiedLowering::DoLoadField(Node* node) {
   const FieldAccess& access = FieldAccessOf(node->op());
-  node->set_op(machine_.Load(access.representation));
+  node->set_op(machine_.Load(access.machine_type));
   Node* offset = jsgraph()->Int32Constant(access.offset - access.tag());
   node->InsertInput(zone(), 1, offset);
 }
 
 
 void SimplifiedLowering::DoStoreField(Node* node) {
   const FieldAccess& access = FieldAccessOf(node->op());
   WriteBarrierKind kind = ComputeWriteBarrierKind(
-      access.base_is_tagged, access.representation, access.type);
-  node->set_op(machine_.Store(access.representation, kind));
+      access.base_is_tagged, access.machine_type, access.type);
+  node->set_op(machine_.Store(access.machine_type, kind));
   Node* offset = jsgraph()->Int32Constant(access.offset - access.tag());
   node->InsertInput(zone(), 1, offset);
 }
 
 
 Node* SimplifiedLowering::ComputeIndex(const ElementAccess& access,
                                        Node* index) {
-  int element_size = 0;
-  switch (access.representation) {
-    case kMachineTagged:
-      element_size = kPointerSize;
-      break;
-    case kMachineWord8:
-      element_size = 1;
-      break;
-    case kMachineWord16:
-      element_size = 2;
-      break;
-    case kMachineWord32:
-      element_size = 4;
-      break;
-    case kMachineWord64:
-    case kMachineFloat64:
-      element_size = 8;
-      break;
-    case kMachineLast:
-      UNREACHABLE();
-      break;
-  }
+  int element_size = ElementSizeOf(access.machine_type);
   if (element_size != 1) {
     index = graph()->NewNode(machine()->Int32Mul(),
                              jsgraph()->Int32Constant(element_size), index);
   }
   int fixed_offset = access.header_size - access.tag();
   if (fixed_offset == 0) return index;
   return graph()->NewNode(machine()->Int32Add(), index,
                           jsgraph()->Int32Constant(fixed_offset));
 }
 
 
 void SimplifiedLowering::DoLoadElement(Node* node) {
   const ElementAccess& access = ElementAccessOf(node->op());
-  node->set_op(machine_.Load(access.representation));
+  node->set_op(machine_.Load(access.machine_type));
   node->ReplaceInput(1, ComputeIndex(access, node->InputAt(1)));
 }
 
 
 void SimplifiedLowering::DoStoreElement(Node* node) {
   const ElementAccess& access = ElementAccessOf(node->op());
   WriteBarrierKind kind = ComputeWriteBarrierKind(
-      access.base_is_tagged, access.representation, access.type);
-  node->set_op(machine_.Store(access.representation, kind));
+      access.base_is_tagged, access.machine_type, access.type);
+  node->set_op(machine_.Store(access.machine_type, kind));
   node->ReplaceInput(1, ComputeIndex(access, node->InputAt(1)));
 }
 
 
 void SimplifiedLowering::Lower(Node* node) {}
 
 
 void SimplifiedLowering::LowerChange(Node* node, Node* effect, Node* control) {
   switch (node->opcode()) {
     case IrOpcode::kChangeTaggedToInt32:
@@ skipping 22 matching lines @@
       break;
     default:
       UNREACHABLE();
       break;
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8