一、观察点

观察点（watchpoint）是GDB中一种特殊的断点，也可以理解为“数据断点”。普通断点通常是在程序执行到某一行代码或某个函数时停下来，而观察点关注的是某个表达式的值是否发生变化。当被观察的表达式发生变化，或者被读写访问时，程序就会中断下来。

观察点常用于排查“某个变量不知道在哪里被修改了”的问题。例如，一个全局变量、结构体成员、指针指向的内存、数组元素等，在程序运行过程中被意外修改，这时就可以使用观察点让GDB在变量发生变化的那一刻停下来，从而定位是哪一行代码修改了它。

1.1 观察点类型

GDB 中的观察点分为两类：

---

1、硬件观察点（hardware watchpoint）

硬件观察点依赖CPU的调试寄存器来监控内存访问。当变量被修改时，CPU会自动触发调试异常，GDB就能在修改变量的位置停下来。硬件观察点的优点是效率高，对程序运行性能影响很小，而且通常能准确停在真正修改变量的那条指令附近。

例如设置观察点后，GDB 可能会提示：

(gdb) watch gdata
Hardware watchpoint 2: gdata

这表示当前观察点是硬件观察点。

---

2、软件观察点（software watchpoint）

软件观察点则是GDB通过单步执行程序，并在每一步之后检查表达式的值是否发生变化来实现的。因此软件观察点会明显降低程序运行速度，尤其是在循环、递归、多线程程序中会更加明显。软件观察点是一种类似轮询的方式，他不是CPU自动通知GDB变量变了，而是GDB反复检查变量有没有变。

大多数情况下GDB默认使用的都是硬件观察点，不过需要注意，虽然硬件观察点效率高，但它并不是无限制使用的。硬件观察点依赖CPU的调试寄存器，而调试寄存器的数量是有限的，所以同时能够设置的硬件观察点数量也有限。不同CPU架构支持的数量可能不同，通常只能设置少量几个硬件观察点。

GDB默认会尽量使用硬件观察点。如果想查看当前是否允许使用硬件观察点，可以使用：

(gdb) show can-use-hw-watchpoints

如果想强制关闭硬件观察点，让 GDB 使用软件观察点，可以使用：

(gdb) set can-use-hw-watchpoints 0

如果想重新开启硬件观察点，可以使用：

(gdb) set can-use-hw-watchpoints 1

一般情况下不需要手动修改这个选项，保持默认即可。只有在研究软件观察点行为，或者某些调试环境下硬件观察点异常时，才需要手动设置。

1.2 观察点常用命令

命令	作用
watch expr	写观察点，当表达式的值发生变化时中断
rwatch expr	读观察点，当表达式被读取时中断
awatch expr	访问观察点，当表达式被读取或写入时中断
i watchpoints	查看当前观察点信息，也可以使用i b命令，观察点和断点显示在同一个列表当中
delete num	删除指定编号的观察点
disable num	禁用指定编号的观察点
enable num	启用指定编号的观察点

其中，watch最常用，通常用来定位变量被修改的位置。rwatch和awatch使用频率相对较低，主要用于排查某块数据在哪里被读取或访问。

在实际使用中，观察点常见于以下几类场景：

---

1、定位全局变量被谁修改

当某个全局变量的值异常，但是不清楚是哪段代码修改的，可以使用：

(gdb) watch gdata

程序运行过程中，只要gdata的值发生变化，GDB就会停下来，并显示旧值和新值。

---

2、定位结构体成员被谁修改

例如有如下结构体：

struct Node {
    int id;
    int value;
};

struct Node node;

如果想观察node.value是否被修改，可以使用：

(gdb) watch node.value

如果是结构体指针：

struct Node *pnode;

则可以使用：

(gdb) watch pnode->value

---

3、定位数组元素被谁修改

如果只关心数组中的某一个元素，可以直接观察指定下标：

(gdb) watch arr[3]

