Seer: front-end GUI para o GDB no Linux

 (github.com/epasveer)
3 pontos por GN⁺ 2024-11-16 | 1 comentários | Compartilhar no WhatsApp
  • O Seer é um front-end para operar o GDB por meio de uma GUI no Linux e está em desenvolvimento ativo com o objetivo de oferecer uma GUI simples e visualmente agradável para o GDB
  • A instalação pode ser feita por gerenciador de pacotes ou compilando do código-fonte, e os requisitos são Linux, C++17, GDB com suporte ao interpretador MI, CMake 3.5.0 ou superior e Qt6
  • O Qt5 não compila mais a partir da árvore de código-fonte mais recente, e a árvore de código-fonte 2.3 é a última que pode ser compilada com Qt5, enquanto a v1.17 é o último release com Qt5
  • O Seer oferece na GUI navegação de código-fonte, exibição de variáveis e registradores, gerenciamento de breakpoints, watchpoints, catchpoints e printpoints, visualização de pilha e threads, além de reverse debugging do GDB
  • Recursos adicionais incluem visualização de assembly, visualização de memória, arrays, structs e imagens, além de um console de entrada e saída do programa em execução para lidar visualmente com o trabalho de depuração no GDB

Visão geral do projeto

  • Seer é um front-end GUI do GDB para Linux
  • O objetivo é fornecer uma GUI simples e visualmente agradável para o GDB
  • O projeto está em desenvolvimento ativo, e bugs ou recursos desejados podem ser enviados por e-mail ou por issue no GitHub

Instalação e requisitos

  • O Seer pode ser instalado por gerenciador de pacotes ou por compilação do código-fonte
  • Requisitos:
    • Linux
    • C++17
    • GDB com suporte ao interpretador mi
      • Comando de verificação: gdb --interpreter=mi
    • CMake 3.5.0 ou superior
    • Qt6
      • Ao compilar do código-fonte, é necessário o pacote de desenvolvimento Qt6 apropriado para a distribuição
      • Os módulos Qt6 necessários são Core, Gui, Widgets, PrintSupport, Charts e Svg
      • Instruções de build com Qt6: Building Seer - Qt6
  • Limitações relacionadas ao Qt5:

    • O Seer não compila mais com Qt5

      • A árvore de código-fonte 2.3 é a última que pode ser compilada com Qt5
      • Instruções de build com Qt5: Building Seer - Qt5

Caminhos de instalação por pacote

  • Pamac no Manjaro:
    • pamac install seer
  • zypper no openSUSE Tumbleweed:
    • zypper install seergdb
  • Flathub:
  • Versão beta em Flatpak:
    • Seer release page
    • Baixe seer.flatpak e instale
    • Para executar o GDB no GDB Launcher, é necessário flatpak-spawn --host

Releases e transição para Qt

  • Você pode conferir novidades na Seer Wiki
  • v1.17 é o último release com Qt5
  • O próximo release é o v2.0, baseado em Qt6
  • Por enquanto ainda é possível compilar com Qt5, mas, se você precisar do código-fonte Qt5 estável mais recente, deve usar v1.17

Forma de execução

  • O Seer foi criado para facilitar o início do programa a ser depurado a partir da linha de comando
  • Como o GDB oferece várias formas de dar suporte à depuração de programas, o Seer também oferece vários modos de execução
  • Os métodos de execução podem ser vistos na wiki Starting Seer

Estrutura principal da GUI

  • Source/Function/Types/Variables/Libraries

    • Mostra a lista de arquivos-fonte e arquivos de cabeçalho usados no programa
    • Permite pesquisar funções, tipos e variáveis estáticas
    • Um clique duplo abre o arquivo-fonte
    • Mostra a lista de bibliotecas compartilhadas referenciadas pelo programa
    • A lista de arquivos-fonte e de cabeçalho pode ser filtrada por busca

  • Variable/Register Info

    • Exibe valores de variáveis e registradores
    • O Logger registra os valores das variáveis
    • O Tracker mostra os valores das variáveis especificadas sempre que o GDB atinge um ponto de parada, como step, next ou finish
    • Registers mostra os valores de todos os registradores da CPU

  • Code Manager

    • É a grande área central da GUI do Seer e mostra arquivos-fonte em abas
    • É possível pesquisar texto no arquivo com ^F
    • Você pode dar clique duplo no nome de uma variável para adicioná-la ao Logger
      • CTRL + clique duplo adiciona * antes da variável
      • SHIFT + clique duplo adiciona & antes da variável
      • CTRL+SHIFT + clique duplo adiciona *& antes da variável
    • Pelo menu de clique direito, é possível adicionar a variável ao Tracker ou ao Memory Visualizer
    • É possível criar um breakpoint ou printpoint em uma linha específica
    • É possível executar até uma linha específica
    • As abas podem ser destacadas com clique duplo

