/* Testing framework, for developing code to copy vex's x87 simulation
   state to and from a real x87 state image (the 108-byte thing). 

   Includes code from fp_80_64.c.
*/

#include "../pub/libvex_basictypes.h"
#include "../pub/libvex_ir.h"
#include "../priv/guest-x86/gdefs.h"
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

/* Get definitions of convert_f64le_to_f80le and
   convert_f80le_to_f64le. */
#define USED_AS_INCLUDE
#include "fp_80_64.c"
#undef  USED_AS_INCLUDE


////////////////////////////////////////////////////////////////

/* Layout of the real x87 state. */

typedef
   struct {
      UShort env[14];
      UChar  reg[80];
   }
   Fpu_State;

/* Offsets, in 16-bit ints, into the FPU environment (env) area. */
#define FP_ENV_CTRL   0
#define FP_ENV_STAT   2
#define FP_ENV_TAG    4
#define FP_ENV_IP     6 /* and 7 */
#define FP_ENV_CS     8
#define FP_ENV_OPOFF  10 /* and 11 */
#define FP_ENV_OPSEL  12
#define FP_REG(ii)    (10*(7-(ii)))


/* Layout of vex's FP state is defined in ../priv/guest-x86/gdefs.h */

static void x87_to_vex ( /*IN*/UChar* x87_state, /*OUT*/UChar* vex_state )
{
   Int        r;
   UInt       tag;
   Double*    vexRegs = (Double*)(vex_state + OFFB_F0);
   UChar*     vexTags = (UChar*)(vex_state + OFFB_FTAG0);
   Fpu_State* x87     = (Fpu_State*)x87_state;
   UInt       ftop    = (x87->env[FP_ENV_STAT] >> 11) & 7;
   UInt       tagw    = x87->env[FP_ENV_TAG];

   /* Copy registers and tags */
   for (r = 0; r < 8; r++) {
      tag = (tagw >> (2*r)) & 3;
      if (tag == 3) {
         /* register is empty */
         vexRegs[r] = 0.0;
         vexTags[r] = 0;
      } else {
         /* register is non-empty */
         convert_f80le_to_f64le( &x87->reg[FP_REG(r)], (UChar*)&vexRegs[r] );
         vexTags[r] = 1;
      }
   }

   /* stack pointer */
   *(UInt*)(vex_state + OFFB_FTOP) = ftop;

   /* TODO: Check the CW is 037F.  Or at least, bottom 6 bits are 1
      (all exceptions masked), and 11:10, which is rounding control,
      is set to ..?
   */
}


static void vex_to_x87 ( /*IN*/UChar* vex_state, /*OUT*/UChar* x87_state )
{
   Int        i, r;
   UInt       tagw;
   Double*    vexRegs = (Double*)(vex_state + OFFB_F0);
   UChar*     vexTags = (UChar*)(vex_state + OFFB_FTAG0);
   Fpu_State* x87     = (Fpu_State*)x87_state;
   UInt       ftop    = *(UInt*)(vex_state + OFFB_FTOP);

   for (i = 0; i < 14; i++)
      x87->env[i] = 0;

   x87->env[1] = x87->env[3] = x87->env[5] = x87->env[13] = 0xFFFF;
   x87->env[FP_ENV_CTRL] = 0x037F;
   x87->env[FP_ENV_STAT] = (ftop & 7) << 11;

   tagw = 0;
   for (r = 0; r < 8; r++) {
      if (vexTags[r] == 0) {
         /* register is empty */
         tagw |= (3 << (2*r));
         convert_f64le_to_f80le( (UChar*)&vexRegs[r], &x87->reg[FP_REG(r)] );
      } else {
         /* register is full. */
         tagw |= (0 << (2*r));
         convert_f64le_to_f80le( (UChar*)&vexRegs[r],  &x87->reg[FP_REG(r)] );
      }
   }
   x87->env[FP_ENV_TAG] = tagw;
}

////////////////////////////////////////////////////////////////

// fwds ...
static void printFpuState ( UChar* fpu_state );
static void printVexState ( UChar* vex_state );


/* Capture the FPU state.  Convert it to vex.  Convert it back
   to x87.  Print it at all stages.
*/
void capture_convert_show ( /* preallocated storage */
                            UChar* x87_state0,
                            UChar* x87_state1,
                            UChar* vex_state )
{
   asm volatile ("fsave (%0)"
                 :
                 : "r" (x87_state0)
                 : "memory" );
   x87_to_vex(x87_state0, vex_state);
   vex_to_x87(vex_state, x87_state1);
   printf("\n\n=================================================\n\n");
   printFpuState(x87_state0);
   printf("\n\n");
   printVexState(vex_state);
   printf("\n\n");
#if 0
   asm volatile("frstor (%0) ; fsave (%0)"
                 :
                 : "r" (x87_state1)
                 : "memory" );
#endif
   printFpuState(x87_state1);
   printf("\n\n");
   x87_to_vex(x87_state1, vex_state);
   printVexState(vex_state);
   printf("\n\n");
}

int main ( void )
{
  UChar*  x87_state0 = malloc(sizeof(Fpu_State));
  UChar* x87_state1 = malloc(sizeof(Fpu_State));
  UChar* vex_state = malloc(1000);
  asm volatile ("finit");
  capture_convert_show(x87_state0, x87_state1, vex_state);
  asm volatile ("fldpi");
  capture_convert_show(x87_state0, x87_state1, vex_state);
  asm volatile ("fldz ; fld1 ; fdiv %st(1)");
  asm volatile ("fldln2 ; fldlg2 ; fchs ; fsqrt");
  capture_convert_show(x87_state0, x87_state1, vex_state);
  return 1;
}

