1/*  Copyright (C) 2011 IBM
2
3 Author: Maynard Johnson <maynardj@us.ibm.com>
4
5 This program is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 License, or (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18 02111-1307, USA.
19
20 The GNU General Public License is contained in the file COPYING.
21 */
22
23#ifdef HAS_VSX
24
25#include <stdio.h>
26#include <stdint.h>
27#include <stdlib.h>
28#include <string.h>
29#include <malloc.h>
30#include <altivec.h>
31
32#ifndef __powerpc64__
33typedef uint32_t HWord_t;
34#else
35typedef uint64_t HWord_t;
36#endif /* __powerpc64__ */
37
38#ifdef VGP_ppc64le_linux
39#define isLE 1
40#else
41#define isLE 0
42#endif
43
44register HWord_t r14 __asm__ ("r14");
45register HWord_t r15 __asm__ ("r15");
46register HWord_t r16 __asm__ ("r16");
47register HWord_t r17 __asm__ ("r17");
48register double f14 __asm__ ("fr14");
49register double f15 __asm__ ("fr15");
50register double f16 __asm__ ("fr16");
51register double f17 __asm__ ("fr17");
52
53static volatile unsigned int cond_reg;
54
55#define ALLCR "cr0","cr1","cr2","cr3","cr4","cr5","cr6","cr7"
56
57#define SET_CR(_arg) \
58      __asm__ __volatile__ ("mtcr  %0" : : "b"(_arg) : ALLCR );
59
60#define SET_XER(_arg) \
61      __asm__ __volatile__ ("mtxer %0" : : "b"(_arg) : "xer" );
62
63#define GET_CR(_lval) \
64      __asm__ __volatile__ ("mfcr %0"  : "=b"(_lval) )
65
66#define GET_XER(_lval) \
67      __asm__ __volatile__ ("mfxer %0" : "=b"(_lval) )
68
69#define GET_CR_XER(_lval_cr,_lval_xer) \
70   do { GET_CR(_lval_cr); GET_XER(_lval_xer); } while (0)
71
72#define SET_CR_ZERO \
73      SET_CR(0)
74
75#define SET_XER_ZERO \
76      SET_XER(0)
77
78#define SET_CR_XER_ZERO \
79   do { SET_CR_ZERO; SET_XER_ZERO; } while (0)
80
81#define SET_FPSCR_ZERO \
82   do { double _d = 0.0; \
83        __asm__ __volatile__ ("mtfsf 0xFF, %0" : : "f"(_d) ); \
84   } while (0)
85
86
87typedef void (*test_func_t)(void);
88typedef struct ldst_test ldst_test_t;
89typedef struct vsx_logic_test logic_test_t;
90typedef struct xs_conv_test xs_conv_test_t;
91typedef struct p7_fp_test fp_test_t;
92typedef struct vx_fp_test vx_fp_test_t;
93typedef struct vsx_move_test move_test_t;
94typedef struct vsx_permute_test permute_test_t;
95typedef struct test_table test_table_t;
96
97static double *fargs = NULL;
98static int nb_fargs;
99
100/* These functions below that construct a table of floating point
101 * values were lifted from none/tests/ppc32/jm-insns.c.
102 */
103
104#if defined (DEBUG_ARGS_BUILD)
105#define AB_DPRINTF(fmt, args...) do { fprintf(stderr, fmt , ##args); } while (0)
106#else
107#define AB_DPRINTF(fmt, args...) do { } while (0)
108#endif
109
110static inline void register_farg (void *farg,
111                                  int s, uint16_t _exp, uint64_t mant)
112{
113   uint64_t tmp;
114
115   tmp = ((uint64_t)s << 63) | ((uint64_t)_exp << 52) | mant;
116   *(uint64_t *)farg = tmp;
117   AB_DPRINTF("%d %03x %013llx => %016llx %0e\n",
118              s, _exp, mant, *(uint64_t *)farg, *(double *)farg);
119}
120
121static void build_fargs_table(void)
122/*
123 * Double precision:
124 * Sign goes from zero to one               (1 bit)
125 * Exponent goes from 0 to ((1 << 12) - 1)  (11 bits)
126 * Mantissa goes from 1 to ((1 << 52) - 1)  (52 bits)
127 * + special values:
128 * +0.0      : 0 0x000 0x0000000000000 => 0x0000000000000000
129 * -0.0      : 1 0x000 0x0000000000000 => 0x8000000000000000
130 * +infinity : 0 0x7FF 0x0000000000000 => 0x7FF0000000000000
131 * -infinity : 1 0x7FF 0x0000000000000 => 0xFFF0000000000000
132 * +QNaN     : 0 0x7FF 0x8000000000000 => 0x7FF8000000000000
133 * -QNaN     : 1 0x7FF 0x8000000000000 => 0xFFF8000000000000
134 * +SNaN     : 0 0x7FF 0x7FFFFFFFFFFFF => 0x7FF7FFFFFFFFFFFF
135 * -SNaN     : 1 0x7FF 0x7FFFFFFFFFFFF => 0xFFF7FFFFFFFFFFFF
136 * (8 values)
137 *
138 * Single precision
139 * Sign:     1 bit
140 * Exponent: 8 bits
141 * Mantissa: 23 bits
142 * +0.0      : 0 0x00 0x000000 => 0x00000000
143 * -0.0      : 1 0x00 0x000000 => 0x80000000
144 * +infinity : 0 0xFF 0x000000 => 0x7F800000
145 * -infinity : 1 0xFF 0x000000 => 0xFF800000
146 * +QNaN     : 0 0xFF 0x400000 => 0x7FC00000
147 * -QNaN     : 1 0xFF 0x400000 => 0xFFC00000
148 * +SNaN     : 0 0xFF 0x3FFFFF => 0x7FBFFFFF
149 * -SNaN     : 1 0xFF 0x3FFFFF => 0xFFBFFFFF
150*/
151{
152   uint64_t mant;
153   uint16_t _exp, e1;
154   int s;
155   int i=0;
156
157   if (nb_fargs)
158      return;
159
160   fargs = malloc( 16 * sizeof(double) );
161   for (s = 0; s < 2; s++) {
162      for (e1 = 0x001;; e1 = ((e1 + 1) << 13) + 7) {
163         if (e1 >= 0x400)
164            e1 = 0x3fe;
165         _exp = e1;
166         for (mant = 0x0000000000001ULL; mant < (1ULL << 52);
167         /* Add 'random' bits */
168         mant = ((mant + 0x4A6) << 29) + 0x359) {
169            register_farg( &fargs[i++], s, _exp, mant );
170         }
171         if (e1 == 0x3fe)
172            break;
173      }
174   }
175   // add a few smaller values to fargs . . .
176   s = 0;
177   _exp = 0x002;
178   mant = 0x0000000000b01ULL;
179   register_farg(&fargs[i++], s, _exp, mant);
180
181   _exp = 0x000;
182   mant = 0x00000203f0b3dULL;
183   register_farg(&fargs[i++], s, _exp, mant);
184
185   mant = 0x00000005a203dULL;
186   register_farg(&fargs[i++], s, _exp, mant);
187
188   s = 1;
189   _exp = 0x002;
190   mant = 0x0000000000b01ULL;
191   register_farg(&fargs[i++], s, _exp, mant);
192
193   _exp = 0x000;
194   mant = 0x00000203f0b3dULL;
195   register_farg(&fargs[i++], s, _exp, mant);
196
197   nb_fargs = i;
198}
199
200
201typedef struct fp_test_args {
202   int fra_idx;
203   int frb_idx;
204   int cr_flags;
205} fp_test_args_t;
206
207
208fp_test_args_t ftdiv_tests[] = {
209                              {0, 1, 0x8},
210                              {9, 1, 0xa},
211                              {1, 12, 0xa},
212                              {0, 2, 0xa},
213                              {1, 3, 0xa},
214                              {3, 0, 0xa},
215                              {0, 3, 0xa},
216                              {4, 0, 0xa},
217                              {7, 1, 0xe},
218                              {8, 1, 0xe},
219                              {1, 7, 0xe},
220                              {0, 13, 0xe},
221                              {5, 5, 0xe},
222                              {5, 6, 0xe},
223};
224
225fp_test_args_t xscmpX_tests[] = {
226                                   {8, 8, 0x2},
227                                   {8, 14, 0x8},
228                                   {8, 6, 0x8},
229                                   {8, 5, 0x8},
230                                   {8, 4, 0x8},
231                                   {8, 7, 0x8},
232                                   {8, 9, 0x1},
233                                   {8, 11, 0x1},
234                                   {14, 8, 0x4},
235                                   {14, 14, 0x2},
236                                   {14, 6, 0x8},
237                                   {14, 5, 0x8},
238                                   {14, 4, 0x8},
239                                   {14, 7, 0x8},
240                                   {14, 9, 0x1},
241                                   {14, 11, 0x1},
242                                   {6, 8, 0x4},
243                                   {6, 14, 0x4},
244                                   {6, 6, 0x2},
245                                   {6, 5, 0x2},
246                                   {6, 4, 0x8},
247                                   {6, 7, 0x8},
248                                   {6, 9, 0x1},
249                                   {6, 11, 0x1},
250                                   {5, 8, 0x4},
251                                   {5, 14, 0x4},
252                                   {5, 6, 0x2},
253                                   {5, 5, 0x2},
254                                   {5, 4, 0x8},
255                                   {5, 7, 0x8},
256                                   {5, 9, 0x1},
257                                   {5, 11, 0x1},
258                                   {4, 8, 0x4},
259                                   {4, 14, 0x4},
260                                   {4, 6, 0x4},
261                                   {4, 5, 0x4},
262                                   {4, 1, 0x8},
263                                   {4, 7, 0x8},
264                                   {4, 9, 0x1},
265                                   {4, 11, 0x1},
266                                   {7, 8, 0x4},
267                                   {7, 14, 0x4},
268                                   {7, 6, 0x4},
269                                   {7, 5, 0x4},
270                                   {7, 4, 0x4},
271                                   {7, 7, 0x2},
272                                   {7, 9, 0x1},
273                                   {7, 11, 0x1},
274                                   {10, 8, 0x1},
275                                   {10, 14, 0x1},
276                                   {10, 6, 0x1},
277                                   {10, 5, 0x1},
278                                   {10, 4, 0x1},
279                                   {10, 7, 0x1},
280                                   {10, 9, 0x1},
281                                   {10, 11, 0x1},
282                                   {12, 8, 0x1},
283                                   {12, 14, 0x1},
284                                   {12, 6, 0x1},
285                                   {12, 5, 0x1},
286                                   {12, 4, 0x1},
287                                   {12, 7, 0x1},
288                                   {12, 9, 0x1},
289                                   {12, 11, 0x1},
290};
291
292fp_test_args_t xsadddp_tests[] = {
293                                   {8, 8, 0x0},
294                                   {8, 14, 0x0},
295                                   {8, 6, 0x0},
296                                   {8, 5, 0x0},
297                                   {8, 4, 0x0},
298                                   {8, 7, 0x0},
299                                   {8, 9, 0x0},
300                                   {8, 11, 0x0},
301                                   {14, 8, 0x0},
302                                   {14, 14, 0x0},
303                                   {14, 6, 0x0},
304                                   {14, 5, 0x0},
305                                   {14, 4, 0x0},
306                                   {14, 7, 0x0},
307                                   {14, 9, 0x0},
308                                   {14, 11, 0x0},
309                                   {6, 8, 0x0},
310                                   {6, 14, 0x0},
311                                   {6, 6, 0x0},
312                                   {6, 5, 0x0},
313                                   {6, 4, 0x0},
314                                   {6, 7, 0x0},
315                                   {6, 9, 0x0},
316                                   {6, 11, 0x0},
317                                   {5, 8, 0x0},
318                                   {5, 14, 0x0},
319                                   {5, 6, 0x0},
320                                   {5, 5, 0x0},
321                                   {5, 4, 0x0},
322                                   {5, 7, 0x0},
323                                   {5, 9, 0x0},
324                                   {5, 11, 0x0},
325                                   {4, 8, 0x0},
326                                   {4, 14, 0x0},
327                                   {4, 6, 0x0},
328                                   {4, 5, 0x0},
329                                   {4, 1, 0x0},
330                                   {4, 7, 0x0},
331                                   {4, 9, 0x0},
332                                   {4, 11, 0x0},
333                                   {7, 8, 0x0},
334                                   {7, 14, 0x0},
335                                   {7, 6, 0x0},
336                                   {7, 5, 0x0},
337                                   {7, 4, 0x0},
338                                   {7, 7, 0x0},
339                                   {7, 9, 0x0},
340                                   {7, 11, 0x0},
341                                   {10, 8, 0x0},
342                                   {10, 14, 0x0},
343                                   {10, 6, 0x0},
344                                   {10, 5, 0x0},
345                                   {10, 4, 0x0},
346                                   {10, 7, 0x0},
347                                   {10, 9, 0x0},
348                                   {10, 11, 0x0},
349                                   {12, 8, 0x0},
350                                   {12, 14, 0x0},
351                                   {12, 6, 0x0},
352                                   {12, 5, 0x0},
353                                   {12, 4, 0x0},
354                                   {12, 7, 0x0},
355                                   {12, 9, 0x0},
356                                   {12, 11, 0x0},
357};
358
359fp_test_args_t xsdivdp_tests[] = {
360                                   {8, 8, 0x0},
361                                   {8, 14, 0x0},
362                                   {8, 6, 0x0},
363                                   {8, 5, 0x0},
364                                   {8, 4, 0x0},
365                                   {8, 7, 0x0},
366                                   {8, 9, 0x0},
367                                   {8, 11, 0x0},
368                                   {14, 8, 0x0},
369                                   {14, 14, 0x0},
370                                   {14, 6, 0x0},
371                                   {14, 5, 0x0},
372                                   {14, 4, 0x0},
373                                   {14, 7, 0x0},
374                                   {14, 9, 0x0},
375                                   {14, 11, 0x0},
376                                   {6, 8, 0x0},
377                                   {6, 14, 0x0},
378                                   {6, 6, 0x0},
379                                   {6, 5, 0x0},
380                                   {6, 4, 0x0},
381                                   {6, 7, 0x0},
382                                   {6, 9, 0x0},
383                                   {6, 11, 0x0},
384                                   {5, 8, 0x0},
385                                   {5, 14, 0x0},
386                                   {5, 6, 0x0},
387                                   {5, 5, 0x0},
388                                   {5, 4, 0x0},
389                                   {5, 7, 0x0},
390                                   {5, 9, 0x0},
391                                   {5, 11, 0x0},
392                                   {4, 8, 0x0},
393                                   {4, 14, 0x0},
394                                   {4, 6, 0x0},
395                                   {4, 5, 0x0},
396                                   {4, 1, 0x0},
397                                   {4, 7, 0x0},
398                                   {4, 9, 0x0},
399                                   {4, 11, 0x0},
400                                   {7, 8, 0x0},
401                                   {7, 14, 0x0},
402                                   {7, 6, 0x0},
403                                   {7, 5, 0x0},
404                                   {7, 4, 0x0},
405                                   {7, 7, 0x0},
406                                   {7, 9, 0x0},
407                                   {7, 11, 0x0},
408                                   {10, 8, 0x0},
409                                   {10, 14, 0x0},
410                                   {10, 6, 0x0},
411                                   {10, 5, 0x0},
412                                   {10, 4, 0x0},
413                                   {10, 7, 0x0},
414                                   {10, 9, 0x0},
415                                   {10, 11, 0x0},
416                                   {12, 8, 0x0},
417                                   {12, 14, 0x0},
418                                   {12, 6, 0x0},
419                                   {12, 5, 0x0},
420                                   {12, 4, 0x0},
421                                   {12, 7, 0x0},
422                                   {12, 9, 0x0},
423                                   {12, 11, 0x0},
424};
425
426fp_test_args_t xsmaddXdp_tests[] = {
427                                   {8, 8, 0x0},
428                                   {8, 14, 0x0},
429                                   {8, 6, 0x0},
430                                   {8, 5, 0x0},
431                                   {8, 4, 0x0},
432                                   {8, 7, 0x0},
433                                   {8, 9, 0x0},
434                                   {8, 11, 0x0},
435                                   {14, 8, 0x0},
436                                   {14, 14, 0x0},
437                                   {14, 6, 0x0},
438                                   {14, 5, 0x0},
439                                   {14, 4, 0x0},
440                                   {14, 7, 0x0},
441                                   {14, 9, 0x0},
442                                   {14, 11, 0x0},
443                                   {6, 8, 0x0},
444                                   {6, 14, 0x0},
445                                   {6, 6, 0x0},
446                                   {6, 5, 0x0},
447                                   {6, 4, 0x0},
448                                   {6, 7, 0x0},
449                                   {6, 9, 0x0},
450                                   {6, 11, 0x0},
451                                   {5, 8, 0x0},
452                                   {5, 14, 0x0},
453                                   {5, 6, 0x0},
454                                   {5, 5, 0x0},
455                                   {5, 4, 0x0},
456                                   {5, 7, 0x0},
457                                   {5, 9, 0x0},
458                                   {5, 11, 0x0},
459                                   {4, 8, 0x0},
460                                   {4, 14, 0x0},
461                                   {4, 6, 0x0},
462                                   {4, 5, 0x0},
463                                   {4, 1, 0x0},
464                                   {4, 7, 0x0},
465                                   {4, 9, 0x0},
466                                   {4, 11, 0x0},
467                                   {7, 8, 0x0},
468                                   {7, 14, 0x0},
469                                   {7, 6, 0x0},
470                                   {7, 5, 0x0},
471                                   {7, 4, 0x0},
472                                   {7, 7, 0x0},
473                                   {7, 9, 0x0},
474                                   {7, 11, 0x0},
475                                   {10, 8, 0x0},
476                                   {10, 14, 0x0},
477                                   {10, 6, 0x0},
478                                   {10, 5, 0x0},
479                                   {10, 4, 0x0},
480                                   {10, 7, 0x0},
481                                   {10, 9, 0x0},
482                                   {10, 11, 0x0},
483                                   {12, 8, 0x0},
484                                   {12, 14, 0x0},
485                                   {12, 6, 0x0},
486                                   {12, 5, 0x0},
487                                   {12, 4, 0x0},
488                                   {12, 7, 0x0},
489                                   {12, 9, 0x0},
490                                   {12, 11, 0x0},
491};
492
493fp_test_args_t xsmsubXdp_tests[] = {
494                                   {8, 8, 0x0},
495                                   {8, 14, 0x0},
496                                   {8, 6, 0x0},
497                                   {8, 5, 0x0},
498                                   {8, 4, 0x0},
499                                   {8, 7, 0x0},
500                                   {8, 9, 0x0},
501                                   {8, 11, 0x0},
502                                   {14, 8, 0x0},
503                                   {14, 14, 0x0},
504                                   {14, 6, 0x0},
505                                   {14, 5, 0x0},
506                                   {14, 4, 0x0},
507                                   {14, 7, 0x0},
508                                   {14, 9, 0x0},
509                                   {14, 11, 0x0},
510                                   {6, 8, 0x0},
511                                   {6, 14, 0x0},
512                                   {6, 6, 0x0},
513                                   {6, 5, 0x0},
514                                   {6, 4, 0x0},
515                                   {6, 7, 0x0},
516                                   {6, 9, 0x0},
517                                   {6, 11, 0x0},
518                                   {5, 8, 0x0},
519                                   {5, 14, 0x0},
520                                   {5, 6, 0x0},
521                                   {5, 5, 0x0},
522                                   {5, 4, 0x0},
523                                   {5, 7, 0x0},
524                                   {5, 9, 0x0},
525                                   {5, 11, 0x0},
526                                   {4, 8, 0x0},
527                                   {4, 14, 0x0},
528                                   {4, 6, 0x0},
529                                   {4, 5, 0x0},
530                                   {4, 1, 0x0},
531                                   {4, 7, 0x0},
532                                   {4, 9, 0x0},
533                                   {4, 11, 0x0},
534                                   {7, 8, 0x0},
535                                   {7, 14, 0x0},
536                                   {7, 6, 0x0},
537                                   {7, 5, 0x0},
538                                   {7, 4, 0x0},
539                                   {7, 7, 0x0},
540                                   {7, 9, 0x0},
541                                   {7, 11, 0x0},
542                                   {10, 8, 0x0},
543                                   {10, 14, 0x0},
544                                   {10, 6, 0x0},
545                                   {10, 5, 0x0},
546                                   {10, 4, 0x0},
547                                   {10, 7, 0x0},
548                                   {10, 9, 0x0},
549                                   {10, 11, 0x0},
550                                   {12, 8, 0x0},
551                                   {12, 14, 0x0},
552                                   {12, 6, 0x0},
553                                   {12, 5, 0x0},
554                                   {12, 4, 0x0},
555                                   {12, 7, 0x0},
556                                   {12, 9, 0x0},
557                                   {12, 11, 0x0},
558};
559
560fp_test_args_t xsnmaddXdp_tests[] = {
561                                     {8, 8, 0x0},
562                                     {8, 14, 0x0},
563                                     {8, 6, 0x0},
564                                     {8, 5, 0x0},
565                                     {8, 4, 0x0},
566                                     {8, 7, 0x0},
567                                     {8, 9, 0x0},
568                                     {8, 11, 0x0},
569                                     {14, 8, 0x0},
570                                     {14, 14, 0x0},
571                                     {14, 6, 0x0},
572                                     {14, 5, 0x0},
573                                     {14, 4, 0x0},
574                                     {14, 7, 0x0},
575                                     {14, 9, 0x0},
576                                     {14, 11, 0x0},
577                                     {6, 8, 0x0},
578                                     {6, 14, 0x0},
579                                     {6, 6, 0x0},
580                                     {6, 5, 0x0},
581                                     {6, 4, 0x0},
582                                     {6, 7, 0x0},
583                                     {6, 9, 0x0},
584                                     {6, 11, 0x0},
585                                     {5, 8, 0x0},
586                                     {5, 14, 0x0},
587                                     {5, 6, 0x0},
588                                     {5, 5, 0x0},
589                                     {5, 4, 0x0},
590                                     {5, 7, 0x0},
591                                     {5, 9, 0x0},
592                                     {5, 11, 0x0},
593                                     {4, 8, 0x0},
594                                     {4, 14, 0x0},
595                                     {4, 6, 0x0},
596                                     {4, 5, 0x0},
597                                     {4, 1, 0x0},
598                                     {4, 7, 0x0},
599                                     {4, 9, 0x0},
600                                     {4, 11, 0x0},
601                                     {7, 8, 0x0},
602                                     {7, 14, 0x0},
603                                     {7, 6, 0x0},
604                                     {7, 5, 0x0},
605                                     {7, 4, 0x0},
606                                     {7, 7, 0x0},
607                                     {7, 9, 0x0},
608                                     {7, 11, 0x0},
609                                     {10, 8, 0x0},
610                                     {10, 14, 0x0},
611                                     {10, 6, 0x0},
612                                     {10, 5, 0x0},
613                                     {10, 4, 0x0},
614                                     {10, 7, 0x0},
615                                     {10, 9, 0x0},
616                                     {10, 11, 0x0},
617                                     {12, 8, 0x0},
618                                     {12, 14, 0x0},
619                                     {12, 6, 0x0},
620                                     {12, 5, 0x0},
621                                     {12, 4, 0x0},
622                                     {12, 7, 0x0},
623                                     {12, 9, 0x0},
624                                     {12, 11, 0x0},
625};
626
627fp_test_args_t xsmuldp_tests[] = {
628                                  {8, 8, 0x0},
629                                  {8, 14, 0x0},
630                                  {8, 6, 0x0},
631                                  {8, 5, 0x0},
632                                  {8, 4, 0x0},
633                                  {8, 7, 0x0},
634                                  {8, 9, 0x0},
635                                  {8, 11, 0x0},
636                                  {14, 8, 0x0},
637                                  {14, 14, 0x0},
638                                  {14, 6, 0x0},
639                                  {14, 5, 0x0},
640                                  {14, 4, 0x0},
641                                  {14, 7, 0x0},
642                                  {14, 9, 0x0},
643                                  {14, 11, 0x0},
644                                  {6, 8, 0x0},
645                                  {6, 14, 0x0},
646                                  {6, 6, 0x0},
647                                  {6, 5, 0x0},
648                                  {6, 4, 0x0},
649                                  {6, 7, 0x0},
650                                  {6, 9, 0x0},
651                                  {6, 11, 0x0},
652                                  {5, 8, 0x0},
653                                  {5, 14, 0x0},
654                                  {5, 6, 0x0},
655                                  {5, 5, 0x0},
656                                  {5, 4, 0x0},
657                                  {5, 7, 0x0},
658                                  {5, 9, 0x0},
659                                  {5, 11, 0x0},
660                                  {4, 8, 0x0},
661                                  {4, 14, 0x0},
662                                  {4, 6, 0x0},
663                                  {4, 5, 0x0},
664                                  {4, 1, 0x0},
665                                  {4, 7, 0x0},
666                                  {4, 9, 0x0},
667                                  {4, 11, 0x0},
668                                  {7, 8, 0x0},
669                                  {7, 14, 0x0},
670                                  {7, 6, 0x0},
671                                  {7, 5, 0x0},
672                                  {7, 4, 0x0},
673                                  {7, 7, 0x0},
674                                  {7, 9, 0x0},
675                                  {7, 11, 0x0},
676                                  {10, 8, 0x0},
677                                  {10, 14, 0x0},
678                                  {10, 6, 0x0},
679                                  {10, 5, 0x0},
680                                  {10, 4, 0x0},
681                                  {10, 7, 0x0},
682                                  {10, 9, 0x0},
683                                  {10, 11, 0x0},
684                                  {12, 8, 0x0},
685                                  {12, 14, 0x0},
686                                  {12, 6, 0x0},
687                                  {12, 5, 0x0},
688                                  {12, 4, 0x0},
689                                  {12, 7, 0x0},
690                                  {12, 9, 0x0},
691                                  {12, 11, 0x0},
692};
693
694fp_test_args_t xssubdp_tests[] = {
695                                  {8, 8, 0x0},
696                                  {8, 14, 0x0},
697                                  {8, 6, 0x0},
698                                  {8, 5, 0x0},
699                                  {8, 4, 0x0},
700                                  {8, 7, 0x0},
701                                  {8, 9, 0x0},
702                                  {8, 11, 0x0},
703                                  {14, 8, 0x0},
704                                  {14, 14, 0x0},
705                                  {14, 6, 0x0},
706                                  {14, 5, 0x0},
707                                  {14, 4, 0x0},
708                                  {14, 7, 0x0},
709                                  {14, 9, 0x0},
710                                  {14, 11, 0x0},
711                                  {6, 8, 0x0},
712                                  {6, 14, 0x0},
713                                  {6, 6, 0x0},
714                                  {6, 5, 0x0},
715                                  {6, 4, 0x0},
716                                  {6, 7, 0x0},
717                                  {6, 9, 0x0},
718                                  {6, 11, 0x0},
719                                  {5, 8, 0x0},
720                                  {5, 14, 0x0},
721                                  {5, 6, 0x0},
722                                  {5, 5, 0x0},
723                                  {5, 4, 0x0},
724                                  {5, 7, 0x0},
725                                  {5, 9, 0x0},
726                                  {5, 11, 0x0},
727                                  {4, 8, 0x0},
728                                  {4, 14, 0x0},
729                                  {4, 6, 0x0},
730                                  {4, 5, 0x0},
731                                  {4, 1, 0x0},
732                                  {4, 7, 0x0},
733                                  {4, 9, 0x0},
734                                  {4, 11, 0x0},
735                                  {7, 8, 0x0},
736                                  {7, 14, 0x0},
737                                  {7, 6, 0x0},
738                                  {7, 5, 0x0},
739                                  {7, 4, 0x0},
740                                  {7, 7, 0x0},
741                                  {7, 9, 0x0},
742                                  {7, 11, 0x0},
743                                  {10, 8, 0x0},
744                                  {10, 14, 0x0},
745                                  {10, 6, 0x0},
746                                  {10, 5, 0x0},
747                                  {10, 4, 0x0},
748                                  {10, 7, 0x0},
749                                  {10, 9, 0x0},
750                                  {10, 11, 0x0},
751                                  {12, 8, 0x0},
752                                  {12, 14, 0x0},
753                                  {12, 6, 0x0},
754                                  {12, 5, 0x0},
755                                  {12, 4, 0x0},
756                                  {12, 7, 0x0},
757                                  {12, 9, 0x0},
758                                  {12, 11, 0x0},
759};
760
761
762
763static int nb_special_fargs;
764static double * spec_fargs;
765
766static void build_special_fargs_table(void)
767{
768   /* The special floating point values created below are for
769    * use in the ftdiv tests for setting the fe_flag and fg_flag,
770    * but they can also be used for other tests (e.g., xscmpudp).
771    *
772    * Note that fl_flag is 'always '1' on ppc64 Linux.
773    *
774  Entry  Sign Exp   fraction                  Special value
775   0      0   3fd   0x8000000000000ULL         Positive finite number
776   1      0   404   0xf000000000000ULL         ...
777   2      0   001   0x8000000b77501ULL         ...
778   3      0   7fe   0x800000000051bULL         ...
779   4      0   012   0x3214569900000ULL         ...
780   5      0   000   0x0000000000000ULL         +0.0 (+zero)
781   6      1   000   0x0000000000000ULL         -0.0 (-zero)
782   7      0   7ff   0x0000000000000ULL         +infinity
783   8      1   7ff   0x0000000000000ULL         -infinity
784   9      0   7ff   0x7FFFFFFFFFFFFULL         +SNaN
785   10     1   7ff   0x7FFFFFFFFFFFFULL         -SNaN
786   11     0   7ff   0x8000000000000ULL         +QNaN
787   12     1   7ff   0x8000000000000ULL         -QNaN
788   13     1   000   0x8340000078000ULL         Denormalized val (zero exp and non-zero fraction)
789   14     1   40d   0x0650f5a07b353ULL         Negative finite number
790    */
791
792   uint64_t mant;
793   uint16_t _exp;
794   int s;
795   int i = 0;
796
797   if (spec_fargs)
798      return;
799
800   spec_fargs = malloc( 16 * sizeof(double) );
801
802   // #0
803   s = 0;
804   _exp = 0x3fd;
805   mant = 0x8000000000000ULL;
806   register_farg(&spec_fargs[i++], s, _exp, mant);
807
808   // #1
809   s = 0;
810   _exp = 0x404;
811   mant = 0xf000000000000ULL;
812   register_farg(&spec_fargs[i++], s, _exp, mant);
813
814   /* None of the ftdiv tests succeed.
815    * FRA = value #0; FRB = value #1
816    * ea_ = -2; e_b = 5
817    * fl_flag || fg_flag || fe_flag = 100
818    */
819
820   /*************************************************
821    *     fe_flag tests
822    *
823    *************************************************/
824
825   /* fe_flag <- 1 if FRA is a NaN
826    * FRA = value #9; FRB = value #1
827    * e_a = 1024; e_b = 5
828    * fl_flag || fg_flag || fe_flag = 101
829    */
830
831   /* fe_flag <- 1 if FRB is a NaN
832    * FRA = value #1; FRB = value #12
833    * e_a = 5; e_b = 1024
834    * fl_flag || fg_flag || fe_flag = 101
835    */
836
837   /* fe_flag <- 1 if e_b <= -1022
838    * FRA = value #0; FRB = value #2
839    * e_a = -2; e_b = -1022
840    * fl_flag || fg_flag || fe_flag = 101
841    *
842    */
843   // #2
844   s = 0;
845   _exp = 0x001;
846   mant = 0x8000000b77501ULL;
847   register_farg(&spec_fargs[i++], s, _exp, mant);
848
849   /* fe_flag <- 1 if e_b >= 1021
850    * FRA = value #1; FRB = value #3
851    * e_a = 5; e_b = 1023
852    * fl_flag || fg_flag || fe_flag = 101
853    */
854   // #3
855   s = 0;
856   _exp = 0x7fe;
857   mant = 0x800000000051bULL;
858   register_farg(&spec_fargs[i++], s, _exp, mant);
859
860   /* fe_flag <- 1 if FRA != 0 && e_a - e_b >= 1023
861    * Let FRA = value #3 and FRB be value #0.
862    * e_a = 1023; e_b = -2
863    * fl_flag || fg_flag || fe_flag = 101
864    */
865
866   /* fe_flag <- 1 if FRA != 0 && e_a - e_b <= -1023
867    * Let FRA = value #0 above and FRB be value #3 above
868    * e_a = -2; e_b = 1023
869    * fl_flag || fg_flag || fe_flag = 101
870    */
871
872   /* fe_flag <- 1 if FRA != 0 && e_a <= -970
873    * Let FRA = value #4 and FRB be value #0
874    * e_a = -1005; e_b = -2
875    * fl_flag || fg_flag || fe_flag = 101
876   */
877   // #4
878   s = 0;
879   _exp = 0x012;
880   mant = 0x3214569900000ULL;
881   register_farg(&spec_fargs[i++], s, _exp, mant);
882
883   /*************************************************
884    *     fg_flag tests
885    *
886    *************************************************/
887   /* fg_flag <- 1 if FRA is an Infinity
888    * NOTE: FRA = Inf also sets fe_flag
889    * Do two tests, using values #7 and #8 (+/- Inf) for FRA.
890    * Test 1:
891    *   Let FRA be value #7 and FRB be value #1
892    *   e_a = 1024; e_b = 5
893    *   fl_flag || fg_flag || fe_flag = 111
894    *
895    * Test 2:
896    *   Let FRA be value #8 and FRB be value #1
897    *   e_a = 1024; e_b = 5
898    *   fl_flag || fg_flag || fe_flag = 111
899    *
900    */
901
902   /* fg_flag <- 1 if FRB is an Infinity
903    * NOTE: FRB = Inf also sets fe_flag
904    * Let FRA be value #1 and FRB be value #7
905    * e_a = 5; e_b = 1024
906    * fl_flag || fg_flag || fe_flag = 111
907    */
908
909   /* fg_flag <- 1 if FRB is denormalized
910    * NOTE: e_b < -1022 ==> fe_flag <- 1
911    * Let FRA be value #0 and FRB be value #13
912    * e_a = -2; e_b = -1023
913    * fl_flag || fg_flag || fe_flag = 111
914    */
915
916   /* fg_flag <- 1 if FRB is +zero
917    * NOTE: FRA = Inf also sets fe_flag
918    * Let FRA = val #5; FRB = val #5
919    * ea_ = -1023; e_b = -1023
920    * fl_flag || fg_flag || fe_flag = 111
921    */
922
923   /* fg_flag <- 1 if FRB is -zero
924    * NOTE: FRA = Inf also sets fe_flag
925    * Let FRA = val #5; FRB = val #6
926    * ea_ = -1023; e_b = -1023
927    * fl_flag || fg_flag || fe_flag = 111
928    */
929
930   /* Special values */
931   /* +0.0      : 0 0x000 0x0000000000000 */
932   // #5
933   s = 0;
934   _exp = 0x000;
935   mant = 0x0000000000000ULL;
936   register_farg(&spec_fargs[i++], s, _exp, mant);
937
938   /* -0.0      : 1 0x000 0x0000000000000 */
939   // #6
940   s = 1;
941   _exp = 0x000;
942   mant = 0x0000000000000ULL;
943   register_farg(&spec_fargs[i++], s, _exp, mant);
944
945   /* +infinity : 0 0x7FF 0x0000000000000  */
946   // #7
947   s = 0;
948   _exp = 0x7FF;
949   mant = 0x0000000000000ULL;
950   register_farg(&spec_fargs[i++], s, _exp, mant);
951
952   /* -infinity : 1 0x7FF 0x0000000000000 */
953   // #8
954   s = 1;
955   _exp = 0x7FF;
956   mant = 0x0000000000000ULL;
957   register_farg(&spec_fargs[i++], s, _exp, mant);
958
959   /* +SNaN     : 0 0x7FF 0x7FFFFFFFFFFFF */
960   // #9
961   s = 0;
962   _exp = 0x7FF;
963   mant = 0x7FFFFFFFFFFFFULL;
964   register_farg(&spec_fargs[i++], s, _exp, mant);
965
966   /* -SNaN     : 1 0x7FF 0x7FFFFFFFFFFFF */
967   // #10
968   s = 1;
969   _exp = 0x7FF;
970   mant = 0x7FFFFFFFFFFFFULL;
971   register_farg(&spec_fargs[i++], s, _exp, mant);
972
973   /* +QNaN     : 0 0x7FF 0x8000000000000 */
974   // #11
975   s = 0;
976   _exp = 0x7FF;
977   mant = 0x8000000000000ULL;
978   register_farg(&spec_fargs[i++], s, _exp, mant);
979
980   /* -QNaN     : 1 0x7FF 0x8000000000000 */
981   // #12
982   s = 1;
983   _exp = 0x7FF;
984   mant = 0x8000000000000ULL;
985   register_farg(&spec_fargs[i++], s, _exp, mant);
986
987   /* denormalized value */
988   // #13
989   s = 1;
990   _exp = 0x000;
991   mant = 0x8340000078000ULL;
992   register_farg(&spec_fargs[i++], s, _exp, mant);
993
994   /* Negative finite number */
995   // #14
996   s = 1;
997   _exp = 0x40d;
998   mant = 0x0650f5a07b353ULL;
999   register_farg(&spec_fargs[i++], s, _exp, mant);
1000
1001   nb_special_fargs = i;
1002}
1003
1004
1005struct test_table
1006{
1007   test_func_t test_category;
1008   char * name;
1009};
1010
1011struct p7_fp_test
1012{
1013   test_func_t test_func;
1014   const char *name;
1015   int single;  // 1=single precision result; 0=double precision result
1016};
1017
1018typedef enum {
1019   VX_FP_CMP,
1020   VX_FP_SMA,
1021   VX_FP_SMS,
1022   VX_FP_SNMA,
1023   VX_FP_OTHER
1024} vx_fp_test_type;
1025
1026struct vx_fp_test
1027{
1028   test_func_t test_func;
1029   const char *name;
1030   fp_test_args_t * targs;
1031   int num_tests;
1032   vx_fp_test_type test_type;
1033};
1034
1035struct xs_conv_test
1036{
1037   test_func_t test_func;
1038   const char *name;
1039   int num_tests;
1040};
1041
1042typedef enum {
1043   VSX_LOAD =1,
1044   VSX_LOAD_SPLAT,
1045   VSX_STORE
1046} vsx_ldst_type;
1047
1048struct ldst_test
1049{
1050   test_func_t test_func;
1051   const char *name;
1052   void * base_addr;
1053   uint32_t offset;
1054   int num_words_to_process;
1055   vsx_ldst_type type;
1056};
1057
1058typedef enum {
1059   VSX_AND = 1,
1060   VSX_XOR,
1061   VSX_ANDC,
1062   VSX_OR,
1063   VSX_NOR
1064} vsx_log_op;
1065
1066struct vsx_logic_test
1067{
1068   test_func_t test_func;
1069   const char *name;
1070   vsx_log_op op;
1071};
1072
1073struct vsx_move_test
1074{
1075   test_func_t test_func;
1076   const char *name;
1077};
1078
1079struct vsx_permute_test
1080{
1081   test_func_t test_func;
1082   const char *name;
1083   unsigned int xa[4];
1084   unsigned int xb[4];
1085};
1086
1087static vector unsigned int vec_out, vec_inA, vec_inB;
1088
1089static void test_lxsdx(void)
1090{
1091   __asm__ __volatile__ ("lxsdx          %x0, %1, %2" : "=wa" (vec_out): "b" (r14),"r" (r15));
1092}
1093
1094static void
1095test_lxvd2x(void)
1096{
1097   __asm__ __volatile__ ("lxvd2x          %x0, %1, %2" : "=wa" (vec_out): "b" (r14),"r" (r15));
1098}
1099
1100static void test_lxvdsx(void)
1101{
1102   __asm__ __volatile__ ("lxvdsx          %x0, %1, %2" : "=wa" (vec_out): "b" (r14),"r" (r15));
1103}
1104
1105static void test_lxvw4x(void)
1106{
1107   __asm__ __volatile__ ("lxvw4x          %x0, %1, %2" : "=wa" (vec_out): "b" (r14),"r" (r15));
1108}
1109
1110static void test_stxsdx(void)
1111{
1112   __asm__ __volatile__ ("stxsdx          %x0, %1, %2" : : "wa" (vec_inA), "b" (r14),"r" (r15));
1113}
1114
1115static void test_stxvd2x(void)
1116{
1117   __asm__ __volatile__ ("stxvd2x          %x0, %1, %2" : : "wa" (vec_inA), "b" (r14),"r" (r15));
1118}
1119
1120static void test_stxvw4x(void)
1121{
1122   __asm__ __volatile__ ("stxvw4x          %x0, %1, %2" : : "wa" (vec_inA), "b" (r14),"r" (r15));
1123}
1124
1125static void test_xxlxor(void)
1126{
1127   __asm__ __volatile__ ("xxlxor          %x0, %x1, %x2" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1128}
1129
1130static void test_xxlor(void)
1131{
1132   __asm__ __volatile__ ("xxlor          %x0, %x1, %x2" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1133}
1134
1135static void test_xxlnor(void)
1136{
1137   __asm__ __volatile__ ("xxlnor          %x0, %x1, %x2" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1138}
1139
1140static void test_xxland(void)
1141{
1142   __asm__ __volatile__ ("xxland          %x0, %x1, %x2" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1143}
1144
1145static void test_xxlandc(void)
1146{
1147   __asm__ __volatile__ ("xxlandc          %x0, %x1, %x2" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1148}
1149
1150static void test_xxmrghw(void)
1151{
1152   __asm__ __volatile__ ("xxmrghw          %x0, %x1, %x2" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1153}
1154
1155static void test_xxmrglw(void)
1156{
1157   __asm__ __volatile__ ("xxmrglw          %x0, %x1, %x2" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1158}
1159
1160static void test_xxpermdi_00(void)
1161{
1162   __asm__ __volatile__ ("xxpermdi         %x0, %x1, %x2, 0x0" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1163}
1164
1165static void test_xxpermdi_01(void)
1166{
1167   __asm__ __volatile__ ("xxpermdi         %x0, %x1, %x2, 0x1" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1168}
1169
1170static void test_xxpermdi_10(void)
1171{
1172   __asm__ __volatile__ ("xxpermdi         %x0, %x1, %x2, 0x2" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1173}
1174
1175static void test_xxpermdi_11(void)
1176{
1177   __asm__ __volatile__ ("xxpermdi         %x0, %x1, %x2, 0x3" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1178}
1179
1180static void test_xxsldwi_0(void)
1181{
1182   __asm__ __volatile__ ("xxsldwi         %x0, %x1, %x2, 0" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1183}
1184
1185static void test_xxsldwi_1(void)
1186{
1187   __asm__ __volatile__ ("xxsldwi         %x0, %x1, %x2, 1" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1188}
1189
1190static void test_xxsldwi_2(void)
1191{
1192   __asm__ __volatile__ ("xxsldwi         %x0, %x1, %x2, 2" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1193}
1194
1195static void test_xxsldwi_3(void)
1196{
1197   __asm__ __volatile__ ("xxsldwi         %x0, %x1, %x2, 3" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1198}
1199
1200static void test_fcfids (void)
1201{
1202    __asm__ __volatile__ ("fcfids          %0, %1" : "=f" (f17): "d" (f14));
1203}
1204
1205static void test_fcfidus (void)
1206{
1207    __asm__ __volatile__ ("fcfidus          %0, %1" : "=f" (f17): "d" (f14));
1208}
1209
1210static void test_fcfidu (void)
1211{
1212    __asm__ __volatile__ ("fcfidu          %0, %1" : "=f" (f17): "d" (f14));
1213}
1214
1215static void test_xsabsdp (void)
1216{
1217   __asm__ __volatile__ ("xsabsdp          %x0, %x1" : "=wa" (vec_out): "wa" (vec_inB));
1218}
1219
1220static void test_xscpsgndp (void)
1221{
1222   __asm__ __volatile__ ("xscpsgndp          %x0, %x1, %x2" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1223}
1224
1225static void test_xsnabsdp (void)
1226{
1227   __asm__ __volatile__ ("xsnabsdp          %x0, %x1" : "=wa" (vec_out): "wa" (vec_inB));
1228}
1229
1230static void test_xsnegdp (void)
1231{
1232   __asm__ __volatile__ ("xsnegdp          %x0, %x1" : "=wa" (vec_out): "wa" (vec_inB));
1233}
1234
1235static int do_cmpudp;
1236static void test_xscmp (void)
1237{
1238   if (do_cmpudp)
1239      __asm__ __volatile__ ("xscmpudp          cr1, %x0, %x1" : : "wa" (vec_inA),"wa" (vec_inB));
1240   else
1241      __asm__ __volatile__ ("xscmpodp          cr1, %x0, %x1" : : "wa" (vec_inA),"wa" (vec_inB));
1242}
1243
1244static void test_xsadddp(void)
1245{
1246   __asm__ __volatile__ ("xsadddp          %x0, %x1, %x2" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1247}
1248
1249static void test_xsdivdp(void)
1250{
1251   __asm__ __volatile__ ("xsdivdp          %x0, %x1, %x2" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1252}
1253
1254static int do_adp;
1255static void test_xsmadd(void)
1256{
1257   if (do_adp)
1258      __asm__ __volatile__ ("xsmaddadp          %x0, %x1, %x2" : "+wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1259   else
1260      __asm__ __volatile__ ("xsmaddmdp          %x0, %x1, %x2" : "+wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1261}
1262
1263static void test_xsmsub(void)
1264{
1265   if (do_adp)
1266      __asm__ __volatile__ ("xsmsubadp          %x0, %x1, %x2" : "+wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1267   else
1268      __asm__ __volatile__ ("xsmsubmdp          %x0, %x1, %x2" : "+wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1269}
1270
1271static void test_xsnmadd(void)
1272{
1273   if (do_adp)
1274      __asm__ __volatile__ ("xsnmaddadp          %x0, %x1, %x2" : "+wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1275   else
1276      __asm__ __volatile__ ("xsnmaddmdp          %x0, %x1, %x2" : "+wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1277}
1278
1279static void test_xsmuldp(void)
1280{
1281   __asm__ __volatile__ ("xsmuldp          %x0, %x1, %x2" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1282}
1283
1284static void test_xssubdp(void)
1285{
1286   __asm__ __volatile__ ("xssubdp          %x0, %x1, %x2" : "=wa" (vec_out): "wa" (vec_inA),"wa" (vec_inB));
1287}
1288
1289static void test_xscvdpsxds (void)
1290{
1291   __asm__ __volatile__ ("xscvdpsxds          %x0, %x1" : "=wa" (vec_out): "wa" (vec_inB));
1292}
1293
1294static void test_xscvsxddp (void)
1295{
1296   __asm__ __volatile__ ("xscvsxddp          %x0, %x1" : "=wa" (vec_out): "wa" (vec_inB));
1297}
1298
1299static void test_xscvuxddp (void)
1300{
1301   __asm__ __volatile__ ("xscvuxddp          %x0, %x1" : "=wa" (vec_out): "wa" (vec_inB));
1302}
1303
1304static unsigned int vstg[] __attribute__ ((aligned (16))) = { 0, 0, 0,0,
1305                                                              0, 0, 0, 0 };
1306
1307#define NUM_VSTG_INTS (sizeof vstg/sizeof vstg[0])
1308#define NUM_VSTG_VECS (NUM_VSTG_INTS/4)
1309
1310static unsigned int viargs[] __attribute__ ((aligned (16))) = { 0x01234567,
1311                                                                0x89abcdef,
1312                                                                0x00112233,
1313                                                                0x44556677,
1314                                                                0x8899aabb,
1315                                                                0x91929394,
1316                                                                0xa1a2a3a4,
1317                                                                0xb1b2b3b4,
1318                                                                0xc1c2c3c4,
1319                                                                0xd1d2d3d4,
1320                                                                0x7a6b5d3e
1321};
1322#define NUM_VIARGS_INTS (sizeof viargs/sizeof viargs[0])
1323#define NUM_VIARGS_VECS  (NUM_VIARGS_INTS/4)
1324
1325static ldst_test_t ldst_tests[] = { { &test_lxsdx, "lxsdx", viargs, 0, 2, VSX_LOAD },
1326                                     { &test_lxsdx, "lxsdx", viargs, 4, 2, VSX_LOAD },
1327                                     { &test_lxvd2x, "lxvd2x", viargs, 0, 4, VSX_LOAD },
1328                                     { &test_lxvd2x, "lxvd2x", viargs, 4, 4, VSX_LOAD },
1329                                     { &test_lxvdsx, "lxvdsx", viargs, 0, 4, VSX_LOAD_SPLAT },
1330                                     { &test_lxvdsx, "lxvdsx", viargs, 4, 4, VSX_LOAD_SPLAT },
1331                                     { &test_lxvw4x, "lxvw4x", viargs, 0, 4, VSX_LOAD },
1332                                     { &test_lxvw4x, "lxvw4x", viargs, 4, 4, VSX_LOAD },
1333                                     { &test_stxsdx, "stxsdx", vstg, 0, 2, VSX_STORE },
1334                                     { &test_stxsdx, "stxsdx", vstg, 4, 2, VSX_STORE },
1335                                     { &test_stxvd2x, "stxvd2x", vstg, 0, 4, VSX_STORE },
1336                                     { &test_stxvd2x, "stxvd2x", vstg, 4, 4, VSX_STORE },
1337                                     { &test_stxvw4x, "stxvw4x", vstg, 0, 4, VSX_STORE },
1338                                     { &test_stxvw4x, "stxvw4x", vstg, 4, 4, VSX_STORE },
1339                                     { NULL, NULL, NULL, 0, 0, 0 } };
1340
1341static logic_test_t logic_tests[] = { { &test_xxlxor, "xxlxor", VSX_XOR },
1342                                      { &test_xxlor, "xxlor", VSX_OR } ,
1343                                      { &test_xxlnor, "xxlnor", VSX_NOR },
1344                                      { &test_xxland, "xxland", VSX_AND },
1345                                      { &test_xxlandc, "xxlandc", VSX_ANDC },
1346                                      { NULL, NULL, 0}};
1347
1348static move_test_t move_tests[] = { { &test_xsabsdp, "xsabsdp" },
1349                                    { &test_xscpsgndp, "xscpsgndp" },
1350                                    { &test_xsnabsdp, "xsnabsdp" },
1351                                    { &test_xsnegdp, "xsnegdp" },
1352                                    { NULL, NULL }
1353
1354};
1355
1356static permute_test_t permute_tests[] =
1357{
1358  { &test_xxmrghw, "xxmrghw",
1359    { 0x11111111, 0x22222222, 0x33333333, 0x44444444 }, /* XA input */
1360    { 0x55555555, 0x66666666, 0x77777777, 0x88888888 }, /* XB input */
1361  },
1362  { &test_xxmrghw, "xxmrghw",
1363    { 0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff }, /* XA input */
1364    { 0x11111111, 0x22222222, 0x33333333, 0x44444444 }, /* XB input */
1365  },
1366  { &test_xxmrglw, "xxmrglw",
1367    { 0x11111111, 0x22222222, 0x33333333, 0x44444444 }, /* XA input */
1368    { 0x55555555, 0x66666666, 0x77777777, 0x88888888 }, /* XB input */
1369  },
1370  { &test_xxmrglw, "xxmrglw",
1371    { 0x00112233, 0x44556677, 0x8899aabb, 0xccddeeff}, /* XA input */
1372    { 0x11111111, 0x22222222, 0x33333333, 0x44444444}, /* XB input */
1373  },
1374  { &test_xxpermdi_00, "xxpermdi DM=00",
1375    { 0x11111111, 0x22222222, 0x33333333, 0x44444444 }, /* XA input */
1376    { 0x55555555, 0x66666666, 0x77777777, 0x88888888 }, /* XB input */
1377  },
1378  { &test_xxpermdi_01, "xxpermdi DM=01",
1379    { 0x11111111, 0x22222222, 0x33333333, 0x44444444 }, /* XA input */
1380    { 0x55555555, 0x66666666, 0x77777777, 0x88888888 }, /* XB input */
1381  },
1382  { &test_xxpermdi_10, "xxpermdi DM=10",
1383    { 0x11111111, 0x22222222, 0x33333333, 0x44444444 }, /* XA input */
1384    { 0x55555555, 0x66666666, 0x77777777, 0x88888888 }, /* XB input */
1385  },
1386  { &test_xxpermdi_11, "xxpermdi DM=11",
1387    { 0x11111111, 0x22222222, 0x33333333, 0x44444444 }, /* XA input */
1388    { 0x55555555, 0x66666666, 0x77777777, 0x88888888 }, /* XB input */
1389  },
1390  { &test_xxsldwi_0, "xxsldwi SHW=0",
1391    { 0x11111111, 0x22222222, 0x33333333, 0x44444444 }, /* XA input */
1392    { 0x55555555, 0x66666666, 0x77777777, 0x88888888 }, /* XB input */
1393  },
1394  { &test_xxsldwi_1, "xxsldwi SHW=1",
1395    { 0x11111111, 0x22222222, 0x33333333, 0x44444444 }, /* XA input */
1396    { 0x55555555, 0x66666666, 0x77777777, 0x88888888 }, /* XB input */
1397  },
1398  { &test_xxsldwi_2, "xxsldwi SHW=2",
1399    { 0x11111111, 0x22222222, 0x33333333, 0x44444444 }, /* XA input */
1400    { 0x55555555, 0x66666666, 0x77777777, 0x88888888 }, /* XB input */
1401  },
1402  { &test_xxsldwi_3, "xxsldwi SHW=3",
1403    { 0x11111111, 0x22222222, 0x33333333, 0x44444444 }, /* XA input */
1404    { 0x55555555, 0x66666666, 0x77777777, 0x88888888 }, /* XB input */
1405  },
1406  { NULL, NULL }
1407};
1408
1409static fp_test_t fp_tests[] = { { &test_fcfids, "fcfids", 1 },
1410                                { &test_fcfidus, "fcfidus", 1 },
1411                                { &test_fcfidu, "fcfidu", 1 },
1412                                { NULL, NULL, 0 },
1413
1414};
1415
1416static vx_fp_test_t vx_fp_tests[] = {
1417                                     { &test_xscmp, "xscmp", xscmpX_tests, 64, VX_FP_CMP},
1418                                     { &test_xsadddp, "xsadddp", xsadddp_tests, 64, VX_FP_OTHER},
1419                                     { &test_xsdivdp, "xsdivdp", xsdivdp_tests, 64, VX_FP_OTHER},
1420                                     { &test_xsmadd, "xsmadd", xsmaddXdp_tests, 64, VX_FP_SMA},
1421                                     { &test_xsmsub, "xsmsub", xsmsubXdp_tests, 64, VX_FP_SMS},
1422                                     { &test_xsnmadd, "xsnmadd", xsnmaddXdp_tests, 64, VX_FP_SNMA},
1423                                     { & test_xsmuldp, "xsmuldp", xsmuldp_tests, 64, VX_FP_OTHER},
1424                                     { & test_xssubdp, "xssubdp", xssubdp_tests, 64, VX_FP_OTHER},
1425                                     { NULL, NULL, NULL, 0, 0 }
1426};
1427
1428static xs_conv_test_t xs_conv_tests[] = {
1429                                         { &test_xscvdpsxds, "xscvdpsxds", 15},
1430                                         { &test_xscvsxddp, "xscvsxddp", 15},
1431                                         { &test_xscvuxddp, "xscvuxddp", 15},
1432                                         { NULL, NULL, 0}
1433};
1434
1435#ifdef __powerpc64__
1436static void test_ldbrx(void)
1437{
1438   int i;
1439   HWord_t reg_out;
1440   unsigned char * byteIn, * byteOut;
1441   r14 = (HWord_t)viargs;
1442   // Just try the instruction an arbitrary number of times at different r15 offsets.
1443   for (i = 0; i < 3; i++) {
1444      int j, k;
1445      reg_out = 0;
1446      r15 = i * 4;
1447      __asm__ __volatile__ ("ldbrx          %0, %1, %2" : "=r" (reg_out): "b" (r14),"r" (r15));
1448      byteIn = ((unsigned char *)(r14 + r15));
1449      byteOut = (unsigned char *)&reg_out;
1450
1451      printf("ldbrx:");
1452      for (k = 0; k < 8; k++) {
1453         printf( " %02x", (byteIn[k]));
1454      }
1455      printf(" (reverse) =>");
1456      for (j = 0; j < 8; j++) {
1457         printf( " %02x", (byteOut[j]));
1458      }
1459      printf("\n");
1460   }
1461   printf( "\n" );
1462}
1463
1464static void
1465test_popcntd(void)
1466{
1467   uint64_t res;
1468   unsigned long long src = 0x9182736405504536ULL;
1469   r14 = src;
1470   __asm__ __volatile__ ("popcntd          %0, %1" : "=r" (res): "r" (r14));
1471   printf("popcntd: 0x%llx => %d\n", src, (int)res);
1472   printf( "\n" );
1473}
1474#endif
1475
1476static void
1477test_lfiwzx(void)
1478{
1479   unsigned int i;
1480   unsigned int * src;
1481   uint64_t reg_out;
1482   r14 = (HWord_t)viargs;
1483   // Just try the instruction an arbitrary number of times at different r15 offsets.
1484   for (i = 0; i < 3; i++) {
1485      reg_out = 0;
1486      r15 = i * 4;
1487      __asm__ __volatile__ ("lfiwzx          %0, %1, %2" : "=d" (reg_out): "b" (r14),"r" (r15));
1488      src = ((unsigned int *)(r14 + r15));
1489      printf("lfiwzx: %u => %llu.00\n", *src, (unsigned long long)reg_out);
1490
1491   }
1492   printf( "\n" );
1493}
1494
1495static void test_vx_fp_ops(void)
1496{
1497
1498   test_func_t func;
1499   int k;
1500   char * test_name = (char *)malloc(20);
1501   k = 0;
1502
1503   build_special_fargs_table();
1504   while ((func = vx_fp_tests[k].test_func)) {
1505      int i, condreg, repeat = 0;
1506      unsigned int flags;
1507      unsigned long long * frap, * frbp, * dst;
1508      vx_fp_test_t test_group = vx_fp_tests[k];
1509      vx_fp_test_type test_type = test_group.test_type;
1510
1511      switch (test_type) {
1512         case VX_FP_CMP:
1513            strcpy(test_name, "xscmp");
1514            if (!repeat) {
1515               repeat = 1;
1516               strcat(test_name, "udp");
1517               do_cmpudp = 1;
1518            }
1519            break;
1520         case VX_FP_SMA:
1521         case VX_FP_SMS:
1522         case VX_FP_SNMA:
1523            if (test_type == VX_FP_SMA)
1524               strcpy(test_name, "xsmadd");
1525            else if (test_type == VX_FP_SMS)
1526               strcpy(test_name, "xsmsub");
1527            else
1528               strcpy(test_name, "xsnmadd");
1529            if (!repeat) {
1530               repeat = 1;
1531               strcat(test_name, "adp");
1532               do_adp = 1;
1533            }
1534            break;
1535         case VX_FP_OTHER:
1536            strcpy(test_name, test_group.name);
1537            break;
1538         default:
1539            printf("ERROR:  Invalid VX FP test type %d\n", test_type);
1540            exit(1);
1541      }
1542
1543again:
1544      for (i = 0; i < test_group.num_tests; i++) {
1545         unsigned int * inA, * inB, * pv;
1546         double * dpA = (double *)&vec_inA;
1547         double * dpB = (double *)&vec_inB;
1548         double * dpT = (double *)&vec_out;
1549
1550         fp_test_args_t aTest = test_group.targs[i];
1551         inA = (unsigned int *)&spec_fargs[aTest.fra_idx];
1552         inB = (unsigned int *)&spec_fargs[aTest.frb_idx];
1553         frap = (unsigned long long *)&spec_fargs[aTest.fra_idx];
1554         frbp = (unsigned long long *)&spec_fargs[aTest.frb_idx];
1555         // Only need to copy one doubleword into each vector's element 0
1556         if (isLE) {
1557            // With LE, vector element 0 is the second doubleword from the left
1558            memset(dpA, 0, 8);
1559            memset(dpB, 0, 8);
1560            dpA++;
1561            dpB++;
1562         }
1563         memcpy(dpA, inA, 8);
1564         memcpy(dpB, inB, 8);
1565
1566         switch (test_type) {
1567            case VX_FP_CMP:
1568               SET_FPSCR_ZERO;
1569               SET_CR_XER_ZERO;
1570               (*func)();
1571               GET_CR(flags);
1572               condreg = (flags & 0x0f000000) >> 24;
1573               printf("#%d: %s %016llx <=> %016llx ? %x (CRx)\n", i, test_name, *frap, *frbp, condreg);
1574              // printf("\tFRA: %e;  FRB: %e\n", spec_fargs[aTest.fra_idx], spec_fargs[aTest.frb_idx]);
1575               if ( condreg != aTest.cr_flags) {
1576                  printf("Error: Expected CR flags 0x%x; actual flags: 0x%x\n", aTest.cr_flags, condreg);
1577               }
1578               break;
1579            case VX_FP_SMA:
1580            case VX_FP_SMS:
1581            case VX_FP_SNMA:
1582            case VX_FP_OTHER:
1583            {
1584               int idx;
1585               unsigned long long vsr_XT;
1586               pv = (unsigned int *)&vec_out;
1587               // clear vec_out
1588               for (idx = 0; idx < 4; idx++, pv++)
1589                  *pv = 0;
1590
1591               if (test_type != VX_FP_OTHER) {
1592                  /* Then we need a third src argument, which is stored in element 0 of
1593                   * VSX[XT] -- i.e., vec_out.  For the xs<ZZZ>mdp cases, VSX[XT] holds
1594                   * src3 and VSX[XB] holds src2; for the xs<ZZZ>adp cases, VSX[XT] holds
1595                   * src2 and VSX[XB] holds src3.  The fp_test_args_t that holds the test
1596                   * data (input args) contain only two inputs, so I arbitrarily
1597                   * use spec_fargs elements 4 and 14 (alternating) for the third source
1598                   * argument.  We can use the same input data for a given pair of
1599                   * adp/mdp-type instructions by swapping the src2 and src3 arguments; thus
1600                   * the expected result should be the same.
1601                   */
1602                  int extra_arg_idx;
1603                  if (i % 2)
1604                     extra_arg_idx = 4;
1605                  else
1606                     extra_arg_idx = 14;
1607
1608                  if (repeat) {
1609                     /* We're on the first time through of one of the VX_FP_SMx
1610                      * test types, meaning we're testing a xs<ZZZ>adp case, thus we
1611                      * have to swap inputs as described above:
1612                      *    src2 <= VSX[XT]
1613                      *    src3 <= VSX[XB]
1614                      */
1615                     if (isLE)
1616                        dpT++;
1617                     memcpy(dpT, inB, 8);  // src2
1618                     memcpy(dpB, &spec_fargs[extra_arg_idx], 8);  //src3
1619                     frbp = (unsigned long long *)&spec_fargs[extra_arg_idx];
1620                  } else {
1621                     // Don't need to init src2, as it's done before the switch()
1622                     if (isLE)
1623                        dpT++;
1624                     memcpy(dpT, &spec_fargs[extra_arg_idx], 8);  //src3
1625                  }
1626                  memcpy(&vsr_XT, dpT, 8);
1627               }
1628
1629               (*func)();
1630               dst = (unsigned long long *) &vec_out;
1631               if (isLE)
1632                  dst++;
1633               if (test_type == VX_FP_OTHER)
1634                  printf("#%d: %s %016llx %016llx = %016llx\n", i, test_name, *frap, *frbp, *dst);
1635               else
1636                  printf( "#%d: %s %016llx %016llx %016llx = %016llx\n", i,
1637                          test_name, vsr_XT, *frap, *frbp, *dst );
1638
1639               /*
1640              {
1641                  // Debug code.  Keep this block commented out except when debugging.
1642                  double result, expected;
1643                  memcpy(&result, dst, 8);
1644                  memcpy(&expected, &aTest.dp_bin_result, 8);
1645                  printf( "\tFRA + FRB: %e + %e: Expected = %e; Actual = %e\n",
1646                          spec_fargs[aTest.fra_idx], spec_fargs[aTest.frb_idx],
1647                          expected, result );
1648               }
1649              */
1650               break;
1651            }
1652         }
1653
1654
1655      }
1656      printf( "\n" );
1657
1658      if (repeat) {
1659         repeat = 0;
1660         switch (test_type) {
1661            case VX_FP_CMP:
1662               strcpy(test_name, "xscmp");
1663               strcat(test_name, "odp");
1664               do_cmpudp = 0;
1665               break;
1666            case VX_FP_SMA:
1667            case VX_FP_SMS:
1668            case VX_FP_SNMA:
1669               if (test_type == VX_FP_SMA)
1670                  strcpy(test_name, "xsmadd");
1671               else if (test_type == VX_FP_SMS)
1672                  strcpy(test_name, "xsmsub");
1673               else
1674                  strcpy(test_name, "xsnmadd");
1675               strcat(test_name, "mdp");
1676               do_adp = 0;
1677               break;
1678            case VX_FP_OTHER:
1679               break;
1680         }
1681         goto again;
1682      }
1683      k++;
1684   }
1685   printf( "\n" );
1686   free(test_name);
1687}
1688
1689static void test_xs_conv_ops(void)
1690{
1691
1692   test_func_t func;
1693   int k = 0;
1694   double * dpB = (double *)&vec_inB;
1695   if (isLE) {
1696      memset(dpB, 0, 8);
1697      dpB++;
1698   }
1699
1700   build_special_fargs_table();
1701   while ((func = xs_conv_tests[k].test_func)) {
1702      int i;
1703      unsigned long long * frbp, * dst;
1704      xs_conv_test_t test_group = xs_conv_tests[k];
1705      for (i = 0; i < test_group.num_tests; i++) {
1706         unsigned int * inB, * pv;
1707         int idx;
1708         inB = (unsigned int *)&spec_fargs[i];
1709         frbp = (unsigned long long *)&spec_fargs[i];
1710
1711         memcpy(dpB, inB, 8);
1712         pv = (unsigned int *)&vec_out;
1713         // clear vec_out
1714         for (idx = 0; idx < 4; idx++, pv++)
1715            *pv = 0;
1716         (*func)();
1717         dst = (unsigned long long *) &vec_out;
1718         if (isLE)
1719            dst++;
1720         printf("#%d: %s %016llx => %016llx\n", i, test_group.name, *frbp, *dst);
1721
1722      }
1723      k++;
1724      printf("\n");
1725   }
1726   printf( "\n" );
1727}
1728
1729static void do_load_test(ldst_test_t loadTest)
1730{
1731   test_func_t func;
1732   unsigned int *src, *dst;
1733   int splat = loadTest.type == VSX_LOAD_SPLAT ? 1: 0;
1734   int i, j, m, k;
1735   i = j = 0;
1736
1737   func = loadTest.test_func;
1738   for (i = 0, r14 = (HWord_t) loadTest.base_addr; i < NUM_VIARGS_VECS; i++) {
1739      int again;
1740      j = 0;
1741       r14 += i * 16;
1742      do {
1743         unsigned int * pv = (unsigned int *)&vec_out;
1744         int idx;
1745         // clear vec_out
1746         for (idx = 0; idx < 4; idx++, pv+=idx)
1747            *pv = 0;
1748
1749         again = 0;
1750         r15 = j;
1751
1752         // execute test insn
1753         (*func)();
1754
1755         src = (unsigned int*) (((unsigned char *)r14) + j);
1756         dst = (unsigned int*) &vec_out;
1757
1758         printf( "%s:", loadTest.name);
1759         for (m = 0; m < loadTest.num_words_to_process; m++) {
1760            printf( " %08x", src[splat ? m % 2 : m]);
1761         }
1762         printf( " =>");
1763         m = 0;
1764         k = loadTest.num_words_to_process;
1765         if (isLE) {
1766            if (loadTest.num_words_to_process == 2) {
1767               m = 2;
1768               k += 2;
1769            }
1770         }
1771
1772         for (; m < k; m++) {
1773            printf( " %08x", dst[m]);
1774         }
1775         printf("\n");
1776         if (j == 0 && loadTest.offset) {
1777            again = 1;
1778            j += loadTest.offset;
1779         }
1780      }
1781      while (again);
1782   }
1783}
1784
1785static void
1786do_store_test ( ldst_test_t storeTest )
1787{
1788   test_func_t func;
1789   unsigned int *src, *dst;
1790   int m;
1791
1792   func = storeTest.test_func;
1793   r14 = (HWord_t) storeTest.base_addr;
1794   r15 = (HWord_t) storeTest.offset;
1795   unsigned int * pv = (unsigned int *) storeTest.base_addr;
1796   int idx;
1797   // clear out storage destination
1798   for (idx = 0; idx < 4; idx++, pv += idx)
1799      *pv = 0;
1800
1801   memcpy(&vec_inA, &viargs[0], sizeof(vector unsigned char));
1802
1803   // execute test insn
1804   (*func)();
1805   src = &viargs[0];
1806   dst = (unsigned int*) (((unsigned char *) r14) + storeTest.offset);
1807
1808   printf( "%s:", storeTest.name );
1809   for (m = 0; m < storeTest.num_words_to_process; m++) {
1810      printf( " %08x", src[m] );
1811   }
1812   printf( " =>" );
1813   for (m = 0; m < storeTest.num_words_to_process; m++) {
1814      printf( " %08x", dst[m] );
1815   }
1816   printf( "\n" );
1817}
1818
1819
1820static void test_ldst(void)
1821{
1822   int k = 0;
1823
1824   while (ldst_tests[k].test_func) {
1825      if (ldst_tests[k].type == VSX_STORE)
1826         do_store_test(ldst_tests[k]);
1827      else
1828         do_load_test(ldst_tests[k]);
1829      k++;
1830      printf("\n");
1831   }
1832}
1833
1834static void test_ftdiv(void)
1835{
1836   int i, num_tests, crx;
1837   unsigned int flags;
1838   unsigned long long * frap, * frbp;
1839   build_special_fargs_table();
1840
1841   num_tests = sizeof ftdiv_tests/sizeof ftdiv_tests[0];
1842
1843   for (i = 0; i < num_tests; i++) {
1844      fp_test_args_t aTest = ftdiv_tests[i];
1845      f14 = spec_fargs[aTest.fra_idx];
1846      f15 = spec_fargs[aTest.frb_idx];
1847      frap = (unsigned long long *)&spec_fargs[aTest.fra_idx];
1848      frbp = (unsigned long long *)&spec_fargs[aTest.frb_idx];
1849      SET_FPSCR_ZERO;
1850      SET_CR_XER_ZERO;
1851      __asm__ __volatile__ ("ftdiv           cr1, %0, %1" : : "d" (f14), "d" (f15));
1852      GET_CR(flags);
1853      crx = (flags & 0x0f000000) >> 24;
1854      printf( "ftdiv: %016llx <=> %016llx ? %x (CRx)\n", *frap, *frbp, crx);
1855//      printf("\tFRA: %e;  FRB: %e\n", f14, f15);
1856      if ( crx != aTest.cr_flags) {
1857         printf("Error: Expected CR flags 0x%x; actual flags: 0x%x\n", aTest.cr_flags, crx);
1858      }
1859   }
1860   printf( "\n" );
1861}
1862
1863
1864static void test_p7_fpops ( void )
1865{
1866   int k = 0;
1867   test_func_t func;
1868
1869   build_fargs_table();
1870   while ((func = fp_tests[k].test_func)) {
1871      float res;
1872      double resd;
1873      unsigned long long u0;
1874      int i;
1875      int res32 = strcmp(fp_tests[k].name, "fcfidu");
1876
1877      for (i = 0; i < nb_fargs; i++) {
1878         u0 = *(unsigned long long *) (&fargs[i]);
1879         f14 = fargs[i];
1880         (*func)();
1881         if (res32) {
1882            res = f17;
1883            printf( "%s %016llx => (raw sp) %08x)",
1884                    fp_tests[k].name, u0, *((unsigned int *)&res));
1885         } else {
1886            resd = f17;
1887            printf( "%s %016llx => (raw sp) %016llx)",
1888                    fp_tests[k].name, u0, *(unsigned long long *)(&resd));
1889         }
1890         printf( "\n" );
1891      }
1892
1893      k++;
1894      printf( "\n" );
1895   }
1896}
1897
1898static void test_vsx_logic(void)
1899{
1900   logic_test_t aTest;
1901   test_func_t func;
1902   int k;
1903   k = 0;
1904
1905   while ((func = logic_tests[k].test_func)) {
1906      unsigned int * pv;
1907      int startA, startB;
1908      unsigned int * inA, * inB, * dst;
1909      int idx, i;
1910      startA = 0;
1911      aTest = logic_tests[k];
1912      for (i = 0; i <= (NUM_VIARGS_INTS - (NUM_VIARGS_VECS * sizeof(int))); i++, startA++) {
1913         startB = startA + 4;
1914         pv = (unsigned int *)&vec_out;
1915         inA = &viargs[startA];
1916         inB = &viargs[startB];
1917         memcpy(&vec_inA, inA, sizeof(vector unsigned char));
1918         memcpy(&vec_inB, inB, sizeof(vector unsigned char));
1919         // clear vec_out
1920         for (idx = 0; idx < 4; idx++, pv++)
1921            *pv = 0;
1922
1923         // execute test insn
1924         (*func)();
1925         dst = (unsigned int*) &vec_out;
1926
1927         printf( "%s:", aTest.name);
1928         printf( " %08x %08x %08x %08x %s", inA[0], inA[1], inA[2], inA[3], aTest.name);
1929         printf( " %08x %08x %08x %08x", inB[0], inB[1], inB[2], inB[3]);
1930         printf(" => %08x %08x %08x %08x\n", dst[0], dst[1], dst[2], dst[3]);
1931
1932      }
1933      k++;
1934   }
1935   printf( "\n" );
1936}
1937
1938static vector unsigned long long vec_args[] __attribute__ ((aligned (16))) =
1939{
1940 { 0x0123456789abcdefULL, 0x0011223344556677ULL},
1941 { 0x8899aabb19293942ULL, 0xa1a2a3a4b1b2b3b4ULL},
1942 { 0xc1c2c3c4d1d2d3d4ULL, 0x7a6b5d3efc032778ULL}
1943};
1944#define NUM_VEC_ARGS_LONGS (sizeof vec_args/sizeof vec_args[0])
1945
1946static void test_move_ops (void)
1947{
1948   move_test_t aTest;
1949   test_func_t func;
1950   int k;
1951   k = 0;
1952
1953   while ((func = move_tests[k].test_func)) {
1954      unsigned int * pv;
1955      int startA, startB;
1956      unsigned long long * inA, * inB, * dst;
1957      int use_vecA = (strcmp(move_tests[k].name, "xscpsgndp") == 0);
1958      int idx;
1959      inA = NULL;
1960      aTest = move_tests[k];
1961      for (startB = 0; startB < NUM_VEC_ARGS_LONGS; startB++) {
1962         inB = (unsigned long long *)&vec_args[startB];
1963         memcpy(&vec_inB, inB, sizeof(vector unsigned char));
1964         if (isLE)
1965            inB++;
1966         startA = 0;
1967repeat:
1968         if (use_vecA) {
1969            inA = (unsigned long long *)&vec_args[startA];
1970            memcpy(&vec_inA, inA, sizeof(vector unsigned char));
1971            startA++;
1972         }
1973         pv = (unsigned int *)&vec_out;
1974         // clear vec_out
1975         for (idx = 0; idx < 4; idx++, pv++)
1976            *pv = 0;
1977
1978         // execute test insn
1979         (*func)();
1980         dst = (unsigned long long *) &vec_out;
1981         if (isLE) {
1982            dst++;
1983            inA++;
1984         }
1985
1986         printf( "%s:", aTest.name);
1987         if (use_vecA)
1988            printf( " X[A]: %016llx ", *inA);
1989         printf( " X[B]: %016llx", *inB);
1990         printf(" => %016llx\n", *dst);
1991
1992         if (use_vecA && startA < NUM_VEC_ARGS_LONGS)
1993            goto repeat;
1994      }
1995      k++;
1996      printf( "\n" );
1997   }
1998}
1999
2000static void test_permute_ops (void)
2001{
2002  permute_test_t *aTest;
2003  unsigned int *dst = (unsigned int *) &vec_out;
2004
2005  for (aTest = &(permute_tests[0]); aTest->test_func != NULL; aTest++)
2006    {
2007      /* Grab test input and clear output vector.  */
2008      memcpy(&vec_inA, aTest->xa, sizeof(vec_inA));
2009      memcpy(&vec_inB, aTest->xb, sizeof(vec_inB));
2010      memset(dst, 0, sizeof(vec_out));
2011
2012      /* execute test insn */
2013      aTest->test_func();
2014
2015      printf( "%s:\n", aTest->name);
2016      printf( "        XA[%08x,%08x,%08x,%08x]\n",
2017              aTest->xa[0], aTest->xa[1], aTest->xa[2], aTest->xa[3]);
2018      printf( "        XB[%08x,%08x,%08x,%08x]\n",
2019              aTest->xb[0], aTest->xb[1], aTest->xb[2], aTest->xb[3]);
2020      printf( "   =>   XT[%08x,%08x,%08x,%08x]\n",
2021              dst[0], dst[1], dst[2], dst[3]);
2022
2023    }
2024  printf( "\n" );
2025}
2026
2027static test_table_t all_tests[] = { { &test_ldst,
2028                                       "Test VSX load/store instructions" },
2029                                     { &test_vsx_logic,
2030                                       "Test VSX logic instructions" },
2031#ifdef __powerpc64__
2032                                     { &test_ldbrx,
2033                                       "Test ldbrx instruction" },
2034                                     { &test_popcntd,
2035                                       "Test popcntd instruction" },
2036#endif
2037                                     { &test_lfiwzx,
2038                                       "Test lfiwzx instruction" },
2039                                     { &test_p7_fpops,
2040                                       "Test P7 floating point convert instructions"},
2041                                     { &test_ftdiv,
2042                                       "Test ftdiv instruction" },
2043                                     { &test_move_ops,
2044                                       "Test VSX move instructions"},
2045                                     { &test_permute_ops,
2046                                       "Test VSX permute instructions"},
2047                                     { &test_vx_fp_ops,
2048                                       "Test VSX floating point instructions"},
2049                                     { &test_xs_conv_ops,
2050                                       "Test VSX scalar integer conversion instructions" },
2051                                     { NULL, NULL }
2052};
2053#endif // HAS_VSX
2054
2055int main(int argc, char *argv[])
2056{
2057#ifdef HAS_VSX
2058
2059   test_table_t aTest;
2060   test_func_t func;
2061   int i = 0;
2062
2063   while ((func = all_tests[i].test_category)) {
2064      aTest = all_tests[i];
2065      printf( "%s\n", aTest.name );
2066      (*func)();
2067      i++;
2068   }
2069
2070#endif // HAS _VSX
2071
2072   return 0;
2073}
2074