PureBasic Assembler Error [93937]

[lite]

Hallo

Ich habe ein Problem mit den kompilieren.
Seit einigen Jahren schreiben ich nun an meinen Programm. Es wurde immer für x86 kompiliert. Funktioniert ohne Probleme. Seit gestern versuche ich es mit x64.
Die gleiche Source, und es kommt zu einem "Assembler Error".

"PureBasic.asm [93937]:"
"MP192"
"PureBasic.asm [86348] MP192 [10]:"
"xor rdx,[v_Bit21]"
"error: operand sizes do not match."

Wie soll ich den Fehler suchen, wen der Source um die 11000 Zeilen hat ?

Kann man ganze Bereiche ausdokumentieren ?

MFG
Lite

[NicTheQuick]

Ganze Bereiche kann man recht einfach mit "CompilerIf #False : CompilerEndIf" umschließen um sie zu deaktivieren.

Du kannst dir auch den ASM-Output generieren lassen, die entsprechende Zeile in der ASM-Datei suchen und dann schauen zu welcher Zeile diese im PureBasic-Code passt. Das ist recht einfach, weil im ASM-Output jede Originalprogrammzeile als Kommentar steht.

Trotzdem noch eine weitere Frage: Nutzt du UserLibraries?

[lite]

Danke für deine Rückantwort.

Ich nutze keine Userlibs.
Wo kann man sich den ASM Output generieren lassen ?

MFG
Lite

[lite]

Hallo

Ursache gefunden.
Die .asm war sehr nützlich.
Liegt an dieser Zeile unter 64 Bit:
!xor rdx,[v_Bit21] ;Bit21 kippen

Wie kann man das beheben ?

Hier die fehlerhafte Funktion:

Code: Alles auswählen

Procedure _getCPUVT()
  
;Global Bit0.l  = $1          ;für SSE3
Global Bit2.l  = $4          ;für AMD SVM MONITOR
Global Bit5.l  = $20         ;für VT-X, MSR, LZCNT
;Global Bit9.l  = $200        ;für SSSE3
;Global Bit15.l = $8000       ;für CMOVcc
Global Bit21.l = $200000     ;für EFlag
;Global Bit23.l = $800000     ;für MMX 
;Global Bit25.l = $2000000    ;für SSE
;Global Bit26.l = $4000000    ;für SSE2
;Global Bit30.l = $40000000   ;für extended 3DNow!
;Global Bit31.l = $80000000   ;für 3DNow!
   
CompilerSelect #PB_Compiler_Processor
 CompilerCase #PB_Processor_x86
      ;     MessageRequester("","x86")
  !pushfd                ;das EFlag-Register (32-Bit) auf den Stack
  !pop eax               ;rein in EAX
  !mov edx,eax           ;EAX unverändert lassen
  !xor edx,[v_Bit21]     ;Bit21 kippen 
  !push edx                          
  !popfd                 ;in EFlag schreiben
  !pushfd                ;wieder auf Stack
  !pop edx
  !push eax              ;der Ordnung halber alten Wert wieder herstellen
  !popfd   
  !cmp eax,edx
  !jne @f                ;sind nicht gleich -> CPUID ist möglich
  ProcedureReturn 0   
      ;  MessageRequester("Status", "Der getestete Prozessor unterstützt den CPUID-Befehl nicht!")
!@@:
 CompilerCase #PB_Processor_x64
    ;  MessageRequester("","64")
  !pushfq                ;das RFlag-Register (64-Bit) auf den Stack
  !pop rax               ;rein in RAX
  !mov rdx,rax           ;RAX unverändert lassen
  !xor rdx,[v_Bit21]     ;Bit21 kippen 
  !push rdx                          
  !popfq                 ;in RFlag schreiben
  !pushfq                ;wieder auf Stack
  !pop rdx
  !push rax              ;der Ordnung halber alten Wert wieder herstellen
  !popfq   
  !cmp rax,rdx
  !jne @f                ;sind nicht gleich -> CPUID ist möglich
  ProcedureReturn 0 
  ;  MessageRequester("Status", "Der getestete Prozessor unterstützt den CPUID-Befehl nicht!")
End  
!@@:
  CompilerEndSelect
  !mov eax,80000000h
  !cpuid
  !cmp eax,80000000h       ;hat nichts mit einem Bit zu tun!
  !jbe noexte            ;keine Extended Levels, Ende
  !mov eax,80000001h
  !cpuid                   ;Intel-Prozessoren liefern hier EAX=0 zurück
  !or eax,eax

  !je cpuintel              ;ist Intel-Prozessor
    !mov eax,1h
    !test ecx,[v_Bit2]      ; AMD SVM
    !jz nosvm
      ProcedureReturn 1   ; AMD SVM ,True
    !nosvm:
      ProcedureReturn 0
  !cpuintel:
    !mov eax,1h
    !cpuid
    !test ecx,[v_Bit5]      ;Intel VTX  
    !jz novt
       ProcedureReturn 1  ; Intel VTX, True
    !novt: 
      ProcedureReturn 0
    !noexte:
    ProcedureReturn 0   ; no extension
EndProcedure 

MFG
Lite

[Danilo]

Ich verwende das als IDE-Tool: CommentedASM.zip
mit Argument "%TEMPFILE" von der IDE aus.

Wenn Du "Global Bit21.l = $200000" in den Typ .i änderst, ist es 64bit mit PB 64bit.

[NicTheQuick]

Wieso muss man da denn überhaupt globale Variablen verwenden? Kann man die Konstante nicht gleich an die Stelle im ASM-Code schreiben?

[Helle]

@lite: Sorry, meine Jugendsünde. Habe damals (2009) den 64-Bit-Part offensichtlich ohne zu testen (können?) hinzugefügt. Lass man die Bit-Variablen als Long (DWord) und ändere rdx in edx. Bit21 bleibt Bit21. Der Test auf CPUID-Verfügbarkeit ist unter 64-Bit eh sinnlos (wird einfach vorausgesetzt, seit vielen Jahren auch bei allen verfügbaren Prozis).
@Nic: Bei 32-Bit-Programmen ja, diente hier aber der Übersichtlichkeit. Bei 64-Bit-Progs: Bei vielen Instruktionen nur bis zur Variablengröße von $7FFFFFFF. Hängt mit der max. zulässigen Länge des Opcodes zusammen; ist begrenzt auf max.15 Bytes.
Teste mal:

Code: Alles auswählen

;Geht nicht:
!xor rdx,80000000h

Code: Alles auswählen

;Geht:
!xor rdx,7FFFFFFFh
X.q=$80000000
!xor rdx,[v_X]

[lite]

Vielen herzlichen Dank für eure Hilfe.

Bei einer 64 Bit Version sollte trotzdem die Intel VT oder AMD SVM fähigkeit geprüft werden können. So als wäre es 32 Bit.
Ich habe gerade meinen 64 Bit Laptop nicht da. Bekomme in erst nächste Woche wieder. (Frau) und kann deshalb nicht testen.
Funktioniert jetzt die Version ?

MFG
Lite