////////////////////////////////////////////////////////////////

/* Bitfield offsets for exceptions in the FPU status and control words. */
#define FP_E_INVAL    0
#define FP_E_DENOR    1
#define FP_E_DIVZ     2
#define FP_E_OVERF    3
#define FP_E_UNDER    4
#define FP_E_LOS      5

/* More bitfield offsets, but for the status word only. */
#define FP_E_STACKF   6
#define FP_E_SUMMARY  7
#define FP_F_C0       8
#define FP_F_C1       9
#define FP_F_C2      10
#define FP_F_C3      14
/* top-of-stack ptr is bits 13,12,11 of the word */
#define FP_F_TOS_LO  11
#define FP_F_TOS_HI  13

/* Register tags. */
#define FP_TAG_VALID 0
#define FP_TAG_ZERO  1
#define FP_TAG_SPEC  2
#define FP_TAG_EMPTY 3

char* fp_tag_names[4]
   = { "Valid", "Zero", "Spec", "Empty" };

char* fp_exception_names[6]
   = { "INVAL", "DENOR", "DIVZ", "OVERF", "UNDERF", "LOS" };


UInt fp_get_tos ( Fpu_State* x87 )
{
   return (x87->env[FP_ENV_STAT] >> FP_F_TOS_LO) & 7;
}

UInt fp_get_tag ( Fpu_State* x87, UInt regno )
{
   assert(!(regno < 0 || regno > 7));
   return (x87->env[FP_ENV_TAG] >> (2*regno)) & 3;
}

UInt fp_get_statusword_flag ( Fpu_State* x87, UInt flagno )
{
   assert(!(flagno < 0 || flagno > 15));
   return (x87->env[FP_ENV_STAT] >> flagno) & 0x1;
}

UInt fp_get_controlword_flag ( Fpu_State* x87, UInt flagno )
{
   assert(!(flagno < 0 || flagno > 15));
   return (x87->env[FP_ENV_CTRL] >> flagno) & 0x1;
}


static void printFpuState ( UChar* fpu_state )
{
   Fpu_State* x87 = (Fpu_State*)fpu_state;

   Int i, j, k;
   assert(sizeof(Fpu_State)==108);
   for (i = 7; i >= 0; i--) {
      printf ( " %s fpreg%d: 0x", 
               (UInt)i == fp_get_tos(x87) ? "**" : "  ", i );
      for (k = 0, j = FP_REG(i)+9; k < 10; k++,j--)
         printf ( "%02x", (UInt)x87->reg[j]);
      printf ( "  %5s  ", fp_tag_names[fp_get_tag(x87,i)] );
      printf("\n");
      //printf ( "%20.16e\n", fp_get_reg(i) );
   }
   printf("     fctrl:     0x%04x  masked: ", 
          (UInt)x87->env[FP_ENV_CTRL] );
   for (i = FP_E_INVAL; i <= FP_E_LOS; i++)
      if (fp_get_controlword_flag(x87,i))
         printf ( "%s ", fp_exception_names[i] );
   printf ( "\n" );

   printf("     fstat:     0x%04x  except:", 
          (UInt)x87->env[FP_ENV_STAT] );
   for (i = FP_E_INVAL; i <= FP_E_LOS; i++)
      if (fp_get_statusword_flag(x87,i))
         printf ( "%s ", fp_exception_names[i] );
   printf ( "  top: %d  ", fp_get_tos(x87) );
   printf ( "c3210: %d%d%d%d",
            fp_get_statusword_flag(x87,FP_F_C3),
            fp_get_statusword_flag(x87,FP_F_C2),
            fp_get_statusword_flag(x87,FP_F_C1),
            fp_get_statusword_flag(x87,FP_F_C0) );
   printf ( "  STACKF: %d\n", fp_get_statusword_flag(x87,FP_E_STACKF) );

   printf("      ftag:     0x%04x  ", (UInt)x87->env[FP_ENV_TAG] );
   for (i = 7; i >= 0; i--)
      printf ( "%d:%s ", i, fp_tag_names[fp_get_tag(x87,i)] );
   printf("\n");

   printf("       fip: 0x%08x\n", 
           (((UInt)x87->env[FP_ENV_IP+1]) << 16) |
            ((UInt)x87->env[FP_ENV_IP]) );
   printf("       fcs:     0x%04x\n", 
           ((UInt)x87->env[FP_ENV_CS]) );
   printf("    fopoff: 0x%08x\n", 
           (((UInt)x87->env[FP_ENV_OPOFF+1]) << 16) |
            ((UInt)x87->env[FP_ENV_OPOFF]) );
   printf("    fopsel:     0x%04x\n", 
           ((UInt)x87->env[FP_ENV_OPSEL]) );
}


static void printVexState ( UChar* vex_state )
{
   Int r;
   ULong*     vexRegs = (ULong*)(vex_state + OFFB_F0);
   UChar*     vexTags = (UChar*)(vex_state + OFFB_FTAG0);
   UInt       ftop    = *(UInt*)(vex_state + OFFB_FTOP);

   for (r = 7; r >= 0; r--) {
      printf("%s %%f%d:  0x%llx  %s\n", 
              r == ftop ? "##" : "  ",
              r,
              vexRegs[r], 
	      vexTags[r] == 0 ? "Empty" : "Full" );
   }

}