[turbofan] Make MachineType a pair of enums.

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 <limits>
 
 #include "src/base/bits.h"
 #include "src/code-factory.h"
@@ skipping 55 matching lines @@
 // 1. During propagation, the use info is used to inform the input node
 //    about what part of the input is used (we call this truncation) and what
 //    is the preferred representation.
 //
 // 2. During lowering, the use info is used to properly convert the input
 //    to the preferred representation. The preferred representation might be
 //    insufficient to do the conversion (e.g. word32->float64 conv), so we also
 //    need the signedness information to produce the correct value.
 class UseInfo {
  public:
-  UseInfo(MachineType preferred, Truncation truncation)
-      : preferred_(preferred), truncation_(truncation) {
-    DCHECK(preferred == (preferred & kRepMask));
-  }
+  UseInfo(MachineRepresentation preferred, Truncation truncation)
+      : preferred_(preferred), truncation_(truncation) {}
   static UseInfo TruncatingWord32() {
-    return UseInfo(kRepWord32, Truncation::Word32());
+    return UseInfo(MachineRepresentation::kWord32, Truncation::Word32());
   }
   static UseInfo TruncatingWord64() {
-    return UseInfo(kRepWord64, Truncation::Word64());
+    return UseInfo(MachineRepresentation::kWord64, Truncation::Word64());
   }
-  static UseInfo Bool() { return UseInfo(kRepBit, Truncation::Bool()); }
+  static UseInfo Bool() {
+    return UseInfo(MachineRepresentation::kBit, Truncation::Bool());
+  }
   static UseInfo Float32() {
-    return UseInfo(kRepFloat32, Truncation::Float32());
+    return UseInfo(MachineRepresentation::kFloat32, Truncation::Float32());
   }
   static UseInfo Float64() {
-    return UseInfo(kRepFloat64, Truncation::Float64());
+    return UseInfo(MachineRepresentation::kFloat64, Truncation::Float64());
   }
   static UseInfo PointerInt() {
     return kPointerSize == 4 ? TruncatingWord32() : TruncatingWord64();
   }
-  static UseInfo AnyTagged() { return UseInfo(kRepTagged, Truncation::Any()); }
+  static UseInfo AnyTagged() {
+    return UseInfo(MachineRepresentation::kTagged, Truncation::Any());
+  }
 
   // Undetermined representation.
-  static UseInfo Any() { return UseInfo(kMachNone, Truncation::Any()); }
-  static UseInfo None() { return UseInfo(kMachNone, Truncation::None()); }
+  static UseInfo Any() {
+    return UseInfo(MachineRepresentation::kNone, Truncation::Any());
+  }
+  static UseInfo None() {
+    return UseInfo(MachineRepresentation::kNone, Truncation::None());
+  }
 
   // Truncation to a representation that is smaller than the preferred
   // one.
   static UseInfo Float64TruncatingToWord32() {
-    return UseInfo(kRepFloat64, Truncation::Word32());
+    return UseInfo(MachineRepresentation::kFloat64, Truncation::Word32());
   }
   static UseInfo Word64TruncatingToWord32() {
-    return UseInfo(kRepWord64, Truncation::Word32());
+    return UseInfo(MachineRepresentation::kWord64, Truncation::Word32());
   }
   static UseInfo AnyTruncatingToBool() {
-    return UseInfo(kMachNone, Truncation::Bool());
+    return UseInfo(MachineRepresentation::kNone, Truncation::Bool());
   }
 
-  MachineType preferred() const { return preferred_; }
+  MachineRepresentation preferred() const { return preferred_; }
   Truncation truncation() const { return truncation_; }
 
  private:
-  MachineType preferred_;
+  MachineRepresentation preferred_;
   Truncation truncation_;
 };
 
 
