svf-lib 1.0.744 → 1.0.745

package/SVF-osx/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-osx/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-osx/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
@@ -314,9 +314,9 @@ public:
     {
         return pag->getAllFieldsObjNode(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-osx/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-osx/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-osx/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-osx/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-osx/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-osx/include/MemoryModel/PointerAnalysis.h

@@ -346,17 +346,17 @@ 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)
     {

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

@@ -352,7 +352,7 @@ 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());
                 for(NodeBS::iterator it = fields.begin(), eit = fields.end(); it!=eit; ++it)

package/SVF-osx/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> Inst2PAGEdgesMap;
     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
+    Inst2PAGEdgesMap inst2SVFStmtsMap;	///< Map a instruction to its PAGEdges
+    Inst2PAGEdgesMap inst2PTASVFStmtsMap;	///< Map a instruction to its PointerAnalysis related PAGEdges
+    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 inst2SVFStmtsMap.find(inst)!=inst2SVFStmtsMap.end();
     }
-    inline bool hasPTAPAGEdgeList(const ICFGNode* inst) const
+    inline bool hasPTASVFStmtList(const ICFGNode* inst) const
     {
-        return inst2PTAPAGEdgesMap.find(inst)!=inst2PTAPAGEdgesMap.end();
+        return inst2PTASVFStmtsMap.find(inst)!=inst2PTASVFStmtsMap.end();
     }
     /// Given an instruction, get all its PAGEdges
-    inline PAGEdgeList& getInstPAGEdgeList(const ICFGNode* inst)
+    inline SVFStmtList& getSVFStmtList(const ICFGNode* inst)
     {
-        return inst2PAGEdgesMap[inst];
+        return inst2SVFStmtsMap[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 inst2PTASVFStmtsMap[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);
+        inst2SVFStmtsMap[inst].push_back(edge);
         if (edge->isPTAEdge())
-            inst2PTAPAGEdgesMap[inst].push_back(edge);
+            inst2PTASVFStmtsMap[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();
     }
@@ -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 opcode);
     /// 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;

package/SVF-osx/include/MemoryModel/SVFStatements.h

@@ -175,9 +175,10 @@ public:
     }
     //@}
 
-    typedef GenericNode<SVFVar,SVFStmt>::GEdgeSetTy PAGEdgeSetTy;
-    typedef Map<EdgeID, PAGEdgeSetTy> PAGEdgeToSetMapTy;
-    typedef PAGEdgeToSetMapTy PAGKindToEdgeSetMapTy;
+    typedef GenericNode<SVFVar,SVFStmt>::GEdgeSetTy SVFStmtSetTy;
+    typedef Map<EdgeID, SVFStmtSetTy> PAGEdgeToSetMapTy;
+    typedef PAGEdgeToSetMapTy KindToSVFStmtMapTy;
+    typedef SVFStmtSetTy PAGEdgeSetTy;
 
 private:
     typedef Map<const ICFGNode*, u32_t> Inst2LabelMap;

package/SVF-osx/include/MemoryModel/SVFVariables.h

@@ -76,8 +76,8 @@ public:
 
 protected:
     const Value* value; ///< value of this SVFIR node
-    SVFStmt::PAGKindToEdgeSetMapTy InEdgeKindToSetMap;
-    SVFStmt::PAGKindToEdgeSetMapTy OutEdgeKindToSetMap;
+    SVFStmt::KindToSVFStmtMapTy InEdgeKindToSetMap;
+    SVFStmt::KindToSVFStmtMapTy OutEdgeKindToSetMap;
     bool isTLPointer;	/// top-level pointer
     bool isATPointer;	/// address-taken pointer
 
@@ -158,13 +158,13 @@ public:
     }
 
     /// Get incoming SVFIR edges
-    inline SVFStmt::PAGEdgeSetTy& getIncomingEdges(SVFStmt::PEDGEK kind)
+    inline SVFStmt::SVFStmtSetTy& getIncomingEdges(SVFStmt::PEDGEK kind)
     {
         return InEdgeKindToSetMap[kind];
     }
 
     /// Get outgoing SVFIR edges
-    inline SVFStmt::PAGEdgeSetTy& getOutgoingEdges(SVFStmt::PEDGEK kind)
+    inline SVFStmt::SVFStmtSetTy& getOutgoingEdges(SVFStmt::PEDGEK kind)
     {
         return OutEdgeKindToSetMap[kind];
     }
