Skip to content

gdb 使用 ​

Linux 下的 C/C++ 调试器。核心场景就三个:程序崩溃(段错误)、卡死(死锁)、结果不对。线上没日志时,靠 core dump + gdb 定位是基本功。

命令普遍支持缩写:r=run、c=continue、n=next、s=step、b=break、p=print、bt=backtrace、l=list。

一、编译准备 ​

bash
g++ -g -O0 app.cpp -o app          # -g 生成调试信息,-O0 关闭优化
g++ -g -O0 -fsanitize=address app.cpp -o app   # 额外开 ASan,内存越界能直接报行号

-O2 下调试的痛苦:断点乱跳、变量显示 <optimized out>、函数被内联导致 bt 栈帧缺失、循环被展开。复现 bug 用 -O0 -g;分析线上 core 必须用带 -g 编译的同一版本。

二、三种启动方式 ​

bash
gdb ./app                       # 1. 直接启动并调试
gdb ./app core.1234             # 2. 加载 core 文件,事后分析崩溃现场
gdb -p 1234                     # 3. attach 到正在运行的进程(卡死、死锁时用)
gdb --args ./app --port 8080    # 4. 带命令行参数启动
gdb -batch -ex run -ex bt ./app # 5. 非交互:跑一次,崩溃就打印栈

退出:quit(q)。attach 模式退出时进程会被 detach,不会杀进程。

三、断点 ​

bash
(gdb) b main                    # 在 main 函数入口下断点
(gdb) b list.cpp:42             # 在 list.cpp 第 42 行下断点
(gdb) b Node::next              # 在某个类的方法上下断点(支持 C++ 名字)
(gdb) b func if x > 10          # 条件断点:只有 x > 10 才停,避免停一百次
(gdb) b list.cpp:42 if p == nullptr   # 行断点 + 条件,常用于空指针
(gdb) tbreak list.cpp:42        # 临时断点:命中一次后自动删除
(gdb) rbreak ^Node::            # 正则批量下断:所有 Node:: 开头的方法
(gdb) watch var                 # 观察点:var 被写时停下(查「谁改了我的变量」)
(gdb) rwatch var                # 读观察点:var 被读时停下
(gdb) catch throw               # 捕获 C++ 异常抛出
(gdb) catch syscall open        # 捕获系统调用 open
(gdb) info breakpoints          # 查看所有断点及编号
(gdb) delete 2                  # 删除 2 号断点(delete 不带编号删除全部)
(gdb) disable 2                 # 禁用 2 号断点(保留但不停)
(gdb) enable 2                  # 重新启用

四、运行控制 ​

bash
(gdb) run                       # 开始运行(可带参数:run --port 8080)
(gdb) continue                  # 继续到下一个断点(c)
(gdb) next                      # 单步,跳过函数调用(n)
(gdb) step                      # 单步,进入函数内部(s)
(gdb) finish                    # 执行到当前函数返回,并打印返回值
(gdb) until 50                  # 执行到第 50 行(常用于跳出循环)
(gdb) advance list.cpp:80       # 运行到指定位置(会跳过循环)
(gdb) return 0                  # 强制当前函数立即返回 0(跳过剩余逻辑)
(gdb) jump 60                   # 跳到第 60 行继续执行(危险,慎用)

五、看栈、变量、内存 ​

bash
(gdb) bt                        # 打印调用栈(backtrace),#0 是当前帧
(gdb) bt full                   # 每帧带局部变量,信息更全
(gdb) frame 3                   # 切到 3 号栈帧(f 3)
(gdb) up                        # 向调用者方向上一层
(gdb) down                      # 向被调用者方向下一层
(gdb) info frame                # 当前帧的详细信息(返回地址、参数、局部变量)

(gdb) p var                     # 打印变量
(gdb) p *ptr                    # 解引用指针
(gdb) p arr[2]@5                # 从 arr[2] 开始打印 5 个元素(查数组越界神器)
(gdb) p/x var                   # 十六进制显示
(gdb) p/d var                   # 十进制显示
(gdb) p/s ptr                   # 当字符串显示
(gdb) p this                    # C++ 成员函数里查对象地址
(gdb) ptype var                 # 查看变量类型定义
(gdb) info locals               # 当前帧所有局部变量
(gdb) info args                 # 当前函数参数
(gdb) info registers            # 寄存器;崩溃时重点看 rip(下一条指令)、rsp(栈顶)

(gdb) x/10gx ptr                # 从 ptr 开始看 10 个 8 字节,十六进制
                                # g=8 字节,w=4 字节,h=2 字节,b=1 字节
