clang/test/Analysis/lifetime-extended-regions.cpp

   1 // RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core\
   2 // RUN:                    -analyzer-checker=debug.ExprInspection\
   3 // RUN:                    -Wno-dangling -Wno-c++1z-extensions\
   4 // RUN:                    -verify=expected,cpp14\
   5 // RUN:                    -x c++ -std=c++14 %s
   6 // RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core\
   7 // RUN:                    -analyzer-checker=debug.ExprInspection\
   8 // RUN:                    -analyzer-config elide-constructors=false\
   9 // RUN:                    -Wno-dangling -Wno-c++1z-extensions\
  10 // RUN:                    -verify=expected,cpp14\
  11 // RUN:                    -x c++ -std=c++14 %s
  12 // RUN: %clang_analyze_cc1 -analyzer-checker=core,alpha.core\
  13 // RUN:                    -analyzer-checker=debug.ExprInspection\
  14 // RUN:                    -Wno-dangling -verify=expected,cpp17\
  15 // RUN:                    -x c++ -std=c++17 %s
  16
  17 template<typename T>
  18 void clang_analyzer_dump(T&&) {}
  19
  20 template<typename T>
  21 T create() { return T{}; }
  22
  23 template<typename T>
  24 T const& select(bool cond, T const& t, T const& u) { return cond ? t : u; }
  25
  26 struct Composite {
  27   int x;
  28   int y;
  29 };
  30
  31 struct Derived : Composite {
  32   int z;
  33 };
  34
  35 template<typename T>
  36 struct Array {
  37   T array[20];
  38
  39   T&& front() && { return static_cast<T&&>(array[0]); }
  40 };
  41
  42 void whole_object() {
  43   int const& i = 10; // extends `int`
  44   clang_analyzer_dump(i); // expected-warning-re {{&lifetime_extended_object{int, i, S{{[0-9]+}}} }}
  45   Composite&& c = Composite{}; // extends `Composite`
  46   clang_analyzer_dump(c); // expected-warning-re {{&lifetime_extended_object{Composite, c, S{{[0-9]+}}} }}
  47   auto&& a = Array<int>{}; // extends `Array<int>`
  48   clang_analyzer_dump(a); // expected-warning-re {{&lifetime_extended_object{Array<int>, a, S{{[0-9]+}}} }}
  49   Composite&& d = Derived{}; // extends `Derived`
  50   clang_analyzer_dump(d); // expected-warning-re {{&Base{lifetime_extended_object{Derived, d, S{{[0-9]+}}},Composite} }}
  51 }
  52
  53 void member_access() {
  54   int&& x = Composite{}.x;  // extends `Composite`
  55   clang_analyzer_dump(x); // expected-warning-re {{&lifetime_extended_object{Composite, x, S{{[0-9]+}}}.x }}
  56   int&& y = create<Composite>().y; // extends `Composite`
  57   clang_analyzer_dump(y); // expected-warning-re {{&lifetime_extended_object{struct Composite, y, S{{[0-9]+}}}.y }}
  58   int&& d = Array<int>{}.front(); // dangles `Array<int>`
  59   clang_analyzer_dump(d); // expected-warning-re {{&Element{temp_object{Array<int>, S{{[0-9]+}}}.array,0 S64b,int} }}
  60 }
  61
  62 void array_subscript() {
  63   int&& i = Array<int>{}.array[0]; // extends `Array<int>`
  64   clang_analyzer_dump(i); // expected-warning-re {{&Element{lifetime_extended_object{Array<int>, i, S{{[0-9]+}}}.array,0 S64b,int} }}
  65   auto&& c = Array<Composite>{}.array[0]; // extends `Array<int>`
  66   clang_analyzer_dump(c); // expected-warning-re {{&Element{lifetime_extended_object{Array<Composite>, c, S{{[0-9]+}}}.array,0 S64b,struct Composite} }}
  67   auto&& x = Array<Composite>{}.array[0].x; // extends `Array<Composite>`
  68   clang_analyzer_dump(x); // expected-warning-re {{&Element{lifetime_extended_object{Array<Composite>, x, S{{[0-9]+}}}.array,0 S64b,struct Composite}.x }}
  69 }
  70
  71 void ternary(bool cond) {
  72   Composite cc;
  73   // Value category mismatch of the operands (lvalue and xvalue), ternary produces prvalue
  74   auto&& ternaryProducesPRvalue = cond ? Composite{}.x : cc.x; // extends prvalue of 'int', `Composite` in true branch is destroyed
  75   clang_analyzer_dump(ternaryProducesPRvalue); // expected-warning-re {{&lifetime_extended_object{int, ternaryProducesPRvalue, S{{[0-9]+}}} }}
  76
  77   // Value category agrees (xvalues), lifetime extension is triggered
  78   auto&& branchesExtended = cond ? Composite{}.x : static_cast<Composite&&>(cc).x; // extends `Composite` in true branch
  79   clang_analyzer_dump(branchesExtended);
  80   // expected-warning-re@-1 {{&lifetime_extended_object{Composite, branchesExtended, S{{[0-9]+}}}.x }}
  81   // expected-warning@-2 {{&cc.x }}
  82
  83   // Object of different types in branches are lifetime extended
  84   auto&& extendingDifferentTypes = cond ? Composite{}.x : Array<int>{}.array[0]; // extends `Composite` or `Array<int>`
  85   clang_analyzer_dump(extendingDifferentTypes);
  86   // expected-warning-re@-1 {{&lifetime_extended_object{Composite, extendingDifferentTypes, S{{[0-9]+}}}.x }}
  87   // expected-warning-re@-2 {{&Element{lifetime_extended_object{Array<int>, extendingDifferentTypes, S{{[0-9]+}}}.array,0 S64b,int} }}
  88
  89   Composite const& variableAndExtended = cond ? static_cast<Composite&&>(cc) : Array<Composite>{}.array[0]; // extends `Array<Composite>` in false branch
  90   clang_analyzer_dump(variableAndExtended);
  91   // expected-warning@-1 {{&cc }}
  92   // expected-warning-re@-2 {{&Element{lifetime_extended_object{Array<Composite>, variableAndExtended, S{{[0-9]+}}}.array,0 S64b,struct Composite} }}
  93
  94   int const& extendAndDangling = cond ? Array<int>{}.array[0] : Array<int>{}.front(); // extends `Array<int>` only in true branch, false branch dangles
  95   clang_analyzer_dump(extendAndDangling);
  96   // expected-warning-re@-1 {{&Element{lifetime_extended_object{Array<int>, extendAndDangling, S{{[0-9]+}}}.array,0 S64b,int} }}
  97   // expected-warning-re@-2 {{&Element{temp_object{Array<int>, S{{[0-9]+}}}.array,0 S64b,int} }}
  98 }
  99
 100 struct RefAggregate {
 101   int const& rx;
 102   Composite&& ry = Composite{};
 103 };
 104
 105 void aggregateWithReferences() {
 106   RefAggregate multipleExtensions = {10, Composite{}}; // extends `int` and `Composite`
 107   clang_analyzer_dump(multipleExtensions.rx); // expected-warning-re {{&lifetime_extended_object{int, multipleExtensions, S{{[0-9]+}}} }}
 108   clang_analyzer_dump(multipleExtensions.ry); // expected-warning-re {{&lifetime_extended_object{Composite, multipleExtensions, S{{[0-9]+}}} }}
 109
 110   RefAggregate danglingAndExtended{Array<int>{}.front(), Composite{}}; // extends only `Composite`, `Array<int>` dangles
 111   clang_analyzer_dump(danglingAndExtended.rx); // expected-warning-re {{&Element{temp_object{Array<int>, S{{[0-9]+}}}.array,0 S64b,int} }}
 112   clang_analyzer_dump(danglingAndExtended.ry); // expected-warning-re {{&lifetime_extended_object{Composite, danglingAndExtended, S{{[0-9]+}}} }}
 113
 114   int i = 10;
 115   RefAggregate varAndExtended{i, Composite{}};  // extends `Composite`
 116   clang_analyzer_dump(varAndExtended.rx); // expected-warning {{&i }}
 117   clang_analyzer_dump(varAndExtended.ry); // expected-warning-re {{&lifetime_extended_object{Composite, varAndExtended, S{{[0-9]+}}} }}
 118
 119   auto const& viaReference = RefAggregate{10, Composite{}}; // extends `int`, `Composite`, and `RefAggregate`
 120   clang_analyzer_dump(viaReference);    // expected-warning-re {{&lifetime_extended_object{RefAggregate, viaReference, S{{[0-9]+}}} }}
 121   clang_analyzer_dump(viaReference.rx); // expected-warning-re {{&lifetime_extended_object{int, viaReference, S{{[0-9]+}}} }}
 122   clang_analyzer_dump(viaReference.ry); // expected-warning-re {{&lifetime_extended_object{Composite, viaReference, S{{[0-9]+}}} }}
 123
 124   // FIXME: clang currently support extending lifetime of object bound to reference members of aggregates,
 125   // that are created from default member initializer. But CFG and ExprEngine need to be updated to address this change.
 126   // The following expect warning: {{&lifetime_extended_object{Composite, defaultInitExtended, S{{[0-9]+}}} }}
 127   RefAggregate defaultInitExtended{i};
 128   clang_analyzer_dump(defaultInitExtended.ry); // expected-warning {{Unknown }}
 129 }
 130
 131 void lambda() {
 132   auto const& lambdaRef = [capture = create<Composite>()] {};
 133   clang_analyzer_dump(lambdaRef); // expected-warning-re {{lifetime_extended_object{class (lambda at {{[^)]+}}), lambdaRef, S{{[0-9]+}}} }}
 134
 135   // The capture [&refCapture = create<Composite const>()] { ... } per [expr.prim.lambda.capture] p6 equivalent to:
 136   //   auto& refCapture = create<Composite const>(); // Well-formed, deduces auto = Composite const, and performs lifetime extension
 137   //   [&refCapture] { ... }
 138   // Where 'refCapture' has the same lifetime as the lambda itself.
 139   // However, compilers differ: Clang lifetime-extends from C++17, GCC rejects the code, and MSVC dangles
 140   // See also CWG2737 (https://cplusplus.github.io/CWG/issues/2737.html)
 141   auto const refExtendingCapture = [&refCapture = create<Composite const>()] {
 142      clang_analyzer_dump(refCapture);
 143      // cpp14-warning-re@-1 {{&temp_object{const struct Composite, S{{[0-9]+}}} }}
 144      // cpp17-warning-re@-2 {{&lifetime_extended_object{const struct Composite, refExtendingCapture, S{{[0-9]+}}} }}
 145   };
 146   refExtendingCapture();
 147 }
 148
 149 void viaStructuredBinding() {
 150   auto&& [x, y] = Composite{}; // extends `Composite` and binds it to unnamed decomposed object
 151   clang_analyzer_dump(x); // expected-warning-re {{&lifetime_extended_object{Composite, D{{[0-9]+}}, S{{[0-9]+}}}.x }}
 152   clang_analyzer_dump(y); // expected-warning-re {{&lifetime_extended_object{Composite, D{{[0-9]+}}, S{{[0-9]+}}}.y }}
 153
 154   auto&& [rx, ry] = RefAggregate{10, Composite{}}; // extends `int`, `Composite`, and `RefAggregate`, and binds them to unnamed decomposed object
 155   clang_analyzer_dump(rx); // expected-warning-re {{&lifetime_extended_object{int, D{{[0-9]+}}, S{{[0-9]+}}} }}
 156   clang_analyzer_dump(ry); // expected-warning-re {{&lifetime_extended_object{Composite, D{{[0-9]+}}, S{{[0-9]+}}} }}
 157 }
 158
 159 void propagation(bool cond) {
 160   int const& le = Composite{}.x;
 161   // May return lifetime-extended region or dangling temporary
 162   auto&& oneDangling = select(cond, le, 10); // does not extend lifetime of arguments
 163   clang_analyzer_dump(oneDangling);
 164   // expected-warning-re@-1 {{&lifetime_extended_object{Composite, le, S{{[0-9]+}}}.x }}
 165   // expected-warning-re@-2 {{&temp_object{int, S{{[0-9]+}}} }}
 166
 167   // Always dangles
 168   auto&& bothDangling = select(cond, 10, 20); // does not extend lifetime of arguments
 169   clang_analyzer_dump(bothDangling);
 170   // expected-warning-re@-1 {{&temp_object{int, S{{[0-9]+}}} }}
 171   // expected-warning-re@-2 {{&temp_object{int, S{{[0-9]+}}} }}
 172 }