这样只有arr[3]的值发生变化时才会中断，修改数组中的其他元素不会触发这个观察点。

---

4、定位多线程中的共享变量修改

在多线程程序中，多个线程可能都会修改同一个共享变量。如果想知道到底是哪个线程修改了变量，可以设置观察点：

(gdb) watch gdata

当gdata被修改时，程序会停下来。此时可以使用：

(gdb) info threads
(gdb) bt

查看当前是哪个线程触发了观察点，以及对应的函数调用栈。

如果只想观察某一个线程对变量的修改，可以使用：

(gdb) watch gdata thread 3

这表示只有GDB中编号为3的线程修改gdata时，才会触发观察点。

线程编号可以通过下面命令查看：

(gdb) info threads

---

5、观察变量计算式

观察点不仅可以观察单个变量，也可以观察由多个变量组成的计算表达式。当表达式的计算结果发生变化时，程序就会中断下来。

例如：

(gdb) watch a + b

表示观察表达式a + b的值。当a或b的值发生变化，并且导致a + b的计算结果发生变化时，GDB就会停下来。

示例代码：

#include <stdio.h>

int main()
{
    int a = 1;
    int b = 2;

    a = 3;      // a + b 从 3 变成 5，会触发观察点
    b = 4;      // a + b 从 5 变成 7，会触发观察点

    printf("a + b = %d\n", a + b);

    return 0;
}

调试时可以这样设置：

(gdb) r
(gdb) watch a + b
(gdb) continue

当a + b的结果发生变化时，GDB会中断下来，并显示表达式的旧值和新值。

除了普通计算表达式，也可以观察条件表达式：

(gdb) watch a + b > 10

这表示观察表达式a + b > 10的结果是否发生变化。由于这是一个布尔表达式，所以结果只有两种：真或假。

需要注意，watch a + b > 10并不是表示“只要a + b > 10就停下来”，而是表示“当 a + b > 10这个表达式的结果发生变化时停下来”。

二、捕获点

捕获点（catchpoint）也是一种特殊的断点。普通断点通常是在程序执行到某一行代码或某个函数时中断，观察点是在某个表达式的值发生变化时中断，而捕获点关注的是某类事件是否发生。

捕获点的命令语法为：

catch event

含义是：当程序运行过程中捕获到指定的 event 事件时，程序就会中断下来。

捕获点和普通断点、观察点一样，也会被 GDB 分配编号，因此可以使用 info breakpoints、delete、disable、enable 等命令进行管理。

2.1 常用捕获点命令

常见的捕获点事件如下：

命令	作用
catch throw	当C++ 程序抛出异常时中断
catch catch	当C++ 程序捕获异常时中断
catch rethrow	当C++ 程序重新抛出异常时中断
catch syscall	当程序执行系统调用时中断
catch fork	当程序调用fork创建子进程时中断
catch vfork	当程序调用vfork创建子进程时中断
catch exec	当程序调用exec执行新程序时中断
catch load	当程序加载动态库时中断
catch unload	当程序卸载动态库时中断

其中，C++ 异常调试中比较常用的是：

catch throw
catch catch
catch rethrow

进程调试中比较常用的是：

catch fork
catch exec

系统调用调试中比较常用的是：

catch syscall

2.2 捕获点示例

在这一小节中，将介绍几种捕获点的使用场景，包括捕获C++异常、捕获系统调用、捕获进程创建、捕获程序替换以及捕获动态库加载和卸载等。

---

1、捕获C++异常

在C++程序中，如果程序抛出了异常，但是不清楚异常是在哪里抛出的，可以使用catch throw捕获异常抛出事件，或者捕获对应的异常被处理的位置catch catch。

示例代码如下：

#include <iostream>
#include <stdexcept>

void func()
{
    throw std::runtime_error("error happened");
}

int main()
{
    try {
        func();
    } catch (const std::exception &e) {
        std::cout << "catch exception: " << e.what() << std::endl;
    }

    return 0;
}