Controle de depuração e visualização do estado de execução

  • A área inferior lida com breakpoints, watchpoints, catchpoints, printpoints, comandos manuais do GDB e logs
  • Na aba de comandos manuais, você pode inserir diretamente comandos do GDB ou do GDB/MI
    • Os comandos inseridos são lembrados para o próximo uso do Seer
  • O Breakpoint manager cria e gerencia breakpoints
  • O Watchpoint manager monitora acesso a variáveis
    • É possível monitorar leitura, escrita ou leitura e escrita
  • O Catchpoint manager interrompe a execução em chamadas throw, rethrow e catch do C++
  • O Printpoint manager permite imprimir variáveis em pontos específicos, como o dprintf do GDB
  • GDB output registra a saída do próprio programa GDB
  • Seer output registra a saída de diagnóstico do programa Seer
  • Informações de stack frame:
    • É possível mudar o escopo atual da função com clique duplo na lista de frames
    • Mostra os argumentos de função de cada frame
    • Mostra os valores das variáveis locais da função atual
  • Informações de thread:
    • Mostra a lista de IDs de todas as threads
    • É possível mudar o escopo atual da thread com clique duplo no ID da thread
    • Lista os stack frames de cada thread
  • Suporta o modo de Reverse Debugging do GDB
    • É possível ativar ou desativar o registro de comandos
    • A direção da reprodução pode ser definida como forward ou reverse

Console e visualização de assembly

  • O Seer Console mostra toda a saída de texto do executável
  • A entrada de texto para o executável também pode ser feita no console
  • Assembly View adiciona uma aba ao lado das abas de código-fonte para mostrar o assembly em execução no momento
    • É ativada em View->Assembly View
    • Também é possível definir breakpoints na aba de assembly
    • A instrução atual é destacada
    • Ao dar clique duplo em um item da aba Breakpoints ou Stack frames, o assembly daquele endereço é exibido
    • Suporta atalhos Nexti e Stepi, normalmente com padrão Ctrl+F5 e CTRL+F6
    • Ao usar ^F na aba de assembly, a barra de busca é exibida
    • Esse recurso de assembly é novo e aceita sugestões de mudanças e funcionalidades

Ferramentas de visualização

  • Memory Visualizer

    • Permite inspecionar conteúdo bruto de memória
    • É possível visualizá-lo como memória e como disassembly

  • Array Visualizer

    • Visualiza o conteúdo de arrays
    • Oferece modos de exibição Normal, Spline e Scatter
    • Dois arrays podem ser usados como gráfico X-Y
    • O array de exemplo points forma um contorno X-Y

  • Struct Visualizer

    • Mostra o conteúdo de structs em C/C++ ou classes C++
    • O exemplo mostra o conteúdo de *this da classe C++ atual
    • Membros de struct de tipos básicos podem ser editados
    • Também existe o Basic Struct Visualizer, que é mais leve, mas não consegue seguir ponteiros nem permite edição

  • Image Visualizer

    • Pode ser usado ao visualizar conteúdo bruto de memória que represente uma imagem

Suporte e contato

  • Bugs ou solicitações de recurso podem ser enviados para epasveer@att.net ou registrados como issue no GitHub
  • Registrar issue: GitHub issues

Leituras relacionadas

