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