# Alpine (musl) 环境
$ apk add gdb strace ltrace musl-dbg

# Ubuntu (glibc) 环境
$ sudo apt install gdb strace ltrace libc6-dbg valgrind

# 通用调试工具（两者都可用）
$ which gdb strace ltrace perf

# 两者通用的调试编译选项
$ gcc -g -O0 -o debug_program debug_program.c
$ musl-gcc -g -O0 -o debug_program debug_program.c

# 推荐的调试编译选项
$ gcc -g3 -O0 -fno-omit-frame-pointer \
    -fsanitize=address \
    -o debug_program debug_program.c

# musl 静态链接但带调试信息
$ musl-gcc -g -O0 -static -o debug_static debug_program.c

/* debug_example.c — 调试示例程序 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct Node {
    int data;
    struct Node *next;
} Node;

Node *create_node(int data) {
    Node *n = malloc(sizeof(Node));
    n->data = data;
    n->next = NULL;
    return n;
}

void free_list(Node *head) {
    /* 故意的 bug：不释放当前节点 */
    while (head) {
        Node *next = head->next;
        head = next;  /* 应该先 free(head) */
    }
}

int compute(int n) {
    if (n <= 0) return 0;
    return n + compute(n - 1);  /* 递归可能导致栈溢出 */
}

int main() {
    /* 创建链表 */
    Node *head = create_node(1);
    head->next = create_node(2);
    head->next->next = create_node(3);

    printf("Sum: %d\n", compute(100));

    free_list(head);  /* 内存泄漏 */
    return 0;
}

# 两者都可以使用 GDB
$ gdb ./debug_program

# GDB 命令通用
(gdb) break main
(gdb) run
(gdb) next
(gdb) print head->data
(gdb) backtrace
(gdb) info locals
(gdb) continue

# glibc 环境下 GDB 会加载 glibc 调试符号
(gdb) info sharedlibrary
# From                To                  Syms Read   Shared Object Library
# 0x00007ffff7dc1280  0x00007ffff7f48890  Yes         /lib/x86_64-linux-gnu/libc.so.6
# 0x00007ffff7fae280  0x00007ffff7fc9270  Yes         /lib64/ld-linux-x86-64.so.2

# musl 环境下
(gdb) info sharedlibrary
# From                To                  Syms Read   Shared Object Library
# 0x00007ffff7fd4000  0x00007ffff7fe9200  Yes         /lib/ld-musl-x86_64.so.1

# 安装 musl 调试符号
$ apk add musl-dbg

# musl-dbg 安装了什么
$ apk info -L musl-dbg
# /usr/lib/debug/lib/ld-musl-x86_64.so.1.debug

# GDB 现在可以显示 musl 内部函数名
(gdb) bt
#0  __syscall4 (n=14, a1=0, a2=0, a3=0, a4=0) at src/internal/syscall.h:50
#1  __timedwait (addr=0x7ffff7feb800, val=0, clk=0, ...)
#2  0x00007ffff7fe2100 in __pthread_timedjoin_np (...)
#3  0x00007ffff7fe3045 in pthread_join (...)

# 静态链接程序的调试
$ musl-gcc -g -static -o debug_static debug_program.c

$ gdb ./debug_static
(gdb) break main
(gdb) run
(gdb) bt
#0  main() at debug_program.c:35
# 静态链接时所有符号都在一个可执行文件中
# 不需要额外的 .debug 文件

/* glibc 独有的 backtrace 支持 */
#include <execinfo.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>

static void handler(int sig) {
    void *buffer[100];
    int nptrs = backtrace(buffer, 100);
    char **strings = backtrace_symbols(buffer, nptrs);

    fprintf(stderr, "\n=== Signal %d: Backtrace ===\n", sig);
    for (int i = 0; i < nptrs; i++) {
        fprintf(stderr, "  [%d] %s\n", i, strings[i]);
    }
    fprintf(stderr, "===========================\n");

    free(strings);
    _exit(1);
}

void func_c(void) {
    int *p = NULL;
    *p = 42;  /* 触发 SIGSEGV */
}

void func_b(void) { func_c(); }
void func_a(void) { func_b(); }

int main() {
    signal(SIGSEGV, handler);
    func_a();
    return 0;
}

# glibc 输出示例
$ gcc -g -rdynamic -o bt_glibc backtrace.c && ./bt_glibc

