C++中的调试器扩展：利用Python/Lua脚本定制GDB/LLDB的功能

C++调试器扩展：利用Python/Lua脚本定制GDB/LLDB的功能

大家好，今天我们来聊聊一个比较高级但非常有用的调试技巧：利用Python或Lua脚本扩展GDB/LLDB的功能。 调试器本身提供的功能虽然强大，但在面对复杂的项目或者特定的调试场景时，往往会显得不够灵活。通过脚本扩展，我们可以定制调试器的行为，自动化一些重复性的任务，甚至实现一些调试器本身不支持的功能。

为什么需要扩展调试器？

在深入细节之前，我们先来思考一下，为什么我们需要扩展调试器？ 简单来说，有以下几个原因：

• 自动化重复性任务: 例如，每次断点命中后都要打印一系列变量的值，或者执行一系列命令。通过脚本，我们可以将这些操作自动化。
• 简化复杂调试流程: 对于一些复杂的算法或数据结构，需要深入理解其内部状态。通过脚本，我们可以编写自定义的命令来可视化这些状态。
• 解决特定问题: 某些Bug可能只在特定条件下才会出现，传统的调试方法可能难以定位。通过脚本，我们可以定制断点条件，或者在特定事件发生时执行一些操作。
• 扩展调试器功能: 调试器本身的功能是有限的，通过脚本，我们可以扩展调试器的功能，例如，支持新的调试格式，或者与其他工具集成。

GDB 和 LLDB 扩展机制对比

GDB和LLDB都提供了强大的脚本扩展机制，但实现方式略有不同。

特性	GDB	LLDB
脚本语言	Python (主要), Scheme (有限支持)	Python (主要)
扩展方式	1. .gdbinit 文件 2. source 命令 3. define 命令 (自定义命令)	1. .lldbinit 文件 2. command script import 命令 3. command regex 命令 (自定义命令)
对象模型	GDB Python API (较底层)	LLDB Python API (更现代化，更易用)
自动加载脚本	支持，通过 .gdbinit 文件	支持，通过 .lldbinit 文件
C++ 集成度	较低，主要通过Python API操作	较高，可以直接在Python脚本中调用LLDB的C++ API
调试器集成度	紧密集成，可以直接访问调试器的内部状态	紧密集成，可以直接访问调试器的内部状态

总的来说，LLDB的Python API设计得更加现代化，易于使用，并且与C++的集成度更高。但GDB的Python API也很强大，可以实现很多高级的调试功能。

GDB 脚本示例：打印变量值

我们先来看一个简单的GDB脚本示例，演示如何自动打印变量的值。

# ~/.gdbinit

# 定义一个名为 "print_vars" 的自定义命令
define print_vars
  # 打印变量 a 的值
  print a
  # 打印变量 b 的值
  print b
end

# 为断点设置命令
break main
commands
  print_vars
  continue
end

这个脚本做了以下几件事：

1. define print_vars: 定义了一个名为print_vars的自定义命令。
2. print a, print b: 在print_vars命令中，打印变量a和b的值。
3. break main: 在main函数处设置一个断点。
4. commands: 指定断点命中后要执行的命令。
5. print_vars: 执行我们自定义的print_vars命令。
6. continue: 继续执行程序。

将这个脚本保存到~/.gdbinit文件中，启动GDB调试程序，程序会在main函数处断点，并自动打印变量a和b的值。

LLDB 脚本示例：打印变量值

LLDB的脚本实现方式类似，但语法略有不同。

# ~/.lldbinit

# 自定义命令： print_vars
def print_vars(debugger, command, result, internal_dict):
  """Prints the values of variables a and b."""
  a = debugger.GetSelectedTarget().FindFirstGlobalVariable("a")
  b = debugger.GetSelectedTarget().FindFirstGlobalVariable("b")

  if a.IsValid():
    result.AppendMessage("a = {}".format(a.GetValue()))
  else:
    result.AppendMessage("Variable 'a' not found.")

  if b.IsValid():
    result.AppendMessage("b = {}".format(b.GetValue()))
  else:
    result.AppendMessage("Variable 'b' not found.")

# 创建一个LLDB命令：print_vars
lldb.debugger.HandleCommand('command script add -f print_vars print_vars')

