/*  Copyright (C) 2012 IBM

 Author: 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.

 The GNU General Public License is contained in the file COPYING.
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>

#if defined(HAS_DFP)

register double f14 __asm__ ("fr14");
register double f15 __asm__ ("fr15");
register double f16 __asm__ ("fr16");
register double f17 __asm__ ("fr17");
register double f18 __asm__ ("fr18");
register double f19 __asm__ ("fr19");


typedef unsigned char Bool;
#define True 1
#define False 0


#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 GET_FPSCR(_arg) \
    __asm__ __volatile__ ("mffs %0"  : "=f"(_arg) )

#define SET_FPSCR_DRN \
    __asm__ __volatile__ ("mtfsf  1, %0, 0, 1" :  : "f"(f14) )


// The assembly-level instructions being tested
static void _test_drintx(int R, int RMC)
{
   if (RMC < 0 || RMC > 3 || R < 0 || R > 1) {
      fprintf(stderr, "Invalid inputs to asm test: a=%d, b=%d\n", R, RMC);
      return;
   }
   switch (RMC) {
      case 0:
         if (R)
            __asm__ __volatile__ ("drintx 1, %0, %1, 0" : "=f" (f18) : "f" (f16));
         else
            __asm__ __volatile__ ("drintx 0, %0, %1, 0" : "=f" (f18) : "f" (f16));
         break;
      case 1:
         if (R)
            __asm__ __volatile__ ("drintx 1, %0, %1, 1" : "=f" (f18) : "f" (f16));
         else
            __asm__ __volatile__ ("drintx 0, %0, %1, 1" : "=f" (f18) : "f" (f16));
         break;
      case 2:
         if (R)
            __asm__ __volatile__ ("drintx 1, %0, %1, 2" : "=f" (f18) : "f" (f16));
         else
            __asm__ __volatile__ ("drintx 0, %0, %1, 2" : "=f" (f18) : "f" (f16));
         break;
      case 3:
         if (R)
            __asm__ __volatile__ ("drintx 1, %0, %1, 3" : "=f" (f18) : "f" (f16));
         else
            __asm__ __volatile__ ("drintx 0, %0, %1, 3" : "=f" (f18) : "f" (f16));
         break;
      default:
         break;
   }
}

static void _test_drintn(int R, int RMC)
{
   if (RMC < 0 || RMC > 3 || R < 0 || R > 1) {
      fprintf(stderr, "Invalid inputs to asm test: a=%d, b=%d\n", R, RMC);
      return;
   }
   switch (RMC) {
      case 0:
         if (R)
            __asm__ __volatile__ ("drintn 1, %0, %1, 0" : "=f" (f18) : "f" (f16));
         else
            __asm__ __volatile__ ("drintn 0, %0, %1, 0" : "=f" (f18) : "f" (f16));
         break;
      case 1:
         if (R)
            __asm__ __volatile__ ("drintn 1, %0, %1, 1" : "=f" (f18) : "f" (f16));
         else
            __asm__ __volatile__ ("drintn 0, %0, %1, 1" : "=f" (f18) : "f" (f16));
         break;
      case 2:
         if (R)
            __asm__ __volatile__ ("drintn 1, %0, %1, 2" : "=f" (f18) : "f" (f16));
         else
            __asm__ __volatile__ ("drintn 0, %0, %1, 2" : "=f" (f18) : "f" (f16));
         break;
      case 3:
         if (R)
            __asm__ __volatile__ ("drintn 1, %0, %1, 3" : "=f" (f18) : "f" (f16));
         else
            __asm__ __volatile__ ("drintn 0, %0, %1, 3" : "=f" (f18) : "f" (f16));
         break;
      default:
         break;
   }
}


static void _test_diex(int a __attribute__((unused)), int b __attribute__((unused)))
{
   __asm__ __volatile__ ("diex  %0, %1, %2" : "=f" (f18) : "f" (f14),"f" (f16));
}

static void _test_dxex(int a __attribute__((unused)), int b __attribute__((unused)))
{
   __asm__ __volatile__ ("dxex  %0, %1" : "=f" (f18) : "f" (f16));
}

static void _test_dcmpo(int BF, int x __attribute__((unused)))
{
   if (BF < 0 || BF > 7) {
      fprintf(stderr, "Invalid input to asm test: a=%d\n", BF);
      return;
   }
   switch (BF) {
      case 0:
         __asm__ __volatile__ ("dcmpo  0, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 1:
         __asm__ __volatile__ ("dcmpo  1, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 2:
         __asm__ __volatile__ ("dcmpo  2, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 3:
         __asm__ __volatile__ ("dcmpo  3, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 4:
         __asm__ __volatile__ ("dcmpo  4, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 5:
         __asm__ __volatile__ ("dcmpo  5, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 6:
         __asm__ __volatile__ ("dcmpo  6, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 7:
         __asm__ __volatile__ ("dcmpo  7, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      default:
         break;
   }
}

static void _test_dcmpu(int BF, int x __attribute__((unused)))
{
   if (BF < 0 || BF > 7) {
      fprintf(stderr, "Invalid input to asm test: a=%d\n", BF);
      return;
   }
   switch (BF) {
      case 0:
         __asm__ __volatile__ ("dcmpu  0, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 1:
         __asm__ __volatile__ ("dcmpu  1, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 2:
         __asm__ __volatile__ ("dcmpu  2, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 3:
         __asm__ __volatile__ ("dcmpu  3, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 4:
         __asm__ __volatile__ ("dcmpu  4, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 5:
         __asm__ __volatile__ ("dcmpu  5, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 6:
         __asm__ __volatile__ ("dcmpu  6, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 7:
         __asm__ __volatile__ ("dcmpu  7, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      default:
         break;
   }
}

// Quad instruction testing
static void _test_drintxq(int R, int RMC)
{
   if (RMC < 0 || RMC > 3 || R < 0 || R > 1) {
      fprintf(stderr, "Invalid inputs to asm test: a=%d, b=%d\n", R, RMC);
      return;
   }
   switch (RMC) {
      case 0:
         if (R)
            __asm__ __volatile__ ("drintxq 1, %0, %1, 0" : "=f" (f18) : "f" (f16));
         else
            __asm__ __volatile__ ("drintxq 0, %0, %1, 0" : "=f" (f18) : "f" (f16));
         break;
      case 1:
         if (R)
            __asm__ __volatile__ ("drintxq 1, %0, %1, 1" : "=f" (f18) : "f" (f16));
         else
            __asm__ __volatile__ ("drintxq 0, %0, %1, 1" : "=f" (f18) : "f" (f16));
         break;
      case 2:
         if (R)
            __asm__ __volatile__ ("drintxq 1, %0, %1, 2" : "=f" (f18) : "f" (f16));
         else
            __asm__ __volatile__ ("drintxq 0, %0, %1, 2" : "=f" (f18) : "f" (f16));
         break;
      case 3:
         if (R)
            __asm__ __volatile__ ("drintxq 1, %0, %1, 3" : "=f" (f18) : "f" (f16));
         else
            __asm__ __volatile__ ("drintxq 0, %0, %1, 3" : "=f" (f18) : "f" (f16));
         break;
      default:
         break;
   }
}

static void _test_drintnq(int R, int RMC)
{
   if (RMC < 0 || RMC > 3 || R < 0 || R > 1) {
      fprintf(stderr, "Invalid inputs to asm test: a=%d, b=%d\n", R, RMC);
      return;
   }
   switch (RMC) {
      case 0:
         if (R)
            __asm__ __volatile__ ("drintnq 1, %0, %1, 0" : "=f" (f18) : "f" (f16));
         else
            __asm__ __volatile__ ("drintnq 0, %0, %1, 0" : "=f" (f18) : "f" (f16));
         break;
      case 1:
         if (R)
            __asm__ __volatile__ ("drintnq 1, %0, %1, 1" : "=f" (f18) : "f" (f16));
         else
            __asm__ __volatile__ ("drintnq 0, %0, %1, 1" : "=f" (f18) : "f" (f16));
         break;
      case 2:
         if (R)
            __asm__ __volatile__ ("drintnq 1, %0, %1, 2" : "=f" (f18) : "f" (f16));
         else
            __asm__ __volatile__ ("drintnq 0, %0, %1, 2" : "=f" (f18) : "f" (f16));
         break;
      case 3:
         if (R)
            __asm__ __volatile__ ("drintnq 1, %0, %1, 3" : "=f" (f18) : "f" (f16));
         else
            __asm__ __volatile__ ("drintnq 0, %0, %1, 3" : "=f" (f18) : "f" (f16));
         break;
      default:
         break;
   }
}

static void _test_diexq(int a __attribute__((unused)), int b __attribute__((unused)))
{
   __asm__ __volatile__ ("diexq  %0, %1, %2" : "=f" (f18) : "f" (f14),"f" (f16));
}

static void _test_dxexq(int a __attribute__((unused)), int b __attribute__((unused)))
{
   __asm__ __volatile__ ("dxexq  %0, %1" : "=f" (f18) : "f" (f16));
}

static void _test_dcmpoq(int BF, int x __attribute__((unused)))
{
   if (BF < 0 || BF > 7) {
      fprintf(stderr, "Invalid input to asm test: a=%d\n", BF );
      return;
   }
   switch (BF) {
      case 0:
         __asm__ __volatile__ ("dcmpoq  0, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 1:
         __asm__ __volatile__ ("dcmpoq  1, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 2:
         __asm__ __volatile__ ("dcmpoq  2, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 3:
         __asm__ __volatile__ ("dcmpoq  3, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 4:
         __asm__ __volatile__ ("dcmpoq  4, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 5:
         __asm__ __volatile__ ("dcmpoq  5, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 6:
         __asm__ __volatile__ ("dcmpoq  6, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 7:
         __asm__ __volatile__ ("dcmpoq  7, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      default:
         break;
   }
}

static void _test_dcmpuq(int BF, int x __attribute__((unused)))
{
   if (BF < 0 || BF > 7) {
      fprintf(stderr, "Invalid input to asm test: a=%d\n", BF);
      return;
   }
   switch (BF) {
      case 0:
         __asm__ __volatile__ ("dcmpuq  0, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 1:
         __asm__ __volatile__ ("dcmpuq  1, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 2:
         __asm__ __volatile__ ("dcmpuq  2, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 3:
         __asm__ __volatile__ ("dcmpuq  3, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 4:
         __asm__ __volatile__ ("dcmpuq  4, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 5:
         __asm__ __volatile__ ("dcmpuq  5, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 6:
         __asm__ __volatile__ ("dcmpuq  6, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      case 7:
         __asm__ __volatile__ ("dcmpuq  7, %0, %1" :  : "f" (f14),"f" (f16));
         break;
      default:
         break;
   }
}

static void _test_drrnd(int x __attribute__((unused)), int RMC)
{
   if (RMC < 0 || RMC > 31) {
      fprintf(stderr, "Invalid input to asm test: a=%d\n", RMC);
      return;
   }
   switch (RMC) {
      case 0:
         __asm__ __volatile__ ("drrnd %0, %1, %2, 0" : "=f" (f18) : "f" (f14), "f" (f16));
         break;
      case 1:
         __asm__ __volatile__ ("drrnd %0, %1, %2, 1" : "=f" (f18) : "f" (f14), "f" (f16));
         break;
      case 2:
         __asm__ __volatile__ ("drrnd %0, %1, %2, 2" : "=f" (f18) : "f" (f14), "f" (f16));
         break;
      case 3:
         __asm__ __volatile__ ("drrnd %0, %1, %2, 3" : "=f" (f18) : "f" (f14), "f" (f16));
         break;
      default:
         break;
   }
}

static void _test_drrndq(int x __attribute__((unused)), int RMC)
{
   if (RMC < 0 || RMC > 3) {
      fprintf(stderr, "Invalid input to asm test: a=%dn", RMC);
      return;
   }
   switch (RMC) {
      case 0:
         __asm__ __volatile__ ("drrndq %0, %1, %2, 0" : "=f" (f18) : "f" (f14), "f" (f16));
         break;
      case 1:
         __asm__ __volatile__ ("drrndq %0, %1, %2, 1" : "=f" (f18) : "f" (f14), "f" (f16));
         break;
      case 2:
         __asm__ __volatile__ ("drrndq %0, %1, %2, 2" : "=f" (f18) : "f" (f14), "f" (f16));
         break;
      case 3:
         __asm__ __volatile__ ("drrndq %0, %1, %2, 3" : "=f" (f18) : "f" (f14), "f" (f16));
         break;
      default:
         break;
   }
}

static void _test_dqua(int x __attribute__((unused)), int RMC)
{
   if (RMC < 0 || RMC > 3) {
      fprintf(stderr, "Invalid input to asm test: a=%d\n", RMC);
      return;
   }
   switch (RMC) {
      case 0:
         __asm__ __volatile__ ("dqua %0, %1, %2, 0" : "=f" (f18) : "f" (f14), "f" (f16));
         break;
      case 1:
         __asm__ __volatile__ ("dqua %0, %1, %2, 1" : "=f" (f18) : "f" (f14), "f" (f16));
         break;
      case 2:
         __asm__ __volatile__ ("dqua %0, %1, %2, 2" : "=f" (f18) : "f" (f14), "f" (f16));
         break;
      case 3:
         __asm__ __volatile__ ("dqua %0, %1, %2, 3" : "=f" (f18) : "f" (f14), "f" (f16));
         break;
      default:
         break;
   }
}

static void _test_dquaq(int x __attribute__((unused)), int RMC)
{
   if (RMC < 0 || RMC > 3) {
      fprintf(stderr, "Invalid input to asm test: a=%d\n", RMC);
      return;
   }
   switch (RMC) {
      case 0:
         __asm__ __volatile__ ("dquaq %0, %1, %2, 0" : "=f" (f18) : "f" (f14), "f" (f16));
         break;
      case 1:
         __asm__ __volatile__ ("dquaq %0, %1, %2, 1" : "=f" (f18) : "f" (f14), "f" (f16));
         break;
      case 2:
         __asm__ __volatile__ ("dquaq %0, %1, %2, 2" : "=f" (f18) : "f" (f14), "f" (f16));
         break;
      case 3:
         __asm__ __volatile__ ("dquaq %0, %1, %2, 3" : "=f" (f18) : "f" (f14), "f" (f16));
         break;
      default:
         break;
   }
}

static int TE_vals[] = { -16, -2, 0, 5};
#define TE_VAL_LEN sizeof(TE_vals)/sizeof(int)
static Bool __is_TE_val(int x)
{
   int i;
   for (i = 0; i < TE_VAL_LEN; i++) {
      if (x==TE_vals[i])
         return True;
   }
   return False;
}

static void _test_dquai(int TE, int RMC)
{
   if (RMC < 0 || RMC > 3 || !__is_TE_val(TE)) {
      fprintf(stderr, "Invalid inputs to asm test: a=%d, b=%d\n", TE, RMC);
      return;
   }
   switch (RMC) {
      case 0:
         switch (TE) {
            case -16:
               __asm__ __volatile__ ("dquai -16, %0, %1, 0" : "=f" (f18) : "f" (f16));
               break;
            case -2:
               __asm__ __volatile__ ("dquai  -2, %0, %1, 0" : "=f" (f18) : "f" (f16));
               break;
            case 0:
               __asm__ __volatile__ ("dquai   0, %0, %1, 0" : "=f" (f18) : "f" (f16));
               break;
            case 5:
               __asm__ __volatile__ ("dquai   5, %0, %1, 0" : "=f" (f18) : "f" (f16));
               break;
            default:
               break;
         }
         break;
      case 1:
         switch (TE) {
            case -16:
               __asm__ __volatile__ ("dquai -16, %0, %1, 1" : "=f" (f18) : "f" (f16));
               break;
            case -2:
               __asm__ __volatile__ ("dquai  -2, %0, %1, 1" : "=f" (f18) : "f" (f16));
               break;
            case 0:
               __asm__ __volatile__ ("dquai   0, %0, %1, 1" : "=f" (f18) : "f" (f16));
               break;
            case 5:
               __asm__ __volatile__ ("dquai   5, %0, %1, 1" : "=f" (f18) : "f" (f16));
               break;
            default:
               break;
         }
         break;
      case 2:
         switch (TE) {
            case -16:
               __asm__ __volatile__ ("dquai -16, %0, %1, 2" : "=f" (f18) : "f" (f16));
               break;
            case -2:
               __asm__ __volatile__ ("dquai  -2, %0, %1, 2" : "=f" (f18) : "f" (f16));
               break;
            case 0:
               __asm__ __volatile__ ("dquai   0, %0, %1, 2" : "=f" (f18) : "f" (f16));
               break;
            case 5:
               __asm__ __volatile__ ("dquai   5, %0, %1, 2" : "=f" (f18) : "f" (f16));
               break;
            default:
               break;
         }
         break;
      case 3:
         switch (TE) {
            case -16:
               __asm__ __volatile__ ("dquai -16, %0, %1, 3" : "=f" (f18) : "f" (f16));
               break;
            case -2:
               __asm__ __volatile__ ("dquai  -2, %0, %1, 3" : "=f" (f18) : "f" (f16));
               break;
            case 0:
               __asm__ __volatile__ ("dquai   0, %0, %1, 3" : "=f" (f18) : "f" (f16));
               break;
            case 5:
               __asm__ __volatile__ ("dquai   5, %0, %1, 3" : "=f" (f18) : "f" (f16));
               break;
            default:
               break;
         }
         break;
      default:
         break;
   }
}

static void _test_dquaiq(int TE, int RMC)
{
   if (RMC < 0 || RMC > 3 || !__is_TE_val(TE)) {
      fprintf(stderr, "Invalid inputs to asm test: a=%d, b=%d\n", TE, RMC);
      return;
   }
   switch (RMC) {
      case 0:
         switch (TE) {
            case -16:
               __asm__ __volatile__ ("dquaiq -16, %0, %1, 0" : "=f" (f18) : "f" (f16));
               break;
            case -2:
               __asm__ __volatile__ ("dquaiq  -2, %0, %1, 0" : "=f" (f18) : "f" (f16));
               break;
            case 0:
               __asm__ __volatile__ ("dquaiq   0, %0, %1, 0" : "=f" (f18) : "f" (f16));
               break;
            case 5:
               __asm__ __volatile__ ("dquaiq   5, %0, %1, 0" : "=f" (f18) : "f" (f16));
               break;
            default:
               break;
         }
         break;
      case 1:
         switch (TE) {
            case -16:
               __asm__ __volatile__ ("dquaiq -16, %0, %1, 1" : "=f" (f18) : "f" (f16));
               break;
            case -2:
               __asm__ __volatile__ ("dquaiq  -2, %0, %1, 1" : "=f" (f18) : "f" (f16));
               break;
            case 0:
               __asm__ __volatile__ ("dquaiq   0, %0, %1, 1" : "=f" (f18) : "f" (f16));
               break;
            case 5:
               __asm__ __volatile__ ("dquaiq   5, %0, %1, 1" : "=f" (f18) : "f" (f16));
               break;
            default:
               break;
         }
         break;
      case 2:
         switch (TE) {
            case -16:
               __asm__ __volatile__ ("dquaiq -16, %0, %1, 2" : "=f" (f18) : "f" (f16));
               break;
            case -2:
               __asm__ __volatile__ ("dquaiq  -2, %0, %1, 2" : "=f" (f18) : "f" (f16));
               break;
            case 0:
               __asm__ __volatile__ ("dquaiq   0, %0, %1, 2" : "=f" (f18) : "f" (f16));
               break;
            case 5:
               __asm__ __volatile__ ("dquaiq   5, %0, %1, 2" : "=f" (f18) : "f" (f16));
               break;
            default:
               break;
         }
         break;
      case 3:
         switch (TE) {
            case -16:
               __asm__ __volatile__ ("dquaiq -16, %0, %1, 3" : "=f" (f18) : "f" (f16));
               break;
            case -2:
               __asm__ __volatile__ ("dquaiq  -2, %0, %1, 3" : "=f" (f18) : "f" (f16));
               break;
            case 0:
               __asm__ __volatile__ ("dquaiq   0, %0, %1, 3" : "=f" (f18) : "f" (f16));
               break;
            case 5:
               __asm__ __volatile__ ("dquaiq   5, %0, %1, 3" : "=f" (f18) : "f" (f16));
               break;
            default:
               break;
         }
         break;
      default:
         break;
   }
}


typedef void (*test_func_t)(int a, int b);
typedef void (*test_driver_func_t)(void);
typedef struct test_table
{
   test_driver_func_t test_category;
   char * name;
} test_table_t;

/*
 *  345.0DD (0x2207c00000000000 0xe50)
 *  1.2300e+5DD (0x2207c00000000000 0x14c000)
 *  -16.0DD (0xa207c00000000000 0xe0)
 *  0.00189DD (0x2206c00000000000 0xcf)
 *  -4.1235DD (0xa205c00000000000 0x10a395bcf)
 *  9.8399e+20DD (0x2209400000000000 0x253f1f534acdd4)
 *  0DD (0x2208000000000000 0x0)
 *  0DD (0x2208000000000000 0x0)
 *  infDD (0x7800000000000000 0x0)
 *  nanDD (0x7c00000000000000 0x0
 */
