vendor/clang/clang-r84119

1 files changed, 161 insertions, 126 deletions

diff --git a/include/clang/Analysis/PathSensitive/BugReporter.h b/include/clang/Analysis/PathSensitive/BugReporter.h
index 90fd9d8ebf45e..1434fce811d15 100644
--- a/include/clang/Analysis/PathSensitive/BugReporter.h
+++ b/include/clang/Analysis/PathSensitive/BugReporter.h
@@ -27,7 +27,7 @@
 #include <list>
 
 namespace clang {
-  
+
 class PathDiagnostic;
 class PathDiagnosticPiece;
 class PathDiagnosticClient;
@@ -40,7 +40,7 @@ class GRState;
 class Stmt;
 class BugType;
 class ParentMap;
-  
+
 //===----------------------------------------------------------------------===//
 // Interface for individual bug reports.
 //===----------------------------------------------------------------------===//
@@ -48,22 +48,22 @@ class ParentMap;
 class BugReporterVisitor {
 public:
   virtual ~BugReporterVisitor();
-  virtual PathDiagnosticPiece* VisitNode(const ExplodedNode<GRState>* N,
-                                         const ExplodedNode<GRState>* PrevN,
+  virtual PathDiagnosticPiece* VisitNode(const ExplodedNode* N,
+                                         const ExplodedNode* PrevN,
                                          BugReporterContext& BRC) = 0;
-  
+
   virtual bool isOwnedByReporterContext() { return true; }
 };
-  
+
 // FIXME: Combine this with RangedBugReport and remove RangedBugReport.
 class BugReport : public BugReporterVisitor {
 protected:
   BugType& BT;
   std::string ShortDescription;
   std::string Description;
-  const ExplodedNode<GRState> *EndNode;
+  const ExplodedNode *EndNode;
   SourceRange R;
-  
+
 protected:
   friend class BugReporter;
   friend class BugReportEquivClass;
@@ -71,79 +71,78 @@ protected:
   virtual void Profile(llvm::FoldingSetNodeID& hash) const {
     hash.AddInteger(getLocation().getRawEncoding());
   }
-  
+
 public:
   class NodeResolver {
   public:
     virtual ~NodeResolver() {}
-    virtual const ExplodedNode<GRState>*
-            getOriginalNode(const ExplodedNode<GRState>* N) = 0;
+    virtual const ExplodedNode*
+            getOriginalNode(const ExplodedNode* N) = 0;
   };
-  
-  BugReport(BugType& bt, const char* desc, const ExplodedNode<GRState> *n)
+
+  BugReport(BugType& bt, const char* desc, const ExplodedNode *n)
     : BT(bt), Description(desc), EndNode(n) {}
-  
+
   BugReport(BugType& bt, const char* shortDesc, const char* desc,
-            const ExplodedNode<GRState> *n)
+            const ExplodedNode *n)
   : BT(bt), ShortDescription(shortDesc), Description(desc), EndNode(n) {}
 
   virtual ~BugReport();
-  
+
   virtual bool isOwnedByReporterContext() { return false; }
 
   const BugType& getBugType() const { return BT; }
   BugType& getBugType() { return BT; }
-  
+
   // FIXME: Perhaps this should be moved into a subclass?
-  const ExplodedNode<GRState>* getEndNode() const { return EndNode; }
-  
+  const ExplodedNode* getEndNode() const { return EndNode; }
+
   // FIXME: Do we need this?  Maybe getLocation() should return a ProgramPoint
   // object.
   // FIXME: If we do need it, we can probably just make it private to
   // BugReporter.
-  Stmt* getStmt(BugReporter& BR) const;
-  
+  const Stmt* getStmt() const;
+
   const std::string& getDescription() const { return Description; }
 
   const std::string& getShortDescription() const {
     return ShortDescription.empty() ? Description : ShortDescription;
   }
-  
+
   // FIXME: Is this needed?
   virtual std::pair<const char**,const char**> getExtraDescriptiveText() {
     return std::make_pair((const char**)0,(const char**)0);
   }
-  
+
   // FIXME: Perhaps move this into a subclass.
   virtual PathDiagnosticPiece* getEndPath(BugReporterContext& BRC,
-                                          const ExplodedNode<GRState>* N);
-  
+                                          const ExplodedNode* N);
+
   /// getLocation - Return the "definitive" location of the reported bug.
   ///  While a bug can span an entire path, usually there is a specific
   ///  location that can be used to identify where the key issue occured.
   ///  This location is used by clients rendering diagnostics.
   virtual SourceLocation getLocation() const;
-  
+
   /// getRanges - Returns the source ranges associated with this bug.
-  virtual void getRanges(BugReporter& BR,const SourceRange*& beg,
-                         const SourceRange*& end);
+  virtual void getRanges(const SourceRange*& beg, const SourceRange*& end);
 
-  virtual PathDiagnosticPiece* VisitNode(const ExplodedNode<GRState>* N,
-                                         const ExplodedNode<GRState>* PrevN,
+  virtual PathDiagnosticPiece* VisitNode(const ExplodedNode* N,
+                                         const ExplodedNode* PrevN,
                                          BugReporterContext& BR);
-  
+
   virtual void registerInitialVisitors(BugReporterContext& BRC,
-                                       const ExplodedNode<GRState>* N) {}
+                                       const ExplodedNode* N) {}
 };
 
 //===----------------------------------------------------------------------===//
 // BugTypes (collections of related reports).
 //===----------------------------------------------------------------------===//
