From 6a5fd36d4c54756d36ab466bd1180a40106fbb7e Mon Sep 17 00:00:00 2001 From: LongHairedHacker Date: Sun, 19 Aug 2018 13:46:08 +0200 Subject: [PATCH] Playing with dma --- .cargo/config | 2 + .gdb_history | 256 ++++++++ .gdbdash | 1605 +++++++++++++++++++++++++++++++++++++++++++++++++ .gdbinit | 8 + .gitignore | 2 + .gitmodules | 3 + Cargo.lock | 44 ++ Cargo.toml | 20 + build.rs | 3 + hcl | 1 + src/debug.rs | 73 +++ src/main.rs | 100 +++ 12 files changed, 2117 insertions(+) create mode 100644 .cargo/config create mode 100644 .gdb_history create mode 100644 .gdbdash create mode 100644 .gdbinit create mode 100644 .gitignore create mode 100644 .gitmodules create mode 100644 Cargo.lock create mode 100644 Cargo.toml create mode 100644 build.rs create mode 160000 hcl create mode 100644 src/debug.rs create mode 100644 src/main.rs diff --git a/.cargo/config b/.cargo/config new file mode 100644 index 0000000..f5c97f7 --- /dev/null +++ b/.cargo/config @@ -0,0 +1,2 @@ +[build] +rustc = "hcl/rustc-wrapper" diff --git a/.gdb_history b/.gdb_history new file mode 100644 index 0000000..281c1d5 --- /dev/null +++ b/.gdb_history @@ -0,0 +1,256 @@ +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +continue +continue +continue +continue +continue +continue +continue +tbre + +quitr +quit +s +s +s +s +s +s +tbreak timertest::systick +continue +continue +s +s +continue +continue +quit +q +run +continue +run +continue +exit +exit() +continue +break systick +break timertest::systick +continue +continue +continue +break timertest::systick +contine +cont +s +s +s +s +s +s +s +s +s +s +s +s +n +n +print cur +continue +cont +cont +tbreak timertest::systick +cont +cont +continue +cont +cont +cont +cont +s +n +s +cont +cont +cont +cont +cont +tbreak main.rs:128 +continue +n +cont +tbreak main.rs:111 +cont +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +s +cont +cont +cont +cont + s +s +s +s +s +s +s +s +n +n +n +n +n +n +n +n +n +n +n +n +break main.rs:115 +cont +break main.rs:113 +cont +n +n +n +n +n +s +s +break main.rs:116 +cont +cont +cont +cont +run +cont +s +s +n +n +n +n +n +n +n +break main.rs:50 +cont +break main.rs:50 +cont +s +s +s +s +s +break main.rs:50 +cont +cont +cont +cont +cont +cont +cont +cont +cont +cont +run +cont +cont diff --git a/.gdbdash b/.gdbdash new file mode 100644 index 0000000..fc838dc --- /dev/null +++ b/.gdbdash @@ -0,0 +1,1605 @@ +python + +# GDB dashboard - Modular visual interface for GDB in Python. +# +# https://github.com/cyrus-and/gdb-dashboard + +import ast +import fcntl +import os +import re +import struct +import termios +import traceback +import math + +# 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 get_all_styles as styles + python for s in styles(): print(s) +""", + 'default': 'vim', + 'type': str + }, + # prompt + 'prompt': { + 'doc': """Command prompt. +This value is parsed as a Python format string in which `{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': """`{status}` when the target program is running. +See the `prompt` attribute. This value is parsed as a Python format string in +which `{pid}` is expanded with the process identifier of the target program.""", + 'default': '\[\e[1;35m\]>>>\[\e[0m\]' + }, + 'prompt_not_running': { + 'doc': '`{status}` when the target program is not running.', + 'default': '\[\e[1;30m\]>>>\[\e[0m\]' + }, + # divider + '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': '1;30' + }, + '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': '0' + }, + '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': '1;30' + }, + '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': '1;30' + }, + 'style_high': { + 'default': '1;37' + }, + 'style_error': { + 'default': '31' + } + } + +# Common ----------------------------------------------------------------------- + +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') + 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): + # 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: + return to_string(value.referenced_value()) + except gdb.MemoryError: + return to_string(value) + else: + try: + return to_string(value) + except gdb.MemoryError as e: + return ansi(e, R.style_error) + +class Beautifier(): + def __init__(self, filename, tab_size=4): + self.tab_spaces = ' ' * tab_size + self.active = False + if not R.ansi: + return + # attempt to set up Pygments + try: + from pygments.lexers import get_lexer_for_filename + from pygments.formatters import Terminal256Formatter + self.formatter = Terminal256Formatter(style=R.syntax_highlighting) + self.lexer = get_lexer_for_filename(filename, stripnl=False) + 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 anyway + source = source.replace('\t', self.tab_spaces) + if self.active: + import pygments + source = pygments.highlight(source, self.lexer, self.formatter) + return source.rstrip('\n') + +# Dashboard -------------------------------------------------------------------- + +class Dashboard(gdb.Command): + """Redisplay the dashboard.""" + + def __init__(self): + gdb.Command.__init__(self, 'dashboard', + gdb.COMMAND_USER, gdb.COMPLETE_NONE, True) + self.output = None # main terminal + # setup subcommands + Dashboard.ConfigurationCommand(self) + Dashboard.OutputCommand(self) + Dashboard.EnabledCommand(self) + Dashboard.LayoutCommand(self) + # setup style commands + Dashboard.StyleCommand(self, 'dashboard', R, R.attributes()) + # disabled by default + self.enabled = None + self.disable() + + 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 ...) + if self.is_running() and not self.output: + width = Dashboard.get_term_width() + 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) + # clean the screen and notify to avoid confusion + for output in outputs: + try: + with open(output, 'w') as fs: + fs.write(Dashboard.reset_terminal()) + fs.write(Dashboard.clear_screen()) + fs.write('--- EXITED ---') + 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 self.enabled: + 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) + # notify the user if the output is empty, on the main terminal + if all_disabled: + # write the error message + width = Dashboard.get_term_width() + gdb.write(divider(width, 'Error', True)) + gdb.write('\n') + if self.modules: + gdb.write('No module to display (see `help dashboard`)') + else: + gdb.write('No module loaded') + # write the terminator + gdb.write('\n') + gdb.write(divider(width, primary=True)) + gdb.write('\n') + gdb.flush() + # continue to allow separate terminals to update + # process each display info + for output, instances in display_map.items(): + try: + fs = None + # use GDB stream by default + if output: + fs = open(output, 'w') + fd = fs.fileno() + # setup the terminal + fs.write(Dashboard.hide_cursor()) + else: + fs = gdb + fd = 1 # stdout + # get the terminal width (default main terminal if either + # the output is not a file) + try: + width = Dashboard.get_term_width(fd) + except: + width = Dashboard.get_term_width() + # clear the "screen" if requested for the main terminal, + # auxiliary terminals are always cleared + if fs is not gdb or clear_screen: + fs.write(Dashboard.clear_screen()) + # show message in separate terminals if all the modules are + # disabled + if output != self.output and not any(instances): + fs.write('--- NO MODULE TO DISPLAY ---\n') + continue + # process all the modules for that output + for n, instance in enumerate(instances, 1): + # skip disabled modules + if not instance: + continue + # ask the module to generate the content + lines = instance.lines(width, style_changed) + # create the divider accordingly + div = divider(width, instance.label(), True, lines) + # write the data + fs.write('\n'.join([div] + lines)) + # write the newline for all but last unless main terminal + if n != len(instances) or fs is gdb: + fs.write('\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: + fs.write(divider(width, primary=True)) + fs.write('\n') + fs.flush() + 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(): + # initialize the dashboard + dashboard = Dashboard() + Dashboard.set_custom_prompt(dashboard) + # parse Python inits, load modules then parse GDB inits + Dashboard.parse_inits(True) + modules = Dashboard.get_modules() + dashboard.load_modules(modules) + Dashboard.parse_inits(False) + # GDB overrides + run('set pagination off') + # enable and display if possible (program running) + dashboard.enable() + dashboard.redisplay() + + @staticmethod + def get_term_width(fd=1): # defaults to the main terminal + # first 2 shorts (4 byte) of struct winsize + raw = fcntl.ioctl(fd, termios.TIOCGWINSZ, ' ' * 4) + height, width = struct.unpack('hh', raw) + return int(width) + + @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): + for root, dirs, files in os.walk(os.path.expanduser('~/.gdbinit.d/')): + 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 + return '\x1b[H\x1b[J' + + @staticmethod + def hide_cursor(): + # ANSI: hide cursor + return '\x1b[?25l' + + @staticmethod + def reset_terminal(): + # ANSI: reset to initial state + return '\x1bc' + +# 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.'.format(self.name) + doc_extended = 'Toggle the module visibility.' + doc = '{}\n{}\n\n{}'.format(doc_brief, doc_extended, 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): + if 'attributes' in dir(self.instance): + Dashboard.StyleCommand(dashboard, self.prefix, self.instance, + self.instance.attributes()) + + def add_subcommands(self, dashboard): + if 'commands' in dir(self.instance): + 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 ----------------------------------------------------------------- + + 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 the dashboard configuration (layout, styles, outputs). +With an optional argument the configuration will be written to the specified +file.""" + + 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 both the dashboard and 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 width will be used to format the dashboard, otherwise falls back to the +width of the main GDB terminal. Without argument the dashboard, the +output/messages and modules which do not specify the output will be printed on +standard output (default). Without argument the module will be printed where the +dashboard will be printed.""" + + 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) + # display a message in a separate terminal if released (note that + # the check if this is the last module to use the output is not + # performed since if that's not the case the message will be + # overwritten) + if self.obj.output: + try: + with open(self.obj.output, 'w') as fs: + fs.write(Dashboard.clear_screen()) + fs.write('--- RELEASED ---\n') + 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 [on|off]. +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 +"[!]". 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.""" + + 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: + self.layout(directives) + if from_tty and not self.dashboard.is_running(): + self.show() + else: + self.show() + + def show(self): + global_str = 'Global' + max_name_len = len(global_str) + # print directives + modules = [] + for module in self.dashboard.modules: + max_name_len = max(max_name_len, len(module.name)) + mark = '' if module.enabled else '!' + modules.append('{}{}'.format(mark, module.name)) + print(' '.join(modules)) + # print outputs + default = '(default)' + fmt = '{{:{}s}}{{}}'.format(max_name_len + 2) + print(('\n' + fmt + '\n').format(global_str, + self.dashboard.output or default)) + for module in self.dashboard.modules: + style = R.style_high if module.enabled else R.style_low + line = fmt.format(module.name, module.output or default) + print(ansi(line, style)) + + def layout(self, directives): + modules = self.dashboard.modules + # reset visibility + for module in modules: + module.enabled = False + # move and enable the selected modules on top + last = 0 + n_enabled = 0 + for directive in directives: + # parse next directive + enabled = (directive[0] != '!') + name = directive[not enabled:] + try: + # it may actually start from last, but in this way repeated + # modules can be handled transparently and without error + todo = enumerate(modules[last:], start=last) + index = next(i for i, m in todo if name == m.name) + modules[index].enabled = enabled + modules.insert(last, modules.pop(index)) + last += 1 + n_enabled += enabled + except StopIteration: + def find_module(x): + return x.name == name + first_part = modules[:last] + if len(list(filter(find_module, first_part))) == 0: + Dashboard.err('Cannot find module "{}"'.format(name)) + else: + Dashboard.err('Module "{}" already set'.format(name)) + continue + # redisplay the dashboard + if n_enabled: + self.dashboard.redisplay() + + 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. Subcommands are used to set +or print (when the value is omitted) individual attributes.""" + + 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(): + pass + +# 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 + + def label(self): + return 'Source' + + def lines(self, term_width, 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: + return [] + # reload the source file if changed + file_name = sal.symtab.fullname() + ts = None + try: + ts = os.path.getmtime(file_name) + except: + pass # delay error check to open() + if (style_changed or + file_name != self.file_name or # different file name + ts and ts > self.ts): # file modified in the meanwhile + self.file_name = file_name + self.ts = ts + try: + highlighter = Beautifier(self.file_name, self.tab_size) + self.highlighted = highlighter.active + with open(self.file_name) as source_file: + source = highlighter.process(source_file.read()) + self.source_lines = source.split('\n') + except Exception as e: + msg = 'Cannot display "{}" ({})'.format(self.file_name, e) + return [ansi(msg, R.style_error)] + # compute the line range + start = max(current_line - 1 - self.context, 0) + end = min(current_line - 1 + self.context + 1, len(self.source_lines)) + # return the source code listing + 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: + 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) + ' {}' + out.append(line_format.format(number, line.rstrip('\n'))) + return out + + def attributes(self): + return { + 'context': { + 'doc': 'Number of context lines.', + 'default': 5, + '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 + } + } + +class Assembly(Dashboard.Module): + """Show the disassembled code surrounding the program counter. The +instructions constituting the current statement are marked, if available.""" + + def label(self): + return 'Assembly' + + def lines(self, term_width, style_changed): + # skip if the current thread is not stopped + if not gdb.selected_thread().is_stopped(): + return [] + line_info = None + frame = gdb.selected_frame() # PC is here + disassemble = frame.architecture().disassemble + try: + # try to fetch the function boundaries using the disassemble command + output = run('disassemble').split('\n') + start = int(re.split('[ :]', output[1][3:], 1)[0], 16) + end = int(re.split('[ :]', output[-3][3:], 1)[0], 16) + asm = disassemble(start, end_pc=end) + # find the location of the PC + pc_index = next(index for index, instr in enumerate(asm) + if instr['addr'] == frame.pc()) + start = max(pc_index - self.context, 0) + end = pc_index + self.context + 1 + 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, 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 and + # end after twice the context + try: + asm = disassemble(frame.pc(), count=2 * self.context + 1) + except gdb.error as e: + msg = '{}'.format(e) + return [ansi(msg, R.style_error)] + # fetch function start if available + func_start = None + if self.show_function and frame.name(): + try: + # it may happen that the frame name is the whole function + # declaration, instead of just the name, e.g., 'getkey()', so it + # would be treated as a function call by 'gdb.parse_and_eval', + # hence the trim, see #87 and #88 + value = gdb.parse_and_eval(frame.name().split('(')[0]).address + func_start = to_unsigned(value) + except gdb.error: + pass # e.g., @plt + # fetch the assembly flavor and the extension used by Pygments + try: + flavor = gdb.parameter('disassembly-flavor') + except: + flavor = None # not always defined (see #36) + filename = { + 'att': '.s', + 'intel': '.asm' + }.get(flavor, '.s') + # prepare the highlighter + highlighter = Beautifier(filename) + # compute the maximum offset size + if 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 + max_length = max(instr['length'] for instr in asm) + 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.name(), offset) + else: + func_info = '?' + else: + func_info = '' + format_string = '{}{}{}{}{}' + indicator = ' ' + text = ' ' + highlighter.process(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: + 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: + text = ansi(text, R.style_selected_2) + else: + addr_str = ansi(addr_str, R.style_low) + func_info = ansi(func_info, R.style_low) + out.append(format_string.format(addr_str, indicator, + opcodes, func_info, text)) + return out + + def attributes(self): + return { + 'context': { + 'doc': 'Number of context instructions.', + 'default': 3, + '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 + } + } + +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, 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)) + # fetch frame arguments and locals + decorator = gdb.FrameDecorator.FrameDecorator(frame) + separator = ansi(', ', R.style_low) + strip_newlines = re.compile(r'$\s*', re.MULTILINE) + if self.show_arguments: + def prefix(line): + return Stack.format_line('arg', line) + frame_args = decorator.frame_args() + args_lines = Stack.fetch_frame_info(frame, frame_args) + if args_lines: + if self.compact: + args_line = separator.join(args_lines) + args_line = strip_newlines.sub('', args_line) + single_line = prefix(args_line) + frame_lines.append(single_line) + else: + frame_lines.extend(map(prefix, args_lines)) + else: + frame_lines.append(ansi('(no arguments)', R.style_low)) + if self.show_locals: + def prefix(line): + return Stack.format_line('loc', line) + frame_locals = decorator.frame_locals() + locals_lines = Stack.fetch_frame_info(frame, frame_locals) + if locals_lines: + if self.compact: + locals_line = separator.join(locals_lines) + locals_line = strip_newlines.sub('', locals_line) + single_line = prefix(locals_line) + frame_lines.append(single_line) + else: + frame_lines.extend(map(prefix, locals_lines)) + else: + frame_lines.append(ansi('(no locals)', R.style_low)) + # 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 + + @staticmethod + def format_line(prefix, line): + prefix = ansi(prefix, R.style_low) + return '{} {}'.format(prefix, line) + + @staticmethod + def fetch_frame_info(frame, data): + lines = [] + for elem in data or []: + name = elem.sym + equal = ansi('=', R.style_low) + value = format_value(elem.sym.value(frame)) + lines.append('{} {} {}'.format(name, equal, value)) + return lines + + @staticmethod + def get_pc_line(frame, style): + frame_pc = ansi(format_address(frame.pc()), style) + info = 'from {}'.format(frame_pc) + if frame.name(): + frame_name = ansi(frame.name(), style) + try: + # try to compute the offset relative to the current function (it + # may happen that the frame name is the whole function + # declaration, instead of just the name, e.g., 'getkey()', so it + # would be treated as a function call by 'gdb.parse_and_eval', + # hence the trim, see #87 and #88) + value = gdb.parse_and_eval(frame.name().split('(')[0]).address + # it can be None even if it is part of the "stack" (C++) + if value: + func_start = to_unsigned(value) + offset = frame.pc() - func_start + frame_name += '+' + ansi(str(offset), style) + except gdb.error: + pass # e.g., @plt + info += ' in {}'.format(frame_name) + sal = frame.find_sal() + if 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 + + def attributes(self): + return { + 'limit': { + 'doc': 'Maximum number of displayed frames (0 means no limit).', + 'default': 2, + 'type': int, + 'check': check_ge_zero + }, + 'arguments': { + 'doc': 'Frame arguments visibility flag.', + 'default': True, + '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 + } + } + +class History(Dashboard.Module): + """List the last entries of the value history.""" + + def label(self): + return 'History' + + def lines(self, term_width, 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_low).format(abs(i)) + line = '{} = {}'.format(value_id, 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.""" + + @staticmethod + def format_byte(byte): + # `type(byte) is bytes` in Python 3 + if byte.isspace(): + return ' ' + elif 0x20 < ord(byte) < 0x7e: + return chr(ord(byte)) + else: + return '.' + + @staticmethod + def parse_as_address(expression): + value = gdb.parse_and_eval(expression) + return to_unsigned(value) + + def __init__(self): + self.row_length = 16 + self.table = {} + + def format_memory(self, start, memory): + out = [] + for i in range(0, len(memory), self.row_length): + region = memory[i:i + self.row_length] + pad = self.row_length - len(region) + address = format_address(start + i) + hexa = (' '.join('{:02x}'.format(ord(byte)) for byte in region)) + text = (''.join(Memory.format_byte(byte) for byte in region)) + out.append('{} {}{} {}{}'.format(ansi(address, R.style_low), + hexa, + ansi(pad * ' --', R.style_low), + ansi(text, R.style_high), + ansi(pad * '.', R.style_low))) + return out + + def label(self): + return 'Memory' + + def lines(self, term_width, style_changed): + out = [] + inferior = gdb.selected_inferior() + for address, length in sorted(self.table.items()): + try: + memory = inferior.read_memory(address, length) + out.extend(self.format_memory(address, memory)) + except gdb.error: + msg = 'Cannot access {} bytes starting at {}' + msg = msg.format(length, format_address(address)) + out.append(ansi(msg, R.style_error)) + out.append(divider(term_width)) + # drop last divider + if out: + del out[-1] + return out + + def watch(self, arg): + if arg: + address, _, length = arg.partition(' ') + address = Memory.parse_as_address(address) + if length: + length = Memory.parse_as_address(length) + else: + length = self.row_length + self.table[address] = length + else: + raise Exception('Specify an address') + + def unwatch(self, arg): + if arg: + try: + del self.table[Memory.parse_as_address(arg)] + except KeyError: + raise Exception('Memory region not watched') + else: + raise Exception('Specify an address') + + def clear(self, arg): + self.table.clear() + + def commands(self): + return { + 'watch': { + 'action': self.watch, + 'doc': 'Watch a memory region by address and length.\n' + 'The length defaults to 16 byte.', + 'complete': gdb.COMPLETE_EXPRESSION + }, + 'unwatch': { + 'action': self.unwatch, + 'doc': 'Stop watching a memory region by address.', + 'complete': gdb.COMPLETE_EXPRESSION + }, + 'clear': { + 'action': self.clear, + 'doc': 'Clear all the watched regions.' + } + } + +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, style_changed): + # skip if the current thread is not stopped + if not gdb.selected_thread().is_stopped(): + return [] + # fetch registers status + registers = [] + for reg_info in run('info registers').strip().split('\n'): + # fetch register and update the table + name = reg_info.split(None, 1)[0] + # 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) + changed = self.table and (self.table.get(name, '') != string_value) + self.table[name] = string_value + registers.append((name, string_value, changed)) + # split registers in rows and columns, each column is composed of name, + # space, value and another trailing space which is skipped in the last + # column (hence 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 + per_line = int((term_width + 1) / max_width) or 1 + # redistribute extra space among columns + extra = int((term_width + 1 - max_width * per_line) / per_line) + if per_line == 1: + # center when there is only one column + max_name += int(extra / 2) + max_value += int(extra / 2) + else: + max_value += extra + # format registers info + partial = [] + for name, value, changed in registers: + styled_name = ansi(name.rjust(max_name), R.style_low) + value_style = R.style_selected_1 if changed else '' + styled_value = ansi(value.ljust(max_value), value_style) + partial.append(styled_name + ' ' + styled_value) + out = [] + if self.column_major: + num_lines = int(math.ceil(float(len(partial)) / per_line)) + for i in range(num_lines): + line = ' '.join(partial[i:len(partial):num_lines]).rstrip() + real_n_col = math.ceil(float(len(partial)) / num_lines) + line = ' ' * int((per_line - real_n_col) * max_width / 2) + line + out.append(line) + else: + for i in range(0, len(partial), per_line): + out.append(' '.join(partial[i:i + per_line]).rstrip()) + return out + + def attributes(self): + return { + 'column-major': { + 'doc': 'Whether to show registers in columns instead of rows.', + 'default': False, + 'name': 'column_major', + 'type': bool + } + } + + @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) + +class Threads(Dashboard.Module): + """List the currently available threads.""" + + def label(self): + return 'Threads' + + def lines(self, term_width, 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() + for thread in gdb.Inferior.threads(gdb.selected_inferior()): + # 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 + number = ansi(str(thread.num), 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 + } + } + +class Expressions(Dashboard.Module): + """Watch user expressions.""" + + def __init__(self): + self.number = 1 + self.table = {} + + def label(self): + return 'Expressions' + + def lines(self, term_width, style_changed): + out = [] + for number, expression in sorted(self.table.items()): + try: + value = format_value(gdb.parse_and_eval(expression)) + except gdb.error as e: + value = ansi(e, R.style_error) + number = ansi(number, R.style_selected_2) + expression = ansi(expression, R.style_low) + out.append('[{}] {} = {}'.format(number, expression, value)) + return out + + def watch(self, arg): + if arg: + self.table[self.number] = arg + self.number += 1 + else: + raise Exception('Specify an expression') + + def unwatch(self, arg): + if arg: + try: + del self.table[int(arg)] + except: + raise Exception('Expression not watched') + else: + raise Exception('Specify an identifier') + + def clear(self, arg): + self.table.clear() + + def commands(self): + return { + 'watch': { + 'action': self.watch, + 'doc': 'Watch an expression.', + 'complete': gdb.COMPLETE_EXPRESSION + }, + 'unwatch': { + 'action': self.unwatch, + 'doc': 'Stop watching an expression by id.', + 'complete': gdb.COMPLETE_EXPRESSION + }, + 'clear': { + 'action': self.clear, + 'doc': 'Clear all the watched expressions.' + } + } + +# 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() + +# ------------------------------------------------------------------------------ +# Copyright (c) 2015-2017 Andrea Cardaci +# +# 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. +# ------------------------------------------------------------------------------ +# vim: filetype=python +# Local Variables: +# mode: python +# End: diff --git a/.gdbinit b/.gdbinit new file mode 100644 index 0000000..c8aff38 --- /dev/null +++ b/.gdbinit @@ -0,0 +1,8 @@ +target remote :3333 +monitor arm semihosting enable +load +tbreak run +monitor reset halt +continue + +#source .gdbdash diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..53eaa21 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +/target +**/*.rs.bk diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..a2c6ab6 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "hcl"] + path = hcl + url = https://git.eno.space/hcl.git diff --git a/Cargo.lock b/Cargo.lock new file mode 100644 index 0000000..48ef0cb --- /dev/null +++ b/Cargo.lock @@ -0,0 +1,44 @@ +[[package]] +name = "hcl" +version = "0.0.0" +dependencies = [ + "platform_def 0.1.0", +] + +[[package]] +name = "hclnom" +version = "3.2.1" +dependencies = [ + "memchr 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "libc" +version = "0.2.43" +source = "registry+https://github.com/rust-lang/crates.io-index" + +[[package]] +name = "memchr" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "platform_def" +version = "0.1.0" +dependencies = [ + "hclnom 3.2.1", +] + +[[package]] +name = "reflow-firmware" +version = "0.1.0" +dependencies = [ + "hcl 0.0.0", +] + +[metadata] +"checksum libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)" = "76e3a3ef172f1a0b9a9ff0dd1491ae5e6c948b94479a3021819ba7d860c8645d" +"checksum memchr 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "148fab2e51b4f1cfc66da2a7c32981d1d3c083a803978268bb11fe4b86925e7a" diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..183935b --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,20 @@ +[package] +name = "reflow-firmware" +version = "0.1.0" +authors = ["ar3itrary "] + +[dependencies] +hcl = { path = "hcl", features = ["stm32f103:b"] } + + + +[profile.dev] +opt-level = 2 +debug = 2 +lto = true +incremental = false + +[profile.release] +opt-level = 3 +lto = true +incremental = false diff --git a/build.rs b/build.rs new file mode 100644 index 0000000..b501025 --- /dev/null +++ b/build.rs @@ -0,0 +1,3 @@ +fn main() { + println!("cargo:rustc-env=HCL_FIXUP_ARGS=1"); +} diff --git a/hcl b/hcl new file mode 160000 index 0000000..001d44d --- /dev/null +++ b/hcl @@ -0,0 +1 @@ +Subproject commit 001d44d6b9693a9ad3fd6fc8bc44e8dc22ad7149 diff --git a/src/debug.rs b/src/debug.rs new file mode 100644 index 0000000..0494b83 --- /dev/null +++ b/src/debug.rs @@ -0,0 +1,73 @@ + +use hcl::platform::usart; +use hcl::platform::dma; +use hcl::platform::PeripheralRef; +use hcl::platform::Location; +use hcl::dma::*; + +use alloc::vec::Vec; + + +type UsartDRRef = PeripheralRef>; +type UsartDMAResult<'a, Addr, Chan> = Result<'a, Vec, UsartDRRef, Chan, SetupError>; + + +pub struct UsartPrinter<'a, Addr, Chan : 'a, ChanAddr> where + Addr : hcl::platform::Location, + Chan: hcl::dma::PeripheralChannel, + ChanAddr: hcl::platform::Location { + usart_dr: Option>, + dma_result : Option>, + + dma_channel_idx: u32, + dma_channel: PeripheralRef, +} + +impl<'a, Addr, Chan, ChanAddr> UsartPrinter<'a, Addr, Chan, ChanAddr> where + Addr : hcl::platform::Location, + Chan: hcl::dma::PeripheralChannel, + ChanAddr: hcl::platform::Location { + + pub fn init(usart: usart::USARTParts, + dma_channel_idx: u32, + dma_channel: PeripheralRef) -> UsartPrinter<'a, Addr, Chan, ChanAddr> { + UsartPrinter { + usart_dr: Some(usart.dr), + dma_result: None, + dma_channel_idx: dma_channel_idx, + dma_channel: dma_channel, + } + } + + pub fn wait_for_completion(&mut self, dma_control: &mut dma::DMA1control) -> () { + match self.dma_result.take() { + Some(res) => { + let dr = match res { + Ok(tx) => { + while !dma_control.transfer_complete(self.dma_channel_idx) { + } + tx.retrieve().1 + }, + Err((_, sink, _)) => sink + }; + self.usart_dr = Some(dr) + } + None => {} + } + } + + pub fn print(&'a mut self, data: Vec, dma_control: & mut dma::DMA1control) -> () { + let dr = match self.usart_dr.take() { + Some(dr) => dr, + None => { + self.wait_for_completion(dma_control); + self.usart_dr.take().unwrap() + } + }; + + let foo = &self.dma_channel; + + dma_control.clear_transfer_complete(self.dma_channel_idx); + self.dma_result = Some(self.dma_channel.begin_source(data, dr)); + } +} diff --git a/src/main.rs b/src/main.rs new file mode 100644 index 0000000..3968ea9 --- /dev/null +++ b/src/main.rs @@ -0,0 +1,100 @@ +#![no_std] +#![feature(asm, used, const_fn, naked_functions, alloc, box_syntax)] +#![no_main] +#![feature(extern_prelude)] + +#[macro_use] +extern crate hcl; + +#[macro_use] +extern crate alloc; + +use core::mem; +use hcl::platform::gpio; +use hcl::platform::irq; +use hcl::platform::rcc; +use hcl::platform::scs; +use hcl::platform::timer; +use hcl::platform::usart; +use hcl::platform::dma; +use hcl::dma::*; + +mod debug; + +use debug::UsartPrinter; + +fn configure_clocks(rcc: &mut rcc::RCC) { + rcc.clock_control.set_hse_on(true); + while !rcc.clock_control.hse_ready() { + } + + rcc.clock_config.configure(|c| c + .set_pll_multiplier(10) + .set_pll_source(rcc::PllSource::HsiDiv2)); + + rcc.clock_control.set_pll_on(true); + while !rcc.clock_control.pll_ready() { + } + + rcc.clock_config.switch_clock_source(rcc::SystemClockSource::Pll); +} + +fn configure_peripherals(rcc: &mut hcl::platform::rcc::RCC, + gpio: &mut gpio::GPIO, + usart: &mut usart::USART) { + rcc.apb2_enable.set_gpio_a(true); + rcc.apb1_enable.configure(|a| a + .set_usart2(true)); + rcc.ahb_enable.set_dma1(true); + + gpio.configure(|g| g + .set_mode(2, gpio::PinMode::Output2MHz) + .set_output_config(2, gpio::OutputConfig::AfPushPull) + .set_mode(3, gpio::PinMode::Output50MHz) + .set_output_config(3, gpio::OutputConfig::AfPushPull) + .set_mode(5, gpio::PinMode::Output50MHz) + .set_output_config(5, gpio::OutputConfig::PushPull)); + + usart.configure(|u| u + .set_enabled(true) + .set_tx_enabled(true) + .set_dma_transmit_enabled(true) + .set_baudgen((21, 11))); // 115.2 kbaud +} + + + +// allowing inlining into main() breaks the stack, since main() must be naked to set up a process stack. +#[inline(never)] +fn run(mut scs: scs::Instance, mut p: hcl::platform::Instance) { + configure_clocks(&mut p.rcc); + configure_peripherals(&mut p.rcc, &mut p.gpio_a, &mut p.usart2); + + let dma = p.dma1.split(); + + + let mut dma_control = dma.control; + + + let printer = UsartPrinter::init(p.usart2.split(), 7, dma.channel7); + + for i in 0u32..0xffffffff { + let x = format!("> {}\r\n", i).into_bytes(); + + priner.print(x); + } + +} + + +entry_point!(main); +fn main(scs: scs::Instance, p: hcl::platform::Instance) { + declare_thread_stack!(stack, 512); + + unsafe { + hcl::set_process_stack(&stack); + hcl::use_process_stack(true); + } + + run(scs, p); +}