Lines Matching +full:sometimes +full:- +full:uninitialized
1 //=- AnalysisBasedWarnings.cpp - Sema warnings based on libAnalysis -*- C++ -*-=//
8 //===----------------------------------------------------------------------===//
14 //===----------------------------------------------------------------------===//
57 //===----------------------------------------------------------------------===//
59 //===----------------------------------------------------------------------===//
103 /// CheckUnreachable - Check for unreachable code.
112 if (!S.getSourceManager().isInMainFile(AC.getDecl()->getLocStart())) in CheckUnreachable()
128 if (E->getExprLoc().isMacroID()) in HasMacroID()
132 for (const Stmt *SubStmt : E->children()) in HasMacroID()
144 SourceRange DiagRange = B->getSourceRange(); in compareAlwaysTrue()
145 S.Diag(B->getExprLoc(), diag::warn_tautological_overlap_comparison) in compareAlwaysTrue()
154 SourceRange DiagRange = B->getSourceRange(); in compareBitwiseEquality()
155 S.Diag(B->getExprLoc(), diag::warn_comparison_bitwise_always) in compareBitwiseEquality()
161 //===----------------------------------------------------------------------===//
162 // Check for infinite self-recursion in functions
163 //===----------------------------------------------------------------------===//
174 const CallExpr *CE = dyn_cast<CallExpr>(B.getAs<CFGStmt>()->getStmt()); in hasRecursiveCallInPath()
175 if (!CE || !CE->getCalleeDecl() || in hasRecursiveCallInPath()
176 CE->getCalleeDecl()->getCanonicalDecl() != FD) in hasRecursiveCallInPath()
181 dyn_cast<DeclRefExpr>(CE->getCallee()->IgnoreParenImpCasts())) { in hasRecursiveCallInPath()
182 if (NestedNameSpecifier *NNS = DRE->getQualifier()) { in hasRecursiveCallInPath()
183 if (NNS->getKind() == NestedNameSpecifier::TypeSpec && in hasRecursiveCallInPath()
184 isa<TemplateSpecializationType>(NNS->getAsType())) { in hasRecursiveCallInPath()
191 if (!MCE || isa<CXXThisExpr>(MCE->getImplicitObjectArgument()) || in hasRecursiveCallInPath()
192 !MCE->getMethodDecl()->isVirtual()) in hasRecursiveCallInPath()
210 const unsigned ExitID = cfg->getExit().getBlockID(); in checkForRecursiveFunctionCall()
213 SmallVector<RecursiveState, 16> States(cfg->getNumBlockIDs(), FoundNoPath); in checkForRecursiveFunctionCall()
214 States[cfg->getEntry().getBlockID()] = FoundPathWithNoRecursiveCall; in checkForRecursiveFunctionCall()
218 Stack.push_back(&cfg->getEntry()); in checkForRecursiveFunctionCall()
224 unsigned ID = CurBlock->getBlockID(); in checkForRecursiveFunctionCall()
239 for (auto I = CurBlock->succ_begin(), E = CurBlock->succ_end(); I != E; ++I) in checkForRecursiveFunctionCall()
241 unsigned next_ID = (*I)->getBlockID(); in checkForRecursiveFunctionCall()
256 FD = FD->getCanonicalDecl(); in checkRecursiveFunction()
258 // Only run on non-templated functions and non-templated members of in checkRecursiveFunction()
260 if (FD->getTemplatedKind() != FunctionDecl::TK_NonTemplate && in checkRecursiveFunction()
261 FD->getTemplatedKind() != FunctionDecl::TK_MemberSpecialization) in checkRecursiveFunction()
268 if (cfg->getExit().pred_empty()) in checkRecursiveFunction()
273 S.Diag(Body->getLocStart(), diag::warn_infinite_recursive_function); in checkRecursiveFunction()
276 //===----------------------------------------------------------------------===//
278 //===----------------------------------------------------------------------===//
288 /// CheckFallThrough - Check that we don't fall off the end of a
303 llvm::BitVector live(cfg->getNumBlockIDs()); in CheckFallThrough()
304 unsigned count = reachable_code::ScanReachableFromBlock(&cfg->getEntry(), in CheckFallThrough()
308 if (!AddEHEdges && count != cfg->getNumBlockIDs()) in CheckFallThrough()
313 if (!live[B->getBlockID()]) { in CheckFallThrough()
314 if (B->pred_begin() == B->pred_end()) { in CheckFallThrough()
315 if (B->getTerminator() && isa<CXXTryStmt>(B->getTerminator())) in CheckFallThrough()
338 I = cfg->getExit().filtered_pred_start_end(FO); I.hasMore(); ++I) { in CheckFallThrough()
343 // Skip blocks which contain an element marked as no-return. They don't in CheckFallThrough()
357 if (ri->getAs<CFGStmt>()) in CheckFallThrough()
371 CFGStmt CS = ri->castAs<CFGStmt>(); in CheckFallThrough()
395 if (std::find(B.succ_begin(), B.succ_end(), &cfg->getExit()) in CheckFallThrough()
429 D.FuncLoc = Func->getLocation(); in MakeForFunction()
440 // might be overridden by non-noreturn functions. in MakeForFunction()
443 isVirtualMethod = Method->isVirtual(); in MakeForFunction()
448 isTemplateInstantiation = Function->isTemplateInstantiation(); in MakeForFunction()
510 /// CheckFallThroughForFunctionDef - Check that we don't fall off the end of a
523 ReturnsVoid = FD->getReturnType()->isVoidType(); in CheckFallThroughForBody()
524 HasNoReturn = FD->isNoReturn(); in CheckFallThroughForBody()
527 ReturnsVoid = MD->getReturnType()->isVoidType(); in CheckFallThroughForBody()
528 HasNoReturn = MD->hasAttr<NoReturnAttr>(); in CheckFallThroughForBody()
531 QualType BlockTy = blkExpr->getType(); in CheckFallThroughForBody()
533 BlockTy->getPointeeType()->getAs<FunctionType>()) { in CheckFallThroughForBody()
534 if (FT->getReturnType()->isVoidType()) in CheckFallThroughForBody()
536 if (FT->getNoReturnAttr()) in CheckFallThroughForBody()
547 SourceLocation LBrace = Body->getLocStart(), RBrace = Body->getLocEnd(); in CheckFallThroughForBody()
548 // Either in a function body compound statement, or a function-try-block. in CheckFallThroughForBody()
581 //===----------------------------------------------------------------------===//
582 // -Wuninitialized
583 //===----------------------------------------------------------------------===//
586 /// ContainsReference - A visitor class to search for references to
619 QualType VariableTy = VD->getType().getCanonicalType(); in SuggestInitializationFixit()
620 if (VariableTy->isBlockPointerType() && in SuggestInitializationFixit()
621 !VD->hasAttr<BlocksAttr>()) { in SuggestInitializationFixit()
622 S.Diag(VD->getLocation(), diag::note_block_var_fixit_add_initialization) in SuggestInitializationFixit()
623 << VD->getDeclName() in SuggestInitializationFixit()
624 << FixItHint::CreateInsertion(VD->getLocation(), "__block "); in SuggestInitializationFixit()
629 if (VD->getInit()) in SuggestInitializationFixit()
633 if (VD->getLocEnd().isMacroID()) in SuggestInitializationFixit()
636 SourceLocation Loc = S.getLocForEndOfToken(VD->getLocEnd()); in SuggestInitializationFixit()
643 S.Diag(Loc, diag::note_var_fixit_add_initialization) << VD->getDeclName() in SuggestInitializationFixit()
648 /// Create a fixit to remove an if-like statement, on the assumption that its
656 CharSourceRange::getCharRange(If->getLocStart(), in CreateIfFixit()
657 Then->getLocStart())); in CreateIfFixit()
659 SourceLocation ElseKwLoc = S.getLocForEndOfToken(Then->getLocEnd()); in CreateIfFixit()
661 SourceRange(ElseKwLoc, Else->getLocEnd())); in CreateIfFixit()
667 CharSourceRange::getCharRange(If->getLocStart(), in CreateIfFixit()
668 Else->getLocStart())); in CreateIfFixit()
670 Fixit1 = FixItHint::CreateRemoval(If->getSourceRange()); in CreateIfFixit()
674 /// DiagUninitUse -- Helper function to produce a diagnostic for an
675 /// uninitialized use of a variable.
682 S.Diag(Use.getUser()->getLocStart(), diag::warn_uninit_var) in DiagUninitUse()
683 << VD->getDeclName() << IsCapturedByBlock in DiagUninitUse()
684 << Use.getUser()->getSourceRange(); in DiagUninitUse()
689 S.Diag(VD->getLocation(), diag::warn_sometimes_uninit_var) in DiagUninitUse()
690 << VD->getDeclName() << IsCapturedByBlock in DiagUninitUse()
692 << const_cast<DeclContext*>(VD->getLexicalDeclContext()) in DiagUninitUse()
693 << VD->getSourceRange(); in DiagUninitUse()
694 S.Diag(Use.getUser()->getLocStart(), diag::note_uninit_var_use) in DiagUninitUse()
695 << IsCapturedByBlock << Use.getUser()->getSourceRange(); in DiagUninitUse()
699 case UninitUse::Sometimes: in DiagUninitUse()
700 // Carry on to report sometimes-uninitialized branches, if possible, in DiagUninitUse()
701 // or a 'may be used uninitialized' diagnostic otherwise. in DiagUninitUse()
705 // Diagnose each branch which leads to a sometimes-uninitialized use. in DiagUninitUse()
708 assert(Use.getKind() == UninitUse::Sometimes); in DiagUninitUse()
711 const Stmt *Term = I->Terminator; in DiagUninitUse()
721 int RemoveDiagKind = -1; in DiagUninitUse()
723 S.getLangOpts().CPlusPlus ? (I->Output ? "true" : "false") in DiagUninitUse()
724 : (I->Output ? "1" : "0"); in DiagUninitUse()
727 switch (Term ? Term->getStmtClass() : Stmt::DeclStmtClass) { in DiagUninitUse()
730 // uninitialized'. FIXME: Can this happen? in DiagUninitUse()
738 Range = IS->getCond()->getSourceRange(); in DiagUninitUse()
740 CreateIfFixit(S, IS, IS->getThen(), IS->getElse(), in DiagUninitUse()
741 I->Output, Fixit1, Fixit2); in DiagUninitUse()
748 Range = CO->getCond()->getSourceRange(); in DiagUninitUse()
750 CreateIfFixit(S, CO, CO->getTrueExpr(), CO->getFalseExpr(), in DiagUninitUse()
751 I->Output, Fixit1, Fixit2); in DiagUninitUse()
756 if (!BO->isLogicalOp()) in DiagUninitUse()
759 Str = BO->getOpcodeStr(); in DiagUninitUse()
760 Range = BO->getLHS()->getSourceRange(); in DiagUninitUse()
762 if ((BO->getOpcode() == BO_LAnd && I->Output) || in DiagUninitUse()
763 (BO->getOpcode() == BO_LOr && !I->Output)) in DiagUninitUse()
764 // true && y -> y, false || y -> y. in DiagUninitUse()
765 Fixit1 = FixItHint::CreateRemoval(SourceRange(BO->getLocStart(), in DiagUninitUse()
766 BO->getOperatorLoc())); in DiagUninitUse()
768 // false && y -> false, true || y -> true. in DiagUninitUse()
769 Fixit1 = FixItHint::CreateReplacement(BO->getSourceRange(), FixitStr); in DiagUninitUse()
777 Range = cast<WhileStmt>(Term)->getCond()->getSourceRange(); in DiagUninitUse()
784 Range = cast<ForStmt>(Term)->getCond()->getSourceRange(); in DiagUninitUse()
786 if (I->Output) in DiagUninitUse()
792 if (I->Output == 1) { in DiagUninitUse()
793 // The use occurs if a range-based for loop's body never executes. in DiagUninitUse()
795 // so treat it as a 'may be uninitialized' case. in DiagUninitUse()
800 Range = cast<CXXForRangeStmt>(Term)->getRangeInit()->getSourceRange(); in DiagUninitUse()
807 Range = cast<DoStmt>(Term)->getCond()->getSourceRange(); in DiagUninitUse()
816 Range = cast<CaseStmt>(Term)->getLHS()->getSourceRange(); in DiagUninitUse()
821 Range = cast<DefaultStmt>(Term)->getDefaultLoc(); in DiagUninitUse()
826 << VD->getDeclName() << IsCapturedByBlock << DiagKind in DiagUninitUse()
827 << Str << I->Output << Range; in DiagUninitUse()
828 S.Diag(User->getLocStart(), diag::note_uninit_var_use) in DiagUninitUse()
829 << IsCapturedByBlock << User->getSourceRange(); in DiagUninitUse()
830 if (RemoveDiagKind != -1) in DiagUninitUse()
832 << RemoveDiagKind << Str << I->Output << Fixit1 << Fixit2; in DiagUninitUse()
838 S.Diag(Use.getUser()->getLocStart(), diag::warn_maybe_uninit_var) in DiagUninitUse()
839 << VD->getDeclName() << IsCapturedByBlock in DiagUninitUse()
840 << Use.getUser()->getSourceRange(); in DiagUninitUse()
843 /// DiagnoseUninitializedUse -- Helper function for diagnosing uses of an
844 /// uninitialized variable. This manages the different forms of diagnostic
854 // specialized diagnostics for self-initialization, and we in DiagnoseUninitializedUse()
861 // uninitialized. Proven code paths which access 'x' in in DiagnoseUninitializedUse()
862 // an uninitialized state after this will still warn. in DiagnoseUninitializedUse()
863 if (const Expr *Initializer = VD->getInit()) { in DiagnoseUninitializedUse()
864 if (!alwaysReportSelfInit && DRE == Initializer->IgnoreParenImpCasts()) in DiagnoseUninitializedUse()
870 S.Diag(DRE->getLocStart(), in DiagnoseUninitializedUse()
872 << VD->getDeclName() << VD->getLocation() << DRE->getSourceRange(); in DiagnoseUninitializedUse()
880 if (VD->getType()->isBlockPointerType() && !VD->hasAttr<BlocksAttr>()) in DiagnoseUninitializedUse()
881 S.Diag(BE->getLocStart(), in DiagnoseUninitializedUse()
883 << VD->getDeclName(); in DiagnoseUninitializedUse()
892 S.Diag(VD->getLocStart(), diag::note_var_declared_here) in DiagnoseUninitializedUse()
893 << VD->getDeclName(); in DiagnoseUninitializedUse()
924 ReachableBlocks.insert(&Cfg->getEntry()); in fillReachableBlocks()
925 BlockQueue.push_back(&Cfg->getEntry()); in fillReachableBlocks()
928 // These blocks can contain fall-through annotations, and we don't want to in fillReachableBlocks()
931 const Stmt *L = B->getLabel(); in fillReachableBlocks()
939 for (CFGBlock::const_succ_iterator I = P->succ_begin(), in fillReachableBlocks()
940 E = P->succ_end(); in fillReachableBlocks()
960 const Stmt *Term = P->getTerminator(); in checkFallThroughIntoBlock()
964 const SwitchCase *SW = dyn_cast_or_null<SwitchCase>(P->getLabel()); in checkFallThroughIntoBlock()
965 if (SW && SW->getSubStmt() == B.getLabel() && P->begin() == P->end()) in checkFallThroughIntoBlock()
968 const LabelStmt *L = dyn_cast_or_null<LabelStmt>(P->getLabel()); in checkFallThroughIntoBlock()
969 if (L && L->getSubStmt() == B.getLabel() && P->begin() == P->end()) in checkFallThroughIntoBlock()
973 for (CFGBlock::const_reverse_iterator ElemIt = P->rbegin(), in checkFallThroughIntoBlock()
974 ElemEnd = P->rend(); in checkFallThroughIntoBlock()
976 if (Optional<CFGStmt> CS = ElemIt->getAs<CFGStmt>()) { in checkFallThroughIntoBlock()
977 if (const AttributedStmt *AS = asFallThroughAttr(CS->getStmt())) { in checkFallThroughIntoBlock()
978 S.Diag(AS->getLocStart(), in checkFallThroughIntoBlock()
1007 std::copy(P->pred_begin(), P->pred_end(), in checkFallThroughIntoBlock()
1042 if (hasSpecificAttr<FallThroughAttr>(AS->getAttrs())) in asFallThroughAttr()
1054 if (Optional<CFGStmt> CS = ElemIt->getAs<CFGStmt>()) in getLastStmt()
1055 return CS->getStmt(); in getLastStmt()
1061 if (!isa<SwitchCase>(SW->getSubStmt())) in getLastStmt()
1062 return SW->getSubStmt(); in getLastStmt()
1111 // NOTE: This an intermediate solution. There are on-going discussions on in DiagnoseSwitchLabelsFallthrough()
1133 const Stmt *Label = B->getLabel(); in DiagnoseSwitchLabelsFallthrough()
1143 S.Diag(Label->getLocStart(), in DiagnoseSwitchLabelsFallthrough()
1148 SourceLocation L = Label->getLocStart(); in DiagnoseSwitchLabelsFallthrough()
1152 const Stmt *Term = B->getTerminator(); in DiagnoseSwitchLabelsFallthrough()
1154 while (B->empty() && !Term && B->succ_size() == 1) { in DiagnoseSwitchLabelsFallthrough()
1155 B = *B->succ_begin(); in DiagnoseSwitchLabelsFallthrough()
1156 Term = B->getTerminator(); in DiagnoseSwitchLabelsFallthrough()
1158 if (!(B->empty() && Term && isa<BreakStmt>(Term))) { in DiagnoseSwitchLabelsFallthrough()
1174 S.Diag(F->getLocStart(), diag::err_fallthrough_attr_invalid_placement); in DiagnoseSwitchLabelsFallthrough()
1182 switch (S->getStmtClass()) { in isInLoop()
1189 const Expr *Cond = cast<DoStmt>(S)->getCond(); in isInLoop()
1191 if (!Cond->EvaluateAsInt(Val, Ctx)) in isInLoop()
1215 const WeakObjectUseMap &WeakMap = CurFn->getWeakObjectUses(); in diagnoseRepeatedUseOfWeak()
1221 const WeakUseVector &Uses = I->second; in diagnoseRepeatedUseOfWeak()
1226 if (UI->isUnsafe()) in diagnoseRepeatedUseOfWeak()
1236 // loop if the base object is a local variable -- local variables are often in diagnoseRepeatedUseOfWeak()
1241 if (UI2->isUnsafe()) in diagnoseRepeatedUseOfWeak()
1245 if (!isInLoop(Ctx, PM, UI->getUseExpr())) in diagnoseRepeatedUseOfWeak()
1248 const WeakObjectProfileTy &Profile = I->first; in diagnoseRepeatedUseOfWeak()
1258 if (BaseVar->hasLocalStorage() && !isa<ParmVarDecl>(Base)) in diagnoseRepeatedUseOfWeak()
1263 UsesByStmt.push_back(StmtUsesPair(UI->getUseExpr(), I)); in diagnoseRepeatedUseOfWeak()
1273 return SM.isBeforeInTranslationUnit(LHS.first->getLocStart(), in diagnoseRepeatedUseOfWeak()
1274 RHS.first->getLocStart()); in diagnoseRepeatedUseOfWeak()
1301 const WeakObjectProfileTy &Key = P.second->first; in diagnoseRepeatedUseOfWeak()
1302 const WeakUseVector &Uses = P.second->second; in diagnoseRepeatedUseOfWeak()
1340 if (Prop->hasAttr<IBOutletAttr>()) in diagnoseRepeatedUseOfWeak()
1344 S.Diag(FirstRead->getLocStart(), DiagKind) in diagnoseRepeatedUseOfWeak()
1346 << FirstRead->getSourceRange(); in diagnoseRepeatedUseOfWeak()
1352 S.Diag(Use.getUseExpr()->getLocStart(), in diagnoseRepeatedUseOfWeak()
1354 << Use.getUseExpr()->getSourceRange(); in diagnoseRepeatedUseOfWeak()
1383 getUses(vd).getPointer()->push_back(use); in handleUseOfUninitVariable()
1398 // Specially handle the case where we have uses of an uninitialized in flushDiagnostics()
1399 // variable, but the root cause is an idiomatic self-init. We want in flushDiagnostics()
1400 // to report the diagnostic at the self-init since that is the root cause. in flushDiagnostics()
1401 if (!vec->empty() && hasSelfInit && hasAlwaysUninitializedUse(vec)) in flushDiagnostics()
1403 UninitUse(vd->getInit()->IgnoreParenCasts(), in flushDiagnostics()
1410 std::sort(vec->begin(), vec->end(), in flushDiagnostics()
1415 return a.getUser()->getLocStart() < b.getUser()->getLocStart(); in flushDiagnostics()
1419 // If we have self-init, downgrade all uses to 'may be uninitialized'. in flushDiagnostics()
1424 // on the first point at which a variable is used uninitialized. in flushDiagnostics()
1438 return std::any_of(vec->begin(), vec->end(), [](const UninitUse &U) { in hasAlwaysUninitializedUse()
1466 //===----------------------------------------------------------------------===//
1467 // -Wthread-safety
1468 //===----------------------------------------------------------------------===//
1482 PartialDiagnosticAt FNote(CurrentFunction->getBody()->getLocStart(), in getNotes()
1484 << CurrentFunction->getNameAsString()); in getNotes()
1493 PartialDiagnosticAt FNote(CurrentFunction->getBody()->getLocStart(), in getNotes()
1495 << CurrentFunction->getNameAsString()); in getNotes()
1507 PartialDiagnosticAt FNote(CurrentFunction->getBody()->getLocStart(), in getNotes()
1509 << CurrentFunction->getNameAsString()); in getNotes()
1625 << D->getNameAsString() << getLockKindFromAccessKind(AK)); in handleNoMutexHeld()
1653 << D->getNameAsString() in handleMutexNotHeld()
1658 PartialDiagnosticAt VNote(D->getLocation(), in handleMutexNotHeld()
1660 << D->getNameAsString()); in handleMutexNotHeld()
1683 << D->getNameAsString() in handleMutexNotHeld()
1686 PartialDiagnosticAt Note(D->getLocation(), in handleMutexNotHeld()
1688 << D->getNameAsString()); in handleMutexNotHeld()
1735 //===----------------------------------------------------------------------===//
1736 // -Wconsumed
1737 //===----------------------------------------------------------------------===//
1828 //===----------------------------------------------------------------------===//
1829 // AnalysisBasedWarnings - Worker object used by Sema to execute analysis-based
1831 //===----------------------------------------------------------------------===//
1873 for (const auto &D : fscope->PossiblyUnreachableDiags) in flushDiagnostics()
1882 // We avoid doing analysis-based warnings when there are errors for in IssueWarnings()
1893 S.SourceMgr.isInSystemHeader(D->getLocation())) in IssueWarnings()
1897 if (cast<DeclContext>(D)->isDependentContext()) in IssueWarnings()
1906 const Stmt *Body = D->getBody(); in IssueWarnings()
1945 // Install the logical handler for -Wtautological-overlap-compare in IssueWarnings()
1948 D->getLocStart())) { in IssueWarnings()
1954 if (!fscope->PossiblyUnreachableDiags.empty()) { in IssueWarnings()
1958 for (const auto &D : fscope->PossiblyUnreachableDiags) { in IssueWarnings()
1965 for (const auto &D : fscope->PossiblyUnreachableDiags) { in IssueWarnings()
1971 // FIXME: We should be able to assert that block is non-null, but in IssueWarnings()
1972 // the CFG analysis can skip potentially-evaluated expressions in in IssueWarnings()
1973 // edge cases; see test/Sema/vla-2.c. in IssueWarnings()
1976 if (cra->isReachable(&AC.getCFG()->getEntry(), block)) in IssueWarnings()
1997 cast<CXXMethodDecl>(D)->getOverloadedOperator() == OO_Call && in IssueWarnings()
1998 cast<CXXMethodDecl>(D)->getParent()->isLambda()) in IssueWarnings()
2006 // Only check for unreachable code on non-template instantiations. in IssueWarnings()
2007 // Different template instantiations can effectively change the control-flow in IssueWarnings()
2012 isTemplateInstantiation = Function->isTemplateInstantiation(); in IssueWarnings()
2019 SourceLocation FL = AC.getDecl()->getLocation(); in IssueWarnings()
2020 SourceLocation FEL = AC.getDecl()->getLocEnd(); in IssueWarnings()
2022 if (!Diags.isIgnored(diag::warn_thread_safety_beta, D->getLocStart())) in IssueWarnings()
2024 if (!Diags.isIgnored(diag::warn_thread_safety_verbose, D->getLocStart())) in IssueWarnings()
2039 if (!Diags.isIgnored(diag::warn_uninit_var, D->getLocStart()) || in IssueWarnings()
2040 !Diags.isIgnored(diag::warn_sometimes_uninit_var, D->getLocStart()) || in IssueWarnings()
2041 !Diags.isIgnored(diag::warn_maybe_uninit_var, D->getLocStart())) { in IssueWarnings()
2064 !Diags.isIgnored(diag::warn_unannotated_fallthrough, D->getLocStart()); in IssueWarnings()
2066 diag::warn_unannotated_fallthrough_per_function, D->getLocStart()); in IssueWarnings()
2068 fscope->HasFallthroughStmt) { in IssueWarnings()
2073 !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, D->getLocStart())) in IssueWarnings()
2077 // Check for infinite self-recursion in functions in IssueWarnings()
2079 D->getLocStart())) { in IssueWarnings()
2086 // for -Wtautological-overlap-compare in IssueWarnings()
2088 D->getLocStart())) { in IssueWarnings()
2098 NumCFGBlocks += cfg->getNumBlockIDs(); in IssueWarnings()
2100 cfg->getNumBlockIDs()); in IssueWarnings()
2110 unsigned NumCFGsBuilt = NumFunctionsAnalyzed - NumFunctionsWithBadCFGs; in PrintStats()