clang 19.0.0git
AnalysisManager.h
Go to the documentation of this file.
1//== AnalysisManager.h - Path sensitive analysis data manager ------*- C++ -*-//
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 defines the AnalysisManager class that manages the data and policy
10// for path sensitive analysis.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ANALYSISMANAGER_H
15#define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ANALYSISMANAGER_H
16
23
24namespace clang {
25
26class CodeInjector;
27
28namespace ento {
29 class CheckerManager;
30
32 virtual void anchor();
34
35 ASTContext &Ctx;
36 Preprocessor &PP;
37 const LangOptions &LangOpts;
38 PathDiagnosticConsumers PathConsumers;
39
40 // Configurable components creators.
41 StoreManagerCreator CreateStoreMgr;
42 ConstraintManagerCreator CreateConstraintMgr;
43
44 CheckerManager *CheckerMgr;
45
46public:
48
50 const PathDiagnosticConsumers &Consumers,
51 StoreManagerCreator storemgr,
52 ConstraintManagerCreator constraintmgr,
53 CheckerManager *checkerMgr, AnalyzerOptions &Options,
54 CodeInjector *injector = nullptr);
55
56 ~AnalysisManager() override;
57
59 AnaCtxMgr.clear();
60 }
61
63 return AnaCtxMgr;
64 }
65
66 Preprocessor &getPreprocessor() override { return PP; }
67
69 return CreateStoreMgr;
70 }
71
73 return options;
74 }
75
77 return CreateConstraintMgr;
78 }
79
80 CheckerManager *getCheckerManager() const { return CheckerMgr; }
81
83 return Ctx;
84 }
85
88 }
89
90 const LangOptions &getLangOpts() const {
91 return LangOpts;
92 }
93
95 return PathConsumers;
96 }
97
98 void FlushDiagnostics();
99
100 bool shouldVisualize() const {
102 }
103
104 bool shouldInlineCall() const {
105 return options.getIPAMode() != IPAK_None;
106 }
107
108 CFG *getCFG(Decl const *D) {
109 return AnaCtxMgr.getContext(D)->getCFG();
110 }
111
112 template <typename T>
113 T *getAnalysis(Decl const *D) {
114 return AnaCtxMgr.getContext(D)->getAnalysis<T>();
115 }
116
118 return AnaCtxMgr.getContext(D)->getParentMap();
119 }
120
122 return AnaCtxMgr.getContext(D);
123 }
124
125 static bool isInCodeFile(SourceLocation SL, const SourceManager &SM) {
126 if (SM.isInMainFile(SL))
127 return true;
128
129 // Support the "unified sources" compilation method (eg. WebKit) that
130 // involves producing non-header files that include other non-header files.
131 // We should be included directly from a UnifiedSource* file
132 // and we shouldn't be a header - which is a very safe defensive check.
133 SourceLocation IL = SM.getIncludeLoc(SM.getFileID(SL));
134 if (!IL.isValid() || !SM.isInMainFile(IL))
135 return false;
136 // Should rather be "file name starts with", but the current .getFilename
137 // includes the full path.
138 if (SM.getFilename(IL).contains("UnifiedSource")) {
139 // It might be great to reuse FrontendOptions::getInputKindForExtension()
140 // but for now it doesn't discriminate between code and header files.
141 return llvm::StringSwitch<bool>(SM.getFilename(SL).rsplit('.').second)
142 .Cases("c", "m", "mm", "C", "cc", "cp", true)
143 .Cases("cpp", "CPP", "c++", "cxx", "cppm", true)
144 .Default(false);
145 }
146
147 return false;
148 }
149
152 return isInCodeFile(SL, SM);
153 }
154};
155
156} // enAnaCtxMgrspace
157
158} // end clang namespace
159
160#endif
This file defines AnalysisDeclContext, a class that manages the analysis context data for context sen...
#define SM(sm)
Definition: Cuda.cpp:84
Defines the clang::Preprocessor interface.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:185
SourceManager & getSourceManager()
Definition: ASTContext.h:708
void clear()
Discard all previously created AnalysisDeclContexts.
AnalysisDeclContext * getContext(const Decl *D)
AnalysisDeclContext contains the context data for the function, method or block under analysis.
Stores options for the analyzer from the command line.
unsigned visualizeExplodedGraphWithGraphViz
IPAKind getIPAMode() const
Returns the inter-procedural analysis mode.
Represents a source-level, intra-procedural CFG that represents the control-flow of a Stmt.
Definition: CFG.h:1214
CodeInjector is an interface which is responsible for injecting AST of function definitions that may ...
Definition: CodeInjector.h:35
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:461
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:137
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
This class handles loading and caching of source files into memory.
const LangOptions & getLangOpts() const
ConstraintManagerCreator getConstraintManagerCreator()
ASTContext & getASTContext() override
ArrayRef< PathDiagnosticConsumer * > getPathDiagnosticConsumers() override
Preprocessor & getPreprocessor() override
static bool isInCodeFile(SourceLocation SL, const SourceManager &SM)
bool isInCodeFile(SourceLocation SL)
AnalysisDeclContext * getAnalysisDeclContext(const Decl *D)
AnalysisDeclContextManager & getAnalysisDeclContextManager()
SourceManager & getSourceManager() override
T * getAnalysis(Decl const *D)
StoreManagerCreator getStoreManagerCreator()
ParentMap & getParentMap(Decl const *D)
CheckerManager * getCheckerManager() const
CFG * getCFG(Decl const *D)
AnalyzerOptions & getAnalyzerOptions() override
std::unique_ptr< ConstraintManager >(* ConstraintManagerCreator)(ProgramStateManager &, ExprEngine *)
Definition: ProgramState.h:42
std::vector< PathDiagnosticConsumer * > PathDiagnosticConsumers
std::unique_ptr< StoreManager >(* StoreManagerCreator)(ProgramStateManager &)
Definition: ProgramState.h:44
The JSON file list parser is used to communicate input to InstallAPI.
@ IPAK_None
Perform only intra-procedural analysis.
const FunctionProtoType * T