[Lldb-commits] [lldb] r255697 - First pass at LLDBRPC.framework
Greg Clayton via lldb-commits
lldb-commits at lists.llvm.org
Tue Dec 15 15:10:42 PST 2015
Xcode checked stuff in incorrectly from another project that contained the LLDB.framework that I built. I will be removing ASAP.
> On Dec 15, 2015, at 3:09 PM, Zachary Turner <zturner at google.com> wrote:
>
> Can you explain this? Why are we upstreaming a second copy of SB headers and clang headers? This looks like something that should be out of tree
>
> On Tue, Dec 15, 2015 at 3:06 PM Greg Clayton via lldb-commits <lldb-commits at lists.llvm.org> wrote:
> Added: lldb/trunk/build/Debug/LLDB.framework/Versions/A/Resources/Python/lldb/macosx/crashlog.py
> URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/build/Debug/LLDB.framework/Versions/A/Resources/Python/lldb/macosx/crashlog.py?rev=255697&view=auto
> ==============================================================================
> --- lldb/trunk/build/Debug/LLDB.framework/Versions/A/Resources/Python/lldb/macosx/crashlog.py (added)
> +++ lldb/trunk/build/Debug/LLDB.framework/Versions/A/Resources/Python/lldb/macosx/crashlog.py Tue Dec 15 17:03:22 2015
> @@ -0,0 +1,829 @@
> +#!/usr/bin/python
> +
> +#----------------------------------------------------------------------
> +# Be sure to add the python path that points to the LLDB shared library.
> +#
> +# To use this in the embedded python interpreter using "lldb":
> +#
> +# cd /path/containing/crashlog.py
> +# lldb
> +# (lldb) script import crashlog
> +# "crashlog" command installed, type "crashlog --help" for detailed help
> +# (lldb) crashlog ~/Library/Logs/DiagnosticReports/a.crash
> +#
> +# The benefit of running the crashlog command inside lldb in the
> +# embedded python interpreter is when the command completes, there
> +# will be a target with all of the files loaded at the locations
> +# described in the crash log. Only the files that have stack frames
> +# in the backtrace will be loaded unless the "--load-all" option
> +# has been specified. This allows users to explore the program in the
> +# state it was in right at crash time.
> +#
> +# On MacOSX csh, tcsh:
> +# ( setenv PYTHONPATH /path/to/LLDB.framework/Resources/Python ; ./crashlog.py ~/Library/Logs/DiagnosticReports/a.crash )
> +#
> +# On MacOSX sh, bash:
> +# PYTHONPATH=/path/to/LLDB.framework/Resources/Python ./crashlog.py ~/Library/Logs/DiagnosticReports/a.crash
> +#----------------------------------------------------------------------
> +
> +import commands
> +import cmd
> +import datetime
> +import glob
> +import optparse
> +import os
> +import platform
> +import plistlib
> +import pprint # pp = pprint.PrettyPrinter(indent=4); pp.pprint(command_args)
> +import re
> +import shlex
> +import string
> +import sys
> +import time
> +import uuid
> +
> +try:
> + # Just try for LLDB in case PYTHONPATH is already correctly setup
> + import lldb
> +except ImportError:
> + lldb_python_dirs = list()
> + # lldb is not in the PYTHONPATH, try some defaults for the current platform
> + platform_system = platform.system()
> + if platform_system == 'Darwin':
> + # On Darwin, try the currently selected Xcode directory
> + xcode_dir = commands.getoutput("xcode-select --print-path")
> + if xcode_dir:
> + lldb_python_dirs.append(os.path.realpath(xcode_dir + '/../SharedFrameworks/LLDB.framework/Resources/Python'))
> + lldb_python_dirs.append(xcode_dir + '/Library/PrivateFrameworks/LLDB.framework/Resources/Python')
> + lldb_python_dirs.append('/System/Library/PrivateFrameworks/LLDB.framework/Resources/Python')
> + success = False
> + for lldb_python_dir in lldb_python_dirs:
> + if os.path.exists(lldb_python_dir):
> + if not (sys.path.__contains__(lldb_python_dir)):
> + sys.path.append(lldb_python_dir)
> + try:
> + import lldb
> + except ImportError:
> + pass
> + else:
> + print 'imported lldb from: "%s"' % (lldb_python_dir)
> + success = True
> + break
> + if not success:
> + print "error: couldn't locate the 'lldb' module, please set PYTHONPATH correctly"
> + sys.exit(1)
> +
> +from lldb.utils import symbolication
> +
> +PARSE_MODE_NORMAL = 0
> +PARSE_MODE_THREAD = 1
> +PARSE_MODE_IMAGES = 2
> +PARSE_MODE_THREGS = 3
> +PARSE_MODE_SYSTEM = 4
> +
> +class CrashLog(symbolication.Symbolicator):
> + """Class that does parses darwin crash logs"""
> + parent_process_regex = re.compile('^Parent Process:\s*(.*)\[(\d+)\]');
> + thread_state_regex = re.compile('^Thread ([0-9]+) crashed with')
> + thread_regex = re.compile('^Thread ([0-9]+)([^:]*):(.*)')
> + app_backtrace_regex = re.compile('^Application Specific Backtrace ([0-9]+)([^:]*):(.*)')
> + frame_regex = re.compile('^([0-9]+)\s+([^ ]+)\s+(0x[0-9a-fA-F]+) +(.*)')
> + image_regex_uuid = re.compile('(0x[0-9a-fA-F]+)[- ]+(0x[0-9a-fA-F]+) +[+]?([^ ]+) +([^<]+)<([-0-9a-fA-F]+)> (.*)');
> + image_regex_no_uuid = re.compile('(0x[0-9a-fA-F]+)[- ]+(0x[0-9a-fA-F]+) +[+]?([^ ]+) +([^/]+)/(.*)');
> + empty_line_regex = re.compile('^$')
> +
> + class Thread:
> + """Class that represents a thread in a darwin crash log"""
> + def __init__(self, index, app_specific_backtrace):
> + self.index = index
> + self.frames = list()
> + self.idents = list()
> + self.registers = dict()
> + self.reason = None
> + self.queue = None
> + self.app_specific_backtrace = app_specific_backtrace
> +
> + def dump(self, prefix):
> + if self.app_specific_backtrace:
> + print "%Application Specific Backtrace[%u] %s" % (prefix, self.index, self.reason)
> + else:
> + print "%sThread[%u] %s" % (prefix, self.index, self.reason)
> + if self.frames:
> + print "%s Frames:" % (prefix)
> + for frame in self.frames:
> + frame.dump(prefix + ' ')
> + if self.registers:
> + print "%s Registers:" % (prefix)
> + for reg in self.registers.keys():
> + print "%s %-5s = %#16.16x" % (prefix, reg, self.registers[reg])
> +
> + def dump_symbolicated (self, crash_log, options):
> + this_thread_crashed = self.app_specific_backtrace
> + if not this_thread_crashed:
> + this_thread_crashed = self.did_crash()
> + if options.crashed_only and this_thread_crashed == False:
> + return
> +
> + print "%s" % self
> + #prev_frame_index = -1
> + display_frame_idx = -1
> + for frame_idx, frame in enumerate(self.frames):
> + disassemble = (this_thread_crashed or options.disassemble_all_threads) and frame_idx < options.disassemble_depth;
> + if frame_idx == 0:
> + symbolicated_frame_addresses = crash_log.symbolicate (frame.pc & crash_log.addr_mask, options.verbose)
> + else:
> + # Any frame above frame zero and we have to subtract one to get the previous line entry
> + symbolicated_frame_addresses = crash_log.symbolicate ((frame.pc & crash_log.addr_mask) - 1, options.verbose)
> +
> + if symbolicated_frame_addresses:
> + symbolicated_frame_address_idx = 0
> + for symbolicated_frame_address in symbolicated_frame_addresses:
> + display_frame_idx += 1
> + print '[%3u] %s' % (frame_idx, symbolicated_frame_address)
> + if (options.source_all or self.did_crash()) and display_frame_idx < options.source_frames and options.source_context:
> + source_context = options.source_context
> + line_entry = symbolicated_frame_address.get_symbol_context().line_entry
> + if line_entry.IsValid():
> + strm = lldb.SBStream()
> + if line_entry:
> + lldb.debugger.GetSourceManager().DisplaySourceLinesWithLineNumbers(line_entry.file, line_entry.line, source_context, source_context, "->", strm)
> + source_text = strm.GetData()
> + if source_text:
> + # Indent the source a bit
> + indent_str = ' '
> + join_str = '\n' + indent_str
> + print '%s%s' % (indent_str, join_str.join(source_text.split('\n')))
> + if symbolicated_frame_address_idx == 0:
> + if disassemble:
> + instructions = symbolicated_frame_address.get_instructions()
> + if instructions:
> + print
> + symbolication.disassemble_instructions (crash_log.get_target(),
> + instructions,
> + frame.pc,
> + options.disassemble_before,
> + options.disassemble_after, frame.index > 0)
> + print
> + symbolicated_frame_address_idx += 1
> + else:
> + print frame
> +
> + def add_ident(self, ident):
> + if not ident in self.idents:
> + self.idents.append(ident)
> +
> + def did_crash(self):
> + return self.reason != None
> +
> + def __str__(self):
> + if self.app_specific_backtrace:
> + s = "Application Specific Backtrace[%u]" % self.index
> + else:
> + s = "Thread[%u]" % self.index
> + if self.reason:
> + s += ' %s' % self.reason
> + return s
> +
> +
> + class Frame:
> + """Class that represents a stack frame in a thread in a darwin crash log"""
> + def __init__(self, index, pc, description):
> + self.pc = pc
> + self.description = description
> + self.index = index
> +
> + def __str__(self):
> + if self.description:
> + return "[%3u] 0x%16.16x %s" % (self.index, self.pc, self.description)
> + else:
> + return "[%3u] 0x%16.16x" % (self.index, self.pc)
> +
> + def dump(self, prefix):
> + print "%s%s" % (prefix, str(self))
> +
> + class DarwinImage(symbolication.Image):
> + """Class that represents a binary images in a darwin crash log"""
> + dsymForUUIDBinary = os.path.expanduser('~rc/bin/dsymForUUID')
> + if not os.path.exists(dsymForUUIDBinary):
> + dsymForUUIDBinary = commands.getoutput('which dsymForUUID')
> +
> + dwarfdump_uuid_regex = re.compile('UUID: ([-0-9a-fA-F]+) \(([^\(]+)\) .*')
> +
> + def __init__(self, text_addr_lo, text_addr_hi, identifier, version, uuid, path):
> + symbolication.Image.__init__(self, path, uuid);
> + self.add_section (symbolication.Section(text_addr_lo, text_addr_hi, "__TEXT"))
> + self.identifier = identifier
> + self.version = version
> +
> + def locate_module_and_debug_symbols(self):
> + # Don't load a module twice...
> + if self.resolved:
> + return True
> + # Mark this as resolved so we don't keep trying
> + self.resolved = True
> + uuid_str = self.get_normalized_uuid_string()
> + print 'Getting symbols for %s %s...' % (uuid_str, self.path),
> + if os.path.exists(self.dsymForUUIDBinary):
> + dsym_for_uuid_command = '%s %s' % (self.dsymForUUIDBinary, uuid_str)
> + s = commands.getoutput(dsym_for_uuid_command)
> + if s:
> + plist_root = plistlib.readPlistFromString (s)
> + if plist_root:
> + plist = plist_root[uuid_str]
> + if plist:
> + if 'DBGArchitecture' in plist:
> + self.arch = plist['DBGArchitecture']
> + if 'DBGDSYMPath' in plist:
> + self.symfile = os.path.realpath(plist['DBGDSYMPath'])
> + if 'DBGSymbolRichExecutable' in plist:
> + self.path = os.path.expanduser (plist['DBGSymbolRichExecutable'])
> + self.resolved_path = self.path
> + if not self.resolved_path and os.path.exists(self.path):
> + dwarfdump_cmd_output = commands.getoutput('dwarfdump --uuid "%s"' % self.path)
> + self_uuid = self.get_uuid()
> + for line in dwarfdump_cmd_output.splitlines():
> + match = self.dwarfdump_uuid_regex.search (line)
> + if match:
> + dwarf_uuid_str = match.group(1)
> + dwarf_uuid = uuid.UUID(dwarf_uuid_str)
> + if self_uuid == dwarf_uuid:
> + self.resolved_path = self.path
> + self.arch = match.group(2)
> + break;
> + if not self.resolved_path:
> + self.unavailable = True
> + print "error\n error: unable to locate '%s' with UUID %s" % (self.path, uuid_str)
> + return False
> + if (self.resolved_path and os.path.exists(self.resolved_path)) or (self.path and os.path.exists(self.path)):
> + print 'ok'
> + # if self.resolved_path:
> + # print ' exe = "%s"' % self.resolved_path
> + # if self.symfile:
> + # print ' dsym = "%s"' % self.symfile
> + return True
> + else:
> + self.unavailable = True
> + return False
> +
> +
> +
> + def __init__(self, path):
> + """CrashLog constructor that take a path to a darwin crash log file"""
> + symbolication.Symbolicator.__init__(self);
> + self.path = os.path.expanduser(path);
> + self.info_lines = list()
> + self.system_profile = list()
> + self.threads = list()
> + self.backtraces = list() # For application specific backtraces
> + self.idents = list() # A list of the required identifiers for doing all stack backtraces
> + self.crashed_thread_idx = -1
> + self.version = -1
> + self.error = None
> + self.target = None
> + # With possible initial component of ~ or ~user replaced by that user's home directory.
> + try:
> + f = open(self.path)
> + except IOError:
> + self.error = 'error: cannot open "%s"' % self.path
> + return
> +
> + self.file_lines = f.read().splitlines()
> + parse_mode = PARSE_MODE_NORMAL
> + thread = None
> + app_specific_backtrace = False
> + for line in self.file_lines:
> + # print line
> + line_len = len(line)
> + if line_len == 0:
> + if thread:
> + if parse_mode == PARSE_MODE_THREAD:
> + if thread.index == self.crashed_thread_idx:
> + thread.reason = ''
> + if self.thread_exception:
> + thread.reason += self.thread_exception
> + if self.thread_exception_data:
> + thread.reason += " (%s)" % self.thread_exception_data
> + if app_specific_backtrace:
> + self.backtraces.append(thread)
> + else:
> + self.threads.append(thread)
> + thread = None
> + else:
> + # only append an extra empty line if the previous line
> + # in the info_lines wasn't empty
> + if len(self.info_lines) > 0 and len(self.info_lines[-1]):
> + self.info_lines.append(line)
> + parse_mode = PARSE_MODE_NORMAL
> + # print 'PARSE_MODE_NORMAL'
> + elif parse_mode == PARSE_MODE_NORMAL:
> + if line.startswith ('Process:'):
> + (self.process_name, pid_with_brackets) = line[8:].strip().split(' [')
> + self.process_id = pid_with_brackets.strip('[]')
> + elif line.startswith ('Path:'):
> + self.process_path = line[5:].strip()
> + elif line.startswith ('Identifier:'):
> + self.process_identifier = line[11:].strip()
> + elif line.startswith ('Version:'):
> + version_string = line[8:].strip()
> + matched_pair = re.search("(.+)\((.+)\)", version_string)
> + if matched_pair:
> + self.process_version = matched_pair.group(1)
> + self.process_compatability_version = matched_pair.group(2)
> + else:
> + self.process = version_string
> + self.process_compatability_version = version_string
> + elif self.parent_process_regex.search(line):
> + parent_process_match = self.parent_process_regex.search(line)
> + self.parent_process_name = parent_process_match.group(1)
> + self.parent_process_id = parent_process_match.group(2)
> + elif line.startswith ('Exception Type:'):
> + self.thread_exception = line[15:].strip()
> + continue
> + elif line.startswith ('Exception Codes:'):
> + self.thread_exception_data = line[16:].strip()
> + continue
> + elif line.startswith ('Crashed Thread:'):
> + self.crashed_thread_idx = int(line[15:].strip().split()[0])
> + continue
> + elif line.startswith ('Report Version:'):
> + self.version = int(line[15:].strip())
> + continue
> + elif line.startswith ('System Profile:'):
> + parse_mode = PARSE_MODE_SYSTEM
> + continue
> + elif (line.startswith ('Interval Since Last Report:') or
> + line.startswith ('Crashes Since Last Report:') or
> + line.startswith ('Per-App Interval Since Last Report:') or
> + line.startswith ('Per-App Crashes Since Last Report:') or
> + line.startswith ('Sleep/Wake UUID:') or
> + line.startswith ('Anonymous UUID:')):
> + # ignore these
> + continue
> + elif line.startswith ('Thread'):
> + thread_state_match = self.thread_state_regex.search (line)
> + if thread_state_match:
> + app_specific_backtrace = False
> + thread_state_match = self.thread_regex.search (line)
> + thread_idx = int(thread_state_match.group(1))
> + parse_mode = PARSE_MODE_THREGS
> + thread = self.threads[thread_idx]
> + else:
> + thread_match = self.thread_regex.search (line)
> + if thread_match:
> + app_specific_backtrace = False
> + parse_mode = PARSE_MODE_THREAD
> + thread_idx = int(thread_match.group(1))
> + thread = CrashLog.Thread(thread_idx, False)
> + continue
> + elif line.startswith ('Binary Images:'):
> + parse_mode = PARSE_MODE_IMAGES
> + continue
> + elif line.startswith ('Application Specific Backtrace'):
> + app_backtrace_match = self.app_backtrace_regex.search (line)
> + if app_backtrace_match:
> + parse_mode = PARSE_MODE_THREAD
> + app_specific_backtrace = True
> + idx = int(app_backtrace_match.group(1))
> + thread = CrashLog.Thread(idx, True)
> + self.info_lines.append(line.strip())
> + elif parse_mode == PARSE_MODE_THREAD:
> + if line.startswith ('Thread'):
> + continue
> + frame_match = self.frame_regex.search(line)
> + if frame_match:
> + ident = frame_match.group(2)
> + thread.add_ident(ident)
> + if not ident in self.idents:
> + self.idents.append(ident)
> + thread.frames.append (CrashLog.Frame(int(frame_match.group(1)), int(frame_match.group(3), 0), frame_match.group(4)))
> + else:
> + print 'error: frame regex failed for line: "%s"' % line
> + elif parse_mode == PARSE_MODE_IMAGES:
> + image_match = self.image_regex_uuid.search (line)
> + if image_match:
> + image = CrashLog.DarwinImage (int(image_match.group(1),0),
> + int(image_match.group(2),0),
> + image_match.group(3).strip(),
> + image_match.group(4).strip(),
> + uuid.UUID(image_match.group(5)),
> + image_match.group(6))
> + self.images.append (image)
> + else:
> + image_match = self.image_regex_no_uuid.search (line)
> + if image_match:
> + image = CrashLog.DarwinImage (int(image_match.group(1),0),
> + int(image_match.group(2),0),
> + image_match.group(3).strip(),
> + image_match.group(4).strip(),
> + None,
> + image_match.group(5))
> + self.images.append (image)
> + else:
> + print "error: image regex failed for: %s" % line
> +
> + elif parse_mode == PARSE_MODE_THREGS:
> + stripped_line = line.strip()
> + # "r12: 0x00007fff6b5939c8 r13: 0x0000000007000006 r14: 0x0000000000002a03 r15: 0x0000000000000c00"
> + reg_values = re.findall ('([a-zA-Z0-9]+: 0[Xx][0-9a-fA-F]+) *', stripped_line);
> + for reg_value in reg_values:
> + #print 'reg_value = "%s"' % reg_value
> + (reg, value) = reg_value.split(': ')
> + #print 'reg = "%s"' % reg
> + #print 'value = "%s"' % value
> + thread.registers[reg.strip()] = int(value, 0)
> + elif parse_mode == PARSE_MODE_SYSTEM:
> + self.system_profile.append(line)
> + f.close()
> +
> + def dump(self):
> + print "Crash Log File: %s" % (self.path)
> + if self.backtraces:
> + print "\nApplication Specific Backtraces:"
> + for thread in self.backtraces:
> + thread.dump(' ')
> + print "\nThreads:"
> + for thread in self.threads:
> + thread.dump(' ')
> + print "\nImages:"
> + for image in self.images:
> + image.dump(' ')
> +
> + def find_image_with_identifier(self, identifier):
> + for image in self.images:
> + if image.identifier == identifier:
> + return image
> + regex_text = '^.*\.%s$' % (identifier)
> + regex = re.compile(regex_text)
> + for image in self.images:
> + if regex.match(image.identifier):
> + return image
> + return None
> +
> + def create_target(self):
> + #print 'crashlog.create_target()...'
> + if self.target is None:
> + self.target = symbolication.Symbolicator.create_target(self)
> + if self.target:
> + return self.target
> + # We weren't able to open the main executable as, but we can still symbolicate
> + print 'crashlog.create_target()...2'
> + if self.idents:
> + for ident in self.idents:
> + image = self.find_image_with_identifier (ident)
> + if image:
> + self.target = image.create_target ()
> + if self.target:
> + return self.target # success
> + print 'crashlog.create_target()...3'
> + for image in self.images:
> + self.target = image.create_target ()
> + if self.target:
> + return self.target # success
> + print 'crashlog.create_target()...4'
> + print 'error: unable to locate any executables from the crash log'
> + return self.target
> +
> + def get_target(self):
> + return self.target
> +
> +def usage():
> + print "Usage: lldb-symbolicate.py [-n name] executable-image"
> + sys.exit(0)
> +
> +class Interactive(cmd.Cmd):
> + '''Interactive prompt for analyzing one or more Darwin crash logs, type "help" to see a list of supported commands.'''
> + image_option_parser = None
> +
> + def __init__(self, crash_logs):
> + cmd.Cmd.__init__(self)
> + self.use_rawinput = False
> + self.intro = 'Interactive crashlogs prompt, type "help" to see a list of supported commands.'
> + self.crash_logs = crash_logs
> + self.prompt = '% '
> +
> + def default(self, line):
> + '''Catch all for unknown command, which will exit the interpreter.'''
> + print "uknown command: %s" % line
> + return True
> +
> + def do_q(self, line):
> + '''Quit command'''
> + return True
> +
> + def do_quit(self, line):
> + '''Quit command'''
> + return True
> +
> + def do_symbolicate(self, line):
> + description='''Symbolicate one or more darwin crash log files by index to provide source file and line information,
> + inlined stack frames back to the concrete functions, and disassemble the location of the crash
> + for the first frame of the crashed thread.'''
> + option_parser = CreateSymbolicateCrashLogOptions ('symbolicate', description, False)
> + command_args = shlex.split(line)
> + try:
> + (options, args) = option_parser.parse_args(command_args)
> + except:
> + return
> +
> + if args:
> + # We have arguments, they must valid be crash log file indexes
> + for idx_str in args:
> + idx = int(idx_str)
> + if idx < len(self.crash_logs):
> + SymbolicateCrashLog (self.crash_logs[idx], options)
> + else:
> + print 'error: crash log index %u is out of range' % (idx)
> + else:
> + # No arguments, symbolicate all crash logs using the options provided
> + for idx in range(len(self.crash_logs)):
> + SymbolicateCrashLog (self.crash_logs[idx], options)
> +
> + def do_list(self, line=None):
> + '''Dump a list of all crash logs that are currently loaded.
> +
> + USAGE: list'''
> + print '%u crash logs are loaded:' % len(self.crash_logs)
> + for (crash_log_idx, crash_log) in enumerate(self.crash_logs):
> + print '[%u] = %s' % (crash_log_idx, crash_log.path)
> +
> + def do_image(self, line):
> + '''Dump information about one or more binary images in the crash log given an image basename, or all images if no arguments are provided.'''
> + usage = "usage: %prog [options] <PATH> [PATH ...]"
> + description='''Dump information about one or more images in all crash logs. The <PATH> can be a full path, image basename, or partial path. Searches are done in this order.'''
> + command_args = shlex.split(line)
> + if not self.image_option_parser:
> + self.image_option_parser = optparse.OptionParser(description=description, prog='image',usage=usage)
> + self.image_option_parser.add_option('-a', '--all', action='store_true', help='show all images', default=False)
> + try:
> + (options, args) = self.image_option_parser.parse_args(command_args)
> + except:
> + return
> +
> + if args:
> + for image_path in args:
> + fullpath_search = image_path[0] == '/'
> + for (crash_log_idx, crash_log) in enumerate(self.crash_logs):
> + matches_found = 0
> + for (image_idx, image) in enumerate(crash_log.images):
> + if fullpath_search:
> + if image.get_resolved_path() == image_path:
> + matches_found += 1
> + print '[%u] ' % (crash_log_idx), image
> + else:
> + image_basename = image.get_resolved_path_basename()
> + if image_basename == image_path:
> + matches_found += 1
> + print '[%u] ' % (crash_log_idx), image
> + if matches_found == 0:
> + for (image_idx, image) in enumerate(crash_log.images):
> + resolved_image_path = image.get_resolved_path()
> + if resolved_image_path and string.find(image.get_resolved_path(), image_path) >= 0:
> + print '[%u] ' % (crash_log_idx), image
> + else:
> + for crash_log in self.crash_logs:
> + for (image_idx, image) in enumerate(crash_log.images):
> + print '[%u] %s' % (image_idx, image)
> + return False
> +
> +
> +def interactive_crashlogs(options, args):
> + crash_log_files = list()
> + for arg in args:
> + for resolved_path in glob.glob(arg):
> + crash_log_files.append(resolved_path)
> +
> + crash_logs = list();
> + for crash_log_file in crash_log_files:
> + #print 'crash_log_file = "%s"' % crash_log_file
> + crash_log = CrashLog(crash_log_file)
> + if crash_log.error:
> + print crash_log.error
> + continue
> + if options.debug:
> + crash_log.dump()
> + if not crash_log.images:
> + print 'error: no images in crash log "%s"' % (crash_log)
> + continue
> + else:
> + crash_logs.append(crash_log)
> +
> + interpreter = Interactive(crash_logs)
> + # List all crash logs that were imported
> + interpreter.do_list()
> + interpreter.cmdloop()
> +
> +
> +def save_crashlog(debugger, command, result, dict):
> + usage = "usage: %prog [options] <output-path>"
> + description='''Export the state of current target into a crashlog file'''
> + parser = optparse.OptionParser(description=description, prog='save_crashlog',usage=usage)
> + parser.add_option('-v', '--verbose', action='store_true', dest='verbose', help='display verbose debug info', default=False)
> + try:
> + (options, args) = parser.parse_args(shlex.split(command))
> + except:
> + result.PutCString ("error: invalid options");
> + return
> + if len(args) != 1:
> + result.PutCString ("error: invalid arguments, a single output file is the only valid argument")
> + return
> + out_file = open(args[0], 'w')
> + if not out_file:
> + result.PutCString ("error: failed to open file '%s' for writing...", args[0]);
> + return
> + target = debugger.GetSelectedTarget()
> + if target:
> + identifier = target.executable.basename
> + if lldb.process:
> + pid = lldb.process.id
> + if pid != lldb.LLDB_INVALID_PROCESS_ID:
> + out_file.write('Process: %s [%u]\n' % (identifier, pid))
> + out_file.write('Path: %s\n' % (target.executable.fullpath))
> + out_file.write('Identifier: %s\n' % (identifier))
> + out_file.write('\nDate/Time: %s\n' % (datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
> + out_file.write('OS Version: Mac OS X %s (%s)\n' % (platform.mac_ver()[0], commands.getoutput('sysctl -n kern.osversion')));
> + out_file.write('Report Version: 9\n')
> + for thread_idx in range(lldb.process.num_threads):
> + thread = lldb.process.thread[thread_idx]
> + out_file.write('\nThread %u:\n' % (thread_idx))
> + for (frame_idx, frame) in enumerate(thread.frames):
> + frame_pc = frame.pc
> + frame_offset = 0
> + if frame.function:
> + block = frame.GetFrameBlock()
> + block_range = block.range[frame.addr]
> + if block_range:
> + block_start_addr = block_range[0]
> + frame_offset = frame_pc - block_start_addr.load_addr
> + else:
> + frame_offset = frame_pc - frame.function.addr.load_addr
> + elif frame.symbol:
> + frame_offset = frame_pc - frame.symbol.addr.load_addr
> + out_file.write('%-3u %-32s 0x%16.16x %s' % (frame_idx, frame.module.file.basename, frame_pc, frame.name))
> + if frame_offset > 0:
> + out_file.write(' + %u' % (frame_offset))
> + line_entry = frame.line_entry
> + if line_entry:
> + if options.verbose:
> + # This will output the fullpath + line + column
> + out_file.write(' %s' % (line_entry))
> + else:
> + out_file.write(' %s:%u' % (line_entry.file.basename, line_entry.line))
> + column = line_entry.column
> + if column:
> + out_file.write(':%u' % (column))
> + out_file.write('\n')
> +
> + out_file.write('\nBinary Images:\n')
> + for module in target.modules:
> + text_segment = module.section['__TEXT']
> + if text_segment:
> + text_segment_load_addr = text_segment.GetLoadAddress(target)
> + if text_segment_load_addr != lldb.LLDB_INVALID_ADDRESS:
> + text_segment_end_load_addr = text_segment_load_addr + text_segment.size
> + identifier = module.file.basename
> + module_version = '???'
> + module_version_array = module.GetVersion()
> + if module_version_array:
> + module_version = '.'.join(map(str,module_version_array))
> + out_file.write (' 0x%16.16x - 0x%16.16x %s (%s - ???) <%s> %s\n' % (text_segment_load_addr, text_segment_end_load_addr, identifier, module_version, module.GetUUIDString(), module.file.fullpath))
> + out_file.close()
> + else:
> + result.PutCString ("error: invalid target");
> +
> +
> +def Symbolicate(debugger, command, result, dict):
> + try:
> + SymbolicateCrashLogs (shlex.split(command))
> + except:
> + result.PutCString ("error: python exception %s" % sys.exc_info()[0])
> +
> +def SymbolicateCrashLog(crash_log, options):
> + if crash_log.error:
> + print crash_log.error
> + return
> + if options.debug:
> + crash_log.dump()
> + if not crash_log.images:
> + print 'error: no images in crash log'
> + return
> +
> + if options.dump_image_list:
> + print "Binary Images:"
> + for image in crash_log.images:
> + if options.verbose:
> + print image.debug_dump()
> + else:
> + print image
> +
> + target = crash_log.create_target ()
> + if not target:
> + return
> + exe_module = target.GetModuleAtIndex(0)
> + images_to_load = list()
> + loaded_images = list()
> + if options.load_all_images:
> + # --load-all option was specified, load everything up
> + for image in crash_log.images:
> + images_to_load.append(image)
> + else:
> + # Only load the images found in stack frames for the crashed threads
> + if options.crashed_only:
> + for thread in crash_log.threads:
> + if thread.did_crash():
> + for ident in thread.idents:
> + images = crash_log.find_images_with_identifier (ident)
> + if images:
> + for image in images:
> + images_to_load.append(image)
> + else:
> + print 'error: can\'t find image for identifier "%s"' % ident
> + else:
> + for ident in crash_log.idents:
> + images = crash_log.find_images_with_identifier (ident)
> + if images:
> + for image in images:
> + images_to_load.append(image)
> + else:
> + print 'error: can\'t find image for identifier "%s"' % ident
> +
> + for image in images_to_load:
> + if not image in loaded_images:
> + err = image.add_module (target)
> + if err:
> + print err
> + else:
> + #print 'loaded %s' % image
> + loaded_images.append(image)
> +
> + if crash_log.backtraces:
> + for thread in crash_log.backtraces:
> + thread.dump_symbolicated (crash_log, options)
> + print
> +
> + for thread in crash_log.threads:
> + thread.dump_symbolicated (crash_log, options)
> + print
> +
> +
> +def CreateSymbolicateCrashLogOptions(command_name, description, add_interactive_options):
> + usage = "usage: %prog [options] <FILE> [FILE ...]"
> + option_parser = optparse.OptionParser(description=description, prog='crashlog',usage=usage)
> + option_parser.add_option('--verbose' , '-v', action='store_true', dest='verbose', help='display verbose debug info', default=False)
> + option_parser.add_option('--debug' , '-g', action='store_true', dest='debug', help='display verbose debug logging', default=False)
> + option_parser.add_option('--load-all' , '-a', action='store_true', dest='load_all_images', help='load all executable images, not just the images found in the crashed stack frames', default=False)
> + option_parser.add_option('--images' , action='store_true', dest='dump_image_list', help='show image list', default=False)
> + option_parser.add_option('--debug-delay' , type='int', dest='debug_delay', metavar='NSEC', help='pause for NSEC seconds for debugger', default=0)
> + option_parser.add_option('--crashed-only' , '-c', action='store_true', dest='crashed_only', help='only symbolicate the crashed thread', default=False)
> + option_parser.add_option('--disasm-depth' , '-d', type='int', dest='disassemble_depth', help='set the depth in stack frames that should be disassembled (default is 1)', default=1)
> + option_parser.add_option('--disasm-all' , '-D', action='store_true', dest='disassemble_all_threads', help='enabled disassembly of frames on all threads (not just the crashed thread)', default=False)
> + option_parser.add_option('--disasm-before' , '-B', type='int', dest='disassemble_before', help='the number of instructions to disassemble before the frame PC', default=4)
> + option_parser.add_option('--disasm-after' , '-A', type='int', dest='disassemble_after', help='the number of instructions to disassemble after the frame PC', default=4)
> + option_parser.add_option('--source-context', '-C', type='int', metavar='NLINES', dest='source_context', help='show NLINES source lines of source context (default = 4)', default=4)
> + option_parser.add_option('--source-frames' , type='int', metavar='NFRAMES', dest='source_frames', help='show source for NFRAMES (default = 4)', default=4)
> + option_parser.add_option('--source-all' , action='store_true', dest='source_all', help='show source for all threads, not just the crashed thread', default=False)
> + if add_interactive_options:
> + option_parser.add_option('-i', '--interactive', action='store_true', help='parse all crash logs and enter interactive mode', default=False)
> + return option_parser
> +
> +def SymbolicateCrashLogs(command_args):
> + description='''Symbolicate one or more darwin crash log files to provide source file and line information,
> +inlined stack frames back to the concrete functions, and disassemble the location of the crash
> +for the first frame of the crashed thread.
> +If this script is imported into the LLDB command interpreter, a "crashlog" command will be added to the interpreter
> +for use at the LLDB command line. After a crash log has been parsed and symbolicated, a target will have been
> +created that has all of the shared libraries loaded at the load addresses found in the crash log file. This allows
> +you to explore the program as if it were stopped at the locations described in the crash log and functions can
> +be disassembled and lookups can be performed using the addresses found in the crash log.'''
> + option_parser = CreateSymbolicateCrashLogOptions ('crashlog', description, True)
> + try:
> + (options, args) = option_parser.parse_args(command_args)
> + except:
> + return
> +
> + if options.debug:
> + print 'command_args = %s' % command_args
> + print 'options', options
> + print 'args', args
> +
> + if options.debug_delay > 0:
> + print "Waiting %u seconds for debugger to attach..." % options.debug_delay
> + time.sleep(options.debug_delay)
> + error = lldb.SBError()
> +
> + if args:
> + if options.interactive:
> + interactive_crashlogs(options, args)
> + else:
> + for crash_log_file in args:
> + crash_log = CrashLog(crash_log_file)
> + SymbolicateCrashLog (crash_log, options)
> +if __name__ == '__main__':
> + # Create a new debugger instance
> + lldb.debugger = lldb.SBDebugger.Create()
> + SymbolicateCrashLogs (sys.argv[1:])
> + lldb.SBDebugger.Destroy (lldb.debugger)
> +elif getattr(lldb, 'debugger', None):
> + lldb.debugger.HandleCommand('command script add -f lldb.macosx.crashlog.Symbolicate crashlog')
> + lldb.debugger.HandleCommand('command script add -f lldb.macosx.crashlog.save_crashlog save_crashlog')
> + print '"crashlog" and "save_crashlog" command installed, use the "--help" option for detailed help'
> +
>
> Propchange: lldb/trunk/build/Debug/LLDB.framework/Versions/A/Resources/Python/lldb/macosx/crashlog.py
> ------------------------------------------------------------------------------
> svn:executable = *
>
> Added: lldb/trunk/build/Debug/LLDB.framework/Versions/A/Resources/Python/lldb/macosx/heap.py
> URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/build/Debug/LLDB.framework/Versions/A/Resources/Python/lldb/macosx/heap.py?rev=255697&view=auto
> ==============================================================================
> --- lldb/trunk/build/Debug/LLDB.framework/Versions/A/Resources/Python/lldb/macosx/heap.py (added)
> +++ lldb/trunk/build/Debug/LLDB.framework/Versions/A/Resources/Python/lldb/macosx/heap.py Tue Dec 15 17:03:22 2015
> @@ -0,0 +1,1244 @@
> +#!/usr/bin/python
> +
> +#----------------------------------------------------------------------
> +# This module is designed to live inside the "lldb" python package
> +# in the "lldb.macosx" package. To use this in the embedded python
> +# interpreter using "lldb" just import it:
> +#
> +# (lldb) script import lldb.macosx.heap
> +#----------------------------------------------------------------------
> +
> +import lldb
> +import commands
> +import optparse
> +import os
> +import os.path
> +import re
> +import shlex
> +import string
> +import sys
> +import tempfile
> +import lldb.utils.symbolication
> +
> +g_libheap_dylib_dir = None
> +g_libheap_dylib_dict = dict()
> +
> +def get_iterate_memory_expr(options, process, user_init_code, user_return_code):
> + expr = '''
> +typedef unsigned natural_t;
> +typedef uintptr_t vm_size_t;
> +typedef uintptr_t vm_address_t;
> +typedef natural_t task_t;
> +typedef int kern_return_t;
> +#define KERN_SUCCESS 0
> +typedef void (*range_callback_t)(task_t task, void *baton, unsigned type, uintptr_t ptr_addr, uintptr_t ptr_size);
> +''';
> + if options.search_vm_regions:
> + expr += '''
> +typedef int vm_prot_t;
> +typedef unsigned int vm_inherit_t;
> +typedef unsigned long long memory_object_offset_t;
> +typedef unsigned int boolean_t;
> +typedef int vm_behavior_t;
> +typedef uint32_t vm32_object_id_t;
> +typedef natural_t mach_msg_type_number_t;
> +typedef uint64_t mach_vm_address_t;
> +typedef uint64_t mach_vm_offset_t;
> +typedef uint64_t mach_vm_size_t;
> +typedef uint64_t vm_map_offset_t;
> +typedef uint64_t vm_map_address_t;
> +typedef uint64_t vm_map_size_t;
> +#define VM_PROT_NONE ((vm_prot_t) 0x00)
> +#define VM_PROT_READ ((vm_prot_t) 0x01)
> +#define VM_PROT_WRITE ((vm_prot_t) 0x02)
> +#define VM_PROT_EXECUTE ((vm_prot_t) 0x04)
> +typedef struct vm_region_submap_short_info_data_64_t {
> + vm_prot_t protection;
> + vm_prot_t max_protection;
> + vm_inherit_t inheritance;
> + memory_object_offset_t offset; // offset into object/map
> + unsigned int user_tag; // user tag on map entry
> + unsigned int ref_count; // obj/map mappers, etc
> + unsigned short shadow_depth; // only for obj
> + unsigned char external_pager; // only for obj
> + unsigned char share_mode; // see enumeration
> + boolean_t is_submap; // submap vs obj
> + vm_behavior_t behavior; // access behavior hint
> + vm32_object_id_t object_id; // obj/map name, not a handle
> + unsigned short user_wired_count;
> +} vm_region_submap_short_info_data_64_t;
> +#define VM_REGION_SUBMAP_SHORT_INFO_COUNT_64 ((mach_msg_type_number_t)(sizeof(vm_region_submap_short_info_data_64_t)/sizeof(int)))''';
> + if user_init_code:
> + expr += user_init_code;
> + expr += '''
> +task_t task = (task_t)mach_task_self();
> +mach_vm_address_t vm_region_base_addr;
> +mach_vm_size_t vm_region_size;
> +natural_t vm_region_depth;
> +vm_region_submap_short_info_data_64_t vm_region_info;
> +kern_return_t err;
> +for (vm_region_base_addr = 0, vm_region_size = 1; vm_region_size != 0; vm_region_base_addr += vm_region_size)
> +{
> + mach_msg_type_number_t vm_region_info_size = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
> + err = (kern_return_t)mach_vm_region_recurse (task,
> + &vm_region_base_addr,
> + &vm_region_size,
> + &vm_region_depth,
> + &vm_region_info,
> + &vm_region_info_size);
> + if (err)
> + break;
> + // Check all read + write regions. This will cover the thread stacks
> + // and any regions of memory like __DATA segments, that might contain
> + // data we are looking for
> + if (vm_region_info.protection & VM_PROT_WRITE &&
> + vm_region_info.protection & VM_PROT_READ)
> + {
> + baton.callback (task,
> + &baton,
> + 64,
> + vm_region_base_addr,
> + vm_region_size);
> + }
> +}'''
> + else:
> + if options.search_stack:
> + expr += get_thread_stack_ranges_struct (process)
> + if options.search_segments:
> + expr += get_sections_ranges_struct (process)
> + if user_init_code:
> + expr += user_init_code
> + if options.search_heap:
> + expr += '''
> +#define MALLOC_PTR_IN_USE_RANGE_TYPE 1
> +typedef struct vm_range_t {
> + vm_address_t address;
> + vm_size_t size;
> +} vm_range_t;
> +typedef kern_return_t (*memory_reader_t)(task_t task, vm_address_t remote_address, vm_size_t size, void **local_memory);
> +typedef void (*vm_range_recorder_t)(task_t task, void *baton, unsigned type, vm_range_t *range, unsigned size);
> +typedef struct malloc_introspection_t {
> + kern_return_t (*enumerator)(task_t task, void *, unsigned type_mask, vm_address_t zone_address, memory_reader_t reader, vm_range_recorder_t recorder); /* enumerates all the malloc pointers in use */
> +} malloc_introspection_t;
> +typedef struct malloc_zone_t {
> + void *reserved1[12];
> + struct malloc_introspection_t *introspect;
> +} malloc_zone_t;
> +memory_reader_t task_peek = [](task_t task, vm_address_t remote_address, vm_size_t size, void **local_memory) -> kern_return_t {
> + *local_memory = (void*) remote_address;
> + return KERN_SUCCESS;
> +};
> +vm_address_t *zones = 0;
> +unsigned int num_zones = 0;task_t task = 0;
> +kern_return_t err = (kern_return_t)malloc_get_all_zones (task, task_peek, &zones, &num_zones);
> +if (KERN_SUCCESS == err)
> +{
> + for (unsigned int i=0; i<num_zones; ++i)
> + {
> + const malloc_zone_t *zone = (const malloc_zone_t *)zones[i];
> + if (zone && zone->introspect)
> + zone->introspect->enumerator (task,
> + &baton,
> + MALLOC_PTR_IN_USE_RANGE_TYPE,
> + (vm_address_t)zone,
> + task_peek,
> + [] (task_t task, void *baton, unsigned type, vm_range_t *ranges, unsigned size) -> void
> + {
> + range_callback_t callback = ((callback_baton_t *)baton)->callback;
> + for (unsigned i=0; i<size; ++i)
> + {
> + callback (task, baton, type, ranges[i].address, ranges[i].size);
> + }
> + });
> + }
> +}'''
> +
> + if options.search_stack:
> + expr += '''
> +#ifdef NUM_STACKS
> +// Call the callback for the thread stack ranges
> +for (uint32_t i=0; i<NUM_STACKS; ++i) {
> + range_callback(task, &baton, 8, stacks[i].base, stacks[i].size);
> + if (STACK_RED_ZONE_SIZE > 0) {
> + range_callback(task, &baton, 16, stacks[i].base - STACK_RED_ZONE_SIZE, STACK_RED_ZONE_SIZE);
> + }
> +}
> +#endif'''
> +
> + if options.search_segments:
> + expr += '''
> +#ifdef NUM_SEGMENTS
> +// Call the callback for all segments
> +for (uint32_t i=0; i<NUM_SEGMENTS; ++i)
> + range_callback(task, &baton, 32, segments[i].base, segments[i].size);
> +#endif'''
> +
> + if user_return_code:
> + expr += "\n%s" % (user_return_code,)
> +
> + return expr
> +
> +def get_member_types_for_offset(value_type, offset, member_list):
> + member = value_type.GetFieldAtIndex(0)
> + search_bases = False
> + if member:
> + if member.GetOffsetInBytes() <= offset:
> + for field_idx in range (value_type.GetNumberOfFields()):
> + member = value_type.GetFieldAtIndex(field_idx)
> + member_byte_offset = member.GetOffsetInBytes()
> + member_end_byte_offset = member_byte_offset + member.type.size
> + if member_byte_offset <= offset and offset < member_end_byte_offset:
> + member_list.append(member)
> + get_member_types_for_offset (member.type, offset - member_byte_offset, member_list)
> + return
> + else:
> + search_bases = True
> + else:
> + search_bases = True
> + if search_bases:
> + for field_idx in range (value_type.GetNumberOfDirectBaseClasses()):
> + member = value_type.GetDirectBaseClassAtIndex(field_idx)
> + member_byte_offset = member.GetOffsetInBytes()
> + member_end_byte_offset = member_byte_offset + member.type.size
> + if member_byte_offset <= offset and offset < member_end_byte_offset:
> + member_list.append(member)
> + get_member_types_for_offset (member.type, offset - member_byte_offset, member_list)
> + return
> + for field_idx in range (value_type.GetNumberOfVirtualBaseClasses()):
> + member = value_type.GetVirtualBaseClassAtIndex(field_idx)
> + member_byte_offset = member.GetOffsetInBytes()
> + member_end_byte_offset = member_byte_offset + member.type.size
> + if member_byte_offset <= offset and offset < member_end_byte_offset:
> + member_list.append(member)
> + get_member_types_for_offset (member.type, offset - member_byte_offset, member_list)
> + return
> +
> +def append_regex_callback(option, opt, value, parser):
> + try:
> + ivar_regex = re.compile(value)
> + parser.values.ivar_regex_blacklist.append(ivar_regex)
> + except:
> + print 'error: an exception was thrown when compiling the ivar regular expression for "%s"' % value
> +
> +def add_common_options(parser):
> + parser.add_option('-v', '--verbose', action='store_true', dest='verbose', help='display verbose debug info', default=False)
> + parser.add_option('-t', '--type', action='store_true', dest='print_type', help='print the full value of the type for each matching malloc block', default=False)
> + parser.add_option('-o', '--po', action='store_true', dest='print_object_description', help='print the object descriptions for any matches', default=False)
> + parser.add_option('-z', '--size', action='store_true', dest='show_size', help='print the allocation size in bytes', default=False)
> + parser.add_option('-r', '--range', action='store_true', dest='show_range', help='print the allocation address range instead of just the allocation base address', default=False)
> + parser.add_option('-m', '--memory', action='store_true', dest='memory', help='dump the memory for each matching block', default=False)
> + parser.add_option('-f', '--format', type='string', dest='format', help='the format to use when dumping memory if --memory is specified', default=None)
> + parser.add_option('-I', '--omit-ivar-regex', type='string', action='callback', callback=append_regex_callback, dest='ivar_regex_blacklist', default=[], help='specify one or more regular expressions used to backlist any matches that are in ivars')
> + parser.add_option('-s', '--stack', action='store_true', dest='stack', help='gets the stack that allocated each malloc block if MallocStackLogging is enabled', default=False)
> + parser.add_option('-S', '--stack-history', action='store_true', dest='stack_history', help='gets the stack history for all allocations whose start address matches each malloc block if MallocStackLogging is enabled', default=False)
> + parser.add_option('-F', '--max-frames', type='int', dest='max_frames', help='the maximum number of stack frames to print when using the --stack or --stack-history options (default=128)', default=128)
> + parser.add_option('-H', '--max-history', type='int', dest='max_history', help='the maximum number of stack history backtraces to print for each allocation when using the --stack-history option (default=16)', default=16)
> + parser.add_option('-M', '--max-matches', type='int', dest='max_matches', help='the maximum number of matches to print', default=32)
> + parser.add_option('-O', '--offset', type='int', dest='offset', help='the matching data must be at this offset', default=-1)
> + parser.add_option('--ignore-stack', action='store_false', dest='search_stack', help="Don't search the stack when enumerating memory", default=True)
> + parser.add_option('--ignore-heap', action='store_false', dest='search_heap', help="Don't search the heap allocations when enumerating memory", default=True)
> + parser.add_option('--ignore-segments', action='store_false', dest='search_segments', help="Don't search readable executable segments enumerating memory", default=True)
> + parser.add_option('-V', '--vm-regions', action='store_true', dest='search_vm_regions', help='Check all VM regions instead of searching the heap, stack and segments', default=False)
> +
> +def type_flags_to_string(type_flags):
> + if type_flags == 0:
> + type_str = 'free'
> + elif type_flags & 2:
> + type_str = 'malloc'
> + elif type_flags & 4:
> + type_str = 'free'
> + elif type_flags & 1:
> + type_str = 'generic'
> + elif type_flags & 8:
> + type_str = 'stack'
> + elif type_flags & 16:
> + type_str = 'stack (red zone)'
> + elif type_flags & 32:
> + type_str = 'segment'
> + elif type_flags & 64:
> + type_str = 'vm_region'
> + else:
> + type_str = hex(type_flags)
> + return type_str
> +
> +def find_variable_containing_address(verbose, frame, match_addr):
> + variables = frame.GetVariables(True,True,True,True)
> + matching_var = None
> + for var in variables:
> + var_addr = var.GetLoadAddress()
> + if var_addr != lldb.LLDB_INVALID_ADDRESS:
> + byte_size = var.GetType().GetByteSize()
> + if verbose:
> + print 'frame #%u: [%#x - %#x) %s' % (frame.GetFrameID(), var.load_addr, var.load_addr + byte_size, var.name)
> + if var_addr == match_addr:
> + if verbose:
> + print 'match'
> + return var
> + else:
> + if byte_size > 0 and var_addr <= match_addr and match_addr < (var_addr + byte_size):
> + if verbose:
> + print 'match'
> + return var
> + return None
> +
> +def find_frame_for_stack_address(process, addr):
> + closest_delta = sys.maxint
> + closest_frame = None
> + #print 'find_frame_for_stack_address(%#x)' % (addr)
> + for thread in process:
> + prev_sp = lldb.LLDB_INVALID_ADDRESS
> + for frame in thread:
> + cfa = frame.GetCFA()
> + #print 'frame #%u: cfa = %#x' % (frame.GetFrameID(), cfa)
> + if addr < cfa:
> + delta = cfa - addr
> + #print '%#x < %#x, delta = %
More information about the lldb-commits
mailing list