feat(walkvm): wextend=vt_carrier opt-in for carrier frame walking

- Add wextend argument (string-parsed, comma-separated tokens)
- vt_carrier token enables walking through VT continuation boundaries
  to carrier thread frames; default stops at synthetic "JVM Continuation"
  root frame (no truncation, no carrier noise)
- Add carrier_frames bit to StackWalkFeatures (replaces _padding bit)
- Use FRAME_PC_SLOT for architecture-portable carrier frame extraction
- Split VMContinuationEntry into DECLARE_V21_TYPES_DO to prevent
  assert(_VMContinuationEntry_size > 0) on JDK <21 debug builds
- Expand DECLARE_V21_TYPES_DO at all four declaration/init/read/verify
  sites in vmStructs.h and vmStructs.cpp
- Enable wextend=vt_carrier in VirtualThreadWallClockTest

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: jbachorik

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

@@ -300,6 +300,19 @@ Error Arguments::parse(const char *args) {
         }
       }
 
+      CASE("wextend")
+      if (value != NULL) {
+        const char* p = value;
+        while (*p != '\0') {
+          const char* comma = strchr(p, ',');
+          size_t len = comma != NULL ? (size_t)(comma - p) : strlen(p);
+          if (len == 10 && strncmp(p, "vt_carrier", 10) == 0) {
+            _features.carrier_frames = 1;
+          }
+          p += len + (comma != NULL ? 1 : 0);
+        }
+      }
+
       CASE("attributes")
       if (value != NULL) {
         std::string input(value);

ddprof-lib/src/main/cpp/arguments.h

@@ -122,7 +122,8 @@ struct StackWalkFeatures {
     unsigned short vtable_target : 1;  // show receiver classes of vtable/itable stubs
     unsigned short comp_task     : 1;  // display current compilation task for JIT threads
     unsigned short pc_addr       : 1;  // record exact PC address for each sample
-    unsigned short _padding      : 3;  // pad structure to 16 bits
+    unsigned short carrier_frames: 1;  // walk through VT continuation boundary to carrier frames (wextend=vt_carrier)
+    unsigned short _padding      : 2;  // pad structure to 16 bits
 };
 
 struct Multiplier {

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

@@ -350,40 +350,43 @@ __attribute__((no_sanitize("address"))) int StackWalker::walkVM(void* ucontext,
         anchor = vm_thread->anchor();
     }
 
-    // Advances through a continuation boundary to the carrier frame.
-    // Walks cont_entry->parent() on repeated calls to handle nested continuations
-    // (_parent is maintained by the JVM for its own bookkeeping; not triggered by
-    // standard single-level VTs today, but required once any runtime layers
-    // continuations on top of VTs).  Returns true to continue the walk, false to break.
-    // Synthetic root frame inserted when a continuation boundary is detected but
-    // carrier frames cannot be captured (transient JVM state or invalid pointers).
-    // Using BCI_NATIVE_FRAME rather than BCI_ERROR avoids marking the sample as
-    // truncated — the virtual thread's own frames are complete; carrier internals
-    // (ForkJoinWorkerThread pool mechanics) are not profiling-relevant anyway.
     static const char* CONT_ROOT_FRAME = "JVM Continuation";
 
+    // Advances through a continuation boundary to the carrier frame.
+    // Without wextend=vt_carrier (default): always stops with a "JVM Continuation"
+    // synthetic root frame — VT frames are complete, carrier internals are noise.
+    // With wextend=carrier: attempts to walk through; failures emit BCI_ERROR
+    // so the sample is truthfully marked truncated.
+    // Walks cont_entry->parent() on repeated calls to handle nested continuations
+    // (_parent not triggered by standard single-level VTs today, but required
+    // once any runtime layers continuations on top of VTs).
+    // Returns true to continue the walk, false to break.
     auto walkThroughContinuation = [&]() -> bool {
+        if (!features.carrier_frames) {
+            fillFrame(frames[depth++], BCI_NATIVE_FRAME, CONT_ROOT_FRAME);
+            return false;
+        }
         cont_entry = (cont_entry != nullptr) ? cont_entry->parent() : vm_thread->contEntry();
         if (cont_entry == nullptr) {
             Counters::increment(WALKVM_CONT_ENTRY_NULL);
-            fillFrame(frames[depth++], BCI_NATIVE_FRAME, CONT_ROOT_FRAME);
+            fillFrame(frames[depth++], BCI_ERROR, "break_cont_entry_null");
             return false;
         }
         uintptr_t entry_fp = cont_entry->entryFP();
         if (!StackWalkValidation::isValidFP(entry_fp)) {
-            fillFrame(frames[depth++], BCI_NATIVE_FRAME, CONT_ROOT_FRAME);
+            fillFrame(frames[depth++], BCI_ERROR, "break_cont_entry_fp");
             return false;
         }
         // entry_fp has been range-checked by isValidFP above; any remaining
         // SIGSEGV from a stale/concurrently-freed pointer is caught by the
         // setjmp crash protection in walkVM (checkFault -> longjmp).
         uintptr_t carrier_fp = *(uintptr_t*)entry_fp;
-        const void* carrier_pc = ((const void**)entry_fp)[1];
-        uintptr_t carrier_sp = entry_fp + 2 * sizeof(void*);
+        const void* carrier_pc = ((const void**)entry_fp)[FRAME_PC_SLOT];
+        uintptr_t carrier_sp = entry_fp + (FRAME_PC_SLOT + 1) * sizeof(void*);
         if (!StackWalkValidation::isValidFP(carrier_fp) ||
             StackWalkValidation::inDeadZone(carrier_pc) ||
             !StackWalkValidation::isValidSP(carrier_sp, sp, bottom)) {
-            fillFrame(frames[depth++], BCI_NATIVE_FRAME, CONT_ROOT_FRAME);
+            fillFrame(frames[depth++], BCI_ERROR, "break_cont_carrier_sp");
             return false;
         }
         sp = carrier_sp;

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

@@ -46,6 +46,7 @@ const void* VMStructs::_interpreted_frame_valid_end = nullptr;
 // Initialize type size to 0
 #define INIT_TYPE_SIZE(name, names) uint64_t VMStructs::TYPE_SIZE_NAME(name) = 0;
 DECLARE_TYPES_DO(INIT_TYPE_SIZE)
+DECLARE_V21_TYPES_DO(INIT_TYPE_SIZE)
 #undef INIT_TYPE_SIZE
 
 #define offset_value -1
@@ -211,6 +212,7 @@ void VMStructs::init_type_sizes() {
         }
 
         DECLARE_TYPES_DO(READ_TYPE_SIZE)
+        DECLARE_V21_TYPES_DO(READ_TYPE_SIZE)
 
 #undef READ_TYPE_SIZE   
 
@@ -279,6 +281,9 @@ void VMStructs::verify_offsets() {
 // Verify type sizes
 #define VERIFY_TYPE_SIZE(name, names) assert(TYPE_SIZE_NAME(name) > 0);
     DECLARE_TYPES_DO(VERIFY_TYPE_SIZE);
+    if (hotspot_version >= 21) {
+        DECLARE_V21_TYPES_DO(VERIFY_TYPE_SIZE);
+    }
 #undef VERIFY_TYPE_SIZE
 
 

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

@@ -117,7 +117,6 @@ inline T* cast_to(const void* ptr) {
     f(VMClassLoaderData,      MATCH_SYMBOLS("ClassLoaderData"))   \
     f(VMConstantPool,         MATCH_SYMBOLS("ConstantPool"))      \
     f(VMConstMethod,          MATCH_SYMBOLS("ConstMethod"))       \
-    f(VMContinuationEntry,    MATCH_SYMBOLS("ContinuationEntry")) \
     f(VMFlag,                 MATCH_SYMBOLS("JVMFlag", "Flag"))   \
     f(VMJavaFrameAnchor,      MATCH_SYMBOLS("JavaFrameAnchor"))   \
     f(VMKlass,                MATCH_SYMBOLS("Klass"))             \
@@ -126,6 +125,10 @@ inline T* cast_to(const void* ptr) {
     f(VMSymbol,               MATCH_SYMBOLS("Symbol"))            \
     f(VMThread,               MATCH_SYMBOLS("Thread"))
 
+// Types only present in JDK 21+ (Project Loom); size is 0 on older JDKs
+#define DECLARE_V21_TYPES_DO(f) \
+    f(VMContinuationEntry,    MATCH_SYMBOLS("ContinuationEntry"))
+
 /**
  * Following macros define field offsets, addresses or values of JVM classes that are exported by
  * vmStructs.
@@ -332,6 +335,7 @@ class VMStructs {
     static uint64_t TYPE_SIZE_NAME(name);
 
     DECLARE_TYPES_DO(DECLARE_TYPE_SIZE_VAR)
+    DECLARE_V21_TYPES_DO(DECLARE_TYPE_SIZE_VAR)
 #undef DECLARE_TYPE_SIZE_VAR
 
 // Declare vmStructs' field offsets and addresses

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

@@ -50,7 +50,7 @@ protected boolean isPlatformSupported() {
 
     @Override
     protected String getProfilerCommand() {
-        return "wall=1ms,filter=";
+        return "wall=1ms,filter=,wextend=vt_carrier";
     }
 
     /**