Debian Codegraph @

gcc/testsuite/gcc.target/powerpc/builtins-3-runnable.c

raw
1 /* { dg-do run { target { vsx_hw } } } */
2 /* { dg-require-effective-target vsx_hw } */
3 /* { dg-options "-maltivec -mvsx" } */
4
5 #include <altivec.h> // vector
6
7 #ifdef DEBUG
8 #include <stdio.h>
9 #endif
10
11 #define ALL 1
12 #define EVEN 2
13 #define ODD 3
14
15 void abort (void);
16
17 void test_int_result(int check, vector int vec_result, vector int vec_expected)
18 {
19 int i;
20
21 for (i = 0; i < 4; i++) {
22 switch (check) {
23 case ALL:
24 break;
25 case EVEN:
26 if (i%2 == 0)
27 break;
28 else
29 continue;
30 case ODD:
31 if (i%2 != 0)
32 break;
33 else
34 continue;
35 }
36
37 if (vec_result[i] != vec_expected[i]) {
38 #ifdef DEBUG
39 printf("Test_int_result: ");
40 printf("vec_result[%d] (%d) != vec_expected[%d] (%d)\n",
41 i, vec_result[i], i, vec_expected[i]);
42 #else
43 abort();
44 #endif
45 }
46 }
47 }
48
49 void test_unsigned_int_result(int check, vector unsigned int vec_result,
50 vector unsigned int vec_expected)
51 {
52 int i;
53
54 for (i = 0; i < 4; i++) {
55 switch (check) {
56 case ALL:
57 break;
58 case EVEN:
59 if (i%2 == 0)
60 break;
61 else
62 continue;
63 case ODD:
64 if (i%2 != 0)
65 break;
66 else
67 continue;
68 }
69
70 if (vec_result[i] != vec_expected[i]) {
71 #ifdef DEBUG
72 printf("Test_unsigned int_result: ");
73 printf("vec_result[%d] (%d) != vec_expected[%d] (%d)\n",
74 i, vec_result[i], i, vec_expected[i]);
75 #else
76 abort();
77 #endif
78 }
79
80 }
81 }
82
83 void test_ll_int_result(vector long long int vec_result,
84 vector long long int vec_expected,
85 char *string)
86 {
87 int i;
88
89 for (i = 0; i < 2; i++)
90 if (vec_result[i] != vec_expected[i]) {
91 #ifdef DEBUG
92 printf("Test_ll_int_result %s: ", string);
93 printf("vec_result[%d] (%lld) != vec_expected[%d] (%lld)\n",
94 i, vec_result[i], i, vec_expected[i]);
95 #else
96 abort();
97 #endif
98 }
99 }
100
101 void test_ll_unsigned_int_result(vector long long unsigned int vec_result,
102 vector long long unsigned int vec_expected,
103 char *string)
104 {
105 int i;
106
107 for (i = 0; i < 2; i++)
108 if (vec_result[i] != vec_expected[i]) {
109 #ifdef DEBUG
110 printf("Test_ll_unsigned_int_result %s: ", string);
111 printf("vec_result[%d] (%lld) != vec_expected[%d] (%lld)\n",
112 i, vec_result[i], i, vec_expected[i]);
113 #else
114 abort();
115 #endif
116 }
117 }
118
119 void test_result_sp(int check, vector float vec_result,
120 vector float vec_expected)
121 {
122 int i;
123 for(i = 0; i<4; i++) {
124
125 switch (check) {
126 case ALL:
127 break;
128 case EVEN:
129 if (i%2 == 0)
130 break;
131 else
132 continue;
133 case ODD:
134 if (i%2 != 0)
135 break;
136 else
137 continue;
138 }
139
140 if (vec_result[i] != vec_expected[i]) {
141 #ifdef DEBUG
142 printf("Test_result_sp: ");
143 printf("vec_result[%d] (%f) != vec_expected[%d] (%f)\n",
144 i, vec_result[i], i, vec_expected[i]);
145 #else
146 abort();
147 #endif
148 }
149 }
150 }
151
152 void test_result_dp(vector double vec_result, vector double vec_expected)
153 {
154 if (vec_result[0] != vec_expected[0]) {
155 #ifdef DEBUG
156 printf("Test_result_dp: ");
157 printf("vec_result[0] (%f) != vec_expected[0] (%f)\n",
158 vec_result[0], vec_expected[0]);
159 #else
160 abort();
161 #endif
162 }
163
164 if (vec_result[1] != vec_expected[1]) {
165 #ifdef DEBUG
166 printf("Test_result_dp: ");
167 printf("vec_result[1] (%lld) != vec_expected[1] (%lld)\n",
168 vec_result[1], vec_expected[1]);
169 #else
170 abort();
171 #endif
172 }
173 }
174
175 int main()
176 {
177 int i;
178 vector unsigned int vec_unint, vec_uns_int_expected, vec_uns_int_result;
179 vector signed int vec_int, vec_int_expected, vec_int_result;
180 vector long long int vec_ll_int0, vec_ll_int1;
181 vector long long int vec_ll_int_expected, vec_ll_int_result;
182 vector long long unsigned int vec_ll_uns_int0, vec_ll_uns_int1;
183 vector long long unsigned int vec_ll_uns_int_expected, vec_ll_uns_int_result;
184 vector float vec_flt0, vec_flt1, vec_flt_result, vec_flt_expected;
185 vector double vec_dble0, vec_dble1, vec_dble_result, vec_dble_expected;
186
187 vec_int = (vector signed int){ -1, 3, -5, 1234567 };
188 vec_ll_int0 = (vector long long int){ -12, -12345678901234 };
189 vec_ll_int1 = (vector long long int){ 12, 9876543210 };
190 vec_unint = (vector unsigned int){ 9, 11, 15, 2468013579 };
191 vec_ll_uns_int0 = (vector unsigned long long int){ 102, 9753108642 };
192 vec_ll_uns_int1 = (vector unsigned long long int){ 23, 29 };
193 vec_flt0 = (vector float){ -21., 3.5, -53., 78. };
194 vec_dble0 = (vector double){ 34.0, 97.0 };
195 vec_dble1 = (vector double){ 214.0, -5.5 };
196
197 /* conversion of words 0 and 2 */
198 vec_dble_expected = (vector double){-1.000000, -5.000000};
199 vec_dble_result = vec_doublee (vec_int);
200 test_result_dp(vec_dble_result, vec_dble_expected);
201
202 vec_dble_expected = (vector double){9.000000, 15.000000};
203 vec_dble_result = vec_doublee (vec_unint);
204 test_result_dp(vec_dble_result, vec_dble_expected);
205
206 vec_dble_expected = (vector double){-21.000000, -53.000000};
207 vec_dble_result = vec_doublee (vec_flt0);
208 test_result_dp(vec_dble_result, vec_dble_expected);
209
210
211 /* conversion of words 1 and 3 */
212 vec_dble_expected = (vector double){3.000000, 1234567.000000};
213 vec_dble_result = vec_doubleo (vec_int);
214 test_result_dp(vec_dble_result, vec_dble_expected);
215
216 vec_dble_expected = (vector double){11.000000, 2468013579.000000};
217 vec_dble_result = vec_doubleo (vec_unint);
218 test_result_dp(vec_dble_result, vec_dble_expected);
219
220 vec_dble_expected = (vector double){3.500000, 78.000000};
221 vec_dble_result = vec_doubleo (vec_flt0);
222 test_result_dp(vec_dble_result, vec_dble_expected);
223
224
225 /* conversion of words 0 and 1 */
226 vec_dble_expected = (vector double){-5.000000, 1234567.000000};
227 vec_dble_result = vec_doublel (vec_int);
228 test_result_dp(vec_dble_result, vec_dble_expected);
229
230 vec_dble_expected = (vector double){15.000000, 2468013579.000000};
231 vec_dble_result = vec_doublel (vec_unint);
232 test_result_dp(vec_dble_result, vec_dble_expected);
233
234 vec_dble_expected = (vector double){-53.000000, 78.000000};
235 vec_dble_result = vec_doublel (vec_flt0);
236 test_result_dp(vec_dble_result, vec_dble_expected);
237
238
239 /* conversion of words 2 and 3 */
240 vec_dble_expected = (vector double){-1.000000, 3.000000};
241 vec_dble_result = vec_doubleh (vec_int);
242 test_result_dp(vec_dble_result, vec_dble_expected);
243
244 vec_dble_expected = (vector double){9.000000, 11.000000};
245 vec_dble_result = vec_doubleh (vec_unint);
246 test_result_dp(vec_dble_result, vec_dble_expected);
247
248 vec_dble_expected = (vector double){-21.000000, 3.500000};
249 vec_dble_result = vec_doubleh (vec_flt0);
250 test_result_dp(vec_dble_result, vec_dble_expected);
251
252 /* conversion of integer vector to single precision float vector */
253 vec_flt_expected = (vector float){-1.00, 3.00, -5.00, 1234567.00};
254 vec_flt_result = vec_float (vec_int);
255 test_result_sp(ALL, vec_flt_result, vec_flt_expected);
256
257 vec_flt_expected = (vector float){9.00, 11.00, 15.00, 2468013579.0};
258 vec_flt_result = vec_float (vec_unint);
259 test_result_sp(ALL, vec_flt_result, vec_flt_expected);
260
261 /* conversion of even words in double precision vector to single precision vector */
262 vec_flt_expected = (vector float){-12.00, 00.00, -12345678901234.00, 0.00};
263 vec_flt_result = vec_floate (vec_ll_int0);
264 test_result_sp(EVEN, vec_flt_result, vec_flt_expected);
265
266 vec_flt_expected = (vector float){102.00, 0.00, 9753108642.00, 0.00};
267 vec_flt_result = vec_floate (vec_ll_uns_int0);
268 test_result_sp(EVEN, vec_flt_result, vec_flt_expected);
269
270 vec_flt_expected = (vector float){34.00, 0.00, 97.00, 0.00};
271 vec_flt_result = vec_floate (vec_dble0);
272 test_result_sp(EVEN, vec_flt_result, vec_flt_expected);
273
274 /* conversion of odd words in double precision vector to single precision vector */
275 vec_flt_expected = (vector float){0.00, -12.00, 00.00, -12345678901234.00};
276 vec_flt_result = vec_floato (vec_ll_int0);
277 test_result_sp(ODD, vec_flt_result, vec_flt_expected);
278
279 vec_flt_expected = (vector float){0.00, 102.00, 0.00, 9753108642.00};
280 vec_flt_result = vec_floato (vec_ll_uns_int0);
281 test_result_sp(ODD, vec_flt_result, vec_flt_expected);
282
283 vec_flt_expected = (vector float){0.00, 34.00, 0.00, 97.00};
284 vec_flt_result = vec_floato (vec_dble0);
285 test_result_sp(ODD, vec_flt_result, vec_flt_expected);
286
287 /* Convert single precision float to int */
288 vec_flt0 = (vector float){-14.30, 34.00, 22.00, 97.00};
289 vec_int_expected = (vector signed int){-14, 34, 22, 97};
290 vec_int_result = vec_signed (vec_flt0);
291 test_int_result (ALL, vec_int_result, vec_int_expected);
292
293 /* Convert double precision float to long long int */
294 vec_dble0 = (vector double){-124.930, 81234.49};
295 vec_ll_int_expected = (vector long long signed int){-124, 81234};
296 vec_ll_int_result = vec_signed (vec_dble0);
297 test_ll_int_result (vec_ll_int_result, vec_ll_int_expected,
298 "vec_signed");
299
300 /* Convert double precision vector float to vector int, even words */
301 vec_dble0 = (vector double){-124.930, 81234.49};
302 vec_int_expected = (vector signed int){-124, 0, 81234, 0};
303 vec_int_result = vec_signede (vec_dble0);
304 test_int_result (EVEN, vec_int_result, vec_int_expected);
305
306 /* Convert double precision vector float to vector int, odd words */
307 vec_dble0 = (vector double){-124.930, 81234.49};
308 vec_int_expected = (vector signed int){0, -124, 0, 81234};
309 vec_int_result = vec_signedo (vec_dble0);
310 test_int_result (ODD, vec_int_result, vec_int_expected);
311
312 /* Convert single precision float to unsigned int */
313 vec_flt0 = (vector float){124.930, 8134.49, 23.3, 45.4};
314 vec_uns_int_expected = (vector unsigned int){124, 8134, 23, 45};
315 vec_uns_int_result = vec_unsigned (vec_flt0);
316 test_unsigned_int_result (ALL, vec_uns_int_result,
317 vec_uns_int_expected);
318
319 /* Convert single precision float to unsigned int. Negative
320 arguments. */
321 vec_flt0 = (vector float){-14.930, -834.49, -3.3, -5.4};
322 vec_uns_int_expected = (vector unsigned int){0, 0, 0, 0};
323 vec_uns_int_result = vec_unsigned (vec_flt0);
324 test_unsigned_int_result (ALL, vec_uns_int_result,
325 vec_uns_int_expected);
326
327 /* Convert single precision vector float, even args, to vector
328 signed long long int. */
329 vec_flt0 = (vector float){14.930, 834.49, -3.3, -5.4};
330 vec_ll_int_expected = (vector signed long long int){14, -3};
331 vec_ll_int_result = vec_signede (vec_flt0);
332 test_ll_int_result (vec_ll_int_result, vec_ll_int_expected,
333 "vec_signede");
334
335 /* Convert single precision vector float, odd args, to vector
336 signed long long int. */
337 vec_flt0 = (vector float){14.930, 834.49, -3.3, -5.4};
338 vec_ll_int_expected = (vector signed long long int){834, -5};
339 vec_ll_int_result = vec_signedo (vec_flt0);
340 test_ll_int_result (vec_ll_int_result, vec_ll_int_expected,
341 "vec_signedo");
342
343 /* Convert single precision vector float, even args, to vector
344 unsigned long long int. */
345 vec_flt0 = (vector float){14.930, 834.49, -3.3, -5.4};
346 vec_ll_uns_int_expected = (vector unsigned long long int){14, 0};
347 vec_ll_uns_int_result = vec_unsignede (vec_flt0);
348 test_ll_unsigned_int_result (vec_ll_uns_int_result,
349 vec_ll_uns_int_expected, "vec_unsignede");
350
351 /* Convert single precision vector float, odd args, to vector
352 unsigned long long int. */
353 vec_flt0 = (vector float){14.930, 834.49, -3.3, -5.4};
354 vec_ll_uns_int_expected = (vector unsigned long long int){834, 0};
355 vec_ll_uns_int_result = vec_unsignedo (vec_flt0);
356 test_ll_unsigned_int_result (vec_ll_uns_int_result,
357 vec_ll_uns_int_expected, "vec_unsignedo");
358
359 /* Convert double precision float to long long unsigned int */
360 vec_dble0 = (vector double){124.930, 8134.49};
361 vec_ll_uns_int_expected = (vector long long unsigned int){124, 8134};
362 vec_ll_uns_int_result = vec_unsigned (vec_dble0);
363 test_ll_unsigned_int_result (vec_ll_uns_int_result,
364 vec_ll_uns_int_expected, "vec_unsigned");
365
366 /* Convert double precision float to long long unsigned int. Negative
367 arguments. */
368 vec_dble0 = (vector double){-24.93, -134.9};
369 vec_ll_uns_int_expected = (vector long long unsigned int){0, 0};
370 vec_ll_uns_int_result = vec_unsigned (vec_dble0);
371 test_ll_unsigned_int_result (vec_ll_uns_int_result,
372 vec_ll_uns_int_expected, "vec_unsigned");
373
374 /* Convert double precision vector float to vector unsigned int,
375 even words. Negative arguments */
376 vec_dble0 = (vector double){-124.930, -234.49};
377 vec_uns_int_expected = (vector unsigned int){0, 0, 0, 0};
378 vec_uns_int_result = vec_unsignede (vec_dble0);
379 test_unsigned_int_result (EVEN, vec_uns_int_result,
380 vec_uns_int_expected);
381
382 /* Convert double precision vector float to vector unsigned int,
383 odd words */
384 vec_dble0 = (vector double){1924.930, 81234.49};
385 vec_uns_int_expected = (vector unsigned int){0, 1924, 0, 81234};
386 vec_uns_int_result = vec_unsignedo (vec_dble0);
387 test_unsigned_int_result (ODD, vec_uns_int_result,
388 vec_uns_int_expected);
389
390 /* Convert double precision vector float to vector unsigned int,
391 odd words. Negative arguments. */
392 vec_dble0 = (vector double){-924.930, -1234.49};
393 vec_uns_int_expected = (vector unsigned int){0, 0, 0, 0};
394 vec_uns_int_result = vec_unsignedo (vec_dble0);
395 test_unsigned_int_result (ODD, vec_uns_int_result,
396 vec_uns_int_expected);
397 }
398