Verdrehte Bits (Wilde Pointereien)

[OlafSt]

Ich empfehle, das ganze mal in Delphi einzugeben, zu kompilieren und dann mal den Assemblercode anzuschauen. Und vielleicht wirfst du auch mal einen Blick in die OH zum Thema Inline-Assembler. Dann wird dir auffallen:

- Das der Parameter "Source" vor dem Call in das EAX-Register geladen wird
- Dann der Call in die Routine stattfindet:

  SwapBytes($00800081);

Delphi-Quellcode:

  
mov eax,$00800081
call SwapBytes

- Die Routine SwapBytes nur das Register EAX (und sonst kein anderes) verändert
- Das Ergebnis nach Verlassen der Routine in EAX erwartet wird.

Wozu dann noch unnötige Ladeoperationen mit EAX ?

Mein zweites Beispiel berücksichtigt nur, das bei Methodenaufrufen der Objektzeiger als erster Parameter übergeben wird (und, wie sich das gehört, landet der erste Parameter in EAX), der zweite Param landet dann in EDX. Da wir das Ergebnis eh in EAX brauchen, lade ich es von EDX nach EAX und mache dann ein BSWAP EAX - in Anlehnung an die einzeilige Version.

Natürlich hätte ich auch BSWAP EDX, gefolgt von MOV EAX,EDX machen können.

Zitat:

Mein Delphi 7 kann das auch schon.

Ich bitte um Verzeihung, das ich keine gesteigerte Lust hatte, mein Delphi 7 hochzufahren und auszuprobieren, ob der Inline-Assembler von D7 bereits BSWAP beherrscht. Ich halte es lieber mit dem Motto "Wenn ich's nicht genau weiß, sag ich nichts".

[Quake]

Ich glaube, wir reden aneinander vorbei.

Zitat:

- Das der Parameter "Source" vor dem Call in das EAX-Register geladen wird.

Das ist das doch was ich die ganze Zeit sage.

Ich sehe immer noch nicht die unnötige Ladeoperation. In deinem Code taucht das "MOV EAX,***" auf und in meinem Code statt dessen "MOV EDX,***". Wo ist da der Unterschied, ausser das ein anderes Register geladen wird. Die CPU führt beide Befehle gleich schnell aus. Ich sehe aber immer noch ein unnötiges "CALL".

Delphi-Quellcode:

mov eax,$00800081
call SwapBytes

Eines muss ich dazu noch sagen: Das "Swapen" tauch nur einmal in meinem gesamten Programm auf.
Deswegen : Warum das in eine Funktion packen, wenn ich es auch mitten in den Code packen kann.

Noch einmal die Gegenüberstellung

Delphi-Quellcode:

   Meins                            Deins
   Zahl := $12345678;               Zahl := $12345678;
   asm                              Zahl := SwapBytes(Zahl);
     mov edx, Zahl;                 // mov eax, Zahl    // bei dir von Delphi generiert
                                    // call SwapBytes
                                    asm    // Dieser Block ist in deiner Funktion
     bswap edx;                       bswap eax;
                                      // Rücksprung aus Funktion 
                                      ret;    // ich hoffe das heisst so auf einem 8086
                                    end;
     mov Zahl, edx;                 // mov Zahl, eax;    // bei dir von Delphi generiert
   end;
   // jetzt ist bei beiden Varianten die Variable Zahl gedreht

Ich sehe es nicht wo dein Code kürzer oder schneller sein sollte.

Zitat:

Ich empfehle, das ganze mal in Delphi einzugeben, zu kompilieren und dann mal den Assemblercode anzuschauen.

Kann Delphi den Asm-Code selbst ausgeben? Ich habe keinen Disassembler installiert.

[Apollonius]

Einen Haltepunkt einfügen und im angehaltenen Zustand alt+strg+c drücken (Delphi 2005). Sonst eben mal das Menü durchforsten, die Ansicht heißt "CPU".

[Gruber_Hans_12345]

Zitat von Quake:

Delphi-Quellcode:

   Meins                            Deins
   Zahl := $12345678;               Zahl := $12345678;
   asm                              Zahl := SwapBytes(Zahl);
     mov edx, Zahl;                 // mov eax, Zahl    // bei dir von Delphi generiert
                                    // call SwapBytes
                                    asm    // Dieser Block ist in deiner Funktion
     bswap edx;                       bswap eax;
                                      // Rücksprung aus Funktion 
                                      ret;    // ich hoffe das heisst so auf einem 8086
                                    end;
     mov Zahl, edx;                 // mov Zahl, eax;    // bei dir von Delphi generiert
   end;
   // jetzt ist bei beiden Varianten die Variable Zahl gedreht

Berücksichtigt Delphi eigentlich solche sachen, wenn man manuelle die Register verändert?
ich pushe und pope die register immer auf den stack, die ich verändere, und ich nicht weiss, ob nicht delphi die selber braucht ...

[edit]ok, kommando zurück, hätte mir vorher den ganzen thread mal durchlesen sollen ...

[OlafSt]

@Quake: Wir reden hier wirklich aneinander vorbei

im Verlaufe des Threads ist im Kopf hängengeblieben, das das ganze in eine Funktion ausgelagert wurde (dein RET an der Stelle ist überflüssig und sogar gefährlich. Den Rücksprung besorgt Delphi durch das "end;" von allein). Dann genügt die eine Zeile, wie ich es schrieb.

Mitten im Programmcode, wie in deinem Falle, hast du natürlich recht. Wie sich das ganze verhält, wenn wir "inline" ins Spiel bringen, werde ich jetzt nicht ausführen...

Was deinen Codeschnipsel angeht: Es wäre interessant zu sehen, ob "Zahl" nicht schon in einem Register liegt - dann wären die MOV's wieder überflüssig und wir hätten wieder nur eine Zeile Code. Grundsätzlich empfiehlt sich ein PUSH/POP um solcherlei "handcrafted" Code, wie @Apollonius schon bemerkte. Kann aber durchaus entfallen, wenn es die allerletzten Zeilen in der Funktion sind.

Ach ja, das CPU-Fenster gibt es IIRC seit Delphi 3 (dort nur mit Registry-Hack) und ist erreichbar über ALT+8

[Quake]

Zitat:

(dein RET an der Stelle ist überflüssig und sogar gefährlich. Den Rücksprung besorgt Delphi durch das "end;" von allein). Dann genügt die eine Zeile, wie ich es schrieb.

Da hast du mich auch falsch verstanden. Ich wollte nur verdeutlichen, was bei deiner Methode ausgeführt wird. Da die Funktion mit einem CALL aufgerufen wird muss sie auch mit einem RET (ist RET überhaupt richtig?) beendet werden. Das fügt Delphi natürlich auch selbst hinzu. Du hast Recht, das man das RET auf jeden Fall hier nicht selbst hinzufügen darf.

Zitat:

Es wäre interessant zu sehen, ob "Zahl" nicht schon in einem Register liegt

Das würde der OH widersprechen.

Zitat:

Zu Beginn der Ausführung einer asm-Anweisung ist der Registerinhalt unbekannt.

Es währe natürlich zufällig möglich.

Für mich stellt sich nur die Frage, kann man der OH trauen? Ihr scheint ja alle sehr misstrauisch zu sein.