debug/memory.c

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
#if defined(DEBUG_MEMORY) && !defined(NDEBUG)
 
#include <stdatomic.h>
#include <stdlib.h>
#include <string.h>
 
#include <ascii-chat/debug/memory.h>
#include <ascii-chat/common.h>
#include <ascii-chat/common/buffer_sizes.h>
#include <ascii-chat/common/error_codes.h>
#include <ascii-chat/asciichat_errno.h>
#include <ascii-chat/platform/mutex.h>
#include <ascii-chat/platform/system.h>
#include <ascii-chat/platform/memory.h>
#include <ascii-chat/platform/terminal.h>
#include <ascii-chat/util/format.h>
#include <ascii-chat/util/path.h>
#include <ascii-chat/util/string.h>
#include <ascii-chat/util/time.h>
#include <ascii-chat/log/logging.h>
#include <ascii-chat/options/options.h>
 
typedef struct mem_block {
  void *ptr;
  size_t size;
  char file[BUFFER_SIZE_SMALL];
  int line;
  bool is_aligned;
  void *backtrace_ptrs[16]; // Store up to 16 return addresses
  int backtrace_count;      // Number of frames captured
  struct mem_block *next;
} mem_block_t;
 
// Non-static for shared library compatibility (still thread-local)
__thread bool g_in_debug_memory = false;
 
typedef struct {
  const char *file;
  int line;
  int expected_count; // Exact number of allocations expected from this location
} ignore_entry_t;
 
static const ignore_entry_t g_ignore_list[] = {
    {"lib/options/colorscheme.c", 579, 8}, // 8 16-color ANSI strings (cleaned after report)
    {"lib/options/colorscheme.c", 596, 8}, // 8 256-color ANSI strings (cleaned after report)
    {"lib/options/colorscheme.c", 613, 8}, // 8 truecolor ANSI strings (cleaned after report)
    {"lib/util/path.c", 1203, 1},          // Normalized path allocation (caller responsibility to free)
    {NULL, 0, 0}                           // Sentinel
};
 
// Track seen count for each ignore entry (reset at start of memory report)
static int g_ignore_counts[32] = {0};
 
static void reset_ignore_counters(void) {
  memset(g_ignore_counts, 0, sizeof(g_ignore_counts));
}
 
// Helper function to acquire mutex with polling instead of blocking.
// mutex_lock() can be unsafe during shutdown when signals may arrive.
// Use trylock polling instead to avoid hanging indefinitely.
static bool acquire_mutex_with_polling(mutex_t *mutex, int timeout_ms) {
  int max_retries = (timeout_ms + 9) / 10; // 10ms per retry
  for (int retry = 0; retry < max_retries; retry++) {
    int lock_result = mutex_trylock(mutex);
    if (lock_result == 0) {
      return true;
    }
    if (lock_result != EBUSY) {
      return false; // Unexpected error
    }
    platform_sleep_ms(10); // Sleep 10ms before retry
  }
  return false; // Timeout
}
 
static bool should_ignore_allocation(const char *file, int line) {
  // file is already the normalized relative path from curr->file
  // (set during debug_malloc/debug_calloc using extract_project_relative_path)
  // Do NOT call extract_project_relative_path again - it won't work on already-relative paths
 
  for (size_t i = 0; g_ignore_list[i].file != NULL; i++) {
    if (line == g_ignore_list[i].line && strcmp(file, g_ignore_list[i].file) == 0) {
      // Found matching ignore entry - check if we've exceeded expected count
      if (g_ignore_counts[i] < g_ignore_list[i].expected_count) {
        g_ignore_counts[i]++;
        return true; // Ignore this allocation
      }
      // Exceeded expected count - report as leak!
      return false;
    }
  }
  return false;
}
 