static unsigned long long dfp128_vals[] = {
                                    // Some finite numbers
                                    0x2207c00000000000ULL, 0x0000000000000e50ULL,
                                    0x2207c00000000000ULL, 0x000000000014c000ULL,
                                    0xa207c00000000000ULL, 0x00000000000000e0ULL,
                                    0x2206c00000000000ULL, 0x00000000000000cfULL,
                                    0xa205c00000000000ULL, 0x000000010a395bcfULL,
                                    0x6209400000fd0000ULL, 0x00253f1f534acdd4ULL, // huge number
                                    0x000400000089b000ULL, 0x0a6000d000000049ULL, // very small number
                                    // flavors of zero
                                    0x2208000000000000ULL, 0x0000000000000000ULL,
                                    0xa208000000000000ULL, 0x0000000000000000ULL, // negative
                                    0xa248000000000000ULL, 0x0000000000000000ULL,
                                    // flavors of NAN
                                    0x7c00000000000000ULL, 0x0000000000000000ULL, // quiet
                                    0xfc00000000000000ULL, 0xc00100035b007700ULL,
                                    0x7e00000000000000ULL, 0xfe000000d0e0a0d0ULL, // signaling
                                    // flavors of Infinity
                                    0x7800000000000000ULL, 0x0000000000000000ULL,
                                    0xf800000000000000ULL, 0x0000000000000000ULL, // negative
                                    0xf900000000000000ULL, 0x0000000000000000ULL
};

