AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren
Zurück Delphi-PRAXiS Sprachen und Entwicklungsumgebungen Sonstige Fragen zu Delphi Delphi Inline Assembler und überladene Prozeduren?

Inline Assembler und überladene Prozeduren?

Ein Thema von himitsu · begonnen am 21. Feb 2005 · letzter Beitrag vom 9. Aug 2005
Antwort Antwort
Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
44.027 Beiträge
 
Delphi 12 Athens
 
#1

Inline Assembler und überladene Prozeduren?

  Alt 21. Feb 2005, 11:41
Also, wenn man in Pascal 'ne Überladene Funktion/Prozedur aufruft, dann entscheidet ja der Compiler anhand der Parameter, welche "Version" er verwenden muß, aber in ASM geht das ja nicht und so nimmt der Compiler immer (ist jedenfalls bei mir so) die erster Funktion/Prozedure mit dem angegebenem Namen.

Nun möchte ich aber nicht zu Dieser, sondern zu 'ner Anderen.
Also wie kann ich das dem Compiler begreiflich machen?


Delphi-Quellcode:
ASM
  ...
  CALL diePozedur
  ...
End;

Procedure diePozedur(x: Integer); // << und nicht dort
Procedure diePozedur(X: String); // << ich will hierhin
...
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
my Delphi wish list : BugReports/FeatureRequests
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
44.027 Beiträge
 
Delphi 12 Athens
 
#2

Re: Inline Assembler und überladene Prozeduren?

  Alt 28. Feb 2005, 11:19
Hat denn wirklich keine eine Ahnung, irgendwie muß das doch gehen?

PS: ich hab zwar schon rausgefunden, dass man irgendwas in Klammer hinter dn Prozedurnamen setzen kann, aber es wird immernoch die 1. Prozedur angesprungen.

z.B.
Delphi-Quellcode:
ASM
  ...
  CALL diePozedur(Integer)
  ...
End;

Procedure diePozedur(x: String); // << und nicht dort
Procedure diePozedur(X: Integer); // << ich will hierhin
...
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
my Delphi wish list : BugReports/FeatureRequests
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
44.027 Beiträge
 
Delphi 12 Athens
 
#3

Re: Inline Assembler und überladene Prozeduren?

  Alt 16. Mär 2005, 14:20
Also endlich mal 'ne Antwort. (sozusagen )

DF: Inline Assembler und überladene Prozeduren?

Aber vieleicht findet sich dennoch irgendeine Lösung an
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
my Delphi wish list : BugReports/FeatureRequests
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
44.027 Beiträge
 
Delphi 12 Athens
 
#4

Re: Inline Assembler und überladene Prozeduren?

  Alt 23. Jul 2005, 01:08
So, hat sich erledigt ... Delphi ist dafür leider nicht ausgelegt
und es gibt anscheinend wirklich keine andere und vernünftige Lösung außer die Prozeduren nicht zu überladen.

Der einzige Umweg ist, dass man es dem Compiler überlasst und die Prozeduraufrufe nur per Pascal macht.
Seien es direkt Prozeduraufrufe, oder indem man die Prozedue an eine Constante/Variable übergibt und dann zu den darin enthaltenen Pointern springt.


Also Erledig
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
my Delphi wish list : BugReports/FeatureRequests
  Mit Zitat antworten Zitat
choose

Registriert seit: 2. Nov 2003
Ort: Bei Kiel, SH
729 Beiträge
 
Delphi 2006 Architect
 
#5

Re: Inline Assembler und überladene Prozeduren?

  Alt 23. Jul 2005, 14:15
Hallo himitsu,

Zitat von himitsu:
Delphi ist dafür leider nicht ausgelegt
Schade. Hast Du eine verlässliche Quelle für diese Aussage, oder ist das die Essenz aus Deinen Bemühungen?

Delphi hat in der Tat auch andere Probleme mit Adressen im Zusammenhang mit dem @-Parameter
Delphi-Quellcode:
procedure TestProc(param: string); overload;
procedure TestProc(param: Integer); overload;

type
  TStringProc = procedure(param: string);
  TIntProc = procedure(param: Integer);
wenn Du nun eine Zuweisung der Art
Delphi-Quellcode:
var
  myStringProc: TStringProc;
  myIntProc: TIntProc;
begin
  myStringProc := @TestProc;
  myIntProc := @TestProc;
  Assert( Pointer(myIntProc)=Pointer(myStringProc) );
durchführst, weist der Compiler myIntProc dieselbe Variable zu, wie es bei Deinem Call wäre: Immer die erste.
Abhilfe schafft die Zuweisung ohne Operator
Delphi-Quellcode:
myStringProc := TestProc;
myIntProc := TestProc;
Assert( Pointer(myIntProc)<>Pointer(myStringProc) );
Dein Problem wird beim Einsatz mit DLLs (zB bei BPLs) mithilfe von gesonderten Exportnamen (name manging) gelöst, was im Wesentlichen einem Vergeben eines Alias entspricht. Ohne nun die Routinen zunächst in eine BPL verschieben zu müssen, könntest Du einen solchen Alias über Konstanten realisieren:
Delphi-Quellcode:
const
  STRING_PROC : TStringProc = TestProc;
  INT_PROC: TIntPRoc = TestProc;
