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