| /* Verify that <stdint.h> is present and follows the C99 requirements. |
| If this test fails because of the header being missing on a |
| particular target, this indicates GCC has not been correctly |
| configured regarding what version of <stdint.h> to install or what |
| the <stdint.h> types are on that target. If GCC is wrapping a |
| system copy of the header and some tests fail because of bugs in |
| that copy, they should be fixed with fixincludes (and the bugs |
| reported to maintainer of that copy if still present in the latest |
| version). */ |
| /* { dg-do compile } */ |
| /* { dg-options "-std=iso9899:1999 -pedantic-errors -fhosted" } */ |
| |
| #include <limits.h> |
| #include <stdint.h> |
| /* This and the later SIG_ATOMIC_* tests should be appropriately |
| conditioned for any freestanding targets with no <signal.h>. */ |
| #ifndef SIGNAL_SUPPRESS |
| #include <signal.h> |
| #endif |
| |
| /* Note that some of these conditions assume two's complement and no |
| padding bits; GCC only supports two's complement, and no supported |
| target has padding bits in any integer type of the standard |
| widths. */ |
| #define CHECK_SIGNED(TYPE) \ |
| do { TYPE a; int b[(TYPE)-1 < 0 ? 1 : -1]; } while (0) |
| #define CHECK_UNSIGNED(TYPE) \ |
| do { TYPE a; int b[(TYPE)-1 < 0 ? -1 : 1]; } while (0) |
| #define CHECK_WIDTH_EQUALS(TYPE, WIDTH) \ |
| do { int a[sizeof(TYPE) * CHAR_BIT == (WIDTH) ? 1 : -1]; } while (0) |
| #define CHECK_WIDTH_AT_LEAST(TYPE, WIDTH) \ |
| do { int a[sizeof(TYPE) * CHAR_BIT >= (WIDTH) ? 1 : -1]; } while (0) |
| #define CHECK_WIDTH_ORDER(TYPE1, TYPE2) \ |
| do { int a[sizeof(TYPE2) >= sizeof(TYPE1) ? 1 : -1]; } while (0) |
| #define CHECK_EXPR_TYPE(TYPE, EXPR) \ |
| do { __typeof__(EXPR) a; __typeof__((TYPE)0 + 0) *b = &a; } while (0) |
| #define UNSIGNED_MAX_COND(TYPE, EXPR) \ |
| ((EXPR) == (TYPE)-1) |
| #define SIGNED_MIN_MAX_COND(TYPE, MIN, MAX) \ |
| ((MIN) == -(MAX)-1 \ |
| && ((MAX) & 1) \ |
| && ((((MAX) >> 1) + 1) >> (sizeof(TYPE) * CHAR_BIT - 2)) == 1) |
| #define MIN_MAX_COND(TYPE, MIN, MAX) \ |
| ((TYPE)-1 < 0 \ |
| ? SIGNED_MIN_MAX_COND(TYPE, (MIN), (MAX)) \ |
| : ((MIN) == 0 && UNSIGNED_MAX_COND(TYPE, (MAX)))) |
| #define CHECK_SIGNED_LIMITS(TYPE, MIN, MAX) \ |
| CHECK_SIGNED(TYPE); \ |
| CHECK_EXPR_TYPE(TYPE, (MIN)); \ |
| CHECK_EXPR_TYPE(TYPE, (MAX)); \ |
| do { int a[SIGNED_MIN_MAX_COND(TYPE, (MIN), (MAX)) ? 1 : -1]; } while (0) |
| #define CHECK_SIGNED_LIMITS_2(TYPE, MIN, MAX, MINBD, MAXBD) \ |
| CHECK_SIGNED(TYPE); \ |
| CHECK_EXPR_TYPE(TYPE, (MIN)); \ |
| CHECK_EXPR_TYPE(TYPE, (MAX)); \ |
| do { int a[(SIGNED_MIN_MAX_COND(TYPE, (MIN), (MAX)) \ |
| && (MIN) <= (MINBD) \ |
| && (MAX) >= (MAXBD)) ? 1 : -1]; } while (0) |
| #define CHECK_UNSIGNED_LIMITS(TYPE, MAX) \ |
| CHECK_UNSIGNED(TYPE); \ |
| CHECK_EXPR_TYPE(TYPE, (MAX)); \ |
| do { int a[UNSIGNED_MAX_COND(TYPE, (MAX)) ? 1 : -1]; } while (0) |
| #define CHECK_UNSIGNED_LIMITS_2(TYPE, MAX, MAXBD) \ |
| CHECK_UNSIGNED(TYPE); \ |
| CHECK_EXPR_TYPE(TYPE, (MAX)); \ |
| do { int a[(UNSIGNED_MAX_COND(TYPE, (MAX)) \ |
| && (MAX) >= (MAXBD)) ? 1 : -1]; } while (0) |
| #define CHECK_LIMITS_2(TYPE, MIN, MAX, SMINBD, SMAXBD, UMAXBD) \ |
| do { int a[(MIN_MAX_COND(TYPE, (MIN), (MAX)) \ |
| && ((TYPE)-1 < 0 \ |
| ? ((MIN) <= (SMINBD) && (MAX) >= (SMAXBD)) \ |
| : (MAX) >= (UMAXBD))) ? 1 : -1]; } while (0) |
| #define CHECK_CONSTS(TYPE, MACRO) \ |
| CHECK_EXPR_TYPE(TYPE, MACRO(01)); \ |
| CHECK_EXPR_TYPE(TYPE, MACRO(2)); \ |
| CHECK_EXPR_TYPE(TYPE, MACRO(0x3)); \ |
| do { int a[(MACRO(12) == 12 \ |
| && MACRO(012) == 012 \ |
| && MACRO(0x12) == 0x12) ? 1 : -1]; } while (0); |
| |
| void |
| test_exact (void) |
| { |
| #ifdef INT8_MIN |
| CHECK_WIDTH_EQUALS(int8_t, 8); |
| CHECK_SIGNED_LIMITS(int8_t, INT8_MIN, INT8_MAX); |
| #else |
| CHECK_WIDTH_AT_LEAST(int_least8_t, 9); |
| #endif |
| #ifdef INT16_MIN |
| CHECK_WIDTH_EQUALS(int16_t, 16); |
| CHECK_SIGNED_LIMITS(int16_t, INT16_MIN, INT16_MAX); |
| #else |
| CHECK_WIDTH_AT_LEAST(int_least16_t, 17); |
| #endif |
| #ifdef INT32_MIN |
| CHECK_WIDTH_EQUALS(int32_t, 32); |
| CHECK_SIGNED_LIMITS(int32_t, INT32_MIN, INT32_MAX); |
| #else |
| CHECK_WIDTH_AT_LEAST(int_least32_t, 33); |
| #endif |
| #ifdef INT64_MIN |
| CHECK_WIDTH_EQUALS(int64_t, 64); |
| CHECK_SIGNED_LIMITS(int64_t, INT64_MIN, INT64_MAX); |
| #else |
| CHECK_WIDTH_AT_LEAST(int_least64_t, 65); |
| #endif |
| #ifdef UINT8_MAX |
| CHECK_WIDTH_EQUALS(uint8_t, 8); |
| CHECK_UNSIGNED_LIMITS(uint8_t, UINT8_MAX); |
| #else |
| CHECK_WIDTH_AT_LEAST(uint_least8_t, 9); |
| #endif |
| #ifdef UINT16_MAX |
| CHECK_WIDTH_EQUALS(uint16_t, 16); |
| CHECK_UNSIGNED_LIMITS(uint16_t, UINT16_MAX); |
| #else |
| CHECK_WIDTH_AT_LEAST(uint_least16_t, 17); |
| #endif |
| #ifdef UINT32_MAX |
| CHECK_WIDTH_EQUALS(uint32_t, 32); |
| CHECK_UNSIGNED_LIMITS(uint32_t, UINT32_MAX); |
| #else |
| CHECK_WIDTH_AT_LEAST(uint_least32_t, 33); |
| #endif |
| #ifdef UINT64_MAX |
| CHECK_WIDTH_EQUALS(uint64_t, 64); |
| CHECK_UNSIGNED_LIMITS(uint64_t, UINT64_MAX); |
| #else |
| CHECK_WIDTH_AT_LEAST(uint_least64_t, 65); |
| #endif |
| } |
| |
| void |
| test_least (void) |
| { |
| CHECK_WIDTH_AT_LEAST(int_least8_t, 8); |
| CHECK_WIDTH_ORDER(int_least8_t, int_fast8_t); |
| CHECK_SIGNED_LIMITS(int_least8_t, INT_LEAST8_MIN, INT_LEAST8_MAX); |
| CHECK_WIDTH_AT_LEAST(int_least16_t, 16); |
| CHECK_WIDTH_ORDER(int_least16_t, int_fast16_t); |
| CHECK_SIGNED_LIMITS(int_least16_t, INT_LEAST16_MIN, INT_LEAST16_MAX); |
| CHECK_WIDTH_AT_LEAST(int_least32_t, 32); |
| CHECK_WIDTH_ORDER(int_least32_t, int_fast32_t); |
| CHECK_SIGNED_LIMITS(int_least32_t, INT_LEAST32_MIN, INT_LEAST32_MAX); |
| CHECK_WIDTH_AT_LEAST(int_least64_t, 64); |
| CHECK_WIDTH_ORDER(int_least64_t, int_fast64_t); |
| CHECK_SIGNED_LIMITS(int_least64_t, INT_LEAST64_MIN, INT_LEAST64_MAX); |
| CHECK_WIDTH_AT_LEAST(uint_least8_t, 8); |
| CHECK_WIDTH_ORDER(uint_least8_t, uint_fast8_t); |
| CHECK_UNSIGNED_LIMITS(uint_least8_t, UINT_LEAST8_MAX); |
| CHECK_WIDTH_AT_LEAST(uint_least16_t, 16); |
| CHECK_WIDTH_ORDER(uint_least16_t, uint_fast16_t); |
| CHECK_UNSIGNED_LIMITS(uint_least16_t, UINT_LEAST16_MAX); |
| CHECK_WIDTH_AT_LEAST(uint_least32_t, 32); |
| CHECK_WIDTH_ORDER(uint_least32_t, uint_fast32_t); |
| CHECK_UNSIGNED_LIMITS(uint_least32_t, UINT_LEAST32_MAX); |
| CHECK_WIDTH_AT_LEAST(uint_least64_t, 64); |
| CHECK_WIDTH_ORDER(uint_least64_t, uint_fast64_t); |
| CHECK_UNSIGNED_LIMITS(uint_least64_t, UINT_LEAST64_MAX); |
| } |
| |
| void |
| test_fast (void) |
| { |
| CHECK_WIDTH_AT_LEAST(int_fast8_t, 8); |
| CHECK_SIGNED_LIMITS(int_fast8_t, INT_FAST8_MIN, INT_FAST8_MAX); |
| CHECK_WIDTH_AT_LEAST(int_fast16_t, 16); |
| CHECK_SIGNED_LIMITS(int_fast16_t, INT_FAST16_MIN, INT_FAST16_MAX); |
| CHECK_WIDTH_AT_LEAST(int_fast32_t, 32); |
| CHECK_SIGNED_LIMITS(int_fast32_t, INT_FAST32_MIN, INT_FAST32_MAX); |
| CHECK_WIDTH_AT_LEAST(int_fast64_t, 64); |
| CHECK_SIGNED_LIMITS(int_fast64_t, INT_FAST64_MIN, INT_FAST64_MAX); |
| CHECK_WIDTH_AT_LEAST(uint_fast8_t, 8); |
| CHECK_UNSIGNED_LIMITS(uint_fast8_t, UINT_FAST8_MAX); |
| CHECK_WIDTH_AT_LEAST(uint_fast16_t, 16); |
| CHECK_UNSIGNED_LIMITS(uint_fast16_t, UINT_FAST16_MAX); |
| CHECK_WIDTH_AT_LEAST(uint_fast32_t, 32); |
| CHECK_UNSIGNED_LIMITS(uint_fast32_t, UINT_FAST32_MAX); |
| CHECK_WIDTH_AT_LEAST(uint_fast64_t, 64); |
| CHECK_UNSIGNED_LIMITS(uint_fast64_t, UINT_FAST64_MAX); |
| } |
| |
| void |
| test_ptr (void) |
| { |
| #ifdef INTPTR_MIN |
| CHECK_SIGNED_LIMITS_2(intptr_t, INTPTR_MIN, INTPTR_MAX, -0x7fff, 0x7fff); |
| #endif |
| #ifdef UINTPTR_MAX |
| CHECK_UNSIGNED_LIMITS_2(uintptr_t, UINTPTR_MAX, 0xffffU); |
| #endif |
| } |
| |
| void |
| test_max (void) |
| { |
| CHECK_WIDTH_AT_LEAST(intmax_t, 64); |
| CHECK_WIDTH_ORDER(long long, intmax_t); |
| CHECK_WIDTH_ORDER(int_fast8_t, intmax_t); |
| CHECK_WIDTH_ORDER(int_fast16_t, intmax_t); |
| CHECK_WIDTH_ORDER(int_fast32_t, intmax_t); |
| CHECK_WIDTH_ORDER(int_fast64_t, intmax_t); |
| CHECK_SIGNED_LIMITS(intmax_t, INTMAX_MIN, INTMAX_MAX); |
| CHECK_WIDTH_AT_LEAST(uintmax_t, 64); |
| CHECK_WIDTH_ORDER(unsigned long long, uintmax_t); |
| CHECK_WIDTH_ORDER(uint_fast8_t, uintmax_t); |
| CHECK_WIDTH_ORDER(uint_fast16_t, uintmax_t); |
| CHECK_WIDTH_ORDER(uint_fast32_t, uintmax_t); |
| CHECK_WIDTH_ORDER(uint_fast64_t, uintmax_t); |
| CHECK_UNSIGNED_LIMITS(uintmax_t, UINTMAX_MAX); |
| } |
| |
| void |
| test_misc_limits (void) |
| { |
| /* { dg-bogus "size" "ptrdiff is 16bits" { xfail avr-*-* } 218 } */ |
| CHECK_SIGNED_LIMITS_2(__PTRDIFF_TYPE__, PTRDIFF_MIN, PTRDIFF_MAX, -65535L, 65535L); |
| #ifndef SIGNAL_SUPPRESS |
| CHECK_LIMITS_2(sig_atomic_t, SIG_ATOMIC_MIN, SIG_ATOMIC_MAX, -127, 127, 255); |
| #endif |
| CHECK_UNSIGNED_LIMITS_2(__SIZE_TYPE__, SIZE_MAX, 65535U); |
| CHECK_LIMITS_2(__WCHAR_TYPE__, WCHAR_MIN, WCHAR_MAX, -127, 127, 255); |
| CHECK_LIMITS_2(__WINT_TYPE__, WINT_MIN, WINT_MAX, -32767, 32767, 65535); |
| } |
| |
| void |
| test_constants (void) |
| { |
| CHECK_CONSTS(int_least8_t, INT8_C); |
| CHECK_CONSTS(int_least16_t, INT16_C); |
| CHECK_CONSTS(int_least32_t, INT32_C); |
| CHECK_CONSTS(int_least64_t, INT64_C); |
| CHECK_CONSTS(intmax_t, INTMAX_C); |
| CHECK_CONSTS(uint_least8_t, UINT8_C); |
| CHECK_CONSTS(uint_least16_t, UINT16_C); |
| CHECK_CONSTS(uint_least32_t, UINT32_C); |
| CHECK_CONSTS(uint_least64_t, UINT64_C); |
| CHECK_CONSTS(uintmax_t, UINTMAX_C); |
| #if INT8_C(12) != 12 |
| #error "INT8_C not usable in #if" |
| #endif |
| #if INT16_C(12) != 12 |
| #error "INT16_C not usable in #if" |
| #endif |
| #if INT32_C(12) != 12 |
| #error "INT32_C not usable in #if" |
| #endif |
| #if INT64_C(12) != 12 |
| #error "INT64_C not usable in #if" |
| #endif |
| #if INTMAX_C(12) != 12 |
| #error "INTMAX_C not usable in #if" |
| #endif |
| #if UINT8_C(12) != 12 |
| #error "UINT8_C not usable in #if" |
| #endif |
| #if UINT16_C(12) != 12 |
| #error "UINT16_C not usable in #if" |
| #endif |
| #if UINT32_C(12) != 12 |
| #error "UINT32_C not usable in #if" |
| #endif |
| #if UINT64_C(12) != 12 |
| #error "UINT64_C not usable in #if" |
| #endif |
| #if UINTMAX_C(12) != 12 |
| #error "UINTMAX_C not usable in #if" |
| #endif |
| } |