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 } } } */