Endianness erkennen

Ich versuche gerade eine zu erstellen C Quellcode, der I/O unabhängig von der Endianness des Zielsystems richtig handhabt.

Ich habe “Little Endian” als E/A-Konvention ausgewählt, was bedeutet, dass ich für eine Big-Endian-CPU Daten beim Schreiben oder Lesen konvertieren muss.

Konvertierung ist nicht das Problem. Das Problem, dem ich gegenüberstehe, besteht darin, die Endianness zu erkennen, vorzugsweise zur Kompilierzeit (da die CPU die Endianness mitten in der Ausführung nicht ändert …).

Bisher habe ich das hier verwendet:

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
...
#else
...
#endif

Es ist als vordefiniertes GCC-Makro dokumentiert, und Visual scheint es auch zu verstehen.

Ich habe jedoch die Meldung erhalten, dass die Prüfung bei einigen big_endian-Systemen (PowerPC) fehlschlägt.

Ich suche also nach einer narrensicheren Lösung, die sicherstellt, dass Endianess unabhängig vom Compiler und Zielsystem korrekt erkannt wird. naja, die meisten zumindest…

[Edit] : Die meisten der vorgeschlagenen Lösungen beruhen auf “Laufzeittests”. Diese Tests werden unter Umständen von Compilern während der Kompilierung richtig ausgewertet und kosten daher keine wirkliche Laufzeitleistung.

Verzweigung jedoch mit einer Art << if (0) { … } else { … } >> reicht nicht. In der aktuellen Codeimplementierung Variablen und Funktionen Erklärung hängen von der big_endian-Erkennung ab. Diese können nicht mit einer if-Anweisung geändert werden.

Nun, offensichtlich gibt es einen Ausweichplan, der darin besteht, den Code neu zu schreiben …

Ich würde das lieber vermeiden, aber, naja, es sieht nach einer schwindenden Hoffnung aus…

[Edit 2] : Ich habe “Laufzeittests” getestet, indem ich den Code tiefgreifend verändert habe. Obwohl sie ihre Aufgabe korrekt erfüllen, wirken sich diese Tests auch auf die Leistung aus.

Ich hatte erwartet, dass der Compiler fehlerhafte Verzweigungen eliminieren könnte, da die Tests eine vorhersehbare Ausgabe haben. Aber leider funktioniert es nicht immer. MSVC ist ein guter Compiler und eliminiert erfolgreich fehlerhafte Verzweigungen, aber GCC hat gemischte Ergebnisse, je nach Version, Art der Tests und mit größeren Auswirkungen auf 64 Bit als auf 32 Bit.

Es ist komisch. Und es bedeutet auch, dass die Ausführung der Laufzeittests durch den Compiler nicht sichergestellt werden kann.

Bearbeiten 3 : Heutzutage verwende ich eine konstante Vereinigung zur Kompilierzeit und erwarte, dass der Compiler sie zu einem klaren Ja/Nein-Signal löst. Und es funktioniert ziemlich gut:
https://godbolt.org/g/DAafKo

Wie bereits erwähnt, ist die einzige “echte” Möglichkeit, Big Endian zu erkennen, die Verwendung von Laufzeittests.

Manchmal wird jedoch ein Makro bevorzugt.

Leider habe ich keinen einzigen “Test” gefunden, um diese Situation zu erkennen, sondern eine Sammlung davon.

GCC empfiehlt zum Beispiel: __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ . Dies funktioniert jedoch nur mit den neuesten Versionen, und frühere Versionen (und andere Compiler) geben diesem Test einen falschen Wert “true”, da NULL == NULL. Sie benötigen also die vollständigere Version: defined(__BYTE_ORDER__)&&(__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)

OK, jetzt funktioniert das für den neuesten GCC, aber was ist mit anderen Compilern?

Du kannst es versuchen __BIG_ENDIAN__ oder __BIG_ENDIAN oder _BIG_ENDIAN die häufig auf Big-Endian-Compilern definiert werden.

Dadurch wird die Erkennung verbessert. Wenn Sie jedoch speziell auf PowerPC-Plattformen abzielen, können Sie einige weitere Tests hinzufügen, um die Erkennung noch weiter zu verbessern. Versuchen _ARCH_PPC oder __PPC__ oder __PPC oder PPC oder __powerpc__ oder __powerpc oder auch powerpc. Binden Sie alle diese Definitionen zusammen, und Sie haben eine ziemlich gute Chance, Big-Endian-Systeme und insbesondere PowerPC zu erkennen, unabhängig vom Compiler und seiner Version.

