From: Julian Seward Date: Mon, 6 Feb 2006 04:19:30 +0000 (+0000) Subject: Add a program for checking behaviour of ppc floating point insns in X-Git-Tag: svn/VALGRIND_3_2_0~300 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=412cd357f66069bdc99eedd82477ef8c59fb1357;p=thirdparty%2Fvalgrind.git Add a program for checking behaviour of ppc floating point insns in the presence of different rounding modes. This should really be a ppc regression test, but the output is so large (~30MB) that the .stdout.exp file would be unviably large. git-svn-id: svn://svn.valgrind.org/valgrind/trunk@5611 --- diff --git a/auxprogs/Makefile.am b/auxprogs/Makefile.am index 85cc0cd1d9..4f78fc05cb 100644 --- a/auxprogs/Makefile.am +++ b/auxprogs/Makefile.am @@ -4,7 +4,8 @@ include $(top_srcdir)/Makefile.core.am bin_PROGRAMS = valgrind-listener noinst_SCRIPTS = gen-mdg DotToScc.hs primes.c \ - gsl16test gsl16-badfree.patch gsl16-wavelet.patch + gsl16test gsl16-badfree.patch gsl16-wavelet.patch \ + ppcfround.c EXTRA_DIST = $(noinst_SCRIPTS) diff --git a/auxprogs/ppcfround.c b/auxprogs/ppcfround.c new file mode 100644 index 0000000000..ab724f9f85 --- /dev/null +++ b/auxprogs/ppcfround.c @@ -0,0 +1,541 @@ + +#include +#include +#include + +typedef unsigned int UInt; +typedef unsigned long long int ULong; + +typedef + struct { + double fres; + UInt cr; + UInt fpscr; + } + Result; + + +static void set_NEAREST ( void ) { + __asm__ __volatile__("mtfsb0 30 ; mtfsb0 31"); +} +static void set_ZERO ( void ) { + __asm__ __volatile__("mtfsb0 30 ; mtfsb1 31"); +} +static void set_PosINF ( void ) { + __asm__ __volatile__("mtfsb1 30 ; mtfsb0 31"); +} +static void set_NegINF ( void ) { + __asm__ __volatile__("mtfsb1 30 ; mtfsb1 31"); +} + + +static ULong double_as_ULong ( double d ) +{ + union { double dd; ULong ll; } u; + assert(sizeof(u) == 8); + u.dd = d; + return u.ll; +} + +static ULong round_with_mask ( ULong x, ULong mask ) +{ + if (mask == 1) { + switch (x & 1) { + case 0: return x; + case 1: return x+1; + } + assert(0); + } + + if (mask == 3) { + switch (x & 3) { + case 0: return x; + case 1: return x-1; + case 2: return x+2; + case 3: return x+1; + } + assert(0); + } + + if (mask == 7) { + switch (x & 7) { + case 0: return x; + case 1: return x-1; + case 2: return x-2; + case 3: return x-3; + case 4: return x+4; + case 5: return x+3; + case 6: return x+2; + case 7: return x+1; + } + assert(0); + } + + if (mask == 15) { + switch (x & 15) { + case 0: return x; + case 1: return x-1; + case 2: return x-2; + case 3: return x-3; + case 4: return x-4; + case 5: return x-5; + case 6: return x-6; + case 7: return x-7; + case 8: return x+8; + case 9: return x+7; + case 10: return x+6; + case 11: return x+5; + case 12: return x+4; + case 13: return x+3; + case 14: return x+2; + case 15: return x+1; + } + assert(0); + } + + assert(0); +} + +static void showResult ( Result r, ULong hideMask ) +{ + /* hidemask should have 1 for every result bit we **don't** + want to show. viz should be all zeroes normally. */ +#if 0 + printf("(%016llx cr1 0x%01x fprf 0x%02x)", + double_as_ULong(r.fres) & ~hidemask, + (r.cr >> 24) & 0xF, (r.fpscr >> 12) & 0x1F); +#else + printf("(%016llx cr1 ... fprf ...)", + (hideMask == 0x1 || hideMask == 0x3 || hideMask == 0x7) + ? round_with_mask( double_as_ULong(r.fres), hideMask ) + : double_as_ULong(r.fres) & ~hideMask + ); +#endif +} + + +/* Give an insn string such as "fmadd %%f4, %%f1,%%f2,%%f3". Args are + in f1, f2, f3, and result should go in f4. */ +#define INSN(name,insn) \ + \ + static Result insn_##name ( double arg1, double arg2, double arg3 ) \ + { \ + struct { \ + /* 0 */ double a1; \ + /* 8 */ double a2; \ + /* 16 */ double a3; \ + /* 24 */ double res; \ + /* 32 */ UInt fpscr_after; \ + /* 36 */ UInt cr_after; \ + } foo; \ + assert(sizeof(foo) == 40); \ + foo.a1 = foo.a2 = foo.a3 = foo.res = 0; \ + foo.fpscr_after = foo.cr_after = 0; \ + foo.a1 = arg1; \ + foo.a2 = arg2; \ + foo.a3 = arg3; \ + __asm__ __volatile__( \ + "lfd %%f1, 0(%0)\n\t" /* a1 */ \ + "lfd %%f2, 8(%0)\n\t" /* a2 */ \ + "lfd %%f3, 16(%0)\n\t" /* a3 */ \ + insn "\n\t" \ + "stfd %%f4, 24(%0)\n\t" /* res */ \ + "mffs %%f4\n\t" \ + "addi %0,%0,32\n\t" \ + "stfiwx %%f4, %%r0,%0\n\t" /* fpscr_after. r0 reads as zero */ \ + "addi %0,%0,-32\n\t" \ + "mfcr %%r31\n\t" \ + "stw %%r31, 36(%0)" /* cr_after */ \ + : /*out*/ \ + : /*in*/ "b" (&foo.a1) \ + : /*trash*/ "memory","cc", "fr1","fr2","fr3","fr4", "r31" \ + ); \ + { Result result; \ + result.fres = foo.res; \ + result.cr = foo.cr_after; \ + result.fpscr = foo.fpscr_after; \ + return result; \ + } \ + } + +INSN(fabs, "fabs %%f4, %%f1"); +INSN(fabs_, "fabs. %%f4, %%f1"); + +INSN(fnabs, "fnabs %%f4, %%f1"); +INSN(fnabs_, "fnabs. %%f4, %%f1"); + +INSN(fadd, "fadd %%f4, %%f1,%%f2"); +INSN(fadd_, "fadd. %%f4, %%f1,%%f2"); + +INSN(fadds, "fadds %%f4, %%f1,%%f2"); +INSN(fadds_, "fadds. %%f4, %%f1,%%f2"); + +INSN(fcfid, "fcfid %%f4, %%f1"); +INSN(fcfid_, "fcfid. %%f4, %%f1"); + +INSN(fctid, "fctid %%f4, %%f1"); +INSN(fctid_, "fctid. %%f4, %%f1"); + +INSN(fctidz, "fctidz %%f4, %%f1"); +INSN(fctidz_, "fctidz. %%f4, %%f1"); + +INSN(fctiw, "fctiw %%f4, %%f1"); +INSN(fctiw_, "fctiw. %%f4, %%f1"); + +INSN(fctiwz, "fctiwz %%f4, %%f1"); +INSN(fctiwz_, "fctiwz. %%f4, %%f1"); + +INSN(fdiv, "fdiv %%f4, %%f1,%%f2"); +INSN(fdiv_, "fdiv. %%f4, %%f1,%%f2"); + +INSN(fdivs, "fdivs %%f4, %%f1,%%f2"); +INSN(fdivs_, "fdivs. %%f4, %%f1,%%f2"); + +INSN(fmadd, "fmadd %%f4, %%f1,%%f2,%%f3"); +INSN(fmadd_, "fmadd. %%f4, %%f1,%%f2,%%f3"); + +INSN(fmadds, "fmadds %%f4, %%f1,%%f2,%%f3"); +INSN(fmadds_, "fmadds. %%f4, %%f1,%%f2,%%f3"); + +INSN(fmr, "fmr %%f4, %%f1"); +INSN(fmr_, "fmr. %%f4, %%f1"); + +INSN(fmsub, "fmsub %%f4, %%f1,%%f2,%%f3"); +INSN(fmsub_, "fmsub. %%f4, %%f1,%%f2,%%f3"); + +INSN(fmsubs, "fmsubs %%f4, %%f1,%%f2,%%f3"); +INSN(fmsubs_, "fmsubs. %%f4, %%f1,%%f2,%%f3"); + +INSN(fmul, "fmul %%f4, %%f1,%%f2"); +INSN(fmul_, "fmul. %%f4, %%f1,%%f2"); + +INSN(fmuls, "fmuls %%f4, %%f1,%%f2"); +INSN(fmuls_, "fmuls. %%f4, %%f1,%%f2"); + +INSN(fneg, "fneg %%f4, %%f1"); +INSN(fneg_, "fneg. %%f4, %%f1"); + +INSN(fnmadd, "fnmadd %%f4, %%f1,%%f2,%%f3"); +INSN(fnmadd_, "fnmadd. %%f4, %%f1,%%f2,%%f3"); + +INSN(fnmadds, "fnmadds %%f4, %%f1,%%f2,%%f3"); +INSN(fnmadds_, "fnmadds. %%f4, %%f1,%%f2,%%f3"); + +INSN(fnmsub, "fnmsub %%f4, %%f1,%%f2,%%f3"); +INSN(fnmsub_, "fnmsub. %%f4, %%f1,%%f2,%%f3"); + +INSN(fnmsubs, "fnmsubs %%f4, %%f1,%%f2,%%f3"); +INSN(fnmsubs_, "fnmsubs. %%f4, %%f1,%%f2,%%f3"); + +INSN(fre, "fre %%f4, %%f1"); +INSN(fre_, "fre. %%f4, %%f1"); + +INSN(fres, "fres %%f4, %%f1"); +INSN(fres_, "fres. %%f4, %%f1"); + +INSN(frsqrte, "frsqrte %%f4, %%f1"); +INSN(frsqrte_, "frsqrte. %%f4, %%f1"); + +//INSN(frsqrtes, "frsqrtes %%f4, %%f1"); +//INSN(frsqrtes_, "frsqrtes. %%f4, %%f1"); + +INSN(frsp, "frsp %%f4, %%f1"); +INSN(frsp_, "frsp. %%f4, %%f1"); + +INSN(fsel, "fsel %%f4, %%f1,%%f2,%%f3"); +INSN(fsel_, "fsel. %%f4, %%f1,%%f2,%%f3"); + +INSN(fsqrt, "fsqrt %%f4, %%f1"); +INSN(fsqrt_, "fsqrt. %%f4, %%f1"); + +INSN(fsqrts, "fsqrts %%f4, %%f1"); +INSN(fsqrts_, "fsqrts. %%f4, %%f1"); + +INSN(fsub, "fsub %%f4, %%f1,%%f2"); +INSN(fsub_, "fsub. %%f4, %%f1,%%f2"); + +INSN(fsubs, "fsubs %%f4, %%f1,%%f2"); +INSN(fsubs_, "fsubs. %%f4, %%f1,%%f2"); + + + +void do_1_unary ( char* name, + Result(*f)(double,double,double), + double a1, + ULong hideMask ) +{ + Result r; + printf("%8s: %016llx (%e)\n", name, double_as_ULong(a1), a1); + set_NEAREST(); + r = f(a1, 0.0,0.0); + printf(" near "); showResult(r,hideMask); printf("\n"); + set_ZERO(); + r = f(a1, 0.0,0.0); + printf(" zero "); showResult(r,hideMask); printf("\n"); + set_PosINF(); + r = f(a1, 0.0,0.0); + printf(" +inf "); showResult(r,hideMask); printf("\n"); + set_NegINF(); + r = f(a1, 0.0,0.0); + printf(" -inf "); showResult(r,hideMask); printf("\n"); +} + +void do_1_binary ( char* name, + Result(*f)(double,double,double), + double a1, double a2, + ULong hideMask ) +{ + Result r; + printf("%8s: %016llx %016llx\n", name, double_as_ULong(a1), + double_as_ULong(a2)); + set_NEAREST(); + r = f(a1,a2, 0.0); + printf(" near "); showResult(r,hideMask); printf("\n"); + set_ZERO(); + r = f(a1,a2, 0.0); + printf(" zero "); showResult(r,hideMask); printf("\n"); + set_PosINF(); + r = f(a1,a2, 0.0); + printf(" +inf "); showResult(r,hideMask); printf("\n"); + set_NegINF(); + r = f(a1,a2, 0.0); + printf(" -inf "); showResult(r,hideMask); printf("\n"); +} + +void do_1_ternary ( char* name, + Result(*f)(double,double,double), + double a1, double a2, double a3, + ULong hideMask ) +{ + Result r; + printf("%8s: %016llx %016llx %016llx\n", + name, double_as_ULong(a1), + double_as_ULong(a2), double_as_ULong(a3)); + set_NEAREST(); + r = f(a1,a2,a3); + printf(" near "); showResult(r,hideMask); printf("\n"); + set_ZERO(); + r = f(a1,a2,a3); + printf(" zero "); showResult(r,hideMask); printf("\n"); + set_PosINF(); + r = f(a1,a2,a3); + printf(" +inf "); showResult(r,hideMask); printf("\n"); + set_NegINF(); + r = f(a1,a2,a3); + printf(" -inf "); showResult(r,hideMask); printf("\n"); +} + +void do_N_unary ( char* name, + Result(*f)(double,double,double), + double* args, + int nargs, + ULong hideMask ) +{ + int i; + for (i = 0; i < nargs; i++) { + do_1_unary( name, f, args[i], hideMask ); + } +} + +void do_N_binary ( char* name, + Result(*f)(double,double,double), + double* args, + int nargs, + ULong hideMask ) +{ + int i, j; + for (i = 0; i < nargs; i++) { + for (j = 0; j < nargs; j++) { + do_1_binary( name, f, args[i], args[j], hideMask ); + } + } +} + +void do_N_ternary ( char* name, + Result(*f)(double,double,double), + double* args, + int nargs, + ULong hideMask ) +{ + int i, j, k; + for (i = 0; i < nargs; i++) { + for (j = 0; j < nargs; j++) { + for (k = 0; k < nargs; k++) { + do_1_ternary( name, f, args[i], args[j], args[k], hideMask ); + } + } + } +} + +int main ( void ) +{ + const ULong SHOW_ALL = 0; + + int nargs = 21; + int nMacArgs = 11; + + double* args = malloc(nargs * sizeof(double)); + double* macArgs = malloc(nMacArgs * sizeof(double)); + + args[0] = 0.0; + args[1] = 1.0 / 0.0; // inf + args[2] = -args[1]; // -inf + args[3] = args[2]/args[2]; // nan + args[4] = -args[3]; // -nan + args[5] = -5e100; + args[6] = -5e20; + args[7] = -501.0; + args[8] = -6.0; + args[9] = -1.0; + args[10] = -2e-20; + args[11] = -2e-200; + args[12] = 2e-200; + args[13] = 2e-20; + args[14] = 1.0; + args[15] = 6.0; + args[16] = 501.0; + args[17] = 5e20; + args[18] = 5e100; + args[19] = 1.23e+5; + args[20] = 1.23e+14; + +#if 0 + macArgs[0] = 0.0; + macArgs[1] = -5e100; + macArgs[2] = -5e20; + macArgs[3] = -501.0; + macArgs[4] = -6.0; + macArgs[5] = -1.0; + macArgs[6] = -2e-20; + macArgs[7] = -2e-200; + macArgs[8] = 2e-200; + macArgs[9] = 2e-20; + macArgs[10] = 1.0; + macArgs[11] = 6.0; + macArgs[12] = 501.0; + macArgs[13] = 5e20; + macArgs[14] = 5e100; + macArgs[15] = 1.23e+5; + macArgs[16] = 1.23e+14; + + //macArgs[17] = args[3]; // nan + //macArgs[18] = -args[3]; // -nan +#endif + + macArgs[0] = 0.0; + macArgs[1] = 1.0; + macArgs[2] = 1.0 + (1.0/7.0); + macArgs[3] = 6.01; + macArgs[4] = 501.0; + macArgs[5] = 31415927.0; + macArgs[6] = - 1.0; + macArgs[7] = - (1.0 + (1.0/7.0)); + macArgs[8] = - 6.01; + macArgs[9] = - 501.0; + macArgs[10] = - 31415927.0; + + + do_N_unary("fmr", insn_fmr, args, nargs, SHOW_ALL); + do_N_unary("fmr_", insn_fmr_, args, nargs, SHOW_ALL); + + do_N_unary("fneg", insn_fneg, args, nargs, SHOW_ALL); + do_N_unary("fneg_", insn_fneg_, args, nargs, SHOW_ALL); + + do_N_unary("fabs", insn_fabs, args, nargs, SHOW_ALL); + do_N_unary("fabs_", insn_fabs_, args, nargs, SHOW_ALL); + + do_N_unary("fnabs", insn_fnabs, args, nargs, SHOW_ALL); + do_N_unary("fnabs_", insn_fnabs_, args, nargs, SHOW_ALL); + + + do_N_binary("fadd", insn_fadd, args, nargs, SHOW_ALL); + do_N_binary("fadd_", insn_fadd_, args, nargs, SHOW_ALL); + + do_N_binary("fadds", insn_fadds, args, nargs, SHOW_ALL); + do_N_binary("fadds_", insn_fadds_, args, nargs, SHOW_ALL); + + do_N_binary("fdiv", insn_fdiv, args, nargs, SHOW_ALL); + do_N_binary("fdiv_", insn_fdiv_, args, nargs, SHOW_ALL); + + do_N_binary("fdivs", insn_fdivs, args, nargs, SHOW_ALL); + do_N_binary("fdivs_", insn_fdivs_, args, nargs, SHOW_ALL); + + do_N_binary("fmul", insn_fmul, args, nargs, SHOW_ALL); + do_N_binary("fmul_", insn_fmul_, args, nargs, SHOW_ALL); + + do_N_binary("fmuls", insn_fmuls, args, nargs, SHOW_ALL); + do_N_binary("fmuls_", insn_fmuls_, args, nargs, SHOW_ALL); + + do_N_binary("fsub", insn_fsub, args, nargs, SHOW_ALL); + do_N_binary("fsub_", insn_fsub_, args, nargs, SHOW_ALL); + + do_N_binary("fsubs", insn_fsubs, args, nargs, SHOW_ALL); + do_N_binary("fsubs_", insn_fsubs_, args, nargs, SHOW_ALL); + + //do_N_unary(fcfid, SHOW_ALL); + //do_N_unary(fcfid_, SHOW_ALL); + + //do_N_unary(fctid, SHOW_ALL); + //do_N_unary(fctid_, SHOW_ALL); + + //do_N_unary(fctidz, SHOW_ALL); + //do_N_unary(fctidz_, SHOW_ALL); + + do_N_unary("fctiw", insn_fctiw, args, nargs, 0xFFFFFFFF00000000ULL); + do_N_unary("fctiw_", insn_fctiw_, args, nargs, 0xFFFFFFFF00000000ULL); + + do_N_unary("fctiwz", insn_fctiwz, args, nargs, 0xFFFFFFFF00000000ULL); + do_N_unary("fctiwz_", insn_fctiwz_, args, nargs, 0xFFFFFFFF00000000ULL); + +#if 0 + do_N_ternary("fmadd", insn_fmadd, macArgs, nMacArgs, SHOW_ALL); + do_N_ternary("fmadd_", insn_fmadd_, macArgs, nMacArgs, SHOW_ALL); + + do_N_ternary("fmadds", insn_fmadds, macArgs, nMacArgs, SHOW_ALL); + do_N_ternary("fmadds_", insn_fmadds_, macArgs, nMacArgs, SHOW_ALL); + + do_N_ternary("fmsub", insn_fmsub, macArgs, nMacArgs, SHOW_ALL); + do_N_ternary("fmsub_", insn_fmsub_, macArgs, nMacArgs, SHOW_ALL); + + do_N_ternary("fmsubs", insn_fmsubs, macArgs, nMacArgs, SHOW_ALL); + do_N_ternary("fmsubs_", insn_fmsubs_, macArgs, nMacArgs, SHOW_ALL); + + do_N_ternary("fnmadd", insn_fnmadd, macArgs, nMacArgs, SHOW_ALL); + do_N_ternary("fnmadd_", insn_fnmadd_, macArgs, nMacArgs, SHOW_ALL); + + do_N_ternary("fnmadds", insn_fnmadds, macArgs, nMacArgs, SHOW_ALL); + do_N_ternary("fnmadds_", insn_fnmadds_, macArgs, nMacArgs, SHOW_ALL); + + do_N_ternary("fnmsub", insn_fnmsub, macArgs, nMacArgs, SHOW_ALL); + do_N_ternary("fnmsub_", insn_fnmsub_, macArgs, nMacArgs, SHOW_ALL); + + do_N_ternary("fnmsubs", insn_fnmsubs, macArgs, nMacArgs, SHOW_ALL); + do_N_ternary("fnmsubs_", insn_fnmsubs_, macArgs, nMacArgs, SHOW_ALL); +#endif + + //do_N_unary(fre, SHOW_ALL); + //do_N_unary(fre_, SHOW_ALL); + + do_N_unary("fres", insn_fres, args, nargs, 0x000001FFFFFFFFFFULL); + do_N_unary("fres_", insn_fres_, args, nargs, 0x000001FFFFFFFFFFULL); + + do_N_unary("frsqrte", insn_frsqrte, args, nargs, SHOW_ALL); + do_N_unary("frsqrte_", insn_frsqrte_, args, nargs, SHOW_ALL); + + // do_N_unary("frsqrtes", insn_frsqrtes, args, nargs, SHOW_ALL); + // do_N_unary("frsqrtes_", insn_frsqrtes_, args, nargs, SHOW_ALL); + + do_N_unary("frsp", insn_frsp, args, nargs, SHOW_ALL); + do_N_unary("frsp_", insn_frsp_, args, nargs, SHOW_ALL); + + do_N_ternary("fsel", insn_fsel, args, nargs, SHOW_ALL); + do_N_ternary("fsel_", insn_fsel_, args, nargs, SHOW_ALL); + + //do_N_unary(fsqrt, SHOW_ALL); + //do_N_unary(fsqrt_, SHOW_ALL); + + //do_N_unary(fsqrts, SHOW_ALL); + //do_N_unary(fsqrts_, SHOW_ALL); + + return 0; +}