Add FINAL and OVERRIDE to calling conventions of the JNI compiler
Change-Id: I72d75e6eabbef334a9244668a1b20f7113f76c2b
diff --git a/compiler/jni/quick/arm/calling_convention_arm.h b/compiler/jni/quick/arm/calling_convention_arm.h
index f188700..fc2d857 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 @@
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 b4d0502..2dcf1af 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 @@
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 8412898..445f453 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 @@
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 @@
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 082c1c8..e814c7e 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