x64-Befehle

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

Alle 618 Befehle in 1.314 Formen, die Asmonite für .arch x64 assembliert und Dismonite zerlegt: Name, Operanden, die Kodierung in Bytes und eine kurze Beschreibung. Mit dem Suchfeld findest du einen Befehl, eine Bytefolge (0F B6) oder ein Wort der Beschreibung. Nicht dabei sind die AVX-Befehle (VEX, EVEX), die Asmonite und Dismonite noch nicht kennen.

So liest du die Tabelle

Die Operanden stehen in der Reihenfolge wie im Quelltext: zuerst das Ziel, dann die Quelle (Intel-Schreibweise). r8 bis r64 ist ein Register dieser Breite, m eine Speicheradresse, r/m32 ein Register oder 32 Bit Speicher, imm8 eine Zahl im Befehl, rel8 und rel32 eine Sprungweite, xmm und mm Vektor-Register.

Unter der Beschreibung steht die Wirkung in Pseudocode: dst ist der erste Operand (das Ziel), src der zweite (die Quelle), [x] der Speicher an der Adresse x; sext und zext erweitern mit Vorzeichen und mit Nullen, >>s schiebt mit Vorzeichen, hi:lo ist ein Registerpaar. Darunter stehen die Flags, die der Befehl ändert, und die, die danach undefiniert sind.

Die Kodierung sind die Bytes des Befehls, farbig nach ihrer Rolle:

66 F3 F2	Präfix: wählt die 16-Bit-Form (66) oder bei SSE die Art des Befehls (66 = Doubles, F3 = ein Single, F2 = ein Double)
REX.W	REX-Präfix mit gesetztem W-Bit: 64-Bit-Operanden (Byte `48` bis `4F`; die Bits für die Register r8 bis r15 setzt der Assembler selbst)
0F 38 3A	Erweiterung des Opcodes (Zwei- und Drei-Byte-Tabellen)
8B B8+rd	der Opcode; `+rb`, `+rw`, `+rd`, `+rq`: die Nummer des Registers kommt in die unteren drei Bits des Opcodes
/r /0…/7	ein ModRM-Byte folgt (mit Register, Speicher und Adressteilen). `/r`: das Feld reg ist ein Register; `/0` bis `/7`: das Feld reg ist ein Teil des Opcodes
ib iw id iq cb cd	danach: eine Zahl von 1, 2, 4 oder 8 Bytes (`i…`) oder eine Sprungweite (`c…`); `moffs` ist eine absolute Adresse

Die Tabelle gilt für den 64-Bit-Modus. Sie ist aus dem Zerleger von Dismonite hergeleitet und wird neu erzeugt, wenn sich der Zerleger ändert; die Beschreibungen sind kurz gehalten, ausführliche Erklärungen stehen in der Hilfe (F1) von Asmonite und Dismonite.

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

Befehl	Operanden	Kodierung	Beschreibung
adc	r/m8, r8	10 /r	Addition mit Übertrag (CF)`dst = dst + src + CF`Flags: OF SF ZF AF CF PFArithmetik
	r/m32, r32	11 /r
	r/m16, r16	66 11 /r
	r/m64, r64	REX.W 11 /r
	r8, r/m8	12 /r
	r32, r/m32	13 /r
	r16, r/m16	66 13 /r
	r64, r/m64	REX.W 13 /r
	al, imm8	14 ib
	eax, imm32	15 id
	ax, imm16	66 15 iw
	rax, imm32	REX.W 15 id
	r/m8, imm8	80 /2 ib
	r/m32, imm32	81 /2 id
	r/m16, imm16	66 81 /2 iw
	r/m64, imm32	REX.W 81 /2 id
	r/m32, imm8	83 /2 ib
	r/m16, imm8	66 83 /2 ib
	r/m64, imm8	REX.W 83 /2 ib
adcx	r32, r/m32	66 0F 38 F6 /r	Addition mit Übertrag, ändert nur CF`dst = dst + src + CF`Flags: CFArithmetik
adcx	r64, r/m64	66 REX.W 0F 38 F6 /r
add	r/m8, r8	00 /r	Addition der Quelle zum Ziel`dst = dst + src`Flags: OF SF ZF AF CF PFArithmetik
	r/m32, r32	01 /r
	r/m16, r16	66 01 /r
	r/m64, r64	REX.W 01 /r
	r8, r/m8	02 /r
	r32, r/m32	03 /r
	r16, r/m16	66 03 /r
	r64, r/m64	REX.W 03 /r
	al, imm8	04 ib
	eax, imm32	05 id
	ax, imm16	66 05 iw
	rax, imm32	REX.W 05 id
	r/m8, imm8	80 /0 ib
	r/m32, imm32	81 /0 id
	r/m16, imm16	66 81 /0 iw
	r/m64, imm32	REX.W 81 /0 id
	r/m32, imm8	83 /0 ib
	r/m16, imm8	66 83 /0 ib
	r/m64, imm8	REX.W 83 /0 ib
addpd	xmm, xmm/m128	66 0F 58 /r	Addition von 2 Doubles`for every element: dst[i] = dst[i] + src[i] (double)`SSE Gleitkomma
addps	xmm, xmm/m128	0F 58 /r	Addition von 4 Singles`for every element: dst[i] = dst[i] + src[i] (single)`SSE Gleitkomma
addsd	xmm, xmm/m64	F2 0F 58 /r	Addition von einem Double`dst[0] = dst[0] + src[0] (double); the other elements stay`SSE Gleitkomma
addss	xmm, xmm/m32	F3 0F 58 /r	Addition von einem Single`dst[0] = dst[0] + src[0] (single); the other elements stay`SSE Gleitkomma
addsubpd	xmm, xmm/m128	66 0F D0 /r	Abwechselnde Subtraktion und Addition (Doubles)`even elements: dst[i] = dst[i] - src[i]; odd elements: dst[i] = dst[i] + src[i]`SSE Gleitkomma
addsubps	xmm, xmm/m128	F2 0F D0 /r	Abwechselnde Subtraktion und Addition (Singles)`even elements: dst[i] = dst[i] - src[i]; odd elements: dst[i] = dst[i] + src[i]`SSE Gleitkomma
adox	r32, r/m32	F3 0F 38 F6 /r	Addition mit Überlauf-Flag, ändert nur OF`dst = dst + src + OF`Flags: OFArithmetik
adox	r64, r/m64	F3 REX.W 0F 38 F6 /r
aesdec	xmm, xmm/m128	66 0F 38 DE /r	Eine Entschlüsselungsrunde von AES`dst = inverse AES round of dst with the round key src`Kryptografie
aesdeclast	xmm, xmm/m128	66 0F 38 DF /r	Die letzte Entschlüsselungsrunde von AES`dst = last inverse AES round of dst with the round key src`Kryptografie
aesenc	xmm, xmm/m128	66 0F 38 DC /r	Eine Verschlüsselungsrunde von AES`dst = AES round of dst with the round key src`Kryptografie
aesenclast	xmm, xmm/m128	66 0F 38 DD /r	Die letzte Verschlüsselungsrunde von AES`dst = last AES round of dst with the round key src`Kryptografie
aesimc	xmm, xmm/m128	66 0F 38 DB /r	Umwandlung eines AES-Rundenschlüssels für die Entschlüsselung`dst = InvMixColumns(src)`Kryptografie
aeskeygenassist	xmm, xmm/m128, imm8	66 0F 3A DF /r ib	Hilfsbefehl für die AES-Schlüsselerzeugung`dst = helper values for the AES key schedule from src (round constant imm8)`Kryptografie
and	r/m8, r8	20 /r	Bitweise UND-Verknüpfung`dst = dst & src; CF = OF = 0`Flags: OF SF ZF CF PF · undefiniert: AFLogik und Bits
	r/m32, r32	21 /r
	r/m16, r16	66 21 /r
	r/m64, r64	REX.W 21 /r
	r8, r/m8	22 /r
	r32, r/m32	23 /r
	r16, r/m16	66 23 /r
	r64, r/m64	REX.W 23 /r
	al, imm8	24 ib
	eax, imm32	25 id
	ax, imm16	66 25 iw
	rax, imm32	REX.W 25 id
	r/m8, imm8	80 /4 ib
	r/m32, imm32	81 /4 id
	r/m16, imm16	66 81 /4 iw
	r/m64, imm32	REX.W 81 /4 id
	r/m32, imm8	83 /4 ib
	r/m16, imm8	66 83 /4 ib
	r/m64, imm8	REX.W 83 /4 ib
andnpd	xmm, xmm/m128	66 0F 55 /r	Bitweise Verknüpfung: NICHT Ziel UND Quelle`dst = ~dst & src`SSE Gleitkomma
andnps	xmm, xmm/m128	0F 55 /r	Bitweise Verknüpfung: NICHT Ziel UND Quelle`dst = ~dst & src`SSE Gleitkomma
andpd	xmm, xmm/m128	66 0F 54 /r	Bitweise UND-Verknüpfung`dst = dst & src`SSE Gleitkomma
andps	xmm, xmm/m128	0F 54 /r	Bitweise UND-Verknüpfung`dst = dst & src`SSE Gleitkomma
blendpd	xmm, xmm/m128, imm8	66 0F 3A 0D /r ib	Auswahl von Doubles aus zwei Registern nach einer Maske`for every element: dst[i] = bit i of imm8 ? src[i] : dst[i]`SSE Gleitkomma
blendps	xmm, xmm/m128, imm8	66 0F 3A 0C /r ib	Auswahl von Singles aus zwei Registern nach einer Maske`for every element: dst[i] = bit i of imm8 ? src[i] : dst[i]`SSE Gleitkomma
blendvpd	xmm, xmm/m128, xmm0	66 0F 38 15 /r	Auswahl von Doubles nach den Vorzeichenbits von xmm0`for every element: dst[i] = (sign bit of xmm0[i]) ? src[i] : dst[i]`SSE Gleitkomma
blendvps	xmm, xmm/m128, xmm0	66 0F 38 14 /r	Auswahl von Singles nach den Vorzeichenbits von xmm0`for every element: dst[i] = (sign bit of xmm0[i]) ? src[i] : dst[i]`SSE Gleitkomma
bsf	r32, r/m32	0F BC /r	Suche des niedrigsten gesetzten Bits`dst = index of the lowest 1 bit of src; ZF = (src = 0), dst undefined then`Flags: ZFLogik und Bits
	r16, r/m16	66 0F BC /r
	r64, r/m64	REX.W 0F BC /r
bsr	r32, r/m32	0F BD /r	Suche des höchsten gesetzten Bits`dst = index of the highest 1 bit of src; ZF = (src = 0), dst undefined then`Flags: ZFLogik und Bits
	r16, r/m16	66 0F BD /r
	r64, r/m64	REX.W 0F BD /r
bswap	r32	0F C8+rd	Umkehren der Reihenfolge der Bytes (Little/Big Endian)`dst = reverse_bytes(dst)`Daten kopieren
bswap	r64	REX.W 0F C8+rq
bt	r/m32, r32	0F A3 /r	Kopie eines Bits nach CF`CF = bit src of dst`Flags: CFLogik und Bits
	r/m16, r16	66 0F A3 /r
	r/m64, r64	REX.W 0F A3 /r
	r/m32, imm8	0F BA /4 ib
	r/m16, imm8	66 0F BA /4 ib
	r/m64, imm8	REX.W 0F BA /4 ib
btc	r/m32, imm8	0F BA /7 ib	Kopie eines Bits nach CF und Umkehren des Bits`CF = bit src of dst; bit src of dst = not bit`Flags: CFLogik und Bits
	r/m16, imm8	66 0F BA /7 ib
	r/m64, imm8	REX.W 0F BA /7 ib
	r/m32, r32	0F BB /r
	r/m16, r16	66 0F BB /r
	r/m64, r64	REX.W 0F BB /r
btr	r/m32, r32	0F B3 /r	Kopie eines Bits nach CF und Löschen des Bits`CF = bit src of dst; bit src of dst = 0`Flags: CFLogik und Bits
	r/m16, r16	66 0F B3 /r
	r/m64, r64	REX.W 0F B3 /r
	r/m32, imm8	0F BA /6 ib
	r/m16, imm8	66 0F BA /6 ib
	r/m64, imm8	REX.W 0F BA /6 ib
bts	r/m32, r32	0F AB /r	Kopie eines Bits nach CF und Setzen des Bits`CF = bit src of dst; bit src of dst = 1`Flags: CFLogik und Bits
	r/m16, r16	66 0F AB /r
	r/m64, r64	REX.W 0F AB /r
	r/m32, imm8	0F BA /5 ib
	r/m16, imm8	66 0F BA /5 ib
	r/m64, imm8	REX.W 0F BA /5 ib
call	rel32	E8 cd	Aufruf einer Funktion (die Rücksprungadresse kommt auf den Stack)`push(rip of the next instruction); rip = target`Sprünge, Aufrufe und Interrupts
	r/m64	FF /2
	m	FF /3
	r/m16	66 FF /2
cbw		66 98	Vorzeichenerweiterung von al nach ax`ax = sext(al)`Daten kopieren
cdq		99	Vorzeichenerweiterung von eax nach edx:eax`edx:eax = sext(eax)`Daten kopieren
cdqe		REX.W 98	Vorzeichenerweiterung von eax nach rax`rax = sext(eax)`Daten kopieren
clac		0F 01 CA	Löschen des AC-Flags (Zugriffsschutz)`EFLAGS.AC = 0`Flags: ACFlags
clc		F8	Löschen des Carry-Flags`CF = 0`Flags: CFFlags
cld		FC	Löschen des Richtungs-Flags (String-Befehle zählen aufwärts)`DF = 0`Flags: DFFlags
clflush	m	0F AE /7	Leeren einer Cache-Zeile`write back and remove the cache line of [m] from all caches`System und Privilegien
clflushopt	m	66 0F AE /7	Leeren einer Cache-Zeile (schneller, lose geordnet)`write back and remove the cache line of [m] from all caches`System und Privilegien
cli		FA	Sperren der Interrupts (IF=0)`IF = 0`Flags: IFFlags
clts		0F 06	Löschen des Task-Switched-Flags in cr0`CR0.TS = 0 (privileged)`System und Privilegien
clwb	m	66 0F AE /6	Zurückschreiben einer Cache-Zeile, ohne sie zu leeren`write back the cache line of [m], it may stay in the cache`System und Privilegien
cmc		F5	Umkehren des Carry-Flags`CF = not CF`Flags: CFFlags
cmova	r32, r/m32	0F 47 /r	Kopieren nur, wenn ohne Vorzeichen größer (CF=0 und ZF=0)`if CF = 0 and ZF = 0 then dst = src`Daten kopieren
	r16, r/m16	66 0F 47 /r
	r64, r/m64	REX.W 0F 47 /r
cmovbe	r32, r/m32	0F 46 /r	Kopieren nur, wenn ohne Vorzeichen kleiner oder gleich (CF=1 oder ZF=1)`if CF = 1 or ZF = 1 then dst = src`Daten kopieren
	r16, r/m16	66 0F 46 /r
	r64, r/m64	REX.W 0F 46 /r
cmovc	r32, r/m32	0F 42 /r	Kopieren nur, wenn Übertrag, ohne Vorzeichen kleiner (CF=1)`if CF = 1 then dst = src`Daten kopieren
	r16, r/m16	66 0F 42 /r
	r64, r/m64	REX.W 0F 42 /r
cmovg	r32, r/m32	0F 4F /r	Kopieren nur, wenn mit Vorzeichen größer (ZF=0 und SF=OF)`if ZF = 0 and SF = OF then dst = src`Daten kopieren
	r16, r/m16	66 0F 4F /r
	r64, r/m64	REX.W 0F 4F /r
cmovge	r32, r/m32	0F 4D /r	Kopieren nur, wenn mit Vorzeichen größer oder gleich (SF=OF)`if SF = OF then dst = src`Daten kopieren
	r16, r/m16	66 0F 4D /r
	r64, r/m64	REX.W 0F 4D /r
cmovl	r32, r/m32	0F 4C /r	Kopieren nur, wenn mit Vorzeichen kleiner (SF≠OF)`if SF != OF then dst = src`Daten kopieren
	r16, r/m16	66 0F 4C /r
	r64, r/m64	REX.W 0F 4C /r
cmovle	r32, r/m32	0F 4E /r	Kopieren nur, wenn mit Vorzeichen kleiner oder gleich (ZF=1 oder SF≠OF)`if ZF = 1 or SF != OF then dst = src`Daten kopieren
	r16, r/m16	66 0F 4E /r
	r64, r/m64	REX.W 0F 4E /r
cmovnc	r32, r/m32	0F 43 /r	Kopieren nur, wenn kein Übertrag, ohne Vorzeichen größer oder gleich (CF=0)`if CF = 0 then dst = src`Daten kopieren
	r16, r/m16	66 0F 43 /r
	r64, r/m64	REX.W 0F 43 /r
cmovno	r32, r/m32	0F 41 /r	Kopieren nur, wenn kein Überlauf (OF=0)`if OF = 0 then dst = src`Daten kopieren
	r16, r/m16	66 0F 41 /r
	r64, r/m64	REX.W 0F 41 /r
cmovnp	r32, r/m32	0F 4B /r	Kopieren nur, wenn Parität ungerade (PF=0)`if PF = 0 then dst = src`Daten kopieren
	r16, r/m16	66 0F 4B /r
	r64, r/m64	REX.W 0F 4B /r
cmovns	r32, r/m32	0F 49 /r	Kopieren nur, wenn nicht negativ (SF=0)`if SF = 0 then dst = src`Daten kopieren
	r16, r/m16	66 0F 49 /r
	r64, r/m64	REX.W 0F 49 /r
cmovnz	r32, r/m32	0F 45 /r	Kopieren nur, wenn ungleich, Ergebnis nicht null (ZF=0)`if ZF = 0 then dst = src`Daten kopieren
	r16, r/m16	66 0F 45 /r
	r64, r/m64	REX.W 0F 45 /r
cmovo	r32, r/m32	0F 40 /r	Kopieren nur, wenn Überlauf (OF=1)`if OF = 1 then dst = src`Daten kopieren
	r16, r/m16	66 0F 40 /r
	r64, r/m64	REX.W 0F 40 /r
cmovp	r32, r/m32	0F 4A /r	Kopieren nur, wenn Parität gerade (PF=1)`if PF = 1 then dst = src`Daten kopieren
	r16, r/m16	66 0F 4A /r
	r64, r/m64	REX.W 0F 4A /r
cmovs	r32, r/m32	0F 48 /r	Kopieren nur, wenn negativ (SF=1)`if SF = 1 then dst = src`Daten kopieren
	r16, r/m16	66 0F 48 /r
	r64, r/m64	REX.W 0F 48 /r
cmovz	r32, r/m32	0F 44 /r	Kopieren nur, wenn gleich, Ergebnis null (ZF=1)`if ZF = 1 then dst = src`Daten kopieren
	r16, r/m16	66 0F 44 /r
	r64, r/m64	REX.W 0F 44 /r
