svf-lib 1.0.2133 → 1.0.2135

package/SVF-linux/Release-build/include/MemoryModel/PointerAnalysis.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,8 +148,8 @@ protected:
     /// Statistics
     PTAStat* stat;
     /// Call graph used for pointer analysis
-    CallGraph* callgraph;
-    /// SCC for CallGraph
+    PTACallGraph* callgraph;
+    /// SCC for PTACallGraph
     CallGraphSCC* callGraphSCC;
     /// Interprocedural control-flow graph
     ICFG* icfg;
@@ -168,7 +168,7 @@ public:
         return getCallGraph()->getNumOfResolvedIndCallEdge();
     }
     /// Return call graph
-    inline CallGraph* getCallGraph() const
+    inline PTACallGraph* getCallGraph() const
     {
         return callgraph;
     }
@@ -382,9 +382,9 @@ public:
     /// Resolve indirect call edges
     virtual void resolveIndCalls(const CallICFGNode* cs, const PointsTo& target, CallEdgeMap& newEdges);
 
-    /// CallGraph SCC related methods
+    /// PTACallGraph SCC related methods
     //@{
-    /// CallGraph SCC detection
+    /// PTACallGraph SCC detection
     inline void callGraphSCCDetection()
     {
         if(callGraphSCC==nullptr)
@@ -397,11 +397,11 @@ public:
     {
         return callGraphSCC->repNode(id);
     }
-    /// 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.
+    /// Return TRUE if this edge is inside a PTACallGraph 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 = callgraph->getCallGraphNode(fun1);
+        const PTACallGraphNode* dst = callgraph->getCallGraphNode(fun2);
         return (getCallGraphSCCRepNode(src->getId()) == getCallGraphSCCRepNode(dst->getId()));
     }
     inline bool isInRecursion(const SVFFunction* fun) const

package/SVF-linux/Release-build/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-linux/Release-build/include/SABER/SrcSnkDDA.h

@@ -76,7 +76,7 @@ private:
 protected:
     SaberSVFGBuilder memSSA;
     SVFG* svfg;
-    CallGraph* callgraph;
+    PTACallGraph* callgraph;
     SVFBugReport report; /// Bug Reporter
 
 public:
@@ -129,7 +129,7 @@ public:
     }
 
     /// Get Callgraph
-    inline CallGraph* getCallgraph() const
+    inline PTACallGraph* getCallgraph() const
     {
         return callgraph;
     }

package/SVF-linux/Release-build/include/SVF-LLVM/LLVMModule.h

@@ -105,7 +105,7 @@ private:
     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;
+    PTACallGraph* callgraph;
 
     /// Constructor
     LLVMModuleSet();

package/SVF-linux/Release-build/include/SVF-LLVM/SVFIRBuilder.h

@@ -201,7 +201,7 @@ public:
     //}@
 
     /// connect PAG edges based on callgraph
-    void updateCallGraph(CallGraph* callgraph);
+    void updateCallGraph(PTACallGraph* callgraph);
 
 protected:
     /// Handle globals including (global variable and functions)

package/SVF-linux/Release-build/include/SVFIR/SVFIR.h

@@ -98,7 +98,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.
 
@@ -185,13 +185,13 @@ 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!");
+        assert(callGraph && "empty PTACallGraph! Build SVF IR first!");
         return callGraph;
     }
 

package/SVF-linux/Release-build/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
@@ -46,7 +46,7 @@ public:
     CallGraphBuilder()=default;
 
     /// Buidl SVFIR callgraoh
-    CallGraph* buildSVFIRCallGraph(SVFModule* svfModule);
+    PTACallGraph* buildSVFIRCallGraph(SVFModule* svfModule);
 
     /// Build thread-aware callgraph
     ThreadCallGraph* buildThreadCallGraph();

package/SVF-osx/Release-build/include/AE/Svfexe/AbstractInterpretation.h

@@ -106,7 +106,7 @@ class AbstractInterpretation
     friend class BufOverflowDetector;
 
 public:
-    typedef SCCDetection<CallGraph*> CallGraphSCC;
+    typedef SCCDetection<PTACallGraph*> CallGraphSCC;
     /// Constructor
     AbstractInterpretation();
 

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<CallGraph*> CallGraphSCC;
-    typedef CallGraphEdge::CallInstSet CallInstSet;
+    typedef SCCDetection<PTACallGraph*> CallGraphSCC;
+    typedef PTACallGraphEdge::CallInstSet CallInstSet;
     typedef SVFIR::CallSiteSet CallSiteSet;
     typedef OrderedSet<DPIm> DPTItemSet;
     typedef OrderedMap<DPIm, CPtSet> DPImToCPtSetMap;
@@ -624,7 +624,7 @@ protected:
         return (getSVFGSCCRepNode(edge->getSrcID()) == getSVFGSCCRepNode(edge->getDstID()));
     }
     /// Set callgraph
-    inline void setCallGraph (CallGraph* cg)
+    inline void setCallGraph (PTACallGraph* cg)
     {
         _callGraph = cg;
     }
@@ -775,8 +775,8 @@ protected:
     SVFG* _svfg;					///< SVFG
     AndersenWaveDiff* _ander;		///< Andersen's analysis
     NodeBS candidateQueries;		///< candidate pointers;
-    CallGraph* _callGraph;		///< CallGraph
-    CallGraphSCC* _callGraphSCC;	///< SCC for CallGraph
+    PTACallGraph* _callGraph;		///< PTACallGraph
+    CallGraphSCC* _callGraphSCC;	///< SCC for PTACallGraph
     SVFGSCC* _svfgSCC;				///< SCC for SVFG
     DPTItemSet backwardVisited;		///< visited map during backward traversing
     DPImToCPtSetMap dpmToTLCPtSetMap;	///< points-to caching map for top-level vars

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

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

package/SVF-osx/Release-build/include/Graphs/{CallGraph.h → PTACallGraph.h}

@@ -1,4 +1,4 @@
-//===- CallGraph.h -- Call graph representation----------------------------//
+//===- PTACallGraph.h -- Call graph representation----------------------------//
 //
 //                     SVF: Static Value-Flow Analysis
 //
@@ -21,14 +21,14 @@
 //===----------------------------------------------------------------------===//
 
 /*
- * CallGraph.h
+ * PTACallGraph.h
  *
  *  Created on: Nov 7, 2013
  *      Author: Yulei Sui
  */
 
-#ifndef CALLGRAPH_H_
-#define CALLGRAPH_H_
+#ifndef PTACALLGRAPH_H_
+#define PTACALLGRAPH_H_
 
 #include "Graphs/GenericGraph.h"
 #include "SVFIR/SVFValue.h"