-  
+
 class BugReportEquivClass : public llvm::FoldingSetNode {
   // List of *owned* BugReport objects.
   std::list<BugReport*> Reports;
-  
+
   friend class BugReporter;
   void AddReport(BugReport* R) { Reports.push_back(R); }
 public:
@@ -165,7 +164,7 @@ public:
     BugReport* operator*() const { return *impl; }
     BugReport* operator->() const { return *impl; }
   };
-  
+
   class const_iterator {
     std::list<BugReport*>::const_iterator impl;
   public:
@@ -176,64 +175,70 @@ public:
     const BugReport* operator*() const { return *impl; }
     const BugReport* operator->() const { return *impl; }
   };
-    
+
   iterator begin() { return iterator(Reports.begin()); }
   iterator end() { return iterator(Reports.end()); }
-  
+
   const_iterator begin() const { return const_iterator(Reports.begin()); }
   const_iterator end() const { return const_iterator(Reports.end()); }
 };
-  
+
 class BugType {
 private:
   const std::string Name;
   const std::string Category;
   llvm::FoldingSet<BugReportEquivClass> EQClasses;
   friend class BugReporter;
+  bool SuppressonSink;
 public:
-  BugType(const char *name, const char* cat) : Name(name), Category(cat) {}
+  BugType(const char *name, const char* cat)
+    : Name(name), Category(cat), SuppressonSink(false) {}
   virtual ~BugType();
-  
+
   // FIXME: Should these be made strings as well?
   const std::string& getName() const { return Name; }
   const std::string& getCategory() const { return Category; }
-
-  virtual void FlushReports(BugReporter& BR);  
-  void AddReport(BugReport* BR);  
   
+  /// isSuppressOnSink - Returns true if bug reports associated with this bug
+  ///  type should be suppressed if the end node of the report is post-dominated
+  ///  by a sink node.
+  bool isSuppressOnSink() const { return SuppressonSink; }
+  void setSuppressOnSink(bool x) { SuppressonSink = x; }
+
+  virtual void FlushReports(BugReporter& BR);
+
   typedef llvm::FoldingSet<BugReportEquivClass>::iterator iterator;
   iterator begin() { return EQClasses.begin(); }
   iterator end() { return EQClasses.end(); }
-  
+
   typedef llvm::FoldingSet<BugReportEquivClass>::const_iterator const_iterator;
   const_iterator begin() const { return EQClasses.begin(); }
   const_iterator end() const { return EQClasses.end(); }
 };