static unsigned long long dfp64_vals[] = {
                                 // various finite numbers
                                 0x2234000000000e50ULL,
                                 0x223400000014c000ULL,
                                 0xa2340000000000e0ULL,// negative
                                 0x22240000000000cfULL,
                                 0xa21400010a395bcfULL,// negative
                                 0x6e4d3f1f534acdd4ULL,// huge number
                                 0x000400000089b000ULL,// very small number
                                 // flavors of zero
                                 0x2238000000000000ULL,
                                 0xa238000000000000ULL,
                                 0x4248000000000000ULL,
                                 // flavors of NAN
                                 0x7e34000000000111ULL,
                                 0xfe000000d0e0a0d0ULL,//signaling
                                 0xfc00000000000000ULL,//quiet
                                 // flavors of Infinity
                                 0x7800000000000000ULL,
                                 0xf800000000000000ULL,//negative
                                 0x7a34000000000000ULL,
};

// Both Long and Quad arrays of DFP values should have the same length.
// If that length is changed, t
#define NUM_DFP_VALS (sizeof(dfp64_vals)/8)

typedef struct dfp_test_args {
   int fra_idx;
   int frb_idx;
} dfp_test_args_t;


// Index pairs from dfp64_vals array to be used with dfp_two_arg_tests
static dfp_test_args_t dfp_2args_x1[] = {
                                    {0, 1},
                                    {2, 1},
                                    {3, 4},
                                    {0, 6},
                                    {2, 4},
                                    {5, 1},
                                    {5, 2},
                                    {7, 1},
                                    {7, 2},
                                    {8, 0},
                                    {8, 1},
                                    {8, 2},
                                    {7, 8},
                                    {12, 14},
                                    {12, 1},
                                    {12, 13},
                                    {12, 12},
                                    {12, 11},
                                    {11, 14},
                                    {11, 0},
                                    {11, 13},
                                    {11, 11},
                                    {14, 14},
                                    {14, 3},
                                    {14, 15},
};

