Changeset c0c38c7c in mainline for uspace/lib/softfloat

Timestamp:

2015-03-14T21:36:44Z (10 years ago)

Author:

Martin Decky <martin@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

7f9d97f3

Parents:

2c7fdaa

Message:

software floating point overhaul
use proper type mapping
fix cosine calculation

Location:

uspace/lib/softfloat

Files:

• Makefile (modified) (2 diffs)
• add.c (modified) (2 diffs)
• add.h (modified) (2 diffs)
• common.c (modified) (1 diff)
• common.h (modified) (3 diffs)
• comparison.c (modified) (2 diffs)
• comparison.h (modified) (2 diffs)
• conversion.c (modified) (2 diffs)
• conversion.h (modified) (2 diffs)
• div.c (modified) (2 diffs)
• div.h (modified) (1 diff)
• mul.c (modified) (9 diffs)
• mul.h (modified) (2 diffs)
• neg.c (added)
• neg.h (added)
• sftypes.h (deleted)
• softfloat.c (deleted)
• softfloat.h (deleted)
• sub.c (modified) (2 diffs)
• sub.h (modified) (2 diffs)

uspace/lib/softfloat/Makefile

@@ -33 +33 @@
 
 SOURCES = \
-        softfloat.c \
         common.c \
         add.c \
@@ -39 +38 @@
         div.c \
         mul.c \
+        neg.c \
         comparison.c \
         conversion.c

uspace/lib/softfloat/add.c

@@ -34 +34 @@
  */
 
-#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 +413 @@
 }
 
+#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
+
 /** @}
  */

uspace/lib/softfloat/add.h

@@ -37 +37 @@
 #define __ADD_H__
 
+#include <mathtypes.h>
+
 extern float32 add_float32(float32, float32);
 extern float64 add_float64(float64, float64);
@@ -42 +44 @@
 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
 

uspace/lib/softfloat/common.c

@@ -34 +34 @@
  */
 
-#include "sftypes.h"
 #include "common.h"
 

uspace/lib/softfloat/common.h

@@ -37 +37 @@
 #define __COMMON_H__
 
-#include "sftypes.h"
+#include <mathtypes.h>
 
 extern float64 finish_float64(int32_t, uint64_t, char);
@@ -53 +53 @@
 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 +65 @@
 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 *);

uspace/lib/softfloat/comparison.c

@@ -34 +34 @@
  */
 
-#include "sftypes.h"
 #include "comparison.h"
 #include "common.h"
@@ -439 +438 @@
 }
 
+#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
+
 /** @}
  */

uspace/lib/softfloat/comparison.h

@@ -36 +36 @@
 #ifndef __COMPARISON_H__
 #define __COMPARISON_H__
+
+#include <mathtypes.h>
 
 extern int is_float32_nan(float32);
@@ -77 +79 @@
 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
 

uspace/lib/softfloat/conversion.c

@@ -34 +34 @@
  */
 
-#include "sftypes.h"
 #include "conversion.h"
 #include "comparison.h"
@@ -1037 +1036 @@
 }
 
+#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
+
 /** @}
  */

uspace/lib/softfloat/conversion.h

@@ -36 +36 @@
 #ifndef __CONVERSION_H__
 #define __CONVERSION_H__
+
+#include <mathtypes.h>
 
 extern float64 float32_to_float64(float32);
@@ -99 +101 @@
 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
 

uspace/lib/softfloat/div.c

@@ -34 +34 @@
  */
 
-#include "sftypes.h"
 #include "add.h"
 #include "div.h"
@@ -539 +538 @@
 }
 
+#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
+
 /** @}
  */

uspace/lib/softfloat/div.h

@@ -42 +42 @@
 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
 

uspace/lib/softfloat/mul.c

@@ -34 +34 @@
  */
 
-#include "sftypes.h"
 #include "mul.h"
 #include "comparison.h"
@@ -62 +61 @@
                         return result;
                 }
+                
                 if (is_float32_signan(b)) { /* TODO: fix SigNaN */
                         result.parts.fraction = b.parts.fraction;
@@ -67 +67 @@
                         return result;
                 }
+                
                 /* set NaN as result */
                 result.bin = FLOAT32_NAN;
@@ -78 +79 @@
                         return result;
                 }
+                
                 result.parts.fraction = a.parts.fraction;
                 result.parts.exp = a.parts.exp;
@@ -89 +91 @@
                         return result;
                 }
+                
                 result.parts.fraction = b.parts.fraction;
                 result.parts.exp = b.parts.exp;
@@ -106 +109 @@
         }
         
-        if (exp < 0) { 
+        if (exp < 0) {
                 /* FIXME: underflow */
                 /* return signed zero */
@@ -164 +167 @@
                 /* denormalized number */
                 frac1 >>= 1; /* denormalize */
+                
                 while ((frac1 > 0) && (exp < 0)) {
                         frac1 >>= 1;
                         ++exp;
                 }
+                
                 if (frac1 == 0) {
                         /* FIXME : underflow */
@@ -175 +180 @@
                 }
         }
+        
         result.parts.exp = exp; 
         result.parts.fraction = frac1 & ((1 << FLOAT32_FRACTION_SIZE) - 1);
@@ -380 +386 @@
 }
 
+#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
+
 /** @}
  */

uspace/lib/softfloat/mul.h

@@ -37 +37 @@
 #define __MUL_H__
 
+#include <mathtypes.h>
+
 extern float32 mul_float32(float32, float32);
 extern float64 mul_float64(float64, float64);
@@ -42 +44 @@
 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
 

uspace/lib/softfloat/sub.c

@@ -34 +34 @@
  */
 
-#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 +438 @@
 }
 
+#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
+
 /** @}
  */

uspace/lib/softfloat/sub.h

@@ -37 +37 @@
 #define __SUB_H__
 
+#include <mathtypes.h>
+
 extern float32 sub_float32(float32, float32);
 extern float64 sub_float64(float64, float64);
@@ -42 +44 @@
 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