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