AnalyzerOptions.h revision 57330eed3fbe530cb05996e4a346cc5fc217c0d9
1//===--- AnalyzerOptions.h - Analysis Engine Options ------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This header defines various options for the static analyzer that are set 11// by the frontend and are consulted throughout the analyzer. 12// 13//===----------------------------------------------------------------------===// 14 15#ifndef LLVM_CLANG_ANALYZEROPTIONS_H 16#define LLVM_CLANG_ANALYZEROPTIONS_H 17 18#include <string> 19#include <vector> 20#include "clang/Basic/LLVM.h" 21#include "llvm/ADT/Optional.h" 22#include "llvm/ADT/IntrusiveRefCntPtr.h" 23#include "llvm/ADT/StringMap.h" 24 25namespace clang { 26class ASTConsumer; 27class DiagnosticsEngine; 28class Preprocessor; 29class LangOptions; 30 31/// Analysis - Set of available source code analyses. 32enum Analyses { 33#define ANALYSIS(NAME, CMDFLAG, DESC, SCOPE) NAME, 34#include "clang/StaticAnalyzer/Core/Analyses.def" 35NumAnalyses 36}; 37 38/// AnalysisStores - Set of available analysis store models. 39enum AnalysisStores { 40#define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) NAME##Model, 41#include "clang/StaticAnalyzer/Core/Analyses.def" 42NumStores 43}; 44 45/// AnalysisConstraints - Set of available constraint models. 46enum AnalysisConstraints { 47#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) NAME##Model, 48#include "clang/StaticAnalyzer/Core/Analyses.def" 49NumConstraints 50}; 51 52/// AnalysisDiagClients - Set of available diagnostic clients for rendering 53/// analysis results. 54enum AnalysisDiagClients { 55#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREAT) PD_##NAME, 56#include "clang/StaticAnalyzer/Core/Analyses.def" 57NUM_ANALYSIS_DIAG_CLIENTS 58}; 59 60/// AnalysisPurgeModes - Set of available strategies for dead symbol removal. 61enum AnalysisPurgeMode { 62#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) NAME, 63#include "clang/StaticAnalyzer/Core/Analyses.def" 64NumPurgeModes 65}; 66 67/// AnalysisIPAMode - Set of inter-procedural modes. 68enum AnalysisIPAMode { 69#define ANALYSIS_IPA(NAME, CMDFLAG, DESC) NAME, 70#include "clang/StaticAnalyzer/Core/Analyses.def" 71NumIPAModes 72}; 73 74/// AnalysisInlineFunctionSelection - Set of inlining function selection heuristics. 75enum AnalysisInliningMode { 76#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) NAME, 77#include "clang/StaticAnalyzer/Core/Analyses.def" 78NumInliningModes 79}; 80 81/// \brief Describes the different kinds of C++ member functions which can be 82/// considered for inlining by the analyzer. 83/// 84/// These options are cumulative; enabling one kind of member function will 85/// enable all kinds with lower enum values. 86enum CXXInlineableMemberKind { 87 // Uninitialized = 0, 88 89 /// A dummy mode in which no C++ inlining is enabled. 90 CIMK_None = 1, 91 92 /// Refers to regular member function and operator calls. 93 CIMK_MemberFunctions, 94 95 /// Refers to constructors (implicit or explicit). 96 /// 97 /// Note that a constructor will not be inlined if the corresponding 98 /// destructor is non-trivial. 99 CIMK_Constructors, 100 101 /// Refers to destructors (implicit or explicit). 102 CIMK_Destructors 103}; 104 105 106class AnalyzerOptions : public llvm::RefCountedBase<AnalyzerOptions> { 107public: 108 typedef llvm::StringMap<std::string> ConfigTable; 109 110 /// \brief Pair of checker name and enable/disable. 111 std::vector<std::pair<std::string, bool> > CheckersControlList; 112 113 /// \brief A key-value table of use-specified configuration values. 114 ConfigTable Config; 115 AnalysisStores AnalysisStoreOpt; 116 AnalysisConstraints AnalysisConstraintsOpt; 117 AnalysisDiagClients AnalysisDiagOpt; 118 AnalysisPurgeMode AnalysisPurgeOpt; 119 120 // \brief The interprocedural analysis mode. 121 AnalysisIPAMode IPAMode; 122 123 std::string AnalyzeSpecificFunction; 124 125 /// \brief The maximum number of exploded nodes the analyzer will generate. 126 unsigned MaxNodes; 127 128 /// \brief The maximum number of times the analyzer visits a block. 129 unsigned maxBlockVisitOnPath; 130 131 132 unsigned ShowCheckerHelp : 1; 133 unsigned AnalyzeAll : 1; 134 unsigned AnalyzerDisplayProgress : 1; 135 unsigned AnalyzeNestedBlocks : 1; 136 137 /// \brief The flag regulates if we should eagerly assume evaluations of 138 /// conditionals, thus, bifurcating the path. 139 /// 140 /// This flag indicates how the engine should handle expressions such as: 'x = 141 /// (y != 0)'. When this flag is true then the subexpression 'y != 0' will be 142 /// eagerly assumed to be true or false, thus evaluating it to the integers 0 143 /// or 1 respectively. The upside is that this can increase analysis 144 /// precision until we have a better way to lazily evaluate such logic. The 145 /// downside is that it eagerly bifurcates paths. 146 unsigned eagerlyAssumeBinOpBifurcation : 1; 147 148 unsigned TrimGraph : 1; 149 unsigned visualizeExplodedGraphWithGraphViz : 1; 150 unsigned visualizeExplodedGraphWithUbiGraph : 1; 151 unsigned UnoptimizedCFG : 1; 152 unsigned eagerlyTrimExplodedGraph : 1; 153 unsigned PrintStats : 1; 154 155 /// \brief Do not re-analyze paths leading to exhausted nodes with a different 156 /// strategy. We get better code coverage when retry is enabled. 157 unsigned NoRetryExhausted : 1; 158 159 /// \brief The inlining stack depth limit. 160 unsigned InlineMaxStackDepth; 161 162 /// \brief The mode of function selection used during inlining. 163 unsigned InlineMaxFunctionSize; 164 165 /// \brief The mode of function selection used during inlining. 166 AnalysisInliningMode InliningMode; 167 168private: 169 /// Controls which C++ member functions will be considered for inlining. 170 CXXInlineableMemberKind CXXMemberInliningMode; 171 172 /// \sa includeTemporaryDtorsInCFG 173 llvm::Optional<bool> IncludeTemporaryDtorsInCFG; 174 175 /// \sa mayInlineCXXStandardLibrary 176 llvm::Optional<bool> InlineCXXStandardLibrary; 177 178 /// \sa mayInlineTemplateFunctions 179 llvm::Optional<bool> InlineTemplateFunctions; 180 181 /// \sa mayInlineObjCMethod 182 llvm::Optional<bool> ObjCInliningMode; 183 184 // Cache of the "ipa-always-inline-size" setting. 185 // \sa getAlwaysInlineSize 186 llvm::Optional<unsigned> AlwaysInlineSize; 187 188 /// Interprets an option's string value as a boolean. 189 /// 190 /// Accepts the strings "true" and "false". 191 /// If an option value is not provided, returns the given \p DefaultVal. 192 bool getBooleanOption(StringRef Name, bool DefaultVal) const; 193 194 /// Interprets an option's string value as an integer value. 195 int getOptionAsInteger(llvm::StringRef Name, int DefaultVal) const; 196 197public: 198 /// Returns the option controlling which C++ member functions will be 199 /// considered for inlining. 200 /// 201 /// This is controlled by the 'c++-inlining' config option. 202 /// 203 /// \sa CXXMemberInliningMode 204 bool mayInlineCXXMemberFunction(CXXInlineableMemberKind K) const; 205 206 /// Returns true if ObjectiveC inlining is enabled, false otherwise. 207 bool mayInlineObjCMethod() const; 208 209 /// Returns whether or not the destructors for C++ temporary objects should 210 /// be included in the CFG. 211 /// 212 /// This is controlled by the 'cfg-temporary-dtors' config option, which 213 /// accepts the values "true" and "false". 214 bool includeTemporaryDtorsInCFG() const; 215 216 /// Returns whether or not C++ standard library functions may be considered 217 /// for inlining. 218 /// 219 /// This is controlled by the 'c++-stdlib-inlining' config option, which 220 /// accepts the values "true" and "false". 221 bool mayInlineCXXStandardLibrary() const; 222 223 /// Returns whether or not templated functions may be considered for inlining. 224 /// 225 /// This is controlled by the 'c++-template-inlining' config option, which 226 /// accepts the values "true" and "false". 227 bool mayInlineTemplateFunctions() const; 228 229 // Returns the size of the functions (in basic blocks), which should be 230 // considered to be small enough to always inline. 231 // 232 // This is controlled by "ipa-always-inline-size" analyzer-config option. 233 unsigned getAlwaysInlineSize() const; 234 235public: 236 AnalyzerOptions() : CXXMemberInliningMode() { 237 AnalysisStoreOpt = RegionStoreModel; 238 AnalysisConstraintsOpt = RangeConstraintsModel; 239 AnalysisDiagOpt = PD_HTML; 240 AnalysisPurgeOpt = PurgeStmt; 241 IPAMode = DynamicDispatchBifurcate; 242 ShowCheckerHelp = 0; 243 AnalyzeAll = 0; 244 AnalyzerDisplayProgress = 0; 245 AnalyzeNestedBlocks = 0; 246 eagerlyAssumeBinOpBifurcation = 0; 247 TrimGraph = 0; 248 visualizeExplodedGraphWithGraphViz = 0; 249 visualizeExplodedGraphWithUbiGraph = 0; 250 UnoptimizedCFG = 0; 251 eagerlyTrimExplodedGraph = 0; 252 PrintStats = 0; 253 NoRetryExhausted = 0; 254 // Cap the stack depth at 4 calls (5 stack frames, base + 4 calls). 255 InlineMaxStackDepth = 5; 256 InlineMaxFunctionSize = 200; 257 InliningMode = NoRedundancy; 258 } 259}; 260 261typedef llvm::IntrusiveRefCntPtr<AnalyzerOptions> AnalyzerOptionsRef; 262 263} 264 265#endif 266