From: Ted Kremenek Date: Thu, 21 Jul 2011 05:22:47 +0000 (+0000) Subject: Simplify passing of CFGBuildOptions around for AnalysisContext. No functionality... X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=bc5cb8a5fe2b88f917d47ceb58b53696a121e57e;p=clang Simplify passing of CFGBuildOptions around for AnalysisContext. No functionality change. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@135666 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/include/clang/Analysis/AnalysisContext.h b/include/clang/Analysis/AnalysisContext.h index 421dbb0dff..0d4446f8ed 100644 --- a/include/clang/Analysis/AnalysisContext.h +++ b/include/clang/Analysis/AnalysisContext.h @@ -19,6 +19,7 @@ #include "clang/AST/Expr.h" #include "clang/Analysis/CFG.h" #include "llvm/ADT/OwningPtr.h" +#include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/PointerUnion.h" #include "llvm/ADT/DenseMap.h" @@ -54,7 +55,6 @@ class AnalysisContext { CFG::BuildOptions::ForcedBlkExprs *forcedBlkExprs; bool builtCFG, builtCompleteCFG; - const bool useUnoptimizedCFG; llvm::OwningPtr liveness; llvm::OwningPtr relaxedLiveness; @@ -68,11 +68,10 @@ class AnalysisContext { llvm::DenseMap *ReferencedBlockVars; public: + AnalysisContext(const Decl *d, idx::TranslationUnit *tu); + AnalysisContext(const Decl *d, idx::TranslationUnit *tu, - bool useUnoptimizedCFG = false, - bool addehedges = false, - bool addImplicitDtors = false, - bool addInitializers = false); + const CFG::BuildOptions &buildOptions); ~AnalysisContext(); @@ -96,7 +95,7 @@ public: /// cope with that. bool getAddEHEdges() const { return cfgBuildOptions.AddEHEdges; } bool getUseUnoptimizedCFG() const { - return cfgBuildOptions.PruneTriviallyFalseEdges; + return !cfgBuildOptions.PruneTriviallyFalseEdges; } bool getAddImplicitDtors() const { return cfgBuildOptions.AddImplicitDtors; } bool getAddInitializers() const { return cfgBuildOptions.AddInitializers; } @@ -139,24 +138,25 @@ public: class AnalysisContextManager { typedef llvm::DenseMap ContextMap; ContextMap Contexts; - bool UseUnoptimizedCFG; - bool AddImplicitDtors; - bool AddInitializers; + CFG::BuildOptions cfgBuildOptions; public: AnalysisContextManager(bool useUnoptimizedCFG = false, - bool addImplicitDtors = false, bool addInitializers = false) - : UseUnoptimizedCFG(useUnoptimizedCFG), AddImplicitDtors(addImplicitDtors), - AddInitializers(addInitializers) {} + bool addImplicitDtors = false, + bool addInitializers = false); ~AnalysisContextManager(); AnalysisContext *getContext(const Decl *D, idx::TranslationUnit *TU = 0); - bool getUseUnoptimizedCFG() const { return UseUnoptimizedCFG; } - bool getAddImplicitDtors() const { return AddImplicitDtors; } - bool getAddInitializers() const { return AddInitializers; } + bool getUseUnoptimizedCFG() const { + return !cfgBuildOptions.PruneTriviallyFalseEdges; + } + + CFG::BuildOptions &getCFGBuildOptions() { + return cfgBuildOptions; + } - // Discard all previously created AnalysisContexts. + /// Discard all previously created AnalysisContexts. void clear(); }; diff --git a/include/clang/Analysis/CFG.h b/include/clang/Analysis/CFG.h index f7a0f95847..87f32a5166 100644 --- a/include/clang/Analysis/CFG.h +++ b/include/clang/Analysis/CFG.h @@ -536,17 +536,18 @@ public: typedef llvm::DenseMap ForcedBlkExprs; ForcedBlkExprs **forcedBlkExprs; - bool PruneTriviallyFalseEdges:1; - bool AddEHEdges:1; - bool AddInitializers:1; - bool AddImplicitDtors:1; + bool PruneTriviallyFalseEdges; + bool AddEHEdges; + bool AddInitializers; + bool AddImplicitDtors; bool alwaysAdd(const Stmt *stmt) const { return alwaysAddMask[stmt->getStmtClass()]; } - void setAlwaysAdd(Stmt::StmtClass stmtClass) { + BuildOptions &setAlwaysAdd(Stmt::StmtClass stmtClass) { alwaysAddMask[stmtClass] = true; + return *this; } BuildOptions() diff --git a/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h b/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h index 1ba038e6da..9452a7d9d8 100644 --- a/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h +++ b/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h @@ -86,7 +86,6 @@ public: bool inlinecall, bool useUnoptimizedCFG, bool addImplicitDtors, bool addInitializers, bool eagerlyTrimEGraph) - : AnaCtxMgr(useUnoptimizedCFG, addImplicitDtors, addInitializers), Ctx(ctx), Diags(diags), LangInfo(lang), PD(pd), CreateStoreMgr(storemgr), CreateConstraintMgr(constraintmgr), diff --git a/lib/Analysis/AnalysisContext.cpp b/lib/Analysis/AnalysisContext.cpp index 678f02fd71..7ee247da00 100644 --- a/lib/Analysis/AnalysisContext.cpp +++ b/lib/Analysis/AnalysisContext.cpp @@ -24,6 +24,7 @@ #include "clang/Analysis/CFG.h" #include "clang/Analysis/CFGStmtMap.h" #include "clang/Analysis/Support/BumpVector.h" +#include "clang/Analysis/Support/SaveAndRestore.h" #include "llvm/ADT/SmallSet.h" #include "llvm/Support/ErrorHandling.h" @@ -31,18 +32,32 @@ using namespace clang; AnalysisContext::AnalysisContext(const Decl *d, idx::TranslationUnit *tu, - bool useUnoptimizedCFG, - bool addehedges, - bool addImplicitDtors, - bool addInitializers) + const CFG::BuildOptions &buildOptions) : D(d), TU(tu), + cfgBuildOptions(buildOptions), forcedBlkExprs(0), - builtCFG(false), builtCompleteCFG(false), - useUnoptimizedCFG(useUnoptimizedCFG), + builtCFG(false), + builtCompleteCFG(false), ReferencedBlockVars(0) -{ +{ cfgBuildOptions.forcedBlkExprs = &forcedBlkExprs; - cfgBuildOptions.AddEHEdges = addehedges; +} + +AnalysisContext::AnalysisContext(const Decl *d, + idx::TranslationUnit *tu) +: D(d), TU(tu), + forcedBlkExprs(0), + builtCFG(false), + builtCompleteCFG(false), + ReferencedBlockVars(0) +{ + cfgBuildOptions.forcedBlkExprs = &forcedBlkExprs; +} + +AnalysisContextManager::AnalysisContextManager(bool useUnoptimizedCFG, + bool addImplicitDtors, + bool addInitializers) { + cfgBuildOptions.PruneTriviallyFalseEdges = !useUnoptimizedCFG; cfgBuildOptions.AddImplicitDtors = addImplicitDtors; cfgBuildOptions.AddInitializers = addInitializers; } @@ -95,7 +110,7 @@ AnalysisContext::getBlockForRegisteredExpression(const Stmt *stmt) { } CFG *AnalysisContext::getCFG() { - if (useUnoptimizedCFG) + if (!cfgBuildOptions.PruneTriviallyFalseEdges) return getUnoptimizedCFG(); if (!builtCFG) { @@ -110,9 +125,10 @@ CFG *AnalysisContext::getCFG() { CFG *AnalysisContext::getUnoptimizedCFG() { if (!builtCompleteCFG) { - CFG::BuildOptions B = cfgBuildOptions; - B.PruneTriviallyFalseEdges = false; - completeCFG.reset(CFG::buildCFG(D, getBody(), &D->getASTContext(), B)); + SaveAndRestore NotPrune(cfgBuildOptions.PruneTriviallyFalseEdges, + false); + completeCFG.reset(CFG::buildCFG(D, getBody(), &D->getASTContext(), + cfgBuildOptions)); // Even when the cfg is not successfully built, we don't // want to try building it again. builtCompleteCFG = true; @@ -187,9 +203,7 @@ AnalysisContext *AnalysisContextManager::getContext(const Decl *D, idx::TranslationUnit *TU) { AnalysisContext *&AC = Contexts[D]; if (!AC) - AC = new AnalysisContext(D, TU, UseUnoptimizedCFG, false, - AddImplicitDtors, AddInitializers); - + AC = new AnalysisContext(D, TU, cfgBuildOptions); return AC; } diff --git a/lib/Sema/AnalysisBasedWarnings.cpp b/lib/Sema/AnalysisBasedWarnings.cpp index c0e271590d..06e42b7728 100644 --- a/lib/Sema/AnalysisBasedWarnings.cpp +++ b/lib/Sema/AnalysisBasedWarnings.cpp @@ -656,10 +656,14 @@ AnalysisBasedWarnings::IssueWarnings(sema::AnalysisBasedWarnings::Policy P, const Stmt *Body = D->getBody(); assert(Body); + AnalysisContext AC(D, 0); + // Don't generate EH edges for CallExprs as we'd like to avoid the n^2 // explosion for destrutors that can result and the compile time hit. - AnalysisContext AC(D, 0, /*useUnoptimizedCFG=*/false, /*addehedges=*/false, - /*addImplicitDtors=*/true, /*addInitializers=*/true); + AC.getCFGBuildOptions().PruneTriviallyFalseEdges = true; + AC.getCFGBuildOptions().AddEHEdges = false; + AC.getCFGBuildOptions().AddInitializers = true; + AC.getCFGBuildOptions().AddImplicitDtors = true; // Force that certain expressions appear as CFGElements in the CFG. This // is used to speed up various analyses. @@ -667,14 +671,16 @@ AnalysisBasedWarnings::IssueWarnings(sema::AnalysisBasedWarnings::Policy P, // prototyping, but we need a way for analyses to say what expressions they // expect to always be CFGElements and then fill in the BuildOptions // appropriately. This is essentially a layering violation. - CFG::BuildOptions &buildOptions = AC.getCFGBuildOptions(); - buildOptions.setAlwaysAdd(Stmt::BinaryOperatorClass); - buildOptions.setAlwaysAdd(Stmt::BlockExprClass); - buildOptions.setAlwaysAdd(Stmt::CStyleCastExprClass); - buildOptions.setAlwaysAdd(Stmt::DeclRefExprClass); - buildOptions.setAlwaysAdd(Stmt::ImplicitCastExprClass); - buildOptions.setAlwaysAdd(Stmt::UnaryOperatorClass); - + AC.getCFGBuildOptions() + .setAlwaysAdd(Stmt::BinaryOperatorClass) + .setAlwaysAdd(Stmt::BlockExprClass) + .setAlwaysAdd(Stmt::CStyleCastExprClass) + .setAlwaysAdd(Stmt::DeclRefExprClass) + .setAlwaysAdd(Stmt::ImplicitCastExprClass) + .setAlwaysAdd(Stmt::UnaryOperatorClass); + + // Construct the analysis context with the specified CFG build options. + // Emit delayed diagnostics. if (!fscope->PossiblyUnreachableDiags.empty()) { bool analyzed = false; diff --git a/lib/StaticAnalyzer/Core/CoreEngine.cpp b/lib/StaticAnalyzer/Core/CoreEngine.cpp index 34cd6e8884..9fcc04e2e4 100644 --- a/lib/StaticAnalyzer/Core/CoreEngine.cpp +++ b/lib/StaticAnalyzer/Core/CoreEngine.cpp @@ -787,7 +787,7 @@ void CallEnterNodeBuilder::generateNode(const GRState *state) { // Create a new AnalysisManager with components of the callee's // TranslationUnit. - // The Diagnostic is actually shared when we create ASTUnits from AST files. + // The Diagnostic is actually shared when we create ASTUnits from AST files. AnalysisManager AMgr(TU->getASTContext(), TU->getDiagnostic(), OldMgr.getLangOptions(), OldMgr.getPathDiagnosticClient(), @@ -803,8 +803,10 @@ void CallEnterNodeBuilder::generateNode(const GRState *state) { OldMgr.shouldTrimGraph(), OldMgr.shouldInlineCall(), OldMgr.getAnalysisContextManager().getUseUnoptimizedCFG(), - OldMgr.getAnalysisContextManager().getAddImplicitDtors(), - OldMgr.getAnalysisContextManager().getAddInitializers(), + OldMgr.getAnalysisContextManager(). + getCFGBuildOptions().AddImplicitDtors, + OldMgr.getAnalysisContextManager(). + getCFGBuildOptions().AddInitializers, OldMgr.shouldEagerlyTrimExplodedGraph()); llvm::OwningPtr TF(MakeCFRefCountTF(AMgr.getASTContext(), /* GCEnabled */ false,