static struct {
  mem_block_t *head;
  atomic_size_t total_allocated;
  atomic_size_t total_freed;
  atomic_size_t current_usage;
  atomic_size_t peak_usage;
  atomic_size_t malloc_calls;
  atomic_size_t free_calls;
  atomic_size_t calloc_calls;
  atomic_size_t realloc_calls;
  mutex_t mutex;
  atomic_int mutex_state;
  bool quiet_mode;
} g_mem = {.head = NULL,
           .total_allocated = 0,
           .total_freed = 0,
           .current_usage = 0,
           .peak_usage = 0,
           .malloc_calls = 0,
           .free_calls = 0,
           .calloc_calls = 0,
           .realloc_calls = 0,
           .mutex_state = 0,
           .quiet_mode = false};
 
#undef malloc
#undef free
#undef calloc
#undef realloc
 
static atomic_flag g_logged_mutex_init_failure = ATOMIC_FLAG_INIT;
 
static bool ensure_mutex_initialized(void) {
  for (;;) {
    int state = atomic_load_explicit(&g_mem.mutex_state, memory_order_acquire);
    if (state == 2) {
      return true;
    }
 
    if (state == 0) {
      int expected = 0;
      if (atomic_compare_exchange_strong_explicit(&g_mem.mutex_state, &expected, 1, memory_order_acq_rel,
                                                  memory_order_acquire)) {
        if (mutex_init(&g_mem.mutex) == 0) {
          atomic_store_explicit(&g_mem.mutex_state, 2, memory_order_release);
          return true;
        }
 
        atomic_store_explicit(&g_mem.mutex_state, 0, memory_order_release);
        if (!atomic_flag_test_and_set(&g_logged_mutex_init_failure)) {
          log_error("Failed to initialize debug memory mutex; memory tracking will run without locking");
        }
        return false;
      }
      continue;
    }
 
    platform_sleep_ms(1);
  }
}
 
void *debug_malloc(size_t size, const char *file, int line) {
  void *ptr = (void *)malloc(size);
  if (!ptr)
    return NULL;
 
  if (g_in_debug_memory) {
    return ptr;
  }
 
  g_in_debug_memory = true;
 
  atomic_fetch_add(&g_mem.malloc_calls, 1);
  atomic_fetch_add(&g_mem.total_allocated, size);
  size_t new_usage = atomic_fetch_add(&g_mem.current_usage, size) + size;
 
  size_t peak = atomic_load(&g_mem.peak_usage);
  while (new_usage > peak) {
    if (atomic_compare_exchange_weak(&g_mem.peak_usage, &peak, new_usage))
      break;
  }
 
  bool have_mutex = ensure_mutex_initialized();
  if (have_mutex) {
    mutex_lock(&g_mem.mutex);
 
    mem_block_t *block = (mem_block_t *)malloc(sizeof(mem_block_t));
    if (block) {
      block->ptr = ptr;
      block->size = size;
      block->is_aligned = false;
      const char *normalized_file = extract_project_relative_path(file);
      SAFE_STRNCPY(block->file, normalized_file, sizeof(block->file) - 1);
      block->line = line;
      // Capture backtrace (skip 1 frame for this function)
      block->backtrace_count = platform_backtrace(block->backtrace_ptrs, 16);
      // Ensure valid backtrace count
      if (block->backtrace_count < 0) {
        block->backtrace_count = 0;
      }
      block->next = g_mem.head;
      g_mem.head = block;
    }
 
    mutex_unlock(&g_mem.mutex);
  }
 
  g_in_debug_memory = false;
  return ptr;
}
 
void debug_track_aligned(void *ptr, size_t size, const char *file, int line) {
  if (!ptr)
    return;
 
  if (g_in_debug_memory) {
    return;
  }
 
  g_in_debug_memory = true;
 
  atomic_fetch_add(&g_mem.malloc_calls, 1);
  atomic_fetch_add(&g_mem.total_allocated, size);
  size_t new_usage = atomic_fetch_add(&g_mem.current_usage, size) + size;
 
  size_t peak = atomic_load(&g_mem.peak_usage);
  while (new_usage > peak) {
    if (atomic_compare_exchange_weak(&g_mem.peak_usage, &peak, new_usage))
      break;
  }
 
  bool have_mutex = ensure_mutex_initialized();
  if (have_mutex) {
    mutex_lock(&g_mem.mutex);
 
    mem_block_t *block = (mem_block_t *)malloc(sizeof(mem_block_t));
    if (block) {
      block->ptr = ptr;
      block->size = size;
      block->is_aligned = true;
      const char *normalized_file = extract_project_relative_path(file);
      SAFE_STRNCPY(block->file, normalized_file, sizeof(block->file) - 1);
      block->line = line;
      // Capture backtrace (skip 1 frame for this function)
      block->backtrace_count = platform_backtrace(block->backtrace_ptrs, 16);
      // Ensure valid backtrace count
      if (block->backtrace_count < 0) {
        block->backtrace_count = 0;
      }
      block->next = g_mem.head;
      g_mem.head = block;
    }
 
    mutex_unlock(&g_mem.mutex);
  }
 
  g_in_debug_memory = false;
}
 
