Hilfe zum PBXB64-Compiler

Kern-GPR-Mnemonik

In diesem Abschnitt werden die vom PBXB64-Assembler unterstützten x86-64-General-Purpose-Register-Anweisungen (GPR) dokumentiert. Alle Anweisungen verwenden Intel-Syntax.

Kategorie: Mnemonik-Familienübersichten

Beschreibung

In diesem Abschnitt werden die vom PBXB64-Assembler unterstützten x86-64-General-Purpose-Register-Anweisungen (GPR) dokumentiert. Alle Anweisungen verwenden Intel-Syntax.

Datenbewegung

Gedächtnisstütze	Beschreibung	Operanden
`MOV`	Verschieben Sie Daten zwischen Registern, Speicher und Sofortdaten	reg/mem, reg/mem/imm
`MOVZX`	Bewegen Sie sich ohne Verlängerung	reg, reg/mem
`MOVSX`	Umzug mit Schilderverlängerung	reg, reg/mem
`MOVSXD`	Mit Vorzeichenerweiterung verschieben (32-Bit auf 64-Bit)	reg64, reg/mem32
`CMOVcc`	Bedingter Umzug (siehe unten)	reg, reg/mem
`XCHG`	Daten zwischen Operanden austauschen	reg, reg/mem
`BSWAP`	Byte-Swap (Reverse Endianness)	reg32/64
`MOVBE`	Verschieben mit Big-Endian-Konvertierung (Laden/Speichern)	reg, mem / mem, reg
`MOVABS`	64-Bit-Absolutwert verschieben (Alias auf MOV mit imm64)	reg64, imm64

Bedingte Bewegungen (CMOVcc)

Gedächtnisstütze	Zustand	Flaggen
`CMOVA` / `CMOVNBE`	Oben (nicht unten oder gleich)	CF=0 und ZF=0
`CMOVAE` / `CMOVNB`	Oben oder gleich (nicht unten)	CF=0
`CMOVB` / `CMOVNAE`	Unten (nicht darüber oder gleich)	CF=1
`CMOVBE` / `CMOVNA`	Unterhalb oder gleich (nicht darüber)	CF=1 oder ZF=1
`CMOVE` / `CMOVZ`	Gleich (Null)	ZF=1
`CMOVNE` / `CMOVNZ`	Ungleich (nicht Null)	ZF=0
`CMOVG` / `CMOVNLE`	Größer (mit Vorzeichen, nicht kleiner oder gleich)	ZF=0 und SF=OF
`CMOVGE` / `CMOVNL`	Größer oder gleich (mit Vorzeichen, nicht kleiner)	SF=OF
`CMOVL` / `CMOVNGE`	Kleiner (mit Vorzeichen, nicht größer oder gleich)	SF!=OF
`CMOVLE` / `CMOVNG`	Kleiner oder gleich (mit Vorzeichen, nicht größer)	ZF=1 oder SF!=OF
`CMOVO`	Überlauf	OF=1
`CMOVNO`	Nicht überlaufen	OF=0
`CMOVS`	Vorzeichen (negativ)	SF=1
`CMOVNS`	Nicht signieren (nicht negativ)	SF=0
`CMOVP` / `CMOVPE`	Parität (gerade)	PF=1
`CMOVNP` / `CMOVPO`	Keine Parität (ungerade)	PF=0

Arithmetik

Gedächtnisstütze	Beschreibung	Operanden
`ADD`	Ganzzahlige Addition	reg/mem, reg/mem/imm
`ADC`	Mit Carry hinzufügen	reg/mem, reg/mem/imm
`SUB`	Ganzzahlige Subtraktion	reg/mem, reg/mem/imm
`SBB`	Mit „borgen“ subtrahieren	reg/mem, reg/mem/imm
`MUL`	Vorzeichenlose Multiplikation (r/m * AL/AX/EAX/RAX)	reg/mem
`IMUL`	Vorzeichenbehaftete Multiplikation (mehrere Formen)	reg/mem / reg, reg/mem / reg, reg/mem, imm
`DIV`	Division ohne Vorzeichen (r/m dividiert AX/EAX/RAX)	reg/mem
`IDIV`	Unterzeichnete Kluft	reg/mem
`INC`	Erhöhen Sie um 1	reg/mem
`DEC`	Um 1 verringern	reg/mem
`NEG`	Negieren (Zweierkomplement)	reg/mem
`CMP`	Vergleichen (setzt Flags, kein Ergebnis)	reg/mem, reg/mem/imm
`TEST`	Logischer Vergleich (UND setzt Flags)	reg/mem, reg/mem/imm

DerMULUndDIVAnweisungen verwenden implizite Quell-/Zielregister:

Operandengröße	MUL: r/m *	Ergebnis (Produkt)	DIV: r/m dividiert	Quotient	Rest
8-Bit	AL	AXT	AXT	AL	AH
16-Bit	AXT	DX:AX	DX:AX	AXT	DX
32-Bit	EAX	EDX:EAX	EDX:EAX	EAX	EDX
64-Bit	RAX	RDX:RAX	RDX:RAX	RAX	RDX

DerIMULDie Anweisung hat drei Formen:

Einzelner Operand: imul r/m— gleiches implizites Verhalten wie MUL
Zwei Operanden: imul reg, r/m— reg = reg * r/m
Drei Operanden: imul reg, r/m, imm— reg = r/m * imm

Logisch / Bitweise

Gedächtnisstütze	Beschreibung	Operanden
`AND`	Bitwise AND	reg/mem, reg/mem/imm
`OR`	Bitwise OR	reg/mem, reg/mem/imm
`XOR`	Bitwise XOR	reg/mem, reg/mem/imm
`NOT`	Bitweises NICHT (Einzelkomplement)	reg/mem
`ANDN`	Bitweises UND-NICHT (BMI1)	reg, reg, reg/mem

Verschieben / Drehen

Gedächtnisstütze	Beschreibung	Operanden
`SHL` / `SAL`	Logisch/arithmetisch nach links verschieben	reg/mem, imm8/CL
`SHR`	Logisch nach rechts verschieben	reg/mem, imm8/CL
`SAR`	Arithmetik nach rechts verschieben (vorzeichenerhaltend)	reg/mem, imm8/CL
`ROL`	Nach links drehen	reg/mem, imm8/CL
`ROR`	Nach rechts drehen	reg/mem, imm8/CL
`RCL`	Durch Tragen nach links drehen	reg/mem, imm8/CL
`RCR`	Nach rechts drehen durch Tragen	reg/mem, imm8/CL
`SHLD`	Doppelte Präzisionsverschiebung nach links	reg/mem, reg, imm8/CL
`SHRD`	Doppelte Präzisionsverschiebung nach rechts	reg/mem, reg, imm8/CL

Stapeloperationen

Gedächtnisstütze	Beschreibung	Operanden
`PUSH`	Auf Stapel schieben (RSP um 8 in x64 dekrementiert)	reg/mem/imm
`POP`	Pop vom Stapel (RSP um 8 in x64 erhöht)	reg/mem
`PUSHA` / `PUSHAD`	Alle GPRs pushen (nicht gültig im x64-Modus)	keiner
`POPA` / `POPAD`	Pop alle GPRs (nicht gültig im x64-Modus)	keiner
`PUSHF` / `PUSHFD`	Drücken Sie EFLAGS/RFLAGS	keiner
`POPF` / `POPFD`	Pop EFLAGS/RFLAGS	keiner
`PUSHQ`	Push QWORD (impliziter 64-Bit-Push)	imm32
`ENTER`	Stapelrahmen erstellen (push rbp, mov rbp, rsp; sub rsp, X)	imm16, imm8
`LEAVE`	Stack-Frame zerstören (mov rsp, rbp; pop rbp)	keiner

Notiz:Im x64-ModusPUSHUndPOPArbeiten Sie immer mit 64-Bit-Werten (RSP wird um 8 angepasst). 32-Bit- und 16-Bit-Push/Pop sind in x64 nicht kodierbar.PUSHA/POPAsind nicht verfügbar.

Kontrollübertragung

Bedingungslose Sprünge

Gedächtnisstütze	Beschreibung	Operanden
`JMP`	Bedingungsloser Sprung	Etikett/Reg/Speicher
`CALL`	Aufrufvorgang (Push-Rücksprungadresse)	Etikett/Reg/Speicher
`RET`	Rückkehr vom Verfahren (Pops-Rücksprungadresse)	none / imm16 (Pop N Bytes)
`RETF`	Far Return (wird in x64 nicht verwendet)	keine / imm16

Bedingte Sprünge

