# 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.'
)
Codebase Browser
llvm