-  
+
 //===----------------------------------------------------------------------===//
 // Specialized subclasses of BugReport.
 //===----------------------------------------------------------------------===//
-  
+
 // FIXME: Collapse this with the default BugReport class.
 class RangedBugReport : public BugReport {
   std::vector<SourceRange> Ranges;
 public:
-  RangedBugReport(BugType& D, const char* description, ExplodedNode<GRState> *n)
+  RangedBugReport(BugType& D, const char* description, ExplodedNode *n)
     : BugReport(D, description, n) {}
-  
+
   RangedBugReport(BugType& D, const char *shortDescription,
-                  const char *description, ExplodedNode<GRState> *n)
+                  const char *description, ExplodedNode *n)
   : BugReport(D, shortDescription, description, n) {}
-  
+
   ~RangedBugReport();
 
   // FIXME: Move this out of line.
   void addRange(SourceRange R) { Ranges.push_back(R); }
-  
+
   // FIXME: Move this out of line.
-  void getRanges(BugReporter& BR,const SourceRange*& beg,
-                 const SourceRange*& end) {
-    
+  void getRanges(const SourceRange*& beg, const SourceRange*& end) {
+
     if (Ranges.empty()) {
       beg = NULL;
       end = NULL;
@@ -244,7 +249,36 @@ public:
     }
   }
 };
-  
+
+class EnhancedBugReport : public RangedBugReport {
+public:
+  typedef void (*VisitorCreator)(BugReporterContext &BRcC, const void *data,
+                                 const ExplodedNode *N);
+
+private:
+  typedef std::vector<std::pair<VisitorCreator, const void*> > Creators;
+  Creators creators;
+
+public:
+  EnhancedBugReport(BugType& D, const char* description, ExplodedNode *n)
+   : RangedBugReport(D, description, n) {}
+
+  EnhancedBugReport(BugType& D, const char *shortDescription,
+                  const char *description, ExplodedNode *n)
+    : RangedBugReport(D, shortDescription, description, n) {}
+
+  ~EnhancedBugReport() {}
+
+  void registerInitialVisitors(BugReporterContext& BRC, const ExplodedNode* N) {
+    for (Creators::iterator I = creators.begin(), E = creators.end(); I!=E; ++I)
+      I->first(BRC, I->second, N);
+  }
+
+  void addVisitorCreator(VisitorCreator creator, const void *data) {
+    creators.push_back(std::make_pair(creator, data));
+  }
+};
+
 //===----------------------------------------------------------------------===//
 // BugReporter and friends.
 //===----------------------------------------------------------------------===//
@@ -252,15 +286,12 @@ public:
 class BugReporterData {
 public:
   virtual ~BugReporterData();
-  virtual Diagnostic& getDiagnostic() = 0;  
-  virtual PathDiagnosticClient* getPathDiagnosticClient() = 0;  
-  virtual ASTContext& getContext() = 0;
+  virtual Diagnostic& getDiagnostic() = 0;
+  virtual PathDiagnosticClient* getPathDiagnosticClient() = 0;
+  virtual ASTContext& getASTContext() = 0;
   virtual SourceManager& getSourceManager() = 0;
-  virtual CFG* getCFG() = 0;
-  virtual ParentMap& getParentMap() = 0;
-  virtual LiveVariables* getLiveVariables() = 0;
 };
