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

src/compiler/register-allocator.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_REGISTER_ALLOCATOR_H_
 #define V8_REGISTER_ALLOCATOR_H_
 
 #include "src/compiler/instruction.h"
 #include "src/zone-containers.h"
 
@@ skipping 14 matching lines @@
 //   [[START, END], [START, END]]
 //
 // Where the first half position corresponds to
 //
 //  [GapPosition::START, GapPosition::END]
 //
 // and the second half position corresponds to
 //
 //  [Lifetime::USED_AT_START, Lifetime::USED_AT_END]
 //
-class LifetimePosition FINAL {
+class LifetimePosition final {
  public:
   // Return the lifetime position that corresponds to the beginning of
   // the gap with the given index.
   static LifetimePosition GapFromInstructionIndex(int index) {
     return LifetimePosition(index * kStep);
   }
   // Return the lifetime position that corresponds to the beginning of
   // the instruction with the given index.
   static LifetimePosition InstructionFromInstructionIndex(int index) {
     return LifetimePosition(index * kStep + kHalfStep);
@@ skipping 77 matching lines @@
   // Code relies on kStep and kHalfStep being a power of two.
   STATIC_ASSERT(IS_POWER_OF_TWO(kHalfStep));
 
   explicit LifetimePosition(int value) : value_(value) {}
 
   int value_;
 };
 
 
 // Representation of the non-empty interval [start,end[.
-class UseInterval FINAL : public ZoneObject {
+class UseInterval final : public ZoneObject {
  public:
   UseInterval(LifetimePosition start, LifetimePosition end)
       : start_(start), end_(end), next_(nullptr) {
     DCHECK(start.Value() < end.Value());
   }
 
   LifetimePosition start() const { return start_; }
   LifetimePosition end() const { return end_; }
   UseInterval* next() const { return next_; }
 
@@ skipping 22 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UseInterval);
 };
 
 
 enum class UsePositionType : uint8_t { kAny, kRequiresRegister, kRequiresSlot };
 
 
 // Representation of a use position.
-class UsePosition FINAL : public ZoneObject {
+class UsePosition final : public ZoneObject {
  public:
   UsePosition(LifetimePosition pos, InstructionOperand* operand,
               InstructionOperand* hint);
 
   InstructionOperand* operand() const { return operand_; }
   bool HasOperand() const { return operand_ != nullptr; }
 
   InstructionOperand* hint() const { return hint_; }
   bool HasHint() const;
   bool RegisterIsBeneficial() const {
@@ skipping 18 matching lines @@
   uint8_t flags_;
 
   DISALLOW_COPY_AND_ASSIGN(UsePosition);
 };
 
 class SpillRange;
 
 
 // Representation of SSA values' live ranges as a collection of (continuous)
 // intervals over the instruction ordering.
-class LiveRange FINAL : public ZoneObject {
+class LiveRange final : public ZoneObject {
  public:
   static const int kInvalidAssignment = 0x7fffffff;
 
   LiveRange(int id, Zone* zone);
 
   UseInterval* first_interval() const { return first_interval_; }
   UsePosition* first_pos() const { return first_pos_; }
   LiveRange* parent() const { return parent_; }
   LiveRange* TopLevel() { return (parent_ == nullptr) ? this : parent_; }
   const LiveRange* TopLevel() const {
@@ skipping 154 matching lines @@
     SpillRange* spill_range_;
   };
   SpillAtDefinitionList* spills_at_definition_;
 
   friend class RegisterAllocator;  // Assigns to kind_.
 
   DISALLOW_COPY_AND_ASSIGN(LiveRange);
 };
 
 
-class SpillRange FINAL : public ZoneObject {
+class SpillRange final : public ZoneObject {
  public:
   SpillRange(LiveRange* range, Zone* zone);
 
   UseInterval* interval() const { return use_interval_; }
   RegisterKind Kind() const { return live_ranges_[0]->Kind(); }
   bool IsEmpty() const { return live_ranges_.empty(); }
   bool TryMerge(SpillRange* other);
   void SetOperand(AllocatedOperand* op);
 
  private:
   LifetimePosition End() const { return end_position_; }
   ZoneVector<LiveRange*>& live_ranges() { return live_ranges_; }
   bool IsIntersectingWith(SpillRange* other) const;
   // Merge intervals, making sure the use intervals are sorted
   void MergeDisjointIntervals(UseInterval* other);
 
   ZoneVector<LiveRange*> live_ranges_;
   UseInterval* use_interval_;
   LifetimePosition end_position_;
 
   DISALLOW_COPY_AND_ASSIGN(SpillRange);
 };
 
 
-class RegisterAllocator FINAL : public ZoneObject {
+class RegisterAllocator final : public ZoneObject {
  public:
   explicit RegisterAllocator(const RegisterConfiguration* config,
                              Zone* local_zone, Frame* frame,
                              InstructionSequence* code,
                              const char* debug_name = nullptr);
 
   const ZoneVector<LiveRange*>& live_ranges() const { return live_ranges_; }
   const ZoneVector<LiveRange*>& fixed_live_ranges() const {
     return fixed_live_ranges_;
   }
@@ skipping 235 matching lines @@
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(RegisterAllocator);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_REGISTER_ALLOCATOR_H_