clang 18.0.0git
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
18#include "clang/Basic/LLVM.h"
19#include "llvm/ADT/IntrusiveRefCntPtr.h"
20#include "llvm/ADT/StringMap.h"
21#include "llvm/ADT/StringRef.h"
22#include <string>
23#include <utility>
24#include <vector>
25
26namespace clang {
27
28namespace ento {
29
30class CheckerBase;
31
32} // namespace ento
33
34/// AnalysisConstraints - Set of available constraint models.
36#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) NAME##Model,
37#include "clang/StaticAnalyzer/Core/Analyses.def"
39};
40
41/// AnalysisDiagClients - Set of available diagnostic clients for rendering
42/// analysis results.
44#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) PD_##NAME,
45#include "clang/StaticAnalyzer/Core/Analyses.def"
48};
49
50/// AnalysisPurgeModes - Set of available strategies for dead symbol removal.
52#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) NAME,
53#include "clang/StaticAnalyzer/Core/Analyses.def"
55};
56
57/// AnalysisInlineFunctionSelection - Set of inlining function selection heuristics.
59#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) NAME,
60#include "clang/StaticAnalyzer/Core/Analyses.def"
62};
63
64/// Describes the different kinds of C++ member functions which can be
65/// considered for inlining by the analyzer.
66///
67/// These options are cumulative; enabling one kind of member function will
68/// enable all kinds with lower enum values.
70 // Uninitialized = 0,
71
72 /// A dummy mode in which no C++ inlining is enabled.
74
75 /// Refers to regular member function and operator calls.
77
78 /// Refers to constructors (implicit or explicit).
79 ///
80 /// Note that a constructor will not be inlined if the corresponding
81 /// destructor is non-trivial.
83
84 /// Refers to destructors (implicit or explicit).
86};
87
88/// Describes the different modes of inter-procedural analysis.
89enum IPAKind {
90 /// Perform only intra-procedural analysis.
92
93 /// Inline C functions and blocks when their definitions are available.
95
96 /// Inline callees(C, C++, ObjC) when their definitions are available.
98
99 /// Enable inlining of dynamically dispatched methods.
101
102 /// Enable inlining of dynamically dispatched methods, bifurcate paths when
103 /// exact type info is unavailable.
106
108 DFS,
109 BFS,
114};
115
116/// Describes the kinds for high-level analyzer mode.
118 /// Perform shallow but fast analyzes.
120
121 /// Perform deep analyzes.
122 UMK_Deep = 2
124
126
127/// Stores options for the analyzer from the command line.
128///
129/// Some options are frontend flags (e.g.: -analyzer-output), but some are
130/// analyzer configuration options, which are preceded by -analyzer-config
131/// (e.g.: -analyzer-config notes-as-events=true).
132///
133/// If you'd like to add a new frontend flag, add it to
134/// include/clang/Driver/CC1Options.td, add a new field to store the value of
135/// that flag in this class, and initialize it in
136/// lib/Frontend/CompilerInvocation.cpp.
137///
138/// If you'd like to add a new non-checker configuration, register it in
139/// include/clang/StaticAnalyzer/Core/AnalyzerOptions.def, and refer to the
140/// top of the file for documentation.
141///
142/// If you'd like to add a new checker option, call getChecker*Option()
143/// whenever.
144///
145/// Some of the options are controlled by raw frontend flags for no good reason,
146/// and should be eventually converted into -analyzer-config flags. New analyzer
147/// options should not be implemented as frontend flags. Frontend flags still
148/// make sense for things that do not affect the actual analysis.
149class AnalyzerOptions : public RefCountedBase<AnalyzerOptions> {
150public:
151 using ConfigTable = llvm::StringMap<std::string>;
152
153 /// Retrieves the list of checkers generated from Checkers.td. This doesn't
154 /// contain statically linked but non-generated checkers and plugin checkers!
155 static std::vector<StringRef>
156 getRegisteredCheckers(bool IncludeExperimental = false);
157
158 /// Retrieves the list of packages generated from Checkers.td. This doesn't
159 /// contain statically linked but non-generated packages and plugin packages!
160 static std::vector<StringRef>
161 getRegisteredPackages(bool IncludeExperimental = false);
162
163 /// Convenience function for printing options or checkers and their
164 /// description in a formatted manner. If \p MinLineWidth is set to 0, no line
165 /// breaks are introduced for the description.
166 ///
167 /// Format, depending whether the option name's length is less than
168 /// \p EntryWidth:
169 ///
170 /// <padding>EntryName<padding>Description
171 /// <---------padding--------->Description
172 /// <---------padding--------->Description
173 ///
174 /// <padding>VeryVeryLongEntryName
175 /// <---------padding--------->Description
176 /// <---------padding--------->Description
177 /// ^~~~~~~~~InitialPad
178 /// ^~~~~~~~~~~~~~~~~~EntryWidth
179 /// ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~MinLineWidth
180 static void printFormattedEntry(llvm::raw_ostream &Out,
181 std::pair<StringRef, StringRef> EntryDescPair,
182 size_t InitialPad, size_t EntryWidth,
183 size_t MinLineWidth = 0);
184
185 /// Pairs of checker/package name and enable/disable.
186 std::vector<std::pair<std::string, bool>> CheckersAndPackages;
187
188 /// Vector of checker/package names which will not emit warnings.
189 std::vector<std::string> SilencedCheckersAndPackages;
190
191 /// A key-value table of use-specified configuration values.
192 // TODO: This shouldn't be public.
197
199
200 /// File path to which the exploded graph should be dumped.
202
203 /// Store full compiler invocation for reproducible instructions in the
204 /// generated report.
206
207 /// The maximum number of times the analyzer visits a block.
209
210 /// Disable all analyzer checkers.
211 ///
212 /// This flag allows one to disable analyzer checkers on the code processed by
213 /// the given analysis consumer. Note, the code will get parsed and the
214 /// command-line options will get checked.
215 unsigned DisableAllCheckers : 1;
216
217 unsigned ShowCheckerHelp : 1;
220
224
228 unsigned AnalyzeAll : 1;
230
232
233 unsigned TrimGraph : 1;
235 unsigned UnoptimizedCFG : 1;
236 unsigned PrintStats : 1;
237
238 /// Do not re-analyze paths leading to exhausted nodes with a different
239 /// strategy. We get better code coverage when retry is enabled.
240 unsigned NoRetryExhausted : 1;
241
242 /// Emit analyzer warnings as errors.
244
245 /// The inlining stack depth limit.
247
248 /// The mode of function selection used during inlining.
250
251 // Create a field for each -analyzer-config option.
252#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \
253 SHALLOW_VAL, DEEP_VAL) \
254 ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, SHALLOW_VAL)
255
256#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
257 TYPE NAME;
258
259#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
260#undef ANALYZER_OPTION
261#undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
262
263 bool isUnknownAnalyzerConfig(llvm::StringRef Name) {
264 static std::vector<llvm::StringLiteral> AnalyzerConfigCmdFlags = []() {
265 // Create an array of all -analyzer-config command line options.
266 std::vector<llvm::StringLiteral> AnalyzerConfigCmdFlags = {
267#define ANALYZER_OPTION_DEPENDS_ON_USER_MODE(TYPE, NAME, CMDFLAG, DESC, \
268 SHALLOW_VAL, DEEP_VAL) \
269 ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, SHALLOW_VAL)
270
271#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL) \
272 llvm::StringLiteral(CMDFLAG),
273
274#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
275#undef ANALYZER_OPTION
276#undef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
277 };
278 // FIXME: Sort this at compile-time when we get constexpr sort (C++20).
279 llvm::sort(AnalyzerConfigCmdFlags);
280 return AnalyzerConfigCmdFlags;
281 }();
282
283 return !std::binary_search(AnalyzerConfigCmdFlags.begin(),
284 AnalyzerConfigCmdFlags.end(), Name);
285 }
286
298
299 /// Interprets an option's string value as a boolean. The "true" string is
300 /// interpreted as true and the "false" string is interpreted as false.
301 ///
302 /// If an option value is not provided, returns the given \p DefaultVal.
303 /// @param [in] CheckerName The *full name* of the checker. One may retrieve
304 /// this from the checker object's field \c Name, or through \c
305 /// CheckerManager::getCurrentCheckerName within the checker's registry
306 /// function.
307 /// Checker options are retrieved in the following format:
308 /// `-analyzer-config CheckerName:OptionName=Value.
309 /// @param [in] OptionName Name for option to retrieve.
310 /// @param [in] SearchInParents If set to true and the searched option was not
311 /// specified for the given checker the options for the parent packages will
312 /// be searched as well. The inner packages take precedence over the outer
313 /// ones.
314 bool getCheckerBooleanOption(StringRef CheckerName, StringRef OptionName,
315 bool SearchInParents = false) const;
316
317 bool getCheckerBooleanOption(const ento::CheckerBase *C, StringRef OptionName,
318 bool SearchInParents = false) const;
319
320 /// Interprets an option's string value as an integer value.
321 ///
322 /// If an option value is not provided, returns the given \p DefaultVal.
323 /// @param [in] CheckerName The *full name* of the checker. One may retrieve
324 /// this from the checker object's field \c Name, or through \c
325 /// CheckerManager::getCurrentCheckerName within the checker's registry
326 /// function.
327 /// Checker options are retrieved in the following format:
328 /// `-analyzer-config CheckerName:OptionName=Value.
329 /// @param [in] OptionName Name for option to retrieve.
330 /// @param [in] SearchInParents If set to true and the searched option was not
331 /// specified for the given checker the options for the parent packages will
332 /// be searched as well. The inner packages take precedence over the outer
333 /// ones.
334 int getCheckerIntegerOption(StringRef CheckerName, StringRef OptionName,
335 bool SearchInParents = false) const;
336
337 int getCheckerIntegerOption(const ento::CheckerBase *C, StringRef OptionName,
338 bool SearchInParents = false) const;
339
340 /// Query an option's string value.
341 ///
342 /// If an option value is not provided, returns the given \p DefaultVal.
343 /// @param [in] CheckerName The *full name* of the checker. One may retrieve
344 /// this from the checker object's field \c Name, or through \c
345 /// CheckerManager::getCurrentCheckerName within the checker's registry
346 /// function.
347 /// Checker options are retrieved in the following format:
348 /// `-analyzer-config CheckerName:OptionName=Value.
349 /// @param [in] OptionName Name for option to retrieve.
350 /// @param [in] SearchInParents If set to true and the searched option was not
351 /// specified for the given checker the options for the parent packages will
352 /// be searched as well. The inner packages take precedence over the outer
353 /// ones.
354 StringRef getCheckerStringOption(StringRef CheckerName, StringRef OptionName,
355 bool SearchInParents = false) const;
356
358 StringRef OptionName,
359 bool SearchInParents = false) const;
360
363
364 /// Returns the inter-procedural analysis mode.
365 IPAKind getIPAMode() const;
366
367 /// Returns the option controlling which C++ member functions will be
368 /// considered for inlining.
369 ///
370 /// This is controlled by the 'c++-inlining' config option.
371 ///
372 /// \sa CXXMemberInliningMode
374
377 ShouldDisplayMacroExpansions,
378 ShouldSerializeStats,
379 // The stable report filename option is deprecated because
380 // file names are now always stable. Now the old option acts as
381 // an alias to the new verbose filename option because this
382 // closely mimics the behavior under the old option.
383 ShouldWriteStableReportFilename || ShouldWriteVerboseReportFilename,
385 ShouldApplyFixIts,
386 ShouldDisplayCheckerNameForText};
387 }
388};
389
391
392//===----------------------------------------------------------------------===//
393// We'll use AnalyzerOptions in the frontend, but we can't link the frontend
394// with clangStaticAnalyzerCore, because clangStaticAnalyzerCore depends on
395// clangFrontend.
396//
397// For this reason, implement some methods in this header file.
398//===----------------------------------------------------------------------===//
399
400inline std::vector<StringRef>
401AnalyzerOptions::getRegisteredCheckers(bool IncludeExperimental) {
402 static constexpr llvm::StringLiteral StaticAnalyzerCheckerNames[] = {
403#define GET_CHECKERS
404#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI, IS_HIDDEN) \
405 llvm::StringLiteral(FULLNAME),
406#include "clang/StaticAnalyzer/Checkers/Checkers.inc"
407#undef CHECKER
408#undef GET_CHECKERS
409 };
410 std::vector<StringRef> Checkers;
411 for (StringRef CheckerName : StaticAnalyzerCheckerNames) {
412 if (!CheckerName.startswith("debug.") &&
413 (IncludeExperimental || !CheckerName.startswith("alpha.")))
414 Checkers.push_back(CheckerName);
415 }
416 return Checkers;
417}
418
419inline std::vector<StringRef>
420AnalyzerOptions::getRegisteredPackages(bool IncludeExperimental) {
421 static constexpr llvm::StringLiteral StaticAnalyzerPackageNames[] = {
422#define GET_PACKAGES
423#define PACKAGE(FULLNAME) llvm::StringLiteral(FULLNAME),
424#include "clang/StaticAnalyzer/Checkers/Checkers.inc"
425#undef PACKAGE
426#undef GET_PACKAGES
427 };
428 std::vector<StringRef> Packages;
429 for (StringRef PackageName : StaticAnalyzerPackageNames) {
430 if (PackageName != "debug" &&
431 (IncludeExperimental || PackageName != "alpha"))
432 Packages.push_back(PackageName);
433 }
434 return Packages;
435}
436
437} // namespace clang
438
439#endif // LLVM_CLANG_STATICANALYZER_CORE_ANALYZEROPTIONS_H
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Stores options for the analyzer from the command line.
static std::vector< StringRef > getRegisteredPackages(bool IncludeExperimental=false)
Retrieves the list of packages generated from Checkers.td.
unsigned eagerlyAssumeBinOpBifurcation
std::vector< std::pair< std::string, bool > > CheckersAndPackages
Pairs of checker/package name and enable/disable.
unsigned ShowCheckerOptionDeveloperList
unsigned DisableAllCheckers
Disable all analyzer checkers.
std::vector< std::string > SilencedCheckersAndPackages
Vector of checker/package names which will not emit warnings.
unsigned NoRetryExhausted
Do not re-analyze paths leading to exhausted nodes with a different strategy.
AnalysisDiagClients AnalysisDiagOpt
bool mayInlineCXXMemberFunction(CXXInlineableMemberKind K) const
Returns the option controlling which C++ member functions will be considered for inlining.
AnalysisConstraints AnalysisConstraintsOpt
unsigned visualizeExplodedGraphWithGraphViz
bool AnalyzerWerror
Emit analyzer warnings as errors.
ConfigTable Config
A key-value table of use-specified configuration values.
bool getCheckerBooleanOption(StringRef CheckerName, StringRef OptionName, bool SearchInParents=false) const
Interprets an option's string value as a boolean.
unsigned maxBlockVisitOnPath
The maximum number of times the analyzer visits a block.
std::string AnalyzeSpecificFunction
IPAKind getIPAMode() const
Returns the inter-procedural analysis mode.
std::string DumpExplodedGraphTo
File path to which the exploded graph should be dumped.
unsigned ShouldEmitErrorsOnInvalidConfigValue
ento::PathDiagnosticConsumerOptions getDiagOpts() const
CTUPhase1InliningKind getCTUPhase1Inlining() const
AnalysisPurgeMode AnalysisPurgeOpt
bool isUnknownAnalyzerConfig(llvm::StringRef Name)
static std::vector< StringRef > getRegisteredCheckers(bool IncludeExperimental=false)
Retrieves the list of checkers generated from Checkers.td.
unsigned InlineMaxStackDepth
The inlining stack depth limit.
llvm::StringMap< std::string > ConfigTable
int getCheckerIntegerOption(StringRef CheckerName, StringRef OptionName, bool SearchInParents=false) const
Interprets an option's string value as an integer value.
static void printFormattedEntry(llvm::raw_ostream &Out, std::pair< StringRef, StringRef > EntryDescPair, size_t InitialPad, size_t EntryWidth, size_t MinLineWidth=0)
Convenience function for printing options or checkers and their description in a formatted manner.
ExplorationStrategyKind getExplorationStrategy() const
StringRef getCheckerStringOption(StringRef CheckerName, StringRef OptionName, bool SearchInParents=false) const
Query an option's string value.
std::string FullCompilerInvocation
Store full compiler invocation for reproducible instructions in the generated report.
AnalysisInliningMode InliningMode
The mode of function selection used during inlining.
UserModeKind
Describes the kinds for high-level analyzer mode.
@ UMK_Deep
Perform deep analyzes.
@ UMK_Shallow
Perform shallow but fast analyzes.
IPAKind
Describes the different modes of inter-procedural analysis.
@ IPAK_Inlining
Inline callees(C, C++, ObjC) when their definitions are available.
@ IPAK_BasicInlining
Inline C functions and blocks when their definitions are available.
@ IPAK_None
Perform only intra-procedural analysis.
@ IPAK_DynamicDispatch
Enable inlining of dynamically dispatched methods.
@ IPAK_DynamicDispatchBifurcate
Enable inlining of dynamically dispatched methods, bifurcate paths when exact type info is unavailabl...
AnalysisConstraints
AnalysisConstraints - Set of available constraint models.
@ NumConstraints
@ C
Languages that the frontend can parse and compile.
CXXInlineableMemberKind
Describes the different kinds of C++ member functions which can be considered for inlining by the ana...
@ CIMK_Destructors
Refers to destructors (implicit or explicit).
@ CIMK_MemberFunctions
Refers to regular member function and operator calls.
@ CIMK_Constructors
Refers to constructors (implicit or explicit).
@ CIMK_None
A dummy mode in which no C++ inlining is enabled.
AnalysisPurgeMode
AnalysisPurgeModes - Set of available strategies for dead symbol removal.
@ NumPurgeModes
CTUPhase1InliningKind
AnalysisDiagClients
AnalysisDiagClients - Set of available diagnostic clients for rendering analysis results.
@ NUM_ANALYSIS_DIAG_CLIENTS
AnalysisInliningMode
AnalysisInlineFunctionSelection - Set of inlining function selection heuristics.
@ NumInliningModes
@ None
The alignment was not explicit in code.
ExplorationStrategyKind
#define false
Definition: stdbool.h:22
These options tweak the behavior of path diangostic consumers.