typedef enum {
   LONG_TEST,
   QUAD_TEST
} precision_type_t;

typedef struct dfp_test
{
   test_func_t test_func;
   const char * name;
   dfp_test_args_t * targs;
   int num_tests;
   precision_type_t precision;
   const char * op;
} dfp_test_t;

typedef struct dfp_one_arg_test
{
   test_func_t test_func;
   const char * name;
   precision_type_t precision;
   const char * op;
} dfp_one_arg_test_t;


static dfp_one_arg_test_t
dfp_quai_tests[] = {
                    { &_test_dquai, "dquai", LONG_TEST, "[QI]"},
                    { &_test_dquaiq, "dquaiq", QUAD_TEST, "[QI]"},
                    { NULL, NULL, 0, NULL}
};

static void test_dfp_quai_ops(void)
{
   test_func_t func;
   unsigned long long u0, u0x;
   double res, d0, *d0p, d0x, *d0xp;

   int k = 0;
   u0 = u0x = 0;
   d0p = &d0;
   d0xp = &d0x;

   while ((func = dfp_quai_tests[k].test_func)) {
      int i;
      dfp_one_arg_test_t test_def = dfp_quai_tests[k];

      for (i = 0; i < NUM_DFP_VALS; i++) {
         int TE, RMC;

         if (test_def.precision == LONG_TEST) {
            u0 = dfp64_vals[i];
         } else {
            u0 = dfp128_vals[i * 2];
            u0x = dfp128_vals[(i * 2) + 1];
         }
         *(unsigned long long *)d0p = u0;
         f16 = d0;
         if (test_def.precision == QUAD_TEST) {
            *(unsigned long long *)d0xp = u0x;
            f17 = d0x;
         }

         for (TE = 0; TE < TE_VAL_LEN; TE++) {
            for (RMC = 0; RMC < 4; RMC++) {
               (*func)(TE_vals[TE], RMC);
               res = f18;
               printf("%s (RMC=%2d, TE=%3d) %s %016llx", test_def.name, RMC,
                      TE_vals[TE], test_def.op, u0);
               if (test_def.precision == LONG_TEST) {
                  printf(" => %016llx\n",
                         *((unsigned long long *)(&res)));
               } else {
                  double resx = f19;
                  printf(" %016llx ==> %016llx %016llx\n",
                         u0x, *((unsigned long long *)(&res)), *((unsigned long long *)(&resx)));
               }
            }
         }
      }
      k++;
      printf( "\n" );
   }
}