在对应系统中编译出对应的可执行文件，并进行GDB调试

可以看见执行了catch throw命令之后，让程序继续执行，当func函数中执行完throw命令之后，GDB会对其进行捕获，在该捕获处，执行bt命令查看对应的函数栈调用情况

切换到1号栈帧中，就可以看见抛出异常的具体代码在什么地方

---

2、捕获系统调用

系统调用是用户程序请求内核服务的接口，例如文件读写、进程创建、网络通信等操作最终都会通过系统调用完成。

如果想捕获程序中发生的系统调用，可以使用：

(gdb) catch syscall

这会捕获所有系统调用。不过程序运行过程中系统调用非常频繁，如果捕获所有系统调用，程序可能会频繁中断，因此实际调试中通常会指定具体的系统调用。

例如，捕获文件打开相关的系统调用：

(gdb) catch syscall openat

捕获读文件操作：

(gdb) catch syscall read

捕获写文件操作：

(gdb) catch syscall write

小技巧：在捕获linux系统调度的read、write、open、close这些系统调度函数的时候，运行程序之后在linux的库中也会有一些调度函数，这时候如果我们想跳过main函数之后前的系统调度，可以先在main函数加上断点，r命令执行到main函数之后，再使用catch命令

示例代码如下：

#include <stdio.h>

int main()
{
    FILE *fp = fopen("test.txt", "r");
    if (fp == NULL) {
        perror("fopen");
        return 1;
    }

    fclose(fp);
    return 0;
}

对上述程序进行系统调试，在对应的系统调用处中断下来之后，查看对应的帧栈情况。

因为这里的程序中使用的是fopen标准IO函数，非系统IO函数open所以使用的捕获接口是openat，也可以使用openat2新标准。如果是使用的系统IO中的open函数打开对应的文件描述符，这种情况下需要使用syscall open。

---

3、捕获进程创建

在多进程程序中，如果想知道程序什么时候创建了子进程，可以使用catch fork或catch vfork。

示例代码：

#include <stdio.h>
#include <unistd.h>

int main()
{
    pid_t pid = fork();

    if (pid == 0) {
        printf("child process\n");
    } else {
        printf("parent process\n");
    }

    return 0;
}

当程序执行到fork()创建子进程时，GDB会中断下来。

如果程序使用的是vfork()，可以使用：

(gdb) catch vfork

捕获进程创建事件后，可以使用：

(gdb) bt

查看是哪个函数调用了fork()或vfork()。

---

4、捕获程序替换

在 Linux 中，exec系列函数用于将当前进程替换成另一个程序。例如，当前程序调用execl()执行 /bin/ls，那么当前进程的代码和数据会被新的程序替换。

如果想捕获这种程序替换事件，可以使用：

(gdb) catch exec

示例代码：

#include <unistd.h>

int main()
{
    execl("/bin/ls", "ls", NULL);
    return 0;
}

当程序执行到 execl()并准备替换为/bin/ls 时，GDB会中断下来。

这个命令适合用来调试启动脚本、父子进程、程序跳转执行其他可执行文件等场景。

---

5、捕获动态库加载和卸载

如果程序使用了动态库，或者程序运行过程中会动态加载插件，可以使用catch load和catch unload捕获动态库的加载和卸载事件。

捕获任意动态库加载：

(gdb) catch load

捕获指定动态库加载：

(gdb) catch load libm.so

捕获任意动态库卸载：

(gdb) catch unload

捕获指定动态库卸载：

(gdb) catch unload libm.so

这类捕获点常用于调试动态库初始化、插件加载、共享库符号解析等问题。

例如，一个程序通过dlopen()动态加载某个动态库.so文件，如果想知道动态库什么时候被加载，可以这样设置：

(gdb) catch load
(gdb) run

当动态库被加载时，GDB 就会中断下来。