ARM32-Befehle (Thumb-2)

Befehlsreferenz: i386 · x64 · ARM32 (Thumb-2) · ARM64 (AArch64)

154 Befehle in 231 Formen für .arch thumb: Name, Operanden, die Bitkodierung (16 oder 32 Bit) und eine kurze Beschreibung mit der Wirkung als Pseudocode. Enthalten sind die 16-Bit-Befehle und die 32-Bit-Befehle: Rechnen, Logik, Schieben, Bitfelder, Multiplikation und Division, Laden und Speichern (auch unprivilegiert und exklusiv), Sprünge, Systembefehle, Koprozessor-Zugriffe und Gleitkomma (VFP). Alle Befehle, die Dismonite zerlegt, sind enthalten. Noch nicht dabei sind NEON, die DSP- und Sättigungs-Befehle und weitere Varianten. Der klassische ARM-Modus (A32) fehlt, weil Windows on ARM nur Thumb-2 benutzt.

So liest du die Tabelle

Ein Thumb-Befehl ist 16 oder 32 Bit lang; ein 32-Bit-Befehl besteht aus zwei Halbwörtern, die im Speicher nacheinander stehen (zuerst das obere Halbwort, hier links, dann das untere, hier rechts, mit einer Lücke dazwischen). Die Kodierung zeigt die Bits von links (höchste Bit-Nummer) nach rechts: feste Bits als Ziffern (der Opcode), die Namen sind Felder. Mit der Maus auf einem Feld steht der Bereich der Bits. Rd, Rn, Rm, Rt sind Register: in 16-Bit-Befehlen meist 3 Bit (r0 bis r7), in 32-Bit-Befehlen 4 Bit (r0 bis r15). imm… ist eine Konstante, cond eine Bedingung (4 Bit), S wählt die Form, die die Flags setzt. Darunter steht der Wert der festen Bits und die Maske in Hex: Ein Befehl gehört zu dieser Form, wenn (Wort & Maske) == Wert ist.

Flags: Die 16-Bit-Befehle zum Rechnen setzen die Flags (N Z C V), wenn sie nicht in einem IT-Block stehen, und sonst nicht; deshalb heißen sie adds, movs, lsls ... Die 32-Bit-Formen setzen die Flags nur, wenn das Bit S gesetzt ist. Wirkung: Rd = Rn + Rm und ähnlich ist Pseudocode; sext und zext erweitern mit Vorzeichen und mit Nullen, >>s schiebt mit Vorzeichen, [x] ist der Speicher an der Adresse x.

Jede Kodierung in dieser Tabelle ist gegen den Zerleger von Dismonite geprüft: Mit zufälligen Werten für die Felder ergibt sie wieder diesen Befehl (oder seinen Alias).

Der Pseudocode ist wie Quelltext englisch geschrieben (if, then, for every element), auch auf der deutschen Seite.