1 comentários

 
GN⁺ 2024-11-16
Opiniões no Hacker News

  • Compilei no Linux junto com o Godot e usei um pouco; no geral é OK, mas a UI parece carregada demais de widgets e um tanto pouco polida
    Alterar a fonte do editor não funcionou, e ao passar o mouse sobre uma variável para ver o valor, ou nada acontecia, ou o cursor mudava por um instante muito curto e então o GDB emitia um erro dizendo que tentou usar uma expressão contendo um tipo/palavra-chave
    Dar duplo clique em uma variável adiciona o valor atual e um timestamp em algum painel, então a funcionalidade de ler valores/expressões pela UI existe, mas a implementação dos tooltips parece quebrada
    Com um pouco mais de acabamento pode ficar útil, mas, entre os front-ends que já testei até agora, o que menos me desagradou foi o Gede. A UI é simples e intuitiva e, embora não tenha muitos recursos, os que ficam expostos tendem a funcionar bem, sem bugs: https://gede.dexar.se/

    • Sou o autor do Seergdb. Seria bom se você pudesse explicar melhor a parte em que a configuração da fonte do editor não funciona; nos testes, ela parece funcionar
      Para salvar a configuração de forma permanente, é preciso usar “Save Configuration...”. Também vou testar a exibição de valores ao passar o mouse sobre variáveis; se puder deixar bugs ou pedidos de recursos como issues no GitHub, seria ótimo
    • Quando estou tentando encontrar bugs no meu código, não quero ter que lidar também com bugs da ferramenta de depuração, então anotei para experimentar o Gede da próxima vez que eu precisar depurar

  • O GDB também tem uma interface de usuário em texto (TUI) embutida que é surpreendentemente fácil de usar. Ela até oferece suporte a interações com o mouse: https://sourceware.org/gdb/current/onlinedocs/gdb.html/TUI.h...

    • Pessoalmente, prefiro a linha de comando à TUI, mas dá para colocar algo assim no .gdbinit
      tui new-layout default regs 1 {-horizontal src 1 asm 1} 2 status 0 cmd 1
      tui layout default
      tui enable
    • A combinação Neovim + nvim-dap + nvim-dap-ui + gdb foi muito melhor do que isso
    • Infelizmente, só funciona se o GDB tiver sido compilado com suporte à TUI

  • Depois de usar vários front-ends para GDB, acho que a TUI é a melhor opção. Quando o programa imprime saída e bagunça a interface, basta saber que Ctrl + L redesenha a tela
    Em $XDG_CONFIG_HOME/gdb/gdbinit, deixo apenas isto
    layout src
    set confirm off

    • Gosto de usar um prompt colorido assim
      set prompt \001\033[01;36m\002(gdb)\001\033[0m\002
      E salvo o histórico assim
      set history save on
      set history size 500000
      set history filename ~/.cache/gdb/history
    • Usei bastante o gdb-dashboard e recomendo. Ele é parecido com a TUI, mas permite escolher vários tipos de informação para exibir, e as cores tornam a saída muito mais legível
      Também dá para mostrar o dashboard em outro terminal, ou dividi-lo entre vários terminais, o que permite criar disposições de janelas melhores. Antigamente fiz um script com tmux para gerar automaticamente a disposição dos terminais e conectá-los ao GDB; dá bastante trabalho, mas foi possível criar um layout bem bom
    • Ctrl + L é algo obrigatório de saber em interfaces do tipo TUI, inclusive quando a tela do Vim fica corrompida. Depois que aprendi isso, inúmeros “crashes” misteriosos foram resolvidos
    • O gef tem suporte a tmux, então a saída do programa vai para outro painel do tmux
    • O front-end gud-gdb dentro do Emacs é bem conveniente e fácil de usar

  • Mesmo quando você está conectado a um Linux a partir do Windows, ou usando WSL, é possível depurar remotamente processos Linux com WinDBG/VisualStudio

    • Não basta ter o gdbserver rodando no lado remoto?

  • Isto é uma UI em Qt para GDB
    Pelo que sei, também existe o gdbgui, uma UI baseada na web para GDB: https://www.gdbgui.com/
    É sempre bom ver mais movimento em ferramentas de depuração

    • Gosto de como o GDB funciona no Qt Creator sem configurações complexas. Você coloca alguns breakpoints, aperta executar, e a IDE cuida do resto
    • Para acrescentar mais um à lista de GUIs para GDB, também existe uma que eu fiz: https://github.com/dzaima/grr
      Ainda faltam vários recursos que podem ser essenciais para alguns usos. Isso porque meu modo de uso é principalmente depuração em nível de assembly, então eu não precisava de muitos recursos sofisticados
    • Também existe o DDD. É um front-end em Motif
    • O VS Code também tem um front-end decente para GDB, e é especialmente bom para depurar microcontroladores embarcados
    • Já que o assunto chegou a depuradores baseados na web, recentemente criei um projeto parecido focado em depuração de assembly x86-64: https://github.com/robalb/x86-64-playground

  • Dois anos atrás também houve uma discussão de porte médio: https://news.ycombinator.com/item?id=33044885

  • Se você usa Emacs, o GUD é uma integração com o GDB bastante boa

    • Depois que o LSP apareceu, o Emacs passou a parecer melhor do que todo o resto. Não há motivo para sair. Especialmente depois que ficou mais rápido com compilação nativa.
      Não há motivo para continuar experimentando o novo editor do mês só porque ele adicionou alguns recursos meio de brinquedo. Colocando um plugin no Emacs, consigo o mesmo recurso e mantenho todo o resto do jeito que eu gosto.
      Entrei de cabeça em programação na época do Atom, e fiquei bem triste quando o Atom desapareceu e virou o VS Code. O VS Code é bom, mas não segue a mesma filosofia do Atom.
      Desde que aprendi Emacs há uns 4 anos, nenhuma ferramenta nova me convenceu dizendo “isso é tecnologia velha, você precisa trocar”. É um discurso aleatório e longo, mas sou muito grato por o Emacs continuar sobrevivendo.
    • Prefiro M-x gdb, a GDB Graphical Interface do Emacs, ao M-x gud-gdb, que é a integração básica via GUD.
      Recentemente tive que mudar para o GUD para rodar o lldb, e senti falta das janelas dedicadas que mostram breakpoints, threads, a stack atual etc.
      O bom do GUD é que a interface é consistente mesmo com depuradores diferentes. Assim, ao depurar Python com pdb e depois C++ com lldb, não preciso reaprender atalhos de teclado.
      https://www.gnu.org/software/emacs/manual/html_node/emacs/GD...
      https://www.gnu.org/software/emacs/manual/html_node/emacs/St...
    • dape(https://github.com/svaante/dape#) é uma boa opção para linguagens que têm um depurador que implementa o Debug Adapter Protocol.
      Usando com o debugpy, deixei de usar M-x pdb, e a UI também é muito parecida com M-x gdb.
    • lsp-mode + dap-mode também funciona bem, mas é preciso mexer um pouco manualmente no arquivo launch.json.

  • Legal. Me lembra o DDD, que pareceu mágico quando vi pela primeira vez. Fico surpreso que o DDD ainda esteja sendo mantido.
    https://en.wikipedia.org/wiki/Data_Display_Debugger
    https://www.gnu.org/software/ddd/

    • Aprendi DDD na universidade há 20 anos, e mesmo naquela época ele já parecia tosco. Hoje vejo com muito mais tolerância, mas o Motif ainda me incomoda visualmente.
      Pelo que vi em anos de conversas, o DDD foi, paradoxalmente, uma ótima ferramenta de antimarketing, empurrando desenvolvedores para a UI de depuração embutida de suas IDEs favoritas. É verdade que o DDD em si é muito poderoso, mas até o “usabilidade é mais importante que estética” tem seus limites.
    • Claro que o DDD está em manutenção. Escrevi aqui sobre os recursos: https://begriffs.com/posts/2022-07-17-debugging-gdb-ddd.html
      Depois que escrevi o texto, os mantenedores corrigiram os problemas que apontei, então agora não são necessárias tantas gambiarras. As versões 3.4.0 e 3.4.1 são lançamentos bem grandes.
    • Gosto do fato de o DDD trazer várias visualizações gráficas embutidas. Em especial, sempre achei muito legal a função de visualizar estruturas de dados.
      Houve um projeto antigamente para portar para GTK3, mas parece que desapareceu. Ainda assim, fico feliz que o projeto principal continue seguindo em frente.
    • Isso me lembra o Insight, meu front-end de GDB favorito, que funcionava bem no Windows na época do cygwin. Infelizmente, definitivamente não é mais mantido: https://sourceware.org/insight/screenshots.php
      Ainda assim, parece que alguém o moveu para o GitHub, ressuscitou o projeto e fez um pouco de trabalho nele: https://github.com/antony-jr/insight
    • DDD é excelente. Ainda uso, mas sou uma espécie de fóssil.
      Encontrei o DDD quando estava procurando algo parecido com o dbxtool que eu usava nas máquinas antigas da Sun Microsystems. Hoje em dia o pessoal tem bastante luxo com coisas como depuração em nível de código-fonte.

  • O projeto GNU e o RMS parecem ser bastante ridicularizados como memes, mas o GDB é uma ferramenta poderosa. Eu só mexi um pouco diretamente, mas parece ter tido um impacto enorme no trabalho de desenvolvedores ao longo dos anos.

    • Pergunta sincera: por que exatamente o GNU é ridicularizado?

  • Há mais de 10 anos, quando eu escrevia C++ no Linux, usava o Qt Creator, que tinha um depurador integrado. Era um front-end para GDB, funcionava muito bem, e para C++ e Qt eu não via motivo para usar outra coisa.