# x86 (Intel & AMD)

## 🧠 Conceito Fundamental

**x86** é uma família de arquiteturas baseada no modelo **CISC**, originalmente criada pela **Intel (1978)** com o 8086, posteriormente expandida pela AMD e adotada como padrão dominante em computadores pessoais e servidores.

Hoje, o x86 moderno (x86-64 / AMD64) combina:

* **Set de instruções complexo (CISC)**
* **Execução interna baseada em μOps (RISC-like)**
* Alta performance com técnicas agressivas de pipeline e previsão de desvio

***

## 🧬 Evolução Histórica Resumida

| Ano   | Modelo                  | Largura | Observações                                   |
| ----- | ----------------------- | ------- | --------------------------------------------- |
| 1978  | 8086                    | 16-bit  | Origem da arquitetura                         |
| 1985  | 80386                   | 32-bit  | Introdução do modo protegido                  |
| 1999  | x86-64 (AMD64)          | 64-bit  | AMD lidera, Intel adota depois                |
| 2011+ | Intel Sandy/Ivy/Skylake | 64-bit  | Transformação para μOps + pipelines profundos |
| 2017+ | AMD Zen                 | 64-bit  | Arquitetura paralela, SMT eficiente           |

***

## 🧠 Modelo de Execução Interna (RISC-like)

Apesar de x86 ser **CISC**, **o processador não executa diretamente** essas instruções.

```mermaid
graph LR
    A[Instruções x86 CISC] --> B[Decodificador]
    B --> C[Micro-Operações (μOps)]
    C --> D[Execução (núcleo RISC)]
```

* Intel → Usa **µOp Cache** (guarda instruções já decodificadas)
* AMD → Usa **Macro-Op Fusion** e **µOp Queues**

***

## 🗂️ Formato das Instruções x86

* **Tamanho variável**: **1 a 15 bytes**
* Pode conter:

```
[PREFIXOS] [OPCODE] [MOD/RM] [SIB] [IMMEDIATE]
```

Exemplo em Assembly:

```asm
MOV EAX, [EBX + EDX*4 + 0x10]
```

x86 suporta **endereçamento extremamente complexo**, o que reduz tamanho do código, porém aumenta **complexidade do decodificador**.

***

## 🔧 Registradores (x86-64)

### Propósito Geral (64 bits)

```
RAX, RBX, RCX, RDX, RSI, RDI, RBP, RSP
R8 – R15 (adicionados no x86-64)
```

### Segmentação (herança)

```
CS, DS, ES, FS, GS, SS
```

### Flags (EFLAGS/RFLAGS)

* Zero (ZF)
* Carry (CF)
* Overflow (OF)
* Sign (SF)

### SIMD (para paralelismo)

* SSE / SSE2: XMM0–XMM31 (128 bits)
* AVX/AVX2: YMM0–YMM31 (256 bits)
* AVX-512: ZMM0–ZMM31 (512 bits)

***

## ⚙️ Caches e Execução (Exemplo: Intel Core)

```mermaid
graph TD
    A[L1 Instr] & B[L1 Data] --> C[L2]
    C --> D[L3 Shared]
    D --> E[Memory Controller]
```

Núcleo Interno:

```mermaid
graph LR
    A[Fetch] --> B[Decode] --> C[µOp Cache]
    C --> D[Scheduler / ROB]
    D --> E[ALU/AGU/FPU/Vector Units]
```

* **Out-of-Order Execution**
* **Speculative Execution**
* **Branch Prediction Avançado**

> Esses mecanismos foram responsáveis pelos ataques **Spectre / Meltdown**.

***

## 🥊 Intel vs AMD (Visão Microarquitetural)

| Aspecto              | Intel Core                      | AMD Zen                            |
| -------------------- | ------------------------------- | ---------------------------------- |
| μOp Cache            | Sim, altamente otimizada        | Parcial (depende da geração)       |
| Unidades de Execução | Geralmente mais agressivas      | Melhor balanceamento e paralelismo |
| Pipeline             | Mais profundo (clock mais alto) | Mais curto (eficiência por watt)   |
| SMT                  | Hyper-Threading                 | SMT eficiente + melhor latência    |
| L3 Cache             | Compartilhado                   | Dividido em "CCX / CCD" (chiplets) |

### Chiplets AMD (Zen 2+)

```mermaid
graph LR
    A[CCD] --> B[Core Complex 1]
    A --> C[Core Complex 2]
    A --> D[L3 Compartilhado]
    A --> E[IF Infinity Fabric]
```

Reduz custo e melhora escalabilidade.

***

## 🔥 Exemplo de Código Assembly x86

```asm
LOOP:
    MOV EAX, [RBX]
    ADD RDI, RAX
    ADD RBX, 4
    CMP RBX, RCX
    JNE LOOP
```

Decodificação interna (conceitual):

```
LOAD → ALU → ADD → AGU → BRANCH
```

***

## 📉 Vantagens e Desvantagens

| Vantagens                            | Desvantagens                                        |
| ------------------------------------ | --------------------------------------------------- |
| Altíssima performance absoluta       | Decodificação complexa                              |
| Compatibilidade ampla (40+ anos)     | Consumo de energia maior                            |
| Suporte avançado SIMD (AVX, AVX-512) | Complexidade leva a superfícies de ataque (Spectre) |
| Excelente desempenho em servidores   | Microarquitetura extremamente sofisticada           |

***

## 🧪 Ferramentas de Análise e Performance

**Monitorar performance:**

```bash
perf stat -e cycles,instructions,branches,branch-misses ./prog
```

**Desmontar binário:**

```bash
objdump -D ./programa
```

**Inspecionar CPU:**

```bash
lscpu
```


---

# Agent Instructions: 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:

```
GET https://0xmorte.gitbook.io/bibliadopentestbr/conceitos/arquitetura-de-hardware/arquiteturas-de-processadores/x86-intel-and-amd.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.