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)