[Builtin][ARM] #ifdef ARM vfp tests and cpu_model_tests

[weimingz]

Summary

Add in #ifdef to exclude cpu_model_test on non-X86 and *vfp_test on ARM targets without VFP support.

This is consistent with other target-specific tests that print "Skipped" if not supported.

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

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/addsf3vfp_test.c

 #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__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/cpu_model_test.c

 //===-- cpu_model_test.c - Test __builtin_cpu_supports -------------------------------===//
 //
 //                     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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file tests __builtin_cpu_supports for the compiler_rt library.
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: x86-target-arch
 
+#include <stdio.h>
+
 int main (void) {
+#if defined(i386) || defined(__x86_64__)
   if(__builtin_cpu_supports("avx2"))
     return 4;
   else
     return 3;
+#else
+  printf("skipped\n");
+  return 0;
+#endif
 }

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

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/divsf3vfp_test.c

 #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__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/eqdf2vfp_test.c

 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __eqdf2vfp(double a, double b);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/eqsf2vfp_test.c

 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __eqsf2vfp(float a, float b);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/extebdsfdf2vfp_test.c

 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI double __extendsfdf2vfp(float a);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/fixdfsivfp_test.c

 
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern int __fixdfsivfp(double a);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/fixsfsivfp_test.c

 
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern int __fixsfsivfp(float a);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/fixunsdfsivfp_test.c

 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI unsigned int __fixunsdfsivfp(double a);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/fixunssfsivfp_test.c

 
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern unsigned int __fixunssfsivfp(float a);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/floatsidfvfp_test.c

 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI double __floatsidfvfp(int a);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/floatsisfvfp_test.c

 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI float __floatsisfvfp(int a);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/floatunssidfvfp_test.c

 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI double __floatunssidfvfp(unsigned int a);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/floatunssisfvfp_test.c

 
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 #include "int_lib.h"
 
 extern COMPILER_RT_ABI float __floatunssisfvfp(unsigned int a);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/gedf2vfp_test.c

 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __gedf2vfp(double a, double b);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/gesf2vfp_test.c

 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __gesf2vfp(float a, float b);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/gtdf2vfp_test.c

 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __gtdf2vfp(double a, double b);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/gtsf2vfp_test.c

 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __gtsf2vfp(float a, float b);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/ledf2vfp_test.c

 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __ledf2vfp(double a, double b);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/lesf2vfp_test.c

 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __lesf2vfp(float a, float b);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/ltdf2vfp_test.c

 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __ltdf2vfp(double a, double b);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/ltsf2vfp_test.c

 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __ltsf2vfp(float a, float b);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/muldf3vfp_test.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/mulsf3vfp_test.c

 #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__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/nedf2vfp_test.c

 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __nedf2vfp(double a, double b);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/negdf2vfp_test.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/negsf2vfp_test.c

 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI float __negsf2vfp(float a);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/nesf2vfp_test.c

 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __nesf2vfp(float a, float b);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/subdf3vfp_test.c

 //===----------------------------------------------------------------------===//
 
 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/subsf3vfp_test.c

 #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__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/truncdfsf2vfp_test.c

 #include "int_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 
 
 extern COMPILER_RT_ABI float __truncdfsf2vfp(double a);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/unorddf2vfp_test.c

 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __unorddf2vfp(double a, double b);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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/trunk/test/builtins/Unit/unordsf2vfp_test.c

 #include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <math.h>
 
 
 extern int __unordsf2vfp(float a, float b);
 
-#if __arm__
+#if __arm__ && __VFP_FP__
 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__
+#if __arm__ && __VFP_FP__
     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;
 }