-  
+
 class BugReporter {
 public:
   enum Kind { BaseBRKind, GRBugReporterKind };
@@ -270,9 +301,9 @@ private:
   BugTypesTy::Factory F;
   BugTypesTy BugTypes;
 
-  const Kind kind;  
+  const Kind kind;
   BugReporterData& D;
-  
+
   void FlushReport(BugReportEquivClass& EQ);
 
 protected:
@@ -281,40 +312,34 @@ protected:
 public:
   BugReporter(BugReporterData& d) : BugTypes(F.GetEmptySet()), kind(BaseBRKind), D(d) {}
   virtual ~BugReporter();
-  
+
   void FlushReports();
-  
+
   Kind getKind() const { return kind; }
-  
+
   Diagnostic& getDiagnostic() {
     return D.getDiagnostic();
   }
-  
+
   PathDiagnosticClient* getPathDiagnosticClient() {
     return D.getPathDiagnosticClient();
   }
-  
+
   typedef BugTypesTy::iterator iterator;
   iterator begin() { return BugTypes.begin(); }
   iterator end() { return BugTypes.end(); }
-  
-  ASTContext& getContext() { return D.getContext(); }
-  
+
+  ASTContext& getContext() { return D.getASTContext(); }
+
   SourceManager& getSourceManager() { return D.getSourceManager(); }
-  
-  CFG* getCFG() { return D.getCFG(); }
-  
-  ParentMap& getParentMap() { return D.getParentMap(); }
-  
-  LiveVariables* getLiveVariables() { return D.getLiveVariables(); }
-  
+
   virtual void GeneratePathDiagnostic(PathDiagnostic& PD,
                                       BugReportEquivClass& EQ) {}
 
   void Register(BugType *BT);
-  
+
   void EmitReport(BugReport *R);
-  
+
   void EmitBasicReport(const char* BugName, const char* BugStr,
                        SourceLocation Loc,
                        SourceRange* RangeBeg, unsigned NumRanges);
@@ -322,28 +347,28 @@ public:
   void EmitBasicReport(const char* BugName, const char* BugCategory,
                        const char* BugStr, SourceLocation Loc,
                        SourceRange* RangeBeg, unsigned NumRanges);
-  
-  
+
+
   void EmitBasicReport(const char* BugName, const char* BugStr,
                        SourceLocation Loc) {
     EmitBasicReport(BugName, BugStr, Loc, 0, 0);
   }
-  
+
   void EmitBasicReport(const char* BugName, const char* BugCategory,
                        const char* BugStr, SourceLocation Loc) {
     EmitBasicReport(BugName, BugCategory, BugStr, Loc, 0, 0);
   }
-  
+
   void EmitBasicReport(const char* BugName, const char* BugStr,
                        SourceLocation Loc, SourceRange R) {
     EmitBasicReport(BugName, BugStr, Loc, &R, 1);
   }
-  
+
   void EmitBasicReport(const char* BugName, const char* Category,
                        const char* BugStr, SourceLocation Loc, SourceRange R) {
     EmitBasicReport(BugName, Category, BugStr, Loc, &R, 1);
   }
-  
+
   static bool classof(const BugReporter* R) { return true; }
 };
 
@@ -351,95 +376,87 @@ public:
 class GRBugReporter : public BugReporter {
   GRExprEngine& Eng;
   llvm::SmallSet<SymbolRef, 10> NotableSymbols;
-public:  
+public:
   GRBugReporter(BugReporterData& d, GRExprEngine& eng)
     : BugReporter(d, GRBugReporterKind), Eng(eng) {}
-  
+
   virtual ~GRBugReporter();
-  
+
   /// getEngine - Return the analysis engine used to analyze a given
   ///  function or method.
-  GRExprEngine& getEngine() { return Eng; }
+  GRExprEngine &getEngine() { return Eng; }
 
   /// getGraph - Get the exploded graph created by the analysis engine
   ///  for the analyzed method or function.
-  ExplodedGraph<GRState>& getGraph();
-  
+  ExplodedGraph &getGraph();
+
   /// getStateManager - Return the state manager used by the analysis
   ///  engine.
-  GRStateManager& getStateManager();
-  
+  GRStateManager &getStateManager();
+
   virtual void GeneratePathDiagnostic(PathDiagnostic& PD,
                                       BugReportEquivClass& R);
 
   void addNotableSymbol(SymbolRef Sym) {
     NotableSymbols.insert(Sym);
   }
-  
+
   bool isNotable(SymbolRef Sym) const {
     return (bool) NotableSymbols.count(Sym);
   }
-    
+
   /// classof - Used by isa<>, cast<>, and dyn_cast<>.
   static bool classof(const BugReporter* R) {
     return R->getKind() == GRBugReporterKind;
   }
 };
