Callgraph

svf-llvm/include/SVF-LLVM/LLVMModule.h

@@ -105,6 +105,7 @@ class LLVMModuleSet
     InstToBlockNodeMapTy InstToBlockNodeMap; ///< map a basic block to its ICFGNode
     FunToFunEntryNodeMapTy FunToFunEntryNodeMap; ///< map a function to its FunExitICFGNode
     FunToFunExitNodeMapTy FunToFunExitNodeMap; ///< map a function to its FunEntryICFGNode
+    CallGraph* callgraph;
 
     /// Constructor
     LLVMModuleSet();

svf-llvm/lib/LLVMModule.cpp

@@ -41,6 +41,8 @@
 #include "SVF-LLVM/ObjTypeInference.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "SVF-LLVM/ICFGBuilder.h"
+#include "Graphs/CallGraph.h"
+#include "Util/CallGraphBuilder.h"
 
 using namespace std;
 using namespace SVF;
@@ -169,6 +171,9 @@ void LLVMModuleSet::build()
     initSVFFunction();
     ICFGBuilder icfgbuilder;
     icfg = icfgbuilder.build();
+
+    CallGraphBuilder callGraphBuilder;
+    callgraph = callGraphBuilder.buildSVFIRCallGraph(svfModule);
 }
 
 void LLVMModuleSet::createSVFDataStructure()

svf-llvm/lib/SVFIRBuilder.cpp

@@ -38,6 +38,7 @@
 #include "SVFIR/SVFFileSystem.h"
 #include "SVFIR/SVFModule.h"
 #include "SVFIR/SVFValue.h"
+#include "Util/CallGraphBuilder.h"
 #include "Util/Options.h"
 #include "Util/SVFUtil.h"
 
@@ -62,6 +63,9 @@ SVFIR* SVFIRBuilder::build()
     // Build ICFG
     pag->setICFG(llvmModuleSet()->getICFG());
 
+    // Set callgraph
+    pag->setCallGraph(llvmModuleSet()->callgraph);
+
     // Set icfgnode in memobj
     for (auto& it : SymbolTableInfo::SymbolInfo()->idToObjMap())
     {

svf/include/Graphs/CallGraph.h

@@ -189,6 +189,11 @@ class CallGraphNode : public GenericCallGraphNodeTy
 
     }
 
+    inline const std::string &getName() const
+    {
+        return fun->getName();
+    }
+
     /// Get function of this call node
     inline const SVFFunction* getFunction() const
     {
@@ -254,8 +259,6 @@ class CallGraph : public GenericCallGraphTy
     };
 
 private:
-    CGEK kind;
-
     /// Indirect call map
     CallEdgeMap indirectCallMap;
 
@@ -270,6 +273,7 @@ class CallGraph : public GenericCallGraphTy
 
     NodeID callGraphNodeNum;
     u32_t numOfResolvedIndCallEdge;
+    CGEK kind;
 
     /// Clean up memory
     void destroy();
@@ -278,7 +282,9 @@ class CallGraph : public GenericCallGraphTy
     /// Constructor
     CallGraph(CGEK k = NormCallGraph);
 
-    /// Add callgraph Node
+    /// Copy constructor
+    CallGraph(const CallGraph& other);
+
     void addCallGraphNode(const SVFFunction* fun);
 
     /// Destructor

svf/include/Graphs/ThreadCallGraph.h

@@ -172,7 +172,10 @@ class ThreadCallGraph: public CallGraph
     typedef Map<const CallICFGNode*, ParForEdgeSet> CallInstToParForEdgesMap;
 
     /// Constructor