Gedächtnisstütze	Zustand	Flaggen
`JA` / `JNBE`	Springe, wenn oben	CF=0 und ZF=0
`JAE` / `JNB` / `JNC`	Springe, wenn höher oder gleich	CF=0
`JB` / `JNAE` / `JC`	Springe, wenn unten	CF=1
`JBE` / `JNA`	Springe, wenn weniger als oder gleich	CF=1 oder ZF=1
`JE` / `JZ`	Bei Gleichheit springen	ZF=1
`JNE` / `JNZ`	Springe, wenn nicht gleich	ZF=0
`JG` / `JNLE`	Springe, wenn größer (vorzeichenbehaftet)	ZF=0 und SF=OF
`JGE` / `JNL`	Springen, wenn größer oder gleich (mit Vorzeichen)	SF=OF
`JL` / `JNGE`	Springe, wenn weniger (vorzeichenbehaftet)	SF!=OF
`JLE` / `JNG`	Springen, wenn kleiner oder gleich (mit Vorzeichen)	ZF=1 oder SF!=OF
`JO`	Bei Überlauf springen	OF=1
`JNO`	Springe, wenn nicht überlaufen	OF=0
`JS`	Springe, wenn Vorzeichen (negativ)	SF=1
`JNS`	Springen Sie, wenn Sie nicht unterschreiben	SF=0
`JP` / `JPE`	Springe, wenn die Parität gerade ist	PF=1
`JNP` / `JPO`	Springe, wenn die Parität ungerade ist	PF=0
`JCXZ` / `JECXZ` / `JRCXZ`	Springe, wenn CX/ECX/RCX Null ist	CX/ECX/RCX=0

Schleifenanweisungen

Gedächtnisstütze	Beschreibung	Operanden
`LOOP`	CX/ECX/RCX dekrementieren, springen, wenn nicht Null	Etikett
`LOOPE` / `LOOPZ`	LOOP während gleich/null	Etikett
`LOOPNE` / `LOOPNZ`	LOOP solange ungleich/nicht Null	Etikett

String-Operationen

Gedächtnisstütze	Beschreibung	Operanden
`MOVS` / `MOVSB` / `MOVSW` / `MOVSD` / `MOVSQ`	Zeichenfolge verschieben (RSI→RDI, nach Größe anpassen)	keiner
`CMPS` / `CMPSB` / `CMPSW` / `CMPSD` / `CMPSQ`	Zeichenfolge vergleichen (RSI vs. RDI)	keiner
`SCAS` / `SCASB` / `SCASW` / `SCASD` / `SCASQ`	Scan-String (vergleiche AL/AX/EAX/RAX mit [RDI])	keiner
`LODS` / `LODSB` / `LODSW` / `LODSD` / `LODSQ`	String laden ([RSI]→AL/AX/EAX/RAX)	keiner
`STOS` / `STOSB` / `STOSW` / `STOSD` / `STOSQ`	Zeichenfolge speichern (AL/AX/EAX/RAX→[RDI])	keiner

String-Anweisungen werden häufig mit dem kombiniertREPPräfix für Blockoperationen:

cld                     ; clear direction flag (forward)
rep movsb               ; copy RCX bytes from RSI to RDI
rep stosd               ; fill RCX dwords with EAX
repne scasb             ; scan for AL in [RDI], RCX times

Flaggenkontrolle

Gedächtnisstütze	Beschreibung
`STC`	Carry-Flag setzen (CF=1)
`CLC`	Clear Carry Flag (CF=0)
`CMC`	Komplement-Carry-Flag (CF=!CF)
`STD`	Richtungsflag setzen (DF=1)
`CLD`	Flag „Richtung löschen“ (DF=0)
`STI`	Interrupt-Flag setzen (IF=1)
`CLI`	Interrupt-Flag löschen (IF=0)
`LAHF`	Flags in AH laden (SF:ZF:0:AF:0:PF:1:CF)
`SAHF`	Speichern Sie AH in Flags
`SAHF`	Speichern Sie AH im unteren RFLAGS-Byte

Bit-Manipulation

Gedächtnisstütze	Beschreibung	Operanden
`BT`	Bittest (speichert Bit an Position in CF)	reg/mem, reg/imm
`BTS`	Bit testen und einstellen	reg/mem, reg/imm
`BTR`	Bittest und Reset	reg/mem, reg/imm
`BTC`	Bittest und Ergänzung	reg/mem, reg/imm
`BSF`	Bit-Scan vorwärts (niedrigstes gesetztes Bit)	reg, reg/mem
`BSR`	Bit-Scan rückwärts (höchstes gesetztes Bit)	reg, reg/mem
`POPCNT`	Bevölkerungszahl (Anzahl der gesetzten Bits) – SSE4.2	reg, reg/mem
`LZCNT`	Führende Nullen zählen – BMI1 (über F3 0F BD)	reg, reg/mem
`TZCNT`	Nachgestellte Nullen zählen – BMI1	reg, reg/mem

Tauschen / Konvertieren

