Définition de la macro C pour déterminer la machine big endian ou little endian ?

Question

Existe-t-il une macro de définition d'une ligne pour déterminer l'endiannité de la machine ? J'utilise le code suivant mais le convertir en macro serait trop long.

unsigned char test_endian( void )
{
    int test_var = 1;
    unsigned char *test_endian = (unsigned char*)&test_var;

    return (test_endian[0] == 0);
}

Answer 1

Code supportant des ordres d'octets arbitraires, prêt à être placé dans un fichier appelé order32.h :

#ifndef ORDER32_H
#define ORDER32_H

#include <limits.h>
#include <stdint.h>

#if CHAR_BIT != 8
#error "unsupported char size"
#endif

enum
{
    O32_LITTLE_ENDIAN = 0x03020100ul,
    O32_BIG_ENDIAN = 0x00010203ul,
    O32_PDP_ENDIAN = 0x01000302ul,      /* DEC PDP-11 (aka ENDIAN_LITTLE_WORD) */
    O32_HONEYWELL_ENDIAN = 0x02030001ul /* Honeywell 316 (aka ENDIAN_BIG_WORD) */
};

static const union { unsigned char bytes[4]; uint32_t value; } o32_host_order =
    { { 0, 1, 2, 3 } };

#define O32_HOST_ORDER (o32_host_order.value)

#endif

Vous pouvez vérifier les systèmes little endian via

O32_HOST_ORDER == O32_LITTLE_ENDIAN

Answer 2

Si vous avez un compilateur qui supporte les littéraux composés C99 :

#define IS_BIG_ENDIAN (!*(unsigned char *)&(uint16_t){1})

ou :

#define IS_BIG_ENDIAN (!(union { uint16_t u16; unsigned char c; }){ .u16 = 1 }.c)

En général, cependant, vous devriez essayer d'écrire du code qui ne dépend pas de l'endive de la plate-forme hôte.

---

Exemple d'une mise en œuvre indépendante de l'endianisme de l'hôte de l'application ntohl() :

uint32_t ntohl(uint32_t n)
{
    unsigned char *np = (unsigned char *)&n;

    return ((uint32_t)np[0] << 24) |
        ((uint32_t)np[1] << 16) |
        ((uint32_t)np[2] << 8) |
        (uint32_t)np[3];
}

Answer 3

Il n'existe pas de norme, mais sur de nombreux systèmes, notamment <endian.h> vous donnera quelques définitions à rechercher.

Answer 4

Pour détecter l'endiveté au moment de l'exécution, il faut pouvoir faire référence à la mémoire. Si vous vous en tenez au C standard, la déclaration d'une variable en mémoire nécessite une instruction, mais le retour d'une valeur nécessite une expression. Je ne sais pas comment faire cela dans une seule macro - c'est pourquoi gcc a des extensions :-)

Si vous êtes prêt à avoir un fichier .h, vous pouvez définir

static uint32_t endianness = 0xdeadbeef; 
enum endianness { BIG, LITTLE };

#define ENDIANNESS ( *(const char *)&endianness == 0xef ? LITTLE \
                   : *(const char *)&endianness == 0xde ? BIG \
                   : assert(0))

et ensuite vous pouvez utiliser le ENDIANNESS macro comme vous le souhaitez.

Answer 5

Si vous voulez vous reposer uniquement sur le préprocesseur, vous devez trouver la liste des symboles prédéfinis. L'arithmétique du préprocesseur n'a pas de concept d'adressage.

CCG sur Mac définit __LITTLE_ENDIAN__ o __BIG_ENDIAN__

$ gcc -E -dM - < /dev/null |grep ENDIAN
#define __LITTLE_ENDIAN__ 1

Ensuite, vous pouvez ajouter d'autres directives conditionnelles du préprocesseur basées sur la détection de la plate-forme comme #ifdef _WIN32 etc.