svf-tools 1.0.1039 → 1.0.1041

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.1039",
+  "version": "1.0.1041",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf/include/AE/Svfexe/AbstractInterpretation.h

@@ -251,8 +251,8 @@ private:
     AEStat* stat;
 
     std::vector<const CallICFGNode*> callSiteStack;
-    Map<const CallGraphNode*, ICFGWTO*> funcToWTO;
-    Set<const CallGraphNode*> recursiveFuns;
+    Map<const SVFFunction*, ICFGWTO*> funcToWTO;
+    Set<const SVFFunction*> recursiveFuns;
 
 
     AbstractState& getAbsStateFromTrace(const ICFGNode* node)

package/svf/include/Graphs/PTACallGraph.h

@@ -302,7 +302,7 @@ public:
     PTACallGraph(CGEK k = NormCallGraph);
 
     /// Copy constructor
-    PTACallGraph(const CallGraph& other);
+    PTACallGraph(const PTACallGraph& other);
 
     /// Destructor
     virtual ~PTACallGraph()
@@ -351,8 +351,16 @@ public:
     /// Issue a warning if the function which has indirect call sites can not be reached from program entry.
     void verifyCallGraph();
 
+    /// Add direct call edges
+    void addDirectCallGraphEdge(const CallICFGNode* call, const SVFFunction* callerFun, const SVFFunction* calleeFun);
+
+    void addCallGraphNode(const SVFFunction* fun);
+
     /// Get call graph node
     //@{
+
+    const PTACallGraphNode* getCallGraphNode(const std::string& name);
+
     inline PTACallGraphNode* getCallGraphNode(NodeID id) const
     {
         return getGNode(id);

package/svf/include/Graphs/SCC.h

@@ -130,12 +130,17 @@ public:
         return _T;
     }
 
+    inline const GNodeStack& topoNodeStack() const
+    {
+        return _T;
+    }
+
     /// Return a handle to the stack of nodes in reverse topological
     /// order. This will be used to seed the initial solution
     /// and improve efficiency.
