Notação: Rd (destino), Rn (fonte): registradores de propósito geral, r0,...,r12
Sugestão: use o sufixo s em todas as instruções (exceto ldr/str, udiv)
| Instrução | Operação | Exemplos |
|---|---|---|
| mov Rd, Rn | Rd := Rn | mov r0, r1 |
| mov Rd, const8 | Rd:= constante-8-bits (com sinal opcional) | mov r0, 1 mov r1, -1 |
| ldr Rd, =constante | Rd := constante-grande: em geral endereço de 32 bits de dado na RAM ou Flash | ldr r0, =rotulo |
| add Rd, Rn | Rd := Rd+Rn | add r0, r1 |
| add Rd, const8 | Rd:= Rd + constante-8-bits (com sinal opcional) | add r0, 1 |
| sub Rd, Rn | Rd := Rd - Rn | sub r0, r1 |
| sub Rd, const8 | Rd:= Rd - constante-8-bits (sinal opcional) | sub r0, 1 |
| mul Rd, Rn | Rd := Rd * Rn | mul r0, r1 |
| udiv Rd, Rn | Rd:= Rd / Rn (divisão inteira) | udiv r1, r2 |
| lsl Rd, Rn, const5 | Rd:= Rn << const-5-bits (logical shift left) | lsl r1, r2, 4 |
| sss Rd, Rn, const5 | Rd:= Rn sss const-5-bits (sss= lsr, asr, ror: logical/aritmetic shift right, rotate right) | asr r1, r2, 4 |
| as instruções and, orr, eor usam os mesmos operandos da instrução add e podem usar um 3o reg para o resultado: xxx Rd, Rm, Rn | add r0, r1, r2 (r0:=r1+r2) | |
| cmp Rd, const8 | compara Rd com const-8-bits (com sinal opcional) - atualiza flags C,Z,N,V para salto condicional | cmp r0, 1 cmp r0, -2 |
| cmp Rd, Rn | compara Rd com Rn (liga flags para salto condicional | cmp r0, r1 |
| bxx rotulo | xx= " ", eq, ne, gt, ge, lt, le, cs, cc - desvia para rotulo se condição xx verdadeira | blt rotulo1 b rotulo2 |
| bl rotulo | chamada de subrotina: LR:= PC+4, PC=endereço do rotulo | bl mysub |
| mov pc, lr | retorno de subrotina: pop {pc} se antes houve push {lr} | pop {pc} | instruções para acessar dados na memória: ldrb, ldr (leitura) e strb, str (escrita). Endereço do dado foi antes carregado num registrador Rx via instrução: ldr Rx, =rotulo |
| ldr(b) Rd, [Rn] | Rd:= word(byte) apontado por Rn | ldrb r1, [r0] |
| ldr(b) Rd, [Rn], const8 | Rd:= word(byte) apontado por Rn, Rn := Rn+const-8-bits (com sinal opcional) | ldr r1, [r0], 4 |
| str(b) Rn, [Rd] | word (byte) apontado por Rd:= Rn | strb r1, [r0] |
| str(b) Rn, [Rd], const8 | word (byte) apontado por Rd:= Rn, Rd := Rd +const-8-bits (com sinal opcional) | strb r1, [r0],1 |
| Instruções ldr e str para acesso à memória com endereçamento pre-indexado.
Nos exemplos, ao usar str no lugar de ldr, Rn passa a ser Rd e vice-versa: str r1, [r0,4] |
||
| ldr(b) Rd, [Rn,const8] | Rd:= word(byte) apontado por Rn+const8 (com sinal opcional), Rn não muda | ldr r1, [r0,4] |
| ldr(b) Rd, [Rn,Rm] | Rd:= word(byte) apontado por Rn+Rm ; Rn e Rm não mudam! | ldr r1, [r0,r2] |
| ldr(b) Rd, [Rn,Rm,lsl const5] | Rd:= word(byte) apontado por Rn+(Rm lsl const5); Rn e Rm não mudam! | ldr r1, [r0,r2,lsl 2] | ldr(b) Rd, [Rn,const8]! | Rd:= word(byte) apontado por Rn+const8 (com sinal opcional), Rn:= Rn + const8 | ldr r1, [r0,4]! |
| ldr(b) Rd, [Rn,Rm]! | Rd:= word(byte) apontado por Rn+Rm ; Rn:= Rn+Rm, Rm não muda! | ldr r1, [r0,r2]! |