1 //===-- ReachableCode.cpp - Code Reachability Analysis --------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements a flow-sensitive, path-insensitive analysis of 10 // determining reachable blocks within a CFG. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Analysis/Analyses/ReachableCode.h" 15 #include "clang/AST/Expr.h" 16 #include "clang/AST/ExprCXX.h" 17 #include "clang/AST/ExprObjC.h" 18 #include "clang/AST/ParentMap.h" 19 #include "clang/AST/StmtCXX.h" 20 #include "clang/Analysis/AnalysisDeclContext.h" 21 #include "clang/Analysis/CFG.h" 22 #include "clang/Basic/Builtins.h" 23 #include "clang/Basic/SourceManager.h" 24 #include "clang/Lex/Preprocessor.h" 25 #include "llvm/ADT/BitVector.h" 26 #include "llvm/ADT/SmallVector.h" 27 28 using namespace clang; 29 30 //===----------------------------------------------------------------------===// 31 // Core Reachability Analysis routines. 32 //===----------------------------------------------------------------------===// 33 34 static bool isEnumConstant(const Expr *Ex) { 35 const DeclRefExpr *DR = dyn_cast<DeclRefExpr>(Ex); 36 if (!DR) 37 return false; 38 return isa<EnumConstantDecl>(DR->getDecl()); 39 } 40 41 static bool isTrivialExpression(const Expr *Ex) { 42 Ex = Ex->IgnoreParenCasts(); 43 return isa<IntegerLiteral>(Ex) || isa<StringLiteral>(Ex) || 44 isa<CXXBoolLiteralExpr>(Ex) || isa<ObjCBoolLiteralExpr>(Ex) || 45 isa<CharacterLiteral>(Ex) || 46 isEnumConstant(Ex); 47 } 48 49 static bool isTrivialDoWhile(const CFGBlock *B, const Stmt *S) { 50 // Check if the block ends with a do...while() and see if 'S' is the 51 // condition. 52 if (const Stmt *Term = B->getTerminatorStmt()) { 53 if (const DoStmt *DS = dyn_cast<DoStmt>(Term)) { 54 const Expr *Cond = DS->getCond()->IgnoreParenCasts(); 55 return Cond == S && isTrivialExpression(Cond); 56 } 57 } 58 return false; 59 } 60 61 static bool isBuiltinUnreachable(const Stmt *S) { 62 if (const auto *DRE = dyn_cast<DeclRefExpr>(S)) 63 if (const auto *FDecl = dyn_cast<FunctionDecl>(DRE->getDecl())) 64 return FDecl->getIdentifier() && 65 FDecl->getBuiltinID() == Builtin::BI__builtin_unreachable; 66 return false; 67 } 68 69 static bool isBuiltinAssumeFalse(const CFGBlock *B, const Stmt *S, 70 ASTContext &C) { 71 if (B->empty()) { 72 // Happens if S is B's terminator and B contains nothing else 73 // (e.g. a CFGBlock containing only a goto). 74 return false; 75 } 76 if (Optional<CFGStmt> CS = B->back().getAs<CFGStmt>()) { 77 if (const auto *CE = dyn_cast<CallExpr>(CS->getStmt())) { 78 return CE->getCallee()->IgnoreCasts() == S && CE->isBuiltinAssumeFalse(C); 79 } 80 } 81 return false; 82 } 83 84 static bool isDeadReturn(const CFGBlock *B, const Stmt *S) { 85 // Look to see if the current control flow ends with a 'return', and see if 86 // 'S' is a substatement. The 'return' may not be the last element in the 87 // block, or may be in a subsequent block because of destructors. 88 const CFGBlock *Current = B; 89 while (true) { 90 for (const CFGElement &CE : llvm::reverse(*Current)) { 91 if (Optional<CFGStmt> CS = CE.getAs<CFGStmt>()) { 92 if (const ReturnStmt *RS = dyn_cast<ReturnStmt>(CS->getStmt())) { 93 if (RS == S) 94 return true; 95 if (const Expr *RE = RS->getRetValue()) { 96 RE = RE->IgnoreParenCasts(); 97 if (RE == S) 98 return true; 99 ParentMap PM(const_cast<Expr *>(RE)); 100 // If 'S' is in the ParentMap, it is a subexpression of 101 // the return statement. 102 return PM.getParent(S); 103 } 104 } 105 break; 106 } 107 } 108 // Note also that we are restricting the search for the return statement 109 // to stop at control-flow; only part of a return statement may be dead, 110 // without the whole return statement being dead. 111 if (Current->getTerminator().isTemporaryDtorsBranch()) { 112 // Temporary destructors have a predictable control flow, thus we want to 113 // look into the next block for the return statement. 114 // We look into the false branch, as we know the true branch only contains 115 // the call to the destructor. 116 assert(Current->succ_size() == 2); 117 Current = *(Current->succ_begin() + 1); 118 } else if (!Current->getTerminatorStmt() && Current->succ_size() == 1) { 119 // If there is only one successor, we're not dealing with outgoing control 120 // flow. Thus, look into the next block. 121 Current = *Current->succ_begin(); 122 if (Current->pred_size() > 1) { 123 // If there is more than one predecessor, we're dealing with incoming 124 // control flow - if the return statement is in that block, it might 125 // well be reachable via a different control flow, thus it's not dead. 126 return false; 127 } 128 } else { 129 // We hit control flow or a dead end. Stop searching. 130 return false; 131 } 132 } 133 llvm_unreachable("Broke out of infinite loop."); 134 } 135 136 static SourceLocation getTopMostMacro(SourceLocation Loc, SourceManager &SM) { 137 assert(Loc.isMacroID()); 138 SourceLocation Last; 139 do { 140 Last = Loc; 141 Loc = SM.getImmediateMacroCallerLoc(Loc); 142 } while (Loc.isMacroID()); 143 return Last; 144 } 145 146 /// Returns true if the statement is expanded from a configuration macro. 147 static bool isExpandedFromConfigurationMacro(const Stmt *S, 148 Preprocessor &PP, 149 bool IgnoreYES_NO = false) { 150 // FIXME: This is not very precise. Here we just check to see if the 151 // value comes from a macro, but we can do much better. This is likely 152 // to be over conservative. This logic is factored into a separate function 153 // so that we can refine it later. 154 SourceLocation L = S->getBeginLoc(); 155 if (L.isMacroID()) { 156 SourceManager &SM = PP.getSourceManager(); 157 if (IgnoreYES_NO) { 158 // The Objective-C constant 'YES' and 'NO' 159 // are defined as macros. Do not treat them 160 // as configuration values. 161 SourceLocation TopL = getTopMostMacro(L, SM); 162 StringRef MacroName = PP.getImmediateMacroName(TopL); 163 if (MacroName == "YES" || MacroName == "NO") 164 return false; 165 } else if (!PP.getLangOpts().CPlusPlus) { 166 // Do not treat C 'false' and 'true' macros as configuration values. 167 SourceLocation TopL = getTopMostMacro(L, SM); 168 StringRef MacroName = PP.getImmediateMacroName(TopL); 169 if (MacroName == "false" || MacroName == "true") 170 return false; 171 } 172 return true; 173 } 174 return false; 175 } 176 177 static bool isConfigurationValue(const ValueDecl *D, Preprocessor &PP); 178 179 /// Returns true if the statement represents a configuration value. 180 /// 181 /// A configuration value is something usually determined at compile-time 182 /// to conditionally always execute some branch. Such guards are for 183 /// "sometimes unreachable" code. Such code is usually not interesting 184 /// to report as unreachable, and may mask truly unreachable code within 185 /// those blocks. 186 static bool isConfigurationValue(const Stmt *S, 187 Preprocessor &PP, 188 SourceRange *SilenceableCondVal = nullptr, 189 bool IncludeIntegers = true, 190 bool WrappedInParens = false) { 191 if (!S) 192 return false; 193 194 if (const auto *Ex = dyn_cast<Expr>(S)) 195 S = Ex->IgnoreImplicit(); 196 197 if (const auto *Ex = dyn_cast<Expr>(S)) 198 S = Ex->IgnoreCasts(); 199 200 // Special case looking for the sigil '()' around an integer literal. 201 if (const ParenExpr *PE = dyn_cast<ParenExpr>(S)) 202 if (!PE->getBeginLoc().isMacroID()) 203 return isConfigurationValue(PE->getSubExpr(), PP, SilenceableCondVal, 204 IncludeIntegers, true); 205 206 if (const Expr *Ex = dyn_cast<Expr>(S)) 207 S = Ex->IgnoreCasts(); 208 209 bool IgnoreYES_NO = false; 210 211 switch (S->getStmtClass()) { 212 case Stmt::CallExprClass: { 213 const FunctionDecl *Callee = 214 dyn_cast_or_null<FunctionDecl>(cast<CallExpr>(S)->getCalleeDecl()); 215 return Callee ? Callee->isConstexpr() : false; 216 } 217 case Stmt::DeclRefExprClass: 218 return isConfigurationValue(cast<DeclRefExpr>(S)->getDecl(), PP); 219 case Stmt::ObjCBoolLiteralExprClass: 220 IgnoreYES_NO = true; 221 LLVM_FALLTHROUGH; 222 case Stmt::CXXBoolLiteralExprClass: 223 case Stmt::IntegerLiteralClass: { 224 const Expr *E = cast<Expr>(S); 225 if (IncludeIntegers) { 226 if (SilenceableCondVal && !SilenceableCondVal->getBegin().isValid()) 227 *SilenceableCondVal = E->getSourceRange(); 228 return WrappedInParens || 229 isExpandedFromConfigurationMacro(E, PP, IgnoreYES_NO); 230 } 231 return false; 232 } 233 case Stmt::MemberExprClass: 234 return isConfigurationValue(cast<MemberExpr>(S)->getMemberDecl(), PP); 235 case Stmt::UnaryExprOrTypeTraitExprClass: 236 return true; 237 case Stmt::BinaryOperatorClass: { 238 const BinaryOperator *B = cast<BinaryOperator>(S); 239 // Only include raw integers (not enums) as configuration 240 // values if they are used in a logical or comparison operator 241 // (not arithmetic). 242 IncludeIntegers &= (B->isLogicalOp() || B->isComparisonOp()); 243 return isConfigurationValue(B->getLHS(), PP, SilenceableCondVal, 244 IncludeIntegers) || 245 isConfigurationValue(B->getRHS(), PP, SilenceableCondVal, 246 IncludeIntegers); 247 } 248 case Stmt::UnaryOperatorClass: { 249 const UnaryOperator *UO = cast<UnaryOperator>(S); 250 if (UO->getOpcode() != UO_LNot && UO->getOpcode() != UO_Minus) 251 return false; 252 bool SilenceableCondValNotSet = 253 SilenceableCondVal && SilenceableCondVal->getBegin().isInvalid(); 254 bool IsSubExprConfigValue = 255 isConfigurationValue(UO->getSubExpr(), PP, SilenceableCondVal, 256 IncludeIntegers, WrappedInParens); 257 // Update the silenceable condition value source range only if the range 258 // was set directly by the child expression. 259 if (SilenceableCondValNotSet && 260 SilenceableCondVal->getBegin().isValid() && 261 *SilenceableCondVal == 262 UO->getSubExpr()->IgnoreCasts()->getSourceRange()) 263 *SilenceableCondVal = UO->getSourceRange(); 264 return IsSubExprConfigValue; 265 } 266 default: 267 return false; 268 } 269 } 270 271 static bool isConfigurationValue(const ValueDecl *D, Preprocessor &PP) { 272 if (const EnumConstantDecl *ED = dyn_cast<EnumConstantDecl>(D)) 273 return isConfigurationValue(ED->getInitExpr(), PP); 274 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 275 // As a heuristic, treat globals as configuration values. Note 276 // that we only will get here if Sema evaluated this 277 // condition to a constant expression, which means the global 278 // had to be declared in a way to be a truly constant value. 279 // We could generalize this to local variables, but it isn't 280 // clear if those truly represent configuration values that 281 // gate unreachable code. 282 if (!VD->hasLocalStorage()) 283 return true; 284 285 // As a heuristic, locals that have been marked 'const' explicitly 286 // can be treated as configuration values as well. 287 return VD->getType().isLocalConstQualified(); 288 } 289 return false; 290 } 291 292 /// Returns true if we should always explore all successors of a block. 293 static bool shouldTreatSuccessorsAsReachable(const CFGBlock *B, 294 Preprocessor &PP) { 295 if (const Stmt *Term = B->getTerminatorStmt()) { 296 if (isa<SwitchStmt>(Term)) 297 return true; 298 // Specially handle '||' and '&&'. 299 if (isa<BinaryOperator>(Term)) { 300 return isConfigurationValue(Term, PP); 301 } 302 } 303 304 const Stmt *Cond = B->getTerminatorCondition(/* stripParens */ false); 305 return isConfigurationValue(Cond, PP); 306 } 307 308 static unsigned scanFromBlock(const CFGBlock *Start, 309 llvm::BitVector &Reachable, 310 Preprocessor *PP, 311 bool IncludeSometimesUnreachableEdges) { 312 unsigned count = 0; 313 314 // Prep work queue 315 SmallVector<const CFGBlock*, 32> WL; 316 317 // The entry block may have already been marked reachable 318 // by the caller. 319 if (!Reachable[Start->getBlockID()]) { 320 ++count; 321 Reachable[Start->getBlockID()] = true; 322 } 323 324 WL.push_back(Start); 325 326 // Find the reachable blocks from 'Start'. 327 while (!WL.empty()) { 328 const CFGBlock *item = WL.pop_back_val(); 329 330 // There are cases where we want to treat all successors as reachable. 331 // The idea is that some "sometimes unreachable" code is not interesting, 332 // and that we should forge ahead and explore those branches anyway. 333 // This allows us to potentially uncover some "always unreachable" code 334 // within the "sometimes unreachable" code. 335 // Look at the successors and mark then reachable. 336 Optional<bool> TreatAllSuccessorsAsReachable; 337 if (!IncludeSometimesUnreachableEdges) 338 TreatAllSuccessorsAsReachable = false; 339 340 for (CFGBlock::const_succ_iterator I = item->succ_begin(), 341 E = item->succ_end(); I != E; ++I) { 342 const CFGBlock *B = *I; 343 if (!B) do { 344 const CFGBlock *UB = I->getPossiblyUnreachableBlock(); 345 if (!UB) 346 break; 347 348 if (!TreatAllSuccessorsAsReachable.hasValue()) { 349 assert(PP); 350 TreatAllSuccessorsAsReachable = 351 shouldTreatSuccessorsAsReachable(item, *PP); 352 } 353 354 if (TreatAllSuccessorsAsReachable.getValue()) { 355 B = UB; 356 break; 357 } 358 } 359 while (false); 360 361 if (B) { 362 unsigned blockID = B->getBlockID(); 363 if (!Reachable[blockID]) { 364 Reachable.set(blockID); 365 WL.push_back(B); 366 ++count; 367 } 368 } 369 } 370 } 371 return count; 372 } 373 374 static unsigned scanMaybeReachableFromBlock(const CFGBlock *Start, 375 Preprocessor &PP, 376 llvm::BitVector &Reachable) { 377 return scanFromBlock(Start, Reachable, &PP, true); 378 } 379 380 //===----------------------------------------------------------------------===// 381 // Dead Code Scanner. 382 //===----------------------------------------------------------------------===// 383 384 namespace { 385 class DeadCodeScan { 386 llvm::BitVector Visited; 387 llvm::BitVector &Reachable; 388 SmallVector<const CFGBlock *, 10> WorkList; 389 Preprocessor &PP; 390 ASTContext &C; 391 392 typedef SmallVector<std::pair<const CFGBlock *, const Stmt *>, 12> 393 DeferredLocsTy; 394 395 DeferredLocsTy DeferredLocs; 396 397 public: 398 DeadCodeScan(llvm::BitVector &reachable, Preprocessor &PP, ASTContext &C) 399 : Visited(reachable.size()), 400 Reachable(reachable), 401 PP(PP), C(C) {} 402 403 void enqueue(const CFGBlock *block); 404 unsigned scanBackwards(const CFGBlock *Start, 405 clang::reachable_code::Callback &CB); 406 407 bool isDeadCodeRoot(const CFGBlock *Block); 408 409 const Stmt *findDeadCode(const CFGBlock *Block); 410 411 void reportDeadCode(const CFGBlock *B, 412 const Stmt *S, 413 clang::reachable_code::Callback &CB); 414 }; 415 } 416 417 void DeadCodeScan::enqueue(const CFGBlock *block) { 418 unsigned blockID = block->getBlockID(); 419 if (Reachable[blockID] || Visited[blockID]) 420 return; 421 Visited[blockID] = true; 422 WorkList.push_back(block); 423 } 424 425 bool DeadCodeScan::isDeadCodeRoot(const clang::CFGBlock *Block) { 426 bool isDeadRoot = true; 427 428 for (CFGBlock::const_pred_iterator I = Block->pred_begin(), 429 E = Block->pred_end(); I != E; ++I) { 430 if (const CFGBlock *PredBlock = *I) { 431 unsigned blockID = PredBlock->getBlockID(); 432 if (Visited[blockID]) { 433 isDeadRoot = false; 434 continue; 435 } 436 if (!Reachable[blockID]) { 437 isDeadRoot = false; 438 Visited[blockID] = true; 439 WorkList.push_back(PredBlock); 440 continue; 441 } 442 } 443 } 444 445 return isDeadRoot; 446 } 447 448 static bool isValidDeadStmt(const Stmt *S) { 449 if (S->getBeginLoc().isInvalid()) 450 return false; 451 if (const BinaryOperator *BO = dyn_cast<BinaryOperator>(S)) 452 return BO->getOpcode() != BO_Comma; 453 return true; 454 } 455 456 const Stmt *DeadCodeScan::findDeadCode(const clang::CFGBlock *Block) { 457 for (CFGBlock::const_iterator I = Block->begin(), E = Block->end(); I!=E; ++I) 458 if (Optional<CFGStmt> CS = I->getAs<CFGStmt>()) { 459 const Stmt *S = CS->getStmt(); 460 if (isValidDeadStmt(S)) 461 return S; 462 } 463 464 CFGTerminator T = Block->getTerminator(); 465 if (T.isStmtBranch()) { 466 const Stmt *S = T.getStmt(); 467 if (S && isValidDeadStmt(S)) 468 return S; 469 } 470 471 return nullptr; 472 } 473 474 static int SrcCmp(const std::pair<const CFGBlock *, const Stmt *> *p1, 475 const std::pair<const CFGBlock *, const Stmt *> *p2) { 476 if (p1->second->getBeginLoc() < p2->second->getBeginLoc()) 477 return -1; 478 if (p2->second->getBeginLoc() < p1->second->getBeginLoc()) 479 return 1; 480 return 0; 481 } 482 483 unsigned DeadCodeScan::scanBackwards(const clang::CFGBlock *Start, 484 clang::reachable_code::Callback &CB) { 485 486 unsigned count = 0; 487 enqueue(Start); 488 489 while (!WorkList.empty()) { 490 const CFGBlock *Block = WorkList.pop_back_val(); 491 492 // It is possible that this block has been marked reachable after 493 // it was enqueued. 494 if (Reachable[Block->getBlockID()]) 495 continue; 496 497 // Look for any dead code within the block. 498 const Stmt *S = findDeadCode(Block); 499 500 if (!S) { 501 // No dead code. Possibly an empty block. Look at dead predecessors. 502 for (CFGBlock::const_pred_iterator I = Block->pred_begin(), 503 E = Block->pred_end(); I != E; ++I) { 504 if (const CFGBlock *predBlock = *I) 505 enqueue(predBlock); 506 } 507 continue; 508 } 509 510 // Specially handle macro-expanded code. 511 if (S->getBeginLoc().isMacroID()) { 512 count += scanMaybeReachableFromBlock(Block, PP, Reachable); 513 continue; 514 } 515 516 if (isDeadCodeRoot(Block)) { 517 reportDeadCode(Block, S, CB); 518 count += scanMaybeReachableFromBlock(Block, PP, Reachable); 519 } 520 else { 521 // Record this statement as the possibly best location in a 522 // strongly-connected component of dead code for emitting a 523 // warning. 524 DeferredLocs.push_back(std::make_pair(Block, S)); 525 } 526 } 527 528 // If we didn't find a dead root, then report the dead code with the 529 // earliest location. 530 if (!DeferredLocs.empty()) { 531 llvm::array_pod_sort(DeferredLocs.begin(), DeferredLocs.end(), SrcCmp); 532 for (const auto &I : DeferredLocs) { 533 const CFGBlock *Block = I.first; 534 if (Reachable[Block->getBlockID()]) 535 continue; 536 reportDeadCode(Block, I.second, CB); 537 count += scanMaybeReachableFromBlock(Block, PP, Reachable); 538 } 539 } 540 541 return count; 542 } 543 544 static SourceLocation GetUnreachableLoc(const Stmt *S, 545 SourceRange &R1, 546 SourceRange &R2) { 547 R1 = R2 = SourceRange(); 548 549 if (const Expr *Ex = dyn_cast<Expr>(S)) 550 S = Ex->IgnoreParenImpCasts(); 551 552 switch (S->getStmtClass()) { 553 case Expr::BinaryOperatorClass: { 554 const BinaryOperator *BO = cast<BinaryOperator>(S); 555 return BO->getOperatorLoc(); 556 } 557 case Expr::UnaryOperatorClass: { 558 const UnaryOperator *UO = cast<UnaryOperator>(S); 559 R1 = UO->getSubExpr()->getSourceRange(); 560 return UO->getOperatorLoc(); 561 } 562 case Expr::CompoundAssignOperatorClass: { 563 const CompoundAssignOperator *CAO = cast<CompoundAssignOperator>(S); 564 R1 = CAO->getLHS()->getSourceRange(); 565 R2 = CAO->getRHS()->getSourceRange(); 566 return CAO->getOperatorLoc(); 567 } 568 case Expr::BinaryConditionalOperatorClass: 569 case Expr::ConditionalOperatorClass: { 570 const AbstractConditionalOperator *CO = 571 cast<AbstractConditionalOperator>(S); 572 return CO->getQuestionLoc(); 573 } 574 case Expr::MemberExprClass: { 575 const MemberExpr *ME = cast<MemberExpr>(S); 576 R1 = ME->getSourceRange(); 577 return ME->getMemberLoc(); 578 } 579 case Expr::ArraySubscriptExprClass: { 580 const ArraySubscriptExpr *ASE = cast<ArraySubscriptExpr>(S); 581 R1 = ASE->getLHS()->getSourceRange(); 582 R2 = ASE->getRHS()->getSourceRange(); 583 return ASE->getRBracketLoc(); 584 } 585 case Expr::CStyleCastExprClass: { 586 const CStyleCastExpr *CSC = cast<CStyleCastExpr>(S); 587 R1 = CSC->getSubExpr()->getSourceRange(); 588 return CSC->getLParenLoc(); 589 } 590 case Expr::CXXFunctionalCastExprClass: { 591 const CXXFunctionalCastExpr *CE = cast <CXXFunctionalCastExpr>(S); 592 R1 = CE->getSubExpr()->getSourceRange(); 593 return CE->getBeginLoc(); 594 } 595 case Stmt::CXXTryStmtClass: { 596 return cast<CXXTryStmt>(S)->getHandler(0)->getCatchLoc(); 597 } 598 case Expr::ObjCBridgedCastExprClass: { 599 const ObjCBridgedCastExpr *CSC = cast<ObjCBridgedCastExpr>(S); 600 R1 = CSC->getSubExpr()->getSourceRange(); 601 return CSC->getLParenLoc(); 602 } 603 default: ; 604 } 605 R1 = S->getSourceRange(); 606 return S->getBeginLoc(); 607 } 608 609 void DeadCodeScan::reportDeadCode(const CFGBlock *B, 610 const Stmt *S, 611 clang::reachable_code::Callback &CB) { 612 // Classify the unreachable code found, or suppress it in some cases. 613 reachable_code::UnreachableKind UK = reachable_code::UK_Other; 614 615 if (isa<BreakStmt>(S)) { 616 UK = reachable_code::UK_Break; 617 } else if (isTrivialDoWhile(B, S) || isBuiltinUnreachable(S) || 618 isBuiltinAssumeFalse(B, S, C)) { 619 return; 620 } 621 else if (isDeadReturn(B, S)) { 622 UK = reachable_code::UK_Return; 623 } 624 625 SourceRange SilenceableCondVal; 626 627 if (UK == reachable_code::UK_Other) { 628 // Check if the dead code is part of the "loop target" of 629 // a for/for-range loop. This is the block that contains 630 // the increment code. 631 if (const Stmt *LoopTarget = B->getLoopTarget()) { 632 SourceLocation Loc = LoopTarget->getBeginLoc(); 633 SourceRange R1(Loc, Loc), R2; 634 635 if (const ForStmt *FS = dyn_cast<ForStmt>(LoopTarget)) { 636 const Expr *Inc = FS->getInc(); 637 Loc = Inc->getBeginLoc(); 638 R2 = Inc->getSourceRange(); 639 } 640 641 CB.HandleUnreachable(reachable_code::UK_Loop_Increment, 642 Loc, SourceRange(), SourceRange(Loc, Loc), R2); 643 return; 644 } 645 646 // Check if the dead block has a predecessor whose branch has 647 // a configuration value that *could* be modified to 648 // silence the warning. 649 CFGBlock::const_pred_iterator PI = B->pred_begin(); 650 if (PI != B->pred_end()) { 651 if (const CFGBlock *PredBlock = PI->getPossiblyUnreachableBlock()) { 652 const Stmt *TermCond = 653 PredBlock->getTerminatorCondition(/* strip parens */ false); 654 isConfigurationValue(TermCond, PP, &SilenceableCondVal); 655 } 656 } 657 } 658 659 SourceRange R1, R2; 660 SourceLocation Loc = GetUnreachableLoc(S, R1, R2); 661 CB.HandleUnreachable(UK, Loc, SilenceableCondVal, R1, R2); 662 } 663 664 //===----------------------------------------------------------------------===// 665 // Reachability APIs. 666 //===----------------------------------------------------------------------===// 667 668 namespace clang { namespace reachable_code { 669 670 void Callback::anchor() { } 671 672 unsigned ScanReachableFromBlock(const CFGBlock *Start, 673 llvm::BitVector &Reachable) { 674 return scanFromBlock(Start, Reachable, /* SourceManager* */ nullptr, false); 675 } 676 677 void FindUnreachableCode(AnalysisDeclContext &AC, Preprocessor &PP, 678 Callback &CB) { 679 680 CFG *cfg = AC.getCFG(); 681 if (!cfg) 682 return; 683 684 // Scan for reachable blocks from the entrance of the CFG. 685 // If there are no unreachable blocks, we're done. 686 llvm::BitVector reachable(cfg->getNumBlockIDs()); 687 unsigned numReachable = 688 scanMaybeReachableFromBlock(&cfg->getEntry(), PP, reachable); 689 if (numReachable == cfg->getNumBlockIDs()) 690 return; 691 692 // If there aren't explicit EH edges, we should include the 'try' dispatch 693 // blocks as roots. 694 if (!AC.getCFGBuildOptions().AddEHEdges) { 695 for (const CFGBlock *B : cfg->try_blocks()) 696 numReachable += scanMaybeReachableFromBlock(B, PP, reachable); 697 if (numReachable == cfg->getNumBlockIDs()) 698 return; 699 } 700 701 // There are some unreachable blocks. We need to find the root blocks that 702 // contain code that should be considered unreachable. 703 for (const CFGBlock *block : *cfg) { 704 // A block may have been marked reachable during this loop. 705 if (reachable[block->getBlockID()]) 706 continue; 707 708 DeadCodeScan DS(reachable, PP, AC.getASTContext()); 709 numReachable += DS.scanBackwards(block, CB); 710 711 if (numReachable == cfg->getNumBlockIDs()) 712 return; 713 } 714 } 715 716 }} // end namespace clang::reachable_code 717