svf-lib 1.0.2078 → 1.0.2080

package/SVF-osx/Release-build/include/DDA/ContextDDA.h

@@ -133,8 +133,8 @@ public:
     /// Whether call/return inside recursion
     inline virtual bool isEdgeInRecursion(CallSiteID csId)
     {
-        const SVFFunction* caller = getPTACallGraph()->getCallerOfCallSite(csId);
-        const SVFFunction* callee = getPTACallGraph()->getCalleeOfCallSite(csId);
+        const SVFFunction* caller = getCallGraph()->getCallerOfCallSite(csId);
+        const SVFFunction* callee = getCallGraph()->getCalleeOfCallSite(csId);
         return inSameCallGraphSCC(caller, callee);
     }
     /// Update call graph.

package/SVF-osx/Release-build/include/DDA/DDAVFSolver.h

@@ -49,8 +49,8 @@ class DDAVFSolver
     friend class DDAStat;
 public:
     typedef SCCDetection<SVFG*> SVFGSCC;
-    typedef SCCDetection<PTACallGraph*> CallGraphSCC;
-    typedef PTACallGraphEdge::CallInstSet CallInstSet;
+    typedef SCCDetection<CallGraph*> CallGraphSCC;
+    typedef CallGraphEdge::CallInstSet CallInstSet;
     typedef SVFIR::CallSiteSet CallSiteSet;
     typedef OrderedSet<DPIm> DPTItemSet;
     typedef OrderedMap<DPIm, CPtSet> DPImToCPtSetMap;