-UseInfo UseInfoFromMachineType(MachineType type) {
-  MachineTypeUnion rep = RepresentationOf(type);
-  DCHECK((rep & kTypeMask) == 0);
-
-  if (rep & kRepTagged) return UseInfo::AnyTagged();
-  if (rep & kRepFloat64) {
-    DCHECK((rep & kRepWord64) == 0);
+UseInfo TruncatingUseInfoFromRepresentation(MachineRepresentation rep) {
+  switch (rep) {
+    case MachineRepresentation::kTagged:
+      return UseInfo::AnyTagged();
+    case MachineRepresentation::kFloat64:
     return UseInfo::Float64();
+    case MachineRepresentation::kFloat32:
+      return UseInfo::Float32();
+    case MachineRepresentation::kWord64:
+    return UseInfo::TruncatingWord64();
+    case MachineRepresentation::kWord8:
+    case MachineRepresentation::kWord16:
+    case MachineRepresentation::kWord32:
+    return UseInfo::TruncatingWord32();
+    case MachineRepresentation::kBit:
+      return UseInfo::Bool();
+    case MachineRepresentation::kNone:
+      break;
   }
-  if (rep & kRepFloat32) {
-    if (rep == kRepFloat32) return UseInfo::Float32();
-    return UseInfo::AnyTagged();
-  }
-  if (rep & kRepWord64) {
-    return UseInfo::TruncatingWord64();
-  }
-  if (rep & (kRepWord32 | kRepWord16 | kRepWord8)) {
-    CHECK(!(rep & kRepBit));
-    return UseInfo::TruncatingWord32();
-  }
-  DCHECK(rep & kRepBit);
-  return UseInfo::Bool();
+  UNREACHABLE();
+  return UseInfo::None();
 }
 
 
 UseInfo UseInfoForBasePointer(const FieldAccess& access) {
   return access.tag() != 0 ? UseInfo::AnyTagged() : UseInfo::PointerInt();
 }
 
 
 UseInfo UseInfoForBasePointer(const ElementAccess& access) {
   return access.tag() != 0 ? UseInfo::AnyTagged() : UseInfo::PointerInt();
 }
 
 
 #ifdef DEBUG
 // Helpers for monotonicity checking.
 
-bool MachineTypeIsSubtype(MachineType t1, MachineType t2) {
+bool MachineTypeIsSubtype(MachineSemantic t1, MachineSemantic t2) {
   switch (t1) {
-    case kMachNone:
+    case MachineSemantic::kNone:
       return true;
-    case kTypeBool:
-      return t2 == kTypeBool || t2 == kTypeNumber || t2 == kTypeAny;
-    case kTypeInt32:
-      return t2 == kTypeInt32 || t2 == kTypeNumber || t2 == kTypeAny;
-    case kTypeUint32:
-      return t2 == kTypeUint32 || t2 == kTypeNumber || t2 == kTypeAny;
-    case kTypeInt64:
-      return t2 == kTypeInt64;
-    case kTypeUint64:
-      return t2 == kTypeUint64;
-    case kTypeNumber:
-      return t2 == kTypeNumber || t2 == kTypeAny;
-    case kTypeAny:
-      return t2 == kTypeAny;
+    case MachineSemantic::kBool:
+      return t2 == MachineSemantic::kBool || t2 == MachineSemantic::kNumber ||
+             t2 == MachineSemantic::kAny;
+    case MachineSemantic::kInt32:
+      return t2 == MachineSemantic::kInt32 || t2 == MachineSemantic::kNumber ||
+             t2 == MachineSemantic::kAny;
+    case MachineSemantic::kUint32:
+      return t2 == MachineSemantic::kUint32 || t2 == MachineSemantic::kNumber ||
+             t2 == MachineSemantic::kAny;
+    case MachineSemantic::kInt64:
+      return t2 == MachineSemantic::kInt64;
+    case MachineSemantic::kUint64:
+      return t2 == MachineSemantic::kUint64;
+    case MachineSemantic::kNumber:
+      return t2 == MachineSemantic::kNumber || t2 == MachineSemantic::kAny;
+    case MachineSemantic::kAny:
+      return t2 == MachineSemantic::kAny;
     default:
       break;
   }
   UNREACHABLE();
   return false;
 }
 
 
-bool MachineRepresentationIsSubtype(MachineType r1, MachineType r2) {
+bool MachineRepresentationIsSubtype(MachineRepresentation r1,
+                                    MachineRepresentation r2) {
   switch (r1) {
-    case kMachNone:
+    case MachineRepresentation::kNone:
       return true;
-    case kRepBit:
-      return r2 == kRepBit || r2 == kRepTagged;
-    case kRepWord8:
-      return r2 == kRepWord8 || r2 == kRepWord16 || r2 == kRepWord32 ||
-             r2 == kRepWord64 || r2 == kRepFloat32 || r2 == kRepFloat64 ||
-             r2 == kRepTagged;
-    case kRepWord16:
-      return r2 == kRepWord16 || r2 == kRepWord32 || r2 == kRepWord64 ||
-             r2 == kRepFloat32 || r2 == kRepFloat64 || r2 == kRepTagged;
-    case kRepWord32:
-      return r2 == kRepWord32 || r2 == kRepWord64 || r2 == kRepFloat64 ||
-             r2 == kRepTagged;
-    case kRepWord64:
-      return r2 == kRepWord64;
-    case kRepFloat32:
-      return r2 == kRepFloat32 || r2 == kRepFloat64 || r2 == kRepTagged;
-    case kRepFloat64:
-      return r2 == kRepFloat64 || r2 == kRepTagged;
-    case kRepTagged:
-      return r2 == kRepTagged;
+    case MachineRepresentation::kBit:
+      return r2 == MachineRepresentation::kBit ||
+             r2 == MachineRepresentation::kTagged;
+    case MachineRepresentation::kWord8:
+      return r2 == MachineRepresentation::kWord8 ||
+             r2 == MachineRepresentation::kWord16 ||
+             r2 == MachineRepresentation::kWord32 ||
+             r2 == MachineRepresentation::kWord64 ||
+             r2 == MachineRepresentation::kFloat32 ||
+             r2 == MachineRepresentation::kFloat64 ||
+             r2 == MachineRepresentation::kTagged;
+    case MachineRepresentation::kWord16:
+      return r2 == MachineRepresentation::kWord16 ||
+             r2 == MachineRepresentation::kWord32 ||
+             r2 == MachineRepresentation::kWord64 ||
+             r2 == MachineRepresentation::kFloat32 ||
+             r2 == MachineRepresentation::kFloat64 ||
+             r2 == MachineRepresentation::kTagged;
+    case MachineRepresentation::kWord32:
+      return r2 == MachineRepresentation::kWord32 ||
+             r2 == MachineRepresentation::kWord64 ||
+             r2 == MachineRepresentation::kFloat64 ||
+             r2 == MachineRepresentation::kTagged;
+    case MachineRepresentation::kWord64:
+      return r2 == MachineRepresentation::kWord64;
+    case MachineRepresentation::kFloat32:
+      return r2 == MachineRepresentation::kFloat32 ||
+             r2 == MachineRepresentation::kFloat64 ||
+             r2 == MachineRepresentation::kTagged;
+    case MachineRepresentation::kFloat64:
+      return r2 == MachineRepresentation::kFloat64 ||
+             r2 == MachineRepresentation::kTagged;
+    case MachineRepresentation::kTagged:
+      return r2 == MachineRepresentation::kTagged;
     default:
       break;
   }
   UNREACHABLE();
   return false;
 }
 
 
-bool MachineTypeRepIsSubtype(MachineTypeUnion m1, MachineTypeUnion m2) {
-  return MachineTypeIsSubtype(static_cast<MachineType>(m1 & kTypeMask),
-                              static_cast<MachineType>(m2 & kTypeMask)) &&
-         MachineRepresentationIsSubtype(
-             static_cast<MachineType>(m1 & kRepMask),
-             static_cast<MachineType>(m2 & kRepMask));
+bool MachineTypeRepIsSubtype(MachineType m1, MachineType m2) {
+  return MachineTypeIsSubtype(m1.semantic(), m2.semantic()) &&
+         MachineRepresentationIsSubtype(m1.representation(),
+                                        m2.representation());
 }
 
 
 class InputUseInfos {
  public:
   explicit InputUseInfos(Zone* zone) : input_use_infos_(zone) {}
 
   void SetAndCheckInput(Node* node, int index, UseInfo use_info) {
     if (input_use_infos_.empty()) {
       input_use_infos_.resize(node->InputCount(), UseInfo::None());
@@ skipping 29 matching lines @@
       Truncation old_truncation = truncation_;
       truncation_ = Truncation::Generalize(truncation_, info.truncation());
       return truncation_ != old_truncation;
     }
 
     void set_queued(bool value) { queued_ = value; }
     bool queued() const { return queued_; }
     void set_visited() { visited_ = true; }
     bool visited() const { return visited_; }
     Truncation truncation() const { return truncation_; }
-    void set_output_type(MachineTypeUnion type) { output_ = type; }
-    MachineTypeUnion output_type() const { return output_; }
+    void set_output_type(MachineType type) { output_ = type; }
+    MachineType output_type() const { return output_; }
 
    private:
     bool queued_ = false;                  // Bookkeeping for the traversal.
     bool visited_ = false;                 // Bookkeeping for the traversal.
-    MachineTypeUnion output_ = kMachNone;  // Output type of the node.
+    MachineType output_ = MachineType::None();    // Output type of the node.
     Truncation truncation_ = Truncation::None();  // Information about uses.
   };
 
   RepresentationSelector(JSGraph* jsgraph, Zone* zone,
                          RepresentationChanger* changer,
                          SourcePositionTable* source_positions)
       : jsgraph_(jsgraph),
         count_(jsgraph->graph()->NodeCount()),
         info_(count_, zone),
 #ifdef DEBUG
@@ skipping 96 matching lines @@
         TRACE("   added: ");
       } else {
         TRACE(" inqueue: ");
       }
       PrintTruncation(info->truncation());
     }
   }
 
   bool lower() { return phase_ == LOWER; }
 
-  void SetOutput(Node* node, MachineTypeUnion output) {
+  void SetOutput(Node* node, MachineType 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 & kRepMask) == 0 ||
-           base::bits::IsPowerOfTwo32(output & kRepMask));
     NodeInfo* info = GetInfo(node);
     DCHECK(MachineTypeRepIsSubtype(info->output_type(), output));
     info->set_output_type(output);
   }
 
   bool BothInputsAre(Node* node, Type* type) {
     DCHECK_EQ(2, node->InputCount());
     return NodeProperties::GetType(node->InputAt(0))->Is(type) &&
            NodeProperties::GetType(node->InputAt(1))->Is(type);
   }
 
   void ConvertInput(Node* node, int index, UseInfo use) {
     Node* input = node->InputAt(index);
     // In the change phase, insert a change before the use if necessary.
-    if (use.preferred() == kMachNone)
+    if (use.preferred() == MachineRepresentation::kNone)
       return;  // No input requirement on the use.
-    MachineTypeUnion output = GetInfo(input)->output_type();
-    if ((output & kRepMask) != use.preferred()) {
+    MachineType output = GetInfo(input)->output_type();
+    if (output.representation() != use.preferred()) {
       // 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 ");
       PrintUseInfo(use);
       TRACE("\n");
       Node* n = changer_->GetRepresentationFor(input, output, use.preferred(),
                                                use.truncation());
@@ skipping 34 matching lines @@
       ProcessInput(node, i, UseInfo::AnyTagged());
     }
     // Only enqueue other inputs (framestates, effects, control).
     for (int i = tagged_count; i < node->InputCount(); i++) {
       EnqueueInput(node, i);
     }
   }
 
   // Helper for binops of the R x L -> O variety.
   void VisitBinop(Node* node, UseInfo left_use, UseInfo right_use,
-                  MachineTypeUnion output) {
+                  MachineType output) {
     DCHECK_EQ(2, node->op()->ValueInputCount());
     ProcessInput(node, 0, left_use);
     ProcessInput(node, 1, right_use);
     for (int i = 2; i < node->InputCount(); i++) {
       EnqueueInput(node, i);
     }
     SetOutput(node, output);
   }
 
   // Helper for binops of the I x I -> O variety.
-  void VisitBinop(Node* node, UseInfo input_use, MachineTypeUnion output) {
+  void VisitBinop(Node* node, UseInfo input_use, MachineType output) {
     VisitBinop(node, input_use, input_use, output);
   }
 
   // Helper for unops of the I -> O variety.
-  void VisitUnop(Node* node, UseInfo input_use, MachineTypeUnion output) {
+  void VisitUnop(Node* node, UseInfo input_use, MachineType output) {
     DCHECK_EQ(1, node->InputCount());
     ProcessInput(node, 0, input_use);
     SetOutput(node, output);
   }
 
   // Helper for leaf nodes.
-  void VisitLeaf(Node* node, MachineTypeUnion output) {
+  void VisitLeaf(Node* node, MachineType output) {
     DCHECK_EQ(0, node->InputCount());
     SetOutput(node, output);
   }
 
   // Helpers for specific types of binops.
   void VisitFloat64Binop(Node* node) {
-    VisitBinop(node, UseInfo::Float64(), kMachFloat64);
+    VisitBinop(node, UseInfo::Float64(), MachineType::Float64());
   }
   void VisitInt32Binop(Node* node) {
-    VisitBinop(node, UseInfo::TruncatingWord32(), kMachInt32);
+    VisitBinop(node, UseInfo::TruncatingWord32(), MachineType::Int32());
   }
   void VisitUint32Binop(Node* node) {
-    VisitBinop(node, UseInfo::TruncatingWord32(), kMachUint32);
+    VisitBinop(node, UseInfo::TruncatingWord32(), MachineType::Uint32());
   }
   void VisitInt64Binop(Node* node) {
-    VisitBinop(node, UseInfo::TruncatingWord64(), kMachInt64);
+    VisitBinop(node, UseInfo::TruncatingWord64(), MachineType::Int64());
   }
   void VisitUint64Binop(Node* node) {
-    VisitBinop(node, UseInfo::TruncatingWord64(), kMachUint64);
+    VisitBinop(node, UseInfo::TruncatingWord64(), MachineType::Uint64());
   }
   void VisitFloat64Cmp(Node* node) {
-    VisitBinop(node, UseInfo::Float64(), kMachBool);
+    VisitBinop(node, UseInfo::Float64(), MachineType::Bool());
   }
   void VisitInt32Cmp(Node* node) {
-    VisitBinop(node, UseInfo::TruncatingWord32(), kMachBool);
+    VisitBinop(node, UseInfo::TruncatingWord32(), MachineType::Bool());
   }
   void VisitUint32Cmp(Node* node) {
-    VisitBinop(node, UseInfo::TruncatingWord32(), kMachBool);
+    VisitBinop(node, UseInfo::TruncatingWord32(), MachineType::Bool());
   }
   void VisitInt64Cmp(Node* node) {
-    VisitBinop(node, UseInfo::TruncatingWord64(), kMachBool);
+    VisitBinop(node, UseInfo::TruncatingWord64(), MachineType::Bool());
   }
   void VisitUint64Cmp(Node* node) {
-    VisitBinop(node, UseInfo::TruncatingWord64(), kMachBool);
+    VisitBinop(node, UseInfo::TruncatingWord64(), MachineType::Bool());
   }
 
   // Infer representation for phi-like nodes.
-  static MachineType GetRepresentationForPhi(Node* node, Truncation use) {
+  static MachineRepresentation GetRepresentationForPhi(Node* node,
+                                                       Truncation use) {
     // Phis adapt to the output representation their uses demand.
     Type* upper = NodeProperties::GetType(node);
     if (upper->Is(Type::Signed32()) || upper->Is(Type::Unsigned32())) {
       // We are within 32 bits range => pick kRepWord32.
-      return kRepWord32;
+      return MachineRepresentation::kWord32;
     } else if (use.TruncatesToWord32()) {
       // We only use 32 bits.
-      return kRepWord32;
+      return MachineRepresentation::kWord32;
     } else if (upper->Is(Type::Boolean())) {
       // multiple uses => pick kRepBit.
-      return kRepBit;
+      return MachineRepresentation::kBit;
     } else if (upper->Is(Type::Number())) {
       // multiple uses => pick kRepFloat64.
-      return kRepFloat64;
+      return MachineRepresentation::kFloat64;
     } else if (upper->Is(Type::Internal())) {
-      return kMachPtr;
+      return MachineType::PointerRepresentation();
     }
-    return kRepTagged;
+    return MachineRepresentation::kTagged;
   }
 
   // Helper for handling selects.
   void VisitSelect(Node* node, Truncation truncation,
                    SimplifiedLowering* lowering) {
     ProcessInput(node, 0, UseInfo::Bool());
-    MachineType output = GetRepresentationForPhi(node, truncation);
+    MachineRepresentation output = GetRepresentationForPhi(node, truncation);
 
     Type* upper = NodeProperties::GetType(node);
     MachineType output_type =
-        static_cast<MachineType>(changer_->TypeFromUpperBound(upper) | output);
+        MachineType(output, changer_->TypeFromUpperBound(upper));
     SetOutput(node, output_type);
 
     if (lower()) {
       // Update the select operator.
       SelectParameters p = SelectParametersOf(node->op());
-      MachineType type = static_cast<MachineType>(output_type);
-      if (type != p.type()) {
+      if (output != p.representation()) {
         NodeProperties::ChangeOp(node,
-                                 lowering->common()->Select(type, p.hint()));
+                                 lowering->common()->Select(output, p.hint()));
       }
     }
     // Convert inputs to the output representation of this phi, pass the
     // truncation truncation along.
     UseInfo input_use(output, truncation);
     ProcessInput(node, 1, input_use);
     ProcessInput(node, 2, input_use);
   }
 
   // Helper for handling phis.
   void VisitPhi(Node* node, Truncation truncation,
                 SimplifiedLowering* lowering) {
-    MachineType output = GetRepresentationForPhi(node, truncation);
+    MachineRepresentation output = GetRepresentationForPhi(node, truncation);
 
     Type* upper = NodeProperties::GetType(node);
     MachineType output_type =
-        static_cast<MachineType>(changer_->TypeFromUpperBound(upper) | output);
+        MachineType(output, changer_->TypeFromUpperBound(upper));
     SetOutput(node, output_type);
 
     int values = node->op()->ValueInputCount();
 
     if (lower()) {
       // Update the phi operator.
-      MachineType type = static_cast<MachineType>(output_type);
-      if (type != OpParameter<MachineType>(node)) {
-        NodeProperties::ChangeOp(node, lowering->common()->Phi(type, values));
+      if (output != PhiRepresentationOf(node->op())) {
+        NodeProperties::ChangeOp(node, lowering->common()->Phi(output, values));
       }
     }
 
     // Convert inputs to the output representation of this phi, pass the
     // truncation truncation along.
     UseInfo input_use(output, truncation);
     for (int i = 0; i < node->InputCount(); i++) {
       ProcessInput(node, i, i < values ? input_use : UseInfo::None());
     }
   }
 
   void VisitCall(Node* node, SimplifiedLowering* lowering) {
     const CallDescriptor* desc = OpParameter<const CallDescriptor*>(node->op());
     const MachineSignature* sig = desc->GetMachineSignature();
     int params = static_cast<int>(sig->parameter_count());
     // Propagate representation information from call descriptor.
     for (int i = 0; i < node->InputCount(); i++) {
       if (i == 0) {
         // The target of the call.
         ProcessInput(node, i, UseInfo::None());
       } else if ((i - 1) < params) {
-        ProcessInput(node, i, UseInfoFromMachineType(sig->GetParam(i - 1)));
+        ProcessInput(node, i, TruncatingUseInfoFromRepresentation(
+                                  sig->GetParam(i - 1).representation()));
       } else {
         ProcessInput(node, i, UseInfo::None());
       }
     }
 
     if (sig->return_count() > 0) {
       SetOutput(node, desc->GetMachineSignature()->GetReturn());
     } else {
-      SetOutput(node, kMachAnyTagged);
+      SetOutput(node, MachineType::AnyTagged());
     }
   }
 
   void VisitStateValues(Node* node) {
     if (phase_ == PROPAGATE) {
       for (int i = 0; i < node->InputCount(); i++) {
         EnqueueInput(node, i, UseInfo::Any());
       }
     } else {
       Zone* zone = jsgraph_->zone();
       ZoneVector<MachineType>* types =
           new (zone->New(sizeof(ZoneVector<MachineType>)))
               ZoneVector<MachineType>(node->InputCount(), zone);
       for (int i = 0; i < node->InputCount(); i++) {
-        MachineTypeUnion input_type = GetInfo(node->InputAt(i))->output_type();
-        (*types)[i] = static_cast<MachineType>(input_type);
+        MachineType input_type = GetInfo(node->InputAt(i))->output_type();
+        (*types)[i] = input_type;
       }
       NodeProperties::ChangeOp(node,
                                jsgraph_->common()->TypedStateValues(types));
     }
-    SetOutput(node, kMachAnyTagged);
+    SetOutput(node, MachineType::AnyTagged());
   }
 
   const Operator* Int32Op(Node* node) {
     return changer_->Int32OperatorFor(node->opcode());
   }
 
   const Operator* Uint32Op(Node* node) {
     return changer_->Uint32OperatorFor(node->opcode());
   }
 
@@ skipping 30 matching lines @@
   // 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, Truncation truncation,
                  SimplifiedLowering* lowering) {
     switch (node->opcode()) {
       //------------------------------------------------------------------
       // Common operators.
       //------------------------------------------------------------------
       case IrOpcode::kStart:
       case IrOpcode::kDead:
-        return VisitLeaf(node, 0);
+        return VisitLeaf(node, MachineType::None());
       case IrOpcode::kParameter: {
         // TODO(titzer): use representation from linkage.
         Type* upper = NodeProperties::GetType(node);
         ProcessInput(node, 0, UseInfo::None());
-        SetOutput(node, kRepTagged | changer_->TypeFromUpperBound(upper));
+        SetOutput(node, MachineType(MachineRepresentation::kTagged,
+                                    changer_->TypeFromUpperBound(upper)));
         return;
       }
       case IrOpcode::kInt32Constant:
-        return VisitLeaf(node, kRepWord32);
+        return VisitLeaf(node, MachineType::RepWord32());
       case IrOpcode::kInt64Constant:
-        return VisitLeaf(node, kRepWord64);
+        return VisitLeaf(node, MachineType::RepWord64());
       case IrOpcode::kFloat32Constant:
-        return VisitLeaf(node, kRepFloat32);
+        return VisitLeaf(node, MachineType::RepFloat32());
       case IrOpcode::kFloat64Constant:
-        return VisitLeaf(node, kRepFloat64);
+        return VisitLeaf(node, MachineType::RepFloat64());
       case IrOpcode::kExternalConstant:
-        return VisitLeaf(node, kMachPtr);
+        return VisitLeaf(node, MachineType::Pointer());
       case IrOpcode::kNumberConstant:
-        return VisitLeaf(node, kRepTagged);
+        return VisitLeaf(node, MachineType::RepTagged());
       case IrOpcode::kHeapConstant:
-        return VisitLeaf(node, kRepTagged);
+        return VisitLeaf(node, MachineType::RepTagged());
 
       case IrOpcode::kBranch:
         ProcessInput(node, 0, UseInfo::Bool());
         EnqueueInput(node, NodeProperties::FirstControlIndex(node));
         break;
       case IrOpcode::kSwitch:
         ProcessInput(node, 0, UseInfo::TruncatingWord32());
         EnqueueInput(node, NodeProperties::FirstControlIndex(node));
         break;
       case IrOpcode::kSelect:
         return VisitSelect(node, truncation, lowering);
       case IrOpcode::kPhi:
         return VisitPhi(node, truncation, lowering);
       case IrOpcode::kCall:
         return VisitCall(node, lowering);
 
 //------------------------------------------------------------------
 // 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
         VisitInputs(node);
-        return SetOutput(node, kRepTagged);
+        return SetOutput(node, MachineType::RepTagged());
 
       //------------------------------------------------------------------
       // Simplified operators.
       //------------------------------------------------------------------
       case IrOpcode::kBooleanNot: {
         if (lower()) {
-          MachineTypeUnion input = GetInfo(node->InputAt(0))->output_type();
-          if (input & kRepBit) {
+          MachineType input = GetInfo(node->InputAt(0))->output_type();
+          if (input.representation() == MachineRepresentation::kBit) {
             // BooleanNot(x: kRepBit) => Word32Equal(x, #0)
             node->AppendInput(jsgraph_->zone(), jsgraph_->Int32Constant(0));
             NodeProperties::ChangeOp(node, lowering->machine()->Word32Equal());
           } else {
             // BooleanNot(x: kRepTagged) => WordEqual(x, #false)
             node->AppendInput(jsgraph_->zone(), jsgraph_->FalseConstant());
             NodeProperties::ChangeOp(node, lowering->machine()->WordEqual());
           }
         } else {
           // No input representation requirement; adapt during lowering.
           ProcessInput(node, 0, UseInfo::AnyTruncatingToBool());
-          SetOutput(node, kRepBit);
+          SetOutput(node, MachineType::RepBit());
         }
         break;
       }
       case IrOpcode::kBooleanToNumber: {
         if (lower()) {
-          MachineTypeUnion input = GetInfo(node->InputAt(0))->output_type();
-          if (input & kRepBit) {
+          MachineType input = GetInfo(node->InputAt(0))->output_type();
+          if (input.representation() == MachineRepresentation::kBit) {
             // BooleanToNumber(x: kRepBit) => x
             DeferReplacement(node, node->InputAt(0));
           } else {
             // BooleanToNumber(x: kRepTagged) => WordEqual(x, #true)
             node->AppendInput(jsgraph_->zone(), jsgraph_->TrueConstant());
             NodeProperties::ChangeOp(node, lowering->machine()->WordEqual());
           }
         } else {
           // No input representation requirement; adapt during lowering.
           ProcessInput(node, 0, UseInfo::AnyTruncatingToBool());
-          SetOutput(node, kMachInt32);
+          SetOutput(node, MachineType::Int32());
         }
         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);
@@ skipping 78 matching lines @@
       }
       case IrOpcode::kNumberBitwiseOr:
       case IrOpcode::kNumberBitwiseXor:
       case IrOpcode::kNumberBitwiseAnd: {
         VisitInt32Binop(node);
         if (lower()) NodeProperties::ChangeOp(node, Int32Op(node));
         break;
       }
       case IrOpcode::kNumberShiftLeft: {
         VisitBinop(node, UseInfo::TruncatingWord32(),
-                   UseInfo::TruncatingWord32(), kMachInt32);
+                   UseInfo::TruncatingWord32(), MachineType::Int32());
         if (lower()) lowering->DoShift(node, lowering->machine()->Word32Shl());
         break;
       }
       case IrOpcode::kNumberShiftRight: {
         VisitBinop(node, UseInfo::TruncatingWord32(),
-                   UseInfo::TruncatingWord32(), kMachInt32);
+                   UseInfo::TruncatingWord32(), MachineType::Int32());
         if (lower()) lowering->DoShift(node, lowering->machine()->Word32Sar());
         break;
       }
       case IrOpcode::kNumberShiftRightLogical: {
         VisitBinop(node, UseInfo::TruncatingWord32(),
-                   UseInfo::TruncatingWord32(), kMachUint32);
+                   UseInfo::TruncatingWord32(), MachineType::Uint32());
         if (lower()) lowering->DoShift(node, lowering->machine()->Word32Shr());
         break;
       }
       case IrOpcode::kNumberToInt32: {
         // Just change representation if necessary.
-        VisitUnop(node, UseInfo::TruncatingWord32(), kMachInt32);
+        VisitUnop(node, UseInfo::TruncatingWord32(), MachineType::Int32());
         if (lower()) DeferReplacement(node, node->InputAt(0));
         break;
       }
       case IrOpcode::kNumberToUint32: {
         // Just change representation if necessary.
-        VisitUnop(node, UseInfo::TruncatingWord32(), kMachUint32);
+        VisitUnop(node, UseInfo::TruncatingWord32(), MachineType::Uint32());
         if (lower()) DeferReplacement(node, node->InputAt(0));
         break;
       }
       case IrOpcode::kNumberIsHoleNaN: {
-        VisitUnop(node, UseInfo::Float64(), kMachBool);
+        VisitUnop(node, UseInfo::Float64(), MachineType::Bool());
         if (lower()) {
           // NumberIsHoleNaN(x) => Word32Equal(Float64ExtractLowWord32(x),
           //                                   #HoleNaNLower32)
           node->ReplaceInput(0,
                              jsgraph_->graph()->NewNode(
                                  lowering->machine()->Float64ExtractLowWord32(),
                                  node->InputAt(0)));
           node->AppendInput(jsgraph_->zone(),
                             jsgraph_->Int32Constant(kHoleNanLower32));
           NodeProperties::ChangeOp(node, jsgraph_->machine()->Word32Equal());
         }
         break;
       }
       case IrOpcode::kPlainPrimitiveToNumber: {
-        VisitUnop(node, UseInfo::AnyTagged(), kTypeNumber | kRepTagged);
+        VisitUnop(node, UseInfo::AnyTagged(),
+                  MachineType(MachineRepresentation::kTagged,
+                              MachineSemantic::kNumber));
         if (lower()) {
           // PlainPrimitiveToNumber(x) => Call(ToNumberStub, x, no-context)
           Operator::Properties properties = node->op()->properties();
           Callable callable = CodeFactory::ToNumber(jsgraph_->isolate());
           CallDescriptor::Flags flags = CallDescriptor::kNoFlags;
           CallDescriptor* desc = Linkage::GetStubCallDescriptor(
               jsgraph_->isolate(), jsgraph_->zone(), callable.descriptor(), 0,
               flags, properties);
           node->InsertInput(jsgraph_->zone(), 0,
                             jsgraph_->HeapConstant(callable.code()));
           node->AppendInput(jsgraph_->zone(), jsgraph_->NoContextConstant());
           NodeProperties::ChangeOp(node, jsgraph_->common()->Call(desc));
         }
         break;
       }
       case IrOpcode::kReferenceEqual: {
-        VisitBinop(node, UseInfo::AnyTagged(), kMachBool);
+        VisitBinop(node, UseInfo::AnyTagged(), MachineType::Bool());
         if (lower()) {
           NodeProperties::ChangeOp(node, lowering->machine()->WordEqual());
         }
         break;
       }
       case IrOpcode::kStringEqual: {
-        VisitBinop(node, UseInfo::AnyTagged(), kMachBool);
+        VisitBinop(node, UseInfo::AnyTagged(), MachineType::Bool());
         if (lower()) lowering->DoStringEqual(node);
         break;
       }
       case IrOpcode::kStringLessThan: {
-        VisitBinop(node, UseInfo::AnyTagged(), kMachBool);
+        VisitBinop(node, UseInfo::AnyTagged(), MachineType::Bool());
         if (lower()) lowering->DoStringLessThan(node);
         break;
       }
       case IrOpcode::kStringLessThanOrEqual: {
-        VisitBinop(node, UseInfo::AnyTagged(), kMachBool);
+        VisitBinop(node, UseInfo::AnyTagged(), MachineType::Bool());
         if (lower()) lowering->DoStringLessThanOrEqual(node);
         break;
       }
       case IrOpcode::kAllocate: {
         ProcessInput(node, 0, UseInfo::AnyTagged());
         ProcessRemainingInputs(node, 1);
-        SetOutput(node, kMachAnyTagged);
+        SetOutput(node, MachineType::AnyTagged());
         break;
       }
       case IrOpcode::kLoadField: {
         FieldAccess access = FieldAccessOf(node->op());
         ProcessInput(node, 0, UseInfoForBasePointer(access));
         ProcessRemainingInputs(node, 1);
         SetOutput(node, access.machine_type);
         break;
       }
       case IrOpcode::kStoreField: {
         FieldAccess access = FieldAccessOf(node->op());
         ProcessInput(node, 0, UseInfoForBasePointer(access));
-        ProcessInput(node, 1, UseInfoFromMachineType(access.machine_type));
+        ProcessInput(node, 1, TruncatingUseInfoFromRepresentation(
+                                  access.machine_type.representation()));
         ProcessRemainingInputs(node, 2);
-        SetOutput(node, 0);
+        SetOutput(node, MachineType::None());
         break;
       }
       case IrOpcode::kLoadBuffer: {
         BufferAccess access = BufferAccessOf(node->op());
         ProcessInput(node, 0, UseInfo::PointerInt());        // buffer
         ProcessInput(node, 1, UseInfo::TruncatingWord32());  // offset
         ProcessInput(node, 2, UseInfo::TruncatingWord32());  // length
         ProcessRemainingInputs(node, 3);
 
         MachineType output_type;
         if (truncation.TruncatesUndefinedToZeroOrNaN()) {
           if (truncation.TruncatesNaNToZero()) {
             // If undefined is truncated to a non-NaN number, we can use
             // the load's representation.
             output_type = access.machine_type();
           } else {
             // If undefined is truncated to a number, but the use can
             // observe NaN, we need to output at least the float32
             // representation.
-            if (access.machine_type() & kRepFloat32) {
+            if (access.machine_type().representation() ==
+                MachineRepresentation::kFloat32) {
               output_type = access.machine_type();
             } else {
-              output_type = kMachFloat64;
+              output_type = MachineType::Float64();
             }
           }
         } else {
           // If undefined is not truncated away, we need to have the tagged
           // representation.
-          output_type = kMachAnyTagged;
+          output_type = MachineType::AnyTagged();
         }
         SetOutput(node, output_type);
         if (lower()) lowering->DoLoadBuffer(node, output_type, changer_);
         break;
       }
       case IrOpcode::kStoreBuffer: {
         BufferAccess access = BufferAccessOf(node->op());
         ProcessInput(node, 0, UseInfo::PointerInt());        // buffer
         ProcessInput(node, 1, UseInfo::TruncatingWord32());  // offset
         ProcessInput(node, 2, UseInfo::TruncatingWord32());  // length
         ProcessInput(node, 3,
-                     UseInfoFromMachineType(access.machine_type()));  // value
+                     TruncatingUseInfoFromRepresentation(
+                         access.machine_type().representation()));  // value
         ProcessRemainingInputs(node, 4);
-        SetOutput(node, 0);
+        SetOutput(node, MachineType::None());
         if (lower()) lowering->DoStoreBuffer(node);
         break;
       }
       case IrOpcode::kLoadElement: {
         ElementAccess access = ElementAccessOf(node->op());
         ProcessInput(node, 0, UseInfoForBasePointer(access));  // base
         ProcessInput(node, 1, UseInfo::TruncatingWord32());    // index
         ProcessRemainingInputs(node, 2);
         SetOutput(node, access.machine_type);
         break;
       }
       case IrOpcode::kStoreElement: {
         ElementAccess access = ElementAccessOf(node->op());
         ProcessInput(node, 0, UseInfoForBasePointer(access));  // base
         ProcessInput(node, 1, UseInfo::TruncatingWord32());    // index
         ProcessInput(node, 2,
-                     UseInfoFromMachineType(access.machine_type));  // value
+                     TruncatingUseInfoFromRepresentation(
+                         access.machine_type.representation()));  // value
         ProcessRemainingInputs(node, 3);
-        SetOutput(node, 0);
+        SetOutput(node, MachineType::None());
         break;
       }
       case IrOpcode::kObjectIsNumber: {
         ProcessInput(node, 0, UseInfo::AnyTagged());
-        SetOutput(node, kMachBool);
+        SetOutput(node, MachineType::Bool());
         if (lower()) lowering->DoObjectIsNumber(node);
         break;
       }
       case IrOpcode::kObjectIsSmi: {
         ProcessInput(node, 0, UseInfo::AnyTagged());
-        SetOutput(node, kMachBool);
+        SetOutput(node, MachineType::Bool());
         if (lower()) lowering->DoObjectIsSmi(node);
         break;
       }
 
       //------------------------------------------------------------------
       // Machine-level operators.
       //------------------------------------------------------------------
       case IrOpcode::kLoad: {
         // TODO(jarin) Eventually, we should get rid of all machine stores
         // from the high-level phases, then this becomes UNREACHABLE.
-        LoadRepresentation rep = OpParameter<LoadRepresentation>(node);
+        LoadRepresentation rep = LoadRepresentationOf(node->op());
         ProcessInput(node, 0, UseInfo::AnyTagged());   // tagged pointer
         ProcessInput(node, 1, UseInfo::PointerInt());  // index
         ProcessRemainingInputs(node, 2);
         SetOutput(node, rep);
         break;
       }
       case IrOpcode::kStore: {
         // TODO(jarin) Eventually, we should get rid of all machine stores
         // from the high-level phases, then this becomes UNREACHABLE.
-        StoreRepresentation rep = OpParameter<StoreRepresentation>(node);
+        StoreRepresentation rep = StoreRepresentationOf(node->op());
         ProcessInput(node, 0, UseInfo::AnyTagged());   // tagged pointer
         ProcessInput(node, 1, UseInfo::PointerInt());  // index
-        ProcessInput(node, 2, UseInfoFromMachineType(rep.machine_type()));
+        ProcessInput(node, 2, TruncatingUseInfoFromRepresentation(
+                                  rep.machine_type().representation()));
         ProcessRemainingInputs(node, 3);
-        SetOutput(node, 0);
+        SetOutput(node, MachineType::None());
         break;
       }
       case IrOpcode::kWord32Shr:
         // We output unsigned int32 for shift right because JavaScript.
-        return VisitBinop(node, UseInfo::TruncatingWord32(), kMachUint32);
+        return VisitBinop(node, UseInfo::TruncatingWord32(),
+                          MachineType::Uint32());
       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, UseInfo::TruncatingWord32(),
-                          kRepWord32 | kTypeInt32);
+                          MachineType::Int32());
       case IrOpcode::kWord32Equal:
-        return VisitBinop(node, UseInfo::TruncatingWord32(), kMachBool);
+        return VisitBinop(node, UseInfo::TruncatingWord32(),
+                          MachineType::Bool());
 
       case IrOpcode::kWord32Clz:
-        return VisitUnop(node, UseInfo::TruncatingWord32(), kMachUint32);
+        return VisitUnop(node, UseInfo::TruncatingWord32(),
+                         MachineType::Uint32());
 
       case IrOpcode::kInt32Add:
       case IrOpcode::kInt32Sub:
       case IrOpcode::kInt32Mul:
       case IrOpcode::kInt32MulHigh:
       case IrOpcode::kInt32Div:
       case IrOpcode::kInt32Mod:
         return VisitInt32Binop(node);
       case IrOpcode::kUint32Div:
       case IrOpcode::kUint32Mod:
@@ skipping 23 matching lines @@
       case IrOpcode::kUint64Div:
       case IrOpcode::kUint64Mod:
         return VisitUint64Binop(node);
 
       case IrOpcode::kWord64And:
       case IrOpcode::kWord64Or:
       case IrOpcode::kWord64Xor:
       case IrOpcode::kWord64Shl:
       case IrOpcode::kWord64Shr:
       case IrOpcode::kWord64Sar:
-        return VisitBinop(node, UseInfo::TruncatingWord64(), kRepWord64);
+        return VisitBinop(node, UseInfo::TruncatingWord64(),
+                          MachineType(MachineRepresentation::kWord64,
+                                      MachineSemantic::kNone));
       case IrOpcode::kWord64Equal:
-        return VisitBinop(node, UseInfo::TruncatingWord64(), kMachBool);
+        return VisitBinop(node, UseInfo::TruncatingWord64(),
+                          MachineType::Bool());
 
       case IrOpcode::kChangeInt32ToInt64:
         return VisitUnop(node, UseInfo::TruncatingWord32(),
-                         kTypeInt32 | kRepWord64);
+                         MachineType(MachineRepresentation::kWord64,
+                                     MachineSemantic::kInt32));
       case IrOpcode::kChangeUint32ToUint64:
         return VisitUnop(node, UseInfo::TruncatingWord32(),
-                         kTypeUint32 | kRepWord64);
+                         MachineType(MachineRepresentation::kWord64,
+                                     MachineSemantic::kUint32));
       case IrOpcode::kTruncateFloat64ToFloat32:
-        return VisitUnop(node, UseInfo::Float64(), kTypeNumber | kRepFloat32);
+        return VisitUnop(node, UseInfo::Float64(), MachineType::Float32());
       case IrOpcode::kTruncateFloat64ToInt32:
-        return VisitUnop(node, UseInfo::Float64(), kTypeInt32 | kRepWord32);
+        return VisitUnop(node, UseInfo::Float64(), MachineType::Int32());
       case IrOpcode::kTruncateInt64ToInt32:
         // TODO(titzer): Is kTypeInt32 correct here?
         return VisitUnop(node, UseInfo::Word64TruncatingToWord32(),
-                         kTypeInt32 | kRepWord32);
+                         MachineType::Int32());
 
       case IrOpcode::kChangeFloat32ToFloat64:
-        return VisitUnop(node, UseInfo::Float32(), kTypeNumber | kRepFloat64);
+        return VisitUnop(node, UseInfo::Float32(), MachineType::Float64());
       case IrOpcode::kChangeInt32ToFloat64:
         return VisitUnop(node, UseInfo::TruncatingWord32(),
-                         kTypeInt32 | kRepFloat64);
+                         MachineType(MachineRepresentation::kFloat64,
+                                     MachineSemantic::kInt32));
       case IrOpcode::kChangeUint32ToFloat64:
         return VisitUnop(node, UseInfo::TruncatingWord32(),
-                         kTypeUint32 | kRepFloat64);
+                         MachineType(MachineRepresentation::kFloat64,
+                                     MachineSemantic::kUint32));
       case IrOpcode::kChangeFloat64ToInt32:
         return VisitUnop(node, UseInfo::Float64TruncatingToWord32(),
-                         kTypeInt32 | kRepWord32);
+                         MachineType::Int32());
       case IrOpcode::kChangeFloat64ToUint32:
         return VisitUnop(node, UseInfo::Float64TruncatingToWord32(),
-                         kTypeUint32 | kRepWord32);
+                         MachineType::Uint32());
 
       case IrOpcode::kFloat64Add:
       case IrOpcode::kFloat64Sub:
       case IrOpcode::kFloat64Mul:
       case IrOpcode::kFloat64Div:
       case IrOpcode::kFloat64Mod:
       case IrOpcode::kFloat64Min:
         return VisitFloat64Binop(node);
       case IrOpcode::kFloat64Abs:
       case IrOpcode::kFloat64Sqrt:
       case IrOpcode::kFloat64RoundDown:
       case IrOpcode::kFloat64RoundTruncate:
       case IrOpcode::kFloat64RoundTiesAway:
-        return VisitUnop(node, UseInfo::Float64(), kMachFloat64);
+        return VisitUnop(node, UseInfo::Float64(), MachineType::Float64());
       case IrOpcode::kFloat64Equal:
       case IrOpcode::kFloat64LessThan:
       case IrOpcode::kFloat64LessThanOrEqual:
         return VisitFloat64Cmp(node);
       case IrOpcode::kFloat64ExtractLowWord32:
       case IrOpcode::kFloat64ExtractHighWord32:
-        return VisitUnop(node, UseInfo::Float64(), kMachInt32);
+        return VisitUnop(node, UseInfo::Float64(), MachineType::Int32());
       case IrOpcode::kFloat64InsertLowWord32:
       case IrOpcode::kFloat64InsertHighWord32:
         return VisitBinop(node, UseInfo::Float64(), UseInfo::TruncatingWord32(),
-                          kMachFloat64);
+                          MachineType::Float64());
       case IrOpcode::kLoadStackPointer:
       case IrOpcode::kLoadFramePointer:
-        return VisitLeaf(node, kMachPtr);
+        return VisitLeaf(node, MachineType::Pointer());
       case IrOpcode::kStateValues:
         VisitStateValues(node);
         break;
       default:
         VisitInputs(node);
         // Assume the output is tagged.
