// RUN: %clang_cc1 %s -fsyntax-only -verify -pedantic -Wstrlcpy-strlcat-size -Wno-string-plus-int -triple=i686-apple-darwin9
// This test needs to set the target because it uses __builtin_ia32_vec_ext_v4si

int test1(float a, int b) {
  return __builtin_isless(a, b); // expected-note {{declared here}}
}
int test2(int a, int b) {
  return __builtin_islessequal(a, b);  // expected-error {{floating point type}}
}

int test3(double a, float b) {
  return __builtin_isless(a, b);
}
int test4(int* a, double b) {
  return __builtin_islessequal(a, b);  // expected-error {{floating point type}}
}

int test5(float a, long double b) {
  return __builtin_isless(a, b, b);  // expected-error {{too many arguments}}
}
int test6(float a, long double b) {
  return __builtin_islessequal(a);  // expected-error {{too few arguments}}
}


#define CFSTR __builtin___CFStringMakeConstantString
void test7() {
  const void *X;
  X = CFSTR("\242"); // expected-warning {{input conversion stopped}}
  X = CFSTR("\0"); // no-warning
  X = CFSTR(242); // expected-error {{CFString literal is not a string constant}} expected-warning {{incompatible integer to pointer conversion}}
  X = CFSTR("foo", "bar"); // expected-error {{too many arguments to function call}}
}


// atomics.

void test9(short v) {
  unsigned i, old;

  old = __sync_fetch_and_add();  // expected-error {{too few arguments to function call}}
  old = __sync_fetch_and_add(&old);  // expected-error {{too few arguments to function call}}
  old = __sync_fetch_and_add((unsigned*)0, 42i); // expected-warning {{imaginary constants are a GNU extension}}

  // PR7600: Pointers are implicitly casted to integers and back.
  void *old_ptr = __sync_val_compare_and_swap((void**)0, 0, 0);

  // Ensure the return type is correct even when implicit casts are stripped
  // away. This triggers an assertion while checking the comparison otherwise.
  if (__sync_fetch_and_add(&old, 1) == 1) {
  }
}

// overloaded atomics should be declared only once.
void test9_1(volatile int* ptr, int val) {
  __sync_fetch_and_add_4(ptr, val);
}
void test9_2(volatile int* ptr, int val) {
  __sync_fetch_and_add(ptr, val);
}
void test9_3(volatile int* ptr, int val) {
  __sync_fetch_and_add_4(ptr, val);
  __sync_fetch_and_add(ptr, val);
  __sync_fetch_and_add(ptr, val);
  __sync_fetch_and_add_4(ptr, val);
  __sync_fetch_and_add_4(ptr, val);
}

void test9_4(volatile int* ptr, int val) {
  // expected-warning@+1 {{the semantics of this intrinsic changed with GCC version 4.4 - the newer semantics are provided here}}
  __sync_fetch_and_nand(ptr, val);
}

// rdar://7236819
void test10(void) __attribute__((noreturn));

void test10(void) {
  __asm__("int3");
  __builtin_unreachable();

  // No warning about falling off the end of a noreturn function.
}

void test11(int X) {
  switch (X) {
  case __builtin_eh_return_data_regno(0):  // constant foldable.
    break;
  }

  __builtin_eh_return_data_regno(X);  // expected-error {{argument to '__builtin_eh_return_data_regno' must be a constant integer}}
}

// PR5062
void test12(void) __attribute__((__noreturn__));
void test12(void) {
  __builtin_trap();  // no warning because trap is noreturn.
}

void test_unknown_builtin(int a, int b) {
  __builtin_isles(a, b); // expected-error{{use of unknown builtin}} \
                         // expected-note{{did you mean '__builtin_isless'?}}
}

int test13() {
  __builtin_eh_return(0, 0); // no warning, eh_return never returns.
}

// <rdar://problem/8228293>
void test14() {
  int old;
  old = __sync_fetch_and_min((volatile int *)&old, 1);
}

// <rdar://problem/8336581>
void test15(const char *s) {
  __builtin_printf("string is %s\n", s);
}

// PR7885
int test16() {
  return __builtin_constant_p() + // expected-error{{too few arguments}}
         __builtin_constant_p(1, 2); // expected-error {{too many arguments}}
}

const int test17_n = 0;
const char test17_c[] = {1, 2, 3, 0};
const char test17_d[] = {1, 2, 3, 4};
typedef int __attribute__((vector_size(16))) IntVector;
struct Aggregate { int n; char c; };
enum Enum { EnumValue1, EnumValue2 };

typedef __typeof(sizeof(int)) size_t;
size_t strlen(const char *);

