svf-lib 1.0.730 → 1.0.734

package/SVF-osx/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-osx/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-osx/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

package/SVF-osx/include/Graphs/PAGNode.h

@@ -31,7 +31,7 @@
 #define PAGNODE_H_
 
 #include "Graphs/GenericGraph.h"
-#include "MemoryModel/MemModel.h"
+#include "MemoryModel/SVFSymbols.h"
 #include "MemoryModel/SymbolTableInfo.h"
 #include "SVF-FE/LLVMUtil.h"
 #include "Graphs/PAGEdge.h"
@@ -483,9 +483,9 @@ public:
 
     /// Constructor
     GepObjPN(const MemObj* mem, NodeID i, const LocationSet& l, PNODEK ty = GepObjNode) :
-        ObjPN(mem->getRefVal(), i, mem, ty), ls(l)
+        ObjPN(mem->getValue(), i, mem, ty), ls(l)
     {
-        base = mem->getSymId();
+        base = mem->getId();
     }
 
     /// offset of the mem object

package/SVF-osx/include/Graphs/SVFG.h

@@ -369,7 +369,7 @@ 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 MRVer* mvar) const

package/SVF-osx/include/Graphs/SVFGOPT.h

@@ -259,7 +259,7 @@ private:
     inline void resetDef(const PAGNode* pagNode, const SVFGNode* node)
     {
         PAGNodeToDefMapTy::iterator it = PAGNodeToDefMap.find(pagNode);
-        assert(it != PAGNodeToDefMap.end() && "a PAG node doesn't have definition before");
+        assert(it != PAGNodeToDefMap.end() && "a SVFIR node doesn't have definition before");
         PAGNodeToDefMap[pagNode] = node->getId();
     }
 
@@ -290,11 +290,11 @@ private:
     //@{
     inline bool actualInOfIndCS(const ActualINSVFGNode* ai) const
     {
-        return (PAG::getPAG()->isIndirectCallSites(ai->getCallSite()));
+        return (SVFIR::getPAG()->isIndirectCallSites(ai->getCallSite()));
     }
     inline bool actualOutOfIndCS(const ActualOUTSVFGNode* ao) const
     {
-        return (PAG::getPAG()->isIndirectCallSites(ao->getCallSite()));
+        return (SVFIR::getPAG()->isIndirectCallSites(ao->getCallSite()));
     }
     //@}
 

package/SVF-osx/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,12 +561,12 @@ protected:
         PAGNodeToActualRetMap[ret] = sNode;
     }
     /// Add an llvm PHI VFG node
-    inline void addIntraPHIVFGNode(const PAGNode* phiResNode, PAG::CopyPEList& oplist)
+    inline void addIntraPHIVFGNode(const PAGNode* phiResNode, SVFIR::CopyPEList& oplist)
     {
         IntraPHIVFGNode* sNode = new IntraPHIVFGNode(totalVFGNode++,phiResNode);
         u32_t pos = 0;
         const PAGEdge* edge = nullptr;
-        for(PAG::CopyPEList::const_iterator it = oplist.begin(), eit=oplist.end(); it!=eit; ++it,++pos)
+        for(SVFIR::CopyPEList::const_iterator it = oplist.begin(), eit=oplist.end(); it!=eit; ++it,++pos)
         {
             edge = *it;
             sNode->setOpVerAndBB(pos, edge->getSrcNode(), edge->getICFGNode());
@@ -577,12 +577,12 @@ protected:
         PAGNodeToIntraPHIVFGNodeMap[phiResNode] = sNode;
     }
     /// Add a Compare VFG node
-    inline void addCmpVFGNode(const PAGNode* resNode, PAG::CmpPEList& oplist)
+    inline void addCmpVFGNode(const PAGNode* resNode, SVFIR::CmpPEList& oplist)
     {
         CmpVFGNode* sNode = new CmpVFGNode(totalVFGNode++, resNode);
         u32_t pos = 0;
         const PAGEdge* edge = nullptr;
-        for(PAG::CmpPEList::const_iterator it = oplist.begin(), eit=oplist.end(); it!=eit; ++it,++pos)
+        for(SVFIR::CmpPEList::const_iterator it = oplist.begin(), eit=oplist.end(); it!=eit; ++it,++pos)
         {
             edge = *it;
             sNode->setOpVer(pos, edge->getSrcNode());
@@ -593,12 +593,12 @@ protected:
         PAGNodeToCmpVFGNodeMap[resNode] = sNode;
     }
     /// Add a BinaryOperator VFG node
-    inline void addBinaryOPVFGNode(const PAGNode* resNode, PAG::BinaryOPList& oplist)
+    inline void addBinaryOPVFGNode(const PAGNode* resNode, SVFIR::BinaryOPList& oplist)
     {
         BinaryOPVFGNode* sNode = new BinaryOPVFGNode(totalVFGNode++, resNode);
         u32_t pos = 0;
         const PAGEdge* edge = nullptr;
-        for(PAG::BinaryOPList::const_iterator it = oplist.begin(), eit=oplist.end(); it!=eit; ++it,++pos)
+        for(SVFIR::BinaryOPList::const_iterator it = oplist.begin(), eit=oplist.end(); it!=eit; ++it,++pos)
         {
             edge = *it;
             sNode->setOpVer(pos, (*it)->getSrcNode());
@@ -610,12 +610,12 @@ protected:
         PAGNodeToBinaryOPVFGNodeMap[resNode] = sNode;
     }
     /// Add a UnaryOperator VFG node
-    inline void addUnaryOPVFGNode(const PAGNode* resNode, PAG::UnaryOPList& oplist)
+    inline void addUnaryOPVFGNode(const PAGNode* resNode, SVFIR::UnaryOPList& oplist)
     {
         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)
+        for(SVFIR::UnaryOPList::const_iterator it = oplist.begin(), eit=oplist.end(); it!=eit; ++it,++pos)
         {
             edge = *it;
             sNode->setOpVer(pos, (*it)->getSrcNode());

package/SVF-osx/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
 {
@@ -1092,7 +1091,7 @@ public:
         return node->isPointer();
     }
     /// Return corresponding PAGNode
-    const PAGNode* getPAGNode() const
+    const PAGNode* getGNode() const
     {
         return node;
     }

package/SVF-osx/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-osx/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-osx/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-osx/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,