gdb-pratico/mods/01/README.org

Curso prático de introdução ao GDB

• 1. Primeiro contato guiado
  • Objetivos
  • O que é o GDB
  • O que é depurar (debugar)
    • Uma nota sobre depuração preventiva
  • Uma pequena demonstração
    • Iniciando o GDB para depuração
    • Terminando o GDB
    • Omitindo a mensagem de início
    • Uma nota sobre compilação com símbolos de depuração
    • Listando o código-fonte
    • Ponto de parada e execução

1. Primeiro contato guiado

Objetivos

• Entender o que é o GDB;
• Conhecer o conceito de depuração;
• Demonstrar o GDB em ação.

O que é o GDB

O GDB (GNU Debugger) é uma ferramenta de depuração de programas escritos em diversas linguagens. Ele possibilita a inspeção da execução de um programa em tempo real ou após uma falha, fornecendo recursos como:

• Pontos de parada (breakpoints);
• Execução passo a passo (step-by-step);
• Visualização e modificação de variáveis;
• Análise de memória e registradores;
• Inspeção da pilha de chamadas (backtrace);
• Avaliação de expressões em tempo de execução;
• Depuração de múltiplas threads;
• Depuração remota (via gdbserver).

Por operar em baixo nível, o GDB oferece uma visão detalhada do comportamento interno do programa, sendo essencial tanto para o desenvolvimento quanto para o diagnóstico de erros complexos.

O que é depurar (debugar)

Depuração (ou debugging) é o processo de identificar, analisar e corrigir erros (bugs) em um programa ou sistema. Durante a depuração, o programador examina o comportamento do código para entender onde e por que ele não funciona como esperado. O objetivo é encontrar a origem dos problemas e corrigi-los, até que o software opere corretamente.

Sem o auxílio de ferramentas especializadas, a depuração pode ser feita, por exemplo:

• Com uma revisão cuidadosa do que está escrito no código-fonte;
• Inserindo a exibição de mensagens em pontos suspeitos do código para avaliar variáveis ("o valor está correto neste ponto?") e o próprio fluxo de execução ("o programa chegou a este ponto?");
• Com a análise manual de algoritmos, seguindo a execução do programa no código tendo em mente alguns exemplos de entrada.

Mas existem ferramentas (como o GDB) que auxiliam o processo de depuração que, sem alterar diretamente o código, oferecem formas de:

• Definir pontos de parada (breakpoints);
• Monitorar a alteração de valores em variáveis (whatchpoints);
• Executar o programa passo a passo;
• Examinar dados em endereços específicos da memória através de símbolos;
• Examinar o conteúdo da pilha de chamadas de sistema;
• Explorar informações sobre o processo do programa na memória…

Entre várias outras possibilidades.

Também existem ferramentas especializadas em aspectos e métodos específicos da depuração, como…

• Valgrind: para examinar a memória e detectar vazamentos e acessos inválidos.
• Linters e analisadores: para analisar como o código-fonte foi escrito e apontar erros de sintaxe, de estilo e violações de especificações e convenções da linguagem em uso sem, sequer, compilar (se for o caso) e executar o código.

Uma nota sobre depuração preventiva

Alguns ambientes integrados de desenvolvimento (IDE) e editores de código oferecem meios para sinalizar erros de sintaxe (a falta de um ; em C, por exemplo) ou destaques coloridos para diferentes tipos de elementos da linguagem. Muitos deles integram-se com protocolos de servidores de linguagem (LSP) para funcionarem como linters e analisadores de código em tempo real (ou seja, durante a digitação do código), o que antecipa e ajuda a evitar potenciais causas de erros.

Uma pequena demonstração

Considere o seguinte programa em C (demo.c):

#include <stdio.h>

int soma(int a, int b) {
    int resultado = a + b;
    return resultado;
}

int main() {
    int x = 10;
    int y = 20;
    int z = soma(x, y);
    printf("Resultado: %d\n", z);
    return 0;
}

Compilação com símbolos de depuração:

gcc -g -o demo demo.c

Sem os símbolos de depuração, nós teríamos que descobrir quais seriam os endereços de dados em variáveis e de outros elementos do código para inspecionar seus valores e comportamentos.

Iniciando o GDB para depuração

O GDB pode ser iniciado de várias formas para depurar programas. A mais comum, porém, é através da passagem do caminho de um binário executável como argumento na sua invocação na linha de comandos.

No nosso exemplo:

gdb ./demo

Sem a opção -q (quiet) ou sem configurações de início, o GDB exibe informações de versão e copyright antes das mensagens relativas à depuração, propriamente dita, e do prompt de seu shell de comandos…

:~$ gdb ./demo
GNU gdb (Debian 16.3-1) 16.3
Copyright (C) 2024 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Type "show copying" and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<https://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
    <http://www.gnu.org/software/gdb/documentation/>.

For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from ./demo...
(gdb)

Apesar da poluição visual, essa mensagem padrão pode ser útil para iniciantes, especialmente este trecho sobre ajuda:

For help, type "help".
Type "apropos word" to search for commands related to "word"...

Ou seja…

• Com o comando help (ou apenas h), nós teremos uma lista dos tópicos de ajuda (classes de comandos) e as instruções de uso do próprio comando help;
• Com o comando apropos PALAVRA, nós podemos buscar comandos que casem com PALAVRA, que é interpretada como uma expressão regular (REGEX).

