contrib/llvm/tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h

   1 //== AnalysisManager.h - Path sensitive analysis data manager ------*- 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 file defines the AnalysisManager class that manages the data and policy
  11 // for path sensitive analysis.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_GR_ANALYSISMANAGER_H
  16 #define LLVM_CLANG_GR_ANALYSISMANAGER_H
  17
  18 #include "clang/Analysis/AnalysisContext.h"
  19 #include "clang/Frontend/AnalyzerOptions.h"
  20 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
  21 #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
  22 #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
  23
  24 namespace clang {
  25
  26 namespace ento {
  27   class CheckerManager;
  28
  29 class AnalysisManager : public BugReporterData {
  30   virtual void anchor();
  31   AnalysisDeclContextManager AnaCtxMgr;
  32
  33   ASTContext &Ctx;
  34   DiagnosticsEngine &Diags;
  35   const LangOptions &LangOpts;
  36   PathDiagnosticConsumers PathConsumers;
  37
  38   // Configurable components creators.
  39   StoreManagerCreator CreateStoreMgr;
  40   ConstraintManagerCreator CreateConstraintMgr;
  41
  42   CheckerManager *CheckerMgr;
  43
  44   /// \brief The maximum number of exploded nodes the analyzer will generate.
  45   unsigned MaxNodes;
  46
  47   /// \brief The maximum number of times the analyzer visits a block.
  48   unsigned MaxVisit;
  49
  50   bool VisualizeEGDot;
  51   bool VisualizeEGUbi;
  52   AnalysisPurgeMode PurgeDead;
  53
  54   /// \brief The flag regulates if we should eagerly assume evaluations of
  55   /// conditionals, thus, bifurcating the path.
  56   ///
  57   /// EagerlyAssume - A flag indicating how the engine should handle
  58   ///   expressions such as: 'x = (y != 0)'.  When this flag is true then
  59   ///   the subexpression 'y != 0' will be eagerly assumed to be true or false,
  60   ///   thus evaluating it to the integers 0 or 1 respectively.  The upside
  61   ///   is that this can increase analysis precision until we have a better way
  62   ///   to lazily evaluate such logic.  The downside is that it eagerly
  63   ///   bifurcates paths.
  64   bool EagerlyAssume;
  65   bool TrimGraph;
  66   bool EagerlyTrimEGraph;
  67
  68 public:
  69   // \brief inter-procedural analysis mode.
  70   AnalysisIPAMode IPAMode;
  71
  72   // Settings for inlining tuning.
  73   /// \brief The inlining stack depth limit.
  74   unsigned InlineMaxStackDepth;
  75   /// \brief The max number of basic blocks in a function being inlined.
  76   unsigned InlineMaxFunctionSize;
  77   /// \brief The mode of function selection used during inlining.
  78   AnalysisInliningMode InliningMode;
  79
  80   /// \brief Do not re-analyze paths leading to exhausted nodes with a different
  81   /// strategy. We get better code coverage when retry is enabled.
  82   bool NoRetryExhausted;
  83
  84 public:
  85   AnalysisManager(ASTContext &ctx,DiagnosticsEngine &diags,
  86                   const LangOptions &lang,
  87                   const PathDiagnosticConsumers &Consumers,
  88                   StoreManagerCreator storemgr,
  89                   ConstraintManagerCreator constraintmgr,
  90                   CheckerManager *checkerMgr,
  91                   unsigned maxnodes, unsigned maxvisit,
  92                   bool vizdot, bool vizubi, AnalysisPurgeMode purge,
  93                   bool eager, bool trim,
  94                   bool useUnoptimizedCFG,
  95                   bool addImplicitDtors,
  96                   bool eagerlyTrimEGraph,
  97                   AnalysisIPAMode ipa,
  98                   unsigned inlineMaxStack,
  99                   unsigned inlineMaxFunctionSize,
 100                   AnalysisInliningMode inliningMode,
 101                   bool NoRetry);
 102
 103   ~AnalysisManager();
 104
 105   void ClearContexts() {
 106     AnaCtxMgr.clear();
 107   }
 108
 109   AnalysisDeclContextManager& getAnalysisDeclContextManager() {
 110     return AnaCtxMgr;
 111   }
 112
 113   StoreManagerCreator getStoreManagerCreator() {
 114     return CreateStoreMgr;
 115   }
 116
 117   ConstraintManagerCreator getConstraintManagerCreator() {
 118     return CreateConstraintMgr;
 119   }
 120
 121   CheckerManager *getCheckerManager() const { return CheckerMgr; }
 122
 123   virtual ASTContext &getASTContext() {
 124     return Ctx;
 125   }
 126
 127   virtual SourceManager &getSourceManager() {
 128     return getASTContext().getSourceManager();
 129   }
 130
 131   virtual DiagnosticsEngine &getDiagnostic() {
 132     return Diags;
 133   }
 134
 135   const LangOptions &getLangOpts() const {
 136     return LangOpts;
 137   }
 138
 139   ArrayRef<PathDiagnosticConsumer*> getPathDiagnosticConsumers()  {
 140     return PathConsumers;
 141   }
 142
 143   void FlushDiagnostics();
 144
 145   unsigned getMaxNodes() const { return MaxNodes; }
 146
 147   unsigned getMaxVisit() const { return MaxVisit; }
 148
 149   bool shouldVisualizeGraphviz() const { return VisualizeEGDot; }
 150
 151   bool shouldVisualizeUbigraph() const { return VisualizeEGUbi; }
 152
 153   bool shouldVisualize() const {
 154     return VisualizeEGDot || VisualizeEGUbi;
 155   }
 156
 157   bool shouldEagerlyTrimExplodedGraph() const { return EagerlyTrimEGraph; }
 158
 159   bool shouldTrimGraph() const { return TrimGraph; }
 160
 161   AnalysisPurgeMode getPurgeMode() const { return PurgeDead; }
 162
 163   bool shouldEagerlyAssume() const { return EagerlyAssume; }
 164
 165   bool shouldInlineCall() const { return (IPAMode != None); }
 166
 167   CFG *getCFG(Decl const *D) {
 168     return AnaCtxMgr.getContext(D)->getCFG();
 169   }
 170
 171   template <typename T>
 172   T *getAnalysis(Decl const *D) {
 173     return AnaCtxMgr.getContext(D)->getAnalysis<T>();
 174   }
 175
 176   ParentMap &getParentMap(Decl const *D) {
 177     return AnaCtxMgr.getContext(D)->getParentMap();
 178   }
 179
 180   AnalysisDeclContext *getAnalysisDeclContext(const Decl *D) {
 181     return AnaCtxMgr.getContext(D);
 182   }
 183
 184 };
 185
 186 } // enAnaCtxMgrspace
 187
 188 } // end clang namespace
 189
 190 #endif