Replace OVERRIDE->override and FINAL->final since we now require C++11.

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>
 
@@ skipping 172 matching lines @@
   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; } \
+  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; \
+  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; }
+  Opcode opcode() const final { return HValue::k##type; }
 
 
 enum PropertyAccessType { LOAD, STORE };
 
 
-class Range FINAL : public ZoneObject {
+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),
@@ skipping 83 matching lines @@
 
  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 {
+class HUseIterator final BASE_EMBEDDED {
  public:
   bool Done() { return current_ == NULL; }
   void Advance();
 
   HValue* value() {
     DCHECK(!Done());
     return value_;
   }
 
   int index() {
@@ skipping 28 matching lines @@
 };
 
 
 static inline GVNFlag GVNFlagFromInt(int i) {
   DCHECK(i >= 0);
   DCHECK(i < kNumberOfFlags);
   return static_cast<GVNFlag>(i);
 }
 
 
-class DecompositionResult FINAL BASE_EMBEDDED {
+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;
@@ skipping 679 matching lines @@
 
   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
+  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 {
+  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 {
+  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;
+  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(); }
+  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]; }
+  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; }
+  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
+  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 {
+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 {
+  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]; }
+  int OperandCount() const override { return V; }
+  HValue* OperandAt(int i) const override { return inputs_[i]; }
 
 
  protected:
-  void InternalSetOperandAt(int i, HValue* value) OVERRIDE {
+  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> {
+class HBlockEntry final : public HTemplateInstruction<0> {
  public:
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::None();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(BlockEntry)
 };
 
 
-class HDummyUse FINAL : public HTemplateInstruction<1> {
+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 {
+  bool HasEscapingOperandAt(int index) override { return false; }
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::None();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  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> {
+class HDebugBreak final : public HTemplateInstruction<0> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P0(HDebugBreak);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::None();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(DebugBreak)
 };
 
 
-class HGoto FINAL : public HTemplateControlInstruction<1, 0> {
+class HGoto final : public HTemplateControlInstruction<1, 0> {
  public:
   explicit HGoto(HBasicBlock* target) {
     SetSuccessorAt(0, target);
   }
 
-  bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE {
+  bool KnownSuccessorBlock(HBasicBlock** block) override {
     *block = FirstSuccessor();
     return true;
   }
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::None();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   DECLARE_CONCRETE_INSTRUCTION(Goto)
 };
 
 
-class HDeoptimize FINAL : public HTemplateControlInstruction<1, 0> {
+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 {
+  bool KnownSuccessorBlock(HBasicBlock** block) override {
     *block = NULL;
     return true;
   }
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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,
@@ skipping 11 matching lines @@
 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
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   HValue* value() const { return OperandAt(0); }
 };
 
 
-class HBranch FINAL : public HUnaryControlInstruction {
+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 {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::None();
   }
-  Representation observed_input_representation(int index) OVERRIDE;
+  Representation observed_input_representation(int index) override;
 
-  bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+  bool KnownSuccessorBlock(HBasicBlock** block) override;
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  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 {
+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 {
+  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
+  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 {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(CompareMap)
 
  protected:
-  int RedefinedOperandIndex() OVERRIDE { return 0; }
+  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> {
+class HContext final : public HTemplateInstruction<0> {
  public:
   static HContext* New(Zone* zone) {
     return new(zone) HContext();
   }
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::None();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Context)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE { return true; }
+  bool DataEquals(HValue* other) override { return true; }
 
  private:
   HContext() {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
   }
 
-  bool IsDeletable() const OVERRIDE { return true; }
+  bool IsDeletable() const override { return true; }
 };
 
 
-class HReturn FINAL : public HTemplateControlInstruction<0, 3> {
+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 {
+  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
+  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> {
+class HAbnormalExit final : public HTemplateControlInstruction<0, 0> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P0(HAbnormalExit);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 };
 
 
-class HUseConst FINAL : public HUnaryOperation {
+class HUseConst final : public HUnaryOperation {
  public:
   DECLARE_INSTRUCTION_FACTORY_P1(HUseConst, HValue*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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> {
+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 {
+  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 {
+  Representation RequiredInputRepresentation(int index) override {
     return representation();  // Same as the output representation.
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  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 {
+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;
+  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 {
+  Representation RequiredInputRepresentation(int index) override {
     return from();
   }
 
-  Range* InferRange(Zone* zone) OVERRIDE;
+  Range* InferRange(Zone* zone) override;
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   DECLARE_CONCRETE_INSTRUCTION(Change)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE { return true; }
+  bool DataEquals(HValue* other) override { return true; }
 
  private:
-  bool IsDeletable() const OVERRIDE {
+  bool IsDeletable() const override {
     return !from().IsTagged() || value()->type().IsSmi();
   }
 };
 
 
-class HClampToUint8 FINAL : public HUnaryOperation {
+class HClampToUint8 final : public HUnaryOperation {
  public:
   DECLARE_INSTRUCTION_FACTORY_P1(HClampToUint8, HValue*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::None();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(ClampToUint8)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE { return true; }
+  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; }
+  bool IsDeletable() const override { return true; }
 };
 
 
-class HDoubleBits FINAL : public HUnaryOperation {
+class HDoubleBits final : public HUnaryOperation {
  public:
   enum Bits { HIGH, LOW };
   DECLARE_INSTRUCTION_FACTORY_P2(HDoubleBits, HValue*, Bits);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Double();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(DoubleBits)
 
   Bits bits() { return bits_; }
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE {
+  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; }
+  bool IsDeletable() const override { return true; }
 
   Bits bits_;
 };
 
 
-class HConstructDouble FINAL : public HTemplateInstruction<2> {
+class HConstructDouble final : public HTemplateInstruction<2> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P2(HConstructDouble, HValue*, HValue*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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; }
+  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; }
+  bool IsDeletable() const override { return true; }
 };
 
 
 enum RemovableSimulate {
   REMOVABLE_SIMULATE,
   FIXED_SIMULATE
 };
 
 
-class HSimulate FINAL : public HInstruction {
+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
+  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]; }
+  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 {
+  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 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 {
+  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
@@ skipping 22 matching lines @@
   ZoneList<int> assigned_indexes_;
   Zone* zone_;
   uint32_t bit_field_;
 
 #ifdef DEBUG
   Handle<JSFunction> closure_;
 #endif
 };
 
 
-class HEnvironmentMarker FINAL : public HTemplateInstruction<1> {
+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 {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::None();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  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> {
+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 {
+  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);
     }
   }
@@ skipping 18 matching lines @@
   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> {
+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
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   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 {
+  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,
@@ skipping 20 matching lines @@
   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> {
+class HLeaveInlined final : public HTemplateInstruction<0> {
  public:
   HLeaveInlined(HEnterInlined* entry,
                 int drop_count)
       : entry_(entry),
         drop_count_(drop_count) { }
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::None();
   }
 
-  int argument_delta() const OVERRIDE {
+  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 {
+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;
   }
@@ skipping 16 matching lines @@
                              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 {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  int argument_delta() const OVERRIDE { return inputs_.length(); }
+  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]; }
+  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; }
+  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> {
+class HThisFunction final : public HTemplateInstruction<0> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P0(HThisFunction);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::None();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(ThisFunction)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE { return true; }
+  bool DataEquals(HValue* other) override { return true; }
 
  private:
   HThisFunction() {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
   }
 
-  bool IsDeletable() const OVERRIDE { return true; }
+  bool IsDeletable() const override { return true; }
 };
 
 
-class HDeclareGlobals FINAL : public HUnaryOperation {
+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 {
+  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(); }
+  HType CalculateInferredType() final { return HType::Tagged(); }
 
   virtual int argument_count() const {
     return argument_count_;
   }
 
-  int argument_delta() const OVERRIDE { 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 {
+  Representation RequiredInputRepresentation(int index) final {
     return Representation::Tagged();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  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
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  Representation RequiredInputRepresentation(int index) FINAL {
+  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> {
+class HCallJSFunction final : public HCall<1> {
  public:
   static HCallJSFunction* New(Isolate* isolate, Zone* zone, HValue* context,
                               HValue* function, int argument_count,
                               bool pass_argument_count);
 
   HValue* function() const { return OperandAt(0); }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  Representation RequiredInputRepresentation(int index) FINAL {
+  Representation RequiredInputRepresentation(int index) final {
     DCHECK(index == 0);
     return Representation::Tagged();
   }
 
   bool pass_argument_count() const { return pass_argument_count_; }
 
-  bool HasStackCheck() FINAL { return has_stack_check_; }
+  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 pass_argument_count,
                   bool has_stack_check)
       : HCall<1>(argument_count),
         pass_argument_count_(pass_argument_count),
         has_stack_check_(has_stack_check) {
       SetOperandAt(0, function);
   }
 
   bool pass_argument_count_;
   bool has_stack_check_;
 };
 
 
 enum CallMode { NORMAL_CALL, TAIL_CALL };
 
 
-class HCallWithDescriptor FINAL : public HInstruction {
+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) {
     DCHECK(operands.length() == descriptor.GetEnvironmentLength());
     HCallWithDescriptor* res = new (zone) HCallWithDescriptor(
         target, argument_count, descriptor, operands, call_mode, zone);
     return res;
   }
 
-  int OperandCount() const FINAL { return values_.length(); }
-  HValue* OperandAt(int index) const FINAL { return values_[index]; }
+  int OperandCount() const final { return values_.length(); }
+  HValue* OperandAt(int index) const final { return values_[index]; }
 
-  Representation RequiredInputRepresentation(int index) FINAL {
+  Representation RequiredInputRepresentation(int index) final {
     if (index == 0) {
       return Representation::Tagged();
     } else {
       int par_index = index - 1;
       DCHECK(par_index < descriptor_.GetEnvironmentLength());
       return descriptor_.GetParameterRepresentation(par_index);
     }
   }
 
   DECLARE_CONCRETE_INSTRUCTION(CallWithDescriptor)
 
-  HType CalculateInferredType() FINAL { return HType::Tagged(); }
+  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_; }
+  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
+  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_(descriptor.GetEnvironmentLength() + 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);
   }
 
-  void InternalSetOperandAt(int index, HValue* value) FINAL {
+  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 {
+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_ =
@@ skipping 11 matching lines @@
                               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_; }
+  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 {
+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_; }
 
   FeedbackVectorICSlot 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,
                         FeedbackVectorICSlot slot) {
     feedback_vector_ = vector;
     slot_ = slot;
   }
 
   DECLARE_CONCRETE_INSTRUCTION(CallFunction)
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  int argument_delta() const OVERRIDE { return -argument_count(); }
+  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),
         slot_(FeedbackVectorICSlot::Invalid()) {}
   CallFunctionFlags function_flags_;
   Handle<TypeFeedbackVector> feedback_vector_;
   FeedbackVectorICSlot slot_;
 };
 
 
-class HCallNew FINAL : public HBinaryCall {
+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 {
+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
+  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> {
+class HCallRuntime final : public HCall<1> {
  public:
   DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HCallRuntime,
                                               Handle<String>,
                                               const Runtime::Function*,
                                               int);
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   HValue* context() { return OperandAt(0); }
   const Runtime::Function* function() const { return c_function_; }
   Handle<String> name() const { return name_; }
   SaveFPRegsMode save_doubles() const { return save_doubles_; }
   void set_save_doubles(SaveFPRegsMode save_doubles) {
     save_doubles_ = save_doubles;
   }
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(CallRuntime)
 
  private:
   HCallRuntime(HValue* context,
                Handle<String> name,
                const Runtime::Function* c_function,
                int argument_count)
       : HCall<1>(argument_count), c_function_(c_function), name_(name),
         save_doubles_(kDontSaveFPRegs) {
     SetOperandAt(0, context);
   }
 
   const Runtime::Function* c_function_;
   Handle<String> name_;
   SaveFPRegsMode save_doubles_;
 };
 
 
-class HMapEnumLength FINAL : public HUnaryOperation {
+class HMapEnumLength final : public HUnaryOperation {
  public:
   DECLARE_INSTRUCTION_FACTORY_P1(HMapEnumLength, HValue*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(MapEnumLength)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE { return true; }
+  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; }
+  bool IsDeletable() const override { return true; }
 };
 
 
-class HUnaryMathOperation FINAL : public HTemplateInstruction<2> {
+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
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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;
+  Range* InferRange(Zone* zone) override;
 
-  HValue* Canonicalize() OVERRIDE;
-  Representation RepresentationFromUses() OVERRIDE;
-  Representation RepresentationFromInputs() 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 {
+  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
@@ skipping 33 matching lines @@
       case kMathPowHalf:
         set_representation(Representation::Double());
         break;
       default:
         UNREACHABLE();
     }
     SetFlag(kUseGVN);
     SetFlag(kAllowUndefinedAsNaN);
   }
 
-  bool IsDeletable() const OVERRIDE { return true; }
+  bool IsDeletable() const override { return true; }
 
   HValue* SimplifiedDividendForMathFloorOfDiv(HDiv* hdiv);
   HValue* SimplifiedDivisorForMathFloorOfDiv(HDiv* hdiv);
 
   BuiltinFunctionId op_;
 };
 
 
-class HLoadRoot FINAL : public HTemplateInstruction<0> {
+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 {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::None();
   }
 
   Heap::RootListIndex index() const { return index_; }
 
   DECLARE_CONCRETE_INSTRUCTION(LoadRoot)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE {
+  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; }
+  bool IsDeletable() const override { return true; }
 
   const Heap::RootListIndex index_;
 };
 
 
-class HCheckMaps FINAL : public HTemplateInstruction<2> {
+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 {
+  bool HasEscapingOperandAt(int index) override { return false; }
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  HType CalculateInferredType() OVERRIDE {
+  HType CalculateInferredType() override {
     if (value()->type().IsHeapObject()) return value()->type();
     return HType::HeapObject();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  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;
+  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 {
+  bool DataEquals(HValue* other) override {
     return this->maps()->Equals(HCheckMaps::cast(other)->maps());
   }
 
-  int RedefinedOperandIndex() OVERRIDE { return 0; }
+  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);
@@ skipping 33 matching lines @@
 
   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 {
+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 {
+  void FinalizeUniqueness() override {
     object_ = Unique<HeapObject>(object_.handle());
   }
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  HValue* Canonicalize() OVERRIDE;
+  HValue* Canonicalize() override;
 
 #ifdef DEBUG
-  void Verify() OVERRIDE;
+  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 {
+  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 {
+class HCheckInstanceType final : public HUnaryOperation {
  public:
   enum Check {
     IS_SPEC_OBJECT,
     IS_JS_ARRAY,
     IS_STRING,
     IS_INTERNALIZED_STRING,
     LAST_INTERVAL_CHECK = IS_JS_ARRAY
   };
 
   DECLARE_INSTRUCTION_FACTORY_P2(HCheckInstanceType, HValue*, Check);
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  HType CalculateInferredType() OVERRIDE {
+  HType CalculateInferredType() override {
     switch (check_) {
       case IS_SPEC_OBJECT: return HType::JSObject();
       case IS_JS_ARRAY: return HType::JSArray();
       case IS_STRING: return HType::String();
       case IS_INTERNALIZED_STRING: return HType::String();
     }
     UNREACHABLE();
     return HType::Tagged();
   }
 
-  HValue* Canonicalize() OVERRIDE;
+  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 {
+  bool DataEquals(HValue* other) override {
     HCheckInstanceType* b = HCheckInstanceType::cast(other);
     return check_ == b->check_;
   }
 
-  int RedefinedOperandIndex() OVERRIDE { return 0; }
+  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 {
+class HCheckSmi final : public HUnaryOperation {
  public:
   DECLARE_INSTRUCTION_FACTORY_P1(HCheckSmi, HValue*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  HValue* Canonicalize() OVERRIDE {
+  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; }
+  bool DataEquals(HValue* other) override { return true; }
 
  private:
   explicit HCheckSmi(HValue* value) : HUnaryOperation(value, HType::Smi()) {
     set_representation(Representation::Smi());
     SetFlag(kUseGVN);
   }
 };
 
 
-class HCheckHeapObject FINAL : public HUnaryOperation {
+class HCheckHeapObject final : public HUnaryOperation {
  public:
   DECLARE_INSTRUCTION_FACTORY_P1(HCheckHeapObject, HValue*);
 
-  bool HasEscapingOperandAt(int index) OVERRIDE { return false; }
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  bool HasEscapingOperandAt(int index) override { return false; }
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  HType CalculateInferredType() OVERRIDE {
+  HType CalculateInferredType() override {
     if (value()->type().IsHeapObject()) return value()->type();
     return HType::HeapObject();
   }
 
 #ifdef DEBUG
-  void Verify() OVERRIDE;
+  void Verify() override;
 #endif
 
-  HValue* Canonicalize() OVERRIDE {
+  HValue* Canonicalize() override {
     return value()->type().IsHeapObject() ? NULL : this;
   }
 
   DECLARE_CONCRETE_INSTRUCTION(CheckHeapObject)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE { return true; }
+  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 {
+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_;
     }
@@ skipping 179 matching lines @@
   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 {
+class HPhi final : public HValue {
  public:
   HPhi(int merged_index, Zone* zone)
       : inputs_(2, zone),
         merged_index_(merged_index),
         phi_id_(-1),
         induction_variable_data_(NULL) {
     for (int i = 0; i < Representation::kNumRepresentations; i++) {
       non_phi_uses_[i] = 0;
       indirect_uses_[i] = 0;
     }
     DCHECK(merged_index >= 0 || merged_index == kInvalidMergedIndex);
     SetFlag(kFlexibleRepresentation);
     SetFlag(kAllowUndefinedAsNaN);
   }
 
-  Representation RepresentationFromInputs() OVERRIDE;
+  Representation RepresentationFromInputs() override;
 
-  Range* InferRange(Zone* zone) OVERRIDE;
-  virtual void InferRepresentation(
-      HInferRepresentationPhase* h_infer) OVERRIDE;
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Range* InferRange(Zone* zone) override;
+  virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
+  Representation RequiredInputRepresentation(int index) override {
     return representation();
   }
-  Representation KnownOptimalRepresentation() OVERRIDE {
+  Representation KnownOptimalRepresentation() override {
     return representation();
   }
-  HType CalculateInferredType() OVERRIDE;
-  int OperandCount() const OVERRIDE { return inputs_.length(); }
-  HValue* OperandAt(int index) const OVERRIDE { return inputs_[index]; }
+  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;
+  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
+  std::ostream& PrintTo(std::ostream& os) const override;  // NOLINT
 
 #ifdef DEBUG
-  void Verify() OVERRIDE;
+  void Verify() override;
 #endif
 
   void InitRealUses(int id);
   void AddNonPhiUsesFrom(HPhi* other);
   void AddIndirectUsesTo(int* use_count);
 
   int tagged_non_phi_uses() const {
     return non_phi_uses_[Representation::kTagged];
   }
   int smi_non_phi_uses() const {
@@ skipping 16 matching lines @@
   }
   int double_indirect_uses() const {
     return indirect_uses_[Representation::kDouble];
   }
   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; }
+  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 {
+  void DeleteFromGraph() override;
+  void InternalSetOperandAt(int index, HValue* value) override {
     inputs_[index] = value;
   }
 
  private:
   ZoneList<HValue*> inputs_;
   int merged_index_;
 
   int non_phi_uses_[Representation::kNumRepresentations];
   int indirect_uses_[Representation::kNumRepresentations];
   int phi_id_;
   InductionVariableData* induction_variable_data_;
 
   // TODO(titzer): we can't eliminate the receiver for generating backtraces
-  bool IsDeletable() const OVERRIDE { return !IsReceiver(); }
+  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]; }
+  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 {
+  bool HasEscapingOperandAt(int index) final { return false; }
+  Representation RequiredInputRepresentation(int index) final {
     return Representation::None();
   }
 
  protected:
-  void InternalSetOperandAt(int index, HValue* value) FINAL {
+  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 {
+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 {
+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
+  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; }
+  bool IsDeletable() const final { return false; }
 };
 
 
-class HConstant FINAL : public HTemplateInstruction<0> {
+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<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,
@@ skipping 44 matching lines @@
     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 {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::None();
   }
 
-  Representation KnownOptimalRepresentation() OVERRIDE {
+  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
+  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_;
   }
@@ skipping 65 matching lines @@
     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 {
+  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 {
+  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 {
+  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 {}
+  void Verify() override {}
 #endif
 
   DECLARE_CONCRETE_INSTRUCTION(Constant)
 
  protected:
-  Range* InferRange(Zone* zone) OVERRIDE;
+  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; }
+  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> {};
@@ skipping 67 matching lines @@
 
   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 {
+  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 {
+                                    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;
+  virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
+  Representation RepresentationFromInputs() override;
   Representation RepresentationFromOutput();
-  void AssumeRepresentation(Representation r) OVERRIDE;
+  void AssumeRepresentation(Representation r) override;
 
   virtual bool IsCommutative() const { return false; }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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));
   }
 
   DECLARE_ABSTRACT_INSTRUCTION(BinaryOperation)
 
  private:
   bool IgnoreObservedOutputRepresentation(Representation current_rep);
 
   Representation observed_input_representation_[2];
   Representation observed_output_representation_;
 };
 
 
-class HWrapReceiver FINAL : public HTemplateInstruction<2> {
+class HWrapReceiver final : public HTemplateInstruction<2> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P2(HWrapReceiver, HValue*, HValue*);
 
-  bool DataEquals(HValue* other) OVERRIDE { return true; }
+  bool DataEquals(HValue* other) override { return true; }
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
   HValue* receiver() const { return OperandAt(0); }
   HValue* function() const { return OperandAt(1); }
 
-  HValue* Canonicalize() OVERRIDE;
+  HValue* Canonicalize() override;
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  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> {
+class HApplyArguments final : public HTemplateInstruction<4> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P4(HApplyArguments, HValue*, HValue*, HValue*,
                                  HValue*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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> {
+class HArgumentsElements final : public HTemplateInstruction<0> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P1(HArgumentsElements, bool);
 
   DECLARE_CONCRETE_INSTRUCTION(ArgumentsElements)
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::None();
   }
 
   bool from_inlined() const { return from_inlined_; }
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE { return true; }
+  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 IsDeletable() const override { return true; }
 
   bool from_inlined_;
 };
 
 
-class HArgumentsLength FINAL : public HUnaryOperation {
+class HArgumentsLength final : public HUnaryOperation {
  public:
   DECLARE_INSTRUCTION_FACTORY_P1(HArgumentsLength, HValue*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(ArgumentsLength)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE { return true; }
+  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; }
+  bool IsDeletable() const override { return true; }
 };
 
 
-class HAccessArgumentsAt FINAL : public HTemplateInstruction<3> {
+class HAccessArgumentsAt final : public HTemplateInstruction<3> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P3(HAccessArgumentsAt, HValue*, HValue*, HValue*);
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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; }
+  bool DataEquals(HValue* other) override { return true; }
 };
 
 
 class HBoundsCheckBaseIndexInformation;
 
 
-class HBoundsCheck FINAL : public HTemplateInstruction<2> {
+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 {
+  Representation RequiredInputRepresentation(int index) override {
     return representation();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
-  virtual void InferRepresentation(
-      HInferRepresentationPhase* h_infer) OVERRIDE;
+  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(); }
+  int RedefinedOperandIndex() override { return 0; }
+  bool IsPurelyInformativeDefinition() override { return skip_check(); }
 
   DECLARE_CONCRETE_INSTRUCTION(BoundsCheck)
 
  protected:
   friend class HBoundsCheckBaseIndexInformation;
 
-  Range* InferRange(Zone* zone) OVERRIDE;
+  Range* InferRange(Zone* zone) override;
 
-  bool DataEquals(HValue* other) OVERRIDE { return true; }
+  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; }
+  bool IsDeletable() const override { return skip_check() && !FLAG_debug_code; }
 };
 
 
-class HBoundsCheckBaseIndexInformation FINAL
-    : public HTemplateInstruction<2> {
+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 {
+  Representation RequiredInputRepresentation(int index) override {
     return representation();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  int RedefinedOperandIndex() OVERRIDE { return 0; }
-  bool IsPurelyInformativeDefinition() OVERRIDE { return true; }
+  int RedefinedOperandIndex() override { return 0; }
+  bool IsPurelyInformativeDefinition() override { return true; }
 };
 
 
 class HBitwiseBinaryOperation : public HBinaryOperation {
  public:
   HBitwiseBinaryOperation(HValue* context, HValue* left, HValue* right,
                           HType type = HType::TaggedNumber())
       : HBinaryOperation(context, left, right, type) {
     SetFlag(kFlexibleRepresentation);
     SetFlag(kTruncatingToInt32);
     SetFlag(kAllowUndefinedAsNaN);
     SetAllSideEffects();
   }
 
-  void RepresentationChanged(Representation to) OVERRIDE {
+  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 {
+                                    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 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 {
+      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; }
+  bool IsDeletable() const override { return true; }
 };
 
 
-class HMathFloorOfDiv FINAL : public HBinaryOperation {
+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; }
+  bool DataEquals(HValue* other) override { return true; }
 
  private:
   HMathFloorOfDiv(HValue* context, HValue* left, HValue* right)
       : HBinaryOperation(context, left, right) {
     set_representation(Representation::Integer32());
     SetFlag(kUseGVN);
     SetFlag(kCanOverflow);
     SetFlag(kCanBeDivByZero);
     SetFlag(kLeftCanBeMinInt);
     SetFlag(kLeftCanBeNegative);
     SetFlag(kLeftCanBePositive);
     SetFlag(kAllowUndefinedAsNaN);
   }
 
-  Range* InferRange(Zone* zone) OVERRIDE;
+  Range* InferRange(Zone* zone) override;
 
-  bool IsDeletable() const OVERRIDE { return true; }
+  bool IsDeletable() const override { return true; }
 };
 
 
 class HArithmeticBinaryOperation : public HBinaryOperation {
  public:
   HArithmeticBinaryOperation(HValue* context, HValue* left, HValue* right)
       : HBinaryOperation(context, left, right, HType::TaggedNumber()) {
     SetAllSideEffects();
     SetFlag(kFlexibleRepresentation);
     SetFlag(kAllowUndefinedAsNaN);
   }
 
-  void RepresentationChanged(Representation to) OVERRIDE {
+  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; }
+  bool IsDeletable() const override { return true; }
 };
 
 
-class HCompareGeneric FINAL : public HBinaryOperation {
+class HCompareGeneric final : public HBinaryOperation {
  public:
   DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HCompareGeneric, HValue*,
                                               HValue*, Token::Value);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   DECLARE_CONCRETE_INSTRUCTION(CompareGeneric)
 
  private:
   HCompareGeneric(HValue* context,
                   HValue* left,
                   HValue* right,
                   Token::Value token)
       : HBinaryOperation(context, left, right, HType::Boolean()),
         token_(token) {
@@ skipping 17 matching lines @@
   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;
+  virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return representation();
   }
-  Representation observed_input_representation(int index) OVERRIDE {
+  Representation observed_input_representation(int index) override {
     return observed_input_representation_[index];
   }
 
-  bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+  bool KnownSuccessorBlock(HBasicBlock** block) override;
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  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 = NULL,
                            HBasicBlock* false_target = NULL)
       : token_(token) {
     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_;
 };
 
 
-class HCompareHoleAndBranch FINAL : public HUnaryControlInstruction {
+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;
+  virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
 
-  Representation RequiredInputRepresentation(int index) 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 {
+class HCompareMinusZeroAndBranch final : public HUnaryControlInstruction {
  public:
   DECLARE_INSTRUCTION_FACTORY_P1(HCompareMinusZeroAndBranch, HValue*);
 
-  virtual void InferRepresentation(
-      HInferRepresentationPhase* h_infer) OVERRIDE;
+  virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return representation();
   }
 
-  bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+  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;
+  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
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  Representation observed_input_representation(int index) OVERRIDE {
+  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 HIsObjectAndBranch FINAL : public HUnaryControlInstruction {
+class HIsObjectAndBranch final : public HUnaryControlInstruction {
  public:
   DECLARE_INSTRUCTION_FACTORY_P1(HIsObjectAndBranch, HValue*);
   DECLARE_INSTRUCTION_FACTORY_P3(HIsObjectAndBranch, HValue*,
                                  HBasicBlock*, HBasicBlock*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+  bool KnownSuccessorBlock(HBasicBlock** block) override;
 
   DECLARE_CONCRETE_INSTRUCTION(IsObjectAndBranch)
 
  private:
   HIsObjectAndBranch(HValue* value,
                      HBasicBlock* true_target = NULL,
                      HBasicBlock* false_target = NULL)
     : HUnaryControlInstruction(value, true_target, false_target) {}
 };
 
 
-class HIsStringAndBranch FINAL : public HUnaryControlInstruction {
+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 {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+  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; }
+  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 {
+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 {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE { return true; }
-  int RedefinedOperandIndex() OVERRIDE { return 0; }
+  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 {
+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 {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+  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 : public HTemplateControlInstruction<2, 3> {
  public:
   DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HStringCompareAndBranch,
                                               HValue*,
                                               HValue*,
                                               Token::Value);
 
   HValue* context() { return OperandAt(0); }
   HValue* left() { return OperandAt(1); }
   HValue* right() { return OperandAt(2); }
   Token::Value token() const { return token_; }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
   Representation GetInputRepresentation() const {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(StringCompareAndBranch)
 
  private:
@@ skipping 11 matching lines @@
   }
 
   Token::Value token_;
 };
 
 
 class HIsConstructCallAndBranch : public HTemplateControlInstruction<2, 0> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P0(HIsConstructCallAndBranch);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::None();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(IsConstructCallAndBranch)
  private:
   HIsConstructCallAndBranch() {}
 };
 
 
-class HHasInstanceTypeAndBranch FINAL : public HUnaryControlInstruction {
+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
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+  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 {
+class HHasCachedArrayIndexAndBranch final : public HUnaryControlInstruction {
  public:
   DECLARE_INSTRUCTION_FACTORY_P1(HHasCachedArrayIndexAndBranch, HValue*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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 {
+class HGetCachedArrayIndex final : public HUnaryOperation {
  public:
   DECLARE_INSTRUCTION_FACTORY_P1(HGetCachedArrayIndex, HValue*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(GetCachedArrayIndex)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE { return true; }
+  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; }
+  bool IsDeletable() const override { return true; }
 };
 
 
-class HClassOfTestAndBranch FINAL : public HUnaryControlInstruction {
+class HClassOfTestAndBranch final : public HUnaryControlInstruction {
  public:
   DECLARE_INSTRUCTION_FACTORY_P2(HClassOfTestAndBranch, HValue*,
                                  Handle<String>);
 
   DECLARE_CONCRETE_INSTRUCTION(ClassOfTestAndBranch)
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  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 {
+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
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   DECLARE_CONCRETE_INSTRUCTION(TypeofIsAndBranch)
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::None();
   }
 
-  bool KnownSuccessorBlock(HBasicBlock** block) OVERRIDE;
+  bool KnownSuccessorBlock(HBasicBlock** block) override;
 
-  void FinalizeUniqueness() 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 {
+class HInstanceOf final : public HBinaryOperation {
  public:
   DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HInstanceOf, HValue*, HValue*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  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, HType::Boolean()) {
     set_representation(Representation::Tagged());
     SetAllSideEffects();
   }
 };
 
 
-class HInstanceOfKnownGlobal FINAL : public HTemplateInstruction<2> {
+class HInstanceOfKnownGlobal final : public HTemplateInstruction<2> {
  public:
   DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HInstanceOfKnownGlobal,
                                               HValue*,
                                               Handle<JSFunction>);
 
   HValue* context() { return OperandAt(0); }
   HValue* left() { return OperandAt(1); }
   Handle<JSFunction> function() { return function_; }
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(InstanceOfKnownGlobal)
 
  private:
   HInstanceOfKnownGlobal(HValue* context,
                          HValue* left,
                          Handle<JSFunction> right)
       : HTemplateInstruction<2>(HType::Boolean()), function_(right) {
     SetOperandAt(0, context);
     SetOperandAt(1, left);
     set_representation(Representation::Tagged());
     SetAllSideEffects();
   }
 
   Handle<JSFunction> function_;
 };
 
 
-class HPower FINAL : public HTemplateInstruction<2> {
+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 {
+  Representation RequiredInputRepresentation(int index) override {
     return index == 0
       ? Representation::Double()
       : Representation::None();
   }
-  Representation observed_input_representation(int index) OVERRIDE {
+  Representation observed_input_representation(int index) override {
     return RequiredInputRepresentation(index);
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Power)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE { return true; }
+  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 {
+  bool IsDeletable() const override {
     return !right()->representation().IsTagged();
   }
 };
 
 
-class HAdd FINAL : public HArithmeticBinaryOperation {
+class HAdd final : public HArithmeticBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right);
 
   // 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 {
+  bool IsCommutative() const override {
     return !representation().IsTagged() && !representation().IsExternal();
   }
 
-  HValue* Canonicalize() OVERRIDE;
+  HValue* Canonicalize() override;
 
-  bool TryDecompose(DecompositionResult* decomposition) 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 {
+  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 RepresentationFromInputs() override;
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE;
+  Representation RequiredInputRepresentation(int index) override;
 
   DECLARE_CONCRETE_INSTRUCTION(Add)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE { return true; }
+  bool DataEquals(HValue* other) override { return true; }
 
-  Range* InferRange(Zone* zone) OVERRIDE;
+  Range* InferRange(Zone* zone) override;
 
  private:
   HAdd(HValue* context, HValue* left, HValue* right)
       : HArithmeticBinaryOperation(context, left, right) {
     SetFlag(kCanOverflow);
   }
 };
 
 
-class HSub FINAL : public HArithmeticBinaryOperation {
+class HSub final : public HArithmeticBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right);
 
-  HValue* Canonicalize() OVERRIDE;
+  HValue* Canonicalize() override;
 
-  bool TryDecompose(DecompositionResult* decomposition) 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; }
+  bool DataEquals(HValue* other) override { return true; }
 
-  Range* InferRange(Zone* zone) OVERRIDE;
+  Range* InferRange(Zone* zone) override;
 
  private:
   HSub(HValue* context, HValue* left, HValue* right)
       : HArithmeticBinaryOperation(context, left, right) {
     SetFlag(kCanOverflow);
   }
 };
 
 
-class HMul FINAL : public HArithmeticBinaryOperation {
+class HMul final : public HArithmeticBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right);
 
   static HInstruction* NewImul(Isolate* isolate, Zone* zone, HValue* context,
                                HValue* left, HValue* right) {
     HInstruction* instr = HMul::New(isolate, zone, context, left, right);
     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;
+  HValue* Canonicalize() override;
 
   // Only commutative if it is certain that not two objects are multiplicated.
-  bool IsCommutative() const OVERRIDE { return !representation().IsTagged(); }
+  bool IsCommutative() const override { return !representation().IsTagged(); }
 
   virtual void UpdateRepresentation(Representation new_rep,
                                     HInferRepresentationPhase* h_infer,
-                                    const char* reason) OVERRIDE {
+                                    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; }
+  bool DataEquals(HValue* other) override { return true; }
 
-  Range* InferRange(Zone* zone) OVERRIDE;
+  Range* InferRange(Zone* zone) override;
 
  private:
   HMul(HValue* context, HValue* left, HValue* right)
       : HArithmeticBinaryOperation(context, left, right) {
     SetFlag(kCanOverflow);
   }
 };
 
 
-class HMod FINAL : public HArithmeticBinaryOperation {
+class HMod final : public HArithmeticBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right);
 
-  HValue* Canonicalize() OVERRIDE;
+  HValue* Canonicalize() override;
 
   virtual void UpdateRepresentation(Representation new_rep,
                                     HInferRepresentationPhase* h_infer,
-                                    const char* reason) OVERRIDE {
+                                    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; }
+  bool DataEquals(HValue* other) override { return true; }
 
-  Range* InferRange(Zone* zone) OVERRIDE;
+  Range* InferRange(Zone* zone) override;
 
  private:
   HMod(HValue* context,
        HValue* left,
        HValue* right) : HArithmeticBinaryOperation(context, left, right) {
     SetFlag(kCanBeDivByZero);
     SetFlag(kCanOverflow);
     SetFlag(kLeftCanBeNegative);
   }
 };
 
 
-class HDiv FINAL : public HArithmeticBinaryOperation {
+class HDiv final : public HArithmeticBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right);
 
-  HValue* Canonicalize() OVERRIDE;
+  HValue* Canonicalize() override;
 
   virtual void UpdateRepresentation(Representation new_rep,
                                     HInferRepresentationPhase* h_infer,
-                                    const char* reason) OVERRIDE {
+                                    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; }
+  bool DataEquals(HValue* other) override { return true; }
 
-  Range* InferRange(Zone* zone) OVERRIDE;
+  Range* InferRange(Zone* zone) override;
 
  private:
   HDiv(HValue* context, HValue* left, HValue* right)
       : HArithmeticBinaryOperation(context, left, right) {
     SetFlag(kCanBeDivByZero);
     SetFlag(kCanOverflow);
   }
 };
 
 
-class HMathMinMax FINAL : public HArithmeticBinaryOperation {
+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 {
+  Representation observed_input_representation(int index) override {
     return RequiredInputRepresentation(index);
   }
 
-  virtual void InferRepresentation(
-      HInferRepresentationPhase* h_infer) OVERRIDE;
+  virtual void InferRepresentation(HInferRepresentationPhase* h_infer) override;
 
-  Representation RepresentationFromInputs() 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; }
+  bool IsCommutative() const override { return true; }
 
   Operation operation() { return operation_; }
 
   DECLARE_CONCRETE_INSTRUCTION(MathMinMax)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE {
+  bool DataEquals(HValue* other) override {
     return other->IsMathMinMax() &&
         HMathMinMax::cast(other)->operation_ == operation_;
   }
 
-  Range* InferRange(Zone* zone) OVERRIDE;
+  Range* InferRange(Zone* zone) override;
 
  private:
   HMathMinMax(HValue* context, HValue* left, HValue* right, Operation op)
       : HArithmeticBinaryOperation(context, left, right),
         operation_(op) { }
 
   Operation operation_;
 };
 
 
-class HBitwise FINAL : public HBitwiseBinaryOperation {
+class HBitwise final : public HBitwiseBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            Token::Value op, HValue* left, HValue* right);
 
   Token::Value op() const { return op_; }
 
-  bool IsCommutative() const OVERRIDE { return true; }
+  bool IsCommutative() const override { return true; }
 
-  HValue* Canonicalize() OVERRIDE;
+  HValue* Canonicalize() override;
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   DECLARE_CONCRETE_INSTRUCTION(Bitwise)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE {
+  bool DataEquals(HValue* other) override {
     return op() == HBitwise::cast(other)->op();
   }
 
-  Range* InferRange(Zone* zone) OVERRIDE;
+  Range* InferRange(Zone* zone) override;
 
  private:
   HBitwise(HValue* context,
            Token::Value op,
            HValue* left,
            HValue* right)
       : HBitwiseBinaryOperation(context, left, right),
         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
@@ skipping 18 matching lines @@
           HConstant::cast(right)->Integer32Value() < 0))) {
       SetFlag(kTruncatingToSmi);
       SetFlag(kTruncatingToInt32);
     }
   }
 
   Token::Value op_;
 };
 
 
-class HShl FINAL : public HBitwiseBinaryOperation {
+class HShl final : public HBitwiseBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right);
 
-  Range* InferRange(Zone* zone) OVERRIDE;
+  Range* InferRange(Zone* zone) override;
 
   virtual void UpdateRepresentation(Representation new_rep,
                                     HInferRepresentationPhase* h_infer,
-                                    const char* reason) OVERRIDE {
+                                    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; }
+  bool DataEquals(HValue* other) override { return true; }
 
  private:
   HShl(HValue* context, HValue* left, HValue* right)
       : HBitwiseBinaryOperation(context, left, right) { }
 };
 
 
-class HShr FINAL : public HBitwiseBinaryOperation {
+class HShr final : public HBitwiseBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right);
 
-  bool TryDecompose(DecompositionResult* decomposition) OVERRIDE {
+  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;
+  Range* InferRange(Zone* zone) override;
 
   virtual void UpdateRepresentation(Representation new_rep,
                                     HInferRepresentationPhase* h_infer,
-                                    const char* reason) OVERRIDE {
+                                    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; }
+  bool DataEquals(HValue* other) override { return true; }
 
  private:
   HShr(HValue* context, HValue* left, HValue* right)
       : HBitwiseBinaryOperation(context, left, right) { }
 };
 
 
-class HSar FINAL : public HBitwiseBinaryOperation {
+class HSar final : public HBitwiseBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right);
 
-  bool TryDecompose(DecompositionResult* decomposition) OVERRIDE {
+  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;
+  Range* InferRange(Zone* zone) override;
 
   virtual void UpdateRepresentation(Representation new_rep,
                                     HInferRepresentationPhase* h_infer,
-                                    const char* reason) OVERRIDE {
+                                    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; }
+  bool DataEquals(HValue* other) override { return true; }
 
  private:
   HSar(HValue* context, HValue* left, HValue* right)
       : HBitwiseBinaryOperation(context, left, right) { }
 };
 
 
-class HRor FINAL : public HBitwiseBinaryOperation {
+class HRor final : public HBitwiseBinaryOperation {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* left, HValue* right) {
     return new(zone) HRor(context, left, right);
   }
 
   virtual void UpdateRepresentation(Representation new_rep,
                                     HInferRepresentationPhase* h_infer,
-                                    const char* reason) OVERRIDE {
+                                    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; }
+  bool DataEquals(HValue* other) override { return true; }
 
  private:
   HRor(HValue* context, HValue* left, HValue* right)
        : HBitwiseBinaryOperation(context, left, right) {
     ChangeRepresentation(Representation::Integer32());
   }
 };
 
 
-class HOsrEntry FINAL : public HTemplateInstruction<0> {
+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 {
+  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> {
+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
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::None();
   }
 
-  Representation KnownOptimalRepresentation() OVERRIDE {
+  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 {
+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
+  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 HTailCallThroughMegamorphicCache FINAL : public HInstruction {
+class HTailCallThroughMegamorphicCache final : public HInstruction {
  public:
   DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HTailCallThroughMegamorphicCache,
                                               HValue*, HValue*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  virtual int OperandCount() const FINAL OVERRIDE { return 3; }
-  virtual HValue* OperandAt(int i) const FINAL OVERRIDE { return inputs_[i]; }
+  virtual int OperandCount() const final override { return 3; }
+  virtual HValue* OperandAt(int i) const final override { return inputs_[i]; }
 
   HValue* context() const { return OperandAt(0); }
   HValue* receiver() const { return OperandAt(1); }
   HValue* name() const { return OperandAt(2); }
   Code::Flags flags() const;
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   DECLARE_CONCRETE_INSTRUCTION(TailCallThroughMegamorphicCache)
 
  protected:
-  virtual void InternalSetOperandAt(int i, HValue* value) FINAL OVERRIDE {
+  virtual void InternalSetOperandAt(int i, HValue* value) final override {
     inputs_[i] = value;
   }
 
  private:
   HTailCallThroughMegamorphicCache(HValue* context, HValue* receiver,
                                    HValue* name) {
     SetOperandAt(0, context);
     SetOperandAt(1, receiver);
     SetOperandAt(2, name);
   }
 
   EmbeddedContainer<HValue*, 3> inputs_;
 };
 
 
-class HUnknownOSRValue FINAL : public HTemplateInstruction<0> {
+class HUnknownOSRValue final : public HTemplateInstruction<0> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P2(HUnknownOSRValue, HEnvironment*, int);
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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 {
+  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> {
+class HLoadGlobalGeneric final : public HTemplateInstruction<2> {
  public:
   DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HLoadGlobalGeneric, HValue*,
                                               Handle<String>, bool);
 
   HValue* context() { return OperandAt(0); }
   HValue* global_object() { return OperandAt(1); }
   Handle<String> name() const { return name_; }
   bool for_typeof() const { return for_typeof_; }
   FeedbackVectorICSlot slot() const { return slot_; }
   Handle<TypeFeedbackVector> feedback_vector() const {
     return feedback_vector_;
   }
   bool HasVectorAndSlot() const { return FLAG_vector_ics; }
   void SetVectorAndSlot(Handle<TypeFeedbackVector> vector,
                         FeedbackVectorICSlot slot) {
     DCHECK(FLAG_vector_ics);
     feedback_vector_ = vector;
     slot_ = slot;
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(LoadGlobalGeneric)
 
  private:
   HLoadGlobalGeneric(HValue* context, HValue* global_object,
                      Handle<String> name, bool for_typeof)
       : name_(name),
         for_typeof_(for_typeof),
         slot_(FeedbackVectorICSlot::Invalid()) {
     SetOperandAt(0, context);
     SetOperandAt(1, global_object);
     set_representation(Representation::Tagged());
     SetAllSideEffects();
   }
 
   Handle<String> name_;
   bool for_typeof_;
   Handle<TypeFeedbackVector> feedback_vector_;
   FeedbackVectorICSlot slot_;
 };
 
 
-class HAllocate FINAL : public HTemplateInstruction<2> {
+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 {
+  Representation RequiredInputRepresentation(int index) override {
     if (index == 0) {
       return Representation::Tagged();
     } else {
       return Representation::Integer32();
     }
   }
 
-  Handle<Map> GetMonomorphicJSObjectMap() OVERRIDE {
+  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;
   }
@@ skipping 16 matching lines @@
 
   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;
+                                         HValue* dominator) override;
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  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
@@ skipping 78 matching lines @@
   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> {
+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 {
+  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> {
+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 {
+  Representation RequiredInputRepresentation(int index) override {
     return index == 0 ? Representation::Tagged() : Representation::Integer32();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  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);
@@ skipping 56 matching lines @@
   }
   if (object == dominator &&
       object->IsAllocate() &&
       HAllocate::cast(object)->IsNewSpaceAllocation()) {
     return kPointersToHereAreAlwaysInteresting;
   }
   return kPointersToHereMaybeInteresting;
 }
 
 
-class HLoadContextSlot FINAL : public HUnaryOperation {
+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
@@ skipping 12 matching lines @@
   Mode mode() const { return mode_; }
 
   bool DeoptimizesOnHole() {
     return mode_ == kCheckDeoptimize;
   }
 
   bool RequiresHoleCheck() const {
     return mode_ != kNoCheck;
   }
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   DECLARE_CONCRETE_INSTRUCTION(LoadContextSlot)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE {
+  bool DataEquals(HValue* other) override {
     HLoadContextSlot* b = HLoadContextSlot::cast(other);
     return (slot_index() == b->slot_index());
   }
 
  private:
-  bool IsDeletable() const OVERRIDE { return !RequiresHoleCheck(); }
+  bool IsDeletable() const override { return !RequiresHoleCheck(); }
 
   int slot_index_;
   Mode mode_;
 };
 
 
-class HStoreContextSlot FINAL : public HTemplateInstruction<2> {
+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,
@@ skipping 14 matching lines @@
   }
 
   bool DeoptimizesOnHole() {
     return mode_ == kCheckDeoptimize;
   }
 
   bool RequiresHoleCheck() {
     return mode_ != kNoCheck;
   }
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  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 {
+class HObjectAccess final {
  public:
   inline bool IsInobject() const {
     return portion() != kBackingStore && portion() != kExternalMemory;
   }
 
   inline bool IsExternalMemory() const {
     return portion() == kExternalMemory;
   }
 
   inline bool IsStringLength() const {
@@ skipping 411 matching lines @@
 
   inline Portion portion() const {
     return PortionField::decode(value_);
   }
 };
 
 
 std::ostream& operator<<(std::ostream& os, const HObjectAccess& access);
 
 
-class HLoadNamedField FINAL : public HTemplateInstruction<2> {
+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 {
+  bool HasEscapingOperandAt(int index) override { return false; }
+  bool HasOutOfBoundsAccess(int size) override {
     return !access().IsInobject() || access().offset() >= size;
   }
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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
+  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 {
+  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,
@@ skipping 43 matching lines @@
     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; }
+  bool IsDeletable() const override { return true; }
 
   HObjectAccess access_;
   const UniqueSet<Map>* maps_;
 };
 
 
-class HLoadNamedGeneric FINAL : public HTemplateInstruction<2> {
+class HLoadNamedGeneric final : public HTemplateInstruction<2> {
  public:
   DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HLoadNamedGeneric, HValue*,
                                               Handle<Object>, InlineCacheState);
 
   HValue* context() const { return OperandAt(0); }
   HValue* object() const { return OperandAt(1); }
   Handle<Object> name() const { return name_; }
 
   InlineCacheState initialization_state() const {
     return initialization_state_;
   }
   FeedbackVectorICSlot slot() const { return slot_; }
   Handle<TypeFeedbackVector> feedback_vector() const {
     return feedback_vector_;
   }
   bool HasVectorAndSlot() const { return FLAG_vector_ics; }
   void SetVectorAndSlot(Handle<TypeFeedbackVector> vector,
                         FeedbackVectorICSlot slot) {
     DCHECK(FLAG_vector_ics);
     feedback_vector_ = vector;
     slot_ = slot;
   }
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   DECLARE_CONCRETE_INSTRUCTION(LoadNamedGeneric)
 
  private:
   HLoadNamedGeneric(HValue* context, HValue* object, Handle<Object> name,
                     InlineCacheState initialization_state)
       : name_(name),
         slot_(FeedbackVectorICSlot::Invalid()),
         initialization_state_(initialization_state) {
     SetOperandAt(0, context);
     SetOperandAt(1, object);
     set_representation(Representation::Tagged());
     SetAllSideEffects();
   }
 
   Handle<Object> name_;
   Handle<TypeFeedbackVector> feedback_vector_;
   FeedbackVectorICSlot slot_;
   InlineCacheState initialization_state_;
 };
 
 
-class HLoadFunctionPrototype FINAL : public HUnaryOperation {
+class HLoadFunctionPrototype final : public HUnaryOperation {
  public:
   DECLARE_INSTRUCTION_FACTORY_P1(HLoadFunctionPrototype, HValue*);
 
   HValue* function() { return OperandAt(0); }
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(LoadFunctionPrototype)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE { return true; }
+  bool DataEquals(HValue* other) override { return true; }
 
  private:
   explicit HLoadFunctionPrototype(HValue* function)
       : HUnaryOperation(function) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     SetDependsOnFlag(kCalls);
   }
 };
 
@@ skipping 16 matching lines @@
 
 
 static const int kDefaultKeyedHeaderOffsetSentinel = -1;
 
 enum LoadKeyedHoleMode {
   NEVER_RETURN_HOLE,
   ALLOW_RETURN_HOLE
 };
 
 
-class HLoadKeyed FINAL
-    : public HTemplateInstruction<3>, public ArrayInstructionInterface {
+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_external() const {
     return IsExternalArrayElementsKind(elements_kind());
   }
   bool is_fixed_typed_array() const {
     return IsFixedTypedArrayElementsKind(elements_kind());
   }
   bool is_typed_elements() const {
     return is_external() || is_fixed_typed_array();
   }
   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 {
+  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 {
+  void SetDehoisted(bool is_dehoisted) override {
     bit_field_ = IsDehoistedField::update(bit_field_, is_dehoisted);
   }
-  ElementsKind elements_kind() const OVERRIDE {
+  ElementsKind elements_kind() const override {
     return ElementsKindField::decode(bit_field_);
   }
   LoadKeyedHoleMode hole_mode() const {
     return HoleModeField::decode(bit_field_);
   }
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     // kind_fast:                 tagged[int32] (none)
     // kind_double:               tagged[int32] (none)
     // kind_fixed_typed_array:    tagged[int32] (none)
     // kind_external:             external[int32] (none)
     if (index == 0) {
       return is_external() ? Representation::External()
           : Representation::Tagged();
     }
     if (index == 1) {
       return ArrayInstructionInterface::KeyedAccessIndexRequirement(
           OperandAt(1)->representation());
     }
     return Representation::None();
   }
 
-  Representation observed_input_representation(int index) OVERRIDE {
+  Representation observed_input_representation(int index) override {
     return RequiredInputRepresentation(index);
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   bool UsesMustHandleHole() const;
   bool AllUsesCanTreatHoleAsNaN() const;
   bool RequiresHoleCheck() const;
 
-  Range* InferRange(Zone* zone) OVERRIDE;
+  Range* InferRange(Zone* zone) override;
 
   DECLARE_CONCRETE_INSTRUCTION(LoadKeyed)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE {
+  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,
@@ skipping 55 matching lines @@
       } else {
         UNREACHABLE();
       }
       // Native code could change the specialized array.
       SetDependsOnFlag(kCalls);
     }
 
     SetFlag(kUseGVN);
   }
 
-  bool IsDeletable() const OVERRIDE { return !RequiresHoleCheck(); }
+  bool IsDeletable() const override { return !RequiresHoleCheck(); }
 
   // Establish some checks around our packed fields
   enum LoadKeyedBits {
     kBitsForElementsKind = 5,
     kBitsForHoleMode = 1,
     kBitsForBaseOffset = 25,
     kBitsForIsDehoisted = 1,
 
     kStartElementsKind = 0,
     kStartHoleMode = kStartElementsKind + kBitsForElementsKind,
@@ skipping 13 matching lines @@
   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> {
+class HLoadKeyedGeneric final : public HTemplateInstruction<3> {
  public:
   DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P3(HLoadKeyedGeneric, HValue*,
                                               HValue*, 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_;
   }
   FeedbackVectorICSlot slot() const { return slot_; }
   Handle<TypeFeedbackVector> feedback_vector() const {
     return feedback_vector_;
   }
   bool HasVectorAndSlot() const {
     DCHECK(!FLAG_vector_ics || initialization_state_ == MEGAMORPHIC ||
            !feedback_vector_.is_null());
     return !feedback_vector_.is_null();
   }
   void SetVectorAndSlot(Handle<TypeFeedbackVector> vector,
                         FeedbackVectorICSlot slot) {
     DCHECK(FLAG_vector_ics);
     feedback_vector_ = vector;
     slot_ = slot;
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     // tagged[tagged]
     return Representation::Tagged();
   }
 
-  HValue* Canonicalize() OVERRIDE;
+  HValue* Canonicalize() override;
 
   DECLARE_CONCRETE_INSTRUCTION(LoadKeyedGeneric)
 
  private:
   HLoadKeyedGeneric(HValue* context, HValue* obj, HValue* key,
                     InlineCacheState initialization_state)
       : slot_(FeedbackVectorICSlot::Invalid()),
         initialization_state_(initialization_state) {
     set_representation(Representation::Tagged());
     SetOperandAt(0, obj);
@@ skipping 12 matching lines @@
 // 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> {
+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 {
+  bool HasEscapingOperandAt(int index) override { return index == 1; }
+  bool HasOutOfBoundsAccess(int size) override {
     return !access().IsInobject() || access().offset() >= size;
   }
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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 {
+                                         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
+  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_);
@@ skipping 82 matching lines @@
 
   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> {
+class HStoreNamedGeneric final : public HTemplateInstruction<3> {
  public:
   DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P5(HStoreNamedGeneric, HValue*,
                                               Handle<String>, HValue*,
                                               LanguageMode, InlineCacheState);
   HValue* object() const { return OperandAt(0); }
   HValue* value() const { return OperandAt(1); }
   HValue* context() const { return OperandAt(2); }
   Handle<String> 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
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(StoreNamedGeneric)
 
  private:
   HStoreNamedGeneric(HValue* context, HValue* object, Handle<String> 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<String> name_;
   LanguageMode language_mode_;
   InlineCacheState initialization_state_;
 };
 
 
-class HStoreKeyed FINAL
-    : public HTemplateInstruction<3>, public ArrayInstructionInterface {
+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 {
+  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_external() ? Representation::External()
                            : Representation::Tagged();
     } else if (index == 1) {
       return ArrayInstructionInterface::KeyedAccessIndexRequirement(
@@ skipping 30 matching lines @@
   }
 
   bool is_fixed_typed_array() const {
     return IsFixedTypedArrayElementsKind(elements_kind());
   }
 
   bool is_typed_elements() const {
     return is_external() || is_fixed_typed_array();
   }
 
-  Representation observed_input_representation(int index) OVERRIDE {
+  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 {
+  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 {
+  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 {
+  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 {
+                                         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
+  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),
@@ skipping 37 matching lines @@
   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> {
+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 {
+  Representation RequiredInputRepresentation(int index) override {
     // tagged[tagged] = tagged
     return Representation::Tagged();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  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();
   }
 
   LanguageMode language_mode_;
   InlineCacheState initialization_state_;
 };
 
 
-class HTransitionElementsKind FINAL : public HTemplateInstruction<2> {
+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 {
+  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
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   DECLARE_CONCRETE_INSTRUCTION(TransitionElementsKind)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE {
+  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; }
+  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()) |
@@ skipping 12 matching lines @@
   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 {
+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 {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
   DECLARE_CONCRETE_INSTRUCTION(StringAdd)
 
  protected:
-  bool DataEquals(HValue* other) OVERRIDE {
+  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, HType::String()),
         flags_(flags), pretenure_flag_(pretenure_flag) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     SetDependsOnFlag(kMaps);
     SetChangesFlag(kNewSpacePromotion);
     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");
     }
   }
 
   // No side-effects except possible allocation:
-  bool IsDeletable() const OVERRIDE { return true; }
+  bool IsDeletable() const override { return true; }
 
   const StringAddFlags flags_;
   const PretenureFlag pretenure_flag_;
 };
 
 
-class HStringCharCodeAt FINAL : public HTemplateInstruction<3> {
+class HStringCharCodeAt final : public HTemplateInstruction<3> {
  public:
   DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HStringCharCodeAt,
                                               HValue*,
                                               HValue*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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; }
+  bool DataEquals(HValue* other) override { return true; }
 
-  Range* InferRange(Zone* zone) OVERRIDE {
+  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; }
+  bool IsDeletable() const override { return true; }
 };
 
 
-class HStringCharFromCode FINAL : public HTemplateInstruction<2> {
+class HStringCharFromCode final : public HTemplateInstruction<2> {
  public:
   static HInstruction* New(Isolate* isolate, Zone* zone, HValue* context,
                            HValue* char_code);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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; }
+  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 {
+  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; }
+  bool IsDeletable() const final { return true; }
 
   int literal_index_;
   int depth_;
   AllocationSiteMode allocation_site_mode_;
 };
 
 
-class HRegExpLiteral FINAL : public HMaterializedLiteral<1> {
+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 {
+  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 HFunctionLiteral FINAL : public HTemplateInstruction<1> {
+class HFunctionLiteral final : public HTemplateInstruction<1> {
  public:
   DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P2(HFunctionLiteral,
                                               Handle<SharedFunctionInfo>,
                                               bool);
   HValue* context() { return OperandAt(0); }
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(FunctionLiteral)
 
   Handle<SharedFunctionInfo> shared_info() const { return shared_info_; }
   bool pretenure() const { return PretenureField::decode(bit_field_); }
   bool has_no_literals() const {
     return HasNoLiteralsField::decode(bit_field_);
   }
   FunctionKind kind() const { return FunctionKindField::decode(bit_field_); }
   LanguageMode language_mode() const {
     return LanguageModeField::decode(bit_field_);
   }
 
  private:
   HFunctionLiteral(HValue* context, Handle<SharedFunctionInfo> shared,
                    bool pretenure)
       : HTemplateInstruction<1>(HType::JSObject()),
         shared_info_(shared),
         bit_field_(FunctionKindField::encode(shared->kind()) |
                    PretenureField::encode(pretenure) |
                    HasNoLiteralsField::encode(shared->num_literals() == 0) |
                    LanguageModeField::encode(shared->language_mode())) {
     SetOperandAt(0, context);
     set_representation(Representation::Tagged());
     SetChangesFlag(kNewSpacePromotion);
   }
 
-  bool IsDeletable() const OVERRIDE { return true; }
+  bool IsDeletable() const override { return true; }
 
   class FunctionKindField : public BitField<FunctionKind, 0, 8> {};
   class PretenureField : public BitField<bool, 8, 1> {};
   class HasNoLiteralsField : public BitField<bool, 9, 1> {};
   STATIC_ASSERT(LANGUAGE_END == 3);
   class LanguageModeField : public BitField<LanguageMode, 10, 2> {};
 
   Handle<SharedFunctionInfo> shared_info_;
   uint32_t bit_field_;
 };
 
 
-class HTypeof FINAL : public HTemplateInstruction<2> {
+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
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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; }
+  bool IsDeletable() const override { return true; }
 };
 
 
-class HTrapAllocationMemento FINAL : public HTemplateInstruction<1> {
+class HTrapAllocationMemento final : public HTemplateInstruction<1> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P1(HTrapAllocationMemento, HValue*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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 HToFastProperties FINAL : public HUnaryOperation {
+class HToFastProperties final : public HUnaryOperation {
  public:
   DECLARE_INSTRUCTION_FACTORY_P1(HToFastProperties, HValue*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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; }
+  bool IsDeletable() const override { return true; }
 };
 
 
-class HDateField FINAL : public HUnaryOperation {
+class HDateField final : public HUnaryOperation {
  public:
   DECLARE_INSTRUCTION_FACTORY_P2(HDateField, HValue*, Smi*);
 
   Smi* index() const { return index_; }
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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> {
+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 {
+  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 {
+  bool DataEquals(HValue* other) override {
     return encoding() == HSeqStringGetChar::cast(other)->encoding();
   }
 
-  Range* InferRange(Zone* zone) OVERRIDE {
+  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; }
+  bool IsDeletable() const override { return true; }
 
   String::Encoding encoding_;
 };
 
 
-class HSeqStringSetChar FINAL : public HTemplateInstruction<4> {
+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 {
+  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> {
+class HCheckMapValue final : public HTemplateInstruction<2> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P2(HCheckMapValue, HValue*, HValue*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  HType CalculateInferredType() OVERRIDE {
+  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;
+  HValue* Canonicalize() override;
 
   DECLARE_CONCRETE_INSTRUCTION(CheckMapValue)
 
  protected:
-  int RedefinedOperandIndex() OVERRIDE { return 0; }
+  int RedefinedOperandIndex() override { return 0; }
 
-  bool DataEquals(HValue* other) OVERRIDE { return true; }
+  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> {
+class HForInPrepareMap final : public HTemplateInstruction<2> {
  public:
   DECLARE_INSTRUCTION_WITH_CONTEXT_FACTORY_P1(HForInPrepareMap, HValue*);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  HType CalculateInferredType() OVERRIDE { return HType::Tagged(); }
+  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> {
+class HForInCacheArray final : public HTemplateInstruction<2> {
  public:
   DECLARE_INSTRUCTION_FACTORY_P3(HForInCacheArray, HValue*, HValue*, int);
 
-  Representation RequiredInputRepresentation(int index) OVERRIDE {
+  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
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  HType CalculateInferredType() OVERRIDE { return HType::Tagged(); }
+  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> {
+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 {
+  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
+  std::ostream& PrintDataTo(std::ostream& os) const override;  // NOLINT
 
-  HType CalculateInferredType() OVERRIDE { return HType::Tagged(); }
+  HType CalculateInferredType() override { return HType::Tagged(); }
 
   DECLARE_CONCRETE_INSTRUCTION(LoadFieldByIndex);
 
  private:
-  bool IsDeletable() const OVERRIDE { return true; }
+  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 {
+  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 {
+  Representation RequiredInputRepresentation(int index) override {
     return Representation::Tagged();
   }
 
-  std::ostream& PrintDataTo(std::ostream& os) const OVERRIDE;  // NOLINT
+  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 v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_