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

src/code-stubs.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_CODE_STUBS_H_
 #define V8_CODE_STUBS_H_
 
 #include "src/allocation.h"
 #include "src/assembler.h"
 #include "src/codegen.h"
@@ skipping 287 matching lines @@
 // TODO(svenpanne) This class is only used to construct a more or less sensible
 // CompilationInfo for testing purposes, basically pretending that we are
 // currently compiling some kind of code stub. Remove this when the pipeline and
 // testing machinery is restructured in such a way that we don't have to come up
 // with a CompilationInfo out of thin air, although we only need a few parts of
 // it.
 struct FakeStubForTesting : public CodeStub {
   explicit FakeStubForTesting(Isolate* isolate) : CodeStub(isolate) {}
 
   // Only used by pipeline.cc's GetDebugName in DEBUG mode.
-  Major MajorKey() const OVERRIDE { return CodeStub::NoCache; }
+  Major MajorKey() const override { return CodeStub::NoCache; }
 
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+  CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
     UNREACHABLE();
     return CallInterfaceDescriptor();
   }
 
-  Handle<Code> GenerateCode() OVERRIDE {
+  Handle<Code> GenerateCode() override {
     UNREACHABLE();
     return Handle<Code>();
   }
 };
 
 
 #define DEFINE_CODE_STUB_BASE(NAME, SUPER)                      \
  public:                                                        \
   NAME(uint32_t key, Isolate* isolate) : SUPER(key, isolate) {} \
                                                                 \
  private:                                                       \
   DISALLOW_COPY_AND_ASSIGN(NAME)
 
 
 #define DEFINE_CODE_STUB(NAME, SUPER)                      \
  protected:                                                \
-  inline Major MajorKey() const OVERRIDE { return NAME; }; \
+  inline Major MajorKey() const override { return NAME; }; \
   DEFINE_CODE_STUB_BASE(NAME##Stub, SUPER)
 
 
 #define DEFINE_PLATFORM_CODE_STUB(NAME, SUPER)  \
  private:                                       \
-  void Generate(MacroAssembler* masm) OVERRIDE; \
+  void Generate(MacroAssembler* masm) override; \
   DEFINE_CODE_STUB(NAME, SUPER)
 
 
 #define DEFINE_HYDROGEN_CODE_STUB(NAME, SUPER)                        \
  public:                                                              \
-  void InitializeDescriptor(CodeStubDescriptor* descriptor) OVERRIDE; \
-  Handle<Code> GenerateCode() OVERRIDE;                               \
+  void InitializeDescriptor(CodeStubDescriptor* descriptor) override; \
+  Handle<Code> GenerateCode() override;                               \
   DEFINE_CODE_STUB(NAME, SUPER)
 
 #define DEFINE_HANDLER_CODE_STUB(NAME, SUPER) \
  public:                                      \
-  Handle<Code> GenerateCode() OVERRIDE;       \
+  Handle<Code> GenerateCode() override;       \
   DEFINE_CODE_STUB(NAME, SUPER)
 
 #define DEFINE_CALL_INTERFACE_DESCRIPTOR(NAME)                    \
  public:                                                          \
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE { \
+  CallInterfaceDescriptor GetCallInterfaceDescriptor() override { \
     return NAME##Descriptor(isolate());                           \
   }
 
 // There are some code stubs we just can't describe right now with a
 // CallInterfaceDescriptor. Isolate behavior for those cases with this macro.
 // An attempt to retrieve a descriptor will fail.
 #define DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR()                   \
  public:                                                          \
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE { \
+  CallInterfaceDescriptor GetCallInterfaceDescriptor() override { \
     UNREACHABLE();                                                \
     return CallInterfaceDescriptor();                             \
   }
 
 
 class PlatformCodeStub : public CodeStub {
  public:
   // Retrieve the code for the stub. Generate the code if needed.
-  Handle<Code> GenerateCode() OVERRIDE;
+  Handle<Code> GenerateCode() override;
 
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::STUB; }
+  Code::Kind GetCodeKind() const override { return Code::STUB; }
 
  protected:
   explicit PlatformCodeStub(Isolate* isolate) : CodeStub(isolate) {}
 
   // Generates the assembler code for the stub.
   virtual void Generate(MacroAssembler* masm) = 0;
 
   DEFINE_CODE_STUB_BASE(PlatformCodeStub, CodeStub);
 };
 
@@ skipping 79 matching lines @@
 };
 
 
 class HydrogenCodeStub : public CodeStub {
  public:
   enum InitializationState {
     UNINITIALIZED,
     INITIALIZED
   };
 
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::STUB; }
+  Code::Kind GetCodeKind() const override { return Code::STUB; }
 
   template<class SubClass>
   static Handle<Code> GetUninitialized(Isolate* isolate) {
     SubClass::GenerateAheadOfTime(isolate);
     return SubClass().GetCode(isolate);
   }
 
   // Retrieve the code for the stub. Generate the code if needed.
-  Handle<Code> GenerateCode() OVERRIDE = 0;
+  Handle<Code> GenerateCode() override = 0;
 
   bool IsUninitialized() const { return IsMissBits::decode(minor_key_); }
 
   Handle<Code> GenerateLightweightMissCode(ExternalReference miss);
 
   template<class StateType>
   void TraceTransition(StateType from, StateType to);
 
  protected:
   explicit HydrogenCodeStub(Isolate* isolate,
@@ skipping 79 matching lines @@
 class NopRuntimeCallHelper : public RuntimeCallHelper {
  public:
   NopRuntimeCallHelper() {}
 
   virtual void BeforeCall(MacroAssembler* masm) const {}
 
   virtual void AfterCall(MacroAssembler* masm) const {}
 };
 
 
-class NumberToStringStub FINAL : public HydrogenCodeStub {
+class NumberToStringStub final : public HydrogenCodeStub {
  public:
   explicit NumberToStringStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kNumber = 0;
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(NumberToString);
   DEFINE_HYDROGEN_CODE_STUB(NumberToString, HydrogenCodeStub);
 };
 
@@ skipping 19 matching lines @@
  private:
   STATIC_ASSERT(LANGUAGE_END == 3);
   class LanguageModeBits : public BitField<LanguageMode, 0, 2> {};
   class FunctionKindBits : public BitField<FunctionKind, 2, 8> {};
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(FastNewClosure);
   DEFINE_HYDROGEN_CODE_STUB(FastNewClosure, HydrogenCodeStub);
 };
 
 
-class FastNewContextStub FINAL : public HydrogenCodeStub {
+class FastNewContextStub final : public HydrogenCodeStub {
  public:
   static const int kMaximumSlots = 64;
 
   FastNewContextStub(Isolate* isolate, int slots) : HydrogenCodeStub(isolate) {
     DCHECK(slots > 0 && slots <= kMaximumSlots);
     set_sub_minor_key(SlotsBits::encode(slots));
   }
 
   int slots() const { return SlotsBits::decode(sub_minor_key()); }
 
@@ skipping 82 matching lines @@
     kReturnTrueFalseObject = 1 << 2
   };
 
   InstanceofStub(Isolate* isolate, Flags flags) : PlatformCodeStub(isolate) {
     minor_key_ = FlagBits::encode(flags);
   }
 
   static Register left() { return InstanceofDescriptor::left(); }
   static Register right() { return InstanceofDescriptor::right(); }
 
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+  CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
     if (HasArgsInRegisters()) {
       return InstanceofDescriptor(isolate());
     }
     return ContextOnlyDescriptor(isolate());
   }
 
  private:
   Flags flags() const { return FlagBits::decode(minor_key_); }
 
   bool HasArgsInRegisters() const { return (flags() & kArgsInRegisters) != 0; }
 
   bool HasCallSiteInlineCheck() const {
     return (flags() & kCallSiteInlineCheck) != 0;
   }
 
   bool ReturnTrueFalseObject() const {
     return (flags() & kReturnTrueFalseObject) != 0;
   }
 
-  void PrintName(std::ostream& os) const OVERRIDE;  // NOLINT
+  void PrintName(std::ostream& os) const override;  // NOLINT
 
   class FlagBits : public BitField<Flags, 0, 3> {};
 
   DEFINE_PLATFORM_CODE_STUB(Instanceof, PlatformCodeStub);
 };
 
 
 enum AllocationSiteOverrideMode {
   DONT_OVERRIDE,
   DISABLE_ALLOCATION_SITES,
@@ skipping 10 matching lines @@
   explicit ArrayConstructorStub(Isolate* isolate);
 
  private:
   ArgumentCountKey argument_count() const {
     return ArgumentCountBits::decode(minor_key_);
   }
 
   void GenerateDispatchToArrayStub(MacroAssembler* masm,
                                    AllocationSiteOverrideMode mode);
 
-  void PrintName(std::ostream& os) const OVERRIDE;  // NOLINT
+  void PrintName(std::ostream& os) const override;  // NOLINT
 
   class ArgumentCountBits : public BitField<ArgumentCountKey, 0, 2> {};
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(ArrayConstructor);
   DEFINE_PLATFORM_CODE_STUB(ArrayConstructor, PlatformCodeStub);
 };
 
 
 class InternalArrayConstructorStub: public PlatformCodeStub {
  public:
   explicit InternalArrayConstructorStub(Isolate* isolate);
 
  private:
   void GenerateCase(MacroAssembler* masm, ElementsKind kind);
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(InternalArrayConstructor);
   DEFINE_PLATFORM_CODE_STUB(InternalArrayConstructor, PlatformCodeStub);
 };
 
 
 class MathPowStub: public PlatformCodeStub {
  public:
   enum ExponentType { INTEGER, DOUBLE, TAGGED, ON_STACK };
 
   MathPowStub(Isolate* isolate, ExponentType exponent_type)
       : PlatformCodeStub(isolate) {
     minor_key_ = ExponentTypeBits::encode(exponent_type);
   }
 
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+  CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
     if (exponent_type() == TAGGED) {
       return MathPowTaggedDescriptor(isolate());
     } else if (exponent_type() == INTEGER) {
       return MathPowIntegerDescriptor(isolate());
     }
     // A CallInterfaceDescriptor doesn't specify double registers (yet).
     return ContextOnlyDescriptor(isolate());
   }
 
  private:
@@ skipping 12 matching lines @@
   CallICStub(Isolate* isolate, const CallICState& state)
       : PlatformCodeStub(isolate) {
     minor_key_ = state.GetExtraICState();
   }
 
   static int ExtractArgcFromMinorKey(int minor_key) {
     CallICState state(static_cast<ExtraICState>(minor_key));
     return state.arg_count();
   }
 
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::CALL_IC; }
+  Code::Kind GetCodeKind() const override { return Code::CALL_IC; }
 
