ICFG Optimizations -- graph merging and others.

The largest change performance wise is the change to the graph type to
use a vector for edge storage.

The merge function now mirrors the changes to the Points-To class to
avoid re-building the FunctionVertexMap from scratch.

Changes in constructionWalker avoid fetching the same data multiple
times back-to-back.

printAsDot was modified to allow the user to skip the edge labels,
because those are quite expensive.  Moved code out of the header that is
only used internally to this function body.


ProjectIRDB.h does not use the LLVMPointsToGraph.h, so it was removed
which necessitated several other header changes.

Author: ddiepo-pjr

include/phasar/DB/ProjectIRDB.h

@@ -20,7 +20,6 @@
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/IR/Module.h>
 
-#include <phasar/PhasarLLVM/Pointer/LLVMPointsToGraph.h>
 #include <phasar/Utils/EnumFlags.h>
 
 namespace llvm {

include/phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h

@@ -88,7 +88,7 @@ class LLVMBasedICFG
   };
 
   /// Specify the type of graph to be used.
-  typedef boost::adjacency_list<boost::multisetS, boost::vecS,
+  typedef boost::adjacency_list<boost::vecS, boost::vecS,
                                 boost::bidirectionalS, VertexProperties,
                                 EdgeProperties>
       bidigraph_t;
@@ -106,7 +106,7 @@ class LLVMBasedICFG
   /// Maps function names to the corresponding vertex id.
   std::unordered_map<const llvm::Function *, vertex_t> FunctionVertexMap;
 
-  void constructionWalker(const llvm::Function *F, Resolver *Res);
+  void constructionWalker(const llvm::Function *F, Resolver &Resolver);
 
   struct dependency_visitor;
 
@@ -162,44 +162,7 @@ class LLVMBasedICFG
   using LLVMBasedCFG::print; // tell the compiler we wish to have both prints
   void print(std::ostream &OS = std::cout) const override;
 
-  // provide a VertexPropertyWrite to tell boost how to write a vertex
-  class CallGraphVertexWriter {
-  public:
-    CallGraphVertexWriter(const bidigraph_t &CGraph) : CGraph(CGraph) {}
-    template <class VertexOrEdge>
-    void operator()(std::ostream &out, const VertexOrEdge &v) const {
-      out << "[label=\"" << CGraph[v].getFunctionName() << "\"]";
-    }
-
-  private:
-    const bidigraph_t &CGraph;
-  };
-
-  // a function to conveniently create the vertex writer
-  CallGraphVertexWriter
-  makeCallGraphVertexWriter(const bidigraph_t &CGraph) const {
-    return CallGraphVertexWriter(CGraph);
-  }
-
-  // provide a EdgePropertyWrite to tell boost how to write an edge
-  class CallGraphEdgeWriter {
-  public:
-    CallGraphEdgeWriter(const bidigraph_t &CGraph) : CGraph(CGraph) {}
-    template <class VertexOrEdge>
-    void operator()(std::ostream &out, const VertexOrEdge &v) const {
-      out << "[label=\"" << CGraph[v].getCallSiteAsString() << "\"]";
-    }
-
-  private:
-    const bidigraph_t &CGraph;
-  };
-
-  // a function to conveniently create the edge writer
-  CallGraphEdgeWriter makeCallGraphEdgeWriter(const bidigraph_t &CGraph) const {
-    return CallGraphEdgeWriter(CGraph);
-  }
-
-  void printAsDot(std::ostream &OS = std::cout) const;
+  void printAsDot(std::ostream &OS = std::cout, bool printEdgeLabels = true) const;
 
   void printInternalPTGAsDot(std::ostream &OS = std::cout) const;
 

lib/DB/ProjectIRDB.cpp

@@ -28,6 +28,7 @@
 
 #include <boost/filesystem.hpp>
 
+#include <phasar/Config/Configuration.h>
 #include <phasar/DB/ProjectIRDB.h>
 #include <phasar/PhasarLLVM/DataFlowSolver/IfdsIde/LLVMZeroValue.h>
 #include <phasar/PhasarLLVM/Passes/GeneralStatisticsAnalysis.h>

lib/PhasarLLVM/ControlFlow/LLVMBasedICFG.cpp

@@ -143,7 +143,7 @@ LLVMBasedICFG::LLVMBasedICFG(ProjectIRDB &IRDB, CallGraphAnalysisType CGType,
       PointsToGraph *PTG = PT->getPointsToGraph(F);
       WholeModulePTG.mergeWith(PTG, F);
     }
