1 /* Native implementation of soft float functions. Only a single status

     2    context is supported */

     3 #include "softfloat.h"

     4 #include <math.h>

     5 

     6 void set_float_rounding_mode(int val STATUS_PARAM)

     7 {

     8     STATUS(float_rounding_mode) = val;

     9 #if defined(_BSD) && !defined(__APPLE__) || (defined(HOST_SOLARIS) && HOST_SOLARIS < 10)

    10     fpsetround(val);

    11 #elif defined(__arm__)

    12     /* nothing to do */

    13 #else

    14     fesetround(val);

    15 #endif

    16 }

    17 

    18 #ifdef FLOATX80

    19 void set_floatx80_rounding_precision(int val STATUS_PARAM)

    20 {

    21     STATUS(floatx80_rounding_precision) = val;

    22 }

    23 #endif

    24 

    25 #if defined(_BSD) || (defined(HOST_SOLARIS) && HOST_SOLARIS < 10)

    26 #define lrint(d)		((int32_t)rint(d))

    27 #define llrint(d)		((int64_t)rint(d))

    28 #define lrintf(f)		((int32_t)rint(f))

    29 #define llrintf(f)		((int64_t)rint(f))

    30 #define sqrtf(f)		((float)sqrt(f))

    31 #define remainderf(fa, fb)	((float)remainder(fa, fb))

    32 #define rintf(f)		((float)rint(f))

    33 #if !defined(__sparc__) && defined(HOST_SOLARIS) && HOST_SOLARIS < 10

    34 extern long double rintl(long double);

    35 extern long double scalbnl(long double, int);

    36 

    37 long long

    38 llrintl(long double x) {

    39 	return ((long long) rintl(x));

    40 }

    41 

    42 long

    43 lrintl(long double x) {

    44 	return ((long) rintl(x));

    45 }

    46 

    47 long double

    48 ldexpl(long double x, int n) {

    49 	return (scalbnl(x, n));

    50 }

    51 #endif

    52 #endif

    53 

    54 #if defined(__powerpc__)

    55 

    56 /* correct (but slow) PowerPC rint() (glibc version is incorrect) */

    57 double qemu_rint(double x)

    58 {

    59     double y = 4503599627370496.0;

    60     if (fabs(x) >= y)

    61         return x;

    62     if (x < 0)

    63         y = -y;

    64     y = (x + y) - y;

    65     if (y == 0.0)

    66         y = copysign(y, x);

    67     return y;

    68 }

    69 

    70 #define rint qemu_rint

    71 #endif

    72 

    73 /*----------------------------------------------------------------------------

    74 | Software IEC/IEEE integer-to-floating-point conversion routines.

    75 *----------------------------------------------------------------------------*/

    76 float32 int32_to_float32(int v STATUS_PARAM)

    77 {

    78     return (float32)v;

    79 }

    80 

    81 float32 uint32_to_float32(unsigned int v STATUS_PARAM)

    82 {

    83     return (float32)v;

    84 }

    85 

    86 float64 int32_to_float64(int v STATUS_PARAM)

    87 {

    88     return (float64)v;

    89 }

    90 

    91 float64 uint32_to_float64(unsigned int v STATUS_PARAM)

    92 {

    93     return (float64)v;

    94 }

    95 

    96 #ifdef FLOATX80

    97 floatx80 int32_to_floatx80(int v STATUS_PARAM)

    98 {

    99     return (floatx80)v;

   100 }

   101 #endif

   102 float32 int64_to_float32( int64_t v STATUS_PARAM)

   103 {

   104     return (float32)v;

   105 }

   106 float32 uint64_to_float32( uint64_t v STATUS_PARAM)

   107 {

   108     return (float32)v;

   109 }

   110 float64 int64_to_float64( int64_t v STATUS_PARAM)

   111 {

   112     return (float64)v;

   113 }

   114 float64 uint64_to_float64( uint64_t v STATUS_PARAM)

   115 {

   116     return (float64)v;

   117 }

   118 #ifdef FLOATX80

   119 floatx80 int64_to_floatx80( int64_t v STATUS_PARAM)

   120 {

   121     return (floatx80)v;

   122 }

   123 #endif

   124 

   125 /* XXX: this code implements the x86 behaviour, not the IEEE one.  */

   126 #if HOST_LONG_BITS == 32

   127 static inline int long_to_int32(long a)

   128 {

   129     return a;

   130 }

   131 #else

   132 static inline int long_to_int32(long a)

   133 {

   134     if (a != (int32_t)a)

   135         a = 0x80000000;

   136     return a;

   137 }

   138 #endif

   139 

   140 /*----------------------------------------------------------------------------

   141 | Software IEC/IEEE single-precision conversion routines.

   142 *----------------------------------------------------------------------------*/

   143 int float32_to_int32( float32 a STATUS_PARAM)

   144 {

   145     return long_to_int32(lrintf(a));

   146 }

   147 int float32_to_int32_round_to_zero( float32 a STATUS_PARAM)

   148 {

   149     return (int)a;

   150 }

   151 int64_t float32_to_int64( float32 a STATUS_PARAM)

   152 {

   153     return llrintf(a);

   154 }

   155 

   156 int64_t float32_to_int64_round_to_zero( float32 a STATUS_PARAM)

   157 {

   158     return (int64_t)a;

   159 }

   160 

   161 float64 float32_to_float64( float32 a STATUS_PARAM)

   162 {

   163     return a;

   164 }

   165 #ifdef FLOATX80

   166 floatx80 float32_to_floatx80( float32 a STATUS_PARAM)

   167 {

   168     return a;

   169 }

   170 #endif

   171 

   172 unsigned int float32_to_uint32( float32 a STATUS_PARAM)

   173 {

   174     int64_t v;

   175     unsigned int res;

   176 

   177     v = llrintf(a);

   178     if (v < 0) {

   179         res = 0;

   180     } else if (v > 0xffffffff) {

   181         res = 0xffffffff;

   182     } else {

   183         res = v;

   184     }

   185     return res;

   186 }

   187 unsigned int float32_to_uint32_round_to_zero( float32 a STATUS_PARAM)

   188 {

   189     int64_t v;

   190     unsigned int res;

   191 

   192     v = (int64_t)a;

   193     if (v < 0) {

   194         res = 0;

   195     } else if (v > 0xffffffff) {

   196         res = 0xffffffff;

   197     } else {

   198         res = v;

   199     }

   200     return res;

   201 }

   202 

   203 /*----------------------------------------------------------------------------

   204 | Software IEC/IEEE single-precision operations.

   205 *----------------------------------------------------------------------------*/

   206 float32 float32_round_to_int( float32 a STATUS_PARAM)

   207 {

   208     return rintf(a);

   209 }

   210 

   211 float32 float32_rem( float32 a, float32 b STATUS_PARAM)

   212 {

   213     return remainderf(a, b);

   214 }

   215 

   216 float32 float32_sqrt( float32 a STATUS_PARAM)

   217 {

   218     return sqrtf(a);

   219 }

   220 int float32_compare( float32 a, float32 b STATUS_PARAM )

   221 {

   222     if (a < b) {

   223         return float_relation_less;

   224     } else if (a == b) {

   225         return float_relation_equal;

   226     } else if (a > b) {

   227         return float_relation_greater;

   228     } else {

   229         return float_relation_unordered;

   230     }

   231 }

   232 int float32_compare_quiet( float32 a, float32 b STATUS_PARAM )

   233 {

   234     if (isless(a, b)) {

   235         return float_relation_less;

   236     } else if (a == b) {

   237         return float_relation_equal;

   238     } else if (isgreater(a, b)) {

   239         return float_relation_greater;

   240     } else {

   241         return float_relation_unordered;

   242     }

   243 }

   244 int float32_is_signaling_nan( float32 a1)

   245 {

   246     float32u u;

   247     uint32_t a;

   248     u.f = a1;

   249     a = u.i;

   250     return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );

   251 }

   252 

   253 int float32_is_nan( float32 a1 )

   254 {

   255     float32u u;

   256     uint64_t a;

   257     u.f = a1;

   258     a = u.i;

   259     return ( 0xFF800000 < ( a<<1 ) );

   260 }

   261 

   262 /*----------------------------------------------------------------------------

   263 | Software IEC/IEEE double-precision conversion routines.

   264 *----------------------------------------------------------------------------*/

   265 int float64_to_int32( float64 a STATUS_PARAM)

   266 {

   267     return long_to_int32(lrint(a));

   268 }

   269 int float64_to_int32_round_to_zero( float64 a STATUS_PARAM)

   270 {

   271     return (int)a;

   272 }

   273 int64_t float64_to_int64( float64 a STATUS_PARAM)

   274 {

   275     return llrint(a);

   276 }

   277 int64_t float64_to_int64_round_to_zero( float64 a STATUS_PARAM)

   278 {

   279     return (int64_t)a;

   280 }

   281 float32 float64_to_float32( float64 a STATUS_PARAM)

   282 {

   283     return a;

   284 }

   285 #ifdef FLOATX80

   286 floatx80 float64_to_floatx80( float64 a STATUS_PARAM)

   287 {

   288     return a;

   289 }

   290 #endif

   291 #ifdef FLOAT128

   292 float128 float64_to_float128( float64 a STATUS_PARAM)

   293 {

   294     return a;

   295 }

   296 #endif

   297 

   298 unsigned int float64_to_uint32( float64 a STATUS_PARAM)

   299 {

   300     int64_t v;

   301     unsigned int res;

   302 

   303     v = llrint(a);

   304     if (v < 0) {

   305         res = 0;

   306     } else if (v > 0xffffffff) {

   307         res = 0xffffffff;

   308     } else {

   309         res = v;

   310     }

   311     return res;

   312 }

   313 unsigned int float64_to_uint32_round_to_zero( float64 a STATUS_PARAM)

   314 {

   315     int64_t v;

   316     unsigned int res;

   317 

   318     v = (int64_t)a;

   319     if (v < 0) {

   320         res = 0;

   321     } else if (v > 0xffffffff) {

   322         res = 0xffffffff;

   323     } else {

   324         res = v;

   325     }

   326     return res;

   327 }

   328 uint64_t float64_to_uint64 (float64 a STATUS_PARAM)

   329 {

   330     int64_t v;

   331 

   332     v = llrint(a + (float64)INT64_MIN);

   333 

   334     return v - INT64_MIN;

   335 }

   336 uint64_t float64_to_uint64_round_to_zero (float64 a STATUS_PARAM)

   337 {

   338     int64_t v;

   339 

   340     v = (int64_t)(a + (float64)INT64_MIN);

   341 

   342     return v - INT64_MIN;

   343 }

   344 

   345 /*----------------------------------------------------------------------------

   346 | Software IEC/IEEE double-precision operations.

   347 *----------------------------------------------------------------------------*/

   348 #if defined(__sun__) && defined(HOST_SOLARIS) && HOST_SOLARIS < 10

   349 static inline float64 trunc(float64 x)

   350 {

   351     return x < 0 ? -floor(-x) : floor(x);

   352 }

   353 #endif

   354 float64 float64_trunc_to_int( float64 a STATUS_PARAM )

   355 {

   356     return trunc(a);

   357 }

   358 

   359 float64 float64_round_to_int( float64 a STATUS_PARAM )

   360 {

   361 #if defined(__arm__)

   362     switch(STATUS(float_rounding_mode)) {

   363     default:

   364     case float_round_nearest_even:

   365         asm("rndd %0, %1" : "=f" (a) : "f"(a));

   366         break;

   367     case float_round_down:

   368         asm("rnddm %0, %1" : "=f" (a) : "f"(a));

   369         break;

   370     case float_round_up:

   371         asm("rnddp %0, %1" : "=f" (a) : "f"(a));

   372         break;

   373     case float_round_to_zero:

   374         asm("rnddz %0, %1" : "=f" (a) : "f"(a));

   375         break;

   376     }

   377 #else

   378     return rint(a);

   379 #endif

   380 }

   381 

   382 float64 float64_rem( float64 a, float64 b STATUS_PARAM)

   383 {

   384     return remainder(a, b);

   385 }

   386 

   387 float64 float64_sqrt( float64 a STATUS_PARAM)

   388 {

   389     return sqrt(a);

   390 }

   391 int float64_compare( float64 a, float64 b STATUS_PARAM )

   392 {

   393     if (a < b) {

   394         return float_relation_less;

   395     } else if (a == b) {

   396         return float_relation_equal;

   397     } else if (a > b) {

   398         return float_relation_greater;

   399     } else {

   400         return float_relation_unordered;

   401     }

   402 }

   403 int float64_compare_quiet( float64 a, float64 b STATUS_PARAM )

   404 {

   405     if (isless(a, b)) {

   406         return float_relation_less;

   407     } else if (a == b) {

   408         return float_relation_equal;

   409     } else if (isgreater(a, b)) {

   410         return float_relation_greater;

   411     } else {

   412         return float_relation_unordered;

   413     }

   414 }

   415 int float64_is_signaling_nan( float64 a1)

   416 {

   417     float64u u;

   418     uint64_t a;

   419     u.f = a1;

   420     a = u.i;

   421     return

   422            ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )

   423         && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );

   424 

   425 }

   426 

   427 int float64_is_nan( float64 a1 )

   428 {

   429     float64u u;

   430     uint64_t a;

   431     u.f = a1;

   432     a = u.i;

   433 

   434     return ( LIT64( 0xFFF0000000000000 ) < (bits64) ( a<<1 ) );

   435 

   436 }

   437 

   438 #ifdef FLOATX80

   439 

   440 /*----------------------------------------------------------------------------

   441 | Software IEC/IEEE extended double-precision conversion routines.

   442 *----------------------------------------------------------------------------*/

   443 int floatx80_to_int32( floatx80 a STATUS_PARAM)

   444 {

   445     return long_to_int32(lrintl(a));

   446 }

   447 int floatx80_to_int32_round_to_zero( floatx80 a STATUS_PARAM)

   448 {

   449     return (int)a;

   450 }

   451 int64_t floatx80_to_int64( floatx80 a STATUS_PARAM)

   452 {

   453     return llrintl(a);

   454 }

   455 int64_t floatx80_to_int64_round_to_zero( floatx80 a STATUS_PARAM)

   456 {

   457     return (int64_t)a;

   458 }

   459 float32 floatx80_to_float32( floatx80 a STATUS_PARAM)

   460 {

   461     return a;

   462 }

   463 float64 floatx80_to_float64( floatx80 a STATUS_PARAM)

   464 {

   465     return a;

   466 }

   467 

   468 /*----------------------------------------------------------------------------

   469 | Software IEC/IEEE extended double-precision operations.

   470 *----------------------------------------------------------------------------*/

   471 floatx80 floatx80_round_to_int( floatx80 a STATUS_PARAM)

   472 {

   473     return rintl(a);

   474 }

   475 floatx80 floatx80_rem( floatx80 a, floatx80 b STATUS_PARAM)

   476 {

   477     return remainderl(a, b);

   478 }

   479 floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM)

   480 {

   481     return sqrtl(a);

   482 }

   483 int floatx80_compare( floatx80 a, floatx80 b STATUS_PARAM )

   484 {

   485     if (a < b) {

   486         return float_relation_less;

   487     } else if (a == b) {

   488         return float_relation_equal;

   489     } else if (a > b) {

   490         return float_relation_greater;

   491     } else {

   492         return float_relation_unordered;

   493     }

   494 }

   495 int floatx80_compare_quiet( floatx80 a, floatx80 b STATUS_PARAM )

   496 {

   497     if (isless(a, b)) {

   498         return float_relation_less;

   499     } else if (a == b) {

   500         return float_relation_equal;

   501     } else if (isgreater(a, b)) {

   502         return float_relation_greater;

   503     } else {

   504         return float_relation_unordered;

   505     }

   506 }

   507 int floatx80_is_signaling_nan( floatx80 a1)

   508 {

   509     floatx80u u;

   510     uint64_t aLow;

   511     u.f = a1;

   512 

   513     aLow = u.i.low & ~ LIT64( 0x4000000000000000 );

   514     return

   515            ( ( u.i.high & 0x7FFF ) == 0x7FFF )

   516         && (bits64) ( aLow<<1 )

   517         && ( u.i.low == aLow );

   518 }

   519 

   520 int floatx80_is_nan( floatx80 a1 )

   521 {

   522     floatx80u u;

   523     u.f = a1;

   524     return ( ( u.i.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( u.i.low<<1 );

   525 }

   526 

   527 #endif