git.maemo.org Git - qemu/blob - fpu/softfloat-native.c

   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__)
  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)
  26 #define lrint(d)                ((int32_t)rint(d))
  27 #define llrint(d)               ((int64_t)rint(d))
  28 #endif
  29
  30 #if defined(__powerpc__)
  31
  32 /* correct (but slow) PowerPC rint() (glibc version is incorrect) */
  33 double qemu_rint(double x)
  34 {
  35     double y = 4503599627370496.0;
  36     if (fabs(x) >= y)
  37         return x;
  38     if (x < 0)
  39         y = -y;
  40     y = (x + y) - y;
  41     if (y == 0.0)
  42         y = copysign(y, x);
  43     return y;
  44 }
  45
  46 #define rint qemu_rint
  47 #endif
  48
  49 /*----------------------------------------------------------------------------
  50 | Software IEC/IEEE integer-to-floating-point conversion routines.
  51 *----------------------------------------------------------------------------*/
  52 float32 int32_to_float32(int v STATUS_PARAM)
  53 {
  54     return (float32)v;
  55 }
  56
  57 float64 int32_to_float64(int v STATUS_PARAM)
  58 {
  59     return (float64)v;
  60 }
  61
  62 #ifdef FLOATX80
  63 floatx80 int32_to_floatx80(int v STATUS_PARAM)
  64 {
  65     return (floatx80)v;
  66 }
  67 #endif
  68 float32 int64_to_float32( int64_t v STATUS_PARAM)
  69 {
  70     return (float32)v;
  71 }
  72 float64 int64_to_float64( int64_t v STATUS_PARAM)
  73 {
  74     return (float64)v;
  75 }
  76 #ifdef FLOATX80
  77 floatx80 int64_to_floatx80( int64_t v STATUS_PARAM)
  78 {
  79     return (floatx80)v;
  80 }
  81 #endif
  82
  83 /*----------------------------------------------------------------------------
  84 | Software IEC/IEEE single-precision conversion routines.
  85 *----------------------------------------------------------------------------*/
  86 int float32_to_int32( float32 a STATUS_PARAM)
  87 {
  88     return lrintf(a);
  89 }
  90 int float32_to_int32_round_to_zero( float32 a STATUS_PARAM)
  91 {
  92     return (int)a;
  93 }
  94 int64_t float32_to_int64( float32 a STATUS_PARAM)
  95 {
  96     return llrintf(a);
  97 }
  98
  99 int64_t float32_to_int64_round_to_zero( float32 a STATUS_PARAM)
 100 {
 101     return (int64_t)a;
 102 }
 103
 104 float64 float32_to_float64( float32 a STATUS_PARAM)
 105 {
 106     return a;
 107 }
 108 #ifdef FLOATX80
 109 floatx80 float32_to_floatx80( float32 a STATUS_PARAM)
 110 {
 111     return a;
 112 }
 113 #endif
 114
 115 /*----------------------------------------------------------------------------
 116 | Software IEC/IEEE single-precision operations.
 117 *----------------------------------------------------------------------------*/
 118 float32 float32_round_to_int( float32 a STATUS_PARAM)
 119 {
 120     return rintf(a);
 121 }
 122
 123 float32 float32_sqrt( float32 a STATUS_PARAM)
 124 {
 125     return sqrtf(a);
 126 }
 127 char float32_is_signaling_nan( float32 a1)
 128 {
 129     float32u u;
 130     uint32_t a;
 131     u.f = a1;
 132     a = u.i;
 133     return ( ( ( a>>22 ) & 0x1FF ) == 0x1FE ) && ( a & 0x003FFFFF );
 134 }
 135
 136 /*----------------------------------------------------------------------------
 137 | Software IEC/IEEE double-precision conversion routines.
 138 *----------------------------------------------------------------------------*/
 139 int float64_to_int32( float64 a STATUS_PARAM)
 140 {
 141     return lrint(a);
 142 }
 143 int float64_to_int32_round_to_zero( float64 a STATUS_PARAM)
 144 {
 145     return (int)a;
 146 }
 147 int64_t float64_to_int64( float64 a STATUS_PARAM)
 148 {
 149     return llrint(a);
 150 }
 151 int64_t float64_to_int64_round_to_zero( float64 a STATUS_PARAM)
 152 {
 153     return (int64_t)a;
 154 }
 155 float32 float64_to_float32( float64 a STATUS_PARAM)
 156 {
 157     return a;
 158 }
 159 #ifdef FLOATX80
 160 floatx80 float64_to_floatx80( float64 a STATUS_PARAM)
 161 {
 162     return a;
 163 }
 164 #endif
 165 #ifdef FLOAT128
 166 float128 float64_to_float128( float64 a STATUS_PARAM)
 167 {
 168     return a;
 169 }
 170 #endif
 171
 172 /*----------------------------------------------------------------------------
 173 | Software IEC/IEEE double-precision operations.
 174 *----------------------------------------------------------------------------*/
 175 float64 float64_round_to_int( float64 a STATUS_PARAM )
 176 {
 177 #if defined(__arm__)
 178     switch(STATUS(float_rounding_mode)) {
 179     default:
 180     case float_round_nearest_even:
 181         asm("rndd %0, %1" : "=f" (a) : "f"(a));
 182         break;
 183     case float_round_down:
 184         asm("rnddm %0, %1" : "=f" (a) : "f"(a));
 185         break;
 186     case float_round_up:
 187         asm("rnddp %0, %1" : "=f" (a) : "f"(a));
 188         break;
 189     case float_round_to_zero:
 190         asm("rnddz %0, %1" : "=f" (a) : "f"(a));
 191         break;
 192     }
 193 #else
 194     return rint(a);
 195 #endif
 196 }
 197
 198 float64 float64_sqrt( float64 a STATUS_PARAM)
 199 {
 200     return sqrt(a);
 201 }
 202 char float64_is_signaling_nan( float64 a1)
 203 {
 204     float64u u;
 205     uint64_t a;
 206     u.f = a1;
 207     a = u.i;
 208     return
 209            ( ( ( a>>51 ) & 0xFFF ) == 0xFFE )
 210         && ( a & LIT64( 0x0007FFFFFFFFFFFF ) );
 211
 212 }
 213
 214 #ifdef FLOATX80
 215
 216 /*----------------------------------------------------------------------------
 217 | Software IEC/IEEE extended double-precision conversion routines.
 218 *----------------------------------------------------------------------------*/
 219 int floatx80_to_int32( floatx80 a STATUS_PARAM)
 220 {
 221     return lrintl(a);
 222 }
 223 int floatx80_to_int32_round_to_zero( floatx80 a STATUS_PARAM)
 224 {
 225     return (int)a;
 226 }
 227 int64_t floatx80_to_int64( floatx80 a STATUS_PARAM)
 228 {
 229     return llrintl(a);
 230 }
 231 int64_t floatx80_to_int64_round_to_zero( floatx80 a STATUS_PARAM)
 232 {
 233     return (int64_t)a;
 234 }
 235 float32 floatx80_to_float32( floatx80 a STATUS_PARAM)
 236 {
 237     return a;
 238 }
 239 float64 floatx80_to_float64( floatx80 a STATUS_PARAM)
 240 {
 241     return a;
 242 }
 243
 244 /*----------------------------------------------------------------------------
 245 | Software IEC/IEEE extended double-precision operations.
 246 *----------------------------------------------------------------------------*/
 247 floatx80 floatx80_round_to_int( floatx80 a STATUS_PARAM)
 248 {
 249     return rintl(a);
 250 }
 251 floatx80 floatx80_sqrt( floatx80 a STATUS_PARAM)
 252 {
 253     return sqrtl(a);
 254 }
 255 char floatx80_is_signaling_nan( floatx80 a1)
 256 {
 257     floatx80u u;
 258     u.f = a1;
 259     return ( ( u.i.high & 0x7FFF ) == 0x7FFF ) && (bits64) ( u.i.low<<1 );
 260 }
 261
 262 #endif