Rewrite control-flow diagnostic generation "extensive" algorithm using "edge

contexts".  This allows us to use a stack of contexts to keep track of what control-flow pieces to include when exiting blocks like 'if', 'for', etc.

llvm-svn: 68473

clang/lib/Analysis/BugReporter.cpp

@@ -456,6 +456,8 @@ public:
 // "Minimal" path diagnostic generation algorithm.
 //===----------------------------------------------------------------------===//
 
+static void CompactPathDiagnostic(PathDiagnostic &PD, const SourceManager& SM);
+
 static void GenerateMinimalPathDiagnostic(PathDiagnostic& PD,
                                           PathDiagnosticBuilder &PDB,
                                           const ExplodedNode<GRState> *N) {
@@ -740,6 +742,10 @@ static void GenerateMinimalPathDiagnostic(PathDiagnostic& PD,
       PDB.getStateManager().iterBindings(N->getState(), SNS);
     }
   }
+  
+  // After constructing the full PathDiagnostic, do a pass over it to compact
+  // PathDiagnosticPieces that occur within a macro.
+  CompactPathDiagnostic(PD, PDB.getSourceManager());
 }
 
 //===----------------------------------------------------------------------===//
@@ -764,6 +770,258 @@ static bool IsControlFlowExpr(const Stmt *S) {
   return false;  
 }
 
