contrib/llvm/tools/clang/include/clang/Analysis/AnalysisContext.h

   1 //=== AnalysisContext.h - Analysis context for Path Sens analysis --*- 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 AnalysisContext, a class that manages the analysis context
  11 // data for path sensitive analysis.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_ANALYSIS_ANALYSISCONTEXT_H
  16 #define LLVM_CLANG_ANALYSIS_ANALYSISCONTEXT_H
  17
  18 #include "clang/AST/Decl.h"
  19 #include "clang/AST/Expr.h"
  20 #include "clang/Analysis/CFG.h"
  21 #include "llvm/ADT/OwningPtr.h"
  22 #include "llvm/ADT/FoldingSet.h"
  23 #include "llvm/ADT/PointerUnion.h"
  24 #include "llvm/ADT/DenseMap.h"
  25 #include "llvm/Support/Allocator.h"
  26
  27 namespace clang {
  28
  29 class Decl;
  30 class Stmt;
  31 class CFGReverseBlockReachabilityAnalysis;
  32 class CFGStmtMap;
  33 class LiveVariables;
  34 class ParentMap;
  35 class PseudoConstantAnalysis;
  36 class ImplicitParamDecl;
  37 class LocationContextManager;
  38 class StackFrameContext;
  39
  40 namespace idx { class TranslationUnit; }
  41
  42 /// AnalysisContext contains the context data for the function or method under
  43 /// analysis.
  44 class AnalysisContext {
  45   const Decl *D;
  46
  47   // TranslationUnit is NULL if we don't have multiple translation units.
  48   idx::TranslationUnit *TU;
  49
  50   llvm::OwningPtr<CFG> cfg, completeCFG;
  51   llvm::OwningPtr<CFGStmtMap> cfgStmtMap;
  52
  53   CFG::BuildOptions cfgBuildOptions;
  54   CFG::BuildOptions::ForcedBlkExprs *forcedBlkExprs;
  55
  56   bool builtCFG, builtCompleteCFG;
  57   const bool useUnoptimizedCFG;
  58
  59   llvm::OwningPtr<LiveVariables> liveness;
  60   llvm::OwningPtr<LiveVariables> relaxedLiveness;
  61   llvm::OwningPtr<ParentMap> PM;
  62   llvm::OwningPtr<PseudoConstantAnalysis> PCA;
  63   llvm::OwningPtr<CFGReverseBlockReachabilityAnalysis> CFA;
  64
  65   llvm::BumpPtrAllocator A;
  66
  67   // FIXME: remove.
  68   llvm::DenseMap<const BlockDecl*,void*> *ReferencedBlockVars;
  69
  70 public:
  71   AnalysisContext(const Decl *d, idx::TranslationUnit *tu,
  72                   bool useUnoptimizedCFG = false,
  73                   bool addehedges = false,
  74                   bool addImplicitDtors = false,
  75                   bool addInitializers = false);
  76
  77   ~AnalysisContext();
  78
  79   ASTContext &getASTContext() { return D->getASTContext(); }
  80   const Decl *getDecl() const { return D; }
  81
  82   idx::TranslationUnit *getTranslationUnit() const { return TU; }
  83
  84   /// getAddEHEdges - Return true iff we are adding exceptional edges from
  85   /// callExprs.  If this is false, then try/catch statements and blocks
  86   /// reachable from them can appear to be dead in the CFG, analysis passes must
  87   /// cope with that.
  88   bool getAddEHEdges() const { return cfgBuildOptions.AddEHEdges; }
  89   bool getUseUnoptimizedCFG() const {
  90       return cfgBuildOptions.PruneTriviallyFalseEdges;
  91   }
  92   bool getAddImplicitDtors() const { return cfgBuildOptions.AddImplicitDtors; }
  93   bool getAddInitializers() const { return cfgBuildOptions.AddInitializers; }
  94
  95   void registerForcedBlockExpression(const Stmt *stmt);
  96   const CFGBlock *getBlockForRegisteredExpression(const Stmt *stmt);
  97
  98   Stmt *getBody();
  99   CFG *getCFG();
 100
 101   CFGStmtMap *getCFGStmtMap();
 102
 103   CFGReverseBlockReachabilityAnalysis *getCFGReachablityAnalysis();
 104
 105   /// Return a version of the CFG without any edges pruned.
 106   CFG *getUnoptimizedCFG();
 107
 108   void dumpCFG();
 109
 110   /// \brief Returns true if we have built a CFG for this analysis context.
 111   /// Note that this doesn't correspond to whether or not a valid CFG exists, it
 112   /// corresponds to whether we *attempted* to build one.
 113   bool isCFGBuilt() const { return builtCFG; }
 114
 115   ParentMap &getParentMap();
 116   PseudoConstantAnalysis *getPseudoConstantAnalysis();
 117   LiveVariables *getLiveVariables();
 118   LiveVariables *getRelaxedLiveVariables();
 119
 120   typedef const VarDecl * const * referenced_decls_iterator;
 121
 122   std::pair<referenced_decls_iterator, referenced_decls_iterator>
 123     getReferencedBlockVars(const BlockDecl *BD);
 124
 125   /// Return the ImplicitParamDecl* associated with 'self' if this
 126   /// AnalysisContext wraps an ObjCMethodDecl.  Returns NULL otherwise.
 127   const ImplicitParamDecl *getSelfDecl() const;
 128 };
 129
 130 class AnalysisContextManager {
 131   typedef llvm::DenseMap<const Decl*, AnalysisContext*> ContextMap;
 132   ContextMap Contexts;
 133   bool UseUnoptimizedCFG;
 134   bool AddImplicitDtors;
 135   bool AddInitializers;
 136 public:
 137   AnalysisContextManager(bool useUnoptimizedCFG = false,
 138       bool addImplicitDtors = false, bool addInitializers = false)
 139     : UseUnoptimizedCFG(useUnoptimizedCFG), AddImplicitDtors(addImplicitDtors),
 140       AddInitializers(addInitializers) {}
 141
 142   ~AnalysisContextManager();
 143
 144   AnalysisContext *getContext(const Decl *D, idx::TranslationUnit *TU = 0);
 145
 146   bool getUseUnoptimizedCFG() const { return UseUnoptimizedCFG; }
 147   bool getAddImplicitDtors() const { return AddImplicitDtors; }
 148   bool getAddInitializers() const { return AddInitializers; }
 149
 150   // Discard all previously created AnalysisContexts.
 151   void clear();
 152 };
 153
 154 class LocationContext : public llvm::FoldingSetNode {
 155 public:
 156   enum ContextKind { StackFrame, Scope, Block };
 157
 158 private:
 159   ContextKind Kind;
 160
 161   // AnalysisContext can't be const since some methods may modify its member.
 162   AnalysisContext *Ctx;
 163
 164   const LocationContext *Parent;
 165
 166 protected:
 167   LocationContext(ContextKind k, AnalysisContext *ctx,
 168                   const LocationContext *parent)
 169     : Kind(k), Ctx(ctx), Parent(parent) {}
 170
 171 public:
 172   virtual ~LocationContext();
 173
 174   ContextKind getKind() const { return Kind; }
 175
 176   AnalysisContext *getAnalysisContext() const { return Ctx; }
 177
 178   idx::TranslationUnit *getTranslationUnit() const {
 179     return Ctx->getTranslationUnit();
 180   }
 181
 182   const LocationContext *getParent() const { return Parent; }
 183
 184   bool isParentOf(const LocationContext *LC) const;
 185
 186   const Decl *getDecl() const { return getAnalysisContext()->getDecl(); }
 187
 188   CFG *getCFG() const { return getAnalysisContext()->getCFG(); }
 189
 190   LiveVariables *getLiveVariables() const {
 191     return getAnalysisContext()->getLiveVariables();
 192   }
 193
 194   ParentMap &getParentMap() const {
 195     return getAnalysisContext()->getParentMap();
 196   }
 197
 198   const ImplicitParamDecl *getSelfDecl() const {
 199     return Ctx->getSelfDecl();
 200   }
 201
 202   const StackFrameContext *getCurrentStackFrame() const;
 203   const StackFrameContext *
 204     getStackFrameForDeclContext(const DeclContext *DC) const;
 205
 206   virtual void Profile(llvm::FoldingSetNodeID &ID) = 0;
 207
 208   static bool classof(const LocationContext*) { return true; }
 209
 210 public:
 211   static void ProfileCommon(llvm::FoldingSetNodeID &ID,
 212                             ContextKind ck,
 213                             AnalysisContext *ctx,
 214                             const LocationContext *parent,
 215                             const void* data);
 216 };
 217
 218 class StackFrameContext : public LocationContext {
 219   // The callsite where this stack frame is established.
 220   const Stmt *CallSite;
 221
 222   // The parent block of the callsite.
 223   const CFGBlock *Block;
 224
 225   // The index of the callsite in the CFGBlock.
 226   unsigned Index;
 227
 228   friend class LocationContextManager;
 229   StackFrameContext(AnalysisContext *ctx, const LocationContext *parent,
 230                     const Stmt *s, const CFGBlock *blk,
 231                     unsigned idx)
 232     : LocationContext(StackFrame, ctx, parent), CallSite(s),
 233       Block(blk), Index(idx) {}
 234
 235 public:
 236   ~StackFrameContext() {}
 237
 238   const Stmt *getCallSite() const { return CallSite; }
 239
 240   const CFGBlock *getCallSiteBlock() const { return Block; }
 241
 242   unsigned getIndex() const { return Index; }
 243
 244   void Profile(llvm::FoldingSetNodeID &ID);
 245
 246   static void Profile(llvm::FoldingSetNodeID &ID, AnalysisContext *ctx,
 247                       const LocationContext *parent, const Stmt *s,
 248                       const CFGBlock *blk, unsigned idx) {
 249     ProfileCommon(ID, StackFrame, ctx, parent, s);
 250     ID.AddPointer(blk);
 251     ID.AddInteger(idx);
 252   }
 253
 254   static bool classof(const LocationContext* Ctx) {
 255     return Ctx->getKind() == StackFrame;
 256   }
 257 };
 258
 259 class ScopeContext : public LocationContext {
 260   const Stmt *Enter;
 261
 262   friend class LocationContextManager;
 263   ScopeContext(AnalysisContext *ctx, const LocationContext *parent,
 264                const Stmt *s)
 265     : LocationContext(Scope, ctx, parent), Enter(s) {}
 266
 267 public:
 268   ~ScopeContext() {}
 269
 270   void Profile(llvm::FoldingSetNodeID &ID);
 271
 272   static void Profile(llvm::FoldingSetNodeID &ID, AnalysisContext *ctx,
 273                       const LocationContext *parent, const Stmt *s) {
 274     ProfileCommon(ID, Scope, ctx, parent, s);
 275   }
 276
 277   static bool classof(const LocationContext* Ctx) {
 278     return Ctx->getKind() == Scope;
 279   }
 280 };
 281
 282 class BlockInvocationContext : public LocationContext {
 283   // FIXME: Add back context-sensivity (we don't want libAnalysis to know
 284   //  about MemRegion).
 285   const BlockDecl *BD;
 286
 287   friend class LocationContextManager;
 288
 289   BlockInvocationContext(AnalysisContext *ctx, const LocationContext *parent,
 290                          const BlockDecl *bd)
 291     : LocationContext(Block, ctx, parent), BD(bd) {}
 292
 293 public:
 294   ~BlockInvocationContext() {}
 295
 296   const BlockDecl *getBlockDecl() const { return BD; }
 297
 298   void Profile(llvm::FoldingSetNodeID &ID);
 299
 300   static void Profile(llvm::FoldingSetNodeID &ID, AnalysisContext *ctx,
 301                       const LocationContext *parent, const BlockDecl *bd) {
 302     ProfileCommon(ID, Block, ctx, parent, bd);
 303   }
 304
 305   static bool classof(const LocationContext* Ctx) {
 306     return Ctx->getKind() == Block;
 307   }
 308 };
 309
 310 class LocationContextManager {
 311   llvm::FoldingSet<LocationContext> Contexts;
 312 public:
 313   ~LocationContextManager();
 314
 315   const StackFrameContext *getStackFrame(AnalysisContext *ctx,
 316                                          const LocationContext *parent,
 317                                          const Stmt *s,
 318                                          const CFGBlock *blk, unsigned idx);
 319
 320   const ScopeContext *getScope(AnalysisContext *ctx,
 321                                const LocationContext *parent,
 322                                const Stmt *s);
 323
 324   /// Discard all previously created LocationContext objects.
 325   void clear();
 326 private:
 327   template <typename LOC, typename DATA>
 328   const LOC *getLocationContext(AnalysisContext *ctx,
 329                                 const LocationContext *parent,
 330                                 const DATA *d);
 331 };
 332
 333 } // end clang namespace
 334 #endif