# 在main函数处设置断点，并执行print_vars命令
lldb.debugger.HandleCommand('breakpoint set -n main')
lldb.debugger.HandleCommand('breakpoint command add -s python -F .lldbinit.print_vars')

这个脚本也做了类似的事情：

1. def print_vars(...): 定义了一个Python函数print_vars，用于打印变量a和b的值。
2. debugger.GetSelectedTarget().FindFirstGlobalVariable("a"): 通过LLDB的API获取变量a和b的值。
3. lldb.debugger.HandleCommand(...): 使用LLDB的API执行命令。
4. command script add -f print_vars print_vars: 将Python函数print_vars注册为一个LLDB命令print_vars。
5. breakpoint set -n main: 在main函数处设置一个断点。
6. breakpoint command add -s python -F .lldbinit.print_vars: 指定断点命中后执行Python函数print_vars。

将这个脚本保存到~/.lldbinit文件中，启动LLDB调试程序，程序会在main函数处断点，并自动打印变量a和b的值。

高级脚本示例：可视化链表

接下来，我们来看一个更高级的例子，演示如何使用Python脚本可视化链表。

// linked_list.cpp
#include <iostream>

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

void printList(Node* n) {
  while (n != nullptr) {
    std::cout << n->data << " ";
    n = n->next;
  }
  std::cout << std::endl;
}

int main() {
  Node* head = new Node{1, nullptr};
  head->next = new Node{2, nullptr};
  head->next->next = new Node{3, nullptr};

  printList(head);

  // Set breakpoint here to visualize the linked list

  delete head->next->next;
  delete head->next;
  delete head;

  return 0;
}

# ~/.lldbinit (or source this file in LLDB)

import lldb

def print_linked_list(debugger, command, result, internal_dict):
  """
  Prints the elements of a linked list.

  Usage: print_linked_list <head_node_address>
  """
  args = command.split()
  if len(args) != 1:
    result.SetError("Usage: print_linked_list <head_node_address>")
    return

  try:
    head_address = int(args[0], 0)  # Allow hex or decimal
  except ValueError:
    result.SetError("Invalid address: {}".format(args[0]))
    return

  target = debugger.GetSelectedTarget()
  process = target.GetProcess()
  error = lldb.SBError()

  head_node = target.CreateValueFromAddress("head", head_address, target.GetBasicType(lldb.eBasicTypeVoid).GetPointerType())
  if not head_node.IsValid():
    result.SetError("Invalid head node address.")
    return

  node = head_node.GetValueAsUnsigned()
  if node == 0:
    result.AppendMessage("Linked list is empty.")
    return

  output = "Linked List: "
  count = 0
  while node != 0:
    # Read the data field
    data_address = node + 0  # Assuming 'data' is the first member (offset 0)
    data = process.ReadUnsignedFromMemory(data_address, 4, error)  # Assuming 'data' is an int (4 bytes)
    if error.Fail():
      result.SetError("Failed to read data: {}".format(error.GetCString()))
      return

    # Read the next pointer
    next_address = node + 8 # Assuming 'next' is the second member (offset 8) and a pointer (8 bytes on x64)
    next_node = process.ReadUnsignedFromMemory(next_address, 8, error) # Assuming 'next' is a pointer (8 bytes on x64)
    if error.Fail():
      result.SetError("Failed to read next pointer: {}".format(error.GetCString()))
      return

    output += str(data) + " -> "
    node = next_node
    count += 1

    if count > 20:
        output += "..."
        break

  output += "nullptr"
  result.AppendMessage(output)

# Register the command
def __lldb_init_module(debugger, internal_dict):
  debugger.HandleCommand('command script add -f linked_list.print_linked_list print_linked_list')

这个脚本做了以下几件事：

1. print_linked_list(debugger, command, result, internal_dict): 定义了一个Python函数print_linked_list，用于打印链表的内容。它接受链表头节点的地址作为参数。
2. target.CreateValueFromAddress(...): 使用LLDB的API创建一个指向链表头节点的指针。
3. process.ReadUnsignedFromMemory(...): 使用LLDB的API从内存中读取节点的数据和next指针。
4. __lldb_init_module(debugger, internal_dict): LLDB在加载脚本时会自动调用这个函数，用于注册自定义命令。

使用方法：

