[compiler-rt] Replaced __SOFT_FP__ with __SOFTFP__

[kamleshbhalui]

Summary

https://bugs.llvm.org/show_bug.cgi?id=46294
As described in above bug.

in compiler-rt at few places we

__SOFT_FP__

macro used, but never defined any where
either by compiler or config files.

But I do find a similar macro

__SOFTFP__

(missing middle underscore) which defined by compiler.
so in this patch I replaced former macro with latter.

[MaskRay]

Please upload with full diff diff -U9999, or use arc diff --head=HEAD 'HEAD~1'

If the original code intends to target __SOFTFP__ (compiler defined macro), then these are indeed typo errors. It seems that __SOFT_FP__ is used to pick different implementations. It is likely that the #ifdef __SOFT_FP__ branches are never executed, so the potential correctness/accuracy issues may never be exposed. Even if __SOFT_FP__ uses are indeed typo errors (I am unsure as I can't find __SOFTFP__ in libgcc sources), we should test these on ARM softfp machines to ensure nothing breaks.

[psmith]

I think that this is highly likely to be a typo, it looks like it dates to the contribution of compiler-rt so there isn't any history we can use. I believe that compiler-rt builtins originated in Apple so there is a possibility that SOFTFP was used in the compiler at contribution time. If you wanted to be safe you could support both SOFTFP and SOFT_FP but I don't think that is necessary. I would like to think that for a soft-fp target the tests for these functions fail or are at least xfailed at the moment. Are you able to compile the tests for a soft-fp target to check?

[MaskRay]

Ping @kamleshbhalui

I hope your or some reviewer can test the buildability on ARM.

[psmith]

In D82014#2180015, @MaskRay wrote:

Ping @kamleshbhalui

I hope your or some reviewer can test the buildability on ARM.

If I get some time this week(end) I'll make a soft-float build. I don't want to hold the change up by insisting we test on a soft-float Arm. I am interested in whether these functions are tested at all in that case, which we ought to follow up with if they are not.

[atrosinenko]

In D82014#2182436, @psmith wrote:

In D82014#2180015, @MaskRay wrote:

Ping @kamleshbhalui

I hope your or some reviewer can test the buildability on ARM.

If I get some time this week(end) I'll make a soft-float build. I don't want to hold the change up by insisting we test on a soft-float Arm. I am interested in whether these functions are tested at all in that case, which we ought to follow up with if they are not.

In case it may be relevant, I faced something like this while trying to port the builtins library of compiler-rt to MSP430. At some point, I was debugging failing unit tests and spotted some functions not expecting the soft-float by default. That time I just conditionally #defined the __SOFT_FP__ macro in int_lib.h for MSP430 target and eventually made all the XPASS tests pass.

PS: msp430-elf-gcc provided by TI seems not to define such a macro:

echo | msp430-elf-gcc -E -dM - | grep SOFT
<prints nothing>

compiler-rt/lib/builtins/fixdfdi.c

 //===-- fixdfdi.c - Implement __fixdfdi -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #define DOUBLE_PRECISION
 #include "fp_lib.h"
 
-#ifndef __SOFT_FP__
+#ifndef __SOFTFP__
 // 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);

compiler-rt/lib/builtins/fixsfdi.c

 //===-- fixsfdi.c - Implement __fixsfdi -----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #define SINGLE_PRECISION
 #include "fp_lib.h"
 
-#ifndef __SOFT_FP__
+#ifndef __SOFTFP__
 // 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);

compiler-rt/lib/builtins/fixunsdfdi.c

 //===-- fixunsdfdi.c - Implement __fixunsdfdi -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #define DOUBLE_PRECISION
 #include "fp_lib.h"
 
-#ifndef __SOFT_FP__
+#ifndef __SOFTFP__
 // 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) {
   if (a <= 0.0)
     return 0;
   su_int high = a / 4294967296.f;               // a / 0x1p32f;
   su_int low = a - (double)high * 4294967296.f; // high * 0x1p32f;

compiler-rt/lib/builtins/fixunssfdi.c

 //===-- fixunssfdi.c - Implement __fixunssfdi -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #define SINGLE_PRECISION
 #include "fp_lib.h"
 
-#ifndef __SOFT_FP__
+#ifndef __SOFTFP__
 // 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) {
   if (a <= 0.0f)
     return 0;
   double da = a;
   su_int high = da / 4294967296.f;               // da / 0x1p32f;

compiler-rt/lib/builtins/floatdidf.c

 // Returns: convert a to a double, rounding toward even.
 
 // Assumption: double is a IEEE 64 bit floating point type
 //             di_int is a 64 bit integral type
 
 // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 // mmmm
 
-#ifndef __SOFT_FP__
+#ifndef __SOFTFP__
 // Support for systems that have hardware floating-point; we'll set the inexact
 // flag as a side-effect of this computation.
 
 COMPILER_RT_ABI double __floatdidf(di_int a) {
   static const double twop52 = 4503599627370496.0; // 0x1.0p52
   static const double twop32 = 4294967296.0;       // 0x1.0p32
 
   union {

compiler-rt/lib/builtins/floatundidf.c

 // Assumption: double is a IEEE 64 bit floating point type
 //             du_int is a 64 bit integral type
 
 // seee eeee eeee mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm mmmm mmmm
 // mmmm
 
 #include "int_lib.h"
 
-#ifndef __SOFT_FP__
+#ifndef __SOFTFP__
 // Support for systems that have hardware floating-point; we'll set the inexact
 // flag as a side-effect of this computation.
 
 COMPILER_RT_ABI double __floatundidf(du_int a) {
   static const double twop52 = 4503599627370496.0;           // 0x1.0p52
   static const double twop84 = 19342813113834066795298816.0; // 0x1.0p84
   static const double twop84_plus_twop52 =
       19342813118337666422669312.0; // 0x1.00000001p84