@@ -505,7 +505,7 @@ protected:
         {
             CallInstSet csSet;
             /// use pre-analysis call graph to approximate all potential callsites
-            _ander->getPTACallGraph()->getIndCallSitesInvokingCallee(fun,csSet);
+            _ander->getCallGraph()->getIndCallSitesInvokingCallee(fun,csSet);
             for(CallInstSet::const_iterator it = csSet.begin(), eit = csSet.end(); it!=eit; ++it)
             {
                 NodeID funPtr = _pag->getFunPtr(*it);
@@ -624,7 +624,7 @@ protected:
         return (getSVFGSCCRepNode(edge->getSrcID()) == getSVFGSCCRepNode(edge->getDstID()));
     }
     /// Set callgraph
-    inline void setCallGraph (PTACallGraph* cg)
+    inline void setCallGraph (CallGraph* cg)
     {
         _callGraph = cg;
     }
@@ -775,7 +775,7 @@ protected:
     SVFG* _svfg;					///< SVFG
     AndersenWaveDiff* _ander;		///< Andersen's analysis
     NodeBS candidateQueries;		///< candidate pointers;
-    PTACallGraph* _callGraph;		///< CallGraph
+    CallGraph* _callGraph;		///< CallGraph
     CallGraphSCC* _callGraphSCC;	///< SCC for CallGraph
     SVFGSCC* _svfgSCC;				///< SCC for SVFG
     DPTItemSet backwardVisited;		///< visited map during backward traversing

package/SVF-osx/Release-build/include/DDA/FlowDDA.h

@@ -87,7 +87,7 @@ public:
     {
         BVDataPTAImpl::initialize();
         buildSVFG(pag);
-        setCallGraph(getPTACallGraph());
+        setCallGraph(getCallGraph());
         setCallGraphSCC(getCallGraphSCC());
         stat = setDDAStat(new DDAStat(this));
     }

package/SVF-osx/Release-build/include/Graphs/ICFG.h

@@ -38,7 +38,7 @@
 namespace SVF
 {
 
-class PTACallGraph;
+class CallGraph;
 
 /*!
  * Interprocedural Control-Flow Graph (ICFG)
@@ -117,7 +117,7 @@ public:
     void view();
 
     /// update ICFG for indirect calls
-    void updateCallGraph(PTACallGraph* callgraph);
+    void updateCallGraph(CallGraph* callgraph);
 
     /// Whether node is in a loop
     inline bool isInLoop(const ICFGNode *node)

package/SVF-osx/Release-build/include/Graphs/ThreadCallGraph.h

@@ -30,7 +30,7 @@
 #ifndef RCG_H_
 #define RCG_H_
 
-#include "Graphs/PTACallGraph.h"
+#include "Graphs/CallGraph.h"
 #include "MemoryModel/PointerAnalysisImpl.h"
 
 namespace SVF
@@ -41,13 +41,13 @@ class ThreadAPI;
 /*!
  * PTA thread fork edge from fork site to the entry of a start routine function
  */
-class ThreadForkEdge: public PTACallGraphEdge
+class ThreadForkEdge: public CallGraphEdge
 {
 
 public:
     /// Constructor
-    ThreadForkEdge(PTACallGraphNode* s, PTACallGraphNode* d, CallSiteID csId) :
-        PTACallGraphEdge(s, d, PTACallGraphEdge::TDForkEdge, csId)
+    ThreadForkEdge(CallGraphNode* s, CallGraphNode* d, CallSiteID csId) :
+        CallGraphEdge(s, d, CallGraphEdge::TDForkEdge, csId)
     {
     }
     /// Destructor
@@ -61,9 +61,9 @@ public:
     {
         return true;
     }
-    static inline bool classof(const PTACallGraphEdge *edge)
+    static inline bool classof(const CallGraphEdge *edge)
     {
-        return edge->getEdgeKind() == PTACallGraphEdge::TDForkEdge;
+        return edge->getEdgeKind() == CallGraphEdge::TDForkEdge;
     }
     //@}
 
@@ -78,19 +78,19 @@ public:
         return rawstr.str();
     }
 
-    typedef GenericNode<PTACallGraphNode, ThreadForkEdge>::GEdgeSetTy ForkEdgeSet;
+    typedef GenericNode<CallGraphNode, ThreadForkEdge>::GEdgeSetTy ForkEdgeSet;
 };
 
 /*!
  * PTA thread join edge from the exit of a start routine function to a join point of the thread
  */
-class ThreadJoinEdge: public PTACallGraphEdge
+class ThreadJoinEdge: public CallGraphEdge
 {
 
 public:
     /// Constructor
-    ThreadJoinEdge(PTACallGraphNode* s, PTACallGraphNode* d, CallSiteID csId) :
-        PTACallGraphEdge(s, d, PTACallGraphEdge::TDJoinEdge, csId)
+    ThreadJoinEdge(CallGraphNode* s, CallGraphNode* d, CallSiteID csId) :
+        CallGraphEdge(s, d, CallGraphEdge::TDJoinEdge, csId)
     {
     }
     /// Destructor
@@ -102,9 +102,9 @@ public:
     {
         return true;
     }
-    static inline bool classof(const PTACallGraphEdge *edge)
+    static inline bool classof(const CallGraphEdge *edge)
     {
-        return edge->getEdgeKind() == PTACallGraphEdge::TDJoinEdge;
+        return edge->getEdgeKind() == CallGraphEdge::TDJoinEdge;
     }
 
     virtual const std::string toString() const
@@ -118,19 +118,19 @@ public:
         return rawstr.str();
     }
 
-    typedef GenericNode<PTACallGraphNode, ThreadJoinEdge>::GEdgeSetTy JoinEdgeSet;
+    typedef GenericNode<CallGraphNode, ThreadJoinEdge>::GEdgeSetTy JoinEdgeSet;
 };
 
 /*!
  * hare_parallel_for edge from fork site to the entry of a start routine function
  */
-class HareParForEdge: public PTACallGraphEdge
+class HareParForEdge: public CallGraphEdge
 {
 
 public:
     /// Constructor
-    HareParForEdge(PTACallGraphNode* s, PTACallGraphNode* d, CallSiteID csId) :
-        PTACallGraphEdge(s, d, PTACallGraphEdge::HareParForEdge, csId)
+    HareParForEdge(CallGraphNode* s, CallGraphNode* d, CallSiteID csId) :
+        CallGraphEdge(s, d, CallGraphEdge::HareParForEdge, csId)
     {
     }
     /// Destructor
@@ -144,20 +144,20 @@ public:
     {
         return true;
     }
-    static inline bool classof(const PTACallGraphEdge *edge)
+    static inline bool classof(const CallGraphEdge *edge)
     {
-        return edge->getEdgeKind() == PTACallGraphEdge::HareParForEdge;
+        return edge->getEdgeKind() == CallGraphEdge::HareParForEdge;
     }
     //@}
 
-    typedef GenericNode<PTACallGraphNode, HareParForEdge>::GEdgeSetTy ParForEdgeSet;
+    typedef GenericNode<CallGraphNode, HareParForEdge>::GEdgeSetTy ParForEdgeSet;
 };
 
 
 /*!
  * Thread sensitive call graph
  */
