diff options
Diffstat (limited to 'gnu/llvm/lldb/examples/python/gdbremote.py')
| -rwxr-xr-x | gnu/llvm/lldb/examples/python/gdbremote.py | 1630 |
1 files changed, 1630 insertions, 0 deletions
diff --git a/gnu/llvm/lldb/examples/python/gdbremote.py b/gnu/llvm/lldb/examples/python/gdbremote.py new file mode 100755 index 00000000000..dcacbfccdaf --- /dev/null +++ b/gnu/llvm/lldb/examples/python/gdbremote.py @@ -0,0 +1,1630 @@ +#!/usr/bin/python + +#---------------------------------------------------------------------- +# This module will enable GDB remote packet logging when the +# 'start_gdb_log' command is called with a filename to log to. When the +# 'stop_gdb_log' command is called, it will disable the logging and +# print out statistics about how long commands took to execute and also +# will primnt ou +# Be sure to add the python path that points to the LLDB shared library. +# +# To use this in the embedded python interpreter using "lldb" just +# import it with the full path using the "command script import" +# command. This can be done from the LLDB command line: +# (lldb) command script import /path/to/gdbremote.py +# Or it can be added to your ~/.lldbinit file so this module is always +# available. +#---------------------------------------------------------------------- + +import binascii +import subprocess +import json +import math +import optparse +import os +import re +import shlex +import string +import sys +import tempfile +import xml.etree.ElementTree as ET + +#---------------------------------------------------------------------- +# Global variables +#---------------------------------------------------------------------- +g_log_file = '' +g_byte_order = 'little' +g_number_regex = re.compile('^(0x[0-9a-fA-F]+|[0-9]+)') +g_thread_id_regex = re.compile('^(-1|[0-9a-fA-F]+|0)') + + +class TerminalColors: + '''Simple terminal colors class''' + + def __init__(self, enabled=True): + # TODO: discover terminal type from "file" and disable if + # it can't handle the color codes + self.enabled = enabled + + def reset(self): + '''Reset all terminal colors and formatting.''' + if self.enabled: + return "\x1b[0m" + return '' + + def bold(self, on=True): + '''Enable or disable bold depending on the "on" parameter.''' + if self.enabled: + if on: + return "\x1b[1m" + else: + return "\x1b[22m" + return '' + + def italics(self, on=True): + '''Enable or disable italics depending on the "on" parameter.''' + if self.enabled: + if on: + return "\x1b[3m" + else: + return "\x1b[23m" + return '' + + def underline(self, on=True): + '''Enable or disable underline depending on the "on" parameter.''' + if self.enabled: + if on: + return "\x1b[4m" + else: + return "\x1b[24m" + return '' + + def inverse(self, on=True): + '''Enable or disable inverse depending on the "on" parameter.''' + if self.enabled: + if on: + return "\x1b[7m" + else: + return "\x1b[27m" + return '' + + def strike(self, on=True): + '''Enable or disable strike through depending on the "on" parameter.''' + if self.enabled: + if on: + return "\x1b[9m" + else: + return "\x1b[29m" + return '' + + def black(self, fg=True): + '''Set the foreground or background color to black. + The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.''' + if self.enabled: + if fg: + return "\x1b[30m" + else: + return "\x1b[40m" + return '' + + def red(self, fg=True): + '''Set the foreground or background color to red. + The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.''' + if self.enabled: + if fg: + return "\x1b[31m" + else: + return "\x1b[41m" + return '' + + def green(self, fg=True): + '''Set the foreground or background color to green. + The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.''' + if self.enabled: + if fg: + return "\x1b[32m" + else: + return "\x1b[42m" + return '' + + def yellow(self, fg=True): + '''Set the foreground or background color to yellow. + The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.''' + if self.enabled: + if fg: + return "\x1b[33m" + else: + return "\x1b[43m" + return '' + + def blue(self, fg=True): + '''Set the foreground or background color to blue. + The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.''' + if self.enabled: + if fg: + return "\x1b[34m" + else: + return "\x1b[44m" + return '' + + def magenta(self, fg=True): + '''Set the foreground or background color to magenta. + The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.''' + if self.enabled: + if fg: + return "\x1b[35m" + else: + return "\x1b[45m" + return '' + + def cyan(self, fg=True): + '''Set the foreground or background color to cyan. + The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.''' + if self.enabled: + if fg: + return "\x1b[36m" + else: + return "\x1b[46m" + return '' + + def white(self, fg=True): + '''Set the foreground or background color to white. + The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.''' + if self.enabled: + if fg: + return "\x1b[37m" + else: + return "\x1b[47m" + return '' + + def default(self, fg=True): + '''Set the foreground or background color to the default. + The foreground color will be set if "fg" tests True. The background color will be set if "fg" tests False.''' + if self.enabled: + if fg: + return "\x1b[39m" + else: + return "\x1b[49m" + return '' + + +def start_gdb_log(debugger, command, result, dict): + '''Start logging GDB remote packets by enabling logging with timestamps and + thread safe logging. Follow a call to this function with a call to "stop_gdb_log" + in order to dump out the commands.''' + global g_log_file + command_args = shlex.split(command) + usage = "usage: start_gdb_log [options] [<LOGFILEPATH>]" + description = '''The command enables GDB remote packet logging with timestamps. The packets will be logged to <LOGFILEPATH> if supplied, or a temporary file will be used. Logging stops when stop_gdb_log is called and the packet times will + be aggregated and displayed.''' + parser = optparse.OptionParser( + description=description, + prog='start_gdb_log', + 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(command_args) + except: + return + + if g_log_file: + result.PutCString( + 'error: logging is already in progress with file "%s"' % + g_log_file) + else: + args_len = len(args) + if args_len == 0: + g_log_file = tempfile.mktemp() + elif len(args) == 1: + g_log_file = args[0] + + if g_log_file: + debugger.HandleCommand( + 'log enable --threadsafe --timestamp --file "%s" gdb-remote packets' % + g_log_file) + result.PutCString( + "GDB packet logging enable with log file '%s'\nUse the 'stop_gdb_log' command to stop logging and show packet statistics." % + g_log_file) + return + + result.PutCString('error: invalid log file path') + result.PutCString(usage) + + +def stop_gdb_log(debugger, command, result, dict): + '''Stop logging GDB remote packets to the file that was specified in a call + to "start_gdb_log" and normalize the timestamps to be relative to the first + timestamp in the log file. Also print out statistics for how long each + command took to allow performance bottlenecks to be determined.''' + global g_log_file + # Any commands whose names might be followed by more valid C identifier + # characters must be listed here + command_args = shlex.split(command) + usage = "usage: stop_gdb_log [options]" + description = '''The command stops a previously enabled GDB remote packet logging command. Packet logging must have been previously enabled with a call to start_gdb_log.''' + parser = optparse.OptionParser( + description=description, + prog='stop_gdb_log', + usage=usage) + parser.add_option( + '-v', + '--verbose', + action='store_true', + dest='verbose', + help='display verbose debug info', + default=False) + parser.add_option( + '-q', + '--quiet', + action='store_true', + dest='quiet', + help='display verbose debug info', + default=False) + parser.add_option( + '-C', + '--color', + action='store_true', + dest='color', + help='add terminal colors', + default=False) + parser.add_option( + '-c', + '--sort-by-count', + action='store_true', + dest='sort_count', + help='display verbose debug info', + default=False) + parser.add_option( + '-s', + '--symbolicate', + action='store_true', + dest='symbolicate', + help='symbolicate addresses in log using current "lldb.target"', + default=False) + try: + (options, args) = parser.parse_args(command_args) + except: + return + options.colors = TerminalColors(options.color) + options.symbolicator = None + if options.symbolicate: + if lldb.target: + import lldb.utils.symbolication + options.symbolicator = lldb.utils.symbolication.Symbolicator() + options.symbolicator.target = lldb.target + else: + print("error: can't symbolicate without a target") + + if not g_log_file: + result.PutCString( + 'error: logging must have been previously enabled with a call to "stop_gdb_log"') + elif os.path.exists(g_log_file): + if len(args) == 0: + debugger.HandleCommand('log disable gdb-remote packets') + result.PutCString( + "GDB packet logging disabled. Logged packets are in '%s'" % + g_log_file) + parse_gdb_log_file(g_log_file, options) + else: + result.PutCString(usage) + else: + print('error: the GDB packet log file "%s" does not exist' % g_log_file) + + +def is_hex_byte(str): + if len(str) == 2: + return str[0] in string.hexdigits and str[1] in string.hexdigits + return False + +def get_hex_string_if_all_printable(str): + try: + s = binascii.unhexlify(str) + if all(c in string.printable for c in s): + return s + except TypeError: + pass + return None + +# global register info list +g_register_infos = list() +g_max_register_info_name_len = 0 + + +class RegisterInfo: + """Class that represents register information""" + + def __init__(self, kvp): + self.info = dict() + for kv in kvp: + key = kv[0] + value = kv[1] + self.info[key] = value + + def name(self): + '''Get the name of the register.''' + if self.info and 'name' in self.info: + return self.info['name'] + return None + + def bit_size(self): + '''Get the size in bits of the register.''' + if self.info and 'bitsize' in self.info: + return int(self.info['bitsize']) + return 0 + + def byte_size(self): + '''Get the size in bytes of the register.''' + return self.bit_size() / 8 + + def get_value_from_hex_string(self, hex_str): + '''Dump the register value given a native byte order encoded hex ASCII byte string.''' + encoding = self.info['encoding'] + bit_size = self.bit_size() + packet = Packet(hex_str) + if encoding == 'uint': + uval = packet.get_hex_uint(g_byte_order) + if bit_size == 8: + return '0x%2.2x' % (uval) + elif bit_size == 16: + return '0x%4.4x' % (uval) + elif bit_size == 32: + return '0x%8.8x' % (uval) + elif bit_size == 64: + return '0x%16.16x' % (uval) + bytes = list() + uval = packet.get_hex_uint8() + while uval is not None: + bytes.append(uval) + uval = packet.get_hex_uint8() + value_str = '0x' + if g_byte_order == 'little': + bytes.reverse() + for byte in bytes: + value_str += '%2.2x' % byte + return '%s' % (value_str) + + def __str__(self): + '''Dump the register info key/value pairs''' + s = '' + for key in self.info.keys(): + if s: + s += ', ' + s += "%s=%s " % (key, self.info[key]) + return s + + +class Packet: + """Class that represents a packet that contains string data""" + + def __init__(self, packet_str): + self.str = packet_str + + def peek_char(self): + ch = 0 + if self.str: + ch = self.str[0] + return ch + + def get_char(self): + ch = 0 + if self.str: + ch = self.str[0] + self.str = self.str[1:] + return ch + + def skip_exact_string(self, s): + if self.str and self.str.startswith(s): + self.str = self.str[len(s):] + return True + else: + return False + + def get_thread_id(self, fail_value=-1): + match = g_number_regex.match(self.str) + if match: + number_str = match.group(1) + self.str = self.str[len(number_str):] + return int(number_str, 0) + else: + return fail_value + + def get_hex_uint8(self): + if self.str and len(self.str) >= 2 and self.str[ + 0] in string.hexdigits and self.str[1] in string.hexdigits: + uval = int(self.str[0:2], 16) + self.str = self.str[2:] + return uval + return None + + def get_hex_uint16(self, byte_order): + uval = 0 + if byte_order == 'big': + uval |= self.get_hex_uint8() << 8 + uval |= self.get_hex_uint8() + else: + uval |= self.get_hex_uint8() + uval |= self.get_hex_uint8() << 8 + return uval + + def get_hex_uint32(self, byte_order): + uval = 0 + if byte_order == 'big': + uval |= self.get_hex_uint8() << 24 + uval |= self.get_hex_uint8() << 16 + uval |= self.get_hex_uint8() << 8 + uval |= self.get_hex_uint8() + else: + uval |= self.get_hex_uint8() + uval |= self.get_hex_uint8() << 8 + uval |= self.get_hex_uint8() << 16 + uval |= self.get_hex_uint8() << 24 + return uval + + def get_hex_uint64(self, byte_order): + uval = 0 + if byte_order == 'big': + uval |= self.get_hex_uint8() << 56 + uval |= self.get_hex_uint8() << 48 + uval |= self.get_hex_uint8() << 40 + uval |= self.get_hex_uint8() << 32 + uval |= self.get_hex_uint8() << 24 + uval |= self.get_hex_uint8() << 16 + uval |= self.get_hex_uint8() << 8 + uval |= self.get_hex_uint8() + else: + uval |= self.get_hex_uint8() + uval |= self.get_hex_uint8() << 8 + uval |= self.get_hex_uint8() << 16 + uval |= self.get_hex_uint8() << 24 + uval |= self.get_hex_uint8() << 32 + uval |= self.get_hex_uint8() << 40 + uval |= self.get_hex_uint8() << 48 + uval |= self.get_hex_uint8() << 56 + return uval + + def get_number(self, fail_value=-1): + '''Get a number from the packet. The number must be in big endian format and should be parsed + according to its prefix (starts with "0x" means hex, starts with "0" means octal, starts with + [1-9] means decimal, etc)''' + match = g_number_regex.match(self.str) + if match: + number_str = match.group(1) + self.str = self.str[len(number_str):] + return int(number_str, 0) + else: + return fail_value + + def get_hex_ascii_str(self, n=0): + hex_chars = self.get_hex_chars(n) + if hex_chars: + return binascii.unhexlify(hex_chars) + else: + return None + + def get_hex_chars(self, n=0): + str_len = len(self.str) + if n == 0: + # n was zero, so we need to determine all hex chars and + # stop when we hit the end of the string of a non-hex character + while n < str_len and self.str[n] in string.hexdigits: + n = n + 1 + else: + if n > str_len: + return None # Not enough chars + # Verify all chars are hex if a length was specified + for i in range(n): + if self.str[i] not in string.hexdigits: + return None # Not all hex digits + if n == 0: + return None + hex_str = self.str[0:n] + self.str = self.str[n:] + return hex_str + + def get_hex_uint(self, byte_order, n=0): + if byte_order == 'big': + hex_str = self.get_hex_chars(n) + if hex_str is None: + return None + return int(hex_str, 16) + else: + uval = self.get_hex_uint8() + if uval is None: + return None + uval_result = 0 + shift = 0 + while uval is not None: + uval_result |= (uval << shift) + shift += 8 + uval = self.get_hex_uint8() + return uval_result + + def get_key_value_pairs(self): + kvp = list() + if ';' in self.str: + key_value_pairs = string.split(self.str, ';') + for key_value_pair in key_value_pairs: + if len(key_value_pair): + kvp.append(string.split(key_value_pair, ':')) + return kvp + + def split(self, ch): + return string.split(self.str, ch) + + def split_hex(self, ch, byte_order): + hex_values = list() + strings = string.split(self.str, ch) + for str in strings: + hex_values.append(Packet(str).get_hex_uint(byte_order)) + return hex_values + + def __str__(self): + return self.str + + def __len__(self): + return len(self.str) + +g_thread_suffix_regex = re.compile(';thread:([0-9a-fA-F]+);') + + +def get_thread_from_thread_suffix(str): + if str: + match = g_thread_suffix_regex.match(str) + if match: + return int(match.group(1), 16) + return None + + +def cmd_qThreadStopInfo(options, cmd, args): + packet = Packet(args) + tid = packet.get_hex_uint('big') + print("get_thread_stop_info (tid = 0x%x)" % (tid)) + + +def cmd_stop_reply(options, cmd, args): + print("get_last_stop_info()") + return False + + +def rsp_stop_reply(options, cmd, cmd_args, rsp): + global g_byte_order + packet = Packet(rsp) + stop_type = packet.get_char() + if stop_type == 'T' or stop_type == 'S': + signo = packet.get_hex_uint8() + key_value_pairs = packet.get_key_value_pairs() + for key_value_pair in key_value_pairs: + key = key_value_pair[0] + if is_hex_byte(key): + reg_num = Packet(key).get_hex_uint8() + if reg_num < len(g_register_infos): + reg_info = g_register_infos[reg_num] + key_value_pair[0] = reg_info.name() + key_value_pair[1] = reg_info.get_value_from_hex_string( + key_value_pair[1]) + elif key == 'jthreads' or key == 'jstopinfo': + key_value_pair[1] = binascii.unhexlify(key_value_pair[1]) + key_value_pairs.insert(0, ['signal', signo]) + print('stop_reply():') + dump_key_value_pairs(key_value_pairs) + elif stop_type == 'W': + exit_status = packet.get_hex_uint8() + print('stop_reply(): exit (status=%i)' % exit_status) + elif stop_type == 'O': + print('stop_reply(): stdout = "%s"' % packet.str) + + +def cmd_unknown_packet(options, cmd, args): + if args: + print("cmd: %s, args: %s", cmd, args) + else: + print("cmd: %s", cmd) + return False + + +def cmd_qSymbol(options, cmd, args): + if args == ':': + print('ready to serve symbols') + else: + packet = Packet(args) + symbol_addr = packet.get_hex_uint('big') + if symbol_addr is None: + if packet.skip_exact_string(':'): + symbol_name = packet.get_hex_ascii_str() + print('lookup_symbol("%s") -> symbol not available yet' % (symbol_name)) + else: + print('error: bad command format') + else: + if packet.skip_exact_string(':'): + symbol_name = packet.get_hex_ascii_str() + print('lookup_symbol("%s") -> 0x%x' % (symbol_name, symbol_addr)) + else: + print('error: bad command format') + +def cmd_QSetWithHexString(options, cmd, args): + print('%s("%s")' % (cmd[:-1], binascii.unhexlify(args))) + +def cmd_QSetWithString(options, cmd, args): + print('%s("%s")' % (cmd[:-1], args)) + +def cmd_QSetWithUnsigned(options, cmd, args): + print('%s(%i)' % (cmd[:-1], int(args))) + +def rsp_qSymbol(options, cmd, cmd_args, rsp): + if len(rsp) == 0: + print("Unsupported") + else: + if rsp == "OK": + print("No more symbols to lookup") + else: + packet = Packet(rsp) + if packet.skip_exact_string("qSymbol:"): + symbol_name = packet.get_hex_ascii_str() + print('lookup_symbol("%s")' % (symbol_name)) + else: + print('error: response string should start with "qSymbol:": respnse is "%s"' % (rsp)) + + +def cmd_qXfer(options, cmd, args): + # $qXfer:features:read:target.xml:0,1ffff#14 + print("read target special data %s" % (args)) + return True + + +def rsp_qXfer(options, cmd, cmd_args, rsp): + data = string.split(cmd_args, ':') + if data[0] == 'features': + if data[1] == 'read': + filename, extension = os.path.splitext(data[2]) + if extension == '.xml': + response = Packet(rsp) + xml_string = response.get_hex_ascii_str() + if xml_string: + ch = xml_string[0] + if ch == 'l': + xml_string = xml_string[1:] + xml_root = ET.fromstring(xml_string) + for reg_element in xml_root.findall("./feature/reg"): + if not 'value_regnums' in reg_element.attrib: + reg_info = RegisterInfo([]) + if 'name' in reg_element.attrib: + reg_info.info[ + 'name'] = reg_element.attrib['name'] + else: + reg_info.info['name'] = 'unspecified' + if 'encoding' in reg_element.attrib: + reg_info.info['encoding'] = reg_element.attrib[ + 'encoding'] + else: + reg_info.info['encoding'] = 'uint' + if 'offset' in reg_element.attrib: + reg_info.info[ + 'offset'] = reg_element.attrib['offset'] + if 'bitsize' in reg_element.attrib: + reg_info.info[ + 'bitsize'] = reg_element.attrib['bitsize'] + g_register_infos.append(reg_info) + print('XML for "%s":' % (data[2])) + ET.dump(xml_root) + + +def cmd_A(options, cmd, args): + print('launch process:') + packet = Packet(args) + while True: + arg_len = packet.get_number() + if arg_len == -1: + break + if not packet.skip_exact_string(','): + break + arg_idx = packet.get_number() + if arg_idx == -1: + break + if not packet.skip_exact_string(','): + break + arg_value = packet.get_hex_ascii_str(arg_len) + print('argv[%u] = "%s"' % (arg_idx, arg_value)) + + +def cmd_qC(options, cmd, args): + print("query_current_thread_id()") + + +def rsp_qC(options, cmd, cmd_args, rsp): + packet = Packet(rsp) + if packet.skip_exact_string("QC"): + tid = packet.get_thread_id() + print("current_thread_id = %#x" % (tid)) + else: + print("current_thread_id = old thread ID") + + +def cmd_query_packet(options, cmd, args): + if args: + print("%s%s" % (cmd, args)) + else: + print("%s" % (cmd)) + return False + + +def rsp_ok_error(rsp): + print("rsp: ", rsp) + + +def rsp_ok_means_supported(options, cmd, cmd_args, rsp): + if rsp == 'OK': + print("%s%s is supported" % (cmd, cmd_args)) + elif rsp == '': + print("%s%s is not supported" % (cmd, cmd_args)) + else: + print("%s%s -> %s" % (cmd, cmd_args, rsp)) + + +def rsp_ok_means_success(options, cmd, cmd_args, rsp): + if rsp == 'OK': + print("success") + elif rsp == '': + print("%s%s is not supported" % (cmd, cmd_args)) + else: + print("%s%s -> %s" % (cmd, cmd_args, rsp)) + + +def dump_key_value_pairs(key_value_pairs): + max_key_len = 0 + for key_value_pair in key_value_pairs: + key_len = len(key_value_pair[0]) + if max_key_len < key_len: + max_key_len = key_len + for key_value_pair in key_value_pairs: + key = key_value_pair[0] + value = key_value_pair[1] + unhex_value = get_hex_string_if_all_printable(value) + if unhex_value: + print("%*s = %s (%s)" % (max_key_len, key, value, unhex_value)) + else: + print("%*s = %s" % (max_key_len, key, value)) + + +def rsp_dump_key_value_pairs(options, cmd, cmd_args, rsp): + if rsp: + print('%s response:' % (cmd)) + packet = Packet(rsp) + key_value_pairs = packet.get_key_value_pairs() + dump_key_value_pairs(key_value_pairs) + else: + print("not supported") + + +def cmd_c(options, cmd, args): + print("continue()") + return False + + +def cmd_s(options, cmd, args): + print("step()") + return False + + +def cmd_qSpeedTest(options, cmd, args): + print(("qSpeedTest: cmd='%s', args='%s'" % (cmd, args))) + + +def rsp_qSpeedTest(options, cmd, cmd_args, rsp): + print(("qSpeedTest: rsp='%s' cmd='%s', args='%s'" % (rsp, cmd, args))) + + +def cmd_vCont(options, cmd, args): + if args == '?': + print("%s: get supported extended continue modes" % (cmd)) + else: + got_other_threads = 0 + s = '' + for thread_action in string.split(args[1:], ';'): + (short_action, thread) = string.split(thread_action, ':') + tid = int(thread, 16) + if short_action == 'c': + action = 'continue' + elif short_action == 's': + action = 'step' + elif short_action[0] == 'C': + action = 'continue with signal 0x%s' % (short_action[1:]) + elif short_action == 'S': + action = 'step with signal 0x%s' % (short_action[1:]) + else: + action = short_action + if s: + s += ', ' + if tid == -1: + got_other_threads = 1 + s += 'other-threads:' + else: + s += 'thread 0x%4.4x: %s' % (tid, action) + if got_other_threads: + print("extended_continue (%s)" % (s)) + else: + print("extended_continue (%s, other-threads: suspend)" % (s)) + return False + + +def rsp_vCont(options, cmd, cmd_args, rsp): + if cmd_args == '?': + # Skip the leading 'vCont;' + rsp = rsp[6:] + modes = string.split(rsp, ';') + s = "%s: supported extended continue modes include: " % (cmd) + + for i, mode in enumerate(modes): + if i: + s += ', ' + if mode == 'c': + s += 'continue' + elif mode == 'C': + s += 'continue with signal' + elif mode == 's': + s += 'step' + elif mode == 'S': + s += 'step with signal' + elif mode == 't': + s += 'stop' + # else: + # s += 'unrecognized vCont mode: ', str(mode) + print(s) + elif rsp: + if rsp[0] == 'T' or rsp[0] == 'S' or rsp[0] == 'W' or rsp[0] == 'X': + rsp_stop_reply(options, cmd, cmd_args, rsp) + return + if rsp[0] == 'O': + print("stdout: %s" % (rsp)) + return + else: + print("not supported (cmd = '%s', args = '%s', rsp = '%s')" % (cmd, cmd_args, rsp)) + + +def cmd_vAttach(options, cmd, args): + (extra_command, args) = string.split(args, ';') + if extra_command: + print("%s%s(%s)" % (cmd, extra_command, args)) + else: + print("attach(pid = %u)" % int(args, 16)) + return False + + +def cmd_qRegisterInfo(options, cmd, args): + print('query_register_info(reg_num=%i)' % (int(args, 16))) + return False + + +def rsp_qRegisterInfo(options, cmd, cmd_args, rsp): + global g_max_register_info_name_len + print('query_register_info(reg_num=%i):' % (int(cmd_args, 16)), end=' ') + if len(rsp) == 3 and rsp[0] == 'E': + g_max_register_info_name_len = 0 + for reg_info in g_register_infos: + name_len = len(reg_info.name()) + if g_max_register_info_name_len < name_len: + g_max_register_info_name_len = name_len + print(' DONE') + else: + packet = Packet(rsp) + reg_info = RegisterInfo(packet.get_key_value_pairs()) + g_register_infos.append(reg_info) + print(reg_info) + return False + + +def cmd_qThreadInfo(options, cmd, args): + if cmd == 'qfThreadInfo': + query_type = 'first' + else: + query_type = 'subsequent' + print('get_current_thread_list(type=%s)' % (query_type)) + return False + + +def rsp_qThreadInfo(options, cmd, cmd_args, rsp): + packet = Packet(rsp) + response_type = packet.get_char() + if response_type == 'm': + tids = packet.split_hex(';', 'big') + for i, tid in enumerate(tids): + if i: + print(',', end=' ') + print('0x%x' % (tid), end=' ') + print() + elif response_type == 'l': + print('END') + + +def rsp_hex_big_endian(options, cmd, cmd_args, rsp): + if rsp == '': + print("%s%s is not supported" % (cmd, cmd_args)) + else: + packet = Packet(rsp) + uval = packet.get_hex_uint('big') + print('%s: 0x%x' % (cmd, uval)) + + +def cmd_read_mem_bin(options, cmd, args): + # x0x7fff5fc39200,0x200 + packet = Packet(args) + addr = packet.get_hex_uint('big') + comma = packet.get_char() + size = packet.get_hex_uint('big') + print('binary_read_memory (addr = 0x%16.16x, size = %u)' % (addr, size)) + return False + + +def rsp_mem_bin_bytes(options, cmd, cmd_args, rsp): + packet = Packet(cmd_args) + addr = packet.get_hex_uint('big') + comma = packet.get_char() + size = packet.get_hex_uint('big') + print('memory:') + if size > 0: + dump_hex_memory_buffer(addr, rsp) + + +def cmd_read_memory(options, cmd, args): + packet = Packet(args) + addr = packet.get_hex_uint('big') + comma = packet.get_char() + size = packet.get_hex_uint('big') + print('read_memory (addr = 0x%16.16x, size = %u)' % (addr, size)) + return False + + +def dump_hex_memory_buffer(addr, hex_byte_str): + packet = Packet(hex_byte_str) + idx = 0 + ascii = '' + uval = packet.get_hex_uint8() + while uval is not None: + if ((idx % 16) == 0): + if ascii: + print(' ', ascii) + ascii = '' + print('0x%x:' % (addr + idx), end=' ') + print('%2.2x' % (uval), end=' ') + if 0x20 <= uval and uval < 0x7f: + ascii += '%c' % uval + else: + ascii += '.' + uval = packet.get_hex_uint8() + idx = idx + 1 + if ascii: + print(' ', ascii) + ascii = '' + + +def cmd_write_memory(options, cmd, args): + packet = Packet(args) + addr = packet.get_hex_uint('big') + if packet.get_char() != ',': + print('error: invalid write memory command (missing comma after address)') + return + size = packet.get_hex_uint('big') + if packet.get_char() != ':': + print('error: invalid write memory command (missing colon after size)') + return + print('write_memory (addr = 0x%16.16x, size = %u, data:' % (addr, size)) + dump_hex_memory_buffer(addr, packet.str) + return False + + +def cmd_alloc_memory(options, cmd, args): + packet = Packet(args) + byte_size = packet.get_hex_uint('big') + if packet.get_char() != ',': + print('error: invalid allocate memory command (missing comma after address)') + return + print('allocate_memory (byte-size = %u (0x%x), permissions = %s)' % (byte_size, byte_size, packet.str)) + return False + + +def rsp_alloc_memory(options, cmd, cmd_args, rsp): + packet = Packet(rsp) + addr = packet.get_hex_uint('big') + print('addr = 0x%x' % addr) + + +def cmd_dealloc_memory(options, cmd, args): + packet = Packet(args) + addr = packet.get_hex_uint('big') + if packet.get_char() != ',': + print('error: invalid allocate memory command (missing comma after address)') + else: + print('deallocate_memory (addr = 0x%x, permissions = %s)' % (addr, packet.str)) + return False + + +def rsp_memory_bytes(options, cmd, cmd_args, rsp): + addr = Packet(cmd_args).get_hex_uint('big') + dump_hex_memory_buffer(addr, rsp) + + +def get_register_name_equal_value(options, reg_num, hex_value_str): + if reg_num < len(g_register_infos): + reg_info = g_register_infos[reg_num] + value_str = reg_info.get_value_from_hex_string(hex_value_str) + s = reg_info.name() + ' = ' + if options.symbolicator: + symbolicated_addresses = options.symbolicator.symbolicate( + int(value_str, 0)) + if symbolicated_addresses: + s += options.colors.magenta() + s += '%s' % symbolicated_addresses[0] + s += options.colors.reset() + return s + s += value_str + return s + else: + reg_value = Packet(hex_value_str).get_hex_uint(g_byte_order) + return 'reg(%u) = 0x%x' % (reg_num, reg_value) + + +def cmd_read_one_reg(options, cmd, args): + packet = Packet(args) + reg_num = packet.get_hex_uint('big') + tid = get_thread_from_thread_suffix(packet.str) + name = None + if reg_num < len(g_register_infos): + name = g_register_infos[reg_num].name() + if packet.str: + packet.get_char() # skip ; + thread_info = packet.get_key_value_pairs() + tid = int(thread_info[0][1], 16) + s = 'read_register (reg_num=%u' % reg_num + if name: + s += ' (%s)' % (name) + if tid is not None: + s += ', tid = 0x%4.4x' % (tid) + s += ')' + print(s) + return False + + +def rsp_read_one_reg(options, cmd, cmd_args, rsp): + packet = Packet(cmd_args) + reg_num = packet.get_hex_uint('big') + print(get_register_name_equal_value(options, reg_num, rsp)) + + +def cmd_write_one_reg(options, cmd, args): + packet = Packet(args) + reg_num = packet.get_hex_uint('big') + if packet.get_char() != '=': + print('error: invalid register write packet') + else: + name = None + hex_value_str = packet.get_hex_chars() + tid = get_thread_from_thread_suffix(packet.str) + s = 'write_register (reg_num=%u' % reg_num + if name: + s += ' (%s)' % (name) + s += ', value = ' + s += get_register_name_equal_value(options, reg_num, hex_value_str) + if tid is not None: + s += ', tid = 0x%4.4x' % (tid) + s += ')' + print(s) + return False + + +def dump_all_regs(packet): + for reg_info in g_register_infos: + nibble_size = reg_info.bit_size() / 4 + hex_value_str = packet.get_hex_chars(nibble_size) + if hex_value_str is not None: + value = reg_info.get_value_from_hex_string(hex_value_str) + print('%*s = %s' % (g_max_register_info_name_len, reg_info.name(), value)) + else: + return + + +def cmd_read_all_regs(cmd, cmd_args): + packet = Packet(cmd_args) + packet.get_char() # toss the 'g' command character + tid = get_thread_from_thread_suffix(packet.str) + if tid is not None: + print('read_all_register(thread = 0x%4.4x)' % tid) + else: + print('read_all_register()') + return False + + +def rsp_read_all_regs(options, cmd, cmd_args, rsp): + packet = Packet(rsp) + dump_all_regs(packet) + + +def cmd_write_all_regs(options, cmd, args): + packet = Packet(args) + print('write_all_registers()') + dump_all_regs(packet) + return False + +g_bp_types = ["software_bp", "hardware_bp", "write_wp", "read_wp", "access_wp"] + + +def cmd_bp(options, cmd, args): + if cmd == 'Z': + s = 'set_' + else: + s = 'clear_' + packet = Packet(args) + bp_type = packet.get_hex_uint('big') + packet.get_char() # Skip , + bp_addr = packet.get_hex_uint('big') + packet.get_char() # Skip , + bp_size = packet.get_hex_uint('big') + s += g_bp_types[bp_type] + s += " (addr = 0x%x, size = %u)" % (bp_addr, bp_size) + print(s) + return False + + +def cmd_mem_rgn_info(options, cmd, args): + packet = Packet(args) + packet.get_char() # skip ':' character + addr = packet.get_hex_uint('big') + print('get_memory_region_info (addr=0x%x)' % (addr)) + return False + + +def cmd_kill(options, cmd, args): + print('kill_process()') + return False + + +def cmd_jThreadsInfo(options, cmd, args): + print('jThreadsInfo()') + return False + + +def cmd_jGetLoadedDynamicLibrariesInfos(options, cmd, args): + print('jGetLoadedDynamicLibrariesInfos()') + return False + + +def decode_packet(s, start_index=0): + # print '\ndecode_packet("%s")' % (s[start_index:]) + index = s.find('}', start_index) + have_escapes = index != -1 + if have_escapes: + normal_s = s[start_index:index] + else: + normal_s = s[start_index:] + # print 'normal_s = "%s"' % (normal_s) + if have_escapes: + escape_char = '%c' % (ord(s[index + 1]) ^ 0x20) + # print 'escape_char for "%s" = %c' % (s[index:index+2], escape_char) + return normal_s + escape_char + decode_packet(s, index + 2) + else: + return normal_s + + +def rsp_json(options, cmd, cmd_args, rsp): + print('%s() reply:' % (cmd)) + json_tree = json.loads(rsp) + print(json.dumps(json_tree, indent=4, separators=(',', ': '))) + + +def rsp_jGetLoadedDynamicLibrariesInfos(options, cmd, cmd_args, rsp): + if cmd_args: + rsp_json(options, cmd, cmd_args, rsp) + else: + rsp_ok_means_supported(options, cmd, cmd_args, rsp) + +gdb_remote_commands = { + '\\?': {'cmd': cmd_stop_reply, 'rsp': rsp_stop_reply, 'name': "stop reply pacpket"}, + 'qThreadStopInfo': {'cmd': cmd_qThreadStopInfo, 'rsp': rsp_stop_reply, 'name': "stop reply pacpket"}, + 'QStartNoAckMode': {'cmd': cmd_query_packet, 'rsp': rsp_ok_means_supported, 'name': "query if no ack mode is supported"}, + 'QThreadSuffixSupported': {'cmd': cmd_query_packet, 'rsp': rsp_ok_means_supported, 'name': "query if thread suffix is supported"}, + 'QListThreadsInStopReply': {'cmd': cmd_query_packet, 'rsp': rsp_ok_means_supported, 'name': "query if threads in stop reply packets are supported"}, + 'QSetDetachOnError:': {'cmd': cmd_QSetWithUnsigned, 'rsp': rsp_ok_means_success, 'name': "set if we should detach on error"}, + 'QSetDisableASLR:': {'cmd': cmd_QSetWithUnsigned, 'rsp': rsp_ok_means_success, 'name': "set if we should disable ASLR"}, + 'qLaunchSuccess': {'cmd': cmd_query_packet, 'rsp': rsp_ok_means_success, 'name': "check on launch success for the A packet"}, + 'A': {'cmd': cmd_A, 'rsp': rsp_ok_means_success, 'name': "launch process"}, + 'QLaunchArch:': {'cmd': cmd_QSetWithString, 'rsp': rsp_ok_means_supported, 'name': "set the arch to launch in case the file contains multiple architectures"}, + 'qVAttachOrWaitSupported': {'cmd': cmd_query_packet, 'rsp': rsp_ok_means_supported, 'name': "set the launch architecture"}, + 'qHostInfo': {'cmd': cmd_query_packet, 'rsp': rsp_dump_key_value_pairs, 'name': "get host information"}, + 'qC': {'cmd': cmd_qC, 'rsp': rsp_qC, 'name': "return the current thread ID"}, + 'vCont': {'cmd': cmd_vCont, 'rsp': rsp_vCont, 'name': "extended continue command"}, + 'qSpeedTest': {'cmd':cmd_qSpeedTest, 'rsp': rsp_qSpeedTest, 'name': 'speed test packdet'}, + 'vAttach': {'cmd': cmd_vAttach, 'rsp': rsp_stop_reply, 'name': "attach to process"}, + 'c': {'cmd': cmd_c, 'rsp': rsp_stop_reply, 'name': "continue"}, + 's': {'cmd': cmd_s, 'rsp': rsp_stop_reply, 'name': "step"}, + 'qRegisterInfo': {'cmd': cmd_qRegisterInfo, 'rsp': rsp_qRegisterInfo, 'name': "query register info"}, + 'qfThreadInfo': {'cmd': cmd_qThreadInfo, 'rsp': rsp_qThreadInfo, 'name': "get current thread list"}, + 'qsThreadInfo': {'cmd': cmd_qThreadInfo, 'rsp': rsp_qThreadInfo, 'name': "get current thread list"}, + 'qShlibInfoAddr': {'cmd': cmd_query_packet, 'rsp': rsp_hex_big_endian, 'name': "get shared library info address"}, + 'qMemoryRegionInfo': {'cmd': cmd_mem_rgn_info, 'rsp': rsp_dump_key_value_pairs, 'name': "get memory region information"}, + 'qProcessInfo': {'cmd': cmd_query_packet, 'rsp': rsp_dump_key_value_pairs, 'name': "get process info"}, + 'qSupported': {'cmd': cmd_query_packet, 'rsp': rsp_ok_means_supported, 'name': "query supported"}, + 'qXfer:': {'cmd': cmd_qXfer, 'rsp': rsp_qXfer, 'name': "qXfer"}, + 'qSymbol:': {'cmd': cmd_qSymbol, 'rsp': rsp_qSymbol, 'name': "qSymbol"}, + 'QSetSTDIN:' : {'cmd' : cmd_QSetWithHexString, 'rsp' : rsp_ok_means_success, 'name': "set STDIN prior to launching with A packet"}, + 'QSetSTDOUT:' : {'cmd' : cmd_QSetWithHexString, 'rsp' : rsp_ok_means_success, 'name': "set STDOUT prior to launching with A packet"}, + 'QSetSTDERR:' : {'cmd' : cmd_QSetWithHexString, 'rsp' : rsp_ok_means_success, 'name': "set STDERR prior to launching with A packet"}, + 'QEnvironment:' : {'cmd' : cmd_QSetWithString, 'rsp' : rsp_ok_means_success, 'name': "set an environment variable prior to launching with A packet"}, + 'QEnvironmentHexEncoded:' : {'cmd' : cmd_QSetWithHexString, 'rsp' : rsp_ok_means_success, 'name': "set an environment variable prior to launching with A packet"}, + 'x': {'cmd': cmd_read_mem_bin, 'rsp': rsp_mem_bin_bytes, 'name': "read memory binary"}, + 'X': {'cmd': cmd_write_memory, 'rsp': rsp_ok_means_success, 'name': "write memory binary"}, + 'm': {'cmd': cmd_read_memory, 'rsp': rsp_memory_bytes, 'name': "read memory"}, + 'M': {'cmd': cmd_write_memory, 'rsp': rsp_ok_means_success, 'name': "write memory"}, + '_M': {'cmd': cmd_alloc_memory, 'rsp': rsp_alloc_memory, 'name': "allocate memory"}, + '_m': {'cmd': cmd_dealloc_memory, 'rsp': rsp_ok_means_success, 'name': "deallocate memory"}, + 'p': {'cmd': cmd_read_one_reg, 'rsp': rsp_read_one_reg, 'name': "read single register"}, + 'P': {'cmd': cmd_write_one_reg, 'rsp': rsp_ok_means_success, 'name': "write single register"}, + 'g': {'cmd': cmd_read_all_regs, 'rsp': rsp_read_all_regs, 'name': "read all registers"}, + 'G': {'cmd': cmd_write_all_regs, 'rsp': rsp_ok_means_success, 'name': "write all registers"}, + 'z': {'cmd': cmd_bp, 'rsp': rsp_ok_means_success, 'name': "clear breakpoint or watchpoint"}, + 'Z': {'cmd': cmd_bp, 'rsp': rsp_ok_means_success, 'name': "set breakpoint or watchpoint"}, + 'k': {'cmd': cmd_kill, 'rsp': rsp_stop_reply, 'name': "kill process"}, + 'jThreadsInfo': {'cmd': cmd_jThreadsInfo, 'rsp': rsp_json, 'name': "JSON get all threads info"}, + 'jGetLoadedDynamicLibrariesInfos:': {'cmd': cmd_jGetLoadedDynamicLibrariesInfos, 'rsp': rsp_jGetLoadedDynamicLibrariesInfos, 'name': 'JSON get loaded dynamic libraries'}, +} + + +def calculate_mean_and_standard_deviation(floats): + sum = 0.0 + count = len(floats) + if count == 0: + return (0.0, 0.0) + for f in floats: + sum += f + mean = sum / count + accum = 0.0 + for f in floats: + delta = f - mean + accum += delta * delta + + std_dev = math.sqrt(accum / (count - 1)) + return (mean, std_dev) + + +def parse_gdb_log_file(path, options): + f = open(path) + parse_gdb_log(f, options) + f.close() + + +def round_up(n, incr): + return float(((int(n) + incr) / incr) * incr) + + +def plot_latencies(sec_times): + # import numpy as np + import matplotlib.pyplot as plt + + for (i, name) in enumerate(sec_times.keys()): + times = sec_times[name] + if len(times) <= 1: + continue + plt.subplot(2, 1, 1) + plt.title('Packet "%s" Times' % (name)) + plt.xlabel('Packet') + units = 'ms' + adj_times = [] + max_time = 0.0 + for time in times: + time = time * 1000.0 + adj_times.append(time) + if time > max_time: + max_time = time + if max_time < 1.0: + units = 'us' + max_time = 0.0 + for i in range(len(adj_times)): + adj_times[i] *= 1000.0 + if adj_times[i] > max_time: + max_time = adj_times[i] + plt.ylabel('Time (%s)' % (units)) + max_y = None + for i in [5.0, 10.0, 25.0, 50.0]: + if max_time < i: + max_y = round_up(max_time, i) + break + if max_y is None: + max_y = round_up(max_time, 100.0) + plt.ylim(0.0, max_y) + plt.plot(adj_times, 'o-') + plt.show() + + +def parse_gdb_log(file, options): + '''Parse a GDB log file that was generated by enabling logging with: + (lldb) log enable --threadsafe --timestamp --file <FILE> gdb-remote packets + This log file will contain timestamps and this function will then normalize + those packets to be relative to the first value timestamp that is found and + show delta times between log lines and also keep track of how long it takes + for GDB remote commands to make a send/receive round trip. This can be + handy when trying to figure out why some operation in the debugger is taking + a long time during a preset set of debugger commands.''' + + tricky_commands = ['qRegisterInfo'] + timestamp_regex = re.compile('(\s*)([1-9][0-9]+\.[0-9]+)([^0-9].*)$') + packet_name_regex = re.compile('([A-Za-z_]+)[^a-z]') + packet_transmit_name_regex = re.compile( + '(?P<direction>send|read) packet: (?P<packet>.*)') + packet_contents_name_regex = re.compile('\$([^#]*)#[0-9a-fA-F]{2}') + packet_checksum_regex = re.compile('.*#[0-9a-fA-F]{2}$') + packet_names_regex_str = '(' + \ + '|'.join(gdb_remote_commands.keys()) + ')(.*)' + packet_names_regex = re.compile(packet_names_regex_str) + + base_time = 0.0 + last_time = 0.0 + min_time = 100000000.0 + packet_total_times = {} + all_packet_times = [] + packet_times = {} + packet_counts = {} + lines = file.read().splitlines() + last_command = None + last_command_args = None + last_command_packet = None + hide_next_response = False + num_lines = len(lines) + skip_count = 0 + for (line_index, line) in enumerate(lines): + # See if we need to skip any lines + if skip_count > 0: + skip_count -= 1 + continue + m = packet_transmit_name_regex.search(line) + is_command = False + direction = None + if m: + direction = m.group('direction') + is_command = direction == 'send' + packet = m.group('packet') + sys.stdout.write(options.colors.green()) + if not options.quiet and not hide_next_response: + print('# ', line) + sys.stdout.write(options.colors.reset()) + + # print 'direction = "%s", packet = "%s"' % (direction, packet) + + if packet[0] == '+': + if is_command: + print('-->', end=' ') + else: + print('<--', end=' ') + if not options.quiet: + print('ACK') + continue + elif packet[0] == '-': + if is_command: + print('-->', end=' ') + else: + print('<--', end=' ') + if not options.quiet: + print('NACK') + continue + elif packet[0] == '$': + m = packet_contents_name_regex.match(packet) + if not m and packet[0] == '$': + multiline_packet = packet + idx = line_index + 1 + while idx < num_lines: + if not options.quiet and not hide_next_response: + print('# ', lines[idx]) + multiline_packet += lines[idx] + m = packet_contents_name_regex.match(multiline_packet) + if m: + packet = multiline_packet + skip_count = idx - line_index + break + else: + idx += 1 + if m: + if is_command: + print('-->', end=' ') + else: + print('<--', end=' ') + contents = decode_packet(m.group(1)) + if is_command: + hide_next_response = False + m = packet_names_regex.match(contents) + if m: + last_command = m.group(1) + if last_command == '?': + last_command = '\\?' + packet_name = last_command + last_command_args = m.group(2) + last_command_packet = contents + hide_next_response = gdb_remote_commands[last_command][ + 'cmd'](options, last_command, last_command_args) + else: + packet_match = packet_name_regex.match(contents) + if packet_match: + packet_name = packet_match.group(1) + for tricky_cmd in tricky_commands: + if packet_name.find(tricky_cmd) == 0: + packet_name = tricky_cmd + else: + packet_name = contents + last_command = None + last_command_args = None + last_command_packet = None + elif last_command: + gdb_remote_commands[last_command]['rsp']( + options, last_command, last_command_args, contents) + else: + print('error: invalid packet: "', packet, '"') + else: + print('???') + else: + print('## ', line) + match = timestamp_regex.match(line) + if match: + curr_time = float(match.group(2)) + if last_time and not is_command: + delta = curr_time - last_time + all_packet_times.append(delta) + delta = 0.0 + if base_time: + delta = curr_time - last_time + else: + base_time = curr_time + + if not is_command: + if line.find('read packet: $') >= 0 and packet_name: + if packet_name in packet_total_times: + packet_total_times[packet_name] += delta + packet_counts[packet_name] += 1 + else: + packet_total_times[packet_name] = delta + packet_counts[packet_name] = 1 + if packet_name not in packet_times: + packet_times[packet_name] = [] + packet_times[packet_name].append(delta) + packet_name = None + if min_time > delta: + min_time = delta + + if not options or not options.quiet: + print('%s%.6f %+.6f%s' % (match.group(1), + curr_time - base_time, + delta, + match.group(3))) + last_time = curr_time + # else: + # print line + (average, std_dev) = calculate_mean_and_standard_deviation(all_packet_times) + if average and std_dev: + print('%u packets with average packet time of %f and standard deviation of %f' % (len(all_packet_times), average, std_dev)) + if packet_total_times: + total_packet_time = 0.0 + total_packet_count = 0 + for key, vvv in packet_total_times.items(): + # print ' key = (%s) "%s"' % (type(key), key) + # print 'value = (%s) %s' % (type(vvv), vvv) + # if type(vvv) == 'float': + total_packet_time += vvv + for key, vvv in packet_counts.items(): + total_packet_count += vvv + + print('#------------------------------------------------------------') + print('# Packet timing summary:') + print('# Totals: time = %6f, count = %6d' % (total_packet_time, + total_packet_count)) + print('# Min packet time: time = %6f' % (min_time)) + print('#------------------------------------------------------------') + print('# Packet Time (sec) Percent Count Latency') + print('#------------------------- ----------- ------- ------ -------') + if options and options.sort_count: + res = sorted( + packet_counts, + key=packet_counts.__getitem__, + reverse=True) + else: + res = sorted( + packet_total_times, + key=packet_total_times.__getitem__, + reverse=True) + + if last_time > 0.0: + for item in res: + packet_total_time = packet_total_times[item] + packet_percent = ( + packet_total_time / total_packet_time) * 100.0 + packet_count = packet_counts[item] + print(" %24s %11.6f %5.2f%% %6d %9.6f" % ( + item, packet_total_time, packet_percent, packet_count, + float(packet_total_time) / float(packet_count))) + if options.plot: + plot_latencies(packet_times) + +if __name__ == '__main__': + usage = "usage: gdbremote [options]" + description = '''The command disassembles a GDB remote packet log.''' + parser = optparse.OptionParser( + description=description, + prog='gdbremote', + usage=usage) + parser.add_option( + '-v', + '--verbose', + action='store_true', + dest='verbose', + help='display verbose debug info', + default=False) + parser.add_option( + '--plot', + action='store_true', + dest='plot', + help='plot packet latencies by packet type', + default=False) + parser.add_option( + '-q', + '--quiet', + action='store_true', + dest='quiet', + help='display verbose debug info', + default=False) + parser.add_option( + '-C', + '--color', + action='store_true', + dest='color', + help='add terminal colors', + default=False) + parser.add_option( + '-c', + '--sort-by-count', + action='store_true', + dest='sort_count', + help='display verbose debug info', + default=False) + parser.add_option( + '--crashlog', + type='string', + dest='crashlog', + help='symbolicate using a darwin crash log file', + default=False) + try: + (options, args) = parser.parse_args(sys.argv[1:]) + except: + print('error: argument error') + sys.exit(1) + + options.colors = TerminalColors(options.color) + options.symbolicator = None + if options.crashlog: + import lldb + lldb.debugger = lldb.SBDebugger.Create() + import lldb.macosx.crashlog + options.symbolicator = lldb.macosx.crashlog.CrashLog(options.crashlog) + print('%s' % (options.symbolicator)) + + # This script is being run from the command line, create a debugger in case we are + # going to use any debugger functions in our function. + if len(args): + for file in args: + print('#----------------------------------------------------------------------') + print("# GDB remote log file: '%s'" % file) + print('#----------------------------------------------------------------------') + parse_gdb_log_file(file, options) + if options.symbolicator: + print('%s' % (options.symbolicator)) + else: + parse_gdb_log(sys.stdin, options) + +else: + import lldb + if lldb.debugger: + # This initializer is being run from LLDB in the embedded command interpreter + # Add any commands contained in this module to LLDB + lldb.debugger.HandleCommand( + 'command script add -f gdbremote.start_gdb_log start_gdb_log') + lldb.debugger.HandleCommand( + 'command script add -f gdbremote.stop_gdb_log stop_gdb_log') + print('The "start_gdb_log" and "stop_gdb_log" commands are now installed and ready for use, type "start_gdb_log --help" or "stop_gdb_log --help" for more information') |