static dfp_test_t
dfp_qua_tests[] = {
                   { &_test_dqua, "dqua", dfp_2args_x1, 25, LONG_TEST, "[Q]"},
                   { &_test_dquaq, "dquaq", dfp_2args_x1, 25, QUAD_TEST, "[Q]"},
                   { NULL, NULL, NULL, 0, 0, NULL}
};

static void test_dfp_qua_ops(void)
{
   test_func_t func;
   unsigned long long u0, u0x, u1, u1x;
   double res, d0, d1, *d0p, *d1p;
   double d0x, d1x, *d0xp, *d1xp;
   int k = 0;
   u0x = u1x = 0;
   d0p = &d0;
   d0xp = &d0x;
   d1p = &d1;
   d1xp = &d1x;

   while ((func = dfp_qua_tests[k].test_func)) {
      int i, RMC;
      dfp_test_t test_def = dfp_qua_tests[k];

      for (i = 0; i < test_def.num_tests; i++) {
         if (test_def.precision == LONG_TEST) {
            u0 = dfp64_vals[test_def.targs[i].fra_idx];
            u1 = dfp64_vals[test_def.targs[i].frb_idx];
         } else {
            u0 = dfp128_vals[test_def.targs[i].fra_idx * 2];
            u0x = dfp128_vals[(test_def.targs[i].fra_idx * 2) + 1];
            u1 = dfp128_vals[test_def.targs[i].frb_idx * 2];
            u1x = dfp128_vals[(test_def.targs[i].frb_idx * 2) + 1];
         }
         *(unsigned long long *)d0p = u0;
         *(unsigned long long *)d1p = u1;
         f14 = d0;
         f16 = d1;
         if (test_def.precision == QUAD_TEST) {
            *(unsigned long long *)d0xp = u0x;
            *(unsigned long long *)d1xp = u1x;
            f15 = d0x;
            f17 = d1x;
         }
         for (RMC = 0; RMC < 4; RMC++) {
            (*func)(-1, RMC);
            res = f18;
            printf("%s (RMC=%2d) %s %016llx", test_def.name, RMC, test_def.op, u0);
            if (test_def.precision == LONG_TEST) {
               printf(", %016llx => %016llx\n", u1, *((unsigned long long *)(&res)));
            } else {
               double resx = f19;
               printf(" %016llx, %016llx %016llx ==> %016llx %016llx\n",u0x, u1, u1x,
                      *((unsigned long long *)(&res)), *((unsigned long long *)(&resx)));
            }
         }
      }
      k++;
      printf( "\n" );
   }
}


