Home | History | Annotate | Download | only in fpu 
      1 /* Native implementation of soft float functions. Only a single status
      2    context is supported */
      3 #include "softfloat.h"
      4 #include <math.h>
      5 #if defined(CONFIG_SOLARIS)
      6 #include <fenv.h>
      7 #endif
      8 
      9 void set_float_rounding_mode(int val STATUS_PARAM)
     10 {
     11     STATUS(float_rounding_mode) = val;
     12 #if (defined(CONFIG_BSD) && !defined(__APPLE__) && !defined(__GLIBC__)) || \
     13     (defined(CONFIG_SOLARIS) && CONFIG_SOLARIS_VERSION < 10)
     14     fpsetround(val);
     15 #else
     16     fesetround(val);
     17 #endif
     18 }
     19 
     20 #ifdef FLOATX80
     21 void set_floatx80_rounding_precision(int val STATUS_PARAM)
     22 {
     23     STATUS(floatx80_rounding_precision) = val;
     24 }
     25 #endif
     26 
     27 #if defined(CONFIG_BSD) || \
     28     (defined(CONFIG_SOLARIS) && CONFIG_SOLARIS_VERSION < 10)
     29 #define lrint(d)		((int32_t)rint(d))
     30 #define llrint(d)		((int64_t)rint(d))
     31 #define lrintf(f)		((int32_t)rint(f))
     32 #define llrintf(f)		((int64_t)rint(f))
     33 #define sqrtf(f)		((float)sqrt(f))
     34 #define remainderf(fa, fb)	((float)remainder(fa, fb))
     35 #define rintf(f)		((float)rint(f))
     36 #if !defined(__sparc__) && \
     37     (defined(CONFIG_SOLARIS) && CONFIG_SOLARIS_VERSION < 10)
     38 extern long double rintl(long double);
     39 extern long double scalbnl(long double, int);
     40 
     41 long long
     42 llrintl(long double x) {
     43 	return ((long long) rintl(x));
     44 }
     45 
     46 long
     47 lrintl(long double x) {
     48 	return ((long) rintl(x));
     49 }
     50 
     51 long double
     52 ldexpl(long double x, int n) {
     53 	return (scalbnl(x, n));
     54 }
     55 #endif
     56 #endif
     57 
     58 #if defined(_ARCH_PPC)
     59 
     60 /* correct (but slow) PowerPC rint() (glibc version is incorrect) */
     61 static double qemu_rint(double x)
     62 {
     63     double y = 4503599627370496.0;
     64     if (fabs(x) >= y)
     65         return x;
     66     if (x < 0)
     67         y = -y;
     68     y = (x + y) - y;
     69     if (y == 0.0)
     70         y = copysign(y, x);
     71     return y;
     72 }
     73 
     74 #define rint qemu_rint
     75 #endif
     76 
     77 /*----------------------------------------------------------------------------
     78 | Software IEC/IEEE integer-to-floating-point conversion routines.
     79 *----------------------------------------------------------------------------*/
     80 float32 int32_to_float32(int v STATUS_PARAM)
     81 {
     82     return (float32)v;
     83 }
     84 
     85 float32 uint32_to_float32(unsigned int v STATUS_PARAM)
     86 {
     87     return (float32)v;
     88 }
     89 
     90 float64 int32_to_float64(int v STATUS_PARAM)
     91 {
     92     return (float64)v;
     93 }
     94 
     95 float64 uint32_to_float64(unsigned int v STATUS_PARAM)
     96 {
     97     return (float64)v;
     98 }
     99 
    100 #ifdef FLOATX80
    101 floatx80 int32_to_floatx80(int v STATUS_PARAM)
    102 {
    103     return (floatx80)v;
    104 }
    105 #endif
    106 float32 int64_to_float32( int64_t v STATUS_PARAM)
    107 {
    108     return (float32)v;
    109 }
    110 float32 uint64_to_float32( uint64_t v STATUS_PARAM)
    111 {
    112     return (float32)v;
    113 }
    114 float64 int64_to_float64( int64_t v STATUS_PARAM)
    115 {
    116     return (float64)v;
    117 }
    118 float64 uint64_to_float64( uint64_t v STATUS_PARAM)
    119 {
    120     return (float64)v;
    121 }
    122 #ifdef FLOATX80
    123 floatx80 int64_to_floatx80( int64_t v STATUS_PARAM)
    124 {
    125     return (floatx80)v;
    126 }
    127 #endif
    128 
    129 /* XXX: this code implements the x86 behaviour, not the IEEE one.  */
    130 #if HOST_LONG_BITS == 32
    131 static inline int long_to_int32(long a)
    132 {
    133     return a;
    134 }
    135 #else
    136 static inline int long_to_int32(long a)
    137 {
    138     if (a != (int32_t)a)
    139         a = 0x80000000;
    140     return a;
    141 }
    142 #endif
    143 
    144 /*----------------------------------------------------------------------------
    145 | Software IEC/IEEE single-precision conversion routines.
    146 *----------------------------------------------------------------------------*/
    147 int float32_to_int32( float32 a STATUS_PARAM)
    148 {
    149     return long_to_int32(lrintf(a));
    150 }
    151 int float32_to_int32_round_to_zero( float32 a STATUS_PARAM)
    152 {
    153     return (int)a;
    154 }
    155 int64_t float32_to_int64( float32 a STATUS_PARAM)
    156 {
    157     return llrintf(a);
    158 }
    159 
    160 int64_t float32_to_int64_round_to_zero( float32 a STATUS_PARAM)
    161 {
    162     return (int64_t)a;
    163 }
    164 
    165 float64 float32_to_float64( float32 a STATUS_PARAM)
    166 {
    167     return a;
    168 }
    169 #ifdef FLOATX80
    170 floatx80 float32_to_floatx80( float32 a STATUS_PARAM)
    171 {
    172     return a;
    173 }
    174 #endif
    175 
    176 unsigned int float32_to_uint32( float32 a STATUS_PARAM)
    177 {
    178     int64_t v;
    179     unsigned int res;
    180 
    181     v = llrintf(a);
    182     if (v < 0) {
    183         res = 0;
    184     } else if (v > 0xffffffff) {
    185         res = 0xffffffff;
    186     } else {
    187         res = v;
    188     }
    189     return res;
    190 }
    191 unsigned int float32_to_uint32_round_to_zero( float32 a STATUS_PARAM)
    192 {
    193     int64_t v;
    194     unsigned int res;
    195 
    196     v = (int64_t)a;
    197     if (v < 0) {
    198         res = 0;
    199     } else if (v > 0xffffffff) {
    200         res = 0xffffffff;
    201     } else {
    202         res = v;
    203     }
    204     return res;
    205 }
    206 
    207 /*----------------------------------------------------------------------------
    208 | Software IEC/IEEE single-precision operations.
    209 *----------------------------------------------------------------------------*/
    210 float32 float32_round_to_int( float32 a STATUS_PARAM)
    211 {
    212     return rintf(a);
    213 }
    214 
    215 float32 float32_rem( float32 a, float32 b STATUS_PARAM)
    216 {
    217     return remainderf(a, b);
    218 }
    219 
    220 float32 float32_sqrt( float32 a STATUS_PARAM)
    221 {
    222     return sqrtf(a);
    223 }
    224 int float32_compare( float32 a, float32 b STATUS_PARAM )
    225 {
    226     if (a < b) {
    227         return float_relation_less;
    228     } else if (a == b) {
    229         return float_relation_equal;
    230     } else if (a > b) {
    231         return float_relation_greater;
    232     } else {
    233         return float_relation_unordered;
    234     }
    235 }
    236 int float32_compare_quiet( float32 a, float32 b STATUS_PARAM )
    237 {
    238     if (isless(a, b)) {
    239         return float_relation_less;
    240     } else if (a == b) {
    241         return float_relation_equal;
    242     } else if (isgreater(a, b)) {
    243         return float_relation_greater;
    244     } else {
    245         return float_relation_unordered;
    246     }
    247 }
    248 int float32_is_signaling_nan( float32 a1)
    249 {
    250     float32u u;
    251     uint32_t a;
    252     u.f = a1;
    253     a = u.i;
    254     return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
    255 }
    256 
    257 int float32_is_quiet_nan( float32 a1 )
    258 {
    259     float32u u;
    260     uint64_t a;
    261     u.f = a1;
    262     a = u.i;
    263     return ( 0xFF800000 < ( a<<1 ) );
    264 }
    265 
    266 int float32_is_any_nan( float32 a1 )
    267 {
    268     float32u u;
    269     uint32_t a;
    270     u.f = a1;
    271     a = u.i;
    272     return (a & ~(1 << 31)) > 0x7f800000U;
    273 }
    274 
    275 /*----------------------------------------------------------------------------
    276 | Software IEC/IEEE double-precision conversion routines.
    277 *----------------------------------------------------------------------------*/
    278 int float64_to_int32( float64 a STATUS_PARAM)
    279 {
    280     return long_to_int32(lrint(a));
    281 }
    282 int float64_to_int32_round_to_zero( float64 a STATUS_PARAM)
    283 {
    284     return (int)a;
    285 }
    286 int64_t float64_to_int64( float64 a STATUS_PARAM)
    287 {
    288     return llrint(a);
    289 }
    290 int64_t float64_to_int64_round_to_zero( float64 a STATUS_PARAM)
    291 {
    292     return (int64_t)a;
    293 }
    294 float32 float64_to_float32( float64 a STATUS_PARAM)
    295 {
    296     return a;
    297 }
    298 #ifdef FLOATX80
    299 floatx80 float64_to_floatx80( float64 a STATUS_PARAM)
    300 {
    301     return a;
    302 }
    303 #endif
    304 #ifdef FLOAT128
    305 float128 float64_to_float128( float64 a STATUS_PARAM)
    306 {
    307     return a;
    308 }
    309 #endif
    310 
    311 unsigned int float64_to_uint32( float64 a STATUS_PARAM)
    312 {
    313     int64_t v;
    314     unsigned int res;
    315 
    316     v = llrint(a);
    317     if (v < 0) {
    318         res = 0;
    319     } else if (v > 0xffffffff) {
    320         res = 0xffffffff;
    321     } else {
    322         res = v;
    323     }
    324     return res;
    325 }
    326 unsigned int float64_to_uint32_round_to_zero( float64 a STATUS_PARAM)
    327 {
    328     int64_t v;
    329     unsigned int res;
    330 
    331     v = (int64_t)a;
    332     if (v < 0) {
    333         res = 0;
    334     } else if (v > 0xffffffff) {
    335         res = 0xffffffff;
    336     } else {
    337         res = v;
    338     }
    339     return res;
    340 }
    341 uint64_t float64_to_uint64 (float64 a STATUS_PARAM)
    342 {
    343     int64_t v;
    344 
    345     v = llrint(a + (float64)INT64_MIN);
    346 
    347     return v - INT64_MIN;
    348 }
    349 uint64_t float64_to_uint64_round_to_zero (float64 a STATUS_PARAM)
    350 {
    351     int64_t v;
    352 
    353     v = (int64_t)(a + (float64)INT64_MIN);
    354 
    355     return v - INT64_MIN;
    356 }
    357 
    358 /*----------------------------------------------------------------------------
    359 | Software IEC/IEEE double-precision operations.
    360 *----------------------------------------------------------------------------*/
    361 #if defined(__sun__) && \
    362     (defined(CONFIG_SOLARIS) && CONFIG_SOLARIS_VERSION < 10)
    363 static inline float64 trunc(float64 x)
    364 {
    365     return x < 0 ? -floor(-x) : floor(x);
    366 }
    367 #endif
    368 float64 float64_trunc_to_int( float64 a STATUS_PARAM )
    369 {
    370     return trunc(a);
    371 }
    372 
    373 float64 float64_round_to_int( float64 a STATUS_PARAM )
    374 {
    375     return rint(a);
    376 }
    377 
    378 float64 float64_rem( float64 a, float64 b STATUS_PARAM)
    379 {
    380     return remainder(a, b);
    381 }
    382 
    383 float64 float64_sqrt( float64 a STATUS_PARAM)
    384 {
    385     return sqrt(a);
    386 }
    387 int float64_compare( float64 a, float64 b STATUS_PARAM )
    388 {
    389     if (a < b) {
    390         return float_relation_less;
    391     } else if (a == b) {
    392         return float_relation_equal;
    393     } else if (a > b) {
    394         return float_relation_greater;
    395     } else {
    396         return float_relation_unordered;
    397     }
    398 }
    399 int float64_compare_quiet( float64 a, float64 b STATUS_PARAM )
    400 {
    401     if (isless(a, b)) {
    402         return float_relation_less;
    403     } else if (a == b) {
    404         return float_relation_equal;
    405     } else if (isgreater(a, b)) {
    406         return float_relation_greater;
    407     } else {
    408         return float_relation_unordered;
    409     }
    410 }
    411 int float64_is_signaling_nan( float64 a1)
    412 {
    413     float64u u;
    414     uint64_t a;
    415     u.f = a1;
    416     a = u.i;
    417     return
    418            ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
    419         && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
    420 
    421 }
    422 
    423 int float64_is_quiet_nan( float64 a1 )
    424 {
    425     float64u u;
    426     uint64_t a;
    427     u.f = a1;
    428     a = u.i;
    429 
    430     return ( LIT64( 0xFFF0000000000000 ) < (uint64_t) ( a<<1 ) );
    431 
    432 }
    433 
    434 int float64_is_any_nan( float64 a1 )
    435 {
    436     float64u u;
    437     uint64_t a;
    438     u.f = a1;
    439     a = u.i;
    440 
    441     return (a & ~(1ULL << 63)) > LIT64 (0x7FF0000000000000 );
    442 }
    443 
    444 #ifdef FLOATX80
    445 
    446 /*----------------------------------------------------------------------------
    447 | Software IEC/IEEE extended double-precision conversion routines.
    448 *----------------------------------------------------------------------------*/
    449 int floatx80_to_int32( floatx80 a STATUS_PARAM)
    450 {
    451     return long_to_int32(lrintl(a));
    452 }
    453 int floatx80_to_int32_round_to_zero( floatx80 a STATUS_PARAM)
    454 {
    455     return (int)a;
    456 }
    457 int64_t floatx80_to_int64( floatx80 a STATUS_PARAM)
    458 {
    459     return llrintl(a);
    460 }
    461 int64_t floatx80_to_int64_round_to_zero( floatx80 a STATUS_PARAM)
    462 {
    463     return (int64_t)a;
    464 }
    465 float32 floatx80_to_float32( floatx80 a STATUS_PARAM)
    466 {
    467     return a;
    468 }
    469 float64 floatx80_to_float64( floatx80 a STATUS_PARAM)
    470 {
    471     return a;
    472 }
    473 
    474 /*----------------------------------------------------------------------------
    475 | Software IEC/IEEE extended double-precision operations.
    476 *----------------------------------------------------------------------------*/
    477 floatx80 floatx80_round_to_int( floatx80 a STATUS_PARAM)
    478 {
    479     return rintl(a);
    480 }
    481 floatx80 floatx80_rem( floatx80 a, floatx80 b STATUS_PARAM)
    482 {
    483     return remainderl(a, b);
    484 }
    485 floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM)
    486 {
    487     return sqrtl(a);
    488 }
    489 int floatx80_compare( floatx80 a, floatx80 b STATUS_PARAM )
    490 {
    491     if (a < b) {
    492         return float_relation_less;
    493     } else if (a == b) {
    494         return float_relation_equal;
    495     } else if (a > b) {
    496         return float_relation_greater;
    497     } else {
    498         return float_relation_unordered;
    499     }
    500 }
    501 int floatx80_compare_quiet( floatx80 a, floatx80 b STATUS_PARAM )
    502 {
    503     if (isless(a, b)) {
    504         return float_relation_less;
    505     } else if (a == b) {
    506         return float_relation_equal;
    507     } else if (isgreater(a, b)) {
    508         return float_relation_greater;
    509     } else {
    510         return float_relation_unordered;
    511     }
    512 }
    513 int floatx80_is_signaling_nan( floatx80 a1)
    514 {
    515     floatx80u u;
    516     uint64_t aLow;
    517     u.f = a1;
    518 
    519     aLow = u.i.low & ~ LIT64( 0x4000000000000000 );
    520     return
    521            ( ( u.i.high & 0x7FFF ) == 0x7FFF )
    522         && (uint64_t) ( aLow<<1 )
    523         && ( u.i.low == aLow );
    524 }
    525 
    526 int floatx80_is_quiet_nan( floatx80 a1 )
    527 {
    528     floatx80u u;
    529     u.f = a1;
    530     return ( ( u.i.high & 0x7FFF ) == 0x7FFF ) && (uint64_t) ( u.i.low<<1 );
    531 }
    532 
    533 int floatx80_is_any_nan( floatx80 a1 )
    534 {
    535     floatx80u u;
    536     u.f = a1;
    537     return ((u.i.high & 0x7FFF) == 0x7FFF) && ( u.i.low<<1 );
    538 }
    539 
    540 #endif
    541