Hilfe zum PBXB64-Compiler

Referenz zu Adressierungsmodi

Der PBXB64-Assembler unterstützt 7 primäre Adressierungsmodi mit 21 Operandentypvarianten in 14 Kodierungsformen. Alle Adressierungsmodi folgen der Intel-Syntax (Ziel-, Quellreihenfolge).

Kategorie: Übersicht

Beschreibung

Der PBXB64-Assembler unterstützt 7 primäre Adressierungsmodi mit 21 Operandentypvarianten in 14 Kodierungsformen. Alle Adressierungsmodi folgen der Intel-Syntax (Ziel-, Quellreihenfolge).

Zusammenfassung des Adressierungsmodus

#	Modus	Syntax	Codierung	Beispiel
1	Registrieren	`reg`	ModRM.reg / ModRM.rm	`mov eax, ebx`
2	Sofort	`imm`	Sofortiges Feld	`mov eax, 42`
3	Direkter Speicher	`[addr]`	ModRM: 00 000 101 + disp32	`mov eax, [12345678h]`
4	Basis+Anzeige8	`[reg+disp8]`	ModRM: 01 xxx xxx + disp8	`mov eax, [rcx+8]`
5	Basis+disp32	`[reg+disp32]`	ModRM: 10 xxx xxx + disp32	`mov eax, [rcx+1024]`
6	Basis+Index	`[base+index]`	ModRM+SIB: 00 100 xxx	`mov eax, [rbx+rcx]`
7	Basis+Index+Disp8	`[base+index+disp8]`	ModRM+SIB: 01 100 xxx	`mov eax, [rbx+rcx+8]`
8	Basis+Index+Disp32	`[base+index+disp32]`	ModRM+SIB: 10 100 xxx	`mov eax, [rbx+rcx+1024]`
9	Index*Skala	`[index*scale]`	ModRM+SIB: 00 100 101	`mov eax, [rcx*4]`
10	Index*Skala+Anzeige32	`[index*scale+disp]`	ModRM+SIB: 00 100 101 + disp32	`mov eax, [rcx*4+16]`
11	Basis+Index*Skala	`[base+index*scale]`	ModRM+SIB: Skala=Index	`mov eax, [rbx+rcx*4]`
12	Basis+Index*Skala+Anzeige8	`[base+index*scale+disp8]`	ModRM+SIB: 01 xxx xxx	`mov eax, [rbx+rcx*4+8]`
13	Basis+Index*Skala+Anzeige32	`[base+index*scale+disp32]`	ModRM+SIB: 10 xxx xxx	`mov eax, [rbx+rcx*4+1024]`
14	RIP-relativ	`[rip+disp]`	ModRM: 00 000 101 + disp32 (relativ)	`mov rax, [rip+label]`
15	RIP-relativ+Index	`[rip+index*scale+disp]`	RIP+SIB	`mov rax, [rip+rcx*4+label]`
16	FS-Segment-Überschreibung	`fs:[base+disp]`	Segmentpräfix 64h + ModRM	`mov rax, fs:[0x30]`
17	GS-Segment-Überschreibung	`gs:[base+disp]`	Segmentpräfix 65h + ModRM	`mov rax, gs:[0x60]`
18	FS+RIP-relativ	`fs:[rip+disp]`	64h + RIP-relativ	`mov rax, fs:[rip+label]`
19	GS+RIP-relativ	`gs:[rip+disp]`	65h + RIP-relativ	`mov rax, gs:[rip+tls_var]`
20	Registrieren (implizit)	`reg`	Opcode-Bits	`push rbx`(Opcode 53h)
21	Sofort (impliziert)	`imm`	Im Opcode implizit	`ret 16`(imm16 im Opcode C2h)

1. Adressierung registrieren

Der Operand ist ein Register. Das Register ist im ModRM-Byte oder im primären Opcode codiert.

mov eax, ebx        ; eax = ebx
add rcx, rdx        ; rcx = rcx + rdx
xor r8d, r9d        ; r8d = r8d xor r9d

2. Sofortige Adressierung

Der Operand ist ein konstanter Wert, der in die Anweisung eingebettet ist. Die unmittelbare Größe hängt von der Operandengröße ab.

mov eax, 42         ; 32-bit immediate
mov rax, 0x12345678 ; 32-bit sign-extended immediate
mov rcx, -1         ; sign-extended immediate
add ebx, 256        ; 32-bit immediate

3. Direkte Speicheradressierung

Der Operand ist ein Speicherort, der durch eine 32-Bit-Absolutadresse angegeben wird. In x64 ist dies auf den niedrigen Adressraum von 4 GB beschränkt (Kompatibilitätsmodus), sofern nicht mit RIP-relativ verwendet.

mov eax, [12345678h]    ; absolute 32-bit address
mov DWORD PTR [1234h], 42  ; store to absolute address

4. Basis + Verschiebung

Die effektive Adresse wird wie folgt berechnetbase + displacement. Die Verschiebung kann ein 8-Bit-Wert (disp8) oder ein 32-Bit-Wert (disp32) mit Vorzeichen sein.