static dfp_one_arg_test_t
dfp_rrnd_tests[] = {
                    { &_test_drrnd, "drrnd", LONG_TEST, "[RR]"},
                    { &_test_drrndq, "drrndq", QUAD_TEST, "[RR]"},
                    { NULL, NULL, 0, NULL}
};

static void test_dfp_rrnd_ops(void)
{
   test_func_t func;
   unsigned long long u0, u0x;
   double res, d0, *d0p, d0x, *d0xp, reference_sig, *reference_sig_p;
   long long reference_sig_vals[] = {0ULL, 2ULL, 6ULL, 63ULL};
   int num_reference_sig_vals = sizeof(reference_sig_vals)/sizeof(long long);

   int k = 0;
   u0 = u0x = 0;
   d0p = &d0;
   d0xp = &d0x;
   reference_sig_p = &reference_sig;

   while ((func = dfp_rrnd_tests[k].test_func)) {
      int i, j;
      dfp_one_arg_test_t test_def = dfp_rrnd_tests[k];

      for (i = 0; i < NUM_DFP_VALS; i++) {
         int RMC;

         if (test_def.precision == LONG_TEST) {
            u0 = dfp64_vals[i];
         } else {
            u0 = dfp128_vals[i * 2];
            u0x = dfp128_vals[(i * 2) + 1];
         }
         *(unsigned long long *)d0p = u0;
         f16 = d0;
         if (test_def.precision == QUAD_TEST) {
            *(unsigned long long *)d0xp = u0x;
            f17 = d0x;
         }

         for (j = 0; j < num_reference_sig_vals; j++) {
            *(long long *)reference_sig_p = reference_sig_vals[j];
            f14 = reference_sig;
            for (RMC = 0; RMC < 4; RMC++) {
               (*func)(-1, RMC);
               res = f18;
               printf("%s (RMC=%d, ref sig=%d) %s%016llx", test_def.name, RMC,
                      (int)reference_sig_vals[j], test_def.op, u0);
               if (test_def.precision == LONG_TEST) {
                  printf(" => %016llx\n",
                         *((unsigned long long *)(&res)));
               } else {
                  double resx = f19;
                  printf(" %016llx ==> %016llx %016llx\n",
                         u0x, *((unsigned long long *)(&res)), *((unsigned long long *)(&resx)));
               }
            }
         }
      }
      k++;
      printf( "\n" );
   }
}