-  InlineCacheState GetICState() const OVERRIDE { return DEFAULT; }
+  InlineCacheState GetICState() const override { return DEFAULT; }
 
-  ExtraICState GetExtraICState() const FINAL {
+  ExtraICState GetExtraICState() const final {
     return static_cast<ExtraICState>(minor_key_);
   }
 
  protected:
   bool CallAsMethod() const {
     return state().call_type() == CallICState::METHOD;
   }
 
   int arg_count() const { return state().arg_count(); }
 
   CallICState state() const {
     return CallICState(static_cast<ExtraICState>(minor_key_));
   }
 
   // Code generation helpers.
   void GenerateMiss(MacroAssembler* masm);
 
  private:
-  void PrintState(std::ostream& os) const OVERRIDE;  // NOLINT
+  void PrintState(std::ostream& os) const override;  // NOLINT
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(CallFunctionWithFeedbackAndVector);
   DEFINE_PLATFORM_CODE_STUB(CallIC, PlatformCodeStub);
 };
 
 
 class CallIC_ArrayStub: public CallICStub {
  public:
   CallIC_ArrayStub(Isolate* isolate, const CallICState& state_in)
       : CallICStub(isolate, state_in) {}
 
-  InlineCacheState GetICState() const FINAL { return MONOMORPHIC; }
+  InlineCacheState GetICState() const final { return MONOMORPHIC; }
 
  private:
-  void PrintState(std::ostream& os) const OVERRIDE;  // NOLINT
+  void PrintState(std::ostream& os) const override;  // NOLINT
 
   DEFINE_PLATFORM_CODE_STUB(CallIC_Array, CallICStub);
 };
 
 
 // TODO(verwaest): Translate to hydrogen code stub.
 class FunctionPrototypeStub : public PlatformCodeStub {
  public:
   explicit FunctionPrototypeStub(Isolate* isolate)
       : PlatformCodeStub(isolate) {}
 
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::HANDLER; }
+  Code::Kind GetCodeKind() const override { return Code::HANDLER; }
 
   // TODO(mvstanton): only the receiver register is accessed. When this is
   // translated to a hydrogen code stub, a new CallInterfaceDescriptor
   // should be created that just uses that register for more efficient code.
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+  CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
     if (FLAG_vector_ics) {
       return VectorLoadICDescriptor(isolate());
     }
     return LoadDescriptor(isolate());
   }
 
   DEFINE_PLATFORM_CODE_STUB(FunctionPrototype, PlatformCodeStub);
 };
 
 
 // TODO(mvstanton): Translate to hydrogen code stub.
 class LoadIndexedInterceptorStub : public PlatformCodeStub {
  public:
   explicit LoadIndexedInterceptorStub(Isolate* isolate)
       : PlatformCodeStub(isolate) {}
 
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::HANDLER; }
-  Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+  Code::Kind GetCodeKind() const override { return Code::HANDLER; }
+  Code::StubType GetStubType() const override { return Code::FAST; }
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
   DEFINE_PLATFORM_CODE_STUB(LoadIndexedInterceptor, PlatformCodeStub);
 };
 
 
 class LoadIndexedStringStub : public PlatformCodeStub {
  public:
   explicit LoadIndexedStringStub(Isolate* isolate)
       : PlatformCodeStub(isolate) {}
 
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::HANDLER; }
-  Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+  Code::Kind GetCodeKind() const override { return Code::HANDLER; }
+  Code::StubType GetStubType() const override { return Code::FAST; }
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
   DEFINE_PLATFORM_CODE_STUB(LoadIndexedString, PlatformCodeStub);
 };
 
 
 class HandlerStub : public HydrogenCodeStub {
  public:
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::HANDLER; }
-  ExtraICState GetExtraICState() const OVERRIDE { return kind(); }
-  InlineCacheState GetICState() const OVERRIDE { return MONOMORPHIC; }
+  Code::Kind GetCodeKind() const override { return Code::HANDLER; }
+  ExtraICState GetExtraICState() const override { return kind(); }
+  InlineCacheState GetICState() const override { return MONOMORPHIC; }
 