void debug_free(void *ptr, const char *file, int line) {
  if (!ptr)
    return;
 
  if (g_in_debug_memory) {
    free(ptr);
    return;
  }
 
  g_in_debug_memory = true;
 
  atomic_fetch_add(&g_mem.free_calls, 1);
 
  size_t freed_size = 0;
  bool found = false;
#ifdef _WIN32
  bool was_aligned = false;
#endif
 
  bool have_mutex = ensure_mutex_initialized();
  if (have_mutex) {
    mutex_lock(&g_mem.mutex);
 
    mem_block_t *prev = NULL;
    mem_block_t *curr = g_mem.head;
 
    while (curr) {
      if (curr->ptr == ptr) {
        if (prev) {
          prev->next = curr->next;
        } else {
          g_mem.head = curr->next;
        }
 
        freed_size = curr->size;
        found = true;
#ifdef _WIN32
        was_aligned = curr->is_aligned;
#endif
        free(curr);
        break;
      }
      prev = curr;
      curr = curr->next;
    }
 
    if (!found) {
      log_warn_every(LOG_RATE_FAST, "Freeing untracked pointer %p at %s:%d", ptr, file, line);
      // Don't print backtrace - log_warn_every already rate-limits the warning
    }
 
    mutex_unlock(&g_mem.mutex);
  } else {
    log_warn_every(LOG_RATE_FAST, "Debug memory mutex unavailable while freeing %p at %s:%d", ptr, file, line);
  }
 
  if (found) {
    atomic_fetch_add(&g_mem.total_freed, freed_size);
    atomic_fetch_sub(&g_mem.current_usage, freed_size);
  }
 
#ifdef _WIN32
  if (was_aligned) {
    _aligned_free(ptr);
  } else {
    free(ptr);
  }
#else
  free(ptr);
#endif
 
  g_in_debug_memory = false;
}
 
void *debug_calloc(size_t count, size_t size, const char *file, int line) {
  size_t total = count * size;
  void *ptr = calloc(count, size);
  if (!ptr)
    return NULL;
 
  if (g_in_debug_memory) {
    return ptr;
  }
 
  g_in_debug_memory = true;
 
  atomic_fetch_add(&g_mem.calloc_calls, 1);
  atomic_fetch_add(&g_mem.total_allocated, total);
  size_t new_usage = atomic_fetch_add(&g_mem.current_usage, total) + total;
 
  size_t peak = atomic_load(&g_mem.peak_usage);
  while (new_usage > peak) {
    if (atomic_compare_exchange_weak(&g_mem.peak_usage, &peak, new_usage))
      break;
  }
 
  bool have_mutex = ensure_mutex_initialized();
  if (have_mutex) {
    mutex_lock(&g_mem.mutex);
 
    mem_block_t *block = (mem_block_t *)malloc(sizeof(mem_block_t));
    if (block) {
      block->ptr = ptr;
      block->size = total;
      block->is_aligned = false;
      SAFE_STRNCPY(block->file, file, sizeof(block->file) - 1);
      block->line = line;
      block->next = g_mem.head;
      g_mem.head = block;
    }
 
    mutex_unlock(&g_mem.mutex);
  }
 
  g_in_debug_memory = false;
  return ptr;
}
 