static dfp_one_arg_test_t
dfp_xiex_tests[] = {
                       { &_test_diex, "diex", LONG_TEST, ">>"},
                       { &_test_diexq, "diexq", QUAD_TEST, ">>"},
                       { &_test_dxex, "dxex", LONG_TEST, "<<"},
                       { &_test_dxexq, "dxexq", QUAD_TEST, "<<"},
                       { NULL, NULL, 0, NULL}
};

static void test_dfp_xiex_ops(void)
{
   test_func_t func;
   unsigned long long u0, u0x;
   double res, d0, *d0p, d0x, *d0xp, target_exp, *target_exp_p;
   /* The first two positions are placeholders and will be filled in later,
    * based on the precision of the DFP argument.
    */
   long long target_exp_vals[] = {0ULL, 0ULL, 0ULL, -1ULL, -2ULL, -3ULL, -4ULL, -5ULL};
   int num_exp_vals = sizeof(target_exp_vals)/sizeof(long long);
   int k = 0;
   u0 = u0x = 0;
   d0p = &d0;
   d0xp = &d0x;
   target_exp_p = &target_exp;

   while ((func = dfp_xiex_tests[k].test_func)) {
      int i;
      Bool insert_insn = False;
      dfp_one_arg_test_t test_def = dfp_xiex_tests[k];

      if (!strncmp(test_def.name, "di", 2))
         insert_insn = True;

      if (test_def.precision == QUAD_TEST) {
         target_exp_vals[0] = 12288ULL; // > max biased exponent
         target_exp_vals[1] = 5235ULL;
      } else {
         target_exp_vals[0] = 768ULL; // > max biased exponent
         target_exp_vals[1] = 355ULL;
      }

      for (i = 0; i < NUM_DFP_VALS; i++) {
         unsigned int j;

         if (test_def.precision == QUAD_TEST) {
            u0 = dfp128_vals[i * 2];
            u0x = dfp128_vals[(i * 2) + 1];
         } else {
            u0 = dfp64_vals[i];
         }
         *(unsigned long long *)d0p = u0;
         f16 = d0;
         if (test_def.precision == QUAD_TEST) {
            *(unsigned long long *)d0xp = u0x;
            f17 = d0x;
         }

         if (!insert_insn) {
            // This is just for extract insns (dexex[q])
            (*func)(0, 0);
            res = f18;
            printf("%s %s ", test_def.name, test_def.op);
            if (test_def.precision == LONG_TEST) {
               printf("%016llx => %016llx\n", u0,
                      *((unsigned long long *)(&res)));
            } else {
               double resx = f19;
               printf("%016llx %016llx ==> %016llx %016llx\n", u0, u0x,
                      *((unsigned long long *)(&res)), *((unsigned long long *)(&resx)));
            }
            continue;
         }
         // The following for-loop is just for insert insns (diex[q])
         for (j = 0; j < num_exp_vals; j++) {
            *(long long *)target_exp_p = target_exp_vals[j];
            f14 = target_exp;
            (*func)(0, 0);
            res = f18;
            printf("%s %s %5d, ", test_def.name, test_def.op, (int)target_exp_vals[j]);

            if (test_def.precision == LONG_TEST) {
               printf("%016llx => %016llx\n", u0,
                      *((unsigned long long *)(&res)));
            } else {
               double resx = f19;
               printf("%016llx %016llx ==> %016llx %016llx\n", u0, u0x,
                      *((unsigned long long *)(&res)), *((unsigned long long *)(&resx)));
            }
         }
      }
      k++;
      printf( "\n" );
   }
}

static dfp_one_arg_test_t
dfp_rint_tests[] = {
                    { &_test_drintn, "drintn", LONG_TEST, "~"},
                    { &_test_drintnq, "drintnq", QUAD_TEST, "~"},
                    { &_test_drintx, "drintx", LONG_TEST, "~"},
                    { &_test_drintxq, "drintxq", QUAD_TEST, "~"},
                    { NULL, NULL, 0, NULL}
};

