Diff 169688

include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

Show First 20 Lines • Show All 110 Lines • ▼ Show 20 Lines	enum IPAKind {
/// Enable inlining of dynamically dispatched methods.		/// Enable inlining of dynamically dispatched methods.
IPAK_DynamicDispatch = 4,		IPAK_DynamicDispatch = 4,

/// Enable inlining of dynamically dispatched methods, bifurcate paths when		/// Enable inlining of dynamically dispatched methods, bifurcate paths when
/// exact type info is unavailable.		/// exact type info is unavailable.
IPAK_DynamicDispatchBifurcate = 5		IPAK_DynamicDispatchBifurcate = 5
};		};

		enum class ExplorationStrategyKind {
		DFS,
		BFS,
		UnexploredFirst,
		UnexploredFirstQueue,
		UnexploredFirstLocationQueue,
		BFSBlockDFSContents,
		};

		/// Describes the kinds for high-level analyzer mode.
		enum UserModeKind {
		/// Perform shallow but fast analyzes.
		UMK_Shallow = 1,

		/// Perform deep analyzes.
		UMK_Deep = 2
		};
		SzelethusAuthorUnsubmitted Not Done Reply Inline Actions Do we actually ever use `UMK_SHALLOW`? If not, the whole .def file can be simplified, because the use of `getDefaultValForUserMode(/* ShallowVal /, / DeepVal /)` is clunky. If we do, I'd also be fine with rewriting the function generating macro from #define ANALYZER_OPTION_WITH_FN(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL, \ CREATE_FN) to #define ANALYZER_OPTION_WITH_FN(TYPE, NAME, CMDFLAG, DESC, SHALLOW_VAL, \ DEEP_VAL, CREATE_FN) because that'd be nicer than the current solution. Szelethus:* Do we actually //ever// use `UMK_SHALLOW`? If not, the whole .def file can be simplified…
		NoQUnsubmitted Not Done Reply Inline Actions Xcode uses shallow mode when you tick the checkbox to run static analyzer during normal build, so that not to slow down builds too much. rewriting the function generating macro This seems indeed fancier because it makes everything constexpr, which opens up more possibilities. But i don't see any actual possibilities that it opens up. I guess we can always change it when it becomes necessary. Also it's probably better to make a separate macro for options that have different default values in shallow and deep modes, so that not to duplicate every default value twice. NoQ: Xcode uses shallow mode when you tick the checkbox to run static analyzer during normal build…

class AnalyzerOptions : public RefCountedBase<AnalyzerOptions> {		class AnalyzerOptions : public RefCountedBase<AnalyzerOptions> {
public:		public:
using ConfigTable = llvm::StringMap<std::string>;		using ConfigTable = llvm::StringMap<std::string>;

static std::vector<StringRef>		static std::vector<StringRef>
getRegisteredCheckers(bool IncludeExperimental = false);		getRegisteredCheckers(bool IncludeExperimental = false);

/// Pair of checker name and enable/disable.		/// Pair of checker name and enable/disable.
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines	public:

/// The inlining stack depth limit.		/// The inlining stack depth limit.
// Cap the stack depth at 4 calls (5 stack frames, base + 4 calls).		// Cap the stack depth at 4 calls (5 stack frames, base + 4 calls).
unsigned InlineMaxStackDepth = 5;		unsigned InlineMaxStackDepth = 5;

/// The mode of function selection used during inlining.		/// The mode of function selection used during inlining.
AnalysisInliningMode InliningMode = NoRedundancy;		AnalysisInliningMode InliningMode = NoRedundancy;

enum class ExplorationStrategyKind {
DFS,
BFS,
UnexploredFirst,
UnexploredFirstQueue,
UnexploredFirstLocationQueue,
BFSBlockDFSContents,
};

private:		private:
/// Describes the kinds for high-level analyzer mode.		#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC) \
enum UserModeKind {		Optional<TYPE> NAME;
/// Perform shallow but fast analyzes.		#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
UMK_Shallow = 1,		#undef ANALYZER_OPTION

/// Perform deep analyzes.
UMK_Deep = 2
};

llvm::Optional<ExplorationStrategyKind> ExplorationStrategy;

/// Controls the high-level analyzer mode, which influences the default
/// settings for some of the lower-level config options (such as IPAMode).
/// \sa getUserMode
llvm::Optional<UserModeKind> UserMode;

/// Controls the mode of inter-procedural analysis.
llvm::Optional<IPAKind> IPAMode;

/// Controls which C++ member functions will be considered for inlining.
llvm::Optional<CXXInlineableMemberKind> CXXMemberInliningMode;

/// \sa includeImplicitDtorsInCFG
Optional<bool> IncludeImplicitDtorsInCFG;

/// \sa includeTemporaryDtorsInCFG
Optional<bool> IncludeTemporaryDtorsInCFG;

/// \sa IncludeLifetimeInCFG
Optional<bool> IncludeLifetimeInCFG;

/// \sa IncludeLoopExitInCFG
Optional<bool> IncludeLoopExitInCFG;

/// \sa IncludeRichConstructorsInCFG
Optional<bool> IncludeRichConstructorsInCFG;

/// \sa mayInlineCXXStandardLibrary
Optional<bool> InlineCXXStandardLibrary;

/// \sa includeScopesInCFG
Optional<bool> IncludeScopesInCFG;

/// \sa mayInlineTemplateFunctions
Optional<bool> InlineTemplateFunctions;

/// \sa mayInlineCXXAllocator
Optional<bool> InlineCXXAllocator;

/// \sa mayInlineCXXContainerMethods
Optional<bool> InlineCXXContainerMethods;

/// \sa mayInlineCXXSharedPtrDtor
Optional<bool> InlineCXXSharedPtrDtor;

/// \sa mayInlineCXXTemporaryDtors
Optional<bool> InlineCXXTemporaryDtors;

/// \sa mayInlineObjCMethod
Optional<bool> ObjCInliningMode;

// Cache of the "ipa-always-inline-size" setting.
// \sa getAlwaysInlineSize
Optional<unsigned> AlwaysInlineSize;

/// \sa shouldSuppressNullReturnPaths
Optional<bool> SuppressNullReturnPaths;

// \sa getMaxInlinableSize
Optional<unsigned> MaxInlinableSize;

/// \sa shouldAvoidSuppressingNullArgumentPaths
Optional<bool> AvoidSuppressingNullArgumentPaths;

/// \sa shouldSuppressInlinedDefensiveChecks
Optional<bool> SuppressInlinedDefensiveChecks;

/// \sa shouldSuppressFromCXXStandardLibrary
Optional<bool> SuppressFromCXXStandardLibrary;

/// \sa shouldCrosscheckWithZ3
Optional<bool> CrosscheckWithZ3;

/// \sa reportIssuesInMainSourceFile
Optional<bool> ReportIssuesInMainSourceFile;

/// \sa StableReportFilename
Optional<bool> StableReportFilename;

Optional<bool> SerializeStats;

/// \sa getGraphTrimInterval
Optional<unsigned> GraphTrimInterval;

/// \sa getMaxSymbolComplexity
Optional<unsigned> MaxSymbolComplexity;

/// \sa getMaxTimesInlineLarge
Optional<unsigned> MaxTimesInlineLarge;

/// \sa getMinCFGSizeTreatFunctionsAsLarge
Optional<unsigned> MinCFGSizeTreatFunctionsAsLarge;

/// \sa getMaxNodesPerTopLevelFunction
Optional<unsigned> MaxNodesPerTopLevelFunction;

/// \sa shouldInlineLambdas
Optional<bool> InlineLambdas;

/// \sa shouldWidenLoops
Optional<bool> WidenLoops;

/// \sa shouldUnrollLoops
Optional<bool> UnrollLoops;

/// \sa shouldDisplayNotesAsEvents
Optional<bool> DisplayNotesAsEvents;

/// \sa shouldAggressivelySimplifyBinaryOperation
Optional<bool> AggressiveBinaryOperationSimplification;

/// \sa shouldEagerlyAssume
Optional<bool> EagerlyAssumeBinOpBifurcation;

/// \sa getCTUDir
Optional<StringRef> CTUDir;

/// \sa getCTUIndexName
Optional<StringRef> CTUIndexName;

/// \sa naiveCTUEnabled
Optional<bool> NaiveCTU;

/// \sa shouldElideConstructors
Optional<bool> ElideConstructors;

/// \sa getModelPath
Optional<StringRef> ModelPath;

/// A helper function that retrieves option for a given full-qualified		/// A helper function that retrieves option for a given full-qualified
/// checker name.		/// checker name.
/// Options for checkers can be specified via 'analyzer-config' command-line		/// Options for checkers can be specified via 'analyzer-config' command-line
/// option.		/// option.
/// Example:		/// Example:
/// @code-analyzer-config unix.Malloc:OptionName=CheckerOptionValue @endcode		/// @code-analyzer-config unix.Malloc:OptionName=CheckerOptionValue @endcode
/// or @code-analyzer-config unix:OptionName=GroupOptionValue @endcode		/// or @code-analyzer-config unix:OptionName=GroupOptionValue @endcode
Show All 19 Lines
public:		public:
AnalyzerOptions()		AnalyzerOptions()
: DisableAllChecks(false), ShowCheckerHelp(false),		: DisableAllChecks(false), ShowCheckerHelp(false),
ShowEnabledCheckerList(false), AnalyzeAll(false),		ShowEnabledCheckerList(false), AnalyzeAll(false),
AnalyzerDisplayProgress(false), AnalyzeNestedBlocks(false),		AnalyzerDisplayProgress(false), AnalyzeNestedBlocks(false),
eagerlyAssumeBinOpBifurcation(false), TrimGraph(false),		eagerlyAssumeBinOpBifurcation(false), TrimGraph(false),
visualizeExplodedGraphWithGraphViz(false),		visualizeExplodedGraphWithGraphViz(false),
UnoptimizedCFG(false),		UnoptimizedCFG(false),
PrintStats(false), NoRetryExhausted(false), CXXMemberInliningMode() {}		PrintStats(false), NoRetryExhausted(false) {}

/// Interprets an option's string value as a boolean. The "true" string is		/// Interprets an option's string value as a boolean. The "true" string is
/// interpreted as true and the "false" string is interpreted as false.		/// interpreted as true and the "false" string is interpreted as false.
///		///
/// If an option value is not provided, returns the given \p DefaultVal.		/// If an option value is not provided, returns the given \p DefaultVal.
/// @param [in] Name Name for option to retrieve.		/// @param [in] Name Name for option to retrieve.
/// @param [in] DefaultVal Default value returned if no such option was		/// @param [in] DefaultVal Default value returned if no such option was
/// specified.		/// specified.
Show All 38 Lines	public:
/// @param [in] SearchInParents If set to true and the searched option was not		/// @param [in] SearchInParents If set to true and the searched option was not
/// specified for the given checker the options for the parent packages will		/// specified for the given checker the options for the parent packages will
/// be searched as well. The inner packages take precedence over the outer		/// be searched as well. The inner packages take precedence over the outer
/// ones.		/// ones.
int getOptionAsInteger(StringRef Name, int DefaultVal,		int getOptionAsInteger(StringRef Name, int DefaultVal,
const ento::CheckerBase *C = nullptr,		const ento::CheckerBase *C = nullptr,
bool SearchInParents = false);		bool SearchInParents = false);


unsigned getOptionAsUInt(Optional<unsigned> &V, StringRef Name,		unsigned getOptionAsUInt(Optional<unsigned> &V, StringRef Name,
unsigned DefaultVal,		unsigned DefaultVal,
const ento::CheckerBase *C = nullptr,		const ento::CheckerBase *C = nullptr,
bool SearchInParents = false);		bool SearchInParents = false);

/// Query an option's string value.		/// Query an option's string value.
///		///
/// If an option value is not provided, returns the given \p DefaultVal.		/// If an option value is not provided, returns the given \p DefaultVal.
Show All 11 Lines	StringRef getOptionAsString(StringRef Name, StringRef DefaultVal,
const ento::CheckerBase *C = nullptr,		const ento::CheckerBase *C = nullptr,
bool SearchInParents = false);		bool SearchInParents = false);

StringRef getOptionAsString(Optional<StringRef> &V, StringRef Name,		StringRef getOptionAsString(Optional<StringRef> &V, StringRef Name,
StringRef DefaultVal,		StringRef DefaultVal,
const ento::CheckerBase *C = nullptr,		const ento::CheckerBase *C = nullptr,
bool SearchInParents = false);		bool SearchInParents = false);

