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/StaticAnalyzer/Core/Checker.h" 18 #include "clang/StaticAnalyzer/Core/CheckerManager.h" 19 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h" 20 #include "clang/StaticAnalyzer/Core/PathSensitive/ExplodedGraph.h" 21 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h" 22 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerHelpers.h" 23 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h" 24 #include "clang/AST/ParentMap.h" 25 #include "clang/Basic/Builtins.h" 26 #include "clang/Basic/SourceManager.h" 27 #include "llvm/ADT/SmallPtrSet.h" 28 29 // The number of CFGBlock pointers we want to reserve memory for. This is used 30 // once for each function we analyze. 31 #define DEFAULT_CFGBLOCKS 256 32 33 using namespace clang; 34 using namespace ento; 35 36 namespace { 37 class UnreachableCodeChecker : public Checker<check::EndAnalysis> { 38 public: 39 void checkEndAnalysis(ExplodedGraph &G, BugReporter &B, 40 ExprEngine &Eng) const; 41 private: 42 typedef llvm::SmallSet<unsigned, DEFAULT_CFGBLOCKS> CFGBlocksSet; 43 44 static inline const Stmt *getUnreachableStmt(const CFGBlock *CB); 45 static void FindUnreachableEntryPoints(const CFGBlock *CB, 46 CFGBlocksSet &reachable, 47 CFGBlocksSet &visited); 48 static bool isInvalidPath(const CFGBlock *CB, const ParentMap &PM); 49 static inline bool isEmptyCFGBlock(const CFGBlock *CB); 50 }; 51 } 52 53 void UnreachableCodeChecker::checkEndAnalysis(ExplodedGraph &G, 54 BugReporter &B, 55 ExprEngine &Eng) const { 56 CFGBlocksSet reachable, visited; 57 58 if (Eng.hasWorkRemaining()) 59 return; 60 61 CFG *C = 0; 62 ParentMap *PM = 0; 63 // Iterate over ExplodedGraph 64 for (ExplodedGraph::node_iterator I = G.nodes_begin(), E = G.nodes_end(); 65 I != E; ++I) { 66 const ProgramPoint &P = I->getLocation(); 67 const LocationContext *LC = P.getLocationContext(); 68 69 // Save the CFG if we don't have it already 70 if (!C) 71 C = LC->getAnalysisContext()->getUnoptimizedCFG(); 72 if (!PM) 73 PM = &LC->getParentMap(); 74 75 if (const BlockEntrance *BE = dyn_cast<BlockEntrance>(&P)) { 76 const CFGBlock *CB = BE->getBlock(); 77 reachable.insert(CB->getBlockID()); 78 } 79 } 80 81 // Bail out if we didn't get the CFG or the ParentMap. 82 if (!C || !PM) 83 return; 84 85 ASTContext &Ctx = B.getContext(); 86 87 // Find CFGBlocks that were not covered by any node 88 for (CFG::const_iterator I = C->begin(), E = C->end(); I != E; ++I) { 89 const CFGBlock *CB = *I; 90 // Check if the block is unreachable 91 if (reachable.count(CB->getBlockID())) 92 continue; 93 94 // Check if the block is empty (an artificial block) 95 if (isEmptyCFGBlock(CB)) 96 continue; 97 98 // Find the entry points for this block 99 if (!visited.count(CB->getBlockID())) 100 FindUnreachableEntryPoints(CB, reachable, visited); 101 102 // This block may have been pruned; check if we still want to report it 103 if (reachable.count(CB->getBlockID())) 104 continue; 105 106 // Check for false positives 107 if (CB->size() > 0 && isInvalidPath(CB, *PM)) 108 continue; 109 110 // Special case for __builtin_unreachable. 111 // FIXME: This should be extended to include other unreachable markers, 112 // such as llvm_unreachable. 113 if (!CB->empty()) { 114 bool foundUnreachable = false; 115 for (CFGBlock::const_iterator ci = CB->begin(), ce = CB->end(); 116 ci != ce; ++ci) { 117 if (const CFGStmt *S = (*ci).getAs<CFGStmt>()) 118 if (const CallExpr *CE = dyn_cast<CallExpr>(S->getStmt())) { 119 if (CE->isBuiltinCall(Ctx) == Builtin::BI__builtin_unreachable) { 120 foundUnreachable = true; 121 break; 122 } 123 } 124 } 125 if (foundUnreachable) 126 continue; 127 } 128 129 // We found a block that wasn't covered - find the statement to report 130 SourceRange SR; 131 SourceLocation SL; 132 if (const Stmt *S = getUnreachableStmt(CB)) { 133 SR = S->getSourceRange(); 134 SL = S->getLocStart(); 135 if (SR.isInvalid() || SL.isInvalid()) 136 continue; 137 } 138 else 139 continue; 140 141 // Check if the SourceLocation is in a system header 142 const SourceManager &SM = B.getSourceManager(); 143 if (SM.isInSystemHeader(SL) || SM.isInExternCSystemHeader(SL)) 144 continue; 145 146 B.EmitBasicReport("Unreachable code", "Dead code", "This statement is never" 147 " executed", SL, SR); 148 } 149 } 150 151 // Recursively finds the entry point(s) for this dead CFGBlock. 152 void UnreachableCodeChecker::FindUnreachableEntryPoints(const CFGBlock *CB, 153 CFGBlocksSet &reachable, 154 CFGBlocksSet &visited) { 155 visited.insert(CB->getBlockID()); 156 157 for (CFGBlock::const_pred_iterator I = CB->pred_begin(), E = CB->pred_end(); 158 I != E; ++I) { 159 if (!reachable.count((*I)->getBlockID())) { 160 // If we find an unreachable predecessor, mark this block as reachable so 161 // we don't report this block 162 reachable.insert(CB->getBlockID()); 163 if (!visited.count((*I)->getBlockID())) 164 // If we haven't previously visited the unreachable predecessor, recurse 165 FindUnreachableEntryPoints(*I, reachable, visited); 166 } 167 } 168 } 169 170 // Find the Stmt* in a CFGBlock for reporting a warning 171 const Stmt *UnreachableCodeChecker::getUnreachableStmt(const CFGBlock *CB) { 172 for (CFGBlock::const_iterator I = CB->begin(), E = CB->end(); I != E; ++I) { 173 if (const CFGStmt *S = I->getAs<CFGStmt>()) 174 return S->getStmt(); 175 } 176 if (const Stmt *S = CB->getTerminator()) 177 return S; 178 else 179 return 0; 180 } 181 182 // Determines if the path to this CFGBlock contained an element that infers this 183 // block is a false positive. We assume that FindUnreachableEntryPoints has 184 // already marked only the entry points to any dead code, so we need only to 185 // find the condition that led to this block (the predecessor of this block.) 186 // There will never be more than one predecessor. 187 bool UnreachableCodeChecker::isInvalidPath(const CFGBlock *CB, 188 const ParentMap &PM) { 189 // We only expect a predecessor size of 0 or 1. If it is >1, then an external 190 // condition has broken our assumption (for example, a sink being placed by 191 // another check). In these cases, we choose not to report. 192 if (CB->pred_size() > 1) 193 return true; 194 195 // If there are no predecessors, then this block is trivially unreachable 196 if (CB->pred_size() == 0) 197 return false; 198 199 const CFGBlock *pred = *CB->pred_begin(); 200 201 // Get the predecessor block's terminator conditon 202 const Stmt *cond = pred->getTerminatorCondition(); 203 204 //assert(cond && "CFGBlock's predecessor has a terminator condition"); 205 // The previous assertion is invalid in some cases (eg do/while). Leaving 206 // reporting of these situations on at the moment to help triage these cases. 207 if (!cond) 208 return false; 209 210 // Run each of the checks on the conditions 211 if (containsMacro(cond) || containsEnum(cond) 212 || containsStaticLocal(cond) || containsBuiltinOffsetOf(cond) 213 || containsStmt<UnaryExprOrTypeTraitExpr>(cond)) 214 return true; 215 216 return false; 217 } 218 219 // Returns true if the given CFGBlock is empty 220 bool UnreachableCodeChecker::isEmptyCFGBlock(const CFGBlock *CB) { 221 return CB->getLabel() == 0 // No labels 222 && CB->size() == 0 // No statements 223 && CB->getTerminator() == 0; // No terminator 224 } 225 226 void ento::registerUnreachableCodeChecker(CheckerManager &mgr) { 227 mgr.registerChecker<UnreachableCodeChecker>(); 228 } 229