static void test_dfp_rint_ops(void)
{
   test_func_t func;
   unsigned long long u0, u0x;
   double res, d0, *d0p, d0x, *d0xp;
   int k = 0;
   u0 = u0x = 0;
   d0p = &d0;
   d0xp = &d0x;

   while ((func = dfp_rint_tests[k].test_func)) {
      int i;
      dfp_one_arg_test_t test_def = dfp_rint_tests[k];

      for (i = 0; i < NUM_DFP_VALS; i++) {
         int R, RMC;

         if (test_def.precision == LONG_TEST) {
            u0 = dfp64_vals[i];
         } else {
            u0 = dfp128_vals[i * 2];
            u0x = dfp128_vals[(i * 2) + 1];
         }
         *(unsigned long long *)d0p = u0;
         f16 = d0;
         if (test_def.precision == QUAD_TEST) {
            *(unsigned long long *)d0xp = u0x;
            f17 = d0x;
         }

         for (R = 0; R < 2; R++) {
            for (RMC = 0; RMC < 4; RMC++) {
               (*func)(R, RMC);
               res = f18;
               printf("%s (RM=%d) %s%016llx", test_def.name, (RMC + (R << 2)), test_def.op, u0);
               if (test_def.precision == LONG_TEST) {
                  printf(" => %016llx\n",
                         *((unsigned long long *)(&res)));
               } else {
                  double resx = f19;
                  printf(" %016llx ==> %016llx %016llx\n",
                         u0x, *((unsigned long long *)(&res)), *((unsigned long long *)(&resx)));
               }
            }
         }
      }
      k++;
      printf( "\n" );
   }
}

static dfp_test_t
dfp_cmp_tests[] = {
                     { &_test_dcmpo, "dcmpo", dfp_2args_x1, 25, LONG_TEST, "<>"},
                     { &_test_dcmpoq, "dcmpoq", dfp_2args_x1, 25, QUAD_TEST, "<>"},
                     { &_test_dcmpu, "dcmpu", dfp_2args_x1, 25, LONG_TEST, "<>"},
                     { &_test_dcmpuq, "dcmpuq", dfp_2args_x1, 25, QUAD_TEST, "<>"},
                     { NULL, NULL, NULL, 0, 0, NULL}
};

static void test_dfp_cmp_ops(void)
{
   test_func_t func;
   unsigned long long u0, u0x, u1, u1x;
   double d0, d1, *d0p, *d1p;
   double d0x, d1x, *d0xp, *d1xp;
   /* BF is a 3-bit instruction field that indicates the CR field in which the
    * result of the compare should be placed.  We won't iterate through all
    * 8 possible BF values since storing compare results to a given field is
    * a well-tested mechanism in VEX.  But we will test two BF values, just as
    * a sniff-test.
    */
   int k = 0, BF;
   u0x = u1x = 0;
   d0p = &d0;
   d0xp = &d0x;
   d1p = &d1;
   d1xp = &d1x;

   while ((func = dfp_cmp_tests[k].test_func)) {
      int i, repeat = 1;
      dfp_test_t test_def = dfp_cmp_tests[k];
      BF = 0;

again:
      for (i = 0; i < test_def.num_tests; i++) {
         unsigned int condreg;
         unsigned int flags;

         if (test_def.precision == LONG_TEST) {
            u0 = dfp64_vals[test_def.targs[i].fra_idx];
            u1 = dfp64_vals[test_def.targs[i].frb_idx];
         } else {
            u0 = dfp128_vals[test_def.targs[i].fra_idx * 2];
            u0x = dfp128_vals[(test_def.targs[i].fra_idx * 2) + 1];
            u1 = dfp128_vals[test_def.targs[i].frb_idx * 2];
            u1x = dfp128_vals[(test_def.targs[i].frb_idx * 2) + 1];
         }
         *(unsigned long long *)d0p = u0;
         *(unsigned long long *)d1p = u1;
         f14 = d0;
         f16 = d1;
         if (test_def.precision == QUAD_TEST) {
            *(unsigned long long *)d0xp = u0x;
            *(unsigned long long *)d1xp = u1x;
            f15 = d0x;
            f17 = d1x;
         }

         SET_FPSCR_ZERO;
         SET_CR_XER_ZERO;
         (*func)(BF, 0);
         GET_CR(flags);

         condreg = ((flags >> (4 * (7-BF)))) & 0xf;
         printf("%s %016llx", test_def.name, u0);
         if (test_def.precision == LONG_TEST) {
            printf(" %s %016llx => %x (BF=%d)\n",
                   test_def.op, u1, condreg, BF);
         } else {
            printf(" %016llx %s %016llx %016llx ==> %x (BF=%d)\n",
                   u0x, test_def.op, u1, u1x,
                   condreg, BF);
         }
      }
      if (repeat) {
         repeat = 0;
         BF = 5;
         goto again;
      }
      k++;
      printf( "\n" );
   }
}


static test_table_t
         all_tests[] =
{
                    { &test_dfp_cmp_ops,
                      "Test DFP compare instructions"},
                    { &test_dfp_rint_ops,
                      "Test DFP round instructions"},
                    { &test_dfp_xiex_ops,
                      "Test DFP insert/extract instructions"},
                    { &test_dfp_rrnd_ops,
                      "Test DFP reround instructions"},
                    { &test_dfp_qua_ops,
                      "Test DFP quantize instructions"},
                    { &test_dfp_quai_ops,
                      "Test DFP quantize immediate instructions"},
                    { NULL, NULL }
};
#endif // HAS_DFP

int main() {
#if defined(HAS_DFP)

   test_table_t aTest;
   test_driver_func_t func;
   int i = 0;

   while ((func = all_tests[i].test_category)) {
      aTest = all_tests[i];
      printf( "%s\n", aTest.name );
      (*func)();
      i++;
   }

#endif // HAS_DFP
   return 0;
}