-    constructionWalker(F, Res.get());
+    constructionWalker(F, *Res.get());
   }
   REG_COUNTER("WM-PTG Vertices", WholeModulePTG.getNumOfVertices(),
               PAMM_SEVERITY_LEVEL::Full);
@@ -166,29 +166,33 @@ LLVMBasedICFG::~LLVMBasedICFG() {
 }
 
 void LLVMBasedICFG::constructionWalker(const llvm::Function *F,
-                                       Resolver *Resolver) {
+                                       Resolver &Resolver) {
   PAMM_GET_INSTANCE;
   auto &lg = lg::get();
   LOG_IF_ENABLE(BOOST_LOG_SEV(lg, DEBUG)
                 << "Walking in function: " << F->getName().str());
-  if (VisitedFunctions.count(F) || F->isDeclaration()) {
+  if (F->isDeclaration() || !VisitedFunctions.insert(F).second ) {
     LOG_IF_ENABLE(BOOST_LOG_SEV(lg, DEBUG)
                   << "Function already visited or only declaration: "
                   << F->getName().str());
     return;
   }
-  VisitedFunctions.insert(F);
 
   // add a node for function F to the call graph (if not present already)
-  if (!FunctionVertexMap.count(F)) {
-    FunctionVertexMap[F] = boost::add_vertex(CallGraph);
-    CallGraph[FunctionVertexMap[F]] = VertexProperties(F);
+  vertex_t thisFunctionVertexDescriptor;
+  auto fvmItr = FunctionVertexMap.find(F);
+  if (fvmItr != FunctionVertexMap.end())
+    thisFunctionVertexDescriptor = fvmItr->second;
+  else {
+    thisFunctionVertexDescriptor = boost::add_vertex(VertexProperties(F), CallGraph);
+    FunctionVertexMap[F] = thisFunctionVertexDescriptor;
   }
+
   // iterate all instructions of the current function
   for (auto &BB : *F) {
     for (auto &I : BB) {
       if (llvm::isa<llvm::CallInst>(I) || llvm::isa<llvm::InvokeInst>(I)) {
-        Resolver->preCall(&I);
+        Resolver.preCall(&I);
 
         llvm::ImmutableCallSite cs(&I);
         set<const llvm::Function *> possible_targets;
@@ -200,10 +204,11 @@ void LLVMBasedICFG::constructionWalker(const llvm::Function *F,
                         << "  " << llvmIRToString(cs.getInstruction()));
         } else {
           // still try to resolve the called function statically
-          const llvm::Value *v = cs.getCalledValue();
-          const llvm::Value *sv = v->stripPointerCasts();
-          if (sv->hasName() && IRDB.getFunction(sv->getName())) {
-            possible_targets.insert(IRDB.getFunction(sv->getName()));
+          const llvm::Value *sv = cs.getCalledValue()->stripPointerCasts();
+          const llvm::Function *valueFunction =
+              !sv->hasName() ? nullptr : IRDB.getFunction(sv->getName());
+          if (valueFunction) {
+            possible_targets.insert(valueFunction);
             LOG_IF_ENABLE(BOOST_LOG_SEV(lg, DEBUG)
                           << "Found static call-site: "
                           << llvmIRToString(cs.getInstruction()));
@@ -215,9 +220,9 @@ void LLVMBasedICFG::constructionWalker(const llvm::Function *F,
                           << "  " << llvmIRToString(cs.getInstruction()));
             // call the resolve routine
             if (isVirtualFunctionCall(cs.getInstruction())) {
-              possible_targets = Resolver->resolveVirtualCall(cs);
+              possible_targets = Resolver.resolveVirtualCall(cs);
             } else {
-              possible_targets = Resolver->resolveFunctionPointer(cs);
+              possible_targets = Resolver.resolveFunctionPointer(cs);
             }
           }
         }
@@ -226,18 +231,19 @@ void LLVMBasedICFG::constructionWalker(const llvm::Function *F,
                       << "Found " << possible_targets.size()
                       << " possible target(s)");
 
-        Resolver->handlePossibleTargets(cs, possible_targets);
+        Resolver.handlePossibleTargets(cs, possible_targets);
         // Insert possible target inside the graph and add the link with
         // the current function
         for (auto &possible_target : possible_targets) {
-          auto target = possible_target;
-          if (!FunctionVertexMap.count(target)) {
-            FunctionVertexMap[target] = boost::add_vertex(CallGraph);
-            CallGraph[FunctionVertexMap[target]] =
-                VertexProperties(possible_target);
+          vertex_t targetVertex;
+          auto targetFvmItr = FunctionVertexMap.find(possible_target);
+          if (targetFvmItr != FunctionVertexMap.end())
+            targetVertex = targetFvmItr->second;
+          else {
+            targetVertex = boost::add_vertex(VertexProperties(possible_target), CallGraph);
+            FunctionVertexMap[possible_target] = targetVertex;
           }
-
-          boost::add_edge(FunctionVertexMap[F], FunctionVertexMap[target],
+          boost::add_edge(thisFunctionVertexDescriptor, targetVertex,
                           EdgeProperties(cs.getInstruction()), CallGraph);
         }
 
@@ -246,9 +252,9 @@ void LLVMBasedICFG::constructionWalker(const llvm::Function *F,
           constructionWalker(possible_target, Resolver);
         }
 
-        Resolver->postCall(&I);
+        Resolver.postCall(&I);
       } else {
-        Resolver->otherInst(&I);
+        Resolver.otherInst(&I);
       }
     }
   }
@@ -446,23 +452,14 @@ LLVMBasedICFG::getLastInstructionOf(const string &name) {
 }
 
 void LLVMBasedICFG::mergeWith(const LLVMBasedICFG &other) {
-  // Copy other graph into this graph
-  typedef typename boost::property_map<bidigraph_t, boost::vertex_index_t>::type
-      index_map_t;
-  // For simple adjacency_list<> this type would be more efficient:
-  typedef typename boost::iterator_property_map<
-      typename std::vector<LLVMBasedICFG::vertex_t>::iterator, index_map_t,
-      LLVMBasedICFG::vertex_t, LLVMBasedICFG::vertex_t &>
-      IsoMap;
-  // For more generic graphs, one can try typedef std::map<vertex_t, vertex_t>
-  // IsoMap;
-  vector<LLVMBasedICFG::vertex_t> orig2copy_data(
-      boost::num_vertices(other.CallGraph));
-  IsoMap mapV = boost::make_iterator_property_map(
-      orig2copy_data.begin(), get(boost::vertex_index, other.CallGraph));
-  boost::copy_graph(other.CallGraph, CallGraph,
-                    boost::orig_to_copy(mapV)); // means g1 += g2
-  // This vector hols the call-sites that are used to merge the whole-module
+  typedef bidigraph_t::vertex_descriptor vertex_t;
+  typedef std::map<vertex_t, vertex_t> vertex_map_t;
+  vertex_map_t oldToNewVertexMapping;
+  boost::associative_property_map<vertex_map_t> vertexMapWrapper(
+      oldToNewVertexMapping);
+  boost::copy_graph(other.CallGraph, CallGraph, boost::orig_to_copy(vertexMapWrapper));
+
+  // This vector holds the call-sites that are used to merge the whole-module
   // points-to graphs
   vector<pair<llvm::ImmutableCallSite, const llvm::Function *>> Calls;
   vertex_iterator vi_v, vi_v_end, vi_u, vi_u_end;
@@ -494,12 +491,16 @@ void LLVMBasedICFG::mergeWith(const LLVMBasedICFG &other) {
       }
     }
   }
-  // Update the FunctionVertexMap
-  FunctionVertexMap.clear();
-  for (boost::tie(vi_v, vi_v_end) = boost::vertices(CallGraph);
-       vi_v != vi_v_end; ++vi_v) {
-    FunctionVertexMap.insert(make_pair(CallGraph[*vi_v].F, *vi_v));
+
+  // Update the FunctionVertexMap:
+  for (const auto &otherValues : other.FunctionVertexMap) {
+    auto mappingIter = oldToNewVertexMapping.find(otherValues.second);
+    if (mappingIter != oldToNewVertexMapping.end()) {
+      FunctionVertexMap.insert(
+          make_pair(otherValues.first, mappingIter->second));
+    }
   }
+
   // Merge the already visited functions
   VisitedFunctions.insert(other.VisitedFunctions.begin(),
                           other.VisitedFunctions.end());
@@ -535,9 +536,44 @@ void LLVMBasedICFG::print(ostream &OS) const {
   }
 }
 
-void LLVMBasedICFG::printAsDot(std::ostream &OS) const {
-  boost::write_graphviz(OS, CallGraph, makeCallGraphVertexWriter(CallGraph),
-                        makeCallGraphEdgeWriter(CallGraph));
+namespace {
+template <class graphType>
+class VertexWriter {
+public:
+  VertexWriter(const graphType &CGraph) : CGraph(CGraph) {}
+  template <class VertexOrEdge>
+  void operator()(std::ostream &out, const VertexOrEdge &v) const {
+    out << "[label=\"" << CGraph[v].getFunctionName() << "\"]";
+  }
+
+private:
+  const graphType &CGraph;
+};
+
+template <class graphType>
+class EdgeLabelWriter {
+public:
+  EdgeLabelWriter(const graphType &CGraph) : CGraph(CGraph) {}
+  template <class VertexOrEdge>
+  void operator()(std::ostream &out, const VertexOrEdge &v) const {
+    out << "[label=\"" << CGraph[v].getCallSiteAsString() << "\"]";
+  }
+
+private:
+  const graphType &CGraph;
+};
+}
+
+void LLVMBasedICFG::printAsDot(std::ostream &OS, bool printEdgeLabels) const {
+  if (printEdgeLabels) {
+  boost::write_graphviz(OS, CallGraph,
+                        VertexWriter<bidigraph_t>(CallGraph),
+                        EdgeLabelWriter<bidigraph_t>(CallGraph));
+  } else {
+    boost::write_graphviz(OS, CallGraph,
+                          VertexWriter<bidigraph_t>(CallGraph));
+
+  }
 }
 
 void LLVMBasedICFG::printInternalPTGAsDot(std::ostream &OS) const {

lib/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.cpp

@@ -35,6 +35,7 @@
 #include <llvm/IR/Instructions.h>
 #include <llvm/IR/Module.h>
 
+#include <phasar/Config/Configuration.h>
 #include <phasar/DB/ProjectIRDB.h>
 #include <phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h>
 #include <phasar/Utils/GraphExtensions.h>

unittests/PhasarLLVM/ControlFlow/LLVMBasedBackwardCFGTest.cpp

@@ -1,5 +1,8 @@
 #include <gtest/gtest.h>
 #include <llvm/IR/InstIterator.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/Instructions.h>
+#include <phasar/Config/Configuration.h>
 #include <phasar/DB/ProjectIRDB.h>
 #include <phasar/PhasarLLVM/ControlFlow/LLVMBasedBackwardCFG.h>
 #include <phasar/Utils/LLVMShorthands.h>

unittests/PhasarLLVM/ControlFlow/LLVMBasedCFGTest.cpp

@@ -1,5 +1,8 @@
 #include <gtest/gtest.h>
 #include <llvm/IR/InstIterator.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/Instructions.h>
+#include <phasar/Config/Configuration.h>
 #include <phasar/DB/ProjectIRDB.h>
 #include <phasar/PhasarLLVM/ControlFlow/LLVMBasedCFG.h>
 #include <phasar/Utils/LLVMShorthands.h>

unittests/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchyTest.cpp

@@ -6,6 +6,7 @@
 
 #include <gtest/gtest.h>
 
+#include <phasar/Config/Configuration.h>
 #include <phasar/DB/ProjectIRDB.h>
 #include <phasar/PhasarLLVM/TypeHierarchy/LLVMTypeHierarchy.h>
 #include <phasar/Utils/LLVMShorthands.h>

unittests/PhasarLLVM/TypeHierarchy/TypeGraphTest.cpp

@@ -4,6 +4,7 @@
 #include <phasar/PhasarLLVM/Pointer/TypeGraphs/LazyTypeGraph.h>
 
 #include <boost/graph/isomorphism.hpp>
+#include <phasar/Config/Configuration.h>
 #include <phasar/Utils/LLVMShorthands.h>
 #include <phasar/Utils/Utilities.h>
 

unittests/Utils/LLVMShorthandsTest.cpp

@@ -1,4 +1,7 @@
 #include <gtest/gtest.h>
+#include <llvm/IR/Function.h>
+#include <llvm/IR/Instructions.h>
+#include <phasar/Config/Configuration.h>
 #include <phasar/DB/ProjectIRDB.h>
 #include <phasar/Utils/LLVMShorthands.h>
 #include <phasar/Utils/Utilities.h>