l4/pkg/valgrind/src/valgrind-3.6.0-svn/none/tests/ppc64/test_isa_2_06_part1.c

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