• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //==- UnreachableCodeChecker.cpp - Generalized dead code checker -*- C++ -*-==//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 // This file implements a generalized unreachable code checker using a
10 // path-sensitive analysis. We mark any path visited, and then walk the CFG as a
11 // post-analysis to determine what was never visited.
12 //
13 // A similar flow-sensitive only check exists in Analysis/ReachableCode.cpp
14 //===----------------------------------------------------------------------===//
15 
16 #include "ClangSACheckers.h"
17 #include "clang/AST/ParentMap.h"
18 #include "clang/Basic/Builtins.h"
19 #include "clang/Basic/SourceManager.h"
20 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
21 #include "clang/StaticAnalyzer/Core/Checker.h"
22 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
23 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
24 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h"
25 #include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h"
26 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h"
27 #include "llvm/ADT/SmallSet.h"
28 
29 using namespace clang;
30 using namespace ento;
31 
32 namespace {
33 class UnreachableCodeChecker : public Checker<check::EndAnalysis> {
34 public:
35   void checkEndAnalysis(ExplodedGraph &G, BugReporter &B,
36                         ExprEngine &Eng) const;
37 private:
38   typedef llvm::SmallSet<unsigned, 32> CFGBlocksSet;
39 
40   static inline const Stmt *getUnreachableStmt(const CFGBlock *CB);
41   static void FindUnreachableEntryPoints(const CFGBlock *CB,
42                                          CFGBlocksSet &reachable,
43                                          CFGBlocksSet &visited);
44   static bool isInvalidPath(const CFGBlock *CB, const ParentMap &PM);
45   static inline bool isEmptyCFGBlock(const CFGBlock *CB);
46 };
47 }
48 
checkEndAnalysis(ExplodedGraph & G,BugReporter & B,ExprEngine & Eng) const49 void UnreachableCodeChecker::checkEndAnalysis(ExplodedGraph &G,
50                                               BugReporter &B,
51                                               ExprEngine &Eng) const {
52   CFGBlocksSet reachable, visited;
53 
54   if (Eng.hasWorkRemaining())
55     return;
56 
57   const Decl *D = nullptr;
58   CFG *C = nullptr;
59   ParentMap *PM = nullptr;
60   const LocationContext *LC = nullptr;
61   // Iterate over ExplodedGraph
62   for (ExplodedGraph::node_iterator I = G.nodes_begin(), E = G.nodes_end();
63       I != E; ++I) {
64     const ProgramPoint &P = I->getLocation();
65     LC = P.getLocationContext();
66     if (!LC->inTopFrame())
67       continue;
68 
69     if (!D)
70       D = LC->getAnalysisDeclContext()->getDecl();
71 
72     // Save the CFG if we don't have it already
73     if (!C)
74       C = LC->getAnalysisDeclContext()->getUnoptimizedCFG();
75     if (!PM)
76       PM = &LC->getParentMap();
77 
78     if (Optional<BlockEntrance> BE = P.getAs<BlockEntrance>()) {
79       const CFGBlock *CB = BE->getBlock();
80       reachable.insert(CB->getBlockID());
81     }
82   }
83 
84   // Bail out if we didn't get the CFG or the ParentMap.
85   if (!D || !C || !PM)
86     return;
87 
88   // Don't do anything for template instantiations.  Proving that code
89   // in a template instantiation is unreachable means proving that it is
90   // unreachable in all instantiations.
91   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
92     if (FD->isTemplateInstantiation())
93       return;
94 
95   // Find CFGBlocks that were not covered by any node
96   for (CFG::const_iterator I = C->begin(), E = C->end(); I != E; ++I) {
97     const CFGBlock *CB = *I;
98     // Check if the block is unreachable
99     if (reachable.count(CB->getBlockID()))
100       continue;
101 
102     // Check if the block is empty (an artificial block)
103     if (isEmptyCFGBlock(CB))
104       continue;
105 
106     // Find the entry points for this block
107     if (!visited.count(CB->getBlockID()))
108       FindUnreachableEntryPoints(CB, reachable, visited);
109 
110     // This block may have been pruned; check if we still want to report it
111     if (reachable.count(CB->getBlockID()))
112       continue;
113 
114     // Check for false positives
115     if (CB->size() > 0 && isInvalidPath(CB, *PM))
116       continue;
117 
118     // It is good practice to always have a "default" label in a "switch", even
119     // if we should never get there. It can be used to detect errors, for
120     // instance. Unreachable code directly under a "default" label is therefore
121     // likely to be a false positive.
122     if (const Stmt *label = CB->getLabel())
123       if (label->getStmtClass() == Stmt::DefaultStmtClass)
124         continue;
125 
126     // Special case for __builtin_unreachable.
127     // FIXME: This should be extended to include other unreachable markers,
128     // such as llvm_unreachable.
129     if (!CB->empty()) {
130       bool foundUnreachable = false;
131       for (CFGBlock::const_iterator ci = CB->begin(), ce = CB->end();
132            ci != ce; ++ci) {
133         if (Optional<CFGStmt> S = (*ci).getAs<CFGStmt>())
134           if (const CallExpr *CE = dyn_cast<CallExpr>(S->getStmt())) {
135             if (CE->getBuiltinCallee() == Builtin::BI__builtin_unreachable) {
136               foundUnreachable = true;
137               break;
138             }
139           }
140       }
141       if (foundUnreachable)
142         continue;
143     }
144 
145     // We found a block that wasn't covered - find the statement to report
146     SourceRange SR;
147     PathDiagnosticLocation DL;
148     SourceLocation SL;
149     if (const Stmt *S = getUnreachableStmt(CB)) {
150       SR = S->getSourceRange();
151       DL = PathDiagnosticLocation::createBegin(S, B.getSourceManager(), LC);
152       SL = DL.asLocation();
153       if (SR.isInvalid() || !SL.isValid())
154         continue;
155     }
156     else
157       continue;
158 
159     // Check if the SourceLocation is in a system header
160     const SourceManager &SM = B.getSourceManager();
161     if (SM.isInSystemHeader(SL) || SM.isInExternCSystemHeader(SL))
162       continue;
163 
164     B.EmitBasicReport(D, this, "Unreachable code", "Dead code",
165                       "This statement is never executed", DL, SR);
166   }
167 }
168 
169 // Recursively finds the entry point(s) for this dead CFGBlock.
FindUnreachableEntryPoints(const CFGBlock * CB,CFGBlocksSet & reachable,CFGBlocksSet & visited)170 void UnreachableCodeChecker::FindUnreachableEntryPoints(const CFGBlock *CB,
171                                                         CFGBlocksSet &reachable,
172                                                         CFGBlocksSet &visited) {
173   visited.insert(CB->getBlockID());
174 
175   for (CFGBlock::const_pred_iterator I = CB->pred_begin(), E = CB->pred_end();
176       I != E; ++I) {
177     if (!*I)
178       continue;
179 
180     if (!reachable.count((*I)->getBlockID())) {
181       // If we find an unreachable predecessor, mark this block as reachable so
182       // we don't report this block
183       reachable.insert(CB->getBlockID());
184       if (!visited.count((*I)->getBlockID()))
185         // If we haven't previously visited the unreachable predecessor, recurse
186         FindUnreachableEntryPoints(*I, reachable, visited);
187     }
188   }
189 }
190 
191 // Find the Stmt* in a CFGBlock for reporting a warning
getUnreachableStmt(const CFGBlock * CB)192 const Stmt *UnreachableCodeChecker::getUnreachableStmt(const CFGBlock *CB) {
193   for (CFGBlock::const_iterator I = CB->begin(), E = CB->end(); I != E; ++I) {
194     if (Optional<CFGStmt> S = I->getAs<CFGStmt>())
195       return S->getStmt();
196   }
197   if (const Stmt *S = CB->getTerminator())
198     return S;
199   else
200     return nullptr;
201 }
202 
203 // Determines if the path to this CFGBlock contained an element that infers this
204 // block is a false positive. We assume that FindUnreachableEntryPoints has
205 // already marked only the entry points to any dead code, so we need only to
206 // find the condition that led to this block (the predecessor of this block.)
207 // There will never be more than one predecessor.
isInvalidPath(const CFGBlock * CB,const ParentMap & PM)208 bool UnreachableCodeChecker::isInvalidPath(const CFGBlock *CB,
209                                            const ParentMap &PM) {
210   // We only expect a predecessor size of 0 or 1. If it is >1, then an external
211   // condition has broken our assumption (for example, a sink being placed by
212   // another check). In these cases, we choose not to report.
213   if (CB->pred_size() > 1)
214     return true;
215 
216   // If there are no predecessors, then this block is trivially unreachable
217   if (CB->pred_size() == 0)
218     return false;
219 
220   const CFGBlock *pred = *CB->pred_begin();
221   if (!pred)
222     return false;
223 
224   // Get the predecessor block's terminator conditon
225   const Stmt *cond = pred->getTerminatorCondition();
226 
227   //assert(cond && "CFGBlock's predecessor has a terminator condition");
228   // The previous assertion is invalid in some cases (eg do/while). Leaving
229   // reporting of these situations on at the moment to help triage these cases.
230   if (!cond)
231     return false;
232 
233   // Run each of the checks on the conditions
234   return containsMacro(cond) || containsEnum(cond) ||
235          containsStaticLocal(cond) || containsBuiltinOffsetOf(cond) ||
236          containsStmt<UnaryExprOrTypeTraitExpr>(cond);
237 }
238 
239 // Returns true if the given CFGBlock is empty
isEmptyCFGBlock(const CFGBlock * CB)240 bool UnreachableCodeChecker::isEmptyCFGBlock(const CFGBlock *CB) {
241   return CB->getLabel() == nullptr // No labels
242       && CB->size() == 0           // No statements
243       && !CB->getTerminator();     // No terminator
244 }
245 
registerUnreachableCodeChecker(CheckerManager & mgr)246 void ento::registerUnreachableCodeChecker(CheckerManager &mgr) {
247   mgr.registerChecker<UnreachableCodeChecker>();
248 }
249