modernc.org/ccgo/v3@v3.16.14/lib/testdata/gcc-9.1.0/gcc/testsuite/gcc.c-torture/execute/ieee/copysign2.c (about)

     1  #include <string.h>
     2  #include <stdlib.h>
     3  #include <float.h>
     4  
     5  #define fpsizeoff	sizeof(float)
     6  #define fpsizeof	sizeof(double)
     7  #define fpsizeofl	sizeof(long double)
     8  
     9  /* Work around the fact that with the Intel double-extended precision,
    10     we've got a 10 byte type stuffed into some amount of padding.  And
    11     the fact that -ffloat-store is going to stuff this value temporarily
    12     into some bit of stack frame that we've no control over and can't zero.  */
    13  #ifndef __ccgo_test__
    14  #if LDBL_MANT_DIG == 64
    15  # if defined(__i386__) || defined(__x86_64__) || defined (__ia64__)
    16  #  undef fpsizeofl
    17  #  define fpsizeofl	10
    18  # endif
    19  #endif
    20  
    21  /* Work around the fact that the sign of the second double in the IBM
    22     double-double format is not strictly specified when it contains a zero.
    23     For instance, -0.0L can be represented with either (-0.0, +0.0) or
    24     (-0.0, -0.0).  The former is what we'll get from the compiler when it
    25     builds constants; the later is what we'll get from the negation operator
    26     at runtime.  */
    27  /* ??? This hack only works for big-endian, which is fortunately true for
    28     AIX and Darwin.  */
    29  #if LDBL_MANT_DIG == 106
    30  # undef fpsizeofl
    31  # define fpsizeofl	sizeof(double)
    32  #endif
    33  #endif
    34  
    35  
    36  #define TEST(TYPE, EXT)						\
    37  static TYPE Y##EXT[] = {					\
    38    2.0, -2.0, -2.0, -2.0, -2.0, 2.0, -0.0, __builtin_inf##EXT ()	\
    39  };								\
    40  static const TYPE Z##EXT[] = {					\
    41    1.0, -1.0, -1.0, -0.0, -0.0, 0.0, -__builtin_inf##EXT (),	\
    42    __builtin_nan##EXT ("")					\
    43  };								\
    44  								\
    45  void test##EXT (void)						\
    46  {								\
    47    TYPE r[8];							\
    48    int i;							\
    49    r[0] = __builtin_copysign##EXT (1.0, Y##EXT[0]);		\
    50    r[1] = __builtin_copysign##EXT (1.0, Y##EXT[1]);		\
    51    r[2] = __builtin_copysign##EXT (-1.0, Y##EXT[2]);		\
    52    r[3] = __builtin_copysign##EXT (0.0, Y##EXT[3]);		\
    53    r[4] = __builtin_copysign##EXT (-0.0, Y##EXT[4]);		\
    54    r[5] = __builtin_copysign##EXT (-0.0, Y##EXT[5]);		\
    55    r[6] = __builtin_copysign##EXT (__builtin_inf##EXT (), Y##EXT[6]); \
    56    r[7] = __builtin_copysign##EXT (-__builtin_nan##EXT (""), Y##EXT[7]); \
    57    for (i = 0; i < 8; ++i)					\
    58      if (memcmp (r+i, Z##EXT+i, fpsizeof##EXT) != 0)		\
    59        abort ();							\
    60  }
    61  
    62  TEST(float, f)
    63  TEST(double, )
    64  TEST(long double, l)
    65  
    66  int main()
    67  {
    68    testf();
    69    test();
    70    testl();
    71    return 0;
    72  }