C 빅 엔디안 또는 리틀 엔디안 머신을 결정하는 매크로 정의?

기계의 엔디안을 결정하는 한 줄 매크로 정의가 있습니까? 다음 코드를 사용하고 있지만 매크로로 변환하면 너무 길어집니다.

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

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

임의의 바이트 순서를 지원하는 코드로 다음과 같은 파일에 넣을 준비가되었습니다 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

다음을 통해 리틀 엔디안 시스템을 확인합니다.

O32_HOST_ORDER == O32_LITTLE_ENDIAN

C99 복합 리터럴을 지원하는 컴파일러가있는 경우 :

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

또는:

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

그러나 일반적으로 호스트 플랫폼의 엔디안에 의존하지 않는 코드를 작성해야합니다.

호스트 엔디안 독립 구현 예 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];
}

표준 <endian.h>은 없지만를 포함한 많은 시스템 에서 찾을 수있는 몇 가지 정의를 제공합니다.

런타임에 엔디안을 감지하려면 메모리를 참조 할 수 있어야합니다. 표준 C를 고수하는 경우 메모리에서 변수를 선언하려면 문이 필요하지만 값을 반환하려면식이 필요합니다. 단일 매크로에서이 작업을 수행하는 방법을 모르겠습니다. 이것이 gcc에 확장자가있는 이유입니다. :-)

.h 파일을 갖고 싶다면 다음을 정의 할 수 있습니다.

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

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

그런 다음 원하는대로 ENDIANNESS매크로를 사용할 수 있습니다 .

전처리기에 만 의존하려면 미리 정의 된 기호 목록을 찾아야합니다. 전 처리기 산술에는 주소 지정 개념이 없습니다.

Mac의 GCC 는 __LITTLE_ENDIAN__또는__BIG_ENDIAN__

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

그런 다음 #ifdef _WIN32등 플랫폼 감지를 기반으로 더 많은 전 처리기 조건 지시문을 추가 할 수 있습니다 .

나는 이것이 요구 된 것이라고 믿는다. 나는 msvc 아래의 little 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

부수적으로 (컴파일러 별), 공격적인 컴파일러를 사용하면 "데드 코드 제거"최적화를 사용하여 다음과 같은 컴파일 시간 #if과 동일한 효과를 얻을 수 있습니다.

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

위는 완전히 내 코드를 제거, 컴파일러는 컴파일시에 상수 값을 인식한다는 사실에 의존 if (false) { ... }와 같은 대체합니다 코드 if (true) { foo(); }와 foo();최악의 시나리오 : 최적화를하지 않는 컴파일러는, 당신은 여전히 약간 느린 올바른 코드 만 얻을.

컴파일 시간 테스트를 찾고 있고 gcc를 사용하는 경우 다음을 수행 할 수 있습니다.

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

자세한 정보는 gcc 문서 를 참조하십시오.

실제로 복합 리터럴 (C99)을 사용하여 임시 개체의 메모리에 액세스 할 수 있습니다 .

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

컴파일 타임에 평가할 GCC.

'C 네트워크 라이브러리'는 엔디안을 처리하는 기능을 제공합니다. 즉, htons (), htonl (), ntohs () 및 ntohl () ... 여기서 n은 "network"(즉, big-endian)이고 h는 "host"(즉, 암호).

이러한 명백한 '함수'는 (일반적으로) 매크로로 정의되므로 [<netinet / in.h> 참조], 사용에 대한 런타임 오버 헤드가 없습니다.

다음 매크로는 이러한 '함수'를 사용하여 엔디안을 평가합니다.

#include <arpa/inet.h>
#define  IS_BIG_ENDIAN     (1 == htons(1))
#define  IS_LITTLE_ENDIAN  (!IS_BIG_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);

매크로보다는 인라인 함수를 사용하십시오. 게다가 매크로의 좋지 않은 부작용 인 메모리에 무언가를 저장해야합니다.

다음과 같이 정적 또는 전역 변수를 사용하여 짧은 매크로로 변환 할 수 있습니다.

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

이식 가능한 #define 또는 의존 할 것이 없지만 플랫폼은 '호스트'엔디안으로 /에서 변환하는 표준 기능을 제공합니다.

일반적으로 BIG 엔디안 인 '네트워크 엔디안'을 사용하여 디스크 또는 네트워크로 스토리지를 수행 하고 호스트 엔디안 (x86에서는 LITTLE 엔디안)을 사용하여 로컬 계산을 수행합니다 . htons()및 ntohs()및 친구를 사용 하여 둘 사이를 변환합니다.

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

엔디안이 전체 이야기가 아니라는 점을 잊지 마십시오. 크기 char가 8 비트 (예 : DSP)가 아닐 수도 있고, 2의 보수 부정이 보장되지 않을 수 있으며 (예 : Cray), 엄격한 정렬이 필요할 수 있습니다 (예 : SPARC, ARM도 중간으로 스프링). - 정렬되지 않은 경우 엔디안 ) 등

특정 CPU 아키텍처 를 대상으로하는 것이 더 나은 아이디어 일 수 있습니다.대신 .

예를 들면 :

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

불행히도이 솔루션은 컴파일러 별 정의에 의존하기 때문에 휴대 성이 뛰어나지 않습니다 (표준은 없지만 여기 에 이러한 정의에 대한 멋진 컴파일이 있습니다).

이 시도:

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

   TEST;
}

오늘날 컴파일러는 컴파일 시간 (최적화에 따라 다름)에서 해당 답변을 평가하고 특정 엔디안을 기반으로 특정 값을 반환하지만 실제 머신 엔디안은 다를 수 있으므로 여기에있는 대부분의 답변은 이식 가능하지 않습니다. 엔디안이 테스트되는 값은 시스템 메모리에 도달하지 않으므로 실제 실행 된 코드는 실제 엔디안에 관계없이 동일한 결과를 반환합니다.

예를 들어 ARM Cortex-M3에서 구현 된 엔디안은 상태 비트 AIRCR.ENDIANNESS에 반영되며 컴파일러는 컴파일 타임에이 값을 알 수 없습니다.

여기에 제안 된 일부 답변에 대한 컴파일 출력 :

https://godbolt.org/z/GJGNE2 에 대한 이 대답은,

https://godbolt.org/z/Yv-pyJ 에 대한 이 답변은 .

이를 해결하려면 volatile한정자 를 사용해야합니다 . Yogeesh H T의 대답은 오늘날의 실제 사용에 대한 가장 가까운 하나이지만, 이후 Christoph더 포괄적 인 솔루션을 제안, 자신에 대한 약간의 수정 대답은 대답이 완료, 단지 추가 할 것이다 volatile노조의 선언 : static const volatile union.

이것은 엔디안을 결정하는 데 필요한 메모리에서 저장하고 읽는 것을 보장합니다.

전처리기를 덤프하는 경우 #defines

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

일반적으로 도움이되는 자료를 찾을 수 있습니다. 컴파일 타임 로직.

#define __LITTLE_ENDIAN__ 1
#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__

그러나 다양한 컴파일러는 다른 정의를 가질 수 있습니다.

내 대답은 질문과는 다르지만 시스템이 리틀 엔디안인지 빅 엔디안인지 찾는 것이 정말 간단 합니까?

암호:

#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 코드입니다.

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");

엔디안을 찾는 매크로

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

또는

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