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

Existe-t-il une définition de macro sur une ligne pour déterminer l'endianité 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);
}

Code prenant en charge les 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 vérifieriez les systèmes little endian via

O32_HOST_ORDER == O32_LITTLE_ENDIAN

Si vous avez un compilateur qui prend en charge 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'endianness de la plate-forme hôte.

Exemple d'implémentation indépendante de l'hôte-endianness de 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];
}

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

Pour détecter l'endianness au moment de l'exécution, vous devez pouvoir vous référer à la mémoire. Si vous vous en tenez au standard C, 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 souhaitez 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))

puis vous pouvez utiliser la ENDIANNESSmacro comme vous le souhaitez.

Si vous voulez vous fier uniquement au 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.

GCC sur Mac définit __LITTLE_ENDIAN__ou__BIG_ENDIAN__

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

Ensuite, vous pouvez ajouter plus de directives conditionnelles de préprocesseur basées sur la détection de plate-forme comme #ifdef _WIN32etc.

Je crois que c'est ce qui a été demandé. Je n'ai testé cela que sur une petite machine endian sous msvc. Quelqu'un peut confirmer sur une machine big endian.

    #define LITTLE_ENDIAN 0x41424344UL 
    #define BIG_ENDIAN    0x44434241UL
    #define PDP_ENDIAN    0x42414443UL
    #define ENDIAN_ORDER  ('ABCD') 

    #if ENDIAN_ORDER==LITTLE_ENDIAN
        #error "machine is little endian"
    #elif ENDIAN_ORDER==BIG_ENDIAN
        #error "machine is big endian"
    #elif ENDIAN_ORDER==PDP_ENDIAN
        #error "jeez, machine is PDP!"
    #else
        #error "What kind of hardware is this?!"
    #endif

En remarque (spécifique au compilateur), avec un compilateur agressif, vous pouvez utiliser l'optimisation "d'élimination de code mort" pour obtenir le même effet qu'un temps de compilation #ifcomme ceci:

    unsigned yourOwnEndianSpecific_htonl(unsigned n)
    {
        static unsigned long signature= 0x01020304UL; 
        if (1 == (unsigned char&)signature) // big endian
            return n;
        if (2 == (unsigned char&)signature) // the PDP style
        {
            n = ((n << 8) & 0xFF00FF00UL) | ((n>>8) & 0x00FF00FFUL);
            return n;
        }
        if (4 == (unsigned char&)signature) // little endian
        {
            n = (n << 16) | (n >> 16);
            n = ((n << 8) & 0xFF00FF00UL) | ((n>>8) & 0x00FF00FFUL);
            return n;
        }
        // only weird machines get here
        return n; // ?
    }

Ce qui précède repose sur le fait que le compilateur reconnaît les valeurs constantes au moment de la compilation, supprime entièrement le code à l'intérieur if (false) { ... }et remplace le code comme if (true) { foo(); }avec foo();Le pire des cas: le compilateur ne fait pas l'optimisation, vous obtenez toujours du code correct mais un peu plus lent.

Si vous recherchez un test de compilation et que vous utilisez gcc, vous pouvez faire:

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

Consultez la documentation de gcc pour plus d'informations.

Vous pouvez en effet accéder à la mémoire d'un objet temporaire en utilisant un littéral composé (C99):

#define IS_LITTLE_ENDIAN (1 == *(unsigned char *)&(const int){1})

Quel GCC évaluera au moment de la compilation.

La 'bibliothèque réseau C' offre des fonctions pour gérer l'endian'ness. A savoir htons (), htonl (), ntohs () et ntohl () ... où n est "network" (ie. Big-endian) et h est "host" (ie. Endian'ness de la machine exécutant le code).

Ces «fonctions» apparentes sont (généralement) définies comme des macros [voir <netinet / in.h>], il n'y a donc pas de surcharge d'exécution pour les utiliser.

Les macros suivantes utilisent ces 'fonctions' pour évaluer l'endian'ness.

#include <arpa/inet.h>
#define  IS_BIG_ENDIAN     (1 == htons(1))
#define  IS_LITTLE_ENDIAN  (!IS_BIG_ENDIAN)

En outre:

La seule fois où j'ai besoin de connaître le caractère endian d'un système, c'est lorsque j'écris une variable [dans un fichier / autre] qui peut être lue par un autre système dont le caractère endian est inconnu (pour une compatibilité multiplateforme ) ... Dans de tels cas, vous préférerez peut-être utiliser directement les fonctions endian:

#include <arpa/inet.h>

#define JPEG_MAGIC  (('J'<<24) | ('F'<<16) | ('I'<<8) | 'F')

// Result will be in 'host' byte-order
unsigned long  jpeg_magic = JPEG_MAGIC;

// Result will be in 'network' byte-order (IE. Big-Endian/Human-Readable)
unsigned long  jpeg_magic = htonl(JPEG_MAGIC);

Utilisez une fonction en ligne plutôt qu'une macro. De plus, vous devez stocker quelque chose en mémoire, ce qui est un effet secondaire pas très agréable d'une macro.

Vous pouvez le convertir en une macro courte en utilisant une variable statique ou globale, comme ceci:

static int s_endianess = 0;
#define ENDIANESS() ((s_endianess = 1), (*(unsigned char*) &s_endianess) == 0)

Bien qu'il n'y ait pas de #define portable ou quelque chose sur lequel s'appuyer, les plates-formes fournissent des fonctions standard pour la conversion vers et depuis votre endian «hôte».

En règle générale, vous effectuez le stockage - sur disque ou réseau - en utilisant 'network endian', ce qui est BIG endian, et le calcul local en utilisant host endian (qui sur x86 est LITTLE endian). Vous utilisez htons()et ntohs()et vos amis pour convertir entre les deux.

#include <stdint.h>
#define IS_LITTLE_ENDIAN (*(uint16_t*)"\0\1">>8)
#define IS_BIG_ENDIAN (*(uint16_t*)"\1\0">>8)

N'oubliez pas que l'endianness n'est pas toute l'histoire - la taille de charpeut ne pas être de 8 bits (par exemple DSP), la négation du complément à deux n'est pas garantie (par exemple Cray), un alignement strict peut être requis (par exemple, SPARC, ARM passe également au milieu -endian lorsqu'il pas aligné), etc., etc.

