Verfügbare CPU-Register für x64

[Helle]

Als Assembler-Programmierer kann man ja nie genug CPU-Register haben, denn darin Daten zwischenzuspeichern ist viel schneller als das Auslagern in (Speicher-)Variablen. Wer sich mit der jetzt verfügbaren x64-Version von PB assembler-mäßig beschäftigen will, ist fein raus: Etliche neue Register stehen zur Verfügung, an deren Namen man sich aber erst gewöhnen muss. Damit bei z.B. "SIL" nicht an Muttis Waschpulver gedacht wird, hier eine kleine Übersicht über die verfügbaren x64-Register:

Code: Alles auswählen

;Verfügbare CPU-Register für x64 (ohne Instruction-Pointer und FPU sowie MMX)

;      -------------------------------------------------      
; Byte |  7  |  6  |  5  |  4  |  3  |  2  |  1  |  0  |  
;      -------------------------------------------------
; z.B.                                     |  AH |  AL |
; z.B.                                     |--- AX ----|
; z.B.                         |--------- EAX ---------|
; z.B. |--------------------- RAX ---------------------|
; z.B.                                           | DIL |
; z.B.                                     |--- DI ----|
; z.B.                         |--------- EDI ---------|
; z.B. |--------------------- RDI ---------------------|
; z.B.                                           | R8L |
; z.B.                                     |--- R8W ---|
; z.B.                         |--------- R8D ---------|
; z.B. |--------------------- R8 ----------------------|

;----------------------------------------------------------------------------------------
;- Verfügbare CPU-Register für x64: 
;AL, AH, AX, EAX, RAX
;BL, BH, BX, EBX, RBX
;CL, CH, CX, ECX, RCX
;DL, DH, DX, EDX, RDX

;DIL, DI, EDI, RDI           ;sowas wie DIH (High-Byte von DI) gibt es nicht!
;SIL, SI, ESI, RSI           ;sowas wie SIH (High-Byte von SI) gibt es nicht!
;BPL, BP, EBP, RBP           ;sowas wie BPH (High-Byte von BP) gibt es nicht!
;SPL, SP, ESP, RSP           ;sowas wie SPH (High-Byte von SP) gibt es nicht!

;R8L, R9L ... R15L           ;komplett neue (8-Bit) Register!
;R8W, R9W ... R15W           ;komplett neue (16-Bit) Register!
;R8D, R9D ... R15D           ;komplett neue (32-Bit) Register!
;R8, R9 ... R15              ;komplett neue (64-Bit) Register!

;----------------------------------------------------------------------------------------
;- Neu hinzugekommen:
;RAX, RBX, RCX, RDX          ;64-Bit-Register (Erweiterung der "alten" 32-Bit-Register)
;DIL, SIL, BPL, SPL          ;8-Bit-Register (Byte 0 von RDI, RSI, RBP, RSP)
;RDI, RSI ,RBP, RSP          ;64-Bit-Register (Erweiterung der "alten" 32-Bit-Register) 
;R8L bis R15L                ;8-Bit-Register (Byte 0 von R8 bis R15) 
;R8W bis R15W                ;16-Bit-Register (Byte 0 und 1 von R8 bis R15)
;R8D bis R15D                ;32-Bit-Register (Byte 0 bis 3 von R8 bis R15)
;R8 bis R15                  ;64-Bit-Register

;----------------------------------------------------------------------------------------
;dazu kommen zu den vorhandenen 128-Bit-XMM-Registern XMM0-XMM7 die Register XMM8-XMM15

;----------------------------------------------------------------------------------------
;hier evtl. Test, ob überhaupt 64-Bit-OS 

;----------------------------------------------------------------------------------------
;- Einige Beispiele

Global B.b                   ;Global scheint hier nicht mehr nötig zu sein, ich hab´s gelassen  
Global W.w
Global L.l
Global I.i

