C Definizione di macro per determinare la macchina big endian o little endian?

Esiste una definizione di macro di una riga per determinare l'endianità della macchina. Sto usando il seguente codice ma convertirlo in macro sarebbe troppo lungo.

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

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

Codice che supporta ordini di byte arbitrari, pronto per essere inserito in un file chiamato 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

Dovresti controllare i sistemi little endian tramite

O32_HOST_ORDER == O32_LITTLE_ENDIAN

Se hai un compilatore che supporta i letterali composti C99:

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

o:

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

In generale, però, dovresti provare a scrivere codice che non dipenda dall'endianità della piattaforma host.

Esempio di implementazione indipendente dall'host endian di 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];
}

Non esiste uno standard, ma su molti sistemi incluso <endian.h>ti fornirà alcune definizioni da cercare.

Per rilevare endianness in fase di esecuzione, devi essere in grado di fare riferimento alla memoria. Se ti attieni allo standard C, la dichiarazione di una variabile in memoria richiede un'istruzione, ma la restituzione di un valore richiede un'espressione. Non so come farlo in una singola macro: questo è il motivo per cui gcc ha estensioni :-)

Se desideri avere un file .h, puoi definire

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

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

e poi puoi usare la ENDIANNESSmacro come preferisci.

Se vuoi fare affidamento solo sul preprocessore, devi capire l'elenco dei simboli predefiniti. L'aritmetica del preprocessore non ha il concetto di indirizzamento.

GCC su Mac definisce __LITTLE_ENDIAN__o__BIG_ENDIAN__

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

Quindi, puoi aggiungere più direttive condizionali del preprocessore basate sul rilevamento della piattaforma come #ifdef _WIN32ecc.

Credo che questo sia ciò che è stato chiesto. L'ho provato solo su una piccola macchina endian sotto msvc. Qualcuno può confermare su una macchina 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

Come nota a margine (specifica del compilatore), con un compilatore aggressivo puoi usare l'ottimizzazione "eliminazione codice morto" per ottenere lo stesso effetto di un tempo di compilazione #ifcome questo:

    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; // ?
    }

Quanto sopra si basa sul fatto che il compilatore riconosce i valori costanti in fase di compilazione, rimuove completamente il codice all'interno if (false) { ... }e lo sostituisce come if (true) { foo(); }con foo();Lo scenario peggiore: il compilatore non esegue l'ottimizzazione, si ottiene comunque il codice corretto ma un po 'più lento.

Se stai cercando un test in fase di compilazione e stai usando gcc, puoi fare:

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

Vedere la documentazione di gcc per ulteriori informazioni.

È possibile nell'accesso infatti il ricordo di un oggetto temporaneo utilizzando un letterale composto (C99):

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

Quale GCC valuterà in fase di compilazione.

La 'libreria di rete C' offre funzioni per gestire endian'ness. Vale a dire htons (), htonl (), ntohs () e ntohl () ... dove n è "network" (cioè big-endian) e h è "host" (cioè l'endianità della macchina che esegue il codice).

Queste apparenti 'funzioni' sono (comunemente) definite come macro [vedere <netinet / in.h>], quindi non c'è alcun sovraccarico di runtime per usarle.

Le seguenti macro usano queste 'funzioni' per valutare endian'ness.

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

Inoltre:

L'unica volta che ho bisogno di conoscere l'endianità di un sistemaèquando scrivo una variabile [in un file / altro] che può essere letta da un altro sistema di endianità sconosciuta (per compatibilità multipiattaforma ) ... In casi come questi, potresti preferire utilizzare direttamente le funzioni 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);

Usa una funzione inline piuttosto che una macro. Inoltre, è necessario memorizzare qualcosa in memoria che è un effetto collaterale non così piacevole di una macro.

Puoi convertirlo in una breve macro utilizzando una variabile statica o globale, come questa:

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

Sebbene non ci sia un #define portatile o qualcosa su cui fare affidamento, le piattaforme forniscono funzioni standard per la conversione da e verso il tuo endian 'host'.

Generalmente, fai l'archiviazione - su disco o in rete - usando 'network endian', che è BIG endian, e il calcolo locale usando host endian (che su x86 è LITTLE endian). Usi htons()e ntohs()e gli amici per convertire tra i due.

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

Non dimenticare che endianness non è l'intera storia: la dimensione di charpotrebbe non essere 8 bit (ad esempio DSP), la negazione del complemento a due non è garantita (ad esempio Cray), potrebbe essere richiesto un allineamento rigoroso (ad esempio SPARC, anche ARM balza al centro -endian quando non allineato), ecc. ecc.

Potrebbe essere un'idea migliore invece indirizzare una specifica architettura della CPU .

Per esempio:

#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
}

Si noti che questa soluzione non è purtroppo ultraportatile, poiché dipende dalle definizioni specifiche del compilatore (non esiste uno standard, ma ecco una bella raccolta di tali definizioni).

Prova questo:

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

   TEST;
}

Si prega di prestare attenzione che la maggior parte delle risposte qui non sono portabili, poiché i compilatori oggi valuteranno quelle risposte in tempo di compilazione (dipende dall'ottimizzazione) e restituiranno un valore specifico basato su uno specifico endianness, mentre l'effettivo endianness della macchina può differire. I valori su cui viene testato l'endianness, non raggiungeranno mai la memoria di sistema quindi il codice reale eseguito restituirà lo stesso risultato indipendentemente dall'endianness effettivo.

Ad esempio , in ARM Cortex-M3 l'endianness implementato si rifletterà in un bit di stato AIRCR.ENDIANNESS e il compilatore non può conoscere questo valore in fase di compilazione.

Risultato della compilazione per alcune delle risposte suggerite qui:

https://godbolt.org/z/GJGNE2 per questa risposta,

https://godbolt.org/z/Yv-pyJ per questa risposta e così via.

Per risolverlo dovrai usare il volatilequalificatore. Yogeesh H T's risposta è quello più vicino per l'utilizzo di vita reale di oggi, ma dal momento che Christophsuggerisce la soluzione più completa, una lieve correzione al suo risposta sarebbe la risposta completa, basta aggiungere volatilela dichiarazione dell'Unione: static const volatile union.

Ciò assicurerebbe l'archiviazione e la lettura dalla memoria, che è necessaria per determinare l'endianness.

Se esegui il dump del preprocessore #defines

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

Di solito puoi trovare cose che ti aiuteranno. Con logica del tempo di compilazione.

#define __LITTLE_ENDIAN__ 1
#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__

Tuttavia, vari compilatori possono avere definizioni diverse.

La mia risposta non è come chiesto ma è davvero semplice scoprire se il tuo sistema è little endian o big endian?

Codice:

#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 Codice per verificare se un sistema è little-endian o big-indian.

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 per trovare endiannes

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

o

#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;
}