svf-lib 1.0.732 → 1.0.736

package/SVF-linux/include/Graphs/VFG.h

@@ -31,7 +31,7 @@
 #define INCLUDE_UTIL_VFG_H_
 
 
-#include "Graphs/PAG.h"
+#include "MemoryModel/SVFIR.h"
 #include "Graphs/PTACallGraph.h"
 #include "Graphs/VFGNode.h"
 #include "Graphs/VFGEdge.h"
@@ -78,7 +78,7 @@ public:
     typedef VFGEdge::VFGEdgeSetTy::iterator VFGNodeIter;
     typedef VFGNodeIDToNodeMapTy::iterator iterator;
     typedef VFGNodeIDToNodeMapTy::const_iterator const_iterator;
-    typedef PAG::PAGEdgeSet PAGEdgeSet;
+    typedef SVFIR::PAGEdgeSet PAGEdgeSet;
     typedef Set<const VFGNode*> GlobalVFGNodeSet;
     typedef Set<const PAGNode*> PAGNodeSet;
 
@@ -99,7 +99,7 @@ protected:
 
     GlobalVFGNodeSet globalVFGNodes;	///< set of global store VFG nodes
     PTACallGraph* callgraph;
-    PAG* pag;
+    SVFIR* pag;
     VFGK kind;
 
     /// Clean up memory
@@ -127,8 +127,8 @@ public:
         return (kind == PTRONLYSVFG) || (kind == PTRONLYSVFG_OPT);
     }
 
-    /// Return PAG
-    inline PAG* getPAG() const
+    /// Return SVFIR
+    inline SVFIR* getPAG() const
     {
         return pag;
     }
@@ -261,12 +261,12 @@ public:
             const VFGNode* defNode = getVFGNode(getDef(pagNode));
             if (const AddrVFGNode* addr = SVFUtil::dyn_cast<AddrVFGNode>(defNode))
             {
-                if (PAG::getPAG()->isBlkObjOrConstantObj(addr->getPAGEdge()->getSrcID()))
+                if (SVFIR::getPAG()->isBlkObjOrConstantObj(addr->getPAGEdge()->getSrcID()))
                     return true;
             }
             else if(const CopyVFGNode* copy = SVFUtil::dyn_cast<CopyVFGNode>(defNode))
             {
-                if (PAG::getPAG()->isNullPtr(copy->getPAGEdge()->getSrcID()))
+                if (SVFIR::getPAG()->isNullPtr(copy->getPAGEdge()->getSrcID()))
                     return true;
             }
         }
@@ -400,13 +400,13 @@ protected:
         }
         else
         {
-            assert((it->second == node->getId()) && "a PAG node can only have unique definition ");
+            assert((it->second == node->getId()) && "a SVFIR node can only have unique definition ");
         }
     }
     inline NodeID getDef(const PAGNode* pagNode) const
     {
         PAGNodeToDefMapTy::const_iterator it = PAGNodeToDefMap.find(pagNode);
-        assert(it!=PAGNodeToDefMap.end() && "PAG node does not have a definition??");
+        assert(it!=PAGNodeToDefMap.end() && "SVFIR node does not have a definition??");
         return it->second;
     }
     inline bool hasDef(const PAGNode* pagNode) const
@@ -503,7 +503,7 @@ protected:
         setDef(load->getDstNode(),sNode);
     }
     /// Add a Store VFG node,
