blob: 0a78caa924ea95a1468f25bbb09066bb2e20d491 [file] [log] [blame]
// RUN: %clang_cc1 -fsyntax-only -verify -Wno-sizeof-array-argument %s
//
extern "C" void *bzero(void *, unsigned);
extern "C" void *memset(void *, int, unsigned);
extern "C" void *memmove(void *s1, const void *s2, unsigned n);
extern "C" void *memcpy(void *s1, const void *s2, unsigned n);
extern "C" void *memcmp(void *s1, const void *s2, unsigned n);
struct S {int a, b, c, d;};
typedef S* PS;
struct Foo {};
typedef const Foo& CFooRef;
typedef const Foo CFoo;
typedef volatile Foo VFoo;
typedef const volatile Foo CVFoo;
typedef double Mat[4][4];
template <class Dest, class Source>
inline Dest bit_cast(const Source& source) {
Dest dest;
memcpy(&dest, &source, sizeof(dest));
return dest;
}
// http://www.lysator.liu.se/c/c-faq/c-2.html#2-6
void f(Mat m, const Foo& const_foo, char *buffer) {
S s;
S* ps = &s;
PS ps2 = &s;
char arr[5];
char* parr[5];
Foo foo;
char* heap_buffer = new char[42];
/* Should warn */
memset(&s, 0, sizeof(&s)); // \
// expected-warning {{'memset' call operates on objects of type 'S' while the size is based on a different type 'S *'}} expected-note{{did you mean to remove the addressof in the argument to 'sizeof' (and multiply it by the number of elements)?}}
memset(ps, 0, sizeof(ps)); // \
// expected-warning {{'memset' call operates on objects of type 'S' while the size is based on a different type 'S *'}} expected-note{{did you mean to dereference the argument to 'sizeof' (and multiply it by the number of elements)?}}
memset(ps2, 0, sizeof(ps2)); // \
// expected-warning {{'memset' call operates on objects of type 'S' while the size is based on a different type 'PS' (aka 'S *')}} expected-note{{did you mean to dereference the argument to 'sizeof' (and multiply it by the number of elements)?}}
memset(ps2, 0, sizeof(typeof(ps2))); // \
// expected-warning {{argument to 'sizeof' in 'memset' call is the same pointer type}}
memset(ps2, 0, sizeof(PS)); // \
// expected-warning {{argument to 'sizeof' in 'memset' call is the same pointer type}}
memset(heap_buffer, 0, sizeof(heap_buffer)); // \
// expected-warning {{'memset' call operates on objects of type 'char' while the size is based on a different type 'char *'}} expected-note{{did you mean to provide an explicit length?}}
bzero(&s, sizeof(&s)); // \
// expected-warning {{'bzero' call operates on objects of type 'S' while the size is based on a different type 'S *'}} expected-note{{did you mean to remove the addressof in the argument to 'sizeof' (and multiply it by the number of elements)?}}
bzero(ps, sizeof(ps)); // \
// expected-warning {{'bzero' call operates on objects of type 'S' while the size is based on a different type 'S *'}} expected-note{{did you mean to dereference the argument to 'sizeof' (and multiply it by the number of elements)?}}
bzero(ps2, sizeof(ps2)); // \
// expected-warning {{'bzero' call operates on objects of type 'S' while the size is based on a different type 'PS' (aka 'S *')}} expected-note{{did you mean to dereference the argument to 'sizeof' (and multiply it by the number of elements)?}}
bzero(ps2, sizeof(typeof(ps2))); // \
// expected-warning {{argument to 'sizeof' in 'bzero' call is the same pointer type}}
bzero(ps2, sizeof(PS)); // \
// expected-warning {{argument to 'sizeof' in 'bzero' call is the same pointer type}}
bzero(heap_buffer, sizeof(heap_buffer)); // \
// expected-warning {{'bzero' call operates on objects of type 'char' while the size is based on a different type 'char *'}} expected-note{{did you mean to provide an explicit length?}}
memcpy(&s, 0, sizeof(&s)); // \
// expected-warning {{'memcpy' call operates on objects of type 'S' while the size is based on a different type 'S *'}} expected-note{{did you mean to remove the addressof in the argument to 'sizeof' (and multiply it by the number of elements)?}}
memcpy(0, &s, sizeof(&s)); // \
// expected-warning {{'memcpy' call operates on objects of type 'S' while the size is based on a different type 'S *'}} expected-note{{did you mean to remove the addressof in the argument to 'sizeof' (and multiply it by the number of elements)?}}
memmove(ps, 0, sizeof(ps)); // \
// expected-warning {{'memmove' call operates on objects of type 'S' while the size is based on a different type 'S *'}} expected-note{{did you mean to dereference the argument to 'sizeof' (and multiply it by the number of elements)?}}
memcmp(ps, 0, sizeof(ps)); // \
// expected-warning {{'memcmp' call operates on objects of type 'S' while the size is based on a different type 'S *'}} expected-note{{did you mean to dereference the argument to 'sizeof' (and multiply it by the number of elements)?}}
/* Shouldn't warn */
memset((void*)&s, 0, sizeof(&s));
memset(&s, 0, sizeof(s));
memset(&s, 0, sizeof(S));
memset(&s, 0, sizeof(const S));
memset(&s, 0, sizeof(volatile S));
memset(&s, 0, sizeof(volatile const S));
memset(&foo, 0, sizeof(CFoo));
memset(&foo, 0, sizeof(VFoo));
memset(&foo, 0, sizeof(CVFoo));
memset(ps, 0, sizeof(*ps));
memset(ps2, 0, sizeof(*ps2));
memset(ps2, 0, sizeof(typeof(*ps2)));
memset(arr, 0, sizeof(arr));
memset(parr, 0, sizeof(parr));
bzero((void*)&s, sizeof(&s));
bzero(&s, sizeof(s));
bzero(&s, sizeof(S));
bzero(&s, sizeof(const S));
bzero(&s, sizeof(volatile S));
bzero(&s, sizeof(volatile const S));
bzero(&foo, sizeof(CFoo));
bzero(&foo, sizeof(VFoo));
bzero(&foo, sizeof(CVFoo));
bzero(ps, sizeof(*ps));
bzero(ps2, sizeof(*ps2));
bzero(ps2, sizeof(typeof(*ps2)));
bzero(arr, sizeof(arr));
bzero(parr, sizeof(parr));
memcpy(&foo, &const_foo, sizeof(Foo));
memcpy((void*)&s, 0, sizeof(&s));
memcpy(0, (void*)&s, sizeof(&s));
char *cptr;
memcpy(&cptr, buffer, sizeof(cptr));
memcpy((char*)&cptr, buffer, sizeof(cptr));
CFooRef cfoo = foo;
memcpy(&foo, &cfoo, sizeof(Foo));
memcpy(0, &arr, sizeof(arr));
typedef char Buff[8];
memcpy(0, &arr, sizeof(Buff));
unsigned char* puc;
bit_cast<char*>(puc);
float* pf;
bit_cast<int*>(pf);
int iarr[14];
memset(&iarr[0], 0, sizeof iarr);
memset(iarr, 0, sizeof iarr);
bzero(&iarr[0], sizeof iarr);
bzero(iarr, sizeof iarr);
int* iparr[14];
memset(&iparr[0], 0, sizeof iparr);
memset(iparr, 0, sizeof iparr);
bzero(&iparr[0], sizeof iparr);
bzero(iparr, sizeof iparr);
memset(m, 0, sizeof(Mat));
bzero(m, sizeof(Mat));
// Copy to raw buffer shouldn't warn either
memcpy(&foo, &arr, sizeof(Foo));
memcpy(&arr, &foo, sizeof(Foo));
// Shouldn't warn, and shouldn't crash either.
memset(({
if (0) {}
while (0) {}
for (;;) {}
&s;
}), 0, sizeof(s));
bzero(({
if (0) {}
while (0) {}
for (;;) {}
&s;
}), sizeof(s));
}
namespace ns {
void memset(void* s, char c, int n);
void bzero(void* s, int n);
void f(int* i) {
memset(i, 0, sizeof(i));
bzero(i, sizeof(i));
}
}
extern "C" int strncmp(const char *s1, const char *s2, unsigned n);
extern "C" int strncasecmp(const char *s1, const char *s2, unsigned n);
extern "C" char *strncpy(char *det, const char *src, unsigned n);
extern "C" char *strncat(char *dst, const char *src, unsigned n);
extern "C" char *strndup(const char *src, unsigned n);
void strcpy_and_friends() {
const char* FOO = "<- should be an array instead";
const char* BAR = "<- this, too";
strncmp(FOO, BAR, sizeof(FOO)); // \
// expected-warning {{'strncmp' call operates on objects of type 'const char' while the size is based on a different type 'const char *'}} expected-note{{did you mean to provide an explicit length?}}
strncasecmp(FOO, BAR, sizeof(FOO)); // \
// expected-warning {{'strncasecmp' call operates on objects of type 'const char' while the size is based on a different type 'const char *'}} expected-note{{did you mean to provide an explicit length?}}
char buff[80];
strncpy(buff, BAR, sizeof(BAR)); // \
// expected-warning {{'strncpy' call operates on objects of type 'const char' while the size is based on a different type 'const char *'}} expected-note{{did you mean to provide an explicit length?}}
strndup(FOO, sizeof(FOO)); // \
// expected-warning {{'strndup' call operates on objects of type 'const char' while the size is based on a different type 'const char *'}} expected-note{{did you mean to provide an explicit length?}}
}