-    ThreadCallGraph();
+    ThreadCallGraph(const CallGraph& cg);
+
+    ThreadCallGraph(ThreadCallGraph& cg) = delete;
+
     /// Destructor
     virtual ~ThreadCallGraph()
     {

svf/include/SVFIR/SVFIR.h

@@ -98,6 +98,7 @@ class SVFIR : public IRGraph
     ICFG* icfg; // ICFG
     CommonCHGraph* chgraph; // class hierarchy graph
     CallSiteSet callSiteSet; /// all the callsites of a program
+    CallGraph* callGraph; /// call graph
 
     static std::unique_ptr<SVFIR> pag;	///< Singleton pattern here to enable instance of SVFIR can only be created once.
 
@@ -182,6 +183,18 @@ class SVFIR : public IRGraph
         assert(chgraph && "empty ICFG! Build SVF IR first!");
         return chgraph;
     }
+
+    /// Set/Get CG
+    inline void setCallGraph(CallGraph* c)
+    {
+        callGraph = c;
+    }
+    inline CallGraph* getCallGraph()
+    {
+        assert(callGraph && "empty CallGraph! Build SVF IR first!");
+        return callGraph;
+    }
+
     /// Get/set methods to get SVFStmts based on their kinds and ICFGNodes
     //@{
     /// Get edges set according to its kind

svf/include/SVFIR/SVFModule.h

@@ -130,23 +130,6 @@ class SVFModule
 
     /// Iterators
     ///@{
-    iterator begin()
-    {
-        return FunctionSet.begin();
-    }
-    const_iterator begin() const
-    {
-        return FunctionSet.begin();
-    }
-    iterator end()
-    {
-        return FunctionSet.end();
-    }
-    const_iterator end() const
-    {
-        return FunctionSet.end();
-    }
-
     global_iterator global_begin()
     {
         return GlobalSet.begin();

svf/include/Util/CallGraphBuilder.h

@@ -38,34 +38,18 @@ namespace SVF
 {
 
 class ICFG;
+class SVFModule;
 
 class CallGraphBuilder
 {
-
-protected:
-    CallGraph* callgraph;
-    ICFG* icfg;
 public:
-    CallGraphBuilder(CallGraph* cg, ICFG* i): callgraph(cg),icfg(i)
-    {
-    }
-
-    /// Build normal callgraph
-    CallGraph* buildCallGraph(SVFModule* svfModule);
-
-};
+    CallGraphBuilder()=default;
 
-class ThreadCallGraphBuilder : public CallGraphBuilder
-{
-
-public:
-    ThreadCallGraphBuilder(ThreadCallGraph* cg, ICFG* i): CallGraphBuilder(cg,i)
-    {
-    }
+    /// Buidl SVFIR callgraoh
+    CallGraph* buildSVFIRCallGraph(SVFModule* svfModule);
 
     /// Build thread-aware callgraph
-    CallGraph* buildThreadCallGraph(SVFModule* svfModule);
-
+    ThreadCallGraph* buildThreadCallGraph();
 };
 
 } // End namespace SVF

svf/include/Util/SVFUtil.h

@@ -327,29 +327,11 @@ inline bool isProgEntryFunction(const SVFFunction* fun)
     return fun && fun->getName() == "main";
 }
 
-/// Get program entry function from module.
-inline const SVFFunction* getProgFunction(SVFModule* svfModule, const std::string& funName)
-{
-    for (SVFModule::const_iterator it = svfModule->begin(), eit = svfModule->end(); it != eit; ++it)
-    {
-        const SVFFunction *fun = *it;
-        if (fun->getName()==funName)
-            return fun;
-    }
-    return nullptr;
-}
+/// Get program entry function from function name.
+const SVFFunction* getProgFunction(const std::string& funName);
 
-/// Get program entry function from module.
-inline const SVFFunction* getProgEntryFunction(SVFModule* svfModule)
-{
-    for (SVFModule::const_iterator it = svfModule->begin(), eit = svfModule->end(); it != eit; ++it)
-    {
-        const SVFFunction *fun = *it;
-        if (isProgEntryFunction(fun))
-            return (fun);
-    }
-    return nullptr;
-}
+/// Get program entry function.
+const SVFFunction* getProgEntryFunction();
 
 /// Return true if this is a program exit function call
 //@{

svf/lib/Graphs/CallGraph.cpp

