Subversion Repositories HelenOS-historic

Compare Revisions

Ignore whitespace Rev 864 → Rev 865

/uspace/trunk/softfloat/include/conversion.h
33,5 → 33,15
 
float32 convertFloat64ToFloat32(float64 a);
 
__u32 float32_to_uint32(float32 a);
__s32 float32_to_int32(float32 a);
__u64 float64_to_uint64(float64 a);
__s64 float64_to_int64(float64 a);
__u64 float32_to_uint64(float32 a);
__s64 float32_to_int64(float32 a);
__u32 float64_to_uint32(float64 a);
__s32 float64_to_int32(float64 a);
 
 
#endif
 
/uspace/trunk/softfloat/generic/softfloat.c
173,6 → 173,10
}
int __fixdfsi(double a)
{
float64 da;
da.d = a;
return float64_to_int(da);
}
long __fixsfdi(float a)
184,13 → 188,25
}
long __fixdfdi(double a)
{
float64 da;
da.d = a;
return float64_to_long(da);
}
long long __fixsfti(float a)
{
float32 fa;
fa.f = a;
return float32_to_longlong(fa);
}
long long __fixdfti(double a)
{
float64 da;
da.d = a;
return float64_to_longlong(da);
}
 
unsigned int __fixunssfsi(float a)
202,6 → 218,10
}
unsigned int __fixunsdfsi(double a)
{
float64 da;
da.d = a;
return float64_to_uint(da);
}
unsigned long __fixunssfdi(float a)
213,13 → 233,25
}
unsigned long __fixunsdfdi(double a)
{
float64 da;
da.d = a;
return float64_to_ulong(da);
}
unsigned long long __fixunssfti(float a)
{
float32 fa;
fa.f = a;
return float32_to_ulonglong(fa);
}
unsigned long long __fixunsdfti(double a)
{
float64 da;
da.d = a;
return float64_to_ulonglong(da);
}
float __floatsisf(int i)
/uspace/trunk/softfloat/generic/conversion.c
207,4 → 207,182
}
 
 
/** Helping procedure for converting float64 to uint64
* @param a floating point number in normalized form (no NaNs or Inf are checked )
* @return unsigned integer
*/
static __u64 _float64_to_uint64_helper(float64 a)
{
__u64 frac;
if (a.parts.exp < FLOAT64_BIAS) {
/*TODO: rounding*/
return 0;
}
frac = a.parts.fraction;
frac |= FLOAT64_HIDDEN_BIT_MASK;
/* shift fraction to left so hidden bit will be the most significant bit */
frac <<= 64 - FLOAT64_FRACTION_SIZE - 1;
 
frac >>= 64 - (a.parts.exp - FLOAT64_BIAS) - 1;
if ((a.parts.sign == 1) && (frac != 0)) {
frac = ~frac;
++frac;
}
return frac;
}
 
/* Convert float to unsigned int64
* FIXME: Im not sure what to return if overflow/underflow happens
* - now its the biggest or the smallest int
*/
__u64 float64_to_uint64(float64 a)
{
if (isFloat64NaN(a)) {
return MAX_UINT64;
}
if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
if (a.parts.sign) {
return MIN_UINT64;
}
return MAX_UINT64;
}
return _float64_to_uint64_helper(a);
}
 
/* Convert float to signed int64
* FIXME: Im not sure what to return if overflow/underflow happens
* - now its the biggest or the smallest int
*/
__s64 float64_to_int64(float64 a)
{
if (isFloat64NaN(a)) {
return MAX_INT64;
}
if (isFloat64Infinity(a) || (a.parts.exp >= (64 + FLOAT64_BIAS))) {
if (a.parts.sign) {
return MIN_INT64;
}
return MAX_INT64;
}
return _float64_to_uint64_helper(a);
}
 
 
 
 
 
/** Helping procedure for converting float32 to uint64
* @param a floating point number in normalized form (no NaNs or Inf are checked )
* @return unsigned integer
*/
static __u64 _float32_to_uint64_helper(float32 a)
{
__u64 frac;
if (a.parts.exp < FLOAT32_BIAS) {
/*TODO: rounding*/
return 0;
}
frac = a.parts.fraction;
frac |= FLOAT32_HIDDEN_BIT_MASK;
/* shift fraction to left so hidden bit will be the most significant bit */
frac <<= 64 - FLOAT32_FRACTION_SIZE - 1;
 
frac >>= 64 - (a.parts.exp - FLOAT32_BIAS) - 1;
if ((a.parts.sign == 1) && (frac != 0)) {
frac = ~frac;
++frac;
}
return frac;
}
 
/* Convert float to unsigned int64
* FIXME: Im not sure what to return if overflow/underflow happens
* - now its the biggest or the smallest int
*/
__u64 float32_to_uint64(float32 a)
{
if (isFloat32NaN(a)) {
return MAX_UINT64;
}
if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
if (a.parts.sign) {
return MIN_UINT64;
}
return MAX_UINT64;
}
return _float32_to_uint64_helper(a);
}
 
/* Convert float to signed int64
* FIXME: Im not sure what to return if overflow/underflow happens
* - now its the biggest or the smallest int
*/
__s64 float32_to_int64(float32 a)
{
if (isFloat32NaN(a)) {
return MAX_INT64;
}
if (isFloat32Infinity(a) || (a.parts.exp >= (64 + FLOAT32_BIAS))) {
if (a.parts.sign) {
return (MIN_INT64);
}
return MAX_INT64;
}
return _float32_to_uint64_helper(a);
}
 
 
/* Convert float64 to unsigned int32
* FIXME: Im not sure what to return if overflow/underflow happens
* - now its the biggest or the smallest int
*/
__u32 float64_to_uint32(float64 a)
{
if (isFloat64NaN(a)) {
return MAX_UINT32;
}
if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
if (a.parts.sign) {
return MIN_UINT32;
}
return MAX_UINT32;
}
return (__u32)_float64_to_uint64_helper(a);
}
 
/* Convert float64 to signed int32
* FIXME: Im not sure what to return if overflow/underflow happens
* - now its the biggest or the smallest int
*/
__s32 float64_to_int32(float64 a)
{
if (isFloat64NaN(a)) {
return MAX_INT32;
}
if (isFloat64Infinity(a) || (a.parts.exp >= (32 + FLOAT64_BIAS))) {
if (a.parts.sign) {
return MIN_INT32;
}
return MAX_INT32;
}
return (__s32)_float64_to_uint64_helper(a);
}
 
 
/uspace/trunk/softfloat/arch/ia32/include/types.h
48,7 → 48,7
#define MAX_INT64 (0x7FFFFFFFFFFFFFFFll)
#define MIN_INT64 (0x8000000000000000ll)
 
#define MAX_UINT64 (0xFFFFFFFFFFFFFFFll)
#define MAX_UINT64 (0xFFFFFFFFFFFFFFFFll)
#define MIN_UINT64 (0ll)
 
 
/uspace/trunk/softfloat/arch/ia32/include/functions.h
41,4 → 41,8
#define float32_to_ulong(X) float32_to_uint32(X);
#define float32_to_ulonglong(X) float32_to_uint64(X);
 
#define float64_to_uint(X) float64_to_uint32(X);
#define float64_to_ulong(X) float64_to_uint32(X);
#define float64_to_ulonglong(X) float64_to_uint64(X);
 
#endif