svf-lib 1.0.730 → 1.0.734

package/SVF-linux/include/DDA/ContextDDA.h

@@ -28,7 +28,7 @@ class ContextDDA : public CondPTAImpl<ContextCond>, public DDAVFSolver<CxtVar,Cx
 
 public:
     /// Constructor
-    ContextDDA(PAG* _pag, DDAClient* client);
+    ContextDDA(SVFIR* _pag, DDAClient* client);
 
     /// Destructor
     virtual ~ContextDDA();

package/SVF-linux/include/DDA/DDAClient.h

@@ -11,7 +11,7 @@
 #ifndef DDACLIENT_H_
 #define DDACLIENT_H_
 
-#include "Graphs/PAG.h"
+#include "MemoryModel/SVFIR.h"
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "Graphs/SVFG.h"
 #include "Util/BasicTypes.h"
@@ -32,7 +32,7 @@ public:
     virtual inline void initialise(SVFModule*) {}
 
     /// Collect candidate pointers for query.
-    virtual inline OrderedNodeSet& collectCandidateQueries(PAG* p)
+    virtual inline OrderedNodeSet& collectCandidateQueries(SVFIR* p)
     {
         setPAG(p);
         if (solveAll)
@@ -52,8 +52,8 @@ public:
 
     /// Call back used by DDAVFSolver.
     virtual inline void handleStatement(const SVFGNode*, NodeID) {}
-    /// Set PAG graph.
-    inline void setPAG(PAG* g)
+    /// Set SVFIR graph.
+    inline void setPAG(SVFIR* g)
     {
         pag = g;
     }
@@ -81,11 +81,11 @@ public:
 protected:
     void addCandidate(NodeID id)
     {
-        if (pag->isValidTopLevelPtr(pag->getPAGNode(id)))
+        if (pag->isValidTopLevelPtr(pag->getGNode(id)))
             candidateQueries.insert(id);
     }
 
-    PAG*   pag;					///< PAG graph used by current DDA analysis
+    SVFIR*   pag;					///< SVFIR graph used by current DDA analysis
     SVFModule* module;		///< LLVM module
     NodeID curPtr;				///< current pointer being queried
     OrderedNodeSet candidateQueries;	///< store all candidate pointers to be queried
@@ -109,7 +109,7 @@ public:
     ~FunptrDDAClient() {}
 
     /// Only collect function pointers as query candidates.
-    virtual OrderedNodeSet& collectCandidateQueries(PAG* p);
+    virtual OrderedNodeSet& collectCandidateQueries(SVFIR* p);
     virtual void performStat(PointerAnalysis* pta);
 };
 
@@ -128,7 +128,7 @@ public:
     ~AliasDDAClient() {}
 
     /// Only collect function pointers as query candidates.
-    virtual OrderedNodeSet& collectCandidateQueries(PAG* pag);
+    virtual OrderedNodeSet& collectCandidateQueries(SVFIR* pag);
 
     virtual void performStat(PointerAnalysis* pta);
 

package/SVF-linux/include/DDA/DDAVFSolver.h

@@ -29,7 +29,7 @@ public:
     typedef SCCDetection<SVFG*> SVFGSCC;
     typedef SCCDetection<PTACallGraph*> CallGraphSCC;
     typedef PTACallGraphEdge::CallInstSet CallInstSet;
-    typedef PAG::CallSiteSet CallSiteSet;
+    typedef SVFIR::CallSiteSet CallSiteSet;
     typedef OrderedSet<DPIm> DPTItemSet;
     typedef OrderedMap<DPIm, CPtSet> DPImToCPtSetMap;
     typedef OrderedMap<DPIm,CVar> DPMToCVarMap;
@@ -287,7 +287,7 @@ protected:
     }
 
     /// Build SVFG
