Remove debug log

Author: pablogsal

src/memray/_memray/ghost_stack/BUG_FIX_DESCRIPTION.md

@@ -0,0 +1,60 @@
+# Ghost Stack Bug Fix
+
+## Problem
+
+The ghost unwind feature was producing incorrect native stack traces. When `fast_unwind=True`, the captured stack was missing the top frames (like `valloc`) and showed frames shifted by one position.
+
+## Root Causes
+
+### Bug 1: Returning Return Addresses Instead of Instruction Pointers
+
+The `unw_backtrace()` function returns **instruction pointers (IPs)** - the address where each frame is currently executing. However, ghost_stack was returning **return addresses** - the address where each frame will return TO after it completes.
+
+These are different values:
+- IP of frame N = where frame N is executing
+- Return address stored in frame N = IP of frame N-1 (the caller)
+
+So returning return addresses produces a stack that is shifted by one frame and missing the topmost frame entirely.
+
+**Location**: `capture_and_install()` and `copy_cached_frames()` in `ghost_stack.cpp`
+
+**Fix**:
+1. Added `ip` field to `StackEntry` struct to store both the IP (for returning to caller) and the return_address (for trampoline restoration)
+2. Changed output buffer to return `entries_[i].ip` instead of `entries_[i].return_address`
+
+### Bug 2: Off-by-One Error in Frame Walking Loop
+
+The original loop structure was:
+```cpp
+while (unw_step(&cursor) > 0 && frame_idx < raw_count) {
+    unw_get_reg(&cursor, UNW_REG_IP, &ip);  // Read AFTER stepping
+    ...
+}
+```
+
+This calls `unw_step()` BEFORE reading frame data. After the skip loop positions the cursor at frame 3, the first `unw_step()` moves to frame 4 before we read anything - skipping frame 3 entirely.
+
+**Fix**: Changed to read-then-step pattern:
+```cpp
+do {
+    unw_get_reg(&cursor, UNW_REG_IP, &ip);  // Read FIRST
+    ...
+    step_result = unw_step(&cursor);         // Step AFTER
+} while (step_result > 0);
+```
+
+## Files Modified
+
+- `src/memray/_memray/ghost_stack/src/ghost_stack.cpp`
+  - `StackEntry` struct: added `ip` field
+  - `capture_and_install()`: store IP, return IP, fix loop structure
+  - `copy_cached_frames()`: return IP instead of return_address
+
+## Test
+
+The fix was verified with:
+```
+python -m pytest tests/integration/test_native_tracking.py -v -s -x -k ceval
+```
+
+Both `fast_unwind=False` and `fast_unwind=True` variants now pass and produce correct stack traces with `valloc` and `run_recursive` in the expected positions.

src/memray/_memray/ghost_stack/src/ghost_stack.cpp

@@ -394,12 +394,7 @@ class GhostStackImpl {
 #else
         // Linux: use libunwind's unw_backtrace
         int ret = unw_backtrace(buffer, static_cast<int>(max_frames));
-        size_t count = (ret > 0) ? static_cast<size_t>(ret) : 0;
-        LOG_DEBUG("do_unwind: unw_backtrace returned %zu frames\n", count);
-        for (size_t i = 0; i < count && i < 10; ++i) {
-            LOG_DEBUG("  raw frame %zu: ip=%p\n", i, buffer[i]);
-        }
-        return count;
+        return (ret > 0) ? static_cast<size_t>(ret) : 0;
 #endif
     }
 
@@ -426,9 +421,6 @@ class GhostStackImpl {
 // Thread-Local Instance Management
 // ============================================================================
 
-// Global counter for debugging
-static std::atomic<int> g_backtrace_call_count{0};
-
 /**
  * RAII wrapper for thread-local GhostStackImpl.
  *
@@ -441,8 +433,7 @@ struct ThreadLocalInstance {
 
     ~ThreadLocalInstance() {
         if (ptr) {
-            LOG_DEBUG("Thread exit: resetting shadow stack (total backtrace calls: %d)\n",
-                      g_backtrace_call_count.load());
+            LOG_DEBUG("Thread exit: resetting shadow stack\n");
             ptr->reset();
             delete ptr;
             ptr = nullptr;
@@ -501,21 +492,15 @@ static void register_atfork_handler() {
 extern "C" {
 
 void ghost_stack_init(ghost_stack_unwinder_t unwinder) {
-    LOG_DEBUG("ghost_stack_init called\n");
     std::call_once(g_init_flag, [unwinder]() {
         g_custom_unwinder = unwinder;
-        LOG_DEBUG("Initialized with %s unwinder\n",
-                  unwinder ? "custom" : "default");
     });
 
     // Register fork handler (idempotent, safe to call multiple times)
     register_atfork_handler();
 }
 
 size_t ghost_stack_backtrace(void** buffer, size_t size) {
-    int call_num = g_backtrace_call_count.fetch_add(1) + 1;
-    LOG_DEBUG("ghost_stack_backtrace called (call #%d, size=%zu)\n", call_num, size);
-
     // Auto-init if needed
     std::call_once(g_init_flag, []() {
         g_custom_unwinder = nullptr;
@@ -533,9 +518,7 @@ size_t ghost_stack_backtrace(void** buffer, size_t size) {
         unwinder_set = true;
     }
 
-    size_t result = impl.backtrace(buffer, size);
-    LOG_DEBUG("ghost_stack_backtrace returning %zu frames (call #%d)\n", result, call_num);
-    return result;
+    return impl.backtrace(buffer, size);
 }
 
 void ghost_stack_reset(void) {