1 // RUN: %clang_analyze_cc1 -analyzer-checker=core,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 %s
6 // RUN: %clang_analyze_cc1 -analyzer-checker=core,optin.cplusplus.UninitializedObject \
7 // RUN: -analyzer-config optin.cplusplus.UninitializedObject:CheckPointeeInitialization=true \
8 // RUN: -std=c++11 -verify %s
10 //===----------------------------------------------------------------------===//
11 // Concrete location tests.
12 //===----------------------------------------------------------------------===//
14 struct ConcreteIntLocTest
{
17 ConcreteIntLocTest() : ptr(reinterpret_cast<int *>(0xDEADBEEF)) {}
20 void fConcreteIntLocTest() {
24 //===----------------------------------------------------------------------===//
25 // nonloc::LocAsInteger tests.
26 //===----------------------------------------------------------------------===//
28 using intptr_t = unsigned long long;
30 struct LocAsIntegerTest
{
31 intptr_t ptr
; // expected-note{{uninitialized pointee 'reinterpret_cast<char *>(this->ptr)'}}
32 int dontGetFilteredByNonPedanticMode
= 0;
34 LocAsIntegerTest(void *ptr
) : ptr(reinterpret_cast<intptr_t>(ptr
)) {} // expected-warning{{1 uninitialized field}}
37 void fLocAsIntegerTest() {
39 LocAsIntegerTest
t(&c
);
42 //===----------------------------------------------------------------------===//
43 // Null pointer tests.
44 //===----------------------------------------------------------------------===//
52 float *fptr
= nullptr;
57 NullPtrTest() : ptr(nullptr), recPtr(nullptr) {
66 //===----------------------------------------------------------------------===//
68 //===----------------------------------------------------------------------===//
70 struct UntypedAllocaTest
{
72 int dontGetFilteredByNonPedanticMode
= 0;
74 // expected-warning-re@+3 {{Address of stack memory allocated by call to \
75 alloca() on line
{{[0-9]+}} is still referred to by a temporary object on the \
76 stack upon returning to the caller
. This will be a dangling reference
}}
77 UntypedAllocaTest() : allocaPtr(__builtin_alloca(sizeof(int))) {
82 void fUntypedAllocaTest() {
86 struct TypedAllocaTest1
{
87 int *allocaPtr
; // expected-note{{uninitialized pointee 'this->allocaPtr'}}
88 int dontGetFilteredByNonPedanticMode
= 0;
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 \
93 alloca() on line
{{[0-9]+}} is still referred to by a temporary object on the \
94 stack upon returning to the caller
. This will be a dangling reference
}}
97 void fTypedAllocaTest1() {
101 struct TypedAllocaTest2
{
103 int dontGetFilteredByNonPedanticMode
= 0;
105 // expected-warning-re@+5 {{Address of stack memory allocated by call to \
106 alloca() on line
{{[0-9]+}} is still referred to by a temporary object on the \
107 stack upon returning to the caller
. This will be a dangling reference
}}
109 : allocaPtr(static_cast<int *>(__builtin_alloca(sizeof(int)))) {
115 void fTypedAllocaTest2() {
119 //===----------------------------------------------------------------------===//
120 // Heap pointer tests.
121 //===----------------------------------------------------------------------===//
123 class HeapPointerTest1
{
125 // TODO: we'd expect the note: {{uninitialized field 'this->recPtr->y'}}
127 // TODO: we'd expect the note: {{uninitialized field 'this->recPtr->y'}}
130 // TODO: we'd expect the note: {{uninitialized pointee 'this->fptr'}}
131 float *fptr
= new float; // no-note
132 // TODO: we'd expect the note: {{uninitialized pointee 'this->ptr'}}
137 // TODO: we'd expect the warning: {{4 uninitialized fields}}
138 HeapPointerTest1() : ptr(new int), recPtr(new RecordType
) { // no-note
142 void fHeapPointerTest1() {
146 class HeapPointerTest2
{
152 float *fptr
= new float(); // initializes to 0
157 HeapPointerTest2() : ptr(new int{25}), recPtr(new RecordType
{26, 27}) {
162 void fHeapPointerTest2() {
166 //===----------------------------------------------------------------------===//
167 // Stack pointer tests.
168 //===----------------------------------------------------------------------===//
170 class StackPointerTest1
{
182 StackPointerTest1(int *_ptr
, StackPointerTest1::RecordType
*_recPtr
) : ptr(_ptr
), recPtr(_recPtr
) {
187 void fStackPointerTest1() {
189 StackPointerTest1::RecordType ok_rec
{29, 30};
190 StackPointerTest1(&ok_a
, &ok_rec
); // 'a', 'rec.x', 'rec.y' uninitialized
194 class StackPointerTest2
{
197 int x
; // expected-note{{uninitialized field 'this->recPtr->x'}}
198 int y
; // expected-note{{uninitialized field 'this->recPtr->y'}}
202 int *ptr
; // expected-note{{uninitialized pointee 'this->ptr'}}
206 StackPointerTest2(int *_ptr
, RecordType
*_recPtr
) : ptr(_ptr
), recPtr(_recPtr
) { // expected-warning{{3 uninitialized fields}}
210 void fStackPointerTest2() {
212 StackPointerTest2::RecordType rec
;
213 StackPointerTest2(&a
, &rec
); // 'a', 'rec.x', 'rec.y' uninitialized
216 class StackPointerTest2
{
228 StackPointerTest2(int *_ptr
, RecordType
*_recPtr
) : ptr(_ptr
), recPtr(_recPtr
) {
232 void fStackPointerTest2() {
234 StackPointerTest2::RecordType rec
;
235 StackPointerTest2(&a
, &rec
); // 'a', 'rec.x', 'rec.y' uninitialized
239 class UninitPointerTest
{
245 int *ptr
; // expected-note{{uninitialized pointer 'this->ptr'}}
249 UninitPointerTest() : recPtr(new RecordType
{13, 13}) { // expected-warning{{1 uninitialized field}}
253 void fUninitPointerTest() {
257 struct CharPointerTest
{
259 int dontGetFilteredByNonPedanticMode
= 0;
261 CharPointerTest() : str("") {}
264 void fCharPointerTest() {
268 struct 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;
274 void __vector_size__PointerTest() {
278 struct VectorSizePointee
{
279 using MyVectorType
= __attribute__((__vector_size__(8))) int;
282 VectorSizePointee(decltype(x
) x
) : x(x
) {}
285 void __vector_size__PointeeTest() {
286 VectorSizePointee::MyVectorType i
;
287 // TODO: Report v.x's pointee.
288 VectorSizePointee
v(&i
);
291 struct CyclicPointerTest1
{
292 int *ptr
; // expected-note{{object references itself 'this->ptr'}}
293 int dontGetFilteredByNonPedanticMode
= 0;
295 CyclicPointerTest1() : ptr(reinterpret_cast<int *>(&ptr
)) {} // expected-warning{{1 uninitialized field}}
298 void fCyclicPointerTest1() {
299 CyclicPointerTest1();
302 struct CyclicPointerTest2
{
303 int **pptr
; // expected-note{{object references itself 'this->pptr'}}
304 int dontGetFilteredByNonPedanticMode
= 0;
306 CyclicPointerTest2() : pptr(reinterpret_cast<int **>(&pptr
)) {} // expected-warning{{1 uninitialized field}}
309 void fCyclicPointerTest2() {
310 CyclicPointerTest2();
313 //===----------------------------------------------------------------------===//
314 // Void pointer tests.
315 //===----------------------------------------------------------------------===//
317 // Void pointer tests are mainly no-crash tests.
319 void *malloc(int size
);
321 class VoidPointerTest1
{
325 VoidPointerTest1(void *vptr
, char) : vptr(vptr
) {
330 void fVoidPointerTest1() {
331 void *vptr
= malloc(sizeof(int));
332 VoidPointerTest1(vptr
, char());
335 class VoidPointerTest2
{
339 VoidPointerTest2(void **vpptr
, char) : vpptr(vpptr
) {
344 void fVoidPointerTest2() {
345 void *vptr
= malloc(sizeof(int));
346 VoidPointerTest2(&vptr
, char());
349 class VoidPointerRRefTest1
{
350 void *&&vptrrref
; // expected-note {{here}}
353 // expected-warning@+3 {{Address of stack memory associated with local \
354 variable
'vptr' is still referred to by a temporary object on the stack \
355 upon returning to the caller
. This will be a dangling reference
}}
356 VoidPointerRRefTest1(void *vptr
, char) : vptrrref(static_cast<void *&&>(vptr
)) { // expected-warning {{binding reference member 'vptrrref' to stack allocated parameter 'vptr'}}
361 void fVoidPointerRRefTest1() {
362 void *vptr
= malloc(sizeof(int));
363 VoidPointerRRefTest1(vptr
, char());
366 class VoidPointerRRefTest2
{
367 void **&&vpptrrref
; // expected-note {{here}}
370 // expected-warning@+3 {{Address of stack memory associated with local \
371 variable
'vptr' is still referred to by a temporary object on the stack \
372 upon returning to the caller
. This will be a dangling reference
}}
373 VoidPointerRRefTest2(void **vptr
, char) : vpptrrref(static_cast<void **&&>(vptr
)) { // expected-warning {{binding reference member 'vpptrrref' to stack allocated parameter 'vptr'}}
378 void fVoidPointerRRefTest2() {
379 void *vptr
= malloc(sizeof(int));
380 VoidPointerRRefTest2(&vptr
, char());
383 class VoidPointerLRefTest
{
384 void *&vptrrref
; // expected-note {{here}}
387 // expected-warning@+3 {{Address of stack memory associated with local \
388 variable
'vptr' is still referred to by a temporary object on the stack \
389 upon returning to the caller
. This will be a dangling reference
}}
390 VoidPointerLRefTest(void *vptr
, char) : vptrrref(static_cast<void *&>(vptr
)) { // expected-warning {{binding reference member 'vptrrref' to stack allocated parameter 'vptr'}}
395 void fVoidPointerLRefTest() {
396 void *vptr
= malloc(sizeof(int));
397 VoidPointerLRefTest(vptr
, char());
400 struct CyclicVoidPointerTest
{
401 void *vptr
; // expected-note{{object references itself 'this->vptr'}}
402 int dontGetFilteredByNonPedanticMode
= 0;
404 CyclicVoidPointerTest() : vptr(&vptr
) {} // expected-warning{{1 uninitialized field}}
407 void fCyclicVoidPointerTest() {
408 CyclicVoidPointerTest();
411 struct IntDynTypedVoidPointerTest1
{
412 void *vptr
; // expected-note{{uninitialized pointee 'static_cast<int *>(this->vptr)'}}
413 int dontGetFilteredByNonPedanticMode
= 0;
415 IntDynTypedVoidPointerTest1(void *vptr
) : vptr(vptr
) {} // expected-warning{{1 uninitialized field}}
418 void fIntDynTypedVoidPointerTest1() {
420 IntDynTypedVoidPointerTest1
tmp(&a
);
423 struct RecordDynTypedVoidPointerTest
{
425 int x
; // expected-note{{uninitialized field 'static_cast<struct RecordDynTypedVoidPointerTest::RecordType *>(this->vptr)->x'}}
426 int y
; // expected-note{{uninitialized field 'static_cast<struct RecordDynTypedVoidPointerTest::RecordType *>(this->vptr)->y'}}
430 int dontGetFilteredByNonPedanticMode
= 0;
432 RecordDynTypedVoidPointerTest(void *vptr
) : vptr(vptr
) {} // expected-warning{{2 uninitialized fields}}
435 void fRecordDynTypedVoidPointerTest() {
436 RecordDynTypedVoidPointerTest::RecordType a
;
437 RecordDynTypedVoidPointerTest
tmp(&a
);
440 struct NestedNonVoidDynTypedVoidPointerTest
{
442 int x
; // expected-note{{uninitialized field 'static_cast<struct NestedNonVoidDynTypedVoidPointerTest::RecordType *>(this->vptr)->x'}}
443 int y
; // expected-note{{uninitialized field 'static_cast<struct NestedNonVoidDynTypedVoidPointerTest::RecordType *>(this->vptr)->y'}}
444 void *vptr
; // expected-note{{uninitialized pointee 'static_cast<char *>(static_cast<struct NestedNonVoidDynTypedVoidPointerTest::RecordType *>(this->vptr)->vptr)'}}
448 int dontGetFilteredByNonPedanticMode
= 0;
450 NestedNonVoidDynTypedVoidPointerTest(void *vptr
, void *c
) : vptr(vptr
) {
451 static_cast<RecordType
*>(vptr
)->vptr
= c
; // expected-warning{{3 uninitialized fields}}
455 void fNestedNonVoidDynTypedVoidPointerTest() {
456 NestedNonVoidDynTypedVoidPointerTest::RecordType a
;
458 NestedNonVoidDynTypedVoidPointerTest
tmp(&a
, &c
);
461 //===----------------------------------------------------------------------===//
462 // Multipointer tests.
463 //===----------------------------------------------------------------------===//
466 class MultiPointerTest1
{
474 RecordType
**mptr
; // expected-note{{uninitialized pointee 'this->mptr'}}
477 MultiPointerTest1(RecordType
**p
, int) : mptr(p
) { // expected-warning{{1 uninitialized field}}
481 void fMultiPointerTest1() {
482 MultiPointerTest1::RecordType
*p1
;
483 MultiPointerTest1::RecordType
**mptr
= &p1
;
484 MultiPointerTest1(mptr
, int()); // '*mptr' uninitialized
487 class MultiPointerTest1
{
498 MultiPointerTest1(RecordType
**p
, int) : mptr(p
) {}
501 void fMultiPointerTest1() {
502 MultiPointerTest1::RecordType
*p1
;
503 MultiPointerTest1::RecordType
**mptr
= &p1
;
504 MultiPointerTest1(mptr
, int()); // '*mptr' uninitialized
509 class MultiPointerTest2
{
512 int x
; // expected-note{{uninitialized field 'this->mptr->x'}}
513 int y
; // expected-note{{uninitialized field 'this->mptr->y'}}
520 MultiPointerTest2(RecordType
**p
, int) : mptr(p
) { // expected-warning{{2 uninitialized fields}}
524 void fMultiPointerTest2() {
525 MultiPointerTest2::RecordType i
;
526 MultiPointerTest2::RecordType
*p1
= &i
;
527 MultiPointerTest2::RecordType
**mptr
= &p1
;
528 MultiPointerTest2(mptr
, int()); // '**mptr' uninitialized
531 class MultiPointerTest2
{
542 MultiPointerTest2(RecordType
**p
, int) : mptr(p
) {
546 void fMultiPointerTest2() {
547 MultiPointerTest2::RecordType i
;
548 MultiPointerTest2::RecordType
*p1
= &i
;
549 MultiPointerTest2::RecordType
**mptr
= &p1
;
550 MultiPointerTest2(mptr
, int()); // '**mptr' uninitialized
554 class MultiPointerTest3
{
565 MultiPointerTest3(RecordType
**p
, int) : mptr(p
) {
570 void fMultiPointerTest3() {
571 MultiPointerTest3::RecordType i
{31, 32};
572 MultiPointerTest3::RecordType
*p1
= &i
;
573 MultiPointerTest3::RecordType
**mptr
= &p1
;
574 MultiPointerTest3(mptr
, int()); // '**mptr' uninitialized
577 //===----------------------------------------------------------------------===//
578 // Incomplete pointee tests.
579 //===----------------------------------------------------------------------===//
581 class IncompleteType
;
583 struct IncompletePointeeTypeTest
{
584 IncompleteType
*pImpl
; //no-crash
585 int dontGetFilteredByNonPedanticMode
= 0;
587 IncompletePointeeTypeTest(IncompleteType
*A
) : pImpl(A
) {}
590 void fIncompletePointeeTypeTest(void *ptr
) {
591 IncompletePointeeTypeTest(reinterpret_cast<IncompleteType
*>(ptr
));
594 //===----------------------------------------------------------------------===//
595 // Function pointer tests.
596 //===----------------------------------------------------------------------===//
598 struct FunctionPointerWithDifferentDynTypeTest
{
599 using Func1
= void *(*)();
600 using Func2
= int *(*)();
603 FunctionPointerWithDifferentDynTypeTest(Func2 f
) : f((Func1
)f
) {}
606 // Note that there isn't a function calling the constructor of
607 // FunctionPointerWithDifferentDynTypeTest, because a crash could only be
608 // reproduced without it.
610 //===----------------------------------------------------------------------===//
611 // Member pointer tests.
612 //===----------------------------------------------------------------------===//
614 struct UsefulFunctions
{
622 struct PointerToMemberFunctionTest1
{
623 void (UsefulFunctions::*f
)(void); // expected-note{{uninitialized field 'this->f'}}
624 PointerToMemberFunctionTest1() {}
627 void fPointerToMemberFunctionTest1() {
628 PointerToMemberFunctionTest1(); // expected-warning{{1 uninitialized field}}
631 struct PointerToMemberFunctionTest2
{
632 void (UsefulFunctions::*f
)(void);
633 PointerToMemberFunctionTest2(void (UsefulFunctions::*f
)(void)) : f(f
) {
638 void fPointerToMemberFunctionTest2() {
639 void (UsefulFunctions::*f
)(void) = &UsefulFunctions::print
;
640 PointerToMemberFunctionTest2
a(f
);
643 struct MultiPointerToMemberFunctionTest1
{
644 void (UsefulFunctions::**f
)(void); // expected-note{{uninitialized pointer 'this->f'}}
645 MultiPointerToMemberFunctionTest1() {}
648 void fMultiPointerToMemberFunctionTest1() {
649 MultiPointerToMemberFunctionTest1(); // expected-warning{{1 uninitialized field}}
652 struct MultiPointerToMemberFunctionTest2
{
653 void (UsefulFunctions::**f
)(void);
654 MultiPointerToMemberFunctionTest2(void (UsefulFunctions::**f
)(void)) : f(f
) {
659 void fMultiPointerToMemberFunctionTest2() {
660 void (UsefulFunctions::*f
)(void) = &UsefulFunctions::print
;
661 MultiPointerToMemberFunctionTest2
a(&f
);
664 struct PointerToMemberDataTest1
{
665 int UsefulFunctions::*d
; // expected-note{{uninitialized field 'this->d'}}
666 PointerToMemberDataTest1() {}
669 void fPointerToMemberDataTest1() {
670 PointerToMemberDataTest1(); // expected-warning{{1 uninitialized field}}
673 struct PointerToMemberDataTest2
{
674 int UsefulFunctions::*d
;
675 PointerToMemberDataTest2(int UsefulFunctions::*d
) : d(d
) {
680 void fPointerToMemberDataTest2() {
681 int UsefulFunctions::*d
= &UsefulFunctions::a
;
682 PointerToMemberDataTest2
a(d
);
685 struct MultiPointerToMemberDataTest1
{
686 int UsefulFunctions::**d
; // expected-note{{uninitialized pointer 'this->d'}}
687 MultiPointerToMemberDataTest1() {}
690 void fMultiPointerToMemberDataTest1() {
691 MultiPointerToMemberDataTest1(); // expected-warning{{1 uninitialized field}}
694 struct MultiPointerToMemberDataTest2
{
695 int UsefulFunctions::**d
;
696 MultiPointerToMemberDataTest2(int UsefulFunctions::**d
) : d(d
) {
701 void fMultiPointerToMemberDataTest2() {
702 int UsefulFunctions::*d
= &UsefulFunctions::a
;
703 MultiPointerToMemberDataTest2
a(&d
);
707 //===----------------------------------------------------------------------===//
708 // Tests for list-like records.
709 //===----------------------------------------------------------------------===//
714 Node
*next
= nullptr; // no crash
719 Node
*head
= nullptr;
734 Node
*next
= nullptr;
735 int i
; // expected-note{{uninitialized field 'this->head->i'}}
739 Node
*head
= nullptr;
742 ListTest2(Node
*node
, int) : head(node
) { // expected-warning{{1 uninitialized field}}
748 ListTest2(&n
, int());
754 Node
*next
= nullptr;
755 int i
; // expected-note{{uninitialized field 'this->head->i'}}
759 Node
*head
= nullptr;
762 CyclicList(Node
*node
, int) : head(node
) { // expected-warning{{1 uninitialized field}}
781 // note that n1.i is uninitialized
782 CyclicList(&n1
, int());
785 struct RingListTest
{
786 RingListTest
*next
; // no-crash
787 RingListTest() : next(this) {}
790 void fRingListTest() {
794 //===----------------------------------------------------------------------===//
795 // Tests for classes containing references.
796 //===----------------------------------------------------------------------===//
798 class ReferenceTest1
{
810 ReferenceTest1(RecordType
&lref
, RecordType
&rref
) : lref(lref
), rref(static_cast<RecordType
&&>(rref
)) {
815 void fReferenceTest1() {
816 ReferenceTest1::RecordType d
{33, 34};
817 ReferenceTest1(d
, d
);
821 class ReferenceTest2
{
824 int x
; // expected-note{{uninitialized field 'this->lref.x'}}
825 int y
; // expected-note{{uninitialized field 'this->lref.y'}}
833 ReferenceTest2(RecordType
&lref
, RecordType
&rref
)
834 : lref(lref
), rref(static_cast<RecordType
&&>(rref
)) { // expected-warning{{2 uninitialized fields}}
838 void fReferenceTest2() {
839 ReferenceTest2::RecordType c
;
840 ReferenceTest2(c
, c
);
843 class ReferenceTest2
{
855 ReferenceTest2(RecordType
&lref
, RecordType
&rref
)
856 : lref(lref
), rref(static_cast<RecordType
&&>(rref
)) {
860 void fReferenceTest2() {
861 ReferenceTest2::RecordType c
;
862 ReferenceTest2(c
, c
);
866 class ReferenceTest3
{
869 int x
; // expected-note{{uninitialized field 'this->lref.x'}}
870 int y
; // expected-note{{uninitialized field 'this->lref.y'}}
878 ReferenceTest3(RecordType
&lref
, RecordType
&rref
)
879 : lref(lref
), rref(static_cast<RecordType
&&>(rref
)) { // expected-warning{{2 uninitialized fields}}
883 void fReferenceTest3() {
884 ReferenceTest3::RecordType c
, d
{35, 36};
885 ReferenceTest3(c
, d
);
888 class ReferenceTest4
{
891 int x
; // expected-note{{uninitialized field 'this->rref.x'}}
892 int y
; // expected-note{{uninitialized field 'this->rref.y'}}
900 ReferenceTest4(RecordType
&lref
, RecordType
&rref
)
901 : lref(lref
), rref(static_cast<RecordType
&&>(rref
)) { // expected-warning{{2 uninitialized fields}}
905 void fReferenceTest5() {
906 ReferenceTest4::RecordType c
, d
{37, 38};
907 ReferenceTest4(d
, c
);
910 //===----------------------------------------------------------------------===//
911 // Tests for objects containing multiple references to the same object.
912 //===----------------------------------------------------------------------===//
914 struct IntMultipleReferenceToSameObjectTest
{
915 int *iptr
; // expected-note{{uninitialized pointee 'this->iptr'}}
916 int &iref
; // no-note, pointee of this->iref was already reported
918 int dontGetFilteredByNonPedanticMode
= 0;
920 IntMultipleReferenceToSameObjectTest(int *i
) : iptr(i
), iref(*i
) {} // expected-warning{{1 uninitialized field}}
923 void fIntMultipleReferenceToSameObjectTest() {
925 IntMultipleReferenceToSameObjectTest
Test(&a
);
928 struct IntReferenceWrapper1
{
929 int &a
; // expected-note{{uninitialized pointee 'this->a'}}
931 int dontGetFilteredByNonPedanticMode
= 0;
933 IntReferenceWrapper1(int &a
) : a(a
) {} // expected-warning{{1 uninitialized field}}
936 struct IntReferenceWrapper2
{
937 int &a
; // no-note, pointee of this->a was already reported
939 int dontGetFilteredByNonPedanticMode
= 0;
941 IntReferenceWrapper2(int &a
) : a(a
) {} // no-warning
944 void fMultipleObjectsReferencingTheSameObjectTest() {
947 IntReferenceWrapper1
T1(a
);
948 IntReferenceWrapper2
T2(a
);