# This implements the "diagnose-unwind" command, usually installed
# in the debug session like
#   command script import lldb.diagnose
# it is used when lldb's backtrace fails -- it collects and prints
# information about the stack frames, and tries an alternate unwind
# algorithm, that will help to understand why lldb's unwind algorithm
# did not succeed.

import optparse
import lldb
import re
import shlex

# Print the frame number, pc, frame pointer, module UUID and function name
# Returns the SBModule that contains the PC, if it could be found


def backtrace_print_frame(target, frame_num, addr, fp):
    process = target.GetProcess()
    addr_for_printing = addr
    addr_width = process.GetAddressByteSize() * 2
    if frame_num > 0:
        addr = addr - 1

    sbaddr = lldb.SBAddress()
    try:
        sbaddr.SetLoadAddress(addr, target)
        module_description = ""
        if sbaddr.GetModule():
            module_filename = ""
            module_uuid_str = sbaddr.GetModule().GetUUIDString()
            if module_uuid_str is None:
                module_uuid_str = ""
            if sbaddr.GetModule().GetFileSpec():
                module_filename = sbaddr.GetModule().GetFileSpec().GetFilename()
                if module_filename is None:
                    module_filename = ""
            if module_uuid_str != "" or module_filename != "":
                module_description = "%s %s" % (module_filename, module_uuid_str)
    except Exception:
        print(
            "%2d: pc==0x%-*x fp==0x%-*x"
            % (frame_num, addr_width, addr_for_printing, addr_width, fp)
        )
        return

    sym_ctx = target.ResolveSymbolContextForAddress(
        sbaddr, lldb.eSymbolContextEverything
    )
    if sym_ctx.IsValid() and sym_ctx.GetSymbol().IsValid():
        function_start = sym_ctx.GetSymbol().GetStartAddress().GetLoadAddress(target)
        offset = addr - function_start
        print(
            "%2d: pc==0x%-*x fp==0x%-*x %s %s + %d"
            % (
                frame_num,
                addr_width,
                addr_for_printing,
                addr_width,
                fp,
                module_description,
                sym_ctx.GetSymbol().GetName(),
                offset,
            )
        )
    else:
        print(
            "%2d: pc==0x%-*x fp==0x%-*x %s"
            % (
                frame_num,
                addr_width,
                addr_for_printing,
                addr_width,
                fp,
                module_description,
            )
        )
    return sbaddr.GetModule()


# A simple stack walk algorithm that follows the frame chain.
# Returns a two-element list; the first element is a list of modules
# seen and the second element is a list of addresses seen during the backtrace.


def simple_backtrace(debugger):
    target = debugger.GetSelectedTarget()
    process = target.GetProcess()
    cur_thread = process.GetSelectedThread()

    initial_fp = cur_thread.GetFrameAtIndex(0).GetFP()

    # If the pseudoreg "fp" isn't recognized, on arm hardcode to r7 which is
    # correct for Darwin programs.
    if initial_fp == lldb.LLDB_INVALID_ADDRESS and target.triple[0:3] == "arm":
        for reggroup in cur_thread.GetFrameAtIndex(1).registers:
            if reggroup.GetName() == "General Purpose Registers":
                for reg in reggroup:
                    if reg.GetName() == "r7":
                        initial_fp = int(reg.GetValue(), 16)

    module_list = []
    address_list = [cur_thread.GetFrameAtIndex(0).GetPC()]
    this_module = backtrace_print_frame(
        target, 0, cur_thread.GetFrameAtIndex(0).GetPC(), initial_fp
    )
    print_stack_frame(process, initial_fp)
    print("")
    if this_module is not None:
        module_list.append(this_module)
    if cur_thread.GetNumFrames() < 2:
        return [module_list, address_list]

    cur_fp = process.ReadPointerFromMemory(initial_fp, lldb.SBError())
    cur_pc = process.ReadPointerFromMemory(
        initial_fp + process.GetAddressByteSize(), lldb.SBError()
    )

    frame_num = 1

    while (
        cur_pc != 0
        and cur_fp != 0
        and cur_pc != lldb.LLDB_INVALID_ADDRESS
        and cur_fp != lldb.LLDB_INVALID_ADDRESS
    ):
        address_list.append(cur_pc)
        this_module = backtrace_print_frame(target, frame_num, cur_pc, cur_fp)
        print_stack_frame(process, cur_fp)
        print("")
        if this_module is not None:
            module_list.append(this_module)
        frame_num = frame_num + 1
        next_pc = 0
        next_fp = 0
        if (
            target.triple[0:6] == "x86_64"
            or target.triple[0:4] == "i386"
            or target.triple[0:3] == "arm"
        ):
            error = lldb.SBError()
            next_pc = process.ReadPointerFromMemory(
                cur_fp + process.GetAddressByteSize(), error
            )
            if not error.Success():
                next_pc = 0
            next_fp = process.ReadPointerFromMemory(cur_fp, error)
            if not error.Success():
                next_fp = 0
        # Clear the 0th bit for arm frames - this indicates it is a thumb frame
        if target.triple[0:3] == "arm" and (next_pc & 1) == 1:
            next_pc = next_pc & ~1
        cur_pc = next_pc
        cur_fp = next_fp
    this_module = backtrace_print_frame(target, frame_num, cur_pc, cur_fp)
    print_stack_frame(process, cur_fp)
    print("")
    if this_module is not None:
        module_list.append(this_module)
    return [module_list, address_list]


