svf-lib 1.0.2207 → 1.0.2209

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

@@ -55,7 +55,6 @@ public:
     typedef Map<const GlobalVariable*, GlobalVariable*> GlobalDefToRepMapTy;
 
     typedef Map<const Function*, SVFFunction*> LLVMFun2SVFFunMap;
-    typedef Map<const Function*, CallGraphNode*> LLVMFun2CallGraphNodeMap;
     typedef Map<const BasicBlock*, SVFBasicBlock*> LLVMBB2SVFBBMap;
     typedef Map<const Instruction*, SVFInstruction*> LLVMInst2SVFInstMap;
     typedef Map<const Argument*, SVFArgument*> LLVMArgument2SVFArgumentMap;
@@ -95,7 +94,6 @@ private:
     GlobalDefToRepMapTy GlobalDefToRepMap;
 
     LLVMFun2SVFFunMap LLVMFunc2SVFFunc; ///< Map an LLVM Function to an SVF Function
-    LLVMFun2CallGraphNodeMap LLVMFunc2CallGraphNode; ///< Map an LLVM Function to an CallGraph Node
     LLVMBB2SVFBBMap LLVMBB2SVFBB;
     LLVMInst2SVFInstMap LLVMInst2SVFInst;
     LLVMArgument2SVFArgumentMap LLVMArgument2SVFArgument;
@@ -112,7 +110,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;
 
     Map<const Function*, DominatorTree> FunToDominatorTree;
 
@@ -218,8 +216,6 @@ public:
         setValueAttr(func,svfFunc);
     }
 
-    void addFunctionMap(const Function* func, CallGraphNode* svfFunc);
-
     // create a SVFBasicBlock according to LLVM BasicBlock, then add it to SVFFunction's BasicBlockGraph
     inline void addBasicBlock(SVFFunction* fun, const BasicBlock* bb)
     {
@@ -296,13 +292,6 @@ public:
         return it->second;
     }
 
-    inline CallGraphNode* getCallGraphNode(const Function* fun) const
-    {
-        LLVMFun2CallGraphNodeMap::const_iterator it = LLVMFunc2CallGraphNode.find(fun);
-        assert(it!=LLVMFunc2CallGraphNode.end() && "SVF Function not found!");
-        return it->second;
-    }
-
     inline SVFFunction* getSVFFunction(const Function* fun) const
     {
         LLVMFun2SVFFunMap::const_iterator it = LLVMFunc2SVFFunc.find(fun);

package/SVF-linux/Release-build/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-linux/Release-build/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-linux/Release-build/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-linux/Release-build/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-osx/Release-build/include/AE/Svfexe/AbstractInterpretation.h

@@ -106,7 +106,7 @@ class AbstractInterpretation
     friend class BufOverflowDetector;
 
 public:
-    typedef SCCDetection<PTACallGraph*> CallGraphSCC;
+    typedef SCCDetection<CallGraph*> 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<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;
@@ -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;
     }
@@ -774,7 +774,7 @@ protected:
     SVFG* _svfg;					///< SVFG
     AndersenWaveDiff* _ander;		///< Andersen's analysis
     NodeBS candidateQueries;		///< candidate pointers;
-    PTACallGraph* _callGraph;		///< PTACallGraph
+    CallGraph* _callGraph;		///< PTACallGraph
     CallGraphSCC* _callGraphSCC;	///< SCC for PTACallGraph
     SVFGSCC* _svfgSCC;				///< SCC for SVFG
     DPTItemSet backwardVisited;		///< visited map during backward traversing

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