Zusammenfassend lässt sich sagen, dass es keine “vordefinierten Standardmakros” gibt, die garantieren, dass Big-Endian-CPUs auf allen Plattformen und Compilern erkannt werden, aber es gibt viele solcher vordefinierten Makros, die zusammengenommen eine hohe Wahrscheinlichkeit ergeben Big Endian unter den meisten Umständen korrekt zu erkennen.

Zur Kompilierzeit in C können Sie nicht viel mehr tun, als dem Präprozessor zu vertrauen #defines, und es gibt keine Standardlösungen, da sich der C-Standard nicht mit Endianness befasst.

Dennoch könnten Sie eine Zusicherung hinzufügen, die zur Laufzeit beim Start des Programms ausgeführt wird, um sicherzustellen, dass die beim Kompilieren getroffene Annahme wahr ist:

inline int IsBigEndian()
{
    int i=1;
    return ! *((char *)&i);
}

/* ... */

#ifdef COMPILED_FOR_BIG_ENDIAN
assert(IsBigEndian());
#elif COMPILED_FOR_LITTLE_ENDIAN
assert(!IsBigEndian());
#else
#error "No endianness macro defined"
#endif

(wo COMPILED_FOR_BIG_ENDIAN und COMPILED_FOR_LITTLE_ENDIAN sind Makros #defined zuvor gemäß Ihren Präprozessor-Endianness-Prüfungen)

Anstatt nach einer Prüfung zur Kompilierzeit zu suchen, warum nicht einfach die Big-Endian-Reihenfolge verwenden (die als “Netzwerkordnung” von vielen) und verwenden Sie die htons/htonl/ntohs/ntohl Funktionen, die von den meisten UNIX-Systemen und Windows bereitgestellt werden. Sie sind bereits für die Arbeit definiert, die Sie zu erledigen versuchen. Warum das Rad neu erfinden?

Versuchen Sie etwas wie:

if(*(char *)(int[]){1}) {
    /* little endian code */
} else {
    /* big endian code */
}

und sehen Sie, ob Ihr Compiler es zur Kompilierzeit auflöst. Wenn nicht, haben Sie vielleicht mehr Glück, wenn Sie dasselbe mit einer Gewerkschaft tun. Eigentlich mag ich es, Makros mit Unions zu definieren, die zu 0,1 oder 1,0 (jeweils) ausgewertet werden, damit ich nur Dinge wie den Zugriff tun kann buf[HI] und buf[LO].

Ungeachtet der vom Compiler definierten Makros gibt es meiner Meinung nach keine Möglichkeit, dies zur Kompilierzeit zu erkennen, da die Bestimmung der Endianness einer Architektur die Analyse der Art und Weise erfordert, in der sie Daten im Speicher speichert.

Hier ist eine Funktion, die genau das tut:

bool IsLittleEndian () {

    int i=1;

    return (int)*((unsigned char *)&i)==1;

}

Wie andere darauf hingewiesen haben, gibt es keine portable Möglichkeit, zur Kompilierungszeit auf Endianness zu prüfen. Eine Möglichkeit wäre jedoch die Verwendung von autoconf Tool als Teil Ihres Build-Skripts, um zu erkennen, ob das System Big-Endian oder Little-Endian ist, und dann das zu verwenden AC_C_BIGENDIAN Makro, das diese Informationen enthält. In gewissem Sinne baut dies ein Programm auf, das zur Laufzeit erkennt, ob das System Big-Endian oder Little-Endian ist, und dann über diese Programmausgabeinformationen verfügt, die dann statisch vom Hauptquellcode verwendet werden können.

Hoffe das hilft!

Das kommt von S. 45 von Zeiger in C:

#include <stdio.h>
#define BIG_ENDIAN 0
#define LITTLE_ENDIAN 1

int endian()
{
   short int word = 0x0001;
   char *byte = (char *) &word;
   return (byte[0] ? LITTLE_ENDIAN : BIG_ENDIAN);
}

int main(int argc, char* argv[])
{
   int value;
   value = endian();
   if (value == 1)
      printf("The machine is Little Endian\n");
   else
      printf("The machine is Big Endian\n");
   return 0;
}