-  void InitializeDescriptor(CodeStubDescriptor* descriptor) OVERRIDE;
+  void InitializeDescriptor(CodeStubDescriptor* descriptor) override;
 
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE;
+  CallInterfaceDescriptor GetCallInterfaceDescriptor() override;
 
  protected:
   explicit HandlerStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
 
   virtual Code::Kind kind() const = 0;
 
   DEFINE_CODE_STUB_BASE(HandlerStub, HydrogenCodeStub);
 };
 
 
 class LoadFieldStub: public HandlerStub {
  public:
   LoadFieldStub(Isolate* isolate, FieldIndex index) : HandlerStub(isolate) {
     int property_index_key = index.GetFieldAccessStubKey();
     set_sub_minor_key(LoadFieldByIndexBits::encode(property_index_key));
   }
 
   FieldIndex index() const {
     int property_index_key = LoadFieldByIndexBits::decode(sub_minor_key());
     return FieldIndex::FromFieldAccessStubKey(property_index_key);
   }
 
  protected:
-  Code::Kind kind() const OVERRIDE { return Code::LOAD_IC; }
-  Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+  Code::Kind kind() const override { return Code::LOAD_IC; }
+  Code::StubType GetStubType() const override { return Code::FAST; }
 
  private:
   class LoadFieldByIndexBits : public BitField<int, 0, 13> {};
 
   DEFINE_HANDLER_CODE_STUB(LoadField, HandlerStub);
 };
 
 
 class KeyedLoadSloppyArgumentsStub : public HandlerStub {
  public:
   explicit KeyedLoadSloppyArgumentsStub(Isolate* isolate)
       : HandlerStub(isolate) {}
 
  protected:
-  Code::Kind kind() const OVERRIDE { return Code::KEYED_LOAD_IC; }
-  Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+  Code::Kind kind() const override { return Code::KEYED_LOAD_IC; }
+  Code::StubType GetStubType() const override { return Code::FAST; }
 
  private:
   DEFINE_HANDLER_CODE_STUB(KeyedLoadSloppyArguments, HandlerStub);
 };
 
 
 class LoadConstantStub : public HandlerStub {
  public:
   LoadConstantStub(Isolate* isolate, int constant_index)
       : HandlerStub(isolate) {
     set_sub_minor_key(ConstantIndexBits::encode(constant_index));
   }
 
   int constant_index() const {
     return ConstantIndexBits::decode(sub_minor_key());
   }
 
  protected:
-  Code::Kind kind() const OVERRIDE { return Code::LOAD_IC; }
-  Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+  Code::Kind kind() const override { return Code::LOAD_IC; }
+  Code::StubType GetStubType() const override { return Code::FAST; }
 
  private:
   class ConstantIndexBits : public BitField<int, 0, kSubMinorKeyBits> {};
 
   DEFINE_HANDLER_CODE_STUB(LoadConstant, HandlerStub);
 };
 
 
 class StringLengthStub: public HandlerStub {
  public:
   explicit StringLengthStub(Isolate* isolate) : HandlerStub(isolate) {}
 
  protected:
-  Code::Kind kind() const OVERRIDE { return Code::LOAD_IC; }
-  Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+  Code::Kind kind() const override { return Code::LOAD_IC; }
+  Code::StubType GetStubType() const override { return Code::FAST; }
 
   DEFINE_HANDLER_CODE_STUB(StringLength, HandlerStub);
 };
 
 
 class StoreFieldStub : public HandlerStub {
  public:
   StoreFieldStub(Isolate* isolate, FieldIndex index,
                  Representation representation)
       : HandlerStub(isolate) {
     int property_index_key = index.GetFieldAccessStubKey();
     uint8_t repr = PropertyDetails::EncodeRepresentation(representation);
     set_sub_minor_key(StoreFieldByIndexBits::encode(property_index_key) |
                       RepresentationBits::encode(repr));
   }
 
   FieldIndex index() const {
     int property_index_key = StoreFieldByIndexBits::decode(sub_minor_key());
     return FieldIndex::FromFieldAccessStubKey(property_index_key);
   }
 
   Representation representation() {
     uint8_t repr = RepresentationBits::decode(sub_minor_key());
     return PropertyDetails::DecodeRepresentation(repr);
   }
 
  protected:
-  Code::Kind kind() const OVERRIDE { return Code::STORE_IC; }
-  Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+  Code::Kind kind() const override { return Code::STORE_IC; }
+  Code::StubType GetStubType() const override { return Code::FAST; }
 
  private:
   class StoreFieldByIndexBits : public BitField<int, 0, 13> {};
   class RepresentationBits : public BitField<uint8_t, 13, 4> {};
 
   DEFINE_HANDLER_CODE_STUB(StoreField, HandlerStub);
 };
 
 
 class StoreTransitionStub : public HandlerStub {
@@ skipping 28 matching lines @@
   Representation representation() {
     DCHECK(store_mode() != StoreMapOnly);
     uint8_t repr = RepresentationBits::decode(sub_minor_key());
     return PropertyDetails::DecodeRepresentation(repr);
   }
 
   StoreMode store_mode() const {
     return StoreModeBits::decode(sub_minor_key());
   }
 
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE;
+  CallInterfaceDescriptor GetCallInterfaceDescriptor() override;
 
  protected:
-  Code::Kind kind() const OVERRIDE { return Code::STORE_IC; }
-  Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+  Code::Kind kind() const override { return Code::STORE_IC; }
+  Code::StubType GetStubType() const override { return Code::FAST; }
 
  private:
   class StoreFieldByIndexBits : public BitField<int, 0, 13> {};
   class RepresentationBits : public BitField<uint8_t, 13, 4> {};
   class StoreModeBits : public BitField<StoreMode, 17, 2> {};
 
   DEFINE_HANDLER_CODE_STUB(StoreTransition, HandlerStub);
 };
 
 
@@ skipping 19 matching lines @@
                   isolate()->factory()->NewWeakCell(cell));
       return CodeStub::GetCodeCopy(pattern);
     } else {
       Code::FindAndReplacePattern pattern;
       pattern.Add(Handle<Map>(property_cell_placeholder(isolate())->map()),
                   isolate()->factory()->NewWeakCell(cell));
       return CodeStub::GetCodeCopy(pattern);
     }
   }
 
-  Code::Kind kind() const OVERRIDE { return Code::STORE_IC; }
+  Code::Kind kind() const override { return Code::STORE_IC; }
 
   bool is_constant() const { return IsConstantBits::decode(sub_minor_key()); }
 
   bool check_global() const { return CheckGlobalBits::decode(sub_minor_key()); }
 
   void set_is_constant(bool value) {
     set_sub_minor_key(IsConstantBits::update(sub_minor_key(), value));
   }
 
   Representation representation() {
@@ skipping 103 matching lines @@
     set_sub_minor_key(state.GetExtraICState());
   }
 
   BinaryOpICStub(Isolate* isolate, const BinaryOpICState& state)
       : HydrogenCodeStub(isolate) {
     set_sub_minor_key(state.GetExtraICState());
   }
 
   static void GenerateAheadOfTime(Isolate* isolate);
 
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::BINARY_OP_IC; }
+  Code::Kind GetCodeKind() const override { return Code::BINARY_OP_IC; }
 
