svf-tools 1.0.976 → 1.0.977

package/svf/include/MemoryModel/PointerAnalysis.h

@@ -34,7 +34,7 @@
 #include <signal.h>
 
 #include "Graphs/CHG.h"
-#include "Graphs/CallGraph.h"
+#include "Graphs/PTACallGraph.h"
 #include "Graphs/SCC.h"
 #include "MemoryModel/AbstractPointsToDS.h"
 #include "MemoryModel/ConditionalPT.h"
@@ -103,7 +103,7 @@ public:
     typedef SVFIR::CallSiteToFunPtrMap CallSiteToFunPtrMap;
     typedef Set<const SVFFunction*> FunctionSet;
     typedef OrderedMap<const CallICFGNode*, FunctionSet> CallEdgeMap;
-    typedef SCCDetection<CallGraph*> CallGraphSCC;
+    typedef SCCDetection<PTACallGraph*> CallGraphSCC;
     typedef Set<const SVFGlobalValue*> VTableSet;
     typedef Set<const SVFFunction*> VFunSet;
     //@}
@@ -148,7 +148,7 @@ protected:
     /// Statistics
     PTAStat* stat;
     /// Call graph used for pointer analysis
-    CallGraph* callgraph;
+    PTACallGraph* ptaCallGraph;
     /// SCC for CallGraph
     CallGraphSCC* callGraphSCC;
     /// Interprocedural control-flow graph
@@ -165,12 +165,12 @@ public:
     /// Return number of resolved indirect call edges
     inline u32_t getNumOfResolvedIndCallEdge() const
     {
-        return getCallGraph()->getNumOfResolvedIndCallEdge();
+        return getPTACallGraph()->getNumOfResolvedIndCallEdge();
     }
     /// Return call graph
-    inline CallGraph* getCallGraph() const
+    inline PTACallGraph* getPTACallGraph() const
     {
-        return callgraph;
+        return ptaCallGraph;
     }
     /// Return call graph SCC
     inline CallGraphSCC* getCallGraphSCC() const
@@ -367,15 +367,15 @@ public:
     //@{
     inline CallEdgeMap& getIndCallMap()
     {
-        return getCallGraph()->getIndCallMap();
+        return getPTACallGraph()->getIndCallMap();
     }
     inline bool hasIndCSCallees(const CallICFGNode* cs) const
     {
-        return getCallGraph()->hasIndCSCallees(cs);
+        return getPTACallGraph()->hasIndCSCallees(cs);
     }
     inline const FunctionSet& getIndCSCallees(const CallICFGNode* cs) const
     {
-        return getCallGraph()->getIndCSCallees(cs);
+        return getPTACallGraph()->getIndCSCallees(cs);
     }
     //@}
 
@@ -388,7 +388,7 @@ public:
     inline void callGraphSCCDetection()
     {
         if(callGraphSCC==nullptr)
-            callGraphSCC = new CallGraphSCC(callgraph);
+            callGraphSCC = new CallGraphSCC(ptaCallGraph);
 
         callGraphSCC->find();
     }
@@ -400,13 +400,13 @@ public:
     /// Return TRUE if this edge is inside a CallGraph SCC, i.e., src node and dst node are in the same SCC on the SVFG.
     inline bool inSameCallGraphSCC(const SVFFunction* fun1,const SVFFunction* fun2)
     {
-        const CallGraphNode* src = callgraph->getCallGraphNode(fun1);
-        const CallGraphNode* dst = callgraph->getCallGraphNode(fun2);
+        const PTACallGraphNode* src = ptaCallGraph->getCallGraphNode(fun1);
+        const PTACallGraphNode* dst = ptaCallGraph->getCallGraphNode(fun2);
         return (getCallGraphSCCRepNode(src->getId()) == getCallGraphSCCRepNode(dst->getId()));
     }
     inline bool isInRecursion(const SVFFunction* fun) const
     {
-        return callGraphSCC->isInCycle(callgraph->getCallGraphNode(fun)->getId());
+        return callGraphSCC->isInCycle(ptaCallGraph->getCallGraphNode(fun)->getId());
     }
     /// Whether a local variable is in function recursions
     bool isLocalVarInRecursiveFun(NodeID id) const;

package/svf/include/SABER/SaberSVFGBuilder.h

@@ -89,7 +89,7 @@ protected:
 
     /// Add actual parameter SVFGNode for 1st argument of a deallocation like external function
     /// In order to path sensitive leak detection
