
/* HOW TO COMPILE:

 * 32bit build:
   gcc -Winline -Wall -g -O -mregnames -maltivec -m32
 * 64bit build:
   gcc -Winline -Wall -g -O -mregnames -maltivec -m64


 * test_isa_2_07_part1.c:
 * PPC tests for the ISA 2.07.  This file is based on the
 * jm-insns.c file for the new instructions in the ISA 2.07.  The
 * test structure has been kept the same as the original file to
 * the extent possible.
 *
 * Copyright (C) 2013 IBM
 *
 *   Authors: Carl Love <carll@us.ibm.com>
 *            Maynard Johnson <maynardj@us.ibm.com>
 *
 *   This program is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU General Public License as
 *   published by the Free Software Foundation; either version 2 of the
 *   License, or (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/*
 * Operation details
 * -----------------
 *
 * The 'loops' (e.g. int_loops) do the actual work:
 *  - loops over as many arguments as the insn needs (regs | imms)
 *     - sets up the environment (reset cr,xer, assign src regs...)
 *     - maybe modifies the asm instn to test different imm args
 *     - calls the test function
 *     - retrieves relevant register data (rD,cr,xer,...)
 *     - prints argument and result data.
 *
 * More specifically...
 *
 * all_tests[i] holds insn tests
 *  - of which each holds: {instn_test_arr[], description, flags}
 *
 * flags hold 3 instn classifiers: {family, type, arg_type}
 *
 * // The main test loop:
 * do_tests( user_ctl_flags ) {
 *    foreach(curr_test = all_test[i]) {
 *
 *       // flags are used to control what tests are run:
 *       if (curr_test->flags && !user_ctl_flags)
 *          continue;
 *
 *       // a 'loop_family_arr' is chosen based on the 'family' flag...
 *       switch(curr_test->flags->family) {
 *       case x: loop_family_arr = int_loops;
 *      ...
 *       }
 *
 *       // ...and the actual test_loop to run is found by indexing into
 *       // the loop_family_arr with the 'arg_type' flag:
 *       test_loop = loop_family[curr_test->flags->arg_type]
 *
 *       // finally, loop over all instn tests for this test:
 *       foreach (instn_test = curr_test->instn_test_arr[i]) {
 *
 *          // and call the test_loop with the current instn_test function,name
 *          test_loop( instn_test->func, instn_test->name )
 *       }
 *    }
 * }
 *
 */


/**********************************************************************/

/* Uncomment to enable output of CR flags for float tests */
//#define TEST_FLOAT_FLAGS

/* Uncomment to enable debug output */
//#define DEBUG_ARGS_BUILD
//#define DEBUG_FILTER

/**********************************************************************/
#include <stdio.h>

#ifdef HAS_ISA_2_07

#include "config.h"
#include <altivec.h>
#include <stdint.h>

#include <assert.h>
#include <ctype.h>     // isspace
#include <stdlib.h>
#include <string.h>
#include <unistd.h>    // getopt

#if !defined (__TEST_PPC_H__)
#define __TEST_PPC_H__

#include "tests/sys_mman.h"
#include "tests/malloc.h"       // memalign16

#define STATIC_ASSERT(e) sizeof(struct { int:-!(e); })

/* Something of the same size as void*, so can be safely be coerced
 * to/from a pointer type. Also same size as the host's gp registers.
 * According to the AltiVec section of the GCC manual, the syntax does
 * not allow the use of a typedef name as a type specifier in conjunction
 * with the vector keyword, so typedefs uint[32|64]_t are #undef'ed here
 * and redefined using #define.
 */
#undef uint32_t
#undef uint64_t
#define uint32_t unsigned int
#define uint64_t unsigned long long int

#ifndef __powerpc64__
typedef uint32_t  HWord_t;
#define ZERO 0
#else
typedef uint64_t  HWord_t;
#define ZERO 0ULL
#endif /* __powerpc64__ */

#ifdef VGP_ppc64le_linux
#define isLE 1
#else
#define isLE 0
#endif

typedef uint64_t Word_t;

enum {
    compile_time_test1 = STATIC_ASSERT(sizeof(uint32_t) == 4),
    compile_time_test2 = STATIC_ASSERT(sizeof(uint64_t) == 8),
};

#define ALLCR "cr0","cr1","cr2","cr3","cr4","cr5","cr6","cr7"

#define SET_CR(_arg) \
      __asm__ __volatile__ ("mtcr  %0" : : "b"(_arg) : ALLCR );

#define SET_XER(_arg) \
      __asm__ __volatile__ ("mtxer %0" : : "b"(_arg) : "xer" );

#define GET_CR(_lval) \
      __asm__ __volatile__ ("mfcr %0"  : "=b"(_lval) )

#define GET_XER(_lval) \
      __asm__ __volatile__ ("mfxer %0" : "=b"(_lval) )

#define GET_CR_XER(_lval_cr,_lval_xer) \
   do { GET_CR(_lval_cr); GET_XER(_lval_xer); } while (0)

#define SET_CR_ZERO \
      SET_CR(0)

#define SET_XER_ZERO \
      SET_XER(0)

#define SET_CR_XER_ZERO \
   do { SET_CR_ZERO; SET_XER_ZERO; } while (0)

#define SET_FPSCR_ZERO \
   do { double _d = 0.0; \
        __asm__ __volatile__ ("mtfsf 0xFF, %0" : : "f"(_d) ); \
   } while (0)

#define DEFAULT_VSCR 0x0

static vector unsigned long long vec_out, vec_inA, vec_inB, vec_inC;
static vector unsigned int vec_inA_wd, vec_inB_wd;

/* XXXX these must all be callee-save regs! */
register double f14 __asm__ ("fr14");
register double f15 __asm__ ("fr15");
register double f16 __asm__ ("fr16");
register double f17 __asm__ ("fr17");
register HWord_t r14 __asm__ ("r14");
register HWord_t r15 __asm__ ("r15");
register HWord_t r16 __asm__ ("r16");
register HWord_t r17 __asm__ ("r17");

typedef void (*test_func_t) (void);
typedef struct _test test_t;
typedef struct _test_table test_table_t;
struct _test {
    test_func_t func;
    const char *name;
};

struct _test_table {
    test_t *tests;
    const char *name;
    uint32_t flags;
};

typedef void (*test_loop_t) (const char *name, test_func_t func,
                             uint32_t flags);

enum test_flags {
    /* Nb arguments */
    PPC_ONE_ARG    = 0x00000001,
    PPC_TWO_ARGS   = 0x00000002,
    PPC_THREE_ARGS = 0x00000003,
    PPC_CMP_ARGS   = 0x00000004,  // family: compare
    PPC_CMPI_ARGS  = 0x00000005,  // family: compare
    PPC_TWO_I16    = 0x00000006,  // family: arith/logical
    PPC_SPECIAL    = 0x00000007,  // family: logical
    PPC_LD_ARGS    = 0x00000008,  // family: ldst
    PPC_LDX_ARGS   = 0x00000009,  // family: ldst
    PPC_ST_ARGS    = 0x0000000A,  // family: ldst
    PPC_STX_ARGS   = 0x0000000B,  // family: ldst
    PPC_STQ_ARGS   = 0x0000000C,  // family: ldst, two args, imm
    PPC_LDQ_ARGS   = 0x0000000D,  // family: ldst, two args, imm
    PPC_STQX_ARGS  = 0x0000000E,  // family: ldst, three args
    PPC_LDQX_ARGS  = 0x0000000F,  // family: ldst, three_args
    PPC_NB_ARGS    = 0x0000000F,
    /* Type */
    PPC_ARITH      = 0x00000100,
    PPC_LOGICAL    = 0x00000200,
    PPC_COMPARE    = 0x00000300,
    PPC_CROP       = 0x00000400,
    PPC_LDST       = 0x00000500,
    PPC_POPCNT     = 0x00000600,
    PPC_ARITH_DRES = 0x00000700,
    PPC_DOUBLE_IN_IRES = 0x00000800,
    PPC_MOV        = 0x00000A00,
    PPC_SHA_OR_BCD = 0x00000B00,
    PPC_TYPE       = 0x00000F00,
    /* Family */
    PPC_INTEGER    = 0x00010000,
    PPC_FLOAT      = 0x00020000,
    PPC_405        = 0x00030000,  // Leave so we keep numbering consistent
    PPC_ALTIVEC    = 0x00040000,
    PPC_FALTIVEC   = 0x00050000,
    PPC_ALTIVECD   = 0x00060000,    /* double word Altivec tests */
    PPC_ALTIVECQ   = 0x00070000,
    PPC_FAMILY     = 0x000F0000,
    /* Flags: these may be combined, so use separate bitfields. */
    PPC_CR         = 0x01000000,
    PPC_XER_CA     = 0x02000000,
};

#endif /* !defined (__TEST_PPC_H__) */

/* -------------- END #include "test-ppc.h" -------------- */


#if defined (DEBUG_ARGS_BUILD)
#define AB_DPRINTF(fmt, args...) do { fprintf(stderr, fmt , ##args); } while (0)
#else
#define AB_DPRINTF(fmt, args...) do { } while (0)
#endif