-        SetOutput(node, kMachAnyTagged);
+        SetOutput(node, MachineType::AnyTagged());
         break;
     }
   }
 
   void DeferReplacement(Node* node, Node* replacement) {
     TRACE("defer replacement #%d:%s with #%d:%s\n", node->id(),
           node->op()->mnemonic(), replacement->id(),
           replacement->op()->mnemonic());
 
     if (replacement->id() < count_ &&
         GetInfo(replacement)->output_type() == GetInfo(node)->output_type()) {
       // Replace with a previously existing node eagerly only if the type is the
       // same.
       node->ReplaceUses(replacement);
     } else {
       // Otherwise, we are replacing a node with a representation change.
       // Such a substitution must be done after all lowering is done, because
       // changing the type could confuse the representation change
       // insertion for uses of the node.
       replacements_.push_back(node);
       replacements_.push_back(replacement);
     }
     node->NullAllInputs();  // Node is now dead.
   }
 
-  void PrintInfo(MachineTypeUnion info) {
+  void PrintInfo(MachineType info) {
     if (FLAG_trace_representation) {
       OFStream os(stdout);
-      os << static_cast<MachineType>(info);
+      os << info;
     }
   }
 
   void PrintTruncation(Truncation truncation) {
     if (FLAG_trace_representation) {
       OFStream os(stdout);
       os << truncation.description();
     }
   }
 
@@ skipping 45 matching lines @@
   RepresentationChanger changer(jsgraph(), jsgraph()->isolate());
   RepresentationSelector selector(jsgraph(), zone_, &changer,
                                   source_positions_);
   selector.Run(this);
 }
 
 
 void SimplifiedLowering::DoLoadBuffer(Node* node, MachineType output_type,
                                       RepresentationChanger* changer) {
   DCHECK_EQ(IrOpcode::kLoadBuffer, node->opcode());
-  DCHECK_NE(kMachNone, RepresentationOf(output_type));
+  DCHECK_NE(MachineRepresentation::kNone, output_type.representation());
   MachineType const type = BufferAccessOf(node->op()).machine_type();
   if (output_type != type) {
     Node* const buffer = node->InputAt(0);
     Node* const offset = node->InputAt(1);
     Node* const length = node->InputAt(2);
     Node* const effect = node->InputAt(3);
     Node* const control = node->InputAt(4);
     Node* const index =
         machine()->Is64()
             ? graph()->NewNode(machine()->ChangeUint32ToUint64(), offset)
             : offset;
 
     Node* check = graph()->NewNode(machine()->Uint32LessThan(), offset, length);
     Node* branch =
         graph()->NewNode(common()->Branch(BranchHint::kTrue), check, control);
 
     Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
     Node* etrue =
         graph()->NewNode(machine()->Load(type), buffer, index, effect, if_true);
     Node* vtrue = changer->GetRepresentationFor(
-        etrue, type, RepresentationOf(output_type), Truncation::None());
+        etrue, type, output_type.representation(), Truncation::None());
 
     Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
     Node* efalse = effect;
     Node* vfalse;
-    if (output_type & kRepTagged) {
+    if (output_type.representation() == MachineRepresentation::kTagged) {
       vfalse = jsgraph()->UndefinedConstant();
-    } else if (output_type & kRepFloat64) {
+    } else if (output_type.representation() ==
+               MachineRepresentation::kFloat64) {
       vfalse =
           jsgraph()->Float64Constant(std::numeric_limits<double>::quiet_NaN());
-    } else if (output_type & kRepFloat32) {
+    } else if (output_type.representation() ==
+               MachineRepresentation::kFloat32) {
       vfalse =
           jsgraph()->Float32Constant(std::numeric_limits<float>::quiet_NaN());
     } else {
       vfalse = jsgraph()->Int32Constant(0);
     }
 
     Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
     Node* ephi = graph()->NewNode(common()->EffectPhi(2), etrue, efalse, merge);
 
     // Replace effect uses of {node} with the {ephi}.
     NodeProperties::ReplaceUses(node, node, ephi);
 
     // Turn the {node} into a Phi.
     node->ReplaceInput(0, vtrue);
     node->ReplaceInput(1, vfalse);
     node->ReplaceInput(2, merge);
     node->TrimInputCount(3);
-    NodeProperties::ChangeOp(node, common()->Phi(output_type, 2));
+    NodeProperties::ChangeOp(node,
+                             common()->Phi(output_type.representation(), 2));
   } else {
     NodeProperties::ChangeOp(node, machine()->CheckedLoad(type));
   }
 }
 
 
 void SimplifiedLowering::DoStoreBuffer(Node* node) {
   DCHECK_EQ(IrOpcode::kStoreBuffer, node->opcode());
   MachineType const type = BufferAccessOf(node->op()).machine_type();
   NodeProperties::ChangeOp(node, machine()->CheckedStore(type));
 }
 
 
 void SimplifiedLowering::DoObjectIsNumber(Node* node) {
   Node* input = NodeProperties::GetValueInput(node, 0);
   // TODO(bmeurer): Optimize somewhat based on input type.
   Node* check =
       graph()->NewNode(machine()->WordEqual(),
                        graph()->NewNode(machine()->WordAnd(), input,
                                         jsgraph()->IntPtrConstant(kSmiTagMask)),
                        jsgraph()->IntPtrConstant(kSmiTag));
   Node* branch = graph()->NewNode(common()->Branch(), check, graph()->start());
   Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* vtrue = jsgraph()->Int32Constant(1);
   Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
   Node* vfalse = graph()->NewNode(
       machine()->WordEqual(),
       graph()->NewNode(
-          machine()->Load(kMachAnyTagged), input,
+          machine()->Load(MachineType::AnyTagged()), input,
           jsgraph()->IntPtrConstant(HeapObject::kMapOffset - kHeapObjectTag),
           graph()->start(), if_false),
       jsgraph()->HeapConstant(isolate()->factory()->heap_number_map()));
   Node* control = graph()->NewNode(common()->Merge(2), if_true, if_false);
   node->ReplaceInput(0, vtrue);
   node->AppendInput(graph()->zone(), vfalse);
   node->AppendInput(graph()->zone(), control);
-  NodeProperties::ChangeOp(node, common()->Phi(kMachBool, 2));
+  NodeProperties::ChangeOp(node, common()->Phi(MachineRepresentation::kBit, 2));
 }
 
 
 void SimplifiedLowering::DoObjectIsSmi(Node* node) {
   node->ReplaceInput(0,
                      graph()->NewNode(machine()->WordAnd(), node->InputAt(0),
                                       jsgraph()->IntPtrConstant(kSmiTagMask)));
   node->AppendInput(graph()->zone(), jsgraph()->IntPtrConstant(kSmiTag));
   NodeProperties::ChangeOp(node, machine()->WordEqual());
 }
