diff options
Diffstat (limited to 'compiler/utils')
22 files changed, 392 insertions, 392 deletions
diff --git a/compiler/utils/arm/assembler_arm_vixl.h b/compiler/utils/arm/assembler_arm_vixl.h index b0310f2fb6..98c0191679 100644 --- a/compiler/utils/arm/assembler_arm_vixl.h +++ b/compiler/utils/arm/assembler_arm_vixl.h @@ -39,7 +39,7 @@ namespace vixl32 = vixl::aarch32; namespace art { namespace arm { -class ArmVIXLMacroAssembler FINAL : public vixl32::MacroAssembler { +class ArmVIXLMacroAssembler final : public vixl32::MacroAssembler { public: // Most methods fit in a 1KB code buffer, which results in more optimal alloc/realloc and // fewer system calls than a larger default capacity. @@ -149,7 +149,7 @@ class ArmVIXLMacroAssembler FINAL : public vixl32::MacroAssembler { using MacroAssembler::Vmov; }; -class ArmVIXLAssembler FINAL : public Assembler { +class ArmVIXLAssembler final : public Assembler { private: class ArmException; public: @@ -161,19 +161,19 @@ class ArmVIXLAssembler FINAL : public Assembler { virtual ~ArmVIXLAssembler() {} ArmVIXLMacroAssembler* GetVIXLAssembler() { return &vixl_masm_; } - void FinalizeCode() OVERRIDE; + void FinalizeCode() override; // Size of generated code. - size_t CodeSize() const OVERRIDE; - const uint8_t* CodeBufferBaseAddress() const OVERRIDE; + size_t CodeSize() const override; + const uint8_t* CodeBufferBaseAddress() const override; // Copy instructions out of assembly buffer into the given region of memory. - void FinalizeInstructions(const MemoryRegion& region) OVERRIDE; + void FinalizeInstructions(const MemoryRegion& region) override; - void Bind(Label* label ATTRIBUTE_UNUSED) OVERRIDE { + void Bind(Label* label ATTRIBUTE_UNUSED) override { UNIMPLEMENTED(FATAL) << "Do not use Bind for ARM"; } - void Jump(Label* label ATTRIBUTE_UNUSED) OVERRIDE { + void Jump(Label* label ATTRIBUTE_UNUSED) override { UNIMPLEMENTED(FATAL) << "Do not use Jump for ARM"; } diff --git a/compiler/utils/arm/jni_macro_assembler_arm_vixl.h b/compiler/utils/arm/jni_macro_assembler_arm_vixl.h index 4bc5d69f4d..674bf12f89 100644 --- a/compiler/utils/arm/jni_macro_assembler_arm_vixl.h +++ b/compiler/utils/arm/jni_macro_assembler_arm_vixl.h @@ -32,7 +32,7 @@ namespace art { namespace arm { -class ArmVIXLJNIMacroAssembler FINAL +class ArmVIXLJNIMacroAssembler final : public JNIMacroAssemblerFwd<ArmVIXLAssembler, PointerSize::k32> { private: class ArmException; @@ -42,7 +42,7 @@ class ArmVIXLJNIMacroAssembler FINAL exception_blocks_(allocator->Adapter(kArenaAllocAssembler)) {} virtual ~ArmVIXLJNIMacroAssembler() {} - void FinalizeCode() OVERRIDE; + void FinalizeCode() override; // // Overridden common assembler high-level functionality @@ -52,109 +52,109 @@ class ArmVIXLJNIMacroAssembler FINAL void BuildFrame(size_t frame_size, ManagedRegister method_reg, ArrayRef<const ManagedRegister> callee_save_regs, - const ManagedRegisterEntrySpills& entry_spills) OVERRIDE; + const ManagedRegisterEntrySpills& entry_spills) override; // Emit code that will remove an activation from the stack. void RemoveFrame(size_t frame_size, ArrayRef<const ManagedRegister> callee_save_regs, - bool may_suspend) OVERRIDE; + bool may_suspend) override; - void IncreaseFrameSize(size_t adjust) OVERRIDE; - void DecreaseFrameSize(size_t adjust) OVERRIDE; + void IncreaseFrameSize(size_t adjust) override; + void DecreaseFrameSize(size_t adjust) override; // Store routines. - void Store(FrameOffset offs, ManagedRegister src, size_t size) OVERRIDE; - void StoreRef(FrameOffset dest, ManagedRegister src) OVERRIDE; - void StoreRawPtr(FrameOffset dest, ManagedRegister src) OVERRIDE; + void Store(FrameOffset offs, ManagedRegister src, size_t size) override; + void StoreRef(FrameOffset dest, ManagedRegister src) override; + void StoreRawPtr(FrameOffset dest, ManagedRegister src) override; - void StoreImmediateToFrame(FrameOffset dest, uint32_t imm, ManagedRegister scratch) OVERRIDE; + void StoreImmediateToFrame(FrameOffset dest, uint32_t imm, ManagedRegister scratch) override; void StoreStackOffsetToThread(ThreadOffset32 thr_offs, FrameOffset fr_offs, - ManagedRegister scratch) OVERRIDE; + ManagedRegister scratch) override; - void StoreStackPointerToThread(ThreadOffset32 thr_offs) OVERRIDE; + void StoreStackPointerToThread(ThreadOffset32 thr_offs) override; void StoreSpanning(FrameOffset dest, ManagedRegister src, FrameOffset in_off, - ManagedRegister scratch) OVERRIDE; + ManagedRegister scratch) override; // Load routines. - void Load(ManagedRegister dest, FrameOffset src, size_t size) OVERRIDE; + void Load(ManagedRegister dest, FrameOffset src, size_t size) override; void LoadFromThread(ManagedRegister dest, ThreadOffset32 src, - size_t size) OVERRIDE; + size_t size) override; - void LoadRef(ManagedRegister dest, FrameOffset src) OVERRIDE; + void LoadRef(ManagedRegister dest, FrameOffset src) override; void LoadRef(ManagedRegister dest, ManagedRegister base, MemberOffset offs, - bool unpoison_reference) OVERRIDE; + bool unpoison_reference) override; - void LoadRawPtr(ManagedRegister dest, ManagedRegister base, Offset offs) OVERRIDE; + void LoadRawPtr(ManagedRegister dest, ManagedRegister base, Offset offs) override; - void LoadRawPtrFromThread(ManagedRegister dest, ThreadOffset32 offs) OVERRIDE; + void LoadRawPtrFromThread(ManagedRegister dest, ThreadOffset32 offs) override; // Copying routines. - void Move(ManagedRegister dest, ManagedRegister src, size_t size) OVERRIDE; + void Move(ManagedRegister dest, ManagedRegister src, size_t size) override; void CopyRawPtrFromThread(FrameOffset fr_offs, ThreadOffset32 thr_offs, - ManagedRegister scratch) OVERRIDE; + ManagedRegister scratch) override; void CopyRawPtrToThread(ThreadOffset32 thr_offs, FrameOffset fr_offs, - ManagedRegister scratch) OVERRIDE; + ManagedRegister scratch) override; - void CopyRef(FrameOffset dest, FrameOffset src, ManagedRegister scratch) OVERRIDE; + void CopyRef(FrameOffset dest, FrameOffset src, ManagedRegister scratch) override; - void Copy(FrameOffset dest, FrameOffset src, ManagedRegister scratch, size_t size) OVERRIDE; + void Copy(FrameOffset dest, FrameOffset src, ManagedRegister scratch, size_t size) override; void Copy(FrameOffset dest, ManagedRegister src_base, Offset src_offset, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(ManagedRegister dest_base, Offset dest_offset, FrameOffset src, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(FrameOffset dest, FrameOffset src_base, Offset src_offset, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(ManagedRegister dest, Offset dest_offset, ManagedRegister src, Offset src_offset, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(FrameOffset dest, Offset dest_offset, FrameOffset src, Offset src_offset, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; // Sign extension. - void SignExtend(ManagedRegister mreg, size_t size) OVERRIDE; + void SignExtend(ManagedRegister mreg, size_t size) override; // Zero extension. - void ZeroExtend(ManagedRegister mreg, size_t size) OVERRIDE; + void ZeroExtend(ManagedRegister mreg, size_t size) override; // Exploit fast access in managed code to Thread::Current(). - void GetCurrentThread(ManagedRegister mtr) OVERRIDE; + void GetCurrentThread(ManagedRegister mtr) override; void GetCurrentThread(FrameOffset dest_offset, - ManagedRegister scratch) OVERRIDE; + ManagedRegister scratch) override; // Set up out_reg to hold a Object** into the handle scope, or to be null if the // value is null and null_allowed. in_reg holds a possibly stale reference @@ -163,43 +163,43 @@ class ArmVIXLJNIMacroAssembler FINAL void CreateHandleScopeEntry(ManagedRegister out_reg, FrameOffset handlescope_offset, ManagedRegister in_reg, - bool null_allowed) OVERRIDE; + bool null_allowed) override; // Set up out_off to hold a Object** into the handle scope, or to be null if the // value is null and null_allowed. void CreateHandleScopeEntry(FrameOffset out_off, FrameOffset handlescope_offset, ManagedRegister scratch, - bool null_allowed) OVERRIDE; + bool null_allowed) override; // src holds a handle scope entry (Object**) load this into dst. void LoadReferenceFromHandleScope(ManagedRegister dst, - ManagedRegister src) OVERRIDE; + ManagedRegister src) override; // Heap::VerifyObject on src. In some cases (such as a reference to this) we // know that src may not be null. - void VerifyObject(ManagedRegister src, bool could_be_null) OVERRIDE; - void VerifyObject(FrameOffset src, bool could_be_null) OVERRIDE; + void VerifyObject(ManagedRegister src, bool could_be_null) override; + void VerifyObject(FrameOffset src, bool could_be_null) override; // Call to address held at [base+offset]. - void Call(ManagedRegister base, Offset offset, ManagedRegister scratch) OVERRIDE; - void Call(FrameOffset base, Offset offset, ManagedRegister scratch) OVERRIDE; - void CallFromThread(ThreadOffset32 offset, ManagedRegister scratch) OVERRIDE; + void Call(ManagedRegister base, Offset offset, ManagedRegister scratch) override; + void Call(FrameOffset base, Offset offset, ManagedRegister scratch) override; + void CallFromThread(ThreadOffset32 offset, ManagedRegister scratch) override; // Generate code to check if Thread::Current()->exception_ is non-null // and branch to a ExceptionSlowPath if it is. void ExceptionPoll(ManagedRegister scratch, size_t stack_adjust); // Create a new label that can be used with Jump/Bind calls. - std::unique_ptr<JNIMacroLabel> CreateLabel() OVERRIDE; + std::unique_ptr<JNIMacroLabel> CreateLabel() override; // Emit an unconditional jump to the label. - void Jump(JNIMacroLabel* label) OVERRIDE; + void Jump(JNIMacroLabel* label) override; // Emit a conditional jump to the label by applying a unary condition test to the register. - void Jump(JNIMacroLabel* label, JNIMacroUnaryCondition cond, ManagedRegister test) OVERRIDE; + void Jump(JNIMacroLabel* label, JNIMacroUnaryCondition cond, ManagedRegister test) override; // Code at this offset will serve as the target for the Jump call. - void Bind(JNIMacroLabel* label) OVERRIDE; + void Bind(JNIMacroLabel* label) override; - void MemoryBarrier(ManagedRegister scratch) OVERRIDE; + void MemoryBarrier(ManagedRegister scratch) override; void EmitExceptionPoll(ArmVIXLJNIMacroAssembler::ArmException *exception); void Load(ArmManagedRegister dest, vixl32::Register base, int32_t offset, size_t size); @@ -231,7 +231,7 @@ class ArmVIXLJNIMacroAssembler FINAL friend class ArmVIXLAssemblerTest_VixlStoreToOffset_Test; }; -class ArmVIXLJNIMacroLabel FINAL +class ArmVIXLJNIMacroLabel final : public JNIMacroLabelCommon<ArmVIXLJNIMacroLabel, vixl32::Label, InstructionSet::kArm> { diff --git a/compiler/utils/arm64/assembler_arm64.h b/compiler/utils/arm64/assembler_arm64.h index 8983af2677..74537dd5a3 100644 --- a/compiler/utils/arm64/assembler_arm64.h +++ b/compiler/utils/arm64/assembler_arm64.h @@ -61,7 +61,7 @@ enum StoreOperandType { kStoreDWord }; -class Arm64Assembler FINAL : public Assembler { +class Arm64Assembler final : public Assembler { public: explicit Arm64Assembler(ArenaAllocator* allocator) : Assembler(allocator) {} @@ -70,11 +70,11 @@ class Arm64Assembler FINAL : public Assembler { vixl::aarch64::MacroAssembler* GetVIXLAssembler() { return &vixl_masm_; } // Finalize the code. - void FinalizeCode() OVERRIDE; + void FinalizeCode() override; // Size of generated code. - size_t CodeSize() const OVERRIDE; - const uint8_t* CodeBufferBaseAddress() const OVERRIDE; + size_t CodeSize() const override; + const uint8_t* CodeBufferBaseAddress() const override; // Copy instructions out of assembly buffer into the given region of memory. void FinalizeInstructions(const MemoryRegion& region); @@ -109,10 +109,10 @@ class Arm64Assembler FINAL : public Assembler { // MaybeGenerateMarkingRegisterCheck and is passed to the BRK instruction. void GenerateMarkingRegisterCheck(vixl::aarch64::Register temp, int code = 0); - void Bind(Label* label ATTRIBUTE_UNUSED) OVERRIDE { + void Bind(Label* label ATTRIBUTE_UNUSED) override { UNIMPLEMENTED(FATAL) << "Do not use Bind for ARM64"; } - void Jump(Label* label ATTRIBUTE_UNUSED) OVERRIDE { + void Jump(Label* label ATTRIBUTE_UNUSED) override { UNIMPLEMENTED(FATAL) << "Do not use Jump for ARM64"; } diff --git a/compiler/utils/arm64/jni_macro_assembler_arm64.h b/compiler/utils/arm64/jni_macro_assembler_arm64.h index f531b2aa51..45316ed88e 100644 --- a/compiler/utils/arm64/jni_macro_assembler_arm64.h +++ b/compiler/utils/arm64/jni_macro_assembler_arm64.h @@ -40,7 +40,7 @@ namespace art { namespace arm64 { -class Arm64JNIMacroAssembler FINAL : public JNIMacroAssemblerFwd<Arm64Assembler, PointerSize::k64> { +class Arm64JNIMacroAssembler final : public JNIMacroAssemblerFwd<Arm64Assembler, PointerSize::k64> { public: explicit Arm64JNIMacroAssembler(ArenaAllocator* allocator) : JNIMacroAssemblerFwd(allocator), @@ -49,94 +49,94 @@ class Arm64JNIMacroAssembler FINAL : public JNIMacroAssemblerFwd<Arm64Assembler, ~Arm64JNIMacroAssembler(); // Finalize the code. - void FinalizeCode() OVERRIDE; + void FinalizeCode() override; // Emit code that will create an activation on the stack. void BuildFrame(size_t frame_size, ManagedRegister method_reg, ArrayRef<const ManagedRegister> callee_save_regs, - const ManagedRegisterEntrySpills& entry_spills) OVERRIDE; + const ManagedRegisterEntrySpills& entry_spills) override; // Emit code that will remove an activation from the stack. void RemoveFrame(size_t frame_size, ArrayRef<const ManagedRegister> callee_save_regs, - bool may_suspend) OVERRIDE; + bool may_suspend) override; - void IncreaseFrameSize(size_t adjust) OVERRIDE; - void DecreaseFrameSize(size_t adjust) OVERRIDE; + void IncreaseFrameSize(size_t adjust) override; + void DecreaseFrameSize(size_t adjust) override; // Store routines. - void Store(FrameOffset offs, ManagedRegister src, size_t size) OVERRIDE; - void StoreRef(FrameOffset dest, ManagedRegister src) OVERRIDE; - void StoreRawPtr(FrameOffset dest, ManagedRegister src) OVERRIDE; - void StoreImmediateToFrame(FrameOffset dest, uint32_t imm, ManagedRegister scratch) OVERRIDE; + void Store(FrameOffset offs, ManagedRegister src, size_t size) override; + void StoreRef(FrameOffset dest, ManagedRegister src) override; + void StoreRawPtr(FrameOffset dest, ManagedRegister src) override; + void StoreImmediateToFrame(FrameOffset dest, uint32_t imm, ManagedRegister scratch) override; void StoreStackOffsetToThread(ThreadOffset64 thr_offs, FrameOffset fr_offs, - ManagedRegister scratch) OVERRIDE; - void StoreStackPointerToThread(ThreadOffset64 thr_offs) OVERRIDE; + ManagedRegister scratch) override; + void StoreStackPointerToThread(ThreadOffset64 thr_offs) override; void StoreSpanning(FrameOffset dest, ManagedRegister src, FrameOffset in_off, - ManagedRegister scratch) OVERRIDE; + ManagedRegister scratch) override; // Load routines. - void Load(ManagedRegister dest, FrameOffset src, size_t size) OVERRIDE; - void LoadFromThread(ManagedRegister dest, ThreadOffset64 src, size_t size) OVERRIDE; - void LoadRef(ManagedRegister dest, FrameOffset src) OVERRIDE; + void Load(ManagedRegister dest, FrameOffset src, size_t size) override; + void LoadFromThread(ManagedRegister dest, ThreadOffset64 src, size_t size) override; + void LoadRef(ManagedRegister dest, FrameOffset src) override; void LoadRef(ManagedRegister dest, ManagedRegister base, MemberOffset offs, - bool unpoison_reference) OVERRIDE; - void LoadRawPtr(ManagedRegister dest, ManagedRegister base, Offset offs) OVERRIDE; - void LoadRawPtrFromThread(ManagedRegister dest, ThreadOffset64 offs) OVERRIDE; + bool unpoison_reference) override; + void LoadRawPtr(ManagedRegister dest, ManagedRegister base, Offset offs) override; + void LoadRawPtrFromThread(ManagedRegister dest, ThreadOffset64 offs) override; // Copying routines. - void Move(ManagedRegister dest, ManagedRegister src, size_t size) OVERRIDE; + void Move(ManagedRegister dest, ManagedRegister src, size_t size) override; void CopyRawPtrFromThread(FrameOffset fr_offs, ThreadOffset64 thr_offs, - ManagedRegister scratch) OVERRIDE; + ManagedRegister scratch) override; void CopyRawPtrToThread(ThreadOffset64 thr_offs, FrameOffset fr_offs, ManagedRegister scratch) - OVERRIDE; - void CopyRef(FrameOffset dest, FrameOffset src, ManagedRegister scratch) OVERRIDE; - void Copy(FrameOffset dest, FrameOffset src, ManagedRegister scratch, size_t size) OVERRIDE; + override; + void CopyRef(FrameOffset dest, FrameOffset src, ManagedRegister scratch) override; + void Copy(FrameOffset dest, FrameOffset src, ManagedRegister scratch, size_t size) override; void Copy(FrameOffset dest, ManagedRegister src_base, Offset src_offset, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(ManagedRegister dest_base, Offset dest_offset, FrameOffset src, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(FrameOffset dest, FrameOffset src_base, Offset src_offset, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(ManagedRegister dest, Offset dest_offset, ManagedRegister src, Offset src_offset, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(FrameOffset dest, Offset dest_offset, FrameOffset src, Offset src_offset, ManagedRegister scratch, - size_t size) OVERRIDE; - void MemoryBarrier(ManagedRegister scratch) OVERRIDE; + size_t size) override; + void MemoryBarrier(ManagedRegister scratch) override; // Sign extension. - void SignExtend(ManagedRegister mreg, size_t size) OVERRIDE; + void SignExtend(ManagedRegister mreg, size_t size) override; // Zero extension. - void ZeroExtend(ManagedRegister mreg, size_t size) OVERRIDE; + void ZeroExtend(ManagedRegister mreg, size_t size) override; // Exploit fast access in managed code to Thread::Current(). - void GetCurrentThread(ManagedRegister tr) OVERRIDE; - void GetCurrentThread(FrameOffset dest_offset, ManagedRegister scratch) OVERRIDE; + void GetCurrentThread(ManagedRegister tr) override; + void GetCurrentThread(FrameOffset dest_offset, ManagedRegister scratch) override; // Set up out_reg to hold a Object** into the handle scope, or to be null if the // value is null and null_allowed. in_reg holds a possibly stale reference @@ -145,40 +145,40 @@ class Arm64JNIMacroAssembler FINAL : public JNIMacroAssemblerFwd<Arm64Assembler, void CreateHandleScopeEntry(ManagedRegister out_reg, FrameOffset handlescope_offset, ManagedRegister in_reg, - bool null_allowed) OVERRIDE; + bool null_allowed) override; // Set up out_off to hold a Object** into the handle scope, or to be null if the // value is null and null_allowed. void CreateHandleScopeEntry(FrameOffset out_off, FrameOffset handlescope_offset, ManagedRegister scratch, - bool null_allowed) OVERRIDE; + bool null_allowed) override; // src holds a handle scope entry (Object**) load this into dst. - void LoadReferenceFromHandleScope(ManagedRegister dst, ManagedRegister src) OVERRIDE; + void LoadReferenceFromHandleScope(ManagedRegister dst, ManagedRegister src) override; // Heap::VerifyObject on src. In some cases (such as a reference to this) we // know that src may not be null. - void VerifyObject(ManagedRegister src, bool could_be_null) OVERRIDE; - void VerifyObject(FrameOffset src, bool could_be_null) OVERRIDE; + void VerifyObject(ManagedRegister src, bool could_be_null) override; + void VerifyObject(FrameOffset src, bool could_be_null) override; // Call to address held at [base+offset]. - void Call(ManagedRegister base, Offset offset, ManagedRegister scratch) OVERRIDE; - void Call(FrameOffset base, Offset offset, ManagedRegister scratch) OVERRIDE; - void CallFromThread(ThreadOffset64 offset, ManagedRegister scratch) OVERRIDE; + void Call(ManagedRegister base, Offset offset, ManagedRegister scratch) override; + void Call(FrameOffset base, Offset offset, ManagedRegister scratch) override; + void CallFromThread(ThreadOffset64 offset, ManagedRegister scratch) override; // Generate code to check if Thread::Current()->exception_ is non-null // and branch to a ExceptionSlowPath if it is. - void ExceptionPoll(ManagedRegister scratch, size_t stack_adjust) OVERRIDE; + void ExceptionPoll(ManagedRegister scratch, size_t stack_adjust) override; // Create a new label that can be used with Jump/Bind calls. - std::unique_ptr<JNIMacroLabel> CreateLabel() OVERRIDE; + std::unique_ptr<JNIMacroLabel> CreateLabel() override; // Emit an unconditional jump to the label. - void Jump(JNIMacroLabel* label) OVERRIDE; + void Jump(JNIMacroLabel* label) override; // Emit a conditional jump to the label by applying a unary condition test to the register. - void Jump(JNIMacroLabel* label, JNIMacroUnaryCondition cond, ManagedRegister test) OVERRIDE; + void Jump(JNIMacroLabel* label, JNIMacroUnaryCondition cond, ManagedRegister test) override; // Code at this offset will serve as the target for the Jump call. - void Bind(JNIMacroLabel* label) OVERRIDE; + void Bind(JNIMacroLabel* label) override; private: class Arm64Exception { @@ -234,7 +234,7 @@ class Arm64JNIMacroAssembler FINAL : public JNIMacroAssemblerFwd<Arm64Assembler, ArenaVector<std::unique_ptr<Arm64Exception>> exception_blocks_; }; -class Arm64JNIMacroLabel FINAL +class Arm64JNIMacroLabel final : public JNIMacroLabelCommon<Arm64JNIMacroLabel, vixl::aarch64::Label, InstructionSet::kArm64> { diff --git a/compiler/utils/assembler.h b/compiler/utils/assembler.h index 379a6396eb..251b82cb54 100644 --- a/compiler/utils/assembler.h +++ b/compiler/utils/assembler.h @@ -283,7 +283,7 @@ class AssemblerBuffer { // The purpose of this class is to ensure that we do not have to explicitly // call the AdvancePC method (which is good for convenience and correctness). -class DebugFrameOpCodeWriterForAssembler FINAL +class DebugFrameOpCodeWriterForAssembler final : public dwarf::DebugFrameOpCodeWriter<> { public: struct DelayedAdvancePC { @@ -292,7 +292,7 @@ class DebugFrameOpCodeWriterForAssembler FINAL }; // This method is called the by the opcode writers. - virtual void ImplicitlyAdvancePC() FINAL; + virtual void ImplicitlyAdvancePC() final; explicit DebugFrameOpCodeWriterForAssembler(Assembler* buffer) : dwarf::DebugFrameOpCodeWriter<>(false /* enabled */), diff --git a/compiler/utils/assembler_test.h b/compiler/utils/assembler_test.h index 7c800b355f..9e23d11116 100644 --- a/compiler/utils/assembler_test.h +++ b/compiler/utils/assembler_test.h @@ -737,7 +737,7 @@ class AssemblerTest : public testing::Test { protected: AssemblerTest() {} - void SetUp() OVERRIDE { + void SetUp() override { allocator_.reset(new ArenaAllocator(&pool_)); assembler_.reset(CreateAssembler(allocator_.get())); test_helper_.reset( @@ -753,7 +753,7 @@ class AssemblerTest : public testing::Test { SetUpHelpers(); } - void TearDown() OVERRIDE { + void TearDown() override { test_helper_.reset(); // Clean up the helper. assembler_.reset(); allocator_.reset(); diff --git a/compiler/utils/jni_macro_assembler.h b/compiler/utils/jni_macro_assembler.h index f5df926749..e0c2992dea 100644 --- a/compiler/utils/jni_macro_assembler.h +++ b/compiler/utils/jni_macro_assembler.h @@ -259,19 +259,19 @@ inline JNIMacroLabel::~JNIMacroLabel() { template <typename T, PointerSize kPointerSize> class JNIMacroAssemblerFwd : public JNIMacroAssembler<kPointerSize> { public: - void FinalizeCode() OVERRIDE { + void FinalizeCode() override { asm_.FinalizeCode(); } - size_t CodeSize() const OVERRIDE { + size_t CodeSize() const override { return asm_.CodeSize(); } - void FinalizeInstructions(const MemoryRegion& region) OVERRIDE { + void FinalizeInstructions(const MemoryRegion& region) override { asm_.FinalizeInstructions(region); } - DebugFrameOpCodeWriterForAssembler& cfi() OVERRIDE { + DebugFrameOpCodeWriterForAssembler& cfi() override { return asm_.cfi(); } @@ -299,7 +299,7 @@ class JNIMacroLabelCommon : public JNIMacroLabel { JNIMacroLabelCommon() : JNIMacroLabel(kIsa) { } - virtual ~JNIMacroLabelCommon() OVERRIDE {} + virtual ~JNIMacroLabelCommon() override {} private: PlatformLabel label_; diff --git a/compiler/utils/jni_macro_assembler_test.h b/compiler/utils/jni_macro_assembler_test.h index b70c18b3e2..067a5953b8 100644 --- a/compiler/utils/jni_macro_assembler_test.h +++ b/compiler/utils/jni_macro_assembler_test.h @@ -58,7 +58,7 @@ class JNIMacroAssemblerTest : public testing::Test { protected: JNIMacroAssemblerTest() {} - void SetUp() OVERRIDE { + void SetUp() override { allocator_.reset(new ArenaAllocator(&pool_)); assembler_.reset(CreateAssembler(allocator_.get())); test_helper_.reset( @@ -74,7 +74,7 @@ class JNIMacroAssemblerTest : public testing::Test { SetUpHelpers(); } - void TearDown() OVERRIDE { + void TearDown() override { test_helper_.reset(); // Clean up the helper. assembler_.reset(); allocator_.reset(); diff --git a/compiler/utils/mips/assembler_mips.h b/compiler/utils/mips/assembler_mips.h index af3d7a06ba..8a1e1df777 100644 --- a/compiler/utils/mips/assembler_mips.h +++ b/compiler/utils/mips/assembler_mips.h @@ -263,7 +263,7 @@ class MipsExceptionSlowPath { DISALLOW_COPY_AND_ASSIGN(MipsExceptionSlowPath); }; -class MipsAssembler FINAL : public Assembler, public JNIMacroAssembler<PointerSize::k32> { +class MipsAssembler final : public Assembler, public JNIMacroAssembler<PointerSize::k32> { public: using JNIBase = JNIMacroAssembler<PointerSize::k32>; @@ -285,8 +285,8 @@ class MipsAssembler FINAL : public Assembler, public JNIMacroAssembler<PointerSi cfi().DelayEmittingAdvancePCs(); } - size_t CodeSize() const OVERRIDE { return Assembler::CodeSize(); } - size_t CodePosition() OVERRIDE; + size_t CodeSize() const override { return Assembler::CodeSize(); } + size_t CodePosition() override; DebugFrameOpCodeWriterForAssembler& cfi() { return Assembler::cfi(); } virtual ~MipsAssembler() { @@ -1143,10 +1143,10 @@ class MipsAssembler FINAL : public Assembler, public JNIMacroAssembler<PointerSi } } - void Bind(Label* label) OVERRIDE { + void Bind(Label* label) override { Bind(down_cast<MipsLabel*>(label)); } - void Jump(Label* label ATTRIBUTE_UNUSED) OVERRIDE { + void Jump(Label* label ATTRIBUTE_UNUSED) override { UNIMPLEMENTED(FATAL) << "Do not use Jump for MIPS"; } @@ -1155,25 +1155,25 @@ class MipsAssembler FINAL : public Assembler, public JNIMacroAssembler<PointerSi using JNIBase::Jump; // Create a new label that can be used with Jump/Bind calls. - std::unique_ptr<JNIMacroLabel> CreateLabel() OVERRIDE { + std::unique_ptr<JNIMacroLabel> CreateLabel() override { LOG(FATAL) << "Not implemented on MIPS32"; UNREACHABLE(); } // Emit an unconditional jump to the label. - void Jump(JNIMacroLabel* label ATTRIBUTE_UNUSED) OVERRIDE { + void Jump(JNIMacroLabel* label ATTRIBUTE_UNUSED) override { LOG(FATAL) << "Not implemented on MIPS32"; UNREACHABLE(); } // Emit a conditional jump to the label by applying a unary condition test to the register. void Jump(JNIMacroLabel* label ATTRIBUTE_UNUSED, JNIMacroUnaryCondition cond ATTRIBUTE_UNUSED, - ManagedRegister test ATTRIBUTE_UNUSED) OVERRIDE { + ManagedRegister test ATTRIBUTE_UNUSED) override { LOG(FATAL) << "Not implemented on MIPS32"; UNREACHABLE(); } // Code at this offset will serve as the target for the Jump call. - void Bind(JNIMacroLabel* label ATTRIBUTE_UNUSED) OVERRIDE { + void Bind(JNIMacroLabel* label ATTRIBUTE_UNUSED) override { LOG(FATAL) << "Not implemented on MIPS32"; UNREACHABLE(); } @@ -1232,108 +1232,108 @@ class MipsAssembler FINAL : public Assembler, public JNIMacroAssembler<PointerSi void BuildFrame(size_t frame_size, ManagedRegister method_reg, ArrayRef<const ManagedRegister> callee_save_regs, - const ManagedRegisterEntrySpills& entry_spills) OVERRIDE; + const ManagedRegisterEntrySpills& entry_spills) override; // Emit code that will remove an activation from the stack. void RemoveFrame(size_t frame_size, ArrayRef<const ManagedRegister> callee_save_regs, - bool may_suspend) OVERRIDE; + bool may_suspend) override; - void IncreaseFrameSize(size_t adjust) OVERRIDE; - void DecreaseFrameSize(size_t adjust) OVERRIDE; + void IncreaseFrameSize(size_t adjust) override; + void DecreaseFrameSize(size_t adjust) override; // Store routines. - void Store(FrameOffset offs, ManagedRegister msrc, size_t size) OVERRIDE; - void StoreRef(FrameOffset dest, ManagedRegister msrc) OVERRIDE; - void StoreRawPtr(FrameOffset dest, ManagedRegister msrc) OVERRIDE; + void Store(FrameOffset offs, ManagedRegister msrc, size_t size) override; + void StoreRef(FrameOffset dest, ManagedRegister msrc) override; + void StoreRawPtr(FrameOffset dest, ManagedRegister msrc) override; - void StoreImmediateToFrame(FrameOffset dest, uint32_t imm, ManagedRegister mscratch) OVERRIDE; + void StoreImmediateToFrame(FrameOffset dest, uint32_t imm, ManagedRegister mscratch) override; void StoreStackOffsetToThread(ThreadOffset32 thr_offs, FrameOffset fr_offs, - ManagedRegister mscratch) OVERRIDE; + ManagedRegister mscratch) override; - void StoreStackPointerToThread(ThreadOffset32 thr_offs) OVERRIDE; + void StoreStackPointerToThread(ThreadOffset32 thr_offs) override; void StoreSpanning(FrameOffset dest, ManagedRegister msrc, FrameOffset in_off, - ManagedRegister mscratch) OVERRIDE; + ManagedRegister mscratch) override; // Load routines. - void Load(ManagedRegister mdest, FrameOffset src, size_t size) OVERRIDE; + void Load(ManagedRegister mdest, FrameOffset src, size_t size) override; - void LoadFromThread(ManagedRegister mdest, ThreadOffset32 src, size_t size) OVERRIDE; + void LoadFromThread(ManagedRegister mdest, ThreadOffset32 src, size_t size) override; - void LoadRef(ManagedRegister dest, FrameOffset src) OVERRIDE; + void LoadRef(ManagedRegister dest, FrameOffset src) override; void LoadRef(ManagedRegister mdest, ManagedRegister base, MemberOffset offs, - bool unpoison_reference) OVERRIDE; + bool unpoison_reference) override; - void LoadRawPtr(ManagedRegister mdest, ManagedRegister base, Offset offs) OVERRIDE; + void LoadRawPtr(ManagedRegister mdest, ManagedRegister base, Offset offs) override; - void LoadRawPtrFromThread(ManagedRegister mdest, ThreadOffset32 offs) OVERRIDE; + void LoadRawPtrFromThread(ManagedRegister mdest, ThreadOffset32 offs) override; // Copying routines. - void Move(ManagedRegister mdest, ManagedRegister msrc, size_t size) OVERRIDE; + void Move(ManagedRegister mdest, ManagedRegister msrc, size_t size) override; void CopyRawPtrFromThread(FrameOffset fr_offs, ThreadOffset32 thr_offs, - ManagedRegister mscratch) OVERRIDE; + ManagedRegister mscratch) override; void CopyRawPtrToThread(ThreadOffset32 thr_offs, FrameOffset fr_offs, - ManagedRegister mscratch) OVERRIDE; + ManagedRegister mscratch) override; - void CopyRef(FrameOffset dest, FrameOffset src, ManagedRegister mscratch) OVERRIDE; + void CopyRef(FrameOffset dest, FrameOffset src, ManagedRegister mscratch) override; - void Copy(FrameOffset dest, FrameOffset src, ManagedRegister mscratch, size_t size) OVERRIDE; + void Copy(FrameOffset dest, FrameOffset src, ManagedRegister mscratch, size_t size) override; void Copy(FrameOffset dest, ManagedRegister src_base, Offset src_offset, ManagedRegister mscratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(ManagedRegister dest_base, Offset dest_offset, FrameOffset src, ManagedRegister mscratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(FrameOffset dest, FrameOffset src_base, Offset src_offset, ManagedRegister mscratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(ManagedRegister dest, Offset dest_offset, ManagedRegister src, Offset src_offset, ManagedRegister mscratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(FrameOffset dest, Offset dest_offset, FrameOffset src, Offset src_offset, ManagedRegister mscratch, - size_t size) OVERRIDE; + size_t size) override; - void MemoryBarrier(ManagedRegister) OVERRIDE; + void MemoryBarrier(ManagedRegister) override; // Sign extension. - void SignExtend(ManagedRegister mreg, size_t size) OVERRIDE; + void SignExtend(ManagedRegister mreg, size_t size) override; // Zero extension. - void ZeroExtend(ManagedRegister mreg, size_t size) OVERRIDE; + void ZeroExtend(ManagedRegister mreg, size_t size) override; // Exploit fast access in managed code to Thread::Current(). - void GetCurrentThread(ManagedRegister tr) OVERRIDE; - void GetCurrentThread(FrameOffset dest_offset, ManagedRegister mscratch) OVERRIDE; + void GetCurrentThread(ManagedRegister tr) override; + void GetCurrentThread(FrameOffset dest_offset, ManagedRegister mscratch) override; // Set up out_reg to hold a Object** into the handle scope, or to be null if the // value is null and null_allowed. in_reg holds a possibly stale reference @@ -1342,34 +1342,34 @@ class MipsAssembler FINAL : public Assembler, public JNIMacroAssembler<PointerSi void CreateHandleScopeEntry(ManagedRegister out_reg, FrameOffset handlescope_offset, ManagedRegister in_reg, - bool null_allowed) OVERRIDE; + bool null_allowed) override; // Set up out_off to hold a Object** into the handle scope, or to be null if the // value is null and null_allowed. void CreateHandleScopeEntry(FrameOffset out_off, FrameOffset handlescope_offset, ManagedRegister mscratch, - bool null_allowed) OVERRIDE; + bool null_allowed) override; // src holds a handle scope entry (Object**) load this into dst. - void LoadReferenceFromHandleScope(ManagedRegister dst, ManagedRegister src) OVERRIDE; + void LoadReferenceFromHandleScope(ManagedRegister dst, ManagedRegister src) override; // Heap::VerifyObject on src. In some cases (such as a reference to this) we // know that src may not be null. - void VerifyObject(ManagedRegister src, bool could_be_null) OVERRIDE; - void VerifyObject(FrameOffset src, bool could_be_null) OVERRIDE; + void VerifyObject(ManagedRegister src, bool could_be_null) override; + void VerifyObject(FrameOffset src, bool could_be_null) override; // Call to address held at [base+offset]. - void Call(ManagedRegister base, Offset offset, ManagedRegister mscratch) OVERRIDE; - void Call(FrameOffset base, Offset offset, ManagedRegister mscratch) OVERRIDE; - void CallFromThread(ThreadOffset32 offset, ManagedRegister mscratch) OVERRIDE; + void Call(ManagedRegister base, Offset offset, ManagedRegister mscratch) override; + void Call(FrameOffset base, Offset offset, ManagedRegister mscratch) override; + void CallFromThread(ThreadOffset32 offset, ManagedRegister mscratch) override; // Generate code to check if Thread::Current()->exception_ is non-null // and branch to a ExceptionSlowPath if it is. - void ExceptionPoll(ManagedRegister mscratch, size_t stack_adjust) OVERRIDE; + void ExceptionPoll(ManagedRegister mscratch, size_t stack_adjust) override; // Emit slow paths queued during assembly and promote short branches to long if needed. - void FinalizeCode() OVERRIDE; + void FinalizeCode() override; // Emit branches and finalize all instructions. void FinalizeInstructions(const MemoryRegion& region); diff --git a/compiler/utils/mips/assembler_mips32r5_test.cc b/compiler/utils/mips/assembler_mips32r5_test.cc index 0f858926df..f9919f52b5 100644 --- a/compiler/utils/mips/assembler_mips32r5_test.cc +++ b/compiler/utils/mips/assembler_mips32r5_test.cc @@ -61,15 +61,15 @@ class AssemblerMIPS32r5Test : public AssemblerTest<mips::MipsAssembler, protected: // Get the typically used name for this architecture, e.g., aarch64, x86-64, ... - std::string GetArchitectureString() OVERRIDE { + std::string GetArchitectureString() override { return "mips"; } - std::string GetAssemblerParameters() OVERRIDE { + std::string GetAssemblerParameters() override { return " --no-warn -32 -march=mips32r5 -mmsa"; } - void Pad(std::vector<uint8_t>& data) OVERRIDE { + void Pad(std::vector<uint8_t>& data) override { // The GNU linker unconditionally pads the code segment with NOPs to a size that is a multiple // of 16 and there doesn't appear to be a way to suppress this padding. Our assembler doesn't // pad, so, in order for two assembler outputs to match, we need to match the padding as well. @@ -78,15 +78,15 @@ class AssemblerMIPS32r5Test : public AssemblerTest<mips::MipsAssembler, data.insert(data.end(), pad_size, 0); } - std::string GetDisassembleParameters() OVERRIDE { + std::string GetDisassembleParameters() override { return " -D -bbinary -mmips:isa32r5"; } - mips::MipsAssembler* CreateAssembler(ArenaAllocator* allocator) OVERRIDE { + mips::MipsAssembler* CreateAssembler(ArenaAllocator* allocator) override { return new (allocator) mips::MipsAssembler(allocator, instruction_set_features_.get()); } - void SetUpHelpers() OVERRIDE { + void SetUpHelpers() override { if (registers_.size() == 0) { registers_.push_back(new mips::Register(mips::ZERO)); registers_.push_back(new mips::Register(mips::AT)); @@ -222,7 +222,7 @@ class AssemblerMIPS32r5Test : public AssemblerTest<mips::MipsAssembler, } } - void TearDown() OVERRIDE { + void TearDown() override { AssemblerTest::TearDown(); STLDeleteElements(®isters_); STLDeleteElements(&fp_registers_); @@ -234,23 +234,23 @@ class AssemblerMIPS32r5Test : public AssemblerTest<mips::MipsAssembler, UNREACHABLE(); } - std::vector<mips::Register*> GetRegisters() OVERRIDE { + std::vector<mips::Register*> GetRegisters() override { return registers_; } - std::vector<mips::FRegister*> GetFPRegisters() OVERRIDE { + std::vector<mips::FRegister*> GetFPRegisters() override { return fp_registers_; } - std::vector<mips::VectorRegister*> GetVectorRegisters() OVERRIDE { + std::vector<mips::VectorRegister*> GetVectorRegisters() override { return vec_registers_; } - uint32_t CreateImmediate(int64_t imm_value) OVERRIDE { + uint32_t CreateImmediate(int64_t imm_value) override { return imm_value; } - std::string GetSecondaryRegisterName(const mips::Register& reg) OVERRIDE { + std::string GetSecondaryRegisterName(const mips::Register& reg) override { CHECK(secondary_register_names_.find(reg) != secondary_register_names_.end()); return secondary_register_names_[reg]; } diff --git a/compiler/utils/mips/assembler_mips32r6_test.cc b/compiler/utils/mips/assembler_mips32r6_test.cc index 3d876ca613..1ec7a6a3e0 100644 --- a/compiler/utils/mips/assembler_mips32r6_test.cc +++ b/compiler/utils/mips/assembler_mips32r6_test.cc @@ -61,16 +61,16 @@ class AssemblerMIPS32r6Test : public AssemblerTest<mips::MipsAssembler, protected: // Get the typically used name for this architecture, e.g., aarch64, x86-64, ... - std::string GetArchitectureString() OVERRIDE { + std::string GetArchitectureString() override { return "mips"; } - std::string GetAssemblerCmdName() OVERRIDE { + std::string GetAssemblerCmdName() override { // We assemble and link for MIPS32R6. See GetAssemblerParameters() for details. return "gcc"; } - std::string GetAssemblerParameters() OVERRIDE { + std::string GetAssemblerParameters() override { // We assemble and link for MIPS32R6. The reason is that object files produced for MIPS32R6 // (and MIPS64R6) with the GNU assembler don't have correct final offsets in PC-relative // branches in the .text section and so they require a relocation pass (there's a relocation @@ -82,7 +82,7 @@ class AssemblerMIPS32r6Test : public AssemblerTest<mips::MipsAssembler, " -Wl,-Ttext=0x1000000 -Wl,-e0x1000000 -nostdlib"; } - void Pad(std::vector<uint8_t>& data) OVERRIDE { + void Pad(std::vector<uint8_t>& data) override { // The GNU linker unconditionally pads the code segment with NOPs to a size that is a multiple // of 16 and there doesn't appear to be a way to suppress this padding. Our assembler doesn't // pad, so, in order for two assembler outputs to match, we need to match the padding as well. @@ -91,15 +91,15 @@ class AssemblerMIPS32r6Test : public AssemblerTest<mips::MipsAssembler, data.insert(data.end(), pad_size, 0); } - std::string GetDisassembleParameters() OVERRIDE { + std::string GetDisassembleParameters() override { return " -D -bbinary -mmips:isa32r6"; } - mips::MipsAssembler* CreateAssembler(ArenaAllocator* allocator) OVERRIDE { + mips::MipsAssembler* CreateAssembler(ArenaAllocator* allocator) override { return new (allocator) mips::MipsAssembler(allocator, instruction_set_features_.get()); } - void SetUpHelpers() OVERRIDE { + void SetUpHelpers() override { if (registers_.size() == 0) { registers_.push_back(new mips::Register(mips::ZERO)); registers_.push_back(new mips::Register(mips::AT)); @@ -235,7 +235,7 @@ class AssemblerMIPS32r6Test : public AssemblerTest<mips::MipsAssembler, } } - void TearDown() OVERRIDE { + void TearDown() override { AssemblerTest::TearDown(); STLDeleteElements(®isters_); STLDeleteElements(&fp_registers_); @@ -247,23 +247,23 @@ class AssemblerMIPS32r6Test : public AssemblerTest<mips::MipsAssembler, UNREACHABLE(); } - std::vector<mips::Register*> GetRegisters() OVERRIDE { + std::vector<mips::Register*> GetRegisters() override { return registers_; } - std::vector<mips::FRegister*> GetFPRegisters() OVERRIDE { + std::vector<mips::FRegister*> GetFPRegisters() override { return fp_registers_; } - std::vector<mips::VectorRegister*> GetVectorRegisters() OVERRIDE { + std::vector<mips::VectorRegister*> GetVectorRegisters() override { return vec_registers_; } - uint32_t CreateImmediate(int64_t imm_value) OVERRIDE { + uint32_t CreateImmediate(int64_t imm_value) override { return imm_value; } - std::string GetSecondaryRegisterName(const mips::Register& reg) OVERRIDE { + std::string GetSecondaryRegisterName(const mips::Register& reg) override { CHECK(secondary_register_names_.find(reg) != secondary_register_names_.end()); return secondary_register_names_[reg]; } diff --git a/compiler/utils/mips/assembler_mips_test.cc b/compiler/utils/mips/assembler_mips_test.cc index f94d074299..9527fa6ddd 100644 --- a/compiler/utils/mips/assembler_mips_test.cc +++ b/compiler/utils/mips/assembler_mips_test.cc @@ -55,19 +55,19 @@ class AssemblerMIPSTest : public AssemblerTest<mips::MipsAssembler, protected: // Get the typically used name for this architecture, e.g., aarch64, x86-64, ... - std::string GetArchitectureString() OVERRIDE { + std::string GetArchitectureString() override { return "mips"; } - std::string GetAssemblerParameters() OVERRIDE { + std::string GetAssemblerParameters() override { return " --no-warn -32 -march=mips32r2"; } - std::string GetDisassembleParameters() OVERRIDE { + std::string GetDisassembleParameters() override { return " -D -bbinary -mmips:isa32r2"; } - void SetUpHelpers() OVERRIDE { + void SetUpHelpers() override { if (registers_.size() == 0) { registers_.push_back(new mips::Register(mips::ZERO)); registers_.push_back(new mips::Register(mips::AT)); @@ -170,7 +170,7 @@ class AssemblerMIPSTest : public AssemblerTest<mips::MipsAssembler, } } - void TearDown() OVERRIDE { + void TearDown() override { AssemblerTest::TearDown(); STLDeleteElements(®isters_); STLDeleteElements(&fp_registers_); @@ -181,19 +181,19 @@ class AssemblerMIPSTest : public AssemblerTest<mips::MipsAssembler, UNREACHABLE(); } - std::vector<mips::Register*> GetRegisters() OVERRIDE { + std::vector<mips::Register*> GetRegisters() override { return registers_; } - std::vector<mips::FRegister*> GetFPRegisters() OVERRIDE { + std::vector<mips::FRegister*> GetFPRegisters() override { return fp_registers_; } - uint32_t CreateImmediate(int64_t imm_value) OVERRIDE { + uint32_t CreateImmediate(int64_t imm_value) override { return imm_value; } - std::string GetSecondaryRegisterName(const mips::Register& reg) OVERRIDE { + std::string GetSecondaryRegisterName(const mips::Register& reg) override { CHECK(secondary_register_names_.find(reg) != secondary_register_names_.end()); return secondary_register_names_[reg]; } diff --git a/compiler/utils/mips64/assembler_mips64.h b/compiler/utils/mips64/assembler_mips64.h index 19f23b7e95..ce447db4fb 100644 --- a/compiler/utils/mips64/assembler_mips64.h +++ b/compiler/utils/mips64/assembler_mips64.h @@ -414,7 +414,7 @@ class Mips64ExceptionSlowPath { DISALLOW_COPY_AND_ASSIGN(Mips64ExceptionSlowPath); }; -class Mips64Assembler FINAL : public Assembler, public JNIMacroAssembler<PointerSize::k64> { +class Mips64Assembler final : public Assembler, public JNIMacroAssembler<PointerSize::k64> { public: using JNIBase = JNIMacroAssembler<PointerSize::k64>; @@ -439,7 +439,7 @@ class Mips64Assembler FINAL : public Assembler, public JNIMacroAssembler<Pointer } } - size_t CodeSize() const OVERRIDE { return Assembler::CodeSize(); } + size_t CodeSize() const override { return Assembler::CodeSize(); } DebugFrameOpCodeWriterForAssembler& cfi() { return Assembler::cfi(); } // Emit Machine Instructions. @@ -920,10 +920,10 @@ class Mips64Assembler FINAL : public Assembler, public JNIMacroAssembler<Pointer } } - void Bind(Label* label) OVERRIDE { + void Bind(Label* label) override { Bind(down_cast<Mips64Label*>(label)); } - void Jump(Label* label ATTRIBUTE_UNUSED) OVERRIDE { + void Jump(Label* label ATTRIBUTE_UNUSED) override { UNIMPLEMENTED(FATAL) << "Do not use Jump for MIPS64"; } @@ -934,25 +934,25 @@ class Mips64Assembler FINAL : public Assembler, public JNIMacroAssembler<Pointer using JNIBase::Jump; // Create a new label that can be used with Jump/Bind calls. - std::unique_ptr<JNIMacroLabel> CreateLabel() OVERRIDE { + std::unique_ptr<JNIMacroLabel> CreateLabel() override { LOG(FATAL) << "Not implemented on MIPS64"; UNREACHABLE(); } // Emit an unconditional jump to the label. - void Jump(JNIMacroLabel* label ATTRIBUTE_UNUSED) OVERRIDE { + void Jump(JNIMacroLabel* label ATTRIBUTE_UNUSED) override { LOG(FATAL) << "Not implemented on MIPS64"; UNREACHABLE(); } // Emit a conditional jump to the label by applying a unary condition test to the register. void Jump(JNIMacroLabel* label ATTRIBUTE_UNUSED, JNIMacroUnaryCondition cond ATTRIBUTE_UNUSED, - ManagedRegister test ATTRIBUTE_UNUSED) OVERRIDE { + ManagedRegister test ATTRIBUTE_UNUSED) override { LOG(FATAL) << "Not implemented on MIPS64"; UNREACHABLE(); } // Code at this offset will serve as the target for the Jump call. - void Bind(JNIMacroLabel* label ATTRIBUTE_UNUSED) OVERRIDE { + void Bind(JNIMacroLabel* label ATTRIBUTE_UNUSED) override { LOG(FATAL) << "Not implemented on MIPS64"; UNREACHABLE(); } @@ -1322,119 +1322,119 @@ class Mips64Assembler FINAL : public Assembler, public JNIMacroAssembler<Pointer void BuildFrame(size_t frame_size, ManagedRegister method_reg, ArrayRef<const ManagedRegister> callee_save_regs, - const ManagedRegisterEntrySpills& entry_spills) OVERRIDE; + const ManagedRegisterEntrySpills& entry_spills) override; // Emit code that will remove an activation from the stack. void RemoveFrame(size_t frame_size, ArrayRef<const ManagedRegister> callee_save_regs, - bool may_suspend) OVERRIDE; + bool may_suspend) override; - void IncreaseFrameSize(size_t adjust) OVERRIDE; - void DecreaseFrameSize(size_t adjust) OVERRIDE; + void IncreaseFrameSize(size_t adjust) override; + void DecreaseFrameSize(size_t adjust) override; // Store routines. - void Store(FrameOffset offs, ManagedRegister msrc, size_t size) OVERRIDE; - void StoreRef(FrameOffset dest, ManagedRegister msrc) OVERRIDE; - void StoreRawPtr(FrameOffset dest, ManagedRegister msrc) OVERRIDE; + void Store(FrameOffset offs, ManagedRegister msrc, size_t size) override; + void StoreRef(FrameOffset dest, ManagedRegister msrc) override; + void StoreRawPtr(FrameOffset dest, ManagedRegister msrc) override; - void StoreImmediateToFrame(FrameOffset dest, uint32_t imm, ManagedRegister mscratch) OVERRIDE; + void StoreImmediateToFrame(FrameOffset dest, uint32_t imm, ManagedRegister mscratch) override; void StoreStackOffsetToThread(ThreadOffset64 thr_offs, FrameOffset fr_offs, - ManagedRegister mscratch) OVERRIDE; + ManagedRegister mscratch) override; - void StoreStackPointerToThread(ThreadOffset64 thr_offs) OVERRIDE; + void StoreStackPointerToThread(ThreadOffset64 thr_offs) override; void StoreSpanning(FrameOffset dest, ManagedRegister msrc, FrameOffset in_off, - ManagedRegister mscratch) OVERRIDE; + ManagedRegister mscratch) override; // Load routines. - void Load(ManagedRegister mdest, FrameOffset src, size_t size) OVERRIDE; + void Load(ManagedRegister mdest, FrameOffset src, size_t size) override; - void LoadFromThread(ManagedRegister mdest, ThreadOffset64 src, size_t size) OVERRIDE; + void LoadFromThread(ManagedRegister mdest, ThreadOffset64 src, size_t size) override; - void LoadRef(ManagedRegister dest, FrameOffset src) OVERRIDE; + void LoadRef(ManagedRegister dest, FrameOffset src) override; void LoadRef(ManagedRegister mdest, ManagedRegister base, MemberOffset offs, - bool unpoison_reference) OVERRIDE; + bool unpoison_reference) override; - void LoadRawPtr(ManagedRegister mdest, ManagedRegister base, Offset offs) OVERRIDE; + void LoadRawPtr(ManagedRegister mdest, ManagedRegister base, Offset offs) override; - void LoadRawPtrFromThread(ManagedRegister mdest, ThreadOffset64 offs) OVERRIDE; + void LoadRawPtrFromThread(ManagedRegister mdest, ThreadOffset64 offs) override; // Copying routines. - void Move(ManagedRegister mdest, ManagedRegister msrc, size_t size) OVERRIDE; + void Move(ManagedRegister mdest, ManagedRegister msrc, size_t size) override; void CopyRawPtrFromThread(FrameOffset fr_offs, ThreadOffset64 thr_offs, - ManagedRegister mscratch) OVERRIDE; + ManagedRegister mscratch) override; void CopyRawPtrToThread(ThreadOffset64 thr_offs, FrameOffset fr_offs, - ManagedRegister mscratch) OVERRIDE; + ManagedRegister mscratch) override; - void CopyRef(FrameOffset dest, FrameOffset src, ManagedRegister mscratch) OVERRIDE; + void CopyRef(FrameOffset dest, FrameOffset src, ManagedRegister mscratch) override; - void Copy(FrameOffset dest, FrameOffset src, ManagedRegister mscratch, size_t size) OVERRIDE; + void Copy(FrameOffset dest, FrameOffset src, ManagedRegister mscratch, size_t size) override; void Copy(FrameOffset dest, ManagedRegister src_base, Offset src_offset, ManagedRegister mscratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(ManagedRegister dest_base, Offset dest_offset, FrameOffset src, - ManagedRegister mscratch, size_t size) OVERRIDE; + ManagedRegister mscratch, size_t size) override; void Copy(FrameOffset dest, FrameOffset src_base, Offset src_offset, ManagedRegister mscratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(ManagedRegister dest, Offset dest_offset, ManagedRegister src, Offset src_offset, - ManagedRegister mscratch, size_t size) OVERRIDE; + ManagedRegister mscratch, size_t size) override; void Copy(FrameOffset dest, Offset dest_offset, FrameOffset src, Offset src_offset, - ManagedRegister mscratch, size_t size) OVERRIDE; + ManagedRegister mscratch, size_t size) override; - void MemoryBarrier(ManagedRegister) OVERRIDE; + void MemoryBarrier(ManagedRegister) override; // Sign extension. - void SignExtend(ManagedRegister mreg, size_t size) OVERRIDE; + void SignExtend(ManagedRegister mreg, size_t size) override; // Zero extension. - void ZeroExtend(ManagedRegister mreg, size_t size) OVERRIDE; + void ZeroExtend(ManagedRegister mreg, size_t size) override; // Exploit fast access in managed code to Thread::Current(). - void GetCurrentThread(ManagedRegister tr) OVERRIDE; - void GetCurrentThread(FrameOffset dest_offset, ManagedRegister mscratch) OVERRIDE; + void GetCurrentThread(ManagedRegister tr) override; + void GetCurrentThread(FrameOffset dest_offset, ManagedRegister mscratch) override; // Set up out_reg to hold a Object** into the handle scope, or to be null if the // value is null and null_allowed. in_reg holds a possibly stale reference // that can be used to avoid loading the handle scope entry to see if the value is // null. void CreateHandleScopeEntry(ManagedRegister out_reg, FrameOffset handlescope_offset, - ManagedRegister in_reg, bool null_allowed) OVERRIDE; + ManagedRegister in_reg, bool null_allowed) override; // Set up out_off to hold a Object** into the handle scope, or to be null if the // value is null and null_allowed. void CreateHandleScopeEntry(FrameOffset out_off, FrameOffset handlescope_offset, ManagedRegister - mscratch, bool null_allowed) OVERRIDE; + mscratch, bool null_allowed) override; // src holds a handle scope entry (Object**) load this into dst. - void LoadReferenceFromHandleScope(ManagedRegister dst, ManagedRegister src) OVERRIDE; + void LoadReferenceFromHandleScope(ManagedRegister dst, ManagedRegister src) override; // Heap::VerifyObject on src. In some cases (such as a reference to this) we // know that src may not be null. - void VerifyObject(ManagedRegister src, bool could_be_null) OVERRIDE; - void VerifyObject(FrameOffset src, bool could_be_null) OVERRIDE; + void VerifyObject(ManagedRegister src, bool could_be_null) override; + void VerifyObject(FrameOffset src, bool could_be_null) override; // Call to address held at [base+offset]. - void Call(ManagedRegister base, Offset offset, ManagedRegister mscratch) OVERRIDE; - void Call(FrameOffset base, Offset offset, ManagedRegister mscratch) OVERRIDE; - void CallFromThread(ThreadOffset64 offset, ManagedRegister mscratch) OVERRIDE; + void Call(ManagedRegister base, Offset offset, ManagedRegister mscratch) override; + void Call(FrameOffset base, Offset offset, ManagedRegister mscratch) override; + void CallFromThread(ThreadOffset64 offset, ManagedRegister mscratch) override; // Generate code to check if Thread::Current()->exception_ is non-null // and branch to a ExceptionSlowPath if it is. - void ExceptionPoll(ManagedRegister mscratch, size_t stack_adjust) OVERRIDE; + void ExceptionPoll(ManagedRegister mscratch, size_t stack_adjust) override; // Emit slow paths queued during assembly and promote short branches to long if needed. - void FinalizeCode() OVERRIDE; + void FinalizeCode() override; // Emit branches and finalize all instructions. void FinalizeInstructions(const MemoryRegion& region); diff --git a/compiler/utils/mips64/assembler_mips64_test.cc b/compiler/utils/mips64/assembler_mips64_test.cc index a53ff7cc2b..4ceb356910 100644 --- a/compiler/utils/mips64/assembler_mips64_test.cc +++ b/compiler/utils/mips64/assembler_mips64_test.cc @@ -63,16 +63,16 @@ class AssemblerMIPS64Test : public AssemblerTest<mips64::Mips64Assembler, protected: // Get the typically used name for this architecture, e.g., aarch64, x86-64, ... - std::string GetArchitectureString() OVERRIDE { + std::string GetArchitectureString() override { return "mips64"; } - std::string GetAssemblerCmdName() OVERRIDE { + std::string GetAssemblerCmdName() override { // We assemble and link for MIPS64R6. See GetAssemblerParameters() for details. return "gcc"; } - std::string GetAssemblerParameters() OVERRIDE { + std::string GetAssemblerParameters() override { // We assemble and link for MIPS64R6. The reason is that object files produced for MIPS64R6 // (and MIPS32R6) with the GNU assembler don't have correct final offsets in PC-relative // branches in the .text section and so they require a relocation pass (there's a relocation @@ -80,7 +80,7 @@ class AssemblerMIPS64Test : public AssemblerTest<mips64::Mips64Assembler, return " -march=mips64r6 -mmsa -Wa,--no-warn -Wl,-Ttext=0 -Wl,-e0 -nostdlib"; } - void Pad(std::vector<uint8_t>& data) OVERRIDE { + void Pad(std::vector<uint8_t>& data) override { // The GNU linker unconditionally pads the code segment with NOPs to a size that is a multiple // of 16 and there doesn't appear to be a way to suppress this padding. Our assembler doesn't // pad, so, in order for two assembler outputs to match, we need to match the padding as well. @@ -89,15 +89,15 @@ class AssemblerMIPS64Test : public AssemblerTest<mips64::Mips64Assembler, data.insert(data.end(), pad_size, 0); } - std::string GetDisassembleParameters() OVERRIDE { + std::string GetDisassembleParameters() override { return " -D -bbinary -mmips:isa64r6"; } - mips64::Mips64Assembler* CreateAssembler(ArenaAllocator* allocator) OVERRIDE { + mips64::Mips64Assembler* CreateAssembler(ArenaAllocator* allocator) override { return new (allocator) mips64::Mips64Assembler(allocator, instruction_set_features_.get()); } - void SetUpHelpers() OVERRIDE { + void SetUpHelpers() override { if (registers_.size() == 0) { registers_.push_back(new mips64::GpuRegister(mips64::ZERO)); registers_.push_back(new mips64::GpuRegister(mips64::AT)); @@ -233,7 +233,7 @@ class AssemblerMIPS64Test : public AssemblerTest<mips64::Mips64Assembler, } } - void TearDown() OVERRIDE { + void TearDown() override { AssemblerTest::TearDown(); STLDeleteElements(®isters_); STLDeleteElements(&fp_registers_); @@ -245,23 +245,23 @@ class AssemblerMIPS64Test : public AssemblerTest<mips64::Mips64Assembler, UNREACHABLE(); } - std::vector<mips64::GpuRegister*> GetRegisters() OVERRIDE { + std::vector<mips64::GpuRegister*> GetRegisters() override { return registers_; } - std::vector<mips64::FpuRegister*> GetFPRegisters() OVERRIDE { + std::vector<mips64::FpuRegister*> GetFPRegisters() override { return fp_registers_; } - std::vector<mips64::VectorRegister*> GetVectorRegisters() OVERRIDE { + std::vector<mips64::VectorRegister*> GetVectorRegisters() override { return vec_registers_; } - uint32_t CreateImmediate(int64_t imm_value) OVERRIDE { + uint32_t CreateImmediate(int64_t imm_value) override { return imm_value; } - std::string GetSecondaryRegisterName(const mips64::GpuRegister& reg) OVERRIDE { + std::string GetSecondaryRegisterName(const mips64::GpuRegister& reg) override { CHECK(secondary_register_names_.find(reg) != secondary_register_names_.end()); return secondary_register_names_[reg]; } diff --git a/compiler/utils/x86/assembler_x86.h b/compiler/utils/x86/assembler_x86.h index e42c4c986a..5ac9236d6b 100644 --- a/compiler/utils/x86/assembler_x86.h +++ b/compiler/utils/x86/assembler_x86.h @@ -306,7 +306,7 @@ class ConstantArea { ArenaVector<int32_t> buffer_; }; -class X86Assembler FINAL : public Assembler { +class X86Assembler final : public Assembler { public: explicit X86Assembler(ArenaAllocator* allocator) : Assembler(allocator), constant_area_(allocator) {} @@ -758,8 +758,8 @@ class X86Assembler FINAL : public Assembler { // int PreferredLoopAlignment() { return 16; } void Align(int alignment, int offset); - void Bind(Label* label) OVERRIDE; - void Jump(Label* label) OVERRIDE { + void Bind(Label* label) override; + void Jump(Label* label) override { jmp(label); } void Bind(NearLabel* label); diff --git a/compiler/utils/x86/assembler_x86_test.cc b/compiler/utils/x86/assembler_x86_test.cc index cd007b32d4..b03c40aa3e 100644 --- a/compiler/utils/x86/assembler_x86_test.cc +++ b/compiler/utils/x86/assembler_x86_test.cc @@ -51,19 +51,19 @@ class AssemblerX86Test : public AssemblerTest<x86::X86Assembler, x86::Immediate> Base; protected: - std::string GetArchitectureString() OVERRIDE { + std::string GetArchitectureString() override { return "x86"; } - std::string GetAssemblerParameters() OVERRIDE { + std::string GetAssemblerParameters() override { return " --32"; } - std::string GetDisassembleParameters() OVERRIDE { + std::string GetDisassembleParameters() override { return " -D -bbinary -mi386 --no-show-raw-insn"; } - void SetUpHelpers() OVERRIDE { + void SetUpHelpers() override { if (addresses_singleton_.size() == 0) { // One addressing mode to test the repeat drivers. addresses_singleton_.push_back(x86::Address(x86::EAX, x86::EBX, x86::TIMES_1, 2)); @@ -118,25 +118,25 @@ class AssemblerX86Test : public AssemblerTest<x86::X86Assembler, } } - void TearDown() OVERRIDE { + void TearDown() override { AssemblerTest::TearDown(); STLDeleteElements(®isters_); STLDeleteElements(&fp_registers_); } - std::vector<x86::Address> GetAddresses() OVERRIDE { + std::vector<x86::Address> GetAddresses() override { return addresses_; } - std::vector<x86::Register*> GetRegisters() OVERRIDE { + std::vector<x86::Register*> GetRegisters() override { return registers_; } - std::vector<x86::XmmRegister*> GetFPRegisters() OVERRIDE { + std::vector<x86::XmmRegister*> GetFPRegisters() override { return fp_registers_; } - x86::Immediate CreateImmediate(int64_t imm_value) OVERRIDE { + x86::Immediate CreateImmediate(int64_t imm_value) override { return x86::Immediate(imm_value); } diff --git a/compiler/utils/x86/jni_macro_assembler_x86.cc b/compiler/utils/x86/jni_macro_assembler_x86.cc index dd99f03aa7..df946bd229 100644 --- a/compiler/utils/x86/jni_macro_assembler_x86.cc +++ b/compiler/utils/x86/jni_macro_assembler_x86.cc @@ -25,10 +25,10 @@ namespace art { namespace x86 { // Slowpath entered when Thread::Current()->_exception is non-null -class X86ExceptionSlowPath FINAL : public SlowPath { +class X86ExceptionSlowPath final : public SlowPath { public: explicit X86ExceptionSlowPath(size_t stack_adjust) : stack_adjust_(stack_adjust) {} - virtual void Emit(Assembler *sp_asm) OVERRIDE; + virtual void Emit(Assembler *sp_asm) override; private: const size_t stack_adjust_; }; diff --git a/compiler/utils/x86/jni_macro_assembler_x86.h b/compiler/utils/x86/jni_macro_assembler_x86.h index 99219d8f88..a701080b4f 100644 --- a/compiler/utils/x86/jni_macro_assembler_x86.h +++ b/compiler/utils/x86/jni_macro_assembler_x86.h @@ -32,7 +32,7 @@ namespace x86 { class X86JNIMacroLabel; -class X86JNIMacroAssembler FINAL : public JNIMacroAssemblerFwd<X86Assembler, PointerSize::k32> { +class X86JNIMacroAssembler final : public JNIMacroAssemblerFwd<X86Assembler, PointerSize::k32> { public: explicit X86JNIMacroAssembler(ArenaAllocator* allocator) : JNIMacroAssemblerFwd(allocator) {} virtual ~X86JNIMacroAssembler() {} @@ -45,130 +45,130 @@ class X86JNIMacroAssembler FINAL : public JNIMacroAssemblerFwd<X86Assembler, Poi void BuildFrame(size_t frame_size, ManagedRegister method_reg, ArrayRef<const ManagedRegister> callee_save_regs, - const ManagedRegisterEntrySpills& entry_spills) OVERRIDE; + const ManagedRegisterEntrySpills& entry_spills) override; // Emit code that will remove an activation from the stack void RemoveFrame(size_t frame_size, ArrayRef<const ManagedRegister> callee_save_regs, - bool may_suspend) OVERRIDE; + bool may_suspend) override; - void IncreaseFrameSize(size_t adjust) OVERRIDE; - void DecreaseFrameSize(size_t adjust) OVERRIDE; + void IncreaseFrameSize(size_t adjust) override; + void DecreaseFrameSize(size_t adjust) override; // Store routines - void Store(FrameOffset offs, ManagedRegister src, size_t size) OVERRIDE; - void StoreRef(FrameOffset dest, ManagedRegister src) OVERRIDE; - void StoreRawPtr(FrameOffset dest, ManagedRegister src) OVERRIDE; + void Store(FrameOffset offs, ManagedRegister src, size_t size) override; + void StoreRef(FrameOffset dest, ManagedRegister src) override; + void StoreRawPtr(FrameOffset dest, ManagedRegister src) override; - void StoreImmediateToFrame(FrameOffset dest, uint32_t imm, ManagedRegister scratch) OVERRIDE; + void StoreImmediateToFrame(FrameOffset dest, uint32_t imm, ManagedRegister scratch) override; void StoreStackOffsetToThread(ThreadOffset32 thr_offs, FrameOffset fr_offs, - ManagedRegister scratch) OVERRIDE; + ManagedRegister scratch) override; - void StoreStackPointerToThread(ThreadOffset32 thr_offs) OVERRIDE; + void StoreStackPointerToThread(ThreadOffset32 thr_offs) override; void StoreSpanning(FrameOffset dest, ManagedRegister src, FrameOffset in_off, - ManagedRegister scratch) OVERRIDE; + ManagedRegister scratch) override; // Load routines - void Load(ManagedRegister dest, FrameOffset src, size_t size) OVERRIDE; + void Load(ManagedRegister dest, FrameOffset src, size_t size) override; - void LoadFromThread(ManagedRegister dest, ThreadOffset32 src, size_t size) OVERRIDE; + void LoadFromThread(ManagedRegister dest, ThreadOffset32 src, size_t size) override; - void LoadRef(ManagedRegister dest, FrameOffset src) OVERRIDE; + void LoadRef(ManagedRegister dest, FrameOffset src) override; void LoadRef(ManagedRegister dest, ManagedRegister base, MemberOffset offs, - bool unpoison_reference) OVERRIDE; + bool unpoison_reference) override; - void LoadRawPtr(ManagedRegister dest, ManagedRegister base, Offset offs) OVERRIDE; + void LoadRawPtr(ManagedRegister dest, ManagedRegister base, Offset offs) override; - void LoadRawPtrFromThread(ManagedRegister dest, ThreadOffset32 offs) OVERRIDE; + void LoadRawPtrFromThread(ManagedRegister dest, ThreadOffset32 offs) override; // Copying routines - void Move(ManagedRegister dest, ManagedRegister src, size_t size) OVERRIDE; + void Move(ManagedRegister dest, ManagedRegister src, size_t size) override; void CopyRawPtrFromThread(FrameOffset fr_offs, ThreadOffset32 thr_offs, - ManagedRegister scratch) OVERRIDE; + ManagedRegister scratch) override; void CopyRawPtrToThread(ThreadOffset32 thr_offs, FrameOffset fr_offs, ManagedRegister scratch) - OVERRIDE; + override; - void CopyRef(FrameOffset dest, FrameOffset src, ManagedRegister scratch) OVERRIDE; + void CopyRef(FrameOffset dest, FrameOffset src, ManagedRegister scratch) override; - void Copy(FrameOffset dest, FrameOffset src, ManagedRegister scratch, size_t size) OVERRIDE; + void Copy(FrameOffset dest, FrameOffset src, ManagedRegister scratch, size_t size) override; void Copy(FrameOffset dest, ManagedRegister src_base, Offset src_offset, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(ManagedRegister dest_base, Offset dest_offset, FrameOffset src, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(FrameOffset dest, FrameOffset src_base, Offset src_offset, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(ManagedRegister dest, Offset dest_offset, ManagedRegister src, Offset src_offset, - ManagedRegister scratch, size_t size) OVERRIDE; + ManagedRegister scratch, size_t size) override; void Copy(FrameOffset dest, Offset dest_offset, FrameOffset src, Offset src_offset, - ManagedRegister scratch, size_t size) OVERRIDE; + ManagedRegister scratch, size_t size) override; - void MemoryBarrier(ManagedRegister) OVERRIDE; + void MemoryBarrier(ManagedRegister) override; // Sign extension - void SignExtend(ManagedRegister mreg, size_t size) OVERRIDE; + void SignExtend(ManagedRegister mreg, size_t size) override; // Zero extension - void ZeroExtend(ManagedRegister mreg, size_t size) OVERRIDE; + void ZeroExtend(ManagedRegister mreg, size_t size) override; // Exploit fast access in managed code to Thread::Current() - void GetCurrentThread(ManagedRegister tr) OVERRIDE; - void GetCurrentThread(FrameOffset dest_offset, ManagedRegister scratch) OVERRIDE; + void GetCurrentThread(ManagedRegister tr) override; + void GetCurrentThread(FrameOffset dest_offset, ManagedRegister scratch) override; // Set up out_reg to hold a Object** into the handle scope, or to be null if the // value is null and null_allowed. in_reg holds a possibly stale reference // that can be used to avoid loading the handle scope entry to see if the value is // null. void CreateHandleScopeEntry(ManagedRegister out_reg, FrameOffset handlescope_offset, - ManagedRegister in_reg, bool null_allowed) OVERRIDE; + ManagedRegister in_reg, bool null_allowed) override; // Set up out_off to hold a Object** into the handle scope, or to be null if the // value is null and null_allowed. void CreateHandleScopeEntry(FrameOffset out_off, FrameOffset handlescope_offset, - ManagedRegister scratch, bool null_allowed) OVERRIDE; + ManagedRegister scratch, bool null_allowed) override; // src holds a handle scope entry (Object**) load this into dst - void LoadReferenceFromHandleScope(ManagedRegister dst, ManagedRegister src) OVERRIDE; + void LoadReferenceFromHandleScope(ManagedRegister dst, ManagedRegister src) override; // Heap::VerifyObject on src. In some cases (such as a reference to this) we // know that src may not be null. - void VerifyObject(ManagedRegister src, bool could_be_null) OVERRIDE; - void VerifyObject(FrameOffset src, bool could_be_null) OVERRIDE; + void VerifyObject(ManagedRegister src, bool could_be_null) override; + void VerifyObject(FrameOffset src, bool could_be_null) override; // Call to address held at [base+offset] - void Call(ManagedRegister base, Offset offset, ManagedRegister scratch) OVERRIDE; - void Call(FrameOffset base, Offset offset, ManagedRegister scratch) OVERRIDE; - void CallFromThread(ThreadOffset32 offset, ManagedRegister scratch) OVERRIDE; + void Call(ManagedRegister base, Offset offset, ManagedRegister scratch) override; + void Call(FrameOffset base, Offset offset, ManagedRegister scratch) override; + void CallFromThread(ThreadOffset32 offset, ManagedRegister scratch) override; // Generate code to check if Thread::Current()->exception_ is non-null // and branch to a ExceptionSlowPath if it is. - void ExceptionPoll(ManagedRegister scratch, size_t stack_adjust) OVERRIDE; + void ExceptionPoll(ManagedRegister scratch, size_t stack_adjust) override; // Create a new label that can be used with Jump/Bind calls. - std::unique_ptr<JNIMacroLabel> CreateLabel() OVERRIDE; + std::unique_ptr<JNIMacroLabel> CreateLabel() override; // Emit an unconditional jump to the label. - void Jump(JNIMacroLabel* label) OVERRIDE; + void Jump(JNIMacroLabel* label) override; // Emit a conditional jump to the label by applying a unary condition test to the register. - void Jump(JNIMacroLabel* label, JNIMacroUnaryCondition cond, ManagedRegister test) OVERRIDE; + void Jump(JNIMacroLabel* label, JNIMacroUnaryCondition cond, ManagedRegister test) override; // Code at this offset will serve as the target for the Jump call. - void Bind(JNIMacroLabel* label) OVERRIDE; + void Bind(JNIMacroLabel* label) override; private: DISALLOW_COPY_AND_ASSIGN(X86JNIMacroAssembler); }; -class X86JNIMacroLabel FINAL +class X86JNIMacroLabel final : public JNIMacroLabelCommon<X86JNIMacroLabel, art::Label, InstructionSet::kX86> { diff --git a/compiler/utils/x86_64/assembler_x86_64.h b/compiler/utils/x86_64/assembler_x86_64.h index e4d72a7ba2..e696635e62 100644 --- a/compiler/utils/x86_64/assembler_x86_64.h +++ b/compiler/utils/x86_64/assembler_x86_64.h @@ -351,7 +351,7 @@ class NearLabel : private Label { }; -class X86_64Assembler FINAL : public Assembler { +class X86_64Assembler final : public Assembler { public: explicit X86_64Assembler(ArenaAllocator* allocator) : Assembler(allocator), constant_area_(allocator) {} @@ -844,8 +844,8 @@ class X86_64Assembler FINAL : public Assembler { // int PreferredLoopAlignment() { return 16; } void Align(int alignment, int offset); - void Bind(Label* label) OVERRIDE; - void Jump(Label* label) OVERRIDE { + void Bind(Label* label) override; + void Jump(Label* label) override { jmp(label); } void Bind(NearLabel* label); diff --git a/compiler/utils/x86_64/assembler_x86_64_test.cc b/compiler/utils/x86_64/assembler_x86_64_test.cc index 0589df55d2..e1de1f172f 100644 --- a/compiler/utils/x86_64/assembler_x86_64_test.cc +++ b/compiler/utils/x86_64/assembler_x86_64_test.cc @@ -145,15 +145,15 @@ class AssemblerX86_64Test : public AssemblerTest<x86_64::X86_64Assembler, protected: // Get the typically used name for this architecture, e.g., aarch64, x86-64, ... - std::string GetArchitectureString() OVERRIDE { + std::string GetArchitectureString() override { return "x86_64"; } - std::string GetDisassembleParameters() OVERRIDE { + std::string GetDisassembleParameters() override { return " -D -bbinary -mi386:x86-64 -Mx86-64,addr64,data32 --no-show-raw-insn"; } - void SetUpHelpers() OVERRIDE { + void SetUpHelpers() override { if (addresses_singleton_.size() == 0) { // One addressing mode to test the repeat drivers. addresses_singleton_.push_back( @@ -291,7 +291,7 @@ class AssemblerX86_64Test : public AssemblerTest<x86_64::X86_64Assembler, } } - void TearDown() OVERRIDE { + void TearDown() override { AssemblerTest::TearDown(); STLDeleteElements(®isters_); STLDeleteElements(&fp_registers_); @@ -301,29 +301,29 @@ class AssemblerX86_64Test : public AssemblerTest<x86_64::X86_64Assembler, return addresses_; } - std::vector<x86_64::CpuRegister*> GetRegisters() OVERRIDE { + std::vector<x86_64::CpuRegister*> GetRegisters() override { return registers_; } - std::vector<x86_64::XmmRegister*> GetFPRegisters() OVERRIDE { + std::vector<x86_64::XmmRegister*> GetFPRegisters() override { return fp_registers_; } - x86_64::Immediate CreateImmediate(int64_t imm_value) OVERRIDE { + x86_64::Immediate CreateImmediate(int64_t imm_value) override { return x86_64::Immediate(imm_value); } - std::string GetSecondaryRegisterName(const x86_64::CpuRegister& reg) OVERRIDE { + std::string GetSecondaryRegisterName(const x86_64::CpuRegister& reg) override { CHECK(secondary_register_names_.find(reg) != secondary_register_names_.end()); return secondary_register_names_[reg]; } - std::string GetTertiaryRegisterName(const x86_64::CpuRegister& reg) OVERRIDE { + std::string GetTertiaryRegisterName(const x86_64::CpuRegister& reg) override { CHECK(tertiary_register_names_.find(reg) != tertiary_register_names_.end()); return tertiary_register_names_[reg]; } - std::string GetQuaternaryRegisterName(const x86_64::CpuRegister& reg) OVERRIDE { + std::string GetQuaternaryRegisterName(const x86_64::CpuRegister& reg) override { CHECK(quaternary_register_names_.find(reg) != quaternary_register_names_.end()); return quaternary_register_names_[reg]; } @@ -2002,11 +2002,11 @@ class JNIMacroAssemblerX86_64Test : public JNIMacroAssemblerTest<x86_64::X86_64J protected: // Get the typically used name for this architecture, e.g., aarch64, x86-64, ... - std::string GetArchitectureString() OVERRIDE { + std::string GetArchitectureString() override { return "x86_64"; } - std::string GetDisassembleParameters() OVERRIDE { + std::string GetDisassembleParameters() override { return " -D -bbinary -mi386:x86-64 -Mx86-64,addr64,data32 --no-show-raw-insn"; } diff --git a/compiler/utils/x86_64/jni_macro_assembler_x86_64.cc b/compiler/utils/x86_64/jni_macro_assembler_x86_64.cc index f6b2f9df34..d5c0878c95 100644 --- a/compiler/utils/x86_64/jni_macro_assembler_x86_64.cc +++ b/compiler/utils/x86_64/jni_macro_assembler_x86_64.cc @@ -574,10 +574,10 @@ void X86_64JNIMacroAssembler::GetCurrentThread(FrameOffset offset, ManagedRegist } // Slowpath entered when Thread::Current()->_exception is non-null -class X86_64ExceptionSlowPath FINAL : public SlowPath { +class X86_64ExceptionSlowPath final : public SlowPath { public: explicit X86_64ExceptionSlowPath(size_t stack_adjust) : stack_adjust_(stack_adjust) {} - virtual void Emit(Assembler *sp_asm) OVERRIDE; + virtual void Emit(Assembler *sp_asm) override; private: const size_t stack_adjust_; }; diff --git a/compiler/utils/x86_64/jni_macro_assembler_x86_64.h b/compiler/utils/x86_64/jni_macro_assembler_x86_64.h index d766ad4716..4411558340 100644 --- a/compiler/utils/x86_64/jni_macro_assembler_x86_64.h +++ b/compiler/utils/x86_64/jni_macro_assembler_x86_64.h @@ -31,7 +31,7 @@ namespace art { namespace x86_64 { -class X86_64JNIMacroAssembler FINAL : public JNIMacroAssemblerFwd<X86_64Assembler, +class X86_64JNIMacroAssembler final : public JNIMacroAssemblerFwd<X86_64Assembler, PointerSize::k64> { public: explicit X86_64JNIMacroAssembler(ArenaAllocator* allocator) @@ -46,107 +46,107 @@ class X86_64JNIMacroAssembler FINAL : public JNIMacroAssemblerFwd<X86_64Assemble void BuildFrame(size_t frame_size, ManagedRegister method_reg, ArrayRef<const ManagedRegister> callee_save_regs, - const ManagedRegisterEntrySpills& entry_spills) OVERRIDE; + const ManagedRegisterEntrySpills& entry_spills) override; // Emit code that will remove an activation from the stack void RemoveFrame(size_t frame_size, ArrayRef<const ManagedRegister> callee_save_regs, - bool may_suspend) OVERRIDE; + bool may_suspend) override; - void IncreaseFrameSize(size_t adjust) OVERRIDE; - void DecreaseFrameSize(size_t adjust) OVERRIDE; + void IncreaseFrameSize(size_t adjust) override; + void DecreaseFrameSize(size_t adjust) override; // Store routines - void Store(FrameOffset offs, ManagedRegister src, size_t size) OVERRIDE; - void StoreRef(FrameOffset dest, ManagedRegister src) OVERRIDE; - void StoreRawPtr(FrameOffset dest, ManagedRegister src) OVERRIDE; + void Store(FrameOffset offs, ManagedRegister src, size_t size) override; + void StoreRef(FrameOffset dest, ManagedRegister src) override; + void StoreRawPtr(FrameOffset dest, ManagedRegister src) override; - void StoreImmediateToFrame(FrameOffset dest, uint32_t imm, ManagedRegister scratch) OVERRIDE; + void StoreImmediateToFrame(FrameOffset dest, uint32_t imm, ManagedRegister scratch) override; void StoreStackOffsetToThread(ThreadOffset64 thr_offs, FrameOffset fr_offs, - ManagedRegister scratch) OVERRIDE; + ManagedRegister scratch) override; - void StoreStackPointerToThread(ThreadOffset64 thr_offs) OVERRIDE; + void StoreStackPointerToThread(ThreadOffset64 thr_offs) override; void StoreSpanning(FrameOffset dest, ManagedRegister src, FrameOffset in_off, - ManagedRegister scratch) OVERRIDE; + ManagedRegister scratch) override; // Load routines - void Load(ManagedRegister dest, FrameOffset src, size_t size) OVERRIDE; + void Load(ManagedRegister dest, FrameOffset src, size_t size) override; - void LoadFromThread(ManagedRegister dest, ThreadOffset64 src, size_t size) OVERRIDE; + void LoadFromThread(ManagedRegister dest, ThreadOffset64 src, size_t size) override; - void LoadRef(ManagedRegister dest, FrameOffset src) OVERRIDE; + void LoadRef(ManagedRegister dest, FrameOffset src) override; void LoadRef(ManagedRegister dest, ManagedRegister base, MemberOffset offs, - bool unpoison_reference) OVERRIDE; + bool unpoison_reference) override; - void LoadRawPtr(ManagedRegister dest, ManagedRegister base, Offset offs) OVERRIDE; + void LoadRawPtr(ManagedRegister dest, ManagedRegister base, Offset offs) override; - void LoadRawPtrFromThread(ManagedRegister dest, ThreadOffset64 offs) OVERRIDE; + void LoadRawPtrFromThread(ManagedRegister dest, ThreadOffset64 offs) override; // Copying routines void Move(ManagedRegister dest, ManagedRegister src, size_t size); void CopyRawPtrFromThread(FrameOffset fr_offs, ThreadOffset64 thr_offs, - ManagedRegister scratch) OVERRIDE; + ManagedRegister scratch) override; void CopyRawPtrToThread(ThreadOffset64 thr_offs, FrameOffset fr_offs, ManagedRegister scratch) - OVERRIDE; + override; - void CopyRef(FrameOffset dest, FrameOffset src, ManagedRegister scratch) OVERRIDE; + void CopyRef(FrameOffset dest, FrameOffset src, ManagedRegister scratch) override; - void Copy(FrameOffset dest, FrameOffset src, ManagedRegister scratch, size_t size) OVERRIDE; + void Copy(FrameOffset dest, FrameOffset src, ManagedRegister scratch, size_t size) override; void Copy(FrameOffset dest, ManagedRegister src_base, Offset src_offset, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(ManagedRegister dest_base, Offset dest_offset, FrameOffset src, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(FrameOffset dest, FrameOffset src_base, Offset src_offset, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(ManagedRegister dest, Offset dest_offset, ManagedRegister src, Offset src_offset, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; void Copy(FrameOffset dest, Offset dest_offset, FrameOffset src, Offset src_offset, ManagedRegister scratch, - size_t size) OVERRIDE; + size_t size) override; - void MemoryBarrier(ManagedRegister) OVERRIDE; + void MemoryBarrier(ManagedRegister) override; // Sign extension - void SignExtend(ManagedRegister mreg, size_t size) OVERRIDE; + void SignExtend(ManagedRegister mreg, size_t size) override; // Zero extension - void ZeroExtend(ManagedRegister mreg, size_t size) OVERRIDE; + void ZeroExtend(ManagedRegister mreg, size_t size) override; // Exploit fast access in managed code to Thread::Current() - void GetCurrentThread(ManagedRegister tr) OVERRIDE; - void GetCurrentThread(FrameOffset dest_offset, ManagedRegister scratch) OVERRIDE; + void GetCurrentThread(ManagedRegister tr) override; + void GetCurrentThread(FrameOffset dest_offset, ManagedRegister scratch) override; // Set up out_reg to hold a Object** into the handle scope, or to be null if the // value is null and null_allowed. in_reg holds a possibly stale reference @@ -155,46 +155,46 @@ class X86_64JNIMacroAssembler FINAL : public JNIMacroAssemblerFwd<X86_64Assemble void CreateHandleScopeEntry(ManagedRegister out_reg, FrameOffset handlescope_offset, ManagedRegister in_reg, - bool null_allowed) OVERRIDE; + bool null_allowed) override; // Set up out_off to hold a Object** into the handle scope, or to be null if the // value is null and null_allowed. void CreateHandleScopeEntry(FrameOffset out_off, FrameOffset handlescope_offset, ManagedRegister scratch, - bool null_allowed) OVERRIDE; + bool null_allowed) override; // src holds a handle scope entry (Object**) load this into dst - virtual void LoadReferenceFromHandleScope(ManagedRegister dst, ManagedRegister src) OVERRIDE; + virtual void LoadReferenceFromHandleScope(ManagedRegister dst, ManagedRegister src) override; // Heap::VerifyObject on src. In some cases (such as a reference to this) we // know that src may not be null. - void VerifyObject(ManagedRegister src, bool could_be_null) OVERRIDE; - void VerifyObject(FrameOffset src, bool could_be_null) OVERRIDE; + void VerifyObject(ManagedRegister src, bool could_be_null) override; + void VerifyObject(FrameOffset src, bool could_be_null) override; // Call to address held at [base+offset] - void Call(ManagedRegister base, Offset offset, ManagedRegister scratch) OVERRIDE; - void Call(FrameOffset base, Offset offset, ManagedRegister scratch) OVERRIDE; - void CallFromThread(ThreadOffset64 offset, ManagedRegister scratch) OVERRIDE; + void Call(ManagedRegister base, Offset offset, ManagedRegister scratch) override; + void Call(FrameOffset base, Offset offset, ManagedRegister scratch) override; + void CallFromThread(ThreadOffset64 offset, ManagedRegister scratch) override; // Generate code to check if Thread::Current()->exception_ is non-null // and branch to a ExceptionSlowPath if it is. - void ExceptionPoll(ManagedRegister scratch, size_t stack_adjust) OVERRIDE; + void ExceptionPoll(ManagedRegister scratch, size_t stack_adjust) override; // Create a new label that can be used with Jump/Bind calls. - std::unique_ptr<JNIMacroLabel> CreateLabel() OVERRIDE; + std::unique_ptr<JNIMacroLabel> CreateLabel() override; // Emit an unconditional jump to the label. - void Jump(JNIMacroLabel* label) OVERRIDE; + void Jump(JNIMacroLabel* label) override; // Emit a conditional jump to the label by applying a unary condition test to the register. - void Jump(JNIMacroLabel* label, JNIMacroUnaryCondition cond, ManagedRegister test) OVERRIDE; + void Jump(JNIMacroLabel* label, JNIMacroUnaryCondition cond, ManagedRegister test) override; // Code at this offset will serve as the target for the Jump call. - void Bind(JNIMacroLabel* label) OVERRIDE; + void Bind(JNIMacroLabel* label) override; private: DISALLOW_COPY_AND_ASSIGN(X86_64JNIMacroAssembler); }; -class X86_64JNIMacroLabel FINAL +class X86_64JNIMacroLabel final : public JNIMacroLabelCommon<X86_64JNIMacroLabel, art::Label, InstructionSet::kX86_64> { |