| #!/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 commands |
| 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() |
| 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_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' |
| else: |
| s += 'unrecognized vCont mode: ', 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)), |
| 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 ',', |
| print '0x%x' % (tid), |
| 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), |
| print '%2.2x' % (uval), |
| 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"}, |
| '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 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 |
| packet_send_time = 0.0 |
| packet_total_times = {} |
| packet_times = [] |
| packet_count = {} |
| 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 '-->', |
| else: |
| print '<--', |
| if not options.quiet: |
| print 'ACK' |
| continue |
| elif packet[0] == '-': |
| if is_command: |
| print '-->', |
| else: |
| print '<--', |
| 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 '-->', |
| else: |
| print '<--', |
| 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 |
| packet_times.append(delta) |
| delta = 0.0 |
| if base_time: |
| delta = curr_time - last_time |
| else: |
| base_time = curr_time |
| |
| if is_command: |
| packet_send_time = curr_time |
| elif line.find('read packet: $') >= 0 and packet_name: |
| if packet_name in packet_total_times: |
| packet_total_times[packet_name] += delta |
| packet_count[packet_name] += 1 |
| else: |
| packet_total_times[packet_name] = delta |
| packet_count[packet_name] = 1 |
| packet_name = None |
| |
| 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(packet_times) |
| if average and std_dev: |
| print '%u packets with average packet time of %f and standard deviation of %f' % (len(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_count.items(): |
| total_packet_count += vvv |
| |
| print '#---------------------------------------------------' |
| print '# Packet timing summary:' |
| print '# Totals: time = %6f, count = %6d' % (total_packet_time, total_packet_count) |
| print '#---------------------------------------------------' |
| print '# Packet Time (sec) Percent Count ' |
| print '#------------------------- ---------- ------- ------' |
| if options and options.sort_count: |
| res = sorted( |
| packet_count, |
| key=packet_count.__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 |
| if packet_percent >= 10.0: |
| print " %24s %.6f %.2f%% %6d" % (item, packet_total_time, packet_percent, packet_count[item]) |
| else: |
| print " %24s %.6f %.2f%% %6d" % (item, packet_total_time, packet_percent, packet_count[item]) |
| |
| |
| 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( |
| '-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' |
