> For the complete documentation index, see [llms.txt](https://gitbook.ganeshicmc.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://gitbook.ganeshicmc.com/engenharia-reversa/registradores-e-tipos-de-dados.md).

# Registradores e tipos de dados

## Registradores e Tipos de Dados

Aqui estaremos estudando os registradores da arquitetura x86 e x86-64, seguindo principalmente o padrão da Intel.

Para guardar variáveis de forma no geral e passá-los de uma parte da memória para outra, a nossa principal ferramenta são os registradores.

### Registradores

Na arquitetura x86 temos 8 registradores de propósitos gerais (ou GPR) de 32-bits, alguns deles também podem ser divididos em registradores de 8 e 16 bits.

#### Registradores de propósito geral

Como o próprio nome diz, esses registradores são de propósito geral, ou seja, podem ser usados para "qualquer coisa", mas usualmente seguem algumas convenções

| Registrador |                                Convenção                               | 16 - Bits | 8 Bits |
| ----------- | :--------------------------------------------------------------------: | :-------: | :----: |
| EAX         | Acumulador, usado para operações aritméticas e para guardar resultados |     AX    |  AH-AL |
| EBX         |    Registrador secundário, usado como "base" em operações de vetores   |     -     |    -   |
| ECX         |                            Contador em loops                           |     -     |    -   |
| EDX         |                  Usado para guardar endereços de dados                 |     -     |    -   |

#### Registradores de Endereços

| Registrador | Propósito                                         | 16 - Bits |
| ----------- | ------------------------------------------------- | :-------: |
| ESI         | Fonte em operações de memória/strings             |     SI    |
| EDI         | Destino em operações de memória/strings           |     DI    |
| EBP         | Registrador base para a stack/pilha (frame atual) |     BP    |
| ESP         | Pointeiro da stack/pilha                          |     SP    |

#### Outros registradores

| Registrador | Propósito                                                                               | 16 - Bits |
| ----------- | --------------------------------------------------------------------------------------- | :-------: |
| EIP         | Instruction Pointer (Program counter) - Indica em qual instrução a execução se encontra |     -     |
| EFLAGS      | Guarda resultado de operações - Ex: Flag Zero                                           |     -     |

### Set de Instruções

O conjunto de instruções x86 envolve o movimento de dados entre registradores e memória, classificados em 5 tipos:

* Imediato para registrador
* Registrador para registrador
* Imediato para memória
* Registrador para memória e vice-versa
* Memória para memória - Somente nas arquiteturas RISC.

#### x86

O foco aqui será a sintaxe da Intel.

**Intel vs AT\&T**

A AT\&T prefixa os registradores com `%` e imediatos com `$`, o que não acontece na Intel. Eles também adicionam um prefixo à instrução para indicar o tamanho do dado da operação  (long, byte, etc. ). Na sintaxe da Intel, o destino vem e, em seguida, a fonte  (op dest source ), na AT\&T é o contrário. (Pense em dest=fonte) As instruções têm comprimento variável  (1 a 15 bytes ).

x86 usa colchetes ( \[] ) para indicar acesso à memória  (semelhante ao asterisco ( \* ) em C / C ++ ) Para somar ou subtrair o endereço dentro de \[] geralmente é usado hexadecimal, por exemplo: mov eax \[ecx + 10h] - Onde h é usado para indicar notação hexadecimal.

**Instruções**

* MOV - mov ecx, \[eax]
  * Seta ecx = \[eax]  
* ADD - inc dword ptr \[eax]
  * Incrementa o valor no endereço eax.  
* SUB - sub eax, 0x20
  * Subtrai eax por 0x20 (32 em decimal).
* PUSH - push eax
  * Coloca eax na stack.
* POP - pop eax
  * Tira o endereço do topo da stack e salva em eax.
* CMP - cmp eax, ebx
  * if (eax == ebx) seta eflags;
* JNE - jne 0x400086
  * Pula para o endereço dado se eflags foi setado como igual.
* CALL - call 0x400086
  * Pula para o endereço dado e salva a localização atual na stack. Equivalente às instruções:
    * push rip
    * jump 0x400086
* RET - ret
  * Tira o endereço da stack e retorna o controle para aquela localização.
    * pop rip
* LEA - lea eax, \[esp+0x1c]
  * Move o endereço do registrador para outro. Usado para passar parâmetros para funções.
* LEAVE - leave
  * Move ebp para esp e tira ebp da stack.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://gitbook.ganeshicmc.com/engenharia-reversa/registradores-e-tipos-de-dados.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.