developer-assembly-instructions

name	developer-assembly-instructions
description	Referência do conjunto de instruções x86/x64 — utilizável com assembler Delphi, NASM, GAS e similares.
model	sonnet
license	MIT
copyright	Copyright (c) 2026 CSL Tech Solutions
company	CSL Tech Solutions
author	Claiton de Souza Linhares

developer-assembly-instructions_V1.0.0

Versão: 1.0.0 Data: 2026-04-11 Locale: pt-BR Categoria: developer · delphi · assembly

Propósito

Referência do conjunto de instruções x86/x64 para uso com o built-in assembler Delphi e NASM. Cobre transferência de dados, aritmética inteira, lógica e deslocamentos, comparação/saltos, operações de string com prefixo REP, instruções especiais e diferenças de sintaxe entre o assembler Delphi e NASM.

---

Transferência de dados

MOV e variantes

; MOV — move dado entre registrador/memória/imediato
mov eax, 42          ; EAX = 42 (imediato)
mov eax, ebx         ; EAX = EBX (registrador)
mov eax, [ptr]       ; EAX = mem[ptr] (carga de memória)
mov [ptr], eax       ; mem[ptr] = EAX (armazenamento)
mov eax, [ebx+4]     ; EAX = mem[EBX+4] (endereçamento baseado)
mov eax, [ebx+ecx*4] ; EAX = mem[EBX + ECX*4] (indexado com escala)

; MOVZX — move com zero-extension (sem sinal)
movzx eax, byte [ptr]    ; EAX = byte lido, zero-extended para 32-bit
movzx eax, word [ptr]    ; EAX = word lido, zero-extended para 32-bit
movzx rax, byte [ptr]    ; RAX = byte lido, zero-extended para 64-bit

; MOVSX — move com sign-extension (com sinal)
movsx eax, byte [ptr]    ; EAX = byte lido, sign-extended
movsx rax, dword [ptr]   ; RAX = dword lido, sign-extended (= MOVSXD)

; XCHG — troca valores
xchg eax, ebx        ; swap(EAX, EBX) — atomico com prefixo LOCK implícito em memória
xchg [var], eax      ; swap(mem[var], EAX) — sempre atômico

; LEA — Load Effective Address: calcula endereço SEM acessar memória
lea eax, [ebx+ecx*4+8]   ; EAX = EBX + ECX*4 + 8 (usa ULA, não memória!)
lea rax, [rip+offset]     ; RIP-relative: endereço relativo ao PC (x64)

; LEA como calculadora (truque comum):
lea eax, [eax+eax*2]     ; EAX = EAX * 3 (sem MUL!)
lea eax, [eax*4]         ; EAX = EAX * 4

---

Aritméticas inteiras

ADD, SUB, ADC, SBB

add eax, ebx         ; EAX = EAX + EBX  (afeta CF, ZF, SF, OF)
add eax, 100         ; EAX = EAX + 100
add [var], eax       ; mem[var] = mem[var] + EAX
sub eax, ebx         ; EAX = EAX - EBX
sub eax, 1           ; EAX = EAX - 1

; ADC/SBB: add/sub com carry (para aritmética de precisão múltipla)
adc eax, ebx         ; EAX = EAX + EBX + CF
sbb eax, ebx         ; EAX = EAX - EBX - CF

INC, DEC, NEG

inc eax              ; EAX++ — NÃO afeta CF!
dec ecx              ; ECX-- — NÃO afeta CF!
neg eax              ; EAX = -EAX (complemento de dois)

MUL, IMUL (multiplicação)

; MUL — unsigned: resultado em EDX:EAX (32) ou RDX:RAX (64)
mul ebx              ; EDX:EAX = EAX * EBX (sem sinal)
mul dword [ptr]      ; EDX:EAX = EAX * mem (sem sinal)

; IMUL — signed: formas de 1, 2 e 3 operandos
imul ebx             ; EDX:EAX = EAX * EBX (com sinal, forma 1 op)
imul eax, ebx        ; EAX = EAX * EBX (com sinal, truncado — forma 2 ops)
imul eax, ebx, 10    ; EAX = EBX * 10 (com sinal — forma 3 ops)
imul rax, rcx        ; RAX = RAX * RCX (64-bit signed)

DIV, IDIV (divisão)

; DIV — unsigned: dividendo em EDX:EAX, divisor é operando
; Resultado: quociente em EAX, resto em EDX
xor edx, edx         ; limpar EDX antes de divisão 32-bit!
div ebx              ; EAX = EDX:EAX / EBX; EDX = resto
div dword [ptr]

