sdk/dotfiles
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
24a10e2261
dotfiles/.gdbinit

2339 lines
90 KiB
Plaintext
Raw Normal View History

Update 2022-12-06 08:46 OpenBSD/amd64
2022-12-06 08:46:12 +01:00
python
# GDB dashboard - Modular visual interface for GDB in Python.
#
# https://github.com/cyrus-and/gdb-dashboard
# License ----------------------------------------------------------------------
# Copyright (c) 2015-2022 Andrea Cardaci <cyrus.and@gmail.com>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# Imports ----------------------------------------------------------------------
import ast
import io
import itertools
import math
import os
import re
import struct
import traceback
# Common attributes ------------------------------------------------------------
class R():
@staticmethod
def attributes():
return {
# miscellaneous
'ansi': {
'doc': 'Control the ANSI output of the dashboard.',
'default': True,
'type': bool
},
'syntax_highlighting': {
'doc': '''Pygments style to use for syntax highlighting.
Using an empty string (or a name not in the list) disables this feature. The
list of all the available styles can be obtained with (from GDB itself):
python from pygments.styles import *
python for style in get_all_styles(): print(style)''',
'default': 'monokai'
},
'discard_scrollback': {
'doc': '''Discard the scrollback buffer at each redraw.
This makes scrolling less confusing by discarding the previously printed
dashboards but only works with certain terminals.''',
'default': True,
'type': bool
},
# values formatting
'compact_values': {
'doc': 'Display complex objects in a single line.',
'default': True,
'type': bool
},
'max_value_length': {
'doc': 'Maximum length of displayed values before truncation.',
'default': 100,
'type': int
},
'value_truncation_string': {
'doc': 'String to use to mark value truncation.',
'default': '…',
},
'dereference': {
'doc': 'Annotate pointers with the pointed value.',
'default': True,
'type': bool
},
# prompt
'prompt': {
'doc': '''GDB prompt.
This value is used as a Python format string where `{status}` is expanded with
the substitution of either `prompt_running` or `prompt_not_running` attributes,
according to the target program status. The resulting string must be a valid GDB
prompt, see the command `python print(gdb.prompt.prompt_help())`''',
'default': '{status}'
},
'prompt_running': {
'doc': '''Define the value of `{status}` when the target program is running.
See the `prompt` attribute. This value is used as a Python format string where
`{pid}` is expanded with the process identifier of the target program.''',
'default': '\[\e[1;35m\]>>>\[\e[0m\]'
},
'prompt_not_running': {
'doc': '''Define the value of `{status}` when the target program is running.
See the `prompt` attribute. This value is used as a Python format string.''',
'default': '\[\e[90m\]>>>\[\e[0m\]'
},
# divider
'omit_divider': {
'doc': 'Omit the divider in external outputs when only one module is displayed.',
'default': False,
'type': bool
},
'divider_fill_char_primary': {
'doc': 'Filler around the label for primary dividers',
'default': '─'
},
'divider_fill_char_secondary': {
'doc': 'Filler around the label for secondary dividers',
'default': '─'
},
'divider_fill_style_primary': {
'doc': 'Style for `divider_fill_char_primary`',
'default': '36'
},
'divider_fill_style_secondary': {
'doc': 'Style for `divider_fill_char_secondary`',
'default': '90'
},
'divider_label_style_on_primary': {
'doc': 'Label style for non-empty primary dividers',
'default': '1;33'
},
'divider_label_style_on_secondary': {
'doc': 'Label style for non-empty secondary dividers',
'default': '1;37'
},
'divider_label_style_off_primary': {
'doc': 'Label style for empty primary dividers',
'default': '33'
},
'divider_label_style_off_secondary': {
'doc': 'Label style for empty secondary dividers',
'default': '90'
},
'divider_label_skip': {
'doc': 'Gap between the aligning border and the label.',
'default': 3,
'type': int,
'check': check_ge_zero
},
'divider_label_margin': {
'doc': 'Number of spaces around the label.',
'default': 1,
'type': int,
'check': check_ge_zero
},
'divider_label_align_right': {
'doc': 'Label alignment flag.',
'default': False,
'type': bool
},
# common styles
'style_selected_1': {
'default': '1;32'
},
'style_selected_2': {
'default': '32'
},
'style_low': {
'default': '90'
},
'style_high': {
'default': '1;37'
},
'style_error': {
'default': '31'
},
'style_critical': {
'default': '0;41'
}
}
# Common -----------------------------------------------------------------------
class Beautifier():
def __init__(self, hint, tab_size=4):
self.tab_spaces = ' ' * tab_size if tab_size else None
self.active = False
if not R.ansi or not R.syntax_highlighting:
return
# attempt to set up Pygments
try:
import pygments
from pygments.lexers import GasLexer, NasmLexer
from pygments.formatters import Terminal256Formatter
if hint == 'att':
self.lexer = GasLexer()
elif hint == 'intel':
self.lexer = NasmLexer()
else:
from pygments.lexers import get_lexer_for_filename
self.lexer = get_lexer_for_filename(hint, stripnl=False)
self.formatter = Terminal256Formatter(style=R.syntax_highlighting)
self.active = True
except ImportError:
# Pygments not available
pass
except pygments.util.ClassNotFound:
# no lexer for this file or invalid style
pass
def process(self, source):
# convert tabs if requested
if self.tab_spaces:
source = source.replace('\t', self.tab_spaces)
if self.active:
import pygments
source = pygments.highlight(source, self.lexer, self.formatter)
return source.rstrip('\n')
def run(command):
return gdb.execute(command, to_string=True)
def ansi(string, style):
if R.ansi:
return '\x1b[{}m{}\x1b[0m'.format(style, string)
else:
return string
def divider(width, label='', primary=False, active=True):
if primary:
divider_fill_style = R.divider_fill_style_primary
divider_fill_char = R.divider_fill_char_primary
divider_label_style_on = R.divider_label_style_on_primary
divider_label_style_off = R.divider_label_style_off_primary
else:
divider_fill_style = R.divider_fill_style_secondary
divider_fill_char = R.divider_fill_char_secondary
divider_label_style_on = R.divider_label_style_on_secondary
divider_label_style_off = R.divider_label_style_off_secondary
if label:
if active:
divider_label_style = divider_label_style_on
else:
divider_label_style = divider_label_style_off
skip = R.divider_label_skip
margin = R.divider_label_margin
before = ansi(divider_fill_char * skip, divider_fill_style)
middle = ansi(label, divider_label_style)
after_length = width - len(label) - skip - 2 * margin
after = ansi(divider_fill_char * after_length, divider_fill_style)
if R.divider_label_align_right:
before, after = after, before
return ''.join([before, ' ' * margin, middle, ' ' * margin, after])
else:
return ansi(divider_fill_char * width, divider_fill_style)
def check_gt_zero(x):
return x > 0
def check_ge_zero(x):
return x >= 0
def to_unsigned(value, size=8):
# values from GDB can be used transparently but are not suitable for
# being printed as unsigned integers, so a conversion is needed
mask = (2 ** (size * 8)) - 1
return int(value.cast(gdb.Value(mask).type)) & mask
def to_string(value):
# attempt to convert an inferior value to string; OK when (Python 3 ||
# simple ASCII); otherwise (Python 2.7 && not ASCII) encode the string as
# utf8
try:
value_string = str(value)
except UnicodeEncodeError:
value_string = unicode(value).encode('utf8')
except gdb.error as e:
value_string = ansi(e, R.style_error)
return value_string
def format_address(address):
pointer_size = gdb.parse_and_eval('$pc').type.sizeof
return ('0x{{:0{}x}}').format(pointer_size * 2).format(address)
def format_value(value, compact=None):
# format references as referenced values
# (TYPE_CODE_RVALUE_REF is not supported by old GDB)
if value.type.code in (getattr(gdb, 'TYPE_CODE_REF', None),
getattr(gdb, 'TYPE_CODE_RVALUE_REF', None)):
try:
value = value.referenced_value()
except gdb.error as e:
return ansi(e, R.style_error)
# format the value
out = to_string(value)
# dereference up to the actual value if requested
if R.dereference and value.type.code == gdb.TYPE_CODE_PTR:
while value.type.code == gdb.TYPE_CODE_PTR:
try:
value = value.dereference()
except gdb.error as e:
break
else:
formatted = to_string(value)
out += '{} {}'.format(ansi(':', R.style_low), formatted)
# compact the value
if compact is not None and compact or R.compact_values:
out = re.sub(r'$\s*', '', out, flags=re.MULTILINE)
# truncate the value
if R.max_value_length > 0 and len(out) > R.max_value_length:
out = out[0:R.max_value_length] + ansi(R.value_truncation_string, R.style_critical)
return out
# XXX parsing the output of `info breakpoints` is apparently the best option
# right now, see: https://sourceware.org/bugzilla/show_bug.cgi?id=18385
# XXX GDB version 7.11 (quire recent) does not have the pending field, so
# fall back to the parsed information
def fetch_breakpoints(watchpoints=False, pending=False):
# fetch breakpoints addresses
parsed_breakpoints = dict()
catch_what_regex = re.compile(r'([^,]+".*")?[^,]*')
for line in run('info breakpoints').split('\n'):
# just keep numbered lines
if not line or not line[0].isdigit():
continue
# extract breakpoint number, address and pending status
fields = line.split()
number = int(fields[0].split('.')[0])
try:
if len(fields) >= 5 and fields[1] == 'breakpoint':
# multiple breakpoints have no address yet
is_pending = fields[4] == '<PENDING>'
is_multiple = fields[4] == '<MULTIPLE>'
address = None if is_multiple or is_pending else int(fields[4], 16)
is_enabled = fields[3] == 'y'
address_info = address, is_enabled
parsed_breakpoints[number] = [address_info], is_pending, ''
elif len(fields) >= 5 and fields[1] == 'catchpoint':
# only take before comma, but ignore commas in quotes
what = catch_what_regex.search(' '.join(fields[4:]))[0].strip()
parsed_breakpoints[number] = [], False, what
elif len(fields) >= 3 and number in parsed_breakpoints:
# add this address to the list of multiple locations
address = int(fields[2], 16)
is_enabled = fields[1] == 'y'
address_info = address, is_enabled
parsed_breakpoints[number][0].append(address_info)
else:
# watchpoints
parsed_breakpoints[number] = [], False, ''
except ValueError:
pass
# fetch breakpoints from the API and complement with address and source
# information
breakpoints = []
# XXX in older versions gdb.breakpoints() returns None
for gdb_breakpoint in gdb.breakpoints() or []:
# skip internal breakpoints
if gdb_breakpoint.number < 0:
continue
addresses, is_pending, what = parsed_breakpoints[gdb_breakpoint.number]
is_pending = getattr(gdb_breakpoint, 'pending', is_pending)
if not pending and is_pending:
continue
if not watchpoints and gdb_breakpoint.type != gdb.BP_BREAKPOINT:
continue
# add useful fields to the object
breakpoint = dict()
breakpoint['number'] = gdb_breakpoint.number
breakpoint['type'] = gdb_breakpoint.type
breakpoint['enabled'] = gdb_breakpoint.enabled
breakpoint['location'] = gdb_breakpoint.location
breakpoint['expression'] = gdb_breakpoint.expression
breakpoint['condition'] = gdb_breakpoint.condition
breakpoint['temporary'] = gdb_breakpoint.temporary
breakpoint['hit_count'] = gdb_breakpoint.hit_count
breakpoint['pending'] = is_pending
breakpoint['what'] = what
# add addresses and source information
breakpoint['addresses'] = []
for address, is_enabled in addresses:
if address:
sal = gdb.find_pc_line(address)
breakpoint['addresses'].append({
'address': address,
'enabled': is_enabled,
'file_name': sal.symtab.filename if address and sal.symtab else None,
'file_line': sal.line if address else None
})
breakpoints.append(breakpoint)
return breakpoints
# Dashboard --------------------------------------------------------------------
class Dashboard(gdb.Command):
'''Redisplay the dashboard.'''
def __init__(self):
gdb.Command.__init__(self, 'dashboard', gdb.COMMAND_USER, gdb.COMPLETE_NONE, True)
# setup subcommands
Dashboard.ConfigurationCommand(self)
Dashboard.OutputCommand(self)
Dashboard.EnabledCommand(self)
Dashboard.LayoutCommand(self)
# setup style commands
Dashboard.StyleCommand(self, 'dashboard', R, R.attributes())
# main terminal
self.output = None
# used to inhibit redisplays during init parsing
self.inhibited = None
# enabled by default
self.enabled = None
self.enable()
def on_continue(self, _):
# try to contain the GDB messages in a specified area unless the
# dashboard is printed to a separate file (dashboard -output ...)
# or there are no modules to display in the main terminal
enabled_modules = list(filter(lambda m: not m.output and m.enabled, self.modules))
if self.is_running() and not self.output and len(enabled_modules) > 0:
width, _ = Dashboard.get_term_size()
gdb.write(Dashboard.clear_screen())
gdb.write(divider(width, 'Output/messages', True))
gdb.write('\n')
gdb.flush()
def on_stop(self, _):
if self.is_running():
self.render(clear_screen=False)
def on_exit(self, _):
if not self.is_running():
return
# collect all the outputs
outputs = set()
outputs.add(self.output)
outputs.update(module.output for module in self.modules)
outputs.remove(None)
# reset the terminal status
for output in outputs:
try:
with open(output, 'w') as fs:
fs.write(Dashboard.reset_terminal())
except:
# skip cleanup for invalid outputs
pass
def enable(self):
if self.enabled:
return
self.enabled = True
# setup events
gdb.events.cont.connect(self.on_continue)
gdb.events.stop.connect(self.on_stop)
gdb.events.exited.connect(self.on_exit)
def disable(self):
if not self.enabled:
return
self.enabled = False
# setup events
gdb.events.cont.disconnect(self.on_continue)
gdb.events.stop.disconnect(self.on_stop)
gdb.events.exited.disconnect(self.on_exit)
def load_modules(self, modules):
self.modules = []
for module in modules:
info = Dashboard.ModuleInfo(self, module)
self.modules.append(info)
def redisplay(self, style_changed=False):
# manually redisplay the dashboard
if self.is_running() and not self.inhibited:
self.render(True, style_changed)
def inferior_pid(self):
return gdb.selected_inferior().pid
def is_running(self):
return self.inferior_pid() != 0
def render(self, clear_screen, style_changed=False):
# fetch module content and info
all_disabled = True
display_map = dict()
for module in self.modules:
# fall back to the global value
output = module.output or self.output
# add the instance or None if disabled
if module.enabled:
all_disabled = False
instance = module.instance
else:
instance = None
display_map.setdefault(output, []).append(instance)
# process each display info
for output, instances in display_map.items():
try:
buf = ''
# use GDB stream by default
fs = None
if output:
fs = open(output, 'w')
fd = fs.fileno()
fs.write(Dashboard.setup_terminal())
else:
fs = gdb
fd = 1 # stdout
# get the terminal size (default main terminal if either the
# output is not a file)
try:
width, height = Dashboard.get_term_size(fd)
except:
width, height = Dashboard.get_term_size()
# clear the "screen" if requested for the main terminal,
# auxiliary terminals are always cleared
if fs is not gdb or clear_screen:
buf += Dashboard.clear_screen()
# show message if all the modules in this output are disabled
if not any(instances):
# skip the main terminal
if fs is gdb:
continue
# write the error message
buf += divider(width, 'Warning', True)
buf += '\n'
if self.modules:
buf += 'No module to display (see `dashboard -layout`)'
else:
buf += 'No module loaded'
buf += '\n'
fs.write(buf)
continue
# process all the modules for that output
for n, instance in enumerate(instances, 1):
# skip disabled modules
if not instance:
continue
try:
# ask the module to generate the content
lines = instance.lines(width, height, style_changed)
except Exception as e:
# allow to continue on exceptions in modules
stacktrace = traceback.format_exc().strip()
lines = [ansi(stacktrace, R.style_error)]
# create the divider if needed
div = []
if not R.omit_divider or len(instances) > 1 or fs is gdb:
div = [divider(width, instance.label(), True, lines)]
# write the data
buf += '\n'.join(div + lines)
# write the newline for all but last unless main terminal
if n != len(instances) or fs is gdb:
buf += '\n'
# write the final newline and the terminator only if it is the
# main terminal to allow the prompt to display correctly (unless
# there are no modules to display)
if fs is gdb and not all_disabled:
buf += divider(width, primary=True)
buf += '\n'
fs.write(buf)
except Exception as e:
cause = traceback.format_exc().strip()
Dashboard.err('Cannot write the dashboard\n{}'.format(cause))
finally:
# don't close gdb stream
if fs and fs is not gdb:
fs.close()
# Utility methods --------------------------------------------------------------
@staticmethod
def start():
# save the instance for customization convenience
global dashboard
# initialize the dashboard
dashboard = Dashboard()
Dashboard.set_custom_prompt(dashboard)
# parse Python inits, load modules then parse GDB inits
dashboard.inhibited = True
Dashboard.parse_inits(True)
modules = Dashboard.get_modules()
dashboard.load_modules(modules)
Dashboard.parse_inits(False)
dashboard.inhibited = False
# GDB overrides
run('set pagination off')
# display if possible (program running and not explicitly disabled by
# some configuration file)
if dashboard.enabled:
dashboard.redisplay()
@staticmethod
def get_term_size(fd=1): # defaults to the main terminal
try:
if sys.platform == 'win32':
import curses
# XXX always neglects the fd parameter
height, width = curses.initscr().getmaxyx()
curses.endwin()
return int(width), int(height)
else:
import termios
import fcntl
# first 2 shorts (4 byte) of struct winsize
raw = fcntl.ioctl(fd, termios.TIOCGWINSZ, ' ' * 4)
height, width = struct.unpack('hh', raw)
return int(width), int(height)
except (ImportError, OSError):
# this happens when no curses library is found on windows or when
# the terminal is not properly configured
return 80, 24 # hardcoded fallback value
@staticmethod
def set_custom_prompt(dashboard):
def custom_prompt(_):
# render thread status indicator
if dashboard.is_running():
pid = dashboard.inferior_pid()
status = R.prompt_running.format(pid=pid)
else:
status = R.prompt_not_running
# build prompt
prompt = R.prompt.format(status=status)
prompt = gdb.prompt.substitute_prompt(prompt)
return prompt + ' ' # force trailing space
gdb.prompt_hook = custom_prompt
@staticmethod
def parse_inits(python):
# paths where the .gdbinit.d directory might be
search_paths = [
'/etc/gdb-dashboard',
'{}/gdb-dashboard'.format(os.getenv('XDG_CONFIG_HOME', '~/.config')),
'~/Library/Preferences/gdb-dashboard',
'~/.gdbinit.d'
]
# expand the tilde and walk the paths
inits_dirs = (os.walk(os.path.expanduser(path)) for path in search_paths)
# process all the init files in order
for root, dirs, files in itertools.chain.from_iterable(inits_dirs):
dirs.sort()
for init in sorted(files):
path = os.path.join(root, init)
_, ext = os.path.splitext(path)
# either load Python files or GDB
if python == (ext == '.py'):
gdb.execute('source ' + path)
@staticmethod
def get_modules():
# scan the scope for modules
modules = []
for name in globals():
obj = globals()[name]
try:
if issubclass(obj, Dashboard.Module):
modules.append(obj)
except TypeError:
continue
# sort modules alphabetically
modules.sort(key=lambda x: x.__name__)
return modules
@staticmethod
def create_command(name, invoke, doc, is_prefix, complete=None):
Class = type('', (gdb.Command,), {'invoke': invoke, '__doc__': doc})
Class(name, gdb.COMMAND_USER, complete or gdb.COMPLETE_NONE, is_prefix)
@staticmethod
def err(string):
print(ansi(string, R.style_error))
@staticmethod
def complete(word, candidates):
return filter(lambda candidate: candidate.startswith(word), candidates)
@staticmethod
def parse_arg(arg):
# encode unicode GDB command arguments as utf8 in Python 2.7
if type(arg) is not str:
arg = arg.encode('utf8')
return arg
@staticmethod
def clear_screen():
# ANSI: move the cursor to top-left corner and clear the screen
# (optionally also clear the scrollback buffer if supported by the
# terminal)
return '\x1b[H\x1b[J' + '\x1b[3J' if R.discard_scrollback else ''
@staticmethod
def setup_terminal():
# ANSI: enable alternative screen buffer and hide cursor
return '\x1b[?1049h\x1b[?25l'
@staticmethod
def reset_terminal():
# ANSI: disable alternative screen buffer and show cursor
return '\x1b[?1049l\x1b[?25h'
# Module descriptor ------------------------------------------------------------
class ModuleInfo:
def __init__(self, dashboard, module):
self.name = module.__name__.lower() # from class to module name
self.enabled = True
self.output = None # value from the dashboard by default
self.instance = module()
self.doc = self.instance.__doc__ or '(no documentation)'
self.prefix = 'dashboard {}'.format(self.name)
# add GDB commands
self.add_main_command(dashboard)
self.add_output_command(dashboard)
self.add_style_command(dashboard)
self.add_subcommands(dashboard)
def add_main_command(self, dashboard):
module = self
def invoke(self, arg, from_tty, info=self):
arg = Dashboard.parse_arg(arg)
if arg == '':
info.enabled ^= True
if dashboard.is_running():
dashboard.redisplay()
else:
status = 'enabled' if info.enabled else 'disabled'
print('{} module {}'.format(module.name, status))
else:
Dashboard.err('Wrong argument "{}"'.format(arg))
doc_brief = 'Configure the {} module, with no arguments toggles its visibility.'.format(self.name)
doc = '{}\n\n{}'.format(doc_brief, self.doc)
Dashboard.create_command(self.prefix, invoke, doc, True)
def add_output_command(self, dashboard):
Dashboard.OutputCommand(dashboard, self.prefix, self)
def add_style_command(self, dashboard):
Dashboard.StyleCommand(dashboard, self.prefix, self.instance, self.instance.attributes())
def add_subcommands(self, dashboard):
for name, command in self.instance.commands().items():
self.add_subcommand(dashboard, name, command)
def add_subcommand(self, dashboard, name, command):
action = command['action']
doc = command['doc']
complete = command.get('complete')
def invoke(self, arg, from_tty, info=self):
arg = Dashboard.parse_arg(arg)
if info.enabled:
try:
action(arg)
except Exception as e:
Dashboard.err(e)
return
# don't catch redisplay errors
dashboard.redisplay()
else:
Dashboard.err('Module disabled')
prefix = '{} {}'.format(self.prefix, name)
Dashboard.create_command(prefix, invoke, doc, False, complete)
# GDB commands -----------------------------------------------------------------
# handler for the `dashboard` command itself
def invoke(self, arg, from_tty):
arg = Dashboard.parse_arg(arg)
# show messages for checks in redisplay
if arg != '':
Dashboard.err('Wrong argument "{}"'.format(arg))
elif not self.is_running():
Dashboard.err('Is the target program running?')
else:
self.redisplay()
class ConfigurationCommand(gdb.Command):
'''Dump or save the dashboard configuration.
With an optional argument the configuration will be written to the specified
file.
This command allows to configure the dashboard live then make the changes
permanent, for example:
dashboard -configuration ~/.gdbinit.d/init
At startup the `~/.gdbinit.d/` directory tree is walked and files are evaluated
in alphabetical order but giving priority to Python files. This is where user
configuration files must be placed.'''
def __init__(self, dashboard):
gdb.Command.__init__(self, 'dashboard -configuration',
gdb.COMMAND_USER, gdb.COMPLETE_FILENAME)
self.dashboard = dashboard
def invoke(self, arg, from_tty):
arg = Dashboard.parse_arg(arg)
if arg:
with open(os.path.expanduser(arg), 'w') as fs:
fs.write('# auto generated by GDB dashboard\n\n')
self.dump(fs)
self.dump(gdb)
def dump(self, fs):
# dump layout
self.dump_layout(fs)
# dump styles
self.dump_style(fs, R)
for module in self.dashboard.modules:
self.dump_style(fs, module.instance, module.prefix)
# dump outputs
self.dump_output(fs, self.dashboard)
for module in self.dashboard.modules:
self.dump_output(fs, module, module.prefix)
def dump_layout(self, fs):
layout = ['dashboard -layout']
for module in self.dashboard.modules:
mark = '' if module.enabled else '!'
layout.append('{}{}'.format(mark, module.name))
fs.write(' '.join(layout))
fs.write('\n')
def dump_style(self, fs, obj, prefix='dashboard'):
attributes = getattr(obj, 'attributes', lambda: dict())()
for name, attribute in attributes.items():
real_name = attribute.get('name', name)
default = attribute.get('default')
value = getattr(obj, real_name)
if value != default:
fs.write('{} -style {} {!r}\n'.format(prefix, name, value))
def dump_output(self, fs, obj, prefix='dashboard'):
output = getattr(obj, 'output')
if output:
fs.write('{} -output {}\n'.format(prefix, output))
class OutputCommand(gdb.Command):
'''Set the output file/TTY for the whole dashboard or single modules.
The dashboard/module will be written to the specified file, which will be
created if it does not exist. If the specified file identifies a terminal then
its geometry will be used, otherwise it falls back to the geometry of the main
GDB terminal.
When invoked without argument on the dashboard, the output/messages and modules
which do not specify an output themselves will be printed on standard output
(default).
When invoked without argument on a module, it will be printed where the
dashboard will be printed.
An overview of all the outputs can be obtained with the `dashboard -layout`
command.'''
def __init__(self, dashboard, prefix=None, obj=None):
if not prefix:
prefix = 'dashboard'
if not obj:
obj = dashboard
prefix = prefix + ' -output'
gdb.Command.__init__(self, prefix, gdb.COMMAND_USER, gdb.COMPLETE_FILENAME)
self.dashboard = dashboard
self.obj = obj # None means the dashboard itself
def invoke(self, arg, from_tty):
arg = Dashboard.parse_arg(arg)
# reset the terminal status
if self.obj.output:
try:
with open(self.obj.output, 'w') as fs:
fs.write(Dashboard.reset_terminal())
except:
# just do nothing if the file is not writable
pass
# set or open the output file
if arg == '':
self.obj.output = None
else:
self.obj.output = arg
# redisplay the dashboard in the new output
self.dashboard.redisplay()
class EnabledCommand(gdb.Command):
'''Enable or disable the dashboard.
The current status is printed if no argument is present.'''
def __init__(self, dashboard):
gdb.Command.__init__(self, 'dashboard -enabled', gdb.COMMAND_USER)
self.dashboard = dashboard
def invoke(self, arg, from_tty):
arg = Dashboard.parse_arg(arg)
if arg == '':
status = 'enabled' if self.dashboard.enabled else 'disabled'
print('The dashboard is {}'.format(status))
elif arg == 'on':
self.dashboard.enable()
self.dashboard.redisplay()
elif arg == 'off':
self.dashboard.disable()
else:
msg = 'Wrong argument "{}"; expecting "on" or "off"'
Dashboard.err(msg.format(arg))
def complete(self, text, word):
return Dashboard.complete(word, ['on', 'off'])
class LayoutCommand(gdb.Command):
'''Set or show the dashboard layout.
Accepts a space-separated list of directive. Each directive is in the form
"[!]<module>". Modules in the list are placed in the dashboard in the same order
as they appear and those prefixed by "!" are disabled by default. Omitted
modules are hidden and placed at the bottom in alphabetical order.
Without arguments the current layout is shown where the first line uses the same
form expected by the input while the remaining depict the current status of
output files.
Passing `!` as a single argument resets the dashboard original layout.'''
def __init__(self, dashboard):
gdb.Command.__init__(self, 'dashboard -layout', gdb.COMMAND_USER)
self.dashboard = dashboard
def invoke(self, arg, from_tty):
arg = Dashboard.parse_arg(arg)
directives = str(arg).split()
if directives:
# apply the layout
if directives == ['!']:
self.reset()
else:
if not self.layout(directives):
return # in case of errors
# redisplay or otherwise notify
if from_tty:
if self.dashboard.is_running():
self.dashboard.redisplay()
else:
self.show()
else:
self.show()
def reset(self):
modules = self.dashboard.modules
modules.sort(key=lambda module: module.name)
for module in modules:
module.enabled = True
def show(self):
global_str = 'Dashboard'
default = '(default TTY)'
max_name_len = max(len(module.name) for module in self.dashboard.modules)
max_name_len = max(max_name_len, len(global_str))
fmt = '{{}}{{:{}s}}{{}}'.format(max_name_len + 2)
print((fmt + '\n').format(' ', global_str, self.dashboard.output or default))
for module in self.dashboard.modules:
mark = ' ' if module.enabled else '!'
style = R.style_high if module.enabled else R.style_low
line = fmt.format(mark, module.name, module.output or default)
print(ansi(line, style))
def layout(self, directives):
modules = self.dashboard.modules
# parse and check directives
parsed_directives = []
selected_modules = set()
for directive in directives:
enabled = (directive[0] != '!')
name = directive[not enabled:]
if name in selected_modules:
Dashboard.err('Module "{}" already set'.format(name))
return False
if next((False for module in modules if module.name == name), True):
Dashboard.err('Cannot find module "{}"'.format(name))
return False
parsed_directives.append((name, enabled))
selected_modules.add(name)
# reset visibility
for module in modules:
module.enabled = False
# move and enable the selected modules on top
last = 0
for name, enabled in parsed_directives:
todo = enumerate(modules[last:], start=last)
index = next(index for index, module in todo if name == module.name)
modules[index].enabled = enabled
modules.insert(last, modules.pop(index))
last += 1
return True
def complete(self, text, word):
all_modules = (m.name for m in self.dashboard.modules)
return Dashboard.complete(word, all_modules)
class StyleCommand(gdb.Command):
'''Access the stylable attributes.
Without arguments print all the stylable attributes.
When only the name is specified show the current value.
With name and value set the stylable attribute. Values are parsed as Python
literals and converted to the proper type. '''
def __init__(self, dashboard, prefix, obj, attributes):
self.prefix = prefix + ' -style'
gdb.Command.__init__(self, self.prefix, gdb.COMMAND_USER, gdb.COMPLETE_NONE, True)
self.dashboard = dashboard
self.obj = obj
self.attributes = attributes
self.add_styles()
def add_styles(self):
this = self
for name, attribute in self.attributes.items():
# fetch fields
attr_name = attribute.get('name', name)
attr_type = attribute.get('type', str)
attr_check = attribute.get('check', lambda _: True)
attr_default = attribute['default']
# set the default value (coerced to the type)
value = attr_type(attr_default)
setattr(self.obj, attr_name, value)
# create the command
def invoke(self, arg, from_tty,
name=name,
attr_name=attr_name,
attr_type=attr_type,
attr_check=attr_check):
new_value = Dashboard.parse_arg(arg)
if new_value == '':
# print the current value
value = getattr(this.obj, attr_name)
print('{} = {!r}'.format(name, value))
else:
try:
# convert and check the new value
parsed = ast.literal_eval(new_value)
value = attr_type(parsed)
if not attr_check(value):
msg = 'Invalid value "{}" for "{}"'
raise Exception(msg.format(new_value, name))
except Exception as e:
Dashboard.err(e)
else:
# set and redisplay
setattr(this.obj, attr_name, value)
this.dashboard.redisplay(True)
prefix = self.prefix + ' ' + name
doc = attribute.get('doc', 'This style is self-documenting')
Dashboard.create_command(prefix, invoke, doc, False)
def invoke(self, arg, from_tty):
# an argument here means that the provided attribute is invalid
if arg:
Dashboard.err('Invalid argument "{}"'.format(arg))
return
# print all the pairs
for name, attribute in self.attributes.items():
attr_name = attribute.get('name', name)
value = getattr(self.obj, attr_name)
print('{} = {!r}'.format(name, value))
# Base module ------------------------------------------------------------------
# just a tag
class Module():
'''Base class for GDB dashboard modules.
Modules are instantiated once at initialization time and kept during the
whole the GDB session.
The name of a module is automatically obtained by the class name.
Optionally, a module may include a description which will appear in the
GDB help system by specifying a Python docstring for the class. By
convention the first line should contain a brief description.'''
def label(self):
'''Return the module label which will appear in the divider.'''
pass
def lines(self, term_width, term_height, style_changed):
'''Return a list of strings which will form the module content.
When a module is temporarily unable to produce its content, it
should return an empty list; its divider will then use the styles
with the "off" qualifier.
term_width and term_height are the dimension of the terminal where
this module will be displayed. If `style_changed` is `True` then
some attributes have changed since the last time so the
implementation may want to update its status.'''
pass
def attributes(self):
'''Return the dictionary of available attributes.
The key is the attribute name and the value is another dictionary
with items:
- `default` is the initial value for this attribute;
- `doc` is the optional documentation of this attribute which will
appear in the GDB help system;
- `name` is the name of the attribute of the Python object (defaults
to the key value);
- `type` is the Python type of this attribute defaulting to the
`str` type, it is used to coerce the value passed as an argument
to the proper type, or raise an exception;
- `check` is an optional control callback which accept the coerced
value and returns `True` if the value satisfies the constraint and
`False` otherwise.
Those attributes can be accessed from the implementation using
instance variables named `name`.'''
return {}
def commands(self):
'''Return the dictionary of available commands.
The key is the attribute name and the value is another dictionary
with items:
- `action` is the callback to be executed which accepts the raw
input string from the GDB prompt, exceptions in these functions
will be shown automatically to the user;
- `doc` is the documentation of this command which will appear in
the GDB help system;
- `completion` is the optional completion policy, one of the
`gdb.COMPLETE_*` constants defined in the GDB reference manual
(https://sourceware.org/gdb/onlinedocs/gdb/Commands-In-Python.html).'''
return {}
# Default modules --------------------------------------------------------------
class Source(Dashboard.Module):
'''Show the program source code, if available.'''
def __init__(self):
self.file_name = None
self.source_lines = []
self.ts = None
self.highlighted = False
self.offset = 0
def label(self):
label = 'Source'
if self.show_path and self.file_name:
label += ': {}'.format(self.file_name)
return label
def lines(self, term_width, term_height, style_changed):
# skip if the current thread is not stopped
if not gdb.selected_thread().is_stopped():
return []
# try to fetch the current line (skip if no line information)
sal = gdb.selected_frame().find_sal()
current_line = sal.line
if current_line == 0:
self.file_name = None
return []
# try to lookup the source file
candidates = [
sal.symtab.fullname(),
sal.symtab.filename,
# XXX GDB also uses absolute filename but it is harder to implement
# properly and IMHO useless
os.path.basename(sal.symtab.filename)]
for candidate in candidates:
file_name = candidate
ts = None
try:
ts = os.path.getmtime(file_name)
break
except:
# try another or delay error check to open()
continue
# style changed, different file name or file modified in the meanwhile
if style_changed or file_name != self.file_name or ts and ts > self.ts:
try:
# reload the source file if changed
with io.open(file_name, errors='replace') as source_file:
highlighter = Beautifier(file_name, self.tab_size)
self.highlighted = highlighter.active
source = highlighter.process(source_file.read())
self.source_lines = source.split('\n')
# store file name and timestamp only if success to have
# persistent errors
self.file_name = file_name
self.ts = ts
except IOError as e:
msg = 'Cannot display "{}"'.format(file_name)
return [ansi(msg, R.style_error)]
# compute the line range
height = self.height or (term_height - 1)
start = current_line - 1 - int(height / 2) + self.offset
end = start + height
# extra at start
extra_start = 0
if start < 0:
extra_start = min(-start, height)
start = 0
# extra at end
extra_end = 0
if end > len(self.source_lines):
extra_end = min(end - len(self.source_lines), height)
end = len(self.source_lines)
else:
end = max(end, 0)
# return the source code listing
breakpoints = fetch_breakpoints()
out = []
number_format = '{{:>{}}}'.format(len(str(end)))
for number, line in enumerate(self.source_lines[start:end], start + 1):
# properly handle UTF-8 source files
line = to_string(line)
if int(number) == current_line:
# the current line has a different style without ANSI
if R.ansi:
if self.highlighted and not self.highlight_line:
line_format = '{}' + ansi(number_format, R.style_selected_1) + ' {}'
else:
line_format = '{}' + ansi(number_format + ' {}', R.style_selected_1)
else:
# just show a plain text indicator
line_format = '{}' + number_format + '> {}'
else:
line_format = '{}' + ansi(number_format, R.style_low) + ' {}'
# check for breakpoint presence
enabled = None
for breakpoint in breakpoints:
addresses = breakpoint['addresses']
is_root_enabled = addresses[0]['enabled']
for address in addresses:
# note, despite the lookup path always use the relative
# (sal.symtab.filename) file name to match source files with
# breakpoints
if address['file_line'] == number and address['file_name'] == sal.symtab.filename:
enabled = enabled or (address['enabled'] and is_root_enabled)
if enabled is None:
breakpoint = ' '
else:
breakpoint = ansi('!', R.style_critical) if enabled else ansi('-', R.style_low)
out.append(line_format.format(breakpoint, number, line.rstrip('\n')))
# return the output along with scroll indicators
if len(out) <= height:
extra = [ansi('~', R.style_low)]
return extra_start * extra + out + extra_end * extra
else:
return out
def commands(self):
return {
'scroll': {
'action': self.scroll,
'doc': 'Scroll by relative steps or reset if invoked without argument.'
}
}
def attributes(self):
return {
'height': {
'doc': '''Height of the module.
A value of 0 uses the whole height.''',
'default': 10,
'type': int,
'check': check_ge_zero
},
'tab-size': {
'doc': 'Number of spaces used to display the tab character.',
'default': 4,
'name': 'tab_size',
'type': int,
'check': check_gt_zero
},
'path': {
'doc': 'Path visibility flag in the module label.',
'default': False,
'name': 'show_path',
'type': bool
},
'highlight-line': {
'doc': 'Decide whether the whole current line should be highlighted.',
'default': False,
'name': 'highlight_line',
'type': bool
}
}
def scroll(self, arg):
if arg:
self.offset += int(arg)
else:
self.offset = 0
class Assembly(Dashboard.Module):
'''Show the disassembled code surrounding the program counter.
The instructions constituting the current statement are marked, if available.'''
def __init__(self):
self.offset = 0
self.cache_key = None
self.cache_asm = None
def label(self):
return 'Assembly'
def lines(self, term_width, term_height, style_changed):
# skip if the current thread is not stopped
if not gdb.selected_thread().is_stopped():
return []
# flush the cache if the style is changed
if style_changed:
self.cache_key = None
# prepare the highlighter
try:
flavor = gdb.parameter('disassembly-flavor')
except:
flavor = 'att' # not always defined (see #36)
highlighter = Beautifier(flavor, tab_size=None)
# fetch the assembly code
line_info = None
frame = gdb.selected_frame() # PC is here
height = self.height or (term_height - 1)
try:
# disassemble the current block
asm_start, asm_end = self.fetch_function_boundaries()
asm = self.fetch_asm(asm_start, asm_end, False, highlighter)
# find the location of the PC
pc_index = next(index for index, instr in enumerate(asm)
if instr['addr'] == frame.pc())
# compute the instruction range
start = pc_index - int(height / 2) + self.offset
end = start + height
# extra at start
extra_start = 0
if start < 0:
extra_start = min(-start, height)
start = 0
# extra at end
extra_end = 0
if end > len(asm):
extra_end = min(end - len(asm), height)
end = len(asm)
else:
end = max(end, 0)
# fetch actual interval
asm = asm[start:end]
# if there are line information then use it, it may be that
# line_info is not None but line_info.last is None
line_info = gdb.find_pc_line(frame.pc())
line_info = line_info if line_info.last else None
except (gdb.error, RuntimeError, StopIteration):
# if it is not possible (stripped binary or the PC is not present in
# the output of `disassemble` as per issue #31) start from PC
try:
extra_start = 0
extra_end = 0
# allow to scroll down nevertheless
clamped_offset = min(self.offset, 0)
asm = self.fetch_asm(frame.pc(), height - clamped_offset, True, highlighter)
asm = asm[-clamped_offset:]
except gdb.error as e:
msg = '{}'.format(e)
return [ansi(msg, R.style_error)]
# fetch function start if available (e.g., not with @plt)
func_start = None
if self.show_function and frame.function():
func_start = to_unsigned(frame.function().value())
# compute the maximum offset size
if asm and func_start:
max_offset = max(len(str(abs(asm[0]['addr'] - func_start))),
len(str(abs(asm[-1]['addr'] - func_start))))
# return the machine code
breakpoints = fetch_breakpoints()
max_length = max(instr['length'] for instr in asm) if asm else 0
inferior = gdb.selected_inferior()
out = []
for index, instr in enumerate(asm):
addr = instr['addr']
length = instr['length']
text = instr['asm']
addr_str = format_address(addr)
if self.show_opcodes:
# fetch and format opcode
region = inferior.read_memory(addr, length)
opcodes = (' '.join('{:02x}'.format(ord(byte)) for byte in region))
opcodes += (max_length - len(region)) * 3 * ' ' + ' '
else:
opcodes = ''
# compute the offset if available
if self.show_function:
if func_start:
offset = '{:+d}'.format(addr - func_start)
offset = offset.ljust(max_offset + 1) # sign
func_info = '{}{}'.format(frame.function(), offset)
else:
func_info = '?'
else:
func_info = ''
format_string = '{}{}{}{}{}{}'
indicator = ' '
text = ' ' + text
if addr == frame.pc():
if not R.ansi:
indicator = '> '
addr_str = ansi(addr_str, R.style_selected_1)
indicator = ansi(indicator, R.style_selected_1)
opcodes = ansi(opcodes, R.style_selected_1)
func_info = ansi(func_info, R.style_selected_1)
if not highlighter.active or self.highlight_line:
text = ansi(text, R.style_selected_1)
elif line_info and line_info.pc <= addr < line_info.last:
if not R.ansi:
indicator = ': '
addr_str = ansi(addr_str, R.style_selected_2)
indicator = ansi(indicator, R.style_selected_2)
opcodes = ansi(opcodes, R.style_selected_2)
func_info = ansi(func_info, R.style_selected_2)
if not highlighter.active or self.highlight_line:
text = ansi(text, R.style_selected_2)
else:
addr_str = ansi(addr_str, R.style_low)
func_info = ansi(func_info, R.style_low)
# check for breakpoint presence
enabled = None
for breakpoint in breakpoints:
addresses = breakpoint['addresses']
is_root_enabled = addresses[0]['enabled']
for address in addresses:
if address['address'] == addr:
enabled = enabled or (address['enabled'] and is_root_enabled)
if enabled is None:
breakpoint = ' '
else:
breakpoint = ansi('!', R.style_critical) if enabled else ansi('-', R.style_low)
out.append(format_string.format(breakpoint, addr_str, indicator, opcodes, func_info, text))
# return the output along with scroll indicators
if len(out) <= height:
extra = [ansi('~', R.style_low)]
return extra_start * extra + out + extra_end * extra
else:
return out
def commands(self):
return {
'scroll': {
'action': self.scroll,
'doc': 'Scroll by relative steps or reset if invoked without argument.'
}
}
def attributes(self):
return {
'height': {
'doc': '''Height of the module.
A value of 0 uses the whole height.''',
'default': 10,
'type': int,
'check': check_ge_zero
},
'opcodes': {
'doc': 'Opcodes visibility flag.',
'default': False,
'name': 'show_opcodes',
'type': bool
},
'function': {
'doc': 'Function information visibility flag.',
'default': True,
'name': 'show_function',
'type': bool
},
'highlight-line': {
'doc': 'Decide whether the whole current line should be highlighted.',
'default': False,
'name': 'highlight_line',
'type': bool
}
}
def scroll(self, arg):
if arg:
self.offset += int(arg)
else:
self.offset = 0
def fetch_function_boundaries(self):
frame = gdb.selected_frame()
# parse the output of the disassemble GDB command to find the function
# boundaries, this should handle cases in which a function spans
# multiple discontinuous blocks
disassemble = run('disassemble')
for block_start, block_end in re.findall(r'Address range 0x([0-9a-f]+) to 0x([0-9a-f]+):', disassemble):
block_start = int(block_start, 16)
block_end = int(block_end, 16)
if block_start <= frame.pc() < block_end:
return block_start, block_end - 1 # need to be inclusive
# if function information is available then try to obtain the
# boundaries by looking at the superblocks
block = frame.block()
if frame.function():
while block and (not block.function or block.function.name != frame.function().name):
block = block.superblock
block = block or frame.block()
return block.start, block.end - 1
def fetch_asm(self, start, end_or_count, relative, highlighter):
# fetch asm from cache or disassemble
if self.cache_key == (start, end_or_count):
asm = self.cache_asm
else:
kwargs = {
'start_pc': start,
'count' if relative else 'end_pc': end_or_count
}
asm = gdb.selected_frame().architecture().disassemble(**kwargs)
self.cache_key = (start, end_or_count)
self.cache_asm = asm
# syntax highlight the cached entry
for instr in asm:
instr['asm'] = highlighter.process(instr['asm'])
return asm
class Variables(Dashboard.Module):
'''Show arguments and locals of the selected frame.'''
def label(self):
return 'Variables'
def lines(self, term_width, term_height, style_changed):
return Variables.format_frame(
gdb.selected_frame(), self.show_arguments, self.show_locals, self.compact, self.align, self.sort)
def attributes(self):
return {
'arguments': {
'doc': 'Frame arguments visibility flag.',
'default': True,
'name': 'show_arguments',
'type': bool
},
'locals': {
'doc': 'Frame locals visibility flag.',
'default': True,
'name': 'show_locals',
'type': bool
},
'compact': {
'doc': 'Single-line display flag.',
'default': True,
'type': bool
},
'align': {
'doc': 'Align variables in column flag (only if not compact).',
'default': False,
'type': bool
},
'sort': {
'doc': 'Sort variables by name.',
'default': False,
'type': bool
}
}
@staticmethod
def format_frame(frame, show_arguments, show_locals, compact, align, sort):
out = []
# fetch frame arguments and locals
decorator = gdb.FrameDecorator.FrameDecorator(frame)
separator = ansi(', ', R.style_low)
if show_arguments:
def prefix(line):
return Stack.format_line('arg', line)
frame_args = decorator.frame_args()
args_lines = Variables.fetch(frame, frame_args, compact, align, sort)
if args_lines:
if compact:
args_line = separator.join(args_lines)
single_line = prefix(args_line)
out.append(single_line)
else:
out.extend(map(prefix, args_lines))
if show_locals:
def prefix(line):
return Stack.format_line('loc', line)
frame_locals = decorator.frame_locals()
locals_lines = Variables.fetch(frame, frame_locals, compact, align, sort)
if locals_lines:
if compact:
locals_line = separator.join(locals_lines)
single_line = prefix(locals_line)
out.append(single_line)
else:
out.extend(map(prefix, locals_lines))
return out
@staticmethod
def fetch(frame, data, compact, align, sort):
lines = []
name_width = 0
if align and not compact:
name_width = max(len(str(elem.sym)) for elem in data) if data else 0
for elem in data or []:
name = ansi(elem.sym, R.style_high) + ' ' * (name_width - len(str(elem.sym)))
equal = ansi('=', R.style_low)
value = format_value(elem.sym.value(frame), compact)
lines.append('{} {} {}'.format(name, equal, value))
if sort:
lines.sort()
return lines
class Stack(Dashboard.Module):
'''Show the current stack trace including the function name and the file location, if available.
Optionally list the frame arguments and locals too.'''
def label(self):
return 'Stack'
def lines(self, term_width, term_height, style_changed):
# skip if the current thread is not stopped
if not gdb.selected_thread().is_stopped():
return []
# find the selected frame (i.e., the first to display)
selected_index = 0
frame = gdb.newest_frame()
while frame:
if frame == gdb.selected_frame():
break
frame = frame.older()
selected_index += 1
# format up to "limit" frames
frames = []
number = selected_index
more = False
while frame:
# the first is the selected one
selected = (len(frames) == 0)
# fetch frame info
style = R.style_selected_1 if selected else R.style_selected_2
frame_id = ansi(str(number), style)
info = Stack.get_pc_line(frame, style)
frame_lines = []
frame_lines.append('[{}] {}'.format(frame_id, info))
# add frame arguments and locals
variables = Variables.format_frame(
frame, self.show_arguments, self.show_locals, self.compact, self.align, self.sort)
frame_lines.extend(variables)
# add frame
frames.append(frame_lines)
# next
frame = frame.older()
number += 1
# check finished according to the limit
if self.limit and len(frames) == self.limit:
# more frames to show but limited
if frame:
more = True
break
# format the output
lines = []
for frame_lines in frames:
lines.extend(frame_lines)
# add the placeholder
if more:
lines.append('[{}]'.format(ansi('+', R.style_selected_2)))
return lines
def attributes(self):
return {
'limit': {
'doc': 'Maximum number of displayed frames (0 means no limit).',
'default': 10,
'type': int,
'check': check_ge_zero
},
'arguments': {
'doc': 'Frame arguments visibility flag.',
'default': False,
'name': 'show_arguments',
'type': bool
},
'locals': {
'doc': 'Frame locals visibility flag.',
'default': False,
'name': 'show_locals',
'type': bool
},
'compact': {
'doc': 'Single-line display flag.',
'default': False,
'type': bool
},
'align': {
'doc': 'Align variables in column flag (only if not compact).',
'default': False,
'type': bool
},
'sort': {
'doc': 'Sort variables by name.',
'default': False,
'type': bool
}
}
@staticmethod
def format_line(prefix, line):
prefix = ansi(prefix, R.style_low)
return '{} {}'.format(prefix, line)
@staticmethod
def get_pc_line(frame, style):
frame_pc = ansi(format_address(frame.pc()), style)
info = 'from {}'.format(frame_pc)
# if a frame function symbol is available then use it to fetch the
# current function name and address, otherwise fall back relying on the
# frame name
if frame.function():
name = ansi(frame.function(), style)
func_start = to_unsigned(frame.function().value())
offset = ansi(str(frame.pc() - func_start), style)
info += ' in {}+{}'.format(name, offset)
elif frame.name():
name = ansi(frame.name(), style)
info += ' in {}'.format(name)
sal = frame.find_sal()
if sal and sal.symtab:
file_name = ansi(sal.symtab.filename, style)
file_line = ansi(str(sal.line), style)
info += ' at {}:{}'.format(file_name, file_line)
return info
class History(Dashboard.Module):
'''List the last entries of the value history.'''
def label(self):
return 'History'
def lines(self, term_width, term_height, style_changed):
out = []
# fetch last entries
for i in range(-self.limit + 1, 1):
try:
value = format_value(gdb.history(i))
value_id = ansi('$${}', R.style_high).format(abs(i))
equal = ansi('=', R.style_low)
line = '{} {} {}'.format(value_id, equal, value)
out.append(line)
except gdb.error:
continue
return out
def attributes(self):
return {
'limit': {
'doc': 'Maximum number of values to show.',
'default': 3,
'type': int,
'check': check_gt_zero
}
}
class Memory(Dashboard.Module):
'''Allow to inspect memory regions.'''
DEFAULT_LENGTH = 16
class Region():
def __init__(self, expression, length, module):
self.expression = expression
self.length = length
self.module = module
self.original = None
self.latest = None
def reset(self):
self.original = None
self.latest = None
def format(self, per_line):
# fetch the memory content
try:
address = Memory.parse_as_address(self.expression)
inferior = gdb.selected_inferior()
memory = inferior.read_memory(address, self.length)
# set the original memory snapshot if needed
if not self.original:
self.original = memory
except gdb.error as e:
msg = 'Cannot access {} bytes starting at {}: {}'
msg = msg.format(self.length, self.expression, e)
return [ansi(msg, R.style_error)]
# format the memory content
out = []
for i in range(0, len(memory), per_line):
region = memory[i:i + per_line]
pad = per_line - len(region)
address_str = format_address(address + i)
# compute changes
hexa = []
text = []
for j in range(len(region)):
rel = i + j
byte = memory[rel]
hexa_byte = '{:02x}'.format(ord(byte))
text_byte = self.module.format_byte(byte)
# differences against the latest have the highest priority
if self.latest and memory[rel] != self.latest[rel]:
hexa_byte = ansi(hexa_byte, R.style_selected_1)
text_byte = ansi(text_byte, R.style_selected_1)
# cumulative changes if enabled
elif self.module.cumulative and memory[rel] != self.original[rel]:
hexa_byte = ansi(hexa_byte, R.style_selected_2)
text_byte = ansi(text_byte, R.style_selected_2)
# format the text differently for clarity
else:
text_byte = ansi(text_byte, R.style_high)
hexa.append(hexa_byte)
text.append(text_byte)
# output the formatted line
hexa_placeholder = ' {}'.format(self.module.placeholder[0] * 2)
text_placeholder = self.module.placeholder[0]
out.append('{} {}{} {}{}'.format(
ansi(address_str, R.style_low),
' '.join(hexa), ansi(pad * hexa_placeholder, R.style_low),
''.join(text), ansi(pad * text_placeholder, R.style_low)))
# update the latest memory snapshot
self.latest = memory
return out
def __init__(self):
self.table = {}
def label(self):
return 'Memory'
def lines(self, term_width, term_height, style_changed):
out = []
for expression, region in self.table.items():
out.append(divider(term_width, expression))
out.extend(region.format(self.get_per_line(term_width)))
return out
def commands(self):
return {
'watch': {
'action': self.watch,
'doc': '''Watch a memory region by expression and length.
The length defaults to 16 bytes.''',
'complete': gdb.COMPLETE_EXPRESSION
},
'unwatch': {
'action': self.unwatch,
'doc': 'Stop watching a memory region by expression.',
'complete': gdb.COMPLETE_EXPRESSION
},
'clear': {
'action': self.clear,
'doc': 'Clear all the watched regions.'
}
}
def attributes(self):
return {
'cumulative': {
'doc': 'Highlight changes cumulatively, watch again to reset.',
'default': False,
'type': bool
},
'full': {
'doc': 'Take the whole horizontal space.',
'default': False,
'type': bool
},
'placeholder': {
'doc': 'Placeholder used for missing items and unprintable characters.',
'default': '·'
}
}
def watch(self, arg):
if arg:
expression, _, length_str = arg.partition(' ')
length = Memory.parse_as_address(length_str) if length_str else Memory.DEFAULT_LENGTH
# keep the length when the memory is watched to reset the changes
region = self.table.get(expression)
if region and not length_str:
region.reset()
else:
self.table[expression] = Memory.Region(expression, length, self)
else:
raise Exception('Specify a memory location')
def unwatch(self, arg):
if arg:
try:
del self.table[arg]
except KeyError:
raise Exception('Memory expression not watched')
else:
raise Exception('Specify a matched memory expression')
def clear(self, arg):
self.table.clear()
def format_byte(self, byte):
# `type(byte) is bytes` in Python 3
if 0x20 < ord(byte) < 0x7f:
return chr(ord(byte))
else:
return self.placeholder[0]
def get_per_line(self, term_width):
if self.full:
padding = 3 # two double spaces separator (one is part of below)
elem_size = 4 # HH + 1 space + T
address_length = gdb.parse_and_eval('$pc').type.sizeof * 2 + 2 # 0x
return max(int((term_width - address_length - padding) / elem_size), 1)
else:
return Memory.DEFAULT_LENGTH
@staticmethod
def parse_as_address(expression):
value = gdb.parse_and_eval(expression)
return to_unsigned(value)
class Registers(Dashboard.Module):
'''Show the CPU registers and their values.'''
def __init__(self):
self.table = {}
def label(self):
return 'Registers'
def lines(self, term_width, term_height, style_changed):
# skip if the current thread is not stopped
if not gdb.selected_thread().is_stopped():
return []
# obtain the registers to display
if style_changed:
self.table = {}
if self.register_list:
register_list = self.register_list.split()
else:
register_list = Registers.fetch_register_list()
# fetch registers status
registers = []
for name in register_list:
# exclude registers with a dot '.' or parse_and_eval() will fail
if '.' in name:
continue
value = gdb.parse_and_eval('${}'.format(name))
string_value = Registers.format_value(value)
# exclude unavailable registers (see #255)
if string_value == '<unavailable>':
continue
changed = self.table and (self.table.get(name, '') != string_value)
self.table[name] = string_value
registers.append((name, string_value, changed))
# compute lengths considering an extra space between and around the
# entries (hence the +2 and term_width - 1)
max_name = max(len(name) for name, _, _ in registers)
max_value = max(len(value) for _, value, _ in registers)
max_width = max_name + max_value + 2
columns = min(int((term_width - 1) / max_width) or 1, len(registers))
rows = int(math.ceil(float(len(registers)) / columns))
# build the registers matrix
if self.column_major:
matrix = list(registers[i:i + rows] for i in range(0, len(registers), rows))
else:
matrix = list(registers[i::columns] for i in range(columns))
# compute the lengths column wise
max_names_column = list(max(len(name) for name, _, _ in column) for column in matrix)
max_values_column = list(max(len(value) for _, value, _ in column) for column in matrix)
line_length = sum(max_names_column) + columns + sum(max_values_column)
extra = term_width - line_length
# compute padding as if there were one more column
base_padding = int(extra / (columns + 1))
padding_column = [base_padding] * columns
# distribute the remainder among columns giving the precedence to
# internal padding
rest = extra % (columns + 1)
while rest:
padding_column[rest % columns] += 1
rest -= 1
# format the registers
out = [''] * rows
for i, column in enumerate(matrix):
max_name = max_names_column[i]
max_value = max_values_column[i]
for j, (name, value, changed) in enumerate(column):
name = ' ' * (max_name - len(name)) + ansi(name, R.style_low)
style = R.style_selected_1 if changed else ''
value = ansi(value, style) + ' ' * (max_value - len(value))
padding = ' ' * padding_column[i]
item = '{}{} {}'.format(padding, name, value)
out[j] += item
return out
def attributes(self):
return {
'column-major': {
'doc': 'Show registers in columns instead of rows.',
'default': False,
'name': 'column_major',
'type': bool
},
'list': {
'doc': '''String of space-separated register names to display.
The empty list (default) causes to show all the available registers.''',
'default': '',
'name': 'register_list',
}
}
@staticmethod
def format_value(value):
try:
if value.type.code in [gdb.TYPE_CODE_INT, gdb.TYPE_CODE_PTR]:
int_value = to_unsigned(value, value.type.sizeof)
value_format = '0x{{:0{}x}}'.format(2 * value.type.sizeof)
return value_format.format(int_value)
except (gdb.error, ValueError):
# convert to unsigned but preserve code and flags information
pass
return str(value)
@staticmethod
def fetch_register_list(*match_groups):
names = []
for line in run('maintenance print register-groups').split('\n'):
fields = line.split()
if len(fields) != 7:
continue
name, _, _, _, _, _, groups = fields
if not re.match('\w', name):
continue
for group in groups.split(','):
if group in (match_groups or ('general',)):
names.append(name)
break
return names
class Threads(Dashboard.Module):
'''List the currently available threads.'''
def label(self):
return 'Threads'
def lines(self, term_width, term_height, style_changed):
out = []
selected_thread = gdb.selected_thread()
# do not restore the selected frame if the thread is not stopped
restore_frame = gdb.selected_thread().is_stopped()
if restore_frame:
selected_frame = gdb.selected_frame()
# fetch the thread list
threads = []
for inferior in gdb.inferiors():
if self.all_inferiors or inferior == gdb.selected_inferior():
threads += gdb.Inferior.threads(inferior)
for thread in threads:
# skip running threads if requested
if self.skip_running and thread.is_running():
continue
is_selected = (thread.ptid == selected_thread.ptid)
style = R.style_selected_1 if is_selected else R.style_selected_2
if self.all_inferiors:
number = '{}.{}'.format(thread.inferior.num, thread.num)
else:
number = str(thread.num)
number = ansi(number, style)
tid = ansi(str(thread.ptid[1] or thread.ptid[2]), style)
info = '[{}] id {}'.format(number, tid)
if thread.name:
info += ' name {}'.format(ansi(thread.name, style))
# switch thread to fetch info (unless is running in non-stop mode)
try:
thread.switch()
frame = gdb.newest_frame()
info += ' ' + Stack.get_pc_line(frame, style)
except gdb.error:
info += ' (running)'
out.append(info)
# restore thread and frame
selected_thread.switch()
if restore_frame:
selected_frame.select()
return out
def attributes(self):
return {
'skip-running': {
'doc': 'Skip running threads.',
'default': False,
'name': 'skip_running',
'type': bool
},
'all-inferiors': {
'doc': 'Show threads from all inferiors.',
'default': False,
'name': 'all_inferiors',
'type': bool
},
}
class Expressions(Dashboard.Module):
'''Watch user expressions.'''
def __init__(self):
self.table = set()
def label(self):
return 'Expressions'
def lines(self, term_width, term_height, style_changed):
out = []
label_width = 0
if self.align:
label_width = max(len(expression) for expression in self.table) if self.table else 0
default_radix = Expressions.get_default_radix()
for expression in self.table:
label = expression
match = re.match('^/(\d+) +(.+)$', expression)
try:
if match:
radix, expression = match.groups()
run('set output-radix {}'.format(radix))
value = format_value(gdb.parse_and_eval(expression))
except gdb.error as e:
value = ansi(e, R.style_error)
finally:
if match:
run('set output-radix {}'.format(default_radix))
label = ansi(expression, R.style_high) + ' ' * (label_width - len(expression))
equal = ansi('=', R.style_low)
out.append('{} {} {}'.format(label, equal, value))
return out
def commands(self):
return {
'watch': {
'action': self.watch,
'doc': 'Watch an expression using the format `[/<radix>] <expression>`.',
'complete': gdb.COMPLETE_EXPRESSION
},
'unwatch': {
'action': self.unwatch,
'doc': 'Stop watching an expression.',
'complete': gdb.COMPLETE_EXPRESSION
},
'clear': {
'action': self.clear,
'doc': 'Clear all the watched expressions.'
}
}
def attributes(self):
return {
'align': {
'doc': 'Align variables in column flag.',
'default': False,
'type': bool
}
}
def watch(self, arg):
if arg:
self.table.add(arg)
else:
raise Exception('Specify an expression')
def unwatch(self, arg):
if arg:
try:
self.table.remove(arg)
except:
raise Exception('Expression not watched')
else:
raise Exception('Specify an expression')
def clear(self, arg):
self.table.clear()
@staticmethod
def get_default_radix():
try:
return gdb.parameter('output-radix')
except RuntimeError:
# XXX this is a fix for GDB <8.1.x see #161
message = run('show output-radix')
match = re.match('^Default output radix for printing of values is (\d+)\.$', message)
return match.groups()[0] if match else 10 # fallback
# XXX workaround to support BP_BREAKPOINT in older GDB versions
setattr(gdb, 'BP_CATCHPOINT', getattr(gdb, 'BP_CATCHPOINT', 26))
class Breakpoints(Dashboard.Module):
'''Display the breakpoints list.'''
NAMES = {
gdb.BP_BREAKPOINT: 'break',
gdb.BP_WATCHPOINT: 'watch',
gdb.BP_HARDWARE_WATCHPOINT: 'write watch',
gdb.BP_READ_WATCHPOINT: 'read watch',
gdb.BP_ACCESS_WATCHPOINT: 'access watch',
gdb.BP_CATCHPOINT: 'catch'
}
def label(self):
return 'Breakpoints'
def lines(self, term_width, term_height, style_changed):
out = []
breakpoints = fetch_breakpoints(watchpoints=True, pending=self.show_pending)
for breakpoint in breakpoints:
sub_lines = []
# format common information
style = R.style_selected_1 if breakpoint['enabled'] else R.style_selected_2
number = ansi(breakpoint['number'], style)
bp_type = ansi(Breakpoints.NAMES[breakpoint['type']], style)
if breakpoint['temporary']:
bp_type = bp_type + ' {}'.format(ansi('once', style))
if not R.ansi and breakpoint['enabled']:
bp_type = 'disabled ' + bp_type
line = '[{}] {}'.format(number, bp_type)
if breakpoint['type'] == gdb.BP_BREAKPOINT:
for i, address in enumerate(breakpoint['addresses']):
addr = address['address']
if i == 0 and addr:
# this is a regular breakpoint
line += ' at {}'.format(ansi(format_address(addr), style))
# format source information
file_name = address.get('file_name')
file_line = address.get('file_line')
if file_name and file_line:
file_name = ansi(file_name, style)
file_line = ansi(file_line, style)
line += ' in {}:{}'.format(file_name, file_line)
elif i > 0:
# this is a sub breakpoint
sub_style = R.style_selected_1 if address['enabled'] else R.style_selected_2
sub_number = ansi('{}.{}'.format(breakpoint['number'], i), sub_style)
sub_line = '[{}]'.format(sub_number)
sub_line += ' at {}'.format(ansi(format_address(addr), sub_style))
# format source information
file_name = address.get('file_name')
file_line = address.get('file_line')
if file_name and file_line:
file_name = ansi(file_name, sub_style)
file_line = ansi(file_line, sub_style)
sub_line += ' in {}:{}'.format(file_name, file_line)
sub_lines += [sub_line]
# format user location
location = breakpoint['location']
line += ' for {}'.format(ansi(location, style))
elif breakpoint['type'] == gdb.BP_CATCHPOINT:
what = breakpoint['what']
line += ' {}'.format(ansi(what, style))
else:
# format user expression
expression = breakpoint['expression']
line += ' for {}'.format(ansi(expression, style))
# format condition
condition = breakpoint['condition']
if condition:
line += ' if {}'.format(ansi(condition, style))
# format hit count
hit_count = breakpoint['hit_count']
if hit_count:
word = 'time{}'.format('s' if hit_count > 1 else '')
line += ' hit {} {}'.format(ansi(breakpoint['hit_count'], style), word)
# append the main line and possibly sub breakpoints
out.append(line)
out.extend(sub_lines)
return out
def attributes(self):
return {
'pending': {
'doc': 'Also show pending breakpoints.',
'default': True,
'name': 'show_pending',
'type': bool
}
}
# XXX traceback line numbers in this Python block must be increased by 1
end
# Better GDB defaults ----------------------------------------------------------
set history save
set verbose off
set print pretty on
set print array off
set print array-indexes on
set python print-stack full
# Start ------------------------------------------------------------------------
python Dashboard.start()
# File variables ---------------------------------------------------------------
# vim: filetype=python
# Local Variables:
# mode: python
# End:
Reference in New Issue Copy Permalink