Artigo :: Começando com GDB

Date: 2018-12-16

Last Modified: 2026-02-01

Reading Time: 9 mins

Categories: articles

Introdução

Este guia completo cobre tudo o que você precisa para começar a depurar programas C com GDB, desde compilar com símbolos de depuração até inspecionar memória e controlar a execução do programa.

Visão Geral

GDB (GNU Debugger) é o depurador padrão para programas compilados com GCC. Ao contrário de ferramentas como strace que mostram chamadas de sistema, o GDB permite percorrer seu código-fonte linha por linha, inspecionar variáveis, definir breakpoints condicionais e até modificar o comportamento do programa durante a execução.

Seja rastreando um segfault, entendendo como o código executa, ou fazendo engenharia reversa de um binário, o GDB é uma ferramenta indispensável para qualquer desenvolvedor C/C++ ou pesquisador de segurança.

Pré-requisitos

Antes de começar, você deve:

Ter o GCC instalado e entender compilação básica
Conhecer fundamentos de programação C (variáveis, funções, ponteiros)
Estar confortável com a linha de comando do Linux
Opcionalmente, ler nosso Cheat Sheet de Compilação GCC para o básico de compilação

Melhore Sua Experiência com GDB

Após aprender o básico aqui, instale GEF (GDB Enhanced Features) para obter syntax highlighting, exibição automática de contexto e uma interface de depuração muito melhor.

Compilando com Símbolos de Depuração

Para depurar efetivamente com GDB, você precisa de símbolos de depuração no seu binário. Esses símbolos mapeiam código de máquina de volta para seu código-fonte (funções, variáveis, números de linha).

1
gcc -ggdb source.c -o prog_with_symbols

A flag -ggdb produz informações de depuração específicas para GDB com mais detalhes que a flag padrão -g.

Builds de Debug vs Release

Sempre compile builds de debug e release separados:

Build de debug: gcc -ggdb -O0 (sem otimização, símbolos completos)
Build de release: gcc -O2 (otimizado, remover símbolos antes da distribuição)

Otimizações podem tornar a depuração confusa pois o compilador reordena e elimina código.

Gerenciando Símbolos de Depuração

Removendo Símbolos de Binários

Para deploys em produção, remova símbolos de depuração para reduzir o tamanho do binário:

Usando strip (remove todos os símbolos):

1
strip --strip-debug --strip-unneeded prog_not_stripped -o prog_stripped

Usando objcopy (cria arquivo de debug separado):

1
objcopy --only-keep-debug binary_file debug_file

Esta abordagem mantém os símbolos em um arquivo separado, permitindo depurar problemas de produção sem distribuir binários grandes.

Adicionando Símbolos de Volta

Opção 1: Vincular arquivo de debug ao binário

1
objcopy --add-gnu-debuglink=debug_file binary_file

O GDB automaticamente encontrará e carregará debug_file ao depurar binary_file.

Opção 2: Carregar arquivo de símbolos manualmente no GDB

1
(gdb) symbol-file debug_file

Melhor Prática para Produção

Mantenha símbolos de depuração em um arquivo separado e armazene-os com segurança. Ao depurar crashes de produção, você pode carregar o arquivo de debug correspondente sem recompilar.

Analisando Símbolos com nm

O comando nm lista símbolos em arquivos objeto e binários, útil para entender quais funções e variáveis existem em um programa.

Convenções de capitalização de símbolos:

Minúsculas = símbolos locais (escopo de arquivo)
Maiúsculas = símbolos externos (escopo global)

Tipos Comuns de Símbolos

Símbolo	Significado
T	Na Seção de Texto (código)
D	Na Seção de Dados Inicializados
B	Na Seção de Dados Não-Inicializados (BSS)
U	Indefinido (referência externa)
A	Símbolo absoluto
N	Símbolo de depuração

Mais Tipos de Símbolos

Execute man nm para ver todos os tipos de símbolos. Estes são os mais comuns que você encontrará.

Comandos Úteis do nm

Procurar por um símbolo específico:

1
nm -A Binary_File | grep function_name

Exibir símbolos ordenados por endereço:

1
nm -n Binary_File

Mostrar apenas símbolos externos (globais):

1
nm -g Binary_File

Mostrar todos os símbolos incluindo símbolos de depuração:

1
nm -a Binary_File

Listar apenas símbolos na seção TEXT (código executável):

1
nm -a Binary_File | grep ' T '  # Espaços ao redor do T são importantes

Desmontando com objdump

O comando objdump desmonta binários, mostrando o código assembly real:

1
objdump -M intel -D a.out | grep -A20 main.:

Isso mostra 20 linhas de assembly começando da função main usando sintaxe Intel.

Opções do objdump Explicadas

-M intel: Usa sintaxe Intel (mais legível que AT&T padrão)
-D: Desmonta todas as seções (não apenas código)
-d: Desmonta apenas seções de código
-S: Intercala código-fonte com assembly (requer símbolos de debug)

Referência de Comandos do GDB

Iniciando o GDB

1
2
gdb ./program           # Carregar programa
gdb --args ./program arg1 arg2   # Carregar com argumentos

Alternando Sintaxe (AT&T vs Intel)

Por padrão, o GDB usa sintaxe assembly AT&T. A sintaxe Intel é frequentemente mais legível:

1
(gdb) set disassembly-flavor intel

Adicione isso ao ~/.gdbinit para tornar permanente.

Desmontando Código

1
2
3
4
(gdb) disassemble main              # Desmontar função main
(gdb) disassemble /r main           # Mostrar opcodes também
(gdb) disassemble _start            # Desmontar _start
(gdb) disassemble 0x80484b0         # Desmontar endereço específico

Desmontar um intervalo:

1
(gdb) disassemble main,+30          # 30 bytes a partir de main

Dois argumentos (separados por vírgula) especificam um intervalo: início,fim ou início,+tamanho.

Executando o Programa

1
2
3
(gdb) run                    # Executar sem argumentos
(gdb) run arg1 arg2          # Executar com argumentos
(gdb) start                  # Executar e parar no main (aprimoramento do GEF)

Listando Código-Fonte

Requer arquivo-fonte disponível no mesmo diretório:

1
2
3
(gdb) list                   # Mostrar linhas próximas à posição atual
(gdb) list 1                 # Listar da linha 1
(gdb) list main              # Listar a função main

Localização do Arquivo-Fonte

O GDB precisa do arquivo-fonte no mesmo caminho onde foi compilado. Se você compilou em /home/user/projeto mas executa o GDB de /tmp, use:

1
(gdb) directory /home/user/projeto

Inspecionando Estado do Programa

Informações de registradores:

1
2
(gdb) info registers         # Mostrar todos os registradores
(gdb) info registers eax     # Mostrar registrador específico

Listagem de funções:

1
(gdb) info functions         # Listar todas as funções

Arquivos-fonte:

1
2
(gdb) info sources           # Listar todos os arquivos-fonte
(gdb) info source            # Mostrar arquivo-fonte atual

Informações de variáveis:

1
2
(gdb) info variables         # Listar variáveis globais/estáticas
(gdb) info scope Function_Name   # Listar variáveis locais na função

Dump da tabela de símbolos:

1
2
(gdb) maintenance print symbols              # Imprimir no console
(gdb) maintenance print symbols output.txt   # Imprimir em arquivo

Trabalhando com Breakpoints

Definir breakpoints:

1
2
3
(gdb) break main             # Break na função
(gdb) break 42               # Break na linha 42
(gdb) break *0x080484b0      # Break no endereço

Listar breakpoints:

1
(gdb) info breakpoints       # Mostrar todos os breakpoints

Habilitar/desabilitar breakpoints:

1
2
(gdb) disable 1              # Desabilitar breakpoint #1
(gdb) enable 1               # Habilitar breakpoint #1

Deletar breakpoints:

1
2
(gdb) delete 1               # Deletar breakpoint #1
(gdb) delete                 # Deletar todos os breakpoints

Breakpoints Condicionais

Break apenas quando uma condição for verdadeira:

1
2
(gdb) break *0x0804844b
(gdb) condition 1 $eax == 0   # Só para se eax for 0

Isso é incrivelmente poderoso para depurar loops ou condições de erro específicas.

Modificando Memória e Registradores

O GDB permite modificar o estado do programa durante a execução:

1
2
3
4
(gdb) set {char} 0xbffff7e6 = 'B'              # Escrever byte na memória
(gdb) set {int} (0xbffff7e6 + 1) = 66          # Escrever int na memória
(gdb) set var1 = 100                            # Modificar variável
(gdb) set $eax = 10                             # Modificar registrador

Opcodes também podem ser modificados:

1
(gdb) set {char} 0x080484b0 = 0xb8              # Escrever opcode

Apenas Patches Temporários

Mudanças feitas no GDB afetam apenas a sessão de depuração atual. Para fazer patches permanentes no binário, use ferramentas como objcopy ou editores hexadecimais.

Definindo Macros

Crie comandos personalizados que executam automaticamente:

1
2
3
4
5
(gdb) define hook-stop
    info registers
    x/8xw $esp
    disassemble $eip,+10
end

Isso executa após cada passo, mostrando registradores, pilha e próximas instruções. Salve em ~/.gdbinit para usar em todas as sessões.

Trabalhando com Dados

Imprimir valores de registradores em diferentes formatos:

1
2
3
(gdb) print /d $eax          # Decimal
(gdb) print /t $eax          # Binário
(gdb) print /x $eax          # Hexadecimal

Exemplo de saída:

(gdb) print /d $eax
$17 = 13
(gdb) print /t $eax
$18 = 1101
(gdb) print /x $eax
$19 = 0xd

Examinar memória (x/nyz):

Formato: x/[quantidade][formato][tamanho] endereço

quantidade (n): Número de itens a exibir
formato (y): c (char), d (decimal), x (hex), s (string)
tamanho (z): b (byte), h (halfword/2 bytes), w (word/4 bytes), g (giant/8 bytes)

Exemplos:

1
2
3
(gdb) x/8xw $esp             # Mostrar 8 words em hex do stack pointer
(gdb) x/s 0x08048000         # Mostrar string no endereço
(gdb) x/20i $eip             # Mostrar 20 instruções no instruction pointer

Variáveis de Conveniência

Crie variáveis temporárias para depuração:

1
2
3
4
(gdb) set $i = 10
(gdb) set $dyn = (char *)malloc(10)
(gdb) set $demo = "psylinux"
(gdb) set argv[1] = $demo                      # Modificar argumentos do programa

Essas variáveis existem apenas na sessão do GDB.

Chamando Funções

Você pode chamar funções no programa sendo depurado:

1
2
3
4
(gdb) info functions                            # Listar funções disponíveis
(gdb) call Function_1(args_list)               # Chamar função personalizada
(gdb) call strlen("psylinux")                  # Chamar biblioteca padrão
(gdb) call strcpy($dyn, argv[1])              # Usar variáveis de conveniência

Útil para Testes

Chamar funções é ótimo para testar casos extremos sem recompilar. Por exemplo, chame malloc() para alocar memória, modifique-a e veja como seu programa lida com isso.

Pontos-Chave

Resumo Rápido

Compile com -ggdb para incluir símbolos de depuração para debugging em nível de código
Use arquivos de debug separados para binários de produção para economizar espaço
nm e objdump ajudam a analisar binários antes da depuração
GDB permite controlar a execução com breakpoints, stepping e breaks condicionais
Inspecione e modifique memória, registradores e variáveis durante runtime
Breakpoints condicionais são poderosos para depurar cenários específicos
Plugin GEF melhora dramaticamente a experiência do GDB com contexto visual

Exercícios Práticos

Experimente Você Mesmo

Escreva um programa C simples com um bug, compile com -ggdb, e use GDB para encontrar o problema
Defina um breakpoint em main(), execute o programa e percorra linha por linha usando next e step
Use x/20xw $esp para examinar a pilha e entender como variáveis locais são armazenadas
Crie um breakpoint condicional que só dispara quando um contador de loop atinge 100
Use call para invocar uma função com diferentes argumentos sem recompilar
Pratique desmontar funções com disassemble e correlacionar assembly com código-fonte

Leitura Adicional

Cheat Sheet de Compilação GCC - Aprenda opções de compilação e gerenciamento de símbolos de debug
Instalando GEF - Turbine seu GDB com uma interface moderna
Depurando com strace - Rastreamento de chamadas de sistema quando o código-fonte não está disponível
Syscalls do Linux em Assembly - Entendendo execução de programas em baixo nível
Manual do GDB - Documentação oficial completa