cmp	r/m8, r8	38 /r	Vergleich (Ziel minus Quelle), nur die Flags ändern sich`flags = dst - src (the result is thrown away)`Flags: OF SF ZF AF CF PFVergleichen und Tauschen
	r/m32, r32	39 /r
	r/m16, r16	66 39 /r
	r/m64, r64	REX.W 39 /r
	r8, r/m8	3A /r
	r32, r/m32	3B /r
	r16, r/m16	66 3B /r
	r64, r/m64	REX.W 3B /r
	al, imm8	3C ib
	eax, imm32	3D id
	ax, imm16	66 3D iw
	rax, imm32	REX.W 3D id
	r/m8, imm8	80 /7 ib
	r/m32, imm32	81 /7 id
	r/m16, imm16	66 81 /7 iw
	r/m64, imm32	REX.W 81 /7 id
	r/m32, imm8	83 /7 ib
	r/m16, imm8	66 83 /7 ib
	r/m64, imm8	REX.W 83 /7 ib
cmpeqpd	xmm, xmm/m128	66 0F C2 /r 00	Vergleich von 2 Doubles auf gleich, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] eq src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpeqps	xmm, xmm/m128	0F C2 /r 00	Vergleich von 4 Singles auf gleich, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] eq src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpeqsd	xmm, xmm/m64	F2 0F C2 /r 00	Vergleich von einem Double auf gleich, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] eq src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpeqss	xmm, xmm/m32	F3 0F C2 /r 00	Vergleich von einem Single auf gleich, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] eq src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmplepd	xmm, xmm/m128	66 0F C2 /r 02	Vergleich von 2 Doubles auf kleiner oder gleich, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] le src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpleps	xmm, xmm/m128	0F C2 /r 02	Vergleich von 4 Singles auf kleiner oder gleich, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] le src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmplesd	xmm, xmm/m64	F2 0F C2 /r 02	Vergleich von einem Double auf kleiner oder gleich, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] le src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpless	xmm, xmm/m32	F3 0F C2 /r 02	Vergleich von einem Single auf kleiner oder gleich, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] le src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpltpd	xmm, xmm/m128	66 0F C2 /r 01	Vergleich von 2 Doubles auf kleiner, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] lt src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpltps	xmm, xmm/m128	0F C2 /r 01	Vergleich von 4 Singles auf kleiner, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] lt src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpltsd	xmm, xmm/m64	F2 0F C2 /r 01	Vergleich von einem Double auf kleiner, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] lt src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpltss	xmm, xmm/m32	F3 0F C2 /r 01	Vergleich von einem Single auf kleiner, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] lt src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpneqpd	xmm, xmm/m128	66 0F C2 /r 04	Vergleich von 2 Doubles auf ungleich, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] neq src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpneqps	xmm, xmm/m128	0F C2 /r 04	Vergleich von 4 Singles auf ungleich, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] neq src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpneqsd	xmm, xmm/m64	F2 0F C2 /r 04	Vergleich von einem Double auf ungleich, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] neq src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpneqss	xmm, xmm/m32	F3 0F C2 /r 04	Vergleich von einem Single auf ungleich, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] neq src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpnlepd	xmm, xmm/m128	66 0F C2 /r 06	Vergleich von 2 Doubles auf nicht kleiner oder gleich, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] nle src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpnleps	xmm, xmm/m128	0F C2 /r 06	Vergleich von 4 Singles auf nicht kleiner oder gleich, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] nle src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpnlesd	xmm, xmm/m64	F2 0F C2 /r 06	Vergleich von einem Double auf nicht kleiner oder gleich, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] nle src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpnless	xmm, xmm/m32	F3 0F C2 /r 06	Vergleich von einem Single auf nicht kleiner oder gleich, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] nle src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpnltpd	xmm, xmm/m128	66 0F C2 /r 05	Vergleich von 2 Doubles auf nicht kleiner, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] nlt src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpnltps	xmm, xmm/m128	0F C2 /r 05	Vergleich von 4 Singles auf nicht kleiner, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] nlt src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpnltsd	xmm, xmm/m64	F2 0F C2 /r 05	Vergleich von einem Double auf nicht kleiner, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] nlt src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpnltss	xmm, xmm/m32	F3 0F C2 /r 05	Vergleich von einem Single auf nicht kleiner, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] nlt src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpordpd	xmm, xmm/m128	66 0F C2 /r 07	Vergleich von 2 Doubles auf geordnet (kein NaN), Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] ord src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpordps	xmm, xmm/m128	0F C2 /r 07	Vergleich von 4 Singles auf geordnet (kein NaN), Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] ord src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpordsd	xmm, xmm/m64	F2 0F C2 /r 07	Vergleich von einem Double auf geordnet (kein NaN), Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] ord src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpordss	xmm, xmm/m32	F3 0F C2 /r 07	Vergleich von einem Single auf geordnet (kein NaN), Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] ord src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmppd	xmm, xmm/m128, imm8	66 0F C2 /r ib	Vergleich von 2 Doubles mit einer Bedingung, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] predicate src[i]) ? all 1 bits : 0; the predicate is imm8`SSE Gleitkomma
cmpps	xmm, xmm/m128, imm8	0F C2 /r ib	Vergleich von 4 Singles mit einer Bedingung, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] predicate src[i]) ? all 1 bits : 0; the predicate is imm8`SSE Gleitkomma
cmpsb		A6	Vergleich von [rsi] mit [rdi], rsi und rdi laufen weiter`flags = [rsi] - [rdi]; rsi, rdi = +/- size; with repe / repne: repeat while equal / not equal, at most rcx times`Flags: OF SF ZF AF CF PFZeichenketten
cmpsd		A7	Vergleich eines Doubles (xmm) mit einer Bedingung; ohne Operanden: String-Vergleich`for every element: dst[i] = (dst[i] predicate src[i]) ? all 1 bits : 0; the predicate is imm8`SSE Gleitkomma
cmpsd	xmm, xmm/m64, imm8	F2 0F C2 /r ib
cmpsq		REX.W A7	Vergleich von [rsi] mit [rdi], rsi und rdi laufen weiter`flags = [rsi] - [rdi]; rsi, rdi = +/- size; with repe / repne: repeat while equal / not equal, at most rcx times`Flags: OF SF ZF AF CF PFZeichenketten
cmpss	xmm, xmm/m32, imm8	F3 0F C2 /r ib	Vergleich eines Singles mit einer Bedingung, Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] predicate src[i]) ? all 1 bits : 0; the predicate is imm8`SSE Gleitkomma
cmpsw		66 A7	Vergleich von [rsi] mit [rdi], rsi und rdi laufen weiter`flags = [rsi] - [rdi]; rsi, rdi = +/- size; with repe / repne: repeat while equal / not equal, at most rcx times`Flags: OF SF ZF AF CF PFZeichenketten
cmpunordpd	xmm, xmm/m128	66 0F C2 /r 03	Vergleich von 2 Doubles auf ungeordnet (NaN), Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] unord src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpunordps	xmm, xmm/m128	0F C2 /r 03	Vergleich von 4 Singles auf ungeordnet (NaN), Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] unord src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpunordsd	xmm, xmm/m64	F2 0F C2 /r 03	Vergleich von einem Double auf ungeordnet (NaN), Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] unord src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpunordss	xmm, xmm/m32	F3 0F C2 /r 03	Vergleich von einem Single auf ungeordnet (NaN), Ergebnis ist eine Maske`for every element: dst[i] = (dst[i] unord src[i]) ? all 1 bits : 0`SSE Gleitkomma
cmpxchg	r/m8, r8	0F B0 /r	Vergleichen und Tauschen bei Gleichheit (atomar mit lock)`if rax == dst then { ZF = 1; dst = src } else { ZF = 0; rax = dst }`Flags: OF SF ZF AF CF PFVergleichen und Tauschen
	r/m32, r32	0F B1 /r
	r/m16, r16	66 0F B1 /r
	r/m64, r64	REX.W 0F B1 /r
cmpxchg16b	m	REX.W 0F C7 /1	Vergleichen und Tauschen von 16 Bytes (rdx:rax, rcx:rbx)`if rdx:rax == [m] then { ZF = 1; [m] = rcx:rbx } else { ZF = 0; rdx:rax = [m] }`Flags: ZFVergleichen und Tauschen
cmpxchg8b	m	0F C7 /1	Vergleichen und Tauschen von 8 Bytes (edx:eax, ecx:ebx)`if edx:eax == [m] then { ZF = 1; [m] = ecx:ebx } else { ZF = 0; edx:eax = [m] }`Flags: ZFVergleichen und Tauschen
comisd	xmm, xmm/m64	66 0F 2F /r	Vergleich zweier Doubles, setzt ZF, PF, CF`ZF PF CF = compare(dst, src): greater 0 0 0, less 0 0 1, equal 1 0 0, unordered 1 1 1; OF SF AF = 0`Flags: OF SF ZF AF CF PFSSE Gleitkomma
comiss	xmm, xmm/m32	0F 2F /r	Vergleich zweier Singles, setzt ZF, PF, CF`ZF PF CF = compare(dst, src): greater 0 0 0, less 0 0 1, equal 1 0 0, unordered 1 1 1; OF SF AF = 0`Flags: OF SF ZF AF CF PFSSE Gleitkomma
cpuid		0F A2	Auskunft über den Prozessor`eax, ebx, ecx, edx = information about the processor for the function in eax (and ecx)`System und Privilegien
cqo		REX.W 99	Vorzeichenerweiterung von rax nach rdx:rax`rdx:rax = sext(rax)`Daten kopieren
crc32	r32, r/m8	F2 0F 38 F0 /r	Berechnung einer CRC-32C-Prüfsumme (Castagnoli)`dst = crc32c(dst, src)`Arithmetik
	r64, r/m8	F2 REX.W 0F 38 F0 /r
	r32, r/m32	F2 0F 38 F1 /r
	r64, r/m64	F2 REX.W 0F 38 F1 /r
cvtdq2pd	xmm, xmm/m64	F3 0F E6 /r	Umwandlung von 2 Ganzzahlen (32 Bit) in Doubles`for every element: dst[i] = convert(src[i]) from int32 to double`Umwandlungen
cvtdq2ps	xmm, xmm/m128	0F 5B /r	Umwandlung von 4 Ganzzahlen (32 Bit) in Singles`for every element: dst[i] = convert(src[i]) from int32 to single`Umwandlungen
cvtpd2dq	xmm, xmm/m128	F2 0F E6 /r	Umwandlung von 2 Doubles in Ganzzahlen (gerundet)`for every element: dst[i] = convert(src[i]) from double to int32`Umwandlungen
cvtpd2pi	mm, xmm/m64	66 0F 2D /r	Umwandlung von 2 Doubles in Ganzzahlen (mm, gerundet)`for every element: dst[i] = convert(src[i]) from double to int32`Umwandlungen
cvtpd2ps	xmm, xmm/m128	66 0F 5A /r	Umwandlung von 2 Doubles in Singles`for every element: dst[i] = convert(src[i]) from double to single`Umwandlungen
cvtpi2pd	xmm, mm/m64	66 0F 2A /r	Umwandlung von 2 Ganzzahlen (mm) in Doubles`for every element: dst[i] = convert(src[i]) from int32 to double`Umwandlungen
cvtpi2ps	xmm, mm/m64	0F 2A /r	Umwandlung von 2 Ganzzahlen (mm) in Singles`for every element: dst[i] = convert(src[i]) from int32 to single`Umwandlungen
cvtps2dq	xmm, xmm/m128	66 0F 5B /r	Umwandlung von 4 Singles in Ganzzahlen (gerundet)`for every element: dst[i] = convert(src[i]) from single to int32`Umwandlungen
cvtps2pd	xmm, xmm/m64	0F 5A /r	Umwandlung von 2 Singles in Doubles`for every element: dst[i] = convert(src[i]) from single to double`Umwandlungen
cvtps2pi	mm, xmm/m64	0F 2D /r	Umwandlung von 2 Singles in Ganzzahlen (mm, gerundet)`for every element: dst[i] = convert(src[i]) from single to int32`Umwandlungen
cvtsd2si	r32, xmm/m128	F2 0F 2D /r	Umwandlung eines Doubles in eine Ganzzahl (gerundet)`for every element: dst[i] = convert(src[i]) from double to integer`Umwandlungen
cvtsd2si	r64, xmm/m128	F2 REX.W 0F 2D /r
cvtsd2ss	xmm, xmm/m128	F2 0F 5A /r	Umwandlung eines Doubles in einen Single`for every element: dst[i] = convert(src[i]) from double to single`Umwandlungen
cvtsi2sd	xmm, r/m32	F2 0F 2A /r	Umwandlung einer Ganzzahl in einen Double`for every element: dst[i] = convert(src[i]) from integer to double`Umwandlungen
cvtsi2sd	xmm, r/m64	F2 REX.W 0F 2A /r
cvtsi2ss	xmm, r/m32	F3 0F 2A /r	Umwandlung einer Ganzzahl in einen Single`for every element: dst[i] = convert(src[i]) from integer to single`Umwandlungen
cvtsi2ss	xmm, r/m64	F3 REX.W 0F 2A /r
cvtss2sd	xmm, xmm/m32	F3 0F 5A /r	Umwandlung eines Singles in einen Double`for every element: dst[i] = convert(src[i]) from single to double`Umwandlungen
cvtss2si	r32, xmm/m32	F3 0F 2D /r	Umwandlung eines Singles in eine Ganzzahl (gerundet)`for every element: dst[i] = convert(src[i]) from single to integer`Umwandlungen
cvtss2si	r64, xmm/m32	F3 REX.W 0F 2D /r
cvttpd2dq	xmm, xmm/m128	66 0F E6 /r	Umwandlung von 2 Doubles in Ganzzahlen (abgeschnitten)`for every element: dst[i] = truncate(src[i]) from double to int32`Umwandlungen
cvttpd2pi	mm, xmm/m64	66 0F 2C /r	Umwandlung von 2 Doubles in Ganzzahlen (mm, abgeschnitten)`for every element: dst[i] = truncate(src[i]) from double to int32`Umwandlungen
cvttps2dq	xmm, xmm/m128	F3 0F 5B /r	Umwandlung von 4 Singles in Ganzzahlen (abgeschnitten)`for every element: dst[i] = truncate(src[i]) from single to int32`Umwandlungen
cvttps2pi	mm, xmm/m64	0F 2C /r	Umwandlung von 2 Singles in Ganzzahlen (mm, abgeschnitten)`for every element: dst[i] = truncate(src[i]) from single to int32`Umwandlungen
cvttsd2si	r32, xmm/m128	F2 0F 2C /r	Umwandlung eines Doubles in eine Ganzzahl (abgeschnitten)`for every element: dst[i] = truncate(src[i]) from double to integer`Umwandlungen
cvttsd2si	r64, xmm/m128	F2 REX.W 0F 2C /r
cvttss2si	r32, xmm/m32	F3 0F 2C /r	Umwandlung eines Singles in eine Ganzzahl (abgeschnitten)`for every element: dst[i] = truncate(src[i]) from single to integer`Umwandlungen
cvttss2si	r64, xmm/m32	F3 REX.W 0F 2C /r
cwd		66 99	Vorzeichenerweiterung von ax nach dx:ax`dx:ax = sext(ax)`Daten kopieren
cwde		98	Vorzeichenerweiterung von ax nach eax`eax = sext(ax)`Daten kopieren
dec	r/m8	FE /1	Verringerung um 1 (CF bleibt)`dst = dst - 1`Flags: OF SF ZF AF PFArithmetik
	r/m32	FF /1
	r/m16	66 FF /1
	r/m64	REX.W FF /1
div	r/m8	F6 /6	Division ohne Vorzeichen: edx:eax durch den Operanden, Quotient nach eax, Rest nach edx`rax = rdx:rax / src; rdx = rdx:rax % src (8 bit: al = ax / src; ah = ax % src); #DE if src = 0 or quotient too big (unsigned)`Flags: – · undefiniert: OF SF ZF AF CF PFArithmetik
	r/m32	F7 /6
	r/m16	66 F7 /6
	r/m64	REX.W F7 /6
divpd	xmm, xmm/m128	66 0F 5E /r	Division von 2 Doubles`for every element: dst[i] = dst[i] / src[i] (double)`SSE Gleitkomma
divps	xmm, xmm/m128	0F 5E /r	Division von 4 Singles`for every element: dst[i] = dst[i] / src[i] (single)`SSE Gleitkomma
divsd	xmm, xmm/m64	F2 0F 5E /r	Division von einem Double`dst[0] = dst[0] / src[0] (double); the other elements stay`SSE Gleitkomma
divss	xmm, xmm/m32	F3 0F 5E /r	Division von einem Single`dst[0] = dst[0] / src[0] (single); the other elements stay`SSE Gleitkomma
dppd	xmm, xmm/m128, imm8	66 0F 3A 41 /r ib	Skalarprodukt von Doubles`dst[i] = sum of dst[j] * src[j] for the elements chosen by imm8 (high bits), written to the elements chosen by imm8 (low bits)`SSE Gleitkomma
dpps	xmm, xmm/m128, imm8	66 0F 3A 40 /r ib	Skalarprodukt von Singles`dst[i] = sum of dst[j] * src[j] for the elements chosen by imm8 (high bits), written to the elements chosen by imm8 (low bits)`SSE Gleitkomma
emms		0F 77	Beenden von MMX und Freigabe der x87-Register`mark all x87 registers as empty (after MMX)`System und Privilegien
endbr32		F3 0F 1E FB	Markierung eines gültigen Sprungziels (Kontrollfluss-Schutz)`marks a valid target of an indirect jump (no change)`Schranken und Sonstiges
endbr64		F3 0F 1E FA	Markierung eines gültigen Sprungziels (Kontrollfluss-Schutz)`marks a valid target of an indirect jump (no change)`Schranken und Sonstiges
enter	imm16, imm8	C8 iw ib	Aufbau eines Stackrahmens (selten, meist push/mov)`push(rbp); rbp = rsp; rsp = rsp - size (nesting level 0)`Stack
extractps	r/m32, xmm, imm8	66 0F 3A 17 /r ib	Herausholen eines Singles aus xmm in ein Register oder Speicher`dst = one single of src, chosen by imm8`SSE und MMX Datenbewegung
f2xm1		D9 F0	2 hoch st0 minus 1`st0 = 2 ^ st0 - 1`Gleitkomma (x87)
fabs		D9 E1	Betrag von st0`st0 = abs(st0)`Gleitkomma (x87)
fadd	m32	D8 /0	Addition (st0 = st0 + Operand)`st0 = st0 + src (or st(i) = st(i) + st0)`Gleitkomma (x87)
	st0, st(i)	D8 /0
	m64	DC /0
	st(i), st0	DC /0
