compiler-rt/test/builtins/Unit/mulxc3_test.c

   1 // RUN: %clang_builtins %s %librt -lm -o %t && %run %t
   2 // REQUIRES: librt_has_mulxc3
   3 // UNSUPPORTED: target=powerpc64{{.*}}
   4 // REQUIRES: x86-target-arch
   5 // UNSUPPORTED: target=mips{{.*}}
   6 // REQUIRES: c99-complex
   7
   8 #if !_ARCH_PPC
   9
  10 #include "int_lib.h"
  11 #include <math.h>
  12 #include <complex.h>
  13 #include <stdio.h>
  14
  15
  16 // Returns: the product of a + ib and c + id
  17
  18 COMPILER_RT_ABI long double _Complex
  19 __mulxc3(long double __a, long double __b, long double __c, long double __d);
  20
  21 enum {zero, non_zero, inf, NaN, non_zero_nan};
  22
  23 int
  24 classify(long double _Complex x)
  25 {
  26     if (x == 0)
  27         return zero;
  28     if (isinf(creall(x)) || isinf(cimagl(x)))
  29         return inf;
  30     if (isnan(creall(x)) && isnan(cimagl(x)))
  31         return NaN;
  32     if (isnan(creall(x)))
  33     {
  34         if (cimagl(x) == 0)
  35             return NaN;
  36         return non_zero_nan;
  37     }
  38     if (isnan(cimagl(x)))
  39     {
  40         if (creall(x) == 0)
  41             return NaN;
  42         return non_zero_nan;
  43     }
  44     return non_zero;
  45 }
  46
  47 int test__mulxc3(long double a, long double b, long double c, long double d)
  48 {
  49     long double _Complex r = __mulxc3(a, b, c, d);
  50 //     printf("test__mulxc3(%Lf, %Lf, %Lf, %Lf) = %Lf + I%Lf\n",
  51 //             a, b, c, d, creall(r), cimagl(r));
  52         long double _Complex dividend;
  53         long double _Complex divisor;
  54
  55         __real__ dividend = a;
  56         __imag__ dividend = b;
  57         __real__ divisor = c;
  58         __imag__ divisor = d;
  59
  60     switch (classify(dividend))
  61     {
  62     case zero:
  63         switch (classify(divisor))
  64         {
  65         case zero:
  66             if (classify(r) != zero)
  67                 return 1;
  68             break;
  69         case non_zero:
  70             if (classify(r) != zero)
  71                 return 1;
  72             break;
  73         case inf:
  74             if (classify(r) != NaN)
  75                 return 1;
  76             break;
  77         case NaN:
  78             if (classify(r) != NaN)
  79                 return 1;
  80             break;
  81         case non_zero_nan:
  82             if (classify(r) != NaN)
  83                 return 1;
  84             break;
  85         }
  86         break;
  87     case non_zero:
  88         switch (classify(divisor))
  89         {
  90         case zero:
  91             if (classify(r) != zero)
  92                 return 1;
  93             break;
  94         case non_zero:
  95             if (classify(r) != non_zero)
  96                 return 1;
  97             if (r != a * c - b * d + _Complex_I*(a * d + b * c))
  98                 return 1;
  99             break;
 100         case inf:
 101             if (classify(r) != inf)
 102                 return 1;
 103             break;
 104         case NaN:
 105             if (classify(r) != NaN)
 106                 return 1;
 107             break;
 108         case non_zero_nan:
 109             if (classify(r) != NaN)
 110                 return 1;
 111             break;
 112         }
 113         break;
 114     case inf:
 115         switch (classify(divisor))
 116         {
 117         case zero:
 118             if (classify(r) != NaN)
 119                 return 1;
 120             break;
 121         case non_zero:
 122             if (classify(r) != inf)
 123                 return 1;
 124             break;
 125         case inf:
 126             if (classify(r) != inf)
 127                 return 1;
 128             break;
 129         case NaN:
 130             if (classify(r) != NaN)
 131                 return 1;
 132             break;
 133         case non_zero_nan:
 134             if (classify(r) != inf)
 135                 return 1;
 136             break;
 137         }
 138         break;
 139     case NaN:
 140         switch (classify(divisor))
 141         {
 142         case zero:
 143             if (classify(r) != NaN)
 144                 return 1;
 145             break;
 146         case non_zero:
 147             if (classify(r) != NaN)
 148                 return 1;
 149             break;
 150         case inf:
 151             if (classify(r) != NaN)
 152                 return 1;
 153             break;
 154         case NaN:
 155             if (classify(r) != NaN)
 156                 return 1;
 157             break;
 158         case non_zero_nan:
 159             if (classify(r) != NaN)
 160                 return 1;
 161             break;
 162         }
 163         break;
 164     case non_zero_nan:
 165         switch (classify(divisor))
 166         {
 167         case zero:
 168             if (classify(r) != NaN)
 169                 return 1;
 170             break;
 171         case non_zero:
 172             if (classify(r) != NaN)
 173                 return 1;
 174             break;
 175         case inf:
 176             if (classify(r) != inf)
 177                 return 1;
 178             break;
 179         case NaN:
 180             if (classify(r) != NaN)
 181                 return 1;
 182             break;
 183         case non_zero_nan:
 184             if (classify(r) != NaN)
 185                 return 1;
 186             break;
 187         }
 188         break;
 189     }
 190
 191     return 0;
 192 }
 193
 194 long double x[][2] =
 195 {
 196     { 1.e-6,  1.e-6},
 197     {-1.e-6,  1.e-6},
 198     {-1.e-6, -1.e-6},
 199     { 1.e-6, -1.e-6},
 200
 201     { 1.e+6,  1.e-6},
 202     {-1.e+6,  1.e-6},
 203     {-1.e+6, -1.e-6},
 204     { 1.e+6, -1.e-6},
 205
 206     { 1.e-6,  1.e+6},
 207     {-1.e-6,  1.e+6},
 208     {-1.e-6, -1.e+6},
 209     { 1.e-6, -1.e+6},
 210
 211     { 1.e+6,  1.e+6},
 212     {-1.e+6,  1.e+6},
 213     {-1.e+6, -1.e+6},
 214     { 1.e+6, -1.e+6},
 215
 216     {NAN, NAN},
 217     {-INFINITY, NAN},
 218     {-2, NAN},
 219     {-1, NAN},
 220     {-0.5, NAN},
 221     {-0., NAN},
 222     {+0., NAN},
 223     {0.5, NAN},
 224     {1, NAN},
 225     {2, NAN},
 226     {INFINITY, NAN},
 227
 228     {NAN, -INFINITY},
 229     {-INFINITY, -INFINITY},
 230     {-2, -INFINITY},
 231     {-1, -INFINITY},
 232     {-0.5, -INFINITY},
 233     {-0., -INFINITY},
 234     {+0., -INFINITY},
 235     {0.5, -INFINITY},
 236     {1, -INFINITY},
 237     {2, -INFINITY},
 238     {INFINITY, -INFINITY},
 239
 240     {NAN, -2},
 241     {-INFINITY, -2},
 242     {-2, -2},
 243     {-1, -2},
 244     {-0.5, -2},
 245     {-0., -2},
 246     {+0., -2},
 247     {0.5, -2},
 248     {1, -2},
 249     {2, -2},
 250     {INFINITY, -2},
 251
 252     {NAN, -1},
 253     {-INFINITY, -1},
 254     {-2, -1},
 255     {-1, -1},
 256     {-0.5, -1},
 257     {-0., -1},
 258     {+0., -1},
 259     {0.5, -1},
 260     {1, -1},
 261     {2, -1},
 262     {INFINITY, -1},
 263
 264     {NAN, -0.5},
 265     {-INFINITY, -0.5},
 266     {-2, -0.5},
 267     {-1, -0.5},
 268     {-0.5, -0.5},
 269     {-0., -0.5},
 270     {+0., -0.5},
 271     {0.5, -0.5},
 272     {1, -0.5},
 273     {2, -0.5},
 274     {INFINITY, -0.5},
 275
 276     {NAN, -0.},
 277     {-INFINITY, -0.},
 278     {-2, -0.},
 279     {-1, -0.},
 280     {-0.5, -0.},
 281     {-0., -0.},
 282     {+0., -0.},
 283     {0.5, -0.},
 284     {1, -0.},
 285     {2, -0.},
 286     {INFINITY, -0.},
 287
 288     {NAN, 0.},
 289     {-INFINITY, 0.},
 290     {-2, 0.},
 291     {-1, 0.},
 292     {-0.5, 0.},
 293     {-0., 0.},
 294     {+0., 0.},
 295     {0.5, 0.},
 296     {1, 0.},
 297     {2, 0.},
 298     {INFINITY, 0.},
 299
 300     {NAN, 0.5},
 301     {-INFINITY, 0.5},
 302     {-2, 0.5},
 303     {-1, 0.5},
 304     {-0.5, 0.5},
 305     {-0., 0.5},
 306     {+0., 0.5},
 307     {0.5, 0.5},
 308     {1, 0.5},
 309     {2, 0.5},
 310     {INFINITY, 0.5},
 311
 312     {NAN, 1},
 313     {-INFINITY, 1},
 314     {-2, 1},
 315     {-1, 1},
 316     {-0.5, 1},
 317     {-0., 1},
 318     {+0., 1},
 319     {0.5, 1},
 320     {1, 1},
 321     {2, 1},
 322     {INFINITY, 1},
 323
 324     {NAN, 2},
 325     {-INFINITY, 2},
 326     {-2, 2},
 327     {-1, 2},
 328     {-0.5, 2},
 329     {-0., 2},
 330     {+0., 2},
 331     {0.5, 2},
 332     {1, 2},
 333     {2, 2},
 334     {INFINITY, 2},
 335
 336     {NAN, INFINITY},
 337     {-INFINITY, INFINITY},
 338     {-2, INFINITY},
 339     {-1, INFINITY},
 340     {-0.5, INFINITY},
 341     {-0., INFINITY},
 342     {+0., INFINITY},
 343     {0.5, INFINITY},
 344     {1, INFINITY},
 345     {2, INFINITY},
 346     {INFINITY, INFINITY}
 347
 348 };
 349
 350 #endif
 351
 352 int main()
 353 {
 354 #if !_ARCH_PPC
 355     const unsigned N = sizeof(x) / sizeof(x[0]);
 356     unsigned i, j;
 357     for (i = 0; i < N; ++i)
 358     {
 359         for (j = 0; j < N; ++j)
 360         {
 361             if (test__mulxc3(x[i][0], x[i][1], x[j][0], x[j][1]))
 362                 return 1;
 363         }
 364     }
 365
 366 #else
 367     printf("skipped\n");
 368 #endif
 369     return 0;
 370 }