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