958 lines · cpp
1// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,optin.cplusplus.UninitializedObject \2// RUN: -analyzer-config optin.cplusplus.UninitializedObject:Pedantic=true -DPEDANTIC \3// RUN: -analyzer-config optin.cplusplus.UninitializedObject:CheckPointeeInitialization=true \4// RUN: -std=c++11 -verify %s5 6// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc,optin.cplusplus.UninitializedObject \7// RUN: -analyzer-config optin.cplusplus.UninitializedObject:CheckPointeeInitialization=true \8// RUN: -std=c++11 -verify %s9 10//===----------------------------------------------------------------------===//11// Concrete location tests.12//===----------------------------------------------------------------------===//13 14struct ConcreteIntLocTest {15 int *ptr;16 17 ConcreteIntLocTest() : ptr(reinterpret_cast<int *>(0xDEADBEEF)) {}18};19 20void fConcreteIntLocTest() {21 ConcreteIntLocTest();22}23 24//===----------------------------------------------------------------------===//25// nonloc::LocAsInteger tests.26//===----------------------------------------------------------------------===//27 28using intptr_t = unsigned long long;29 30struct LocAsIntegerTest {31 intptr_t ptr; // expected-note{{uninitialized pointee 'reinterpret_cast<char *>(this->ptr)'}}32 int dontGetFilteredByNonPedanticMode = 0;33 34 LocAsIntegerTest(void *ptr) : ptr(reinterpret_cast<intptr_t>(ptr)) {} // expected-warning{{1 uninitialized field}}35};36 37void fLocAsIntegerTest() {38 char c;39 LocAsIntegerTest t(&c);40}41 42//===----------------------------------------------------------------------===//43// Null pointer tests.44//===----------------------------------------------------------------------===//45 46class NullPtrTest {47 struct RecordType {48 int x;49 int y;50 };51 52 float *fptr = nullptr;53 int *ptr;54 RecordType *recPtr;55 56public:57 NullPtrTest() : ptr(nullptr), recPtr(nullptr) {58 // All good!59 }60};61 62void fNullPtrTest() {63 NullPtrTest();64}65 66//===----------------------------------------------------------------------===//67// Alloca tests.68//===----------------------------------------------------------------------===//69 70struct UntypedAllocaTest {71 void *allocaPtr;72 int dontGetFilteredByNonPedanticMode = 0;73 74 // expected-warning-re@+3 {{Address of stack memory allocated by call to \75alloca() on line {{[0-9]+}} is still referred to by a temporary object on the \76stack upon returning to the caller. This will be a dangling reference}}77 UntypedAllocaTest() : allocaPtr(__builtin_alloca(sizeof(int))) {78 // All good!79 }80};81 82void fUntypedAllocaTest() {83 UntypedAllocaTest();84}85 86struct TypedAllocaTest1 {87 int *allocaPtr; // expected-note{{uninitialized pointee 'this->allocaPtr'}}88 int dontGetFilteredByNonPedanticMode = 0;89 90 TypedAllocaTest1() // expected-warning{{1 uninitialized field}}91 : allocaPtr(static_cast<int *>(__builtin_alloca(sizeof(int)))) {}92 // expected-warning-re@-2 {{Address of stack memory allocated by call to \93alloca() on line {{[0-9]+}} is still referred to by a temporary object on the \94stack upon returning to the caller. This will be a dangling reference}}95};96 97void fTypedAllocaTest1() {98 TypedAllocaTest1();99}100 101struct TypedAllocaTest2 {102 int *allocaPtr;103 int dontGetFilteredByNonPedanticMode = 0;104 105 // expected-warning-re@+5 {{Address of stack memory allocated by call to \106alloca() on line {{[0-9]+}} is still referred to by a temporary object on the \107stack upon returning to the caller. This will be a dangling reference}}108 TypedAllocaTest2()109 : allocaPtr(static_cast<int *>(__builtin_alloca(sizeof(int)))) {110 *allocaPtr = 55555;111 // All good!112 }113};114 115void fTypedAllocaTest2() {116 TypedAllocaTest2();117}118 119//===----------------------------------------------------------------------===//120// Heap pointer tests.121//===----------------------------------------------------------------------===//122 123class HeapPointerTest1 {124 struct RecordType {125 // TODO: we'd expect the note: {{uninitialized field 'this->recPtr->y'}}126 int x; // no-note127 // TODO: we'd expect the note: {{uninitialized field 'this->recPtr->y'}}128 int y; // no-note129 };130 // TODO: we'd expect the note: {{uninitialized pointee 'this->fptr'}}131 float *fptr = new float; // no-note132 // TODO: we'd expect the note: {{uninitialized pointee 'this->ptr'}}133 int *ptr; // no-note134 RecordType *recPtr;135 136public:137 // TODO: we'd expect the warning: {{4 uninitialized fields}}138 HeapPointerTest1() : ptr(new int), recPtr(new RecordType) { // no-note139 }140};141 142void fHeapPointerTest1() {143 HeapPointerTest1();144}145 146class HeapPointerTest2 {147 struct RecordType {148 int x;149 int y;150 };151 152 float *fptr = new float(); // initializes to 0153 int *ptr;154 RecordType *recPtr;155 156public:157 HeapPointerTest2() : ptr(new int{25}), recPtr(new RecordType{26, 27}) {158 // All good!159 }160};161 162void fHeapPointerTest2() {163 HeapPointerTest2();164}165 166//===----------------------------------------------------------------------===//167// Stack pointer tests.168//===----------------------------------------------------------------------===//169 170class StackPointerTest1 {171public:172 struct RecordType {173 int x;174 int y;175 };176 177private:178 int *ptr;179 RecordType *recPtr;180 181public:182 StackPointerTest1(int *_ptr, StackPointerTest1::RecordType *_recPtr) : ptr(_ptr), recPtr(_recPtr) {183 // All good!184 }185};186 187void fStackPointerTest1() {188 int ok_a = 28;189 StackPointerTest1::RecordType ok_rec{29, 30};190 StackPointerTest1(&ok_a, &ok_rec); // 'a', 'rec.x', 'rec.y' uninitialized191}192 193#ifdef PEDANTIC194class StackPointerTest2 {195public:196 struct RecordType {197 int x; // expected-note{{uninitialized field 'this->recPtr->x'}}198 int y; // expected-note{{uninitialized field 'this->recPtr->y'}}199 };200 201private:202 int *ptr; // expected-note{{uninitialized pointee 'this->ptr'}}203 RecordType *recPtr;204 205public:206 StackPointerTest2(int *_ptr, RecordType *_recPtr) : ptr(_ptr), recPtr(_recPtr) { // expected-warning{{3 uninitialized fields}}207 }208};209 210void fStackPointerTest2() {211 int a;212 StackPointerTest2::RecordType rec;213 StackPointerTest2(&a, &rec); // 'a', 'rec.x', 'rec.y' uninitialized214}215#else216class StackPointerTest2 {217public:218 struct RecordType {219 int x;220 int y;221 };222 223private:224 int *ptr;225 RecordType *recPtr;226 227public:228 StackPointerTest2(int *_ptr, RecordType *_recPtr) : ptr(_ptr), recPtr(_recPtr) {229 }230};231 232void fStackPointerTest2() {233 int a;234 StackPointerTest2::RecordType rec;235 StackPointerTest2(&a, &rec); // 'a', 'rec.x', 'rec.y' uninitialized236}237#endif // PEDANTIC238 239class UninitPointerTest {240 struct RecordType {241 int x;242 int y;243 };244 245 int *ptr; // expected-note{{uninitialized pointer 'this->ptr'}}246 RecordType *recPtr;247 248public:249 UninitPointerTest() : recPtr(new RecordType{13, 13}) { // expected-warning{{1 uninitialized field}}250 }251};252 253void fUninitPointerTest() {254 UninitPointerTest();255}256 257struct CharPointerTest {258 const char *str;259 int dontGetFilteredByNonPedanticMode = 0;260 261 CharPointerTest() : str("") {}262};263 264void fCharPointerTest() {265 CharPointerTest();266}267 268struct VectorSizePointer {269 VectorSizePointer() {} // expected-warning{{1 uninitialized field}}270 __attribute__((__vector_size__(8))) int *x; // expected-note{{uninitialized pointer 'this->x'}}271 int dontGetFilteredByNonPedanticMode = 0;272};273 274void __vector_size__PointerTest() {275 VectorSizePointer v;276}277 278struct VectorSizePointee {279 using MyVectorType = __attribute__((__vector_size__(8))) int;280 MyVectorType *x;281 282 VectorSizePointee(decltype(x) x) : x(x) {}283};284 285void __vector_size__PointeeTest() {286 VectorSizePointee::MyVectorType i;287 // TODO: Report v.x's pointee.288 VectorSizePointee v(&i);289}290 291struct CyclicPointerTest1 {292 int *ptr; // expected-note{{object references itself 'this->ptr'}}293 int dontGetFilteredByNonPedanticMode = 0;294 295 CyclicPointerTest1() : ptr(reinterpret_cast<int *>(&ptr)) {} // expected-warning{{1 uninitialized field}}296};297 298void fCyclicPointerTest1() {299 CyclicPointerTest1();300}301 302struct CyclicPointerTest2 {303 int **pptr; // expected-note{{object references itself 'this->pptr'}}304 int dontGetFilteredByNonPedanticMode = 0;305 306 CyclicPointerTest2() : pptr(reinterpret_cast<int **>(&pptr)) {} // expected-warning{{1 uninitialized field}}307};308 309void fCyclicPointerTest2() {310 CyclicPointerTest2();311}312 313//===----------------------------------------------------------------------===//314// Void pointer tests.315//===----------------------------------------------------------------------===//316 317// Void pointer tests are mainly no-crash tests.318 319typedef __typeof(sizeof(int)) size_t;320 321void *calloc(size_t nmemb, size_t size);322void free(void *p);323 324class VoidPointerTest1 {325 void *vptr;326 327public:328 VoidPointerTest1(void *vptr, char) : vptr(vptr) {329 // All good!330 }331};332 333void fVoidPointerTest1() {334 void *vptr = calloc(1, sizeof(int));335 VoidPointerTest1(vptr, char());336 free(vptr);337}338 339class VoidPointerTest2 {340 void **vpptr;341 342public:343 VoidPointerTest2(void **vpptr, char) : vpptr(vpptr) {344 // All good!345 }346};347 348void fVoidPointerTest2() {349 void *vptr = calloc(1, sizeof(int));350 VoidPointerTest2(&vptr, char());351 free(vptr);352}353 354class VoidPointerRRefTest1 {355 void *&&vptrrref; // expected-note {{here}}356 357public:358 // expected-warning@+3 {{Address of stack memory associated with local \359variable 'vptr' is still referred to by a temporary object on the stack \360upon returning to the caller. This will be a dangling reference}}361 VoidPointerRRefTest1(void *vptr, char) : vptrrref(static_cast<void *&&>(vptr)) { // expected-warning {{binding reference member 'vptrrref' to stack allocated parameter 'vptr'}}362 // All good!363 }364};365 366void fVoidPointerRRefTest1() {367 void *vptr = calloc(1, sizeof(int));368 VoidPointerRRefTest1(vptr, char());369 free(vptr);370}371 372class VoidPointerRRefTest2 {373 void **&&vpptrrref; // expected-note {{here}}374 375public:376 // expected-warning@+3 {{Address of stack memory associated with local \377variable 'vptr' is still referred to by a temporary object on the stack \378upon returning to the caller. This will be a dangling reference}}379 VoidPointerRRefTest2(void **vptr, char) : vpptrrref(static_cast<void **&&>(vptr)) { // expected-warning {{binding reference member 'vpptrrref' to stack allocated parameter 'vptr'}}380 // All good!381 }382};383 384void fVoidPointerRRefTest2() {385 void *vptr = calloc(1, sizeof(int));386 VoidPointerRRefTest2(&vptr, char());387 free(vptr);388}389 390class VoidPointerLRefTest {391 void *&vptrrref; // expected-note {{here}}392 393public:394 // expected-warning@+3 {{Address of stack memory associated with local \395variable 'vptr' is still referred to by a temporary object on the stack \396upon returning to the caller. This will be a dangling reference}}397 VoidPointerLRefTest(void *vptr, char) : vptrrref(static_cast<void *&>(vptr)) { // expected-warning {{binding reference member 'vptrrref' to stack allocated parameter 'vptr'}}398 // All good!399 }400};401 402void fVoidPointerLRefTest() {403 void *vptr = calloc(1, sizeof(int));404 VoidPointerLRefTest(vptr, char());405 free(vptr);406}407 408struct CyclicVoidPointerTest {409 void *vptr; // expected-note{{object references itself 'this->vptr'}}410 int dontGetFilteredByNonPedanticMode = 0;411 412 CyclicVoidPointerTest() : vptr(&vptr) {} // expected-warning{{1 uninitialized field}}413};414 415void fCyclicVoidPointerTest() {416 CyclicVoidPointerTest();417}418 419struct IntDynTypedVoidPointerTest1 {420 void *vptr; // expected-note{{uninitialized pointee 'static_cast<int *>(this->vptr)'}}421 int dontGetFilteredByNonPedanticMode = 0;422 423 IntDynTypedVoidPointerTest1(void *vptr) : vptr(vptr) {} // expected-warning{{1 uninitialized field}}424};425 426void fIntDynTypedVoidPointerTest1() {427 int a;428 IntDynTypedVoidPointerTest1 tmp(&a);429}430 431struct RecordDynTypedVoidPointerTest {432 struct RecordType {433 int x; // expected-note{{uninitialized field 'static_cast<RecordDynTypedVoidPointerTest::RecordType *>(this->vptr)->x'}}434 int y; // expected-note{{uninitialized field 'static_cast<RecordDynTypedVoidPointerTest::RecordType *>(this->vptr)->y'}}435 };436 437 void *vptr;438 int dontGetFilteredByNonPedanticMode = 0;439 440 RecordDynTypedVoidPointerTest(void *vptr) : vptr(vptr) {} // expected-warning{{2 uninitialized fields}}441};442 443void fRecordDynTypedVoidPointerTest() {444 RecordDynTypedVoidPointerTest::RecordType a;445 RecordDynTypedVoidPointerTest tmp(&a);446}447 448struct NestedNonVoidDynTypedVoidPointerTest {449 struct RecordType {450 int x; // expected-note{{uninitialized field 'static_cast<NestedNonVoidDynTypedVoidPointerTest::RecordType *>(this->vptr)->x'}}451 int y; // expected-note{{uninitialized field 'static_cast<NestedNonVoidDynTypedVoidPointerTest::RecordType *>(this->vptr)->y'}}452 void *vptr; // expected-note{{uninitialized pointee 'static_cast<char *>(static_cast<NestedNonVoidDynTypedVoidPointerTest::RecordType *>(this->vptr)->vptr)'}}453 };454 455 void *vptr;456 int dontGetFilteredByNonPedanticMode = 0;457 458 NestedNonVoidDynTypedVoidPointerTest(void *vptr, void *c) : vptr(vptr) {459 static_cast<RecordType *>(vptr)->vptr = c; // expected-warning{{3 uninitialized fields}}460 }461};462 463void fNestedNonVoidDynTypedVoidPointerTest() {464 NestedNonVoidDynTypedVoidPointerTest::RecordType a;465 char c;466 NestedNonVoidDynTypedVoidPointerTest tmp(&a, &c);467}468 469//===----------------------------------------------------------------------===//470// Multipointer tests.471//===----------------------------------------------------------------------===//472 473#ifdef PEDANTIC474class MultiPointerTest1 {475public:476 struct RecordType {477 int x;478 int y;479 };480 481private:482 RecordType **mptr; // expected-note{{uninitialized pointee 'this->mptr'}}483 484public:485 MultiPointerTest1(RecordType **p, int) : mptr(p) { // expected-warning{{1 uninitialized field}}486 }487};488 489void fMultiPointerTest1() {490 MultiPointerTest1::RecordType *p1;491 MultiPointerTest1::RecordType **mptr = &p1;492 MultiPointerTest1(mptr, int()); // '*mptr' uninitialized493}494#else495class MultiPointerTest1 {496public:497 struct RecordType {498 int x;499 int y;500 };501 502private:503 RecordType **mptr;504 505public:506 MultiPointerTest1(RecordType **p, int) : mptr(p) {}507};508 509void fMultiPointerTest1() {510 MultiPointerTest1::RecordType *p1;511 MultiPointerTest1::RecordType **mptr = &p1;512 MultiPointerTest1(mptr, int()); // '*mptr' uninitialized513}514#endif // PEDANTIC515 516#ifdef PEDANTIC517class MultiPointerTest2 {518public:519 struct RecordType {520 int x; // expected-note{{uninitialized field 'this->mptr->x'}}521 int y; // expected-note{{uninitialized field 'this->mptr->y'}}522 };523 524private:525 RecordType **mptr;526 527public:528 MultiPointerTest2(RecordType **p, int) : mptr(p) { // expected-warning{{2 uninitialized fields}}529 }530};531 532void fMultiPointerTest2() {533 MultiPointerTest2::RecordType i;534 MultiPointerTest2::RecordType *p1 = &i;535 MultiPointerTest2::RecordType **mptr = &p1;536 MultiPointerTest2(mptr, int()); // '**mptr' uninitialized537}538#else539class MultiPointerTest2 {540public:541 struct RecordType {542 int x;543 int y;544 };545 546private:547 RecordType **mptr;548 549public:550 MultiPointerTest2(RecordType **p, int) : mptr(p) {551 }552};553 554void fMultiPointerTest2() {555 MultiPointerTest2::RecordType i;556 MultiPointerTest2::RecordType *p1 = &i;557 MultiPointerTest2::RecordType **mptr = &p1;558 MultiPointerTest2(mptr, int()); // '**mptr' uninitialized559}560#endif // PEDANTIC561 562class MultiPointerTest3 {563public:564 struct RecordType {565 int x;566 int y;567 };568 569private:570 RecordType **mptr;571 572public:573 MultiPointerTest3(RecordType **p, int) : mptr(p) {574 // All good!575 }576};577 578void fMultiPointerTest3() {579 MultiPointerTest3::RecordType i{31, 32};580 MultiPointerTest3::RecordType *p1 = &i;581 MultiPointerTest3::RecordType **mptr = &p1;582 MultiPointerTest3(mptr, int()); // '**mptr' uninitialized583}584 585//===----------------------------------------------------------------------===//586// Incomplete pointee tests.587//===----------------------------------------------------------------------===//588 589class IncompleteType;590 591struct IncompletePointeeTypeTest {592 IncompleteType *pImpl; //no-crash593 int dontGetFilteredByNonPedanticMode = 0;594 595 IncompletePointeeTypeTest(IncompleteType *A) : pImpl(A) {}596};597 598void fIncompletePointeeTypeTest(void *ptr) {599 IncompletePointeeTypeTest(reinterpret_cast<IncompleteType *>(ptr));600}601 602//===----------------------------------------------------------------------===//603// Function pointer tests.604//===----------------------------------------------------------------------===//605 606struct FunctionPointerWithDifferentDynTypeTest {607 using Func1 = void *(*)();608 using Func2 = int *(*)();609 610 Func1 f; // no-crash611 FunctionPointerWithDifferentDynTypeTest(Func2 f) : f((Func1)f) {}612};613 614// Note that there isn't a function calling the constructor of615// FunctionPointerWithDifferentDynTypeTest, because a crash could only be616// reproduced without it.617 618//===----------------------------------------------------------------------===//619// Member pointer tests.620//===----------------------------------------------------------------------===//621 622struct UsefulFunctions {623 int a, b;624 625 void print() {}626 void dump() {}627};628 629#ifdef PEDANTIC630struct PointerToMemberFunctionTest1 {631 void (UsefulFunctions::*f)(void); // expected-note{{uninitialized field 'this->f'}}632 PointerToMemberFunctionTest1() {}633};634 635void fPointerToMemberFunctionTest1() {636 PointerToMemberFunctionTest1(); // expected-warning{{1 uninitialized field}}637}638 639struct PointerToMemberFunctionTest2 {640 void (UsefulFunctions::*f)(void);641 PointerToMemberFunctionTest2(void (UsefulFunctions::*f)(void)) : f(f) {642 // All good!643 }644};645 646void fPointerToMemberFunctionTest2() {647 void (UsefulFunctions::*f)(void) = &UsefulFunctions::print;648 PointerToMemberFunctionTest2 a(f);649}650 651struct MultiPointerToMemberFunctionTest1 {652 void (UsefulFunctions::**f)(void); // expected-note{{uninitialized pointer 'this->f'}}653 MultiPointerToMemberFunctionTest1() {}654};655 656void fMultiPointerToMemberFunctionTest1() {657 MultiPointerToMemberFunctionTest1(); // expected-warning{{1 uninitialized field}}658}659 660struct MultiPointerToMemberFunctionTest2 {661 void (UsefulFunctions::**f)(void);662 MultiPointerToMemberFunctionTest2(void (UsefulFunctions::**f)(void)) : f(f) {663 // All good!664 }665};666 667void fMultiPointerToMemberFunctionTest2() {668 void (UsefulFunctions::*f)(void) = &UsefulFunctions::print;669 MultiPointerToMemberFunctionTest2 a(&f);670}671 672struct PointerToMemberDataTest1 {673 int UsefulFunctions::*d; // expected-note{{uninitialized field 'this->d'}}674 PointerToMemberDataTest1() {}675};676 677void fPointerToMemberDataTest1() {678 PointerToMemberDataTest1(); // expected-warning{{1 uninitialized field}}679}680 681struct PointerToMemberDataTest2 {682 int UsefulFunctions::*d;683 PointerToMemberDataTest2(int UsefulFunctions::*d) : d(d) {684 // All good!685 }686};687 688void fPointerToMemberDataTest2() {689 int UsefulFunctions::*d = &UsefulFunctions::a;690 PointerToMemberDataTest2 a(d);691}692 693struct MultiPointerToMemberDataTest1 {694 int UsefulFunctions::**d; // expected-note{{uninitialized pointer 'this->d'}}695 MultiPointerToMemberDataTest1() {}696};697 698void fMultiPointerToMemberDataTest1() {699 MultiPointerToMemberDataTest1(); // expected-warning{{1 uninitialized field}}700}701 702struct MultiPointerToMemberDataTest2 {703 int UsefulFunctions::**d;704 MultiPointerToMemberDataTest2(int UsefulFunctions::**d) : d(d) {705 // All good!706 }707};708 709void fMultiPointerToMemberDataTest2() {710 int UsefulFunctions::*d = &UsefulFunctions::a;711 MultiPointerToMemberDataTest2 a(&d);712}713#endif // PEDANTIC714 715//===----------------------------------------------------------------------===//716// Tests for list-like records.717//===----------------------------------------------------------------------===//718 719class ListTest1 {720public:721 struct Node {722 Node *next = nullptr; // no crash723 int i;724 };725 726private:727 Node *head = nullptr;728 729public:730 ListTest1() {731 // All good!732 }733};734 735void fListTest1() {736 ListTest1();737}738 739class ListTest2 {740public:741 struct Node {742 Node *next = nullptr;743 int i; // expected-note{{uninitialized field 'this->head->i'}}744 };745 746private:747 Node *head = nullptr;748 749public:750 ListTest2(Node *node, int) : head(node) { // expected-warning{{1 uninitialized field}}751 }752};753 754void fListTest2() {755 ListTest2::Node n;756 ListTest2(&n, int());757}758 759class CyclicList {760public:761 struct Node {762 Node *next = nullptr;763 int i; // expected-note{{uninitialized field 'this->head->i'}}764 };765 766private:767 Node *head = nullptr;768 769public:770 CyclicList(Node *node, int) : head(node) { // expected-warning{{1 uninitialized field}}771 }772};773 774void fCyclicList() {775 /*776 n3777 / \778 this -- n1 -- n2779 */780 781 CyclicList::Node n1;782 CyclicList::Node n2;783 n2.next = &n1;784 n2.i = 50;785 CyclicList::Node n3;786 n3.next = &n2;787 n3.i = 50;788 n1.next = &n3;789 // note that n1.i is uninitialized790 CyclicList(&n1, int());791}792 793struct RingListTest {794 RingListTest *next; // no-crash795 RingListTest() : next(this) {}796};797 798void fRingListTest() {799 RingListTest();800}801 802//===----------------------------------------------------------------------===//803// Tests for classes containing references.804//===----------------------------------------------------------------------===//805 806class ReferenceTest1 {807public:808 struct RecordType {809 int x;810 int y;811 };812 813private:814 RecordType &lref;815 RecordType &&rref;816 817public:818 ReferenceTest1(RecordType &lref, RecordType &rref) : lref(lref), rref(static_cast<RecordType &&>(rref)) {819 // All good!820 }821};822 823void fReferenceTest1() {824 ReferenceTest1::RecordType d{33, 34};825 ReferenceTest1(d, d);826}827 828#ifdef PEDANTIC829class ReferenceTest2 {830public:831 struct RecordType {832 int x; // expected-note{{uninitialized field 'this->lref.x'}}833 int y; // expected-note{{uninitialized field 'this->lref.y'}}834 };835 836private:837 RecordType &lref;838 RecordType &&rref;839 840public:841 ReferenceTest2(RecordType &lref, RecordType &rref)842 : lref(lref), rref(static_cast<RecordType &&>(rref)) { // expected-warning{{2 uninitialized fields}}843 }844};845 846void fReferenceTest2() {847 ReferenceTest2::RecordType c;848 ReferenceTest2(c, c);849}850#else851class ReferenceTest2 {852public:853 struct RecordType {854 int x;855 int y;856 };857 858private:859 RecordType &lref;860 RecordType &&rref;861 862public:863 ReferenceTest2(RecordType &lref, RecordType &rref)864 : lref(lref), rref(static_cast<RecordType &&>(rref)) {865 }866};867 868void fReferenceTest2() {869 ReferenceTest2::RecordType c;870 ReferenceTest2(c, c);871}872#endif // PEDANTIC873 874class ReferenceTest3 {875public:876 struct RecordType {877 int x; // expected-note{{uninitialized field 'this->lref.x'}}878 int y; // expected-note{{uninitialized field 'this->lref.y'}}879 };880 881private:882 RecordType &lref;883 RecordType &&rref;884 885public:886 ReferenceTest3(RecordType &lref, RecordType &rref)887 : lref(lref), rref(static_cast<RecordType &&>(rref)) { // expected-warning{{2 uninitialized fields}}888 }889};890 891void fReferenceTest3() {892 ReferenceTest3::RecordType c, d{35, 36};893 ReferenceTest3(c, d);894}895 896class ReferenceTest4 {897public:898 struct RecordType {899 int x; // expected-note{{uninitialized field 'this->rref.x'}}900 int y; // expected-note{{uninitialized field 'this->rref.y'}}901 };902 903private:904 RecordType &lref;905 RecordType &&rref;906 907public:908 ReferenceTest4(RecordType &lref, RecordType &rref)909 : lref(lref), rref(static_cast<RecordType &&>(rref)) { // expected-warning{{2 uninitialized fields}}910 }911};912 913void fReferenceTest5() {914 ReferenceTest4::RecordType c, d{37, 38};915 ReferenceTest4(d, c);916}917 918//===----------------------------------------------------------------------===//919// Tests for objects containing multiple references to the same object.920//===----------------------------------------------------------------------===//921 922struct IntMultipleReferenceToSameObjectTest {923 int *iptr; // expected-note{{uninitialized pointee 'this->iptr'}}924 int &iref; // no-note, pointee of this->iref was already reported925 926 int dontGetFilteredByNonPedanticMode = 0;927 928 IntMultipleReferenceToSameObjectTest(int *i) : iptr(i), iref(*i) {} // expected-warning{{1 uninitialized field}}929};930 931void fIntMultipleReferenceToSameObjectTest() {932 int a;933 IntMultipleReferenceToSameObjectTest Test(&a);934}935 936struct IntReferenceWrapper1 {937 int &a; // expected-note{{uninitialized pointee 'this->a'}}938 939 int dontGetFilteredByNonPedanticMode = 0;940 941 IntReferenceWrapper1(int &a) : a(a) {} // expected-warning{{1 uninitialized field}}942};943 944struct IntReferenceWrapper2 {945 int &a; // no-note, pointee of this->a was already reported946 947 int dontGetFilteredByNonPedanticMode = 0;948 949 IntReferenceWrapper2(int &a) : a(a) {} // no-warning950};951 952void fMultipleObjectsReferencingTheSameObjectTest() {953 int a;954 955 IntReferenceWrapper1 T1(a);956 IntReferenceWrapper2 T2(a);957}958