@@ -112,6 +112,38 @@ CallGraph::CallGraph(CGEK k): kind(k)
     numOfResolvedIndCallEdge = 0;
 }
 
+/// Copy constructor
+CallGraph::CallGraph(const CallGraph& other) {
+    callGraphNodeNum = other.callGraphNodeNum;
+    numOfResolvedIndCallEdge = 0;
+    kind = other.kind;
+
+    /// copy call graph nodes
+    for (const auto& item : other)
+    {
+        const CallGraphNode* cgn = item.second;
+        CallGraphNode* callGraphNode = new CallGraphNode(cgn->getId(), cgn->getFunction());
+        addGNode(cgn->getId(),callGraphNode);
+        funToCallGraphNodeMap[cgn->getFunction()] = callGraphNode;
+    }
+
+    /// copy edges
+    for (const auto& item : other.callinstToCallGraphEdgesMap)
+    {
+        const CallICFGNode* cs = item.first;
+        for (const CallGraphEdge* edge : item.second)
+        {
+            CallGraphNode* src = getCallGraphNode(edge->getSrcID());
+            CallGraphNode* dst = getCallGraphNode(edge->getDstID());
+            CallGraphEdge* newEdge = new CallGraphEdge(src,dst,CallGraphEdge::CallRetEdge,edge->getCallSiteID());
+            newEdge->addDirectCallSite(cs);
+            addEdge(newEdge);
+            callinstToCallGraphEdgesMap[cs].insert(newEdge);
+        }
+    }
+
+}
+
 /*!
  *  Memory has been cleaned up at GenericGraph
  */
@@ -122,12 +154,11 @@ void CallGraph::destroy()
 /*!
  * Add call graph node
  */
