gcc/testsuite/gcc.c-torture/execute/ieee/fp-cmp-8.c

   1 #ifndef FLOAT
   2 #define FLOAT double
   3 #endif
   4
   5 /* Like fp-cmp-4.c, but test that the cmove patterns are correct.  */
   6
   7 static FLOAT
   8 test_isunordered(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
   9 {
  10   return __builtin_isunordered(x, y) ? a : b;
  11 }
  12
  13 static FLOAT
  14 test_not_isunordered(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
  15 {
  16   return !__builtin_isunordered(x, y) ? a : b;
  17 }
  18
  19 static FLOAT
  20 test_isless(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
  21 {
  22   return __builtin_isless(x, y) ? a : b;
  23 }
  24
  25 static FLOAT
  26 test_not_isless(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
  27 {
  28   return !__builtin_isless(x, y) ? a : b;
  29 }
  30
  31 static FLOAT
  32 test_islessequal(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
  33 {
  34   return __builtin_islessequal(x, y) ? a : b;
  35 }
  36
  37 static FLOAT
  38 test_not_islessequal(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
  39 {
  40   return !__builtin_islessequal(x, y) ? a : b;
  41 }
  42
  43 static FLOAT
  44 test_isgreater(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
  45 {
  46   return __builtin_isgreater(x, y) ? a : b;
  47 }
  48
  49 static FLOAT
  50 test_not_isgreater(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
  51 {
  52   return !__builtin_isgreater(x, y) ? a : b;
  53 }
  54
  55 static FLOAT
  56 test_isgreaterequal(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
  57 {
  58   return __builtin_isgreaterequal(x, y) ? a : b;
  59 }
  60
  61 static FLOAT
  62 test_not_isgreaterequal(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
  63 {
  64   return !__builtin_isgreaterequal(x, y) ? a : b;
  65 }
  66
  67 static FLOAT
  68 test_islessgreater(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
  69 {
  70   return __builtin_islessgreater(x, y) ? a : b;
  71 }
  72
  73 static FLOAT
  74 test_not_islessgreater(FLOAT x, FLOAT y, FLOAT a, FLOAT b)
  75 {
  76   return !__builtin_islessgreater(x, y) ? a : b;
  77 }
  78
  79 static void
  80 one_test(FLOAT x, FLOAT y, int expected,
  81          FLOAT (*pos) (FLOAT, FLOAT, FLOAT, FLOAT),
  82          FLOAT (*neg) (FLOAT, FLOAT, FLOAT, FLOAT))
  83 {
  84   if (((*pos)(x, y, 1.0, 2.0) == 1.0) != expected)
  85     abort ();
  86   if (((*neg)(x, y, 3.0, 4.0) == 4.0) != expected)
  87     abort ();
  88 }
  89
  90 #define NAN (0.0 / 0.0)
  91 #define INF (1.0 / 0.0)
  92
  93 int
  94 main()
  95 {
  96   struct try
  97   {
  98     FLOAT x, y;
  99     int result[6];
 100   };
 101
 102   static struct try const data[] =
 103   {
 104     { NAN, NAN, { 1, 0, 0, 0, 0, 0 } },
 105     { 0.0, NAN, { 1, 0, 0, 0, 0, 0 } },
 106     { NAN, 0.0, { 1, 0, 0, 0, 0, 0 } },
 107     { 0.0, 0.0, { 0, 0, 1, 0, 1, 0 } },
 108     { 1.0, 2.0, { 0, 1, 1, 0, 0, 1 } },
 109     { 2.0, 1.0, { 0, 0, 0, 1, 1, 1 } },
 110     { INF, 0.0, { 0, 0, 0, 1, 1, 1 } },
 111     { 1.0, INF, { 0, 1, 1, 0, 0, 1 } },
 112     { INF, INF, { 0, 0, 1, 0, 1, 0 } },
 113     { 0.0, -INF, { 0, 0, 0, 1, 1, 1 } },
 114     { -INF, 1.0, { 0, 1, 1, 0, 0, 1 } },
 115     { -INF, -INF, { 0, 0, 1, 0, 1, 0 } },
 116     { INF, -INF, { 0, 0, 0, 1, 1, 1 } },
 117     { -INF, INF, { 0, 1, 1, 0, 0, 1 } },
 118   };
 119
 120   struct test
 121   {
 122     FLOAT (*pos)(FLOAT, FLOAT, FLOAT, FLOAT);
 123     FLOAT (*neg)(FLOAT, FLOAT, FLOAT, FLOAT);
 124   };
 125
 126   static struct test const tests[] =
 127   {
 128     { test_isunordered, test_not_isunordered },
 129     { test_isless, test_not_isless },
 130     { test_islessequal, test_not_islessequal },
 131     { test_isgreater, test_not_isgreater },
 132     { test_isgreaterequal, test_not_isgreaterequal },
 133     { test_islessgreater, test_not_islessgreater }
 134   };
 135
 136   const int n = sizeof(data) / sizeof(data[0]);
 137   int i, j;
 138
 139   for (i = 0; i < n; ++i)
 140     for (j = 0; j < 6; ++j)
 141       one_test (data[i].x, data[i].y, data[i].result[j],
 142                 tests[j].pos, tests[j].neg);
 143
 144   exit (0);
 145 }