-  InlineCacheState GetICState() const FINAL { return state().GetICState(); }
+  InlineCacheState GetICState() const final { return state().GetICState(); }
 
-  ExtraICState GetExtraICState() const FINAL {
+  ExtraICState GetExtraICState() const final {
     return static_cast<ExtraICState>(sub_minor_key());
   }
 
   BinaryOpICState state() const {
     return BinaryOpICState(isolate(), GetExtraICState());
   }
 
-  void PrintState(std::ostream& os) const FINAL;  // NOLINT
+  void PrintState(std::ostream& os) const final;  // NOLINT
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kLeft = 0;
   static const int kRight = 1;
 
  private:
   static void GenerateAheadOfTime(Isolate* isolate,
                                   const BinaryOpICState& state);
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOp);
   DEFINE_HYDROGEN_CODE_STUB(BinaryOpIC, HydrogenCodeStub);
 };
 
 
 // TODO(bmeurer): Merge this into the BinaryOpICStub once we have proper tail
 // call support for stubs in Hydrogen.
-class BinaryOpICWithAllocationSiteStub FINAL : public PlatformCodeStub {
+class BinaryOpICWithAllocationSiteStub final : public PlatformCodeStub {
  public:
   BinaryOpICWithAllocationSiteStub(Isolate* isolate,
                                    const BinaryOpICState& state)
       : PlatformCodeStub(isolate) {
     minor_key_ = state.GetExtraICState();
   }
 
   static void GenerateAheadOfTime(Isolate* isolate);
 
   Handle<Code> GetCodeCopyFromTemplate(Handle<AllocationSite> allocation_site) {
     Code::FindAndReplacePattern pattern;
     pattern.Add(isolate()->factory()->undefined_map(), allocation_site);
     return CodeStub::GetCodeCopy(pattern);
   }
 
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::BINARY_OP_IC; }
+  Code::Kind GetCodeKind() const override { return Code::BINARY_OP_IC; }
 
-  InlineCacheState GetICState() const OVERRIDE { return state().GetICState(); }
+  InlineCacheState GetICState() const override { return state().GetICState(); }
 
-  ExtraICState GetExtraICState() const OVERRIDE {
+  ExtraICState GetExtraICState() const override {
     return static_cast<ExtraICState>(minor_key_);
   }
 
-  void PrintState(std::ostream& os) const OVERRIDE;  // NOLINT
+  void PrintState(std::ostream& os) const override;  // NOLINT
 
  private:
   BinaryOpICState state() const {
     return BinaryOpICState(isolate(), static_cast<ExtraICState>(minor_key_));
   }
 
   static void GenerateAheadOfTime(Isolate* isolate,
                                   const BinaryOpICState& state);
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOpWithAllocationSite);
   DEFINE_PLATFORM_CODE_STUB(BinaryOpICWithAllocationSite, PlatformCodeStub);
 };
 
 
-class BinaryOpWithAllocationSiteStub FINAL : public BinaryOpICStub {
+class BinaryOpWithAllocationSiteStub final : public BinaryOpICStub {
  public:
   BinaryOpWithAllocationSiteStub(Isolate* isolate, Token::Value op)
       : BinaryOpICStub(isolate, op) {}
 
   BinaryOpWithAllocationSiteStub(Isolate* isolate, const BinaryOpICState& state)
       : BinaryOpICStub(isolate, state) {}
 
-  Code::Kind GetCodeKind() const FINAL { return Code::STUB; }
+  Code::Kind GetCodeKind() const final { return Code::STUB; }
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kAllocationSite = 0;
   static const int kLeft = 1;
   static const int kRight = 2;
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOpWithAllocationSite);
   DEFINE_HYDROGEN_CODE_STUB(BinaryOpWithAllocationSite, BinaryOpICStub);
 };
 
 
 enum StringAddFlags {
   // Omit both parameter checks.
   STRING_ADD_CHECK_NONE = 0,
   // Check left parameter.
   STRING_ADD_CHECK_LEFT = 1 << 0,
   // Check right parameter.
   STRING_ADD_CHECK_RIGHT = 1 << 1,
   // Check both parameters.
   STRING_ADD_CHECK_BOTH = STRING_ADD_CHECK_LEFT | STRING_ADD_CHECK_RIGHT
 };
 
 
