gcc/testsuite/c-c++-common/torture/complex-sign.h

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