1 /* { dg-do run } */
2 /* { dg-options "-mdejagnu-cpu=power10 -save-temps" } */
3 /* { dg-require-effective-target power10_hw } */
4
5 /* Check that the expected 128-bit instructions are generated if the processor
6 supports the 128-bit integer instructions. */
7 /* { dg-final { scan-assembler-times {\mvextsd2q\M} 6 } } */
8 /* { dg-final { scan-assembler-times {\mvslq\M} 2 } } */
9 /* { dg-final { scan-assembler-times {\mvsrq\M} 2 } } */
10 /* { dg-final { scan-assembler-times {\mvsraq\M} 2 } } */
11 /* { dg-final { scan-assembler-times {\mvrlq\M} 2 } } */
12 /* { dg-final { scan-assembler-times {\mvrlqnm\M} 2 } } */
13 /* { dg-final { scan-assembler-times {\mvrlqmi\M} 2 } } */
14 /* { dg-final { scan-assembler-times {\mvcmpequq\M} 24 } } */
15 /* { dg-final { scan-assembler-times {\mvcmpgtsq\M} 26 } } */
16 /* { dg-final { scan-assembler-times {\mvcmpgtuq\M} 26 } } */
17 /* { dg-final { scan-assembler-times {\mvmuloud\M} 1 } } */
18 /* { dg-final { scan-assembler-times {\mvmulesd\M} 1 } } */
19 /* { dg-final { scan-assembler-times {\mvmulosd\M} 1 } } */
20 /* { dg-final { scan-assembler-times {\mvmulld\M} 1 } } */
21 /* { dg-final { scan-assembler-times {\mvdivsq\M} 1 } } */
22 /* { dg-final { scan-assembler-times {\mvdivuq\M} 1 } } */
23 /* { dg-final { scan-assembler-times {\mvdivesq\M} 1 } } */
24 /* { dg-final { scan-assembler-times {\mvdiveuq\M} 1 } } */
25 /* { dg-final { scan-assembler-times {\mvmodsq\M} 1 } } */
26 /* { dg-final { scan-assembler-times {\mvmoduq\M} 1 } } */
27
28 #include <altivec.h>
29
30 #define DEBUG 0
31
32 #if DEBUG
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <math.h>
36
37
38 void print_i128(__int128_t val)
39 {
40 printf(" %lld %llu (0x%llx %llx)",
41 (signed long long)(val >> 64),
42 (unsigned long long)(val & 0xFFFFFFFFFFFFFFFF),
43 (unsigned long long)(val >> 64),
44 (unsigned long long)(val & 0xFFFFFFFFFFFFFFFF));
45 }
46 #endif
47
48 void abort (void);
49
50 __attribute__((noinline))
51 __int128_t shift_right (__int128_t a, __uint128_t b)
52 {
53 return a >> b;
54 }
55
56 __attribute__((noinline))
57 __int128_t shift_left (__int128_t a, __uint128_t b)
58 {
59 return a << b;
60 }
61
62 int main ()
63 {
64 int i, result_int;
65
66 __int128_t arg1, result;
67 __uint128_t uarg2;
68
69 _Decimal128 arg1_dfp128, result_dfp128, expected_result_dfp128;
70
71 struct conv_t {
72 __uint128_t u128;
73 _Decimal128 d128;
74 } conv, conv2;
75
76 vector signed long long int vec_arg1_di, vec_arg2_di;
77 vector signed long long int vec_result_di, vec_expected_result_di;
78 vector unsigned long long int vec_uarg1_di, vec_uarg2_di, vec_uarg3_di;
79 vector unsigned long long int vec_uresult_di;
80 vector unsigned long long int vec_uexpected_result_di;
81
82 __int128_t expected_result;
83 __uint128_t uexpected_result;
84
85 vector __int128 vec_arg1, vec_arg2, vec_result;
86 vector unsigned __int128 vec_uarg1, vec_uarg2, vec_uarg3, vec_uresult;
87 vector bool __int128 vec_result_bool;
88
89 /* sign extend double to 128-bit integer */
90 vec_arg1_di[0] = 1000;
91 vec_arg1_di[1] = -123456;
92
93 #ifdef __BIG_ENDIAN__
94 expected_result = -123456;
95 #else
96 expected_result = 1000;
97 #endif
98
99 vec_result = vec_signextq (vec_arg1_di);
100
101 if (vec_result[0] != expected_result) {
102 #if DEBUG
103 printf("ERROR: vec_signextq ((long long) %lld) = ", vec_arg1_di[0]);
104 print_i128(vec_result[0]);
105 printf("\n does not match expected_result = ");
106 print_i128(expected_result);
107 printf("\n\n");
108 #else
109 abort();
110 #endif
111 }
112
113 vec_arg1_di[0] = -123456;
114 vec_arg1_di[1] = 1000;
115
116 #ifdef __BIG_ENDIAN__
117 expected_result = 1000;
118 #else
119 expected_result = -123456;
120 #endif
121
122 vec_result = vec_signextq (vec_arg1_di);
123
124 if (vec_result[0] != expected_result) {
125 #if DEBUG
126 printf("ERROR: vec_signextq ((long long) %lld) = ", vec_arg1_di[0]);
127 print_i128(vec_result[0]);
128 printf("\n does not match expected_result = ");
129 print_i128(expected_result);
130 printf("\n\n");
131 #else
132 abort();
133 #endif
134 }
135
136 /* test shift 128-bit integers.
137 Note, shift amount is given by the lower 7-bits of the shift amount. */
138 vec_arg1[0] = 3;
139 vec_uarg2[0] = 2;
140 expected_result = vec_arg1[0]*4;
141
142 vec_result = vec_sl (vec_arg1, vec_uarg2);
143
144 if (vec_result[0] != expected_result) {
145 #if DEBUG
146 printf("ERROR: vec_sl(int128, uint128): ");
147 print_i128(vec_arg1[0]);
148 printf(" << %lld", vec_uarg2[0] & 0xFF);
149 printf(" = ");
150 print_i128(vec_result[0]);
151 printf("\n does not match expected_result = ");
152 print_i128(expected_result);
153 printf("\n\n");
154 #else
155 abort();
156 #endif
157 }
158
159 arg1 = vec_result[0];
160 uarg2 = 4;
161 expected_result = arg1*16;
162
163 result = arg1 << uarg2;
164
165 if (result != expected_result) {
166 #if DEBUG
167 printf("ERROR: int128 << uint128): ");
168 print_i128(arg1);
169 printf(" << %lld", uarg2 & 0xFF);
170 printf(" = ");
171 print_i128(result);
172 printf("\n does not match expected_result = ");
173 print_i128(expected_result);
174 printf("\n\n");
175 #else
176 abort();
177 #endif
178 }
179
180 vec_uarg1[0] = 3;
181 vec_uarg2[0] = 2;
182 uexpected_result = vec_uarg1[0]*4;
183
184 vec_uresult = vec_sl (vec_uarg1, vec_uarg2);
185
186 if (vec_uresult[0] != uexpected_result) {
187 #if DEBUG
188 printf("ERROR: vec_sl(uint128, uint128): ");
189 print_i128(vec_uarg1[0]);
190 printf(" << %lld", vec_uarg2[0] & 0xFF);
191 printf(" = ");
192 print_i128(vec_uresult[0]);
193 printf("\n does not match expected_result = ");
194 print_i128(uexpected_result);
195 printf("\n\n");
196 #else
197 abort();
198 #endif
199 }
200
201 vec_arg1[0] = 12;
202 vec_uarg2[0] = 2;
203 expected_result = vec_arg1[0]/4;
204
205 vec_result = vec_sr (vec_arg1, vec_uarg2);
206
207 if (vec_result[0] != expected_result) {
208 #if DEBUG
209 printf("ERROR: vec_sr(int128, uint128): ");
210 print_i128(vec_arg1[0]);
211 printf(" >> %lld", vec_uarg2[0] & 0xFF);
212 printf(" = ");
213 print_i128(vec_result[0]);
214 printf("\n does not match expected_result = ");
215 print_i128(expected_result);
216 printf("\n\n");
217 #else
218 abort();
219 #endif
220 }
221
222 vec_uarg1[0] = 48;
223 vec_uarg2[0] = 2;
224 uexpected_result = vec_uarg1[0]/4;
225
226 vec_uresult = vec_sr (vec_uarg1, vec_uarg2);
227
228 if (vec_uresult[0] != uexpected_result) {
229 #if DEBUG
230 printf("ERROR: vec_sr(uint128, uint128): ");
231 print_i128(vec_uarg1[0]);
232 printf(" >> %lld", vec_uarg2[0] & 0xFF);
233 printf(" = ");
234 print_i128(vec_uresult[0]);
235 printf("\n does not match expected_result = ");
236 print_i128(uexpected_result);
237 printf("\n\n");
238 #else
239 abort();
240 #endif
241 }
242
243 arg1 = vec_uresult[0];
244 uarg2 = 4;
245 expected_result = arg1/16;
246
247 result = arg1 >> uarg2;
248
249 if (result != expected_result) {
250 #if DEBUG
251 printf("ERROR: int128 >> uint128: ");
252 print_i128(arg1);
253 printf(" >> %lld", uarg2 & 0xFF);
254 printf(" = ");
255 print_i128(result);
256 printf("\n does not match expected_result = ");
257 print_i128(expected_result);
258 printf("\n\n");
259 #else
260 abort();
261 #endif
262 }
263
264 vec_arg1[0] = 0x1234567890ABCDEFULL;
265 vec_arg1[0] = (vec_arg1[0] << 64) | 0xAABBCCDDEEFF1122ULL;
266 vec_uarg2[0] = 32;
267 expected_result = 0x0000000012345678ULL;
268 expected_result = (expected_result << 64) | 0x90ABCDEFAABBCCDDULL;
269
270 vec_result = vec_sra (vec_arg1, vec_uarg2);
271
272 if (vec_result[0] != expected_result) {
273 #if DEBUG
274 printf("ERROR: vec_sra(int128, uint128): ");
275 print_i128(vec_arg1[0]);
276 printf(" >> %lld = \n", vec_uarg2[0]);
277 print_i128(vec_result[0]);
278 printf("\n does not match expected_result = ");
279 print_i128(expected_result);
280 printf("\n\n");
281 #else
282 abort();
283 #endif
284 }
285
286 vec_uarg1[0] = 0xAABBCCDDEEFF1122ULL;
287 vec_uarg1[0] = (vec_uarg1[0] << 64) | 0x1234567890ABCDEFULL;
288 vec_uarg2[0] = 48;
289 uexpected_result = 0xFFFFFFFFFFFFAABBLL;
290 uexpected_result = (uexpected_result << 64) | 0xCCDDEEFF11221234ULL;
291
292 vec_uresult = vec_sra (vec_uarg1, vec_uarg2);
293
294 if (vec_uresult[0] != uexpected_result) {
295 #if DEBUG
296 printf("ERROR: vec_sra(uint128, uint128): ");
297 print_i128(vec_uarg1[0]);
298 printf(" >> %lld = \n", vec_uarg2[0] & 0xFF);
299 print_i128(vec_uresult[0]);
300 printf("\n does not match expected_result = ");
301 print_i128(uexpected_result);
302 printf("\n\n");
303 #else
304 abort();
305 #endif
306 }
307
308 vec_arg1[0] = 0x1234567890ABCDEFULL;
309 vec_arg1[0] = (vec_arg1[0] << 64) | 0xAABBCCDDEEFF1122ULL;
310 vec_uarg2[0] = 32;
311 expected_result = 0x90ABCDEFAABBCCDDULL;
312 expected_result = (expected_result << 64) | 0xEEFF112212345678ULL;
313
314 vec_result = vec_rl (vec_arg1, vec_uarg2);
315
316 if (vec_result[0] != expected_result) {
317 #if DEBUG
318 printf("ERROR: vec_rl(int128, uint128): ");
319 print_i128(vec_arg1[0]);
320 printf(" >> %lld = \n", vec_uarg2[0]);
321 print_i128(vec_result[0]);
322 printf("\n does not match expected_result = ");
323 print_i128(expected_result);
324 printf("\n\n");
325 #else
326 abort();
327 #endif
328 }
329
330 vec_uarg1[0] = 0xAABBCCDDEEFF1122ULL;
331 vec_uarg1[0] = (vec_uarg1[0] << 64) | 0x1234567890ABCDEFULL;
332 vec_uarg2[0] = 48;
333 uexpected_result = 0x11221234567890ABULL;
334 uexpected_result = (uexpected_result << 64) | 0xCDEFAABBCCDDEEFFULL;
335
336 vec_uresult = vec_rl (vec_uarg1, vec_uarg2);
337
338 if (vec_uresult[0] != uexpected_result) {
339 #if DEBUG
340 printf("ERROR: vec_rl(uint128, uint128): ");
341 print_i128(vec_uarg1[0]);
342 printf(" >> %lld = \n", vec_uarg2[0]);
343 print_i128(vec_uresult[0]);
344 printf("\n does not match expected_result = ");
345 print_i128(uexpected_result);
346 printf("\n\n");
347 #else
348 abort();
349 #endif
350 }
351
352 /* vec_rlnm(arg1, arg2, arg3)
353 result - rotate each element of arg1 left by shift in element of arg2.
354 Then AND with mask whose start/stop bits are specified in element of
355 arg3. */
356 vec_arg1[0] = 0x1234567890ABCDEFULL;
357 vec_arg1[0] = (vec_arg1[0] << 64) | 0xAABBCCDDEEFF1122ULL;
358 vec_uarg2[0] = 32;
359 vec_uarg3[0] = (32 << 8) | 95;
360 expected_result = 0xaabbccddULL;
361 expected_result = (expected_result << 64) | 0xeeff112200000000ULL;
362
363 vec_result = vec_rlnm (vec_arg1, vec_uarg2, vec_uarg3);
364
365 if (vec_result[0] != expected_result) {
366 #if DEBUG
367 printf("ERROR: vec_rlnm(int128, uint128, uint128): ");
368 print_i128(vec_arg1[0]);
369 printf(" << %lld = \n", vec_uarg3[0] & 0xFF);
370 print_i128(vec_result[0]);
371 printf("\n does not match expected_result = ");
372 print_i128(expected_result);
373 printf("\n\n");
374 #else
375 abort();
376 #endif
377 }
378
379
380
381 /* vec_rlnm(arg1, arg2, arg3)
382 result - rotate each element of arg1 left by shift in element of arg2;
383 then AND with mask whose start/stop bits are specified in element of
384 arg3. */
385 vec_uarg1[0] = 0xAABBCCDDEEFF1122ULL;
386 vec_uarg1[0] = (vec_uarg1[0] << 64) | 0x1234567890ABCDEFULL;
387 vec_uarg2[0] = 48;
388 vec_uarg3[0] = (8 << 8) | 119;
389
390 uexpected_result = 0x00221234567890ABULL;
391 uexpected_result = (uexpected_result << 64) | 0xCDEFAABBCCDDEE00ULL;
392
393 vec_uresult = vec_rlnm (vec_uarg1, vec_uarg2, vec_uarg3);
394
395 if (vec_uresult[0] != uexpected_result) {
396 #if DEBUG
397 printf("ERROR: vec_rlnm(uint128, uint128, uint128): ");
398 print_i128(vec_uarg1[0]);
399 printf(" << %lld = \n", vec_uarg3[0] & 0xFF);
400 print_i128(vec_uresult[0]);
401 printf("\n does not match expected_result = ");
402 print_i128(uexpected_result);
403 printf("\n\n");
404 #else
405 abort();
406 #endif
407 }
408
409 /* vec_rlmi(R, A, B)
410 Result value: Each element of R is obtained by rotating the corresponding
411 element of A left by the number of bits specified by the corresponding element
412 of B. */
413
414 vec_arg1[0] = 0x1234567890ABCDEFULL;
415 vec_arg1[0] = (vec_arg1[0] << 64) | 0xAABBCCDDEEFF1122ULL;
416 vec_arg2[0] = 0x000000000000DEADULL;
417 vec_arg2[0] = (vec_arg2[0] << 64) | 0x0000BEEF00000000ULL;
418 vec_uarg3[0] = 96 << 16 | 127 << 8 | 32;
419 expected_result = 0x000000000000DEADULL;
420 expected_result = (expected_result << 64) | 0x0000BEEF12345678ULL;
421
422 vec_result = vec_rlmi (vec_arg1, vec_arg2, vec_uarg3);
423
424 if (vec_result[0] != expected_result) {
425 #if DEBUG
426 printf("ERROR: vec_rlmi(int128, int128, uint128): ");
427 print_i128(vec_arg1[0]);
428 printf(" << %lld = \n", vec_uarg2_di[1] & 0xFF);
429 print_i128(vec_result[0]);
430 printf("\n does not match expected_result = ");
431 print_i128(expected_result);
432 printf("\n\n");
433 #else
434 abort();
435 #endif
436 }
437
438 /* vec_rlmi(R, A, B)
439 Result value: Each element of R is obtained by rotating the corresponding
440 element of A left by the number of bits specified by the corresponding element
441 of B. */
442
443 vec_uarg1[0] = 0xAABBCCDDEEFF1122ULL;
444 vec_uarg1[0] = (vec_uarg1[0] << 64) | 0x1234567890ABCDEFULL;
445 vec_uarg2[0] = 0xDEAD000000000000ULL;
446 vec_uarg2[0] = (vec_uarg2[0] << 64) | 0x000000000000BEEFULL;
447 vec_uarg3[0] = 16 << 16 | 111 << 8 | 48;
448 uexpected_result = 0xDEAD1234567890ABULL;
449 uexpected_result = (uexpected_result << 64) | 0xCDEFAABBCCDDBEEFULL;
450
451 vec_uresult = vec_rlmi (vec_uarg1, vec_uarg2, vec_uarg3);
452
453 if (vec_uresult[0] != uexpected_result) {
454 #if DEBUG
455 printf("ERROR: vec_rlmi(uint128, unit128, uint128): ");
456 print_i128(vec_uarg1[0]);
457 printf(" << %lld = \n", vec_uarg3[1] & 0xFF);
458 print_i128(vec_uresult[0]);
459 printf("\n does not match expected_result = ");
460 print_i128(uexpected_result);
461 printf("\n\n");
462 #else
463 abort();
464 #endif
465 }
466
467 /* 128-bit compare tests, result is all 1's if true */
468 vec_uarg2[0] = 1234;
469 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
470 vec_uarg1[0] = 2468;
471 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
472 uexpected_result = 0xFFFFFFFFFFFFFFFFULL;
473 uexpected_result = (uexpected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;
474
475 vec_result_bool = vec_cmpgt (vec_uarg1, vec_uarg2);
476
477 if (vec_result_bool[0] != uexpected_result) {
478 #if DEBUG
479 printf("ERROR: unsigned vec_cmpgt ( ");
480 print_i128(vec_uarg1[0]);
481 printf(", ");
482 print_i128(vec_uarg2[0]);
483 printf(") failed.");
484 print_i128(vec_result_bool[0]);
485 printf("\n Result does not match expected_result = ");
486 print_i128(uexpected_result);
487 printf("\n\n");
488 #else
489 abort();
490 #endif
491 }
492
493 vec_arg1[0] = 12468;
494 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
495 vec_arg2[0] = 1234;
496 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
497 expected_result = 0xFFFFFFFFFFFFFFFFULL;
498 expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;
499
500 vec_result_bool = vec_cmpgt (vec_arg1, vec_arg2);
501
502 if (vec_result_bool[0] != expected_result) {
503 #if DEBUG
504 printf("ERROR: signed vec_cmpgt ( ");
505 print_i128(vec_arg1[0]);
506 printf(", ");
507 print_i128(vec_arg2[0]);
508 printf(") failed.");
509 print_i128(vec_result_bool[0]);
510 printf("\n Result does not match expected_result = ");
511 print_i128(expected_result);
512 printf("\n\n");
513 #else
514 abort();
515 #endif
516 }
517
518
519 vec_arg1[0] = 12468;
520 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
521 vec_arg2[0] = -1234;
522 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
523 expected_result = 0x0ULL;
524
525 vec_result_bool = vec_cmpeq (vec_arg1, vec_arg2);
526
527 if (vec_result_bool[0] != expected_result) {
528 #if DEBUG
529 printf("ERROR:not equal signed vec_cmpeq ( ");
530 print_i128(vec_arg1[0]);
531 printf(", ");
532 print_i128(vec_arg2[0]);
533 printf(") failed.");
534 print_i128(vec_result_bool[0]);
535 printf("\n Result does not match expected_result = ");
536 print_i128(expected_result);
537 printf("\n\n");
538 #else
539 abort();
540 #endif
541 }
542
543 vec_arg2[0] = 1234;
544 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
545 vec_arg1 = vec_arg2;
546 expected_result = 0xFFFFFFFFFFFFFFFFULL;
547 expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;
548
549 vec_result_bool = vec_cmpeq (vec_arg1, vec_arg2);
550
551 if (vec_result_bool[0] != expected_result) {
552 #if DEBUG
553 printf("ERROR: signed equal vec_cmpeq ( ");
554 print_i128(vec_arg1[0]);
555 printf(", ");
556 print_i128(vec_arg2[0]);
557 printf(") failed.");
558 print_i128(vec_result_bool[0]);
559 printf("\n Result does not match expected_result = ");
560 print_i128(expected_result);
561 printf("\n\n");
562 #else
563 abort();
564 #endif
565 }
566
567 vec_uarg1[0] = 12468;
568 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
569 vec_uarg2[0] = 1234;
570 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
571 expected_result = 0x0ULL;
572
573 vec_result_bool = vec_cmpeq (vec_uarg1, vec_uarg2);
574
575 if (vec_result_bool[0] != expected_result) {
576 #if DEBUG
577 printf("ERROR: unsigned not equal vec_cmpeq ( ");
578 print_i128(vec_arg1[0]);
579 printf(", ");
580 print_i128(vec_arg2[0]);
581 printf(") failed.");
582 print_i128(vec_result_bool[0]);
583 printf("\n Result does not match expected_result = ");
584 print_i128(expected_result);
585 printf("\n\n");
586 #else
587 abort();
588 #endif
589 }
590
591 vec_uarg2[0] = 1234;
592 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
593 vec_uarg1 = vec_uarg2;
594
595 expected_result = 0xFFFFFFFFFFFFFFFFULL;
596 expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;
597
598 vec_result_bool = vec_cmpeq (vec_uarg1, vec_uarg2);
599
600 if (vec_result_bool[0] != expected_result) {
601 #if DEBUG
602 printf("ERROR: equal unsigned vec_cmpeq ( ");
603 print_i128(vec_uarg1[0]);
604 printf(", ");
605 print_i128(vec_uarg2[0]);
606 printf(") failed.");
607 print_i128(vec_result_bool[0]);
608 printf("\n Result does not match expected_result = ");
609 print_i128(expected_result);
610 printf("\n\n");
611 #else
612 abort();
613 #endif
614 }
615
616 vec_uarg1[0] = 12468;
617 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
618 vec_uarg2[0] = 1234;
619 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
620 expected_result = 0xFFFFFFFFFFFFFFFFULL;
621 expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;
622
623 vec_result_bool = vec_cmpne (vec_uarg1, vec_uarg2);
624
625 if (vec_result_bool[0] != expected_result) {
626 #if DEBUG
627 printf("ERROR: unsigned not equal vec_cmpne ( ");
628 print_i128(vec_arg1[0]);
629 printf(", ");
630 print_i128(vec_arg2[0]);
631 printf(") failed.");
632 print_i128(vec_result_bool[0]);
633 printf("\n Result does not match expected_result = ");
634 print_i128(expected_result);
635 printf("\n\n");
636 #else
637 abort();
638 #endif
639 }
640
641 vec_uarg2[0] = 1234;
642 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
643 vec_uarg1 = vec_uarg2;
644 expected_result = 0x0ULL;
645
646 vec_result_bool = vec_cmpne (vec_uarg1, vec_uarg2);
647
648 if (vec_result_bool[0] != expected_result) {
649 #if DEBUG
650 printf("ERROR: equal unsigned vec_cmpne ( ");
651 print_i128(vec_uarg1[0]);
652 printf(", ");
653 print_i128(vec_uarg2[0]);
654 printf(") failed.");
655 print_i128(vec_result_bool[0]);
656 printf("\n Result does not match expected_result = ");
657 print_i128(expected_result);
658 printf("\n\n");
659 #else
660 abort();
661 #endif
662 }
663
664 vec_arg1[0] = 12468;
665 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
666 vec_arg2[0] = -1234;
667 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
668 expected_result = 0xFFFFFFFFFFFFFFFFULL;
669 expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;
670
671 vec_result_bool = vec_cmpne (vec_arg1, vec_arg2);
672
673 if (vec_result_bool[0] != expected_result) {
674 #if DEBUG
675 printf("ERROR:not equal signed vec_cmpne ( ");
676 print_i128(vec_arg1[0]);
677 printf(", ");
678 print_i128(vec_arg2[0]);
679 printf(") failed.");
680 print_i128(vec_result_bool[0]);
681 printf("\n Result does not match expected_result = ");
682 print_i128(expected_result);
683 printf("\n\n");
684 #else
685 abort();
686 #endif
687 }
688
689 vec_arg2[0] = 1234;
690 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
691 vec_arg1 = vec_arg2;
692 expected_result = 0x0ULL;
693
694 vec_result_bool = vec_cmpne (vec_arg1, vec_arg2);
695
696 if (vec_result_bool[0] != expected_result) {
697 #if DEBUG
698 printf("ERROR: signed equal vec_cmpne ( ");
699 print_i128(vec_arg1[0]);
700 printf(", ");
701 print_i128(vec_arg2[0]);
702 printf(") failed.");
703 print_i128(vec_result_bool[0]);
704 printf("\n Result does not match expected_result = ");
705 print_i128(expected_result);
706 printf("\n\n");
707 #else
708 abort();
709 #endif
710 }
711
712 vec_uarg1[0] = 12468;
713 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
714 vec_uarg2[0] = 1234;
715 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
716 expected_result = 0x0;
717
718 vec_result_bool = vec_cmplt (vec_uarg1, vec_uarg2);
719
720 if (vec_result_bool[0] != expected_result) {
721 #if DEBUG
722 printf("ERROR: unsigned arg1 > arg2 vec_cmplt ( ");
723 print_i128(vec_arg1[0]);
724 printf(", ");
725 print_i128(vec_arg2[0]);
726 printf(") failed.");
727 print_i128(vec_result_bool[0]);
728 printf("\n Result does not match expected_result = ");
729 print_i128(expected_result);
730 printf("\n\n");
731 #else
732 abort();
733 #endif
734 }
735
736 vec_uarg1[0] = 1234;
737 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
738 vec_uarg2[0] = 12468;
739 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
740 expected_result = 0xFFFFFFFFFFFFFFFFULL;
741 expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;
742
743 vec_result_bool = vec_cmplt (vec_uarg1, vec_uarg2);
744
745 if (vec_result_bool[0] != expected_result) {
746 #if DEBUG
747 printf("ERROR: unsigned arg1 < arg2 vec_cmplt ( ");
748 print_i128(vec_arg1[0]);
749 printf(", ");
750 print_i128(vec_arg2[0]);
751 printf(") failed.");
752 print_i128(vec_result_bool[0]);
753 printf("\n Result does not match expected_result = ");
754 print_i128(expected_result);
755 printf("\n\n");
756 #else
757 abort();
758 #endif
759 }
760
761 vec_uarg2[0] = 1234;
762 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
763 vec_uarg1 = vec_uarg2;
764 expected_result = 0x0ULL;
765
766 vec_result_bool = vec_cmplt (vec_uarg1, vec_uarg2);
767
768 if (vec_result_bool[0] != expected_result) {
769 #if DEBUG
770 printf("ERROR: unsigned arg1 = arg2 vec_cmplt ( ");
771 print_i128(vec_uarg1[0]);
772 printf(", ");
773 print_i128(vec_uarg2[0]);
774 printf(") failed.");
775 print_i128(vec_result_bool[0]);
776 printf("\n Result does not match expected_result = ");
777 print_i128(expected_result);
778 printf("\n\n");
779 #else
780 abort();
781 #endif
782 }
783
784 vec_arg1[0] = 12468;
785 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
786 vec_arg2[0] = -1234;
787 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
788 expected_result = 0x0;
789
790 vec_result_bool = vec_cmplt (vec_arg1, vec_arg2);
791
792 if (vec_result_bool[0] != expected_result) {
793 #if DEBUG
794 printf("ERROR: signed arg1 > arg2 vec_cmplt ( ");
795 print_i128(vec_arg1[0]);
796 printf(", ");
797 print_i128(vec_arg2[0]);
798 printf(") failed.");
799 print_i128(vec_result_bool[0]);
800 printf("\n Result does not match expected_result = ");
801 print_i128(expected_result);
802 printf("\n\n");
803 #else
804 abort();
805 #endif
806 }
807
808 vec_arg1[0] = -1234;
809 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
810 vec_arg2[0] = 12468;
811 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
812 expected_result = 0xFFFFFFFFFFFFFFFFULL;
813 expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;
814
815 vec_result_bool = vec_cmplt (vec_arg1, vec_arg2);
816
817 if (vec_result_bool[0] != expected_result) {
818 #if DEBUG
819 printf("ERROR: signed arg1 < arg2 vec_cmplt ( ");
820 print_i128(vec_arg1[0]);
821 printf(", ");
822 print_i128(vec_arg2[0]);
823 printf(") failed.");
824 print_i128(vec_result_bool[0]);
825 printf("\n Result does not match expected_result = ");
826 print_i128(expected_result);
827 printf("\n\n");
828 #else
829 abort();
830 #endif
831 }
832
833 vec_arg2[0] = 1234;
834 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
835 vec_arg1 = vec_arg2;
836 expected_result = 0x0ULL;
837
838 vec_result_bool = vec_cmplt (vec_arg1, vec_arg2);
839
840 if (vec_result_bool[0] != expected_result) {
841 #if DEBUG
842 printf("ERROR: signed arg1 = arg2 vec_cmplt ( ");
843 print_i128(vec_arg1[0]);
844 printf(", ");
845 print_i128(vec_arg2[0]);
846 printf(") failed.");
847 print_i128(vec_result_bool[0]);
848 printf("\n Result does not match expected_result = ");
849 print_i128(expected_result);
850 printf("\n\n");
851 #else
852 abort();
853 #endif
854 }
855
856 vec_uarg1[0] = 12468;
857 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
858 vec_uarg2[0] = 1234;
859 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
860 expected_result = 0x0;
861
862 vec_result_bool = vec_cmple (vec_uarg1, vec_uarg2);
863
864 if (vec_result_bool[0] != expected_result) {
865 #if DEBUG
866 printf("ERROR: unsigned arg1 > arg2 vec_cmple ( ");
867 print_i128(vec_arg1[0]);
868 printf(", ");
869 print_i128(vec_arg2[0]);
870 printf(") failed.");
871 print_i128(vec_result_bool[0]);
872 printf("\n Result does not match expected_result = ");
873 print_i128(expected_result);
874 printf("\n\n");
875 #else
876 abort();
877 #endif
878 }
879
880 vec_uarg1[0] = 1234;
881 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
882 vec_uarg2[0] = 12468;
883 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
884 expected_result = 0xFFFFFFFFFFFFFFFFULL;
885 expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;
886
887 vec_result_bool = vec_cmple (vec_uarg1, vec_uarg2);
888
889 if (vec_result_bool[0] != expected_result) {
890 #if DEBUG
891 printf("ERROR: unsigned arg1 < arg2 vec_cmple ( ");
892 print_i128(vec_arg1[0]);
893 printf(", ");
894 print_i128(vec_arg2[0]);
895 printf(") failed.");
896 print_i128(vec_result_bool[0]);
897 printf("\n Result does not match expected_result = ");
898 print_i128(expected_result);
899 printf("\n\n");
900 #else
901 abort();
902 #endif
903 }
904
905 vec_uarg2[0] = 1234;
906 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
907 vec_uarg1 = vec_uarg2;
908 expected_result = 0xFFFFFFFFFFFFFFFFULL;
909 expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;
910
911 vec_result_bool = vec_cmple (vec_uarg1, vec_uarg2);
912
913 if (vec_result_bool[0] != expected_result) {
914 #if DEBUG
915 printf("ERROR: unsigned arg1 = arg2 vec_cmple ( ");
916 print_i128(vec_uarg1[0]);
917 printf(", ");
918 print_i128(vec_uarg2[0]);
919 printf(") failed.");
920 print_i128(vec_result_bool[0]);
921 printf("\n Result does not match expected_result = ");
922 print_i128(expected_result);
923 printf("\n\n");
924 #else
925 abort();
926 #endif
927 }
928
929 vec_arg1[0] = 12468;
930 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
931 vec_arg2[0] = -1234;
932 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
933 expected_result = 0x0;
934
935 vec_result_bool = vec_cmple (vec_arg1, vec_arg2);
936
937 if (vec_result_bool[0] != expected_result) {
938 #if DEBUG
939 printf("ERROR: signed arg1 > arg2 vec_cmple ( ");
940 print_i128(vec_arg1[0]);
941 printf(", ");
942 print_i128(vec_arg2[0]);
943 printf(") failed.");
944 print_i128(vec_result_bool[0]);
945 printf("\n Result does not match expected_result = ");
946 print_i128(expected_result);
947 printf("\n\n");
948 #else
949 abort();
950 #endif
951 }
952
953 vec_arg1[0] = -1234;
954 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
955 vec_arg2[0] = 12468;
956 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
957 expected_result = 0xFFFFFFFFFFFFFFFFULL;
958 expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;
959
960 vec_result_bool = vec_cmple (vec_arg1, vec_arg2);
961
962 if (vec_result_bool[0] != expected_result) {
963 #if DEBUG
964 printf("ERROR: signed arg1 < arg2 vec_cmple ( ");
965 print_i128(vec_arg1[0]);
966 printf(", ");
967 print_i128(vec_arg2[0]);
968 printf(") failed.");
969 print_i128(vec_result_bool[0]);
970 printf("\n Result does not match expected_result = ");
971 print_i128(expected_result);
972 printf("\n\n");
973 #else
974 abort();
975 #endif
976 }
977
978 vec_arg2[0] = 1234;
979 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
980 vec_arg1 = vec_arg2;
981 expected_result = 0xFFFFFFFFFFFFFFFFULL;
982 expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;
983
984 vec_result_bool = vec_cmple (vec_arg1, vec_arg2);
985
986 if (vec_result_bool[0] != expected_result) {
987 #if DEBUG
988 printf("ERROR: signed arg1 = arg2 vec_cmple ( ");
989 print_i128(vec_arg1[0]);
990 printf(", ");
991 print_i128(vec_arg2[0]);
992 printf(") failed.");
993 print_i128(vec_result_bool[0]);
994 printf("\n Result does not match expected_result = ");
995 print_i128(expected_result);
996 printf("\n\n");
997 #else
998 abort();
999 #endif
1000 }
1001
1002 vec_uarg1[0] = 12468;
1003 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
1004 vec_uarg2[0] = 1234;
1005 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1006 expected_result = 0xFFFFFFFFFFFFFFFFULL;
1007 expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;
1008
1009 vec_result_bool = vec_cmpge (vec_uarg1, vec_uarg2);
1010
1011 if (vec_result_bool[0] != expected_result) {
1012 #if DEBUG
1013 printf("ERROR: unsigned arg1 > arg2 vec_cmpge ( ");
1014 print_i128(vec_arg1[0]);
1015 printf(", ");
1016 print_i128(vec_arg2[0]);
1017 printf(") failed.");
1018 print_i128(vec_result_bool[0]);
1019 printf("\n Result does not match expected_result = ");
1020 print_i128(expected_result);
1021 printf("\n\n");
1022 #else
1023 abort();
1024 #endif
1025 }
1026
1027 vec_uarg1[0] = 1234;
1028 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
1029 vec_uarg2[0] = 12468;
1030 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1031 expected_result = 0x0;
1032
1033 vec_result_bool = vec_cmpge (vec_uarg1, vec_uarg2);
1034
1035 if (vec_result_bool[0] != expected_result) {
1036 #if DEBUG
1037 printf("ERROR: unsigned arg1 < arg2 vec_cmpge ( ");
1038 print_i128(vec_arg1[0]);
1039 printf(", ");
1040 print_i128(vec_arg2[0]);
1041 printf(") failed.");
1042 print_i128(vec_result_bool[0]);
1043 printf("\n Result does not match expected_result = ");
1044 print_i128(expected_result);
1045 printf("\n\n");
1046 #else
1047 abort();
1048 #endif
1049 }
1050
1051 vec_uarg2[0] = 1234;
1052 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1053 vec_uarg1 = vec_uarg2;
1054 expected_result = 0xFFFFFFFFFFFFFFFFULL;
1055 expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;
1056
1057 vec_result_bool = vec_cmpge (vec_uarg1, vec_uarg2);
1058
1059 if (vec_result_bool[0] != expected_result) {
1060 #if DEBUG
1061 printf("ERROR: unsigned arg1 = arg2 vec_cmpge ( ");
1062 print_i128(vec_uarg1[0]);
1063 printf(", ");
1064 print_i128(vec_uarg2[0]);
1065 printf(") failed.");
1066 print_i128(vec_result_bool[0]);
1067 printf("\n Result does not match expected_result = ");
1068 print_i128(expected_result);
1069 printf("\n\n");
1070 #else
1071 abort();
1072 #endif
1073 }
1074
1075 vec_arg1[0] = 12468;
1076 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
1077 vec_arg2[0] = -1234;
1078 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1079 expected_result = 0xFFFFFFFFFFFFFFFFULL;
1080 expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;
1081
1082 vec_result_bool = vec_cmpge (vec_arg1, vec_arg2);
1083
1084 if (vec_result_bool[0] != expected_result) {
1085 #if DEBUG
1086 printf("ERROR: signed arg1 > arg2 vec_cmpge ( ");
1087 print_i128(vec_arg1[0]);
1088 printf(", ");
1089 print_i128(vec_arg2[0]);
1090 printf(") failed.");
1091 print_i128(vec_result_bool[0]);
1092 printf("\n Result does not match expected_result = ");
1093 print_i128(expected_result);
1094 printf("\n\n");
1095 #else
1096 abort();
1097 #endif
1098 }
1099
1100 vec_arg1[0] = -1234;
1101 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
1102 vec_arg2[0] = 12468;
1103 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1104 expected_result = 0x0;
1105
1106 vec_result_bool = vec_cmpge (vec_arg1, vec_arg2);
1107
1108 if (vec_result_bool[0] != expected_result) {
1109 #if DEBUG
1110 printf("ERROR: signed arg1 < arg2 vec_cmpge ( ");
1111 print_i128(vec_arg1[0]);
1112 printf(", ");
1113 print_i128(vec_arg2[0]);
1114 printf(") failed.");
1115 print_i128(vec_result_bool[0]);
1116 printf("\n Result does not match expected_result = ");
1117 print_i128(expected_result);
1118 printf("\n\n");
1119 #else
1120 abort();
1121 #endif
1122 }
1123
1124 vec_arg2[0] = 1234;
1125 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1126 vec_arg1 = vec_arg2;
1127 expected_result = 0xFFFFFFFFFFFFFFFFULL;
1128 expected_result = (expected_result << 64) | 0xFFFFFFFFFFFFFFFFULL;
1129
1130 vec_result_bool = vec_cmpge (vec_arg1, vec_arg2);
1131
1132 if (vec_result_bool[0] != expected_result) {
1133 #if DEBUG
1134 printf("ERROR: signed arg1 = arg2 vec_cmpge ( ");
1135 print_i128(vec_arg1[0]);
1136 printf(", ");
1137 print_i128(vec_arg2[0]);
1138 printf(") failed.");
1139 print_i128(vec_result_bool[0]);
1140 printf("\n Result does not match expected_result = ");
1141 print_i128(expected_result);
1142 printf("\n\n");
1143 #else
1144 abort();
1145 #endif
1146 }
1147
1148 #if 1
1149 vec_arg2[0] = 1234;
1150 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1151 vec_arg1 = vec_arg2;
1152
1153 result_int = vec_all_eq (vec_arg1, vec_arg2);
1154
1155 if (!result_int) {
1156 #if DEBUG
1157 printf("ERROR: signed arg1 = arg2 vec_all_eq ( ");
1158 print_i128(vec_arg1[0]);
1159 printf(", ");
1160 print_i128(vec_arg2[0]);
1161 printf(") failed.\n\n");
1162 printf("\n\n");
1163 #else
1164 abort();
1165 #endif
1166 }
1167
1168 vec_arg1[0] = -234;
1169 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
1170 vec_arg2[0] = 1234;
1171 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1172
1173 result_int = vec_all_eq (vec_arg1, vec_arg2);
1174
1175 if (result_int) {
1176 #if DEBUG
1177 printf("ERROR: signed arg1 != arg2 vec_all_eq ( ");
1178 print_i128(vec_arg1[0]);
1179 printf(", ");
1180 print_i128(vec_arg2[0]);
1181 printf(") failed.\n\n");
1182 printf("\n\n");
1183 #else
1184 abort();
1185 #endif
1186 }
1187
1188 vec_uarg2[0] = 1234;
1189 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1190 vec_uarg1 = vec_uarg2;
1191
1192 result_int = vec_all_eq (vec_uarg1, vec_uarg2);
1193
1194 if (!result_int) {
1195 #if DEBUG
1196 printf("ERROR: unsigned uarg1 = uarg2 vec_all_eq ( ");
1197 print_i128(vec_uarg1[0]);
1198 printf(", ");
1199 print_i128(vec_uarg2[0]);
1200 printf(") failed.\n\n");
1201 #else
1202 abort();
1203 #endif
1204 }
1205
1206 vec_uarg1[0] = 234;
1207 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
1208 vec_uarg2[0] = 1234;
1209 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1210
1211 result_int = vec_all_eq (vec_uarg1, vec_uarg2);
1212
1213 if (result_int) {
1214 #if DEBUG
1215 printf("ERROR: unsigned uarg1 != uarg2 vec_all_eq ( ");
1216 print_i128(vec_uarg1[0]);
1217 printf(", ");
1218 print_i128(vec_uarg2[0]);
1219 printf(") failed.\n\n");
1220 #else
1221 abort();
1222 #endif
1223 }
1224
1225 vec_arg2[0] = 1234;
1226 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1227 vec_arg1 = vec_arg2;
1228
1229 result_int = vec_all_ne (vec_arg1, vec_arg2);
1230
1231 if (result_int) {
1232 #if DEBUG
1233 printf("ERROR: signed arg1 = arg2 vec_all_ne ( ");
1234 print_i128(vec_arg1[0]);
1235 printf(", ");
1236 print_i128(vec_arg2[0]);
1237 printf(") failed.\n\n");
1238 printf("\n\n");
1239 #else
1240 abort();
1241 #endif
1242 }
1243
1244 vec_arg1[0] = -234;
1245 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
1246 vec_arg2[0] = 1234;
1247 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1248
1249 result_int = vec_all_ne (vec_arg1, vec_arg2);
1250
1251 if (!result_int) {
1252 #if DEBUG
1253 printf("ERROR: signed arg1 != arg2 vec_all_ne ( ");
1254 print_i128(vec_arg1[0]);
1255 printf(", ");
1256 print_i128(vec_arg2[0]);
1257 printf(") failed.\n\n");
1258 printf("\n\n");
1259 #else
1260 abort();
1261 #endif
1262 }
1263
1264 vec_uarg2[0] = 1234;
1265 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1266 vec_uarg1 = vec_uarg2;
1267
1268 result_int = vec_all_ne (vec_uarg1, vec_uarg2);
1269
1270 if (result_int) {
1271 #if DEBUG
1272 printf("ERROR: unsigned uarg1 = uarg2 vec_all_ne ( ");
1273 print_i128(vec_uarg1[0]);
1274 printf(", ");
1275 print_i128(vec_uarg2[0]);
1276 printf(") failed.\n\n");
1277 #else
1278 abort();
1279 #endif
1280 }
1281
1282 vec_uarg1[0] = 234;
1283 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
1284 vec_uarg2[0] = 1234;
1285 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1286
1287 result_int = vec_all_ne (vec_uarg1, vec_uarg2);
1288
1289 if (!result_int) {
1290 #if DEBUG
1291 printf("ERROR: unsigned uarg1 != uarg2 vec_all_ne ( ");
1292 print_i128(vec_uarg1[0]);
1293 printf(", ");
1294 print_i128(vec_uarg2[0]);
1295 printf(") failed.\n\n");
1296 #else
1297 abort();
1298 #endif
1299 }
1300
1301 vec_arg2[0] = 1234;
1302 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1303 vec_arg1 = vec_arg2;
1304
1305 result_int = vec_all_lt (vec_arg1, vec_arg2);
1306
1307 if (result_int) {
1308 #if DEBUG
1309 printf("ERROR: signed arg1 = arg2 vec_all_lt ( ");
1310 print_i128(vec_arg1[0]);
1311 printf(", ");
1312 print_i128(vec_arg2[0]);
1313 printf(") failed.\n\n");
1314 printf("\n\n");
1315 #else
1316 abort();
1317 #endif
1318 }
1319
1320 vec_arg1[0] = -234;
1321 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
1322 vec_arg2[0] = 1234;
1323 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1324
1325 result_int = vec_all_lt (vec_arg1, vec_arg2);
1326
1327 if (!result_int) {
1328 #if DEBUG
1329 printf("ERROR: signed arg1 != arg2 vec_all_lt ( ");
1330 print_i128(vec_arg1[0]);
1331 printf(", ");
1332 print_i128(vec_arg2[0]);
1333 printf(") failed.\n\n");
1334 printf("\n\n");
1335 #else
1336 abort();
1337 #endif
1338 }
1339
1340 vec_uarg2[0] = 1234;
1341 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1342 vec_uarg1 = vec_uarg2;
1343
1344 result_int = vec_all_lt (vec_uarg1, vec_uarg2);
1345
1346 if (result_int) {
1347 #if DEBUG
1348 printf("ERROR: unsigned uarg1 = uarg2 vec_all_lt ( ");
1349 print_i128(vec_uarg1[0]);
1350 printf(", ");
1351 print_i128(vec_uarg2[0]);
1352 printf(") failed.\n\n");
1353 #else
1354 abort();
1355 #endif
1356 }
1357
1358 vec_uarg1[0] = 234;
1359 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
1360 vec_uarg2[0] = 1234;
1361 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1362
1363 result_int = vec_all_lt (vec_uarg1, vec_uarg2);
1364
1365 if (!result_int) {
1366 #if DEBUG
1367 printf("ERROR: unsigned uarg1 != uarg2 vec_all_lt ( ");
1368 print_i128(vec_uarg1[0]);
1369 printf(", ");
1370 print_i128(vec_uarg2[0]);
1371 printf(") failed.\n\n");
1372 #else
1373 abort();
1374 #endif
1375 }
1376
1377 vec_arg2[0] = 1234;
1378 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1379 vec_arg1 = vec_arg2;
1380
1381 result_int = vec_all_le (vec_arg1, vec_arg2);
1382
1383 if (!result_int) {
1384 #if DEBUG
1385 printf("ERROR: signed arg1 = arg2 vec_all_le ( ");
1386 print_i128(vec_arg1[0]);
1387 printf(", ");
1388 print_i128(vec_arg2[0]);
1389 printf(") failed.\n\n");
1390 printf("\n\n");
1391 #else
1392 abort();
1393 #endif
1394 }
1395
1396 vec_arg1[0] = -234;
1397 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
1398 vec_arg2[0] = 1234;
1399 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1400
1401 result_int = vec_all_le (vec_arg1, vec_arg2);
1402
1403 if (!result_int) {
1404 #if DEBUG
1405 printf("ERROR: signed arg1 != arg2 vec_all_le ( ");
1406 print_i128(vec_arg1[0]);
1407 printf(", ");
1408 print_i128(vec_arg2[0]);
1409 printf(") failed.\n\n");
1410 printf("\n\n");
1411 #else
1412 abort();
1413 #endif
1414 }
1415
1416 vec_uarg2[0] = 1234;
1417 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1418 vec_uarg1 = vec_uarg2;
1419
1420 result_int = vec_all_le (vec_uarg1, vec_uarg2);
1421
1422 if (!result_int) {
1423 #if DEBUG
1424 printf("ERROR: unsigned uarg1 = uarg2 vec_all_le ( ");
1425 print_i128(vec_uarg1[0]);
1426 printf(", ");
1427 print_i128(vec_uarg2[0]);
1428 printf(") failed.\n\n");
1429 #else
1430 abort();
1431 #endif
1432 }
1433
1434 vec_uarg1[0] = 234;
1435 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
1436 vec_uarg2[0] = 1234;
1437 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1438
1439 result_int = vec_all_le (vec_uarg1, vec_uarg2);
1440
1441 if (!result_int) {
1442 #if DEBUG
1443 printf("ERROR: unsigned uarg1 != uarg2 vec_all_le ( ");
1444 print_i128(vec_uarg1[0]);
1445 printf(", ");
1446 print_i128(vec_uarg2[0]);
1447 printf(") failed.\n\n");
1448 #else
1449 abort();
1450 #endif
1451 }
1452
1453 vec_arg2[0] = 1234;
1454 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1455 vec_arg1 = vec_arg2;
1456
1457 result_int = vec_all_gt (vec_arg1, vec_arg2);
1458
1459 if (result_int) {
1460 #if DEBUG
1461 printf("ERROR: signed arg1 = arg2 vec_all_gt ( ");
1462 print_i128(vec_arg1[0]);
1463 printf(", ");
1464 print_i128(vec_arg2[0]);
1465 printf(") failed.\n\n");
1466 printf("\n\n");
1467 #else
1468 abort();
1469 #endif
1470 }
1471
1472 vec_arg1[0] = -234;
1473 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
1474 vec_arg2[0] = 1234;
1475 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1476
1477 result_int = vec_all_gt (vec_arg1, vec_arg2);
1478
1479 if (result_int) {
1480 #if DEBUG
1481 printf("ERROR: signed arg1 != arg2 vec_all_gt ( ");
1482 print_i128(vec_arg1[0]);
1483 printf(", ");
1484 print_i128(vec_arg2[0]);
1485 printf(") failed.\n\n");
1486 printf("\n\n");
1487 #else
1488 abort();
1489 #endif
1490 }
1491
1492 vec_uarg2[0] = 1234;
1493 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1494 vec_uarg1 = vec_uarg2;
1495
1496 result_int = vec_all_gt (vec_uarg1, vec_uarg2);
1497
1498 if (result_int) {
1499 #if DEBUG
1500 printf("ERROR: unsigned uarg1 = uarg2 vec_all_gt ( ");
1501 print_i128(vec_uarg1[0]);
1502 printf(", ");
1503 print_i128(vec_uarg2[0]);
1504 printf(") failed.\n\n");
1505 #else
1506 abort();
1507 #endif
1508 }
1509
1510 vec_uarg1[0] = 234;
1511 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
1512 vec_uarg2[0] = 1234;
1513 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1514
1515 result_int = vec_all_gt (vec_uarg1, vec_uarg2);
1516
1517 if (result_int) {
1518 #if DEBUG
1519 printf("ERROR: unsigned uarg1 != uarg2 vec_all_gt ( ");
1520 print_i128(vec_uarg1[0]);
1521 printf(", ");
1522 print_i128(vec_uarg2[0]);
1523 printf(") failed.\n\n");
1524 #else
1525 abort();
1526 #endif
1527 }
1528
1529 vec_arg2[0] = 1234;
1530 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1531 vec_arg1 = vec_arg2;
1532
1533 result_int = vec_all_ge (vec_arg1, vec_arg2);
1534
1535 if (!result_int) {
1536 #if DEBUG
1537 printf("ERROR: signed arg1 = arg2 vec_all_ge ( ");
1538 print_i128(vec_arg1[0]);
1539 printf(", ");
1540 print_i128(vec_arg2[0]);
1541 printf(") failed.\n\n");
1542 printf("\n\n");
1543 #else
1544 abort();
1545 #endif
1546 }
1547
1548 vec_arg1[0] = -234;
1549 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
1550 vec_arg2[0] = 1234;
1551 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1552
1553 result_int = vec_all_ge (vec_arg1, vec_arg2);
1554
1555 if (result_int) {
1556 #if DEBUG
1557 printf("ERROR: signed arg1 != arg2 vec_all_ge ( ");
1558 print_i128(vec_arg1[0]);
1559 printf(", ");
1560 print_i128(vec_arg2[0]);
1561 printf(") failed.\n\n");
1562 printf("\n\n");
1563 #else
1564 abort();
1565 #endif
1566 }
1567
1568 vec_uarg2[0] = 1234;
1569 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1570 vec_uarg1 = vec_uarg2;
1571
1572 result_int = vec_all_ge (vec_uarg1, vec_uarg2);
1573
1574 if (!result_int) {
1575 #if DEBUG
1576 printf("ERROR: unsigned uarg1 = uarg2 vec_all_ge ( ");
1577 print_i128(vec_uarg1[0]);
1578 printf(", ");
1579 print_i128(vec_uarg2[0]);
1580 printf(") failed.\n\n");
1581 #else
1582 abort();
1583 #endif
1584 }
1585
1586 vec_uarg1[0] = 234;
1587 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
1588 vec_uarg2[0] = 1234;
1589 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1590
1591 result_int = vec_all_ge (vec_uarg1, vec_uarg2);
1592
1593 if (result_int) {
1594 #if DEBUG
1595 printf("ERROR: unsigned uarg1 != uarg2 vec_all_ge ( ");
1596 print_i128(vec_uarg1[0]);
1597 printf(", ");
1598 print_i128(vec_uarg2[0]);
1599 printf(") failed.\n\n");
1600 #else
1601 abort();
1602 #endif
1603 }
1604
1605 vec_arg2[0] = 1234;
1606 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1607 vec_arg1 = vec_arg2;
1608
1609 result_int = vec_any_eq (vec_arg1, vec_arg2);
1610
1611 if (!result_int) {
1612 #if DEBUG
1613 printf("ERROR: signed arg1 = arg2 vec_any_eq ( ");
1614 print_i128(vec_arg1[0]);
1615 printf(", ");
1616 print_i128(vec_arg2[0]);
1617 printf(") failed.\n\n");
1618 printf("\n\n");
1619 #else
1620 abort();
1621 #endif
1622 }
1623
1624 vec_arg1[0] = -234;
1625 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
1626 vec_arg2[0] = 1234;
1627 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1628
1629 result_int = vec_any_eq (vec_arg1, vec_arg2);
1630
1631 if (result_int) {
1632 #if DEBUG
1633 printf("ERROR: signed arg1 != arg2 vec_any_eq ( ");
1634 print_i128(vec_arg1[0]);
1635 printf(", ");
1636 print_i128(vec_arg2[0]);
1637 printf(") failed.\n\n");
1638 printf("\n\n");
1639 #else
1640 abort();
1641 #endif
1642 }
1643
1644 vec_uarg2[0] = 1234;
1645 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1646 vec_uarg1 = vec_uarg2;
1647
1648 result_int = vec_any_eq (vec_uarg1, vec_uarg2);
1649
1650 if (!result_int) {
1651 #if DEBUG
1652 printf("ERROR: unsigned uarg1 = uarg2 vec_any_eq ( ");
1653 print_i128(vec_uarg1[0]);
1654 printf(", ");
1655 print_i128(vec_uarg2[0]);
1656 printf(") failed.\n\n");
1657 #else
1658 abort();
1659 #endif
1660 }
1661
1662 vec_uarg1[0] = 234;
1663 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
1664 vec_uarg2[0] = 1234;
1665 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1666
1667 result_int = vec_any_eq (vec_uarg1, vec_uarg2);
1668
1669 if (result_int) {
1670 #if DEBUG
1671 printf("ERROR: unsigned uarg1 != uarg2 vec_any_eq ( ");
1672 print_i128(vec_uarg1[0]);
1673 printf(", ");
1674 print_i128(vec_uarg2[0]);
1675 printf(") failed.\n\n");
1676 #else
1677 abort();
1678 #endif
1679 }
1680
1681 vec_arg2[0] = 1234;
1682 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1683 vec_arg1 = vec_arg2;
1684
1685 result_int = vec_any_ne (vec_arg1, vec_arg2);
1686
1687 if (result_int) {
1688 #if DEBUG
1689 printf("ERROR: signed arg1 = arg2 vec_any_ne ( ");
1690 print_i128(vec_arg1[0]);
1691 printf(", ");
1692 print_i128(vec_arg2[0]);
1693 printf(") failed.\n\n");
1694 printf("\n\n");
1695 #else
1696 abort();
1697 #endif
1698 }
1699
1700 vec_arg1[0] = -234;
1701 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
1702 vec_arg2[0] = 1234;
1703 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1704
1705 result_int = vec_any_ne (vec_arg1, vec_arg2);
1706
1707 if (!result_int) {
1708 #if DEBUG
1709 printf("ERROR: signed arg1 != arg2 vec_any_ne ( ");
1710 print_i128(vec_arg1[0]);
1711 printf(", ");
1712 print_i128(vec_arg2[0]);
1713 printf(") failed.\n\n");
1714 printf("\n\n");
1715 #else
1716 abort();
1717 #endif
1718 }
1719
1720 vec_uarg2[0] = 1234;
1721 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1722 vec_uarg1 = vec_uarg2;
1723
1724 result_int = vec_any_ne (vec_uarg1, vec_uarg2);
1725
1726 if (result_int) {
1727 #if DEBUG
1728 printf("ERROR: unsigned uarg1 = uarg2 vec_any_ne ( ");
1729 print_i128(vec_uarg1[0]);
1730 printf(", ");
1731 print_i128(vec_uarg2[0]);
1732 printf(") failed.\n\n");
1733 #else
1734 abort();
1735 #endif
1736 }
1737
1738 vec_uarg1[0] = 234;
1739 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
1740 vec_uarg2[0] = 1234;
1741 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1742
1743 result_int = vec_any_ne (vec_uarg1, vec_uarg2);
1744
1745 if (!result_int) {
1746 #if DEBUG
1747 printf("ERROR: unsigned uarg1 != uarg2 vec_any_ne ( ");
1748 print_i128(vec_uarg1[0]);
1749 printf(", ");
1750 print_i128(vec_uarg2[0]);
1751 printf(") failed.\n\n");
1752 #else
1753 abort();
1754 #endif
1755 }
1756
1757 vec_arg2[0] = 1234;
1758 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1759 vec_arg1 = vec_arg2;
1760
1761 result_int = vec_any_lt (vec_arg1, vec_arg2);
1762
1763 if (result_int) {
1764 #if DEBUG
1765 printf("ERROR: signed arg1 = arg2 vec_any_lt ( ");
1766 print_i128(vec_arg1[0]);
1767 printf(", ");
1768 print_i128(vec_arg2[0]);
1769 printf(") failed.\n\n");
1770 printf("\n\n");
1771 #else
1772 abort();
1773 #endif
1774 }
1775
1776 vec_arg1[0] = -234;
1777 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
1778 vec_arg2[0] = 1234;
1779 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1780
1781 result_int = vec_any_lt (vec_arg1, vec_arg2);
1782
1783 if (!result_int) {
1784 #if DEBUG
1785 printf("ERROR: signed arg1 != arg2 vec_any_lt ( ");
1786 print_i128(vec_arg1[0]);
1787 printf(", ");
1788 print_i128(vec_arg2[0]);
1789 printf(") failed.\n\n");
1790 printf("\n\n");
1791 #else
1792 abort();
1793 #endif
1794 }
1795
1796 vec_uarg2[0] = 1234;
1797 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1798 vec_uarg1 = vec_uarg2;
1799
1800 result_int = vec_any_lt (vec_uarg1, vec_uarg2);
1801
1802 if (result_int) {
1803 #if DEBUG
1804 printf("ERROR: unsigned uarg1 = uarg2 vec_any_lt ( ");
1805 print_i128(vec_uarg1[0]);
1806 printf(", ");
1807 print_i128(vec_uarg2[0]);
1808 printf(") failed.\n\n");
1809 #else
1810 abort();
1811 #endif
1812 }
1813
1814 vec_uarg1[0] = 234;
1815 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
1816 vec_uarg2[0] = 1234;
1817 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1818
1819 result_int = vec_any_lt (vec_uarg1, vec_uarg2);
1820
1821 if (!result_int) {
1822 #if DEBUG
1823 printf("ERROR: unsigned uarg1 != uarg2 vec_any_lt ( ");
1824 print_i128(vec_uarg1[0]);
1825 printf(", ");
1826 print_i128(vec_uarg2[0]);
1827 printf(") failed.\n\n");
1828 #else
1829 abort();
1830 #endif
1831 }
1832
1833 vec_arg2[0] = 1234;
1834 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1835 vec_arg1 = vec_arg2;
1836
1837 result_int = vec_any_gt (vec_arg1, vec_arg2);
1838
1839 if (result_int) {
1840 #if DEBUG
1841 printf("ERROR: signed arg1 = arg2 vec_any_gt ( ");
1842 print_i128(vec_arg1[0]);
1843 printf(", ");
1844 print_i128(vec_arg2[0]);
1845 printf(") failed.\n\n");
1846 printf("\n\n");
1847 #else
1848 abort();
1849 #endif
1850 }
1851
1852 vec_arg1[0] = -234;
1853 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
1854 vec_arg2[0] = 1234;
1855 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1856
1857 result_int = vec_any_gt (vec_arg1, vec_arg2);
1858
1859 if (result_int) {
1860 #if DEBUG
1861 printf("ERROR: signed arg1 != arg2 vec_any_gt ( ");
1862 print_i128(vec_arg1[0]);
1863 printf(", ");
1864 print_i128(vec_arg2[0]);
1865 printf(") failed.\n\n");
1866 printf("\n\n");
1867 #else
1868 abort();
1869 #endif
1870 }
1871
1872 vec_uarg2[0] = 1234;
1873 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1874 vec_uarg1 = vec_uarg2;
1875
1876 result_int = vec_any_gt (vec_uarg1, vec_uarg2);
1877
1878 if (result_int) {
1879 #if DEBUG
1880 printf("ERROR: unsigned uarg1 = uarg2 vec_any_gt ( ");
1881 print_i128(vec_uarg1[0]);
1882 printf(", ");
1883 print_i128(vec_uarg2[0]);
1884 printf(") failed.\n\n");
1885 #else
1886 abort();
1887 #endif
1888 }
1889
1890 vec_uarg1[0] = 234;
1891 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
1892 vec_uarg2[0] = 1234;
1893 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1894
1895 result_int = vec_any_gt (vec_uarg1, vec_uarg2);
1896
1897 if (result_int) {
1898 #if DEBUG
1899 printf("ERROR: unsigned uarg1 != uarg2 vec_any_gt ( ");
1900 print_i128(vec_uarg1[0]);
1901 printf(", ");
1902 print_i128(vec_uarg2[0]);
1903 printf(") failed.\n\n");
1904 #else
1905 abort();
1906 #endif
1907 }
1908
1909 vec_arg2[0] = 1234;
1910 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1911 vec_arg1 = vec_arg2;
1912
1913 result_int = vec_any_le (vec_arg1, vec_arg2);
1914
1915 if (!result_int) {
1916 #if DEBUG
1917 printf("ERROR: signed arg1 = arg2 vec_any_le ( ");
1918 print_i128(vec_arg1[0]);
1919 printf(", ");
1920 print_i128(vec_arg2[0]);
1921 printf(") failed.\n\n");
1922 printf("\n\n");
1923 #else
1924 abort();
1925 #endif
1926 }
1927
1928 vec_arg1[0] = -234;
1929 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
1930 vec_arg2[0] = 1234;
1931 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1932
1933 result_int = vec_any_le (vec_arg1, vec_arg2);
1934
1935 if (!result_int) {
1936 #if DEBUG
1937 printf("ERROR: signed arg1 != arg2 vec_any_le ( ");
1938 print_i128(vec_arg1[0]);
1939 printf(", ");
1940 print_i128(vec_arg2[0]);
1941 printf(") failed.\n\n");
1942 printf("\n\n");
1943 #else
1944 abort();
1945 #endif
1946 }
1947
1948 vec_uarg2[0] = 1234;
1949 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1950 vec_uarg1 = vec_uarg2;
1951
1952 result_int = vec_any_le (vec_uarg1, vec_uarg2);
1953
1954 if (!result_int) {
1955 #if DEBUG
1956 printf("ERROR: unsigned uarg1 = uarg2 vec_any_le ( ");
1957 print_i128(vec_uarg1[0]);
1958 printf(", ");
1959 print_i128(vec_uarg2[0]);
1960 printf(") failed.\n\n");
1961 #else
1962 abort();
1963 #endif
1964 }
1965
1966 vec_uarg1[0] = 234;
1967 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
1968 vec_uarg2[0] = 1234;
1969 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
1970
1971 result_int = vec_any_le (vec_uarg1, vec_uarg2);
1972
1973 if (!result_int) {
1974 #if DEBUG
1975 printf("ERROR: unsigned uarg1 != uarg2 vec_any_le ( ");
1976 print_i128(vec_uarg1[0]);
1977 printf(", ");
1978 print_i128(vec_uarg2[0]);
1979 printf(") failed.\n\n");
1980 #else
1981 abort();
1982 #endif
1983 }
1984
1985 vec_arg2[0] = 1234;
1986 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
1987 vec_arg1 = vec_arg2;
1988
1989 result_int = vec_any_ge (vec_arg1, vec_arg2);
1990
1991 if (!result_int) {
1992 #if DEBUG
1993 printf("ERROR: signed arg1 = arg2 vec_any_ge ( ");
1994 print_i128(vec_arg1[0]);
1995 printf(", ");
1996 print_i128(vec_arg2[0]);
1997 printf(") failed.\n\n");
1998 printf("\n\n");
1999 #else
2000 abort();
2001 #endif
2002 }
2003
2004 vec_arg1[0] = -234;
2005 vec_arg1[0] = (vec_arg1[0] << 64) | 4567;
2006 vec_arg2[0] = 1234;
2007 vec_arg2[0] = (vec_arg2[0] << 64) | 4567;
2008
2009 result_int = vec_any_ge (vec_arg1, vec_arg2);
2010
2011 if (result_int) {
2012 #if DEBUG
2013 printf("ERROR: signed arg1 != arg2 vec_any_ge ( ");
2014 print_i128(vec_arg1[0]);
2015 printf(", ");
2016 print_i128(vec_arg2[0]);
2017 printf(") failed.\n\n");
2018 printf("\n\n");
2019 #else
2020 abort();
2021 #endif
2022 }
2023
2024 vec_uarg2[0] = 1234;
2025 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
2026 vec_uarg1 = vec_uarg2;
2027
2028 result_int = vec_any_ge (vec_uarg1, vec_uarg2);
2029
2030 if (!result_int) {
2031 #if DEBUG
2032 printf("ERROR: unsigned uarg1 = uarg2 vec_any_ge ( ");
2033 print_i128(vec_uarg1[0]);
2034 printf(", ");
2035 print_i128(vec_uarg2[0]);
2036 printf(") failed.\n\n");
2037 #else
2038 abort();
2039 #endif
2040 }
2041
2042 vec_uarg1[0] = 234;
2043 vec_uarg1[0] = (vec_uarg1[0] << 64) | 4567;
2044 vec_uarg2[0] = 1234;
2045 vec_uarg2[0] = (vec_uarg2[0] << 64) | 4567;
2046
2047 result_int = vec_any_ge (vec_uarg1, vec_uarg2);
2048
2049 if (result_int) {
2050 #if DEBUG
2051 printf("ERROR: unsigned uarg1 != uarg2 vec_any_gt ( ");
2052 print_i128(vec_uarg1[0]);
2053 printf(", ");
2054 print_i128(vec_uarg2[0]);
2055 printf(") failed.\n\n");
2056 #else
2057 abort();
2058 #endif
2059 }
2060 #endif
2061
2062 /* Vector multiply Even and Odd tests */
2063 vec_arg1_di[0] = 200;
2064 vec_arg1_di[1] = 400;
2065 vec_arg2_di[0] = 1234;
2066 vec_arg2_di[1] = 4567;
2067 expected_result = vec_arg1_di[0] * vec_arg2_di[0];
2068
2069 vec_result = vec_mule (vec_arg1_di, vec_arg2_di);
2070
2071 if (vec_result[0] != expected_result) {
2072 #if DEBUG
2073 printf("ERROR: vec_mule (signed, signed) failed.\n");
2074 printf(" vec_arg1_di[0] = %lld\n", vec_arg1_di[0]);
2075 printf(" vec_arg2_di[0] = %lld\n", vec_arg2_di[0]);
2076 printf("Result = ");
2077 print_i128(vec_result[0]);
2078 printf("\nExpected Result = ");
2079 print_i128(expected_result);
2080 printf("\n\n");
2081 #else
2082 abort();
2083 #endif
2084 }
2085
2086 vec_arg1_di[0] = -200;
2087 vec_arg1_di[1] = -400;
2088 vec_arg2_di[0] = 1234;
2089 vec_arg2_di[1] = 4567;
2090 expected_result = vec_arg1_di[1] * vec_arg2_di[1];
2091
2092 vec_result = vec_mulo (vec_arg1_di, vec_arg2_di);
2093
2094 if (vec_result[0] != expected_result) {
2095 #if DEBUG
2096 printf("ERROR: vec_mulo (signed, signed) failed.\n");
2097 printf(" vec_arg1_di[1] = %lld\n", vec_arg1_di[1]);
2098 printf(" vec_arg2_di[1] = %lld\n", vec_arg2_di[1]);
2099 printf("Result = ");
2100 print_i128(vec_result[0]);
2101 printf("\nExpected Result = ");
2102 print_i128(expected_result);
2103 printf("\n\n");
2104 #else
2105 abort();
2106 #endif
2107 }
2108
2109 vec_uarg1_di[0] = 200;
2110 vec_uarg1_di[1] = 400;
2111 vec_uarg2_di[0] = 1234;
2112 vec_uarg2_di[1] = 4567;
2113 uexpected_result = vec_uarg1_di[0] * vec_uarg2_di[0];
2114
2115 vec_uresult = vec_mule (vec_uarg1_di, vec_uarg2_di);
2116
2117 if (vec_uresult[0] != uexpected_result) {
2118 #if DEBUG
2119 printf("ERROR: vec_mule (unsigned, unsigned) failed.\n");
2120 printf(" vec_uarg1_di[1] = %lld\n", vec_uarg1_di[1]);
2121 printf(" vec_uarg2_di[1] = %lld\n", vec_uarg2_di[1]);
2122 printf("Result = ");
2123 print_i128(vec_uresult[0]);
2124 printf("\nExpected Result = ");
2125 print_i128(uexpected_result);
2126 printf("\n\n");
2127 #else
2128 abort();
2129 #endif
2130 }
2131
2132 vec_uarg1_di[0] = 200;
2133 vec_uarg1_di[1] = 400;
2134 vec_uarg2_di[0] = 1234;
2135 vec_uarg2_di[1] = 4567;
2136 uexpected_result = vec_uarg1_di[1] * vec_uarg2_di[1];
2137
2138 vec_uresult = vec_mulo (vec_uarg1_di, vec_uarg2_di);
2139
2140 if (vec_uresult[0] != uexpected_result) {
2141 #if DEBUG
2142 printf("ERROR: vec_mulo (unsigned, unsigned) failed.\n");
2143 printf(" vec_uarg1_di[0] = %lld\n", vec_uarg1_di[0]);
2144 printf(" vec_uarg2_di[0] = %lld\n", vec_uarg2_di[0]);
2145 printf("Result = ");
2146 print_i128(vec_uresult[0]);
2147 printf("\nExpected Result = ");
2148 print_i128(uexpected_result);
2149 printf("\n\n");
2150 #else
2151 abort();
2152 #endif
2153 }
2154
2155 /* Vector Multiply Longword */
2156 vec_arg1_di[0] = 100;
2157 vec_arg1_di[1] = -123456;
2158
2159 vec_arg2_di[0] = 123;
2160 vec_arg2_di[1] = 1000;
2161
2162 vec_expected_result_di[0] = 12300;
2163 vec_expected_result_di[1] = -123456000;
2164
2165 vec_result_di = vec_arg1_di * vec_arg2_di;
2166
2167 for (i = 0; i<2; i++) {
2168 if (vec_result_di[i] != vec_expected_result_di[i]) {
2169 #if DEBUG
2170 printf("ERROR: vector multipy [%d] ((long long) %lld) = ", i,
2171 vec_result_di[i]);
2172 printf("\n does not match expected_result [%d] = ((long long) %lld)", i,
2173 vec_expected_result_di[i]);
2174 printf("\n\n");
2175 #else
2176 abort();
2177 #endif
2178 }
2179 }
2180
2181 /* Vector Divide Quadword */
2182 vec_arg1[0] = -12345678;
2183 vec_arg2[0] = 2;
2184 expected_result = -6172839;
2185
2186 vec_result = vec_div (vec_arg1, vec_arg2);
2187
2188 if (vec_result[0] != expected_result) {
2189 #if DEBUG
2190 printf("ERROR: vec_div (signed, signed) failed.\n");
2191 printf("vec_arg1[0] = ");
2192 print_i128(vec_arg1[0]);
2193 printf("\nvec_arg2[0] = ");
2194 print_i128(vec_arg2[0]);
2195 printf("\nResult = ");
2196 print_i128(vec_result[0]);
2197 printf("\nExpected result = ");
2198 print_i128(expected_result);
2199 printf("\n\n");
2200 #else
2201 abort();
2202 #endif
2203 }
2204
2205 vec_uarg1[0] = 24680;
2206 vec_uarg2[0] = 4;
2207 uexpected_result = 6170;
2208
2209 vec_uresult = vec_div (vec_uarg1, vec_uarg2);
2210
2211 if (vec_uresult[0] != uexpected_result) {
2212 #if DEBUG
2213 printf("ERROR: vec_div (unsigned, unsigned) failed.\n");
2214 printf("vec_uarg1[0] = ");
2215 print_i128(vec_uarg1[0]);
2216 printf("\nvec_uarg2[0] = ");
2217 print_i128(vec_uarg2[0]);
2218 printf("\nResult = ");
2219 print_i128(vec_uresult[0]);
2220 printf("\nExpected result = ");
2221 print_i128(uexpected_result);
2222 printf("\n\n");
2223 #else
2224 abort();
2225 #endif
2226 }
2227
2228 /* Vector Divide Extended Quadword */
2229 vec_arg1[0] = -20; // has 128-bit of zero concatenated onto it
2230 vec_arg2[0] = 0x2000000000000000;
2231 vec_arg2[0] = vec_arg2[0] << 64;
2232 expected_result = -160;
2233
2234 vec_result = vec_dive (vec_arg1, vec_arg2);
2235
2236 if (vec_result[0] != expected_result) {
2237 #if DEBUG
2238 printf("ERROR: vec_dive (signed, signed) failed.\n");
2239 printf("vec_arg1[0] = ");
2240 print_i128(vec_arg1[0]);
2241 printf("\nvec_arg2[0] = ");
2242 print_i128(vec_arg2[0]);
2243 printf("\nResult = ");
2244 print_i128(vec_result[0]);
2245 printf("\nExpected result = ");
2246 print_i128(expected_result);
2247 printf("\n\n");
2248 #else
2249 abort();
2250 #endif
2251 }
2252
2253 vec_uarg1[0] = 20; // has 128-bit of zero concatenated onto it
2254 vec_uarg2[0] = 0x4000000000000000;
2255 vec_uarg2[0] = vec_uarg2[0] << 64;
2256 uexpected_result = 80;
2257
2258 vec_uresult = vec_dive (vec_uarg1, vec_uarg2);
2259
2260 if (vec_uresult[0] != uexpected_result) {
2261 #if DEBUG
2262 printf("ERROR: vec_dive (unsigned, unsigned) failed.\n");
2263 printf("vec_uarg1[0] = ");
2264 print_i128(vec_uarg1[0]);
2265 printf("\nvec_uarg2[0] = ");
2266 print_i128(vec_uarg2[0]);
2267 printf("\nResult = ");
2268 print_i128(vec_uresult[0]);
2269 printf("\nExpected result = ");
2270 print_i128(uexpected_result);
2271 printf("\n\n");
2272 #else
2273 abort();
2274 #endif
2275 }
2276
2277 /* Vector modulo quad word */
2278 vec_arg1[0] = -12345675;
2279 vec_arg2[0] = 2;
2280 expected_result = -1;
2281
2282 vec_result = vec_mod (vec_arg1, vec_arg2);
2283
2284 if (vec_result[0] != expected_result) {
2285 #if DEBUG
2286 printf("ERROR: vec_mod (signed, signed) failed.\n");
2287 printf("vec_arg1[0] = ");
2288 print_i128(vec_arg1[0]);
2289 printf("\nvec_arg2[0] = ");
2290 print_i128(vec_arg2[0]);
2291 printf("\nResult = ");
2292 print_i128(vec_result[0]);
2293 printf("\nExpected result = ");
2294 print_i128(expected_result);
2295 printf("\n\n");
2296 #else
2297 abort();
2298 #endif
2299 }
2300
2301 vec_uarg1[0] = 24685;
2302 vec_uarg2[0] = 4;
2303 uexpected_result = 1;
2304
2305 vec_uresult = vec_mod (vec_uarg1, vec_uarg2);
2306
2307 if (vec_uresult[0] != uexpected_result) {
2308 #if DEBUG
2309 printf("ERROR: vec_mod (unsigned, unsigned) failed.\n");
2310 printf("vec_uarg1[0] = ");
2311 print_i128(vec_uarg1[0]);
2312 printf("\nvec_uarg2[0] = ");
2313 print_i128(vec_uarg2[0]);
2314 printf("\nResult = ");
2315 print_i128(vec_uresult[0]);
2316 printf("\nExpected result = ");
2317 print_i128(uexpected_result);
2318 printf("\n\n");
2319 #else
2320 abort();
2321 #endif
2322 }
2323
2324 /* DFP to __int128 and __int128 to DFP conversions */
2325 /* Print the DFP value as an unsigned int so we can see the bit patterns. */
2326 conv.u128 = 0x2208000000000000ULL;
2327 conv.u128 = (conv.u128 << 64) | 0x4ULL; //DFP bit pattern for integer 4
2328 expected_result_dfp128 = conv.d128;
2329
2330 arg1 = 4;
2331
2332 conv.d128 = (_Decimal128) arg1;
2333
2334 result_dfp128 = (_Decimal128) arg1;
2335 if (((conv.u128 >>64) != 0x2208000000000000ULL) &&
2336 ((conv.u128 & 0xFFFFFFFFFFFFFFFF) != 0x4ULL)) {
2337 #if DEBUG
2338 printf("ERROR: convert int128 value ");
2339 print_i128 (arg1);
2340 conv.d128 = result_dfp128;
2341 printf("\nto DFP value 0x%llx %llx (printed as hex bit string) ",
2342 (unsigned long long)((conv.u128) >>64),
2343 (unsigned long long)((conv.u128) & 0xFFFFFFFFFFFFFFFF));
2344
2345 conv.d128 = expected_result_dfp128;
2346 printf("\ndoes not match expected_result = 0x%llx %llx\n\n",
2347 (unsigned long long) (conv.u128>>64),
2348 (unsigned long long) (conv.u128 & 0xFFFFFFFFFFFFFFFF));
2349 #else
2350 abort();
2351 #endif
2352 }
2353
2354 expected_result = 4;
2355
2356 conv.u128 = 0x2208000000000000ULL;
2357 conv.u128 = (conv.u128 << 64) | 0x4ULL; // 4 as DFP
2358 arg1_dfp128 = conv.d128;
2359
2360 result = (__int128_t) arg1_dfp128;
2361
2362 if (result != expected_result) {
2363 #if DEBUG
2364 printf("ERROR: convert DFP value ");
2365 printf("0x%llx %llx (printed as hex bit string) ",
2366 (unsigned long long)(conv.u128>>64),
2367 (unsigned long long)(conv.u128 & 0xFFFFFFFFFFFFFFFF));
2368 printf("to __int128 value = ");
2369 print_i128 (result);
2370 printf("\ndoes not match expected_result = ");
2371 print_i128 (expected_result);
2372 printf("\n");
2373 #else
2374 abort();
2375 #endif
2376 }
2377 return 0;
2378 }