gcc/testsuite/gcc.dg/torture/complex-sign.h

   1 /* Common header for complex arithmetic sign tests.  */
   2
   3 extern void abort (void);
   4 extern void exit (int);
   5
   6 #define CHECK_RES(VALUE, COPY, SIGN_REAL, SIGN_IMAG)            \
   7   do {                                                          \
   8     if ((VALUE) != 0                                            \
   9         || COPY (1.0, __real__ (VALUE)) != SIGN_REAL 1.0        \
  10         || COPY (1.0, __imag__ (VALUE)) != SIGN_IMAG 1.0)       \
  11       abort ();                                                 \
  12   } while (0)
  13
  14 /* This definition is intended to work with or without imaginary
  15    types, as long as mixed real/complex arithmetic is handled
  16    correctly.  */
  17 #define ENCODE(ZERO, ZEROI, SA, SB)                     \
  18   (SA 1 == 1                                            \
  19    ? SB 1 == 1 ? ZERO + ZEROI : ZERO - ZEROI            \
  20    : SB 1 == 1 ? -(ZERO - ZEROI) : -(ZERO + ZEROI))
  21
  22 #define CHECK_ARITH(TYPE, COPY, ZERO, ZEROI, OP, S1, S2, S3, S4, SR, SI) \
  23   do {                                                                  \
  24     _Complex TYPE a1, b1, c1;                                           \
  25     volatile _Complex TYPE a2, b2, c2;                                  \
  26     a1 = ENCODE(ZERO, ZEROI, S1, S2);                                   \
  27     CHECK_RES (a1, COPY, S1, S2);                                       \
  28     b1 = ENCODE(ZERO, ZEROI, S3, S4);                                   \
  29     CHECK_RES (b1, COPY, S3, S4);                                       \
  30     c1 = a1 OP b1;                                                      \
  31     CHECK_RES (c1, COPY, SR, SI);                                       \
  32     a2 = ENCODE(ZERO, ZEROI, S1, S2);                                   \
  33     CHECK_RES (a2, COPY, S1, S2);                                       \
  34     b2 = ENCODE(ZERO, ZEROI, S3, S4);                                   \
  35     CHECK_RES (b2, COPY, S3, S4);                                       \
  36     c2 = a2 OP b2;                                                      \
  37     CHECK_RES (c2, COPY, SR, SI);                                       \
  38   } while (0)
  39
  40 #define CHECK_ARITH_RC(TYPE, COPY, ZERO, ZEROI, OP, S1, S3, S4, SR, SI) \
  41   do {                                                                  \
  42     TYPE a1;                                                            \
  43     _Complex TYPE b1, c1;                                               \
  44     volatile TYPE a2;                                                   \
  45     volatile _Complex TYPE b2, c2;                                      \
  46     a1 = S1 ZERO;                                                       \
  47     b1 = ENCODE(ZERO, ZEROI, S3, S4);                                   \
  48     CHECK_RES (b1, COPY, S3, S4);                                       \
  49     c1 = a1 OP b1;                                                      \
  50     CHECK_RES (c1, COPY, SR, SI);                                       \
  51     a2 = S1 ZERO;                                                       \
  52     b2 = ENCODE(ZERO, ZEROI, S3, S4);                                   \
  53     CHECK_RES (b2, COPY, S3, S4);                                       \
  54     c2 = a2 OP b2;                                                      \
  55     CHECK_RES (c2, COPY, SR, SI);                                       \
  56   } while (0)
  57
  58 #define CHECK_ARITH_CR(TYPE, COPY, ZERO, ZEROI, OP, S1, S2, S3, V3, SR, SI) \
  59   do {                                                                  \
  60     _Complex TYPE a1, c1;                                               \
  61     TYPE b1;                                                            \
  62     volatile _Complex TYPE a2, c2;                                      \
  63     volatile TYPE b2;                                                   \
  64     a1 = ENCODE(ZERO, ZEROI, S1, S2);                                   \
  65     CHECK_RES (a1, COPY, S1, S2);                                       \
  66     b1 = S3 V3;                                                         \
  67     c1 = a1 OP b1;                                                      \
  68     CHECK_RES (c1, COPY, SR, SI);                                       \
  69     a2 = ENCODE(ZERO, ZEROI, S1, S2);                                   \
  70     CHECK_RES (a2, COPY, S1, S2);                                       \
  71     b2 = S3 V3;                                                         \
  72     c2 = a2 OP b2;                                                      \
  73     CHECK_RES (c2, COPY, SR, SI);                                       \
  74   } while (0)