C-Funktionszeiger-Casting in Void-Zeiger

Question 1

Ich versuche, das folgende Programm auszuführen, bekomme aber einige seltsame Fehler:

Datei 1.c:

typedef unsigned long (*FN_GET_VAL)(void);

FN_GET_VAL gfnPtr;

void setCallback(const void *fnPointer)
{
    gfnPtr = *((FN_GET_VAL*) (&fnPointer));
}

Datei 2.c:

extern FN_GET_VAL gfnPtr;

unsigned long myfunc(void)
{
    return 0;
}

main()
{
   setCallback((void*)myfunc);
   gfnPtr(); /* Crashing as value was not properly 
                assigned in setCallback function */
}

Hier stürzt gfnPtr() auf 64-Bit-Suse-Linux ab, wenn es mit gcc kompiliert wird. Aber es ruft erfolgreich gfnPtr() VC6 und SunOS auf.

Aber wenn ich die Funktion wie unten angegeben ändere, funktioniert es erfolgreich.

void setCallback(const void *fnPointer)
{
    int i; // put any statement here
    gfnPtr = *((FN_GET_VAL*) (&fnPointer));
}

Bitte helfen Sie bei der Problemursache. Vielen Dank.

Question 2

Der C-Standard erlaubt es nicht, auf Funktionszeiger umzuwandeln void*. Sie können nur in einen anderen Funktionszeigertyp umwandeln. In dem C11-Standard, 6.3.2.3 §8:

Ein Zeiger auf eine Funktion eines Typs kann in einen Zeiger auf eine Funktion eines anderen Typs umgewandelt werden und wieder zurück

Wichtig ist, dass Sie auf den ursprünglichen Typ zurücksetzen müssen, bevor Sie den Zeiger verwenden, um die Funktion aufzurufen (technisch gesehen auf einen kompatiblen Typ. Definition von “kompatibel” bei 6.2.7).

Beachten Sie, dass der POSIX-Standard, dem viele (aber nicht alle) C-Compiler aufgrund des Kontexts, in dem sie verwendet werden, ebenfalls folgen müssen, vorschreibt, dass ein Funktionszeiger konvertiert werden kann void* und zurück. Dies ist für einige Systemfunktionen erforderlich (z dlsym).

Question 3

Der Standard erlaubt leider kein Casting zwischen Datenzeigern und Funktionszeigern (weil das auf einigen wirklich obskuren Plattformen keinen Sinn machen könnte), obwohl POSIX und andere solche Casts erfordern. Eine Problemumgehung besteht darin, den Zeiger nicht umzuwandeln, sondern einen Zeiger auf den Zeiger umzuwandeln (dies ist für den Compiler in Ordnung und wird die Arbeit auf allen normalen Plattformen erledigen).

typedef void (*FPtr)(void); // Hide the ugliness
FPtr f = someFunc;          // Function pointer to convert
void* ptr = *(void**)(&f);  // Data pointer
FPtr f2 = *(FPtr*)(&ptr);   // Function pointer restored

Question 4

Ich habe drei Faustregeln, wenn es um Datenzeiger und Codezeiger geht:

Tun nicht Mischen Sie Datenzeiger und Codezeiger

Unterlassen Sie mischen Datenzeiger und Codezeiger
Unterlassen Sie je Mischen Sie Datenzeiger und Codezeiger!

In der folgenden Funktion:

void setCallback(const void *fnPointer)
{
    gfnPtr = *((FN_GET_VAL*) (&fnPointer));
}

Du hast ein Datenzeiger dass Sie Fall zu einem Funktionszeiger. (Ganz zu schweigen davon, dass Sie dies tun, indem Sie zuerst die Adresse des Zeigers selbst nehmen, ihn in einen Zeiger auf einen Zeiger umwandeln, bevor Sie ihn dereferenzieren).

Versuchen Sie es umzuschreiben als:

void setCallback(FN_GET_VAL fnPointer)
{
     gfnPtr = fnPointer;
}

Außerdem können (oder sollten) Sie die Besetzung fallen lassen, wenn Sie den Zeiger setzen:

main()
{
   setCallback(myfunc);
   gfnPtr();
}

Als zusätzlichen Bonus können Sie jetzt die normalen Typprüfungen verwenden, die vom Compiler durchgeführt werden.

Question 5

Ich werde eine mögliche vorschlagen teilweise Erläuterung.

@Manoj Wenn Sie die von beiden Compilern generierte Assemblyliste für SetCallback untersuchen (oder bereitstellen können), können wir eine endgültige Antwort erhalten.

Erstens stimmen die Aussagen von Pascal Couq, und Lindydancer zeigt, wie man den Callback richtig setzt. Meine Antwort ist nur ein Versuch, das eigentliche Problem zu erklären.

Ich denke, das Problem rührt von der Tatsache her, dass Linux und die andere Plattform unterschiedliche 64-Bit-Modelle verwenden (siehe 64-Bit-Modelle auf Wikipedia). Beachten Sie, dass Linux LP64 verwendet (int ist 32 Bit). Wir brauchen mehr Details auf der anderen Plattform. Wenn es SPARC64 ist, verwendet es ILP64 (int ist 64 Bit).

Wie ich Sie verstehe, wurde das Problem nur unter Linux beobachtet und verschwand, wenn Sie eine lokale Variable int einführten. Haben Sie dies mit deaktivierten oder aktivierten Optimierungen versucht? Höchstwahrscheinlich hätte dieser Hack keine positiven Auswirkungen mit eingeschalteten Optimierungen.

Bei beiden 64-Bit-Modellen sollten Zeiger 64-Bit sein, unabhängig davon, ob sie auf Code oder Daten zeigen. Es ist jedoch möglich, dass dies nicht der Fall wäre (z. B. segmentierte Speichermodelle); daher die Ermahnungen von Pascal und Lindydancer.

Wenn die Zeiger die gleiche Größe haben, bleibt ein mögliches Stapelausrichtungsproblem. Die Einführung eines lokalen int (das unter Linux 32 Bit ist) könnte die Ausrichtung ändern. Dies würde sich nur auswirken, wenn void*- und Funktionszeiger unterschiedliche Ausrichtungsanforderungen haben. Ein zweifelhaftes Szenario.

Dennoch sind die unterschiedlichen 64-Bit-Speichermodelle höchstwahrscheinlich die Ursache für das, was Sie beobachtet haben. Gerne können Sie uns die Bestückungslisten zur Analyse zur Verfügung stellen.

Question 6

Im Gegensatz zu dem, was andere sagen, ja, Sie können einen haben void* Zeiger als Funktionszeiger, aber die Semantik ist sehr schwierig, ihn damit zu verwenden.

Wie Sie sehen können, müssen Sie es nicht als umwandeln void*, weisen Sie es einfach wie gewohnt zu. Ich habe Ihren Code so ausgeführt und bearbeitet, damit er funktioniert.

Datei1.c:

typedef unsigned long (*FN_GET_VAL)(void);

extern FN_GET_VAL gfnPtr;

void setCallback(const void *fnPointer)
{
    gfnPtr = ((FN_GET_VAL) fnPointer);
}

Datei2.c:

int main(void)
{
    setCallback(myfunc);
    (( unsigned long(*)(void) )gfnPtr)();
}