# Disassembly

Ao observar a região que chamamos de *disassembly*, você verá cinco colunas. A primeira exibe algumas informações e relações entre endereços. A segunda mostra os endereços em si. A terceira mostra os *bytes* do *opcode* e dos operandos das instruções. A quarta mostra os mnemônicos onde podemos ler Assembly e, por fim, a quinta mostra comentários, sejam estes gerados automaticamente pelo *debugger* ou adicionados por você.

![Colunas do disassembly](https://2831222458-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-L8zFFHkPxQb-_1XSGR9%2Fuploads%2Fgit-blob-ca14355f0ddb5a5949a91ca3ded8e5b2f24ca722%2Fx64dbg_analyseme00_disassembly.png?alt=media)

## Realce de Instruções

Perceba que por padrão o *debugger* já realça (*highlight* em inglês) vários aspectos das instruções na janela de *disassembly*. As instruções CALL estão com fundo azul e os destinos das chamadas com fundo amarelo quando o endereço é conhecido. Os saltos também são realçados com fundo amarelo. Dessa forma é possível identificar rapidamente as instruções que alteram o fluxo do execução do programa.

O endereço para o qual o ponteiro de instrução (RIP) aponta é destacado com um fundo preto.

Na coluna de comentários, temos os comentários automáticos em marrom.

É importante lembrar que o conteúdo do arquivo sendo depurado é composto somente pelos *bytes* referentes às instruções (terceira coluna) e dados. Toda essa análise adicional é feita pelo *debugger* para que a nossa experiência seja mais agradável ao depurar o programa.

## Executando Uma Instrução

Neste primeiro momento, o *debugger* está parado e a próxima instrução a ser executada é justamente o que chamamos de EP *(EntryPoint)*.

O primeiro comando que aprenderemos é o **Step over**, que pode ser ativado de pelo menos quatro maneiras:

1. Menu **Debug ► Step over**.
2. Botão **Step over** na barra de botões (por padrão, é o sétimo botão).
3. Tecla de atalho F8.
4. Digitando um dos comandos a seguir na barra de comandos: `StepOver`, `step`, `sto`, ou `st`.

Se você emitir este comando uma vez, verá que o *debugger* vai executar uma única instrução e parar. Na janela do *disassembly*, você vai perceber que o cursor (RIP) "pulou uma linha" e a instrução anterior foi executada. No caso de nosso binário de teste, é a instrução SUB RSP, 98. Após sua execução, perceba que o valor de RSP foi atualizado. Os valores que mudaram são destacados em vermelho pelo x64dbg.

Você pode seguir teclando F8 até alcançar a primeira instrução CALL, destacada por um fundo azul claro.

O comando **Step over** sobre uma CALL faz com que o *debugger* execute a rotina apontada pela instrução e "volte" para o endereço imediatamente após a CALL. Você não verá essa execução, pois o *debugger* não a instrumentará, mas ela acontece. Caso queira observar o que foi executado "dentro" da CALL, é necessário utilizar o **Step into** (F7). Vamos fazer dois testes:

1. Com o RIP apontado para a CALL em 140001019, tecle F8. Você verá que a execução simplesmente "passa para a linha abaixo da CALL". Isso quer dizer que ela **foi executada**, mas você não "viu" essa execução no *debugger*.
2. Agora reinicie o programa no *debugger* clicando em **Debug ► Restart**. Depois, vá teclando F8 até chegar sobre a CALL novamente e tecle F7, que é o **Step into**. Perceba que o *debugger* agora "entrou" na CALL. Não se preocupe em analisar essa função. Ela pertence à API do Windows e seu funcionamento é conhecido. A ideia aqui é você diferenciar o *Step over* do *Step into*. Pode reiniciar o programa novamente.

## Rodando o Programa

Outro comando importante é o **Run** (F9). Ele simplesmente inicia a execução a partir do RIP de todas as instruções subsequentes e só para se encontrar um *breakpoint* (nosso próximo assunto), uma exceção ou se o programa for encerrado. Se você der este comando, verá a execução terminada em menos de um segundo, o que significa que o programa rodou até o final e saiu. Aí basta reiniciar o programa (Ctrl + F2) para recomeçar nossos estudos. ;)

Na próxima seção, vamos entender os pontos de paradas, mais conhecidos como *breakpoints*.