🚀 go-pugleaf

Hi,

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()

Was ich vorschlage ist ein Versuch, ohne es getestet zu haben (ich sehe
eigentlich keinen Grund, heutzutage Assembler zu scheiben: es ist
ungeheuer kompliziert einen modernen Prozessor effizient in Assembler
zu programmieren; der Compiler erzeugt fast immer besseren Code,
insbesondere, falls es sich um einen RISC-Processor handelt):
Deklariere diese Funktion einfach 'extern "C"'. Man kann auch C++
Funktionen 'extern "C"' deklarieren. Genauer gesagt, MUSS man
Funktionen 'extern "C"' dekarieren, wenn man sie von C aus aufrufen
will. Das gilt auch, wenn man versucht poortable zu schreiben, wenn man
Funktionpointer verwendet (da geht es bei vielen Compilern auch, wenn
man das 'extern "C"' weglaesst). Dannach solltest Du die Funktion
genauso aufrufen koennen, als wenn es eine C Funktion waere.
--
dietmar.kuehl@uni-konstanz.de
http://www.informatik.uni-konstanz.de/~kuehl
I am a realistic optimist - that's why I appear to be slightly pessimistic

Am 12. Jan. 1996 schrieb ILT-Benutzer (user@ilt.fhg.de):

> 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 ?

Die Antwort ist sehr einfach: Auch in diesem Fall muß die Funktion im
C++-Modul als  extern "C"  deklariert werden.

	// C++-Modul:
	extern "C" void CProzedur()
	{
	    ...
	}

Der Assemblermodul bleibt unverändert.


Karl-Heinz Krause

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.

ILT-Benutzer <user@ilt.fhg.de> wrote:

>Ich habe da ein vermutlich einfaches Problem.

>Ich habe ein Projekt geschrieben, in dem ein C++ Modul und ein Assembler
>Modul vorkommen. Das C++ Modul soll eine Assemblerfunktion aufrufen koennen.
>Das klappt auch, wenn ich im C++ Modul sage:
[...]
>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()
>{

Versuchs mit 
extern "C" void CProcedur()

>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?

Der C++-Compiler nimmt die Typinformation in seine zum Linken
verwendeten F'nsnamen mit auf (damit overloading möglich wird). Das
extern "C" verhindert das.

Joachim




"... ein Geschlecht erfinderischer Zwerge, die fuer alles gemietet werden 
koennen."                       - Bertolt Brecht - Das Leben des Gallilei