=== Signal 11: Backtrace ===
  [0] ./bt_glibc(handler+0x2f) [0x401234]
  [1] /lib/x86_64-linux-gnu/libc.so.6(+0x42520) [0x7f...]
  [2] ./bt_glibc(func_c+0x14) [0x401300]
  [3] ./bt_glibc(func_b+0x9) [0x401310]
  [4] ./bt_glibc(func_a+0x9) [0x401320]
  [5] ./bt_glibc(main+0x9) [0x401330]
  [6] /lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf3) [0x7f...]
===========================

/* musl 可用的 backtrace 替代方案 */
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <dlfcn.h>

/* 方案 1：使用 _Unwind_Backtrace (GCC 内置) */
#include <unwind.h>

static _Unwinder_Reason trace_callback(struct _Unwind_Context *ctx, void *arg) {
    int *depth = (int *)arg;
    void *ip = (void *)_Unwind_GetIP(ctx);
    if (ip) {
        Dl_info info;
        if (dladdr(ip, &info)) {
            fprintf(stderr, "  [%d] %s (%s+0x%lx) [%p]\n",
                    (*depth)++,
                    info.dli_fname ?: "?",
                    info.dli_sname ?: "?",
                    (unsigned long)((char *)ip - (char *)info.dli_saddr),
                    ip);
        } else {
            fprintf(stderr, "  [%d] [%p]\n", (*depth)++, ip);
        }
    }
    return _URC_NO_REASON;
}

static void print_backtrace(void) {
    int depth = 0;
    fprintf(stderr, "Backtrace:\n");
    _Unwind_Backtrace(trace_callback, &depth);
}

/* 方案 2：使用 -rdynamic + 帧指针回溯 */
#ifdef __x86_64__
static void frame_pointer_backtrace(void) {
    void **rbp;
    __asm__ volatile("mov %%rbp, %0" : "=r"(rbp));

    fprintf(stderr, "Frame pointer backtrace:\n");
    int i = 0;
    while (rbp && rbp[1] && i < 20) {
        void *ret_addr = rbp[1];
        Dl_info info;
        if (dladdr(ret_addr, &info)) {
            fprintf(stderr, "  [%d] %s (%s) [%p]\n",
                    i++, info.dli_fname ?: "?",
                    info.dli_sname ?: "?", ret_addr);
        } else {
            fprintf(stderr, "  [%d] [%p]\n", i++, ret_addr);
        }
        rbp = (void **)rbp[0];  /* 上一个栈帧 */
    }
}
#endif

static void handler(int sig) {
    fprintf(stderr, "\n=== Signal %d ===\n", sig);
    print_backtrace();
    _exit(1);
}

void func_c(void) {
    int *p = NULL;
    *p = 42;
}

void func_b(void) { func_c(); }
void func_a(void) { func_b(); }

int main() {
    signal(SIGSEGV, handler);
    func_a();
    return 0;
}

/*
 * 编译（需要 -rdynamic 和 -funwind-tables）：
 * $ musl-gcc -g -rdynamic -funwind-tables -o bt_musl backtrace_musl.c
 * $ musl-gcc -g -rdynamic -fno-omit-frame-pointer -o bt_musl_fp backtrace_musl.c
 */

# 安装 libunwind
$ apk add libunwind-dev

# 编译使用 libunwind
$ cat > bt_libunwind.c << 'EOF'
#define UNW_LOCAL_ONLY
#include <libunwind.h>
#include <stdio.h>

void print_backtrace(void) {
    unw_cursor_t cursor;
    unw_context_t context;

    unw_getcontext(&context);
    unw_init_local(&cursor, &context);

    int n = 0;
    while (unw_step(&cursor) > 0) {
        unw_word_t ip, sp;
        char sym[256];
        unw_word_t offset;

        unw_get_reg(&cursor, UNW_REG_IP, &ip);
        unw_get_reg(&cursor, UNW_REG_SP, &sp);

        if (unw_get_proc_name(&cursor, sym, sizeof(sym), &offset) == 0) {
            printf("  [%d] %s (+0x%lx) [0x%lx]\n", n++, sym, (long)offset, (long)ip);
        } else {
            printf("  [%d] [0x%lx]\n", n++, (long)ip);
        }
    }
}
EOF

