# CISC

## 🧠 Conceito Fundamental

**CISC (Complex Instruction Set Computer)** é um modelo de arquitetura de processadores onde o conjunto de instruções possui **muitas instruções complexas**, capazes de executar tarefas de alto nível em **poucos comandos**, mesmo que isso torne o hardware e o pipeline mais sofisticados internamente.

### Objetivo do CISC

* **Minimizar código na memória**
* **Executar tarefas complexas por instrução**
* Facilitar compiladores antigos e linguagens de alto nível

Exemplo clássico: **x86 / x86-64 (Intel / AMD)**

## 🧩 Características-Chave

| Característica             | Descrição                                                                     |
| -------------------------- | ----------------------------------------------------------------------------- |
| **Set de Instruções**      | Extenso (centenas a milhares de instruções)                                   |
| **Formato das Instruções** | Variável (1 a 15 bytes no x86)                                                |
| **Endereçamento**          | Suporte a modos complexos (ex: `[EBX + EAX*4 + 0x10]`)                        |
| **Execução Interna**       | Muitas instruções são traduzidas internamente para **micro-operações (μOps)** |
| **Pipeline**               | Normalmente mais profundo e dinâmico                                          |
| **Desempenho**             | Otimizado para **tarefas complexas usando menos código**                      |

## 🔧 Microarquitetura Moderna (Exemplo: x86-64)

```mermaid
graph LR
    A[Instrução CISC x86] --> B[Decodificador Complexo]
    B --> C[Micro-Operações (μOps)]
    C --> D[Pipeline RISC Interno]
    D --> E[Execução e Reordenação]
    E --> F[Unidade de Retorno / Commit]
```

> **Resumo:** Processadores CISC modernos **não executam diretamente** instruções complexas — eles **recompilam internamente** para um núcleo **RISC-like**.

## 🗂️ Modos de Endereçamento Avançados

Exemplo de **endereço composto** (x86):

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

Significa:

```
EAX = MEMÓRIA[ (EBX) + (EDX * 4) + 32 bytes ]
```

Isso reduz o número de instruções necessárias → menor footprint de código.

## 📦 Conjunto de Instruções

As instruções x86 são organizadas em **famílias**:

| Categoria           | Exemplo                      | Função                  |
| ------------------- | ---------------------------- | ----------------------- |
| Aritmética          | `ADD`, `SUB`, `MUL`          | Operações matemáticas   |
| Memória             | `MOV`, `PUSH`, `POP`         | Transferência de dados  |
| Controle            | `JMP`, `CALL`, `RET`, `LOOP` | Controle de fluxo       |
| Vetorial/Multimídia | `SSE`, `AVX`, `MMX`          | Paralelismo em dados    |
| Sistema             | `INT`, `HLT`, `IN`, `OUT`    | Controle de hardware/OS |

## ⚡ Pipeline e Execução

### Arquitetura Simplificada (Intel Core)

```mermaid
graph TB
    A[Fetch] --> B[Decode]
    B --> C[µOp Cache]
    C --> D[Scheduler / Reorder Buffer]
    D --> E[ALUs / AGUs / FPUs]
    E --> F[Write Back]
```

**Recursos Importantes:**

* **Out-of-Order Execution**
* **Branch Prediction** avançado
* **Reorder Buffer (ROB)** para consistência arquitetural

## 🔥 Exemplo de Decodificação Interna

Código Assembly:

```asm
LOOP:   ADD EAX, [RBX]
        INC RBX
        CMP RBX, RCX
        JNE LOOP
```

Tradução interna (conceitual):

```
μOp1: LOAD temp1 ← MEM[RBX]
μOp2: EAX ← EAX + temp1
μOp3: RBX ← RBX + 1
μOp4: FLAGS ← COMPARE RBX, RCX
μOp5: BRANCH_IF_NOT_EQUAL LOOP
```

## 📉 Vantagens e Desvantagens

| Vantagens                      | Desvantagens                              |
| ------------------------------ | ----------------------------------------- |
| Alto nível por instrução       | Decodificação complexa e lenta            |
| Código binário compacto        | Maior consumo energético em decodificação |
| Flexibilidade de endereçamento | Pipeline interno mais sofisticado         |
| Compatibilidade histórica      | Complexidade aumenta o custo do design    |

## 🥊 Comparação CISC vs RISC

| Aspecto              | CISC                 | RISC                           |
| -------------------- | -------------------- | ------------------------------ |
| Filosofia            | Instruções complexas | Instruções simples e uniformes |
| Tamanho da Instrução | Variável             | Fixo (ex: 32 bits)             |
| Decodificação        | Complexa             | Simples                        |
| Pipeline             | Profundo, dinâmico   | Estável, previsível            |
| Exemplos             | x86, Itanium         | ARM, MIPS, RISC-V              |

## 🔍 Ferramentas para Análise

**Desmontar executáveis:**

```bash
objdump -D arquivo.bin
```

**Monitorar micro-operações (Intel):**

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

**Depuração baixo nível:**

```bash
gdb ./programa
```


---

# 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/cisc.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.