Gedächtnisstütze	Beschreibung	Operanden
`XADD`	Austauschen und hinzufügen (atomar)	reg/mem, reg
`CMPXCHG`	Vergleichen und austauschen (atomar)	reg/mem, reg
`CMPXCHG8B`	Vergleichen und tauschen Sie 8 Bytes (atomar) aus	mem64
`CMPXCHG16B`	Vergleichen und tauschen Sie 16 Bytes (atomar, benötigt LOCK)	mem128
`CBW` / `CWDE` / `CDQE`	Konvertieren Sie Byte in Wort / Wort in Dword / Dword in Qword	keine (verwendet AL/AX/EAX)
`CWD` / `CDQ` / `CQO`	Konvertieren Sie Wort in Dword / Dword in Qword / Qword in Dqword (DX:AX / EDX:EAX / RDX:RAX)	keiner
`CWDE`	Wandeln Sie Wort (AX) in Doppelwort (EAX) mit Vorzeichenerweiterung um	keiner
`CDQE`	Doppelwort (EAX) in Quadwort (RAX) mit Vorzeichenerweiterung umwandeln	keiner

Atomar-/Sperrpräfix

DerLOCKDas Präfix macht bestimmte Anweisungen auf Multiprozessorsystemen atomar. Unterstützte Anweisungen:

lock add / lock adc / lock sub / lock sbb / lock and / lock or / lock xor
lock inc / lock dec / lock neg / lock not
lock xadd / lock cmpxchg / lock cmpxchg8b / lock cmpxchg16b
lock bts / lock btr / lock btc

Beispiel:

lock inc DWORD PTR [counter]       ; atomic increment
lock cmpxchg DWORD PTR [ptr], ecx   ; atomic compare-exchange

Legacy / Kompatibilität

Gedächtnisstütze	Beschreibung
`AAA`	ASCII-Anpassung nach Hinzufügung (nicht gültig in x64)
`AAS`	ASCII-Anpassung nach Subtraktion (nicht gültig in x64)
`AAM`	ASCII-Anpassung nach Multiplikation (nicht gültig in x64)
`AAD`	ASCII-Anpassung vor der Division (nicht gültig in x64)
`DAA`	Dezimalanpassung nach Addition (nicht gültig in x64)
`DAS`	Dezimalanpassung nach Subtraktion (nicht gültig in x64)

Notiz:Die ASCII- und Dezimal-Anpassungsanweisungen sind im x64-Modus nicht codierbar, der Assembler akzeptiert sie jedoch aus Gründen der Kompatibilität mit Legacy-Code auf Quellebene.

NOP und Multi-Byte-NOPs

Gedächtnisstütze	Codierung	Größe
`NOP`	90	1 Byte
`NOP`(2 Byte)	66 90	2 Bytes
`NOP`(3 Byte)	0F 1F 00	3 Bytes
`NOP`(4 Byte)	0F 1F 40 00	4 Bytes
`NOP`(5 Byte)	0F 1F 44 00 00	5 Bytes
`NOP`(6 Byte)	66 0F 1F 44 00 00	6 Bytes
`NOP`(7 Byte)	0F 1F 80 00 00 00 00	7 Bytes
`NOP`(8 Byte)	0F 1F 84 00 00 00 00 00	8 Byte
`NOP`(9 Byte)	66 0F 1F 84 00 00 00 00 00	9 Bytes

Category: Assembly

PBXB64 Status: Referenzthema fuer Assembler-Syntax und Familienhinweise; untergeordnete Instruktionsseiten und registrierte Tests liefern den endgueltigen Support-Nachweis.

Beschreibung

Dieses Assembler-Thema gruppiert PBXB64-x64-Assembler-Syntax, Direktiven, Adressierungsregeln oder Mnemonik-Familien. Behandeln Sie es als Navigation plus Nutzungshinweis, sofern keine Unterseite oder kein registrierter Test eine konkrete Instruktionsform belegt.

Prüfung der Instruktionsfamilie

Verwenden Sie diese Mnemonik-Übersichten als Einstieg in fokussierte Assembler-Tests. Eine vollständige Prüfung nennt CPU-Feature-Bit, Operandenbreite, Register- oder Speicherform, Flag-Auswirkungen und ob die Instruktion im Windows-x64-User-Mode gültig ist.

PBXB64-Integrationshinweise

Inline-Assembler muss die Windows-x64-Aufrufkonvention erhalten, wenn die Kontrolle zu compilererzeugtem Code zurückkehrt. Sichern Sie nichtflüchtige Register, halten Sie Stack-Alignment bei Aufrufen ein und dokumentieren Sie absichtlich veränderte Flags oder Register.

Validierungsbeleg

Validierungsbeleg: Verwenden Sie die registrierten Inline-Assembler- und Standalone-Assembler-Validierungsprogramme als Nachweis fuer konkrete unterstuetzte Instruktionsformen und nennen Sie die genaue Testdatei auf der Unterseite, wenn vorhanden.