代码收藏家技术教程 2025-01-18

GDB 脚本化：使用 Python 自动化调试

1. 前言：为什么要用 GDB 脚本化？

手动调试程序，效率低且容易出错。尤其是面对复杂程序或重复的调试任务时，你可能会觉得 GDB 的交互式操作“略显笨重”。这时，GDB 的脚本化能力就像一个超能力工具，能够将复杂的调试过程自动化。

通过 Python 脚本，你可以批量分析程序状态、自动生成调试日志，甚至动态修改程序运行行为。调试不再是痛苦的重复劳动，而是有趣的“自动驾驶”！

2. 环境准备

硬件平台

CPU：Intel i5 或 AMD Ryzen（64 位，4 核心）

内存：8GB+

操作系统：Ubuntu 22.04 LTS

软件版本

GDB：12.1（支持 Python API）

Python：3.8+

确认 Python 支持

运行以下命令，检查 GDB 是否支持 Python：

gdb -ex "python print('Python scripting enabled!')" -ex quit

如果输出：

Python scripting enabled!

说明 GDB 已正确启用 Python 脚本支持。

3. 示例程序

代码：简单的调试目标

创建 simple_debug.c：

#include <stdio.h>

void buggy_function() {
    int a = 5;
    int b = 0;
    int c = a / b; // 除以零，程序将崩溃
    printf("Result: %d\n", c);
}

int main() {
    printf("Starting program...\n");
    buggy_function();
    printf("Ending program...\n");
    return 0;
}

编译程序

gcc -g -o simple_debug simple_debug.c

运行程序：

./simple_debug

输出：

Starting program...
Floating point exception (core dumped)

4. 用 GDB Python API 自动化调试

创建 Python 脚本

创建 auto_debug.py：

import gdb

class CrashAnalyzer(gdb.Command):
    """
    Analyze crashes and print detailed information.
    Usage: crash_analyze
    """
    def __init__(self):
        super(CrashAnalyzer, self).__init__("crash_analyze", gdb.COMMAND_USER)

    def invoke(self, arg, from_tty):
        print("Analyzing crash...")
        # 打印当前堆栈
        gdb.execute("backtrace")
        # 打印崩溃点的变量值
        gdb.execute("info locals")
        # 打印寄存器状态
        gdb.execute("info registers")
        print("Analysis complete.")

CrashAnalyzer()

加载脚本

启动 GDB 并加载脚本：

gdb simple_debug
(gdb) source auto_debug.py

运行程序并触发崩溃：

(gdb) run

自动分析崩溃

运行自定义命令 crash_analyze：

(gdb) crash_analyze

输出示例：

Analyzing crash...
#0  buggy_function () at simple_debug.c:7
#1  0x0000555555555151 in main () at simple_debug.c:13
Local variables:
a = 5
b = 0
c = <optimized out>
Register values:
rax            0x0      0
rbx            0x0      0
...
Analysis complete.

5. 动态调试控制

GDB Python API 提供了动态控制调试过程的能力。

示例：自动设置断点并运行

修改 auto_debug.py：

class AutoBreak(gdb.Command):
    """
    Automatically set breakpoints and run the program.
    Usage: auto_run
    """
    def __init__(self):
        super(AutoBreak, self).__init__("auto_run", gdb.COMMAND_USER)

    def invoke(self, arg, from_tty):
        print("Setting breakpoints...")
        gdb.execute("break main")
        gdb.execute("break buggy_function")
        print("Running the program...")
        gdb.execute("run")

AutoBreak()

重新加载脚本并运行：

(gdb) source auto_debug.py
(gdb) auto_run

输出：

Setting breakpoints...
Running the program...
Breakpoint 1, main () at simple_debug.c:11
11      printf("Starting program...\n");

6. 自动记录调试日志

记录堆栈与变量信息

修改 auto_debug.py，将调试信息输出到文件：

class LogCrash(gdb.Command):
    """
    Log crash details to a file.
    Usage: log_crash
    """
    def __init__(self):
        super(LogCrash, self).__init__("log_crash", gdb.COMMAND_USER)

    def invoke(self, arg, from_tty):
        with open("crash_log.txt", "w") as log:
            log.write("Crash Analysis:\n")
            log.write(gdb.execute("backtrace", to_string=True))
            log.write("\nLocal Variables:\n")
            log.write(gdb.execute("info locals", to_string=True))
            log.write("\nRegisters:\n")
            log.write(gdb.execute("info registers", to_string=True))
        print("Crash details saved to crash_log.txt.")

LogCrash()

加载脚本后触发崩溃并运行命令：

(gdb) log_crash

查看生成的 crash_log.txt，内容类似：

Crash Analysis:
#0  buggy_function () at simple_debug.c:7
#1  0x0000555555555151 in main () at simple_debug.c:13

Local Variables:
a = 5
b = 0
c = <optimized out>

Registers:
rax            0x0      0
rbx            0x0      0
...

7. 自动化调试动态库

加载动态库

修改代码以动态加载库：

#include <stdio.h>
#include <dlfcn.h>

int main() {
    void *handle = dlopen("./libmath_utils.so", RTLD_LAZY);
    if (!handle) {
        fprintf(stderr, "%s\n", dlerror());
        return 1;
    }

    int (*add)(int, int) = dlsym(handle, "add");
    printf("7 + 3 = %d\n", add(7, 3));

    dlclose(handle);
    return 0;
}

编译程序并动态链接：

gcc -g -o dynamic_debug dynamic_debug.c -ldl

动态断点脚本

修改 auto_debug.py，在动态库加载后设置断点：

class DynamicBreak(gdb.Command):
    """
    Set breakpoints dynamically after library loading.
    Usage: dynamic_break
    """
    def __init__(self):
        super(DynamicBreak, self).__init__("dynamic_break", gdb.COMMAND_USER)

    def invoke(self, arg, from_tty):
        gdb.execute("break dlopen")
        gdb.execute("run")
        gdb.execute("sharedlibrary")
        gdb.execute("break add")
        print("Dynamic breakpoints set.")

DynamicBreak()

运行：