svf-lib 1.0.745 → 1.0.749

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

@@ -151,7 +151,7 @@ public:
         NodeID srcID = addr->getPAGSrcNodeID();
         /// whether this object is set field-insensitive during pre-analysis
         if (isFieldInsensitive(srcID))
-            srcID = getFIObjNode(srcID);
+            srcID = getFIObjVar(srcID);
 
         CxtVar var(dpm.getCond(),srcID);
         addDDAPts(pts,var);

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

@@ -93,7 +93,7 @@ public:
         NodeID srcID = addr->getPAGSrcNodeID();
         /// whether this object is set field-insensitive during pre-analysis
         if (isFieldInsensitive(srcID))
-            srcID = getFIObjNode(srcID);
+            srcID = getFIObjVar(srcID);
 
         addDDAPts(pts,srcID);
         DBOUT(DDDA, SVFUtil::outs() << "\t add points-to target " << srcID << " to dpm ");

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

@@ -67,9 +67,9 @@ protected:
 
     void destroy();
 
-    PAGEdge::PAGEdgeSetTy& getPAGEdgeSet(PAGEdge::PEDGEK kind)
+    PAGEdge::SVFStmtSetTy& getPAGEdgeSet(PAGEdge::PEDGEK kind)
     {
-        return pag->getPTAEdgeSet(kind);
+        return pag->getPTASVFStmtSet(kind);
     }
 
     /// Wappers used internally, not expose to Andernsen Pass
@@ -310,13 +310,13 @@ public:
     {
         return pag->isBlkObjOrConstantObj(id);
     }
-    inline NodeBS& getAllFieldsObjNode(NodeID id)
+    inline NodeBS& getAllFieldsObjVars(NodeID id)
     {
-        return pag->getAllFieldsObjNode(id);
+        return pag->getAllFieldsObjVars(id);
     }
-    inline NodeID getBaseObjNode(NodeID id)
+    inline NodeID getBaseObjVar(NodeID id)
     {
-        return pag->getBaseObjNode(id);
+        return pag->getBaseObjVar(id);
     }
     inline bool isSingleFieldObj(NodeID id) const
     {
@@ -324,18 +324,18 @@ public:
         return (mem->getMaxFieldOffsetLimit() == 1);
     }
     /// Get a field of a memory object
-    inline NodeID getGepObjNode(NodeID id, const LocationSet& ls)
+    inline NodeID getGepObjVar(NodeID id, const LocationSet& ls)
     {
-        NodeID gep =  pag->getGepObjNode(id,ls);
+        NodeID gep =  pag->getGepObjVar(id,ls);
         /// Create a node when it is (1) not exist on graph and (2) not merged
         if(sccRepNode(gep)==gep && hasConstraintNode(gep)==false)
             addConstraintNode(new ConstraintNode(gep),gep);
         return gep;
     }
     /// Get a field-insensitive node of a memory object
-    inline NodeID getFIObjNode(NodeID id)
+    inline NodeID getFIObjVar(NodeID id)
     {
-        NodeID fi = pag->getFIObjNode(id);
+        NodeID fi = pag->getFIObjVar(id);
         /// Create a node when it is (1) not exist on graph and (2) not merged
         if (sccRepNode(fi) == fi && hasConstraintNode(fi)==false)
             addConstraintNode(new ConstraintNode(fi),fi);

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

@@ -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 SVFStmt*> PAGEdgeList;
+    typedef std::list<const SVFStmt*> SVFStmtList;
 
 public:
     /// Constructor
@@ -118,7 +118,7 @@ public:
         pagEdges.push_back(edge);
     }
 
-    inline const PAGEdgeList& getPAGEdges() const
+    inline const SVFStmtList& getPAGEdges() const
     {
         return pagEdges;
     }
@@ -132,7 +132,7 @@ protected:
     const SVFFunction* fun;
     const BasicBlock* bb;
     VFGNodeList VFGNodes; //< a list of VFGNodes
-    PAGEdgeList pagEdges; //< a list of PAGEdges
+    SVFStmtList pagEdges; //< a list of PAGEdges
 
 };
 

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

