Add hard float versions of floating point to long long conversions

[sdmitrouk]

Summary

This adds hard-float implementation for the following builtins:

• __fixdfdi()
• __fixsfdi()
• __fixunsdfdi()
• __fixunssfdi()

The soft-float implementation does never raise floating point exceptions,
which doesn't allow clients to detect floating point conversion errors.

I must mention that I had to refer to libgcc's implementation to write these
functions.

Related unit-tests of compiler-rt passed with these changes.

[sdmitrouk]

Ping?

[sdmitrouk]

Ping.

[sdmitrouk]

Ping? Anyone interested in using hard-float when it's available?

[sdmitrouk]

Ping.

[sdmitrouk]

Ping?

[sdmitrouk]

Ping.

[sdmitrouk]

Ping.

[sdmitrouk]

Ping. Also note that apart from related compiler-rt-tests I've also tested these changes with musl-libc-testsuite, musl-libc-bench and llvm-testsuite, none of which revealed any regressions.

[sdmitrouk]

Ping.

[sdmitrouk]

Ping.

[sdmitrouk]

Ping.

[sdmitrouk]

Ping.

[sdmitrouk]

Ping.

Am I going for a record here? It's thirteenth ping and I'm wondering what's current maximum number of successive pings? :-)

[sdmitrouk]

Ping #14.

[rengolin]

Sorry Sergey,

I didn't get any email about this, and I'd not be surprised if no one else got it, either. I've added more people to look at this, since this is not as simple as it looks.

We'll also going to need some tests to make sure the expected behaviour is attained on the corner cases.

cheers,
--renato

[sdmitrouk]

Hi Renato,

I see all my pings in the mailing list, so I'd expect notifications to work fine, but I can't know for sure. It's not something urgent anyway.

We'll also going to need some tests to make sure the expected behaviour is attained on the corner cases.

There are tests for these builtins, I used them to check that everything still works as expected (some of them failed at the beginning, so those tests do their work).

Thanks,
Sergey

[rengolin]

In D5376#137585, @sdmitrouk wrote:

I see all my pings in the mailing list, so I'd expect notifications to work fine, but I can't know for sure. It's not something urgent anyway.

Maybe my filter didn't work as expected, or maybe I just managed to ignore all your pings, which is unsettling... :)

There are tests for these builtins, I used them to check that everything still works as expected (some of them failed at the beginning, so those tests do their work).

I saw them, and they seem broad enough. What kind of hardware did you test this on? These should apply to all architectures, right?

cheers,
--renato

[sdmitrouk]

I saw them, and they seem broad enough. What kind of hardware did you test this on? These should apply to all architectures, right?

I couldn't compile compiler-rt for x86/x86_64 and tested changes on ARM only (but on both 32 and 64 bit). I mentioned that test-suite and musl libc tests (which are quite picky about floating point operations) pass fine with these changes on 32 bit ARM, but I'll add some more tests if you wish.

Cheers,
Sergey

[rengolin]

No, I'm happy with the tests how they are. Please allow others to comment, but it looks ok to me.

[rengolin]

Forgot to accept. @compnerd do you have any comments?

[sdmitrouk]

Ping.

I'll wait for comments until some time on the next week and assume that everyone is OK with the changes if there is no objections.

compiler-rt/trunk/lib/builtins/fixdfdi.c

 /* ===-- fixdfdi.c - Implement __fixdfdi -----------------------------------===
  *
  *                     The LLVM Compiler Infrastructure
  *
  * This file is dual licensed under the MIT and the University of Illinois Open
  * Source Licenses. See LICENSE.TXT for details.
  *
  * ===----------------------------------------------------------------------===
  */
 
 #define DOUBLE_PRECISION
 #include "fp_lib.h"
 ARM_EABI_FNALIAS(d2lz, fixdfdi)
 
+#ifndef __SOFT_FP__
+/* Support for systems that have hardware floating-point; can set the invalid
+ * flag as a side-effect of computation.
+ */
+
+COMPILER_RT_ABI du_int __fixunsdfdi(double a);
+
+COMPILER_RT_ABI di_int
+__fixdfdi(double a)
+{
+    if (a < 0.0) {
+        return -__fixunsdfdi(-a);
+    }
+    return __fixunsdfdi(a);
+}
+
+#else
+/* Support for systems that don't have hardware floating-point; there are no
+ * flags to set, and we don't want to code-gen to an unknown soft-float
+ * implementation.
+ */
+
 typedef di_int fixint_t;
 typedef du_int fixuint_t;
 #include "fp_fixint_impl.inc"
 
 COMPILER_RT_ABI di_int
 __fixdfdi(fp_t a) {
     return __fixint(a);
 }