;----------------------------------------------------------------------------------------
;- AX, BX, CX, DX
!mov AL,123                  ;Byte 0
!mov [v_B],AL
Debug B

!mov AH,123                  ;Byte 1
!mov [v_B],AH
Debug B

!mov AX,12345                ;Byte 0 - Byte 1
!mov [v_W],AX
Debug W

!mov EAX,1234567890          ;Byte 0 - Byte 3      
!mov [v_L],EAX
Debug L

!mov RAX,1234567890123456789 ;Byte 0 - Byte 7  neu hinzugekommen!
!mov qword[v_I],RAX          ;"qword" muss angegeben werden! 
Debug I

;----------------------------------------------------------------------------------------
;- DI, SI, BP, SP (am Instruction-Pointer wollen wir uns hier nicht vergreifen)
!mov DIL,123                 ;Byte 0  neu hinzugekommen!
!mov [v_B],DIL
Debug B

!mov DI,12345                ;Byte 0 - Byte 1
!mov [v_W],DI
Debug W

!mov EDI,1234567890          ;Byte 0 - Byte 3      
!mov [v_L],EDI
Debug L

!mov RDI,1234567890123456789 ;Byte 0 - Byte 7  neu hinzugekommen!
!mov qword[v_I],RDI          ;"qword" muss angegeben werden! 
Debug I

;----------------------------------------------------------------------------------------
;- R8 bis R15                ;komplett neue Register!  
!mov R8L,123                 ;Byte 0
!mov [v_B],R8L
Debug B

!mov R8W,12345               ;Byte 0 - Byte 1
!mov [v_W],R8W
Debug W

!mov R8D,1234567890          ;Byte 0 - Byte 3      
!mov [v_L],R8D
Debug L

!mov R8,1234567890123456789  ;Byte 0 - Byte 7
!mov qword[v_I],R8           ;"qword" muss angegeben werden! 
Debug I

Gruß
Helle

[Thorium]

Sehr geil, danke für diese Übersicht.
Ich brauch jetzt echt dringend nen neuen Rechner.

[KatSeiko]

Kommt man an die Register eigentlich auch ran, wenn man ein 32bit-OS fährt?

[NicTheQuick]

Natürlich nicht. Dann kommst du nur an die Register ran, die deine
32-Bit-CPU auch zur Verfügung stellt.

///Edit:
Achso, du meinst, du hast eine 64-Bit-CPU, aber ein 32-Bit-OS?
Dann wird Purebasic x64 sowieso nicht auf deinem OS laufen und die 64-Bit-
ASM-Befehle gar nicht erst kennen.

[Batze]

Ich würde das ganze auf 64Bit ja auch gerne mal probieren, aber auch nur 32 Bit XP. Gibts da trotzdem ne Möglichkeit Sachen mal zu kompilieren und zu testen?

[Thorium]

Ich würde das ganze auf 64Bit ja auch gerne mal probieren, aber auch nur 32 Bit XP. Gibts da trotzdem ne Möglichkeit Sachen mal zu kompilieren und zu testen?

Nope.
Theoretisch könnte man auch unter einem 32Bit OS 64Bit Code kompilieren. Aber ausführen kann man ihn auf keinen Fall. Ich hab mir die 4.30 Beta nochnicht angeschaut, hoffe das man da auch mit dem 32Bit Compiler 64Bit Executables erstellen kann. Weil wäre ja blöd nur fürs kompilieren das OS switchen zu müssen.

[Thorium]

///Edit:
Achso, du meinst, du hast eine 64-Bit-CPU, aber ein 32-Bit-OS?
Dann wird Purebasic x64 sowieso nicht auf deinem OS laufen und die 64-Bit-
ASM-Befehle gar nicht erst kennen.

So oder so. Ein 32Bit OS läuft auf einem 64Bit CPU im 32Bit Modus, oder besser gesagt die CPU läuft dann im 32Bit Modus. Da gibts keinen Zugriff auf die 64Bit Register.