C++ `GDB` / `LLDB` 扩展：编写 Python 脚本自动化复杂调试流程

哈喽，各位好！今天咱们聊聊一个能让你的调试效率噌噌往上涨的黑科技：C++ GDB/LLDB 扩展，用 Python 脚本自动化那些让人头大的复杂调试流程。

调试，程序员的家常便饭。但有些 bug，藏得深，逻辑绕，靠着一步一步地 next、step，那得调到猴年马月。这时候，就需要一些魔法，让调试器听你的话，按你的想法来。这就是 GDB 和 LLDB 扩展的意义所在。

一、 为什么需要 Python 扩展？

首先，咱们来聊聊为什么需要用 Python 来扩展 GDB 或 LLDB。GDB 和 LLDB 本身已经很强大了，但它们提供的命令毕竟有限，对于一些特定的、复杂的调试场景，就显得力不从心。

• 定制化需求： 比如，你想监控某个变量的变化，但只有当它满足某个条件时才暂停程序。 GDB 本身没有这样的命令。
• 自动化重复性任务： 比如，你想在每次循环迭代时打印一些信息。 手动 print 太累了。
• 复杂数据结构分析： 比如，你想以图形化的方式展示一个复杂的数据结构。 GDB 自带的显示方式可能不太直观。

Python 作为一种脚本语言，简洁易用，而且拥有丰富的库，非常适合用来编写调试脚本，弥补 GDB 和 LLDB 的不足。

二、 GDB Python 扩展入门

GDB 从 7.0 版本开始就支持 Python 扩展。要使用它，你需要确保你的 GDB 版本足够高，并且安装了 Python。

1. 基本概念

• gdb.Command 类： 这是创建自定义 GDB 命令的基础。 你需要继承这个类，并实现 invoke 方法，这个方法会在你的命令被调用时执行。
• gdb.Value 类： 用于表示 GDB 中的值，比如变量、表达式的结果。 你可以使用它来读取和修改内存中的数据。
• gdb.Breakpoint 类： 用于创建断点。 你可以指定断点的位置和条件，以及断点被触发时执行的操作。

2. 一个简单的例子：打印变量类型

咱们来写一个简单的 GDB 扩展，它可以打印指定变量的类型。

import gdb

class PrintType(gdb.Command):
    """Prints the type of a variable."""

    def __init__(self):
        super(PrintType, self).__init__("print_type", gdb.COMMAND_USER)

    def invoke(self, arg, from_tty):
        """
        Usage: print_type <variable_name>
        """
        try:
            val = gdb.parse_and_eval(arg)
            print(val.type)
        except gdb.error as e:
            print("Error: %s" % e)

PrintType()

解释：

• import gdb：导入 gdb 模块，这样才能使用 GDB 提供的 API。
• class PrintType(gdb.Command)：定义一个名为 PrintType 的类，继承自 gdb.Command。
• __init__(self)：构造函数，用于注册命令。"print_type" 是命令的名字，gdb.COMMAND_USER 表示这是一个用户自定义命令。
• invoke(self, arg, from_tty)：这是命令被调用时执行的方法。arg 是用户输入的参数，from_tty 表示命令是否从终端执行。
• gdb.parse_and_eval(arg)：解析并计算表达式 arg 的值。
• val.type：获取变量 val 的类型。
• PrintType()：创建 PrintType 类的实例，这样 GDB 才能找到并加载这个命令。

3. 如何加载和使用扩展

将上面的代码保存为 print_type.py 文件。然后在 GDB 中，使用 source 命令加载这个文件：

(gdb) source print_type.py

现在你就可以使用 print_type 命令了：

(gdb) print_type my_variable

GDB 会打印出 my_variable 的类型。

三、 LLDB Python 扩展入门

LLDB 也支持 Python 扩展，并且它的 API 设计得更加 Pythonic。

1. 基本概念

• lldb.SBCommand 类： 类似于 GDB 的 gdb.Command 类，用于创建自定义 LLDB 命令。
• lldb.SBValue 类： 类似于 GDB 的 gdb.Value 类，用于表示 LLDB 中的值。
• lldb.SBBreakpoint 类： 类似于 GDB 的 gdb.Breakpoint 类，用于创建断点。

2. 一个简单的例子：打印变量类型

咱们来写一个与 GDB 例子功能相同的 LLDB 扩展。

import lldb

def __lldb_init_module(debugger, dict):
    debugger.HandleCommand('command script add -f print_type.print_type print_type')

def print_type(debugger, command, result, internal_dict):
    """Prints the type of a variable."""
    args = command.split()
    if len(args) != 1:
        result.SetError("Usage: print_type <variable_name>")
        return

    target = debugger.GetSelectedTarget()
    process = target.GetProcess()
    frame = process.GetSelectedFrame()

    value = frame.FindVariable(args[0])
    if not value.IsValid():
        result.SetError("Variable '%s' not found." % args[0])
        return

    result.AppendMessage(str(value.GetType()))

