svf-lib 1.0.732 → 1.0.736

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

@@ -0,0 +1,236 @@
+//===- 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;
+
+protected:
+    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
+    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;
+    ValueToEdgeMap valueToEdgeMap;	///< Map llvm::Values to all corresponding PAGEdges
+    SymbolTableInfo* symInfo;
+
+    /// 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);
+    /// Return MultiOpndStmt since it has more than one operands (we use operand 2 here to make the flag)
+    SVFStmt* hasLabeledEdge(SVFVar* src, SVFVar* op1, SVFStmt::PEDGEK kind, const SVFVar* op2);
+
+    /// 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 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/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,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-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
 {
@@ -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-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,