Inline Assembler und automatische Optimierung?

[himitsu]

Moin Ihr,

also, wenn man in Delphi eine Assembler-Prozedur/Funktion erstellt, dann wird ja oftmals schon etwas Code vor und nach dem eigenem AssemblerCode ausgeführt, welche der Compiler, unabhängig von {$O-}, dort hinmacht (ein PUSH's und so).

Kann man dieses Verhalten irgendwie abstellen, wenn man es nicht brauch, oder muß ich dieses immer selber rückgängig machen, wenn ich sowas nicht gebrauchen kann?



Derzeit führe ich einfach die Umkehroperationen aus, um sowas loszuwerden und es funktioniert auch wunderbar, aber ohne diesen zusätzlichen und "unnötigen" Code wäre es mir lieber.


[add]

Zitat von OH:

Der Compiler führt für diese Routinen verschiedene Optimierungen durch:

...

Der Compiler generiert nur Stackframes für verschachtelte Routinen, für Routinen mit lokalen Parametern oder für Routinen, die über Parameter im Stack verfügen.
Der automatisch erzeugte Eintritts- und Austrittscode für Routinen sieht folgendermaßen aus:

Code:

PUSH    EBP              ;Vorhanden wenn Locals <> 0 oder Params <> 0
MOV     EBP,ESP          ;Vorhanden wenn Locals <> 0 oder Params <> 0
SUB     ESP,Locals       ;Vorhanden wenn Locals <> 0
 ...
MOV     ESP,EBP          ;Vorhanden wenn Locals <> 0
POP     EBP              ;Vorhanden wenn Locals <> 0 oder Params <> 0
[color=#808080]RET     Params           ;Immer vorhanden[/color]

Wenn lokale Variablen Varianten, lange Strings oder Schnittstellen enthalten, werden sie mit Null initialisiert, aber nach der Verarbeitung nicht finalisiert.
Locals ist die Größe der lokalen Variablen, Params die Größe der Parameter. Wenn sowohl Locals
als auch Params Null ist, existiert kein Eintrittscode, und der Austrittscode besteht nur aus einer RET-Anweisung.

[shmia]

Zitat von himitsu:

also, wenn man in Delphi eine Assembler-Prozedur/Funktion erstellt, dann wird ja oftmals schon etwas Code vor und nach dem eigenem AssemblerCode ausgeführt, welche der Compiler, unabhängig von {$O-}, dort hinmacht (ein PUSH's und so).

Kann man dieses Verhalten irgendwie abstellen, wenn man es nicht brauch, oder muß ich dieses immer selber rückgängig machen, wenn ich sowas nicht gebrauchen kann?

Derzeit führe ich einfach die Umkehroperationen aus, um sowas loszuwerden und es funktioniert auch wunderbar, aber ohne diesen zusätzlichen und "unnötigen" Code wäre es mir lieber.

Delphi-Quellcode:

procedure MitBremborium;
begin    // <==== das erzeugt den einleitenden Code
   asm
      Add edx, 0
      ....
   end;
end;

// Das reserviert Wort inline und die Direktive assembler werden aus Gründen der
// Abwärtskompatibilität mitgeführt und haben keinerlei Auswirkung auf den Compiler.
procedure OhneBremborium; assembler;
asm    // ohne begin
   ...
end;

[DelphiSourcer]

Hallo shmia!

Delphi-Quellcode:

procedure Irgendwas; assembler;
asm
  ... //Irgendwelcher Code
end;

Aaalso, der Compiler erzeugt hier keinen Ein- und Austrittscode mehe, wenn keine Parameter übergeben werden. Aber wie erreiche ich, das meine Prozedur nicht per Call aufgerufen, sondern an entsprechender Stelle in den Programmcode gesetzt wird. In Turbo-Pascal Zeiten ging das mit Inline.

Delphi-Quellcode:

Procedure Machwas;
Inline($cf/$0a/...);

Gibt es dafür in Delphi auch ne Technik. Wenn ja, welche? Irgendwie muß ja der Compiler schließlich wissen, ob ich ein UP aufrufen, oder dessen Code direkt einfügen will.

Danke schon jetzt für die Hilfe

DelphiSourcer

[Lernnix]

Hallo Ihr!

Delphi-Quellcode:

procedure Irgendwas; assembler; 
asm 
  ... //Irgendwelcher Code 
end;

Setzt Delphi nich den Code direkt an der Aufrufsetlle ein mit der Assembler-Direktive. Hab irgendwo gelesen, das das so sein soll?

Lernnix

[tommie-lie]

Nein, explizites Inlining kennt der Delphi-Compiler nicht. Angeblich soll er es gelegentlich aus eigenen Stücken tun, wenn er dazu Lust hat, mir ist so ein gutes Verhalten des Compilers beim Debuggen aber noch nicht untergekommen...
Erst Delphi2005 unterstützt bei Win32-Anwendungen endlich auch Function-Inlining über explizite Direktiven.

[schöni]

Hallo!

Zitat von tommie-lie:

Nein, explizites Inlining kennt der Delphi-Compiler nicht. Angeblich soll er es gelegentlich aus eigenen Stücken tun, wenn er dazu Lust hat, mir ist so ein gutes Verhalten des Compilers beim Debuggen aber noch nicht untergekommen...
Erst Delphi2005 unterstützt bei Win32-Anwendungen endlich auch Function-Inlining über explizite Direktiven.

Hmmm, das ist natürlich ärgerlich. Was soll man da sagen. In Turbo Pascal war das von Anfang an drin. Hab mit Version 3.0 angefangen, ging dort mit Inline(...); Und jetzt soll wir Delphi2005 kaufen, wenn wir auf das Feature Wert legen. Konnten die das nich schon eher reinbauen???

Tschüß

schöni

[tommie-lie]

Zitat von schöni:

Konnten die das nich schon eher reinbauen???

Konnten schon, sämtliche C-Compiler haben es ihnen 10 Jahre lang vorgemacht

[himitsu]

Also, da ich die reinen Assemblerroutinen sind alle beim mir so

Delphi-Quellcode:

procedure Irgendwas(vars ...); 
asm 
  ... //Irgendwelcher Code 
end;

function Irgendwas(vars ...): type; 
asm 
  ... //Irgendwelcher Code 
end;

aufgebaut.

und hier werden die obengenannten Codes automatisch eingebaut, da ja Variablen an die Prozedure übergeben werden. (das hat also nichts mit dem BEGIN/END zu tun)

Ich hab zwar auch Prozeduren nach diesem Muster,

Delphi-Quellcode:

procedure Irgendwas(vars ...); 
var ...
begin
  ...
  asm 
    ... //Irgendwelcher Code 
  end;
  ...
end.

aber dort stört mich derartiges nicht.


PS: Anfangs hatte ich zwar auch dieses "unnötige" assembler mit eingebaut, aber jetzt nicht mehr.procedure Irgendwas; assembler;

[himitsu]

Also, irgendwas stimmt hier nicht, denn nach der OH macht der Compiler immer diese Optimierungen. (hab ich jedenfalls so verstanden)



Hier macht er das nicht,

Delphi-Quellcode:

Procedure Irgendwas(Var X: Integer); 
  ASM 
    ... //Irgendwelcher Code 
    RET
  End;

aber dafür hier (also bei mehr als 4 Byte)

Delphi-Quellcode:

Procedure Irgendwas(Var X: Int64); 
  ASM 
    PUSH ESP
    ...  //Irgendwelcher Code 
    POP  ESP
    RET  8
  End;

Irgendwie muß das doch in den Griff zu bekommen sein?

Oder gibt es zumindestens 'ne Möglichkeit rauszufinden, ob und welcher Code eingefügt wird?
Ich hab ja schon versucht Locals und Params abzufragen aber es gibt ja keine derartigen Variablen/Konstanten...

[Chewie]

So mal ans Anregung: Wenn du es nicht schaffen solltest, alle "unnötigen" Befehle zu elimieren, so könntest du immer noch deine Routinen mit einem Assembler erzuegen und vom Linker miteinbinden lassen.