Index: uspace/lib/softfloat/Makefile =================================================================== --- uspace/lib/softfloat/Makefile (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ uspace/lib/softfloat/Makefile (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -33,5 +33,4 @@ SOURCES = \ - softfloat.c \ common.c \ add.c \ @@ -39,4 +38,5 @@ div.c \ mul.c \ + neg.c \ comparison.c \ conversion.c Index: uspace/lib/softfloat/add.c =================================================================== --- uspace/lib/softfloat/add.c (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ uspace/lib/softfloat/add.c (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -34,8 +34,8 @@ */ -#include "sftypes.h" #include "add.h" #include "comparison.h" #include "common.h" +#include "sub.h" /** Add two single-precision floats with the same sign. @@ -413,4 +413,141 @@ } +#ifdef float32_t + +float32_t __addsf3(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + float32_u res; + + if (ua.data.parts.sign != ub.data.parts.sign) { + if (ua.data.parts.sign) { + ua.data.parts.sign = 0; + res.data = sub_float32(ub.data, ua.data); + } else { + ub.data.parts.sign = 0; + res.data = sub_float32(ua.data, ub.data); + } + } else + res.data = add_float32(ua.data, ub.data); + + return res.val; +} + +float32_t __aeabi_fadd(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + float32_u res; + + if (ua.data.parts.sign != ub.data.parts.sign) { + if (ua.data.parts.sign) { + ua.data.parts.sign = 0; + res.data = sub_float32(ub.data, ua.data); + } else { + ub.data.parts.sign = 0; + res.data = sub_float32(ua.data, ub.data); + } + } else + res.data = add_float32(ua.data, ub.data); + + return res.val; +} + +#endif + +#ifdef float64_t + +float64_t __adddf3(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + float64_u res; + + if (ua.data.parts.sign != ub.data.parts.sign) { + if (ua.data.parts.sign) { + ua.data.parts.sign = 0; + res.data = sub_float64(ub.data, ua.data); + } else { + ub.data.parts.sign = 0; + res.data = sub_float64(ua.data, ub.data); + } + } else + res.data = add_float64(ua.data, ub.data); + + return res.val; +} + +float64_t __aeabi_dadd(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + float64_u res; + + if (ua.data.parts.sign != ub.data.parts.sign) { + if (ua.data.parts.sign) { + ua.data.parts.sign = 0; + res.data = sub_float64(ub.data, ua.data); + } else { + ub.data.parts.sign = 0; + res.data = sub_float64(ua.data, ub.data); + } + } else + res.data = add_float64(ua.data, ub.data); + + return res.val; +} + +#endif + +#ifdef float128_t + +float128_t __addtf3(float128_t a, float128_t b) +{ + float128_u ua; + ua.val = a; + + float128_u ub; + ub.val = b; + + float128_u res; + + if (ua.data.parts.sign != ub.data.parts.sign) { + if (ua.data.parts.sign) { + ua.data.parts.sign = 0; + res.data = sub_float128(ub.data, ua.data); + } else { + ub.data.parts.sign = 0; + res.data = sub_float128(ua.data, ub.data); + } + } else + res.data = add_float128(ua.data, ub.data); + + return res.val; +} + +void _Qp_add(float128_t *c, float128_t *a, float128_t *b) +{ + *c = __addtf3(*a, *b); +} + +#endif + /** @} */ Index: uspace/lib/softfloat/add.h =================================================================== --- uspace/lib/softfloat/add.h (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ uspace/lib/softfloat/add.h (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -37,4 +37,6 @@ #define __ADD_H__ +#include + extern float32 add_float32(float32, float32); extern float64 add_float64(float64, float64); @@ -42,4 +44,19 @@ extern float128 add_float128(float128, float128); +#ifdef float32_t +extern float32_t __addsf3(float32_t, float32_t); +extern float32_t __aeabi_fadd(float32_t, float32_t); +#endif + +#ifdef float64_t +extern float64_t __adddf3(float64_t, float64_t); +extern float64_t __aeabi_dadd(float64_t, float64_t); +#endif + +#ifdef float128_t +extern float128_t __addtf3(float128_t, float128_t); +extern void _Qp_add(float128_t *, float128_t *, float128_t *); +#endif + #endif Index: uspace/lib/softfloat/common.c =================================================================== --- uspace/lib/softfloat/common.c (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ uspace/lib/softfloat/common.c (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -34,5 +34,4 @@ */ -#include "sftypes.h" #include "common.h" Index: uspace/lib/softfloat/common.h =================================================================== --- uspace/lib/softfloat/common.h (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ uspace/lib/softfloat/common.h (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -37,5 +37,5 @@ #define __COMMON_H__ -#include "sftypes.h" +#include extern float64 finish_float64(int32_t, uint64_t, char); @@ -53,7 +53,10 @@ extern void rshift128(uint64_t, uint64_t, int, uint64_t *, uint64_t *); -extern void and128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, uint64_t *); -extern void or128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, uint64_t *); -extern void xor128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, uint64_t *); +extern void and128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, + uint64_t *); +extern void or128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, + uint64_t *); +extern void xor128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, + uint64_t *); extern void not128(uint64_t, uint64_t, uint64_t *, uint64_t *); @@ -62,6 +65,8 @@ extern int lt128(uint64_t, uint64_t, uint64_t, uint64_t); -extern void add128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, uint64_t *); -extern void sub128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, uint64_t *); +extern void add128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, + uint64_t *); +extern void sub128(uint64_t, uint64_t, uint64_t, uint64_t, uint64_t *, + uint64_t *); extern void mul64(uint64_t, uint64_t, uint64_t *, uint64_t *); Index: uspace/lib/softfloat/comparison.c =================================================================== --- uspace/lib/softfloat/comparison.c (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ uspace/lib/softfloat/comparison.c (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -34,5 +34,4 @@ */ -#include "sftypes.h" #include "comparison.h" #include "common.h" @@ -439,4 +438,713 @@ } +#ifdef float32_t + +int __gtsf2(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { + // TODO: sigNaNs + return -1; + } + + if (is_float32_gt(ua.data, ub.data)) + return 1; + + return 0; +} + +int __gesf2(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { + // TODO: sigNaNs + return -1; + } + + if (is_float32_eq(ua.data, ub.data)) + return 0; + + if (is_float32_gt(ua.data, ub.data)) + return 1; + + return -1; +} + +int __ltsf2(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { + // TODO: sigNaNs + return 1; + } + + if (is_float32_lt(ua.data, ub.data)) + return -1; + + return 0; +} + +int __lesf2(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { + // TODO: sigNaNs + return 1; + } + + if (is_float32_eq(ua.data, ub.data)) + return 0; + + if (is_float32_lt(ua.data, ub.data)) + return -1; + + return 1; +} + +int __eqsf2(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { + // TODO: sigNaNs + return 1; + } + + return is_float32_eq(ua.data, ub.data) - 1; +} + +int __nesf2(float32_t a, float32_t b) +{ + /* Strange, but according to GCC documentation */ + return __eqsf2(a, b); +} + +int __cmpsf2(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { + /* No special constant for unordered - maybe signaled? */ + return 1; + } + + if (is_float32_eq(ua.data, ub.data)) + return 0; + + if (is_float32_lt(ua.data, ub.data)) + return -1; + + return 1; +} + +int __unordsf2(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + return ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))); +} + +int __aeabi_fcmpgt(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { + // TODO: sigNaNs + return -1; + } + + if (is_float32_gt(ua.data, ub.data)) + return 1; + + return 0; +} + +int __aeabi_fcmplt(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { + // TODO: sigNaNs + return 1; + } + + if (is_float32_lt(ua.data, ub.data)) + return -1; + + return 0; +} + +int __aeabi_fcmpge(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { + // TODO: sigNaNs + return -1; + } + + if (is_float32_eq(ua.data, ub.data)) + return 0; + + if (is_float32_gt(ua.data, ub.data)) + return 1; + + return -1; +} + +int __aeabi_fcmpeq(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + if ((is_float32_nan(ua.data)) || (is_float32_nan(ub.data))) { + // TODO: sigNaNs + return 1; + } + + return is_float32_eq(ua.data, ub.data) - 1; +} + +#endif + +#ifdef float64_t + +int __gtdf2(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { + // TODO: sigNaNs + return -1; + } + + if (is_float64_gt(ua.data, ub.data)) + return 1; + + return 0; +} + +int __gedf2(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { + // TODO: sigNaNs + return -1; + } + + if (is_float64_eq(ua.data, ub.data)) + return 0; + + if (is_float64_gt(ua.data, ub.data)) + return 1; + + return -1; +} + +int __ltdf2(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { + // TODO: sigNaNs + return 1; + } + + if (is_float64_lt(ua.data, ub.data)) + return -1; + + return 0; +} + +int __ledf2(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { + // TODO: sigNaNs + return 1; + } + + if (is_float64_eq(ua.data, ub.data)) + return 0; + + if (is_float64_lt(ua.data, ub.data)) + return -1; + + return 1; +} + +int __eqdf2(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { + // TODO: sigNaNs + return 1; + } + + return is_float64_eq(ua.data, ub.data) - 1; +} + +int __nedf2(float64_t a, float64_t b) +{ + /* Strange, but according to GCC documentation */ + return __eqdf2(a, b); +} + +int __cmpdf2(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { + /* No special constant for unordered - maybe signaled? */ + return 1; + } + + if (is_float64_eq(ua.data, ub.data)) + return 0; + + if (is_float64_lt(ua.data, ub.data)) + return -1; + + return 1; +} + +int __unorddf2(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + return ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))); +} + +int __aeabi_dcmplt(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { + // TODO: sigNaNs + return 1; + } + + if (is_float64_lt(ua.data, ub.data)) + return -1; + + return 0; +} + +int __aeabi_dcmpeq(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { + // TODO: sigNaNs + return 1; + } + + return is_float64_eq(ua.data, ub.data) - 1; +} + +int __aeabi_dcmpgt(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { + // TODO: sigNaNs + return -1; + } + + if (is_float64_gt(ua.data, ub.data)) + return 1; + + return 0; +} + +int __aeabi_dcmpge(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { + // TODO: sigNaNs + return -1; + } + + if (is_float64_eq(ua.data, ub.data)) + return 0; + + if (is_float64_gt(ua.data, ub.data)) + return 1; + + return -1; +} + +int __aeabi_dcmple(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + if ((is_float64_nan(ua.data)) || (is_float64_nan(ub.data))) { + // TODO: sigNaNs + return 1; + } + + if (is_float64_eq(ua.data, ub.data)) + return 0; + + if (is_float64_lt(ua.data, ub.data)) + return -1; + + return 1; +} + +#endif + +#ifdef float128_t + +int __gttf2(float128_t a, float128_t b) +{ + float128_u ua; + ua.val = a; + + float128_u ub; + ub.val = b; + + if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) { + // TODO: sigNaNs + return -1; + } + + if (is_float128_gt(ua.data, ub.data)) + return 1; + + return 0; +} + +int __getf2(float128_t a, float128_t b) +{ + float128_u ua; + ua.val = a; + + float128_u ub; + ub.val = b; + + if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) { + // TODO: sigNaNs + return -1; + } + + if (is_float128_eq(ua.data, ub.data)) + return 0; + + if (is_float128_gt(ua.data, ub.data)) + return 1; + + return -1; +} + +int __lttf2(float128_t a, float128_t b) +{ + float128_u ua; + ua.val = a; + + float128_u ub; + ub.val = b; + + if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) { + // TODO: sigNaNs + return 1; + } + + if (is_float128_lt(ua.data, ub.data)) + return -1; + + return 0; +} + +int __letf2(float128_t a, float128_t b) +{ + float128_u ua; + ua.val = a; + + float128_u ub; + ub.val = b; + + if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) { + // TODO: sigNaNs + return 1; + } + + if (is_float128_eq(ua.data, ub.data)) + return 0; + + if (is_float128_lt(ua.data, ub.data)) + return -1; + + return 1; +} + +int __eqtf2(float128_t a, float128_t b) +{ + float128_u ua; + ua.val = a; + + float128_u ub; + ub.val = b; + + if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) { + // TODO: sigNaNs + return 1; + } + + return is_float128_eq(ua.data, ub.data) - 1; +} + +int __netf2(float128_t a, float128_t b) +{ + /* Strange, but according to GCC documentation */ + return __eqtf2(a, b); +} + +int __cmptf2(float128_t a, float128_t b) +{ + float128_u ua; + ua.val = a; + + float128_u ub; + ub.val = b; + + if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) { + /* No special constant for unordered - maybe signaled? */ + return 1; + } + + if (is_float128_eq(ua.data, ub.data)) + return 0; + + if (is_float128_lt(ua.data, ub.data)) + return -1; + + return 1; +} + +int __unordtf2(float128_t a, float128_t b) +{ + float128_u ua; + ua.val = a; + + float128_u ub; + ub.val = b; + + return ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))); +} + +int _Qp_cmp(float128_t *a, float128_t *b) +{ + float128_u ua; + ua.val = *a; + + float128_u ub; + ub.val = *b; + + if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) + return 3; + + if (is_float128_eq(ua.data, ub.data)) + return 0; + + if (is_float128_lt(ua.data, ub.data)) + return 1; + + return 2; +} + +int _Qp_cmpe(float128_t *a, float128_t *b) +{ + /* Strange, but according to SPARC Compliance Definition */ + return _Qp_cmp(a, b); +} + +int _Qp_fgt(float128_t *a, float128_t *b) +{ + float128_u ua; + ua.val = *a; + + float128_u ub; + ub.val = *b; + + if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) + return 0; + + return is_float128_gt(ua.data, ub.data); +} + +int _Qp_fge(float128_t *a, float128_t *b) +{ + float128_u ua; + ua.val = *a; + + float128_u ub; + ub.val = *b; + + if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) + return 0; + + return is_float128_eq(ua.data, ub.data) || + is_float128_gt(ua.data, ub.data); +} + +int _Qp_flt(float128_t *a, float128_t *b) +{ + float128_u ua; + ua.val = *a; + + float128_u ub; + ub.val = *b; + + if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) + return 0; + + return is_float128_lt(ua.data, ub.data); +} + +int _Qp_fle(float128_t *a, float128_t *b) +{ + float128_u ua; + ua.val = *a; + + float128_u ub; + ub.val = *b; + + if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) + return 0; + + return is_float128_eq(ua.data, ub.data) || + is_float128_lt(ua.data, ub.data); +} + +int _Qp_feq(float128_t *a, float128_t *b) +{ + float128_u ua; + ua.val = *a; + + float128_u ub; + ub.val = *b; + + if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) + return 0; + + return is_float128_eq(ua.data, ub.data); +} + +int _Qp_fne(float128_t *a, float128_t *b) +{ + float128_u ua; + ua.val = *a; + + float128_u ub; + ub.val = *b; + + if ((is_float128_nan(ua.data)) || (is_float128_nan(ub.data))) + return 0; + + return !is_float128_eq(ua.data, ub.data); +} + +#endif + /** @} */ Index: uspace/lib/softfloat/comparison.h =================================================================== --- uspace/lib/softfloat/comparison.h (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ uspace/lib/softfloat/comparison.h (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -36,4 +36,6 @@ #ifndef __COMPARISON_H__ #define __COMPARISON_H__ + +#include extern int is_float32_nan(float32); @@ -77,4 +79,55 @@ extern int is_float128_gt(float128, float128); +#ifdef float32_t +extern int __gtsf2(float32_t, float32_t); +extern int __gesf2(float32_t, float32_t); +extern int __ltsf2(float32_t, float32_t); +extern int __lesf2(float32_t, float32_t); +extern int __eqsf2(float32_t, float32_t); +extern int __nesf2(float32_t, float32_t); +extern int __cmpsf2(float32_t, float32_t); +extern int __unordsf2(float32_t, float32_t); +extern int __aeabi_fcmpgt(float32_t, float32_t); +extern int __aeabi_fcmplt(float32_t, float32_t); +extern int __aeabi_fcmpge(float32_t, float32_t); +extern int __aeabi_fcmpeq(float32_t, float32_t); +#endif + +#ifdef float64_t +extern int __gtdf2(float64_t, float64_t); +extern int __gedf2(float64_t, float64_t); +extern int __ltdf2(float64_t, float64_t); +extern int __ledf2(float64_t, float64_t); +extern int __eqdf2(float64_t, float64_t); +extern int __nedf2(float64_t, float64_t); +extern int __cmpdf2(float64_t, float64_t); +extern int __unorddf2(float64_t, float64_t); +extern int __aeabi_dcmplt(float64_t, float64_t); +extern int __aeabi_dcmpeq(float64_t, float64_t); +extern int __aeabi_dcmpgt(float64_t, float64_t); +extern int __aeabi_dcmpge(float64_t, float64_t); +extern int __aeabi_dcmple(float64_t, float64_t); +#endif + +#ifdef float128_t +extern int __gttf2(float128_t, float128_t); +extern int __getf2(float128_t, float128_t); +extern int __lttf2(float128_t, float128_t); +extern int __letf2(float128_t, float128_t); +extern int __eqtf2(float128_t, float128_t); +extern int __netf2(float128_t, float128_t); +extern int __cmptf2(float128_t, float128_t); +extern int __unordtf2(float128_t, float128_t); +extern int _Qp_cmp(float128_t *, float128_t *); +extern int _Qp_cmpe(float128_t *, float128_t *); +extern int _Qp_fgt(float128_t *, float128_t *); +extern int _Qp_fge(float128_t *, float128_t *); +extern int _Qp_flt(float128_t *, float128_t *); +extern int _Qp_fle(float128_t *, float128_t *); +extern int _Qp_feq(float128_t *, float128_t *); +extern int _Qp_fne(float128_t *, float128_t *); + +#endif + #endif Index: uspace/lib/softfloat/conversion.c =================================================================== --- uspace/lib/softfloat/conversion.c (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ uspace/lib/softfloat/conversion.c (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -34,5 +34,4 @@ */ -#include "sftypes.h" #include "conversion.h" #include "comparison.h" @@ -1037,4 +1036,464 @@ } +#ifdef float32_t + +float32_t __floatsisf(int32_t i) +{ + float32_u res; + res.data = int32_to_float32(i); + + return res.val; +} + +float32_t __floatdisf(int64_t i) +{ + float32_u res; + res.data = int64_to_float32(i); + + return res.val; +} + +float32_t __floatunsisf(uint32_t i) +{ + float32_u res; + res.data = uint32_to_float32(i); + + return res.val; +} + +float32_t __floatundisf(uint64_t i) +{ + float32_u res; + res.data = uint64_to_float32(i); + + return res.val; +} + +int32_t __fixsfsi(float32_t a) +{ + float32_u ua; + ua.val = a; + + return float32_to_int32(ua.data); +} + +int64_t __fixsfdi(float32_t a) +{ + float32_u ua; + ua.val = a; + + return float32_to_int64(ua.data); +} + +uint32_t __fixunssfsi(float32_t a) +{ + float32_u ua; + ua.val = a; + + return float32_to_uint32(ua.data); +} + +uint64_t __fixunssfdi(float32_t a) +{ + float32_u ua; + ua.val = a; + + return float32_to_uint64(ua.data); +} + +int32_t __aeabi_f2iz(float32_t a) +{ + float32_u ua; + ua.val = a; + + return float32_to_int32(ua.data); +} + +uint32_t __aeabi_f2uiz(float32_t a) +{ + float32_u ua; + ua.val = a; + + return float32_to_uint32(ua.data); +} + +float32_t __aeabi_i2f(int32_t i) +{ + float32_u res; + res.data = int32_to_float32(i); + + return res.val; +} + +float32_t __aeabi_l2f(int64_t i) +{ + float32_u res; + res.data = int64_to_float32(i); + + return res.val; +} + +float32_t __aeabi_ui2f(uint32_t i) +{ + float32_u res; + res.data = uint32_to_float32(i); + + return res.val; +} + +float32_t __aeabi_ul2f(uint64_t i) +{ + float32_u res; + res.data = uint64_to_float32(i); + + return res.val; +} + +#endif + +#ifdef float64_t + +float64_t __floatsidf(int32_t i) +{ + float64_u res; + res.data = int32_to_float64(i); + + return res.val; +} + +float64_t __floatdidf(int64_t i) +{ + float64_u res; + res.data = int64_to_float64(i); + + return res.val; +} + +float64_t __floatunsidf(uint32_t i) +{ + float64_u res; + res.data = uint32_to_float64(i); + + return res.val; +} + +float64_t __floatundidf(uint64_t i) +{ + float64_u res; + res.data = uint64_to_float64(i); + + return res.val; +} + +uint32_t __fixunsdfsi(float64_t a) +{ + float64_u ua; + ua.val = a; + + return float64_to_uint32(ua.data); +} + +uint64_t __fixunsdfdi(float64_t a) +{ + float64_u ua; + ua.val = a; + + return float64_to_uint64(ua.data); +} + +int32_t __fixdfsi(float64_t a) +{ + float64_u ua; + ua.val = a; + + return float64_to_int32(ua.data); +} + +int64_t __fixdfdi(float64_t a) +{ + float64_u ua; + ua.val = a; + + return float64_to_int64(ua.data); +} + +float64_t __aeabi_i2d(int32_t i) +{ + float64_u res; + res.data = int32_to_float64(i); + + return res.val; +} + +float64_t __aeabi_ui2d(uint32_t i) +{ + float64_u res; + res.data = uint32_to_float64(i); + + return res.val; +} + +float64_t __aeabi_l2d(int64_t i) +{ + float64_u res; + res.data = int64_to_float64(i); + + return res.val; +} + +int32_t __aeabi_d2iz(float64_t a) +{ + float64_u ua; + ua.val = a; + + return float64_to_int32(ua.data); +} + +int64_t __aeabi_d2lz(float64_t a) +{ + float64_u ua; + ua.val = a; + + return float64_to_int64(ua.data); +} + +uint32_t __aeabi_d2uiz(float64_t a) +{ + float64_u ua; + ua.val = a; + + return float64_to_uint32(ua.data); +} + +#endif + +#ifdef float128_t + +float128_t __floatsitf(int32_t i) +{ + float128_u res; + res.data = int32_to_float128(i); + + return res.val; +} + +float128_t __floatditf(int64_t i) +{ + float128_u res; + res.data = int64_to_float128(i); + + return res.val; +} + +float128_t __floatunsitf(uint32_t i) +{ + float128_u res; + res.data = uint32_to_float128(i); + + return res.val; +} + +float128_t __floatunditf(uint64_t i) +{ + float128_u res; + res.data = uint64_to_float128(i); + + return res.val; +} + +int32_t __fixtfsi(float128_t a) +{ + float128_u ua; + ua.val = a; + + return float128_to_int32(ua.data); +} + +int64_t __fixtfdi(float128_t a) +{ + float128_u ua; + ua.val = a; + + return float128_to_uint64(ua.data); +} + +uint32_t __fixunstfsi(float128_t a) +{ + float128_u ua; + ua.val = a; + + return float128_to_uint32(ua.data); +} + +uint64_t __fixunstfdi(float128_t a) +{ + float128_u ua; + ua.val = a; + + return float128_to_uint64(ua.data); +} + +int32_t _Qp_qtoi(float128_t *a) +{ + return __fixtfsi(*a); +} + +int64_t _Qp_qtox(float128_t *a) +{ + return __fixunstfdi(*a); +} + +uint32_t _Qp_qtoui(float128_t *a) +{ + return __fixunstfsi(*a); +} + +uint64_t _Qp_qtoux(float128_t *a) +{ + return __fixunstfdi(*a); +} + +void _Qp_itoq(float128_t *c, int32_t a) +{ + *c = __floatsitf(a); +} + +void _Qp_xtoq(float128_t *c, int64_t a) +{ + *c = __floatditf(a); +} + +void _Qp_uitoq(float128_t *c, uint32_t a) +{ + *c = __floatunsitf(a); +} + +void _Qp_uxtoq(float128_t *c, uint64_t a) +{ + *c = __floatunditf(a); +} + +#endif + +#if (defined(float32_t) && defined(float64_t)) + +float32_t __truncdfsf2(float64_t a) +{ + float64_u ua; + ua.val = a; + + float32_u res; + res.data = float64_to_float32(ua.data); + + return res.val; +} + +float64_t __extendsfdf2(float32_t a) +{ + float32_u ua; + ua.val = a; + + float64_u res; + res.data = float32_to_float64(ua.data); + + return res.val; +} + +float64_t __aeabi_f2d(float32_t a) +{ + float32_u ua; + ua.val = a; + + float64_u res; + res.data = float32_to_float64(ua.data); + + return res.val; +} + +float32_t __aeabi_d2f(float64_t a) +{ + float64_u ua; + ua.val = a; + + float32_u res; + res.data = float64_to_float32(ua.data); + + return res.val; +} + +#endif + +#if (defined(float32_t) && defined(float128_t)) + +float32_t __trunctfsf2(float128_t a) +{ + float128_u ua; + ua.val = a; + + float32_u res; + res.data = float128_to_float32(ua.data); + + return res.val; +} + +float128_t __extendsftf2(float32_t a) +{ + float32_u ua; + ua.val = a; + + float128_u res; + res.data = float32_to_float128(ua.data); + + return res.val; +} + +void _Qp_stoq(float128_t *c, float32_t a) +{ + *c = __extendsftf2(a); +} + +float32_t _Qp_qtos(float128_t *a) +{ + return __trunctfsf2(*a); +} + +#endif + +#if (defined(float64_t) && defined(float128_t)) + +float64_t __trunctfdf2(float128_t a) +{ + float128_u ua; + ua.val = a; + + float64_u res; + res.data = float128_to_float64(ua.data); + + return res.val; +} + +float128_t __extenddftf2(float64_t a) +{ + float64_u ua; + ua.val = a; + + float128_u res; + res.data = float64_to_float128(ua.data); + + return res.val; +} + +void _Qp_dtoq(float128_t *c, float64_t a) +{ + *c = __extenddftf2(a); +} + +float64_t _Qp_qtod(float128_t *a) +{ + return __trunctfdf2(*a); +} + +#endif + /** @} */ Index: uspace/lib/softfloat/conversion.h =================================================================== --- uspace/lib/softfloat/conversion.h (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ uspace/lib/softfloat/conversion.h (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -36,4 +36,6 @@ #ifndef __CONVERSION_H__ #define __CONVERSION_H__ + +#include extern float64 float32_to_float64(float32); @@ -99,4 +101,78 @@ extern float128 int64_to_float128(int64_t); +#ifdef float32_t +extern float32_t __floatsisf(int32_t); +extern float32_t __floatdisf(int64_t); +extern float32_t __floatunsisf(uint32_t); +extern float32_t __floatundisf(uint64_t); +extern int32_t __fixsfsi(float32_t); +extern int64_t __fixsfdi(float32_t); +extern uint32_t __fixunssfsi(float32_t); +extern uint64_t __fixunssfdi(float32_t); +extern int32_t __aeabi_f2iz(float32_t); +extern uint32_t __aeabi_f2uiz(float32_t); +extern float32_t __aeabi_i2f(int32_t); +extern float32_t __aeabi_l2f(int64_t); +extern float32_t __aeabi_ui2f(uint32_t); +extern float32_t __aeabi_ul2f(uint64_t); +#endif + +#ifdef float64_t +extern float64_t __floatsidf(int32_t); +extern float64_t __floatdidf(int64_t); +extern float64_t __floatunsidf(uint32_t); +extern float64_t __floatundidf(uint64_t); +extern int32_t __fixdfsi(float64_t); +extern int64_t __fixdfdi(float64_t); +extern uint32_t __fixunsdfsi(float64_t); +extern uint64_t __fixunsdfdi(float64_t); +extern float64_t __aeabi_i2d(int32_t); +extern float64_t __aeabi_ui2d(uint32_t); +extern float64_t __aeabi_l2d(int64_t); +extern int32_t __aeabi_d2iz(float64_t); +extern int64_t __aeabi_d2lz(float64_t); +extern uint32_t __aeabi_d2uiz(float64_t); +#endif + +#ifdef float128_t +extern float128_t __floatsitf(int32_t); +extern float128_t __floatditf(int64_t); +extern float128_t __floatunsitf(uint32_t); +extern float128_t __floatunditf(uint64_t); +extern int32_t __fixtfsi(float128_t); +extern int64_t __fixtfdi(float128_t); +extern uint32_t __fixunstfsi(float128_t); +extern uint64_t __fixunstfdi(float128_t); +extern int32_t _Qp_qtoi(float128_t *); +extern int64_t _Qp_qtox(float128_t *); +extern uint32_t _Qp_qtoui(float128_t *); +extern uint64_t _Qp_qtoux(float128_t *); +extern void _Qp_itoq(float128_t *, int32_t); +extern void _Qp_xtoq(float128_t *, int64_t); +extern void _Qp_uitoq(float128_t *, uint32_t); +extern void _Qp_uxtoq(float128_t *, uint64_t); +#endif + +#if (defined(float32_t) && defined(float64_t)) +extern float32_t __truncdfsf2(float64_t); +extern float64_t __extendsfdf2(float32_t); +extern float64_t __aeabi_f2d(float32_t); +extern float32_t __aeabi_d2f(float64_t); +#endif + +#if (defined(float32_t) && defined(float128_t)) +extern float32_t __trunctfsf2(float128_t); +extern float128_t __extendsftf2(float32_t); +extern void _Qp_stoq(float128_t *, float32_t); +extern float32_t _Qp_qtos(float128_t *); +#endif + +#if (defined(float64_t) && defined(float128_t)) +extern float64_t __trunctfdf2(float128_t); +extern float128_t __extenddftf2(float64_t); +extern void _Qp_dtoq(float128_t *, float64_t); +extern float64_t _Qp_qtod(float128_t *); +#endif + #endif Index: uspace/lib/softfloat/div.c =================================================================== --- uspace/lib/softfloat/div.c (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ uspace/lib/softfloat/div.c (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -34,5 +34,4 @@ */ -#include "sftypes.h" #include "add.h" #include "div.h" @@ -539,4 +538,91 @@ } +#ifdef float32_t + +float32_t __divsf3(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + float32_u res; + res.data = div_float32(ua.data, ub.data); + + return res.val; +} + +float32_t __aeabi_fdiv(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + float32_u res; + res.data = div_float32(ua.data, ub.data); + + return res.val; +} + +#endif + +#ifdef float64_t + +float64_t __divdf3(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + float64_u res; + res.data = div_float64(ua.data, ub.data); + + return res.val; +} + +float64_t __aeabi_ddiv(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + float64_u res; + res.data = div_float64(ua.data, ub.data); + + return res.val; +} + +#endif + +#ifdef float128_t + +float128_t __divtf3(float128_t a, float128_t b) +{ + float128_u ua; + ua.val = a; + + float128_u ub; + ub.val = b; + + float128_u res; + res.data = div_float128(ua.data, ub.data); + + return res.val; +} + +void _Qp_div(float128_t *c, float128_t *a, float128_t *b) +{ + *c = __divtf3(*a, *b); +} + +#endif + /** @} */ Index: uspace/lib/softfloat/div.h =================================================================== --- uspace/lib/softfloat/div.h (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ uspace/lib/softfloat/div.h (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -42,4 +42,19 @@ extern float128 div_float128(float128, float128); +#ifdef float32_t +extern float32_t __divsf3(float32_t, float32_t); +extern float32_t __aeabi_fdiv(float32_t, float32_t); +#endif + +#ifdef float64_t +extern float64_t __divdf3(float64_t, float64_t); +extern float64_t __aeabi_ddiv(float64_t, float64_t); +#endif + +#ifdef float128_t +extern float128_t __divtf3(float128_t, float128_t); +extern void _Qp_div(float128_t *, float128_t *, float128_t *); +#endif + #endif Index: uspace/lib/softfloat/mul.c =================================================================== --- uspace/lib/softfloat/mul.c (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ uspace/lib/softfloat/mul.c (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -34,5 +34,4 @@ */ -#include "sftypes.h" #include "mul.h" #include "comparison.h" @@ -62,4 +61,5 @@ return result; } + if (is_float32_signan(b)) { /* TODO: fix SigNaN */ result.parts.fraction = b.parts.fraction; @@ -67,4 +67,5 @@ return result; } + /* set NaN as result */ result.bin = FLOAT32_NAN; @@ -78,4 +79,5 @@ return result; } + result.parts.fraction = a.parts.fraction; result.parts.exp = a.parts.exp; @@ -89,4 +91,5 @@ return result; } + result.parts.fraction = b.parts.fraction; result.parts.exp = b.parts.exp; @@ -106,5 +109,5 @@ } - if (exp < 0) { + if (exp < 0) { /* FIXME: underflow */ /* return signed zero */ @@ -164,8 +167,10 @@ /* denormalized number */ frac1 >>= 1; /* denormalize */ + while ((frac1 > 0) && (exp < 0)) { frac1 >>= 1; ++exp; } + if (frac1 == 0) { /* FIXME : underflow */ @@ -175,4 +180,5 @@ } } + result.parts.exp = exp; result.parts.fraction = frac1 & ((1 << FLOAT32_FRACTION_SIZE) - 1); @@ -380,4 +386,91 @@ } +#ifdef float32_t + +float32_t __mulsf3(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + float32_u res; + res.data = mul_float32(ua.data, ub.data); + + return res.val; +} + +float32_t __aeabi_fmul(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + float32_u res; + res.data = mul_float32(ua.data, ub.data); + + return res.val; +} + +#endif + +#ifdef float64_t + +float64_t __muldf3(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + float64_u res; + res.data = mul_float64(ua.data, ub.data); + + return res.val; +} + +float64_t __aeabi_dmul(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + float64_u res; + res.data = mul_float64(ua.data, ub.data); + + return res.val; +} + +#endif + +#ifdef float128_t + +float128_t __multf3(float128_t a, float128_t b) +{ + float128_u ua; + ua.val = a; + + float128_u ub; + ub.val = b; + + float128_u res; + res.data = mul_float128(ua.data, ub.data); + + return res.val; +} + +void _Qp_mul(float128_t *c, float128_t *a, float128_t *b) +{ + *c = __multf3(*a, *b); +} + +#endif + /** @} */ Index: uspace/lib/softfloat/mul.h =================================================================== --- uspace/lib/softfloat/mul.h (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ uspace/lib/softfloat/mul.h (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -37,4 +37,6 @@ #define __MUL_H__ +#include + extern float32 mul_float32(float32, float32); extern float64 mul_float64(float64, float64); @@ -42,4 +44,19 @@ extern float128 mul_float128(float128, float128); +#ifdef float32_t +extern float32_t __mulsf3(float32_t, float32_t); +extern float32_t __aeabi_fmul(float32_t, float32_t); +#endif + +#ifdef float64_t +extern float64_t __muldf3(float64_t, float64_t); +extern float64_t __aeabi_dmul(float64_t, float64_t); +#endif + +#ifdef float128_t +extern float128_t __multf3(float128_t, float128_t); +extern void _Qp_mul(float128_t *, float128_t *, float128_t *); +#endif + #endif Index: uspace/lib/softfloat/neg.c =================================================================== --- uspace/lib/softfloat/neg.c (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) +++ uspace/lib/softfloat/neg.c (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Negation functions. + */ + +#include "neg.h" +#include "common.h" + +#ifdef float32_t + +float32_t __negsf2(float32_t a) +{ + float32_u ua; + ua.val = a; + + ua.data.parts.sign = !ua.data.parts.sign; + + return ua.val; +} + +#endif + +#ifdef float64_t + +float64_t __negdf2(float64_t a) +{ + float64_u ua; + ua.val = a; + + ua.data.parts.sign = !ua.data.parts.sign; + + return ua.val; +} + +#endif + +#ifdef float128_t + +float128_t __negtf2(float128_t a) +{ + float128_u ua; + ua.val = a; + + ua.data.parts.sign = !ua.data.parts.sign; + + return ua.val; +} + +void _Qp_neg(float128_t *c, float128_t *a) +{ + *c = __negtf2(*a); +} + +#endif + +/** @} + */ Index: uspace/lib/softfloat/neg.h =================================================================== --- uspace/lib/softfloat/neg.h (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) +++ uspace/lib/softfloat/neg.h (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2005 Josef Cejka + * Copyright (c) 2011 Petr Koupy + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * - The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** @addtogroup softfloat + * @{ + */ +/** @file Negation functions. + */ + +#ifndef __NEG_H__ +#define __NEG_H__ + +#include + +#ifdef float32_t +extern float32_t __negsf2(float32_t); +#endif + +#ifdef float64_t +extern float64_t __negdf2(float64_t); +#endif + +#ifdef float128_t +extern float128_t __negtf2(float128_t); +extern void _Qp_neg(float128_t *, float128_t *); +#endif + +#endif + +/** @} + */ Index: uspace/lib/softfloat/sftypes.h =================================================================== --- uspace/lib/softfloat/sftypes.h (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ (revision ) @@ -1,406 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Floating point types and constants. - */ - -#ifndef SOFTFLOAT_SFTYPES_H__ -#define SOFTFLOAT_SFTYPES_H__ - -#include - -#if defined(INT_SIZE_8) - -#define _to_int _to_int8 -#define from_int int8 - -#elif defined(INT_SIZE_16) - -#define _to_int _to_int16 -#define from_int int16 - -#elif defined(INT_SIZE_32) - -#define _to_int _to_int32 -#define from_int int32 - -#elif defined(INT_SIZE_64) - -#define _to_int _to_int64 -#define from_int int64 - -#endif - - -#if defined(UINT_SIZE_8) - -#define _to_uint _to_uint8 -#define from_uint uint8 - -#elif defined(UINT_SIZE_16) - -#define _to_uint _to_uint16 -#define from_uint uint16 - -#elif defined(UINT_SIZE_32) - -#define _to_uint _to_uint32 -#define from_uint uint32 - -#elif defined(UINT_SIZE_64) - -#define _to_uint _to_uint64 -#define from_uint uint64 - -#endif - - -#if defined(LONG_SIZE_8) - -#define _to_long _to_int8 -#define from_long int8 - -#elif defined(LONG_SIZE_16) - -#define _to_long _to_int16 -#define from_long int16 - -#elif defined(LONG_SIZE_32) - -#define _to_long _to_int32 -#define from_long int32 - -#elif defined(LONG_SIZE_64) - -#define _to_long _to_int64 -#define from_long int64 - -#endif - - -#if defined(ULONG_SIZE_8) - -#define _to_ulong _to_uint8 -#define from_ulong uint8 - -#elif defined(ULONG_SIZE_16) - -#define _to_ulong _to_uint16 -#define from_ulong uint16 - -#elif defined(ULONG_SIZE_32) - -#define _to_ulong _to_uint32 -#define from_ulong uint32 - -#elif defined(ULONG_SIZE_64) - -#define _to_ulong _to_uint64 -#define from_ulong uint64 - -#endif - - -#if defined(LLONG_SIZE_8) - -#define _to_llong _to_int8 -#define from_llong int8 - -#elif defined(LLONG_SIZE_16) - -#define _to_llong _to_int16 -#define from_llong int16 - -#elif defined(LLONG_SIZE_32) - -#define _to_llong _to_int32 -#define from_llong int32 - -#elif defined(LLONG_SIZE_64) - -#define _to_llong _to_int64 -#define from_llong int64 - -#endif - - -#if defined(ULLONG_SIZE_8) - -#define _to_ullong _to_uint8 -#define from_ullong uint8 - -#elif defined(ULLONG_SIZE_16) - -#define _to_ullong _to_uint16 -#define from_ullong uint16 - -#elif defined(ULLONG_SIZE_32) - -#define _to_ullong _to_uint32 -#define from_ullong uint32 - -#elif defined(ULLONG_SIZE_64) - -#define _to_ullong _to_uint64 -#define from_ullong uint64 - -#endif - - -#if defined(FLOAT_SIZE_32) - -#define add_float add_float32 -#define sub_float sub_float32 -#define mul_float mul_float32 -#define div_float div_float32 -#define _to_float _to_float32 -#define from_float float32 -#define is_float_nan is_float32_nan -#define is_float_eq is_float32_eq -#define is_float_lt is_float32_lt -#define is_float_gt is_float32_gt - -#elif defined(FLOAT_SIZE_64) - -#define add_float add_float64 -#define sub_float sub_float64 -#define mul_float mul_float64 -#define div_float div_float64 -#define _to_float _to_float64 -#define from_float float64 -#define is_float_nan is_float64_nan -#define is_float_eq is_float64_eq -#define is_float_lt is_float64_lt -#define is_float_gt is_float64_gt - -#elif defined(FLOAT_SIZE_96) - -#define add_float add_float96 -#define sub_float sub_float96 -#define mul_float mul_float96 -#define div_float div_float96 -#define _to_float _to_float96 -#define from_float float96 -#define is_float_nan is_float96_nan -#define is_float_eq is_float96_eq -#define is_float_lt is_float96_lt -#define is_float_gt is_float96_gt - -#elif defined(FLOAT_SIZE_128) - -#define add_float add_float128 -#define sub_float sub_float128 -#define mul_float mul_float128 -#define div_float div_float128 -#define _to_float _to_float128 -#define from_float float128 -#define is_float_nan is_float128_nan -#define is_float_eq is_float128_eq -#define is_float_lt is_float128_lt -#define is_float_gt is_float128_gt - -#endif - - -#if defined(DOUBLE_SIZE_32) - -#define add_double add_float32 -#define sub_double sub_float32 -#define mul_double mul_float32 -#define div_double div_float32 -#define _to_double _to_float32 -#define from_double float32 -#define is_double_nan is_float32_nan -#define is_double_eq is_float32_eq -#define is_double_lt is_float32_lt -#define is_double_gt is_float32_gt - -#elif defined(DOUBLE_SIZE_64) - -#define add_double add_float64 -#define sub_double sub_float64 -#define mul_double mul_float64 -#define div_double div_float64 -#define _to_double _to_float64 -#define from_double float64 -#define is_double_nan is_float64_nan -#define is_double_eq is_float64_eq -#define is_double_lt is_float64_lt -#define is_double_gt is_float64_gt - -#elif defined(DOUBLE_SIZE_96) - -#define add_double add_float96 -#define sub_double sub_float96 -#define mul_double mul_float96 -#define div_double div_float96 -#define _to_double _to_float96 -#define from_double float96 -#define is_double_nan is_float96_nan -#define is_double_eq is_float96_eq -#define is_double_lt is_float96_lt -#define is_double_gt is_float96_gt - -#elif defined(DOUBLE_SIZE_128) - -#define add_double add_float128 -#define sub_double sub_float128 -#define mul_double mul_float128 -#define div_double div_float128 -#define _to_double _to_float128 -#define from_double float128 -#define is_double_nan is_float128_nan -#define is_double_eq is_float128_eq -#define is_double_lt is_float128_lt -#define is_double_gt is_float128_gt - -#endif - - -#if defined(LONG_DOUBLE_SIZE_32) - -#define add_long_double add_float32 -#define sub_long_double sub_float32 -#define mul_long_double mul_float32 -#define div_long_double div_float32 -#define _to_long_double _to_float32 -#define from_long_double float32 -#define is_long_double_nan is_float32_nan -#define is_long_double_eq is_float32_eq -#define is_long_double_lt is_float32_lt -#define is_long_double_gt is_float32_gt - -#elif defined(LONG_DOUBLE_SIZE_64) - -#define add_long_double add_float64 -#define sub_long_double sub_float64 -#define mul_long_double mul_float64 -#define div_long_double div_float64 -#define _to_long_double _to_float64 -#define from_long_double float64 -#define is_long_double_nan is_float64_nan -#define is_long_double_eq is_float64_eq -#define is_long_double_lt is_float64_lt -#define is_long_double_gt is_float64_gt - -#elif defined(LONG_DOUBLE_SIZE_96) - -#define add_long_double add_float96 -#define sub_long_double sub_float96 -#define mul_long_double mul_float96 -#define div_long_double div_float96 -#define _to_long_double _to_float96 -#define from_long_double float96 -#define is_long_double_nan is_float96_nan -#define is_long_double_eq is_float96_eq -#define is_long_double_lt is_float96_lt -#define is_long_double_gt is_float96_gt - -#elif defined(LONG_DOUBLE_SIZE_128) - -#define add_long_double add_float128 -#define sub_long_double sub_float128 -#define mul_long_double mul_float128 -#define div_long_double div_float128 -#define _to_long_double _to_float128 -#define from_long_double float128 -#define is_long_double_nan is_float128_nan -#define is_long_double_eq is_float128_eq -#define is_long_double_lt is_float128_lt -#define is_long_double_gt is_float128_gt - -#endif - - -#define CONCAT(a, b) CONCAT_ARGS(a, b) -#define CONCAT_ARGS(a, b) a ## b - -#define float32_to_float32(arg) (arg) -#define float64_to_float64(arg) (arg) -#define float96_to_float96(arg) (arg) -#define float128_to_float128(arg) (arg) - -#define float_to_double CONCAT(from_float, _to_double) -#define float_to_long_double CONCAT(from_float, _to_long_double) -#define float_to_int CONCAT(from_float, _to_int) -#define float_to_uint CONCAT(from_float, _to_uint) -#define float_to_long CONCAT(from_float, _to_long) -#define float_to_ulong CONCAT(from_float, _to_ulong) -#define float_to_llong CONCAT(from_float, _to_llong) -#define float_to_ullong CONCAT(from_float, _to_ullong) - -#define double_to_float CONCAT(from_double, _to_float) -#define double_to_long_double CONCAT(from_double, _to_long_double) -#define double_to_int CONCAT(from_double, _to_int) -#define double_to_uint CONCAT(from_double, _to_uint) -#define double_to_long CONCAT(from_double, _to_long) -#define double_to_ulong CONCAT(from_double, _to_ulong) -#define double_to_llong CONCAT(from_double, _to_llong) -#define double_to_ullong CONCAT(from_double, _to_ullong) - -#define long_double_to_float CONCAT(from_long_double, _to_float) -#define long_double_to_double CONCAT(from_long_double, _to_double) -#define long_double_to_int CONCAT(from_long_double, _to_int) -#define long_double_to_uint CONCAT(from_long_double, _to_uint) -#define long_double_to_long CONCAT(from_long_double, _to_long) -#define long_double_to_ulong CONCAT(from_long_double, _to_ulong) -#define long_double_to_llong CONCAT(from_long_double, _to_llong) -#define long_double_to_ullong CONCAT(from_long_double, _to_ullong) - -#define int_to_float CONCAT(from_int, _to_float) -#define int_to_double CONCAT(from_int, _to_double) -#define int_to_long_double CONCAT(from_int, _to_long_double) - -#define uint_to_float CONCAT(from_uint, _to_float) -#define uint_to_double CONCAT(from_uint, _to_double) -#define uint_to_long_double CONCAT(from_uint, _to_long_double) - -#define long_to_float CONCAT(from_long, _to_float) -#define long_to_double CONCAT(from_long, _to_double) -#define long_to_long_double CONCAT(from_long, _to_long_double) - -#define ulong_to_float CONCAT(from_ulong, _to_float) -#define ulong_to_double CONCAT(from_ulong, _to_double) -#define ulong_to_long_double CONCAT(from_ulong, _to_long_double) - -#define llong_to_float CONCAT(from_llong, _to_float) -#define llong_to_double CONCAT(from_llong, _to_double) -#define llong_to_long_double CONCAT(from_llong, _to_long_double) - -#define ullong_to_float CONCAT(from_ullong, _to_float) -#define ullong_to_double CONCAT(from_ullong, _to_double) -#define ullong_to_long_double CONCAT(from_ullong, _to_long_double) - -#endif - -/** @} - */ Index: uspace/lib/softfloat/softfloat.c =================================================================== --- uspace/lib/softfloat/softfloat.c (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ (revision ) @@ -1,1423 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat generic - * @ingroup sfl - * @brief Architecture independent parts of FPU software emulation library. - * @{ - */ -/** @file Softfloat API. - */ - -#include "softfloat.h" -#include "sftypes.h" -#include "add.h" -#include "sub.h" -#include "mul.h" -#include "div.h" -#include "conversion.h" -#include "comparison.h" - -/* Arithmetic functions */ - -float __addsf3(float a, float b) -{ - float_t fa; - float_t fb; - float_t res; - - fa.val = a; - fb.val = b; - - if (fa.data.parts.sign != fb.data.parts.sign) { - if (fa.data.parts.sign) { - fa.data.parts.sign = 0; - res.data = sub_float(fb.data, fa.data); - - return res.val; - } - - fb.data.parts.sign = 0; - res.data = sub_float(fa.data, fb.data); - - return res.val; - } - - res.data = add_float(fa.data, fb.data); - return res.val; -} - -double __adddf3(double a, double b) -{ - double_t da; - double_t db; - double_t res; - - da.val = a; - db.val = b; - - if (da.data.parts.sign != db.data.parts.sign) { - if (da.data.parts.sign) { - da.data.parts.sign = 0; - res.data = sub_double(db.data, da.data); - - return res.val; - } - - db.data.parts.sign = 0; - res.data = sub_double(da.data, db.data); - - return res.val; - } - - res.data = add_double(da.data, db.data); - return res.val; -} - -long double __addtf3(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - long_double_t res; - - ta.val = a; - tb.val = b; - - if (ta.data.parts.sign != tb.data.parts.sign) { - if (ta.data.parts.sign) { - ta.data.parts.sign = 0; - res.data = sub_long_double(tb.data, ta.data); - - return res.val; - } - - tb.data.parts.sign = 0; - res.data = sub_long_double(ta.data, tb.data); - - return res.val; - } - - res.data = add_long_double(ta.data, tb.data); - return res.val; -} - -float __subsf3(float a, float b) -{ - float_t fa; - float_t fb; - float_t res; - - fa.val = a; - fb.val = b; - - if (fa.data.parts.sign != fb.data.parts.sign) { - fb.data.parts.sign = !fb.data.parts.sign; - res.data = add_float(fa.data, fb.data); - - return res.val; - } - - res.data = sub_float(fa.data, fb.data); - return res.val; -} - -double __subdf3(double a, double b) -{ - double_t da; - double_t db; - double_t res; - - da.val = a; - db.val = b; - - if (da.data.parts.sign != db.data.parts.sign) { - db.data.parts.sign = !db.data.parts.sign; - res.data = add_double(da.data, db.data); - - return res.val; - } - - res.data = sub_double(da.data, db.data); - return res.val; -} - -long double __subtf3(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - long_double_t res; - - ta.val = a; - tb.val = b; - - if (ta.data.parts.sign != tb.data.parts.sign) { - tb.data.parts.sign = !tb.data.parts.sign; - res.data = add_long_double(ta.data, tb.data); - - return res.val; - } - - res.data = sub_long_double(ta.data, tb.data); - return res.val; -} - -float __mulsf3(float a, float b) -{ - float_t fa; - float_t fb; - float_t res; - - fa.val = a; - fb.val = b; - - res.data = mul_float(fa.data, fb.data); - return res.val; -} - -double __muldf3(double a, double b) -{ - double_t da; - double_t db; - double_t res; - - da.val = a; - db.val = b; - - res.data = mul_double(da.data, db.data); - return res.val; -} - -long double __multf3(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - long_double_t res; - - ta.val = a; - tb.val = b; - - res.data = mul_long_double(ta.data, tb.data); - return res.val; -} - -float __divsf3(float a, float b) -{ - float_t fa; - float_t fb; - float_t res; - - fa.val = a; - fb.val = b; - - res.data = div_float(fa.data, fb.data); - return res.val; -} - -double __divdf3(double a, double b) -{ - double_t da; - double_t db; - double_t res; - - da.val = a; - db.val = b; - - res.data = div_double(da.data, db.data); - return res.val; -} - -long double __divtf3(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - long_double_t res; - - ta.val = a; - tb.val = b; - - res.data = div_long_double(ta.data, tb.data); - return res.val; -} - -float __negsf2(float a) -{ - float_t fa; - - fa.val = a; - fa.data.parts.sign = !fa.data.parts.sign; - - return fa.val; -} - -double __negdf2(double a) -{ - double_t da; - - da.val = a; - da.data.parts.sign = !da.data.parts.sign; - - return da.val; -} - -long double __negtf2(long double a) -{ - long_double_t ta; - - ta.val = a; - ta.data.parts.sign = !ta.data.parts.sign; - - return ta.val; -} - -/* Conversion functions */ - -double __extendsfdf2(float a) -{ - float_t fa; - double_t res; - - fa.val = a; - res.data = float_to_double(fa.data); - - return res.val; -} - -long double __extendsftf2(float a) -{ - float_t fa; - long_double_t res; - - fa.val = a; - res.data = float_to_long_double(fa.data); - - return res.val; -} - -long double __extenddftf2(double a) -{ - double_t da; - long_double_t res; - - da.val = a; - res.data = double_to_long_double(da.data); - - return res.val; -} - -float __truncdfsf2(double a) -{ - double_t da; - float_t res; - - da.val = a; - res.data = double_to_float(da.data); - - return res.val; -} - -float __trunctfsf2(long double a) -{ - long_double_t ta; - float_t res; - - ta.val = a; - res.data = long_double_to_float(ta.data); - - return res.val; -} - -double __trunctfdf2(long double a) -{ - long_double_t ta; - double_t res; - - ta.val = a; - res.data = long_double_to_double(ta.data); - - return res.val; -} - -int __fixsfsi(float a) -{ - float_t fa; - - fa.val = a; - return float_to_int(fa.data); -} - -int __fixdfsi(double a) -{ - double_t da; - - da.val = a; - return double_to_int(da.data); -} - -int __fixtfsi(long double a) -{ - long_double_t ta; - - ta.val = a; - return long_double_to_int(ta.data); -} - -long __fixsfdi(float a) -{ - float_t fa; - - fa.val = a; - return float_to_long(fa.data); -} - -long __fixdfdi(double a) -{ - double_t da; - - da.val = a; - return double_to_long(da.data); -} - -long __fixtfdi(long double a) -{ - long_double_t ta; - - ta.val = a; - return long_double_to_long(ta.data); -} - -long long __fixsfti(float a) -{ - float_t fa; - - fa.val = a; - return float_to_llong(fa.data); -} - -long long __fixdfti(double a) -{ - double_t da; - - da.val = a; - return double_to_llong(da.data); -} - -long long __fixtfti(long double a) -{ - long_double_t ta; - - ta.val = a; - return long_double_to_llong(ta.data); -} - -unsigned int __fixunssfsi(float a) -{ - float_t fa; - - fa.val = a; - return float_to_uint(fa.data); -} - -unsigned int __fixunsdfsi(double a) -{ - double_t da; - - da.val = a; - return double_to_uint(da.data); -} - -unsigned int __fixunstfsi(long double a) -{ - long_double_t ta; - - ta.val = a; - return long_double_to_uint(ta.data); -} - -unsigned long __fixunssfdi(float a) -{ - float_t fa; - - fa.val = a; - return float_to_ulong(fa.data); -} - -unsigned long __fixunsdfdi(double a) -{ - double_t da; - - da.val = a; - return double_to_ulong(da.data); -} - -unsigned long __fixunstfdi(long double a) -{ - long_double_t ta; - - ta.val = a; - return long_double_to_ulong(ta.data); -} - -unsigned long long __fixunssfti(float a) -{ - float_t fa; - - fa.val = a; - return float_to_ullong(fa.data); -} - -unsigned long long __fixunsdfti(double a) -{ - double_t da; - - da.val = a; - return double_to_ullong(da.data); -} - -unsigned long long __fixunstfti(long double a) -{ - long_double_t ta; - - ta.val = a; - return long_double_to_ullong(ta.data); -} - -float __floatsisf(int i) -{ - float_t res; - - res.data = int_to_float(i); - return res.val; -} - -double __floatsidf(int i) -{ - double_t res; - - res.data = int_to_double(i); - return res.val; -} - -long double __floatsitf(int i) -{ - long_double_t res; - - res.data = int_to_long_double(i); - return res.val; -} - -float __floatdisf(long i) -{ - float_t res; - - res.data = long_to_float(i); - return res.val; -} - -double __floatdidf(long i) -{ - double_t res; - - res.data = long_to_double(i); - return res.val; -} - -long double __floatditf(long i) -{ - long_double_t res; - - res.data = long_to_long_double(i); - return res.val; -} - -float __floattisf(long long i) -{ - float_t res; - - res.data = llong_to_float(i); - return res.val; -} - -double __floattidf(long long i) -{ - double_t res; - - res.data = llong_to_double(i); - return res.val; -} - -long double __floattitf(long long i) -{ - long_double_t res; - - res.data = llong_to_long_double(i); - return res.val; -} - -float __floatunsisf(unsigned int i) -{ - float_t res; - - res.data = uint_to_float(i); - return res.val; -} - -double __floatunsidf(unsigned int i) -{ - double_t res; - - res.data = uint_to_double(i); - return res.val; -} - -long double __floatunsitf(unsigned int i) -{ - long_double_t res; - - res.data = uint_to_long_double(i); - return res.val; -} - -float __floatundisf(unsigned long i) -{ - float_t res; - - res.data = ulong_to_float(i); - return res.val; -} - -double __floatundidf(unsigned long i) -{ - double_t res; - - res.data = ulong_to_double(i); - return res.val; -} - -long double __floatunditf(unsigned long i) -{ - long_double_t res; - - res.data = ulong_to_long_double(i); - return res.val; -} - -float __floatuntisf(unsigned long long i) -{ - float_t res; - - res.data = ullong_to_float(i); - return res.val; -} - -double __floatuntidf(unsigned long long i) -{ - double_t res; - - res.data = ullong_to_double(i); - return res.val; -} - -long double __floatuntitf(unsigned long long i) -{ - long_double_t res; - - res.data = ullong_to_long_double(i); - return res.val; -} - -/* Comparison functions */ - -int __cmpsf2(float a, float b) -{ - float_t fa; - float_t fb; - - fa.val = a; - fb.val = b; - - if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { - /* no special constant for unordered - maybe signaled? */ - return 1; - } - - if (is_float_eq(fa.data, fb.data)) - return 0; - - if (is_float_lt(fa.data, fb.data)) - return -1; - - return 1; -} - -int __cmpdf2(double a, double b) -{ - double_t da; - double_t db; - - da.val = a; - db.val = b; - - if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { - /* no special constant for unordered - maybe signaled? */ - return 1; - } - - if (is_double_eq(da.data, db.data)) - return 0; - - if (is_double_lt(da.data, db.data)) - return -1; - - return 1; -} - -int __cmptf2(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = a; - tb.val = b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { - /* no special constant for unordered - maybe signaled? */ - return 1; - } - - if (is_long_double_eq(ta.data, tb.data)) - return 0; - - if (is_long_double_lt(ta.data, tb.data)) - return -1; - - return 1; -} - -int __unordsf2(float a, float b) -{ - float_t fa; - float_t fb; - - fa.val = a; - fb.val = b; - - return ((is_float_nan(fa.data)) || (is_float_nan(fb.data))); -} - -int __unorddf2(double a, double b) -{ - double_t da; - double_t db; - - da.val = a; - db.val = b; - - return ((is_double_nan(da.data)) || (is_double_nan(db.data))); -} - -int __unordtf2(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = a; - tb.val = b; - - return ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))); -} - -int __eqsf2(float a, float b) -{ - float_t fa; - float_t fb; - - fa.val = a; - fb.val = b; - - if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { - // TODO: sigNaNs - return 1; - } - - return is_float_eq(fa.data, fb.data) - 1; -} - -int __eqdf2(double a, double b) -{ - double_t da; - double_t db; - - da.val = a; - db.val = b; - - if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { - // TODO: sigNaNs - return 1; - } - - return is_double_eq(da.data, db.data) - 1; -} - -int __eqtf2(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = a; - tb.val = b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { - // TODO: sigNaNs - return 1; - } - - return is_long_double_eq(ta.data, tb.data) - 1; -} - -int __nesf2(float a, float b) -{ - /* strange behavior, but it was in gcc documentation */ - return __eqsf2(a, b); -} - -int __nedf2(double a, double b) -{ - /* strange behavior, but it was in gcc documentation */ - return __eqdf2(a, b); -} - -int __netf2(long double a, long double b) -{ - /* strange behavior, but it was in gcc documentation */ - return __eqtf2(a, b); -} - -int __gesf2(float a, float b) -{ - float_t fa; - float_t fb; - - fa.val = a; - fb.val = b; - - if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { - // TODO: sigNaNs - return -1; - } - - if (is_float_eq(fa.data, fb.data)) - return 0; - - if (is_float_gt(fa.data, fb.data)) - return 1; - - return -1; -} - -int __gedf2(double a, double b) -{ - double_t da; - double_t db; - - da.val = a; - db.val = b; - - if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { - // TODO: sigNaNs - return -1; - } - - if (is_double_eq(da.data, db.data)) - return 0; - - if (is_double_gt(da.data, db.data)) - return 1; - - return -1; -} - -int __getf2(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = a; - tb.val = b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { - // TODO: sigNaNs - return -1; - } - - if (is_long_double_eq(ta.data, tb.data)) - return 0; - - if (is_long_double_gt(ta.data, tb.data)) - return 1; - - return -1; -} - -int __ltsf2(float a, float b) -{ - float_t fa; - float_t fb; - - fa.val = a; - fb.val = b; - - if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { - // TODO: sigNaNs - return 1; - } - - if (is_float_lt(fa.data, fb.data)) - return -1; - - return 0; -} - -int __ltdf2(double a, double b) -{ - double_t da; - double_t db; - - da.val = a; - db.val = b; - - if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { - // TODO: sigNaNs - return 1; - } - - if (is_double_lt(da.data, db.data)) - return -1; - - return 0; -} - -int __lttf2(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = a; - tb.val = b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { - // TODO: sigNaNs - return 1; - } - - if (is_long_double_lt(ta.data, tb.data)) - return -1; - - return 0; -} - -int __lesf2(float a, float b) -{ - float_t fa; - float_t fb; - - fa.val = a; - fb.val = b; - - if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { - // TODO: sigNaNs - return 1; - } - - if (is_float_eq(fa.data, fb.data)) - return 0; - - if (is_float_lt(fa.data, fb.data)) - return -1; - - return 1; -} - -int __ledf2(double a, double b) -{ - double_t da; - double_t db; - - da.val = a; - db.val = b; - - if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { - // TODO: sigNaNs - return 1; - } - - if (is_double_eq(da.data, db.data)) - return 0; - - if (is_double_lt(da.data, db.data)) - return -1; - - return 1; -} - -int __letf2(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = a; - tb.val = b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { - // TODO: sigNaNs - return 1; - } - - if (is_long_double_eq(ta.data, tb.data)) - return 0; - - if (is_long_double_lt(ta.data, tb.data)) - return -1; - - return 1; -} - -int __gtsf2(float a, float b) -{ - float_t fa; - float_t fb; - - fa.val = a; - fb.val = b; - - if ((is_float_nan(fa.data)) || (is_float_nan(fb.data))) { - // TODO: sigNaNs - return -1; - } - - if (is_float_gt(fa.data, fb.data)) - return 1; - - return 0; -} - -int __gtdf2(double a, double b) -{ - double_t da; - double_t db; - - da.val = a; - db.val = b; - - if ((is_double_nan(da.data)) || (is_double_nan(db.data))) { - // TODO: sigNaNs - return -1; - } - - if (is_double_gt(da.data, db.data)) - return 1; - - return 0; -} - -int __gttf2(long double a, long double b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = a; - tb.val = b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) { - // TODO: sigNaNs - return -1; - } - - if (is_long_double_gt(ta.data, tb.data)) - return 1; - - return 0; -} - -/* SPARC quadruple-precision wrappers */ - -void _Qp_add(long double *c, long double *a, long double *b) -{ - *c = __addtf3(*a, *b); -} - -void _Qp_sub(long double *c, long double *a, long double *b) -{ - *c = __subtf3(*a, *b); -} - -void _Qp_mul(long double *c, long double *a, long double *b) -{ - *c = __multf3(*a, *b); -} - -void _Qp_div(long double *c, long double *a, long double *b) -{ - *c = __divtf3(*a, *b); -} - -void _Qp_neg(long double *c, long double *a) -{ - *c = __negtf2(*a); -} - -void _Qp_stoq(long double *c, float a) -{ - *c = __extendsftf2(a); -} - -void _Qp_dtoq(long double *c, double a) -{ - *c = __extenddftf2(a); -} - -float _Qp_qtos(long double *a) -{ - return __trunctfsf2(*a); -} - -double _Qp_qtod(long double *a) -{ - return __trunctfdf2(*a); -} - -int _Qp_qtoi(long double *a) -{ - return __fixtfsi(*a); -} - -unsigned int _Qp_qtoui(long double *a) -{ - return __fixunstfsi(*a); -} - -long _Qp_qtox(long double *a) -{ - return __fixtfdi(*a); -} - -unsigned long _Qp_qtoux(long double *a) -{ - return __fixunstfdi(*a); -} - -void _Qp_itoq(long double *c, int a) -{ - *c = __floatsitf(a); -} - -void _Qp_uitoq(long double *c, unsigned int a) -{ - *c = __floatunsitf(a); -} - -void _Qp_xtoq(long double *c, long a) -{ - *c = __floatditf(a); -} - -void _Qp_uxtoq(long double *c, unsigned long a) -{ - *c = __floatunditf(a); -} - -int _Qp_cmp(long double *a, long double *b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = *a; - tb.val = *b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) - return 3; - - if (is_long_double_eq(ta.data, tb.data)) - return 0; - - if (is_long_double_lt(ta.data, tb.data)) - return 1; - - return 2; -} - -int _Qp_cmpe(long double *a, long double *b) -{ - /* strange, but is defined this way in SPARC Compliance Definition */ - return _Qp_cmp(a, b); -} - -int _Qp_feq(long double *a, long double *b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = *a; - tb.val = *b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) - return 0; - - return is_long_double_eq(ta.data, tb.data); -} - -int _Qp_fge(long double *a, long double *b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = *a; - tb.val = *b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) - return 0; - - return is_long_double_eq(ta.data, tb.data) || - is_long_double_gt(ta.data, tb.data); -} - -int _Qp_fgt(long double *a, long double *b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = *a; - tb.val = *b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) - return 0; - - return is_long_double_gt(ta.data, tb.data); -} - -int _Qp_fle(long double*a, long double *b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = *a; - tb.val = *b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) - return 0; - - return is_long_double_eq(ta.data, tb.data) || - is_long_double_lt(ta.data, tb.data); -} - -int _Qp_flt(long double *a, long double *b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = *a; - tb.val = *b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) - return 0; - - return is_long_double_lt(ta.data, tb.data); -} - -int _Qp_fne(long double *a, long double *b) -{ - long_double_t ta; - long_double_t tb; - - ta.val = *a; - tb.val = *b; - - if ((is_long_double_nan(ta.data)) || (is_long_double_nan(tb.data))) - return 0; - - return !is_long_double_eq(ta.data, tb.data); -} - -float __aeabi_d2f(double a) -{ - return __truncdfsf2(a); -} - -double __aeabi_f2d(float a) -{ - return __extendsfdf2(a); -} - - -float __aeabi_i2f(int i) -{ - return __floatsisf(i); -} - -float __aeabi_ui2f(int i) -{ - return __floatunsisf(i); -} - -double __aeabi_i2d(int i) -{ - return __floatsidf(i); -} - -double __aeabi_ui2d(unsigned int i) -{ - return __floatunsidf(i); -} - -double __aeabi_l2d(long long i) -{ - return __floattidf(i); -} - -float __aeabi_l2f(long long i) -{ - return __floattisf(i); -} - -float __aeabi_ul2f(unsigned long long u) -{ - return __floatuntisf(u); -} - -int __aeabi_f2iz(float a) -{ - return __fixsfsi(a); -} - -int __aeabi_f2uiz(float a) -{ - return __fixunssfsi(a); -} - -int __aeabi_d2iz(double a) -{ - return __fixdfsi(a); -} - -unsigned int __aeabi_d2uiz(double a) -{ - return __fixunsdfsi(a); -} - -long long __aeabi_d2lz(double a) -{ - return __fixdfti(a); -} - -int __aeabi_fcmpge(float a, float b) -{ - return __gesf2(a, b); -} - -int __aeabi_fcmpgt(float a, float b) -{ - return __gtsf2(a, b); -} - -int __aeabi_fcmplt(float a, float b) -{ - return __ltsf2(a, b); -} - -int __aeabi_fcmpeq(float a, float b) -{ - return __eqsf2(a, b); -} - -int __aeabi_dcmpge(double a, double b) -{ - return __gedf2(a, b); -} - -int __aeabi_dcmpgt(double a, double b) -{ - return __gtdf2(a, b); -} - -int __aeabi_dcmplt(double a, double b) -{ - return __ltdf2(a, b); -} - -int __aeabi_dcmple(double a, double b) -{ - return __ledf2(a, b); -} - -int __aeabi_dcmpeq(double a, double b) -{ - return __eqdf2(a, b); -} - -float __aeabi_fadd(float a, float b) -{ - return __addsf3(a, b); -} - -float __aeabi_fsub(float a, float b) -{ - return __subsf3(a, b); -} - -float __aeabi_fmul(float a, float b) -{ - return __mulsf3(a, b); -} - -float __aeabi_fdiv(float a, float b) -{ - return __divsf3(a, b); -} - -double __aeabi_dadd(double a, double b) -{ - return __adddf3(a, b); -} - -double __aeabi_dsub(double a, double b) -{ - return __subdf3(a, b); -} - -double __aeabi_dmul(double a, double b) -{ - return __muldf3(a, b); -} - -double __aeabi_ddiv(double a, double b) -{ - return __divdf3(a, b); -} - -/** @} - */ Index: uspace/lib/softfloat/softfloat.h =================================================================== --- uspace/lib/softfloat/softfloat.h (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ (revision ) @@ -1,249 +1,0 @@ -/* - * Copyright (c) 2005 Josef Cejka - * Copyright (c) 2011 Petr Koupy - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY - * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** @addtogroup softfloat - * @{ - */ -/** @file Softfloat API. - */ - -#ifndef __SOFTFLOAT_H__ -#define __SOFTFLOAT_H__ - -extern float __addsf3(float, float); -extern double __adddf3(double, double); -extern long double __addtf3(long double, long double); -extern long double __addxf3(long double, long double); - -extern float __subsf3(float, float); -extern double __subdf3(double, double); -extern long double __subtf3(long double, long double); -extern long double __subxf3(long double, long double); - -extern float __mulsf3(float, float); -extern double __muldf3(double, double); -extern long double __multf3(long double, long double); -extern long double __mulxf3(long double, long double); - -extern float __divsf3(float, float); -extern double __divdf3(double, double); -extern long double __divtf3(long double, long double); -extern long double __divxf3(long double, long double); - -extern float __negsf2(float); -extern double __negdf2(double); -extern long double __negtf2(long double); -extern long double __negxf2(long double); - -extern double __extendsfdf2(float); -extern long double __extendsftf2(float); -extern long double __extendsfxf2(float); -extern long double __extenddftf2(double); -extern long double __extenddfxf2(double); - -extern double __truncxfdf2(long double); -extern double __trunctfdf2(long double); -extern float __truncxfsf2(long double); -extern float __trunctfsf2(long double); -extern float __truncdfsf2(double); - -extern int __fixsfsi(float); -extern int __fixdfsi(double); -extern int __fixtfsi(long double); -extern int __fixxfsi(long double); - -extern long __fixsfdi(float); -extern long __fixdfdi(double); -extern long __fixtfdi(long double); -extern long __fixxfdi(long double); - -extern long long __fixsfti(float); -extern long long __fixdfti(double); -extern long long __fixtfti(long double); -extern long long __fixxfti(long double); - -extern unsigned int __fixunssfsi(float); -extern unsigned int __fixunsdfsi(double); -extern unsigned int __fixunstfsi(long double); -extern unsigned int __fixunsxfsi(long double); - -extern unsigned long __fixunssfdi(float); -extern unsigned long __fixunsdfdi(double); -extern unsigned long __fixunstfdi(long double); -extern unsigned long __fixunsxfdi(long double); - -extern unsigned long long __fixunssfti(float); -extern unsigned long long __fixunsdfti(double); -extern unsigned long long __fixunstfti(long double); -extern unsigned long long __fixunsxfti(long double); - -extern float __floatsisf(int); -extern double __floatsidf(int); -extern long double __floatsitf(int); -extern long double __floatsixf(int); - -extern float __floatdisf(long); -extern double __floatdidf(long); -extern long double __floatditf(long); -extern long double __floatdixf(long); - -extern float __floattisf(long long); -extern double __floattidf(long long); -extern long double __floattitf(long long); -extern long double __floattixf(long long); - -extern float __floatunsisf(unsigned int); -extern double __floatunsidf(unsigned int); -extern long double __floatunsitf(unsigned int); -extern long double __floatunsixf(unsigned int); - -extern float __floatundisf(unsigned long); -extern double __floatundidf(unsigned long); -extern long double __floatunditf(unsigned long); -extern long double __floatundixf(unsigned long); - -extern float __floatuntisf(unsigned long long); -extern double __floatuntidf(unsigned long long); -extern long double __floatuntitf(unsigned long long); -extern long double __floatuntixf(unsigned long long); - -extern int __cmpsf2(float, float); -extern int __cmpdf2(double, double); -extern int __cmptf2(long double, long double); - -extern int __unordsf2(float, float); -extern int __unorddf2(double, double); -extern int __unordtf2(long double, long double); - -extern int __eqsf2(float, float); -extern int __eqdf2(double, double); -extern int __eqtf2(long double, long double); - -extern int __nesf2(float, float); -extern int __nedf2(double, double); -extern int __netf2(long double, long double); - -extern int __gesf2(float, float); -extern int __gedf2(double, double); -extern int __getf2(long double, long double); - -extern int __ltsf2(float, float); -extern int __ltdf2(double, double); -extern int __lttf2(long double, long double); - -extern int __lesf2(float, float); -extern int __ledf2(double, double); -extern int __letf2(long double, long double); - -extern int __gtsf2(float, float); -extern int __gtdf2(double, double); -extern int __gttf2(long double, long double); - -/* Not implemented yet */ -extern float __powisf2(float, int); -extern double __powidf2 (double, int); -extern long double __powitf2(long double, int); -extern long double __powixf2(long double, int); - -/* SPARC quadruple-precision wrappers */ -extern void _Qp_add(long double *, long double *, long double *); -extern void _Qp_sub(long double *, long double *, long double *); -extern void _Qp_mul(long double *, long double *, long double *); -extern void _Qp_div(long double *, long double *, long double *); -extern void _Qp_neg(long double *, long double *); - -extern void _Qp_stoq(long double *, float); -extern void _Qp_dtoq(long double *, double); -extern float _Qp_qtos(long double *); -extern double _Qp_qtod(long double *); - -extern int _Qp_qtoi(long double *); -extern unsigned int _Qp_qtoui(long double *); -extern long _Qp_qtox(long double *); -extern unsigned long _Qp_qtoux(long double *); - -extern void _Qp_itoq(long double *, int); -extern void _Qp_uitoq(long double *, unsigned int); -extern void _Qp_xtoq(long double *, long); -extern void _Qp_uxtoq(long double *, unsigned long); - -extern int _Qp_cmp(long double *, long double *); -extern int _Qp_cmpe(long double *, long double *); -extern int _Qp_feq(long double *, long double *); -extern int _Qp_fge(long double *, long double *); -extern int _Qp_fgt(long double *, long double *); -extern int _Qp_fle(long double*, long double *); -extern int _Qp_flt(long double *, long double *); -extern int _Qp_fne(long double *, long double *); - -/* ARM EABI */ -extern float __aeabi_d2f(double); -extern double __aeabi_f2d(float); -extern float __aeabi_i2f(int); -extern float __aeabi_ui2f(int); -extern double __aeabi_i2d(int); -extern double __aeabi_ui2d(unsigned int); -extern double __aeabi_l2d(long long); -extern float __aeabi_l2f(long long); -extern float __aeabi_ul2f(unsigned long long); -extern unsigned int __aeabi_d2uiz(double); -extern long long __aeabi_d2lz(double); - -extern int __aeabi_f2iz(float); -extern int __aeabi_f2uiz(float); -extern int __aeabi_d2iz(double); - -extern int __aeabi_fcmpge(float, float); -extern int __aeabi_fcmpgt(float, float); -extern int __aeabi_fcmplt(float, float); -extern int __aeabi_fcmpeq(float, float); - -extern int __aeabi_dcmpge(double, double); -extern int __aeabi_dcmpgt(double, double); -extern int __aeabi_dcmplt(double, double); -extern int __aeabi_dcmple(double, double); -extern int __aeabi_dcmpeq(double, double); - -extern float __aeabi_fadd(float, float); -extern float __aeabi_fsub(float, float); -extern float __aeabi_fmul(float, float); -extern float __aeabi_fdiv(float, float); - -extern double __aeabi_dadd(double, double); -extern double __aeabi_dsub(double, double); -extern double __aeabi_dmul(double, double); -extern double __aeabi_ddiv(double, double); - -/* Not implemented yet */ -extern void _Qp_sqrt(long double *, long double *); - -#endif - -/** @} - */ Index: uspace/lib/softfloat/sub.c =================================================================== --- uspace/lib/softfloat/sub.c (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ uspace/lib/softfloat/sub.c (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -34,8 +34,8 @@ */ -#include "sftypes.h" #include "sub.h" #include "comparison.h" #include "common.h" +#include "add.h" /** Subtract two single-precision floats with the same sign. @@ -438,4 +438,116 @@ } +#ifdef float32_t + +float32_t __subsf3(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + float32_u res; + + if (ua.data.parts.sign != ub.data.parts.sign) { + ub.data.parts.sign = !ub.data.parts.sign; + res.data = add_float32(ua.data, ub.data); + } else + res.data = sub_float32(ua.data, ub.data); + + return res.val; +} + +float32_t __aeabi_fsub(float32_t a, float32_t b) +{ + float32_u ua; + ua.val = a; + + float32_u ub; + ub.val = b; + + float32_u res; + + if (ua.data.parts.sign != ub.data.parts.sign) { + ub.data.parts.sign = !ub.data.parts.sign; + res.data = add_float32(ua.data, ub.data); + } else + res.data = sub_float32(ua.data, ub.data); + + return res.val; +} + +#endif + +#ifdef float64_t + +float64_t __subdf3(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + float64_u res; + + if (ua.data.parts.sign != ub.data.parts.sign) { + ub.data.parts.sign = !ub.data.parts.sign; + res.data = add_float64(ua.data, ub.data); + } else + res.data = sub_float64(ua.data, ub.data); + + return res.val; +} + +float64_t __aeabi_dsub(float64_t a, float64_t b) +{ + float64_u ua; + ua.val = a; + + float64_u ub; + ub.val = b; + + float64_u res; + + if (ua.data.parts.sign != ub.data.parts.sign) { + ub.data.parts.sign = !ub.data.parts.sign; + res.data = add_float64(ua.data, ub.data); + } else + res.data = sub_float64(ua.data, ub.data); + + return res.val; +} + +#endif + +#ifdef float128_t + +float128_t __subtf3(float128_t a, float128_t b) +{ + float128_u ua; + ua.val = a; + + float128_u ub; + ub.val = b; + + float128_u res; + + if (ua.data.parts.sign != ub.data.parts.sign) { + ub.data.parts.sign = !ub.data.parts.sign; + res.data = add_float128(ua.data, ub.data); + } else + res.data = sub_float128(ua.data, ub.data); + + return res.val; +} + +void _Qp_sub(float128_t *c, float128_t *a, float128_t *b) +{ + *c = __subtf3(*a, *b); +} + +#endif + /** @} */ Index: uspace/lib/softfloat/sub.h =================================================================== --- uspace/lib/softfloat/sub.h (revision d9be488aaf4d20f1c61c594ac3595cdf66202e01) +++ uspace/lib/softfloat/sub.h (revision 795e2bfe0ca714517bdac2b7abae8091c5f88ee9) @@ -37,4 +37,6 @@ #define __SUB_H__ +#include + extern float32 sub_float32(float32, float32); extern float64 sub_float64(float64, float64); @@ -42,4 +44,19 @@ extern float128 sub_float128(float128, float128); +#ifdef float32_t +extern float32_t __subsf3(float32_t, float32_t); +extern float32_t __aeabi_fsub(float32_t, float32_t); +#endif + +#ifdef float64_t +extern float64_t __subdf3(float64_t, float64_t); +extern float64_t __aeabi_dsub(float64_t, float64_t); +#endif + +#ifdef float128_t +extern float128_t __subtf3(float128_t, float128_t); +extern void _Qp_sub(float128_t *, float128_t *, float128_t *); +#endif + #endif