		template <typename T>
		T getDefaultValForUserMode(T ShallowVal, T DeepVal);

		#define ANALYZER_OPTION_WITH_FN(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL, \
		CREATE_FN) \
		TYPE CREATE_FN();
		#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
		#undef ANALYZER_OPTION

/// Retrieves and sets the UserMode. This is a high-level option,		/// Retrieves and sets the UserMode. This is a high-level option,
/// which is used to set other low-level options. It is not accessible		/// which is used to set other low-level options. It is not accessible
/// outside of AnalyzerOptions.		/// outside of AnalyzerOptions.
UserModeKind getUserMode();		UserModeKind getUserMode();

ExplorationStrategyKind getExplorationStrategy();		ExplorationStrategyKind getExplorationStrategy();

/// Returns the inter-procedural analysis mode.		/// Returns the inter-procedural analysis mode.
IPAKind getIPAMode();		IPAKind getIPAMode();

/// Returns the option controlling which C++ member functions will be		/// Returns the option controlling which C++ member functions will be
/// considered for inlining.		/// considered for inlining.
///		///
/// This is controlled by the 'c++-inlining' config option.		/// This is controlled by the 'c++-inlining' config option.
///		///
/// \sa CXXMemberInliningMode		/// \sa CXXMemberInliningMode
bool mayInlineCXXMemberFunction(CXXInlineableMemberKind K);		bool mayInlineCXXMemberFunction(CXXInlineableMemberKind K);

/// Returns true if ObjectiveC inlining is enabled, false otherwise.
bool mayInlineObjCMethod();

/// Returns whether or not the destructors for C++ temporary objects should
/// be included in the CFG.
///
/// This is controlled by the 'cfg-temporary-dtors' config option, which
/// accepts the values "true" and "false".
bool includeTemporaryDtorsInCFG();

/// Returns whether or not implicit destructors for C++ objects should
/// be included in the CFG.
///
/// This is controlled by the 'cfg-implicit-dtors' config option, which
/// accepts the values "true" and "false".
bool includeImplicitDtorsInCFG();

/// Returns whether or not end-of-lifetime information should be included in
/// the CFG.
///
/// This is controlled by the 'cfg-lifetime' config option, which accepts
/// the values "true" and "false".
bool includeLifetimeInCFG();

/// Returns whether or not the end of the loop information should be included
/// in the CFG.
///
/// This is controlled by the 'cfg-loopexit' config option, which accepts
/// the values "true" and "false".
bool includeLoopExitInCFG();

/// Returns whether or not construction site information should be included
/// in the CFG C++ constructor elements.
///
/// This is controlled by the 'cfg-rich-constructors' config options,
/// which accepts the values "true" and "false".
bool includeRichConstructorsInCFG();

/// Returns whether or not scope information should be included in the CFG.
///
/// This is controlled by the 'cfg-scope-info' config option, which accepts
/// the values "true" and "false".
bool includeScopesInCFG();

/// Returns whether or not C++ standard library functions may be considered
/// for inlining.
///
/// This is controlled by the 'c++-stdlib-inlining' config option, which
/// accepts the values "true" and "false".
bool mayInlineCXXStandardLibrary();

