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 <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
  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, AUTOCREAT) PD_##NAME,
  56 #include "clang/StaticAnalyzer/Core/Analyses.def"
  57 NUM_ANALYSIS_DIAG_CLIENTS
  58 };
  59
  60 /// AnalysisPurgeModes - Set of available strategies for dead symbol removal.
  61 enum AnalysisPurgeMode {
  62 #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) NAME,
  63 #include "clang/StaticAnalyzer/Core/Analyses.def"
  64 NumPurgeModes
  65 };
  66
  67 /// AnalysisIPAMode - Set of inter-procedural modes.
  68 enum AnalysisIPAMode {
  69 #define ANALYSIS_IPA(NAME, CMDFLAG, DESC) NAME,
  70 #include "clang/StaticAnalyzer/Core/Analyses.def"
  71 NumIPAModes
  72 };
  73
  74 /// AnalysisInlineFunctionSelection - Set of inlining function selection heuristics.
  75 enum AnalysisInliningMode {
  76 #define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) NAME,
  77 #include "clang/StaticAnalyzer/Core/Analyses.def"
  78 NumInliningModes
  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.
  86 enum 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
 106 class AnalyzerOptions : public llvm::RefCountedBase<AnalyzerOptions> {
 107 public:
 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 PrintStats : 1;
 153
 154   /// \brief Do not re-analyze paths leading to exhausted nodes with a different
 155   /// strategy. We get better code coverage when retry is enabled.
 156   unsigned NoRetryExhausted : 1;
 157
 158   /// \brief The inlining stack depth limit.
 159   unsigned InlineMaxStackDepth;
 160
 161   /// \brief The mode of function selection used during inlining.
 162   unsigned InlineMaxFunctionSize;
 163
 164   /// \brief The mode of function selection used during inlining.
 165   AnalysisInliningMode InliningMode;
 166
 167 private:
 168   /// Controls which C++ member functions will be considered for inlining.
 169   CXXInlineableMemberKind CXXMemberInliningMode;
 170
 171   /// \sa includeTemporaryDtorsInCFG
 172   llvm::Optional<bool> IncludeTemporaryDtorsInCFG;
 173
 174   /// \sa mayInlineCXXStandardLibrary
 175   llvm::Optional<bool> InlineCXXStandardLibrary;
 176
 177   /// \sa mayInlineTemplateFunctions
 178   llvm::Optional<bool> InlineTemplateFunctions;
 179
 180   /// \sa mayInlineObjCMethod
 181   llvm::Optional<bool> ObjCInliningMode;
 182
 183   // Cache of the "ipa-always-inline-size" setting.
 184   // \sa getAlwaysInlineSize
 185   llvm::Optional<unsigned> AlwaysInlineSize;
 186
 187   /// \sa shouldPruneNullReturnPaths
 188   llvm::Optional<bool> PruneNullReturnPaths;
 189
 190   /// \sa shouldAvoidSuppressingNullArgumentPaths
 191   llvm::Optional<bool> AvoidSuppressingNullArgumentPaths;
 192
 193   /// \sa getGraphTrimInterval
 194   llvm::Optional<unsigned> GraphTrimInterval;
 195
 196   /// Interprets an option's string value as a boolean.
 197   ///
 198   /// Accepts the strings "true" and "false".
 199   /// If an option value is not provided, returns the given \p DefaultVal.
 200   bool getBooleanOption(StringRef Name, bool DefaultVal);
 201
 202   /// Variant that accepts a Optional value to cache the result.
 203   bool getBooleanOption(llvm::Optional<bool> &V, StringRef Name,
 204                         bool DefaultVal);
 205
 206   /// Interprets an option's string value as an integer value.
 207   int getOptionAsInteger(llvm::StringRef Name, int DefaultVal);
 208
 209 public:
 210   /// Returns the option controlling which C++ member functions will be
 211   /// considered for inlining.
 212   ///
 213   /// This is controlled by the 'c++-inlining' config option.
 214   ///
 215   /// \sa CXXMemberInliningMode
 216   bool mayInlineCXXMemberFunction(CXXInlineableMemberKind K);
 217
 218   /// Returns true if ObjectiveC inlining is enabled, false otherwise.
 219   bool mayInlineObjCMethod();
 220
 221   /// Returns whether or not the destructors for C++ temporary objects should
 222   /// be included in the CFG.
 223   ///
 224   /// This is controlled by the 'cfg-temporary-dtors' config option, which
 225   /// accepts the values "true" and "false".
 226   bool includeTemporaryDtorsInCFG();
 227
 228   /// Returns whether or not C++ standard library functions may be considered
 229   /// for inlining.
 230   ///
 231   /// This is controlled by the 'c++-stdlib-inlining' config option, which
 232   /// accepts the values "true" and "false".
 233   bool mayInlineCXXStandardLibrary();
 234
 235   /// Returns whether or not templated functions may be considered for inlining.
 236   ///
 237   /// This is controlled by the 'c++-template-inlining' config option, which
 238   /// accepts the values "true" and "false".
 239   bool mayInlineTemplateFunctions();
 240
 241   /// Returns whether or not paths that go through null returns should be
 242   /// suppressed.
 243   ///
 244   /// This is a heuristic for avoiding bug reports with paths that go through
 245   /// inlined functions that are more defensive than their callers.
 246   ///
 247   /// This is controlled by the 'suppress-null-return-paths' config option,
 248   /// which accepts the values "true" and "false".
 249   bool shouldPruneNullReturnPaths();
 250
 251   /// Returns whether a bug report should \em not be suppressed if its path
 252   /// includes a call with a null argument, even if that call has a null return.
 253   ///
 254   /// This option has no effect when #shouldPruneNullReturnPaths() is false.
 255   ///
 256   /// This is a counter-heuristic to avoid false negatives.
 257   ///
 258   /// This is controlled by the 'avoid-suppressing-null-argument-paths' config
 259   /// option, which accepts the values "true" and "false".
 260   bool shouldAvoidSuppressingNullArgumentPaths();
 261
 262   // Returns the size of the functions (in basic blocks), which should be
 263   // considered to be small enough to always inline.
 264   //
 265   // This is controlled by "ipa-always-inline-size" analyzer-config option.
 266   unsigned getAlwaysInlineSize();
 267
 268   /// Returns true if the analyzer engine should synthesize fake bodies
 269   /// for well-known functions.
 270   bool shouldSynthesizeBodies();
 271
 272   /// Returns how often nodes in the ExplodedGraph should be recycled to save
 273   /// memory.
 274   ///
 275   /// This is controlled by the 'graph-trim-interval' config option. To disable
 276   /// node reclamation, set the option to "0".
 277   unsigned getGraphTrimInterval();
 278
 279 public:
 280   AnalyzerOptions() : CXXMemberInliningMode() {
 281     AnalysisStoreOpt = RegionStoreModel;
 282     AnalysisConstraintsOpt = RangeConstraintsModel;
 283     AnalysisDiagOpt = PD_HTML;
 284     AnalysisPurgeOpt = PurgeStmt;
 285     IPAMode = DynamicDispatchBifurcate;
 286     ShowCheckerHelp = 0;
 287     AnalyzeAll = 0;
 288     AnalyzerDisplayProgress = 0;
 289     AnalyzeNestedBlocks = 0;
 290     eagerlyAssumeBinOpBifurcation = 0;
 291     TrimGraph = 0;
 292     visualizeExplodedGraphWithGraphViz = 0;
 293     visualizeExplodedGraphWithUbiGraph = 0;
 294     UnoptimizedCFG = 0;
 295     PrintStats = 0;
 296     NoRetryExhausted = 0;
 297     // Cap the stack depth at 4 calls (5 stack frames, base + 4 calls).
 298     InlineMaxStackDepth = 5;
 299     InlineMaxFunctionSize = 200;
 300     InliningMode = NoRedundancy;
 301   }
 302 };
 303
 304 typedef llvm::IntrusiveRefCntPtr<AnalyzerOptions> AnalyzerOptionsRef;
 305
 306 }
 307
 308 #endif