$ musl-gcc -g -rdynamic -o bt_libunwind bt_libunwind.c -lunwind

# Valgrind 在 glibc 上支持最完整
$ valgrind --leak-check=full --show-leak-kinds=all ./debug_program

# Valgrind 在 musl 上也能工作，但可能有更多误报
$ valgrind --leak-check=full ./debug_program

# Valgrind suppressions for musl
$ cat > musl.supp << 'EOF'
{
   musl_tls_dtor
   Memcheck:Leak
   match-leak-kinds: reachable
   fun:calloc
   fun:__init_libc
   ...
}
{
   musl_locale
   Memcheck:Leak
   match-leak-kinds: reachable
   fun:malloc
   fun:setlocale
   ...
}
EOF

$ valgrind --suppressions=musl.supp --leak-check=full ./debug_program

# glibc 提供 memusage 工具
$ memusage ./program
# glibc 独有

# musl 替代：使用 massif
$ valgrind --tool=massif ./program
$ ms_print massif.out.*

# glibc 的 mtrace 内存泄漏检测
$ export MALLOC_TRACE=/tmp/mtrace.log
$ gcc -o program program.c
$ ./program
$ mtrace program /tmp/mtrace.log

# musl 不支持 mtrace，使用 Valgrind 替代
$ valgrind --leak-check=full --log-file=valgrind.log ./program

# strace 用法相同
$ strace -f -e trace=network ./program
$ strace -c ./program  # 统计系统调用

# 但 musl 和 glibc 的系统调用模式可能不同
# 例如：内存分配
# glibc: brk(), mmap(), mremap()
# musl:  mmap() 为主（很少用 brk）

# 观察 DNS 解析的系统调用差异

# glibc DNS 解析
$ strace -e trace=network,file getent hosts example.com 2>&1 | head -30
# openat(AT_FDCWD, "/etc/nsswitch.conf", ...) = 3
# openat(AT_FDCWD, "/etc/hosts", ...) = 3
# openat(AT_FDCWD, "/etc/resolv.conf", ...) = 3
# socket(AF_INET, SOCK_DGRAM, IPPROTO_IP) = 3
# sendto(3, ..., 8.8.8.8#53) = ...

# musl DNS 解析
$ strace -e trace=network,file getent hosts example.com 2>&1 | head -30
# openat(AT_FDCWD, "/etc/hosts", ...) = 3
# openat(AT_FDCWD, "/etc/resolv.conf", ...) = 3
# socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC, IPPROTO_IP) = 3
# sendto(3, ..., 8.8.8.8#53) = ...
# 注意：musl 不读取 nsswitch.conf

# glibc 线程创建
$ strace -e trace=clone,clone3,mmap ./thread_program 2>&1 | head
# clone3({flags=..., stack_size=8388608, ...}) = 12345
# 注意：glibc 请求 8MB 栈

# musl 线程创建
$ strace -e trace=clone,clone3,mmap ./thread_program 2>&1 | head
# mmap(NULL, 139264, ...) = 0x7f...
# clone3({flags=..., stack_size=131072, ...}) = 12345
# 注意：musl 请求 128KB 栈

# glibc 环境下 ltrace
$ ltrace ./program
# __libc_start_main(0x401136, 1, 0x7ffd...) = 0
# printf("Hello %s\n", "World") = 12
# malloc(100) = 0x5555...
# free(0x5555...) = <void>

# musl 环境下 ltrace 可能不工作
$ ltrace ./program
# 可能输出为空或报错

# 原因：ltrace 依赖特定的 PLT（Procedure Linkage Table）格式
# musl 的 PLT 实现与 glibc 不同

# 方案 1：使用 eBPF/bpftrace
$ bpftrace -e 'uprobe:/lib/ld-musl-x86_64.so.1:malloc { printf("malloc %d\n", arg0); }'

# 方案 2：使用 LD_PRELOAD hook
$ cat > hook.c << 'EOF'
#define _GNU_SOURCE
#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>

static void *(*real_malloc)(size_t) = NULL;

void *malloc(size_t size) {
    if (!real_malloc)
        real_malloc = dlsym(RTLD_NEXT, "malloc");
    void *ptr = real_malloc(size);
    fprintf(stderr, "malloc(%zu) = %p\n", size, ptr);
    return ptr;
}
EOF