#if defined (DEBUG_FILTER)
#define FDPRINTF(fmt, args...) do { fprintf(stderr, fmt , ##args); } while (0)
#else
#define FDPRINTF(fmt, args...) do { } while (0)
#endif

#define unused __attribute__ (( unused ))

typedef struct special {
   const char *name;
   void (*test_cb)(const char* name, test_func_t func,
                   unused uint32_t test_flags);
} special_t;

static void test_stq(void)
{
  __asm__ __volatile__ ("stq  %0, 0(%1)" : :"r" (r14), "r" (r16));
}

static test_t tests_istq_ops_two_i16[] = {
    { &test_stq             , "stq", },
    { NULL,                   NULL,           },
};

static void test_lq(void)
{
  __asm__ __volatile__ ("lq  %0, 0(%1)" : :"r" (r14), "r" (r16));
}

static test_t tests_ildq_ops_two_i16[] = {
    { &test_lq              , "lq", },
    { NULL,                   NULL,          },
};

#ifdef HAS_ISA_2_07
Word_t * mem_resv;
static void test_stbcx(void)
{
  /* Have to do the lbarx to the memory address to create the reservation
   * or the store will not occur.
   */
  __asm__ __volatile__ ("lbarx  %0, %1, %2" : :"r" (r14), "r" (r16),"r" (r17));
  r14 = (HWord_t) 0xABEFCD0145236789ULL;
  r15 = (HWord_t) 0x1155337744226688ULL;
  __asm__ __volatile__ ("stbcx. %0, %1, %2" : :"r" (r14), "r" (r16),"r" (r17));
}

static void test_sthcx(void)
{
  /* Have to do the lharx to the memory address to create the reservation
   * or the store will not occur.
   */
  __asm__ __volatile__ ("lharx  %0, %1, %2" : :"r" (r14), "r" (r16),"r" (r17));
  r14 = (HWord_t) 0xABEFCD0145236789ULL;
  r15 = (HWord_t) 0x1155337744226688ULL;
  __asm__ __volatile__ ("sthcx. %0, %1, %2" : :"r" (r14), "r" (r16),"r" (r17));
}
#endif

static void test_stqcx(void)
{
  /* Have to do the lqarx to the memory address to create the reservation
   * or the store will not occur.
   */
  __asm__ __volatile__ ("lqarx  %0, %1, %2" : :"r" (r14), "r" (r16),"r" (r17));
  r14 = (HWord_t) 0xABEFCD0145236789ULL;
  r15 = (HWord_t) 0x1155337744226688ULL;
  __asm__ __volatile__ ("stqcx. %0, %1, %2" : :"r" (r14), "r" (r16),"r" (r17));
}

static test_t tests_stq_ops_three[] = {
#ifdef HAS_ISA_2_07
    { &test_stbcx           , "stbcx.", },
    { &test_sthcx           , "sthcx.", },
#endif
    { &test_stqcx           , "stqcx.", },
    { NULL,                   NULL,           },
};

#ifdef HAS_ISA_2_07
static void test_lbarx(void)
{
  __asm__ __volatile__ ("lbarx  %0, %1, %2, 0" : :"r" (r14), "r" (r16),"r" (r17));
}
static void test_lharx(void)
{
  __asm__ __volatile__ ("lharx  %0, %1, %2, 0" : :"r" (r14), "r" (r16),"r" (r17));
}
#endif
static void test_lqarx(void)
{
  __asm__ __volatile__ ("lqarx  %0, %1, %2, 0" : :"r" (r14), "r" (r16),"r" (r17));
}

static test_t tests_ldq_ops_three[] = {
#ifdef HAS_ISA_2_07
    { &test_lbarx           , "lbarx", },
    { &test_lharx           , "lharx", },
#endif
    { &test_lqarx           , "lqarx", },
    { NULL,                   NULL,           },
};

static void test_fmrgew (void)
{
    __asm__ __volatile__ ("fmrgew        17,14,15");
};

static void test_fmrgow (void)
{
    __asm__ __volatile__ ("fmrgow        17,14,15");
};


// VSX move instructions
static void test_mfvsrd (void)
{
   __asm__ __volatile__ ("mfvsrd %0,%x1" : "=r" (r14) : "ws" (vec_inA));
};

static void test_mfvsrwz (void)
{
   __asm__ __volatile__ ("mfvsrwz %0,%x1" : "=r" (r14) : "ws" (vec_inA));
};

static void test_mtvsrd (void)
{
   __asm__ __volatile__ ("mtvsrd %x0,%1" : "=ws" (vec_out) : "r" (r14));
};

static void test_mtvsrwz (void)
{
   __asm__ __volatile__ ("mtvsrwz %x0,%1" : "=ws" (vec_out) : "r" (r14));
};


static void test_mtfprwa (void)
{
   __asm__ __volatile__ ("mtfprwa %x0,%1" : "=ws" (vec_out) : "r" (r14));
};

static test_t tests_move_ops_spe[] = {
  { &test_mfvsrd          , "mfvsrd" },
  { &test_mfvsrwz         , "mfvsrwz" },
  { &test_mtvsrd          , "mtvsrd" },
  { &test_mtvsrwz         , "mtvsrwz" },
  { &test_mtfprwa         , "mtfprwa" },
  { NULL,                   NULL }
};

/* NOTE: Since these are "vector" instructions versus VSX, we must use
 * vector constraints.
 *
 * Vector Double Word tests.
 */