-class ThreadCallGraph: public PTACallGraph
+class ThreadCallGraph: public CallGraph
 {
 
 public:
@@ -186,9 +186,9 @@ public:
     {
         return true;
     }
-    static inline bool classof(const PTACallGraph *g)
+    static inline bool classof(const CallGraph *g)
     {
-        return g->getKind() == PTACallGraph::ThdCallGraph;
+        return g->getKind() == CallGraph::ThdCallGraph;
     }
     //@}
 
@@ -237,7 +237,7 @@ public:
         assert(it != callinstToThreadJoinEdgesMap.end() && "call instruction does not have a valid callee");
         return it->second.end();
     }
-    inline void getJoinSites(const PTACallGraphNode* routine, InstSet& csSet)
+    inline void getJoinSites(const CallGraphNode* routine, InstSet& csSet)
     {
         for(CallInstToJoinEdgesMap::const_iterator it = callinstToThreadJoinEdgesMap.begin(), eit = callinstToThreadJoinEdgesMap.end(); it!=eit; ++it)
         {
@@ -356,12 +356,6 @@ public:
     void addDirectJoinEdge(const CallICFGNode* cs,const CallSiteSet& forksite);
     //@}
 
-    /// Add direct/indirect parallel for edges
-    //@{
-    void addDirectParForEdge(const CallICFGNode* cs);
-    void addIndirectParForEdge(const CallICFGNode* cs, const SVFFunction* callee);
-    //@}
-
 
     /// map call instruction to its CallGraphEdge map
     inline void addThreadForkEdgeSetMap(const CallICFGNode* cs, ThreadForkEdge* edge)
@@ -394,7 +388,7 @@ public:
     }
 
     /// has thread join edge
-    inline ThreadJoinEdge* hasThreadJoinEdge(const CallICFGNode* call, PTACallGraphNode* joinFunNode, PTACallGraphNode* threadRoutineFunNode, CallSiteID csId) const
+    inline ThreadJoinEdge* hasThreadJoinEdge(const CallICFGNode* call, CallGraphNode* joinFunNode, CallGraphNode* threadRoutineFunNode, CallSiteID csId) const
     {
         ThreadJoinEdge joinEdge(joinFunNode,threadRoutineFunNode, csId);
         CallInstToJoinEdgesMap::const_iterator it = callinstToThreadJoinEdgesMap.find(call);

package/SVF-osx/Release-build/include/Graphs/VFG.h

@@ -32,7 +32,7 @@
 
 
 #include "SVFIR/SVFIR.h"
-#include "Graphs/PTACallGraph.h"
+#include "Graphs/CallGraph.h"
 #include "Graphs/VFGNode.h"
 #include "Graphs/VFGEdge.h"
 
@@ -100,7 +100,7 @@ protected:
     FunToVFGNodesMapTy funToVFGNodesMap; ///< map a function to its VFGNodes;
 
     GlobalVFGNodeSet globalVFGNodes;	///< set of global store VFG nodes
-    PTACallGraph* callgraph;
+    CallGraph* callgraph;
     SVFIR* pag;
     VFGK kind;
 
@@ -109,7 +109,7 @@ protected:
 
 public:
     /// Constructor
-    VFG(PTACallGraph* callgraph, VFGK k = FULLSVFG);
+    VFG(CallGraph* callgraph, VFGK k = FULLSVFG);
 
     /// Destructor
     virtual ~VFG()
@@ -136,7 +136,7 @@ public:
     }
 
     /// Return CallGraph
-    inline PTACallGraph* getCallGraph() const
+    inline CallGraph* getCallGraph() const
     {
         return callgraph;
     }

package/SVF-osx/Release-build/include/MSSA/MemRegion.h

@@ -35,7 +35,7 @@
 #define MEMORYREGION_H_
 
 #include "Graphs/ICFG.h"
-#include "Graphs/PTACallGraph.h"
+#include "Graphs/CallGraph.h"
 #include "Graphs/SCC.h"
 #include "SVFIR/SVFIR.h"
 #include "Util/WorkList.h"
@@ -175,7 +175,7 @@ public:
     /// SVFIR edge list
     typedef SVFIR::SVFStmtList SVFStmtList;
     /// Call Graph SCC
-    typedef SCCDetection<PTACallGraph*> SCC;
+    typedef SCCDetection<CallGraph*> SCC;
 
     MRSet& getMRSet()
     {
@@ -196,7 +196,7 @@ private:
 
     BVDataPTAImpl* pta;
     SCC* callGraphSCC;
-    PTACallGraph* callGraph;
+    CallGraph* callGraph;
     bool ptrOnlyMSSA;
 
     /// Map a function to all its memory regions
@@ -330,7 +330,7 @@ protected:
     }
 
     /// Mod-Ref analysis for callsite invoking this callGraphNode
-    virtual void modRefAnalysis(PTACallGraphNode* callGraphNode, WorkList& worklist);
+    virtual void modRefAnalysis(CallGraphNode* callGraphNode, WorkList& worklist);
 
     /// Get Mod-Ref of a callee function
     virtual bool handleCallsiteModRef(NodeBS& mod, NodeBS& ref, const CallICFGNode* cs, const SVFFunction* fun);

package/SVF-osx/Release-build/include/MTA/LockAnalysis.h

@@ -58,11 +58,11 @@ public:
 
     typedef NodeBS LockSet;
     typedef TCT::InstVec InstVec;
-    typedef Set<const SVFInstruction*> InstSet;
+    typedef Set<const ICFGNode*> InstSet;
     typedef InstSet CISpan;
-    typedef Map<const SVFInstruction*, CISpan>CILockToSpan;
+    typedef Map<const ICFGNode*, CISpan>CILockToSpan;
     typedef Set<const SVFFunction*> FunSet;
-    typedef Map<const SVFInstruction*, InstSet> InstToInstSetMap;
+    typedef Map<const ICFGNode*, InstSet> InstToInstSetMap;
     typedef Map<CxtStmt, ValDomain> CxtStmtToLockFlagMap;
     typedef FIFOWorkList<CxtStmt> CxtStmtWorkList;
     typedef Set<CxtStmt> LockSpan;
@@ -71,13 +71,13 @@ public:
 
     typedef Map<CxtLock, LockSpan> CxtLockToSpan;
     typedef Map<CxtLock, NodeBS> CxtLockToLockSet;
-    typedef Map<const SVFInstruction*, NodeBS> LockSiteToLockSet;
-    typedef Map<const SVFInstruction*, LockSpan> InstToCxtStmtSet;
+    typedef Map<const ICFGNode*, NodeBS> LockSiteToLockSet;
+    typedef Map<const ICFGNode*, LockSpan> InstToCxtStmtSet;
     typedef Map<CxtStmt, CxtLockSet> CxtStmtToCxtLockSet;
     typedef FIFOWorkList<CxtLockProc> CxtLockProcVec;
     typedef Set<CxtLockProc> CxtLockProcSet;
 
-    typedef Map<const SVFInstruction*, CxtStmtSet> InstToCxtStmt;
+    typedef Map<const ICFGNode*, CxtStmtSet> InstToCxtStmt;
 
     LockAnalysis(TCT* t) : tct(t), lockTime(0),numOfTotalQueries(0), numOfLockedQueries(0), lockQueriesTime(0)
     {
@@ -88,7 +88,7 @@ public:
     /// (2) maps a context-sensitive lock site to its corresponding lock span.
     void analyze();
     void analyzeIntraProcedualLock();
-    bool intraForwardTraverse(const SVFInstruction* lock, InstSet& unlockset, InstSet& forwardInsts);
+    bool intraForwardTraverse(const ICFGNode* lock, InstSet& unlockset, InstSet& forwardInsts);
     bool intraBackwardTraverse(const InstSet& unlockset, InstSet& backwardInsts);
 
     void collectCxtLock();
@@ -100,14 +100,14 @@ public:
     /// Intraprocedural locks
     //@{
     /// Return true if the lock is an intra-procedural lock
-    inline bool isIntraLock(const SVFInstruction* lock) const
+    inline bool isIntraLock(const ICFGNode* lock) const
     {
         assert(locksites.find(lock)!=locksites.end() && "not a lock site?");
         return ciLocktoSpan.find(lock)!=ciLocktoSpan.end();
     }
 
     /// Add intra-procedural lock
-    inline void addIntraLock(const SVFInstruction* lockSite, const InstSet& stmts)
+    inline void addIntraLock(const ICFGNode* lockSite, const InstSet& stmts)
     {
         for(InstSet::const_iterator it = stmts.begin(), eit = stmts.end(); it!=eit; ++it)
         {
@@ -117,7 +117,7 @@ public:
     }
 
     /// Add intra-procedural lock
-    inline void addCondIntraLock(const SVFInstruction* lockSite, const InstSet& stmts)
+    inline void addCondIntraLock(const ICFGNode* lockSite, const InstSet& stmts)
     {
         for(InstSet::const_iterator it = stmts.begin(), eit = stmts.end(); it!=eit; ++it)
         {
@@ -126,18 +126,18 @@ public:
     }
 
     /// Return true if a statement is inside an intra-procedural lock
-    inline bool isInsideIntraLock(const SVFInstruction* stmt) const
+    inline bool isInsideIntraLock(const ICFGNode* stmt) const
     {
         return instCILocksMap.find(stmt)!=instCILocksMap.end() || isInsideCondIntraLock(stmt);
     }
 
     /// Return true if a statement is inside a partial lock/unlock pair (conditional lock with unconditional unlock)
-    inline bool isInsideCondIntraLock(const SVFInstruction* stmt) const
+    inline bool isInsideCondIntraLock(const ICFGNode* stmt) const
     {
         return instTocondCILocksMap.find(stmt)!=instTocondCILocksMap.end();
     }
 
-    inline const InstSet& getIntraLockSet(const SVFInstruction* stmt) const
+    inline const InstSet& getIntraLockSet(const ICFGNode* stmt) const
     {
         InstToInstSetMap::const_iterator it = instCILocksMap.find(stmt);
         assert(it!=instCILocksMap.end() && "intralock not found!");
@@ -148,7 +148,7 @@ public:
     /// Context-sensitive locks
     //@{
     /// Add inter-procedural context-sensitive lock
-    inline void addCxtLock(const CallStrCxt& cxt,const SVFInstruction* inst)
+    inline void addCxtLock(const CallStrCxt& cxt,const ICFGNode* inst)
     {
         CxtLock cxtlock(cxt,inst);
         cxtLockset.insert(cxtlock);
@@ -200,12 +200,12 @@ public:
     /// Context-sensitive statement and lock spans
     //@{
     /// Get LockSet and LockSpan
-    inline bool hasCxtStmtfromInst(const SVFInstruction* inst) const
+    inline bool hasCxtStmtfromInst(const ICFGNode* inst) const
     {
         InstToCxtStmtSet::const_iterator it = instToCxtStmtSet.find(inst);
         return (it != instToCxtStmtSet.end());
     }
-    inline const CxtStmtSet& getCxtStmtfromInst(const SVFInstruction* inst) const
+    inline const CxtStmtSet& getCxtStmtfromInst(const ICFGNode* inst) const
     {
         InstToCxtStmtSet::const_iterator it = instToCxtStmtSet.find(inst);
         assert(it != instToCxtStmtSet.end());
@@ -269,7 +269,7 @@ public:
 
 
     /// Check if one instruction's context stmt is in a lock span
-    inline bool hasOneCxtInLockSpan(const SVFInstruction *I, LockSpan lspan) const
+    inline bool hasOneCxtInLockSpan(const ICFGNode *I, LockSpan lspan) const
     {
         if(!hasCxtStmtfromInst(I))
             return false;
@@ -284,7 +284,7 @@ public:
         return false;
     }
 
-    inline bool hasAllCxtInLockSpan(const SVFInstruction *I, LockSpan lspan) const
+    inline bool hasAllCxtInLockSpan(const ICFGNode *I, LockSpan lspan) const
     {
         if(!hasCxtStmtfromInst(I))
             return false;
@@ -303,15 +303,15 @@ public:
     /// Check if two Instructions are protected by common locks
     /// echo inst may have multiple cxt stmt
     /// we check whether every cxt stmt of instructions is protected by a common lock.
-    bool isProtectedByCommonLock(const SVFInstruction *i1, const SVFInstruction *i2);
-    bool isProtectedByCommonCxtLock(const SVFInstruction *i1, const SVFInstruction *i2);
+    bool isProtectedByCommonLock(const ICFGNode *i1, const ICFGNode *i2);
+    bool isProtectedByCommonCxtLock(const ICFGNode *i1, const ICFGNode *i2);
     bool isProtectedByCommonCxtLock(const CxtStmt& cxtStmt1, const CxtStmt& cxtStmt2);
-    bool isProtectedByCommonCILock(const SVFInstruction *i1, const SVFInstruction *i2);
+    bool isProtectedByCommonCILock(const ICFGNode *i1, const ICFGNode *i2);
 
-    bool isInSameSpan(const SVFInstruction *I1, const SVFInstruction *I2);
-    bool isInSameCSSpan(const SVFInstruction *i1, const SVFInstruction *i2) const;
+    bool isInSameSpan(const ICFGNode *I1, const ICFGNode *I2);
+    bool isInSameCSSpan(const ICFGNode *i1, const ICFGNode *i2) const;
     bool isInSameCSSpan(const CxtStmt& cxtStmt1, const CxtStmt& cxtStmt2) const;
-    bool isInSameCISpan(const SVFInstruction *i1, const SVFInstruction *i2) const;
+    bool isInSameCISpan(const ICFGNode *i1, const ICFGNode *i2) const;
 
     inline u32_t getNumOfCxtLocks()
     {
@@ -339,14 +339,14 @@ private:
     void handleIntra(const CxtStmt& cts);
 
     /// Handle call relations
-    void handleCallRelation(CxtLockProc& clp, const PTACallGraphEdge* cgEdge, CallSite call);
+    void handleCallRelation(CxtLockProc& clp, const CallGraphEdge* cgEdge, CallSite call);
 
     /// Return true it a lock matches an unlock
     bool isAliasedLocks(const CxtLock& cl1, const CxtLock& cl2)
     {
         return isAliasedLocks(cl1.getStmt(), cl2.getStmt());
     }
-    bool isAliasedLocks(const SVFInstruction* i1, const SVFInstruction* i2)
+    bool isAliasedLocks(const ICFGNode* i1, const ICFGNode* i2)
     {
         /// todo: must alias
         return tct->getPTA()->alias(getLockVal(i1), getLockVal(i2));
@@ -430,27 +430,37 @@ private:
     //@}
 
     /// Push calling context
-    void pushCxt(CallStrCxt& cxt, const SVFInstruction* call, const SVFFunction* callee);
+    void pushCxt(CallStrCxt& cxt, const CallICFGNode* call, const SVFFunction* callee);
     /// Match context
-    bool matchCxt(CallStrCxt& cxt, const SVFInstruction* call, const SVFFunction* callee);
+    bool matchCxt(CallStrCxt& cxt, const CallICFGNode* call, const SVFFunction* callee);
 
     /// Whether it is a lock site
-    inline bool isTDFork(const SVFInstruction* call)
+    inline bool isTDFork(const ICFGNode* call)
     {
         return getTCG()->getThreadAPI()->isTDFork(call);
     }
     /// Whether it is a lock site
-    inline bool isTDAcquire(const SVFInstruction* call)
+    inline bool isTDAcquire(const ICFGNode* call)
     {
         return getTCG()->getThreadAPI()->isTDAcquire(call);
     }
     /// Whether it is a unlock site
-    inline bool isTDRelease(const SVFInstruction* call)
+    inline bool isTDRelease(const ICFGNode* call)
     {
         return getTCG()->getThreadAPI()->isTDRelease(call);
     }
+    /// Whether it is a callsite
+    inline bool isCallSite(const ICFGNode* inst)
+    {
+        return tct->isCallSite(inst);
+    }
+    /// Whether it is calling an external function
+    inline bool isExtCall(const ICFGNode* inst)
+    {
+        return tct->isExtCall(inst);
+    }
     /// Get lock value
-    inline const SVFValue* getLockVal(const SVFInstruction* call)
+    inline const SVFValue* getLockVal(const ICFGNode* call)
     {
         return getTCG()->getThreadAPI()->getLockVal(call);
     }