#nasm -g -f elf programa.asm
#ld programa.o
#gdb -q a.out

Vamos fazer um pequeno programa teste que carrega no registro ecx o valor da variável (var1) e em edx seu endereço:

section .data
 
   var1 dd 40
 
section .text
 
   global _start
 
   _start:
      nop
      nop
      mov   ecx, [var1]
      lea   edx, [var1]
 
   _exit:
      mov   eax, 1
      int   80h

Dentro do gdb:

(gdb) break 11
Breakpoint 1 at 0x80480a1: file teste.asm, line 11.
(gdb) r
Starting program: /home/maluta/coding/a.out
Breakpoint 1, _start () at teste.asm:11
11            nop
(gdb) print var1
$1 = 40
(gdb) info registers ecx edx
ecx            0x0      0
edx            0x0      0

Adicionamos um breakpoint (eu precisei inserir duas instruções nop para o gdb realmente para no ponto) e verificamos os valores de var1, ecx e edx.

(gdb) si
_start () at teste.asm:12
12            mov   ecx, [var1]
(gdb) si
_start () at teste.asm:13
13            lea   edx, [var1]
(gdb) info registers ecx
ecx            0x28     40
(gdb) si
_exit () at teste.asm:16
16            mov   eax, 1
(gdb) info registers edx
edx            0x80490b8        134516920

E por fim, verificamos o conteúdo no endereço definido em edx.

(gdb) print *0x80490b8
$2 = 40

Algumas considerações:

• O Data Diplay Debugger (DDD) é um front-end muito bom para o GDB que pode ser utilizado ao invés da interface de linha de comando.

• O após label _exit há uma chamada a uma syscall (adivinha qual?) do kernel. Passa-se o valor (no registro eax) e chama uma interrupção (80h).  A verdadeira “diversão” está em associar essas syscalls (write, fork, execve, …) mas isto é para outro post… Por enquanto vou lidar com os diferentes modos de endereçamento e operações lógicas e aritméticas.

1. Básico

Vamos começar com um código muito simples.

#include <stdio.h>
int main(int argc, char *argv[]) {
int *ptr = NULL;
int variavel_A;
int variavel_B;
variavel_A = 5;
variavel_B = 18;
return 0;
}

Usar o menor comando do GCC para compilar e linkar o programa. A saída (o executável) chamará a.out, se você quiser outro nome adicione “-o <nome>” no final do comando.

gcc -ggdb basico.c

E iniciar o depurador, lembre-se que o texto em (vermelho) é comentário e negrito é um comando para você digiar na CLI (command-line interface) do GDB.

2. Intermediário

Vamos dar mais um passo.

#include 
#include  /* malloc() */
#include  /* strncpy */
int main(int argc, char *argv[]) {
 
        char *nome;
 
        nome = malloc(10*sizeof(char));
        strncpy(nome,"tiago",5);
        return 0;
}

maluta@coding ~ $ gdb -q a.out
(gdb) l
1 #include <stdio.h>
2 #include <stdlib.h> /* malloc() */
3 #include <string.h> /* strncpy */
4 int main(int argc, char *argv[]) {
5
6
7 char *nome;
8
9 nome = malloc(10*sizeof(char));
10
(gdb) break 9
Breakpoint 1 at 0x8048421: file intermediario.c, line 9.
(gdb) r
Starting program: /home/maluta/a.out
Breakpoint 1, main () at basico.c:9
9 nome = malloc(10*sizeof(char));
(gdb) print nome
$1 = 0xb80b1190 "U\211åWVSèÀ\207" (LIXO)
(gdb) n (next - executa a próxima instrução)
11 strncpy(nome,"tiago",5);
(gdb) n
15 return 0;
(gdb) print nome (texto copiado)
$2 = 0x804b008 "tiago"
(gdb) x/5x nome (conteudo em hexa)
0x804b008: 0x74 0x69 0x61 0x67 0x6f
(gdb) x/5c nome (conteudo em ascii)
0x804b008: 116 't' 105 'i' 97 'a' 103 'g' 111 'o'
(Vamos mudar a primeira letra da string)
(gdb) set {char}nome='T'
(gdb) x/5x nome
0x804b008: 0x54 0x69 0x61 0x67 0x6f
(gdb) x/5c nome
0x804b008: 84 'T' 105 'i' 97 'a' 103 'g' 111 'o'
(Vamos colocar um espaço em branco na segunda posição)
(gdb) set {char}(nome+1)=' ' (lembre-se que o índice começa em zero)
(gdb) print nome
$11 = 0x804b008 "T ago"
(gdb) x/5x nome
0x804b008: 0x54 0x20 0x61 0x67 0x6f
(gdb) x/5c nome
0x804b008: 84 'T' 32 ' ' 97 'a' 103 'g' 111 'o'
(Você pode ver o conteúdo da variável com deslocamento 'offset')
(gdb) print nome+3
$17 = 0x804b00b "go"

Meu amigo Antônio (aka John) fez um exemplo do uso de classes em C, vamos utilizá-lo por aqui. Para mostrar o ponteiro para função, só vou adicionar uma função/método subtraiMinhaClasse no código.

#include 
 
struct MinhaClasse{
    int a;
    int b;
    int (*soma)();
};
 
int somaMinhaClasse(struct MinhaClasse *this){
    return (*this).a + (*this).b;
}
 
int subtraiMinhaClasse(struct MinhaClasse *this){
    return (*this).a - (*this).b;
}
 
void construtorMinhaClasse(struct MinhaClasse *this){
    this->soma = somaMinhaClasse;
}
 
int main(){
 
    int resposta;
    struct MinhaClasse objeto;
    construtorMinhaClasse(&objeto);
 
    objeto.a = 33;
    objeto.b = 15;
 
    resposta = objeto.soma();
 
    printf("%i",resposta);
 
return 0;
}