$ gcc -shared -fPIC -o hook.so hook.c -ldl
$ LD_PRELOAD=./hook.so ./program

# 方案 3：使用 GDB 的 catchpoint
$ gdb ./program
(gdb) catch syscall open
(gdb) catch syscall mmap
(gdb) run

# ASan 在 glibc 上支持更完整
$ gcc -fsanitize=address -g -o asan_program debug_program.c
$ ./asan_program
# ==12345==ERROR: AddressSanitizer: heap-use-after-free ...

# ASan 在 musl 上也能工作，但可能需要额外配置
$ musl-gcc -fsanitize=address -g -o asan_program debug_program.c
# 可能的警告：
# "ASan is not compatible with musl libc"

# 替代方案：使用 Valgrind Memcheck
$ valgrind --tool=memcheck --leak-check=full ./program

/* 手动内存检查 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* 简单的 debug malloc 封装 */
#ifdef DEBUG_MALLOC
typedef struct {
    size_t size;
    const char *file;
    int line;
    int magic;
} DebugHeader;

#define MAGIC 0xDEADBEEF
#define malloc(s) debug_malloc(s, __FILE__, __LINE__)
#define free(p) debug_free(p, __FILE__, __LINE__)

void *debug_malloc(size_t size, const char *file, int line) {
    DebugHeader *h = (DebugHeader *)malloc(size + sizeof(DebugHeader));
    if (!h) return NULL;
    h->size = size;
    h->file = file;
    h->line = line;
    h->magic = MAGIC;
    return (char *)h + sizeof(DebugHeader);
}

void debug_free(void *ptr, const char *file, int line) {
    if (!ptr) return;
    DebugHeader *h = (DebugHeader *)((char *)ptr - sizeof(DebugHeader));
    if (h->magic != MAGIC) {
        fprintf(stderr, "ERROR: Invalid free at %s:%d\n", file, line);
        return;
    }
    h->magic = 0;
    free(h);
}
#endif

# 两者都可以使用 perf
$ perf record -g ./program
$ perf report

# 分析 libc 函数耗时
$ perf record -g ./program
$ perf report --sort=dso
# 可以看到 libc.so / ld-musl 的函数占比

# 分析特定函数
$ perf annotate -s memcpy
# glibc：可以看到 AVX/AVX2 变体
# musl：可以看到通用 C 实现

# 生成火焰图
$ perf record -g -F 99 ./program
$ perf script | stackcollapse-perf.pl | flamegraph.pl > flamegraph.svg

# 在浏览器中打开 flamegraph.svg
# 可以看到 libc 函数在调用栈中的占比

# 静态链接程序可能缺少某些调试信息
$ musl-gcc -g -static -o program_static program.c

# 调试时 libc 函数名可能不可见
$ gdb ./program_static
(gdb) bt
#0  0x000000000048c230 in ?? ()       # musl 内部函数无符号
#1  0x000000000048c350 in ?? ()
#2  0x0000000000401234 in main() at program.c:10

# 解决方案：使用完整调试信息
$ musl-gcc -g3 -static -o program_static program.c

# 或者使用 rdynamic
$ musl-gcc -g -static -rdynamic -o program_static program.c

# 生产环境 strip 后保留调试符号
$ musl-gcc -g -static -o program program.c
$ objcopy --only-keep-debug program program.debug
$ strip program

# 运行时调试
$ gdb -s program.debug -e program -c core

# 使用 glibc 进行开发和调试（工具支持最完整）
$ gcc -g3 -O0 -fsanitize=address,undefined -o debug_program program.c
$ ./debug_program

# 使用 ASan 和 UBSan 检测问题
# 这些工具在 glibc 上支持最好

# 生产环境使用 musl 静态链接
$ musl-gcc -O2 -static -o program program.c
$ strip program

# 保留调试符号文件
$ objcopy --only-keep-debug program program.debug
$ eu-unstrip program program.debug  # 重新关联（如果需要）

# 启用 core dump
$ ulimit -c unlimited

# 运行程序
$ ./program
Segmentation fault (core dumped)

# 分析 core dump
$ gdb ./program core
(gdb) bt
(gdb) info registers
(gdb) print *ptr
(gdb) list

# 静态链接程序的 core dump 分析更容易
# 因为所有符号都在一个文件中