ARM64-Befehle (AArch64)
Befehlsreferenz: i386 · x64 · ARM32 (Thumb-2) · ARM64 (AArch64)
433 Befehle in 635 Formen: Name, Operanden, die Bitkodierung des 32-Bit-Befehlswortes (feste Bits und Felder) und eine kurze Beschreibung mit der Wirkung als Pseudocode. Enthalten sind die Ganzzahl-Befehle (Rechnen, Logik, Schieben, Bitfelder, Sprünge, Laden und Speichern, Systembefehle), Gleitkomma, die Vektor-Befehle (SIMD), die atomaren Befehle (LSE), Speicher-Tagging (MTE), Zeigerauthentifizierung (PAC), CRC, Speicher kopieren und füllen (MOPS) und die Kryptografie (AES, SHA, SM3, SM4). Alle Befehle, die Dismonite zerlegt, sind enthalten. Befehle, die mehrere Namen haben (Byte und Halbwort, Acquire und Release, Q = 1 mit dem Zusatz 2), stehen in einer Zeile; die weiteren Namen stehen unter den Operanden bei „auch“. Noch nicht dabei sind die skalaren Formen der Vektor-Befehle (Register B, H, S oder D statt Vn.T), die Befehle für SVE und SME und die Gleitkomma-Befehle mit halber Genauigkeit.
So liest du die Tabelle
Jeder ARM64-Befehl ist genau 32 Bit lang. Die Kodierung zeigt die Bits von 31 (links) bis 0 (rechts): 0101 sind feste Bits (der Opcode), die Namen sind Felder. Mit der Maus auf einem Feld steht der Bereich der Bits. Rd, Rn, Rm, Ra sind Register (Nummer 0 bis 31; 31 ist je nach Befehl sp oder xzr/wzr), sf wählt 32 (0, W-Register) oder 64 Bit (1, X-Register), imm… ist eine Konstante, cond eine Bedingung (4 Bit), shift und option wählen eine Schiebe- oder Erweiterungsart. Darunter steht der Wert der festen Bits und die Maske in Hex: Ein Befehlswort gehört zu dieser Form, wenn (Wort & Maske) == Wert ist, wobei die Maske die Felder ausspart.
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. Alias: Viele Befehle schreibt man gern in einer anderen Form (mov, cmp, lsl, cset ...); der Zerleger zeigt dann den Alias-Namen, die Kodierung ist die der Grundform. Die Namen der Felder folgen dem Handbuch von Arm und sind nicht in jedem Fall dieselben.
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 |
|---|---|---|---|
| abs | Vd.T, Vn.T | 0 Q 0 01110 size 10000 01011 10 Rn Rd0x0E20B800 / Maske 0xBF3FFC00 | Betragfor every element: Vd[i] = abs(Vn[i])Vektor (SIMD) |
| adc | Rd, Rn, Rm | sf 0 0 11010000 Rm 000000 Rn Rd0x1A000000 / Maske 0x7FE0FC00 | Addition mit Übertrag (C)Rd = Rn + Rm + CArithmetik |
| adcs | Rd, Rn, Rm | sf 0 1 11010000 Rm 000000 Rn Rd0x3A000000 / Maske 0x7FE0FC00 | Addition mit Übertrag, setzt die FlagsRd = Rn + Rm + CFlags: N Z C VArithmetik |
| add | Rd, Rn, #imm12{, lsl #12}auch: mov, cmn | sf 0 0 100010 sh imm12 Rn Rd0x11000000 / Maske 0x7F800000 | Addition einer Konstanten (12 Bit, optional um 12 verschoben)Rd = Rn + (imm12 << (sh * 12)) (Rd and Rn may be SP)Arithmetik |
| Rd, Rn, Rm{, shift #imm6} | sf 0 0 01011 shift 0 Rm imm6 Rn Rd0x0B000000 / Maske 0x7F200000 | Addition mit verschobenem Register (lsl, lsr, asr)Rd = Rn + shift(Rm, imm6)Arithmetik | |
| Rd, Rn, Rm{, extend #imm3} | sf 0 0 01011 00 1 Rm option imm3 Rn Rd0x0B200000 / Maske 0x7FE00000 | Addition mit erweitertem Register (Byte, Halbwort, Wort)Rd = Rn + (extend(Rm) << imm3) (Rd and Rn may be SP)Arithmetik | |
| Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 10000 1 Rn Rd0x0E208400 / Maske 0xBF20FC00 | Addition der Elemente (8, 16, 32 oder 64 Bit)for every element: Vd[i] = Vn[i] + Vm[i]Vektor (SIMD) | |
| addg | Xd|SP, Xn|SP, #uimm6, #uimm4 | 1 0 0 100011 0 imm6 00 imm4 Rn Rd0x91800000 / Maske 0xFFC0C000 | Addition zu einer Adresse mit Änderung des TagsXd = Xn + uimm6 * 16, tag = (tag of Xn + uimm4) modulo 16Speicher-Tagging (MTE) |
| addhn | Vd.Tb, Vn.Ta, Vm.Taauch: addhn2 | 0 Q 0 01110 size 1 Rm 0100 00 Rn Rd0x0E204000 / Maske 0xBF20FC00 | Addition mit Verschmälerung (obere Hälfte; raddhn mit Runden) (mit Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = high half of (Vn[i] + Vm[i])Vektor (SIMD) |
| addp | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 10111 1 Rn Rd0x0E20BC00 / Maske 0xBF20FC00 | Addition benachbarter Elementpaarefor every element: Vd[i] = sum of each pair of (Vn:Vm)Vektor (SIMD) |
| adds | Rd, Rn, #imm12{, lsl #12}auch: cmn | sf 0 1 100010 sh imm12 Rn Rd0x31000000 / Maske 0x7F800000 | Addition einer Konstanten, setzt die FlagsRd = Rn + (imm12 << (sh * 12))Flags: N Z C VArithmetik |
| Rd, Rn, Rm{, shift #imm6}auch: cmn | sf 0 1 01011 shift 0 Rm imm6 Rn Rd0x2B000000 / Maske 0x7F200000 | Addition mit verschobenem Register, setzt die FlagsRd = Rn + shift(Rm, imm6)Flags: N Z C VArithmetik | |
| Rd, Rn, Rm{, extend #imm3}auch: cmn | sf 0 1 01011 00 1 Rm option imm3 Rn Rd0x2B200000 / Maske 0x7FE00000 | Addition mit erweitertem Register, setzt die FlagsRd = Rn + (extend(Rm) << imm3)Flags: N Z C VArithmetik | |
| addv | Vd, Vn.T | 0 Q 0 01110 size 11000 11011 10 Rn Rd0x0E31B800 / Maske 0xBF3FFC00 | Summe aller ElementeVd = sum of all elements of VnVektor (SIMD) |
| adr | Xd, label | 0 immlo 10000 immhi Rd0x10000000 / Maske 0x9F000000 | Adresse relativ zum Befehlszeiger (+-1 MB)Xd = pc + sext(immhi:immlo)Konstanten und Adressen laden |
| adrp | Xd, label | 1 immlo 10000 immhi Rd0x90000000 / Maske 0x9F000000 | Adresse der 4-KB-Seite relativ zum Befehlszeiger (+-4 GB)Xd = (pc & ~0xFFF) + (sext(immhi:immlo) << 12)Konstanten und Adressen laden |
| aese | Vd.16B, Vn.16Bauch: aesd, aesmc, aesimc | 01001110 00 10100 001 op 10 Rn Rd0x4E284800 / Maske 0xFFFFCC00 | AES-Verschlüsselung: eine Runde (aese, aesmc) oder Entschlüsselung (aesd, aesimc: Gegenstücke)aese: Vd = SubBytes(ShiftRows(Vd ^ Vn)); aesmc: Vd = MixColumns(Vn)Kryptografie |
| and | Rd, Rn, #imm (bit pattern) | sf 0 0 100100 N immr imms Rn Rd0x12000000 / Maske 0x7F800000 | Bitweises UND mit einem Bitmuster als KonstanteRd = Rn & decode_bitmask(N, imms, immr) (Rd may be SP)Logik und Bits |
| Rd, Rn, Rm{, shift #imm6} | sf 0 0 01010 shift 0 Rm imm6 Rn Rd0x0A000000 / Maske 0x7F200000 | Bitweises UND (Register, verschoben)Rd = Rn & shift(Rm, imm6)Logik und Bits | |
| Vd.T, Vn.T, Vm.T | 0 Q 0 01110 00 1 Rm 00011 1 Rn Rd0x0E201C00 / Maske 0xBFE0FC00 | Bitweises UND zweier Vektor-RegisterVd = Vn & VmVektor (SIMD) | |
| ands | Rd, Rn, #imm (bit pattern)auch: tst | sf 1 1 100100 N immr imms Rn Rd0x72000000 / Maske 0x7F800000 | Bitweises UND mit Bitmuster, setzt die FlagsRd = Rn & decode_bitmask(N, imms, immr); C = V = 0Flags: N Z C VLogik und Bits |
| Rd, Rn, Rm{, shift #imm6}auch: tst | sf 1 1 01010 shift 0 Rm imm6 Rn Rd0x6A000000 / Maske 0x7F200000 | Bitweises UND, setzt die FlagsRd = Rn & shift(Rm, imm6); C = V = 0Flags: N Z C VLogik und Bits | |
| asrv | Rd, Rn, Rmauch: asr | sf 0 0 11010110 Rm 001010 Rn Rd0x1AC02800 / Maske 0x7FE0FC00 | Schieben nach rechts mit Vorzeichen um ein RegisterRd = Rn >>s (Rm mod width)Schieben und Rotieren |
| b | label | 0 00101 imm260x14000000 / Maske 0xFC000000 | Sprung (relativ, +-128 MB)pc = pc + sext(imm26 << 2)Sprünge und Aufrufe |
| b.cond | label | 0101010 0 imm19 0 cond0x54000000 / Maske 0xFF000010 | Bedingter Sprung (relativ, +-1 MB)if cond then pc = pc + sext(imm19 << 2)Sprünge und Aufrufe |
| bc | labelauch: bc.eq, bc.ne, bc.hs, bc.lo, bc.mi, bc.pl, bc.vs, bc.vc, bc.hi, bc.ls, bc.ge, bc.lt, bc.gt, bc.le, bc.al, bc.nv | 0101010 0 imm19 1 cond0x54000010 / Maske 0xFF000010 | Bedingter Sprung mit Hinweis, dass er stets gleich verläuft (Konsistenz, FEAT_HBC)if cond then pc = pc + imm19 * 4Sprünge, Aufrufe und Interrupts |
| bcax | Vd.16B, Vn.16B, Vm.16B, Va.16B | 11001110 001 Rm 0 Ra Rn Rd0xCE200000 / Maske 0xFFE08000 | Bitweises Löschen und exklusives ODER (SHA-3)Vd = Vn ^ (Vm & ~Va)Kryptografie |
| bfm | Rd, Rn, #immr, #immsauch: bfc, bfi, bfxil | sf 0 1 100110 N immr imms Rn Rd0x33000000 / Maske 0x7F800000 | Bitfeld verschieben, übrige Bits von Rd bleiben (Grundform von bfi, bfxil)Rd = (Rd with the field replaced by the field of Rn)Bitfelder |
| bic | Rd, Rn, Rm{, shift #imm6} | sf 0 0 01010 shift 1 Rm imm6 Rn Rd0x0A200000 / Maske 0x7F200000 | Bitweises UND mit invertiertem Operanden (Bit löschen)Rd = Rn & ~shift(Rm, imm6)Logik und Bits |
| Vd.T, Vn.T, Vm.T | 0 Q 0 01110 01 1 Rm 00011 1 Rn Rd0x0E601C00 / Maske 0xBFE0FC00 | Bitweises UND mit invertiertem Operanden (Bit löschen)Vd = Vn & ~VmVektor (SIMD) | |
| Vd.T, #imm8{, lsl #amount} | 0 Q 1 0111100000 abc 0 cm 1 01 defgh Rd0x2F001400 / Maske 0xBFF89C00 | Bitweises Löschen mit einer 32-Bit-Konstante (ein Byte, geschoben)Vd = Vd & ~(imm8 << (8 * cm))Vektor (SIMD) | |
| Vd.T, #imm8{, lsl #amount} | 0 Q 1 0111100000 abc 10 c 1 01 defgh Rd0x2F009400 / Maske 0xBFF8DC00 | Bitweises Löschen mit einer 16-Bit-Konstante (ein Byte, geschoben)Vd = Vd & ~(imm8 << (8 * c))Vektor (SIMD) | |
| bics | Rd, Rn, Rm{, shift #imm6} | sf 1 1 01010 shift 1 Rm imm6 Rn Rd0x6A200000 / Maske 0x7F200000 | Bitweises UND mit invertiertem Operanden, setzt die FlagsRd = Rn & ~shift(Rm, imm6); C = V = 0Flags: N Z C VLogik und Bits |
| bif | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 11 1 Rm 00011 1 Rn Rd0x2EE01C00 / Maske 0xBFE0FC00 | Bitweises Einfügen, wenn das Bit in Vm gelöscht istVd = (Vn & ~Vm) | (Vd & Vm)Vektor (SIMD) |
| bit | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 10 1 Rm 00011 1 Rn Rd0x2EA01C00 / Maske 0xBFE0FC00 | Bitweises Einfügen, wenn das Bit in Vm gesetzt istVd = (Vn & Vm) | (Vd & ~Vm)Vektor (SIMD) |
| bl | label | 1 00101 imm260x94000000 / Maske 0xFC000000 | Aufruf einer Funktion (relativ, Rücksprungadresse nach x30)x30 = pc + 4; pc = pc + sext(imm26 << 2)Sprünge und Aufrufe |
| blr | Xn | 1101011 0 0 01 11111 000000 Rn 000000xD63F0000 / Maske 0xFFFFFC1F | Aufruf der Funktion an der Adresse im Registerx30 = pc + 4; pc = XnSprünge und Aufrufe |
| blraa | Xn, Xm|SPauch: blrab, blraaz, blrabz | 1101011 Z 0 01 11111 0000 1 M Rn Rm0xD63F0800 / Maske 0xFEFFF800 | Aufruf einer geprüften Adresse (a = Schlüssel A, b = Schlüssel B, z = Modifizierer 0)x30 = pc + 4; pc = aut(Xn, key, Xm)Zeigerauthentifizierung (PAC) |
| br | Xn | 1101011 0 0 00 11111 000000 Rn 000000xD61F0000 / Maske 0xFFFFFC1F | Sprung zu der Adresse im Registerpc = XnSprünge und Aufrufe |
| braa | Xn, Xm|SPauch: brab, braaz, brabz | 1101011 Z 0 00 11111 0000 1 M Rn Rm0xD61F0800 / Maske 0xFEFFF800 | Sprung zu einer geprüften Adresse (a = Schlüssel A, b = Schlüssel B, z = Modifizierer 0)pc = aut(Xn, key, Xm); jumpZeigerauthentifizierung (PAC) |
| brk | #imm16 | 11010100 001 imm16 000 000xD4200000 / Maske 0xFFE0001F | Haltepunkt (Debug-Ausnahme)raise a breakpoint exception with imm16System und Privilegien |
| bsl | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 01 1 Rm 00011 1 Rn Rd0x2E601C00 / Maske 0xBFE0FC00 | Bitweise Auswahl: Das Ziel selbst ist die MaskeVd = (Vd & Vn) | (~Vd & Vm)Vektor (SIMD) |
| cas | Ws, Wt, [Xn|SP]auch: casa, casal, casl, casb, casab, casalb, caslb, cash, casah, casalh, caslh | size 001000 1 A 1 Rs R 11111 Rn Rt0x08A07C00 / Maske 0x3FA07C00 | Atomares Vergleichen und Austauschen (Compare and Swap): Ist der Speicherwert gleich Ws, wird Wt gespeichert; Ws erhält den alten Wert (Varianten: b, h, a, l)t = [Rn]; if t == Ws then [Rn] = Wt; Ws = tAtomare Speicherzugriffe (LSE) |
| casp | Ws, Ws+1, Wt, Wt+1, [Xn|SP]auch: caspa, caspal, caspl | 0 sz 001000 0 A 1 Rs 0 R 11111 Rn Rt 00x08207C00 / Maske 0xBFA17C01 | Atomares Vergleichen und Austauschen eines Registerpaares (Varianten: a = Acquire, l = Release)t = [Rn] (pair); if t == Ws:Ws+1 then [Rn] = Wt:Wt+1; Ws:Ws+1 = tAtomare Speicherzugriffe (LSE) |
| cbnz | Rt, label | sf 011010 1 imm19 Rt0x35000000 / Maske 0x7F000000 | Sprung, wenn das Register nicht 0 istif Rt != 0 then pc = pc + sext(imm19 << 2)Sprünge und Aufrufe |
| cbz | Rt, label | sf 011010 0 imm19 Rt0x34000000 / Maske 0x7F000000 | Sprung, wenn das Register 0 istif Rt == 0 then pc = pc + sext(imm19 << 2)Sprünge und Aufrufe |
| ccmn | Rn, Rm, #nzcv, cond | sf 0 1 11010010 Rm cond 0 0 Rn 0 nzcv0x3A400000 / Maske 0x7FE00C10 | Bedingter Vergleich (Addition): Flags aus Rn + Rm, sonst aus nzcvif cond then flags = compare(Rn + Rm) else flags = nzcvFlags: N Z C VVergleichen und Tauschen |
| Rn, #imm5, #nzcv, cond | sf 0 1 11010010 imm5 cond 1 0 Rn 0 nzcv0x3A400800 / Maske 0x7FE00C10 | Bedingter Vergleich (Addition) mit einer Konstanteif cond then flags = compare(Rn + imm5) else flags = nzcvFlags: N Z C VVergleichen und Tauschen | |
| ccmp | Rn, Rm, #nzcv, cond | sf 1 1 11010010 Rm cond 0 0 Rn 0 nzcv0x7A400000 / Maske 0x7FE00C10 | Bedingter Vergleich (Subtraktion): Flags aus Rn - Rm, sonst aus nzcvif cond then flags = compare(Rn - Rm) else flags = nzcvFlags: N Z C VVergleichen und Tauschen |
| Rn, #imm5, #nzcv, cond | sf 1 1 11010010 imm5 cond 1 0 Rn 0 nzcv0x7A400800 / Maske 0x7FE00C10 | Bedingter Vergleich (Subtraktion) mit einer Konstanteif cond then flags = compare(Rn - imm5) else flags = nzcvFlags: N Z C VVergleichen und Tauschen | |
| clrex | {#imm4} | 1101010100 0 00 011 0011 CRm 0 10 111110xD503305F / Maske 0xFFFFF0FF | Löschen des Exklusiv-Monitorsclear the exclusive monitorLaden und Speichern |
| cls | Rd, Rn | sf 1 0 11010110 00000 000101 Rn Rd0x5AC01400 / Maske 0x7FFFFC00 | Zählen der führenden Bits gleich dem VorzeichenbitRd = count_leading_sign_bits(Rn)Logik und Bits |
| Vd.T, Vn.T | 0 Q 0 01110 size 10000 00100 10 Rn Rd0x0E204800 / Maske 0xBF3FFC00 | Zählen der führenden Bits, die dem Vorzeichenbit gleichenfor every element: Vd[i] = count_leading_sign_bits(Vn[i])Vektor (SIMD) | |
| clz | Rd, Rn | sf 1 0 11010110 00000 000100 Rn Rd0x5AC01000 / Maske 0x7FFFFC00 | Zählen der führenden NullbitsRd = count_leading_zeros(Rn)Logik und Bits |
| Vd.T, Vn.T | 0 Q 1 01110 size 10000 00100 10 Rn Rd0x2E204800 / Maske 0xBF3FFC00 | Zählen der führenden Nullenfor every element: Vd[i] = count_leading_zeros(Vn[i])Vektor (SIMD) | |
| cmeq | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 10001 1 Rn Rd0x2E208C00 / Maske 0xBF20FC00 | Vergleich auf gleich, Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] == Vm[i]) ? all 1 bits : 0Vektor (SIMD) |
| Vd.T, Vn.T, #0 | 0 Q 0 01110 size 10000 01001 10 Rn Rd0x0E209800 / Maske 0xBF3FFC00 | Vergleich auf gleich null, Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] == 0) ? all 1 bits : 0Vektor (SIMD) | |
| cmge | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 00111 1 Rn Rd0x0E203C00 / Maske 0xBF20FC00 | Vergleich auf größer oder gleich (mit Vorzeichen), Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] >= Vm[i]) ? all 1 bits : 0Vektor (SIMD) |
| Vd.T, Vn.T, #0 | 0 Q 1 01110 size 10000 01000 10 Rn Rd0x2E208800 / Maske 0xBF3FFC00 | Vergleich auf größer oder gleich null, Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] >= 0) ? all 1 bits : 0Vektor (SIMD) | |
| cmgt | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 00110 1 Rn Rd0x0E203400 / Maske 0xBF20FC00 | Vergleich auf größer (mit Vorzeichen), Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] > Vm[i]) ? all 1 bits : 0Vektor (SIMD) |
| Vd.T, Vn.T, #0 | 0 Q 0 01110 size 10000 01000 10 Rn Rd0x0E208800 / Maske 0xBF3FFC00 | Vergleich auf größer als null, Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] > 0) ? all 1 bits : 0Vektor (SIMD) | |
| cmhi | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 00110 1 Rn Rd0x2E203400 / Maske 0xBF20FC00 | Vergleich auf größer (ohne Vorzeichen), Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] > Vm[i]) ? all 1 bits : 0Vektor (SIMD) |
| cmhs | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 00111 1 Rn Rd0x2E203C00 / Maske 0xBF20FC00 | Vergleich auf größer oder gleich (ohne Vorzeichen), Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] >= Vm[i]) ? all 1 bits : 0Vektor (SIMD) |
| cmle | Vd.T, Vn.T, #0 | 0 Q 1 01110 size 10000 01001 10 Rn Rd0x2E209800 / Maske 0xBF3FFC00 | Vergleich auf kleiner oder gleich null, Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] <= 0) ? all 1 bits : 0Vektor (SIMD) |
| cmlt | Vd.T, Vn.T, #0 | 0 Q 0 01110 size 10000 01010 10 Rn Rd0x0E20A800 / Maske 0xBF3FFC00 | Vergleich auf kleiner als null, Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] < 0) ? all 1 bits : 0Vektor (SIMD) |
| cmtst | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 10001 1 Rn Rd0x0E208C00 / Maske 0xBF20FC00 | Test auf gemeinsame gesetzte Bits, Ergebnis ist eine Maskefor every element: Vd[i] = ((Vn[i] & Vm[i]) != 0) ? all 1 bits : 0Vektor (SIMD) |
| cnt | Vd.T, Vn.T | 0 Q 0 01110 00 10000 00101 10 Rn Rd0x0E205800 / Maske 0xBFFFFC00 | Zählen der gesetzten Bits in jedem Bytefor every element: Vd[i] = popcount(Vn[i])Vektor (SIMD) |
| cpye | [Xd]!, [Xs]!, Xn!auch: cpyewn, cpyern, cpyen, cpyewt, cpyewtwn, cpyewtrn, cpyewtn, cpyert, cpyertwn, cpyertrn, cpyertn, cpyet, cpyetwn, cpyetrn, cpyetn | 00 011 1 01 10 0 Rs op2 01 Rn Rd0x1D800400 / Maske 0xFFE00C00 | Kopieren eines Speicherblocks, Abschluss (epilogue) (die drei Befehle p, m, e werden nacheinander ausgeführt)copy Xn bytes from [Xs] to [Xd]; Xd, Xs, Xn are updatedSpeicher kopieren und füllen |
| cpyfe | [Xd]!, [Xs]!, Xn!auch: cpyfewn, cpyfern, cpyfen, cpyfewt, cpyfewtwn, cpyfewtrn, cpyfewtn, cpyfert, cpyfertwn, cpyfertrn, cpyfertn, cpyfet, cpyfetwn, cpyfetrn, cpyfetn | 00 011 0 01 10 0 Rs op2 01 Rn Rd0x19800400 / Maske 0xFFE00C00 | Kopieren eines Speicherblocks, Abschluss (epilogue), nur vorwärts (die drei Befehle p, m, e werden nacheinander ausgeführt)copy Xn bytes from [Xs] to [Xd]; Xd, Xs, Xn are updatedSpeicher kopieren und füllen |
| cpyfm | [Xd]!, [Xs]!, Xn!auch: cpyfmwn, cpyfmrn, cpyfmn, cpyfmwt, cpyfmwtwn, cpyfmwtrn, cpyfmwtn, cpyfmrt, cpyfmrtwn, cpyfmrtrn, cpyfmrtn, cpyfmt, cpyfmtwn, cpyfmtrn, cpyfmtn | 00 011 0 01 01 0 Rs op2 01 Rn Rd0x19400400 / Maske 0xFFE00C00 | Kopieren eines Speicherblocks, Hauptteil (main), nur vorwärts (die drei Befehle p, m, e werden nacheinander ausgeführt)copy Xn bytes from [Xs] to [Xd]; Xd, Xs, Xn are updatedSpeicher kopieren und füllen |
| cpyfp | [Xd]!, [Xs]!, Xn!auch: cpyfpwn, cpyfprn, cpyfpn, cpyfpwt, cpyfpwtwn, cpyfpwtrn, cpyfpwtn, cpyfprt, cpyfprtwn, cpyfprtrn, cpyfprtn, cpyfpt, cpyfptwn, cpyfptrn, cpyfptn | 00 011 0 01 00 0 Rs op2 01 Rn Rd0x19000400 / Maske 0xFFE00C00 | Kopieren eines Speicherblocks, Vorbereitung (prologue), nur vorwärts (die drei Befehle p, m, e werden nacheinander ausgeführt)copy Xn bytes from [Xs] to [Xd]; Xd, Xs, Xn are updatedSpeicher kopieren und füllen |
| cpym | [Xd]!, [Xs]!, Xn!auch: cpymwn, cpymrn, cpymn, cpymwt, cpymwtwn, cpymwtrn, cpymwtn, cpymrt, cpymrtwn, cpymrtrn, cpymrtn, cpymt, cpymtwn, cpymtrn, cpymtn | 00 011 1 01 01 0 Rs op2 01 Rn Rd0x1D400400 / Maske 0xFFE00C00 | Kopieren eines Speicherblocks, Hauptteil (main) (die drei Befehle p, m, e werden nacheinander ausgeführt)copy Xn bytes from [Xs] to [Xd]; Xd, Xs, Xn are updatedSpeicher kopieren und füllen |
| cpyp | [Xd]!, [Xs]!, Xn!auch: cpypwn, cpyprn, cpypn, cpypwt, cpypwtwn, cpypwtrn, cpypwtn, cpyprt, cpyprtwn, cpyprtrn, cpyprtn, cpypt, cpyptwn, cpyptrn, cpyptn | 00 011 1 01 00 0 Rs op2 01 Rn Rd0x1D000400 / Maske 0xFFE00C00 | Kopieren eines Speicherblocks, Vorbereitung (prologue) (die drei Befehle p, m, e werden nacheinander ausgeführt)copy Xn bytes from [Xs] to [Xd]; Xd, Xs, Xn are updatedSpeicher kopieren und füllen |
| crc32b | Wd, Wn, Wm | 0 0 0 11010110 Rm 010 0 00 Rn Rd0x1AC04000 / Maske 0xFFE0FC00 | CRC-32-Prüfsumme (Polynom 0x04C11DB7) über ein ByteWd = crc32(Wn, Wm)CRC-Prüfsummen |
| crc32cb | Wd, Wn, Wm | 0 0 0 11010110 Rm 010 1 00 Rn Rd0x1AC05000 / Maske 0xFFE0FC00 | CRC-32C-Prüfsumme (Castagnoli, Polynom 0x1EDC6F41) über ein ByteWd = crc32c(Wn, Wm)CRC-Prüfsummen |
| crc32ch | Wd, Wn, Wm | 0 0 0 11010110 Rm 010 1 01 Rn Rd0x1AC05400 / Maske 0xFFE0FC00 | CRC-32C-Prüfsumme (Castagnoli, Polynom 0x1EDC6F41) über ein HalbwortWd = crc32c(Wn, Wm)CRC-Prüfsummen |
| crc32cw | Wd, Wn, Wm | 0 0 0 11010110 Rm 010 1 10 Rn Rd0x1AC05800 / Maske 0xFFE0FC00 | CRC-32C-Prüfsumme (Castagnoli, Polynom 0x1EDC6F41) über ein WortWd = crc32c(Wn, Wm)CRC-Prüfsummen |
| crc32cx | Wd, Wn, Xm | 1 0 0 11010110 Rm 010 1 11 Rn Rd0x9AC05C00 / Maske 0xFFE0FC00 | CRC-32C-Prüfsumme (Castagnoli, Polynom 0x1EDC6F41) über ein DoppelwortWd = crc32c(Wn, Xm)CRC-Prüfsummen |
| crc32h | Wd, Wn, Wm | 0 0 0 11010110 Rm 010 0 01 Rn Rd0x1AC04400 / Maske 0xFFE0FC00 | CRC-32-Prüfsumme (Polynom 0x04C11DB7) über ein HalbwortWd = crc32(Wn, Wm)CRC-Prüfsummen |
| crc32w | Wd, Wn, Wm | 0 0 0 11010110 Rm 010 0 10 Rn Rd0x1AC04800 / Maske 0xFFE0FC00 | CRC-32-Prüfsumme (Polynom 0x04C11DB7) über ein WortWd = crc32(Wn, Wm)CRC-Prüfsummen |
| crc32x | Wd, Wn, Xm | 1 0 0 11010110 Rm 010 0 11 Rn Rd0x9AC04C00 / Maske 0xFFE0FC00 | CRC-32-Prüfsumme (Polynom 0x04C11DB7) über ein DoppelwortWd = crc32(Wn, Xm)CRC-Prüfsummen |
| csel | Rd, Rn, Rm, cond | sf 0 0 11010100 Rm cond 0 0 Rn Rd0x1A800000 / Maske 0x7FE00C00 | Bedingte Auswahl (Rn, wenn Bedingung, sonst Rm)Rd = cond ? Rn : RmBedingte Auswahl |
| csinc | Rd, Rn, Rm, condauch: cinc, cset | sf 0 0 11010100 Rm cond 0 1 Rn Rd0x1A800400 / Maske 0x7FE00C00 | Bedingte Auswahl, sonst Rm + 1 (cset, cinc)Rd = cond ? Rn : Rm + 1Bedingte Auswahl |
| csinv | Rd, Rn, Rm, condauch: cinv, csetm | sf 1 0 11010100 Rm cond 0 0 Rn Rd0x5A800000 / Maske 0x7FE00C00 | Bedingte Auswahl, sonst invertiertes RmRd = cond ? Rn : ~RmBedingte Auswahl |
| csneg | Rd, Rn, Rm, condauch: cneg | sf 1 0 11010100 Rm cond 0 1 Rn Rd0x5A800400 / Maske 0x7FE00C00 | Bedingte Auswahl, sonst negiertes RmRd = cond ? Rn : -RmBedingte Auswahl |
| dcps1 | {#imm16}auch: dcps2, dcps3 | 11010100 101 imm16 000 opc0xD4A00000 / Maske 0xFFE0001C | Wechsel in den Debug-Zustand auf der Ausnahmestufe 1, 2 oder 3 (nur im Debug-Zustand)enter debug state at EL1, EL2 or EL3System und Privilegien |
| dmb | option | 1101010100 0 00 011 0011 CRm 1 01 111110xD50330BF / Maske 0xFFFFF0FF | Speicherschranke für die Reihenfolge der Zugriffeearlier memory accesses are observed before later onesSystem und Privilegien |
| dsb | optionauch: ssbb, pssbb | 1101010100 0 00 011 0011 CRm 1 00 111110xD503309F / Maske 0xFFFFF0FF | Speicherschranke: wartet, bis alle Zugriffe fertig sindwait until all earlier memory accesses are completeSystem und Privilegien |
| dup | Vd.T, Rnauch: mov | 0 Q 0 01110000 imm5 0 0001 1 Rn Rd0x0E000C00 / Maske 0xBFE0FC00 | Kopieren eines Ganzzahl-Registers in alle Elementefor every element: Vd[i] = RnVektor (SIMD) |
| Vd.T, Vn.Ts[index]auch: mov | 0 Q 0 01110000 imm5 0 0000 1 Rn Rd0x0E000400 / Maske 0xBFE0FC00 | Kopieren eines Elements in alle Elementefor every element: Vd[i] = Vn[index]Vektor (SIMD) | |
| eon | Rd, Rn, Rm{, shift #imm6} | sf 1 0 01010 shift 1 Rm imm6 Rn Rd0x4A200000 / Maske 0x7F200000 | Bitweises exklusives ODER mit invertiertem OperandenRd = Rn ^ ~shift(Rm, imm6)Logik und Bits |
| eor | Rd, Rn, #imm (bit pattern) | sf 1 0 100100 N immr imms Rn Rd0x52000000 / Maske 0x7F800000 | Bitweises exklusives ODER mit einem Bitmuster als KonstanteRd = Rn ^ decode_bitmask(N, imms, immr) (Rd may be SP)Logik und Bits |
| Rd, Rn, Rm{, shift #imm6} | sf 1 0 01010 shift 0 Rm imm6 Rn Rd0x4A000000 / Maske 0x7F200000 | Bitweises exklusives ODER (Register, verschoben)Rd = Rn ^ shift(Rm, imm6)Logik und Bits | |
| Vd.T, Vn.T, Vm.T | 0 Q 1 01110 00 1 Rm 00011 1 Rn Rd0x2E201C00 / Maske 0xBFE0FC00 | Bitweises exklusives ODERVd = Vn ^ VmVektor (SIMD) | |
| eor3 | Vd.16B, Vn.16B, Vm.16B, Va.16B | 11001110 000 Rm 0 Ra Rn Rd0xCE000000 / Maske 0xFFE08000 | Exklusiv-ODER dreier Vektoren (SHA-3)Vd = Vn ^ Vm ^ VaKryptografie |
| eret | 1101011 0 100 11111 000000 11111 000000xD69F03E0 / Maske 0xFFFFFFFF | Rückkehr aus einer Ausnahme (privilegiert)pc = ELR; PSTATE = SPSRSprünge und Aufrufe | |
| ext | Vd.T, Vn.T, Vm.T, #index | 0 Q 101110 00 0 Rm 0 imm4 0 Rn Rd0x2E000000 / Maske 0xBFE08400 | Herausziehen eines Bytebereichs aus zwei aneinandergehängten VektorenVd = bytes index ... index + 15 of (Vm:Vn)Vektor (SIMD) |
| extr | Rd, Rn, Rm, #lsbauch: ror | sf 0 0 100111 N 0 Rm imms Rn Rd0x13800000 / Maske 0x7FA00000 | Auszug aus dem Registerpaar Rn:Rm ab Bit lsb (ror bei Rn = Rm)Rd = (Rn:Rm >> imms) low halfSchieben und Rotieren |
| fabd | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 1 sz 1 Rm 11010 1 Rn Rd0x2EA0D400 / Maske 0xBFA0FC00 | Absoluter Unterschied von Gleitkomma-Elementenfor every element: Vd[i] = abs(Vn[i] - Vm[i])Vektor (SIMD) |
| fabs | Fd, Fn | 0 0 0 11110 ftype 1 000001 10000 Rn Rd0x1E20C000 / Maske 0xFF3FFC00 | BetragFd = abs(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 0 01110 1 sz 10000 01111 10 Rn Rd0x0EA0F800 / Maske 0xBFBFFC00 | Betrag von Gleitkomma-Elementenfor every element: Vd[i] = abs(Vn[i])Vektor (SIMD) | |
| facge | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 0 sz 1 Rm 11101 1 Rn Rd0x2E20EC00 / Maske 0xBFA0FC00 | Vergleich der Beträge auf größer oder gleich, Ergebnis ist eine Maskefor every element: Vd[i] = (abs(Vn[i]) >= abs(Vm[i])) ? all 1 bits : 0Vektor (SIMD) |
| facgt | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 1 sz 1 Rm 11101 1 Rn Rd0x2EA0EC00 / Maske 0xBFA0FC00 | Vergleich der Beträge auf größer, Ergebnis ist eine Maskefor every element: Vd[i] = (abs(Vn[i]) > abs(Vm[i])) ? all 1 bits : 0Vektor (SIMD) |
| fadd | Fd, Fn, Fm | 0 0 0 11110 ftype 1 Rm 0010 10 Rn Rd0x1E202800 / Maske 0xFF20FC00 | AdditionFd = Fn + FmGleitkomma (skalar) |
| Vd.T, Vn.T, Vm.T | 0 Q 0 01110 0 sz 1 Rm 11010 1 Rn Rd0x0E20D400 / Maske 0xBFA0FC00 | Addition von Gleitkomma-Elementen (sz: 0 = Single, 1 = Double)for every element: Vd[i] = Vn[i] + Vm[i]Vektor (SIMD) | |
| faddp | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 0 sz 1 Rm 11010 1 Rn Rd0x2E20D400 / Maske 0xBFA0FC00 | Addition benachbarter Gleitkomma-Paarefor every element: Vd[i] = sum of each pair of (Vn:Vm)Vektor (SIMD) |
| fcadd | Vd.T, Vn.T, Vm.T, #rot | 0 Q 1 01110 size 0 Rm 1 11 rot 0 1 Rn Rd0x2E00E400 / Maske 0xBF20EC00 | Addition komplexer Zahlen mit einer Drehung um 90 oder 270 GradVd = Vn + rotate(Vm, rot)Vektor (SIMD) |
| fccmp | Fn, Fm, #nzcv, cond | 0 0 0 11110 ftype 1 Rm cond 01 Rn 0 nzcv0x1E200400 / Maske 0xFF200C10 | Bedingter Vergleich: Flags aus Fn, Fm, sonst aus nzcvif cond then flags = compare(Fn, Fm) else flags = nzcvFlags: N Z C VGleitkomma (skalar) |
| fccmpe | Fn, Fm, #nzcv, cond | 0 0 0 11110 ftype 1 Rm cond 01 Rn 1 nzcv0x1E200410 / Maske 0xFF200C10 | Bedingter Gleitkomma-Vergleich (mit Ausnahme bei NaN)if cond then flags = compare(Fn, Fm) else flags = nzcvFlags: N Z C VGleitkomma (skalar) |
| fcmeq | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 0 sz 1 Rm 11100 1 Rn Rd0x0E20E400 / Maske 0xBFA0FC00 | Gleitkomma-Vergleich auf gleich, Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] == Vm[i]) ? all 1 bits : 0Vektor (SIMD) |
| Vd.T, Vn.T, #0 | 0 Q 0 01110 1 sz 10000 01101 10 Rn Rd0x0EA0D800 / Maske 0xBFBFFC00 | Gleitkomma-Vergleich mit null auf gleich, Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] == 0) ? all 1 bits : 0Vektor (SIMD) | |
| fcmge | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 0 sz 1 Rm 11100 1 Rn Rd0x2E20E400 / Maske 0xBFA0FC00 | Gleitkomma-Vergleich auf größer oder gleich, Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] >= Vm[i]) ? all 1 bits : 0Vektor (SIMD) |
| Vd.T, Vn.T, #0 | 0 Q 1 01110 1 sz 10000 01100 10 Rn Rd0x2EA0C800 / Maske 0xBFBFFC00 | Gleitkomma-Vergleich mit null auf größer oder gleich, Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] >= 0) ? all 1 bits : 0Vektor (SIMD) | |
| fcmgt | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 1 sz 1 Rm 11100 1 Rn Rd0x2EA0E400 / Maske 0xBFA0FC00 | Gleitkomma-Vergleich auf größer, Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] > Vm[i]) ? all 1 bits : 0Vektor (SIMD) |
| Vd.T, Vn.T, #0 | 0 Q 0 01110 1 sz 10000 01100 10 Rn Rd0x0EA0C800 / Maske 0xBFBFFC00 | Gleitkomma-Vergleich mit null auf größer, Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] > 0) ? all 1 bits : 0Vektor (SIMD) | |
| fcmla | Vd.T, Vn.T, Vm.T, #rot | 0 Q 1 01110 size 0 Rm 1 1 0 rot 1 Rn Rd0x2E00C400 / Maske 0xBF20E400 | Multiplikation komplexer Zahlen (ein Teilschritt, Drehung 0, 90, 180 oder 270 Grad), addiert zum ZielVd = Vd + partial_product(Vn, Vm, rot)Vektor (SIMD) |
| fcmle | Vd.T, Vn.T, #0 | 0 Q 1 01110 1 sz 10000 01101 10 Rn Rd0x2EA0D800 / Maske 0xBFBFFC00 | Gleitkomma-Vergleich mit null auf kleiner oder gleich, Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] <= 0) ? all 1 bits : 0Vektor (SIMD) |
| fcmlt | Vd.T, Vn.T, #0 | 0 Q 0 01110 1 sz 10000 01110 10 Rn Rd0x0EA0E800 / Maske 0xBFBFFC00 | Gleitkomma-Vergleich mit null auf kleiner, Ergebnis ist eine Maskefor every element: Vd[i] = (Vn[i] < 0) ? all 1 bits : 0Vektor (SIMD) |
| fcmp | Fn, Fm | 0 0 0 11110 ftype 1 Rm 001000 Rn 00 0000x1E202000 / Maske 0xFF20FC1F | Vergleich zweier Gleichkomma-Werte, setzt die Flagsflags = compare(Fn, Fm) (unordered: N Z C V = 0 0 1 1)Flags: N Z C VGleitkomma (skalar) |
| Fn, #0.0 | 0 0 0 11110 ftype 1 00000 001000 Rn 01 0000x1E202008 / Maske 0xFF3FFC1F | Vergleich mit 0.0, setzt die Flagsflags = compare(Fn, 0.0)Flags: N Z C VGleitkomma (skalar) | |
| fcmpe | Fn, Fm | 0 0 0 11110 ftype 1 Rm 001000 Rn 10 0000x1E202010 / Maske 0xFF20FC1F | Vergleich mit Ausnahme bei NaN (signalisierend), setzt die Flagsflags = compare(Fn, Fm)Flags: N Z C VGleitkomma (skalar) |
| fcsel | Fd, Fn, Fm, cond | 0 0 0 11110 ftype 1 Rm cond 11 Rn Rd0x1E200C00 / Maske 0xFF200C00 | Bedingte Auswahl (Fn, wenn Bedingung, sonst Fm)Fd = cond ? Fn : FmGleitkomma (skalar) |
| fcvt | Fd, Fn | 0 0 0 11110 ftype 1 0001 opc 10000 Rn Rd0x1E224000 / Maske 0xFF3E7C00 | Umwandlung zwischen Genauigkeiten (half, single, double)Fd = convert(Fn) to the precision of FdGleitkomma (skalar) |
| fcvtas | Rd, Fn | sf 0 0 11110 ftype 1 00 100 000000 Rn Rd0x1E240000 / Maske 0x7F3FFC00 | Umwandlung in eine Ganzzahl mit Vorzeichen (zur nächsten, bei Gleichstand weg von null)Rd = (int) round_half_away(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 0 01110 0 sz 10000 11100 10 Rn Rd0x0E21C800 / Maske 0xBFBFFC00 | Umwandlung in eine Ganzzahl mit Vorzeichen (zur nächsten, bei Gleichstand weg von null)for every element: Vd[i] = (int) round_half_away(Vn[i])Vektor (SIMD) | |
| fcvtau | Rd, Fn | sf 0 0 11110 ftype 1 00 101 000000 Rn Rd0x1E250000 / Maske 0x7F3FFC00 | Umwandlung in eine Ganzzahl ohne Vorzeichen (zur nächsten, bei Gleichstand weg von null)Rd = (uint) round_half_away(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 1 01110 0 sz 10000 11100 10 Rn Rd0x2E21C800 / Maske 0xBFBFFC00 | Umwandlung in eine Ganzzahl ohne Vorzeichen (zur nächsten, bei Gleichstand weg von null)for every element: Vd[i] = (uint) round_half_away(Vn[i])Vektor (SIMD) | |
| fcvtl | Vd.Ta, Vn.Tbauch: fcvtl2 | 0 Q 0 01110 0 sz 10000 10111 10 Rn Rd0x0E217800 / Maske 0xBFBFFC00 | Umwandlung in die doppelte Genauigkeitfor every element: Vd[i] = convert(Vn[i]) widerVektor (SIMD) |
| fcvtms | Rd, Fn | sf 0 0 11110 ftype 1 10 000 000000 Rn Rd0x1E300000 / Maske 0x7F3FFC00 | Umwandlung in eine Ganzzahl mit Vorzeichen (Richtung minus unendlich)Rd = (int) floor(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 0 01110 0 sz 10000 11011 10 Rn Rd0x0E21B800 / Maske 0xBFBFFC00 | Umwandlung in eine Ganzzahl mit Vorzeichen (Richtung minus unendlich)for every element: Vd[i] = (int) floor(Vn[i])Vektor (SIMD) | |
| fcvtmu | Rd, Fn | sf 0 0 11110 ftype 1 10 001 000000 Rn Rd0x1E310000 / Maske 0x7F3FFC00 | Umwandlung in eine Ganzzahl ohne Vorzeichen (Richtung minus unendlich)Rd = (uint) floor(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 1 01110 0 sz 10000 11011 10 Rn Rd0x2E21B800 / Maske 0xBFBFFC00 | Umwandlung in eine Ganzzahl ohne Vorzeichen (Richtung minus unendlich)for every element: Vd[i] = (uint) floor(Vn[i])Vektor (SIMD) | |
| fcvtn | Vd.Tb, Vn.Taauch: fcvtn2 | 0 Q 0 01110 0 sz 10000 10110 10 Rn Rd0x0E216800 / Maske 0xBFBFFC00 | Umwandlung in die halbe Genauigkeitfor every element: Vd[i] = convert(Vn[i]) narrowerVektor (SIMD) |
| fcvtns | Rd, Fn | sf 0 0 11110 ftype 1 00 000 000000 Rn Rd0x1E200000 / Maske 0x7F3FFC00 | Umwandlung in eine Ganzzahl mit Vorzeichen (zur nächsten, gerade bei Gleichstand)Rd = (int) round_to_nearest_even(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 0 01110 0 sz 10000 11010 10 Rn Rd0x0E21A800 / Maske 0xBFBFFC00 | Umwandlung in eine Ganzzahl mit Vorzeichen (zur nächsten, gerade bei Gleichstand)for every element: Vd[i] = (int) round_to_nearest_even(Vn[i])Vektor (SIMD) | |
| fcvtnu | Rd, Fn | sf 0 0 11110 ftype 1 00 001 000000 Rn Rd0x1E210000 / Maske 0x7F3FFC00 | Umwandlung in eine Ganzzahl ohne Vorzeichen (zur nächsten, gerade bei Gleichstand)Rd = (uint) round_to_nearest_even(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 1 01110 0 sz 10000 11010 10 Rn Rd0x2E21A800 / Maske 0xBFBFFC00 | Umwandlung in eine Ganzzahl ohne Vorzeichen (zur nächsten, gerade bei Gleichstand)for every element: Vd[i] = (uint) round_to_nearest_even(Vn[i])Vektor (SIMD) | |
| fcvtps | Rd, Fn | sf 0 0 11110 ftype 1 01 000 000000 Rn Rd0x1E280000 / Maske 0x7F3FFC00 | Umwandlung in eine Ganzzahl mit Vorzeichen (Richtung plus unendlich)Rd = (int) ceil(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 0 01110 1 sz 10000 11010 10 Rn Rd0x0EA1A800 / Maske 0xBFBFFC00 | Umwandlung in eine Ganzzahl mit Vorzeichen (Richtung plus unendlich)for every element: Vd[i] = (int) ceil(Vn[i])Vektor (SIMD) | |
| fcvtpu | Rd, Fn | sf 0 0 11110 ftype 1 01 001 000000 Rn Rd0x1E290000 / Maske 0x7F3FFC00 | Umwandlung in eine Ganzzahl ohne Vorzeichen (Richtung plus unendlich)Rd = (uint) ceil(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 1 01110 1 sz 10000 11010 10 Rn Rd0x2EA1A800 / Maske 0xBFBFFC00 | Umwandlung in eine Ganzzahl ohne Vorzeichen (Richtung plus unendlich)for every element: Vd[i] = (uint) ceil(Vn[i])Vektor (SIMD) | |
| fcvtxn | Vd.Tb, Vn.Taauch: fcvtxn2 | 0 Q 1 01110 0 sz 10000 10110 10 Rn Rd0x2E216800 / Maske 0xBFBFFC00 | Umwandlung in die halbe Genauigkeit (Runden zur ungeraden Zahl)for every element: Vd[i] = convert_round_to_odd(Vn[i])Vektor (SIMD) |
| fcvtzs | Rd, Fn | sf 0 0 11110 ftype 1 11 000 000000 Rn Rd0x1E380000 / Maske 0x7F3FFC00 | Umwandlung in eine Ganzzahl mit Vorzeichen (abgeschnitten, Richtung null)Rd = (int) trunc(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 0 01110 1 sz 10000 11011 10 Rn Rd0x0EA1B800 / Maske 0xBFBFFC00 | Umwandlung in eine Ganzzahl mit Vorzeichen (Richtung null)for every element: Vd[i] = (int) trunc(Vn[i])Vektor (SIMD) | |
| fcvtzu | Rd, Fn | sf 0 0 11110 ftype 1 11 001 000000 Rn Rd0x1E390000 / Maske 0x7F3FFC00 | Umwandlung in eine Ganzzahl ohne Vorzeichen (abgeschnitten, Richtung null)Rd = (uint) trunc(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 1 01110 1 sz 10000 11011 10 Rn Rd0x2EA1B800 / Maske 0xBFBFFC00 | Umwandlung in eine Ganzzahl ohne Vorzeichen (Richtung null)for every element: Vd[i] = (uint) trunc(Vn[i])Vektor (SIMD) | |
| fdiv | Fd, Fn, Fm | 0 0 0 11110 ftype 1 Rm 0001 10 Rn Rd0x1E201800 / Maske 0xFF20FC00 | DivisionFd = Fn / FmGleitkomma (skalar) |
| Vd.T, Vn.T, Vm.T | 0 Q 1 01110 0 sz 1 Rm 11111 1 Rn Rd0x2E20FC00 / Maske 0xBFA0FC00 | Division von Gleitkomma-Elementenfor every element: Vd[i] = Vn[i] / Vm[i]Vektor (SIMD) | |
| fjcvtzs | Wd, Dn | 0 0 0 11110 01 1 11 110 000000 Rn Rd0x1E7E0000 / Maske 0xFFFFFC00 | Umwandlung in eine Ganzzahl nach JavaScript-Regeln (Ergebnis modulo 2^32)Wd = javascript_to_int32(Dn)Flags: N Z C VZeigerauthentifizierung (PAC) |
| fmadd | Fd, Fn, Fm, Fa | 0 0 0 11111 ftype 0 Rm 0 Ra Rn Rd0x1F000000 / Maske 0xFF208000 | Multiplikation mit Addition (verschmolzen, Fa + Fn * Fm)Fd = Fa + Fn * FmGleitkomma (skalar) |
| fmax | Fd, Fn, Fm | 0 0 0 11110 ftype 1 Rm 0100 10 Rn Rd0x1E204800 / Maske 0xFF20FC00 | Maximum (NaN breitet sich aus)Fd = max(Fn, Fm)Gleitkomma (skalar) |
| Vd.T, Vn.T, Vm.T | 0 Q 0 01110 0 sz 1 Rm 11110 1 Rn Rd0x0E20F400 / Maske 0xBFA0FC00 | Maximum von Gleitkomma-Elementenfor every element: Vd[i] = max(Vn[i], Vm[i])Vektor (SIMD) | |
| fmaxnm | Fd, Fn, Fm | 0 0 0 11110 ftype 1 Rm 0110 10 Rn Rd0x1E206800 / Maske 0xFF20FC00 | Maximum (eine Zahl gewinnt gegen NaN)Fd = maxnum(Fn, Fm)Gleitkomma (skalar) |
| Vd.T, Vn.T, Vm.T | 0 Q 0 01110 0 sz 1 Rm 11000 1 Rn Rd0x0E20C400 / Maske 0xBFA0FC00 | Maximum von Gleitkomma-Elementen (eine Zahl gewinnt gegen NaN)for every element: Vd[i] = maxnum(Vn[i], Vm[i])Vektor (SIMD) | |
| fmaxnmp | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 0 sz 1 Rm 11000 1 Rn Rd0x2E20C400 / Maske 0xBFA0FC00 | Maximum benachbarter Gleitkomma-Paare (eine Zahl gewinnt gegen NaN)for every element: Vd[i] = maxnum of each pair of (Vn:Vm)Vektor (SIMD) |
| fmaxnmv | Sd, Vn.4S | 0 1 1 01110 0 0 11000 01100 10 Rn Rd0x6E30C800 / Maske 0xFFFFFC00 | Maximum aller Gleitkomma-Elemente (eine Zahl gewinnt gegen NaN)Sd = maxnum of all elements of VnVektor (SIMD) |
| fmaxp | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 0 sz 1 Rm 11110 1 Rn Rd0x2E20F400 / Maske 0xBFA0FC00 | Maximum benachbarter Gleitkomma-Paarefor every element: Vd[i] = max of each pair of (Vn:Vm)Vektor (SIMD) |
| fmaxv | Sd, Vn.4S | 0 1 1 01110 0 0 11000 01111 10 Rn Rd0x6E30F800 / Maske 0xFFFFFC00 | Maximum aller Gleitkomma-ElementeSd = max of all elements of VnVektor (SIMD) |
| fmin | Fd, Fn, Fm | 0 0 0 11110 ftype 1 Rm 0101 10 Rn Rd0x1E205800 / Maske 0xFF20FC00 | Minimum (NaN breitet sich aus)Fd = min(Fn, Fm)Gleitkomma (skalar) |
| Vd.T, Vn.T, Vm.T | 0 Q 0 01110 1 sz 1 Rm 11110 1 Rn Rd0x0EA0F400 / Maske 0xBFA0FC00 | Minimum von Gleitkomma-Elementenfor every element: Vd[i] = min(Vn[i], Vm[i])Vektor (SIMD) | |
| fminnm | Fd, Fn, Fm | 0 0 0 11110 ftype 1 Rm 0111 10 Rn Rd0x1E207800 / Maske 0xFF20FC00 | Minimum (eine Zahl gewinnt gegen NaN)Fd = minnum(Fn, Fm)Gleitkomma (skalar) |
| Vd.T, Vn.T, Vm.T | 0 Q 0 01110 1 sz 1 Rm 11000 1 Rn Rd0x0EA0C400 / Maske 0xBFA0FC00 | Minimum von Gleitkomma-Elementen (eine Zahl gewinnt gegen NaN)for every element: Vd[i] = minnum(Vn[i], Vm[i])Vektor (SIMD) | |
| fminnmp | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 1 sz 1 Rm 11000 1 Rn Rd0x2EA0C400 / Maske 0xBFA0FC00 | Minimum benachbarter Gleitkomma-Paare (eine Zahl gewinnt gegen NaN)for every element: Vd[i] = minnum of each pair of (Vn:Vm)Vektor (SIMD) |
| fminnmv | Sd, Vn.4S | 0 1 1 01110 1 0 11000 01100 10 Rn Rd0x6EB0C800 / Maske 0xFFFFFC00 | Minimum aller Gleitkomma-Elemente (eine Zahl gewinnt gegen NaN)Sd = minnum of all elements of VnVektor (SIMD) |
| fminp | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 1 sz 1 Rm 11110 1 Rn Rd0x2EA0F400 / Maske 0xBFA0FC00 | Minimum benachbarter Gleitkomma-Paarefor every element: Vd[i] = min of each pair of (Vn:Vm)Vektor (SIMD) |
| fminv | Sd, Vn.4S | 0 1 1 01110 1 0 11000 01111 10 Rn Rd0x6EB0F800 / Maske 0xFFFFFC00 | Minimum aller Gleitkomma-ElementeSd = min of all elements of VnVektor (SIMD) |
| fmla | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 0 sz 1 Rm 11001 1 Rn Rd0x0E20CC00 / Maske 0xBFA0FC00 | Multiplikation mit Addition zum Ziel (Gleitkomma)for every element: Vd[i] = Vd[i] + Vn[i] * Vm[i]Vektor (SIMD) |
| Vd.T, Vn.T, Vm.Ts[index] | 0 Q 0 01111 1 sz L M Rm 0001 H 0 Rn Rd0x0F801000 / Maske 0xBF80F400 | Gleitkomma-Multiplikation mit einem Element, addiert zum Zielfor every element: Vd[i] = Vd[i] + Vn[i] * Vm[index]Vektor (SIMD) | |
| fmlal | Vd.2S, Vn.2H, Vm.2H | 0 Q 0 01110 0 0 1 Rm 11101 1 Rn Rd0x0E20EC00 / Maske 0xBFE0FC00 | Multiplikation von Halbwert-Zahlen mit Verbreiterung auf Single, addiert zum Ziel (untere Hälfte)for every element: Vd[i] = Vd[i] + float(Vn[i]) * float(Vm[i])Vektor (SIMD) |
| fmlal2 | Vd.2S, Vn.2H, Vm.2H | 0 Q 1 01110 0 0 1 Rm 11001 1 Rn Rd0x2E20CC00 / Maske 0xBFE0FC00 | Wie fmlal, aber mit der oberen Hälfte der Quellenfor every element: Vd[i] = Vd[i] + float(Vn[i + n]) * float(Vm[i + n])Vektor (SIMD) |
| fmls | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 1 sz 1 Rm 11001 1 Rn Rd0x0EA0CC00 / Maske 0xBFA0FC00 | Multiplikation mit Subtraktion vom Ziel (Gleitkomma)for every element: Vd[i] = Vd[i] - Vn[i] * Vm[i]Vektor (SIMD) |
| Vd.T, Vn.T, Vm.Ts[index] | 0 Q 0 01111 1 sz L M Rm 0101 H 0 Rn Rd0x0F805000 / Maske 0xBF80F400 | Gleitkomma-Multiplikation mit einem Element, subtrahiert vom Zielfor every element: Vd[i] = Vd[i] - Vn[i] * Vm[index]Vektor (SIMD) | |
| fmlsl | Vd.2S, Vn.2H, Vm.2H | 0 Q 0 01110 1 0 1 Rm 11101 1 Rn Rd0x0EA0EC00 / Maske 0xBFE0FC00 | Multiplikation von Halbwert-Zahlen mit Verbreiterung auf Single, subtrahiert vom Ziel (untere Hälfte)for every element: Vd[i] = Vd[i] - float(Vn[i]) * float(Vm[i])Vektor (SIMD) |
| fmlsl2 | Vd.2S, Vn.2H, Vm.2H | 0 Q 1 01110 1 0 1 Rm 11001 1 Rn Rd0x2EA0CC00 / Maske 0xBFE0FC00 | Wie fmlsl, aber mit der oberen Hälfte der Quellenfor every element: Vd[i] = Vd[i] - float(Vn[i + n]) * float(Vm[i + n])Vektor (SIMD) |
| fmov | Fd, Fn | 0 0 0 11110 ftype 1 000000 10000 Rn Rd0x1E204000 / Maske 0xFF3FFC00 | Kopieren eines Gleitkomma-RegistersFd = FnGleitkomma (skalar) |
| Fd, #imm | 0 0 0 11110 ftype 1 imm8 100 00000 Rd0x1E201000 / Maske 0xFF201FE0 | Laden einer Gleitkomma-Konstante (8 Bit kodiert: +-n/16 * 2^r)Fd = expand_imm(imm8)Gleitkomma (skalar) | |
| Wd, Sn | 0 0 0 11110 00 1 00 110 000000 Rn Rd0x1E260000 / Maske 0xFFFFFC00 | Bitweises Kopieren eines Single-Registers in ein Ganzzahl-RegisterWd = bits(Sn)Gleitkomma (skalar) | |
| Sd, Wn | 0 0 0 11110 00 1 00 111 000000 Rn Rd0x1E270000 / Maske 0xFFFFFC00 | Bitweises Kopieren eines Ganzzahl-Registers in ein Single-RegisterSd = bits(Wn)Gleitkomma (skalar) | |
| Xd, Dn | 1 0 0 11110 01 1 00 110 000000 Rn Rd0x9E660000 / Maske 0xFFFFFC00 | Bitweises Kopieren eines Double-Registers in ein Ganzzahl-RegisterXd = bits(Dn)Gleitkomma (skalar) | |
| Dd, Xn | 1 0 0 11110 01 1 00 111 000000 Rn Rd0x9E670000 / Maske 0xFFFFFC00 | Bitweises Kopieren eines Ganzzahl-Registers in ein Double-RegisterDd = bits(Xn)Gleitkomma (skalar) | |
| Vd.T, #imm8{, lsl #amount} | 0 Q 0 0111100000 abc 1111 01 defgh Rd0x0F00F400 / Maske 0xBFF8FC00 | Laden einer Gleitkomma-Konstante (Single) in alle ElementeVd = fp_const(imm8)Vektor (SIMD) | |
| Vd.T, #imm8{, lsl #amount} | 0 Q 1 0111100000 abc 1111 01 defgh Rd0x2F00F400 / Maske 0xBFF8FC00 | Laden einer Gleitkomma-Konstante (Double) in beide HälftenVd = fp_const(imm8)Vektor (SIMD) | |
| fmsub | Fd, Fn, Fm, Fa | 0 0 0 11111 ftype 0 Rm 1 Ra Rn Rd0x1F008000 / Maske 0xFF208000 | Multiplikation mit Subtraktion (verschmolzen, Fa - Fn * Fm)Fd = Fa - Fn * FmGleitkomma (skalar) |
| fmul | Fd, Fn, Fm | 0 0 0 11110 ftype 1 Rm 0000 10 Rn Rd0x1E200800 / Maske 0xFF20FC00 | MultiplikationFd = Fn * FmGleitkomma (skalar) |
| Vd.T, Vn.T, Vm.T | 0 Q 1 01110 0 sz 1 Rm 11011 1 Rn Rd0x2E20DC00 / Maske 0xBFA0FC00 | Multiplikation von Gleitkomma-Elementenfor every element: Vd[i] = Vn[i] * Vm[i]Vektor (SIMD) | |
| Vd.T, Vn.T, Vm.Ts[index] | 0 Q 0 01111 1 sz L M Rm 1001 H 0 Rn Rd0x0F809000 / Maske 0xBF80F400 | Gleitkomma-Multiplikation mit einem Elementfor every element: Vd[i] = Vn[i] * Vm[index]Vektor (SIMD) | |
| fmulx | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 0 sz 1 Rm 11011 1 Rn Rd0x0E20DC00 / Maske 0xBFA0FC00 | Multiplikation von Gleitkomma-Elementen (0 mal unendlich ergibt 2)for every element: Vd[i] = Vn[i] * Vm[i]Vektor (SIMD) |
| Vd.T, Vn.T, Vm.Ts[index] | 0 Q 1 01111 1 sz L M Rm 1001 H 0 Rn Rd0x2F809000 / Maske 0xBF80F400 | Gleitkomma-Multiplikation mit einem Element (0 mal unendlich ergibt 2)for every element: Vd[i] = Vn[i] * Vm[index]Vektor (SIMD) | |
| fneg | Fd, Fn | 0 0 0 11110 ftype 1 000010 10000 Rn Rd0x1E214000 / Maske 0xFF3FFC00 | VorzeichenwechselFd = -FnGleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 1 01110 1 sz 10000 01111 10 Rn Rd0x2EA0F800 / Maske 0xBFBFFC00 | Vorzeichenwechsel von Gleitkomma-Elementenfor every element: Vd[i] = -Vn[i]Vektor (SIMD) | |
| fnmadd | Fd, Fn, Fm, Fa | 0 0 0 11111 ftype 1 Rm 0 Ra Rn Rd0x1F200000 / Maske 0xFF208000 | Negierte Multiplikation mit Addition (verschmolzen)Fd = -Fa - Fn * FmGleitkomma (skalar) |
| fnmsub | Fd, Fn, Fm, Fa | 0 0 0 11111 ftype 1 Rm 1 Ra Rn Rd0x1F208000 / Maske 0xFF208000 | Negierte Multiplikation mit Subtraktion (verschmolzen)Fd = -Fa + Fn * FmGleitkomma (skalar) |
| fnmul | Fd, Fn, Fm | 0 0 0 11110 ftype 1 Rm 1000 10 Rn Rd0x1E208800 / Maske 0xFF20FC00 | Multiplikation mit VorzeichenwechselFd = -(Fn * Fm)Gleitkomma (skalar) |
| frecpe | Vd.T, Vn.T | 0 Q 0 01110 1 sz 10000 11101 10 Rn Rd0x0EA1D800 / Maske 0xBFBFFC00 | Schätzung des Kehrwertesfor every element: Vd[i] = estimate(1 / Vn[i])Vektor (SIMD) |
| frecps | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 0 sz 1 Rm 11111 1 Rn Rd0x0E20FC00 / Maske 0xBFA0FC00 | Schritt der Newton-Raphson-Iteration für den Kehrwertfor every element: Vd[i] = 2 - Vn[i] * Vm[i]Vektor (SIMD) |
| frecpx | Fd, Fn | 01 0 11110 1 sz 10000 11111 10 Rn Rd0x5EA1F800 / Maske 0xFFBFFC00 | Schätzung des Kehrwertes eines Exponenten (skalar)Fd = reciprocal_exponent(Fn)Gleitkomma (skalar) |
| frint32x | Vd.T, Vn.T | 0 Q 1 01110 0 sz 10000 11110 10 Rn Rd0x2E21E800 / Maske 0xBFBFFC00 | Runden auf eine ganze Zahl, die in 32 Bit passt (nach dem aktuellen Rundungsmodus)for every element: Vd[i] = round32(Vn[i])Vektor (SIMD) |
| frint32z | Vd.T, Vn.T | 0 Q 0 01110 0 sz 10000 11110 10 Rn Rd0x0E21E800 / Maske 0xBFBFFC00 | Runden auf eine ganze Zahl, die in 32 Bit passt (Richtung null)for every element: Vd[i] = trunc32(Vn[i])Vektor (SIMD) |
| frint64x | Vd.T, Vn.T | 0 Q 1 01110 0 sz 10000 11111 10 Rn Rd0x2E21F800 / Maske 0xBFBFFC00 | Runden auf eine ganze Zahl, die in 64 Bit passt (nach dem aktuellen Rundungsmodus)for every element: Vd[i] = round64(Vn[i])Vektor (SIMD) |
| frint64z | Vd.T, Vn.T | 0 Q 0 01110 0 sz 10000 11111 10 Rn Rd0x0E21F800 / Maske 0xBFBFFC00 | Runden auf eine ganze Zahl, die in 64 Bit passt (Richtung null)for every element: Vd[i] = trunc64(Vn[i])Vektor (SIMD) |
| frinta | Fd, Fn | 0 0 0 11110 ftype 1 001100 10000 Rn Rd0x1E264000 / Maske 0xFF3FFC00 | Runden auf eine ganze Zahl (zur nächsten, bei Gleichstand weg von null)Fd = round_half_away(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 1 01110 0 sz 10000 11000 10 Rn Rd0x2E218800 / Maske 0xBFBFFC00 | Runden auf eine ganze Zahl (zur nächsten, bei Gleichstand weg von null)for every element: Vd[i] = round_half_away(Vn[i])Vektor (SIMD) | |
| frinti | Fd, Fn | 0 0 0 11110 ftype 1 001111 10000 Rn Rd0x1E27C000 / Maske 0xFF3FFC00 | Runden auf eine ganze Zahl (Modus des Steuerregisters)Fd = round(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 1 01110 1 sz 10000 11001 10 Rn Rd0x2EA19800 / Maske 0xBFBFFC00 | Runden auf eine ganze Zahl (nach dem aktuellen Rundungsmodus)for every element: Vd[i] = round(Vn[i])Vektor (SIMD) | |
| frintm | Fd, Fn | 0 0 0 11110 ftype 1 001010 10000 Rn Rd0x1E254000 / Maske 0xFF3FFC00 | Runden auf eine ganze Zahl (Richtung minus unendlich)Fd = floor(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 0 01110 0 sz 10000 11001 10 Rn Rd0x0E219800 / Maske 0xBFBFFC00 | Runden auf eine ganze Zahl (Richtung minus unendlich)for every element: Vd[i] = floor(Vn[i])Vektor (SIMD) | |
| frintn | Fd, Fn | 0 0 0 11110 ftype 1 001000 10000 Rn Rd0x1E244000 / Maske 0xFF3FFC00 | Runden auf eine ganze Zahl (zur nächsten, gerade bei Gleichstand)Fd = round_to_nearest_even(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 0 01110 0 sz 10000 11000 10 Rn Rd0x0E218800 / Maske 0xBFBFFC00 | Runden auf eine ganze Zahl (zur nächsten, gerade bei Gleichstand)for every element: Vd[i] = round_to_nearest_even(Vn[i])Vektor (SIMD) | |
| frintp | Fd, Fn | 0 0 0 11110 ftype 1 001001 10000 Rn Rd0x1E24C000 / Maske 0xFF3FFC00 | Runden auf eine ganze Zahl (Richtung plus unendlich)Fd = ceil(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 0 01110 1 sz 10000 11000 10 Rn Rd0x0EA18800 / Maske 0xBFBFFC00 | Runden auf eine ganze Zahl (Richtung plus unendlich)for every element: Vd[i] = ceil(Vn[i])Vektor (SIMD) | |
| frintx | Fd, Fn | 0 0 0 11110 ftype 1 001110 10000 Rn Rd0x1E274000 / Maske 0xFF3FFC00 | Runden auf eine ganze Zahl (Modus des Steuerregisters, meldet Ungenauigkeit)Fd = round(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 1 01110 0 sz 10000 11001 10 Rn Rd0x2E219800 / Maske 0xBFBFFC00 | Runden auf eine ganze Zahl (nach dem aktuellen Rundungsmodus, mit Ausnahme bei Ungenauigkeit)for every element: Vd[i] = round(Vn[i])Vektor (SIMD) | |
| frintz | Fd, Fn | 0 0 0 11110 ftype 1 001011 10000 Rn Rd0x1E25C000 / Maske 0xFF3FFC00 | Runden auf eine ganze Zahl (Richtung null)Fd = trunc(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 0 01110 1 sz 10000 11001 10 Rn Rd0x0EA19800 / Maske 0xBFBFFC00 | Runden auf eine ganze Zahl (Richtung null)for every element: Vd[i] = trunc(Vn[i])Vektor (SIMD) | |
| frsqrte | Vd.T, Vn.T | 0 Q 1 01110 1 sz 10000 11101 10 Rn Rd0x2EA1D800 / Maske 0xBFBFFC00 | Schätzung des reziproken Wurzelwertesfor every element: Vd[i] = estimate(1 / sqrt(Vn[i]))Vektor (SIMD) |
| frsqrts | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 1 sz 1 Rm 11111 1 Rn Rd0x0EA0FC00 / Maske 0xBFA0FC00 | Schritt der Newton-Raphson-Iteration für den reziproken Wurzelwertfor every element: Vd[i] = (3 - Vn[i] * Vm[i]) / 2Vektor (SIMD) |
| fsqrt | Fd, Fn | 0 0 0 11110 ftype 1 000011 10000 Rn Rd0x1E21C000 / Maske 0xFF3FFC00 | QuadratwurzelFd = sqrt(Fn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 1 01110 1 sz 10000 11111 10 Rn Rd0x2EA1F800 / Maske 0xBFBFFC00 | Quadratwurzel von Gleitkomma-Elementenfor every element: Vd[i] = sqrt(Vn[i])Vektor (SIMD) | |
| fsub | Fd, Fn, Fm | 0 0 0 11110 ftype 1 Rm 0011 10 Rn Rd0x1E203800 / Maske 0xFF20FC00 | SubtraktionFd = Fn - FmGleitkomma (skalar) |
| Vd.T, Vn.T, Vm.T | 0 Q 0 01110 1 sz 1 Rm 11010 1 Rn Rd0x0EA0D400 / Maske 0xBFA0FC00 | Subtraktion von Gleitkomma-Elementenfor every element: Vd[i] = Vn[i] - Vm[i]Vektor (SIMD) | |
| gmi | Xd, Xn|SP, Xm | 1 0 0 11010110 Rm 000101 Rn Rd0x9AC01400 / Maske 0xFFE0FC00 | Aufnahme eines Tags in eine AusschlussmaskeXd = Xm | (1 << tag of Xn)Speicher-Tagging (MTE) |
| hint | #imm7auch: nop, yield, wfe, wfi, sev, sevl, bti, csdb, esb, psb, tsb | 1101010100 0 00 011 0010 CRm op2 111110xD503201F / Maske 0xFFFFF01F | Hinweis an den Prozessor (nop, yield, wfe, wfi, sev, bti ...)no change of the program (a hint)System und Privilegien |
| hlt | #imm16 | 11010100 010 imm16 000 000xD4400000 / Maske 0xFFE0001F | Anhalten für einen Debuggerenter debug stateSystem und Privilegien |
| hvc | #imm16 | 11010100 000 imm16 000 100xD4000002 / Maske 0xFFE0001F | Aufruf des Hypervisors (Ausnahmestufe 2)raise a hypervisor call exceptionSystem und Privilegien |
| ins | Vd.Ts[index], Rnauch: mov | 0 1 0 01110000 imm5 0 0011 1 Rn Rd0x4E001C00 / Maske 0xFFE0FC00 | Einfügen eines Ganzzahl-Registers in ein ElementVd[index] = RnVektor (SIMD) |
| irg | Xd|SP, Xn|SP{, Xm} | 1 0 0 11010110 Rm 000100 Rn Rd0x9AC01000 / Maske 0xFFE0FC00 | Einfügen eines zufälligen Tags in eine AdresseXd = Xn with a random tag (not in the exclude mask Xm)Speicher-Tagging (MTE) |
| isb | {#imm4} | 1101010100 0 00 011 0011 CRm 1 10 111110xD50330DF / Maske 0xFFFFF0FF | Befehlsschranke: leert die Pipelineall instructions after it are fetched anewSystem und Privilegien |
| ld1 | {Vt.T}, [Xn|SP] | 0 Q 0011000 1 000000 0111 size Rn Rt0x0C407000 / Maske 0xBFFFF000 | Laden eines Vektor-Registers aus dem Speicher (ein Register)Vt = [Rn]Vektor (SIMD) |
| {Vt.T, Vt2.T}, [Xn|SP] | 0 Q 0011000 1 000000 1010 size Rn Rt0x0C40A000 / Maske 0xBFFFF000 | Laden von 2 Register aus dem Speicherregisters = [Rn] (2 registers)Vektor (SIMD) | |
| {Vt.T, Vt2.T, Vt3.T}, [Xn|SP] | 0 Q 0011000 1 000000 0110 size Rn Rt0x0C406000 / Maske 0xBFFFF000 | Laden von 3 Register aus dem Speicherregisters = [Rn] (3 registers)Vektor (SIMD) | |
| {Vt.T, Vt2.T, Vt3.T, Vt4.T}, [Xn|SP] | 0 Q 0011000 1 000000 0010 size Rn Rt0x0C402000 / Maske 0xBFFFF000 | Laden von 4 Register aus dem Speicherregisters = [Rn] (4 registers)Vektor (SIMD) | |
| {Vt.Ts}[index], [Xn|SP] | 0 Q 0011010 1 0 00000 e 0 S size Rn Rt0x0D400000 / Maske 0xBFFF2000 | Laden eines Elements (Lane) (ein Register)Vt[index] = [Rn]Vektor (SIMD) | |
| ld1r | {Vt.T}, [Xn|SP] | 0 Q 0011010 1 0 00000 110 0 size Rn Rt0x0D40C000 / Maske 0xBFFFF000 | Laden eines Elements aus dem Speicher in alle Elemente von 1 Registern (Replizieren)every element of every register = [Rn]Vektor (SIMD) |
| ld2 | {Vt.T, Vt2.T}, [Xn|SP] | 0 Q 0011000 1 000000 1000 size Rn Rt0x0C408000 / Maske 0xBFFFF000 | Laden von 2 Register (Elemente abwechselnd) aus dem Speicherregisters = [Rn] (2 registers (elements interleaved))Vektor (SIMD) |
| {Vt.T, Vt2.T}, [Xn|SP], Xm|#imm | 0 Q 0011001 1 0 Rm 1000 size Rn Rt0x0CC08000 / Maske 0xBFE0F000 | Laden von 2 Registern (Elemente abwechselnd) mit Nach-Indizierungregisters = [Rn]; Rn = Rn + Xm or the sizeVektor (SIMD) | |
| {Vt.Ts, Vt2.Ts}[index], [Xn|SP] | 0 Q 0011010 1 1 00000 e 0 S size Rn Rt0x0D600000 / Maske 0xBFFF2000 | Laden eines Elements (Lane) von 2 RegisternVt[index] = [Rn]Vektor (SIMD) | |
| ld2r | {Vt.T, Vt2.T}, [Xn|SP] | 0 Q 0011010 1 1 00000 110 0 size Rn Rt0x0D60C000 / Maske 0xBFFFF000 | Laden eines Elements aus dem Speicher in alle Elemente von 2 Registern (Replizieren)every element of every register = [Rn]Vektor (SIMD) |
| ld3 | {Vt.T, Vt2.T, Vt3.T}, [Xn|SP] | 0 Q 0011000 1 000000 0100 size Rn Rt0x0C404000 / Maske 0xBFFFF000 | Laden von 3 Register (Elemente abwechselnd) aus dem Speicherregisters = [Rn] (3 registers (elements interleaved))Vektor (SIMD) |
| {Vt.T, Vt2.T, Vt3.T}, [Xn|SP], Xm|#imm | 0 Q 0011001 1 0 Rm 0100 size Rn Rt0x0CC04000 / Maske 0xBFE0F000 | Laden von 3 Registern (Elemente abwechselnd) mit Nach-Indizierungregisters = [Rn]; Rn = Rn + Xm or the sizeVektor (SIMD) | |
| {Vt.Ts, Vt2.Ts, Vt3.Ts}[index], [Xn|SP] | 0 Q 0011010 1 0 00000 e 1 S size Rn Rt0x0D402000 / Maske 0xBFFF2000 | Laden eines Elements (Lane) von 3 RegisternVt[index] = [Rn]Vektor (SIMD) | |
| ld3r | {Vt.T, Vt2.T, Vt3.T}, [Xn|SP] | 0 Q 0011010 1 0 00000 111 0 size Rn Rt0x0D40E000 / Maske 0xBFFFF000 | Laden eines Elements aus dem Speicher in alle Elemente von 3 Registern (Replizieren)every element of every register = [Rn]Vektor (SIMD) |
| ld4 | {Vt.T, Vt2.T, Vt3.T, Vt4.T}, [Xn|SP] | 0 Q 0011000 1 000000 0000 size Rn Rt0x0C400000 / Maske 0xBFFFF000 | Laden von 4 Register (Elemente abwechselnd) aus dem Speicherregisters = [Rn] (4 registers (elements interleaved))Vektor (SIMD) |
| {Vt.T, Vt2.T, Vt3.T, Vt4.T}, [Xn|SP], Xm|#imm | 0 Q 0011001 1 0 Rm 0000 size Rn Rt0x0CC00000 / Maske 0xBFE0F000 | Laden von 4 Registern (Elemente abwechselnd) mit Nach-Indizierungregisters = [Rn]; Rn = Rn + Xm or the sizeVektor (SIMD) | |
| {Vt.Ts, Vt2.Ts, Vt3.Ts, Vt4.Ts}[index], [Xn|SP] | 0 Q 0011010 1 1 00000 e 1 S size Rn Rt0x0D602000 / Maske 0xBFFF2000 | Laden eines Elements (Lane) von 4 RegisternVt[index] = [Rn]Vektor (SIMD) | |
| ld4r | {Vt.T, Vt2.T, Vt3.T, Vt4.T}, [Xn|SP] | 0 Q 0011010 1 1 00000 111 0 size Rn Rt0x0D60E000 / Maske 0xBFFFF000 | Laden eines Elements aus dem Speicher in alle Elemente von 4 Registern (Replizieren)every element of every register = [Rn]Vektor (SIMD) |
| ldadd | Ws, Wt, [Xn|SP]auch: ldadda, ldaddal, ldaddl, ldaddb, ldaddab, ldaddalb, ldaddlb, ldaddh, ldaddah, ldaddalh, ldaddlh, staddb, staddh, stadd, staddl, staddlb, staddlh | size 111 0 00 A R 1 Rs 0 000 00 Rn Rt0x38200000 / Maske 0x3F20FC00 | Atomare Operation im Speicher: Addition des Speicherwertes und eines Registers, der alte Wert kommt ins Zielregister (Varianten: b = Byte, h = Halbwort, a = Acquire, l = Release, st... ohne Zielregister)t = [Rn]; [Rn] = t + Ws; Wt = tAtomare Speicherzugriffe (LSE) |
| ldapr | Wt, [Xn|SP]auch: ldaprb, ldaprh | size 111 0 00 1 0 1 11111 1 100 00 Rn Rt0x38BFC000 / Maske 0x3FFFFC00 | Laden mit Release-Consistency (Acquire nur für frühere Speicherzugriffe, Variante RCpc; b = Byte, h = Halbwort)Wt = [Rn]Laden und Speichern |
| ldapur | Wt, [Xn|SP{, #imm9}]auch: ldapurb, ldapurh | size 011 001 01 0 imm9 00 Rn Rt0x19400000 / Maske 0x3FE00C00 | Laden mit Acquire (RCpc, ohne Skalierung, Adresse: Rn + imm9; b = Byte, h = Halbwort)Wt = [Rn + imm9]Laden und Speichern |
| ldapursb | Xt, [Xn|SP{, #imm9}]auch: ldapursh, ldapursw | size 011 001 10 0 imm9 00 Rn Rt0x19800000 / Maske 0x3FE00C00 | Laden mit Acquire (RCpc), mit Vorzeichen auf 64 Bit erweitert (b = Byte, h = Halbwort, w = Wort)Xt = sext([Rn + imm9])Laden und Speichern |
| ldar | Wt, [Xn|SP] | 10 001000 1 1 0 11111 1 11111 Rn Rt0x88DFFC00 / Maske 0xFFFFFC00 | Laden mit Erwerb (acquire) (Wort)Rt = [Rn]; acquireLaden und Speichern |
| Xt, [Xn|SP] | 11 001000 1 1 0 11111 1 11111 Rn Rt0xC8DFFC00 / Maske 0xFFFFFC00 | Laden mit Erwerb (acquire) (Doppelwort)Rt = [Rn]; acquireLaden und Speichern | |
| ldarb | Wt, [Xn|SP] | 00 001000 1 1 0 11111 1 11111 Rn Rt0x08DFFC00 / Maske 0xFFFFFC00 | Laden mit Erwerb (acquire) (Byte)Rt = [Rn]; acquireLaden und Speichern |
| ldarh | Wt, [Xn|SP] | 01 001000 1 1 0 11111 1 11111 Rn Rt0x48DFFC00 / Maske 0xFFFFFC00 | Laden mit Erwerb (acquire) (Halbwort)Rt = [Rn]; acquireLaden und Speichern |
| ldaxp | Rt, Rt2, [Xn|SP] | 1 sz 001000 0 1 1 11111 1 Rt2 Rn Rt0x887F8000 / Maske 0xBFFF8000 | Laden eines Registerpaares (exklusiv) mit ErwerbRt = [Rn]; Rt2 = [Rn + size]; acquire; set the exclusive monitorLaden und Speichern |
| ldaxr | Wt, [Xn|SP] | 10 001000 0 1 0 11111 1 11111 Rn Rt0x885FFC00 / Maske 0xFFFFFC00 | Laden (exklusiv) mit Erwerb (acquire) (Wort)Rt = [Rn]; acquire; set the exclusive monitorLaden und Speichern |
| Xt, [Xn|SP] | 11 001000 0 1 0 11111 1 11111 Rn Rt0xC85FFC00 / Maske 0xFFFFFC00 | Laden (exklusiv) mit Erwerb (acquire) (Doppelwort)Rt = [Rn]; acquire; set the exclusive monitorLaden und Speichern | |
| ldaxrb | Wt, [Xn|SP] | 00 001000 0 1 0 11111 1 11111 Rn Rt0x085FFC00 / Maske 0xFFFFFC00 | Laden (exklusiv) mit Erwerb (acquire) (Byte)Rt = [Rn]; acquire; set the exclusive monitorLaden und Speichern |
| ldaxrh | Wt, [Xn|SP] | 01 001000 0 1 0 11111 1 11111 Rn Rt0x485FFC00 / Maske 0xFFFFFC00 | Laden (exklusiv) mit Erwerb (acquire) (Halbwort)Rt = [Rn]; acquire; set the exclusive monitorLaden und Speichern |
| ldclr | Ws, Wt, [Xn|SP]auch: ldclra, ldclral, ldclrl, ldclrb, ldclrab, ldclralb, ldclrlb, ldclrh, ldclrah, ldclralh, ldclrlh, stclrb, stclrh, stclr, stclrl, stclrlb, stclrlh | size 111 0 00 A R 1 Rs 0 001 00 Rn Rt0x38201000 / Maske 0x3F20FC00 | Atomare Operation im Speicher: Löschen von Bits (UND mit dem invertierten Operanden) des Speicherwertes und eines Registers, der alte Wert kommt ins Zielregister (Varianten: b = Byte, h = Halbwort, a = Acquire, l = Release, st... ohne Zielregister)t = [Rn]; [Rn] = t & ~Ws; Wt = tAtomare Speicherzugriffe (LSE) |
| ldeor | Ws, Wt, [Xn|SP]auch: ldeora, ldeoral, ldeorl, ldeorb, ldeorab, ldeoralb, ldeorlb, ldeorh, ldeorah, ldeoralh, ldeorlh, steorb, steorh, steor, steorl, steorlb, steorlh | size 111 0 00 A R 1 Rs 0 010 00 Rn Rt0x38202000 / Maske 0x3F20FC00 | Atomare Operation im Speicher: exklusives ODER des Speicherwertes und eines Registers, der alte Wert kommt ins Zielregister (Varianten: b = Byte, h = Halbwort, a = Acquire, l = Release, st... ohne Zielregister)t = [Rn]; [Rn] = t ^ Ws; Wt = tAtomare Speicherzugriffe (LSE) |
| ldg | Xt, [Xn|SP{, #imm9}] | 11011001 011 imm9 00 Rn Rt0xD9600000 / Maske 0xFFE00C00 | Laden des Tags aus dem Speicher in eine AdresseXt = Xt with tag of [Rn + imm9 * 16]Speicher-Tagging (MTE) |
| ldlar | Wt, [Xn|SP]auch: ldlarb, ldlarh | size 001000 1 1 0 11111 0 11111 Rn Rt0x08DF7C00 / Maske 0x3FFFFC00 | Laden mit Acquire für eine Speicher-Region mit Ordnung (LORegion; b = Byte, h = Halbwort)Wt = [Rn]Laden und Speichern |
| ldnp | Rt, Rt2, [Xn|SP{, #imm7}] | sf 0 101 0 000 1 imm7 Rt2 Rn Rt0x28400000 / Maske 0x7FC00000 | Laden eines Registerpaares ohne Cache-HinweisRt = [addr]; Rt2 = [addr + size]Laden und Speichern |
| ldp | Rt, Rt2, [Xn|SP], #imm7 | sf 0 101 0 001 1 imm7 Rt2 Rn Rt0x28C00000 / Maske 0x7FC00000 | Laden eines Registerpaares (Nach-Indizierung)Rt = [addr]; Rt2 = [addr + size]; addr = Rn; Rn = Rn + imm7 * sizeLaden und Speichern |
| Rt, Rt2, [Xn|SP{, #imm7}] | sf 0 101 0 010 1 imm7 Rt2 Rn Rt0x29400000 / Maske 0x7FC00000 | Laden eines RegisterpaaresRt = [addr]; Rt2 = [addr + size]; addr = Rn + imm7 * sizeLaden und Speichern | |
| Rt, Rt2, [Xn|SP, #imm7]! | sf 0 101 0 011 1 imm7 Rt2 Rn Rt0x29C00000 / Maske 0x7FC00000 | Laden eines Registerpaares (Vor-Indizierung)Rt = [addr]; Rt2 = [addr + size]; Rn = Rn + imm7 * size; addr = RnLaden und Speichern | |
| Ft, Ft2, [Xn|SP{, #imm7}] | opc 101 1 010 1 imm7 Rt2 Rn Rt0x2D400000 / Maske 0x3FC00000 | Laden eines Paares von Gleitkomma-/Vektor-Registern (opc 00 = S, 01 = D, 10 = Q)Ft = [addr]; Ft2 = [addr + size]Laden und Speichern | |
| ldpsw | Xt, Xt2, [Xn|SP], #imm7 | 01 101 0 001 1 imm7 Rt2 Rn Rt0x68C00000 / Maske 0xFFC00000 | Laden eines Paares von Wörtern mit Vorzeichen (Nach-Indizierung)Xt = sext([addr]); Xt2 = sext([addr + 4]); addr = Rn; Rn = Rn + imm7 * 4Laden und Speichern |
| Xt, Xt2, [Xn|SP{, #imm7}] | 01 101 0 010 1 imm7 Rt2 Rn Rt0x69400000 / Maske 0xFFC00000 | Laden eines Paares von Wörtern mit VorzeichenXt = sext([addr]); Xt2 = sext([addr + 4]); addr = Rn + imm7 * 4Laden und Speichern | |
| Xt, Xt2, [Xn|SP, #imm7]! | 01 101 0 011 1 imm7 Rt2 Rn Rt0x69C00000 / Maske 0xFFC00000 | Laden eines Paares von Wörtern mit Vorzeichen (Vor-Indizierung)Xt = sext([addr]); Xt2 = sext([addr + 4]); Rn = Rn + imm7 * 4; addr = RnLaden und Speichern | |
| ldr | Wt, [Xn|SP{, #imm12}] | 10 111 0 01 01 imm12 Rn Rt0xB9400000 / Maske 0xFFC00000 | Laden eines Wortes (32 Bit) (Adresse: Rn + imm12 * Größe)Wt = [addr]; addr = Rn + imm12 * sizeLaden und Speichern |
| Wt, [Xn|SP, #imm9]! | 10 111 0 00 01 0 imm9 11 Rn Rt0xB8400C00 / Maske 0xFFE00C00 | Laden eines Wortes (32 Bit) (Vor-Indizierung: Rn wird zuerst geändert)Wt = [addr]; Rn = Rn + imm9; addr = RnLaden und Speichern | |
| Wt, [Xn|SP], #imm9 | 10 111 0 00 01 0 imm9 01 Rn Rt0xB8400400 / Maske 0xFFE00C00 | Laden eines Wortes (32 Bit) (Nach-Indizierung: Rn wird danach geändert)Wt = [addr]; addr = Rn; Rn = Rn + imm9Laden und Speichern | |
| Wt, [Xn|SP, Rm{, extend {#amount}}] | 10 111 0 00 01 1 Rm option S 10 Rn Rt0xB8600800 / Maske 0xFFE00C00 | Laden eines Wortes (32 Bit) (Adresse: Rn + Register, erweitert und verschoben)Wt = [addr]; addr = Rn + extend(Rm) << (S * log2(size))Laden und Speichern | |
| Xt, [Xn|SP{, #imm12}] | 11 111 0 01 01 imm12 Rn Rt0xF9400000 / Maske 0xFFC00000 | Laden eines Doppelwortes (64 Bit) (Adresse: Rn + imm12 * Größe)Xt = [addr]; addr = Rn + imm12 * sizeLaden und Speichern | |
| Xt, [Xn|SP, #imm9]! | 11 111 0 00 01 0 imm9 11 Rn Rt0xF8400C00 / Maske 0xFFE00C00 | Laden eines Doppelwortes (64 Bit) (Vor-Indizierung: Rn wird zuerst geändert)Xt = [addr]; Rn = Rn + imm9; addr = RnLaden und Speichern | |
| Xt, [Xn|SP], #imm9 | 11 111 0 00 01 0 imm9 01 Rn Rt0xF8400400 / Maske 0xFFE00C00 | Laden eines Doppelwortes (64 Bit) (Nach-Indizierung: Rn wird danach geändert)Xt = [addr]; addr = Rn; Rn = Rn + imm9Laden und Speichern | |
| Xt, [Xn|SP, Rm{, extend {#amount}}] | 11 111 0 00 01 1 Rm option S 10 Rn Rt0xF8600800 / Maske 0xFFE00C00 | Laden eines Doppelwortes (64 Bit) (Adresse: Rn + Register, erweitert und verschoben)Xt = [addr]; addr = Rn + extend(Rm) << (S * log2(size))Laden und Speichern | |
| Wt, label | 00 011 0 00 imm19 Rt0x18000000 / Maske 0xFF000000 | Laden eines Wortes relativ zum Befehlszeiger (+-1 MB)Wt = [pc + sext(imm19 << 2)]Laden und Speichern | |
| Xt, label | 01 011 0 00 imm19 Rt0x58000000 / Maske 0xFF000000 | Laden eines Doppelwortes relativ zum Befehlszeiger (+-1 MB)Xt = [pc + sext(imm19 << 2)]Laden und Speichern | |
| Ft, [Xn|SP{, #imm12}] | 1 x 111 1 01 01 imm12 Rn Rt0xBD400000 / Maske 0xBFC00000 | Laden eines Single- (x=0) oder Double-Registers (x=1)Ft = [Rn + imm12 * size]Laden und Speichern | |
| Qt, [Xn|SP{, #imm12}] | 00 111 1 01 11 imm12 Rn Rt0x3DC00000 / Maske 0xFFC00000 | Laden eines 128-Bit-Vektor-RegistersQt = [Rn + imm12 * 16]Laden und Speichern | |
| ldraa | Xt, [Xn|SP{, #simm10}]auch: ldrab | 11 111 0 00 M S 1 imm9 W 1 Rn Rt0xF8200400 / Maske 0xFF200400 | Laden mit geprüfter Basisadresse (a = Schlüssel A, b = Schlüssel B; optional mit Vor-Indizierung)Xt = [aut(Xn, key, 0) + simm10 * 8]Zeigerauthentifizierung (PAC) |
| ldrb | Wt, [Xn|SP{, #imm12}] | 00 111 0 01 01 imm12 Rn Rt0x39400000 / Maske 0xFFC00000 | Laden eines Bytes (mit Nullen erweitert) (Adresse: Rn + imm12 * Größe)Wt = zext([addr]); addr = Rn + imm12 * sizeLaden und Speichern |
| Wt, [Xn|SP, #imm9]! | 00 111 0 00 01 0 imm9 11 Rn Rt0x38400C00 / Maske 0xFFE00C00 | Laden eines Bytes (mit Nullen erweitert) (Vor-Indizierung: Rn wird zuerst geändert)Wt = zext([addr]); Rn = Rn + imm9; addr = RnLaden und Speichern | |
| Wt, [Xn|SP], #imm9 | 00 111 0 00 01 0 imm9 01 Rn Rt0x38400400 / Maske 0xFFE00C00 | Laden eines Bytes (mit Nullen erweitert) (Nach-Indizierung: Rn wird danach geändert)Wt = zext([addr]); addr = Rn; Rn = Rn + imm9Laden und Speichern | |
| Wt, [Xn|SP, Rm{, extend {#amount}}] | 00 111 0 00 01 1 Rm option S 10 Rn Rt0x38600800 / Maske 0xFFE00C00 | Laden eines Bytes (mit Nullen erweitert) (Adresse: Rn + Register, erweitert und verschoben)Wt = zext([addr]); addr = Rn + extend(Rm) << (S * log2(size))Laden und Speichern | |
| ldrh | Wt, [Xn|SP{, #imm12}] | 01 111 0 01 01 imm12 Rn Rt0x79400000 / Maske 0xFFC00000 | Laden eines Halbwortes (mit Nullen erweitert) (Adresse: Rn + imm12 * Größe)Wt = zext([addr]); addr = Rn + imm12 * sizeLaden und Speichern |
| Wt, [Xn|SP, #imm9]! | 01 111 0 00 01 0 imm9 11 Rn Rt0x78400C00 / Maske 0xFFE00C00 | Laden eines Halbwortes (mit Nullen erweitert) (Vor-Indizierung: Rn wird zuerst geändert)Wt = zext([addr]); Rn = Rn + imm9; addr = RnLaden und Speichern | |
| Wt, [Xn|SP], #imm9 | 01 111 0 00 01 0 imm9 01 Rn Rt0x78400400 / Maske 0xFFE00C00 | Laden eines Halbwortes (mit Nullen erweitert) (Nach-Indizierung: Rn wird danach geändert)Wt = zext([addr]); addr = Rn; Rn = Rn + imm9Laden und Speichern | |
| Wt, [Xn|SP, Rm{, extend {#amount}}] | 01 111 0 00 01 1 Rm option S 10 Rn Rt0x78600800 / Maske 0xFFE00C00 | Laden eines Halbwortes (mit Nullen erweitert) (Adresse: Rn + Register, erweitert und verschoben)Wt = zext([addr]); addr = Rn + extend(Rm) << (S * log2(size))Laden und Speichern | |
| ldrsb | Xt, [Xn|SP{, #imm12}] | 00 111 0 01 10 imm12 Rn Rt0x39800000 / Maske 0xFFC00000 | Laden eines Bytes (mit Vorzeichen auf 64 Bit erweitert) (Adresse: Rn + imm12 * Größe)Xt = sext([addr]); addr = Rn + imm12 * sizeLaden und Speichern |
| Xt, [Xn|SP, #imm9]! | 00 111 0 00 10 0 imm9 11 Rn Rt0x38800C00 / Maske 0xFFE00C00 | Laden eines Bytes (mit Vorzeichen auf 64 Bit erweitert) (Vor-Indizierung: Rn wird zuerst geändert)Xt = sext([addr]); Rn = Rn + imm9; addr = RnLaden und Speichern | |
| Xt, [Xn|SP], #imm9 | 00 111 0 00 10 0 imm9 01 Rn Rt0x38800400 / Maske 0xFFE00C00 | Laden eines Bytes (mit Vorzeichen auf 64 Bit erweitert) (Nach-Indizierung: Rn wird danach geändert)Xt = sext([addr]); addr = Rn; Rn = Rn + imm9Laden und Speichern | |
| Xt, [Xn|SP, Rm{, extend {#amount}}] | 00 111 0 00 10 1 Rm option S 10 Rn Rt0x38A00800 / Maske 0xFFE00C00 | Laden eines Bytes (mit Vorzeichen auf 64 Bit erweitert) (Adresse: Rn + Register, erweitert und verschoben)Xt = sext([addr]); addr = Rn + extend(Rm) << (S * log2(size))Laden und Speichern | |
| Wt, [Xn|SP{, #imm12}] | 00 111 0 01 11 imm12 Rn Rt0x39C00000 / Maske 0xFFC00000 | Laden eines Bytes (mit Vorzeichen auf 32 Bit erweitert) (Adresse: Rn + imm12 * Größe)Wt = sext([addr]); addr = Rn + imm12 * sizeLaden und Speichern | |
| Wt, [Xn|SP, #imm9]! | 00 111 0 00 11 0 imm9 11 Rn Rt0x38C00C00 / Maske 0xFFE00C00 | Laden eines Bytes (mit Vorzeichen auf 32 Bit erweitert) (Vor-Indizierung: Rn wird zuerst geändert)Wt = sext([addr]); Rn = Rn + imm9; addr = RnLaden und Speichern | |
| Wt, [Xn|SP], #imm9 | 00 111 0 00 11 0 imm9 01 Rn Rt0x38C00400 / Maske 0xFFE00C00 | Laden eines Bytes (mit Vorzeichen auf 32 Bit erweitert) (Nach-Indizierung: Rn wird danach geändert)Wt = sext([addr]); addr = Rn; Rn = Rn + imm9Laden und Speichern | |
| Wt, [Xn|SP, Rm{, extend {#amount}}] | 00 111 0 00 11 1 Rm option S 10 Rn Rt0x38E00800 / Maske 0xFFE00C00 | Laden eines Bytes (mit Vorzeichen auf 32 Bit erweitert) (Adresse: Rn + Register, erweitert und verschoben)Wt = sext([addr]); addr = Rn + extend(Rm) << (S * log2(size))Laden und Speichern | |
| ldrsh | Xt, [Xn|SP{, #imm12}] | 01 111 0 01 10 imm12 Rn Rt0x79800000 / Maske 0xFFC00000 | Laden eines Halbwortes (mit Vorzeichen auf 64 Bit erweitert) (Adresse: Rn + imm12 * Größe)Xt = sext([addr]); addr = Rn + imm12 * sizeLaden und Speichern |
| Xt, [Xn|SP, #imm9]! | 01 111 0 00 10 0 imm9 11 Rn Rt0x78800C00 / Maske 0xFFE00C00 | Laden eines Halbwortes (mit Vorzeichen auf 64 Bit erweitert) (Vor-Indizierung: Rn wird zuerst geändert)Xt = sext([addr]); Rn = Rn + imm9; addr = RnLaden und Speichern | |
| Xt, [Xn|SP], #imm9 | 01 111 0 00 10 0 imm9 01 Rn Rt0x78800400 / Maske 0xFFE00C00 | Laden eines Halbwortes (mit Vorzeichen auf 64 Bit erweitert) (Nach-Indizierung: Rn wird danach geändert)Xt = sext([addr]); addr = Rn; Rn = Rn + imm9Laden und Speichern | |
| Xt, [Xn|SP, Rm{, extend {#amount}}] | 01 111 0 00 10 1 Rm option S 10 Rn Rt0x78A00800 / Maske 0xFFE00C00 | Laden eines Halbwortes (mit Vorzeichen auf 64 Bit erweitert) (Adresse: Rn + Register, erweitert und verschoben)Xt = sext([addr]); addr = Rn + extend(Rm) << (S * log2(size))Laden und Speichern | |
| Wt, [Xn|SP{, #imm12}] | 01 111 0 01 11 imm12 Rn Rt0x79C00000 / Maske 0xFFC00000 | Laden eines Halbwortes (mit Vorzeichen auf 32 Bit erweitert) (Adresse: Rn + imm12 * Größe)Wt = sext([addr]); addr = Rn + imm12 * sizeLaden und Speichern | |
| Wt, [Xn|SP, #imm9]! | 01 111 0 00 11 0 imm9 11 Rn Rt0x78C00C00 / Maske 0xFFE00C00 | Laden eines Halbwortes (mit Vorzeichen auf 32 Bit erweitert) (Vor-Indizierung: Rn wird zuerst geändert)Wt = sext([addr]); Rn = Rn + imm9; addr = RnLaden und Speichern | |
| Wt, [Xn|SP], #imm9 | 01 111 0 00 11 0 imm9 01 Rn Rt0x78C00400 / Maske 0xFFE00C00 | Laden eines Halbwortes (mit Vorzeichen auf 32 Bit erweitert) (Nach-Indizierung: Rn wird danach geändert)Wt = sext([addr]); addr = Rn; Rn = Rn + imm9Laden und Speichern | |
| Wt, [Xn|SP, Rm{, extend {#amount}}] | 01 111 0 00 11 1 Rm option S 10 Rn Rt0x78E00800 / Maske 0xFFE00C00 | Laden eines Halbwortes (mit Vorzeichen auf 32 Bit erweitert) (Adresse: Rn + Register, erweitert und verschoben)Wt = sext([addr]); addr = Rn + extend(Rm) << (S * log2(size))Laden und Speichern | |
| ldrsw | Xt, [Xn|SP{, #imm12}] | 10 111 0 01 10 imm12 Rn Rt0xB9800000 / Maske 0xFFC00000 | Laden eines Wortes (mit Vorzeichen auf 64 Bit erweitert) (Adresse: Rn + imm12 * Größe)Xt = sext([addr]); addr = Rn + imm12 * sizeLaden und Speichern |
| Xt, [Xn|SP, #imm9]! | 10 111 0 00 10 0 imm9 11 Rn Rt0xB8800C00 / Maske 0xFFE00C00 | Laden eines Wortes (mit Vorzeichen auf 64 Bit erweitert) (Vor-Indizierung: Rn wird zuerst geändert)Xt = sext([addr]); Rn = Rn + imm9; addr = RnLaden und Speichern | |
| Xt, [Xn|SP], #imm9 | 10 111 0 00 10 0 imm9 01 Rn Rt0xB8800400 / Maske 0xFFE00C00 | Laden eines Wortes (mit Vorzeichen auf 64 Bit erweitert) (Nach-Indizierung: Rn wird danach geändert)Xt = sext([addr]); addr = Rn; Rn = Rn + imm9Laden und Speichern | |
| Xt, [Xn|SP, Rm{, extend {#amount}}] | 10 111 0 00 10 1 Rm option S 10 Rn Rt0xB8A00800 / Maske 0xFFE00C00 | Laden eines Wortes (mit Vorzeichen auf 64 Bit erweitert) (Adresse: Rn + Register, erweitert und verschoben)Xt = sext([addr]); addr = Rn + extend(Rm) << (S * log2(size))Laden und Speichern | |
| Xt, label | 10 011 0 00 imm19 Rt0x98000000 / Maske 0xFF000000 | Laden eines Wortes mit Vorzeichen relativ zum Befehlszeiger (+-1 MB)Xt = sext([pc + sext(imm19 << 2)])Laden und Speichern | |
| ldset | Ws, Wt, [Xn|SP]auch: ldseta, ldsetal, ldsetl, ldsetb, ldsetab, ldsetalb, ldsetlb, ldseth, ldsetah, ldsetalh, ldsetlh, stsetb, stseth, stset, stsetl, stsetlb, stsetlh | size 111 0 00 A R 1 Rs 0 011 00 Rn Rt0x38203000 / Maske 0x3F20FC00 | Atomare Operation im Speicher: Setzen von Bits (ODER) des Speicherwertes und eines Registers, der alte Wert kommt ins Zielregister (Varianten: b = Byte, h = Halbwort, a = Acquire, l = Release, st... ohne Zielregister)t = [Rn]; [Rn] = t | Ws; Wt = tAtomare Speicherzugriffe (LSE) |
| ldsmax | Ws, Wt, [Xn|SP]auch: ldsmaxa, ldsmaxal, ldsmaxl, ldsmaxb, ldsmaxab, ldsmaxalb, ldsmaxlb, ldsmaxh, ldsmaxah, ldsmaxalh, ldsmaxlh, stsmaxb, stsmaxh, stsmax, stsmaxl, stsmaxlb, stsmaxlh | size 111 0 00 A R 1 Rs 0 100 00 Rn Rt0x38204000 / Maske 0x3F20FC00 | Atomare Operation im Speicher: Maximum (mit Vorzeichen) des Speicherwertes und eines Registers, der alte Wert kommt ins Zielregister (Varianten: b = Byte, h = Halbwort, a = Acquire, l = Release, st... ohne Zielregister)t = [Rn]; [Rn] = max_signed(t, Ws); Wt = tAtomare Speicherzugriffe (LSE) |
| ldsmin | Ws, Wt, [Xn|SP]auch: ldsmina, ldsminal, ldsminl, ldsminb, ldsminab, ldsminalb, ldsminlb, ldsminh, ldsminah, ldsminalh, ldsminlh, stsminb, stsminh, stsmin, stsminl, stsminlb, stsminlh | size 111 0 00 A R 1 Rs 0 101 00 Rn Rt0x38205000 / Maske 0x3F20FC00 | Atomare Operation im Speicher: Minimum (mit Vorzeichen) des Speicherwertes und eines Registers, der alte Wert kommt ins Zielregister (Varianten: b = Byte, h = Halbwort, a = Acquire, l = Release, st... ohne Zielregister)t = [Rn]; [Rn] = min_signed(t, Ws); Wt = tAtomare Speicherzugriffe (LSE) |
| ldtr | Wt, [Xn|SP{, #imm9}]auch: ldtrb, ldtrh | size 111 0 00 01 0 imm9 10 Rn Rt0x38400800 / Maske 0x3FE00C00 | Laden mit den Rechten des Anwendungs-Modus (unprivilegiert; b = Byte, h = Halbwort)Wt = [Rn + imm9]Laden und Speichern |
| ldtrsb | Xt, [Xn|SP{, #imm9}]auch: ldtrsh, ldtrsw | size 111 0 00 10 0 imm9 10 Rn Rt0x38800800 / Maske 0x3FE00C00 | Laden mit den Rechten des Anwendungs-Modus, mit Vorzeichen auf 64 Bit erweitert (b = Byte, h = Halbwort, w = Wort)Xt = sext([Rn + imm9])Laden und Speichern |
| ldumax | Ws, Wt, [Xn|SP]auch: ldumaxa, ldumaxal, ldumaxl, ldumaxb, ldumaxab, ldumaxalb, ldumaxlb, ldumaxh, ldumaxah, ldumaxalh, ldumaxlh, stumaxb, stumaxh, stumax, stumaxl, stumaxlb, stumaxlh | size 111 0 00 A R 1 Rs 0 110 00 Rn Rt0x38206000 / Maske 0x3F20FC00 | Atomare Operation im Speicher: Maximum (ohne Vorzeichen) des Speicherwertes und eines Registers, der alte Wert kommt ins Zielregister (Varianten: b = Byte, h = Halbwort, a = Acquire, l = Release, st... ohne Zielregister)t = [Rn]; [Rn] = max_unsigned(t, Ws); Wt = tAtomare Speicherzugriffe (LSE) |
| ldumin | Ws, Wt, [Xn|SP]auch: ldumina, lduminal, lduminl, lduminb, lduminab, lduminalb, lduminlb, lduminh, lduminah, lduminalh, lduminlh, stuminb, stuminh, stumin, stuminl, stuminlb, stuminlh | size 111 0 00 A R 1 Rs 0 111 00 Rn Rt0x38207000 / Maske 0x3F20FC00 | Atomare Operation im Speicher: Minimum (ohne Vorzeichen) des Speicherwertes und eines Registers, der alte Wert kommt ins Zielregister (Varianten: b = Byte, h = Halbwort, a = Acquire, l = Release, st... ohne Zielregister)t = [Rn]; [Rn] = min_unsigned(t, Ws); Wt = tAtomare Speicherzugriffe (LSE) |
| ldur | Wt, [Xn|SP{, #imm9}] | 10 111 0 00 01 0 imm9 00 Rn Rt0xB8400000 / Maske 0xFFE00C00 | Laden eines Wortes (32 Bit) (ohne Skalierung, Adresse: Rn + imm9)Wt = [addr]; addr = Rn + imm9Laden und Speichern |
| Xt, [Xn|SP{, #imm9}] | 11 111 0 00 01 0 imm9 00 Rn Rt0xF8400000 / Maske 0xFFE00C00 | Laden eines Doppelwortes (64 Bit) (ohne Skalierung, Adresse: Rn + imm9)Xt = [addr]; addr = Rn + imm9Laden und Speichern | |
| ldurb | Wt, [Xn|SP{, #imm9}] | 00 111 0 00 01 0 imm9 00 Rn Rt0x38400000 / Maske 0xFFE00C00 | Laden eines Bytes (mit Nullen erweitert) (ohne Skalierung, Adresse: Rn + imm9)Wt = zext([addr]); addr = Rn + imm9Laden und Speichern |
| ldurh | Wt, [Xn|SP{, #imm9}] | 01 111 0 00 01 0 imm9 00 Rn Rt0x78400000 / Maske 0xFFE00C00 | Laden eines Halbwortes (mit Nullen erweitert) (ohne Skalierung, Adresse: Rn + imm9)Wt = zext([addr]); addr = Rn + imm9Laden und Speichern |
| ldursb | Xt, [Xn|SP{, #imm9}] | 00 111 0 00 10 0 imm9 00 Rn Rt0x38800000 / Maske 0xFFE00C00 | Laden eines Bytes (mit Vorzeichen auf 64 Bit erweitert) (ohne Skalierung, Adresse: Rn + imm9)Xt = sext([addr]); addr = Rn + imm9Laden und Speichern |
| Wt, [Xn|SP{, #imm9}] | 00 111 0 00 11 0 imm9 00 Rn Rt0x38C00000 / Maske 0xFFE00C00 | Laden eines Bytes (mit Vorzeichen auf 32 Bit erweitert) (ohne Skalierung, Adresse: Rn + imm9)Wt = sext([addr]); addr = Rn + imm9Laden und Speichern | |
| ldursh | Xt, [Xn|SP{, #imm9}] | 01 111 0 00 10 0 imm9 00 Rn Rt0x78800000 / Maske 0xFFE00C00 | Laden eines Halbwortes (mit Vorzeichen auf 64 Bit erweitert) (ohne Skalierung, Adresse: Rn + imm9)Xt = sext([addr]); addr = Rn + imm9Laden und Speichern |
| Wt, [Xn|SP{, #imm9}] | 01 111 0 00 11 0 imm9 00 Rn Rt0x78C00000 / Maske 0xFFE00C00 | Laden eines Halbwortes (mit Vorzeichen auf 32 Bit erweitert) (ohne Skalierung, Adresse: Rn + imm9)Wt = sext([addr]); addr = Rn + imm9Laden und Speichern | |
| ldursw | Xt, [Xn|SP{, #imm9}] | 10 111 0 00 10 0 imm9 00 Rn Rt0xB8800000 / Maske 0xFFE00C00 | Laden eines Wortes (mit Vorzeichen auf 64 Bit erweitert) (ohne Skalierung, Adresse: Rn + imm9)Xt = sext([addr]); addr = Rn + imm9Laden und Speichern |
| ldxp | Rt, Rt2, [Xn|SP] | 1 sz 001000 0 1 1 11111 0 Rt2 Rn Rt0x887F0000 / Maske 0xBFFF8000 | Laden eines Registerpaares (exklusiv)Rt = [Rn]; Rt2 = [Rn + size]; set the exclusive monitorLaden und Speichern |
| ldxr | Wt, [Xn|SP] | 10 001000 0 1 0 11111 0 11111 Rn Rt0x885F7C00 / Maske 0xFFFFFC00 | Laden (exklusiv): setzt den Exklusiv-Monitor (Wort)Rt = [Rn]; set the exclusive monitorLaden und Speichern |
| Xt, [Xn|SP] | 11 001000 0 1 0 11111 0 11111 Rn Rt0xC85F7C00 / Maske 0xFFFFFC00 | Laden (exklusiv): setzt den Exklusiv-Monitor (Doppelwort)Rt = [Rn]; set the exclusive monitorLaden und Speichern | |
| ldxrb | Wt, [Xn|SP] | 00 001000 0 1 0 11111 0 11111 Rn Rt0x085F7C00 / Maske 0xFFFFFC00 | Laden (exklusiv): setzt den Exklusiv-Monitor (Byte)Rt = [Rn]; set the exclusive monitorLaden und Speichern |
| ldxrh | Wt, [Xn|SP] | 01 001000 0 1 0 11111 0 11111 Rn Rt0x485F7C00 / Maske 0xFFFFFC00 | Laden (exklusiv): setzt den Exklusiv-Monitor (Halbwort)Rt = [Rn]; set the exclusive monitorLaden und Speichern |
| lslv | Rd, Rn, Rmauch: lsl | sf 0 0 11010110 Rm 001000 Rn Rd0x1AC02000 / Maske 0x7FE0FC00 | Schieben nach links um ein Register (Betrag modulo Breite)Rd = Rn << (Rm mod width)Schieben und Rotieren |
| lsrv | Rd, Rn, Rmauch: lsr | sf 0 0 11010110 Rm 001001 Rn Rd0x1AC02400 / Maske 0x7FE0FC00 | Schieben nach rechts ohne Vorzeichen um ein RegisterRd = Rn >> (Rm mod width)Schieben und Rotieren |
| madd | Rd, Rn, Rm, Raauch: mul | sf 00 11011 000 Rm 0 Ra Rn Rd0x1B000000 / Maske 0x7FE08000 | Multiplikation mit Addition (Ra + Rn * Rm)Rd = Ra + Rn * RmArithmetik |
| mla | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 10010 1 Rn Rd0x0E209400 / Maske 0xBF20FC00 | Multiplikation mit Addition zum Zielfor every element: Vd[i] = Vd[i] + Vn[i] * Vm[i]Vektor (SIMD) |
| Vd.T, Vn.T, Vm.Ts[index] | 0 Q 1 01111 size L M Rm 0000 H 0 Rn Rd0x2F000000 / Maske 0xBF00F400 | Multiplikation mit einem Element, addiert zum Zielfor every element: Vd[i] = Vd[i] + Vn[i] * Vm[index]Vektor (SIMD) | |
| mls | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 10010 1 Rn Rd0x2E209400 / Maske 0xBF20FC00 | Multiplikation mit Subtraktion vom Zielfor every element: Vd[i] = Vd[i] - Vn[i] * Vm[i]Vektor (SIMD) |
| Vd.T, Vn.T, Vm.Ts[index] | 0 Q 1 01111 size L M Rm 0100 H 0 Rn Rd0x2F004000 / Maske 0xBF00F400 | Multiplikation mit einem Element, subtrahiert vom Zielfor every element: Vd[i] = Vd[i] - Vn[i] * Vm[index]Vektor (SIMD) | |
| movi | Vd.T, #imm8{, lsl #amount} | 0 Q 0 0111100000 abc 0 cm 0 01 defgh Rd0x0F000400 / Maske 0xBFF89C00 | Laden einer 32-Bit-Konstante (ein Byte, geschoben) in alle ElementeVd = imm8 << (8 * cm) in every 32 bitsVektor (SIMD) |
| Vd.T, #imm8{, lsl #amount} | 0 Q 0 0111100000 abc 10 c 0 01 defgh Rd0x0F008400 / Maske 0xBFF8DC00 | Laden einer 16-Bit-Konstante (ein Byte, geschoben) in alle ElementeVd = imm8 << (8 * c) in every 16 bitsVektor (SIMD) | |
| Vd.T, #imm8{, lsl #amount} | 0 Q 0 0111100000 abc 110 c 01 defgh Rd0x0F00C400 / Maske 0xBFF8EC00 | Laden einer 32-Bit-Konstante (ein Byte mit nachgezogenen Einsen) in alle ElementeVd = (imm8 << 8 * (c+1)) | onesVektor (SIMD) | |
| Vd.T, #imm8{, lsl #amount} | 0 Q 0 0111100000 abc 1110 01 defgh Rd0x0F00E400 / Maske 0xBFF8FC00 | Laden eines Bytes in alle ElementeVd = imm8 in every byteVektor (SIMD) | |
| Vd.T, #imm8{, lsl #amount} | 0 Q 1 0111100000 abc 1110 01 defgh Rd0x2F00E400 / Maske 0xBFF8FC00 | Laden einer 64-Bit-Konstante, jedes Bit des Bytes steht für ein ByteVd = each bit of imm8 expanded to a byteVektor (SIMD) | |
| movk | Rd, #imm16{, lsl #shift} | sf 1 1 100101 hw imm16 Rd0x72800000 / Maske 0x7F800000 | 16 Bit einer Konstante in ein Register einfügen, übrige Bits bleibenRd[hw*16 + 15 : hw*16] = imm16Konstanten und Adressen laden |
| movn | Rd, #imm16{, lsl #shift}auch: mov | sf 0 0 100101 hw imm16 Rd0x12800000 / Maske 0x7F800000 | Konstante invertiert in ein Register laden (16 Bit, um 0/16/32/48 verschoben)Rd = ~(imm16 << (hw * 16))Konstanten und Adressen laden |
| movz | Rd, #imm16{, lsl #shift}auch: mov | sf 1 0 100101 hw imm16 Rd0x52800000 / Maske 0x7F800000 | Konstante in ein Register laden (16 Bit, um 0/16/32/48 verschoben, Rest 0)Rd = imm16 << (hw * 16)Konstanten und Adressen laden |
| mrs | Xt, sysreg | 1101010100 1 1 o0 op1 CRn CRm op2 Rt0xD5300000 / Maske 0xFFF00000 | Lesen eines SystemregistersXt = sysregSystem und Privilegien |
| msr | sysreg, Xt | 1101010100 0 1 o0 op1 CRn CRm op2 Rt0xD5100000 / Maske 0xFFF00000 | Schreiben eines Systemregisterssysreg = XtSystem und Privilegien |
| msub | Rd, Rn, Rm, Raauch: mneg | sf 00 11011 000 Rm 1 Ra Rn Rd0x1B008000 / Maske 0x7FE08000 | Multiplikation mit Subtraktion (Ra - Rn * Rm)Rd = Ra - Rn * RmArithmetik |
| mul | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 10011 1 Rn Rd0x0E209C00 / Maske 0xBF20FC00 | Multiplikation der Elemente (untere Hälfte des Ergebnisses)for every element: Vd[i] = Vn[i] * Vm[i]Vektor (SIMD) |
| Vd.T, Vn.T, Vm.Ts[index] | 0 Q 0 01111 size L M Rm 1000 H 0 Rn Rd0x0F008000 / Maske 0xBF00F400 | Multiplikation mit einem Elementfor every element: Vd[i] = Vn[i] * Vm[index]Vektor (SIMD) | |
| mvni | Vd.T, #imm8{, lsl #amount} | 0 Q 1 0111100000 abc 0 cm 0 01 defgh Rd0x2F000400 / Maske 0xBFF89C00 | Laden der Negation einer 32-Bit-Konstante in alle ElementeVd = ~(imm8 << (8 * cm))Vektor (SIMD) |
| Vd.T, #imm8{, lsl #amount} | 0 Q 1 0111100000 abc 10 c 0 01 defgh Rd0x2F008400 / Maske 0xBFF8DC00 | Laden der Negation einer 16-Bit-Konstante in alle ElementeVd = ~(imm8 << (8 * c))Vektor (SIMD) | |
| Vd.T, #imm8{, lsl #amount} | 0 Q 1 0111100000 abc 110 c 01 defgh Rd0x2F00C400 / Maske 0xBFF8EC00 | Laden der Negation einer 32-Bit-Konstante (mit nachgezogenen Einsen)Vd = ~((imm8 << 8 * (c+1)) | ones)Vektor (SIMD) | |
| neg | Vd.T, Vn.T | 0 Q 1 01110 size 10000 01011 10 Rn Rd0x2E20B800 / Maske 0xBF3FFC00 | Negationfor every element: Vd[i] = -Vn[i]Vektor (SIMD) |
| not | Vd.T, Vn.Tauch: mvn | 0 Q 1 01110 00 10000 00101 10 Rn Rd0x2E205800 / Maske 0xBFFFFC00 | Bitweise NegationVd = ~VnVektor (SIMD) |
| orn | Rd, Rn, Rm{, shift #imm6}auch: mvn | sf 0 1 01010 shift 1 Rm imm6 Rn Rd0x2A200000 / Maske 0x7F200000 | Bitweises ODER mit invertiertem OperandenRd = Rn OR ~shift(Rm, imm6)Logik und Bits |
| Vd.T, Vn.T, Vm.T | 0 Q 0 01110 11 1 Rm 00011 1 Rn Rd0x0EE01C00 / Maske 0xBFE0FC00 | Bitweises ODER mit invertiertem OperandenVd = Vn OR ~VmVektor (SIMD) | |
| orr | Rd, Rn, #imm (bit pattern)auch: mov | sf 0 1 100100 N immr imms Rn Rd0x32000000 / Maske 0x7F800000 | Bitweises ODER mit einem Bitmuster als KonstanteRd = Rn OR decode_bitmask(N, imms, immr) (Rd may be SP)Logik und Bits |
| Rd, Rn, Rm{, shift #imm6}auch: mov | sf 0 1 01010 shift 0 Rm imm6 Rn Rd0x2A000000 / Maske 0x7F200000 | Bitweises ODER (Register, verschoben); mov Rd, Rm ist orr mit xzrRd = Rn OR shift(Rm, imm6)Logik und Bits | |
| Vd.T, Vn.T, Vm.Tauch: mov | 0 Q 0 01110 10 1 Rm 00011 1 Rn Rd0x0EA01C00 / Maske 0xBFE0FC00 | Bitweises ODER (mov Vd, Vn ist orr mit Vn = Vm)Vd = Vn OR VmVektor (SIMD) | |
| Vd.T, #imm8{, lsl #amount} | 0 Q 0 0111100000 abc 0 cm 1 01 defgh Rd0x0F001400 / Maske 0xBFF89C00 | Bitweises ODER mit einer 32-Bit-Konstante (ein Byte, geschoben)Vd = Vd | (imm8 << (8 * cm))Vektor (SIMD) | |
| Vd.T, #imm8{, lsl #amount} | 0 Q 0 0111100000 abc 10 c 1 01 defgh Rd0x0F009400 / Maske 0xBFF8DC00 | Bitweises ODER mit einer 16-Bit-Konstante (ein Byte, geschoben)Vd = Vd | (imm8 << (8 * c))Vektor (SIMD) | |
| pacga | Xd, Xn, Xm|SP | 1 0 0 11010110 Rm 001100 Rn Rd0x9AC03000 / Maske 0xFFE0FC00 | Berechnung eines allgemeinen AuthentifizierungscodesXd[63:32] = pac_code(Xn, Xm); Xd[31:0] = 0Zeigerauthentifizierung (PAC) |
| pacia | Xd, Xn|SPauch: pacib, pacda, pacdb, autia, autib, autda, autdb | 1 1 0 11010110 00001 000 opc Rn Rd0xDAC10000 / Maske 0xFFFFE000 | Signieren (pac...) oder Prüfen (aut...) eines Zeigers mit einem Schlüssel (ia, ib für Befehle, da, db für Daten) und einem Modifizierer (Xn)Xd = pac(Xd, key, Xn) or Xd = aut(Xd, key, Xn)Zeigerauthentifizierung (PAC) |
| pmul | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 00 1 Rm 10011 1 Rn Rd0x2E209C00 / Maske 0xBFE0FC00 | Polynom-Multiplikation der Elemente (Byte, ohne Übertrag)for every element: Vd[i] = Vn[i] * Vm[i] over GF(2)Vektor (SIMD) |
| pmull | Vd.Tb, Vn.Ta, Vm.Taauch: pmull2 | 0 Q 0 01110 size 1 Rm 1110 00 Rn Rd0x0E20E000 / Maske 0xBF20FC00 | Polynom-Multiplikation mit Verbreiterung (ohne Übertrag; 1Q-Form braucht Krypto-Erweiterung)for every element: Vd[i] = Vn[i] * Vm[i] over GF(2)Vektor (SIMD) |
| prfm | prfop, [Xn|SP{, #imm12}] | 11 111 0 01 10 imm12 Rn Rt0xF9800000 / Maske 0xFFC00000 | Vorab-Laden einer Cache-Zeile (Hinweis)prefetch the cache line at addr (a hint)Laden und Speichern |
| prfop, [Xn|SP, Rm{, extend {#amount}}] | 11 111 0 00 10 1 Rm option S 10 Rn Rt0xF8A00800 / Maske 0xFFE00C00 | Vorab-Laden einer Cache-Zeile (Hinweis) (Register-Adresse)prefetch the cache line at addr (a hint)Laden und Speichern | |
| prfop, label | 11 011 0 00 imm19 Rt0xD8000000 / Maske 0xFF000000 | Vorab-Laden relativ zum Befehlszeiger (Hinweis)prefetch the cache line at pc + sext(imm19 << 2)Laden und Speichern | |
| prfum | prfop, [Xn|SP{, #imm9}] | 11 111 0 00 10 0 imm9 00 Rn Rt0xF8800000 / Maske 0xFFE00C00 | Vorab-Laden einer Cache-Zeile (Hinweis) (ohne Skalierung)prefetch the cache line at addr (a hint)Laden und Speichern |
| raddhn | Vd.Tb, Vn.Ta, Vm.Taauch: raddhn2 | 0 Q 1 01110 size 1 Rm 0100 00 Rn Rd0x2E204000 / Maske 0xBF20FC00 | Addition mit Verschmälerung (obere Hälfte; raddhn mit Runden) (ohne Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = high half of (Vn[i] + Vm[i])Vektor (SIMD) |
| rbit | Rd, Rn | sf 1 0 11010110 00000 000000 Rn Rd0x5AC00000 / Maske 0x7FFFFC00 | Umkehren der BitreihenfolgeRd = reverse_bits(Rn)Logik und Bits |
| Vd.T, Vn.T | 0 Q 1 01110 01 10000 00101 10 Rn Rd0x2E605800 / Maske 0xBFFFFC00 | Umkehren der Bitreihenfolge in jedem Bytefor every element: Vd[i] = reverse_bits(Vn[i])Vektor (SIMD) | |
| ret | {Xn} | 1101011 0 0 10 11111 000000 Rn 000000xD65F0000 / Maske 0xFFFFFC1F | Rückkehr aus der Funktion (Adresse in x30, wenn kein Register steht)pc = Xn (default x30)Sprünge und Aufrufe |
| rev | Wd, Wn | 0 1 0 11010110 00000 000010 Rn Rd0x5AC00800 / Maske 0xFFFFFC00 | Umkehren der Bytes eines 32-Bit-Wertes (Little/Big Endian)Wd = reverse_bytes(Wn)Logik und Bits |
| Xd, Xn | 1 1 0 11010110 00000 000011 Rn Rd0xDAC00C00 / Maske 0xFFFFFC00 | Umkehren der Bytes eines 64-Bit-Wertes (Little/Big Endian)Xd = reverse_bytes(Xn)Logik und Bits | |
| rev16 | Rd, Rn | sf 1 0 11010110 00000 000001 Rn Rd0x5AC00400 / Maske 0x7FFFFC00 | Umkehren der Bytes in jedem HalbwortRd = reverse_bytes_in_each_16_bits(Rn)Logik und Bits |
| Vd.T, Vn.T | 0 Q 0 01110 00 10000 00001 10 Rn Rd0x0E201800 / Maske 0xBFFFFC00 | Vertauschen der Bytes in jedem 16-Bit-Elementfor every element: Vd[i] = reverse(Vn) per 16 bitsVektor (SIMD) | |
| rev32 | Xd, Xn | 1 1 0 11010110 00000 000010 Rn Rd0xDAC00800 / Maske 0xFFFFFC00 | Umkehren der Bytes in jedem 32-Bit-Teil eines 64-Bit-RegistersXd = reverse_bytes_in_each_32_bits(Xn)Logik und Bits |
| Vd.T, Vn.T | 0 Q 1 01110 size 10000 00000 10 Rn Rd0x2E200800 / Maske 0xBF3FFC00 | Umkehren der Reihenfolge der Elemente in jedem 32-Bit-Blockfor every element: Vd[i] = reverse(Vn) per 32 bitsVektor (SIMD) | |
| rev64 | Vd.T, Vn.T | 0 Q 0 01110 size 10000 00000 10 Rn Rd0x0E200800 / Maske 0xBF3FFC00 | Umkehren der Reihenfolge der Elemente in jedem 64-Bit-Blockfor every element: Vd[i] = reverse(Vn) per 64 bitsVektor (SIMD) |
| rmif | Xn, #imm6, #nzcv | 1 0 1 11010000 imm6 00001 Rn 0 nzcv0xBA000400 / Maske 0xFFE07C10 | Drehen eines Registers in die Flags (maskiert)flags = bits of (Xn rotated right by imm6) where the mask nzcv is setFlags: N Z C VSystem und Privilegien |
| rorv | Rd, Rn, Rmauch: ror | sf 0 0 11010110 Rm 001011 Rn Rd0x1AC02C00 / Maske 0x7FE0FC00 | Rotation nach rechts um ein RegisterRd = rotate_right(Rn, Rm mod width)Schieben und Rotieren |
| rshrn | Vd.Tb, Vn.Ta, #shiftauch: rshrn2 | 0 Q 0 011110 0 immh immb 10001 1 Rn Rd0x0F008C00 / Maske 0xBFC0FC00 | Schieben nach rechts mit Verschmälern und Runden (Q = 1: Name mit 2)for every element: Vd[i] = round(Vn[i] >> shift)Vektor (SIMD) |
| rsubhn | Vd.Tb, Vn.Ta, Vm.Taauch: rsubhn2 | 0 Q 1 01110 size 1 Rm 0110 00 Rn Rd0x2E206000 / Maske 0xBF20FC00 | Subtraktion mit Verschmälerung (obere Hälfte; rsubhn mit Runden) (ohne Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = high half of (Vn[i] - Vm[i])Vektor (SIMD) |
| saba | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 01111 1 Rn Rd0x0E207C00 / Maske 0xBF20FC00 | Addition des absoluten Unterschieds zum Ziel (mit Vorzeichen)for every element: Vd[i] = Vd[i] + abs(Vn[i] - Vm[i])Vektor (SIMD) |
| sabal | Vd.Tb, Vn.Ta, Vm.Taauch: sabal2 | 0 Q 0 01110 size 1 Rm 0101 00 Rn Rd0x0E205000 / Maske 0xBF20FC00 | Addition des absoluten Unterschieds mit Verbreiterung (mit Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = Vd[i] + abs(Vn[i] - Vm[i])Vektor (SIMD) |
| sabd | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 01110 1 Rn Rd0x0E207400 / Maske 0xBF20FC00 | Absoluter Unterschied (mit Vorzeichen)for every element: Vd[i] = abs(Vn[i] - Vm[i])Vektor (SIMD) |
| sabdl | Vd.Tb, Vn.Ta, Vm.Taauch: sabdl2 | 0 Q 0 01110 size 1 Rm 0111 00 Rn Rd0x0E207000 / Maske 0xBF20FC00 | Absoluter Unterschied mit Verbreiterung (mit Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = abs(Vn[i] - Vm[i]) (wide result)Vektor (SIMD) |
| sadalp | Vd.T, Vn.T | 0 Q 0 01110 size 10000 00110 10 Rn Rd0x0E206800 / Maske 0xBF3FFC00 | Paarweise Addition mit Verbreiterung, addiert zum Ziel (mit Vorzeichen)for every element: Vd[i] = Vd[i] + Vn[2i] + Vn[2i+1]Vektor (SIMD) |
| saddl | Vd.Tb, Vn.Ta, Vm.Taauch: saddl2 | 0 Q 0 01110 size 1 Rm 0000 00 Rn Rd0x0E200000 / Maske 0xBF20FC00 | Addition mit Verbreiterung (beide Operanden werden doppelt so breit) (mit Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = Vn[i] + Vm[i] (wide result)Vektor (SIMD) |
| saddlp | Vd.T, Vn.T | 0 Q 0 01110 size 10000 00010 10 Rn Rd0x0E202800 / Maske 0xBF3FFC00 | Paarweise Addition benachbarter Elemente mit Verbreiterung (mit Vorzeichen)for every element: Vd[i] = Vn[2i] + Vn[2i+1]Vektor (SIMD) |
| saddlv | Vd, Vn.T | 0 Q 0 01110 size 11000 00011 10 Rn Rd0x0E303800 / Maske 0xBF3FFC00 | Summe aller Elemente mit Verbreiterung (mit Vorzeichen)Vd = sum of all elements of VnVektor (SIMD) |
| saddw | Vd.Tb, Vn.Ta, Vm.Taauch: saddw2 | 0 Q 0 01110 size 1 Rm 0001 00 Rn Rd0x0E201000 / Maske 0xBF20FC00 | Addition eines breiten und eines schmalen Operanden (mit Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = Vn[i] + Vm[i] (Vn is wide)Vektor (SIMD) |
| sbc | Rd, Rn, Rmauch: ngc | sf 1 0 11010000 Rm 000000 Rn Rd0x5A000000 / Maske 0x7FE0FC00 | Subtraktion mit Borgen (C)Rd = Rn - Rm - (1 - C)Arithmetik |
| sbcs | Rd, Rn, Rmauch: ngcs | sf 1 1 11010000 Rm 000000 Rn Rd0x7A000000 / Maske 0x7FE0FC00 | Subtraktion mit Borgen, setzt die FlagsRd = Rn - Rm - (1 - C)Flags: N Z C VArithmetik |
| sbfm | Rd, Rn, #immr, #immsauch: asr, sbfiz, sbfx, sxtb, sxth, sxtw | sf 0 0 100110 N immr imms Rn Rd0x13000000 / Maske 0x7F800000 | Bitfeld verschieben mit Vorzeichenerweiterung (Grundform von asr, sbfx, sxtb ...)Rd = sign-extended field of Rn selected by immr, immsBitfelder |
| scvtf | Fd, Rn | sf 0 0 11110 ftype 1 00 010 000000 Rn Rd0x1E220000 / Maske 0x7F3FFC00 | Umwandlung einer Ganzzahl mit Vorzeichen in GleitkommaFd = (float) sext(Rn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 0 01110 0 sz 10000 11101 10 Rn Rd0x0E21D800 / Maske 0xBFBFFC00 | Umwandlung einer Ganzzahl mit Vorzeichen in Gleitkommafor every element: Vd[i] = (float) Vn[i]Vektor (SIMD) | |
| sdiv | Rd, Rn, Rm | sf 0 0 11010110 Rm 000011 Rn Rd0x1AC00C00 / Maske 0x7FE0FC00 | Division mit Vorzeichen (Division durch 0 ergibt 0)Rd = Rn / RmArithmetik |
| sdot | Vd.4S, Vn.16B, Vm.16B | 0 Q 0 01110 10 0 Rm 10010 1 Rn Rd0x0E809400 / Maske 0xBFE0FC00 | Skalarprodukt von je vier Bytes (mit Vorzeichen), addiert zum 32-Bit-Zielfor every element: Vd[i] = Vd[i] + sum of Vn[4i+k] * Vm[4i+k]Vektor (SIMD) |
| sete | [Xd]!, Xn!, Xsauch: seten, setet, setetn | 00 011 0 01 11 0 Rs 10 o 01 Rn Rd0x19C08400 / Maske 0xFFE0CC00 | Füllen eines Speicherblocks mit einem Byte, Abschluss (epilogue) (die drei Befehle p, m, e werden nacheinander ausgeführt)fill Xn bytes at [Xd] with Xs[7:0]; Xd and Xn are updatedSpeicher kopieren und füllen |
| setge | [Xd]!, Xn!, Xsauch: setgen, setget, setgetn | 00 011 1 01 11 0 Rs 10 o 01 Rn Rd0x1DC08400 / Maske 0xFFE0CC00 | Füllen eines Speicherblocks mit einem Byte mit Tags, Abschluss (epilogue) (die drei Befehle p, m, e werden nacheinander ausgeführt)fill Xn bytes at [Xd] with Xs[7:0]; Xd and Xn are updatedSpeicher kopieren und füllen |
| setgm | [Xd]!, Xn!, Xsauch: setgmn, setgmt, setgmtn | 00 011 1 01 11 0 Rs 01 o 01 Rn Rd0x1DC04400 / Maske 0xFFE0CC00 | Füllen eines Speicherblocks mit einem Byte mit Tags, Hauptteil (main) (die drei Befehle p, m, e werden nacheinander ausgeführt)fill Xn bytes at [Xd] with Xs[7:0]; Xd and Xn are updatedSpeicher kopieren und füllen |
| setgp | [Xd]!, Xn!, Xsauch: setgpn, setgpt, setgptn | 00 011 1 01 11 0 Rs 00 o 01 Rn Rd0x1DC00400 / Maske 0xFFE0CC00 | Füllen eines Speicherblocks mit einem Byte mit Tags, Vorbereitung (prologue) (die drei Befehle p, m, e werden nacheinander ausgeführt)fill Xn bytes at [Xd] with Xs[7:0]; Xd and Xn are updatedSpeicher kopieren und füllen |
| setm | [Xd]!, Xn!, Xsauch: setmn, setmt, setmtn | 00 011 0 01 11 0 Rs 01 o 01 Rn Rd0x19C04400 / Maske 0xFFE0CC00 | Füllen eines Speicherblocks mit einem Byte, Hauptteil (main) (die drei Befehle p, m, e werden nacheinander ausgeführt)fill Xn bytes at [Xd] with Xs[7:0]; Xd and Xn are updatedSpeicher kopieren und füllen |
| setp | [Xd]!, Xn!, Xsauch: setpn, setpt, setptn | 00 011 0 01 11 0 Rs 00 o 01 Rn Rd0x19C00400 / Maske 0xFFE0CC00 | Füllen eines Speicherblocks mit einem Byte, Vorbereitung (prologue) (die drei Befehle p, m, e werden nacheinander ausgeführt)fill Xn bytes at [Xd] with Xs[7:0]; Xd and Xn are updatedSpeicher kopieren und füllen |
| sha1c | Qd, Sn, Vm.4Sauch: sha1p, sha1m, sha1su0, sha256h, sha256h2, sha256su1 | 01011110 00 0 Rm 0 opc 00 Rn Rd0x5E000000 / Maske 0xFFE08C00 | SHA-1- und SHA-256-Hashwert-Update (sha1c: Auswahl, sha1p: Parität, sha1m: Mehrheit, sha256h, sha256h2: Hash-Update, ...su: Nachrichtenplan)Vd = hash_update(Vd, Vn, Vm)Kryptografie |
| sha1h | Sd, Snauch: sha1su1, sha256su0 | 01011110 00 10100 000 opc 10 Rn Rd0x5E280800 / Maske 0xFFFFCC00 | SHA-1-Rotation (sha1h) und Nachrichtenplan (sha1su1, sha256su0)Sd = rotate_left(Sn, 30)Kryptografie |
| sha512h | Qd, Qn, Vm.2Dauch: sha512h2, sha512su1, rax1 | 11001110 011 Rm 1 000 opc Rn Rd0xCE608000 / Maske 0xFFE0F000 | SHA-512-Hashwert-Update (sha512h, sha512h2), Nachrichtenplan (sha512su1) und Rotation (rax1: rotieren und exklusiv-oder, auch für SHA-3)Vd = hash_update(Vd, Vn, Vm)Kryptografie |
| sha512su0 | Vd.2D, Vn.2Dauch: sm4e | 11001110 110 00000 1000 0 x Rn Rd0xCEC08000 / Maske 0xFFFFF800 | SHA-512-Nachrichtenplan (sha512su0) und SM4-Verschlüsselung von vier Runden (sm4e)Vd = message_schedule(Vd, Vn)Kryptografie |
| shadd | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 00000 1 Rn Rd0x0E200400 / Maske 0xBF20FC00 | Halbierende Addition (mit Vorzeichen)for every element: Vd[i] = (Vn[i] + Vm[i]) >> 1Vektor (SIMD) |
| shl | Vd.T, Vn.T, #shift | 0 Q 0 011110 immh immb 01010 1 Rn Rd0x0F005400 / Maske 0xBF80FC00 | Schieben nach linksfor every element: Vd[i] = Vn[i] << shiftVektor (SIMD) |
| shll | Vd.Ta, Vn.Tb, #shiftauch: shll2 | 0 Q 1 01110 size 10000 10011 10 Rn Rd0x2E213800 / Maske 0xBF3FFC00 | Verbreitern mit Linksschieben um die Elementbreitefor every element: Vd[i] = Vn[i] << esizeVektor (SIMD) |
| shrn | Vd.Tb, Vn.Ta, #shiftauch: shrn2 | 0 Q 0 011110 0 immh immb 10000 1 Rn Rd0x0F008400 / Maske 0xBFC0FC00 | Schieben nach rechts mit Verschmälern (Q = 1: Name mit 2)for every element: Vd[i] = Vn[i] >> shiftVektor (SIMD) |
| shsub | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 00100 1 Rn Rd0x0E202400 / Maske 0xBF20FC00 | Halbierende Subtraktion (mit Vorzeichen)for every element: Vd[i] = (Vn[i] - Vm[i]) >> 1Vektor (SIMD) |
| sli | Vd.T, Vn.T, #shift | 0 Q 1 011110 immh immb 01010 1 Rn Rd0x2F005400 / Maske 0xBF80FC00 | Schieben nach links und Einfügen (die unteren Bits des Ziels bleiben)for every element: Vd[i] = (Vd[i] & low_mask) | (Vn[i] << shift)Vektor (SIMD) |
| sm3partw1 | Vd.4S, Vn.4S, Vm.4Sauch: sm3partw2, sm4ekey | 11001110 011 Rm 1100 opc Rn Rd0xCE60C000 / Maske 0xFFE0F000 | SM3-Nachrichtenerweiterung (sm3partw1, sm3partw2) und SM4-Schlüsselerzeugung (sm4ekey)Vd = expand(Vn, Vm)Kryptografie |
| sm3ss1 | Vd.4S, Vn.4S, Vm.4S, Va.4S | 11001110 010 Rm 0 Ra Rn Rd0xCE400000 / Maske 0xFFE08000 | SM3-HilfswertVd = SM3SS1(Vn, Vm, Va)Kryptografie |
| sm3tt1a | Vd.4S, Vn.4S, Vm.S[imm2]auch: sm3tt1b, sm3tt2a, sm3tt2b | 11001110 010 Rm 10 imm2 opc Rn Rd0xCE408000 / Maske 0xFFE0C000 | SM3-Kompressionsfunktion (vier Varianten)Vd = SM3TT(Vd, Vn, Vm[imm2])Kryptografie |
| smaddl | Xd, Wn, Wm, Xaauch: smull | 1 00 11011 001 Rm 0 Ra Rn Rd0x9B200000 / Maske 0xFFE08000 | Multiplikation 32 x 32 Bit mit Vorzeichen, Addition zu 64 BitXd = Xa + sext(Wn) * sext(Wm)Arithmetik |
| smax | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 01100 1 Rn Rd0x0E206400 / Maske 0xBF20FC00 | Maximum der Elemente (mit Vorzeichen)for every element: Vd[i] = max_signed(Vn[i], Vm[i])Vektor (SIMD) |
| smaxp | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 10100 1 Rn Rd0x0E20A400 / Maske 0xBF20FC00 | Maximum benachbarter Elementpaare (mit Vorzeichen)for every element: Vd[i] = max_signed of each pair of (Vn:Vm)Vektor (SIMD) |
| smaxv | Vd, Vn.T | 0 Q 0 01110 size 11000 01010 10 Rn Rd0x0E30A800 / Maske 0xBF3FFC00 | Maximum aller Elemente (mit Vorzeichen)Vd = max_signed of all elements of VnVektor (SIMD) |
| smc | #imm16 | 11010100 000 imm16 000 110xD4000003 / Maske 0xFFE0001F | Aufruf des sicheren Monitors (Ausnahmestufe 3)raise a secure monitor call exceptionSystem und Privilegien |
| smin | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 01101 1 Rn Rd0x0E206C00 / Maske 0xBF20FC00 | Minimum der Elemente (mit Vorzeichen)for every element: Vd[i] = min_signed(Vn[i], Vm[i])Vektor (SIMD) |
| sminp | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 10101 1 Rn Rd0x0E20AC00 / Maske 0xBF20FC00 | Minimum benachbarter Elementpaare (mit Vorzeichen)for every element: Vd[i] = min_signed of each pair of (Vn:Vm)Vektor (SIMD) |
| sminv | Vd, Vn.T | 0 Q 0 01110 size 11000 11010 10 Rn Rd0x0E31A800 / Maske 0xBF3FFC00 | Minimum aller Elemente (mit Vorzeichen)Vd = min_signed of all elements of VnVektor (SIMD) |
| smlal | Vd.Tb, Vn.Ta, Vm.Taauch: smlal2 | 0 Q 0 01110 size 1 Rm 1000 00 Rn Rd0x0E208000 / Maske 0xBF20FC00 | Multiplikation mit Verbreiterung, addiert zum Ziel (mit Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = Vd[i] + Vn[i] * Vm[i]Vektor (SIMD) |
| Vd.Ta, Vn.Tb, Vm.Ts[index]auch: smlal2 | 0 Q 0 01111 size L M Rm 0010 H 0 Rn Rd0x0F002000 / Maske 0xBF00F400 | Multiplikation mit einem Element und Verbreiterung, addiert zum Ziel (mit Vorzeichen) (Q = 1: Name mit 2)for every element: Vd[i] = Vd[i] + Vn[i] * Vm[index]Vektor (SIMD) | |
| smlsl | Vd.Tb, Vn.Ta, Vm.Taauch: smlsl2 | 0 Q 0 01110 size 1 Rm 1010 00 Rn Rd0x0E20A000 / Maske 0xBF20FC00 | Multiplikation mit Verbreiterung, subtrahiert vom Ziel (mit Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = Vd[i] - Vn[i] * Vm[i]Vektor (SIMD) |
| Vd.Ta, Vn.Tb, Vm.Ts[index]auch: smlsl2 | 0 Q 0 01111 size L M Rm 0110 H 0 Rn Rd0x0F006000 / Maske 0xBF00F400 | Multiplikation mit einem Element und Verbreiterung, subtrahiert vom Ziel (mit Vorzeichen) (Q = 1: Name mit 2)for every element: Vd[i] = Vd[i] - Vn[i] * Vm[index]Vektor (SIMD) | |
| smmla | Vd.4S, Vn.16B, Vm.16B | 0 1 0 01110 10 0 Rm 10100 1 Rn Rd0x4E80A400 / Maske 0xFFE0FC00 | Matrix-Multiplikation 2x8 mal 8x2 (mit Vorzeichen), addiert zum ZielVd(2x2) = Vd(2x2) + Vn(2x8) * Vm(8x2)Vektor (SIMD) |
| smov | Rd, Vn.Ts[index] | 0 Q 0 01110000 imm5 0 0101 1 Rn Rd0x0E002C00 / Maske 0xBFE0FC00 | Kopieren eines Elements in ein Ganzzahl-Register (mit Vorzeichen)Rd = sext(Vn[index])Vektor (SIMD) |
| smsubl | Xd, Wn, Wm, Xaauch: smnegl | 1 00 11011 001 Rm 1 Ra Rn Rd0x9B208000 / Maske 0xFFE08000 | Multiplikation 32 x 32 Bit mit Vorzeichen, Subtraktion von 64 BitXd = Xa - sext(Wn) * sext(Wm)Arithmetik |
| smulh | Xd, Xn, Xm | 1 00 11011 010 Rm 0 11111 Rn Rd0x9B407C00 / Maske 0xFFE0FC00 | Multiplikation mit Vorzeichen, obere 64 Bit des ErgebnissesXd = (sext(Xn) * sext(Xm)) >> 64Arithmetik |
| smull | Vd.Tb, Vn.Ta, Vm.Taauch: smull2 | 0 Q 0 01110 size 1 Rm 1100 00 Rn Rd0x0E20C000 / Maske 0xBF20FC00 | Multiplikation mit Verbreiterung (mit Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = Vn[i] * Vm[i] (wide result)Vektor (SIMD) |
| Vd.Ta, Vn.Tb, Vm.Ts[index]auch: smull2 | 0 Q 0 01111 size L M Rm 1010 H 0 Rn Rd0x0F00A000 / Maske 0xBF00F400 | Multiplikation mit einem Element und Verbreiterung (mit Vorzeichen) (Q = 1: Name mit 2)for every element: Vd[i] = Vn[i] * Vm[index]Vektor (SIMD) | |
| sqabs | Vd.T, Vn.T | 0 Q 0 01110 size 10000 00111 10 Rn Rd0x0E207800 / Maske 0xBF3FFC00 | Betrag mit Sättigungfor every element: Vd[i] = saturate(abs(Vn[i]))Vektor (SIMD) |
| sqadd | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 00001 1 Rn Rd0x0E200C00 / Maske 0xBF20FC00 | Addition mit Sättigung (mit Vorzeichen)for every element: Vd[i] = saturate_signed(Vn[i] + Vm[i])Vektor (SIMD) |
| sqdmlal | Vd.Tb, Vn.Ta, Vm.Taauch: sqdmlal2 | 0 Q 0 01110 size 1 Rm 1001 00 Rn Rd0x0E209000 / Maske 0xBF20FC00 | Verdoppelnde Multiplikation mit Verbreiterung und Sättigung, addiert zum Zielfor every element: Vd[i] = saturate(Vd[i] + 2 * Vn[i] * Vm[i])Vektor (SIMD) |
| Vd.Ta, Vn.Tb, Vm.Ts[index]auch: sqdmlal2 | 0 Q 0 01111 size L M Rm 0011 H 0 Rn Rd0x0F003000 / Maske 0xBF00F400 | Verdoppelnde Multiplikation mit einem Element, Verbreiterung und Sättigung, addiert zum Ziel (Q = 1: Name mit 2)for every element: Vd[i] = saturate(Vd[i] + 2 * Vn[i] * Vm[index])Vektor (SIMD) | |
| sqdmlsl | Vd.Tb, Vn.Ta, Vm.Taauch: sqdmlsl2 | 0 Q 0 01110 size 1 Rm 1011 00 Rn Rd0x0E20B000 / Maske 0xBF20FC00 | Verdoppelnde Multiplikation mit Verbreiterung und Sättigung, subtrahiert vom Zielfor every element: Vd[i] = saturate(Vd[i] - 2 * Vn[i] * Vm[i])Vektor (SIMD) |
| Vd.Ta, Vn.Tb, Vm.Ts[index]auch: sqdmlsl2 | 0 Q 0 01111 size L M Rm 0111 H 0 Rn Rd0x0F007000 / Maske 0xBF00F400 | Verdoppelnde Multiplikation mit einem Element, Verbreiterung und Sättigung, subtrahiert vom Ziel (Q = 1: Name mit 2)for every element: Vd[i] = saturate(Vd[i] - 2 * Vn[i] * Vm[index])Vektor (SIMD) | |
| sqdmulh | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 10110 1 Rn Rd0x0E20B400 / Maske 0xBF20FC00 | Verdoppelnde Multiplikation, obere Hälfte, mit Sättigungfor every element: Vd[i] = saturate((2 * Vn[i] * Vm[i]) >> esize)Vektor (SIMD) |
| Vd.T, Vn.T, Vm.Ts[index] | 0 Q 0 01111 size L M Rm 1100 H 0 Rn Rd0x0F00C000 / Maske 0xBF00F400 | Verdoppelnde Multiplikation mit einem Element, obere Hälfte, mit Sättigungfor every element: Vd[i] = saturate((2 * Vn[i] * Vm[index]) >> esize)Vektor (SIMD) | |
| sqdmull | Vd.Tb, Vn.Ta, Vm.Taauch: sqdmull2 | 0 Q 0 01110 size 1 Rm 1101 00 Rn Rd0x0E20D000 / Maske 0xBF20FC00 | Verdoppelnde Multiplikation mit Verbreiterung und Sättigungfor every element: Vd[i] = saturate(2 * Vn[i] * Vm[i])Vektor (SIMD) |
| Vd.Ta, Vn.Tb, Vm.Ts[index]auch: sqdmull2 | 0 Q 0 01111 size L M Rm 1011 H 0 Rn Rd0x0F00B000 / Maske 0xBF00F400 | Verdoppelnde Multiplikation mit einem Element, Verbreiterung und Sättigung (Q = 1: Name mit 2)for every element: Vd[i] = saturate(2 * Vn[i] * Vm[index])Vektor (SIMD) | |
| sqneg | Vd.T, Vn.T | 0 Q 1 01110 size 10000 00111 10 Rn Rd0x2E207800 / Maske 0xBF3FFC00 | Negation mit Sättigungfor every element: Vd[i] = saturate(-Vn[i])Vektor (SIMD) |
| sqrdmlah | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 0 Rm 10000 1 Rn Rd0x2E008400 / Maske 0xBF20FC00 | Verdoppelnde Multiplikation, obere Hälfte, mit Runden und Sättigung, addiert zum Zielfor every element: Vd[i] = saturate(Vd[i] + round((2 * Vn[i] * Vm[i]) >> esize))Vektor (SIMD) |
| sqrdmlsh | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 0 Rm 10001 1 Rn Rd0x2E008C00 / Maske 0xBF20FC00 | Verdoppelnde Multiplikation, obere Hälfte, mit Runden und Sättigung, subtrahiert vom Zielfor every element: Vd[i] = saturate(Vd[i] - round((2 * Vn[i] * Vm[i]) >> esize))Vektor (SIMD) |
| sqrdmulh | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 10110 1 Rn Rd0x2E20B400 / Maske 0xBF20FC00 | Verdoppelnde Multiplikation, obere Hälfte, mit Runden und Sättigungfor every element: Vd[i] = saturate(round((2 * Vn[i] * Vm[i]) >> esize))Vektor (SIMD) |
| Vd.T, Vn.T, Vm.Ts[index] | 0 Q 0 01111 size L M Rm 1101 H 0 Rn Rd0x0F00D000 / Maske 0xBF00F400 | Verdoppelnde Multiplikation mit einem Element, obere Hälfte, mit Runden und Sättigungfor every element: Vd[i] = saturate(round((2 * Vn[i] * Vm[index]) >> esize))Vektor (SIMD) | |
| sqrshl | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 01011 1 Rn Rd0x0E205C00 / Maske 0xBF20FC00 | Schieben je Element mit Runden und Sättigung (mit Vorzeichen)for every element: Vd[i] = saturate_signed(round(Vn[i] << Vm[i]))Vektor (SIMD) |
| sqrshrn | Vd.Tb, Vn.Ta, #shiftauch: sqrshrn2 | 0 Q 0 011110 0 immh immb 10011 1 Rn Rd0x0F009C00 / Maske 0xBFC0FC00 | Schieben nach rechts mit Verschmälern, Runden und Sättigung (mit Vorzeichen) (Q = 1: Name mit 2)for every element: Vd[i] = saturate_signed(round(Vn[i] >> shift))Vektor (SIMD) |
| sqrshrun | Vd.Tb, Vn.Ta, #shiftauch: sqrshrun2 | 0 Q 1 011110 0 immh immb 10001 1 Rn Rd0x2F008C00 / Maske 0xBFC0FC00 | Schieben nach rechts mit Verschmälern, Runden und Sättigung (Quelle mit Vorzeichen, Ergebnis ohne) (Q = 1: Name mit 2)for every element: Vd[i] = saturate_unsigned(round(Vn[i] >> shift))Vektor (SIMD) |
| sqshl | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 01001 1 Rn Rd0x0E204C00 / Maske 0xBF20FC00 | Schieben je Element mit Sättigung (mit Vorzeichen)for every element: Vd[i] = saturate_signed(Vn[i] << Vm[i])Vektor (SIMD) |
| Vd.T, Vn.T, #shift | 0 Q 0 011110 immh immb 01110 1 Rn Rd0x0F007400 / Maske 0xBF80FC00 | Schieben nach links mit Sättigung (mit Vorzeichen)for every element: Vd[i] = saturate_signed(Vn[i] << shift)Vektor (SIMD) | |
| sqshlu | Vd.T, Vn.T, #shift | 0 Q 1 011110 immh immb 01100 1 Rn Rd0x2F006400 / Maske 0xBF80FC00 | Schieben nach links mit Sättigung (Quelle mit Vorzeichen, Ergebnis ohne)for every element: Vd[i] = saturate_unsigned(Vn[i] << shift)Vektor (SIMD) |
| sqshrn | Vd.Tb, Vn.Ta, #shiftauch: sqshrn2 | 0 Q 0 011110 0 immh immb 10010 1 Rn Rd0x0F009400 / Maske 0xBFC0FC00 | Schieben nach rechts mit Verschmälern und Sättigung (mit Vorzeichen) (Q = 1: Name mit 2)for every element: Vd[i] = saturate_signed(Vn[i] >> shift)Vektor (SIMD) |
| sqshrun | Vd.Tb, Vn.Ta, #shiftauch: sqshrun2 | 0 Q 1 011110 0 immh immb 10000 1 Rn Rd0x2F008400 / Maske 0xBFC0FC00 | Schieben nach rechts mit Verschmälern und Sättigung (Quelle mit Vorzeichen, Ergebnis ohne) (Q = 1: Name mit 2)for every element: Vd[i] = saturate_unsigned(Vn[i] >> shift)Vektor (SIMD) |
| sqsub | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 00101 1 Rn Rd0x0E202C00 / Maske 0xBF20FC00 | Subtraktion mit Sättigung (mit Vorzeichen)for every element: Vd[i] = saturate_signed(Vn[i] - Vm[i])Vektor (SIMD) |
| sqxtn | Vd.T, Vn.Tauch: sqxtn2 | 0 Q 0 01110 size 10000 10100 10 Rn Rd0x0E214800 / Maske 0xBF3FFC00 | Verschmälern mit Sättigung (mit Vorzeichen)for every element: Vd[i] = saturate_signed(Vn[i])Vektor (SIMD) |
| sqxtun | Vd.T, Vn.Tauch: sqxtun2 | 0 Q 1 01110 size 10000 10010 10 Rn Rd0x2E212800 / Maske 0xBF3FFC00 | Verschmälern mit Sättigung (Quelle mit Vorzeichen, Ergebnis ohne)for every element: Vd[i] = saturate_unsigned(Vn[i])Vektor (SIMD) |
| srhadd | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 00010 1 Rn Rd0x0E201400 / Maske 0xBF20FC00 | Halbierende Addition mit Aufrunden (mit Vorzeichen)for every element: Vd[i] = (Vn[i] + Vm[i] + 1) >> 1Vektor (SIMD) |
| sri | Vd.T, Vn.T, #shift | 0 Q 1 011110 immh immb 01000 1 Rn Rd0x2F004400 / Maske 0xBF80FC00 | Schieben nach rechts und Einfügen (die oberen Bits des Ziels bleiben)for every element: Vd[i] = (Vd[i] & high_mask) | (Vn[i] >> shift)Vektor (SIMD) |
| srshl | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 01010 1 Rn Rd0x0E205400 / Maske 0xBF20FC00 | Schieben je Element mit Runden (mit Vorzeichen)for every element: Vd[i] = round(Vn[i] << Vm[i])Vektor (SIMD) |
| srshr | Vd.T, Vn.T, #shift | 0 Q 0 011110 immh immb 00100 1 Rn Rd0x0F002400 / Maske 0xBF80FC00 | Schieben nach rechts mit Runden (mit Vorzeichen)for every element: Vd[i] = round(Vn[i] >> shift)Vektor (SIMD) |
| srsra | Vd.T, Vn.T, #shift | 0 Q 0 011110 immh immb 00110 1 Rn Rd0x0F003400 / Maske 0xBF80FC00 | Schieben nach rechts mit Runden und Addition zum Ziel (mit Vorzeichen)for every element: Vd[i] = Vd[i] + round(Vn[i] >> shift)Vektor (SIMD) |
| sshl | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 1 Rm 01000 1 Rn Rd0x0E204400 / Maske 0xBF20FC00 | Schieben nach links oder rechts je Element (mit Vorzeichen)for every element: Vd[i] = Vn[i] << Vm[i] (a negative count shifts right)Vektor (SIMD) |
| sshll | Vd.Ta, Vn.Tb, #shiftauch: sshll2, sxtl, sxtl2 | 0 Q 0 011110 0 immh immb 10100 1 Rn Rd0x0F00A400 / Maske 0xBFC0FC00 | Verbreitern mit Linksschieben (mit Vorzeichen; sxtl ist Schieben um 0)for every element: Vd[i] = sext(Vn[i]) << shiftVektor (SIMD) |
| sshr | Vd.T, Vn.T, #shift | 0 Q 0 011110 immh immb 00000 1 Rn Rd0x0F000400 / Maske 0xBF80FC00 | Schieben nach rechts mit Vorzeichen (mit Vorzeichen)for every element: Vd[i] = Vn[i] >> shiftVektor (SIMD) |
| ssra | Vd.T, Vn.T, #shift | 0 Q 0 011110 immh immb 00010 1 Rn Rd0x0F001400 / Maske 0xBF80FC00 | Schieben nach rechts und Addition zum Ziel (mit Vorzeichen)for every element: Vd[i] = Vd[i] + (Vn[i] >> shift)Vektor (SIMD) |
| ssubl | Vd.Tb, Vn.Ta, Vm.Taauch: ssubl2 | 0 Q 0 01110 size 1 Rm 0010 00 Rn Rd0x0E202000 / Maske 0xBF20FC00 | Subtraktion mit Verbreiterung (mit Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = Vn[i] - Vm[i] (wide result)Vektor (SIMD) |
| ssubw | Vd.Tb, Vn.Ta, Vm.Taauch: ssubw2 | 0 Q 0 01110 size 1 Rm 0011 00 Rn Rd0x0E203000 / Maske 0xBF20FC00 | Subtraktion eines schmalen Operanden von einem breiten (mit Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = Vn[i] - Vm[i] (Vn is wide)Vektor (SIMD) |
| st1 | {Vt.T}, [Xn|SP] | 0 Q 0011000 0 000000 0111 size Rn Rt0x0C007000 / Maske 0xBFFFF000 | Speichern eines Vektor-Registers in den Speicher (ein Register)[Rn] = VtVektor (SIMD) |
| {Vt.T, Vt2.T}, [Xn|SP] | 0 Q 0011000 0 000000 1010 size Rn Rt0x0C00A000 / Maske 0xBFFFF000 | Speichern von 2 Register in den Speicher[Rn] = registers (2 registers)Vektor (SIMD) | |
| {Vt.T, Vt2.T, Vt3.T}, [Xn|SP] | 0 Q 0011000 0 000000 0110 size Rn Rt0x0C006000 / Maske 0xBFFFF000 | Speichern von 3 Register in den Speicher[Rn] = registers (3 registers)Vektor (SIMD) | |
| {Vt.T, Vt2.T, Vt3.T, Vt4.T}, [Xn|SP] | 0 Q 0011000 0 000000 0010 size Rn Rt0x0C002000 / Maske 0xBFFFF000 | Speichern von 4 Register in den Speicher[Rn] = registers (4 registers)Vektor (SIMD) | |
| {Vt.Ts}[index], [Xn|SP] | 0 Q 0011010 0 0 00000 e 0 S size Rn Rt0x0D000000 / Maske 0xBFFF2000 | Speichern eines Elements (Lane) (ein Register)[Rn] = Vt[index]Vektor (SIMD) | |
| st2 | {Vt.T, Vt2.T}, [Xn|SP] | 0 Q 0011000 0 000000 1000 size Rn Rt0x0C008000 / Maske 0xBFFFF000 | Speichern von 2 Register (Elemente abwechselnd) in den Speicher[Rn] = registers (2 registers (elements interleaved))Vektor (SIMD) |
| {Vt.T, Vt2.T}, [Xn|SP], Xm|#imm | 0 Q 0011001 0 0 Rm 1000 size Rn Rt0x0C808000 / Maske 0xBFE0F000 | Speichern von 2 Registern (Elemente abwechselnd) mit Nach-Indizierung[Rn] = registers; Rn = Rn + Xm or the sizeVektor (SIMD) | |
| {Vt.Ts, Vt2.Ts}[index], [Xn|SP] | 0 Q 0011010 0 1 00000 e 0 S size Rn Rt0x0D200000 / Maske 0xBFFF2000 | Speichern eines Elements (Lane) von 2 Registern[Rn] = Vt[index]Vektor (SIMD) | |
| st2g | Xt|SP, [Xn|SP], #imm9 | 11011001 101 imm9 01 Rn Rt0xD9A00400 / Maske 0xFFE00C00 | Speichern des Tags für 32 Byte (Nach-Indizierung)tag of [addr] = tag of Xt (imm9 * 16 added to the address)Speicher-Tagging (MTE) |
| Xt|SP, [Xn|SP{, #imm9}] | 11011001 101 imm9 10 Rn Rt0xD9A00800 / Maske 0xFFE00C00 | Speichern des Tags für 32 Bytetag of [addr] = tag of Xt (imm9 * 16 added to the address)Speicher-Tagging (MTE) | |
| Xt|SP, [Xn|SP, #imm9]! | 11011001 101 imm9 11 Rn Rt0xD9A00C00 / Maske 0xFFE00C00 | Speichern des Tags für 32 Byte (Vor-Indizierung)tag of [addr] = tag of Xt (imm9 * 16 added to the address)Speicher-Tagging (MTE) | |
| st3 | {Vt.T, Vt2.T, Vt3.T}, [Xn|SP] | 0 Q 0011000 0 000000 0100 size Rn Rt0x0C004000 / Maske 0xBFFFF000 | Speichern von 3 Register (Elemente abwechselnd) in den Speicher[Rn] = registers (3 registers (elements interleaved))Vektor (SIMD) |
| {Vt.T, Vt2.T, Vt3.T}, [Xn|SP], Xm|#imm | 0 Q 0011001 0 0 Rm 0100 size Rn Rt0x0C804000 / Maske 0xBFE0F000 | Speichern von 3 Registern (Elemente abwechselnd) mit Nach-Indizierung[Rn] = registers; Rn = Rn + Xm or the sizeVektor (SIMD) | |
| {Vt.Ts, Vt2.Ts, Vt3.Ts}[index], [Xn|SP] | 0 Q 0011010 0 0 00000 e 1 S size Rn Rt0x0D002000 / Maske 0xBFFF2000 | Speichern eines Elements (Lane) von 3 Registern[Rn] = Vt[index]Vektor (SIMD) | |
| st4 | {Vt.T, Vt2.T, Vt3.T, Vt4.T}, [Xn|SP] | 0 Q 0011000 0 000000 0000 size Rn Rt0x0C000000 / Maske 0xBFFFF000 | Speichern von 4 Register (Elemente abwechselnd) in den Speicher[Rn] = registers (4 registers (elements interleaved))Vektor (SIMD) |
| {Vt.T, Vt2.T, Vt3.T, Vt4.T}, [Xn|SP], Xm|#imm | 0 Q 0011001 0 0 Rm 0000 size Rn Rt0x0C800000 / Maske 0xBFE0F000 | Speichern von 4 Registern (Elemente abwechselnd) mit Nach-Indizierung[Rn] = registers; Rn = Rn + Xm or the sizeVektor (SIMD) | |
| {Vt.Ts, Vt2.Ts, Vt3.Ts, Vt4.Ts}[index], [Xn|SP] | 0 Q 0011010 0 1 00000 e 1 S size Rn Rt0x0D202000 / Maske 0xBFFF2000 | Speichern eines Elements (Lane) von 4 Registern[Rn] = Vt[index]Vektor (SIMD) | |
| stg | Xt|SP, [Xn|SP], #imm9 | 11011001 001 imm9 01 Rn Rt0xD9200400 / Maske 0xFFE00C00 | Speichern des Tags einer Adresse für 16 Byte (Nach-Indizierung)tag of [addr] = tag of Xt (imm9 * 16 added to the address)Speicher-Tagging (MTE) |
| Xt|SP, [Xn|SP{, #imm9}] | 11011001 001 imm9 10 Rn Rt0xD9200800 / Maske 0xFFE00C00 | Speichern des Tags einer Adresse für 16 Bytetag of [addr] = tag of Xt (imm9 * 16 added to the address)Speicher-Tagging (MTE) | |
| Xt|SP, [Xn|SP, #imm9]! | 11011001 001 imm9 11 Rn Rt0xD9200C00 / Maske 0xFFE00C00 | Speichern des Tags einer Adresse für 16 Byte (Vor-Indizierung)tag of [addr] = tag of Xt (imm9 * 16 added to the address)Speicher-Tagging (MTE) | |
| stgp | Xt, Xt2, [Xn|SP], #imm7 | 01 101 0 001 0 imm7 Rt2 Rn Rt0x68800000 / Maske 0xFFC00000 | Speichern eines Registerpaares und des Tags (Nach-Indizierung)[addr] = Xt, Xt2; tag of [addr] = tag of RnSpeicher-Tagging (MTE) |
| Xt, Xt2, [Xn|SP{, #imm7}] | 01 101 0 010 0 imm7 Rt2 Rn Rt0x69000000 / Maske 0xFFC00000 | Speichern eines Registerpaares und des Tags[addr] = Xt, Xt2; tag of [addr] = tag of RnSpeicher-Tagging (MTE) | |
| Xt, Xt2, [Xn|SP, #imm7]! | 01 101 0 011 0 imm7 Rt2 Rn Rt0x69800000 / Maske 0xFFC00000 | Speichern eines Registerpaares und des Tags (Vor-Indizierung)[addr] = Xt, Xt2; tag of [addr] = tag of RnSpeicher-Tagging (MTE) | |
| stllr | Wt, [Xn|SP]auch: stllrb, stllrh | size 001000 1 0 0 11111 0 11111 Rn Rt0x089F7C00 / Maske 0x3FFFFC00 | Speichern mit Release für eine Speicher-Region mit Ordnung (LORegion; b = Byte, h = Halbwort)[Rn] = WtLaden und Speichern |
| stlr | Wt, [Xn|SP] | 10 001000 1 0 0 11111 1 11111 Rn Rt0x889FFC00 / Maske 0xFFFFFC00 | Speichern mit Freigabe (release) (Wort)release; [Rn] = RtLaden und Speichern |
| Xt, [Xn|SP] | 11 001000 1 0 0 11111 1 11111 Rn Rt0xC89FFC00 / Maske 0xFFFFFC00 | Speichern mit Freigabe (release) (Doppelwort)release; [Rn] = RtLaden und Speichern | |
| stlrb | Wt, [Xn|SP] | 00 001000 1 0 0 11111 1 11111 Rn Rt0x089FFC00 / Maske 0xFFFFFC00 | Speichern mit Freigabe (release) (Byte)release; [Rn] = RtLaden und Speichern |
| stlrh | Wt, [Xn|SP] | 01 001000 1 0 0 11111 1 11111 Rn Rt0x489FFC00 / Maske 0xFFFFFC00 | Speichern mit Freigabe (release) (Halbwort)release; [Rn] = RtLaden und Speichern |
| stlur | Wt, [Xn|SP{, #imm9}]auch: stlurb, stlurh | size 011 001 00 0 imm9 00 Rn Rt0x19000000 / Maske 0x3FE00C00 | Speichern mit Release (ohne Skalierung, Adresse: Rn + imm9; b = Byte, h = Halbwort)[Rn + imm9] = WtLaden und Speichern |
| stlxp | Ws, Rt, Rt2, [Xn|SP] | 1 sz 001000 0 0 1 Rs 1 Rt2 Rn Rt0x88208000 / Maske 0xBFE08000 | Bedingtes Speichern eines Registerpaares (exklusiv) mit Freigabeif the exclusive monitor is set then { release; [Rn] = Rt; [Rn + size] = Rt2; Ws = 0 } else Ws = 1Laden und Speichern |
| stlxr | Ws, Wt, [Xn|SP] | 10 001000 0 0 0 Rs 1 11111 Rn Rt0x8800FC00 / Maske 0xFFE0FC00 | Bedingtes Speichern (exklusiv) mit Freigabe (release) (Wort)if the exclusive monitor is set then { release; [Rn] = Rt; Ws = 0 } else Ws = 1Laden und Speichern |
| Ws, Xt, [Xn|SP] | 11 001000 0 0 0 Rs 1 11111 Rn Rt0xC800FC00 / Maske 0xFFE0FC00 | Bedingtes Speichern (exklusiv) mit Freigabe (release) (Doppelwort)if the exclusive monitor is set then { release; [Rn] = Rt; Ws = 0 } else Ws = 1Laden und Speichern | |
| stlxrb | Ws, Wt, [Xn|SP] | 00 001000 0 0 0 Rs 1 11111 Rn Rt0x0800FC00 / Maske 0xFFE0FC00 | Bedingtes Speichern (exklusiv) mit Freigabe (release) (Byte)if the exclusive monitor is set then { release; [Rn] = Rt; Ws = 0 } else Ws = 1Laden und Speichern |
| stlxrh | Ws, Wt, [Xn|SP] | 01 001000 0 0 0 Rs 1 11111 Rn Rt0x4800FC00 / Maske 0xFFE0FC00 | Bedingtes Speichern (exklusiv) mit Freigabe (release) (Halbwort)if the exclusive monitor is set then { release; [Rn] = Rt; Ws = 0 } else Ws = 1Laden und Speichern |
| stnp | Rt, Rt2, [Xn|SP{, #imm7}] | sf 0 101 0 000 0 imm7 Rt2 Rn Rt0x28000000 / Maske 0x7FC00000 | Speichern eines Registerpaares ohne Cache-Hinweis[addr] = Rt; [addr + size] = Rt2Laden und Speichern |
| stp | Rt, Rt2, [Xn|SP], #imm7 | sf 0 101 0 001 0 imm7 Rt2 Rn Rt0x28800000 / Maske 0x7FC00000 | Speichern eines Registerpaares (Nach-Indizierung)[addr] = Rt; [addr + size] = Rt2; addr = Rn; Rn = Rn + imm7 * sizeLaden und Speichern |
| Rt, Rt2, [Xn|SP{, #imm7}] | sf 0 101 0 010 0 imm7 Rt2 Rn Rt0x29000000 / Maske 0x7FC00000 | Speichern eines Registerpaares[addr] = Rt; [addr + size] = Rt2; addr = Rn + imm7 * sizeLaden und Speichern | |
| Rt, Rt2, [Xn|SP, #imm7]! | sf 0 101 0 011 0 imm7 Rt2 Rn Rt0x29800000 / Maske 0x7FC00000 | Speichern eines Registerpaares (Vor-Indizierung)[addr] = Rt; [addr + size] = Rt2; Rn = Rn + imm7 * size; addr = RnLaden und Speichern | |
| Ft, Ft2, [Xn|SP{, #imm7}] | opc 101 1 010 0 imm7 Rt2 Rn Rt0x2D000000 / Maske 0x3FC00000 | Speichern eines Paares von Gleitkomma-/Vektor-Registern (opc 00 = S, 01 = D, 10 = Q)[addr] = Ft; [addr + size] = Ft2Laden und Speichern | |
| str | Wt, [Xn|SP{, #imm12}] | 10 111 0 01 00 imm12 Rn Rt0xB9000000 / Maske 0xFFC00000 | Speichern eines Wortes (32 Bit) (Adresse: Rn + imm12 * Größe)[addr] = Wt; addr = Rn + imm12 * sizeLaden und Speichern |
| Wt, [Xn|SP, #imm9]! | 10 111 0 00 00 0 imm9 11 Rn Rt0xB8000C00 / Maske 0xFFE00C00 | Speichern eines Wortes (32 Bit) (Vor-Indizierung: Rn wird zuerst geändert)[addr] = Wt; Rn = Rn + imm9; addr = RnLaden und Speichern | |
| Wt, [Xn|SP], #imm9 | 10 111 0 00 00 0 imm9 01 Rn Rt0xB8000400 / Maske 0xFFE00C00 | Speichern eines Wortes (32 Bit) (Nach-Indizierung: Rn wird danach geändert)[addr] = Wt; addr = Rn; Rn = Rn + imm9Laden und Speichern | |
| Wt, [Xn|SP, Rm{, extend {#amount}}] | 10 111 0 00 00 1 Rm option S 10 Rn Rt0xB8200800 / Maske 0xFFE00C00 | Speichern eines Wortes (32 Bit) (Adresse: Rn + Register, erweitert und verschoben)[addr] = Wt; addr = Rn + extend(Rm) << (S * log2(size))Laden und Speichern | |
| Xt, [Xn|SP{, #imm12}] | 11 111 0 01 00 imm12 Rn Rt0xF9000000 / Maske 0xFFC00000 | Speichern eines Doppelwortes (64 Bit) (Adresse: Rn + imm12 * Größe)[addr] = Xt; addr = Rn + imm12 * sizeLaden und Speichern | |
| Xt, [Xn|SP, #imm9]! | 11 111 0 00 00 0 imm9 11 Rn Rt0xF8000C00 / Maske 0xFFE00C00 | Speichern eines Doppelwortes (64 Bit) (Vor-Indizierung: Rn wird zuerst geändert)[addr] = Xt; Rn = Rn + imm9; addr = RnLaden und Speichern | |
| Xt, [Xn|SP], #imm9 | 11 111 0 00 00 0 imm9 01 Rn Rt0xF8000400 / Maske 0xFFE00C00 | Speichern eines Doppelwortes (64 Bit) (Nach-Indizierung: Rn wird danach geändert)[addr] = Xt; addr = Rn; Rn = Rn + imm9Laden und Speichern | |
| Xt, [Xn|SP, Rm{, extend {#amount}}] | 11 111 0 00 00 1 Rm option S 10 Rn Rt0xF8200800 / Maske 0xFFE00C00 | Speichern eines Doppelwortes (64 Bit) (Adresse: Rn + Register, erweitert und verschoben)[addr] = Xt; addr = Rn + extend(Rm) << (S * log2(size))Laden und Speichern | |
| Ft, [Xn|SP{, #imm12}] | 1 x 111 1 01 00 imm12 Rn Rt0xBD000000 / Maske 0xBFC00000 | Speichern eines Single- (x=0) oder Double-Registers (x=1)[Rn + imm12 * size] = FtLaden und Speichern | |
| Qt, [Xn|SP{, #imm12}] | 00 111 1 01 10 imm12 Rn Rt0x3D800000 / Maske 0xFFC00000 | Speichern eines 128-Bit-Vektor-Registers[Rn + imm12 * 16] = QtLaden und Speichern | |
| strb | Wt, [Xn|SP{, #imm12}] | 00 111 0 01 00 imm12 Rn Rt0x39000000 / Maske 0xFFC00000 | Speichern eines Bytes (Adresse: Rn + imm12 * Größe)[addr] = Wt[7:0]; addr = Rn + imm12 * sizeLaden und Speichern |
| Wt, [Xn|SP, #imm9]! | 00 111 0 00 00 0 imm9 11 Rn Rt0x38000C00 / Maske 0xFFE00C00 | Speichern eines Bytes (Vor-Indizierung: Rn wird zuerst geändert)[addr] = Wt[7:0]; Rn = Rn + imm9; addr = RnLaden und Speichern | |
| Wt, [Xn|SP], #imm9 | 00 111 0 00 00 0 imm9 01 Rn Rt0x38000400 / Maske 0xFFE00C00 | Speichern eines Bytes (Nach-Indizierung: Rn wird danach geändert)[addr] = Wt[7:0]; addr = Rn; Rn = Rn + imm9Laden und Speichern | |
| Wt, [Xn|SP, Rm{, extend {#amount}}] | 00 111 0 00 00 1 Rm option S 10 Rn Rt0x38200800 / Maske 0xFFE00C00 | Speichern eines Bytes (Adresse: Rn + Register, erweitert und verschoben)[addr] = Wt[7:0]; addr = Rn + extend(Rm) << (S * log2(size))Laden und Speichern | |
| strh | Wt, [Xn|SP{, #imm12}] | 01 111 0 01 00 imm12 Rn Rt0x79000000 / Maske 0xFFC00000 | Speichern eines Halbwortes (16 Bit) (Adresse: Rn + imm12 * Größe)[addr] = Wt[15:0]; addr = Rn + imm12 * sizeLaden und Speichern |
| Wt, [Xn|SP, #imm9]! | 01 111 0 00 00 0 imm9 11 Rn Rt0x78000C00 / Maske 0xFFE00C00 | Speichern eines Halbwortes (16 Bit) (Vor-Indizierung: Rn wird zuerst geändert)[addr] = Wt[15:0]; Rn = Rn + imm9; addr = RnLaden und Speichern | |
| Wt, [Xn|SP], #imm9 | 01 111 0 00 00 0 imm9 01 Rn Rt0x78000400 / Maske 0xFFE00C00 | Speichern eines Halbwortes (16 Bit) (Nach-Indizierung: Rn wird danach geändert)[addr] = Wt[15:0]; addr = Rn; Rn = Rn + imm9Laden und Speichern | |
| Wt, [Xn|SP, Rm{, extend {#amount}}] | 01 111 0 00 00 1 Rm option S 10 Rn Rt0x78200800 / Maske 0xFFE00C00 | Speichern eines Halbwortes (16 Bit) (Adresse: Rn + Register, erweitert und verschoben)[addr] = Wt[15:0]; addr = Rn + extend(Rm) << (S * log2(size))Laden und Speichern | |
| sttr | Wt, [Xn|SP{, #imm9}]auch: sttrb, sttrh | size 111 0 00 00 0 imm9 10 Rn Rt0x38000800 / Maske 0x3FE00C00 | Speichern mit den Rechten des Anwendungs-Modus (unprivilegiert; b = Byte, h = Halbwort)[Rn + imm9] = WtLaden und Speichern |
| stur | Wt, [Xn|SP{, #imm9}] | 10 111 0 00 00 0 imm9 00 Rn Rt0xB8000000 / Maske 0xFFE00C00 | Speichern eines Wortes (32 Bit) (ohne Skalierung, Adresse: Rn + imm9)[addr] = Wt; addr = Rn + imm9Laden und Speichern |
| Xt, [Xn|SP{, #imm9}] | 11 111 0 00 00 0 imm9 00 Rn Rt0xF8000000 / Maske 0xFFE00C00 | Speichern eines Doppelwortes (64 Bit) (ohne Skalierung, Adresse: Rn + imm9)[addr] = Xt; addr = Rn + imm9Laden und Speichern | |
| sturb | Wt, [Xn|SP{, #imm9}] | 00 111 0 00 00 0 imm9 00 Rn Rt0x38000000 / Maske 0xFFE00C00 | Speichern eines Bytes (ohne Skalierung, Adresse: Rn + imm9)[addr] = Wt[7:0]; addr = Rn + imm9Laden und Speichern |
| sturh | Wt, [Xn|SP{, #imm9}] | 01 111 0 00 00 0 imm9 00 Rn Rt0x78000000 / Maske 0xFFE00C00 | Speichern eines Halbwortes (16 Bit) (ohne Skalierung, Adresse: Rn + imm9)[addr] = Wt[15:0]; addr = Rn + imm9Laden und Speichern |
| stxp | Ws, Rt, Rt2, [Xn|SP] | 1 sz 001000 0 0 1 Rs 0 Rt2 Rn Rt0x88200000 / Maske 0xBFE08000 | Bedingtes Speichern eines Registerpaares (exklusiv)if the exclusive monitor is set then { [Rn] = Rt; [Rn + size] = Rt2; Ws = 0 } else Ws = 1Laden und Speichern |
| stxr | Ws, Wt, [Xn|SP] | 10 001000 0 0 0 Rs 0 11111 Rn Rt0x88007C00 / Maske 0xFFE0FC00 | Bedingtes Speichern (exklusiv): Ws = 0 bei Erfolg (Wort)if the exclusive monitor is set then { [Rn] = Rt; Ws = 0 } else Ws = 1Laden und Speichern |
| Ws, Xt, [Xn|SP] | 11 001000 0 0 0 Rs 0 11111 Rn Rt0xC8007C00 / Maske 0xFFE0FC00 | Bedingtes Speichern (exklusiv): Ws = 0 bei Erfolg (Doppelwort)if the exclusive monitor is set then { [Rn] = Rt; Ws = 0 } else Ws = 1Laden und Speichern | |
| stxrb | Ws, Wt, [Xn|SP] | 00 001000 0 0 0 Rs 0 11111 Rn Rt0x08007C00 / Maske 0xFFE0FC00 | Bedingtes Speichern (exklusiv): Ws = 0 bei Erfolg (Byte)if the exclusive monitor is set then { [Rn] = Rt; Ws = 0 } else Ws = 1Laden und Speichern |
| stxrh | Ws, Wt, [Xn|SP] | 01 001000 0 0 0 Rs 0 11111 Rn Rt0x48007C00 / Maske 0xFFE0FC00 | Bedingtes Speichern (exklusiv): Ws = 0 bei Erfolg (Halbwort)if the exclusive monitor is set then { [Rn] = Rt; Ws = 0 } else Ws = 1Laden und Speichern |
| stz2g | Xt|SP, [Xn|SP], #imm9 | 11011001 111 imm9 01 Rn Rt0xD9E00400 / Maske 0xFFE00C00 | Speichern des Tags und Nullen von 32 Byte (Nach-Indizierung)tag of [addr] = tag of Xt (imm9 * 16 added to the address)Speicher-Tagging (MTE) |
| Xt|SP, [Xn|SP{, #imm9}] | 11011001 111 imm9 10 Rn Rt0xD9E00800 / Maske 0xFFE00C00 | Speichern des Tags und Nullen von 32 Bytetag of [addr] = tag of Xt (imm9 * 16 added to the address)Speicher-Tagging (MTE) | |
| Xt|SP, [Xn|SP, #imm9]! | 11011001 111 imm9 11 Rn Rt0xD9E00C00 / Maske 0xFFE00C00 | Speichern des Tags und Nullen von 32 Byte (Vor-Indizierung)tag of [addr] = tag of Xt (imm9 * 16 added to the address)Speicher-Tagging (MTE) | |
| stzg | Xt|SP, [Xn|SP], #imm9 | 11011001 011 imm9 01 Rn Rt0xD9600400 / Maske 0xFFE00C00 | Speichern des Tags und Nullen von 16 Byte (Nach-Indizierung)tag of [addr] = tag of Xt (imm9 * 16 added to the address)Speicher-Tagging (MTE) |
| Xt|SP, [Xn|SP{, #imm9}] | 11011001 011 imm9 10 Rn Rt0xD9600800 / Maske 0xFFE00C00 | Speichern des Tags und Nullen von 16 Bytetag of [addr] = tag of Xt (imm9 * 16 added to the address)Speicher-Tagging (MTE) | |
| Xt|SP, [Xn|SP, #imm9]! | 11011001 011 imm9 11 Rn Rt0xD9600C00 / Maske 0xFFE00C00 | Speichern des Tags und Nullen von 16 Byte (Vor-Indizierung)tag of [addr] = tag of Xt (imm9 * 16 added to the address)Speicher-Tagging (MTE) | |
| stzgm | Xt, [Xn|SP] | 11011001 001 000000000 00 Rn Rt0xD9200000 / Maske 0xFFFFFC00 | Speichern mehrerer Tags und Nullen des Speichers (Größe aus dem System)tags and memory of the block at Rn = XtSpeicher-Tagging (MTE) |
| sub | Rd, Rn, #imm12{, lsl #12} | sf 1 0 100010 sh imm12 Rn Rd0x51000000 / Maske 0x7F800000 | Subtraktion einer Konstanten (12 Bit, optional um 12 verschoben)Rd = Rn - (imm12 << (sh * 12)) (Rd and Rn may be SP)Arithmetik |
| Rd, Rn, Rm{, shift #imm6}auch: neg | sf 1 0 01011 shift 0 Rm imm6 Rn Rd0x4B000000 / Maske 0x7F200000 | Subtraktion mit verschobenem RegisterRd = Rn - shift(Rm, imm6)Arithmetik | |
| Rd, Rn, Rm{, extend #imm3} | sf 1 0 01011 00 1 Rm option imm3 Rn Rd0x4B200000 / Maske 0x7FE00000 | Subtraktion mit erweitertem RegisterRd = Rn - (extend(Rm) << imm3) (Rd and Rn may be SP)Arithmetik | |
| Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 10000 1 Rn Rd0x2E208400 / Maske 0xBF20FC00 | Subtraktion der Elementefor every element: Vd[i] = Vn[i] - Vm[i]Vektor (SIMD) | |
| subg | Xd|SP, Xn|SP, #uimm6, #uimm4 | 1 1 0 100011 0 imm6 00 imm4 Rn Rd0xD1800000 / Maske 0xFFC0C000 | Subtraktion von einer Adresse mit Änderung des TagsXd = Xn - uimm6 * 16, tag = (tag of Xn - uimm4) modulo 16Speicher-Tagging (MTE) |
| subhn | Vd.Tb, Vn.Ta, Vm.Taauch: subhn2 | 0 Q 0 01110 size 1 Rm 0110 00 Rn Rd0x0E206000 / Maske 0xBF20FC00 | Subtraktion mit Verschmälerung (obere Hälfte; rsubhn mit Runden) (mit Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = high half of (Vn[i] - Vm[i])Vektor (SIMD) |
| subp | Xd, Xn|SP, Xm|SP | 1 0 0 11010110 Rm 000000 Rn Rd0x9AC00000 / Maske 0xFFE0FC00 | Differenz zweier Adressen ohne Tags (56 Bit, mit Vorzeichen)Xd = sext(Xn[55:0]) - sext(Xm[55:0])Speicher-Tagging (MTE) |
| subps | Xd, Xn|SP, Xm|SP | 1 0 1 11010110 Rm 000000 Rn Rd0xBAC00000 / Maske 0xFFE0FC00 | Differenz zweier Adressen ohne Tags, setzt die FlagsXd = sext(Xn[55:0]) - sext(Xm[55:0])Flags: N Z C VSpeicher-Tagging (MTE) |
| subs | Rd, Rn, #imm12{, lsl #12}auch: cmp | sf 1 1 100010 sh imm12 Rn Rd0x71000000 / Maske 0x7F800000 | Subtraktion einer Konstanten, setzt die FlagsRd = Rn - (imm12 << (sh * 12))Flags: N Z C VArithmetik |
| Rd, Rn, Rm{, shift #imm6}auch: cmp, negs | sf 1 1 01011 shift 0 Rm imm6 Rn Rd0x6B000000 / Maske 0x7F200000 | Subtraktion mit verschobenem Register, setzt die FlagsRd = Rn - shift(Rm, imm6)Flags: N Z C VArithmetik | |
| Rd, Rn, Rm{, extend #imm3}auch: cmp | sf 1 1 01011 00 1 Rm option imm3 Rn Rd0x6B200000 / Maske 0x7FE00000 | Subtraktion mit erweitertem Register, setzt die FlagsRd = Rn - (extend(Rm) << imm3)Flags: N Z C VArithmetik | |
| sudot | Vd.4S, Vn.16B, Vm.4B[index] | 0 Q 0 01111 00 L M Rm 1111 H 0 Rn Rd0x0F00F000 / Maske 0xBFC0F400 | Skalarprodukt je vier Bytes mit einem Element (Vn mit, Vm ohne Vorzeichen), addiert zum 32-Bit-Zielfor every element: Vd[i] = Vd[i] + sum of Vn[4i+k] * Vm[index][k]Vektor (SIMD) |
| suqadd | Vd.T, Vn.T | 0 Q 0 01110 size 10000 00011 10 Rn Rd0x0E203800 / Maske 0xBF3FFC00 | Addition eines Wertes ohne Vorzeichen zu einem mit Vorzeichen, mit Sättigungfor every element: Vd[i] = saturate_signed(Vd[i] + Vn[i])Vektor (SIMD) |
| svc | #imm16 | 11010100 000 imm16 000 010xD4000001 / Maske 0xFFE0001F | Systemaufruf an das Betriebssystem (Ausnahmestufe 1)raise a supervisor call exception with imm16System und Privilegien |
| swp | Ws, Wt, [Xn|SP]auch: swpa, swpal, swpl, swpb, swpab, swpalb, swplb, swph, swpah, swpalh, swplh | size 111 0 00 A R 1 Rs 1 000 00 Rn Rt0x38208000 / Maske 0x3F20FC00 | Atomarer Austausch eines Registers mit dem Speicher (Varianten: b = Byte, h = Halbwort, a = Acquire, l = Release)t = [Rn]; [Rn] = Ws; Wt = tAtomare Speicherzugriffe (LSE) |
| sys | #op1, Cn, Cm, #op2{, Xt}auch: sysl, tlbi | 1101010100 L 01 op1 CRn CRm op2 Rt0xD5080000 / Maske 0xFFD80000 | Systembefehl (Cache-, TLB- und Adress-Umwandlungs-Operationen, auch als dc, ic, at, tlbi geschrieben; sysl liest ein Ergebnis)execute the system operation (op1, Cn, Cm, op2) with XtSystem und Privilegien |
| tbl | Vd.T, {Vn.16B ...}, Vm.Tauch: tbx | 0 Q 001110 00 0 Rm 0 len op 00 Rn Rd0x0E000000 / Maske 0xBFE08C00 | Nachschlagen von Bytes in einer Tabelle aus 1 bis 4 Vektoren (tbx lässt Bytes außerhalb unverändert, tbl setzt sie auf 0)for every element: Vd[i] = table[Vm[i]]Vektor (SIMD) |
| tbnz | Rt, #bit, label | b5 011011 1 b40 imm14 Rt0x37000000 / Maske 0x7F000000 | Sprung, wenn ein Bit des Registers 1 istif bit(b5:b40) of Rt == 1 then pc = pc + sext(imm14 << 2)Sprünge und Aufrufe |
| tbz | Rt, #bit, label | b5 011011 0 b40 imm14 Rt0x36000000 / Maske 0x7F000000 | Sprung, wenn ein Bit des Registers 0 istif bit(b5:b40) of Rt == 0 then pc = pc + sext(imm14 << 2)Sprünge und Aufrufe |
| tcancel | #imm16 | 11010100 011 imm16 000 000xD4600000 / Maske 0xFFE0001F | Abbrechen einer Transaktion (TME)abort the transaction with the reason imm16System und Privilegien |
| trn1 | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 0 Rm 0 010 10 Rn Rd0x0E002800 / Maske 0xBF20FC00 | Transponieren: Elemente mit geraden Nummern abwechselnd aus zwei VektorenVd = Vn[0], Vm[0], Vn[2], Vm[2] ...Vektor (SIMD) |
| trn2 | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 0 Rm 0 110 10 Rn Rd0x0E006800 / Maske 0xBF20FC00 | Transponieren: Elemente mit ungeraden Nummern abwechselnd aus zwei VektorenVd = Vn[1], Vm[1], Vn[3], Vm[3] ...Vektor (SIMD) |
| uaba | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 01111 1 Rn Rd0x2E207C00 / Maske 0xBF20FC00 | Addition des absoluten Unterschieds zum Ziel (ohne Vorzeichen)for every element: Vd[i] = Vd[i] + abs(Vn[i] - Vm[i])Vektor (SIMD) |
| uabal | Vd.Tb, Vn.Ta, Vm.Taauch: uabal2 | 0 Q 1 01110 size 1 Rm 0101 00 Rn Rd0x2E205000 / Maske 0xBF20FC00 | Addition des absoluten Unterschieds mit Verbreiterung (ohne Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = Vd[i] + abs(Vn[i] - Vm[i])Vektor (SIMD) |
| uabd | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 01110 1 Rn Rd0x2E207400 / Maske 0xBF20FC00 | Absoluter Unterschied (ohne Vorzeichen)for every element: Vd[i] = abs(Vn[i] - Vm[i])Vektor (SIMD) |
| uabdl | Vd.Tb, Vn.Ta, Vm.Taauch: uabdl2 | 0 Q 1 01110 size 1 Rm 0111 00 Rn Rd0x2E207000 / Maske 0xBF20FC00 | Absoluter Unterschied mit Verbreiterung (ohne Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = abs(Vn[i] - Vm[i]) (wide result)Vektor (SIMD) |
| uadalp | Vd.T, Vn.T | 0 Q 1 01110 size 10000 00110 10 Rn Rd0x2E206800 / Maske 0xBF3FFC00 | Paarweise Addition mit Verbreiterung, addiert zum Ziel (ohne Vorzeichen)for every element: Vd[i] = Vd[i] + Vn[2i] + Vn[2i+1]Vektor (SIMD) |
| uaddl | Vd.Tb, Vn.Ta, Vm.Taauch: uaddl2 | 0 Q 1 01110 size 1 Rm 0000 00 Rn Rd0x2E200000 / Maske 0xBF20FC00 | Addition mit Verbreiterung (beide Operanden werden doppelt so breit) (ohne Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = Vn[i] + Vm[i] (wide result)Vektor (SIMD) |
| uaddlp | Vd.T, Vn.T | 0 Q 1 01110 size 10000 00010 10 Rn Rd0x2E202800 / Maske 0xBF3FFC00 | Paarweise Addition benachbarter Elemente mit Verbreiterung (ohne Vorzeichen)for every element: Vd[i] = Vn[2i] + Vn[2i+1]Vektor (SIMD) |
| uaddlv | Vd, Vn.T | 0 Q 1 01110 size 11000 00011 10 Rn Rd0x2E303800 / Maske 0xBF3FFC00 | Summe aller Elemente mit Verbreiterung (ohne Vorzeichen)Vd = sum of all elements of VnVektor (SIMD) |
| uaddw | Vd.Tb, Vn.Ta, Vm.Taauch: uaddw2 | 0 Q 1 01110 size 1 Rm 0001 00 Rn Rd0x2E201000 / Maske 0xBF20FC00 | Addition eines breiten und eines schmalen Operanden (ohne Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = Vn[i] + Vm[i] (Vn is wide)Vektor (SIMD) |
| ubfm | Rd, Rn, #immr, #immsauch: lsl, lsr, ubfiz, ubfx, uxtb, uxth | sf 1 0 100110 N immr imms Rn Rd0x53000000 / Maske 0x7F800000 | Bitfeld verschieben mit Nullen (Grundform von lsl, lsr, ubfx, uxtb ...)Rd = zero-extended field of Rn selected by immr, immsBitfelder |
| ucvtf | Fd, Rn | sf 0 0 11110 ftype 1 00 011 000000 Rn Rd0x1E230000 / Maske 0x7F3FFC00 | Umwandlung einer Ganzzahl ohne Vorzeichen in GleitkommaFd = (float) zext(Rn)Gleitkomma (skalar) |
| Vd.T, Vn.T | 0 Q 1 01110 0 sz 10000 11101 10 Rn Rd0x2E21D800 / Maske 0xBFBFFC00 | Umwandlung einer Ganzzahl ohne Vorzeichen in Gleitkommafor every element: Vd[i] = (float) Vn[i]Vektor (SIMD) | |
| udf | #imm16 | 0000000000000000 imm160x00000000 / Maske 0xFFFF0000 | Nicht definierter Befehl (löst immer eine Ausnahme aus)raise undefined-instruction exceptionSystem und Privilegien |
| udiv | Rd, Rn, Rm | sf 0 0 11010110 Rm 000010 Rn Rd0x1AC00800 / Maske 0x7FE0FC00 | Division ohne Vorzeichen (Division durch 0 ergibt 0)Rd = Rn / RmArithmetik |
| udot | Vd.4S, Vn.16B, Vm.16B | 0 Q 1 01110 10 0 Rm 10010 1 Rn Rd0x2E809400 / Maske 0xBFE0FC00 | Skalarprodukt von je vier Bytes (ohne Vorzeichen), addiert zum 32-Bit-Zielfor every element: Vd[i] = Vd[i] + sum of Vn[4i+k] * Vm[4i+k]Vektor (SIMD) |
| uhadd | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 00000 1 Rn Rd0x2E200400 / Maske 0xBF20FC00 | Halbierende Addition (ohne Vorzeichen)for every element: Vd[i] = (Vn[i] + Vm[i]) >> 1Vektor (SIMD) |
| uhsub | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 00100 1 Rn Rd0x2E202400 / Maske 0xBF20FC00 | Halbierende Subtraktion (ohne Vorzeichen)for every element: Vd[i] = (Vn[i] - Vm[i]) >> 1Vektor (SIMD) |
| umaddl | Xd, Wn, Wm, Xaauch: umull | 1 00 11011 101 Rm 0 Ra Rn Rd0x9BA00000 / Maske 0xFFE08000 | Multiplikation 32 x 32 Bit ohne Vorzeichen, Addition zu 64 BitXd = Xa + zext(Wn) * zext(Wm)Arithmetik |
| umax | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 01100 1 Rn Rd0x2E206400 / Maske 0xBF20FC00 | Maximum der Elemente (ohne Vorzeichen)for every element: Vd[i] = max_unsigned(Vn[i], Vm[i])Vektor (SIMD) |
| umaxp | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 10100 1 Rn Rd0x2E20A400 / Maske 0xBF20FC00 | Maximum benachbarter Elementpaare (ohne Vorzeichen)for every element: Vd[i] = max_unsigned of each pair of (Vn:Vm)Vektor (SIMD) |
| umaxv | Vd, Vn.T | 0 Q 1 01110 size 11000 01010 10 Rn Rd0x2E30A800 / Maske 0xBF3FFC00 | Maximum aller Elemente (ohne Vorzeichen)Vd = max_unsigned of all elements of VnVektor (SIMD) |
| umin | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 01101 1 Rn Rd0x2E206C00 / Maske 0xBF20FC00 | Minimum der Elemente (ohne Vorzeichen)for every element: Vd[i] = min_unsigned(Vn[i], Vm[i])Vektor (SIMD) |
| uminp | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 10101 1 Rn Rd0x2E20AC00 / Maske 0xBF20FC00 | Minimum benachbarter Elementpaare (ohne Vorzeichen)for every element: Vd[i] = min_unsigned of each pair of (Vn:Vm)Vektor (SIMD) |
| uminv | Vd, Vn.T | 0 Q 1 01110 size 11000 11010 10 Rn Rd0x2E31A800 / Maske 0xBF3FFC00 | Minimum aller Elemente (ohne Vorzeichen)Vd = min_unsigned of all elements of VnVektor (SIMD) |
| umlal | Vd.Tb, Vn.Ta, Vm.Taauch: umlal2 | 0 Q 1 01110 size 1 Rm 1000 00 Rn Rd0x2E208000 / Maske 0xBF20FC00 | Multiplikation mit Verbreiterung, addiert zum Ziel (ohne Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = Vd[i] + Vn[i] * Vm[i]Vektor (SIMD) |
| Vd.Ta, Vn.Tb, Vm.Ts[index]auch: umlal2 | 0 Q 1 01111 size L M Rm 0010 H 0 Rn Rd0x2F002000 / Maske 0xBF00F400 | Multiplikation mit einem Element und Verbreiterung, addiert zum Ziel (ohne Vorzeichen) (Q = 1: Name mit 2)for every element: Vd[i] = Vd[i] + Vn[i] * Vm[index]Vektor (SIMD) | |
| umlsl | Vd.Tb, Vn.Ta, Vm.Taauch: umlsl2 | 0 Q 1 01110 size 1 Rm 1010 00 Rn Rd0x2E20A000 / Maske 0xBF20FC00 | Multiplikation mit Verbreiterung, subtrahiert vom Ziel (ohne Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = Vd[i] - Vn[i] * Vm[i]Vektor (SIMD) |
| Vd.Ta, Vn.Tb, Vm.Ts[index]auch: umlsl2 | 0 Q 1 01111 size L M Rm 0110 H 0 Rn Rd0x2F006000 / Maske 0xBF00F400 | Multiplikation mit einem Element und Verbreiterung, subtrahiert vom Ziel (ohne Vorzeichen) (Q = 1: Name mit 2)for every element: Vd[i] = Vd[i] - Vn[i] * Vm[index]Vektor (SIMD) | |
| ummla | Vd.4S, Vn.16B, Vm.16B | 0 1 1 01110 10 0 Rm 10100 1 Rn Rd0x6E80A400 / Maske 0xFFE0FC00 | Matrix-Multiplikation 2x8 mal 8x2 (ohne Vorzeichen), addiert zum ZielVd(2x2) = Vd(2x2) + Vn(2x8) * Vm(8x2)Vektor (SIMD) |
| umov | Rd, Vn.Ts[index]auch: mov | 0 Q 0 01110000 imm5 0 0111 1 Rn Rd0x0E003C00 / Maske 0xBFE0FC00 | Kopieren eines Elements in ein Ganzzahl-Register (ohne Vorzeichen)Rd = zext(Vn[index])Vektor (SIMD) |
| umsubl | Xd, Wn, Wm, Xaauch: umnegl | 1 00 11011 101 Rm 1 Ra Rn Rd0x9BA08000 / Maske 0xFFE08000 | Multiplikation 32 x 32 Bit ohne Vorzeichen, Subtraktion von 64 BitXd = Xa - zext(Wn) * zext(Wm)Arithmetik |
| umulh | Xd, Xn, Xm | 1 00 11011 110 Rm 0 11111 Rn Rd0x9BC07C00 / Maske 0xFFE0FC00 | Multiplikation ohne Vorzeichen, obere 64 Bit des ErgebnissesXd = (zext(Xn) * zext(Xm)) >> 64Arithmetik |
| umull | Vd.Tb, Vn.Ta, Vm.Taauch: umull2 | 0 Q 1 01110 size 1 Rm 1100 00 Rn Rd0x2E20C000 / Maske 0xBF20FC00 | Multiplikation mit Verbreiterung (ohne Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = Vn[i] * Vm[i] (wide result)Vektor (SIMD) |
| Vd.Ta, Vn.Tb, Vm.Ts[index]auch: umull2 | 0 Q 1 01111 size L M Rm 1010 H 0 Rn Rd0x2F00A000 / Maske 0xBF00F400 | Multiplikation mit einem Element und Verbreiterung (ohne Vorzeichen) (Q = 1: Name mit 2)for every element: Vd[i] = Vn[i] * Vm[index]Vektor (SIMD) | |
| uqadd | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 00001 1 Rn Rd0x2E200C00 / Maske 0xBF20FC00 | Addition mit Sättigung (ohne Vorzeichen)for every element: Vd[i] = saturate_unsigned(Vn[i] + Vm[i])Vektor (SIMD) |
| uqrshl | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 01011 1 Rn Rd0x2E205C00 / Maske 0xBF20FC00 | Schieben je Element mit Runden und Sättigung (ohne Vorzeichen)for every element: Vd[i] = saturate_unsigned(round(Vn[i] << Vm[i]))Vektor (SIMD) |
| uqrshrn | Vd.Tb, Vn.Ta, #shiftauch: uqrshrn2 | 0 Q 1 011110 0 immh immb 10011 1 Rn Rd0x2F009C00 / Maske 0xBFC0FC00 | Schieben nach rechts mit Verschmälern, Runden und Sättigung (ohne Vorzeichen) (Q = 1: Name mit 2)for every element: Vd[i] = saturate_unsigned(round(Vn[i] >> shift))Vektor (SIMD) |
| uqshl | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 01001 1 Rn Rd0x2E204C00 / Maske 0xBF20FC00 | Schieben je Element mit Sättigung (ohne Vorzeichen)for every element: Vd[i] = saturate_unsigned(Vn[i] << Vm[i])Vektor (SIMD) |
| Vd.T, Vn.T, #shift | 0 Q 1 011110 immh immb 01110 1 Rn Rd0x2F007400 / Maske 0xBF80FC00 | Schieben nach links mit Sättigung (ohne Vorzeichen)for every element: Vd[i] = saturate_unsigned(Vn[i] << shift)Vektor (SIMD) | |
| uqshrn | Vd.Tb, Vn.Ta, #shiftauch: uqshrn2 | 0 Q 1 011110 0 immh immb 10010 1 Rn Rd0x2F009400 / Maske 0xBFC0FC00 | Schieben nach rechts mit Verschmälern und Sättigung (ohne Vorzeichen) (Q = 1: Name mit 2)for every element: Vd[i] = saturate_unsigned(Vn[i] >> shift)Vektor (SIMD) |
| uqsub | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 00101 1 Rn Rd0x2E202C00 / Maske 0xBF20FC00 | Subtraktion mit Sättigung (ohne Vorzeichen)for every element: Vd[i] = saturate_unsigned(Vn[i] - Vm[i])Vektor (SIMD) |
| uqxtn | Vd.T, Vn.Tauch: uqxtn2 | 0 Q 1 01110 size 10000 10100 10 Rn Rd0x2E214800 / Maske 0xBF3FFC00 | Verschmälern mit Sättigung (ohne Vorzeichen)for every element: Vd[i] = saturate_unsigned(Vn[i])Vektor (SIMD) |
| urhadd | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 00010 1 Rn Rd0x2E201400 / Maske 0xBF20FC00 | Halbierende Addition mit Aufrunden (ohne Vorzeichen)for every element: Vd[i] = (Vn[i] + Vm[i] + 1) >> 1Vektor (SIMD) |
| urshl | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 01010 1 Rn Rd0x2E205400 / Maske 0xBF20FC00 | Schieben je Element mit Runden (ohne Vorzeichen)for every element: Vd[i] = round(Vn[i] << Vm[i])Vektor (SIMD) |
| urshr | Vd.T, Vn.T, #shift | 0 Q 1 011110 immh immb 00100 1 Rn Rd0x2F002400 / Maske 0xBF80FC00 | Schieben nach rechts mit Runden (ohne Vorzeichen)for every element: Vd[i] = round(Vn[i] >> shift)Vektor (SIMD) |
| ursra | Vd.T, Vn.T, #shift | 0 Q 1 011110 immh immb 00110 1 Rn Rd0x2F003400 / Maske 0xBF80FC00 | Schieben nach rechts mit Runden und Addition zum Ziel (ohne Vorzeichen)for every element: Vd[i] = Vd[i] + round(Vn[i] >> shift)Vektor (SIMD) |
| usdot | Vd.4S, Vn.16B, Vm.16B | 0 Q 0 01110 10 0 Rm 10011 1 Rn Rd0x0E809C00 / Maske 0xBFE0FC00 | Skalarprodukt von je vier Bytes (Vn ohne, Vm mit Vorzeichen), addiert zum 32-Bit-Zielfor every element: Vd[i] = Vd[i] + sum of Vn[4i+k] * Vm[4i+k]Vektor (SIMD) |
| ushl | Vd.T, Vn.T, Vm.T | 0 Q 1 01110 size 1 Rm 01000 1 Rn Rd0x2E204400 / Maske 0xBF20FC00 | Schieben nach links oder rechts je Element (ohne Vorzeichen)for every element: Vd[i] = Vn[i] << Vm[i] (a negative count shifts right)Vektor (SIMD) |
| ushll | Vd.Ta, Vn.Tb, #shiftauch: ushll2, uxtl, uxtl2 | 0 Q 1 011110 0 immh immb 10100 1 Rn Rd0x2F00A400 / Maske 0xBFC0FC00 | Verbreitern mit Linksschieben (ohne Vorzeichen; uxtl ist Schieben um 0)for every element: Vd[i] = zext(Vn[i]) << shiftVektor (SIMD) |
| ushr | Vd.T, Vn.T, #shift | 0 Q 1 011110 immh immb 00000 1 Rn Rd0x2F000400 / Maske 0xBF80FC00 | Schieben nach rechts mit Vorzeichen (ohne Vorzeichen)for every element: Vd[i] = Vn[i] >> shiftVektor (SIMD) |
| usmmla | Vd.4S, Vn.16B, Vm.16B | 0 1 0 01110 10 0 Rm 10101 1 Rn Rd0x4E80AC00 / Maske 0xFFE0FC00 | Matrix-Multiplikation 2x8 mal 8x2 (Vn ohne, Vm mit Vorzeichen), addiert zum ZielVd(2x2) = Vd(2x2) + Vn(2x8) * Vm(8x2)Vektor (SIMD) |
| usqadd | Vd.T, Vn.T | 0 Q 1 01110 size 10000 00011 10 Rn Rd0x2E203800 / Maske 0xBF3FFC00 | Addition eines Wertes mit Vorzeichen zu einem ohne, mit Sättigungfor every element: Vd[i] = saturate_unsigned(Vd[i] + Vn[i])Vektor (SIMD) |
| usra | Vd.T, Vn.T, #shift | 0 Q 1 011110 immh immb 00010 1 Rn Rd0x2F001400 / Maske 0xBF80FC00 | Schieben nach rechts und Addition zum Ziel (ohne Vorzeichen)for every element: Vd[i] = Vd[i] + (Vn[i] >> shift)Vektor (SIMD) |
| usubl | Vd.Tb, Vn.Ta, Vm.Taauch: usubl2 | 0 Q 1 01110 size 1 Rm 0010 00 Rn Rd0x2E202000 / Maske 0xBF20FC00 | Subtraktion mit Verbreiterung (ohne Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = Vn[i] - Vm[i] (wide result)Vektor (SIMD) |
| usubw | Vd.Tb, Vn.Ta, Vm.Taauch: usubw2 | 0 Q 1 01110 size 1 Rm 0011 00 Rn Rd0x2E203000 / Maske 0xBF20FC00 | Subtraktion eines schmalen Operanden von einem breiten (ohne Vorzeichen; Q = 1: obere Hälfte der Quellen, Name mit 2)for every element: Vd[i] = Vn[i] - Vm[i] (Vn is wide)Vektor (SIMD) |
| uzp1 | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 0 Rm 0 001 10 Rn Rd0x0E001800 / Maske 0xBF20FC00 | Herausziehen der Elemente mit geraden Nummern aus zwei VektorenVd = even elements of (Vn:Vm)Vektor (SIMD) |
| uzp2 | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 0 Rm 0 101 10 Rn Rd0x0E005800 / Maske 0xBF20FC00 | Herausziehen der Elemente mit ungeraden Nummern aus zwei VektorenVd = odd elements of (Vn:Vm)Vektor (SIMD) |
| xar | Vd.2D, Vn.2D, Vm.2D, #imm6 | 11001110 100 Rm imm6 Rn Rd0xCE800000 / Maske 0xFFE00000 | Exklusives ODER und Rotation nach rechts (SHA-3)Vd = rotate_right(Vn ^ Vm, imm6)Kryptografie |
| xtn | Vd.T, Vn.Tauch: xtn2 | 0 Q 0 01110 size 10000 10010 10 Rn Rd0x0E212800 / Maske 0xBF3FFC00 | Verschmälern der Elemente (obere Hälfte abschneiden)for every element: Vd[i] = low half of Vn[i]Vektor (SIMD) |
| zip1 | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 0 Rm 0 011 10 Rn Rd0x0E003800 / Maske 0xBF20FC00 | Mischen der unteren Hälften zweier Vektoren, abwechselndVd = Vn[0], Vm[0], Vn[1], Vm[1] ...Vektor (SIMD) |
| zip2 | Vd.T, Vn.T, Vm.T | 0 Q 0 01110 size 0 Rm 0 111 10 Rn Rd0x0E007800 / Maske 0xBF20FC00 | Mischen der oberen Hälften zweier Vektoren, abwechselndVd = Vn[n/2], Vm[n/2], Vn[n/2+1] ...Vektor (SIMD) |