void *debug_realloc(void *ptr, size_t size, const char *file, int line) {
  // Prevent recursion if we're already in debug memory logic
  if (g_in_debug_memory) {
    return realloc(ptr, size);
  }
 
  g_in_debug_memory = true;
 
  // Track number of realloc calls
  atomic_fetch_add(&g_mem.realloc_calls, 1);
 
  // If ptr == NULL, realloc behaves like malloc
  if (ptr == NULL) {
    g_in_debug_memory = false;
    return debug_malloc(size, file, line);
  }
  // If size == 0, realloc behaves like free
  if (size == 0) {
    g_in_debug_memory = false;
    debug_free(ptr, file, line);
    return NULL;
  }
 
  // Look up old allocation size from tracking list
  size_t old_size = 0;
  bool have_mutex = ensure_mutex_initialized();
 
  if (have_mutex) {
    mutex_lock(&g_mem.mutex);
 
    // Find the existing allocation block in the linked list
    mem_block_t *curr = g_mem.head;
    while (curr && curr->ptr != ptr) {
      curr = curr->next;
    }
    if (curr) {
      old_size = curr->size;
    }
 
    mutex_unlock(&g_mem.mutex);
  } else {
    log_warn_every(LOG_RATE_FAST, "Debug memory mutex unavailable while reallocating %p at %s:%d", ptr, file, line);
  }
 
  // Perform actual reallocation
  void *new_ptr = SAFE_REALLOC(ptr, size, void *);
  if (!new_ptr) {
    g_in_debug_memory = false;
    return NULL;
  }
 
  // Update memory statistics based on size change
  if (old_size > 0) {
    // Block was tracked - update statistics
    if (size >= old_size) {
      // Growing: track additional allocation
      size_t delta = size - old_size;
      atomic_fetch_add(&g_mem.total_allocated, delta);
      size_t new_usage = atomic_fetch_add(&g_mem.current_usage, delta) + delta;
 
      // Update peak usage if new usage exceeds previous peak
      size_t peak = atomic_load(&g_mem.peak_usage);
      while (new_usage > peak) {
        if (atomic_compare_exchange_weak(&g_mem.peak_usage, &peak, new_usage))
          break;
      }
    } else {
      // Shrinking: track freed memory
      size_t delta = old_size - size;
      atomic_fetch_add(&g_mem.total_freed, delta);
      atomic_fetch_sub(&g_mem.current_usage, delta);
    }
  } else {
    // Block was not tracked - treat as new allocation
    atomic_fetch_add(&g_mem.total_allocated, size);
    size_t new_usage = atomic_fetch_add(&g_mem.current_usage, size) + size;
 
    // Update peak usage
    size_t peak = atomic_load(&g_mem.peak_usage);
    while (new_usage > peak) {
      if (atomic_compare_exchange_weak(&g_mem.peak_usage, &peak, new_usage))
        break;
    }
  }
 
  // Update tracking list with new pointer and metadata
  if (ensure_mutex_initialized()) {
    mutex_lock(&g_mem.mutex);
 
    // Find existing block in linked list
    mem_block_t *curr = g_mem.head;
    while (curr && curr->ptr != ptr) {
      curr = curr->next;
    }
 
    if (curr) {
      // Update existing block with new metadata
      curr->ptr = new_ptr;
      curr->size = size;
      curr->is_aligned = false;
      SAFE_STRNCPY(curr->file, file, sizeof(curr->file) - 1);
      curr->file[sizeof(curr->file) - 1] = '\0';
      curr->line = line;
    } else {
      // Block not found - create new tracking entry
      mem_block_t *block = (mem_block_t *)malloc(sizeof(mem_block_t));
      if (block) {
        block->ptr = new_ptr;
        block->size = size;
        block->is_aligned = false;
        SAFE_STRNCPY(block->file, file, sizeof(block->file) - 1);
        block->line = line;
        block->next = g_mem.head;
        g_mem.head = block;
      }
    }
 
    mutex_unlock(&g_mem.mutex);
  } else {
    log_warn_every(LOG_RATE_FAST, "Debug memory mutex unavailable while updating realloc block %p -> %p at %s:%d", ptr,
                   new_ptr, file, line);
  }
 
  g_in_debug_memory = false;
  return new_ptr;
}
 
