gcc/testsuite/gcc.dg/torture/builtin-math-6.c

   1 /* Copyright (C) 2009  Free Software Foundation.
   2
   3    Verify that folding of built-in complex math functions with
   4    constant arguments is correctly performed by the compiler.
   5
   6    Origin: Kaveh R. Ghazi,  January 28, 2009.  */
   7
   8 /* { dg-do link } */
   9 /* { dg-require-effective-target mpc_pow } */
  10
  11 /* All references to link_error should go away at compile-time.  */
  12 extern void link_error(int);
  13
  14 #define CONJ(X) __builtin_conjf(X)
  15
  16 /* Return TRUE if the signs of floating point values X and Y are not
  17    equal.  This is important when comparing signed zeros.  */
  18 #define CKSGN_F(X,Y) \
  19   (__builtin_copysignf(1,(X)) != __builtin_copysignf(1,(Y)))
  20 #define CKSGN(X,Y) \
  21   (__builtin_copysign(1,(X)) != __builtin_copysign(1,(Y)))
  22 #define CKSGN_L(X,Y) \
  23   (__builtin_copysignl(1,(X)) != __builtin_copysignl(1,(Y)))
  24
  25 /* Return TRUE if signs of the real parts, and the signs of the
  26    imaginary parts, of X and Y are not equal.  */
  27 #define COMPLEX_CKSGN_F(X,Y) \
  28   (CKSGN_F(__real__ (X), __real__ (Y)) || CKSGN_F (__imag__ (X), __imag__ (Y)))
  29 #define COMPLEX_CKSGN(X,Y) \
  30   (CKSGN(__real__ (X), __real__ (Y)) || CKSGN (__imag__ (X), __imag__ (Y)))
  31 #define COMPLEX_CKSGN_L(X,Y) \
  32   (CKSGN_L(__real__ (X), __real__ (Y)) || CKSGN_L (__imag__ (X), __imag__ (Y)))
  33
  34 /* For complex numbers, test that FUNC(ARG) == (RES).  */
  35 #define TESTIT_COMPLEX(FUNC, ARG, RES) do { \
  36   if (__builtin_##FUNC##f(ARG) != (RES) \
  37     || COMPLEX_CKSGN_F(__builtin_##FUNC##f(ARG), (RES))) \
  38       link_error(__LINE__); \
  39   if (__builtin_##FUNC(ARG) != (RES) \
  40     || COMPLEX_CKSGN(__builtin_##FUNC(ARG), (RES))) \
  41       link_error(__LINE__); \
  42   if (__builtin_##FUNC##l(ARG) != (RES) \
  43     || COMPLEX_CKSGN_L(__builtin_##FUNC##l(ARG), (RES))) \
  44       link_error(__LINE__); \
  45   } while (0)
  46
  47 /* For complex numbers, call the TESTIT_COMPLEX macro for all
  48    combinations of neg and conj.  */
  49 #define TESTIT_COMPLEX_ALLNEG(FUNC, ARG, RES1, RES2, RES3, RES4) do { \
  50   TESTIT_COMPLEX(FUNC, (_Complex float)(ARG), RES1); \
  51   TESTIT_COMPLEX(FUNC, -CONJ(ARG), RES2); \
  52   TESTIT_COMPLEX(FUNC, CONJ(ARG), RES3); \
  53   TESTIT_COMPLEX(FUNC, -(_Complex float)(ARG), RES4); \
  54 } while (0)
  55
  56 /* For complex numbers, call the TESTIT_COMPLEX_R macro for all
  57    combinations of neg and conj.  */
  58 #define TESTIT_COMPLEX_R_ALLNEG(FUNC, ARG, RES1, RES2, RES3, RES4) do { \
  59   TESTIT_COMPLEX_R(FUNC, (_Complex float)(ARG), RES1); \
  60   TESTIT_COMPLEX_R(FUNC, -CONJ(ARG), RES2); \
  61   TESTIT_COMPLEX_R(FUNC, CONJ(ARG), RES3); \
  62   TESTIT_COMPLEX_R(FUNC, -(_Complex float)(ARG), RES4); \
  63 } while (0)
  64
  65 /* For complex numbers, test that FUNC(ARG0, ARG1) == (RES).  */
  66 #define TESTIT_COMPLEX2(FUNC, ARG0, ARG1, RES) do { \
  67   if (__builtin_##FUNC##f(ARG0, ARG1) != (RES) \
  68     || COMPLEX_CKSGN_F(__builtin_##FUNC##f(ARG0, ARG1), (RES))) \
  69       link_error(__LINE__); \
  70   if (__builtin_##FUNC(ARG0, ARG1) != (RES) \
  71     || COMPLEX_CKSGN(__builtin_##FUNC(ARG0, ARG1), (RES))) \
  72       link_error(__LINE__); \
  73   if (__builtin_##FUNC##l(ARG0, ARG1) != (RES) \
  74     || COMPLEX_CKSGN_L(__builtin_##FUNC##l(ARG0, ARG1), (RES))) \
  75       link_error(__LINE__); \
  76   } while (0)
  77
  78 /* For complex numbers, call the TESTIT_COMPLEX2 macro for all
  79    combinations of neg and conj.  */
  80 #define TESTIT_COMPLEX2_ALLNEG(FUNC, ARG0, ARG1, RES1, RES2, RES3, RES4, RES5,\
  81  RES6, RES7, RES8, RES9, RES10, RES11, RES12, RES13, RES14, RES15, RES16) do{ \
  82   TESTIT_COMPLEX2(FUNC, (_Complex float)(ARG0),(_Complex float)(ARG1), RES1);\
  83   TESTIT_COMPLEX2(FUNC, (_Complex float)(ARG0),CONJ(ARG1), RES2); \
  84   TESTIT_COMPLEX2(FUNC, (_Complex float)(ARG0),-(_Complex float)(ARG1), RES3); \
  85   TESTIT_COMPLEX2(FUNC, (_Complex float)(ARG0),-CONJ(ARG1), RES4); \
  86   TESTIT_COMPLEX2(FUNC, -(_Complex float)(ARG0),(_Complex float)(ARG1), RES5); \
  87   TESTIT_COMPLEX2(FUNC, -(_Complex float)(ARG0),CONJ(ARG1), RES6); \
  88   TESTIT_COMPLEX2(FUNC, -(_Complex float)(ARG0),-(_Complex float)(ARG1), RES7); \
  89   TESTIT_COMPLEX2(FUNC, -(_Complex float)(ARG0),-CONJ(ARG1), RES8); \
  90   TESTIT_COMPLEX2(FUNC, CONJ(ARG0),(_Complex float)(ARG1), RES9); \
  91   TESTIT_COMPLEX2(FUNC, CONJ(ARG0),CONJ(ARG1), RES10); \
  92   TESTIT_COMPLEX2(FUNC, CONJ(ARG0),-(_Complex float)(ARG1), RES11); \
  93   TESTIT_COMPLEX2(FUNC, CONJ(ARG0),-CONJ(ARG1), RES12); \
  94   TESTIT_COMPLEX2(FUNC, -CONJ(ARG0),(_Complex float)(ARG1), RES13); \
  95   TESTIT_COMPLEX2(FUNC, -CONJ(ARG0),CONJ(ARG1), RES14); \
  96   TESTIT_COMPLEX2(FUNC, -CONJ(ARG0),-(_Complex float)(ARG1), RES15); \
  97   TESTIT_COMPLEX2(FUNC, -CONJ(ARG0),-CONJ(ARG1), RES16); \
  98 } while (0)
  99
 100 /* Return TRUE if X differs from EXPECTED by more than 1%.  If
 101    EXPECTED is zero, then any difference may return TRUE.  We don't
 102    worry about signed zeros.  */
 103 #define DIFF1PCT_F(X,EXPECTED) \
 104   (__builtin_fabsf((X)-(EXPECTED)) * 100 > __builtin_fabsf(EXPECTED))
 105 #define DIFF1PCT(X,EXPECTED) \
 106   (__builtin_fabs((X)-(EXPECTED)) * 100 > __builtin_fabs(EXPECTED))
 107 #define DIFF1PCT_L(X,EXPECTED) \
 108   (__builtin_fabsl((X)-(EXPECTED)) * 100 > __builtin_fabsl(EXPECTED))
 109
 110 /* Return TRUE if complex value X differs from EXPECTED by more than
 111    1% in either the real or imaginary parts.  */
 112 #define COMPLEX_DIFF1PCT_F(X,EXPECTED) \
 113   (DIFF1PCT_F(__real__ (X), __real__ (EXPECTED)) \
 114    || DIFF1PCT_F(__imag__ (X), __imag__ (EXPECTED)))
 115 #define COMPLEX_DIFF1PCT(X,EXPECTED) \
 116   (DIFF1PCT(__real__ (X), __real__ (EXPECTED)) \
 117    || DIFF1PCT(__imag__ (X), __imag__ (EXPECTED)))
 118 #define COMPLEX_DIFF1PCT_L(X,EXPECTED) \
 119   (DIFF1PCT_L(__real__ (X), __real__ (EXPECTED)) \
 120    || DIFF1PCT_L(__imag__ (X), __imag__ (EXPECTED)))
 121
 122 /* Range test, for complex numbers check that FUNC(ARG) is within 1%
 123    of RES.  This is NOT a test for accuracy to the last-bit, we're
 124    merely checking that we get relatively sane results.  I.e. the GCC
 125    builtin is hooked up to the correct MPC function call.  We first
 126    check the magnitude and then the sign.  */
 127 #define TESTIT_COMPLEX_R(FUNC, ARG, RES) do { \
 128   if (COMPLEX_DIFF1PCT_F (__builtin_##FUNC##f(ARG), (RES)) \
 129       || COMPLEX_CKSGN_F(__builtin_##FUNC##f(ARG), (RES))) \
 130     link_error(__LINE__); \
 131   if (COMPLEX_DIFF1PCT (__builtin_##FUNC(ARG), (RES)) \
 132       || COMPLEX_CKSGN(__builtin_##FUNC(ARG), (RES))) \
 133     link_error(__LINE__); \
 134   if (COMPLEX_DIFF1PCT (__builtin_##FUNC(ARG), (RES)) \
 135       || COMPLEX_CKSGN(__builtin_##FUNC(ARG), (RES))) \
 136     link_error(__LINE__); \
 137   } while (0)
 138
 139 /* Range test, for complex numbers check that FUNC(ARG0, ARG1) is
 140    within 1% of RES.  This is NOT a test for accuracy to the last-bit,
 141    we're merely checking that we get relatively sane results.
 142    I.e. the GCC builtin is hooked up to the correct MPC function call.
 143    We first check the magnitude and then the sign.  */
 144 #define TESTIT_COMPLEX_R2(FUNC, ARG0, ARG1, RES) do { \
 145   if (COMPLEX_DIFF1PCT_F (__builtin_##FUNC##f(ARG0, ARG1), (RES)) \
 146       || COMPLEX_CKSGN_F (__builtin_##FUNC##f(ARG0, ARG1), (RES))) \
 147     link_error(__LINE__); \
 148   if (COMPLEX_DIFF1PCT (__builtin_##FUNC(ARG0, ARG1), (RES)) \
 149       || COMPLEX_CKSGN (__builtin_##FUNC(ARG0, ARG1), (RES))) \
 150     link_error(__LINE__); \
 151   if (COMPLEX_DIFF1PCT_L (__builtin_##FUNC##l(ARG0, ARG1), (RES)) \
 152       || COMPLEX_CKSGN_L (__builtin_##FUNC##l(ARG0, ARG1), (RES))) \
 153     link_error(__LINE__); \
 154   } while (0)
 155
 156 /* For complex numbers, call the TESTIT_COMPLEX_R2 macro for all
 157    combinations of neg and conj.  */
 158 #define TESTIT_COMPLEX_R2_ALLNEG(FUNC, ARG0, ARG1, RES1, RES2, RES3, RES4, RES5,\
 159  RES6, RES7, RES8, RES9, RES10, RES11, RES12, RES13, RES14, RES15, RES16) do{ \
 160   TESTIT_COMPLEX_R2(FUNC, (_Complex float)(ARG0),(_Complex float)(ARG1), RES1);\
 161   TESTIT_COMPLEX_R2(FUNC, (_Complex float)(ARG0),CONJ(ARG1), RES2); \
 162   TESTIT_COMPLEX_R2(FUNC, (_Complex float)(ARG0),-(_Complex float)(ARG1), RES3); \
 163   TESTIT_COMPLEX_R2(FUNC, (_Complex float)(ARG0),-CONJ(ARG1), RES4); \
 164   TESTIT_COMPLEX_R2(FUNC, -(_Complex float)(ARG0),(_Complex float)(ARG1), RES5); \
 165   TESTIT_COMPLEX_R2(FUNC, -(_Complex float)(ARG0),CONJ(ARG1), RES6); \
 166   TESTIT_COMPLEX_R2(FUNC, -(_Complex float)(ARG0),-(_Complex float)(ARG1), RES7); \
 167   TESTIT_COMPLEX_R2(FUNC, -(_Complex float)(ARG0),-CONJ(ARG1), RES8); \
 168   TESTIT_COMPLEX_R2(FUNC, CONJ(ARG0),(_Complex float)(ARG1), RES9); \
 169   TESTIT_COMPLEX_R2(FUNC, CONJ(ARG0),CONJ(ARG1), RES10); \
 170   TESTIT_COMPLEX_R2(FUNC, CONJ(ARG0),-(_Complex float)(ARG1), RES11); \
 171   TESTIT_COMPLEX_R2(FUNC, CONJ(ARG0),-CONJ(ARG1), RES12); \
 172   TESTIT_COMPLEX_R2(FUNC, -CONJ(ARG0),(_Complex float)(ARG1), RES13); \
 173   TESTIT_COMPLEX_R2(FUNC, -CONJ(ARG0),CONJ(ARG1), RES14); \
 174   TESTIT_COMPLEX_R2(FUNC, -CONJ(ARG0),-(_Complex float)(ARG1), RES15); \
 175   TESTIT_COMPLEX_R2(FUNC, -CONJ(ARG0),-CONJ(ARG1), RES16); \
 176 } while (0)
 177
 178 int main (void)
 179 {
 180   TESTIT_COMPLEX_ALLNEG (csin, 0,
 181                          0, -0.F,
 182                          CONJ(0), CONJ(-0.F));
 183   TESTIT_COMPLEX_R_ALLNEG (csin, 3.45678F + 2.34567FI,
 184                            -1.633059F - 4.917448FI, 1.633059F - 4.917448FI,
 185                            -1.633059F + 4.917448FI, 1.633059F + 4.917448FI);
 186
 187   TESTIT_COMPLEX_ALLNEG (ccos, 0,
 188                          CONJ(1), 1, 1, CONJ(1));
 189   TESTIT_COMPLEX_R_ALLNEG (ccos, 3.45678F + 2.34567FI,
 190                            -5.008512F + 1.603367FI, -5.008512F - 1.603367FI,
 191                            -5.008512F - 1.603367FI, -5.008512F + 1.603367FI);
 192
 193   TESTIT_COMPLEX_ALLNEG (ctan, 0,
 194                          0, -0.F, CONJ(0), CONJ(-0.F));
 195   TESTIT_COMPLEX_R_ALLNEG (ctan, 3.45678F + 2.34567FI,
 196                            0.010657F + 0.985230FI, -0.010657F + 0.985230FI,
 197                            0.010657F - 0.985230FI, -0.010657F - 0.985230FI);
 198
 199   TESTIT_COMPLEX_ALLNEG (csinh, 0,
 200                          0, -0.F, CONJ(0), CONJ(-0.F));
 201   TESTIT_COMPLEX_R_ALLNEG (csinh, 3.45678F + 2.34567FI,
 202                            -11.083178F + 11.341487FI, 11.083178F +11.341487FI,
 203                            -11.083178F - 11.341487FI, 11.083178F -11.341487FI);
 204
 205   TESTIT_COMPLEX_ALLNEG (ccosh, 0,
 206                          1, CONJ(1), CONJ(1), 1);
 207   TESTIT_COMPLEX_R_ALLNEG (ccosh, 3.45678F + 2.34567FI,
 208                            -11.105238F + 11.318958FI,-11.105238F -11.318958FI,
 209                            -11.105238F - 11.318958FI,-11.105238F +11.318958FI);
 210
 211   TESTIT_COMPLEX_ALLNEG (ctanh, 0,
 212                          0, -0.F, CONJ(0), CONJ(-0.F));
 213   TESTIT_COMPLEX_R_ALLNEG (ctanh, 3.45678F + 2.34567FI,
 214                            1.000040F - 0.001988FI, -1.000040F - 0.001988FI,
 215                            1.000040F + 0.001988FI, -1.000040F + 0.001988FI);
 216
 217   TESTIT_COMPLEX (clog, 1, 0);
 218   TESTIT_COMPLEX_R (clog, -1, 3.141593FI);
 219   TESTIT_COMPLEX (clog, CONJ(1), CONJ(0)); /* Fails with mpc-0.6.  */
 220   TESTIT_COMPLEX_R (clog, CONJ(-1), CONJ(3.141593FI)); /* Fails with mpc-0.6.  */
 221   TESTIT_COMPLEX_R_ALLNEG (clog, 3.45678F + 2.34567FI,
 222                            1.429713F + 0.596199FI, 1.429713F + 2.545394FI,
 223                            1.429713F - 0.596199FI, 1.429713F - 2.545394FI);
 224
 225   TESTIT_COMPLEX_ALLNEG (csqrt, 0,
 226                          0, 0, CONJ(0), CONJ(0));
 227   TESTIT_COMPLEX_R_ALLNEG (csqrt, 3.45678F + 2.34567FI,
 228                            1.953750F + 0.600299FI, 0.600299F + 1.953750FI,
 229                            1.953750F - 0.600299FI, 0.600299F - 1.953750FI);
 230
 231   TESTIT_COMPLEX2_ALLNEG (cpow, 1, 0,
 232                           1, 1, CONJ(1), CONJ(1), 1, CONJ(1), 1, 1,
 233                           CONJ(1), CONJ(1), 1, 1, 1, 1, CONJ(1), 1);
 234   TESTIT_COMPLEX2_ALLNEG (cpow, 1.FI, 0,
 235                           1, 1, CONJ(1), 1, 1, CONJ(1), 1, 1,
 236                           1, CONJ(1), 1, 1, 1, 1, CONJ(1), 1);
 237   TESTIT_COMPLEX_R2_ALLNEG (cpow, 2, 3,
 238                             8, 8, CONJ(1/8.F), 1/8.F, CONJ(-8), -8, -1/8.F, -1/8.F,
 239                             8, CONJ(8), 1/8.F, 1/8.F, -8, -8, -1/8.F, CONJ(-1/8.F));
 240   TESTIT_COMPLEX_R2_ALLNEG (cpow, 3, 4,
 241                             81, 81, CONJ(1/81.F), 1/81.F, 81, 81, CONJ(1/81.F), 1/81.F,
 242                             81, CONJ(81), 1/81.F, 1/81.F, 81, CONJ(81), 1/81.F, 1/81.F);
 243   TESTIT_COMPLEX_R2_ALLNEG (cpow, 3, 5,
 244                             243, 243, CONJ(1/243.F), 1/243.F, CONJ(-243), -243, -1/243.F, -1/243.F,
 245                             243, CONJ(243), 1/243.F, 1/243.F, -243, -243, -1/243.F, CONJ(-1/243.F));
 246   TESTIT_COMPLEX_R2_ALLNEG (cpow, 4, 2,
 247                             16, 16, CONJ(1/16.F), 1/16.F, 16, 16, CONJ(1/16.F), 1/16.F,
 248                             16, CONJ(16), 1/16.F, 1/16.F, 16, CONJ(16), 1/16.F, 1/16.F);
 249   TESTIT_COMPLEX_R2_ALLNEG (cpow, 1.5, 3,
 250                             3.375F, 3.375F, CONJ(1/3.375F), 1/3.375F, CONJ(-3.375F), -3.375F, -1/3.375F, -1/3.375F,
 251                             3.375F, CONJ(3.375F), 1/3.375F, 1/3.375F, -3.375F, -3.375F, -1/3.375F, CONJ(-1/3.375F));
 252
 253   TESTIT_COMPLEX2 (cpow, 16, 0.25F, 2);
 254
 255   TESTIT_COMPLEX_R2 (cpow, 3.45678F + 2.34567FI, 1.23456 + 4.56789FI, 0.212485F + 0.319304FI);
 256   TESTIT_COMPLEX_R2 (cpow, 3.45678F - 2.34567FI, 1.23456 + 4.56789FI, 78.576402F + -41.756208FI);
 257   TESTIT_COMPLEX_R2 (cpow, -1.23456F + 2.34567FI, 2.34567 - 1.23456FI, -110.629847F + -57.021655FI);
 258   TESTIT_COMPLEX_R2 (cpow, -1.23456F - 2.34567FI, 2.34567 - 1.23456FI, 0.752336F + 0.199095FI);
 259
 260   return 0;
 261 }