faddp	st(i), st0	DE /0	Addition mit Entfernen vom Stack`st(i) = st(i) + st0; pop`Gleitkomma (x87)
fbld	m80	DF /4	Laden einer gepackten Dezimalzahl (BCD)`push: st0 = packed decimal src`Gleitkomma (x87)
fbstp	m80	DF /6	Speichern von st0 als gepackte Dezimalzahl und Entfernen`dst = st0 as packed decimal; pop`Gleitkomma (x87)
fchs		D9 E0	Vorzeichenwechsel von st0`st0 = -st0`Gleitkomma (x87)
fcmovb	st0, st(i)	DA /0	Kopieren von st(i) nach st0, wenn CF=1`if CF = 1 then st0 = st(i)`Gleitkomma (x87)
fcmovbe	st0, st(i)	DA /2	Kopieren von st(i) nach st0, wenn CF=1 oder ZF=1`if CF = 1 or ZF = 1 then st0 = st(i)`Gleitkomma (x87)
fcmove	st0, st(i)	DA /1	Kopieren von st(i) nach st0, wenn ZF=1`if ZF = 1 then st0 = st(i)`Gleitkomma (x87)
fcmovnb	st0, st(i)	DB /0	Kopieren von st(i) nach st0, wenn CF=0`if CF = 0 then st0 = st(i)`Gleitkomma (x87)
fcmovnbe	st0, st(i)	DB /2	Kopieren von st(i) nach st0, wenn CF=0 und ZF=0`if CF = 0 and ZF = 0 then st0 = st(i)`Gleitkomma (x87)
fcmovne	st0, st(i)	DB /1	Kopieren von st(i) nach st0, wenn ZF=0`if ZF = 0 then st0 = st(i)`Gleitkomma (x87)
fcmovnu	st0, st(i)	DB /3	Kopieren von st(i) nach st0, wenn PF=0`if PF = 0 then st0 = st(i)`Gleitkomma (x87)
fcmovu	st0, st(i)	DA /3	Kopieren von st(i) nach st0, wenn PF=1`if PF = 1 then st0 = st(i)`Gleitkomma (x87)
fcom	st(i)/m32	D8 /2	Vergleich von st0 mit einem Operanden (Statuswort)`status word C3 C2 C0 = compare(st0, src)`Flags: C0 C2 C3Gleitkomma (x87)
fcom	m64	DC /2
fcomi	st0, st(i)	DB /6	Vergleich mit direkter Wirkung auf ZF, PF, CF`ZF PF CF = compare(st0, st(i))`Flags: ZF CF PFGleitkomma (x87)
fcomip	st0, st(i)	DF /6	Vergleich mit ZF, PF, CF und Entfernen von st0`ZF PF CF = compare(st0, st(i)); pop`Flags: ZF CF PFGleitkomma (x87)
fcomp	st(i)/m32	D8 /3	Vergleich mit Entfernen von st0 vom Stack`status word C3 C2 C0 = compare(st0, src); pop`Flags: C0 C2 C3Gleitkomma (x87)
fcomp	m64	DC /3
fcompp		DE D9	Vergleich von st0 mit st1 und Entfernen beider`status word C3 C2 C0 = compare(st0, st1); pop twice`Flags: C0 C2 C3Gleitkomma (x87)
fcos		D9 FF	Kosinus von st0`st0 = cos(st0)`Gleitkomma (x87)
fdecstp		D9 F6	Verringerung des x87-Stackzeigers`top of the x87 stack = top - 1`Gleitkomma (x87)
fdiv	m32	D8 /6	Division`st0 = st0 / src (or st(i) = st(i) / st0)`Gleitkomma (x87)
	st0, st(i)	D8 /6
	m64	DC /6
	st(i), st0	DC /7
fdivp	st(i), st0	DE /7	Division mit Entfernen vom Stack`st(i) = st(i) / st0; pop`Gleitkomma (x87)
fdivr	m32	D8 /7	Division in umgekehrter Reihenfolge`st0 = src / st0 (or st(i) = st0 / st(i))`Gleitkomma (x87)
	st0, st(i)	D8 /7
	st(i), st0	DC /6
	m64	DC /7
fdivrp	st(i), st0	DE /6	Umgekehrte Division mit Entfernen vom Stack`st(i) = st0 / st(i); pop`Gleitkomma (x87)
ffree	st(i)	DD /0	Freigabe eines x87-Registers`mark st(i) as empty`Gleitkomma (x87)
fiadd	m32	DA /0	Addition einer Ganzzahl aus dem Speicher`st0 = st0 + (float) integer src`Gleitkomma (x87)
fiadd	m16	DE /0
ficom	m32	DA /2	Vergleich von st0 mit einer Ganzzahl`status word C3 C2 C0 = compare(st0, integer src)`Flags: C0 C2 C3Gleitkomma (x87)
ficom	m16	DE /2
ficomp	m32	DA /3	Vergleich mit einer Ganzzahl und Entfernen von st0`status word C3 C2 C0 = compare(st0, integer src); pop`Flags: C0 C2 C3Gleitkomma (x87)
ficomp	m16	DE /3
fidiv	m32	DA /6	Division durch eine Ganzzahl aus dem Speicher`st0 = st0 / (float) integer src`Gleitkomma (x87)
fidiv	m16	DE /6
fidivr	m32	DA /7	Division einer Ganzzahl durch st0 (umgekehrt)`st0 = (float) integer src / st0`Gleitkomma (x87)
fidivr	m16	DE /7
fild	m32	DB /0	Laden einer Ganzzahl auf den x87-Stack`push: st0 = (float) integer src`Gleitkomma (x87)
	m16	DF /0
	m64	DF /5
fimul	m32	DA /1	Multiplikation mit einer Ganzzahl aus dem Speicher`st0 = st0 * (float) integer src`Gleitkomma (x87)
fimul	m16	DE /1
fincstp		D9 F7	Erhöhung des x87-Stackzeigers`top of the x87 stack = top + 1`Gleitkomma (x87)
fist	m32	DB /2	Speichern von st0 als Ganzzahl (gerundet)`dst = (integer) st0, rounded`Gleitkomma (x87)
fist	m16	DF /2
fistp	m32	DB /3	Speichern von st0 als Ganzzahl und Entfernen`dst = (integer) st0, rounded; pop`Gleitkomma (x87)
	m16	DF /3
	m64	DF /7
fisttp	m32	DB /1	Speichern von st0 als Ganzzahl (abgeschnitten) und Entfernen`dst = (integer) st0, truncated; pop`Gleitkomma (x87)
	m64	DD /1
	m16	DF /1
fisub	m32	DA /4	Subtraktion einer Ganzzahl aus dem Speicher`st0 = st0 - (float) integer src`Gleitkomma (x87)
fisub	m16	DE /4
fisubr	m32	DA /5	Umgekehrte Subtraktion einer Ganzzahl aus dem Speicher`st0 = (float) integer src - st0`Gleitkomma (x87)
fisubr	m16	DE /5
fld	st(i)/m32	D9 /0	Laden eines Wertes auf den x87-Stack`push: st0 = src`Gleitkomma (x87)
	m80	DB /5
	m64	DD /0
fld1		D9 E8	Laden der Konstante 1.0`push: st0 = 1.0`Gleitkomma (x87)
fldcw	m16	D9 /5	Laden des x87-Steuerworts`x87 control word = [m16]`Gleitkomma (x87)
fldenv	m	D9 /4	Laden der x87-Umgebung`x87 environment = [m]`Gleitkomma (x87)
fldl2e		D9 EA	Laden von log2(e)`push: st0 = log2(e)`Gleitkomma (x87)
fldl2t		D9 E9	Laden von log2(10)`push: st0 = log2(10)`Gleitkomma (x87)
fldlg2		D9 EC	Laden von log10(2)`push: st0 = log10(2)`Gleitkomma (x87)
fldln2		D9 ED	Laden von ln(2)`push: st0 = ln(2)`Gleitkomma (x87)
fldpi		D9 EB	Laden der Konstante π`push: st0 = pi`Gleitkomma (x87)
fldz		D9 EE	Laden der Konstante 0.0`push: st0 = 0.0`Gleitkomma (x87)
fmul	m32	D8 /1	Multiplikation`st0 = st0 * src (or st(i) = st(i) * st0)`Gleitkomma (x87)
	st0, st(i)	D8 /1
	m64	DC /1
	st(i), st0	DC /1
fmulp	st(i), st0	DE /1	Multiplikation mit Entfernen vom Stack`st(i) = st(i) * st0; pop`Gleitkomma (x87)
fnclex		DB E2	Löschen der x87-Ausnahmen`clear the x87 exception flags`Gleitkomma (x87)
fninit		DB E3	Zurücksetzen der x87-Einheit`reset the x87 unit`Gleitkomma (x87)
fnop		D9 D0	Keine Operation (x87)`no operation`Gleitkomma (x87)
fnsave	m	DD /6	Speichern des ganzen x87-Zustands`[m] = whole x87 state; then reset the unit`Gleitkomma (x87)
fnstcw	m16	D9 /7	Speichern des x87-Steuerworts`[m16] = x87 control word`Gleitkomma (x87)
fnstenv	m	D9 /6	Speichern der x87-Umgebung`[m] = x87 environment`Gleitkomma (x87)
fnstsw	m16	DD /7	Speichern des x87-Statusworts`dst = x87 status word`Gleitkomma (x87)
fnstsw	ax	DF E0
fpatan		D9 F3	Arkustangens von st1/st0`st1 = atan(st1 / st0); pop`Gleitkomma (x87)
fprem		D9 F8	Rest einer Division (teilweise)`st0 = st0 mod st1 (truncating quotient, partial)`Gleitkomma (x87)
fprem1		D9 F5	IEEE-Rest einer Division`st0 = IEEE remainder of st0 / st1 (partial)`Gleitkomma (x87)
fptan		D9 F2	Tangens von st0`st0 = tan(st0); push: st0 = 1.0`Gleitkomma (x87)
frndint		D9 FC	Runden von st0 auf eine ganze Zahl`st0 = round(st0) to an integer value`Gleitkomma (x87)
frstor	m	DD /4	Wiederherstellen des ganzen x87-Zustands`whole x87 state = [m]`Gleitkomma (x87)
fscale		D9 FD	Multiplikation von st0 mit 2 hoch st1`st0 = st0 * 2 ^ trunc(st1)`Gleitkomma (x87)
fsin		D9 FE	Sinus von st0`st0 = sin(st0)`Gleitkomma (x87)
fsincos		D9 FB	Sinus und Kosinus von st0`st0 = sin(st0); push: st0 = cos`Gleitkomma (x87)
fsqrt		D9 FA	Quadratwurzel von st0`st0 = sqrt(st0)`Gleitkomma (x87)
fst	m32	D9 /2	Speichern von st0 (ohne Entfernen)`dst = st0`Gleitkomma (x87)
fst	st(i)/m64	DD /2
fstp	m32	D9 /3	Speichern von st0 und Entfernen vom Stack`dst = st0; pop`Gleitkomma (x87)
	m80	DB /7
	st(i)/m64	DD /3
fsub	m32	D8 /4	Subtraktion`st0 = st0 - src (or st(i) = st(i) - st0)`Gleitkomma (x87)
	st0, st(i)	D8 /4
	m64	DC /4
	st(i), st0	DC /5
fsubp	st(i), st0	DE /5	Subtraktion mit Entfernen vom Stack`st(i) = st(i) - st0; pop`Gleitkomma (x87)
fsubr	m32	D8 /5	Subtraktion in umgekehrter Reihenfolge`st0 = src - st0 (or st(i) = st0 - st(i))`Gleitkomma (x87)
	st0, st(i)	D8 /5
	st(i), st0	DC /4
	m64	DC /5
fsubrp	st(i), st0	DE /4	Umgekehrte Subtraktion mit Entfernen vom Stack`st(i) = st0 - st(i); pop`Gleitkomma (x87)
ftst		D9 E4	Vergleich von st0 mit 0.0`status word C3 C2 C0 = compare(st0, 0.0)`Flags: C0 C2 C3Gleitkomma (x87)
fucom	st(i)	DD /4	Ungeordneter Vergleich (kein Fehler bei NaN)`status word C3 C2 C0 = compare(st0, src)`Flags: C0 C2 C3Gleitkomma (x87)
fucomi	st0, st(i)	DB /5	Ungeordneter Vergleich, setzt ZF, PF, CF`ZF PF CF = compare(st0, st(i))`Flags: ZF CF PFGleitkomma (x87)
fucomip	st0, st(i)	DF /5	Ungeordneter Vergleich, setzt ZF, PF, CF, mit Entfernen von st0`ZF PF CF = compare(st0, st(i)); pop`Flags: ZF CF PFGleitkomma (x87)
fucomp	st(i)	DD /5	Ungeordneter Vergleich mit Entfernen von st0`status word C3 C2 C0 = compare(st0, src); pop`Flags: C0 C2 C3Gleitkomma (x87)
fucompp		DA E9	Ungeordneter Vergleich von st0, st1 mit Entfernen beider`status word C3 C2 C0 = compare(st0, st1); pop twice`Flags: C0 C2 C3Gleitkomma (x87)
fwait		9B	Warten auf die x87-Einheit`wait until the x87 unit is done and report its errors`Schranken und Sonstiges
fxam		D9 E5	Feststellen der Art von st0 (Zahl, NaN, ...)`status word C3 C2 C1 C0 = kind of st0 (number, zero, infinity, NaN, ...)`Flags: C0 C1 C2 C3Gleitkomma (x87)
fxch	st(i)	D9 /1	Vertauschen von st0 mit einem anderen Register`swap(st0, st(i))`Gleitkomma (x87)
fxrstor	m	0F AE /1	Wiederherstellen des x87-, MMX- und SSE-Zustands`x87, MMX and SSE state = [m]`System und Privilegien
fxrstor64	m	REX.W 0F AE /1	Wiederherstellen des x87-, MMX- und SSE-Zustands`x87, MMX and SSE state = [m]`System und Privilegien
fxsave	m	0F AE /0	Sichern des x87-, MMX- und SSE-Zustands`[m] = x87, MMX and SSE state (512 bytes)`System und Privilegien
fxsave64	m	REX.W 0F AE /0	Sichern des x87-, MMX- und SSE-Zustands`[m] = x87, MMX and SSE state (512 bytes)`System und Privilegien
fxtract		D9 F4	Zerlegung von st0 in Exponent und Mantisse`st0 = exponent of st0; push: st0 = significand`Gleitkomma (x87)
fyl2x		D9 F1	st1 mal log2(st0)`st1 = st1 * log2(st0); pop`Gleitkomma (x87)
fyl2xp1		D9 F9	st1 mal log2(st0 + 1)`st1 = st1 * log2(st0 + 1); pop`Gleitkomma (x87)
getsec		0F 37	Befehle der Sicherheitserweiterung (Intel TXT)`run the safer-mode function selected by eax (Intel TXT)`System und Privilegien
haddpd	xmm, xmm/m128	66 0F 7C /r	Addition benachbarter Doubles (horizontal)`dst = (dst[0] + dst[1], dst[2] + dst[3], src[0] + src[1], src[2] + src[3])`SSE Gleitkomma
haddps	xmm, xmm/m128	F2 0F 7C /r	Addition benachbarter Singles (horizontal)`dst = (dst[0] + dst[1], dst[2] + dst[3], src[0] + src[1], src[2] + src[3])`SSE Gleitkomma
hlt		F4	Anhalten des Prozessors (bis zum nächsten Interrupt)`stop until the next interrupt (privileged)`System und Privilegien
hsubpd	xmm, xmm/m128	66 0F 7D /r	Subtraktion benachbarter Doubles (horizontal)`dst = (dst[0] - dst[1], dst[2] - dst[3], src[0] - src[1], src[2] - src[3])`SSE Gleitkomma
hsubps	xmm, xmm/m128	F2 0F 7D /r	Subtraktion benachbarter Singles (horizontal)`dst = (dst[0] - dst[1], dst[2] - dst[3], src[0] - src[1], src[2] - src[3])`SSE Gleitkomma
idiv	r/m8	F6 /7	Division mit Vorzeichen: edx:eax durch den Operanden, Quotient nach eax, Rest nach edx`rax = rdx:rax / src; rdx = rdx:rax % src (8 bit: al = ax / src; ah = ax % src); #DE if src = 0 or quotient too big (signed)`Flags: – · undefiniert: OF SF ZF AF CF PFArithmetik
	r/m32	F7 /7
	r/m16	66 F7 /7
	r/m64	REX.W F7 /7
imul	r32, r/m32, imm32	69 /r id	Multiplikation mit Vorzeichen (ein, zwei oder drei Operanden)`1 operand: rdx:rax = rax * src (signed); 2: dst = dst * src; 3: dst = src * imm`Flags: OF CF · undefiniert: SF ZF AF PFArithmetik
	r16, r/m16, imm16	66 69 /r iw
	r64, r/m64, imm32	REX.W 69 /r id
	r32, r/m32, imm8	6B /r ib
	r16, r/m16, imm8	66 6B /r ib
	r64, r/m64, imm8	REX.W 6B /r ib
	r/m8	F6 /5
	r/m32	F7 /5
	r/m16	66 F7 /5
	r/m64	REX.W F7 /5
	r32, r/m32	0F AF /r
	r16, r/m16	66 0F AF /r
	r64, r/m64	REX.W 0F AF /r
in	al, imm8	E4 ib	Lesen eines Wertes von einem Ein-/Ausgabeport`dst = port[src]`Daten kopieren
	eax, imm8	E5 ib
	ax, imm8	66 E5 ib
	al, dx	EC
	eax, dx	ED
	ax, dx	66 ED
inc	r/m8	FE /0	Erhöhung um 1 (CF bleibt)`dst = dst + 1`Flags: OF SF ZF AF PFArithmetik
	r/m32	FF /0
	r/m16	66 FF /0
	r/m64	REX.W FF /0
insb		6C	Lesen eines Ports nach [rdi], rdi läuft weiter`[rdi] = port[dx]; rdi = rdi +/- size`Zeichenketten
insd		6D	Lesen eines Ports nach [rdi], rdi läuft weiter`[rdi] = port[dx]; rdi = rdi +/- size`Zeichenketten
insertps	xmm, xmm/m32, imm8	66 0F 3A 21 /r ib	Einfügen eines Singles in xmm`dst = dst with one single replaced by one of src (and zeroed ones), chosen by imm8`SSE und MMX Datenbewegung
insw		66 6D	Lesen eines Ports nach [rdi], rdi läuft weiter`[rdi] = port[dx]; rdi = rdi +/- size`Zeichenketten
int	imm8	CD ib	Auslösen eines Software-Interrupts`push(flags, cs, rip); jump to the handler of vector imm8`Flags: IF TFSprünge, Aufrufe und Interrupts
int1		F1	Auslösen des Debug-Interrupts 1`interrupt 1 (debug exception)`Sprünge, Aufrufe und Interrupts
int3		CC	Haltepunkt (Interrupt 3, ein Byte)`interrupt 3 (breakpoint)`Sprünge, Aufrufe und Interrupts
invd		0F 08	Leeren der Caches ohne Zurückschreiben (privilegiert)`empty the caches without writing back (privileged)`System und Privilegien
invlpg	m	0F 01 /7	Entwerten eines Eintrags des Adressübersetzungspuffers (TLB)`remove the translation of the page of [m] from the TLB (privileged)`System und Privilegien
iretd		CF	Rückkehr aus einem Interrupt (32 Bit)`rip, cs, flags = pop(); (64 bit and on a change of level: rsp, ss = pop())`Flags: allSprünge, Aufrufe und Interrupts
iretq		REX.W CF	Rückkehr aus einem Interrupt (64 Bit)`rip, cs, flags = pop(); (64 bit and on a change of level: rsp, ss = pop())`Flags: allSprünge, Aufrufe und Interrupts
iretw		66 CF	Rückkehr aus einem Interrupt (16 Bit)`rip, cs, flags = pop(); (64 bit and on a change of level: rsp, ss = pop())`Flags: allSprünge, Aufrufe und Interrupts
ja	rel8	77 cb	Sprung, wenn ohne Vorzeichen größer (CF=0 und ZF=0)`if CF = 0 and ZF = 0 then rip = target`Sprünge, Aufrufe und Interrupts
ja	rel32	0F 87 cd
jbe	rel8	76 cb	Sprung, wenn ohne Vorzeichen kleiner oder gleich (CF=1 oder ZF=1)`if CF = 1 or ZF = 1 then rip = target`Sprünge, Aufrufe und Interrupts
jbe	rel32	0F 86 cd
jc	rel8	72 cb	Sprung, wenn Übertrag, ohne Vorzeichen kleiner (CF=1)`if CF = 1 then rip = target`Sprünge, Aufrufe und Interrupts
jc	rel32	0F 82 cd
jg	rel8	7F cb	Sprung, wenn mit Vorzeichen größer (ZF=0 und SF=OF)`if ZF = 0 and SF = OF then rip = target`Sprünge, Aufrufe und Interrupts
jg	rel32	0F 8F cd
jge	rel8	7D cb	Sprung, wenn mit Vorzeichen größer oder gleich (SF=OF)`if SF = OF then rip = target`Sprünge, Aufrufe und Interrupts
jge	rel32	0F 8D cd
jl	rel8	7C cb	Sprung, wenn mit Vorzeichen kleiner (SF≠OF)`if SF != OF then rip = target`Sprünge, Aufrufe und Interrupts
jl	rel32	0F 8C cd
jle	rel8	7E cb	Sprung, wenn mit Vorzeichen kleiner oder gleich (ZF=1 oder SF≠OF)`if ZF = 1 or SF != OF then rip = target`Sprünge, Aufrufe und Interrupts
jle	rel32	0F 8E cd
jmp	rel32	E9 cd	Sprung zu einer Adresse`rip = target`Sprünge, Aufrufe und Interrupts
	rel8	EB cb
	r/m64	FF /4
	m	FF /5
	r/m16	66 FF /4