static void test_vpkudum (void)
{
   __asm__ __volatile__ ("vpkudum %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vaddudm (void)
{
   __asm__ __volatile__ ("vaddudm %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vsubudm (void)
{
   __asm__ __volatile__ ("vsubudm %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vmaxud (void)
{
   __asm__ __volatile__ ("vmaxud %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vmaxsd (void)
{
   __asm__ __volatile__ ("vmaxsd %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vminud (void)
{
   __asm__ __volatile__ ("vminud %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vminsd (void)
{
   __asm__ __volatile__ ("vminsd %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vcmpequd (void)
{
   __asm__ __volatile__ ("vcmpequd %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vcmpgtud (void)
{
   __asm__ __volatile__ ("vcmpgtud %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vcmpgtsd (void)
{
   __asm__ __volatile__ ("vcmpgtsd %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vrld (void)
{
   __asm__ __volatile__ ("vrld %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vsld (void)
{
   __asm__ __volatile__ ("vsld %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vsrad (void)
{
   __asm__ __volatile__ ("vsrad %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vsrd (void)
{
   __asm__ __volatile__ ("vsrd %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

/* Vector Double Word saturate tests.*/

static void test_vpkudus (void)
{
   __asm__ __volatile__ ("vpkudus %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vpksdus (void)
{
   __asm__ __volatile__ ("vpksdus %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vpksdss (void)
{
   __asm__ __volatile__ ("vpksdss %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}


/* Vector unpack two words from one vector arg */
static void test_vupkhsw (void)
{
    __asm__ __volatile__ ("vupkhsw %0, %1" : "=v" (vec_out): "v" (vec_inB_wd));
}

static void test_vupklsw (void)
{
    __asm__ __volatile__ ("vupklsw %0, %1" : "=v" (vec_out): "v" (vec_inB_wd));
}


/* Vector Integer Word tests.*/
static void test_vmulouw (void)
{
  __asm__ __volatile__ ("vmulouw %0, %1, %2" : "=v" (vec_out): "v" (vec_inA_wd),"v" (vec_inB_wd));
}

static void test_vmuluwm (void)
{
    __asm__ __volatile__ ("vmuluwm %0, %1, %2" : "=v" (vec_out): "v" (vec_inA_wd),"v" (vec_inB_wd));
}

static void test_vmulosw (void)
{
    __asm__ __volatile__ ("vmulosw %0, %1, %2" : "=v" (vec_out): "v" (vec_inA_wd),"v" (vec_inB_wd));
}

static void test_vmuleuw (void)
{
    __asm__ __volatile__ ("vmuleuw %0, %1, %2" : "=v" (vec_out): "v" (vec_inA_wd),"v" (vec_inB_wd));
}

static void test_vmulesw (void)
{
    __asm__ __volatile__ ("vmulesw %0, %1, %2" : "=v" (vec_out): "v" (vec_inA_wd),"v" (vec_inB_wd));
}

static void test_vmrgew (void)
{
    __asm__ __volatile__ ("vmrgew %0, %1, %2" : "=v" (vec_out): "v" (vec_inA_wd),"v" (vec_inB_wd));
}

static void test_vmrgow (void)
{
    __asm__ __volatile__ ("vmrgow %0, %1, %2" : "=v" (vec_out): "v" (vec_inA_wd),"v" (vec_inB_wd));
}

static void test_vpmsumb (void)
{
    __asm__ __volatile__ ("vpmsumb %0, %1, %2" : "=v" (vec_out): "v" (vec_inA_wd),"v" (vec_inB_wd));
}

static void test_vpmsumh (void)
{
    __asm__ __volatile__ ("vpmsumh %0, %1, %2" : "=v" (vec_out): "v" (vec_inA_wd),"v" (vec_inB_wd));
}

static void test_vpmsumw (void)
{
    __asm__ __volatile__ ("vpmsumw %0, %1, %2" : "=v" (vec_out): "v" (vec_inA_wd),"v" (vec_inB_wd));
}

static void test_vpermxor (void)
{
  __asm__ __volatile__ ("vpermxor %0, %1, %2, %3" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB),"v" (vec_inC));
}

static void test_vpmsumd (void)
{
    __asm__ __volatile__ ("vpmsumd %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vnand (void)
{
    __asm__ __volatile__ ("vnand %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vorc (void)
{
    __asm__ __volatile__ ("vorc %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_veqv (void)
{
    __asm__ __volatile__ ("veqv %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vcipher (void)
{
    __asm__ __volatile__ ("vcipher %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vcipherlast (void)
{
    __asm__ __volatile__ ("vcipherlast %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vncipher (void)
{
    __asm__ __volatile__ ("vncipher %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vncipherlast (void)
{
    __asm__ __volatile__ ("vncipherlast %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vclzb (void)
{
    __asm__ __volatile__ ("vclzb %0, %1" : "=v" (vec_out): "v" (vec_inB));
}

static void test_vclzw (void)
{
    __asm__ __volatile__ ("vclzw %0, %1" : "=v" (vec_out): "v" (vec_inB));
}

static void test_vclzh (void)
{
    __asm__ __volatile__ ("vclzh %0, %1" : "=v" (vec_out): "v" (vec_inB));
}

static void test_vclzd (void)
{
    __asm__ __volatile__ ("vclzd %0, %1" : "=v" (vec_out): "v" (vec_inB));
}

static void test_vpopcntb (void)
{
    __asm__ __volatile__ ("vpopcntb %0, %1" : "=v" (vec_out): "v" (vec_inB));
}

static void test_vpopcnth (void)
{
    __asm__ __volatile__ ("vpopcnth %0, %1" : "=v" (vec_out): "v" (vec_inB));
}

static void test_vpopcntw (void)
{
    __asm__ __volatile__ ("vpopcntw %0, %1" : "=v" (vec_out): "v" (vec_inB));
}

static void test_vpopcntd (void)
{
    __asm__ __volatile__ ("vpopcntd %0, %1" : "=v" (vec_out): "v" (vec_inB));
}

static void test_vsbox (void)
{
    __asm__ __volatile__ ("vsbox %0, %1" : "=v" (vec_out): "v" (vec_inB));
}

static int st_six;
static void test_vshasigmad (void)
{
   switch (st_six) {
   case 0x00:
      __asm__ __volatile__ ("vshasigmad %0, %1, 0, 0" : "=v" (vec_out): "v" (vec_inA));
      break;
   case 0x0f:
      __asm__ __volatile__ ("vshasigmad %0, %1, 0, 15" : "=v" (vec_out): "v" (vec_inA));
      break;
   case 0x10:
      __asm__ __volatile__ ("vshasigmad %0, %1, 1, 0" : "=v" (vec_out): "v" (vec_inA));
      break;
   case 0x1f:
      __asm__ __volatile__ ("vshasigmad %0, %1, 1, 15" : "=v" (vec_out): "v" (vec_inA));
      break;
   }
}

static void test_vshasigmaw (void)
{
   switch (st_six) {
   case 0x00:
      __asm__ __volatile__ ("vshasigmaw %0, %1, 0, 0" : "=v" (vec_out): "v" (vec_inA));
      break;
   case 0x0f:
      __asm__ __volatile__ ("vshasigmaw %0, %1, 0, 15" : "=v" (vec_out): "v" (vec_inA));
      break;
   case 0x10:
      __asm__ __volatile__ ("vshasigmaw %0, %1, 1, 0" : "=v" (vec_out): "v" (vec_inA));
      break;
   case 0x1f:
      __asm__ __volatile__ ("vshasigmaw %0, %1, 1, 15" : "=v" (vec_out): "v" (vec_inA));
      break;
   }
}

static int PS_bit;
static void test_bcdadd (void)
{
   if (PS_bit)
      __asm__ __volatile__ ("bcdadd. %0, %1, %2, 1" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
   else
      __asm__ __volatile__ ("bcdadd. %0, %1, %2, 0" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_bcdsub (void)
{
   if (PS_bit)
      __asm__ __volatile__ ("bcdsub. %0, %1, %2, 1" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
   else
      __asm__ __volatile__ ("bcdsub. %0, %1, %2, 0" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vaddcuq (void)
{
   __asm__ __volatile__ ("vaddcuq %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vadduqm (void)
{
   __asm__ __volatile__ ("vadduqm %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vaddecuq (void)
{
  __asm__ __volatile__ ("vaddecuq %0, %1, %2, %3" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB),"v" (vec_inC));
}

static void test_vaddeuqm (void)
{
  __asm__ __volatile__ ("vaddeuqm %0, %1, %2, %3" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB),"v" (vec_inC));
}

static void test_vsubcuq (void)
{
   __asm__ __volatile__ ("vsubcuq %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vsubuqm (void)
{
   __asm__ __volatile__ ("vsubuqm %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vsubecuq (void)
{
  __asm__ __volatile__ ("vsubecuq %0, %1, %2, %3" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB),"v" (vec_inC));
}

static void test_vsubeuqm (void)
{
  __asm__ __volatile__ ("vsubeuqm %0, %1, %2, %3" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB),"v" (vec_inC));
}

static void test_vbpermq (void)
{
   __asm__ __volatile__ ("vbpermq %0, %1, %2" : "=v" (vec_out): "v" (vec_inA),"v" (vec_inB));
}

static void test_vgbbd (void)
{
    __asm__ __volatile__ ("vgbbd %0, %1" : "=v" (vec_out): "v" (vec_inB));
}


static test_t tests_aa_quadword_two_args[] = {
  { &test_vaddcuq       , "vaddcuq" },
  { &test_vadduqm       , "vadduqm" },
  { &test_vsubcuq       , "vsubcuq" },
  { &test_vsubuqm       , "vsubuqm" },
  { &test_vbpermq       , "vbpermq" },
  { NULL                , NULL      },
};

static test_t tests_aa_quadword_three_args[] = {
  { &test_vaddecuq      , "vaddecuq" },
  { &test_vaddeuqm      , "vaddeuqm" },
  { &test_vsubecuq      , "vsubecuq" },
  { &test_vsubeuqm      , "vsubeuqm" },
  { NULL                , NULL      },
};

static test_t tests_aa_bcd_ops[] = {
  { &test_bcdadd        , "bcdadd." },
  { &test_bcdsub        , "bcdsub." },
  { NULL                , NULL      },
};

static test_t tests_aa_SHA_ops[] = {
  { &test_vshasigmad    , "vshasigmad" },
  { &test_vshasigmaw    , "vshasigmaw" },
  { NULL                , NULL         },
};

static test_t tests_aa_ops_three[] = {
  { &test_vpermxor        , "vpermxor" },
  { NULL                  , NULL       },
};

static test_t tests_aa_word_ops_one_arg_dres[] = {
  { &test_vupkhsw         , "vupkhsw" },
  { &test_vupklsw         , "vupklsw" },
  { NULL                  , NULL      }
};

static test_t tests_aa_word_ops_two_args_dres[] = {
  { &test_vmulouw         , "vmulouw" },
  { &test_vmuluwm         , "vmuluwm" },
  { &test_vmulosw         , "vmulosw" },
  { &test_vmuleuw         , "vmuleuw" },
  { &test_vmulesw         , "vmulesw" },
  { &test_vmrgew          , "vmrgew" },
  { &test_vmrgow          , "vmrgow" },
  { &test_vpmsumb         , "vpmsumb" },
  { &test_vpmsumh         , "vpmsumh" },
  { &test_vpmsumw         , "vpmsumw" },
  { NULL                  , NULL      }
};

static test_t tests_aa_dbl_ops_two_args[] = {
  { &test_vaddudm         , "vaddudm", },
  { &test_vsubudm         , "vsubudm", },
  { &test_vmaxud          , "vmaxud", },
  { &test_vmaxsd          , "vmaxsd", },
  { &test_vminud          , "vminud", },
  { &test_vminsd          , "vminsd", },
  { &test_vcmpequd        , "vcmpequd", },
  { &test_vcmpgtud        , "vcmpgtud", },
  { &test_vcmpgtsd        , "vcmpgtsd", },
  { &test_vrld            , "vrld", },
  { &test_vsld            , "vsld", },
  { &test_vsrad           , "vsrad", },
  { &test_vsrd            , "vsrd", },
  { &test_vpkudum         , "vpkudum", },
  { &test_vpmsumd         , "vpmsumd", },
  { &test_vnand           , "vnand", },
  { &test_vorc            , "vorc", },
  { &test_veqv            , "veqv", },
  { &test_vcipher         , "vcipher" },
  { &test_vcipherlast     , "vcipherlast" },
  { &test_vncipher        , "vncipher" },
  { &test_vncipherlast    , "vncipherlast" },
  { NULL                  , NULL,      },
};

static test_t tests_aa_dbl_ops_one_arg[] = {
  { &test_vclzb           , "vclzb" },
  { &test_vclzw           , "vclzw" },
  { &test_vclzh           , "vclzh" },
  { &test_vclzd           , "vclzd" },
  { &test_vpopcntb        , "vpopcntb" },
  { &test_vpopcnth        , "vpopcnth" },
  { &test_vpopcntw        , "vpopcntw" },
  { &test_vpopcntd        , "vpopcntd" },
  { &test_vsbox           , "vsbox" },
  { &test_vgbbd           , "vgbbd" },
  { NULL                  , NULL,      }
};

static test_t tests_aa_dbl_to_int_two_args[] = {
  { &test_vpkudus         , "vpkudus", },
  { &test_vpksdus         , "vpksdus", },
  { &test_vpksdss         , "vpksdss", },
  { NULL                  , NULL,      },
};

static int verbose = 0;
static int arg_list_size = 0;
static unsigned long long * vdargs = NULL;
static unsigned long long * vdargs_x = NULL;
#define NB_VDARGS 9
#define NB_VDARGS_X 4

static void build_vdargs_table (void)
{
   // Each VSX register holds two doubleword integer values
   vdargs = memalign16(NB_VDARGS * sizeof(unsigned long long));
   vdargs[0] = 0x0102030405060708ULL;
   vdargs[1] = 0x090A0B0C0E0D0E0FULL;
   vdargs[2] = 0xF1F2F3F4F5F6F7F8ULL;
   vdargs[3] = 0xF9FAFBFCFEFDFEFFULL;
   vdargs[4] = 0x00007FFFFFFFFFFFULL;
   vdargs[5] = 0xFFFF000000000000ULL;
   vdargs[6] = 0x0000800000000000ULL;
   vdargs[7] = 0x0000000000000000ULL;
   vdargs[8] = 0xFFFFFFFFFFFFFFFFULL;

   vdargs_x = memalign16(NB_VDARGS_X * sizeof(unsigned long long));
   vdargs_x[0] = 0x000000007c118a2bULL;
   vdargs_x[1] = 0x00000000f1112345ULL;
   vdargs_x[2] = 0x01F2F3F4F5F6F7F8ULL;
   vdargs_x[3] = 0xF9FAFBFCFEFDFEFFULL;
}

static unsigned int * vwargs = NULL;
#define NB_VWARGS 8

static void build_vwargs_table (void)
{
   // Each VSX register holds 4 integer word values
   size_t i = 0;
   vwargs = memalign(8, 8 * sizeof(int));
   assert(vwargs);
   assert(0 == ((8-1) & (unsigned long)vwargs));
   vwargs[i++] = 0x01020304;
   vwargs[i++] = 0x05060708;
   vwargs[i++] = 0x090A0B0C;
   vwargs[i++] = 0x0E0D0E0F;
   vwargs[i++] = 0xF1F2F3F4;
   vwargs[i++] = 0xF5F6F7F8;
   vwargs[i++] = 0xF9FAFBFC;
   vwargs[i++] = 0xFEFDFEFF;
}

static unsigned long long vbcd_args[] __attribute__ ((aligned (16))) = {
   0x8045090189321003ULL, // Negative BCD value
   0x001122334556677dULL,
   0x0000107600000001ULL, // Positive BCD value
   0x319293945142031aULL,
   0x0ULL,                // Valid BCD zero
   0xaULL,
   0x0ULL,                // Invalid BCD zero (no sign code)
   0x0ULL
};
//#define NUM_VBCD_VALS (sizeof vbcd_args/sizeof vbcd_args[0])
#define NUM_VBCD_VALS 8 

static void build_vargs_table (void)
{
   build_vdargs_table();
   build_vwargs_table();
}

static double *fargs = NULL;
static int nb_fargs = 0;

static inline void register_farg (void *farg,
                                  int s, uint16_t _exp, uint64_t mant)
{
   uint64_t tmp;

   tmp = ((uint64_t)s << 63) | ((uint64_t)_exp << 52) | mant;
   *(uint64_t *)farg = tmp;
   AB_DPRINTF("%d %03x %013llx => %016llx %0e\n",
              s, _exp, mant, *(uint64_t *)farg, *(double *)farg);
}

static void build_fargs_table (void)
{
   /* Double precision:
    * Sign goes from zero to one               (1 bit)
    * Exponent goes from 0 to ((1 << 12) - 1)  (11 bits)
    * Mantissa goes from 1 to ((1 << 52) - 1)  (52 bits)
    * + special values:
    * +0.0      : 0 0x000 0x0000000000000 => 0x0000000000000000
    * -0.0      : 1 0x000 0x0000000000000 => 0x8000000000000000
    * +infinity : 0 0x7FF 0x0000000000000 => 0x7FF0000000000000
    * -infinity : 1 0x7FF 0x0000000000000 => 0xFFF0000000000000
    * +QNaN     : 0 0x7FF 0x8000000000000 => 0x7FF8000000000000
    * -QNaN     : 1 0x7FF 0x8000000000000 => 0xFFF8000000000000
    * +SNaN     : 0 0x7FF 0x7FFFFFFFFFFFF => 0x7FF7FFFFFFFFFFFF
    * -SNaN     : 1 0x7FF 0x7FFFFFFFFFFFF => 0xFFF7FFFFFFFFFFFF
    * (8 values)

    * Ref only:
    * Single precision
    * Sign:     1 bit
    * Exponent: 8 bits
    * Mantissa: 23 bits
    * +0.0      : 0 0x00 0x000000 => 0x00000000
    * -0.0      : 1 0x00 0x000000 => 0x80000000
    * +infinity : 0 0xFF 0x000000 => 0x7F800000
    * -infinity : 1 0xFF 0x000000 => 0xFF800000
    * +QNaN     : 0 0xFF 0x400000 => 0x7FC00000
    * -QNaN     : 1 0xFF 0x400000 => 0xFFC00000
    * +SNaN     : 0 0xFF 0x3FFFFF => 0x7FBFFFFF
    * -SNaN     : 1 0xFF 0x3FFFFF => 0xFFBFFFFF
    */
   uint64_t mant;
   uint16_t _exp, e0, e1;
   int s;
   int i=0;

   /* Note: VEX isn't so hot with denormals, so don't bother
      testing them: set _exp > 0
   */

   if ( arg_list_size == 1 ) {   // Large
      fargs = malloc(200 * sizeof(double));
      for (s=0; s<2; s++) {
         for (e0=0; e0<2; e0++) {
            for (e1=0x001; ; e1 = ((e1 + 1) << 2) + 6) {
               if (e1 >= 0x400)
                  e1 = 0x3fe;
               _exp = (e0 << 10) | e1;
               for (mant = 0x0000000000001ULL; mant < (1ULL << 52);
                    /* Add 'random' bits */
                    mant = ((mant + 0x4A6) << 13) + 0x359) {
                  register_farg(&fargs[i++], s, _exp, mant);
               }
               if (e1 == 0x3fe)
                  break;
            }
         }
      }
   } else {                      // Default
      fargs = malloc(16 * sizeof(double));
      for (s=0; s<2; s++) {                                // x2
            for (e1=0x001; ; e1 = ((e1 + 1) << 13) + 7) {  // x2
               if (e1 >= 0x400)
                  e1 = 0x3fe;
               _exp = e1;
               for (mant = 0x0000000000001ULL; mant < (1ULL << 52);
                    /* Add 'random' bits */
                    mant = ((mant + 0x4A6) << 29) + 0x359) {  // x2
                  register_farg(&fargs[i++], s, _exp, mant);
               }
               if (e1 == 0x3fe)
                  break;
            }
      }
   }

   /* Special values */
   /* +0.0      : 0 0x000 0x0000000000000 */
   s = 0;
   _exp = 0x000;
   mant = 0x0000000000000ULL;
   register_farg(&fargs[i++], s, _exp, mant);
   /* -0.0      : 1 0x000 0x0000000000000 */
   s = 1;
   _exp = 0x000;
   mant = 0x0000000000000ULL;
   register_farg(&fargs[i++], s, _exp, mant);
   /* +infinity : 0 0x7FF 0x0000000000000  */
   s = 0;
   _exp = 0x7FF;
   mant = 0x0000000000000ULL;
   register_farg(&fargs[i++], s, _exp, mant);
   /* -infinity : 1 0x7FF 0x0000000000000 */
   s = 1;
   _exp = 0x7FF;
   mant = 0x0000000000000ULL;
   register_farg(&fargs[i++], s, _exp, mant);
   /* +QNaN     : 0 0x7FF 0x7FFFFFFFFFFFF */
   s = 0;
   _exp = 0x7FF;
   mant = 0x7FFFFFFFFFFFFULL;
   register_farg(&fargs[i++], s, _exp, mant);
   /* -QNaN     : 1 0x7FF 0x7FFFFFFFFFFFF */
   s = 1;
   _exp = 0x7FF;
   mant = 0x7FFFFFFFFFFFFULL;
   register_farg(&fargs[i++], s, _exp, mant);
   /* +SNaN     : 0 0x7FF 0x8000000000000 */
   s = 0;
   _exp = 0x7FF;
   mant = 0x8000000000000ULL;
   register_farg(&fargs[i++], s, _exp, mant);
   /* -SNaN     : 1 0x7FF 0x8000000000000 */
   s = 1;
   _exp = 0x7FF;
   mant = 0x8000000000000ULL;
   register_farg(&fargs[i++], s, _exp, mant);
   AB_DPRINTF("Registered %d fargs values\n", i);

   nb_fargs = i;
}


static int check_filter (char *filter)
{
   char *c;
   int ret = 1;

   if (filter != NULL) {
      c = strchr(filter, '*');
      if (c != NULL) {
         *c = '\0';
         ret = 0;
      }
   }
   return ret;
}

static int check_name (const char* name, const char *filter,
                       int exact)
{
   int nlen, flen;
   int ret = 0;

   if (filter != NULL) {
      for (; isspace(*name); name++)
         continue;
      FDPRINTF("Check '%s' againt '%s' (%s match)\n",
               name, filter, exact ? "exact" : "starting");
      nlen = strlen(name);
      flen = strlen(filter);
      if (exact) {
         if (nlen == flen && memcmp(name, filter, flen) == 0)
            ret = 1;
      } else {
         if (flen <= nlen && memcmp(name, filter, flen) == 0)
            ret = 1;
      }
   } else {
      ret = 1;
   }
   return ret;
}


typedef struct insn_sel_flags_t_struct {
   int one_arg, two_args, three_args;
   int arith, logical, compare, ldst;
   int integer, floats, altivec, faltivec;
   int cr;
} insn_sel_flags_t;

static void test_float_two_args (const char* name, test_func_t func,
                                 unused uint32_t test_flags)
{
   double res;
   Word_t u0, u1, ur;
   volatile uint32_t flags;
   int i, j;

   for (i=0; i<nb_fargs; i+=3) {
      for (j=0; j<nb_fargs; j+=5) {
         u0 = *(Word_t *)(&fargs[i]);
         u1 = *(Word_t *)(&fargs[j]);
         f14 = fargs[i];
         f15 = fargs[j];

         SET_FPSCR_ZERO;
         SET_CR_XER_ZERO;
         (*func)();
         GET_CR(flags);
         res = f17;
         ur = *(uint64_t *)(&res);

         printf("%s %016llx, %016llx => %016llx",
                name, u0, u1, ur);
#if defined TEST_FLOAT_FLAGS
         printf(" (%08x)", flags);
#endif
         printf("\n");
      }
      if (verbose) printf("\n");
   }
}


static void mfvs(const char* name, test_func_t func,
                 unused uint32_t test_flags)
{
   /* This test is for move instructions where the input is a scalar register
    * and the destination is a vector register.
    */
   int i;
   volatile Word_t result;
   result = 0ULL;

   for (i=0; i < NB_VDARGS; i++) {
      r14 = ZERO;
      if (isLE)
         vec_inA = (vector unsigned long long){ 0ULL, vdargs[i] };
      else
         vec_inA = (vector unsigned long long){ vdargs[i], 0ULL };

      (*func)();
      result = r14;
      printf("%s: %016llx => %016llx\n", name, vdargs[i], result);
   }
}

static void mtvs(const char* name, test_func_t func,
                 unused uint32_t test_flags)
{
   /* This test is for move instructions where the input is a scalar register
    * and the destination is a vector register.
    */
   unsigned long long *dst;
   int i;

   for (i=0; i < NB_VDARGS; i++) {
      r14  = vdargs[i];
      vec_out = (vector unsigned long long){ 0ULL, 0ULL };

      (*func)();
      dst = (unsigned long long *) &vec_out;
      if (isLE)
         dst++;
      printf("%s: %016llx => %016llx\n", name, vdargs[i], *dst);
   }
}

static void mtvs2s(const char* name, test_func_t func,
                 unused uint32_t test_flags)
{
   /* This test is the mtvsrwa instruction.
    */
   unsigned long long *dst;
   int i;

   for (i=0; i < NB_VDARGS; i++) {
      // Only the lower half of the vdarg doubleword arg will be used as input by mtvsrwa
      unsigned int * src = (unsigned int *)&vdargs[i];
      if (!isLE)
         src++;
      r14  = vdargs[i];
      vec_out = (vector unsigned long long){ 0ULL, 0ULL };

      (*func)();
      // Only doubleword 0 is used in output
      dst = (unsigned long long *) &vec_out;
      if (isLE)
         dst++;
      printf("%s: %08x => %016llx\n", name, *src, *dst);
   }
}

static void test_special (special_t *table,
                          const char* name, test_func_t func,
                          unused uint32_t test_flags)
{
   const char *tmp;
   int i;

   for (tmp = name; isspace(*tmp); tmp++)
      continue;
   for (i=0; table[i].name != NULL; i++) {
      if (strcmp(table[i].name, tmp) == 0) {
         (*table[i].test_cb)(name, func, test_flags);
         return;
      }
   }
   fprintf(stderr, "ERROR: no test found for op '%s'\n", name);
}

static special_t special_move_ops[] = {
   {
      "mfvsrd",  /* move from vector to scalar reg doubleword */
      &mfvs,
   },
   {
      "mtvsrd",  /* move from scalar to vector reg doubleword */
      &mtvs,
   },
   {
      "mtfprwa", /* (extended mnemonic for mtvsrwa) move from scalar to vector reg with two’s-complement */
      &mtvs2s,
   },
   {
      "mfvsrwz", /* move from vector to scalar reg word */
      &mfvs,
   },
   {
      "mtvsrwz", /* move from scalar to vector reg word */
      &mtvs2s,
   }
};

static void test_move_special(const char* name, test_func_t func,
                                uint32_t test_flags)
{
   test_special(special_move_ops, name, func, test_flags);
}

/* Vector Double Word tests */

static void test_av_dint_two_args (const char* name, test_func_t func,
                                   unused uint32_t test_flags)
{

   unsigned long long * dst;
   unsigned int * dst_int;
   int i,j;
   int family = test_flags & PPC_FAMILY;
   int is_vpkudum, is_vpmsumd;
   if (strcmp(name, "vpkudum") == 0)
      is_vpkudum = 1;
   else
      is_vpkudum = 0;

   if (strcmp(name, "vpmsumd") == 0)
      is_vpmsumd = 1;
   else
      is_vpmsumd = 0;

   for (i = 0; i < NB_VDARGS - 1; i+=2) {
      if (isLE && family == PPC_ALTIVECQ)
         vec_inA = (vector unsigned long long){ vdargs[i+1], vdargs[i] };
      else
         vec_inA = (vector unsigned long long){ vdargs[i], vdargs[i+1] };
      for (j = 0; j < NB_VDARGS - 1; j+=2) {
         if (isLE && family == PPC_ALTIVECQ)
            vec_inB = (vector unsigned long long){ vdargs[j+1], vdargs[j] };
         else
            vec_inB = (vector unsigned long long){ vdargs[j], vdargs[j+1] };
         vec_out = (vector unsigned long long){ 0,0 };

         (*func)();
         dst_int = (unsigned int *)&vec_out;
         dst  = (unsigned long long*)&vec_out;

         printf("%s: ", name);

         if (is_vpkudum) {
            printf("Inputs: %08llx %08llx %08llx %08llx\n", vdargs[i] & 0x00000000ffffffffULL,
                   vdargs[i+1] & 0x00000000ffffffffULL, vdargs[j] & 0x00000000ffffffffULL,
                   vdargs[j+1] & 0x00000000ffffffffULL);
            if (isLE)
               printf("         Output: %08x %08x %08x %08x\n", dst_int[2], dst_int[3],
                      dst_int[0], dst_int[1]);
            else
               printf("         Output: %08x %08x %08x %08x\n", dst_int[0], dst_int[1],
                      dst_int[2], dst_int[3]);
         } else if (is_vpmsumd) {
            printf("%016llx @@ %016llx ", vdargs[i], vdargs[j]);
            if (isLE)
               printf(" ==> %016llx\n", dst[1]);
            else
               printf(" ==> %016llx\n", dst[0]);
            printf("\t%016llx @@ %016llx ", vdargs[i+1], vdargs[j+1]);
            if (isLE)
               printf(" ==> %016llx\n", dst[0]);
            else
               printf(" ==> %016llx\n", dst[1]);
         } else if (family == PPC_ALTIVECQ) {
            if (isLE)
               printf("%016llx%016llx @@ %016llx%016llx ==> %016llx%016llx\n",
                      vdargs[i], vdargs[i+1], vdargs[j], vdargs[j+1],
                      dst[1], dst[0]);
            else
               printf("%016llx%016llx @@ %016llx%016llx ==> %016llx%016llx\n",
                      vdargs[i], vdargs[i+1], vdargs[j], vdargs[j+1],
                      dst[0], dst[1]);
         } else {
            printf("%016llx @@ %016llx ", vdargs[i], vdargs[j]);
            printf(" ==> %016llx\n", dst[0]);
            printf("\t%016llx @@ %016llx ", vdargs[i+1], vdargs[j+1]);
            printf(" ==> %016llx\n", dst[1]);
         }
      }
   }
}

static void test_av_dint_one_arg (const char* name, test_func_t func,
                                  unused uint32_t test_flags)
{

   unsigned long long * dst;
   int i;

   for (i = 0; i < NB_VDARGS - 1; i+=2) {
      vec_inB = (vector unsigned long long){ vdargs[i], vdargs[i+1] };
      vec_out = (vector unsigned long long){ 0,0 };

      (*func)();
      dst  = (unsigned long long*)&vec_out;

      printf("%s: ", name);
      printf("%016llx @@ %016llx ", vdargs[i], vdargs[i + 1]);
      printf(" ==> %016llx%016llx\n", dst[0], dst[1]);
   }
}

static void test_av_dint_one_arg_SHA (const char* name, test_func_t func,
                                      unused uint32_t test_flags)
{
   unsigned long long * dst;
   int i, st, six;

   for (i = 0; i < NB_VDARGS - 1; i+=2) {
      vec_inA = (vector unsigned long long){ vdargs[i], vdargs[i+1] };
      vec_out = (vector unsigned long long){ 0,0 };

      for (st = 0; st < 2; st++) {
         for (six = 0; six < 16; six+=15) {
            st_six = (st << 4) | six;
            (*func)();
            dst  = (unsigned long long*)&vec_out;

            printf("%s: ", name);
            printf("%016llx @@ %016llx ", vdargs[i], vdargs[i + 1]);
            printf(" ==> %016llx || %016llx\n", dst[0], dst[1]);
         }
      }
   }
}

static void test_av_bcd (const char* name, test_func_t func,
                         unused uint32_t test_flags)
{
   unsigned long long * dst;
   int i, j;

   for (i = 0; i < NUM_VBCD_VALS - 1; i+=2) {
      if (isLE)
         vec_inA = (vector unsigned long long){ vbcd_args[i+1], vbcd_args[i]};
      else
         vec_inA = (vector unsigned long long){ vbcd_args[i], vbcd_args[i+1] };
      for (j = 0; j < NUM_VBCD_VALS - 1; j+=2) {
         if (isLE)
            vec_inB = (vector unsigned long long){ vbcd_args[j+1] , vbcd_args[j] };
         else
            vec_inB = (vector unsigned long long){ vbcd_args[j], vbcd_args[j+1] };
         vec_out = (vector unsigned long long){ 0, 0 };

         for (PS_bit = 0; PS_bit < 2; PS_bit++) {
            (*func)();
            dst  = (unsigned long long*)&vec_out;
            printf("%s: ", name);
            printf("%016llx || %016llx @@ %016llx || %016llx",
                   vbcd_args[i], vbcd_args[i + 1],
                   vbcd_args[j], vbcd_args[j + 1]);
            if (isLE)
               printf(" ==> %016llx || %016llx\n", dst[1], dst[0]);
            else
               printf(" ==> %016llx || %016llx\n", dst[0], dst[1]);
         }
      }
   }
}

/* Vector doubleword-to-int tests, two input args, integer result */
static void test_av_dint_to_int_two_args (const char* name, test_func_t func,
                                          unused uint32_t test_flags)
{

   unsigned int * dst_int;
   int i,j;
   for (i = 0; i < NB_VDARGS_X - 1; i+=2) {
      vec_inA = (vector unsigned long long){ vdargs_x[i], vdargs_x[i+1] };
      for (j = 0; j < NB_VDARGS_X - 1; j+=2) {
         vec_inB = (vector unsigned long long){ vdargs_x[j], vdargs_x[j+1] };
         vec_out = (vector unsigned long long){ 0,0 };

         (*func)();
         dst_int = (unsigned int *)&vec_out;

         printf("%s: ", name);
         printf("%016llx, %016llx @@ %016llx, %016llx ",
                vdargs_x[i], vdargs_x[i+1],
                vdargs_x[j], vdargs_x[j+1]);
         if (isLE)
            printf(" ==> %08x %08x %08x %08x\n", dst_int[2], dst_int[3],
                   dst_int[0], dst_int[1]);
         else
            printf(" ==> %08x %08x %08x %08x\n", dst_int[0], dst_int[1],
                   dst_int[2], dst_int[3]);
      }
   }
}

/* Vector Word tests; two integer args, with double word result */

static void test_av_wint_two_args_dres (const char* name, test_func_t func,
                                        unused uint32_t test_flags)
{

   unsigned long long * dst;
   int i,j;

   for (i = 0; i < NB_VWARGS; i+=4) {
      if (isLE)
         vec_inA_wd = (vector unsigned int){ vwargs[i+3], vwargs[i+2], vwargs[i+1], vwargs[i] };
      else
         vec_inA_wd = (vector unsigned int){ vwargs[i], vwargs[i+1], vwargs[i+2], vwargs[i+3] };
      for (j = 0; j < NB_VWARGS; j+=4) {
         if (isLE)
            vec_inB_wd = (vector unsigned int){ vwargs[j+3], vwargs[j+2], vwargs[j+1], vwargs[j] };
         else
            vec_inB_wd = (vector unsigned int){ vwargs[j], vwargs[j+1], vwargs[j+2], vwargs[j+3] };
         vec_out = (vector unsigned long long){ 0, 0 };

         (*func)();
         dst  = (unsigned long long *)&vec_out;
         printf("%s: ", name);
         if (isLE)
            printf("%08x %08x %08x %08x ==> %016llx %016llx\n",
                   vwargs[i], vwargs[i+1], vwargs[i+2], vwargs[i+3], dst[1], dst[0]);
         else
            printf("%08x %08x %08x %08x ==> %016llx %016llx\n",
                   vwargs[i], vwargs[i+1], vwargs[i+2], vwargs[i+3], dst[0], dst[1]);
      }
   }
}

/* Vector Word tests; one input arg, with double word result */

static void test_av_wint_one_arg_dres (const char* name, test_func_t func,
                                       unused uint32_t test_flags)
{
   unsigned long long * dst;
   int i;
   for (i = 0; i < NB_VWARGS; i+=4) {
      if (isLE)
         vec_inB_wd = (vector unsigned int){ vwargs[i+3], vwargs[i+2], vwargs[i+1], vwargs[i] };
      else
         vec_inB_wd = (vector unsigned int){ vwargs[i], vwargs[i+1], vwargs[i+2], vwargs[i+3] };
      vec_out = (vector unsigned long long){ 0, 0 };

      (*func)();
      dst  = (unsigned long long *)&vec_out;
      printf("%s: ", name);
      if (isLE)
         printf("%08x %08x %08x %08x ==> %016llx %016llx\n",
                vwargs[i], vwargs[i+1], vwargs[i+2], vwargs[i+3], dst[1], dst[0]);
      else
         printf("%08x %08x %08x %08x ==> %016llx %016llx\n",
                vwargs[i], vwargs[i+1], vwargs[i+2], vwargs[i+3], dst[0], dst[1]);
   }
}


static void test_int_stq_two_regs_imm16 (const char* name,
                                        test_func_t func_IN,
                                        unused uint32_t test_flags)
{
   /* Store quad word from register pair */
   int offs, k;
   HWord_t base;
   Word_t *iargs_priv;

   // private iargs table to store to, note storing pair of regs
   iargs_priv = memalign16(2 * sizeof(Word_t));

   base = (HWord_t)&iargs_priv[0];
   for (k = 0; k < 2; k++)  // clear array
      iargs_priv[k] = 0;

   offs = 0;

   /* setup source register pair */
   r14 = (HWord_t) 0xABCDEF0123456789ULL;
   r15 = (HWord_t) 0x1133557722446688ULL;

   r16 = base;                 // store to r16 + offs

   (*func_IN)();

#ifndef __powerpc64__
   printf("%s %08x,%08x, %2d => "
#else
   printf("%s %016llx,%016llx, %3d => "
#endif
            "%016llx,%016llx)\n",
            name, r14, r15, offs, iargs_priv[0], iargs_priv[1]);

   if (verbose) printf("\n");
   free(iargs_priv);
}


static void test_int_stq_three_regs (const char* name,
                                     test_func_t func_IN,
                                     unused uint32_t test_flags)
{
   /* Store quad word from register pair */
   volatile uint32_t flags, xer;
   int k;
   HWord_t base;

   base = (HWord_t)&mem_resv[0];
   for (k = 0; k < 2; k++)  // setup array for lqarx inst
      mem_resv[k] = k;

   /* setup source register pair for store */
   r14 = ZERO;
   r15 = ZERO;
   r16 = base;                 // store to r16 + r17
   r17 = ZERO;

   /* In order for the store to occur, the lqarx instruction must first
    * be used to load from the address thus creating a reservation at the
    * memory address.  The lqarx instruction is done in the test_stqcx(),
    * then registers 14, r15 are changed to the data to be stored in memory
    * by the stqcx instruction.
    */
   SET_CR_XER_ZERO;
   (*func_IN)();
   GET_CR_XER(flags,xer);
#ifndef __powerpc64__
   printf("%s %08x,%08x, =>  "
#else
   printf("%s %016llx,%016llx => "
#endif
            "%016llx,%016llx; CR=%08x\n",
            name, r14, r15, mem_resv[0], mem_resv[1], flags);

   if (verbose) printf("\n");
}

static void test_int_ldq_two_regs_imm16 (const char* name,
                                        test_func_t func_IN,
                                        unused uint32_t test_flags)
{
   /* load quad word from register pair */
   volatile uint32_t flags, xer;
   Word_t * mem_priv;
   HWord_t base;

   // private iargs table to store to, note storing pair of regs
   mem_priv = memalign16(2 * sizeof(Word_t));  // want 128-bits

   base = (HWord_t)&mem_priv[0];

   mem_priv[0] = 0xAACCEE0011335577ULL;
   mem_priv[1] = 0xABCDEF0123456789ULL;

   r14 = 0;
   r15 = 0;
   r16 = base;                 // fetch from r16 + offs
   SET_CR_XER_ZERO;
   (*func_IN)();
   GET_CR_XER(flags,xer);

#ifndef __powerpc64__
   printf("%s (0x%016llx, 0x%016llx) =>  (reg_pair = %08x,%08x)\n",
#else
   printf("%s (0x%016llx, 0x%016llx) =>  (reg_pair = 0x%016llx, 0x%016llx)\n",
#endif
          name, mem_priv[0], mem_priv[1], r14, r15);

   if (verbose) printf("\n");

   free(mem_priv);
}

static void test_int_ldq_three_regs (const char* name,
                                     test_func_t func_IN,
                                     unused uint32_t test_flags)
{
   /* load quad word from register pair */
   HWord_t base;

   base = (HWord_t)&mem_resv[0];

   mem_resv[0] = 0xAACCEE0011335577ULL;
   mem_resv[1] = 0xABCDEF0123456789ULL;

   r14 = 0;
   r15 = 0;
   r16 = base;                 // fetch from r16 + r17
   r17 = 0;

   (*func_IN)();

#ifndef __powerpc64__
   printf("%s (0x%016llx, 0x%016llx) =>  (reg_pair = 0x%08x, 0x%08x)\n",
#else
   printf("%s (0x%016llx, 0x%016llx) =>  (reg_pair = 0x%016llx, 0x%016llx)\n",
#endif
          name, mem_resv[0], mem_resv[1], r14, r15);
   if (verbose) printf("\n");

}

static void test_av_dint_three_args (const char* name, test_func_t func,
                                     unused uint32_t test_flags)
{

   unsigned long long * dst;
   int i,j, k;
   int family = test_flags & PPC_FAMILY;
   unsigned long long cin_vals[] = {
                                    // First pair of ULLs have LSB=0, so cin is '0'.
                                    // Second pair of ULLs have LSB=1, so cin is '1'.
                                    0xf000000000000000ULL, 0xf000000000000000ULL,
                                    0xf000000000000000ULL, 0xf000000000000001ULL
   };
   for (i = 0; i < NB_VDARGS - 1; i+=2) {
      if (isLE)
         vec_inA = (vector unsigned long long){ vdargs[i+1], vdargs[i] };
      else
         vec_inA = (vector unsigned long long){ vdargs[i], vdargs[i+1] };
      for (j = 0; j < NB_VDARGS - 1; j+=2) {
         if (isLE)
            vec_inB = (vector unsigned long long){ vdargs[j+1], vdargs[j] };
         else
            vec_inB = (vector unsigned long long){ vdargs[j], vdargs[j+1] };
         for (k = 0; k < 4 - 1; k+=2) {
            if (family == PPC_ALTIVECQ) {
               if (isLE)
                  vec_inC = (vector unsigned long long){ cin_vals[k+1], cin_vals[k] };
               else
                  vec_inC = (vector unsigned long long){ cin_vals[k], cin_vals[k+1] };
            } else {
               if (isLE)
                  vec_inC = (vector unsigned long long){ vdargs[k+1], vdargs[k] };
               else
                  vec_inC = (vector unsigned long long){ vdargs[k], vdargs[k+1] };
            }
            vec_out = (vector unsigned long long){ 0,0 };

            (*func)();
            dst  = (unsigned long long*)&vec_out;
            printf("%s: ", name);
            if (family == PPC_ALTIVECQ) {
               if (isLE)
                  printf("%016llx%016llx @@ %016llx%016llx @@ %llx ==> %016llx%016llx\n",
                         vdargs[i], vdargs[i+1], vdargs[j], vdargs[j+1], cin_vals[k+1],
                         dst[1], dst[0]);
               else
                  printf("%016llx%016llx @@ %016llx%016llx @@ %llx ==> %016llx%016llx\n",
                         vdargs[i], vdargs[i+1], vdargs[j], vdargs[j+1], cin_vals[k+1],
                         dst[0], dst[1]);
            } else {
               printf("%016llx @@ %016llx @@ %016llx ", vdargs[i], vdargs[j], vdargs[k]);
               if (isLE)
                  printf(" ==> %016llx\n", dst[1]);
               else
                  printf(" ==> %016llx\n", dst[0]);
               printf("\t%016llx @@ %016llx @@ %016llx ", vdargs[i+1], vdargs[j+1], vdargs[k+1]);
               if (isLE)
                  printf(" ==> %016llx\n", dst[0]);
               else
                  printf(" ==> %016llx\n", dst[1]);
            }
         }
      }
   }
}


/* The ALTIVEC_LOOPS and altive_loops defined below are used in do_tests.
 * Add new values to the end; do not change order, since the altivec_loops
 * array is indexed using the enumerated values defined by ALTIVEC_LOOPS.
 */
enum ALTIVEC_LOOPS {
   ALTV_MOV,
   ALTV_DINT,
   ALTV_INT_DRES,
   ALTV_DINT_IRES,
   ALTV_ONE_INT_DRES,
   ALTV_DINT_THREE_ARGS,
   ALTV_DINT_ONE_ARG,
   ALTV_SHA,
   ATLV_BCD
};

static test_loop_t altivec_loops[] = {
   &test_move_special,
   &test_av_dint_two_args,
   &test_av_wint_two_args_dres,
   &test_av_dint_to_int_two_args,
   &test_av_wint_one_arg_dres,
   &test_av_dint_three_args,
   &test_av_dint_one_arg,
   &test_av_dint_one_arg_SHA,
   &test_av_bcd,
   NULL
};

/* Used in do_tests, indexed by flags->nb_args
   Elements correspond to enum test_flags::num args
*/
static test_loop_t int_loops[] = {
  /* The #defines for the family, number registers need the array
   * to be properly indexed.  This test is for the new ISA 2.0.7
   * instructions.  The infrastructure has been left for the momemnt
   */
   NULL, //&test_int_one_arg,
   NULL, //&test_int_two_args,
   NULL, //&test_int_three_args,
   NULL, //&test_int_two_args,
   NULL, //&test_int_one_reg_imm16,
   NULL, //&test_int_one_reg_imm16,
   NULL, //&test_int_special,
   NULL, //&test_int_ld_one_reg_imm16,
   NULL, //&test_int_ld_two_regs,
   NULL, //&test_int_st_two_regs_imm16,
   NULL, //&test_int_st_three_regs,
   &test_int_stq_two_regs_imm16,
   &test_int_ldq_two_regs_imm16,
   &test_int_stq_three_regs,
   &test_int_ldq_three_regs,
};

/* Used in do_tests, indexed by flags->nb_args
   Elements correspond to enum test_flags::num args
   Must have NULL for last entry.
 */
static test_loop_t float_loops[] = {
   NULL,
   &test_float_two_args,
};


static test_t tests_fa_ops_two[] = {
    { &test_fmrgew          , "fmrgew", },
    { &test_fmrgow          , "fmrgow", },
    { NULL,                   NULL,           },
};

static test_table_t all_tests[] = {
   {
       tests_move_ops_spe,
       "PPC VSR special move insns",
       PPC_ALTIVECD | PPC_MOV | PPC_ONE_ARG,
   },
   {
       tests_aa_dbl_ops_two_args,
       "PPC altivec double word integer insns (arith, compare) with two args",
       PPC_ALTIVECD | PPC_ARITH | PPC_TWO_ARGS,
   },
   {
       tests_aa_word_ops_two_args_dres,
       "PPC altivec integer word instructions with two input args, double word result",
       PPC_ALTIVEC | PPC_ARITH_DRES | PPC_TWO_ARGS,
   },
   {
       tests_aa_dbl_to_int_two_args,
       "PPC altivec doubleword-to-integer instructions with two input args, saturated integer result",
       PPC_ALTIVECD | PPC_DOUBLE_IN_IRES | PPC_TWO_ARGS,
   },
   {
       tests_aa_word_ops_one_arg_dres,
       "PPC altivec integer word instructions with one input arg, double word result",
       PPC_ALTIVEC | PPC_ARITH_DRES | PPC_ONE_ARG,
   },
   {
      tests_istq_ops_two_i16,
      "PPC store quadword insns\n    with one register + one 16 bits immediate args with flags update",
      0x0001050c,
   },
   {
      tests_ildq_ops_two_i16,
      "PPC load quadword insns\n    with one register + one 16 bits immediate args with flags update",
      0x0001050d,
   },
   {
       tests_ldq_ops_three,
       "PPC load quadword insns\n    with three register args",
       0x0001050f,
   },
   {
       tests_stq_ops_three,
       "PPC store quadword insns\n    with three register args",
       0x0001050e,
   },
   {
       tests_fa_ops_two,
       "PPC floating point arith insns with two args",
       0x00020102,
   },
   {
       tests_aa_ops_three    ,
       "PPC altivec integer logical insns with three args",
       0x00060203,
   },
   {
       tests_aa_dbl_ops_one_arg,
       "PPC altivec one vector input arg, hex result",
       0x00060201,
   },
   {
       tests_aa_SHA_ops,
       "PPC altivec SSH insns",
       0x00040B01,
   },
   {
       tests_aa_bcd_ops,
       "PPC altivec BCD insns",
       0x00040B02,
   },
   {
       tests_aa_quadword_two_args,
       "PPC altivec quadword insns, two input args",
       0x00070102,
   },
   {
       tests_aa_quadword_three_args,
       "PPC altivec quadword insns, three input args",
       0x00070103
   },
   { NULL,                   NULL,               0x00000000, },
};

static void do_tests ( insn_sel_flags_t seln_flags,
                       char *filter)
{
   test_loop_t *loop;
   test_t *tests;
   int nb_args, type, family;
   int i, j, n;
   int exact;

   exact = check_filter(filter);
   n = 0;
   for (i=0; all_tests[i].name != NULL; i++) {
      nb_args = all_tests[i].flags & PPC_NB_ARGS;

      /* Check number of arguments */
      if ((nb_args == 1 && !seln_flags.one_arg) ||
          (nb_args == 2 && !seln_flags.two_args) ||
          (nb_args == 3 && !seln_flags.three_args)){
         continue;
      }
      /* Check instruction type */
      type = all_tests[i].flags & PPC_TYPE;
      if ((type == PPC_ARITH   && !seln_flags.arith)   ||
          (type == PPC_LOGICAL && !seln_flags.logical) ||
          (type == PPC_COMPARE && !seln_flags.compare) ||
          (type == PPC_LDST && !seln_flags.ldst)       ||
          (type == PPC_MOV && !seln_flags.ldst)       ||
          (type == PPC_POPCNT && !seln_flags.arith)) {
         continue;
      }

      /* Check instruction family */
      family = all_tests[i].flags & PPC_FAMILY;
      if ((family == PPC_INTEGER  && !seln_flags.integer) ||
          (family == PPC_FLOAT    && !seln_flags.floats)  ||
          (family == PPC_ALTIVEC && !seln_flags.altivec)  ||
          (family == PPC_ALTIVECD && !seln_flags.altivec)  ||
          (family == PPC_ALTIVECQ && !seln_flags.altivec)  ||
          (family == PPC_FALTIVEC && !seln_flags.faltivec)) {
         continue;
      }
      /* Check flags update */
      if (((all_tests[i].flags & PPC_CR)  && seln_flags.cr == 0) ||
          (!(all_tests[i].flags & PPC_CR) && seln_flags.cr == 1))
         continue;

      /* All passed, do the tests */
      tests = all_tests[i].tests;

      loop = NULL;

      /* Select the test loop */
      switch (family) {
      case PPC_INTEGER:
         mem_resv = memalign16(2 * sizeof(HWord_t));  // want 128-bits
         loop = &int_loops[nb_args - 1];
         break;

      case PPC_FLOAT:
         loop = &float_loops[nb_args - 1];
         break;

      case PPC_ALTIVECQ:
         if (nb_args == 2)
            loop = &altivec_loops[ALTV_DINT];
         else if (nb_args == 3)
            loop = &altivec_loops[ALTV_DINT_THREE_ARGS];
         break;
      case PPC_ALTIVECD:
         switch (type) {
         case PPC_MOV:
            loop = &altivec_loops[ALTV_MOV];
            break;
         case PPC_ARITH:
            loop = &altivec_loops[ALTV_DINT];
            break;
         case PPC_DOUBLE_IN_IRES:
            loop = &altivec_loops[ALTV_DINT_IRES];
            break;
         case PPC_LOGICAL:
            if (nb_args == 3)
               loop = &altivec_loops[ALTV_DINT_THREE_ARGS];
            else if (nb_args ==1)
               loop = &altivec_loops[ALTV_DINT_ONE_ARG];
            break;
         default:
            printf("No altivec test defined for type %x\n", type);
         }
         break;

      case PPC_FALTIVEC:
         printf("Currently there are no floating altivec tests in this testsuite.\n");
         break;

      case PPC_ALTIVEC:
         switch (type) {
         case PPC_ARITH_DRES:
         {
            switch (nb_args) {
            case 1:
               loop = &altivec_loops[ALTV_ONE_INT_DRES];
               break;
            case 2:
               loop = &altivec_loops[ALTV_INT_DRES];
               break;
            default:
               printf("No altivec test defined for number args %d\n", nb_args);
            }
            break;
         }
         case PPC_SHA_OR_BCD:
            if (nb_args == 1)
               loop = &altivec_loops[ALTV_SHA];
            else
               loop = &altivec_loops[ATLV_BCD];
            break;
         default:
            printf("No altivec test defined for type %x\n", type);
         }
         break;

      default:
         printf("ERROR: unknown insn family %08x\n", family);
         continue;
      }
      if (1 || verbose > 0)
      for (j=0; tests[j].name != NULL; j++) {
         if (check_name(tests[j].name, filter, exact)) {
            if (verbose > 1)
               printf("Test instruction %s\n", tests[j].name);
            if (loop != NULL)
               (*loop)(tests[j].name, tests[j].func, all_tests[i].flags);
            printf("\n");
            n++;
         }
        }
      if (verbose) printf("\n");
   }
   printf("All done. Tested %d different instructions\n", n);
}


static void usage (void)
{
   fprintf(stderr,
           "Usage: jm-insns [OPTION]\n"
           "\t-i: test integer instructions (default)\n"
           "\t-f: test floating point instructions\n"
           "\t-a: test altivec instructions\n"
           "\t-A: test all (int, fp, altivec) instructions\n"
           "\t-v: be verbose\n"
           "\t-h: display this help and exit\n"
           );
}

#endif

int main (int argc, char **argv)
{
#ifdef HAS_ISA_2_07
   /* Simple usage:
      ./jm-insns -i   => int insns
      ./jm-insns -f   => fp  insns
      ./jm-insns -a   => av  insns
      ./jm-insns -A   => int, fp and avinsns
   */
   char *filter = NULL;
   insn_sel_flags_t flags;
   int c;

   // Args
   flags.one_arg    = 1;
   flags.two_args   = 1;
   flags.three_args = 1;
   // Type
   flags.arith      = 1;
   flags.logical    = 1;
   flags.compare    = 1;
   flags.ldst       = 1;
   // Family
   flags.integer    = 0;
   flags.floats     = 0;
   flags.altivec    = 0;
   flags.faltivec   = 0;
   // Flags
   flags.cr         = 2;

   while ((c = getopt(argc, argv, "ifahvA")) != -1) {
      switch (c) {
      case 'i':
         flags.integer  = 1;
         break;
      case 'f':
         build_fargs_table();
         flags.floats   = 1;
         break;
      case 'a':
         flags.altivec  = 1;
         flags.faltivec = 1;
         break;
      case 'A':
         flags.integer  = 1;
         flags.floats   = 1;
         flags.altivec  = 1;
         flags.faltivec = 1;
         break;
      case 'h':
         usage();
         return 0;
      case 'v':
         verbose++;
         break;
      default:
         usage();
         fprintf(stderr, "Unknown argument: '%c'\n", c);
         return 1;
      }
   }

   arg_list_size = 0;

   build_vargs_table();
   if (verbose > 1) {
      printf("\nInstruction Selection:\n");
      printf("  n_args: \n");
      printf("    one_arg    = %d\n", flags.one_arg);
      printf("    two_args   = %d\n", flags.two_args);
      printf("    three_args = %d\n", flags.three_args);
      printf("  type: \n");
      printf("    arith      = %d\n", flags.arith);
      printf("    logical    = %d\n", flags.logical);
      printf("    compare    = %d\n", flags.compare);
      printf("    ldst       = %d\n", flags.ldst);
      printf("  family: \n");
      printf("    integer    = %d\n", flags.integer);
      printf("    floats     = %d\n", flags.floats);
      printf("    altivec    = %d\n", flags.altivec);
      printf("    faltivec   = %d\n", flags.faltivec);
      printf("  cr update: \n");
      printf("    cr         = %d\n", flags.cr);
      printf("\n");
   }

   do_tests( flags, filter );
#else
   printf("NO ISA 2.07 SUPPORT\n");
#endif
   return 0;
}