def print_stack_frame(process, fp):
    if fp == 0 or fp == lldb.LLDB_INVALID_ADDRESS or fp == 1:
        return
    addr_size = process.GetAddressByteSize()
    addr = fp - (2 * addr_size)
    i = 0
    outline = "Stack frame from $fp-%d: " % (2 * addr_size)
    error = lldb.SBError()
    try:
        while i < 5 and error.Success():
            address = process.ReadPointerFromMemory(addr + (i * addr_size), error)
            outline += " 0x%x" % address
            i += 1
        print(outline)
    except Exception:
        return


def diagnose_unwind(debugger, command, result, dict):
    """
    Gather diagnostic information to help debug incorrect unwind (backtrace)
    behavior in lldb.  When there is a backtrace that doesn't look
    correct, run this command with the correct thread selected and a
    large amount of diagnostic information will be printed, it is likely
    to be helpful when reporting the problem.
    """

    command_args = shlex.split(command)
    parser = create_diagnose_unwind_options()
    try:
        (options, args) = parser.parse_args(command_args)
    except:
        return
    target = debugger.GetSelectedTarget()
    if target:
        process = target.GetProcess()
        if process:
            thread = process.GetSelectedThread()
            if thread:
                lldb_versions_match = re.search(
                    r"[lL][lL][dD][bB]-(\d+)([.](\d+))?([.](\d+))?",
                    debugger.GetVersionString(),
                )
                lldb_version = 0
                lldb_minor = 0
                if (
                    len(lldb_versions_match.groups()) >= 1
                    and lldb_versions_match.groups()[0]
                ):
                    lldb_major = int(lldb_versions_match.groups()[0])
                if (
                    len(lldb_versions_match.groups()) >= 5
                    and lldb_versions_match.groups()[4]
                ):
                    lldb_minor = int(lldb_versions_match.groups()[4])

                modules_seen = []
                addresses_seen = []

                print("LLDB version %s" % debugger.GetVersionString())
                print("Unwind diagnostics for thread %d" % thread.GetIndexID())
                print("")
                print(
                    "============================================================================================="
                )
                print("")
                print("OS plugin setting:")
                debugger.HandleCommand(
                    "settings show target.process.python-os-plugin-path"
                )
                print("")
                print("Live register context:")
                thread.SetSelectedFrame(0)
                debugger.HandleCommand("register read")
                print("")
                print(
                    "============================================================================================="
                )
                print("")
                print("lldb's unwind algorithm:")
                print("")
                frame_num = 0
                for frame in thread.frames:
                    if not frame.IsInlined():
                        this_module = backtrace_print_frame(
                            target, frame_num, frame.GetPC(), frame.GetFP()
                        )
                        print_stack_frame(process, frame.GetFP())
                        print("")
                        if this_module is not None:
                            modules_seen.append(this_module)
                        addresses_seen.append(frame.GetPC())
                        frame_num = frame_num + 1
                print("")
                print(
                    "============================================================================================="
                )
                print("")
                print("Simple stack walk algorithm:")
                print("")
                (module_list, address_list) = simple_backtrace(debugger)
                if module_list and module_list is not None:
                    modules_seen += module_list
                if address_list and address_list is not None:
                    addresses_seen = set(addresses_seen)
                    addresses_seen.update(set(address_list))

                print("")
                print(
                    "============================================================================================="
                )
                print("")
                print("Modules seen in stack walks:")
                print("")
                modules_already_seen = set()
                for module in modules_seen:
                    if (
                        module is not None
                        and module.GetFileSpec().GetFilename() is not None
                    ):
                        if (
                            not module.GetFileSpec().GetFilename()
                            in modules_already_seen
                        ):
                            debugger.HandleCommand(
                                "image list %s" % module.GetFileSpec().GetFilename()
                            )
                            modules_already_seen.add(module.GetFileSpec().GetFilename())

                print("")
                print(
                    "============================================================================================="
                )
                print("")
                print("Disassembly ofaddresses seen in stack walks:")
                print("")
                additional_addresses_to_disassemble = addresses_seen
                for frame in thread.frames:
                    if not frame.IsInlined():
                        print(
                            "--------------------------------------------------------------------------------------"
                        )
                        print("")
                        print(
                            "Disassembly of %s, frame %d, address 0x%x"
                            % (
                                frame.GetFunctionName(),
                                frame.GetFrameID(),
                                frame.GetPC(),
                            )
                        )
                        print("")
                        if (
                            target.triple[0:6] == "x86_64"
                            or target.triple[0:4] == "i386"
                        ):
                            debugger.HandleCommand(
                                "disassemble -F att -a 0x%x" % frame.GetPC()
                            )
                        else:
                            debugger.HandleCommand(
                                "disassemble -a 0x%x" % frame.GetPC()
                            )
                        if frame.GetPC() in additional_addresses_to_disassemble:
                            additional_addresses_to_disassemble.remove(frame.GetPC())

                for address in list(additional_addresses_to_disassemble):
                    print(
                        "--------------------------------------------------------------------------------------"
                    )
                    print("")
                    print("Disassembly of 0x%x" % address)
                    print("")
                    if target.triple[0:6] == "x86_64" or target.triple[0:4] == "i386":
                        debugger.HandleCommand("disassemble -F att -a 0x%x" % address)
                    else:
                        debugger.HandleCommand("disassemble -a 0x%x" % address)

                print("")
                print(
                    "============================================================================================="
                )
                print("")
                additional_addresses_to_show_unwind = addresses_seen
                for frame in thread.frames:
                    if not frame.IsInlined():
                        print(
                            "--------------------------------------------------------------------------------------"
                        )
                        print("")
                        print(
                            "Unwind instructions for %s, frame %d"
                            % (frame.GetFunctionName(), frame.GetFrameID())
                        )
                        print("")
                        debugger.HandleCommand(
                            'image show-unwind -a "0x%x"' % frame.GetPC()
                        )
                        if frame.GetPC() in additional_addresses_to_show_unwind:
                            additional_addresses_to_show_unwind.remove(frame.GetPC())

                for address in list(additional_addresses_to_show_unwind):
                    print(
                        "--------------------------------------------------------------------------------------"
                    )
                    print("")
                    print("Unwind instructions for 0x%x" % address)
                    print("")
                    debugger.HandleCommand('image show-unwind -a "0x%x"' % address)


def create_diagnose_unwind_options():
    usage = "usage: %prog"
    description = """Print diagnostic information about a thread backtrace which will help to debug unwind problems"""
    parser = optparse.OptionParser(
        description=description, prog="diagnose_unwind", usage=usage
    )
    return parser


def __lldb_init_module(debugger, internal_dict):
    debugger.HandleCommand(
        "command script add -o -f %s.diagnose_unwind diagnose-unwind" % __name__
    )
    print(
        'The "diagnose-unwind" command has been installed, type "help diagnose-unwind" for detailed help.'
    )