Il pourrait être préférable de cibler une architecture de processeur spécifique place.

Par exemple:

#if defined(__i386__) || defined(_M_IX86) || defined(_M_IX64)
  #define USE_LITTLE_ENDIAN_IMPL
#endif

void my_func()
{
#ifdef USE_LITTLE_ENDIAN_IMPL
  // Intel x86-optimized, LE implementation
#else
  // slow but safe implementation
#endif
}

Notez que cette solution n'est malheureusement pas non plus ultra-portable, car elle dépend de définitions spécifiques au compilateur (il n'y a pas de standard, mais voici une belle compilation de ces définitions).

Essaye ça:

#include<stdio.h>        
int x=1;
#define TEST (*(char*)&(x)==1)?printf("little endian"):printf("Big endian")
int main()
{

   TEST;
}

Veuillez faire attention que la plupart des réponses ici ne sont pas portables, car les compilateurs aujourd'hui évalueront ces réponses au moment de la compilation (dépend de l'optimisation) et retourneront une valeur spécifique basée sur une endianité spécifique, alors que l'endianité réelle de la machine peut différer. Les valeurs sur lesquelles l'endianité est testée n'atteindront jamais la mémoire système, donc le code réel exécuté renverra le même résultat quelle que soit l'endianité réelle.

Par exemple , dans ARM Cortex-M3, l'endianness implémentée se reflétera dans un bit d'état AIRCR.ENDIANNESS et le compilateur ne peut pas connaître cette valeur au moment de la compilation.

Sortie de compilation pour certaines des réponses suggérées ici:

https://godbolt.org/z/GJGNE2 pour cette réponse,

https://godbolt.org/z/Yv-pyJ pour cela réponse, et ainsi de suite.

Pour le résoudre, vous devrez utiliser le volatilequalificatif. Yogeesh H T« s réponse est le plus proche de l' utilisation réelle de la vie d'aujourd'hui, mais comme Christophsuggère une solution plus complète, une légère correction à sa réponse serait la réponse complète, il suffit d' ajouter volatileà la déclaration syndicale: static const volatile union.

Cela assurerait le stockage et la lecture à partir de la mémoire, ce qui est nécessaire pour déterminer l'endianité.

Si vous videz le préprocesseur #defines

gcc -dM -E - < /dev/null
g++ -dM -E -x c++ - < /dev/null

Vous pouvez généralement trouver des choses qui vous aideront. Avec une logique de compilation.

#define __LITTLE_ENDIAN__ 1
#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__

Cependant, divers compilateurs peuvent avoir des définitions différentes.

Ma réponse n'est pas celle demandée mais il est vraiment simple de trouver si votre système est petit ou gros boutien?

Code:

#include<stdio.h>

int main()
{
  int a = 1;
  char *b;

  b = (char *)&a;
  if (*b)
    printf("Little Endian\n");
  else
    printf("Big Endian\n");
}

C Code pour vérifier si un système est petit-boutiste ou grand-indien.

int i = 7;
char* pc = (char*)(&i);
if (pc[0] == '\x7') // aliasing through char is ok
    puts("This system is little-endian");
else
    puts("This system is big-endian");

Macro pour trouver des endiannes

#define ENDIANNES() ((1 && 1 == 0) ? printf("Big-Endian"):printf("Little-Endian"))

ou

#include <stdio.h>

#define ENDIAN() { \
volatile unsigned long ul = 1;\
volatile unsigned char *p;\
p = (volatile unsigned char *)&ul;\
if (*p == 1)\
puts("Little endian.");\
else if (*(p+(sizeof(unsigned long)-1)) == 1)\
puts("Big endian.");\
else puts("Unknown endian.");\
}

int main(void) 
{
       ENDIAN();
       return 0;
}