-class StringAddStub FINAL : public HydrogenCodeStub {
+class StringAddStub final : public HydrogenCodeStub {
  public:
   StringAddStub(Isolate* isolate, StringAddFlags flags,
                 PretenureFlag pretenure_flag)
       : HydrogenCodeStub(isolate) {
     set_sub_minor_key(StringAddFlagsBits::encode(flags) |
                       PretenureFlagBits::encode(pretenure_flag));
   }
 
   StringAddFlags flags() const {
     return StringAddFlagsBits::decode(sub_minor_key());
   }
 
   PretenureFlag pretenure_flag() const {
     return PretenureFlagBits::decode(sub_minor_key());
   }
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kLeft = 0;
   static const int kRight = 1;
 
  private:
   class StringAddFlagsBits: public BitField<StringAddFlags, 0, 2> {};
   class PretenureFlagBits: public BitField<PretenureFlag, 2, 1> {};
 
-  void PrintBaseName(std::ostream& os) const OVERRIDE;  // NOLINT
+  void PrintBaseName(std::ostream& os) const override;  // NOLINT
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(StringAdd);
   DEFINE_HYDROGEN_CODE_STUB(StringAdd, HydrogenCodeStub);
 };
 
 
 class CompareICStub : public PlatformCodeStub {
  public:
   CompareICStub(Isolate* isolate, Token::Value op, CompareICState::State left,
                 CompareICState::State right, CompareICState::State state)
       : PlatformCodeStub(isolate) {
     DCHECK(Token::IsCompareOp(op));
     minor_key_ = OpBits::encode(op - Token::EQ) | LeftStateBits::encode(left) |
                  RightStateBits::encode(right) | StateBits::encode(state);
   }
 
   void set_known_map(Handle<Map> map) { known_map_ = map; }
 
-  InlineCacheState GetICState() const OVERRIDE;
+  InlineCacheState GetICState() const override;
 
   Token::Value op() const {
     return static_cast<Token::Value>(Token::EQ + OpBits::decode(minor_key_));
   }
 
   CompareICState::State left() const {
     return LeftStateBits::decode(minor_key_);
   }
   CompareICState::State right() const {
     return RightStateBits::decode(minor_key_);
   }
   CompareICState::State state() const { return StateBits::decode(minor_key_); }
 
  private:
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::COMPARE_IC; }
+  Code::Kind GetCodeKind() const override { return Code::COMPARE_IC; }
 
   void GenerateSmis(MacroAssembler* masm);
   void GenerateNumbers(MacroAssembler* masm);
   void GenerateInternalizedStrings(MacroAssembler* masm);
   void GenerateStrings(MacroAssembler* masm);
   void GenerateUniqueNames(MacroAssembler* masm);
   void GenerateObjects(MacroAssembler* masm);
   void GenerateMiss(MacroAssembler* masm);
   void GenerateKnownObjects(MacroAssembler* masm);
   void GenerateGeneric(MacroAssembler* masm);
 
   bool strict() const { return op() == Token::EQ_STRICT; }
   Condition GetCondition() const;
 
-  void AddToSpecialCache(Handle<Code> new_object) OVERRIDE;
-  bool FindCodeInSpecialCache(Code** code_out) OVERRIDE;
-  bool UseSpecialCache() OVERRIDE {
+  void AddToSpecialCache(Handle<Code> new_object) override;
+  bool FindCodeInSpecialCache(Code** code_out) override;
+  bool UseSpecialCache() override {
     return state() == CompareICState::KNOWN_OBJECT;
   }
 
   class OpBits : public BitField<int, 0, 3> {};
   class LeftStateBits : public BitField<CompareICState::State, 3, 4> {};
   class RightStateBits : public BitField<CompareICState::State, 7, 4> {};
   class StateBits : public BitField<CompareICState::State, 11, 4> {};
 
   Handle<Map> known_map_;
 
@@ skipping 15 matching lines @@
                    InitializationState init_state = INITIALIZED)
       : HydrogenCodeStub(isolate, init_state) {
     set_sub_minor_key(ic_state);
   }
 
   static Handle<Code> GetUninitialized(Isolate* isolate,
                                        NilValue nil) {
     return CompareNilICStub(isolate, nil, UNINITIALIZED).GetCode();
   }
 
-  InlineCacheState GetICState() const OVERRIDE {
+  InlineCacheState GetICState() const override {
     State state = this->state();
     if (state.Contains(GENERIC)) {
       return MEGAMORPHIC;
     } else if (state.Contains(MONOMORPHIC_MAP)) {
       return MONOMORPHIC;
     } else {
       return PREMONOMORPHIC;
     }
   }
 
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::COMPARE_NIL_IC; }
+  Code::Kind GetCodeKind() const override { return Code::COMPARE_NIL_IC; }
 
-  ExtraICState GetExtraICState() const OVERRIDE { return sub_minor_key(); }
+  ExtraICState GetExtraICState() const override { return sub_minor_key(); }
 
   void UpdateStatus(Handle<Object> object);
 
   bool IsMonomorphic() const { return state().Contains(MONOMORPHIC_MAP); }
 
   NilValue nil_value() const { return NilValueBits::decode(sub_minor_key()); }
 
   void ClearState() {
     set_sub_minor_key(TypesBits::update(sub_minor_key(), 0));
   }
 
-  void PrintState(std::ostream& os) const OVERRIDE;     // NOLINT
-  void PrintBaseName(std::ostream& os) const OVERRIDE;  // NOLINT
+  void PrintState(std::ostream& os) const override;     // NOLINT
+  void PrintBaseName(std::ostream& os) const override;  // NOLINT
 
  private:
   CompareNilICStub(Isolate* isolate, NilValue nil,
                    InitializationState init_state)
       : HydrogenCodeStub(isolate, init_state) {
     set_sub_minor_key(NilValueBits::encode(nil));
   }
 
   enum CompareNilType {
     UNDEFINED,
@@ skipping 47 matching lines @@
   // their code generation.  On machines that always have gp registers (x64) we
   // can generate both variants ahead of time.
   static void GenerateAheadOfTime(Isolate* isolate);
 
  private:
   bool save_doubles() const { return SaveDoublesBits::decode(minor_key_); }
 #if _WIN64 || V8_TARGET_ARCH_PPC
   int result_size() const { return ResultSizeBits::decode(minor_key_); }
 #endif  // _WIN64
 
-  bool NeedsImmovableCode() OVERRIDE;
+  bool NeedsImmovableCode() override;
 
   class SaveDoublesBits : public BitField<bool, 0, 1> {};
   class ResultSizeBits : public BitField<int, 1, 3> {};
 
   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
   DEFINE_PLATFORM_CODE_STUB(CEntry, PlatformCodeStub);
 };
 
 
 class JSEntryStub : public PlatformCodeStub {
  public:
   JSEntryStub(Isolate* isolate, StackFrame::Type type)
       : PlatformCodeStub(isolate) {
     DCHECK(type == StackFrame::ENTRY || type == StackFrame::ENTRY_CONSTRUCT);
     minor_key_ = StackFrameTypeBits::encode(type);
   }
 
  private:
-  void FinishCode(Handle<Code> code) OVERRIDE;
+  void FinishCode(Handle<Code> code) override;
 
-  void PrintName(std::ostream& os) const OVERRIDE {  // NOLINT
+  void PrintName(std::ostream& os) const override {  // NOLINT
     os << (type() == StackFrame::ENTRY ? "JSEntryStub"
                                        : "JSConstructEntryStub");
   }
 
   StackFrame::Type type() const {
     return StackFrameTypeBits::decode(minor_key_);
   }
 
   class StackFrameTypeBits : public BitField<StackFrame::Type, 0, 5> {};
 
@@ skipping 15 matching lines @@
 
   enum HasNewTarget { NO_NEW_TARGET, HAS_NEW_TARGET };
 
   ArgumentsAccessStub(Isolate* isolate, Type type,
                       HasNewTarget has_new_target = NO_NEW_TARGET)
       : PlatformCodeStub(isolate) {
     minor_key_ =
         TypeBits::encode(type) | HasNewTargetBits::encode(has_new_target);
   }
 
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+  CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
     if (type() == READ_ELEMENT) {
       return ArgumentsAccessReadDescriptor(isolate());
     }
     return ContextOnlyDescriptor(isolate());
   }
 
  private:
   Type type() const { return TypeBits::decode(minor_key_); }
   bool has_new_target() const {
     return HasNewTargetBits::decode(minor_key_) == HAS_NEW_TARGET;
   }
 
   void GenerateReadElement(MacroAssembler* masm);
   void GenerateNewStrict(MacroAssembler* masm);
   void GenerateNewSloppyFast(MacroAssembler* masm);
   void GenerateNewSloppySlow(MacroAssembler* masm);
 
-  void PrintName(std::ostream& os) const OVERRIDE;  // NOLINT
+  void PrintName(std::ostream& os) const override;  // NOLINT
 
   class TypeBits : public BitField<Type, 0, 2> {};
   class HasNewTargetBits : public BitField<HasNewTarget, 2, 1> {};
 
   DEFINE_PLATFORM_CODE_STUB(ArgumentsAccess, PlatformCodeStub);
 };
 
 
 class RestParamAccessStub: public PlatformCodeStub {
  public:
   explicit RestParamAccessStub(Isolate* isolate) : PlatformCodeStub(isolate) { }
 
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+  CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
     return ContextOnlyDescriptor(isolate());
   }
 
  private:
   void GenerateNew(MacroAssembler* masm);
 
-  virtual void PrintName(std::ostream& os) const OVERRIDE;  // NOLINT
+  virtual void PrintName(std::ostream& os) const override;  // NOLINT
 
   DEFINE_PLATFORM_CODE_STUB(RestParamAccess, PlatformCodeStub);
 };
 
 
 class RegExpExecStub: public PlatformCodeStub {
  public:
   explicit RegExpExecStub(Isolate* isolate) : PlatformCodeStub(isolate) { }
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(ContextOnly);
   DEFINE_PLATFORM_CODE_STUB(RegExpExec, PlatformCodeStub);
 };
 
 