-    /// To be noted store does not create a new pointer, we do not set def for any PAG node
+    /// To be noted store does not create a new pointer, we do not set def for any SVFIR node
     void addStoreVFGNode(const StorePE* store)
     {
         StoreVFGNode* sNode = new StoreVFGNode(totalVFGNode++,store);
@@ -545,7 +545,7 @@ protected:
 		PAGNodeToFormalRetMap[uniqueFunRet] = sNode;
 		/// if this uniqueFunRet is a phi node, which means it will receive values from multiple return instructions of fun
 		/// we will set this phi node's def later
-		/// Ideally, every function uniqueFunRet should be a PhiNode (PAGBuilder.cpp), unless it does not have ret instruction
+		/// Ideally, every function uniqueFunRet should be a PhiNode (SVFIRBuilder.cpp), unless it does not have ret instruction
 		if (!pag->isPhiNode(uniqueFunRet)){
 			std::string warn = fun->getName().str();
 			SVFUtil::writeWrnMsg(warn + " does not have any ret instruction!");
@@ -561,70 +561,55 @@ protected:
         PAGNodeToActualRetMap[ret] = sNode;
     }
     /// Add an llvm PHI VFG node
-    inline void addIntraPHIVFGNode(const PAGNode* phiResNode, PAG::CopyPEList& oplist)
+    inline void addIntraPHIVFGNode(const PhiPE* edge)
     {
-        IntraPHIVFGNode* sNode = new IntraPHIVFGNode(totalVFGNode++,phiResNode);
+        IntraPHIVFGNode* sNode = new IntraPHIVFGNode(totalVFGNode++,edge->getRes());
         u32_t pos = 0;
-        const PAGEdge* edge = nullptr;
-        for(PAG::CopyPEList::const_iterator it = oplist.begin(), eit=oplist.end(); it!=eit; ++it,++pos)
+        for(auto var : edge->getOpndVars())
         {
-            edge = *it;
-            sNode->setOpVerAndBB(pos, edge->getSrcNode(), edge->getICFGNode());
+            sNode->setOpVerAndBB(pos, var, edge->getICFGNode());
+            pos++;
         }
-        assert(edge && "edge not found?");
         addVFGNode(sNode,edge->getICFGNode());
-        setDef(phiResNode,sNode);
-        PAGNodeToIntraPHIVFGNodeMap[phiResNode] = sNode;
+        setDef(edge->getRes(),sNode);
+        PAGNodeToIntraPHIVFGNodeMap[edge->getRes()] = sNode;
     }
     /// Add a Compare VFG node
-    inline void addCmpVFGNode(const PAGNode* resNode, PAG::CmpPEList& oplist)
+    inline void addCmpVFGNode(const CmpPE* edge)
     {
-        CmpVFGNode* sNode = new CmpVFGNode(totalVFGNode++, resNode);
+        CmpVFGNode* sNode = new CmpVFGNode(totalVFGNode++, edge->getRes());
         u32_t pos = 0;
-        const PAGEdge* edge = nullptr;
-        for(PAG::CmpPEList::const_iterator it = oplist.begin(), eit=oplist.end(); it!=eit; ++it,++pos)
+        for(auto var : edge->getOpndVars())
         {
-            edge = *it;
-            sNode->setOpVer(pos, edge->getSrcNode());
+            sNode->setOpVer(pos, var);
+            pos++;
         }
-        assert(edge && "edge not found?");
         addVFGNode(sNode,edge->getICFGNode());
-        setDef(resNode,sNode);
-        PAGNodeToCmpVFGNodeMap[resNode] = sNode;
+        setDef(edge->getRes(),sNode);
+        PAGNodeToCmpVFGNodeMap[edge->getRes()] = sNode;
     }
     /// Add a BinaryOperator VFG node
-    inline void addBinaryOPVFGNode(const PAGNode* resNode, PAG::BinaryOPList& oplist)
+    inline void addBinaryOPVFGNode(const BinaryOPPE* edge)
     {
-        BinaryOPVFGNode* sNode = new BinaryOPVFGNode(totalVFGNode++, resNode);
+        BinaryOPVFGNode* sNode = new BinaryOPVFGNode(totalVFGNode++, edge->getRes());
         u32_t pos = 0;
-        const PAGEdge* edge = nullptr;
-        for(PAG::BinaryOPList::const_iterator it = oplist.begin(), eit=oplist.end(); it!=eit; ++it,++pos)
+        for(auto var : edge->getOpndVars())
         {
-            edge = *it;
-            sNode->setOpVer(pos, (*it)->getSrcNode());
+            sNode->setOpVer(pos, var);
+            pos++;
         }
-
-        assert(edge && "edge not found?");
         addVFGNode(sNode,edge->getICFGNode());
-        setDef(resNode,sNode);
-        PAGNodeToBinaryOPVFGNodeMap[resNode] = sNode;
+        setDef(edge->getRes(),sNode);
+        PAGNodeToBinaryOPVFGNodeMap[edge->getRes()] = sNode;
     }
     /// Add a UnaryOperator VFG node
-    inline void addUnaryOPVFGNode(const PAGNode* resNode, PAG::UnaryOPList& oplist)
+    inline void addUnaryOPVFGNode(const UnaryOPPE* edge)
     {
-        UnaryOPVFGNode* sNode = new UnaryOPVFGNode(totalVFGNode++, resNode);
-        u32_t pos = 0;
-        const PAGEdge* edge = nullptr;
-        for(PAG::UnaryOPList::const_iterator it = oplist.begin(), eit=oplist.end(); it!=eit; ++it,++pos)
-        {
-            edge = *it;
-            sNode->setOpVer(pos, (*it)->getSrcNode());
-        }
-
-        assert(edge && "edge not found?");
+        UnaryOPVFGNode* sNode = new UnaryOPVFGNode(totalVFGNode++, edge->getDstNode());
+        sNode->setOpVer(0, edge->getSrcNode());
         addVFGNode(sNode,edge->getICFGNode());
-        setDef(resNode,sNode);
-        PAGNodeToUnaryOPVFGNodeMap[resNode] = sNode;
+        setDef(edge->getDstNode(),sNode);
+        PAGNodeToUnaryOPVFGNodeMap[edge->getDstNode()] = sNode;
     }
 };
 

