binutils-gdb/sim/testsuite/common/fpu-tst.c

539 lines
11 KiB
C

#define ASSERT(EXPRESSION) \
do { \
if (!(EXPRESSION)) { \
fprintf (stderr, "%s:%d: assertion failed - %s\n", \
__FILE__, __LINE__, #EXPRESSION); \
abort (); \
} \
} while (0)
#define SIM_BITS_INLINE (INCLUDE_MODULE | INCLUDED_BY_MODULE)
#include "milieu.h"
#include "softfloat.h"
#include "systfloat.h"
#include "systmodes.h"
/* #define SIM_FPU_INLINE (INCLUDE_MODULE | INCLUDED_BY_MODULE) */
#include "sim-bits.h"
#include "sim-fpu.h"
#include "sim-fpu.c"
static int flags;
int8
syst_float_flags_clear ()
{
int old_flags = 0;
int i = 1;
while (flags >= i)
{
switch ((sim_fpu_status) (flags & i))
{
case sim_fpu_status_denorm:
break;
case sim_fpu_status_invalid_snan:
case sim_fpu_status_invalid_qnan:
case sim_fpu_status_invalid_isi:
case sim_fpu_status_invalid_idi:
case sim_fpu_status_invalid_zdz:
case sim_fpu_status_invalid_imz:
case sim_fpu_status_invalid_cvi:
case sim_fpu_status_invalid_cmp:
case sim_fpu_status_invalid_sqrt:
old_flags |= float_flag_invalid; /* v */
break;
case sim_fpu_status_inexact:
old_flags |= float_flag_inexact; /* x */
break;
case sim_fpu_status_overflow:
old_flags |= float_flag_overflow; /* o */
break;
case sim_fpu_status_underflow:
old_flags |= float_flag_underflow; /* u */
break;
case sim_fpu_status_invalid_div0:
old_flags |= float_flag_divbyzero; /* z */
break;
case sim_fpu_status_rounded:
break;
}
i <<= 1;
}
flags = 0;
return old_flags;
}
sim_fpu_round rounding_mode;
void
syst_float_set_rounding_mode(int8 mode)
{
switch (mode)
{
case float_round_nearest_even:
rounding_mode = sim_fpu_round_near;
break;
case float_round_down:
rounding_mode = sim_fpu_round_down;
break;
case float_round_up:
rounding_mode = sim_fpu_round_up;
break;
case float_round_to_zero:
rounding_mode = sim_fpu_round_zero;
break;
}
}
float32
syst_int32_to_float32(int32 a)
{
float32 z;
sim_fpu s;
flags |= sim_fpu_i32to (&s, a, rounding_mode);
flags |= sim_fpu_round_32 (&s, rounding_mode, 0);
sim_fpu_to32 (&z, &s);
return z;
}
float64
syst_int32_to_float64( int32 a )
{
float64 z;
sim_fpu s;
flags |= sim_fpu_i32to (&s, a, rounding_mode);
sim_fpu_to64 (&z, &s);
return z;
}
int32
syst_float32_to_int32_round_to_zero( float32 a )
{
int32 z;
sim_fpu s;
sim_fpu_32to (&s, a);
flags |= sim_fpu_to32i (&z, &s, sim_fpu_round_zero);
return z;
}
float64
syst_float32_to_float64 (float32 a)
{
float64 z;
sim_fpu s;
sim_fpu_32to (&s, a);
flags |= sim_fpu_round_64 (&s, rounding_mode, 0);
sim_fpu_to64 (&z, &s);
return z;
}
float32 syst_float32_add( float32 a, float32 b )
{
float32 z;
sim_fpu A;
sim_fpu B;
sim_fpu ans;
sim_fpu_32to (&A, a);
sim_fpu_32to (&B, b);
#if 0
fprintf (stdout, "\n ");
sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, "\n+ ");
sim_fpu_print_fpu (&B, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, "\n= ");
#endif
flags |= sim_fpu_add (&ans, &A, &B);
flags |= sim_fpu_round_32 (&ans, rounding_mode, 0);
#if 0
sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, "\n");
#endif
sim_fpu_to32 (&z, &ans);
return z;
}
float32 syst_float32_sub( float32 a, float32 b )
{
float32 z;
sim_fpu A;
sim_fpu B;
sim_fpu ans;
sim_fpu_32to (&A, a);
sim_fpu_32to (&B, b);
#if 0
sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, " + ");
sim_fpu_print_fpu (&B, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, " = ");
#endif
flags |= sim_fpu_sub (&ans, &A, &B);
flags |= sim_fpu_round_32 (&ans, rounding_mode, 0);
#if 0
sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, "\n");
#endif
sim_fpu_to32 (&z, &ans);
return z;
}
float32 syst_float32_mul( float32 a, float32 b )
{
float32 z;
sim_fpu A;
sim_fpu B;
sim_fpu ans;
sim_fpu_32to (&A, a);
sim_fpu_32to (&B, b);
#if 0
sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, " + ");
sim_fpu_print_fpu (&B, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, " = ");
#endif
flags |= sim_fpu_mul (&ans, &A, &B);
#if 0
sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
#endif
flags |= sim_fpu_round_32 (&ans, rounding_mode, 0);
#if 0
sim_fpu_print_status (flags, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, "\n");
#endif
sim_fpu_to32 (&z, &ans);
return z;
}
float32 syst_float32_div( float32 a, float32 b )
{
float32 z;
sim_fpu A;
sim_fpu B;
sim_fpu ans;
sim_fpu_32to (&A, a);
sim_fpu_32to (&B, b);
flags |= sim_fpu_div (&ans, &A, &B);
flags |= sim_fpu_round_32 (&ans, rounding_mode, 0);
sim_fpu_to32 (&z, &ans);
return z;
}
float32 syst_float32_sqrt( float32 a )
{
float32 z;
sim_fpu A;
sim_fpu ans;
sim_fpu_32to (&A, a);
#if 0
sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, " sqrt> ");
#endif
flags |= sim_fpu_sqrt (&ans, &A);
#if 0
sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
#endif
flags |= sim_fpu_round_32 (&ans, rounding_mode, 0);
#if 0
fprintf (stdout, " (%x)\n", flags);
#endif
sim_fpu_to32 (&z, &ans);
return z;
}
flag syst_float32_eq( float32 a, float32 b )
{
sim_fpu A;
sim_fpu B;
int is;
sim_fpu_32to (&A, a);
sim_fpu_32to (&B, b);
flags |= (sim_fpu_eq (&is, &A, &B) & ~sim_fpu_status_invalid_qnan);
return is;
}
flag syst_float32_eq_signaling( float32 a, float32 b )
{
sim_fpu A;
sim_fpu B;
int is;
sim_fpu_32to (&A, a);
sim_fpu_32to (&B, b);
flags |= sim_fpu_eq (&is, &A, &B);
return is;
}
flag syst_float32_le( float32 a, float32 b )
{
sim_fpu A;
sim_fpu B;
int is;
sim_fpu_32to (&A, a);
sim_fpu_32to (&B, b);
flags |= sim_fpu_le (&is, &A, &B);
return is;
}
flag syst_float32_le_quiet( float32 a, float32 b )
{
sim_fpu A;
sim_fpu B;
int is;
sim_fpu_32to (&A, a);
sim_fpu_32to (&B, b);
flags |= (sim_fpu_le (&is, &A, &B) & ~sim_fpu_status_invalid_qnan);
return is;
}
flag syst_float32_lt( float32 a, float32 b )
{
sim_fpu A;
sim_fpu B;
int is;
sim_fpu_32to (&A, a);
sim_fpu_32to (&B, b);
flags |= sim_fpu_lt (&is, &A, &B);
return is;
}
flag syst_float32_lt_quiet( float32 a, float32 b )
{
sim_fpu A;
sim_fpu B;
int is;
sim_fpu_32to (&A, a);
sim_fpu_32to (&B, b);
flags |= (sim_fpu_lt (&is, &A, &B) & ~sim_fpu_status_invalid_qnan);
return is;
}
int32 syst_float64_to_int32_round_to_zero( float64 a )
{
int32 z;
sim_fpu s;
sim_fpu_64to (&s, a);
flags |= sim_fpu_to32i (&z, &s, sim_fpu_round_zero);
return z;
}
float32 syst_float64_to_float32( float64 a )
{
float32 z;
sim_fpu s;
sim_fpu_64to (&s, a);
#if 0
sim_fpu_print_fpu (&s, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, " -> ");
#endif
flags |= sim_fpu_round_32 (&s, rounding_mode, 0);
#if 0
sim_fpu_print_fpu (&s, (sim_fpu_print_func*) fprintf, stdout);
sim_fpu_print_status (flags, (sim_fpu_print_func*) fprintf, stdout);
printf ("\n");
#endif
sim_fpu_to32 (&z, &s);
return z;
}
float64 syst_float64_add( float64 a, float64 b )
{
float64 z;
sim_fpu A;
sim_fpu B;
sim_fpu ans;
sim_fpu_64to (&A, a);
sim_fpu_64to (&B, b);
#if 0
sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, " + ");
sim_fpu_print_fpu (&B, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, " = ");
#endif
flags |= sim_fpu_add (&ans, &A, &B);
#if 0
sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
#endif
flags |= sim_fpu_round_64 (&ans, rounding_mode, 0);
#if 0
fprintf (stdout, " (%x)\n", flags);
#endif
sim_fpu_to64 (&z, &ans);
return z;
}
float64 syst_float64_sub( float64 a, float64 b )
{
float64 z;
sim_fpu A;
sim_fpu B;
sim_fpu ans;
sim_fpu_64to (&A, a);
sim_fpu_64to (&B, b);
#if 0
sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, " + ");
sim_fpu_print_fpu (&B, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, " = ");
#endif
flags |= sim_fpu_sub (&ans, &A, &B);
#if 0
sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
#endif
flags |= sim_fpu_round_64 (&ans, rounding_mode, 0);
#if 0
fprintf (stdout, " (%x)\n", flags);
#endif
sim_fpu_to64 (&z, &ans);
return z;
}
float64 syst_float64_mul( float64 a, float64 b )
{
float64 z;
sim_fpu A;
sim_fpu B;
sim_fpu ans;
sim_fpu_64to (&A, a);
sim_fpu_64to (&B, b);
#if 0
sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, " * ");
sim_fpu_print_fpu (&B, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, " = ");
#endif
flags |= sim_fpu_mul (&ans, &A, &B);
#if 0
sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
#endif
flags |= sim_fpu_round_64 (&ans, rounding_mode, 0);
#if 0
sim_fpu_print_status (flags, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, "\n");
#endif
sim_fpu_to64 (&z, &ans);
return z;
}
float64 syst_float64_div( float64 a, float64 b )
{
float64 z;
sim_fpu A;
sim_fpu B;
sim_fpu ans;
sim_fpu_64to (&A, a);
sim_fpu_64to (&B, b);
#if 0
sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, " + ");
sim_fpu_print_fpu (&B, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, " = ");
#endif
flags |= sim_fpu_div (&ans, &A, &B);
#if 0
sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
#endif
flags |= sim_fpu_round_64 (&ans, rounding_mode, 0);
#if 0
sim_fpu_print_status (flags, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, "\n");
#endif
sim_fpu_to64 (&z, &ans);
return z;
}
float64 syst_float64_sqrt( float64 a )
{
float64 z;
sim_fpu A;
sim_fpu ans;
sim_fpu_64to (&A, a);
#if 0
sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
printf (" sqrt> ");
printf ("\n");
#endif
flags |= sim_fpu_sqrt (&ans, &A);
#if 0
sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
#endif
flags |= sim_fpu_round_64 (&ans, rounding_mode, 0);
#if 0
sim_fpu_print_status (flags, (sim_fpu_print_func*) fprintf, stdout);
fprintf (stdout, "\n");
#endif
sim_fpu_to64 (&z, &ans);
return z;
}
flag syst_float64_eq( float64 a, float64 b )
{
sim_fpu A;
sim_fpu B;
int is;
sim_fpu_64to (&A, a);
sim_fpu_64to (&B, b);
flags |= (sim_fpu_eq (&is, &A, &B) & ~sim_fpu_status_invalid_qnan);
return is;
}
flag syst_float64_eq_signaling( float64 a, float64 b )
{
sim_fpu A;
sim_fpu B;
int is;
sim_fpu_64to (&A, a);
sim_fpu_64to (&B, b);
flags |= sim_fpu_eq (&is, &A, &B);
return is;
}
flag syst_float64_le( float64 a, float64 b )
{
sim_fpu A;
sim_fpu B;
int is;
sim_fpu_64to (&A, a);
sim_fpu_64to (&B, b);
flags |= sim_fpu_le (&is, &A, &B);
return is;
}
flag syst_float64_le_quiet( float64 a, float64 b )
{
sim_fpu A;
sim_fpu B;
int is;
sim_fpu_64to (&A, a);
sim_fpu_64to (&B, b);
flags |= (sim_fpu_le (&is, &A, &B) & ~sim_fpu_status_invalid_qnan);
return is;
}
flag syst_float64_lt( float64 a, float64 b )
{
sim_fpu A;
sim_fpu B;
int is;
sim_fpu_64to (&A, a);
sim_fpu_64to (&B, b);
flags |= sim_fpu_lt (&is, &A, &B);
return is;
}
flag syst_float64_lt_quiet( float64 a, float64 b )
{
sim_fpu A;
sim_fpu B;
int is;
sim_fpu_64to (&A, a);
sim_fpu_64to (&B, b);
flags |= (sim_fpu_lt (&is, &A, &B) & ~sim_fpu_status_invalid_qnan);
return is;
}