[builtins][ARM] Check __ARM_FP instead of __VFP_FP__.

[chaosdefinition]

Summary

This patch fixes builtins' CMakeLists.txt and their VFP tests to check the standard macro defined in the ACLE for VFP support. It also enables the tests to be built and run for single-precision-only targets while builtins were built with double-precision support.

[compnerd]

Following the ACLE is definitely preferable. One thing to verify is if gcc does support this correctly as well. IIRC, it does support __ARM_FP properly and this should be safe, but please do verify that.

[chaosdefinition]

In D92497#2429662, @compnerd wrote:

Following the ACLE is definitely preferable. One thing to verify is if gcc does support this correctly as well. IIRC, it does support __ARM_FP properly and this should be safe, but please do verify that.

Thank you for reviewing! I checked the source code of gcc 5.1.0 (current minimum supported version to build LLVM) and it does support __ARM_FP.

compiler-rt/lib/builtins/CMakeLists.txt

if(NOT ANDROID)
     append_list_if(COMPILER_RT_HAS_VISIBILITY_HIDDEN_FLAG VISIBILITY_HIDDEN BUILTIN_DEFS)
   endif()
 
   foreach (arch ${BUILTIN_SUPPORTED_ARCH})
     if (CAN_TARGET_${arch})
       # For ARM archs, exclude any VFP builtins if VFP is not supported
       if (${arch} MATCHES "^(arm|armhf|armv7|armv7s|armv7k|armv7m|armv7em)$")
         string(REPLACE ";" " " _TARGET_${arch}_CFLAGS "${TARGET_${arch}_CFLAGS}")