@@ -48,12 +48,12 @@ typedef SVFStmt PAGEdge;
 class IRGraph : public GenericGraph<SVFVar,SVFStmt>
 {
 public:
-    typedef Set<const SVFStmt*> PAGEdgeSet;
-    typedef Map<const Value*,PAGEdgeSet> ValueToEdgeMap;
+    typedef Set<const SVFStmt*> SVFStmtSet;
+    typedef Map<const Value*,SVFStmtSet> 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
+    SVFStmt::KindToSVFStmtMapTy KindToSVFStmtSetMap;  // < SVFIR edge map containing all PAGEdges
+    SVFStmt::KindToSVFStmtMapTy KindToPTASVFStmtSetMap;  // < 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;
@@ -80,7 +80,7 @@ protected:
     /// Map a value to a set of edges
     inline void mapValueToEdge(const Value *V, SVFStmt *edge)
     {
-        auto inserted = valueToEdgeMap.emplace(V, PAGEdgeSet{edge});
+        auto inserted = valueToEdgeMap.emplace(V, SVFStmtSet{edge});
         if (!inserted.second) {
             inserted.first->second.emplace(edge);
         }
@@ -94,7 +94,7 @@ 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();
+        valueToEdgeMap[nullptr] = SVFStmtSet();
     }
 
     virtual ~IRGraph();
@@ -105,7 +105,7 @@ public:
         return fromFile;
     }
     /// Get all SVFIR Edges that corresponds to an LLVM value
