C Macro definition to determine big endian or little endian machine

Question

Is there a one line macro definition to determine the endianness of the machine  I am using the following code but converting it to macro would be too long   unsigned char test endian  void         int test var   1      unsigned char  test endian    unsigned char   amp test var       return  test endian 0     0

User · Answer

If you have a compiler that supports C99 compound literals:

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

or:

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

In general though, you should try to write code that does not depend on the endianness of the host platform.

Example of host-endianness-independent implementation of 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];
}

User · Answer

My answer is not as asked but It is really simple to find if your system is little endian or big endian   Code    include lt stdio h gt   int main       int a   1    char  b     b    char    amp a    if   b      printf  Little Endian n      else     printf  Big Endian n

User · Answer

The  C network library  offers functions to handle endian ness  Namely htons    htonl    ntohs   and ntohl      where n is  network   ie  big-endian  and h is  host   ie  the endian ness of the machine running the code    These apparent  functions  are  commonly  defined as macros  see  lt netinet in h gt    so there is no runtime overhead for using them   The following macros use these  functions  to evaluate endian ness    include  lt arpa inet h gt   define  IS BIG ENDIAN      1    htons 1    define  IS LITTLE ENDIAN    IS BIG ENDIAN    In addition   The only time I ever need to know the endian ness of a system is when I write-out a variable  to a file other  which may be read-in by another system of unknown endian ness  for cross-platform compatability     In cases such as these  you may prefer to use the endian functions directly    include  lt arpa inet h gt    define JPEG MAGIC     J  lt  lt 24      F  lt  lt 16      I  lt  lt 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

User · Answer

Code supporting arbitrary byte orders  ready to be put into a file called order32 h    ifndef ORDER32 H  define ORDER32 H   include  lt limits h gt   include  lt stdint h gt    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   You would check for little endian systems via  O32 HOST ORDER    O32 LITTLE ENDIAN

User · Answer

Don t forget that endianness is not the whole story - the size of char might not be 8 bits  e g  DSP s   two s complement negation is not guaranteed  e g  Cray   strict alignment might be required  e g  SPARC  also ARM springs into middle-endian when unaligned   etc  etc   It might be a better idea to target a specific CPU architecture instead   For example    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     Note that this solution is also not ultra-portable unfortunately  as it depends on compiler-specific definitions  there is no standard  but here s a nice compilation of such definitions

User · Answer

There is no standard  but on many systems including  lt endian h gt  will give you some defines to look for

User · Answer

Macro to find endiannes     define ENDIANNES     1  amp  amp  1    0    printf  Big-Endian   printf  Little-Endian      or   include  lt stdio h gt    define ENDIAN       volatile unsigned long ul   1   volatile unsigned char  p   p    volatile unsigned char    amp 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

User · Answer

You can in fact access the memory of a temporary object by using a compound literal  C99     define IS LITTLE ENDIAN  1      unsigned char    amp  const int  1     Which GCC will evaluate at compile time

User · Answer

Please pay attention that most of the answers here are not portable  since compilers today will evaluate those answers in compilation time  depends on the optimization  and return a specific value based on a specific endianness  while the actual machine endianness can differ  The values on which the endianness is tested  won t never reach the system memory thus the real executed code will return the same result regardless of the actual endianness   For example  in ARM Cortex-M3 the implemented endianness will reflect in a status bit AIRCR ENDIANNESS and compiler cannot know this value in compile time   Compilation output for some of the answers suggested here   https   godbolt org z GJGNE2 for this answer   https   godbolt org z Yv-pyJ for this answer  and so on   To solve it you will need to use the volatile qualifier  Yogeesh H T s answer is the closest one for today s real life usage  but since Christoph suggests more comprehensive solution  a slight fix to his answer would make the answer complete  just add volatile to the union declaration  static const volatile union    This would assure storing and reading from memory  which is needed to determine endianness

User · Answer

If you want to only rely on the preprocessor  you have to figure out the list of predefined symbols  Preprocessor arithmetics has no concept of addressing   GCC on Mac defines   LITTLE ENDIAN   or   BIG ENDIAN      gcc -E -dM -  lt   dev null  grep ENDIAN  define   LITTLE ENDIAN   1   Then  you can add more preprocessor conditional directives based on platform detection like  ifdef  WIN32 etc

User · Answer

If you dump the preprocessor  defines  gcc -dM -E -  lt   dev null g   -dM -E -x c   -  lt   dev null   You can usually find stuff that will help you  With compile time logic    define   LITTLE ENDIAN   1  define   BYTE ORDER     ORDER LITTLE ENDIAN     Various compilers may have different defines however

User · Answer

Use an inline function rather than a macro  Besides  you need to store something in memory which is a not-so-nice side effect of a macro   You could convert it to a short macro using a static or global variable  like this   static int s endianess   0   define ENDIANESS     s endianess   1      unsigned char    amp s endianess     0

User · Answer

I believe this is what was asked for  I only tested this on a little endian machine under msvc  Someone plese confirm on a big endian machine         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   As a side note  compiler specific   with an aggressive compiler you can use  dead code elimination  optimization to achieve the same effect as a compile time  if like so       unsigned yourOwnEndianSpecific htonl unsigned n                static unsigned long signature  0x01020304UL           if  1     unsigned char amp  signature     big endian             return n          if  2     unsigned char amp  signature     the PDP style                       n     n  lt  lt  8   amp  0xFF00FF00UL      n gt  gt 8   amp  0x00FF00FFUL               return n                    if  4     unsigned char amp  signature     little endian                       n    n  lt  lt  16     n  gt  gt  16               n     n  lt  lt  8   amp  0xFF00FF00UL      n gt  gt 8   amp  0x00FF00FFUL               return n                       only weird machines get here         return n               The above relies on the fact that the compiler recognizes the constant values at compile time  entirely removes the code within if  false          and replaces code like if  true    foo      with foo    The worst case scenario  the compiler does not do the optimization  you still get correct code but a bit slower

User · Answer

Whilst there is no portable  define or something to rely upon  platforms do provide standard functions for converting to and from your  host  endian   Generally  you do storage - to disk  or network - using  network endian   which is BIG endian  and local computation using host endian  which on x86 is LITTLE endian    You use htons   and ntohs   and friends to convert between the two

User · Answer

If you are looking for a compile time test and you are using gcc  you can do    if   BYTE ORDER        ORDER LITTLE ENDIAN     See gcc documentation for more information

User · Answer

include  lt stdint h gt   define IS LITTLE ENDIAN    uint16 t    0 1  gt  gt 8   define IS BIG ENDIAN    uint16 t    1 0  gt  gt 8

User · Answer

Try this    include lt stdio h gt          int x 1   define TEST    char   amp  x   1  printf  little endian   printf  Big endian   int main         TEST

User · Answer

To detect endianness at run time  you have to be able to refer to memory   If you stick to standard C  declarating a variable in memory requires a statement  but returning a value requires an expression   I don t know how to do this in a single macro mdash this is why gcc has extensions  -   If you re willing to have a  h file  you can define  static uint32 t endianness   0xdeadbeef   enum endianness   BIG  LITTLE      define ENDIANNESS     const char    amp endianness    0xef   LITTLE                          const char    amp endianness    0xde   BIG                        assert 0     and then you can use the ENDIANNESS macro as you will

User · Answer

C Code for checking whether a system is little-endian or big-indian   int i   7  char  pc    char    amp i   if  pc 0       x7      aliasing through char is ok     puts  This system is little-endian    else     puts  This system is big-endian

[c] C Macro definition to determine big endian or little endian machine?

Examples related to c

Examples related to architecture

Examples related to macros

Examples related to endianness