解释：

• import lldb：导入 lldb 模块。
• __lldb_init_module(debugger, dict)：这是一个特殊的函数，LLDB 会在加载扩展时调用它。
  • debugger.HandleCommand('command script add -f print_type.print_type print_type')：注册命令。
    • command script add：表示添加一个脚本命令。
    • -f print_type.print_type：指定命令的处理函数。 print_type.print_type 表示 print_type.py 文件中的 print_type 函数。
    • print_type：是命令的名字。
• print_type(debugger, command, result, internal_dict)：这是命令的处理函数。
  • debugger：LLDB 调试器对象。
  • command：用户输入的命令字符串，包括命令名和参数。
  • result：用于返回结果的对象。
  • internal_dict：一个内部字典，可以用来存储一些状态信息。
• target = debugger.GetSelectedTarget()：获取当前的目标进程。
• process = target.GetProcess()：获取进程对象。
• frame = process.GetSelectedFrame()：获取当前栈帧。
• value = frame.FindVariable(args[0])：在当前栈帧中查找变量。
• result.AppendMessage(str(value.GetType()))：将变量的类型添加到结果中。

3. 如何加载和使用扩展

将上面的代码保存为 print_type.py 文件。然后在 LLDB 中，使用 command script import 命令加载这个文件：

(lldb) command script import print_type.py

现在你就可以使用 print_type 命令了：

(lldb) print_type my_variable

LLDB 会打印出 my_variable 的类型。

四、 高级技巧：自动化复杂调试流程

现在咱们来玩点高级的，用 Python 脚本自动化一些复杂的调试流程。

1. 条件断点与数据监控

假设你有一个循环，你想在某个变量的值超过 100 时暂停程序，并打印一些信息。

GDB 脚本：

import gdb

class ConditionalBreakpoint(gdb.Command):
    """Sets a breakpoint that triggers when a condition is met."""

    def __init__(self):
        super(ConditionalBreakpoint, self).__init__("conditional_break", gdb.COMMAND_USER)

    def invoke(self, arg, from_tty):
        args = arg.split()
        if len(args) != 2:
            print("Usage: conditional_break <variable_name> <condition>")
            return

        variable_name = args[0]
        condition = args[1]

        def breakpoint_hit(breakpoint):
            val = gdb.parse_and_eval(variable_name)
            print("Variable %s = %s" % (variable_name, val))
            return False  # Continue execution

        bp = gdb.Breakpoint(None, gdb.BP_BREAKPOINT, condition=condition)
        bp.hit = breakpoint_hit

ConditionalBreakpoint()

使用：

(gdb) conditional_break my_variable my_variable > 100

这个脚本创建了一个名为 conditional_break 的命令，它接受两个参数：变量名和条件。当程序执行到断点时，会检查条件是否满足。如果满足，就会打印变量的值，并继续执行。

LLDB 脚本：

import lldb

def __lldb_init_module(debugger, dict):
    debugger.HandleCommand('command script add -f conditional_break.conditional_break conditional_break')

def conditional_break(debugger, command, result, internal_dict):
    args = command.split()
    if len(args) != 2:
        result.SetError("Usage: conditional_break <variable_name> <condition>")
        return

    variable_name = args[0]
    condition = args[1]

    target = debugger.GetSelectedTarget()
    process = target.GetProcess()

    def breakpoint_callback(frame, bp_loc, dict):
        value = frame.FindVariable(variable_name)
        if value.IsValid():
            result.AppendMessage("Variable %s = %s" % (variable_name, value.GetValue()))
        return False # Continue execution

    breakpoint = target.BreakpointCreateBySourceRegex('', lldb.SBFileSpec(), 0) #Empty source regex to trigger on any line in the function
    breakpoint.SetCondition(condition)
    breakpoint.SetScriptCallbackFunction(breakpoint_callback)

使用：

(lldb) conditional_break my_variable my_variable > 100

2. 函数调用追踪

有时候，你想追踪某个函数的调用链，看看它是从哪里被调用的。

GDB 脚本：

import gdb

class TraceFunction(gdb.Command):
    """Traces the call stack when a function is called."""

    def __init__(self):
        super(TraceFunction, self).__init__("trace_function", gdb.COMMAND_USER)

    def invoke(self, arg, from_tty):
        def breakpoint_hit(breakpoint):
            print("Function called:")
            gdb.execute("bt 10")  # Print the first 10 frames of the backtrace
            return False  # Continue execution

        bp = gdb.Breakpoint(arg)
        bp.hit = breakpoint_hit

TraceFunction()

使用：

(gdb) trace_function my_function

