#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "tests/asm.h"
#include "tests/malloc.h"
#include <string.h>
#define XSAVE_AREA_SIZE 832
typedef unsigned char UChar;
typedef unsigned int UInt;
typedef unsigned long long int ULong;
typedef unsigned long int UWord;
typedef unsigned char Bool;
#define True ((Bool)1)
#define False ((Bool)0)
const unsigned int vec0[8]
= { 0x12345678, 0x11223344, 0x55667788, 0x87654321,
0x15263748, 0x91929394, 0x19293949, 0x48372615 };
const unsigned int vec1[8]
= { 0xABCDEF01, 0xAABBCCDD, 0xEEFF0011, 0x10FEDCBA,
0xBADCFE10, 0xFFEE9988, 0x11667722, 0x01EFCDAB };
const unsigned int vecZ[8]
= { 0, 0, 0, 0, 0, 0, 0, 0 };
/* A version of memset that doesn't use XMM or YMM registers. */
static __attribute__((noinline))
void* my_memset(void* s, int c, size_t n)
{
size_t i;
for (i = 0; i < n; i++) {
((unsigned char*)s)[i] = (unsigned char)(unsigned int)c;
/* Defeat any attempt at autovectorisation */
__asm__ __volatile__("" ::: "cc","memory");
}
return s;
}
/* Ditto for memcpy */
static __attribute__((noinline))
void* my_memcpy(void *dest, const void *src, size_t n)
{
size_t i;
for (i = 0; i < n; i++) {
((unsigned char*)dest)[i] = ((unsigned char*)src)[i];
__asm__ __volatile__("" ::: "cc","memory");
}
return dest;
}
static void* memalign_zeroed64(size_t size)
{
char* p = memalign64(size);
if (p && size > 0) {
my_memset(p, 0, size);
}
return p;
}
__attribute__((noinline))
static void do_xsave ( void* p, UInt rfbm )
{
assert(rfbm <= 7);
__asm__ __volatile__(
"movq %0, %%rax; xorq %%rdx, %%rdx; xsave (%1)"
: /*OUT*/ : /*IN*/ "r"((ULong)rfbm), "r"(p)
: /*TRASH*/ "memory", "rax", "rdx"
);
}
__attribute__((noinline))
static void do_xrstor ( void* p, UInt rfbm )
{
assert(rfbm <= 7);
__asm__ __volatile__(
"movq %0, %%rax; xorq %%rdx, %%rdx; xrstor (%1)"
: /*OUT*/ : /*IN*/ "r"((ULong)rfbm), "r"(p)
: /*TRASH*/ "rax", "rdx" /* FIXME plus all X87,SSE,AVX regs */
);
}
/* set up the FP, SSE and AVX state, and then dump it. */
static void do_setup_then_xsave ( void* p, UInt rfbm )
{
__asm__ __volatile__("finit");
__asm__ __volatile__("fldpi");
__asm__ __volatile__("fld1");
__asm__ __volatile__("fldln2");
__asm__ __volatile__("fldlg2");
__asm__ __volatile__("fld %st(3)");
__asm__ __volatile__("fld %st(3)");
__asm__ __volatile__("fld1");
__asm__ __volatile__("vmovups (%0), %%ymm0" : : "r"(&vec0[0]) : "xmm0" );
__asm__ __volatile__("vmovups (%0), %%ymm1" : : "r"(&vec1[0]) : "xmm1" );
__asm__ __volatile__("vxorps %ymm2, %ymm2, %ymm2");
__asm__ __volatile__("vmovaps %ymm0, %ymm3");
__asm__ __volatile__("vmovaps %ymm1, %ymm4");
__asm__ __volatile__("vmovaps %ymm2, %ymm5");
__asm__ __volatile__("vmovaps %ymm0, %ymm6");
__asm__ __volatile__("vmovaps %ymm1, %ymm7");
__asm__ __volatile__("vmovaps %ymm1, %ymm8");
__asm__ __volatile__("vmovaps %ymm2, %ymm9");
__asm__ __volatile__("vmovaps %ymm0, %ymm10");
__asm__ __volatile__("vmovaps %ymm1, %ymm11");
__asm__ __volatile__("vmovaps %ymm1, %ymm12");
__asm__ __volatile__("vmovaps %ymm2, %ymm13");
__asm__ __volatile__("vmovaps %ymm0, %ymm14");
__asm__ __volatile__("vmovaps %ymm1, %ymm15");
do_xsave(p, rfbm);
}
static int isFPLsbs ( int i )
{
int q;
q = 32; if (i == q || i == q+1) return 1;
q = 48; if (i == q || i == q+1) return 1;
q = 64; if (i == q || i == q+1) return 1;
q = 80; if (i == q || i == q+1) return 1;
q = 96; if (i == q || i == q+1) return 1;
q = 112; if (i == q || i == q+1) return 1;
q = 128; if (i == q || i == q+1) return 1;
q = 144; if (i == q || i == q+1) return 1;
return 0;
}
static void show ( unsigned char* buf, Bool hideBits64to79 )
{
int i;
for (i = 0; i < XSAVE_AREA_SIZE; i++) {
if ((i % 16) == 0)
fprintf(stderr, "%3d ", i);
if (hideBits64to79 && isFPLsbs(i))
fprintf(stderr, "xx ");
else
fprintf(stderr, "%02x ", buf[i]);
if (i > 0 && ((i % 16) == 15))
fprintf(stderr, "\n");
}
}
static void cpuid ( UInt* eax, UInt* ebx, UInt* ecx, UInt* edx,
UInt index, UInt ecx_in )
{
UInt a,b,c,d;
asm volatile ("cpuid"
: "=a" (a), "=b" (b), "=c" (c), "=d" (d) \
: "0" (index), "2"(ecx_in) );
*eax = a; *ebx = b; *ecx = c; *edx = d;
//fprintf(stderr, "%08x %08x -> %08x %08x %08x %08x\n",
// index,ecx_in, a,b,c,d );
}
static void xgetbv ( UInt* eax, UInt* edx, UInt ecx_in )
{
UInt a,d;
asm volatile ("xgetbv"
: "=a" (a), "=d" (d) \
: "c"(ecx_in) );
*eax = a; *edx = d;
}
static void check_for_xsave ( void )
{
UInt eax, ebx, ecx, edx;
Bool ok = True;
eax = ebx = ecx = edx = 0;
cpuid(&eax, &ebx, &ecx, &edx, 1,0);
//fprintf(stderr, "cpuid(1).ecx[26=xsave] = %u\n", (ecx >> 26) & 1);
ok = ok && (((ecx >> 26) & 1) == 1);
eax = ebx = ecx = edx = 0;
cpuid(&eax, &ebx, &ecx, &edx, 1,0);
//fprintf(stderr, "cpuid(1).ecx[27=osxsave] = %u\n", (ecx >> 27) & 1);
ok = ok && (((ecx >> 27) & 1) == 1);
eax = ebx = ecx = edx = 0;
xgetbv(&eax, &edx, 0);
//fprintf(stderr, "xgetbv(0) = %u:%u\n", edx, eax);
ok = ok && (edx == 0) && (eax == 7);
if (ok) return;
fprintf(stderr,
"This program must be run on a CPU that supports AVX and XSAVE.\n");
exit(1);
}
void test_xsave ( Bool hideBits64to79 )
{
/* Testing XSAVE:
For RBFM in 0 .. 7 (that is, all combinations): set the x87, SSE
and AVX registers with some values, do XSAVE to dump it, and
print the resulting buffer. */
UInt rfbm;
for (rfbm = 0; rfbm <= 7; rfbm++) {
UChar* saved_img = memalign_zeroed64(XSAVE_AREA_SIZE);
my_memset(saved_img, 0xAA, XSAVE_AREA_SIZE);
saved_img[512] = 0;
do_setup_then_xsave(saved_img, rfbm);
fprintf(stderr,
"------------------ XSAVE, rfbm = %u ------------------\n", rfbm);
show(saved_img, hideBits64to79);
fprintf(stderr, "\n");
free(saved_img);
}
}
void test_xrstor ( Bool hideBits64to79 )
{
/* Testing XRSTOR is more complex than testing XSAVE, because the
loaded value(s) depend not only on what bits are requested (by
RBFM) but also on what bits are actually present in the image
(defined by XSTATE_BV). So we have to test all 64 (8 x 8)
combinations.
The approach is to fill a memory buffer with data, do XRSTOR
from the buffer, them dump all components with XSAVE in a new
buffer, and print the result. This is complicated by the fact
that we need to be able to see which parts of the state (in
registers) are neither overwritten nor zeroed by the restore.
Hence the registers must be pre-filled with values which are
neither zero nor the data to be loaded. We choose to use 0x55
where possible. */
UChar* fives = memalign_zeroed64(XSAVE_AREA_SIZE);
my_memset(fives, 0x55, XSAVE_AREA_SIZE);
/* Set MXCSR so that the insn doesn't fault */
fives[24] = 0x80;
fives[25] = 0x1f;
fives[26] = 0;
fives[27] = 0;
/* Ditto for the XSAVE header area. Also set XSTATE_BV. */
fives[512] = 7;
UInt i;
for (i = 1; i <= 23; i++) fives[512+i] = 0;
/* Fill the x87 register values with something that VEX's
80-vs-64-bit kludging won't mess up -- an 80 bit number which is
representable also as 64 bit: 123456789.0123 */
for (i = 0; i <= 7; i++) {
UChar* p = &fives[32 + 16 * i];
p[0]=0x00; p[1]=0xf8; p[2]=0xc2; p[3]=0x64; p[4]=0xa0;
p[5]=0xa2; p[6]=0x79; p[7]=0xeb; p[8]=0x19; p[9]=0x40;
}
/* And mark the tags for all 8 dumped regs as "valid". */
fives[4/*FTW*/] = 0xFF;
/* (1) (see comment in loop below) */
UChar* standard_test_data = memalign_zeroed64(XSAVE_AREA_SIZE);
do_setup_then_xsave(standard_test_data, 7);
UInt xstate_bv, rfbm;
for (xstate_bv = 0; xstate_bv <= 7; xstate_bv++) {
for (rfbm = 0; rfbm <= 7; rfbm++) {
//{ xstate_bv = 7;
// { rfbm = 6;
/* 1. Copy the "standard test data" into registers, and dump
it with XSAVE. This gives us an image we can try
restoring from.
2. Set the register state to all-0x55s (as far as is
possible), so we can see which parts get overwritten
and which parts get zeroed on the test restore.
3. Do the restore from the image prepared in (1).
4. Dump the state with XSAVE and print it.
*/
/* (3a). We can't use |standard_test_data| directly, since we
need to put in the required |xstate_bv| value. So make a
copy and modify that instead. */
UChar* img_to_restore_from = memalign_zeroed64(XSAVE_AREA_SIZE);
my_memcpy(img_to_restore_from, standard_test_data, XSAVE_AREA_SIZE);
img_to_restore_from[512] = xstate_bv;
/* (4a) */
UChar* saved_img = memalign_zeroed64(XSAVE_AREA_SIZE);
my_memset(saved_img, 0xAA, XSAVE_AREA_SIZE);
saved_img[512] = 0;
/* (2) */
do_xrstor(fives, 7);
// X87, SSE, AVX state LIVE
/* (3b) */
/* and this is what we're actually trying to test */
do_xrstor(img_to_restore_from, rfbm);
// X87, SSE, AVX state LIVE
/* (4b) */
do_xsave(saved_img, 7);
fprintf(stderr,
"---------- XRSTOR, xstate_bv = %u, rfbm = %u ---------\n",
xstate_bv, rfbm);
show(saved_img, hideBits64to79);
fprintf(stderr, "\n");
free(saved_img);
free(img_to_restore_from);
}
}
}
int main ( int argc, char** argv )
{
Bool hideBits64to79 = argc > 1;
fprintf(stderr, "Re-run with any arg to suppress least-significant\n"
" 16 bits of 80-bit FP numbers\n");
check_for_xsave();
if (1)
test_xsave(hideBits64to79);
if (1)
test_xrstor(hideBits64to79);
return 0;
}