1// RUN: %clang_cc1 -analyze -analyzer-checker=core,debug.ExprInspection -fobjc-arc -analyzer-config c++-inlining=constructors -Wno-null-dereference -std=c++11 -verify %s
2
3#include "Inputs/system-header-simulator-cxx.h"
4
5void clang_analyzer_eval(bool);
6void clang_analyzer_checkInlined(bool);
7
8// A simplified version of std::move.
9template <typename T>
10T &&move(T &obj) {
11  return static_cast<T &&>(obj);
12}
13
14
15struct Wrapper {
16  __strong id obj;
17};
18
19void test() {
20  Wrapper w;
21  // force a diagnostic
22  *(char *)0 = 1; // expected-warning{{Dereference of null pointer}}
23}
24
25
26struct IntWrapper {
27  int x;
28};
29
30void testCopyConstructor() {
31  IntWrapper a;
32  a.x = 42;
33
34  IntWrapper b(a);
35  clang_analyzer_eval(b.x == 42); // expected-warning{{TRUE}}
36}
37
38struct NonPODIntWrapper {
39  int x;
40
41  virtual int get();
42};
43
44void testNonPODCopyConstructor() {
45  NonPODIntWrapper a;
46  a.x = 42;
47
48  NonPODIntWrapper b(a);
49  clang_analyzer_eval(b.x == 42); // expected-warning{{TRUE}}
50}
51
52
53namespace ConstructorVirtualCalls {
54  class A {
55  public:
56    int *out1, *out2, *out3;
57
58    virtual int get() { return 1; }
59
60    A(int *out1) {
61      *out1 = get();
62    }
63  };
64
65  class B : public A {
66  public:
67    virtual int get() { return 2; }
68
69    B(int *out1, int *out2) : A(out1) {
70      *out2 = get();
71    }
72  };
73
74  class C : public B {
75  public:
76    virtual int get() { return 3; }
77
78    C(int *out1, int *out2, int *out3) : B(out1, out2) {
79      *out3 = get();
80    }
81  };
82
83  void test() {
84    int a, b, c;
85
86    C obj(&a, &b, &c);
87    clang_analyzer_eval(a == 1); // expected-warning{{TRUE}}
88    clang_analyzer_eval(b == 2); // expected-warning{{TRUE}}
89    clang_analyzer_eval(c == 3); // expected-warning{{TRUE}}
90
91    clang_analyzer_eval(obj.get() == 3); // expected-warning{{TRUE}}
92
93    // Sanity check for devirtualization.
94    A *base = &obj;
95    clang_analyzer_eval(base->get() == 3); // expected-warning{{TRUE}}
96  }
97}
98
99namespace TemporaryConstructor {
100  class BoolWrapper {
101  public:
102    BoolWrapper() {
103      clang_analyzer_checkInlined(true); // expected-warning{{TRUE}}
104      value = true;
105    }
106    bool value;
107  };
108
109  void test() {
110    // PR13717 - Don't crash when a CXXTemporaryObjectExpr is inlined.
111    if (BoolWrapper().value)
112      return;
113  }
114}
115
116
117namespace ConstructorUsedAsRValue {
118  using TemporaryConstructor::BoolWrapper;
119
120  bool extractValue(BoolWrapper b) {
121    return b.value;
122  }
123
124  void test() {
125    bool result = extractValue(BoolWrapper());
126    clang_analyzer_eval(result); // expected-warning{{TRUE}}
127  }
128}
129
130namespace PODUninitialized {
131  class POD {
132  public:
133    int x, y;
134  };
135
136  class PODWrapper {
137  public:
138    POD p;
139  };
140
141  class NonPOD {
142  public:
143    int x, y;
144
145    NonPOD() {}
146    NonPOD(const NonPOD &Other)
147      : x(Other.x), y(Other.y) // expected-warning {{undefined}}
148    {
149    }
150    NonPOD(NonPOD &&Other)
151    : x(Other.x), y(Other.y) // expected-warning {{undefined}}
152    {
153    }
154
155    NonPOD &operator=(const NonPOD &Other)
156    {
157      x = Other.x;
158      y = Other.y; // expected-warning {{undefined}}
159      return *this;
160    }
161    NonPOD &operator=(NonPOD &&Other)
162    {
163      x = Other.x;
164      y = Other.y; // expected-warning {{undefined}}
165      return *this;
166    }
167  };
168
169  class NonPODWrapper {
170  public:
171    class Inner {
172    public:
173      int x, y;
174
175      Inner() {}
176      Inner(const Inner &Other)
177        : x(Other.x), y(Other.y) // expected-warning {{undefined}}
178      {
179      }
180      Inner(Inner &&Other)
181      : x(Other.x), y(Other.y) // expected-warning {{undefined}}
182      {
183      }
184
185      Inner &operator=(const Inner &Other)
186      {
187        x = Other.x; // expected-warning {{undefined}}
188        y = Other.y;
189        return *this;
190      }
191      Inner &operator=(Inner &&Other)
192      {
193        x = Other.x; // expected-warning {{undefined}}
194        y = Other.y;
195        return *this;
196      }
197    };
198
199    Inner p;
200  };
201
202  void testPOD() {
203    POD p;
204    p.x = 1;
205    POD p2 = p; // no-warning
206    clang_analyzer_eval(p2.x == 1); // expected-warning{{TRUE}}
207    POD p3 = move(p); // no-warning
208    clang_analyzer_eval(p3.x == 1); // expected-warning{{TRUE}}
209
210    // Use rvalues as well.
211    clang_analyzer_eval(POD(p3).x == 1); // expected-warning{{TRUE}}
212
213    PODWrapper w;
214    w.p.y = 1;
215    PODWrapper w2 = w; // no-warning
216    clang_analyzer_eval(w2.p.y == 1); // expected-warning{{TRUE}}
217    PODWrapper w3 = move(w); // no-warning
218    clang_analyzer_eval(w3.p.y == 1); // expected-warning{{TRUE}}
219
220    // Use rvalues as well.
221    clang_analyzer_eval(PODWrapper(w3).p.y == 1); // expected-warning{{TRUE}}
222  }
223
224  void testNonPOD() {
225    NonPOD p;
226    p.x = 1;
227    NonPOD p2 = p;
228  }
229
230  void testNonPODMove() {
231    NonPOD p;
232    p.x = 1;
233    NonPOD p2 = move(p);
234  }
235
236  void testNonPODWrapper() {
237    NonPODWrapper w;
238    w.p.y = 1;
239    NonPODWrapper w2 = w;
240  }
241
242  void testNonPODWrapperMove() {
243    NonPODWrapper w;
244    w.p.y = 1;
245    NonPODWrapper w2 = move(w);
246  }
247
248  // Not strictly about constructors, but trivial assignment operators should
249  // essentially work the same way.
250  namespace AssignmentOperator {
251    void testPOD() {
252      POD p;
253      p.x = 1;
254      POD p2;
255      p2 = p; // no-warning
256      clang_analyzer_eval(p2.x == 1); // expected-warning{{TRUE}}
257      POD p3;
258      p3 = move(p); // no-warning
259      clang_analyzer_eval(p3.x == 1); // expected-warning{{TRUE}}
260
261      PODWrapper w;
262      w.p.y = 1;
263      PODWrapper w2;
264      w2 = w; // no-warning
265      clang_analyzer_eval(w2.p.y == 1); // expected-warning{{TRUE}}
266      PODWrapper w3;
267      w3 = move(w); // no-warning
268      clang_analyzer_eval(w3.p.y == 1); // expected-warning{{TRUE}}
269    }
270
271    void testReturnValue() {
272      POD p;
273      p.x = 1;
274      POD p2;
275      clang_analyzer_eval(&(p2 = p) == &p2); // expected-warning{{TRUE}}
276
277      PODWrapper w;
278      w.p.y = 1;
279      PODWrapper w2;
280      clang_analyzer_eval(&(w2 = w) == &w2); // expected-warning{{TRUE}}
281    }
282
283    void testNonPOD() {
284      NonPOD p;
285      p.x = 1;
286      NonPOD p2;
287      p2 = p;
288    }
289
290    void testNonPODMove() {
291      NonPOD p;
292      p.x = 1;
293      NonPOD p2;
294      p2 = move(p);
295    }
296
297    void testNonPODWrapper() {
298      NonPODWrapper w;
299      w.p.y = 1;
300      NonPODWrapper w2;
301      w2 = w;
302    }
303
304    void testNonPODWrapperMove() {
305      NonPODWrapper w;
306      w.p.y = 1;
307      NonPODWrapper w2;
308      w2 = move(w);
309    }
310  }
311}
312
313namespace ArrayMembers {
314  struct Primitive {
315    int values[3];
316  };
317
318  void testPrimitive() {
319    Primitive a = { { 1, 2, 3 } };
320
321    clang_analyzer_eval(a.values[0] == 1); // expected-warning{{TRUE}}
322    clang_analyzer_eval(a.values[1] == 2); // expected-warning{{TRUE}}
323    clang_analyzer_eval(a.values[2] == 3); // expected-warning{{TRUE}}
324
325    Primitive b = a;
326
327    clang_analyzer_eval(b.values[0] == 1); // expected-warning{{TRUE}}
328    clang_analyzer_eval(b.values[1] == 2); // expected-warning{{TRUE}}
329    clang_analyzer_eval(b.values[2] == 3); // expected-warning{{TRUE}}
330
331    Primitive c;
332    c = b;
333
334    clang_analyzer_eval(c.values[0] == 1); // expected-warning{{TRUE}}
335    clang_analyzer_eval(c.values[1] == 2); // expected-warning{{TRUE}}
336    clang_analyzer_eval(c.values[2] == 3); // expected-warning{{TRUE}}
337  }
338
339  struct NestedPrimitive {
340    int values[2][3];
341  };
342
343  void testNestedPrimitive() {
344    NestedPrimitive a = { { { 0, 0, 0 }, { 1, 2, 3 } } };
345
346    clang_analyzer_eval(a.values[1][0] == 1); // expected-warning{{TRUE}}
347    clang_analyzer_eval(a.values[1][1] == 2); // expected-warning{{TRUE}}
348    clang_analyzer_eval(a.values[1][2] == 3); // expected-warning{{TRUE}}
349
350    NestedPrimitive b = a;
351
352    clang_analyzer_eval(b.values[1][0] == 1); // expected-warning{{TRUE}}
353    clang_analyzer_eval(b.values[1][1] == 2); // expected-warning{{TRUE}}
354    clang_analyzer_eval(b.values[1][2] == 3); // expected-warning{{TRUE}}
355
356    NestedPrimitive c;
357    c = b;
358
359    clang_analyzer_eval(c.values[1][0] == 1); // expected-warning{{TRUE}}
360    clang_analyzer_eval(c.values[1][1] == 2); // expected-warning{{TRUE}}
361    clang_analyzer_eval(c.values[1][2] == 3); // expected-warning{{TRUE}}
362  }
363
364  struct POD {
365    IntWrapper values[3];
366  };
367
368  void testPOD() {
369    POD a = { { { 1 }, { 2 }, { 3 } } };
370
371    clang_analyzer_eval(a.values[0].x == 1); // expected-warning{{TRUE}}
372    clang_analyzer_eval(a.values[1].x == 2); // expected-warning{{TRUE}}
373    clang_analyzer_eval(a.values[2].x == 3); // expected-warning{{TRUE}}
374
375    POD b = a;
376
377    clang_analyzer_eval(b.values[0].x == 1); // expected-warning{{TRUE}}
378    clang_analyzer_eval(b.values[1].x == 2); // expected-warning{{TRUE}}
379    clang_analyzer_eval(b.values[2].x == 3); // expected-warning{{TRUE}}
380
381    POD c;
382    c = b;
383
384    clang_analyzer_eval(c.values[0].x == 1); // expected-warning{{TRUE}}
385    clang_analyzer_eval(c.values[1].x == 2); // expected-warning{{TRUE}}
386    clang_analyzer_eval(c.values[2].x == 3); // expected-warning{{TRUE}}
387  }
388
389  struct NestedPOD {
390    IntWrapper values[2][3];
391  };
392
393  void testNestedPOD() {
394    NestedPOD a = { { { { 0 }, { 0 }, { 0 } }, { { 1 }, { 2 }, { 3 } } } };
395
396    clang_analyzer_eval(a.values[1][0].x == 1); // expected-warning{{TRUE}}
397    clang_analyzer_eval(a.values[1][1].x == 2); // expected-warning{{TRUE}}
398    clang_analyzer_eval(a.values[1][2].x == 3); // expected-warning{{TRUE}}
399
400    NestedPOD b = a;
401
402    clang_analyzer_eval(b.values[1][0].x == 1); // expected-warning{{TRUE}}
403    clang_analyzer_eval(b.values[1][1].x == 2); // expected-warning{{TRUE}}
404    clang_analyzer_eval(b.values[1][2].x == 3); // expected-warning{{TRUE}}
405
406    NestedPOD c;
407    c = b;
408
409    clang_analyzer_eval(c.values[1][0].x == 1); // expected-warning{{TRUE}}
410    clang_analyzer_eval(c.values[1][1].x == 2); // expected-warning{{TRUE}}
411    clang_analyzer_eval(c.values[1][2].x == 3); // expected-warning{{TRUE}}
412  }
413
414  struct NonPOD {
415    NonPODIntWrapper values[3];
416  };
417
418  void testNonPOD() {
419    NonPOD a;
420    a.values[0].x = 1;
421    a.values[1].x = 2;
422    a.values[2].x = 3;
423
424    clang_analyzer_eval(a.values[0].x == 1); // expected-warning{{TRUE}}
425    clang_analyzer_eval(a.values[1].x == 2); // expected-warning{{TRUE}}
426    clang_analyzer_eval(a.values[2].x == 3); // expected-warning{{TRUE}}
427
428    NonPOD b = a;
429
430    clang_analyzer_eval(b.values[0].x == 1); // expected-warning{{UNKNOWN}}
431    clang_analyzer_eval(b.values[1].x == 2); // expected-warning{{UNKNOWN}}
432    clang_analyzer_eval(b.values[2].x == 3); // expected-warning{{UNKNOWN}}
433
434    NonPOD c;
435    c = b;
436
437    clang_analyzer_eval(c.values[0].x == 1); // expected-warning{{UNKNOWN}}
438    clang_analyzer_eval(c.values[1].x == 2); // expected-warning{{UNKNOWN}}
439    clang_analyzer_eval(c.values[2].x == 3); // expected-warning{{UNKNOWN}}
440  }
441
442  struct NestedNonPOD {
443    NonPODIntWrapper values[2][3];
444  };
445
446  void testNestedNonPOD() {
447    NestedNonPOD a;
448    a.values[0][0].x = 0;
449    a.values[0][1].x = 0;
450    a.values[0][2].x = 0;
451    a.values[1][0].x = 1;
452    a.values[1][1].x = 2;
453    a.values[1][2].x = 3;
454
455    clang_analyzer_eval(a.values[1][0].x == 1); // expected-warning{{TRUE}}
456    clang_analyzer_eval(a.values[1][1].x == 2); // expected-warning{{TRUE}}
457    clang_analyzer_eval(a.values[1][2].x == 3); // expected-warning{{TRUE}}
458
459    NestedNonPOD b = a;
460
461    clang_analyzer_eval(b.values[1][0].x == 1); // expected-warning{{UNKNOWN}}
462    clang_analyzer_eval(b.values[1][1].x == 2); // expected-warning{{UNKNOWN}}
463    clang_analyzer_eval(b.values[1][2].x == 3); // expected-warning{{UNKNOWN}}
464
465    NestedNonPOD c;
466    c = b;
467
468    clang_analyzer_eval(c.values[1][0].x == 1); // expected-warning{{UNKNOWN}}
469    clang_analyzer_eval(c.values[1][1].x == 2); // expected-warning{{UNKNOWN}}
470    clang_analyzer_eval(c.values[1][2].x == 3); // expected-warning{{UNKNOWN}}
471  }
472
473  struct NonPODDefaulted {
474    NonPODIntWrapper values[3];
475
476    NonPODDefaulted() = default;
477    NonPODDefaulted(const NonPODDefaulted &) = default;
478    NonPODDefaulted &operator=(const NonPODDefaulted &) = default;
479  };
480
481  void testNonPODDefaulted() {
482    NonPODDefaulted a;
483    a.values[0].x = 1;
484    a.values[1].x = 2;
485    a.values[2].x = 3;
486
487    clang_analyzer_eval(a.values[0].x == 1); // expected-warning{{TRUE}}
488    clang_analyzer_eval(a.values[1].x == 2); // expected-warning{{TRUE}}
489    clang_analyzer_eval(a.values[2].x == 3); // expected-warning{{TRUE}}
490
491    NonPODDefaulted b = a;
492
493    clang_analyzer_eval(b.values[0].x == 1); // expected-warning{{UNKNOWN}}
494    clang_analyzer_eval(b.values[1].x == 2); // expected-warning{{UNKNOWN}}
495    clang_analyzer_eval(b.values[2].x == 3); // expected-warning{{UNKNOWN}}
496
497    NonPODDefaulted c;
498    c = b;
499
500    clang_analyzer_eval(c.values[0].x == 1); // expected-warning{{UNKNOWN}}
501    clang_analyzer_eval(c.values[1].x == 2); // expected-warning{{UNKNOWN}}
502    clang_analyzer_eval(c.values[2].x == 3); // expected-warning{{UNKNOWN}}
503  }
504};
505
506namespace VirtualInheritance {
507  int counter;
508
509  struct base {
510    base() {
511      ++counter;
512    }
513  };
514
515  struct virtual_subclass : public virtual base {
516    virtual_subclass() {}
517  };
518
519  struct double_subclass : public virtual_subclass {
520    double_subclass() {}
521  };
522
523  void test() {
524    counter = 0;
525    double_subclass obj;
526    clang_analyzer_eval(counter == 1); // expected-warning{{TRUE}}
527  }
528
529  struct double_virtual_subclass : public virtual virtual_subclass {
530    double_virtual_subclass() {}
531  };
532
533  void testVirtual() {
534    counter = 0;
535    double_virtual_subclass obj;
536    clang_analyzer_eval(counter == 1); // expected-warning{{TRUE}}
537  }
538}
539
540namespace ZeroInitialization {
541  struct raw_pair {
542    int p1;
543    int p2;
544  };
545
546  void testVarDecl() {
547    raw_pair p{};
548    clang_analyzer_eval(p.p1 == 0); // expected-warning{{TRUE}}
549    clang_analyzer_eval(p.p2 == 0); // expected-warning{{TRUE}}
550  }
551
552  void testTemporary() {
553    clang_analyzer_eval(raw_pair().p1 == 0); // expected-warning{{TRUE}}
554    clang_analyzer_eval(raw_pair().p2 == 0); // expected-warning{{TRUE}}
555  }
556
557  void testArray() {
558    raw_pair p[2] = {};
559    clang_analyzer_eval(p[0].p1 == 0); // expected-warning{{TRUE}}
560    clang_analyzer_eval(p[0].p2 == 0); // expected-warning{{TRUE}}
561    clang_analyzer_eval(p[1].p1 == 0); // expected-warning{{TRUE}}
562    clang_analyzer_eval(p[1].p2 == 0); // expected-warning{{TRUE}}
563  }
564
565  void testNew() {
566    // FIXME: Pending proper implementation of constructors for 'new'.
567    raw_pair *pp = new raw_pair();
568    clang_analyzer_eval(pp->p1 == 0); // expected-warning{{UNKNOWN}}
569    clang_analyzer_eval(pp->p2 == 0); // expected-warning{{UNKNOWN}}
570  }
571
572  void testArrayNew() {
573    // FIXME: Pending proper implementation of constructors for 'new[]'.
574    raw_pair *p = new raw_pair[2]();
575    clang_analyzer_eval(p[0].p1 == 0); // expected-warning{{UNKNOWN}}
576    clang_analyzer_eval(p[0].p2 == 0); // expected-warning{{UNKNOWN}}
577    clang_analyzer_eval(p[1].p1 == 0); // expected-warning{{UNKNOWN}}
578    clang_analyzer_eval(p[1].p2 == 0); // expected-warning{{UNKNOWN}}
579  }
580
581  struct initializing_pair {
582  public:
583    int x;
584    raw_pair y;
585    initializing_pair() : x(), y() {}
586  };
587
588  void testFieldInitializers() {
589    initializing_pair p;
590    clang_analyzer_eval(p.x == 0); // expected-warning{{TRUE}}
591    clang_analyzer_eval(p.y.p1 == 0); // expected-warning{{TRUE}}
592    clang_analyzer_eval(p.y.p2 == 0); // expected-warning{{TRUE}}
593  }
594
595  struct subclass : public raw_pair {
596    subclass() = default;
597  };
598
599  void testSubclass() {
600    subclass p;
601    clang_analyzer_eval(p.p1 == 0); // expected-warning{{garbage}}
602  }
603
604  struct initializing_subclass : public raw_pair {
605    initializing_subclass() : raw_pair() {}
606  };
607
608  void testInitializingSubclass() {
609    initializing_subclass p;
610    clang_analyzer_eval(p.p1 == 0); // expected-warning{{TRUE}}
611    clang_analyzer_eval(p.p2 == 0); // expected-warning{{TRUE}}
612  }
613
614  struct pair_wrapper {
615    pair_wrapper() : p() {}
616    raw_pair p;
617  };
618
619  struct virtual_subclass : public virtual pair_wrapper {
620    virtual_subclass() {}
621  };
622
623  struct double_virtual_subclass : public virtual_subclass {
624    double_virtual_subclass() {
625      // This previously caused a crash because the pair_wrapper subobject was
626      // initialized twice.
627    }
628  };
629
630  class Empty {
631  public:
632    Empty();
633  };
634
635  class PairContainer : public Empty {
636    raw_pair p;
637  public:
638    PairContainer() : Empty(), p() {
639      // This previously caused a crash because the empty base class looked
640      // like an initialization of 'p'.
641    }
642    PairContainer(int) : Empty(), p() {
643      // Test inlining something else here.
644    }
645  };
646
647  class PairContainerContainer {
648    int padding;
649    PairContainer pc;
650  public:
651    PairContainerContainer() : pc(1) {}
652  };
653}
654
655namespace InitializerList {
656  struct List {
657    bool usedInitializerList;
658
659    List() : usedInitializerList(false) {}
660    List(std::initializer_list<int>) : usedInitializerList(true) {}
661  };
662
663  void testStatic() {
664    List defaultCtor;
665    clang_analyzer_eval(!defaultCtor.usedInitializerList); // expected-warning{{TRUE}}
666
667    List list{1, 2};
668    clang_analyzer_eval(list.usedInitializerList); // expected-warning{{TRUE}}
669  }
670
671  void testDynamic() {
672    List *list = new List{1, 2};
673    // FIXME: When we handle constructors with 'new', this will be TRUE.
674    clang_analyzer_eval(list->usedInitializerList); // expected-warning{{UNKNOWN}}
675  }
676}
677
678namespace PR19579 {
679  class C {};
680
681  void f() {
682    C();
683    int a;
684
685    extern void use(int);
686    use(a); // expected-warning{{uninitialized}}
687  }
688
689  void g() {
690    struct S {
691      C c;
692      int i;
693    };
694
695    // This order triggers the initialization of the inner "a" after the
696    // constructor for "C" is run, which used to confuse the analyzer
697    // (is "C()" the initialization of "a"?).
698    struct S s = {
699      C(),
700      ({
701        int a, b = 0;
702        0;
703      })
704    };
705  }
706}
707