-class RegExpConstructResultStub FINAL : public HydrogenCodeStub {
+class RegExpConstructResultStub final : public HydrogenCodeStub {
  public:
   explicit RegExpConstructResultStub(Isolate* isolate)
       : HydrogenCodeStub(isolate) { }
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kLength = 0;
   static const int kIndex = 1;
   static const int kInput = 2;
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(RegExpConstructResult);
@@ skipping 16 matching lines @@
  private:
   int argc() const { return ArgcBits::decode(minor_key_); }
   int flags() const { return FlagBits::decode(minor_key_); }
 
   bool CallAsMethod() const {
     return flags() == CALL_AS_METHOD || flags() == WRAP_AND_CALL;
   }
 
   bool NeedsChecks() const { return flags() != WRAP_AND_CALL; }
 
-  void PrintName(std::ostream& os) const OVERRIDE;  // NOLINT
+  void PrintName(std::ostream& os) const override;  // NOLINT
 
   // Minor key encoding in 32 bits with Bitfield <Type, shift, size>.
   class FlagBits : public BitField<CallFunctionFlags, 0, 2> {};
   class ArgcBits : public BitField<unsigned, 2, Code::kArgumentsBits> {};
   STATIC_ASSERT(Code::kArgumentsBits + 2 <= kStubMinorKeyBits);
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(CallFunction);
   DEFINE_PLATFORM_CODE_STUB(CallFunction, PlatformCodeStub);
 };
 
 
 class CallConstructStub: public PlatformCodeStub {
  public:
   CallConstructStub(Isolate* isolate, CallConstructorFlags flags)
       : PlatformCodeStub(isolate) {
     minor_key_ = FlagBits::encode(flags);
   }
 
-  void FinishCode(Handle<Code> code) OVERRIDE {
+  void FinishCode(Handle<Code> code) override {
     code->set_has_function_cache(RecordCallTarget());
   }
 
  private:
   CallConstructorFlags flags() const { return FlagBits::decode(minor_key_); }
 
   bool RecordCallTarget() const {
     return (flags() & RECORD_CONSTRUCTOR_TARGET) != 0;
   }
 
   bool IsSuperConstructorCall() const {
     return (flags() & SUPER_CONSTRUCTOR_CALL) != 0;
   }
 
-  void PrintName(std::ostream& os) const OVERRIDE;  // NOLINT
+  void PrintName(std::ostream& os) const override;  // NOLINT
 
   class FlagBits : public BitField<CallConstructorFlags, 0, 2> {};
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(CallConstruct);
   DEFINE_PLATFORM_CODE_STUB(CallConstruct, PlatformCodeStub);
 };
 
 
 enum StringIndexFlags {
   // Accepts smis or heap numbers.
@@ skipping 178 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(StringCharAtGenerator);
 };
 
 
 class LoadDictionaryElementStub : public HydrogenCodeStub {
  public:
   explicit LoadDictionaryElementStub(Isolate* isolate)
       : HydrogenCodeStub(isolate) {}
 
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+  CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
     if (FLAG_vector_ics) {
       return VectorLoadICDescriptor(isolate());
     }
     return LoadDescriptor(isolate());
   }
 
   DEFINE_HYDROGEN_CODE_STUB(LoadDictionaryElement, HydrogenCodeStub);
 };
 
 
 class KeyedLoadGenericStub : public HydrogenCodeStub {
  public:
   explicit KeyedLoadGenericStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
 
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::KEYED_LOAD_IC; }
-  InlineCacheState GetICState() const OVERRIDE { return GENERIC; }
+  Code::Kind GetCodeKind() const override { return Code::KEYED_LOAD_IC; }
+  InlineCacheState GetICState() const override { return GENERIC; }
 
   // Since KeyedLoadGeneric stub doesn't miss (simply calls runtime), it
   // doesn't need to use the VectorLoadICDescriptor for the case when
   // flag --vector-ics is true.
   DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
 
   DEFINE_HYDROGEN_CODE_STUB(KeyedLoadGeneric, HydrogenCodeStub);
 };
 
 
 class LoadICTrampolineStub : public PlatformCodeStub {
  public:
   LoadICTrampolineStub(Isolate* isolate, const LoadICState& state)
       : PlatformCodeStub(isolate) {
     minor_key_ = state.GetExtraICState();
   }
 
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::LOAD_IC; }
+  Code::Kind GetCodeKind() const override { return Code::LOAD_IC; }
 
-  InlineCacheState GetICState() const FINAL { return DEFAULT; }
+  InlineCacheState GetICState() const final { return DEFAULT; }
 
-  ExtraICState GetExtraICState() const FINAL {
+  ExtraICState GetExtraICState() const final {
     return static_cast<ExtraICState>(minor_key_);
   }
 
  private:
   LoadICState state() const {
     return LoadICState(static_cast<ExtraICState>(minor_key_));
   }
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(VectorLoadICTrampoline);
   DEFINE_PLATFORM_CODE_STUB(LoadICTrampoline, PlatformCodeStub);
 };
 
 
 class KeyedLoadICTrampolineStub : public LoadICTrampolineStub {
  public:
   explicit KeyedLoadICTrampolineStub(Isolate* isolate)
       : LoadICTrampolineStub(isolate, LoadICState(0)) {}
 
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::KEYED_LOAD_IC; }
+  Code::Kind GetCodeKind() const override { return Code::KEYED_LOAD_IC; }
 
   DEFINE_PLATFORM_CODE_STUB(KeyedLoadICTrampoline, LoadICTrampolineStub);
 };
 
 
 class CallICTrampolineStub : public PlatformCodeStub {
  public:
   CallICTrampolineStub(Isolate* isolate, const CallICState& state)
       : PlatformCodeStub(isolate) {
     minor_key_ = state.GetExtraICState();
   }
 
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::CALL_IC; }
+  Code::Kind GetCodeKind() const override { return Code::CALL_IC; }
 
-  InlineCacheState GetICState() const FINAL { return DEFAULT; }
+  InlineCacheState GetICState() const final { return DEFAULT; }
 
-  ExtraICState GetExtraICState() const FINAL {
+  ExtraICState GetExtraICState() const final {
     return static_cast<ExtraICState>(minor_key_);
   }
 
  protected:
   CallICState state() const {
     return CallICState(static_cast<ExtraICState>(minor_key_));
   }
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(CallFunctionWithFeedback);
   DEFINE_PLATFORM_CODE_STUB(CallICTrampoline, PlatformCodeStub);
@@ skipping 10 matching lines @@
 };
 
 
 class MegamorphicLoadStub : public HydrogenCodeStub {
  public:
   MegamorphicLoadStub(Isolate* isolate, const LoadICState& state)
       : HydrogenCodeStub(isolate) {
     set_sub_minor_key(state.GetExtraICState());
   }
 
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::LOAD_IC; }
+  Code::Kind GetCodeKind() const override { return Code::LOAD_IC; }
 
-  InlineCacheState GetICState() const FINAL { return MEGAMORPHIC; }
+  InlineCacheState GetICState() const final { return MEGAMORPHIC; }
 
