clang/test/Analysis/dead-stores.cpp

   1 // RUN: %clang_analyze_cc1 -fcxx-exceptions -fexceptions -fblocks -std=c++11    \
   2 // RUN:  -analyzer-checker=deadcode.DeadStores -Wno-unreachable-code            \
   3 // RUN:  -analyzer-config deadcode.DeadStores:WarnForDeadNestedAssignments=false\
   4 // RUN:  -verify=non-nested %s
   5 //
   6 // RUN: %clang_analyze_cc1 -fcxx-exceptions -fexceptions -fblocks -std=c++11    \
   7 // RUN:  -analyzer-store=region -analyzer-checker=deadcode.DeadStores           \
   8 // RUN:  -analyzer-config deadcode.DeadStores:WarnForDeadNestedAssignments=false\
   9 // RUN:  -Wno-unreachable-code -verify=non-nested %s
  10 //
  11 // RUN: %clang_analyze_cc1 -fcxx-exceptions -fexceptions -fblocks -std=c++11    \
  12 // RUN:  -analyzer-checker=deadcode.DeadStores -Wno-unreachable-code            \
  13 // RUN:  -verify=non-nested,nested %s
  14
  15 //===----------------------------------------------------------------------===//
  16 // Basic dead store checking (but in C++ mode).
  17 //===----------------------------------------------------------------------===//
  18
  19 int j;
  20 int make_int();
  21 void test1() {
  22   int x = 4;
  23   x = x + 1; // non-nested-warning {{never read}}
  24
  25   switch (j) {
  26   case 1:
  27     throw 1;
  28     (void)x;
  29     break;
  30   }
  31
  32   int y;
  33   (void)y;
  34   if ((y = make_int())) // nested-warning {{Although the value stored}}
  35     return;
  36 }
  37
  38 //===----------------------------------------------------------------------===//
  39 // Dead store checking involving constructors.
  40 //===----------------------------------------------------------------------===//
  41
  42 class Test2 {
  43   int &x;
  44
  45 public:
  46   Test2(int &y) : x(y) {}
  47   ~Test2() { ++x; }
  48 };
  49
  50 int test2(int x) {
  51   { Test2 a(x); } // no-warning
  52   return x;
  53 }
  54
  55 //===----------------------------------------------------------------------===//
  56 // Dead store checking involving CXXTemporaryExprs
  57 //===----------------------------------------------------------------------===//
  58
  59 namespace TestTemp {
  60   template<typename _Tp>
  61   class pencil {
  62   public:
  63     ~pencil() throw() {}
  64   };
  65   template<typename _Tp, typename _Number2> struct _Row_base {
  66     _Row_base(const pencil<_Tp>& x) {}
  67   };
  68   template<typename _Tp, typename _Number2 = TestTemp::pencil<_Tp> >
  69   class row : protected _Row_base<_Tp, _Number2>     {
  70     typedef _Row_base<_Tp, _Number2> _Base;
  71     typedef _Number2 pencil_type;
  72   public:
  73     explicit row(const pencil_type& __a = pencil_type()) : _Base(__a) {}
  74   };
  75 }
  76
  77 void test2_b() {
  78   TestTemp::row<const char*> x; // no-warning
  79 }
  80
  81 //===----------------------------------------------------------------------===//
  82 // Test references.
  83 //===----------------------------------------------------------------------===//
  84
  85 void test3_a(int x) {
  86   x = x + 1; // non-nested-warning {{never read}}
  87 }
  88
  89 void test3_b(int &x) {
  90   x = x + 1; // no-warning
  91 }
  92
  93 void test3_c(int x) {
  94   int &y = x;
  95   // Shows the limitation of dead stores tracking. The write is really dead
  96   // since the value cannot escape the function.
  97   ++y; // no-warning
  98 }
  99
 100 void test3_d(int &x) {
 101   int &y = x;
 102   ++y; // no-warning
 103 }
 104
 105 void test3_e(int &x) {
 106   int &y = x;
 107 }
 108
 109 //===----------------------------------------------------------------------===//
 110 // Dead stores involving 'new'
 111 //===----------------------------------------------------------------------===//
 112
 113 static void test_new(unsigned n) {
 114   char **p = new char *[n]; // non-nested-warning {{never read}}
 115 }
 116
 117 //===----------------------------------------------------------------------===//
 118 // Dead stores in namespaces.
 119 //===----------------------------------------------------------------------===//
 120
 121 namespace foo {
 122 int test_4(int x) {
 123   x = 2; // non-nested-warning {{Value stored to 'x' is never read}}
 124   x = 2;
 125   return x;
 126 }
 127 }
 128
 129 //===----------------------------------------------------------------------===//
 130 // Dead stores in with EH code.
 131 //===----------------------------------------------------------------------===//
 132
 133 void test_5_Aux();
 134 int test_5() {
 135   int x = 0;
 136   try {
 137     x = 2; // no-warning
 138     test_5_Aux();
 139   } catch (int z) {
 140     return x + z;
 141   }
 142   return 1;
 143 }
 144
 145 int test_6_aux(unsigned x);
 146 void test_6() {
 147   unsigned currDestLen = 0; // no-warning
 148   try {
 149     while (test_6_aux(currDestLen)) {
 150       currDestLen += 2; // no-warning
 151     }
 152   } catch (void *) {
 153   }
 154 }
 155
 156 void test_6b() {
 157   unsigned currDestLen = 0; // no-warning
 158   try {
 159     while (test_6_aux(currDestLen)) {
 160       currDestLen += 2;
 161       // non-nested-warning@-1 {{Value stored to 'currDestLen' is never read}}
 162       break;
 163     }
 164   } catch (void *) {
 165   }
 166 }
 167
 168 void testCXX11Using() {
 169   using Int = int;
 170   Int value;
 171   value = 1; // non-nested-warning {{never read}}
 172 }
 173
 174 //===----------------------------------------------------------------------===//
 175 // Dead stores in template instantiations (do not warn).
 176 //===----------------------------------------------------------------------===//
 177
 178 template <bool f> int radar13213575_testit(int i) {
 179   int x = 5+i; // warning: Value stored to 'x' during its initialization is never read
 180   int y = 7;
 181   if (f)
 182     return x;
 183   else
 184     return y;
 185 }
 186
 187 int radar_13213575() {
 188   return radar13213575_testit<true>(5) + radar13213575_testit<false>(3);
 189 }
 190
 191 template <class T>
 192 void test_block_in_dependent_context(typename T::some_t someArray) {
 193   ^{
 194     int i = someArray[0]; // no-warning
 195   }();
 196 }
 197
 198 void test_block_in_non_dependent_context(int *someArray) {
 199   ^{
 200     int i = someArray[0];
 201     // non-nested-warning@-1 {{Value stored to 'i' during its initialization is never read}}
 202   }();
 203 }
 204
 205
 206 //===----------------------------------------------------------------------===//
 207 // Dead store checking involving lambdas.
 208 //===----------------------------------------------------------------------===//
 209
 210 int basicLambda(int i, int j) {
 211   i = 5; // no warning
 212   j = 6; // no warning
 213   [i] { (void)i; }();
 214   [&j] { (void)j; }();
 215   i = 2;
 216   j = 3;
 217   return i + j;
 218 }
 219