package/SVF-linux/include/Graphs/VFGNode.h

@@ -33,8 +33,7 @@
 #include "Graphs/GenericGraph.h"
 #include "Graphs/VFGEdge.h"
 #include "Graphs/ICFGNode.h"
-#include "Graphs/PAGNode.h"
-#include "Graphs/PAGEdge.h"
+#include "MemoryModel/SVFIR.h"
 
 namespace SVF
 {
@@ -331,7 +330,7 @@ public:
     CmpVFGNode(NodeID id,const PAGNode* r): VFGNode(id,Cmp), res(r)
     {
         const CmpInst* cmp = SVFUtil::dyn_cast<CmpInst>(r->getValue());
-        assert(cmp && "not a binary operator?");
+        assert(cmp && "not a compare operator?");
     }
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{

package/SVF-linux/include/MSSA/MemRegion.h

@@ -30,7 +30,7 @@
 #ifndef MEMORYREGION_H_
 #define MEMORYREGION_H_
 
-#include "Graphs/PAG.h"
+#include "MemoryModel/SVFIR.h"
 #include "Graphs/PTACallGraph.h"
 #include "Util/SCC.h"
 #include "Util/WorkList.h"
@@ -168,8 +168,8 @@ public:
 
     typedef Map<NodeID, NodeBS> NodeToPTSSMap;
 
-    /// PAG edge list
-    typedef PAG::PAGEdgeList PAGEdgeList;
+    /// SVFIR edge list
+    typedef SVFIR::PAGEdgeList PAGEdgeList;
     /// Call Graph SCC
     typedef SCCDetection<PTACallGraph*> SCC;
 
@@ -197,17 +197,17 @@ private:
 
     /// Map a function to all its memory regions
     FunToMRsMap funToMRsMap;
-    /// Map a load PAG Edge to its memory regions sets in order for inserting mus in Memory SSA
+    /// Map a load SVFIR Edge to its memory regions sets in order for inserting mus in Memory SSA
     LoadsToMRsMap loadsToMRsMap;
-    /// Map a store PAG Edge to its memory regions sets in order for inserting chis in Memory SSA
+    /// Map a store SVFIR Edge to its memory regions sets in order for inserting chis in Memory SSA
     StoresToMRsMap storesToMRsMap;
     /// Map a callsite to its refs regions
     CallSiteToMRsMap callsiteToRefMRsMap;
     /// Map a callsite to its mods regions
     CallSiteToMRsMap callsiteToModMRsMap;
-    /// Map a load PAG Edge to its CPts set map
+    /// Map a load SVFIR Edge to its CPts set map
     LoadsToPointsToMap loadsToPointsToMap;
-    /// Map a store PAG Edge to its CPts set map
+    /// Map a store SVFIR Edge to its CPts set map
     StoresToPointsToMap	storesToPointsToMap;
     /// Map a callsite to it refs cpts set
     CallSiteToPointsToMap callsiteToRefPointsToMap;
@@ -235,7 +235,7 @@ private:
     /// Map a pointer to its cached points-to chain;
     NodeToPTSSMap cachedPtsChainMap;
 
-    /// All global variable PAG node ids
+    /// All global variable SVFIR node ids
     NodeBS allGlobals;
 
     /// Clean up memory
@@ -427,11 +427,11 @@ public:
     /// Start generating memory regions
     virtual void generateMRs();
 
-    /// Get the function which PAG Edge located
+    /// Get the function which SVFIR Edge located
     const SVFFunction* getFunction(const PAGEdge* pagEdge) const
     {
         PAGEdgeToFunMap::const_iterator it = pagEdgeToFunMap.find(pagEdge);
-        assert(it!=pagEdgeToFunMap.end() && "can not find its function, it is a global PAG edge");
+        assert(it!=pagEdgeToFunMap.end() && "can not find its function, it is a global SVFIR edge");
         return it->second;
     }
     /// Get Memory Region set
@@ -465,7 +465,7 @@ public:
         return callsiteToModMRsMap[cs];
     }
     //@}
-    /// Whether this instruction has PAG Edge
+    /// Whether this instruction has SVFIR Edge
     bool hasPAGEdgeList(const Instruction* inst);
     /// Given an instruction, get all its the PAGEdge (statement) in sequence
     PAGEdgeList& getPAGEdgesFromInst(const Instruction* inst);

package/SVF-linux/include/MSSA/MemSSA.h

@@ -93,8 +93,8 @@ public:
     typedef Map<const MemRegion*, std::vector<MRVer*> > MemRegToVerStackMap;
     typedef Map<const MemRegion*, MRVERSION> MemRegToCounterMap;
 
-    /// PAG edge list
-    typedef PAG::PAGEdgeList PAGEdgeList;
+    /// SVFIR edge list
+    typedef SVFIR::PAGEdgeList PAGEdgeList;
 
     /// Statistics
     //@{
@@ -309,8 +309,8 @@ public:
     {
         destroy();
     }
-    /// Return PAG
-    inline PAG* getPAG();
+    /// Return SVFIR
+    inline SVFIR* getPAG();
     /// Return PTA
     inline BVDataPTAImpl* getPTA() const
     {

package/SVF-linux/include/MTA/FSMPTA.h

@@ -184,7 +184,7 @@ public:
     /// Initialize analysis
     void initialize(SVFModule* module);
 	
-	inline PAG* getPAG() {
+	inline SVFIR* getPAG() {
 		return mhp->getTCT()->getPTA()->getPAG();
 	}
 	

package/SVF-linux/include/MemoryModel/PAGBuilderFromFile.h

@@ -1,4 +1,4 @@
-//===- PAGBuilderFromFile.h -- Building PAG from File--------------------------------//
+//===- PAGBuilderFromFile.h -- Building SVFIR from File--------------------------------//
 //
 //                     SVF: Static Value-Flow Analysis
 //
@@ -30,24 +30,24 @@
 #ifndef INCLUDE_MEMORYMODEL_PAGBUILDERFROMFILE_H_
 #define INCLUDE_MEMORYMODEL_PAGBUILDERFROMFILE_H_
 
-#include "Graphs/PAG.h"
+#include "MemoryModel/SVFIR.h"
 
 namespace SVF
 {
 
 /*!
- * Build PAG from a user specified file (for debugging purpose)
+ * Build SVFIR from a user specified file (for debugging purpose)
  */
 class PAGBuilderFromFile
 {
 
 private:
-    PAG* pag;
+    SVFIR* pag;
     std::string file;
 public:
     /// Constructor
     PAGBuilderFromFile(std::string f) :
-        pag(PAG::getPAG(true)), file(f)
+        pag(SVFIR::getPAG(true)), file(f)
     {
     }
     /// Destructor
@@ -55,8 +55,8 @@ public:
     {
     }
 
-    /// Return PAG
-    PAG* getPAG() const
+    /// Return SVFIR
+    SVFIR* getPAG() const
     {
         return pag;
     }
@@ -68,7 +68,7 @@ public:
     }
 
     /// Start building
-    PAG* build();
+    SVFIR* build();
 
     // Add edges
     void addEdge(NodeID nodeSrc, NodeID nodeDst, Size_t offset,

package/SVF-linux/include/MemoryModel/PTAStat.h

@@ -57,49 +57,49 @@ public:
     static const char* ProcessCopyGepTime;	///< time of processing copys and geps
     static const char* UpdateCallGraphTime;	///< time of updating call graph
 
-    static const char* TotalNumOfPointers;	///< Total PAG value node
-    static const char* TotalNumOfObjects;	///< Total PAG object node
-    static const char* TotalNumOfFieldObjects;	///< Total PAG field object node
+    static const char* TotalNumOfPointers;	///< Total SVFIR value node
+    static const char* TotalNumOfObjects;	///< Total SVFIR object node
+    static const char* TotalNumOfFieldObjects;	///< Total SVFIR field object node
     static const char* MaxStructSize;	///< Max struct size
-    static const char* TotalNumOfEdges;	///< Total PAG edge number
-
-    static const char* NumOfAddrs;		///< PAG addr edge
-    static const char* NumOfLoads;		///< PAG load edge
-    static const char* NumOfStores;		///< PAG store edge
-    static const char* NumOfCopys;		///< PAG copy edge
-    static const char* NumOfGeps;		///< PAG gep edge
-    static const char* NumOfCalls;		///< PAG call edge
-    static const char* NumOfReturns;	///< PAG return edge
-
-    static const char* NumOfProcessedAddrs;		///< PAG processed addr edge
-    static const char* NumOfProcessedLoads;		///< PAG processed load edge
-    static const char* NumOfProcessedStores;	///< PAG processed store edge
-    static const char* NumOfProcessedCopys;		///< PAG processed copy edge
-    static const char* NumOfProcessedGeps;		///< PAG processed gep edge
+    static const char* TotalNumOfEdges;	///< Total SVFIR edge number
+
+    static const char* NumOfAddrs;		///< SVFIR addr edge
+    static const char* NumOfLoads;		///< SVFIR load edge
+    static const char* NumOfStores;		///< SVFIR store edge
+    static const char* NumOfCopys;		///< SVFIR copy edge
+    static const char* NumOfGeps;		///< SVFIR gep edge
+    static const char* NumOfCalls;		///< SVFIR call edge
+    static const char* NumOfReturns;	///< SVFIR return edge
+
+    static const char* NumOfProcessedAddrs;		///< SVFIR processed addr edge
+    static const char* NumOfProcessedLoads;		///< SVFIR processed load edge
+    static const char* NumOfProcessedStores;	///< SVFIR processed store edge
+    static const char* NumOfProcessedCopys;		///< SVFIR processed copy edge
+    static const char* NumOfProcessedGeps;		///< SVFIR processed gep edge
 
     static const char* NumOfSfr;                ///< num of field representatives
     static const char* NumOfFieldExpand;
 
     static const char* NumOfFunctionObjs;	///< Function numbers
-    static const char* NumOfGlobalObjs;	///< PAG global object node
-    static const char* NumOfHeapObjs;	///< PAG heap object node
-    static const char* NumOfStackObjs;	///< PAG stack object node
+    static const char* NumOfGlobalObjs;	///< SVFIR global object node
+    static const char* NumOfHeapObjs;	///< SVFIR heap object node
+    static const char* NumOfStackObjs;	///< SVFIR stack object node
 
-    static const char* NumOfObjsHasVarStruct;	///< PAG object node has var struct (maybe nested with array)
-    static const char* NumOfObjsHasVarArray;	///< PAG object node has var array (maybe nested with struct)
-    static const char* NumOfObjsHasConstStruct;	///< PAG object node has const struct (maybe nested with array)
-    static const char* NumOfObjsHasConstArray;	///< PAG object node has const array (maybe nested with struct)
-    static const char* NumOfNonPtrObjs;	///< PAG object node which is non pointer type object (do not have pts)
-    static const char* NumOfConstantObjs;	///< PAG object node which is purely constant
+    static const char* NumOfObjsHasVarStruct;	///< SVFIR object node has var struct (maybe nested with array)
+    static const char* NumOfObjsHasVarArray;	///< SVFIR object node has var array (maybe nested with struct)
+    static const char* NumOfObjsHasConstStruct;	///< SVFIR object node has const struct (maybe nested with array)
+    static const char* NumOfObjsHasConstArray;	///< SVFIR object node has const array (maybe nested with struct)
+    static const char* NumOfNonPtrObjs;	///< SVFIR object node which is non pointer type object (do not have pts)
+    static const char* NumOfConstantObjs;	///< SVFIR object node which is purely constant
 
     static const char* NumberOfFieldInsensitiveObj;
     static const char* NumberOfFieldSensitiveObj;
 
-    static const char* NumOfPointers;	///< PAG value node, each of them maps to a llvm value
-    static const char* NumOfGepFieldPointers;	///< PAG gep value node (field value, dynamically created dummy node)
+    static const char* NumOfPointers;	///< SVFIR value node, each of them maps to a llvm value
+    static const char* NumOfGepFieldPointers;	///< SVFIR gep value node (field value, dynamically created dummy node)
 
-    static const char* NumOfMemObjects;	///< PAG object node, each of them maps to a llvm value
-    static const char* NumOfGepFieldObjects;	///< PAG gep object node (field obj, dynamically created dummy node)
+    static const char* NumOfMemObjects;	///< SVFIR object node, each of them maps to a llvm value
+    static const char* NumOfGepFieldObjects;	///< SVFIR gep object node (field obj, dynamically created dummy node)
 
     static const char* AveragePointsToSetSize;		///< Average points-to size of all variables
     static const char* AverageTopLevPointsToSetSize; ///< Average points-to size of top-level variables

package/SVF-linux/include/MemoryModel/PointerAnalysis.h

@@ -33,7 +33,7 @@
 #include <unistd.h>
 #include <signal.h>
 
-#include "Graphs/PAG.h"
+#include "MemoryModel/SVFIR.h"
 #include "MemoryModel/ConditionalPT.h"
 #include "MemoryModel/AbstractPointsToDS.h"
 #include "MemoryModel/MutablePointsToDS.h"
@@ -106,7 +106,7 @@ public:
     //@{
     typedef llvm::AliasAnalysis AliasAnalysis;
     typedef Set<const CallBlockNode*> CallSiteSet;
-    typedef PAG::CallSiteToFunPtrMap CallSiteToFunPtrMap;
+    typedef SVFIR::CallSiteToFunPtrMap CallSiteToFunPtrMap;
     typedef Set<const SVFFunction*> FunctionSet;
     typedef OrderedMap<const CallBlockNode*, FunctionSet> CallEdgeMap;
     typedef SCCDetection<PTACallGraph*> CallGraphSCC;
@@ -143,8 +143,8 @@ protected:
     u32_t OnTheFlyIterBudgetForStat;
     //@}
 
-    /// PAG
-    static PAG* pag;
+    /// SVFIR
+    static SVFIR* pag;
     /// Module
     SVFModule* svfMod;
     /// Pointer analysis Type
@@ -186,7 +186,7 @@ public:
     }
 
     /// Constructor
-    PointerAnalysis(PAG* pag, PTATY ty = Default_PTA, bool alias_check = true);
+    PointerAnalysis(SVFIR* pag, PTATY ty = Default_PTA, bool alias_check = true);
 
     /// Type of pointer analysis
     inline PTATY getAnalysisTy() const
@@ -200,9 +200,9 @@ public:
         return ptaImplTy;
     }
 
-    /// Get/set PAG
+    /// Get/set SVFIR
     ///@{
-    inline PAG* getPAG() const
+    inline SVFIR* getPAG() const
     {
         return pag;
     }
@@ -227,7 +227,7 @@ public:
     /// Destructor
     virtual ~PointerAnalysis();
 
-    /// Initialization of a pointer analysis, including building symbol table and PAG etc.
+    /// Initialization of a pointer analysis, including building symbol table and SVFIR etc.
     virtual void initialize();
 
     /// Finalization of a pointer analysis, including checking alias correctness
@@ -344,7 +344,7 @@ public:
     ///@{
     inline bool isFIObjNode(NodeID id) const
     {
-        return (SVFUtil::isa<FIObjPN>(pag->getPAGNode(id)));
+        return (SVFUtil::isa<FIObjPN>(pag->getGNode(id)));
     }
     inline NodeID getBaseObjNode(NodeID id)
     {

package/SVF-linux/include/MemoryModel/PointerAnalysisImpl.h

@@ -68,7 +68,7 @@ public:
     };
 
     /// Constructor
-    BVDataPTAImpl(PAG* pag, PointerAnalysis::PTATY type, bool alias_check = true);
+    BVDataPTAImpl(SVFIR* pag, PointerAnalysis::PTATY type, bool alias_check = true);
 
     /// Destructor
     virtual ~BVDataPTAImpl()
@@ -261,7 +261,7 @@ public:
     typedef Map<NodeID,CPtSet> PtrToCPtsMap;	 /// map a pointer to its conditional points-to set
 
     /// Constructor
-    CondPTAImpl(PAG* pag, PointerAnalysis::PTATY type) : PointerAnalysis(pag, type), normalized(false)
+    CondPTAImpl(SVFIR* pag, PointerAnalysis::PTATY type) : PointerAnalysis(pag, type), normalized(false)
     {
         if (type == PathS_DDA || type == Cxt_DDA)
             ptD = new MutPTDataTy();
@@ -574,7 +574,7 @@ public:
     {
         for (OrderedNodeSet::iterator nIter = this->getAllValidPtrs().begin(); nIter != this->getAllValidPtrs().end(); ++nIter)
         {
-            const PAGNode* node = this->getPAG()->getPAGNode(*nIter);
+            const PAGNode* node = this->getPAG()->getGNode(*nIter);
             if (this->getPAG()->isValidTopLevelPtr(node))
             {
                 if (SVFUtil::isa<DummyObjPN>(node))