@@ skipping 37 matching lines @@
   //      if rhs < -1 then
   //        lhs / rhs
   //      else if rhs == 0 then
   //        0
   //      else
   //        0 - lhs
   //
   // Note: We do not use the Diamond helper class here, because it really hurts
   // readability with nested diamonds.
   const Operator* const merge_op = common()->Merge(2);
-  const Operator* const phi_op = common()->Phi(kMachInt32, 2);
+  const Operator* const phi_op =
+      common()->Phi(MachineRepresentation::kWord32, 2);
 
   Node* check0 = graph()->NewNode(machine()->Int32LessThan(), zero, rhs);
   Node* branch0 = graph()->NewNode(common()->Branch(BranchHint::kTrue), check0,
                                    graph()->start());
 
   Node* if_true0 = graph()->NewNode(common()->IfTrue(), branch0);
   Node* true0 = graph()->NewNode(machine()->Int32Div(), lhs, rhs, if_true0);
 
   Node* if_false0 = graph()->NewNode(common()->IfFalse(), branch0);
   Node* false0;
@@ skipping 56 matching lines @@
   //         lhs & msk
   //   else
   //     if rhs < -1 then
   //       lhs % rhs
   //     else
   //       zero
   //
   // Note: We do not use the Diamond helper class here, because it really hurts
   // readability with nested diamonds.
   const Operator* const merge_op = common()->Merge(2);