diese Zuweisung kann auch lokal, also in Deiner Routine geschehen, in der Du die Assembleraufrufe gestalten möchtest. Problematisch an diesem Ansatz ist leider die interne Realisierung typisierten Konstanten. Sie entsprechen in Delphi einer Art "globaler Variablen". Aus diesem Grund steht INT_PROC nun nicht für eine Adresse,
Code:
MOV    EAX, $1234
CALL   INT_PROC   ; ? FEHLER ? Nein, siehe Erklärung
sondern einer globalen Pointer-Variable. Sie muss dann entsprechend beim Aufruf dereferenziert werden. Glücklicherweise übernimmt der Compiler das für uns, so dass folgendes funktioniert:
Code:
MOV    EAX, $1234
CALL   INT_PROC   ; = CALL [INT_PROC]
Dies ist leider ein kleiner Performancevelust, erspart Dir aber die Änderung des bestehenden überladenen Codes oder das Einführen von Wrapper-Routinen.

Eine Assemblerroutine, die die Integervariante der überladenen Variante von TestProc aufruft könnte demnach ohne neue Symbole nach außen zu veröffentlichen oder Anforderungen an den aufzurufenen Code zu stellen (allerdings auf Kosten einer impliziten Dereferenzierung) so aussehen:
Delphi-Quellcode:
procedure AssemberCallsIntegerVersion; assembler;
const
  TestProc_Integer: procedure(Param: Integer) = TestProc;
asm
  MOV EAX, $1234
  CALL TestProc_Integer
end;
Ich hoffe das hilft... Und würde Dich bitten, die Frage weiterhin als "offen" zu lassen. Mich würde eine direkte Variante ebenfalls interessieren
gruß, choose
  Mit Zitat antworten Zitat
brechi

Registriert seit: 30. Jan 2004
823 Beiträge
 
#6

Re: Inline Assembler und überladene Prozeduren?

  Alt 23. Jul 2005, 14:42
hallo choose,

in deinem Beitrag werden mir 2 sachen nicht ganz klar.

Delphi-Quellcode:

procedure TestProc(param: string); overload;
begin
end;
procedure TestProc(param: Integer); overload;
begin
end;

type
  TStringProc = procedure(param: string);
  TIntProc = procedure(param: Integer);
du meinst doch sicher das (overload bei den proceduren aber net bei der type deklaration)

desweiteren wüßte ich nicht was ein kleingeschriebenes call ändern soll

Delphi-Quellcode:
call INT_PROC ; kein fehler
call [INT_PROC] ; kein fehler
CALL INT_PROC ; kein fehler
CALL [INT_PROC] ; kein fehler
es ist nunmal so das in asm alle parameter nur ein dword sind

also wenn du jetzt

Delphi-Quellcode:
push 0
call irgendwas
machst, woher soll delphi nun wissen ob das nen pointer (nil) oder nen 0 ist wenn ich folgende funktion habe

Delphi-Quellcode:
  procedure bla(p: pointer); overload;
  ...
  procedure bla(i: integer); overload;
  ...

das einzige was ich mir eventuell vorstellen kann, ist das man halt sagt welche funktion gecalled werden soll
irgendwas wie

Delphi-Quellcode:
call bla(0)
call bla(1)
aber leider weiß ich nicht ob es sowas gibt, btw bin ich der uall@ogc der auch das ins delphi forum geschrieben hat
  Mit Zitat antworten Zitat
choose

Registriert seit: 2. Nov 2003
Ort: Bei Kiel, SH
729 Beiträge
 
Delphi 2006 Architect
 
#7

Re: Inline Assembler und überladene Prozeduren?

  Alt 23. Jul 2005, 14:54
Hallo brechi,

danke für den Hinweis mit dem overload und der abweichenden Groß-/Kleinschreibung. Ich habe das entsprechend korrigiert, um weiteren Missverständnissen vorzubeugen.

In der Tat macht es keinen Unterschied, ob Du den Wert zunächst dereferenziert und ich wollte darauf hinweisen, dass CALL SYMBOL in diesem Fall identisch ist mit CALL [SYMBOL], was keine Selbstverständlichkeit ist... Viel mehr zeigt es deutlich, dass der Aufruf über solche Konstanten nicht identisch ist mit dem Aufruf, den der Compiler generiert: Statt "an Ort und Stelle" die Adresse zu ermitteln geschieht dies bei der Deklaration der Konstante.
Allerdings: Wenn der Compiler typisierte Konstanten nicht wie globale Variable behandeln würde, machte dies keinen Unterschied...
gruß, choose
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
44.027 Beiträge
 
Delphi 12 Athens
 
#8

Re: Inline Assembler und überladene Prozeduren?

  Alt 6. Aug 2005, 20:23
