Panel de GDB: interfaz visual modular para GDB en Python

Una interfaz visual modular para GDB en Python.

Esto viene como un único archivo .gdbinit independiente que, entre otras cosas, habilita un panel configurable que muestra la información más relevante mientras se ejecuta el programa. Su objetivo principal es reducir la cantidad de comandos GDB emitidos para inspeccionar el estado actual del programa, lo que permite al programador concentrarse en el flujo de control.

Índice de contenidos

    Instalación

    Simplemente coloque .gdbinit en su directorio de inicio, por ejemplo:

    wget -P ~ git.io/.gdbinit

    Características:

    • Archivo de inicio de GDB único.
    • Escriba el tablero en la consola principal de GDB o en un archivo externo / TTY.
    • Interacción con GDB utilizando la API nativa de Python.
    • Se incluyen varios módulos predefinidos para cubrir las necesidades más básicas: código fuente, ensamblajes, registros, etc.).
    • Los módulos definidos por el usuario se pueden desarrollar fácilmente ampliando una clase de Python.
    • Los archivos de configuración adicionales (tanto GDB como Python) se leen desde ~ / .gdbinit.d /.
    • Interfaz de usuario totalmente personalizable y símbolo del sistema dinámico.
    • Resaltado de sintaxis opcional usando la biblioteca Pygments Python.
    • No se han redefinido los comandos de GDB, en su lugar, todas las funciones están disponibles como subcomandos del comando del panel principal.

    Formas predefinidas:

    A continuación se muestra la lista de módulos empaquetados predefinidos. Consulte el sistema de ayuda de GDB para obtener la sintaxis completa.

    • montaje muestra el código desmontado que rodea el contador del programa. Las declaraciones que componen la declaración actual están marcadas, si están disponibles.
    • historia enumera las últimas entradas en el historial de valores de GDB.
    • memoria le permite inspeccionar las regiones de memoria.
    • registros muestra los registros de la CPU y sus valores.
    • fuente muestra el código fuente del programa, si está disponible.
    • apilar muestra el seguimiento de la pila actual, incluido el nombre de la función y la ruta del archivo, si está disponible. Opcionalmente, también enumera los argumentos del marco y las configuraciones regionales.
    • discusiones enumera los hilos actualmente disponibles.
    • expresiones mira las expresiones del usuario.

      Salida del tablero:

      De forma predeterminada, el tablero se muestra en la terminal GDB pero el -producción El comando tanto del tablero como de los módulos puede cambiar este comportamiento. Cuando no se especifica la salida de un módulo, se utiliza la salida global.

      Ver el tablero completo en otra terminal

      Puede ser útil mover el tablero a otra terminal para que la terminal principal se pueda usar exclusivamente para comandos GDB y E / S de destino.

      1. iniciar GDB en una terminal;
      2. abra otra terminal (por ejemplo, panel tmux) y obtenga su TTY con el tty comando (ex / dev / ttys001, el nombre puede ser diferente por diversas razones);
      3. dar la orden tablero -output / dev / ttys001 redirigir la salida del tablero a la terminal recién creada;
      4. depurar como de costumbre.

              Ver todo el panel en un navegador web

              Yendo aún más lejos, se podría usar un navegador web como terminal auxiliar usando gotty. Por supuesto, utilizando el método descrito anteriormente, también puede ver la salida de módulos individuales en una o más instancias del navegador web.

              1. iniciar GDB en una terminal;
              2. abre otra terminal y ejecuta gotty sh -c 'tty; gato';
              3. abre un navegador web, ve a http: // localhost: 8080 y tome nota del TTY;
              4. dar la orden tablero -output / dev / ttys001 redirigir la salida del tablero al navegador web;
              5. depurar como de costumbre.

              Comandos

              La documentación de GDB está disponible en panel de ayuda. Al igual que cualquier comando de GDB, las abreviaturas son posibles, por lo tanto de, pizcaetc. todos resuelven Panel.

              • Panel

              Este es el comando raíz y se usa para mostrar manualmente el tablero nuevamente.

              • tablero -configuración [<file>]

              Ver y, opcionalmente, escribir en la configuración actual (diseño, estilos, salidas). Este comando le permite configurar el tablero en tiempo real y luego hacer que los cambios sean permanentes, por ejemplo:

              dashboard -configuration ~/.gdbinit.d/auto

              • tablero de salida [<file>]

              De forma predeterminada, el panel se escribe en la consola de GDB, pero puede redirigir su salida a un archivo o incluso a otra terminal. Si el destino es un terminal TTY válido, su ancho se usa para formatear el tablero; de lo contrario, vuelve al ancho de la consola principal de GDB.

              Sin argumentos restablece esta configuración al valor predeterminado.

              • tablero de instrumentos habilitado [on|off]

              Habilite o deshabilite la visualización automática del tablero cada vez que el programa de destino falle. El tablero está habilitado de forma predeterminada e incluso cuando está deshabilitado, se puede ver manualmente con el tablero.

              A veces puede ser conveniente rediseñar el tablero incluso si el programa de destino no ha cambiado su estado de ejecución, por ejemplo, cuando el programador cambia el marco seleccionado actualmente con los comandos arriba o abajo. Puede hacer esto configurando algunos enlaces GDB en el archivo de inicio definido por el usuario, por ejemplo:

              define hookpost-up
              dashboard
              end
              
              define hookpost-down
              dashboard
              end

              • diseño del tablero [<directive>...]

              De forma predeterminada, todos los módulos están habilitados y colocados dentro del tablero en orden alfabético. A medida que crece el número de módulos, es importante decidir qué módulos formarán parte del tablero y dónde.

              Cada directiva tiene la forma [!], ¡cuando el! está presente, por lo que el módulo correspondiente está deshabilitado por defecto. El orden de las directivas indica el orden en el que se muestran en el tablero. Por ejemplo:

              dashboard -layout source !assembly stack

              Los módulos que no aparecen en la lista se desactivan y se colocan después del último elemento en orden alfabético.

              Cuando se ejecuta sin argumentos, este comando enumera todos los módulos disponibles como una lista de directivas seguida del estado de los archivos de salida del módulo.

              • estilo del tablero [<name> [<value>]]

              Para acceder a los atributos de estilo del tablero, consulte Atributos de estilo. Por ejemplo, para cambiar el mensaje a algo más familiar:

              dashboard -style prompt '(gdb)'

              El argumento se analiza como un literal de Python y se convierte al tipo correcto.

              Cuando solo se especifica el nombre, este comando muestra el valor actual, mientras que sin argumentos imprime todos los atributos.

              Subcomandos de módulos

              • Cada módulo agrega su propio subcomando tablero que se utiliza para activar / desactivar la bandera de habilitación y para mostrar el tablero nuevamente.
              • Los módulos también pueden declarar subcomandos adicionales, consulte la ayuda tablero por GDB.
              • Hay dos subcomandos adicionales predefinidos: -estilo Y -producción.

              -estilo

              Si un módulo declara algunos atributos que se pueden cambiar, entonces el comando tablero -estilo estará disponible. Su funcionamiento es equivalente al estilo del tablero comando pero se aplica a un módulo.

              -producción

              Asimismo, el tablero -producción imita el estilo del tablero comando pero permite una operación más fina.

              Configuración

              Presentar en ~ / .gdbinit.d / se ejecutan en orden alfabético, pero se da preferencia a los archivos Python. Si hay subdirectorios, se recorren de forma recursiva. La idea es mantener la definición del módulo personalizado separada de la propia configuración.

              Por convención, el archivo de configuración principal debe colocarse en ~ / .gdbinit.d / (decir ~ / .gdbinit.d / init) y se puede utilizar para ajustar los estilos del tablero y la configuración de formularios, pero también los parámetros habituales de GDB.

              La alternativa es realizar cambios en el código de hardware proporcionado. .gdbinit, para hacer eso, simplemente agregue nuevos módulos y configuraciones de GDB a continuación # Formas predefinidas Y # Mejores valores predeterminados de GDB respectivamente.

              Configuración por proyecto

              GDB admite de forma nativa la carga automática de .gdbinit , esto puede resultar útil para configurar un estilo de panel diferente en función del tipo de proyecto actual (por ejemplo, desarrollo en C ++, ingeniería inversa, etc.). Esta función está desactivada de forma predeterminada por motivos de seguridad. Para habilitar la carga automática en cualquier lugar del sistema de archivos, agregue esta línea al archivo de configuración principal:

              set auto-load safe-path /

              Atributos estilizables

              Hay una serie de atributos que se pueden usar para personalizar la apariencia del tablero y sus formularios. Están documentados en el sistema de ayuda de GDB. En cuanto al tablero en sí, se puede acceder a él con:

              help dashboard -style

              Mientras que para los módulos:

              help dashboard <module> -style

              • Códigos de escape ANSI

              Los colores y estilos de texto se especifican mediante códigos de escape ANSI. Por ejemplo, establecer un estilo en 1; 31 producirá ^[[1;31m, which will result in displaying the text red (31) and bright (1). The ANSI output can be disabled by setting the ansi attribute to False (note that this will not affect the command prompt).

              • Syntax highlighting
              When the ansi attribute is set to True the Pygments Python library may be used by modules to provide syntax highlighting of the source code.
              The syntax_highlighting stylable attribute is a string which defines the Pygments style to use.
              The list of all the available styles can be obtained with (from GDB itself):
              python
              from pygments.styles import get_all_styles as styles
              for s in styles():
                  print(s)
              end
              

              To conveniently cycle through and try each available style (press Return to try the next style and Ctrl-D to exit):

              python
              from pygments.styles import get_all_styles as styles
              for s in styles():
                  c="dashboard -style syntax_highlighting {!r}".format(s)
                  gdb.execute(c)
                  print(c)
                  input()
              end
              
              • Dividers
              A divider is basically a terminal-wide horizontal line with an optional label. Primary dividers are those used to separate the modules, whereas secondary dividers may be used inside modules to logically separate different sections. When a section or module is empty then the styles used for the divider are those with the off qualifier.
              • Common styles
              These are general purpose ANSI styles defined for convenience and used within the default modules.
              • style_selected_1
              • style_selected_2
              • style_low
              • style_high
              • style_error

                Custom Modules

                The idea of custom modules is that they provide ways to access readonly information from the target program status; it is safe to assume that they will be queried during the program execution only.

                Custom modules must inherit the Dashboard.Module class and define some methods:

                • label returns the module label which will appear in the divider.
                • lines 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.
                The name of a module is automatically obtained by the class name.
                Modules are instantiated once at initialization time and kept during the whole the GDB session.
                Optionally, a module may include a description which will appear in the GDB help system by specifying a Python docstring for the class.
                Optionally, a module may define stylable attributes by defining the attributes method returning a dictionary in which the key is the attribute name and the value is another dictionary:
                The name of a module is automatically obtained by the class name.

                Modules are instantiated once at initialization time and kept during the whole the GDB session.

                Optionally, a module may include a description which will appear in the GDB help system by specifying a Python docstring for the class.

                Optionally, a module may define stylable attributes by defining the attributes method returning a dictionary in which the key is the attribute name and the value is another dictionary:

                • default is the initial value for this attribute.
                • doc is the documentation of this attribute which will appear in the GDB help system. This key can be omitted.
                • name is the name of the attribute of the Python object, defaults to the key value.
                • type is the type of this attribute, it is used to coerce the value passed as an argument to the proper type, or raise an exception. This key defaults to the str type.
                • check is a control callback which accept the coerced value and returns True if the value satisfies the constraint and False otherwise. This key is optional, when omitted no check is performed.

                Optionally, a module may declare subcommands by defining the commands method returning a dictionary in which the key is the command name and the value is another dictionary:

                • action is the callback to be executed which accepts the raw input string from the GDB prompt. Callbacks may raise exceptions to notify erroneous situations which message will be shown automatically to the user.
                • doc is the command documentation.
                • completion is the completion policy, one of the gdb.COMPLETE_* constants defined in the reference manual. This key is optional and defaults to None which is equivalent to gdb.COMPLETE_NONE.
                • Common Functions
                A number of auxiliary common functions are defined in the global scope, they can be found in the provided .gdbinit and concern topics like ANSI output, divider formatting, conversion callbacks, etc. They should be more or less self-documented, some usage examples can be found within the bundled default modules.
                • Example
                Default modules already provide a good example, but here is a simple module which may be used as a template for new custom modules, it allows the programmer to note down some snippets of text during the debugging session.

                class Notes(Dashboard.Module):
                    """Simple user-defined notes."""
                
                    def __init__(self):
                        self.notes = []
                
                    def label (self): return 'Note' def lines (self, term_width, style_changed): out = []
                        para nota en self.notes: out.append (note) if self.divider: out.append (divider ()) return out[:-1] if self.divider else out def add (self, arg): if arg: self.notes.append (arg) else: raise Exception ('No se puede agregar una nota en blanco') def clear (self, arg): self.notes = []
                
                    comando def (self): return {'agregar': {'acción': self.add, 'doc': 'Agregar una nota.'  }, 'clear': {'action': self.clear, 'doc': 'Eliminar todas las notas.'  }} atributos def (self): return {'divisor': {'doc': 'Visibilidad del divisor de banda.', 'predeterminado': Verdadero, 'tipo': bool}}
                
                

                Para usar lo anterior, guárdelo en un archivo de Python, por ejemplo, notes.py, dentro ~ / .gdbinit.d /, los siguientes comandos estarán disponibles (junto con la ayuda):

                dashboard notes
                dashboard notes add
                dashboard notes clear
                dashboard notes -style
                

                Requerimientos mínimos:

                El panel de GDB requiere al menos GDB 7.7 compilado con Python 2.7 para funcionar correctamente.

                Interfaces adicionales de GDB

                El tablero de GDB no está diseñado para funcionar perfectamente con interfaces adicionales, por ejemplo, TUI, Nemiver, QtCreator, etc.

                Básicamente, existen dos opciones para solucionar este problema:

                • si la herramienta de depuración principal es el tablero de GDB, se recomienda evitar que el front-end cargue el archivo .gdbinit, generalmente tienen una opción para hacerlo;
                • de lo contrario, puede cargar manualmente el panel de GDB o instalarlo como de costumbre y luego:
                mv ~/.gdbinit ~/.gdb-dashboard
                

                finalmente cárguelo cuando sea necesario desde el shell GDB:

                source ~/.gdb-dashboard
                

                Deja una respuesta

                Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

                Subir