void test17() {
#define ASSERT(...) { int arr[(__VA_ARGS__) ? 1 : -1]; }
#define T(...) ASSERT(__builtin_constant_p(__VA_ARGS__))
#define F(...) ASSERT(!__builtin_constant_p(__VA_ARGS__))

  // __builtin_constant_p returns 1 if the argument folds to:
  //  - an arithmetic constant with value which is known at compile time
  T(test17_n);
  T(&test17_c[3] - test17_c);
  T(3i + 5); // expected-warning {{imaginary constant}}
  T(4.2 * 7.6);
  T(EnumValue1);
  T((enum Enum)(int)EnumValue2);

  //  - the address of the first character of a string literal, losslessly cast
  //    to any type
  T("string literal");
  T((double*)"string literal");
  T("string literal" + 0);
  T((long)"string literal");

  // ... and otherwise returns 0.
  F("string literal" + 1);
  F(&test17_n);
  F(test17_c);
  F(&test17_c);
  F(&test17_d);
  F((struct Aggregate){0, 1});
  F((IntVector){0, 1, 2, 3});

  // Ensure that a technique used in glibc is handled correctly.
#define OPT(...) (__builtin_constant_p(__VA_ARGS__) && strlen(__VA_ARGS__) < 4)
  // FIXME: These are incorrectly treated as ICEs because strlen is treated as
  // a builtin.
  ASSERT(OPT("abc"));
  ASSERT(!OPT("abcd"));
  // In these cases, the strlen is non-constant, but the __builtin_constant_p
  // is 0: the array size is not an ICE but is foldable.
  ASSERT(!OPT(test17_c));        // expected-warning {{folded}}
  ASSERT(!OPT(&test17_c[0]));    // expected-warning {{folded}}
  ASSERT(!OPT((char*)test17_c)); // expected-warning {{folded}}
  ASSERT(!OPT(test17_d));        // expected-warning {{folded}}
  ASSERT(!OPT(&test17_d[0]));    // expected-warning {{folded}}
  ASSERT(!OPT((char*)test17_d)); // expected-warning {{folded}}

#undef OPT
#undef T
#undef F
}

void test18() {
  char src[1024];
  char dst[2048];
  size_t result;
  void *ptr;

  ptr = __builtin___memccpy_chk(dst, src, '\037', sizeof(src), sizeof(dst));
  result = __builtin___strlcpy_chk(dst, src, sizeof(dst), sizeof(dst));
  result = __builtin___strlcat_chk(dst, src, sizeof(dst), sizeof(dst));

  ptr = __builtin___memccpy_chk(dst, src, '\037', sizeof(src));      // expected-error {{too few arguments to function call}}
  ptr = __builtin___strlcpy_chk(dst, src, sizeof(dst), sizeof(dst)); // expected-warning {{incompatible integer to pointer conversion}}
  ptr = __builtin___strlcat_chk(dst, src, sizeof(dst), sizeof(dst)); // expected-warning {{incompatible integer to pointer conversion}}
}

void no_ms_builtins() {
  __assume(1); // expected-warning {{implicit declaration}}
  __noop(1); // expected-warning {{implicit declaration}}
  __debugbreak(); // expected-warning {{implicit declaration}}
}

void unavailable() {
  __builtin_operator_new(0); // expected-error {{'__builtin_operator_new' is only available in C++}}
  __builtin_operator_delete(0); // expected-error {{'__builtin_operator_delete' is only available in C++}}
}

// rdar://18259539
size_t strlcpy(char * restrict dst, const char * restrict src, size_t size);
size_t strlcat(char * restrict dst, const char * restrict src, size_t size);

void Test19(void)
{
        static char b[40];
        static char buf[20];

        strlcpy(buf, b, sizeof(b)); // expected-warning {{size argument in 'strlcpy' call appears to be size of the source; expected the size of the destination}} \\
                                    // expected-note {{change size argument to be the size of the destination}}
        __builtin___strlcpy_chk(buf, b, sizeof(b), __builtin_object_size(buf, 0)); // expected-warning {{size argument in '__builtin___strlcpy_chk' call appears to be size of the source; expected the size of the destination}} \
                                    // expected-note {{change size argument to be the size of the destination}} \
				    // expected-warning {{'__builtin___strlcpy_chk' will always overflow destination buffer}}

        strlcat(buf, b, sizeof(b)); // expected-warning {{size argument in 'strlcat' call appears to be size of the source; expected the size of the destination}} \
                                    // expected-note {{change size argument to be the size of the destination}}
				    
        __builtin___strlcat_chk(buf, b, sizeof(b), __builtin_object_size(buf, 0)); // expected-warning {{size argument in '__builtin___strlcat_chk' call appears to be size of the source; expected the size of the destination}} \
                                                                                   // expected-note {{change size argument to be the size of the destination}} \
				                                                   // expected-warning {{'__builtin___strlcat_chk' will always overflow destination buffer}}
}

// rdar://11076881
char * Test20(char *p, const char *in, unsigned n)
{
    static char buf[10];

    __builtin___memcpy_chk (&buf[6], in, 5, __builtin_object_size (&buf[6], 0)); // expected-warning {{'__builtin___memcpy_chk' will always overflow destination buffer}}

    __builtin___memcpy_chk (p, "abcde", n, __builtin_object_size (p, 0));

    __builtin___memcpy_chk (&buf[5], "abcde", 5, __builtin_object_size (&buf[5], 0));

    __builtin___memcpy_chk (&buf[5], "abcde", n, __builtin_object_size (&buf[5], 0));

    __builtin___memcpy_chk (&buf[6], "abcde", 5, __builtin_object_size (&buf[6], 0)); // expected-warning {{'__builtin___memcpy_chk' will always overflow destination buffer}}

    return buf;
}