jnc	rel8	73 cb	Sprung, wenn kein Übertrag, ohne Vorzeichen größer oder gleich (CF=0)`if CF = 0 then rip = target`Sprünge, Aufrufe und Interrupts
jnc	rel32	0F 83 cd
jno	rel8	71 cb	Sprung, wenn kein Überlauf (OF=0)`if OF = 0 then rip = target`Sprünge, Aufrufe und Interrupts
jno	rel32	0F 81 cd
jnp	rel8	7B cb	Sprung, wenn Parität ungerade (PF=0)`if PF = 0 then rip = target`Sprünge, Aufrufe und Interrupts
jnp	rel32	0F 8B cd
jns	rel8	79 cb	Sprung, wenn nicht negativ (SF=0)`if SF = 0 then rip = target`Sprünge, Aufrufe und Interrupts
jns	rel32	0F 89 cd
jnz	rel8	75 cb	Sprung, wenn ungleich, Ergebnis nicht null (ZF=0)`if ZF = 0 then rip = target`Sprünge, Aufrufe und Interrupts
jnz	rel32	0F 85 cd
jo	rel8	70 cb	Sprung, wenn Überlauf (OF=1)`if OF = 1 then rip = target`Sprünge, Aufrufe und Interrupts
jo	rel32	0F 80 cd
jp	rel8	7A cb	Sprung, wenn Parität gerade (PF=1)`if PF = 1 then rip = target`Sprünge, Aufrufe und Interrupts
jp	rel32	0F 8A cd
jrcxz	rel8	E3 cb	Sprung, wenn rcx gleich 0 ist`if rcx == 0 then rip = target`Sprünge, Aufrufe und Interrupts
js	rel8	78 cb	Sprung, wenn negativ (SF=1)`if SF = 1 then rip = target`Sprünge, Aufrufe und Interrupts
js	rel32	0F 88 cd
jz	rel8	74 cb	Sprung, wenn gleich, Ergebnis null (ZF=1)`if ZF = 1 then rip = target`Sprünge, Aufrufe und Interrupts
jz	rel32	0F 84 cd
lahf		9F	Laden der Flags nach ah`ah = SF:ZF:0:AF:0:PF:1:CF`Flags
lar	r32, r32/m16	0F 02 /r	Laden der Zugriffsrechte eines Segments`dst = access rights of the segment src; ZF = 1 if it is valid`Flags: ZFSystem und Privilegien
	r16, r32/m16	66 0F 02 /r
	r64, r32/m16	REX.W 0F 02 /r
lddqu	xmm, m128	F2 0F F0 /r	Laden von 128 Bit ohne Ausrichtung (schnell über Cache-Zeilen)`dst = src (128 bits; any alignment)`SSE und MMX Datenbewegung
ldmxcsr	m	0F AE /2	Laden des SSE-Steuer- und Statusregisters`MXCSR = [m32]`SSE und MMX Datenbewegung
lea	r32, m	8D /r	Berechnung einer Adresse und Speichern der Adresse, ohne Zugriff auf den Speicher`dst = address of src (no memory access)`Daten kopieren
	r16, m	66 8D /r
	r64, m	REX.W 8D /r
leave		C9	Abbau des Stackrahmens (mov rsp, rbp; pop rbp)`rsp = rbp; rbp = pop()`Stack
lfence		0F AE /5	Schranke für Ladezugriffe`all earlier loads are done before later instructions`Schranken und Sonstiges
lgdt	m	0F 01 /2	Laden des Registers der globalen Deskriptortabelle`GDTR = [m] (privileged)`System und Privilegien
lidt	m	0F 01 /3	Laden des Registers der Interrupt-Deskriptortabelle`IDTR = [m] (privileged)`System und Privilegien
lldt	r/m16	0F 00 /2	Laden des Registers der lokalen Deskriptortabelle`LDTR = src (privileged)`System und Privilegien
lmsw	m	0F 01 /6	Laden des Maschinen-Statuswortes (untere Bits von cr0)`CR0 bits 0 to 15 = src (privileged)`System und Privilegien
lodsb		AC	Laden von [rsi] nach al/ax/eax/rax, rsi läuft weiter`acc = [rsi]; rsi = rsi +/- size (acc is al, ax, eax or rax)`Zeichenketten
lodsd		AD	Laden von [rsi] nach al/ax/eax/rax, rsi läuft weiter`acc = [rsi]; rsi = rsi +/- size (acc is al, ax, eax or rax)`Zeichenketten
lodsq		REX.W AD	Laden von [rsi] nach al/ax/eax/rax, rsi läuft weiter`acc = [rsi]; rsi = rsi +/- size (acc is al, ax, eax or rax)`Zeichenketten
lodsw		66 AD	Laden von [rsi] nach al/ax/eax/rax, rsi läuft weiter`acc = [rsi]; rsi = rsi +/- size (acc is al, ax, eax or rax)`Zeichenketten
loop	rel8	E2 cb	Verringern von rcx und Sprung, solange es nicht 0 ist`rcx = rcx - 1; if rcx != 0 then rip = target`Sprünge, Aufrufe und Interrupts
loope	rel8	E1 cb	Wie loop, aber nur bei ZF=1`rcx = rcx - 1; if rcx != 0 and ZF = 1 then rip = target`Sprünge, Aufrufe und Interrupts
loopne	rel8	E0 cb	Wie loop, aber nur bei ZF=0`rcx = rcx - 1; if rcx != 0 and ZF = 0 then rip = target`Sprünge, Aufrufe und Interrupts
lsl	r32, r32/m16	0F 03 /r	Laden der Grenze eines Segments`dst = limit of the segment src; ZF = 1 if it is valid`Flags: ZFSystem und Privilegien
	r16, r32/m16	66 0F 03 /r
	r64, r32/m16	REX.W 0F 03 /r
ltr	r/m16	0F 00 /3	Laden des Task-Registers`task register = src (privileged)`System und Privilegien
lzcnt	r32, r/m32	F3 0F BD /r	Zählen der führenden Nullbits`dst = number of leading 0 bits of src (width if src = 0)`Flags: ZF CFArithmetik
lzcnt	r64, r/m64	F3 REX.W 0F BD /r
maskmovdqu	xmm, xmm	66 0F F7 /r	Schreiben nur der durch eine Maske gewählten Bytes (xmm)`for each byte whose mask bit (the top bit) is 1: [rdi + i] = dst[i]`SSE und MMX Datenbewegung
maskmovq	mm, mm	0F F7 /r	Schreiben nur der durch eine Maske gewählten Bytes (mm)`for each byte whose mask bit (the top bit) is 1: [rdi + i] = dst[i]`SSE und MMX Datenbewegung
maxpd	xmm, xmm/m128	66 0F 5F /r	Maximum von 2 Doubles`for every element: dst[i] = max(dst[i], src[i])`SSE Gleitkomma
maxps	xmm, xmm/m128	0F 5F /r	Maximum von 4 Singles`for every element: dst[i] = max(dst[i], src[i])`SSE Gleitkomma
maxsd	xmm, xmm/m64	F2 0F 5F /r	Maximum von einem Double`dst[0] = max(dst[0], src[0]); the other elements stay`SSE Gleitkomma
maxss	xmm, xmm/m32	F3 0F 5F /r	Maximum von einem Single`dst[0] = max(dst[0], src[0]); the other elements stay`SSE Gleitkomma
mfence		0F AE /6	Schranke für alle Speicherzugriffe`all earlier loads and stores are done before later ones`Schranken und Sonstiges
minpd	xmm, xmm/m128	66 0F 5D /r	Minimum von 2 Doubles`for every element: dst[i] = min(dst[i], src[i])`SSE Gleitkomma
minps	xmm, xmm/m128	0F 5D /r	Minimum von 4 Singles`for every element: dst[i] = min(dst[i], src[i])`SSE Gleitkomma
minsd	xmm, xmm/m64	F2 0F 5D /r	Minimum von einem Double`dst[0] = min(dst[0], src[0]); the other elements stay`SSE Gleitkomma
minss	xmm, xmm/m32	F3 0F 5D /r	Minimum von einem Single`dst[0] = min(dst[0], src[0]); the other elements stay`SSE Gleitkomma
monitor		0F 01 C8	Einrichten der Überwachung einer Adresse für mwait`watch the address in rax (for mwait)`System und Privilegien
monitorx		0F 01 FA	Einrichten der Überwachung einer Adresse für mwait`watch the address in rax (for mwait)`System und Privilegien
mov	r/m8, r8	88 /r	Kopieren der Quelle in das Ziel`dst = src`Daten kopieren
	r/m32, r32	89 /r
	r/m16, r16	66 89 /r
	r/m64, r64	REX.W 89 /r
	r8, r/m8	8A /r
	r32, r/m32	8B /r
	r16, r/m16	66 8B /r
	r64, r/m64	REX.W 8B /r
	r32/m16, Sreg	8C /r
	r16, Sreg	66 8C /r
	r64, Sreg	REX.W 8C /r
	Sreg, r32/m16	8E /r
	al, moffs	A0 moffs
	eax, moffs	A1 moffs
	ax, moffs	66 A1 moffs
	rax, moffs	REX.W A1 moffs
	moffs, al	A2 moffs
	moffs, eax	A3 moffs
	moffs, ax	66 A3 moffs
	moffs, rax	REX.W A3 moffs
	r8, imm8	B0+rb ib
	r32, imm32	B8+rd id
	r16, imm16	66 B8+rw iw
	r64, imm64	REX.W B8+rq iq
	r/m8, imm8	C6 /0 ib
	r/m32, imm32	C7 /0 id
	r/m16, imm16	66 C7 /0 iw
	r/m64, imm32	REX.W C7 /0 id
	r64, CRn	0F 20 /r
	r64, DRn	0F 21 /r
	CRn, r64	0F 22 /r
	DRn, r64	0F 23 /r
movapd	xmm, xmm/m128	66 0F 28 /r	Kopieren von 2 Double-Floats (128 Bit), Speicher 16-Byte-ausgerichtet`dst = src (128 bits; memory must be 16-byte aligned)`SSE und MMX Datenbewegung
movapd	xmm/m128, xmm	66 0F 29 /r
movaps	xmm, xmm/m128	0F 28 /r	Kopieren von 4 Single-Floats (128 Bit), Speicher 16-Byte-ausgerichtet`dst = src (128 bits; memory must be 16-byte aligned)`SSE und MMX Datenbewegung
movaps	xmm/m128, xmm	0F 29 /r
movbe	r32, m	0F 38 F0 /r	Kopieren mit Umkehren der Bytes`dst = reverse_bytes(src)`Daten kopieren
	r16, m	66 0F 38 F0 /r
	r64, m	REX.W 0F 38 F0 /r
	m, r32	0F 38 F1 /r
	m, r16	66 0F 38 F1 /r
	m, r64	REX.W 0F 38 F1 /r
movd	mm, r/m32	0F 6E /r	Kopieren von 32 Bit zwischen Ganzzahl-Register/Speicher und xmm/mm`dst = src (32 bits; into xmm / mm the upper bits become 0)`SSE und MMX Datenbewegung
	xmm, r/m32	66 0F 6E /r
	r/m32, mm	0F 7E /r
	r/m32, xmm	66 0F 7E /r
movddup	xmm, xmm/m64	F2 0F 12 /r	Verdoppeln des unteren Doubles in beide Hälften`dst = (src[63:0], src[63:0])`SSE und MMX Datenbewegung
movdq2q	mm, xmm	F2 0F D6 /r	Kopieren der unteren Hälfte von xmm nach mm`dst = src[63:0] (xmm to mm)`SSE und MMX Datenbewegung
movdqa	xmm, xmm/m128	66 0F 6F /r	Kopieren von 128 Bit Ganzzahlen, Speicher 16-Byte-ausgerichtet`dst = src (128 bits; memory must be 16-byte aligned)`SSE und MMX Datenbewegung
movdqa	xmm/m128, xmm	66 0F 7F /r
movdqu	xmm, xmm/m128	F3 0F 6F /r	Kopieren von 128 Bit Ganzzahlen, beliebig ausgerichtet`dst = src (128 bits; any alignment)`SSE und MMX Datenbewegung
movdqu	xmm/m128, xmm	F3 0F 7F /r
movhlps	xmm, xmm	0F 12 /r	Kopieren der oberen Hälfte des Quell-xmm nach unten`dst[63:0] = src[127:64]`SSE und MMX Datenbewegung
movhpd	xmm, m64	66 0F 16 /r	Kopieren von 1 Double in die obere Hälfte von xmm (oder aus ihr)`load: dst[127:64] = [m64]; store: [m64] = src[127:64]`SSE und MMX Datenbewegung
movhpd	m64, xmm	66 0F 17 /r
movhps	xmm, m64	0F 16 /r	Kopieren von 2 Singles in die obere Hälfte von xmm (oder aus ihr)`load: dst[127:64] = [m64]; store: [m64] = src[127:64]`SSE und MMX Datenbewegung
movhps	m64, xmm	0F 17 /r
movlhps	xmm, xmm	0F 16 /r	Kopieren der unteren Hälfte des Quell-xmm nach oben`dst[127:64] = src[63:0]`SSE und MMX Datenbewegung
movlpd	xmm, m64	66 0F 12 /r	Kopieren von 1 Double in die untere Hälfte von xmm (oder aus ihr)`load: dst[63:0] = [m64]; store: [m64] = src[63:0]`SSE und MMX Datenbewegung
movlpd	m64, xmm	66 0F 13 /r
movlps	xmm, m64	0F 12 /r	Kopieren von 2 Singles in die untere Hälfte von xmm (oder aus ihr)`load: dst[63:0] = [m64]; store: [m64] = src[63:0]`SSE und MMX Datenbewegung
movlps	m64, xmm	0F 13 /r
movmskpd	r32, xmm	66 0F 50 /r	Sammeln der Vorzeichenbits von 2 Doubles in ein Register`dst = sign bits of the 2 doubles of src (2 bits)`SSE und MMX Datenbewegung
movmskps	r32, xmm	0F 50 /r	Sammeln der Vorzeichenbits von 4 Singles in ein Register`dst = sign bits of the 4 singles of src (4 bits)`SSE und MMX Datenbewegung
movntdq	m128, xmm	66 0F E7 /r	Schreiben von 128 Bit am Cache vorbei`[dst] = src (past the cache)`SSE und MMX Datenbewegung
movntdqa	xmm, xmm/m128	66 0F 38 2A /r	Lesen von 128 Bit aus Speicher mit Write-Combining`dst = [src] (from write-combining memory)`SSE und MMX Datenbewegung
movnti	m, r32	0F C3 /r	Schreiben am Cache vorbei (nicht-temporal)`[dst] = src (past the cache)`Daten kopieren
movnti	m, r64	REX.W 0F C3 /r
movntpd	m128, xmm	66 0F 2B /r	Schreiben von 128 Bit am Cache vorbei`[dst] = src (past the cache)`SSE und MMX Datenbewegung
movntps	m128, xmm	0F 2B /r	Schreiben von 128 Bit am Cache vorbei`[dst] = src (past the cache)`SSE und MMX Datenbewegung
movntq	m64, mm	0F E7 /r	Schreiben von 64 Bit (mm) am Cache vorbei`[dst] = src (past the cache)`SSE und MMX Datenbewegung
movq	mm, r/m64	REX.W 0F 6E /r	Kopieren von 64 Bit (auch zwischen Ganzzahl-Register und xmm/mm)`dst = src (64 bits; into xmm the upper half becomes 0)`SSE und MMX Datenbewegung
	xmm, r/m64	66 REX.W 0F 6E /r
	mm, mm/m64	0F 6F /r
	xmm, xmm/m64	F3 0F 7E /r
	r/m64, mm	REX.W 0F 7E /r
	r/m64, xmm	66 REX.W 0F 7E /r
	mm/m64, mm	0F 7F /r
	xmm/m64, xmm	66 0F D6 /r
movq2dq	xmm, mm	F3 0F D6 /r	Kopieren von mm in die untere Hälfte von xmm`dst = (0, src) (mm to xmm)`SSE und MMX Datenbewegung
movsb		A4	Kopieren eines Elements von [rsi] nach [rdi], rsi und rdi laufen weiter`[rdi] = [rsi]; rsi = rsi +/- size; rdi = rdi +/- size (+ if DF = 0, - if DF = 1); with rep: repeat rcx times`Zeichenketten
movsd		A5	Kopieren eines Double-Floats (bei xmm; ohne Operanden: String-Befehl)`dst[63:0] = src[63:0] (from memory: the rest of dst becomes 0); without operands it is the string instruction`SSE und MMX Datenbewegung
	xmm, xmm/m64	F2 0F 10 /r
	xmm/m64, xmm	F2 0F 11 /r
movshdup	xmm, xmm/m128	F3 0F 16 /r	Verdoppeln der ungeraden Singles`dst = (src[63:32], src[63:32], src[127:96], src[127:96])`SSE und MMX Datenbewegung
movsldup	xmm, xmm/m128	F3 0F 12 /r	Verdoppeln der geraden Singles`dst = (src[31:0], src[31:0], src[95:64], src[95:64])`SSE und MMX Datenbewegung
movsq		REX.W A5	Kopieren eines Elements von [rsi] nach [rdi], rsi und rdi laufen weiter`[rdi] = [rsi]; rsi = rsi +/- size; rdi = rdi +/- size (+ if DF = 0, - if DF = 1); with rep: repeat rcx times`Zeichenketten
movss	xmm, xmm/m32	F3 0F 10 /r	Kopieren eines Single-Floats`dst[31:0] = src[31:0] (from memory: the rest of dst becomes 0)`SSE und MMX Datenbewegung
movss	xmm/m32, xmm	F3 0F 11 /r
movsw		66 A5	Kopieren eines Elements von [rsi] nach [rdi], rsi und rdi laufen weiter`[rdi] = [rsi]; rsi = rsi +/- size; rdi = rdi +/- size (+ if DF = 0, - if DF = 1); with rep: repeat rcx times`Zeichenketten
movsx	r32, r/m8	0F BE /r	Kopieren mit Erweitern des Vorzeichens auf die größere Breite`dst = sext(src)`Daten kopieren
	r16, r/m8	66 0F BE /r
	r64, r/m8	REX.W 0F BE /r
	r32, r/m16	0F BF /r
	r16, r/m16	66 0F BF /r
	r64, r/m16	REX.W 0F BF /r
