掌握LLDB Python调试C语言char类型变量

import lldb

def print_argv_with_synthetic(argv: lldb.SBValue):
    # 获取第一个参数
    if argv.GetNumChildren() > 0:
        first_arg = argv.GetChildAtIndex(0, lldb.eNoDynamicValues, True)
        if first_arg.IsValid():
            print(f"argv[0]: {first_arg.GetSummary().strip('\"')}")

    # 尝试获取第二个参数，使用 can_create_synthetic=True
    # lldb.eNoDynamicValues 表示不获取动态值，这对于静态字符串指针是合适的
    if argv.GetNumChildren() > 1: # 尽管GetNumChildren可能不准确，但可以尝试访问
        second_arg = argv.GetChildAtIndex(1, lldb.eNoDynamicValues, True)
        if second_arg.IsValid():
            print(f"argv[1]: {second_arg.GetSummary().strip('\"')}")
        else:
            print("Failed to get argv[1] with synthetic children.")
    else:
        print("argv does not seem to have enough children or GetNumChildren is inaccurate.")

# 示例调用 (假设已经获取了 argv 的 SBValue)
# print_argv_with_synthetic(argv_sbvalue)

import lldb

def print_argv_robust(argv_sbvalue: lldb.SBValue, argc_sbvalue: lldb.SBValue, target: lldb.SBTarget):
    """
    使用 argc 和 GetArrayType 打印 argv 中的所有字符串。

    Args:
        argv_sbvalue: 'char**' 类型的 lldb.SBValue 对象。
        argc_sbvalue: 'int' 类型的 lldb.SBValue 对象，包含 argv 的大小。
        target: 当前的 lldb.SBTarget 对象。
    """

    if not argv_sbvalue.IsValid() or not argc_sbvalue.IsValid():
        print("Error: argv or argc SBValue is invalid.")
        return

    argc_val = argc_sbvalue.GetValueAsUnsigned()
    if argc_val is None:
        print("Error: Could not get unsigned value from argc.")
        return

    # 1. 获取 argv 指向的类型，即 char*
    # argv_sbvalue 的类型是 char**，其指向的类型是 char*
    char_ptr_type = argv_sbvalue.GetType().GetPointeeType()
    if not char_ptr_type.IsValid():
        print("Error: Could not get char* type from argv.")
        return

    # 2. 根据 argc 的值，构建一个固定大小的 char* 数组类型
    # 例如，如果 argc=3，这里会得到 char*[3] 类型
    array_type = char_ptr_type.GetArrayType(argc_val)
    if not array_type.IsValid():
        print(f"Error: Could not create array type for size {argc_val}.")
        return

    # 3. 使用 argv 的地址和新的数组类型，创建一个表示整个数组的 SBValue
    # argv_sbvalue.GetLoadAddress() 获取 char** 本身在内存中的地址
    argv_array_sbvalue = target.CreateValueFromAddress(
        "argv_array", 
        argv_sbvalue.GetLoadAddress(), 
        array_type
    )

    if not argv_array_sbvalue.IsValid():
        print("Error: Could not create argv_array SBValue from address and type.")
        return

    print(f"Printing {argv_array_sbvalue.GetNumChildren()} arguments:")
    # 4. 遍历数组元素并打印
    for i in range(argv_array_sbvalue.GetNumChildren()):
        arg_child = argv_array_sbvalue.GetChildAtIndex(i)
        if arg_child.IsValid():
            # arg_child 现在是 char* 类型，可以直接 Dereference 或 GetSummary
            # GetSummary() 通常更方便，因为它会处理字符串内容
            summary = arg_child.GetSummary()
            if summary:
                # 移除可能的引号
                print(f"  argv[{i}]: {summary.strip('\"')}")
            else:
                print(f"  argv[{i}]: (Unable to get summary)")
        else:
            print(f"  argv[{i}]: (Invalid child)")

import lldb
import os

def setup_and_debug(binary_path: str, args: list, function_name: str):
    """
    设置 LLDB 调试器并执行目标程序，在指定函数处调用打印函数。

    Args:
        binary_path: 目标程序的路径。
        args: 传递给目标程序的命令行参数列表。
        function_name: 设置断点的函数名 (例如 "main")。
    """
    debugger = lldb.SBDebugger.Create()
    debugger.SetAsync(False) # 设置为同步模式，方便脚本控制

    # 创建目标
    target = debugger.CreateTargetWithFileAndArch(binary_path, lldb.LLDB_ARCH_DEFAULT)
    if not target:
        print(f"Error: Failed to create target for {binary_path}")
        return

    # 设置断点
    breakpoint = target.BreakpointCreateByName(function_name, target.GetExecutable().GetFilename())
    if not breakpoint.IsValid():
        print(f"Error: Failed to set breakpoint at {function_name}")
        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: Failed to launch process: {error.GetCString()}")
        return

    print(f"Process launched with PID: {process.GetProcessID()}")

    # 循环等待进程状态变化
    while True:
        state = process.GetState()

        if state == lldb.eStateStopped:
            print("Process stopped at breakpoint.")
            for thread in process:
                frame = thread.GetSelectedFrame() # 获取当前线程的当前帧
                if frame and frame.IsValid():
                    current_function_name = frame.GetFunctionName()
                    print(f"Current function: {current_function_name}")

                    if current_function_name == function_name:
                        # 查找 argc 和 argv 参数
                        argc_val = None
                        argv_val = None
                        for arg_sbvalue in frame.GetArguments():
                            if arg_sbvalue.GetName() == "argc":
                                argc_val = arg_sbvalue
                            elif arg_sbvalue.GetName() == "argv":
                                argv_val = arg_sbvalue

                        if argc_val and argv_val:
                            print_argv_robust(argv_val, argc_val, target)
                        else:
                            print("Could not find argc or argv in main function arguments.")

                    # 继续执行进程
                    process.Continue()
                    break # 跳出线程循环，继续等待进程状态

        elif state == lldb.eStateExited:
            print(f"Process exited with status: {process.GetExitStatus()}")
            break
        elif state == lldb.eStateRunning:
            # 进程正在运行，等待下一次状态变化
            pass
        else:
            # 其他状态，例如 eStateInvalid, eStateCrashed, eStateSuspended 等
            print(f"Process in unexpected state: {process.GetStateAsString()}")
            if state == lldb.eStateCrashed:
                print("Process crashed.")
            break

    lldb.SBDebugger.Destroy(debugger)

# 假设你的C程序编译后的可执行文件名为 'my_program'
# 且它接受命令行参数
# 示例 C 代码:
# int main(int argc, char *argv[]) {
#     printf("Hello, %s!\n", argv[1]);
#     return 0;
# }
if __name__ == "__main__":
    # 替换为你的实际可执行文件路径
    # 例如，如果你的 C 程序编译后在当前目录名为 'a.out'
    current_dir = os.path.dirname(os.path.abspath(__file__))
    binary_name = "a.out" # 假设你的可执行文件名为 a.out
    binary_path = os.path.join(current_dir, binary_name)

    # 命令行参数，注意第一个参数通常是程序名本身
    program_args = [binary_name, "World", "Test"] 

    # 确保可执行文件存在
    if not os.path.exists(binary_path):
        print(f"Error: Executable not found at {binary_path}. Please compile your C program first.")
        # 示例：你可以添加编译 C 程序的命令
        # import subprocess
        # subprocess.run(["gcc", "your_c_file.c", "-o", binary_name])
    else:
        setup_and_debug(binary_path, program_args, "main")