@@ -172,7 +172,7 @@ public:
     /// Has incoming SVFIR edges
     inline bool hasIncomingEdges(SVFStmt::PEDGEK kind) const
     {
-        SVFStmt::PAGKindToEdgeSetMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
+        SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
         if (it != InEdgeKindToSetMap.end())
             return (!it->second.empty());
         else
@@ -182,7 +182,7 @@ public:
     /// Has incoming VariantGepEdges
     inline bool hasIncomingVariantGepEdge() const
     {
-        SVFStmt::PAGKindToEdgeSetMapTy::const_iterator it = InEdgeKindToSetMap.find(SVFStmt::VariantGep);
+        SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(SVFStmt::VariantGep);
         if (it != InEdgeKindToSetMap.end())
         {
             return (!it->second.empty());
@@ -191,17 +191,17 @@ public:
     }
 
     /// Get incoming SVFStmt iterator
-    inline SVFStmt::PAGEdgeSetTy::iterator getIncomingEdgesBegin(SVFStmt::PEDGEK kind) const
+    inline SVFStmt::SVFStmtSetTy::iterator getIncomingEdgesBegin(SVFStmt::PEDGEK kind) const
     {
-        SVFStmt::PAGKindToEdgeSetMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
+        SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
         assert(it!=InEdgeKindToSetMap.end() && "The node does not have such kind of edge");
         return it->second.begin();
     }
 
     /// Get incoming SVFStmt iterator
-    inline SVFStmt::PAGEdgeSetTy::iterator getIncomingEdgesEnd(SVFStmt::PEDGEK kind) const
+    inline SVFStmt::SVFStmtSetTy::iterator getIncomingEdgesEnd(SVFStmt::PEDGEK kind) const
     {
-        SVFStmt::PAGKindToEdgeSetMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
+        SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(kind);
         assert(it!=InEdgeKindToSetMap.end() && "The node does not have such kind of edge");
         return it->second.end();
     }
@@ -209,7 +209,7 @@ public:
     /// Has outgoing SVFIR edges
     inline bool hasOutgoingEdges(SVFStmt::PEDGEK kind) const
     {
-        SVFStmt::PAGKindToEdgeSetMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
+        SVFStmt::KindToSVFStmtMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
         if (it != OutEdgeKindToSetMap.end())
             return (!it->second.empty());
         else
@@ -217,17 +217,17 @@ public:
     }
 
     /// Get outgoing SVFStmt iterator
-    inline SVFStmt::PAGEdgeSetTy::iterator getOutgoingEdgesBegin(SVFStmt::PEDGEK kind) const
+    inline SVFStmt::SVFStmtSetTy::iterator getOutgoingEdgesBegin(SVFStmt::PEDGEK kind) const
     {
-        SVFStmt::PAGKindToEdgeSetMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
+        SVFStmt::KindToSVFStmtMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
         assert(it!=OutEdgeKindToSetMap.end() && "The node does not have such kind of edge");
         return it->second.begin();
     }
 
     /// Get outgoing SVFStmt iterator
-    inline SVFStmt::PAGEdgeSetTy::iterator getOutgoingEdgesEnd(SVFStmt::PEDGEK kind) const
+    inline SVFStmt::SVFStmtSetTy::iterator getOutgoingEdgesEnd(SVFStmt::PEDGEK kind) const
     {
-        SVFStmt::PAGKindToEdgeSetMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
+        SVFStmt::KindToSVFStmtMapTy::const_iterator it = OutEdgeKindToSetMap.find(kind);
         assert(it!=OutEdgeKindToSetMap.end() && "The node does not have such kind of edge");
         return it->second.end();
     }

package/SVF-osx/include/SVF-FE/SVFIRBuilder.h

@@ -269,13 +269,13 @@ public:
 
 public:
 
-    NodeID getGepValNode(const Value* val, const LocationSet& ls, const Type *baseType, u32_t fieldidx);
+    NodeID getGepValVar(const Value* val, const LocationSet& ls, const Type *baseType, u32_t fieldidx);
 
     void setCurrentBBAndValueForPAGEdge(PAGEdge* edge);
 
     inline PAGEdge* addBlackHoleAddrEdge(NodeID node)
     {
-        PAGEdge *edge = pag->addBlackHoleAddrPE(node);
+        PAGEdge *edge = pag->addBlackHoleAddrStmt(node);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
@@ -283,42 +283,42 @@ public:
     /// Add Address edge
     inline AddrStmt* addAddrEdge(NodeID src, NodeID dst)
     {
-        AddrStmt *edge = pag->addAddrPE(src, dst);
+        AddrStmt *edge = pag->addAddrStmt(src, dst);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Copy edge
     inline CopyStmt* addCopyEdge(NodeID src, NodeID dst)
     {
-        CopyStmt *edge = pag->addCopyPE(src, dst);
+        CopyStmt *edge = pag->addCopyStmt(src, dst);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Copy edge
-    inline PhiStmt* addPhiNode(NodeID res, NodeID opnd)
+    inline PhiStmt* addPhiStmt(NodeID res, NodeID opnd)
     {
-        PhiStmt *edge = pag->addPhiNode(res,opnd);
+        PhiStmt *edge = pag->addPhiStmt(res,opnd);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Copy edge
     inline CmpStmt* addCmpEdge(NodeID op1, NodeID op2, NodeID dst, u32_t opcode)
     {
-        CmpStmt *edge = pag->addCmpPE(op1, op2, dst, opcode);
+        CmpStmt *edge = pag->addCmpStmt(op1, op2, dst, opcode);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Copy edge
     inline BinaryOPStmt* addBinaryOPEdge(NodeID op1, NodeID op2, NodeID dst, u32_t opcode)
     {
-        BinaryOPStmt *edge = pag->addBinaryOPPE(op1, op2, dst, opcode);
+        BinaryOPStmt *edge = pag->addBinaryOPStmt(op1, op2, dst, opcode);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Unary edge
     inline UnaryOPStmt* addUnaryOPEdge(NodeID src, NodeID dst, u32_t opcode)
     {
-        UnaryOPStmt *edge = pag->addUnaryOPPE(src, dst, opcode);
+        UnaryOPStmt *edge = pag->addUnaryOPStmt(src, dst, opcode);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
@@ -331,7 +331,7 @@ public:
     /// Add Load edge
     inline LoadStmt* addLoadEdge(NodeID src, NodeID dst)
     {
-        LoadStmt *edge = pag->addLoadPE(src, dst);
+        LoadStmt *edge = pag->addLoadStmt(src, dst);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
@@ -343,7 +343,7 @@ public:
             node = pag->getICFG()->getIntraBlockNode(inst);
         else
             node = nullptr;
-        StoreStmt *edge = pag->addStorePE(src, dst, node);
+        StoreStmt *edge = pag->addStoreStmt(src, dst, node);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
@@ -364,21 +364,21 @@ public:
     /// Add Gep edge
     inline GepStmt* addGepEdge(NodeID src, NodeID dst, const LocationSet& ls, bool constGep)
     {
-        GepStmt *edge = pag->addGepPE(src, dst, ls, constGep);
+        GepStmt *edge = pag->addGepStmt(src, dst, ls, constGep);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Offset(Gep) edge
     inline NormalGepStmt* addNormalGepEdge(NodeID src, NodeID dst, const LocationSet& ls)
     {
-        NormalGepStmt *edge = pag->addNormalGepPE(src, dst, ls);
+        NormalGepStmt *edge = pag->addNormalGepStmt(src, dst, ls);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Variant(Gep) edge
     inline VariantGepStmt* addVariantGepEdge(NodeID src, NodeID dst)
     {
-        VariantGepStmt *edge = pag->addVariantGepPE(src, dst);
+        VariantGepStmt *edge = pag->addVariantGepStmt(src, dst);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }

package/SVF-osx/include/Util/IRAnnotator.h

@@ -99,7 +99,7 @@ private:
             SVF::Size_t locationSetOffset = std::stoi(llvm::cast<llvm::MDString>(mdNode->getOperand(1))->getString().str());
 
             LocationSet locationSet = LocationSet(locationSetOffset);
-            SVF::NodeID gepnodeId = pag->getGepObjNode(baseNodeId, locationSet);
+            SVF::NodeID gepnodeId = pag->getGepObjVar(baseNodeId, locationSet);
 
             assert(nodeId == gepnodeId && "nodeId != gepnodeId");
         }

package/SVF-osx/include/Util/TypeBasedHeapCloning.h

@@ -97,8 +97,8 @@ protected:
     const NodeBS &getGepObjs(NodeID base);
 
     /// Returns the GEP object node(s) of base for ls. This may include clones.
-    /// If there are no GEP objects, then getGepObjNode is called on the SVFIR
-    /// (through base's getGepObjNode) which will create one.
+    /// If there are no GEP objects, then getGepObjVar is called on the SVFIR
+    /// (through base's getGepObjVar) which will create one.
     const NodeBS getGepObjClones(NodeID base, unsigned offset);
 
     /// Initialise the pointees of p at loc (which is type tildet *). reuse indicates

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.744",
+  "version": "1.0.745",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {