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 {
86 int i;
87
88 for (i = 0; i < 2; i++)
89 if (vec_result[i] != vec_expected[i]) {
90 #ifdef DEBUG
91 printf("Test_ll_int_result: ");
92 printf("vec_result[%d] (%lld) != vec_expected[%d] (%lld)\n",
93 i, vec_result[i], i, vec_expected[i]);
94 #else
95 abort();
96 #endif
97 }
98 }
99
100 void test_ll_unsigned_int_result(vector long long unsigned int vec_result,
101 vector long long unsigned int vec_expected)
102 {
103 int i;
104
105 for (i = 0; i < 2; i++)
106 if (vec_result[i] != vec_expected[i]) {
107 #ifdef DEBUG
108 printf("Test_ll_unsigned_int_result: ");
109 printf("vec_result[%d] (%lld) != vec_expected[%d] (%lld)\n",
110 i, vec_result[i], i, vec_expected[i]);
111 #else
112 abort();
113 #endif
114 }
115 }
116
117 void test_result_sp(int check, vector float vec_result,
118 vector float vec_expected)
119 {
120 int i;
121 for(i = 0; i<4; i++) {
122
123 switch (check) {
124 case ALL:
125 break;
126 case EVEN:
127 if (i%2 == 0)
128 break;
129 else
130 continue;
131 case ODD:
132 if (i%2 != 0)
133 break;
134 else
135 continue;
136 }
137
138 if (vec_result[i] != vec_expected[i]) {
139 #ifdef DEBUG
140 printf("Test_result_sp: ");
141 printf("vec_result[%d] (%f) != vec_expected[%d] (%f)\n",
142 i, vec_result[i], i, vec_expected[i]);
143 #else
144 abort();
145 #endif
146 }
147 }
148 }
149
150 void test_result_dp(vector double vec_result, vector double vec_expected)
151 {
152 if (vec_result[0] != vec_expected[0]) {
153 #ifdef DEBUG
154 printf("Test_result_dp: ");
155 printf("vec_result[0] (%f) != vec_expected[0] (%f)\n",
156 vec_result[0], vec_expected[0]);
157 #else
158 abort();
159 #endif
160 }
161
162 if (vec_result[1] != vec_expected[1]) {
163 #ifdef DEBUG
164 printf("Test_result_dp: ");
165 printf("vec_result[1] (%lld) != vec_expected[1] (%lld)\n",
166 vec_result[1], vec_expected[1]);
167 #else
168 abort();
169 #endif
170 }
171 }
172
173 int main()
174 {
175 int i;
176 vector unsigned int vec_unint, vec_uns_int_expected, vec_uns_int_result;
177 vector signed int vec_int, vec_int_expected, vec_int_result;
178 vector long long int vec_ll_int0, vec_ll_int1;
179 vector long long int vec_ll_int_expected, vec_ll_int_result;
180 vector long long unsigned int vec_ll_uns_int0, vec_ll_uns_int1;
181 vector long long unsigned int vec_ll_uns_int_expected, vec_ll_uns_int_result;
182 vector float vec_flt0, vec_flt1, vec_flt_result, vec_flt_expected;
183 vector double vec_dble0, vec_dble1, vec_dble_result, vec_dble_expected;
184
185 vec_int = (vector signed int){ -1, 3, -5, 1234567 };
186 vec_ll_int0 = (vector long long int){ -12, -12345678901234 };
187 vec_ll_int1 = (vector long long int){ 12, 9876543210 };
188 vec_unint = (vector unsigned int){ 9, 11, 15, 2468013579 };
189 vec_ll_uns_int0 = (vector unsigned long long int){ 102, 9753108642 };
190 vec_ll_uns_int1 = (vector unsigned long long int){ 23, 29 };
191 vec_flt0 = (vector float){ -21., 3.5, -53., 78. };
192 vec_dble0 = (vector double){ 34.0, 97.0 };
193 vec_dble1 = (vector double){ 214.0, -5.5 };
194
195 /* conversion of words 0 and 2 */
196 vec_dble_expected = (vector double){-1.000000, -5.000000};
197 vec_dble_result = vec_doublee (vec_int);
198 test_result_dp(vec_dble_result, vec_dble_expected);
199
200 vec_dble_expected = (vector double){9.000000, 15.000000};
201 vec_dble_result = vec_doublee (vec_unint);
202 test_result_dp(vec_dble_result, vec_dble_expected);
203
204 vec_dble_expected = (vector double){-21.000000, -53.000000};
205 vec_dble_result = vec_doublee (vec_flt0);
206 test_result_dp(vec_dble_result, vec_dble_expected);
207
208
209 /* conversion of words 1 and 3 */
210 vec_dble_expected = (vector double){3.000000, 1234567.000000};
211 vec_dble_result = vec_doubleo (vec_int);
212 test_result_dp(vec_dble_result, vec_dble_expected);
213
214 vec_dble_expected = (vector double){11.000000, 2468013579.000000};
215 vec_dble_result = vec_doubleo (vec_unint);
216 test_result_dp(vec_dble_result, vec_dble_expected);
217
218 vec_dble_expected = (vector double){3.500000, 78.000000};
219 vec_dble_result = vec_doubleo (vec_flt0);
220 test_result_dp(vec_dble_result, vec_dble_expected);
221
222
223 /* conversion of words 0 and 1 */
224 vec_dble_expected = (vector double){-5.000000, 1234567.000000};
225 vec_dble_result = vec_doublel (vec_int);
226 test_result_dp(vec_dble_result, vec_dble_expected);
227
228 vec_dble_expected = (vector double){15.000000, 2468013579.000000};
229 vec_dble_result = vec_doublel (vec_unint);
230 test_result_dp(vec_dble_result, vec_dble_expected);
231
232 vec_dble_expected = (vector double){-53.000000, 78.000000};
233 vec_dble_result = vec_doublel (vec_flt0);
234 test_result_dp(vec_dble_result, vec_dble_expected);
235
236
237 /* conversion of words 2 and 3 */
238 vec_dble_expected = (vector double){-1.000000, 3.000000};
239 vec_dble_result = vec_doubleh (vec_int);
240 test_result_dp(vec_dble_result, vec_dble_expected);
241
242 vec_dble_expected = (vector double){9.000000, 11.000000};
243 vec_dble_result = vec_doubleh (vec_unint);
244 test_result_dp(vec_dble_result, vec_dble_expected);
245
246 vec_dble_expected = (vector double){-21.000000, 3.500000};
247 vec_dble_result = vec_doubleh (vec_flt0);
248 test_result_dp(vec_dble_result, vec_dble_expected);
249
250 /* conversion of integer vector to single precision float vector */
251 vec_flt_expected = (vector float){-1.00, 3.00, -5.00, 1234567.00};
252 vec_flt_result = vec_float (vec_int);
253 test_result_sp(ALL, vec_flt_result, vec_flt_expected);
254
255 vec_flt_expected = (vector float){9.00, 11.00, 15.00, 2468013579.0};
256 vec_flt_result = vec_float (vec_unint);
257 test_result_sp(ALL, vec_flt_result, vec_flt_expected);
258
259 /* conversion of even words in double precision vector to single precision vector */
260 vec_flt_expected = (vector float){-12.00, 00.00, -12345678901234.00, 0.00};
261 vec_flt_result = vec_floate (vec_ll_int0);
262 test_result_sp(EVEN, vec_flt_result, vec_flt_expected);
263
264 vec_flt_expected = (vector float){102.00, 0.00, 9753108642.00, 0.00};
265 vec_flt_result = vec_floate (vec_ll_uns_int0);
266 test_result_sp(EVEN, vec_flt_result, vec_flt_expected);
267
268 vec_flt_expected = (vector float){34.00, 0.00, 97.00, 0.00};
269 vec_flt_result = vec_floate (vec_dble0);
270 test_result_sp(EVEN, vec_flt_result, vec_flt_expected);
271
272 /* conversion of odd words in double precision vector to single precision vector */
273 vec_flt_expected = (vector float){0.00, -12.00, 00.00, -12345678901234.00};
274 vec_flt_result = vec_floato (vec_ll_int0);
275 test_result_sp(ODD, vec_flt_result, vec_flt_expected);
276
277 vec_flt_expected = (vector float){0.00, 102.00, 0.00, 9753108642.00};
278 vec_flt_result = vec_floato (vec_ll_uns_int0);
279 test_result_sp(ODD, vec_flt_result, vec_flt_expected);
280
281 vec_flt_expected = (vector float){0.00, 34.00, 0.00, 97.00};
282 vec_flt_result = vec_floato (vec_dble0);
283 test_result_sp(ODD, vec_flt_result, vec_flt_expected);
284
285 /* Convert single precision float to int */
286 vec_flt0 = (vector float){-14.30, 34.00, 22.00, 97.00};
287 vec_int_expected = (vector signed int){-14, 34, 22, 97};
288 vec_int_result = vec_signed (vec_flt0);
289 test_int_result (ALL, vec_int_result, vec_int_expected);
290
291 /* Convert double precision float to long long int */
292 vec_dble0 = (vector double){-124.930, 81234.49};
293 vec_ll_int_expected = (vector long long signed int){-124, 81234};
294 vec_ll_int_result = vec_signed (vec_dble0);
295 test_ll_int_result (vec_ll_int_result, vec_ll_int_expected);
296
297 /* Convert double precision vector float to vector int, even words */
298 vec_dble0 = (vector double){-124.930, 81234.49};
299 vec_int_expected = (vector signed int){-124, 0, 81234, 0};
300 vec_int_result = vec_signede (vec_dble0);
301 test_int_result (EVEN, vec_int_result, vec_int_expected);
302
303 /* Convert double precision vector float to vector int, odd words */
304 vec_dble0 = (vector double){-124.930, 81234.49};
305 vec_int_expected = (vector signed int){0, -124, 0, 81234};
306 vec_int_result = vec_signedo (vec_dble0);
307 test_int_result (ODD, vec_int_result, vec_int_expected);
308
309 /* Convert single precision float to unsigned int */
310 vec_flt0 = (vector float){124.930, 8134.49, 23.3, 45.4};
311 vec_uns_int_expected = (vector unsigned int){124, 8134, 23, 45};
312 vec_uns_int_result = vec_unsigned (vec_flt0);
313 test_unsigned_int_result (ALL, vec_uns_int_result,
314 vec_uns_int_expected);
315
316 /* Convert double precision float to long long unsigned int */
317 vec_dble0 = (vector double){124.930, 8134.49};
318 vec_ll_uns_int_expected = (vector long long unsigned int){124, 8134};
319 vec_ll_uns_int_result = vec_unsigned (vec_dble0);
320 test_ll_unsigned_int_result (vec_ll_uns_int_result,
321 vec_ll_uns_int_expected);
322
323 /* Convert double precision vector float to vector unsigned int,
324 even words */
325 vec_dble0 = (vector double){3124.930, 8234.49};
326 vec_uns_int_expected = (vector unsigned int){3124, 0, 8234, 0};
327 vec_uns_int_result = vec_unsignede (vec_dble0);
328 test_unsigned_int_result (EVEN, vec_uns_int_result,
329 vec_uns_int_expected);
330
331 /* Convert double precision vector float to vector unsigned int,
332 odd words */
333 vec_dble0 = (vector double){1924.930, 81234.49};
334 vec_uns_int_expected = (vector unsigned int){0, 1924, 0, 81234};
335 vec_uns_int_result = vec_unsignedo (vec_dble0);
336 test_unsigned_int_result (ODD, vec_uns_int_result,
337 vec_uns_int_expected);
338 }
339