@@ -38,7 +38,7 @@
 namespace SVF
 {
 
-class PTACallGraphNode;
+class CallGraphNode;
 class SVFModule;
 class CallGraph;
 
@@ -48,8 +48,8 @@ class CallGraph;
  * 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<PTACallGraphNode> GenericPTACallGraphEdgeTy;
-class PTACallGraphEdge : public GenericPTACallGraphEdgeTy
+typedef GenericEdge<CallGraphNode> GenericPTACallGraphEdgeTy;
+class CallGraphEdge : public GenericPTACallGraphEdgeTy
 {
 
 public:
@@ -66,12 +66,12 @@ private:
     CallSiteID csId;
 public:
     /// Constructor
-    PTACallGraphEdge(PTACallGraphNode* s, PTACallGraphNode* d, CEDGEK kind, CallSiteID cs) :
+    CallGraphEdge(CallGraphNode* s, CallGraphNode* d, CEDGEK kind, CallSiteID cs) :
         GenericPTACallGraphEdgeTy(s, d, makeEdgeFlagWithInvokeID(kind, cs)), csId(cs)
     {
     }
     /// Destructor
-    virtual ~PTACallGraphEdge()
+    virtual ~CallGraphEdge()
     {
     }
     /// Compute the unique edgeFlag value from edge kind and CallSiteID.
@@ -141,21 +141,21 @@ public:
 
     /// ClassOf
     //@{
-    static inline bool classof(const PTACallGraphEdge*)
+    static inline bool classof(const CallGraphEdge*)
     {
         return true;
     }
     static inline bool classof(const GenericPTACallGraphEdgeTy *edge)
     {
-        return edge->getEdgeKind() == PTACallGraphEdge::CallRetEdge ||
-               edge->getEdgeKind() == PTACallGraphEdge::TDForkEdge ||
-               edge->getEdgeKind() == PTACallGraphEdge::TDJoinEdge;
+        return edge->getEdgeKind() == CallGraphEdge::CallRetEdge ||
+               edge->getEdgeKind() == CallGraphEdge::TDForkEdge ||
+               edge->getEdgeKind() == CallGraphEdge::TDJoinEdge;
     }
     //@}
 
     /// Overloading operator << for dumping ICFG node ID
     //@{
-    friend OutStream& operator<< (OutStream &o, const PTACallGraphEdge&edge)
+    friend OutStream& operator<< (OutStream &o, const CallGraphEdge&edge)
     {
         o << edge.toString();
         return o;
@@ -164,22 +164,22 @@ public:
 
     virtual const std::string toString() const;
 
-    typedef GenericNode<PTACallGraphNode, PTACallGraphEdge>::GEdgeSetTy CallGraphEdgeSet;
+    typedef GenericNode<CallGraphNode, CallGraphEdge>::GEdgeSetTy CallGraphEdgeSet;
 
 };
 
 /*
  * Call Graph node representing a function
  */
-typedef GenericNode<PTACallGraphNode, PTACallGraphEdge> GenericPTACallGraphNodeTy;
-class PTACallGraphNode : public GenericPTACallGraphNodeTy
+typedef GenericNode<CallGraphNode, CallGraphEdge> GenericPTACallGraphNodeTy;
+class CallGraphNode : public GenericPTACallGraphNodeTy
 {
 private:
     const SVFFunction* fun;
 
 public:
     /// Constructor
-    PTACallGraphNode(NodeID i, const SVFFunction* f) : GenericPTACallGraphNodeTy(i,CallNodeKd), fun(f)
+    CallGraphNode(NodeID i, const SVFFunction* f) : GenericPTACallGraphNodeTy(i,CallNodeKd), fun(f)
     {
 
     }
@@ -201,7 +201,7 @@ public:
 
     /// Overloading operator << for dumping ICFG node ID
     //@{
-    friend OutStream& operator<< (OutStream &o, const PTACallGraphNode&node)
+    friend OutStream& operator<< (OutStream &o, const CallGraphNode&node)
     {
         o << node.toString();
         return o;
@@ -212,7 +212,7 @@ public:
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const PTACallGraphNode*)
+    static inline bool classof(const CallGraphNode*)
     {
         return true;
     }
@@ -232,13 +232,13 @@ public:
 /*!
  * Pointer Analysis Call Graph used internally for various pointer analysis
  */
-typedef GenericGraph<PTACallGraphNode, PTACallGraphEdge> GenericPTACallGraphTy;
-class PTACallGraph : public GenericPTACallGraphTy
+typedef GenericGraph<CallGraphNode, CallGraphEdge> GenericPTACallGraphTy;
+class CallGraph : public GenericPTACallGraphTy
 {
 
 public:
-    typedef PTACallGraphEdge::CallGraphEdgeSet CallGraphEdgeSet;
-    typedef Map<const SVFFunction*, PTACallGraphNode*> FunToCallGraphNodeMap;
+    typedef CallGraphEdge::CallGraphEdgeSet CallGraphEdgeSet;
+    typedef Map<const SVFFunction*, CallGraphNode*> FunToCallGraphNodeMap;
     typedef Map<const CallICFGNode*, CallGraphEdgeSet> CallInstToCallGraphEdgesMap;
     typedef std::pair<const CallICFGNode*, const SVFFunction*> CallSitePair;
     typedef Map<CallSitePair, CallSiteID> CallSiteToIdMap;
@@ -291,7 +291,7 @@ protected:
     }
 
     /// Add call graph edge
-    inline void addEdge(PTACallGraphEdge* edge)
+    inline void addEdge(CallGraphEdge* edge)
     {
         edge->getDstNode()->addIncomingEdge(edge);
         edge->getSrcNode()->addOutgoingEdge(edge);
@@ -299,13 +299,13 @@ protected:
 
 public:
     /// Constructor
-    PTACallGraph(CGEK k = NormCallGraph);
+    CallGraph(CGEK k = NormCallGraph);
 
     /// Copy constructor
-    PTACallGraph(const PTACallGraph& other);
+    CallGraph(const CallGraph& other);
 
     /// Destructor
-    virtual ~PTACallGraph()
+    virtual ~CallGraph()
     {
         destroy();
     }
@@ -359,13 +359,13 @@ public:
     /// Get call graph node
     //@{
 
-    const PTACallGraphNode* getCallGraphNode(const std::string& name);
+    const CallGraphNode* getCallGraphNode(const std::string& name);
 
-    inline PTACallGraphNode* getCallGraphNode(NodeID id) const
+    inline CallGraphNode* getCallGraphNode(NodeID id) const
     {
         return getGNode(id);
     }
-    inline PTACallGraphNode* getCallGraphNode(const SVFFunction* fun) const
+    inline CallGraphNode* getCallGraphNode(const SVFFunction* fun) const
     {
         FunToCallGraphNodeMap::const_iterator it = funToCallGraphNodeMap.find(fun);
         assert(it!=funToCallGraphNodeMap.end() && "call graph node not found!!");
@@ -409,11 +409,11 @@ public:
     }
     //@}
     /// Whether we have already created this call graph edge
-    PTACallGraphEdge* hasGraphEdge(PTACallGraphNode* src, PTACallGraphNode* dst,
-                                   PTACallGraphEdge::CEDGEK kind, CallSiteID csId) const;
+    CallGraphEdge* hasGraphEdge(CallGraphNode* src, CallGraphNode* dst,
+                                CallGraphEdge::CEDGEK kind, CallSiteID csId) const;
     /// Get call graph edge via nodes
-    PTACallGraphEdge* getGraphEdge(PTACallGraphNode* src, PTACallGraphNode* dst,
-                                   PTACallGraphEdge::CEDGEK kind, CallSiteID csId);
+    CallGraphEdge* getGraphEdge(CallGraphNode* src, CallGraphNode* dst,
+                                CallGraphEdge::CEDGEK kind, CallSiteID csId);
 
     /// Get all callees for a callsite
     inline void getCallees(const CallICFGNode* cs, FunctionSet& callees)
@@ -459,9 +459,9 @@ public:
 
     /// Get callsites invoking the callee
     //@{
-    void getAllCallSitesInvokingCallee(const SVFFunction* callee, PTACallGraphEdge::CallInstSet& csSet);
-    void getDirCallSitesInvokingCallee(const SVFFunction* callee, PTACallGraphEdge::CallInstSet& csSet);
-    void getIndCallSitesInvokingCallee(const SVFFunction* callee, PTACallGraphEdge::CallInstSet& csSet);
+    void getAllCallSitesInvokingCallee(const SVFFunction* callee, CallGraphEdge::CallInstSet& csSet);
+    void getDirCallSitesInvokingCallee(const SVFFunction* callee, CallGraphEdge::CallInstSet& csSet);
+    void getIndCallSitesInvokingCallee(const SVFFunction* callee, CallGraphEdge::CallInstSet& csSet);
     //@}
 
     /// Whether its reachable between two functions
@@ -482,19 +482,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::PTACallGraphNode*> : public GenericGraphTraits<SVF::GenericNode<SVF::PTACallGraphNode,SVF::PTACallGraphEdge>*  >
+template<> struct GenericGraphTraits<SVF::CallGraphNode*> : public GenericGraphTraits<SVF::GenericNode<SVF::CallGraphNode,SVF::CallGraphEdge>*  >
 {
 };
 
 /// Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal.
 template<>
-struct GenericGraphTraits<Inverse<SVF::PTACallGraphNode*> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::PTACallGraphNode,SVF::PTACallGraphEdge>* > >
+struct GenericGraphTraits<Inverse<SVF::CallGraphNode*> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::CallGraphNode,SVF::CallGraphEdge>* > >
 {
 };
 
-template<> struct GenericGraphTraits<SVF::PTACallGraph*> : public GenericGraphTraits<SVF::GenericGraph<SVF::PTACallGraphNode,SVF::PTACallGraphEdge>* >
+template<> struct GenericGraphTraits<SVF::CallGraph*> : public GenericGraphTraits<SVF::GenericGraph<SVF::CallGraphNode,SVF::CallGraphEdge>* >
 {
-    typedef SVF::PTACallGraphNode*NodeRef;
+    typedef SVF::CallGraphNode*NodeRef;
 };
 
 } // End namespace llvm

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

@@ -38,7 +38,7 @@
 namespace SVF
 {
 
-class PTACallGraph;
+class CallGraph;
 
 /*!
  * Interprocedural Control-Flow Graph (ICFG)
@@ -111,7 +111,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)