thiscall calling convention

[Sunec]

Ich muss momentan nicht statische C++ Methoden aufrufen.

Dafür gibt es die thiscall calling convention.

Leider kennt Delphi diese nicht

Also muss man manuell nachhelfen und die Parameter auf den Stack pushen.

Delphi-Quellcode:

asm
    mov ecx, meinKlassenPointer
end;

Das klappt soweit und die Funktionen liefern den richtigen Wert (endlich).

Gibt es da einen besseren Weg das ganze zu realisieren?

Momentan rufe ich vor jedem Funktionsaufruf diesen asm block mit dem jeweiligen Klassenpointer auf. Kann ich das "automatisieren"?

[EWeiss]

Mal ne Frage kannst du hier nicht mit Vtbl arbeiten anstelle von ASM?
Bin mir aber jetzt nicht sicher ob ich dich richtig verstanden habe.


gruss

[Sunec]

Du meinst die Methoden als virtual zu kennzeichnen?

Hab ich leider auch schon vergeblich versucht. Die Funktion liefert ohne den asm "Schnipsel" den falschen Rückgabewert.

[EWeiss]

Zitat:

Du meinst die Methoden als virtual zu kennzeichnen?

Nein Ich meine TDispatchableVtbl.

gruss

[Sunec]

Zitat von EWeiss:

Zitat:

Du meinst die Methoden als virtual zu kennzeichnen?

Nein Ich meine TDispatchableVtbl.

gruss

Da ich davon noch nie gehört habe, hab ich mal das G von Alphabet befrage:
http://foren.activevb.de/cgi-bin/for...msg=404151&id=

Allerdings keine Ahnung wie mir das weiterhelfen soll

[EWeiss]

Zitat von Sunec:

Zitat von EWeiss:

Zitat:

Du meinst die Methoden als virtual zu kennzeichnen?

Nein Ich meine TDispatchableVtbl.

gruss

Da ich davon noch nie gehört habe, hab ich mal das G von Alphabet befrage:
http://foren.activevb.de/cgi-bin/for...msg=404151&id=

Allerdings keine Ahnung wie mir das weiterhelfen soll

Du hast aber schon gelesen ?
stdcall; // Microsoft's thiscall (ecx = this)

und das du den Pointer deiner nicht statischen C++ Methode
hier geliefert bekommst?
AReturn : Pointer; // Pointer to buffer of return value

Von daher dachte ich das es dir vielleicht helfen könnte (andere Methode halt)
Wenn nicht gut dann habe ich wohl was falsch verstanden.
Kein Beinbruch meinerseits.

gruss

[SMO]

Ich hatte auch mal damit zu tun und habe es folgendermaßen gelöst:

Delphi-Quellcode:

type
  PCppClass = ^TCppClass;
  PCppClassVtbl = ^TCppClassVtbl;
  TCppClassVtbl = packed record
    // These are actually Microsoft "thiscall" convention functions that pass a C++ object reference
    // in the ecx register. Delphi doesn't support this calling convention, but in its default
    // "register" calling convention, it passes the first three parameters in eax, edx, ecx, and
    // the rest on the stack. So, by prepending two integer dummies, we can abuse this to fake
    // a thiscall. However, thiscall passes parameters on the stack from right to left, whereas
    // Delphi register uses left to right. Therefore, the order of the parameters after "This"
    // has to be reversed!
    method0: function (Dummy0, Dummy1: Integer; This: PCppClass; hWin: HWND): Boolean;
    method1: function (Dummy0, Dummy1: Integer; This: PCppClass; Arg2, Arg1: Integer): Boolean;
    method2: function (Dummy0, Dummy1: Integer; This: PCppClass): Boolean;
    method3: function (Dummy0, Dummy1: Integer; This: PCppClass; Arg3: Pointer; Arg2, Arg1: Integer): Boolean;
  end;
  TCppClass = packed record
    Vtbl: PCppClassVtbl;
  end;

Erklärung:
Ich habe eine externe in C++ geschriebene DLL, die in einer Funktion eine C++ Klasse zurückliefert und zwar in Form eines Pointers (PCppClass).
Der Pointer zeigt auf eine Datenstruktur, die ihrerseits an erster Stelle einen Pointer auf die Virtual Method Table (Vtbl) hat.
Die Vtbl ist quasi ein Array mit Prozedur/Funktionszeigern (definiert in TCppClassVtbl), die alle die thiscall Aufrufkonvention haben.

Wie im englischen Kommentar beschrieben ist der Trick folgender:
Delphis normale Aufrufkonvention ist "register", d.h. die ersten 3 Parameter werden wenn möglich in den Registern eax, edx, ecx übergeben, in dieser Reihenfolge. Erst ab dem 4. Parameter wird der Stack benutzt. Dagegen benutzt "thiscall" nur ecx für die Klassen/Objektreferenz ("this" is C++, wie "Self" in Delphi) und den Stack für den Rest.
Wenn man also einen thiscall-Aufruf als register-Aufruf definiert, mit zwei initialen Dummy-Parametern, um eax und edx zu füllen, dann kann man auf diese Weise einen thiscall emulieren.
Ein weiterer Unterschied dabei ist, dass "thiscall" die Parameter von rechts nach links auf den Stack legt (wie bei "stdcall"), "register" allerdings von links nach rechts. Das muss man kompensieren, indem man in jeder Methode der Vtbl die Parameter nach "This" einfach in umgekehrter Reihenfolge deklariert im Vergleich zum C++ Original.

Delphi-Quellcode:

// Aufruf ungefähr so:
var
  P: PCppClass;

P := GetClass();
P^.Vtbl^.method0(0, 0, P, Form1.Handle);  // die "^" kann man sich in neueren Delphi-Versionen auch sparen

[EWeiss]

Ist doch quasi das gleiche wie bei mir.
So wie ich es vorgeschlagen habe.
Von dir jedoch um einiges besser beschrieben

gruss

[SMO]

Zitat von EWeiss:

Ist doch quasi das gleiche wie bei mir.

Ist es das? Sehe ich nicht so (stdcall vs. register), aber vielleicht stehe ich gerade auf dem Schlauch.

Zitat von EWeiss:

Von dir jedoch um einiges besser beschrieben

Danke.

[EWeiss]

Zitat:

Ist es das? Sehe ich nicht so, aber vielleicht stehe ich gerade auf dem Schlauch.

Du hast nur die Dispatch Funktion "link" den er gepostet hat gesehen.

Vielleicht hilft dir das auf die Sprünge.

Delphi-Quellcode:

function ApiService_Dispatch(AMessage: Integer; AReturn: Pointer;
  AParams: PPointerArray; AParamCount: Integer): Integer; stdcall;

Delphi-Quellcode:

  ApiServiceVtbl: TDispatchableVtbl = (Dispatch: ApiService_Dispatch);
  ApiService: TDispatchable = (Vtbl: Addr(ApiServiceVtbl));

Result := LRESULT(Addr(ApiService));

Aber egal

gruss