clang  10.0.0svn
AnalyzerOptions.h
Go to the documentation of this file.
1 //===- AnalyzerOptions.h - Analysis Engine Options --------------*- 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 header defines various options for the static analyzer that are set
10 // by the frontend and are consulted throughout the analyzer.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_STATICANALYZER_CORE_ANALYZEROPTIONS_H
15 #define LLVM_CLANG_STATICANALYZER_CORE_ANALYZEROPTIONS_H
16 
17 #include "clang/Basic/LLVM.h"
18 #include "llvm/ADT/IntrusiveRefCntPtr.h"
19 #include "llvm/ADT/Optional.h"
20 #include "llvm/ADT/StringMap.h"
21 #include "llvm/ADT/StringRef.h"
22 #include "llvm/ADT/StringSwitch.h"
23 #include <string>
24 #include <utility>
25 #include <vector>
26 
27 namespace clang {
28 
29 namespace ento {
30 
31 class CheckerBase;
32 
33 } // namespace ento
34 
35 /// Analysis - Set of available source code analyses.
36 enum Analyses {
37 #define ANALYSIS(NAME, CMDFLAG, DESC, SCOPE) NAME,
38 #include "clang/StaticAnalyzer/Core/Analyses.def"
40 };
41 
42 /// AnalysisStores - Set of available analysis store models.
44 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) NAME##Model,
45 #include "clang/StaticAnalyzer/Core/Analyses.def"
47 };
48 
49 /// AnalysisConstraints - Set of available constraint models.
51 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) NAME##Model,
52 #include "clang/StaticAnalyzer/Core/Analyses.def"
54 };
55 
56 /// AnalysisDiagClients - Set of available diagnostic clients for rendering
57 /// analysis results.
59 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) PD_##NAME,
60 #include "clang/StaticAnalyzer/Core/Analyses.def"
63 };
64 
65 /// AnalysisPurgeModes - Set of available strategies for dead symbol removal.
67 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) NAME,
68 #include "clang/StaticAnalyzer/Core/Analyses.def"
70 };
71 
72 /// AnalysisInlineFunctionSelection - Set of inlining function selection heuristics.
74 #define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) NAME,
75 #include "clang/StaticAnalyzer/Core/Analyses.def"
77 };
78 
79 /// Describes the different kinds of C++ member functions which can be
80 /// considered for inlining by the analyzer.
81 ///
82 /// These options are cumulative; enabling one kind of member function will
83 /// enable all kinds with lower enum values.
85  // Uninitialized = 0,
86 
87  /// A dummy mode in which no C++ inlining is enabled.
89 
90  /// Refers to regular member function and operator calls.
92 
93  /// Refers to constructors (implicit or explicit).
94  ///
95  /// Note that a constructor will not be inlined if the corresponding
96  /// destructor is non-trivial.
98 
99  /// Refers to destructors (implicit or explicit).
101 };
102 
103 /// Describes the different modes of inter-procedural analysis.
104 enum IPAKind {
105  /// Perform only intra-procedural analysis.
107 
108  /// Inline C functions and blocks when their definitions are available.
110 
111  /// Inline callees(C, C++, ObjC) when their definitions are available.
113 
114  /// Enable inlining of dynamically dispatched methods.
116 
117  /// Enable inlining of dynamically dispatched methods, bifurcate paths when
118  /// exact type info is unavailable.
120 };
121 
123  DFS,
124  BFS,
129 };
130 
131 /// Describes the kinds for high-level analyzer mode.
133  /// Perform shallow but fast analyzes.
135 
136  /// Perform deep analyzes.
138 };
139 
140 /// Stores options for the analyzer from the command line.
141 ///
142 /// Some options are frontend flags (e.g.: -analyzer-output), but some are
143 /// analyzer configuration options, which are preceded by -analyzer-config
144 /// (e.g.: -analyzer-config notes-as-events=true).
145 ///
146 /// If you'd like to add a new frontend flag, add it to
147 /// include/clang/Driver/CC1Options.td, add a new field to store the value of
148 /// that flag in this class, and initialize it in
149 /// lib/Frontend/CompilerInvocation.cpp.
150 ///
151 /// If you'd like to add a new non-checker configuration, register it in
152 /// include/clang/StaticAnalyzer/Core/AnalyzerOptions.def, and refer to the
153 /// top of the file for documentation.
154 ///
155 /// If you'd like to add a new checker option, call getChecker*Option()
156 /// whenever.
157 ///
158 /// Some of the options are controlled by raw frontend flags for no good reason,
159 /// and should be eventually converted into -analyzer-config flags. New analyzer
160 /// options should not be implemented as frontend flags. Frontend flags still
161 /// make sense for things that do not affect the actual analysis.
162 class AnalyzerOptions : public RefCountedBase<AnalyzerOptions> {
163 public:
164  using ConfigTable = llvm::StringMap<std::string>;
165 
166  static std::vector<StringRef>
167  getRegisteredCheckers(bool IncludeExperimental = false);
168 
169  /// Convenience function for printing options or checkers and their
170  /// description in a formatted manner. If \p MinLineWidth is set to 0, no line
171  /// breaks are introduced for the description.
172  ///
173  /// Format, depending whether the option name's length is less then
174  /// \p OptionWidth:
175  ///
176  /// <padding>EntryName<padding>Description
177  /// <---------padding--------->Description
178  /// <---------padding--------->Description
179  ///
180  /// <padding>VeryVeryLongOptionName
181  /// <---------padding--------->Description
182  /// <---------padding--------->Description
183  /// ^~~~~~~~ InitialPad
184  /// ^~~~~~~~~~~~~~~~~~~~~~~~~~ EntryWidth
185  /// ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~MinLineWidth
186  static void printFormattedEntry(
187  llvm::raw_ostream &Out,
188  std::pair<StringRef, StringRef> EntryDescPair,
189  size_t EntryWidth, size_t InitialPad, size_t MinLineWidth = 0);
190 
191 
192  /// Pair of checker name and enable/disable.
193  std::vector<std::pair<std::string, bool>> CheckersControlList;
194 
195  /// A key-value table of use-specified configuration values.
196  // TODO: This shouldn't be public.
198  AnalysisStores AnalysisStoreOpt = RegionStoreModel;
199  AnalysisConstraints AnalysisConstraintsOpt = RangeConstraintsModel;
200  AnalysisDiagClients AnalysisDiagOpt = PD_HTML;
201  AnalysisPurgeMode AnalysisPurgeOpt = PurgeStmt;
202 
204 
205  /// File path to which the exploded graph should be dumped.
206  std::string DumpExplodedGraphTo;
207 
208  /// Store full compiler invocation for reproducible instructions in the
209  /// generated report.
211 
212  /// The maximum number of times the analyzer visits a block.
214 
215  /// Disable all analyzer checks.
216  ///
217  /// This flag allows one to disable analyzer checks on the code processed by
218  /// the given analysis consumer. Note, the code will get parsed and the
219  /// command-line options will get checked.
220  unsigned DisableAllChecks : 1;
221 
222  unsigned ShowCheckerHelp : 1;
223  unsigned ShowCheckerHelpAlpha : 1;
225 
226  unsigned ShowCheckerOptionList : 1;
229 
231  unsigned ShowConfigOptionsList : 1;
233  unsigned AnalyzeAll : 1;
235  unsigned AnalyzeNestedBlocks : 1;
236 
238 
239  unsigned TrimGraph : 1;
241  unsigned UnoptimizedCFG : 1;
242  unsigned PrintStats : 1;
243 
244  /// Do not re-analyze paths leading to exhausted nodes with a different
245  /// strategy. We get better code coverage when retry is enabled.
246  unsigned NoRetryExhausted : 1;
247 
248  /// Emit analyzer warnings as errors.
249  unsigned AnalyzerWerror : 1;
250 
251  /// The inlining stack depth limit.
252  // Cap the stack depth at 4 calls (5 stack frames, base + 4 calls).
253  unsigned InlineMaxStackDepth = 5;
254 
255  /// The mode of function selection used during inlining.
256  AnalysisInliningMode InliningMode = NoRedundancy;
257 
258  // Create a field for each -analyzer-config option.
259 #define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \
260  SHALLOW_VAL, DEEP_VAL) \
261  ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, SHALLOW_VAL)
262 
263 #define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
264  TYPE NAME;
265 
266 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
267 #undef ANALYZER_OPTION
268 #undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
269 
270  // Create an array of all -analyzer-config command line options. Sort it in
271  // the constructor.
272  std::vector<StringRef> AnalyzerConfigCmdFlags = {
273 #define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \
274  SHALLOW_VAL, DEEP_VAL) \
275  ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, SHALLOW_VAL)
276 
277 #define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
278  CMDFLAG,
279 
280 #include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
281 #undef ANALYZER_OPTION
282 #undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
283  };
284 
285  bool isUnknownAnalyzerConfig(StringRef Name) const {
286 
287  assert(std::is_sorted(AnalyzerConfigCmdFlags.begin(),
288  AnalyzerConfigCmdFlags.end()));
289 
290  return !std::binary_search(AnalyzerConfigCmdFlags.begin(),
291  AnalyzerConfigCmdFlags.end(), Name);
292  }
293 
295  : DisableAllChecks(false), ShowCheckerHelp(false),
296  ShowCheckerHelpAlpha(false), ShowCheckerHelpDeveloper(false),
297  ShowCheckerOptionList(false), ShowCheckerOptionAlphaList(false),
298  ShowCheckerOptionDeveloperList(false), ShowEnabledCheckerList(false),
299  ShowConfigOptionsList(false), AnalyzeAll(false),
300  AnalyzerDisplayProgress(false), AnalyzeNestedBlocks(false),
301  eagerlyAssumeBinOpBifurcation(false), TrimGraph(false),
302  visualizeExplodedGraphWithGraphViz(false), UnoptimizedCFG(false),
303  PrintStats(false), NoRetryExhausted(false), AnalyzerWerror(false) {
304  llvm::sort(AnalyzerConfigCmdFlags);
305  }
306 
307  /// Interprets an option's string value as a boolean. The "true" string is
308  /// interpreted as true and the "false" string is interpreted as false.
309  ///
310  /// If an option value is not provided, returns the given \p DefaultVal.
311  /// @param [in] CheckerName The *full name* of the checker. One may retrieve
312  /// this from the checker object's field \c Name, or through \c
313  /// CheckerManager::getCurrentCheckName within the checker's registry
314  /// function.
315  /// Checker options are retrieved in the following format:
316  /// `-analyzer-config CheckerName:OptionName=Value.
317  /// @param [in] OptionName Name for option to retrieve.
318  /// @param [in] SearchInParents If set to true and the searched option was not
319  /// specified for the given checker the options for the parent packages will
320  /// be searched as well. The inner packages take precedence over the outer
321  /// ones.
322  bool getCheckerBooleanOption(StringRef CheckerName, StringRef OptionName,
323  bool SearchInParents = false) const;
324 
325  bool getCheckerBooleanOption(const ento::CheckerBase *C, StringRef OptionName,
326  bool SearchInParents = false) const;
327 
328  /// Interprets an option's string value as an integer value.
329  ///
330  /// If an option value is not provided, returns the given \p DefaultVal.
331  /// @param [in] CheckerName The *full name* of the checker. One may retrieve
332  /// this from the checker object's field \c Name, or through \c
333  /// CheckerManager::getCurrentCheckName within the checker's registry
334  /// function.
335  /// Checker options are retrieved in the following format:
336  /// `-analyzer-config CheckerName:OptionName=Value.
337  /// @param [in] OptionName Name for option to retrieve.
338  /// @param [in] SearchInParents If set to true and the searched option was not
339  /// specified for the given checker the options for the parent packages will
340  /// be searched as well. The inner packages take precedence over the outer
341  /// ones.
342  int getCheckerIntegerOption(StringRef CheckerName, StringRef OptionName,
343  bool SearchInParents = false) const;
344 
345  int getCheckerIntegerOption(const ento::CheckerBase *C, StringRef OptionName,
346  bool SearchInParents = false) const;
347 
348  /// Query an option's string value.
349  ///
350  /// If an option value is not provided, returns the given \p DefaultVal.
351  /// @param [in] CheckerName The *full name* of the checker. One may retrieve
352  /// this from the checker object's field \c Name, or through \c
353  /// CheckerManager::getCurrentCheckName within the checker's registry
354  /// function.
355  /// Checker options are retrieved in the following format:
356  /// `-analyzer-config CheckerName:OptionName=Value.
357  /// @param [in] OptionName Name for option to retrieve.
358  /// @param [in] SearchInParents If set to true and the searched option was not
359  /// specified for the given checker the options for the parent packages will
360  /// be searched as well. The inner packages take precedence over the outer
361  /// ones.
362  StringRef getCheckerStringOption(StringRef CheckerName, StringRef OptionName,
363  bool SearchInParents = false) const;
364 
365  StringRef getCheckerStringOption(const ento::CheckerBase *C,
366  StringRef OptionName,
367  bool SearchInParents = false) const;
368 
369  /// Retrieves and sets the UserMode. This is a high-level option,
370  /// which is used to set other low-level options. It is not accessible
371  /// outside of AnalyzerOptions.
372  UserModeKind getUserMode() const;
373 
374  ExplorationStrategyKind getExplorationStrategy() const;
375 
376  /// Returns the inter-procedural analysis mode.
377  IPAKind getIPAMode() const;
378 
379  /// Returns the option controlling which C++ member functions will be
380  /// considered for inlining.
381  ///
382  /// This is controlled by the 'c++-inlining' config option.
383  ///
384  /// \sa CXXMemberInliningMode
385  bool mayInlineCXXMemberFunction(CXXInlineableMemberKind K) const;
386 };
387 
389 
390 //===----------------------------------------------------------------------===//
391 // We'll use AnalyzerOptions in the frontend, but we can't link the frontend
392 // with clangStaticAnalyzerCore, because clangStaticAnalyzerCore depends on
393 // clangFrontend.
394 //
395 // For this reason, implement some methods in this header file.
396 //===----------------------------------------------------------------------===//
397 
399  auto K = llvm::StringSwitch<llvm::Optional<UserModeKind>>(UserMode)
400  .Case("shallow", UMK_Shallow)
401  .Case("deep", UMK_Deep)
402  .Default(None);
403  assert(K.hasValue() && "User mode is invalid.");
404  return K.getValue();
405 }
406 
407 } // namespace clang
408 
409 #endif // LLVM_CLANG_STATICANALYZER_CORE_ANALYZEROPTIONS_H
Inline C functions and blocks when their definitions are available.
IPAKind
Describes the different modes of inter-procedural analysis.
unsigned visualizeExplodedGraphWithGraphViz
Perform only intra-procedural analysis.
UserModeKind getUserMode() const
Retrieves and sets the UserMode.
A dummy mode in which no C++ inlining is enabled.
Inline callees(C, C++, ObjC) when their definitions are available.
Perform deep analyzes.
std::string DumpExplodedGraphTo
File path to which the exploded graph should be dumped.
unsigned eagerlyAssumeBinOpBifurcation
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
std::string FullCompilerInvocation
Store full compiler invocation for reproducible instructions in the generated report.
std::vector< std::pair< std::string, bool > > CheckersControlList
Pair of checker name and enable/disable.
AnalysisStores
AnalysisStores - Set of available analysis store models.
ExplorationStrategyKind
Refers to regular member function and operator calls.
AnalysisInliningMode
AnalysisInlineFunctionSelection - Set of inlining function selection heuristics.
Refers to constructors (implicit or explicit).
unsigned AnalyzerWerror
Emit analyzer warnings as errors.
Enable inlining of dynamically dispatched methods.
UserModeKind
Describes the kinds for high-level analyzer mode.
#define false
Definition: stdbool.h:17
AnalysisConstraints
AnalysisConstraints - Set of available constraint models.
llvm::StringMap< std::string > ConfigTable
ConfigTable Config
A key-value table of use-specified configuration values.
unsigned ShowCheckerOptionDeveloperList
Refers to destructors (implicit or explicit).
bool isUnknownAnalyzerConfig(StringRef Name) const
unsigned maxBlockVisitOnPath
The maximum number of times the analyzer visits a block.
unsigned DisableAllChecks
Disable all analyzer checks.
Dataflow Directional Tag Classes.
Perform shallow but fast analyzes.
std::string AnalyzeSpecificFunction
AnalysisPurgeMode
AnalysisPurgeModes - Set of available strategies for dead symbol removal.
Stores options for the analyzer from the command line.
unsigned NoRetryExhausted
Do not re-analyze paths leading to exhausted nodes with a different strategy.
Analyses
Analysis - Set of available source code analyses.
CXXInlineableMemberKind
Describes the different kinds of C++ member functions which can be considered for inlining by the ana...
unsigned ShouldEmitErrorsOnInvalidConfigValue
Enable inlining of dynamically dispatched methods, bifurcate paths when exact type info is unavailabl...
AnalysisDiagClients
AnalysisDiagClients - Set of available diagnostic clients for rendering analysis results.