Befehl	Operanden	Kodierung	Beschreibung
adc	Rd, Rn, #const	11110 i 0 1010 S Rn 0 imm3 Rd imm80xF1400000 / Maske 0xFBE08000	Addition mit Übertrag: Konstante als zweiter Operand (8 Bit, gedreht oder wiederholt)`Rd = Rn + const + C; the constant is expanded from i:imm3:imm8`Flags: N Z C V (if S)Arithmetik
adc	Rd, Rn, Rm{, shift #imm}	1110101 1010 S Rn 0 imm3 Rd imm2 type Rm0xEB400000 / Maske 0xFFE08000	Addition mit Übertrag: Register als zweiter Operand, verschoben (lsl, lsr, asr, ror, rrx)`Rd = Rn + shift(Rm) + C`Flags: N Z C V (if S)Arithmetik
adcs	Rdn, Rmauch: adc	010000 0101 Rm Rdn0x4140 / Maske 0xFFC0	Addition mit Übertrag (C)`Rdn = Rdn + Rm + C`Flags: N Z C VArithmetik
add	Rdn, Rm	010001 00 DN Rm Rdn0x4400 / Maske 0xFF00	Addition zweier Register (auch r8 bis r15, setzt keine Flags)`Rdn = Rdn + Rm`Arithmetik
	Rd, sp, #imm8*4	1010 1 Rd imm80xA800 / Maske 0xF800	Addition des Stackzeigers und einer Konstanten`Rd = sp + imm8 * 4`Arithmetik
	sp, sp, #imm7*4	1011 0000 0 imm70xB000 / Maske 0xFF80	Erhöhung des Stackzeigers`sp = sp + imm7 * 4`Arithmetik
	Rd, Rn, #constauch: cmn	11110 i 0 1000 S Rn 0 imm3 Rd imm80xF1000000 / Maske 0xFBE08000	Addition: Konstante als zweiter Operand (8 Bit, gedreht oder wiederholt)`Rd = Rn + const; the constant is expanded from i:imm3:imm8`Flags: N Z C V (if S)Arithmetik
	Rd, Rn, Rm{, shift #imm}auch: cmn	1110101 1000 S Rn 0 imm3 Rd imm2 type Rm0xEB000000 / Maske 0xFFE08000	Addition: Register als zweiter Operand, verschoben (lsl, lsr, asr, ror, rrx)`Rd = Rn + shift(Rm)`Flags: N Z C V (if S)Arithmetik
adds	Rd, Rn, Rmauch: add	000 11 0 0 Rm Rn Rd0x1800 / Maske 0xFE00	Addition zweier Register`Rd = Rn + Rm`Flags: N Z C VArithmetik
	Rd, Rn, #imm3auch: add	000 11 1 0 imm3 Rn Rd0x1C00 / Maske 0xFE00	Addition einer Konstanten (3 Bit)`Rd = Rn + imm3`Flags: N Z C VArithmetik
	Rdn, #imm8auch: add	001 10 Rdn imm80x3000 / Maske 0xF800	Addition einer Konstanten (8 Bit)`Rdn = Rdn + imm8`Flags: N Z C VArithmetik
addw	Rd, Rn, #imm12auch: add	11110 i 100000 Rn 0 imm3 Rd imm80xF2000000 / Maske 0xFBF08000	Addition einer Konstanten (12 Bit)`Rd = Rn + imm12 (i:imm3:imm8)`Arithmetik
adr	Rd, labelauch: add	1010 0 Rd imm80xA000 / Maske 0xF800	Adresse relativ zum Befehlszeiger`Rd = align(pc, 4) + imm8 * 4`Konstanten und Adressen laden
and	Rd, Rn, #constauch: tst	11110 i 0 0000 S Rn 0 imm3 Rd imm80xF0000000 / Maske 0xFBE08000	Bitweises UND: Konstante als zweiter Operand (8 Bit, gedreht oder wiederholt)`Rd = Rn & const; the constant is expanded from i:imm3:imm8`Flags: N Z C V (if S)Logik und Bits
and	Rd, Rn, Rm{, shift #imm}auch: tst	1110101 0000 S Rn 0 imm3 Rd imm2 type Rm0xEA000000 / Maske 0xFFE08000	Bitweises UND: Register als zweiter Operand, verschoben (lsl, lsr, asr, ror, rrx)`Rd = Rn & shift(Rm)`Flags: N Z C V (if S)Logik und Bits
ands	Rdn, Rmauch: and	010000 0000 Rm Rdn0x4000 / Maske 0xFFC0	Bitweises UND`Rdn = Rdn & Rm`Flags: N ZLogik und Bits
asr	Rd, Rn, Rm	11111010 0 10 S Rn 1111 Rd 0000 Rm0xFA40F000 / Maske 0xFFE0F0F0	Schieben rechts mit Vorzeichen um ein Register (32-Bit-Form)`Rd = Rn >>s Rm[7:0]`Flags: N Z C (if S)Schieben und Rotieren
asrs	Rd, Rm, #imm5auch: asr	000 10 imm5 Rm Rd0x1000 / Maske 0xF800	Schieben nach rechts mit Vorzeichen um eine Konstante`Rd = Rm >>s imm5 (imm5 = 0 means 32)`Flags: N Z CSchieben und Rotieren
asrs	Rdn, Rmauch: asr	010000 0100 Rm Rdn0x4100 / Maske 0xFFC0	Schieben nach rechts mit Vorzeichen um ein Register`Rdn = Rdn >>s Rm[7:0]`Flags: N Z CSchieben und Rotieren
b	label	11100 imm110xE000 / Maske 0xF800	Sprung (relativ, +-2 KB)`pc = pc + (sext(imm11) << 1)`Sprünge und Aufrufe
b	label	11110 S imm10 10 J1 1 J2 imm110xF0009000 / Maske 0xF800D000	Sprung (relativ, +-16 MB)`pc = pc + sext(S:J1:J2:imm10:imm11 << 1)`Sprünge und Aufrufe
b.cond	label	1101 cond imm80xD000 / Maske 0xF000	Bedingter Sprung (relativ, +-256 Byte)`if cond then pc = pc + (sext(imm8) << 1)`Sprünge und Aufrufe
b.cond	label	11110 S cond imm6 10 J1 0 J2 imm110xF0008000 / Maske 0xF800D000	Bedingter Sprung (relativ, +-1 MB)`if cond then pc = pc + sext(S:J2:J1:imm6:imm11 << 1)`Sprünge und Aufrufe
bfi	Rd, Rn, #lsb, #widthauch: bfc	11110 0 110110 Rn 0 imm3 Rd imm2 0 msb0xF3600000 / Maske 0xFFF08020	Einfügen eines Bitfeldes aus Rn in Rd (bfc: Nullen)`Rd[msb : lsb] = Rn[msb - lsb : 0]`Bitfelder
bic	Rd, Rn, #const	11110 i 0 0001 S Rn 0 imm3 Rd imm80xF0200000 / Maske 0xFBE08000	Bitweises UND mit invertierter Konstante: Konstante als zweiter Operand (8 Bit, gedreht oder wiederholt)`Rd = Rn & ~const; the constant is expanded from i:imm3:imm8`Flags: N Z C V (if S)Logik und Bits
bic	Rd, Rn, Rm{, shift #imm}	1110101 0001 S Rn 0 imm3 Rd imm2 type Rm0xEA200000 / Maske 0xFFE08000	Bitweises UND mit invertiertem Operanden: Register als zweiter Operand, verschoben (lsl, lsr, asr, ror, rrx)`Rd = Rn & ~shift(Rm)`Flags: N Z C V (if S)Logik und Bits
bics	Rdn, Rmauch: bic	010000 1110 Rm Rdn0x4380 / Maske 0xFFC0	Bitweises UND mit invertiertem Operanden (Bit löschen)`Rdn = Rdn & ~Rm`Flags: N ZLogik und Bits
bkpt	#imm8	1011 1110 imm80xBE00 / Maske 0xFF00	Haltepunkt`raise a breakpoint exception`System und Privilegien
bl	label	11110 S imm10 11 J1 1 J2 imm110xF000D000 / Maske 0xF800D000	Aufruf einer Funktion (relativ, +-16 MB, lr = Rücksprung)`lr = (pc + 4) \| 1; pc = pc + sext(S:J1:J2:imm10:imm11 << 1)`Sprünge und Aufrufe
blx	Rm	010001 11 1 Rm 0000x4780 / Maske 0xFF87	Aufruf der Funktion an der Adresse im Register (lr = Rücksprung)`lr = (pc + 2) \| 1; pc = Rm & ~1`Sprünge und Aufrufe
blx	label	11110 S imm10 11 J1 0 J2 imm10 00xF000C000 / Maske 0xF800D001	Aufruf einer ARM-Funktion (relativ, wechselt in den ARM-Befehlssatz)`lr = (pc + 4) \| 1; pc = align(pc, 4) + sext(S:J1:J2:imm10H:imm10L << 2); instruction set = ARM`Sprünge und Aufrufe
blxns	Rm	010001111 Rm 1000x4784 / Maske 0xFF87	Aufruf eines Registers mit Wechsel in den nicht sicheren Zustand (TrustZone, ARMv8-M)`lr = next; pc = Rm; state = non-secure`Sprünge und Aufrufe
bx	Rm	010001 11 0 Rm 0000x4700 / Maske 0xFF87	Sprung zur Adresse im Register (Bit 0 wählt Thumb, bei Bit 0 = 0 ARM)`pc = Rm & ~1; instruction set = Rm[0]`Sprünge und Aufrufe
bxns	Rm	010001110 Rm 1000x4704 / Maske 0xFF87	Sprung zu einem Register mit Wechsel in den nicht sicheren Zustand (TrustZone, ARMv8-M)`pc = Rm; state = non-secure`Sprünge und Aufrufe
cbnz	Rn, label	1011 10 i 1 imm5 Rn0xB900 / Maske 0xFD00	Sprung vorwärts, wenn das Register nicht 0 ist`if Rn != 0 then pc = pc + (i:imm5 << 1)`Sprünge und Aufrufe
cbz	Rn, label	1011 00 i 1 imm5 Rn0xB100 / Maske 0xFD00	Sprung vorwärts, wenn das Register 0 ist`if Rn == 0 then pc = pc + (i:imm5 << 1)`Sprünge und Aufrufe
clz	Rd, Rm	111110101011 Rm 1111 Rd 1000 Rm0xFAB0F080 / Maske 0xFFF0F0F0	Zählen der führenden Nullbits`Rd = count_leading_zeros(Rm)`Logik und Bits
cmn	Rn, Rm	010000 1011 Rm Rn0x42C0 / Maske 0xFFC0	Vergleich durch Addition (Rn plus Rm), nur die Flags ändern sich`flags = Rn + Rm`Flags: N Z C VVergleichen und Tauschen
cmp	Rn, #imm8	001 01 Rn imm80x2800 / Maske 0xF800	Vergleich mit einer Konstanten (8 Bit)`flags = Rn - imm8`Flags: N Z C VVergleichen und Tauschen
	Rn, Rm	010000 1010 Rm Rn0x4280 / Maske 0xFFC0	Vergleich (Rn minus Rm), nur die Flags ändern sich`flags = Rn - Rm`Flags: N Z C VVergleichen und Tauschen
	Rn, Rm	010001 01 N Rm Rn0x4500 / Maske 0xFF00	Vergleich zweier Register (auch r8 bis r15)`flags = Rn - Rm`Flags: N Z C VVergleichen und Tauschen
cpsid	iauch: cpsie	1011 0110 011 im 0 0 1 00xB662 / Maske 0xFFEF	Sperren (cpsid) oder Erlauben (cpsie) der Interrupts (privilegiert)`PRIMASK = im`System und Privilegien
dmb	option	111100111011 1111 1000 1111 0101 option0xF3BF8F50 / Maske 0xFFFFFFF0	Speicherschranke für die Reihenfolge der Zugriffe`earlier memory accesses are observed before later ones`System und Privilegien
dsb	option	111100111011 1111 1000 1111 0100 option0xF3BF8F40 / Maske 0xFFFFFFF0	Speicherschranke: wartet, bis alle Zugriffe fertig sind`wait until all earlier memory accesses are complete`System und Privilegien
eor	Rd, Rn, #constauch: teq	11110 i 0 0100 S Rn 0 imm3 Rd imm80xF0800000 / Maske 0xFBE08000	Bitweises exklusives ODER: Konstante als zweiter Operand (8 Bit, gedreht oder wiederholt)`Rd = Rn ^ const; the constant is expanded from i:imm3:imm8`Flags: N Z C V (if S)Logik und Bits
eor	Rd, Rn, Rm{, shift #imm}auch: teq	1110101 0100 S Rn 0 imm3 Rd imm2 type Rm0xEA800000 / Maske 0xFFE08000	Bitweises exklusives ODER: Register als zweiter Operand, verschoben (lsl, lsr, asr, ror, rrx)`Rd = Rn ^ shift(Rm)`Flags: N Z C V (if S)Logik und Bits
eors	Rdn, Rmauch: eor	010000 0001 Rm Rdn0x4040 / Maske 0xFFC0	Bitweises exklusives ODER`Rdn = Rdn ^ Rm`Flags: N ZLogik und Bits
hint	#imm	10111111 hint 00000xBF00 / Maske 0xFF0F	Hinweis-Befehl mit einer Nummer von 0 bis 15 (nop, yield, wfe, wfi, sev haben eigene Namen; die übrigen tun nichts)`no change`System und Privilegien
isb	option	111100111011 1111 1000 1111 0110 option0xF3BF8F60 / Maske 0xFFFFFFF0	Befehlsschranke: leert die Pipeline`all instructions after it are fetched anew`System und Privilegien
it	{x{y{z}}} condauch: ite, itt, itee, itet, itte, ittt, iteee, iteet, itete, itett, ittee, ittet, ittte, itttt	1011 1111 firstcond mask0xBF00 / Maske 0xFF00	IT-Block: macht die folgenden 1 bis 4 Befehle bedingt`the next instructions run only if the condition holds (or its opposite for else)`System und Privilegien
ldm	Rn{!}, {registers}auch: ldmia	11001 Rn register_list0xC800 / Maske 0xF800	Laden mehrerer Register (aufwärts)`for each register in the list: reg = [Rn]; Rn = Rn + 4`Laden und Speichern
ldm	Rn{!}, {registers}auch: ldmia, pop	1110100010 W 1 Rn register_list0xE8900000 / Maske 0xFFD00000	Laden mehrerer Register (aufwärts)`for each register in the list: reg = [Rn]; Rn = Rn + 4`Laden und Speichern
ldmdb	Rn{!}, {registers}	1110100100 W 1 Rn register_list0xE9100000 / Maske 0xFFD00000	Laden mehrerer Register (abwärts)`for each register in the list, last first: Rn = Rn - 4; reg = [Rn]`Laden und Speichern
ldr	Rt, label	01001 Rt imm80x4800 / Maske 0xF800	Laden eines Wortes relativ zum Befehlszeiger (Konstantenpool, bis 1020 Byte)`Rt = [align(pc, 4) + imm8 * 4]`Laden und Speichern
	Rt, [Rn, Rm]	0101 100 Rm Rn Rt0x5800 / Maske 0xFE00	Laden eines Wortes (Register-Adresse)`Rt = [Rn + Rm]`Laden und Speichern
	Rt, [Rn{, #imm5*4}]	011 01 imm5 Rn Rt0x6800 / Maske 0xF800	Laden eines Wortes (Konstante als Abstand)`Rt = [Rn + imm5 * 4]`Laden und Speichern
	Rt, [sp{, #imm8*4}]	100 11 Rt imm80x9800 / Maske 0xF800	Laden eines Wortes relativ zum Stackzeiger`Rt = [sp + imm8 * 4]`Laden und Speichern
	Rt, [Rn, #imm12]	111110001101 Rn Rt imm120xF8D00000 / Maske 0xFFF00000	Laden eines Wortes (Konstante, 12 Bit, nur vorwärts)`Rt = [Rn + imm12]`Laden und Speichern
	Rt, [Rn, #+/-imm8]{!} / [Rn], #+/-imm8	111110000101 Rn Rt 1 P U W imm80xF8500800 / Maske 0xFFF00800	Laden eines Wortes (Konstante, 8 Bit, mit oder ohne Rückschreiben)`Rt = [Rn +/- imm8]`Laden und Speichern
	Rt, [Rn, Rm{, lsl #imm2}]	111110000101 Rn Rt 000000 imm2 Rm0xF8500000 / Maske 0xFFF00FC0	Laden eines Wortes (Register, optional um 0 bis 3 nach links verschoben)`Rt = [Rn + (Rm << imm2)]`Laden und Speichern
	Rt, label	11111000 U 1011111 Rt imm120xF85F0000 / Maske 0xFF7F0000	Laden eines Wortes relativ zum Befehlszeiger (+-4 KB)`Rt = [align(pc, 4) +/- imm12]`Laden und Speichern
ldrb	Rt, [Rn, Rm]	0101 110 Rm Rn Rt0x5C00 / Maske 0xFE00	Laden eines Bytes (Register-Adresse)`Rt = zext([Rn + Rm])`Laden und Speichern
	Rt, [Rn{, #imm5}]	011 11 imm5 Rn Rt0x7800 / Maske 0xF800	Laden eines Bytes (Konstante als Abstand)`Rt = zext([Rn + imm5])`Laden und Speichern
	Rt, [Rn, #imm12]	111110001001 Rn Rt imm120xF8900000 / Maske 0xFFF00000	Laden eines Bytes (Konstante, 12 Bit, nur vorwärts)`Rt = zext([Rn + imm12])`Laden und Speichern
	Rt, [Rn, #+/-imm8]{!} / [Rn], #+/-imm8	111110000001 Rn Rt 1 P U W imm80xF8100800 / Maske 0xFFF00800	Laden eines Bytes (Konstante, 8 Bit, mit oder ohne Rückschreiben)`Rt = zext([Rn +/- imm8])`Laden und Speichern
	Rt, [Rn, Rm{, lsl #imm2}]	111110000001 Rn Rt 000000 imm2 Rm0xF8100000 / Maske 0xFFF00FC0	Laden eines Bytes (Register, optional um 0 bis 3 nach links verschoben)`Rt = zext([Rn + (Rm << imm2)])`Laden und Speichern
ldrbt	Rt, [Rn{, #imm8}]	111110000001 Rn Rt 1110 imm80xF8100E00 / Maske 0xFFF00F00	Laden eines Bytes mit den Rechten des Anwendungs-Modus`Rt = zext([Rn + imm8])`Laden und Speichern
ldrd	Rt, Rt2, [Rn, #+/-imm84]{!} / [Rn], #+/-imm84	1110100 P U 1 W 1 Rn Rt Rt2 imm80xE8500000 / Maske 0xFE500000	Laden eines Registerpaares (zwei Wörter)`Rt = [addr]; Rt2 = [addr + 4]`Laden und Speichern
ldrex	Rt, [Rn{, #imm8*4}]	111010000101 Rn Rt 1111 imm80xE8500F00 / Maske 0xFFF00F00	Laden (exklusiv): setzt den Exklusiv-Monitor`Rt = [Rn + imm8 * 4]; set the exclusive monitor`Laden und Speichern
ldrexb	Rt, [Rn]	111010001101 Rn Rt 1111 0100 11110xE8D00F4F / Maske 0xFFF00FFF	Laden eines Bytes (exklusiv)`Rt = zext([Rn]); set the exclusive monitor`Laden und Speichern
ldrexd	Rt, Rt2, [Rn]	111010001101 Rn Rt Rt2 0111 11110xE8D0007F / Maske 0xFFF000FF	Laden eines Doppelwortes (exklusiv): setzt den Exklusiv-Monitor`Rt:Rt2 = [Rn]; mark exclusive`Laden und Speichern
ldrexh	Rt, [Rn]	111010001101 Rn Rt 1111 0101 11110xE8D00F5F / Maske 0xFFF00FFF	Laden eines Halbwortes (exklusiv)`Rt = zext([Rn]); set the exclusive monitor`Laden und Speichern
ldrh	Rt, [Rn, Rm]	0101 101 Rm Rn Rt0x5A00 / Maske 0xFE00	Laden eines Halbwortes (Register-Adresse)`Rt = zext([Rn + Rm])`Laden und Speichern
	Rt, [Rn{, #imm5*2}]	100 01 imm5 Rn Rt0x8800 / Maske 0xF800	Laden eines Halbwortes (Konstante als Abstand)`Rt = zext([Rn + imm5 * 2])`Laden und Speichern
	Rt, [Rn, #imm12]	111110001011 Rn Rt imm120xF8B00000 / Maske 0xFFF00000	Laden eines Halbwortes (Konstante, 12 Bit, nur vorwärts)`Rt = zext([Rn + imm12])`Laden und Speichern
	Rt, [Rn, #+/-imm8]{!} / [Rn], #+/-imm8	111110000011 Rn Rt 1 P U W imm80xF8300800 / Maske 0xFFF00800	Laden eines Halbwortes (Konstante, 8 Bit, mit oder ohne Rückschreiben)`Rt = zext([Rn +/- imm8])`Laden und Speichern
	Rt, [Rn, Rm{, lsl #imm2}]	111110000011 Rn Rt 000000 imm2 Rm0xF8300000 / Maske 0xFFF00FC0	Laden eines Halbwortes (Register, optional um 0 bis 3 nach links verschoben)`Rt = zext([Rn + (Rm << imm2)])`Laden und Speichern
ldrht	Rt, [Rn{, #imm8}]	111110000011 Rn Rt 1110 imm80xF8300E00 / Maske 0xFFF00F00	Laden eines Halbwortes mit den Rechten des Anwendungs-Modus`Rt = zext([Rn + imm8])`Laden und Speichern
ldrsb	Rt, [Rn, Rm]	0101 011 Rm Rn Rt0x5600 / Maske 0xFE00	Laden eines Bytes mit Vorzeichen (Register-Adresse)`Rt = sext([Rn + Rm])`Laden und Speichern
	Rt, [Rn, #imm12]	111110011001 Rn Rt imm120xF9900000 / Maske 0xFFF00000	Laden eines Bytes mit Vorzeichen (Konstante, 12 Bit, nur vorwärts)`Rt = sext([Rn + imm12])`Laden und Speichern
	Rt, [Rn, #+/-imm8]{!} / [Rn], #+/-imm8	111110010001 Rn Rt 1 P U W imm80xF9100800 / Maske 0xFFF00800	Laden eines Bytes mit Vorzeichen (Konstante, 8 Bit, mit oder ohne Rückschreiben)`Rt = sext([Rn +/- imm8])`Laden und Speichern
	Rt, [Rn, Rm{, lsl #imm2}]	111110010001 Rn Rt 000000 imm2 Rm0xF9100000 / Maske 0xFFF00FC0	Laden eines Bytes mit Vorzeichen (Register, optional um 0 bis 3 nach links verschoben)`Rt = sext([Rn + (Rm << imm2)])`Laden und Speichern
ldrsbt	Rt, [Rn{, #imm8}]	111110010001 Rn Rt 1110 imm80xF9100E00 / Maske 0xFFF00F00	Laden eines Bytes mit Vorzeichenerweiterung mit den Rechten des Anwendungs-Modus`Rt = sext([Rn + imm8])`Laden und Speichern
ldrsh	Rt, [Rn, Rm]	0101 111 Rm Rn Rt0x5E00 / Maske 0xFE00	Laden eines Halbwortes mit Vorzeichen (Register-Adresse)`Rt = sext([Rn + Rm])`Laden und Speichern
	Rt, [Rn, #imm12]	111110011011 Rn Rt imm120xF9B00000 / Maske 0xFFF00000	Laden eines Halbwortes mit Vorzeichen (Konstante, 12 Bit, nur vorwärts)`Rt = sext([Rn + imm12])`Laden und Speichern
	Rt, [Rn, #+/-imm8]{!} / [Rn], #+/-imm8	111110010011 Rn Rt 1 P U W imm80xF9300800 / Maske 0xFFF00800	Laden eines Halbwortes mit Vorzeichen (Konstante, 8 Bit, mit oder ohne Rückschreiben)`Rt = sext([Rn +/- imm8])`Laden und Speichern
	Rt, [Rn, Rm{, lsl #imm2}]	111110010011 Rn Rt 000000 imm2 Rm0xF9300000 / Maske 0xFFF00FC0	Laden eines Halbwortes mit Vorzeichen (Register, optional um 0 bis 3 nach links verschoben)`Rt = sext([Rn + (Rm << imm2)])`Laden und Speichern
ldrsht	Rt, [Rn{, #imm8}]	111110010011 Rn Rt 1110 imm80xF9300E00 / Maske 0xFFF00F00	Laden eines Halbwortes mit Vorzeichenerweiterung mit den Rechten des Anwendungs-Modus`Rt = sext([Rn + imm8])`Laden und Speichern
ldrt	Rt, [Rn{, #imm8}]	111110000101 Rn Rt 1110 imm80xF8500E00 / Maske 0xFFF00F00	Laden eines Wortes mit den Rechten des Anwendungs-Modus`Rt = [Rn + imm8]`Laden und Speichern
lsl	Rd, Rn, Rm	11111010 0 00 S Rn 1111 Rd 0000 Rm0xFA00F000 / Maske 0xFFE0F0F0	Schieben links um ein Register (32-Bit-Form)`Rd = Rn << Rm[7:0]`Flags: N Z C (if S)Schieben und Rotieren
lsls	Rd, Rm, #imm5auch: lsl, movs	000 00 imm5 Rm Rd0x0000 / Maske 0xF800	Schieben nach links um eine Konstante`Rd = Rm << imm5`Flags: N Z CSchieben und Rotieren
lsls	Rdn, Rmauch: lsl	010000 0010 Rm Rdn0x4080 / Maske 0xFFC0	Schieben nach links um ein Register`Rdn = Rdn << Rm[7:0]`Flags: N Z CSchieben und Rotieren
lsr	Rd, Rn, Rm	11111010 0 01 S Rn 1111 Rd 0000 Rm0xFA20F000 / Maske 0xFFE0F0F0	Schieben rechts ohne Vorzeichen um ein Register (32-Bit-Form)`Rd = Rn >> Rm[7:0]`Flags: N Z C (if S)Schieben und Rotieren
lsrs	Rd, Rm, #imm5auch: lsr	000 01 imm5 Rm Rd0x0800 / Maske 0xF800	Schieben nach rechts ohne Vorzeichen um eine Konstante`Rd = Rm >> imm5 (imm5 = 0 means 32)`Flags: N Z CSchieben und Rotieren
lsrs	Rdn, Rmauch: lsr	010000 0011 Rm Rdn0x40C0 / Maske 0xFFC0	Schieben nach rechts ohne Vorzeichen um ein Register`Rdn = Rdn >> Rm[7:0]`Flags: N Z CSchieben und Rotieren
mcr	coproc, #opc1, Rt, CRn, CRm{, #opc2}auch: mrc	1110 1110 opc1 L CRn Rt coproc opc2 1 CRm0xEE000010 / Maske 0xFF000010	Koprozessor-Zugriff: Schreiben eines Registers in einen Koprozessor (mcr) oder Lesen (mrc, L = 1)`coprocessor register = Rt or Rt = coprocessor register`System und Privilegien
mla	Rd, Rn, Rm, Ra	111110110000 Rn Ra Rd 0000 Rm0xFB000000 / Maske 0xFFF000F0	Multiplikation mit Addition`Rd = Ra + Rn * Rm`Arithmetik
mls	Rd, Rn, Rm, Ra	111110110000 Rn Ra Rd 0001 Rm0xFB000010 / Maske 0xFFF000F0	Multiplikation mit Subtraktion`Rd = Ra - Rn * Rm`Arithmetik
mov	Rd, Rm	010001 10 D Rm Rd0x4600 / Maske 0xFF00	Kopieren eines Registers (auch r8 bis r15, setzt keine Flags)`Rd = Rm`Konstanten und Adressen laden
movs	Rd, #imm8auch: mov	001 00 Rd imm80x2000 / Maske 0xF800	Laden einer Konstanten (8 Bit)`Rd = imm8`Flags: N ZKonstanten und Adressen laden
movt	Rd, #imm16	11110 i 101100 imm4 0 imm3 Rd imm80xF2C00000 / Maske 0xFBF08000	Laden der oberen Hälfte eines Registers (untere Hälfte bleibt)`Rd[31:16] = imm4:i:imm3:imm8`Konstanten und Adressen laden
movw	Rd, #imm16auch: mov	11110 i 100100 imm4 0 imm3 Rd imm80xF2400000 / Maske 0xFBF08000	Laden einer 16-Bit-Konstante (obere Hälfte 0)`Rd = zext(imm4:i:imm3:imm8)`Konstanten und Adressen laden
mrs	Rd, sysreg	1111001111101111 1000 Rd SYSm0xF3EF8000 / Maske 0xFFFFF000	Lesen eines Systemregisters (apsr, ipsr, msp, psp, primask ...)`Rd = sysreg`System und Privilegien
msr	sysreg, Rn	111100111000 Rn 1000 mask 00 SYSm0xF3808000 / Maske 0xFFF0F300	Schreiben eines Systemregisters`sysreg = Rn`System und Privilegien
mul	Rd, Rn, Rm	111110110000 Rn 1111 Rd 0000 Rm0xFB00F000 / Maske 0xFFF0F0F0	Multiplikation (untere 32 Bit)`Rd = Rn * Rm`Arithmetik
muls	Rdm, Rn, Rdmauch: mul	010000 1101 Rn Rdm0x4340 / Maske 0xFFC0	Multiplikation (untere 32 Bit)`Rdm = Rn * Rdm`Flags: N ZArithmetik
mvns	Rd, Rmauch: mvn	010000 1111 Rm Rd0x43C0 / Maske 0xFFC0	Bitweise Umkehrung`Rd = ~Rm`Flags: N ZLogik und Bits
nop		1011 1111 0000 00000xBF00 / Maske 0xFFFF	Keine Operation`no change`System und Privilegien
orn	Rd, Rn, #constauch: mvn	11110 i 0 0011 S Rn 0 imm3 Rd imm80xF0600000 / Maske 0xFBE08000	Bitweises ODER mit invertierter Konstante: Konstante als zweiter Operand (8 Bit, gedreht oder wiederholt)`Rd = Rn OR ~const; the constant is expanded from i:imm3:imm8`Flags: N Z C V (if S)Logik und Bits
orn	Rd, Rn, Rm{, shift #imm}auch: mvn	1110101 0011 S Rn 0 imm3 Rd imm2 type Rm0xEA600000 / Maske 0xFFE08000	Bitweises ODER mit invertiertem Operanden: Register als zweiter Operand, verschoben (lsl, lsr, asr, ror, rrx)`Rd = Rn OR ~shift(Rm)`Flags: N Z C V (if S)Logik und Bits
orr	Rd, Rn, #constauch: mov	11110 i 0 0010 S Rn 0 imm3 Rd imm80xF0400000 / Maske 0xFBE08000	Bitweises ODER: Konstante als zweiter Operand (8 Bit, gedreht oder wiederholt)`Rd = Rn OR const; the constant is expanded from i:imm3:imm8`Flags: N Z C V (if S)Logik und Bits
orr	Rd, Rn, Rm{, shift #imm}auch: mov, lsl, lsr, asr, ror	1110101 0010 S Rn 0 imm3 Rd imm2 type Rm0xEA400000 / Maske 0xFFE08000	Bitweises ODER: Register als zweiter Operand, verschoben (lsl, lsr, asr, ror, rrx)`Rd = Rn OR shift(Rm)`Flags: N Z C V (if S)Logik und Bits
orrs	Rdn, Rmauch: orr	010000 1100 Rm Rdn0x4300 / Maske 0xFFC0	Bitweises ODER`Rdn = Rdn OR Rm`Flags: N ZLogik und Bits
pld	[Rn, #imm12]	111110001001 Rn 1111 imm120xF890F000 / Maske 0xFFF0F000	Vorab-Laden einer Cache-Zeile zum Lesen (Hinweis)`prefetch the cache line at Rn + imm12 (a hint)`Laden und Speichern
pldw	[Rn, #imm12]	111110001011 Rn 1111 imm120xF8B0F000 / Maske 0xFFF0F000	Vorab-Laden einer Cache-Zeile zum Schreiben (Hinweis)`prefetch the cache line at Rn + imm12 (a hint)`Laden und Speichern
pli	[Rn, #imm12]	111110011001 Rn 1111 imm120xF990F000 / Maske 0xFFF0F000	Vorab-Laden einer Cache-Zeile für Befehle (Hinweis)`prefetch the cache line at Rn + imm12 (a hint)`Laden und Speichern
pop	{registers{, pc}}	1011 110 P register_list0xBC00 / Maske 0xFE00	Holen von Registern (P: auch pc, Rücksprung) vom Stack`load the registers upward from sp; sp = sp + 4 * count`Stack
push	{registers{, lr}}	1011 010 M register_list0xB400 / Maske 0xFE00	Ablegen von Registern (M: auch lr) auf dem Stack`sp = sp - 4 * count; store the registers upward from sp`Stack
rbit	Rd, Rm	111110101001 Rm 1111 Rd 1010 Rm0xFA90F0A0 / Maske 0xFFF0F0F0	Umkehren der Bitreihenfolge`Rd = reverse_bits(Rm)`Logik und Bits
rev	Rd, Rm	1011 1010 00 Rm Rd0xBA00 / Maske 0xFFC0	Umkehren der Bytes (Little/Big Endian)`Rd = reverse_bytes(Rm)`Logik und Bits
rev	Rd, Rm	111110101001 Rm 1111 Rd 1000 Rm0xFA90F080 / Maske 0xFFF0F0F0	Umkehren der Bytes (Little/Big Endian)`Rd = reverse_bytes(Rm)`Logik und Bits
rev16	Rd, Rm	1011 1010 01 Rm Rd0xBA40 / Maske 0xFFC0	Umkehren der Bytes in jedem Halbwort`Rd = reverse_bytes_in_each_16_bits(Rm)`Logik und Bits
rev16	Rd, Rm	111110101001 Rm 1111 Rd 1001 Rm0xFA90F090 / Maske 0xFFF0F0F0	Umkehren der Bytes in jedem Halbwort`Rd = reverse_bytes_in_each_16_bits(Rm)`Logik und Bits
revsh	Rd, Rm	1011 1010 11 Rm Rd0xBAC0 / Maske 0xFFC0	Umkehren der unteren zwei Bytes, mit Vorzeichenerweiterung`Rd = sext(reverse_bytes(Rm[15:0]))`Logik und Bits
revsh	Rd, Rm	111110101001 Rm 1111 Rd 1011 Rm0xFA90F0B0 / Maske 0xFFF0F0F0	Umkehren der unteren zwei Bytes, mit Vorzeichenerweiterung`Rd = sext(reverse_bytes(Rm[15:0]))`Logik und Bits
ror	Rd, Rn, Rm	11111010 0 11 S Rn 1111 Rd 0000 Rm0xFA60F000 / Maske 0xFFE0F0F0	Schieben rechts (Rotation) um ein Register (32-Bit-Form)`Rd = rotate_right(Rn, Rm[7:0])`Flags: N Z C (if S)Schieben und Rotieren
rors	Rdn, Rmauch: ror	010000 0111 Rm Rdn0x41C0 / Maske 0xFFC0	Rotation nach rechts um ein Register`Rdn = rotate_right(Rdn, Rm[7:0])`Flags: N Z CSchieben und Rotieren
rsb	Rd, Rn, #const	11110 i 0 1110 S Rn 0 imm3 Rd imm80xF1C00000 / Maske 0xFBE08000	Umgekehrte Subtraktion: Konstante als zweiter Operand (8 Bit, gedreht oder wiederholt)`Rd = const - Rn; the constant is expanded from i:imm3:imm8`Flags: N Z C V (if S)Arithmetik
rsb	Rd, Rn, Rm{, shift #imm}	1110101 1110 S Rn 0 imm3 Rd imm2 type Rm0xEBC00000 / Maske 0xFFE08000	Umgekehrte Subtraktion: Register als zweiter Operand, verschoben (lsl, lsr, asr, ror, rrx)`Rd = shift(Rm) - Rn`Flags: N Z C V (if S)Arithmetik
rsbs	Rd, Rn, #0auch: neg, rsb	010000 1001 Rn Rd0x4240 / Maske 0xFFC0	Umgekehrte Subtraktion von 0 (Negation)`Rd = 0 - Rn`Flags: N Z C VArithmetik
sbc	Rd, Rn, #const	11110 i 0 1011 S Rn 0 imm3 Rd imm80xF1600000 / Maske 0xFBE08000	Subtraktion mit Borgen: Konstante als zweiter Operand (8 Bit, gedreht oder wiederholt)`Rd = Rn - const - (1 - C); the constant is expanded from i:imm3:imm8`Flags: N Z C V (if S)Arithmetik
sbc	Rd, Rn, Rm{, shift #imm}	1110101 1011 S Rn 0 imm3 Rd imm2 type Rm0xEB600000 / Maske 0xFFE08000	Subtraktion mit Borgen: Register als zweiter Operand, verschoben (lsl, lsr, asr, ror, rrx)`Rd = Rn - shift(Rm) - (1 - C)`Flags: N Z C V (if S)Arithmetik
sbcs	Rdn, Rmauch: sbc	010000 0110 Rm Rdn0x4180 / Maske 0xFFC0	Subtraktion mit Borgen (C)`Rdn = Rdn - Rm - (1 - C)`Flags: N Z C VArithmetik
sbfx	Rd, Rn, #lsb, #width	11110 0 110100 Rn 0 imm3 Rd imm2 0 widthm10xF3400000 / Maske 0xFFF08020	Herausholen eines Bitfeldes mit Vorzeichenerweiterung`Rd = sext(Rn[lsb + width - 1 : lsb])`Bitfelder
sdiv	Rd, Rn, Rm	111110111001 Rn 1111 Rd 1111 Rm0xFB90F0F0 / Maske 0xFFF0F0F0	Division mit Vorzeichen (Division durch 0 ergibt 0)`Rd = Rn / Rm`Arithmetik
setend	le\|be	10110110 010 E 1 0000xB648 / Maske 0xFFEF	Einstellen der Byte-Reihenfolge für Datenzugriffe (E = 0: little endian, 1: big endian; in ARMv8 veraltet)`data endianness = E`System und Privilegien
sev		1011 1111 0100 00000xBF40 / Maske 0xFFFF	Senden eines Ereignisses an alle Prozessoren`set the event register of all processors`System und Privilegien
smlal	RdLo, RdHi, Rn, Rm	111110111100 Rn RdLo RdHi 0000 Rm0xFBC00000 / Maske 0xFFF000F0	Multiplikation mit Vorzeichen zu 64 Bit mit Addition`RdHi:RdLo = RdHi:RdLo + sext(Rn) * sext(Rm)`Arithmetik
smull	RdLo, RdHi, Rn, Rm	111110111000 Rn RdLo RdHi 0000 Rm0xFB800000 / Maske 0xFFF000F0	Multiplikation mit Vorzeichen zu 64 Bit`RdHi:RdLo = sext(Rn) * sext(Rm)`Arithmetik
stm	Rn!, {registers}auch: stmia	11000 Rn register_list0xC000 / Maske 0xF800	Speichern mehrerer Register (aufwärts, Rn wird weitergezählt)`for each register in the list: [Rn] = reg; Rn = Rn + 4`Laden und Speichern
stm	Rn{!}, {registers}auch: stmia	1110100010 W 0 Rn register_list0xE8800000 / Maske 0xFFD00000	Speichern mehrerer Register (aufwärts)`for each register in the list: [Rn] = reg; Rn = Rn + 4`Laden und Speichern
stmdb	Rn{!}, {registers}auch: push	1110100100 W 0 Rn register_list0xE9000000 / Maske 0xFFD00000	Speichern mehrerer Register (abwärts; push ist stmdb sp!)`for each register in the list, last first: Rn = Rn - 4; [Rn] = reg`Laden und Speichern
str	Rt, [Rn, Rm]	0101 000 Rm Rn Rt0x5000 / Maske 0xFE00	Speichern eines Wortes (Register-Adresse)`[Rn + Rm] = Rt`Laden und Speichern
	Rt, [Rn{, #imm5*4}]	011 00 imm5 Rn Rt0x6000 / Maske 0xF800	Speichern eines Wortes (Konstante als Abstand)`[Rn + imm5 * 4] = Rt`Laden und Speichern
	Rt, [sp{, #imm8*4}]	100 10 Rt imm80x9000 / Maske 0xF800	Speichern eines Wortes relativ zum Stackzeiger`[sp + imm8 * 4] = Rt`Laden und Speichern
	Rt, [Rn, #imm12]	111110001100 Rn Rt imm120xF8C00000 / Maske 0xFFF00000	Speichern eines Wortes (Konstante, 12 Bit, nur vorwärts)`[Rn + imm12] = Rt`Laden und Speichern
	Rt, [Rn, #+/-imm8]{!} / [Rn], #+/-imm8	111110000100 Rn Rt 1 P U W imm80xF8400800 / Maske 0xFFF00800	Speichern eines Wortes (Konstante, 8 Bit, mit oder ohne Rückschreiben)`[Rn +/- imm8] = Rt`Laden und Speichern
	Rt, [Rn, Rm{, lsl #imm2}]	111110000100 Rn Rt 000000 imm2 Rm0xF8400000 / Maske 0xFFF00FC0	Speichern eines Wortes (Register, optional um 0 bis 3 nach links verschoben)`[Rn + (Rm << imm2)] = Rt`Laden und Speichern
strb	Rt, [Rn, Rm]	0101 010 Rm Rn Rt0x5400 / Maske 0xFE00	Speichern eines Bytes (Register-Adresse)`[Rn + Rm] = Rt[7:0]`Laden und Speichern
	Rt, [Rn{, #imm5}]	011 10 imm5 Rn Rt0x7000 / Maske 0xF800	Speichern eines Bytes (Konstante als Abstand)`[Rn + imm5] = Rt[7:0]`Laden und Speichern
	Rt, [Rn, #imm12]	111110001000 Rn Rt imm120xF8800000 / Maske 0xFFF00000	Speichern eines Bytes (Konstante, 12 Bit, nur vorwärts)`[Rn + imm12] = Rt[7:0]`Laden und Speichern
	Rt, [Rn, #+/-imm8]{!} / [Rn], #+/-imm8	111110000000 Rn Rt 1 P U W imm80xF8000800 / Maske 0xFFF00800	Speichern eines Bytes (Konstante, 8 Bit, mit oder ohne Rückschreiben)`[Rn +/- imm8] = Rt[7:0]`Laden und Speichern
	Rt, [Rn, Rm{, lsl #imm2}]	111110000000 Rn Rt 000000 imm2 Rm0xF8000000 / Maske 0xFFF00FC0	Speichern eines Bytes (Register, optional um 0 bis 3 nach links verschoben)`[Rn + (Rm << imm2)] = Rt[7:0]`Laden und Speichern
strbt	Rt, [Rn{, #imm8}]	111110000000 Rn Rt 1110 imm80xF8000E00 / Maske 0xFFF00F00	Speichern eines Bytes mit den Rechten des Anwendungs-Modus`[Rn + imm8] = Rt[7:0]`Laden und Speichern
strd	Rt, Rt2, [Rn, #+/-imm84]{!} / [Rn], #+/-imm84	1110100 P U 1 W 0 Rn Rt Rt2 imm80xE8400000 / Maske 0xFE500000	Speichern eines Registerpaares (zwei Wörter)`[addr] = Rt; [addr + 4] = Rt2`Laden und Speichern
strex	Rd, Rt, [Rn{, #imm8*4}]	111010000100 Rn Rt Rd imm80xE8400000 / Maske 0xFFF00000	Bedingtes Speichern (exklusiv): Rd = 0 bei Erfolg`if the exclusive monitor is set then { [Rn + imm8 * 4] = Rt; Rd = 0 } else Rd = 1`Laden und Speichern
strexb	Rd, Rt, [Rn]	111010001100 Rn Rt 1111 0100 Rd0xE8C00F40 / Maske 0xFFF00FF0	Bedingtes Speichern eines Bytes (exklusiv)`if the exclusive monitor is set then { [Rn] = Rt[7:0]; Rd = 0 } else Rd = 1`Laden und Speichern
strexd	Rd, Rt, Rt2, [Rn]	111010001100 Rn Rt Rt2 0111 Rd0xE8C00070 / Maske 0xFFF000F0	Speichern eines Doppelwortes (exklusiv): nur wenn der Monitor noch gesetzt ist`if exclusive then [Rn] = Rt:Rt2; Rd = 0 else Rd = 1`Laden und Speichern
strexh	Rd, Rt, [Rn]	111010001100 Rn Rt 1111 0101 Rd0xE8C00F50 / Maske 0xFFF00FF0	Bedingtes Speichern eines Halbwortes (exklusiv)`if the exclusive monitor is set then { [Rn] = Rt[15:0]; Rd = 0 } else Rd = 1`Laden und Speichern
strh	Rt, [Rn, Rm]	0101 001 Rm Rn Rt0x5200 / Maske 0xFE00	Speichern eines Halbwortes (Register-Adresse)`[Rn + Rm] = Rt[15:0]`Laden und Speichern
	Rt, [Rn{, #imm5*2}]	100 00 imm5 Rn Rt0x8000 / Maske 0xF800	Speichern eines Halbwortes (Konstante als Abstand)`[Rn + imm5 * 2] = Rt[15:0]`Laden und Speichern
	Rt, [Rn, #imm12]	111110001010 Rn Rt imm120xF8A00000 / Maske 0xFFF00000	Speichern eines Halbwortes (Konstante, 12 Bit, nur vorwärts)`[Rn + imm12] = Rt[15:0]`Laden und Speichern
	Rt, [Rn, #+/-imm8]{!} / [Rn], #+/-imm8	111110000010 Rn Rt 1 P U W imm80xF8200800 / Maske 0xFFF00800	Speichern eines Halbwortes (Konstante, 8 Bit, mit oder ohne Rückschreiben)`[Rn +/- imm8] = Rt[15:0]`Laden und Speichern
	Rt, [Rn, Rm{, lsl #imm2}]	111110000010 Rn Rt 000000 imm2 Rm0xF8200000 / Maske 0xFFF00FC0	Speichern eines Halbwortes (Register, optional um 0 bis 3 nach links verschoben)`[Rn + (Rm << imm2)] = Rt[15:0]`Laden und Speichern
strht	Rt, [Rn{, #imm8}]	111110000010 Rn Rt 1110 imm80xF8200E00 / Maske 0xFFF00F00	Speichern eines Halbwortes mit den Rechten des Anwendungs-Modus`[Rn + imm8] = Rt[15:0]`Laden und Speichern
strt	Rt, [Rn{, #imm8}]	111110000100 Rn Rt 1110 imm80xF8400E00 / Maske 0xFFF00F00	Speichern eines Wortes mit den Rechten des Anwendungs-Modus`[Rn + imm8] = Rt`Laden und Speichern
sub	sp, sp, #imm7*4	1011 0000 1 imm70xB080 / Maske 0xFF80	Verringerung des Stackzeigers`sp = sp - imm7 * 4`Arithmetik
	Rd, Rn, #constauch: cmp	11110 i 0 1101 S Rn 0 imm3 Rd imm80xF1A00000 / Maske 0xFBE08000	Subtraktion: Konstante als zweiter Operand (8 Bit, gedreht oder wiederholt)`Rd = Rn - const; the constant is expanded from i:imm3:imm8`Flags: N Z C V (if S)Arithmetik
	Rd, Rn, Rm{, shift #imm}auch: cmp	1110101 1101 S Rn 0 imm3 Rd imm2 type Rm0xEBA00000 / Maske 0xFFE08000	Subtraktion: Register als zweiter Operand, verschoben (lsl, lsr, asr, ror, rrx)`Rd = Rn - shift(Rm)`Flags: N Z C V (if S)Arithmetik
subs	Rd, Rn, Rmauch: sub	000 11 0 1 Rm Rn Rd0x1A00 / Maske 0xFE00	Subtraktion zweier Register`Rd = Rn - Rm`Flags: N Z C VArithmetik
	Rd, Rn, #imm3auch: sub	000 11 1 1 imm3 Rn Rd0x1E00 / Maske 0xFE00	Subtraktion einer Konstanten (3 Bit)`Rd = Rn - imm3`Flags: N Z C VArithmetik
	Rdn, #imm8auch: sub	001 11 Rdn imm80x3800 / Maske 0xF800	Subtraktion einer Konstanten (8 Bit)`Rdn = Rdn - imm8`Flags: N Z C VArithmetik
subw	Rd, Rn, #imm12auch: sub	11110 i 101010 Rn 0 imm3 Rd imm80xF2A00000 / Maske 0xFBF08000	Subtraktion einer Konstanten (12 Bit)`Rd = Rn - imm12 (i:imm3:imm8)`Arithmetik
svc	#imm8	1101 1111 imm80xDF00 / Maske 0xFF00	Systemaufruf an das Betriebssystem`raise a supervisor call exception with imm8`System und Privilegien
sxtab	Rd, Rn, Rm{, ror #rot}auch: sxtah, sxtab16, uxtab, uxtah, uxtab16	11111010 0 op Rn 1111 Rd 1 0 rotate Rm0xFA00F080 / Maske 0xFF80F0C0	Erweiterung eines Bytes oder Halbwortes (sxt: mit Vorzeichen, uxt: mit Nullen) und Addition von Rn; ...16: zwei Halbwörter aus zwei Bytes; Rm vorher um 0/8/16/24 gedreht`Rd = Rn + extend(ror(Rm, rot))`Logik und Bits
sxtb	Rd, Rm	1011 0010 01 Rm Rd0xB240 / Maske 0xFFC0	Vorzeichenerweiterung eines Bytes`Rd = sext(Rm[7:0])`Logik und Bits
sxtb	Rd, Rm{, ror #rot}	1111101 00100 1111 1111 Rd 10 rotate Rm0xFA4FF080 / Maske 0xFFFFF0C0	Vorzeichenerweiterung eines Bytes (32-Bit-Form, Rm zuvor um 0/8/16/24 gedreht)`Rd = sext(rotate(Rm)[7:0])`Logik und Bits
sxtb16	Rd, Rm{, ror #rot}auch: uxtb16	111110100 01 U 1111 1111 Rd 1 0 rotate Rm0xFA2FF080 / Maske 0xFFEFF0C0	Erweiterung zweier Bytes zu zwei Halbwörtern (sxt: mit Vorzeichen, uxt: mit Nullen); Rm vorher um 0/8/16/24 gedreht`Rd = extend(ror(Rm, rot)) per half word`Logik und Bits
sxth	Rd, Rm	1011 0010 00 Rm Rd0xB200 / Maske 0xFFC0	Vorzeichenerweiterung eines Halbwortes`Rd = sext(Rm[15:0])`Logik und Bits
sxth	Rd, Rm{, ror #rot}	1111101 00000 1111 1111 Rd 10 rotate Rm0xFA0FF080 / Maske 0xFFFFF0C0	Vorzeichenerweiterung eines Halbwortes (32-Bit-Form, Rm zuvor um 0/8/16/24 gedreht)`Rd = sext(rotate(Rm)[15:0])`Logik und Bits
tbb	[Rn, Rm]	111010001101 Rn 1111 0000 000 0 Rm0xE8D0F000 / Maske 0xFFF0FFF0	Sprung über eine Tabelle von Byte-Abständen`pc = pc + 2 * zext([Rn + Rm])`Sprünge und Aufrufe
tbh	[Rn, Rm, lsl #1]	111010001101 Rn 1111 0000 000 1 Rm0xE8D0F010 / Maske 0xFFF0FFF0	Sprung über eine Tabelle von Halbwort-Abständen`pc = pc + 2 * zext([Rn + 2 * Rm])`Sprünge und Aufrufe
tst	Rn, Rm	010000 1000 Rm Rn0x4200 / Maske 0xFFC0	Bitweiser Test (UND), nur die Flags ändern sich`flags = Rn & Rm`Flags: N ZLogik und Bits
tt	Rd, Rnauch: tta, ttt, ttat	111010000100 Rn 1111 Rd A T 0000000xE840F000 / Maske 0xFFF0F03F	Test des Zieles einer Adresse (TrustZone: Sicherheitszustand und Zugriffsrechte; A: alternativ, T: unprivilegiert)`Rd = security attributes of the address Rn`System und Privilegien
ubfx	Rd, Rn, #lsb, #width	11110 0 111100 Rn 0 imm3 Rd imm2 0 widthm10xF3C00000 / Maske 0xFFF08020	Herausholen eines Bitfeldes mit Nullen`Rd = zext(Rn[lsb + width - 1 : lsb])`Bitfelder
udf	#imm8auch: trap	1101 1110 imm80xDE00 / Maske 0xFF00	Absichtlich ungültiger Befehl (löst eine Ausnahme aus)`raise an undefined instruction exception`System und Privilegien
udf	#imm16	111101111111 imm4 1010 imm120xF7F0A000 / Maske 0xFFF0F000	Absichtlich ungültiger Befehl (32-Bit-Form)`raise an undefined instruction exception`System und Privilegien
udiv	Rd, Rn, Rm	111110111011 Rn 1111 Rd 1111 Rm0xFBB0F0F0 / Maske 0xFFF0F0F0	Division ohne Vorzeichen (Division durch 0 ergibt 0)`Rd = Rn / Rm`Arithmetik
umlal	RdLo, RdHi, Rn, Rm	111110111110 Rn RdLo RdHi 0000 Rm0xFBE00000 / Maske 0xFFF000F0	Multiplikation ohne Vorzeichen zu 64 Bit mit Addition`RdHi:RdLo = RdHi:RdLo + zext(Rn) * zext(Rm)`Arithmetik
umull	RdLo, RdHi, Rn, Rm	111110111010 Rn RdLo RdHi 0000 Rm0xFBA00000 / Maske 0xFFF000F0	Multiplikation ohne Vorzeichen zu 64 Bit`RdHi:RdLo = zext(Rn) * zext(Rm)`Arithmetik
uxtb	Rd, Rm	1011 0010 11 Rm Rd0xB2C0 / Maske 0xFFC0	Erweiterung eines Bytes mit Nullen`Rd = zext(Rm[7:0])`Logik und Bits
uxtb	Rd, Rm{, ror #rot}	1111101 00101 1111 1111 Rd 10 rotate Rm0xFA5FF080 / Maske 0xFFFFF0C0	Erweiterung eines Bytes mit Nullen (32-Bit-Form, Rm zuvor um 0/8/16/24 gedreht)`Rd = zext(rotate(Rm)[7:0])`Logik und Bits
uxth	Rd, Rm	1011 0010 10 Rm Rd0xB280 / Maske 0xFFC0	Erweiterung eines Halbwortes mit Nullen`Rd = zext(Rm[15:0])`Logik und Bits
uxth	Rd, Rm{, ror #rot}	1111101 00001 1111 1111 Rd 10 rotate Rm0xFA1FF080 / Maske 0xFFFFF0C0	Erweiterung eines Halbwortes mit Nullen (32-Bit-Form, Rm zuvor um 0/8/16/24 gedreht)`Rd = zext(rotate(Rm)[15:0])`Logik und Bits
vabs	Vd, Vm	11101110 1 D 11 0000 Vd 101 sz 1 1 M 0 Vm0xEEB00AC0 / Maske 0xFFBF0ED0	Gleitkomma: Betrag (sz: 0 = Single, 1 = Double)`Vd = abs(Vm)`Gleitkomma (VFP)
vadd	Vd, Vn, Vm	11101110 0 D 11 Vn Vd 101 sz N 0 M 0 Vm0xEE300A00 / Maske 0xFFB00E50	Gleitkomma: Addition (sz = 0: Single, Sd/Sn/Sm; sz = 1: Double, Dd/Dn/Dm)`Vd = Vn + Vm`Gleitkomma (VFP)
vcmp	Vd, Vmauch: vcmpe	11101110 1 D 11 0100 Vd 101 sz E 1 M 0 Vm0xEEB40A40 / Maske 0xFFBF0E50	Gleitkomma: Vergleich zweier Register, setzt die FPSCR-Flags (vcmpe: mit Ausnahme bei NaN; danach vmrs apsr_nzcv, fpscr)`fpscr flags = compare(Vd, Vm)`Flags: N Z C V (FPSCR)Gleitkomma (VFP)
vcmp	Vd, #0.0auch: vcmpe	11101110 1 D 11 0101 Vd 101 sz E 1 0 0 00000xEEB50A40 / Maske 0xFFBF0E7F	Gleitkomma: Vergleich mit null, setzt die FPSCR-Flags`fpscr flags = compare(Vd, 0.0)`Flags: N Z C V (FPSCR)Gleitkomma (VFP)
vcvt	Sd, Sm / Dd, Sm	11101110 1 D 11 1000 Vd 101 sz op 1 M 0 Vm0xEEB80A40 / Maske 0xFFBF0E50	Gleitkomma: Umwandlung einer Ganzzahl in Gleitkomma (op = 1: mit Vorzeichen, 0: ohne)`Vd = (float) Vm`Gleitkomma (VFP)
	Sd, Sm / Sd, Dmauch: vcvtr	11101110 1 D 11 110 x Vd 101 sz op 1 M 0 Vm0xEEBC0A40 / Maske 0xFFBE0E50	Gleitkomma: Umwandlung in eine Ganzzahl (x = 1: mit Vorzeichen; op = 1: vcvt, Richtung null; op = 0: vcvtr, nach dem Rundungsmodus)`Vd = (int) Vm`Gleitkomma (VFP)
	Dd, Sm / Sd, Dm	11101110 1 D 11 0111 Vd 101 sz 1 1 M 0 Vm0xEEB70AC0 / Maske 0xFFBF0ED0	Gleitkomma: Umwandlung zwischen Single und Double`Vd = convert(Vm)`Gleitkomma (VFP)
vdiv	Vd, Vn, Vm	11101110 1 D 00 Vn Vd 101 sz N 0 M 0 Vm0xEE800A00 / Maske 0xFFB00E50	Gleitkomma: Division (sz = 0: Single, Sd/Sn/Sm; sz = 1: Double, Dd/Dn/Dm)`Vd = Vn / Vm`Gleitkomma (VFP)
vfma	Vd, Vn, Vm	11101110 1 D 10 Vn Vd 101 sz N 0 M 0 Vm0xEEA00A00 / Maske 0xFFB00E50	Gleitkomma: Verschmolzene Multiplikation mit Addition (ohne Zwischenrundung) (sz = 0: Single, Sd/Sn/Sm; sz = 1: Double, Dd/Dn/Dm)`Vd = Vd + Vn * Vm`Gleitkomma (VFP)
vfms	Vd, Vn, Vm	11101110 1 D 10 Vn Vd 101 sz N 1 M 0 Vm0xEEA00A40 / Maske 0xFFB00E50	Gleitkomma: Verschmolzene Multiplikation mit Subtraktion (ohne Zwischenrundung) (sz = 0: Single, Sd/Sn/Sm; sz = 1: Double, Dd/Dn/Dm)`Vd = Vd - Vn * Vm`Gleitkomma (VFP)
vfnma	Vd, Vn, Vm	11101110 1 D 01 Vn Vd 101 sz N 1 M 0 Vm0xEE900A40 / Maske 0xFFB00E50	Gleitkomma: Negierte verschmolzene Multiplikation mit Addition (ohne Zwischenrundung) (sz = 0: Single, Sd/Sn/Sm; sz = 1: Double, Dd/Dn/Dm)`Vd = -Vd - Vn * Vm`Gleitkomma (VFP)
vfnms	Vd, Vn, Vm	11101110 1 D 01 Vn Vd 101 sz N 0 M 0 Vm0xEE900A00 / Maske 0xFFB00E50	Gleitkomma: Negierte verschmolzene Multiplikation mit Subtraktion (ohne Zwischenrundung) (sz = 0: Single, Sd/Sn/Sm; sz = 1: Double, Dd/Dn/Dm)`Vd = -Vd + Vn * Vm`Gleitkomma (VFP)
vldm	Rn{!}, {Sd \| Dd list}auch: vldmia, vpop, fldmiax	1110110 0 1 D W 1 Rn Vd 101 sz imm80xEC900A00 / Maske 0xFF900E00	Gleitkomma: Laden mehrerer Register ab der Adresse aufsteigend (vldmia; vpop = vldmia sp!; fldmx bei ungerader Zahl)`registers = [Rn ...]; optionally Rn = Rn + size`Gleitkomma (VFP)
vldmdb	Rn!, {Sd \| Dd list}auch: fldmdbx	1110110 1 0 D 1 1 Rn Vd 101 sz imm80xED300A00 / Maske 0xFFB00E00	Gleitkomma: Laden mehrerer Register absteigend unterhalb der Adresse, Rn wird verkleinert (vldmdb)`Rn = Rn - size; registers = [Rn ...]`Gleitkomma (VFP)
vldr	Sd\|Dd, [Rn{, #+/-imm8*4}]	11101101 U D 0 1 Rn Vd 101 sz imm80xED100A00 / Maske 0xFF300E00	Gleitkomma: Laden eines Registers aus dem Speicher (sz: 0 = Single, 1 = Double)`Vd = [Rn +/- imm8 * 4]`Gleitkomma (VFP)
vmla	Vd, Vn, Vm	11101110 0 D 00 Vn Vd 101 sz N 0 M 0 Vm0xEE000A00 / Maske 0xFFB00E50	Gleitkomma: Multiplikation mit Addition zum Ziel (sz = 0: Single, Sd/Sn/Sm; sz = 1: Double, Dd/Dn/Dm)`Vd = Vd + Vn * Vm`Gleitkomma (VFP)
vmls	Vd, Vn, Vm	11101110 0 D 00 Vn Vd 101 sz N 1 M 0 Vm0xEE000A40 / Maske 0xFFB00E50	Gleitkomma: Multiplikation mit Subtraktion vom Ziel (sz = 0: Single, Sd/Sn/Sm; sz = 1: Double, Dd/Dn/Dm)`Vd = Vd - Vn * Vm`Gleitkomma (VFP)
vmov	Vd, Vm	11101110 1 D 11 0000 Vd 101 sz 0 1 M 0 Vm0xEEB00A40 / Maske 0xFFBF0ED0	Gleitkomma: Kopieren eines Gleitkomma-Registers (sz: 0 = Single, 1 = Double)`Vd = Vm`Gleitkomma (VFP)
	Sd\|Dd, #imm	11101110 1 D 11 imm4H Vd 101 sz 0 0 0 0 imm4L0xEEB00A00 / Maske 0xFFB00EF0	Gleitkomma: Laden einer Konstante (8 Bit kodiert, +-(16..31)/16 * 2^(-3..4))`Vd = constant`Gleitkomma (VFP)
	Sn, Rt / Rt, Sn	11101110 000 op Vn Rt 1010 N 00 1 00000xEE000A10 / Maske 0xFFE00F7F	Gleitkomma: Kopieren zwischen einem Ganzzahl-Register und einem Single-Register (bitweise)`Rt = bits(Sn) or Sn = bits(Rt)`Gleitkomma (VFP)
	Sm, Sm1, Rt, Rt2 / Dm, Rt, Rt2	11101100 010 op Rt2 Rt 101 sz 0 0 M 1 Vm0xEC400A10 / Maske 0xFFE00ED0	Gleitkomma: Kopieren zwischen zwei Ganzzahl-Registern und zwei Single- oder einem Double-Register`Dm = Rt2:Rt or Rt:Rt2 = Dm`Gleitkomma (VFP)
	Dd[x], Rt / Rt, Dn[x]	11101110 0 0 x L Vn Rt 1011 N 00 1 00000xEE000B10 / Maske 0xFFC00F7F	Gleitkomma: Kopieren eines 32-Bit-Wortes zwischen einem Ganzzahl-Register und der Hälfte eines Double-Registers`Dd[x] = Rt or Rt = Dn[x]`Gleitkomma (VFP)
vmrs	Rt, FPSID\|FPSCR	111011101111 000 x Rt 1010 0001 00000xEEF00A10 / Maske 0xFFFE0FFF	Kopieren eines Gleitkomma-Systemregisters in ein Ganzzahl-Register (mit Rt = pc: in die APSR-Flags)`Rt = system register`Gleitkomma (VFP)
vmsr	FPSID\|FPSCR, Rt	111011101110 000 x Rt 1010 0001 00000xEEE00A10 / Maske 0xFFFE0FFF	Kopieren eines Ganzzahl-Registers in ein Gleitkomma-Systemregister`system register = Rt`Gleitkomma (VFP)
vmul	Vd, Vn, Vm	11101110 0 D 10 Vn Vd 101 sz N 0 M 0 Vm0xEE200A00 / Maske 0xFFB00E50	Gleitkomma: Multiplikation (sz = 0: Single, Sd/Sn/Sm; sz = 1: Double, Dd/Dn/Dm)`Vd = Vn * Vm`Gleitkomma (VFP)
vneg	Vd, Vm	11101110 1 D 11 0001 Vd 101 sz 0 1 M 0 Vm0xEEB10A40 / Maske 0xFFBF0ED0	Gleitkomma: Vorzeichenwechsel (sz: 0 = Single, 1 = Double)`Vd = -Vm`Gleitkomma (VFP)
vnmla	Vd, Vn, Vm	11101110 0 D 01 Vn Vd 101 sz N 1 M 0 Vm0xEE100A40 / Maske 0xFFB00E50	Gleitkomma: Negierte Multiplikation mit Addition (sz = 0: Single, Sd/Sn/Sm; sz = 1: Double, Dd/Dn/Dm)`Vd = -Vd - Vn * Vm`Gleitkomma (VFP)
vnmls	Vd, Vn, Vm	11101110 0 D 01 Vn Vd 101 sz N 0 M 0 Vm0xEE100A00 / Maske 0xFFB00E50	Gleitkomma: Negierte Multiplikation mit Subtraktion (sz = 0: Single, Sd/Sn/Sm; sz = 1: Double, Dd/Dn/Dm)`Vd = -Vd + Vn * Vm`Gleitkomma (VFP)
vnmul	Vd, Vn, Vm	11101110 0 D 10 Vn Vd 101 sz N 1 M 0 Vm0xEE200A40 / Maske 0xFFB00E50	Gleitkomma: Negierte Multiplikation (sz = 0: Single, Sd/Sn/Sm; sz = 1: Double, Dd/Dn/Dm)`Vd = -(Vn * Vm)`Gleitkomma (VFP)
vsqrt	Vd, Vm	11101110 1 D 11 0001 Vd 101 sz 1 1 M 0 Vm0xEEB10AC0 / Maske 0xFFBF0ED0	Gleitkomma: Quadratwurzel (sz: 0 = Single, 1 = Double)`Vd = sqrt(Vm)`Gleitkomma (VFP)
vstm	Rn{!}, {Sd \| Dd list}auch: vstmia, fstmiax	1110110 0 1 D W 0 Rn Vd 101 sz imm80xEC800A00 / Maske 0xFF900E00	Gleitkomma: Speichern mehrerer Register ab der Adresse aufsteigend (vstmia; fstmx bei ungerader Zahl)`[Rn ...] = registers; optionally Rn = Rn + size`Gleitkomma (VFP)
vstmdb	Rn!, {Sd \| Dd list}auch: vpush, fstmdbx	1110110 1 0 D 1 0 Rn Vd 101 sz imm80xED200A00 / Maske 0xFFB00E00	Gleitkomma: Speichern mehrerer Register absteigend unterhalb der Adresse, Rn wird verkleinert (vstmdb; vpush = vstmdb sp!)`Rn = Rn - size; [Rn ...] = registers`Gleitkomma (VFP)
vstr	Sd\|Dd, [Rn{, #+/-imm8*4}]	11101101 U D 0 0 Rn Vd 101 sz imm80xED000A00 / Maske 0xFF300E00	Gleitkomma: Speichern eines Registers in den Speicher (sz: 0 = Single, 1 = Double)`[Rn +/- imm8 * 4] = Vd`Gleitkomma (VFP)
vsub	Vd, Vn, Vm	11101110 0 D 11 Vn Vd 101 sz N 1 M 0 Vm0xEE300A40 / Maske 0xFFB00E50	Gleitkomma: Subtraktion (sz = 0: Single, Sd/Sn/Sm; sz = 1: Double, Dd/Dn/Dm)`Vd = Vn - Vm`Gleitkomma (VFP)
wfe		1011 1111 0010 00000xBF20 / Maske 0xFFFF	Warten auf ein Ereignis`sleep until an event`System und Privilegien
wfi		1011 1111 0011 00000xBF30 / Maske 0xFFFF	Warten auf einen Interrupt`sleep until an interrupt`System und Privilegien
yield		1011 1111 0001 00000xBF10 / Maske 0xFFFF	Hinweis: Warteschleife, der Prozessor darf zu einem anderen Thread wechseln`no change (a hint)`System und Privilegien