-void CallGraph::addCallGraphNode(const SVFFunction* fun)
-{
-    NodeID id = callGraphNodeNum;
-    CallGraphNode* callGraphNode = new CallGraphNode(id, fun);
-    addGNode(id,callGraphNode);
-    funToCallGraphNodeMap[fun] = callGraphNode;
+void CallGraph::addCallGraphNode(const SVFFunction* fun) {
+    NodeID id  = callGraphNodeNum;
+    CallGraphNode *callGraphNode = new CallGraphNode(id, fun);
+    addGNode(id, callGraphNode);
+    funToCallGraphNodeMap[callGraphNode->getFunction()] = callGraphNode;
     callGraphNodeNum++;
 }
 

svf/lib/Graphs/SVFG.cpp

@@ -427,9 +427,7 @@ void SVFG::connectIndirectSVFGEdges()
  */
 void SVFG::connectFromGlobalToProgEntry()
 {
-    SVFModule* svfModule = mssa->getPTA()->getModule();
-    const SVFFunction* mainFunc =
-        SVFUtil::getProgEntryFunction(svfModule);
+    const SVFFunction* mainFunc = SVFUtil::getProgEntryFunction();
     FormalINSVFGNodeSet& formalIns = getFormalINSVFGNodes(mainFunc);
     if (formalIns.empty())
         return;

svf/lib/Graphs/ThreadCallGraph.cpp

@@ -39,9 +39,10 @@ using namespace SVFUtil;
 /*!
  * Constructor
  */
-ThreadCallGraph::ThreadCallGraph() :
-    CallGraph(ThdCallGraph), tdAPI(ThreadAPI::getThreadAPI())
+ThreadCallGraph::ThreadCallGraph(const CallGraph& cg) :
+    CallGraph(cg), tdAPI(ThreadAPI::getThreadAPI())
 {
+    kind = ThdCallGraph;
     DBOUT(DGENERAL, outs() << SVFUtil::pasMsg("Building ThreadCallGraph\n"));
 }
 

svf/lib/MSSA/MemRegion.cpp

@@ -173,11 +173,10 @@ SVFIR::SVFStmtList& MRGenerator::getPAGEdgesFromInst(const ICFGNode* node)
 void MRGenerator::collectModRefForLoadStore()
 {
 
-    SVFModule* svfModule = pta->getModule();
-    for (SVFModule::const_iterator fi = svfModule->begin(), efi = svfModule->end(); fi != efi;
-            ++fi)
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    for (const auto& item: *svfirCallGraph)
     {
-        const SVFFunction& fun = **fi;
+        const SVFFunction& fun = *item.second->getFunction();
 
         /// if this function does not have any caller, then we do not care its MSSA
         if (Options::IgnoreDeadFun() && fun.isUncalledFunction())

svf/lib/MSSA/MemSSA.cpp

@@ -575,10 +575,10 @@ u32_t MemSSA::getBBPhiNum() const
 void MemSSA::dumpMSSA(OutStream& Out)
 {
 
-    for (SVFModule::iterator fit = pta->getModule()->begin(), efit = pta->getModule()->end();
-            fit != efit; ++fit)
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    for (const auto& item: *svfirCallGraph)
     {
-        const SVFFunction* fun = *fit;
+        const SVFFunction* fun = item.second->getFunction();
         if(Options::MSSAFun()!="" && Options::MSSAFun()!=fun->getName())
             continue;
 

svf/lib/MSSA/SVFGBuilder.cpp

@@ -101,12 +101,11 @@ std::unique_ptr<MemSSA> SVFGBuilder::buildMSSA(BVDataPTAImpl* pta, bool ptrOnlyM
 
     auto mssa = std::make_unique<MemSSA>(pta, ptrOnlyMSSA);
 
-    SVFModule* svfModule = mssa->getPTA()->getModule();
-    for (SVFModule::const_iterator iter = svfModule->begin(), eiter = svfModule->end();
-            iter != eiter; ++iter)
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    for (const auto& item: *svfirCallGraph)
     {
 
-        const SVFFunction *fun = *iter;
+        const SVFFunction *fun = item.second->getFunction();
         if (isExtCall(fun))
             continue;
 

svf/lib/MTA/TCT.cpp

@@ -185,9 +185,10 @@ void TCT::markRelProcs(const SVFFunction* svffun)
  */
 void TCT::collectEntryFunInCallGraph()
 {
-    for(SVFModule::const_iterator it = getSVFModule()->begin(), eit = getSVFModule()->end(); it!=eit; ++it)
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    for (const auto& item: *svfirCallGraph)
     {
-        const SVFFunction* fun = (*it);
+        const SVFFunction* fun = item.second->getFunction();
         if (SVFUtil::isExtCall(fun))
             continue;
         CallGraphNode* node = tcg->getCallGraphNode(fun);

svf/lib/MemoryModel/PointerAnalysis.cpp

@@ -111,15 +111,13 @@ void PointerAnalysis::initialize()
     /// initialise pta call graph for every pointer analysis instance
     if(Options::EnableThreadCallGraph())
     {
-        ThreadCallGraph* cg = new ThreadCallGraph();
-        ThreadCallGraphBuilder bd(cg, pag->getICFG());
-        callgraph = bd.buildThreadCallGraph(pag->getModule());
+        CallGraphBuilder bd;
+        callgraph = bd.buildThreadCallGraph();
     }
     else
     {
-        CallGraph* cg = new CallGraph();
-        CallGraphBuilder bd(cg,pag->getICFG());
-        callgraph = bd.buildCallGraph(pag->getModule());
+        CallGraph* cg = pag->getCallGraph();
+        callgraph = new CallGraph(*cg);
     }
     callGraphSCCDetection();
 

svf/lib/SABER/SaberCondAllocator.cpp

@@ -59,8 +59,10 @@ void SaberCondAllocator::allocate(const SVFModule *M)
 {
     DBOUT(DGENERAL, outs() << pasMsg("path condition allocation starts\n"));
 
-    for (const auto &func: *M)
+    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    for (const auto& item: *svfirCallGraph)
     {
+        const SVFFunction *func = (item.second)->getFunction();
         if (!SVFUtil::isExtCall(func))
         {
             // Allocate conditions for a program.