AnalyzerOptions.h revision 48d05e6d776f4b68f3db4016eb5680ac041c2b7d
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 /// \sa shouldPruneNullReturnPaths 189 llvm::Optional<bool> PruneNullReturnPaths; 190 191 /// Interprets an option's string value as a boolean. 192 /// 193 /// Accepts the strings "true" and "false". 194 /// If an option value is not provided, returns the given \p DefaultVal. 195 bool getBooleanOption(StringRef Name, bool DefaultVal); 196 197 /// Variant that accepts a Optional value to cache the result. 198 bool getBooleanOption(llvm::Optional<bool> &V, StringRef Name, 199 bool DefaultVal); 200 201 /// Interprets an option's string value as an integer value. 202 int getOptionAsInteger(llvm::StringRef Name, int DefaultVal); 203 204public: 205 /// Returns the option controlling which C++ member functions will be 206 /// considered for inlining. 207 /// 208 /// This is controlled by the 'c++-inlining' config option. 209 /// 210 /// \sa CXXMemberInliningMode 211 bool mayInlineCXXMemberFunction(CXXInlineableMemberKind K); 212 213 /// Returns true if ObjectiveC inlining is enabled, false otherwise. 214 bool mayInlineObjCMethod(); 215 216 /// Returns whether or not the destructors for C++ temporary objects should 217 /// be included in the CFG. 218 /// 219 /// This is controlled by the 'cfg-temporary-dtors' config option, which 220 /// accepts the values "true" and "false". 221 bool includeTemporaryDtorsInCFG(); 222 223 /// Returns whether or not C++ standard library functions may be considered 224 /// for inlining. 225 /// 226 /// This is controlled by the 'c++-stdlib-inlining' config option, which 227 /// accepts the values "true" and "false". 228 bool mayInlineCXXStandardLibrary(); 229 230 /// Returns whether or not templated functions may be considered for inlining. 231 /// 232 /// This is controlled by the 'c++-template-inlining' config option, which 233 /// accepts the values "true" and "false". 234 bool mayInlineTemplateFunctions(); 235 236 /// Returns whether or not paths that go through null returns should be 237 /// suppressed. 238 /// 239 /// This is a heuristic for avoiding bug reports with paths that go through 240 /// inlined functions that are more defensive than their callers. 241 /// 242 /// This is controlled by the 'suppress-null-return-paths' config option, 243 /// which accepts the values "true" and "false". 244 bool shouldPruneNullReturnPaths(); 245 246 // Returns the size of the functions (in basic blocks), which should be 247 // considered to be small enough to always inline. 248 // 249 // This is controlled by "ipa-always-inline-size" analyzer-config option. 250 unsigned getAlwaysInlineSize(); 251 252 /// Returns true if the analyzer engine should synthesize fake bodies 253 /// for well-known functions. 254 bool shouldSynthesizeBodies(); 255 256public: 257 AnalyzerOptions() : CXXMemberInliningMode() { 258 AnalysisStoreOpt = RegionStoreModel; 259 AnalysisConstraintsOpt = RangeConstraintsModel; 260 AnalysisDiagOpt = PD_HTML; 261 AnalysisPurgeOpt = PurgeStmt; 262 IPAMode = DynamicDispatchBifurcate; 263 ShowCheckerHelp = 0; 264 AnalyzeAll = 0; 265 AnalyzerDisplayProgress = 0; 266 AnalyzeNestedBlocks = 0; 267 eagerlyAssumeBinOpBifurcation = 0; 268 TrimGraph = 0; 269 visualizeExplodedGraphWithGraphViz = 0; 270 visualizeExplodedGraphWithUbiGraph = 0; 271 UnoptimizedCFG = 0; 272 eagerlyTrimExplodedGraph = 0; 273 PrintStats = 0; 274 NoRetryExhausted = 0; 275 // Cap the stack depth at 4 calls (5 stack frames, base + 4 calls). 276 InlineMaxStackDepth = 5; 277 InlineMaxFunctionSize = 200; 278 InliningMode = NoRedundancy; 279 } 280}; 281 282typedef llvm::IntrusiveRefCntPtr<AnalyzerOptions> AnalyzerOptionsRef; 283 284} 285 286#endif 287