-    inline const PAGEdgeSet& getValueEdges(const Value *V)
+    inline const SVFStmtSet& getValueEdges(const Value *V)
     {
         auto it = valueToEdgeMap.find(V);
         if (it == valueToEdgeMap.end()) {

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

@@ -79,7 +79,7 @@ public:
     typedef VFGEdge::VFGEdgeSetTy::iterator VFGNodeIter;
     typedef VFGNodeIDToNodeMapTy::iterator iterator;
     typedef VFGNodeIDToNodeMapTy::const_iterator const_iterator;
-    typedef SVFIR::PAGEdgeSet PAGEdgeSet;
+    typedef SVFIR::SVFStmtSet SVFStmtSet;
     typedef Set<const VFGNode*> GlobalVFGNodeSet;
     typedef Set<const PAGNode*> PAGNodeSet;
 
@@ -427,12 +427,12 @@ protected:
     void addVFGNodes();
 
     /// Get PAGEdge set
-    virtual inline PAGEdge::PAGEdgeSetTy& getPAGEdgeSet(PAGEdge::PEDGEK kind)
+    virtual inline PAGEdge::SVFStmtSetTy& getPAGEdgeSet(PAGEdge::PEDGEK kind)
     {
         if (isPtrOnlySVFG())
-            return pag->getPTAEdgeSet(kind);
+            return pag->getPTASVFStmtSet(kind);
         else
-            return pag->getEdgeSet(kind);
+            return pag->getSVFStmtSet(kind);
     }
 
     virtual inline bool isInterestedPAGNode(const PAGNode* node) const

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

@@ -169,7 +169,7 @@ public:
     typedef Map<NodeID, NodeBS> NodeToPTSSMap;
 
     /// SVFIR edge list
-    typedef SVFIR::PAGEdgeList PAGEdgeList;
+    typedef SVFIR::SVFStmtList SVFStmtList;
     /// Call Graph SCC
     typedef SCCDetection<PTACallGraph*> SCC;
 
@@ -466,9 +466,9 @@ public:
     }
     //@}
     /// Whether this instruction has SVFIR Edge
-    bool hasPAGEdgeList(const Instruction* inst);
+    bool hasSVFStmtList(const Instruction* inst);
     /// Given an instruction, get all its the PAGEdge (statement) in sequence
-    PAGEdgeList& getPAGEdgesFromInst(const Instruction* inst);
+    SVFStmtList& getPAGEdgesFromInst(const Instruction* inst);
 
     /// getModRefInfo APIs
     //@{

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

@@ -94,7 +94,7 @@ public:
     typedef Map<const MemRegion*, MRVERSION> MemRegToCounterMap;
 
     /// SVFIR edge list
-    typedef SVFIR::PAGEdgeList PAGEdgeList;
+    typedef SVFIR::SVFStmtList SVFStmtList;
 
     /// Statistics
     //@{

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

@@ -346,21 +346,21 @@ public:
     {
         return (SVFUtil::isa<FIObjVar>(pag->getGNode(id)));
     }
-    inline NodeID getBaseObjNode(NodeID id)
+    inline NodeID getBaseObjVar(NodeID id)
     {
-        return pag->getBaseObjNode(id);
+        return pag->getBaseObjVar(id);
     }
-    inline NodeID getFIObjNode(NodeID id)
+    inline NodeID getFIObjVar(NodeID id)
     {
-        return pag->getFIObjNode(id);
+        return pag->getFIObjVar(id);
     }
-    inline NodeID getGepObjNode(NodeID id, const LocationSet& ls)
+    inline NodeID getGepObjVar(NodeID id, const LocationSet& ls)
     {
-        return pag->getGepObjNode(id,ls);
+        return pag->getGepObjVar(id,ls);
     }
-    virtual inline const NodeBS& getAllFieldsObjNode(NodeID id)
+    virtual inline const NodeBS& getAllFieldsObjVars(NodeID id)
     {
-        return pag->getAllFieldsObjNode(id);
+        return pag->getAllFieldsObjVars(id);
     }
     inline void setObjFieldInsensitive(NodeID id)
     {

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

@@ -352,9 +352,9 @@ public:
         expandedCpts = cpts;;
         for(typename CPtSet::const_iterator cit = cpts.begin(), ecit=cpts.end(); cit!=ecit; ++cit)
         {
-            if(pag->getBaseObjNode(cit->get_id())==cit->get_id())
+            if(pag->getBaseObjVar(cit->get_id())==cit->get_id())
             {
-                NodeBS& fields = pag->getAllFieldsObjNode(cit->get_id());
+                NodeBS& fields = pag->getAllFieldsObjVars(cit->get_id());
                 for(NodeBS::iterator it = fields.begin(), eit = fields.end(); it!=eit; ++it)
                 {
                     CVar cvar(cit->get_cond(),*it);

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

@@ -53,33 +53,32 @@ public:
     typedef OrderedMap<const CallBlockNode*,NodeID> CallSiteToFunPtrMap;
     typedef Map<NodeID,CallSiteSet> FunPtrToCallSitesMap;
     typedef Map<NodeID,NodeBS> MemObjToFieldsMap;
-    typedef std::vector<const SVFStmt*> PAGEdgeList;
-    typedef std::vector<const SVFVar*> PAGNodeList;
-    typedef std::vector<const CopyStmt*> CopyPEList;
+    typedef std::vector<const SVFStmt*> SVFStmtList;
+    typedef std::vector<const SVFVar*> SVFVarList;
     typedef Map<const SVFVar*,PhiStmt*> PHINodeMap;
-    typedef Map<const SVFFunction*,PAGNodeList> FunToArgsListMap;
-    typedef Map<const CallBlockNode*,PAGNodeList> CSToArgsListMap;
+    typedef Map<const SVFFunction*,SVFVarList> FunToArgsListMap;
+    typedef Map<const CallBlockNode*,SVFVarList> CSToArgsListMap;
     typedef Map<const RetBlockNode*,const SVFVar*> CSToRetMap;
     typedef Map<const SVFFunction*,const SVFVar*> FunToRetMap;
-    typedef Map<const SVFFunction*,PAGEdgeSet> FunToPAGEdgeSetMap;
-    typedef Map<const ICFGNode*,PAGEdgeList> Inst2PAGEdgesMap;
+    typedef Map<const SVFFunction*,SVFStmtSet> FunToPAGEdgeSetMap;
+    typedef Map<const ICFGNode*,SVFStmtList> ICFGNode2SVFStmtsMap;
     typedef Map<NodeID, NodeID> NodeToNodeMap;
     typedef std::pair<NodeID, Size_t> NodeOffset;
     typedef std::pair<NodeID, LocationSet> NodeLocationSet;
     typedef Map<NodeOffset,NodeID> NodeOffsetMap;
     typedef Map<NodeLocationSet,NodeID> NodeLocationSetMap;
-    typedef Map<const Value*, NodeLocationSetMap> GepValPNMap;
+    typedef Map<const Value*, NodeLocationSetMap> GepValueVarMap;
     typedef Map<NodePair,NodeID> NodePairSetMap;
 
 private:
     /// ValueNodes - This map indicates the Node that a particular Value* is
     /// represented by.  This contains entries for all pointers.
-    Inst2PAGEdgesMap inst2PAGEdgesMap;	///< Map a instruction to its PAGEdges
-    Inst2PAGEdgesMap inst2PTAPAGEdgesMap;	///< Map a instruction to its PointerAnalysis related PAGEdges
-    GepValPNMap GepValNodeMap;	///< Map a pair<base,off> to a gep value node id
-    NodeLocationSetMap GepObjNodeMap;	///< Map a pair<base,off> to a gep obj node id
+    ICFGNode2SVFStmtsMap icfgNode2SVFStmtsMap;	///< Map an ICFGNode to its SVFStmts
+    ICFGNode2SVFStmtsMap icfgNode2PTASVFStmtsMap;	///< Map an ICFGNode to its PointerAnalysis related SVFStmts
+    GepValueVarMap GepValObjMap;	///< Map a pair<base,off> to a gep value node id
+    NodeLocationSetMap GepObjVarMap;	///< Map a pair<base,off> to a gep obj node id
     MemObjToFieldsMap memToFieldsMap;	///< Map a mem object id to all its fields
-    PAGEdgeSet globPAGEdgesSet;	///< Global PAGEdges without control flow information
+    SVFStmtSet globSVFStmtSet;	///< Global PAGEdges without control flow information
     PHINodeMap phiNodeMap;	///< A set of phi copy edges
     FunToArgsListMap funArgsListMap;	///< Map a function to a list of all its formal parameters
     CSToArgsListMap callSiteArgsListMap;	///< Map a callsite to a list of all its actual parameters
@@ -124,10 +123,10 @@ public:
     {
         return memToFieldsMap;
     }
-    /// Return GepObjNodeMap
+    /// Return GepObjVarMap
     inline NodeLocationSetMap& getGepObjNodeMap()
     {
-        return GepObjNodeMap;
+        return GepObjVarMap;
     }
     /// Return ICFG
     inline ICFG* getICFG()
@@ -160,46 +159,46 @@ public:
     /// Get/set methods to get SVFStmts based on their kinds and ICFGNodes
     //@{
     /// Get edges set according to its kind
-    inline SVFStmt::PAGEdgeSetTy& getEdgeSet(SVFStmt::PEDGEK kind)
+    inline SVFStmt::SVFStmtSetTy& getSVFStmtSet(SVFStmt::PEDGEK kind)
     {
-        return PAGEdgeKindToSetMap[kind];
+        return KindToSVFStmtSetMap[kind];
     }
     /// Get PTA edges set according to its kind
-    inline SVFStmt::PAGEdgeSetTy& getPTAEdgeSet(SVFStmt::PEDGEK kind)
+    inline SVFStmt::SVFStmtSetTy& getPTASVFStmtSet(SVFStmt::PEDGEK kind)
     {
-        return PTAPAGEdgeKindToSetMap[kind];
+        return KindToPTASVFStmtSetMap[kind];
     }
     /// Whether this instruction has SVFIR Edge
-    inline bool hasPAGEdgeList(const ICFGNode* inst) const
+    inline bool hasSVFStmtList(const ICFGNode* inst) const
     {
-        return inst2PAGEdgesMap.find(inst)!=inst2PAGEdgesMap.end();
+        return icfgNode2SVFStmtsMap.find(inst)!=icfgNode2SVFStmtsMap.end();
     }
-    inline bool hasPTAPAGEdgeList(const ICFGNode* inst) const
+    inline bool hasPTASVFStmtList(const ICFGNode* inst) const
     {
-        return inst2PTAPAGEdgesMap.find(inst)!=inst2PTAPAGEdgesMap.end();
+        return icfgNode2PTASVFStmtsMap.find(inst)!=icfgNode2PTASVFStmtsMap.end();
     }
     /// Given an instruction, get all its PAGEdges
-    inline PAGEdgeList& getInstPAGEdgeList(const ICFGNode* inst)
+    inline SVFStmtList& getSVFStmtList(const ICFGNode* inst)
     {
-        return inst2PAGEdgesMap[inst];
+        return icfgNode2SVFStmtsMap[inst];
     }
     /// Given an instruction, get all its PTA PAGEdges
-    inline PAGEdgeList& getInstPTAPAGEdgeList(const ICFGNode* inst)
+    inline SVFStmtList& getPTASVFStmtList(const ICFGNode* inst)
     {
-        return inst2PTAPAGEdgesMap[inst];
+        return icfgNode2PTASVFStmtsMap[inst];
     }
     /// Add a SVFStmt into instruction map
-    inline void addToInstPAGEdgeList(ICFGNode* inst, SVFStmt* edge)
+    inline void addToSVFStmtList(ICFGNode* inst, SVFStmt* edge)
     {
         edge->setICFGNode(inst);
-        inst2PAGEdgesMap[inst].push_back(edge);
+        icfgNode2SVFStmtsMap[inst].push_back(edge);
         if (edge->isPTAEdge())
-            inst2PTAPAGEdgesMap[inst].push_back(edge);
+            icfgNode2PTASVFStmtsMap[inst].push_back(edge);
     }
     /// Get global PAGEdges (not in a procedure)
-    inline PAGEdgeSet& getGlobalPAGEdgeSet()
+    inline SVFStmtSet& getGlobalSVFStmtSet()
     {
-        return globPAGEdgesSet;
+        return globSVFStmtSet;
     }
     /// Get all callsites
     inline const CallSiteSet& getCallSiteSet() const
@@ -223,7 +222,7 @@ public:
         return funArgsListMap;
     }
     /// Get function arguments list
-    inline const PAGNodeList& getFunArgsList(const SVFFunction*  func) const
+    inline const SVFVarList& getFunArgsList(const SVFFunction*  func) const
     {
         FunToArgsListMap::const_iterator it = funArgsListMap.find(func);
         assert(it != funArgsListMap.end() && "this function doesn't have arguments");
@@ -240,7 +239,7 @@ public:
         return callSiteArgsListMap;
     }
     /// Get callsite argument list
-    inline const PAGNodeList& getCallSiteArgsList(const CallBlockNode* cs) const
+    inline const SVFVarList& getCallSiteArgsList(const CallBlockNode* cs) const
     {
         CSToArgsListMap::const_iterator it = callSiteArgsListMap.find(cs);
         assert(it != callSiteArgsListMap.end() && "this call site doesn't have arguments");
@@ -284,19 +283,19 @@ public:
     //@{
     inline Size_t getFieldValNodeNum() const
     {
-        return GepValNodeMap.size();
+        return GepValObjMap.size();
     }
     inline Size_t getFieldObjNodeNum() const
     {
-        return GepObjNodeMap.size();
+        return GepObjVarMap.size();
     }
     //@}
 
     /// Due to constaint expression, curInst is used to distinguish different instructions (e.g., memorycpy) when creating GepValVar.
-    inline NodeID getGepValNode(const Value* curInst, NodeID base, const LocationSet& ls) const
+    inline NodeID getGepValVar(const Value* curInst, NodeID base, const LocationSet& ls) const
     {
-        GepValPNMap::const_iterator iter = GepValNodeMap.find(curInst);
-        if(iter==GepValNodeMap.end()){
+        GepValueVarMap::const_iterator iter = GepValObjMap.find(curInst);
+        if(iter==GepValObjMap.end()){
             return UINT_MAX;
         }
         else{
@@ -344,8 +343,8 @@ public:
     inline SVFStmt* getIntraPAGEdge(SVFVar* src, SVFVar* dst, SVFStmt::PEDGEK kind)
     {
         SVFStmt edge(src,dst,kind);
-        const SVFStmt::PAGEdgeSetTy& edgeSet = getEdgeSet(kind);
-        SVFStmt::PAGEdgeSetTy::const_iterator it = edgeSet.find(&edge);
+        const SVFStmt::SVFStmtSetTy& edgeSet = getSVFStmtSet(kind);
+        SVFStmt::SVFStmtSetTy::const_iterator it = edgeSet.find(&edge);
         assert(it != edgeSet.end() && "can not find pag edge");
         return (*it);
     }
@@ -370,21 +369,21 @@ public:
     //@}
 
     /// Get a field SVFIR Object node according to base mem obj and offset
-    NodeID getGepObjNode(const MemObj* obj, const LocationSet& ls);
+    NodeID getGepObjVar(const MemObj* obj, const LocationSet& ls);
     /// Get a field obj SVFIR node according to a mem obj and a given offset
-    NodeID getGepObjNode(NodeID id, const LocationSet& ls) ;
+    NodeID getGepObjVar(NodeID id, const LocationSet& ls) ;
     /// Get a field-insensitive obj SVFIR node according to a mem obj
     //@{
-    inline NodeID getFIObjNode(const MemObj* obj) const
+    inline NodeID getFIObjVar(const MemObj* obj) const
     {
         return obj->getId();
     }
-    inline NodeID getFIObjNode(NodeID id) const
+    inline NodeID getFIObjVar(NodeID id) const
     {
         SVFVar* node = pag->getGNode(id);
         assert(SVFUtil::isa<ObjVar>(node) && "need an object node");
         ObjVar* obj = SVFUtil::cast<ObjVar>(node);
-        return getFIObjNode(obj->getMemObj());
+        return getFIObjVar(obj->getMemObj());
     }
     //@}
 
@@ -438,9 +437,9 @@ public:
     /// Base and Offset methods for Value and Object node
     //@{
     /// Get a base pointer node given a field pointer
-    NodeID getBaseValNode(NodeID nodeId);
+    NodeID getBaseValVar(NodeID nodeId);
     LocationSet getLocationSetFromBaseNode(NodeID nodeId);
-    inline NodeID getBaseObjNode(NodeID id) const
+    inline NodeID getBaseObjVar(NodeID id) const
     {
         return getBaseObj(id)->getId();
     }
@@ -455,8 +454,8 @@ public:
 
     /// Get all fields of an object
     //@{
-    NodeBS& getAllFieldsObjNode(const MemObj* obj);
-    NodeBS& getAllFieldsObjNode(NodeID id);
+    NodeBS& getAllFieldsObjVars(const MemObj* obj);
+    NodeBS& getAllFieldsObjVars(NodeID id);
     NodeBS getFieldsAfterCollapse(NodeID id);
     //@}
     inline NodeID addDummyValNode()
@@ -481,12 +480,12 @@ private:
 
     /// Map a SVFStatement type to a set of corresponding SVF statements
     inline void addToStmt2TypeMap(SVFStmt* edge) {
-        bool added = PAGEdgeKindToSetMap[edge->getEdgeKind()].insert(edge).second;
+        bool added = KindToSVFStmtSetMap[edge->getEdgeKind()].insert(edge).second;
         assert(added && "duplicated edge, not added!!!");
         if (edge->isPTAEdge())
         {
             totalPTAPAGEdge++;
-            PTAPAGEdgeKindToSetMap[edge->getEdgeKind()].insert(edge);
+            KindToPTASVFStmtSetMap[edge->getEdgeKind()].insert(edge);
         }
     }
     /// Get/set method for function/callsite arguments and returns
@@ -553,9 +552,9 @@ private:
         return addNode(node,i);
     }
 
-    /// Add a temp field value node, this method can only invoked by getGepValNode
+    /// Add a temp field value node, this method can only invoked by getGepValVar
     NodeID addGepValNode(const Value* curInst,const Value* val, const LocationSet& ls, NodeID i, const Type *type, u32_t fieldidx);
-    /// Add a field obj node, this method can only invoked by getGepObjNode
+    /// Add a field obj node, this method can only invoked by getGepObjVar
     NodeID addGepObjNode(const MemObj* obj, const LocationSet& ls);
     /// Add a field-insensitive node, this method can only invoked by getFIGepObjNode
     NodeID addFIObjNode(const MemObj* obj);
@@ -616,7 +615,7 @@ private:
     /// Add global PAGEdges (not in a procedure)
     inline void addGlobalPAGEdge(const SVFStmt* edge)
     {
-        globPAGEdgesSet.insert(edge);
+        globSVFStmtSet.insert(edge);
     }
     /// Add callsites
     inline void addCallSite(const CallBlockNode* call)
@@ -626,33 +625,33 @@ private:
     /// Add an edge into SVFIR
     //@{
     /// Add Address edge
-    AddrStmt* addAddrPE(NodeID src, NodeID dst);
+    AddrStmt* addAddrStmt(NodeID src, NodeID dst);
     /// Add Copy edge
-    CopyStmt* addCopyPE(NodeID src, NodeID dst);
+    CopyStmt* addCopyStmt(NodeID src, NodeID dst);
     /// Add phi node information
-    PhiStmt*  addPhiNode(NodeID res, NodeID opnd);
+    PhiStmt*  addPhiStmt(NodeID res, NodeID opnd);
     /// Add Copy edge
-    CmpStmt* addCmpPE(NodeID op1, NodeID op2, NodeID dst, u32_t opcode);
+    CmpStmt* addCmpStmt(NodeID op1, NodeID op2, NodeID dst, u32_t predict);
     /// Add Copy edge
-    BinaryOPStmt* addBinaryOPPE(NodeID op1, NodeID op2, NodeID dst, u32_t opcode);
+    BinaryOPStmt* addBinaryOPStmt(NodeID op1, NodeID op2, NodeID dst, u32_t opcode);
     /// Add Unary edge
-    UnaryOPStmt* addUnaryOPPE(NodeID src, NodeID dst, u32_t opcode);
+    UnaryOPStmt* addUnaryOPStmt(NodeID src, NodeID dst, u32_t opcode);
     /// Add BranchStmt
     BranchStmt* addBranchStmt(NodeID br, NodeID cond, std::vector<const ICFGNode*> succs);
     /// Add Load edge
-    LoadStmt* addLoadPE(NodeID src, NodeID dst);
+    LoadStmt* addLoadStmt(NodeID src, NodeID dst);
     /// Add Store edge
-    StoreStmt* addStorePE(NodeID src, NodeID dst, const IntraBlockNode* val);
+    StoreStmt* addStoreStmt(NodeID src, NodeID dst, const IntraBlockNode* val);
     /// Add Call edge
     CallPE* addCallPE(NodeID src, NodeID dst, const CallBlockNode* cs);
     /// Add Return edge
     RetPE* addRetPE(NodeID src, NodeID dst, const CallBlockNode* cs);
     /// Add Gep edge
-    GepStmt* addGepPE(NodeID src, NodeID dst, const LocationSet& ls, bool constGep);
+    GepStmt* addGepStmt(NodeID src, NodeID dst, const LocationSet& ls, bool constGep);
     /// Add Offset(Gep) edge
-    NormalGepStmt* addNormalGepPE(NodeID src, NodeID dst, const LocationSet& ls);
+    NormalGepStmt* addNormalGepStmt(NodeID src, NodeID dst, const LocationSet& ls);
     /// Add Variant(Gep) edge
-    VariantGepStmt* addVariantGepPE(NodeID src, NodeID dst);
+    VariantGepStmt* addVariantGepStmt(NodeID src, NodeID dst);
     /// Add Thread fork edge for parameter passing
     TDForkPE* addThreadForkPE(NodeID src, NodeID dst, const CallBlockNode* cs);
     /// Add Thread join edge for parameter passing
@@ -660,7 +659,7 @@ private:
     //@}
 
     /// Set a pointer points-to black hole (e.g. int2ptr)
-    SVFStmt* addBlackHoleAddrPE(NodeID node);
+    SVFStmt* addBlackHoleAddrStmt(NodeID node);
 };
 
 typedef SVFIR PAG;