From 761774a120f4aa326da3c55a000dacc5549762e9 Mon Sep 17 00:00:00 2001
From: Serguei Spitsyn <sspitsyn@openjdk.org>
Date: Fri, 10 Jan 2025 23:49:03 +0000
Subject: [PATCH] 8346143: add ClearAllFramePops function to speedup debugger
 single stepping in some cases

Reviewed-by: cjplummer, amenkov
---
 src/hotspot/share/prims/jvmti.xml             |  33 +++-
 src/hotspot/share/prims/jvmtiEnv.cpp          |  29 ++-
 src/hotspot/share/prims/jvmtiEnvBase.cpp      |  25 ++-
 src/hotspot/share/prims/jvmtiEnvBase.hpp      |  17 +-
 .../share/prims/jvmtiEnvThreadState.cpp       |  31 ++-
 .../share/prims/jvmtiEnvThreadState.hpp       |   4 +-
 .../share/prims/jvmtiEventController.cpp      |  18 +-
 .../share/prims/jvmtiEventController.hpp      |   3 +-
 src/hotspot/share/prims/jvmtiExport.cpp       |   7 +-
 .../ClearAllFramePops/ClearAllFramePops.java  |  79 ++++++++
 .../libClearAllFramePops.cpp                  | 176 ++++++++++++++++++
 11 files changed, 386 insertions(+), 36 deletions(-)
 create mode 100644 test/hotspot/jtreg/serviceability/jvmti/events/FramePop/ClearAllFramePops/ClearAllFramePops.java
 create mode 100644 test/hotspot/jtreg/serviceability/jvmti/events/FramePop/ClearAllFramePops/libClearAllFramePops.cpp

diff --git a/src/hotspot/share/prims/jvmti.xml b/src/hotspot/share/prims/jvmti.xml
index b63dfdfedb1..4bff3230c9e 100644
--- a/src/hotspot/share/prims/jvmti.xml
+++ b/src/hotspot/share/prims/jvmti.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="ISO-8859-1"?>
 <?xml-stylesheet type="text/xsl" href="jvmti.xsl"?>
 <!--
- Copyright (c) 2002, 2024, Oracle and/or its affiliates. All rights reserved.
+ Copyright (c) 2002, 2025, Oracle and/or its affiliates. All rights reserved.
  DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 
  This code is free software; you can redistribute it and/or modify it
@@ -3090,6 +3090,34 @@ err = (*jvmti)-&gt;Deallocate(jvmti, stack_info);
       </errors>
     </function>
 
+    <function id="ClearAllFramePops" num="67" since="25">
+      <synopsis>Clear Frame Pop</synopsis>
+      <description>
+        Clear all frame pop requests so that a <eventlink id="FramePop"></eventlink>
+        event will not be generated for any frames.
+        See the <eventlink id="FramePop"></eventlink> event for details.
+        <p/>
+        The specified thread must be suspended or must be the current thread.
+      </description>
+      <origin>new</origin>
+      <capabilities>
+        <required id="can_generate_frame_pop_events"></required>
+      </capabilities>
+      <parameters>
+        <param id="thread">
+          <jthread null="current" impl="noconvert"/>
+          <description>
+            The thread for which all the frame pop events will be cleared.
+          </description>
+        </param>
+      </parameters>
+      <errors>
+        <error id="JVMTI_ERROR_THREAD_NOT_SUSPENDED">
+          Thread was not suspended and was not the current thread.
+        </error>
+      </errors>
+    </function>
+
   </category>
 
   <category id="ForceEarlyReturn" label="Force Early Return">
@@ -15481,6 +15509,9 @@ typedef void (JNICALL *jvmtiEventVMInit)
       Virtual threads finalized to be a permanent feature.
       Agent start-up in the live phase now specified to print a warning.
   </change>
+  <change date="10 January 2025" version="25.0.0">
+      Add new function ClearAllFramePops. Needed to speedup debugger single stepping.
+  </change>
 </changehistory>
 
 </specification>
diff --git a/src/hotspot/share/prims/jvmtiEnv.cpp b/src/hotspot/share/prims/jvmtiEnv.cpp
index e97bfc30042..f3c645a0831 100644
--- a/src/hotspot/share/prims/jvmtiEnv.cpp
+++ b/src/hotspot/share/prims/jvmtiEnv.cpp
@@ -1804,12 +1804,39 @@ JvmtiEnv::NotifyFramePop(jthread thread, jint depth) {
     return JVMTI_ERROR_THREAD_NOT_ALIVE;
   }
 
