gcc/testsuite/gcc.dg/torture/builtin-attr-1.c

   1 /* Copyright (C) 2003  Free Software Foundation.
   2
   3    Verify that the `const' function attribute is applied to various
   4    builtins and that these functions are optimized away by the
   5    compiler under the appropriate circumstances.
   6
   7    Written by Kaveh Ghazi, 2003-08-04.  */
   8
   9 /* { dg-do link } */
  10 /* { dg-options "-ffast-math" } */
  11
  12 /* These are helper macros to test combinations of functions.  We test
  13    foo() != foo() with the same arguments, and expect the compiler to
  14    optimize away these tests of const functions.  */
  15
  16 /* Just test the __builtin_ functions.  */
  17 #define BUILTIN_TEST1(FN, TYPE) \
  18 extern void link_failure_builtin_##FN(void); \
  19 void test_builtin_##FN(TYPE x) \
  20 { if (__builtin_##FN(x) != __builtin_##FN(x)) link_failure_builtin_##FN(); }
  21
  22 /* Just test the __builtin_ functions.  */
  23 #define BUILTIN_TEST2(FN, TYPE) \
  24 extern void link_failure_builtin_##FN(void); \
  25 void test_builtin_##FN(TYPE x, TYPE y) \
  26 { if (__builtin_##FN(x,y) != __builtin_##FN(x,y)) link_failure_builtin_##FN(); }
  27
  28 /* Also test the regular (non-__builtin_) function.  */
  29 #define TEST1(FN, TYPE) \
  30 BUILTIN_TEST1(FN, TYPE) \
  31 extern void link_failure_##FN(void); \
  32 void test_##FN(TYPE x) { if (FN(x) != FN(x)) link_failure_##FN(); }
  33
  34 /* Test the __builtin_ functions taking void arguments (with the "f"
  35    and "l" variants).  */
  36 #define BUILTIN_FPTEST0(FN) \
  37 extern void link_failure_builtin_##FN(void); \
  38 extern void link_failure_builtin_##FN##f(void); \
  39 extern void link_failure_builtin_##FN##l(void); \
  40 void test_builtin_##FN(void) \
  41 { if (__builtin_##FN() != __builtin_##FN()) link_failure_builtin_##FN(); } \
  42 void test_builtin_##FN##f(void) \
  43 { if (__builtin_##FN##f() != __builtin_##FN##f()) link_failure_builtin_##FN##f(); } \
  44 void test_builtin_##FN##l(void) \
  45 { if (__builtin_##FN##l() != __builtin_##FN##l()) link_failure_builtin_##FN##l(); }
  46
  47 /* Test the __builtin_ functions taking one FP argument (with the "f"
  48    and "l" variants).  */
  49 #define BUILTIN_FPTEST1(FN) \
  50 extern void link_failure_builtin_##FN(void); \
  51 extern void link_failure_builtin_##FN##f(void); \
  52 extern void link_failure_builtin_##FN##l(void); \
  53 void test_builtin_##FN(double d) \
  54 { if (__builtin_##FN(d) != __builtin_##FN(d)) link_failure_builtin_##FN(); } \
  55 void test_builtin_##FN##f(float f) \
  56 { if (__builtin_##FN##f(f) != __builtin_##FN##f(f)) link_failure_builtin_##FN##f(); } \
  57 void test_builtin_##FN##l(long double ld) \
  58 { if (__builtin_##FN##l(ld) != __builtin_##FN##l(ld)) link_failure_builtin_##FN##l(); }
  59
  60 /* Test the __builtin_ functions taking one argument of supplied type
  61    (with the "f" and "l" variants).  */
  62 #define BUILTIN_FPTEST1ARG(FN, TYPE) \
  63 extern void link_failure_builtin_##FN(void); \
  64 extern void link_failure_builtin_##FN##f(void); \
  65 extern void link_failure_builtin_##FN##l(void); \
  66 void test_builtin_##FN(TYPE x) \
  67 { if (__builtin_##FN(x) != __builtin_##FN(x)) link_failure_builtin_##FN(); } \
  68 void test_builtin_##FN##f(TYPE x) \
  69 { if (__builtin_##FN##f(x) != __builtin_##FN##f(x)) link_failure_builtin_##FN##f(); } \
  70 void test_builtin_##FN##l(TYPE x) \
  71 { if (__builtin_##FN##l(x) != __builtin_##FN##l(x)) link_failure_builtin_##FN##l(); }
  72
  73 /* Test the __builtin_ functions taking two FP arguments (with the "f"
  74    and "l" variants).  */
  75 #define BUILTIN_FPTEST2(FN) \
  76 extern void link_failure_builtin_##FN(void); \
  77 extern void link_failure_builtin_##FN##f(void); \
  78 extern void link_failure_builtin_##FN##l(void); \
  79 void test_builtin_##FN(double d1, double d2) \
  80 { if (__builtin_##FN(d1,d2) != __builtin_##FN(d1,d2)) link_failure_builtin_##FN(); } \
  81 void test_builtin_##FN##f(float f1, float f2) \
  82 { if (__builtin_##FN##f(f1,f2) != __builtin_##FN##f(f1,f2)) link_failure_builtin_##FN##f(); } \
  83 void test_builtin_##FN##l(long double ld1, long double ld2) \
  84 { if (__builtin_##FN##l(ld1,ld2) != __builtin_##FN##l(ld1,ld2)) link_failure_builtin_##FN##l(); }
  85
  86 /* Test the __builtin_ functions taking two arguments, one FP and one
  87    supplied type (with the "f" and "l" variants).  */
  88 #define BUILTIN_FPTEST2ARG(FN, TYPE) \
  89 extern void link_failure_builtin_##FN(void); \
  90 extern void link_failure_builtin_##FN##f(void); \
  91 extern void link_failure_builtin_##FN##l(void); \
  92 void test_builtin_##FN(double d, TYPE x) \
  93 { if (__builtin_##FN(d,x) != __builtin_##FN(d,x)) link_failure_builtin_##FN(); } \
  94 void test_builtin_##FN##f(float f, TYPE x) \
  95 { if (__builtin_##FN##f(f,x) != __builtin_##FN##f(f,x)) link_failure_builtin_##FN##f(); } \
  96 void test_builtin_##FN##l(long double ld, TYPE x) \
  97 { if (__builtin_##FN##l(ld,x) != __builtin_##FN##l(ld,x)) link_failure_builtin_##FN##l(); }
  98
  99 /* Test the __builtin_ functions taking three FP arguments (with the
 100    "f" and "l" variants).  */
 101 #define BUILTIN_FPTEST3(FN) \
 102 extern void link_failure_builtin_##FN(void); \
 103 extern void link_failure_builtin_##FN##f(void); \
 104 extern void link_failure_builtin_##FN##l(void); \
 105 void test_builtin_##FN(double d1, double d2, double d3) \
 106 { if (__builtin_##FN(d1,d2,d3) != __builtin_##FN(d1,d2,d3)) link_failure_builtin_##FN(); } \
 107 void test_builtin_##FN##f(float f1, float f2, float f3) \
 108 { if (__builtin_##FN##f(f1,f2,f3) != __builtin_##FN##f(f1,f2,f3)) link_failure_builtin_##FN##f(); } \
 109 void test_builtin_##FN##l(long double ld1, long double ld2, long double ld3) \
 110 { if (__builtin_##FN##l(ld1,ld2,ld3) != __builtin_##FN##l(ld1,ld2,ld3)) link_failure_builtin_##FN##l(); }
 111
 112 /* These macros additionally test the non-__builtin_ functions.  */
 113
 114 /* Test the functions taking one FP argument (with the "f" and "l"
 115    variants).  */
 116 #define FPTEST1(FN) \
 117 BUILTIN_FPTEST1(FN) \
 118 extern void link_failure_##FN(void); \
 119 extern void link_failure_##FN##f(void); \
 120 extern void link_failure_##FN##l(void); \
 121 void test_##FN(double d) \
 122 { if (FN(d) != FN(d)) link_failure_##FN(); } \
 123 void test_##FN##f(float f) \
 124 { if (FN##f(f) != FN##f(f)) link_failure_##FN##f(); } \
 125 void test_##FN##l(long double ld) \
 126 { if (FN##l(ld) != FN##l(ld)) link_failure_##FN##l(); }
 127
 128 /* Test the functions taking two FP arguments (with the "f" and "l"
 129    variants).  */
 130 #define FPTEST2(FN) \
 131 BUILTIN_FPTEST2(FN) \
 132 extern void link_failure_##FN(void); \
 133 extern void link_failure_##FN##f(void); \
 134 extern void link_failure_##FN##l(void); \
 135 void test_##FN(double d1, double d2) \
 136 { if (FN(d1,d2) != FN(d1,d2)) link_failure_##FN(); } \
 137 void test_##FN##f(float f1, float f2) \
 138 { if (FN##f(f1,f2) != FN##f(f1,f2)) link_failure_##FN##f(); } \
 139 void test_##FN##l(long double ld1, long double ld2) \
 140 { if (FN##l(ld1,ld2) != FN##l(ld1,ld2)) link_failure_##FN##l(); }
 141
 142 /* Test the functions taking two arguments, one FP and one of supplied
 143    type (with the "f" and "l" variants).  */
 144 #define FPTEST2ARG(FN, TYPE) \
 145 BUILTIN_FPTEST2ARG(FN, TYPE) \
 146 extern void link_failure_##FN(void); \
 147 extern void link_failure_##FN##f(void); \
 148 extern void link_failure_##FN##l(void); \
 149 void test_##FN(double d, TYPE x) \
 150 { if (FN(d,x) != FN(d,x)) link_failure_##FN(); } \
 151 void test_##FN##f(float f, TYPE x) \
 152 { if (FN##f(f,x) != FN##f(f,x)) link_failure_##FN##f(); } \
 153 void test_##FN##l(long double ld, TYPE x) \
 154 { if (FN##l(ld,x) != FN##l(ld,x)) link_failure_##FN##l(); }
 155
 156 /* Test the functions taking three FP arguments (with the "f" and "l"
 157    variants).  */
 158 #define FPTEST3(FN) \
 159 BUILTIN_FPTEST3(FN) \
 160 extern void link_failure_##FN(void); \
 161 extern void link_failure_##FN##f(void); \
 162 extern void link_failure_##FN##l(void); \
 163 void test_##FN(double d1, double d2, double d3) \
 164 { if (FN(d1,d2,d3) != FN(d1,d2,d3)) link_failure_##FN(); } \
 165 void test_##FN##f(float f1, float f2, float f3) \
 166 { if (FN##f(f1,f2,f3) != FN##f(f1,f2,f3)) link_failure_##FN##f(); } \
 167 void test_##FN##l(long double ld1, long double ld2, long double ld3) \
 168 { if (FN##l(ld1,ld2,ld3) != FN##l(ld1,ld2,ld3)) link_failure_##FN##l(); }
 169
 170
 171 /* Test the math builtins.  */
 172 FPTEST1            (acos)
 173 FPTEST1            (acosh)
 174 FPTEST1            (asin)
 175 FPTEST1            (asinh)
 176 FPTEST1            (atan)
 177 FPTEST2            (atan2)
 178 FPTEST1            (atanh)
 179 FPTEST1            (cbrt)
 180 FPTEST1            (ceil)
 181 FPTEST2            (copysign)
 182 FPTEST1            (cos)
 183 FPTEST1            (cosh)
 184 FPTEST2            (drem)
 185 FPTEST1            (exp)
 186 FPTEST1            (exp10)
 187 FPTEST1            (exp2)
 188 FPTEST1            (expm1)
 189 FPTEST1            (fabs)
 190 FPTEST2            (fdim)
 191 FPTEST1            (floor)
 192 FPTEST3            (fma)
 193 FPTEST2            (fmax)
 194 FPTEST2            (fmin)
 195 FPTEST2            (fmod)
 196 BUILTIN_FPTEST0    (huge_val)
 197 FPTEST2            (hypot)
 198 FPTEST1            (ilogb)
 199 BUILTIN_FPTEST0    (inf)
 200 FPTEST2ARG         (ldexp, int)
 201 FPTEST1            (llrint)
 202 FPTEST1            (llround)
 203 FPTEST1            (log)
 204 FPTEST1            (log10)
 205 FPTEST1            (log1p)
 206 FPTEST1            (log2)
 207 FPTEST1            (logb)
 208 FPTEST1            (lrint)
 209 FPTEST1            (lround)
 210 BUILTIN_FPTEST1ARG (nan, char *)
 211 BUILTIN_FPTEST1ARG (nans, char *)
 212 FPTEST1            (nearbyint)
 213 FPTEST2            (nextafter)
 214 FPTEST2            (nexttoward)
 215 FPTEST2            (pow)
 216 FPTEST1            (pow10)
 217 FPTEST2            (remainder)
 218 FPTEST1            (rint)
 219 FPTEST1            (round)
 220 FPTEST2            (scalb)
 221 FPTEST2ARG         (scalbln, int)
 222 FPTEST2ARG         (scalbn, int)
 223 FPTEST1            (sin)
 224 FPTEST1            (sinh)
 225 FPTEST1            (sqrt)
 226 FPTEST1            (tan)
 227 FPTEST1            (tanh)
 228 FPTEST1            (trunc)
 229
 230 /* Various other const builtins.  */
 231 TEST1         (abs, int)
 232 BUILTIN_TEST1 (clz, int)
 233 BUILTIN_TEST1 (clzl, long)
 234 BUILTIN_TEST1 (clzll, long long)
 235 BUILTIN_TEST1 (ctz, int)
 236 BUILTIN_TEST1 (ctzl, long)
 237 BUILTIN_TEST1 (ctzll, long long)
 238 TEST1         (ffs, int)
 239 TEST1         (ffsl, long)
 240 TEST1         (ffsll, long long)
 241 TEST1         (imaxabs, int)
 242 TEST1         (labs, long)
 243 TEST1         (llabs, long long)
 244 BUILTIN_TEST1 (parity, int)
 245 BUILTIN_TEST1 (parityl, long)
 246 BUILTIN_TEST1 (parityll, long long)
 247 BUILTIN_TEST1 (popcount, int)
 248 BUILTIN_TEST1 (popcountl, long)
 249 BUILTIN_TEST1 (popcountll, long long)
 250
 251 int main(void)
 252 {
 253   return 0;
 254 }