-  ExtraICState GetExtraICState() const FINAL {
+  ExtraICState GetExtraICState() const final {
     return static_cast<ExtraICState>(sub_minor_key());
   }
 
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+  CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
     if (FLAG_vector_ics) {
       return VectorLoadICDescriptor(isolate());
     }
     return LoadDescriptor(isolate());
   }
 
   DEFINE_HYDROGEN_CODE_STUB(MegamorphicLoad, HydrogenCodeStub);
 };
 
 
 class VectorRawLoadStub : public PlatformCodeStub {
  public:
   explicit VectorRawLoadStub(Isolate* isolate, const LoadICState& state)
       : PlatformCodeStub(isolate) {
     minor_key_ = state.GetExtraICState();
   }
 
   void GenerateForTrampoline(MacroAssembler* masm);
 
-  virtual Code::Kind GetCodeKind() const OVERRIDE { return Code::LOAD_IC; }
+  virtual Code::Kind GetCodeKind() const override { return Code::LOAD_IC; }
 
-  virtual InlineCacheState GetICState() const FINAL OVERRIDE { return DEFAULT; }
+  virtual InlineCacheState GetICState() const final override { return DEFAULT; }
 
-  virtual ExtraICState GetExtraICState() const FINAL OVERRIDE {
+  virtual ExtraICState GetExtraICState() const final override {
     return static_cast<ExtraICState>(minor_key_);
   }
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(VectorLoadIC);
   DEFINE_PLATFORM_CODE_STUB(VectorRawLoad, PlatformCodeStub);
 
  protected:
   void GenerateImpl(MacroAssembler* masm, bool in_frame);
 };
 
 
 class VectorRawKeyedLoadStub : public PlatformCodeStub {
  public:
   explicit VectorRawKeyedLoadStub(Isolate* isolate)
       : PlatformCodeStub(isolate) {}
 
   void GenerateForTrampoline(MacroAssembler* masm);
 
-  virtual Code::Kind GetCodeKind() const OVERRIDE {
+  virtual Code::Kind GetCodeKind() const override {
     return Code::KEYED_LOAD_IC;
   }
 
-  virtual InlineCacheState GetICState() const FINAL OVERRIDE { return DEFAULT; }
+  virtual InlineCacheState GetICState() const final override { return DEFAULT; }
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(VectorLoadIC);
   DEFINE_PLATFORM_CODE_STUB(VectorRawKeyedLoad, PlatformCodeStub);
 
  protected:
   void GenerateImpl(MacroAssembler* masm, bool in_frame);
 };
 
 
 class DoubleToIStub : public PlatformCodeStub {
  public:
   DoubleToIStub(Isolate* isolate, Register source, Register destination,
                 int offset, bool is_truncating, bool skip_fastpath = false)
       : PlatformCodeStub(isolate) {
     minor_key_ = SourceRegisterBits::encode(source.code()) |
                  DestinationRegisterBits::encode(destination.code()) |
                  OffsetBits::encode(offset) |
                  IsTruncatingBits::encode(is_truncating) |
                  SkipFastPathBits::encode(skip_fastpath) |
                  SSE3Bits::encode(CpuFeatures::IsSupported(SSE3) ? 1 : 0);
   }
 
-  bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+  bool SometimesSetsUpAFrame() override { return false; }
 
  private:
   Register source() const {
     return Register::from_code(SourceRegisterBits::decode(minor_key_));
   }
   Register destination() const {
     return Register::from_code(DestinationRegisterBits::decode(minor_key_));
   }
   bool is_truncating() const { return IsTruncatingBits::decode(minor_key_); }
   bool skip_fastpath() const { return SkipFastPathBits::decode(minor_key_); }
@@ skipping 41 matching lines @@
            SlotIndexBits::is_valid(lookup_result->slot_index);
   }
 
  private:
   static const int kContextIndexBits = 13;
   static const int kSlotIndexBits = 13;
   class ContextIndexBits : public BitField<int, 0, kContextIndexBits> {};
   class SlotIndexBits
       : public BitField<int, kContextIndexBits, kSlotIndexBits> {};
 
-  Code::StubType GetStubType() const OVERRIDE { return Code::FAST; }
+  Code::StubType GetStubType() const override { return Code::FAST; }
 
   DEFINE_CODE_STUB_BASE(ScriptContextFieldStub, HandlerStub);
 };
 
 
 class LoadScriptContextFieldStub : public ScriptContextFieldStub {
  public:
   LoadScriptContextFieldStub(
       Isolate* isolate, const ScriptContextTable::LookupResult* lookup_result)
       : ScriptContextFieldStub(isolate, lookup_result) {}
 
  private:
-  Code::Kind kind() const OVERRIDE { return Code::LOAD_IC; }
+  Code::Kind kind() const override { return Code::LOAD_IC; }
 
   DEFINE_HANDLER_CODE_STUB(LoadScriptContextField, ScriptContextFieldStub);
 };
 
 
 class StoreScriptContextFieldStub : public ScriptContextFieldStub {
  public:
   StoreScriptContextFieldStub(
       Isolate* isolate, const ScriptContextTable::LookupResult* lookup_result)
       : ScriptContextFieldStub(isolate, lookup_result) {}
 
  private:
-  Code::Kind kind() const OVERRIDE { return Code::STORE_IC; }
+  Code::Kind kind() const override { return Code::STORE_IC; }
 
   DEFINE_HANDLER_CODE_STUB(StoreScriptContextField, ScriptContextFieldStub);
 };
 
 
 class LoadFastElementStub : public HydrogenCodeStub {
  public:
   LoadFastElementStub(Isolate* isolate, bool is_js_array,
                       ElementsKind elements_kind)
       : HydrogenCodeStub(isolate) {
     set_sub_minor_key(ElementsKindBits::encode(elements_kind) |
                       IsJSArrayBits::encode(is_js_array));
   }
 
   bool is_js_array() const { return IsJSArrayBits::decode(sub_minor_key()); }
 
   ElementsKind elements_kind() const {
     return ElementsKindBits::decode(sub_minor_key());
   }
 
  private:
   class ElementsKindBits: public BitField<ElementsKind, 0, 8> {};
   class IsJSArrayBits: public BitField<bool, 8, 1> {};
 
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE {
+  CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
     if (FLAG_vector_ics) {
       return VectorLoadICDescriptor(isolate());
     }
     return LoadDescriptor(isolate());
   }
 
   DEFINE_HYDROGEN_CODE_STUB(LoadFastElement, HydrogenCodeStub);
 };
 
 
@@ skipping 51 matching lines @@
  private:
   class FromKindBits: public BitField<ElementsKind, 8, 8> {};
   class ToKindBits: public BitField<ElementsKind, 0, 8> {};
   class IsJSArrayBits: public BitField<bool, 16, 1> {};
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(TransitionElementsKind);
   DEFINE_HYDROGEN_CODE_STUB(TransitionElementsKind, HydrogenCodeStub);
 };
 
 
