maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[analyzer] AnalysisDeclContext: Refactor and documentation 

Summary:
`ScopeContext` wanted to be a thing, but sadly it is dead code.

If you wish to continue the work in D19979, here was a tiny code which
could be reused, but that tiny and that dead, I felt that it is unneded.

Note: Other changes are truly uninteresting.

Reviewed By: NoQ

Differential Revision: https://reviews.llvm.org/D73519
This commit is contained in:
Charusso 2020-03-04 07:06:35 +01:00
parent abdd33c86a
commit 7e1a6ca9e8
3 changed files with 199 additions and 280 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

370
clang/include/clang/Analysis/AnalysisDeclContext.h
View File

@ -1,4 +1,4 @@
// AnalysisDeclContext.h - Analysis context for Path Sens analysis -*- C++ -*-// //===- AnalysisDeclContext.h - Context for path sensitivity -----*- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
@ -6,8 +6,11 @@
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// //
// This file defines AnalysisDeclContext, a class that manages the analysis /// \file
// context data for path sensitive analysis. /// This file defines AnalysisDeclContext, a class that manages the analysis
/// context data for context sensitive and path sensitive analysis.
/// It also defines the helper classes to model entering, leaving or inlining
/// function calls.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
@ -64,14 +67,14 @@ public:
// which creates the analysis object given an AnalysisDeclContext. // which creates the analysis object given an AnalysisDeclContext.
}; };
/// AnalysisDeclContext contains the context data for the function or method /// AnalysisDeclContext contains the context data for the function, method
/// under analysis. /// or block under analysis.
class AnalysisDeclContext { class AnalysisDeclContext {
/// Backpoint to the AnalysisManager object that created this // Backpoint to the AnalysisManager object that created this
/// AnalysisDeclContext. This may be null. // AnalysisDeclContext. This may be null.
AnalysisDeclContextManager *Manager; AnalysisDeclContextManager *ADCMgr;
const Decl * const D; const Decl *const D;
std::unique_ptr<CFG> cfg, completeCFG; std::unique_ptr<CFG> cfg, completeCFG;
std::unique_ptr<CFGStmtMap> cfgStmtMap; std::unique_ptr<CFGStmtMap> cfgStmtMap;
@ -86,45 +89,36 @@ class AnalysisDeclContext {
llvm::BumpPtrAllocator A; llvm::BumpPtrAllocator A;
llvm::DenseMap<const BlockDecl *,void *> *ReferencedBlockVars = nullptr; llvm::DenseMap<const BlockDecl *, void *> *ReferencedBlockVars = nullptr;
void *ManagedAnalyses = nullptr; void *ManagedAnalyses = nullptr;
public: public:
AnalysisDeclContext(AnalysisDeclContextManager *Mgr, AnalysisDeclContext(AnalysisDeclContextManager *Mgr, const Decl *D);
const Decl *D);
AnalysisDeclContext(AnalysisDeclContextManager *Mgr, AnalysisDeclContext(AnalysisDeclContextManager *Mgr, const Decl *D,
const Decl *D, const CFG::BuildOptions &BuildOptions);
const CFG::BuildOptions &BuildOptions);
~AnalysisDeclContext(); ~AnalysisDeclContext();
ASTContext &getASTContext() const { return D->getASTContext(); } ASTContext &getASTContext() const { return D->getASTContext(); }
const Decl *getDecl() const { return D; } const Decl *getDecl() const { return D; }
/// Return the AnalysisDeclContextManager (if any) that created AnalysisDeclContextManager *getManager() const { return ADCMgr; }
/// this AnalysisDeclContext.
AnalysisDeclContextManager *getManager() const {
return Manager;
}
/// Return the build options used to construct the CFG. CFG::BuildOptions &getCFGBuildOptions() { return cfgBuildOptions; }
CFG::BuildOptions &getCFGBuildOptions() {
return cfgBuildOptions;
}
const CFG::BuildOptions &getCFGBuildOptions() const { const CFG::BuildOptions &getCFGBuildOptions() const {
return cfgBuildOptions; return cfgBuildOptions;
} }
/// getAddEHEdges - Return true iff we are adding exceptional edges from /// \returns Whether we are adding exception handling edges from CallExprs.
/// callExprs. If this is false, then try/catch statements and blocks /// If this is false, then try/catch statements and blocks reachable from them
/// reachable from them can appear to be dead in the CFG, analysis passes must /// can appear to be dead in the CFG, analysis passes must cope with that.
/// cope with that.
bool getAddEHEdges() const { return cfgBuildOptions.AddEHEdges; } bool getAddEHEdges() const { return cfgBuildOptions.AddEHEdges; }
bool getUseUnoptimizedCFG() const { bool getUseUnoptimizedCFG() const {
return !cfgBuildOptions.PruneTriviallyFalseEdges; return !cfgBuildOptions.PruneTriviallyFalseEdges;
} }
bool getAddImplicitDtors() const { return cfgBuildOptions.AddImplicitDtors; } bool getAddImplicitDtors() const { return cfgBuildOptions.AddImplicitDtors; }
bool getAddInitializers() const { return cfgBuildOptions.AddInitializers; } bool getAddInitializers() const { return cfgBuildOptions.AddInitializers; }
@ -132,25 +126,25 @@ public:
void registerForcedBlockExpression(const Stmt *stmt); void registerForcedBlockExpression(const Stmt *stmt);
const CFGBlock *getBlockForRegisteredExpression(const Stmt *stmt); const CFGBlock *getBlockForRegisteredExpression(const Stmt *stmt);
/// Get the body of the Declaration. /// \returns The body of the stored Decl \c D.
Stmt *getBody() const; Stmt *getBody() const;
/// Get the body of the Declaration. /// \copydoc AnalysisDeclContext::getBody()
/// \param[out] IsAutosynthesized Specifies if the body is auto-generated /// \param[out] IsAutosynthesized Specifies if the body is auto-generated
/// by the BodyFarm. /// by the BodyFarm.
Stmt *getBody(bool &IsAutosynthesized) const; Stmt *getBody(bool &IsAutosynthesized) const;
/// Checks if the body of the Decl is generated by the BodyFarm. /// \returns Whether the body of the Decl \c D is generated by the BodyFarm.
/// ///
/// Note, the lookup is not free. We are going to call getBody behind /// \note The lookup is not free. We are going to call getBody behind
/// the scenes. /// the scenes.
/// \sa getBody /// \sa getBody
bool isBodyAutosynthesized() const; bool isBodyAutosynthesized() const;
/// Checks if the body of the Decl is generated by the BodyFarm from a /// \returns Whether the body of the Decl \c D is generated by the BodyFarm
/// model file. /// from a model file.
/// ///
/// Note, the lookup is not free. We are going to call getBody behind /// \note The lookup is not free. We are going to call getBody behind
/// the scenes. /// the scenes.
/// \sa getBody /// \sa getBody
bool isBodyAutosynthesizedFromModelFile() const; bool isBodyAutosynthesizedFromModelFile() const;
@ -161,40 +155,41 @@ public:
CFGReverseBlockReachabilityAnalysis *getCFGReachablityAnalysis(); CFGReverseBlockReachabilityAnalysis *getCFGReachablityAnalysis();
/// Return a version of the CFG without any edges pruned. /// \returns A version of the CFG without any edges pruned.
CFG *getUnoptimizedCFG(); CFG *getUnoptimizedCFG();
void dumpCFG(bool ShowColors); void dumpCFG(bool ShowColors);
/// Returns true if we have built a CFG for this analysis context. /// \returns Whether we have built a CFG for this analysis context.
/// Note that this doesn't correspond to whether or not a valid CFG exists, it ///
/// \note This doesn't correspond to whether or not a valid CFG exists, it
/// corresponds to whether we *attempted* to build one. /// corresponds to whether we *attempted* to build one.
bool isCFGBuilt() const { return builtCFG; } bool isCFGBuilt() const { return builtCFG; }
ParentMap &getParentMap(); ParentMap &getParentMap();
using referenced_decls_iterator = const VarDecl * const *; using referenced_decls_iterator = const VarDecl *const *;
llvm::iterator_range<referenced_decls_iterator> llvm::iterator_range<referenced_decls_iterator>
getReferencedBlockVars(const BlockDecl *BD); getReferencedBlockVars(const BlockDecl *BD);
/// Return the ImplicitParamDecl* associated with 'self' if this /// \returns The ImplicitParamDecl associated with \c self if this
/// AnalysisDeclContext wraps an ObjCMethodDecl. Returns NULL otherwise. /// AnalysisDeclContext wraps an ObjCMethodDecl or nullptr otherwise.
const ImplicitParamDecl *getSelfDecl() const; const ImplicitParamDecl *getSelfDecl() const;
const StackFrameContext *getStackFrame(LocationContext const *Parent, /// \copydoc LocationContextManager::getStackFrame()
const StackFrameContext *getStackFrame(LocationContext const *ParentLC,
const Stmt *S, const CFGBlock *Blk, const Stmt *S, const CFGBlock *Blk,
unsigned BlockCount, unsigned Idx); unsigned BlockCount, unsigned Index);
/// \copydoc LocationContextManager::getBlockInvocationContext()
const BlockInvocationContext * const BlockInvocationContext *
getBlockInvocationContext(const LocationContext *parent, getBlockInvocationContext(const LocationContext *ParentLC,
const BlockDecl *BD, const BlockDecl *BD, const void *Data);
const void *ContextData);
/// Return the specified analysis object, lazily running the analysis if /// \returns The specified analysis object, lazily running the analysis if
/// necessary. Return NULL if the analysis could not run. /// necessary or nullptr if the analysis could not run.
template <typename T> template <typename T> T *getAnalysis() {
T *getAnalysis() {
const void *tag = T::getTag(); const void *tag = T::getTag();
ManagedAnalysis *&data = getAnalysisImpl(tag); ManagedAnalysis *&data = getAnalysisImpl(tag);
if (!data) { if (!data) {
@ -203,19 +198,22 @@ public:
return static_cast<T *>(data); return static_cast<T *>(data);
} }
/// Returns true if the root namespace of the given declaration is the 'std' /// \returns Whether the root namespace of \p D is the \c std C++ namespace.
/// C++ namespace.
static bool isInStdNamespace(const Decl *D); static bool isInStdNamespace(const Decl *D);
private: private:
ManagedAnalysis *&getAnalysisImpl(const void* tag); ManagedAnalysis *&getAnalysisImpl(const void *tag);
LocationContextManager &getLocationContextManager(); LocationContextManager &getLocationContextManager();
}; };
/// It wraps the AnalysisDeclContext to represent both the call stack with
/// the help of StackFrameContext and inside the function calls the
/// BlockInvocationContext. It is needed for context sensitive analysis to
/// model entering, leaving or inlining function calls.
class LocationContext : public llvm::FoldingSetNode { class LocationContext : public llvm::FoldingSetNode {
public: public:
enum ContextKind { StackFrame, Scope, Block }; enum ContextKind { StackFrame, Block };
private: private:
ContextKind Kind; ContextKind Kind;
@ -229,8 +227,7 @@ private:
protected: protected:
LocationContext(ContextKind k, AnalysisDeclContext *ctx, LocationContext(ContextKind k, AnalysisDeclContext *ctx,
const LocationContext *parent, const LocationContext *parent, int64_t ID)
int64_t ID)
: Kind(k), Ctx(ctx), Parent(parent), ID(ID) {} : Kind(k), Ctx(ctx), Parent(parent), ID(ID) {}
public: public:
@ -238,9 +235,7 @@ public:
ContextKind getKind() const { return Kind; } ContextKind getKind() const { return Kind; }
int64_t getID() const { int64_t getID() const { return ID; }
return ID;
}
AnalysisDeclContext *getAnalysisDeclContext() const { return Ctx; } AnalysisDeclContext *getAnalysisDeclContext() const { return Ctx; }
@ -248,58 +243,61 @@ public:
bool isParentOf(const LocationContext *LC) const; bool isParentOf(const LocationContext *LC) const;
const Decl *getDecl() const { return getAnalysisDeclContext()->getDecl(); } const Decl *getDecl() const { return Ctx->getDecl(); }
CFG *getCFG() const { return getAnalysisDeclContext()->getCFG(); } CFG *getCFG() const { return Ctx->getCFG(); }
template <typename T> template <typename T> T *getAnalysis() const { return Ctx->getAnalysis<T>(); }
T *getAnalysis() const {
return getAnalysisDeclContext()->getAnalysis<T>();
}
const ParentMap &getParentMap() const { const ParentMap &getParentMap() const { return Ctx->getParentMap(); }
return getAnalysisDeclContext()->getParentMap();
}
const ImplicitParamDecl *getSelfDecl() const { /// \copydoc AnalysisDeclContext::getSelfDecl()
return Ctx->getSelfDecl(); const ImplicitParamDecl *getSelfDecl() const { return Ctx->getSelfDecl(); }
}
const StackFrameContext *getStackFrame() const; const StackFrameContext *getStackFrame() const;
/// Return true if the current LocationContext has no caller context. /// \returns Whether the current LocationContext has no caller context.
virtual bool inTopFrame() const; virtual bool inTopFrame() const;
virtual void Profile(llvm::FoldingSetNodeID &ID) = 0; virtual void Profile(llvm::FoldingSetNodeID &ID) = 0;
void dumpStack( /// Prints out the call stack.
raw_ostream &Out, const char *NL = "\n", ///
std::function<void(const LocationContext *)> printMoreInfoPerContext = /// \param Out The out stream.
[](const LocationContext *) {}) const; LLVM_DUMP_METHOD void dumpStack(raw_ostream &Out) const;
/// Prints out the call stack in \c json format.
///
/// \param Out The out stream.
/// \param NL The newline.
/// \param Space The space count for indentation.
/// \param IsDot Whether the output format is \c dot.
/// \param printMoreInfoPerContext
/// A callback to print more information for each context, for example:
/// \code
/// [&](const LocationContext *LC) { LC->dump(); }
/// \endcode
void printJson( void printJson(
raw_ostream &Out, const char *NL = "\n", unsigned int Space = 0, raw_ostream &Out, const char *NL = "\n", unsigned int Space = 0,
bool IsDot = false, bool IsDot = false,
std::function<void(const LocationContext *)> printMoreInfoPerContext = std::function<void(const LocationContext *)> printMoreInfoPerContext =
[](const LocationContext *) {}) const; [](const LocationContext *) {}) const;
void dump() const; LLVM_DUMP_METHOD void dump() const;
public: static void ProfileCommon(llvm::FoldingSetNodeID &ID, ContextKind ck,
static void ProfileCommon(llvm::FoldingSetNodeID &ID,
ContextKind ck,
AnalysisDeclContext *ctx, AnalysisDeclContext *ctx,
const LocationContext *parent, const LocationContext *parent, const void *data);
const void *data);
}; };
/// It represents a stack frame of the call stack (based on CallEvent).
class StackFrameContext : public LocationContext { class StackFrameContext : public LocationContext {
friend class LocationContextManager; friend class LocationContextManager;
// The callsite where this stack frame is established. // The call site where this stack frame is established.
const Stmt *CallSite; const Stmt *CallSite;
// The parent block of the callsite. // The parent block of the call site.
const CFGBlock *Block; const CFGBlock *Block;
// The number of times the 'Block' has been visited. // The number of times the 'Block' has been visited.
@ -307,14 +305,14 @@ class StackFrameContext : public LocationContext {
// called multiple times in a loop. // called multiple times in a loop.
const unsigned BlockCount; const unsigned BlockCount;
// The index of the callsite in the CFGBlock. // The index of the call site in the CFGBlock.
const unsigned Index; const unsigned Index;
StackFrameContext(AnalysisDeclContext *ctx, const LocationContext *parent, StackFrameContext(AnalysisDeclContext *ADC, const LocationContext *ParentLC,
const Stmt *s, const CFGBlock *blk, unsigned blockCount, const Stmt *S, const CFGBlock *Block, unsigned BlockCount,
unsigned idx, int64_t ID) unsigned Index, int64_t ID)
: LocationContext(StackFrame, ctx, parent, ID), CallSite(s), Block(blk), : LocationContext(StackFrame, ADC, ParentLC, ID), CallSite(S),
BlockCount(blockCount), Index(idx) {} Block(Block), BlockCount(BlockCount), Index(Index) {}
public: public:
~StackFrameContext() override = default; ~StackFrameContext() override = default;
@ -323,117 +321,98 @@ public:
const CFGBlock *getCallSiteBlock() const { return Block; } const CFGBlock *getCallSiteBlock() const { return Block; }
/// Return true if the current LocationContext has no caller context. bool inTopFrame() const override { return getParent() == nullptr; }
bool inTopFrame() const override { return getParent() == nullptr; }
unsigned getIndex() const { return Index; } unsigned getIndex() const { return Index; }
void Profile(llvm::FoldingSetNodeID &ID) override; void Profile(llvm::FoldingSetNodeID &ID) override;
static void Profile(llvm::FoldingSetNodeID &ID, AnalysisDeclContext *ctx, static void Profile(llvm::FoldingSetNodeID &ID, AnalysisDeclContext *ADC,
const LocationContext *parent, const Stmt *s, const LocationContext *ParentLC, const Stmt *S,
const CFGBlock *blk, unsigned blockCount, unsigned idx) { const CFGBlock *Block, unsigned BlockCount,
ProfileCommon(ID, StackFrame, ctx, parent, s); unsigned Index) {
ID.AddPointer(blk); ProfileCommon(ID, StackFrame, ADC, ParentLC, S);
ID.AddInteger(blockCount); ID.AddPointer(Block);
ID.AddInteger(idx); ID.AddInteger(BlockCount);
ID.AddInteger(Index);
} }
static bool classof(const LocationContext *Ctx) { static bool classof(const LocationContext *LC) {
return Ctx->getKind() == StackFrame; return LC->getKind() == StackFrame;
}
};
class ScopeContext : public LocationContext {
friend class LocationContextManager;
const Stmt *Enter;
ScopeContext(AnalysisDeclContext *ctx, const LocationContext *parent,
const Stmt *s, int64_t ID)
: LocationContext(Scope, ctx, parent, ID), Enter(s) {}
public:
~ScopeContext() override = default;
void Profile(llvm::FoldingSetNodeID &ID) override;
static void Profile(llvm::FoldingSetNodeID &ID, AnalysisDeclContext *ctx,
const LocationContext *parent, const Stmt *s) {
ProfileCommon(ID, Scope, ctx, parent, s);
}
static bool classof(const LocationContext *Ctx) {
return Ctx->getKind() == Scope;
} }
}; };
/// It represents a block invocation (based on BlockCall).
class BlockInvocationContext : public LocationContext { class BlockInvocationContext : public LocationContext {
friend class LocationContextManager; friend class LocationContextManager;
const BlockDecl *BD; const BlockDecl *BD;
// FIXME: Come up with a more type-safe way to model context-sensitivity. // FIXME: Come up with a more type-safe way to model context-sensitivity.
const void *ContextData; const void *Data;
BlockInvocationContext(AnalysisDeclContext *ctx, BlockInvocationContext(AnalysisDeclContext *ADC,
const LocationContext *parent, const BlockDecl *bd, const LocationContext *ParentLC, const BlockDecl *BD,
const void *contextData, int64_t ID) const void *Data, int64_t ID)
: LocationContext(Block, ctx, parent, ID), BD(bd), : LocationContext(Block, ADC, ParentLC, ID), BD(BD), Data(Data) {}
ContextData(contextData) {}
public: public:
~BlockInvocationContext() override = default; ~BlockInvocationContext() override = default;
const BlockDecl *getBlockDecl() const { return BD; } const BlockDecl *getBlockDecl() const { return BD; }
const void *getContextData() const { return ContextData; } const void *getData() const { return Data; }
void Profile(llvm::FoldingSetNodeID &ID) override; void Profile(llvm::FoldingSetNodeID &ID) override;
static void Profile(llvm::FoldingSetNodeID &ID, AnalysisDeclContext *ctx, static void Profile(llvm::FoldingSetNodeID &ID, AnalysisDeclContext *ADC,
const LocationContext *parent, const BlockDecl *bd, const LocationContext *ParentLC, const BlockDecl *BD,
const void *contextData) { const void *Data) {
ProfileCommon(ID, Block, ctx, parent, bd); ProfileCommon(ID, Block, ADC, ParentLC, BD);
ID.AddPointer(contextData); ID.AddPointer(Data);
} }
static bool classof(const LocationContext *Ctx) { static bool classof(const LocationContext *LC) {
return Ctx->getKind() == Block; return LC->getKind() == Block;
} }
}; };
class LocationContextManager { class LocationContextManager {
llvm::FoldingSet<LocationContext> Contexts; llvm::FoldingSet<LocationContext> Contexts;
/// ID used for generating a new location context. // ID used for generating a new location context.
int64_t NewID = 0; int64_t NewID = 0;
public: public:
~LocationContextManager(); ~LocationContextManager();
const StackFrameContext *getStackFrame(AnalysisDeclContext *ctx, /// Obtain a context of the call stack using its parent context.
const LocationContext *parent, ///
const Stmt *s, const CFGBlock *blk, /// \param ADC The AnalysisDeclContext.
unsigned blockCount, unsigned idx); /// \param ParentLC The parent context of this newly created context.
/// \param S The call.
const ScopeContext *getScope(AnalysisDeclContext *ctx, /// \param Block The basic block.
const LocationContext *parent, /// \param BlockCount The current count of entering into \p Blk.
const Stmt *s); /// \param Index The index of \p Blk.
/// \returns The context for \p D with parent context \p ParentLC.
const StackFrameContext *getStackFrame(AnalysisDeclContext *ADC,
const LocationContext *ParentLC,
const Stmt *S, const CFGBlock *Block,
unsigned BlockCount, unsigned Index);
/// Obtain a context of the block invocation using its parent context.
///
/// \param ADC The AnalysisDeclContext.
/// \param ParentLC The parent context of this newly created context.
/// \param BD The BlockDecl.
/// \param Data The raw data to store as part of the context.
const BlockInvocationContext * const BlockInvocationContext *
getBlockInvocationContext(AnalysisDeclContext *ctx, getBlockInvocationContext(AnalysisDeclContext *ADC,
const LocationContext *parent, const LocationContext *ParentLC,
const BlockDecl *BD, const BlockDecl *BD, const void *Data);
const void *ContextData);
/// Discard all previously created LocationContext objects. /// Discard all previously created LocationContext objects.
void clear(); void clear();
private:
template <typename LOC, typename DATA>
const LOC *getLocationContext(AnalysisDeclContext *ctx,
const LocationContext *parent,
const DATA *d);
}; };
class AnalysisDeclContextManager { class AnalysisDeclContextManager {
@ -441,36 +420,31 @@ class AnalysisDeclContextManager {
llvm::DenseMap<const Decl *, std::unique_ptr<AnalysisDeclContext>>; llvm::DenseMap<const Decl *, std::unique_ptr<AnalysisDeclContext>>;
ContextMap Contexts; ContextMap Contexts;
LocationContextManager LocContexts; LocationContextManager LocCtxMgr;
CFG::BuildOptions cfgBuildOptions; CFG::BuildOptions cfgBuildOptions;
/// Pointer to an interface that can provide function bodies for // Pointer to an interface that can provide function bodies for
/// declarations from external source. // declarations from external source.
std::unique_ptr<CodeInjector> Injector; std::unique_ptr<CodeInjector> Injector;
/// A factory for creating and caching implementations for common // A factory for creating and caching implementations for common
/// methods during the analysis. // methods during the analysis.
BodyFarm FunctionBodyFarm; BodyFarm FunctionBodyFarm;
/// Flag to indicate whether or not bodies should be synthesized // Flag to indicate whether or not bodies should be synthesized
/// for well-known functions. // for well-known functions.
bool SynthesizeBodies; bool SynthesizeBodies;
public: public:
AnalysisDeclContextManager(ASTContext &ASTCtx, bool useUnoptimizedCFG = false, AnalysisDeclContextManager(
bool addImplicitDtors = false, ASTContext &ASTCtx, bool useUnoptimizedCFG = false,
bool addInitializers = false, bool addImplicitDtors = false, bool addInitializers = false,
bool addTemporaryDtors = false, bool addTemporaryDtors = false, bool addLifetime = false,
bool addLifetime = false, bool addLoopExit = false, bool addScopes = false,
bool addLoopExit = false, bool synthesizeBodies = false, bool addStaticInitBranches = false,
bool addScopes = false, bool addCXXNewAllocator = true, bool addRichCXXConstructors = true,
bool synthesizeBodies = false, bool markElidedCXXConstructors = true, bool addVirtualBaseBranches = true,
bool addStaticInitBranches = false, CodeInjector *injector = nullptr);
bool addCXXNewAllocator = true,
bool addRichCXXConstructors = true,
bool markElidedCXXConstructors = true,
bool addVirtualBaseBranches = true,
CodeInjector *injector = nullptr);
AnalysisDeclContext *getContext(const Decl *D); AnalysisDeclContext *getContext(const Decl *D);
@ -478,37 +452,27 @@ public:
return !cfgBuildOptions.PruneTriviallyFalseEdges; return !cfgBuildOptions.PruneTriviallyFalseEdges;
} }
CFG::BuildOptions &getCFGBuildOptions() { CFG::BuildOptions &getCFGBuildOptions() { return cfgBuildOptions; }
return cfgBuildOptions;
}
/// Return true if faux bodies should be synthesized for well-known /// \returns Whether faux bodies should be synthesized for known functions.
/// functions.
bool synthesizeBodies() const { return SynthesizeBodies; } bool synthesizeBodies() const { return SynthesizeBodies; }
const StackFrameContext *getStackFrame(AnalysisDeclContext *Ctx, /// Obtain the beginning context of the analysis.
const LocationContext *Parent, ///
const Stmt *S, const CFGBlock *Blk, /// \returns The top level stack frame for \p D.
unsigned BlockCount, unsigned Idx) {
return LocContexts.getStackFrame(Ctx, Parent, S, Blk, BlockCount, Idx);
}
// Get the top level stack frame.
const StackFrameContext *getStackFrame(const Decl *D) { const StackFrameContext *getStackFrame(const Decl *D) {
return LocContexts.getStackFrame(getContext(D), nullptr, nullptr, nullptr, return LocCtxMgr.getStackFrame(getContext(D), nullptr, nullptr, nullptr, 0,
0, 0); 0);
} }
// Get a stack frame with parent. /// \copydoc LocationContextManager::getStackFrame()
StackFrameContext const *getStackFrame(const Decl *D, const StackFrameContext *getStackFrame(AnalysisDeclContext *ADC,
const LocationContext *Parent, const LocationContext *Parent,
const Stmt *S, const CFGBlock *Blk, const Stmt *S, const CFGBlock *Block,
unsigned BlockCount, unsigned Idx) { unsigned BlockCount, unsigned Index) {
return LocContexts.getStackFrame(getContext(D), Parent, S, Blk, BlockCount, return LocCtxMgr.getStackFrame(ADC, Parent, S, Block, BlockCount, Index);
Idx);
} }
/// Get a reference to {@code BodyFarm} instance.
BodyFarm &getBodyFarm(); BodyFarm &getBodyFarm();
/// Discard all previously created AnalysisDeclContexts. /// Discard all previously created AnalysisDeclContexts.
@ -517,9 +481,7 @@ public:
private: private:
friend class AnalysisDeclContext; friend class AnalysisDeclContext;
LocationContextManager &getLocationContextManager() { LocationContextManager &getLocationContextManager() { return LocCtxMgr; }
return LocContexts;
}
}; };
} // namespace clang } // namespace clang

106
clang/lib/Analysis/AnalysisDeclContext.cpp
View File

@ -52,16 +52,16 @@ using namespace clang;
using ManagedAnalysisMap = llvm::DenseMap<const void *, ManagedAnalysis *>; using ManagedAnalysisMap = llvm::DenseMap<const void *, ManagedAnalysis *>;
AnalysisDeclContext::AnalysisDeclContext(AnalysisDeclContextManager *Mgr, AnalysisDeclContext::AnalysisDeclContext(AnalysisDeclContextManager *ADCMgr,
const Decl *d, const Decl *D,
const CFG::BuildOptions &buildOptions) const CFG::BuildOptions &Options)
: Manager(Mgr), D(d), cfgBuildOptions(buildOptions) { : ADCMgr(ADCMgr), D(D), cfgBuildOptions(Options) {
cfgBuildOptions.forcedBlkExprs = &forcedBlkExprs; cfgBuildOptions.forcedBlkExprs = &forcedBlkExprs;
} }
AnalysisDeclContext::AnalysisDeclContext(AnalysisDeclContextManager *Mgr, AnalysisDeclContext::AnalysisDeclContext(AnalysisDeclContextManager *ADCMgr,
const Decl *d) const Decl *D)
: Manager(Mgr), D(d) { : ADCMgr(ADCMgr), D(D) {
cfgBuildOptions.forcedBlkExprs = &forcedBlkExprs; cfgBuildOptions.forcedBlkExprs = &forcedBlkExprs;
} }
@ -96,8 +96,8 @@ Stmt *AnalysisDeclContext::getBody(bool &IsAutosynthesized) const {
Stmt *Body = FD->getBody(); Stmt *Body = FD->getBody();
if (auto *CoroBody = dyn_cast_or_null<CoroutineBodyStmt>(Body)) if (auto *CoroBody = dyn_cast_or_null<CoroutineBodyStmt>(Body))
Body = CoroBody->getBody(); Body = CoroBody->getBody();
if (Manager && Manager->synthesizeBodies()) { if (ADCMgr && ADCMgr->synthesizeBodies()) {
Stmt *SynthesizedBody = Manager->getBodyFarm().getBody(FD); Stmt *SynthesizedBody = ADCMgr->getBodyFarm().getBody(FD);
if (SynthesizedBody) { if (SynthesizedBody) {
Body = SynthesizedBody; Body = SynthesizedBody;
IsAutosynthesized = true; IsAutosynthesized = true;
@ -107,8 +107,8 @@ Stmt *AnalysisDeclContext::getBody(bool &IsAutosynthesized) const {
} }
else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) { else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
Stmt *Body = MD->getBody(); Stmt *Body = MD->getBody();
if (Manager && Manager->synthesizeBodies()) { if (ADCMgr && ADCMgr->synthesizeBodies()) {
Stmt *SynthesizedBody = Manager->getBodyFarm().getBody(MD); Stmt *SynthesizedBody = ADCMgr->getBodyFarm().getBody(MD);
if (SynthesizedBody) { if (SynthesizedBody) {
Body = SynthesizedBody; Body = SynthesizedBody;
IsAutosynthesized = true; IsAutosynthesized = true;
@ -309,19 +309,17 @@ AnalysisDeclContext *AnalysisDeclContextManager::getContext(const Decl *D) {
BodyFarm &AnalysisDeclContextManager::getBodyFarm() { return FunctionBodyFarm; } BodyFarm &AnalysisDeclContextManager::getBodyFarm() { return FunctionBodyFarm; }
const StackFrameContext * const StackFrameContext *
AnalysisDeclContext::getStackFrame(LocationContext const *Parent, const Stmt *S, AnalysisDeclContext::getStackFrame(const LocationContext *ParentLC,
const CFGBlock *Blk, unsigned BlockCount, const Stmt *S, const CFGBlock *Blk,
unsigned Idx) { unsigned BlockCount, unsigned Index) {
return getLocationContextManager().getStackFrame(this, Parent, S, Blk, return getLocationContextManager().getStackFrame(this, ParentLC, S, Blk,
BlockCount, Idx); BlockCount, Index);
} }
const BlockInvocationContext * const BlockInvocationContext *AnalysisDeclContext::getBlockInvocationContext(
AnalysisDeclContext::getBlockInvocationContext(const LocationContext *parent, const LocationContext *ParentLC, const BlockDecl *BD, const void *Data) {
const BlockDecl *BD, return getLocationContextManager().getBlockInvocationContext(this, ParentLC,
const void *ContextData) { BD, Data);
return getLocationContextManager().getBlockInvocationContext(this, parent,
BD, ContextData);
} }
bool AnalysisDeclContext::isInStdNamespace(const Decl *D) { bool AnalysisDeclContext::isInStdNamespace(const Decl *D) {
@ -340,9 +338,10 @@ bool AnalysisDeclContext::isInStdNamespace(const Decl *D) {
} }
LocationContextManager &AnalysisDeclContext::getLocationContextManager() { LocationContextManager &AnalysisDeclContext::getLocationContextManager() {
assert(Manager && assert(
"Cannot create LocationContexts without an AnalysisDeclContextManager!"); ADCMgr &&
return Manager->getLocationContextManager(); "Cannot create LocationContexts without an AnalysisDeclContextManager!");
return ADCMgr->getLocationContextManager();
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
@ -365,36 +364,14 @@ void StackFrameContext::Profile(llvm::FoldingSetNodeID &ID) {
BlockCount, Index); BlockCount, Index);
} }
void ScopeContext::Profile(llvm::FoldingSetNodeID &ID) {
Profile(ID, getAnalysisDeclContext(), getParent(), Enter);
}
void BlockInvocationContext::Profile(llvm::FoldingSetNodeID &ID) { void BlockInvocationContext::Profile(llvm::FoldingSetNodeID &ID) {
Profile(ID, getAnalysisDeclContext(), getParent(), BD, ContextData); Profile(ID, getAnalysisDeclContext(), getParent(), BD, Data);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// LocationContext creation. // LocationContext creation.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
template <typename LOC, typename DATA>
const LOC*
LocationContextManager::getLocationContext(AnalysisDeclContext *ctx,
const LocationContext *parent,
const DATA *d) {
llvm::FoldingSetNodeID ID;
LOC::Profile(ID, ctx, parent, d);
void *InsertPos;
LOC *L = cast_or_null<LOC>(Contexts.FindNodeOrInsertPos(ID, InsertPos));
if (!L) {
L = new LOC(ctx, parent, d, ++NewID);
Contexts.InsertNode(L, InsertPos);
}
return L;
}
const StackFrameContext *LocationContextManager::getStackFrame( const StackFrameContext *LocationContextManager::getStackFrame(
AnalysisDeclContext *ctx, const LocationContext *parent, const Stmt *s, AnalysisDeclContext *ctx, const LocationContext *parent, const Stmt *s,
const CFGBlock *blk, unsigned blockCount, unsigned idx) { const CFGBlock *blk, unsigned blockCount, unsigned idx) {
@ -410,26 +387,17 @@ const StackFrameContext *LocationContextManager::getStackFrame(
return L; return L;
} }
const ScopeContext * const BlockInvocationContext *LocationContextManager::getBlockInvocationContext(
LocationContextManager::getScope(AnalysisDeclContext *ctx, AnalysisDeclContext *ADC, const LocationContext *ParentLC,
const LocationContext *parent, const BlockDecl *BD, const void *Data) {
const Stmt *s) {
return getLocationContext<ScopeContext, Stmt>(ctx, parent, s);
}
const BlockInvocationContext *
LocationContextManager::getBlockInvocationContext(AnalysisDeclContext *ctx,
const LocationContext *parent,
const BlockDecl *BD,
const void *ContextData) {
llvm::FoldingSetNodeID ID; llvm::FoldingSetNodeID ID;
BlockInvocationContext::Profile(ID, ctx, parent, BD, ContextData); BlockInvocationContext::Profile(ID, ADC, ParentLC, BD, Data);
void *InsertPos; void *InsertPos;
auto *L = auto *L =
cast_or_null<BlockInvocationContext>(Contexts.FindNodeOrInsertPos(ID, cast_or_null<BlockInvocationContext>(Contexts.FindNodeOrInsertPos(ID,
InsertPos)); InsertPos));
if (!L) { if (!L) {
L = new BlockInvocationContext(ctx, parent, BD, ContextData, ++NewID); L = new BlockInvocationContext(ADC, ParentLC, BD, Data, ++NewID);
Contexts.InsertNode(L, InsertPos); Contexts.InsertNode(L, InsertPos);
} }
return L; return L;
@ -473,9 +441,7 @@ static void printLocation(raw_ostream &Out, const SourceManager &SM,
Loc.print(Out, SM); Loc.print(Out, SM);
} }
void LocationContext::dumpStack(raw_ostream &Out, const char *NL, void LocationContext::dumpStack(raw_ostream &Out) const {
std::function<void(const LocationContext *)>
printMoreInfoPerContext) const {
ASTContext &Ctx = getAnalysisDeclContext()->getASTContext(); ASTContext &Ctx = getAnalysisDeclContext()->getASTContext();
PrintingPolicy PP(Ctx.getLangOpts()); PrintingPolicy PP(Ctx.getLangOpts());
PP.TerseOutput = 1; PP.TerseOutput = 1;
@ -498,9 +464,6 @@ void LocationContext::dumpStack(raw_ostream &Out, const char *NL,
printLocation(Out, SM, S->getBeginLoc()); printLocation(Out, SM, S->getBeginLoc());
} }
break; break;
case Scope:
Out << "Entering scope";
break;
case Block: case Block:
Out << "Invoking block"; Out << "Invoking block";
if (const Decl *D = cast<BlockInvocationContext>(LCtx)->getDecl()) { if (const Decl *D = cast<BlockInvocationContext>(LCtx)->getDecl()) {
@ -509,9 +472,7 @@ void LocationContext::dumpStack(raw_ostream &Out, const char *NL,
} }
break; break;
} }
Out << NL; Out << '\n';
printMoreInfoPerContext(LCtx);
} }
} }
@ -548,9 +509,6 @@ void LocationContext::printJson(raw_ostream &Out, const char *NL,
Out << ", \"items\": "; Out << ", \"items\": ";
break; break;
case Scope:
Out << "Entering scope\" ";
break;
case Block: case Block:
Out << "Invoking block\" "; Out << "Invoking block\" ";
if (const Decl *D = cast<BlockInvocationContext>(LCtx)->getDecl()) { if (const Decl *D = cast<BlockInvocationContext>(LCtx)->getDecl()) {

3
clang/lib/StaticAnalyzer/Core/MemRegion.cpp
View File

@ -842,8 +842,7 @@ getStackOrCaptureRegionForDeclContext(const LocationContext *LC,
return SFC; return SFC;
} }
if (const auto *BC = dyn_cast<BlockInvocationContext>(LC)) { if (const auto *BC = dyn_cast<BlockInvocationContext>(LC)) {
const auto *BR = const auto *BR = static_cast<const BlockDataRegion *>(BC->getData());
static_cast<const BlockDataRegion *>(BC->getContextData());
// FIXME: This can be made more efficient. // FIXME: This can be made more efficient.
for (BlockDataRegion::referenced_vars_iterator for (BlockDataRegion::referenced_vars_iterator
I = BR->referenced_vars_begin(), I = BR->referenced_vars_begin(),