clang/test/SemaCXX/warn-memset-bad-sizeof.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-sizeof-array-argument %s
   2 //
   3 extern "C" void *bzero(void *, unsigned);
   4 extern "C" void *memset(void *, int, unsigned);
   5 extern "C" void *memmove(void *s1, const void *s2, unsigned n);
   6 extern "C" void *memcpy(void *s1, const void *s2, unsigned n);
   7 extern "C" void *memcmp(void *s1, const void *s2, unsigned n);
   8
   9 struct S {int a, b, c, d;};
  10 typedef S* PS;
  11
  12 struct Foo {};
  13 typedef const Foo& CFooRef;
  14 typedef const Foo CFoo;
  15 typedef volatile Foo VFoo;
  16 typedef const volatile Foo CVFoo;
  17
  18 typedef double Mat[4][4];
  19
  20 template <class Dest, class Source>
  21 inline Dest bit_cast(const Source& source) {
  22   Dest dest;
  23   memcpy(&dest, &source, sizeof(dest));
  24   return dest;
  25 }
  26
  27 // http://www.lysator.liu.se/c/c-faq/c-2.html#2-6
  28 void f(Mat m, const Foo& const_foo, char *buffer) {
  29   S s;
  30   S* ps = &s;
  31   PS ps2 = &s;
  32   char arr[5];
  33   char* parr[5];
  34   Foo foo;
  35   char* heap_buffer = new char[42];
  36
  37   /* Should warn */
  38   memset(&s, 0, sizeof(&s));  // \
  39       // 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)?}}
  40   memset(ps, 0, sizeof(ps));  // \
  41       // 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)?}}
  42   memset(ps2, 0, sizeof(ps2));  // \
  43       // 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)?}}
  44   memset(ps2, 0, sizeof(typeof(ps2)));  // \
  45       // expected-warning {{argument to 'sizeof' in 'memset' call is the same pointer type}}
  46   memset(ps2, 0, sizeof(PS));  // \
  47       // expected-warning {{argument to 'sizeof' in 'memset' call is the same pointer type}}
  48   memset(heap_buffer, 0, sizeof(heap_buffer));  // \
  49       // 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?}}
  50
  51   bzero(&s, sizeof(&s));  // \
  52       // 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)?}}
  53   bzero(ps, sizeof(ps));  // \
  54       // 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)?}}
  55   bzero(ps2, sizeof(ps2));  // \
  56       // 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)?}}
  57   bzero(ps2, sizeof(typeof(ps2)));  // \
  58       // expected-warning {{argument to 'sizeof' in 'bzero' call is the same pointer type}}
  59   bzero(ps2, sizeof(PS));  // \
  60       // expected-warning {{argument to 'sizeof' in 'bzero' call is the same pointer type}}
  61   bzero(heap_buffer, sizeof(heap_buffer));  // \
  62       // 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?}}
  63
  64   memcpy(&s, 0, sizeof(&s));  // \
  65       // 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)?}}
  66   memcpy(0, &s, sizeof(&s));  // \
  67       // 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)?}}
  68
  69   memmove(ps, 0, sizeof(ps));  // \
  70       // 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)?}}
  71   memcmp(ps, 0, sizeof(ps));  // \
  72       // 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)?}}
  73
  74   /* Shouldn't warn */
  75   memset((void*)&s, 0, sizeof(&s));
  76   memset(&s, 0, sizeof(s));
  77   memset(&s, 0, sizeof(S));
  78   memset(&s, 0, sizeof(const S));
  79   memset(&s, 0, sizeof(volatile S));
  80   memset(&s, 0, sizeof(volatile const S));
  81   memset(&foo, 0, sizeof(CFoo));
  82   memset(&foo, 0, sizeof(VFoo));
  83   memset(&foo, 0, sizeof(CVFoo));
  84   memset(ps, 0, sizeof(*ps));
  85   memset(ps2, 0, sizeof(*ps2));
  86   memset(ps2, 0, sizeof(typeof(*ps2)));
  87   memset(arr, 0, sizeof(arr));
  88   memset(parr, 0, sizeof(parr));
  89
  90   bzero((void*)&s, sizeof(&s));
  91   bzero(&s, sizeof(s));
  92   bzero(&s, sizeof(S));
  93   bzero(&s, sizeof(const S));
  94   bzero(&s, sizeof(volatile S));
  95   bzero(&s, sizeof(volatile const S));
  96   bzero(&foo, sizeof(CFoo));
  97   bzero(&foo, sizeof(VFoo));
  98   bzero(&foo, sizeof(CVFoo));
  99   bzero(ps, sizeof(*ps));
 100   bzero(ps2, sizeof(*ps2));
 101   bzero(ps2, sizeof(typeof(*ps2)));
 102   bzero(arr, sizeof(arr));
 103   bzero(parr, sizeof(parr));
 104
 105   memcpy(&foo, &const_foo, sizeof(Foo));
 106   memcpy((void*)&s, 0, sizeof(&s));
 107   memcpy(0, (void*)&s, sizeof(&s));
 108   char *cptr;
 109   memcpy(&cptr, buffer, sizeof(cptr));
 110   memcpy((char*)&cptr, buffer, sizeof(cptr));
 111
 112   CFooRef cfoo = foo;
 113   memcpy(&foo, &cfoo, sizeof(Foo));
 114
 115   memcpy(0, &arr, sizeof(arr));
 116   typedef char Buff[8];
 117   memcpy(0, &arr, sizeof(Buff));
 118
 119   unsigned char* puc;
 120   bit_cast<char*>(puc);
 121
 122   float* pf;
 123   bit_cast<int*>(pf);
 124
 125   int iarr[14];
 126   memset(&iarr[0], 0, sizeof iarr);
 127   memset(iarr, 0, sizeof iarr);
 128   bzero(&iarr[0], sizeof iarr);
 129   bzero(iarr, sizeof iarr);
 130
 131   int* iparr[14];
 132   memset(&iparr[0], 0, sizeof iparr);
 133   memset(iparr, 0, sizeof iparr);
 134   bzero(&iparr[0], sizeof iparr);
 135   bzero(iparr, sizeof iparr);
 136
 137   memset(m, 0, sizeof(Mat));
 138   bzero(m, sizeof(Mat));
 139
 140   // Copy to raw buffer shouldn't warn either
 141   memcpy(&foo, &arr, sizeof(Foo));
 142   memcpy(&arr, &foo, sizeof(Foo));
 143
 144   // Shouldn't warn, and shouldn't crash either.
 145   memset(({
 146     if (0) {}
 147     while (0) {}
 148     for (;;) {}
 149     &s;
 150   }), 0, sizeof(s));
 151
 152   bzero(({
 153     if (0) {}
 154     while (0) {}
 155     for (;;) {}
 156     &s;
 157   }), sizeof(s));
 158 }
 159
 160 namespace ns {
 161 void memset(void* s, char c, int n);
 162 void bzero(void* s, int n);
 163 void f(int* i) {
 164   memset(i, 0, sizeof(i));
 165   bzero(i, sizeof(i));
 166 }
 167 }
 168
 169 extern "C" int strncmp(const char *s1, const char *s2, unsigned n);
 170 extern "C" int strncasecmp(const char *s1, const char *s2, unsigned n);
 171 extern "C" char *strncpy(char *det, const char *src, unsigned n);
 172 extern "C" char *strncat(char *dst, const char *src, unsigned n);
 173 extern "C" char *strndup(const  char *src, unsigned n);
 174
 175 void strcpy_and_friends() {
 176   const char* FOO = "<- should be an array instead";
 177   const char* BAR = "<- this, too";
 178
 179   strncmp(FOO, BAR, sizeof(FOO)); // \
 180       // 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?}}
 181   strncasecmp(FOO, BAR, sizeof(FOO));  // \
 182       // 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?}}
 183
 184   char buff[80];
 185
 186   strncpy(buff, BAR, sizeof(BAR)); // \
 187       // 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?}}
 188   strndup(FOO, sizeof(FOO)); // \
 189       // 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?}}
 190 }