clang/test/Analysis/placement-new.cpp

   1 // RUN: %clang_analyze_cc1 -std=c++11 %s \
   2 // RUN:   -analyzer-checker=core \
   3 // RUN:   -analyzer-checker=cplusplus.NewDelete \
   4 // RUN:   -analyzer-checker=cplusplus.PlacementNew \
   5 // RUN:   -analyzer-output=text -verify \
   6 // RUN:   -triple x86_64-unknown-linux-gnu
   7
   8 #include "Inputs/system-header-simulator-cxx.h"
   9
  10 void f() {
  11   short s;                    // expected-note {{'s' declared without an initial value}}
  12   long *lp = ::new (&s) long; // expected-warning{{Storage provided to placement new is only 2 bytes, whereas the allocated type requires 8 bytes}} expected-note 3 {{}}
  13   (void)lp;
  14 }
  15
  16 namespace testArrayNew {
  17 void f() {
  18   short s;                        // expected-note {{'s' declared without an initial value}}
  19   char *buf = ::new (&s) char[8]; // expected-warning{{Storage provided to placement new is only 2 bytes, whereas the allocated type requires 8 bytes}} expected-note 3 {{}}
  20   (void)buf;
  21 }
  22 } // namespace testArrayNew
  23
  24 namespace testBufferInOtherFun {
  25 void f(void *place) {
  26   long *lp = ::new (place) long; // expected-warning{{Storage provided to placement new is only 2 bytes, whereas the allocated type requires 8 bytes}} expected-note 1 {{}}
  27   (void)lp;
  28 }
  29 void g() {
  30   short buf; // expected-note {{'buf' declared without an initial value}}
  31   f(&buf);   // expected-note 2 {{}}
  32 }
  33 } // namespace testBufferInOtherFun
  34
  35 namespace testArrayBuffer {
  36 void f(void *place) {
  37   long *lp = ::new (place) long; // expected-warning{{Storage provided to placement new is only 2 bytes, whereas the allocated type requires 8 bytes}} expected-note 1 {{}}
  38   (void)lp;
  39 }
  40 void g() {
  41   char buf[2]; // expected-note {{'buf' initialized here}}
  42   f(&buf);     // expected-note 2 {{}}
  43 }
  44 } // namespace testArrayBuffer
  45
  46 namespace testGlobalPtrAsPlace {
  47 void *gptr = nullptr;
  48 short gs;
  49 void f() {
  50   gptr = &gs; // expected-note {{Value assigned to 'gptr'}}
  51 }
  52 void g() {
  53   f();                          // expected-note 2 {{}}
  54   long *lp = ::new (gptr) long; // expected-warning{{Storage provided to placement new is only 2 bytes, whereas the allocated type requires 8 bytes}} expected-note 1 {{}}
  55   (void)lp;
  56 }
  57 } // namespace testGlobalPtrAsPlace
  58
  59 namespace testRvalue {
  60 short gs;
  61 void *f() {
  62   return &gs;
  63 }
  64 void g() {
  65   long *lp = ::new (f()) long; // expected-warning{{Storage provided to placement new is only 2 bytes, whereas the allocated type requires 8 bytes}} expected-note 1 {{}}
  66   (void)lp;
  67 }
  68 } // namespace testRvalue
  69
  70 namespace testNoWarning {
  71 void *f();
  72 void g() {
  73   long *lp = ::new (f()) long;
  74   (void)lp;
  75 }
  76 } // namespace testNoWarning
  77
  78 namespace testPtrToArrayAsPlace {
  79 void f() {
  80   //char *st = new char [8];
  81   char buf[3];                // expected-note {{'buf' initialized here}}
  82   void *st = buf;             // expected-note {{'st' initialized here}}
  83   long *lp = ::new (st) long; // expected-warning{{Storage provided to placement new is only 3 bytes, whereas the allocated type requires 8 bytes}} expected-note 1 {{}}
  84   (void)lp;
  85 }
  86 } // namespace testPtrToArrayAsPlace
  87
  88 namespace testPtrToArrayWithOffsetAsPlace {
  89 void f() {
  90   int buf[3];                      // expected-note {{'buf' initialized here}}
  91   long *lp = ::new (buf + 2) long; // expected-warning{{Storage provided to placement new is only 4 bytes, whereas the allocated type requires 8 bytes}} expected-note 1 {{}}
  92   (void)lp;
  93 }
  94 } // namespace testPtrToArrayWithOffsetAsPlace
  95
  96 namespace testZeroSize {
  97 void f() {
  98   int buf[3];                      // expected-note {{'buf' initialized here}}
  99   long *lp = ::new (buf + 3) long; // expected-warning{{Storage provided to placement new is only 0 bytes, whereas the allocated type requires 8 bytes}} expected-note 1 {{}}
 100   (void)lp;
 101 }
 102 } // namespace testZeroSize
 103
 104 namespace testNegativeSize {
 105 void f() {
 106   int buf[3];                      // expected-note {{'buf' initialized here}}
 107   long *lp = ::new (buf + 4) long; // expected-warning{{Storage provided to placement new is only -4 bytes, whereas the allocated type requires 8 bytes}} expected-note 1 {{}}
 108   (void)lp;
 109 }
 110 } // namespace testNegativeSize
 111
 112 namespace testHeapAllocatedBuffer {
 113 void g2() {
 114   char *buf = new char[2];     // expected-note {{'buf' initialized here}}
 115                                // FIXME: The message is misleading -- we should
 116                                // state that a pointer to an uninitialized value
 117                                // is stored.
 118                                // expected-note@-4{{Storing uninitialized value}}
 119   long *lp = ::new (buf) long; // expected-warning{{Storage provided to placement new is only 2 bytes, whereas the allocated type requires 8 bytes}} expected-note 1 {{}}
 120   (void)lp;
 121 }
 122 } // namespace testHeapAllocatedBuffer
 123
 124 namespace testMultiDimensionalArray {
 125 void f() {
 126   char buf[2][3];              // expected-note {{'buf' initialized here}}
 127   long *lp = ::new (buf) long; // expected-warning{{Storage provided to placement new is only 6 bytes, whereas the allocated type requires 8 bytes}} expected-note 1 {{}}
 128   (void)lp;
 129 }
 130 } // namespace testMultiDimensionalArray
 131
 132 namespace testMultiDimensionalArray2 {
 133 void f() {
 134   char buf[2][3];                  // expected-note {{'buf' initialized here}}
 135   long *lp = ::new (buf + 1) long; // expected-warning{{Storage provided to placement new is only 3 bytes, whereas the allocated type requires 8 bytes}} expected-note 1 {{}}
 136   (void)lp;
 137 }
 138 } // namespace testMultiDimensionalArray2
 139
 140 namespace testMultiDimensionalArray3 {
 141 void f() {
 142   char buf[2][3];                     // expected-note {{'buf' initialized here}}
 143   long *lp = ::new (&buf[1][1]) long; // expected-warning{{Storage provided to placement new is only 2 bytes, whereas the allocated type requires 8 bytes}} expected-note 1 {{}}
 144   (void)lp;
 145 }
 146 } // namespace testMultiDimensionalArray3
 147
 148 namespace testHierarchy {
 149 struct Base {
 150   char a[2];
 151 };
 152 struct Derived : Base {
 153   char x[2];
 154   int y;
 155 };
 156 void f() {
 157   Base b;                           // expected-note {{'b' initialized here}}
 158   Derived *dp = ::new (&b) Derived; // expected-warning{{Storage provided to placement new is only 2 bytes, whereas the allocated type requires 8 bytes}} expected-note 1 {{}}
 159   (void)dp;
 160 }
 161 } // namespace testHierarchy
 162
 163 namespace testArrayTypesAllocation {
 164 void f1() {
 165   struct S {
 166     short a;
 167   };
 168
 169   // bad (not enough space).
 170   const unsigned N = 32;
 171   alignas(S) unsigned char buffer1[sizeof(S) * N]; // expected-note {{'buffer1' initialized here}}
 172   ::new (buffer1) S[N];                            // expected-warning{{Storage provided to placement new is only 64 bytes, whereas the allocated array type requires more space for internal needs}} expected-note 1 {{}}
 173 }
 174
 175 void f2() {
 176   struct S {
 177     short a;
 178   };
 179
 180   // maybe ok but we need to warn.
 181   const unsigned N = 32;
 182   alignas(S) unsigned char buffer2[sizeof(S) * N + sizeof(int)]; // expected-note {{'buffer2' initialized here}}
 183   ::new (buffer2) S[N];                                          // expected-warning{{68 bytes is possibly not enough for array allocation which requires 64 bytes. Current overhead requires the size of 4 bytes}} expected-note 1 {{}}
 184 }
 185 } // namespace testArrayTypesAllocation
 186
 187 namespace testStructAlign {
 188 void f1() {
 189   struct X {
 190     char a[9];
 191   } Xi; // expected-note {{'Xi' initialized here}}
 192
 193   // bad (struct X is aligned to char).
 194   ::new (&Xi.a) long; // expected-warning{{Storage type is aligned to 1 bytes but allocated type is aligned to 8 bytes}} expected-note 1 {{}}
 195 }
 196
 197 void f2() {
 198   struct X {
 199     char a;
 200     char b;
 201     long c;
 202   } Xi;
 203
 204   // ok (struct X is aligned to long).
 205   ::new (&Xi.a) long;
 206 }
 207
 208 void f3() {
 209   struct X {
 210     char a;
 211     char b;
 212     long c;
 213   } Xi; // expected-note {{'Xi' initialized here}}
 214
 215   // bad (struct X is aligned to long but field 'b' is aligned to 1 because of its offset)
 216   ::new (&Xi.b) long; // expected-warning{{Storage type is aligned to 1 bytes but allocated type is aligned to 8 bytes}} expected-note 1 {{}}
 217 }
 218
 219 void f4() {
 220   struct X {
 221     char a;
 222     struct alignas(alignof(short)) Y {
 223       char b;
 224       char c;
 225     } y;
 226     long d;
 227   } Xi; // expected-note {{'Xi' initialized here}}
 228
 229   // bad. 'b' is aligned to short
 230   ::new (&Xi.y.b) long; // expected-warning{{Storage type is aligned to 2 bytes but allocated type is aligned to 8 bytes}} expected-note 1 {{}}
 231 }
 232
 233 void f5() {
 234   short b[10]; // expected-note {{'b' initialized here}}
 235
 236   ::new (&b) long; // expected-warning{{Storage type is aligned to 2 bytes but allocated type is aligned to 8 bytes}} expected-note 1 {{}}
 237 }
 238
 239 void f6() {
 240   short b[10]; // expected-note {{'b' initialized here}}
 241
 242   // bad (same as previous but checks ElementRegion case)
 243   ::new (&b[0]) long; // expected-warning{{Storage type is aligned to 2 bytes but allocated type is aligned to 8 bytes}} expected-note 1 {{}}
 244 }
 245
 246 void f7() {
 247   alignas(alignof(long)) short b[10];
 248
 249   // ok. aligned to long(ok). offset 4*2(ok)
 250   ::new (&b[4]) long;
 251 }
 252
 253 void f8() {
 254   alignas(alignof(long)) short b[10]; // expected-note {{'b' initialized here}}
 255
 256   // ok. aligned to long(ok). offset 3*2(ok)
 257   ::new (&b[3]) long; // expected-warning{{Storage type is aligned to 6 bytes but allocated type is aligned to 8 bytes}} expected-note 1 {{}}
 258 }
 259
 260 void f9() {
 261   struct X {
 262     char a;
 263     alignas(alignof(long)) char b[20];
 264   } Xi; // expected-note {{'Xi' initialized here}}
 265
 266   // ok. aligned to long(ok). offset 8*1(ok)
 267   ::new (&Xi.b[8]) long;
 268
 269   // bad. aligned to long(ok). offset 1*1(ok)
 270   ::new (&Xi.b[1]) long; // expected-warning{{Storage type is aligned to 1 bytes but allocated type is aligned to 8 bytes}} expected-note 1 {{}}
 271 }
 272
 273 void f10() {
 274   struct X {
 275     char a[8];
 276     alignas(2) char b;
 277   } Xi; // expected-note {{'Xi' initialized here}}
 278
 279   // bad (struct X is aligned to 2).
 280   ::new (&Xi.a) long; // expected-warning{{Storage type is aligned to 2 bytes but allocated type is aligned to 8 bytes}} expected-note 1 {{}}
 281 }
 282
 283 void f11() {
 284   struct X {
 285     char a;
 286     char b;
 287     struct Y {
 288       long c;
 289     } d;
 290   } Xi;
 291
 292   // ok (struct X is aligned to long).
 293   ::new (&Xi.a) long;
 294 }
 295
 296 void f12() {
 297   struct alignas(alignof(long)) X {
 298     char a;
 299     char b;
 300   } Xi;
 301
 302   // ok (struct X is aligned to long).
 303   ::new (&Xi.a) long;
 304 }
 305
 306 void test13() {
 307   struct Y {
 308     char a[10];
 309   };
 310
 311   struct X {
 312     Y b[10];
 313   } Xi; // expected-note {{'Xi' initialized here}}
 314
 315   // bad. X,A are aligned to 'char'
 316   ::new (&Xi.b[0].a) long; // expected-warning{{Storage type is aligned to 1 bytes but allocated type is aligned to 8 bytes}} expected-note 1 {{}}
 317 }
 318
 319 void test14() {
 320   struct Y {
 321     char a[10];
 322   };
 323
 324   struct alignas(alignof(long)) X {
 325     Y b[10];
 326   } Xi;
 327
 328   // ok. X is aligned to 'long' and field 'a' goes with zero offset
 329   ::new (&Xi.b[0].a) long;
 330 }
 331
 332 void test15() {
 333   struct alignas(alignof(long)) Y {
 334     char a[10];
 335   };
 336
 337   struct X {
 338     Y b[10];
 339   } Xi;
 340
 341   // ok. X is aligned to 'long' because it contains struct 'Y' which is aligned to 'long'
 342   ::new (&Xi.b[0].a) long;
 343 }
 344
 345 void test16() {
 346   struct alignas(alignof(long)) Y {
 347     char p;
 348     char a[10];
 349   };
 350
 351   struct X {
 352     Y b[10];
 353   } Xi; // expected-note {{'Xi' initialized here}}
 354
 355   // bad. aligned to long(ok). offset 1(bad)
 356   ::new (&Xi.b[0].a) long; // expected-warning{{Storage type is aligned to 1 bytes but allocated type is aligned to 8 bytes}} expected-note 1 {{}}
 357 }
 358
 359 void test17() {
 360   struct alignas(alignof(long)) Y {
 361     char p;
 362     char a[10];
 363   };
 364
 365   struct X {
 366     Y b[10];
 367   } Xi;
 368
 369   // ok. aligned to long(ok). offset 1+7*1(ok)
 370   ::new (&Xi.b[0].a[7]) long;
 371 }
 372
 373 void test18() {
 374   struct Y {
 375     char p;
 376     alignas(alignof(long)) char a[10];
 377   };
 378
 379   struct X {
 380     Y b[10];
 381   } Xi; // expected-note {{'Xi' initialized here}}
 382
 383   // ok. aligned to long(ok). offset 8*1(ok)
 384   ::new (&Xi.b[0].a[8]) long;
 385
 386   // bad. aligned to long(ok). offset 1(bad)
 387   ::new (&Xi.b[0].a[1]) long; // expected-warning{{Storage type is aligned to 1 bytes but allocated type is aligned to 8 bytes}} expected-note 1 {{}}
 388 }
 389
 390 void test19() {
 391   struct Z {
 392     char p;
 393     char c[10];
 394   };
 395
 396   struct Y {
 397     char p;
 398     Z b[10];
 399   };
 400
 401   struct X {
 402     Y a[10];
 403   } Xi; // expected-note {{'Xi' initialized here}}
 404
 405   // bad. all structures X,Y,Z are aligned to char
 406   ::new (&Xi.a[1].b[1].c) long; // expected-warning{{Storage type is aligned to 1 bytes but allocated type is aligned to 8 bytes}} expected-note 1 {{}}
 407 }
 408
 409 void test20() {
 410   struct Z {
 411     char p;
 412     alignas(alignof(long)) char c[10];
 413   };
 414
 415   struct Y {
 416     char p;
 417     Z b[10];
 418   };
 419
 420   struct X {
 421     Y a[10];
 422   } Xi;
 423
 424   // ok. field 'c' is aligned to 'long'
 425   ::new (&Xi.a[1].b[1].c) long;
 426 }
 427
 428 void test21() {
 429   struct Z {
 430     char p;
 431     char c[10];
 432   };
 433
 434   struct Y {
 435     char p;
 436     Z b[10];
 437   };
 438
 439   struct alignas(alignof(long)) X {
 440     Y a[10];
 441   } Xi; // expected-note {{'Xi' initialized here}}
 442
 443   // ok. aligned to long(ok). offset 1+7*1(ok)
 444   ::new (&Xi.a[0].b[0].c[7]) long; // expected-warning{{Storage type is aligned to 1 bytes but allocated type is aligned to 8 bytes}} expected-note 1 {{}}
 445 }
 446
 447 void test22() {
 448   struct alignas(alignof(long)) Y {
 449     char p;
 450     char a[10][10];
 451   };
 452
 453   struct X {
 454     Y b[10];
 455   } Xi; // expected-note {{'Xi' initialized here}}
 456
 457   // ok. aligned to long(ok). offset ok. 1(field 'a' offset) + 0*10(index '0' * first dimension size '10') + 7*1(index '7')
 458   ::new (&Xi.b[0].a[0][7]) long;
 459
 460   // ok. aligned to long(ok). offset ok. 1(field 'a' offset) + 1*10(index '1' * first dimension size '10') + 5*1(index '5')
 461   ::new (&Xi.b[0].a[1][5]) long;
 462
 463   // bad. aligned to long(ok). offset ok. 1(field 'a' offset) + 1*10(index '1' * first dimension size '10') + 6*1(index '5')
 464   ::new (&Xi.b[0].a[1][6]) long; // expected-warning{{Storage type is aligned to 1 bytes but allocated type is aligned to 8 bytes}} expected-note 1 {{}}
 465 }
 466
 467 } // namespace testStructAlign