/// Returns whether or not templated functions may be considered for inlining.
///
/// This is controlled by the 'c++-template-inlining' config option, which
/// accepts the values "true" and "false".
bool mayInlineTemplateFunctions();

/// Returns whether or not allocator call may be considered for inlining.
///
/// This is controlled by the 'c++-allocator-inlining' config option, which
/// accepts the values "true" and "false".
bool mayInlineCXXAllocator();

/// Returns whether or not methods of C++ container objects may be considered
/// for inlining.
///
/// This is controlled by the 'c++-container-inlining' config option, which
/// accepts the values "true" and "false".
bool mayInlineCXXContainerMethods();

/// Returns whether or not the destructor of C++ 'shared_ptr' may be
/// considered for inlining.
///
/// This covers std::shared_ptr, std::tr1::shared_ptr, and boost::shared_ptr,
/// and indeed any destructor named "~shared_ptr".
///
/// This is controlled by the 'c++-shared_ptr-inlining' config option, which
/// accepts the values "true" and "false".
bool mayInlineCXXSharedPtrDtor();

/// Returns true if C++ temporary destructors should be inlined during
/// analysis.
///
/// If temporary destructors are disabled in the CFG via the
/// 'cfg-temporary-dtors' option, temporary destructors would not be
/// inlined anyway.
///
/// This is controlled by the 'c++-temp-dtor-inlining' config option, which
/// accepts the values "true" and "false".
bool mayInlineCXXTemporaryDtors();

/// Returns whether or not paths that go through null returns should be
/// suppressed.
///
/// This is a heuristic for avoiding bug reports with paths that go through
/// inlined functions that are more defensive than their callers.
///
/// This is controlled by the 'suppress-null-return-paths' config option,
/// which accepts the values "true" and "false".
bool shouldSuppressNullReturnPaths();

/// Returns whether a bug report should \em not be suppressed if its path
/// includes a call with a null argument, even if that call has a null return.
///
/// This option has no effect when #shouldSuppressNullReturnPaths() is false.
///
/// This is a counter-heuristic to avoid false negatives.
///
/// This is controlled by the 'avoid-suppressing-null-argument-paths' config
/// option, which accepts the values "true" and "false".
bool shouldAvoidSuppressingNullArgumentPaths();

/// Returns whether or not diagnostics containing inlined defensive NULL
/// checks should be suppressed.
///
/// This is controlled by the 'suppress-inlined-defensive-checks' config
/// option, which accepts the values "true" and "false".
bool shouldSuppressInlinedDefensiveChecks();

/// Returns whether or not diagnostics reported within the C++ standard
/// library should be suppressed.
///
/// This is controlled by the 'suppress-c++-stdlib' config option,
/// which accepts the values "true" and "false".
bool shouldSuppressFromCXXStandardLibrary();

/// Returns whether bug reports should be crosschecked with the Z3
/// constraint manager backend.
///
/// This is controlled by the 'crosscheck-with-z3' config option,
/// which accepts the values "true" and "false".
bool shouldCrosscheckWithZ3();

/// Returns whether or not the diagnostic report should be always reported
/// in the main source file and not the headers.
///
/// This is controlled by the 'report-in-main-source-file' config option,
/// which accepts the values "true" and "false".
bool shouldReportIssuesInMainSourceFile();

/// Returns whether or not the report filename should be random or not.
///
/// This is controlled by the 'stable-report-filename' config option,
/// which accepts the values "true" and "false". Default = false
bool shouldWriteStableReportFilename();

/// \return Whether the analyzer should
/// serialize statistics to plist output.
/// Statistics would be serialized in JSON format inside the main dictionary
/// under the \c statistics key.
/// Available only if compiled in assert mode or with LLVM statistics
/// explicitly enabled.
bool shouldSerializeStats();

/// Returns whether irrelevant parts of a bug report path should be pruned
/// out of the final output.
///
/// This is controlled by the 'prune-paths' config option, which accepts the
/// values "true" and "false".
bool shouldPrunePaths();

/// Returns true if 'static' initializers should be in conditional logic
/// in the CFG.
bool shouldConditionalizeStaticInitializers();

// Returns the size of the functions (in basic blocks), which should be
// considered to be small enough to always inline.
//
// This is controlled by "ipa-always-inline-size" analyzer-config option.
unsigned getAlwaysInlineSize();

// Returns the bound on the number of basic blocks in an inlined function
// (50 by default).
//
// This is controlled by "-analyzer-config max-inlinable-size" option.
unsigned getMaxInlinableSize();

/// Returns true if the analyzer engine should synthesize fake bodies
/// for well-known functions.
bool shouldSynthesizeBodies();

/// Returns how often nodes in the ExplodedGraph should be recycled to save
/// memory.
///
/// This is controlled by the 'graph-trim-interval' config option. To disable
/// node reclamation, set the option to "0".
unsigned getGraphTrimInterval();

/// Returns the maximum complexity of symbolic constraint (50 by default).
///
/// This is controlled by "-analyzer-config max-symbol-complexity" option.
unsigned getMaxSymbolComplexity();

/// Returns the maximum times a large function could be inlined.
///
/// This is controlled by the 'max-times-inline-large' config option.
unsigned getMaxTimesInlineLarge();

/// Returns the number of basic blocks a function needs to have to be
/// considered large for the 'max-times-inline-large' config option.
///
/// This is controlled by the 'min-cfg-size-treat-functions-as-large' config
/// option.
unsigned getMinCFGSizeTreatFunctionsAsLarge();

/// Returns the maximum number of nodes the analyzer can generate while
/// exploring a top level function (for each exploded graph).
/// 150000 is default; 0 means no limit.
///
/// This is controlled by the 'max-nodes' config option.
unsigned getMaxNodesPerTopLevelFunction();

/// Returns true if lambdas should be inlined. Otherwise a sink node will be
/// generated each time a LambdaExpr is visited.
bool shouldInlineLambdas();

/// Returns true if the analysis should try to widen loops.
/// This is controlled by the 'widen-loops' config option.
bool shouldWidenLoops();

/// Returns true if the analysis should try to unroll loops with known bounds.
/// This is controlled by the 'unroll-loops' config option.
bool shouldUnrollLoops();

/// Returns true if the bug reporter should transparently treat extra note
/// diagnostic pieces as event diagnostic pieces. Useful when the diagnostic
/// consumer doesn't support the extra note pieces.
///
/// This is controlled by the 'extra-notes-as-events' option, which defaults
/// to false when unset.
bool shouldDisplayNotesAsEvents();

/// Returns true if SValBuilder should rearrange comparisons and additive
/// operations of symbolic expressions which consist of a sum of a symbol and
/// a concrete integer into the format where symbols are on the left-hand
/// side and the integer is on the right. This is only done if both symbols
/// and both concrete integers are signed, greater than or equal to the
/// quarter of the minimum value of the type and less than or equal to the
/// quarter of the maximum value of that type.
///
/// A + n <OP> B + m becomes A - B <OP> m - n, where A and B symbolic,
/// n and m are integers. <OP> is any of '==', '!=', '<', '<=', '>', '>=',
/// '+' or '-'. The rearrangement also happens with '-' instead of '+' on
// either or both side and also if any or both integers are missing.
bool shouldAggressivelySimplifyBinaryOperation();

/// Returns true if we should eagerly assume evaluations of
/// conditionals, thus, bifurcating the path.
///
/// This indicates how the engine should handle expressions such as: 'x =
/// (y != 0)'. When this is true then the subexpression 'y != 0' will be
/// eagerly assumed to be true or false, thus evaluating it to the integers 0
/// or 1 respectively. The upside is that this can increase analysis
/// precision until we have a better way to lazily evaluate such logic. The
/// downside is that it eagerly bifurcates paths.
bool shouldEagerlyAssume();

/// Returns the directory containing the CTU related files.
StringRef getCTUDir();		StringRef getCTUDir();

/// Returns the name of the file containing the CTU index of functions.
StringRef getCTUIndexName();

