Inline Assembler: CALL

[Amicello]

Hallo,

seit einigen Tagen hat mich Delphi als Programmiersprache begeistert, ganz einfach durch den Inline Assembler.
Leider scheitert es an scheinbar trivialen Dingen:
z.B. bei soetwas:

push eax
call 006F0B4F

Hier meldet der Compiler beim Call: "error in numeric constant"

call $006F0B4F
Compiler meldet: "invalid combination of opcode and operand"

call 0x006F0B4F
Compiler meldet: "invalid combination of opcode and operand"

call 006F0B4Fh
Compiler meldet: "invalid combination of opcode and operand"


Wie macht man es denn in Delphi nun richtig?
Ein Freund der schon länger mit der Sprache arbeitet, macht es so mit einem Umweg:

mov ecx,$006F0B4F
Call ecx

Das funktioniert - kann aber nicht der Weisheit letzter schluss sein.
Hier muss es doch eine korrekte Schreibweise für absolute Addresssen geben.
Kann hier jemand weiterhelfen?

[Amicello]

Oh sehe gerade, dass ein CALL ebenso wie ein JMP relativ zum EIP addressiert wird.
Das ganze soll eine DLL zum Injecten in ein bestehendes Programm werden, und da der Compiler nicht wissen kann, wo die Originalroutine in Bezug auf die compilierte DLL im Speicher sitzt bleibt wohl nur die Lösung über den Umweg. Oder hat noch jemand eine andere Idee?

[Zacherl]

In Delphi ist "$" das Prefix für hexadezimale Darstellung und nicht "h" als Suffix.

Es gibt kein CALL ABS im X86 Assembler. Calls und Jumps sind immer relativ. Höchstens CALL [ADDR] ist noch möglich.

[Amicello]

Jau.. genauso hab ich das jetzt auch umgesetzt. Ich habe die CALL-Adressen als Konstante definiert.
Die fertige DLL hab ich mir dann mal mit einem Debugger in der Praxis angesehen.

Delphi scheint das nicht als absolute Konstante im Programmcode zu verwursten, sondern legt schön eine 4-Byte breite Variable mit dem Wert als Inhalt an. In dem Fall recht praktisch!
Im Endprodukt steht dann ein CALL [xxxxxxxx] mit der Delphi-Internen Adresse der Variablen, dessen Inhalt dann auf das gewünschte Ziel zeigt. Passt!

Vielleicht nicht die eleganteste Lösung, aber funktioniert - und man braucht nicht den Umweg über ein zusätzliches Register.


const
adr_00845C55 : DWORD = $00845C55;

(...)

ASM
CALL [adr_00845C55]
END;

[Stevie]

Zitat von Amicello:

Delphi scheint das nicht als absolute Konstante im Programmcode zu verwursten, sondern legt schön eine 4-Byte breite Variable mit dem Wert als Inhalt an.

Delphi-Quellcode:

const
  adr_00845C55: DWORD = $00845C55;

Das liegt daran, dass du hier eine sogenannte Typisierte Konstante deklariert hast.

[Amicello]

Zitat von Stevie:

Das liegt daran, dass du hier eine sogenannte Typisierte Konstante deklariert hast.

Ja.. da hab ich mich auch schon versucht etwas einzulesen. Speicherzugriffe mit PDWORD Variablen(^) sind auch herrlich bequem.
Irgendwann werd ich mich wohl auch noch dran gewöhnen wo man ein ";" setzt und wo nicht
Nur mit der IDE steh ich noch auf Kriegsfuß (Stichwort TABS, Zeilenende) .. aber ich denke das wird auch.

[Zacherl]

Falls du lieber auf inline-Assembly verzichten willst, geht sogar Folgendes:

Delphi-Quellcode:

type
  TFunctionPointer = function(A, B, C: Integer): Integer; stdcall;

// Aufruf
TFunctionPointer($00401234)(1, 2, 3);

Je nachdem was für Funktionen du aufrufst, musst du natürlich schauen, ob die überhaupt einer Standard Calling-Convention (stdcall, cdecl, etc.) folgen. Falls nicht, kommst du um den Assembler-Code wohl nicht herum.

[Amicello]

Zitat von Zacherl:

Falls du lieber auf inline-Assembly verzichten willst, geht sogar Folgendes: (...)

Interessanter Ansatz!
Manche Programmfunktionen erfordern zusätzlich zum PUSH'en der Paramenter aber auch noch bestimmte Suchverweisen, Kriterien etc. z.B. in den Registern EAX/ECX. Da muss ich dann in die Assemblertrickkiste greifen, aber trotzdem danke für deinen Tipp!
Ich werde den sicherlich an der ein oder anderen Stelle mit einbauen.

[Zacherl]

Also thiscall (ECX = Pointer zur Objektinstanz) ist auch ohne Assembly möglich:

Delphi-Quellcode:

type
  TFunctionPointer = function(A, B, C: Integer): Integer of object;

// Aufruf
var 
  Method: TMethod;
begin
  Method.Code := Pointer($00401234); // Adresse der Funktion
  Method.Data := Pointer($00749624); // Adresse der Objektinstanz
  Result := TFunctionPointer(Method)(1, 2, 3);

Ich glaube lediglich fastcall (und natürlich alle nicht-standard Conventions) wird von Delphi nicht unterstüzt.

[Amateurprofi]

[QUOTE=Zacherl;1347473]In Delphi ist "$" das Prefix für hexadezimale Darstellung und nicht "h" als Suffix.QUOTE]

Das stimmt nicht.
Du kannst zum Beispiel schreiben
mov eax,$123
mov eax,123H (Hex)
mov eax,123O (Octal)
mov eax,0101B (Binär)