1 // RUN: %clang_analyze_cc1 -analyzer-checker=core,debug.ExprInspection -verify %s
2
3 template <typename T> void clang_analyzer_dump(T);
4 template <typename T> void clang_analyzer_value(T);
5 void clang_analyzer_warnIfReached();
6
7 struct Node { int* ptr; };
8
copy_on_stack(Node * n1)9 void copy_on_stack(Node* n1) {
10 Node tmp = *n1;
11 Node* n2 = &tmp;
12 clang_analyzer_dump(n1); // expected-warning-re {{&SymRegion{reg_${{[0-9]+}}<Node * n1>}}}
13 clang_analyzer_dump(n2); // expected-warning {{&tmp}}
14
15 clang_analyzer_dump(n1->ptr); // expected-warning-re {{&SymRegion{reg_${{[0-9]+}}<int * Element{SymRegion{reg_${{[0-9]+}}<Node * n1>},0 S64b,struct Node}.ptr>}}}
16 clang_analyzer_dump(n2->ptr); // expected-warning-re {{&SymRegion{reg_${{[0-9]+}}<int * Element{SymRegion{reg_${{[0-9]+}}<Node * n1>},0 S64b,struct Node}.ptr>}}}
17
18 if (n1->ptr != n2->ptr)
19 clang_analyzer_warnIfReached(); // unreachable
20 (void)(n1->ptr);
21 (void)(n2->ptr);
22 }
23
copy_on_heap(Node * n1)24 void copy_on_heap(Node* n1) {
25 Node* n2 = new Node(*n1);
26
27 clang_analyzer_dump(n1); // expected-warning-re {{&SymRegion{reg_${{[0-9]+}}<Node * n1>}}}
28 clang_analyzer_dump(n2); // expected-warning-re {{&HeapSymRegion{conj_${{[0-9]+}}{Node *, LC{{[0-9]+}}, S{{[0-9]+}}, #{{[0-9]+}}}}}}
29
30 clang_analyzer_dump(n1->ptr); // expected-warning-re {{&SymRegion{reg_${{[0-9]+}}<int * Element{SymRegion{reg_${{[0-9]+}}<Node * n1>},0 S64b,struct Node}.ptr>}}}
31 clang_analyzer_dump(n2->ptr); // expected-warning-re {{&SymRegion{reg_${{[0-9]+}}<int * Element{SymRegion{reg_${{[0-9]+}}<Node * n1>},0 S64b,struct Node}.ptr>}}}
32
33 if (n1->ptr != n2->ptr)
34 clang_analyzer_warnIfReached(); // unreachable
35 (void)(n1->ptr);
36 (void)(n2->ptr);
37 }
38
39 struct List {
40 List* next;
41 int value;
42 int padding;
43 };
44
deadCode(List orig)45 void deadCode(List orig) {
46 List c = orig;
47 clang_analyzer_dump(c.value);
48 // expected-warning-re@-1 {{reg_${{[0-9]+}}<int orig.value>}}
49 if (c.value == 42)
50 return;
51 clang_analyzer_value(c.value);
52 // expected-warning@-1 {{32s:{ [-2147483648, 41], [43, 2147483647] }}}
53 // Before symbol was garbage collected too early, and we lost the constraints.
54 if (c.value != 42)
55 return;
56
57 clang_analyzer_warnIfReached(); // no-warning: Dead code.
58 };
59
ptr1(List * n)60 void ptr1(List* n) {
61 List* n2 = new List(*n); // ctor
62 if (!n->next) {
63 if (n2->next) {
64 clang_analyzer_warnIfReached(); // unreachable
65 }
66 }
67 delete n2;
68 }
69
ptr2(List * n)70 void ptr2(List* n) {
71 List* n2 = new List(); // ctor
72 *n2 = *n; // assignment
73 if (!n->next) {
74 if (n2->next) {
75 clang_analyzer_warnIfReached(); // unreachable
76 }
77 }
78 delete n2;
79 }
80
81 struct Wrapper {
82 List head;
83 int count;
84 };
85
nestedLazyCompoundVal(List * n)86 void nestedLazyCompoundVal(List* n) {
87 Wrapper* w = 0;
88 {
89 Wrapper lw;
90 lw.head = *n;
91 w = new Wrapper(lw);
92 }
93 if (!n->next) {
94 if (w->head.next) {
95 // Unreachable, w->head is a copy of *n, therefore
96 // w->head.next and n->next are equal
97 clang_analyzer_warnIfReached(); // no-warning: unreachable
98 }
99 }
100 delete w;
101 }
102