# ARM

## 🧠 Conceito Fundamental

**ARM** é uma arquitetura baseada no paradigma **RISC (Reduced Instruction Set Computer)**, projetada para:

* **Alta eficiência energética**
* **Pipeline simples e previsível**
* **Instruções de tamanho fixo e decodificação rápida**

Hoje é amplamente utilizada em:

* Smartphones
* Tablets
* IoT
* Automotivo
* **Apple Silicon (M1 / M2 / M3)**

## 🧩 Características-Chave

| Característica             | ARM                                                   | Diferencial                    |
| -------------------------- | ----------------------------------------------------- | ------------------------------ |
| **Set de Instruções**      | Pequeno e consistente                                 | Decodificação simples          |
| **Formato das Instruções** | Tamanho fixo (32 bits ARM / 16 bits Thumb)            | Menos lógica de decodificação  |
| **Registradores**          | Muitos registradores de uso geral (ex: 31 em AArch64) | Reduz acessos à memória        |
| **Pipeline**               | Linear e previsível                                   | Alta eficiência por ciclo      |
| **Desempenho vs Watt**     | Muito alto                                            | Ideal para dispositivos móveis |

## 🏛️ Modelo Geral de Pipeline ARM

```mermaid
graph LR
    A[Fetch] --> B[Decode]
    B --> C[Execute]
    C --> D[Memory]
    D --> E[Write Back]
```

Pipelines modernos (ARM Cortex-A) adicionam:

* **Out-of-Order Execution**
* **Branch Prediction**
* **Execução superscalar**

## 🔤 Conjuntos de Instruções ARM

| Conjunto             | Descrição                           | Uso                        |
| -------------------- | ----------------------------------- | -------------------------- |
| **ARM32**            | 32-bit original                     | Sistemas embarcados        |
| **Thumb**            | Instruções 16-bit compactas         | Código mais leve           |
| **Thumb-2**          | Mistura de 16/32-bit                | Padrão moderno             |
| **AArch64 (ARMv8+)** | 64-bit com registradores expandidos | Servidores e Apple Silicon |

## 🎯 Modelo de Registradores (AArch64 - 64 bits)

```plaintext
31 Registradores de Propósito Geral:
X0 - X30 (cada um com 64 bits)
```

Além disso:

* **SP**: Stack Pointer
* **PC**: Program Counter
* **FLAGS**: NZCV (Negative, Zero, Carry, Overflow)
* Registradores vetoriais **NEON** (128 bits para SIMD)

## 🧱 Modos de Endereçamento

Formato simples e direto:

```asm
LDR X0, [X1, #8]
```

Significa:

```plaintext
X0 = MEMÓRIA[X1 + 8]
```

Sem modos de endereçamento complexos como no x86.

## ⚡ Operações Vetoriais (NEON / SVE)

ARM é forte em **processamento paralelo (SIMD)**.

**Exemplo NEON (vetor de 128 bits):**

```asm
ADD V0.4S, V1.4S, V2.4S   ; Soma 4 inteiros simultaneamente
```

**SVE (Scalable Vector Extension)** → utilizado em servidores e HPC

## 🏗️ Microarquitetura Moderna (Ex.: ARM Cortex-A)

```mermaid
graph TB
    A[Fetch & Branch Predictor] --> B[Decoder RISC]
    B --> C[Scheduler / Issue Queue]
    C --> D[ALUs / FPUs / Load-Store Units]
    D --> E[Reorder Buffer / Commit]
```

## 🔥 Exemplo de Código ARM

```asm
loop:
    LDR W2, [X1]      ; carrega memória
    ADD W0, W0, W2    ; soma acumulador
    ADD X1, X1, #4    ; avança ponteiro
    CMP X1, X3        ; compara limite
    B.NE loop         ; branch se não igual
```

## 📉 Vantagens e Desvantagens

| Vantagens                         | Desvantagens                                                   |
| --------------------------------- | -------------------------------------------------------------- |
| Consumo energético muito baixo    | Pode precisar de mais instruções para a mesma tarefa (vs CISC) |
| Decodificação extremamente rápida | Depende fortemente de compiladores eficientes                  |
| Pipeline simples e eficiente      | Implementações high-end podem ser complexas                    |
| Altíssimo desempenho por watt     | Ecossistema fragmentado (embarcados diversos)                  |

## 🥊 Comparação Resumida ARM vs x86 (CISC)

| Aspecto              | ARM (RISC)                 | x86 (CISC)            |
| -------------------- | -------------------------- | --------------------- |
| Tamanho da Instrução | Fixo (16/32b)              | Variável (1–15 bytes) |
| Decodificação        | Simples                    | Complexa (μOps)       |
| Consumo              | Baixo                      | Médio/Alto            |
| Desempenho por Clock | Alto                       | Moderado              |
| Melhores Exemplos    | Apple M1/M2/M3, Snapdragon | Intel Core, AMD Ryzen |

## 🔧 Ferramentas de Análise

**Desmontar executável ARM:**

```bash
objdump -D --architecture=arm programa.bin
```

**Simular ARM:**

```bash
qemu-arm ./binario
```

**Debug ARM:**

```bash
gdb-multiarch ./firmware.elf
```


---

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