movsxd	r32, r/m32	63 /r	Erweitern eines 32-Bit-Wertes mit Vorzeichen auf 64 Bit`dst = sext(src32)`Daten kopieren
	r16, r/m32	66 63 /r
	r64, r/m32	REX.W 63 /r
movupd	xmm, xmm/m128	66 0F 10 /r	Kopieren von 2 Double-Floats (128 Bit), beliebig ausgerichtet`dst = src (128 bits; any alignment)`SSE und MMX Datenbewegung
movupd	xmm/m128, xmm	66 0F 11 /r
movups	xmm, xmm/m128	0F 10 /r	Kopieren von 4 Single-Floats (128 Bit), beliebig ausgerichtet`dst = src (128 bits; any alignment)`SSE und MMX Datenbewegung
movups	xmm/m128, xmm	0F 11 /r
movzx	r32, r/m8	0F B6 /r	Kopieren mit Auffüllen der oberen Hälfte durch Nullen (ohne Vorzeichen)`dst = zext(src)`Daten kopieren
	r16, r/m8	66 0F B6 /r
	r64, r/m8	REX.W 0F B6 /r
	r32, r/m16	0F B7 /r
	r16, r/m16	66 0F B7 /r
	r64, r/m16	REX.W 0F B7 /r
mpsadbw	xmm, xmm/m128, imm8	66 0F 3A 42 /r ib	Summen absoluter Differenzen von Bytes (Bewegungssuche)`dst[i] = sums of absolute byte differences of blocks chosen by imm8`SSE und MMX Ganzzahlen
mul	r/m8	F6 /4	Multiplikation ohne Vorzeichen, das Ergebnis ist doppelt so breit (edx:eax)`rdx:rax = rax * src (8 bit: ax = al * src; 16: dx:ax; 32: edx:eax)`Flags: OF CF · undefiniert: SF ZF AF PFArithmetik
	r/m32	F7 /4
	r/m16	66 F7 /4
	r/m64	REX.W F7 /4
mulpd	xmm, xmm/m128	66 0F 59 /r	Multiplikation von 2 Doubles`for every element: dst[i] = dst[i] * src[i] (double)`SSE Gleitkomma
mulps	xmm, xmm/m128	0F 59 /r	Multiplikation von 4 Singles`for every element: dst[i] = dst[i] * src[i] (single)`SSE Gleitkomma
mulsd	xmm, xmm/m64	F2 0F 59 /r	Multiplikation von einem Double`dst[0] = dst[0] * src[0] (double); the other elements stay`SSE Gleitkomma
mulss	xmm, xmm/m32	F3 0F 59 /r	Multiplikation von einem Single`dst[0] = dst[0] * src[0] (single); the other elements stay`SSE Gleitkomma
mwait		0F 01 C9	Warten auf eine Änderung der überwachten Adresse`wait until the watched address is written or an interrupt comes`System und Privilegien
mwaitx		0F 01 FB	Warten auf eine Änderung der überwachten Adresse`wait until the watched address is written or an interrupt comes`System und Privilegien
neg	r/m8	F6 /3	Negation (Zweierkomplement)`dst = 0 - dst; CF = (dst != 0)`Flags: OF SF ZF AF CF PFArithmetik
	r/m32	F7 /3
	r/m16	66 F7 /3
	r/m64	REX.W F7 /3
nop		90	Keine Operation`no operation`Schranken und Sonstiges
	r/m32	0F 19 /r
	r/m16	66 0F 19 /r
	r/m64	REX.W 0F 19 /r
	r/m32	0F 1A /r
	r/m16	66 0F 1A /r
	r/m64	REX.W 0F 1A /r
	r/m32	0F 1B /r
	r/m16	66 0F 1B /r
	r/m64	REX.W 0F 1B /r
	r/m32	0F 1C /r
	r/m16	66 0F 1C /r
	r/m64	REX.W 0F 1C /r
	r/m32	0F 1D /r
	r/m16	66 0F 1D /r
	r/m64	REX.W 0F 1D /r
	r/m32	0F 1E /r
	r/m16	66 0F 1E /r
	r32	F3 0F 1E /0
	r32	F3 0F 1E /2
	r32	F3 0F 1E /3
	r32	F3 0F 1E /4
	r32	F3 0F 1E /5
	r32	F3 0F 1E /6
	eax	F3 0F 1E F8
	ebp	F3 0F 1E FD
	ecx	F3 0F 1E F9
	edi	F3 0F 1E FF
	esi	F3 0F 1E FE
	esp	F3 0F 1E FC
	r/m64	REX.W 0F 1E /r
	r64	F3 REX.W 0F 1E /0
	r64	F3 REX.W 0F 1E /2
	r64	F3 REX.W 0F 1E /3
	r64	F3 REX.W 0F 1E /4
	r64	F3 REX.W 0F 1E /5
	r64	F3 REX.W 0F 1E /6
	rax	F3 REX.W 0F 1E F8
	rbp	F3 REX.W 0F 1E FD
	rcx	F3 REX.W 0F 1E F9
	rdi	F3 REX.W 0F 1E FF
	rsi	F3 REX.W 0F 1E FE
	rsp	F3 REX.W 0F 1E FC
	r/m32	0F 1F /r
	r/m16	66 0F 1F /r
	r/m64	REX.W 0F 1F /r
not	r/m8	F6 /2	Umkehrung aller Bits (Einerkomplement)`dst = ~dst`Logik und Bits
	r/m32	F7 /2
	r/m16	66 F7 /2
	r/m64	REX.W F7 /2
or	r/m8, r8	08 /r	Bitweise ODER-Verknüpfung`dst = dst OR src; CF = OF = 0`Flags: OF SF ZF CF PF · undefiniert: AFLogik und Bits
	r/m32, r32	09 /r
	r/m16, r16	66 09 /r
	r/m64, r64	REX.W 09 /r
	r8, r/m8	0A /r
	r32, r/m32	0B /r
	r16, r/m16	66 0B /r
	r64, r/m64	REX.W 0B /r
	al, imm8	0C ib
	eax, imm32	0D id
	ax, imm16	66 0D iw
	rax, imm32	REX.W 0D id
	r/m8, imm8	80 /1 ib
	r/m32, imm32	81 /1 id
	r/m16, imm16	66 81 /1 iw
	r/m64, imm32	REX.W 81 /1 id
	r/m32, imm8	83 /1 ib
	r/m16, imm8	66 83 /1 ib
	r/m64, imm8	REX.W 83 /1 ib
orpd	xmm, xmm/m128	66 0F 56 /r	Bitweise ODER-Verknüpfung`dst = dst OR src`SSE Gleitkomma
orps	xmm, xmm/m128	0F 56 /r	Bitweise ODER-Verknüpfung`dst = dst OR src`SSE Gleitkomma
out	imm8, al	E6 ib	Schreiben eines Wertes auf einen Ein-/Ausgabeport`port[dst] = src`Daten kopieren
	imm8, eax	E7 ib
	imm8, ax	66 E7 ib
	dx, al	EE
	dx, eax	EF
	dx, ax	66 EF
outsb		6E	Schreiben von [rsi] auf einen Port, rsi läuft weiter`port[dx] = [rsi]; rsi = rsi +/- size`Zeichenketten
outsd		6F	Schreiben von [rsi] auf einen Port, rsi läuft weiter`port[dx] = [rsi]; rsi = rsi +/- size`Zeichenketten
outsw		66 6F	Schreiben von [rsi] auf einen Port, rsi läuft weiter`port[dx] = [rsi]; rsi = rsi +/- size`Zeichenketten
pabsb	mm, mm/m64	0F 38 1C /r	Betrag von Bytes`for every 8 bit element: dst[i] = abs(src[i])`SSE und MMX Ganzzahlen
pabsb	xmm, xmm/m128	66 0F 38 1C /r
pabsd	mm, mm/m64	0F 38 1E /r	Betrag von 32-Bit-Elementen`for every 32 bit element: dst[i] = abs(src[i])`SSE und MMX Ganzzahlen
pabsd	xmm, xmm/m64	66 0F 38 1E /r
pabsw	mm, mm/m64	0F 38 1D /r	Betrag von 16-Bit-Elementen`for every 16 bit element: dst[i] = abs(src[i])`SSE und MMX Ganzzahlen
pabsw	xmm, xmm/m128	66 0F 38 1D /r
packssdw	mm, mm/m64	0F 6B /r	Packen von 32 in 16 Bit mit Vorzeichen (gesättigt)`dst = (sat16_s(dst[i]) ..., sat16_s(src[i]) ...) (32 to 16 bit, signed)`SSE und MMX Ganzzahlen
packssdw	xmm, xmm/m128	66 0F 6B /r
packsswb	mm, mm/m64	0F 63 /r	Packen von 16 in 8 Bit mit Vorzeichen (gesättigt)`dst = (sat8_s(dst[i]) ..., sat8_s(src[i]) ...) (16 to 8 bit, signed)`SSE und MMX Ganzzahlen
packsswb	xmm, xmm/m128	66 0F 63 /r
packusdw	xmm, xmm/m128	66 0F 38 2B /r	Packen von 32 in 16 Bit ohne Vorzeichen (gesättigt)`dst = (sat16_u(dst[i]) ..., sat16_u(src[i]) ...) (32 to 16 bit, unsigned)`SSE und MMX Ganzzahlen
packuswb	mm, mm/m64	0F 67 /r	Packen von 16 in 8 Bit ohne Vorzeichen (gesättigt)`dst = (sat8_u(dst[i]) ..., sat8_u(src[i]) ...) (16 to 8 bit, unsigned)`SSE und MMX Ganzzahlen
packuswb	xmm, xmm/m128	66 0F 67 /r
paddb	mm, mm/m64	0F FC /r	Addition von Bytes`for every 8 bit element: dst[i] = dst[i] + src[i]`SSE und MMX Ganzzahlen
paddb	xmm, xmm/m128	66 0F FC /r
paddd	mm, mm/m64	0F FE /r	Addition von 32-Bit-Elementen`for every 32 bit element: dst[i] = dst[i] + src[i]`SSE und MMX Ganzzahlen
paddd	xmm, xmm/m128	66 0F FE /r
paddq	mm, mm/m64	0F D4 /r	Addition von 64-Bit-Elementen`for every 64 bit element: dst[i] = dst[i] + src[i]`SSE und MMX Ganzzahlen
paddq	xmm, xmm/m128	66 0F D4 /r
paddsb	mm, mm/m64	0F EC /r	Addition von Bytes (mit Vorzeichen, gesättigt)`for every 8 bit element: dst[i] = sat_s(dst[i] + src[i])`SSE und MMX Ganzzahlen
paddsb	xmm, xmm/m128	66 0F EC /r
paddsw	mm, mm/m64	0F ED /r	Addition von 16-Bit-Elementen (mit Vorzeichen, gesättigt)`for every 16 bit element: dst[i] = sat_s(dst[i] + src[i])`SSE und MMX Ganzzahlen
paddsw	xmm, xmm/m128	66 0F ED /r
paddusb	mm, mm/m64	0F DC /r	Addition von Bytes (ohne Vorzeichen, gesättigt)`for every 8 bit element: dst[i] = sat_u(dst[i] + src[i])`SSE und MMX Ganzzahlen
paddusb	xmm, xmm/m128	66 0F DC /r
paddusw	mm, mm/m64	0F DD /r	Addition von 16-Bit-Elementen (ohne Vorzeichen, gesättigt)`for every 16 bit element: dst[i] = sat_u(dst[i] + src[i])`SSE und MMX Ganzzahlen
paddusw	xmm, xmm/m128	66 0F DD /r
paddw	mm, mm/m64	0F FD /r	Addition von 16-Bit-Elementen`for every 16 bit element: dst[i] = dst[i] + src[i]`SSE und MMX Ganzzahlen
paddw	xmm, xmm/m128	66 0F FD /r
palignr	mm, mm/m64, imm8	0F 3A 0F /r ib	Verbinden zweier Register und Schieben um eine Byte-Zahl`dst = low part of (dst:src >> (imm8 * 8 bits))`SSE und MMX Ganzzahlen
palignr	xmm, xmm/m128, imm8	66 0F 3A 0F /r ib
pand	mm, mm/m64	0F DB /r	Bitweise UND-Verknüpfung`dst = dst & src`SSE und MMX Ganzzahlen
pand	xmm, xmm/m128	66 0F DB /r
pandn	mm, mm/m64	0F DF /r	Bitweise Verknüpfung: NICHT Ziel UND Quelle`dst = ~dst & src`SSE und MMX Ganzzahlen
pandn	xmm, xmm/m128	66 0F DF /r
pause		F3 90	Hinweis in Warteschleifen (spart Strom, hilft bei Hyper-Threading)`hint: this is a wait loop (no change)`Schranken und Sonstiges
pavgb	mm, mm/m64	0F E0 /r	Mittelwert von Bytes (gerundet)`dst[i] = (dst[i] + src[i] + 1) >> 1 (unsigned)`SSE und MMX Ganzzahlen
pavgb	xmm, xmm/m128	66 0F E0 /r
pavgw	mm, mm/m64	0F E3 /r	Mittelwert von 16-Bit-Elementen (gerundet)`dst[i] = (dst[i] + src[i] + 1) >> 1 (unsigned)`SSE und MMX Ganzzahlen
pavgw	xmm, xmm/m128	66 0F E3 /r
pblendvb	xmm, xmm/m128, xmm0	66 0F 38 10 /r	Auswahl von Bytes nach den Vorzeichenbits von xmm0`for every element: dst[i] = (sign bit of xmm0[i]) ? src[i] : dst[i]`SSE und MMX Ganzzahlen
pblendw	xmm, xmm/m128, imm8	66 0F 3A 0E /r ib	Auswahl von 16-Bit-Elementen nach einer Maske`for every element: dst[i] = bit i of imm8 ? src[i] : dst[i]`SSE und MMX Ganzzahlen
pclmulqdq	xmm, xmm/m128, imm8	66 0F 3A 44 /r ib	Multiplikation ohne Übertrag (Galois-Feld, für CRC und GCM)`dst = carry-less product of one quadword of dst and one of src (chosen by imm8)`Kryptografie
pcmpeqb	mm, mm/m64	0F 74 /r	Vergleich auf gleich (Bytes), Ergebnis ist eine Maske`for every 8 bit element: dst[i] = (dst[i] == src[i]) ? all 1 bits : 0`SSE und MMX Ganzzahlen
pcmpeqb	xmm, xmm/m128	66 0F 74 /r
pcmpeqd	mm, mm/m64	0F 76 /r	Vergleich auf gleich (32-Bit-Elementen), Ergebnis ist eine Maske`for every 32 bit element: dst[i] = (dst[i] == src[i]) ? all 1 bits : 0`SSE und MMX Ganzzahlen
pcmpeqd	xmm, xmm/m128	66 0F 76 /r
pcmpeqq	xmm, xmm/m128	66 0F 38 29 /r	Vergleich auf gleich (64-Bit-Elementen), Ergebnis ist eine Maske`for every 64 bit element: dst[i] = (dst[i] == src[i]) ? all 1 bits : 0`SSE und MMX Ganzzahlen
pcmpeqw	mm, mm/m64	0F 75 /r	Vergleich auf gleich (16-Bit-Elementen), Ergebnis ist eine Maske`for every 16 bit element: dst[i] = (dst[i] == src[i]) ? all 1 bits : 0`SSE und MMX Ganzzahlen
pcmpeqw	xmm, xmm/m128	66 0F 75 /r
pcmpestri	xmm, xmm/m128, imm8	66 0F 3A 61 /r ib	Vergleich von Zeichenketten (explizite Längen), Ergebnis ist ein Index`ECX = index of the match of the strings dst, src (lengths in eax, edx; mode imm8)`Flags: OF SF ZF AF CF PFSSE und MMX Ganzzahlen
pcmpestrm	xmm, xmm/m128, imm8	66 0F 3A 60 /r ib	Vergleich von Zeichenketten (explizite Längen), Ergebnis ist eine Maske`xmm0 = mask of the matches of the strings dst, src (lengths in eax, edx; mode imm8)`Flags: OF SF ZF AF CF PFSSE und MMX Ganzzahlen
pcmpgtb	mm, mm/m64	0F 64 /r	Vergleich auf größer, mit Vorzeichen (Bytes), Ergebnis ist eine Maske`for every 8 bit element: dst[i] = (dst[i] > src[i]) ? all 1 bits : 0 (signed)`SSE und MMX Ganzzahlen
pcmpgtb	xmm, xmm/m128	66 0F 64 /r
pcmpgtd	mm, mm/m64	0F 66 /r	Vergleich auf größer, mit Vorzeichen (32-Bit-Elementen), Ergebnis ist eine Maske`for every 32 bit element: dst[i] = (dst[i] > src[i]) ? all 1 bits : 0 (signed)`SSE und MMX Ganzzahlen
pcmpgtd	xmm, xmm/m128	66 0F 66 /r
pcmpgtq	xmm, xmm/m128	66 0F 38 37 /r	Vergleich auf größer, mit Vorzeichen (64-Bit-Elementen), Ergebnis ist eine Maske`for every 64 bit element: dst[i] = (dst[i] > src[i]) ? all 1 bits : 0 (signed)`SSE und MMX Ganzzahlen
pcmpgtw	mm, mm/m64	0F 65 /r	Vergleich auf größer, mit Vorzeichen (16-Bit-Elementen), Ergebnis ist eine Maske`for every 16 bit element: dst[i] = (dst[i] > src[i]) ? all 1 bits : 0 (signed)`SSE und MMX Ganzzahlen
pcmpgtw	xmm, xmm/m128	66 0F 65 /r
pcmpistri	xmm, xmm/m128, imm8	66 0F 3A 63 /r ib	Vergleich von Zeichenketten (mit Ende 0), Ergebnis ist ein Index`ECX = index of the match of the 0-terminated strings dst, src (mode imm8)`Flags: OF SF ZF AF CF PFSSE und MMX Ganzzahlen
pcmpistrm	xmm, xmm/m128, imm8	66 0F 3A 62 /r ib	Vergleich von Zeichenketten (mit Ende 0), Ergebnis ist eine Maske`xmm0 = mask of the matches of the 0-terminated strings dst, src (mode imm8)`Flags: OF SF ZF AF CF PFSSE und MMX Ganzzahlen
pextrb	r32/m8, xmm, imm8	66 0F 3A 14 /r ib	Herausholen eines Elements aus xmm in ein Register`dst = element number imm8 of src`SSE und MMX Datenbewegung
pextrd	r/m32, xmm, imm8	66 0F 3A 16 /r ib	Herausholen eines Elements aus xmm in ein Register`dst = element number imm8 of src`SSE und MMX Datenbewegung
pextrq	r/m64, xmm, imm8	66 REX.W 0F 3A 16 /r ib	Herausholen eines Elements aus xmm in ein Register`dst = element number imm8 of src`SSE und MMX Datenbewegung
pextrw	r32, mm, imm8	0F C5 /r ib	Herausholen eines Elements aus xmm in ein Register`dst = element number imm8 of src`SSE und MMX Datenbewegung
	r32, xmm, imm8	66 0F C5 /r ib
	r32/m16, xmm, imm8	66 0F 3A 15 /r ib
