Index: uspace/app/tester/float/softfloat1.c =================================================================== --- uspace/app/tester/float/softfloat1.c (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/app/tester/float/softfloat1.c (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -29,5 +29,5 @@ #include #include -#include +#include #include #include @@ -39,6 +39,28 @@ #include "../tester.h" +#define add_float __addsf3 +#define sub_float __subsf3 +#define mul_float __mulsf3 +#define div_float __divsf3 + +#define is_float_lt __ltsf2 +#define is_float_gt __gtsf2 +#define is_float_eq __eqsf2 + +#define add_double __adddf3 +#define sub_double __subdf3 +#define mul_double __muldf3 +#define div_double __divdf3 + +#define is_double_lt __ltdf2 +#define is_double_gt __gtdf2 +#define is_double_eq __eqdf2 + +#define uint_to_double __floatsidf +#define double_to_uint __fixunsdfsi +#define double_to_int __fixdfsi + #define OPERANDS 10 -#define PRECISION 10000 +#define PRECISION 1000 #define PRIdCMPTYPE PRId32 @@ -46,8 +68,9 @@ typedef int32_t cmptype_t; -typedef void (* uint_to_double_op_t)(unsigned int, double *, double_t *); +typedef void (* uint_to_double_op_t)(unsigned int, double *, double *); typedef void (* double_to_uint_op_t)(double, unsigned int *, unsigned int *); -typedef void (* float_binary_op_t)(float, float, float *, float_t *); -typedef void (* double_binary_op_t)(double, double, double *, double_t *); +typedef void (* float_binary_op_t)(float, float, float *, float *); +typedef void (* float_cmp_op_t)(float, float, cmptype_t *, cmptype_t *); +typedef void (* double_binary_op_t)(double, double, double *, double *); typedef void (* double_cmp_op_t)(double, double, cmptype_t *, cmptype_t *); @@ -68,16 +91,8 @@ static unsigned int uop_a[OPERANDS] = { - 4, -100, 100, 50, 1024, 0, 1000000, -1U, 0x80000000U, 500 + 4, 2, 100, 50, 1024, 0, 1000000, 1, 0x8000000, 500 }; -static cmptype_t cmpabs(cmptype_t a) -{ - if (a >= 0) - return a; - - return -a; -} - -static int dcmp(double a, double b) +static int fcmp(float a, float b) { if (a < b) @@ -90,4 +105,15 @@ } +static int dcmp(double a, double b) +{ + if (a < b) + return -1; + + if (a > b) + return 1; + + return 0; +} + static void uint_to_double_template(void *f, unsigned i, cmptype_t *pic, cmptype_t *pisc) @@ -96,9 +122,9 @@ double c; - double_t sc; + double sc; op(uop_a[i], &c, &sc); *pic = (cmptype_t) (c * PRECISION); - *pisc = (cmptype_t) (sc.val * PRECISION); + *pisc = (cmptype_t) (sc * PRECISION); } @@ -116,5 +142,4 @@ } - static void float_template_binary(void *f, unsigned i, unsigned j, cmptype_t *pic, cmptype_t *pisc) @@ -123,9 +148,17 @@ float c; - float_t sc; + float sc; op(fop_a[i], fop_a[j], &c, &sc); *pic = (cmptype_t) (c * PRECISION); - *pisc = (cmptype_t) (sc.val * PRECISION); + *pisc = (cmptype_t) (sc * PRECISION); +} + +static void float_compare_template(void *f, unsigned i, unsigned j, + cmptype_t *pis, cmptype_t *piss) +{ + float_cmp_op_t op = (float_cmp_op_t) f; + + op(dop_a[i], dop_a[j], pis, piss); } @@ -136,9 +169,9 @@ double c; - double_t sc; + double sc; op(dop_a[i], dop_a[j], &c, &sc); *pic = (cmptype_t) (c * PRECISION); - *pisc = (cmptype_t) (sc.val * PRECISION); + *pisc = (cmptype_t) (sc * PRECISION); } @@ -160,8 +193,9 @@ template(f, i, &ic, &isc); - cmptype_t diff = cmpabs(ic - isc); + cmptype_t diff = ic - isc; if (diff != 0) { - TPRINTF("i=%u diff=%" PRIdCMPTYPE "\n", i, diff); + TPRINTF("i=%u ic=%" PRIdCMPTYPE " isc=%" PRIdCMPTYPE "\n", + i, ic, isc); correct = false; } @@ -181,9 +215,9 @@ template(f, i, j, &ic, &isc); - cmptype_t diff = cmpabs(ic - isc); + cmptype_t diff = ic - isc; if (diff != 0) { - TPRINTF("i=%u, j=%u diff=%" PRIdCMPTYPE "\n", - i, j, diff); + TPRINTF("i=%u, j=%u ic=%" PRIdCMPTYPE + " isc=%" PRIdCMPTYPE "\n", i, j, ic, isc); correct = false; } @@ -194,8 +228,8 @@ } -static void uint_to_double_operator(unsigned int a, double *pc, double_t *psc) +static void uint_to_double_operator(unsigned int a, double *pc, double *psc) { *pc = (double) a; - psc->data = uint_to_double(a); + *psc = uint_to_double(a); } @@ -203,10 +237,6 @@ unsigned int *psc) { - double_t sa; - - sa.val = a; - *pc = (unsigned int) a; - *psc = double_to_uint(sa.data); + *psc = double_to_uint(a); } @@ -214,130 +244,48 @@ unsigned int *psc) { - double_t sa; - - sa.val = a; - *pc = (int) a; - *psc = double_to_int(sa.data); -} - -static void float_add_operator(float a, float b, float *pc, float_t *psc) + *psc = double_to_int(a); +} + +static void float_add_operator(float a, float b, float *pc, float *psc) { *pc = a + b; - - float_t sa; - float_t sb; - - sa.val = a; - sb.val = b; - - if (sa.data.parts.sign == sb.data.parts.sign) { - psc->data = add_float(sa.data, sb.data); - } else if (sa.data.parts.sign) { - sa.data.parts.sign = 0; - psc->data = sub_float(sb.data, sa.data); - } else { - sb.data.parts.sign = 0; - psc->data = sub_float(sa.data, sb.data); - } -} - -static void float_mul_operator(float a, float b, float *pc, float_t *psc) + *psc = add_float(a, b); +} + +static void float_sub_operator(float a, float b, float *pc, float *psc) +{ + *pc = a - b; + *psc = sub_float(a, b); +} + +static void float_mul_operator(float a, float b, float *pc, float *psc) { *pc = a * b; - - float_t sa; - float_t sb; - - sa.val = a; - sb.val = b; - psc->data = mul_float(sa.data, sb.data); -} - -static void float_div_operator(float a, float b, float *pc, float_t *psc) + *psc = mul_float(a, b); +} + +static void float_div_operator(float a, float b, float *pc, float *psc) { if ((cmptype_t) b == 0) { *pc = 0.0; - psc->val = 0.0; + *psc = 0.0; return; } *pc = a / b; - - float_t sa; - float_t sb; - - sa.val = a; - sb.val = b; - psc->data = div_float(sa.data, sb.data); -} - -static void double_add_operator(double a, double b, double *pc, double_t *psc) -{ - *pc = a + b; - - double_t sa; - double_t sb; - - sa.val = a; - sb.val = b; - - if (sa.data.parts.sign == sb.data.parts.sign) { - psc->data = add_double(sa.data, sb.data); - } else if (sa.data.parts.sign) { - sa.data.parts.sign = 0; - psc->data = sub_double(sb.data, sa.data); - } else { - sb.data.parts.sign = 0; - psc->data = sub_double(sa.data, sb.data); - } -} - -static void double_mul_operator(double a, double b, double *pc, double_t *psc) -{ - *pc = a * b; - - double_t sa; - double_t sb; - - sa.val = a; - sb.val = b; - psc->data = mul_double(sa.data, sb.data); -} - -static void double_div_operator(double a, double b, double *pc, double_t *psc) -{ - if ((cmptype_t) b == 0) { - *pc = 0.0; - psc->val = 0.0; - return; - } - - *pc = a / b; - - double_t sa; - double_t sb; - - sa.val = a; - sb.val = b; - psc->data = div_double(sa.data, sb.data); -} - -static void double_cmp_operator(double a, double b, cmptype_t *pis, + *psc = div_float(a, b); +} + +static void float_cmp_operator(float a, float b, cmptype_t *pis, cmptype_t *piss) { - *pis = dcmp(a, b); - - double_t sa; - double_t sb; - - sa.val = a; - sb.val = b; - - if (is_double_lt(sa.data, sb.data)) + *pis = fcmp(a, b); + + if (is_float_lt(a, b) == -1) *piss = -1; - else if (is_double_gt(sa.data, sb.data)) + else if (is_float_gt(a, b) == 1) *piss = 1; - else if (is_double_eq(sa.data, sb.data)) + else if (is_float_eq(a, b) == 0) *piss = 0; else @@ -345,61 +293,124 @@ } +static void double_add_operator(double a, double b, double *pc, double *psc) +{ + *pc = a + b; + *psc = add_double(a, b); +} + +static void double_sub_operator(double a, double b, double *pc, double *psc) +{ + *pc = a - b; + *psc = sub_double(a, b); +} + +static void double_mul_operator(double a, double b, double *pc, double *psc) +{ + *pc = a * b; + *psc = mul_double(a, b); +} + +static void double_div_operator(double a, double b, double *pc, double *psc) +{ + if ((cmptype_t) b == 0) { + *pc = 0.0; + *psc = 0.0; + return; + } + + *pc = a / b; + *psc = div_double(a, b); +} + +static void double_cmp_operator(double a, double b, cmptype_t *pis, + cmptype_t *piss) +{ + *pis = dcmp(a, b); + + if (is_double_lt(a, b) == -1) + *piss = -1; + else if (is_double_gt(a, b) == 1) + *piss = 1; + else if (is_double_eq(a, b) == 0) + *piss = 0; + else + *piss = 42; +} + const char *test_softfloat1(void) { - const char *err = NULL; + bool err = false; if (!test_template_binary(float_template_binary, float_add_operator)) { - err = "Float addition failed"; - TPRINTF("%s\n", err); + err = true; + TPRINTF("%s\n", "Float addition failed"); + } + + if (!test_template_binary(float_template_binary, float_sub_operator)) { + err = true; + TPRINTF("%s\n", "Float addition failed"); } if (!test_template_binary(float_template_binary, float_mul_operator)) { - err = "Float multiplication failed"; - TPRINTF("%s\n", err); + err = true; + TPRINTF("%s\n", "Float multiplication failed"); } if (!test_template_binary(float_template_binary, float_div_operator)) { - err = "Float division failed"; - TPRINTF("%s\n", err); + err = true; + TPRINTF("%s\n", "Float division failed"); + } + + if (!test_template_binary(float_compare_template, float_cmp_operator)) { + err = true; + TPRINTF("%s\n", "Float comparison failed"); } if (!test_template_binary(double_template_binary, double_add_operator)) { - err = "Double addition failed"; - TPRINTF("%s\n", err); + err = true; + TPRINTF("%s\n", "Double addition failed"); + } + + if (!test_template_binary(double_template_binary, double_sub_operator)) { + err = true; + TPRINTF("%s\n", "Double addition failed"); } if (!test_template_binary(double_template_binary, double_mul_operator)) { - err = "Double multiplication failed"; - TPRINTF("%s\n", err); + err = true; + TPRINTF("%s\n", "Double multiplication failed"); } if (!test_template_binary(double_template_binary, double_div_operator)) { - err = "Double division failed"; - TPRINTF("%s\n", err); + err = true; + TPRINTF("%s\n", "Double division failed"); } if (!test_template_binary(double_compare_template, double_cmp_operator)) { - err = "Double comparison failed"; - TPRINTF("%s\n", err); + err = true; + TPRINTF("%s\n", "Double comparison failed"); } if (!test_template_unary(uint_to_double_template, uint_to_double_operator)) { - err = "Conversion from unsigned int to double failed"; - TPRINTF("%s\n", err); + err = true; + TPRINTF("%s\n", "Conversion from unsigned int to double failed"); } if (!test_template_unary(double_to_uint_template, double_to_uint_operator)) { - err = "Conversion from double to unsigned int failed"; - TPRINTF("%s\n", err); + err = true; + TPRINTF("%s\n", "Conversion from double to unsigned int failed"); } if (!test_template_unary(double_to_uint_template, double_to_int_operator)) { - err = "Conversion from double to signed int failed"; - TPRINTF("%s\n", err); - } - - return err; -} + err = true; + TPRINTF("%s\n", "Conversion from double to signed int failed"); + } + + if (err) + return "Software floating point imprecision"; + + return NULL; +} Index: uspace/lib/math/arch/abs32le/include/libarch/math.h =================================================================== --- uspace/lib/math/arch/abs32le/include/libarch/math.h (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/math/arch/abs32le/include/libarch/math.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -41,15 +41,15 @@ #include -static inline double fmod(double dividend, double divisor) +static inline float64_t fmod(float64_t dividend, float64_t divisor) { - return double_mod(dividend, divisor); + return float64_mod(dividend, divisor); } -static inline double trunc(double val) +static inline float64_t trunc(float64_t val) { - double_t arg; + float64_u arg; arg.val = val; - double_t ret; + float64_u ret; ret.data = trunc_float64(arg.data); @@ -57,12 +57,12 @@ } -static inline double sin(double val) +static inline float64_t sin(float64_t val) { - return double_sin(val); + return float64_sin(val); } -static inline double cos(double val) +static inline float64_t cos(float64_t val) { - return double_cos(val); + return float64_cos(val); } Index: uspace/lib/math/arch/amd64/include/libarch/math.h =================================================================== --- uspace/lib/math/arch/amd64/include/libarch/math.h (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/math/arch/amd64/include/libarch/math.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -36,14 +36,15 @@ #define LIBMATH_amd64_MATH_H_ +#include #include -static inline double fmod(double dividend, double divisor) +static inline float64_t fmod(float64_t dividend, float64_t divisor) { - return double_mod(dividend, divisor); + return float64_mod(dividend, divisor); } -extern double sin(double); -extern double cos(double); -extern double trunc(double); +extern float64_t sin(float64_t); +extern float64_t cos(float64_t); +extern float64_t trunc(float64_t); #endif Index: uspace/lib/math/arch/arm32/include/libarch/math.h =================================================================== --- uspace/lib/math/arch/arm32/include/libarch/math.h (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/math/arch/arm32/include/libarch/math.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -41,15 +41,15 @@ #include -static inline double fmod(double dividend, double divisor) +static inline float64_t fmod(float64_t dividend, float64_t divisor) { - return double_mod(dividend, divisor); + return float64_mod(dividend, divisor); } -static inline double trunc(double val) +static inline float64_t trunc(float64_t val) { - double_t arg; + float64_u arg; arg.val = val; - double_t ret; + float64_u ret; ret.data = trunc_float64(arg.data); @@ -57,12 +57,12 @@ } -static inline double sin(double val) +static inline float64_t sin(float64_t val) { - return double_sin(val); + return float64_sin(val); } -static inline double cos(double val) +static inline float64_t cos(float64_t val) { - return double_cos(val); + return float64_cos(val); } Index: uspace/lib/math/arch/ia32/include/libarch/math.h =================================================================== --- uspace/lib/math/arch/ia32/include/libarch/math.h (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/math/arch/ia32/include/libarch/math.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -36,14 +36,15 @@ #define LIBMATH_ia32_MATH_H_ +#include #include -static inline double fmod(double dividend, double divisor) +static inline float64_t fmod(float64_t dividend, float64_t divisor) { - return double_mod(dividend, divisor); + return float64_mod(dividend, divisor); } -extern double sin(double); -extern double cos(double); -extern double trunc(double); +extern float64_t sin(float64_t); +extern float64_t cos(float64_t); +extern float64_t trunc(float64_t); #endif Index: uspace/lib/math/arch/ia64/include/libarch/math.h =================================================================== --- uspace/lib/math/arch/ia64/include/libarch/math.h (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/math/arch/ia64/include/libarch/math.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -41,15 +41,15 @@ #include -static inline double fmod(double dividend, double divisor) +static inline float64_t fmod(float64_t dividend, float64_t divisor) { - return double_mod(dividend, divisor); + return float64_mod(dividend, divisor); } -static inline double trunc(double val) +static inline float64_t trunc(float64_t val) { - double_t arg; + float64_u arg; arg.val = val; - double_t ret; + float64_u ret; ret.data = trunc_float64(arg.data); @@ -57,12 +57,12 @@ } -static inline double sin(double val) +static inline float64_t sin(float64_t val) { - return double_sin(val); + return float64_sin(val); } -static inline double cos(double val) +static inline float64_t cos(float64_t val) { - return double_cos(val); + return float64_cos(val); } Index: uspace/lib/math/arch/mips32/include/libarch/math.h =================================================================== --- uspace/lib/math/arch/mips32/include/libarch/math.h (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/math/arch/mips32/include/libarch/math.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -41,15 +41,15 @@ #include -static inline double fmod(double dividend, double divisor) +static inline float64_t fmod(float64_t dividend, float64_t divisor) { - return double_mod(dividend, divisor); + return float64_mod(dividend, divisor); } -static inline double trunc(double val) +static inline float64_t trunc(float64_t val) { - double_t arg; + float64_u arg; arg.val = val; - double_t ret; + float64_u ret; ret.data = trunc_float64(arg.data); @@ -57,12 +57,12 @@ } -static inline double sin(double val) +static inline float64_t sin(float64_t val) { - return double_sin(val); + return float64_sin(val); } -static inline double cos(double val) +static inline float64_t cos(float64_t val) { - return double_cos(val); + return float64_cos(val); } Index: uspace/lib/math/arch/mips32eb/include/libarch/math.h =================================================================== --- uspace/lib/math/arch/mips32eb/include/libarch/math.h (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/math/arch/mips32eb/include/libarch/math.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -41,15 +41,15 @@ #include -static inline double fmod(double dividend, double divisor) +static inline float64_t fmod(float64_t dividend, float64_t divisor) { - return double_mod(dividend, divisor); + return float64_mod(dividend, divisor); } -static inline double trunc(double val) +static inline float64_t trunc(float64_t val) { - double_t arg; + float64_u arg; arg.val = val; - double_t ret; + float64_u ret; ret.data = trunc_float64(arg.data); @@ -57,12 +57,12 @@ } -static inline double sin(double val) +static inline float64_t sin(float64_t val) { - return double_sin(val); + return float64_sin(val); } -static inline double cos(double val) +static inline float64_t cos(float64_t val) { - return double_cos(val); + return float64_cos(val); } Index: uspace/lib/math/arch/ppc32/include/libarch/math.h =================================================================== --- uspace/lib/math/arch/ppc32/include/libarch/math.h (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/math/arch/ppc32/include/libarch/math.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -41,15 +41,15 @@ #include -static inline double fmod(double dividend, double divisor) +static inline float64_t fmod(float64_t dividend, float64_t divisor) { - return double_mod(dividend, divisor); + return float64_mod(dividend, divisor); } static inline double trunc(double val) { - double_t arg; + float64_u arg; arg.val = val; - double_t ret; + float64_u ret; ret.data = trunc_float64(arg.data); @@ -57,12 +57,12 @@ } -static inline double sin(double val) +static inline float64_t sin(float64_t val) { - return double_sin(val); + return float64_sin(val); } -static inline double cos(double val) +static inline float64_t cos(float64_t val) { - return double_cos(val); + return float64_cos(val); } Index: uspace/lib/math/arch/sparc32/include/libarch/math.h =================================================================== --- uspace/lib/math/arch/sparc32/include/libarch/math.h (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/math/arch/sparc32/include/libarch/math.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -41,15 +41,15 @@ #include -static inline double fmod(double dividend, double divisor) +static inline float64_t fmod(float64_t dividend, float64_t divisor) { - return double_mod(dividend, divisor); + return float64_mod(dividend, divisor); } -static inline double trunc(double val) +static inline float64_t trunc(float64_t val) { - double_t arg; + float64_u arg; arg.val = val; - double_t ret; + float64_u ret; ret.data = trunc_float64(arg.data); @@ -57,12 +57,12 @@ } -static inline double sin(double val) +static inline float64_t sin(float64_t val) { - return double_sin(val); + return float64_sin(val); } -static inline double cos(double val) +static inline float64_t cos(float64_t val) { - return double_cos(val); + return float64_cos(val); } Index: uspace/lib/math/arch/sparc64/include/libarch/math.h =================================================================== --- uspace/lib/math/arch/sparc64/include/libarch/math.h (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/math/arch/sparc64/include/libarch/math.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -41,15 +41,15 @@ #include -static inline double fmod(double dividend, double divisor) +static inline float64_t fmod(float64_t dividend, float64_t divisor) { - return double_mod(dividend, divisor); + return float64_mod(dividend, divisor); } -static inline double trunc(double val) +static inline float64_t trunc(float64_t val) { - double_t arg; + float64_u arg; arg.val = val; - double_t ret; + float64_u ret; ret.data = trunc_float64(arg.data); @@ -57,12 +57,12 @@ } -static inline double sin(double val) +static inline float64_t sin(float64_t val) { - return double_sin(val); + return float64_sin(val); } -static inline double cos(double val) +static inline float64_t cos(float64_t val) { - return double_cos(val); + return float64_cos(val); } Index: uspace/lib/math/generic/mod.c =================================================================== --- uspace/lib/math/generic/mod.c (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/math/generic/mod.c (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -52,9 +52,9 @@ * */ -double double_mod(double dividend, double divisor) +float64_t float64_mod(float64_t dividend, float64_t divisor) { // FIXME: replace with exact arithmetics - double quotient = trunc(dividend / divisor); + float64_t quotient = trunc(dividend / divisor); return (dividend - quotient * divisor); Index: uspace/lib/math/generic/trig.c =================================================================== --- uspace/lib/math/generic/trig.c (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/math/generic/trig.c (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -39,5 +39,5 @@ /** Precomputed values for factorial (starting from 1!) */ -static double factorials[TAYLOR_DEGREE] = { +static float64_t factorials[TAYLOR_DEGREE] = { 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800 @@ -56,8 +56,8 @@ * */ -static double taylor_sin(double arg) -{ - double ret = 0; - double nom = 1; +static float64_t taylor_sin(float64_t arg) +{ + float64_t ret = 0; + float64_t nom = 1; for (unsigned int i = 0; i < TAYLOR_DEGREE; i++) { @@ -85,8 +85,8 @@ * */ -static double taylor_cos(double arg) -{ - double ret = 1; - double nom = 1; +static float64_t taylor_cos(float64_t arg) +{ + float64_t ret = 1; + float64_t nom = 1; for (unsigned int i = 0; i < TAYLOR_DEGREE; i++) { @@ -114,5 +114,5 @@ * */ -static double base_sin(double arg) +static float64_t base_sin(float64_t arg) { unsigned int period = arg / (M_PI / 4); @@ -147,5 +147,5 @@ * */ -static double base_cos(double arg) +static float64_t base_cos(float64_t arg) { unsigned int period = arg / (M_PI / 4); @@ -156,5 +156,5 @@ case 1: case 2: - return taylor_sin(arg - M_PI / 2); + return -taylor_sin(arg - M_PI / 2); case 3: case 4: @@ -162,5 +162,5 @@ case 5: case 6: - return -taylor_sin(arg - 3 * M_PI / 2); + return taylor_sin(arg - 3 * M_PI / 2); default: return taylor_cos(arg - 2 * M_PI); @@ -177,7 +177,7 @@ * */ -double double_sin(double arg) -{ - double base_arg = fmod(arg, 2 * M_PI); +float64_t float64_sin(float64_t arg) +{ + float64_t base_arg = fmod(arg, 2 * M_PI); if (base_arg < 0) @@ -196,7 +196,7 @@ * */ -double double_cos(double arg) -{ - double base_arg = fmod(arg, 2 * M_PI); +float64_t float64_cos(float64_t arg) +{ + float64_t base_arg = fmod(arg, 2 * M_PI); if (base_arg < 0) Index: uspace/lib/math/include/mathtypes.h =================================================================== --- uspace/lib/math/include/mathtypes.h (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/math/include/mathtypes.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -191,51 +191,121 @@ #endif -typedef union { - float val; - + #if defined(FLOAT_SIZE_32) + +#ifndef float32_t + #define float32_t float +#endif + +#elif defined(FLOAT_SIZE_64) + +#ifndef float64_t + #define float64_t float +#endif + +#elif defined(FLOAT_SIZE_96) + +#ifndef float96_t + #define float96_t float +#endif + +#elif defined(FLOAT_SIZE_128) + +#ifndef float128_t + #define float128_t float +#endif + +#endif + + +#if defined(DOUBLE_SIZE_32) + +#ifndef float32_t + #define float32_t double +#endif + +#elif defined(DOUBLE_SIZE_64) + +#ifndef float64_t + #define float64_t double +#endif + +#elif defined(DOUBLE_SIZE_96) + +#ifndef float96_t + #define float96_t double +#endif + +#elif defined(DOUBLE_SIZE_128) + +#ifndef float128_t + #define float128_t double +#endif + +#endif + + +#if defined(LONG_DOUBLE_SIZE_32) + +#ifndef float32_t + #define float32_t long double +#endif + +#elif defined(LONG_DOUBLE_SIZE_64) + +#ifndef float64_t + #define float64_t long double +#endif + +#elif defined(LONG_DOUBLE_SIZE_96) + +#ifndef float96_t + #define float96_t long double +#endif + +#elif defined(LONG_DOUBLE_SIZE_128) + +#ifndef float128_t + #define float128_t long double +#endif + +#endif + + +#ifdef float32_t + +typedef union { + float32_t val; float32 data; -#elif defined(FLOAT_SIZE_64) +} float32_u; + +#endif + +#ifdef float64_t + +typedef union { + float64_t val; float64 data; -#elif defined(FLOAT_SIZE_96) +} float64_u; + +#endif + +#ifdef float96_t + +typedef union { + float96_t val; float96 data; -#elif defined(FLOAT_SIZE_128) +} float96_u; + +#endif + +#ifdef float128_t + +typedef union { + float128_t val; float128 data; -#else - #error Unsupported float size -#endif -} float_t; - -typedef union { - double val; - -#if defined(DOUBLE_SIZE_32) - float32 data; -#elif defined(DOUBLE_SIZE_64) - float64 data; -#elif defined(DOUBLE_SIZE_96) - float96 data; -#elif defined(DOUBLE_SIZE_128) - float128 data; -#else - #error Unsupported double size -#endif -} double_t; - -typedef union { - long double val; - -#if defined(LONG_DOUBLE_SIZE_32) - float32 data; -#elif defined(LONG_DOUBLE_SIZE_64) - float64 data; -#elif defined(LONG_DOUBLE_SIZE_96) - float96 data; -#elif defined(LONG_DOUBLE_SIZE_128) - float128 data; -#else - #error Unsupported long double size -#endif -} long_double_t; +} float128_u; + +#endif #endif Index: uspace/lib/math/include/mod.h =================================================================== --- uspace/lib/math/include/mod.h (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/math/include/mod.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -36,5 +36,5 @@ #define LIBMATH_MOD_H_ -extern double double_mod(double, double); +extern float64_t float64_mod(float64_t, float64_t); #endif Index: uspace/lib/math/include/trig.h =================================================================== --- uspace/lib/math/include/trig.h (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/math/include/trig.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -36,6 +36,6 @@ #define LIBMATH_TRIG_H_ -extern double double_sin(double); -extern double double_cos(double); +extern float64_t float64_sin(float64_t); +extern float64_t float64_cos(float64_t); #endif Index: uspace/lib/softfloat/Makefile =================================================================== --- uspace/lib/softfloat/Makefile (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/softfloat/Makefile (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -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 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/softfloat/add.c (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -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 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/softfloat/add.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -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 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/softfloat/common.c (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -34,5 +34,4 @@ */ -#include "sftypes.h" #include "common.h" Index: uspace/lib/softfloat/common.h =================================================================== --- uspace/lib/softfloat/common.h (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/softfloat/common.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -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 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/softfloat/comparison.c (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -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 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/softfloat/comparison.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -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 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/softfloat/conversion.c (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -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 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/softfloat/conversion.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -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 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/softfloat/div.c (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -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 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/softfloat/div.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -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 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/softfloat/mul.c (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -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 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/softfloat/mul.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -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 c0c38c7c377b0a40d556f2b53fa830176a19d761) +++ uspace/lib/softfloat/neg.c (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -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 c0c38c7c377b0a40d556f2b53fa830176a19d761) +++ uspace/lib/softfloat/neg.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -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: pace/lib/softfloat/sftypes.h =================================================================== --- uspace/lib/softfloat/sftypes.h (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ (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: pace/lib/softfloat/softfloat.c =================================================================== --- uspace/lib/softfloat/softfloat.c (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ (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: pace/lib/softfloat/softfloat.h =================================================================== --- uspace/lib/softfloat/softfloat.h (revision 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ (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 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/softfloat/sub.c (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -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 2c7fdaa52e822972ed823b3dc82058faf31a152b) +++ uspace/lib/softfloat/sub.h (revision c0c38c7c377b0a40d556f2b53fa830176a19d761) @@ -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