[analyzer] ExplodedGraph: printDiff(): Store implementation

[Charusso]

Summary

printDiff() takes the current and a previous state of the given object
and only prints out the additional differences.

[Charusso]

This patch is the sample for every other printDiff() functions, so let us brainstorming. I think it is useless to write out if there is no new information, also it comes with an ugly code. What do you guys think?

clang/lib/StaticAnalyzer/Core/ProgramState.cpp

449

Now the separator is driven by the Store, mentioned in D61677.

[Charusso]

Abandoned like its parent revision.

clang/include/clang/StaticAnalyzer/Core/PathSensitive/Store.h

StoreRef enterStackFrame(Store store,
                            const StackFrameContext *CalleeCtx);
 
   /// Finds the transitive closure of symbols within the given region.
   ///
   /// Returns false if the visitor aborted the scan.
   virtual bool scanReachableSymbols(Store S, const MemRegion *R,
                                     ScanReachableSymbols &Visitor) = 0;
 
-  virtual void print(Store store, raw_ostream &Out, const char* nl) = 0;
+  virtual void print(raw_ostream &Out, Store S, const char *NL,
+                     const char *Sep) const = 0;
+
+  virtual void printDiff(raw_ostream &Out, Store CurrentStore,
+                         Store PreviousStore, const char *NL,
+                         const char *Sep) const = 0;
 
   class BindingsHandler {
   public:
     virtual ~BindingsHandler();
 
     /// \return whether the iteration should continue.
     virtual bool HandleBinding(StoreManager& SMgr, Store store,
                                const MemRegion *region, SVal val) = 0;

clang/lib/StaticAnalyzer/Core/ProgramState.cpp

 //===----------------------------------------------------------------------===//
 
 void ProgramState::print(raw_ostream &Out, const LocationContext *LCtx,
                          const char *NL, const char *Sep) const {
   ProgramStateManager &Mgr = getStateManager();
   const ASTContext &Ctx = Mgr.getContext();
 
   // Print out the store.
-  Mgr.getStoreManager().print(getStore(), Out, NL);
+  Mgr.getStoreManager().print(Out, getStore(), NL, Sep);
 
   // Print out the environment.
   Env.print(Out, NL, Sep, Ctx, LCtx);
 
   // Print out the constraints.
   Mgr.getConstraintManager().print(this, Out, NL, Sep);
 
   // Print out the tracked dynamic types.
void ProgramState::printDiff(raw_ostream &Out, ProgramStateRef PreviousState,
   // If there is no previous state just print the current state.
   if (!PreviousState) {
     print(Out, CurrentLCtx, NL, Sep);
     return;
   }
 
   ProgramStateManager &Mgr = getStateManager();
   const ASTContext &Ctx = Mgr.getContext();
+  const Store PreviousStore = PreviousState->getStore();
 
   // Print out the store.
-  Mgr.getStoreManager().print(getStore(), Out, NL);
+  Mgr.getStoreManager().printDiff(Out, getStore(), PreviousStore, NL, Sep);
 
   // Print out the environment.
   Env.print(Out, NL, Sep, Ctx, CurrentLCtx);
 
   // Print out the constraints.
   Mgr.getConstraintManager().print(this, Out, NL, Sep);
 
   // Print out the tracked dynamic types.

clang/lib/StaticAnalyzer/Core/RegionStore.cpp

public:
   ///  binding associated with a region and its subregions.
   Optional<SVal> getDefaultBinding(const MemRegion *R) const;
 
   /// Return the internal tree as a Store.
   Store asStore() const {
     return asImmutableMap().getRootWithoutRetain();
   }
 
-  void dump(raw_ostream &OS, const char *nl) const {
+  void print(raw_ostream &Out, const char *NL = "\n") const {
     for (iterator I = begin(), E = end(); I != E; ++I) {
       const ClusterBindings &Cluster = I.getData();
-     for (ClusterBindings::iterator CI = Cluster.begin(), CE = Cluster.end();
-          CI != CE; ++CI) {
-       OS << ' ' << CI.getKey() << " : " << CI.getData() << nl;
-     }
-     OS << nl;
+      for (ClusterBindings::iterator CI = Cluster.begin(); CI != Cluster.end();
+           ++CI) {
+        Out << ' ' << CI.getKey() << " : " << CI.getData() << NL;
+      }
+      Out << NL;
+    }
+  }
+
+  void printDiff(raw_ostream &Out, RegionBindingsRef PreviousCluster,
+                 const char *NL = "\n") const {
+    // If there is no previous cluster just print the current cluster.
+    if (PreviousCluster.isEmpty()) {
+      print(Out, NL);
+      return;
+
+    bool IsDifferent = false;
+    for (iterator I = begin(); I != end(); ++I) {
+      // Skip duplications.
+      if (std::find(PreviousCluster.begin(), PreviousCluster.end(), *I) !=
+          PreviousCluster.end())
+        continue;
+
+      // In the beginning add a little space.
+      if (!IsDifferent) {
+        Out << NL << NL;
+        IsDifferent = true;
+      }
+
+      const ClusterBindings &Cluster = I.getData();
+      for (ClusterBindings::iterator CI = Cluster.begin(); CI != Cluster.end();
+           ++CI) {
+        Out << ' ' << CI.getKey() << " : " << CI.getData() << NL;
       }
+      Out << NL;
     }
 
-  LLVM_DUMP_METHOD void dump() const { dump(llvm::errs(), "\n"); }
+    if (!IsDifferent)
+      Out << " No difference." << NL;
+  }
+
+  LLVM_DUMP_METHOD void dump() const { print(llvm::errs(), "\n"); }
 };
 } // end anonymous namespace
 
 typedef const RegionBindingsRef& RegionBindingsConstRef;
 
 Optional<SVal> RegionBindingsRef::getDirectBinding(const MemRegion *R) const {
   return Optional<SVal>::create(lookup(R, BindingKey::Direct));
 }
public: // Part of public interface to class.
   //===------------------------------------------------------------------===//
 
   RegionBindingsRef getRegionBindings(Store store) const {
     return RegionBindingsRef(CBFactory,
                              static_cast<const RegionBindings::TreeTy*>(store),
                              RBFactory.getTreeFactory());
   }
 
-  void print(Store store, raw_ostream &Out, const char* nl) override;
+  void print(raw_ostream &Out, Store S, const char *NL = "\n",
+             const char *Sep = "") const override;
+
+  void printDiff(raw_ostream &Out, Store CurrentStore, Store PreviousStore,
+                 const char *NL = "\n", const char *Sep = "") const override;
 
   void iterBindings(Store store, BindingsHandler& f) override {
     RegionBindingsRef B = getRegionBindings(store);
     for (RegionBindingsRef::iterator I = B.begin(), E = B.end(); I != E; ++I) {
       const ClusterBindings &Cluster = I.getData();
       for (ClusterBindings::iterator CI = Cluster.begin(), CE = Cluster.end();
            CI != CE; ++CI) {
         const BindingKey &K = CI.getKey();
StoreRef RegionStoreManager::removeDeadBindings(Store store,
 
   return StoreRef(B.asStore(), *this);
 }
 
 //===----------------------------------------------------------------------===//
 // Utility methods.
 //===----------------------------------------------------------------------===//
 
-void RegionStoreManager::print(Store store, raw_ostream &OS,
-                               const char* nl) {
-  RegionBindingsRef B = getRegionBindings(store);
-  OS << "Store (direct and default bindings), "
-     << B.asStore()
-     << " :" << nl;
-  B.dump(OS, nl);
+void RegionStoreManager::print(raw_ostream &Out, Store S, const char *NL,
+                               const char *Sep) const {
+  RegionBindingsRef Bindings = getRegionBindings(S);
+
+  Out << Sep;
+  if (Bindings.isEmpty()) {
+    Out << "Store is empty." << NL;
+    return;
+  }
+
+  Out << "Store <" << Bindings.asStore() << ">:";
+  Bindings.print(Out, NL);
+}
+
+void RegionStoreManager::printDiff(raw_ostream &Out, Store CurrentStore,
+                                   Store PreviousStore, const char *NL,
+                                   const char *Sep) const {
+  RegionBindingsRef Bindings = getRegionBindings(CurrentStore);
+
+  Out << Sep;
+  if (Bindings.isEmpty()) {
+    Out << "Store is empty." << NL;
+    return;
+  }
+
+  Out << "Store <" << Bindings.asStore() << ">:";
+  Bindings.printDiff(Out, getRegionBindings(PreviousStore), NL);
 }