1. 编译linked_list.cpp。
2. 在main函数中设置一个断点。
3. 启动LLDB调试程序。
4. 在LLDB命令行中输入print_linked_list head，其中head是链表头节点的变量名。LLDB会打印出链表的内容。

关键点：

• 内存访问: 通过process.ReadUnsignedFromMemory()函数，我们可以直接从内存中读取数据，这使得我们可以访问程序中的任何变量。
• 地址计算: 需要根据结构体的定义，计算出每个成员的偏移量。
• 错误处理: 需要对内存访问进行错误处理，防止程序崩溃。

GDB 和 LLDB Python API 的核心概念

要深入理解如何编写GDB和LLDB的Python脚本，需要熟悉它们的核心API。

GDB Python API的核心概念：

• gdb.Breakpoint: 表示一个断点。
• gdb.Frame: 表示一个栈帧。
• gdb.Value: 表示一个变量的值。
• gdb.execute(): 执行GDB命令。
• gdb.parse_and_eval(): 解析并计算一个表达式的值。

LLDB Python API的核心概念：

• lldb.SBTarget: 表示被调试的目标程序。
• lldb.SBProcess: 表示被调试的进程。
• lldb.SBThread: 表示被调试的线程。
• lldb.SBFrame: 表示一个栈帧。
• lldb.SBValue: 表示一个变量的值。
• lldb.SBCommandInterpreter: 执行LLDB命令。
• lldb.SBExpressionOptions: 控制表达式评估的选项。

一些常用的API：

功能	GDB	LLDB
获取当前栈帧	gdb.selected_frame()	debugger.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame()
获取变量的值	gdb.parse_and_eval("variable_name")	frame.FindVariable("variable_name").GetValue()
设置断点	gdb.Breakpoint("file.cpp:10")	target.BreakpointCreateByLocation("file.cpp", 10)
执行命令	gdb.execute("command")	debugger.HandleCommand("command")
从内存读取数据	(需要使用inferior对象，较复杂)	process.ReadMemory(address, size, error)
向内存写入数据	(需要使用inferior对象，较复杂)	process.WriteMemory(address, data, error)

GDB 和 LLDB 的事件处理

GDB和LLDB都支持事件处理，允许我们在特定事件发生时执行脚本代码。

GDB 事件处理：

GDB通过gdb.events模块提供事件处理功能。常用的事件包括：

• gdb.events.stop: 当程序停止时触发。
• gdb.events.exited: 当程序退出时触发。
• gdb.events.new_objfile: 当加载新的目标文件时触发。

# GDB 事件处理示例

def stop_handler(event):
  print("Program stopped at: {}".format(event.frame.name()))

gdb.events.stop.connect(stop_handler)

LLDB 事件处理：

LLDB通过SBListener和SBEvent类提供事件处理功能。常用的事件包括：

• lldb.SBProcess.eBroadcastBitStateChanged: 当进程状态改变时触发。
• lldb.SBTarget.eBroadcastBitBreakpointChanged: 当断点状态改变时触发。

# LLDB 事件处理示例

import lldb

def process_state_changed(event):
  if event.GetState() == lldb.eStateStopped:
    print("Program stopped.")

listener = lldb.SBListener()
debugger.GetSelectedTarget().GetProcess().GetBroadcaster().AddListener(listener, lldb.SBProcess.eBroadcastBitStateChanged)

while True:
  event = llistener.WaitForEvent(5)  # Wait for 5 seconds
  if event.IsValid():
    process_state_changed(event)

Lua 脚本在 GDB 中的应用

虽然GDB主要使用Python进行扩展，但它也支持有限的Lua脚本。Lua脚本通常用于编写简单的自定义命令。

-- ~/.gdbinit (使用Lua)

define lua_print
  lua
    print("Hello from Lua!")
    print("Value of variable a: " .. gdb.parse_and_eval("a"))
  end
end

document lua_print
  Prints a message from Lua and the value of variable a.
end

这个例子展示了如何在GDB中使用Lua脚本定义一个名为lua_print的自定义命令。该命令会打印一条Lua消息以及变量a的值。

Lua 脚本的局限性：

• 功能有限: Lua API不如Python API强大。
• 调试困难: Lua脚本的调试不如Python脚本方便。

因此，在大多数情况下，建议使用Python进行GDB扩展。

实际案例分析：定制内存查看器