-    virtual void AddExtActualParmSVFGNodes(CallGraph* callgraph);
+    virtual void AddExtActualParmSVFGNodes(PTACallGraph* callgraph);
 
     /// Collect memory pointed global pointers,
     /// note that this collection is recursively performed, for example gp-->obj-->obj'

package/svf/include/SABER/SrcSnkDDA.h

@@ -76,13 +76,13 @@ private:
 protected:
     SaberSVFGBuilder memSSA;
     SVFG* svfg;
-    CallGraph* callgraph;
+    PTACallGraph* ptaCallGraph;
     SVFBugReport report; /// Bug Reporter
 
 public:
 
     /// Constructor
-    SrcSnkDDA() : _curSlice(nullptr), svfg(nullptr), callgraph(nullptr)
+    SrcSnkDDA() : _curSlice(nullptr), svfg(nullptr), ptaCallGraph(nullptr)
     {
         saberCondAllocator = std::make_unique<SaberCondAllocator>();
     }
@@ -95,9 +95,9 @@ public:
         _curSlice = nullptr;
 
         /// the following shared by multiple checkers, thus can not be released.
-        //if (callgraph != nullptr)
-        //    delete callgraph;
-        //callgraph = nullptr;
+        //if (ptaCallGraph != nullptr)
+        //    delete ptaCallGraph;
+        //ptaCallGraph = nullptr;
 
         //if(pathCondAllocator)
         //    delete pathCondAllocator;
@@ -129,9 +129,9 @@ public:
     }
 
     /// Get Callgraph
-    inline CallGraph* getCallgraph() const
+    inline PTACallGraph* getCallgraph() const
     {
-        return callgraph;
+        return ptaCallGraph;
     }
 
     /// Whether this svfg node may access global variable

package/svf/include/Util/CallGraphBuilder.h

@@ -31,7 +31,7 @@
 #ifndef INCLUDE_SVF_FE_CALLGRAPHBUILDER_H_
 #define INCLUDE_SVF_FE_CALLGRAPHBUILDER_H_
 
-#include "Graphs/CallGraph.h"
+#include "Graphs/PTACallGraph.h"
 #include "Graphs/ThreadCallGraph.h"
 
 namespace SVF
@@ -43,15 +43,15 @@ class CallGraphBuilder
 {
 
 protected:
-    CallGraph* callgraph;
+    PTACallGraph* callgraph;
     ICFG* icfg;
 public:
-    CallGraphBuilder(CallGraph* cg, ICFG* i): callgraph(cg),icfg(i)
+    CallGraphBuilder(PTACallGraph* cg, ICFG* i): callgraph(cg),icfg(i)
     {
     }
 
     /// Build normal callgraph
-    CallGraph* buildCallGraph(SVFModule* svfModule);
+    PTACallGraph* buildCallGraph(SVFModule* svfModule);
 
 };
 
@@ -64,7 +64,7 @@ public:
     }
 
     /// Build thread-aware callgraph
-    CallGraph* buildThreadCallGraph(SVFModule* svfModule);
+    PTACallGraph* buildThreadCallGraph(SVFModule* svfModule);
 
 };
 

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

@@ -131,7 +131,7 @@ void AbstractInterpretation::initWTO()
     // Detect if the call graph has cycles by finding its strongly connected components (SCC)
     Andersen::CallGraphSCC* callGraphScc = ander->getCallGraphSCC();
     callGraphScc->find();
-    auto callGraph = ander->getCallGraph();
+    auto callGraph = ander->getPTACallGraph();
 
     // Iterate through the call graph
     for (auto it = callGraph->begin(); it != callGraph->end(); it++)

package/svf/lib/CFL/CFLSVFGBuilder.cpp

@@ -50,7 +50,7 @@ void CFLSVFGBuilder::buildSVFG()
 
     DBOUT(DGENERAL, outs() << pasMsg("\tAdd Sink SVFG Nodes\n"));
 
-    AddExtActualParmSVFGNodes(pta->getCallGraph());
+    AddExtActualParmSVFGNodes(pta->getPTACallGraph());
 
     if(pta->printStat())
         svfg->performStat();

package/svf/lib/DDA/ContextDDA.cpp