Terminando o GDB

Para sair do GDB, nós podemos teclar Ctrl+D ou executar quit (ou apenas q) no prompt do shell de comandos:

(gdb) quit

Omitindo a mensagem de início

A forma mais simples de omitir a mensagem de início é utilizando a opção -q na invocação do GDB:

:~$ gdb ./demo
Reading symbols from ./demo...
(gdb)

Desta forma, a primeira mensagem relevante para a depuração é a única a ser exibida antes do prompt:

Reading symbols from ./demo...

Ela diz que o nosso binário foi compilado com símbolos para depuração e que esses símbolos foram lidos e registrados. Mas, vamos sair e compilar novamente o programa para ver o que aconteceria…

(gdb) q
:~$ gcc -o demo demo.c
:~$ gdb ./demo
Reading symbols from ./demo...
(No debugging symbols found in ./demo)
(gdb)

Desta vez, sem os símbolos de depuração, nós tivemos a mensagem:

Reading symbols from ./demo...
(No debugging symbols found in ./demo)

Uma nota sobre compilação com símbolos de depuração

Normalmente, os projetos são compilados para duas finalidades: desenvolvimento e publicação (release). É na compilação em desenvolvimento que os símbolos de depuração podem ser úteis. Embora isso não cause prejuízos de desempenho, binários compilados e publicados com símbolos de depuração resultam em arquivos maiores e, dependendo do caso, podem expor informações internas sensíveis.

Isso não costuma ser relevante no contexto do Software Livre, já que o acesso aos fontes deve ser garantido, mas existem casos de programas escritos para uso interno em alguma cadeia de produção que vão requerer mais cuidados.

É possível compilar o código com os símbolos de depuração e, depois, removê-los do binário que será distribuído(strip -g), ou ainda, gerar e armazenar cópias dos símbolos em arquivos separados (objcopy --only-keep-debug), mas isso foge do nosso escopo de interesses.

Sendo assim, vamos sair e compilar novamente o nosso programa com os símbolos de depuração.

(gdb) q
:~$ gcc -g -o demo demo.c
:~$ gdb ./demo
Reading symbols from ./demo...
(gdb)

Listando o código-fonte

No GDB, podemos listar o código-fonte com o comando list:

(gdb) list
3	int soma(int a, int b) {
4	    int resultado = a + b;
5	    return resultado;
6	}
7	
8	int main() {
9	    int x = 10;
10	    int y = 20;
11	    int z = soma(x, y);
12	    printf("Resultado: %d\n", z);

Por padrão, somente 10 linhas são exibidas, mas podemos teclar Enter algumas vezes até que todo o código seja listado.

(gdb)
13	    return 0;
14	}

Chagando ao final, podemos reiniciar a listagem com list .:

(gdb) list .
3	int soma(int a, int b) {
4	    int resultado = a + b;
5	    return resultado;
6	}
7	
8	int main() {
9	    int x = 10;
10	    int y = 20;
11	    int z = soma(x, y);
12	    printf("Resultado: %d\n", z);

Ponto de parada e execução

Nós podemos definir pontos de parada com o comando break:

(gdb) break main
Breakpoint 1 at 0x115b: file demo.c, line 9.

Assim, quando o programa for executado (com o comando run), a execução será pausada nos símbolos definidos como pontos de parada:

(gdb) run
Starting program: /home/blau/tmp/gdb/demo
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Breakpoint 1, main () at demo.c:9
9	    int x = 10;

Neste exemplo, o ponto de parada é a função main, e nós vemos a próxima linha a ser executada (linha 9). Para avançar para as próximas linhas, nós podemos executar o comando next:

(gdb) next
10	    int y = 20;

A linha 9 foi executada e a próxima será a linha 10. Se quisermos continuar executando o comando next, basta teclar Enter imediatamente em seguida:

(gdb)
11	    int z = soma(x, y);

Neste ponto, as variáveis x e y já foram carregadas e nós podemos conferir seus valores com o comando print:

(gdb) print x
$1 = 10
(gdb) print y
$2 = 20

O resultado de cada avaliação é armazenado no GDB em uma variável especial numerada ($n) de acordo com a ordem da avaliação.

A próxima linha a ser executada será a linha 11, onde temos a chamada da função soma. Se executarmos next novamente, a função será executada e nós iremos para a linha seguinte na função main. Mas nós também podemos entrar na função soma e acompanhar a sua execução passo a passo com o comando step:

(gdb) step
soma (a=10, b=20) at demo.c:4
4	    int resultado = a + b;

Aqui, nós podemos inspecionar os valores de a, b e do valor inicial de resultado, antes da linha 4 ser executada:

(gdb) print a
$3 = 10
(gdb) print b
$4 = 20
(gdb) print resultado
$5 = 0

Com o comando next, nós avançamos na função e já podemos exibir o novo valor de resultado:

(gdb) next
5	    return resultado;
(gdb) print resultado
$6 = 30

Se, a partir daqui, nós quisermos executar todo o restante do programa, basta executar comando continue:

(gdb) continue
Continuing.
Resultado: 30
[Inferior 1 (process 214693) exited normally]

Para sair do GDB…

(gdb) quit
:~$