这个脚本创建了一个名为 trace_function 的命令，它接受一个参数：函数名。当程序执行到该函数时，会打印调用栈信息。

LLDB 脚本：

import lldb

def __lldb_init_module(debugger, dict):
    debugger.HandleCommand('command script add -f trace_function.trace_function trace_function')

def trace_function(debugger, command, result, internal_dict):
    target = debugger.GetSelectedTarget()

    def breakpoint_callback(frame, bp_loc, dict):
        thread = frame.GetThread()
        result.AppendMessage("Function called:n")
        for i in range(thread.GetNumFrames()):
            frame = thread.GetFrameAtIndex(i)
            function = frame.GetFunction()
            if function:
                result.AppendMessage("  %d: %s" % (i, function.GetName()))
            else:
                symbol = frame.GetSymbol()
                if symbol:
                     result.AppendMessage("  %d: %s" % (i, symbol.GetName()))
                else:
                    result.AppendMessage(" %d: Address 0x%x" % (i, frame.GetPC()))
        return False # Continue Execution

    breakpoint = target.BreakpointCreateByName(command)
    breakpoint.SetScriptCallbackFunction(breakpoint_callback)

使用：

(lldb) trace_function my_function

3. 复杂数据结构可视化

如果你的程序中使用了复杂的数据结构，比如树或图，你可以编写 Python 脚本来将它们可视化。 这需要一些额外的库，比如 graphviz。

伪代码示例 (GDB):

import gdb
import graphviz

class VisualizeTree(gdb.Command):
    """Visualizes a tree data structure using Graphviz."""

    def __init__(self):
        super(VisualizeTree, self).__init__("visualize_tree", gdb.COMMAND_USER)

    def invoke(self, arg, from_tty):
        # 1. 获取树的根节点
        root = gdb.parse_and_eval(arg)

        # 2. 创建 Graphviz 图对象
        dot = graphviz.Digraph(comment='Tree')

        # 3. 递归遍历树，添加节点和边
        def add_node(node):
            if node == 0: # Check for NULL
                return
            node_value = gdb.parse_and_eval(str(node) + "->data") # Assuming node has a 'data' field
            dot.node(str(node), str(node_value))

            left_child = gdb.parse_and_eval(str(node) + "->left") # Assuming node has 'left' and 'right' pointers
            right_child = gdb.parse_and_eval(str(node) + "->right")

            if left_child != 0:
                dot.edge(str(node), str(left_child))
                add_node(left_child)

            if right_child != 0:
                dot.edge(str(node), str(right_child))
                add_node(right_child)

        add_node(root)

        # 4. 保存为图像文件
        dot.render('tree.gv', view=True)  # Generates tree.gv.pdf and opens it

使用：

(gdb) visualize_tree my_tree_root

解释：

这个例子只是一个伪代码，你需要根据你的数据结构的实际情况来修改 add_node 函数。 它假设你的树节点有一个 data 字段，以及 left 和 right 指针。 你需要使用 gdb.parse_and_eval 来读取这些字段的值，并使用 graphviz 库来创建图形。

五、 调试技巧与最佳实践

• 善用 print 调试： 在你的 Python 脚本中，可以使用 print 语句来输出调试信息。 这些信息会显示在 GDB 或 LLDB 的控制台中。
• 模块化你的代码： 将你的调试脚本分解成多个函数或类，这样可以提高代码的可读性和可维护性。
• 编写单元测试： 为你的调试脚本编写单元测试，确保它们能够正常工作。
• 查阅官方文档： GDB 和 LLDB 的官方文档包含了大量的示例和 API 说明，是学习 Python 扩展的宝贵资源。
• 使用版本控制： 将你的调试脚本放在版本控制系统中，比如 Git，这样可以方便地跟踪修改和协作。
• 异常处理： 在你的 Python 脚本中，要使用 try...except 语句来处理可能出现的异常，避免程序崩溃。

六、 GDB vs LLDB：一些对比

特性	GDB	LLDB
语言支持	C, C++, Objective-C, Go, Python 等	C, C++, Objective-C, Swift, Rust, Go, Python 等
平台支持	Linux, Windows, macOS 等	macOS, Linux, Windows 等
Python API	历史悠久，但可能略显笨拙	设计更现代，更 Pythonic
Swift 支持	一般	优秀
社区支持	庞大，但可能不如 LLDB 活跃	活跃，增长迅速
易用性	学习曲线可能稍陡峭	相对更容易上手

七、 总结

Python 扩展是 GDB 和 LLDB 的一个强大的补充，它可以让你自动化复杂的调试流程，提高调试效率。 掌握 Python 扩展，就好像给你的调试工具箱里增加了一件秘密武器，让你可以更加轻松地应对各种 bug。

希望今天的分享对大家有所帮助！ 祝大家调试愉快！