phaddd	mm, mm/m64	0F 38 02 /r	Addition benachbarter 32-Bit-Elemente (horizontal)`dst = (dst[0] + dst[1], dst[2] + dst[3], ..., src[0] + src[1], ...)`SSE und MMX Ganzzahlen
phaddd	xmm, xmm/m128	66 0F 38 02 /r
phaddsw	mm, mm/m64	0F 38 03 /r	Addition benachbarter 16-Bit-Elemente (horizontal), gesättigt`dst = (dst[0] + dst[1], dst[2] + dst[3], ..., src[0] + src[1], ...) (saturating)`SSE und MMX Ganzzahlen
phaddsw	xmm, xmm/m128	66 0F 38 03 /r
phaddw	mm, mm/m64	0F 38 01 /r	Addition benachbarter 16-Bit-Elemente (horizontal)`dst = (dst[0] + dst[1], dst[2] + dst[3], ..., src[0] + src[1], ...)`SSE und MMX Ganzzahlen
phaddw	xmm, xmm/m128	66 0F 38 01 /r
phminposuw	xmm, xmm/m128	66 0F 38 41 /r	Suche des kleinsten 16-Bit-Elements samt Position`dst = (smallest unsigned word of src, its index, 0 ...)`SSE und MMX Ganzzahlen
phsubd	mm, mm/m64	0F 38 06 /r	Subtraktion benachbarter 32-Bit-Elemente (horizontal)`dst = (dst[0] - dst[1], dst[2] - dst[3], ..., src[0] - src[1], ...)`SSE und MMX Ganzzahlen
phsubd	xmm, xmm/m128	66 0F 38 06 /r
phsubsw	mm, mm/m64	0F 38 07 /r	Subtraktion benachbarter 16-Bit-Elemente (horizontal), gesättigt`dst = (dst[0] - dst[1], dst[2] - dst[3], ..., src[0] - src[1], ...) (saturating)`SSE und MMX Ganzzahlen
phsubsw	xmm, xmm/m128	66 0F 38 07 /r
phsubw	mm, mm/m64	0F 38 05 /r	Subtraktion benachbarter 16-Bit-Elemente (horizontal)`dst = (dst[0] - dst[1], dst[2] - dst[3], ..., src[0] - src[1], ...)`SSE und MMX Ganzzahlen
phsubw	xmm, xmm/m128	66 0F 38 05 /r
pinsrb	xmm, r32/m8, imm8	66 0F 3A 20 /r ib	Einfügen eines Elements aus einem Register in xmm`dst = dst with element number imm8 replaced by src`SSE und MMX Datenbewegung
pinsrd	xmm, r/m32, imm8	66 0F 3A 22 /r ib	Einfügen eines Elements aus einem Register in xmm`dst = dst with element number imm8 replaced by src`SSE und MMX Datenbewegung
pinsrq	xmm, r/m64, imm8	66 REX.W 0F 3A 22 /r ib	Einfügen eines Elements aus einem Register in xmm`dst = dst with element number imm8 replaced by src`SSE und MMX Datenbewegung
pinsrw	mm, r32/m16, imm8	0F C4 /r ib	Einfügen eines Elements aus einem Register in xmm`dst = dst with element number imm8 replaced by src`SSE und MMX Datenbewegung
pinsrw	xmm, r32/m16, imm8	66 0F C4 /r ib
pmaddubsw	mm, mm/m64	0F 38 04 /r	Multiplikation von Bytepaaren und Addition (mit Sättigung)`dst[i] = sat16(dst_u8[2i] * src_s8[2i] + dst_u8[2i+1] * src_s8[2i+1])`SSE und MMX Ganzzahlen
pmaddubsw	xmm, xmm/m128	66 0F 38 04 /r
pmaddwd	mm, mm/m64	0F F5 /r	Multiplikation von 16-Bit-Paaren und Addition zu 32 Bit`dst[i] = dst_s16[2i] * src_s16[2i] + dst_s16[2i+1] * src_s16[2i+1] (32 bit)`SSE und MMX Ganzzahlen
pmaddwd	xmm, xmm/m128	66 0F F5 /r
pmaxsb	xmm, xmm/m128	66 0F 38 3C /r	Maximum von Bytes (mit Vorzeichen)`for every 8 bit element: dst[i] = max(dst[i], src[i]) (signed)`SSE und MMX Ganzzahlen
pmaxsd	xmm, xmm/m64	66 0F 38 3D /r	Maximum von 32-Bit-Elementen (mit Vorzeichen)`for every 32 bit element: dst[i] = max(dst[i], src[i]) (signed)`SSE und MMX Ganzzahlen
pmaxsw	mm, mm/m64	0F EE /r	Maximum von 16-Bit-Elementen (mit Vorzeichen)`for every 16 bit element: dst[i] = max(dst[i], src[i]) (signed)`SSE und MMX Ganzzahlen
pmaxsw	xmm, xmm/m128	66 0F EE /r
pmaxub	mm, mm/m64	0F DE /r	Maximum von Bytes (ohne Vorzeichen)`for every 8 bit element: dst[i] = max(dst[i], src[i]) (unsigned)`SSE und MMX Ganzzahlen
pmaxub	xmm, xmm/m128	66 0F DE /r
pmaxud	xmm, xmm/m128	66 0F 38 3F /r	Maximum von 32-Bit-Elementen (ohne Vorzeichen)`for every 32 bit element: dst[i] = max(dst[i], src[i]) (unsigned)`SSE und MMX Ganzzahlen
pmaxuw	xmm, xmm/m128	66 0F 38 3E /r	Maximum von 16-Bit-Elementen (ohne Vorzeichen)`for every 16 bit element: dst[i] = max(dst[i], src[i]) (unsigned)`SSE und MMX Ganzzahlen
pminsb	xmm, xmm/m128	66 0F 38 38 /r	Minimum von Bytes (mit Vorzeichen)`for every 8 bit element: dst[i] = min(dst[i], src[i]) (signed)`SSE und MMX Ganzzahlen
pminsd	xmm, xmm/m64	66 0F 38 39 /r	Minimum von 32-Bit-Elementen (mit Vorzeichen)`for every 32 bit element: dst[i] = min(dst[i], src[i]) (signed)`SSE und MMX Ganzzahlen
pminsw	mm, mm/m64	0F EA /r	Minimum von 16-Bit-Elementen (mit Vorzeichen)`for every 16 bit element: dst[i] = min(dst[i], src[i]) (signed)`SSE und MMX Ganzzahlen
pminsw	xmm, xmm/m128	66 0F EA /r
pminub	mm, mm/m64	0F DA /r	Minimum von Bytes (ohne Vorzeichen)`for every 8 bit element: dst[i] = min(dst[i], src[i]) (unsigned)`SSE und MMX Ganzzahlen
pminub	xmm, xmm/m128	66 0F DA /r
pminud	xmm, xmm/m128	66 0F 38 3B /r	Minimum von 32-Bit-Elementen (ohne Vorzeichen)`for every 32 bit element: dst[i] = min(dst[i], src[i]) (unsigned)`SSE und MMX Ganzzahlen
pminuw	xmm, xmm/m128	66 0F 38 3A /r	Minimum von 16-Bit-Elementen (ohne Vorzeichen)`for every 16 bit element: dst[i] = min(dst[i], src[i]) (unsigned)`SSE und MMX Ganzzahlen
pmovmskb	r32, mm	0F D7 /r	Sammeln der Vorzeichenbits der Bytes in ein Register`dst = the top bits of all bytes of src`SSE und MMX Datenbewegung
pmovmskb	r32, xmm	66 0F D7 /r
pmovsxbd	xmm, xmm/m32	66 0F 38 21 /r	Erweiterung von Bytes zu 32 Bit (mit Vorzeichen)`for every element: dst[i] = sext(src[i]) to the wider size`SSE und MMX Ganzzahlen
pmovsxbq	xmm, xmm/m16	66 0F 38 22 /r	Erweiterung von Bytes zu 64 Bit (mit Vorzeichen)`for every element: dst[i] = sext(src[i]) to the wider size`SSE und MMX Ganzzahlen
pmovsxbw	xmm, xmm/m64	66 0F 38 20 /r	Erweiterung von Bytes zu 16 Bit (mit Vorzeichen)`for every element: dst[i] = sext(src[i]) to the wider size`SSE und MMX Ganzzahlen
pmovsxdq	xmm, xmm/m64	66 0F 38 25 /r	Erweiterung von 32-Bit-Elementen zu 64 Bit (mit Vorzeichen)`for every element: dst[i] = sext(src[i]) to the wider size`SSE und MMX Ganzzahlen
pmovsxwd	xmm, xmm/m64	66 0F 38 23 /r	Erweiterung von 16-Bit-Elementen zu 32 Bit (mit Vorzeichen)`for every element: dst[i] = sext(src[i]) to the wider size`SSE und MMX Ganzzahlen
pmovsxwq	xmm, xmm/m32	66 0F 38 24 /r	Erweiterung von 16-Bit-Elementen zu 64 Bit (mit Vorzeichen)`for every element: dst[i] = sext(src[i]) to the wider size`SSE und MMX Ganzzahlen
pmovzxbd	xmm, xmm/m32	66 0F 38 31 /r	Erweiterung von Bytes zu 32 Bit (mit Nullen)`for every element: dst[i] = zext(src[i]) to the wider size`SSE und MMX Ganzzahlen
pmovzxbq	xmm, xmm/m16	66 0F 38 32 /r	Erweiterung von Bytes zu 64 Bit (mit Nullen)`for every element: dst[i] = zext(src[i]) to the wider size`SSE und MMX Ganzzahlen
pmovzxbw	xmm, xmm/m64	66 0F 38 30 /r	Erweiterung von Bytes zu 16 Bit (mit Nullen)`for every element: dst[i] = zext(src[i]) to the wider size`SSE und MMX Ganzzahlen
pmovzxdq	xmm, xmm/m64	66 0F 38 35 /r	Erweiterung von 32-Bit-Elementen zu 64 Bit (mit Nullen)`for every element: dst[i] = zext(src[i]) to the wider size`SSE und MMX Ganzzahlen
pmovzxwd	xmm, xmm/m64	66 0F 38 33 /r	Erweiterung von 16-Bit-Elementen zu 32 Bit (mit Nullen)`for every element: dst[i] = zext(src[i]) to the wider size`SSE und MMX Ganzzahlen
pmovzxwq	xmm, xmm/m32	66 0F 38 34 /r	Erweiterung von 16-Bit-Elementen zu 64 Bit (mit Nullen)`for every element: dst[i] = zext(src[i]) to the wider size`SSE und MMX Ganzzahlen
pmuldq	xmm, xmm/m128	66 0F 38 28 /r	Multiplikation von 32 Bit mit Vorzeichen zu 64 Bit`dst[i] = dst_s32[2i] * src_s32[2i] (64 bit results)`SSE und MMX Ganzzahlen
pmulhrsw	mm, mm/m64	0F 38 0B /r	Multiplikation von 16 Bit mit Vorzeichen, gerundet`dst[i] = (dst[i] * src[i] >> 14 + 1) >> 1 (signed 16 bit, rounded)`SSE und MMX Ganzzahlen
pmulhrsw	xmm, xmm/m128	66 0F 38 0B /r
pmulhuw	mm, mm/m64	0F E4 /r	Multiplikation von 16 Bit ohne Vorzeichen, obere Hälfte bleibt`dst[i] = (dst[i] * src[i]) >> 16 (unsigned 16 bit)`SSE und MMX Ganzzahlen
pmulhuw	xmm, xmm/m128	66 0F E4 /r
pmulhw	mm, mm/m64	0F E5 /r	Multiplikation von 16 Bit mit Vorzeichen, obere Hälfte bleibt`dst[i] = (dst[i] * src[i]) >> 16 (signed 16 bit)`SSE und MMX Ganzzahlen
pmulhw	xmm, xmm/m128	66 0F E5 /r
pmulld	xmm, xmm/m128	66 0F 38 40 /r	Multiplikation von 32 Bit, untere Hälfte bleibt`dst[i] = low 32 bits of dst[i] * src[i]`SSE und MMX Ganzzahlen
pmullw	mm, mm/m64	0F D5 /r	Multiplikation von 16 Bit, untere Hälfte bleibt`dst[i] = low 16 bits of dst[i] * src[i]`SSE und MMX Ganzzahlen
pmullw	xmm, xmm/m128	66 0F D5 /r
pmuludq	mm, mm/m64	0F F4 /r	Multiplikation von 32 Bit ohne Vorzeichen zu 64 Bit`dst[i] = dst_u32[2i] * src_u32[2i] (64 bit results)`SSE und MMX Ganzzahlen
pmuludq	xmm, xmm/m128	66 0F F4 /r
pop	r64	58+rq	Holen eines Wertes vom Stack`dst = [rsp]; rsp = rsp + 8 (16 bit: 2 bytes)`Stack
	r16	66 58+rw
	r/m64	8F /0
	r/m16	66 8F /0
	fs	0F A1
	gs	0F A9
popcnt	r32, r/m32	F3 0F B8 /r	Zählen der gesetzten Bits`dst = number of 1 bits in src`Flags: OF SF ZF AF CF PFArithmetik
popcnt	r64, r/m64	F3 REX.W 0F B8 /r
popfq		9D	Holen des Flag-Registers vom Stack`flags = pop() (privileged bits stay)`Flags: allStack
popfw		66 9D	Holen des Flag-Registers vom Stack`flags = pop() (privileged bits stay)`Flags: allStack
por	mm, mm/m64	0F EB /r	Bitweise ODER-Verknüpfung`dst = dst OR src`SSE und MMX Ganzzahlen
por	xmm, xmm/m128	66 0F EB /r
prefetch	m	0F 0D /0	Vorab-Laden einer Cache-Zeile (w: zum Schreiben)`load the cache line of [m] into the cache (a hint, no change of the program)`System und Privilegien
	m	0F 0D /2
	m	0F 0D /3
	m	0F 0D /4
	m	0F 0D /5
	m	0F 0D /6
	m	0F 0D /7
prefetchnta	m	0F 18 /0	Vorab-Laden, möglichst ohne den Cache zu verdrängen`load the cache line of [m] into the cache (a hint, no change of the program)`System und Privilegien
prefetcht0	m	0F 18 /1	Vorab-Laden in alle Cache-Ebenen`load the cache line of [m] into the cache (a hint, no change of the program)`System und Privilegien
prefetcht1	m	0F 18 /2	Vorab-Laden in die Cache-Ebene 2 und höher`load the cache line of [m] into the cache (a hint, no change of the program)`System und Privilegien
prefetcht2	m	0F 18 /3	Vorab-Laden in die Cache-Ebene 3`load the cache line of [m] into the cache (a hint, no change of the program)`System und Privilegien
prefetchw	m	0F 0D /1	Vorab-Laden einer Cache-Zeile (w: zum Schreiben)`load the cache line of [m] into the cache (a hint, no change of the program)`System und Privilegien
psadbw	mm, mm/m64	0F F6 /r	Summe der absoluten Byte-Differenzen`dst[i] = sum of abs(dst_u8[j] - src_u8[j]) over 8 bytes`SSE und MMX Ganzzahlen
psadbw	xmm, xmm/m128	66 0F F6 /r
pshufb	mm, mm/m64	0F 38 00 /r	Mischen von Bytes nach einer Tabelle im Quellregister`dst[i] = (src[i] has top bit 1) ? 0 : dst[src[i] & 15]`SSE und MMX Ganzzahlen
pshufb	xmm, xmm/m128	66 0F 38 00 /r
pshufd	xmm, xmm/m128, imm8	66 0F 70 /r ib	Mischen der 32-Bit-Elemente nach einer Vorgabe`dst = (src[sel0], src[sel1], src[sel2], src[sel3]); sel = bit pairs of imm8`SSE und MMX Ganzzahlen
pshufhw	xmm, xmm/m128, imm8	F3 0F 70 /r ib	Mischen der oberen vier 16-Bit-Elemente`dst[63:0] = src[63:0]; the upper four words are chosen from src[127:64] by imm8`SSE und MMX Ganzzahlen
pshuflw	xmm, xmm/m128, imm8	F2 0F 70 /r ib	Mischen der unteren vier 16-Bit-Elemente`dst[127:64] = src[127:64]; the lower four words are chosen from src[63:0] by imm8`SSE und MMX Ganzzahlen
pshufw	mm, mm/m64, imm8	0F 70 /r ib	Mischen von vier 16-Bit-Elementen (mm)`dst = four words chosen from src by imm8 (mm)`SSE und MMX Ganzzahlen
psignb	mm, mm/m64	0F 38 08 /r	Übernahme des Vorzeichens der Quelle für Bytes`for every 8 bit element: dst[i] = src[i] < 0 ? -dst[i] : (src[i] == 0 ? 0 : dst[i])`SSE und MMX Ganzzahlen
psignb	xmm, xmm/m128	66 0F 38 08 /r
psignd	mm, mm/m64	0F 38 0A /r	Übernahme des Vorzeichens der Quelle für 32-Bit-Elementen`for every 32 bit element: dst[i] = src[i] < 0 ? -dst[i] : (src[i] == 0 ? 0 : dst[i])`SSE und MMX Ganzzahlen
psignd	xmm, xmm/m128	66 0F 38 0A /r
psignw	mm, mm/m64	0F 38 09 /r	Übernahme des Vorzeichens der Quelle für 16-Bit-Elementen`for every 16 bit element: dst[i] = src[i] < 0 ? -dst[i] : (src[i] == 0 ? 0 : dst[i])`SSE und MMX Ganzzahlen
psignw	xmm, xmm/m128	66 0F 38 09 /r
pslld	mm, imm8	0F 72 /6 ib	Schieben von 32-Bit-Elementen nach links`for every 32 bit element: dst[i] = dst[i] << count (count = src or imm8)`SSE und MMX Ganzzahlen
	xmm, imm8	66 0F 72 /6 ib
	mm, mm/m64	0F F2 /r
	xmm, xmm/m128	66 0F F2 /r
pslldq	xmm, imm8	66 0F 73 /7 ib	Schieben des ganzen Registers um Bytes nach links`dst = dst << (imm8 * 8 bits) (the whole register, zeros come in)`SSE und MMX Ganzzahlen
psllq	mm, imm8	0F 73 /6 ib	Schieben von 64-Bit-Elementen nach links`for every 64 bit element: dst[i] = dst[i] << count (count = src or imm8)`SSE und MMX Ganzzahlen
	xmm, imm8	66 0F 73 /6 ib
	mm, mm/m64	0F F3 /r
	xmm, xmm/m128	66 0F F3 /r
psllw	mm, imm8	0F 71 /6 ib	Schieben von 16-Bit-Elementen nach links`for every 16 bit element: dst[i] = dst[i] << count (count = src or imm8)`SSE und MMX Ganzzahlen
	xmm, imm8	66 0F 71 /6 ib
	mm, mm/m64	0F F1 /r
	xmm, xmm/m128	66 0F F1 /r