-    inline GNodeStack revTopoNodeStack()
+    inline FIFOWorkList<NodeID> revTopoNodeStack() const
     {
-        GNodeStack revTopoOrder;
+        FIFOWorkList<NodeID> revTopoOrder;
         GNodeStack topoOrder = topoNodeStack();
         while(!topoOrder.empty())
         {

package/svf/include/Graphs/ThreadCallGraph.h

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

package/svf/include/MSSA/MemRegion.h

@@ -268,8 +268,6 @@ private:
     /// Get all the objects in callee's modref escaped via global objects (the chain pts of globals)
     void getEscapObjviaGlobals(NodeBS& globs, const NodeBS& pts);
 
-    /// Get reverse topo call graph scc
-    void getCallGraphSCCRevTopoOrder(WorkList& worklist);
 
 protected:
     MRGenerator(BVDataPTAImpl* p, bool ptrOnly);

package/svf/include/SVFIR/SVFIR.h

@@ -35,7 +35,6 @@
 namespace SVF
 {
 class CommonCHGraph;
-class CallGraph;
 /*!
  * SVF Intermediate representation, representing variables and statements as a Program Assignment Graph (PAG)
  * Variables as nodes and statements as edges.
@@ -62,7 +61,7 @@ public:
     typedef Map<const CallICFGNode*,SVFVarList> CSToArgsListMap;
     typedef Map<const RetICFGNode*,const SVFVar*> CSToRetMap;
     typedef Map<const SVFFunction*,const SVFVar*> FunToRetMap;
-    typedef Map<const CallGraphNode*,const FunObjVar *> FunToFunObjVarMap;
+    typedef Map<const SVFFunction*,const FunObjVar *> FunToFunObjVarMap;
     typedef Map<const SVFFunction*,SVFStmtSet> FunToPAGEdgeSetMap;
     typedef Map<const ICFGNode*,SVFStmtList> ICFGNode2SVFStmtsMap;
     typedef Map<NodeID, NodeID> NodeToNodeMap;
@@ -100,7 +99,7 @@ private:
     ICFG* icfg; // ICFG
     CommonCHGraph* chgraph; // class hierarchy graph
     CallSiteSet callSiteSet; /// all the callsites of a program
-    CallGraph* callGraph; /// call graph
+    PTACallGraph* callGraph; /// call graph
 
     static std::unique_ptr<SVFIR> pag;	///< Singleton pattern here to enable instance of SVFIR can only be created once.
 
@@ -187,11 +186,11 @@ public:
     }
 
     /// Set/Get CG
-    inline void setCallGraph(CallGraph* c)
+    inline void setCallGraph(PTACallGraph* c)
     {
         callGraph = c;
     }
-    inline CallGraph* getCallGraph()
+    inline PTACallGraph* getCallGraph()
     {
         assert(callGraph && "empty CallGraph! Build SVF IR first!");
         return callGraph;
@@ -331,7 +330,7 @@ public:
     }
     //@}
 
-    inline const FunObjVar* getFunObjVar(const CallGraphNode*  node) const
+    inline const FunObjVar* getFunObjVar(const SVFFunction*  node) const
     {
         FunToFunObjVarMap::const_iterator it = funToFunObjvarMap.find(node);
         assert(it != funToFunObjvarMap.end() && "this function doesn't have funobjvar");
@@ -547,13 +546,13 @@ private:
         return addValNode(node);
     }
 
-    NodeID addFunValNode(NodeID i, const ICFGNode* icfgNode, const CallGraphNode* callGraphNode, const SVFType* type)
+    NodeID addFunValNode(NodeID i, const ICFGNode* icfgNode, const SVFFunction* callGraphNode, const SVFType* type)
     {
         FunValVar* node = new FunValVar(i, icfgNode, callGraphNode, type);
         return addValNode(node);
     }
 
-    NodeID addArgValNode(NodeID i, u32_t argNo, const ICFGNode* icfgNode, const CallGraphNode* callGraphNode, const SVFType* type)
+    NodeID addArgValNode(NodeID i, u32_t argNo, const ICFGNode* icfgNode, const SVFFunction* callGraphNode, const SVFType* type)
     {
         ArgValVar* node =
             new ArgValVar(i, argNo, icfgNode, callGraphNode, type);
@@ -625,7 +624,7 @@ private:
         return addObjNode(stackObj);
     }
 
-    NodeID addFunObjNode(NodeID id,  ObjTypeInfo* ti, const CallGraphNode* callGraphNode, const SVFType* type, const ICFGNode* node)
+    NodeID addFunObjNode(NodeID id,  ObjTypeInfo* ti, const SVFFunction* callGraphNode, const SVFType* type, const ICFGNode* node)
     {
         memToFieldsMap[id].set(id);
         FunObjVar* funObj = new FunObjVar(id, ti, callGraphNode, type, node);
@@ -678,13 +677,13 @@ private:
     }
 
     /// Add a unique return node for a procedure
-    inline NodeID addRetNode(NodeID i, const CallGraphNode* callGraphNode, const SVFType* type, const ICFGNode* icn)
+    inline NodeID addRetNode(NodeID i, const SVFFunction* callGraphNode, const SVFType* type, const ICFGNode* icn)
     {
         SVFVar *node = new RetValPN(i, callGraphNode, type, icn);
         return addRetNode(callGraphNode, node);
     }
     /// Add a unique vararg node for a procedure
-    inline NodeID addVarargNode(NodeID i, const CallGraphNode* val, const SVFType* type, const ICFGNode* n)
+    inline NodeID addVarargNode(NodeID i, const SVFFunction* val, const SVFType* type, const ICFGNode* n)
     {
         SVFVar *node = new VarArgValPN(i, val, type, n);
         return addNode(node);
@@ -758,7 +757,7 @@ private:
         return addNode(node);
     }
     /// Add a unique return node for a procedure
-    inline NodeID addRetNode(const CallGraphNode*, SVFVar *node)
+    inline NodeID addRetNode(const SVFFunction*, SVFVar *node)
     {
         return addNode(node);
     }

package/svf/include/SVFIR/SVFValue.h

@@ -320,14 +320,9 @@ private:
     const SVFFunction* realDefFun;  /// the definition of a function across multiple modules
     std::vector<const ArgValVar*> allArgs;    /// all formal arguments of this function
     SVFBasicBlock *exitBlock;             /// a 'single' basic block having no successors and containing return instruction in a function
-    const CallGraphNode *callGraphNode;          /// call graph node for this function
     BasicBlockGraph* bbGraph; /// the basic block graph of this function
 
 protected:
-    inline void setCallGraphNode(CallGraphNode *cgn)
-    {
-        callGraphNode = cgn;
-    }
 
     inline void addArgument(const ArgValVar* arg)
     {
@@ -355,11 +350,6 @@ public:
     SVFFunction(void) = delete;
     virtual ~SVFFunction();
 
-    inline const CallGraphNode* getCallGraphNode() const
-    {
-        return callGraphNode;
-    }
-
     static inline bool classof(const SVFValue *node)
     {
         return node->getKind() == SVFFunc;

package/svf/include/SVFIR/SVFVariables.h

@@ -366,7 +366,7 @@ class ArgValVar: public ValVar
     friend class SVFIRReader;
 
 private:
-    const CallGraphNode* cgNode;
+    const SVFFunction* cgNode;
     u32_t argNo;
 
 protected:
@@ -399,7 +399,7 @@ public:
     //@}
 
     /// Constructor
-    ArgValVar(NodeID i, u32_t argNo, const ICFGNode* icn, const CallGraphNode* callGraphNode,
+    ArgValVar(NodeID i, u32_t argNo, const ICFGNode* icn, const SVFFunction* callGraphNode,
               const SVFType* svfType);
 
     /// Return name of a LLVM value
@@ -968,7 +968,7 @@ class FunValVar : public ValVar
     friend class SVFIRWriter;
     friend class SVFIRReader;
 private:
-    const CallGraphNode* callGraphNode;
+    const SVFFunction* callGraphNode;
 
 public:
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -995,13 +995,13 @@ public:
     }
     //@}
 
-    inline const CallGraphNode* getCallGraphNode() const
+    inline virtual const SVFFunction* getFunction() const
     {
         return callGraphNode;
     }
 
     /// Constructor
-    FunValVar(NodeID i, const ICFGNode* icn, const CallGraphNode* cgn, const SVFType* svfType);
+    FunValVar(NodeID i, const ICFGNode* icn, const SVFFunction* cgn, const SVFType* svfType);
 
 
     virtual bool isPointer() const
@@ -1018,7 +1018,7 @@ class FunObjVar : public BaseObjVar
     friend class SVFIRReader;
 
 private:
-    const CallGraphNode* callGraphNode;
+    const SVFFunction* callGraphNode;
 
 private:
     /// Constructor to create empty ObjVar (for SVFIRReader/deserialization)
@@ -1054,9 +1054,9 @@ public:
     //@}
 
     /// Constructor
-    FunObjVar(NodeID i, ObjTypeInfo* ti, const CallGraphNode* cgNode, const SVFType* svfType, const ICFGNode* node);
+    FunObjVar(NodeID i, ObjTypeInfo* ti, const SVFFunction* cgNode, const SVFType* svfType, const ICFGNode* node);
 
-    inline const CallGraphNode* getCallGraphNode() const
+    inline const SVFFunction* getCallGraphNode() const
     {
         return callGraphNode;
     }
@@ -1782,7 +1782,7 @@ class RetValPN : public ValVar
     friend class SVFIRReader;
 
 private:
-    const CallGraphNode* callGraphNode;
+    const SVFFunction* callGraphNode;
 private:
     /// Constructor to create empty RetValPN (for SVFIRReader/deserialization)
     RetValPN(NodeID i) : ValVar(i, RetValNode) {}
@@ -1813,9 +1813,9 @@ public:
 
 
     /// Constructor
-    RetValPN(NodeID i, const CallGraphNode* node, const SVFType* svfType, const ICFGNode* icn);
+    RetValPN(NodeID i, const SVFFunction* node, const SVFType* svfType, const ICFGNode* icn);
 
-    inline const CallGraphNode* getCallGraphNode() const
+    inline const SVFFunction* getCallGraphNode() const
     {
         return callGraphNode;
     }
@@ -1838,7 +1838,7 @@ class VarArgValPN : public ValVar
     friend class SVFIRWriter;
     friend class SVFIRReader;
 private:
-    const CallGraphNode* callGraphNode;
+    const SVFFunction* callGraphNode;
 
 private:
     /// Constructor to create empty VarArgValPN (for SVFIRReader/deserialization)
@@ -1869,7 +1869,7 @@ public:
     //@}
 
     /// Constructor
-    VarArgValPN(NodeID i, const CallGraphNode* node, const SVFType* svfType, const ICFGNode* icn)
+    VarArgValPN(NodeID i, const SVFFunction* node, const SVFType* svfType, const ICFGNode* icn)
         : ValVar(i, svfType, icn, VarargValNode), callGraphNode(node)
     {
     }

package/svf/include/Util/CallGraphBuilder.h

@@ -47,7 +47,7 @@ public:
     CallGraphBuilder()=default;
 
     /// Buidl SVFIR callgraoh
-    CallGraph* buildSVFIRCallGraph(SVFModule* svfModule);
+    PTACallGraph* buildSVFIRCallGraph(SVFModule* svfModule);
 
     /// Buidl PTA callgraoh
     PTACallGraph* buildPTACallGraph();

package/svf/include/WPA/WPAFSSolver.h

@@ -73,10 +73,10 @@ protected:
 
         /// Both rep and sub nodes need to be processed later.
         /// Collect sub nodes from SCCDetector.
-        NodeStack revTopoStack = this->getSCCDetector()->revTopoNodeStack();
+        FIFOWorkList<NodeID> revTopoStack = this->getSCCDetector()->revTopoNodeStack();
         while (!revTopoStack.empty())
         {
-            NodeID nodeId = revTopoStack.top();
+            NodeID nodeId = revTopoStack.front();
             revTopoStack.pop();
             const NodeBS& subNodes = this->getSCCDetector()->subNodes(nodeId);
             for (NodeBS::iterator it = subNodes.begin(), eit = subNodes.end(); it != eit; ++it)

package/svf/lib/AE/Svfexe/AbstractInterpretation.cpp

@@ -30,7 +30,7 @@
 #include "SVFIR/SVFIR.h"
 #include "Util/Options.h"
 #include "Util/WorkList.h"
-#include "Graphs/CallGraph.h"
+#include "Graphs/PTACallGraph.h"
 #include <cmath>
 
 using namespace SVF;
@@ -84,19 +84,19 @@ void AbstractInterpretation::initWTO()
     // Detect if the call graph has cycles by finding its strongly connected components (SCC)
     Andersen::CallGraphSCC* callGraphScc = ander->getCallGraphSCC();
     callGraphScc->find();
-    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    PTACallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
 
     // Iterate through the call graph
     for (auto it = svfirCallGraph->begin(); it != svfirCallGraph->end(); it++)
     {
         // Check if the current function is part of a cycle
         if (callGraphScc->isInCycle(it->second->getId()))
-            recursiveFuns.insert(it->second); // Mark the function as recursive
+            recursiveFuns.insert(it->second->getFunction()); // Mark the function as recursive
         if (it->second->getFunction()->isDeclaration())
             continue;
         auto* wto = new ICFGWTO(icfg, icfg->getFunEntryICFGNode(it->second->getFunction()));
         wto->init();
-        funcToWTO[it->second] = wto;
+        funcToWTO[it->second->getFunction()] = wto;
     }
 }
 /// Program entry
@@ -107,9 +107,9 @@ void AbstractInterpretation::analyse()
     handleGlobalNode();
     getAbsStateFromTrace(
         icfg->getGlobalICFGNode())[PAG::getPAG()->getBlkPtr()] = IntervalValue::top();
-    if (const CallGraphNode* cgn = svfir->getCallGraph()->getCallGraphNode("main"))
+    if (const PTACallGraphNode* cgn = svfir->getCallGraph()->getCallGraphNode("main"))
     {
-        ICFGWTO* wto = funcToWTO[cgn];
+        ICFGWTO* wto = funcToWTO[cgn->getFunction()];
         handleWTOComponents(wto->getWTOComponents());
     }
 }
@@ -585,7 +585,7 @@ bool AbstractInterpretation::isRecursiveCall(const SVF::CallICFGNode *callNode)
     if (!callfun)
         return false;
     else
-        return recursiveFuns.find(callfun->getCallGraphNode()) != recursiveFuns.end();
+        return recursiveFuns.find(callfun) != recursiveFuns.end();
 }
 
 void AbstractInterpretation::recursiveCallPass(const SVF::CallICFGNode *callNode)
@@ -613,7 +613,7 @@ bool AbstractInterpretation::isDirectCall(const SVF::CallICFGNode *callNode)
     if (!callfun)
         return false;
     else
-        return funcToWTO.find(callfun->getCallGraphNode()) != funcToWTO.end();
+        return funcToWTO.find(callfun) != funcToWTO.end();
 }
 void AbstractInterpretation::directCallFunPass(const SVF::CallICFGNode *callNode)
 {
@@ -623,7 +623,7 @@ void AbstractInterpretation::directCallFunPass(const SVF::CallICFGNode *callNode
     abstractTrace[callNode] = as;
 
     const SVFFunction *callfun =callNode->getCalledFunction();
-    ICFGWTO* wto = funcToWTO[callfun->getCallGraphNode()];
+    ICFGWTO* wto = funcToWTO[callfun];
     handleWTOComponents(wto->getWTOComponents());
 
     callSiteStack.pop_back();
@@ -653,7 +653,7 @@ void AbstractInterpretation::indirectCallFunPass(const SVF::CallICFGNode *callNo
     SVFVar *func_var = svfir->getGNode(AbstractState::getInternalID(addr));
     if(const FunObjVar*funObjVar = SVFUtil::dyn_cast<FunObjVar>(func_var))
     {
-        const CallGraphNode* callfun = funObjVar->getCallGraphNode();
+        const SVFFunction* callfun = funObjVar->getFunction();
         callSiteStack.push_back(callNode);
         abstractTrace[callNode] = as;
 

package/svf/lib/DDA/ContextDDA.cpp

@@ -195,7 +195,7 @@ bool ContextDDA::testIndCallReachability(CxtLocDPItem& dpm, const SVFFunction* c
         CxtVar funptrVar(dpm.getCondVar().get_cond(), id);
         CxtLocDPItem funptrDpm = getDPIm(funptrVar,getDefSVFGNode(node));
         PointsTo pts = getBVPointsTo(findPT(funptrDpm));
-        if(pts.test(getPAG()->getFunObjVar(callee->getCallGraphNode())->getId()))
+        if(pts.test(getPAG()->getFunObjVar(callee)->getId()))
             return true;
         else
             return false;

package/svf/lib/Graphs/PTACallGraph.cpp

@@ -29,7 +29,7 @@
  */
 
 #include "Graphs/PTACallGraph.h"
-#include "Graphs/CallGraph.h"
+#include "Graphs/PTACallGraph.h"
 #include "SVFIR/SVFIR.h"
 #include "SVFIR/SVFModule.h"
 #include "Util/SVFUtil.h"
@@ -114,7 +114,7 @@ PTACallGraph::PTACallGraph(CGEK k): kind(k)
 }
 
 /// Copy constructor
-PTACallGraph::PTACallGraph(const CallGraph& other)
+PTACallGraph::PTACallGraph(const PTACallGraph& other)
 {
     callGraphNodeNum = other.getTotalNodeNum();
     numOfResolvedIndCallEdge = 0;
@@ -123,7 +123,7 @@ PTACallGraph::PTACallGraph(const CallGraph& other)
     /// copy call graph nodes
     for (const auto& item : other)
     {
-        const CallGraphNode* cgn = item.second;
+        const PTACallGraphNode* cgn = item.second;
         PTACallGraphNode* callGraphNode = new PTACallGraphNode(cgn->getId(), cgn->getFunction());
         addGNode(cgn->getId(),callGraphNode);
         funToCallGraphNodeMap[cgn->getFunction()] = callGraphNode;
@@ -133,7 +133,7 @@ PTACallGraph::PTACallGraph(const CallGraph& other)
     for (const auto& item : other.callinstToCallGraphEdgesMap)
     {
         const CallICFGNode* cs = item.first;
-        for (const CallGraphEdge* edge : item.second)
+        for (const PTACallGraphEdge* edge : item.second)
         {
             PTACallGraphNode* src = getCallGraphNode(edge->getSrcID());
             PTACallGraphNode* dst = getCallGraphNode(edge->getDstID());
@@ -334,6 +334,48 @@ void PTACallGraph::view()
     SVF::ViewGraph(this, "Call Graph");
 }
 
+
+/*!
+ * Add call graph node
+ */
+void PTACallGraph::addCallGraphNode(const SVFFunction* fun)
+{
+    NodeID id  = callGraphNodeNum;
+    PTACallGraphNode*callGraphNode = new PTACallGraphNode(id, fun);
+    addGNode(id, callGraphNode);
+    funToCallGraphNodeMap[callGraphNode->getFunction()] = callGraphNode;
+    callGraphNodeNum++;
+}
+
+const PTACallGraphNode* PTACallGraph::getCallGraphNode(const std::string& name)
+{
+    for (const auto& item : *this)
+    {
+        if (item.second->getName() == name)
+            return item.second;
+    }
+    return nullptr;
+}
+
+/*!
+ * Add direct call edges
+ */
+void PTACallGraph::addDirectCallGraphEdge(const CallICFGNode* cs,const SVFFunction* callerFun, const SVFFunction* calleeFun)
+{
+
+    PTACallGraphNode* caller = getCallGraphNode(callerFun);
+    PTACallGraphNode* callee = getCallGraphNode(calleeFun);
+    CallSiteID csId = addCallSite(cs, calleeFun);
+
+    if(!hasGraphEdge(caller,callee, PTACallGraphEdge::CallRetEdge, csId))
+    {
+        PTACallGraphEdge* edge = new PTACallGraphEdge(caller,callee, PTACallGraphEdge::CallRetEdge, csId);
+        edge->addDirectCallSite(cs);
+        addEdge(edge);
+        callinstToCallGraphEdgesMap[cs].insert(edge);
+    }
+}
+
 namespace SVF
 {
 

package/svf/lib/Graphs/ThreadCallGraph.cpp

@@ -32,7 +32,7 @@
 #include "Util/ThreadAPI.h"
 #include "SVFIR/SVFIR.h"
 #include "MemoryModel/PointerAnalysisImpl.h"
-#include "Graphs/CallGraph.h"
+#include "Graphs/PTACallGraph.h"
 
 using namespace SVF;
 using namespace SVFUtil;
@@ -40,7 +40,7 @@ using namespace SVFUtil;
 /*!
  * Constructor
  */
-ThreadCallGraph::ThreadCallGraph(const CallGraph& cg) :
+ThreadCallGraph::ThreadCallGraph(const PTACallGraph& cg) :
     PTACallGraph(cg), tdAPI(ThreadAPI::getThreadAPI())
 {
     kind = ThdCallGraph;
@@ -127,8 +127,8 @@ bool ThreadCallGraph::addDirectForkEdge(const CallICFGNode* cs)
 {
 
     PTACallGraphNode* caller = getCallGraphNode(cs->getCaller());
-    const SVFFunction* forkee = SVFUtil::dyn_cast<FunValVar>(tdAPI->getForkedFun(cs))
-                                ->getCallGraphNode()->getFunction();
+    const FunValVar* funValvar = SVFUtil::dyn_cast<FunValVar>(tdAPI->getForkedFun(cs));
+    const SVFFunction* forkee = funValvar->getFunction();
     assert(forkee && "callee does not exist");
     PTACallGraphNode* callee = getCallGraphNode(forkee->getDefFunForMultipleModule());
     CallSiteID csId = addCallSite(cs, callee->getFunction());
@@ -188,9 +188,7 @@ void ThreadCallGraph::addDirectJoinEdge(const CallICFGNode* cs,const CallSiteSet
     {
 
         const SVFFunction* threadRoutineFun =
-            SVFUtil::dyn_cast<FunValVar>(tdAPI->getForkedFun(*it))
-            ->getCallGraphNode()
-            ->getFunction();
+            SVFUtil::dyn_cast<FunValVar>(tdAPI->getForkedFun(*it))->getFunction();
         assert(threadRoutineFun && "thread routine function does not exist");
         PTACallGraphNode* threadRoutineFunNode = getCallGraphNode(threadRoutineFun);
         CallSiteID csId = addCallSite(cs, threadRoutineFun);

package/svf/lib/MSSA/MemRegion.cpp

@@ -31,7 +31,7 @@
 #include "SVFIR/SVFModule.h"
 #include "MSSA/MemRegion.h"
 #include "MSSA/MSSAMuChi.h"
-#include "Graphs/CallGraph.h"
+#include "Graphs/PTACallGraph.h"
 
 using namespace SVF;
 using namespace SVFUtil;
@@ -174,7 +174,7 @@ SVFIR::SVFStmtList& MRGenerator::getPAGEdgesFromInst(const ICFGNode* node)
 void MRGenerator::collectModRefForLoadStore()
 {
 
-    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    PTACallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
     for (const auto& item: *svfirCallGraph)
     {
         const SVFFunction& fun = *item.second->getFunction();
@@ -238,12 +238,12 @@ void MRGenerator::collectModRefForCall()
 
     DBOUT(DGENERAL, outs() << pasMsg("\t\tPerform Callsite Mod-Ref \n"));
 
-    WorkList worklist;
-    getCallGraphSCCRevTopoOrder(worklist);
+    WorkList worklist = callGraphSCC->revTopoNodeStack();
 
     while(!worklist.empty())
     {
-        NodeID callGraphNodeID = worklist.pop();
+        NodeID callGraphNodeID = worklist.front();
+        worklist.pop();
         /// handle all sub scc nodes of this rep node
         const NodeBS& subNodes = callGraphSCC->subNodes(callGraphNodeID);
         for(NodeBS::iterator it = subNodes.begin(), eit = subNodes.end(); it!=eit; ++it)
@@ -456,20 +456,6 @@ bool MRGenerator::addModSideEffectOfCallSite(const CallICFGNode* cs, const NodeB
 }
 
 
-/*!
- * Get the reverse topo order of scc call graph
- */
-void MRGenerator::getCallGraphSCCRevTopoOrder(WorkList& worklist)
-{
-    NodeStack revTopoNodeStack = callGraphSCC->revTopoNodeStack();
-    while(!revTopoNodeStack.empty())
-    {
-        NodeID callgraphNodeID = revTopoNodeStack.top();
-        revTopoNodeStack.pop();
-        worklist.push(callgraphNodeID);
-    }
-}
-
 /*!
  * Get all objects might pass into and pass out of callee(s) from a callsite
  */

package/svf/lib/MSSA/MemSSA.cpp

@@ -31,7 +31,7 @@
 #include "MSSA/MemPartition.h"
 #include "MSSA/MemSSA.h"
 #include "Graphs/SVFGStat.h"
-#include "Graphs/CallGraph.h"
+#include "Graphs/PTACallGraph.h"
 
 using namespace SVF;
 using namespace SVFUtil;
@@ -576,7 +576,7 @@ u32_t MemSSA::getBBPhiNum() const
 void MemSSA::dumpMSSA(OutStream& Out)
 {
 
-    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    PTACallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
     for (const auto& item: *svfirCallGraph)
     {
         const SVFFunction* fun = item.second->getFunction();

package/svf/lib/MSSA/SVFGBuilder.cpp

@@ -33,7 +33,7 @@
 #include "Graphs/SVFG.h"
 #include "MSSA/SVFGBuilder.h"
 #include "WPA/Andersen.h"
-#include "Graphs/CallGraph.h"
+#include "Graphs/PTACallGraph.h"
 
 
 using namespace SVF;
@@ -103,7 +103,7 @@ std::unique_ptr<MemSSA> SVFGBuilder::buildMSSA(BVDataPTAImpl* pta, bool ptrOnlyM
 
     auto mssa = std::make_unique<MemSSA>(pta, ptrOnlyMSSA);
 
-    CallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
+    PTACallGraph* svfirCallGraph = PAG::getPAG()->getCallGraph();
     for (const auto& item: *svfirCallGraph)
     {
 

package/svf/lib/MTA/MTAStat.cpp

@@ -33,7 +33,7 @@
 #include "MTA/MHP.h"
 #include "MTA/LockAnalysis.h"
 #include "Graphs/ThreadCallGraph.h"
-#include "Graphs/CallGraph.h"
+#include "Graphs/PTACallGraph.h"
 
 using namespace SVF;