Fix remote symbolication for VM/VMX stack walkers

- Add resolveNativeFrameForWalkVM helper to profiler.h/cpp
- Patch walkVM to use remote symbolication at native frame resolution point
- Remove broken applyRemoteSymbolicationToVMFrames function
- Add lock_index parameter to all walkVM signatures via patching.gradle
- Update stackWalker_dd.h wrappers to pass lock_index
- Remove dead non-const operator[] from codeCache.h
- Add alignment check for ELF program headers in symbols_linux_dd.cpp

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Author: jbachorik

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

@@ -243,7 +243,6 @@ class CodeCacheArray {
     memset(_libs, 0, MAX_NATIVE_LIBS * sizeof(CodeCache *));
   }
 
-  CodeCache *operator[](int index) { return _libs[index]; }
   CodeCache *operator[](int index) const { return __atomic_load_n(&_libs[index], __ATOMIC_ACQUIRE); }
 
   int count() const { return __atomic_load_n(&_count, __ATOMIC_RELAXED); }

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

@@ -323,66 +323,6 @@ int Profiler::getNativeTrace(void *ucontext, ASGCT_CallFrame *frames,
   return convertNativeTrace(native_frames, callchain, frames, lock_index);
 }
 
-void Profiler::applyRemoteSymbolicationToVMFrames(ASGCT_CallFrame *frames, int num_frames, int lock_index) {
-  for (int i = 0; i < num_frames; i++) {
-    // Only process native frames (not Java frames or special frames)
-    if (frames[i].bci != BCI_NATIVE_FRAME) {
-      continue;
-    }
-
-    // method_id contains the resolved symbol name (const char*)
-    const char* symbol_name = (const char*)frames[i].method_id;
-    if (symbol_name == nullptr) {
-      continue;
-    }
-
-    // Find the library containing this symbol to get the PC
-    // We search all libraries for this symbol
-    uintptr_t pc = 0;
-    CodeCache* lib = nullptr;
-    const CodeCacheArray& native_libs = _libs->native_libs();
-    int lib_count = native_libs.count();
-    for (int lib_idx = 0; lib_idx < lib_count; lib_idx++) {
-      CodeCache* candidate_lib = native_libs[lib_idx];
-      if (candidate_lib == nullptr) {
-        continue;
-      }
-
-      // Search for the symbol in this library
-      const void* symbol_addr = candidate_lib->findSymbol(symbol_name);
-      if (symbol_addr != nullptr) {
-        lib = candidate_lib;
-        pc = (uintptr_t)symbol_addr;
-        TEST_LOG("Found symbol %s in lib %s at pc=0x%lx", symbol_name, lib->name(), pc);
-        break;
-      }
-    }
-
-    // If we found the PC and the library has a build-id, apply remote symbolication
-    if (pc != 0 && lib != nullptr && lib->hasBuildId()) {
-      TEST_LOG("Applying remote symbolication to VM frame: symbol=%s, lib=%s, build-id=%s",
-               symbol_name, lib->name(), lib->buildId());
-
-      // Calculate PC offset within the library
-      uintptr_t offset = pc - (uintptr_t)lib->imageBase();
-
-      // Allocate RemoteFrameInfo from pre-allocated pool (signal-safe)
-      RemoteFrameInfo* rfi = allocateRemoteFrameInfo(lock_index);
-      if (rfi != nullptr) {
-        rfi->build_id = lib->buildId();
-        rfi->pc_offset = offset;
-        rfi->lib_index = lib->libIndex();
-
-        // Replace the frame with remote symbolication format
-        frames[i].method_id = (jmethodID)rfi;
-        frames[i].bci = BCI_NATIVE_FRAME_REMOTE;
-        TEST_LOG("Converted VM frame to remote format: build-id=%s, offset=0x%lx", rfi->build_id, rfi->pc_offset);
-      }
-      // If pool exhausted, keep original resolved symbol name
-    }
-  }
-}
-
 /**
  * Allocate a RemoteFrameInfo from the pre-allocated pool for the given lock-strip.
  * This is signal-safe (uses atomic operations, no dynamic allocation).
@@ -469,6 +409,11 @@ Profiler::NativeFrameResolution Profiler::resolveNativeFrame(uintptr_t pc, int l
   }
 }
 
+Profiler::NativeFrameResolution Profiler::resolveNativeFrameForWalkVM(uintptr_t pc, int lock_index) {
+  // Direct pass-through to resolveNativeFrame with lock_index
+  return resolveNativeFrame(pc, lock_index);
+}
+
 int Profiler::convertNativeTrace(int native_frames, const void **callchain,
                                  ASGCT_CallFrame *frames, int lock_index) {
   int depth = 0;
@@ -865,21 +810,13 @@ void Profiler::recordSample(void *ucontext, u64 counter, int tid,
       int max_remaining = _max_stack_depth - num_frames;
       if (_features.mixed) {
         int vm_start = num_frames;
-        int vm_frames = ddprof::StackWalker::walkVM(ucontext, frames + vm_start, max_remaining, _features, eventTypeFromBCI(event_type), &truncated);
+        int vm_frames = ddprof::StackWalker::walkVM(ucontext, frames + vm_start, max_remaining, _features, eventTypeFromBCI(event_type), &truncated, lock_index);
         num_frames += vm_frames;
-        // Apply remote symbolication to VM frames if enabled
-        if (_remote_symbolication) {
-          applyRemoteSymbolicationToVMFrames(frames + vm_start, vm_frames, lock_index);
-        }
       } else if (event_type == BCI_CPU || event_type == BCI_WALL) {
         if (_cstack >= CSTACK_VM) {
           int vm_start = num_frames;
-          int vm_frames = ddprof::StackWalker::walkVM(ucontext, frames + vm_start, max_remaining, _features, eventTypeFromBCI(event_type), &truncated);
+          int vm_frames = ddprof::StackWalker::walkVM(ucontext, frames + vm_start, max_remaining, _features, eventTypeFromBCI(event_type), &truncated, lock_index);
           num_frames += vm_frames;
-          // Apply remote symbolication to VM frames if enabled
-          if (_remote_symbolication) {
-            applyRemoteSymbolicationToVMFrames(frames + vm_start, vm_frames, lock_index);
-          }
         } else {
           // Async events
           AsyncSampleMutex mutex(ProfiledThread::currentSignalSafe());

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

@@ -293,7 +293,7 @@ class alignas(alignof(SpinLock)) Profiler {
   };
 
   NativeFrameResolution resolveNativeFrame(uintptr_t pc, int lock_index);
-  void applyRemoteSymbolicationToVMFrames(ASGCT_CallFrame *frames, int num_frames, int lock_index);
+  NativeFrameResolution resolveNativeFrameForWalkVM(uintptr_t pc, int lock_index);
   RemoteFrameInfo* allocateRemoteFrameInfo(int lock_index);
   int convertNativeTrace(int native_frames, const void **callchain,
                          ASGCT_CallFrame *frames, int lock_index);

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

@@ -50,8 +50,8 @@ namespace ddprof {
         return walked;
       }
 
-      inline static int walkVM(void* ucontext, ASGCT_CallFrame* frames, int max_depth, StackWalkFeatures features, EventType event_type, bool* truncated) {
-        int walked = ::StackWalker::walkVM(ucontext, frames, max_depth + 1, features, event_type);
+      inline static int walkVM(void* ucontext, ASGCT_CallFrame* frames, int max_depth, StackWalkFeatures features, EventType event_type, bool* truncated, int lock_index) {
+        int walked = ::StackWalker::walkVM(ucontext, frames, max_depth + 1, features, event_type, lock_index);
         if (walked > max_depth) {
           *truncated = true;
           walked = max_depth;
@@ -64,8 +64,8 @@ namespace ddprof {
         return walked;
       }
 
-      inline static int walkVM(void* ucontext, ASGCT_CallFrame* frames, int max_depth, JavaFrameAnchor* anchor, EventType event_type, bool* truncated) {
-        int walked = ::StackWalker::walkVM(ucontext, frames, max_depth + 1, anchor, event_type);
+      inline static int walkVM(void* ucontext, ASGCT_CallFrame* frames, int max_depth, JavaFrameAnchor* anchor, EventType event_type, bool* truncated, int lock_index) {
+        int walked = ::StackWalker::walkVM(ucontext, frames, max_depth + 1, anchor, event_type, lock_index);
         if (walked > max_depth) {
           *truncated = true;
           walked = max_depth;

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

@@ -72,6 +72,16 @@ char* SymbolsLinux::extractBuildIdFromMemory(const void* elf_base, size_t elf_si
         return nullptr;
     }
 
+    // Verify program header table is within file bounds
+    if (ehdr->e_phoff + ehdr->e_phnum * sizeof(Elf64_Phdr) > elf_size) {
+        return nullptr;
+    }
+
+    // Verify program header offset is properly aligned
+    if (ehdr->e_phoff % alignof(Elf64_Phdr) != 0) {
+        return nullptr;
+    }
+
     const char* base = static_cast<const char*>(elf_base);
     const Elf64_Phdr* phdr = reinterpret_cast<const Elf64_Phdr*>(base + ehdr->e_phoff);
 

gradle/patching.gradle

@@ -188,7 +188,7 @@ ext.upstreamPatches = [
     ]
   ],
 
-  // Stack walker patches for ASan compatibility
+  // Stack walker patches for ASan compatibility and remote symbolication
   "stackWalker.cpp": [
     validations: [[contains: "StackWalker::"], [contains: "StackWalker::walkVM"]],
     operations: [
@@ -199,6 +199,78 @@ ext.upstreamPatches = [
         find: "(int\\s+StackWalker::walkVM\\s*\\()",
         replace: "__attribute__((no_sanitize(\"address\"))) \$1",
         idempotent_check: "__attribute__((no_sanitize(\"address\"))) int StackWalker::walkVM("
+      ],
+      [
+        type: "signature_parameter_add",
+        name: "Add lock_index to public walkVM (features) signature",
+        description: "Adds lock_index parameter to public walkVM overload with features parameter",
+        find: "(__attribute__\\(\\(no_sanitize\\(\"address\"\\)\\)\\) int StackWalker::walkVM\\(void\\* ucontext, ASGCT_CallFrame\\* frames, int max_depth,\\s*StackWalkFeatures features, EventType event_type)\\)",
+        replace: "\$1, int lock_index)",
+        idempotent_check: "EventType event_type, int lock_index\\) \\{"
+      ],
+      [
+        type: "expression_replace",
+        name: "Update first walkVM call in public features overload",
+        description: "Adds lock_index to walkVM call with callerPC/callerSP/callerFP",
+        find: "(return walkVM\\(&empty_ucontext, frames, max_depth, features, event_type,\\s*callerPC\\(\\), \\(uintptr_t\\)callerSP\\(\\), \\(uintptr_t\\)callerFP\\(\\))\\);",
+        replace: "\$1, lock_index);",
+        idempotent_check: "callerFP\\(\\), lock_index\\);"
+      ],
+      [
+        type: "expression_replace",
+        name: "Update second walkVM call in public features overload",
+        description: "Adds lock_index to walkVM call with frame.pc/sp/fp",
+        find: "(return walkVM\\(ucontext, frames, max_depth, features, event_type,\\s*\\(const void\\*\\)frame\\.pc\\(\\), frame\\.sp\\(\\), frame\\.fp\\(\\))\\);",
+        replace: "\$1, lock_index);",
+        idempotent_check: "frame\\.fp\\(\\), lock_index\\);"
+      ],
+      [
+        type: "signature_parameter_add",
+        name: "Add lock_index to public walkVM (anchor) signature",
+        description: "Adds lock_index parameter to public walkVM overload with anchor parameter",
+        find: "(__attribute__\\(\\(no_sanitize\\(\"address\"\\)\\)\\) int StackWalker::walkVM\\(void\\* ucontext, ASGCT_CallFrame\\* frames, int max_depth, JavaFrameAnchor\\* anchor, EventType event_type)\\)",
+        replace: "\$1, int lock_index)",
+        idempotent_check: "EventType event_type, int lock_index\\) \\{"
+      ],
+      [
+        type: "expression_replace",
+        name: "Update walkVM call in public anchor overload",
+        description: "Adds lock_index to walkVM call from anchor overload",
+        find: "(return walkVM\\(ucontext, frames, max_depth, no_features, event_type, pc, sp, fp)\\);",
+        replace: "\$1, lock_index);",
+        idempotent_check: "fp, lock_index\\);"
+      ],
+      [
+        type: "signature_parameter_add",
+        name: "Add lock_index to private walkVM implementation signature",
+        description: "Adds lock_index parameter to private walkVM implementation for remote symbolication pool management",
+        find: "(__attribute__\\(\\(no_sanitize\\(\"address\"\\)\\)\\) int StackWalker::walkVM\\(void\\* ucontext, ASGCT_CallFrame\\* frames, int max_depth,\\s*StackWalkFeatures features, EventType event_type,\\s*const void\\* pc, uintptr_t sp, uintptr_t fp)\\)",
+        replace: "\$1, int lock_index)",
+        idempotent_check: "uintptr_t fp, int lock_index\\)"
+      ],
+      [
+        type: "expression_replace",
+        name: "Add remote symbolication support to walkVM native frame resolution",
+        description: "Replaces direct symbol resolution with resolveNativeFrameForWalkVM call that checks remote symbolication mode",
+        find: "const char\\* method_name = profiler->findNativeMethod\\(pc\\);",
+        replace: "// Check if remote symbolication is enabled\n            Profiler::NativeFrameResolution resolution = profiler->resolveNativeFrameForWalkVM((uintptr_t)pc, lock_index);\n            if (resolution.is_marked) {\n                // This is a marked C++ interpreter frame, terminate scan\n                break;\n            }\n            const char* method_name = (const char*)resolution.method_id;\n            int frame_bci = resolution.bci;",
+        idempotent_check: "resolveNativeFrameForWalkVM"
+      ],
+      [
+        type: "expression_replace",
+        name: "Update fillFrame call to use dynamic BCI",
+        description: "Updates the fillFrame call to use the dynamic frame_bci value determined by remote symbolication mode",
+        find: "fillFrame\\(frames\\[depth\\+\\+\\], BCI_NATIVE_FRAME, method_name\\);",
+        replace: "fillFrame(frames[depth++], frame_bci, (void*)method_name);",
+        idempotent_check: "frame_bci, \\(void\\*\\)method_name"
+      ],
+      [
+        type: "method_implementation",
+        name: "Add fillFrame overload for void* method_id",
+        description: "Adds fillFrame overload that accepts void* method_id to support both symbol names and RemoteFrameInfo pointers",
+        find: "(static inline void fillFrame\\(ASGCT_CallFrame& frame, ASGCT_CallFrameType type, const char\\* name\\) \\{[^}]+\\})",
+        replace: "\$1\n\n// Overload for RemoteFrameInfo* (passed as void* to support both char* and RemoteFrameInfo*)\nstatic inline void fillFrame(ASGCT_CallFrame& frame, int bci, void* method_id_ptr) {\n    frame.bci = bci;\n    frame.method_id = (jmethodID)method_id_ptr;\n}",
+        idempotent_check: "void fillFrame\\(ASGCT_CallFrame& frame, int bci, void\\* method_id_ptr\\)"
       ]
     ]
   ],
@@ -284,5 +356,36 @@ ext.upstreamPatches = [
         idempotent_check: "uintptr_t sender_sp_baseline("
       ]
     ]
+  ],
+
+  // Stack walker header patches for remote symbolication support
+  "stackWalker.h": [
+    validations: [[contains: "class StackWalker"], [contains: "static int walkVM"]],
+    operations: [
+      [
+        type: "signature_parameter_add",
+        name: "Add lock_index to private walkVM signature",
+        description: "Adds lock_index parameter to private walkVM implementation for remote symbolication pool management",
+        find: "(static int walkVM\\(void\\* ucontext, ASGCT_CallFrame\\* frames, int max_depth,\\s*StackWalkFeatures features, EventType event_type,\\s*const void\\* pc, uintptr_t sp, uintptr_t fp)\\);",
+        replace: "\$1, int lock_index);",
+        idempotent_check: "int lock_index\\);"
+      ],
+      [
+        type: "signature_parameter_add",
+        name: "Add lock_index to public walkVM signature (features overload)",
+        description: "Adds lock_index parameter to public walkVM features-based overload",
+        find: "(static int walkVM\\(void\\* ucontext, ASGCT_CallFrame\\* frames, int max_depth, StackWalkFeatures features, EventType event_type)\\);",
+        replace: "\$1, int lock_index);",
+        idempotent_check: "EventType event_type, int lock_index\\);"
+      ],
+      [
+        type: "signature_parameter_add",
+        name: "Add lock_index to public walkVM signature (anchor overload)",
+        description: "Adds lock_index parameter to public walkVM anchor-based overload",
+        find: "(static int walkVM\\(void\\* ucontext, ASGCT_CallFrame\\* frames, int max_depth, JavaFrameAnchor\\* anchor, EventType event_type)\\);",
+        replace: "\$1, int lock_index);",
+        idempotent_check: "JavaFrameAnchor\\* anchor, EventType event_type, int lock_index\\);"
+      ]
+    ]
   ]
 ]