psrad	mm, imm8	0F 72 /4 ib	Schieben von 32-Bit-Elementen nach rechts (arithmetisch)`for every 32 bit element: dst[i] = dst[i] >>s count (count = src or imm8)`SSE und MMX Ganzzahlen
	xmm, imm8	66 0F 72 /4 ib
	mm, mm/m64	0F E2 /r
	xmm, xmm/m128	66 0F E2 /r
psraw	mm, imm8	0F 71 /4 ib	Schieben von 16-Bit-Elementen nach rechts (arithmetisch)`for every 16 bit element: dst[i] = dst[i] >>s count (count = src or imm8)`SSE und MMX Ganzzahlen
	xmm, imm8	66 0F 71 /4 ib
	mm, mm/m64	0F E1 /r
	xmm, xmm/m128	66 0F E1 /r
psrld	mm, imm8	0F 72 /2 ib	Schieben von 32-Bit-Elementen nach rechts (logisch)`for every 32 bit element: dst[i] = dst[i] >> count (count = src or imm8)`SSE und MMX Ganzzahlen
	xmm, imm8	66 0F 72 /2 ib
	mm, mm/m64	0F D2 /r
	xmm, xmm/m128	66 0F D2 /r
psrldq	xmm, imm8	66 0F 73 /3 ib	Schieben des ganzen Registers um Bytes nach rechts`dst = dst >> (imm8 * 8 bits) (the whole register, zeros come in)`SSE und MMX Ganzzahlen
psrlq	mm, imm8	0F 73 /2 ib	Schieben von 64-Bit-Elementen nach rechts (logisch)`for every 64 bit element: dst[i] = dst[i] >> count (count = src or imm8)`SSE und MMX Ganzzahlen
	xmm, imm8	66 0F 73 /2 ib
	mm, mm/m64	0F D3 /r
	xmm, xmm/m128	66 0F D3 /r
psrlw	mm, imm8	0F 71 /2 ib	Schieben von 16-Bit-Elementen nach rechts (logisch)`for every 16 bit element: dst[i] = dst[i] >> count (count = src or imm8)`SSE und MMX Ganzzahlen
	xmm, imm8	66 0F 71 /2 ib
	mm, mm/m64	0F D1 /r
	xmm, xmm/m128	66 0F D1 /r
psubb	mm, mm/m64	0F F8 /r	Subtraktion von Bytes`for every 8 bit element: dst[i] = dst[i] - src[i]`SSE und MMX Ganzzahlen
psubb	xmm, xmm/m128	66 0F F8 /r
psubd	mm, mm/m64	0F FA /r	Subtraktion von 32-Bit-Elementen`for every 32 bit element: dst[i] = dst[i] - src[i]`SSE und MMX Ganzzahlen
psubd	xmm, xmm/m128	66 0F FA /r
psubq	mm, mm/m64	0F FB /r	Subtraktion von 64-Bit-Elementen`for every 64 bit element: dst[i] = dst[i] - src[i]`SSE und MMX Ganzzahlen
psubq	xmm, xmm/m128	66 0F FB /r
psubsb	mm, mm/m64	0F E8 /r	Subtraktion von Bytes (mit Vorzeichen, gesättigt)`for every 8 bit element: dst[i] = sat_s(dst[i] - src[i])`SSE und MMX Ganzzahlen
psubsb	xmm, xmm/m128	66 0F E8 /r
psubsw	mm, mm/m64	0F E9 /r	Subtraktion von 16-Bit-Elementen (mit Vorzeichen, gesättigt)`for every 16 bit element: dst[i] = sat_s(dst[i] - src[i])`SSE und MMX Ganzzahlen
psubsw	xmm, xmm/m128	66 0F E9 /r
psubusb	mm, mm/m64	0F D8 /r	Subtraktion von Bytes (ohne Vorzeichen, gesättigt)`for every 8 bit element: dst[i] = sat_u(dst[i] - src[i])`SSE und MMX Ganzzahlen
psubusb	xmm, xmm/m128	66 0F D8 /r
psubusw	mm, mm/m64	0F D9 /r	Subtraktion von 16-Bit-Elementen (ohne Vorzeichen, gesättigt)`for every 16 bit element: dst[i] = sat_u(dst[i] - src[i])`SSE und MMX Ganzzahlen
psubusw	xmm, xmm/m128	66 0F D9 /r
psubw	mm, mm/m64	0F F9 /r	Subtraktion von 16-Bit-Elementen`for every 16 bit element: dst[i] = dst[i] - src[i]`SSE und MMX Ganzzahlen
psubw	xmm, xmm/m128	66 0F F9 /r
ptest	xmm, xmm/m128	66 0F 38 17 /r	Bit-Test (setzt ZF und CF)`ZF = ((dst & src) == 0); CF = ((~dst & src) == 0); OF SF AF PF = 0`Flags: OF SF ZF AF CF PFSSE und MMX Ganzzahlen
punpckhbw	mm, mm/m64	0F 68 /r	Verschränken der oberen Bytes zweier Register`dst = (dst[0], src[0], dst[1], src[1], ...) of the high half of the elements`SSE und MMX Ganzzahlen
punpckhbw	xmm, xmm/m128	66 0F 68 /r
punpckhdq	mm, mm/m64	0F 6A /r	Verschränken der oberen 32-Bit-Elemente zweier Register`dst = (dst[0], src[0], dst[1], src[1], ...) of the high half of the elements`SSE und MMX Ganzzahlen
punpckhdq	xmm, xmm/m128	66 0F 6A /r
punpckhqdq	xmm, xmm/m128	66 0F 6D /r	Verschränken der oberen 64-Bit-Elemente zweier Register`dst = (dst[0], src[0], dst[1], src[1], ...) of the high half of the elements`SSE und MMX Ganzzahlen
punpckhwd	mm, mm/m64	0F 69 /r	Verschränken der oberen 16-Bit-Elemente zweier Register`dst = (dst[0], src[0], dst[1], src[1], ...) of the high half of the elements`SSE und MMX Ganzzahlen
punpckhwd	xmm, xmm/m128	66 0F 69 /r
punpcklbw	mm, mm/m64	0F 60 /r	Verschränken der unteren Bytes zweier Register`dst = (dst[0], src[0], dst[1], src[1], ...) of the low half of the elements`SSE und MMX Ganzzahlen
punpcklbw	xmm, xmm/m128	66 0F 60 /r
punpckldq	mm, mm/m64	0F 62 /r	Verschränken der unteren 32-Bit-Elemente zweier Register`dst = (dst[0], src[0], dst[1], src[1], ...) of the low half of the elements`SSE und MMX Ganzzahlen
punpckldq	xmm, xmm/m128	66 0F 62 /r
punpcklqdq	xmm, xmm/m128	66 0F 6C /r	Verschränken der unteren 64-Bit-Elemente zweier Register`dst = (dst[0], src[0], dst[1], src[1], ...) of the low half of the elements`SSE und MMX Ganzzahlen
punpcklwd	mm, mm/m64	0F 61 /r	Verschränken der unteren 16-Bit-Elemente zweier Register`dst = (dst[0], src[0], dst[1], src[1], ...) of the low half of the elements`SSE und MMX Ganzzahlen
punpcklwd	xmm, xmm/m128	66 0F 61 /r
push	r64	50+rq	Ablegen eines Wertes auf dem Stack`rsp = rsp - 8; [rsp] = src (16 bit: 2 bytes)`Stack
	r16	66 50+rw
	imm32	68 id
	imm16	66 68 iw
	imm8	6A ib
	r/m64	FF /6
	r/m16	66 FF /6
	fs	0F A0
	gs	0F A8
pushfq		9C	Ablegen des Flag-Registers auf dem Stack`push(flags)`Stack
pushfw		66 9C	Ablegen des Flag-Registers auf dem Stack`push(flags)`Stack
pxor	mm, mm/m64	0F EF /r	Bitweise exklusive ODER-Verknüpfung (pxor x, x löscht)`dst = dst ^ src`SSE und MMX Ganzzahlen
pxor	xmm, xmm/m128	66 0F EF /r
rcl	r/m8, imm8	C0 /2 ib	Rotation nach links durch das Carry-Flag`rotate_left(CF:dst, count) as one value of width + 1 bits`Flags: OF CFSchieben und Rotieren
	r/m32, imm8	C1 /2 ib
	r/m16, imm8	66 C1 /2 ib
	r/m64, imm8	REX.W C1 /2 ib
	r/m8, 1	D0 /2
	r/m32, 1	D1 /2
	r/m16, 1	66 D1 /2
	r/m64, 1	REX.W D1 /2
	r/m8, cl	D2 /2
	r/m32, cl	D3 /2
	r/m16, cl	66 D3 /2
	r/m64, cl	REX.W D3 /2
rcpps	xmm, xmm/m128	0F 53 /r	Kehrwert (angenähert) von 4 Singles`for every element: dst[i] = 1 / src[i] (approximate)`SSE Gleitkomma
rcpss	xmm, xmm/m32	F3 0F 53 /r	Kehrwert (angenähert) von einem Single`dst[0] = 1 / src[0] (approximate); the other elements stay`SSE Gleitkomma
rcr	r/m8, imm8	C0 /3 ib	Rotation nach rechts durch das Carry-Flag`rotate_right(CF:dst, count) as one value of width + 1 bits`Flags: OF CFSchieben und Rotieren
	r/m32, imm8	C1 /3 ib
	r/m16, imm8	66 C1 /3 ib
	r/m64, imm8	REX.W C1 /3 ib
	r/m8, 1	D0 /3
	r/m32, 1	D1 /3
	r/m16, 1	66 D1 /3
	r/m64, 1	REX.W D1 /3
	r/m8, cl	D2 /3
	r/m32, cl	D3 /3
	r/m16, cl	66 D3 /3
	r/m64, cl	REX.W D3 /3
rdfsbase	r32	F3 0F AE /0	Lesen der Basisadresse von fs/gs`dst = base address of fs`System und Privilegien
rdfsbase	r64	F3 REX.W 0F AE /0
rdgsbase	r32	F3 0F AE /1	Lesen der Basisadresse von fs/gs`dst = base address of gs`System und Privilegien
rdgsbase	r64	F3 REX.W 0F AE /1
rdmsr		0F 32	Lesen eines modellspezifischen Registers (privilegiert)`edx:eax = model-specific register number ecx (privileged)`System und Privilegien
rdpid	r64	F3 0F C7 /7	Lesen der Prozessor-Kennung`dst = id of the processor`System und Privilegien
rdpmc		0F 33	Lesen eines Leistungszählers`edx:eax = performance counter number ecx`System und Privilegien
rdrand	r32	0F C7 /6	Lesen einer Zufallszahl des Prozessors`dst = random number from the processor; CF = 1 if it is valid`Flags: OF SF ZF AF CF PFSystem und Privilegien
	r16	66 0F C7 /6
	r64	REX.W 0F C7 /6
rdseed	r32	0F C7 /7	Lesen eines Startwertes für Zufallsgeneratoren`dst = seed value for random number generators; CF = 1 if it is valid`Flags: OF SF ZF AF CF PFSystem und Privilegien
	r16	66 0F C7 /7
	r64	REX.W 0F C7 /7
rdsspd	r32	F3 0F 1E /1	Lesen des Schatten-Stackzeigers`dst = shadow stack pointer`System und Privilegien
rdsspq	r64	F3 REX.W 0F 1E /1	Lesen des Schatten-Stackzeigers`dst = shadow stack pointer`System und Privilegien
rdtsc		0F 31	Lesen des Zeitstempelzählers (Taktzyklen)`edx:eax = time stamp counter`System und Privilegien
rdtscp		0F 01 F9	Lesen des Zeitstempelzählers und der Prozessor-Kennung`edx:eax = time stamp counter; ecx = processor id`System und Privilegien
ret	imm16	C2 iw	Rückkehr aus der Funktion (die Adresse kommt vom Stack)`rip = pop(); with imm16: rsp = rsp + imm16 afterwards`Sprünge, Aufrufe und Interrupts
ret		C3
retf	imm16	CA iw	Rückkehr aus einer Far-Funktion`rip = pop(); cs = pop()`Sprünge, Aufrufe und Interrupts
retf		CB
rol	r/m8, imm8	C0 /0 ib	Rotation nach links`dst = rotate_left(dst, count); CF = lowest bit of the result`Flags: OF CFSchieben und Rotieren
	r/m32, imm8	C1 /0 ib
	r/m16, imm8	66 C1 /0 ib
	r/m64, imm8	REX.W C1 /0 ib
	r/m8, 1	D0 /0
	r/m32, 1	D1 /0
	r/m16, 1	66 D1 /0
	r/m64, 1	REX.W D1 /0
	r/m8, cl	D2 /0
	r/m32, cl	D3 /0
	r/m16, cl	66 D3 /0
	r/m64, cl	REX.W D3 /0
ror	r/m8, imm8	C0 /1 ib	Rotation nach rechts`dst = rotate_right(dst, count); CF = highest bit of the result`Flags: OF CFSchieben und Rotieren
	r/m32, imm8	C1 /1 ib
	r/m16, imm8	66 C1 /1 ib
	r/m64, imm8	REX.W C1 /1 ib
	r/m8, 1	D0 /1
	r/m32, 1	D1 /1
	r/m16, 1	66 D1 /1
	r/m64, 1	REX.W D1 /1
	r/m8, cl	D2 /1
	r/m32, cl	D3 /1
	r/m16, cl	66 D3 /1
	r/m64, cl	REX.W D3 /1
roundpd	xmm, xmm/m128, imm8	66 0F 3A 09 /r ib	Runden von 2 Doubles auf ganze Zahlen`dst[i] = round(src[i]) with the rounding mode of imm8`SSE Gleitkomma
roundps	xmm, xmm/m128, imm8	66 0F 3A 08 /r ib	Runden von 4 Singles auf ganze Zahlen`dst[i] = round(src[i]) with the rounding mode of imm8`SSE Gleitkomma
roundsd	xmm, xmm/m64, imm8	66 0F 3A 0B /r ib	Runden eines Doubles auf eine ganze Zahl`dst[i] = round(src[i]) with the rounding mode of imm8`SSE Gleitkomma
roundss	xmm, xmm/m32, imm8	66 0F 3A 0A /r ib	Runden eines Singles auf eine ganze Zahl`dst[i] = round(src[i]) with the rounding mode of imm8`SSE Gleitkomma
rsm		0F AA	Verlassen des Systemverwaltungsmodus (SMM)`leave system management mode, restore the saved state`Flags: allSystem und Privilegien
rsqrtps	xmm, xmm/m128	0F 52 /r	Kehrwert der Wurzel (angenähert) von 4 Singles`for every element: dst[i] = 1 / sqrt(src[i]) (approximate)`SSE Gleitkomma
rsqrtss	xmm, xmm/m32	F3 0F 52 /r	Kehrwert der Wurzel (angenähert) von einem Single`dst[0] = 1 / sqrt(src[0]) (approximate); the other elements stay`SSE Gleitkomma
sahf		9E	Speichern von ah in die Flags`SF ZF AF PF CF = bits of ah`Flags: SF ZF AF CF PFFlags
sar	r/m8, imm8	C0 /7 ib	Schieben nach rechts mit Vorzeichen (Vorzeichenbit bleibt)`dst = dst >>s count (sign bit comes in); CF = last bit shifted out`Flags: OF SF ZF CF PF · undefiniert: AFSchieben und Rotieren
	r/m32, imm8	C1 /7 ib
	r/m16, imm8	66 C1 /7 ib
	r/m64, imm8	REX.W C1 /7 ib
	r/m8, 1	D0 /7
	r/m32, 1	D1 /7
	r/m16, 1	66 D1 /7
	r/m64, 1	REX.W D1 /7
	r/m8, cl	D2 /7
	r/m32, cl	D3 /7
	r/m16, cl	66 D3 /7
	r/m64, cl	REX.W D3 /7
sbb	r/m8, r8	18 /r	Subtraktion mit Borgen (CF)`dst = dst - src - CF`Flags: OF SF ZF AF CF PFArithmetik
	r/m32, r32	19 /r
	r/m16, r16	66 19 /r
	r/m64, r64	REX.W 19 /r
	r8, r/m8	1A /r
	r32, r/m32	1B /r
	r16, r/m16	66 1B /r
	r64, r/m64	REX.W 1B /r
	al, imm8	1C ib
	eax, imm32	1D id
	ax, imm16	66 1D iw
	rax, imm32	REX.W 1D id
	r/m8, imm8	80 /3 ib
	r/m32, imm32	81 /3 id
	r/m16, imm16	66 81 /3 iw
	r/m64, imm32	REX.W 81 /3 id
	r/m32, imm8	83 /3 ib
	r/m16, imm8	66 83 /3 ib
	r/m64, imm8	REX.W 83 /3 ib
