Restore error frames for truncated stacks in walkVM

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

Author: jbachorik

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

@@ -555,6 +555,7 @@ __attribute__((no_sanitize("address"))) int StackWalker::walkVM(void* ucontext,
                         // already used the anchor; disable it
                         anchor = NULL;
                         if (sp < prev_sp || sp >= bottom || !aligned(sp)) {
+                            fillFrame(frames[depth++], BCI_ERROR, "break_no_anchor");
                             break;
                         }
                         // we restored from Java frame; clean the prev_native_pc
@@ -579,6 +580,11 @@ __attribute__((no_sanitize("address"))) int StackWalker::walkVM(void* ucontext,
                         }
                     }
                 }
+                if (vm_thread != NULL && vm_thread->isJavaThread()) {
+                    fillFrame(frames[depth++], BCI_ERROR, "break_no_anchor");
+                } else {
+                    fillFrame(frames[depth++], BCI_ERROR, "break_no_symbol");
+                }
                 break;
             }
             fillFrame(frames[depth++], frame_bci, (void*)method_name);

ddprof-test/src/test/java/com/datadoghq/profiler/nativethread/NativeThreadTest.java

@@ -32,9 +32,10 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
- * Tests native thread profiling to ensure proper stack unwinding without error frames.
- * This test validates Theory 1 (thread entry point detection) by verifying that
- * native threads no longer produce break_no_anchor or other error frames.
+ * Tests native thread profiling to ensure proper stack unwinding.
+ * Validates that native threads produce usable samples with do_primes() and
+ * that non-Java thread samples are not misclassified as break_no_anchor
+ * (which implies a missing JavaFrameAnchor, inapplicable for pure pthreads).
  */
 public class NativeThreadTest extends AbstractProfilerTest {
 
@@ -68,13 +69,13 @@ public void test() {
               String stacktrace = stacktraceAccessor.getMember(item);
               totalSamples++;
 
-              // Primary verification: Assert NO break_no_anchor errors
-              // Note: no_Java_frame is acceptable for pure native threads that never enter Java
-              assertFalse(stacktrace.contains("break_no_anchor"),
-                  "Found break_no_anchor error frame in stacktrace: " + stacktrace);
-
-              // Secondary verification: Check for expected native frames
               if (stacktrace.indexOf("do_primes()") != -1) {
+                // Native thread sample: must not contain break_no_anchor
+                // (non-Java threads have no JavaFrameAnchor — that error is inapplicable)
+                // break_no_symbol is expected when DWARF CFI is incomplete
+                assertFalse(stacktrace.contains("break_no_anchor"),
+                    "Found break_no_anchor in native thread sample: " + stacktrace);
+
                 if (!stacktrace_printed) {
                     stacktrace_printed = true;
                     System.out.println("Native thread stack:");

ddprof-test/src/test/java/com/datadoghq/profiler/nativethread/ThreadEntryDetectionTest.java

@@ -28,15 +28,14 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
- * Test specifically for thread entry point detection (Theory 1).
+ * Test for thread entry point detection on native threads.
  *
- * This test validates that when profiling native threads, the profiler:
- * 1. Correctly detects JVM thread entry points (thread_native_entry, JavaThread::, etc.)
- * 2. Does NOT produce break_no_anchor or other error frames
- * 3. Treats thread entry points as root frames and stops unwinding
- *
- * The test uses a larger number of threads than the standard test to increase
- * the likelihood of catching race conditions in thread startup detection.
+ * Validates that when profiling native threads the profiler produces usable
+ * samples and that non-Java thread samples are not misclassified as
+ * break_no_anchor (which implies a missing JavaFrameAnchor, inapplicable
+ * for pure pthreads).  break_no_symbol is acceptable — it indicates the
+ * DWARF unwind could not resolve the next frame, which is expected when
+ * the test library or libc lacks complete CFI.
  */
 public class ThreadEntryDetectionTest extends AbstractProfilerTest {
 
@@ -76,9 +75,10 @@ public void testThreadEntryDetection() throws Exception {
     }
 
     /**
-     * Verifies that no error frames are present in the stacktraces.
-     * This is the primary validation for Theory 1 - ensuring thread entry
-     * detection prevents malformed stacktraces.
+     * Verifies that native thread samples do not contain break_no_anchor.
+     * break_no_anchor implies a missing JavaFrameAnchor which is inapplicable
+     * for pure pthreads.  break_no_symbol is acceptable — it means the DWARF
+     * unwind hit an unresolvable PC, expected when CFI is incomplete.
      */
     private void assertNoErrorFrames(IItemCollection events) {
         int samplesChecked = 0;
@@ -91,21 +91,16 @@ private void assertNoErrorFrames(IItemCollection events) {
                 String stackTrace = stackTraceAccessor.getMember(sample);
                 samplesChecked++;
 
-                // Critical assertion: NO error frames should be present
-                assertFalse(stackTrace.contains("break_no_anchor"),
-                    String.format("Found break_no_anchor error in sample %d/%d:\n%s",
-                        samplesChecked, samplesChecked, stackTrace));
-
-                // Note: no_Java_frame is acceptable for pure native threads that never enter Java
-
-                // Additional checks for other error indicators
-                assertFalse(stackTrace.contains("BCI_ERROR"),
-                    String.format("Found BCI_ERROR in sample %d/%d:\n%s",
-                        samplesChecked, samplesChecked, stackTrace));
+                if (stackTrace.contains("do_primes()")) {
+                    // Native thread sample: must not be misclassified as break_no_anchor
+                    assertFalse(stackTrace.contains("break_no_anchor"),
+                        String.format("Found break_no_anchor in native thread sample %d:\n%s",
+                            samplesChecked, stackTrace));
+                }
             }
         }
 
-        System.out.println("Verified " + samplesChecked + " samples - no error frames found");
+        System.out.println("Verified " + samplesChecked + " samples");
     }
 
     /**