Add FINAL and OVERRIDE to calling conventions of the JNI compiler

Change-Id: I72d75e6eabbef334a9244668a1b20f7113f76c2b

4 files changed, 108 insertions, 107 deletions

diff --git a/compiler/jni/quick/arm/calling_convention_arm.h b/compiler/jni/quick/arm/calling_convention_arm.h
index f18870074..fc2d8570f 100644
--- a/compiler/jni/quick/arm/calling_convention_arm.h
+++ b/compiler/jni/quick/arm/calling_convention_arm.h
@@ -22,21 +22,21 @@
 namespace art {
 namespace arm {
 
-class ArmManagedRuntimeCallingConvention : public ManagedRuntimeCallingConvention {
+class ArmManagedRuntimeCallingConvention FINAL : public ManagedRuntimeCallingConvention {
  public:
   ArmManagedRuntimeCallingConvention(bool is_static, bool is_synchronized, const char* shorty)
       : ManagedRuntimeCallingConvention(is_static, is_synchronized, shorty) {}
-  virtual ~ArmManagedRuntimeCallingConvention() {}
+  ~ArmManagedRuntimeCallingConvention() OVERRIDE {}
   // Calling convention
-  virtual ManagedRegister ReturnRegister();
-  virtual ManagedRegister InterproceduralScratchRegister();
+  ManagedRegister ReturnRegister() OVERRIDE;
+  ManagedRegister InterproceduralScratchRegister() OVERRIDE;
   // Managed runtime calling convention
-  virtual ManagedRegister MethodRegister();
-  virtual bool IsCurrentParamInRegister();
-  virtual bool IsCurrentParamOnStack();
-  virtual ManagedRegister CurrentParamRegister();
-  virtual FrameOffset CurrentParamStackOffset();
-  virtual const std::vector<ManagedRegister>& EntrySpills();
+  ManagedRegister MethodRegister() OVERRIDE;
+  bool IsCurrentParamInRegister() OVERRIDE;
+  bool IsCurrentParamOnStack() OVERRIDE;
+  ManagedRegister CurrentParamRegister() OVERRIDE;
+  FrameOffset CurrentParamStackOffset() OVERRIDE;
+  const std::vector<ManagedRegister>& EntrySpills() OVERRIDE;
 
  private:
   std::vector<ManagedRegister> entry_spills_;
@@ -44,33 +44,33 @@ class ArmManagedRuntimeCallingConvention : public ManagedRuntimeCallingConventio
   DISALLOW_COPY_AND_ASSIGN(ArmManagedRuntimeCallingConvention);
 };
 
-class ArmJniCallingConvention : public JniCallingConvention {
+class ArmJniCallingConvention FINAL : public JniCallingConvention {
  public:
   explicit ArmJniCallingConvention(bool is_static, bool is_synchronized, const char* shorty);
-  virtual ~ArmJniCallingConvention() {}
+  ~ArmJniCallingConvention() OVERRIDE {}
   // Calling convention
-  virtual ManagedRegister ReturnRegister();
-  virtual ManagedRegister IntReturnRegister();
-  virtual ManagedRegister InterproceduralScratchRegister();
+  ManagedRegister ReturnRegister() OVERRIDE;
+  ManagedRegister IntReturnRegister() OVERRIDE;
+  ManagedRegister InterproceduralScratchRegister() OVERRIDE;
   // JNI calling convention
-  virtual void Next();  // Override default behavior for AAPCS
-  virtual size_t FrameSize();
-  virtual size_t OutArgSize();
-  virtual const std::vector<ManagedRegister>& CalleeSaveRegisters() const {
+  void Next() OVERRIDE;  // Override default behavior for AAPCS
+  size_t FrameSize() OVERRIDE;
+  size_t OutArgSize() OVERRIDE;
+  const std::vector<ManagedRegister>& CalleeSaveRegisters() const OVERRIDE {
     return callee_save_regs_;
   }
-  virtual ManagedRegister ReturnScratchRegister() const;
-  virtual uint32_t CoreSpillMask() const;
-  virtual uint32_t FpSpillMask() const {
+  ManagedRegister ReturnScratchRegister() const OVERRIDE;
+  uint32_t CoreSpillMask() const OVERRIDE;
+  uint32_t FpSpillMask() const OVERRIDE {
     return 0;  // Floats aren't spilled in JNI down call
   }
-  virtual bool IsCurrentParamInRegister();
-  virtual bool IsCurrentParamOnStack();
-  virtual ManagedRegister CurrentParamRegister();
-  virtual FrameOffset CurrentParamStackOffset();
+  bool IsCurrentParamInRegister() OVERRIDE;
+  bool IsCurrentParamOnStack() OVERRIDE;
+  ManagedRegister CurrentParamRegister() OVERRIDE;
+  FrameOffset CurrentParamStackOffset() OVERRIDE;
 
  protected:
-  virtual size_t NumberOfOutgoingStackArgs();
+  size_t NumberOfOutgoingStackArgs() OVERRIDE;
 
  private:
   // TODO: these values aren't unique and can be shared amongst instances
diff --git a/compiler/jni/quick/arm64/calling_convention_arm64.h b/compiler/jni/quick/arm64/calling_convention_arm64.h
index b4d050275..2dcf1af71 100644
--- a/compiler/jni/quick/arm64/calling_convention_arm64.h
+++ b/compiler/jni/quick/arm64/calling_convention_arm64.h
@@ -22,21 +22,21 @@
 namespace art {
 namespace arm64 {
 
-class Arm64ManagedRuntimeCallingConvention : public ManagedRuntimeCallingConvention {
+class Arm64ManagedRuntimeCallingConvention FINAL : public ManagedRuntimeCallingConvention {
  public:
   Arm64ManagedRuntimeCallingConvention(bool is_static, bool is_synchronized, const char* shorty)
       : ManagedRuntimeCallingConvention(is_static, is_synchronized, shorty) {}
-  virtual ~Arm64ManagedRuntimeCallingConvention() {}
+  ~Arm64ManagedRuntimeCallingConvention() OVERRIDE {}
   // Calling convention
-  virtual ManagedRegister ReturnRegister();
-  virtual ManagedRegister InterproceduralScratchRegister();
+  ManagedRegister ReturnRegister() OVERRIDE;
+  ManagedRegister InterproceduralScratchRegister() OVERRIDE;
   // Managed runtime calling convention
-  virtual ManagedRegister MethodRegister();
-  virtual bool IsCurrentParamInRegister();
-  virtual bool IsCurrentParamOnStack();
-  virtual ManagedRegister CurrentParamRegister();
-  virtual FrameOffset CurrentParamStackOffset();
-  virtual const std::vector<ManagedRegister>& EntrySpills();
+  ManagedRegister MethodRegister() OVERRIDE;
+  bool IsCurrentParamInRegister() OVERRIDE;
+  bool IsCurrentParamOnStack() OVERRIDE;
+  ManagedRegister CurrentParamRegister() OVERRIDE;
+  FrameOffset CurrentParamStackOffset() OVERRIDE;
+  const std::vector<ManagedRegister>& EntrySpills() OVERRIDE;
 
  private:
   std::vector<ManagedRegister> entry_spills_;
@@ -44,33 +44,33 @@ class Arm64ManagedRuntimeCallingConvention : public ManagedRuntimeCallingConvent
   DISALLOW_COPY_AND_ASSIGN(Arm64ManagedRuntimeCallingConvention);
 };
 
-class Arm64JniCallingConvention : public JniCallingConvention {
+class Arm64JniCallingConvention FINAL : public JniCallingConvention {
  public:
   explicit Arm64JniCallingConvention(bool is_static, bool is_synchronized, const char* shorty);
-  virtual ~Arm64JniCallingConvention() {}
+  ~Arm64JniCallingConvention() OVERRIDE {}
   // Calling convention
-  virtual ManagedRegister ReturnRegister();
-  virtual ManagedRegister IntReturnRegister();
-  virtual ManagedRegister InterproceduralScratchRegister();
+  ManagedRegister ReturnRegister() OVERRIDE;
+  ManagedRegister IntReturnRegister() OVERRIDE;
+  ManagedRegister InterproceduralScratchRegister() OVERRIDE;
   // JNI calling convention
-  virtual void Next();  // Override default behavior for AAPCS
-  virtual size_t FrameSize();
-  virtual size_t OutArgSize();
-  virtual const std::vector<ManagedRegister>& CalleeSaveRegisters() const {
+  void Next() OVERRIDE;  // Override default behavior for AAPCS
+  size_t FrameSize() OVERRIDE;
+  size_t OutArgSize() OVERRIDE;
+  const std::vector<ManagedRegister>& CalleeSaveRegisters() const OVERRIDE {
     return callee_save_regs_;
   }
-  virtual ManagedRegister ReturnScratchRegister() const;
-  virtual uint32_t CoreSpillMask() const;
-  virtual uint32_t FpSpillMask() const {
+  ManagedRegister ReturnScratchRegister() const OVERRIDE;
+  uint32_t CoreSpillMask() const OVERRIDE;
+  uint32_t FpSpillMask() const OVERRIDE {
     return 0;  // Floats aren't spilled in JNI down call
   }
-  virtual bool IsCurrentParamInRegister();
-  virtual bool IsCurrentParamOnStack();
-  virtual ManagedRegister CurrentParamRegister();
-  virtual FrameOffset CurrentParamStackOffset();
+  bool IsCurrentParamInRegister() OVERRIDE;
+  bool IsCurrentParamOnStack() OVERRIDE;
+  ManagedRegister CurrentParamRegister() OVERRIDE;
+  FrameOffset CurrentParamStackOffset() OVERRIDE;
 
  protected:
-  virtual size_t NumberOfOutgoingStackArgs();
+  size_t NumberOfOutgoingStackArgs() OVERRIDE;
 
  private:
   // TODO: these values aren't unique and can be shared amongst instances
diff --git a/compiler/jni/quick/mips/calling_convention_mips.h b/compiler/jni/quick/mips/calling_convention_mips.h
index 8412898dd..445f45394 100644
--- a/compiler/jni/quick/mips/calling_convention_mips.h
+++ b/compiler/jni/quick/mips/calling_convention_mips.h
@@ -21,21 +21,21 @@
 
 namespace art {
 namespace mips {
-class MipsManagedRuntimeCallingConvention : public ManagedRuntimeCallingConvention {
+class MipsManagedRuntimeCallingConvention FINAL : public ManagedRuntimeCallingConvention {
  public:
   MipsManagedRuntimeCallingConvention(bool is_static, bool is_synchronized, const char* shorty)
       : ManagedRuntimeCallingConvention(is_static, is_synchronized, shorty) {}
-  virtual ~MipsManagedRuntimeCallingConvention() {}
+  ~MipsManagedRuntimeCallingConvention() OVERRIDE {}
   // Calling convention
-  virtual ManagedRegister ReturnRegister();
-  virtual ManagedRegister InterproceduralScratchRegister();
+  ManagedRegister ReturnRegister() OVERRIDE;
+  ManagedRegister InterproceduralScratchRegister() OVERRIDE;
   // Managed runtime calling convention
-  virtual ManagedRegister MethodRegister();
-  virtual bool IsCurrentParamInRegister();
-  virtual bool IsCurrentParamOnStack();
-  virtual ManagedRegister CurrentParamRegister();
-  virtual FrameOffset CurrentParamStackOffset();
-  virtual const std::vector<ManagedRegister>& EntrySpills();
+  ManagedRegister MethodRegister() OVERRIDE;
+  bool IsCurrentParamInRegister() OVERRIDE;
+  bool IsCurrentParamOnStack() OVERRIDE;
+  ManagedRegister CurrentParamRegister() OVERRIDE;
+  FrameOffset CurrentParamStackOffset() OVERRIDE;
+  const std::vector<ManagedRegister>& EntrySpills() OVERRIDE;
 
  private:
   std::vector<ManagedRegister> entry_spills_;
@@ -43,33 +43,33 @@ class MipsManagedRuntimeCallingConvention : public ManagedRuntimeCallingConventi
   DISALLOW_COPY_AND_ASSIGN(MipsManagedRuntimeCallingConvention);
 };
 
-class MipsJniCallingConvention : public JniCallingConvention {
+class MipsJniCallingConvention FINAL : public JniCallingConvention {
  public:
   explicit MipsJniCallingConvention(bool is_static, bool is_synchronized, const char* shorty);
-  virtual ~MipsJniCallingConvention() {}
+  ~MipsJniCallingConvention() OVERRIDE {}
   // Calling convention
-  virtual ManagedRegister ReturnRegister();
-  virtual ManagedRegister IntReturnRegister();
-  virtual ManagedRegister InterproceduralScratchRegister();
+  ManagedRegister ReturnRegister() OVERRIDE;
+  ManagedRegister IntReturnRegister() OVERRIDE;
+  ManagedRegister InterproceduralScratchRegister() OVERRIDE;
   // JNI calling convention
-  virtual void Next();  // Override default behavior for AAPCS
-  virtual size_t FrameSize();
-  virtual size_t OutArgSize();
-  virtual const std::vector<ManagedRegister>& CalleeSaveRegisters() const {
+  void Next() OVERRIDE;  // Override default behavior for AAPCS
+  size_t FrameSize() OVERRIDE;
+  size_t OutArgSize() OVERRIDE;
+  const std::vector<ManagedRegister>& CalleeSaveRegisters() const OVERRIDE {
     return callee_save_regs_;
   }
-  virtual ManagedRegister ReturnScratchRegister() const;
-  virtual uint32_t CoreSpillMask() const;
-  virtual uint32_t FpSpillMask() const {
+  ManagedRegister ReturnScratchRegister() const OVERRIDE;
+  uint32_t CoreSpillMask() const OVERRIDE;
+  uint32_t FpSpillMask() const OVERRIDE {
     return 0;  // Floats aren't spilled in JNI down call
   }
-  virtual bool IsCurrentParamInRegister();
-  virtual bool IsCurrentParamOnStack();
-  virtual ManagedRegister CurrentParamRegister();
-  virtual FrameOffset CurrentParamStackOffset();
+  bool IsCurrentParamInRegister() OVERRIDE;
+  bool IsCurrentParamOnStack() OVERRIDE;
+  ManagedRegister CurrentParamRegister() OVERRIDE;
+  FrameOffset CurrentParamStackOffset() OVERRIDE;
 
  protected:
-  virtual size_t NumberOfOutgoingStackArgs();
+  size_t NumberOfOutgoingStackArgs() OVERRIDE;
 
  private:
   // TODO: these values aren't unique and can be shared amongst instances
@@ -80,6 +80,7 @@ class MipsJniCallingConvention : public JniCallingConvention {
 
   DISALLOW_COPY_AND_ASSIGN(MipsJniCallingConvention);
 };
+
 }  // namespace mips
 }  // namespace art
 
diff --git a/compiler/jni/quick/x86/calling_convention_x86.h b/compiler/jni/quick/x86/calling_convention_x86.h
index 082c1c8eb..e814c7e53 100644
--- a/compiler/jni/quick/x86/calling_convention_x86.h
+++ b/compiler/jni/quick/x86/calling_convention_x86.h
@@ -22,53 +22,53 @@
 namespace art {
 namespace x86 {
 
-class X86ManagedRuntimeCallingConvention : public ManagedRuntimeCallingConvention {
+class X86ManagedRuntimeCallingConvention FINAL : public ManagedRuntimeCallingConvention {
  public:
   explicit X86ManagedRuntimeCallingConvention(bool is_static, bool is_synchronized,
                                               const char* shorty)
       : ManagedRuntimeCallingConvention(is_static, is_synchronized, shorty) {}
-  virtual ~X86ManagedRuntimeCallingConvention() {}
+  ~X86ManagedRuntimeCallingConvention() OVERRIDE {}
   // Calling convention
-  virtual ManagedRegister ReturnRegister();
-  virtual ManagedRegister InterproceduralScratchRegister();
+  ManagedRegister ReturnRegister() OVERRIDE;
+  ManagedRegister InterproceduralScratchRegister() OVERRIDE;
   // Managed runtime calling convention
-  virtual ManagedRegister MethodRegister();
-  virtual bool IsCurrentParamInRegister();
-  virtual bool IsCurrentParamOnStack();
-  virtual ManagedRegister CurrentParamRegister();
-  virtual FrameOffset CurrentParamStackOffset();
-  virtual const std::vector<ManagedRegister>& EntrySpills();
+  ManagedRegister MethodRegister() OVERRIDE;
+  bool IsCurrentParamInRegister() OVERRIDE;
+  bool IsCurrentParamOnStack() OVERRIDE;
+  ManagedRegister CurrentParamRegister() OVERRIDE;
+  FrameOffset CurrentParamStackOffset() OVERRIDE;
+  const std::vector<ManagedRegister>& EntrySpills() OVERRIDE;
  private:
   std::vector<ManagedRegister> entry_spills_;
   DISALLOW_COPY_AND_ASSIGN(X86ManagedRuntimeCallingConvention);
 };
 
-class X86JniCallingConvention : public JniCallingConvention {
+class X86JniCallingConvention FINAL : public JniCallingConvention {
  public:
   explicit X86JniCallingConvention(bool is_static, bool is_synchronized, const char* shorty);
-  virtual ~X86JniCallingConvention() {}
+  ~X86JniCallingConvention() OVERRIDE {}
   // Calling convention
-  virtual ManagedRegister ReturnRegister();
-  virtual ManagedRegister IntReturnRegister();
-  virtual ManagedRegister InterproceduralScratchRegister();
+  ManagedRegister ReturnRegister() OVERRIDE;
+  ManagedRegister IntReturnRegister() OVERRIDE;
+  ManagedRegister InterproceduralScratchRegister() OVERRIDE;
   // JNI calling convention
-  virtual size_t FrameSize();
-  virtual size_t OutArgSize();
-  virtual const std::vector<ManagedRegister>& CalleeSaveRegisters() const {
+  size_t FrameSize() OVERRIDE;
+  size_t OutArgSize() OVERRIDE;
+  const std::vector<ManagedRegister>& CalleeSaveRegisters() const OVERRIDE {
     return callee_save_regs_;
   }
-  virtual ManagedRegister ReturnScratchRegister() const;
-  virtual uint32_t CoreSpillMask() const;
-  virtual uint32_t FpSpillMask() const {
+  ManagedRegister ReturnScratchRegister() const OVERRIDE;
+  uint32_t CoreSpillMask() const OVERRIDE;
+  uint32_t FpSpillMask() const OVERRIDE {
     return 0;
   }
-  virtual bool IsCurrentParamInRegister();
-  virtual bool IsCurrentParamOnStack();
-  virtual ManagedRegister CurrentParamRegister();
-  virtual FrameOffset CurrentParamStackOffset();
+  bool IsCurrentParamInRegister() OVERRIDE;
+  bool IsCurrentParamOnStack() OVERRIDE;
+  ManagedRegister CurrentParamRegister() OVERRIDE;
+  FrameOffset CurrentParamStackOffset() OVERRIDE;
 
  protected:
-  virtual size_t NumberOfOutgoingStackArgs();
+  size_t NumberOfOutgoingStackArgs() OVERRIDE;
 
  private:
   // TODO: these values aren't unique and can be shared amongst instances