gcc/testsuite/gcc.target/powerpc/pr92132-fp-1.c

   1 /* { dg-do run } */
   2 /* { dg-require-effective-target vsx_hw } */
   3 /* { dg-options "-O2 -ftree-vectorize -mvsx -fno-vect-cost-model -fdump-tree-vect-details" } */
   4
   5 /* To test condition reduction vectorization, where comparison operands are of
   6    double type and condition true/false values are integer type.  Cover all
   7    float point comparison codes.  */
   8
   9 #include <math.h>
  10
  11 extern void
  12 abort (void) __attribute__ ((noreturn));
  13
  14 #define N 27
  15 #define FP_TYPE double
  16
  17 #define LTGT(a, b) (__builtin_islessgreater ((a), (b)))
  18 #define UNORD(a, b) (__builtin_isunordered ((a), (b)))
  19 #define ORD(a, b) (!__builtin_isunordered ((a), (b)))
  20 #define UNEQ(a, b) (!__builtin_islessgreater ((a), (b)))
  21 #define UNGT(a, b) (!__builtin_islessequal ((a), (b)))
  22 #define UNGE(a, b) (!__builtin_isless ((a), (b)))
  23 #define UNLT(a, b) (!__builtin_isgreaterequal ((a), (b)))
  24 #define UNLE(a, b) (!__builtin_isgreater ((a), (b)))
  25
  26 __attribute__ ((noinline)) int
  27 test_eq (FP_TYPE *a, FP_TYPE min_v)
  28 {
  29   int last = 0;
  30
  31   for (int i = 0; i < N; i++)
  32     if (a[i] == min_v)
  33       last = i;
  34
  35   return last;
  36 }
  37
  38 __attribute__ ((noinline)) int
  39 test_ne (FP_TYPE *a, FP_TYPE min_v)
  40 {
  41   int last = 0;
  42
  43   for (int i = 0; i < N; i++)
  44     if (a[i] != min_v)
  45       last = i;
  46
  47   return last;
  48 }
  49
  50 __attribute__ ((noinline)) int
  51 test_gt (FP_TYPE *a, FP_TYPE min_v)
  52 {
  53   int last = 0;
  54
  55   for (int i = 0; i < N; i++)
  56     if (a[i] > min_v)
  57       last = i;
  58
  59   return last;
  60 }
  61
  62 __attribute__ ((noinline)) int
  63 test_ge (FP_TYPE *a, FP_TYPE min_v)
  64 {
  65   int last = 0;
  66
  67   for (int i = 0; i < N; i++)
  68     if (a[i] >= min_v)
  69       last = i;
  70
  71   return last;
  72 }
  73
  74 __attribute__ ((noinline)) int
  75 test_lt (FP_TYPE *a, FP_TYPE min_v)
  76 {
  77   int last = 0;
  78
  79   for (int i = 0; i < N; i++)
  80     if (a[i] < min_v)
  81       last = i;
  82
  83   return last;
  84 }
  85
  86 __attribute__ ((noinline)) int
  87 test_le (FP_TYPE *a, FP_TYPE min_v)
  88 {
  89   int last = 0;
  90
  91   for (int i = 0; i < N; i++)
  92     if (a[i] <= min_v)
  93       last = i;
  94
  95   return last;
  96 }
  97
  98 __attribute__ ((noinline)) int
  99 test_ltgt (FP_TYPE *a, FP_TYPE min_v)
 100 {
 101   int last = 0;
 102
 103   for (int i = 0; i < N; i++)
 104     if (LTGT (a[i], min_v))
 105       last = i;
 106
 107   return last;
 108 }
 109
 110 __attribute__ ((noinline)) int
 111 test_ord (FP_TYPE *a, FP_TYPE min_v)
 112 {
 113   int last = 0;
 114
 115   for (int i = 0; i < N; i++)
 116     if (ORD (a[i], min_v))
 117       last = i;
 118
 119   return last;
 120 }
 121
 122 __attribute__ ((noinline)) int
 123 test_unord (FP_TYPE *a, FP_TYPE min_v)
 124 {
 125   int last = 0;
 126
 127   for (int i = 0; i < N; i++)
 128     if (UNORD (a[i], min_v))
 129       last = i;
 130
 131   return last;
 132 }
 133
 134 __attribute__ ((noinline)) int
 135 test_uneq (FP_TYPE *a, FP_TYPE min_v)
 136 {
 137   int last = 0;
 138
 139   for (int i = 0; i < N; i++)
 140     if (UNEQ (a[i], min_v))
 141       last = i;
 142
 143   return last;
 144 }
 145
 146 __attribute__ ((noinline)) int
 147 test_ungt (FP_TYPE *a, FP_TYPE min_v)
 148 {
 149   int last = 0;
 150
 151   for (int i = 0; i < N; i++)
 152     if (UNGT (a[i], min_v))
 153       last = i;
 154
 155   return last;
 156 }
 157
 158 __attribute__ ((noinline)) int
 159 test_unge (FP_TYPE *a, FP_TYPE min_v)
 160 {
 161   int last = 0;
 162
 163   for (int i = 0; i < N; i++)
 164     if (UNGE (a[i], min_v))
 165       last = i;
 166
 167   return last;
 168 }
 169
 170 __attribute__ ((noinline)) int
 171 test_unlt (FP_TYPE *a, FP_TYPE min_v)
 172 {
 173   int last = 0;
 174
 175   for (int i = 0; i < N; i++)
 176     if (UNLT (a[i], min_v))
 177       last = i;
 178
 179   return last;
 180 }
 181
 182 __attribute__ ((noinline)) int
 183 test_unle (FP_TYPE *a, FP_TYPE min_v)
 184 {
 185   int last = 0;
 186
 187   for (int i = 0; i < N; i++)
 188     if (UNLE (a[i], min_v))
 189       last = i;
 190
 191   return last;
 192 }
 193
 194 int
 195 main (void)
 196 {
 197   int ret = 0;
 198
 199   FP_TYPE a1[N] = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 1,  2,  3, 4,
 200                    5,  6,  7,  8,  9,  10, 21, 22, 23, 24, 25, 26, 27};
 201
 202   FP_TYPE a2[N] = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20,  1,  2,  3, 4,
 203                    5,  6,  7,  8,  9,  10, 21, 22, 23, NAN, 25, 26, 27};
 204
 205   FP_TYPE a3[N] = {21, 22, 23, 24, 25, 26, 27, 28, 29, 10, 11, 12, 13, 14,
 206                    15, 16, 17, 18, 19, 20, 1,  2,  3,  4,  5,  6,  7};
 207
 208   FP_TYPE a4[N] = {21, 22, 23, 24, 25, 26, 27, 28, 29, 10, 11,  12, 13, 14,
 209                    15, 16, 17, 18, 19, 20, 1,  2,  3,  4,  NAN, 6,  7};
 210
 211   FP_TYPE a5[N] = {21, 22, 23, 24, 25, 26, 27, 28, 29, 10, 11,  12, 13, 14,
 212                    15, 16, 17, 18, 19, 20, 1,  2,  3,  4,  NAN, 10, 10};
 213
 214   ret = test_eq (a1, 10);
 215   if (ret != 19)
 216     abort ();
 217
 218   ret = test_ne (a1, 10);
 219   if (ret != 26)
 220     abort ();
 221
 222   ret = test_gt (a3, 10);
 223   if (ret != 19)
 224     abort ();
 225
 226   ret = test_ge (a3, 10);
 227   if (ret != 19)
 228     abort ();
 229
 230   ret = test_lt (a1, 10);
 231   if (ret != 18)
 232     abort ();
 233
 234   ret = test_le (a1, 10);
 235   if (ret != 19)
 236     abort ();
 237
 238   ret = test_ltgt (a3, 10);
 239   if (ret != 26)
 240     abort ();
 241
 242   ret = test_ltgt (a5, 10);
 243   if (ret != 23)
 244     abort ();
 245
 246   ret = test_unord (a5, 10);
 247   if (ret != 24)
 248     abort ();
 249
 250   ret = test_ord (a5, 10);
 251   if (ret != 26)
 252     abort ();
 253
 254   ret = test_uneq (a1, 10);
 255   if (ret != 19)
 256     abort ();
 257
 258   ret = test_uneq (a4, 10);
 259   if (ret != 24)
 260     abort ();
 261
 262   ret = test_ungt (a3, 10);
 263   if (ret != 19)
 264     abort ();
 265
 266   ret = test_ungt (a4, 10);
 267   if (ret != 24)
 268     abort ();
 269
 270   ret = test_unge (a3, 10);
 271   if (ret != 19)
 272     abort ();
 273
 274   ret = test_ungt (a4, 10);
 275   if (ret != 24)
 276     abort ();
 277
 278   ret = test_unlt (a1, 10);
 279   if (ret != 18)
 280     abort ();
 281
 282   ret = test_unlt (a2, 10);
 283   if (ret != 23)
 284     abort ();
 285
 286   ret = test_unle (a1, 10);
 287   if (ret != 19)
 288     abort ();
 289
 290   ret = test_unle (a2, 10);
 291   if (ret != 23)
 292     abort ();
 293
 294   return 0;
 295 }
 296
 297 /* { dg-final { scan-tree-dump-times "LOOP VECTORIZED" 14 "vect" { target has_arch_pwr8 } } } */