-  
+
 class BugReporterContext {
   GRBugReporter &BR;
   std::vector<BugReporterVisitor*> Callbacks;
 public:
   BugReporterContext(GRBugReporter& br) : BR(br) {}
   virtual ~BugReporterContext();
-  
+
   void addVisitor(BugReporterVisitor* visitor) {
     if (visitor) Callbacks.push_back(visitor);
   }
-  
+
   typedef std::vector<BugReporterVisitor*>::iterator visitor_iterator;
   visitor_iterator visitor_begin() { return Callbacks.begin(); }
-  visitor_iterator visitor_end() { return Callbacks.end(); }  
-  
-  GRBugReporter& getBugReporter() { return BR; }  
-  
-  ExplodedGraph<GRState>& getGraph() { return BR.getGraph(); }
-  
+  visitor_iterator visitor_end() { return Callbacks.end(); }
+
+  GRBugReporter& getBugReporter() { return BR; }
+
+  ExplodedGraph &getGraph() { return BR.getGraph(); }
+
   void addNotableSymbol(SymbolRef Sym) {
     // FIXME: For now forward to GRBugReporter.
     BR.addNotableSymbol(Sym);
   }
-  
+
   bool isNotable(SymbolRef Sym) const {
     // FIXME: For now forward to GRBugReporter.
     return BR.isNotable(Sym);
   }
-  
+
   GRStateManager& getStateManager() {
     return BR.getStateManager();
   }
-  
+
   ValueManager& getValueManager() {
     return getStateManager().getValueManager();
   }
-  
+
   ASTContext& getASTContext() {
     return BR.getContext();
   }
-  
+
   SourceManager& getSourceManager() {
     return BR.getSourceManager();
   }
-  
-  const Decl& getCodeDecl() {
-    return getStateManager().getCodeDecl();
-  }
-  
-  const CFG& getCFG() {
-    return *BR.getCFG();
-  }
-  
-  virtual BugReport::NodeResolver& getNodeResolver() = 0;  
+
+  virtual BugReport::NodeResolver& getNodeResolver() = 0;
 };
 
 class DiagBugReport : public RangedBugReport {
@@ -448,19 +465,37 @@ class DiagBugReport : public RangedBugReport {
 public:
   DiagBugReport(BugType& D, const char* desc, FullSourceLoc l) :
   RangedBugReport(D, desc, 0), L(l) {}
-  
+
   virtual ~DiagBugReport() {}
-  
+
   // FIXME: Move out-of-line (virtual function).
   SourceLocation getLocation() const { return L; }
-  
-  void addString(const std::string& s) { Strs.push_back(s); }  
-  
+
+  void addString(const std::string& s) { Strs.push_back(s); }
+
   typedef std::list<std::string>::const_iterator str_iterator;
   str_iterator str_begin() const { return Strs.begin(); }
   str_iterator str_end() const { return Strs.end(); }
 };
 
+//===----------------------------------------------------------------------===//
+//===----------------------------------------------------------------------===//
+
+namespace bugreporter {
+
+const Stmt *GetDerefExpr(const ExplodedNode *N);
+const Stmt *GetReceiverExpr(const ExplodedNode *N);
+const Stmt *GetDenomExpr(const ExplodedNode *N);
+const Stmt *GetCalleeExpr(const ExplodedNode *N);
+const Stmt *GetRetValExpr(const ExplodedNode *N);
+
+void registerTrackNullOrUndefValue(BugReporterContext& BRC, const void *stmt,
+                                   const ExplodedNode* N);
+
+} // end namespace clang::bugreporter
+
+//===----------------------------------------------------------------------===//
+
 } // end clang namespace
 
 #endif