@@ -38,7 +38,7 @@
 namespace SVF
 {
 
-class CallGraphNode;
+class PTACallGraphNode;
 class SVFModule;
 
 
@@ -47,8 +47,8 @@ class SVFModule;
  * Multiple calls from function A to B are merged into one call edge
  * Each call edge has a set of direct callsites and a set of indirect callsites
  */
-typedef GenericEdge<CallGraphNode> GenericCallGraphEdgeTy;
-class CallGraphEdge : public GenericCallGraphEdgeTy
+typedef GenericEdge<PTACallGraphNode> GenericCallGraphEdgeTy;
+class PTACallGraphEdge : public GenericCallGraphEdgeTy
 {
 
 public:
@@ -65,12 +65,12 @@ private:
     CallSiteID csId;
 public:
     /// Constructor
-    CallGraphEdge(CallGraphNode* s, CallGraphNode* d, CEDGEK kind, CallSiteID cs) :
+    PTACallGraphEdge(PTACallGraphNode* s, PTACallGraphNode* d, CEDGEK kind, CallSiteID cs) :
         GenericCallGraphEdgeTy(s, d, makeEdgeFlagWithInvokeID(kind, cs)), csId(cs)
     {
     }
     /// Destructor
-    virtual ~CallGraphEdge()
+    virtual ~PTACallGraphEdge()
     {
     }
     /// Compute the unique edgeFlag value from edge kind and CallSiteID.
@@ -140,21 +140,21 @@ public:
 
     /// ClassOf
     //@{
-    static inline bool classof(const CallGraphEdge*)
+    static inline bool classof(const PTACallGraphEdge*)
     {
         return true;
     }
     static inline bool classof(const GenericCallGraphEdgeTy *edge)
     {
-        return edge->getEdgeKind() == CallGraphEdge::CallRetEdge ||
-        edge->getEdgeKind() == CallGraphEdge::TDForkEdge ||
-        edge->getEdgeKind() == CallGraphEdge::TDJoinEdge;
+        return edge->getEdgeKind() == PTACallGraphEdge::CallRetEdge ||
+        edge->getEdgeKind() == PTACallGraphEdge::TDForkEdge ||
+        edge->getEdgeKind() == PTACallGraphEdge::TDJoinEdge;
     }
     //@}
 
     /// Overloading operator << for dumping ICFG node ID
     //@{
-    friend OutStream& operator<< (OutStream &o, const CallGraphEdge &edge)
+    friend OutStream& operator<< (OutStream &o, const PTACallGraphEdge&edge)
     {
         o << edge.toString();
         return o;
@@ -163,28 +163,28 @@ public:
 
     virtual const std::string toString() const;
 
-    typedef GenericNode<CallGraphNode, CallGraphEdge>::GEdgeSetTy CallGraphEdgeSet;
+    typedef GenericNode<PTACallGraphNode, PTACallGraphEdge>::GEdgeSetTy CallGraphEdgeSet;
 
 };
 
 /*
  * Call Graph node representing a function
  */
-typedef GenericNode<CallGraphNode, CallGraphEdge> GenericCallGraphNodeTy;
-class CallGraphNode : public GenericCallGraphNodeTy
+typedef GenericNode<PTACallGraphNode, PTACallGraphEdge> GenericCallGraphNodeTy;
+class PTACallGraphNode : public GenericCallGraphNodeTy
 {
 
 public:
-    typedef CallGraphEdge::CallGraphEdgeSet CallGraphEdgeSet;
-    typedef CallGraphEdge::CallGraphEdgeSet::iterator iterator;
-    typedef CallGraphEdge::CallGraphEdgeSet::const_iterator const_iterator;
+    typedef PTACallGraphEdge::CallGraphEdgeSet CallGraphEdgeSet;
+    typedef PTACallGraphEdge::CallGraphEdgeSet::iterator iterator;
+    typedef PTACallGraphEdge::CallGraphEdgeSet::const_iterator const_iterator;
 
 private:
     const SVFFunction* fun;
 
 public:
     /// Constructor
-    CallGraphNode(NodeID i, const SVFFunction* f) : GenericCallGraphNodeTy(i,CallNodeKd), fun(f)
+    PTACallGraphNode(NodeID i, const SVFFunction* f) : GenericCallGraphNodeTy(i,CallNodeKd), fun(f)
     {
 
     }
@@ -206,7 +206,7 @@ public:
 
     /// Overloading operator << for dumping ICFG node ID
     //@{
-    friend OutStream& operator<< (OutStream &o, const CallGraphNode &node)
+    friend OutStream& operator<< (OutStream &o, const PTACallGraphNode&node)
     {
         o << node.toString();
         return o;
@@ -217,7 +217,7 @@ public:
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const CallGraphNode *)
+    static inline bool classof(const PTACallGraphNode*)
     {
         return true;
     }
@@ -237,13 +237,13 @@ public:
 /*!
  * Pointer Analysis Call Graph used internally for various pointer analysis
  */
-typedef GenericGraph<CallGraphNode, CallGraphEdge> GenericCallGraphTy;
-class CallGraph : public GenericCallGraphTy
+typedef GenericGraph<PTACallGraphNode, PTACallGraphEdge> GenericCallGraphTy;
+class PTACallGraph : public GenericCallGraphTy
 {
 
 public:
-    typedef CallGraphEdge::CallGraphEdgeSet CallGraphEdgeSet;
-    typedef Map<const SVFFunction*, CallGraphNode *> FunToCallGraphNodeMap;
+    typedef PTACallGraphEdge::CallGraphEdgeSet CallGraphEdgeSet;
+    typedef Map<const SVFFunction*, PTACallGraphNode*> FunToCallGraphNodeMap;
     typedef Map<const CallICFGNode*, CallGraphEdgeSet> CallInstToCallGraphEdgesMap;
     typedef std::pair<const CallICFGNode*, const SVFFunction*> CallSitePair;
     typedef Map<CallSitePair, CallSiteID> CallSiteToIdMap;
@@ -280,15 +280,15 @@ protected:
 
 public:
     /// Constructor
-    CallGraph(CGEK k = NormCallGraph);
+    PTACallGraph(CGEK k = NormCallGraph);
 
     /// Copy constructor
-    CallGraph(const CallGraph& other);
+    PTACallGraph(const PTACallGraph& other);
 
     void addCallGraphNode(const SVFFunction* fun);
 
     /// Destructor
-    virtual ~CallGraph()
+    virtual ~PTACallGraph()
     {
         destroy();
     }
@@ -336,11 +336,11 @@ public:
 
     /// Get call graph node
     //@{
-    inline CallGraphNode* getCallGraphNode(NodeID id) const
+    inline PTACallGraphNode* getCallGraphNode(NodeID id) const
     {
         return getGNode(id);
     }
-    inline CallGraphNode* getCallGraphNode(const SVFFunction* fun) const
+    inline PTACallGraphNode* getCallGraphNode(const SVFFunction* fun) const
     {
         FunToCallGraphNodeMap::const_iterator it = funToCallGraphNodeMap.find(fun);
         assert(it!=funToCallGraphNodeMap.end() && "call graph node not found!!");
@@ -398,9 +398,11 @@ public:
     }
     //@}
     /// Whether we have already created this call graph edge
-    CallGraphEdge* hasGraphEdge(CallGraphNode* src, CallGraphNode* dst,CallGraphEdge::CEDGEK kind, CallSiteID csId) const;
+    PTACallGraphEdge* hasGraphEdge(PTACallGraphNode* src, PTACallGraphNode* dst,
+                                   PTACallGraphEdge::CEDGEK kind, CallSiteID csId) const;
     /// Get call graph edge via nodes
-    CallGraphEdge* getGraphEdge(CallGraphNode* src, CallGraphNode* dst,CallGraphEdge::CEDGEK kind, CallSiteID csId);
+    PTACallGraphEdge* getGraphEdge(PTACallGraphNode* src, PTACallGraphNode* dst,
+                                   PTACallGraphEdge::CEDGEK kind, CallSiteID csId);
 
     /// Get all callees for a callsite
     inline void getCallees(const CallICFGNode* cs, FunctionSet& callees)
@@ -438,7 +440,7 @@ public:
     }
     //@}
     /// Add call graph edge
-    inline void addEdge(CallGraphEdge* edge)
+    inline void addEdge(PTACallGraphEdge* edge)
     {
         edge->getDstNode()->addIncomingEdge(edge);
         edge->getSrcNode()->addOutgoingEdge(edge);
@@ -452,9 +454,9 @@ public:
 
     /// Get callsites invoking the callee
     //@{
-    void getAllCallSitesInvokingCallee(const SVFFunction* callee, CallGraphEdge::CallInstSet& csSet);
-    void getDirCallSitesInvokingCallee(const SVFFunction* callee, CallGraphEdge::CallInstSet& csSet);
-    void getIndCallSitesInvokingCallee(const SVFFunction* callee, CallGraphEdge::CallInstSet& csSet);
+    void getAllCallSitesInvokingCallee(const SVFFunction* callee, PTACallGraphEdge::CallInstSet& csSet);
+    void getDirCallSitesInvokingCallee(const SVFFunction* callee, PTACallGraphEdge::CallInstSet& csSet);
+    void getIndCallSitesInvokingCallee(const SVFFunction* callee, PTACallGraphEdge::CallInstSet& csSet);
     //@}
 
     /// Whether its reachable between two functions
@@ -475,19 +477,19 @@ namespace SVF
  * GenericGraphTraits specializations for generic graph algorithms.
  * Provide graph traits for traversing from a constraint node using standard graph traversals.
  */
-template<> struct GenericGraphTraits<SVF::CallGraphNode*> : public GenericGraphTraits<SVF::GenericNode<SVF::CallGraphNode, SVF::CallGraphEdge>*  >
+template<> struct GenericGraphTraits<SVF::PTACallGraphNode*> : public GenericGraphTraits<SVF::GenericNode<SVF::PTACallGraphNode, SVF::PTACallGraphEdge>*  >
 {
 };
 
 /// Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal.
 template<>
-struct GenericGraphTraits<Inverse<SVF::CallGraphNode *> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::CallGraphNode, SVF::CallGraphEdge>* > >
+struct GenericGraphTraits<Inverse<SVF::PTACallGraphNode*> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::PTACallGraphNode, SVF::PTACallGraphEdge>* > >
 {
 };
 
-template<> struct GenericGraphTraits<SVF::CallGraph*> : public GenericGraphTraits<SVF::GenericGraph<SVF::CallGraphNode, SVF::CallGraphEdge>* >
+template<> struct GenericGraphTraits<SVF::PTACallGraph*> : public GenericGraphTraits<SVF::GenericGraph<SVF::PTACallGraphNode, SVF::PTACallGraphEdge>* >
 {
-    typedef SVF::CallGraphNode *NodeRef;
+    typedef SVF::PTACallGraphNode*NodeRef;
 };
 
 } // End namespace llvm

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

@@ -30,7 +30,7 @@
 #ifndef RCG_H_
 #define RCG_H_
 
-#include "Graphs/CallGraph.h"
+#include "Graphs/PTACallGraph.h"
 
 namespace SVF
 {
@@ -41,13 +41,13 @@ class PointerAnalysis;
 /*!
  * PTA thread fork edge from fork site to the entry of a start routine function
  */
-class ThreadForkEdge: public CallGraphEdge
+class ThreadForkEdge: public PTACallGraphEdge
 {
 
 public:
     /// Constructor
-    ThreadForkEdge(CallGraphNode* s, CallGraphNode* d, CallSiteID csId) :
-        CallGraphEdge(s, d, CallGraphEdge::TDForkEdge, csId)
+    ThreadForkEdge(PTACallGraphNode* s, PTACallGraphNode* d, CallSiteID csId) :
+        PTACallGraphEdge(s, d, PTACallGraphEdge::TDForkEdge, csId)
     {
     }
     /// Destructor
@@ -61,9 +61,9 @@ public:
     {
         return true;
     }
-    static inline bool classof(const CallGraphEdge *edge)
+    static inline bool classof(const PTACallGraphEdge*edge)
     {
-        return edge->getEdgeKind() == CallGraphEdge::TDForkEdge;
+        return edge->getEdgeKind() == PTACallGraphEdge::TDForkEdge;
     }
     //@}
 
@@ -78,19 +78,19 @@ public:
         return rawstr.str();
     }
 
-    typedef GenericNode<CallGraphNode, ThreadForkEdge>::GEdgeSetTy ForkEdgeSet;
+    typedef GenericNode<PTACallGraphNode, 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 CallGraphEdge
+class ThreadJoinEdge: public PTACallGraphEdge
 {
 
 public:
     /// Constructor
-    ThreadJoinEdge(CallGraphNode* s, CallGraphNode* d, CallSiteID csId) :
-        CallGraphEdge(s, d, CallGraphEdge::TDJoinEdge, csId)
+    ThreadJoinEdge(PTACallGraphNode* s, PTACallGraphNode* d, CallSiteID csId) :
+        PTACallGraphEdge(s, d, PTACallGraphEdge::TDJoinEdge, csId)
     {
     }
     /// Destructor
@@ -102,9 +102,9 @@ public:
     {
         return true;
     }
-    static inline bool classof(const CallGraphEdge *edge)
+    static inline bool classof(const PTACallGraphEdge*edge)
     {
-        return edge->getEdgeKind() == CallGraphEdge::TDJoinEdge;
+        return edge->getEdgeKind() == PTACallGraphEdge::TDJoinEdge;
     }
 
     virtual const std::string toString() const
@@ -118,19 +118,19 @@ public:
         return rawstr.str();
     }
 
-    typedef GenericNode<CallGraphNode, ThreadJoinEdge>::GEdgeSetTy JoinEdgeSet;
+    typedef GenericNode<PTACallGraphNode, ThreadJoinEdge>::GEdgeSetTy JoinEdgeSet;
 };
 
 /*!
  * hare_parallel_for edge from fork site to the entry of a start routine function
  */
-class HareParForEdge: public CallGraphEdge
+class HareParForEdge: public PTACallGraphEdge
 {
 
 public:
     /// Constructor
-    HareParForEdge(CallGraphNode* s, CallGraphNode* d, CallSiteID csId) :
-        CallGraphEdge(s, d, CallGraphEdge::HareParForEdge, csId)
+    HareParForEdge(PTACallGraphNode* s, PTACallGraphNode* d, CallSiteID csId) :
+        PTACallGraphEdge(s, d, PTACallGraphEdge::HareParForEdge, csId)
     {
     }
     /// Destructor
@@ -144,20 +144,20 @@ public:
     {
         return true;
     }
-    static inline bool classof(const CallGraphEdge *edge)
+    static inline bool classof(const PTACallGraphEdge*edge)
     {
-        return edge->getEdgeKind() == CallGraphEdge::HareParForEdge;
+        return edge->getEdgeKind() == PTACallGraphEdge::HareParForEdge;
     }
     //@}
 
-    typedef GenericNode<CallGraphNode, HareParForEdge>::GEdgeSetTy ParForEdgeSet;
+    typedef GenericNode<PTACallGraphNode, HareParForEdge>::GEdgeSetTy ParForEdgeSet;
 };
 
 
 /*!
  * Thread sensitive call graph
  */
-class ThreadCallGraph: public CallGraph
+class ThreadCallGraph: public PTACallGraph
 {
 
 public:
@@ -172,7 +172,7 @@ public:
     typedef Map<const CallICFGNode*, ParForEdgeSet> CallInstToParForEdgesMap;
 
     /// Constructor
-    ThreadCallGraph(const CallGraph& cg);
+    ThreadCallGraph(const PTACallGraph& cg);
 
     ThreadCallGraph(ThreadCallGraph& cg) = delete;
 
@@ -187,9 +187,9 @@ public:
     {
         return true;
     }
-    static inline bool classof(const CallGraph *g)
+    static inline bool classof(const PTACallGraph*g)
     {
-        return g->getKind() == CallGraph::ThdCallGraph;
+        return g->getKind() == PTACallGraph::ThdCallGraph;
     }
     //@}
 
@@ -239,7 +239,7 @@ public:
         assert(it != callinstToThreadJoinEdgesMap.end() && "call instruction does not have a valid callee");
         return it->second.end();
     }
-    inline void getJoinSites(const CallGraphNode* routine, InstSet& csSet)
+    inline void getJoinSites(const PTACallGraphNode* routine, InstSet& csSet)
     {
         for(CallInstToJoinEdgesMap::const_iterator it = callinstToThreadJoinEdgesMap.begin(), eit = callinstToThreadJoinEdgesMap.end(); it!=eit; ++it)
         {
@@ -359,7 +359,7 @@ public:
     //@}
 
 
-    /// map call instruction to its CallGraphEdge map
+    /// map call instruction to its PTACallGraphEdge map
     inline void addThreadForkEdgeSetMap(const CallICFGNode* cs, ThreadForkEdge* edge)
     {
         if(edge!=nullptr)
@@ -369,7 +369,7 @@ public:
         }
     }
 
-    /// map call instruction to its CallGraphEdge map
+    /// map call instruction to its PTACallGraphEdge map
     inline void addThreadJoinEdgeSetMap(const CallICFGNode* cs, ThreadJoinEdge* edge)
     {
         if(edge!=nullptr)
@@ -379,7 +379,7 @@ public:
         }
     }
 
-    /// map call instruction to its CallGraphEdge map
+    /// map call instruction to its PTACallGraphEdge map
     inline void addHareParForEdgeSetMap(const CallICFGNode* cs, HareParForEdge* edge)
     {
         if(edge!=nullptr)
@@ -390,7 +390,7 @@ public:
     }
 
     /// has thread join edge
-    inline ThreadJoinEdge* hasThreadJoinEdge(const CallICFGNode* call, CallGraphNode* joinFunNode, CallGraphNode* threadRoutineFunNode, CallSiteID csId) const
+    inline ThreadJoinEdge* hasThreadJoinEdge(const CallICFGNode* call, PTACallGraphNode* joinFunNode, PTACallGraphNode* threadRoutineFunNode, CallSiteID csId) const
     {
         ThreadJoinEdge joinEdge(joinFunNode,threadRoutineFunNode, csId);
         CallInstToJoinEdgesMap::const_iterator it = callinstToThreadJoinEdgesMap.find(call);