-        check_compile_definition(__VFP_FP__ "${CMAKE_C_FLAGS} ${_TARGET_${arch}_CFLAGS}" COMPILER_RT_HAS_${arch}_VFP)
+        check_compile_definition(__ARM_FP "${CMAKE_C_FLAGS} ${_TARGET_${arch}_CFLAGS}" COMPILER_RT_HAS_${arch}_VFP)
         if(NOT COMPILER_RT_HAS_${arch}_VFP)
           list(REMOVE_ITEM ${arch}_SOURCES ${arm_Thumb1_VFPv2_DP_SOURCES} ${arm_Thumb1_VFPv2_SP_SOURCES} ${arm_Thumb1_SjLj_EH_SOURCES})
         else()
           # Exclude any double-precision builtins if VFP is single-precision-only
           check_c_source_compiles("#if !(__ARM_FP & 0x8)
                                    #error No double-precision support!
                                    #endif
                                    int main() { return 0; }" COMPILER_RT_HAS_${arch}_VFP_DP)

compiler-rt/test/builtins/Unit/adddf3vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_adddf3vfp
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 extern COMPILER_RT_ABI double __adddf3vfp(double a, double b);
 
 int test__adddf3vfp(double a, double b)
 {
     double actual = __adddf3vfp(a, b);
     double expected = a + b;
     if (actual != expected)
         printf("error in test__adddf3vfp(%f, %f) = %f, expected %f\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__adddf3vfp(1.0, 1.0))
         return 1;
     if (test__adddf3vfp(HUGE_VAL, HUGE_VAL))
         return 1;
     if (test__adddf3vfp(0.0, HUGE_VAL))
         return 1;
     if (test__adddf3vfp(0.0, -0.0))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/addsf3vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_addsf3vfp
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI float __addsf3vfp(float a, float b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
 int test__addsf3vfp(float a, float b)
 {
     float actual = __addsf3vfp(a, b);
     float expected = a + b;
     if (actual != expected)
         printf("error in test__addsf3vfp(%f, %f) = %f, expected %f\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
     if (test__addsf3vfp(1.0, 1.0))
         return 1;
     if (test__addsf3vfp(HUGE_VALF, HUGE_VALF))
         return 1;
     if (test__addsf3vfp(0.0, HUGE_VALF))
         return 1;
     if (test__addsf3vfp(0.0, -0.0))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/divdf3vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_divdf3vfp
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 extern COMPILER_RT_ABI double __divdf3vfp(double a, double b);
 
 int test__divdf3vfp(double a, double b)
 {
     double actual = __divdf3vfp(a, b);
     double expected = a / b;
     if (actual != expected)
         printf("error in test__divdf3vfp(%f, %f) = %f, expected %f\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__divdf3vfp(1.0, 1.0))
         return 1;
     if (test__divdf3vfp(12345.678, 1.23))
         return 1;
     if (test__divdf3vfp(-10.0, 0.25))
         return 1;
     if (test__divdf3vfp(10.0, -2.0))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/divsf3vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_divsf3vfp
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI float __divsf3vfp(float a, float b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
 int test__divsf3vfp(float a, float b)
 {
     float actual = __divsf3vfp(a, b);
     float expected = a / b;
     if (actual != expected)
         printf("error in test__divsf3vfp(%f, %f) = %f, expected %f\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
     if (test__divsf3vfp(1.0, 1.0))
         return 1;
     if (test__divsf3vfp(12345.678, 1.23))
         return 1;
     if (test__divsf3vfp(0.0, HUGE_VALF))
         return 1;
     if (test__divsf3vfp(10.0, -2.0))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/eqdf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_eqdf2vfp
 
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __eqdf2vfp(double a, double b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 int test__eqdf2vfp(double a, double b)
 {
     int actual = __eqdf2vfp(a, b);
   int expected = (a == b) ? 1 : 0;
     if (actual != expected)
         printf("error in __eqdf2vfp(%f, %f) = %d, expected %d\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__eqdf2vfp(0.0, 0.0))
         return 1;
     if (test__eqdf2vfp(1.0, 1.0))
         return 1;
     if (test__eqdf2vfp(0.0, 1.0))
         return 1;
     if (test__eqdf2vfp(-1.0, -1.0))
         return 1;

compiler-rt/test/builtins/Unit/eqsf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_eqsf2vfp
 
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __eqsf2vfp(float a, float b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
 int test__eqsf2vfp(float a, float b)
 {
     int actual = __eqsf2vfp(a, b);
   int expected = (a == b) ? 1 : 0;
     if (actual != expected)
         printf("error in __eqsf2vfp(%f, %f) = %d, expected %d\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
     if (test__eqsf2vfp(0.0, 0.0))
         return 1;
     if (test__eqsf2vfp(1.0, 1.0))
         return 1;
     if (test__eqsf2vfp(-1.0, -1.0))
         return 1;
     if (test__eqsf2vfp(HUGE_VALF, 1.0))
         return 1;
     if (test__eqsf2vfp(1.0, HUGE_VALF))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/extendsfdf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_extendsfdf2vfp
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI double __extendsfdf2vfp(float a);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 int test__extendsfdf2vfp(float a)
 {
     double actual = __extendsfdf2vfp(a);
     double expected = a;
     if (actual != expected)
         printf("error in test__extendsfdf2vfp(%f) = %f, expected %f\n",
                a, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__extendsfdf2vfp(0.0))
         return 1;
     if (test__extendsfdf2vfp(1.0))
         return 1;
     if (test__extendsfdf2vfp(-1.0))
         return 1;
     if (test__extendsfdf2vfp(3.1415926535))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/fixdfsivfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_fixdfsivfp
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern int __fixdfsivfp(double a);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 int test__fixdfsivfp(double a)
 {
   int actual = __fixdfsivfp(a);
   int expected = a;
     if (actual != expected)
         printf("error in test__fixdfsivfp(%f) = %d, expected %d\n",
                a, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__fixdfsivfp(0.0))
         return 1;
     if (test__fixdfsivfp(1.0))
         return 1;
     if (test__fixdfsivfp(-1.0))
         return 1;
     if (test__fixdfsivfp(2147483647))
         return 1;
     if (test__fixdfsivfp(-2147483648.0))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/fixsfsivfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_fixsfsivfp
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern int __fixsfsivfp(float a);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
 int test__fixsfsivfp(float a)
 {
   int actual = __fixsfsivfp(a);
   int expected = a;
     if (actual != expected)
         printf("error in test__fixsfsivfp(%f) = %u, expected %u\n",
                a, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
     if (test__fixsfsivfp(0.0))
         return 1;
     if (test__fixsfsivfp(1.0))
         return 1;
     if (test__fixsfsivfp(-1.0))
         return 1;
     if (test__fixsfsivfp(2147483647.0))
         return 1;

compiler-rt/test/builtins/Unit/fixunsdfsivfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_fixunsdfsivfp
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI unsigned int __fixunsdfsivfp(double a);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 int test__fixunsdfsivfp(double a)
 {
     unsigned int actual = __fixunsdfsivfp(a);
     unsigned int expected = a;
     if (actual != expected)
         printf("error in test__fixunsdfsivfp(%f) = %u, expected %u\n",
                a, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__fixunsdfsivfp(0.0))
         return 1;
     if (test__fixunsdfsivfp(1.0))
         return 1;
     if (test__fixunsdfsivfp(-1.0))
         return 1;
     if (test__fixunsdfsivfp(4294967295.0))
         return 1;
     if (test__fixunsdfsivfp(65536.0))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/fixunssfsivfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_fixunssfsivfp
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern unsigned int __fixunssfsivfp(float a);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
 int test__fixunssfsivfp(float a)
 {
     unsigned int actual = __fixunssfsivfp(a);
     unsigned int expected = a;
     if (actual != expected)
         printf("error in test__fixunssfsivfp(%f) = %u, expected %u\n",
                a, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
     if (test__fixunssfsivfp(0.0))
         return 1;
     if (test__fixunssfsivfp(1.0))
         return 1;
     if (test__fixunssfsivfp(-1.0))
         return 1;
     if (test__fixunssfsivfp(4294967295.0))
         return 1;
     if (test__fixunssfsivfp(65536.0))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/floatsidfvfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_floatsidfvfp
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI double __floatsidfvfp(int a);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 int test__floatsidfvfp(int a)
 {
     double actual = __floatsidfvfp(a);
     double expected = a;
     if (actual != expected)
         printf("error in test__ floatsidfvfp(%d) = %f, expected %f\n",
                a, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__floatsidfvfp(0))
         return 1;
     if (test__floatsidfvfp(1))
         return 1;
     if (test__floatsidfvfp(-1))
         return 1;
     if (test__floatsidfvfp(0x7FFFFFFF))
         return 1;
     if (test__floatsidfvfp(0x80000000))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/floatsisfvfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_floatsisfvfp
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI float __floatsisfvfp(int a);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
 int test__floatsisfvfp(int a)
 {
     float actual = __floatsisfvfp(a);
     float expected = a;
     if (actual != expected)
         printf("error in test__floatsisfvfp(%d) = %f, expected %f\n",
                a, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
     if (test__floatsisfvfp(0))
         return 1;
     if (test__floatsisfvfp(1))
         return 1;
     if (test__floatsisfvfp(-1))
         return 1;
     if (test__floatsisfvfp(0x7FFFFFFF))
         return 1;
     if (test__floatsisfvfp(0x80000000))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/floatunssidfvfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_floatunssidfvfp
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI double __floatunssidfvfp(unsigned int a);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 int test__floatunssidfvfp(unsigned int a)
 {
     double actual = __floatunssidfvfp(a);
     double expected = a;
     if (actual != expected)
         printf("error in test__floatunssidfvfp(%u) = %f, expected %f\n",
                a, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__floatunssidfvfp(0))
         return 1;
     if (test__floatunssidfvfp(1))
         return 1;
     if (test__floatunssidfvfp(0x7FFFFFFF))
         return 1;
     if (test__floatunssidfvfp(0x80000000))
         return 1;
     if (test__floatunssidfvfp(0xFFFFFFFF))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/floatunssisfvfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_floatunssisfvfp
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 #include "int_lib.h"
 
 extern COMPILER_RT_ABI float __floatunssisfvfp(unsigned int a);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
 int test__floatunssisfvfp(unsigned int a)
 {
     float actual = __floatunssisfvfp(a);
     float expected = a;
     if (actual != expected)
         printf("error in test__floatunssisfvfp(%u) = %f, expected %f\n",
                a, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
     if (test__floatunssisfvfp(0))
         return 1;
     if (test__floatunssisfvfp(1))
         return 1;
     if (test__floatunssisfvfp(0x7FFFFFFF))
         return 1;
     if (test__floatunssisfvfp(0x80000000))
         return 1;
     if (test__floatunssisfvfp(0xFFFFFFFF))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/gedf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_gedf2vfp
 
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __gedf2vfp(double a, double b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 int test__gedf2vfp(double a, double b)
 {
     int actual = __gedf2vfp(a, b);
   int expected = (a >= b) ? 1 : 0;
     if (actual != expected)
         printf("error in __gedf2vfp(%f, %f) = %d, expected %d\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__gedf2vfp(0.0, 0.0))
         return 1;
     if (test__gedf2vfp(1.0, 0.0))
         return 1;
     if (test__gedf2vfp(-1.0, -2.0))
         return 1;
     if (test__gedf2vfp(-2.0, -1.0))
         return 1;

compiler-rt/test/builtins/Unit/gesf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_gesf2vfp
 
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __gesf2vfp(float a, float b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
 int test__gesf2vfp(float a, float b)
 {
     int actual = __gesf2vfp(a, b);
   int expected = (a >= b) ? 1 : 0;
     if (actual != expected)
         printf("error in __gesf2vfp(%f, %f) = %d, expected %d\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
     if (test__gesf2vfp(0.0, 0.0))
         return 1;
     if (test__gesf2vfp(1.1, 1.0))
         return 1;
     if (test__gesf2vfp(-1.0, -2.0))
         return 1;
     if (test__gesf2vfp(-2.0, -1.0))
         return 1;

compiler-rt/test/builtins/Unit/gtdf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_gtdf2vfp
 
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __gtdf2vfp(double a, double b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 int test__gtdf2vfp(double a, double b)
 {
     int actual = __gtdf2vfp(a, b);
   int expected = (a > b) ? 1 : 0;
     if (actual != expected)
         printf("error in __gtdf2vfp(%f, %f) = %d, expected %d\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__gtdf2vfp(0.0, 0.0))
         return 1;
     if (test__gtdf2vfp(1.0, 0.0))
         return 1;
     if (test__gtdf2vfp(-1.0, -2.0))
         return 1;
     if (test__gtdf2vfp(-2.0, -1.0))
         return 1;

compiler-rt/test/builtins/Unit/gtsf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_gtsf2vfp
 
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __gtsf2vfp(float a, float b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
 int test__gtsf2vfp(float a, float b)
 {
     int actual = __gtsf2vfp(a, b);
   int expected = (a > b) ? 1 : 0;
     if (actual != expected)
         printf("error in __gtsf2vfp(%f, %f) = %d, expected %d\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
     if (test__gtsf2vfp(0.0, 0.0))
         return 1;
     if (test__gtsf2vfp(1.0, 0.0))
         return 1;
     if (test__gtsf2vfp(-1.0, -2.0))
         return 1;
     if (test__gtsf2vfp(-2.0, -1.0))
         return 1;

compiler-rt/test/builtins/Unit/ledf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_ledf2vfp
 
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __ledf2vfp(double a, double b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 int test__ledf2vfp(double a, double b)
 {
     int actual = __ledf2vfp(a, b);
   int expected = (a <= b) ? 1 : 0;
     if (actual != expected)
         printf("error in __ledf2vfp(%f, %f) = %d, expected %d\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__ledf2vfp(0.0, 0.0))
         return 1;
     if (test__ledf2vfp(1.0, 1.0))
         return 1;
     if (test__ledf2vfp(-1.0, -2.0))
         return 1;
     if (test__ledf2vfp(-2.0, -1.0))
         return 1;

compiler-rt/test/builtins/Unit/lesf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_lesf2vfp
 
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __lesf2vfp(float a, float b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
 int test__lesf2vfp(float a, float b)
 {
     int actual = __lesf2vfp(a, b);
   int expected = (a <= b) ? 1 : 0;
     if (actual != expected)
         printf("error in __lesf2vfp(%f, %f) = %d, expected %d\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
     if (test__lesf2vfp(0.0, 0.0))
         return 1;
     if (test__lesf2vfp(1.0, 1.0))
         return 1;
     if (test__lesf2vfp(-1.0, -2.0))
         return 1;
     if (test__lesf2vfp(-2.0, -1.0))
         return 1;

compiler-rt/test/builtins/Unit/ltdf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_ltdf2vfp
 
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __ltdf2vfp(double a, double b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 int test__ltdf2vfp(double a, double b)
 {
     int actual = __ltdf2vfp(a, b);
   int expected = (a < b) ? 1 : 0;
     if (actual != expected)
         printf("error in __ltdf2vfp(%f, %f) = %d, expected %d\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__ltdf2vfp(0.0, 0.0))
         return 1;
     if (test__ltdf2vfp(1.0, 1.0))
         return 1;
     if (test__ltdf2vfp(-1.0, -1.0))
         return 1;
     if (test__ltdf2vfp(HUGE_VAL, 1.0))
         return 1;
     if (test__ltdf2vfp(1.0, HUGE_VAL))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/ltsf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_ltsf2vfp
 
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __ltsf2vfp(float a, float b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
 int test__ltsf2vfp(float a, float b)
 {
     int actual = __ltsf2vfp(a, b);
   int expected = (a < b) ? 1 : 0;
     if (actual != expected)
         printf("error in __ltsf2vfp(%f, %f) = %d, expected %d\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
     if (test__ltsf2vfp(0.0, 0.0))
         return 1;
     if (test__ltsf2vfp(-1.0, 1.0))
         return 1;
     if (test__ltsf2vfp(-1.0, -2.0))
         return 1;
     if (test__ltsf2vfp(-2.0, -1.0))
         return 1;

compiler-rt/test/builtins/Unit/muldf3vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_muldf3vfp
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 extern COMPILER_RT_ABI double __muldf3vfp(double a, double b);
 
 int test__muldf3vfp(double a, double b)
 {
     double actual = __muldf3vfp(a, b);
     double expected = a * b;
     if (actual != expected)
         printf("error in test__muldf3vfp(%f, %f) = %f, expected %f\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__muldf3vfp(0.5, 10.0))
         return 1;
     if (test__muldf3vfp(-0.5, -2.0))
         return 1;
     if (test__muldf3vfp(HUGE_VALF, 0.25))
         return 1;
     if (test__muldf3vfp(-0.125, HUGE_VALF))
         return 1;
     if (test__muldf3vfp(0.0, -0.0))
     return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/mulsf3vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_mulsf3vfp
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI float __mulsf3vfp(float a, float b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
 int test__mulsf3vfp(float a, float b)
 {
     float actual = __mulsf3vfp(a, b);
     float expected = a * b;
     if (actual != expected)
         printf("error in test__mulsf3vfp(%f, %f) = %f, expected %f\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
     if (test__mulsf3vfp(0.5, 10.0))
         return 1;
     if (test__mulsf3vfp(-0.5, -2.0))
         return 1;
     if (test__mulsf3vfp(HUGE_VALF, 0.25))
         return 1;
     if (test__mulsf3vfp(-0.125, HUGE_VALF))
         return 1;
     if (test__mulsf3vfp(0.0, -0.0))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/nedf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_nedf2vfp
 
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __nedf2vfp(double a, double b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 int test__nedf2vfp(double a, double b)
 {
     int actual = __nedf2vfp(a, b);
   int expected = (a != b) ? 1 : 0;
     if (actual != expected)
         printf("error in __nedf2vfp(%f, %f) = %d, expected %d\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__nedf2vfp(0.0, 0.0))
         return 1;
     if (test__nedf2vfp(1.0, 1.0))
         return 1;
     if (test__nedf2vfp(-1.0, -1.0))
         return 1;
     if (test__nedf2vfp(HUGE_VAL, 1.0))
         return 1;
     if (test__nedf2vfp(1.0, HUGE_VAL))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/negdf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_negdf2vfp
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 extern COMPILER_RT_ABI double __negdf2vfp(double a);
 
 int test__negdf2vfp(double a)
 {
     double actual = __negdf2vfp(a);
     double expected = -a;
     if (actual != expected)
         printf("error in test__negdf2vfp(%f) = %f, expected %f\n",
                a, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__negdf2vfp(1.0))
         return 1;
     if (test__negdf2vfp(HUGE_VALF))
         return 1;
     if (test__negdf2vfp(0.0))
         return 1;
     if (test__negdf2vfp(-1.0))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/negsf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_negsf2vfp
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI float __negsf2vfp(float a);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
 int test__negsf2vfp(float a)
 {
     float actual = __negsf2vfp(a);
     float expected = -a;
     if (actual != expected)
         printf("error in test__negsf2vfp(%f) = %f, expected %f\n",
                a, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
     if (test__negsf2vfp(1.0))
         return 1;
     if (test__negsf2vfp(HUGE_VALF))
         return 1;
     if (test__negsf2vfp(0.0))
         return 1;
     if (test__negsf2vfp(-1.0))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/nesf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_nesf2vfp
 
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __nesf2vfp(float a, float b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
 int test__nesf2vfp(float a, float b)
 {
     int actual = __nesf2vfp(a, b);
   int expected = (a != b) ? 1 : 0;
     if (actual != expected)
         printf("error in __nesf2vfp(%f, %f) = %d, expected %d\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
     if (test__nesf2vfp(0.0, 0.0))
         return 1;
     if (test__nesf2vfp(1.0, 1.0))
         return 1;
     if (test__nesf2vfp(-1.0, -1.0))
         return 1;
     if (test__nesf2vfp(HUGE_VALF, 1.0))
         return 1;
     if (test__nesf2vfp(1.0, HUGE_VALF))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/subdf3vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_subdf3vfp
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 extern COMPILER_RT_ABI double __subdf3vfp(double a, double b);
 
 int test__subdf3vfp(double a, double b)
 {
     double actual = __subdf3vfp(a, b);
     double expected = a - b;
     if (actual != expected)
         printf("error in test__subdf3vfp(%f, %f) = %f, expected %f\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__subdf3vfp(1.0, 1.0))
         return 1;
     if (test__subdf3vfp(1234.567, 765.4321))
         return 1;
     if (test__subdf3vfp(-123.0, -678.0))
         return 1;
     if (test__subdf3vfp(0.0, -0.0))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/subsf3vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_subsf3vfp
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI float __subsf3vfp(float a, float b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
 int test__subsf3vfp(float a, float b)
 {
     float actual = __subsf3vfp(a, b);
     float expected = a - b;
     if (actual != expected)
         printf("error in test__subsf3vfp(%f, %f) = %f, expected %f\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
     if (test__subsf3vfp(1.0, 1.0))
         return 1;
     if (test__subsf3vfp(1234.567, 765.4321))
         return 1;
     if (test__subsf3vfp(-123.0, -678.0))
         return 1;
     if (test__subsf3vfp(0.0, -0.0))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/truncdfsf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_truncdfsf2vfp
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI float __truncdfsf2vfp(double a);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 int test__truncdfsf2vfp(double a)
 {
     float actual = __truncdfsf2vfp(a);
     float expected = a;
     if (actual != expected)
         printf("error in test__truncdfsf2vfp(%f) = %f, expected %f\n",
                a, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__truncdfsf2vfp(0.0))
         return 1;
     if (test__truncdfsf2vfp(1.0))
         return 1;
     if (test__truncdfsf2vfp(-1.0))
         return 1;
     if (test__truncdfsf2vfp(3.1415926535))
         return 1;
     if (test__truncdfsf2vfp(123.456))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/unorddf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_unorddf2vfp
 
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __unorddf2vfp(double a, double b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
 int test__unorddf2vfp(double a, double b)
 {
     int actual = __unorddf2vfp(a, b);
   int expected = (isnan(a) || isnan(b)) ? 1 : 0;
     if (actual != expected)
         printf("error in __unorddf2vfp(%f, %f) = %d, expected %d\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x8)
     if (test__unorddf2vfp(0.0, NAN))
         return 1;
     if (test__unorddf2vfp(NAN, 1.0))
         return 1;
     if (test__unorddf2vfp(NAN, NAN))
         return 1;
     if (test__unorddf2vfp(1.0, 1.0))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }

compiler-rt/test/builtins/Unit/unordsf2vfp_test.c

 // RUN: %clang_builtins %s %librt -o %t && %run %t
 // REQUIRES: librt_has_unordsf2vfp
 
 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __unordsf2vfp(float a, float b);
 
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
 int test__unordsf2vfp(float a, float b)
 {
     int actual = __unordsf2vfp(a, b);
   int expected = (isnan(a) || isnan(b)) ? 1 : 0;
     if (actual != expected)
         printf("error in __unordsf2vfp(%f, %f) = %d, expected %d\n",
                a, b, actual, expected);
     return actual != expected;
 }
 #endif
 
 int main()
 {
-#if __arm__ && __VFP_FP__
+#if defined(__arm__) && defined(__ARM_FP) && (__ARM_FP & 0x4)
     if (test__unordsf2vfp(0.0, NAN))
         return 1;
     if (test__unordsf2vfp(NAN, 1.0))
         return 1;
     if (test__unordsf2vfp(NAN, NAN))
         return 1;
     if (test__unordsf2vfp(1.0, 1.0))
         return 1;
 #else
     printf("skipped\n");
 #endif
     return 0;
 }