-  const Operator* const phi_op = common()->Phi(kMachInt32, 2);
+  const Operator* const phi_op =
+      common()->Phi(MachineRepresentation::kWord32, 2);
 
   Node* check0 = graph()->NewNode(machine()->Int32LessThan(), zero, rhs);
   Node* branch0 = graph()->NewNode(common()->Branch(BranchHint::kTrue), check0,
                                    graph()->start());
 
   Node* if_true0 = graph()->NewNode(common()->IfTrue(), branch0);
   Node* true0;
   {
     Node* msk = graph()->NewNode(machine()->Int32Add(), rhs, minus_one);
 
@@ skipping 58 matching lines @@
 
   if (m.right().Is(0)) {
     return zero;
   } else if (machine()->Uint32DivIsSafe() || m.right().HasValue()) {
     return graph()->NewNode(machine()->Uint32Div(), lhs, rhs, graph()->start());
   }
 
   Node* check = graph()->NewNode(machine()->Word32Equal(), rhs, zero);
   Diamond d(graph(), common(), check, BranchHint::kFalse);
   Node* div = graph()->NewNode(machine()->Uint32Div(), lhs, rhs, d.if_false);
-  return d.Phi(kMachUint32, zero, div);
+  return d.Phi(MachineRepresentation::kWord32, zero, div);
 }
 
 
 Node* SimplifiedLowering::Uint32Mod(Node* const node) {
   Uint32BinopMatcher m(node);
   Node* const minus_one = jsgraph()->Int32Constant(-1);
   Node* const zero = jsgraph()->Uint32Constant(0);
   Node* const lhs = m.left().node();
   Node* const rhs = m.right().node();
 
@@ skipping 11 matching lines @@
   //     if rhs & msk != 0 then
   //       lhs % rhs
   //     else
   //       lhs & msk
   //   else
   //     zero
   //
   // Note: We do not use the Diamond helper class here, because it really hurts
   // readability with nested diamonds.
   const Operator* const merge_op = common()->Merge(2);
-  const Operator* const phi_op = common()->Phi(kMachInt32, 2);
+  const Operator* const phi_op =
+      common()->Phi(MachineRepresentation::kWord32, 2);
 
   Node* branch0 = graph()->NewNode(common()->Branch(BranchHint::kTrue), rhs,
                                    graph()->start());
 
   Node* if_true0 = graph()->NewNode(common()->IfTrue(), branch0);
   Node* true0;
   {
     Node* msk = graph()->NewNode(machine()->Int32Add(), rhs, minus_one);
 
     Node* check1 = graph()->NewNode(machine()->Word32And(), rhs, msk);
@@ skipping 70 matching lines @@
   ReplaceEffectUses(node, comparison);
   node->ReplaceInput(0, comparison);
   node->ReplaceInput(1, jsgraph()->SmiConstant(EQUAL));
   node->TrimInputCount(2);
   NodeProperties::ChangeOp(node, machine()->IntLessThanOrEqual());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8