mov eax, [rbp-8]        ; local variable at rbp-8
mov eax, [rcx+16]       ; struct member at offset 16
mov eax, [rsp+0x30]     ; stack parameter
mov eax, [rbx-4]        ; negative displacement

5. Basis + Index

Die effektive Adresse lautetbase + index. Der Index ist ein Allzweckregister, das als Offset verwendet wird.

mov eax, [rbx+rcx]      ; array element: base + index
mov eax, [rax+rdx]      ; pointer + offset

6. Index * Skala

Die effektive Adresse lautetindex * scale. Gültige Skalenwerte sind 1, 2, 4, 8 (kodiert als 00, 01, 10, 11 im SIB-Byte).

mov eax, [rcx*4]        ; element at index*4
mov eax, [rdx*8]        ; element at index*8 (array of pointers)
mov eax, [r9*2]         ; 16-bit element array

7. Basis + Index * Skala + Verschiebung

Das vollständige SIB-Adressierungsformular (Scale-Index-Base). Dies ist der allgemeinste Adressierungsmodus, der alle Komponenten vereint.

mov eax, [rbx+rcx*4+16]        ; array of structs
mov eax, [rbp+r9*8-32]         ; local array with negative offset
mov eax, [rax+rdx*2+0x100]     ; large displacement
mov eax, [r12+r10*4+0x80]      ; base+r12 with r10 scaled

8. RIP-relative Adressierung

In x64 verwenden die meisten Speicherreferenzen standardmäßig RIP-relative Adressierung für den coderelativen Datenzugriff. Der Assembler codiert eine 32-Bit-Verschiebung mit Vorzeichen vom aktuellen Befehlszeiger.

mov rax, [rip+label]           ; load from label (relative to RIP)
mov rax, [rip+my_data]         ; access global data
lea rcx, [rip+message]         ; load effective address
jmp [rip+function_ptr]         ; indirect jump via global pointer

Die RIP-relative Adressierung ist die Standardmethode für den Zugriff auf globale Variablen und Konstanten im x64-Code, da sie die Notwendigkeit absoluter 64-Bit-Adressen vermeidet und positionsunabhängigen Code erzeugt.

9. Segmentüberschreibungen

x64 unterstütztfs:Undgs:Segmentüberschreibungen für den Zugriff auf Thread-lokale Speicher- und Betriebssystemdatenstrukturen.

FS-Segment

In Windows x64 ist diefsDas Segment zeigt auf den Thread Environment Block (TEB).

mov rax, QWORD PTR fs:[0x30]   ; PEB pointer from TEB
mov eax, DWORD PTR fs:[0x18]   ; LastError from TEB
mov rax, QWORD PTR fs:[0x60]   ; TLS base pointer

GS-Segment

Unter Windows x64,gsDas Segment wird für die Thread-lokale Speicherung verwendet. Unter x86-64-Linux verweist es auf threadspezifische Daten.

mov rax, QWORD PTR gs:[0x00]   ; TLS variable (Win64)
mov rax, QWORD PTR gs:[0x10]   ; thread-specific data (Linux)

; With RIP-relative: TLS combined addressing
mov rax, QWORD PTR gs:[rip+tls_var]

Präfixe für die Operandengröße

Speicheroperanden erfordern Größenbezeichner, um die Operandengröße eindeutig zu machen:

Präfix	Größe	Beispiel
`BYTE PTR`	8 Bit	`mov BYTE PTR [rcx], 0xFF`
`WORD PTR`	16 Bit	`mov WORD PTR [rcx], 0x1234`
`DWORD PTR`	32 Bit	`mov DWORD PTR [rcx], eax`
`QWORD PTR`	64 Bit	`mov QWORD PTR [rcx], rax`
`XMMWORD PTR`	128 Bit	`movdqa XMMWORD PTR [rcx], xmm0`
`YMMWORD PTR`	256 Bit	`vmovdqa YMMWORD PTR [rcx], ymm0`
`ZMMWORD PTR`	512 Bit	`vmovdqa32 ZMMWORD PTR [rcx], zmm0`
`TBYTE PTR`	80 Bit	`fld TBYTE PTR [rcx]`

SIB-Kodierung (Scale-Index-Base).

Das SIB-Byte wird verwendet, wenn ein Speicheroperand ein Indexregister umfasst. Format:

SIB = [Scale 2 bits] [Index 3 bits] [Base 3 bits]

Scale: 00=1, 01=2, 10=4, 11=8
Index: general-purpose register (100 = no index)
Base:  general-purpose register (101 = disp32 if Mod=00)

Sonderfälle:

Basis = RSP (100):Ein SIB-Byte iststetserforderlich, um rsp als Basisregister zu kodieren (um Verwechslungen mit der ModRM-Kodierung „SIB vorhanden“ zu vermeiden)
Index = rsp (100):Bedeutet, dass das Register „kein Index“ verwendet wird (nur Basis + Verschiebung)
Mod=00, Basis=101, Index=100:RIP-relative Adressierung

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.