-    virtual inline void buildSVFG(PAG* pag)
+    virtual inline void buildSVFG(SVFIR* pag)
     {
         _ander = AndersenWaveDiff::createAndersenWaveDiff(pag);
         _svfg = svfgBuilder.buildPTROnlySVFGWithoutOPT(_ander);
@@ -448,7 +448,7 @@ protected:
         assert(obj && "object not found!!");
         if(obj->isStack())
         {
-            if(const AllocaInst* local = SVFUtil::dyn_cast<AllocaInst>(obj->getRefVal()))
+            if(const AllocaInst* local = SVFUtil::dyn_cast<AllocaInst>(obj->getValue()))
             {
                 const SVFFunction* fun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(local->getFunction());
                 return _callGraphSCC->isInCycle(_callGraph->getCallGraphNode(fun)->getId());
@@ -473,7 +473,7 @@ protected:
             {
                 NodeID funPtr = _pag->getFunPtr(cbn);
                 DPIm funPtrDpm(dpm);
-                funPtrDpm.setLocVar(getSVFG()->getDefSVFGNode(_pag->getPAGNode(funPtr)),funPtr);
+                funPtrDpm.setLocVar(getSVFG()->getDefSVFGNode(_pag->getGNode(funPtr)),funPtr);
                 findPT(funPtrDpm);
             }
         }
@@ -486,7 +486,7 @@ protected:
             {
                 NodeID funPtr = _pag->getFunPtr(*it);
                 DPIm funPtrDpm(dpm);
-                funPtrDpm.setLocVar(getSVFG()->getDefSVFGNode(_pag->getPAGNode(funPtr)),funPtr);
+                funPtrDpm.setLocVar(getSVFG()->getDefSVFGNode(_pag->getGNode(funPtr)),funPtr);
                 findPT(funPtrDpm);
             }
         }
@@ -750,7 +750,7 @@ protected:
     }
 
     bool outOfBudgetQuery;			///< Whether the current query is out of step limits
-    PAG* _pag;						///< PAG
+    SVFIR* _pag;						///< SVFIR
     SVFG* _svfg;					///< SVFG
     AndersenWaveDiff* _ander;		///< Andersen's analysis
     NodeBS candidateQueries;		///< candidate pointers;

package/SVF-linux/include/DDA/FlowDDA.h

@@ -30,7 +30,7 @@ public:
     typedef BVDataPTAImpl::CallEdgeMap	CallEdgeMap;
     typedef BVDataPTAImpl::FunctionSet	FunctionSet;
     /// Constructor
-    FlowDDA(PAG* _pag, DDAClient* client): BVDataPTAImpl(_pag, PointerAnalysis::FlowS_DDA),
+    FlowDDA(SVFIR* _pag, DDAClient* client): BVDataPTAImpl(_pag, PointerAnalysis::FlowS_DDA),
         DDAVFSolver<NodeID,PointsTo,LocDPItem>(),
         _client(client)
     {

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

@@ -52,7 +52,7 @@ public:
     typedef FIFOWorkList<NodeID> WorkList;
 
 protected:
-    PAG*pag;
+    SVFIR*pag;
     NodeToRepMap nodeToRepMap;
     NodeToSubsMap nodeToSubsMap;
     WorkList nodesToBeCollapsed;
@@ -92,7 +92,7 @@ protected:
 
 public:
     /// Constructor
-    ConstraintGraph(PAG* p): pag(p), edgeIndex(0)
+    ConstraintGraph(SVFIR* p): pag(p), edgeIndex(0)
     {
         buildCG();
     }
@@ -172,7 +172,7 @@ public:
         }
     }
 
-    ///Add a PAG edge into Edge map
+    ///Add a SVFIR edge into Edge map
     //@{
     /// Add Address edge
     AddrCGEdge* addAddrCGEdge(NodeID src, NodeID dst);
@@ -187,7 +187,7 @@ public:
     StoreCGEdge* addStoreCGEdge(NodeID src, NodeID dst);
     //@}
 
-    ///Get PAG edge
+    ///Get SVFIR edge
     //@{
     /// Get Address edges
     inline ConstraintEdge::ConstraintEdgeSetTy& getAddrCGEdges()
@@ -296,9 +296,9 @@ public:
         return false;
     }
 
-    /// Wrappers for invoking PAG methods
+    /// Wrappers for invoking SVFIR methods
     //@{
-    inline const PAG::CallSiteToFunPtrMap& getIndirectCallsites() const
+    inline const SVFIR::CallSiteToFunPtrMap& getIndirectCallsites() const
     {
         return pag->getIndirectCallsites();
     }

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

@@ -30,7 +30,7 @@
 #ifndef CONSGEDGE_H_
 #define CONSGEDGE_H_
 
-#include "Graphs/PAG.h"
+#include "MemoryModel/SVFIR.h"
 #include "Util/WorkList.h"
 
 #include <map>
