1 /* Native implementation of soft float functions */
4 #if (defined(_BSD) && !defined(__APPLE__)) || defined(HOST_SOLARIS)
6 #define fabsf(f) ((float)fabs(f))
12 * Define some C99-7.12.3 classification macros and
13 * some C99-.12.4 for Solaris systems OS less than 10,
14 * or Solaris 10 systems running GCC 3.x or less.
15 * Solaris 10 with GCC4 does not need these macros as they
16 * are defined in <iso/math_c99.h> with a compiler directive
18 #if defined(HOST_SOLARIS) && (( HOST_SOLARIS <= 9 ) || ( ( HOST_SOLARIS >= 10 ) && ( __GNUC__ <= 4) ))
20 * C99 7.12.3 classification macros
22 * C99 7.12.14 comparison macros
24 * ... do not work on Solaris 10 using GNU CC 3.4.x.
25 * Try to workaround the missing / broken C99 math macros.
28 #define isnormal(x) (fpclass(x) >= FP_NZERO)
29 #define isgreater(x, y) ((!unordered(x, y)) && ((x) > (y)))
30 #define isgreaterequal(x, y) ((!unordered(x, y)) && ((x) >= (y)))
31 #define isless(x, y) ((!unordered(x, y)) && ((x) < (y)))
32 #define islessequal(x, y) ((!unordered(x, y)) && ((x) <= (y)))
33 #define isunordered(x,y) unordered(x, y)
36 typedef float float32
;
37 typedef double float64
;
39 typedef long double floatx80
;
60 /*----------------------------------------------------------------------------
61 | Software IEC/IEEE floating-point rounding mode.
62 *----------------------------------------------------------------------------*/
63 #if (defined(_BSD) && !defined(__APPLE__)) || defined(HOST_SOLARIS)
65 float_round_nearest_even
= FP_RN
,
66 float_round_down
= FP_RM
,
67 float_round_up
= FP_RP
,
68 float_round_to_zero
= FP_RZ
70 #elif defined(__arm__)
72 float_round_nearest_even
= 0,
75 float_round_to_zero
= 3
79 float_round_nearest_even
= FE_TONEAREST
,
80 float_round_down
= FE_DOWNWARD
,
81 float_round_up
= FE_UPWARD
,
82 float_round_to_zero
= FE_TOWARDZERO
86 typedef struct float_status
{
87 signed char float_rounding_mode
;
89 signed char floatx80_rounding_precision
;
93 void set_float_rounding_mode(int val STATUS_PARAM
);
95 void set_floatx80_rounding_precision(int val STATUS_PARAM
);
98 /*----------------------------------------------------------------------------
99 | Software IEC/IEEE integer-to-floating-point conversion routines.
100 *----------------------------------------------------------------------------*/
101 float32
int32_to_float32( int STATUS_PARAM
);
102 float64
int32_to_float64( int STATUS_PARAM
);
104 floatx80
int32_to_floatx80( int STATUS_PARAM
);
107 float128
int32_to_float128( int STATUS_PARAM
);
109 float32
int64_to_float32( int64_t STATUS_PARAM
);
110 float64
int64_to_float64( int64_t STATUS_PARAM
);
112 floatx80
int64_to_floatx80( int64_t STATUS_PARAM
);
115 float128
int64_to_float128( int64_t STATUS_PARAM
);
118 /*----------------------------------------------------------------------------
119 | Software IEC/IEEE single-precision conversion routines.
120 *----------------------------------------------------------------------------*/
121 int float32_to_int32( float32 STATUS_PARAM
);
122 int float32_to_int32_round_to_zero( float32 STATUS_PARAM
);
123 int64_t float32_to_int64( float32 STATUS_PARAM
);
124 int64_t float32_to_int64_round_to_zero( float32 STATUS_PARAM
);
125 float64
float32_to_float64( float32 STATUS_PARAM
);
127 floatx80
float32_to_floatx80( float32 STATUS_PARAM
);
130 float128
float32_to_float128( float32 STATUS_PARAM
);
133 /*----------------------------------------------------------------------------
134 | Software IEC/IEEE single-precision operations.
135 *----------------------------------------------------------------------------*/
136 float32
float32_round_to_int( float32 STATUS_PARAM
);
137 INLINE float32
float32_add( float32 a
, float32 b STATUS_PARAM
)
141 INLINE float32
float32_sub( float32 a
, float32 b STATUS_PARAM
)
145 INLINE float32
float32_mul( float32 a
, float32 b STATUS_PARAM
)
149 INLINE float32
float32_div( float32 a
, float32 b STATUS_PARAM
)
153 float32
float32_rem( float32
, float32 STATUS_PARAM
);
154 float32
float32_sqrt( float32 STATUS_PARAM
);
155 INLINE
int float32_eq( float32 a
, float32 b STATUS_PARAM
)
159 INLINE
int float32_le( float32 a
, float32 b STATUS_PARAM
)
163 INLINE
int float32_lt( float32 a
, float32 b STATUS_PARAM
)
167 INLINE
int float32_eq_signaling( float32 a
, float32 b STATUS_PARAM
)
169 return a
<= b
&& a
>= b
;
171 INLINE
int float32_le_quiet( float32 a
, float32 b STATUS_PARAM
)
173 return islessequal(a
, b
);
175 INLINE
int float32_lt_quiet( float32 a
, float32 b STATUS_PARAM
)
179 INLINE
int float32_unordered( float32 a
, float32 b STATUS_PARAM
)
181 return isunordered(a
, b
);
184 int float32_compare( float32
, float32 STATUS_PARAM
);
185 int float32_compare_quiet( float32
, float32 STATUS_PARAM
);
186 int float32_is_signaling_nan( float32
);
188 INLINE float32
float32_abs(float32 a
)
193 INLINE float32
float32_chs(float32 a
)
198 /*----------------------------------------------------------------------------
199 | Software IEC/IEEE double-precision conversion routines.
200 *----------------------------------------------------------------------------*/
201 int float64_to_int32( float64 STATUS_PARAM
);
202 int float64_to_int32_round_to_zero( float64 STATUS_PARAM
);
203 int64_t float64_to_int64( float64 STATUS_PARAM
);
204 int64_t float64_to_int64_round_to_zero( float64 STATUS_PARAM
);
205 float32
float64_to_float32( float64 STATUS_PARAM
);
207 floatx80
float64_to_floatx80( float64 STATUS_PARAM
);
210 float128
float64_to_float128( float64 STATUS_PARAM
);
213 /*----------------------------------------------------------------------------
214 | Software IEC/IEEE double-precision operations.
215 *----------------------------------------------------------------------------*/
216 float64
float64_round_to_int( float64 STATUS_PARAM
);
217 float64
float64_trunc_to_int( float64 STATUS_PARAM
);
218 INLINE float64
float64_add( float64 a
, float64 b STATUS_PARAM
)
222 INLINE float64
float64_sub( float64 a
, float64 b STATUS_PARAM
)
226 INLINE float64
float64_mul( float64 a
, float64 b STATUS_PARAM
)
230 INLINE float64
float64_div( float64 a
, float64 b STATUS_PARAM
)
234 float64
float64_rem( float64
, float64 STATUS_PARAM
);
235 float64
float64_sqrt( float64 STATUS_PARAM
);
236 INLINE
int float64_eq( float64 a
, float64 b STATUS_PARAM
)
240 INLINE
int float64_le( float64 a
, float64 b STATUS_PARAM
)
244 INLINE
int float64_lt( float64 a
, float64 b STATUS_PARAM
)
248 INLINE
int float64_eq_signaling( float64 a
, float64 b STATUS_PARAM
)
250 return a
<= b
&& a
>= b
;
252 INLINE
int float64_le_quiet( float64 a
, float64 b STATUS_PARAM
)
254 return islessequal(a
, b
);
256 INLINE
int float64_lt_quiet( float64 a
, float64 b STATUS_PARAM
)
261 INLINE
int float64_unordered( float64 a
, float64 b STATUS_PARAM
)
263 return isunordered(a
, b
);
266 int float64_compare( float64
, float64 STATUS_PARAM
);
267 int float64_compare_quiet( float64
, float64 STATUS_PARAM
);
268 int float64_is_signaling_nan( float64
);
269 int float64_is_nan( float64
);
271 INLINE float64
float64_abs(float64 a
)
276 INLINE float64
float64_chs(float64 a
)
283 /*----------------------------------------------------------------------------
284 | Software IEC/IEEE extended double-precision conversion routines.
285 *----------------------------------------------------------------------------*/
286 int floatx80_to_int32( floatx80 STATUS_PARAM
);
287 int floatx80_to_int32_round_to_zero( floatx80 STATUS_PARAM
);
288 int64_t floatx80_to_int64( floatx80 STATUS_PARAM
);
289 int64_t floatx80_to_int64_round_to_zero( floatx80 STATUS_PARAM
);
290 float32
floatx80_to_float32( floatx80 STATUS_PARAM
);
291 float64
floatx80_to_float64( floatx80 STATUS_PARAM
);
293 float128
floatx80_to_float128( floatx80 STATUS_PARAM
);
296 /*----------------------------------------------------------------------------
297 | Software IEC/IEEE extended double-precision operations.
298 *----------------------------------------------------------------------------*/
299 floatx80
floatx80_round_to_int( floatx80 STATUS_PARAM
);
300 INLINE floatx80
floatx80_add( floatx80 a
, floatx80 b STATUS_PARAM
)
304 INLINE floatx80
floatx80_sub( floatx80 a
, floatx80 b STATUS_PARAM
)
308 INLINE floatx80
floatx80_mul( floatx80 a
, floatx80 b STATUS_PARAM
)
312 INLINE floatx80
floatx80_div( floatx80 a
, floatx80 b STATUS_PARAM
)
316 floatx80
floatx80_rem( floatx80
, floatx80 STATUS_PARAM
);
317 floatx80
floatx80_sqrt( floatx80 STATUS_PARAM
);
318 INLINE
int floatx80_eq( floatx80 a
, floatx80 b STATUS_PARAM
)
322 INLINE
int floatx80_le( floatx80 a
, floatx80 b STATUS_PARAM
)
326 INLINE
int floatx80_lt( floatx80 a
, floatx80 b STATUS_PARAM
)
330 INLINE
int floatx80_eq_signaling( floatx80 a
, floatx80 b STATUS_PARAM
)
332 return a
<= b
&& a
>= b
;
334 INLINE
int floatx80_le_quiet( floatx80 a
, floatx80 b STATUS_PARAM
)
336 return islessequal(a
, b
);
338 INLINE
int floatx80_lt_quiet( floatx80 a
, floatx80 b STATUS_PARAM
)
343 INLINE
int floatx80_unordered( floatx80 a
, floatx80 b STATUS_PARAM
)
345 return isunordered(a
, b
);
348 int floatx80_compare( floatx80
, floatx80 STATUS_PARAM
);
349 int floatx80_compare_quiet( floatx80
, floatx80 STATUS_PARAM
);
350 int floatx80_is_signaling_nan( floatx80
);
352 INLINE floatx80
floatx80_abs(floatx80 a
)
357 INLINE floatx80
floatx80_chs(floatx80 a
)