fix(walkvm): detect Path A via cont_entry_return_pc exact-PC match

- Replace heuristic type_size()==0 && hasActiveContinuation() check with
  isContEntryReturnPc(pc) exact-PC match before nmethod dispatch
- Add isContEntryReturnPc() to VMStructs mirroring isContReturnBarrier()
- Remove hasActiveContinuation() from VMThread (no longer needed)
- Update enterSpecial comment: RuntimeBlob on JDK 21-26, nmethod on JDK 27+
- Add assertFalse(vt.isAlive()) timeout guard to blocking VT test

The old condition fired only when ContinuationEntry was absent from vmStructs
(musl/minimal JDK 21-26 builds). On JDK 21-26 glibc, ContinuationEntry IS in
vmStructs so type_size()!=0, but enterSpecial is still a RuntimeBlob whose
findNMethod() returns NULL. Path A was silently skipped, showing truncated
traces instead of carrier frames.

This commit made by [/dd:git:commit:atomic](https://github.com/DataDog/claude-marketplace/tree/main/dd/commands/git/commit/atomic.md)

Author: jbachorik

ddprof-lib/src/main/cpp/hotspot/vmStructs.cpp

@@ -475,11 +475,10 @@ void VMStructs::resolveOffsets() {
         _interpreter_nm = CodeHeap::findNMethod(_interpreter_start);
     }
     if (_enter_special_nm == NULL && _cont_entry_return_pc != NULL) {
-        // enterSpecial is a generated nmethod. If findNMethod returns NULL the
-        // CodeHeap may not yet contain it at VM-ready time; Path A (enterSpecial
-        // detection) will silently not trigger for those samples, which is safe —
-        // the stack will simply be truncated at the continuation boundary rather
-        // than showing carrier frames.
+        // On JDK 27+, enterSpecial is a proper nmethod; findNMethod succeeds.
+        // On JDK 21-26, it is a RuntimeBlob; findNMethod returns NULL and
+        // _enter_special_nm stays NULL.  Path A is then detected via
+        // isContEntryReturnPc() in the walk loop rather than nmethod identity.
         _enter_special_nm = CodeHeap::findNMethod(_cont_entry_return_pc);
     }
 }

ddprof-lib/src/main/cpp/hotspot/vmStructs.h

@@ -475,9 +475,11 @@ class VMStructs {
         return _cont_return_barrier != nullptr && pc == _cont_return_barrier;
     }
 
