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));
+    DCHECK((output & kRepMask) == 0 || IsPowerOf2(output & kRepMask));
     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;
-      if ((output & rMask & use) == 0) {
+      if ((use & kRepMask) == 0) return;  // No input requirement on the use.
+      MachineTypeUnion output = GetInfo(input)->output;
+      if ((output & kRepMask & 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}.
+  // {kRepTagged} representation and can observe all output values {kTypeAny}.
   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(), kMachAnyTagged);  // Value inputs
     }
     for (int j = OperatorProperties::GetContextInputCount(node->op()); j > 0;
          ++i, j--) {
-      ProcessInput(node, i.index(), kAnyTagged);  // Context inputs
+      ProcessInput(node, i.index(), kMachAnyTagged);  // 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, kMachAnyTagged);
   }
 
   // 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, kMachFloat64, kMachFloat64);
+  }
+  void VisitInt32Binop(Node* node) { VisitBinop(node, kMachInt32, kMachInt32); }
+  void VisitUint32Binop(Node* node) {
+    VisitBinop(node, kMachUint32, kMachUint32);
+  }
+  void VisitInt64Binop(Node* node) { VisitBinop(node, kMachInt64, kMachInt64); }
+  void VisitUint64Binop(Node* node) {
+    VisitBinop(node, kMachUint64, kMachUint64);
+  }
+  void VisitFloat64Cmp(Node* node) { VisitBinop(node, kMachFloat64, kRepBit); }
+  void VisitInt32Cmp(Node* node) { VisitBinop(node, kMachInt32, kRepBit); }
+  void VisitUint32Cmp(Node* node) { VisitBinop(node, kMachUint32, kRepBit); }
+  void VisitInt64Cmp(Node* node) { VisitBinop(node, kMachInt64, kRepBit); }
+  void VisitUint64Cmp(Node* node) { VisitBinop(node, kMachUint64, kRepBit); }
 
   // 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;
-    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;
+    MachineTypeUnion use_rep = GetUseInfo(node) & kRepMask;
+    MachineTypeUnion use_type = GetUseInfo(node) & kTypeMask;
+    MachineTypeUnion rep = 0;
+    if (use_rep & kRepTagged) {
+      rep = kRepTagged;  // Tagged overrides everything.
+    } else if (use_rep & kRepFloat64) {
+      rep = kRepFloat64;
+    } else if (use_rep & kRepWord64) {
+      rep = kRepWord64;
+    } else if (use_rep & kRepWord32) {
+      rep = kRepWord32;
+    } else if (use_rep & kRepBit) {
+      rep = kRepBit;
     } else {
       // There was no representation associated with any of the uses.
       // TODO(titzer): Select the best rep using phi's type, not the usage type?
-      if (use_type & tAny) {
-        rep = rTagged;
-      } else if (use_type & tNumber) {
-        rep = rFloat64;
-      } else if (use_type & tInt64 || use_type & tUint64) {
-        rep = rWord64;
-      } else if (use_type & tInt32 || use_type & tUint32) {
-        rep = rWord32;
-      } else if (use_type & tBool) {
-        rep = rBit;
+      if (use_type & kTypeAny) {
+        rep = kRepTagged;
+      } else if (use_type & kTypeNumber) {
+        rep = kRepFloat64;
+      } else if (use_type & kTypeInt64 || use_type & kTypeUint64) {
+        rep = kRepWord64;
+      } else if (use_type & kTypeInt32 || use_type & kTypeUint32) {
+        rep = kRepWord32;
+      } else if (use_type & kTypeBool) {
+        rep = kRepBit;
       } else {
         UNREACHABLE();  // should have at least a usage type!
       }
     }
     // Preserve the usage type, but set the representation.
     Type* upper = NodeProperties::GetBounds(node).upper;
     SetOutput(node, rep | changer_->TypeFromUpperBound(upper));
   }
 
   Operator* Int32Op(Node* node) {
     return changer_->Int32OperatorFor(node->opcode());
   }
 
   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));
+        SetOutput(node, kRepTagged | changer_->TypeFromUpperBound(upper));
         return;
       }
       case IrOpcode::kInt32Constant:
-        return VisitLeaf(node, rWord32);
+        return VisitLeaf(node, kRepWord32);
       case IrOpcode::kInt64Constant:
-        return VisitLeaf(node, rWord64);
+        return VisitLeaf(node, kRepWord64);
       case IrOpcode::kFloat64Constant:
-        return VisitLeaf(node, rFloat64);
+        return VisitLeaf(node, kRepFloat64);
       case IrOpcode::kExternalConstant:
-        return VisitLeaf(node, rPtr);
+        return VisitLeaf(node, kMachPtr);
       case IrOpcode::kNumberConstant:
-        return VisitLeaf(node, rTagged);
+        return VisitLeaf(node, kRepTagged);
       case IrOpcode::kHeapConstant:
-        return VisitLeaf(node, rTagged);
+        return VisitLeaf(node, kRepTagged);
 
       case IrOpcode::kEnd:
       case IrOpcode::kIfTrue:
       case IrOpcode::kIfFalse:
       case IrOpcode::kReturn:
       case IrOpcode::kMerge:
       case IrOpcode::kThrow:
         return VisitInputs(node);  // default visit for all node inputs.
 
       case IrOpcode::kBranch:
-        ProcessInput(node, 0, rBit);
+        ProcessInput(node, 0, kRepBit);
         Enqueue(NodeProperties::GetControlInput(node, 0));
         break;
       case IrOpcode::kPhi:
         return VisitPhi(node, use);
 
 //------------------------------------------------------------------
 // JavaScript operators.
 //------------------------------------------------------------------
 // For now, we assume that all JS operators were too complex to lower
 // to Simplified and that they will always require tagged value inputs
 // and produce tagged value outputs.
 // TODO(turbofan): it might be possible to lower some JSOperators here,
 // but that responsibility really lies in the typed lowering phase.
 #define DEFINE_JS_CASE(x) case IrOpcode::k##x:
         JS_OP_LIST(DEFINE_JS_CASE)
 #undef DEFINE_JS_CASE
         contains_js_nodes_ = true;
         VisitInputs(node);