+#if 1
+
+namespace {
+class VISIBILITY_HIDDEN EdgeBuilder {
+  std::vector<PathDiagnosticLocation> CLocs;
+  typedef std::vector<PathDiagnosticLocation>::iterator iterator;
+  PathDiagnostic &PD;
+  PathDiagnosticBuilder &PDB;
+  PathDiagnosticLocation PrevLoc;
+
+  bool containsLocation(const PathDiagnosticLocation &Container,
+                        const PathDiagnosticLocation &Containee);
+  
+  PathDiagnosticLocation getContextLocation(const PathDiagnosticLocation &L);
+  void rawAddEdge(PathDiagnosticLocation NewLoc);
+  
+  void popLocation() {
+    rawAddEdge(CLocs.back());
+    CLocs.pop_back();
+  }
+  
+  PathDiagnosticLocation IgnoreParens(const PathDiagnosticLocation &L);  
+
+public:
+  EdgeBuilder(PathDiagnostic &pd, PathDiagnosticBuilder &pdb)
+    : PD(pd), PDB(pdb) {
+      CLocs.push_back(PathDiagnosticLocation(&PDB.getCodeDecl(),
+                                             PDB.getSourceManager()));
+      if (!PD.empty()) {
+        PrevLoc = PD.begin()->getLocation();
+        
+        if (const Stmt *S = PrevLoc.asStmt())
+          addContext(PDB.getEnclosingStmtLocation(S).asStmt());
+      }
+  }
+
+  ~EdgeBuilder() {
+    while (!CLocs.empty()) popLocation();
+  }
+
+  void addEdge(PathDiagnosticLocation NewLoc, bool alwaysAdd = false);
+  
+  void addEdge(const Stmt *S, bool alwaysAdd = false) {
+    addEdge(PathDiagnosticLocation(S, PDB.getSourceManager()), alwaysAdd);
+  }
+  
+  void addContext(const Stmt *S);
+};  
+} // end anonymous namespace
+
+
+PathDiagnosticLocation
+EdgeBuilder::getContextLocation(const PathDiagnosticLocation &L) {
+  if (const Stmt *S = L.asStmt()) {
+    if (IsControlFlowExpr(S))
+      return L;
+    
+    return PDB.getEnclosingStmtLocation(S);    
+  }
+  
+  return L;
+}
+
+bool EdgeBuilder::containsLocation(const PathDiagnosticLocation &Container,
+                                   const PathDiagnosticLocation &Containee) {
+
+  if (Container == Containee)
+    return true;
+    
+  if (Container.asDecl())
+    return true;
+  
+  if (const Stmt *S = Containee.asStmt())
+    if (const Stmt *ContainerS = Container.asStmt()) {
+      while (S) {
+        if (S == ContainerS)
+          return true;
+        S = PDB.getParent(S);
+      }
+      return false;
+    }
+
+  // Less accurate: compare using source ranges.
+  SourceRange ContainerR = Container.asRange();
+  SourceRange ContaineeR = Containee.asRange();
+  
+  SourceManager &SM = PDB.getSourceManager();
+  SourceLocation ContainerRBeg = SM.getInstantiationLoc(ContainerR.getBegin());
+  SourceLocation ContainerREnd = SM.getInstantiationLoc(ContainerR.getEnd());
+  SourceLocation ContaineeRBeg = SM.getInstantiationLoc(ContaineeR.getBegin());
+  SourceLocation ContaineeREnd = SM.getInstantiationLoc(ContaineeR.getEnd());
+  
+  unsigned ContainerBegLine = SM.getInstantiationLineNumber(ContainerRBeg);
+  unsigned ContainerEndLine = SM.getInstantiationLineNumber(ContainerREnd);
+  unsigned ContaineeBegLine = SM.getInstantiationLineNumber(ContaineeRBeg);
+  unsigned ContaineeEndLine = SM.getInstantiationLineNumber(ContaineeREnd);
+  
+  assert(ContainerBegLine <= ContainerEndLine);
+  assert(ContaineeBegLine <= ContaineeEndLine);  
+  
+  return (ContainerBegLine <= ContaineeBegLine &&
+          ContainerEndLine >= ContaineeEndLine &&
+          (ContainerBegLine != ContaineeBegLine ||
+           SM.getInstantiationColumnNumber(ContainerRBeg) <= 
+           SM.getInstantiationColumnNumber(ContaineeRBeg)) &&
+          (ContainerEndLine != ContaineeEndLine ||
+           SM.getInstantiationColumnNumber(ContainerREnd) >=
+           SM.getInstantiationColumnNumber(ContainerREnd)));
+}
+
+PathDiagnosticLocation
+EdgeBuilder::IgnoreParens(const PathDiagnosticLocation &L) {
+  if (const Expr* E = dyn_cast_or_null<Expr>(L.asStmt()))
+      return PathDiagnosticLocation(E->IgnoreParenCasts(),
+                                    PDB.getSourceManager());
+  return L;
+}
+
+void EdgeBuilder::rawAddEdge(PathDiagnosticLocation NewLoc) {
+  if (!PrevLoc.isValid()) {
+    PrevLoc = NewLoc;
+    return;
+  }
+  
+  if (NewLoc.asLocation() == PrevLoc.asLocation())
+    return;
+    
+  // FIXME: Ignore intra-macro edges for now.
+  if (NewLoc.asLocation().getInstantiationLoc() ==
+      PrevLoc.asLocation().getInstantiationLoc())
+    return;
+
+  PD.push_front(new PathDiagnosticControlFlowPiece(NewLoc, PrevLoc));
+  PrevLoc = NewLoc;  
+}
+
+void EdgeBuilder::addEdge(PathDiagnosticLocation NewLoc, bool alwaysAdd) {
+  const PathDiagnosticLocation &CLoc = getContextLocation(NewLoc);
+
+  while (!CLocs.empty()) {
+    const PathDiagnosticLocation &TopContextLoc = CLocs.back();
+    
+    // Is the top location context the same as the one for the new location?
+    if (TopContextLoc == CLoc) {
+      if (alwaysAdd && NewLoc.asLocation() != CLoc.asLocation())
+        rawAddEdge(NewLoc);
+
+      return;
+    }
+
+    if (containsLocation(TopContextLoc, CLoc)) {
+      if (alwaysAdd)
+        rawAddEdge(NewLoc);
+
+      CLocs.push_back(CLoc);
+      return;      
+    }
+
+    // Context does not contain the location.  Flush it.
+    popLocation();
+  }
+
+  assert(0 && "addEdge should never pop the top context");
+}
+
+void EdgeBuilder::addContext(const Stmt *S) {
+  if (!S)
+    return;
+
+  PathDiagnosticLocation L(S, PDB.getSourceManager());
+  
+  while (!CLocs.empty()) {
+    const PathDiagnosticLocation &TopContextLoc = CLocs.back();
+
+    // Is the top location context the same as the one for the new location?
+    if (TopContextLoc == L)
+      return;
+
+    if (containsLocation(TopContextLoc, L)) {
+    //   if (const Stmt *S = L.asStmt())
+    //     if (isa<Expr>(S))
+    //       if (const Stmt *P = PDB.getParent(S))
+    //         addContext(PDB.getEnclosingStmtLocation(P).asStmt());
+      
+      CLocs.push_back(L);
+      return;      
+    }
+
+    // Context does not contain the location.  Flush it.
+    popLocation();
+  }
+
+  CLocs.push_back(L);
+}
+
+static void GenerateExtensivePathDiagnostic(PathDiagnostic& PD,
+                                            PathDiagnosticBuilder &PDB,
+                                            const ExplodedNode<GRState> *N) {
+  
+  
+  EdgeBuilder EB(PD, PDB);
+
+  const ExplodedNode<GRState>* NextNode = N->pred_empty() 
+                                        ? NULL : *(N->pred_begin());
+
+  while (NextNode) {
+    N = NextNode;
+    NextNode = GetPredecessorNode(N);
+    ProgramPoint P = N->getLocation();
+
+    // Block edges.
+    if (const BlockEdge *BE = dyn_cast<BlockEdge>(&P)) {
+      const CFGBlock &Blk = *BE->getSrc();
+
+      if (const Stmt *Term = Blk.getTerminator())
+        EB.addContext(Term);
+
+      // Only handle blocks with more than 1 statement here, as the blocks
+      // with one statement are handled at BlockEntrances.
+      if (Blk.size() > 1) {
+        const Stmt *S = *Blk.rbegin();
+        EB.addEdge(S);
+      }
+
+      continue;
+    }
+
+    if (const BlockEntrance *BE = dyn_cast<BlockEntrance>(&P)) {
+      if (const Stmt* S = BE->getFirstStmt()) {
+       if (IsControlFlowExpr(S))
+         EB.addContext(S);
+       else
+        EB.addEdge(S);
+      }
+
+      continue;
+    }
+    
+    PathDiagnosticPiece* p =
+    PDB.getReport().VisitNode(N, NextNode, PDB.getGraph(),
+                              PDB.getBugReporter(), PDB.getNodeMapClosure());
+    
+    if (p) {
+      EB.addEdge(p->getLocation(), true);
+      PD.push_front(p);
+    }
+  }
+}
+
+
+#else
+
 static void GenExtAddEdge(PathDiagnostic& PD,
                           PathDiagnosticBuilder &PDB,
                           PathDiagnosticLocation NewLoc,
@@ -930,6 +1188,7 @@ static void GenerateExtensivePathDiagnostic(PathDiagnostic& PD,
     }
   }
 }
+#endif
 
 //===----------------------------------------------------------------------===//
 // Methods for BugType and subclasses.
@@ -1337,10 +1596,6 @@ void GRBugReporter::GeneratePathDiagnostic(PathDiagnostic& PD,
       GenerateMinimalPathDiagnostic(PD, PDB, N);
       break;
   }
-  
-  // After constructing the full PathDiagnostic, do a pass over it to compact
-  // PathDiagnosticPieces that occur within a macro.
-  CompactPathDiagnostic(PD, PDB.getSourceManager());  
 }
 
 void BugReporter::Register(BugType *BT) {