void debug_memory_set_quiet_mode(bool quiet) {
  g_mem.quiet_mode = quiet;
}
 
void debug_memory_report(void) {
  // Guard against multiple calls during shutdown
  static bool report_done = false;
  if (report_done) {
    return;
  }
 
  // Check for usage error BEFORE cleanup clears it
  asciichat_error_t error = GET_ERRNO();
 
  asciichat_errno_destroy();
  report_done = true;
 
  // Skip memory report if an action flag was passed (for clean action output)
  // unless explicitly forced via ASCII_CHAT_MEMORY_DEBUG environment variable
  if (has_action_flag() && !SAFE_GETENV("ASCII_CHAT_MEMORY_DEBUG")) {
    return;
  }
 
  // Skip memory report on command-line usage errors for clean error output
  if (error == ERROR_USAGE) {
    return;
  }
 
  bool quiet = g_mem.quiet_mode;
 
  // Reset ignore counters at start of report
  reset_ignore_counters();
 
  if (!quiet && terminal_is_interactive()) {
    SAFE_IGNORE_PRINTF_RESULT(safe_fprintf(stderr, "\n%s\n", colored_string(LOG_COLOR_DEV, "=== Memory Report ===")));
 
    size_t total_allocated = atomic_load(&g_mem.total_allocated);
    size_t total_freed = atomic_load(&g_mem.total_freed);
    size_t current_usage = atomic_load(&g_mem.current_usage);
    size_t peak_usage = atomic_load(&g_mem.peak_usage);
    size_t malloc_calls = atomic_load(&g_mem.malloc_calls);
    size_t calloc_calls = atomic_load(&g_mem.calloc_calls);
    size_t free_calls = atomic_load(&g_mem.free_calls);
 
    // Calculate total size and count of suppressed allocations
    size_t suppressed_bytes = 0;
    size_t suppressed_count = 0;
    if (g_mem.head) {
      if (ensure_mutex_initialized()) {
        // Use polling instead of blocking mutex_lock to avoid hangs during shutdown.
        if (!acquire_mutex_with_polling(&g_mem.mutex, 100)) {
          goto skip_memory_iter;
        }
 
        // Now we have the lock - iterate memory blocks
        mem_block_t *curr = g_mem.head;
        while (curr) {
          if (should_ignore_allocation(curr->file, curr->line)) {
            suppressed_bytes += curr->size;
            suppressed_count++;
          }
          curr = curr->next;
        }
        mutex_unlock(&g_mem.mutex);
      }
    }
 
  skip_memory_iter:
 
    // Adjust current usage to exclude suppressed allocations
    size_t adjusted_current_usage = (current_usage >= suppressed_bytes) ? (current_usage - suppressed_bytes) : 0;
 
    // Adjust total allocated for display to exclude suppressions (so it matches total freed)
    size_t adjusted_total_allocated =
        (total_allocated >= suppressed_bytes) ? (total_allocated - suppressed_bytes) : total_allocated;
 
    // Reset ignore counters after counting suppressed bytes
    reset_ignore_counters();
 
    // Count actual unfreed allocations early so we can use it to filter suppression warnings
    size_t unfreed_count = 0;
    if (g_mem.head) {
      if (ensure_mutex_initialized()) {
        if (acquire_mutex_with_polling(&g_mem.mutex, 100)) {
          mem_block_t *curr = g_mem.head;
          while (curr) {
            if (!should_ignore_allocation(curr->file, curr->line)) {
              unfreed_count++;
            }
            curr = curr->next;
          }
          mutex_unlock(&g_mem.mutex);
        }
      }
    }
 
    // Only warn about suppression mismatches if there are outstanding allocations
    if (unfreed_count > 0) {
      for (size_t i = 0; g_ignore_list[i].file != NULL; i++) {
        if (g_ignore_counts[i] != g_ignore_list[i].expected_count) {
          SAFE_IGNORE_PRINTF_RESULT(
              safe_fprintf(stderr, "%s\n", colored_string(LOG_COLOR_ERROR, "WARNING: Suppression mismatch detected")));
          SAFE_IGNORE_PRINTF_RESULT(safe_fprintf(stderr, "  %s:%d - expected %d, found %d\n", g_ignore_list[i].file,
                                                 g_ignore_list[i].line, g_ignore_list[i].expected_count,
                                                 g_ignore_counts[i]));
        }
      }
    }
 
    char pretty_total[64];
    char pretty_freed[64];
    char pretty_current[64];
    char pretty_peak[64];
    format_bytes_pretty(adjusted_total_allocated, pretty_total, sizeof(pretty_total));
    format_bytes_pretty(total_freed, pretty_freed, sizeof(pretty_freed));
    format_bytes_pretty(adjusted_current_usage, pretty_current, sizeof(pretty_current));
    format_bytes_pretty(peak_usage, pretty_peak, sizeof(pretty_peak));
 
    // Calculate max label width for column alignment
    const char *label_total = "Total allocated:";
    const char *label_freed = "Total freed:";
    const char *label_current = "Current usage:";
    const char *label_peak = "Peak usage:";
    const char *label_malloc = "malloc calls:";
    const char *label_calloc = "calloc calls:";
    const char *label_free = "free calls:";
    const char *label_suppressions = "suppressions:";
    const char *label_diff = "unfreed allocations:";
 
    size_t max_label_width = 0;
    max_label_width = MAX(max_label_width, strlen(label_total));
    max_label_width = MAX(max_label_width, strlen(label_freed));
    max_label_width = MAX(max_label_width, strlen(label_current));
    max_label_width = MAX(max_label_width, strlen(label_peak));
    max_label_width = MAX(max_label_width, strlen(label_malloc));
    max_label_width = MAX(max_label_width, strlen(label_calloc));
    max_label_width = MAX(max_label_width, strlen(label_free));
    max_label_width = MAX(max_label_width, strlen(label_suppressions));
    max_label_width = MAX(max_label_width, strlen(label_diff));
 
#define PRINT_MEM_LINE(label, value_str)                                                                               \
  do {                                                                                                                 \
    SAFE_IGNORE_PRINTF_RESULT(safe_fprintf(stderr, "%s", colored_string(LOG_COLOR_GREY, label)));                      \
    for (size_t i = strlen(label); i < max_label_width; i++) {                                                         \
      SAFE_IGNORE_PRINTF_RESULT(safe_fprintf(stderr, " "));                                                            \
    }                                                                                                                  \
    SAFE_IGNORE_PRINTF_RESULT(safe_fprintf(stderr, " %s\n", value_str));                                               \
  } while (0)
 
#define PRINT_MEM_LINE_COLORED(label, value_str, color)                                                                \
  do {                                                                                                                 \
    SAFE_IGNORE_PRINTF_RESULT(safe_fprintf(stderr, "%s", colored_string(LOG_COLOR_GREY, label)));                      \
    for (size_t i = strlen(label); i < max_label_width; i++) {                                                         \
      SAFE_IGNORE_PRINTF_RESULT(safe_fprintf(stderr, " "));                                                            \
    }                                                                                                                  \
    SAFE_IGNORE_PRINTF_RESULT(safe_fprintf(stderr, " %s\n", colored_string(color, value_str)));                        \
  } while (0)
 
    // Colorize total allocated/freed: green if they match, red if they don't (memory leak)
    // We've already adjusted allocated to exclude suppressions, so now compare directly
    log_color_t alloc_freed_color = (adjusted_total_allocated == total_freed) ? LOG_COLOR_INFO : LOG_COLOR_ERROR;
    PRINT_MEM_LINE_COLORED(label_total, pretty_total, alloc_freed_color);
    PRINT_MEM_LINE_COLORED(label_freed, pretty_freed, alloc_freed_color);
 
    // Colorize current usage: green if 0 (no leaks), red if any unfreed memory (leak detected)
    log_color_t current_color = (adjusted_current_usage == 0) ? LOG_COLOR_INFO : LOG_COLOR_ERROR;
    PRINT_MEM_LINE_COLORED(label_current, pretty_current, current_color);
 
    // Colorize peak usage: green if 0-50 MB, yellow if 50-80 MB, red if above 80 MB
    log_color_t peak_color = LOG_COLOR_INFO; // Default green
    if (peak_usage >= (80 * 1024 * 1024)) {
      peak_color = LOG_COLOR_ERROR; // Red if >= 80 MB
    } else if (peak_usage >= (50 * 1024 * 1024)) {
      peak_color = LOG_COLOR_WARN; // Yellow if >= 50 MB
    }
    PRINT_MEM_LINE_COLORED(label_peak, pretty_peak, peak_color);
 
    // unfreed_count already calculated earlier for suppression warning filtering
 
    // Colorize malloc/calloc/free calls: green if unfreed == 0, red if unfreed != 0
    log_color_t calls_color = (unfreed_count == 0) ? LOG_COLOR_INFO : LOG_COLOR_ERROR;
    char malloc_str[32];
    safe_snprintf(malloc_str, sizeof(malloc_str), "%zu", malloc_calls);
    PRINT_MEM_LINE_COLORED(label_malloc, malloc_str, calls_color);
 
    char calloc_str[32];
    safe_snprintf(calloc_str, sizeof(calloc_str), "%zu", calloc_calls);
    PRINT_MEM_LINE_COLORED(label_calloc, calloc_str, calls_color);
 
    char free_str[32];
    safe_snprintf(free_str, sizeof(free_str), "%zu", free_calls);
    PRINT_MEM_LINE_COLORED(label_free, free_str, calls_color);
 
    // Colorize suppressions: green if working properly, red if >= 1MB or >= 100 allocations
    if (suppressed_count > 0) {
      char pretty_suppressed[64];
      format_bytes_pretty(suppressed_bytes, pretty_suppressed, sizeof(pretty_suppressed));
      char suppressions_str[128];
      safe_snprintf(suppressions_str, sizeof(suppressions_str), "%zu (%s)", suppressed_count, pretty_suppressed);
 
      log_color_t suppressions_color = LOG_COLOR_INFO; // Green by default (working properly)
      if (suppressed_bytes >= (1024 * 1024) || suppressed_count >= 100) {
        suppressions_color = LOG_COLOR_ERROR; // Red if >= 1MB or >= 100 allocations
      }
      PRINT_MEM_LINE_COLORED(label_suppressions, suppressions_str, suppressions_color);
    }
 
    char diff_str[32];
    safe_snprintf(diff_str, sizeof(diff_str), "%zu", unfreed_count);
    SAFE_IGNORE_PRINTF_RESULT(safe_fprintf(stderr, "%s", colored_string(LOG_COLOR_GREY, label_diff)));
    for (size_t i = strlen(label_diff); i < max_label_width; i++) {
      SAFE_IGNORE_PRINTF_RESULT(safe_fprintf(stderr, " "));
    }
    SAFE_IGNORE_PRINTF_RESULT(
        safe_fprintf(stderr, " %s\n", colored_string(unfreed_count == 0 ? LOG_COLOR_INFO : LOG_COLOR_ERROR, diff_str)));
 
#undef PRINT_MEM_LINE
#undef PRINT_MEM_LINE_COLORED
 
    // Only show "Current allocations:" section if there are actual leaks
    if (unfreed_count > 0) {
      // Reset counters before printing pass (after counting pass used them)
      reset_ignore_counters();
 
      // Print "Current allocations:" header (count already shown in "unfreed allocations" above)
      SAFE_IGNORE_PRINTF_RESULT(safe_fprintf(stderr, "\n%s\n", colored_string(LOG_COLOR_DEV, "Current allocations:")));
    }
 
    if (g_mem.head && unfreed_count > 0) {
      if (ensure_mutex_initialized()) {
        if (!acquire_mutex_with_polling(&g_mem.mutex, 100)) {
          goto skip_allocations_list;
        }
 
        // Check if we should print backtraces
        const char *print_backtrace = SAFE_GETENV("ASCII_CHAT_MEMORY_REPORT_BACKTRACE");
        int backtrace_count = 0;
        int backtrace_limit = (print_backtrace != NULL) ? 5 : 0; // Only print first 5 backtraces to save time
 
        mem_block_t *curr = g_mem.head;
        while (curr) {
          // Skip ignored allocations (e.g., PCRE2 singletons)
          if (should_ignore_allocation(curr->file, curr->line)) {
            curr = curr->next;
            continue;
          }
 
          char pretty_size[64];
          format_bytes_pretty(curr->size, pretty_size, sizeof(pretty_size));
          const char *file_location = curr->file; // Already normalized relative path
 
          // Determine color based on unit (1 MB and over=red, KB=yellow, B=light blue)
          log_color_t size_color = LOG_COLOR_DEBUG; // Default to light blue for bytes
          if (strstr(pretty_size, "MB") || strstr(pretty_size, "GB") || strstr(pretty_size, "TB") ||
              strstr(pretty_size, "PB") || strstr(pretty_size, "EB")) {
            size_color = LOG_COLOR_ERROR; // Red for 1 MB and over (MB, GB, TB, PB, EB)
          } else if (strstr(pretty_size, "KB")) {
            size_color = LOG_COLOR_WARN; // Yellow for kilobytes
          } else if (strstr(pretty_size, " B")) {
            size_color = LOG_COLOR_DEBUG; // Light blue for bytes
          }
 
          char line_str[32];
          safe_snprintf(line_str, sizeof(line_str), "%d", curr->line);
          SAFE_IGNORE_PRINTF_RESULT(
              safe_fprintf(stderr, "  - %s:%s - %s\n", colored_string(LOG_COLOR_GREY, file_location),
                           colored_string(LOG_COLOR_FATAL, line_str), colored_string(size_color, pretty_size)));
 
          // Print backtrace if environment variable is set and we haven't hit the limit
          if (backtrace_count < backtrace_limit && curr->backtrace_count > 0) {
            backtrace_count++;
            // Unlock mutex before calling platform_backtrace_symbols to avoid deadlock
            // when backtrace symbol resolution allocates memory.
            mutex_unlock(&g_mem.mutex);
 
            // Print backtrace with symbol names
            char **symbols = platform_backtrace_symbols(curr->backtrace_ptrs, curr->backtrace_count);
            if (symbols) {
              SAFE_IGNORE_PRINTF_RESULT(safe_fprintf(stderr, "    Backtrace (%d frames):\n", curr->backtrace_count));
              for (int i = 0; i < curr->backtrace_count; i++) {
                SAFE_IGNORE_PRINTF_RESULT(safe_fprintf(stderr, "      [%d] %s\n", i, symbols[i]));
              }
              platform_backtrace_symbols_destroy(symbols);
            }
 
            // Re-acquire mutex for next iteration (with polling, not blocking)
            if (!acquire_mutex_with_polling(&g_mem.mutex, 100)) {
              break; // Exit loop if we can't re-acquire the lock
            }
          }
 
          curr = curr->next;
        }
 
        mutex_unlock(&g_mem.mutex);
      } else {
        SAFE_IGNORE_PRINTF_RESULT(
            safe_fprintf(stderr, "\n%s\n",
                         colored_string(LOG_COLOR_ERROR,
                                        "Current allocations unavailable: failed to initialize debug memory mutex")));
      }
    }
 
  skip_allocations_list:
  }
}
 
#elif defined(DEBUG_MEMORY)
 
void debug_memory_set_quiet_mode(bool quiet) {
  (void)quiet;
}
 
void debug_memory_report(void) {}
 
void *debug_malloc(size_t size, const char *file, int line) {
  (void)file;
  (void)line;
  return malloc(size);
}
 
void *debug_calloc(size_t count, size_t size, const char *file, int line) {
  (void)file;
  (void)line;
  return calloc(count, size);
}
 
void *debug_realloc(void *ptr, size_t size, const char *file, int line) {
  (void)file;
  (void)line;
  return realloc(ptr, size);
}
 
void debug_free(void *ptr, const char *file, int line) {
  (void)file;
  (void)line;
  free(ptr);
}
 
void debug_track_aligned(void *ptr, size_t size, const char *file, int line) {
  (void)ptr;
  (void)size;
  (void)file;
  (void)line;
}
 
#endif