/// Returns true when naive cross translation unit analysis is enabled.
/// This is an experimental feature to inline functions from another
/// translation units.
bool naiveCTUEnabled();

/// Returns true if elidable C++ copy-constructors and move-constructors
/// should be actually elided during analysis. Both behaviors are allowed
/// by the C++ standard, and the analyzer, like CodeGen, defaults to eliding.
/// Starting with C++17 some elisions become mandatory, and in these cases
/// the option will be ignored.
bool shouldElideConstructors();

StringRef getModelPath();
};		};

using AnalyzerOptionsRef = IntrusiveRefCntPtr<AnalyzerOptions>;		using AnalyzerOptionsRef = IntrusiveRefCntPtr<AnalyzerOptions>;

} // namespace clang		} // namespace clang

#endif // LLVM_CLANG_STATICANALYZER_CORE_ANALYZEROPTIONS_H		#endif // LLVM_CLANG_STATICANALYZER_CORE_ANALYZEROPTIONS_H

include/clang/StaticAnalyzer/Core/AnalyzerOptions.def

This file was added.

				//===-- AnalyzerOptions.def - Metadata about Static Analyses ----- C++ --===//
				//
				// The LLVM Compiler Infrastructure
				//
				// This file is distributed under the University of Illinois Open Source
				// License. See LICENSE.TXT for details.
				//
				//===----------------------------------------------------------------------===//
				//
				// This file defines the analyzer options avaible with -analyzer-config.
				//
				// This file is in part intended for method generation. The options are listed
				// in two formats, with two function-like macros:
				//
				// * ANALYZER_OPTION_WITH_FN: Register a new option, and generate a getter
				// method for it in AnalyzerOptions.
				// * ANALYZER_OPTION: Register a new option, but do not generate a method.
				//
				// If this file is included with ANALYZER_OPTION_WITH_FN predefined, entries
				// that do not generate functions won't appear. If it is not defined, all
				// entries are accessible through the ANALYZER_OPTION function-like macro.
				//
				//===----------------------------------------------------------------------===//

				#ifndef LLVM_CLANG_STATICANALYZER_CORE_ANALYZEROPTIONS_H
				#error This .def file is expected to be included in translation units where \
				"clang/StaticAnalyzer/Core/AnalyzerOptions.h" is already included, as it \
				contains types from that header!
				#endif

				#ifndef ANALYZER_OPTION
				/// Create a new analyzer option, but dont generate a method for it in
				/// AnalyzerOptions.
				///
				/// TYPE - The type of the option object that will be stored in
				/// AnalyzerOptions. This file is expected to be icluded in translation
				/// units where AnalyzerOptions.h is included, so types from that header
				/// should be used.
				/// NAME - The name of the option object.
				/// CMDFLAG - The command line flag for the option.
				/// (-analyzer-option CMDFLAG=VALUE)
				/// DESC - Description of the flag.
				#define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC)
				#endif

				#ifndef ANALYZER_OPTION_WITH_FN
				/// Create a new analyzer option, and generate a getter method for it in
				/// AnalyzerOptions.
				/// TYPE - The type of the option object that will be stored in
				/// AnalyzerOptions. This file is expected to be icluded in translation
				/// units where AnalyzerOptions.h is included, so types from that header
				/// should be used.
				/// NAME - The name of the option object.
				/// CMDFLAG - The command line flag for the option.
				/// (-analyzer-option CMDFLAG=VALUE)
				/// DESC - Description of the flag.
				/// DEFAULT_VAL - The default value, same type as TYPE.
				/// CREATE_FN - Name of the getter function.
				// If this def file wasn't included with the intent of generating functions,
				// regard all entries as ANALYZER_OPTION.
				#define ANALYZER_OPTION_WITH_FN(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL, \
				CREATE_FN) \
				ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC)
				#endif

				//===----------------------------------------------------------------------===//
				// Analyzer options of a variety of types.
				//===----------------------------------------------------------------------===//

				/// Controls the high-level analyzer mode, which influences the default
				/// settings for some of the lower-level config options (such as IPAMode).
				ANALYZER_OPTION(UserModeKind, UserMode, "mode", "")
				NoQUnsubmitted Not Done Reply Inline Actions I think it's unnecessary to duplicate the --help text in comments. NoQ: I think it's unnecessary to duplicate the --help text in comments.

				/// Controls which C++ member functions will be considered for inlining.
				ANALYZER_OPTION(CXXInlineableMemberKind, CXXMemberInliningMode, "c++-inlining",
				"")

				/// Controls the mode of inter-procedural analysis.
				ANALYZER_OPTION(IPAKind, IPAMode, "ipa", "")

				ANALYZER_OPTION(ExplorationStrategyKind, ExplorationStrategy,
				"exploration_strategy", "")

				//===----------------------------------------------------------------------===//
				// Boolean analyzer options.
				//===----------------------------------------------------------------------===//

				/// Returns whether or not implicit destructors for C++ objects should
				/// be included in the CFG.
				ANALYZER_OPTION_WITH_FN(bool, IncludeImplicitDtorsInCFG, "cfg-implicit-dtors",
				"", true, includeImplicitDtorsInCFG)

				/// Returns whether or not the destructors for C++ temporary objects should
				/// be included in the CFG.
				ANALYZER_OPTION_WITH_FN(bool, IncludeTemporaryDtorsInCFG, "cfg-temporary-dtors",
				"", true, includeTemporaryDtorsInCFG)

				/// Returns whether or not end-of-lifetime information should be included in
				/// the CFG.
				ANALYZER_OPTION_WITH_FN(bool, IncludeLifetimeInCFG, "cfg-lifetime", "", false,
				includeLifetimeInCFG)

				/// Returns whether or not the end of the loop information should be included
				/// in the CFG.
				ANALYZER_OPTION_WITH_FN(bool, IncludeLoopExitInCFG, "cfg-loopexit", "", false,
				includeLoopExitInCFG)

				/// Returns whether or not construction site information should be included
				/// in the CFG C++ constructor elements.
				ANALYZER_OPTION_WITH_FN(bool, IncludeRichConstructorsInCFG,
				"cfg-rich-constructors", "", true,
				includeRichConstructorsInCFG)

				/// Returns whether or not scope information should be included in the CFG.
				ANALYZER_OPTION_WITH_FN(bool, IncludeScopesInCFG, "cfg-scopes", "", false,
				includeScopesInCFG)

				/// Returns whether or not templated functions may be considered for inlining.
				ANALYZER_OPTION_WITH_FN(bool, InlineTemplateFunctions, "c++-template-inlining",
				"", true, mayInlineTemplateFunctions)

				/// Returns whether or not C++ standard library functions may be considered
				/// for inlining.
				ANALYZER_OPTION_WITH_FN(bool, InlineCXXStandardLibrary, "c++-stdlib-inlining",
				"", true, mayInlineCXXStandardLibrary)

				/// Returns whether or not allocator call may be considered for inlining.
				ANALYZER_OPTION_WITH_FN(bool, InlineCXXAllocator, "c++-allocator-inlining", "",
				true, mayInlineCXXAllocator)

				/// Returns whether or not the destructor of C++ 'shared_ptr' may be
				/// considered for inlining.
				///
				/// This covers std::shared_ptr, std::tr1::shared_ptr, and boost::shared_ptr,
				/// and indeed any destructor named "~shared_ptr".
				ANALYZER_OPTION_WITH_FN(bool, InlineCXXSharedPtrDtor, "c++-shared_ptr-inlining",
				"", false, mayInlineCXXSharedPtrDtor)

				/// Returns true if C++ temporary destructors should be inlined during
				/// analysis.
				///
				/// If temporary destructors are disabled in the CFG via the
				/// 'cfg-temporary-dtors' option, temporary destructors would not be
				/// inlined anyway.
				ANALYZER_OPTION_WITH_FN(bool, InlineCXXTemporaryDtors, "c++-temp-dtor-inlining",
				"", true, mayInlineCXXTemporaryDtors)

				/// Returns whether or not paths that go through null returns should be
				/// suppressed.
				///
				/// This is a heuristic for avoiding bug reports with paths that go through
				/// inlined functions that are more defensive than their callers.
				ANALYZER_OPTION_WITH_FN(bool, SuppressNullReturnPaths,
				"suppress-null-return-paths", "", true,
				shouldSuppressNullReturnPaths)

				/// Returns whether a bug report should \em not be suppressed if its path
				/// includes a call with a null argument, even if that call has a null return.
				///
				/// This option has no effect when #shouldSuppressNullReturnPaths() is false.
				///
				/// This is a counter-heuristic to avoid false negatives.
				ANALYZER_OPTION_WITH_FN(bool, AvoidSuppressingNullArgumentPaths,
				"avoid-suppressing-null-argument-paths", "", false,
				shouldAvoidSuppressingNullArgumentPaths)

				/// Returns whether or not diagnostics containing inlined defensive NULL
				/// checks should be suppressed.
				ANALYZER_OPTION_WITH_FN(bool, SuppressInlinedDefensiveChecks,
				"suppress-inlined-defensive-checks", "", true,
				shouldSuppressInlinedDefensiveChecks)

				/// Returns whether or not methods of C++ container objects may be considered
				/// for inlining.
				ANALYZER_OPTION_WITH_FN(bool, InlineCXXContainerMethods,
				"c++-container-inlining", "", false,
				mayInlineCXXContainerMethods)

				/// Returns whether or not diagnostics reported within the C++ standard
				/// library should be suppressed.
				ANALYZER_OPTION_WITH_FN(bool, SuppressFromCXXStandardLibrary,
				"suppress-c++-stdlib", "", true,
				shouldSuppressFromCXXStandardLibrary)

				/// Returns whether bug reports should be crosschecked with the Z3
				/// constraint manager backend.
				ANALYZER_OPTION_WITH_FN(bool, CrosscheckWithZ3, "crosscheck-with-z3", "", false,
				shouldCrosscheckWithZ3)

				/// Returns whether or not the diagnostic report should be always reported
				/// in the main source file and not the headers.
				ANALYZER_OPTION_WITH_FN(bool, ReportIssuesInMainSourceFile,
				"report-in-main-source-file", "", false,
				shouldReportIssuesInMainSourceFile)

				/// Returns whether or not the report filename should be random or not.
				ANALYZER_OPTION_WITH_FN(bool, WriteStableReportFilename,
				"stable-report-filename", "", false,
				shouldWriteStableReportFilename)

				/// \return Whether the analyzer should serialize statistics to plist output.
				/// Statistics would be serialized in JSON format inside the main dictionary
				/// under the \c statistics key.
				/// Available only if compiled in assert mode or with LLVM statistics
				/// explicitly enabled.
				ANALYZER_OPTION_WITH_FN(bool, SerializeStats, "serialize-stats", "", false,
				shouldSerializeStats)

				/// Returns true if ObjectiveC inlining is enabled, false otherwise.
				ANALYZER_OPTION_WITH_FN(bool, InlineObjCMethod, "objc-inlining", "", true,
				mayInlineObjCMethod)

				/// Returns whether irrelevant parts of a bug report path should be pruned
				/// out of the final output.
				ANALYZER_OPTION_WITH_FN(bool, PrunePaths, "prune-paths", "", true,
				shouldPrunePaths)

				/// Returns true if 'static' initializers should be in conditional logic
				/// in the CFG.
				ANALYZER_OPTION_WITH_FN(bool, ConditionalizeStaticInitializers,
				"cfg-conditional-static-initializers", "", true,
				shouldConditionalizeStaticInitializers)

				/// Returns true if the analyzer engine should synthesize fake bodies
				/// for well-known functions.
				ANALYZER_OPTION_WITH_FN(bool, SynthesizeBodies, "faux-bodies", "", true,
				shouldSynthesizeBodies)

				/// Returns true if elidable C++ copy-constructors and move-constructors
				/// should be actually elided during analysis. Both behaviors are allowed
				/// by the C++ standard, and the analyzer, like CodeGen, defaults to eliding.
				/// Starting with C++17 some elisions become mandatory, and in these cases
				/// the option will be ignored.
				ANALYZER_OPTION_WITH_FN(bool, ElideConstructors, "elide-constructors", "", true,
				shouldElideConstructors)

				/// Returns true if lambdas should be inlined. Otherwise a sink node will be
				/// generated each time a LambdaExpr is visited.
				ANALYZER_OPTION_WITH_FN(bool, InlineLambdas, "inline-lambdas", "", true,
				shouldInlineLambdas)

				/// Returns true if the analysis should try to widen loops.
				/// This is controlled by the '' config option.
				ANALYZER_OPTION_WITH_FN(bool, WidenLoops, "widen-loops", "", false,
				shouldWidenLoops)

				/// Returns true if the analysis should try to unroll loops with known bounds.
				/// This is controlled by the '' config option.
				ANALYZER_OPTION_WITH_FN(bool, UnrollLoops, "unroll-loops", "", false,
				shouldUnrollLoops)

				/// Returns true if the bug reporter should transparently treat extra note
				/// diagnostic pieces as event diagnostic pieces. Useful when the diagnostic
				/// consumer doesn't support the extra note pieces.
				ANALYZER_OPTION_WITH_FN(bool, DisplayNotesAsEvents, "notes-as-events", "",
				false, shouldDisplayNotesAsEvents)

				/// Returns true if SValBuilder should rearrange comparisons and additive
				/// operations of symbolic expressions which consist of a sum of a symbol and
				/// a concrete integer into the format where symbols are on the left-hand
				/// side and the integer is on the right. This is only done if both symbols
				/// and both concrete integers are signed, greater than or equal to the
				/// quarter of the minimum value of the type and less than or equal to the
				/// quarter of the maximum value of that type.
				///
				/// A + n <OP> B + m becomes A - B <OP> m - n, where A and B symbolic,
				/// n and m are integers. <OP> is any of '==', '!=', '<', '<=', '>', '>=',
				/// '+' or '-'. The rearrangement also happens with '-' instead of '+' on
				// either or both side and also if any or both integers are missing.
				ANALYZER_OPTION_WITH_FN(bool, AggressivelySimplifyBinaryOperation,
				"aggressive-binary-operation-simplification", "", false,
				shouldAggressivelySimplifyBinaryOperation)

				/// Returns true if we should eagerly assume evaluations of
				/// conditionals, thus, bifurcating the path.
				///
				/// This indicates how the engine should handle expressions such as: 'x =
				/// (y != 0)'. When this is true then the subexpression 'y != 0' will be
				/// eagerly assumed to be true or false, thus evaluating it to the integers 0
				/// or 1 respectively. The upside is that this can increase analysis
				/// precision until we have a better way to lazily evaluate such logic. The
				/// downside is that it eagerly bifurcates paths.
				ANALYZER_OPTION_WITH_FN(bool, EagerlyAssume, "eagerly-assume", "", true,
				shouldEagerlyAssume)

				/// Returns true when naive cross translation unit analysis is enabled.
				/// This is an experimental feature to inline functions from another
				/// translation units.
				ANALYZER_OPTION_WITH_FN(bool, NaiveCTU,
				"experimental-enable-naive-ctu-analysis", "", false,
				naiveCTUEnabled)

				//===----------------------------------------------------------------------===//
				// Unsinged analyzer options.
				//===----------------------------------------------------------------------===//

				// Returns the size of the functions (in basic blocks), which should be
				// considered to be small enough to always inline.
				ANALYZER_OPTION_WITH_FN(unsigned, AlwaysInlineSize, "ipa-always-inline-size",
				"", 3, getAlwaysInlineSize)

				/// Returns how often nodes in the ExplodedGraph should be recycled to save
				/// memory.
				///
				/// To disable node reclamation, set the option to "0".
				ANALYZER_OPTION_WITH_FN(unsigned, GraphTrimInterval, "graph-trim-interval", "",
				1000, getGraphTrimInterval)

				/// Returns the number of basic blocks a function needs to have to be
				/// considered large for the 'max-times-inline-large' config option.
				ANALYZER_OPTION_WITH_FN(unsigned, MinCFGSizeTreatFunctionsAsLarge,
				"min-cfg-size-treat-functions-as-large", "", 14,
				getMinCFGSizeTreatFunctionsAsLarge)

				/// Returns the maximum complexity of symbolic constraint (50 by default).
				ANALYZER_OPTION_WITH_FN(unsigned, MaxSymbolComplexity, "max-symbol-complexity",
				"", 35, getMaxSymbolComplexity)

				/// Returns the maximum times a large function could be inlined.
				ANALYZER_OPTION_WITH_FN(unsigned, MaxTimesInlineLarge, "max-times-inline-large",
				"", 32, getMaxTimesInlineLarge)

				// Returns the bound on the number of basic blocks in an inlined function.
				ANALYZER_OPTION_WITH_FN(unsigned, MaxInlinableSize, "max-inlinable-size", "",
				getDefaultValForUserMode(/* ShallowVal */ 4,
				/* DeepVal */ 100),
				getMaxInlinableSize)

				/// Returns the maximum number of nodes the analyzer can generate while
				/// exploring a top level function (for each exploded graph).
				/// 150000 is default; 0 means no limit.
				ANALYZER_OPTION_WITH_FN(unsigned, MaxNodesPerTopLevelFunction, "max-nodes", "",
				getDefaultValForUserMode(/* ShallowVal */ 75000,
				/* DeepVal */ 225000),
				getMaxNodesPerTopLevelFunction)

				//===----------------------------------------------------------------------===//
				// String analyzer options.
				//===----------------------------------------------------------------------===//

				/// Returns the directory containing the CTU related files.
				ANALYZER_OPTION(StringRef, CTUDir, "ctu-dir", "")

				/// Returns the name of the file containing the CTU index of functions.
				ANALYZER_OPTION_WITH_FN(StringRef, CTUIndexName, "ctu-index-name", "",
				"externalFnMap.txt", getCTUIndexName)

				/// TODO: Document this, used in lib/StaticAnalyzer/Frontend/ModelInjector.cpp.
				ANALYZER_OPTION_WITH_FN(StringRef, ModelPath, "model-path", "", "",
				getModelPath)

				#undef ANALYZER_OPTION_WITH_FN
				#undef ANALYZER_OPTION
				SzelethusAuthorUnsubmitted Not Done Reply Inline Actions Found the use for this here: https://github.com/llvm-mirror/clang/blob/master/lib/StaticAnalyzer/Frontend/ModelInjector.cpp#L51 Which was added by this commit: https://github.com/llvm-mirror/clang/commit/fdf0d3513240fd8e4da6942e9cd26d2d730eb37b#diff-6e67e63f578935f02bd1d5b20488ea8c This patch was contributed by Gábor Horváth as part of his Google Summer of Code project. @xazax.hun, what would be a good description for this flag? Szelethus: Found the use for this here: https://github.com/llvm…
				SzelethusAuthorUnsubmitted Not Done Reply Inline Actions This inline was meant for: `ANALYZER_OPTION_GEN_FN(StringRef, ModelPath, "model-path", "", "", getModelPath)` Szelethus: This inline was meant for: `ANALYZER_OPTION_GEN_FN(StringRef, ModelPath, "model-path", "", ""…
				xazax.hunUnsubmitted Not Done Reply Inline Actions Should we explain the feature in the commad line path? The description might be somethinge like: `(string) The analyzer can inline an alternative implementation written in C at the call site if the called function's body is not available. This is a path where to look for those alternative implementations (called models).` xazax.hun: Should we explain the feature in the commad line path? The description might be somethinge…