; IDIV — signed: dividendo em EDX:EAX (sinal-extended)
cdq                  ; sign-extend EAX -> EDX:EAX (obrigatório antes de IDIV!)
idiv ebx             ; EAX = EDX:EAX / EBX; EDX = resto

; ATENÇÃO: divisão por zero gera INT 0 (#DE exception)

---

Lógicas e deslocamentos

AND, OR, XOR, NOT

and eax, ebx         ; EAX = EAX AND EBX  (CF=OF=0, ZF/SF baseados no resultado)
and eax, 0xFF        ; mascara: mantém apenas byte baixo
or  eax, ebx         ; EAX = EAX OR EBX
or  eax, 0x01        ; seta bit 0
xor eax, ebx         ; EAX = EAX XOR EBX
xor eax, eax         ; EAX = 0 (padrão idiomático — menor que MOV EAX,0!)
not eax              ; EAX = NOT EAX (complemento de bits — NÃO afeta flags!)

Deslocamentos: SHL, SHR, SAR, ROL, ROR

; SHL/SAL — shift left (multiplica por potência de 2)
shl eax, 1           ; EAX = EAX * 2 (CF = bit deslocado para fora)
shl eax, 3           ; EAX = EAX * 8
shl eax, cl          ; EAX <<= CL (contador variável DEVE ser em CL)

; SHR — shift right lógico (sem sinal: preenche com 0)
shr eax, 1           ; EAX = EAX / 2 (sem sinal)
shr eax, cl

; SAR — shift right aritmético (com sinal: preserva bit de sinal)
sar eax, 1           ; EAX = EAX / 2 (com sinal, arredonda para -inf)
sar eax, cl

; ROL/ROR — rotações (o bit que sai pela esquerda entra pela direita e vice-versa)
rol eax, 1           ; rotação left 1 bit
ror eax, 1           ; rotação right 1 bit
rol eax, cl

; RCL/RCR — rotação através do CF
rcl eax, 1           ; rotate left through carry
rcr eax, 1           ; rotate right through carry

---

Comparação e saltos

CMP, TEST

; CMP: subtração virtual (NÃO salva resultado, apenas afeta flags)
cmp eax, ebx         ; flags de (EAX - EBX)
cmp eax, 0           ; EAX == 0 ?
cmp dword [ptr], 100 ; mem[ptr] == 100 ?

; TEST: AND virtual (NÃO salva resultado, apenas afeta flags)
test eax, eax        ; EAX == 0 ? (mais rápido que CMP EAX, 0)
test eax, 0x01       ; bit 0 de EAX está setado?
test al, 0b00001111  ; bits 0-3 de AL estão todos zerados?

Tabela completa de saltos condicionais (Jcc)

Instrução	Sinônimo	Condição	Flags
JE	JZ	Igual / Zero	ZF=1
JNE	JNZ	Não igual / Não zero	ZF=0
JG	JNLE	Maior (signed)	ZF=0 AND SF=OF
JGE	JNL	Maior ou igual (signed)	SF=OF
JL	JNGE	Menor (signed)	SF≠OF
JLE	JNG	Menor ou igual (signed)	ZF=1 OR SF≠OF
JA	JNBE	Acima (unsigned)	CF=0 AND ZF=0
JAE	JNB, JNC	Acima ou igual (unsigned)	CF=0
JB	JNAE, JC	Abaixo (unsigned)	CF=1
JBE	JNA	Abaixo ou igual (unsigned)	CF=1 OR ZF=1
JS	—	Sinal negativo	SF=1
JNS	—	Sinal positivo	SF=0
JO	—	Overflow	OF=1
JNO	—	Sem overflow	OF=0
JP	JPE	Paridade par	PF=1
JNP	JPO	Paridade ímpar	PF=0

; Padrão típico: CMP + Jcc
cmp eax, 10
jge .maior_igual    ; salta se EAX >= 10 (signed)
; código para EAX < 10
jmp .fim
.maior_igual:
; código para EAX >= 10
.fim:

; JMP incondicional
jmp label           ; salto relativo curto/longo
jmp eax             ; salto indireto (jump table)
jmp [eax]           ; salto indireto via memória

---

Operações de string

; MOVSB/MOVSW/MOVSD/MOVSQ — copia DS:[RSI] → ES:[RDI], incrementa/decrementa RSI e RDI
movsb               ; copia 1 byte
movsw               ; copia 2 bytes (word)
movsd               ; copia 4 bytes (dword)
movsq               ; copia 8 bytes (qword) — x64

; CMPSB/CMPSW/CMPSD — compara DS:[RSI] com ES:[RDI]
cmpsb               ; compara 1 byte, afeta flags

; SCASB/SCASW/SCASD — busca AL/AX/EAX em ES:[RDI]
scasb               ; compara AL com byte em [RDI]

; LODSB/LODSW/LODSD/LODSQ — carrega DS:[RSI] em AL/AX/EAX/RAX
lodsb               ; AL = byte em [RSI]; incrementa RSI

; STOSB/STOSW/STOSD/STOSQ — armazena AL/AX/EAX/RAX em ES:[RDI]
stosb               ; byte [RDI] = AL; incrementa RDI
stosd               ; dword [RDI] = EAX; incrementa RDI por 4

; Prefixos REP:
; REP   — repete RCX vezes (para MOVS, STOS, LODS)
; REPE/REPZ  — repete enquanto ZF=1 (para CMPS, SCAS)
; REPNE/REPNZ — repete enquanto ZF=0 (para CMPS, SCAS)

; Direção: DF=0 (CLD) → incremento, DF=1 (STD) → decremento
cld                 ; direction flag = 0 (incrementar — padrão)
std                 ; direction flag = 1 (decrementar)

; Exemplo: copiar 100 bytes de src para dst
lea rsi, [src]
lea rdi, [dst]
mov rcx, 100
cld
rep movsb           ; copia 100 bytes RSI→RDI

; Exemplo: buscar null byte (strlen)
lea rdi, [string]
xor al, al          ; AL = 0
mov rcx, -1         ; RCX = contador máximo
cld
repne scasb         ; busca até AL == byte em [RDI]
not rcx             ; RCX = comprimento + 1
dec rcx             ; RCX = comprimento

---

Instruções especiais

; NOP — No Operation (1 byte, usado para alinhamento ou patch)
nop
nop dword [rax+0]   ; NOP multi-byte (alinhamento de código)

; HLT — Halt (para execução até próxima interrupção — apenas ring 0)
hlt

; INT 3 — Breakpoint de software (debug trap)
int3                ; gera exceção #BP — o debugger captura
; int 3 (com espaço) gera opcode 0xCD 0x03 (2 bytes)
; int3 (sem espaço) gera opcode 0xCC (1 byte — preferido para breakpoints)

; PAUSE — hint para loops de spin-wait (economiza energia no HT)
pause               ; equivalente a REP NOP (0xF3 0x90)

; CPUID — consulta features (destrói EAX,EBX,ECX,EDX)
mov eax, 0          ; função 0: vendor string
cpuid               ; EBX:EDX:ECX = "GenuineIntel" ou "AuthenticAMD"

---

Diferenças de sintaxe — Delphi built-in assembler

Situação	NASM	Delphi asm..end
Tamanho de operando de memória	mov dword [var], 0	mov dword ptr [var], 0
Rótulo local	.label:	@label:
Referência a variável Pascal	—	MOV EAX, MinhaVar
Endereço de variável	lea rax, [var]	LEA EAX, MinhaVar
Chamada a função Pascal	call _ProcName	CALL PascalProc (direto)
Comentários	;	// ou { }

// Exemplo: diferenças de rótulos no Delphi asm
procedure ExemploRotulos(N: Integer);
asm
  MOV ECX, N
  TEST ECX, ECX
  JZ @zero          // rótulo local com @
@loop:
  DEC ECX
  JNZ @loop
@zero:
  // fim
end;

---

Estrutura de arquivos

developer-assembly-instructions_V1.0.0/
├── SKILL.md
├── exemplos/
│   ├── asm/
│   │   ├── aritmetica.asm
│   │   ├── bitwise_shifts.asm
│   │   ├── comparacao_saltos.asm
│   │   ├── string_operations.asm
│   │   ├── loop_patterns.asm
│   │   └── conditional_ops.asm
│   └── pas/
│       ├── aritmetica_delphi.pas
│       ├── bitwise_flags.pas
│       ├── string_move.pas
│       ├── condicional_cmov.pas
│       ├── loop_counter.pas
│       └── prefixo_lock.pas
├── consultas_rapidas/
│   ├── instrucoes_referencia.md
│   ├── jcc_tabela.md
│   ├── string_ops.md
│   └── instrucoes_delphi_diffs.md
└── templates/
    ├── TEMPLATE_loop_array.pas
    ├── TEMPLATE_atomic_inc.pas
    ├── TEMPLATE_memset_asm.pas
    └── TEMPLATE_loop_nasm.asm

Skills relacionadas

• developer-assembly-x86-fundamentals_V1.0.0 — arquitetura base
• developer-assembly-registers_V1.0.0 — registradores e flags
• developer-assembly-stack-call_V1.0.0 — stack frame e convenções de chamada