gcc/testsuite/gcc.dg/builtin-tgmath-1.c

   1 /* Test __builtin_tgmath: valid uses, standard floating-point types.  */
   2 /* { dg-do run } */
   3 /* { dg-options "" } */
   4
   5 extern void abort (void);
   6 extern void exit (int);
   7
   8 #define CHECK_CALL(C, E, V)                     \
   9   do                                            \
  10     {                                           \
  11       if ((C) != (E))                           \
  12         abort ();                               \
  13       extern __typeof (C) V;                    \
  14     }                                           \
  15   while (0)
  16
  17 extern float var_f;
  18 extern double var_d;
  19 extern long double var_ld;
  20 extern _Complex float var_cf;
  21 extern _Complex double var_cd;
  22 extern _Complex long double var_cld;
  23 extern int var_i;
  24
  25 typedef float float_type;
  26 typedef double double_type;
  27
  28 /* Test simple case, real arguments and return type.  */
  29
  30 float_type t1f (float x) { return x + 1; }
  31 double t1d (double_type x) { return x + 2; }
  32 long double t1l (volatile long double x) { return x + 3; }
  33
  34 #define t1v(x) __builtin_tgmath (t1f, t1d, t1l, x)
  35 #define t1vr(x) __builtin_tgmath (t1l, t1d, t1f, x)
  36
  37 static void
  38 test_1 (void)
  39 {
  40   float_type f = 1;
  41   volatile float vf = 2;
  42   double d = 3;
  43   long double ld = 4;
  44   int i = 5;
  45   long long ll = 6;
  46   CHECK_CALL (t1v (f), 2, var_f);
  47   CHECK_CALL (t1v (vf), 3, var_f);
  48   CHECK_CALL (t1v (d), 5, var_d);
  49   CHECK_CALL (t1v (ld), 7, var_ld);
  50   CHECK_CALL (t1v (i), 7, var_d);
  51   CHECK_CALL (t1v (ll), 8, var_d);
  52   CHECK_CALL (t1vr (f), 2, var_f);
  53   CHECK_CALL (t1vr (vf), 3, var_f);
  54   CHECK_CALL (t1vr (d), 5, var_d);
  55   CHECK_CALL (t1vr (ld), 7, var_ld);
  56   CHECK_CALL (t1vr (i), 7, var_d);
  57   CHECK_CALL (t1vr (ll), 8, var_d);
  58 }
  59
  60 /* Test first argument not type-generic.  */
  61
  62 float t2f (int a, float x) { return a * x + 1; }
  63 double t2d (int a, double x) { return a * x + 2; }
  64 long double t2l (int a, long double x) { return a * x + 3; }
  65
  66 #define t2v(a, x) __builtin_tgmath (t2f, t2d, t2l, a, x)
  67
  68 static void
  69 test_2 (void)
  70 {
  71   float f = 1;
  72   double d = 2;
  73   long double ld = 3;
  74   int i = 4;
  75   unsigned long long ll = 5;
  76   CHECK_CALL (t2v (1, f), 2, var_f);
  77   CHECK_CALL (t2v (2, d), 6, var_d);
  78   CHECK_CALL (t2v (3, ld), 12, var_ld);
  79   CHECK_CALL (t2v (4, i), 18, var_d);
  80   CHECK_CALL (t2v (5, ll), 27, var_d);
  81 }
  82
  83 /* Test return type not type-generic.  */
  84
  85 int t3f (float x) { return x + 1; }
  86 int t3d (double x) { return x + 2; }
  87 int t3l (long double x) { return x + 3; }
  88
  89 #define t3v(x) __builtin_tgmath (t3f, t3d, t3l, x)
  90
  91 static void
  92 test_3 (void)
  93 {
  94   float f = 1;
  95   double d = 2;
  96   long double ld = 3;
  97   short s = 4;
  98   CHECK_CALL (t3v (f), 2, var_i);
  99   CHECK_CALL (t3v (d), 4, var_i);
 100   CHECK_CALL (t3v (ld), 6, var_i);
 101   CHECK_CALL (t3v (s), 6, var_i);
 102 }
 103
 104 /* Test multiple type-generic arguments.  */
 105
 106 float t4f (float x, float y) { return 10 * x + y; }
 107 double t4d (double x, double y) { return 100 * x + y; }
 108 long double t4l (long double x, long double y) { return 1000 * x + y; }
 109
 110 #define t4v(x, y) __builtin_tgmath (t4f, t4d, t4l, x, y)
 111
 112 static void
 113 test_4 (void)
 114 {
 115   float f1 = 1;
 116   float f2 = 2;
 117   double d1 = 3;
 118   double d2 = 4;
 119   long double ld = 5;
 120   long int l = 6;
 121   CHECK_CALL (t4v (f1, f2), 12, var_f);
 122   CHECK_CALL (t4v (f2, f1), 21, var_f);
 123   CHECK_CALL (t4v (f1, d1), 103, var_d);
 124   CHECK_CALL (t4v (d2, f2), 402, var_d);
 125   CHECK_CALL (t4v (f1, l), 106, var_d);
 126   CHECK_CALL (t4v (ld, f1), 5001, var_ld);
 127   CHECK_CALL (t4v (l, l), 606, var_d);
 128   CHECK_CALL (t4v (l, ld), 6005, var_ld);
 129 }
 130
 131 /* Test complex argument, real return type.  */
 132
 133 float t5f (_Complex float x) { return 1 + __real__ x + 3 * __imag__ x; }
 134 double t5d (_Complex double x) { return 2 + __real__ x + 4 * __imag__ x; }
 135 long double t5l (_Complex long double x) { return 3 + __real__ x + 5 * __imag__ x; }
 136
 137 #define t5v(x) __builtin_tgmath (t5f, t5d, t5l, x)
 138
 139 static void
 140 test_5 (void)
 141 {
 142   float f = 1;
 143   _Complex float cf = 2 + 3i;
 144   double d = 4;
 145   _Complex double cd = 5 + 6i;
 146   long double ld = 7;
 147   _Complex long double cld = 8 + 9i;
 148   int i = 10;
 149   _Complex int ci = 11 + 12i;
 150   CHECK_CALL (t5v (f), 2, var_f);
 151   CHECK_CALL (t5v (cf), 12, var_f);
 152   CHECK_CALL (t5v (d), 6, var_d);
 153   CHECK_CALL (t5v (cd), 31, var_d);
 154   CHECK_CALL (t5v (ld), 10, var_ld);
 155   CHECK_CALL (t5v (cld), 56, var_ld);
 156   CHECK_CALL (t5v (i), 12, var_d);
 157   CHECK_CALL (t5v (ci), 61, var_d);
 158 }
 159
 160 /* Test complex argument, complex return type.  */
 161
 162 _Complex float t6f (_Complex float x) { return 1 + x; }
 163 _Complex double t6d (_Complex double x) { return 2 + x; }
 164 _Complex long double t6l (_Complex long double x) { return 3 + x; }
 165
 166 #define t6v(x) __builtin_tgmath (t6f, t6d, t6l, x)
 167
 168 static void
 169 test_6 (void)
 170 {
 171   float f = 1;
 172   _Complex float cf = 2 + 3i;
 173   double d = 4;
 174   _Complex double cd = 5 + 6i;
 175   long double ld = 7;
 176   _Complex long double cld = 8 + 9i;
 177   int i = 10;
 178   _Complex int ci = 11 + 12i;
 179   CHECK_CALL (t6v (f), 2, var_cf);
 180   CHECK_CALL (t6v (cf), 3 + 3i, var_cf);
 181   CHECK_CALL (t6v (d), 6, var_cd);
 182   CHECK_CALL (t6v (cd), 7 + 6i, var_cd);
 183   CHECK_CALL (t6v (ld), 10, var_cld);
 184   CHECK_CALL (t6v (cld), 11 + 9i, var_cld);
 185   CHECK_CALL (t6v (i), 12, var_cd);
 186   CHECK_CALL (t6v (ci), 13 + 12i, var_cd);
 187 }
 188
 189 /* Test real and complex argument, real return type.  */
 190
 191 float t7f (float x) { return 1 + x; }
 192 float t7cf (_Complex float x) { return 2 + __real__ x; }
 193 double t7d (double x) { return 3 + x; }
 194 double t7cd (_Complex double x) { return 4 + __real__ x; }
 195 long double t7l (long double x) { return 5 + x; }
 196 long double t7cl (_Complex long double x) { return 6 + __real__ x; }
 197
 198 #define t7v(x) __builtin_tgmath (t7f, t7d, t7l, t7cf, t7cd, t7cl, x)
 199
 200 static void
 201 test_7 (void)
 202 {
 203   float f = 1;
 204   _Complex float cf = 2 + 3i;
 205   double d = 4;
 206   _Complex double cd = 5 + 6i;
 207   long double ld = 7;
 208   _Complex long double cld = 8 + 9i;
 209   int i = 10;
 210   _Complex int ci = 11 + 12i;
 211   CHECK_CALL (t7v (f), 2, var_f);
 212   CHECK_CALL (t7v (cf), 4, var_f);
 213   CHECK_CALL (t7v (d), 7, var_d);
 214   CHECK_CALL (t7v (cd), 9, var_d);
 215   CHECK_CALL (t7v (ld), 12, var_ld);
 216   CHECK_CALL (t7v (cld), 14, var_ld);
 217   CHECK_CALL (t7v (i), 13, var_d);
 218   CHECK_CALL (t7v (ci), 15, var_d);
 219 }
 220
 221 /* Test real and complex argument, real and complex return type.  */
 222
 223 float t8f (float x) { return 1 + x; }
 224 _Complex float t8cf (_Complex float x) { return 2 + x; }
 225 double t8d (double x) { return 3 + x; }
 226 _Complex double t8cd (_Complex double x) { return 4 + x; }
 227 long double t8l (long double x) { return 5 + x; }
 228 _Complex long double t8cl (_Complex long double x) { return 6 + x; }
 229
 230 #define t8v(x) __builtin_tgmath (t8f, t8d, t8l, t8cf, t8cd, t8cl, x)
 231
 232 static void
 233 test_8 (void)
 234 {
 235   float f = 1;
 236   _Complex float cf = 2 + 3i;
 237   double d = 4;
 238   _Complex double cd = 5 + 6i;
 239   long double ld = 7;
 240   _Complex long double cld = 8 + 9i;
 241   int i = 10;
 242   _Complex int ci = 11 + 12i;
 243   CHECK_CALL (t8v (f), 2, var_f);
 244   CHECK_CALL (t8v (cf), 4 + 3i, var_cf);
 245   CHECK_CALL (t8v (d), 7, var_d);
 246   CHECK_CALL (t8v (cd), 9 + 6i, var_cd);
 247   CHECK_CALL (t8v (ld), 12, var_ld);
 248   CHECK_CALL (t8v (cld), 14 + 9i, var_cld);
 249   CHECK_CALL (t8v (i), 13, var_d);
 250   CHECK_CALL (t8v (ci), 15 + 12i, var_cd);
 251 }
 252
 253 /* Test multiple type-generic arguments, real and complex.  */
 254
 255 float t9f (float x, float y) { return x + 10 * y; }
 256 _Complex float t9cf (_Complex float x, _Complex float y) { return x + 100 * y; }
 257 double t9d (double x, double y) { return x + 1000 * y; }
 258 _Complex double t9cd (_Complex double x, _Complex double y) { return x + 10000 * y; }
 259 long double t9l (long double x, long double y) { return x + 100000 * y; }
 260 _Complex long double t9cl (_Complex long double x, _Complex long double y) { return x + 1000000 * y; }
 261
 262 #define t9v(x, y) __builtin_tgmath (t9f, t9d, t9l, t9cf, t9cd, t9cl, x, y)
 263
 264 static void
 265 test_9 (void)
 266 {
 267   float f = 1;
 268   _Complex float cf = 2 + 3i;
 269   double d = 4;
 270   _Complex double cd = 5 + 6i;
 271   long double ld = 7;
 272   _Complex long double cld = 8 + 9i;
 273   int i = 10;
 274   _Complex int ci = 11 + 12i;
 275   CHECK_CALL (t9v (f, f), 11, var_f);
 276   CHECK_CALL (t9v (f, cf), 201 + 300i, var_cf);
 277   CHECK_CALL (t9v (cf, f), 102 + 3i, var_cf);
 278   CHECK_CALL (t9v (f, i), 10001, var_d);
 279   CHECK_CALL (t9v (i, f), 1010, var_d);
 280   CHECK_CALL (t9v (d, d), 4004, var_d);
 281   CHECK_CALL (t9v (d, cd), 50004 + 60000i, var_cd);
 282   CHECK_CALL (t9v (ld, i), 1000007, var_ld);
 283   CHECK_CALL (t9v (cf, cld), 8000002 + 9000003i, var_cld);
 284   CHECK_CALL (t9v (i, i), 10010, var_d);
 285   CHECK_CALL (t9v (ci, i), 100011 + 12i, var_cd);
 286 }
 287
 288 /* Test functions rounding result to narrower type.  */
 289
 290 float t10d (double x) { return 1 + x; }
 291 float t10l (long double x) { return 2 + x; }
 292
 293 #define t10v(x) __builtin_tgmath (t10d, t10l, x)
 294
 295 static void
 296 test_10 (void)
 297 {
 298   float f = 1;
 299   double d = 2;
 300   long double ld = 3;
 301   short s = 4;
 302   CHECK_CALL (t10v (f), 2, var_f);
 303   CHECK_CALL (t10v (d), 3, var_f);
 304   CHECK_CALL (t10v (ld), 5, var_f);
 305   CHECK_CALL (t10v (s), 5, var_f);
 306 }
 307
 308 int
 309 main (void)
 310 {
 311   test_1 ();
 312   test_2 ();
 313   test_3 ();
 314   test_4 ();
 315   test_5 ();
 316   test_6 ();
 317   test_7 ();
 318   test_8 ();
 319   test_9 ();
 320   test_10 ();
 321   exit (0);
 322 }