lib/StaticAnalyzer/Core/AnalyzerOptions.cpp

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines	#undef GET_CHECKERS
for (StringRef CheckName : StaticAnalyzerChecks) {		for (StringRef CheckName : StaticAnalyzerChecks) {
if (!CheckName.startswith("debug.") &&		if (!CheckName.startswith("debug.") &&
(IncludeExperimental \|\| !CheckName.startswith("alpha.")))		(IncludeExperimental \|\| !CheckName.startswith("alpha.")))
Result.push_back(CheckName);		Result.push_back(CheckName);
}		}
return Result;		return Result;
}		}

AnalyzerOptions::UserModeKind AnalyzerOptions::getUserMode() {		UserModeKind AnalyzerOptions::getUserMode() {
if (!UserMode.hasValue()) {		if (!UserMode.hasValue()) {
StringRef ModeStr = getOptionAsString("mode", "deep");		StringRef ModeStr = getOptionAsString("mode", "deep");
UserMode = llvm::StringSwitch<llvm::Optional<UserModeKind>>(ModeStr)		UserMode = llvm::StringSwitch<llvm::Optional<UserModeKind>>(ModeStr)
.Case("shallow", UMK_Shallow)		.Case("shallow", UMK_Shallow)
.Case("deep", UMK_Deep)		.Case("deep", UMK_Deep)
.Default(None);		.Default(None);
assert(UserMode.getValue() && "User mode is invalid.");		assert(UserMode.getValue() && "User mode is invalid.");
}		}
return UserMode.getValue();		return UserMode.getValue();
}		}

