Move Hydrogen and Lithium to src/crankshaft/

src/hydrogen-instructions.h

-// Copyright 2012 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.
-
-#ifndef V8_HYDROGEN_INSTRUCTIONS_H_
-#define V8_HYDROGEN_INSTRUCTIONS_H_
-
-#include <cstring>
-#include <iosfwd>
-
-#include "src/allocation.h"
-#include "src/base/bits.h"
-#include "src/bit-vector.h"
-#include "src/code-stubs.h"
-#include "src/conversions.h"
-#include "src/deoptimizer.h"
-#include "src/hydrogen-types.h"
-#include "src/small-pointer-list.h"
-#include "src/unique.h"
-#include "src/utils.h"
-#include "src/zone.h"
-
-namespace v8 {
-namespace internal {
-
-// Forward declarations.
-struct ChangesOf;
-class HBasicBlock;
-class HDiv;
-class HEnvironment;
-class HInferRepresentationPhase;
-class HInstruction;
-class HLoopInformation;
-class HStoreNamedField;
-class HValue;
-class LInstruction;
-class LChunkBuilder;
-
-#define HYDROGEN_ABSTRACT_INSTRUCTION_LIST(V) \
-  V(ArithmeticBinaryOperation)                \
-  V(BinaryOperation)                          \
-  V(BitwiseBinaryOperation)                   \
-  V(ControlInstruction)                       \
-  V(Instruction)
-
-
-#define HYDROGEN_CONCRETE_INSTRUCTION_LIST(V) \
-  V(AbnormalExit)                             \
-  V(AccessArgumentsAt)                        \
-  V(Add)                                      \
-  V(AllocateBlockContext)                     \
-  V(Allocate)                                 \
-  V(ApplyArguments)                           \
-  V(ArgumentsElements)                        \
-  V(ArgumentsLength)                          \
-  V(ArgumentsObject)                          \
-  V(Bitwise)                                  \
-  V(BlockEntry)                               \
-  V(BoundsCheck)                              \
-  V(BoundsCheckBaseIndexInformation)          \
-  V(Branch)                                   \
-  V(CallWithDescriptor)                       \
-  V(CallJSFunction)                           \
-  V(CallFunction)                             \
-  V(CallNew)                                  \
-  V(CallNewArray)                             \
-  V(CallRuntime)                              \
-  V(CallStub)                                 \
-  V(CapturedObject)                           \
-  V(Change)                                   \
-  V(CheckArrayBufferNotNeutered)              \
-  V(CheckHeapObject)                          \
-  V(CheckInstanceType)                        \
-  V(CheckMaps)                                \
-  V(CheckMapValue)                            \
-  V(CheckSmi)                                 \
-  V(CheckValue)                               \
-  V(ClampToUint8)                             \
-  V(ClassOfTestAndBranch)                     \
-  V(CompareNumericAndBranch)                  \
-  V(CompareHoleAndBranch)                     \
-  V(CompareGeneric)                           \
-  V(CompareMinusZeroAndBranch)                \
-  V(CompareObjectEqAndBranch)                 \
-  V(CompareMap)                               \
-  V(Constant)                                 \
-  V(ConstructDouble)                          \
-  V(Context)                                  \
-  V(DateField)                                \
-  V(DebugBreak)                               \
-  V(DeclareGlobals)                           \
-  V(Deoptimize)                               \
-  V(Div)                                      \
-  V(DoubleBits)                               \
-  V(DummyUse)                                 \
-  V(EnterInlined)                             \
-  V(EnvironmentMarker)                        \
-  V(ForceRepresentation)                      \
-  V(ForInCacheArray)                          \
-  V(ForInPrepareMap)                          \
-  V(GetCachedArrayIndex)                      \
-  V(Goto)                                     \
-  V(HasCachedArrayIndexAndBranch)             \
-  V(HasInstanceTypeAndBranch)                 \
-  V(InnerAllocatedObject)                     \
-  V(InstanceOf)                               \
-  V(InvokeFunction)                           \
-  V(IsConstructCallAndBranch)                 \
-  V(HasInPrototypeChainAndBranch)             \
-  V(IsStringAndBranch)                        \
-  V(IsSmiAndBranch)                           \
-  V(IsUndetectableAndBranch)                  \
-  V(LeaveInlined)                             \
-  V(LoadContextSlot)                          \
-  V(LoadFieldByIndex)                         \
-  V(LoadFunctionPrototype)                    \
-  V(LoadGlobalGeneric)                        \
-  V(LoadGlobalViaContext)                     \
-  V(LoadKeyed)                                \
-  V(LoadKeyedGeneric)                         \
-  V(LoadNamedField)                           \
-  V(LoadNamedGeneric)                         \
-  V(LoadRoot)                                 \
-  V(MapEnumLength)                            \
-  V(MathFloorOfDiv)                           \
-  V(MathMinMax)                               \
-  V(MaybeGrowElements)                        \
-  V(Mod)                                      \
-  V(Mul)                                      \
-  V(OsrEntry)                                 \
-  V(Parameter)                                \
-  V(Power)                                    \
-  V(Prologue)                                 \
-  V(PushArguments)                            \
-  V(RegExpLiteral)                            \
-  V(Return)                                   \
-  V(Ror)                                      \
-  V(Sar)                                      \
-  V(SeqStringGetChar)                         \
-  V(SeqStringSetChar)                         \
-  V(Shl)                                      \
-  V(Shr)                                      \
-  V(Simulate)                                 \
-  V(StackCheck)                               \
-  V(StoreCodeEntry)                           \
-  V(StoreContextSlot)                         \
-  V(StoreFrameContext)                        \
-  V(StoreGlobalViaContext)                    \
-  V(StoreKeyed)                               \
-  V(StoreKeyedGeneric)                        \
-  V(StoreNamedField)                          \
-  V(StoreNamedGeneric)                        \
-  V(StringAdd)                                \
-  V(StringCharCodeAt)                         \
-  V(StringCharFromCode)                       \
-  V(StringCompareAndBranch)                   \
-  V(Sub)                                      \
-  V(ThisFunction)                             \
-  V(ToFastProperties)                         \
-  V(TransitionElementsKind)                   \
-  V(TrapAllocationMemento)                    \
-  V(Typeof)                                   \
-  V(TypeofIsAndBranch)                        \
-  V(UnaryMathOperation)                       \
-  V(UnknownOSRValue)                          \
-  V(UseConst)                                 \
-  V(WrapReceiver)
-
-#define GVN_TRACKED_FLAG_LIST(V)               \
-  V(NewSpacePromotion)
-
-#define GVN_UNTRACKED_FLAG_LIST(V)             \
-  V(ArrayElements)                             \
-  V(ArrayLengths)                              \
-  V(StringLengths)                             \
-  V(BackingStoreFields)                        \
-  V(Calls)                                     \
-  V(ContextSlots)                              \
-  V(DoubleArrayElements)                       \
-  V(DoubleFields)                              \
-  V(ElementsKind)                              \
-  V(ElementsPointer)                           \
-  V(GlobalVars)                                \
-  V(InobjectFields)                            \
-  V(Maps)                                      \
-  V(OsrEntries)                                \
-  V(ExternalMemory)                            \
-  V(StringChars)                               \
-  V(TypedArrayElements)
-
-
-#define DECLARE_ABSTRACT_INSTRUCTION(type)     \
-  bool Is##type() const final { return true; } \
-  static H##type* cast(HValue* value) {        \
-    DCHECK(value->Is##type());                 \
-    return reinterpret_cast<H##type*>(value);  \
-  }
-
-
-#define DECLARE_CONCRETE_INSTRUCTION(type)                      \
-  LInstruction* CompileToLithium(LChunkBuilder* builder) final; \
-  static H##type* cast(HValue* value) {                         \
-    DCHECK(value->Is##type());                                  \
-    return reinterpret_cast<H##type*>(value);                   \
-  }                                                             \
-  Opcode opcode() const final { return HValue::k##type; }
-
-
-enum PropertyAccessType { LOAD, STORE };
-
-
-class Range final : public ZoneObject {
- public:
-  Range()
-      : lower_(kMinInt),
-        upper_(kMaxInt),
-        next_(NULL),
-        can_be_minus_zero_(false) { }
-
-  Range(int32_t lower, int32_t upper)
-      : lower_(lower),
-        upper_(upper),
-        next_(NULL),
-        can_be_minus_zero_(false) { }
-
-  int32_t upper() const { return upper_; }
-  int32_t lower() const { return lower_; }
-  Range* next() const { return next_; }
-  Range* CopyClearLower(Zone* zone) const {
-    return new(zone) Range(kMinInt, upper_);
-  }
-  Range* CopyClearUpper(Zone* zone) const {
-    return new(zone) Range(lower_, kMaxInt);
-  }
-  Range* Copy(Zone* zone) const {
-    Range* result = new(zone) Range(lower_, upper_);
-    result->set_can_be_minus_zero(CanBeMinusZero());
-    return result;
-  }
-  int32_t Mask() const;
-  void set_can_be_minus_zero(bool b) { can_be_minus_zero_ = b; }
-  bool CanBeMinusZero() const { return CanBeZero() && can_be_minus_zero_; }
-  bool CanBeZero() const { return upper_ >= 0 && lower_ <= 0; }
-  bool CanBeNegative() const { return lower_ < 0; }
-  bool CanBePositive() const { return upper_ > 0; }
-  bool Includes(int value) const { return lower_ <= value && upper_ >= value; }
-  bool IsMostGeneric() const {
-    return lower_ == kMinInt && upper_ == kMaxInt && CanBeMinusZero();
-  }
-  bool IsInSmiRange() const {
-    return lower_ >= Smi::kMinValue && upper_ <= Smi::kMaxValue;
-  }
-  void ClampToSmi() {
-    lower_ = Max(lower_, Smi::kMinValue);
-    upper_ = Min(upper_, Smi::kMaxValue);
-  }
-  void KeepOrder();
-#ifdef DEBUG
-  void Verify() const;
-#endif
-
-  void StackUpon(Range* other) {
-    Intersect(other);
-    next_ = other;
-  }
-
-  void Intersect(Range* other);
-  void Union(Range* other);
-  void CombinedMax(Range* other);
-  void CombinedMin(Range* other);
-
-  void AddConstant(int32_t value);
-  void Sar(int32_t value);
-  void Shl(int32_t value);
-  bool AddAndCheckOverflow(const Representation& r, Range* other);
-  bool SubAndCheckOverflow(const Representation& r, Range* other);
-  bool MulAndCheckOverflow(const Representation& r, Range* other);
-
- private:
-  int32_t lower_;
-  int32_t upper_;
-  Range* next_;
-  bool can_be_minus_zero_;
-};
-
-
-class HUseListNode: public ZoneObject {
- public:
-  HUseListNode(HValue* value, int index, HUseListNode* tail)
-      : tail_(tail), value_(value), index_(index) {
-  }
-
-  HUseListNode* tail();
-  HValue* value() const { return value_; }
-  int index() const { return index_; }
-
-  void set_tail(HUseListNode* list) { tail_ = list; }
-
-#ifdef DEBUG
-  void Zap() {
-    tail_ = reinterpret_cast<HUseListNode*>(1);
-    value_ = NULL;
-    index_ = -1;
-  }
-#endif
-
- private:
-  HUseListNode* tail_;
-  HValue* value_;
-  int index_;
-};
-
-
-// We reuse use list nodes behind the scenes as uses are added and deleted.
-// This class is the safe way to iterate uses while deleting them.
-class HUseIterator final BASE_EMBEDDED {
- public:
-  bool Done() { return current_ == NULL; }
-  void Advance();
-
-  HValue* value() {
-    DCHECK(!Done());
-    return value_;
-  }
-
-  int index() {
-    DCHECK(!Done());
-    return index_;
-  }
-
- private:
-  explicit HUseIterator(HUseListNode* head);
-
-  HUseListNode* current_;
-  HUseListNode* next_;
-  HValue* value_;
-  int index_;
-
-  friend class HValue;
-};
-
-
-// All tracked flags should appear before untracked ones.
-enum GVNFlag {
-  // Declare global value numbering flags.
-#define DECLARE_FLAG(Type) k##Type,
-  GVN_TRACKED_FLAG_LIST(DECLARE_FLAG)
-  GVN_UNTRACKED_FLAG_LIST(DECLARE_FLAG)
-#undef DECLARE_FLAG
-#define COUNT_FLAG(Type) + 1
-  kNumberOfTrackedSideEffects = 0 GVN_TRACKED_FLAG_LIST(COUNT_FLAG),
-  kNumberOfUntrackedSideEffects = 0 GVN_UNTRACKED_FLAG_LIST(COUNT_FLAG),
-#undef COUNT_FLAG
-  kNumberOfFlags = kNumberOfTrackedSideEffects + kNumberOfUntrackedSideEffects
-};
-
-
-static inline GVNFlag GVNFlagFromInt(int i) {
-  DCHECK(i >= 0);
-  DCHECK(i < kNumberOfFlags);
-  return static_cast<GVNFlag>(i);
-}
-
-
-class DecompositionResult final BASE_EMBEDDED {
- public:
-  DecompositionResult() : base_(NULL), offset_(0), scale_(0) {}
-
-  HValue* base() { return base_; }
-  int offset() { return offset_; }
-  int scale() { return scale_; }
-
-  bool Apply(HValue* other_base, int other_offset, int other_scale = 0) {
-    if (base_ == NULL) {
-      base_ = other_base;
-      offset_ = other_offset;
-      scale_ = other_scale;
-      return true;
-    } else {
-      if (scale_ == 0) {
-        base_ = other_base;
-        offset_ += other_offset;
-        scale_ = other_scale;
-        return true;
-      } else {
-        return false;
-      }
-    }
-  }
-
-  void SwapValues(HValue** other_base, int* other_offset, int* other_scale) {
-    swap(&base_, other_base);
-    swap(&offset_, other_offset);
-    swap(&scale_, other_scale);
-  }
-
- private:
-  template <class T> void swap(T* a, T* b) {
-    T c(*a);
-    *a = *b;
-    *b = c;
-  }
-
-  HValue* base_;
-  int offset_;
-  int scale_;
-};
-
-
-typedef EnumSet<GVNFlag, int32_t> GVNFlagSet;
-
-
-class HValue : public ZoneObject {
- public:
-  static const int kNoNumber = -1;
-
-  enum Flag {
-    kFlexibleRepresentation,
-    kCannotBeTagged,
-    // Participate in Global Value Numbering, i.e. elimination of
-    // unnecessary recomputations. If an instruction sets this flag, it must
-    // implement DataEquals(), which will be used to determine if other
-    // occurrences of the instruction are indeed the same.
-    kUseGVN,
-    // Track instructions that are dominating side effects. If an instruction
-    // sets this flag, it must implement HandleSideEffectDominator() and should
-    // indicate which side effects to track by setting GVN flags.
-    kTrackSideEffectDominators,
-    kCanOverflow,
-    kBailoutOnMinusZero,
-    kCanBeDivByZero,
-    kLeftCanBeMinInt,
-    kLeftCanBeNegative,
-    kLeftCanBePositive,
-    kAllowUndefinedAsNaN,
-    kIsArguments,
-    kTruncatingToInt32,
-    kAllUsesTruncatingToInt32,
-    kTruncatingToSmi,
-    kAllUsesTruncatingToSmi,
-    // Set after an instruction is killed.
-    kIsDead,
-    // Instructions that are allowed to produce full range unsigned integer
-    // values are marked with kUint32 flag. If arithmetic shift or a load from
-    // EXTERNAL_UINT32_ELEMENTS array is not marked with this flag
-    // it will deoptimize if result does not fit into signed integer range.
-    // HGraph::ComputeSafeUint32Operations is responsible for setting this
-    // flag.
-    kUint32,
-    kHasNoObservableSideEffects,
-    // Indicates an instruction shouldn't be replaced by optimization, this flag
-    // is useful to set in cases where recomputing a value is cheaper than
-    // extending the value's live range and spilling it.
-    kCantBeReplaced,
-    // Indicates the instruction is live during dead code elimination.
-    kIsLive,
-
-    // HEnvironmentMarkers are deleted before dead code
-    // elimination takes place, so they can repurpose the kIsLive flag:
-    kEndsLiveRange = kIsLive,
-
-    // TODO(everyone): Don't forget to update this!
-    kLastFlag = kIsLive
-  };
-
-  STATIC_ASSERT(kLastFlag < kBitsPerInt);
-
-  static HValue* cast(HValue* value) { return value; }
-
-  enum Opcode {
-    // Declare a unique enum value for each hydrogen instruction.
-  #define DECLARE_OPCODE(type) k##type,
-    HYDROGEN_CONCRETE_INSTRUCTION_LIST(DECLARE_OPCODE)
-    kPhi
-  #undef DECLARE_OPCODE
-  };
-  virtual Opcode opcode() const = 0;
-
-  // Declare a non-virtual predicates for each concrete HInstruction or HValue.
-  #define DECLARE_PREDICATE(type) \
-    bool Is##type() const { return opcode() == k##type; }
-    HYDROGEN_CONCRETE_INSTRUCTION_LIST(DECLARE_PREDICATE)
-  #undef DECLARE_PREDICATE
-    bool IsPhi() const { return opcode() == kPhi; }
-
-  // Declare virtual predicates for abstract HInstruction or HValue
-  #define DECLARE_PREDICATE(type) \
-    virtual bool Is##type() const { return false; }
-    HYDROGEN_ABSTRACT_INSTRUCTION_LIST(DECLARE_PREDICATE)
-  #undef DECLARE_PREDICATE
-
-  bool IsBitwiseBinaryShift() {
-    return IsShl() || IsShr() || IsSar();
-  }
-
-  explicit HValue(HType type = HType::Tagged())
-      : block_(NULL),
-        id_(kNoNumber),
-        type_(type),
-        use_list_(NULL),
-        range_(NULL),
-#ifdef DEBUG
-        range_poisoned_(false),
-#endif
-        flags_(0) {}
-  virtual ~HValue() {}
-
-  virtual SourcePosition position() const { return SourcePosition::Unknown(); }
-  virtual SourcePosition operand_position(int index) const {
-    return position();
-  }
-
-  HBasicBlock* block() const { return block_; }
-  void SetBlock(HBasicBlock* block);
-
-  // Note: Never call this method for an unlinked value.
-  Isolate* isolate() const;
-
-  int id() const { return id_; }
-  void set_id(int id) { id_ = id; }
-
-  HUseIterator uses() const { return HUseIterator(use_list_); }
-
-  virtual bool EmitAtUses() { return false; }
-
-  Representation representation() const { return representation_; }
-  void ChangeRepresentation(Representation r) {
-    DCHECK(CheckFlag(kFlexibleRepresentation));
-    DCHECK(!CheckFlag(kCannotBeTagged) || !r.IsTagged());
-    RepresentationChanged(r);
-    representation_ = r;
-    if (r.IsTagged()) {
-      // Tagged is the bottom of the lattice, don't go any further.
-      ClearFlag(kFlexibleRepresentation);
-    }
-  }
-  virtual void AssumeRepresentation(Representation r);
-
-  virtual Representation KnownOptimalRepresentation() {
-    Representation r = representation();
-    if (r.IsTagged()) {
-      HType t = type();
-      if (t.IsSmi()) return Representation::Smi();
-      if (t.IsHeapNumber()) return Representation::Double();
-      if (t.IsHeapObject()) return r;
-      return Representation::None();
-    }
-    return r;
-  }
-
-  HType type() const { return type_; }
-  void set_type(HType new_type) {
-    DCHECK(new_type.IsSubtypeOf(type_));
-    type_ = new_type;
-  }
-
-  // There are HInstructions that do not really change a value, they
-  // only add pieces of information to it (like bounds checks, map checks,
-  // smi checks...).
-  // We call these instructions "informative definitions", or "iDef".
-  // One of the iDef operands is special because it is the value that is
-  // "transferred" to the output, we call it the "redefined operand".
-  // If an HValue is an iDef it must override RedefinedOperandIndex() so that
-  // it does not return kNoRedefinedOperand;
-  static const int kNoRedefinedOperand = -1;
-  virtual int RedefinedOperandIndex() { return kNoRedefinedOperand; }
-  bool IsInformativeDefinition() {
-    return RedefinedOperandIndex() != kNoRedefinedOperand;
-  }
-  HValue* RedefinedOperand() {
-    int index = RedefinedOperandIndex();
-    return index == kNoRedefinedOperand ? NULL : OperandAt(index);
-  }
-
-  bool CanReplaceWithDummyUses();
-
-  virtual int argument_delta() const { return 0; }
-
-  // A purely informative definition is an idef that will not emit code and
-  // should therefore be removed from the graph in the RestoreActualValues
-  // phase (so that live ranges will be shorter).
-  virtual bool IsPurelyInformativeDefinition() { return false; }
-
-  // This method must always return the original HValue SSA definition,
-  // regardless of any chain of iDefs of this value.
-  HValue* ActualValue() {
-    HValue* value = this;
-    int index;
-    while ((index = value->RedefinedOperandIndex()) != kNoRedefinedOperand) {
-      value = value->OperandAt(index);
-    }
-    return value;
-  }
-
-  bool IsInteger32Constant();
-  int32_t GetInteger32Constant();
-  bool EqualsInteger32Constant(int32_t value);
-
-  bool IsDefinedAfter(HBasicBlock* other) const;
-
-  // Operands.
-  virtual int OperandCount() const = 0;
-  virtual HValue* OperandAt(int index) const = 0;
-  void SetOperandAt(int index, HValue* value);
-
-  void DeleteAndReplaceWith(HValue* other);
-  void ReplaceAllUsesWith(HValue* other);
-  bool HasNoUses() const { return use_list_ == NULL; }
-  bool HasOneUse() const {
-    return use_list_ != NULL && use_list_->tail() == NULL;
-  }
-  bool HasMultipleUses() const {
-    return use_list_ != NULL && use_list_->tail() != NULL;
-  }
-  int UseCount() const;
-
-  // Mark this HValue as dead and to be removed from other HValues' use lists.
-  void Kill();
-
-  int flags() const { return flags_; }
-  void SetFlag(Flag f) { flags_ |= (1 << f); }
-  void ClearFlag(Flag f) { flags_ &= ~(1 << f); }
-  bool CheckFlag(Flag f) const { return (flags_ & (1 << f)) != 0; }
-  void CopyFlag(Flag f, HValue* other) {
-    if (other->CheckFlag(f)) SetFlag(f);
-  }
-
-  // Returns true if the flag specified is set for all uses, false otherwise.
-  bool CheckUsesForFlag(Flag f) const;
-  // Same as before and the first one without the flag is returned in value.
-  bool CheckUsesForFlag(Flag f, HValue** value) const;
-  // Returns true if the flag specified is set for all uses, and this set
-  // of uses is non-empty.
-  bool HasAtLeastOneUseWithFlagAndNoneWithout(Flag f) const;
-
-  GVNFlagSet ChangesFlags() const { return changes_flags_; }
-  GVNFlagSet DependsOnFlags() const { return depends_on_flags_; }
-  void SetChangesFlag(GVNFlag f) { changes_flags_.Add(f); }
-  void SetDependsOnFlag(GVNFlag f) { depends_on_flags_.Add(f); }
-  void ClearChangesFlag(GVNFlag f) { changes_flags_.Remove(f); }
-  void ClearDependsOnFlag(GVNFlag f) { depends_on_flags_.Remove(f); }
-  bool CheckChangesFlag(GVNFlag f) const {
-    return changes_flags_.Contains(f);
-  }
-  bool CheckDependsOnFlag(GVNFlag f) const {
-    return depends_on_flags_.Contains(f);
-  }
-  void SetAllSideEffects() { changes_flags_.Add(AllSideEffectsFlagSet()); }
-  void ClearAllSideEffects() {
-    changes_flags_.Remove(AllSideEffectsFlagSet());
-  }
-  bool HasSideEffects() const {
-    return changes_flags_.ContainsAnyOf(AllSideEffectsFlagSet());
-  }
-  bool HasObservableSideEffects() const {
-    return !CheckFlag(kHasNoObservableSideEffects) &&
-        changes_flags_.ContainsAnyOf(AllObservableSideEffectsFlagSet());
-  }
-
-  GVNFlagSet SideEffectFlags() const {
-    GVNFlagSet result = ChangesFlags();
-    result.Intersect(AllSideEffectsFlagSet());
-    return result;
-  }
-
-  GVNFlagSet ObservableChangesFlags() const {
-    GVNFlagSet result = ChangesFlags();
-    result.Intersect(AllObservableSideEffectsFlagSet());
-    return result;
-  }
-
-  Range* range() const {
-    DCHECK(!range_poisoned_);
-    return range_;
-  }
-  bool HasRange() const {
-    DCHECK(!range_poisoned_);
-    return range_ != NULL;
-  }
-#ifdef DEBUG
-  void PoisonRange() { range_poisoned_ = true; }
-#endif
-  void AddNewRange(Range* r, Zone* zone);
-  void RemoveLastAddedRange();
-  void ComputeInitialRange(Zone* zone);
-
-  // Escape analysis helpers.
-  virtual bool HasEscapingOperandAt(int index) { return true; }
-  virtual bool HasOutOfBoundsAccess(int size) { return false; }
-
-  // Representation helpers.
-  virtual Representation observed_input_representation(int index) {
-    return Representation::None();
-  }
-  virtual Representation RequiredInputRepresentation(int index) = 0;
-  virtual void InferRepresentation(HInferRepresentationPhase* h_infer);
-
-  // This gives the instruction an opportunity to replace itself with an
-  // instruction that does the same in some better way.  To replace an
-  // instruction with a new one, first add the new instruction to the graph,
-  // then return it.  Return NULL to have the instruction deleted.
-  virtual HValue* Canonicalize() { return this; }
-
-  bool Equals(HValue* other);
-  virtual intptr_t Hashcode();
-
-  // Compute unique ids upfront that is safe wrt GC and concurrent compilation.
-  virtual void FinalizeUniqueness() { }
-
-  // Printing support.
-  virtual std::ostream& PrintTo(std::ostream& os) const = 0;  // NOLINT
-
-  const char* Mnemonic() const;
-
-  // Type information helpers.
-  bool HasMonomorphicJSObjectType();
-
-  // TODO(mstarzinger): For now instructions can override this function to
-  // specify statically known types, once HType can convey more information
-  // it should be based on the HType.
-  virtual Handle<Map> GetMonomorphicJSObjectMap() { return Handle<Map>(); }
-
-  // Updated the inferred type of this instruction and returns true if
-  // it has changed.
-  bool UpdateInferredType();
-
-  virtual HType CalculateInferredType();
-
-  // This function must be overridden for instructions which have the
-  // kTrackSideEffectDominators flag set, to track instructions that are
-  // dominating side effects.
-  // It returns true if it removed an instruction which had side effects.
-  virtual bool HandleSideEffectDominator(GVNFlag side_effect,
-                                         HValue* dominator) {
-    UNREACHABLE();
-    return false;
-  }
-
-  // Check if this instruction has some reason that prevents elimination.
-  bool CannotBeEliminated() const {
-    return HasObservableSideEffects() || !IsDeletable();
-  }
-
-#ifdef DEBUG
-  virtual void Verify() = 0;
-#endif
-
-  virtual bool TryDecompose(DecompositionResult* decomposition) {
-    if (RedefinedOperand() != NULL) {
-      return RedefinedOperand()->TryDecompose(decomposition);
-    } else {
-      return false;
-    }
-  }
-
-  // Returns true conservatively if the program might be able to observe a
-  // ToString() operation on this value.
-  bool ToStringCanBeObserved() const {
-    return ToStringOrToNumberCanBeObserved();
-  }
-
-  // Returns true conservatively if the program might be able to observe a
-  // ToNumber() operation on this value.
-  bool ToNumberCanBeObserved() const {
-    return ToStringOrToNumberCanBeObserved();
-  }
-
-  MinusZeroMode GetMinusZeroMode() {
-    return CheckFlag(kBailoutOnMinusZero)
-        ? FAIL_ON_MINUS_ZERO : TREAT_MINUS_ZERO_AS_ZERO;
-  }
-
- protected:
-  // This function must be overridden for instructions with flag kUseGVN, to
-  // compare the non-Operand parts of the instruction.
-  virtual bool DataEquals(HValue* other) {
-    UNREACHABLE();
-    return false;
-  }
-
-  bool ToStringOrToNumberCanBeObserved() const {
-    if (type().IsTaggedPrimitive()) return false;
-    if (type().IsJSObject()) return true;
-    return !representation().IsSmiOrInteger32() && !representation().IsDouble();
-  }
-
-  virtual Representation RepresentationFromInputs() {
-    return representation();
-  }
-  virtual Representation RepresentationFromUses();
-  Representation RepresentationFromUseRequirements();
-  bool HasNonSmiUse();
-  virtual void UpdateRepresentation(Representation new_rep,
-                                    HInferRepresentationPhase* h_infer,
-                                    const char* reason);
-  void AddDependantsToWorklist(HInferRepresentationPhase* h_infer);
-
-  virtual void RepresentationChanged(Representation to) { }
-
-  virtual Range* InferRange(Zone* zone);
-  virtual void DeleteFromGraph() = 0;
-  virtual void InternalSetOperandAt(int index, HValue* value) = 0;
-  void clear_block() {
-    DCHECK(block_ != NULL);
-    block_ = NULL;
-  }
-
-  void set_representation(Representation r) {
-    DCHECK(representation_.IsNone() && !r.IsNone());
-    representation_ = r;
-  }
-
-  static GVNFlagSet AllFlagSet() {
-    GVNFlagSet result;
-#define ADD_FLAG(Type) result.Add(k##Type);
-  GVN_TRACKED_FLAG_LIST(ADD_FLAG)
-  GVN_UNTRACKED_FLAG_LIST(ADD_FLAG)
-#undef ADD_FLAG
-    return result;
-  }
-
-  // A flag mask to mark an instruction as having arbitrary side effects.
-  static GVNFlagSet AllSideEffectsFlagSet() {
-    GVNFlagSet result = AllFlagSet();
-    result.Remove(kOsrEntries);
-    return result;
-  }
-  friend std::ostream& operator<<(std::ostream& os, const ChangesOf& v);
-
-  // A flag mask of all side effects that can make observable changes in
-  // an executing program (i.e. are not safe to repeat, move or remove);
-  static GVNFlagSet AllObservableSideEffectsFlagSet() {
-    GVNFlagSet result = AllFlagSet();
-    result.Remove(kNewSpacePromotion);
-    result.Remove(kElementsKind);
-    result.Remove(kElementsPointer);
-    result.Remove(kMaps);
-    return result;
-  }
-
-  // Remove the matching use from the use list if present.  Returns the
-  // removed list node or NULL.
-  HUseListNode* RemoveUse(HValue* value, int index);
-
-  void RegisterUse(int index, HValue* new_value);
-
-  HBasicBlock* block_;
-
-  // The id of this instruction in the hydrogen graph, assigned when first
-  // added to the graph. Reflects creation order.
-  int id_;
-
-  Representation representation_;
-  HType type_;
-  HUseListNode* use_list_;
-  Range* range_;
-#ifdef DEBUG
-  bool range_poisoned_;
-#endif
-  int flags_;
-  GVNFlagSet changes_flags_;
-  GVNFlagSet depends_on_flags_;
-
- private:
-  virtual bool IsDeletable() const { return false; }
-
-  DISALLOW_COPY_AND_ASSIGN(HValue);
-};
-
-// Support for printing various aspects of an HValue.
-struct NameOf {
-  explicit NameOf(const HValue* const v) : value(v) {}
-  const HValue* value;
-};
-
-
-struct TypeOf {
-  explicit TypeOf(const HValue* const v) : value(v) {}
-  const HValue* value;
-};
-
-
-struct ChangesOf {
-  explicit ChangesOf(const HValue* const v) : value(v) {}
-  const HValue* value;
-};
-
-
-std::ostream& operator<<(std::ostream& os, const HValue& v);
-std::ostream& operator<<(std::ostream& os, const NameOf& v);
-std::ostream& operator<<(std::ostream& os, const TypeOf& v);
-std::ostream& operator<<(std::ostream& os, const ChangesOf& v);
-
-
-#define DECLARE_INSTRUCTION_FACTORY_P0(I)                        \
-  static I* New(Isolate* isolate, Zone* zone, HValue* context) { \
-    return new (zone) I();                                       \
-  }
-
-#define DECLARE_INSTRUCTION_FACTORY_P1(I, P1)                           \
-  static I* New(Isolate* isolate, Zone* zone, HValue* context, P1 p1) { \
-    return new (zone) I(p1);                                            \
-  }
-
-#define DECLARE_INSTRUCTION_FACTORY_P2(I, P1, P2)                              \
-  static I* New(Isolate* isolate, Zone* zone, HValue* context, P1 p1, P2 p2) { \
-    return new (zone) I(p1, p2);                                               \
-  }
-
-#define DECLARE_INSTRUCTION_FACTORY_P3(I, P1, P2, P3)                        \
-  static I* New(Isolate* isolate, Zone* zone, HValue* context, P1 p1, P2 p2, \
-                P3 p3) {                                                     \
-    return new (zone) I(p1, p2, p3);                                         \
-  }
-
-#define DECLARE_INSTRUCTION_FACTORY_P4(I, P1, P2, P3, P4)                    \
-  static I* New(Isolate* isolate, Zone* zone, HValue* context, P1 p1, P2 p2, \
-                P3 p3, P4 p4) {                                              \
-    return new (zone) I(p1, p2, p3, p4);                                     \
-  }
-
-#define DECLARE_INSTRUCTION_FACTORY_P5(I, P1, P2, P3, P4, P5)                \
-  static I* New(Isolate* isolate, Zone* zone, HValue* context, P1 p1, P2 p2, \
-                P3 p3, P4 p4, P5 p5) {                                       \
-    return new (zone) I(p1, p2, p3, p4, p5);                                 \
-  }
-
-#define DECLARE_INSTRUCTION_FACTORY_P6(I, P1, P2, P3, P4, P5, P6)            \
-  static I* New(Isolate* isolate, Zone* zone, HValue* context, P1 p1, P2 p2, \
-                P3 p3, P4 p4, P5 p5, P6 p6) {                                \
-    return new (zone) I(p1, p2, p3, p4, p5, p6);                             \
-  }
-
-#define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P0(I)           \
-  static I* New(Isolate* isolate, Zone* zone, HValue* context) { \
-    return new (zone) I(context);                                \
-  }
-
-#define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P1(I, P1)              \
-  static I* New(Isolate* isolate, Zone* zone, HValue* context, P1 p1) { \
-    return new (zone) I(context, p1);                                   \
-  }
-
-#define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(I, P1, P2)                 \
-  static I* New(Isolate* isolate, Zone* zone, HValue* context, P1 p1, P2 p2) { \
-    return new (zone) I(context, p1, p2);                                      \
-  }
-
-#define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(I, P1, P2, P3)           \
-  static I* New(Isolate* isolate, Zone* zone, HValue* context, P1 p1, P2 p2, \
-                P3 p3) {                                                     \
-    return new (zone) I(context, p1, p2, p3);                                \
-  }
-
-#define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P4(I, P1, P2, P3, P4)       \
-  static I* New(Isolate* isolate, Zone* zone, HValue* context, P1 p1, P2 p2, \
-                P3 p3, P4 p4) {                                              \
-    return new (zone) I(context, p1, p2, p3, p4);                            \
-  }
-
-#define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P5(I, P1, P2, P3, P4, P5)   \
-  static I* New(Isolate* isolate, Zone* zone, HValue* context, P1 p1, P2 p2, \
-                P3 p3, P4 p4, P5 p5) {                                       \
-    return new (zone) I(context, p1, p2, p3, p4, p5);                        \
-  }
-
-#define DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P6(I, P1, P2, P3, P4, P5, P6) \
-  static I* New(Isolate* isolate, Zone* zone, HValue* context, P1 p1, P2 p2,   \
-                P3 p3, P4 p4, P5 p5, P6 p6) {                                  \
-    return new (zone) I(context, p1, p2, p3, p4, p5, p6);                      \
-  }
-
-
-// A helper class to represent per-operand position information attached to
-// the HInstruction in the compact form. Uses tagging to distinguish between
-// case when only instruction's position is available and case when operands'
-// positions are also available.
-// In the first case it contains intruction's position as a tagged value.
-// In the second case it points to an array which contains instruction's
-// position and operands' positions.
-class HPositionInfo {
- public:
-  explicit HPositionInfo(int pos) : data_(TagPosition(pos)) { }
-
-  SourcePosition position() const {
-    if (has_operand_positions()) {
-      return operand_positions()[kInstructionPosIndex];
-    }
-    return SourcePosition::FromRaw(static_cast<int>(UntagPosition(data_)));
-  }
-
-  void set_position(SourcePosition pos) {
-    if (has_operand_positions()) {
-      operand_positions()[kInstructionPosIndex] = pos;
-    } else {
-      data_ = TagPosition(pos.raw());
-    }
-  }
-
-  void ensure_storage_for_operand_positions(Zone* zone, int operand_count) {
-    if (has_operand_positions()) {
-      return;
-    }
-
-    const int length = kFirstOperandPosIndex + operand_count;
-    SourcePosition* positions = zone->NewArray<SourcePosition>(length);
-    for (int i = 0; i < length; i++) {
-      positions[i] = SourcePosition::Unknown();
-    }
-
-    const SourcePosition pos = position();
-    data_ = reinterpret_cast<intptr_t>(positions);
-    set_position(pos);
-
-    DCHECK(has_operand_positions());
-  }
-
-  SourcePosition operand_position(int idx) const {
-    if (!has_operand_positions()) {
-      return position();
-    }
-    return *operand_position_slot(idx);
-  }
-
-  void set_operand_position(int idx, SourcePosition pos) {
-    *operand_position_slot(idx) = pos;
-  }
-
- private:
-  static const intptr_t kInstructionPosIndex = 0;
-  static const intptr_t kFirstOperandPosIndex = 1;
-
-  SourcePosition* operand_position_slot(int idx) const {
-    DCHECK(has_operand_positions());
-    return &(operand_positions()[kFirstOperandPosIndex + idx]);
-  }
-
-  bool has_operand_positions() const {
-    return !IsTaggedPosition(data_);
-  }
-
-  SourcePosition* operand_positions() const {
-    DCHECK(has_operand_positions());
-    return reinterpret_cast<SourcePosition*>(data_);
-  }
-
-  static const intptr_t kPositionTag = 1;
-  static const intptr_t kPositionShift = 1;
-  static bool IsTaggedPosition(intptr_t val) {
-    return (val & kPositionTag) != 0;
-  }
-  static intptr_t UntagPosition(intptr_t val) {
-    DCHECK(IsTaggedPosition(val));
-    return val >> kPositionShift;
-  }
-  static intptr_t TagPosition(intptr_t val) {
-    const intptr_t result = (val << kPositionShift) | kPositionTag;
-    DCHECK(UntagPosition(result) == val);
-    return result;
-  }
-
-  intptr_t data_;
-};
-
-
-class HInstruction : public HValue {
- public:
-  HInstruction* next() const { return next_; }
-  HInstruction* previous() const { return previous_; }
-
-  std::ostream& PrintTo(std::ostream& os) const override;          // NOLINT
-  virtual std::ostream& PrintDataTo(std::ostream& os) const;       // NOLINT
-
-  bool IsLinked() const { return block() != NULL; }
-  void Unlink();
-
-  void InsertBefore(HInstruction* next);
-
-  template<class T> T* Prepend(T* instr) {
-    instr->InsertBefore(this);
-    return instr;
-  }
-
-  void InsertAfter(HInstruction* previous);
-
-  template<class T> T* Append(T* instr) {
-    instr->InsertAfter(this);
-    return instr;
-  }
-
-  // The position is a write-once variable.
-  SourcePosition position() const override {
-    return SourcePosition(position_.position());
-  }
-  bool has_position() const {
-    return !position().IsUnknown();
-  }
-  void set_position(SourcePosition position) {
-    DCHECK(!has_position());
-    DCHECK(!position.IsUnknown());
-    position_.set_position(position);
-  }
-
-  SourcePosition operand_position(int index) const override {
-    const SourcePosition pos = position_.operand_position(index);
-    return pos.IsUnknown() ? position() : pos;
-  }
-  void set_operand_position(Zone* zone, int index, SourcePosition pos) {
-    DCHECK(0 <= index && index < OperandCount());
-    position_.ensure_storage_for_operand_positions(zone, OperandCount());
-    position_.set_operand_position(index, pos);
-  }
-
-  bool Dominates(HInstruction* other);
-  bool CanTruncateToSmi() const { return CheckFlag(kTruncatingToSmi); }
-  bool CanTruncateToInt32() const { return CheckFlag(kTruncatingToInt32); }
-
-  virtual LInstruction* CompileToLithium(LChunkBuilder* builder) = 0;
-
-#ifdef DEBUG
-  void Verify() override;
-#endif
-
-  bool CanDeoptimize();
-
-  virtual bool HasStackCheck() { return false; }
-
-  DECLARE_ABSTRACT_INSTRUCTION(Instruction)
-
- protected:
-  explicit HInstruction(HType type = HType::Tagged())
-      : HValue(type),
-        next_(NULL),
-        previous_(NULL),
-        position_(RelocInfo::kNoPosition) {
-    SetDependsOnFlag(kOsrEntries);
-  }
-
-  void DeleteFromGraph() override { Unlink(); }
-
- private:
-  void InitializeAsFirst(HBasicBlock* block) {
-    DCHECK(!IsLinked());
-    SetBlock(block);
-  }
-
-  HInstruction* next_;
-  HInstruction* previous_;
-  HPositionInfo position_;
-
-  friend class HBasicBlock;
-};
-
-
-template<int V>
-class HTemplateInstruction : public HInstruction {
- public:
-  int OperandCount() const final { return V; }
-  HValue* OperandAt(int i) const final { return inputs_[i]; }
-
- protected:
-  explicit HTemplateInstruction(HType type = HType::Tagged())
-      : HInstruction(type) {}
-
-  void InternalSetOperandAt(int i, HValue* value) final { inputs_[i] = value; }
-
- private:
-  EmbeddedContainer<HValue*, V> inputs_;
-};
-
-
-class HControlInstruction : public HInstruction {
- public:
-  virtual HBasicBlock* SuccessorAt(int i) const = 0;
-  virtual int SuccessorCount() const = 0;
-  virtual void SetSuccessorAt(int i, HBasicBlock* block) = 0;
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  virtual bool KnownSuccessorBlock(HBasicBlock** block) {
-    *block = NULL;
-    return false;
-  }
-
-  HBasicBlock* FirstSuccessor() {
-    return SuccessorCount() > 0 ? SuccessorAt(0) : NULL;
-  }
-  HBasicBlock* SecondSuccessor() {
-    return SuccessorCount() > 1 ? SuccessorAt(1) : NULL;
-  }
-
-  void Not() {
-    HBasicBlock* swap = SuccessorAt(0);
-    SetSuccessorAt(0, SuccessorAt(1));
-    SetSuccessorAt(1, swap);
-  }
-
-  DECLARE_ABSTRACT_INSTRUCTION(ControlInstruction)
-};
-
-
-class HSuccessorIterator final BASE_EMBEDDED {
- public:
-  explicit HSuccessorIterator(const HControlInstruction* instr)
-      : instr_(instr), current_(0) {}
-
-  bool Done() { return current_ >= instr_->SuccessorCount(); }
-  HBasicBlock* Current() { return instr_->SuccessorAt(current_); }
-  void Advance() { current_++; }
-
- private:
-  const HControlInstruction* instr_;
-  int current_;
-};
-
-
-template<int S, int V>
-class HTemplateControlInstruction : public HControlInstruction {
- public:
-  int SuccessorCount() const override { return S; }
-  HBasicBlock* SuccessorAt(int i) const override { return successors_[i]; }
-  void SetSuccessorAt(int i, HBasicBlock* block) override {
-    successors_[i] = block;
-  }
-
-  int OperandCount() const override { return V; }
-  HValue* OperandAt(int i) const override { return inputs_[i]; }
-
-
- protected:
-  void InternalSetOperandAt(int i, HValue* value) override {
-    inputs_[i] = value;
-  }
-
- private:
-  EmbeddedContainer<HBasicBlock*, S> successors_;
-  EmbeddedContainer<HValue*, V> inputs_;
-};
-
-
-class HBlockEntry final : public HTemplateInstruction<0> {
- public:
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(BlockEntry)
-};
-
-
-class HDummyUse final : public HTemplateInstruction<1> {
- public:
-  explicit HDummyUse(HValue* value)
-      : HTemplateInstruction<1>(HType::Smi()) {
-    SetOperandAt(0, value);
-    // Pretend to be a Smi so that the HChange instructions inserted
-    // before any use generate as little code as possible.
-    set_representation(Representation::Tagged());
-  }
-
-  HValue* value() const { return OperandAt(0); }
-
-  bool HasEscapingOperandAt(int index) override { return false; }
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(DummyUse);
-};
-
-
-// Inserts an int3/stop break instruction for debugging purposes.
-class HDebugBreak final : public HTemplateInstruction<0> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P0(HDebugBreak);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(DebugBreak)
-};
-
-
-class HPrologue final : public HTemplateInstruction<0> {
- public:
-  static HPrologue* New(Zone* zone) { return new (zone) HPrologue(); }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(Prologue)
-};
-
-
-class HGoto final : public HTemplateControlInstruction<1, 0> {
- public:
-  explicit HGoto(HBasicBlock* target) {
-    SetSuccessorAt(0, target);
-  }
-
-  bool KnownSuccessorBlock(HBasicBlock** block) override {
-    *block = FirstSuccessor();
-    return true;
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(Goto)
-};
-
-
-class HDeoptimize final : public HTemplateControlInstruction<1, 0> {
- public:
-  static HDeoptimize* New(Isolate* isolate, Zone* zone, HValue* context,
-                          Deoptimizer::DeoptReason reason,
-                          Deoptimizer::BailoutType type,
-                          HBasicBlock* unreachable_continuation) {
-    return new(zone) HDeoptimize(reason, type, unreachable_continuation);
-  }
-
-  bool KnownSuccessorBlock(HBasicBlock** block) override {
-    *block = NULL;
-    return true;
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  Deoptimizer::DeoptReason reason() const { return reason_; }
-  Deoptimizer::BailoutType type() { return type_; }
-
-  DECLARE_CONCRETE_INSTRUCTION(Deoptimize)
-
- private:
-  explicit HDeoptimize(Deoptimizer::DeoptReason reason,
-                       Deoptimizer::BailoutType type,
-                       HBasicBlock* unreachable_continuation)
-      : reason_(reason), type_(type) {
-    SetSuccessorAt(0, unreachable_continuation);
-  }
-
-  Deoptimizer::DeoptReason reason_;
-  Deoptimizer::BailoutType type_;
-};
-
-
-class HUnaryControlInstruction : public HTemplateControlInstruction<2, 1> {
- public:
-  HUnaryControlInstruction(HValue* value,
-                           HBasicBlock* true_target,
-                           HBasicBlock* false_target) {
-    SetOperandAt(0, value);
-    SetSuccessorAt(0, true_target);
-    SetSuccessorAt(1, false_target);
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  HValue* value() const { return OperandAt(0); }
-};
-
-
-class HBranch final : public HUnaryControlInstruction {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HBranch, HValue*);
-  DECLARE_INSTRUCTION_FACTORY_P2(HBranch, HValue*,
-                                 ToBooleanStub::Types);
-  DECLARE_INSTRUCTION_FACTORY_P4(HBranch, HValue*,
-                                 ToBooleanStub::Types,
-                                 HBasicBlock*, HBasicBlock*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-  Representation observed_input_representation(int index) override;
-
-  bool KnownSuccessorBlock(HBasicBlock** block) override;
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  ToBooleanStub::Types expected_input_types() const {
-    return expected_input_types_;
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(Branch)
-
- private:
-  HBranch(HValue* value,
-          ToBooleanStub::Types expected_input_types = ToBooleanStub::Types(),
-          HBasicBlock* true_target = NULL,
-          HBasicBlock* false_target = NULL)
-      : HUnaryControlInstruction(value, true_target, false_target),
-        expected_input_types_(expected_input_types) {
-    SetFlag(kAllowUndefinedAsNaN);
-  }
-
-  ToBooleanStub::Types expected_input_types_;
-};
-
-
-class HCompareMap final : public HUnaryControlInstruction {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P2(HCompareMap, HValue*, Handle<Map>);
-  DECLARE_INSTRUCTION_FACTORY_P4(HCompareMap, HValue*, Handle<Map>,
-                                 HBasicBlock*, HBasicBlock*);
-
-  bool KnownSuccessorBlock(HBasicBlock** block) override {
-    if (known_successor_index() != kNoKnownSuccessorIndex) {
-      *block = SuccessorAt(known_successor_index());
-      return true;
-    }
-    *block = NULL;
-    return false;
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  static const int kNoKnownSuccessorIndex = -1;
-  int known_successor_index() const {
-    return KnownSuccessorIndexField::decode(bit_field_) -
-           kInternalKnownSuccessorOffset;
-  }
-  void set_known_successor_index(int index) {
-    DCHECK(index >= 0 - kInternalKnownSuccessorOffset);
-    bit_field_ = KnownSuccessorIndexField::update(
-        bit_field_, index + kInternalKnownSuccessorOffset);
-  }
-
-  Unique<Map> map() const { return map_; }
-  bool map_is_stable() const { return MapIsStableField::decode(bit_field_); }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(CompareMap)
-
- protected:
-  int RedefinedOperandIndex() override { return 0; }
-
- private:
-  HCompareMap(HValue* value, Handle<Map> map, HBasicBlock* true_target = NULL,
-              HBasicBlock* false_target = NULL)
-      : HUnaryControlInstruction(value, true_target, false_target),
-        bit_field_(KnownSuccessorIndexField::encode(
-                       kNoKnownSuccessorIndex + kInternalKnownSuccessorOffset) |
-                   MapIsStableField::encode(map->is_stable())),
-        map_(Unique<Map>::CreateImmovable(map)) {
-    set_representation(Representation::Tagged());
-  }
-
-  // BitFields can only store unsigned values, so use an offset.
-  // Adding kInternalKnownSuccessorOffset must yield an unsigned value.
-  static const int kInternalKnownSuccessorOffset = 1;
-  STATIC_ASSERT(kNoKnownSuccessorIndex + kInternalKnownSuccessorOffset >= 0);
-
-  class KnownSuccessorIndexField : public BitField<int, 0, 31> {};
-  class MapIsStableField : public BitField<bool, 31, 1> {};
-
-  uint32_t bit_field_;
-  Unique<Map> map_;
-};
-
-
-class HContext final : public HTemplateInstruction<0> {
- public:
-  static HContext* New(Zone* zone) {
-    return new(zone) HContext();
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(Context)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  HContext() {
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-  }
-
-  bool IsDeletable() const override { return true; }
-};
-
-
-class HReturn final : public HTemplateControlInstruction<0, 3> {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HReturn, HValue*, HValue*);
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P1(HReturn, HValue*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    // TODO(titzer): require an Int32 input for faster returns.
-    if (index == 2) return Representation::Smi();
-    return Representation::Tagged();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  HValue* value() const { return OperandAt(0); }
-  HValue* context() const { return OperandAt(1); }
-  HValue* parameter_count() const { return OperandAt(2); }
-
-  DECLARE_CONCRETE_INSTRUCTION(Return)
-
- private:
-  HReturn(HValue* context, HValue* value, HValue* parameter_count = 0) {
-    SetOperandAt(0, value);
-    SetOperandAt(1, context);
-    SetOperandAt(2, parameter_count);
-  }
-};
-
-
-class HAbnormalExit final : public HTemplateControlInstruction<0, 0> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P0(HAbnormalExit);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(AbnormalExit)
- private:
-  HAbnormalExit() {}
-};
-
-
-class HUnaryOperation : public HTemplateInstruction<1> {
- public:
-  explicit HUnaryOperation(HValue* value, HType type = HType::Tagged())
-      : HTemplateInstruction<1>(type) {
-    SetOperandAt(0, value);
-  }
-
-  static HUnaryOperation* cast(HValue* value) {
-    return reinterpret_cast<HUnaryOperation*>(value);
-  }
-
-  HValue* value() const { return OperandAt(0); }
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-};
-
-
-class HUseConst final : public HUnaryOperation {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HUseConst, HValue*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(UseConst)
-
- private:
-    explicit HUseConst(HValue* old_value) : HUnaryOperation(old_value) { }
-};
-
-
-class HForceRepresentation final : public HTemplateInstruction<1> {
- public:
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           HValue* value,
-                           Representation required_representation);
-
-  HValue* value() const { return OperandAt(0); }
-
-  Representation observed_input_representation(int index) override {
-    // We haven't actually *observed* this, but it's closer to the truth
-    // than 'None'.
-    return representation();  // Same as the output representation.
-  }
-  Representation RequiredInputRepresentation(int index) override {
-    return representation();  // Same as the output representation.
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(ForceRepresentation)
-
- private:
-  HForceRepresentation(HValue* value, Representation required_representation) {
-    SetOperandAt(0, value);
-    set_representation(required_representation);
-  }
-};
-
-
-class HChange final : public HUnaryOperation {
- public:
-  HChange(HValue* value,
-          Representation to,
-          bool is_truncating_to_smi,
-          bool is_truncating_to_int32)
-      : HUnaryOperation(value) {
-    DCHECK(!value->representation().IsNone());
-    DCHECK(!to.IsNone());
-    DCHECK(!value->representation().Equals(to));
-    set_representation(to);
-    SetFlag(kUseGVN);
-    SetFlag(kCanOverflow);
-    if (is_truncating_to_smi && to.IsSmi()) {
-      SetFlag(kTruncatingToSmi);
-      SetFlag(kTruncatingToInt32);
-    }
-    if (is_truncating_to_int32) SetFlag(kTruncatingToInt32);
-    if (value->representation().IsSmi() || value->type().IsSmi()) {
-      set_type(HType::Smi());
-    } else {
-      set_type(HType::TaggedNumber());
-      if (to.IsTagged()) SetChangesFlag(kNewSpacePromotion);
-    }
-  }
-
-  bool can_convert_undefined_to_nan() {
-    return CheckUsesForFlag(kAllowUndefinedAsNaN);
-  }
-
-  HType CalculateInferredType() override;
-  HValue* Canonicalize() override;
-
-  Representation from() const { return value()->representation(); }
-  Representation to() const { return representation(); }
-  bool deoptimize_on_minus_zero() const {
-    return CheckFlag(kBailoutOnMinusZero);
-  }
-  Representation RequiredInputRepresentation(int index) override {
-    return from();
-  }
-
-  Range* InferRange(Zone* zone) override;
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(Change)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  bool IsDeletable() const override {
-    return !from().IsTagged() || value()->type().IsSmi();
-  }
-};
-
-
-class HClampToUint8 final : public HUnaryOperation {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HClampToUint8, HValue*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(ClampToUint8)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  explicit HClampToUint8(HValue* value)
-      : HUnaryOperation(value) {
-    set_representation(Representation::Integer32());
-    SetFlag(kAllowUndefinedAsNaN);
-    SetFlag(kUseGVN);
-  }
-
-  bool IsDeletable() const override { return true; }
-};
-
-
-class HDoubleBits final : public HUnaryOperation {
- public:
-  enum Bits { HIGH, LOW };
-  DECLARE_INSTRUCTION_FACTORY_P2(HDoubleBits, HValue*, Bits);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Double();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(DoubleBits)
-
-  Bits bits() { return bits_; }
-
- protected:
-  bool DataEquals(HValue* other) override {
-    return other->IsDoubleBits() && HDoubleBits::cast(other)->bits() == bits();
-  }
-
- private:
-  HDoubleBits(HValue* value, Bits bits)
-      : HUnaryOperation(value), bits_(bits) {
-    set_representation(Representation::Integer32());
-    SetFlag(kUseGVN);
-  }
-
-  bool IsDeletable() const override { return true; }
-
-  Bits bits_;
-};
-
-
-class HConstructDouble final : public HTemplateInstruction<2> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P2(HConstructDouble, HValue*, HValue*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Integer32();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(ConstructDouble)
-
-  HValue* hi() { return OperandAt(0); }
-  HValue* lo() { return OperandAt(1); }
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  explicit HConstructDouble(HValue* hi, HValue* lo) {
-    set_representation(Representation::Double());
-    SetFlag(kUseGVN);
-    SetOperandAt(0, hi);
-    SetOperandAt(1, lo);
-  }
-
-  bool IsDeletable() const override { return true; }
-};
-
-
-enum RemovableSimulate {
-  REMOVABLE_SIMULATE,
-  FIXED_SIMULATE
-};
-
-
-class HSimulate final : public HInstruction {
- public:
-  HSimulate(BailoutId ast_id, int pop_count, Zone* zone,
-            RemovableSimulate removable)
-      : ast_id_(ast_id),
-        pop_count_(pop_count),
-        values_(2, zone),
-        assigned_indexes_(2, zone),
-        zone_(zone),
-        bit_field_(RemovableField::encode(removable) |
-                   DoneWithReplayField::encode(false)) {}
-  ~HSimulate() {}
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  bool HasAstId() const { return !ast_id_.IsNone(); }
-  BailoutId ast_id() const { return ast_id_; }
-  void set_ast_id(BailoutId id) {
-    DCHECK(!HasAstId());
-    ast_id_ = id;
-  }
-
-  int pop_count() const { return pop_count_; }
-  const ZoneList<HValue*>* values() const { return &values_; }
-  int GetAssignedIndexAt(int index) const {
-    DCHECK(HasAssignedIndexAt(index));
-    return assigned_indexes_[index];
-  }
-  bool HasAssignedIndexAt(int index) const {
-    return assigned_indexes_[index] != kNoIndex;
-  }
-  void AddAssignedValue(int index, HValue* value) {
-    AddValue(index, value);
-  }
-  void AddPushedValue(HValue* value) {
-    AddValue(kNoIndex, value);
-  }
-  int ToOperandIndex(int environment_index) {
-    for (int i = 0; i < assigned_indexes_.length(); ++i) {
-      if (assigned_indexes_[i] == environment_index) return i;
-    }
-    return -1;
-  }
-  int OperandCount() const override { return values_.length(); }
-  HValue* OperandAt(int index) const override { return values_[index]; }
-
-  bool HasEscapingOperandAt(int index) override { return false; }
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  void MergeWith(ZoneList<HSimulate*>* list);
-  bool is_candidate_for_removal() {
-    return RemovableField::decode(bit_field_) == REMOVABLE_SIMULATE;
-  }
-
-  // Replay effects of this instruction on the given environment.
-  void ReplayEnvironment(HEnvironment* env);
-
-  DECLARE_CONCRETE_INSTRUCTION(Simulate)
-
-#ifdef DEBUG
-  void Verify() override;
-  void set_closure(Handle<JSFunction> closure) { closure_ = closure; }
-  Handle<JSFunction> closure() const { return closure_; }
-#endif
-
- protected:
-  void InternalSetOperandAt(int index, HValue* value) override {
-    values_[index] = value;
-  }
-
- private:
-  static const int kNoIndex = -1;
-  void AddValue(int index, HValue* value) {
-    assigned_indexes_.Add(index, zone_);
-    // Resize the list of pushed values.
-    values_.Add(NULL, zone_);
-    // Set the operand through the base method in HValue to make sure that the
-    // use lists are correctly updated.
-    SetOperandAt(values_.length() - 1, value);
-  }
-  bool HasValueForIndex(int index) {
-    for (int i = 0; i < assigned_indexes_.length(); ++i) {
-      if (assigned_indexes_[i] == index) return true;
-    }
-    return false;
-  }
-  bool is_done_with_replay() const {
-    return DoneWithReplayField::decode(bit_field_);
-  }
-  void set_done_with_replay() {
-    bit_field_ = DoneWithReplayField::update(bit_field_, true);
-  }
-
-  class RemovableField : public BitField<RemovableSimulate, 0, 1> {};
-  class DoneWithReplayField : public BitField<bool, 1, 1> {};
-
-  BailoutId ast_id_;
-  int pop_count_;
-  ZoneList<HValue*> values_;
-  ZoneList<int> assigned_indexes_;
-  Zone* zone_;
-  uint32_t bit_field_;
-
-#ifdef DEBUG
-  Handle<JSFunction> closure_;
-#endif
-};
-
-
-class HEnvironmentMarker final : public HTemplateInstruction<1> {
- public:
-  enum Kind { BIND, LOOKUP };
-
-  DECLARE_INSTRUCTION_FACTORY_P2(HEnvironmentMarker, Kind, int);
-
-  Kind kind() const { return kind_; }
-  int index() const { return index_; }
-  HSimulate* next_simulate() { return next_simulate_; }
-  void set_next_simulate(HSimulate* simulate) {
-    next_simulate_ = simulate;
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-#ifdef DEBUG
-  void set_closure(Handle<JSFunction> closure) {
-    DCHECK(closure_.is_null());
-    DCHECK(!closure.is_null());
-    closure_ = closure;
-  }
-  Handle<JSFunction> closure() const { return closure_; }
-#endif
-
-  DECLARE_CONCRETE_INSTRUCTION(EnvironmentMarker);
-
- private:
-  HEnvironmentMarker(Kind kind, int index)
-      : kind_(kind), index_(index), next_simulate_(NULL) { }
-
-  Kind kind_;
-  int index_;
-  HSimulate* next_simulate_;
-
-#ifdef DEBUG
-  Handle<JSFunction> closure_;
-#endif
-};
-
-
-class HStackCheck final : public HTemplateInstruction<1> {
- public:
-  enum Type {
-    kFunctionEntry,
-    kBackwardsBranch
-  };
-
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P1(HStackCheck, Type);
-
-  HValue* context() { return OperandAt(0); }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  void Eliminate() {
-    // The stack check eliminator might try to eliminate the same stack
-    // check instruction multiple times.
-    if (IsLinked()) {
-      DeleteAndReplaceWith(NULL);
-    }
-  }
-
-  bool is_function_entry() { return type_ == kFunctionEntry; }
-  bool is_backwards_branch() { return type_ == kBackwardsBranch; }
-
-  DECLARE_CONCRETE_INSTRUCTION(StackCheck)
-
- private:
-  HStackCheck(HValue* context, Type type) : type_(type) {
-    SetOperandAt(0, context);
-    SetChangesFlag(kNewSpacePromotion);
-  }
-
-  Type type_;
-};
-
-
-enum InliningKind {
-  NORMAL_RETURN,          // Drop the function from the environment on return.
-  CONSTRUCT_CALL_RETURN,  // Either use allocated receiver or return value.
-  GETTER_CALL_RETURN,     // Returning from a getter, need to restore context.
-  SETTER_CALL_RETURN      // Use the RHS of the assignment as the return value.
-};
-
-
-class HArgumentsObject;
-class HConstant;
-
-
-class HEnterInlined final : public HTemplateInstruction<0> {
- public:
-  static HEnterInlined* New(Isolate* isolate, Zone* zone, HValue* context,
-                            BailoutId return_id, Handle<JSFunction> closure,
-                            HConstant* closure_context, int arguments_count,
-                            FunctionLiteral* function,
-                            InliningKind inlining_kind, Variable* arguments_var,
-                            HArgumentsObject* arguments_object) {
-    return new (zone) HEnterInlined(return_id, closure, closure_context,
-                                    arguments_count, function, inlining_kind,
-                                    arguments_var, arguments_object, zone);
-  }
-
-  void RegisterReturnTarget(HBasicBlock* return_target, Zone* zone);
-  ZoneList<HBasicBlock*>* return_targets() { return &return_targets_; }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Handle<SharedFunctionInfo> shared() const { return shared_; }
-  Handle<JSFunction> closure() const { return closure_; }
-  HConstant* closure_context() const { return closure_context_; }
-  int arguments_count() const { return arguments_count_; }
-  bool arguments_pushed() const { return arguments_pushed_; }
-  void set_arguments_pushed() { arguments_pushed_ = true; }
-  FunctionLiteral* function() const { return function_; }
-  InliningKind inlining_kind() const { return inlining_kind_; }
-  BailoutId ReturnId() const { return return_id_; }
-  int inlining_id() const { return inlining_id_; }
-  void set_inlining_id(int inlining_id) { inlining_id_ = inlining_id; }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  Variable* arguments_var() { return arguments_var_; }
-  HArgumentsObject* arguments_object() { return arguments_object_; }
-
-  DECLARE_CONCRETE_INSTRUCTION(EnterInlined)
-
- private:
-  HEnterInlined(BailoutId return_id, Handle<JSFunction> closure,
-                HConstant* closure_context, int arguments_count,
-                FunctionLiteral* function, InliningKind inlining_kind,
-                Variable* arguments_var, HArgumentsObject* arguments_object,
-                Zone* zone)
-      : return_id_(return_id),
-        shared_(handle(closure->shared())),
-        closure_(closure),
-        closure_context_(closure_context),
-        arguments_count_(arguments_count),
-        arguments_pushed_(false),
-        function_(function),
-        inlining_kind_(inlining_kind),
-        inlining_id_(0),
-        arguments_var_(arguments_var),
-        arguments_object_(arguments_object),
-        return_targets_(2, zone) {}
-
-  BailoutId return_id_;
-  Handle<SharedFunctionInfo> shared_;
-  Handle<JSFunction> closure_;
-  HConstant* closure_context_;
-  int arguments_count_;
-  bool arguments_pushed_;
-  FunctionLiteral* function_;
-  InliningKind inlining_kind_;
-  int inlining_id_;
-  Variable* arguments_var_;
-  HArgumentsObject* arguments_object_;
-  ZoneList<HBasicBlock*> return_targets_;
-};
-
-
-class HLeaveInlined final : public HTemplateInstruction<0> {
- public:
-  HLeaveInlined(HEnterInlined* entry,
-                int drop_count)
-      : entry_(entry),
-        drop_count_(drop_count) { }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  int argument_delta() const override {
-    return entry_->arguments_pushed() ? -drop_count_ : 0;
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(LeaveInlined)
-
- private:
-  HEnterInlined* entry_;
-  int drop_count_;
-};
-
-
-class HPushArguments final : public HInstruction {
- public:
-  static HPushArguments* New(Isolate* isolate, Zone* zone, HValue* context) {
-    return new(zone) HPushArguments(zone);
-  }
-  static HPushArguments* New(Isolate* isolate, Zone* zone, HValue* context,
-                             HValue* arg1) {
-    HPushArguments* instr = new(zone) HPushArguments(zone);
-    instr->AddInput(arg1);
-    return instr;
-  }
-  static HPushArguments* New(Isolate* isolate, Zone* zone, HValue* context,
-                             HValue* arg1, HValue* arg2) {
-    HPushArguments* instr = new(zone) HPushArguments(zone);
-    instr->AddInput(arg1);
-    instr->AddInput(arg2);
-    return instr;
-  }
-  static HPushArguments* New(Isolate* isolate, Zone* zone, HValue* context,
-                             HValue* arg1, HValue* arg2, HValue* arg3) {
-    HPushArguments* instr = new(zone) HPushArguments(zone);
-    instr->AddInput(arg1);
-    instr->AddInput(arg2);
-    instr->AddInput(arg3);
-    return instr;
-  }
-  static HPushArguments* New(Isolate* isolate, Zone* zone, HValue* context,
-                             HValue* arg1, HValue* arg2, HValue* arg3,
-                             HValue* arg4) {
-    HPushArguments* instr = new(zone) HPushArguments(zone);
-    instr->AddInput(arg1);
-    instr->AddInput(arg2);
-    instr->AddInput(arg3);
-    instr->AddInput(arg4);
-    return instr;
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  int argument_delta() const override { return inputs_.length(); }
-  HValue* argument(int i) { return OperandAt(i); }
-
-  int OperandCount() const final { return inputs_.length(); }
-  HValue* OperandAt(int i) const final { return inputs_[i]; }
-
-  void AddInput(HValue* value);
-
-  DECLARE_CONCRETE_INSTRUCTION(PushArguments)
-
- protected:
-  void InternalSetOperandAt(int i, HValue* value) final { inputs_[i] = value; }
-
- private:
-  explicit HPushArguments(Zone* zone)
-      : HInstruction(HType::Tagged()), inputs_(4, zone) {
-    set_representation(Representation::Tagged());
-  }
-
-  ZoneList<HValue*> inputs_;
-};
-
-
-class HThisFunction final : public HTemplateInstruction<0> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P0(HThisFunction);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(ThisFunction)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  HThisFunction() {
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-  }
-
-  bool IsDeletable() const override { return true; }
-};
-
-
-class HDeclareGlobals final : public HUnaryOperation {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HDeclareGlobals,
-                                              Handle<FixedArray>,
-                                              int);
-
-  HValue* context() { return OperandAt(0); }
-  Handle<FixedArray> pairs() const { return pairs_; }
-  int flags() const { return flags_; }
-
-  DECLARE_CONCRETE_INSTRUCTION(DeclareGlobals)
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
- private:
-  HDeclareGlobals(HValue* context,
-                  Handle<FixedArray> pairs,
-                  int flags)
-      : HUnaryOperation(context),
-        pairs_(pairs),
-        flags_(flags) {
-    set_representation(Representation::Tagged());
-    SetAllSideEffects();
-  }
-
-  Handle<FixedArray> pairs_;
-  int flags_;
-};
-
-
-template <int V>
-class HCall : public HTemplateInstruction<V> {
- public:
-  // The argument count includes the receiver.
-  explicit HCall<V>(int argument_count) : argument_count_(argument_count) {
-    this->set_representation(Representation::Tagged());
-    this->SetAllSideEffects();
-  }
-
-  HType CalculateInferredType() final { return HType::Tagged(); }
-
-  virtual int argument_count() const {
-    return argument_count_;
-  }
-
-  int argument_delta() const override { return -argument_count(); }
-
- private:
-  int argument_count_;
-};
-
-
-class HUnaryCall : public HCall<1> {
- public:
-  HUnaryCall(HValue* value, int argument_count)
-      : HCall<1>(argument_count) {
-    SetOperandAt(0, value);
-  }
-
-  Representation RequiredInputRepresentation(int index) final {
-    return Representation::Tagged();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  HValue* value() const { return OperandAt(0); }
-};
-
-
-class HBinaryCall : public HCall<2> {
- public:
-  HBinaryCall(HValue* first, HValue* second, int argument_count)
-      : HCall<2>(argument_count) {
-    SetOperandAt(0, first);
-    SetOperandAt(1, second);
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) final {
-    return Representation::Tagged();
-  }
-
-  HValue* first() const { return OperandAt(0); }
-  HValue* second() const { return OperandAt(1); }
-};
-
-
-class HCallJSFunction final : public HCall<1> {
- public:
-  static HCallJSFunction* New(Isolate* isolate, Zone* zone, HValue* context,
-                              HValue* function, int argument_count);
-
-  HValue* function() const { return OperandAt(0); }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) final {
-    DCHECK(index == 0);
-    return Representation::Tagged();
-  }
-
-  bool HasStackCheck() final { return has_stack_check_; }
-
-  DECLARE_CONCRETE_INSTRUCTION(CallJSFunction)
-
- private:
-  // The argument count includes the receiver.
-  HCallJSFunction(HValue* function,
-                  int argument_count,
-                  bool has_stack_check)
-      : HCall<1>(argument_count),
-        has_stack_check_(has_stack_check) {
-      SetOperandAt(0, function);
-  }
-
-  bool has_stack_check_;
-};
-
-
-enum CallMode { NORMAL_CALL, TAIL_CALL };
-
-
-class HCallWithDescriptor final : public HInstruction {
- public:
-  static HCallWithDescriptor* New(Isolate* isolate, Zone* zone, HValue* context,
-                                  HValue* target, int argument_count,
-                                  CallInterfaceDescriptor descriptor,
-                                  const Vector<HValue*>& operands,
-                                  CallMode call_mode = NORMAL_CALL) {
-    HCallWithDescriptor* res = new (zone) HCallWithDescriptor(
-        target, argument_count, descriptor, operands, call_mode, zone);
-    DCHECK(operands.length() == res->GetParameterCount());
-    return res;
-  }
-
-  int OperandCount() const final { return values_.length(); }
-  HValue* OperandAt(int index) const final { return values_[index]; }
-
-  Representation RequiredInputRepresentation(int index) final {
-    if (index == 0 || index == 1) {
-      // Target + context
-      return Representation::Tagged();
-    } else {
-      int par_index = index - 2;
-      DCHECK(par_index < GetParameterCount());
-      return RepresentationFromType(descriptor_.GetParameterType(par_index));
-    }
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor)
-
-  HType CalculateInferredType() final { return HType::Tagged(); }
-
-  bool IsTailCall() const { return call_mode_ == TAIL_CALL; }
-
-  virtual int argument_count() const {
-    return argument_count_;
-  }
-
-  int argument_delta() const override { return -argument_count_; }
-
-  CallInterfaceDescriptor descriptor() const { return descriptor_; }
-
-  HValue* target() {
-    return OperandAt(0);
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
- private:
-  // The argument count includes the receiver.
-  HCallWithDescriptor(HValue* target, int argument_count,
-                      CallInterfaceDescriptor descriptor,
-                      const Vector<HValue*>& operands, CallMode call_mode,
-                      Zone* zone)
-      : descriptor_(descriptor),
-        values_(GetParameterCount() + 1, zone),
-        argument_count_(argument_count),
-        call_mode_(call_mode) {
-    // We can only tail call without any stack arguments.
-    DCHECK(call_mode != TAIL_CALL || argument_count == 0);
-    AddOperand(target, zone);
-    for (int i = 0; i < operands.length(); i++) {
-      AddOperand(operands[i], zone);
-    }
-    this->set_representation(Representation::Tagged());
-    this->SetAllSideEffects();
-  }
-
-  void AddOperand(HValue* v, Zone* zone) {
-    values_.Add(NULL, zone);
-    SetOperandAt(values_.length() - 1, v);
-  }
-
-  int GetParameterCount() const {
-    return descriptor_.GetRegisterParameterCount() + 1;
-  }
-
-  void InternalSetOperandAt(int index, HValue* value) final {
-    values_[index] = value;
-  }
-
-  CallInterfaceDescriptor descriptor_;
-  ZoneList<HValue*> values_;
-  int argument_count_;
-  CallMode call_mode_;
-};
-
-
-class HInvokeFunction final : public HBinaryCall {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HInvokeFunction, HValue*, int);
-
-  HInvokeFunction(HValue* context,
-                  HValue* function,
-                  Handle<JSFunction> known_function,
-                  int argument_count)
-      : HBinaryCall(context, function, argument_count),
-        known_function_(known_function) {
-    formal_parameter_count_ =
-        known_function.is_null()
-            ? 0
-            : known_function->shared()->internal_formal_parameter_count();
-    has_stack_check_ = !known_function.is_null() &&
-        (known_function->code()->kind() == Code::FUNCTION ||
-         known_function->code()->kind() == Code::OPTIMIZED_FUNCTION);
-  }
-
-  static HInvokeFunction* New(Isolate* isolate, Zone* zone, HValue* context,
-                              HValue* function,
-                              Handle<JSFunction> known_function,
-                              int argument_count) {
-    return new(zone) HInvokeFunction(context, function,
-                                     known_function, argument_count);
-  }
-
-  HValue* context() { return first(); }
-  HValue* function() { return second(); }
-  Handle<JSFunction> known_function() { return known_function_; }
-  int formal_parameter_count() const { return formal_parameter_count_; }
-
-  bool HasStackCheck() final { return has_stack_check_; }
-
-  DECLARE_CONCRETE_INSTRUCTION(InvokeFunction)
-
- private:
-  HInvokeFunction(HValue* context, HValue* function, int argument_count)
-      : HBinaryCall(context, function, argument_count),
-        has_stack_check_(false) {
-  }
-
-  Handle<JSFunction> known_function_;
-  int formal_parameter_count_;
-  bool has_stack_check_;
-};
-
-
-class HCallFunction final : public HBinaryCall {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HCallFunction, HValue*, int);
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(
-      HCallFunction, HValue*, int, CallFunctionFlags);
-
-  HValue* context() const { return first(); }
-  HValue* function() const { return second(); }
-  CallFunctionFlags function_flags() const { return function_flags_; }
-
-  FeedbackVectorSlot slot() const { return slot_; }
-  Handle<TypeFeedbackVector> feedback_vector() const {
-    return feedback_vector_;
-  }
-  bool HasVectorAndSlot() const { return !feedback_vector_.is_null(); }
-  void SetVectorAndSlot(Handle<TypeFeedbackVector> vector,
-                        FeedbackVectorSlot slot) {
-    feedback_vector_ = vector;
-    slot_ = slot;
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(CallFunction)
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  int argument_delta() const override { return -argument_count(); }
-
- private:
-  HCallFunction(HValue* context, HValue* function, int argument_count,
-                CallFunctionFlags flags = NO_CALL_FUNCTION_FLAGS)
-      : HBinaryCall(context, function, argument_count),
-        function_flags_(flags) {}
-  CallFunctionFlags function_flags_;
-  Handle<TypeFeedbackVector> feedback_vector_;
-  FeedbackVectorSlot slot_;
-};
-
-
-class HCallNew final : public HBinaryCall {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HCallNew, HValue*, int);
-
-  HValue* context() { return first(); }
-  HValue* constructor() { return second(); }
-
-  DECLARE_CONCRETE_INSTRUCTION(CallNew)
-
- private:
-  HCallNew(HValue* context, HValue* constructor, int argument_count)
-      : HBinaryCall(context, constructor, argument_count) {}
-};
-
-
-class HCallNewArray final : public HBinaryCall {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P4(HCallNewArray, HValue*, int,
-                                              ElementsKind,
-                                              Handle<AllocationSite>);
-
-  HValue* context() { return first(); }
-  HValue* constructor() { return second(); }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  ElementsKind elements_kind() const { return elements_kind_; }
-  Handle<AllocationSite> site() const { return site_; }
-
-  DECLARE_CONCRETE_INSTRUCTION(CallNewArray)
-
- private:
-  HCallNewArray(HValue* context, HValue* constructor, int argument_count,
-                ElementsKind elements_kind, Handle<AllocationSite> site)
-      : HBinaryCall(context, constructor, argument_count),
-        elements_kind_(elements_kind),
-        site_(site) {}
-
-  ElementsKind elements_kind_;
-  Handle<AllocationSite> site_;
-};
-
-
-class HCallRuntime final : public HCall<1> {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HCallRuntime,
-                                              const Runtime::Function*, int);
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  HValue* context() { return OperandAt(0); }
-  const Runtime::Function* function() const { return c_function_; }
-  SaveFPRegsMode save_doubles() const { return save_doubles_; }
-  void set_save_doubles(SaveFPRegsMode save_doubles) {
-    save_doubles_ = save_doubles;
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(CallRuntime)
-
- private:
-  HCallRuntime(HValue* context, const Runtime::Function* c_function,
-               int argument_count)
-      : HCall<1>(argument_count),
-        c_function_(c_function),
-        save_doubles_(kDontSaveFPRegs) {
-    SetOperandAt(0, context);
-  }
-
-  const Runtime::Function* c_function_;
-  SaveFPRegsMode save_doubles_;
-};
-
-
-class HMapEnumLength final : public HUnaryOperation {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HMapEnumLength, HValue*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(MapEnumLength)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  explicit HMapEnumLength(HValue* value)
-      : HUnaryOperation(value, HType::Smi()) {
-    set_representation(Representation::Smi());
-    SetFlag(kUseGVN);
-    SetDependsOnFlag(kMaps);
-  }
-
-  bool IsDeletable() const override { return true; }
-};
-
-
-class HUnaryMathOperation final : public HTemplateInstruction<2> {
- public:
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           HValue* value, BuiltinFunctionId op);
-
-  HValue* context() const { return OperandAt(0); }
-  HValue* value() const { return OperandAt(1); }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) override {
-    if (index == 0) {
-      return Representation::Tagged();
-    } else {
-      switch (op_) {
-        case kMathFloor:
-        case kMathRound:
-        case kMathFround:
-        case kMathSqrt:
-        case kMathPowHalf:
-        case kMathLog:
-        case kMathExp:
-          return Representation::Double();
-        case kMathAbs:
-          return representation();
-        case kMathClz32:
-          return Representation::Integer32();
-        default:
-          UNREACHABLE();
-          return Representation::None();
-      }
-    }
-  }
-
-  Range* InferRange(Zone* zone) override;
-
-  HValue* Canonicalize() override;
-  Representation RepresentationFromUses() override;
-  Representation RepresentationFromInputs() override;
-
-  BuiltinFunctionId op() const { return op_; }
-  const char* OpName() const;
-
-  DECLARE_CONCRETE_INSTRUCTION(UnaryMathOperation)
-
- protected:
-  bool DataEquals(HValue* other) override {
-    HUnaryMathOperation* b = HUnaryMathOperation::cast(other);
-    return op_ == b->op();
-  }
-
- private:
-  // Indicates if we support a double (and int32) output for Math.floor and
-  // Math.round.
-  bool SupportsFlexibleFloorAndRound() const {
-#ifdef V8_TARGET_ARCH_ARM64
-    // TODO(rmcilroy): Re-enable this for Arm64 once http://crbug.com/476477 is
-    // fixed.
-    return false;
-#else
-    return false;
-#endif
-  }
-  HUnaryMathOperation(HValue* context, HValue* value, BuiltinFunctionId op)
-      : HTemplateInstruction<2>(HType::TaggedNumber()), op_(op) {
-    SetOperandAt(0, context);
-    SetOperandAt(1, value);
-    switch (op) {
-      case kMathFloor:
-      case kMathRound:
-        if (SupportsFlexibleFloorAndRound()) {
-          SetFlag(kFlexibleRepresentation);
-        } else {
-          set_representation(Representation::Integer32());
-        }
-        break;
-      case kMathClz32:
-        set_representation(Representation::Integer32());
-        break;
-      case kMathAbs:
-        // Not setting representation here: it is None intentionally.
-        SetFlag(kFlexibleRepresentation);
-        // TODO(svenpanne) This flag is actually only needed if representation()
-        // is tagged, and not when it is an unboxed double or unboxed integer.
-        SetChangesFlag(kNewSpacePromotion);
-        break;
-      case kMathFround:
-      case kMathLog:
-      case kMathExp:
-      case kMathSqrt:
-      case kMathPowHalf:
-        set_representation(Representation::Double());
-        break;
-      default:
-        UNREACHABLE();
-    }
-    SetFlag(kUseGVN);
-    SetFlag(kAllowUndefinedAsNaN);
-  }
-
-  bool IsDeletable() const override {
-    // TODO(crankshaft): This should be true, however the semantics of this
-    // instruction also include the ToNumber conversion that is mentioned in the
-    // spec, which is of course observable.
-    return false;
-  }
-
-  HValue* SimplifiedDividendForMathFloorOfDiv(HDiv* hdiv);
-  HValue* SimplifiedDivisorForMathFloorOfDiv(HDiv* hdiv);
-
-  BuiltinFunctionId op_;
-};
-
-
-class HLoadRoot final : public HTemplateInstruction<0> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HLoadRoot, Heap::RootListIndex);
-  DECLARE_INSTRUCTION_FACTORY_P2(HLoadRoot, Heap::RootListIndex, HType);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  Heap::RootListIndex index() const { return index_; }
-
-  DECLARE_CONCRETE_INSTRUCTION(LoadRoot)
-
- protected:
-  bool DataEquals(HValue* other) override {
-    HLoadRoot* b = HLoadRoot::cast(other);
-    return index_ == b->index_;
-  }
-
- private:
-  explicit HLoadRoot(Heap::RootListIndex index, HType type = HType::Tagged())
-      : HTemplateInstruction<0>(type), index_(index) {
-    SetFlag(kUseGVN);
-    // TODO(bmeurer): We'll need kDependsOnRoots once we add the
-    // corresponding HStoreRoot instruction.
-    SetDependsOnFlag(kCalls);
-    set_representation(Representation::Tagged());
-  }
-
-  bool IsDeletable() const override { return true; }
-
-  const Heap::RootListIndex index_;
-};
-
-
-class HCheckMaps final : public HTemplateInstruction<2> {
- public:
-  static HCheckMaps* New(Isolate* isolate, Zone* zone, HValue* context,
-                         HValue* value, Handle<Map> map,
-                         HValue* typecheck = NULL) {
-    return new(zone) HCheckMaps(value, new(zone) UniqueSet<Map>(
-            Unique<Map>::CreateImmovable(map), zone), typecheck);
-  }
-  static HCheckMaps* New(Isolate* isolate, Zone* zone, HValue* context,
-                         HValue* value, SmallMapList* map_list,
-                         HValue* typecheck = NULL) {
-    UniqueSet<Map>* maps = new(zone) UniqueSet<Map>(map_list->length(), zone);
-    for (int i = 0; i < map_list->length(); ++i) {
-      maps->Add(Unique<Map>::CreateImmovable(map_list->at(i)), zone);
-    }
-    return new(zone) HCheckMaps(value, maps, typecheck);
-  }
-
-  bool IsStabilityCheck() const {
-    return IsStabilityCheckField::decode(bit_field_);
-  }
-  void MarkAsStabilityCheck() {
-    bit_field_ = MapsAreStableField::encode(true) |
-                 HasMigrationTargetField::encode(false) |
-                 IsStabilityCheckField::encode(true);
-    ClearChangesFlag(kNewSpacePromotion);
-    ClearDependsOnFlag(kElementsKind);
-    ClearDependsOnFlag(kMaps);
-  }
-
-  bool HasEscapingOperandAt(int index) override { return false; }
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  HType CalculateInferredType() override {
-    if (value()->type().IsHeapObject()) return value()->type();
-    return HType::HeapObject();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  HValue* value() const { return OperandAt(0); }
-  HValue* typecheck() const { return OperandAt(1); }
-
-  const UniqueSet<Map>* maps() const { return maps_; }
-  void set_maps(const UniqueSet<Map>* maps) { maps_ = maps; }
-
-  bool maps_are_stable() const {
-    return MapsAreStableField::decode(bit_field_);
-  }
-
-  bool HasMigrationTarget() const {
-    return HasMigrationTargetField::decode(bit_field_);
-  }
-
-  HValue* Canonicalize() override;
-
-  static HCheckMaps* CreateAndInsertAfter(Zone* zone,
-                                          HValue* value,
-                                          Unique<Map> map,
-                                          bool map_is_stable,
-                                          HInstruction* instr) {
-    return instr->Append(new(zone) HCheckMaps(
-            value, new(zone) UniqueSet<Map>(map, zone), map_is_stable));
-  }
-
-  static HCheckMaps* CreateAndInsertBefore(Zone* zone,
-                                           HValue* value,
-                                           const UniqueSet<Map>* maps,
-                                           bool maps_are_stable,
-                                           HInstruction* instr) {
-    return instr->Prepend(new(zone) HCheckMaps(value, maps, maps_are_stable));
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(CheckMaps)
-
- protected:
-  bool DataEquals(HValue* other) override {
-    return this->maps()->Equals(HCheckMaps::cast(other)->maps());
-  }
-
-  int RedefinedOperandIndex() override { return 0; }
-
- private:
-  HCheckMaps(HValue* value, const UniqueSet<Map>* maps, bool maps_are_stable)
-      : HTemplateInstruction<2>(HType::HeapObject()),
-        maps_(maps),
-        bit_field_(HasMigrationTargetField::encode(false) |
-                   IsStabilityCheckField::encode(false) |
-                   MapsAreStableField::encode(maps_are_stable)) {
-    DCHECK_NE(0, maps->size());
-    SetOperandAt(0, value);
-    // Use the object value for the dependency.
-    SetOperandAt(1, value);
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-    SetDependsOnFlag(kMaps);
-    SetDependsOnFlag(kElementsKind);
-  }
-
-  HCheckMaps(HValue* value, const UniqueSet<Map>* maps, HValue* typecheck)
-      : HTemplateInstruction<2>(HType::HeapObject()),
-        maps_(maps),
-        bit_field_(HasMigrationTargetField::encode(false) |
-                   IsStabilityCheckField::encode(false) |
-                   MapsAreStableField::encode(true)) {
-    DCHECK_NE(0, maps->size());
-    SetOperandAt(0, value);
-    // Use the object value for the dependency if NULL is passed.
-    SetOperandAt(1, typecheck ? typecheck : value);
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-    SetDependsOnFlag(kMaps);
-    SetDependsOnFlag(kElementsKind);
-    for (int i = 0; i < maps->size(); ++i) {
-      Handle<Map> map = maps->at(i).handle();
-      if (map->is_migration_target()) {
-        bit_field_ = HasMigrationTargetField::update(bit_field_, true);
-      }
-      if (!map->is_stable()) {
-        bit_field_ = MapsAreStableField::update(bit_field_, false);
-      }
-    }
-    if (HasMigrationTarget()) SetChangesFlag(kNewSpacePromotion);
-  }
-
-  class HasMigrationTargetField : public BitField<bool, 0, 1> {};
-  class IsStabilityCheckField : public BitField<bool, 1, 1> {};
-  class MapsAreStableField : public BitField<bool, 2, 1> {};
-
-  const UniqueSet<Map>* maps_;
-  uint32_t bit_field_;
-};
-
-
-class HCheckValue final : public HUnaryOperation {
- public:
-  static HCheckValue* New(Isolate* isolate, Zone* zone, HValue* context,
-                          HValue* value, Handle<JSFunction> func) {
-    bool in_new_space = isolate->heap()->InNewSpace(*func);
-    // NOTE: We create an uninitialized Unique and initialize it later.
-    // This is because a JSFunction can move due to GC during graph creation.
-    // TODO(titzer): This is a migration crutch. Replace with some kind of
-    // Uniqueness scope later.
-    Unique<JSFunction> target = Unique<JSFunction>::CreateUninitialized(func);
-    HCheckValue* check = new(zone) HCheckValue(value, target, in_new_space);
-    return check;
-  }
-  static HCheckValue* New(Isolate* isolate, Zone* zone, HValue* context,
-                          HValue* value, Unique<HeapObject> target,
-                          bool object_in_new_space) {
-    return new(zone) HCheckValue(value, target, object_in_new_space);
-  }
-
-  void FinalizeUniqueness() override {
-    object_ = Unique<HeapObject>(object_.handle());
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  HValue* Canonicalize() override;
-
-#ifdef DEBUG
-  void Verify() override;
-#endif
-
-  Unique<HeapObject> object() const { return object_; }
-  bool object_in_new_space() const { return object_in_new_space_; }
-
-  DECLARE_CONCRETE_INSTRUCTION(CheckValue)
-
- protected:
-  bool DataEquals(HValue* other) override {
-    HCheckValue* b = HCheckValue::cast(other);
-    return object_ == b->object_;
-  }
-
- private:
-  HCheckValue(HValue* value, Unique<HeapObject> object,
-               bool object_in_new_space)
-      : HUnaryOperation(value, value->type()),
-        object_(object),
-        object_in_new_space_(object_in_new_space) {
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-  }
-
-  Unique<HeapObject> object_;
-  bool object_in_new_space_;
-};
-
-
-class HCheckInstanceType final : public HUnaryOperation {
- public:
-  enum Check {
-    IS_SPEC_OBJECT,
-    IS_JS_ARRAY,
-    IS_JS_DATE,
-    IS_STRING,
-    IS_INTERNALIZED_STRING,
-    LAST_INTERVAL_CHECK = IS_JS_DATE
-  };
-
-  DECLARE_INSTRUCTION_FACTORY_P2(HCheckInstanceType, HValue*, Check);
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  HType CalculateInferredType() override {
-    switch (check_) {
-      case IS_SPEC_OBJECT: return HType::JSObject();
-      case IS_JS_ARRAY: return HType::JSArray();
-      case IS_JS_DATE:
-        return HType::JSObject();
-      case IS_STRING: return HType::String();
-      case IS_INTERNALIZED_STRING: return HType::String();
-    }
-    UNREACHABLE();
-    return HType::Tagged();
-  }
-
-  HValue* Canonicalize() override;
-
-  bool is_interval_check() const { return check_ <= LAST_INTERVAL_CHECK; }
-  void GetCheckInterval(InstanceType* first, InstanceType* last);
-  void GetCheckMaskAndTag(uint8_t* mask, uint8_t* tag);
-
-  Check check() const { return check_; }
-
-  DECLARE_CONCRETE_INSTRUCTION(CheckInstanceType)
-
- protected:
-  // TODO(ager): It could be nice to allow the ommision of instance
-  // type checks if we have already performed an instance type check
-  // with a larger range.
-  bool DataEquals(HValue* other) override {
-    HCheckInstanceType* b = HCheckInstanceType::cast(other);
-    return check_ == b->check_;
-  }
-
-  int RedefinedOperandIndex() override { return 0; }
-
- private:
-  const char* GetCheckName() const;
-
-  HCheckInstanceType(HValue* value, Check check)
-      : HUnaryOperation(value, HType::HeapObject()), check_(check) {
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-  }
-
-  const Check check_;
-};
-
-
-class HCheckSmi final : public HUnaryOperation {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HCheckSmi, HValue*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  HValue* Canonicalize() override {
-    HType value_type = value()->type();
-    if (value_type.IsSmi()) {
-      return NULL;
-    }
-    return this;
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(CheckSmi)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  explicit HCheckSmi(HValue* value) : HUnaryOperation(value, HType::Smi()) {
-    set_representation(Representation::Smi());
-    SetFlag(kUseGVN);
-  }
-};
-
-
-class HCheckArrayBufferNotNeutered final : public HUnaryOperation {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HCheckArrayBufferNotNeutered, HValue*);
-
-  bool HasEscapingOperandAt(int index) override { return false; }
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  HType CalculateInferredType() override {
-    if (value()->type().IsHeapObject()) return value()->type();
-    return HType::HeapObject();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(CheckArrayBufferNotNeutered)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-  int RedefinedOperandIndex() override { return 0; }
-
- private:
-  explicit HCheckArrayBufferNotNeutered(HValue* value)
-      : HUnaryOperation(value) {
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-    SetDependsOnFlag(kCalls);
-  }
-};
-
-
-class HCheckHeapObject final : public HUnaryOperation {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HCheckHeapObject, HValue*);
-
-  bool HasEscapingOperandAt(int index) override { return false; }
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  HType CalculateInferredType() override {
-    if (value()->type().IsHeapObject()) return value()->type();
-    return HType::HeapObject();
-  }
-
-#ifdef DEBUG
-  void Verify() override;
-#endif
-
-  HValue* Canonicalize() override {
-    return value()->type().IsHeapObject() ? NULL : this;
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(CheckHeapObject)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  explicit HCheckHeapObject(HValue* value) : HUnaryOperation(value) {
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-  }
-};
-
-
-class InductionVariableData;
-
-
-struct InductionVariableLimitUpdate {
-  InductionVariableData* updated_variable;
-  HValue* limit;
-  bool limit_is_upper;
-  bool limit_is_included;
-
-  InductionVariableLimitUpdate()
-      : updated_variable(NULL), limit(NULL),
-        limit_is_upper(false), limit_is_included(false) {}
-};
-
-
-class HBoundsCheck;
-class HPhi;
-class HBitwise;
-
-
-class InductionVariableData final : public ZoneObject {
- public:
-  class InductionVariableCheck : public ZoneObject {
-   public:
-    HBoundsCheck* check() { return check_; }
-    InductionVariableCheck* next() { return next_; }
-    bool HasUpperLimit() { return upper_limit_ >= 0; }
-    int32_t upper_limit() {
-      DCHECK(HasUpperLimit());
-      return upper_limit_;
-    }
-    void set_upper_limit(int32_t upper_limit) {
-      upper_limit_ = upper_limit;
-    }
-
-    bool processed() { return processed_; }
-    void set_processed() { processed_ = true; }
-
-    InductionVariableCheck(HBoundsCheck* check,
-                           InductionVariableCheck* next,
-                           int32_t upper_limit = kNoLimit)
-        : check_(check), next_(next), upper_limit_(upper_limit),
-          processed_(false) {}
-
-   private:
-    HBoundsCheck* check_;
-    InductionVariableCheck* next_;
-    int32_t upper_limit_;
-    bool processed_;
-  };
-
-  class ChecksRelatedToLength : public ZoneObject {
-   public:
-    HValue* length() { return length_; }
-    ChecksRelatedToLength* next() { return next_; }
-    InductionVariableCheck* checks() { return checks_; }
-
-    void AddCheck(HBoundsCheck* check, int32_t upper_limit = kNoLimit);
-    void CloseCurrentBlock();
-
-    ChecksRelatedToLength(HValue* length, ChecksRelatedToLength* next)
-      : length_(length), next_(next), checks_(NULL),
-        first_check_in_block_(NULL),
-        added_index_(NULL),
-        added_constant_(NULL),
-        current_and_mask_in_block_(0),
-        current_or_mask_in_block_(0) {}
-
-   private:
-    void UseNewIndexInCurrentBlock(Token::Value token,
-                                   int32_t mask,
-                                   HValue* index_base,
-                                   HValue* context);
-
-    HBoundsCheck* first_check_in_block() { return first_check_in_block_; }
-    HBitwise* added_index() { return added_index_; }
-    void set_added_index(HBitwise* index) { added_index_ = index; }
-    HConstant* added_constant() { return added_constant_; }
-    void set_added_constant(HConstant* constant) { added_constant_ = constant; }
-    int32_t current_and_mask_in_block() { return current_and_mask_in_block_; }
-    int32_t current_or_mask_in_block() { return current_or_mask_in_block_; }
-    int32_t current_upper_limit() { return current_upper_limit_; }
-
-    HValue* length_;
-    ChecksRelatedToLength* next_;
-    InductionVariableCheck* checks_;
-
-    HBoundsCheck* first_check_in_block_;
-    HBitwise* added_index_;
-    HConstant* added_constant_;
-    int32_t current_and_mask_in_block_;
-    int32_t current_or_mask_in_block_;
-    int32_t current_upper_limit_;
-  };
-
-  struct LimitFromPredecessorBlock {
-    InductionVariableData* variable;
-    Token::Value token;
-    HValue* limit;
-    HBasicBlock* other_target;
-
-    bool LimitIsValid() { return token != Token::ILLEGAL; }
-
-    bool LimitIsIncluded() {
-      return Token::IsEqualityOp(token) ||
-          token == Token::GTE || token == Token::LTE;
-    }
-    bool LimitIsUpper() {
-      return token == Token::LTE || token == Token::LT || token == Token::NE;
-    }
-
-    LimitFromPredecessorBlock()
-        : variable(NULL),
-          token(Token::ILLEGAL),
-          limit(NULL),
-          other_target(NULL) {}
-  };
-
-  static const int32_t kNoLimit = -1;
-
-  static InductionVariableData* ExaminePhi(HPhi* phi);
-  static void ComputeLimitFromPredecessorBlock(
-      HBasicBlock* block,
-      LimitFromPredecessorBlock* result);
-  static bool ComputeInductionVariableLimit(
-      HBasicBlock* block,
-      InductionVariableLimitUpdate* additional_limit);
-
-  struct BitwiseDecompositionResult {
-    HValue* base;
-    int32_t and_mask;
-    int32_t or_mask;
-    HValue* context;
-
-    BitwiseDecompositionResult()
-        : base(NULL), and_mask(0), or_mask(0), context(NULL) {}
-  };
-  static void DecomposeBitwise(HValue* value,
-                               BitwiseDecompositionResult* result);
-
-  void AddCheck(HBoundsCheck* check, int32_t upper_limit = kNoLimit);
-
-  bool CheckIfBranchIsLoopGuard(Token::Value token,
-                                HBasicBlock* current_branch,
-                                HBasicBlock* other_branch);
-
-  void UpdateAdditionalLimit(InductionVariableLimitUpdate* update);
-
-  HPhi* phi() { return phi_; }
-  HValue* base() { return base_; }
-  int32_t increment() { return increment_; }
-  HValue* limit() { return limit_; }
-  bool limit_included() { return limit_included_; }
-  HBasicBlock* limit_validity() { return limit_validity_; }
-  HBasicBlock* induction_exit_block() { return induction_exit_block_; }
-  HBasicBlock* induction_exit_target() { return induction_exit_target_; }
-  ChecksRelatedToLength* checks() { return checks_; }
-  HValue* additional_upper_limit() { return additional_upper_limit_; }
-  bool additional_upper_limit_is_included() {
-    return additional_upper_limit_is_included_;
-  }
-  HValue* additional_lower_limit() { return additional_lower_limit_; }
-  bool additional_lower_limit_is_included() {
-    return additional_lower_limit_is_included_;
-  }
-
-  bool LowerLimitIsNonNegativeConstant() {
-    if (base()->IsInteger32Constant() && base()->GetInteger32Constant() >= 0) {
-      return true;
-    }
-    if (additional_lower_limit() != NULL &&
-        additional_lower_limit()->IsInteger32Constant() &&
-        additional_lower_limit()->GetInteger32Constant() >= 0) {
-      // Ignoring the corner case of !additional_lower_limit_is_included()
-      // is safe, handling it adds unneeded complexity.
-      return true;
-    }
-    return false;
-  }
-
-  int32_t ComputeUpperLimit(int32_t and_mask, int32_t or_mask);
-
- private:
-  template <class T> void swap(T* a, T* b) {
-    T c(*a);
-    *a = *b;
-    *b = c;
-  }
-
-  InductionVariableData(HPhi* phi, HValue* base, int32_t increment)
-      : phi_(phi), base_(IgnoreOsrValue(base)), increment_(increment),
-        limit_(NULL), limit_included_(false), limit_validity_(NULL),
-        induction_exit_block_(NULL), induction_exit_target_(NULL),
-        checks_(NULL),
-        additional_upper_limit_(NULL),
-        additional_upper_limit_is_included_(false),
-        additional_lower_limit_(NULL),
-        additional_lower_limit_is_included_(false) {}
-
-  static int32_t ComputeIncrement(HPhi* phi, HValue* phi_operand);
-
-  static HValue* IgnoreOsrValue(HValue* v);
-  static InductionVariableData* GetInductionVariableData(HValue* v);
-
-  HPhi* phi_;
-  HValue* base_;
-  int32_t increment_;
-  HValue* limit_;
-  bool limit_included_;
-  HBasicBlock* limit_validity_;
-  HBasicBlock* induction_exit_block_;
-  HBasicBlock* induction_exit_target_;
-  ChecksRelatedToLength* checks_;
-  HValue* additional_upper_limit_;
-  bool additional_upper_limit_is_included_;
-  HValue* additional_lower_limit_;
-  bool additional_lower_limit_is_included_;
-};
-
-
-class HPhi final : public HValue {
- public:
-  HPhi(int merged_index, Zone* zone)
-      : inputs_(2, zone), merged_index_(merged_index) {
-    DCHECK(merged_index >= 0 || merged_index == kInvalidMergedIndex);
-    SetFlag(kFlexibleRepresentation);
-    SetFlag(kAllowUndefinedAsNaN);
-  }
-
-  Representation RepresentationFromInputs() override;
-
-  Range* InferRange(Zone* zone) override;
-  virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
-  Representation RequiredInputRepresentation(int index) override {
-    return representation();
-  }
-  Representation KnownOptimalRepresentation() override {
-    return representation();
-  }
-  HType CalculateInferredType() override;
-  int OperandCount() const override { return inputs_.length(); }
-  HValue* OperandAt(int index) const override { return inputs_[index]; }
-  HValue* GetRedundantReplacement();
-  void AddInput(HValue* value);
-  bool HasRealUses();
-
-  bool IsReceiver() const { return merged_index_ == 0; }
-  bool HasMergedIndex() const { return merged_index_ != kInvalidMergedIndex; }
-
-  SourcePosition position() const override;
-
-  int merged_index() const { return merged_index_; }
-
-  InductionVariableData* induction_variable_data() {
-    return induction_variable_data_;
-  }
-  bool IsInductionVariable() {
-    return induction_variable_data_ != NULL;
-  }
-  bool IsLimitedInductionVariable() {
-    return IsInductionVariable() &&
-        induction_variable_data_->limit() != NULL;
-  }
-  void DetectInductionVariable() {
-    DCHECK(induction_variable_data_ == NULL);
-    induction_variable_data_ = InductionVariableData::ExaminePhi(this);
-  }
-
-  std::ostream& PrintTo(std::ostream& os) const override;  // NOLINT
-
-#ifdef DEBUG
-  void Verify() override;
-#endif
-
-  void InitRealUses(int id);
-  void AddNonPhiUsesFrom(HPhi* other);
-
-  Representation representation_from_indirect_uses() const {
-    return representation_from_indirect_uses_;
-  }
-
-  bool has_type_feedback_from_uses() const {
-    return has_type_feedback_from_uses_;
-  }
-
-  int phi_id() { return phi_id_; }
-
-  static HPhi* cast(HValue* value) {
-    DCHECK(value->IsPhi());
-    return reinterpret_cast<HPhi*>(value);
-  }
-  Opcode opcode() const override { return HValue::kPhi; }
-
-  void SimplifyConstantInputs();
-
-  // Marker value representing an invalid merge index.
-  static const int kInvalidMergedIndex = -1;
-
- protected:
-  void DeleteFromGraph() override;
-  void InternalSetOperandAt(int index, HValue* value) override {
-    inputs_[index] = value;
-  }
-
- private:
-  Representation representation_from_non_phi_uses() const {
-    return representation_from_non_phi_uses_;
-  }
-
-  ZoneList<HValue*> inputs_;
-  int merged_index_ = 0;
-
-  int phi_id_ = -1;
-  InductionVariableData* induction_variable_data_ = nullptr;
-
-  Representation representation_from_indirect_uses_ = Representation::None();
-  Representation representation_from_non_phi_uses_ = Representation::None();
-  bool has_type_feedback_from_uses_ = false;
-
-  // TODO(titzer): we can't eliminate the receiver for generating backtraces
-  bool IsDeletable() const override { return !IsReceiver(); }
-};
-
-
-// Common base class for HArgumentsObject and HCapturedObject.
-class HDematerializedObject : public HInstruction {
- public:
-  HDematerializedObject(int count, Zone* zone) : values_(count, zone) {}
-
-  int OperandCount() const final { return values_.length(); }
-  HValue* OperandAt(int index) const final { return values_[index]; }
-
-  bool HasEscapingOperandAt(int index) final { return false; }
-  Representation RequiredInputRepresentation(int index) final {
-    return Representation::None();
-  }
-
- protected:
-  void InternalSetOperandAt(int index, HValue* value) final {
-    values_[index] = value;
-  }
-
-  // List of values tracked by this marker.
-  ZoneList<HValue*> values_;
-};
-
-
-class HArgumentsObject final : public HDematerializedObject {
- public:
-  static HArgumentsObject* New(Isolate* isolate, Zone* zone, HValue* context,
-                               int count) {
-    return new(zone) HArgumentsObject(count, zone);
-  }
-
-  // The values contain a list of all elements in the arguments object
-  // including the receiver object, which is skipped when materializing.
-  const ZoneList<HValue*>* arguments_values() const { return &values_; }
-  int arguments_count() const { return values_.length(); }
-
-  void AddArgument(HValue* argument, Zone* zone) {
-    values_.Add(NULL, zone);  // Resize list.
-    SetOperandAt(values_.length() - 1, argument);
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(ArgumentsObject)
-
- private:
-  HArgumentsObject(int count, Zone* zone)
-      : HDematerializedObject(count, zone) {
-    set_representation(Representation::Tagged());
-    SetFlag(kIsArguments);
-  }
-};
-
-
-class HCapturedObject final : public HDematerializedObject {
- public:
-  HCapturedObject(int length, int id, Zone* zone)
-      : HDematerializedObject(length, zone), capture_id_(id) {
-    set_representation(Representation::Tagged());
-    values_.AddBlock(NULL, length, zone);  // Resize list.
-  }
-
-  // The values contain a list of all in-object properties inside the
-  // captured object and is index by field index. Properties in the
-  // properties or elements backing store are not tracked here.
-  const ZoneList<HValue*>* values() const { return &values_; }
-  int length() const { return values_.length(); }
-  int capture_id() const { return capture_id_; }
-
-  // Shortcut for the map value of this captured object.
-  HValue* map_value() const { return values()->first(); }
-
-  void ReuseSideEffectsFromStore(HInstruction* store) {
-    DCHECK(store->HasObservableSideEffects());
-    DCHECK(store->IsStoreNamedField());
-    changes_flags_.Add(store->ChangesFlags());
-  }
-
-  // Replay effects of this instruction on the given environment.
-  void ReplayEnvironment(HEnvironment* env);
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(CapturedObject)
-
- private:
-  int capture_id_;
-
-  // Note that we cannot DCE captured objects as they are used to replay
-  // the environment. This method is here as an explicit reminder.
-  // TODO(mstarzinger): Turn HSimulates into full snapshots maybe?
-  bool IsDeletable() const final { return false; }
-};
-
-
-class HConstant final : public HTemplateInstruction<0> {
- public:
-  enum Special { kHoleNaN };
-
-  DECLARE_INSTRUCTION_FACTORY_P1(HConstant, Special);
-  DECLARE_INSTRUCTION_FACTORY_P1(HConstant, int32_t);
-  DECLARE_INSTRUCTION_FACTORY_P2(HConstant, int32_t, Representation);
-  DECLARE_INSTRUCTION_FACTORY_P1(HConstant, double);
-  DECLARE_INSTRUCTION_FACTORY_P1(HConstant, Handle<Object>);
-  DECLARE_INSTRUCTION_FACTORY_P1(HConstant, ExternalReference);
-
-  static HConstant* CreateAndInsertAfter(Isolate* isolate, Zone* zone,
-                                         HValue* context, int32_t value,
-                                         Representation representation,
-                                         HInstruction* instruction) {
-    return instruction->Append(
-        HConstant::New(isolate, zone, context, value, representation));
-  }
-
-  Handle<Map> GetMonomorphicJSObjectMap() override {
-    Handle<Object> object = object_.handle();
-    if (!object.is_null() && object->IsHeapObject()) {
-      return v8::internal::handle(HeapObject::cast(*object)->map());
-    }
-    return Handle<Map>();
-  }
-
-  static HConstant* CreateAndInsertBefore(Isolate* isolate, Zone* zone,
-                                          HValue* context, int32_t value,
-                                          Representation representation,
-                                          HInstruction* instruction) {
-    return instruction->Prepend(
-        HConstant::New(isolate, zone, context, value, representation));
-  }
-
-  static HConstant* CreateAndInsertBefore(Zone* zone,
-                                          Unique<Map> map,
-                                          bool map_is_stable,
-                                          HInstruction* instruction) {
-    return instruction->Prepend(new(zone) HConstant(
-        map, Unique<Map>(Handle<Map>::null()), map_is_stable,
-        Representation::Tagged(), HType::HeapObject(), true,
-        false, false, MAP_TYPE));
-  }
-
-  static HConstant* CreateAndInsertAfter(Zone* zone,
-                                         Unique<Map> map,
-                                         bool map_is_stable,
-                                         HInstruction* instruction) {
-    return instruction->Append(new(zone) HConstant(
-            map, Unique<Map>(Handle<Map>::null()), map_is_stable,
-            Representation::Tagged(), HType::HeapObject(), true,
-            false, false, MAP_TYPE));
-  }
-
-  Handle<Object> handle(Isolate* isolate) {
-    if (object_.handle().is_null()) {
-      // Default arguments to is_not_in_new_space depend on this heap number
-      // to be tenured so that it's guaranteed not to be located in new space.
-      object_ = Unique<Object>::CreateUninitialized(
-          isolate->factory()->NewNumber(double_value_, TENURED));
-    }
-    AllowDeferredHandleDereference smi_check;
-    DCHECK(HasInteger32Value() || !object_.handle()->IsSmi());
-    return object_.handle();
-  }
-
-  bool IsSpecialDouble() const {
-    return HasDoubleValue() &&
-           (bit_cast<int64_t>(double_value_) == bit_cast<int64_t>(-0.0) ||
-            std::isnan(double_value_));
-  }
-
-  bool NotInNewSpace() const {
-    return IsNotInNewSpaceField::decode(bit_field_);
-  }
-
-  bool ImmortalImmovable() const;
-
-  bool IsCell() const {
-    InstanceType instance_type = GetInstanceType();
-    return instance_type == CELL_TYPE;
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  Representation KnownOptimalRepresentation() override {
-    if (HasSmiValue() && SmiValuesAre31Bits()) return Representation::Smi();
-    if (HasInteger32Value()) return Representation::Integer32();
-    if (HasNumberValue()) return Representation::Double();
-    if (HasExternalReferenceValue()) return Representation::External();
-    return Representation::Tagged();
-  }
-
-  bool EmitAtUses() override;
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-  HConstant* CopyToRepresentation(Representation r, Zone* zone) const;
-  Maybe<HConstant*> CopyToTruncatedInt32(Zone* zone);
-  Maybe<HConstant*> CopyToTruncatedNumber(Isolate* isolate, Zone* zone);
-  bool HasInteger32Value() const {
-    return HasInt32ValueField::decode(bit_field_);
-  }
-  int32_t Integer32Value() const {
-    DCHECK(HasInteger32Value());
-    return int32_value_;
-  }
-  bool HasSmiValue() const { return HasSmiValueField::decode(bit_field_); }
-  bool HasDoubleValue() const {
-    return HasDoubleValueField::decode(bit_field_);
-  }
-  double DoubleValue() const {
-    DCHECK(HasDoubleValue());
-    return double_value_;
-  }
-  uint64_t DoubleValueAsBits() const {
-    uint64_t bits;
-    DCHECK(HasDoubleValue());
-    STATIC_ASSERT(sizeof(bits) == sizeof(double_value_));
-    std::memcpy(&bits, &double_value_, sizeof(bits));
-    return bits;
-  }
-  bool IsTheHole() const {
-    if (HasDoubleValue() && DoubleValueAsBits() == kHoleNanInt64) {
-      return true;
-    }
-    return object_.IsInitialized() &&
-           object_.IsKnownGlobal(isolate()->heap()->the_hole_value());
-  }
-  bool HasNumberValue() const { return HasDoubleValue(); }
-  int32_t NumberValueAsInteger32() const {
-    DCHECK(HasNumberValue());
-    // Irrespective of whether a numeric HConstant can be safely
-    // represented as an int32, we store the (in some cases lossy)
-    // representation of the number in int32_value_.
-    return int32_value_;
-  }
-  bool HasStringValue() const {
-    if (HasNumberValue()) return false;
-    DCHECK(!object_.handle().is_null());
-    return GetInstanceType() < FIRST_NONSTRING_TYPE;
-  }
-  Handle<String> StringValue() const {
-    DCHECK(HasStringValue());
-    return Handle<String>::cast(object_.handle());
-  }
-  bool HasInternalizedStringValue() const {
-    return HasStringValue() && StringShape(GetInstanceType()).IsInternalized();
-  }
-
-  bool HasExternalReferenceValue() const {
-    return HasExternalReferenceValueField::decode(bit_field_);
-  }
-  ExternalReference ExternalReferenceValue() const {
-    return external_reference_value_;
-  }
-
-  bool HasBooleanValue() const { return type_.IsBoolean(); }
-  bool BooleanValue() const { return BooleanValueField::decode(bit_field_); }
-  bool IsCallable() const { return IsCallableField::decode(bit_field_); }
-  bool IsUndetectable() const {
-    return IsUndetectableField::decode(bit_field_);
-  }
-  InstanceType GetInstanceType() const {
-    return InstanceTypeField::decode(bit_field_);
-  }
-
-  bool HasMapValue() const { return GetInstanceType() == MAP_TYPE; }
-  Unique<Map> MapValue() const {
-    DCHECK(HasMapValue());
-    return Unique<Map>::cast(GetUnique());
-  }
-  bool HasStableMapValue() const {
-    DCHECK(HasMapValue() || !HasStableMapValueField::decode(bit_field_));
-    return HasStableMapValueField::decode(bit_field_);
-  }
-
-  bool HasObjectMap() const { return !object_map_.IsNull(); }
-  Unique<Map> ObjectMap() const {
-    DCHECK(HasObjectMap());
-    return object_map_;
-  }
-
-  intptr_t Hashcode() override {
-    if (HasInteger32Value()) {
-      return static_cast<intptr_t>(int32_value_);
-    } else if (HasDoubleValue()) {
-      uint64_t bits = DoubleValueAsBits();
-      if (sizeof(bits) > sizeof(intptr_t)) {
-        bits ^= (bits >> 32);
-      }
-      return static_cast<intptr_t>(bits);
-    } else if (HasExternalReferenceValue()) {
-      return reinterpret_cast<intptr_t>(external_reference_value_.address());
-    } else {
-      DCHECK(!object_.handle().is_null());
-      return object_.Hashcode();
-    }
-  }
-
-  void FinalizeUniqueness() override {
-    if (!HasDoubleValue() && !HasExternalReferenceValue()) {
-      DCHECK(!object_.handle().is_null());
-      object_ = Unique<Object>(object_.handle());
-    }
-  }
-
-  Unique<Object> GetUnique() const {
-    return object_;
-  }
-
-  bool EqualsUnique(Unique<Object> other) const {
-    return object_.IsInitialized() && object_ == other;
-  }
-
-  bool DataEquals(HValue* other) override {
-    HConstant* other_constant = HConstant::cast(other);
-    if (HasInteger32Value()) {
-      return other_constant->HasInteger32Value() &&
-             int32_value_ == other_constant->int32_value_;
-    } else if (HasDoubleValue()) {
-      return other_constant->HasDoubleValue() &&
-             std::memcmp(&double_value_, &other_constant->double_value_,
-                         sizeof(double_value_)) == 0;
-    } else if (HasExternalReferenceValue()) {
-      return other_constant->HasExternalReferenceValue() &&
-             external_reference_value_ ==
-                 other_constant->external_reference_value_;
-    } else {
-      if (other_constant->HasInteger32Value() ||
-          other_constant->HasDoubleValue() ||
-          other_constant->HasExternalReferenceValue()) {
-        return false;
-      }
-      DCHECK(!object_.handle().is_null());
-      return other_constant->object_ == object_;
-    }
-  }
-
-#ifdef DEBUG
-  void Verify() override {}
-#endif
-
-  DECLARE_CONCRETE_INSTRUCTION(Constant)
-
- protected:
-  Range* InferRange(Zone* zone) override;
-
- private:
-  friend class HGraph;
-  explicit HConstant(Special special);
-  explicit HConstant(Handle<Object> handle,
-                     Representation r = Representation::None());
-  HConstant(int32_t value,
-            Representation r = Representation::None(),
-            bool is_not_in_new_space = true,
-            Unique<Object> optional = Unique<Object>(Handle<Object>::null()));
-  HConstant(double value,
-            Representation r = Representation::None(),
-            bool is_not_in_new_space = true,
-            Unique<Object> optional = Unique<Object>(Handle<Object>::null()));
-  HConstant(Unique<Object> object,
-            Unique<Map> object_map,
-            bool has_stable_map_value,
-            Representation r,
-            HType type,
-            bool is_not_in_new_space,
-            bool boolean_value,
-            bool is_undetectable,
-            InstanceType instance_type);
-
-  explicit HConstant(ExternalReference reference);
-
-  void Initialize(Representation r);
-
-  bool IsDeletable() const override { return true; }
-
-  // If object_ is a map, this indicates whether the map is stable.
-  class HasStableMapValueField : public BitField<bool, 0, 1> {};
-
-  // We store the HConstant in the most specific form safely possible.
-  // These flags tell us if the respective member fields hold valid, safe
-  // representations of the constant. More specific flags imply more general
-  // flags, but not the converse (i.e. smi => int32 => double).
-  class HasSmiValueField : public BitField<bool, 1, 1> {};
-  class HasInt32ValueField : public BitField<bool, 2, 1> {};
-  class HasDoubleValueField : public BitField<bool, 3, 1> {};
-
-  class HasExternalReferenceValueField : public BitField<bool, 4, 1> {};
-  class IsNotInNewSpaceField : public BitField<bool, 5, 1> {};
-  class BooleanValueField : public BitField<bool, 6, 1> {};
-  class IsUndetectableField : public BitField<bool, 7, 1> {};
-  class IsCallableField : public BitField<bool, 8, 1> {};
-
-  static const InstanceType kUnknownInstanceType = FILLER_TYPE;
-  class InstanceTypeField : public BitField<InstanceType, 16, 8> {};
-
-  // If this is a numerical constant, object_ either points to the
-  // HeapObject the constant originated from or is null.  If the
-  // constant is non-numeric, object_ always points to a valid
-  // constant HeapObject.
-  Unique<Object> object_;
-
-  // If object_ is a heap object, this points to the stable map of the object.
-  Unique<Map> object_map_;
-
-  uint32_t bit_field_;
-
-  int32_t int32_value_;
-  double double_value_;
-  ExternalReference external_reference_value_;
-};
-
-
-class HBinaryOperation : public HTemplateInstruction<3> {
- public:
-  HBinaryOperation(HValue* context, HValue* left, HValue* right,
-                   Strength strength, HType type = HType::Tagged())
-      : HTemplateInstruction<3>(type),
-        strength_(strength),
-        observed_output_representation_(Representation::None()) {
-    DCHECK(left != NULL && right != NULL);
-    SetOperandAt(0, context);
-    SetOperandAt(1, left);
-    SetOperandAt(2, right);
-    observed_input_representation_[0] = Representation::None();
-    observed_input_representation_[1] = Representation::None();
-  }
-
-  HValue* context() const { return OperandAt(0); }
-  HValue* left() const { return OperandAt(1); }
-  HValue* right() const { return OperandAt(2); }
-  Strength strength() const { return strength_; }
-
-  // True if switching left and right operands likely generates better code.
-  bool AreOperandsBetterSwitched() {
-    if (!IsCommutative()) return false;
-
-    // Constant operands are better off on the right, they can be inlined in
-    // many situations on most platforms.
-    if (left()->IsConstant()) return true;
-    if (right()->IsConstant()) return false;
-
-    // Otherwise, if there is only one use of the right operand, it would be
-    // better off on the left for platforms that only have 2-arg arithmetic
-    // ops (e.g ia32, x64) that clobber the left operand.
-    return right()->HasOneUse();
-  }
-
-  HValue* BetterLeftOperand() {
-    return AreOperandsBetterSwitched() ? right() : left();
-  }
-
-  HValue* BetterRightOperand() {
-    return AreOperandsBetterSwitched() ? left() : right();
-  }
-
-  void set_observed_input_representation(int index, Representation rep) {
-    DCHECK(index >= 1 && index <= 2);
-    observed_input_representation_[index - 1] = rep;
-  }
-
-  virtual void initialize_output_representation(Representation observed) {
-    observed_output_representation_ = observed;
-  }
-
-  Representation observed_input_representation(int index) override {
-    if (index == 0) return Representation::Tagged();
-    return observed_input_representation_[index - 1];
-  }
-
-  virtual void UpdateRepresentation(Representation new_rep,
-                                    HInferRepresentationPhase* h_infer,
-                                    const char* reason) override {
-    Representation rep = !FLAG_smi_binop && new_rep.IsSmi()
-        ? Representation::Integer32() : new_rep;
-    HValue::UpdateRepresentation(rep, h_infer, reason);
-  }
-
-  virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
-  Representation RepresentationFromInputs() override;
-  Representation RepresentationFromOutput();
-  void AssumeRepresentation(Representation r) override;
-
-  virtual bool IsCommutative() const { return false; }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) override {
-    if (index == 0) return Representation::Tagged();
-    return representation();
-  }
-
-  void SetOperandPositions(Zone* zone, SourcePosition left_pos,
-                           SourcePosition right_pos) {
-    set_operand_position(zone, 1, left_pos);
-    set_operand_position(zone, 2, right_pos);
-  }
-
-  bool RightIsPowerOf2() {
-    if (!right()->IsInteger32Constant()) return false;
-    int32_t value = right()->GetInteger32Constant();
-    if (value < 0) {
-      return base::bits::IsPowerOfTwo32(static_cast<uint32_t>(-value));
-    }
-    return base::bits::IsPowerOfTwo32(static_cast<uint32_t>(value));
-  }
-
-  Strength strength() { return strength_; }
-
-  DECLARE_ABSTRACT_INSTRUCTION(BinaryOperation)
-
- private:
-  bool IgnoreObservedOutputRepresentation(Representation current_rep);
-  Strength strength_;
-
-  Representation observed_input_representation_[2];
-  Representation observed_output_representation_;
-};
-
-
-class HWrapReceiver final : public HTemplateInstruction<2> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P2(HWrapReceiver, HValue*, HValue*);
-
-  bool DataEquals(HValue* other) override { return true; }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  HValue* receiver() const { return OperandAt(0); }
-  HValue* function() const { return OperandAt(1); }
-
-  HValue* Canonicalize() override;
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-  bool known_function() const { return known_function_; }
-
-  DECLARE_CONCRETE_INSTRUCTION(WrapReceiver)
-
- private:
-  HWrapReceiver(HValue* receiver, HValue* function) {
-    known_function_ = function->IsConstant() &&
-        HConstant::cast(function)->handle(function->isolate())->IsJSFunction();
-    set_representation(Representation::Tagged());
-    SetOperandAt(0, receiver);
-    SetOperandAt(1, function);
-    SetFlag(kUseGVN);
-  }
-
-  bool known_function_;
-};
-
-
-class HApplyArguments final : public HTemplateInstruction<4> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P4(HApplyArguments, HValue*, HValue*, HValue*,
-                                 HValue*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    // The length is untagged, all other inputs are tagged.
-    return (index == 2)
-        ? Representation::Integer32()
-        : Representation::Tagged();
-  }
-
-  HValue* function() { return OperandAt(0); }
-  HValue* receiver() { return OperandAt(1); }
-  HValue* length() { return OperandAt(2); }
-  HValue* elements() { return OperandAt(3); }
-
-  DECLARE_CONCRETE_INSTRUCTION(ApplyArguments)
-
- private:
-  HApplyArguments(HValue* function,
-                  HValue* receiver,
-                  HValue* length,
-                  HValue* elements) {
-    set_representation(Representation::Tagged());
-    SetOperandAt(0, function);
-    SetOperandAt(1, receiver);
-    SetOperandAt(2, length);
-    SetOperandAt(3, elements);
-    SetAllSideEffects();
-  }
-};
-
-
-class HArgumentsElements final : public HTemplateInstruction<0> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HArgumentsElements, bool);
-
-  DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements)
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  bool from_inlined() const { return from_inlined_; }
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  explicit HArgumentsElements(bool from_inlined) : from_inlined_(from_inlined) {
-    // The value produced by this instruction is a pointer into the stack
-    // that looks as if it was a smi because of alignment.
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-  }
-
-  bool IsDeletable() const override { return true; }
-
-  bool from_inlined_;
-};
-
-
-class HArgumentsLength final : public HUnaryOperation {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HArgumentsLength, HValue*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(ArgumentsLength)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  explicit HArgumentsLength(HValue* value) : HUnaryOperation(value) {
-    set_representation(Representation::Integer32());
-    SetFlag(kUseGVN);
-  }
-
-  bool IsDeletable() const override { return true; }
-};
-
-
-class HAccessArgumentsAt final : public HTemplateInstruction<3> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P3(HAccessArgumentsAt, HValue*, HValue*, HValue*);
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) override {
-    // The arguments elements is considered tagged.
-    return index == 0
-        ? Representation::Tagged()
-        : Representation::Integer32();
-  }
-
-  HValue* arguments() const { return OperandAt(0); }
-  HValue* length() const { return OperandAt(1); }
-  HValue* index() const { return OperandAt(2); }
-
-  DECLARE_CONCRETE_INSTRUCTION(AccessArgumentsAt)
-
- private:
-  HAccessArgumentsAt(HValue* arguments, HValue* length, HValue* index) {
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-    SetOperandAt(0, arguments);
-    SetOperandAt(1, length);
-    SetOperandAt(2, index);
-  }
-
-  bool DataEquals(HValue* other) override { return true; }
-};
-
-
-class HBoundsCheckBaseIndexInformation;
-
-
-class HBoundsCheck final : public HTemplateInstruction<2> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P2(HBoundsCheck, HValue*, HValue*);
-
-  bool skip_check() const { return skip_check_; }
-  void set_skip_check() { skip_check_ = true; }
-
-  HValue* base() const { return base_; }
-  int offset() const { return offset_; }
-  int scale() const { return scale_; }
-
-  void ApplyIndexChange();
-  bool DetectCompoundIndex() {
-    DCHECK(base() == NULL);
-
-    DecompositionResult decomposition;
-    if (index()->TryDecompose(&decomposition)) {
-      base_ = decomposition.base();
-      offset_ = decomposition.offset();
-      scale_ = decomposition.scale();
-      return true;
-    } else {
-      base_ = index();
-      offset_ = 0;
-      scale_ = 0;
-      return false;
-    }
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return representation();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-  virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
-
-  HValue* index() const { return OperandAt(0); }
-  HValue* length() const { return OperandAt(1); }
-  bool allow_equality() const { return allow_equality_; }
-  void set_allow_equality(bool v) { allow_equality_ = v; }
-
-  int RedefinedOperandIndex() override { return 0; }
-  bool IsPurelyInformativeDefinition() override { return skip_check(); }
-
-  DECLARE_CONCRETE_INSTRUCTION(BoundsCheck)
-
- protected:
-  friend class HBoundsCheckBaseIndexInformation;
-
-  Range* InferRange(Zone* zone) override;
-
-  bool DataEquals(HValue* other) override { return true; }
-  bool skip_check_;
-  HValue* base_;
-  int offset_;
-  int scale_;
-  bool allow_equality_;
-
- private:
-  // Normally HBoundsCheck should be created using the
-  // HGraphBuilder::AddBoundsCheck() helper.
-  // However when building stubs, where we know that the arguments are Int32,
-  // it makes sense to invoke this constructor directly.
-  HBoundsCheck(HValue* index, HValue* length)
-    : skip_check_(false),
-      base_(NULL), offset_(0), scale_(0),
-      allow_equality_(false) {
-    SetOperandAt(0, index);
-    SetOperandAt(1, length);
-    SetFlag(kFlexibleRepresentation);
-    SetFlag(kUseGVN);
-  }
-
-  bool IsDeletable() const override { return skip_check() && !FLAG_debug_code; }
-};
-
-
-class HBoundsCheckBaseIndexInformation final : public HTemplateInstruction<2> {
- public:
-  explicit HBoundsCheckBaseIndexInformation(HBoundsCheck* check) {
-    DecompositionResult decomposition;
-    if (check->index()->TryDecompose(&decomposition)) {
-      SetOperandAt(0, decomposition.base());
-      SetOperandAt(1, check);
-    } else {
-      UNREACHABLE();
-    }
-  }
-
-  HValue* base_index() const { return OperandAt(0); }
-  HBoundsCheck* bounds_check() { return HBoundsCheck::cast(OperandAt(1)); }
-
-  DECLARE_CONCRETE_INSTRUCTION(BoundsCheckBaseIndexInformation)
-
-  Representation RequiredInputRepresentation(int index) override {
-    return representation();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  int RedefinedOperandIndex() override { return 0; }
-  bool IsPurelyInformativeDefinition() override { return true; }
-};
-
-
-class HBitwiseBinaryOperation : public HBinaryOperation {
- public:
-  HBitwiseBinaryOperation(HValue* context, HValue* left, HValue* right,
-                          Strength strength, HType type = HType::TaggedNumber())
-      : HBinaryOperation(context, left, right, strength, type) {
-    SetFlag(kFlexibleRepresentation);
-    SetFlag(kTruncatingToInt32);
-    if (!is_strong(strength)) SetFlag(kAllowUndefinedAsNaN);
-    SetAllSideEffects();
-  }
-
-  void RepresentationChanged(Representation to) override {
-    if (to.IsTagged() &&
-        (left()->ToNumberCanBeObserved() || right()->ToNumberCanBeObserved())) {
-      SetAllSideEffects();
-      ClearFlag(kUseGVN);
-    } else {
-      ClearAllSideEffects();
-      SetFlag(kUseGVN);
-    }
-    if (to.IsTagged()) SetChangesFlag(kNewSpacePromotion);
-  }
-
-  virtual void UpdateRepresentation(Representation new_rep,
-                                    HInferRepresentationPhase* h_infer,
-                                    const char* reason) override {
-    // We only generate either int32 or generic tagged bitwise operations.
-    if (new_rep.IsDouble()) new_rep = Representation::Integer32();
-    HBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
-  }
-
-  Representation observed_input_representation(int index) override {
-    Representation r = HBinaryOperation::observed_input_representation(index);
-    if (r.IsDouble()) return Representation::Integer32();
-    return r;
-  }
-
-  virtual void initialize_output_representation(
-      Representation observed) override {
-    if (observed.IsDouble()) observed = Representation::Integer32();
-    HBinaryOperation::initialize_output_representation(observed);
-  }
-
-  DECLARE_ABSTRACT_INSTRUCTION(BitwiseBinaryOperation)
-
- private:
-  bool IsDeletable() const override { return true; }
-};
-
-
-class HMathFloorOfDiv final : public HBinaryOperation {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HMathFloorOfDiv,
-                                              HValue*,
-                                              HValue*);
-
-  DECLARE_CONCRETE_INSTRUCTION(MathFloorOfDiv)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  HMathFloorOfDiv(HValue* context, HValue* left, HValue* right)
-      : HBinaryOperation(context, left, right, Strength::WEAK) {
-    set_representation(Representation::Integer32());
-    SetFlag(kUseGVN);
-    SetFlag(kCanOverflow);
-    SetFlag(kCanBeDivByZero);
-    SetFlag(kLeftCanBeMinInt);
-    SetFlag(kLeftCanBeNegative);
-    SetFlag(kLeftCanBePositive);
-    SetFlag(kAllowUndefinedAsNaN);
-  }
-
-  Range* InferRange(Zone* zone) override;
-
-  bool IsDeletable() const override { return true; }
-};
-
-
-class HArithmeticBinaryOperation : public HBinaryOperation {
- public:
-  HArithmeticBinaryOperation(HValue* context, HValue* left, HValue* right,
-                             Strength strength)
-      : HBinaryOperation(context, left, right, strength,
-                         HType::TaggedNumber()) {
-    SetAllSideEffects();
-    SetFlag(kFlexibleRepresentation);
-    if (!is_strong(strength)) SetFlag(kAllowUndefinedAsNaN);
-  }
-
-  void RepresentationChanged(Representation to) override {
-    if (to.IsTagged() &&
-        (left()->ToNumberCanBeObserved() || right()->ToNumberCanBeObserved())) {
-      SetAllSideEffects();
-      ClearFlag(kUseGVN);
-    } else {
-      ClearAllSideEffects();
-      SetFlag(kUseGVN);
-    }
-    if (to.IsTagged()) SetChangesFlag(kNewSpacePromotion);
-  }
-
-  DECLARE_ABSTRACT_INSTRUCTION(ArithmeticBinaryOperation)
-
- private:
-  bool IsDeletable() const override { return true; }
-};
-
-
-class HCompareGeneric final : public HBinaryOperation {
- public:
-  static HCompareGeneric* New(Isolate* isolate, Zone* zone, HValue* context,
-                              HValue* left, HValue* right, Token::Value token,
-                              Strength strength = Strength::WEAK) {
-    return new (zone) HCompareGeneric(context, left, right, token, strength);
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return index == 0
-        ? Representation::Tagged()
-        : representation();
-  }
-
-  Token::Value token() const { return token_; }
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(CompareGeneric)
-
- private:
-  HCompareGeneric(HValue* context, HValue* left, HValue* right,
-                  Token::Value token, Strength strength)
-      : HBinaryOperation(context, left, right, strength, HType::Boolean()),
-        token_(token) {
-    DCHECK(Token::IsCompareOp(token));
-    set_representation(Representation::Tagged());
-    SetAllSideEffects();
-  }
-
-  Token::Value token_;
-};
-
-
-class HCompareNumericAndBranch : public HTemplateControlInstruction<2, 2> {
- public:
-  static HCompareNumericAndBranch* New(Isolate* isolate, Zone* zone,
-                                       HValue* context, HValue* left,
-                                       HValue* right, Token::Value token,
-                                       HBasicBlock* true_target = NULL,
-                                       HBasicBlock* false_target = NULL,
-                                       Strength strength = Strength::WEAK) {
-    return new (zone) HCompareNumericAndBranch(left, right, token, true_target,
-                                               false_target, strength);
-  }
-  static HCompareNumericAndBranch* New(Isolate* isolate, Zone* zone,
-                                       HValue* context, HValue* left,
-                                       HValue* right, Token::Value token,
-                                       Strength strength) {
-    return new (zone)
-        HCompareNumericAndBranch(left, right, token, NULL, NULL, strength);
-  }
-
-  HValue* left() const { return OperandAt(0); }
-  HValue* right() const { return OperandAt(1); }
-  Token::Value token() const { return token_; }
-
-  void set_observed_input_representation(Representation left,
-                                         Representation right) {
-      observed_input_representation_[0] = left;
-      observed_input_representation_[1] = right;
-  }
-
-  virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
-
-  Representation RequiredInputRepresentation(int index) override {
-    return representation();
-  }
-  Representation observed_input_representation(int index) override {
-    return observed_input_representation_[index];
-  }
-
-  bool KnownSuccessorBlock(HBasicBlock** block) override;
-
-  Strength strength() const { return strength_; }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  void SetOperandPositions(Zone* zone, SourcePosition left_pos,
-                           SourcePosition right_pos) {
-    set_operand_position(zone, 0, left_pos);
-    set_operand_position(zone, 1, right_pos);
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(CompareNumericAndBranch)
-
- private:
-  HCompareNumericAndBranch(HValue* left, HValue* right, Token::Value token,
-                           HBasicBlock* true_target, HBasicBlock* false_target,
-                           Strength strength)
-      : token_(token), strength_(strength) {
-    SetFlag(kFlexibleRepresentation);
-    DCHECK(Token::IsCompareOp(token));
-    SetOperandAt(0, left);
-    SetOperandAt(1, right);
-    SetSuccessorAt(0, true_target);
-    SetSuccessorAt(1, false_target);
-  }
-
-  Representation observed_input_representation_[2];
-  Token::Value token_;
-  Strength strength_;
-};
-
-
-class HCompareHoleAndBranch final : public HUnaryControlInstruction {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HCompareHoleAndBranch, HValue*);
-  DECLARE_INSTRUCTION_FACTORY_P3(HCompareHoleAndBranch, HValue*,
-                                 HBasicBlock*, HBasicBlock*);
-
-  virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
-
-  Representation RequiredInputRepresentation(int index) override {
-    return representation();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(CompareHoleAndBranch)
-
- private:
-  HCompareHoleAndBranch(HValue* value,
-                        HBasicBlock* true_target = NULL,
-                        HBasicBlock* false_target = NULL)
-      : HUnaryControlInstruction(value, true_target, false_target) {
-    SetFlag(kFlexibleRepresentation);
-    SetFlag(kAllowUndefinedAsNaN);
-  }
-};
-
-
-class HCompareMinusZeroAndBranch final : public HUnaryControlInstruction {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HCompareMinusZeroAndBranch, HValue*);
-
-  virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
-
-  Representation RequiredInputRepresentation(int index) override {
-    return representation();
-  }
-
-  bool KnownSuccessorBlock(HBasicBlock** block) override;
-
-  DECLARE_CONCRETE_INSTRUCTION(CompareMinusZeroAndBranch)
-
- private:
-  explicit HCompareMinusZeroAndBranch(HValue* value)
-      : HUnaryControlInstruction(value, NULL, NULL) {
-  }
-};
-
-
-class HCompareObjectEqAndBranch : public HTemplateControlInstruction<2, 2> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P2(HCompareObjectEqAndBranch, HValue*, HValue*);
-  DECLARE_INSTRUCTION_FACTORY_P4(HCompareObjectEqAndBranch, HValue*, HValue*,
-                                 HBasicBlock*, HBasicBlock*);
-
-  bool KnownSuccessorBlock(HBasicBlock** block) override;
-
-  static const int kNoKnownSuccessorIndex = -1;
-  int known_successor_index() const { return known_successor_index_; }
-  void set_known_successor_index(int known_successor_index) {
-    known_successor_index_ = known_successor_index;
-  }
-
-  HValue* left() const { return OperandAt(0); }
-  HValue* right() const { return OperandAt(1); }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  Representation observed_input_representation(int index) override {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(CompareObjectEqAndBranch)
-
- private:
-  HCompareObjectEqAndBranch(HValue* left,
-                            HValue* right,
-                            HBasicBlock* true_target = NULL,
-                            HBasicBlock* false_target = NULL)
-      : known_successor_index_(kNoKnownSuccessorIndex) {
-    SetOperandAt(0, left);
-    SetOperandAt(1, right);
-    SetSuccessorAt(0, true_target);
-    SetSuccessorAt(1, false_target);
-  }
-
-  int known_successor_index_;
-};
-
-
-class HIsStringAndBranch final : public HUnaryControlInstruction {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HIsStringAndBranch, HValue*);
-  DECLARE_INSTRUCTION_FACTORY_P3(HIsStringAndBranch, HValue*,
-                                 HBasicBlock*, HBasicBlock*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  bool KnownSuccessorBlock(HBasicBlock** block) override;
-
-  static const int kNoKnownSuccessorIndex = -1;
-  int known_successor_index() const { return known_successor_index_; }
-  void set_known_successor_index(int known_successor_index) {
-    known_successor_index_ = known_successor_index;
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(IsStringAndBranch)
-
- protected:
-  int RedefinedOperandIndex() override { return 0; }
-
- private:
-  HIsStringAndBranch(HValue* value, HBasicBlock* true_target = NULL,
-                     HBasicBlock* false_target = NULL)
-      : HUnaryControlInstruction(value, true_target, false_target),
-        known_successor_index_(kNoKnownSuccessorIndex) {
-    set_representation(Representation::Tagged());
-  }
-
-  int known_successor_index_;
-};
-
-
-class HIsSmiAndBranch final : public HUnaryControlInstruction {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HIsSmiAndBranch, HValue*);
-  DECLARE_INSTRUCTION_FACTORY_P3(HIsSmiAndBranch, HValue*,
-                                 HBasicBlock*, HBasicBlock*);
-
-  DECLARE_CONCRETE_INSTRUCTION(IsSmiAndBranch)
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-  int RedefinedOperandIndex() override { return 0; }
-
- private:
-  HIsSmiAndBranch(HValue* value,
-                  HBasicBlock* true_target = NULL,
-                  HBasicBlock* false_target = NULL)
-      : HUnaryControlInstruction(value, true_target, false_target) {
-    set_representation(Representation::Tagged());
-  }
-};
-
-
-class HIsUndetectableAndBranch final : public HUnaryControlInstruction {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HIsUndetectableAndBranch, HValue*);
-  DECLARE_INSTRUCTION_FACTORY_P3(HIsUndetectableAndBranch, HValue*,
-                                 HBasicBlock*, HBasicBlock*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  bool KnownSuccessorBlock(HBasicBlock** block) override;
-
-  DECLARE_CONCRETE_INSTRUCTION(IsUndetectableAndBranch)
-
- private:
-  HIsUndetectableAndBranch(HValue* value,
-                           HBasicBlock* true_target = NULL,
-                           HBasicBlock* false_target = NULL)
-      : HUnaryControlInstruction(value, true_target, false_target) {}
-};
-
-
-class HStringCompareAndBranch final : public HTemplateControlInstruction<2, 3> {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HStringCompareAndBranch,
-                                              HValue*,
-                                              HValue*,
-                                              Token::Value);
-
-  HValue* context() const { return OperandAt(0); }
-  HValue* left() const { return OperandAt(1); }
-  HValue* right() const { return OperandAt(2); }
-  Token::Value token() const { return token_; }
-
-  std::ostream& PrintDataTo(std::ostream& os) const final;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) final {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(StringCompareAndBranch)
-
- private:
-  HStringCompareAndBranch(HValue* context, HValue* left, HValue* right,
-                          Token::Value token)
-      : token_(token) {
-    DCHECK(Token::IsCompareOp(token));
-    SetOperandAt(0, context);
-    SetOperandAt(1, left);
-    SetOperandAt(2, right);
-    set_representation(Representation::Tagged());
-    SetChangesFlag(kNewSpacePromotion);
-    SetDependsOnFlag(kStringChars);
-    SetDependsOnFlag(kStringLengths);
-  }
-
-  Token::Value const token_;
-};
-
-
-class HIsConstructCallAndBranch : public HTemplateControlInstruction<2, 0> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P0(HIsConstructCallAndBranch);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(IsConstructCallAndBranch)
- private:
-  HIsConstructCallAndBranch() {}
-};
-
-
-class HHasInstanceTypeAndBranch final : public HUnaryControlInstruction {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P2(
-      HHasInstanceTypeAndBranch, HValue*, InstanceType);
-  DECLARE_INSTRUCTION_FACTORY_P3(
-      HHasInstanceTypeAndBranch, HValue*, InstanceType, InstanceType);
-
-  InstanceType from() { return from_; }
-  InstanceType to() { return to_; }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  bool KnownSuccessorBlock(HBasicBlock** block) override;
-
-  DECLARE_CONCRETE_INSTRUCTION(HasInstanceTypeAndBranch)
-
- private:
-  HHasInstanceTypeAndBranch(HValue* value, InstanceType type)
-      : HUnaryControlInstruction(value, NULL, NULL), from_(type), to_(type) { }
-  HHasInstanceTypeAndBranch(HValue* value, InstanceType from, InstanceType to)
-      : HUnaryControlInstruction(value, NULL, NULL), from_(from), to_(to) {
-    DCHECK(to == LAST_TYPE);  // Others not implemented yet in backend.
-  }
-
-  InstanceType from_;
-  InstanceType to_;  // Inclusive range, not all combinations work.
-};
-
-
-class HHasCachedArrayIndexAndBranch final : public HUnaryControlInstruction {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HHasCachedArrayIndexAndBranch, HValue*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(HasCachedArrayIndexAndBranch)
- private:
-  explicit HHasCachedArrayIndexAndBranch(HValue* value)
-      : HUnaryControlInstruction(value, NULL, NULL) { }
-};
-
-
-class HGetCachedArrayIndex final : public HUnaryOperation {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HGetCachedArrayIndex, HValue*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  explicit HGetCachedArrayIndex(HValue* value) : HUnaryOperation(value) {
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-  }
-
-  bool IsDeletable() const override { return true; }
-};
-
-
-class HClassOfTestAndBranch final : public HUnaryControlInstruction {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P2(HClassOfTestAndBranch, HValue*,
-                                 Handle<String>);
-
-  DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch)
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Handle<String> class_name() const { return class_name_; }
-
- private:
-  HClassOfTestAndBranch(HValue* value, Handle<String> class_name)
-      : HUnaryControlInstruction(value, NULL, NULL),
-        class_name_(class_name) { }
-
-  Handle<String> class_name_;
-};
-
-
-class HTypeofIsAndBranch final : public HUnaryControlInstruction {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P2(HTypeofIsAndBranch, HValue*, Handle<String>);
-
-  Handle<String> type_literal() const { return type_literal_.handle(); }
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch)
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  bool KnownSuccessorBlock(HBasicBlock** block) override;
-
-  void FinalizeUniqueness() override {
-    type_literal_ = Unique<String>(type_literal_.handle());
-  }
-
- private:
-  HTypeofIsAndBranch(HValue* value, Handle<String> type_literal)
-      : HUnaryControlInstruction(value, NULL, NULL),
-        type_literal_(Unique<String>::CreateUninitialized(type_literal)) { }
-
-  Unique<String> type_literal_;
-};
-
-
-class HInstanceOf final : public HBinaryOperation {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HInstanceOf, HValue*, HValue*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(InstanceOf)
-
- private:
-  HInstanceOf(HValue* context, HValue* left, HValue* right)
-      : HBinaryOperation(context, left, right, Strength::WEAK,
-                         HType::Boolean()) {
-    set_representation(Representation::Tagged());
-    SetAllSideEffects();
-  }
-};
-
-
-class HHasInPrototypeChainAndBranch final
-    : public HTemplateControlInstruction<2, 2> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P2(HHasInPrototypeChainAndBranch, HValue*,
-                                 HValue*);
-
-  HValue* object() const { return OperandAt(0); }
-  HValue* prototype() const { return OperandAt(1); }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  bool ObjectNeedsSmiCheck() const {
-    return !object()->type().IsHeapObject() &&
-           !object()->representation().IsHeapObject();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(HasInPrototypeChainAndBranch)
-
- private:
-  HHasInPrototypeChainAndBranch(HValue* object, HValue* prototype) {
-    SetOperandAt(0, object);
-    SetOperandAt(1, prototype);
-    SetDependsOnFlag(kCalls);
-  }
-};
-
-
-class HPower final : public HTemplateInstruction<2> {
- public:
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           HValue* left, HValue* right);
-
-  HValue* left() { return OperandAt(0); }
-  HValue* right() const { return OperandAt(1); }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return index == 0
-      ? Representation::Double()
-      : Representation::None();
-  }
-  Representation observed_input_representation(int index) override {
-    return RequiredInputRepresentation(index);
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(Power)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  HPower(HValue* left, HValue* right) {
-    SetOperandAt(0, left);
-    SetOperandAt(1, right);
-    set_representation(Representation::Double());
-    SetFlag(kUseGVN);
-    SetChangesFlag(kNewSpacePromotion);
-  }
-
-  bool IsDeletable() const override {
-    return !right()->representation().IsTagged();
-  }
-};
-
-
-enum ExternalAddType {
-  AddOfExternalAndTagged,
-  AddOfExternalAndInt32,
-  NoExternalAdd
-};
-
-
-class HAdd final : public HArithmeticBinaryOperation {
- public:
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           HValue* left, HValue* right,
-                           Strength strength = Strength::WEAK);
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           HValue* left, HValue* right, Strength strength,
-                           ExternalAddType external_add_type);
-
-  // Add is only commutative if two integer values are added and not if two
-  // tagged values are added (because it might be a String concatenation).
-  // We also do not commute (pointer + offset).
-  bool IsCommutative() const override {
-    return !representation().IsTagged() && !representation().IsExternal();
-  }
-
-  HValue* Canonicalize() override;
-
-  bool TryDecompose(DecompositionResult* decomposition) override {
-    if (left()->IsInteger32Constant()) {
-      decomposition->Apply(right(), left()->GetInteger32Constant());
-      return true;
-    } else if (right()->IsInteger32Constant()) {
-      decomposition->Apply(left(), right()->GetInteger32Constant());
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-  void RepresentationChanged(Representation to) override {
-    if (to.IsTagged() &&
-        (left()->ToNumberCanBeObserved() || right()->ToNumberCanBeObserved() ||
-         left()->ToStringCanBeObserved() || right()->ToStringCanBeObserved())) {
-      SetAllSideEffects();
-      ClearFlag(kUseGVN);
-    } else {
-      ClearAllSideEffects();
-      SetFlag(kUseGVN);
-    }
-    if (to.IsTagged()) {
-      SetChangesFlag(kNewSpacePromotion);
-      ClearFlag(kAllowUndefinedAsNaN);
-    }
-  }
-
-  Representation RepresentationFromInputs() override;
-
-  Representation RequiredInputRepresentation(int index) override;
-
-  bool IsConsistentExternalRepresentation() {
-    return left()->representation().IsExternal() &&
-           ((external_add_type_ == AddOfExternalAndInt32 &&
-             right()->representation().IsInteger32()) ||
-            (external_add_type_ == AddOfExternalAndTagged &&
-             right()->representation().IsTagged()));
-  }
-
-  ExternalAddType external_add_type() const { return external_add_type_; }
-
-  DECLARE_CONCRETE_INSTRUCTION(Add)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
-  Range* InferRange(Zone* zone) override;
-
- private:
-  HAdd(HValue* context, HValue* left, HValue* right, Strength strength,
-       ExternalAddType external_add_type = NoExternalAdd)
-      : HArithmeticBinaryOperation(context, left, right, strength),
-        external_add_type_(external_add_type) {
-    SetFlag(kCanOverflow);
-    switch (external_add_type_) {
-      case AddOfExternalAndTagged:
-        DCHECK(left->representation().IsExternal());
-        DCHECK(right->representation().IsTagged());
-        SetDependsOnFlag(kNewSpacePromotion);
-        ClearFlag(HValue::kCanOverflow);
-        SetFlag(kHasNoObservableSideEffects);
-        break;
-
-      case NoExternalAdd:
-        // This is a bit of a hack: The call to this constructor is generated
-        // by a macro that also supports sub and mul, so it doesn't pass in
-        // a value for external_add_type but uses the default.
-        if (left->representation().IsExternal()) {
-          external_add_type_ = AddOfExternalAndInt32;
-        }
-        break;
-
-      case AddOfExternalAndInt32:
-        // See comment above.
-        UNREACHABLE();
-        break;
-    }
-  }
-
-  ExternalAddType external_add_type_;
-};
-
-
-class HSub final : public HArithmeticBinaryOperation {
- public:
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           HValue* left, HValue* right,
-                           Strength strength = Strength::WEAK);
-
-  HValue* Canonicalize() override;
-
-  bool TryDecompose(DecompositionResult* decomposition) override {
-    if (right()->IsInteger32Constant()) {
-      decomposition->Apply(left(), -right()->GetInteger32Constant());
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(Sub)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
-  Range* InferRange(Zone* zone) override;
-
- private:
-  HSub(HValue* context, HValue* left, HValue* right, Strength strength)
-      : HArithmeticBinaryOperation(context, left, right, strength) {
-    SetFlag(kCanOverflow);
-  }
-};
-
-
-class HMul final : public HArithmeticBinaryOperation {
- public:
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           HValue* left, HValue* right,
-                           Strength strength = Strength::WEAK);
-
-  static HInstruction* NewImul(Isolate* isolate, Zone* zone, HValue* context,
-                               HValue* left, HValue* right,
-                               Strength strength = Strength::WEAK) {
-    HInstruction* instr =
-        HMul::New(isolate, zone, context, left, right, strength);
-    if (!instr->IsMul()) return instr;
-    HMul* mul = HMul::cast(instr);
-    // TODO(mstarzinger): Prevent bailout on minus zero for imul.
-    mul->AssumeRepresentation(Representation::Integer32());
-    mul->ClearFlag(HValue::kCanOverflow);
-    return mul;
-  }
-
-  HValue* Canonicalize() override;
-
-  // Only commutative if it is certain that not two objects are multiplicated.
-  bool IsCommutative() const override { return !representation().IsTagged(); }
-
-  virtual void UpdateRepresentation(Representation new_rep,
-                                    HInferRepresentationPhase* h_infer,
-                                    const char* reason) override {
-    HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
-  }
-
-  bool MulMinusOne();
-
-  DECLARE_CONCRETE_INSTRUCTION(Mul)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
-  Range* InferRange(Zone* zone) override;
-
- private:
-  HMul(HValue* context, HValue* left, HValue* right, Strength strength)
-      : HArithmeticBinaryOperation(context, left, right, strength) {
-    SetFlag(kCanOverflow);
-  }
-};
-
-
-class HMod final : public HArithmeticBinaryOperation {
- public:
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           HValue* left, HValue* right,
-                           Strength strength = Strength::WEAK);
-
-  HValue* Canonicalize() override;
-
-  virtual void UpdateRepresentation(Representation new_rep,
-                                    HInferRepresentationPhase* h_infer,
-                                    const char* reason) override {
-    if (new_rep.IsSmi()) new_rep = Representation::Integer32();
-    HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(Mod)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
-  Range* InferRange(Zone* zone) override;
-
- private:
-  HMod(HValue* context, HValue* left, HValue* right, Strength strength)
-      : HArithmeticBinaryOperation(context, left, right, strength) {
-    SetFlag(kCanBeDivByZero);
-    SetFlag(kCanOverflow);
-    SetFlag(kLeftCanBeNegative);
-  }
-};
-
-
-class HDiv final : public HArithmeticBinaryOperation {
- public:
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           HValue* left, HValue* right,
-                           Strength strength = Strength::WEAK);
-
-  HValue* Canonicalize() override;
-
-  virtual void UpdateRepresentation(Representation new_rep,
-                                    HInferRepresentationPhase* h_infer,
-                                    const char* reason) override {
-    if (new_rep.IsSmi()) new_rep = Representation::Integer32();
-    HArithmeticBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(Div)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
-  Range* InferRange(Zone* zone) override;
-
- private:
-  HDiv(HValue* context, HValue* left, HValue* right, Strength strength)
-      : HArithmeticBinaryOperation(context, left, right, strength) {
-    SetFlag(kCanBeDivByZero);
-    SetFlag(kCanOverflow);
-  }
-};
-
-
-class HMathMinMax final : public HArithmeticBinaryOperation {
- public:
-  enum Operation { kMathMin, kMathMax };
-
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           HValue* left, HValue* right, Operation op);
-
-  Representation observed_input_representation(int index) override {
-    return RequiredInputRepresentation(index);
-  }
-
-  virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
-
-  Representation RepresentationFromInputs() override {
-    Representation left_rep = left()->representation();
-    Representation right_rep = right()->representation();
-    Representation result = Representation::Smi();
-    result = result.generalize(left_rep);
-    result = result.generalize(right_rep);
-    if (result.IsTagged()) return Representation::Double();
-    return result;
-  }
-
-  bool IsCommutative() const override { return true; }
-
-  Operation operation() { return operation_; }
-
-  DECLARE_CONCRETE_INSTRUCTION(MathMinMax)
-
- protected:
-  bool DataEquals(HValue* other) override {
-    return other->IsMathMinMax() &&
-        HMathMinMax::cast(other)->operation_ == operation_;
-  }
-
-  Range* InferRange(Zone* zone) override;
-
- private:
-  HMathMinMax(HValue* context, HValue* left, HValue* right, Operation op)
-      : HArithmeticBinaryOperation(context, left, right, Strength::WEAK),
-        operation_(op) {}
-
-  Operation operation_;
-};
-
-
-class HBitwise final : public HBitwiseBinaryOperation {
- public:
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           Token::Value op, HValue* left, HValue* right,
-                           Strength strength = Strength::WEAK);
-
-  Token::Value op() const { return op_; }
-
-  bool IsCommutative() const override { return true; }
-
-  HValue* Canonicalize() override;
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(Bitwise)
-
- protected:
-  bool DataEquals(HValue* other) override {
-    return op() == HBitwise::cast(other)->op();
-  }
-
-  Range* InferRange(Zone* zone) override;
-
- private:
-  HBitwise(HValue* context, Token::Value op, HValue* left, HValue* right,
-           Strength strength)
-      : HBitwiseBinaryOperation(context, left, right, strength), op_(op) {
-    DCHECK(op == Token::BIT_AND || op == Token::BIT_OR || op == Token::BIT_XOR);
-    // BIT_AND with a smi-range positive value will always unset the
-    // entire sign-extension of the smi-sign.
-    if (op == Token::BIT_AND &&
-        ((left->IsConstant() &&
-          left->representation().IsSmi() &&
-          HConstant::cast(left)->Integer32Value() >= 0) ||
-         (right->IsConstant() &&
-          right->representation().IsSmi() &&
-          HConstant::cast(right)->Integer32Value() >= 0))) {
-      SetFlag(kTruncatingToSmi);
-      SetFlag(kTruncatingToInt32);
-    // BIT_OR with a smi-range negative value will always set the entire
-    // sign-extension of the smi-sign.
-    } else if (op == Token::BIT_OR &&
-        ((left->IsConstant() &&
-          left->representation().IsSmi() &&
-          HConstant::cast(left)->Integer32Value() < 0) ||
-         (right->IsConstant() &&
-          right->representation().IsSmi() &&
-          HConstant::cast(right)->Integer32Value() < 0))) {
-      SetFlag(kTruncatingToSmi);
-      SetFlag(kTruncatingToInt32);
-    }
-  }
-
-  Token::Value op_;
-};
-
-
-class HShl final : public HBitwiseBinaryOperation {
- public:
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           HValue* left, HValue* right,
-                           Strength strength = Strength::WEAK);
-
-  Range* InferRange(Zone* zone) override;
-
-  virtual void UpdateRepresentation(Representation new_rep,
-                                    HInferRepresentationPhase* h_infer,
-                                    const char* reason) override {
-    if (new_rep.IsSmi() &&
-        !(right()->IsInteger32Constant() &&
-          right()->GetInteger32Constant() >= 0)) {
-      new_rep = Representation::Integer32();
-    }
-    HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(Shl)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  HShl(HValue* context, HValue* left, HValue* right, Strength strength)
-      : HBitwiseBinaryOperation(context, left, right, strength) {}
-};
-
-
-class HShr final : public HBitwiseBinaryOperation {
- public:
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           HValue* left, HValue* right,
-                           Strength strength = Strength::WEAK);
-
-  bool TryDecompose(DecompositionResult* decomposition) override {
-    if (right()->IsInteger32Constant()) {
-      if (decomposition->Apply(left(), 0, right()->GetInteger32Constant())) {
-        // This is intended to look for HAdd and HSub, to handle compounds
-        // like ((base + offset) >> scale) with one single decomposition.
-        left()->TryDecompose(decomposition);
-        return true;
-      }
-    }
-    return false;
-  }
-
-  Range* InferRange(Zone* zone) override;
-
-  virtual void UpdateRepresentation(Representation new_rep,
-                                    HInferRepresentationPhase* h_infer,
-                                    const char* reason) override {
-    if (new_rep.IsSmi()) new_rep = Representation::Integer32();
-    HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(Shr)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  HShr(HValue* context, HValue* left, HValue* right, Strength strength)
-      : HBitwiseBinaryOperation(context, left, right, strength) {}
-};
-
-
-class HSar final : public HBitwiseBinaryOperation {
- public:
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           HValue* left, HValue* right,
-                           Strength strength = Strength::WEAK);
-
-  bool TryDecompose(DecompositionResult* decomposition) override {
-    if (right()->IsInteger32Constant()) {
-      if (decomposition->Apply(left(), 0, right()->GetInteger32Constant())) {
-        // This is intended to look for HAdd and HSub, to handle compounds
-        // like ((base + offset) >> scale) with one single decomposition.
-        left()->TryDecompose(decomposition);
-        return true;
-      }
-    }
-    return false;
-  }
-
-  Range* InferRange(Zone* zone) override;
-
-  virtual void UpdateRepresentation(Representation new_rep,
-                                    HInferRepresentationPhase* h_infer,
-                                    const char* reason) override {
-    if (new_rep.IsSmi()) new_rep = Representation::Integer32();
-    HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(Sar)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  HSar(HValue* context, HValue* left, HValue* right, Strength strength)
-      : HBitwiseBinaryOperation(context, left, right, strength) {}
-};
-
-
-class HRor final : public HBitwiseBinaryOperation {
- public:
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           HValue* left, HValue* right,
-                           Strength strength = Strength::WEAK) {
-    return new (zone) HRor(context, left, right, strength);
-  }
-
-  virtual void UpdateRepresentation(Representation new_rep,
-                                    HInferRepresentationPhase* h_infer,
-                                    const char* reason) override {
-    if (new_rep.IsSmi()) new_rep = Representation::Integer32();
-    HBitwiseBinaryOperation::UpdateRepresentation(new_rep, h_infer, reason);
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(Ror)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  HRor(HValue* context, HValue* left, HValue* right, Strength strength)
-      : HBitwiseBinaryOperation(context, left, right, strength) {
-    ChangeRepresentation(Representation::Integer32());
-  }
-};
-
-
-class HOsrEntry final : public HTemplateInstruction<0> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HOsrEntry, BailoutId);
-
-  BailoutId ast_id() const { return ast_id_; }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(OsrEntry)
-
- private:
-  explicit HOsrEntry(BailoutId ast_id) : ast_id_(ast_id) {
-    SetChangesFlag(kOsrEntries);
-    SetChangesFlag(kNewSpacePromotion);
-  }
-
-  BailoutId ast_id_;
-};
-
-
-class HParameter final : public HTemplateInstruction<0> {
- public:
-  enum ParameterKind {
-    STACK_PARAMETER,
-    REGISTER_PARAMETER
-  };
-
-  DECLARE_INSTRUCTION_FACTORY_P1(HParameter, unsigned);
-  DECLARE_INSTRUCTION_FACTORY_P2(HParameter, unsigned, ParameterKind);
-  DECLARE_INSTRUCTION_FACTORY_P3(HParameter, unsigned, ParameterKind,
-                                 Representation);
-
-  unsigned index() const { return index_; }
-  ParameterKind kind() const { return kind_; }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  Representation KnownOptimalRepresentation() override {
-    // If a parameter is an input to a phi, that phi should not
-    // choose any more optimistic representation than Tagged.
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(Parameter)
-
- private:
-  explicit HParameter(unsigned index,
-                      ParameterKind kind = STACK_PARAMETER)
-      : index_(index),
-        kind_(kind) {
-    set_representation(Representation::Tagged());
-  }
-
-  explicit HParameter(unsigned index,
-                      ParameterKind kind,
-                      Representation r)
-      : index_(index),
-        kind_(kind) {
-    set_representation(r);
-  }
-
-  unsigned index_;
-  ParameterKind kind_;
-};
-
-
-class HCallStub final : public HUnaryCall {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HCallStub, CodeStub::Major, int);
-  CodeStub::Major major_key() { return major_key_; }
-
-  HValue* context() { return value(); }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(CallStub)
-
- private:
-  HCallStub(HValue* context, CodeStub::Major major_key, int argument_count)
-      : HUnaryCall(context, argument_count),
-        major_key_(major_key) {
-  }
-
-  CodeStub::Major major_key_;
-};
-
-
-class HUnknownOSRValue final : public HTemplateInstruction<0> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P2(HUnknownOSRValue, HEnvironment*, int);
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::None();
-  }
-
-  void set_incoming_value(HPhi* value) { incoming_value_ = value; }
-  HPhi* incoming_value() { return incoming_value_; }
-  HEnvironment *environment() { return environment_; }
-  int index() { return index_; }
-
-  Representation KnownOptimalRepresentation() override {
-    if (incoming_value_ == NULL) return Representation::None();
-    return incoming_value_->KnownOptimalRepresentation();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(UnknownOSRValue)
-
- private:
-  HUnknownOSRValue(HEnvironment* environment, int index)
-      : environment_(environment),
-        index_(index),
-        incoming_value_(NULL) {
-    set_representation(Representation::Tagged());
-  }
-
-  HEnvironment* environment_;
-  int index_;
-  HPhi* incoming_value_;
-};
-
-
-class HLoadGlobalGeneric final : public HTemplateInstruction<2> {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HLoadGlobalGeneric, HValue*,
-                                              Handle<String>, TypeofMode);
-
-  HValue* context() { return OperandAt(0); }
-  HValue* global_object() { return OperandAt(1); }
-  Handle<String> name() const { return name_; }
-  TypeofMode typeof_mode() const { return typeof_mode_; }
-  FeedbackVectorSlot slot() const { return slot_; }
-  Handle<TypeFeedbackVector> feedback_vector() const {
-    return feedback_vector_;
-  }
-  bool HasVectorAndSlot() const { return true; }
-  void SetVectorAndSlot(Handle<TypeFeedbackVector> vector,
-                        FeedbackVectorSlot slot) {
-    feedback_vector_ = vector;
-    slot_ = slot;
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(LoadGlobalGeneric)
-
- private:
-  HLoadGlobalGeneric(HValue* context, HValue* global_object,
-                     Handle<String> name, TypeofMode typeof_mode)
-      : name_(name), typeof_mode_(typeof_mode) {
-    SetOperandAt(0, context);
-    SetOperandAt(1, global_object);
-    set_representation(Representation::Tagged());
-    SetAllSideEffects();
-  }
-
-  Handle<String> name_;
-  TypeofMode typeof_mode_;
-  Handle<TypeFeedbackVector> feedback_vector_;
-  FeedbackVectorSlot slot_;
-};
-
-
-class HLoadGlobalViaContext final : public HTemplateInstruction<1> {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HLoadGlobalViaContext, int, int);
-
-  HValue* context() { return OperandAt(0); }
-  int depth() const { return depth_; }
-  int slot_index() const { return slot_index_; }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(LoadGlobalViaContext)
-
- private:
-  HLoadGlobalViaContext(HValue* context, int depth, int slot_index)
-      : depth_(depth), slot_index_(slot_index) {
-    SetOperandAt(0, context);
-    set_representation(Representation::Tagged());
-    SetAllSideEffects();
-  }
-
-  int const depth_;
-  int const slot_index_;
-};
-
-
-class HAllocate final : public HTemplateInstruction<2> {
- public:
-  static bool CompatibleInstanceTypes(InstanceType type1,
-                                      InstanceType type2) {
-    return ComputeFlags(TENURED, type1) == ComputeFlags(TENURED, type2) &&
-        ComputeFlags(NOT_TENURED, type1) == ComputeFlags(NOT_TENURED, type2);
-  }
-
-  static HAllocate* New(
-      Isolate* isolate, Zone* zone, HValue* context, HValue* size, HType type,
-      PretenureFlag pretenure_flag, InstanceType instance_type,
-      Handle<AllocationSite> allocation_site = Handle<AllocationSite>::null()) {
-    return new(zone) HAllocate(context, size, type, pretenure_flag,
-        instance_type, allocation_site);
-  }
-
-  // Maximum instance size for which allocations will be inlined.
-  static const int kMaxInlineSize = 64 * kPointerSize;
-
-  HValue* context() const { return OperandAt(0); }
-  HValue* size() const { return OperandAt(1); }
-
-  bool has_size_upper_bound() { return size_upper_bound_ != NULL; }
-  HConstant* size_upper_bound() { return size_upper_bound_; }
-  void set_size_upper_bound(HConstant* value) {
-    DCHECK(size_upper_bound_ == NULL);
-    size_upper_bound_ = value;
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    if (index == 0) {
-      return Representation::Tagged();
-    } else {
-      return Representation::Integer32();
-    }
-  }
-
-  Handle<Map> GetMonomorphicJSObjectMap() override {
-    return known_initial_map_;
-  }
-
-  void set_known_initial_map(Handle<Map> known_initial_map) {
-    known_initial_map_ = known_initial_map;
-  }
-
-  bool IsNewSpaceAllocation() const {
-    return (flags_ & ALLOCATE_IN_NEW_SPACE) != 0;
-  }
-
-  bool IsOldSpaceAllocation() const {
-    return (flags_ & ALLOCATE_IN_OLD_SPACE) != 0;
-  }
-
-  bool MustAllocateDoubleAligned() const {
-    return (flags_ & ALLOCATE_DOUBLE_ALIGNED) != 0;
-  }
-
-  bool MustPrefillWithFiller() const {
-    return (flags_ & PREFILL_WITH_FILLER) != 0;
-  }
-
-  void MakePrefillWithFiller() {
-    flags_ = static_cast<HAllocate::Flags>(flags_ | PREFILL_WITH_FILLER);
-  }
-
-  bool MustClearNextMapWord() const {
-    return (flags_ & CLEAR_NEXT_MAP_WORD) != 0;
-  }
-
-  void MakeDoubleAligned() {
-    flags_ = static_cast<HAllocate::Flags>(flags_ | ALLOCATE_DOUBLE_ALIGNED);
-  }
-
-  virtual bool HandleSideEffectDominator(GVNFlag side_effect,
-                                         HValue* dominator) override;
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(Allocate)
-
- private:
-  enum Flags {
-    ALLOCATE_IN_NEW_SPACE = 1 << 0,
-    ALLOCATE_IN_OLD_SPACE = 1 << 2,
-    ALLOCATE_DOUBLE_ALIGNED = 1 << 3,
-    PREFILL_WITH_FILLER = 1 << 4,
-    CLEAR_NEXT_MAP_WORD = 1 << 5
-  };
-
-  HAllocate(HValue* context,
-            HValue* size,
-            HType type,
-            PretenureFlag pretenure_flag,
-            InstanceType instance_type,
-            Handle<AllocationSite> allocation_site =
-                Handle<AllocationSite>::null())
-      : HTemplateInstruction<2>(type),
-        flags_(ComputeFlags(pretenure_flag, instance_type)),
-        dominating_allocate_(NULL),
-        filler_free_space_size_(NULL),
-        size_upper_bound_(NULL) {
-    SetOperandAt(0, context);
-    UpdateSize(size);
-    set_representation(Representation::Tagged());
-    SetFlag(kTrackSideEffectDominators);
-    SetChangesFlag(kNewSpacePromotion);
-    SetDependsOnFlag(kNewSpacePromotion);
-
-    if (FLAG_trace_pretenuring) {
-      PrintF("HAllocate with AllocationSite %p %s\n",
-             allocation_site.is_null()
-                 ? static_cast<void*>(NULL)
-                 : static_cast<void*>(*allocation_site),
-             pretenure_flag == TENURED ? "tenured" : "not tenured");
-    }
-  }
-
-  static Flags ComputeFlags(PretenureFlag pretenure_flag,
-                            InstanceType instance_type) {
-    Flags flags = pretenure_flag == TENURED ? ALLOCATE_IN_OLD_SPACE
-                                            : ALLOCATE_IN_NEW_SPACE;
-    if (instance_type == FIXED_DOUBLE_ARRAY_TYPE) {
-      flags = static_cast<Flags>(flags | ALLOCATE_DOUBLE_ALIGNED);
-    }
-    // We have to fill the allocated object with one word fillers if we do
-    // not use allocation folding since some allocations may depend on each
-    // other, i.e., have a pointer to each other. A GC in between these
-    // allocations may leave such objects behind in a not completely initialized
-    // state.
-    if (!FLAG_use_gvn || !FLAG_use_allocation_folding) {
-      flags = static_cast<Flags>(flags | PREFILL_WITH_FILLER);
-    }
-    if (pretenure_flag == NOT_TENURED &&
-        AllocationSite::CanTrack(instance_type)) {
-      flags = static_cast<Flags>(flags | CLEAR_NEXT_MAP_WORD);
-    }
-    return flags;
-  }
-
-  void UpdateClearNextMapWord(bool clear_next_map_word) {
-    flags_ = static_cast<Flags>(clear_next_map_word
-                                ? flags_ | CLEAR_NEXT_MAP_WORD
-                                : flags_ & ~CLEAR_NEXT_MAP_WORD);
-  }
-
-  void UpdateSize(HValue* size) {
-    SetOperandAt(1, size);
-    if (size->IsInteger32Constant()) {
-      size_upper_bound_ = HConstant::cast(size);
-    } else {
-      size_upper_bound_ = NULL;
-    }
-  }
-
-  HAllocate* GetFoldableDominator(HAllocate* dominator);
-
-  void UpdateFreeSpaceFiller(int32_t filler_size);
-
-  void CreateFreeSpaceFiller(int32_t filler_size);
-
-  bool IsFoldable(HAllocate* allocate) {
-    return (IsNewSpaceAllocation() && allocate->IsNewSpaceAllocation()) ||
-           (IsOldSpaceAllocation() && allocate->IsOldSpaceAllocation());
-  }
-
-  void ClearNextMapWord(int offset);
-
-  Flags flags_;
-  Handle<Map> known_initial_map_;
-  HAllocate* dominating_allocate_;
-  HStoreNamedField* filler_free_space_size_;
-  HConstant* size_upper_bound_;
-};
-
-
-class HStoreCodeEntry final : public HTemplateInstruction<2> {
- public:
-  static HStoreCodeEntry* New(Isolate* isolate, Zone* zone, HValue* context,
-                              HValue* function, HValue* code) {
-    return new(zone) HStoreCodeEntry(function, code);
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  HValue* function() { return OperandAt(0); }
-  HValue* code_object() { return OperandAt(1); }
-
-  DECLARE_CONCRETE_INSTRUCTION(StoreCodeEntry)
-
- private:
-  HStoreCodeEntry(HValue* function, HValue* code) {
-    SetOperandAt(0, function);
-    SetOperandAt(1, code);
-  }
-};
-
-
-class HInnerAllocatedObject final : public HTemplateInstruction<2> {
- public:
-  static HInnerAllocatedObject* New(Isolate* isolate, Zone* zone,
-                                    HValue* context, HValue* value,
-                                    HValue* offset, HType type) {
-    return new(zone) HInnerAllocatedObject(value, offset, type);
-  }
-
-  HValue* base_object() const { return OperandAt(0); }
-  HValue* offset() const { return OperandAt(1); }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return index == 0 ? Representation::Tagged() : Representation::Integer32();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(InnerAllocatedObject)
-
- private:
-  HInnerAllocatedObject(HValue* value,
-                        HValue* offset,
-                        HType type) : HTemplateInstruction<2>(type) {
-    DCHECK(value->IsAllocate());
-    DCHECK(type.IsHeapObject());
-    SetOperandAt(0, value);
-    SetOperandAt(1, offset);
-    set_representation(Representation::Tagged());
-  }
-};
-
-
-inline bool StoringValueNeedsWriteBarrier(HValue* value) {
-  return !value->type().IsSmi()
-      && !value->type().IsNull()
-      && !value->type().IsBoolean()
-      && !value->type().IsUndefined()
-      && !(value->IsConstant() && HConstant::cast(value)->ImmortalImmovable());
-}
-
-
-inline bool ReceiverObjectNeedsWriteBarrier(HValue* object,
-                                            HValue* value,
-                                            HValue* dominator) {
-  while (object->IsInnerAllocatedObject()) {
-    object = HInnerAllocatedObject::cast(object)->base_object();
-  }
-  if (object->IsConstant() &&
-      HConstant::cast(object)->HasExternalReferenceValue()) {
-    // Stores to external references require no write barriers
-    return false;
-  }
-  // We definitely need a write barrier unless the object is the allocation
-  // dominator.
-  if (object == dominator && object->IsAllocate()) {
-    // Stores to new space allocations require no write barriers.
-    if (HAllocate::cast(object)->IsNewSpaceAllocation()) {
-      return false;
-    }
-    // Stores to old space allocations require no write barriers if the value is
-    // a constant provably not in new space.
-    if (value->IsConstant() && HConstant::cast(value)->NotInNewSpace()) {
-      return false;
-    }
-    // Stores to old space allocations require no write barriers if the value is
-    // an old space allocation.
-    while (value->IsInnerAllocatedObject()) {
-      value = HInnerAllocatedObject::cast(value)->base_object();
-    }
-    if (value->IsAllocate() &&
-        !HAllocate::cast(value)->IsNewSpaceAllocation()) {
-      return false;
-    }
-  }
-  return true;
-}
-
-
-inline PointersToHereCheck PointersToHereCheckForObject(HValue* object,
-                                                        HValue* dominator) {
-  while (object->IsInnerAllocatedObject()) {
-    object = HInnerAllocatedObject::cast(object)->base_object();
-  }
-  if (object == dominator &&
-      object->IsAllocate() &&
-      HAllocate::cast(object)->IsNewSpaceAllocation()) {
-    return kPointersToHereAreAlwaysInteresting;
-  }
-  return kPointersToHereMaybeInteresting;
-}
-
-
-class HLoadContextSlot final : public HUnaryOperation {
- public:
-  enum Mode {
-    // Perform a normal load of the context slot without checking its value.
-    kNoCheck,
-    // Load and check the value of the context slot. Deoptimize if it's the
-    // hole value. This is used for checking for loading of uninitialized
-    // harmony bindings where we deoptimize into full-codegen generated code
-    // which will subsequently throw a reference error.
-    kCheckDeoptimize,
-    // Load and check the value of the context slot. Return undefined if it's
-    // the hole value. This is used for non-harmony const assignments
-    kCheckReturnUndefined
-  };
-
-  HLoadContextSlot(HValue* context, int slot_index, Mode mode)
-      : HUnaryOperation(context), slot_index_(slot_index), mode_(mode) {
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-    SetDependsOnFlag(kContextSlots);
-  }
-
-  int slot_index() const { return slot_index_; }
-  Mode mode() const { return mode_; }
-
-  bool DeoptimizesOnHole() {
-    return mode_ == kCheckDeoptimize;
-  }
-
-  bool RequiresHoleCheck() const {
-    return mode_ != kNoCheck;
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(LoadContextSlot)
-
- protected:
-  bool DataEquals(HValue* other) override {
-    HLoadContextSlot* b = HLoadContextSlot::cast(other);
-    return (slot_index() == b->slot_index());
-  }
-
- private:
-  bool IsDeletable() const override { return !RequiresHoleCheck(); }
-
-  int slot_index_;
-  Mode mode_;
-};
-
-
-class HStoreContextSlot final : public HTemplateInstruction<2> {
- public:
-  enum Mode {
-    // Perform a normal store to the context slot without checking its previous
-    // value.
-    kNoCheck,
-    // Check the previous value of the context slot and deoptimize if it's the
-    // hole value. This is used for checking for assignments to uninitialized
-    // harmony bindings where we deoptimize into full-codegen generated code
-    // which will subsequently throw a reference error.
-    kCheckDeoptimize,
-    // Check the previous value and ignore assignment if it isn't a hole value
-    kCheckIgnoreAssignment
-  };
-
-  DECLARE_INSTRUCTION_FACTORY_P4(HStoreContextSlot, HValue*, int,
-                                 Mode, HValue*);
-
-  HValue* context() const { return OperandAt(0); }
-  HValue* value() const { return OperandAt(1); }
-  int slot_index() const { return slot_index_; }
-  Mode mode() const { return mode_; }
-
-  bool NeedsWriteBarrier() {
-    return StoringValueNeedsWriteBarrier(value());
-  }
-
-  bool DeoptimizesOnHole() {
-    return mode_ == kCheckDeoptimize;
-  }
-
-  bool RequiresHoleCheck() {
-    return mode_ != kNoCheck;
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(StoreContextSlot)
-
- private:
-  HStoreContextSlot(HValue* context, int slot_index, Mode mode, HValue* value)
-      : slot_index_(slot_index), mode_(mode) {
-    SetOperandAt(0, context);
-    SetOperandAt(1, value);
-    SetChangesFlag(kContextSlots);
-  }
-
-  int slot_index_;
-  Mode mode_;
-};
-
-
-// Represents an access to a portion of an object, such as the map pointer,
-// array elements pointer, etc, but not accesses to array elements themselves.
-class HObjectAccess final {
- public:
-  inline bool IsInobject() const {
-    return portion() != kBackingStore && portion() != kExternalMemory;
-  }
-
-  inline bool IsExternalMemory() const {
-    return portion() == kExternalMemory;
-  }
-
-  inline bool IsStringLength() const {
-    return portion() == kStringLengths;
-  }
-
-  inline bool IsMap() const {
-    return portion() == kMaps;
-  }
-
-  inline int offset() const {
-    return OffsetField::decode(value_);
-  }
-
-  inline Representation representation() const {
-    return Representation::FromKind(RepresentationField::decode(value_));
-  }
-
-  inline Handle<Name> name() const { return name_; }
-
-  inline bool immutable() const {
-    return ImmutableField::decode(value_);
-  }
-
-  // Returns true if access is being made to an in-object property that
-  // was already added to the object.
-  inline bool existing_inobject_property() const {
-    return ExistingInobjectPropertyField::decode(value_);
-  }
-
-  inline HObjectAccess WithRepresentation(Representation representation) {
-    return HObjectAccess(portion(), offset(), representation, name(),
-                         immutable(), existing_inobject_property());
-  }
-
-  static HObjectAccess ForHeapNumberValue() {
-    return HObjectAccess(
-        kDouble, HeapNumber::kValueOffset, Representation::Double());
-  }
-
-  static HObjectAccess ForHeapNumberValueLowestBits() {
-    return HObjectAccess(kDouble,
-                         HeapNumber::kValueOffset,
-                         Representation::Integer32());
-  }
-
-  static HObjectAccess ForHeapNumberValueHighestBits() {
-    return HObjectAccess(kDouble,
-                         HeapNumber::kValueOffset + kIntSize,
-                         Representation::Integer32());
-  }
-
-  static HObjectAccess ForOddballToNumber(
-      Representation representation = Representation::Tagged()) {
-    return HObjectAccess(kInobject, Oddball::kToNumberOffset, representation);
-  }
-
-  static HObjectAccess ForOddballTypeOf() {
-    return HObjectAccess(kInobject, Oddball::kTypeOfOffset,
-                         Representation::HeapObject());
-  }
-
-  static HObjectAccess ForElementsPointer() {
-    return HObjectAccess(kElementsPointer, JSObject::kElementsOffset);
-  }
-
-  static HObjectAccess ForLiteralsPointer() {
-    return HObjectAccess(kInobject, JSFunction::kLiteralsOffset);
-  }
-
-  static HObjectAccess ForNextFunctionLinkPointer() {
-    return HObjectAccess(kInobject, JSFunction::kNextFunctionLinkOffset);
-  }
-
-  static HObjectAccess ForArrayLength(ElementsKind elements_kind) {
-    return HObjectAccess(
-        kArrayLengths,
-        JSArray::kLengthOffset,
-        IsFastElementsKind(elements_kind)
-            ? Representation::Smi() : Representation::Tagged());
-  }
-
-  static HObjectAccess ForAllocationSiteOffset(int offset);
-
-  static HObjectAccess ForAllocationSiteList() {
-    return HObjectAccess(kExternalMemory, 0, Representation::Tagged(),
-                         Handle<Name>::null(), false, false);
-  }
-
-  static HObjectAccess ForFixedArrayLength() {
-    return HObjectAccess(
-        kArrayLengths,
-        FixedArray::kLengthOffset,
-        Representation::Smi());
-  }
-
-  static HObjectAccess ForFixedTypedArrayBaseBasePointer() {
-    return HObjectAccess(kInobject, FixedTypedArrayBase::kBasePointerOffset,
-                         Representation::Tagged());
-  }
-
-  static HObjectAccess ForFixedTypedArrayBaseExternalPointer() {
-    return HObjectAccess::ForObservableJSObjectOffset(
-        FixedTypedArrayBase::kExternalPointerOffset,
-        Representation::External());
-  }
-
-  static HObjectAccess ForStringHashField() {
-    return HObjectAccess(kInobject,
-                         String::kHashFieldOffset,
-                         Representation::Integer32());
-  }
-
-  static HObjectAccess ForStringLength() {
-    STATIC_ASSERT(String::kMaxLength <= Smi::kMaxValue);
-    return HObjectAccess(
-        kStringLengths,
-        String::kLengthOffset,
-        Representation::Smi());
-  }
-
-  static HObjectAccess ForConsStringFirst() {
-    return HObjectAccess(kInobject, ConsString::kFirstOffset);
-  }
-
-  static HObjectAccess ForConsStringSecond() {
-    return HObjectAccess(kInobject, ConsString::kSecondOffset);
-  }
-
-  static HObjectAccess ForPropertiesPointer() {
-    return HObjectAccess(kInobject, JSObject::kPropertiesOffset);
-  }
-
-  static HObjectAccess ForPrototypeOrInitialMap() {
-    return HObjectAccess(kInobject, JSFunction::kPrototypeOrInitialMapOffset);
-  }
-
-  static HObjectAccess ForSharedFunctionInfoPointer() {
-    return HObjectAccess(kInobject, JSFunction::kSharedFunctionInfoOffset);
-  }
-
-  static HObjectAccess ForCodeEntryPointer() {
-    return HObjectAccess(kInobject, JSFunction::kCodeEntryOffset);
-  }
-
-  static HObjectAccess ForCodeOffset() {
-    return HObjectAccess(kInobject, SharedFunctionInfo::kCodeOffset);
-  }
-
-  static HObjectAccess ForOptimizedCodeMap() {
-    return HObjectAccess(kInobject,
-                         SharedFunctionInfo::kOptimizedCodeMapOffset);
-  }
-
-  static HObjectAccess ForOptimizedCodeMapSharedCode() {
-    return HObjectAccess(kInobject, FixedArray::OffsetOfElementAt(
-                                        SharedFunctionInfo::kSharedCodeIndex));
-  }
-
-  static HObjectAccess ForFunctionContextPointer() {
-    return HObjectAccess(kInobject, JSFunction::kContextOffset);
-  }
-
-  static HObjectAccess ForMap() {
-    return HObjectAccess(kMaps, JSObject::kMapOffset);
-  }
-
-  static HObjectAccess ForPrototype() {
-    return HObjectAccess(kMaps, Map::kPrototypeOffset);
-  }
-
-  static HObjectAccess ForMapAsInteger32() {
-    return HObjectAccess(kMaps, JSObject::kMapOffset,
-                         Representation::Integer32());
-  }
-
-  static HObjectAccess ForMapInObjectPropertiesOrConstructorFunctionIndex() {
-    return HObjectAccess(
-        kInobject, Map::kInObjectPropertiesOrConstructorFunctionIndexOffset,
-        Representation::UInteger8());
-  }
-
-  static HObjectAccess ForMapInstanceType() {
-    return HObjectAccess(kInobject,
-                         Map::kInstanceTypeOffset,
-                         Representation::UInteger8());
-  }
-
-  static HObjectAccess ForMapInstanceSize() {
-    return HObjectAccess(kInobject,
-                         Map::kInstanceSizeOffset,
-                         Representation::UInteger8());
-  }
-
-  static HObjectAccess ForMapBitField() {
-    return HObjectAccess(kInobject,
-                         Map::kBitFieldOffset,
-                         Representation::UInteger8());
-  }
-
-  static HObjectAccess ForMapBitField2() {
-    return HObjectAccess(kInobject,
-                         Map::kBitField2Offset,
-                         Representation::UInteger8());
-  }
-
-  static HObjectAccess ForNameHashField() {
-    return HObjectAccess(kInobject,
-                         Name::kHashFieldOffset,
-                         Representation::Integer32());
-  }
-
-  static HObjectAccess ForMapInstanceTypeAndBitField() {
-    STATIC_ASSERT((Map::kInstanceTypeAndBitFieldOffset & 1) == 0);
-    // Ensure the two fields share one 16-bit word, endian-independent.
-    STATIC_ASSERT((Map::kBitFieldOffset & ~1) ==
-                  (Map::kInstanceTypeOffset & ~1));
-    return HObjectAccess(kInobject,
-                         Map::kInstanceTypeAndBitFieldOffset,
-                         Representation::UInteger16());
-  }
-
-  static HObjectAccess ForPropertyCellValue() {
-    return HObjectAccess(kInobject, PropertyCell::kValueOffset);
-  }
-
-  static HObjectAccess ForPropertyCellDetails() {
-    return HObjectAccess(kInobject, PropertyCell::kDetailsOffset,
-                         Representation::Smi());
-  }
-
-  static HObjectAccess ForCellValue() {
-    return HObjectAccess(kInobject, Cell::kValueOffset);
-  }
-
-  static HObjectAccess ForWeakCellValue() {
-    return HObjectAccess(kInobject, WeakCell::kValueOffset);
-  }
-
-  static HObjectAccess ForWeakCellNext() {
-    return HObjectAccess(kInobject, WeakCell::kNextOffset);
-  }
-
-  static HObjectAccess ForAllocationMementoSite() {
-    return HObjectAccess(kInobject, AllocationMemento::kAllocationSiteOffset);
-  }
-
-  static HObjectAccess ForCounter() {
-    return HObjectAccess(kExternalMemory, 0, Representation::Integer32(),
-                         Handle<Name>::null(), false, false);
-  }
-
-  static HObjectAccess ForExternalUInteger8() {
-    return HObjectAccess(kExternalMemory, 0, Representation::UInteger8(),
-                         Handle<Name>::null(), false, false);
-  }
-
-  // Create an access to an offset in a fixed array header.
-  static HObjectAccess ForFixedArrayHeader(int offset);
-
-  // Create an access to an in-object property in a JSObject.
-  // This kind of access must be used when the object |map| is known and
-  // in-object properties are being accessed. Accesses of the in-object
-  // properties can have different semantics depending on whether corresponding
-  // property was added to the map or not.
-  static HObjectAccess ForMapAndOffset(Handle<Map> map, int offset,
-      Representation representation = Representation::Tagged());
-
-  // Create an access to an in-object property in a JSObject.
-  // This kind of access can be used for accessing object header fields or
-  // in-object properties if the map of the object is not known.
-  static HObjectAccess ForObservableJSObjectOffset(int offset,
-      Representation representation = Representation::Tagged()) {
-    return ForMapAndOffset(Handle<Map>::null(), offset, representation);
-  }
-
-  // Create an access to an in-object property in a JSArray.
-  static HObjectAccess ForJSArrayOffset(int offset);
-
-  static HObjectAccess ForContextSlot(int index);
-
-  static HObjectAccess ForScriptContext(int index);
-
-  // Create an access to the backing store of an object.
-  static HObjectAccess ForBackingStoreOffset(int offset,
-      Representation representation = Representation::Tagged());
-
-  // Create an access to a resolved field (in-object or backing store).
-  static HObjectAccess ForField(Handle<Map> map, int index,
-                                Representation representation,
-                                Handle<Name> name);
-
-  static HObjectAccess ForJSTypedArrayLength() {
-    return HObjectAccess::ForObservableJSObjectOffset(
-        JSTypedArray::kLengthOffset);
-  }
-
-  static HObjectAccess ForJSArrayBufferBackingStore() {
-    return HObjectAccess::ForObservableJSObjectOffset(
-        JSArrayBuffer::kBackingStoreOffset, Representation::External());
-  }
-
-  static HObjectAccess ForJSArrayBufferByteLength() {
-    return HObjectAccess::ForObservableJSObjectOffset(
-        JSArrayBuffer::kByteLengthOffset, Representation::Tagged());
-  }
-
-  static HObjectAccess ForJSArrayBufferBitField() {
-    return HObjectAccess::ForObservableJSObjectOffset(
-        JSArrayBuffer::kBitFieldOffset, Representation::Integer32());
-  }
-
-  static HObjectAccess ForJSArrayBufferBitFieldSlot() {
-    return HObjectAccess::ForObservableJSObjectOffset(
-        JSArrayBuffer::kBitFieldSlot, Representation::Smi());
-  }
-
-  static HObjectAccess ForJSArrayBufferViewBuffer() {
-    return HObjectAccess::ForObservableJSObjectOffset(
-        JSArrayBufferView::kBufferOffset);
-  }
-
-  static HObjectAccess ForJSArrayBufferViewByteOffset() {
-    return HObjectAccess::ForObservableJSObjectOffset(
-        JSArrayBufferView::kByteOffsetOffset);
-  }
-
-  static HObjectAccess ForJSArrayBufferViewByteLength() {
-    return HObjectAccess::ForObservableJSObjectOffset(
-        JSArrayBufferView::kByteLengthOffset);
-  }
-
-  static HObjectAccess ForGlobalObjectNativeContext() {
-    return HObjectAccess(kInobject, GlobalObject::kNativeContextOffset);
-  }
-
-  static HObjectAccess ForJSCollectionTable() {
-    return HObjectAccess::ForObservableJSObjectOffset(
-        JSCollection::kTableOffset);
-  }
-
-  template <typename CollectionType>
-  static HObjectAccess ForOrderedHashTableNumberOfBuckets() {
-    return HObjectAccess(kInobject, CollectionType::kNumberOfBucketsOffset,
-                         Representation::Smi());
-  }
-
-  template <typename CollectionType>
-  static HObjectAccess ForOrderedHashTableNumberOfElements() {
-    return HObjectAccess(kInobject, CollectionType::kNumberOfElementsOffset,
-                         Representation::Smi());
-  }
-
-  template <typename CollectionType>
-  static HObjectAccess ForOrderedHashTableNumberOfDeletedElements() {
-    return HObjectAccess(kInobject,
-                         CollectionType::kNumberOfDeletedElementsOffset,
-                         Representation::Smi());
-  }
-
-  template <typename CollectionType>
-  static HObjectAccess ForOrderedHashTableNextTable() {
-    return HObjectAccess(kInobject, CollectionType::kNextTableOffset);
-  }
-
-  template <typename CollectionType>
-  static HObjectAccess ForOrderedHashTableBucket(int bucket) {
-    return HObjectAccess(kInobject, CollectionType::kHashTableStartOffset +
-                                        (bucket * kPointerSize),
-                         Representation::Smi());
-  }
-
-  // Access into the data table of an OrderedHashTable with a
-  // known-at-compile-time bucket count.
-  template <typename CollectionType, int kBucketCount>
-  static HObjectAccess ForOrderedHashTableDataTableIndex(int index) {
-    return HObjectAccess(kInobject, CollectionType::kHashTableStartOffset +
-                                        (kBucketCount * kPointerSize) +
-                                        (index * kPointerSize));
-  }
-
-  inline bool Equals(HObjectAccess that) const {
-    return value_ == that.value_;  // portion and offset must match
-  }
-
- protected:
-  void SetGVNFlags(HValue *instr, PropertyAccessType access_type);
-
- private:
-  // internal use only; different parts of an object or array
-  enum Portion {
-    kMaps,             // map of an object
-    kArrayLengths,     // the length of an array
-    kStringLengths,    // the length of a string
-    kElementsPointer,  // elements pointer
-    kBackingStore,     // some field in the backing store
-    kDouble,           // some double field
-    kInobject,         // some other in-object field
-    kExternalMemory    // some field in external memory
-  };
-
-  HObjectAccess() : value_(0) {}
-
-  HObjectAccess(Portion portion, int offset,
-                Representation representation = Representation::Tagged(),
-                Handle<Name> name = Handle<Name>::null(),
-                bool immutable = false, bool existing_inobject_property = true)
-      : value_(PortionField::encode(portion) |
-               RepresentationField::encode(representation.kind()) |
-               ImmutableField::encode(immutable ? 1 : 0) |
-               ExistingInobjectPropertyField::encode(
-                   existing_inobject_property ? 1 : 0) |
-               OffsetField::encode(offset)),
-        name_(name) {
-    // assert that the fields decode correctly
-    DCHECK(this->offset() == offset);
-    DCHECK(this->portion() == portion);
-    DCHECK(this->immutable() == immutable);
-    DCHECK(this->existing_inobject_property() == existing_inobject_property);
-    DCHECK(RepresentationField::decode(value_) == representation.kind());
-    DCHECK(!this->existing_inobject_property() || IsInobject());
-  }
-
-  class PortionField : public BitField<Portion, 0, 3> {};
-  class RepresentationField : public BitField<Representation::Kind, 3, 4> {};
-  class ImmutableField : public BitField<bool, 7, 1> {};
-  class ExistingInobjectPropertyField : public BitField<bool, 8, 1> {};
-  class OffsetField : public BitField<int, 9, 23> {};
-
-  uint32_t value_;  // encodes portion, representation, immutable, and offset
-  Handle<Name> name_;
-
-  friend class HLoadNamedField;
-  friend class HStoreNamedField;
-  friend class SideEffectsTracker;
-  friend std::ostream& operator<<(std::ostream& os,
-                                  const HObjectAccess& access);
-
-  inline Portion portion() const {
-    return PortionField::decode(value_);
-  }
-};
-
-
-std::ostream& operator<<(std::ostream& os, const HObjectAccess& access);
-
-
-class HLoadNamedField final : public HTemplateInstruction<2> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P3(HLoadNamedField, HValue*,
-                                 HValue*, HObjectAccess);
-  DECLARE_INSTRUCTION_FACTORY_P5(HLoadNamedField, HValue*, HValue*,
-                                 HObjectAccess, const UniqueSet<Map>*, HType);
-
-  HValue* object() const { return OperandAt(0); }
-  HValue* dependency() const {
-    DCHECK(HasDependency());
-    return OperandAt(1);
-  }
-  bool HasDependency() const { return OperandAt(0) != OperandAt(1); }
-  HObjectAccess access() const { return access_; }
-  Representation field_representation() const {
-      return access_.representation();
-  }
-
-  const UniqueSet<Map>* maps() const { return maps_; }
-
-  bool HasEscapingOperandAt(int index) override { return false; }
-  bool HasOutOfBoundsAccess(int size) override {
-    return !access().IsInobject() || access().offset() >= size;
-  }
-  Representation RequiredInputRepresentation(int index) override {
-    if (index == 0) {
-      // object must be external in case of external memory access
-      return access().IsExternalMemory() ? Representation::External()
-                                         : Representation::Tagged();
-    }
-    DCHECK(index == 1);
-    return Representation::None();
-  }
-  Range* InferRange(Zone* zone) override;
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  bool CanBeReplacedWith(HValue* other) const {
-    if (!CheckFlag(HValue::kCantBeReplaced)) return false;
-    if (!type().Equals(other->type())) return false;
-    if (!representation().Equals(other->representation())) return false;
-    if (!other->IsLoadNamedField()) return true;
-    HLoadNamedField* that = HLoadNamedField::cast(other);
-    if (this->maps_ == that->maps_) return true;
-    if (this->maps_ == NULL || that->maps_ == NULL) return false;
-    return this->maps_->IsSubset(that->maps_);
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(LoadNamedField)
-
- protected:
-  bool DataEquals(HValue* other) override {
-    HLoadNamedField* that = HLoadNamedField::cast(other);
-    if (!this->access_.Equals(that->access_)) return false;
-    if (this->maps_ == that->maps_) return true;
-    return (this->maps_ != NULL &&
-            that->maps_ != NULL &&
-            this->maps_->Equals(that->maps_));
-  }
-
- private:
-  HLoadNamedField(HValue* object,
-                  HValue* dependency,
-                  HObjectAccess access)
-      : access_(access), maps_(NULL) {
-    DCHECK_NOT_NULL(object);
-    SetOperandAt(0, object);
-    SetOperandAt(1, dependency ? dependency : object);
-
-    Representation representation = access.representation();
-    if (representation.IsInteger8() ||
-        representation.IsUInteger8() ||
-        representation.IsInteger16() ||
-        representation.IsUInteger16()) {
-      set_representation(Representation::Integer32());
-    } else if (representation.IsSmi()) {
-      set_type(HType::Smi());
-      if (SmiValuesAre32Bits()) {
-        set_representation(Representation::Integer32());
-      } else {
-        set_representation(representation);
-      }
-    } else if (representation.IsDouble() ||
-               representation.IsExternal() ||
-               representation.IsInteger32()) {
-      set_representation(representation);
-    } else if (representation.IsHeapObject()) {
-      set_type(HType::HeapObject());
-      set_representation(Representation::Tagged());
-    } else {
-      set_representation(Representation::Tagged());
-    }
-    access.SetGVNFlags(this, LOAD);
-  }
-
-  HLoadNamedField(HValue* object,
-                  HValue* dependency,
-                  HObjectAccess access,
-                  const UniqueSet<Map>* maps,
-                  HType type)
-      : HTemplateInstruction<2>(type), access_(access), maps_(maps) {
-    DCHECK_NOT_NULL(maps);
-    DCHECK_NE(0, maps->size());
-
-    DCHECK_NOT_NULL(object);
-    SetOperandAt(0, object);
-    SetOperandAt(1, dependency ? dependency : object);
-
-    DCHECK(access.representation().IsHeapObject());
-    DCHECK(type.IsHeapObject());
-    set_representation(Representation::Tagged());
-
-    access.SetGVNFlags(this, LOAD);
-  }
-
-  bool IsDeletable() const override { return true; }
-
-  HObjectAccess access_;
-  const UniqueSet<Map>* maps_;
-};
-
-
-class HLoadNamedGeneric final : public HTemplateInstruction<2> {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P4(HLoadNamedGeneric, HValue*,
-                                              Handle<Name>, LanguageMode,
-                                              InlineCacheState);
-
-  HValue* context() const { return OperandAt(0); }
-  HValue* object() const { return OperandAt(1); }
-  Handle<Name> name() const { return name_; }
-
-  InlineCacheState initialization_state() const {
-    return initialization_state_;
-  }
-  FeedbackVectorSlot slot() const { return slot_; }
-  Handle<TypeFeedbackVector> feedback_vector() const {
-    return feedback_vector_;
-  }
-  bool HasVectorAndSlot() const { return true; }
-  void SetVectorAndSlot(Handle<TypeFeedbackVector> vector,
-                        FeedbackVectorSlot slot) {
-    feedback_vector_ = vector;
-    slot_ = slot;
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric)
-
-  LanguageMode language_mode() const { return language_mode_; }
-
- private:
-  HLoadNamedGeneric(HValue* context, HValue* object, Handle<Name> name,
-                    LanguageMode language_mode,
-                    InlineCacheState initialization_state)
-      : name_(name),
-        language_mode_(language_mode),
-        initialization_state_(initialization_state) {
-    SetOperandAt(0, context);
-    SetOperandAt(1, object);
-    set_representation(Representation::Tagged());
-    SetAllSideEffects();
-  }
-
-  Handle<Name> name_;
-  Handle<TypeFeedbackVector> feedback_vector_;
-  FeedbackVectorSlot slot_;
-  LanguageMode language_mode_;
-  InlineCacheState initialization_state_;
-};
-
-
-class HLoadFunctionPrototype final : public HUnaryOperation {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HLoadFunctionPrototype, HValue*);
-
-  HValue* function() { return OperandAt(0); }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(LoadFunctionPrototype)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  explicit HLoadFunctionPrototype(HValue* function)
-      : HUnaryOperation(function) {
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-    SetDependsOnFlag(kCalls);
-  }
-};
-
-class ArrayInstructionInterface {
- public:
-  virtual HValue* GetKey() = 0;
-  virtual void SetKey(HValue* key) = 0;
-  virtual ElementsKind elements_kind() const = 0;
-  // TryIncreaseBaseOffset returns false if overflow would result.
-  virtual bool TryIncreaseBaseOffset(uint32_t increase_by_value) = 0;
-  virtual bool IsDehoisted() const = 0;
-  virtual void SetDehoisted(bool is_dehoisted) = 0;
-  virtual ~ArrayInstructionInterface() { }
-
-  static Representation KeyedAccessIndexRequirement(Representation r) {
-    return r.IsInteger32() || SmiValuesAre32Bits()
-        ? Representation::Integer32() : Representation::Smi();
-  }
-};
-
-
-static const int kDefaultKeyedHeaderOffsetSentinel = -1;
-
-enum LoadKeyedHoleMode {
-  NEVER_RETURN_HOLE,
-  ALLOW_RETURN_HOLE,
-  CONVERT_HOLE_TO_UNDEFINED
-};
-
-
-class HLoadKeyed final : public HTemplateInstruction<3>,
-                         public ArrayInstructionInterface {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P4(HLoadKeyed, HValue*, HValue*, HValue*,
-                                 ElementsKind);
-  DECLARE_INSTRUCTION_FACTORY_P5(HLoadKeyed, HValue*, HValue*, HValue*,
-                                 ElementsKind, LoadKeyedHoleMode);
-  DECLARE_INSTRUCTION_FACTORY_P6(HLoadKeyed, HValue*, HValue*, HValue*,
-                                 ElementsKind, LoadKeyedHoleMode, int);
-
-  bool is_fixed_typed_array() const {
-    return IsFixedTypedArrayElementsKind(elements_kind());
-  }
-  HValue* elements() const { return OperandAt(0); }
-  HValue* key() const { return OperandAt(1); }
-  HValue* dependency() const {
-    DCHECK(HasDependency());
-    return OperandAt(2);
-  }
-  bool HasDependency() const { return OperandAt(0) != OperandAt(2); }
-  uint32_t base_offset() const { return BaseOffsetField::decode(bit_field_); }
-  bool TryIncreaseBaseOffset(uint32_t increase_by_value) override;
-  HValue* GetKey() override { return key(); }
-  void SetKey(HValue* key) override { SetOperandAt(1, key); }
-  bool IsDehoisted() const override {
-    return IsDehoistedField::decode(bit_field_);
-  }
-  void SetDehoisted(bool is_dehoisted) override {
-    bit_field_ = IsDehoistedField::update(bit_field_, is_dehoisted);
-  }
-  ElementsKind elements_kind() const override {
-    return ElementsKindField::decode(bit_field_);
-  }
-  LoadKeyedHoleMode hole_mode() const {
-    return HoleModeField::decode(bit_field_);
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    // kind_fast:                 tagged[int32] (none)
-    // kind_double:               tagged[int32] (none)
-    // kind_fixed_typed_array:    external[int32] (none)
-    // kind_external:             external[int32] (none)
-    if (index == 0) {
-      return is_fixed_typed_array() ? Representation::External()
-                                    : Representation::Tagged();
-    }
-    if (index == 1) {
-      return ArrayInstructionInterface::KeyedAccessIndexRequirement(
-          OperandAt(1)->representation());
-    }
-    return Representation::None();
-  }
-
-  Representation observed_input_representation(int index) override {
-    return RequiredInputRepresentation(index);
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  bool UsesMustHandleHole() const;
-  bool AllUsesCanTreatHoleAsNaN() const;
-  bool RequiresHoleCheck() const;
-
-  Range* InferRange(Zone* zone) override;
-
-  DECLARE_CONCRETE_INSTRUCTION(LoadKeyed)
-
- protected:
-  bool DataEquals(HValue* other) override {
-    if (!other->IsLoadKeyed()) return false;
-    HLoadKeyed* other_load = HLoadKeyed::cast(other);
-
-    if (base_offset() != other_load->base_offset()) return false;
-    return elements_kind() == other_load->elements_kind();
-  }
-
- private:
-  HLoadKeyed(HValue* obj, HValue* key, HValue* dependency,
-             ElementsKind elements_kind,
-             LoadKeyedHoleMode mode = NEVER_RETURN_HOLE,
-             int offset = kDefaultKeyedHeaderOffsetSentinel)
-      : bit_field_(0) {
-    offset = offset == kDefaultKeyedHeaderOffsetSentinel
-        ? GetDefaultHeaderSizeForElementsKind(elements_kind)
-        : offset;
-    bit_field_ = ElementsKindField::encode(elements_kind) |
-        HoleModeField::encode(mode) |
-        BaseOffsetField::encode(offset);
-
-    SetOperandAt(0, obj);
-    SetOperandAt(1, key);
-    SetOperandAt(2, dependency != NULL ? dependency : obj);
-
-    if (!is_fixed_typed_array()) {
-      // I can detect the case between storing double (holey and fast) and
-      // smi/object by looking at elements_kind_.
-      DCHECK(IsFastSmiOrObjectElementsKind(elements_kind) ||
-             IsFastDoubleElementsKind(elements_kind));
-
-      if (IsFastSmiOrObjectElementsKind(elements_kind)) {
-        if (IsFastSmiElementsKind(elements_kind) &&
-            (!IsHoleyElementsKind(elements_kind) ||
-             mode == NEVER_RETURN_HOLE)) {
-          set_type(HType::Smi());
-          if (SmiValuesAre32Bits() && !RequiresHoleCheck()) {
-            set_representation(Representation::Integer32());
-          } else {
-            set_representation(Representation::Smi());
-          }
-        } else {
-          set_representation(Representation::Tagged());
-        }
-
-        SetDependsOnFlag(kArrayElements);
-      } else {
-        set_representation(Representation::Double());
-        SetDependsOnFlag(kDoubleArrayElements);
-      }
-    } else {
-      if (elements_kind == FLOAT32_ELEMENTS ||
-          elements_kind == FLOAT64_ELEMENTS) {
-        set_representation(Representation::Double());
-      } else {
-        set_representation(Representation::Integer32());
-      }
-
-      if (is_fixed_typed_array()) {
-        SetDependsOnFlag(kExternalMemory);
-        SetDependsOnFlag(kTypedArrayElements);
-      } else {
-        UNREACHABLE();
-      }
-      // Native code could change the specialized array.
-      SetDependsOnFlag(kCalls);
-    }
-
-    SetFlag(kUseGVN);
-  }
-
-  bool IsDeletable() const override { return !RequiresHoleCheck(); }
-
-  // Establish some checks around our packed fields
-  enum LoadKeyedBits {
-    kBitsForElementsKind = 5,
-    kBitsForHoleMode = 2,
-    kBitsForBaseOffset = 24,
-    kBitsForIsDehoisted = 1,
-
-    kStartElementsKind = 0,
-    kStartHoleMode = kStartElementsKind + kBitsForElementsKind,
-    kStartBaseOffset = kStartHoleMode + kBitsForHoleMode,
-    kStartIsDehoisted = kStartBaseOffset + kBitsForBaseOffset
-  };
-
-  STATIC_ASSERT((kBitsForElementsKind + kBitsForHoleMode + kBitsForBaseOffset +
-                 kBitsForIsDehoisted) <= sizeof(uint32_t) * 8);
-  STATIC_ASSERT(kElementsKindCount <= (1 << kBitsForElementsKind));
-  class ElementsKindField:
-    public BitField<ElementsKind, kStartElementsKind, kBitsForElementsKind>
-    {};  // NOLINT
-  class HoleModeField:
-    public BitField<LoadKeyedHoleMode, kStartHoleMode, kBitsForHoleMode>
-    {};  // NOLINT
-  class BaseOffsetField:
-    public BitField<uint32_t, kStartBaseOffset, kBitsForBaseOffset>
-    {};  // NOLINT
-  class IsDehoistedField:
-    public BitField<bool, kStartIsDehoisted, kBitsForIsDehoisted>
-    {};  // NOLINT
-  uint32_t bit_field_;
-};
-
-
-class HLoadKeyedGeneric final : public HTemplateInstruction<3> {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P4(HLoadKeyedGeneric, HValue*,
-                                              HValue*, LanguageMode,
-                                              InlineCacheState);
-  HValue* object() const { return OperandAt(0); }
-  HValue* key() const { return OperandAt(1); }
-  HValue* context() const { return OperandAt(2); }
-  InlineCacheState initialization_state() const {
-    return initialization_state_;
-  }
-  FeedbackVectorSlot slot() const { return slot_; }
-  Handle<TypeFeedbackVector> feedback_vector() const {
-    return feedback_vector_;
-  }
-  bool HasVectorAndSlot() const {
-    DCHECK(initialization_state_ == MEGAMORPHIC || !feedback_vector_.is_null());
-    return !feedback_vector_.is_null();
-  }
-  void SetVectorAndSlot(Handle<TypeFeedbackVector> vector,
-                        FeedbackVectorSlot slot) {
-    feedback_vector_ = vector;
-    slot_ = slot;
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) override {
-    // tagged[tagged]
-    return Representation::Tagged();
-  }
-
-  HValue* Canonicalize() override;
-
-  DECLARE_CONCRETE_INSTRUCTION(LoadKeyedGeneric)
-
-  LanguageMode language_mode() const { return language_mode_; }
-
- private:
-  HLoadKeyedGeneric(HValue* context, HValue* obj, HValue* key,
-                    LanguageMode language_mode,
-                    InlineCacheState initialization_state)
-      : initialization_state_(initialization_state),
-        language_mode_(language_mode) {
-    set_representation(Representation::Tagged());
-    SetOperandAt(0, obj);
-    SetOperandAt(1, key);
-    SetOperandAt(2, context);
-    SetAllSideEffects();
-  }
-
-  Handle<TypeFeedbackVector> feedback_vector_;
-  FeedbackVectorSlot slot_;
-  InlineCacheState initialization_state_;
-  LanguageMode language_mode_;
-};
-
-
-// Indicates whether the store is a store to an entry that was previously
-// initialized or not.
-enum StoreFieldOrKeyedMode {
-  // The entry could be either previously initialized or not.
-  INITIALIZING_STORE,
-  // At the time of this store it is guaranteed that the entry is already
-  // initialized.
-  STORE_TO_INITIALIZED_ENTRY
-};
-
-
-class HStoreNamedField final : public HTemplateInstruction<3> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P3(HStoreNamedField, HValue*,
-                                 HObjectAccess, HValue*);
-  DECLARE_INSTRUCTION_FACTORY_P4(HStoreNamedField, HValue*,
-                                 HObjectAccess, HValue*, StoreFieldOrKeyedMode);
-
-  DECLARE_CONCRETE_INSTRUCTION(StoreNamedField)
-
-  bool HasEscapingOperandAt(int index) override { return index == 1; }
-  bool HasOutOfBoundsAccess(int size) override {
-    return !access().IsInobject() || access().offset() >= size;
-  }
-  Representation RequiredInputRepresentation(int index) override {
-    if (index == 0 && access().IsExternalMemory()) {
-      // object must be external in case of external memory access
-      return Representation::External();
-    } else if (index == 1) {
-      if (field_representation().IsInteger8() ||
-          field_representation().IsUInteger8() ||
-          field_representation().IsInteger16() ||
-          field_representation().IsUInteger16() ||
-          field_representation().IsInteger32()) {
-        return Representation::Integer32();
-      } else if (field_representation().IsDouble()) {
-        return field_representation();
-      } else if (field_representation().IsSmi()) {
-        if (SmiValuesAre32Bits() &&
-            store_mode() == STORE_TO_INITIALIZED_ENTRY) {
-          return Representation::Integer32();
-        }
-        return field_representation();
-      } else if (field_representation().IsExternal()) {
-        return Representation::External();
-      }
-    }
-    return Representation::Tagged();
-  }
-  virtual bool HandleSideEffectDominator(GVNFlag side_effect,
-                                         HValue* dominator) override {
-    DCHECK(side_effect == kNewSpacePromotion);
-    if (!FLAG_use_write_barrier_elimination) return false;
-    dominator_ = dominator;
-    return false;
-  }
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  HValue* object() const { return OperandAt(0); }
-  HValue* value() const { return OperandAt(1); }
-  HValue* transition() const { return OperandAt(2); }
-
-  HObjectAccess access() const { return access_; }
-  HValue* dominator() const { return dominator_; }
-  bool has_transition() const { return HasTransitionField::decode(bit_field_); }
-  StoreFieldOrKeyedMode store_mode() const {
-    return StoreModeField::decode(bit_field_);
-  }
-
-  Handle<Map> transition_map() const {
-    if (has_transition()) {
-      return Handle<Map>::cast(
-          HConstant::cast(transition())->handle(isolate()));
-    } else {
-      return Handle<Map>();
-    }
-  }
-
-  void SetTransition(HConstant* transition) {
-    DCHECK(!has_transition());  // Only set once.
-    SetOperandAt(2, transition);
-    bit_field_ = HasTransitionField::update(bit_field_, true);
-    SetChangesFlag(kMaps);
-  }
-
-  bool NeedsWriteBarrier() const {
-    DCHECK(!field_representation().IsDouble() ||
-           (FLAG_unbox_double_fields && access_.IsInobject()) ||
-           !has_transition());
-    if (field_representation().IsDouble()) return false;
-    if (field_representation().IsSmi()) return false;
-    if (field_representation().IsInteger32()) return false;
-    if (field_representation().IsExternal()) return false;
-    return StoringValueNeedsWriteBarrier(value()) &&
-        ReceiverObjectNeedsWriteBarrier(object(), value(), dominator());
-  }
-
-  bool NeedsWriteBarrierForMap() {
-    return ReceiverObjectNeedsWriteBarrier(object(), transition(),
-                                           dominator());
-  }
-
-  SmiCheck SmiCheckForWriteBarrier() const {
-    if (field_representation().IsHeapObject()) return OMIT_SMI_CHECK;
-    if (value()->type().IsHeapObject()) return OMIT_SMI_CHECK;
-    return INLINE_SMI_CHECK;
-  }
-
-  PointersToHereCheck PointersToHereCheckForValue() const {
-    return PointersToHereCheckForObject(value(), dominator());
-  }
-
-  Representation field_representation() const {
-    return access_.representation();
-  }
-
-  void UpdateValue(HValue* value) {
-    SetOperandAt(1, value);
-  }
-
-  bool CanBeReplacedWith(HStoreNamedField* that) const {
-    if (!this->access().Equals(that->access())) return false;
-    if (SmiValuesAre32Bits() &&
-        this->field_representation().IsSmi() &&
-        this->store_mode() == INITIALIZING_STORE &&
-        that->store_mode() == STORE_TO_INITIALIZED_ENTRY) {
-      // We cannot replace an initializing store to a smi field with a store to
-      // an initialized entry on 64-bit architectures (with 32-bit smis).
-      return false;
-    }
-    return true;
-  }
-
- private:
-  HStoreNamedField(HValue* obj, HObjectAccess access, HValue* val,
-                   StoreFieldOrKeyedMode store_mode = INITIALIZING_STORE)
-      : access_(access),
-        dominator_(NULL),
-        bit_field_(HasTransitionField::encode(false) |
-                   StoreModeField::encode(store_mode)) {
-    // Stores to a non existing in-object property are allowed only to the
-    // newly allocated objects (via HAllocate or HInnerAllocatedObject).
-    DCHECK(!access.IsInobject() || access.existing_inobject_property() ||
-           obj->IsAllocate() || obj->IsInnerAllocatedObject());
-    SetOperandAt(0, obj);
-    SetOperandAt(1, val);
-    SetOperandAt(2, obj);
-    access.SetGVNFlags(this, STORE);
-  }
-
-  class HasTransitionField : public BitField<bool, 0, 1> {};
-  class StoreModeField : public BitField<StoreFieldOrKeyedMode, 1, 1> {};
-
-  HObjectAccess access_;
-  HValue* dominator_;
-  uint32_t bit_field_;
-};
-
-
-class HStoreNamedGeneric final : public HTemplateInstruction<3> {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P5(HStoreNamedGeneric, HValue*,
-                                              Handle<Name>, HValue*,
-                                              LanguageMode, InlineCacheState);
-  HValue* object() const { return OperandAt(0); }
-  HValue* value() const { return OperandAt(1); }
-  HValue* context() const { return OperandAt(2); }
-  Handle<Name> name() const { return name_; }
-  LanguageMode language_mode() const { return language_mode_; }
-  InlineCacheState initialization_state() const {
-    return initialization_state_;
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  FeedbackVectorSlot slot() const { return slot_; }
-  Handle<TypeFeedbackVector> feedback_vector() const {
-    return feedback_vector_;
-  }
-  bool HasVectorAndSlot() const { return FLAG_vector_stores; }
-  void SetVectorAndSlot(Handle<TypeFeedbackVector> vector,
-                        FeedbackVectorSlot slot) {
-    feedback_vector_ = vector;
-    slot_ = slot;
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric)
-
- private:
-  HStoreNamedGeneric(HValue* context, HValue* object, Handle<Name> name,
-                     HValue* value, LanguageMode language_mode,
-                     InlineCacheState initialization_state)
-      : name_(name),
-        language_mode_(language_mode),
-        initialization_state_(initialization_state) {
-    SetOperandAt(0, object);
-    SetOperandAt(1, value);
-    SetOperandAt(2, context);
-    SetAllSideEffects();
-  }
-
-  Handle<Name> name_;
-  Handle<TypeFeedbackVector> feedback_vector_;
-  FeedbackVectorSlot slot_;
-  LanguageMode language_mode_;
-  InlineCacheState initialization_state_;
-};
-
-
-class HStoreGlobalViaContext final : public HTemplateInstruction<2> {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P4(HStoreGlobalViaContext, HValue*,
-                                              int, int, LanguageMode);
-  HValue* context() const { return OperandAt(0); }
-  HValue* value() const { return OperandAt(1); }
-  int depth() const { return depth_; }
-  int slot_index() const { return slot_index_; }
-  LanguageMode language_mode() const { return language_mode_; }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(StoreGlobalViaContext)
-
- private:
-  HStoreGlobalViaContext(HValue* context, HValue* value, int depth,
-                         int slot_index, LanguageMode language_mode)
-      : depth_(depth), slot_index_(slot_index), language_mode_(language_mode) {
-    SetOperandAt(0, context);
-    SetOperandAt(1, value);
-    SetAllSideEffects();
-  }
-
-  int const depth_;
-  int const slot_index_;
-  LanguageMode const language_mode_;
-};
-
-
-class HStoreKeyed final : public HTemplateInstruction<3>,
-                          public ArrayInstructionInterface {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P4(HStoreKeyed, HValue*, HValue*, HValue*,
-                                 ElementsKind);
-  DECLARE_INSTRUCTION_FACTORY_P5(HStoreKeyed, HValue*, HValue*, HValue*,
-                                 ElementsKind, StoreFieldOrKeyedMode);
-  DECLARE_INSTRUCTION_FACTORY_P6(HStoreKeyed, HValue*, HValue*, HValue*,
-                                 ElementsKind, StoreFieldOrKeyedMode, int);
-
-  Representation RequiredInputRepresentation(int index) override {
-    // kind_fast:               tagged[int32] = tagged
-    // kind_double:             tagged[int32] = double
-    // kind_smi   :             tagged[int32] = smi
-    // kind_fixed_typed_array:  tagged[int32] = (double | int32)
-    // kind_external:           external[int32] = (double | int32)
-    if (index == 0) {
-      return is_fixed_typed_array() ? Representation::External()
-                                    : Representation::Tagged();
-    } else if (index == 1) {
-      return ArrayInstructionInterface::KeyedAccessIndexRequirement(
-          OperandAt(1)->representation());
-    }
-
-    DCHECK_EQ(index, 2);
-    return RequiredValueRepresentation(elements_kind(), store_mode());
-  }
-
-  static Representation RequiredValueRepresentation(
-      ElementsKind kind, StoreFieldOrKeyedMode mode) {
-    if (IsDoubleOrFloatElementsKind(kind)) {
-      return Representation::Double();
-    }
-
-    if (kind == FAST_SMI_ELEMENTS && SmiValuesAre32Bits() &&
-        mode == STORE_TO_INITIALIZED_ENTRY) {
-      return Representation::Integer32();
-    }
-
-    if (IsFastSmiElementsKind(kind)) {
-      return Representation::Smi();
-    }
-
-    if (IsFixedTypedArrayElementsKind(kind)) {
-      return Representation::Integer32();
-    }
-    return Representation::Tagged();
-  }
-
-  bool is_fixed_typed_array() const {
-    return IsFixedTypedArrayElementsKind(elements_kind());
-  }
-
-  Representation observed_input_representation(int index) override {
-    if (index < 2) return RequiredInputRepresentation(index);
-    if (IsUninitialized()) {
-      return Representation::None();
-    }
-    Representation r =
-        RequiredValueRepresentation(elements_kind(), store_mode());
-    // For fast object elements kinds, don't assume anything.
-    if (r.IsTagged()) return Representation::None();
-    return r;
-  }
-
-  HValue* elements() const { return OperandAt(0); }
-  HValue* key() const { return OperandAt(1); }
-  HValue* value() const { return OperandAt(2); }
-  bool value_is_smi() const { return IsFastSmiElementsKind(elements_kind()); }
-  StoreFieldOrKeyedMode store_mode() const {
-    return StoreModeField::decode(bit_field_);
-  }
-  ElementsKind elements_kind() const override {
-    return ElementsKindField::decode(bit_field_);
-  }
-  uint32_t base_offset() const { return base_offset_; }
-  bool TryIncreaseBaseOffset(uint32_t increase_by_value) override;
-  HValue* GetKey() override { return key(); }
-  void SetKey(HValue* key) override { SetOperandAt(1, key); }
-  bool IsDehoisted() const override {
-    return IsDehoistedField::decode(bit_field_);
-  }
-  void SetDehoisted(bool is_dehoisted) override {
-    bit_field_ = IsDehoistedField::update(bit_field_, is_dehoisted);
-  }
-  bool IsUninitialized() { return IsUninitializedField::decode(bit_field_); }
-  void SetUninitialized(bool is_uninitialized) {
-    bit_field_ = IsUninitializedField::update(bit_field_, is_uninitialized);
-  }
-
-  bool IsConstantHoleStore() {
-    return value()->IsConstant() && HConstant::cast(value())->IsTheHole();
-  }
-
-  virtual bool HandleSideEffectDominator(GVNFlag side_effect,
-                                         HValue* dominator) override {
-    DCHECK(side_effect == kNewSpacePromotion);
-    dominator_ = dominator;
-    return false;
-  }
-
-  HValue* dominator() const { return dominator_; }
-
-  bool NeedsWriteBarrier() {
-    if (value_is_smi()) {
-      return false;
-    } else {
-      return StoringValueNeedsWriteBarrier(value()) &&
-          ReceiverObjectNeedsWriteBarrier(elements(), value(), dominator());
-    }
-  }
-
-  PointersToHereCheck PointersToHereCheckForValue() const {
-    return PointersToHereCheckForObject(value(), dominator());
-  }
-
-  bool NeedsCanonicalization();
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(StoreKeyed)
-
- private:
-  HStoreKeyed(HValue* obj, HValue* key, HValue* val, ElementsKind elements_kind,
-              StoreFieldOrKeyedMode store_mode = INITIALIZING_STORE,
-              int offset = kDefaultKeyedHeaderOffsetSentinel)
-      : base_offset_(offset == kDefaultKeyedHeaderOffsetSentinel
-                         ? GetDefaultHeaderSizeForElementsKind(elements_kind)
-                         : offset),
-        bit_field_(IsDehoistedField::encode(false) |
-                   IsUninitializedField::encode(false) |
-                   StoreModeField::encode(store_mode) |
-                   ElementsKindField::encode(elements_kind)),
-        dominator_(NULL) {
-    SetOperandAt(0, obj);
-    SetOperandAt(1, key);
-    SetOperandAt(2, val);
-
-    if (IsFastObjectElementsKind(elements_kind)) {
-      SetFlag(kTrackSideEffectDominators);
-      SetDependsOnFlag(kNewSpacePromotion);
-    }
-    if (IsFastDoubleElementsKind(elements_kind)) {
-      SetChangesFlag(kDoubleArrayElements);
-    } else if (IsFastSmiElementsKind(elements_kind)) {
-      SetChangesFlag(kArrayElements);
-    } else if (is_fixed_typed_array()) {
-      SetChangesFlag(kTypedArrayElements);
-      SetChangesFlag(kExternalMemory);
-      SetFlag(kAllowUndefinedAsNaN);
-    } else {
-      SetChangesFlag(kArrayElements);
-    }
-
-    // {UNSIGNED_,}{BYTE,SHORT,INT}_ELEMENTS are truncating.
-    if (elements_kind >= UINT8_ELEMENTS && elements_kind <= INT32_ELEMENTS) {
-      SetFlag(kTruncatingToInt32);
-    }
-  }
-
-  class IsDehoistedField : public BitField<bool, 0, 1> {};
-  class IsUninitializedField : public BitField<bool, 1, 1> {};
-  class StoreModeField : public BitField<StoreFieldOrKeyedMode, 2, 1> {};
-  class ElementsKindField : public BitField<ElementsKind, 3, 5> {};
-
-  uint32_t base_offset_;
-  uint32_t bit_field_;
-  HValue* dominator_;
-};
-
-
-class HStoreKeyedGeneric final : public HTemplateInstruction<4> {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P5(HStoreKeyedGeneric, HValue*,
-                                              HValue*, HValue*, LanguageMode,
-                                              InlineCacheState);
-
-  HValue* object() const { return OperandAt(0); }
-  HValue* key() const { return OperandAt(1); }
-  HValue* value() const { return OperandAt(2); }
-  HValue* context() const { return OperandAt(3); }
-  LanguageMode language_mode() const { return language_mode_; }
-  InlineCacheState initialization_state() const {
-    return initialization_state_;
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    // tagged[tagged] = tagged
-    return Representation::Tagged();
-  }
-
-  FeedbackVectorSlot slot() const { return slot_; }
-  Handle<TypeFeedbackVector> feedback_vector() const {
-    return feedback_vector_;
-  }
-  bool HasVectorAndSlot() const {
-    DCHECK(!(FLAG_vector_stores && initialization_state_ != MEGAMORPHIC) ||
-           !feedback_vector_.is_null());
-    return !feedback_vector_.is_null();
-  }
-  void SetVectorAndSlot(Handle<TypeFeedbackVector> vector,
-                        FeedbackVectorSlot slot) {
-    feedback_vector_ = vector;
-    slot_ = slot;
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(StoreKeyedGeneric)
-
- private:
-  HStoreKeyedGeneric(HValue* context, HValue* object, HValue* key,
-                     HValue* value, LanguageMode language_mode,
-                     InlineCacheState initialization_state)
-      : language_mode_(language_mode),
-        initialization_state_(initialization_state) {
-    SetOperandAt(0, object);
-    SetOperandAt(1, key);
-    SetOperandAt(2, value);
-    SetOperandAt(3, context);
-    SetAllSideEffects();
-  }
-
-  Handle<TypeFeedbackVector> feedback_vector_;
-  FeedbackVectorSlot slot_;
-  LanguageMode language_mode_;
-  InlineCacheState initialization_state_;
-};
-
-
-class HTransitionElementsKind final : public HTemplateInstruction<2> {
- public:
-  inline static HTransitionElementsKind* New(Isolate* isolate, Zone* zone,
-                                             HValue* context, HValue* object,
-                                             Handle<Map> original_map,
-                                             Handle<Map> transitioned_map) {
-    return new(zone) HTransitionElementsKind(context, object,
-                                             original_map, transitioned_map);
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  HValue* object() const { return OperandAt(0); }
-  HValue* context() const { return OperandAt(1); }
-  Unique<Map> original_map() const { return original_map_; }
-  Unique<Map> transitioned_map() const { return transitioned_map_; }
-  ElementsKind from_kind() const {
-    return FromElementsKindField::decode(bit_field_);
-  }
-  ElementsKind to_kind() const {
-    return ToElementsKindField::decode(bit_field_);
-  }
-  bool map_is_stable() const { return MapIsStableField::decode(bit_field_); }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(TransitionElementsKind)
-
- protected:
-  bool DataEquals(HValue* other) override {
-    HTransitionElementsKind* instr = HTransitionElementsKind::cast(other);
-    return original_map_ == instr->original_map_ &&
-           transitioned_map_ == instr->transitioned_map_;
-  }
-
-  int RedefinedOperandIndex() override { return 0; }
-
- private:
-  HTransitionElementsKind(HValue* context, HValue* object,
-                          Handle<Map> original_map,
-                          Handle<Map> transitioned_map)
-      : original_map_(Unique<Map>(original_map)),
-        transitioned_map_(Unique<Map>(transitioned_map)),
-        bit_field_(
-            FromElementsKindField::encode(original_map->elements_kind()) |
-            ToElementsKindField::encode(transitioned_map->elements_kind()) |
-            MapIsStableField::encode(transitioned_map->is_stable())) {
-    SetOperandAt(0, object);
-    SetOperandAt(1, context);
-    SetFlag(kUseGVN);
-    SetChangesFlag(kElementsKind);
-    if (!IsSimpleMapChangeTransition(from_kind(), to_kind())) {
-      SetChangesFlag(kElementsPointer);
-      SetChangesFlag(kNewSpacePromotion);
-    }
-    set_representation(Representation::Tagged());
-  }
-
-  class FromElementsKindField : public BitField<ElementsKind, 0, 5> {};
-  class ToElementsKindField : public BitField<ElementsKind, 5, 5> {};
-  class MapIsStableField : public BitField<bool, 10, 1> {};
-
-  Unique<Map> original_map_;
-  Unique<Map> transitioned_map_;
-  uint32_t bit_field_;
-};
-
-
-class HStringAdd final : public HBinaryOperation {
- public:
-  static HInstruction* New(
-      Isolate* isolate, Zone* zone, HValue* context, HValue* left,
-      HValue* right, PretenureFlag pretenure_flag = NOT_TENURED,
-      StringAddFlags flags = STRING_ADD_CHECK_BOTH,
-      Handle<AllocationSite> allocation_site = Handle<AllocationSite>::null());
-
-  StringAddFlags flags() const { return flags_; }
-  PretenureFlag pretenure_flag() const { return pretenure_flag_; }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(StringAdd)
-
- protected:
-  bool DataEquals(HValue* other) override {
-    return flags_ == HStringAdd::cast(other)->flags_ &&
-        pretenure_flag_ == HStringAdd::cast(other)->pretenure_flag_;
-  }
-
- private:
-  HStringAdd(HValue* context, HValue* left, HValue* right,
-             PretenureFlag pretenure_flag, StringAddFlags flags,
-             Handle<AllocationSite> allocation_site)
-      : HBinaryOperation(context, left, right, Strength::WEAK, HType::String()),
-        flags_(flags),
-        pretenure_flag_(pretenure_flag) {
-    set_representation(Representation::Tagged());
-    if ((flags & STRING_ADD_CONVERT) == STRING_ADD_CONVERT) {
-      SetAllSideEffects();
-      ClearFlag(kUseGVN);
-    } else {
-      SetChangesFlag(kNewSpacePromotion);
-      SetFlag(kUseGVN);
-    }
-    SetDependsOnFlag(kMaps);
-    if (FLAG_trace_pretenuring) {
-      PrintF("HStringAdd with AllocationSite %p %s\n",
-             allocation_site.is_null()
-                 ? static_cast<void*>(NULL)
-                 : static_cast<void*>(*allocation_site),
-             pretenure_flag == TENURED ? "tenured" : "not tenured");
-    }
-  }
-
-  bool IsDeletable() const final {
-    return (flags_ & STRING_ADD_CONVERT) != STRING_ADD_CONVERT;
-  }
-
-  const StringAddFlags flags_;
-  const PretenureFlag pretenure_flag_;
-};
-
-
-class HStringCharCodeAt final : public HTemplateInstruction<3> {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HStringCharCodeAt,
-                                              HValue*,
-                                              HValue*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    // The index is supposed to be Integer32.
-    return index == 2
-        ? Representation::Integer32()
-        : Representation::Tagged();
-  }
-
-  HValue* context() const { return OperandAt(0); }
-  HValue* string() const { return OperandAt(1); }
-  HValue* index() const { return OperandAt(2); }
-
-  DECLARE_CONCRETE_INSTRUCTION(StringCharCodeAt)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
-  Range* InferRange(Zone* zone) override {
-    return new(zone) Range(0, String::kMaxUtf16CodeUnit);
-  }
-
- private:
-  HStringCharCodeAt(HValue* context, HValue* string, HValue* index) {
-    SetOperandAt(0, context);
-    SetOperandAt(1, string);
-    SetOperandAt(2, index);
-    set_representation(Representation::Integer32());
-    SetFlag(kUseGVN);
-    SetDependsOnFlag(kMaps);
-    SetDependsOnFlag(kStringChars);
-    SetChangesFlag(kNewSpacePromotion);
-  }
-
-  // No side effects: runtime function assumes string + number inputs.
-  bool IsDeletable() const override { return true; }
-};
-
-
-class HStringCharFromCode final : public HTemplateInstruction<2> {
- public:
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           HValue* char_code);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return index == 0
-        ? Representation::Tagged()
-        : Representation::Integer32();
-  }
-
-  HValue* context() const { return OperandAt(0); }
-  HValue* value() const { return OperandAt(1); }
-
-  bool DataEquals(HValue* other) override { return true; }
-
-  DECLARE_CONCRETE_INSTRUCTION(StringCharFromCode)
-
- private:
-  HStringCharFromCode(HValue* context, HValue* char_code)
-      : HTemplateInstruction<2>(HType::String()) {
-    SetOperandAt(0, context);
-    SetOperandAt(1, char_code);
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-    SetChangesFlag(kNewSpacePromotion);
-  }
-
-  bool IsDeletable() const override {
-    return !value()->ToNumberCanBeObserved();
-  }
-};
-
-
-template <int V>
-class HMaterializedLiteral : public HTemplateInstruction<V> {
- public:
-  HMaterializedLiteral<V>(int index, int depth, AllocationSiteMode mode)
-      : literal_index_(index), depth_(depth), allocation_site_mode_(mode) {
-    this->set_representation(Representation::Tagged());
-  }
-
-  HMaterializedLiteral<V>(int index, int depth)
-      : literal_index_(index), depth_(depth),
-        allocation_site_mode_(DONT_TRACK_ALLOCATION_SITE) {
-    this->set_representation(Representation::Tagged());
-  }
-
-  int literal_index() const { return literal_index_; }
-  int depth() const { return depth_; }
-  AllocationSiteMode allocation_site_mode() const {
-    return allocation_site_mode_;
-  }
-
- private:
-  bool IsDeletable() const final { return true; }
-
-  int literal_index_;
-  int depth_;
-  AllocationSiteMode allocation_site_mode_;
-};
-
-
-class HRegExpLiteral final : public HMaterializedLiteral<1> {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P4(HRegExpLiteral,
-                                              Handle<FixedArray>,
-                                              Handle<String>,
-                                              Handle<String>,
-                                              int);
-
-  HValue* context() { return OperandAt(0); }
-  Handle<FixedArray> literals() { return literals_; }
-  Handle<String> pattern() { return pattern_; }
-  Handle<String> flags() { return flags_; }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(RegExpLiteral)
-
- private:
-  HRegExpLiteral(HValue* context,
-                 Handle<FixedArray> literals,
-                 Handle<String> pattern,
-                 Handle<String> flags,
-                 int literal_index)
-      : HMaterializedLiteral<1>(literal_index, 0),
-        literals_(literals),
-        pattern_(pattern),
-        flags_(flags) {
-    SetOperandAt(0, context);
-    SetAllSideEffects();
-    set_type(HType::JSObject());
-  }
-
-  Handle<FixedArray> literals_;
-  Handle<String> pattern_;
-  Handle<String> flags_;
-};
-
-
-class HTypeof final : public HTemplateInstruction<2> {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P1(HTypeof, HValue*);
-
-  HValue* context() const { return OperandAt(0); }
-  HValue* value() const { return OperandAt(1); }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(Typeof)
-
- private:
-  explicit HTypeof(HValue* context, HValue* value) {
-    SetOperandAt(0, context);
-    SetOperandAt(1, value);
-    set_representation(Representation::Tagged());
-  }
-
-  bool IsDeletable() const override { return true; }
-};
-
-
-class HTrapAllocationMemento final : public HTemplateInstruction<1> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HTrapAllocationMemento, HValue*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  HValue* object() { return OperandAt(0); }
-
-  DECLARE_CONCRETE_INSTRUCTION(TrapAllocationMemento)
-
- private:
-  explicit HTrapAllocationMemento(HValue* obj) {
-    SetOperandAt(0, obj);
-  }
-};
-
-
-class HMaybeGrowElements final : public HTemplateInstruction<5> {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P6(HMaybeGrowElements, HValue*,
-                                              HValue*, HValue*, HValue*, bool,
-                                              ElementsKind);
-
-  Representation RequiredInputRepresentation(int index) override {
-    if (index < 3) {
-      return Representation::Tagged();
-    }
-    DCHECK(index == 3 || index == 4);
-    return Representation::Integer32();
-  }
-
-  HValue* context() const { return OperandAt(0); }
-  HValue* object() const { return OperandAt(1); }
-  HValue* elements() const { return OperandAt(2); }
-  HValue* key() const { return OperandAt(3); }
-  HValue* current_capacity() const { return OperandAt(4); }
-
-  bool is_js_array() const { return is_js_array_; }
-  ElementsKind kind() const { return kind_; }
-
-  DECLARE_CONCRETE_INSTRUCTION(MaybeGrowElements)
-
- protected:
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  explicit HMaybeGrowElements(HValue* context, HValue* object, HValue* elements,
-                              HValue* key, HValue* current_capacity,
-                              bool is_js_array, ElementsKind kind) {
-    is_js_array_ = is_js_array;
-    kind_ = kind;
-
-    SetOperandAt(0, context);
-    SetOperandAt(1, object);
-    SetOperandAt(2, elements);
-    SetOperandAt(3, key);
-    SetOperandAt(4, current_capacity);
-
-    SetFlag(kUseGVN);
-    SetChangesFlag(kElementsPointer);
-    SetChangesFlag(kNewSpacePromotion);
-    set_representation(Representation::Tagged());
-  }
-
-  bool is_js_array_;
-  ElementsKind kind_;
-};
-
-
-class HToFastProperties final : public HUnaryOperation {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HToFastProperties, HValue*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(ToFastProperties)
-
- private:
-  explicit HToFastProperties(HValue* value) : HUnaryOperation(value) {
-    set_representation(Representation::Tagged());
-    SetChangesFlag(kNewSpacePromotion);
-
-    // This instruction is not marked as kChangesMaps, but does
-    // change the map of the input operand. Use it only when creating
-    // object literals via a runtime call.
-    DCHECK(value->IsCallRuntime());
-#ifdef DEBUG
-    const Runtime::Function* function = HCallRuntime::cast(value)->function();
-    DCHECK(function->function_id == Runtime::kCreateObjectLiteral);
-#endif
-  }
-
-  bool IsDeletable() const override { return true; }
-};
-
-
-class HDateField final : public HUnaryOperation {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P2(HDateField, HValue*, Smi*);
-
-  Smi* index() const { return index_; }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(DateField)
-
- private:
-  HDateField(HValue* date, Smi* index)
-      : HUnaryOperation(date), index_(index) {
-    set_representation(Representation::Tagged());
-  }
-
-  Smi* index_;
-};
-
-
-class HSeqStringGetChar final : public HTemplateInstruction<2> {
- public:
-  static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
-                           String::Encoding encoding, HValue* string,
-                           HValue* index);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return (index == 0) ? Representation::Tagged()
-                        : Representation::Integer32();
-  }
-
-  String::Encoding encoding() const { return encoding_; }
-  HValue* string() const { return OperandAt(0); }
-  HValue* index() const { return OperandAt(1); }
-
-  DECLARE_CONCRETE_INSTRUCTION(SeqStringGetChar)
-
- protected:
-  bool DataEquals(HValue* other) override {
-    return encoding() == HSeqStringGetChar::cast(other)->encoding();
-  }
-
-  Range* InferRange(Zone* zone) override {
-    if (encoding() == String::ONE_BYTE_ENCODING) {
-      return new(zone) Range(0, String::kMaxOneByteCharCode);
-    } else {
-      DCHECK_EQ(String::TWO_BYTE_ENCODING, encoding());
-      return  new(zone) Range(0, String::kMaxUtf16CodeUnit);
-    }
-  }
-
- private:
-  HSeqStringGetChar(String::Encoding encoding,
-                    HValue* string,
-                    HValue* index) : encoding_(encoding) {
-    SetOperandAt(0, string);
-    SetOperandAt(1, index);
-    set_representation(Representation::Integer32());
-    SetFlag(kUseGVN);
-    SetDependsOnFlag(kStringChars);
-  }
-
-  bool IsDeletable() const override { return true; }
-
-  String::Encoding encoding_;
-};
-
-
-class HSeqStringSetChar final : public HTemplateInstruction<4> {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P4(
-      HSeqStringSetChar, String::Encoding,
-      HValue*, HValue*, HValue*);
-
-  String::Encoding encoding() { return encoding_; }
-  HValue* context() { return OperandAt(0); }
-  HValue* string() { return OperandAt(1); }
-  HValue* index() { return OperandAt(2); }
-  HValue* value() { return OperandAt(3); }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return (index <= 1) ? Representation::Tagged()
-                        : Representation::Integer32();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(SeqStringSetChar)
-
- private:
-  HSeqStringSetChar(HValue* context,
-                    String::Encoding encoding,
-                    HValue* string,
-                    HValue* index,
-                    HValue* value) : encoding_(encoding) {
-    SetOperandAt(0, context);
-    SetOperandAt(1, string);
-    SetOperandAt(2, index);
-    SetOperandAt(3, value);
-    set_representation(Representation::Tagged());
-    SetChangesFlag(kStringChars);
-  }
-
-  String::Encoding encoding_;
-};
-
-
-class HCheckMapValue final : public HTemplateInstruction<2> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P2(HCheckMapValue, HValue*, HValue*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  HType CalculateInferredType() override {
-    if (value()->type().IsHeapObject()) return value()->type();
-    return HType::HeapObject();
-  }
-
-  HValue* value() const { return OperandAt(0); }
-  HValue* map() const { return OperandAt(1); }
-
-  HValue* Canonicalize() override;
-
-  DECLARE_CONCRETE_INSTRUCTION(CheckMapValue)
-
- protected:
-  int RedefinedOperandIndex() override { return 0; }
-
-  bool DataEquals(HValue* other) override { return true; }
-
- private:
-  HCheckMapValue(HValue* value, HValue* map)
-      : HTemplateInstruction<2>(HType::HeapObject()) {
-    SetOperandAt(0, value);
-    SetOperandAt(1, map);
-    set_representation(Representation::Tagged());
-    SetFlag(kUseGVN);
-    SetDependsOnFlag(kMaps);
-    SetDependsOnFlag(kElementsKind);
-  }
-};
-
-
-class HForInPrepareMap final : public HTemplateInstruction<2> {
- public:
-  DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P1(HForInPrepareMap, HValue*);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  HValue* context() const { return OperandAt(0); }
-  HValue* enumerable() const { return OperandAt(1); }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  HType CalculateInferredType() override { return HType::Tagged(); }
-
-  DECLARE_CONCRETE_INSTRUCTION(ForInPrepareMap);
-
- private:
-  HForInPrepareMap(HValue* context,
-                   HValue* object) {
-    SetOperandAt(0, context);
-    SetOperandAt(1, object);
-    set_representation(Representation::Tagged());
-    SetAllSideEffects();
-  }
-};
-
-
-class HForInCacheArray final : public HTemplateInstruction<2> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P3(HForInCacheArray, HValue*, HValue*, int);
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  HValue* enumerable() const { return OperandAt(0); }
-  HValue* map() const { return OperandAt(1); }
-  int idx() const { return idx_; }
-
-  HForInCacheArray* index_cache() {
-    return index_cache_;
-  }
-
-  void set_index_cache(HForInCacheArray* index_cache) {
-    index_cache_ = index_cache;
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  HType CalculateInferredType() override { return HType::Tagged(); }
-
-  DECLARE_CONCRETE_INSTRUCTION(ForInCacheArray);
-
- private:
-  HForInCacheArray(HValue* enumerable,
-                   HValue* keys,
-                   int idx) : idx_(idx) {
-    SetOperandAt(0, enumerable);
-    SetOperandAt(1, keys);
-    set_representation(Representation::Tagged());
-  }
-
-  int idx_;
-  HForInCacheArray* index_cache_;
-};
-
-
-class HLoadFieldByIndex final : public HTemplateInstruction<2> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P2(HLoadFieldByIndex, HValue*, HValue*);
-
-  HLoadFieldByIndex(HValue* object,
-                    HValue* index) {
-    SetOperandAt(0, object);
-    SetOperandAt(1, index);
-    SetChangesFlag(kNewSpacePromotion);
-    set_representation(Representation::Tagged());
-  }
-
-  Representation RequiredInputRepresentation(int index) override {
-    if (index == 1) {
-      return Representation::Smi();
-    } else {
-      return Representation::Tagged();
-    }
-  }
-
-  HValue* object() const { return OperandAt(0); }
-  HValue* index() const { return OperandAt(1); }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  HType CalculateInferredType() override { return HType::Tagged(); }
-
-  DECLARE_CONCRETE_INSTRUCTION(LoadFieldByIndex);
-
- private:
-  bool IsDeletable() const override { return true; }
-};
-
-
-class HStoreFrameContext: public HUnaryOperation {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P1(HStoreFrameContext, HValue*);
-
-  HValue* context() { return OperandAt(0); }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  DECLARE_CONCRETE_INSTRUCTION(StoreFrameContext)
- private:
-  explicit HStoreFrameContext(HValue* context)
-      : HUnaryOperation(context) {
-    set_representation(Representation::Tagged());
-    SetChangesFlag(kContextSlots);
-  }
-};
-
-
-class HAllocateBlockContext: public HTemplateInstruction<2> {
- public:
-  DECLARE_INSTRUCTION_FACTORY_P3(HAllocateBlockContext, HValue*,
-                                 HValue*, Handle<ScopeInfo>);
-  HValue* context() const { return OperandAt(0); }
-  HValue* function() const { return OperandAt(1); }
-  Handle<ScopeInfo> scope_info() const { return scope_info_; }
-
-  Representation RequiredInputRepresentation(int index) override {
-    return Representation::Tagged();
-  }
-
-  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
-
-  DECLARE_CONCRETE_INSTRUCTION(AllocateBlockContext)
-
- private:
-  HAllocateBlockContext(HValue* context,
-                        HValue* function,
-                        Handle<ScopeInfo> scope_info)
-      : scope_info_(scope_info) {
-    SetOperandAt(0, context);
-    SetOperandAt(1, function);
-    set_representation(Representation::Tagged());
-  }
-
-  Handle<ScopeInfo> scope_info_;
-};
-
-
-
-#undef DECLARE_INSTRUCTION
-#undef DECLARE_CONCRETE_INSTRUCTION
-
-}  // namespace internal
-}  // namespace v8
-
-#endif  // V8_HYDROGEN_INSTRUCTIONS_H_