(gdb) x/20wx arr                # 20 个 4 字节字
(gdb) x/s str                   # 按字符串查看
(gdb) x/10i $rip                # 反汇编当前指令附近的 10 条
(gdb) list                      # 显示当前行附近的源码(l)
(gdb) disassemble /m func       # 反汇编并混排源码

六、多线程:查卡死 / 死锁 ​

bash
(gdb) info threads                  # 列出所有线程,* 是当前线程
(gdb) thread 3                      # 切到 3 号线程
(gdb) thread apply all bt           # 所有线程的调用栈(死锁排查第一招)
(gdb) thread apply all bt full      # 带局部变量,看谁持锁、谁在等锁
(gdb) set scheduler-locking on      # 调试时锁住调度,避免其他线程乱跑
(gdb) set scheduler-locking off     # 恢复

死锁特征:多个线程都停在 pthread_mutex_lock / std::mutex::lock,且各自持有对方想要的锁。配合 thread apply all bt 就能看出循环等待。

不启动 gdb 也能看:pstack PID 等价于 gdb -p PID 后 thread apply all bt。

七、段错误定位流程 ​

bash
ulimit -c unlimited              # 1. 当前 shell 允许生成 core(默认常是 0)
./app                            # 2. 运行,崩溃后生成 core.PID
gdb ./app core.PID               # 3. 用可执行文件 + core 还原现场
(gdb) bt                         # 4. 看崩溃栈
# #0  Node::next (this=0x0) at list.cpp:15   ← 出事的帧
# #1  main () at main.cpp:9                  ← 调用者
(gdb) frame 0                    # 5. 切到崩溃帧
(gdb) info locals                # 6. 看局部变量
(gdb) p this                     # $1 = (Node *) 0x0   ← 空指针实锤
(gdb) p *this                    # 会提示 Cannot access memory,进一步确认

判断思路:先 bt 找 #0(真正崩的那一行),检查指针是否为 0x0 或野值,再看 #1 是谁把坏参数传进来的。常见原因:空指针、野指针(对象已析构)、数组越界、栈溢出(递归太深)。

八、core dump 配置 ​

bash
ulimit -c unlimited                              # 当前 shell 生效;写进 ~/.bashrc 可持久化
ulimit -c                                        # 查看当前值,0 表示不生成
cat /proc/sys/kernel/core_pattern                # 看 core 文件命名和存放位置
sudo sysctl -w kernel.core_pattern=/var/core/core.%e.%p.%t   # 临时修改
echo 'kernel.core_pattern=/var/core/core.%e.%p.%t' | sudo tee /etc/sysctl.d/90-core.conf
                                                 # 永久修改(重启后仍生效)
sudo sysctl -p /etc/sysctl.d/90-core.conf        # 立即加载

占位符:%e 程序名 · %p PID · %t 时间戳 · %s 信号 · %u 用户。以 | 开头是管道模式,内核把 core 交给指定程序处理(systemd-coredump、Apport 都这么干)。

core 没生成? 按顺序查:

  1. ulimit -c 是否为 0;
  2. core_pattern 指定的目录是否存在、当前用户是否有写权限;
  3. 磁盘是否已满;
  4. 程序是否自己用 setrlimit 关掉了 core;
  5. 是否在容器里,而 core 目录没挂载出来。

九、常用调试技巧 ​

bash
(gdb) set print pretty on          # 结构体/对象多行缩进显示,可写进 ~/.gdbinit
(gdb) set pagination off           # 关闭分页,脚本里不会卡在 --More--
(gdb) define hook-stop             # 自定义每次停下时自动执行的动作
         bt 3
       end
(gdb) shell ls -l                  # 不退出 gdb 执行 shell 命令
(gdb) call func(1, 2)              # 直接调用函数(会真的执行,注意副作用)
(gdb) print errno                  # 查 errno(需要 #include <errno.h>)

~/.gdbinit 里可以放常用设置,省得每次输:

text
set pagination off
set print pretty on
set print elements 200

十、原理:ptrace 和断点 ​

gdb 依赖内核的 ptrace 系统调用:PTRACE_ATTACH 暂停目标、PEEKTEXT/POKETEXT 读写内存、GETREGS/SETREGS 读写寄存器、SINGLESTEP 单步、PTRACE_CONT 继续。

断点原理(高频追问):gdb 把目标地址的指令首字节替换成 0xCC(int3 软中断)。CPU 执行到 0xCC 触发陷阱,控制权交给 gdb;gdb 恢复原指令、暂停给你看,继续时再写回 0xCC。

由此可推:

  • 断点下多了程序会明显变慢(每次命中都要陷入内核);
  • 0xCC 写在代码段,gdb 需要 mprotect 把代码段改为可写;
  • 这也是一些反调试手段检测 gdb 的思路——检查代码段有没有 0xCC,或检测 ptrace 是否已被 attach。