?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drd/tests/tsan_thread_wrappers_pthread.h: Fix MyThread::ThreadBody()
[valgrind.git] / VEX / switchback / test_ppc_jm1.c
blob292f433100199df6a8e43b0869122c1757c65016
1
2 /* HOW TO COMPILE FOR SWITCHBACK:
3
4 gcc -O -c test_ppc_jm1.c -mregnames -Wall
5
6 */
7
8 #undef HAS_ALTIVEC
9 #define NO_FLOAT
10 #undef IS_PPC405
11
12
13 /*
14 * test-ppc.c:
15 * PPC tests for qemu-PPC CPU emulation checks
16 *
17 * Copyright (c) 2005 Jocelyn Mayer
18 *
19 * This program is free software; you can redistribute it and/or
20 * modify it under the terms of the GNU General Public License V2
21 * as published by the Free Software Foundation.
22 */
23
24 /*
25 * Theory of operations:
26 * a few registers are reserved for the test program:
27 * r14 => r18
28 * f14 => f18
29 * I do preload test values in r14 thru r17 (or less, depending on the number
30 * of register operands needed), patch the test opcode if any immediate
31 * operands are required, execute the tested opcode.
32 * XER, CCR and FPSCR are cleared before every test.
33 * I always get the result in r17 and also save XER and CCR for fixed-point
34 * operations. I also check FPSCR for floating points operations.
35 *
36 * Improvments:
37 * a more cleaver FPSCR management is needed: for now, I always test
38 * the round-to-zero case. Other rounding modes also need to be tested.
39 */
40
41 #include <stdint.h>
42 //#include <stdlib.h>
43 //#include <stdio.h>
44 //#include <string.h>
45 //#include <unistd.h>
46 //#include <fcntl.h>
47 //#include <ctype.h>
48 //#include <math.h>
49 //#include <fenv.h>
50
51 #define NULL ((void*)0)
52
53 //#include "test-ppc.h"
54
55 // BEGIN #include "test-ppc.h"
56 /*
57 * test-ppc.h:
58 * PPC tests for qemu-PPC CPU emulation checks - definitions
59 *
60 * Copyright (c) 2005 Jocelyn Mayer
61 *
62 * This program is free software; you can redistribute it and/or
63 * modify it under the terms of the GNU General Public License V2
64 * as published by the Free Software Foundation.
65 */
66
67 #if !defined (__TEST_PPC_H__)
68 #define __TEST_PPC_H__
69
70 typedef void (*test_func_t) (void);
71 typedef struct test_t test_t;
72 typedef struct test_table_t test_table_t;
73 struct test_t {
74 test_func_t func;
75 const unsigned char *name;
76 };
77
78 struct test_table_t {
79 test_t *tests;
80 const unsigned char *name;
81 int flags;
82 };
83
84 typedef void (*test_loop_t) (const unsigned char *name, test_func_t func);
85
86 enum test_flags {
87 /* Nb arguments */
88 PPC_ONE_ARG = 0x00000001,
89 PPC_TWO_ARGS = 0x00000002,
90 PPC_THREE_ARGS = 0x00000003,
91 PPC_CMP_ARGS = 0x00000004,
92 PPC_CMPI_ARGS = 0x00000005,
93 PPC_TWO_I16 = 0x00000006,
94 PPC_SPECIAL = 0x00000007,
95 PPC_NB_ARGS = 0x0000000F,
96 /* Type */
97 PPC_ARITH = 0x00000100,
98 PPC_LOGICAL = 0x00000200,
99 PPC_COMPARE = 0x00000300,
100 PPC_CROP = 0x00000400,
101 PPC_TYPE = 0x00000F00,
102 /* Family */
103 PPC_INTEGER = 0x00010000,
104 PPC_FLOAT = 0x00020000,
105 PPC_405 = 0x00030000,
106 PPC_ALTIVEC = 0x00040000,
107 PPC_FALTIVEC = 0x00050000,
108 PPC_FAMILY = 0x000F0000,
109 /* Flags */
110 PPC_CR = 0x01000000,
111 };
112
113 #endif /* !defined (__TEST_PPC_H__) */
114
115 // END #include "test-ppc.h"
116
117
118
119
120 //#define DEBUG_ARGS_BUILD
121 #if defined (DEBUG_ARGS_BUILD)
122 #define AB_DPRINTF(fmt, args...) do { vexxx_printf(fmt , ##args); } while (0)
123 #else
124 #define AB_DPRINTF(fmt, args...) do { } while (0)
125 #endif
126
127 //#define DEBUG_FILTER
128 #if defined (DEBUG_FILTER)
129 #define FDPRINTF(fmt, args...) do { vexxx_printf(fmt , ##args); } while (0)
130 #else
131 #define FDPRINTF(fmt, args...) do { } while (0)
132 #endif
133
134 #if !defined (NO_FLOAT)
135 register double f14 __asm__ ("f14");
136 register double f15 __asm__ ("f15");
137 register double f16 __asm__ ("f16");
138 register double f17 __asm__ ("f17");
139 register double f18 __asm__ ("f18");
140 #endif
141 register uint32_t r14 __asm__ ("r14");
142 register uint32_t r15 __asm__ ("r15");
143 register uint32_t r16 __asm__ ("r16");
144 register uint32_t r17 __asm__ ("r17");
145 register uint32_t r18 __asm__ ("r18");
146
147
148 /////////////////////////////////////////////////////////////////////
149 /////////////////////////////////////////////////////////////////////
150 /////////////////////////////////////////////////////////////////////
151 /////////////////////////////////////////////////////////////////////
152
153 /* Something which has the same size as void* on the host. That is,
154 it is 32 bits on a 32-bit host and 64 bits on a 64-bit host, and so
155 it can safely be coerced to and from a pointer type on the host
156 machine. */
157 typedef unsigned long HWord;
158 typedef char HChar;
159 typedef signed int Int;
160 typedef unsigned int UInt;
161 typedef unsigned char UChar;
162
163 typedef signed long long int Long;
164 typedef unsigned long long int ULong;
165
166 typedef unsigned char Bool;
167 #define True ((Bool)1)
168 #define False ((Bool)0)
169
170
171 //#include "/home/sewardj/VEX/trunk/pub/libvex_basictypes.h"
172
173 static HWord (*serviceFn)(HWord,HWord) = 0;
174
175 static Bool my_isspace ( UChar c )
176 {
177 return c == ' '
178 || c == '\f'
179 || c == '\n'
180 || c == '\r'
181 || c == '\t'
182 || c == '\v';
183 }
184
185 #if 0 // unused
186 static char* my_strcpy ( char* dest, const char* src )
187 {
188 char* dest_orig = dest;
189 while (*src) *dest++ = *src++;
190 *dest = 0;
191 return dest_orig;
192 }
193
194 static void* my_memcpy ( void *dest, const void *src, int sz )
195 {
196 const char *s = (const char *)src;
197 char *d = (char *)dest;
198
199 while (sz--)
200 *d++ = *s++;
201
202 return dest;
203 }
204
205 static void* my_memmove( void *dst, const void *src, unsigned int len )
206 {
207 register char *d;
208 register char *s;
209 if ( dst > src ) {
210 d = (char *)dst + len - 1;
211 s = (char *)src + len - 1;
212 while ( len >= 4 ) {
213 *d-- = *s--;
214 *d-- = *s--;
215 *d-- = *s--;
216 *d-- = *s--;
217 len -= 4;
218 }
219 while ( len-- ) {
220 *d-- = *s--;
221 }
222 } else if ( dst < src ) {
223 d = (char *)dst;
224 s = (char *)src;
225 while ( len >= 4 ) {
226 *d++ = *s++;
227 *d++ = *s++;
228 *d++ = *s++;
229 *d++ = *s++;
230 len -= 4;
231 }
232 while ( len-- ) {
233 *d++ = *s++;
234 }
235 }
236 return dst;
237 }
238 #endif
239
240 char* my_strcat ( char* dest, const char* src )
241 {
242 char* dest_orig = dest;
243 while (*dest) dest++;
244 while (*src) *dest++ = *src++;
245 *dest = 0;
246 return dest_orig;
247 }
248
249 int my_strcmp ( const char* s1, const char* s2 )
250 {
251 register unsigned char c1;
252 register unsigned char c2;
253 while (True) {
254 c1 = *(unsigned char *)s1;
255 c2 = *(unsigned char *)s2;
256 if (c1 != c2) break;
257 if (c1 == 0) break;
258 s1++; s2++;
259 }
260 if ((unsigned char)c1 < (unsigned char)c2) return -1;
261 if ((unsigned char)c1 > (unsigned char)c2) return 1;
262 return 0;
263 }
264
265
266 int my_memcmp ( const void *s1V, const void *s2V, int n )
267 {
268 int res;
269 unsigned char a0;
270 unsigned char b0;
271 unsigned char* s1 = (unsigned char*)s1V;
272 unsigned char* s2 = (unsigned char*)s2V;
273
274 while (n != 0) {
275 a0 = s1[0];
276 b0 = s2[0];
277 s1 += 1;
278 s2 += 1;
279 res = ((int)a0) - ((int)b0);
280 if (res != 0)
281 return res;
282 n -= 1;
283 }
284 return 0;
285 }
286
287 char* my_strchr ( const char* s, int c )
288 {
289 UChar ch = (UChar)((UInt)c);
290 UChar* p = (UChar*)s;
291 while (True) {
292 if (*p == ch) return p;
293 if (*p == 0) return NULL;
294 p++;
295 }
296 }
297
298 void* my_malloc ( int n )
299 {
300 void* r = (void*) (*serviceFn)(2,n);
301 return r;
302 }
303
304
305 /////////////////////////////////////////////////////////////////////
306
307 static void vexxx_log_bytes ( char* p, int n )
308 {
309 int i;
310 for (i = 0; i < n; i++)
311 (*serviceFn)( 1, (int)p[i] );
312 }
313
314 /*---------------------------------------------------------*/
315 /*--- vexxx_printf ---*/
316 /*---------------------------------------------------------*/
317
318 /* This should be the only <...> include in the entire VEX library.
319 New code for vex_util.c should go above this point. */
320 #include <stdarg.h>
321
322 static HChar vexxx_toupper ( HChar c )
323 {
324 if (c >= 'a' && c <= 'z')
325 return c + ('A' - 'a');
326 else
327 return c;
328 }
329
330 static Int vexxx_strlen ( const HChar* str )
331 {
332 Int i = 0;
333 while (str[i] != 0) i++;
334 return i;
335 }
336
337 Bool vexxx_streq ( const HChar* s1, const HChar* s2 )
338 {
339 while (True) {
340 if (*s1 == 0 && *s2 == 0)
341 return True;
342 if (*s1 != *s2)
343 return False;
344 s1++;
345 s2++;
346 }
347 }
348
349 /* Some flags. */
350 #define VG_MSG_SIGNED 1 /* The value is signed. */
351 #define VG_MSG_ZJUSTIFY 2 /* Must justify with '0'. */
352 #define VG_MSG_LJUSTIFY 4 /* Must justify on the left. */
353 #define VG_MSG_PAREN 8 /* Parenthesize if present (for %y) */
354 #define VG_MSG_COMMA 16 /* Add commas to numbers (for %d, %u) */
355
356 /* Copy a string into the buffer. */
357 static UInt
358 myvprintf_str ( void(*send)(HChar), Int flags, Int width, HChar* str,
359 Bool capitalise )
360 {
361 # define MAYBE_TOUPPER(ch) (capitalise ? vexxx_toupper(ch) : (ch))
362 UInt ret = 0;
363 Int i, extra;
364 Int len = vexxx_strlen(str);
365
366 if (width == 0) {
367 ret += len;
368 for (i = 0; i < len; i++)
369 send(MAYBE_TOUPPER(str[i]));
370 return ret;
371 }
372
373 if (len > width) {
374 ret += width;
375 for (i = 0; i < width; i++)
376 send(MAYBE_TOUPPER(str[i]));
377 return ret;
378 }
379
380 extra = width - len;
381 if (flags & VG_MSG_LJUSTIFY) {
382 ret += extra;
383 for (i = 0; i < extra; i++)
384 send(' ');
385 }
386 ret += len;
387 for (i = 0; i < len; i++)
388 send(MAYBE_TOUPPER(str[i]));
389 if (!(flags & VG_MSG_LJUSTIFY)) {
390 ret += extra;
391 for (i = 0; i < extra; i++)
392 send(' ');
393 }
394
395 # undef MAYBE_TOUPPER
396
397 return ret;
398 }
399
400 /* Write P into the buffer according to these args:
401 * If SIGN is true, p is a signed.
402 * BASE is the base.
403 * If WITH_ZERO is true, '0' must be added.
404 * WIDTH is the width of the field.
405 */
406 static UInt
407 myvprintf_int64 ( void(*send)(HChar), Int flags, Int base, Int width, ULong pL)
408 {
409 HChar buf[40];
410 Int ind = 0;
411 Int i, nc = 0;
412 Bool neg = False;
413 HChar *digits = "0123456789ABCDEF";
414 UInt ret = 0;
415 UInt p = (UInt)pL;
416
417 if (base < 2 || base > 16)
418 return ret;
419
420 if ((flags & VG_MSG_SIGNED) && (Int)p < 0) {
421 p = - (Int)p;
422 neg = True;
423 }
424
425 if (p == 0)
426 buf[ind++] = '0';
427 else {
428 while (p > 0) {
429 if ((flags & VG_MSG_COMMA) && 10 == base &&
430 0 == (ind-nc) % 3 && 0 != ind)
431 {
432 buf[ind++] = ',';
433 nc++;
434 }
435 buf[ind++] = digits[p % base];
436 p /= base;
437 }
438 }
439
440 if (neg)
441 buf[ind++] = '-';
442
443 if (width > 0 && !(flags & VG_MSG_LJUSTIFY)) {
444 for(; ind < width; ind++) {
445 //vassert(ind < 39);
446 buf[ind] = ((flags & VG_MSG_ZJUSTIFY) ? '0': ' ');
447 }
448 }
449
450 /* Reverse copy to buffer. */
451 ret += ind;
452 for (i = ind -1; i >= 0; i--) {
453 send(buf[i]);
454 }
455 if (width > 0 && (flags & VG_MSG_LJUSTIFY)) {
456 for(; ind < width; ind++) {
457 ret++;
458 send(' '); // Never pad with zeroes on RHS -- changes the value!
459 }
460 }
461 return ret;
462 }
463
464
465 /* A simple vprintf(). */
466 static
467 UInt vprintf_wrk ( void(*send)(HChar), const HChar *format, va_list vargs )
468 {
469 UInt ret = 0;
470 int i;
471 int flags;
472 int width;
473 Bool is_long;
474
475 /* We assume that vargs has already been initialised by the
476 caller, using va_start, and that the caller will similarly
477 clean up with va_end.
478 */
479
480 for (i = 0; format[i] != 0; i++) {
481 if (format[i] != '%') {
482 send(format[i]);
483 ret++;
484 continue;
485 }
486 i++;
487 /* A '%' has been found. Ignore a trailing %. */
488 if (format[i] == 0)
489 break;
490 if (format[i] == '%') {
491 /* `%%' is replaced by `%'. */
492 send('%');
493 ret++;
494 continue;
495 }
496 flags = 0;
497 is_long = False;
498 width = 0; /* length of the field. */
499 if (format[i] == '(') {
500 flags |= VG_MSG_PAREN;
501 i++;
502 }
503 /* If ',' follows '%', commas will be inserted. */
504 if (format[i] == ',') {
505 flags |= VG_MSG_COMMA;
506 i++;
507 }
508 /* If '-' follows '%', justify on the left. */
509 if (format[i] == '-') {
510 flags |= VG_MSG_LJUSTIFY;
511 i++;
512 }
513 /* If '0' follows '%', pads will be inserted. */
514 if (format[i] == '0') {
515 flags |= VG_MSG_ZJUSTIFY;
516 i++;
517 }
518 /* Compute the field length. */
519 while (format[i] >= '0' && format[i] <= '9') {
520 width *= 10;
521 width += format[i++] - '0';
522 }
523 while (format[i] == 'l') {
524 i++;
525 is_long = True;
526 }
527
528 switch (format[i]) {
529 case 'd': /* %d */
530 flags |= VG_MSG_SIGNED;
531 if (is_long)
532 ret += myvprintf_int64(send, flags, 10, width,
533 (ULong)(va_arg (vargs, Long)));
534 else
535 ret += myvprintf_int64(send, flags, 10, width,
536 (ULong)(va_arg (vargs, Int)));
537 break;
538 case 'u': /* %u */
539 if (is_long)
540 ret += myvprintf_int64(send, flags, 10, width,
541 (ULong)(va_arg (vargs, ULong)));
542 else
543 ret += myvprintf_int64(send, flags, 10, width,
544 (ULong)(va_arg (vargs, UInt)));
545 break;
546 case 'p': /* %p */
547 ret += 2;
548 send('0');
549 send('x');
550 ret += myvprintf_int64(send, flags, 16, width,
551 (ULong)((HWord)va_arg (vargs, void *)));
552 break;
553 case 'x': /* %x */
554 if (is_long)
555 ret += myvprintf_int64(send, flags, 16, width,
556 (ULong)(va_arg (vargs, ULong)));
557 else
558 ret += myvprintf_int64(send, flags, 16, width,
559 (ULong)(va_arg (vargs, UInt)));
560 break;
561 case 'c': /* %c */
562 ret++;
563 send((va_arg (vargs, int)));
564 break;
565 case 's': case 'S': { /* %s */
566 char *str = va_arg (vargs, char *);
567 if (str == (char*) 0) str = "(null)";
568 ret += myvprintf_str(send, flags, width, str,
569 (format[i]=='S'));
570 break;
571 }
572 # if 0
573 case 'y': { /* %y - print symbol */
574 Addr a = va_arg(vargs, Addr);
575
576 HChar *name;
577 if (VG_(get_fnname_w_offset)(a, &name)) {
578 HChar buf[1 + VG_strlen(name) + 1 + 1];
579 if (flags & VG_MSG_PAREN) {
580 VG_(sprintf)(str, "(%s)", name):
581 } else {
582 VG_(sprintf)(str, "%s", name):
583 }
584 ret += myvprintf_str(send, flags, width, buf, 0);
585 }
586 break;
587 }
588 # endif
589 default:
590 break;
591 }
592 }
593 return ret;
594 }
595
596
597 /* A general replacement for printf(). Note that only low-level
598 debugging info should be sent via here. The official route is to
599 to use vg_message(). This interface is deprecated.
600 */
601 static HChar myprintf_buf[1000];
602 static Int n_myprintf_buf;
603
604 static void add_to_myprintf_buf ( HChar c )
605 {
606 if (c == '\n' || n_myprintf_buf >= 1000-10 /*paranoia*/ ) {
607 (*vexxx_log_bytes)( myprintf_buf, vexxx_strlen(myprintf_buf) );
608 n_myprintf_buf = 0;
609 myprintf_buf[n_myprintf_buf] = 0;
610 }
611 myprintf_buf[n_myprintf_buf++] = c;
612 myprintf_buf[n_myprintf_buf] = 0;
613 }
614
615 static UInt vexxx_printf ( const char *format, ... )
616 {
617 UInt ret;
618 va_list vargs;
619 va_start(vargs,format);
620
621 n_myprintf_buf = 0;
622 myprintf_buf[n_myprintf_buf] = 0;
623 ret = vprintf_wrk ( add_to_myprintf_buf, format, vargs );
624
625 if (n_myprintf_buf > 0) {
626 (*vexxx_log_bytes)( myprintf_buf, n_myprintf_buf );
627 }
628
629 va_end(vargs);
630
631 return ret;
632 }
633
634 /*---------------------------------------------------------------*/
635 /*--- end vex_util.c ---*/
636 /*---------------------------------------------------------------*/
637
638
639 /////////////////////////////////////////////////////////////////////
640 /////////////////////////////////////////////////////////////////////
641 /////////////////////////////////////////////////////////////////////
642 /////////////////////////////////////////////////////////////////////
643
644 // BEGIN #include "ops-ppc.c"
645 /*
646 * WARNING:
647 * This file has been auto-generated by './gen-ppc' program
648 * Please don't edit by hand
649 */
650
651
652 //BEGIN #include "test-ppc.h"
653 /*
654 * test-ppc.h:
655 * PPC tests for qemu-PPC CPU emulation checks - definitions
656 *
657 * Copyright (c) 2005 Jocelyn Mayer
658 *
659 * This program is free software; you can redistribute it and/or
660 * modify it under the terms of the GNU General Public License V2
661 * as published by the Free Software Foundation.
662 */
663
664 #if !defined (__TEST_PPC_H__)
665 #define __TEST_PPC_H__
666
667 typedef void (*test_func_t) (void);
668 typedef struct test_t test_t;
669 typedef struct test_table_t test_table_t;
670 struct test_t {
671 test_func_t func;
672 const unsigned char *name;
673 };
674
675 struct test_table_t {
676 test_t *tests;
677 const unsigned char *name;
678 int flags;
679 };
680
681 typedef void (*test_loop_t) (const unsigned char *name, test_func_t func);
682
683 enum test_flags {
684 /* Nb arguments */
685 PPC_ONE_ARG = 0x00000001,
686 PPC_TWO_ARGS = 0x00000002,
687 PPC_THREE_ARGS = 0x00000003,
688 PPC_CMP_ARGS = 0x00000004,
689 PPC_CMPI_ARGS = 0x00000005,
690 PPC_TWO_I16 = 0x00000006,
691 PPC_SPECIAL = 0x00000007,
692 PPC_NB_ARGS = 0x0000000F,
693 /* Type */
694 PPC_ARITH = 0x00000100,
695 PPC_LOGICAL = 0x00000200,
696 PPC_COMPARE = 0x00000300,
697 PPC_CROP = 0x00000400,
698 PPC_TYPE = 0x00000F00,
699 /* Family */
700 PPC_INTEGER = 0x00010000,
701 PPC_FLOAT = 0x00020000,
702 PPC_405 = 0x00030000,
703 PPC_ALTIVEC = 0x00040000,
704 PPC_FALTIVEC = 0x00050000,
705 PPC_FAMILY = 0x000F0000,
706 /* Flags */
707 PPC_CR = 0x01000000,
708 };
709
710 #endif /* !defined (__TEST_PPC_H__) */
711
712 //END #include "test-ppc.h"
713
714 static void test_add (void)
715 {
716 __asm__ __volatile__ ("add 17, 14, 15");
717 }
718
719 static void test_addo (void)
720 {
721 __asm__ __volatile__ ("addo 17, 14, 15");
722 }
723
724 static void test_addc (void)
725 {
726 __asm__ __volatile__ ("addc 17, 14, 15");
727 }
728
729 static void test_addco (void)
730 {
731 __asm__ __volatile__ ("addco 17, 14, 15");
732 }
733
734 static void test_adde (void)
735 {
736 __asm__ __volatile__ ("adde 17, 14, 15");
737 }
738
739 static void test_addeo (void)
740 {
741 __asm__ __volatile__ ("addeo 17, 14, 15");
742 }
743
744 static void test_divw (void)
745 {
746 __asm__ __volatile__ ("divw 17, 14, 15");
747 }
748
749 static void test_divwo (void)
750 {
751 __asm__ __volatile__ ("divwo 17, 14, 15");
752 }
753
754 static void test_divwu (void)
755 {
756 __asm__ __volatile__ ("divwu 17, 14, 15");
757 }
758
759 static void test_divwuo (void)
760 {
761 __asm__ __volatile__ ("divwuo 17, 14, 15");
762 }
763
764 static void test_mulhw (void)
765 {
766 __asm__ __volatile__ ("mulhw 17, 14, 15");
767 }
768
769 static void test_mulhwu (void)
770 {
771 __asm__ __volatile__ ("mulhwu 17, 14, 15");
772 }
773
774 static void test_mullw (void)
775 {
776 __asm__ __volatile__ ("mullw 17, 14, 15");
777 }
778
779 static void test_mullwo (void)
780 {
781 __asm__ __volatile__ ("mullwo 17, 14, 15");
782 }
783
784 static void test_subf (void)
785 {
786 __asm__ __volatile__ ("subf 17, 14, 15");
787 }
788
789 static void test_subfo (void)
790 {
791 __asm__ __volatile__ ("subfo 17, 14, 15");
792 }
793
794 static void test_subfc (void)
795 {
796 __asm__ __volatile__ ("subfc 17, 14, 15");
797 }
798
799 static void test_subfco (void)
800 {
801 __asm__ __volatile__ ("subfco 17, 14, 15");
802 }
803
804 static void test_subfe (void)
805 {
806 __asm__ __volatile__ ("subfe 17, 14, 15");
807 }
808
809 static void test_subfeo (void)
810 {
811 __asm__ __volatile__ ("subfeo 17, 14, 15");
812 }
813
814 static test_t tests_ia_ops_two[] = {
815 { &test_add , " add", },
816 { &test_addo , " addo", },
817 { &test_addc , " addc", },
818 { &test_addco , " addco", },
819 { &test_adde , " adde", },
820 { &test_addeo , " addeo", },
821 { &test_divw , " divw", },
822 { &test_divwo , " divwo", },
823 { &test_divwu , " divwu", },
824 { &test_divwuo , " divwuo", },
825 { &test_mulhw , " mulhw", },
826 { &test_mulhwu , " mulhwu", },
827 { &test_mullw , " mullw", },
828 { &test_mullwo , " mullwo", },
829 { &test_subf , " subf", },
830 { &test_subfo , " subfo", },
831 { &test_subfc , " subfc", },
832 { &test_subfco , " subfco", },
833 { &test_subfe , " subfe", },
834 { &test_subfeo , " subfeo", },
835 { NULL, NULL, },
836 };
837
838 static void test_add_ (void)
839 {
840 __asm__ __volatile__ ("add. 17, 14, 15");
841 }
842
843 static void test_addo_ (void)
844 {
845 __asm__ __volatile__ ("addo. 17, 14, 15");
846 }
847
848 static void test_addc_ (void)
849 {
850 __asm__ __volatile__ ("addc. 17, 14, 15");
851 }
852
853 static void test_addco_ (void)
854 {
855 __asm__ __volatile__ ("addco. 17, 14, 15");
856 }
857
858 static void test_adde_ (void)
859 {
860 __asm__ __volatile__ ("adde. 17, 14, 15");
861 }
862
863 static void test_addeo_ (void)
864 {
865 __asm__ __volatile__ ("addeo. 17, 14, 15");
866 }
867
868 static void test_divw_ (void)
869 {
870 __asm__ __volatile__ ("divw. 17, 14, 15");
871 }
872
873 static void test_divwo_ (void)
874 {
875 __asm__ __volatile__ ("divwo. 17, 14, 15");
876 }
877
878 static void test_divwu_ (void)
879 {
880 __asm__ __volatile__ ("divwu. 17, 14, 15");
881 }
882
883 static void test_divwuo_ (void)
884 {
885 __asm__ __volatile__ ("divwuo. 17, 14, 15");
886 }
887
888 static void test_subf_ (void)
889 {
890 __asm__ __volatile__ ("subf. 17, 14, 15");
891 }
892
893 static void test_subfo_ (void)
894 {
895 __asm__ __volatile__ ("subfo. 17, 14, 15");
896 }
897
898 static void test_subfc_ (void)
899 {
900 __asm__ __volatile__ ("subfc. 17, 14, 15");
901 }
902
903 static void test_subfco_ (void)
904 {
905 __asm__ __volatile__ ("subfco. 17, 14, 15");
906 }
907
908 static void test_subfe_ (void)
909 {
910 __asm__ __volatile__ ("subfe. 17, 14, 15");
911 }
912
913 static void test_subfeo_ (void)
914 {
915 __asm__ __volatile__ ("subfeo. 17, 14, 15");
916 }
917
918 static test_t tests_iar_ops_two[] = {
919 { &test_add_ , " add.", },
920 { &test_addo_ , " addo.", },
921 { &test_addc_ , " addc.", },
922 { &test_addco_ , " addco.", },
923 { &test_adde_ , " adde.", },
924 { &test_addeo_ , " addeo.", },
925 { &test_divw_ , " divw.", },
926 { &test_divwo_ , " divwo.", },
927 { &test_divwu_ , " divwu.", },
928 { &test_divwuo_ , " divwuo.", },
929 { &test_subf_ , " subf.", },
930 { &test_subfo_ , " subfo.", },
931 { &test_subfc_ , " subfc.", },
932 { &test_subfco_ , " subfco.", },
933 { &test_subfe_ , " subfe.", },
934 { &test_subfeo_ , " subfeo.", },
935 { NULL, NULL, },
936 };
937
938 static void test_and (void)
939 {
940 __asm__ __volatile__ ("and 17, 14, 15");
941 }
942
943 static void test_andc (void)
944 {
945 __asm__ __volatile__ ("andc 17, 14, 15");
946 }
947
948 static void test_eqv (void)
949 {
950 __asm__ __volatile__ ("eqv 17, 14, 15");
951 }
952
953 static void test_nand (void)
954 {
955 __asm__ __volatile__ ("nand 17, 14, 15");
956 }
957
958 static void test_nor (void)
959 {
960 __asm__ __volatile__ ("nor 17, 14, 15");
961 }
962
963 static void test_or (void)
964 {
965 __asm__ __volatile__ ("or 17, 14, 15");
966 }
967
968 static void test_orc (void)
969 {
970 __asm__ __volatile__ ("orc 17, 14, 15");
971 }
972
973 static void test_xor (void)
974 {
975 __asm__ __volatile__ ("xor 17, 14, 15");
976 }
977
978 static void test_slw (void)
979 {
980 __asm__ __volatile__ ("slw 17, 14, 15");
981 }
982
983 static void test_sraw (void)
984 {
985 __asm__ __volatile__ ("sraw 17, 14, 15");
986 }
987
988 static void test_srw (void)
989 {
990 __asm__ __volatile__ ("srw 17, 14, 15");
991 }
992
993 static test_t tests_il_ops_two[] = {
994 { &test_and , " and", },
995 { &test_andc , " andc", },
996 { &test_eqv , " eqv", },
997 { &test_nand , " nand", },
998 { &test_nor , " nor", },
999 { &test_or , " or", },
1000 { &test_orc , " orc", },
1001 { &test_xor , " xor", },
1002 { &test_slw , " slw", },
1003 { &test_sraw , " sraw", },
1004 { &test_srw , " srw", },
1005 { NULL, NULL, },
1006 };
1007
1008 static void test_and_ (void)
1009 {
1010 __asm__ __volatile__ ("and. 17, 14, 15");
1011 }
1012
1013 static void test_andc_ (void)
1014 {
1015 __asm__ __volatile__ ("andc. 17, 14, 15");
1016 }
1017
1018 static void test_eqv_ (void)
1019 {
1020 __asm__ __volatile__ ("eqv. 17, 14, 15");
1021 }
1022
1023 static void test_mulhw_ (void)
1024 {
1025 __asm__ __volatile__ ("mulhw. 17, 14, 15");
1026 }
1027
1028 static void test_mulhwu_ (void)
1029 {
1030 __asm__ __volatile__ ("mulhwu. 17, 14, 15");
1031 }
1032
1033 static void test_mullw_ (void)
1034 {
1035 __asm__ __volatile__ ("mullw. 17, 14, 15");
1036 }
1037
1038 static void test_mullwo_ (void)
1039 {
1040 __asm__ __volatile__ ("mullwo. 17, 14, 15");
1041 }
1042
1043 static void test_nand_ (void)
1044 {
1045 __asm__ __volatile__ ("nand. 17, 14, 15");
1046 }
1047
1048 static void test_nor_ (void)
1049 {
1050 __asm__ __volatile__ ("nor. 17, 14, 15");
1051 }
1052
1053 static void test_or_ (void)
1054 {
1055 __asm__ __volatile__ ("or. 17, 14, 15");
1056 }
1057
1058 static void test_orc_ (void)
1059 {
1060 __asm__ __volatile__ ("orc. 17, 14, 15");
1061 }
1062
1063 static void test_xor_ (void)
1064 {
1065 __asm__ __volatile__ ("xor. 17, 14, 15");
1066 }
1067
1068 static void test_slw_ (void)
1069 {
1070 __asm__ __volatile__ ("slw. 17, 14, 15");
1071 }
1072
1073 static void test_sraw_ (void)
1074 {
1075 __asm__ __volatile__ ("sraw. 17, 14, 15");
1076 }
1077
1078 static void test_srw_ (void)
1079 {
1080 __asm__ __volatile__ ("srw. 17, 14, 15");
1081 }
1082
1083 static test_t tests_ilr_ops_two[] = {
1084 { &test_and_ , " and.", },
1085 { &test_andc_ , " andc.", },
1086 { &test_eqv_ , " eqv.", },
1087 { &test_mulhw_ , " mulhw.", },
1088 { &test_mulhwu_ , " mulhwu.", },
1089 { &test_mullw_ , " mullw.", },
1090 { &test_mullwo_ , " mullwo.", },
1091 { &test_nand_ , " nand.", },
1092 { &test_nor_ , " nor.", },
1093 { &test_or_ , " or.", },
1094 { &test_orc_ , " orc.", },
1095 { &test_xor_ , " xor.", },
1096 { &test_slw_ , " slw.", },
1097 { &test_sraw_ , " sraw.", },
1098 { &test_srw_ , " srw.", },
1099 { NULL, NULL, },
1100 };
1101
1102 static void test_cmp (void)
1103 {
1104 __asm__ __volatile__ ("cmp 2, 14, 15");
1105 }
1106
1107 static void test_cmpl (void)
1108 {
1109 __asm__ __volatile__ ("cmpl 2, 14, 15");
1110 }
1111
1112 static test_t tests_icr_ops_two[] = {
1113 { &test_cmp , " cmp", },
1114 { &test_cmpl , " cmpl", },
1115 { NULL, NULL, },
1116 };
1117
1118 static void test_cmpi (void)
1119 {
1120 __asm__ __volatile__ ("cmpi 2, 14, 15");
1121 }
1122
1123 static void test_cmpli (void)
1124 {
1125 __asm__ __volatile__ ("cmpli 2, 14, 15");
1126 }
1127
1128 static test_t tests_icr_ops_two_i16[] = {
1129 { &test_cmpi , " cmpi", },
1130 { &test_cmpli , " cmpli", },
1131 { NULL, NULL, },
1132 };
1133
1134 static void test_addi (void)
1135 {
1136 __asm__ __volatile__ ("addi 17, 14, 0");
1137 }
1138
1139 static void test_addic (void)
1140 {
1141 __asm__ __volatile__ ("addic 17, 14, 0");
1142 }
1143
1144 static void test_addis (void)
1145 {
1146 __asm__ __volatile__ ("addis 17, 14, 0");
1147 }
1148
1149 static void test_mulli (void)
1150 {
1151 __asm__ __volatile__ ("mulli 17, 14, 0");
1152 }
1153
1154 static void test_subfic (void)
1155 {
1156 __asm__ __volatile__ ("subfic 17, 14, 0");
1157 }
1158
1159 static test_t tests_ia_ops_two_i16[] = {
1160 { &test_addi , " addi", },
1161 { &test_addic , " addic", },
1162 { &test_addis , " addis", },
1163 { &test_mulli , " mulli", },
1164 { &test_subfic , " subfic", },
1165 { NULL, NULL, },
1166 };
1167
1168 static void test_addic_ (void)
1169 {
1170 __asm__ __volatile__ ("addic. 17, 14, 0");
1171 }
1172
1173 static test_t tests_iar_ops_two_i16[] = {
1174 { &test_addic_ , " addic.", },
1175 { NULL, NULL, },
1176 };
1177
1178 static void test_ori (void)
1179 {
1180 __asm__ __volatile__ ("ori 17, 14, 0");
1181 }
1182
1183 static void test_oris (void)
1184 {
1185 __asm__ __volatile__ ("oris 17, 14, 0");
1186 }
1187
1188 static void test_xori (void)
1189 {
1190 __asm__ __volatile__ ("xori 17, 14, 0");
1191 }
1192
1193 static void test_xoris (void)
1194 {
1195 __asm__ __volatile__ ("xoris 17, 14, 0");
1196 }
1197
1198 static test_t tests_il_ops_two_i16[] = {
1199 { &test_ori , " ori", },
1200 { &test_oris , " oris", },
1201 { &test_xori , " xori", },
1202 { &test_xoris , " xoris", },
1203 { NULL, NULL, },
1204 };
1205
1206 static void test_andi_ (void)
1207 {
1208 __asm__ __volatile__ ("andi. 17, 14, 0");
1209 }
1210
1211 static void test_andis_ (void)
1212 {
1213 __asm__ __volatile__ ("andis. 17, 14, 0");
1214 }
1215
1216 static test_t tests_ilr_ops_two_i16[] = {
1217 { &test_andi_ , " andi.", },
1218 { &test_andis_ , " andis.", },
1219 { NULL, NULL, },
1220 };
1221
1222 static void test_crand (void)
1223 {
1224 __asm__ __volatile__ ("crand 17, 14, 15");
1225 }
1226
1227 static void test_crandc (void)
1228 {
1229 __asm__ __volatile__ ("crandc 17, 14, 15");
1230 }
1231
1232 static void test_creqv (void)
1233 {
1234 __asm__ __volatile__ ("creqv 17, 14, 15");
1235 }
1236
1237 static void test_crnand (void)
1238 {
1239 __asm__ __volatile__ ("crnand 17, 14, 15");
1240 }
1241
1242 static void test_crnor (void)
1243 {
1244 __asm__ __volatile__ ("crnor 17, 14, 15");
1245 }
1246
1247 static void test_cror (void)
1248 {
1249 __asm__ __volatile__ ("cror 17, 14, 15");
1250 }
1251
1252 static void test_crorc (void)
1253 {
1254 __asm__ __volatile__ ("crorc 17, 14, 15");
1255 }
1256
1257 static void test_crxor (void)
1258 {
1259 __asm__ __volatile__ ("crxor 17, 14, 15");
1260 }
1261
1262 static test_t tests_crl_ops_two[] = {
1263 { &test_crand , " crand", },
1264 { &test_crandc , " crandc", },
1265 { &test_creqv , " creqv", },
1266 { &test_crnand , " crnand", },
1267 { &test_crnor , " crnor", },
1268 { &test_cror , " cror", },
1269 { &test_crorc , " crorc", },
1270 { &test_crxor , " crxor", },
1271 { NULL, NULL, },
1272 };
1273
1274 static void test_addme (void)
1275 {
1276 __asm__ __volatile__ ("addme 17, 14");
1277 }
1278
1279 static void test_addmeo (void)
1280 {
1281 __asm__ __volatile__ ("addmeo 17, 14");
1282 }
1283
1284 static void test_addze (void)
1285 {
1286 __asm__ __volatile__ ("addze 17, 14");
1287 }
1288
1289 static void test_addzeo (void)
1290 {
1291 __asm__ __volatile__ ("addzeo 17, 14");
1292 }
1293
1294 static void test_subfme (void)
1295 {
1296 __asm__ __volatile__ ("subfme 17, 14");
1297 }
1298
1299 static void test_subfmeo (void)
1300 {
1301 __asm__ __volatile__ ("subfmeo 17, 14");
1302 }
1303
1304 static void test_subfze (void)
1305 {
1306 __asm__ __volatile__ ("subfze 17, 14");
1307 }
1308
1309 static void test_subfzeo (void)
1310 {
1311 __asm__ __volatile__ ("subfzeo 17, 14");
1312 }
1313
1314 static test_t tests_ia_ops_one[] = {
1315 { &test_addme , " addme", },
1316 { &test_addmeo , " addmeo", },
1317 { &test_addze , " addze", },
1318 { &test_addzeo , " addzeo", },
1319 { &test_subfme , " subfme", },
1320 { &test_subfmeo , " subfmeo", },
1321 { &test_subfze , " subfze", },
1322 { &test_subfzeo , " subfzeo", },
1323 { NULL, NULL, },
1324 };
1325
1326 static void test_addme_ (void)
1327 {
1328 __asm__ __volatile__ ("addme. 17, 14");
1329 }
1330
1331 static void test_addmeo_ (void)
1332 {
1333 __asm__ __volatile__ ("addmeo. 17, 14");
1334 }
1335
1336 static void test_addze_ (void)
1337 {
1338 __asm__ __volatile__ ("addze. 17, 14");
1339 }
1340
1341 static void test_addzeo_ (void)
1342 {
1343 __asm__ __volatile__ ("addzeo. 17, 14");
1344 }
1345
1346 static void test_subfme_ (void)
1347 {
1348 __asm__ __volatile__ ("subfme. 17, 14");
1349 }
1350
1351 static void test_subfmeo_ (void)
1352 {
1353 __asm__ __volatile__ ("subfmeo. 17, 14");
1354 }
1355
1356 static void test_subfze_ (void)
1357 {
1358 __asm__ __volatile__ ("subfze. 17, 14");
1359 }
1360
1361 static void test_subfzeo_ (void)
1362 {
1363 __asm__ __volatile__ ("subfzeo. 17, 14");
1364 }
1365
1366 static test_t tests_iar_ops_one[] = {
1367 { &test_addme_ , " addme.", },
1368 { &test_addmeo_ , " addmeo.", },
1369 { &test_addze_ , " addze.", },
1370 { &test_addzeo_ , " addzeo.", },
1371 { &test_subfme_ , " subfme.", },
1372 { &test_subfmeo_ , " subfmeo.", },
1373 { &test_subfze_ , " subfze.", },
1374 { &test_subfzeo_ , " subfzeo.", },
1375 { NULL, NULL, },
1376 };
1377
1378 static void test_cntlzw (void)
1379 {
1380 __asm__ __volatile__ ("cntlzw 17, 14");
1381 }
1382
1383 static void test_extsb (void)
1384 {
1385 __asm__ __volatile__ ("extsb 17, 14");
1386 }
1387
1388 static void test_extsh (void)
1389 {
1390 __asm__ __volatile__ ("extsh 17, 14");
1391 }
1392
1393 static void test_neg (void)
1394 {
1395 __asm__ __volatile__ ("neg 17, 14");
1396 }
1397
1398 static void test_nego (void)
1399 {
1400 __asm__ __volatile__ ("nego 17, 14");
1401 }
1402
1403 static test_t tests_il_ops_one[] = {
1404 { &test_cntlzw , " cntlzw", },
1405 { &test_extsb , " extsb", },
1406 { &test_extsh , " extsh", },
1407 { &test_neg , " neg", },
1408 { &test_nego , " nego", },
1409 { NULL, NULL, },
1410 };
1411
1412 static void test_cntlzw_ (void)
1413 {
1414 __asm__ __volatile__ ("cntlzw. 17, 14");
1415 }
1416
1417 static void test_extsb_ (void)
1418 {
1419 __asm__ __volatile__ ("extsb. 17, 14");
1420 }
1421
1422 static void test_extsh_ (void)
1423 {
1424 __asm__ __volatile__ ("extsh. 17, 14");
1425 }
1426
1427 static void test_neg_ (void)
1428 {
1429 __asm__ __volatile__ ("neg. 17, 14");
1430 }
1431
1432 static void test_nego_ (void)
1433 {
1434 __asm__ __volatile__ ("nego. 17, 14");
1435 }
1436
1437 static test_t tests_ilr_ops_one[] = {
1438 { &test_cntlzw_ , " cntlzw.", },
1439 { &test_extsb_ , " extsb.", },
1440 { &test_extsh_ , " extsh.", },
1441 { &test_neg_ , " neg.", },
1442 { &test_nego_ , " nego.", },
1443 { NULL, NULL, },
1444 };
1445
1446 static void test_rlwimi (void)
1447 {
1448 __asm__ __volatile__ ("rlwimi 17, 14, 0, 0, 0");
1449 }
1450
1451 static void test_rlwinm (void)
1452 {
1453 __asm__ __volatile__ ("rlwinm 17, 14, 0, 0, 0");
1454 }
1455
1456 static void test_rlwnm (void)
1457 {
1458 __asm__ __volatile__ ("rlwnm 17, 14, 15, 0, 0");
1459 }
1460
1461 static void test_srawi (void)
1462 {
1463 __asm__ __volatile__ ("srawi 17, 14, 0");
1464 }
1465
1466 static test_t tests_il_ops_spe[] = {
1467 { &test_rlwimi , " rlwimi", },
1468 { &test_rlwinm , " rlwinm", },
1469 { &test_rlwnm , " rlwnm", },
1470 { &test_srawi , " srawi", },
1471 { NULL, NULL, },
1472 };
1473
1474 static void test_rlwimi_ (void)
1475 {
1476 __asm__ __volatile__ ("rlwimi. 17, 14, 0, 0, 0");
1477 }
1478
1479 static void test_rlwinm_ (void)
1480 {
1481 __asm__ __volatile__ ("rlwinm. 17, 14, 0, 0, 0");
1482 }
1483
1484 static void test_rlwnm_ (void)
1485 {
1486 __asm__ __volatile__ ("rlwnm. 17, 14, 15, 0, 0");
1487 }
1488
1489 static void test_srawi_ (void)
1490 {
1491 __asm__ __volatile__ ("srawi. 17, 14, 0");
1492 }
1493
1494 static test_t tests_ilr_ops_spe[] = {
1495 { &test_rlwimi_ , " rlwimi.", },
1496 { &test_rlwinm_ , " rlwinm.", },
1497 { &test_rlwnm_ , " rlwnm.", },
1498 { &test_srawi_ , " srawi.", },
1499 { NULL, NULL, },
1500 };
1501
1502 #if !defined (NO_FLOAT)
1503 static void test_fsel (void)
1504 {
1505 __asm__ __volatile__ ("fsel 17, 14, 15, 16");
1506 }
1507
1508 static void test_fmadd (void)
1509 {
1510 __asm__ __volatile__ ("fmadd 17, 14, 15, 16");
1511 }
1512
1513 static void test_fmadds (void)
1514 {
1515 __asm__ __volatile__ ("fmadds 17, 14, 15, 16");
1516 }
1517
1518 static void test_fmsub (void)
1519 {
1520 __asm__ __volatile__ ("fmsub 17, 14, 15, 16");
1521 }
1522
1523 static void test_fmsubs (void)
1524 {
1525 __asm__ __volatile__ ("fmsubs 17, 14, 15, 16");
1526 }
1527
1528 static void test_fnmadd (void)
1529 {
1530 __asm__ __volatile__ ("fnmadd 17, 14, 15, 16");
1531 }
1532
1533 static void test_fnmadds (void)
1534 {
1535 __asm__ __volatile__ ("fnmadds 17, 14, 15, 16");
1536 }
1537
1538 static void test_fnmsub (void)
1539 {
1540 __asm__ __volatile__ ("fnmsub 17, 14, 15, 16");
1541 }
1542
1543 static void test_fnmsubs (void)
1544 {
1545 __asm__ __volatile__ ("fnmsubs 17, 14, 15, 16");
1546 }
1547
1548 static test_t tests_fa_ops_three[] = {
1549 { &test_fsel , " fsel", },
1550 { &test_fmadd , " fmadd", },
1551 { &test_fmadds , " fmadds", },
1552 { &test_fmsub , " fmsub", },
1553 { &test_fmsubs , " fmsubs", },
1554 { &test_fnmadd , " fnmadd", },
1555 { &test_fnmadds , " fnmadds", },
1556 { &test_fnmsub , " fnmsub", },
1557 { &test_fnmsubs , " fnmsubs", },
1558 { NULL, NULL, },
1559 };
1560 #endif /* !defined (NO_FLOAT) */
1561
1562 #if !defined (NO_FLOAT)
1563 static void test_fsel_ (void)
1564 {
1565 __asm__ __volatile__ ("fsel. 17, 14, 15, 16");
1566 }
1567
1568 static void test_fmadd_ (void)
1569 {
1570 __asm__ __volatile__ ("fmadd. 17, 14, 15, 16");
1571 }
1572
1573 static void test_fmadds_ (void)
1574 {
1575 __asm__ __volatile__ ("fmadds. 17, 14, 15, 16");
1576 }
1577
1578 static void test_fmsub_ (void)
1579 {
1580 __asm__ __volatile__ ("fmsub. 17, 14, 15, 16");
1581 }
1582
1583 static void test_fmsubs_ (void)
1584 {
1585 __asm__ __volatile__ ("fmsubs. 17, 14, 15, 16");
1586 }
1587
1588 static void test_fnmadd_ (void)
1589 {
1590 __asm__ __volatile__ ("fnmadd. 17, 14, 15, 16");
1591 }
1592
1593 static void test_fnmadds_ (void)
1594 {
1595 __asm__ __volatile__ ("fnmadds. 17, 14, 15, 16");
1596 }
1597
1598 static void test_fnmsub_ (void)
1599 {
1600 __asm__ __volatile__ ("fnmsub. 17, 14, 15, 16");
1601 }
1602
1603 static void test_fnmsubs_ (void)
1604 {
1605 __asm__ __volatile__ ("fnmsubs. 17, 14, 15, 16");
1606 }
1607
1608 static test_t tests_far_ops_three[] = {
1609 { &test_fsel_ , " fsel.", },
1610 { &test_fmadd_ , " fmadd.", },
1611 { &test_fmadds_ , " fmadds.", },
1612 { &test_fmsub_ , " fmsub.", },
1613 { &test_fmsubs_ , " fmsubs.", },
1614 { &test_fnmadd_ , " fnmadd.", },
1615 { &test_fnmadds_ , " fnmadds.", },
1616 { &test_fnmsub_ , " fnmsub.", },
1617 { &test_fnmsubs_ , " fnmsubs.", },
1618 { NULL, NULL, },
1619 };
1620 #endif /* !defined (NO_FLOAT) */
1621
1622 #if !defined (NO_FLOAT)
1623 static void test_fadd (void)
1624 {
1625 __asm__ __volatile__ ("fadd 17, 14, 15");
1626 }
1627
1628 static void test_fadds (void)
1629 {
1630 __asm__ __volatile__ ("fadds 17, 14, 15");
1631 }
1632
1633 static void test_fsub (void)
1634 {
1635 __asm__ __volatile__ ("fsub 17, 14, 15");
1636 }
1637
1638 static void test_fsubs (void)
1639 {
1640 __asm__ __volatile__ ("fsubs 17, 14, 15");
1641 }
1642
1643 static void test_fmul (void)
1644 {
1645 __asm__ __volatile__ ("fmul 17, 14, 15");
1646 }
1647
1648 static void test_fmuls (void)
1649 {
1650 __asm__ __volatile__ ("fmuls 17, 14, 15");
1651 }
1652
1653 static void test_fdiv (void)
1654 {
1655 __asm__ __volatile__ ("fdiv 17, 14, 15");
1656 }
1657
1658 static void test_fdivs (void)
1659 {
1660 __asm__ __volatile__ ("fdivs 17, 14, 15");
1661 }
1662
1663 static test_t tests_fa_ops_two[] = {
1664 { &test_fadd , " fadd", },
1665 { &test_fadds , " fadds", },
1666 { &test_fsub , " fsub", },
1667 { &test_fsubs , " fsubs", },
1668 { &test_fmul , " fmul", },
1669 { &test_fmuls , " fmuls", },
1670 { &test_fdiv , " fdiv", },
1671 { &test_fdivs , " fdivs", },
1672 { NULL, NULL, },
1673 };
1674 #endif /* !defined (NO_FLOAT) */
1675
1676 #if !defined (NO_FLOAT)
1677 static void test_fadd_ (void)
1678 {
1679 __asm__ __volatile__ ("fadd. 17, 14, 15");
1680 }
1681
1682 static void test_fadds_ (void)
1683 {
1684 __asm__ __volatile__ ("fadds. 17, 14, 15");
1685 }
1686
1687 static void test_fsub_ (void)
1688 {
1689 __asm__ __volatile__ ("fsub. 17, 14, 15");
1690 }
1691
1692 static void test_fsubs_ (void)
1693 {
1694 __asm__ __volatile__ ("fsubs. 17, 14, 15");
1695 }
1696
1697 static void test_fmul_ (void)
1698 {
1699 __asm__ __volatile__ ("fmul. 17, 14, 15");
1700 }
1701
1702 static void test_fmuls_ (void)
1703 {
1704 __asm__ __volatile__ ("fmuls. 17, 14, 15");
1705 }
1706
1707 static void test_fdiv_ (void)
1708 {
1709 __asm__ __volatile__ ("fdiv. 17, 14, 15");
1710 }
1711
1712 static void test_fdivs_ (void)
1713 {
1714 __asm__ __volatile__ ("fdivs. 17, 14, 15");
1715 }
1716
1717 static test_t tests_far_ops_two[] = {
1718 { &test_fadd_ , " fadd.", },
1719 { &test_fadds_ , " fadds.", },
1720 { &test_fsub_ , " fsub.", },
1721 { &test_fsubs_ , " fsubs.", },
1722 { &test_fmul_ , " fmul.", },
1723 { &test_fmuls_ , " fmuls.", },
1724 { &test_fdiv_ , " fdiv.", },
1725 { &test_fdivs_ , " fdivs.", },
1726 { NULL, NULL, },
1727 };
1728 #endif /* !defined (NO_FLOAT) */
1729
1730 #if !defined (NO_FLOAT)
1731 static void test_fcmpo (void)
1732 {
1733 __asm__ __volatile__ ("fcmpo 2, 14, 15");
1734 }
1735
1736 static void test_fcmpu (void)
1737 {
1738 __asm__ __volatile__ ("fcmpu 2, 14, 15");
1739 }
1740
1741 static test_t tests_fcr_ops_two[] = {
1742 { &test_fcmpo , " fcmpo", },
1743 { &test_fcmpu , " fcmpu", },
1744 { NULL, NULL, },
1745 };
1746 #endif /* !defined (NO_FLOAT) */
1747
1748 #if !defined (NO_FLOAT)
1749 static void test_fres (void)
1750 {
1751 __asm__ __volatile__ ("fres 17, 14");
1752 }
1753
1754 static void test_frsqrte (void)
1755 {
1756 __asm__ __volatile__ ("frsqrte 17, 14");
1757 }
1758
1759 static void test_frsp (void)
1760 {
1761 __asm__ __volatile__ ("frsp 17, 14");
1762 }
1763
1764 static void test_fctiw (void)
1765 {
1766 __asm__ __volatile__ ("fctiw 17, 14");
1767 }
1768
1769 static void test_fctiwz (void)
1770 {
1771 __asm__ __volatile__ ("fctiwz 17, 14");
1772 }
1773
1774 static void test_fmr (void)
1775 {
1776 __asm__ __volatile__ ("fmr 17, 14");
1777 }
1778
1779 static void test_fneg (void)
1780 {
1781 __asm__ __volatile__ ("fneg 17, 14");
1782 }
1783
1784 static void test_fabs (void)
1785 {
1786 __asm__ __volatile__ ("fabs 17, 14");
1787 }
1788
1789 static void test_fnabs (void)
1790 {
1791 __asm__ __volatile__ ("fnabs 17, 14");
1792 }
1793
1794 static test_t tests_fa_ops_one[] = {
1795 { &test_fres , " fres", },
1796 { &test_frsqrte , " frsqrte", },
1797 { &test_frsp , " frsp", },
1798 { &test_fctiw , " fctiw", },
1799 { &test_fctiwz , " fctiwz", },
1800 { &test_fmr , " fmr", },
1801 { &test_fneg , " fneg", },
1802 { &test_fabs , " fabs", },
1803 { &test_fnabs , " fnabs", },
1804 { NULL, NULL, },
1805 };
1806 #endif /* !defined (NO_FLOAT) */
1807
1808 #if !defined (NO_FLOAT)
1809 static void test_fres_ (void)
1810 {
1811 __asm__ __volatile__ ("fres. 17, 14");
1812 }
1813
1814 static void test_frsqrte_ (void)
1815 {
1816 __asm__ __volatile__ ("frsqrte. 17, 14");
1817 }
1818
1819 static void test_frsp_ (void)
1820 {
1821 __asm__ __volatile__ ("frsp. 17, 14");
1822 }
1823
1824 static void test_fctiw_ (void)
1825 {
1826 __asm__ __volatile__ ("fctiw. 17, 14");
1827 }
1828
1829 static void test_fctiwz_ (void)
1830 {
1831 __asm__ __volatile__ ("fctiwz. 17, 14");
1832 }
1833
1834 static void test_fmr_ (void)
1835 {
1836 __asm__ __volatile__ ("fmr. 17, 14");
1837 }
1838
1839 static void test_fneg_ (void)
1840 {
1841 __asm__ __volatile__ ("fneg. 17, 14");
1842 }
1843
1844 static void test_fabs_ (void)
1845 {
1846 __asm__ __volatile__ ("fabs. 17, 14");
1847 }
1848
1849 static void test_fnabs_ (void)
1850 {
1851 __asm__ __volatile__ ("fnabs. 17, 14");
1852 }
1853
1854 static test_t tests_far_ops_one[] = {
1855 { &test_fres_ , " fres.", },
1856 { &test_frsqrte_ , " frsqrte.", },
1857 { &test_frsp_ , " frsp.", },
1858 { &test_fctiw_ , " fctiw.", },
1859 { &test_fctiwz_ , " fctiwz.", },
1860 { &test_fmr_ , " fmr.", },
1861 { &test_fneg_ , " fneg.", },
1862 { &test_fabs_ , " fabs.", },
1863 { &test_fnabs_ , " fnabs.", },
1864 { NULL, NULL, },
1865 };
1866 #endif /* !defined (NO_FLOAT) */
1867
1868 #if !defined (NO_FLOAT)
1869 static test_t tests_fl_ops_spe[] = {
1870 { NULL, NULL, },
1871 };
1872 #endif /* !defined (NO_FLOAT) */
1873
1874 #if !defined (NO_FLOAT)
1875 static test_t tests_flr_ops_spe[] = {
1876 { NULL, NULL, },
1877 };
1878 #endif /* !defined (NO_FLOAT) */
1879
1880 #if defined (HAS_ALTIVEC)
1881 static void test_vmhaddshs (void)
1882 {
1883 __asm__ __volatile__ ("vmhaddshs 17, 14, 15, 16");
1884 }
1885
1886 static void test_vmhraddshs (void)
1887 {
1888 __asm__ __volatile__ ("vmhraddshs 17, 14, 15, 16");
1889 }
1890
1891 static void test_vmladduhm (void)
1892 {
1893 __asm__ __volatile__ ("vmladduhm 17, 14, 15, 16");
1894 }
1895
1896 static void test_vmsumubm (void)
1897 {
1898 __asm__ __volatile__ ("vmsumubm 17, 14, 15, 16");
1899 }
1900
1901 static void test_vmsumuhm (void)
1902 {
1903 __asm__ __volatile__ ("vmsumuhm 17, 14, 15, 16");
1904 }
1905
1906 static void test_vmsumshs (void)
1907 {
1908 __asm__ __volatile__ ("vmsumshs 17, 14, 15, 16");
1909 }
1910
1911 static void test_vmsumuhs (void)
1912 {
1913 __asm__ __volatile__ ("vmsumuhs 17, 14, 15, 16");
1914 }
1915
1916 static void test_vmsummbm (void)
1917 {
1918 __asm__ __volatile__ ("vmsummbm 17, 14, 15, 16");
1919 }
1920
1921 static void test_vmsumshm (void)
1922 {
1923 __asm__ __volatile__ ("vmsumshm 17, 14, 15, 16");
1924 }
1925
1926 static test_t tests_aa_ops_three[] = {
1927 { &test_vmhaddshs , " vmhaddshs", },
1928 { &test_vmhraddshs , " vmhraddshs", },
1929 { &test_vmladduhm , " vmladduhm", },
1930 { &test_vmsumubm , " vmsumubm", },
1931 { &test_vmsumuhm , " vmsumuhm", },
1932 { &test_vmsumshs , " vmsumshs", },
1933 { &test_vmsumuhs , " vmsumuhs", },
1934 { &test_vmsummbm , " vmsummbm", },
1935 { &test_vmsumshm , " vmsumshm", },
1936 { NULL, NULL, },
1937 };
1938 #endif /* defined (HAS_ALTIVEC) */
1939
1940 #if defined (HAS_ALTIVEC)
1941 static void test_vperm (void)
1942 {
1943 __asm__ __volatile__ ("vperm 17, 14, 15, 16");
1944 }
1945
1946 static void test_vsel (void)
1947 {
1948 __asm__ __volatile__ ("vsel 17, 14, 15, 16");
1949 }
1950
1951 static test_t tests_al_ops_three[] = {
1952 { &test_vperm , " vperm", },
1953 { &test_vsel , " vsel", },
1954 { NULL, NULL, },
1955 };
1956 #endif /* defined (HAS_ALTIVEC) */
1957
1958 #if defined (HAS_ALTIVEC)
1959 static void test_vaddubm (void)
1960 {
1961 __asm__ __volatile__ ("vaddubm 17, 14, 15");
1962 }
1963
1964 static void test_vadduhm (void)
1965 {
1966 __asm__ __volatile__ ("vadduhm 17, 14, 15");
1967 }
1968
1969 static void test_vadduwm (void)
1970 {
1971 __asm__ __volatile__ ("vadduwm 17, 14, 15");
1972 }
1973
1974 static void test_vaddubs (void)
1975 {
1976 __asm__ __volatile__ ("vaddubs 17, 14, 15");
1977 }
1978
1979 static void test_vadduhs (void)
1980 {
1981 __asm__ __volatile__ ("vadduhs 17, 14, 15");
1982 }
1983
1984 static void test_vadduws (void)
1985 {
1986 __asm__ __volatile__ ("vadduws 17, 14, 15");
1987 }
1988
1989 static void test_vaddsbs (void)
1990 {
1991 __asm__ __volatile__ ("vaddsbs 17, 14, 15");
1992 }
1993
1994 static void test_vaddshs (void)
1995 {
1996 __asm__ __volatile__ ("vaddshs 17, 14, 15");
1997 }
1998
1999 static void test_vaddsws (void)
2000 {
2001 __asm__ __volatile__ ("vaddsws 17, 14, 15");
2002 }
2003
2004 static void test_vaddcuw (void)
2005 {
2006 __asm__ __volatile__ ("vaddcuw 17, 14, 15");
2007 }
2008
2009 static void test_vsububm (void)
2010 {
2011 __asm__ __volatile__ ("vsububm 17, 14, 15");
2012 }
2013
2014 static void test_vsubuhm (void)
2015 {
2016 __asm__ __volatile__ ("vsubuhm 17, 14, 15");
2017 }
2018
2019 static void test_vsubuwm (void)
2020 {
2021 __asm__ __volatile__ ("vsubuwm 17, 14, 15");
2022 }
2023
2024 static void test_vsububs (void)
2025 {
2026 __asm__ __volatile__ ("vsububs 17, 14, 15");
2027 }
2028
2029 static void test_vsubuhs (void)
2030 {
2031 __asm__ __volatile__ ("vsubuhs 17, 14, 15");
2032 }
2033
2034 static void test_vsubuws (void)
2035 {
2036 __asm__ __volatile__ ("vsubuws 17, 14, 15");
2037 }
2038
2039 static void test_vsubcuw (void)
2040 {
2041 __asm__ __volatile__ ("vsubcuw 17, 14, 15");
2042 }
2043
2044 static void test_vmuloub (void)
2045 {
2046 __asm__ __volatile__ ("vmuloub 17, 14, 15");
2047 }
2048
2049 static void test_vmulouh (void)
2050 {
2051 __asm__ __volatile__ ("vmulouh 17, 14, 15");
2052 }
2053
2054 static void test_vmulosb (void)
2055 {
2056 __asm__ __volatile__ ("vmulosb 17, 14, 15");
2057 }
2058
2059 static void test_vmulosh (void)
2060 {
2061 __asm__ __volatile__ ("vmulosh 17, 14, 15");
2062 }
2063
2064 static void test_vmuleub (void)
2065 {
2066 __asm__ __volatile__ ("vmuleub 17, 14, 15");
2067 }
2068
2069 static void test_vmuleuh (void)
2070 {
2071 __asm__ __volatile__ ("vmuleuh 17, 14, 15");
2072 }
2073
2074 static void test_vmulesb (void)
2075 {
2076 __asm__ __volatile__ ("vmulesb 17, 14, 15");
2077 }
2078
2079 static void test_vmulesh (void)
2080 {
2081 __asm__ __volatile__ ("vmulesh 17, 14, 15");
2082 }
2083
2084 static void test_vsumsws (void)
2085 {
2086 __asm__ __volatile__ ("vsumsws 17, 14, 15");
2087 }
2088
2089 static void test_vsum2sws (void)
2090 {
2091 __asm__ __volatile__ ("vsum2sws 17, 14, 15");
2092 }
2093
2094 static void test_vsum4ubs (void)
2095 {
2096 __asm__ __volatile__ ("vsum4ubs 17, 14, 15");
2097 }
2098
2099 static void test_vsum4sbs (void)
2100 {
2101 __asm__ __volatile__ ("vsum4sbs 17, 14, 15");
2102 }
2103
2104 static void test_vsum4shs (void)
2105 {
2106 __asm__ __volatile__ ("vsum4shs 17, 14, 15");
2107 }
2108
2109 static void test_vavgub (void)
2110 {
2111 __asm__ __volatile__ ("vavgub 17, 14, 15");
2112 }
2113
2114 static void test_vavguh (void)
2115 {
2116 __asm__ __volatile__ ("vavguh 17, 14, 15");
2117 }
2118
2119 static void test_vavguw (void)
2120 {
2121 __asm__ __volatile__ ("vavguw 17, 14, 15");
2122 }
2123
2124 static void test_vavgsb (void)
2125 {
2126 __asm__ __volatile__ ("vavgsb 17, 14, 15");
2127 }
2128
2129 static void test_vavgsh (void)
2130 {
2131 __asm__ __volatile__ ("vavgsh 17, 14, 15");
2132 }
2133
2134 static void test_vavgsw (void)
2135 {
2136 __asm__ __volatile__ ("vavgsw 17, 14, 15");
2137 }
2138
2139 static void test_vmaxub (void)
2140 {
2141 __asm__ __volatile__ ("vmaxub 17, 14, 15");
2142 }
2143
2144 static void test_vmaxuh (void)
2145 {
2146 __asm__ __volatile__ ("vmaxuh 17, 14, 15");
2147 }
2148
2149 static void test_vmaxuw (void)
2150 {
2151 __asm__ __volatile__ ("vmaxuw 17, 14, 15");
2152 }
2153
2154 static void test_vmaxsb (void)
2155 {
2156 __asm__ __volatile__ ("vmaxsb 17, 14, 15");
2157 }
2158
2159 static void test_vmaxsh (void)
2160 {
2161 __asm__ __volatile__ ("vmaxsh 17, 14, 15");
2162 }
2163
2164 static void test_vmaxsw (void)
2165 {
2166 __asm__ __volatile__ ("vmaxsw 17, 14, 15");
2167 }
2168
2169 static void test_vminub (void)
2170 {
2171 __asm__ __volatile__ ("vminub 17, 14, 15");
2172 }
2173
2174 static void test_vminuh (void)
2175 {
2176 __asm__ __volatile__ ("vminuh 17, 14, 15");
2177 }
2178
2179 static void test_vminuw (void)
2180 {
2181 __asm__ __volatile__ ("vminuw 17, 14, 15");
2182 }
2183
2184 static void test_vminsb (void)
2185 {
2186 __asm__ __volatile__ ("vminsb 17, 14, 15");
2187 }
2188
2189 static void test_vminsh (void)
2190 {
2191 __asm__ __volatile__ ("vminsh 17, 14, 15");
2192 }
2193
2194 static void test_vminsw (void)
2195 {
2196 __asm__ __volatile__ ("vminsw 17, 14, 15");
2197 }
2198
2199 static test_t tests_aa_ops_two[] = {
2200 { &test_vaddubm , " vaddubm", },
2201 { &test_vadduhm , " vadduhm", },
2202 { &test_vadduwm , " vadduwm", },
2203 { &test_vaddubs , " vaddubs", },
2204 { &test_vadduhs , " vadduhs", },
2205 { &test_vadduws , " vadduws", },
2206 { &test_vaddsbs , " vaddsbs", },
2207 { &test_vaddshs , " vaddshs", },
2208 { &test_vaddsws , " vaddsws", },
2209 { &test_vaddcuw , " vaddcuw", },
2210 { &test_vsububm , " vsububm", },
2211 { &test_vsubuhm , " vsubuhm", },
2212 { &test_vsubuwm , " vsubuwm", },
2213 { &test_vsububs , " vsububs", },
2214 { &test_vsubuhs , " vsubuhs", },
2215 { &test_vsubuws , " vsubuws", },
2216 { &test_vsubcuw , " vsubcuw", },
2217 { &test_vmuloub , " vmuloub", },
2218 { &test_vmulouh , " vmulouh", },
2219 { &test_vmulosb , " vmulosb", },
2220 { &test_vmulosh , " vmulosh", },
2221 { &test_vmuleub , " vmuleub", },
2222 { &test_vmuleuh , " vmuleuh", },
2223 { &test_vmulesb , " vmulesb", },
2224 { &test_vmulesh , " vmulesh", },
2225 { &test_vsumsws , " vsumsws", },
2226 { &test_vsum2sws , " vsum2sws", },
2227 { &test_vsum4ubs , " vsum4ubs", },
2228 { &test_vsum4sbs , " vsum4sbs", },
2229 { &test_vsum4shs , " vsum4shs", },
2230 { &test_vavgub , " vavgub", },
2231 { &test_vavguh , " vavguh", },
2232 { &test_vavguw , " vavguw", },
2233 { &test_vavgsb , " vavgsb", },
2234 { &test_vavgsh , " vavgsh", },
2235 { &test_vavgsw , " vavgsw", },
2236 { &test_vmaxub , " vmaxub", },
2237 { &test_vmaxuh , " vmaxuh", },
2238 { &test_vmaxuw , " vmaxuw", },
2239 { &test_vmaxsb , " vmaxsb", },
2240 { &test_vmaxsh , " vmaxsh", },
2241 { &test_vmaxsw , " vmaxsw", },
2242 { &test_vminub , " vminub", },
2243 { &test_vminuh , " vminuh", },
2244 { &test_vminuw , " vminuw", },
2245 { &test_vminsb , " vminsb", },
2246 { &test_vminsh , " vminsh", },
2247 { &test_vminsw , " vminsw", },
2248 { NULL, NULL, },
2249 };
2250 #endif /* defined (HAS_ALTIVEC) */
2251
2252 #if defined (HAS_ALTIVEC)
2253 static void test_vand (void)
2254 {
2255 __asm__ __volatile__ ("vand 17, 14, 15");
2256 }
2257
2258 static void test_vor (void)
2259 {
2260 __asm__ __volatile__ ("vor 17, 14, 15");
2261 }
2262
2263 static void test_vxor (void)
2264 {
2265 __asm__ __volatile__ ("vxor 17, 14, 15");
2266 }
2267
2268 static void test_vandc (void)
2269 {
2270 __asm__ __volatile__ ("vandc 17, 14, 15");
2271 }
2272
2273 static void test_vnor (void)
2274 {
2275 __asm__ __volatile__ ("vnor 17, 14, 15");
2276 }
2277
2278 static void test_vrlb (void)
2279 {
2280 __asm__ __volatile__ ("vrlb 17, 14, 15");
2281 }
2282
2283 static void test_vrlh (void)
2284 {
2285 __asm__ __volatile__ ("vrlh 17, 14, 15");
2286 }
2287
2288 static void test_vrlw (void)
2289 {
2290 __asm__ __volatile__ ("vrlw 17, 14, 15");
2291 }
2292
2293 static void test_vslb (void)
2294 {
2295 __asm__ __volatile__ ("vslb 17, 14, 15");
2296 }
2297
2298 static void test_vslh (void)
2299 {
2300 __asm__ __volatile__ ("vslh 17, 14, 15");
2301 }
2302
2303 static void test_vslw (void)
2304 {
2305 __asm__ __volatile__ ("vslw 17, 14, 15");
2306 }
2307
2308 static void test_vsrb (void)
2309 {
2310 __asm__ __volatile__ ("vsrb 17, 14, 15");
2311 }
2312
2313 static void test_vsrh (void)
2314 {
2315 __asm__ __volatile__ ("vsrh 17, 14, 15");
2316 }
2317
2318 static void test_vsrw (void)
2319 {
2320 __asm__ __volatile__ ("vsrw 17, 14, 15");
2321 }
2322
2323 static void test_vsrab (void)
2324 {
2325 __asm__ __volatile__ ("vsrab 17, 14, 15");
2326 }
2327
2328 static void test_vsrah (void)
2329 {
2330 __asm__ __volatile__ ("vsrah 17, 14, 15");
2331 }
2332
2333 static void test_vsraw (void)
2334 {
2335 __asm__ __volatile__ ("vsraw 17, 14, 15");
2336 }
2337
2338 static void test_vpkuhum (void)
2339 {
2340 __asm__ __volatile__ ("vpkuhum 17, 14, 15");
2341 }
2342
2343 static void test_vpkuwum (void)
2344 {
2345 __asm__ __volatile__ ("vpkuwum 17, 14, 15");
2346 }
2347
2348 static void test_vpkuhus (void)
2349 {
2350 __asm__ __volatile__ ("vpkuhus 17, 14, 15");
2351 }
2352
2353 static void test_vpkuwus (void)
2354 {
2355 __asm__ __volatile__ ("vpkuwus 17, 14, 15");
2356 }
2357
2358 static void test_vpkshus (void)
2359 {
2360 __asm__ __volatile__ ("vpkshus 17, 14, 15");
2361 }
2362
2363 static void test_vpkswus (void)
2364 {
2365 __asm__ __volatile__ ("vpkswus 17, 14, 15");
2366 }
2367
2368 static void test_vpkshss (void)
2369 {
2370 __asm__ __volatile__ ("vpkshss 17, 14, 15");
2371 }
2372
2373 static void test_vpkswss (void)
2374 {
2375 __asm__ __volatile__ ("vpkswss 17, 14, 15");
2376 }
2377
2378 static void test_vpkpx (void)
2379 {
2380 __asm__ __volatile__ ("vpkpx 17, 14, 15");
2381 }
2382
2383 static void test_vmrghb (void)
2384 {
2385 __asm__ __volatile__ ("vmrghb 17, 14, 15");
2386 }
2387
2388 static void test_vmrghh (void)
2389 {
2390 __asm__ __volatile__ ("vmrghh 17, 14, 15");
2391 }
2392
2393 static void test_vmrghw (void)
2394 {
2395 __asm__ __volatile__ ("vmrghw 17, 14, 15");
2396 }
2397
2398 static void test_vmrglb (void)
2399 {
2400 __asm__ __volatile__ ("vmrglb 17, 14, 15");
2401 }
2402
2403 static void test_vmrglh (void)
2404 {
2405 __asm__ __volatile__ ("vmrglh 17, 14, 15");
2406 }
2407
2408 static void test_vmrglw (void)
2409 {
2410 __asm__ __volatile__ ("vmrglw 17, 14, 15");
2411 }
2412
2413 static void test_vsl (void)
2414 {
2415 __asm__ __volatile__ ("vsl 17, 14, 15");
2416 }
2417
2418 static void test_vsr (void)
2419 {
2420 __asm__ __volatile__ ("vsr 17, 14, 15");
2421 }
2422
2423 static void test_vslo (void)
2424 {
2425 __asm__ __volatile__ ("vslo 17, 14, 15");
2426 }
2427
2428 static void test_vsro (void)
2429 {
2430 __asm__ __volatile__ ("vsro 17, 14, 15");
2431 }
2432
2433 static test_t tests_al_ops_two[] = {
2434 { &test_vand , " vand", },
2435 { &test_vor , " vor", },
2436 { &test_vxor , " vxor", },
2437 { &test_vandc , " vandc", },
2438 { &test_vnor , " vnor", },
2439 { &test_vrlb , " vrlb", },
2440 { &test_vrlh , " vrlh", },
2441 { &test_vrlw , " vrlw", },
2442 { &test_vslb , " vslb", },
2443 { &test_vslh , " vslh", },
2444 { &test_vslw , " vslw", },
2445 { &test_vsrb , " vsrb", },
2446 { &test_vsrh , " vsrh", },
2447 { &test_vsrw , " vsrw", },
2448 { &test_vsrab , " vsrab", },
2449 { &test_vsrah , " vsrah", },
2450 { &test_vsraw , " vsraw", },
2451 { &test_vpkuhum , " vpkuhum", },
2452 { &test_vpkuwum , " vpkuwum", },
2453 { &test_vpkuhus , " vpkuhus", },
2454 { &test_vpkuwus , " vpkuwus", },
2455 { &test_vpkshus , " vpkshus", },
2456 { &test_vpkswus , " vpkswus", },
2457 { &test_vpkshss , " vpkshss", },
2458 { &test_vpkswss , " vpkswss", },
2459 { &test_vpkpx , " vpkpx", },
2460 { &test_vmrghb , " vmrghb", },
2461 { &test_vmrghh , " vmrghh", },
2462 { &test_vmrghw , " vmrghw", },
2463 { &test_vmrglb , " vmrglb", },
2464 { &test_vmrglh , " vmrglh", },
2465 { &test_vmrglw , " vmrglw", },
2466 { &test_vsl , " vsl", },
2467 { &test_vsr , " vsr", },
2468 { &test_vslo , " vslo", },
2469 { &test_vsro , " vsro", },
2470 { NULL, NULL, },
2471 };
2472 #endif /* defined (HAS_ALTIVEC) */
2473
2474 #if defined (HAS_ALTIVEC)
2475 static void test_vupkhsb (void)
2476 {
2477 __asm__ __volatile__ ("vupkhsb 17, 14");
2478 }
2479
2480 static void test_vupkhsh (void)
2481 {
2482 __asm__ __volatile__ ("vupkhsh 17, 14");
2483 }
2484
2485 static void test_vupkhpx (void)
2486 {
2487 __asm__ __volatile__ ("vupkhpx 17, 14");
2488 }
2489
2490 static void test_vupklsb (void)
2491 {
2492 __asm__ __volatile__ ("vupklsb 17, 14");
2493 }
2494
2495 static void test_vupklsh (void)
2496 {
2497 __asm__ __volatile__ ("vupklsh 17, 14");
2498 }
2499
2500 static void test_vupklpx (void)
2501 {
2502 __asm__ __volatile__ ("vupklpx 17, 14");
2503 }
2504
2505 static test_t tests_al_ops_one[] = {
2506 { &test_vupkhsb , " vupkhsb", },
2507 { &test_vupkhsh , " vupkhsh", },
2508 { &test_vupkhpx , " vupkhpx", },
2509 { &test_vupklsb , " vupklsb", },
2510 { &test_vupklsh , " vupklsh", },
2511 { &test_vupklpx , " vupklpx", },
2512 { NULL, NULL, },
2513 };
2514 #endif /* defined (HAS_ALTIVEC) */
2515
2516 #if defined (HAS_ALTIVEC)
2517 static void test_vcmpgtub (void)
2518 {
2519 __asm__ __volatile__ ("vcmpgtub 17, 14, 15");
2520 }
2521
2522 static void test_vcmpgtuh (void)
2523 {
2524 __asm__ __volatile__ ("vcmpgtuh 17, 14, 15");
2525 }
2526
2527 static void test_vcmpgtuw (void)
2528 {
2529 __asm__ __volatile__ ("vcmpgtuw 17, 14, 15");
2530 }
2531
2532 static void test_vcmpgtsb (void)
2533 {
2534 __asm__ __volatile__ ("vcmpgtsb 17, 14, 15");
2535 }
2536
2537 static void test_vcmpgtsh (void)
2538 {
2539 __asm__ __volatile__ ("vcmpgtsh 17, 14, 15");
2540 }
2541
2542 static void test_vcmpgtsw (void)
2543 {
2544 __asm__ __volatile__ ("vcmpgtsw 17, 14, 15");
2545 }
2546
2547 static void test_vcmpequb (void)
2548 {
2549 __asm__ __volatile__ ("vcmpequb 17, 14, 15");
2550 }
2551
2552 static void test_vcmpequh (void)
2553 {
2554 __asm__ __volatile__ ("vcmpequh 17, 14, 15");
2555 }
2556
2557 static void test_vcmpequw (void)
2558 {
2559 __asm__ __volatile__ ("vcmpequw 17, 14, 15");
2560 }
2561
2562 static test_t tests_ac_ops_two[] = {
2563 { &test_vcmpgtub , " vcmpgtub", },
2564 { &test_vcmpgtuh , " vcmpgtuh", },
2565 { &test_vcmpgtuw , " vcmpgtuw", },
2566 { &test_vcmpgtsb , " vcmpgtsb", },
2567 { &test_vcmpgtsh , " vcmpgtsh", },
2568 { &test_vcmpgtsw , " vcmpgtsw", },
2569 { &test_vcmpequb , " vcmpequb", },
2570 { &test_vcmpequh , " vcmpequh", },
2571 { &test_vcmpequw , " vcmpequw", },
2572 { NULL, NULL, },
2573 };
2574 #endif /* defined (HAS_ALTIVEC) */
2575
2576 #if defined (HAS_ALTIVEC)
2577 static void test_vcmpgtub_ (void)
2578 {
2579 __asm__ __volatile__ ("vcmpgtub. 17, 14, 15");
2580 }
2581
2582 static void test_vcmpgtuh_ (void)
2583 {
2584 __asm__ __volatile__ ("vcmpgtuh. 17, 14, 15");
2585 }
2586
2587 static void test_vcmpgtuw_ (void)
2588 {
2589 __asm__ __volatile__ ("vcmpgtuw. 17, 14, 15");
2590 }
2591
2592 static void test_vcmpgtsb_ (void)
2593 {
2594 __asm__ __volatile__ ("vcmpgtsb. 17, 14, 15");
2595 }
2596
2597 static void test_vcmpgtsh_ (void)
2598 {
2599 __asm__ __volatile__ ("vcmpgtsh. 17, 14, 15");
2600 }
2601
2602 static void test_vcmpgtsw_ (void)
2603 {
2604 __asm__ __volatile__ ("vcmpgtsw. 17, 14, 15");
2605 }
2606
2607 static void test_vcmpequb_ (void)
2608 {
2609 __asm__ __volatile__ ("vcmpequb. 17, 14, 15");
2610 }
2611
2612 static void test_vcmpequh_ (void)
2613 {
2614 __asm__ __volatile__ ("vcmpequh. 17, 14, 15");
2615 }
2616
2617 static void test_vcmpequw_ (void)
2618 {
2619 __asm__ __volatile__ ("vcmpequw. 17, 14, 15");
2620 }
2621
2622 static test_t tests_acr_ops_two[] = {
2623 { &test_vcmpgtub_ , " vcmpgtub.", },
2624 { &test_vcmpgtuh_ , " vcmpgtuh.", },
2625 { &test_vcmpgtuw_ , " vcmpgtuw.", },
2626 { &test_vcmpgtsb_ , " vcmpgtsb.", },
2627 { &test_vcmpgtsh_ , " vcmpgtsh.", },
2628 { &test_vcmpgtsw_ , " vcmpgtsw.", },
2629 { &test_vcmpequb_ , " vcmpequb.", },
2630 { &test_vcmpequh_ , " vcmpequh.", },
2631 { &test_vcmpequw_ , " vcmpequw.", },
2632 { NULL, NULL, },
2633 };
2634 #endif /* defined (HAS_ALTIVEC) */
2635
2636 #if defined (HAS_ALTIVEC)
2637 static void test_vmaddfp (void)
2638 {
2639 __asm__ __volatile__ ("vmaddfp 17, 14, 15, 16");
2640 }
2641
2642 static void test_vnmsubfp (void)
2643 {
2644 __asm__ __volatile__ ("vnmsubfp 17, 14, 15, 16");
2645 }
2646
2647 static test_t tests_afa_ops_three[] = {
2648 { &test_vmaddfp , " vmaddfp", },
2649 { &test_vnmsubfp , " vnmsubfp", },
2650 { NULL, NULL, },
2651 };
2652 #endif /* defined (HAS_ALTIVEC) */
2653
2654 #if defined (HAS_ALTIVEC)
2655 static void test_vaddfp (void)
2656 {
2657 __asm__ __volatile__ ("vaddfp 17, 14, 15");
2658 }
2659
2660 static void test_vsubfp (void)
2661 {
2662 __asm__ __volatile__ ("vsubfp 17, 14, 15");
2663 }
2664
2665 static void test_vmaxfp (void)
2666 {
2667 __asm__ __volatile__ ("vmaxfp 17, 14, 15");
2668 }
2669
2670 static void test_vminfp (void)
2671 {
2672 __asm__ __volatile__ ("vminfp 17, 14, 15");
2673 }
2674
2675 static test_t tests_afa_ops_two[] = {
2676 { &test_vaddfp , " vaddfp", },
2677 { &test_vsubfp , " vsubfp", },
2678 { &test_vmaxfp , " vmaxfp", },
2679 { &test_vminfp , " vminfp", },
2680 { NULL, NULL, },
2681 };
2682 #endif /* defined (HAS_ALTIVEC) */
2683
2684 #if defined (HAS_ALTIVEC)
2685 static void test_vrfin (void)
2686 {
2687 __asm__ __volatile__ ("vrfin 17, 14");
2688 }
2689
2690 static void test_vrfiz (void)
2691 {
2692 __asm__ __volatile__ ("vrfiz 17, 14");
2693 }
2694
2695 static void test_vrfip (void)
2696 {
2697 __asm__ __volatile__ ("vrfip 17, 14");
2698 }
2699
2700 static void test_vrfim (void)
2701 {
2702 __asm__ __volatile__ ("vrfim 17, 14");
2703 }
2704
2705 static void test_vrefp (void)
2706 {
2707 __asm__ __volatile__ ("vrefp 17, 14");
2708 }
2709
2710 static void test_vrsqrtefp (void)
2711 {
2712 __asm__ __volatile__ ("vrsqrtefp 17, 14");
2713 }
2714
2715 static void test_vlogefp (void)
2716 {
2717 __asm__ __volatile__ ("vlogefp 17, 14");
2718 }
2719
2720 static void test_vexptefp (void)
2721 {
2722 __asm__ __volatile__ ("vexptefp 17, 14");
2723 }
2724
2725 static test_t tests_afa_ops_one[] = {
2726 { &test_vrfin , " vrfin", },
2727 { &test_vrfiz , " vrfiz", },
2728 { &test_vrfip , " vrfip", },
2729 { &test_vrfim , " vrfim", },
2730 { &test_vrefp , " vrefp", },
2731 { &test_vrsqrtefp , " vrsqrtefp", },
2732 { &test_vlogefp , " vlogefp", },
2733 { &test_vexptefp , " vexptefp", },
2734 { NULL, NULL, },
2735 };
2736 #endif /* defined (HAS_ALTIVEC) */
2737
2738 #if defined (HAS_ALTIVEC)
2739 static void test_vcmpgtfp (void)
2740 {
2741 __asm__ __volatile__ ("vcmpgtfp 17, 14, 15");
2742 }
2743
2744 static void test_vcmpeqfp (void)
2745 {
2746 __asm__ __volatile__ ("vcmpeqfp 17, 14, 15");
2747 }
2748
2749 static void test_vcmpgefp (void)
2750 {
2751 __asm__ __volatile__ ("vcmpgefp 17, 14, 15");
2752 }
2753
2754 static void test_vcmpbfp (void)
2755 {
2756 __asm__ __volatile__ ("vcmpbfp 17, 14, 15");
2757 }
2758
2759 static test_t tests_afc_ops_two[] = {
2760 { &test_vcmpgtfp , " vcmpgtfp", },
2761 { &test_vcmpeqfp , " vcmpeqfp", },
2762 { &test_vcmpgefp , " vcmpgefp", },
2763 { &test_vcmpbfp , " vcmpbfp", },
2764 { NULL, NULL, },
2765 };
2766 #endif /* defined (HAS_ALTIVEC) */
2767
2768 #if defined (HAS_ALTIVEC)
2769 static void test_vcmpgtfp_ (void)
2770 {
2771 __asm__ __volatile__ ("vcmpgtfp. 17, 14, 15");
2772 }
2773
2774 static void test_vcmpeqfp_ (void)
2775 {
2776 __asm__ __volatile__ ("vcmpeqfp. 17, 14, 15");
2777 }
2778
2779 static void test_vcmpgefp_ (void)
2780 {
2781 __asm__ __volatile__ ("vcmpgefp. 17, 14, 15");
2782 }
2783
2784 static void test_vcmpbfp_ (void)
2785 {
2786 __asm__ __volatile__ ("vcmpbfp. 17, 14, 15");
2787 }
2788
2789 static test_t tests_afcr_ops_two[] = {
2790 { &test_vcmpgtfp_ , " vcmpgtfp.", },
2791 { &test_vcmpeqfp_ , " vcmpeqfp.", },
2792 { &test_vcmpgefp_ , " vcmpgefp.", },
2793 { &test_vcmpbfp_ , " vcmpbfp.", },
2794 { NULL, NULL, },
2795 };
2796 #endif /* defined (HAS_ALTIVEC) */
2797
2798 #if defined (IS_PPC405)
2799 static void test_macchw (void)
2800 {
2801 __asm__ __volatile__ ("macchw 17, 14, 15");
2802 }
2803
2804 static void test_macchwo (void)
2805 {
2806 __asm__ __volatile__ ("macchwo 17, 14, 15");
2807 }
2808
2809 static void test_macchws (void)
2810 {
2811 __asm__ __volatile__ ("macchws 17, 14, 15");
2812 }
2813
2814 static void test_macchwso (void)
2815 {
2816 __asm__ __volatile__ ("macchwso 17, 14, 15");
2817 }
2818
2819 static void test_macchwsu (void)
2820 {
2821 __asm__ __volatile__ ("macchwsu 17, 14, 15");
2822 }
2823
2824 static void test_macchwsuo (void)
2825 {
2826 __asm__ __volatile__ ("macchwsuo 17, 14, 15");
2827 }
2828
2829 static void test_macchwu (void)
2830 {
2831 __asm__ __volatile__ ("macchwu 17, 14, 15");
2832 }
2833
2834 static void test_macchwuo (void)
2835 {
2836 __asm__ __volatile__ ("macchwuo 17, 14, 15");
2837 }
2838
2839 static void test_machhw (void)
2840 {
2841 __asm__ __volatile__ ("machhw 17, 14, 15");
2842 }
2843
2844 static void test_machhwo (void)
2845 {
2846 __asm__ __volatile__ ("machhwo 17, 14, 15");
2847 }
2848
2849 static void test_machhws (void)
2850 {
2851 __asm__ __volatile__ ("machhws 17, 14, 15");
2852 }
2853
2854 static void test_machhwso (void)
2855 {
2856 __asm__ __volatile__ ("machhwso 17, 14, 15");
2857 }
2858
2859 static void test_machhwsu (void)
2860 {
2861 __asm__ __volatile__ ("machhwsu 17, 14, 15");
2862 }
2863
2864 static void test_machhwsuo (void)
2865 {
2866 __asm__ __volatile__ ("machhwsuo 17, 14, 15");
2867 }
2868
2869 static void test_machhwu (void)
2870 {
2871 __asm__ __volatile__ ("machhwu 17, 14, 15");
2872 }
2873
2874 static void test_machhwuo (void)
2875 {
2876 __asm__ __volatile__ ("machhwuo 17, 14, 15");
2877 }
2878
2879 static void test_maclhw (void)
2880 {
2881 __asm__ __volatile__ ("maclhw 17, 14, 15");
2882 }
2883
2884 static void test_maclhwo (void)
2885 {
2886 __asm__ __volatile__ ("maclhwo 17, 14, 15");
2887 }
2888
2889 static void test_maclhws (void)
2890 {
2891 __asm__ __volatile__ ("maclhws 17, 14, 15");
2892 }
2893
2894 static void test_maclhwso (void)
2895 {
2896 __asm__ __volatile__ ("maclhwso 17, 14, 15");
2897 }
2898
2899 static void test_maclhwsu (void)
2900 {
2901 __asm__ __volatile__ ("maclhwsu 17, 14, 15");
2902 }
2903
2904 static void test_maclhwsuo (void)
2905 {
2906 __asm__ __volatile__ ("maclhwsuo 17, 14, 15");
2907 }
2908
2909 static void test_maclhwu (void)
2910 {
2911 __asm__ __volatile__ ("maclhwu 17, 14, 15");
2912 }
2913
2914 static void test_maclhwuo (void)
2915 {
2916 __asm__ __volatile__ ("maclhwuo 17, 14, 15");
2917 }
2918
2919 static void test_mulchw (void)
2920 {
2921 __asm__ __volatile__ ("mulchw 17, 14, 15");
2922 }
2923
2924 static void test_mulchwu (void)
2925 {
2926 __asm__ __volatile__ ("mulchwu 17, 14, 15");
2927 }
2928
2929 static void test_mulhhw (void)
2930 {
2931 __asm__ __volatile__ ("mulhhw 17, 14, 15");
2932 }
2933
2934 static void test_mulhhwu (void)
2935 {
2936 __asm__ __volatile__ ("mulhhwu 17, 14, 15");
2937 }
2938
2939 static void test_mullhw (void)
2940 {
2941 __asm__ __volatile__ ("mullhw 17, 14, 15");
2942 }
2943
2944 static void test_mullhwu (void)
2945 {
2946 __asm__ __volatile__ ("mullhwu 17, 14, 15");
2947 }
2948
2949 static void test_nmacchw (void)
2950 {
2951 __asm__ __volatile__ ("nmacchw 17, 14, 15");
2952 }
2953
2954 static void test_nmacchwo (void)
2955 {
2956 __asm__ __volatile__ ("nmacchwo 17, 14, 15");
2957 }
2958
2959 static void test_nmacchws (void)
2960 {
2961 __asm__ __volatile__ ("nmacchws 17, 14, 15");
2962 }
2963
2964 static void test_nmacchwso (void)
2965 {
2966 __asm__ __volatile__ ("nmacchwso 17, 14, 15");
2967 }
2968
2969 static void test_nmachhw (void)
2970 {
2971 __asm__ __volatile__ ("nmachhw 17, 14, 15");
2972 }
2973
2974 static void test_nmachhwo (void)
2975 {
2976 __asm__ __volatile__ ("nmachhwo 17, 14, 15");
2977 }
2978
2979 static void test_nmachhws (void)
2980 {
2981 __asm__ __volatile__ ("nmachhws 17, 14, 15");
2982 }
2983
2984 static void test_nmachhwso (void)
2985 {
2986 __asm__ __volatile__ ("nmachhwso 17, 14, 15");
2987 }
2988
2989 static void test_nmaclhw (void)
2990 {
2991 __asm__ __volatile__ ("nmaclhw 17, 14, 15");
2992 }
2993
2994 static void test_nmaclhwo (void)
2995 {
2996 __asm__ __volatile__ ("nmaclhwo 17, 14, 15");
2997 }
2998
2999 static void test_nmaclhws (void)
3000 {
3001 __asm__ __volatile__ ("nmaclhws 17, 14, 15");
3002 }
3003
3004 static void test_nmaclhwso (void)
3005 {
3006 __asm__ __volatile__ ("nmaclhwso 17, 14, 15");
3007 }
3008
3009 static test_t tests_p4m_ops_two[] = {
3010 { &test_macchw , " macchw", },
3011 { &test_macchwo , " macchwo", },
3012 { &test_macchws , " macchws", },
3013 { &test_macchwso , " macchwso", },
3014 { &test_macchwsu , " macchwsu", },
3015 { &test_macchwsuo , " macchwsuo", },
3016 { &test_macchwu , " macchwu", },
3017 { &test_macchwuo , " macchwuo", },
3018 { &test_machhw , " machhw", },
3019 { &test_machhwo , " machhwo", },
3020 { &test_machhws , " machhws", },
3021 { &test_machhwso , " machhwso", },
3022 { &test_machhwsu , " machhwsu", },
3023 { &test_machhwsuo , " machhwsuo", },
3024 { &test_machhwu , " machhwu", },
3025 { &test_machhwuo , " machhwuo", },
3026 { &test_maclhw , " maclhw", },
3027 { &test_maclhwo , " maclhwo", },
3028 { &test_maclhws , " maclhws", },
3029 { &test_maclhwso , " maclhwso", },
3030 { &test_maclhwsu , " maclhwsu", },
3031 { &test_maclhwsuo , " maclhwsuo", },
3032 { &test_maclhwu , " maclhwu", },
3033 { &test_maclhwuo , " maclhwuo", },
3034 { &test_mulchw , " mulchw", },
3035 { &test_mulchwu , " mulchwu", },
3036 { &test_mulhhw , " mulhhw", },
3037 { &test_mulhhwu , " mulhhwu", },
3038 { &test_mullhw , " mullhw", },
3039 { &test_mullhwu , " mullhwu", },
3040 { &test_nmacchw , " nmacchw", },
3041 { &test_nmacchwo , " nmacchwo", },
3042 { &test_nmacchws , " nmacchws", },
3043 { &test_nmacchwso , " nmacchwso", },
3044 { &test_nmachhw , " nmachhw", },
3045 { &test_nmachhwo , " nmachhwo", },
3046 { &test_nmachhws , " nmachhws", },
3047 { &test_nmachhwso , " nmachhwso", },
3048 { &test_nmaclhw , " nmaclhw", },
3049 { &test_nmaclhwo , " nmaclhwo", },
3050 { &test_nmaclhws , " nmaclhws", },
3051 { &test_nmaclhwso , " nmaclhwso", },
3052 { NULL, NULL, },
3053 };
3054 #endif /* defined (IS_PPC405) */
3055
3056 #if defined (IS_PPC405)
3057 static void test_macchw_ (void)
3058 {
3059 __asm__ __volatile__ ("macchw. 17, 14, 15");
3060 }
3061
3062 static void test_macchwo_ (void)
3063 {
3064 __asm__ __volatile__ ("macchwo. 17, 14, 15");
3065 }
3066
3067 static void test_macchws_ (void)
3068 {
3069 __asm__ __volatile__ ("macchws. 17, 14, 15");
3070 }
3071
3072 static void test_macchwso_ (void)
3073 {
3074 __asm__ __volatile__ ("macchwso. 17, 14, 15");
3075 }
3076
3077 static void test_macchwsu_ (void)
3078 {
3079 __asm__ __volatile__ ("macchwsu. 17, 14, 15");
3080 }
3081
3082 static void test_macchwsuo_ (void)
3083 {
3084 __asm__ __volatile__ ("macchwsuo. 17, 14, 15");
3085 }
3086
3087 static void test_macchwu_ (void)
3088 {
3089 __asm__ __volatile__ ("macchwu. 17, 14, 15");
3090 }
3091
3092 static void test_macchwuo_ (void)
3093 {
3094 __asm__ __volatile__ ("macchwuo. 17, 14, 15");
3095 }
3096
3097 static void test_machhw_ (void)
3098 {
3099 __asm__ __volatile__ ("machhw. 17, 14, 15");
3100 }
3101
3102 static void test_machhwo_ (void)
3103 {
3104 __asm__ __volatile__ ("machhwo. 17, 14, 15");
3105 }
3106
3107 static void test_machhws_ (void)
3108 {
3109 __asm__ __volatile__ ("machhws. 17, 14, 15");
3110 }
3111
3112 static void test_machhwso_ (void)
3113 {
3114 __asm__ __volatile__ ("machhwso. 17, 14, 15");
3115 }
3116
3117 static void test_machhwsu_ (void)
3118 {
3119 __asm__ __volatile__ ("machhwsu. 17, 14, 15");
3120 }
3121
3122 static void test_machhwsuo_ (void)
3123 {
3124 __asm__ __volatile__ ("machhwsuo. 17, 14, 15");
3125 }
3126
3127 static void test_machhwu_ (void)
3128 {
3129 __asm__ __volatile__ ("machhwu. 17, 14, 15");
3130 }
3131
3132 static void test_machhwuo_ (void)
3133 {
3134 __asm__ __volatile__ ("machhwuo. 17, 14, 15");
3135 }
3136
3137 static void test_maclhw_ (void)
3138 {
3139 __asm__ __volatile__ ("maclhw. 17, 14, 15");
3140 }
3141
3142 static void test_maclhwo_ (void)
3143 {
3144 __asm__ __volatile__ ("maclhwo. 17, 14, 15");
3145 }
3146
3147 static void test_maclhws_ (void)
3148 {
3149 __asm__ __volatile__ ("maclhws. 17, 14, 15");
3150 }
3151
3152 static void test_maclhwso_ (void)
3153 {
3154 __asm__ __volatile__ ("maclhwso. 17, 14, 15");
3155 }
3156
3157 static void test_maclhwsu_ (void)
3158 {
3159 __asm__ __volatile__ ("maclhwsu. 17, 14, 15");
3160 }
3161
3162 static void test_maclhwsuo_ (void)
3163 {
3164 __asm__ __volatile__ ("maclhwsuo. 17, 14, 15");
3165 }
3166
3167 static void test_maclhwu_ (void)
3168 {
3169 __asm__ __volatile__ ("maclhwu. 17, 14, 15");
3170 }
3171
3172 static void test_maclhwuo_ (void)
3173 {
3174 __asm__ __volatile__ ("maclhwuo. 17, 14, 15");
3175 }
3176
3177 static void test_mulchw_ (void)
3178 {
3179 __asm__ __volatile__ ("mulchw. 17, 14, 15");
3180 }
3181
3182 static void test_mulchwu_ (void)
3183 {
3184 __asm__ __volatile__ ("mulchwu. 17, 14, 15");
3185 }
3186
3187 static void test_mulhhw_ (void)
3188 {
3189 __asm__ __volatile__ ("mulhhw. 17, 14, 15");
3190 }
3191
3192 static void test_mulhhwu_ (void)
3193 {
3194 __asm__ __volatile__ ("mulhhwu. 17, 14, 15");
3195 }
3196
3197 static void test_mullhw_ (void)
3198 {
3199 __asm__ __volatile__ ("mullhw. 17, 14, 15");
3200 }
3201
3202 static void test_mullhwu_ (void)
3203 {
3204 __asm__ __volatile__ ("mullhwu. 17, 14, 15");
3205 }
3206
3207 static void test_nmacchw_ (void)
3208 {
3209 __asm__ __volatile__ ("nmacchw. 17, 14, 15");
3210 }
3211
3212 static void test_nmacchwo_ (void)
3213 {
3214 __asm__ __volatile__ ("nmacchwo. 17, 14, 15");
3215 }
3216
3217 static void test_nmacchws_ (void)
3218 {
3219 __asm__ __volatile__ ("nmacchws. 17, 14, 15");
3220 }
3221
3222 static void test_nmacchwso_ (void)
3223 {
3224 __asm__ __volatile__ ("nmacchwso. 17, 14, 15");
3225 }
3226
3227 static void test_nmachhw_ (void)
3228 {
3229 __asm__ __volatile__ ("nmachhw. 17, 14, 15");
3230 }
3231
3232 static void test_nmachhwo_ (void)
3233 {
3234 __asm__ __volatile__ ("nmachhwo. 17, 14, 15");
3235 }
3236
3237 static void test_nmachhws_ (void)
3238 {
3239 __asm__ __volatile__ ("nmachhws. 17, 14, 15");
3240 }
3241
3242 static void test_nmachhwso_ (void)
3243 {
3244 __asm__ __volatile__ ("nmachhwso. 17, 14, 15");
3245 }
3246
3247 static void test_nmaclhw_ (void)
3248 {
3249 __asm__ __volatile__ ("nmaclhw. 17, 14, 15");
3250 }
3251
3252 static void test_nmaclhwo_ (void)
3253 {
3254 __asm__ __volatile__ ("nmaclhwo. 17, 14, 15");
3255 }
3256
3257 static void test_nmaclhws_ (void)
3258 {
3259 __asm__ __volatile__ ("nmaclhws. 17, 14, 15");
3260 }
3261
3262 static void test_nmaclhwso_ (void)
3263 {
3264 __asm__ __volatile__ ("nmaclhwso. 17, 14, 15");
3265 }
3266
3267 static test_t tests_p4mc_ops_two[] = {
3268 { &test_macchw_ , " macchw.", },
3269 { &test_macchwo_ , " macchwo.", },
3270 { &test_macchws_ , " macchws.", },
3271 { &test_macchwso_ , " macchwso.", },
3272 { &test_macchwsu_ , " macchwsu.", },
3273 { &test_macchwsuo_ , " macchwsuo.", },
3274 { &test_macchwu_ , " macchwu.", },
3275 { &test_macchwuo_ , " macchwuo.", },
3276 { &test_machhw_ , " machhw.", },
3277 { &test_machhwo_ , " machhwo.", },
3278 { &test_machhws_ , " machhws.", },
3279 { &test_machhwso_ , " machhwso.", },
3280 { &test_machhwsu_ , " machhwsu.", },
3281 { &test_machhwsuo_ , " machhwsuo.", },
3282 { &test_machhwu_ , " machhwu.", },
3283 { &test_machhwuo_ , " machhwuo.", },
3284 { &test_maclhw_ , " maclhw.", },
3285 { &test_maclhwo_ , " maclhwo.", },
3286 { &test_maclhws_ , " maclhws.", },
3287 { &test_maclhwso_ , " maclhwso.", },
3288 { &test_maclhwsu_ , " maclhwsu.", },
3289 { &test_maclhwsuo_ , " maclhwsuo.", },
3290 { &test_maclhwu_ , " maclhwu.", },
3291 { &test_maclhwuo_ , " maclhwuo.", },
3292 { &test_mulchw_ , " mulchw.", },
3293 { &test_mulchwu_ , " mulchwu.", },
3294 { &test_mulhhw_ , " mulhhw.", },
3295 { &test_mulhhwu_ , " mulhhwu.", },
3296 { &test_mullhw_ , " mullhw.", },
3297 { &test_mullhwu_ , " mullhwu.", },
3298 { &test_nmacchw_ , " nmacchw.", },
3299 { &test_nmacchwo_ , " nmacchwo.", },
3300 { &test_nmacchws_ , " nmacchws.", },
3301 { &test_nmacchwso_ , " nmacchwso.", },
3302 { &test_nmachhw_ , " nmachhw.", },
3303 { &test_nmachhwo_ , " nmachhwo.", },
3304 { &test_nmachhws_ , " nmachhws.", },
3305 { &test_nmachhwso_ , " nmachhwso.", },
3306 { &test_nmaclhw_ , " nmaclhw.", },
3307 { &test_nmaclhwo_ , " nmaclhwo.", },
3308 { &test_nmaclhws_ , " nmaclhws.", },
3309 { &test_nmaclhwso_ , " nmaclhwso.", },
3310 { NULL, NULL, },
3311 };
3312 #endif /* defined (IS_PPC405) */
3313
3314 static test_table_t all_tests[] = {
3315 {
3316 tests_ia_ops_two ,
3317 "PPC integer arithmetic instructions with two arguments",
3318 0x00010102,
3319 },
3320 {
3321 tests_iar_ops_two ,
3322 "PPC integer instructions with two arguments with flags update",
3323 0x01010102,
3324 },
3325 {
3326 tests_il_ops_two ,
3327 "PPC integer logical instructions with two arguments",
3328 0x00010202,
3329 },
3330 {
3331 tests_ilr_ops_two ,
3332 "PPC integer logical instructions with two arguments with flags update",
3333 0x01010202,
3334 },
3335 {
3336 tests_icr_ops_two ,
3337 "PPC integer compare instructions (two arguents)",
3338 0x01010304,
3339 },
3340 {
3341 tests_icr_ops_two_i16 ,
3342 "PPC integer compare with immediate instructions (two arguents)",
3343 0x01010304,
3344 },
3345 {
3346 tests_ia_ops_two_i16 ,
3347 "PPC integer arithmetic instructions\n with one register + one 16 bits immediate arguments",
3348 0x00010106,
3349 },
3350 {
3351 tests_iar_ops_two_i16 ,
3352 "PPC integer arithmetic instructions\n with one register + one 16 bits immediate arguments with flags update",
3353 0x01010106,
3354 },
3355 {
3356 tests_il_ops_two_i16 ,
3357 "PPC integer logical instructions\n with one register + one 16 bits immediate arguments",
3358 0x00010206,
3359 },
3360 {
3361 tests_ilr_ops_two_i16 ,
3362 "PPC integer logical instructions\n with one register + one 16 bits immediate arguments with flags update",
3363 0x01010206,
3364 },
3365 {
3366 tests_crl_ops_two ,
3367 "PPC condition register logical instructions - two operands",
3368 0x01000602,
3369 },
3370 {
3371 tests_ia_ops_one ,
3372 "PPC integer arithmetic instructions with one argument",
3373 0x00010101,
3374 },
3375 {
3376 tests_iar_ops_one ,
3377 "PPC integer arithmetic instructions with one argument with flags update",
3378 0x01010101,
3379 },
3380 {
3381 tests_il_ops_one ,
3382 "PPC integer logical instructions with one argument",
3383 0x00010201,
3384 },
3385 {
3386 tests_ilr_ops_one ,
3387 "PPC integer logical instructions with one argument with flags update",
3388 0x01010201,
3389 },
3390 {
3391 tests_il_ops_spe ,
3392 "PPC logical instructions with special forms",
3393 0x00010207,
3394 },
3395 {
3396 tests_ilr_ops_spe ,
3397 "PPC logical instructions with special forms with flags update",
3398 0x01010207,
3399 },
3400 #if !defined (NO_FLOAT)
3401 {
3402 tests_fa_ops_three ,
3403 "PPC floating point arithmetic instructions with three arguments",
3404 0x00020103,
3405 },
3406 #endif /* !defined (NO_FLOAT) */
3407 #if !defined (NO_FLOAT)
3408 {
3409 tests_far_ops_three ,
3410 "PPC floating point arithmetic instructions\n with three arguments with flags update",
3411 0x01020103,
3412 },
3413 #endif /* !defined (NO_FLOAT) */
3414 #if !defined (NO_FLOAT)
3415 {
3416 tests_fa_ops_two ,
3417 "PPC floating point arithmetic instructions with two arguments",
3418 0x00020102,
3419 },
3420 #endif /* !defined (NO_FLOAT) */
3421 #if !defined (NO_FLOAT)
3422 {
3423 tests_far_ops_two ,
3424 "PPC floating point arithmetic instructions\n with two arguments with flags update",
3425 0x01020102,
3426 },
3427 #endif /* !defined (NO_FLOAT) */
3428 #if !defined (NO_FLOAT)
3429 {
3430 tests_fcr_ops_two ,
3431 "PPC floating point compare instructions (two arguments)",
3432 0x01020304,
3433 },
3434 #endif /* !defined (NO_FLOAT) */
3435 #if !defined (NO_FLOAT)
3436 {
3437 tests_fa_ops_one ,
3438 "PPC floating point arithmetic instructions with one argument",
3439 0x00020101,
3440 },
3441 #endif /* !defined (NO_FLOAT) */
3442 #if !defined (NO_FLOAT)
3443 {
3444 tests_far_ops_one ,
3445 "PPC floating point arithmetic instructions\n with one argument with flags update",
3446 0x01020101,
3447 },
3448 #endif /* !defined (NO_FLOAT) */
3449 #if !defined (NO_FLOAT)
3450 {
3451 tests_fl_ops_spe ,
3452 "PPC floating point status register manipulation instructions",
3453 0x00020207,
3454 },
3455 #endif /* !defined (NO_FLOAT) */
3456 #if !defined (NO_FLOAT)
3457 {
3458 tests_flr_ops_spe ,
3459 "PPC floating point status register manipulation instructions\n with flags update",
3460 0x01020207,
3461 },
3462 #endif /* !defined (NO_FLOAT) */
3463 #if defined (HAS_ALTIVEC)
3464 {
3465 tests_aa_ops_three ,
3466 "PPC altivec integer arithmetic instructions with three arguments",
3467 0x00040103,
3468 },
3469 #endif /* defined (HAS_ALTIVEC) */
3470 #if defined (HAS_ALTIVEC)
3471 {
3472 tests_al_ops_three ,
3473 "PPC altivec integer logical instructions with three arguments",
3474 0x00040203,
3475 },
3476 #endif /* defined (HAS_ALTIVEC) */
3477 #if defined (HAS_ALTIVEC)
3478 {
3479 tests_aa_ops_two ,
3480 "PPC altivec integer arithmetic instructions with two arguments",
3481 0x00040102,
3482 },
3483 #endif /* defined (HAS_ALTIVEC) */
3484 #if defined (HAS_ALTIVEC)
3485 {
3486 tests_al_ops_two ,
3487 "PPC altivec integer logical instructions with two arguments",
3488 0x00040202,
3489 },
3490 #endif /* defined (HAS_ALTIVEC) */
3491 #if defined (HAS_ALTIVEC)
3492 {
3493 tests_al_ops_one ,
3494 "PPC altivec integer logical instructions with one argument",
3495 0x00040201,
3496 },
3497 #endif /* defined (HAS_ALTIVEC) */
3498 #if defined (HAS_ALTIVEC)
3499 {
3500 tests_ac_ops_two ,
3501 "Altivec integer compare instructions",
3502 0x00040302,
3503 },
3504 #endif /* defined (HAS_ALTIVEC) */
3505 #if defined (HAS_ALTIVEC)
3506 {
3507 tests_acr_ops_two ,
3508 "Altivec integer compare instructions with flags update",
3509 0x01040302,
3510 },
3511 #endif /* defined (HAS_ALTIVEC) */
3512 #if defined (HAS_ALTIVEC)
3513 {
3514 tests_afa_ops_three ,
3515 "Altivec floating point arithmetic instructions with three arguments",
3516 0x00050103,
3517 },
3518 #endif /* defined (HAS_ALTIVEC) */
3519 #if defined (HAS_ALTIVEC)
3520 {
3521 tests_afa_ops_two ,
3522 "Altivec floating point arithmetic instructions with two arguments",
3523 0x00050102,
3524 },
3525 #endif /* defined (HAS_ALTIVEC) */
3526 #if defined (HAS_ALTIVEC)
3527 {
3528 tests_afa_ops_one ,
3529 "Altivec floating point arithmetic instructions with one argument",
3530 0x00050101,
3531 },
3532 #endif /* defined (HAS_ALTIVEC) */
3533 #if defined (HAS_ALTIVEC)
3534 {
3535 tests_afc_ops_two ,
3536 "Altivec floating point compare instructions",
3537 0x00050302,
3538 },
3539 #endif /* defined (HAS_ALTIVEC) */
3540 #if defined (HAS_ALTIVEC)
3541 {
3542 tests_afcr_ops_two ,
3543 "Altivec floating point compare instructions with flags update",
3544 0x01050302,
3545 },
3546 #endif /* defined (HAS_ALTIVEC) */
3547 #if defined (IS_PPC405)
3548 {
3549 tests_p4m_ops_two ,
3550 "PPC 405 mac instructions with three arguments",
3551 0x00030102,
3552 },
3553 #endif /* defined (IS_PPC405) */
3554 #if defined (IS_PPC405)
3555 {
3556 tests_p4mc_ops_two ,
3557 "PPC 405 mac instructions with three arguments with flags update",
3558 0x01030102,
3559 },
3560 #endif /* defined (IS_PPC405) */
3561 { NULL, NULL, 0x00000000, },
3562 };
3563
3564 // END #include "ops-ppc.c"
3565
3566
3567 static int verbose = 0;
3568
3569 static double *fargs;
3570 static int nb_fargs;
3571 static uint32_t *iargs;
3572 static int nb_iargs;
3573 static uint16_t *ii16;
3574 static int nb_ii16;
3575
3576 static inline void register_farg (void *farg,
3577 int s, uint16_t _exp, uint64_t mant)
3578 {
3579 uint64_t tmp;
3580
3581 tmp = ((uint64_t)s << 63) | ((uint64_t)_exp << 52) | mant;
3582 *(uint64_t *)farg = tmp;
3583 AB_DPRINTF("%d %03x %013llx => %016llx %0e\n",
3584 s, _exp, mant, *(uint64_t *)farg, *(double *)farg);
3585 }
3586
3587 static void build_fargs_table (void)
3588 {
3589 /* Sign goes from zero to one
3590 * Exponent goes from 0 to ((1 << 12) - 1)
3591 * Mantissa goes from 1 to ((1 << 52) - 1)
3592 * + special values:
3593 * +0.0 : 0 0x000 0x0000000000000
3594 * -0.0 : 1 0x000 0x0000000000000
3595 * +infinity : 0 0x7FF 0x0000000000000
3596 * -infinity : 1 0x7FF 0x0000000000000
3597 * +SNaN : 0 0x7FF 0x7FFFFFFFFFFFF
3598 * -SNaN : 1 0x7FF 0x7FFFFFFFFFFFF
3599 * +QNaN : 0 0x7FF 0x8000000000000
3600 * -QNaN : 1 0x7FF 0x8000000000000
3601 * (8 values)
3602 */
3603 uint64_t mant;
3604 uint16_t _exp, e0, e1;
3605 int s;
3606 int i;
3607
3608 fargs = my_malloc(200 * sizeof(double));
3609 i = 0;
3610 for (s = 0; s < 2; s++) {
3611 for (e0 = 0; e0 < 2; e0++) {
3612 for (e1 = 0x000; ; e1 = ((e1 + 1) << 2) + 6) {
3613 if (e1 >= 0x400)
3614 e1 = 0x3fe;
3615 _exp = (e0 << 10) | e1;
3616 for (mant = 0x0000000000001ULL; mant < (1ULL << 52);
3617 /* Add 'random' bits */
3618 mant = ((mant + 0x4A6) << 13) + 0x359) {
3619 register_farg(&fargs[i++], s, _exp, mant);
3620 }
3621 if (e1 == 0x3fe)
3622 break;
3623 }
3624 }
3625 }
3626 /* Special values */
3627 /* +0.0 : 0 0x000 0x0000000000000 */
3628 s = 0;
3629 _exp = 0x000;
3630 mant = 0x0000000000000ULL;
3631 register_farg(&fargs[i++], s, _exp, mant);
3632 /* -0.0 : 1 0x000 0x0000000000000 */
3633 s = 1;
3634 _exp = 0x000;
3635 mant = 0x0000000000000ULL;
3636 register_farg(&fargs[i++], s, _exp, mant);
3637 /* +infinity : 0 0x7FF 0x0000000000000 */
3638 s = 0;
3639 _exp = 0x7FF;
3640 mant = 0x0000000000000ULL;
3641 register_farg(&fargs[i++], s, _exp, mant);
3642 /* -infinity : 1 0x7FF 0x0000000000000 */
3643 s = 1;
3644 _exp = 0x7FF;
3645 mant = 0x0000000000000ULL;
3646 register_farg(&fargs[i++], s, _exp, mant);
3647 /* +SNaN : 0 0x7FF 0x7FFFFFFFFFFFF */
3648 s = 0;
3649 _exp = 0x7FF;
3650 mant = 0x7FFFFFFFFFFFFULL;
3651 register_farg(&fargs[i++], s, _exp, mant);
3652 /* -SNaN : 1 0x7FF 0x7FFFFFFFFFFFF */
3653 s = 1;
3654 _exp = 0x7FF;
3655 mant = 0x7FFFFFFFFFFFFULL;
3656 register_farg(&fargs[i++], s, _exp, mant);
3657 /* +QNaN : 0 0x7FF 0x8000000000000 */
3658 s = 0;
3659 _exp = 0x7FF;
3660 mant = 0x8000000000000ULL;
3661 register_farg(&fargs[i++], s, _exp, mant);
3662 /* -QNaN : 1 0x7FF 0x8000000000000 */
3663 s = 1;
3664 _exp = 0x7FF;
3665 mant = 0x8000000000000ULL;
3666 register_farg(&fargs[i++], s, _exp, mant);
3667 AB_DPRINTF("Registered %d floats values\n", i);
3668 nb_fargs = i;
3669 }
3670
3671 static void build_iargs_table (void)
3672 {
3673 uint64_t tmp;
3674 int i;
3675
3676 iargs = my_malloc(400 * sizeof(uint32_t));
3677 i = 0;
3678 for (tmp = 0; ; tmp = tmp + 1 + (tmp>>1)+(tmp>>2)+(tmp>>3)) {
3679 if (tmp >= 0x100000000ULL)
3680 tmp = 0xFFFFFFFF;
3681 iargs[i++] = tmp;
3682 AB_DPRINTF("val %08llx\n", tmp);
3683 if (tmp == 0xFFFFFFFF)
3684 break;
3685 }
3686 AB_DPRINTF("Registered %d ints values\n", i);
3687 nb_iargs = i;
3688 }
3689
3690 static void build_ii16_table (void)
3691 {
3692 uint32_t tmp;
3693 int i;
3694
3695 ii16 = my_malloc(200 * sizeof(uint32_t));
3696 i = 0;
3697 for (tmp = 0; ; tmp = tmp + 1 + (tmp>>1)+(tmp>>2)+(tmp>>3)) {
3698 if (tmp >= 0x10000)
3699 tmp = 0xFFFF;
3700 ii16[i++] = tmp;
3701 AB_DPRINTF("val %08llx\n", tmp);
3702 if (tmp == 0xFFFF)
3703 break;
3704 }
3705 AB_DPRINTF("Registered %d ints values\n", i);
3706 nb_ii16 = i;
3707 }
3708
3709 static void test_int_three_args (const unsigned char *name, test_func_t func)
3710 {
3711 uint32_t res, flags, xer;
3712 int i, j, k;
3713
3714 if (verbose > 1)
3715 vexxx_printf( "Test instruction %s\n", name);
3716 for (i = 0; i < nb_iargs; i++) {
3717 for (j = 0; j < nb_iargs; j++) {
3718 for (k = 0;k < nb_iargs; k++) {
3719 r14 = iargs[i];
3720 r15 = iargs[j];
3721 r16 = iargs[k];
3722 r18 = 0;
3723 __asm__ __volatile__ ("mtcr 18");
3724 __asm__ __volatile__ ("mtxer 18");
3725 (*func)();
3726 __asm__ __volatile__ ("mfcr 18");
3727 flags = r18;
3728 __asm__ __volatile__ ("mfxer 18");
3729 xer = r18;
3730 res = r17;
3731 vexxx_printf("%s %08x, %08x, %08x => %08x (%08x %08x)\n",
3732 name, iargs[i], iargs[j], iargs[k], res, flags, xer);
3733 }
3734 vexxx_printf("\n");
3735 }
3736 vexxx_printf("\n");
3737 }
3738 vexxx_printf("\n");
3739 }
3740
3741 static void test_int_two_args (const unsigned char *name, test_func_t func)
3742 {
3743 uint32_t res, flags, xer;
3744 int i, j;
3745
3746 if (verbose > 1)
3747 vexxx_printf( "Test instruction %s\n", name);
3748 for (i = 0; i < nb_iargs; i++) {
3749 for (j = 0; j < nb_iargs; j++) {
3750 r14 = iargs[i];
3751 r15 = iargs[j];
3752 r18 = 0;
3753 __asm__ __volatile__ ("mtcr 18");
3754 __asm__ __volatile__ ("mtxer 18");
3755 (*func)();
3756 __asm__ __volatile__ ("mfcr 18");
3757 flags = r18;
3758 __asm__ __volatile__ ("mfxer 18");
3759 xer = r18;
3760 res = r17;
3761 vexxx_printf("%s %08x, %08x => %08x (%08x %08x)\n",
3762 name, iargs[i], iargs[j], res, flags, xer);
3763 }
3764 vexxx_printf("\n");
3765 }
3766 vexxx_printf("\n");
3767 }
3768
3769 static void test_int_one_arg (const unsigned char *name, test_func_t func)
3770 {
3771 uint32_t res, flags, xer;
3772 int i;
3773
3774 if (verbose > 1)
3775 vexxx_printf( "Test instruction %s\n", name);
3776 for (i = 0; i < nb_iargs; i++) {
3777 r14 = iargs[i];
3778 r18 = 0;
3779 __asm__ __volatile__ ("mtcr 18");
3780 // r18 = 0x20000000; // set xer_ca
3781 __asm__ __volatile__ ("mtxer 18");
3782 (*func)();
3783 res = r17;
3784 __asm__ __volatile__ ("mfcr 18");
3785 flags = r18;
3786 __asm__ __volatile__ ("mfxer 18");
3787 xer = r18;
3788 vexxx_printf("%s %08x => %08x (%08x %08x)\n",
3789 name, iargs[i], res, flags, xer);
3790 }
3791 vexxx_printf("\n");
3792 }
3793
3794 static inline void _patch_op_imm (void *out, void *in,
3795 uint16_t imm, int sh, int len)
3796 {
3797 volatile uint32_t *p, *q;
3798
3799 p = out;
3800 q = in;
3801 *p = (*q & ~(((1 << len) - 1) << sh)) | ((imm & ((1 << len) - 1)) << sh);
3802 }
3803
3804 static inline void patch_op_imm (void *out, void *in,
3805 uint16_t imm, int sh, int len)
3806 {
3807 volatile uint32_t *p;
3808
3809 p = out;
3810 _patch_op_imm(out, in, imm, sh, len);
3811 __asm__ __volatile__ ("dcbf 0, %0 ; icbi 0, %0 ; isync" ::"r"(p));
3812 }
3813
3814 static inline void patch_op_imm16 (void *out, void *in, uint16_t imm)
3815 {
3816 patch_op_imm(out, in, imm, 0, 16);
3817 }
3818
3819 static void test_int_one_reg_imm16 (const unsigned char *name,
3820 test_func_t func)
3821 {
3822 uint32_t func_buf[2], *p;
3823 uint32_t res, flags, xer;
3824 int i, j;
3825
3826 if (verbose > 1)
3827 vexxx_printf( "Test instruction %s\n", name);
3828 for (i = 0; i < nb_iargs; i++) {
3829 for (j = 0; j < nb_ii16; j++) {
3830 p = (void *)func;
3831 #if 0
3832 vexxx_printf("copy func %s from %p to %p (%08x %08x)\n",
3833 name, func, func_buf, p[0], p[1]);
3834 #endif
3835 func_buf[1] = p[1];
3836 patch_op_imm16(func_buf, p, ii16[j]);
3837 func = (void *)func_buf;
3838 #if 0
3839 vexxx_printf(" => func %s from %p to %p (%08x %08x)\n",
3840 name, func, func_buf, func_buf[0], func_buf[1]);
3841 #endif
3842 r14 = iargs[i];
3843 r18 = 0;
3844 __asm__ __volatile__ ("mtcr 18");
3845 __asm__ __volatile__ ("mtxer 18");
3846 (*func)();
3847 __asm__ __volatile__ ("mfcr 18");
3848 flags = r18;
3849 __asm__ __volatile__ ("mfxer 18");
3850 xer = r18;
3851 res = r17;
3852 vexxx_printf("%s %08x, %08x => %08x (%08x %08x)\n",
3853 name, iargs[i], ii16[j], res, flags, xer);
3854 }
3855 vexxx_printf("\n");
3856 }
3857 vexxx_printf("\n");
3858 }
3859
3860 /* Special test cases for:
3861 * rlwimi
3862 * rlwinm
3863 * rlwnm
3864 * srawi
3865 * mcrf
3866 * mcrfs
3867 * mffs
3868 * mtfsb0
3869 * mtfsb1
3870 */
3871
3872 static void rlwi_cb (const unsigned char *name, test_func_t func)
3873 {
3874 uint32_t func_buf[2], *p;
3875 uint32_t res, flags, xer;
3876 int i, j, k, l;
3877
3878 if (verbose > 1)
3879 vexxx_printf( "Test instruction %s\n", name);
3880 for (i = 0;;) {
3881 if (i >= nb_iargs)
3882 i = nb_iargs - 1;
3883 for (j = 0; j < 32; j++) {
3884 for (k = 0; k < 32; k++) {
3885 for (l = 0; l < 32; l++) {
3886 p = (void *)func;
3887 func_buf[1] = p[1];
3888 _patch_op_imm(func_buf, p, j, 11, 5);
3889 _patch_op_imm(func_buf, p, k, 6, 5);
3890 patch_op_imm(func_buf, p, l, 1, 5);
3891 func = (void *)func_buf;
3892 r14 = iargs[i];
3893 r18 = 0;
3894 __asm__ __volatile__ ("mtcr 18");
3895 __asm__ __volatile__ ("mtxer 18");
3896 (*func)();
3897 __asm__ __volatile__ ("mfcr 18");
3898 flags = r18;
3899 __asm__ __volatile__ ("mfxer 18");
3900 xer = r18;
3901 res = r17;
3902 vexxx_printf("%s %08x, %d, %d, %d => %08x (%08x %08x)\n",
3903 name, iargs[i], j, k, l, res, flags, xer);
3904 }
3905 vexxx_printf("\n");
3906 }
3907 vexxx_printf("\n");
3908 }
3909 vexxx_printf("\n");
3910 if (i == 0)
3911 i = 1;
3912 else if (i == nb_iargs - 1)
3913 break;
3914 else
3915 i += 3;
3916 }
3917 vexxx_printf("\n");
3918 }
3919
3920 static void rlwnm_cb (const unsigned char *name, test_func_t func)
3921 {
3922 uint32_t func_buf[2], *p;
3923 uint32_t res, flags, xer;
3924 int i, j, k, l;
3925
3926 if (verbose > 1)
3927 vexxx_printf( "Test instruction %s\n", name);
3928 for (i = 0; i < nb_iargs; i++) {
3929 for (j = 0; j < 64; j++) {
3930 for (k = 0; k < 32; k++) {
3931 for (l = 0; l < 32; l++) {
3932 p = (void *)func;
3933 func_buf[1] = p[1];
3934 _patch_op_imm(func_buf, p, k, 6, 5);
3935 patch_op_imm(func_buf, p, l, 1, 5);
3936 func = (void *)func_buf;
3937 r14 = iargs[i];
3938 r15 = j;
3939 r18 = 0;
3940 __asm__ __volatile__ ("mtcr 18");
3941 __asm__ __volatile__ ("mtxer 18");
3942 (*func)();
3943 __asm__ __volatile__ ("mfcr 18");
3944 flags = r18;
3945 __asm__ __volatile__ ("mfxer 18");
3946 xer = r18;
3947 res = r17;
3948 vexxx_printf("%s %08x, %08x, %d, %d => %08x (%08x %08x)\n",
3949 name, iargs[i], j, k, l, res, flags, xer);
3950 }
3951 vexxx_printf("\n");
3952 }
3953 vexxx_printf("\n");
3954 }
3955 vexxx_printf("\n");
3956 }
3957 vexxx_printf("\n");
3958 }
3959
3960 static void srawi_cb (const unsigned char *name, test_func_t func)
3961 {
3962 uint32_t func_buf[2], *p;
3963 uint32_t res, flags, xer;
3964 int i, j;
3965
3966 if (verbose > 1)
3967 vexxx_printf( "Test instruction %s\n", name);
3968 for (i = 0; i < nb_iargs; i++) {
3969 for (j = 0; j < 32; j++) {
3970 p = (void *)func;
3971 func_buf[1] = p[1];
3972 patch_op_imm(func_buf, p, j, 11, 5);
3973 func = (void *)func_buf;
3974 r14 = iargs[i];
3975 r18 = 0;
3976 __asm__ __volatile__ ("mtcr 18");
3977 __asm__ __volatile__ ("mtxer 18");
3978 (*func)();
3979 __asm__ __volatile__ ("mfcr 18");
3980 flags = r18;
3981 __asm__ __volatile__ ("mfxer 18");
3982 xer = r18;
3983 res = r17;
3984 vexxx_printf("%s %08x, %d => %08x (%08x %08x)\n",
3985 name, iargs[i], j, res, flags, xer);
3986 }
3987 vexxx_printf("\n");
3988 }
3989 vexxx_printf("\n");
3990 }
3991
3992 typedef struct special_t special_t;
3993 struct special_t {
3994 const unsigned char *name;
3995 void (*test_cb)(const unsigned char *name, test_func_t func);
3996 };
3997
3998 static void test_special (special_t *table,
3999 const unsigned char *name, test_func_t func)
4000 {
4001 const unsigned char *tmp;
4002 int i;
4003
4004 for (tmp = name; my_isspace(*tmp); tmp++)
4005 continue;
4006 for (i = 0; table[i].name != NULL; i++) {
4007 #if 0
4008 vexxx_printf( "look for handler for '%s' (%s)\n", name,
4009 table[i].name);
4010 #endif
4011 if (my_strcmp(table[i].name, tmp) == 0) {
4012 (*table[i].test_cb)(name, func);
4013 return;
4014 }
4015 }
4016 vexxx_printf( "ERROR: no test found for op '%s'\n", name);
4017 }
4018
4019 static special_t special_int_ops[] = {
4020 #if 0
4021 {
4022 "rlwimi", /* One register + 3 5 bits immediate arguments */
4023 &rlwi_cb,
4024 },
4025 {
4026 "rlwimi.", /* One register + 3 5 bits immediate arguments */
4027 &rlwi_cb,
4028 },
4029 {
4030 "rlwinm", /* One register + 3 5 bits immediate arguments */
4031 &rlwi_cb,
4032 },
4033 {
4034 "rlwinm.", /* One register + 3 5 bits immediate arguments */
4035 &rlwi_cb,
4036 },
4037 {
4038 "rlwnm", /* Two registers + 3 5 bits immediate arguments */
4039 &rlwnm_cb,
4040 },
4041 {
4042 "rlwnm.", /* Two registers + 3 5 bits immediate arguments */
4043 &rlwnm_cb,
4044 },
4045 {
4046 "srawi", /* One register + 1 5 bits immediate arguments */
4047 &srawi_cb,
4048 },
4049 {
4050 "srawi.", /* One register + 1 5 bits immediate arguments */
4051 &srawi_cb,
4052 },
4053 #endif
4054 #if 0
4055 {
4056 "mcrf", /* 2 3 bits immediate arguments */
4057 &mcrf_cb,
4058 },
4059 {
4060 "mcrf", /* 2 3 bits immediate arguments */
4061 &mcrf_cb,
4062 },
4063 #endif
4064 {
4065 NULL,
4066 NULL,
4067 },
4068 };
4069
4070 static void test_int_special (const unsigned char *name, test_func_t func)
4071 {
4072 test_special(special_int_ops, name, func);
4073 }
4074
4075 static test_loop_t int_loops[] = {
4076 &test_int_one_arg,
4077 &test_int_two_args,
4078 &test_int_three_args,
4079 &test_int_two_args,
4080 &test_int_one_reg_imm16,
4081 &test_int_one_reg_imm16,
4082 &test_int_special,
4083 };
4084
4085 #if !defined (NO_FLOAT)
4086 static void test_float_three_args (const unsigned char *name, test_func_t func)
4087 {
4088 double res;
4089 uint64_t u0, u1, u2, ur;
4090 uint32_t flags;
4091 int i, j, k;
4092
4093 if (verbose > 1)
4094 vexxx_printf( "Test instruction %s\n", name);
4095 for (i = 0; i < nb_fargs; i++) {
4096 for (j = 0; j < nb_fargs; j++) {
4097 for (k = 0;k < nb_fargs; k++) {
4098 u0 = *(uint64_t *)(&fargs[i]);
4099 u1 = *(uint64_t *)(&fargs[j]);
4100 u2 = *(uint64_t *)(&fargs[k]);
4101 f14 = fargs[i];
4102 f15 = fargs[j];
4103 f16 = fargs[k];
4104 r18 = 0;
4105 __asm__ __volatile__ ("mtcr 18");
4106 __asm__ __volatile__ ("mtxer 18");
4107 f18 = +0.0;
4108 __asm__ __volatile__ ("mtfsf 0xFF, 18");
4109 (*func)();
4110 __asm__ __volatile__ ("mfcr 18");
4111 flags = r18;
4112 res = f17;
4113 ur = *(uint64_t *)(&res);
4114 vexxx_printf("%s %016llx, %016llx, %016llx => %016llx (%08x)\n",
4115 name, u0, u1, u2, ur, flags);
4116 }
4117 vexxx_printf("\n");
4118 }
4119 vexxx_printf("\n");
4120 }
4121 vexxx_printf("\n");
4122 }
4123
4124 static void test_float_two_args (const unsigned char *name, test_func_t func)
4125 {
4126 double res;
4127 uint64_t u0, u1, ur;
4128 uint32_t flags;
4129 int i, j;
4130
4131 if (verbose > 1)
4132 vexxx_printf( "Test instruction %s\n", name);
4133 for (i = 0; i < nb_fargs; i++) {
4134 for (j = 0; j < nb_fargs; j++) {
4135 u0 = *(uint64_t *)(&fargs[i]);
4136 u1 = *(uint64_t *)(&fargs[j]);
4137 f14 = fargs[i];
4138 f15 = fargs[j];
4139 r18 = 0;
4140 __asm__ __volatile__ ("mtcr 18");
4141 __asm__ __volatile__ ("mtxer 18");
4142 f18 = +0.0;
4143 __asm__ __volatile__ ("mtfsf 0xFF, 18");
4144 (*func)();
4145 __asm__ __volatile__ ("mfcr 18");
4146 flags = r18;
4147 res = f17;
4148 ur = *(uint64_t *)(&res);
4149 vexxx_printf("%s %016llx, %016llx => %016llx (%08x)\n",
4150 name, u0, u1, ur, flags);
4151 }
4152 vexxx_printf("\n");
4153 }
4154 vexxx_printf("\n");
4155 }
4156
4157 static void test_float_one_arg (const unsigned char *name, test_func_t func)
4158 {
4159 double res;
4160 uint64_t u0, ur;
4161 uint32_t flags;
4162 int i;
4163
4164 if (verbose > 1)
4165 vexxx_printf( "Test instruction %s\n", name);
4166 for (i = 0; i < nb_fargs; i++) {
4167 u0 = *(uint64_t *)(&fargs[i]);
4168 f14 = fargs[i];
4169 r18 = 0;
4170 __asm__ __volatile__ ("mtcr 18");
4171 __asm__ __volatile__ ("mtxer 18");
4172 f18 = +0.0;
4173 __asm__ __volatile__ ("mtfsf 0xFF, 18");
4174 (*func)();
4175 __asm__ __volatile__ ("mfcr 18");
4176 flags = r18;
4177 res = f17;
4178 ur = *(uint64_t *)(&res);
4179 vexxx_printf("%s %016llx => %016llx (%08x)\n", name, u0, ur, flags);
4180 }
4181 vexxx_printf("\n");
4182 }
4183
4184 static special_t special_float_ops[] = {
4185 #if 0
4186 {
4187 "mffs", /* One 5 bits immediate argument */
4188 &mffs_cb,
4189 },
4190 {
4191 "mffs.", /* One 5 bits immediate argument */
4192 &mffs_cb,
4193 },
4194 {
4195 "mtfsb0", /* One 5 bits immediate argument */
4196 &mffs_cb,
4197 },
4198 {
4199 "mtfsb0.", /* One 5 bits immediate argument */
4200 &mffs_cb,
4201 },
4202 {
4203 "mtfsb1", /* One 5 bits immediate argument */
4204 &mffs_cb,
4205 },
4206 {
4207 "mtfsb1.", /* One 5 bits immediate argument */
4208 &mffs_cb,
4209 },
4210 {
4211 "mtfsf", /* One register + 1 8 bits immediate argument */
4212 &mtfsf_cb,
4213 },
4214 {
4215 "mtfsf.", /* One register + 1 8 bits immediate argument */
4216 &mtfsf_cb,
4217 },
4218 {
4219 "mtfsfi", /* One 5 bits argument + 1 5 bits argument */
4220 &mtfsfi_cb,
4221 },
4222 {
4223 "mtfsfi.", /* One 5 bits argument + 1 5 bits argument */
4224 &mtfsfi_cb,
4225 },
4226 #endif
4227 {
4228 NULL,
4229 NULL,
4230 },
4231 };
4232
4233 static void test_float_special (const unsigned char *name, test_func_t func)
4234 {
4235 test_special(special_float_ops, name, func);
4236 }
4237
4238 static test_loop_t float_loops[] = {
4239 &test_float_one_arg,
4240 &test_float_two_args,
4241 &test_float_three_args,
4242 &test_float_two_args,
4243 NULL,
4244 NULL,
4245 &test_float_special,
4246 };
4247 #endif /* !defined (NO_FLOAT) */
4248
4249
4250 #if defined (HAS_ALTIVEC) /* XXX: TODO */
4251 #endif /* defined (HAS_ALTIVEC) */
4252
4253 #if defined (IS_PPC405)
4254 static void test_ppc405 (const unsigned char *name, test_func_t func)
4255 {
4256 uint32_t res, flags, xer;
4257 int i, j, k;
4258
4259 if (verbose > 1)
4260 vexxx_printf( "Test instruction %s\n", name);
4261 for (i = 0; i < nb_iargs; i++) {
4262 for (j = 0; j < nb_iargs; j++) {
4263 for (k = 0;k < nb_iargs; k++) {
4264 r14 = iargs[i];
4265 r15 = iargs[j];
4266 /* Beware: the third argument and the result
4267 * are in the same register
4268 */
4269 r17 = iargs[k];
4270 r18 = 0;
4271 __asm__ __volatile__ ("mtcr 18");
4272 __asm__ __volatile__ ("mtxer 18");
4273 (*func)();
4274 __asm__ __volatile__ ("mfcr 18");
4275 flags = r18;
4276 __asm__ __volatile__ ("mfxer 18");
4277 xer = r18;
4278 res = r17;
4279 vexxx_printf("%s %08x, %08x, %08x => %08x (%08x %08x)\n",
4280 name, iargs[i], iargs[j], iargs[k], res, flags, xer);
4281 }
4282 vexxx_printf("\n");
4283 }
4284 vexxx_printf("\n");
4285 }
4286 vexxx_printf("\n");
4287 }
4288 #endif /* defined (IS_PPC405) */
4289
4290 static int check_filter (unsigned char *filter)
4291 {
4292 unsigned char *c;
4293 int ret = 1;
4294
4295 if (filter != NULL) {
4296 c = my_strchr(filter, '*');
4297 if (c != NULL) {
4298 *c = '\0';
4299 ret = 0;
4300 }
4301 }
4302
4303 return ret;
4304 }
4305
4306 static int check_name (const unsigned char *name, const unsigned char *filter,
4307 int exact)
4308 {
4309 int nlen, flen;
4310 int ret = 0;
4311
4312 if (filter != NULL) {
4313 for (; my_isspace(*name); name++)
4314 continue;
4315 FDPRINTF("Check '%s' againt '%s' (%s match)\n",
4316 name, filter, exact ? "exact" : "starting");
4317 nlen = vexxx_strlen(name);
4318 flen = vexxx_strlen(filter);
4319 if (exact) {
4320 if (nlen == flen && my_memcmp(name, filter, flen) == 0)
4321 ret = 1;
4322 } else {
4323 if (flen <= nlen && my_memcmp(name, filter, flen) == 0)
4324 ret = 1;
4325 }
4326 } else {
4327 ret = 1;
4328 }
4329
4330 return ret;
4331 }
4332
4333 static void do_tests (int one_arg, int two_args, int three_args,
4334 int arith, int logical, int compare,
4335 int integer, int floats, int p405,
4336 int altivec, int faltivec,
4337 int cr, unsigned char *filter)
4338 {
4339 #if defined (IS_PPC405)
4340 test_loop_t tmpl;
4341 #endif
4342 test_loop_t *loop;
4343 test_t *tests;
4344 int nb_args, type, family;
4345 int i, j, n;
4346 int exact;
4347
4348 exact = check_filter(filter);
4349 n = 0;
4350 for (i = 0; all_tests[i].name != NULL; i++) {
4351 nb_args = all_tests[i].flags & PPC_NB_ARGS;
4352 /* Check number of arguments */
4353 if ((nb_args == 1 && !one_arg) ||
4354 (nb_args == 2 && !two_args) ||
4355 (nb_args == 3 && !three_args))
4356 continue;
4357 /* Check instruction type */
4358 type = all_tests[i].flags & PPC_TYPE;
4359 if ((type == PPC_ARITH && !arith) ||
4360 (type == PPC_LOGICAL && !logical) ||
4361 (type == PPC_COMPARE && !compare))
4362 continue;
4363 /* Check instruction family */
4364 family = all_tests[i].flags & PPC_FAMILY;
4365 if ((family == PPC_INTEGER && !integer) ||
4366 (family == PPC_FLOAT && !floats) ||
4367 (family == PPC_405 && !p405) ||
4368 (family == PPC_ALTIVEC && !altivec) ||
4369 (family == PPC_FALTIVEC && !faltivec))
4370 continue;
4371 /* Check flags update */
4372 if (((all_tests[i].flags & PPC_CR) && cr == 0) ||
4373 (!(all_tests[i].flags & PPC_CR) && cr == 1))
4374 continue;
4375 /* All passed, do the tests */
4376 tests = all_tests[i].tests;
4377 /* Select the test loop */
4378 switch (family) {
4379 case PPC_INTEGER:
4380 loop = &int_loops[nb_args - 1];
4381 break;
4382 case PPC_FLOAT:
4383 #if !defined (NO_FLOAT)
4384 loop = &float_loops[nb_args - 1];
4385 break;
4386 #else
4387 vexxx_printf( "Sorry. "
4388 "PPC floating point instructions tests "
4389 "are disabled on your host\n");
4390 #endif /* !defined (NO_FLOAT) */
4391
4392 case PPC_405:
4393 #if defined (IS_PPC405)
4394 tmpl = &test_ppc405;
4395 loop = &tmpl;
4396 break;
4397 #else
4398 vexxx_printf( "Sorry. "
4399 "PPC405 instructions tests are disabled on your host\n");
4400 continue;
4401 #endif /* defined (IS_PPC405) */
4402 case PPC_ALTIVEC:
4403 #if defined (HAS_ALTIVEC)
4404 #if 0
4405 loop = &altivec_int_loops[nb_args - 1];
4406 break;
4407 #else
4408 vexxx_printf( "Sorry. "
4409 "Altivec instructions tests are not yet implemented\n");
4410 continue;
4411 #endif
4412 #else
4413 vexxx_printf( "Sorry. "
4414 "Altivec instructions tests are disabled on your host\n");
4415 continue;
4416 #endif
4417 case PPC_FALTIVEC:
4418 #if defined (HAS_ALTIVEC)
4419 #if 0
4420 loop = &altivec_float_loops[nb_args - 1];
4421 break;
4422 #else
4423 vexxx_printf( "Sorry. "
4424 "Altivec instructions tests are not yet implemented\n");
4425 continue;
4426 #endif
4427 #else
4428 vexxx_printf( "Sorry. "
4429 "Altivec float instructions tests "
4430 "are disabled on your host\n");
4431 #endif
4432 continue;
4433 default:
4434 vexxx_printf("ERROR: unknown insn family %08x\n", family);
4435 continue;
4436 }
4437 if (verbose > 0)
4438 vexxx_printf( "%s:\n", all_tests[i].name);
4439 for (j = 0; tests[j].name != NULL; j++) {
4440 if (check_name(tests[j].name, filter, exact))
4441 (*loop)(tests[j].name, tests[j].func);
4442 n++;
4443 }
4444 vexxx_printf("\n");
4445 }
4446 vexxx_printf( "All done. Tested %d different instructions\n", n);
4447 }
4448
4449 #if 0 // unused
4450 static void usage (void)
4451 {
4452 vexxx_printf(
4453 "test-ppc [-1] [-2] [-3] [-*] [-t <type>] [-f <family>] [-u] "
4454 "[-n <filter>] [-x] [-h]\n"
4455 "\t-1: test opcodes with one argument\n"
4456 "\t-2: test opcodes with two arguments\n"
4457 "\t-3: test opcodes with three arguments\n"
4458 "\t-*: launch test without checking the number of arguments\n"
4459 "\t-t: launch test for instructions of type <type>\n"
4460 "\t recognized types:\n"
4461 "\t\tarith (or a)\n"
4462 "\t\tlogical (or l)\n"
4463 "\t\tcompare (or c)\n"
4464 "\t-f: launch test for instructions of family <family>\n"
4465 "\t recognized families:\n"
4466 "\t\tinteger (or i)\n"
4467 "\t\tfloat (or f)\n"
4468 "\t\tppc405 (or mac)\n"
4469 "\t\taltivec (or a)\n"
4470 "\t-u: test instructions that update flags\n"
4471 "\t-n: filter instructions with <filter>\n"
4472 "\t <filter> can be in two forms:\n"
4473 "\t\tname : filter functions that exactly match <name>\n"
4474 "\t\tname* : filter functions that start with <name>\n"
4475 "\t-h: print this help\n"
4476 );
4477 }
4478 #endif
4479
4480 int _main (int argc, char **argv)
4481 {
4482 unsigned char /* *tmp, */ *filter = NULL;
4483 int one_arg = 0, two_args = 0, three_args = 0;
4484 int arith = 0, logical = 0, compare = 0;
4485 int integer = 0, floats = 0, p405 = 0, altivec = 0, faltivec = 0;
4486 int cr = -1;
4487 //int c;
4488
4489 // while ((c = getopt(argc, argv, "123t:f:n:uvh")) != -1) {
4490 // switch (c) {
4491 // case '1':
4492 // one_arg = 1;
4493 // break;
4494 // case '2':
4495 // two_args = 1;
4496 // break;
4497 // case '3':
4498 // three_args = 1;
4499 // break;
4500 // case 't':
4501 // tmp = optarg;
4502 // if (my_strcmp(tmp, "arith") == 0 || my_strcmp(tmp, "a") == 0) {
4503 // arith = 1;
4504 // } else if (my_strcmp(tmp, "logical") == 0 || my_strcmp(tmp, "l") == 0) {
4505 // logical = 1;
4506 // } else if (my_strcmp(tmp, "compare") == 0 || my_strcmp(tmp, "c") == 0) {
4507 // compare = 1;
4508 // } else {
4509 // goto bad_arg;
4510 // }
4511 // break;
4512 // case 'f':
4513 // tmp = optarg;
4514 // if (my_strcmp(tmp, "integer") == 0 || my_strcmp(tmp, "i") == 0) {
4515 // integer = 1;
4516 // } else if (my_strcmp(tmp, "float") == 0 || my_strcmp(tmp, "f") == 0) {
4517 // floats = 1;
4518 // } else if (my_strcmp(tmp, "ppc405") == 0 || my_strcmp(tmp, "mac") == 0) {
4519 // p405 = 1;
4520 // } else if (my_strcmp(tmp, "altivec") == 0 || my_strcmp(tmp, "a") == 0) {
4521 // altivec = 1;
4522 // faltivec = 1;
4523 // } else {
4524 // goto bad_arg;
4525 // }
4526 // break;
4527 // case 'n':
4528 // filter = optarg;
4529 // break;
4530 // case 'u':
4531 // cr = 1;
4532 // break;
4533 // case 'h':
4534 // usage();
4535 // return 0;
4536 // case 'v':
4537 // verbose++;
4538 // break;
4539 // default:
4540 // usage();
4541 // vexxx_printf( "Unknown argument: '%c'\n", c);
4542 // return 1;
4543 // bad_arg:
4544 // usage();
4545 // vexxx_printf( "Bad argument for '%c': '%s'\n", c, tmp);
4546 // return 1;
4547 // }
4548 // }
4549 // if (argc != optind) {
4550 // usage();
4551 // vexxx_printf( "Bad number of arguments\n");
4552 // return 1;
4553 // }
4554
4555 if (one_arg == 0 && two_args == 0 && three_args == 0) {
4556 one_arg = 1;
4557 two_args = 1;
4558 three_args = 1;
4559 }
4560 if (arith == 0 && logical == 0 && compare == 0) {
4561 arith = 1;
4562 logical = 1;
4563 compare = 1;
4564 }
4565 if (integer == 0 && floats == 0 && altivec == 0 && faltivec == 0 &&
4566 p405 == 0) {
4567 integer = 1;
4568 floats = 1;
4569 altivec = 1;
4570 faltivec = 1;
4571 p405 = 1;
4572 }
4573 if (cr == -1)
4574 cr = 2;
4575 build_iargs_table();
4576 build_fargs_table();
4577 build_ii16_table();
4578
4579 #if 1
4580 one_arg=1;
4581 two_args=1;
4582 three_args=1;
4583
4584 arith=1;
4585 logical=1;
4586 compare=1;
4587
4588 integer=1;
4589 floats=0;
4590
4591 p405=0;
4592 altivec=0;
4593 faltivec=0;
4594 #endif
4595
4596 do_tests(one_arg, two_args, three_args,
4597 arith, logical, compare,
4598 integer, floats, p405, altivec, faltivec,
4599 cr, filter);
4600
4601 return 0;
4602 }
4603
4604
4605 void entry ( HWord(*service)(HWord,HWord) )
4606 {
4607 char* argv[2] = { NULL, NULL };
4608 serviceFn = service;
4609 _main(0, argv);
4610 (*service)(0,0);
4611 }
Instrumentation framework for detecting many memory management and threading bugs, and profile your programs in detail.