Detect per-library aarch64 frame layout from DWARF

Wire up default_clang_frame which was defined but never used.
DwarfParser now detects the linked frame size by observing the
first FP-based CFA entry with a non-zero offset during DWARF
parsing (both GCC and Clang emit cfa_off=LINKED_FRAME_CLANG_SIZE
in function bodies on aarch64). CodeCache stores the detected
default per library and uses it when DWARF doesn't cover a PC.
For unknown libraries (cc==NULL) on Apple/aarch64, fall back to
default_clang_frame since Apple ships Clang-only code.

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: jbachorik

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

@@ -63,6 +63,7 @@ CodeCache::CodeCache(const char *name, short lib_index,
 
   _dwarf_table = NULL;
   _dwarf_table_length = 0;
+  _default_frame = &FrameDesc::default_frame;
 
   _capacity = INITIAL_CODE_CACHE_CAPACITY;
   _count = 0;
@@ -101,6 +102,7 @@ void CodeCache::copyFrom(const CodeCache& other) {
   _dwarf_table = new FrameDesc[_dwarf_table_length];
   memcpy(_dwarf_table, other._dwarf_table,
          _dwarf_table_length * sizeof(FrameDesc));
+  _default_frame = other._default_frame;
 
   _capacity = other._capacity;
   _count = other._count;
@@ -388,16 +390,15 @@ void CodeCache::makeImportsPatchable() {
   }
 }
 
-void CodeCache::setDwarfTable(FrameDesc *table, int length) {
+void CodeCache::setDwarfTable(FrameDesc *table, int length, const FrameDesc &default_frame) {
   _dwarf_table = table;
   _dwarf_table_length = length;
+  _default_frame = &default_frame;
 }
 
 FrameDesc CodeCache::findFrameDesc(const void *pc) {
   if (_dwarf_table == NULL || _dwarf_table_length == 0) {
-    // No DWARF data available - use default frame pointer unwinding
-    // This handles OpenJ9 and other VMs that don't provide DWARF info
-    return FrameDesc::default_frame;
+    return *_default_frame;
   }
 
   u32 target_loc = (const char *)pc - _text_base;
@@ -420,7 +421,7 @@ FrameDesc CodeCache::findFrameDesc(const void *pc) {
   } else if (target_loc - _plt_offset < _plt_size) {
     return FrameDesc::empty_frame;
   } else {
-    return FrameDesc::default_frame;
+    return *_default_frame;
   }
 }
 

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

@@ -8,6 +8,7 @@
 
 #include "common.h"
 #include "counters.h"
+#include "dwarf.h"
 #include "utils.h"
 
 #include <jvmti.h>
@@ -116,8 +117,6 @@ class CodeBlob {
   }
 };
 
-class FrameDesc;
-
 class CodeCache {
 private:
   char *_name;
@@ -141,6 +140,7 @@ class CodeCache {
 
   FrameDesc *_dwarf_table;
   int _dwarf_table_length;
+  const FrameDesc *_default_frame;
 
   int _capacity;
   int _count;
@@ -241,7 +241,7 @@ class CodeCache {
   void findSymbolsByPrefix(std::vector<const char *> &prefixes,
                            std::vector<const void *> &symbols);
 
-  void setDwarfTable(FrameDesc *table, int length);
+  void setDwarfTable(FrameDesc *table, int length, const FrameDesc &default_frame = FrameDesc::default_frame);
   FrameDesc findFrameDesc(const void *pc);
 
   long long memoryUsage() {

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

@@ -104,6 +104,7 @@ DwarfParser::DwarfParser(const char *name, const char *image_base,
 
   _code_align = sizeof(instruction_t);
   _data_align = -(int)sizeof(void *);
+  _linked_frame_size = -1;
 
   parse(eh_frame_hdr);
 }
@@ -411,6 +412,14 @@ void DwarfParser::addRecord(u32 loc, u32 cfa_reg, int cfa_off, int fp_off,
   // cfa_reg and cfa_off can be encoded to a single 32 bit value, considering the existing and supported systems
   u32 cfa = static_cast<u32>(cfa_off) << 8 | static_cast<u32>(cfa_reg & 0xff);
 
+  // Detect the linked frame size from the first FP-based entry with a non-zero offset.
+  // Both GCC and Clang emit DW_REG_FP with cfa_off = LINKED_FRAME_CLANG_SIZE in function
+  // bodies after the prologue completes. Terminal records use cfa_off = 0 (LINKED_FRAME_SIZE
+  // on aarch64) and do not influence detection.
+  if (_linked_frame_size < 0 && cfa_reg == DW_REG_FP && cfa_off > 0) {
+    _linked_frame_size = cfa_off;
+  }
+
   if (_prev == NULL || (_prev->loc == loc && --_count >= 0) ||
       _prev->cfa != cfa || _prev->fp_off != fp_off || _prev->pc_off != pc_off) {
     _prev = addRecordRaw(loc, cfa, fp_off, pc_off);

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

@@ -80,7 +80,7 @@ struct FrameDesc {
 
     static FrameDesc empty_frame;
     static FrameDesc default_frame;
-    static FrameDesc default_clang_frame;
+    static FrameDesc    default_clang_frame;
     static FrameDesc no_dwarf_frame;
 
     static int comparator(const void* p1, const void* p2) {
@@ -104,6 +104,7 @@ class DwarfParser {
 
     u32 _code_align;
     int _data_align;
+    int _linked_frame_size;  // detected from FP-based DWARF entries; -1 = undetected
 
     const char* add(size_t size) {
         const char* ptr = _ptr;
@@ -185,6 +186,13 @@ class DwarfParser {
     int count() const {
         return _count;
     }
+
+    const FrameDesc& detectedDefaultFrame() const {
+        if (_linked_frame_size == LINKED_FRAME_CLANG_SIZE && LINKED_FRAME_CLANG_SIZE != LINKED_FRAME_SIZE) {
+            return FrameDesc::default_clang_frame;
+        }
+        return FrameDesc::default_frame;
+    }
 };
 
 #endif // _DWARF_H

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

@@ -158,7 +158,11 @@ int StackWalker::walkDwarf(void* ucontext, const void** callchain, int max_depth
 
         uintptr_t prev_sp = sp;
         CodeCache* cc = profiler->findLibraryByAddress(pc);
+#if defined(__APPLE__) && defined(__aarch64__)
+        FrameDesc f = cc != NULL ? cc->findFrameDesc(pc) : FrameDesc::default_clang_frame;
+#else
         FrameDesc f = cc != NULL ? cc->findFrameDesc(pc) : FrameDesc::default_frame;
+#endif
 
         u8 cfa_reg = (u8)f.cfa;
         int cfa_off = f.cfa >> 8;
@@ -694,7 +698,11 @@ __attribute__((no_sanitize("address"))) int StackWalker::walkVM(void* ucontext,
         dwarf_unwind:
         uintptr_t prev_sp = sp;
         CodeCache* cc = profiler->findLibraryByAddress(pc);
+#if defined(__APPLE__) && defined(__aarch64__)
+        FrameDesc f = cc != NULL ? cc->findFrameDesc(pc) : FrameDesc::default_clang_frame;
+#else
         FrameDesc f = cc != NULL ? cc->findFrameDesc(pc) : FrameDesc::default_frame;
+#endif
 
         u8 cfa_reg = (u8)f.cfa;
         int cfa_off = f.cfa >> 8;

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

@@ -605,7 +605,7 @@ void ElfParser::parseDwarfInfo() {
     if (eh_frame_hdr != NULL) {
         if (eh_frame_hdr->p_vaddr != 0) {
             DwarfParser dwarf(_cc->name(), _base, at(eh_frame_hdr));
-            _cc->setDwarfTable(dwarf.table(), dwarf.count());
+            _cc->setDwarfTable(dwarf.table(), dwarf.count(), dwarf.detectedDefaultFrame());
         } else if (strcmp(_cc->name(), "[vdso]") == 0) {
             FrameDesc* table = (FrameDesc*)malloc(sizeof(FrameDesc));
             *table = FrameDesc::empty_frame;