假设我们需要一个定制的内存查看器，可以按照特定的格式显示内存内容。例如，我们需要以16进制显示一段内存区域，并按照每行16个字节的格式排列。

我们可以使用Python脚本来实现这个功能。

GDB Python 脚本：

# ~/.gdbinit

import gdb

class MemoryViewer(gdb.Command):
  """
  A command to view memory in a formatted way.

  Usage: memory_view <address> <size>
  """

  def __init__(self):
    super(MemoryViewer, self).__init__("memory_view", gdb.COMMAND_USER)

  def invoke(self, arg, from_tty):
    args = arg.split()
    if len(args) != 2:
      print("Usage: memory_view <address> <size>")
      return

    try:
      address = int(args[0], 0)  # Allow hex or decimal
      size = int(args[1])
    except ValueError:
      print("Invalid address or size.")
      return

    inferior = gdb.selected_inferior()
    try:
      memory = inferior.read_memory(address, size)
    except gdb.error as e:
      print("Error reading memory: {}".format(e))
      return

    for i in range(0, size, 16):
      line = ""
      for j in range(16):
        if i + j < size:
          byte = memory[i + j]
          line += "{:02x} ".format(byte)
        else:
          line += "   "
      print("0x{:08x}: {}".format(address + i, line))

MemoryViewer()

LLDB Python 脚本：

# ~/.lldbinit

import lldb

def memory_view(debugger, command, result, internal_dict):
  """
  A command to view memory in a formatted way.

  Usage: memory_view <address> <size>
  """

  args = command.split()
  if len(args) != 2:
    result.SetError("Usage: memory_view <address> <size>")
    return

  try:
    address = int(args[0], 0)  # Allow hex or decimal
    size = int(args[1])
  except ValueError:
    result.SetError("Invalid address or size.")
    return

  target = debugger.GetSelectedTarget()
  process = target.GetProcess()
  error = lldb.SBError()

  memory = process.ReadMemory(address, size, error)
  if error.Fail():
    result.SetError("Error reading memory: {}".format(error.GetCString()))
    return

  for i in range(0, size, 16):
    line = ""
    for j in range(16):
      if i + j < size:
        byte = memory[i + j]
        line += "{:02x} ".format(byte)
      else:
        line += "   "
    result.AppendMessage("0x{:08x}: {}".format(address + i, line))

# Register the command
def __lldb_init_module(debugger, internal_dict):
  debugger.HandleCommand('command script add -f memory_view.memory_view memory_view')

使用方法：

1. 将脚本保存到~/.gdbinit或~/.lldbinit文件中。
2. 启动GDB或LLDB调试程序。
3. 在GDB或LLDB命令行中输入memory_view <address> <size>，其中<address>是内存地址，<size>是要查看的内存大小。调试器会以16进制格式显示内存内容。

这个例子展示了如何使用Python脚本扩展调试器的功能，实现一个定制的内存查看器。

调试脚本

调试GDB和LLDB脚本本身也是一个挑战。 可以使用以下方法：

• print 语句: 在脚本中插入print语句，用于输出调试信息。
• gdb.write() 和 lldb.SBCommandReturnObject.AppendMessage(): 使用这些函数可以将消息输出到调试器的控制台。
• 断点调试: 可以在脚本中设置断点，然后使用调试器来调试脚本。
• 日志记录: 可以将脚本的输出记录到文件中，以便后续分析。

一些建议

• 模块化: 将脚本分解为小的、可重用的模块。
• 文档化: 为脚本编写清晰的文档，说明脚本的功能和使用方法。
• 测试: 对脚本进行充分的测试，确保其功能正确。
• 版本控制: 使用版本控制系统（例如Git）来管理脚本。
• 参考文档: GDB和LLDB的官方文档是学习脚本扩展的最佳资源。

总结一下

通过Python或Lua脚本扩展GDB/LLDB的功能，可以极大地提高调试效率和灵活性。 我们可以自动化重复性任务，简化复杂调试流程，解决特定问题，甚至扩展调试器本身的功能。 但是，脚本扩展也需要一定的学习成本，需要熟悉GDB/LLDB的API和脚本语言。

希望今天的分享能帮助大家更好地利用调试器，更高效地解决Bug！

更多IT精英技术系列讲座，到智猿学院