Changeset a82695c in mainline


Ignore:
Timestamp:
2006-02-22T11:29:49Z (19 years ago)
Author:
Josef Cejka <malyzelenyhnus@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
1d83419
Parents:
2cb202e
Message:

Completed conversions from float/double to integer types.

Location:
softfloat
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • softfloat/arch/ia32/include/functions.h

    r2cb202e ra82695c  
    4242#define float32_to_ulonglong(X) float32_to_uint64(X);
    4343
     44#define float64_to_uint(X) float64_to_uint32(X);
     45#define float64_to_ulong(X) float64_to_uint32(X);
     46#define float64_to_ulonglong(X) float64_to_uint64(X);
     47
    4448#endif
  • softfloat/arch/ia32/include/types.h

    r2cb202e ra82695c  
    4949#define MIN_INT64 (0x8000000000000000ll)
    5050
    51 #define MAX_UINT64 (0xFFFFFFFFFFFFFFFll)
     51#define MAX_UINT64 (0xFFFFFFFFFFFFFFFFll)
    5252#define MIN_UINT64 (0ll)
    5353
  • softfloat/generic/conversion.c

    r2cb202e ra82695c  
    208208
    209209
    210 
     210/** Helping procedure for converting float64 to uint64
     211 * @param a floating point number in normalized form (no NaNs or Inf are checked )
     212 * @return unsigned integer
     213 */
     214static __u64 _float64_to_uint64_helper(float64 a)
     215{
     216        __u64 frac;
     217       
     218        if (a.parts.exp < FLOAT64_BIAS) {
     219                /*TODO: rounding*/
     220                return 0;
     221        }
     222       
     223        frac = a.parts.fraction;
     224       
     225        frac |= FLOAT64_HIDDEN_BIT_MASK;
     226        /* shift fraction to left so hidden bit will be the most significant bit */
     227        frac <<= 64 - FLOAT64_FRACTION_SIZE - 1;
     228
     229        frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1;
     230        if ((a.parts.sign == 1) && (frac != 0)) {
     231                frac = ~frac;
     232                ++frac;
     233        }
     234       
     235        return frac;
     236}
     237
     238/* Convert float to unsigned int64
     239 * FIXME: Im not sure what to return if overflow/underflow happens
     240 *      - now its the biggest or the smallest int
     241 */
     242__u64 float64_to_uint64(float64 a)
     243{
     244        if (isFloat64NaN(a)) {
     245                return MAX_UINT64;
     246        }
     247       
     248        if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS)))  {
     249                if (a.parts.sign) {
     250                        return MIN_UINT64;
     251                }
     252                return MAX_UINT64;
     253        }
     254       
     255        return _float64_to_uint64_helper(a);   
     256}
     257
     258/* Convert float to signed int64
     259 * FIXME: Im not sure what to return if overflow/underflow happens
     260 *      - now its the biggest or the smallest int
     261 */
     262__s64 float64_to_int64(float64 a)
     263{
     264        if (isFloat64NaN(a)) {
     265                return MAX_INT64;
     266        }
     267       
     268        if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS)))  {
     269                if (a.parts.sign) {
     270                        return MIN_INT64;
     271                }
     272                return MAX_INT64;
     273        }
     274        return _float64_to_uint64_helper(a);
     275}       
     276
     277
     278
     279
     280
     281/** Helping procedure for converting float32 to uint64
     282 * @param a floating point number in normalized form (no NaNs or Inf are checked )
     283 * @return unsigned integer
     284 */
     285static __u64 _float32_to_uint64_helper(float32 a)
     286{
     287        __u64 frac;
     288       
     289        if (a.parts.exp < FLOAT32_BIAS) {
     290                /*TODO: rounding*/
     291                return 0;
     292        }
     293       
     294        frac = a.parts.fraction;
     295       
     296        frac |= FLOAT32_HIDDEN_BIT_MASK;
     297        /* shift fraction to left so hidden bit will be the most significant bit */
     298        frac <<= 64 - FLOAT32_FRACTION_SIZE - 1;
     299
     300        frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1;
     301        if ((a.parts.sign == 1) && (frac != 0)) {
     302                frac = ~frac;
     303                ++frac;
     304        }
     305       
     306        return frac;
     307}
     308
     309/* Convert float to unsigned int64
     310 * FIXME: Im not sure what to return if overflow/underflow happens
     311 *      - now its the biggest or the smallest int
     312 */
     313__u64 float32_to_uint64(float32 a)
     314{
     315        if (isFloat32NaN(a)) {
     316                return MAX_UINT64;
     317        }
     318       
     319        if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS)))  {
     320                if (a.parts.sign) {
     321                        return MIN_UINT64;
     322                }
     323                return MAX_UINT64;
     324        }
     325       
     326        return _float32_to_uint64_helper(a);   
     327}
     328
     329/* Convert float to signed int64
     330 * FIXME: Im not sure what to return if overflow/underflow happens
     331 *      - now its the biggest or the smallest int
     332 */
     333__s64 float32_to_int64(float32 a)
     334{
     335        if (isFloat32NaN(a)) {
     336                return MAX_INT64;
     337        }
     338       
     339        if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS)))  {
     340                if (a.parts.sign) {
     341                        return (MIN_INT64);
     342                }
     343                return MAX_INT64;
     344        }
     345        return _float32_to_uint64_helper(a);
     346}       
     347
     348
     349/* Convert float64 to unsigned int32
     350 * FIXME: Im not sure what to return if overflow/underflow happens
     351 *      - now its the biggest or the smallest int
     352 */
     353__u32 float64_to_uint32(float64 a)
     354{
     355        if (isFloat64NaN(a)) {
     356                return MAX_UINT32;
     357        }
     358       
     359        if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS)))  {
     360                if (a.parts.sign) {
     361                        return MIN_UINT32;
     362                }
     363                return MAX_UINT32;
     364        }
     365       
     366        return (__u32)_float64_to_uint64_helper(a);     
     367}
     368
     369/* Convert float64 to signed int32
     370 * FIXME: Im not sure what to return if overflow/underflow happens
     371 *      - now its the biggest or the smallest int
     372 */
     373__s32 float64_to_int32(float64 a)
     374{
     375        if (isFloat64NaN(a)) {
     376                return MAX_INT32;
     377        }
     378       
     379        if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS)))  {
     380                if (a.parts.sign) {
     381                        return MIN_INT32;
     382                }
     383                return MAX_INT32;
     384        }
     385        return (__s32)_float64_to_uint64_helper(a);
     386}       
     387
     388
  • softfloat/generic/softfloat.c

    r2cb202e ra82695c  
    174174int __fixdfsi(double a)
    175175{
     176        float64 da;
     177        da.d = a;
     178       
     179        return float64_to_int(da);
    176180}
    177181 
     
    185189long __fixdfdi(double a)
    186190{
     191        float64 da;
     192        da.d = a;
     193       
     194        return float64_to_long(da);
    187195}
    188196 
    189197long long __fixsfti(float a)
    190198{
     199        float32 fa;
     200        fa.f = a;
     201       
     202        return float32_to_longlong(fa);
    191203}
    192204long long __fixdfti(double a)
    193205{
     206        float64 da;
     207        da.d = a;
     208       
     209        return float64_to_longlong(da);
    194210}
    195211
     
    203219unsigned int __fixunsdfsi(double a)
    204220{
     221        float64 da;
     222        da.d = a;
     223       
     224        return float64_to_uint(da);
    205225}
    206226 
     
    214234unsigned long __fixunsdfdi(double a)
    215235{
     236        float64 da;
     237        da.d = a;
     238       
     239        return float64_to_ulong(da);
    216240}
    217241 
    218242unsigned long long __fixunssfti(float a)
    219243{
     244        float32 fa;
     245        fa.f = a;
     246       
     247        return float32_to_ulonglong(fa);
    220248}
    221249unsigned long long __fixunsdfti(double a)
    222250{
     251        float64 da;
     252        da.d = a;
     253       
     254        return float64_to_ulonglong(da);
    223255}
    224256 
  • softfloat/include/conversion.h

    r2cb202e ra82695c  
    3434float32 convertFloat64ToFloat32(float64 a);
    3535
     36__u32 float32_to_uint32(float32 a);
     37__s32 float32_to_int32(float32 a);
     38__u64 float64_to_uint64(float64 a);
     39__s64 float64_to_int64(float64 a);
     40__u64 float32_to_uint64(float32 a);
     41__s64 float32_to_int64(float32 a);
     42__u32 float64_to_uint32(float64 a);
     43__s32 float64_to_int32(float64 a);
     44
     45
    3646#endif
    3747
Note: See TracChangeset for help on using the changeset viewer.