Zitat:
Schade. Hast Du eine verlässliche Quelle für diese Aussage, oder ist das die Essenz aus Deinen Bemühungen?
Ist nicht nur meine Meinung ... an anderen Stellen wurde mir mittler Weile "bestätigt", daß der Delphi-Compiler in der ASM-Umgebung nichts zur Verfüguns stellt, womit man sagen kann, ob nun die 1., oder z.B. die 3. Implementierung einer überladenen Funktion/Prozedur verwenden soll.
Es gibt allerdings andere Sprachen, wo man derartiges angeben kann.

Irgendwo im DF existiert z.B. einer dieser Beiträge wo mir gesagt wurde, daß Borland's Delphi nicht damit klar kommt.



Das mit dem "Alias" bei der External-Deklaration für DLL's wußte ich auch schon, aber dieses funktioniert halt nur dann, wenn man die entsprechende Funktion z.B. in eine DLL auslagert und beim einbinden nicht wieder überlagert.

Innerhalb eines Programms kommt man halt nicht weit damit.

Dazu kommt dann noch, daß ich zwar unter Umständen einige Funktionen in eine DLL auslagere, und die überladenen Funktionen natürlich über andere Namen exportiere, aber dann wieder mit dem originalen Namen improtiere.



Im Endeffekt bleiben dann leider nur die 2 übrigen Möglichkeiten übrig:
* entweder man verzichtet auf das Überladen,
aber ofmals läßt es sich halt nicht vermeiden.
* oder man besorgt sich per Pascal den gewünschten Prozedur-Pointer,
speichert diesen in einer Konstante/Variable
und springt dann diese Prozedur/Funktion über den gepeicherten wert an.

wobei letzteres auch nicht immer funktioniert ... vorallem bei bestimmten Funktionen/Prozeduren und dann auch noch bei Methoden...





Und das Problemchen mit den [ ] ist mir auch schon schmerzlich aufgefallen, allerdings bei Variablen.

In meinem Fall wollte ich
MOV EAX, &Variable
haben, aber delphi machte wegen der Variable automatisch die Klammer drum
MOV EAX, [&Variable]
was dann 'nen netten Fehler verursachte, der mich dann 'ne ganze Weile verrückt gemacht hatte,
bis ich dann durch Zufall im IM CPU-Fenster darüber gestolpert bin
Es ist schon komisch, wie Delphi immer wieder versucht intelligent zu sein
und dann selbstständing vieles verändert.

Mit einigen "gut gemeinten" Optimierungen hab ich auch manchmal zu kämpfen, vorallem mit denen, welche sich nicht abschalten lassen -.-''





Zitat:
Wenn der Compiler typisierte Konstanten nicht wie globale Variable behandeln würde...
das ist ja auch noch sowas gemeines (manchmal)
aber ich hab mittler Weile wenigstens einen Weg gefunden, wie man unter Umständen dennoch eine untypisierte Konstante erstellen kann, die dennoch in einem gewissen Maße typisiert ist ^^
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
my Delphi wish list : BugReports/FeatureRequests
  Mit Zitat antworten Zitat
Benutzerbild von negaH
negaH

Registriert seit: 25. Jun 2003
Ort: Thüringen
2.950 Beiträge
 
#9

Re: Inline Assembler und überladene Prozeduren?

  Alt 6. Aug 2005, 22:59
Baue einen "Calldispatcher" rein.

Delphi-Quellcode:

procedure DoCallOverload(params);
begin
  OverloadedProc1(Params);
end;

procedure Asmtest;
asm
   ... blabla
   call DoCallOverloaded
   ... blabla
end;
Geht nicht anders, der Assembler bzw. Linker benutzt immer die erste überladene Funktion die er findet. Ist mir auch schon aufgefallen. Allerdings habe ich festgestellt das die erste Funktion die der Linker benutzt auch immer die erste Funktion ist die im Source deklariert wurde. Bei überladenen Funktionen ist es ja meistens so das sie nur als "Typ-Konviertierungs-Funktionen" agieren, sprich mehrere überladens Funktionen gleichen Typus rufen intern im Grunde immer die gleiche reale Funktion auf. D.h. sie wandeln nur die Paramater um. Exakt das nutze ich dann aus indem diese interne Arbeits-Funktion Paramater benutzt die für Assembler Aufrufe tauglich sind. Dieses Arbeits-Funktion wird selber nicht überladen, und schwups hat sich das Problem erledigt.

Gruß Hagen
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
44.027 Beiträge
 
Delphi 12 Athens
 
#10

Re: Inline Assembler und überladene Prozeduren?

  Alt 9. Aug 2005, 19:30
Diese möglichkeit hatte ich mittler Weile verdrängt ... da nehme ich doch lieber den Umweg über eine Konstante - somit wird nebenbei auch noch der doppelte CALL-Aufruf weggelassen ^^
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
my Delphi wish list : BugReports/FeatureRequests
  Mit Zitat antworten Zitat
Themen-Optionen Thema durchsuchen
Thema durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 14:25 Uhr.
Powered by vBulletin® Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz