🚀 go-pugleaf

ILT-Benutzer <user@ilt.fhg.de> wrote:
>Nun muss ich aber auch das ganze umgekehrt haben, d.h. das Assemblermodul
>soll eine C++ Funktion aufrufen.

>Ich habe ausprobiert:
>Im C++ Modul:
>--------------------------------------
>..
>void CProzedur()
>{
> ...
>}
>..
>--------------------------------------

>und im Assemblermodul:
>--------------------------------------
>..
>extrn _CProzedur:far
>..
>..
>call _CProzedur  ; die CRoutine aufrufen
>--------------------------------------

>Dieses funktioniert fuer einfache C Module ohne Probleme.
>Sobald ich aber diesen Schalter Options|Compiler|C++options auf
>CPP always stelle (was ich muss) geht's nicht mehr.
>Ich muss also dem Assembler irgendwie mitteilen, dass es sich
>um ein C++ Modul handelt. Hast jemand 'ne Ahnung wie das gemacht wird ?

Hmm, Dein Problem dürfte daran liegen, daß C++ sogenanntes
Name-Mangling macht. Das hat vor allem mit Typerkennung und über-
ladenen Funktionen zu tun. Wenn Du z.B. eine Funktion

int foo(int IntPar) {...}

und eine andere

int foo(char *StringPar) {...}

hast, was ja unter C++ möglich ist, muß der Compiler/Linker wissen, wie er diese
unterscheidet. Wie er das macht, ist in keinem Standard festgelegt - da kocht
jeder Compilerbauer sein eigenes Süppchen. In den meisten Fällern werden
irgendwelche kryptische Zeichen um den eigentlichen Namen herum gruppiert, so
könnte irgendein Compiler aus den beiden "foos" oben machen:

foo@i

sowie

foo@pc

oder sonstwie - wie gesagt, NICHT STANDARDISIERT  und der Willkür des
Compilerbauers überlassen.

Wie löst das nun Dein Problem? 

Du mußt herausbekommen, wie Dein spezieller Compiler sein Name-Mangling macht.
Die einfachste Möglichkeit ist die, daß Du Dir in C++ eine Dummy-Funktion mit
dem gewünschten Namen, Returntyp und allen gewünschten Parametern schreibst und
- die meisten Compiler können das - Dir daraus eine ASM-Source generieren läßt.
Dann hast Du nicht nur den korrekten gemangleten Namen, sondern quasi als
kostenlose Draufgabe auch alle Standard-Alllocations von Stack, Groups,
Segment-Namen, Prolog, Epilog und was dergleichen mehr ist. In diesen Rumpf
brauchst Du dann nur mehr den Code einbauen, wie Du ihn haben möchtest.
Funktioniert prächtig und vermeidet einige sonst sehr schwer entdeckbare Fehler
(wenn Dein Compiler z.B. return-Werte anders zurückerwartet als der normale
Verstand es annehmen sollte).

In Deinem konkreten Fall würde es allerdings reichen, den korrekten Namen zu
wissen. Dennoch würde ich Dir empfehlen. ASM-Funktionen auf die beschriebene Art
zu generieren und Dir das "extern "C" " zu ersparen. Es könnte umgekehrt auch
hilfreich sein, an Hand einer derartigen Dummy-Source festzustellen, wie Dein
C++ Deine gewünschte CProcedure aufrufen würde.