+
+#endif

compiler-rt/trunk/lib/builtins/fixsfdi.c

 /* ===-- fixsfdi.c - Implement __fixsfdi -----------------------------------===
  *
  *                     The LLVM Compiler Infrastructure
  *
  * This file is dual licensed under the MIT and the University of Illinois Open
  * Source Licenses. See LICENSE.TXT for details.
  *
  * ===----------------------------------------------------------------------===
  */
 
 #define SINGLE_PRECISION
 #include "fp_lib.h"
 
 ARM_EABI_FNALIAS(f2lz, fixsfdi)
 
+#ifndef __SOFT_FP__
+/* Support for systems that have hardware floating-point; can set the invalid
+ * flag as a side-effect of computation.
+ */
+
+COMPILER_RT_ABI du_int __fixunssfdi(float a);
+
+COMPILER_RT_ABI di_int
+__fixsfdi(float a)
+{
+    if (a < 0.0f) {
+        return -__fixunssfdi(-a);
+    }
+    return __fixunssfdi(a);
+}
+
+#else
+/* Support for systems that don't have hardware floating-point; there are no
+ * flags to set, and we don't want to code-gen to an unknown soft-float
+ * implementation.
+ */
+
 typedef di_int fixint_t;
 typedef du_int fixuint_t;
 #include "fp_fixint_impl.inc"
 
 COMPILER_RT_ABI di_int
 __fixsfdi(fp_t a) {
     return __fixint(a);
 }
+
+#endif

compiler-rt/trunk/lib/builtins/fixunsdfdi.c

 /* ===-- fixunsdfdi.c - Implement __fixunsdfdi -----------------------------===
  *
  *                     The LLVM Compiler Infrastructure
  *
  * This file is dual licensed under the MIT and the University of Illinois Open
  * Source Licenses. See LICENSE.TXT for details.
  *
  * ===----------------------------------------------------------------------===
  */
 
 #define DOUBLE_PRECISION
 #include "fp_lib.h"
-typedef du_int fixuint_t;
-#include "fp_fixuint_impl.inc"
 
 ARM_EABI_FNALIAS(d2ulz, fixunsdfdi)
 
+#ifndef __SOFT_FP__
+/* Support for systems that have hardware floating-point; can set the invalid
+ * flag as a side-effect of computation.
+ */
+
+COMPILER_RT_ABI du_int
+__fixunsdfdi(double a)
+{
+    su_int high = a/0x1p32f;
+    su_int low = a - (double)high*0x1p32f;
+    return ((du_int)high << 32) | low;
+}
+
+#else
+/* Support for systems that don't have hardware floating-point; there are no
+ * flags to set, and we don't want to code-gen to an unknown soft-float
+ * implementation.
+ */
+
+typedef du_int fixuint_t;
+#include "fp_fixuint_impl.inc"
+
 COMPILER_RT_ABI du_int
 __fixunsdfdi(fp_t a) {
     return __fixuint(a);
 }
+
+#endif

compiler-rt/trunk/lib/builtins/fixunssfdi.c

 /* ===-- fixunssfdi.c - Implement __fixunssfdi -----------------------------===
  *
  *                     The LLVM Compiler Infrastructure
  *
  * This file is dual licensed under the MIT and the University of Illinois Open
  * Source Licenses. See LICENSE.TXT for details.
  *
  * ===----------------------------------------------------------------------===
  */
 
 #define SINGLE_PRECISION
 #include "fp_lib.h"
-typedef du_int fixuint_t;
-#include "fp_fixuint_impl.inc"
 
 ARM_EABI_FNALIAS(f2ulz, fixunssfdi)
 
+#ifndef __SOFT_FP__
+/* Support for systems that have hardware floating-point; can set the invalid
+ * flag as a side-effect of computation.
+ */
+
+COMPILER_RT_ABI du_int
+__fixunssfdi(float a)
+{
+    double da = a;
+    su_int high = da/0x1p32f;
+    su_int low = da - (double)high*0x1p32f;
+    return ((du_int)high << 32) | low;
+}
+
+#else
+/* Support for systems that don't have hardware floating-point; there are no
+ * flags to set, and we don't want to code-gen to an unknown soft-float
+ * implementation.
+ */
+
+typedef du_int fixuint_t;
+#include "fp_fixuint_impl.inc"
+
 COMPILER_RT_ABI du_int
 __fixunssfdi(fp_t a) {
     return __fixuint(a);
 }
+
+#endif