@@ -63,7 +63,7 @@ void ContextDDA::initialize()
 {
     CondPTAImpl<ContextCond>::initialize();
     buildSVFG(pag);
-    setCallGraph(getCallGraph());
+    setCallGraph(getPTACallGraph());
     setCallGraphSCC(getCallGraphSCC());
     stat = setDDAStat(new DDAStat(this));
     flowDDA->initialize();
@@ -219,9 +219,9 @@ CallSiteID ContextDDA::getCSIDAtCall(CxtLocDPItem&, const SVFGEdge* edge)
     const CallICFGNode* cbn = getSVFG()->getCallSite(svfg_csId);
     const SVFFunction* callee = edge->getDstNode()->getFun();
 
-    if(getCallGraph()->hasCallSiteID(cbn,callee))
+    if(getPTACallGraph()->hasCallSiteID(cbn,callee))
     {
-        return getCallGraph()->getCallSiteID(cbn,callee);
+        return getPTACallGraph()->getCallSiteID(cbn,callee);
     }
 
     return 0;
@@ -243,9 +243,9 @@ CallSiteID ContextDDA::getCSIDAtRet(CxtLocDPItem&, const SVFGEdge* edge)
     const CallICFGNode* cbn = getSVFG()->getCallSite(svfg_csId);
     const SVFFunction* callee = edge->getSrcNode()->getFun();
 
-    if(getCallGraph()->hasCallSiteID(cbn,callee))
+    if(getPTACallGraph()->hasCallSiteID(cbn,callee))
     {
-        return getCallGraph()->getCallSiteID(cbn,callee);
+        return getPTACallGraph()->getCallSiteID(cbn,callee);
     }
 
     return 0;
@@ -265,8 +265,8 @@ bool ContextDDA::handleBKCondition(CxtLocDPItem& dpm, const SVFGEdge* edge)
 
             if(isEdgeInRecursion(csId))
             {
-                DBOUT(DDDA,outs() << "\t\t call edge " << getCallGraph()->getCallerOfCallSite(csId)->getName() <<
-                      "=>" << getCallGraph()->getCalleeOfCallSite(csId)->getName() << "in recursion \n");
+                DBOUT(DDDA,outs() << "\t\t call edge " << getPTACallGraph()->getCallerOfCallSite(csId)->getName() <<
+                      "=>" << getPTACallGraph()->getCalleeOfCallSite(csId)->getName() << "in recursion \n");
                 popRecursiveCallSites(dpm);
             }
             else
@@ -293,8 +293,8 @@ bool ContextDDA::handleBKCondition(CxtLocDPItem& dpm, const SVFGEdge* edge)
 
             if(isEdgeInRecursion(csId))
             {
-                DBOUT(DDDA,outs() << "\t\t return edge " << getCallGraph()->getCalleeOfCallSite(csId)->getName() <<
-                      "=>" << getCallGraph()->getCallerOfCallSite(csId)->getName() << "in recursion \n");
+                DBOUT(DDDA,outs() << "\t\t return edge " << getPTACallGraph()->getCalleeOfCallSite(csId)->getName() <<
+                      "=>" << getPTACallGraph()->getCallerOfCallSite(csId)->getName() << "in recursion \n");
                 popRecursiveCallSites(dpm);
             }
             else

package/svf/lib/DDA/DDAClient.cpp

@@ -115,7 +115,7 @@ void FunptrDDAClient::performStat(PointerAnalysis* pta)
         const PointsTo& ddaPts = pta->getPts(vtptr);
         const PointsTo& anderPts = ander->getPts(vtptr);
 
-        CallGraph* callgraph = ander->getCallGraph();
+        PTACallGraph* callgraph = ander->getPTACallGraph();
         const CallICFGNode* cbn = nIter->second;
 
         if(!callgraph->hasIndCSCallees(cbn))
@@ -124,7 +124,7 @@ void FunptrDDAClient::performStat(PointerAnalysis* pta)
             continue;
         }
 
-        const CallGraph::FunctionSet& callees = callgraph->getIndCSCallees(cbn);
+        const PTACallGraph::FunctionSet& callees = callgraph->getIndCSCallees(cbn);
         totalCallsites++;
         if(callees.size() == 0)
             zeroTargetCallsites++;
@@ -162,7 +162,7 @@ void FunptrDDAClient::performStat(PointerAnalysis* pta)
     outs() << "=================================================\n";
     outs() << "Total virtual callsites: " << vtableToCallSiteMap.size() << "\n";
     outs() << "Total analyzed virtual callsites: " << totalCallsites << "\n";