-  SetFramePopClosure op(this, state, depth);
+  SetOrClearFramePopClosure op(this, state, true /* set */, depth);
   MutexLocker mu(current, JvmtiThreadState_lock);
   JvmtiHandshake::execute(&op, &tlh, java_thread, thread_handle);
   return op.result();
 } /* end NotifyFramePop */
 
+// Threads_lock NOT held, java_thread not protected by lock
+jvmtiError
+JvmtiEnv::ClearAllFramePops(jthread thread) {
+  ResourceMark rm;
+  JvmtiVTMSTransitionDisabler disabler(thread);
+  JavaThread* current = JavaThread::current();
+  ThreadsListHandle tlh(current);
+
+  JavaThread* java_thread = nullptr;
+  oop thread_obj = nullptr;
+  jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current, &java_thread, &thread_obj);
+  if (err != JVMTI_ERROR_NONE) {
+    return err;
+  }
+
+  HandleMark hm(current);
+  Handle thread_handle(current, thread_obj);
+  JvmtiThreadState *state = JvmtiThreadState::state_for(java_thread, thread_handle);
+  if (state == nullptr) {
+    return JVMTI_ERROR_THREAD_NOT_ALIVE;
+  }
+
+  SetOrClearFramePopClosure op(this, state, false /* clear all frame pops*/);
+  MutexLocker mu(current, JvmtiThreadState_lock);
+  JvmtiHandshake::execute(&op, &tlh, java_thread, thread_handle);
+  return op.result();
+} /* end ClearAllFramePops */
 
   //
   // Force Early Return functions
diff --git a/src/hotspot/share/prims/jvmtiEnvBase.cpp b/src/hotspot/share/prims/jvmtiEnvBase.cpp
index ec269e60e1b..4305549e1b4 100644
--- a/src/hotspot/share/prims/jvmtiEnvBase.cpp
+++ b/src/hotspot/share/prims/jvmtiEnvBase.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -1367,6 +1367,13 @@ JvmtiEnvBase::set_frame_pop(JvmtiThreadState* state, javaVFrame* jvf, jint depth
   return JVMTI_ERROR_NONE;
 }
 
