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_STATICANALYZER_CORE_PATHSENSITIVE_ANALYSISMANAGER_H
  16 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_ANALYSISMANAGER_H
  17
  18 #include "clang/Analysis/AnalysisDeclContext.h"
  19 #include "clang/StaticAnalyzer/Core/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 class CodeInjector;
  27
  28 namespace ento {
  29   class CheckerManager;
  30
  31 class AnalysisManager : public BugReporterData {
  32   virtual void anchor();
  33   AnalysisDeclContextManager AnaCtxMgr;
  34
  35   ASTContext &Ctx;
  36   DiagnosticsEngine &Diags;
  37   const LangOptions &LangOpts;
  38   PathDiagnosticConsumers PathConsumers;
  39
  40   // Configurable components creators.
  41   StoreManagerCreator CreateStoreMgr;
  42   ConstraintManagerCreator CreateConstraintMgr;
  43
  44   CheckerManager *CheckerMgr;
  45
  46 public:
  47   AnalyzerOptions &options;
  48
  49   AnalysisManager(ASTContext &ctx,DiagnosticsEngine &diags,
  50                   const LangOptions &lang,
  51                   const PathDiagnosticConsumers &Consumers,
  52                   StoreManagerCreator storemgr,
  53                   ConstraintManagerCreator constraintmgr,
  54                   CheckerManager *checkerMgr,
  55                   AnalyzerOptions &Options,
  56                   CodeInjector* injector = nullptr);
  57
  58   ~AnalysisManager() override;
  59
  60   void ClearContexts() {
  61     AnaCtxMgr.clear();
  62   }
  63
  64   AnalysisDeclContextManager& getAnalysisDeclContextManager() {
  65     return AnaCtxMgr;
  66   }
  67
  68   StoreManagerCreator getStoreManagerCreator() {
  69     return CreateStoreMgr;
  70   }
  71
  72   AnalyzerOptions& getAnalyzerOptions() override {
  73     return options;
  74   }
  75
  76   ConstraintManagerCreator getConstraintManagerCreator() {
  77     return CreateConstraintMgr;
  78   }
  79
  80   CheckerManager *getCheckerManager() const { return CheckerMgr; }
  81
  82   ASTContext &getASTContext() override {
  83     return Ctx;
  84   }
  85
  86   SourceManager &getSourceManager() override {
  87     return getASTContext().getSourceManager();
  88   }
  89
  90   DiagnosticsEngine &getDiagnostic() override {
  91     return Diags;
  92   }
  93
  94   const LangOptions &getLangOpts() const {
  95     return LangOpts;
  96   }
  97
  98   ArrayRef<PathDiagnosticConsumer*> getPathDiagnosticConsumers() override {
  99     return PathConsumers;
 100   }
 101
 102   void FlushDiagnostics();
 103
 104   bool shouldVisualize() const {
 105     return options.visualizeExplodedGraphWithGraphViz ||
 106            options.visualizeExplodedGraphWithUbiGraph;
 107   }
 108
 109   bool shouldInlineCall() const {
 110     return options.getIPAMode() != IPAK_None;
 111   }
 112
 113   CFG *getCFG(Decl const *D) {
 114     return AnaCtxMgr.getContext(D)->getCFG();
 115   }
 116
 117   template <typename T>
 118   T *getAnalysis(Decl const *D) {
 119     return AnaCtxMgr.getContext(D)->getAnalysis<T>();
 120   }
 121
 122   ParentMap &getParentMap(Decl const *D) {
 123     return AnaCtxMgr.getContext(D)->getParentMap();
 124   }
 125
 126   AnalysisDeclContext *getAnalysisDeclContext(const Decl *D) {
 127     return AnaCtxMgr.getContext(D);
 128   }
 129
 130   static bool isInCodeFile(SourceLocation SL, const SourceManager &SM) {
 131     if (SM.isInMainFile(SL))
 132       return true;
 133
 134     // Support the "unified sources" compilation method (eg. WebKit) that
 135     // involves producing non-header files that include other non-header files.
 136     // We should be included directly from a UnifiedSource* file
 137     // and we shouldn't be a header - which is a very safe defensive check.
 138     SourceLocation IL = SM.getIncludeLoc(SM.getFileID(SL));
 139     if (!IL.isValid() || !SM.isInMainFile(IL))
 140       return false;
 141     // Should rather be "file name starts with", but the current .getFilename
 142     // includes the full path.
 143     if (SM.getFilename(IL).contains("UnifiedSource")) {
 144       // It might be great to reuse FrontendOptions::getInputKindForExtension()
 145       // but for now it doesn't discriminate between code and header files.
 146       return llvm::StringSwitch<bool>(SM.getFilename(SL).rsplit('.').second)
 147           .Cases("c", "m", "mm", "C", "cc", "cp", true)
 148           .Cases("cpp", "CPP", "c++", "cxx", "cppm", true)
 149           .Default(false);
 150     }
 151
 152     return false;
 153   }
 154
 155   bool isInCodeFile(SourceLocation SL) {
 156     const SourceManager &SM = getASTContext().getSourceManager();
 157     return isInCodeFile(SL, SM);
 158   }
 159 };
 160
 161 } // enAnaCtxMgrspace
 162
 163 } // end clang namespace
 164
 165 #endif