-    outs() << "Indirect call map size: " << ander->getCallGraph()->getIndCallMap().size() << "\n";
+    outs() << "Indirect call map size: " << ander->getPTACallGraph()->getIndCallMap().size() << "\n";
     outs() << "Precise callsites: " << morePreciseCallsites << "\n";
     outs() << "Zero target callsites: " << zeroTargetCallsites << "\n";
     outs() << "One target callsites: " << oneTargetCallsites << "\n";

package/svf/lib/DDA/DDAPass.cpp

@@ -239,8 +239,8 @@ void DDAPass::collectCxtInsenEdgeForVFCycle(PointerAnalysis* pta, const SVFG* sv
 
                     if(srcFun && dstFun)
                     {
-                        NodeID src = pta->getCallGraph()->getCallGraphNode(srcFun)->getId();
-                        NodeID dst = pta->getCallGraph()->getCallGraphNode(dstFun)->getId();
+                        NodeID src = pta->getPTACallGraph()->getCallGraphNode(srcFun)->getId();
+                        NodeID dst = pta->getPTACallGraph()->getCallGraphNode(dstFun)->getId();
                         insensitvefunPairs.insert(std::make_pair(src,dst));
                         insensitvefunPairs.insert(std::make_pair(dst,src));
                     }
@@ -266,8 +266,8 @@ void DDAPass::collectCxtInsenEdgeForVFCycle(PointerAnalysis* pta, const SVFG* sv
 
                 if(srcFun && dstFun)
                 {
-                    NodeID src = pta->getCallGraph()->getCallGraphNode(srcFun)->getId();
-                    NodeID dst = pta->getCallGraph()->getCallGraphNode(dstFun)->getId();
+                    NodeID src = pta->getPTACallGraph()->getCallGraphNode(srcFun)->getId();
+                    NodeID dst = pta->getPTACallGraph()->getCallGraphNode(dstFun)->getId();
                     if(insensitvefunPairs.find(std::make_pair(src,dst))!=insensitvefunPairs.end())
                         insensitveEdges.insert(edge);
                     else if(insensitvefunPairs.find(std::make_pair(dst,src))!=insensitvefunPairs.end())

package/svf/lib/DDA/FlowDDA.cpp

@@ -85,9 +85,9 @@ bool FlowDDA::testIndCallReachability(LocDPItem&, const SVFFunction* callee, Cal
 
     if(getPAG()->isIndirectCallSites(cbn))
     {
-        if(getCallGraph()->hasIndCSCallees(cbn))
+        if(getPTACallGraph()->hasIndCSCallees(cbn))
         {
-            const FunctionSet& funset = getCallGraph()->getIndCSCallees(cbn);
+            const FunctionSet& funset = getPTACallGraph()->getIndCSCallees(cbn);
             if(funset.find(callee)!=funset.end())
                 return true;
         }

package/svf/lib/Graphs/ICFG.cpp

@@ -31,7 +31,7 @@
 #include "SVFIR/SVFModule.h"
 #include "Graphs/ICFG.h"
 #include "SVFIR/SVFIR.h"
-#include "Graphs/CallGraph.h"
+#include "Graphs/PTACallGraph.h"
 
 using namespace SVF;
 using namespace SVFUtil;
@@ -460,17 +460,17 @@ void ICFG::view()
 /*!
  * Update ICFG for indirect calls
  */
-void ICFG::updateCallGraph(CallGraph* callgraph)
+void ICFG::updateCallGraph(PTACallGraph* callgraph)
 {
-    CallGraph::CallEdgeMap::const_iterator iter = callgraph->getIndCallMap().begin();
-    CallGraph::CallEdgeMap::const_iterator eiter = callgraph->getIndCallMap().end();
+    PTACallGraph::CallEdgeMap::const_iterator iter = callgraph->getIndCallMap().begin();
+    PTACallGraph::CallEdgeMap::const_iterator eiter = callgraph->getIndCallMap().end();
     for (; iter != eiter; iter++)
     {
         const CallICFGNode* callBlock = iter->first;
         const SVFInstruction* cs = callBlock->getCallSite();
         assert(callBlock->isIndirectCall() && "this is not an indirect call?");
-        const CallGraph::FunctionSet & functions = iter->second;
-        for (CallGraph::FunctionSet::const_iterator func_iter = functions.begin(); func_iter != functions.end(); func_iter++)
+        const PTACallGraph::FunctionSet & functions = iter->second;
+        for (PTACallGraph::FunctionSet::const_iterator func_iter = functions.begin(); func_iter != functions.end(); func_iter++)
         {
             const SVFFunction*  callee = *func_iter;
             CallICFGNode* callBlockNode = getCallICFGNode(cs);