1 /* { dg-do run { target { p8vector_hw } } } */
2 /* { dg-require-effective-target vsx_hw } */
3 /* { dg-options "-O2 -mvsx -mcpu=power8" } */
4 /* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
6 #include <altivec.h> // vector
18 void test_int_result(int check
, vector
int vec_result
, vector
int vec_expected
)
22 for (i
= 0; i
< 4; i
++) {
38 if (vec_result
[i
] != vec_expected
[i
]) {
40 printf("Test_int_result: ");
41 printf("vec_result[%d] (%d) != vec_expected[%d] (%d)\n",
42 i
, vec_result
[i
], i
, vec_expected
[i
]);
50 void test_unsigned_int_result(int check
, vector
unsigned int vec_result
,
51 vector
unsigned int vec_expected
)
55 for (i
= 0; i
< 4; i
++) {
71 if (vec_result
[i
] != vec_expected
[i
]) {
73 printf("Test_unsigned int_result: ");
74 printf("vec_result[%d] (%d) != vec_expected[%d] (%d)\n",
75 i
, vec_result
[i
], i
, vec_expected
[i
]);
84 void test_ll_int_result(vector
long long int vec_result
,
85 vector
long long int vec_expected
)
89 for (i
= 0; i
< 2; i
++)
90 if (vec_result
[i
] != vec_expected
[i
]) {
92 printf("Test_ll_int_result: ");
93 printf("vec_result[%d] (%lld) != vec_expected[%d] (%lld)\n",
94 i
, vec_result
[i
], i
, vec_expected
[i
]);
101 void test_ll_unsigned_int_result(vector
long long unsigned int vec_result
,
102 vector
long long unsigned int vec_expected
)
106 for (i
= 0; i
< 2; i
++)
107 if (vec_result
[i
] != vec_expected
[i
]) {
109 printf("Test_ll_unsigned_int_result: ");
110 printf("vec_result[%d] (%lld) != vec_expected[%d] (%lld)\n",
111 i
, vec_result
[i
], i
, vec_expected
[i
]);
118 void test_result_sp(int check
, vector
float vec_result
,
119 vector
float vec_expected
)
122 for(i
= 0; i
<4; i
++) {
139 if (vec_result
[i
] != vec_expected
[i
]) {
141 printf("Test_result_sp: ");
142 printf("vec_result[%d] (%f) != vec_expected[%d] (%f)\n",
143 i
, vec_result
[i
], i
, vec_expected
[i
]);
151 void test_result_dp(vector
double vec_result
, vector
double vec_expected
)
153 if (vec_result
[0] != vec_expected
[0]) {
155 printf("Test_result_dp: ");
156 printf("vec_result[0] (%f) != vec_expected[0] (%f)\n",
157 vec_result
[0], vec_expected
[0]);
163 if (vec_result
[1] != vec_expected
[1]) {
165 printf("Test_result_dp: ");
166 printf("vec_result[1] (%lld) != vec_expected[1] (%lld)\n",
167 vec_result
[1], vec_expected
[1]);
177 vector
unsigned int vec_unint
, vec_uns_int_expected
, vec_uns_int_result
;
178 vector
signed int vec_int
, vec_int_expected
, vec_int_result
;
179 vector
long long int vec_ll_int0
, vec_ll_int1
;
180 vector
long long int vec_ll_int_expected
, vec_ll_int_result
;
181 vector
long long unsigned int vec_ll_uns_int0
, vec_ll_uns_int1
;
182 vector
long long unsigned int vec_ll_uns_int_expected
, vec_ll_uns_int_result
;
183 vector
float vec_flt
, vec_flt_result
, vec_flt_expected
;
184 vector
double vec_dble0
, vec_dble1
, vec_dble_result
, vec_dble_expected
;
186 vec_int
= (vector
signed int){ -1, 3, -5, 1234567 };
187 vec_ll_int0
= (vector
long long int){ -12, -12345678901234 };
188 vec_ll_int1
= (vector
long long int){ 12, 9876543210 };
189 vec_unint
= (vector
unsigned int){ 9, 11, 15, 2468013579 };
190 vec_ll_uns_int0
= (vector
unsigned long long int){ 102, 9753108642 };
191 vec_ll_uns_int1
= (vector
unsigned long long int){ 23, 29 };
192 vec_flt
= (vector
float){ -21., 3.5, -53., 78. };
193 vec_dble0
= (vector
double){ 34.0, 97.0 };
194 vec_dble1
= (vector
double){ 214.0, -5.5 };
196 /* conversion of words 0 and 2 */
197 vec_dble_expected
= (vector
double){-1.000000, -5.000000};
198 vec_dble_result
= vec_doublee (vec_int
);
199 test_result_dp(vec_dble_result
, vec_dble_expected
);
201 vec_dble_expected
= (vector
double){9.000000, 15.000000};
202 vec_dble_result
= vec_doublee (vec_unint
);
203 test_result_dp(vec_dble_result
, vec_dble_expected
);
205 vec_dble_expected
= (vector
double){-21.000000, -53.000000};
206 vec_dble_result
= vec_doublee (vec_flt
);
207 test_result_dp(vec_dble_result
, vec_dble_expected
);
210 /* conversion of words 1 and 3 */
211 vec_dble_expected
= (vector
double){3.000000, 1234567.000000};
212 vec_dble_result
= vec_doubleo (vec_int
);
213 test_result_dp(vec_dble_result
, vec_dble_expected
);
215 vec_dble_expected
= (vector
double){11.000000, 2468013579.000000};
216 vec_dble_result
= vec_doubleo (vec_unint
);
217 test_result_dp(vec_dble_result
, vec_dble_expected
);
219 vec_dble_expected
= (vector
double){3.500000, 78.000000};
220 vec_dble_result
= vec_doubleo (vec_flt
);
221 test_result_dp(vec_dble_result
, vec_dble_expected
);
224 /* conversion of words 0 and 1 */
225 vec_dble_expected
= (vector
double){-5.000000, 1234567.000000};
226 vec_dble_result
= vec_doublel (vec_int
);
227 test_result_dp(vec_dble_result
, vec_dble_expected
);
229 vec_dble_expected
= (vector
double){15.000000, 2468013579.000000};
230 vec_dble_result
= vec_doublel (vec_unint
);
231 test_result_dp(vec_dble_result
, vec_dble_expected
);
233 vec_dble_expected
= (vector
double){-53.000000, 78.000000};
234 vec_dble_result
= vec_doublel (vec_flt
);
235 test_result_dp(vec_dble_result
, vec_dble_expected
);
238 /* conversion of words 2 and 3 */
239 vec_dble_expected
= (vector
double){-1.000000, 3.000000};
240 vec_dble_result
= vec_doubleh (vec_int
);
241 test_result_dp(vec_dble_result
, vec_dble_expected
);
243 vec_dble_expected
= (vector
double){9.000000, 11.000000};
244 vec_dble_result
= vec_doubleh (vec_unint
);
245 test_result_dp(vec_dble_result
, vec_dble_expected
);
247 vec_dble_expected
= (vector
double){-21.000000, 3.500000};
248 vec_dble_result
= vec_doubleh (vec_flt
);
249 test_result_dp(vec_dble_result
, vec_dble_expected
);
251 /* conversion of integer vector to single precision float vector */
252 vec_flt_expected
= (vector
float){-1.00, 3.00, -5.00, 1234567.00};
253 vec_flt_result
= vec_float (vec_int
);
254 test_result_sp(ALL
, vec_flt_result
, vec_flt_expected
);
256 vec_flt_expected
= (vector
float){9.00, 11.00, 15.00, 2468013579.0};
257 vec_flt_result
= vec_float (vec_unint
);
258 test_result_sp(ALL
, vec_flt_result
, vec_flt_expected
);
260 /* conversion of two double precision vectors to single precision vector */
261 vec_flt_expected
= (vector
float){-12.00, -12345678901234.00, 12.00, 9876543210.00};
262 vec_flt_result
= vec_float2 (vec_ll_int0
, vec_ll_int1
);
263 test_result_sp(ALL
, vec_flt_result
, vec_flt_expected
);
265 vec_flt_expected
= (vector
float){102.00, 9753108642.00, 23.00, 29.00};
266 vec_flt_result
= vec_float2 (vec_ll_uns_int0
, vec_ll_uns_int1
);
267 test_result_sp(ALL
, vec_flt_result
, vec_flt_expected
);
269 vec_flt_expected
= (vector
float){34.0, 97.0, 214.0, -5.5};
270 vec_flt_result
= vec_float2 (vec_dble0
, vec_dble1
);
271 test_result_sp(ALL
, vec_flt_result
, vec_flt_expected
);
273 /* conversion of even words in double precision vector to single precision vector */
274 vec_flt_expected
= (vector
float){-12.00, 00.00, -12345678901234.00, 0.00};
275 vec_flt_result
= vec_floate (vec_ll_int0
);
276 test_result_sp(EVEN
, vec_flt_result
, vec_flt_expected
);
278 vec_flt_expected
= (vector
float){102.00, 0.00, 9753108642.00, 0.00};
279 vec_flt_result
= vec_floate (vec_ll_uns_int0
);
280 test_result_sp(EVEN
, vec_flt_result
, vec_flt_expected
);
282 vec_flt_expected
= (vector
float){34.00, 0.00, 97.00, 0.00};
283 vec_flt_result
= vec_floate (vec_dble0
);
284 test_result_sp(EVEN
, vec_flt_result
, vec_flt_expected
);
286 /* conversion of odd words in double precision vector to single precision vector */
287 vec_flt_expected
= (vector
float){0.00, -12.00, 00.00, -12345678901234.00};
288 vec_flt_result
= vec_floato (vec_ll_int0
);
289 test_result_sp(ODD
, vec_flt_result
, vec_flt_expected
);
291 vec_flt_expected
= (vector
float){0.00, 102.00, 0.00, 9753108642.00};
292 vec_flt_result
= vec_floato (vec_ll_uns_int0
);
293 test_result_sp(ODD
, vec_flt_result
, vec_flt_expected
);
295 vec_flt_expected
= (vector
float){0.00, 34.00, 0.00, 97.00};
296 vec_flt_result
= vec_floato (vec_dble0
);
297 test_result_sp(ODD
, vec_flt_result
, vec_flt_expected
);
299 /* Convert single precision float to int */
300 vec_flt
= (vector
float){-14.30, 34.00, 22.00, 97.00};
301 vec_int_expected
= (vector
signed int){-14, 34, 22, 97};
302 vec_int_result
= vec_signed (vec_flt
);
303 test_int_result (ALL
, vec_int_result
, vec_int_expected
);
305 /* Convert double precision float to long long int */
306 vec_dble0
= (vector
double){-124.930, 81234.49};
307 vec_ll_int_expected
= (vector
long long signed int){-124, 81234};
308 vec_ll_int_result
= vec_signed (vec_dble0
);
309 test_ll_int_result (vec_ll_int_result
, vec_ll_int_expected
);
311 /* Convert two double precision vector float to vector int */
312 vec_dble0
= (vector
double){-124.930, 81234.49};
313 vec_dble1
= (vector
double){-24.370, 8354.99};
314 vec_int_expected
= (vector
signed int){-124, 81234, -24, 8354};
315 vec_int_result
= vec_signed2 (vec_dble0
, vec_dble1
);
316 test_int_result (ALL
, vec_int_result
, vec_int_expected
);
318 /* Convert double precision vector float to vector int, even words */
319 vec_dble0
= (vector
double){-124.930, 81234.49};
320 vec_int_expected
= (vector
signed int){-124, 0, 81234, 0};
321 vec_int_result
= vec_signede (vec_dble0
);
322 test_int_result (EVEN
, vec_int_result
, vec_int_expected
);
324 /* Convert double precision vector float to vector int, odd words */
325 vec_dble0
= (vector
double){-124.930, 81234.49};
326 vec_int_expected
= (vector
signed int){0, -124, 0, 81234};
327 vec_int_result
= vec_signedo (vec_dble0
);
328 test_int_result (ODD
, vec_int_result
, vec_int_expected
);
330 /* Convert double precision float to long long unsigned int */
331 vec_dble0
= (vector
double){124.930, 8134.49};
332 vec_ll_uns_int_expected
= (vector
long long unsigned int){124, 8134};
333 vec_ll_uns_int_result
= vec_unsigned (vec_dble0
);
334 test_ll_unsigned_int_result (vec_ll_uns_int_result
,
335 vec_ll_uns_int_expected
);
337 /* Convert two double precision vector float to vector unsigned int */
338 vec_dble0
= (vector
double){124.930, 8134.49};
339 vec_dble1
= (vector
double){24.370, 834.99};
340 vec_uns_int_expected
= (vector
unsigned int){124, 8134, 24, 834};
341 vec_uns_int_result
= vec_unsigned2 (vec_dble0
, vec_dble1
);
342 test_unsigned_int_result (ALL
, vec_uns_int_result
,
343 vec_uns_int_expected
);
345 /* Convert double precision vector float to vector unsigned int,
347 vec_dble0
= (vector
double){3124.930, 8234.49};
348 vec_uns_int_expected
= (vector
unsigned int){3124, 0, 8234, 0};
349 vec_uns_int_result
= vec_unsignede (vec_dble0
);
350 test_unsigned_int_result (EVEN
, vec_uns_int_result
,
351 vec_uns_int_expected
);
353 /* Convert double precision vector float to vector unsigned int,
355 vec_dble0
= (vector
double){1924.930, 81234.49};
356 vec_uns_int_expected
= (vector
unsigned int){0, 1924, 0, 81234};
357 vec_uns_int_result
= vec_unsignedo (vec_dble0
);
358 test_unsigned_int_result (ODD
, vec_uns_int_result
,
359 vec_uns_int_expected
);