contrib/llvm/tools/clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

   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 "clang/Basic/LLVM.h"
  19 #include "llvm/ADT/IntrusiveRefCntPtr.h"
  20 #include "llvm/ADT/Optional.h"
  21 #include "llvm/ADT/StringMap.h"
  22 #include <string>
  23 #include <vector>
  24
  25 namespace clang {
  26 class ASTConsumer;
  27 class DiagnosticsEngine;
  28 class Preprocessor;
  29 class LangOptions;
  30
  31 /// Analysis - Set of available source code analyses.
  32 enum Analyses {
  33 #define ANALYSIS(NAME, CMDFLAG, DESC, SCOPE) NAME,
  34 #include "clang/StaticAnalyzer/Core/Analyses.def"
  35 NumAnalyses
  36 };
  37
  38 /// AnalysisStores - Set of available analysis store models.
  39 enum AnalysisStores {
  40 #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) NAME##Model,
  41 #include "clang/StaticAnalyzer/Core/Analyses.def"
  42 NumStores
  43 };
  44
  45 /// AnalysisConstraints - Set of available constraint models.
  46 enum AnalysisConstraints {
  47 #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) NAME##Model,
  48 #include "clang/StaticAnalyzer/Core/Analyses.def"
  49 NumConstraints
  50 };
  51
  52 /// AnalysisDiagClients - Set of available diagnostic clients for rendering
  53 ///  analysis results.
  54 enum AnalysisDiagClients {
  55 #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) PD_##NAME,
  56 #include "clang/StaticAnalyzer/Core/Analyses.def"
  57 PD_NONE,
  58 NUM_ANALYSIS_DIAG_CLIENTS
  59 };
  60
  61 /// AnalysisPurgeModes - Set of available strategies for dead symbol removal.
  62 enum AnalysisPurgeMode {
  63 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) NAME,
  64 #include "clang/StaticAnalyzer/Core/Analyses.def"
  65 NumPurgeModes
  66 };
  67
  68 /// AnalysisInlineFunctionSelection - Set of inlining function selection heuristics.
  69 enum AnalysisInliningMode {
  70 #define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) NAME,
  71 #include "clang/StaticAnalyzer/Core/Analyses.def"
  72 NumInliningModes
  73 };
  74
  75 /// \brief Describes the different kinds of C++ member functions which can be
  76 /// considered for inlining by the analyzer.
  77 ///
  78 /// These options are cumulative; enabling one kind of member function will
  79 /// enable all kinds with lower enum values.
  80 enum CXXInlineableMemberKind {
  81   // Uninitialized = 0,
  82
  83   /// A dummy mode in which no C++ inlining is enabled.
  84   CIMK_None = 1,
  85
  86   /// Refers to regular member function and operator calls.
  87   CIMK_MemberFunctions,
  88
  89   /// Refers to constructors (implicit or explicit).
  90   ///
  91   /// Note that a constructor will not be inlined if the corresponding
  92   /// destructor is non-trivial.
  93   CIMK_Constructors,
  94
  95   /// Refers to destructors (implicit or explicit).
  96   CIMK_Destructors
  97 };
  98
  99 /// \brief Describes the different modes of inter-procedural analysis.
 100 enum IPAKind {
 101   IPAK_NotSet = 0,
 102
 103   /// Perform only intra-procedural analysis.
 104   IPAK_None = 1,
 105
 106   /// Inline C functions and blocks when their definitions are available.
 107   IPAK_BasicInlining = 2,
 108
 109   /// Inline callees(C, C++, ObjC) when their definitions are available.
 110   IPAK_Inlining = 3,
 111
 112   /// Enable inlining of dynamically dispatched methods.
 113   IPAK_DynamicDispatch = 4,
 114
 115   /// Enable inlining of dynamically dispatched methods, bifurcate paths when
 116   /// exact type info is unavailable.
 117   IPAK_DynamicDispatchBifurcate = 5
 118 };
 119
 120 class AnalyzerOptions : public RefCountedBase<AnalyzerOptions> {
 121 public:
 122   typedef llvm::StringMap<std::string> ConfigTable;
 123
 124   /// \brief Pair of checker name and enable/disable.
 125   std::vector<std::pair<std::string, bool> > CheckersControlList;
 126
 127   /// \brief A key-value table of use-specified configuration values.
 128   ConfigTable Config;
 129   AnalysisStores AnalysisStoreOpt;
 130   AnalysisConstraints AnalysisConstraintsOpt;
 131   AnalysisDiagClients AnalysisDiagOpt;
 132   AnalysisPurgeMode AnalysisPurgeOpt;
 133
 134   std::string AnalyzeSpecificFunction;
 135
 136   /// \brief The maximum number of times the analyzer visits a block.
 137   unsigned maxBlockVisitOnPath;
 138
 139
 140   unsigned ShowCheckerHelp : 1;
 141   unsigned AnalyzeAll : 1;
 142   unsigned AnalyzerDisplayProgress : 1;
 143   unsigned AnalyzeNestedBlocks : 1;
 144
 145   /// \brief The flag regulates if we should eagerly assume evaluations of
 146   /// conditionals, thus, bifurcating the path.
 147   ///
 148   /// This flag indicates how the engine should handle expressions such as: 'x =
 149   /// (y != 0)'.  When this flag is true then the subexpression 'y != 0' will be
 150   /// eagerly assumed to be true or false, thus evaluating it to the integers 0
 151   /// or 1 respectively.  The upside is that this can increase analysis
 152   /// precision until we have a better way to lazily evaluate such logic.  The
 153   /// downside is that it eagerly bifurcates paths.
 154   unsigned eagerlyAssumeBinOpBifurcation : 1;
 155
 156   unsigned TrimGraph : 1;
 157   unsigned visualizeExplodedGraphWithGraphViz : 1;
 158   unsigned visualizeExplodedGraphWithUbiGraph : 1;
 159   unsigned UnoptimizedCFG : 1;
 160   unsigned PrintStats : 1;
 161
 162   /// \brief Do not re-analyze paths leading to exhausted nodes with a different
 163   /// strategy. We get better code coverage when retry is enabled.
 164   unsigned NoRetryExhausted : 1;
 165
 166   /// \brief The inlining stack depth limit.
 167   unsigned InlineMaxStackDepth;
 168
 169   /// \brief The mode of function selection used during inlining.
 170   AnalysisInliningMode InliningMode;
 171
 172 private:
 173   /// \brief Describes the kinds for high-level analyzer mode.
 174   enum UserModeKind {
 175     UMK_NotSet = 0,
 176     /// Perform shallow but fast analyzes.
 177     UMK_Shallow = 1,
 178     /// Perform deep analyzes.
 179     UMK_Deep = 2
 180   };
 181
 182   /// Controls the high-level analyzer mode, which influences the default
 183   /// settings for some of the lower-level config options (such as IPAMode).
 184   /// \sa getUserMode
 185   UserModeKind UserMode;
 186
 187   /// Controls the mode of inter-procedural analysis.
 188   IPAKind IPAMode;
 189
 190   /// Controls which C++ member functions will be considered for inlining.
 191   CXXInlineableMemberKind CXXMemberInliningMode;
 192
 193   /// \sa includeTemporaryDtorsInCFG
 194   Optional<bool> IncludeTemporaryDtorsInCFG;
 195
 196   /// \sa mayInlineCXXStandardLibrary
 197   Optional<bool> InlineCXXStandardLibrary;
 198
 199   /// \sa mayInlineTemplateFunctions
 200   Optional<bool> InlineTemplateFunctions;
 201
 202   /// \sa mayInlineCXXAllocator
 203   Optional<bool> InlineCXXAllocator;
 204
 205   /// \sa mayInlineCXXContainerMethods
 206   Optional<bool> InlineCXXContainerMethods;
 207
 208   /// \sa mayInlineCXXSharedPtrDtor
 209   Optional<bool> InlineCXXSharedPtrDtor;
 210
 211   /// \sa mayInlineObjCMethod
 212   Optional<bool> ObjCInliningMode;
 213
 214   // Cache of the "ipa-always-inline-size" setting.
 215   // \sa getAlwaysInlineSize
 216   Optional<unsigned> AlwaysInlineSize;
 217
 218   /// \sa shouldSuppressNullReturnPaths
 219   Optional<bool> SuppressNullReturnPaths;
 220
 221   // \sa getMaxInlinableSize
 222   Optional<unsigned> MaxInlinableSize;
 223
 224   /// \sa shouldAvoidSuppressingNullArgumentPaths
 225   Optional<bool> AvoidSuppressingNullArgumentPaths;
 226
 227   /// \sa shouldSuppressInlinedDefensiveChecks
 228   Optional<bool> SuppressInlinedDefensiveChecks;
 229
 230   /// \sa shouldSuppressFromCXXStandardLibrary
 231   Optional<bool> SuppressFromCXXStandardLibrary;
 232
 233   /// \sa reportIssuesInMainSourceFile
 234   Optional<bool> ReportIssuesInMainSourceFile;
 235
 236   /// \sa StableReportFilename
 237   Optional<bool> StableReportFilename;
 238
 239   /// \sa getGraphTrimInterval
 240   Optional<unsigned> GraphTrimInterval;
 241
 242   /// \sa getMaxTimesInlineLarge
 243   Optional<unsigned> MaxTimesInlineLarge;
 244
 245   /// \sa getMaxNodesPerTopLevelFunction
 246   Optional<unsigned> MaxNodesPerTopLevelFunction;
 247
 248 public:
 249   /// Interprets an option's string value as a boolean.
 250   ///
 251   /// Accepts the strings "true" and "false".
 252   /// If an option value is not provided, returns the given \p DefaultVal.
 253   bool getBooleanOption(StringRef Name, bool DefaultVal);
 254
 255   /// Variant that accepts a Optional value to cache the result.
 256   bool getBooleanOption(Optional<bool> &V, StringRef Name, bool DefaultVal);
 257
 258   /// Interprets an option's string value as an integer value.
 259   int getOptionAsInteger(StringRef Name, int DefaultVal);
 260
 261   /// \brief Retrieves and sets the UserMode. This is a high-level option,
 262   /// which is used to set other low-level options. It is not accessible
 263   /// outside of AnalyzerOptions.
 264   UserModeKind getUserMode();
 265
 266   /// \brief Returns the inter-procedural analysis mode.
 267   IPAKind getIPAMode();
 268
 269   /// Returns the option controlling which C++ member functions will be
 270   /// considered for inlining.
 271   ///
 272   /// This is controlled by the 'c++-inlining' config option.
 273   ///
 274   /// \sa CXXMemberInliningMode
 275   bool mayInlineCXXMemberFunction(CXXInlineableMemberKind K);
 276
 277   /// Returns true if ObjectiveC inlining is enabled, false otherwise.
 278   bool mayInlineObjCMethod();
 279
 280   /// Returns whether or not the destructors for C++ temporary objects should
 281   /// be included in the CFG.
 282   ///
 283   /// This is controlled by the 'cfg-temporary-dtors' config option, which
 284   /// accepts the values "true" and "false".
 285   bool includeTemporaryDtorsInCFG();
 286
 287   /// Returns whether or not C++ standard library functions may be considered
 288   /// for inlining.
 289   ///
 290   /// This is controlled by the 'c++-stdlib-inlining' config option, which
 291   /// accepts the values "true" and "false".
 292   bool mayInlineCXXStandardLibrary();
 293
 294   /// Returns whether or not templated functions may be considered for inlining.
 295   ///
 296   /// This is controlled by the 'c++-template-inlining' config option, which
 297   /// accepts the values "true" and "false".
 298   bool mayInlineTemplateFunctions();
 299
 300   /// Returns whether or not allocator call may be considered for inlining.
 301   ///
 302   /// This is controlled by the 'c++-allocator-inlining' config option, which
 303   /// accepts the values "true" and "false".
 304   bool mayInlineCXXAllocator();
 305
 306   /// Returns whether or not methods of C++ container objects may be considered
 307   /// for inlining.
 308   ///
 309   /// This is controlled by the 'c++-container-inlining' config option, which
 310   /// accepts the values "true" and "false".
 311   bool mayInlineCXXContainerMethods();
 312
 313   /// Returns whether or not the destructor of C++ 'shared_ptr' may be
 314   /// considered for inlining.
 315   ///
 316   /// This covers std::shared_ptr, std::tr1::shared_ptr, and boost::shared_ptr,
 317   /// and indeed any destructor named "~shared_ptr".
 318   ///
 319   /// This is controlled by the 'c++-shared_ptr-inlining' config option, which
 320   /// accepts the values "true" and "false".
 321   bool mayInlineCXXSharedPtrDtor();
 322
 323   /// Returns whether or not paths that go through null returns should be
 324   /// suppressed.
 325   ///
 326   /// This is a heuristic for avoiding bug reports with paths that go through
 327   /// inlined functions that are more defensive than their callers.
 328   ///
 329   /// This is controlled by the 'suppress-null-return-paths' config option,
 330   /// which accepts the values "true" and "false".
 331   bool shouldSuppressNullReturnPaths();
 332
 333   /// Returns whether a bug report should \em not be suppressed if its path
 334   /// includes a call with a null argument, even if that call has a null return.
 335   ///
 336   /// This option has no effect when #shouldSuppressNullReturnPaths() is false.
 337   ///
 338   /// This is a counter-heuristic to avoid false negatives.
 339   ///
 340   /// This is controlled by the 'avoid-suppressing-null-argument-paths' config
 341   /// option, which accepts the values "true" and "false".
 342   bool shouldAvoidSuppressingNullArgumentPaths();
 343
 344   /// Returns whether or not diagnostics containing inlined defensive NULL
 345   /// checks should be suppressed.
 346   ///
 347   /// This is controlled by the 'suppress-inlined-defensive-checks' config
 348   /// option, which accepts the values "true" and "false".
 349   bool shouldSuppressInlinedDefensiveChecks();
 350
 351   /// Returns whether or not diagnostics reported within the C++ standard
 352   /// library should be suppressed.
 353   ///
 354   /// This is controlled by the 'suppress-c++-stdlib' config option,
 355   /// which accepts the values "true" and "false".
 356   bool shouldSuppressFromCXXStandardLibrary();
 357
 358   /// Returns whether or not the diagnostic report should be always reported
 359   /// in the main source file and not the headers.
 360   ///
 361   /// This is controlled by the 'report-in-main-source-file' config option,
 362   /// which accepts the values "true" and "false".
 363   bool shouldReportIssuesInMainSourceFile();
 364
 365   /// Returns whether or not the report filename should be random or not.
 366   ///
 367   /// This is controlled by the 'stable-report-filename' config option,
 368   /// which accepts the values "true" and "false". Default = false
 369   bool shouldWriteStableReportFilename();
 370
 371   /// Returns whether irrelevant parts of a bug report path should be pruned
 372   /// out of the final output.
 373   ///
 374   /// This is controlled by the 'prune-paths' config option, which accepts the
 375   /// values "true" and "false".
 376   bool shouldPrunePaths();
 377
 378   /// Returns true if 'static' initializers should be in conditional logic
 379   /// in the CFG.
 380   bool shouldConditionalizeStaticInitializers();
 381
 382   // Returns the size of the functions (in basic blocks), which should be
 383   // considered to be small enough to always inline.
 384   //
 385   // This is controlled by "ipa-always-inline-size" analyzer-config option.
 386   unsigned getAlwaysInlineSize();
 387
 388   // Returns the bound on the number of basic blocks in an inlined function
 389   // (50 by default).
 390   //
 391   // This is controlled by "-analyzer-config max-inlinable-size" option.
 392   unsigned getMaxInlinableSize();
 393
 394   /// Returns true if the analyzer engine should synthesize fake bodies
 395   /// for well-known functions.
 396   bool shouldSynthesizeBodies();
 397
 398   /// Returns how often nodes in the ExplodedGraph should be recycled to save
 399   /// memory.
 400   ///
 401   /// This is controlled by the 'graph-trim-interval' config option. To disable
 402   /// node reclamation, set the option to "0".
 403   unsigned getGraphTrimInterval();
 404
 405   /// Returns the maximum times a large function could be inlined.
 406   ///
 407   /// This is controlled by the 'max-times-inline-large' config option.
 408   unsigned getMaxTimesInlineLarge();
 409
 410   /// Returns the maximum number of nodes the analyzer can generate while
 411   /// exploring a top level function (for each exploded graph).
 412   /// 150000 is default; 0 means no limit.
 413   ///
 414   /// This is controlled by the 'max-nodes' config option.
 415   unsigned getMaxNodesPerTopLevelFunction();
 416
 417 public:
 418   AnalyzerOptions() :
 419     AnalysisStoreOpt(RegionStoreModel),
 420     AnalysisConstraintsOpt(RangeConstraintsModel),
 421     AnalysisDiagOpt(PD_HTML),
 422     AnalysisPurgeOpt(PurgeStmt),
 423     ShowCheckerHelp(0),
 424     AnalyzeAll(0),
 425     AnalyzerDisplayProgress(0),
 426     AnalyzeNestedBlocks(0),
 427     eagerlyAssumeBinOpBifurcation(0),
 428     TrimGraph(0),
 429     visualizeExplodedGraphWithGraphViz(0),
 430     visualizeExplodedGraphWithUbiGraph(0),
 431     UnoptimizedCFG(0),
 432     PrintStats(0),
 433     NoRetryExhausted(0),
 434     // Cap the stack depth at 4 calls (5 stack frames, base + 4 calls).
 435     InlineMaxStackDepth(5),
 436     InliningMode(NoRedundancy),
 437     UserMode(UMK_NotSet),
 438     IPAMode(IPAK_NotSet),
 439     CXXMemberInliningMode() {}
 440
 441 };
 442
 443 typedef IntrusiveRefCntPtr<AnalyzerOptions> AnalyzerOptionsRef;
 444
 445 }
 446
 447 #endif