scasb		AE	Vergleich von al/ax/eax/rax mit [rdi], rdi läuft weiter`flags = acc - [rdi]; rdi = +/- size; with repe / repne: repeat, at most rcx times`Flags: OF SF ZF AF CF PFZeichenketten
scasd		AF	Vergleich von al/ax/eax/rax mit [rdi], rdi läuft weiter`flags = acc - [rdi]; rdi = +/- size; with repe / repne: repeat, at most rcx times`Flags: OF SF ZF AF CF PFZeichenketten
scasq		REX.W AF	Vergleich von al/ax/eax/rax mit [rdi], rdi läuft weiter`flags = acc - [rdi]; rdi = +/- size; with repe / repne: repeat, at most rcx times`Flags: OF SF ZF AF CF PFZeichenketten
scasw		66 AF	Vergleich von al/ax/eax/rax mit [rdi], rdi läuft weiter`flags = acc - [rdi]; rdi = +/- size; with repe / repne: repeat, at most rcx times`Flags: OF SF ZF AF CF PFZeichenketten
seta	r/m8	0F 97 /r	Setzen des Bytes auf 1, wenn ohne Vorzeichen größer (CF=0 und ZF=0), sonst auf 0`dst = (CF = 0 and ZF = 0) ? 1 : 0`Daten kopieren
setbe	r/m8	0F 96 /r	Setzen des Bytes auf 1, wenn ohne Vorzeichen kleiner oder gleich (CF=1 oder ZF=1), sonst auf 0`dst = (CF = 1 or ZF = 1) ? 1 : 0`Daten kopieren
setc	r/m8	0F 92 /r	Setzen des Bytes auf 1, wenn Übertrag, ohne Vorzeichen kleiner (CF=1), sonst auf 0`dst = (CF = 1) ? 1 : 0`Daten kopieren
setg	r/m8	0F 9F /r	Setzen des Bytes auf 1, wenn mit Vorzeichen größer (ZF=0 und SF=OF), sonst auf 0`dst = (ZF = 0 and SF = OF) ? 1 : 0`Daten kopieren
setge	r/m8	0F 9D /r	Setzen des Bytes auf 1, wenn mit Vorzeichen größer oder gleich (SF=OF), sonst auf 0`dst = (SF = OF) ? 1 : 0`Daten kopieren
setl	r/m8	0F 9C /r	Setzen des Bytes auf 1, wenn mit Vorzeichen kleiner (SF≠OF), sonst auf 0`dst = (SF != OF) ? 1 : 0`Daten kopieren
setle	r/m8	0F 9E /r	Setzen des Bytes auf 1, wenn mit Vorzeichen kleiner oder gleich (ZF=1 oder SF≠OF), sonst auf 0`dst = (ZF = 1 or SF != OF) ? 1 : 0`Daten kopieren
setnc	r/m8	0F 93 /r	Setzen des Bytes auf 1, wenn kein Übertrag, ohne Vorzeichen größer oder gleich (CF=0), sonst auf 0`dst = (CF = 0) ? 1 : 0`Daten kopieren
setno	r/m8	0F 91 /r	Setzen des Bytes auf 1, wenn kein Überlauf (OF=0), sonst auf 0`dst = (OF = 0) ? 1 : 0`Daten kopieren
setnp	r/m8	0F 9B /r	Setzen des Bytes auf 1, wenn Parität ungerade (PF=0), sonst auf 0`dst = (PF = 0) ? 1 : 0`Daten kopieren
setns	r/m8	0F 99 /r	Setzen des Bytes auf 1, wenn nicht negativ (SF=0), sonst auf 0`dst = (SF = 0) ? 1 : 0`Daten kopieren
setnz	r/m8	0F 95 /r	Setzen des Bytes auf 1, wenn ungleich, Ergebnis nicht null (ZF=0), sonst auf 0`dst = (ZF = 0) ? 1 : 0`Daten kopieren
seto	r/m8	0F 90 /r	Setzen des Bytes auf 1, wenn Überlauf (OF=1), sonst auf 0`dst = (OF = 1) ? 1 : 0`Daten kopieren
setp	r/m8	0F 9A /r	Setzen des Bytes auf 1, wenn Parität gerade (PF=1), sonst auf 0`dst = (PF = 1) ? 1 : 0`Daten kopieren
sets	r/m8	0F 98 /r	Setzen des Bytes auf 1, wenn negativ (SF=1), sonst auf 0`dst = (SF = 1) ? 1 : 0`Daten kopieren
setz	r/m8	0F 94 /r	Setzen des Bytes auf 1, wenn gleich, Ergebnis null (ZF=1), sonst auf 0`dst = (ZF = 1) ? 1 : 0`Daten kopieren
sfence		0F AE /7	Schranke für Schreibzugriffe`all earlier stores are done before later stores`Schranken und Sonstiges
sgdt	m	0F 01 /0	Speichern des Registers der globalen Deskriptortabelle`[m] = GDTR`System und Privilegien
shl	r/m8, imm8	C0 /4 ib	Schieben nach links (Faktor 2 je Stelle), Auffüllen mit 0`dst = dst << count (count masked to 5 / 6 bits); CF = last bit shifted out`Flags: OF SF ZF CF PF · undefiniert: AFSchieben und Rotieren
	r/m8, imm8	C0 /6 ib
	r/m32, imm8	C1 /4 ib
	r/m32, imm8	C1 /6 ib
	r/m16, imm8	66 C1 /4 ib
	r/m16, imm8	66 C1 /6 ib
	r/m64, imm8	REX.W C1 /4 ib
	r/m64, imm8	REX.W C1 /6 ib
	r/m8, 1	D0 /4
	r/m8, 1	D0 /6
	r/m32, 1	D1 /4
	r/m32, 1	D1 /6
	r/m16, 1	66 D1 /4
	r/m16, 1	66 D1 /6
	r/m64, 1	REX.W D1 /4
	r/m64, 1	REX.W D1 /6
	r/m8, cl	D2 /4
	r/m8, cl	D2 /6
	r/m32, cl	D3 /4
	r/m32, cl	D3 /6
	r/m16, cl	66 D3 /4
	r/m16, cl	66 D3 /6
	r/m64, cl	REX.W D3 /4
	r/m64, cl	REX.W D3 /6
shld	r/m32, r32, imm8	0F A4 /r ib	Schieben nach links mit Auffüllen aus einem zweiten Register`dst = (dst << count) OR (src >> (width - count))`Flags: OF SF ZF CF PF · undefiniert: AFSchieben und Rotieren
	r/m16, r16, imm8	66 0F A4 /r ib
	r/m64, r64, imm8	REX.W 0F A4 /r ib
	r/m32, r32, cl	0F A5 /r
	r/m16, r16, cl	66 0F A5 /r
	r/m64, r64, cl	REX.W 0F A5 /r
shr	r/m8, imm8	C0 /5 ib	Schieben nach rechts ohne Vorzeichen, Auffüllen mit 0`dst = dst >> count (zeros come in); CF = last bit shifted out`Flags: OF SF ZF CF PF · undefiniert: AFSchieben und Rotieren
	r/m32, imm8	C1 /5 ib
	r/m16, imm8	66 C1 /5 ib
	r/m64, imm8	REX.W C1 /5 ib
	r/m8, 1	D0 /5
	r/m32, 1	D1 /5
	r/m16, 1	66 D1 /5
	r/m64, 1	REX.W D1 /5
	r/m8, cl	D2 /5
	r/m32, cl	D3 /5
	r/m16, cl	66 D3 /5
	r/m64, cl	REX.W D3 /5
shrd	r/m32, r32, imm8	0F AC /r ib	Schieben nach rechts mit Auffüllen aus einem zweiten Register`dst = (dst >> count) OR (src << (width - count))`Flags: OF SF ZF CF PF · undefiniert: AFSchieben und Rotieren
	r/m16, r16, imm8	66 0F AC /r ib
	r/m64, r64, imm8	REX.W 0F AC /r ib
	r/m32, r32, cl	0F AD /r
	r/m16, r16, cl	66 0F AD /r
	r/m64, r64, cl	REX.W 0F AD /r
shufpd	xmm, xmm/m128, imm8	66 0F C6 /r ib	Mischen von Doubles aus zwei Registern nach einer Vorgabe`dst = (dst[sel0], src[sel1]); sel = bits of imm8`SSE Gleitkomma
shufps	xmm, xmm/m128, imm8	0F C6 /r ib	Mischen von Singles aus zwei Registern nach einer Vorgabe`dst = (dst[sel0], dst[sel1], src[sel2], src[sel3]); sel = bit pairs of imm8`SSE Gleitkomma
sidt	m	0F 01 /1	Speichern des Registers der Interrupt-Deskriptortabelle`[m] = IDTR`System und Privilegien
sldt	r32/m16	0F 00 /0	Speichern des Registers der lokalen Deskriptortabelle`dst = LDTR`System und Privilegien
	r16	66 0F 00 /0
	r64	REX.W 0F 00 /0
smsw	m	0F 01 /4	Speichern des Maschinen-Statuswortes`dst = CR0 bits 0 to 15`System und Privilegien
sqrtpd	xmm, xmm/m128	66 0F 51 /r	Quadratwurzel von 2 Doubles`for every element: dst[i] = sqrt(src[i])`SSE Gleitkomma
sqrtps	xmm, xmm/m128	0F 51 /r	Quadratwurzel von 4 Singles`for every element: dst[i] = sqrt(src[i])`SSE Gleitkomma
sqrtsd	xmm, xmm/m64	F2 0F 51 /r	Quadratwurzel von einem Double`dst[0] = sqrt(src[0]); the other elements stay`SSE Gleitkomma
sqrtss	xmm, xmm/m32	F3 0F 51 /r	Quadratwurzel von einem Single`dst[0] = sqrt(src[0]); the other elements stay`SSE Gleitkomma
stac		0F 01 CB	Setzen des AC-Flags (Zugriffsschutz)`EFLAGS.AC = 1`Flags: ACFlags
stc		F9	Setzen des Carry-Flags`CF = 1`Flags: CFFlags
std		FD	Setzen des Richtungs-Flags (String-Befehle zählen abwärts)`DF = 1`Flags: DFFlags
sti		FB	Erlauben der Interrupts (IF=1)`IF = 1 (effective after the next instruction)`Flags: IFFlags
stmxcsr	m	0F AE /3	Speichern des SSE-Steuer- und Statusregisters`[m32] = MXCSR`SSE und MMX Datenbewegung
stosb		AA	Speichern von al/ax/eax/rax nach [rdi], rdi läuft weiter`[rdi] = acc; rdi = rdi +/- size (acc is al, ax, eax or rax)`Zeichenketten
stosd		AB	Speichern von al/ax/eax/rax nach [rdi], rdi läuft weiter`[rdi] = acc; rdi = rdi +/- size (acc is al, ax, eax or rax)`Zeichenketten
stosq		REX.W AB	Speichern von al/ax/eax/rax nach [rdi], rdi läuft weiter`[rdi] = acc; rdi = rdi +/- size (acc is al, ax, eax or rax)`Zeichenketten
stosw		66 AB	Speichern von al/ax/eax/rax nach [rdi], rdi läuft weiter`[rdi] = acc; rdi = rdi +/- size (acc is al, ax, eax or rax)`Zeichenketten
str	r32/m16	0F 00 /1	Speichern des Task-Registers`dst = task register`System und Privilegien
	r16	66 0F 00 /1
	r64	REX.W 0F 00 /1
sub	r/m8, r8	28 /r	Subtraktion der Quelle vom Ziel`dst = dst - src`Flags: OF SF ZF AF CF PFArithmetik
	r/m32, r32	29 /r
	r/m16, r16	66 29 /r
	r/m64, r64	REX.W 29 /r
	r8, r/m8	2A /r
	r32, r/m32	2B /r
	r16, r/m16	66 2B /r
	r64, r/m64	REX.W 2B /r
	al, imm8	2C ib
	eax, imm32	2D id
	ax, imm16	66 2D iw
	rax, imm32	REX.W 2D id
	r/m8, imm8	80 /5 ib
	r/m32, imm32	81 /5 id
	r/m16, imm16	66 81 /5 iw
	r/m64, imm32	REX.W 81 /5 id
	r/m32, imm8	83 /5 ib
	r/m16, imm8	66 83 /5 ib
	r/m64, imm8	REX.W 83 /5 ib
subpd	xmm, xmm/m128	66 0F 5C /r	Subtraktion von 2 Doubles`for every element: dst[i] = dst[i] - src[i] (double)`SSE Gleitkomma
subps	xmm, xmm/m128	0F 5C /r	Subtraktion von 4 Singles`for every element: dst[i] = dst[i] - src[i] (single)`SSE Gleitkomma
subsd	xmm, xmm/m64	F2 0F 5C /r	Subtraktion von einem Double`dst[0] = dst[0] - src[0] (double); the other elements stay`SSE Gleitkomma
subss	xmm, xmm/m32	F3 0F 5C /r	Subtraktion von einem Single`dst[0] = dst[0] - src[0] (single); the other elements stay`SSE Gleitkomma
swapgs		0F 01 F8	Tausch der gs-Basis mit dem Kernel-Wert`swap(gs base, kernel gs base) (privileged)`System und Privilegien
syscall		0F 05	Aufruf des Betriebssystems (64 Bit, schnell)`rcx = rip of the next instruction; r11 = flags; rip = LSTAR; flags = flags & ~SFMASK; ring 0`Flags: RFSprünge, Aufrufe und Interrupts
sysenter		0F 34	Aufruf des Betriebssystems (32 Bit, schnell)`enter ring 0 at the address in IA32_SYSENTER_EIP`Flags: IF VMSprünge, Aufrufe und Interrupts
sysexit		0F 35	Rückkehr aus einem Systemaufruf (32 Bit, schnell)`back to ring 3: rip = rdx, rsp = rcx`Sprünge, Aufrufe und Interrupts
sysretd		0F 07	Rückkehr aus einem Systemaufruf (schnell)`rip = rcx; flags = r11; back to ring 3`Sprünge, Aufrufe und Interrupts
sysretq		REX.W 0F 07	Rückkehr aus einem Systemaufruf (schnell)`rip = rcx; flags = r11; back to ring 3`Sprünge, Aufrufe und Interrupts
test	r/m8, r8	84 /r	Bitweiser Test (UND), nur die Flags ändern sich`flags = dst & src (the result is thrown away); CF = OF = 0`Flags: OF SF ZF CF PF · undefiniert: AFVergleichen und Tauschen
	r/m32, r32	85 /r
	r/m16, r16	66 85 /r
	r/m64, r64	REX.W 85 /r
	al, imm8	A8 ib
	eax, imm32	A9 id
	ax, imm16	66 A9 iw
	rax, imm32	REX.W A9 id
	r/m8, imm8	F6 /0 ib
	r/m8, imm8	F6 /1 ib
	r/m32, imm32	F7 /0 id
	r/m32, imm32	F7 /1 id
	r/m16, imm16	66 F7 /0 iw
	r/m16, imm16	66 F7 /1 iw
	r/m64, imm32	REX.W F7 /0 id
	r/m64, imm32	REX.W F7 /1 id
tzcnt	r32, r/m32	F3 0F BC /r	Zählen der Nullbits am unteren Ende`dst = number of trailing 0 bits of src (width if src = 0)`Flags: ZF CFArithmetik
tzcnt	r64, r/m64	F3 REX.W 0F BC /r
ucomisd	xmm, xmm/m64	66 0F 2E /r	Wie comisd, ohne Ausnahme bei stillen NaN`ZF PF CF = compare(dst, src): greater 0 0 0, less 0 0 1, equal 1 0 0, unordered 1 1 1; OF SF AF = 0`Flags: OF SF ZF AF CF PFSSE Gleitkomma
ucomiss	xmm, xmm/m32	0F 2E /r	Wie comiss, ohne Ausnahme bei stillen NaN`ZF PF CF = compare(dst, src): greater 0 0 0, less 0 0 1, equal 1 0 0, unordered 1 1 1; OF SF AF = 0`Flags: OF SF ZF AF CF PFSSE Gleitkomma
ud2		0F 0B	Absichtlich ungültiger Befehl (löst eine Ausnahme aus)`raises #UD (invalid instruction)`Sprünge, Aufrufe und Interrupts
unpckhpd	xmm, xmm/m128	66 0F 15 /r	Verschränken der oberen Doubles zweier Register`dst = (dst[1], src[1])`SSE Gleitkomma
unpckhps	xmm, xmm/m128	0F 15 /r	Verschränken der oberen Singles zweier Register`dst = (dst[2], src[2], dst[3], src[3])`SSE Gleitkomma
unpcklpd	xmm, xmm/m128	66 0F 14 /r	Verschränken der unteren Doubles zweier Register`dst = (dst[0], src[0])`SSE Gleitkomma
unpcklps	xmm, xmm/m128	0F 14 /r	Verschränken der unteren Singles zweier Register`dst = (dst[0], src[0], dst[1], src[1])`SSE Gleitkomma
verr	r/m16	0F 00 /4	Prüfung eines Segments auf Lesbarkeit`ZF = 1 if the segment src can be read`Flags: ZFSystem und Privilegien
verw	r/m16	0F 00 /5	Prüfung eines Segments auf Schreibbarkeit`ZF = 1 if the segment src can be written`Flags: ZFSystem und Privilegien
wbinvd		0F 09	Zurückschreiben und Leeren der Caches (privilegiert)`write back and empty the caches (privileged)`System und Privilegien
wrfsbase	r32	F3 0F AE /2	Schreiben der Basisadresse von fs/gs`base address of fs = src`System und Privilegien
wrfsbase	r64	F3 REX.W 0F AE /2
wrgsbase	r32	F3 0F AE /3	Schreiben der Basisadresse von fs/gs`base address of gs = src`System und Privilegien
wrgsbase	r64	F3 REX.W 0F AE /3
wrmsr		0F 30	Schreiben eines modellspezifischen Registers (privilegiert)`model-specific register number ecx = edx:eax (privileged)`System und Privilegien
xadd	r/m8, r8	0F C0 /r	Tauschen und Addieren (atomar mit lock)`tmp = dst + src; src = dst; dst = tmp`Flags: OF SF ZF AF CF PFVergleichen und Tauschen
	r/m32, r32	0F C1 /r
	r/m16, r16	66 0F C1 /r
	r/m64, r64	REX.W 0F C1 /r
xchg	r/m8, r8	86 /r	Vertauschen der beiden Operanden (mit Speicher: atomar)`tmp = dst; dst = src; src = tmp`Daten kopieren
	r/m32, r32	87 /r
	r/m16, r16	66 87 /r
	r/m64, r64	REX.W 87 /r
	r32, eax	90+rd
	r16, ax	66 90+rw
	r64, rax	REX.W 90+rq
xgetbv		0F 01 D0	Lesen eines erweiterten Steuerregisters (XCR)`edx:eax = extended control register number ecx`System und Privilegien
xlatb		D7	Laden von al aus der Tabelle bei [rbx + al]`al = [rbx + zext(al)]`Daten kopieren
xor	r/m8, r8	30 /r	Bitweise exklusive ODER-Verknüpfung (xor eax, eax setzt auf 0)`dst = dst ^ src; CF = OF = 0`Flags: OF SF ZF CF PF · undefiniert: AFLogik und Bits
	r/m32, r32	31 /r
	r/m16, r16	66 31 /r
	r/m64, r64	REX.W 31 /r
	r8, r/m8	32 /r
	r32, r/m32	33 /r
	r16, r/m16	66 33 /r
	r64, r/m64	REX.W 33 /r
	al, imm8	34 ib
	eax, imm32	35 id
	ax, imm16	66 35 iw
	rax, imm32	REX.W 35 id
	r/m8, imm8	80 /6 ib
	r/m32, imm32	81 /6 id
	r/m16, imm16	66 81 /6 iw
	r/m64, imm32	REX.W 81 /6 id
	r/m32, imm8	83 /6 ib
	r/m16, imm8	66 83 /6 ib
	r/m64, imm8	REX.W 83 /6 ib
xorpd	xmm, xmm/m128	66 0F 57 /r	Bitweise exklusive ODER-Verknüpfung (xorps x, x löscht)`dst = dst ^ src`SSE Gleitkomma
xorps	xmm, xmm/m128	0F 57 /r	Bitweise exklusive ODER-Verknüpfung (xorps x, x löscht)`dst = dst ^ src`SSE Gleitkomma
xrstor	m	0F AE /5	Wiederherstellen des erweiterten Prozessorzustands`the state components selected by edx:eax = [m]`System und Privilegien
xrstor64	m	REX.W 0F AE /5	Wiederherstellen des erweiterten Prozessorzustands`the state components selected by edx:eax = [m]`System und Privilegien
xsave	m	0F AE /4	Sichern des erweiterten Prozessorzustands (SSE, AVX ...)`[m] = the state components selected by edx:eax`System und Privilegien
xsave64	m	REX.W 0F AE /4	Sichern des erweiterten Prozessorzustands (SSE, AVX ...)`[m] = the state components selected by edx:eax`System und Privilegien
xsavec	m	0F C7 /4	Sichern des erweiterten Prozessorzustands (SSE, AVX ...)`[m] = the state components selected by edx:eax`System und Privilegien
xsavec64	m	REX.W 0F C7 /4	Sichern des erweiterten Prozessorzustands (SSE, AVX ...)`[m] = the state components selected by edx:eax`System und Privilegien
xsaveopt	m	0F AE /6	Sichern des erweiterten Prozessorzustands (SSE, AVX ...)`[m] = the state components selected by edx:eax`System und Privilegien
xsaveopt64	m	REX.W 0F AE /6	Sichern des erweiterten Prozessorzustands (SSE, AVX ...)`[m] = the state components selected by edx:eax`System und Privilegien
xsetbv		0F 01 D1	Schreiben eines erweiterten Steuerregisters (XCR)`extended control register number ecx = edx:eax (privileged)`System und Privilegien