/* 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" );
}
}