Subversion Repositories openrisc_me

/* 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

}