test/Sema/builtins.c

   1 // RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic -Wno-string-plus-int -triple=i686-apple-darwin9
   2 // This test needs to set the target because it uses __builtin_ia32_vec_ext_v4si
   3
   4 int test1(float a, int b) {
   5   return __builtin_isless(a, b);
   6 }
   7 int test2(int a, int b) {
   8   return __builtin_islessequal(a, b);  // expected-error {{floating point type}}
   9 }
  10
  11 int test3(double a, float b) {
  12   return __builtin_isless(a, b);
  13 }
  14 int test4(int* a, double b) {
  15   return __builtin_islessequal(a, b);  // expected-error {{floating point type}}
  16 }
  17
  18 int test5(float a, long double b) {
  19   return __builtin_isless(a, b, b);  // expected-error {{too many arguments}}
  20 }
  21 int test6(float a, long double b) {
  22   return __builtin_islessequal(a);  // expected-error {{too few arguments}}
  23 }
  24
  25
  26 #define CFSTR __builtin___CFStringMakeConstantString
  27 void test7() {
  28   const void *X;
  29   X = CFSTR("\242"); // expected-warning {{input conversion stopped}}
  30   X = CFSTR("\0"); // no-warning
  31   X = CFSTR(242); // expected-error {{CFString literal is not a string constant}} expected-warning {{incompatible integer to pointer conversion}}
  32   X = CFSTR("foo", "bar"); // expected-error {{too many arguments to function call}}
  33 }
  34
  35
  36 // atomics.
  37
  38 void test9(short v) {
  39   unsigned i, old;
  40
  41   old = __sync_fetch_and_add();  // expected-error {{too few arguments to function call}}
  42   old = __sync_fetch_and_add(&old);  // expected-error {{too few arguments to function call}}
  43   old = __sync_fetch_and_add((unsigned*)0, 42i); // expected-warning {{imaginary constants are an extension}}
  44
  45   // PR7600: Pointers are implicitly casted to integers and back.
  46   void *old_ptr = __sync_val_compare_and_swap((void**)0, 0, 0);
  47
  48   // Ensure the return type is correct even when implicit casts are stripped
  49   // away. This triggers an assertion while checking the comparison otherwise.
  50   if (__sync_fetch_and_add(&old, 1) == 1) {
  51   }
  52 }
  53
  54
  55 // rdar://7236819
  56 void test10(void) __attribute__((noreturn));
  57
  58 void test10(void) {
  59   __asm__("int3");
  60   __builtin_unreachable();
  61
  62   // No warning about falling off the end of a noreturn function.
  63 }
  64
  65 void test11(int X) {
  66   switch (X) {
  67   case __builtin_eh_return_data_regno(0):  // constant foldable.
  68     break;
  69   }
  70
  71   __builtin_eh_return_data_regno(X);  // expected-error {{argument to '__builtin_eh_return_data_regno' must be a constant integer}}
  72 }
  73
  74 // PR5062
  75 void test12(void) __attribute__((__noreturn__));
  76 void test12(void) {
  77   __builtin_trap();  // no warning because trap is noreturn.
  78 }
  79
  80 void test_unknown_builtin(int a, int b) {
  81   __builtin_isles(a, b); // expected-error{{use of unknown builtin}} \
  82                          // expected-note{{did you mean '__builtin_isless'?}}
  83 }
  84
  85 int test13() {
  86   __builtin_eh_return(0, 0); // no warning, eh_return never returns.
  87 }
  88
  89 // <rdar://problem/8228293>
  90 void test14() {
  91   int old;
  92   old = __sync_fetch_and_min((volatile int *)&old, 1);
  93 }
  94
  95 // <rdar://problem/8336581>
  96 void test15(const char *s) {
  97   __builtin_printf("string is %s\n", s);
  98 }
  99
 100 // PR7885
 101 int test16() {
 102   return __builtin_constant_p() + // expected-error{{too few arguments}}
 103          __builtin_constant_p(1, 2); // expected-error {{too many arguments}}
 104 }
 105
 106 const int test17_n = 0;
 107 const char test17_c[] = {1, 2, 3, 0};
 108 const char test17_d[] = {1, 2, 3, 4};
 109 typedef int __attribute__((vector_size(16))) IntVector;
 110 struct Aggregate { int n; char c; };
 111 enum Enum { EnumValue1, EnumValue2 };
 112
 113 typedef __typeof(sizeof(int)) size_t;
 114 size_t strlen(const char *);
 115
 116 void test17() {
 117 #define ASSERT(...) { int arr[(__VA_ARGS__) ? 1 : -1]; }
 118 #define T(...) ASSERT(__builtin_constant_p(__VA_ARGS__))
 119 #define F(...) ASSERT(!__builtin_constant_p(__VA_ARGS__))
 120
 121   // __builtin_constant_p returns 1 if the argument folds to:
 122   //  - an arithmetic constant with value which is known at compile time
 123   T(test17_n);
 124   T(&test17_c[3] - test17_c);
 125   T(3i + 5); // expected-warning {{imaginary constant}}
 126   T(4.2 * 7.6);
 127   T(EnumValue1);
 128   T((enum Enum)(int)EnumValue2);
 129
 130   //  - the address of the first character of a string literal, losslessly cast
 131   //    to any type
 132   T("string literal");
 133   T((double*)"string literal");
 134   T("string literal" + 0);
 135   T((long)"string literal");
 136
 137   // ... and otherwise returns 0.
 138   F("string literal" + 1);
 139   F(&test17_n);
 140   F(test17_c);
 141   F(&test17_c);
 142   F(&test17_d);
 143   F((struct Aggregate){0, 1});
 144   F((IntVector){0, 1, 2, 3});
 145
 146   // Ensure that a technique used in glibc is handled correctly.
 147 #define OPT(...) (__builtin_constant_p(__VA_ARGS__) && strlen(__VA_ARGS__) < 4)
 148   // FIXME: These are incorrectly treated as ICEs because strlen is treated as
 149   // a builtin.
 150   ASSERT(OPT("abc"));
 151   ASSERT(!OPT("abcd"));
 152   // In these cases, the strlen is non-constant, but the __builtin_constant_p
 153   // is 0: the array size is not an ICE but is foldable.
 154   ASSERT(!OPT(test17_c));        // expected-warning {{folded}}
 155   ASSERT(!OPT(&test17_c[0]));    // expected-warning {{folded}}
 156   ASSERT(!OPT((char*)test17_c)); // expected-warning {{folded}}
 157   ASSERT(!OPT(test17_d));        // expected-warning {{folded}}
 158   ASSERT(!OPT(&test17_d[0]));    // expected-warning {{folded}}
 159   ASSERT(!OPT((char*)test17_d)); // expected-warning {{folded}}
 160
 161 #undef OPT
 162 #undef T
 163 #undef F
 164 }