-    // Returns true if cont_returnBarrier was successfully resolved (JDK 21+).
-    static bool hasContReturnBarrier() {
-        return _cont_return_barrier != nullptr;
+    // Path A: bottom VT frame's return address when the continuation is fully
+    // thawed (CPU-bound or fully resumed).  Mirrors isContReturnBarrier (Path B).
+    // Available on JDK 21+ via vmStructs or symbol fallback.
+    static bool isContEntryReturnPc(const void* pc) {
+        return _cont_entry_return_pc != nullptr && pc == _cont_entry_return_pc;
     }
 
     static VMNMethod* enterSpecialNMethod() {
@@ -860,14 +862,6 @@ DECLARE(VMThread)
         return ptr != nullptr ? VMContinuationEntry::cast(ptr) : nullptr;
     }
 
-    // Returns true if a continuation (virtual thread) is currently mounted on
-    // this carrier thread, without requiring VMContinuationEntry::type_size() > 0.
-    // Used on JDK 21-26 where type_size() == 0 but _cont_entry_offset is valid.
-    bool hasActiveContinuation() {
-        if (_cont_entry_offset < 0) return false;
-        return SafeAccess::loadPtr((void**) at(_cont_entry_offset), nullptr) != nullptr;
-    }
-
     inline VMMethod* compiledMethod();
 private:
     static inline int nativeThreadId(JNIEnv* jni, jthread thread);

ddprof-lib/src/main/cpp/stackWalker.cpp

@@ -381,7 +381,10 @@ __attribute__((no_sanitize("address"))) int StackWalker::walkVM(void* ucontext,
         uintptr_t entry_fp;
 
         if (VMContinuationEntry::type_size() > 0) {
-            // JDK 27+: full ContinuationEntry support via vmStructs.
+            // ContinuationEntry is known via vmStructs (JDK 27+, and JDK 21-26
+            // on distros that expose it).  Walk the linked list of entries for
+            // nested-continuation support and derive the enterSpecial frame FP
+            // from the struct layout (entry + type_size).
             cont_entry = (cont_entry != nullptr) ? cont_entry->parent() : vm_thread->contEntry();
             if (cont_entry == nullptr) {
                 Counters::increment(WALKVM_CONT_ENTRY_NULL);
@@ -390,12 +393,11 @@ __attribute__((no_sanitize("address"))) int StackWalker::walkVM(void* ucontext,
             }
             entry_fp = cont_entry->entryFP();
         } else {
-            // JDK 21-26: ContinuationEntry type size absent from vmStructs.
-            // Derive the enterSpecial frame FP directly from the current fp:
-            //   Path A (nm == enterSpecial): fp IS the enterSpecial frame
-            //   Path B (pc == cont_returnBarrier): the saved caller FP at *fp
-            //   is the enterSpecial frame (the VT's bottom frame's FP chain
-            //   leads directly to the enterSpecial frame on the carrier stack).
+            // ContinuationEntry absent from vmStructs (musl/minimal JDK 21-26).
+            // Derive the enterSpecial frame FP from the current fp:
+            //   Path A (pc == cont_entry_return_pc): fp IS the enterSpecial frame
+            //   Path B (pc == cont_returnBarrier):   the saved caller FP at *fp
+            //   leads to the enterSpecial frame on the carrier stack.
             // Nested continuation tracking is unavailable without type_size().
             entry_fp = path_a ? fp : (uintptr_t)SafeAccess::load((void**)fp);
         }
@@ -453,35 +455,26 @@ __attribute__((no_sanitize("address"))) int StackWalker::walkVM(void* ucontext,
             }
             prev_native_pc = NULL; // we are in JVM code, no previous 'native' PC
 
-            // cont_returnBarrier is a JVM stub — CodeHeap::findNMethod() returns NULL for it,
-            // so it must be handled before the nmethod dispatch below.
+            // Both continuation boundary PCs are JVM stubs whose findNMethod()
+            // returns NULL; detect them by exact-PC match before the nmethod
+            // dispatch below.
+            // Path B: bottom thawed frame returns to cont_returnBarrier when
+            //         frozen frames remain in the StackChunk (blocking VT).
+            // Path A: bottom thawed frame returns to cont_entry_return_pc when
+            //         the continuation is fully thawed (CPU-bound VT).
             if (!CONT_UNWIND_DISABLED && VMStructs::isContReturnBarrier(pc)) {
                 Counters::increment(WALKVM_CONT_BARRIER_HIT);
                 if (walkThroughContinuation(false)) continue;
                 break;
             }
+            if (!CONT_UNWIND_DISABLED && VMStructs::isContEntryReturnPc(pc)) {
+                Counters::increment(WALKVM_ENTER_SPECIAL_HIT);
+                if (walkThroughContinuation(true)) continue;
+                break;
+            }
 
             VMNMethod* nm = CodeHeap::findNMethod(pc);
             if (nm == NULL) {
-                // On JDK 21-26, enterSpecial is a RuntimeBlob rather than an
-                // nmethod, so findNMethod() returns NULL even though pc is in
-                // the CodeHeap.  When a continuation is active and the
-                // cont_returnBarrier is known (JDK 21+), treat this as Path A:
-                // the previous frame's fp already points to the enterSpecial
-                // frame, so fp-based carrier-frame unwind is valid.
-                if (VMContinuationEntry::type_size() == 0
-                        && VMStructs::hasContReturnBarrier()
-                        && vm_thread != NULL && vm_thread->hasActiveContinuation()) {
-                    if (!CONT_UNWIND_DISABLED) {
-                        Counters::increment(WALKVM_ENTER_SPECIAL_HIT);
-                        if (walkThroughContinuation(true)) continue;
-                    } else {
-                        // Continuation detected but unwind is disabled; emit
-                        // the synthetic boundary frame and stop cleanly.
-                        fillFrame(frames[depth++], BCI_NATIVE_FRAME, CONT_ROOT_FRAME);
-                    }
-                    break;
-                }
                 if (anchor == NULL) {
                     // Add an error frame only if we cannot recover
                     fillFrame(frames[depth++], BCI_ERROR, "unknown_nmethod");

ddprof-test/src/test/java/com/datadoghq/profiler/wallclock/VirtualThreadWallClockTest.java

@@ -16,6 +16,7 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.locks.LockSupport;
 
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
@@ -170,6 +171,7 @@ public void samplesCarrierFramesFromBlockingVT(@CStack String cstack) throws Exc
             LockSupport.unpark(vt);
         }
         vt.join(15_000);
+        assertFalse(vt.isAlive(), "Virtual thread did not complete within timeout");
         stopProfiler();
 
         verifyCStackSettings();