[thirdparty/binutils-gdb.git] / sim / testsuite / common / fpu-tst.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;
}
Commit	Line	Data
b3c77578 AC	1	#define ASSERT(EXPRESSION) \
	2	do { \
	3	if (!(EXPRESSION)) { \
	4	fprintf (stderr, "%s:%d: assertion failed - %s\n", \
	5	__FILE__, __LINE__, #EXPRESSION); \
	6	abort (); \
	7	} \
	8	} while (0)
	9
	10	#define SIM_BITS_INLINE (INCLUDE_MODULE \| INCLUDED_BY_MODULE)
	11
	12	#include "milieu.h"
	13	#include "softfloat.h"
	14	#include "systfloat.h"
	15	#include "systmodes.h"
	16
	17	/* #define SIM_FPU_INLINE (INCLUDE_MODULE \| INCLUDED_BY_MODULE) */
	18
	19
	20	#include "sim-bits.h"
	21	#include "sim-fpu.h"
	22	#include "sim-fpu.c"
	23
	24
	25
	26	static int flags;
	27
	28	int8
	29	syst_float_flags_clear ()
	30	{
	31	int old_flags = 0;
	32	int i = 1;
	33	while (flags >= i)
	34	{
	35	switch ((sim_fpu_status) (flags & i))
	36	{
	37	case sim_fpu_status_denorm:
	38	break;
	39	case sim_fpu_status_invalid_snan:
	40	case sim_fpu_status_invalid_qnan:
	41	case sim_fpu_status_invalid_isi:
	42	case sim_fpu_status_invalid_idi:
	43	case sim_fpu_status_invalid_zdz:
	44	case sim_fpu_status_invalid_imz:
	45	case sim_fpu_status_invalid_cvi:
	46	case sim_fpu_status_invalid_cmp:
	47	case sim_fpu_status_invalid_sqrt:
	48	old_flags \|= float_flag_invalid; /* v */
	49	break;
	50	case sim_fpu_status_inexact:
	51	old_flags \|= float_flag_inexact; /* x */
	52	break;
	53	case sim_fpu_status_overflow:
	54	old_flags \|= float_flag_overflow; /* o */
	55	break;
	56	case sim_fpu_status_underflow:
	57	old_flags \|= float_flag_underflow; /* u */
	58	break;
	59	case sim_fpu_status_invalid_div0:
	60	old_flags \|= float_flag_divbyzero; /* z */
	61	break;
	62	case sim_fpu_status_rounded:
	63	break;
	64	}
65	i <<= 1;
66	}
67	flags = 0;
68	return old_flags;
69	}
70
71
72	sim_fpu_round rounding_mode;
73
74	void
75	syst_float_set_rounding_mode(int8 mode)
76	{
77	switch (mode)
78	{
79	case float_round_nearest_even:
80	rounding_mode = sim_fpu_round_near;
81	break;
82	case float_round_down:
83	rounding_mode = sim_fpu_round_down;
84	break;
85	case float_round_up:
86	rounding_mode = sim_fpu_round_up;
87	break;
88	case float_round_to_zero:
89	rounding_mode = sim_fpu_round_zero;
90	break;
91	}
92	}
93
94
95	float32
96	syst_int32_to_float32(int32 a)
97	{
98	float32 z;
99	sim_fpu s;
100	flags \|= sim_fpu_i32to (&s, a, rounding_mode);
101	flags \|= sim_fpu_round_32 (&s, rounding_mode, 0);
102	sim_fpu_to32 (&z, &s);
103	return z;
104	}
105
106	float64
107	syst_int32_to_float64( int32 a )
108	{
109	float64 z;
110	sim_fpu s;
111	flags \|= sim_fpu_i32to (&s, a, rounding_mode);
112	sim_fpu_to64 (&z, &s);
113	return z;
114	}
115
116	int32
117	syst_float32_to_int32_round_to_zero( float32 a )
118	{
119	int32 z;
120	sim_fpu s;
121	sim_fpu_32to (&s, a);
122	flags \|= sim_fpu_to32i (&z, &s, sim_fpu_round_zero);
123	return z;
124	}
125
126	float64
127	syst_float32_to_float64 (float32 a)
128	{
129	float64 z;
130	sim_fpu s;
131	sim_fpu_32to (&s, a);
132	flags \|= sim_fpu_round_64 (&s, rounding_mode, 0);
133	sim_fpu_to64 (&z, &s);
134	return z;
135	}
136
137	float32 syst_float32_add( float32 a, float32 b )
138	{
139	float32 z;
140	sim_fpu A;
141	sim_fpu B;
142	sim_fpu ans;
143	sim_fpu_32to (&A, a);
144	sim_fpu_32to (&B, b);
145	#if 0
146	fprintf (stdout, "\n ");
147	sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
148	fprintf (stdout, "\n+ ");
149	sim_fpu_print_fpu (&B, (sim_fpu_print_func*) fprintf, stdout);
150	fprintf (stdout, "\n= ");
151	#endif
152	flags \|= sim_fpu_add (&ans, &A, &B);
153	flags \|= sim_fpu_round_32 (&ans, rounding_mode, 0);
154	#if 0
155	sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
156	fprintf (stdout, "\n");
157	#endif
158	sim_fpu_to32 (&z, &ans);
159	return z;
160	}
161
162	float32 syst_float32_sub( float32 a, float32 b )
163	{
164	float32 z;
165	sim_fpu A;
166	sim_fpu B;
167	sim_fpu ans;
168	sim_fpu_32to (&A, a);
169	sim_fpu_32to (&B, b);
170	#if 0
171	sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
172	fprintf (stdout, " + ");
173	sim_fpu_print_fpu (&B, (sim_fpu_print_func*) fprintf, stdout);
174	fprintf (stdout, " = ");
175	#endif
176	flags \|= sim_fpu_sub (&ans, &A, &B);
177	flags \|= sim_fpu_round_32 (&ans, rounding_mode, 0);
178	#if 0
179	sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
180	fprintf (stdout, "\n");
181	#endif
182	sim_fpu_to32 (&z, &ans);
183	return z;
184	}
185
186	float32 syst_float32_mul( float32 a, float32 b )
187	{
188	float32 z;
189	sim_fpu A;
190	sim_fpu B;
191	sim_fpu ans;
192	sim_fpu_32to (&A, a);
193	sim_fpu_32to (&B, b);
194	#if 0
195	sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
196	fprintf (stdout, " + ");
197	sim_fpu_print_fpu (&B, (sim_fpu_print_func*) fprintf, stdout);
198	fprintf (stdout, " = ");
199	#endif
200	flags \|= sim_fpu_mul (&ans, &A, &B);
201	#if 0
202	sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
203	#endif
204	flags \|= sim_fpu_round_32 (&ans, rounding_mode, 0);
205	#if 0
206	sim_fpu_print_status (flags, (sim_fpu_print_func*) fprintf, stdout);
207	fprintf (stdout, "\n");
208	#endif
209	sim_fpu_to32 (&z, &ans);
210	return z;
211	}
212
213	float32 syst_float32_div( float32 a, float32 b )
214	{
215	float32 z;
216	sim_fpu A;
217	sim_fpu B;
218	sim_fpu ans;
219	sim_fpu_32to (&A, a);
220	sim_fpu_32to (&B, b);
221	flags \|= sim_fpu_div (&ans, &A, &B);
222	flags \|= sim_fpu_round_32 (&ans, rounding_mode, 0);
223	sim_fpu_to32 (&z, &ans);
224	return z;
225	}
226
227	float32 syst_float32_sqrt( float32 a )
228	{
229	float32 z;
230	sim_fpu A;
231	sim_fpu ans;
232	sim_fpu_32to (&A, a);
233	#if 0
234	sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
235	fprintf (stdout, " sqrt> ");
236	#endif
237	flags \|= sim_fpu_sqrt (&ans, &A);
238	#if 0
239	sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
240	#endif
241	flags \|= sim_fpu_round_32 (&ans, rounding_mode, 0);
242	#if 0
243	fprintf (stdout, " (%x)\n", flags);
244	#endif
245	sim_fpu_to32 (&z, &ans);
246	return z;
247	}
248
249	flag syst_float32_eq( float32 a, float32 b )
250	{
251	sim_fpu A;
252	sim_fpu B;
253	int is;
254	sim_fpu_32to (&A, a);
255	sim_fpu_32to (&B, b);
256	flags \|= (sim_fpu_eq (&is, &A, &B) & ~sim_fpu_status_invalid_qnan);
257	return is;
258	}
259
260	flag syst_float32_eq_signaling( float32 a, float32 b )
261	{
262	sim_fpu A;
263	sim_fpu B;
264	int is;
265	sim_fpu_32to (&A, a);
266	sim_fpu_32to (&B, b);
267	flags \|= sim_fpu_eq (&is, &A, &B);
268	return is;
269	}
270
271	flag syst_float32_le( float32 a, float32 b )
272	{
273	sim_fpu A;
274	sim_fpu B;
275	int is;
276	sim_fpu_32to (&A, a);
277	sim_fpu_32to (&B, b);
278	flags \|= sim_fpu_le (&is, &A, &B);
279	return is;
280	}
281
282	flag syst_float32_le_quiet( float32 a, float32 b )
283	{
284	sim_fpu A;
285	sim_fpu B;
286	int is;
287	sim_fpu_32to (&A, a);
288	sim_fpu_32to (&B, b);
289	flags \|= (sim_fpu_le (&is, &A, &B) & ~sim_fpu_status_invalid_qnan);
290	return is;
291	}
292
293	flag syst_float32_lt( float32 a, float32 b )
294	{
295	sim_fpu A;
296	sim_fpu B;
297	int is;
298	sim_fpu_32to (&A, a);
299	sim_fpu_32to (&B, b);
300	flags \|= sim_fpu_lt (&is, &A, &B);
301	return is;
302	}
303
304	flag syst_float32_lt_quiet( float32 a, float32 b )
305	{
306	sim_fpu A;
307	sim_fpu B;
308	int is;
309	sim_fpu_32to (&A, a);
310	sim_fpu_32to (&B, b);
311	flags \|= (sim_fpu_lt (&is, &A, &B) & ~sim_fpu_status_invalid_qnan);
312	return is;
313	}
314
315	int32 syst_float64_to_int32_round_to_zero( float64 a )
316	{
317	int32 z;
318	sim_fpu s;
319	sim_fpu_64to (&s, a);
320	flags \|= sim_fpu_to32i (&z, &s, sim_fpu_round_zero);
321	return z;
322	}
323
324	float32 syst_float64_to_float32( float64 a )
325	{
326	float32 z;
327	sim_fpu s;
328	sim_fpu_64to (&s, a);
329	#if 0
330	sim_fpu_print_fpu (&s, (sim_fpu_print_func*) fprintf, stdout);
331	fprintf (stdout, " -> ");
332	#endif
333	flags \|= sim_fpu_round_32 (&s, rounding_mode, 0);
334	#if 0
335	sim_fpu_print_fpu (&s, (sim_fpu_print_func*) fprintf, stdout);
336	sim_fpu_print_status (flags, (sim_fpu_print_func*) fprintf, stdout);
337	printf ("\n");
338	#endif
339	sim_fpu_to32 (&z, &s);
340	return z;
341	}
342
343	float64 syst_float64_add( float64 a, float64 b )
344	{
345	float64 z;
346	sim_fpu A;
347	sim_fpu B;
348	sim_fpu ans;
349	sim_fpu_64to (&A, a);
350	sim_fpu_64to (&B, b);
351	#if 0
352	sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
353	fprintf (stdout, " + ");
354	sim_fpu_print_fpu (&B, (sim_fpu_print_func*) fprintf, stdout);
355	fprintf (stdout, " = ");
356	#endif
357	flags \|= sim_fpu_add (&ans, &A, &B);
358	#if 0
359	sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
360	#endif
361	flags \|= sim_fpu_round_64 (&ans, rounding_mode, 0);
362	#if 0
363	fprintf (stdout, " (%x)\n", flags);
364	#endif
365	sim_fpu_to64 (&z, &ans);
366	return z;
367	}
368
369	float64 syst_float64_sub( float64 a, float64 b )
370	{
371	float64 z;
372	sim_fpu A;
373	sim_fpu B;
374	sim_fpu ans;
375	sim_fpu_64to (&A, a);
376	sim_fpu_64to (&B, b);
377	#if 0
378	sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
379	fprintf (stdout, " + ");
380	sim_fpu_print_fpu (&B, (sim_fpu_print_func*) fprintf, stdout);
381	fprintf (stdout, " = ");
382	#endif
383	flags \|= sim_fpu_sub (&ans, &A, &B);
384	#if 0
385	sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
386	#endif
387	flags \|= sim_fpu_round_64 (&ans, rounding_mode, 0);
388	#if 0
389	fprintf (stdout, " (%x)\n", flags);
390	#endif
391	sim_fpu_to64 (&z, &ans);
392	return z;
393	}
394
395	float64 syst_float64_mul( float64 a, float64 b )
396	{
397	float64 z;
398	sim_fpu A;
399	sim_fpu B;
400	sim_fpu ans;
401	sim_fpu_64to (&A, a);
402	sim_fpu_64to (&B, b);
403	#if 0
404	sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
405	fprintf (stdout, " * ");
406	sim_fpu_print_fpu (&B, (sim_fpu_print_func*) fprintf, stdout);
407	fprintf (stdout, " = ");
408	#endif
409	flags \|= sim_fpu_mul (&ans, &A, &B);
410	#if 0
411	sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
412	#endif
413	flags \|= sim_fpu_round_64 (&ans, rounding_mode, 0);
414	#if 0
415	sim_fpu_print_status (flags, (sim_fpu_print_func*) fprintf, stdout);
416	fprintf (stdout, "\n");
417	#endif
418	sim_fpu_to64 (&z, &ans);
419	return z;
420	}
421
422	float64 syst_float64_div( float64 a, float64 b )
423	{
424	float64 z;
425	sim_fpu A;
426	sim_fpu B;
427	sim_fpu ans;
428	sim_fpu_64to (&A, a);
429	sim_fpu_64to (&B, b);
430	#if 0
431	sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
432	fprintf (stdout, " + ");
433	sim_fpu_print_fpu (&B, (sim_fpu_print_func*) fprintf, stdout);
434	fprintf (stdout, " = ");
435	#endif
436	flags \|= sim_fpu_div (&ans, &A, &B);
437	#if 0
438	sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
439	#endif
440	flags \|= sim_fpu_round_64 (&ans, rounding_mode, 0);
441	#if 0
442	sim_fpu_print_status (flags, (sim_fpu_print_func*) fprintf, stdout);
443	fprintf (stdout, "\n");
444	#endif
445	sim_fpu_to64 (&z, &ans);
446	return z;
447	}
448
449	float64 syst_float64_sqrt( float64 a )
450	{
451	float64 z;
452	sim_fpu A;
453	sim_fpu ans;
454	sim_fpu_64to (&A, a);
455	#if 0
456	sim_fpu_print_fpu (&A, (sim_fpu_print_func*) fprintf, stdout);
457	printf (" sqrt> ");
458	printf ("\n");
459	#endif
460	flags \|= sim_fpu_sqrt (&ans, &A);
461	#if 0
462	sim_fpu_print_fpu (&ans, (sim_fpu_print_func*) fprintf, stdout);
463	#endif
464	flags \|= sim_fpu_round_64 (&ans, rounding_mode, 0);
465	#if 0
466	sim_fpu_print_status (flags, (sim_fpu_print_func*) fprintf, stdout);
467	fprintf (stdout, "\n");
468	#endif
469	sim_fpu_to64 (&z, &ans);
470	return z;
471	}
472
473	flag syst_float64_eq( float64 a, float64 b )
474	{
475	sim_fpu A;
476	sim_fpu B;
477	int is;
478	sim_fpu_64to (&A, a);
479	sim_fpu_64to (&B, b);
480	flags \|= (sim_fpu_eq (&is, &A, &B) & ~sim_fpu_status_invalid_qnan);
481	return is;
482	}
483
484	flag syst_float64_eq_signaling( float64 a, float64 b )
485	{
486	sim_fpu A;
487	sim_fpu B;
488	int is;
489	sim_fpu_64to (&A, a);
490	sim_fpu_64to (&B, b);
491	flags \|= sim_fpu_eq (&is, &A, &B);
492	return is;
493	}
494
495	flag syst_float64_le( float64 a, float64 b )
496	{
497	sim_fpu A;
498	sim_fpu B;
499	int is;
500	sim_fpu_64to (&A, a);
501	sim_fpu_64to (&B, b);
502	flags \|= sim_fpu_le (&is, &A, &B);
503	return is;
504	}
505
506	flag syst_float64_le_quiet( float64 a, float64 b )
507	{
508	sim_fpu A;
509	sim_fpu B;
510	int is;
511	sim_fpu_64to (&A, a);
512	sim_fpu_64to (&B, b);
513	flags \|= (sim_fpu_le (&is, &A, &B) & ~sim_fpu_status_invalid_qnan);
514	return is;
515	}
516
517	flag syst_float64_lt( float64 a, float64 b )
518	{
519	sim_fpu A;
520	sim_fpu B;
521	int is;
522	sim_fpu_64to (&A, a);
523	sim_fpu_64to (&B, b);
524	flags \|= sim_fpu_lt (&is, &A, &B);
525	return is;
526	}
527
528	flag syst_float64_lt_quiet( float64 a, float64 b )
529	{
530	sim_fpu A;
531	sim_fpu B;
532	int is;
533	sim_fpu_64to (&A, a);
534	sim_fpu_64to (&B, b);
535	flags \|= (sim_fpu_lt (&is, &A, &B) & ~sim_fpu_status_invalid_qnan);
536	return is;
537	}
538