@@ -42,7 +42,7 @@ namespace SVF
 class ConstraintNode;
 /*!
  * Self-defined edge for constraint resolution
- * including add/remove/re-target, but all the operations do not affect original PAG Edges
+ * including add/remove/re-target, but all the operations do not affect original SVFIR Edges
  */
 typedef GenericEdge<ConstraintNode> GenericConsEdgeTy;
 class ConstraintEdge : public GenericConsEdgeTy

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

@@ -101,7 +101,7 @@ public:
     }
     //@}
 
-    /// Direct and Indirect PAG edges
+    /// Direct and Indirect SVFIR edges
     inline bool isdirectEdge(ConstraintEdge::ConstraintEdgeK kind)
     {
         return (kind == ConstraintEdge::Copy || kind == ConstraintEdge::NormalGep || kind == ConstraintEdge::VariantGep );

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

@@ -10,15 +10,15 @@
 #ifndef EXTERNALPAG_H_
 #define EXTERNALPAG_H_
 
-#include "Graphs/PAGNode.h"
+#include "MemoryModel/SVFVariables.h"
 
 extern llvm::cl::list<std::string> DumpPAGFunctions;
 
 namespace SVF
 {
 
-/// Represents the PAG of a function loaded externally (i.e. from file).
-/// It's purpose is to be attached to the main PAG (almost) seamlessly.
+/// Represents the SVFIR of a function loaded externally (i.e. from file).
+/// It's purpose is to be attached to the main SVFIR (almost) seamlessly.
 class ExternalPAG
 {
 private:
@@ -28,17 +28,17 @@ private:
             functionToExternalPAGEntries;
     static Map<const SVFFunction*, PAGNode *> functionToExternalPAGReturns;
 
-    /// Name of the function this external PAG represents.
+    /// Name of the function this external SVFIR represents.
     std::string functionName;
 
-    /// Value nodes in this external PAG, represented by NodeIDs
-    /// because we will rebuild these nodes in the main PAG.
+    /// Value nodes in this external SVFIR, represented by NodeIDs
+    /// because we will rebuild these nodes in the main SVFIR.
     NodeSet valueNodes;
-    /// Object nodes in this external PAG, represented by NodeIDs
-    /// because we will rebuild these nodes in the main PAG.
+    /// Object nodes in this external SVFIR, represented by NodeIDs
+    /// because we will rebuild these nodes in the main SVFIR.
     NodeSet objectNodes;
-    /// Edges in this external PAG, represented by the parts of an Edge because
-    /// we will rebuild these edges in the main PAG.
+    /// Edges in this external SVFIR, represented by the parts of an Edge because
+    /// we will rebuild these edges in the main SVFIR.
     OrderedSet<std::tuple<NodeID, NodeID, std::string, int>> edges;
 
     // Special nodes.
@@ -82,15 +82,15 @@ public:
     ~ExternalPAG() {}
 
     /// Parses command line arguments and attaches external PAGs to main
-    /// PAG.
+    /// SVFIR.
     static void initialise(SVFModule* svfModule);
 
-    /// Connects callsite if a external PAG implementing the relevant function
+    /// Connects callsite if a external SVFIR implementing the relevant function
     /// has been added.
     /// Returns true on success, false otherwise.
     static bool connectCallsiteToExternalPAG(CallSite *cs);
 
-    /// Whether an external PAG implementing function exists.
+    /// Whether an external SVFIR implementing function exists.
     static bool hasExternalPAG(const SVFFunction* function);
 
     /// Dump individual PAGs of specified functions. Currently to outs().
@@ -136,7 +136,7 @@ public:
     }
 
     /// Adds (creates new equivalents) all the nodes and edges of this extpag to
-    /// the main PAG. function is used as a key for future lookups.
+    /// the main SVFIR. function is used as a key for future lookups.
     /// Returns true on success, false otherwise (incl. if it already exists).
     bool addExternalPAG(const SVFFunction* function);
 

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

@@ -41,8 +41,8 @@ class ICFGNode;
 class RetBlockNode;
 class CallPE;
 class RetPE;
-class PAGEdge;
-class PAGNode;
+class SVFStmt;
+class SVFVar;
 class VFGNode;
 
 /*!
@@ -67,7 +67,7 @@ public:
     typedef Set<const CallPE *> CallPESet;
     typedef Set<const RetPE *> RetPESet;
     typedef std::list<const VFGNode*> VFGNodeList;
-    typedef std::list<const PAGEdge*> PAGEdgeList;
+    typedef std::list<const SVFStmt*> PAGEdgeList;
 
 public:
     /// Constructor
@@ -113,7 +113,7 @@ public:
 
     /// Set/Get methods of VFGNodes
     ///@{
-    inline void addPAGEdge(const PAGEdge *edge)
+    inline void addPAGEdge(const SVFStmt *edge)
     {
         pagEdges.push_back(edge);
     }
@@ -252,7 +252,7 @@ class FunEntryBlockNode : public InterBlockNode
 {
 
 public:
-    typedef std::vector<const PAGNode *> FormalParmNodeVec;
+    typedef std::vector<const SVFVar *> FormalParmNodeVec;
 private:
     FormalParmNodeVec FPNodes;
 public:
@@ -271,7 +271,7 @@ public:
     }
 
     /// Add formal parameters
-    inline void addFormalParms(const PAGNode *fp)
+    inline void addFormalParms(const SVFVar *fp)
     {
         FPNodes.push_back(fp);
     }
@@ -310,7 +310,7 @@ class FunExitBlockNode : public InterBlockNode
 
 private:
     const SVFFunction* fun;
-    const PAGNode *formalRet;
+    const SVFVar *formalRet;
 public:
     FunExitBlockNode(NodeID id, const SVFFunction* f);
 
@@ -321,13 +321,13 @@ public:
     }
 
     /// Return actual return parameter
-    inline const PAGNode *getFormalRet() const
+    inline const SVFVar *getFormalRet() const
     {
         return formalRet;
     }
 
     /// Add actual return parameter
-    inline void addFormalRet(const PAGNode *fr)
+    inline void addFormalRet(const SVFVar *fr)
     {
         formalRet = fr;
     }
@@ -365,7 +365,7 @@ class CallBlockNode : public InterBlockNode
 {
 
 public:
-    typedef std::vector<const PAGNode *> ActualParmVFGNodeVec;
+    typedef std::vector<const SVFVar *> ActualParmVFGNodeVec;
 private:
     const Instruction* cs;
     const RetBlockNode* ret;
@@ -421,7 +421,7 @@ public:
     }
 
     /// Add actual parameters
-    inline void addActualParms(const PAGNode *ap)
+    inline void addActualParms(const SVFVar *ap)
     {
         APNodes.push_back(ap);
     }
@@ -461,7 +461,7 @@ class RetBlockNode : public InterBlockNode
 
 private:
     const Instruction* cs;
-    const PAGNode *actualRet;
+    const SVFVar *actualRet;
     const CallBlockNode* callBlockNode;
 public:
     RetBlockNode(NodeID id, const Instruction* c, CallBlockNode* cb) :
@@ -482,13 +482,13 @@ public:
         return callBlockNode;
     }
     /// Return actual return parameter
-    inline const PAGNode *getActualRet() const
+    inline const SVFVar *getActualRet() const
     {
         return actualRet;
     }
 
     /// Add actual return parameter
-    inline void addActualRet(const PAGNode *ar)
+    inline void addActualRet(const SVFVar *ar)
     {
         actualRet = ar;
     }

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

@@ -0,0 +1,245 @@
+//===- SVFIR.h -- SVF IR Graph or PAG (Program Assignment Graph)--------------------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2017>  <Yulei Sui>
+//
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * IRGraph.h 
+ *
+ *  Created on: Nov 1, 2013
+ *      Author: Yulei Sui
+ */
+
+
+#ifndef IRGRAPH_H_
+#define IRGRAPH_H_
+
+#include "MemoryModel/SVFStatements.h"
+#include "MemoryModel/SVFVariables.h"
+#include "Util/NodeIDAllocator.h"
+#include "Util/SVFUtil.h"
+#include "Graphs/ICFG.h"
+
+namespace SVF
+{
+typedef SVFVar PAGNode;
+typedef SVFStmt PAGEdge;
+
+/*
+* Graph representation of SVF IR. It can be seen as a program assignment graph (PAG)
+*/
+class IRGraph : public GenericGraph<SVFVar,SVFStmt>
+{
+public:
+    typedef Set<const SVFStmt*> PAGEdgeSet;
+    typedef Map<const Value*,PAGEdgeSet> ValueToEdgeMap;
+
+private:
+    bool fromFile; ///< Whether the SVFIR is built according to user specified data from a txt file
+    NodeID nodeNumAfterPAGBuild; // initial node number after building SVFIR, excluding later added nodes, e.g., gepobj nodes
+    u32_t totalPTAPAGEdge;
+    SVFStmt::PAGKindToEdgeSetMapTy PAGEdgeKindToSetMap;  // < SVFIR edge map containing all PAGEdges
+    SVFStmt::PAGKindToEdgeSetMapTy PTAPAGEdgeKindToSetMap;  // < SVFIR edge map containing only pointer-related edges, i.e, both RHS and RHS are of pointer type
+    ValueToEdgeMap valueToEdgeMap;	///< Map llvm::Values to all corresponding PAGEdges
+    SymbolTableInfo* symInfo;
+
+protected:
+    /// Add a node into the graph
+    inline NodeID addNode(SVFVar* node, NodeID i)
+    {
+        addGNode(i,node);
+        return i;
+    }
+    /// Add an edge into the graph
+    bool addEdge(SVFVar* src, SVFVar* dst, SVFStmt* edge);
+
+    //// Return true if this edge exits
+    SVFStmt* hasNonlabeledEdge(SVFVar* src, SVFVar* dst, SVFStmt::PEDGEK kind);
+    /// Return true if this labeled edge exits, including store, call and load
+    /// two store edge can have same dst and src but located in different basic blocks, thus flags are needed to distinguish them
+    SVFStmt* hasLabeledEdge(SVFVar* src, SVFVar* dst, SVFStmt::PEDGEK kind, const ICFGNode* cs);
+    /// Map a value to a set of edges
+    inline void mapValueToEdge(const Value *V, SVFStmt *edge)
+    {
+        auto inserted = valueToEdgeMap.emplace(V, PAGEdgeSet{edge});
+        if (!inserted.second) {
+            inserted.first->second.emplace(edge);
+        }
+    }
+    /// get MemObj according to LLVM value
+    inline const MemObj* getMemObj(const Value* val) const{
+        return symInfo->getObj(symInfo->getObjSym(val));
+    }
+    
+public:
+    IRGraph(bool buildFromFile): fromFile(buildFromFile), nodeNumAfterPAGBuild(0), totalPTAPAGEdge(0){
+        symInfo = SymbolTableInfo::SymbolInfo();
+        // insert dummy value if a correct value cannot be found
+        valueToEdgeMap[nullptr] = PAGEdgeSet();
+    }
+
+    virtual ~IRGraph();
+
+    /// Whether this SVFIR built from a txt file
+    inline bool isBuiltFromFile()
+    {
+        return fromFile;
+    }
+    /// Get edges set according to its kind
+    inline SVFStmt::PAGEdgeSetTy& getEdgeSet(SVFStmt::PEDGEK kind)
+    {
+        return PAGEdgeKindToSetMap[kind];
+    }
+    /// Get PTA edges set according to its kind
+    inline SVFStmt::PAGEdgeSetTy& getPTAEdgeSet(SVFStmt::PEDGEK kind)
+    {
+        return PTAPAGEdgeKindToSetMap[kind];
+    }
+
+    /// Get all SVFIR Edges that corresponds to an LLVM value
+    inline const PAGEdgeSet& getValueEdges(const Value *V)
+    {
+        auto it = valueToEdgeMap.find(V);
+        if (it == valueToEdgeMap.end()) {
+            //special empty set
+            return valueToEdgeMap.at(nullptr);
+        }
+        return it->second;
+    }
+
+    /// Get SVFIR Node according to LLVM value
+    ///getNode - Return the node corresponding to the specified pointer.
+    inline NodeID getValueNode(const Value *V)
+    {
+        return symInfo->getValSym(V);
+    }
+    inline bool hasValueNode(const Value* V)
+    {
+        return symInfo->hasValSym(V);
+    }
+    /// getObject - Return the obj node id refer to the memory object for the
+    /// specified global, heap or alloca instruction according to llvm value.
+    inline NodeID getObjectNode(const Value *V)
+    {
+        return symInfo->getObjSym(V);
+    }
+    /// GetReturnNode - Return the unique node representing the return value of a function
+    inline NodeID getReturnNode(const SVFFunction* func) const
+    {
+        return symInfo->getRetSym(func->getLLVMFun());
+    }
+    /// getVarargNode - Return the unique node representing the variadic argument of a variadic function.
+    inline NodeID getVarargNode(const SVFFunction* func) const
+    {
+        return symInfo->getVarargSym(func->getLLVMFun());
+    }
+    inline NodeID getBlackHoleNode() const
+    {
+        return symInfo->blackholeSymID();
+    }
+    inline NodeID getConstantNode() const
+    {
+        return symInfo->constantSymID();
+    }
+    inline NodeID getBlkPtr() const
+    {
+        return symInfo->blkPtrSymID();
+    }
+    inline NodeID getNullPtr() const
+    {
+        return symInfo->nullPtrSymID();
+    }
+    inline const MemObj* getBlackHoleObj() const
+    {
+        return symInfo->getBlkObj();
+    }
+    inline const MemObj* getConstantObj() const
+    {
+        return symInfo->getConstantObj();
+    }
+
+    inline Size_t getValueNodeNum() const
+    {
+        return symInfo->valSyms().size();
+    }
+    inline Size_t getObjectNodeNum() const
+    {
+        return symInfo->idToObjMap().size();
+    }
+    inline u32_t getNodeNumAfterPAGBuild() const
+    {
+        return nodeNumAfterPAGBuild;
+    }
+    inline void setNodeNumAfterPAGBuild(u32_t num)
+    {
+        nodeNumAfterPAGBuild = num;
+    }
+
+    inline Size_t getPAGNodeNum() const
+    {
+        return nodeNum;
+    }
+    inline Size_t getPAGEdgeNum() const
+    {
+        return edgeNum;
+    }
+    inline Size_t getPTAPAGEdgeNum() const
+    {
+        return totalPTAPAGEdge;
+    }
+    /// Return graph name
+    inline std::string getGraphName() const
+    {
+        return "SVFIR";
+    }
+
+    /// Dump SVFIR
+    void dump(std::string name);
+
+    /// View graph from the debugger
+    void view();
+};
+
+}
+
+
+namespace llvm
+{
+
+/* !
+ * GraphTraits specializations of SVFIR to be used for the generic graph algorithms.
+ * Provide graph traits for tranversing from a SVFIR node using standard graph traversals.
+ */
+template<> struct GraphTraits<SVF::SVFVar*> : public GraphTraits<SVF::GenericNode<SVF::SVFVar,SVF::SVFStmt>*  >
+{
+};
+
+/// Inverse GraphTraits specializations for SVFIR node, it is used for inverse traversal.
+template<> struct GraphTraits<Inverse<SVF::SVFVar *> > : public GraphTraits<Inverse<SVF::GenericNode<SVF::SVFVar,SVF::SVFStmt>* > >
+{
+};
+
+template<> struct GraphTraits<SVF::IRGraph*> : public GraphTraits<SVF::GenericGraph<SVF::SVFVar,SVF::SVFStmt>* >
+{
+    typedef SVF::SVFVar *NodeRef;
+};
+
+} // End namespace llvm
+#endif /* IRGRAPH_H_ */

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

@@ -55,7 +55,7 @@ protected:
     NodeToRepMap norToRepMap;   // for each *a construct a --> rep, i.e., mapping a node of to a rep node for online constraint solving
 
 public:
-    OfflineConsG(PAG *p) : ConstraintGraph(p),
+    OfflineConsG(SVFIR *p) : ConstraintGraph(p),
         nodeToRefMap( {}), norToRepMap({})
     {
         buildOfflineCG();

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

@@ -561,7 +561,7 @@ public:
     /// getObject - return mem object id
     inline NodeID getObjectNode(const MemObj *mem)
     {
-        return mem->getSymId();
+        return mem->getId();
     }
     /// Get all PAG Edges that corresponds to an LLVM value
     inline const PAGEdgeSet& getValueEdges(const Value *V)
@@ -618,7 +618,7 @@ public:
     //@{
     inline NodeID getFIObjNode(const MemObj* obj) const
     {
-        return obj->getSymId();
+        return obj->getId();
     }
     inline NodeID getFIObjNode(NodeID id) const
     {
@@ -716,7 +716,7 @@ public:
     LocationSet getLocationSetFromBaseNode(NodeID nodeId);
     inline NodeID getBaseObjNode(NodeID id) const
     {
-        return getBaseObj(id)->getSymId();
+        return getBaseObj(id)->getId();
     }
     inline const MemObj* getBaseObj(NodeID id) const
     {
@@ -752,7 +752,7 @@ public:
     inline NodeID addObjNode(const Value* val, NodeID i)
     {
         MemObj* mem = symInfo->getObj(symInfo->getObjSym(val));
-        assert(((mem->getSymId() == i)) && "not same object id?");
+        assert(((mem->getId() == i)) && "not same object id?");
         return addFIObjNode(mem);
     }
     /// Add a unique return node for a procedure