1. Load e Store — movendo dados
Em Assembler, você não opera diretamente na memória — você carrega em registrador, opera e armazena de volta. As instruções principais:
| Instrução | Ação | Exemplo |
|---|---|---|
L Rx,D(Rb) | Load fullword da memória para registrador | L R2,VALOR |
LH Rx,D(Rb) | Load halfword com extensão de sinal | LH R2,HALF |
LR Rx,Ry | Load registrador (copia Ry em Rx) | LR R4,R2 |
LA Rx,D(Rb) | Load Address — carrega o endereço (não o valor) | LA R3,BUFFER |
ST Rx,D(Rb) | Store fullword do registrador para memória | ST R2,RESULT |
STH Rx,D(Rb) | Store halfword | STH R2,HALF |
STC Rx,D(Rb) | Store Character (1 byte) | STC R2,BYTE |
💡 LA não acessa memória
LA R4,BUFFER carrega o endereço de BUFFER em R4 — não o conteúdo. É equivalente ao operador & do C. Já L R4,BUFFER carrega os 4 bytes que estão no endereço BUFFER. Confundir os dois é um dos erros mais comuns de iniciantes.
2. MVC e MVI — movendo caracteres
Para mover strings (campos de caracteres), o Assembler usa instruções SS (Storage-to-Storage):
| Instrução | Ação |
|---|---|
MVC D1(L,B1),D2(B2) | Move L bytes de B2+D2 para B1+D1 (L=1 a 256) |
MVI D1(B1),imm8 | Move um byte imediato para B1+D1 |
MVCL Rx,Ry | Move até 16MB — comprimento em par de registradores |
3. Aritmética inteira
Aritmética com fullwords (32-bit). As operações são sempre no registrador:
| Instrução | Ação |
|---|---|
A Rx,D(Rb) | Add — Rx ← Rx + memória |
AR Rx,Ry | Add Register — Rx ← Rx + Ry |
S Rx,D(Rb) | Subtract — Rx ← Rx - memória |
SR Rx,Ry | Subtract Register — Rx ← Rx - Ry |
M Rx,D(Rb) | Multiply — par Rx:Rx+1 ← Rx+1 * memória |
MR Rx,Ry | Multiply Register — par Rx:Rx+1 ← Rx+1 * Ry |
D Rx,D(Rb) | Divide — quociente em Rx+1, resto em Rx |
DR Rx,Ry | Divide Register — quociente em Rx+1, resto em Rx |
4. Comparação e Condition Code
Toda instrução de comparação seta o Condition Code (CC) — um campo de 2 bits no PSW (Program Status Word) com 4 valores possíveis:
| CC | Significado (comparação) | Significado (aritmética) |
|---|---|---|
0 | Igual | Resultado = 0 |
1 | Primeiro operando menor | Resultado < 0 |
2 | Primeiro operando maior | Resultado > 0 |
3 | (não usado) | Overflow |
| Instrução | Compara |
|---|---|
C Rx,D(Rb) | Registrador com fullword na memória (com sinal) |
CR Rx,Ry | Registrador com registrador (com sinal) |
CL Rx,D(Rb) | Registrador com fullword (sem sinal — logical) |
CLC D1(L,B1),D2(B2) | Bytes na memória com bytes na memória (até 256 bytes) |
CLI D1(B1),imm8 | Byte na memória com valor imediato |
5. Desvio condicional — B e BC
O desvio (branch) testa o Condition Code e salta para um label se a condição for verdadeira. A instrução base é BC mask,label:
| Mnemônico | Máscara | Desvia quando |
|---|---|---|
B | 15 | Sempre (desvio incondicional) |
BE | 8 | Equal (CC=0) |
BNE | 7 | Not Equal (CC≠0) |
BL | 4 | Low / Less than (CC=1) |
BH | 2 | High / Greater than (CC=2) |
BNH | 13 | Not High (CC=0 ou CC=1) |
BNL | 11 | Not Low (CC=0 ou CC=2) |
BZ | 8 | Zero (CC=0) — alias de BE |
BNZ | 7 | Not Zero (CC≠0) — alias de BNE |
BO | 1 | Overflow (CC=3) |
6. Exemplo completo — lógica IF/ELSE
Um trecho que implementa: "Se VALOR > 100, gravar ALTO; senão gravar BAIXO":
Note o uso de literais (=F'100', =CL4'ALTO') — o assembler aloca automaticamente o dado na seção de literais do programa, economizando uma declaração DC explícita.