+jvmtiError
+JvmtiEnvBase::clear_all_frame_pops(JvmtiThreadState* state) {
+  JvmtiEnvThreadState* ets = state->env_thread_state(this);
+  ets->clear_all_frame_pops();
+  return JVMTI_ERROR_NONE;
+}
+
 bool
 JvmtiEnvBase::is_cthread_with_mounted_vthread(JavaThread* jt) {
   oop thread_oop = jt->threadObj();
@@ -2482,7 +2489,7 @@ UpdateForPopTopFrameClosure::doit(Thread *target) {
 }
 
 void
-SetFramePopClosure::do_thread(Thread *target) {
+SetOrClearFramePopClosure::do_thread(Thread *target) {
   Thread* current = Thread::current();
   ResourceMark rm(current); // vframes are resource allocated
   JavaThread* java_thread = JavaThread::cast(target);
@@ -2495,6 +2502,10 @@ SetFramePopClosure::do_thread(Thread *target) {
     _result = JVMTI_ERROR_THREAD_NOT_SUSPENDED;
     return;
   }
+  if (!_set) { // ClearAllFramePops
+    _result = _env->clear_all_frame_pops(_state);
+    return;
+  }
   if (!java_thread->has_last_Java_frame()) {
     _result = JVMTI_ERROR_NO_MORE_FRAMES;
     return;
@@ -2506,11 +2517,11 @@ SetFramePopClosure::do_thread(Thread *target) {
                       RegisterMap::ProcessFrames::skip,
                       RegisterMap::WalkContinuation::include);
   javaVFrame* jvf = JvmtiEnvBase::get_cthread_last_java_vframe(java_thread, &reg_map);
-  _result = ((JvmtiEnvBase*)_env)->set_frame_pop(_state, jvf, _depth);
+  _result = _env->set_frame_pop(_state, jvf, _depth);
 }
 
 void
-SetFramePopClosure::do_vthread(Handle target_h) {
+SetOrClearFramePopClosure::do_vthread(Handle target_h) {
   Thread* current = Thread::current();
   ResourceMark rm(current); // vframes are resource allocated
 
@@ -2518,8 +2529,12 @@ SetFramePopClosure::do_vthread(Handle target_h) {
     _result = JVMTI_ERROR_THREAD_NOT_SUSPENDED;
     return;
   }
+  if (!_set) { // ClearAllFramePops
+    _result = _env->clear_all_frame_pops(_state);
+    return;
+  }
   javaVFrame *jvf = JvmtiEnvBase::get_vthread_jvf(target_h());
-  _result = ((JvmtiEnvBase*)_env)->set_frame_pop(_state, jvf, _depth);
+  _result = _env->set_frame_pop(_state, jvf, _depth);
 }
 
 void
diff --git a/src/hotspot/share/prims/jvmtiEnvBase.hpp b/src/hotspot/share/prims/jvmtiEnvBase.hpp
index 217731cd8f0..ec4423e4a1c 100644
--- a/src/hotspot/share/prims/jvmtiEnvBase.hpp
+++ b/src/hotspot/share/prims/jvmtiEnvBase.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -410,6 +410,7 @@ class JvmtiEnvBase : public CHeapObj<mtInternal> {
   jvmtiError get_frame_location(oop vthread_oop, jint depth,
                                 jmethodID* method_ptr, jlocation* location_ptr);
   jvmtiError set_frame_pop(JvmtiThreadState* state, javaVFrame* jvf, jint depth);
+  jvmtiError clear_all_frame_pops(JvmtiThreadState* state);
   jvmtiError get_object_monitor_usage(JavaThread* calling_thread,
                                       jobject object, jvmtiMonitorUsage* info_ptr);
   jvmtiError get_stack_trace(javaVFrame* jvf,
@@ -534,17 +535,19 @@ class UpdateForPopTopFrameClosure : public JvmtiUnitedHandshakeClosure {
 };
 
 // HandshakeClosure to set frame pop.
-class SetFramePopClosure : public JvmtiUnitedHandshakeClosure {
+class SetOrClearFramePopClosure : public JvmtiUnitedHandshakeClosure {
 private:
-  JvmtiEnv *_env;
+  JvmtiEnvBase *_env;
   JvmtiThreadState* _state;
-  jint _depth;
+  bool _set;
+  jint _depth; // used for NotiftyFramePop only
 
 public:
-  SetFramePopClosure(JvmtiEnv *env, JvmtiThreadState* state, jint depth)
-    : JvmtiUnitedHandshakeClosure("SetFramePopClosure"),
-      _env(env),
+  SetOrClearFramePopClosure(JvmtiEnv *env, JvmtiThreadState* state, bool set, jint depth = 0)
+    : JvmtiUnitedHandshakeClosure("SetOrClearFramePopClosure"),
+      _env((JvmtiEnvBase*)env),
       _state(state),
+      _set(set),
       _depth(depth) {}
   void do_thread(Thread *target);
   void do_vthread(Handle target_h);
diff --git a/src/hotspot/share/prims/jvmtiEnvThreadState.cpp b/src/hotspot/share/prims/jvmtiEnvThreadState.cpp
index b531961e7a5..57eb23b8f93 100644
--- a/src/hotspot/share/prims/jvmtiEnvThreadState.cpp
+++ b/src/hotspot/share/prims/jvmtiEnvThreadState.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -71,6 +71,10 @@ JvmtiFramePops::clear(JvmtiFramePop& fp) {
   _pops->remove(fp.frame_number());
 }
 
+void
+JvmtiFramePops::clear_all() {
+  _pops->clear();
+}
 
 int
 JvmtiFramePops::clear_to(JvmtiFramePop& fp) {
@@ -212,10 +216,7 @@ void JvmtiEnvThreadState::compare_and_set_current_location(Method* new_method,
 
 
 JvmtiFramePops* JvmtiEnvThreadState::get_frame_pops() {
-#ifdef ASSERT
-  Thread *current = Thread::current();
-#endif
-  assert(get_thread() == nullptr || get_thread()->is_handshake_safe_for(current),
+  assert(get_thread() == nullptr || get_thread()->is_handshake_safe_for(Thread::current()),
          "frame pop data only accessible from same or detached thread or direct handshake");
   if (_frame_pops == nullptr) {
     _frame_pops = new JvmtiFramePops();
@@ -230,10 +231,7 @@ bool JvmtiEnvThreadState::has_frame_pops() {
 }
 
 void JvmtiEnvThreadState::set_frame_pop(int frame_number) {
-#ifdef ASSERT
-  Thread *current = Thread::current();
-#endif
-  assert(get_thread() == nullptr || get_thread()->is_handshake_safe_for(current),
+  assert(get_thread() == nullptr || get_thread()->is_handshake_safe_for(Thread::current()),
          "frame pop data only accessible from same or detached thread or direct handshake");
   JvmtiFramePop fpop(frame_number);
   JvmtiEventController::set_frame_pop(this, fpop);
@@ -241,21 +239,20 @@ void JvmtiEnvThreadState::set_frame_pop(int frame_number) {
 
 
 void JvmtiEnvThreadState::clear_frame_pop(int frame_number) {
-#ifdef ASSERT
-  Thread *current = Thread::current();
-#endif
-  assert(get_thread() == nullptr || get_thread()->is_handshake_safe_for(current),
+  assert(get_thread() == nullptr || get_thread()->is_handshake_safe_for(Thread::current()),
          "frame pop data only accessible from same or detached thread or direct handshake");
   JvmtiFramePop fpop(frame_number);
   JvmtiEventController::clear_frame_pop(this, fpop);
 }
 
+void JvmtiEnvThreadState::clear_all_frame_pops() {
+  assert(get_thread() == nullptr || get_thread()->is_handshake_safe_for(Thread::current()),
+         "frame pop data only accessible from same or detached thread or direct handshake");
+  JvmtiEventController::clear_all_frame_pops(this);
+}
 
 bool JvmtiEnvThreadState::is_frame_pop(int cur_frame_number) {
-#ifdef ASSERT
-  Thread *current = Thread::current();
-#endif
-  assert(get_thread() == nullptr || get_thread()->is_handshake_safe_for(current),
+  assert(get_thread() == nullptr || get_thread()->is_handshake_safe_for(Thread::current()),
          "frame pop data only accessible from same or detached thread or direct handshake");
   if (!jvmti_thread_state()->is_interp_only_mode() || _frame_pops == nullptr) {
     return false;
diff --git a/src/hotspot/share/prims/jvmtiEnvThreadState.hpp b/src/hotspot/share/prims/jvmtiEnvThreadState.hpp
index 544d4eff5f1..a2ab25a59dd 100644
--- a/src/hotspot/share/prims/jvmtiEnvThreadState.hpp
+++ b/src/hotspot/share/prims/jvmtiEnvThreadState.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -86,6 +86,7 @@ class JvmtiFramePops : public CHeapObj<mtInternal> {
   friend class JvmtiEventControllerPrivate;
   void set(JvmtiFramePop& fp);
   void clear(JvmtiFramePop& fp);
+  void clear_all();
   int clear_to(JvmtiFramePop& fp);
 
  public:
@@ -184,6 +185,7 @@ class JvmtiEnvThreadState : public CHeapObj<mtInternal> {
 
   void set_frame_pop(int frame_number);
   void clear_frame_pop(int frame_number);
+  void clear_all_frame_pops();
 
 };
 
diff --git a/src/hotspot/share/prims/jvmtiEventController.cpp b/src/hotspot/share/prims/jvmtiEventController.cpp
index 32d691a5793..93d4eece2a1 100644
--- a/src/hotspot/share/prims/jvmtiEventController.cpp
+++ b/src/hotspot/share/prims/jvmtiEventController.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -312,6 +312,7 @@ class JvmtiEventControllerPrivate : public AllStatic {
 
   static void set_frame_pop(JvmtiEnvThreadState *env_thread, JvmtiFramePop fpop);
   static void clear_frame_pop(JvmtiEnvThreadState *env_thread, JvmtiFramePop fpop);
+  static void clear_all_frame_pops(JvmtiEnvThreadState *env_thread);
   static void clear_to_frame_pop(JvmtiEnvThreadState *env_thread, JvmtiFramePop fpop);
   static void change_field_watch(jvmtiEvent event_type, bool added);
 
@@ -946,6 +947,15 @@ JvmtiEventControllerPrivate::clear_frame_pop(JvmtiEnvThreadState *ets, JvmtiFram
   recompute_thread_enabled(ets->jvmti_thread_state());
 }
 
+void
+JvmtiEventControllerPrivate::clear_all_frame_pops(JvmtiEnvThreadState *ets) {
+  EC_TRACE(("[%s] # clear all frame pops",
+            JvmtiTrace::safe_get_thread_name(ets->get_thread_or_saved())
+          ));
+
+  ets->get_frame_pops()->clear_all();
+  recompute_thread_enabled(ets->jvmti_thread_state());
+}
 
 void
 JvmtiEventControllerPrivate::clear_to_frame_pop(JvmtiEnvThreadState *ets, JvmtiFramePop fpop) {
@@ -1125,6 +1135,12 @@ JvmtiEventController::clear_frame_pop(JvmtiEnvThreadState *ets, JvmtiFramePop fp
   JvmtiEventControllerPrivate::clear_frame_pop(ets, fpop);
 }
 
+void
+JvmtiEventController::clear_all_frame_pops(JvmtiEnvThreadState *ets) {
+  assert(JvmtiThreadState_lock->is_locked(), "Must be locked.");
+  JvmtiEventControllerPrivate::clear_all_frame_pops(ets);
+}
+
 void
 JvmtiEventController::change_field_watch(jvmtiEvent event_type, bool added) {
   MutexLocker mu(JvmtiThreadState_lock);
diff --git a/src/hotspot/share/prims/jvmtiEventController.hpp b/src/hotspot/share/prims/jvmtiEventController.hpp
index cdd75a2ec56..3949f3a7b7d 100644
--- a/src/hotspot/share/prims/jvmtiEventController.hpp
+++ b/src/hotspot/share/prims/jvmtiEventController.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -231,6 +231,7 @@ class JvmtiEventController : AllStatic {
   static void enter_interp_only_mode(JvmtiThreadState* state);
   static void set_frame_pop(JvmtiEnvThreadState *env_thread, JvmtiFramePop fpop);
   static void clear_frame_pop(JvmtiEnvThreadState *env_thread, JvmtiFramePop fpop);
+  static void clear_all_frame_pops(JvmtiEnvThreadState *env_thread);
 
   static void change_field_watch(jvmtiEvent event_type, bool added);
 
diff --git a/src/hotspot/share/prims/jvmtiExport.cpp b/src/hotspot/share/prims/jvmtiExport.cpp
index c68692a2fa1..cf14d40e513 100644
--- a/src/hotspot/share/prims/jvmtiExport.cpp
+++ b/src/hotspot/share/prims/jvmtiExport.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -1969,7 +1969,10 @@ void JvmtiExport::post_method_exit_inner(JavaThread* thread,
         // remove the frame's entry
         {
           MutexLocker mu(JvmtiThreadState_lock);
-          ets->clear_frame_pop(cur_frame_number);
+          // Need to recheck the condition as the JVMTI ClearAllFramePops can do its work at a safepoint.
+          if (ets->is_frame_pop(cur_frame_number)) {
+            ets->clear_frame_pop(cur_frame_number);
+          }
         }
       }
     }
diff --git a/test/hotspot/jtreg/serviceability/jvmti/events/FramePop/ClearAllFramePops/ClearAllFramePops.java b/test/hotspot/jtreg/serviceability/jvmti/events/FramePop/ClearAllFramePops/ClearAllFramePops.java
new file mode 100644
index 00000000000..7c92b734a55
--- /dev/null
+++ b/test/hotspot/jtreg/serviceability/jvmti/events/FramePop/ClearAllFramePops/ClearAllFramePops.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test id=platform
+ * @summary Verifies JVMTI ClearAllFramePops clears all FramePop requests
+ * @library /test/lib
+ * @run main/othervm/native -agentlib:ClearAllFramePops ClearAllFramePops platform
+ */
+/*
+ * @test id=virtual
+ * @summary Verifies JVMTI ClearAllFramePops clears all FramePop requests
+ * @library /test/lib
+ * @run main/othervm/native -agentlib:ClearAllFramePops ClearAllFramePops virtual
+ */
+
+public class ClearAllFramePops {
+
+    final static int MAX_THREADS_LIMIT = 10;
+    final static int NESTING_DEPTH = 5;
+    final static String TEST_THREAD_NAME_BASE = "Test Thread #";
+
+    native static void clearAllFramePops();
+    native static void getReady();
+    native static void check();
+
+    public static void main(String args[]) {
+        boolean isVirtual = args.length > 0 && args[0].equals("virtual");
+        final int THREADS_LIMIT = Math.min(Runtime.getRuntime().availableProcessors() + 1, MAX_THREADS_LIMIT);
+        Thread[] t = new Thread[THREADS_LIMIT];
+        getReady();
+        Thread.Builder builder = (isVirtual ? Thread.ofVirtual() : Thread.ofPlatform())
+                .name(TEST_THREAD_NAME_BASE, 0);
+        for (int i = 0; i < THREADS_LIMIT; i++) {
+            t[i] = builder.start(new TestTask());
+        }
+        for (int i = 0; i < THREADS_LIMIT; i++) {
+            try {
+                t[i].join();
+            } catch (InterruptedException e) {
+                throw new Error("Unexpected: " + e);
+            }
+        }
+        check();
+    }
+
+    static class TestTask implements Runnable {
+        int nestingCount = 0;
+
+        public void run() {
+            if (nestingCount < NESTING_DEPTH) {
+                nestingCount++;
+                run();
+            } else {
+                clearAllFramePops();
+            }
+        }
+    }
+}
diff --git a/test/hotspot/jtreg/serviceability/jvmti/events/FramePop/ClearAllFramePops/libClearAllFramePops.cpp b/test/hotspot/jtreg/serviceability/jvmti/events/FramePop/ClearAllFramePops/libClearAllFramePops.cpp
new file mode 100644
index 00000000000..a65bf88e778
--- /dev/null
+++ b/test/hotspot/jtreg/serviceability/jvmti/events/FramePop/ClearAllFramePops/libClearAllFramePops.cpp
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "jvmti.h"
+#include "jvmti_common.hpp"
+
+
+extern "C" {
+
+static jvmtiEnv *jvmti;
+static jvmtiEventCallbacks callbacks;
+static jrawMonitorID event_lock;
+static jboolean watch_events = JNI_FALSE;
+static int pop_count;
+static const char* TEST_THREAD_NAME_BASE = "Test Thread";
+static const char* TEST_CLASS_SIG = "LClearAllFramePops$TestTask;";
+
+static
+bool isTestThread(JNIEnv *jni, jvmtiEnv *jvmti, jthread thr) {
+  char* tname = get_thread_name(jvmti, jni, thr);
+  bool result = strncmp(tname, TEST_THREAD_NAME_BASE, strlen(TEST_THREAD_NAME_BASE)) == 0;
+  deallocate(jvmti, jni, tname);
+
+  return result;
+}
+
+static
+void printInfo(JNIEnv *jni, jvmtiEnv *jvmti, jthread thr, jmethodID method, int depth) {
+  jclass cls;
+  char *mname, *msig, *csig;
+  char* tname = get_thread_name(jvmti, jni, thr);
+
+  check_jvmti_status(jni, jvmti->GetMethodDeclaringClass(method, &cls), "Error in GetMethodDeclaringClass.");
+  check_jvmti_status(jni, jvmti->GetClassSignature(cls, &csig, nullptr), "Error in GetClassSignature.");
+  check_jvmti_status(jni, jvmti->GetMethodName(method, &mname, &msig, nullptr), "Error in GetMethodName.");
+
+  LOG(" %s: %s.%s%s, depth = %d\n", tname, csig, mname, msig, depth);
+
+  deallocate(jvmti, jni, tname);
+  deallocate(jvmti, jni, mname);
+  deallocate(jvmti, jni, msig);
+  deallocate(jvmti, jni, csig);
+}
+
+void JNICALL MethodEntry(jvmtiEnv *jvmti, JNIEnv *jni,
+                         jthread thr, jmethodID method) {
+  RawMonitorLocker rml(jvmti, jni, event_lock);
+
+  if (watch_events == JNI_FALSE) {
+    return;
+  }
+  if (!isTestThread(jni, jvmti, thr)) {
+    return; // not a tested thread
+  }
+  jclass cls;
+  char *csig;
+
+  check_jvmti_status(jni, jvmti->GetMethodDeclaringClass(method, &cls), "Error in GetMethodDeclaringClass.");
+  check_jvmti_status(jni, jvmti->GetClassSignature(cls, &csig, nullptr), "Error in GetClassSignature.");
+
+  if (strcmp(csig, TEST_CLASS_SIG) != 0 ||
+      strcmp(get_method_name(jvmti, jni, method), "run") != 0) {
+    return; // not a tested method
+  }
+  LOG("\n>>>Method entry event:");
+  printInfo(jni, jvmti, thr, method, get_frame_count(jvmti, jni, thr));
+
+  check_jvmti_status(jni, jvmti->NotifyFramePop(thr, 0), "Error in NotifyFramePop.");
+  deallocate(jvmti, jni, csig);
+}
+
+void JNICALL FramePop(jvmtiEnv *jvmti, JNIEnv *jni,
+                      jthread thr, jmethodID method, jboolean wasPopedByException) {
+  RawMonitorLocker rml(jvmti, jni, event_lock);
+
+  jint frameCount = get_frame_count(jvmti, jni, thr);
+
+  LOG("\n>>> Frame Pop event:");
+  printInfo(jni, jvmti, thr, method, frameCount);
+  pop_count++;
+}
+
+JNIEXPORT jint JNICALL
+Agent_OnLoad(JavaVM *jvm, char *options, void *reserved) {
+  jvmtiCapabilities caps;
+  jvmtiError err;
+
+  jint res = jvm->GetEnv((void **) &jvmti, JVMTI_VERSION_1_1);
+  if (res != JNI_OK || jvmti == nullptr) {
+    LOG("Failed: Wrong result of a valid call to GetEnv!\n");
+    return JNI_ERR;
+  }
+  event_lock = create_raw_monitor(jvmti, "_event_lock");
+
+  memset(&caps, 0, sizeof(jvmtiCapabilities));
+  caps.can_generate_frame_pop_events = 1;
+  caps.can_generate_method_entry_events = 1;
+  caps.can_support_virtual_threads = 1;
+
+  callbacks.MethodEntry = &MethodEntry;
+  callbacks.FramePop = &FramePop;
+
+  err = jvmti->AddCapabilities(&caps);
+  if (err != JVMTI_ERROR_NONE) {
+    LOG("(AddCapabilities) unexpected error: %s (%d)\n", TranslateError(err), err);
+    return JNI_ERR;
+  }
+  err = jvmti->SetEventCallbacks(&callbacks, sizeof(callbacks));
+  if (err != JVMTI_ERROR_NONE) {
+    LOG("(SetEventCallbacks) unexpected error: %s (%d)\n", TranslateError(err), err);
+    return JNI_ERR;
+  }
+  err = set_event_notification_mode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_VM_DEATH, nullptr);
+  if (err != JVMTI_ERROR_NONE) {
+    return JNI_ERR;
+  }
+  return JNI_OK;
+}
+
+JNIEXPORT void JNICALL Java_ClearAllFramePops_clearAllFramePops(JNIEnv *jni, jclass cls) {
+  RawMonitorLocker rml(jvmti, jni, event_lock);
+
+  char* tname = get_thread_name(jvmti, jni, nullptr);
+
+  check_jvmti_status(jni, jvmti->ClearAllFramePops(nullptr), "Error in ClearAllFramePops");
+  LOG("Called ClearAllFramePops for thread: %s\n", tname);
+
+  deallocate(jvmti, jni, tname);
+}
+
+JNIEXPORT void JNICALL Java_ClearAllFramePops_getReady(JNIEnv *jni, jclass cls) {
+  RawMonitorLocker rml(jvmti, jni, event_lock);
+
+  watch_events = JNI_TRUE;
+  set_event_notification_mode(jvmti, jni, JVMTI_ENABLE, JVMTI_EVENT_METHOD_ENTRY, nullptr);
+  set_event_notification_mode(jvmti, jni, JVMTI_ENABLE, JVMTI_EVENT_FRAME_POP, nullptr);
+}
+
+JNIEXPORT void JNICALL Java_ClearAllFramePops_check(JNIEnv *jni, jclass cls) {
+  RawMonitorLocker rml(jvmti, jni, event_lock);
+
+  watch_events = JNI_FALSE;
+  set_event_notification_mode(jvmti, jni, JVMTI_DISABLE, JVMTI_EVENT_METHOD_ENTRY, nullptr);
+  set_event_notification_mode(jvmti, jni, JVMTI_DISABLE, JVMTI_EVENT_FRAME_POP, nullptr);
+  LOG("\n>>> Total frame pops: %d\n", pop_count);
+
+  if (pop_count > 0) {
+    fatal(jni, "Failed: FramePop events are not expected");
+  }
+}
+
+}