使用 LLDB Python 脚本高效调试 C 语言中的 char 类型变量

import lldb

def print_argv_synthetic(argv: lldb.SBValue):
    """
    使用 can_create_synthetic 参数打印 argv 数组中的字符串。
    适用于无法获取 argc 的情况，但可能不如基于类型的方法健壮。
    """
    if not argv.IsValid():
        print("无效的 argv SBValue。")
        return

    # 尝试获取第一个参数
    child_0 = argv.GetChildAtIndex(0, lldb.eNoDynamicValues, True)
    if child_0.IsValid():
        print(f"argv[0]: {child_0.GetSummary().strip('\"')}")
    else:
        print("无法获取 argv[0]。")

    # 尝试获取第二个参数
    child_1 = argv.GetChildAtIndex(1, lldb.eNoDynamicValues, True)
    if child_1.IsValid():
        print(f"argv[1]: {child_1.GetSummary().strip('\"')}")
    else:
        print("无法获取 argv[1]。")

    # 可以继续尝试其他索引
    # child_2 = argv.GetChildAtIndex(2, lldb.eNoDynamicValues, True)
    # if child_2.IsValid():
    #     print(f"argv[2]: {child_2.GetSummary().strip('\"')}")

import lldb

def print_argv_robust(argv_val: lldb.SBValue, argc_val: lldb.SBValue, target: lldb.SBTarget):
    """
    使用 SBType::GetArrayType 和 argc 参数打印 argv 数组中的字符串。
    这是推荐的健壮方法。

    参数:
    argv_val: lldb.SBValue, 代表 C 程序的 argv 参数 (char** 类型)。
    argc_val: lldb.SBValue, 代表 C 程序的 argc 参数 (int 类型)。
    target: lldb.SBTarget, 当前的调试目标。
    """
    if not argv_val.IsValid() or not argc_val.IsValid():
        print("无效的 argv 或 argc SBValue。")
        return

    # 1. 获取 argv 指向的类型 (char*)
    # argv_val 是 char**，所以 Dereference() 得到 char*
    pointer_type = argv_val.GetType().GetPointeeType() 
    if not pointer_type.IsValid():
        print("无法获取 argv 的指针类型。")
        return

    # 2. 获取 argc 的无符号整数值
    argc_unsigned = argc_val.GetValueAsUnsigned()
    if argc_unsigned == 0:
        print("argc 为 0，没有命令行参数。")
        return

    # 3. 基于 char* 类型和 argc 创建一个固定大小的数组类型 (char*[argc])
    array_type = pointer_type.GetArrayType(argc_unsigned)
    if not array_type.IsValid():
        print("无法创建数组类型。")
        return

    # 4. 使用这个新的数组类型，从 argv 的地址创建一个表示整个数组的 SBValue
    # argv_val.GetLoadAddress() 获取 argv 指向的实际内存地址，即 char* 数组的起始地址
    argv_array_value = target.CreateValueFromAddress(
        "argv_array_view",          # 给这个合成值一个名字
        argv_val.GetLoadAddress(),  # 数组的起始地址
        array_type                  # 精确的数组类型 (char*[argc])
    )

    if not argv_array_value.IsValid():
        print("无法创建 argv 数组视图。")
        return

    print(f"--- 打印 {argc_unsigned} 个 argv 参数 ---")
    # 5. 遍历数组的子元素并打印
    for i in range(argv_array_value.GetNumChildren()):
        child = argv_array_value.GetChildAtIndex(i)
        if child.IsValid():
            # GetSummary() 通常会返回带引号的字符串，strip() 去除它们
            summary = child.GetSummary().strip('\"')
            print(f"argv[{i}]: {summary}")
        else:
            print(f"无法获取 argv[{i}]。")

import lldb
import os

def debug_c_program(binary_path: str, args: list):
    """
    设置 LLDB 调试会话并打印 C 程序的 argv 参数。

    参数:
    binary_path: str, C 可执行文件的路径。
    args: list, 传递给 C 程序的命令行参数列表。
    """
    debugger = lldb.SBDebugger.Create()
    debugger.SetAsync(False) # 设置为同步模式，方便脚本控制

    # 创建目标程序
    target = debugger.CreateTargetWithFileAndArch(binary_path, lldb.LLDB_ARCH_DEFAULT)
    if not target:
        print(f"错误: 无法创建目标程序 {binary_path}")
        return

    # 在 main 函数设置断点
    breakpoint = target.BreakpointCreateByName("main", target.GetExecutable().GetFilename())
    if not breakpoint.IsValid():
        print("错误: 无法在 main 函数设置断点。")
        return

    # 准备启动信息
    launch_info = lldb.SBLaunchInfo(args) # 将命令行参数传递给启动信息
    launch_info.SetWorkingDirectory(os.getcwd()) # 设置工作目录
    error = lldb.SBError()

    # 启动进程
    process = target.Launch(launch_info, error)
    if not process or error.Fail():
        print(f"错误: 无法启动进程: {error.GetCString()}")
        return

    print(f"进程 {process.GetProcessID()} 已启动。")

    # 循环检查进程状态，直到停止在断点
    for _ in range(100): # 设置一个循环上限，防止无限循环
        state = process.GetState()

        if state == lldb.eStateStopped:
            print("进程在断点处停止。")
            for thread in process:
                frame = thread.GetSelectedFrame() # 获取当前线程的当前栈帧
                if frame.IsValid():
                    function_name = frame.GetFunctionName()
                    if function_name == "main":
                        # 在 main 函数中查找 argc 和 argv 参数
                        argc_val = None
                        argv_val = None
                        for arg in frame.GetArguments():
                            if arg.GetName() == "argc":
                                argc_val = arg
                            elif arg.GetName() == "argv":
                                argv_val = arg

                        if argc_val and argv_val:
                            print_argv_robust(argv_val, argc_val, target)
                        else:
                            print("未找到 main 函数的 argc 或 argv 参数。")
                        break # 找到 main 函数的帧后退出线程循环
            process.Continue() # 恢复进程执行
            break # 退出状态检查循环
        elif state == lldb.eStateExited:
            print(f"进程已退出，退出码: {process.GetExitStatus()}")
            break
        elif state == lldb.eStateRunning:
            # 进程仍在运行，可能需要等待或继续
            pass
        else:
            # 其他状态，例如 eStateInvalid, eStateUnloaded, eStateSuspended, eStateAttaching
            pass

    # 清理调试器
    lldb.SBDebugger.Destroy(debugger)

# 示例用法：
if __name__ == "__main__":
    # 假设你有一个名为 'a.out' 的 C 可执行文件
    # 编译一个简单的 C 程序：
    # int main(int argc, char *argv[]) {
    #     printf("Hello from C!\n");
    #     for (int i = 0; i < argc; i++) {
    #         printf("argv[%d]: %s\n", i, argv[i]);
    #     }
    #     return 0;
    # }
    # gcc -o a.out your_program.c

    # 确保 'a.out' 在当前目录或指定完整路径
    executable_path = "./a.out" 

    # 传递给 C 程序的命令行参数
    command_line_args = ["arg1", "another_arg", "last_one"] 

    if os.path.exists(executable_path):
        debug_c_program(executable_path, [executable_path] + command_line_args)
    else:
        print(f"错误: 可执行文件 '{executable_path}' 不存在。请先编译 C 程序。")