diff options
Diffstat (limited to 'openjdkjvmti')
| -rw-r--r-- | openjdkjvmti/OpenjdkJvmTi.cc | 47 | ||||
| -rw-r--r-- | openjdkjvmti/alloc_manager.cc | 5 | ||||
| -rw-r--r-- | openjdkjvmti/events-inl.h | 47 | ||||
| -rw-r--r-- | openjdkjvmti/events.cc | 17 | ||||
| -rw-r--r-- | openjdkjvmti/jvmti_allocator.h | 4 | ||||
| -rw-r--r-- | openjdkjvmti/jvmti_weak_table-inl.h | 10 | ||||
| -rw-r--r-- | openjdkjvmti/jvmti_weak_table.h | 2 | ||||
| -rw-r--r-- | openjdkjvmti/ti_allocator.cc | 6 | ||||
| -rw-r--r-- | openjdkjvmti/ti_class.cc | 39 | ||||
| -rw-r--r-- | openjdkjvmti/ti_field.cc | 6 | ||||
| -rw-r--r-- | openjdkjvmti/ti_heap.cc | 122 | ||||
| -rw-r--r-- | openjdkjvmti/ti_jni.cc | 2 | ||||
| -rw-r--r-- | openjdkjvmti/ti_logging.cc | 2 | ||||
| -rw-r--r-- | openjdkjvmti/ti_method.cc | 18 | ||||
| -rw-r--r-- | openjdkjvmti/ti_monitor.cc | 18 | ||||
| -rw-r--r-- | openjdkjvmti/ti_object.cc | 4 | ||||
| -rw-r--r-- | openjdkjvmti/ti_phase.cc | 2 | ||||
| -rw-r--r-- | openjdkjvmti/ti_properties.cc | 6 | ||||
| -rw-r--r-- | openjdkjvmti/ti_redefine.cc | 6 | ||||
| -rw-r--r-- | openjdkjvmti/ti_stack.cc | 26 | ||||
| -rw-r--r-- | openjdkjvmti/ti_thread.cc | 13 | ||||
| -rw-r--r-- | openjdkjvmti/ti_timers.cc | 6 |
22 files changed, 201 insertions, 207 deletions
diff --git a/openjdkjvmti/OpenjdkJvmTi.cc b/openjdkjvmti/OpenjdkJvmTi.cc index 276b3a813d..1e76368618 100644 --- a/openjdkjvmti/OpenjdkJvmTi.cc +++ b/openjdkjvmti/OpenjdkJvmTi.cc @@ -472,9 +472,9 @@ class JvmtiFunctions { static jvmtiError IterateOverObjectsReachableFromObject( jvmtiEnv* env, - jobject object ATTRIBUTE_UNUSED, - jvmtiObjectReferenceCallback object_reference_callback ATTRIBUTE_UNUSED, - const void* user_data ATTRIBUTE_UNUSED) { + [[maybe_unused]] jobject object, + [[maybe_unused]] jvmtiObjectReferenceCallback object_reference_callback, + [[maybe_unused]] const void* user_data) { ENSURE_VALID_ENV(env); ENSURE_HAS_CAP(env, can_tag_objects); return ERR(NOT_IMPLEMENTED); @@ -482,19 +482,19 @@ class JvmtiFunctions { static jvmtiError IterateOverReachableObjects( jvmtiEnv* env, - jvmtiHeapRootCallback heap_root_callback ATTRIBUTE_UNUSED, - jvmtiStackReferenceCallback stack_ref_callback ATTRIBUTE_UNUSED, - jvmtiObjectReferenceCallback object_ref_callback ATTRIBUTE_UNUSED, - const void* user_data ATTRIBUTE_UNUSED) { + [[maybe_unused]] jvmtiHeapRootCallback heap_root_callback, + [[maybe_unused]] jvmtiStackReferenceCallback stack_ref_callback, + [[maybe_unused]] jvmtiObjectReferenceCallback object_ref_callback, + [[maybe_unused]] const void* user_data) { ENSURE_VALID_ENV(env); ENSURE_HAS_CAP(env, can_tag_objects); return ERR(NOT_IMPLEMENTED); } static jvmtiError IterateOverHeap(jvmtiEnv* env, - jvmtiHeapObjectFilter object_filter ATTRIBUTE_UNUSED, - jvmtiHeapObjectCallback heap_object_callback ATTRIBUTE_UNUSED, - const void* user_data ATTRIBUTE_UNUSED) { + [[maybe_unused]] jvmtiHeapObjectFilter object_filter, + [[maybe_unused]] jvmtiHeapObjectCallback heap_object_callback, + [[maybe_unused]] const void* user_data) { ENSURE_VALID_ENV(env); ENSURE_HAS_CAP(env, can_tag_objects); return ERR(NOT_IMPLEMENTED); @@ -730,10 +730,10 @@ class JvmtiFunctions { } static jvmtiError GetConstantPool(jvmtiEnv* env, - jclass klass ATTRIBUTE_UNUSED, - jint* constant_pool_count_ptr ATTRIBUTE_UNUSED, - jint* constant_pool_byte_count_ptr ATTRIBUTE_UNUSED, - unsigned char** constant_pool_bytes_ptr ATTRIBUTE_UNUSED) { + [[maybe_unused]] jclass klass, + [[maybe_unused]] jint* constant_pool_count_ptr, + [[maybe_unused]] jint* constant_pool_byte_count_ptr, + [[maybe_unused]] unsigned char** constant_pool_bytes_ptr) { ENSURE_VALID_ENV(env); ENSURE_HAS_CAP(env, can_get_constant_pool); return ERR(NOT_IMPLEMENTED); @@ -926,15 +926,15 @@ class JvmtiFunctions { return MethodUtil::IsMethodObsolete(env, method, is_obsolete_ptr); } - static jvmtiError SetNativeMethodPrefix(jvmtiEnv* env, const char* prefix ATTRIBUTE_UNUSED) { + static jvmtiError SetNativeMethodPrefix(jvmtiEnv* env, [[maybe_unused]] const char* prefix) { ENSURE_VALID_ENV(env); ENSURE_HAS_CAP(env, can_set_native_method_prefix); return ERR(NOT_IMPLEMENTED); } static jvmtiError SetNativeMethodPrefixes(jvmtiEnv* env, - jint prefix_count ATTRIBUTE_UNUSED, - char** prefixes ATTRIBUTE_UNUSED) { + [[maybe_unused]] jint prefix_count, + [[maybe_unused]] char** prefixes) { ENSURE_VALID_ENV(env); ENSURE_HAS_CAP(env, can_set_native_method_prefix); return ERR(NOT_IMPLEMENTED); @@ -1032,8 +1032,7 @@ class JvmtiFunctions { mode); } - static jvmtiError GenerateEvents(jvmtiEnv* env, - jvmtiEvent event_type ATTRIBUTE_UNUSED) { + static jvmtiError GenerateEvents(jvmtiEnv* env, [[maybe_unused]] jvmtiEvent event_type) { ENSURE_VALID_ENV(env); return OK; } @@ -1195,28 +1194,28 @@ class JvmtiFunctions { } static jvmtiError GetCurrentThreadCpuTimerInfo(jvmtiEnv* env, - jvmtiTimerInfo* info_ptr ATTRIBUTE_UNUSED) { + [[maybe_unused]] jvmtiTimerInfo* info_ptr) { ENSURE_VALID_ENV(env); ENSURE_HAS_CAP(env, can_get_current_thread_cpu_time); return ERR(NOT_IMPLEMENTED); } - static jvmtiError GetCurrentThreadCpuTime(jvmtiEnv* env, jlong* nanos_ptr ATTRIBUTE_UNUSED) { + static jvmtiError GetCurrentThreadCpuTime(jvmtiEnv* env, [[maybe_unused]] jlong* nanos_ptr) { ENSURE_VALID_ENV(env); ENSURE_HAS_CAP(env, can_get_current_thread_cpu_time); return ERR(NOT_IMPLEMENTED); } static jvmtiError GetThreadCpuTimerInfo(jvmtiEnv* env, - jvmtiTimerInfo* info_ptr ATTRIBUTE_UNUSED) { + [[maybe_unused]] jvmtiTimerInfo* info_ptr) { ENSURE_VALID_ENV(env); ENSURE_HAS_CAP(env, can_get_thread_cpu_time); return ERR(NOT_IMPLEMENTED); } static jvmtiError GetThreadCpuTime(jvmtiEnv* env, - jthread thread ATTRIBUTE_UNUSED, - jlong* nanos_ptr ATTRIBUTE_UNUSED) { + [[maybe_unused]] jthread thread, + [[maybe_unused]] jlong* nanos_ptr) { ENSURE_VALID_ENV(env); ENSURE_HAS_CAP(env, can_get_thread_cpu_time); return ERR(NOT_IMPLEMENTED); diff --git a/openjdkjvmti/alloc_manager.cc b/openjdkjvmti/alloc_manager.cc index 5910073d79..b20e098546 100644 --- a/openjdkjvmti/alloc_manager.cc +++ b/openjdkjvmti/alloc_manager.cc @@ -198,9 +198,8 @@ void AllocationManager::PauseAllocations(art::Thread* self) { // Force every thread to either be suspended or pass through a barrier. art::ScopedThreadSuspension sts(self, art::ThreadState::kSuspended); art::Barrier barrier(0); - art::FunctionClosure fc([&](art::Thread* thr ATTRIBUTE_UNUSED) { - barrier.Pass(art::Thread::Current()); - }); + art::FunctionClosure fc( + [&]([[maybe_unused]] art::Thread* thr) { barrier.Pass(art::Thread::Current()); }); size_t requested = art::Runtime::Current()->GetThreadList()->RunCheckpoint(&fc); barrier.Increment(self, requested); } diff --git a/openjdkjvmti/events-inl.h b/openjdkjvmti/events-inl.h index 92cfbc9c41..1e309b4938 100644 --- a/openjdkjvmti/events-inl.h +++ b/openjdkjvmti/events-inl.h @@ -360,8 +360,9 @@ template <> inline bool EventHandler::ShouldDispatch<ArtJvmtiEvent::kBreakpoint>( ArtJvmTiEnv* env, art::Thread* thread, - JNIEnv* jnienv ATTRIBUTE_UNUSED, - jthread jni_thread ATTRIBUTE_UNUSED, + + [[maybe_unused]] JNIEnv* jnienv, + [[maybe_unused]] jthread jni_thread, jmethodID jmethod, jlocation location) const { art::ReaderMutexLock lk(art::Thread::Current(), env->event_info_mutex_); @@ -374,10 +375,10 @@ template <> inline bool EventHandler::ShouldDispatch<ArtJvmtiEvent::kFramePop>( ArtJvmTiEnv* env, art::Thread* thread, - JNIEnv* jnienv ATTRIBUTE_UNUSED, - jthread jni_thread ATTRIBUTE_UNUSED, - jmethodID jmethod ATTRIBUTE_UNUSED, - jboolean is_exception ATTRIBUTE_UNUSED, + [[maybe_unused]] JNIEnv* jnienv, + [[maybe_unused]] jthread jni_thread, + [[maybe_unused]] jmethodID jmethod, + [[maybe_unused]] jboolean is_exception, const art::ShadowFrame* frame) const { // Search for the frame. Do this before checking if we need to send the event so that we don't // have to deal with use-after-free or the frames being reallocated later. @@ -395,15 +396,15 @@ template <> inline bool EventHandler::ShouldDispatch<ArtJvmtiEvent::kFieldModification>( ArtJvmTiEnv* env, art::Thread* thread, - JNIEnv* jnienv ATTRIBUTE_UNUSED, - jthread jni_thread ATTRIBUTE_UNUSED, - jmethodID method ATTRIBUTE_UNUSED, - jlocation location ATTRIBUTE_UNUSED, - jclass field_klass ATTRIBUTE_UNUSED, - jobject object ATTRIBUTE_UNUSED, + [[maybe_unused]] JNIEnv* jnienv, + [[maybe_unused]] jthread jni_thread, + [[maybe_unused]] jmethodID method, + [[maybe_unused]] jlocation location, + [[maybe_unused]] jclass field_klass, + [[maybe_unused]] jobject object, jfieldID field, - char type_char ATTRIBUTE_UNUSED, - jvalue val ATTRIBUTE_UNUSED) const { + [[maybe_unused]] char type_char, + [[maybe_unused]] jvalue val) const { art::ReaderMutexLock lk(art::Thread::Current(), env->event_info_mutex_); return ShouldDispatchOnThread<ArtJvmtiEvent::kFieldModification>(env, thread) && env->modify_watched_fields.find( @@ -414,12 +415,12 @@ template <> inline bool EventHandler::ShouldDispatch<ArtJvmtiEvent::kFieldAccess>( ArtJvmTiEnv* env, art::Thread* thread, - JNIEnv* jnienv ATTRIBUTE_UNUSED, - jthread jni_thread ATTRIBUTE_UNUSED, - jmethodID method ATTRIBUTE_UNUSED, - jlocation location ATTRIBUTE_UNUSED, - jclass field_klass ATTRIBUTE_UNUSED, - jobject object ATTRIBUTE_UNUSED, + [[maybe_unused]] JNIEnv* jnienv, + [[maybe_unused]] jthread jni_thread, + [[maybe_unused]] jmethodID method, + [[maybe_unused]] jlocation location, + [[maybe_unused]] jclass field_klass, + [[maybe_unused]] jobject object, jfieldID field) const { art::ReaderMutexLock lk(art::Thread::Current(), env->event_info_mutex_); return ShouldDispatchOnThread<ArtJvmtiEvent::kFieldAccess>(env, thread) && @@ -439,7 +440,7 @@ inline void EventHandler::ExecuteCallback<ArtJvmtiEvent::kFramePop>( jthread jni_thread, jmethodID jmethod, jboolean is_exception, - const art::ShadowFrame* frame ATTRIBUTE_UNUSED) { + [[maybe_unused]] const art::ShadowFrame* frame) { ExecuteCallback<ArtJvmtiEvent::kFramePop>(event, jnienv, jni_thread, jmethod, is_exception); } @@ -628,10 +629,10 @@ inline bool EventHandler::ShouldDispatchOnThread(ArtJvmTiEnv* env, art::Thread* return dispatch; } -template <ArtJvmtiEvent kEvent, typename ...Args> +template <ArtJvmtiEvent kEvent, typename... Args> inline bool EventHandler::ShouldDispatch(ArtJvmTiEnv* env, art::Thread* thread, - Args... args ATTRIBUTE_UNUSED) const { + [[maybe_unused]] Args... args) const { static_assert(std::is_same<typename impl::EventFnType<kEvent>::type, void(*)(jvmtiEnv*, Args...)>::value, "Unexpected different type of shouldDispatch"); diff --git a/openjdkjvmti/events.cc b/openjdkjvmti/events.cc index 64da6ed3f6..31107d08a5 100644 --- a/openjdkjvmti/events.cc +++ b/openjdkjvmti/events.cc @@ -737,9 +737,7 @@ class JvmtiMethodTraceListener final : public art::instrumentation::Instrumentat // Call-back for when a method is popped due to an exception throw. A method will either cause a // MethodExited call-back or a MethodUnwind call-back when its activation is removed. - void MethodUnwind(art::Thread* self, - art::ArtMethod* method, - uint32_t dex_pc ATTRIBUTE_UNUSED) + void MethodUnwind(art::Thread* self, art::ArtMethod* method, [[maybe_unused]] uint32_t dex_pc) REQUIRES_SHARED(art::Locks::mutator_lock_) override { if (!method->IsRuntimeMethod() && event_handler_->IsEventEnabledAnywhere(ArtJvmtiEvent::kMethodExit)) { @@ -767,10 +765,9 @@ class JvmtiMethodTraceListener final : public art::instrumentation::Instrumentat // Call-back for when the dex pc moves in a method. void DexPcMoved(art::Thread* self, - art::Handle<art::mirror::Object> this_object ATTRIBUTE_UNUSED, + [[maybe_unused]] art::Handle<art::mirror::Object> this_object, art::ArtMethod* method, - uint32_t new_dex_pc) - REQUIRES_SHARED(art::Locks::mutator_lock_) override { + uint32_t new_dex_pc) REQUIRES_SHARED(art::Locks::mutator_lock_) override { DCHECK(!method->IsRuntimeMethod()); // Default methods might be copied to multiple classes. We need to get the canonical version of // this method so that we can check for breakpoints correctly. @@ -1034,10 +1031,10 @@ class JvmtiMethodTraceListener final : public art::instrumentation::Instrumentat } // Call-back for when we execute a branch. - void Branch(art::Thread* self ATTRIBUTE_UNUSED, - art::ArtMethod* method ATTRIBUTE_UNUSED, - uint32_t dex_pc ATTRIBUTE_UNUSED, - int32_t dex_pc_offset ATTRIBUTE_UNUSED) + void Branch([[maybe_unused]] art::Thread* self, + [[maybe_unused]] art::ArtMethod* method, + [[maybe_unused]] uint32_t dex_pc, + [[maybe_unused]] int32_t dex_pc_offset) REQUIRES_SHARED(art::Locks::mutator_lock_) override { return; } diff --git a/openjdkjvmti/jvmti_allocator.h b/openjdkjvmti/jvmti_allocator.h index 4adf769f12..618a661c5a 100644 --- a/openjdkjvmti/jvmti_allocator.h +++ b/openjdkjvmti/jvmti_allocator.h @@ -110,7 +110,7 @@ class JvmtiAllocator { pointer address(reference x) const { return &x; } const_pointer address(const_reference x) const { return &x; } - pointer allocate(size_type n, JvmtiAllocator<void>::pointer hint ATTRIBUTE_UNUSED = nullptr) { + pointer allocate(size_type n, [[maybe_unused]] JvmtiAllocator<void>::pointer hint = nullptr) { DCHECK_LE(n, max_size()); if (env_ == nullptr) { T* result = reinterpret_cast<T*>(AllocUtil::AllocateImpl(n * sizeof(T))); @@ -123,7 +123,7 @@ class JvmtiAllocator { return reinterpret_cast<T*>(result); } } - void deallocate(pointer p, size_type n ATTRIBUTE_UNUSED) { + void deallocate(pointer p, [[maybe_unused]] size_type n) { if (env_ == nullptr) { AllocUtil::DeallocateImpl(reinterpret_cast<unsigned char*>(p)); } else { diff --git a/openjdkjvmti/jvmti_weak_table-inl.h b/openjdkjvmti/jvmti_weak_table-inl.h index c5663e5475..7502ad272a 100644 --- a/openjdkjvmti/jvmti_weak_table-inl.h +++ b/openjdkjvmti/jvmti_weak_table-inl.h @@ -68,10 +68,10 @@ void JvmtiWeakTable<T>::UpdateTableWithReadBarrier() { update_since_last_sweep_ = true; auto WithReadBarrierUpdater = [&](const art::GcRoot<art::mirror::Object>& original_root, - art::mirror::Object* original_obj ATTRIBUTE_UNUSED) - REQUIRES_SHARED(art::Locks::mutator_lock_) { - return original_root.Read<art::kWithReadBarrier>(); - }; + [[maybe_unused]] art::mirror::Object* original_obj) + REQUIRES_SHARED(art::Locks::mutator_lock_) { + return original_root.Read<art::kWithReadBarrier>(); + }; UpdateTableWith<decltype(WithReadBarrierUpdater), kIgnoreNull>(WithReadBarrierUpdater); } @@ -198,7 +198,7 @@ void JvmtiWeakTable<T>::SweepImpl(art::IsMarkedVisitor* visitor) { art::Thread* self = art::Thread::Current(); art::MutexLock mu(self, allow_disallow_lock_); - auto IsMarkedUpdater = [&](const art::GcRoot<art::mirror::Object>& original_root ATTRIBUTE_UNUSED, + auto IsMarkedUpdater = [&]([[maybe_unused]] const art::GcRoot<art::mirror::Object>& original_root, art::mirror::Object* original_obj) { return visitor->IsMarked(original_obj); }; diff --git a/openjdkjvmti/jvmti_weak_table.h b/openjdkjvmti/jvmti_weak_table.h index 674b2a3d52..8f8d89b818 100644 --- a/openjdkjvmti/jvmti_weak_table.h +++ b/openjdkjvmti/jvmti_weak_table.h @@ -128,7 +128,7 @@ class JvmtiWeakTable : public art::gc::SystemWeakHolder { return false; } // If DoesHandleNullOnSweep returns true, this function will be called. - virtual void HandleNullSweep(T tag ATTRIBUTE_UNUSED) {} + virtual void HandleNullSweep([[maybe_unused]] T tag) {} private: ALWAYS_INLINE diff --git a/openjdkjvmti/ti_allocator.cc b/openjdkjvmti/ti_allocator.cc index 575558dccf..1e6d4627b5 100644 --- a/openjdkjvmti/ti_allocator.cc +++ b/openjdkjvmti/ti_allocator.cc @@ -47,7 +47,7 @@ namespace openjdkjvmti { std::atomic<jlong> AllocUtil::allocated; -jvmtiError AllocUtil::GetGlobalJvmtiAllocationState(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError AllocUtil::GetGlobalJvmtiAllocationState([[maybe_unused]] jvmtiEnv* env, jlong* allocated_ptr) { if (allocated_ptr == nullptr) { return ERR(NULL_POINTER); @@ -56,7 +56,7 @@ jvmtiError AllocUtil::GetGlobalJvmtiAllocationState(jvmtiEnv* env ATTRIBUTE_UNUS return OK; } -jvmtiError AllocUtil::Allocate(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError AllocUtil::Allocate([[maybe_unused]] jvmtiEnv* env, jlong size, unsigned char** mem_ptr) { if (size < 0) { @@ -80,7 +80,7 @@ unsigned char* AllocUtil::AllocateImpl(jlong size) { return ret; } -jvmtiError AllocUtil::Deallocate(jvmtiEnv* env ATTRIBUTE_UNUSED, unsigned char* mem) { +jvmtiError AllocUtil::Deallocate([[maybe_unused]] jvmtiEnv* env, unsigned char* mem) { DeallocateImpl(mem); return OK; } diff --git a/openjdkjvmti/ti_class.cc b/openjdkjvmti/ti_class.cc index 3d44516173..7ded350c53 100644 --- a/openjdkjvmti/ti_class.cc +++ b/openjdkjvmti/ti_class.cc @@ -162,10 +162,10 @@ struct ClassCallback : public art::ClassLoadCallback { art::Handle<art::mirror::Class> klass, art::Handle<art::mirror::ClassLoader> class_loader, const art::DexFile& initial_dex_file, - const art::dex::ClassDef& initial_class_def ATTRIBUTE_UNUSED, - /*out*/art::DexFile const** final_dex_file, - /*out*/art::dex::ClassDef const** final_class_def) - override REQUIRES_SHARED(art::Locks::mutator_lock_) { + [[maybe_unused]] const art::dex::ClassDef& initial_class_def, + /*out*/ art::DexFile const** final_dex_file, + /*out*/ art::dex::ClassDef const** final_class_def) override + REQUIRES_SHARED(art::Locks::mutator_lock_) { bool is_enabled = event_handler->IsEventEnabledAnywhere(ArtJvmtiEvent::kClassFileLoadHookRetransformable) || event_handler->IsEventEnabledAnywhere(ArtJvmtiEvent::kClassFileLoadHookNonRetransformable); @@ -387,8 +387,7 @@ struct ClassCallback : public art::ClassLoadCallback { void VisitRoots(art::mirror::Object*** roots, size_t count, - const art::RootInfo& info ATTRIBUTE_UNUSED) - override { + [[maybe_unused]] const art::RootInfo& info) override { for (size_t i = 0; i != count; ++i) { if (*roots[i] == input_) { *roots[i] = output_; @@ -398,8 +397,8 @@ struct ClassCallback : public art::ClassLoadCallback { void VisitRoots(art::mirror::CompressedReference<art::mirror::Object>** roots, size_t count, - const art::RootInfo& info ATTRIBUTE_UNUSED) - override REQUIRES_SHARED(art::Locks::mutator_lock_) { + [[maybe_unused]] const art::RootInfo& info) override + REQUIRES_SHARED(art::Locks::mutator_lock_) { for (size_t i = 0; i != count; ++i) { if (roots[i]->AsMirrorPtr() == input_) { roots[i]->Assign(output_); @@ -476,7 +475,7 @@ struct ClassCallback : public art::ClassLoadCallback { void operator()(art::mirror::Object* src, art::MemberOffset field_offset, - bool is_static ATTRIBUTE_UNUSED) const + [[maybe_unused]] bool is_static) const REQUIRES_SHARED(art::Locks::mutator_lock_) { art::mirror::HeapReference<art::mirror::Object>* trg = src->GetFieldObjectReferenceAddr(field_offset); @@ -487,7 +486,7 @@ struct ClassCallback : public art::ClassLoadCallback { } } - void operator()(art::ObjPtr<art::mirror::Class> klass ATTRIBUTE_UNUSED, + void operator()([[maybe_unused]] art::ObjPtr<art::mirror::Class> klass, art::ObjPtr<art::mirror::Reference> reference) const REQUIRES_SHARED(art::Locks::mutator_lock_) { art::mirror::Object* val = reference->GetReferent(); @@ -496,13 +495,13 @@ struct ClassCallback : public art::ClassLoadCallback { } } - void VisitRoot(art::mirror::CompressedReference<art::mirror::Object>* root ATTRIBUTE_UNUSED) - const { + void VisitRoot( + [[maybe_unused]] art::mirror::CompressedReference<art::mirror::Object>* root) const { LOG(FATAL) << "Unreachable"; } void VisitRootIfNonNull( - art::mirror::CompressedReference<art::mirror::Object>* root ATTRIBUTE_UNUSED) const { + [[maybe_unused]] art::mirror::CompressedReference<art::mirror::Object>* root) const { LOG(FATAL) << "Unreachable"; } @@ -623,7 +622,7 @@ jvmtiError ClassUtil::GetClassMethods(jvmtiEnv* env, if (art::kIsDebugBuild) { size_t count = 0; - for (auto& m ATTRIBUTE_UNUSED : klass->GetDeclaredMethods(art::kRuntimePointerSize)) { + for ([[maybe_unused]] auto& m : klass->GetDeclaredMethods(art::kRuntimePointerSize)) { count++; } CHECK_EQ(count, klass->NumDirectMethods() + klass->NumDeclaredVirtualMethods()); @@ -747,7 +746,7 @@ jvmtiError ClassUtil::GetClassSignature(jvmtiEnv* env, return ERR(NONE); } -jvmtiError ClassUtil::GetClassStatus(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError ClassUtil::GetClassStatus([[maybe_unused]] jvmtiEnv* env, jclass jklass, jint* status_ptr) { art::ScopedObjectAccess soa(art::Thread::Current()); @@ -798,7 +797,7 @@ static jvmtiError ClassIsT(jclass jklass, T test, jboolean* is_t_ptr) { return ERR(NONE); } -jvmtiError ClassUtil::IsInterface(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError ClassUtil::IsInterface([[maybe_unused]] jvmtiEnv* env, jclass jklass, jboolean* is_interface_ptr) { auto test = [](art::ObjPtr<art::mirror::Class> klass) REQUIRES_SHARED(art::Locks::mutator_lock_) { @@ -807,7 +806,7 @@ jvmtiError ClassUtil::IsInterface(jvmtiEnv* env ATTRIBUTE_UNUSED, return ClassIsT(jklass, test, is_interface_ptr); } -jvmtiError ClassUtil::IsArrayClass(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError ClassUtil::IsArrayClass([[maybe_unused]] jvmtiEnv* env, jclass jklass, jboolean* is_array_class_ptr) { auto test = [](art::ObjPtr<art::mirror::Class> klass) REQUIRES_SHARED(art::Locks::mutator_lock_) { @@ -834,7 +833,7 @@ static uint32_t ClassGetModifiers(art::Thread* self, art::ObjPtr<art::mirror::Cl return art::mirror::Class::GetInnerClassFlags(h_klass, modifiers); } -jvmtiError ClassUtil::GetClassModifiers(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError ClassUtil::GetClassModifiers([[maybe_unused]] jvmtiEnv* env, jclass jklass, jint* modifiers_ptr) { art::ScopedObjectAccess soa(art::Thread::Current()); @@ -852,7 +851,7 @@ jvmtiError ClassUtil::GetClassModifiers(jvmtiEnv* env ATTRIBUTE_UNUSED, return ERR(NONE); } -jvmtiError ClassUtil::GetClassLoader(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError ClassUtil::GetClassLoader([[maybe_unused]] jvmtiEnv* env, jclass jklass, jobject* classloader_ptr) { art::ScopedObjectAccess soa(art::Thread::Current()); @@ -1047,7 +1046,7 @@ jvmtiError ClassUtil::GetClassLoaderClasses(jvmtiEnv* env, return ERR(NONE); } -jvmtiError ClassUtil::GetClassVersionNumbers(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError ClassUtil::GetClassVersionNumbers([[maybe_unused]] jvmtiEnv* env, jclass jklass, jint* minor_version_ptr, jint* major_version_ptr) { diff --git a/openjdkjvmti/ti_field.cc b/openjdkjvmti/ti_field.cc index d4c0ec830b..4e39e22649 100644 --- a/openjdkjvmti/ti_field.cc +++ b/openjdkjvmti/ti_field.cc @@ -200,7 +200,7 @@ jvmtiError FieldUtil::GetFieldName(jvmtiEnv* env, return ERR(NONE); } -jvmtiError FieldUtil::GetFieldDeclaringClass(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError FieldUtil::GetFieldDeclaringClass([[maybe_unused]] jvmtiEnv* env, jclass klass, jfieldID field, jclass* declaring_class_ptr) { @@ -223,7 +223,7 @@ jvmtiError FieldUtil::GetFieldDeclaringClass(jvmtiEnv* env ATTRIBUTE_UNUSED, return ERR(NONE); } -jvmtiError FieldUtil::GetFieldModifiers(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError FieldUtil::GetFieldModifiers([[maybe_unused]] jvmtiEnv* env, jclass klass, jfieldID field, jint* modifiers_ptr) { @@ -246,7 +246,7 @@ jvmtiError FieldUtil::GetFieldModifiers(jvmtiEnv* env ATTRIBUTE_UNUSED, return ERR(NONE); } -jvmtiError FieldUtil::IsFieldSynthetic(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError FieldUtil::IsFieldSynthetic([[maybe_unused]] jvmtiEnv* env, jclass klass, jfieldID field, jboolean* is_synthetic_ptr) { diff --git a/openjdkjvmti/ti_heap.cc b/openjdkjvmti/ti_heap.cc index 01864cd312..4be7922e70 100644 --- a/openjdkjvmti/ti_heap.cc +++ b/openjdkjvmti/ti_heap.cc @@ -211,11 +211,11 @@ jint ReportPrimitiveArray(art::ObjPtr<art::mirror::Object> obj, } template <typename UserData> -bool VisitorFalse(art::ObjPtr<art::mirror::Object> obj ATTRIBUTE_UNUSED, - art::ObjPtr<art::mirror::Class> klass ATTRIBUTE_UNUSED, - art::ArtField& field ATTRIBUTE_UNUSED, - size_t field_index ATTRIBUTE_UNUSED, - UserData* user_data ATTRIBUTE_UNUSED) { +bool VisitorFalse([[maybe_unused]] art::ObjPtr<art::mirror::Object> obj, + [[maybe_unused]] art::ObjPtr<art::mirror::Class> klass, + [[maybe_unused]] art::ArtField& field, + [[maybe_unused]] size_t field_index, + [[maybe_unused]] UserData* user_data) { return false; } @@ -476,11 +476,11 @@ class FieldVisitor { // Debug helper. Prints the structure of an object. template <bool kStatic, bool kRef> struct DumpVisitor { - static bool Callback(art::ObjPtr<art::mirror::Object> obj ATTRIBUTE_UNUSED, - art::ObjPtr<art::mirror::Class> klass ATTRIBUTE_UNUSED, + static bool Callback([[maybe_unused]] art::ObjPtr<art::mirror::Object> obj, + [[maybe_unused]] art::ObjPtr<art::mirror::Class> klass, art::ArtField& field, size_t field_index, - void* user_data ATTRIBUTE_UNUSED) + [[maybe_unused]] void* user_data) REQUIRES_SHARED(art::Locks::mutator_lock_) { LOG(ERROR) << (kStatic ? "static " : "instance ") << (kRef ? "ref " : "primitive ") @@ -490,8 +490,7 @@ struct DumpVisitor { return false; } }; -ATTRIBUTE_UNUSED -void DumpObjectFields(art::ObjPtr<art::mirror::Object> obj) +[[maybe_unused]] void DumpObjectFields(art::ObjPtr<art::mirror::Object> obj) REQUIRES_SHARED(art::Locks::mutator_lock_) { if (obj->IsClass()) { FieldVisitor<void, false>:: ReportFields(obj, @@ -825,14 +824,13 @@ jvmtiError HeapUtil::IterateThroughHeap(jvmtiEnv* env, jclass klass, const jvmtiHeapCallbacks* callbacks, const void* user_data) { - auto JvmtiIterateHeap = [](art::mirror::Object* obj ATTRIBUTE_UNUSED, + auto JvmtiIterateHeap = []([[maybe_unused]] art::mirror::Object* obj, const jvmtiHeapCallbacks* cb_callbacks, jlong class_tag, jlong size, jlong* tag, jint length, - void* cb_user_data) - REQUIRES_SHARED(art::Locks::mutator_lock_) { + void* cb_user_data) REQUIRES_SHARED(art::Locks::mutator_lock_) { return cb_callbacks->heap_iteration_callback(class_tag, size, tag, @@ -1108,31 +1106,33 @@ class FollowReferencesHelper final { } // All instance fields. - auto report_instance_field = [&](art::ObjPtr<art::mirror::Object> src, - art::ObjPtr<art::mirror::Class> obj_klass ATTRIBUTE_UNUSED, - art::ArtField& field, - size_t field_index, - void* user_data ATTRIBUTE_UNUSED) - REQUIRES_SHARED(art::Locks::mutator_lock_) - REQUIRES(!*tag_table_->GetAllowDisallowLock()) { - art::ObjPtr<art::mirror::Object> field_value = field.GetObject(src); - if (field_value != nullptr) { - jvmtiHeapReferenceInfo reference_info; - memset(&reference_info, 0, sizeof(reference_info)); - - reference_info.field.index = field_index; - - jvmtiHeapReferenceKind kind = - field.GetOffset().Int32Value() == art::mirror::Object::ClassOffset().Int32Value() - ? JVMTI_HEAP_REFERENCE_CLASS - : JVMTI_HEAP_REFERENCE_FIELD; - const jvmtiHeapReferenceInfo* reference_info_ptr = - kind == JVMTI_HEAP_REFERENCE_CLASS ? nullptr : &reference_info; - - return !ReportReferenceMaybeEnqueue(kind, reference_info_ptr, src.Ptr(), field_value.Ptr()); - } - return false; - }; + auto report_instance_field = + [&](art::ObjPtr<art::mirror::Object> src, + [[maybe_unused]] art::ObjPtr<art::mirror::Class> obj_klass, + art::ArtField& field, + size_t field_index, + [[maybe_unused]] void* user_data) REQUIRES_SHARED(art::Locks::mutator_lock_) + REQUIRES(!*tag_table_->GetAllowDisallowLock()) { + art::ObjPtr<art::mirror::Object> field_value = field.GetObject(src); + if (field_value != nullptr) { + jvmtiHeapReferenceInfo reference_info; + memset(&reference_info, 0, sizeof(reference_info)); + + reference_info.field.index = field_index; + + jvmtiHeapReferenceKind kind = + field.GetOffset().Int32Value() == + art::mirror::Object::ClassOffset().Int32Value() ? + JVMTI_HEAP_REFERENCE_CLASS : + JVMTI_HEAP_REFERENCE_FIELD; + const jvmtiHeapReferenceInfo* reference_info_ptr = + kind == JVMTI_HEAP_REFERENCE_CLASS ? nullptr : &reference_info; + + return !ReportReferenceMaybeEnqueue( + kind, reference_info_ptr, src.Ptr(), field_value.Ptr()); + } + return false; + }; stop_reports_ = FieldVisitor<void, true>::ReportFields(obj, nullptr, VisitorFalse<void>, @@ -1241,27 +1241,27 @@ class FollowReferencesHelper final { DCHECK_EQ(h_klass.Get(), klass); // Declared static fields. - auto report_static_field = [&](art::ObjPtr<art::mirror::Object> obj ATTRIBUTE_UNUSED, - art::ObjPtr<art::mirror::Class> obj_klass, - art::ArtField& field, - size_t field_index, - void* user_data ATTRIBUTE_UNUSED) - REQUIRES_SHARED(art::Locks::mutator_lock_) - REQUIRES(!*tag_table_->GetAllowDisallowLock()) { - art::ObjPtr<art::mirror::Object> field_value = field.GetObject(obj_klass); - if (field_value != nullptr) { - jvmtiHeapReferenceInfo reference_info; - memset(&reference_info, 0, sizeof(reference_info)); - - reference_info.field.index = static_cast<jint>(field_index); - - return !ReportReferenceMaybeEnqueue(JVMTI_HEAP_REFERENCE_STATIC_FIELD, - &reference_info, - obj_klass.Ptr(), - field_value.Ptr()); - } - return false; - }; + auto report_static_field = + [&]([[maybe_unused]] art::ObjPtr<art::mirror::Object> obj, + art::ObjPtr<art::mirror::Class> obj_klass, + art::ArtField& field, + size_t field_index, + [[maybe_unused]] void* user_data) REQUIRES_SHARED(art::Locks::mutator_lock_) + REQUIRES(!*tag_table_->GetAllowDisallowLock()) { + art::ObjPtr<art::mirror::Object> field_value = field.GetObject(obj_klass); + if (field_value != nullptr) { + jvmtiHeapReferenceInfo reference_info; + memset(&reference_info, 0, sizeof(reference_info)); + + reference_info.field.index = static_cast<jint>(field_index); + + return !ReportReferenceMaybeEnqueue(JVMTI_HEAP_REFERENCE_STATIC_FIELD, + &reference_info, + obj_klass.Ptr(), + field_value.Ptr()); + } + return false; + }; stop_reports_ = FieldVisitor<void, false>::ReportFields(klass, nullptr, VisitorFalse<void>, @@ -1473,7 +1473,7 @@ jvmtiError HeapUtil::GetLoadedClasses(jvmtiEnv* env, return ERR(NONE); } -jvmtiError HeapUtil::ForceGarbageCollection(jvmtiEnv* env ATTRIBUTE_UNUSED) { +jvmtiError HeapUtil::ForceGarbageCollection([[maybe_unused]] jvmtiEnv* env) { art::Runtime::Current()->GetHeap()->CollectGarbage(/* clear_soft_references= */ false); return ERR(NONE); @@ -1666,7 +1666,7 @@ static void ReplaceObjectReferences(const ObjectMap& map) } // java.lang.ref.Reference visitor. - void operator()(art::ObjPtr<art::mirror::Class> klass ATTRIBUTE_UNUSED, + void operator()([[maybe_unused]] art::ObjPtr<art::mirror::Class> klass, art::ObjPtr<art::mirror::Reference> ref) const REQUIRES_SHARED(art::Locks::mutator_lock_) { operator()(ref, art::mirror::Reference::ReferentOffset(), /* is_static */ false); diff --git a/openjdkjvmti/ti_jni.cc b/openjdkjvmti/ti_jni.cc index b655d6a8e1..98d4ec7290 100644 --- a/openjdkjvmti/ti_jni.cc +++ b/openjdkjvmti/ti_jni.cc @@ -42,7 +42,7 @@ namespace openjdkjvmti { -jvmtiError JNIUtil::SetJNIFunctionTable(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError JNIUtil::SetJNIFunctionTable([[maybe_unused]] jvmtiEnv* env, const jniNativeInterface* function_table) { // While we supporting setting null (which will reset the table), the spec says no. if (function_table == nullptr) { diff --git a/openjdkjvmti/ti_logging.cc b/openjdkjvmti/ti_logging.cc index 8740ec65c2..82057b1251 100644 --- a/openjdkjvmti/ti_logging.cc +++ b/openjdkjvmti/ti_logging.cc @@ -100,7 +100,7 @@ jvmtiError LogUtil::SetVerboseFlagExt(jvmtiEnv* env, const char* data, jboolean return OK; } -jvmtiError LogUtil::SetVerboseFlag(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError LogUtil::SetVerboseFlag([[maybe_unused]] jvmtiEnv* env, jvmtiVerboseFlag flag, jboolean value) { if (flag == jvmtiVerboseFlag::JVMTI_VERBOSE_OTHER) { diff --git a/openjdkjvmti/ti_method.cc b/openjdkjvmti/ti_method.cc index 99a5d9c988..dc3f6dcf91 100644 --- a/openjdkjvmti/ti_method.cc +++ b/openjdkjvmti/ti_method.cc @@ -162,7 +162,7 @@ jvmtiError MethodUtil::GetBytecodes(jvmtiEnv* env, return OK; } -jvmtiError MethodUtil::GetArgumentsSize(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError MethodUtil::GetArgumentsSize([[maybe_unused]] jvmtiEnv* env, jmethodID method, jint* size_ptr) { if (method == nullptr) { @@ -284,7 +284,7 @@ jvmtiError MethodUtil::GetLocalVariableTable(jvmtiEnv* env, return release(entry_count_ptr, table_ptr); } -jvmtiError MethodUtil::GetMaxLocals(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError MethodUtil::GetMaxLocals([[maybe_unused]] jvmtiEnv* env, jmethodID method, jint* max_ptr) { if (method == nullptr) { @@ -380,7 +380,7 @@ jvmtiError MethodUtil::GetMethodName(jvmtiEnv* env, return ERR(NONE); } -jvmtiError MethodUtil::GetMethodDeclaringClass(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError MethodUtil::GetMethodDeclaringClass([[maybe_unused]] jvmtiEnv* env, jmethodID method, jclass* declaring_class_ptr) { if (declaring_class_ptr == nullptr) { @@ -397,7 +397,7 @@ jvmtiError MethodUtil::GetMethodDeclaringClass(jvmtiEnv* env ATTRIBUTE_UNUSED, return ERR(NONE); } -jvmtiError MethodUtil::GetMethodLocation(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError MethodUtil::GetMethodLocation([[maybe_unused]] jvmtiEnv* env, jmethodID method, jlocation* start_location_ptr, jlocation* end_location_ptr) { @@ -430,7 +430,7 @@ jvmtiError MethodUtil::GetMethodLocation(jvmtiEnv* env ATTRIBUTE_UNUSED, return ERR(NONE); } -jvmtiError MethodUtil::GetMethodModifiers(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError MethodUtil::GetMethodModifiers([[maybe_unused]] jvmtiEnv* env, jmethodID method, jint* modifiers_ptr) { if (modifiers_ptr == nullptr) { @@ -507,7 +507,7 @@ jvmtiError MethodUtil::GetLineNumberTable(jvmtiEnv* env, } template <typename T> -static jvmtiError IsMethodT(jvmtiEnv* env ATTRIBUTE_UNUSED, +static jvmtiError IsMethodT([[maybe_unused]] jvmtiEnv* env, jmethodID method, T test, jboolean* is_t_ptr) { @@ -833,9 +833,9 @@ class GetLocalVariableClosure : public CommonLocalVariableClosure { return res; } - jvmtiError GetTypeErrorInner(art::ArtMethod* method ATTRIBUTE_UNUSED, + jvmtiError GetTypeErrorInner([[maybe_unused]] art::ArtMethod* method, SlotType slot_type, - const std::string& descriptor ATTRIBUTE_UNUSED) + [[maybe_unused]] const std::string& descriptor) REQUIRES_SHARED(art::Locks::mutator_lock_) { switch (type_) { case art::Primitive::kPrimFloat: @@ -1177,7 +1177,7 @@ class GetLocalInstanceClosure : public art::Closure { art::GcRoot<art::mirror::Object> val_; }; -jvmtiError MethodUtil::GetLocalInstance(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError MethodUtil::GetLocalInstance([[maybe_unused]] jvmtiEnv* env, jthread thread, jint depth, jobject* data) { diff --git a/openjdkjvmti/ti_monitor.cc b/openjdkjvmti/ti_monitor.cc index f244cc114d..469693d37f 100644 --- a/openjdkjvmti/ti_monitor.cc +++ b/openjdkjvmti/ti_monitor.cc @@ -225,7 +225,7 @@ static JvmtiMonitor* DecodeMonitor(jrawMonitorID id) { return reinterpret_cast<JvmtiMonitor*>(id); } -jvmtiError MonitorUtil::CreateRawMonitor(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError MonitorUtil::CreateRawMonitor([[maybe_unused]] jvmtiEnv* env, const char* name, jrawMonitorID* monitor_ptr) { if (name == nullptr || monitor_ptr == nullptr) { @@ -238,7 +238,7 @@ jvmtiError MonitorUtil::CreateRawMonitor(jvmtiEnv* env ATTRIBUTE_UNUSED, return ERR(NONE); } -jvmtiError MonitorUtil::DestroyRawMonitor(jvmtiEnv* env ATTRIBUTE_UNUSED, jrawMonitorID id) { +jvmtiError MonitorUtil::DestroyRawMonitor([[maybe_unused]] jvmtiEnv* env, jrawMonitorID id) { if (id == nullptr) { return ERR(INVALID_MONITOR); } @@ -253,7 +253,7 @@ jvmtiError MonitorUtil::DestroyRawMonitor(jvmtiEnv* env ATTRIBUTE_UNUSED, jrawMo return ERR(NONE); } -jvmtiError MonitorUtil::RawMonitorEnterNoSuspend(jvmtiEnv* env ATTRIBUTE_UNUSED, jrawMonitorID id) { +jvmtiError MonitorUtil::RawMonitorEnterNoSuspend([[maybe_unused]] jvmtiEnv* env, jrawMonitorID id) { if (id == nullptr) { return ERR(INVALID_MONITOR); } @@ -266,7 +266,7 @@ jvmtiError MonitorUtil::RawMonitorEnterNoSuspend(jvmtiEnv* env ATTRIBUTE_UNUSED, return ERR(NONE); } -jvmtiError MonitorUtil::RawMonitorEnter(jvmtiEnv* env ATTRIBUTE_UNUSED, jrawMonitorID id) { +jvmtiError MonitorUtil::RawMonitorEnter([[maybe_unused]] jvmtiEnv* env, jrawMonitorID id) { if (id == nullptr) { return ERR(INVALID_MONITOR); } @@ -279,7 +279,7 @@ jvmtiError MonitorUtil::RawMonitorEnter(jvmtiEnv* env ATTRIBUTE_UNUSED, jrawMoni return ERR(NONE); } -jvmtiError MonitorUtil::RawMonitorExit(jvmtiEnv* env ATTRIBUTE_UNUSED, jrawMonitorID id) { +jvmtiError MonitorUtil::RawMonitorExit([[maybe_unused]] jvmtiEnv* env, jrawMonitorID id) { if (id == nullptr) { return ERR(INVALID_MONITOR); } @@ -294,7 +294,7 @@ jvmtiError MonitorUtil::RawMonitorExit(jvmtiEnv* env ATTRIBUTE_UNUSED, jrawMonit return ERR(NONE); } -jvmtiError MonitorUtil::RawMonitorWait(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError MonitorUtil::RawMonitorWait([[maybe_unused]] jvmtiEnv* env, jrawMonitorID id, jlong millis) { if (id == nullptr) { @@ -322,7 +322,7 @@ jvmtiError MonitorUtil::RawMonitorWait(jvmtiEnv* env ATTRIBUTE_UNUSED, return ERR(NONE); } -jvmtiError MonitorUtil::RawMonitorNotify(jvmtiEnv* env ATTRIBUTE_UNUSED, jrawMonitorID id) { +jvmtiError MonitorUtil::RawMonitorNotify([[maybe_unused]] jvmtiEnv* env, jrawMonitorID id) { if (id == nullptr) { return ERR(INVALID_MONITOR); } @@ -337,7 +337,7 @@ jvmtiError MonitorUtil::RawMonitorNotify(jvmtiEnv* env ATTRIBUTE_UNUSED, jrawMon return ERR(NONE); } -jvmtiError MonitorUtil::RawMonitorNotifyAll(jvmtiEnv* env ATTRIBUTE_UNUSED, jrawMonitorID id) { +jvmtiError MonitorUtil::RawMonitorNotifyAll([[maybe_unused]] jvmtiEnv* env, jrawMonitorID id) { if (id == nullptr) { return ERR(INVALID_MONITOR); } @@ -352,7 +352,7 @@ jvmtiError MonitorUtil::RawMonitorNotifyAll(jvmtiEnv* env ATTRIBUTE_UNUSED, jraw return ERR(NONE); } -jvmtiError MonitorUtil::GetCurrentContendedMonitor(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError MonitorUtil::GetCurrentContendedMonitor([[maybe_unused]] jvmtiEnv* env, jthread thread, jobject* monitor) { if (monitor == nullptr) { diff --git a/openjdkjvmti/ti_object.cc b/openjdkjvmti/ti_object.cc index eb1140df4f..f37df86048 100644 --- a/openjdkjvmti/ti_object.cc +++ b/openjdkjvmti/ti_object.cc @@ -40,7 +40,7 @@ namespace openjdkjvmti { -jvmtiError ObjectUtil::GetObjectSize(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError ObjectUtil::GetObjectSize([[maybe_unused]] jvmtiEnv* env, jobject jobject, jlong* size_ptr) { if (jobject == nullptr) { @@ -57,7 +57,7 @@ jvmtiError ObjectUtil::GetObjectSize(jvmtiEnv* env ATTRIBUTE_UNUSED, return ERR(NONE); } -jvmtiError ObjectUtil::GetObjectHashCode(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError ObjectUtil::GetObjectHashCode([[maybe_unused]] jvmtiEnv* env, jobject jobject, jint* hash_code_ptr) { if (jobject == nullptr) { diff --git a/openjdkjvmti/ti_phase.cc b/openjdkjvmti/ti_phase.cc index 4fa97f10aa..89bf1aa384 100644 --- a/openjdkjvmti/ti_phase.cc +++ b/openjdkjvmti/ti_phase.cc @@ -97,7 +97,7 @@ struct PhaseUtil::PhaseCallback : public art::RuntimePhaseCallback { PhaseUtil::PhaseCallback gPhaseCallback; -jvmtiError PhaseUtil::GetPhase(jvmtiEnv* env ATTRIBUTE_UNUSED, jvmtiPhase* phase_ptr) { +jvmtiError PhaseUtil::GetPhase([[maybe_unused]] jvmtiEnv* env, jvmtiPhase* phase_ptr) { if (phase_ptr == nullptr) { return ERR(NULL_POINTER); } diff --git a/openjdkjvmti/ti_properties.cc b/openjdkjvmti/ti_properties.cc index 4fb3070e93..c6490c3193 100644 --- a/openjdkjvmti/ti_properties.cc +++ b/openjdkjvmti/ti_properties.cc @@ -226,9 +226,9 @@ jvmtiError PropertiesUtil::GetSystemProperty(jvmtiEnv* env, return ERR(NOT_AVAILABLE); } -jvmtiError PropertiesUtil::SetSystemProperty(jvmtiEnv* env ATTRIBUTE_UNUSED, - const char* property ATTRIBUTE_UNUSED, - const char* value ATTRIBUTE_UNUSED) { +jvmtiError PropertiesUtil::SetSystemProperty([[maybe_unused]] jvmtiEnv* env, + [[maybe_unused]] const char* property, + [[maybe_unused]] const char* value) { // We do not allow manipulation of any property here. return ERR(NOT_AVAILABLE); } diff --git a/openjdkjvmti/ti_redefine.cc b/openjdkjvmti/ti_redefine.cc index aafca47605..dfcbeb42e3 100644 --- a/openjdkjvmti/ti_redefine.cc +++ b/openjdkjvmti/ti_redefine.cc @@ -2372,9 +2372,9 @@ class ClassDefinitionPauser : public art::ClassLoadCallback { } } - void ClassLoad(art::Handle<art::mirror::Class> klass ATTRIBUTE_UNUSED) override {} - void ClassPrepare(art::Handle<art::mirror::Class> klass1 ATTRIBUTE_UNUSED, - art::Handle<art::mirror::Class> klass2 ATTRIBUTE_UNUSED) override {} + void ClassLoad([[maybe_unused]] art::Handle<art::mirror::Class> klass) override {} + void ClassPrepare([[maybe_unused]] art::Handle<art::mirror::Class> klass1, + [[maybe_unused]] art::Handle<art::mirror::Class> klass2) override {} void SetRunning() { is_running_ = true; diff --git a/openjdkjvmti/ti_stack.cc b/openjdkjvmti/ti_stack.cc index 8ee4adb853..9af8861260 100644 --- a/openjdkjvmti/ti_stack.cc +++ b/openjdkjvmti/ti_stack.cc @@ -716,7 +716,7 @@ struct GetFrameCountClosure : public art::Closure { size_t count; }; -jvmtiError StackUtil::GetFrameCount(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError StackUtil::GetFrameCount([[maybe_unused]] jvmtiEnv* env, jthread java_thread, jint* count_ptr) { // It is not great that we have to hold these locks for so long, but it is necessary to ensure @@ -784,7 +784,7 @@ struct GetLocationClosure : public art::Closure { uint32_t dex_pc; }; -jvmtiError StackUtil::GetFrameLocation(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError StackUtil::GetFrameLocation([[maybe_unused]] jvmtiEnv* env, jthread java_thread, jint depth, jmethodID* method_ptr, @@ -877,8 +877,8 @@ struct MonitorVisitor : public art::StackVisitor, public art::SingleRootVisitor visitor->stack_depths.push_back(visitor->current_stack_depth); } - void VisitRoot(art::mirror::Object* obj, const art::RootInfo& info ATTRIBUTE_UNUSED) - override REQUIRES_SHARED(art::Locks::mutator_lock_) { + void VisitRoot(art::mirror::Object* obj, [[maybe_unused]] const art::RootInfo& info) override + REQUIRES_SHARED(art::Locks::mutator_lock_) { for (const art::Handle<art::mirror::Object>& m : monitors) { if (m.Get() == obj) { return; @@ -1219,7 +1219,7 @@ class NonStandardExitFrames { template <> bool NonStandardExitFrames<NonStandardExitType::kForceReturn>::CheckFunctions( - jvmtiEnv* env, art::ArtMethod* calling ATTRIBUTE_UNUSED, art::ArtMethod* called) { + jvmtiEnv* env, [[maybe_unused]] art::ArtMethod* calling, art::ArtMethod* called) { if (UNLIKELY(called->IsNative())) { result_ = ERR(OPAQUE_FRAME); JVMTI_LOG(INFO, env) << "Cannot force early return from " << called->PrettyMethod() @@ -1297,7 +1297,7 @@ void AddDelayedMethodExitEvent(EventHandler* handler, art::ShadowFrame* frame, T template <> void AddDelayedMethodExitEvent<std::nullptr_t>(EventHandler* handler, art::ShadowFrame* frame, - std::nullptr_t null_val ATTRIBUTE_UNUSED) { + [[maybe_unused]] std::nullptr_t null_val) { jvalue jval; memset(&jval, 0, sizeof(jval)); handler->AddDelayedNonStandardExitEvent(frame, false, jval); @@ -1316,13 +1316,13 @@ bool ValidReturnType(art::Thread* self, art::ObjPtr<art::mirror::Class> return_t REQUIRES_SHARED(art::Locks::mutator_lock_) REQUIRES(art::Locks::user_code_suspension_lock_, art::Locks::thread_list_lock_); -#define SIMPLE_VALID_RETURN_TYPE(type, ...) \ - template <> \ - bool ValidReturnType<type>(art::Thread * self ATTRIBUTE_UNUSED, \ - art::ObjPtr<art::mirror::Class> return_type, \ - type value ATTRIBUTE_UNUSED) { \ - static constexpr std::initializer_list<art::Primitive::Type> types{ __VA_ARGS__ }; \ - return std::find(types.begin(), types.end(), return_type->GetPrimitiveType()) != types.end(); \ +#define SIMPLE_VALID_RETURN_TYPE(type, ...) \ + template <> \ + bool ValidReturnType<type>([[maybe_unused]] art::Thread * self, \ + art::ObjPtr<art::mirror::Class> return_type, \ + [[maybe_unused]] type value) { \ + static constexpr std::initializer_list<art::Primitive::Type> types{__VA_ARGS__}; \ + return std::find(types.begin(), types.end(), return_type->GetPrimitiveType()) != types.end(); \ } SIMPLE_VALID_RETURN_TYPE(jlong, art::Primitive::kPrimLong); diff --git a/openjdkjvmti/ti_thread.cc b/openjdkjvmti/ti_thread.cc index b5bc35e7e6..13eebbff04 100644 --- a/openjdkjvmti/ti_thread.cc +++ b/openjdkjvmti/ti_thread.cc @@ -205,7 +205,7 @@ void ThreadUtil::Unregister() { runtime->GetRuntimeCallbacks()->RemoveThreadLifecycleCallback(&gThreadCallback); } -jvmtiError ThreadUtil::GetCurrentThread(jvmtiEnv* env ATTRIBUTE_UNUSED, jthread* thread_ptr) { +jvmtiError ThreadUtil::GetCurrentThread([[maybe_unused]] jvmtiEnv* env, jthread* thread_ptr) { art::Thread* self = art::Thread::Current(); art::ScopedObjectAccess soa(self); @@ -564,7 +564,7 @@ bool ThreadUtil::WouldSuspendForUserCode(art::Thread* self) { return WouldSuspendForUserCodeLocked(self); } -jvmtiError ThreadUtil::GetThreadState(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError ThreadUtil::GetThreadState([[maybe_unused]] jvmtiEnv* env, jthread thread, jint* thread_state_ptr) { if (thread_state_ptr == nullptr) { @@ -940,7 +940,7 @@ jvmtiError ThreadUtil::SuspendSelf(art::Thread* self) { return OK; } -jvmtiError ThreadUtil::SuspendThread(jvmtiEnv* env ATTRIBUTE_UNUSED, jthread thread) { +jvmtiError ThreadUtil::SuspendThread([[maybe_unused]] jvmtiEnv* env, jthread thread) { art::Thread* self = art::Thread::Current(); bool target_is_self = false; { @@ -961,8 +961,7 @@ jvmtiError ThreadUtil::SuspendThread(jvmtiEnv* env ATTRIBUTE_UNUSED, jthread thr } } -jvmtiError ThreadUtil::ResumeThread(jvmtiEnv* env ATTRIBUTE_UNUSED, - jthread thread) { +jvmtiError ThreadUtil::ResumeThread([[maybe_unused]] jvmtiEnv* env, jthread thread) { if (thread == nullptr) { return ERR(NULL_POINTER); } @@ -1079,7 +1078,7 @@ jvmtiError ThreadUtil::ResumeThreadList(jvmtiEnv* env, return OK; } -jvmtiError ThreadUtil::StopThread(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError ThreadUtil::StopThread([[maybe_unused]] jvmtiEnv* env, jthread thread, jobject exception) { art::Thread* self = art::Thread::Current(); @@ -1128,7 +1127,7 @@ jvmtiError ThreadUtil::StopThread(jvmtiEnv* env ATTRIBUTE_UNUSED, } } -jvmtiError ThreadUtil::InterruptThread(jvmtiEnv* env ATTRIBUTE_UNUSED, jthread thread) { +jvmtiError ThreadUtil::InterruptThread([[maybe_unused]] jvmtiEnv* env, jthread thread) { art::Thread* self = art::Thread::Current(); art::ScopedObjectAccess soa(self); art::MutexLock tll_mu(self, *art::Locks::thread_list_lock_); diff --git a/openjdkjvmti/ti_timers.cc b/openjdkjvmti/ti_timers.cc index 11b58c452e..f02501fb1e 100644 --- a/openjdkjvmti/ti_timers.cc +++ b/openjdkjvmti/ti_timers.cc @@ -45,7 +45,7 @@ namespace openjdkjvmti { -jvmtiError TimerUtil::GetAvailableProcessors(jvmtiEnv* env ATTRIBUTE_UNUSED, +jvmtiError TimerUtil::GetAvailableProcessors([[maybe_unused]] jvmtiEnv* env, jint* processor_count_ptr) { if (processor_count_ptr == nullptr) { return ERR(NULL_POINTER); @@ -56,7 +56,7 @@ jvmtiError TimerUtil::GetAvailableProcessors(jvmtiEnv* env ATTRIBUTE_UNUSED, return ERR(NONE); } -jvmtiError TimerUtil::GetTimerInfo(jvmtiEnv* env ATTRIBUTE_UNUSED, jvmtiTimerInfo* info_ptr) { +jvmtiError TimerUtil::GetTimerInfo([[maybe_unused]] jvmtiEnv* env, jvmtiTimerInfo* info_ptr) { if (info_ptr == nullptr) { return ERR(NULL_POINTER); } @@ -69,7 +69,7 @@ jvmtiError TimerUtil::GetTimerInfo(jvmtiEnv* env ATTRIBUTE_UNUSED, jvmtiTimerInf return ERR(NONE); } -jvmtiError TimerUtil::GetTime(jvmtiEnv* env ATTRIBUTE_UNUSED, jlong* nanos_ptr) { +jvmtiError TimerUtil::GetTime([[maybe_unused]] jvmtiEnv* env, jlong* nanos_ptr) { if (nanos_ptr == nullptr) { return ERR(NULL_POINTER); } |