Revision 750afe93 fpu/softfloat-native.h
| b/fpu/softfloat-native.h | ||
|---|---|---|
| 152 | 152 |
} |
| 153 | 153 |
float32 float32_rem( float32, float32 STATUS_PARAM); |
| 154 | 154 |
float32 float32_sqrt( float32 STATUS_PARAM); |
| 155 |
INLINE char float32_eq( float32 a, float32 b STATUS_PARAM)
|
|
| 155 |
INLINE int float32_eq( float32 a, float32 b STATUS_PARAM)
|
|
| 156 | 156 |
{
|
| 157 | 157 |
return a == b; |
| 158 | 158 |
} |
| 159 |
INLINE char float32_le( float32 a, float32 b STATUS_PARAM)
|
|
| 159 |
INLINE int float32_le( float32 a, float32 b STATUS_PARAM)
|
|
| 160 | 160 |
{
|
| 161 | 161 |
return a <= b; |
| 162 | 162 |
} |
| 163 |
INLINE char float32_lt( float32 a, float32 b STATUS_PARAM)
|
|
| 163 |
INLINE int float32_lt( float32 a, float32 b STATUS_PARAM)
|
|
| 164 | 164 |
{
|
| 165 | 165 |
return a < b; |
| 166 | 166 |
} |
| 167 |
INLINE char float32_eq_signaling( float32 a, float32 b STATUS_PARAM)
|
|
| 167 |
INLINE int float32_eq_signaling( float32 a, float32 b STATUS_PARAM)
|
|
| 168 | 168 |
{
|
| 169 | 169 |
return a <= b && a >= b; |
| 170 | 170 |
} |
| 171 |
INLINE char float32_le_quiet( float32 a, float32 b STATUS_PARAM)
|
|
| 171 |
INLINE int float32_le_quiet( float32 a, float32 b STATUS_PARAM)
|
|
| 172 | 172 |
{
|
| 173 | 173 |
return islessequal(a, b); |
| 174 | 174 |
} |
| 175 |
INLINE char float32_lt_quiet( float32 a, float32 b STATUS_PARAM)
|
|
| 175 |
INLINE int float32_lt_quiet( float32 a, float32 b STATUS_PARAM)
|
|
| 176 | 176 |
{
|
| 177 | 177 |
return isless(a, b); |
| 178 | 178 |
} |
| 179 |
INLINE char float32_unordered( float32 a, float32 b STATUS_PARAM)
|
|
| 179 |
INLINE int float32_unordered( float32 a, float32 b STATUS_PARAM)
|
|
| 180 | 180 |
{
|
| 181 | 181 |
return isunordered(a, b); |
| 182 | 182 |
|
| 183 | 183 |
} |
| 184 |
char float32_compare( float32, float32 STATUS_PARAM );
|
|
| 185 |
char float32_compare_quiet( float32, float32 STATUS_PARAM );
|
|
| 186 |
char float32_is_signaling_nan( float32 );
|
|
| 184 |
int float32_compare( float32, float32 STATUS_PARAM );
|
|
| 185 |
int float32_compare_quiet( float32, float32 STATUS_PARAM );
|
|
| 186 |
int float32_is_signaling_nan( float32 );
|
|
| 187 | 187 |
|
| 188 | 188 |
INLINE float32 float32_abs(float32 a) |
| 189 | 189 |
{
|
| ... | ... | |
| 233 | 233 |
} |
| 234 | 234 |
float64 float64_rem( float64, float64 STATUS_PARAM ); |
| 235 | 235 |
float64 float64_sqrt( float64 STATUS_PARAM ); |
| 236 |
INLINE char float64_eq( float64 a, float64 b STATUS_PARAM)
|
|
| 236 |
INLINE int float64_eq( float64 a, float64 b STATUS_PARAM)
|
|
| 237 | 237 |
{
|
| 238 | 238 |
return a == b; |
| 239 | 239 |
} |
| 240 |
INLINE char float64_le( float64 a, float64 b STATUS_PARAM)
|
|
| 240 |
INLINE int float64_le( float64 a, float64 b STATUS_PARAM)
|
|
| 241 | 241 |
{
|
| 242 | 242 |
return a <= b; |
| 243 | 243 |
} |
| 244 |
INLINE char float64_lt( float64 a, float64 b STATUS_PARAM)
|
|
| 244 |
INLINE int float64_lt( float64 a, float64 b STATUS_PARAM)
|
|
| 245 | 245 |
{
|
| 246 | 246 |
return a < b; |
| 247 | 247 |
} |
| 248 |
INLINE char float64_eq_signaling( float64 a, float64 b STATUS_PARAM)
|
|
| 248 |
INLINE int float64_eq_signaling( float64 a, float64 b STATUS_PARAM)
|
|
| 249 | 249 |
{
|
| 250 | 250 |
return a <= b && a >= b; |
| 251 | 251 |
} |
| 252 |
INLINE char float64_le_quiet( float64 a, float64 b STATUS_PARAM)
|
|
| 252 |
INLINE int float64_le_quiet( float64 a, float64 b STATUS_PARAM)
|
|
| 253 | 253 |
{
|
| 254 | 254 |
return islessequal(a, b); |
| 255 | 255 |
} |
| 256 |
INLINE char float64_lt_quiet( float64 a, float64 b STATUS_PARAM)
|
|
| 256 |
INLINE int float64_lt_quiet( float64 a, float64 b STATUS_PARAM)
|
|
| 257 | 257 |
{
|
| 258 | 258 |
return isless(a, b); |
| 259 | 259 |
|
| 260 | 260 |
} |
| 261 |
INLINE char float64_unordered( float64 a, float64 b STATUS_PARAM)
|
|
| 261 |
INLINE int float64_unordered( float64 a, float64 b STATUS_PARAM)
|
|
| 262 | 262 |
{
|
| 263 | 263 |
return isunordered(a, b); |
| 264 | 264 |
|
| 265 | 265 |
} |
| 266 |
char float64_compare( float64, float64 STATUS_PARAM );
|
|
| 267 |
char float64_compare_quiet( float64, float64 STATUS_PARAM );
|
|
| 268 |
char float64_is_signaling_nan( float64 );
|
|
| 269 |
flag float64_is_nan( float64 );
|
|
| 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 );
|
|
| 270 | 270 |
|
| 271 | 271 |
INLINE float64 float64_abs(float64 a) |
| 272 | 272 |
{
|
| ... | ... | |
| 315 | 315 |
} |
| 316 | 316 |
floatx80 floatx80_rem( floatx80, floatx80 STATUS_PARAM ); |
| 317 | 317 |
floatx80 floatx80_sqrt( floatx80 STATUS_PARAM ); |
| 318 |
INLINE char floatx80_eq( floatx80 a, floatx80 b STATUS_PARAM)
|
|
| 318 |
INLINE int floatx80_eq( floatx80 a, floatx80 b STATUS_PARAM)
|
|
| 319 | 319 |
{
|
| 320 | 320 |
return a == b; |
| 321 | 321 |
} |
| 322 |
INLINE char floatx80_le( floatx80 a, floatx80 b STATUS_PARAM)
|
|
| 322 |
INLINE int floatx80_le( floatx80 a, floatx80 b STATUS_PARAM)
|
|
| 323 | 323 |
{
|
| 324 | 324 |
return a <= b; |
| 325 | 325 |
} |
| 326 |
INLINE char floatx80_lt( floatx80 a, floatx80 b STATUS_PARAM)
|
|
| 326 |
INLINE int floatx80_lt( floatx80 a, floatx80 b STATUS_PARAM)
|
|
| 327 | 327 |
{
|
| 328 | 328 |
return a < b; |
| 329 | 329 |
} |
| 330 |
INLINE char floatx80_eq_signaling( floatx80 a, floatx80 b STATUS_PARAM)
|
|
| 330 |
INLINE int floatx80_eq_signaling( floatx80 a, floatx80 b STATUS_PARAM)
|
|
| 331 | 331 |
{
|
| 332 | 332 |
return a <= b && a >= b; |
| 333 | 333 |
} |
| 334 |
INLINE char floatx80_le_quiet( floatx80 a, floatx80 b STATUS_PARAM)
|
|
| 334 |
INLINE int floatx80_le_quiet( floatx80 a, floatx80 b STATUS_PARAM)
|
|
| 335 | 335 |
{
|
| 336 | 336 |
return islessequal(a, b); |
| 337 | 337 |
} |
| 338 |
INLINE char floatx80_lt_quiet( floatx80 a, floatx80 b STATUS_PARAM)
|
|
| 338 |
INLINE int floatx80_lt_quiet( floatx80 a, floatx80 b STATUS_PARAM)
|
|
| 339 | 339 |
{
|
| 340 | 340 |
return isless(a, b); |
| 341 | 341 |
|
| 342 | 342 |
} |
| 343 |
INLINE char floatx80_unordered( floatx80 a, floatx80 b STATUS_PARAM)
|
|
| 343 |
INLINE int floatx80_unordered( floatx80 a, floatx80 b STATUS_PARAM)
|
|
| 344 | 344 |
{
|
| 345 | 345 |
return isunordered(a, b); |
| 346 | 346 |
|
| 347 | 347 |
} |
| 348 |
char floatx80_compare( floatx80, floatx80 STATUS_PARAM );
|
|
| 349 |
char floatx80_compare_quiet( floatx80, floatx80 STATUS_PARAM );
|
|
| 350 |
char floatx80_is_signaling_nan( floatx80 );
|
|
| 348 |
int floatx80_compare( floatx80, floatx80 STATUS_PARAM );
|
|
| 349 |
int floatx80_compare_quiet( floatx80, floatx80 STATUS_PARAM );
|
|
| 350 |
int floatx80_is_signaling_nan( floatx80 );
|
|
| 351 | 351 |
|
| 352 | 352 |
INLINE floatx80 floatx80_abs(floatx80 a) |
| 353 | 353 |
{
|
Also available in: Unified diff