AnalyzerOptions::ExplorationStrategyKind		ExplorationStrategyKind
AnalyzerOptions::getExplorationStrategy() {		AnalyzerOptions::getExplorationStrategy() {
if (!ExplorationStrategy.hasValue()) {		if (!ExplorationStrategy.hasValue()) {
StringRef StratStr = getOptionAsString("exploration_strategy",		StringRef StratStr = getOptionAsString("exploration_strategy",
"unexplored_first_queue");		"unexplored_first_queue");
ExplorationStrategy =		ExplorationStrategy =
llvm::StringSwitch<llvm::Optional<ExplorationStrategyKind>>(StratStr)		llvm::StringSwitch<llvm::Optional<ExplorationStrategyKind>>(StratStr)
.Case("dfs", ExplorationStrategyKind::DFS)		.Case("dfs", ExplorationStrategyKind::DFS)
.Case("bfs", ExplorationStrategyKind::BFS)		.Case("bfs", ExplorationStrategyKind::BFS)
▲ Show 20 Lines • Show All 104 Lines • ▼ Show 20 Lines
bool AnalyzerOptions::getBooleanOption(Optional<bool> &V, StringRef Name,		bool AnalyzerOptions::getBooleanOption(Optional<bool> &V, StringRef Name,
bool DefaultVal, const CheckerBase *C,		bool DefaultVal, const CheckerBase *C,
bool SearchInParents) {		bool SearchInParents) {
if (!V.hasValue())		if (!V.hasValue())
V = getBooleanOption(Name, DefaultVal, C, SearchInParents);		V = getBooleanOption(Name, DefaultVal, C, SearchInParents);
return V.getValue();		return V.getValue();
}		}

bool AnalyzerOptions::includeTemporaryDtorsInCFG() {
return getBooleanOption(IncludeTemporaryDtorsInCFG,
"cfg-temporary-dtors",
/* Default = */ true);
}

bool AnalyzerOptions::includeImplicitDtorsInCFG() {
return getBooleanOption(IncludeImplicitDtorsInCFG,
"cfg-implicit-dtors",
/* Default = */ true);
}

bool AnalyzerOptions::includeLifetimeInCFG() {
return getBooleanOption(IncludeLifetimeInCFG, "cfg-lifetime",
/* Default = */ false);
}

bool AnalyzerOptions::includeLoopExitInCFG() {
return getBooleanOption(IncludeLoopExitInCFG, "cfg-loopexit",
/* Default = */ false);
}

bool AnalyzerOptions::includeRichConstructorsInCFG() {
return getBooleanOption(IncludeRichConstructorsInCFG,
"cfg-rich-constructors",
/* Default = */ true);
}

bool AnalyzerOptions::includeScopesInCFG() {
return getBooleanOption(IncludeScopesInCFG,
"cfg-scopes",
/* Default = */ false);
}

bool AnalyzerOptions::mayInlineCXXStandardLibrary() {
return getBooleanOption(InlineCXXStandardLibrary,
"c++-stdlib-inlining",
/Default=/true);
}

bool AnalyzerOptions::mayInlineTemplateFunctions() {
return getBooleanOption(InlineTemplateFunctions,
"c++-template-inlining",
/Default=/true);
}

bool AnalyzerOptions::mayInlineCXXAllocator() {
return getBooleanOption(InlineCXXAllocator,
"c++-allocator-inlining",
/Default=/true);
}

bool AnalyzerOptions::mayInlineCXXContainerMethods() {
return getBooleanOption(InlineCXXContainerMethods,
"c++-container-inlining",
/Default=/false);
}

bool AnalyzerOptions::mayInlineCXXSharedPtrDtor() {
return getBooleanOption(InlineCXXSharedPtrDtor,
"c++-shared_ptr-inlining",
/Default=/false);
}

bool AnalyzerOptions::mayInlineCXXTemporaryDtors() {
return getBooleanOption(InlineCXXTemporaryDtors,
"c++-temp-dtor-inlining",
/Default=/true);
}

bool AnalyzerOptions::mayInlineObjCMethod() {
return getBooleanOption(ObjCInliningMode,
"objc-inlining",
/* Default = */ true);
}

bool AnalyzerOptions::shouldSuppressNullReturnPaths() {
return getBooleanOption(SuppressNullReturnPaths,
"suppress-null-return-paths",
/* Default = */ true);
}

bool AnalyzerOptions::shouldAvoidSuppressingNullArgumentPaths() {
return getBooleanOption(AvoidSuppressingNullArgumentPaths,
"avoid-suppressing-null-argument-paths",
/* Default = */ false);
}

bool AnalyzerOptions::shouldSuppressInlinedDefensiveChecks() {
return getBooleanOption(SuppressInlinedDefensiveChecks,
"suppress-inlined-defensive-checks",
/* Default = */ true);
}

bool AnalyzerOptions::shouldSuppressFromCXXStandardLibrary() {
return getBooleanOption(SuppressFromCXXStandardLibrary,
"suppress-c++-stdlib",
/* Default = */ true);
}

bool AnalyzerOptions::shouldCrosscheckWithZ3() {
return getBooleanOption(CrosscheckWithZ3,
"crosscheck-with-z3",
/* Default = */ false);
}

bool AnalyzerOptions::shouldReportIssuesInMainSourceFile() {
return getBooleanOption(ReportIssuesInMainSourceFile,
"report-in-main-source-file",
/* Default = */ false);
}


bool AnalyzerOptions::shouldWriteStableReportFilename() {
return getBooleanOption(StableReportFilename,
"stable-report-filename",
/* Default = */ false);
}

bool AnalyzerOptions::shouldSerializeStats() {
return getBooleanOption(SerializeStats,
"serialize-stats",
/* Default = */ false);
}

bool AnalyzerOptions::shouldElideConstructors() {
return getBooleanOption(ElideConstructors,
"elide-constructors",
/* Default = */ true);
}

int AnalyzerOptions::getOptionAsInteger(StringRef Name, int DefaultVal,		int AnalyzerOptions::getOptionAsInteger(StringRef Name, int DefaultVal,
const CheckerBase *C,		const CheckerBase *C,
bool SearchInParents) {		bool SearchInParents) {
SmallString<10> StrBuf;		SmallString<10> StrBuf;
llvm::raw_svector_ostream OS(StrBuf);		llvm::raw_svector_ostream OS(StrBuf);
OS << DefaultVal;		OS << DefaultVal;

StringRef V = C ? getCheckerOption(C->getTagDescription(), Name, OS.str(),		StringRef V = C ? getCheckerOption(C->getTagDescription(), Name, OS.str(),
Show All 19 Lines
StringRef AnalyzerOptions::getOptionAsString(StringRef Name,		StringRef AnalyzerOptions::getOptionAsString(StringRef Name,
StringRef DefaultVal,		StringRef DefaultVal,
const CheckerBase *C,		const CheckerBase *C,
bool SearchInParents) {		bool SearchInParents) {
return C ? getCheckerOption(C->getTagDescription(), Name, DefaultVal,		return C ? getCheckerOption(C->getTagDescription(), Name, DefaultVal,
SearchInParents)		SearchInParents)
: StringRef(		: StringRef(
Config.insert(std::make_pair(Name, DefaultVal)).first->second);		Config.insert(std::make_pair(Name, DefaultVal)).first->second);

}		}

StringRef AnalyzerOptions::getOptionAsString(Optional<StringRef> &V,		StringRef AnalyzerOptions::getOptionAsString(Optional<StringRef> &V,
StringRef Name,		StringRef Name,
StringRef DefaultVal,		StringRef DefaultVal,
const ento::CheckerBase *C,		const ento::CheckerBase *C,
bool SearchInParents) {		bool SearchInParents) {
if (!V.hasValue())		if (!V.hasValue())
V = getOptionAsString(Name, DefaultVal, C, SearchInParents);		V = getOptionAsString(Name, DefaultVal, C, SearchInParents);
return V.getValue();		return V.getValue();
}		}

unsigned AnalyzerOptions::getAlwaysInlineSize() {		template <typename T>
if (!AlwaysInlineSize.hasValue())		T AnalyzerOptions::getDefaultValForUserMode(T ShallowVal, T DeepVal) {
AlwaysInlineSize = getOptionAsInteger("ipa-always-inline-size", 3);
return AlwaysInlineSize.getValue();
}

unsigned AnalyzerOptions::getMaxInlinableSize() {
if (!MaxInlinableSize.hasValue()) {
int DefaultValue = 0;
UserModeKind HighLevelMode = getUserMode();		UserModeKind HighLevelMode = getUserMode();
switch (HighLevelMode) {		switch (HighLevelMode) {
case UMK_Shallow:		case UMK_Shallow:
DefaultValue = 4;		return ShallowVal;
break;
case UMK_Deep:		case UMK_Deep:
DefaultValue = 100;		return DeepVal;
break;
}		}

MaxInlinableSize = getOptionAsInteger("max-inlinable-size", DefaultValue);		return {};
}
return MaxInlinableSize.getValue();
}		}

unsigned AnalyzerOptions::getGraphTrimInterval() {		static bool getOption(AnalyzerOptions &A, Optional<bool> &V, StringRef Name,
if (!GraphTrimInterval.hasValue())		bool DefaultVal) {
GraphTrimInterval = getOptionAsInteger("graph-trim-interval", 1000);		return A.getBooleanOption(V, Name, DefaultVal);
return GraphTrimInterval.getValue();
}		}

unsigned AnalyzerOptions::getMaxSymbolComplexity() {		static unsigned getOption(AnalyzerOptions &A, Optional<unsigned> &V,
if (!MaxSymbolComplexity.hasValue())		StringRef Name, unsigned DefaultVal) {
MaxSymbolComplexity = getOptionAsInteger("max-symbol-complexity", 35);		return A.getOptionAsUInt(V, Name, DefaultVal);
return MaxSymbolComplexity.getValue();
}		}

unsigned AnalyzerOptions::getMaxTimesInlineLarge() {		static StringRef getOption(AnalyzerOptions &A, Optional<StringRef> &V,
if (!MaxTimesInlineLarge.hasValue())		StringRef Name, StringRef DefaultVal) {
MaxTimesInlineLarge = getOptionAsInteger("max-times-inline-large", 32);		return A.getOptionAsString(V, Name, DefaultVal);
return MaxTimesInlineLarge.getValue();
}		}

unsigned AnalyzerOptions::getMinCFGSizeTreatFunctionsAsLarge() {		#define ANALYZER_OPTION_WITH_FN(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL, \
if (!MinCFGSizeTreatFunctionsAsLarge.hasValue())		CREATE_FN) \
MinCFGSizeTreatFunctionsAsLarge = getOptionAsInteger(		TYPE AnalyzerOptions::CREATE_FN() { \
"min-cfg-size-treat-functions-as-large", 14);		return getOption(*this, NAME, CMDFLAG, DEFAULT_VAL); \
return MinCFGSizeTreatFunctionsAsLarge.getValue();
}		}
		#include "clang/StaticAnalyzer/Core/AnalyzerOptions.def"
		#undef ANALYZER_OPTION

unsigned AnalyzerOptions::getMaxNodesPerTopLevelFunction() {
if (!MaxNodesPerTopLevelFunction.hasValue()) {
int DefaultValue = 0;
UserModeKind HighLevelMode = getUserMode();
switch (HighLevelMode) {
case UMK_Shallow:
DefaultValue = 75000;
break;
case UMK_Deep:
DefaultValue = 225000;
break;
}
MaxNodesPerTopLevelFunction = getOptionAsInteger("max-nodes", DefaultValue);
}
return MaxNodesPerTopLevelFunction.getValue();
}

bool AnalyzerOptions::shouldSynthesizeBodies() {
return getBooleanOption("faux-bodies", true);
}

bool AnalyzerOptions::shouldPrunePaths() {
return getBooleanOption("prune-paths", true);
}

bool AnalyzerOptions::shouldConditionalizeStaticInitializers() {
return getBooleanOption("cfg-conditional-static-initializers", true);
}

bool AnalyzerOptions::shouldInlineLambdas() {
if (!InlineLambdas.hasValue())
InlineLambdas = getBooleanOption("inline-lambdas", /Default=/true);
return InlineLambdas.getValue();
}

bool AnalyzerOptions::shouldWidenLoops() {
if (!WidenLoops.hasValue())
WidenLoops = getBooleanOption("widen-loops", /Default=/false);
return WidenLoops.getValue();
}

bool AnalyzerOptions::shouldUnrollLoops() {
if (!UnrollLoops.hasValue())
UnrollLoops = getBooleanOption("unroll-loops", /Default=/false);
return UnrollLoops.getValue();
}


bool AnalyzerOptions::shouldDisplayNotesAsEvents() {
if (!DisplayNotesAsEvents.hasValue())
DisplayNotesAsEvents =
getBooleanOption("notes-as-events", /Default=/false);
return DisplayNotesAsEvents.getValue();
}

bool AnalyzerOptions::shouldAggressivelySimplifyBinaryOperation() {
if (!AggressiveBinaryOperationSimplification.hasValue())
AggressiveBinaryOperationSimplification =
getBooleanOption("aggressive-binary-operation-simplification",
/Default=/false);
return AggressiveBinaryOperationSimplification.getValue();
}

bool AnalyzerOptions::shouldEagerlyAssume() {
if (!EagerlyAssumeBinOpBifurcation.hasValue())
EagerlyAssumeBinOpBifurcation =
getBooleanOption("eagerly-assume", true);
return EagerlyAssumeBinOpBifurcation.getValue();
}

StringRef AnalyzerOptions::getCTUDir() {		StringRef AnalyzerOptions::getCTUDir() {
if (!CTUDir.hasValue()) {		if (!CTUDir.hasValue()) {
CTUDir = getOptionAsString("ctu-dir", "");		CTUDir = getOptionAsString("ctu-dir", "");
if (!llvm::sys::fs::is_directory(*CTUDir))		if (!llvm::sys::fs::is_directory(*CTUDir))
CTUDir = "";		CTUDir = "";
}		}
return CTUDir.getValue();		return CTUDir.getValue();
}		}

bool AnalyzerOptions::naiveCTUEnabled() {
if (!NaiveCTU.hasValue()) {
NaiveCTU = getBooleanOption("experimental-enable-naive-ctu-analysis",
/Default=/false);
}
return NaiveCTU.getValue();
}

StringRef AnalyzerOptions::getCTUIndexName() {
if (!CTUIndexName.hasValue())
CTUIndexName = getOptionAsString("ctu-index-name", "externalFnMap.txt");
return CTUIndexName.getValue();
}

StringRef AnalyzerOptions::getModelPath() {
if (!ModelPath.hasValue())
ModelPath = getOptionAsString("model-path", "");
return ModelPath.getValue();
}

lib/StaticAnalyzer/Core/CoreEngine.cpp

	Show First 20 Lines • Show All 50 Lines • ▼ Show 20 Lines

	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//
	// Core analysis engine.			// Core analysis engine.
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	static std::unique_ptr<WorkList> generateWorkList(AnalyzerOptions &Opts,			static std::unique_ptr<WorkList> generateWorkList(AnalyzerOptions &Opts,
	SubEngine &subengine) {			SubEngine &subengine) {
	switch (Opts.getExplorationStrategy()) {			switch (Opts.getExplorationStrategy()) {
	case AnalyzerOptions::ExplorationStrategyKind::DFS:			case ExplorationStrategyKind::DFS:
	return WorkList::makeDFS();			return WorkList::makeDFS();
	case AnalyzerOptions::ExplorationStrategyKind::BFS:			case ExplorationStrategyKind::BFS:
	return WorkList::makeBFS();			return WorkList::makeBFS();
	case AnalyzerOptions::ExplorationStrategyKind::BFSBlockDFSContents:			case ExplorationStrategyKind::BFSBlockDFSContents:
	return WorkList::makeBFSBlockDFSContents();			return WorkList::makeBFSBlockDFSContents();
	case AnalyzerOptions::ExplorationStrategyKind::UnexploredFirst:			case ExplorationStrategyKind::UnexploredFirst:
	return WorkList::makeUnexploredFirst();			return WorkList::makeUnexploredFirst();
	case AnalyzerOptions::ExplorationStrategyKind::UnexploredFirstQueue:			case ExplorationStrategyKind::UnexploredFirstQueue:
	return WorkList::makeUnexploredFirstPriorityQueue();			return WorkList::makeUnexploredFirstPriorityQueue();
	case AnalyzerOptions::ExplorationStrategyKind::UnexploredFirstLocationQueue:			case ExplorationStrategyKind::UnexploredFirstLocationQueue:
	return WorkList::makeUnexploredFirstPriorityLocationQueue();			return WorkList::makeUnexploredFirstPriorityLocationQueue();
	}			}
	}			}

	CoreEngine::CoreEngine(SubEngine &subengine, FunctionSummariesTy *FS,			CoreEngine::CoreEngine(SubEngine &subengine, FunctionSummariesTy *FS,
	AnalyzerOptions &Opts)			AnalyzerOptions &Opts)
	: SubEng(subengine), WList(generateWorkList(Opts, subengine)),			: SubEng(subengine), WList(generateWorkList(Opts, subengine)),
	BCounterFactory(G.getAllocator()), FunctionSummaries(FS) {}			BCounterFactory(G.getAllocator()), FunctionSummaries(FS) {}
	▲ Show 20 Lines • Show All 577 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

[analyzer][NFC] Collect all -analyzer-config options in a .def file
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 169688

include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

include/clang/StaticAnalyzer/Core/AnalyzerOptions.def

lib/StaticAnalyzer/Core/AnalyzerOptions.cpp

lib/StaticAnalyzer/Core/CoreEngine.cpp

This is an archive of the discontinued LLVM Phabricator instance.

[analyzer][NFC] Collect all -analyzer-config options in a .def fileClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 169688

include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

include/clang/StaticAnalyzer/Core/AnalyzerOptions.def

lib/StaticAnalyzer/Core/AnalyzerOptions.cpp

lib/StaticAnalyzer/Core/CoreEngine.cpp

[analyzer][NFC] Collect all -analyzer-config options in a .def file
ClosedPublic