-class AllocateHeapNumberStub FINAL : public HydrogenCodeStub {
+class AllocateHeapNumberStub final : public HydrogenCodeStub {
  public:
   explicit AllocateHeapNumberStub(Isolate* isolate)
       : HydrogenCodeStub(isolate) {}
 
  private:
   DEFINE_CALL_INTERFACE_DESCRIPTOR(AllocateHeapNumber);
   DEFINE_HYDROGEN_CODE_STUB(AllocateHeapNumber, HydrogenCodeStub);
 };
 
 
@@ skipping 45 matching lines @@
 class ArrayNoArgumentConstructorStub : public ArrayConstructorStubBase {
  public:
   ArrayNoArgumentConstructorStub(
       Isolate* isolate,
       ElementsKind kind,
       AllocationSiteOverrideMode override_mode = DONT_OVERRIDE)
       : ArrayConstructorStubBase(isolate, kind, override_mode) {
   }
 
  private:
-  void PrintName(std::ostream& os) const OVERRIDE {  // NOLINT
+  void PrintName(std::ostream& os) const override {  // NOLINT
     BasePrintName(os, "ArrayNoArgumentConstructorStub");
   }
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(ArrayConstructorConstantArgCount);
   DEFINE_HYDROGEN_CODE_STUB(ArrayNoArgumentConstructor,
                             ArrayConstructorStubBase);
 };
 
 
 class ArraySingleArgumentConstructorStub : public ArrayConstructorStubBase {
  public:
   ArraySingleArgumentConstructorStub(
       Isolate* isolate,
       ElementsKind kind,
       AllocationSiteOverrideMode override_mode = DONT_OVERRIDE)
       : ArrayConstructorStubBase(isolate, kind, override_mode) {
   }
 
  private:
-  void PrintName(std::ostream& os) const OVERRIDE {  // NOLINT
+  void PrintName(std::ostream& os) const override {  // NOLINT
     BasePrintName(os, "ArraySingleArgumentConstructorStub");
   }
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(ArrayConstructor);
   DEFINE_HYDROGEN_CODE_STUB(ArraySingleArgumentConstructor,
                             ArrayConstructorStubBase);
 };
 
 
 class ArrayNArgumentsConstructorStub : public ArrayConstructorStubBase {
  public:
   ArrayNArgumentsConstructorStub(
       Isolate* isolate,
       ElementsKind kind,
       AllocationSiteOverrideMode override_mode = DONT_OVERRIDE)
       : ArrayConstructorStubBase(isolate, kind, override_mode) {
   }
 
  private:
-  void PrintName(std::ostream& os) const OVERRIDE {  // NOLINT
+  void PrintName(std::ostream& os) const override {  // NOLINT
     BasePrintName(os, "ArrayNArgumentsConstructorStub");
   }
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(ArrayConstructor);
   DEFINE_HYDROGEN_CODE_STUB(ArrayNArgumentsConstructor,
                             ArrayConstructorStubBase);
 };
 
 
 class InternalArrayConstructorStubBase : public HydrogenCodeStub {
@@ skipping 123 matching lines @@
   ToBooleanStub(Isolate* isolate, ExtraICState state)
       : HydrogenCodeStub(isolate) {
     set_sub_minor_key(TypesBits::encode(static_cast<byte>(state)) |
                       ResultModeBits::encode(RESULT_AS_SMI));
   }
 
   bool UpdateStatus(Handle<Object> object);
   Types types() const { return Types(TypesBits::decode(sub_minor_key())); }
   ResultMode mode() const { return ResultModeBits::decode(sub_minor_key()); }
 
-  Code::Kind GetCodeKind() const OVERRIDE { return Code::TO_BOOLEAN_IC; }
-  void PrintState(std::ostream& os) const OVERRIDE;  // NOLINT
+  Code::Kind GetCodeKind() const override { return Code::TO_BOOLEAN_IC; }
+  void PrintState(std::ostream& os) const override;  // NOLINT
 
-  bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+  bool SometimesSetsUpAFrame() override { return false; }
 
   static Handle<Code> GetUninitialized(Isolate* isolate) {
     return ToBooleanStub(isolate, UNINITIALIZED).GetCode();
   }
 
-  ExtraICState GetExtraICState() const OVERRIDE { return types().ToIntegral(); }
+  ExtraICState GetExtraICState() const override { return types().ToIntegral(); }
 
-  InlineCacheState GetICState() const OVERRIDE {
+  InlineCacheState GetICState() const override {
     if (types().IsEmpty()) {
       return ::v8::internal::UNINITIALIZED;
     } else {
       return MONOMORPHIC;
     }
   }
 
  private:
   ToBooleanStub(Isolate* isolate, InitializationState init_state)
       : HydrogenCodeStub(isolate, init_state) {
@@ skipping 91 matching lines @@
   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
   DEFINE_PLATFORM_CODE_STUB(StubFailureTrampoline, PlatformCodeStub);
 };
 
 
 class ProfileEntryHookStub : public PlatformCodeStub {
  public:
   explicit ProfileEntryHookStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
 
   // The profile entry hook function is not allowed to cause a GC.
-  bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+  bool SometimesSetsUpAFrame() override { return false; }
 
   // Generates a call to the entry hook if it's enabled.
   static void MaybeCallEntryHook(MacroAssembler* masm);
 
  private:
   static void EntryHookTrampoline(intptr_t function,
                                   intptr_t stack_pointer,
                                   Isolate* isolate);
 
   // ProfileEntryHookStub is called at the start of a function, so it has the
   // same register set.
   DEFINE_CALL_INTERFACE_DESCRIPTOR(CallFunction)
   DEFINE_PLATFORM_CODE_STUB(ProfileEntryHook, PlatformCodeStub);
 };
 
 
 class StoreBufferOverflowStub : public PlatformCodeStub {
  public:
   StoreBufferOverflowStub(Isolate* isolate, SaveFPRegsMode save_fp)
       : PlatformCodeStub(isolate) {
     minor_key_ = SaveDoublesBits::encode(save_fp == kSaveFPRegs);
   }
 
   static void GenerateFixedRegStubsAheadOfTime(Isolate* isolate);
-  bool SometimesSetsUpAFrame() OVERRIDE { return false; }
+  bool SometimesSetsUpAFrame() override { return false; }
 
  private:
   bool save_doubles() const { return SaveDoublesBits::decode(minor_key_); }
 
   class SaveDoublesBits : public BitField<bool, 0, 1> {};
 
   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
   DEFINE_PLATFORM_CODE_STUB(StoreBufferOverflow, PlatformCodeStub);
 };
 
 
 class SubStringStub : public PlatformCodeStub {
  public:
   explicit SubStringStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(ContextOnly);
   DEFINE_PLATFORM_CODE_STUB(SubString, PlatformCodeStub);
 };
 
 
-class ToNumberStub FINAL : public PlatformCodeStub {
+class ToNumberStub final : public PlatformCodeStub {
  public:
   explicit ToNumberStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(ToNumber);
   DEFINE_PLATFORM_CODE_STUB(ToNumber, PlatformCodeStub);
 };
 
 
 class StringCompareStub : public PlatformCodeStub {
  public:
   explicit StringCompareStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(ContextOnly);
   DEFINE_PLATFORM_CODE_STUB(StringCompare, PlatformCodeStub);
 };
 
 
 #undef DEFINE_CALL_INTERFACE_DESCRIPTOR
 #undef DEFINE_PLATFORM_CODE_STUB
 #undef DEFINE_HANDLER_CODE_STUB
 #undef DEFINE_HYDROGEN_CODE_STUB
 #undef DEFINE_CODE_STUB
 #undef DEFINE_CODE_STUB_BASE
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_