Use 'final' and 'override' specifiers directly in ART.

Remove all uses of macros 'FINAL' and 'OVERRIDE' and replace them with
'final' and 'override' specifiers. Remove all definitions of these
macros as well, which were located in these files:
- libartbase/base/macros.h
- test/913-heaps/heaps.cc
- test/ti-agent/ti_macros.h

ART is now using C++14; the 'final' and 'override' specifiers have
been introduced in C++11.

Test: mmma art
Change-Id: I256c7758155a71a2940ef2574925a44076feeebf

3 files changed, 142 insertions, 142 deletions

diff --git a/runtime/verifier/instruction_flags.h b/runtime/verifier/instruction_flags.h
index e67067cdde..e5e71a4d07 100644
--- a/runtime/verifier/instruction_flags.h
+++ b/runtime/verifier/instruction_flags.h
@@ -25,7 +25,7 @@
 namespace art {
 namespace verifier {
 
-class InstructionFlags FINAL {
+class InstructionFlags final {
  public:
   InstructionFlags() : flags_(0) {}
 
diff --git a/runtime/verifier/reg_type.h b/runtime/verifier/reg_type.h
index 29da376091..04a7dfba66 100644
--- a/runtime/verifier/reg_type.h
+++ b/runtime/verifier/reg_type.h
@@ -378,11 +378,11 @@ class RegType {
 };
 
 // Bottom type.
-class ConflictType FINAL : public RegType {
+class ConflictType final : public RegType {
  public:
-  bool IsConflict() const OVERRIDE { return true; }
+  bool IsConflict() const override { return true; }
 
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
   // Get the singleton Conflict instance.
   static const ConflictType* GetInstance() PURE;
@@ -396,7 +396,7 @@ class ConflictType FINAL : public RegType {
   // Destroy the singleton instance.
   static void Destroy();
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kConflict;
   }
 
@@ -414,11 +414,11 @@ class ConflictType FINAL : public RegType {
 // A variant of the bottom type used to specify an undefined value in the
 // incoming registers.
 // Merging with UndefinedType yields ConflictType which is the true bottom.
-class UndefinedType FINAL : public RegType {
+class UndefinedType final : public RegType {
  public:
-  bool IsUndefined() const OVERRIDE { return true; }
+  bool IsUndefined() const override { return true; }
 
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
   // Get the singleton Undefined instance.
   static const UndefinedType* GetInstance() PURE;
@@ -432,7 +432,7 @@ class UndefinedType FINAL : public RegType {
   // Destroy the singleton instance.
   static void Destroy();
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kNotAssignable;
   }
 
@@ -453,7 +453,7 @@ class PrimitiveType : public RegType {
                 const StringPiece& descriptor,
                 uint16_t cache_id) REQUIRES_SHARED(Locks::mutator_lock_);
 
-  bool HasClassVirtual() const OVERRIDE { return true; }
+  bool HasClassVirtual() const override { return true; }
 };
 
 class Cat1Type : public PrimitiveType {
@@ -462,10 +462,10 @@ class Cat1Type : public PrimitiveType {
            uint16_t cache_id) REQUIRES_SHARED(Locks::mutator_lock_);
 };
 
-class IntegerType FINAL : public Cat1Type {
+class IntegerType final : public Cat1Type {
  public:
-  bool IsInteger() const OVERRIDE { return true; }
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsInteger() const override { return true; }
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
   static const IntegerType* CreateInstance(ObjPtr<mirror::Class> klass,
                                            const StringPiece& descriptor,
                                            uint16_t cache_id)
@@ -473,7 +473,7 @@ class IntegerType FINAL : public Cat1Type {
   static const IntegerType* GetInstance() PURE;
   static void Destroy();
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kInteger;
   }
 
@@ -487,10 +487,10 @@ class IntegerType FINAL : public Cat1Type {
   static const IntegerType* instance_;
 };
 
-class BooleanType FINAL : public Cat1Type {
+class BooleanType final : public Cat1Type {
  public:
-  bool IsBoolean() const OVERRIDE { return true; }
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsBoolean() const override { return true; }
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
   static const BooleanType* CreateInstance(ObjPtr<mirror::Class> klass,
                                            const StringPiece& descriptor,
                                            uint16_t cache_id)
@@ -498,7 +498,7 @@ class BooleanType FINAL : public Cat1Type {
   static const BooleanType* GetInstance() PURE;
   static void Destroy();
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kBoolean;
   }
 
@@ -513,10 +513,10 @@ class BooleanType FINAL : public Cat1Type {
   static const BooleanType* instance_;
 };
 
-class ByteType FINAL : public Cat1Type {
+class ByteType final : public Cat1Type {
  public:
-  bool IsByte() const OVERRIDE { return true; }
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsByte() const override { return true; }
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
   static const ByteType* CreateInstance(ObjPtr<mirror::Class> klass,
                                         const StringPiece& descriptor,
                                         uint16_t cache_id)
@@ -524,7 +524,7 @@ class ByteType FINAL : public Cat1Type {
   static const ByteType* GetInstance() PURE;
   static void Destroy();
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kByte;
   }
 
@@ -538,10 +538,10 @@ class ByteType FINAL : public Cat1Type {
   static const ByteType* instance_;
 };
 
-class ShortType FINAL : public Cat1Type {
+class ShortType final : public Cat1Type {
  public:
-  bool IsShort() const OVERRIDE { return true; }
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsShort() const override { return true; }
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
   static const ShortType* CreateInstance(ObjPtr<mirror::Class> klass,
                                          const StringPiece& descriptor,
                                          uint16_t cache_id)
@@ -549,7 +549,7 @@ class ShortType FINAL : public Cat1Type {
   static const ShortType* GetInstance() PURE;
   static void Destroy();
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kShort;
   }
 
@@ -562,10 +562,10 @@ class ShortType FINAL : public Cat1Type {
   static const ShortType* instance_;
 };
 
-class CharType FINAL : public Cat1Type {
+class CharType final : public Cat1Type {
  public:
-  bool IsChar() const OVERRIDE { return true; }
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsChar() const override { return true; }
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
   static const CharType* CreateInstance(ObjPtr<mirror::Class> klass,
                                         const StringPiece& descriptor,
                                         uint16_t cache_id)
@@ -573,7 +573,7 @@ class CharType FINAL : public Cat1Type {
   static const CharType* GetInstance() PURE;
   static void Destroy();
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kChar;
   }
 
@@ -587,10 +587,10 @@ class CharType FINAL : public Cat1Type {
   static const CharType* instance_;
 };
 
-class FloatType FINAL : public Cat1Type {
+class FloatType final : public Cat1Type {
  public:
-  bool IsFloat() const OVERRIDE { return true; }
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsFloat() const override { return true; }
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
   static const FloatType* CreateInstance(ObjPtr<mirror::Class> klass,
                                          const StringPiece& descriptor,
                                          uint16_t cache_id)
@@ -598,7 +598,7 @@ class FloatType FINAL : public Cat1Type {
   static const FloatType* GetInstance() PURE;
   static void Destroy();
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kFloat;
   }
 
@@ -619,11 +619,11 @@ class Cat2Type : public PrimitiveType {
            uint16_t cache_id) REQUIRES_SHARED(Locks::mutator_lock_);
 };
 
-class LongLoType FINAL : public Cat2Type {
+class LongLoType final : public Cat2Type {
  public:
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
-  bool IsLongLo() const OVERRIDE { return true; }
-  bool IsLong() const OVERRIDE { return true; }
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsLongLo() const override { return true; }
+  bool IsLong() const override { return true; }
   static const LongLoType* CreateInstance(ObjPtr<mirror::Class> klass,
                                           const StringPiece& descriptor,
                                           uint16_t cache_id)
@@ -631,7 +631,7 @@ class LongLoType FINAL : public Cat2Type {
   static const LongLoType* GetInstance() PURE;
   static void Destroy();
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kLongLo;
   }
 
@@ -645,10 +645,10 @@ class LongLoType FINAL : public Cat2Type {
   static const LongLoType* instance_;
 };
 
-class LongHiType FINAL : public Cat2Type {
+class LongHiType final : public Cat2Type {
  public:
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
-  bool IsLongHi() const OVERRIDE { return true; }
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsLongHi() const override { return true; }
   static const LongHiType* CreateInstance(ObjPtr<mirror::Class> klass,
                                           const StringPiece& descriptor,
                                           uint16_t cache_id)
@@ -656,7 +656,7 @@ class LongHiType FINAL : public Cat2Type {
   static const LongHiType* GetInstance() PURE;
   static void Destroy();
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kNotAssignable;
   }
 
@@ -670,11 +670,11 @@ class LongHiType FINAL : public Cat2Type {
   static const LongHiType* instance_;
 };
 
-class DoubleLoType FINAL : public Cat2Type {
+class DoubleLoType final : public Cat2Type {
  public:
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
-  bool IsDoubleLo() const OVERRIDE { return true; }
-  bool IsDouble() const OVERRIDE { return true; }
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsDoubleLo() const override { return true; }
+  bool IsDouble() const override { return true; }
   static const DoubleLoType* CreateInstance(ObjPtr<mirror::Class> klass,
                                             const StringPiece& descriptor,
                                             uint16_t cache_id)
@@ -682,7 +682,7 @@ class DoubleLoType FINAL : public Cat2Type {
   static const DoubleLoType* GetInstance() PURE;
   static void Destroy();
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kDoubleLo;
   }
 
@@ -696,10 +696,10 @@ class DoubleLoType FINAL : public Cat2Type {
   static const DoubleLoType* instance_;
 };
 
-class DoubleHiType FINAL : public Cat2Type {
+class DoubleHiType final : public Cat2Type {
  public:
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
-  virtual bool IsDoubleHi() const OVERRIDE { return true; }
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
+  virtual bool IsDoubleHi() const override { return true; }
   static const DoubleHiType* CreateInstance(ObjPtr<mirror::Class> klass,
                                             const StringPiece& descriptor,
                                             uint16_t cache_id)
@@ -707,7 +707,7 @@ class DoubleHiType FINAL : public Cat2Type {
   static const DoubleHiType* GetInstance() PURE;
   static void Destroy();
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kNotAssignable;
   }
 
@@ -751,30 +751,30 @@ class ConstantType : public RegType {
     }
   }
 
-  bool IsZero() const OVERRIDE {
+  bool IsZero() const override {
     return IsPreciseConstant() && ConstantValue() == 0;
   }
-  bool IsOne() const OVERRIDE {
+  bool IsOne() const override {
     return IsPreciseConstant() && ConstantValue() == 1;
   }
 
-  bool IsConstantChar() const OVERRIDE {
+  bool IsConstantChar() const override {
     return IsConstant() && ConstantValue() >= 0 &&
            ConstantValue() <= std::numeric_limits<uint16_t>::max();
   }
-  bool IsConstantByte() const OVERRIDE {
+  bool IsConstantByte() const override {
     return IsConstant() &&
            ConstantValue() >= std::numeric_limits<int8_t>::min() &&
            ConstantValue() <= std::numeric_limits<int8_t>::max();
   }
-  bool IsConstantShort() const OVERRIDE {
+  bool IsConstantShort() const override {
     return IsConstant() &&
            ConstantValue() >= std::numeric_limits<int16_t>::min() &&
            ConstantValue() <= std::numeric_limits<int16_t>::max();
   }
-  virtual bool IsConstantTypes() const OVERRIDE { return true; }
+  virtual bool IsConstantTypes() const override { return true; }
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kNotAssignable;
   }
 
@@ -782,7 +782,7 @@ class ConstantType : public RegType {
   const uint32_t constant_;
 };
 
-class PreciseConstType FINAL : public ConstantType {
+class PreciseConstType final : public ConstantType {
  public:
   PreciseConstType(uint32_t constant, uint16_t cache_id)
       REQUIRES_SHARED(Locks::mutator_lock_)
@@ -790,94 +790,94 @@ class PreciseConstType FINAL : public ConstantType {
     CheckConstructorInvariants(this);
   }
 
-  bool IsPreciseConstant() const OVERRIDE { return true; }
+  bool IsPreciseConstant() const override { return true; }
 
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kNotAssignable;
   }
 };
 
-class PreciseConstLoType FINAL : public ConstantType {
+class PreciseConstLoType final : public ConstantType {
  public:
   PreciseConstLoType(uint32_t constant, uint16_t cache_id)
       REQUIRES_SHARED(Locks::mutator_lock_)
       : ConstantType(constant, cache_id) {
     CheckConstructorInvariants(this);
   }
-  bool IsPreciseConstantLo() const OVERRIDE { return true; }
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsPreciseConstantLo() const override { return true; }
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kNotAssignable;
   }
 };
 
-class PreciseConstHiType FINAL : public ConstantType {
+class PreciseConstHiType final : public ConstantType {
  public:
   PreciseConstHiType(uint32_t constant, uint16_t cache_id)
       REQUIRES_SHARED(Locks::mutator_lock_)
       : ConstantType(constant, cache_id) {
     CheckConstructorInvariants(this);
   }
-  bool IsPreciseConstantHi() const OVERRIDE { return true; }
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsPreciseConstantHi() const override { return true; }
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kNotAssignable;
   }
 };
 
-class ImpreciseConstType FINAL : public ConstantType {
+class ImpreciseConstType final : public ConstantType {
  public:
   ImpreciseConstType(uint32_t constat, uint16_t cache_id)
        REQUIRES_SHARED(Locks::mutator_lock_)
        : ConstantType(constat, cache_id) {
     CheckConstructorInvariants(this);
   }
-  bool IsImpreciseConstant() const OVERRIDE { return true; }
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsImpreciseConstant() const override { return true; }
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kNotAssignable;
   }
 };
 
-class ImpreciseConstLoType FINAL : public ConstantType {
+class ImpreciseConstLoType final : public ConstantType {
  public:
   ImpreciseConstLoType(uint32_t constant, uint16_t cache_id)
       REQUIRES_SHARED(Locks::mutator_lock_)
       : ConstantType(constant, cache_id) {
     CheckConstructorInvariants(this);
   }
-  bool IsImpreciseConstantLo() const OVERRIDE { return true; }
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsImpreciseConstantLo() const override { return true; }
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kNotAssignable;
   }
 };
 
-class ImpreciseConstHiType FINAL : public ConstantType {
+class ImpreciseConstHiType final : public ConstantType {
  public:
   ImpreciseConstHiType(uint32_t constant, uint16_t cache_id)
       REQUIRES_SHARED(Locks::mutator_lock_)
       : ConstantType(constant, cache_id) {
     CheckConstructorInvariants(this);
   }
-  bool IsImpreciseConstantHi() const OVERRIDE { return true; }
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsImpreciseConstantHi() const override { return true; }
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kNotAssignable;
   }
 };
 
 // Special "null" type that captures the semantics of null / bottom.
-class NullType FINAL : public RegType {
+class NullType final : public RegType {
  public:
-  bool IsNull() const OVERRIDE {
+  bool IsNull() const override {
     return true;
   }
 
@@ -892,15 +892,15 @@ class NullType FINAL : public RegType {
 
   static void Destroy();
 
-  std::string Dump() const OVERRIDE {
+  std::string Dump() const override {
     return "null";
   }
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kReference;
   }
 
-  bool IsConstantTypes() const OVERRIDE {
+  bool IsConstantTypes() const override {
     return true;
   }
 
@@ -925,15 +925,15 @@ class UninitializedType : public RegType {
                     uint16_t cache_id)
       : RegType(klass, descriptor, cache_id), allocation_pc_(allocation_pc) {}
 
-  bool IsUninitializedTypes() const OVERRIDE;
-  bool IsNonZeroReferenceTypes() const OVERRIDE;
+  bool IsUninitializedTypes() const override;
+  bool IsNonZeroReferenceTypes() const override;
 
   uint32_t GetAllocationPc() const {
     DCHECK(IsUninitializedTypes());
     return allocation_pc_;
   }
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kReference;
   }
 
@@ -942,7 +942,7 @@ class UninitializedType : public RegType {
 };
 
 // Similar to ReferenceType but not yet having been passed to a constructor.
-class UninitializedReferenceType FINAL : public UninitializedType {
+class UninitializedReferenceType final : public UninitializedType {
  public:
   UninitializedReferenceType(ObjPtr<mirror::Class> klass,
                              const StringPiece& descriptor,
@@ -953,16 +953,16 @@ class UninitializedReferenceType FINAL : public UninitializedType {
     CheckConstructorInvariants(this);
   }
 
-  bool IsUninitializedReference() const OVERRIDE { return true; }
+  bool IsUninitializedReference() const override { return true; }
 
-  bool HasClassVirtual() const OVERRIDE { return true; }
+  bool HasClassVirtual() const override { return true; }
 
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 };
 
 // Similar to UnresolvedReferenceType but not yet having been passed to a
 // constructor.
-class UnresolvedUninitializedRefType FINAL : public UninitializedType {
+class UnresolvedUninitializedRefType final : public UninitializedType {
  public:
   UnresolvedUninitializedRefType(const StringPiece& descriptor,
                                  uint32_t allocation_pc, uint16_t cache_id)
@@ -971,19 +971,19 @@ class UnresolvedUninitializedRefType FINAL : public UninitializedType {
     CheckConstructorInvariants(this);
   }
 
-  bool IsUnresolvedAndUninitializedReference() const OVERRIDE { return true; }
+  bool IsUnresolvedAndUninitializedReference() const override { return true; }
 
-  bool IsUnresolvedTypes() const OVERRIDE { return true; }
+  bool IsUnresolvedTypes() const override { return true; }
 
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
  private:
-  void CheckInvariants() const REQUIRES_SHARED(Locks::mutator_lock_) OVERRIDE;
+  void CheckInvariants() const REQUIRES_SHARED(Locks::mutator_lock_) override;
 };
 
 // Similar to UninitializedReferenceType but special case for the this argument
 // of a constructor.
-class UninitializedThisReferenceType FINAL : public UninitializedType {
+class UninitializedThisReferenceType final : public UninitializedType {
  public:
   UninitializedThisReferenceType(ObjPtr<mirror::Class> klass,
                                  const StringPiece& descriptor,
@@ -993,17 +993,17 @@ class UninitializedThisReferenceType FINAL : public UninitializedType {
     CheckConstructorInvariants(this);
   }
 
-  virtual bool IsUninitializedThisReference() const OVERRIDE { return true; }
+  virtual bool IsUninitializedThisReference() const override { return true; }
 
-  bool HasClassVirtual() const OVERRIDE { return true; }
+  bool HasClassVirtual() const override { return true; }
 
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
  private:
-  void CheckInvariants() const REQUIRES_SHARED(Locks::mutator_lock_) OVERRIDE;
+  void CheckInvariants() const REQUIRES_SHARED(Locks::mutator_lock_) override;
 };
 
-class UnresolvedUninitializedThisRefType FINAL : public UninitializedType {
+class UnresolvedUninitializedThisRefType final : public UninitializedType {
  public:
   UnresolvedUninitializedThisRefType(const StringPiece& descriptor,
                                      uint16_t cache_id)
@@ -1012,19 +1012,19 @@ class UnresolvedUninitializedThisRefType FINAL : public UninitializedType {
     CheckConstructorInvariants(this);
   }
 
-  bool IsUnresolvedAndUninitializedThisReference() const OVERRIDE { return true; }
+  bool IsUnresolvedAndUninitializedThisReference() const override { return true; }
 
-  bool IsUnresolvedTypes() const OVERRIDE { return true; }
+  bool IsUnresolvedTypes() const override { return true; }
 
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
  private:
-  void CheckInvariants() const REQUIRES_SHARED(Locks::mutator_lock_) OVERRIDE;
+  void CheckInvariants() const REQUIRES_SHARED(Locks::mutator_lock_) override;
 };
 
 // A type of register holding a reference to an Object of type GetClass or a
 // sub-class.
-class ReferenceType FINAL : public RegType {
+class ReferenceType final : public RegType {
  public:
   ReferenceType(ObjPtr<mirror::Class> klass,
                 const StringPiece& descriptor,
@@ -1033,15 +1033,15 @@ class ReferenceType FINAL : public RegType {
     CheckConstructorInvariants(this);
   }
 
-  bool IsReference() const OVERRIDE { return true; }
+  bool IsReference() const override { return true; }
 
-  bool IsNonZeroReferenceTypes() const OVERRIDE { return true; }
+  bool IsNonZeroReferenceTypes() const override { return true; }
 
-  bool HasClassVirtual() const OVERRIDE { return true; }
+  bool HasClassVirtual() const override { return true; }
 
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kReference;
   }
 };
@@ -1049,22 +1049,22 @@ class ReferenceType FINAL : public RegType {
 // A type of register holding a reference to an Object of type GetClass and only
 // an object of that
 // type.
-class PreciseReferenceType FINAL : public RegType {
+class PreciseReferenceType final : public RegType {
  public:
   PreciseReferenceType(ObjPtr<mirror::Class> klass,
                        const StringPiece& descriptor,
                        uint16_t cache_id)
       REQUIRES_SHARED(Locks::mutator_lock_);
 
-  bool IsPreciseReference() const OVERRIDE { return true; }
+  bool IsPreciseReference() const override { return true; }
 
-  bool IsNonZeroReferenceTypes() const OVERRIDE { return true; }
+  bool IsNonZeroReferenceTypes() const override { return true; }
 
-  bool HasClassVirtual() const OVERRIDE { return true; }
+  bool HasClassVirtual() const override { return true; }
 
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kReference;
   }
 };
@@ -1076,9 +1076,9 @@ class UnresolvedType : public RegType {
       REQUIRES_SHARED(Locks::mutator_lock_)
       : RegType(nullptr, descriptor, cache_id) {}
 
-  bool IsNonZeroReferenceTypes() const OVERRIDE;
+  bool IsNonZeroReferenceTypes() const override;
 
-  AssignmentType GetAssignmentTypeImpl() const OVERRIDE {
+  AssignmentType GetAssignmentTypeImpl() const override {
     return AssignmentType::kReference;
   }
 };
@@ -1086,7 +1086,7 @@ class UnresolvedType : public RegType {
 // Similar to ReferenceType except the Class couldn't be loaded. Assignability
 // and other tests made
 // of this type must be conservative.
-class UnresolvedReferenceType FINAL : public UnresolvedType {
+class UnresolvedReferenceType final : public UnresolvedType {
  public:
   UnresolvedReferenceType(const StringPiece& descriptor, uint16_t cache_id)
       REQUIRES_SHARED(Locks::mutator_lock_)
@@ -1094,18 +1094,18 @@ class UnresolvedReferenceType FINAL : public UnresolvedType {
     CheckConstructorInvariants(this);
   }
 
-  bool IsUnresolvedReference() const OVERRIDE { return true; }
+  bool IsUnresolvedReference() const override { return true; }
 
-  bool IsUnresolvedTypes() const OVERRIDE { return true; }
+  bool IsUnresolvedTypes() const override { return true; }
 
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
  private:
-  void CheckInvariants() const REQUIRES_SHARED(Locks::mutator_lock_) OVERRIDE;
+  void CheckInvariants() const REQUIRES_SHARED(Locks::mutator_lock_) override;
 };
 
 // Type representing the super-class of an unresolved type.
-class UnresolvedSuperClass FINAL : public UnresolvedType {
+class UnresolvedSuperClass final : public UnresolvedType {
  public:
   UnresolvedSuperClass(uint16_t child_id, RegTypeCache* reg_type_cache,
                        uint16_t cache_id)
@@ -1116,19 +1116,19 @@ class UnresolvedSuperClass FINAL : public UnresolvedType {
     CheckConstructorInvariants(this);
   }
 
-  bool IsUnresolvedSuperClass() const OVERRIDE { return true; }
+  bool IsUnresolvedSuperClass() const override { return true; }
 
-  bool IsUnresolvedTypes() const OVERRIDE { return true; }
+  bool IsUnresolvedTypes() const override { return true; }
 
   uint16_t GetUnresolvedSuperClassChildId() const {
     DCHECK(IsUnresolvedSuperClass());
     return static_cast<uint16_t>(unresolved_child_id_ & 0xFFFF);
   }
 
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
  private:
-  void CheckInvariants() const REQUIRES_SHARED(Locks::mutator_lock_) OVERRIDE;
+  void CheckInvariants() const REQUIRES_SHARED(Locks::mutator_lock_) override;
 
   const uint16_t unresolved_child_id_;
   const RegTypeCache* const reg_type_cache_;
@@ -1136,7 +1136,7 @@ class UnresolvedSuperClass FINAL : public UnresolvedType {
 
 // A merge of unresolved (and resolved) types. If the types were resolved this may be
 // Conflict or another known ReferenceType.
-class UnresolvedMergedType FINAL : public UnresolvedType {
+class UnresolvedMergedType final : public UnresolvedType {
  public:
   // Note: the constructor will copy the unresolved BitVector, not use it directly.
   UnresolvedMergedType(const RegType& resolved,
@@ -1154,17 +1154,17 @@ class UnresolvedMergedType FINAL : public UnresolvedType {
     return unresolved_types_;
   }
 
-  bool IsUnresolvedMergedReference() const OVERRIDE { return true; }
+  bool IsUnresolvedMergedReference() const override { return true; }
 
-  bool IsUnresolvedTypes() const OVERRIDE { return true; }
+  bool IsUnresolvedTypes() const override { return true; }
 
-  bool IsArrayTypes() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
-  bool IsObjectArrayTypes() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsArrayTypes() const override REQUIRES_SHARED(Locks::mutator_lock_);
+  bool IsObjectArrayTypes() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
-  std::string Dump() const OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_);
+  std::string Dump() const override REQUIRES_SHARED(Locks::mutator_lock_);
 
  private:
-  void CheckInvariants() const REQUIRES_SHARED(Locks::mutator_lock_) OVERRIDE;
+  void CheckInvariants() const REQUIRES_SHARED(Locks::mutator_lock_) override;
 
   const RegTypeCache* const reg_type_cache_;
 
diff --git a/runtime/verifier/reg_type_test.cc b/runtime/verifier/reg_type_test.cc
index 15a38f3fd7..0430d205af 100644
--- a/runtime/verifier/reg_type_test.cc
+++ b/runtime/verifier/reg_type_test.cc
@@ -1042,7 +1042,7 @@ TEST_F(RegTypeTest, ConstPrecision) {
 
 class RegTypeOOMTest : public RegTypeTest {
  protected:
-  void SetUpRuntimeOptions(RuntimeOptions *options) OVERRIDE {
+  void SetUpRuntimeOptions(RuntimeOptions *options) override {
     SetUpRuntimeOptionsForFillHeap(options);
 
     // We must not appear to be a compiler, or we'll abort on the host.