-        return SetOutput(node, rTagged);
+        return SetOutput(node, kRepTagged);
 
       //------------------------------------------------------------------
       // Simplified operators.
       //------------------------------------------------------------------
       case IrOpcode::kBooleanNot: {
         if (lower()) {
-          RepTypeUnion input = GetInfo(node->InputAt(0))->output;
-          if (input & rBit) {
-            // BooleanNot(x: rBit) => WordEqual(x, #0)
+          MachineTypeUnion input = GetInfo(node->InputAt(0))->output;
+          if (input & kRepBit) {
+            // BooleanNot(x: kRepBit) => WordEqual(x, #0)
             node->set_op(lowering->machine()->WordEqual());
             node->AppendInput(jsgraph_->zone(), jsgraph_->Int32Constant(0));
           } else {
-            // BooleanNot(x: rTagged) => WordEqual(x, #false)
+            // BooleanNot(x: kRepTagged) => WordEqual(x, #false)
             node->set_op(lowering->machine()->WordEqual());
             node->AppendInput(jsgraph_->zone(), jsgraph_->FalseConstant());
           }
         } else {
           // No input representation requirement; adapt during lowering.
-          ProcessInput(node, 0, tBool);
-          SetOutput(node, rBit);
+          ProcessInput(node, 0, kTypeBool);
+          SetOutput(node, kRepBit);
         }
         break;
       }
       case IrOpcode::kNumberEqual:
       case IrOpcode::kNumberLessThan:
       case IrOpcode::kNumberLessThanOrEqual: {
         // Number comparisons reduce to integer comparisons for integer inputs.
         if (BothInputsAre(node, Type::Signed32())) {
           // => signed Int32Cmp
           VisitInt32Cmp(node);
           if (lower()) node->set_op(Int32Op(node));
         } else if (BothInputsAre(node, Type::Unsigned32())) {
           // => unsigned Int32Cmp
           VisitUint32Cmp(node);
           if (lower()) node->set_op(Uint32Op(node));
         } else {
           // => Float64Cmp
           VisitFloat64Cmp(node);
           if (lower()) node->set_op(Float64Op(node));
         }
         break;
       }
       case IrOpcode::kNumberAdd:
       case IrOpcode::kNumberSubtract: {
         // Add and subtract reduce to Int32Add/Sub if the inputs
         // are already integers and all uses are truncating.
         if (BothInputsAre(node, Type::Signed32()) &&
-            (use & (tUint32 | tNumber | tAny)) == 0) {
+            (use & (kTypeUint32 | kTypeNumber | kTypeAny)) == 0) {
           // => signed Int32Add/Sub
           VisitInt32Binop(node);
           if (lower()) node->set_op(Int32Op(node));
         } else if (BothInputsAre(node, Type::Unsigned32()) &&
-                   (use & (tInt32 | tNumber | tAny)) == 0) {
+                   (use & (kTypeInt32 | kTypeNumber | kTypeAny)) == 0) {
           // => unsigned Int32Add/Sub
           VisitUint32Binop(node);
           if (lower()) node->set_op(Uint32Op(node));
         } else {
           // => Float64Add/Sub
           VisitFloat64Binop(node);
           if (lower()) node->set_op(Float64Op(node));
         }
         break;
       }
       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 & kRepMask;
         if (lower()) {
-          RepTypeUnion in = GetInfo(node->InputAt(0))->output;
-          if ((in & tMask) == tInt32 || (in & rMask) == rWord32) {
+          MachineTypeUnion in = GetInfo(node->InputAt(0))->output;
+          if ((in & kTypeMask) == kTypeInt32 || (in & kRepMask) == kRepWord32) {
             // If the input has type int32, or is already a word32, just change
             // representation if necessary.
-            VisitUnop(node, tInt32 | use_rep, tInt32 | use_rep);
+            VisitUnop(node, kTypeInt32 | use_rep, kTypeInt32 | 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);
+            VisitUnop(node, kTypeInt32 | kRepFloat64, kTypeInt32 | kRepWord32);
             // 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);
+          VisitUnop(node, kTypeInt32, kTypeInt32 | use_rep);
         }
         break;
       }
       case IrOpcode::kNumberToUint32: {
-        RepTypeUnion use_rep = use & rMask;
+        MachineTypeUnion use_rep = use & kRepMask;
         if (lower()) {
-          RepTypeUnion in = GetInfo(node->InputAt(0))->output;
-          if ((in & tMask) == tUint32 || (in & rMask) == rWord32) {
+          MachineTypeUnion in = GetInfo(node->InputAt(0))->output;
+          if ((in & kTypeMask) == kTypeUint32 ||
+              (in & kRepMask) == kRepWord32) {
             // The input has type int32, just change representation.
-            VisitUnop(node, tUint32 | use_rep, tUint32 | use_rep);
+            VisitUnop(node, kTypeUint32 | use_rep, kTypeUint32 | 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);
+            VisitUnop(node, kTypeUint32 | kRepFloat64,
+                      kTypeUint32 | kRepWord32);
             // 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);
+          VisitUnop(node, kTypeUint32, kTypeUint32 | use_rep);
         }
         break;
       }
       case IrOpcode::kReferenceEqual: {
-        VisitBinop(node, kAnyTagged, rBit);
+        VisitBinop(node, kMachAnyTagged, kRepBit);
         if (lower()) node->set_op(lowering->machine()->WordEqual());
         break;
       }
       case IrOpcode::kStringEqual: {
-        VisitBinop(node, kAnyTagged, rBit);
+        VisitBinop(node, kMachAnyTagged, kRepBit);
         // TODO(titzer): lower StringEqual to stub/runtime call.
         break;
       }
       case IrOpcode::kStringLessThan: {
-        VisitBinop(node, kAnyTagged, rBit);
+        VisitBinop(node, kMachAnyTagged, kRepBit);
         // TODO(titzer): lower StringLessThan to stub/runtime call.
         break;
       }
       case IrOpcode::kStringLessThanOrEqual: {
-        VisitBinop(node, kAnyTagged, rBit);
+        VisitBinop(node, kMachAnyTagged, kRepBit);
         // TODO(titzer): lower StringLessThanOrEqual to stub/runtime call.
         break;
       }
       case IrOpcode::kStringAdd: {
-        VisitBinop(node, kAnyTagged, kAnyTagged);
+        VisitBinop(node, kMachAnyTagged, kMachAnyTagged);
         // 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, kMachInt32);  // 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, kMachInt32);  // 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 = kRepTagged;
+        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, kMachInt32);  // index
+        SetOutput(node, machine_type);
         break;
       }
       case IrOpcode::kStore: {
         // TODO(titzer): machine loads/stores need to know BaseTaggedness!?
-        RepType tBase = rTagged;
+        MachineType tBase = kRepTagged;
         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, kMachInt32);  // 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);
+        return VisitBinop(node, kRepWord32, kRepWord32 | kTypeUint32);
       case IrOpcode::kWord32And:
       case IrOpcode::kWord32Or:
       case IrOpcode::kWord32Xor:
       case IrOpcode::kWord32Shl:
       case IrOpcode::kWord32Sar:
         // We use signed int32 as the output type for these word32 operations,
         // though the machine bits are the same for either signed or unsigned,
         // because JavaScript considers the result from these operations signed.
-        return VisitBinop(node, rWord32, rWord32 | tInt32);
+        return VisitBinop(node, kRepWord32, kRepWord32 | kTypeInt32);
       case IrOpcode::kWord32Equal:
-        return VisitBinop(node, rWord32, rBit);
+        return VisitBinop(node, kRepWord32, kRepBit);
 
       case IrOpcode::kInt32Add:
       case IrOpcode::kInt32Sub:
       case IrOpcode::kInt32Mul:
       case IrOpcode::kInt32Div:
       case IrOpcode::kInt32Mod:
         return VisitInt32Binop(node);
       case IrOpcode::kInt32UDiv:
       case IrOpcode::kInt32UMod:
         return VisitUint32Binop(node);
@@ skipping 18 matching lines @@
       case IrOpcode::kInt64UDiv:
       case IrOpcode::kInt64UMod:
         return VisitUint64Binop(node);
 
       case IrOpcode::kWord64And:
       case IrOpcode::kWord64Or:
       case IrOpcode::kWord64Xor:
       case IrOpcode::kWord64Shl:
       case IrOpcode::kWord64Shr:
       case IrOpcode::kWord64Sar:
-        return VisitBinop(node, rWord64, rWord64);
+        return VisitBinop(node, kRepWord64, kRepWord64);
       case IrOpcode::kWord64Equal:
-        return VisitBinop(node, rWord64, rBit);
+        return VisitBinop(node, kRepWord64, kRepBit);
 
       case IrOpcode::kConvertInt32ToInt64:
-        return VisitUnop(node, tInt32 | rWord32, tInt32 | rWord64);
+        return VisitUnop(node, kTypeInt32 | kRepWord32,
+                         kTypeInt32 | kRepWord64);
       case IrOpcode::kConvertInt64ToInt32:
-        return VisitUnop(node, tInt64 | rWord64, tInt32 | rWord32);
+        return VisitUnop(node, kTypeInt64 | kRepWord64,
+                         kTypeInt32 | kRepWord32);
 
       case IrOpcode::kChangeInt32ToFloat64:
-        return VisitUnop(node, tInt32 | rWord32, tInt32 | rFloat64);
+        return VisitUnop(node, kTypeInt32 | kRepWord32,
+                         kTypeInt32 | kRepFloat64);
       case IrOpcode::kChangeUint32ToFloat64:
-        return VisitUnop(node, tUint32 | rWord32, tUint32 | rFloat64);
+        return VisitUnop(node, kTypeUint32 | kRepWord32,
+                         kTypeUint32 | kRepFloat64);
       case IrOpcode::kChangeFloat64ToInt32:
-        return VisitUnop(node, tInt32 | rFloat64, tInt32 | rWord32);
+        return VisitUnop(node, kTypeInt32 | kRepFloat64,
+                         kTypeInt32 | kRepWord32);
       case IrOpcode::kChangeFloat64ToUint32:
-        return VisitUnop(node, tUint32 | rFloat64, tUint32 | rWord32);
+        return VisitUnop(node, kTypeUint32 | kRepFloat64,
+                         kTypeUint32 | kRepWord32);
 
       case IrOpcode::kFloat64Add:
       case IrOpcode::kFloat64Sub:
       case IrOpcode::kFloat64Mul:
       case IrOpcode::kFloat64Div:
       case IrOpcode::kFloat64Mod:
         return VisitFloat64Binop(node);
       case IrOpcode::kFloat64Equal:
       case IrOpcode::kFloat64LessThan:
       case IrOpcode::kFloat64LessThanOrEqual:
@@ skipping 18 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);
+      os << static_cast<MachineType>(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[kMachFloat64](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(kMachFloat64), 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[kMachFloat64](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(kMachFloat64), 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) == kRepTagged) {
     // 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