svf-lib 1.0.739 → 1.0.743

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

@@ -1,8 +1,8 @@
-//===----- CHG.h -- Base class of pointer analyses ---------------------------//
+//===----- CHG.h -- Class hirachary graph  ---------------------------//
 //
 //                     SVF: Static Value-Flow Analysis
 //
-// Copyright (C) <2013-2017>  <Yulei Sui>
+// Copyright (C) <2013->  <Yulei Sui>
 //
 
 // This program is free software: you can redistribute it and/or modify

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

@@ -47,7 +47,7 @@ class VFGNode;
 
 /*!
  * Interprocedural control-flow graph node, representing different kinds of program statements
- * including top-level pointers (ValPN) and address-taken objects (ObjPN)
+ * including top-level pointers (ValVar) and address-taken objects (ObjVar)
  */
 typedef GenericNode<ICFGNode, ICFGEdge> GenericICFGNodeTy;
 

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

@@ -483,28 +483,28 @@ protected:
         setDef(pagNode,sNode);
     }
     /// Add an Address VFG node
-    inline void addAddrVFGNode(const AddrPE* addr)
+    inline void addAddrVFGNode(const AddrStmt* addr)
     {
         AddrVFGNode* sNode = new AddrVFGNode(totalVFGNode++,addr);
         addStmtVFGNode(sNode, addr);
         setDef(addr->getDstNode(),sNode);
     }
     /// Add a Copy VFG node
-    inline void addCopyVFGNode(const CopyPE* copy)
+    inline void addCopyVFGNode(const CopyStmt* copy)
     {
         CopyVFGNode* sNode = new CopyVFGNode(totalVFGNode++,copy);
         addStmtVFGNode(sNode, copy);
         setDef(copy->getDstNode(),sNode);
     }
     /// Add a Gep VFG node
-    inline void addGepVFGNode(const GepPE* gep)
+    inline void addGepVFGNode(const GepStmt* gep)
     {
         GepVFGNode* sNode = new GepVFGNode(totalVFGNode++,gep);
         addStmtVFGNode(sNode, gep);
         setDef(gep->getDstNode(),sNode);
     }
     /// Add a Load VFG node
-    void addLoadVFGNode(const LoadPE* load)
+    void addLoadVFGNode(const LoadStmt* load)
     {
         LoadVFGNode* sNode = new LoadVFGNode(totalVFGNode++,load);
         addStmtVFGNode(sNode, load);
@@ -512,7 +512,7 @@ protected:
     }
     /// Add a Store VFG 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)
+    void addStoreVFGNode(const StoreStmt* store)
     {
         StoreVFGNode* sNode = new StoreVFGNode(totalVFGNode++,store);
         addStmtVFGNode(sNode, store);
@@ -569,7 +569,7 @@ protected:
         PAGNodeToActualRetMap[ret] = sNode;
     }
     /// Add an llvm PHI VFG node
-    inline void addIntraPHIVFGNode(const PhiPE* edge)
+    inline void addIntraPHIVFGNode(const PhiStmt* edge)
     {
         IntraPHIVFGNode* sNode = new IntraPHIVFGNode(totalVFGNode++,edge->getRes());
         u32_t pos = 0;
@@ -583,7 +583,7 @@ protected:
         PAGNodeToIntraPHIVFGNodeMap[edge->getRes()] = sNode;
     }
     /// Add a Compare VFG node
-    inline void addCmpVFGNode(const CmpPE* edge)
+    inline void addCmpVFGNode(const CmpStmt* edge)
     {
         CmpVFGNode* sNode = new CmpVFGNode(totalVFGNode++, edge->getRes());
         u32_t pos = 0;
@@ -597,7 +597,7 @@ protected:
         PAGNodeToCmpVFGNodeMap[edge->getRes()] = sNode;
     }
     /// Add a BinaryOperator VFG node
-    inline void addBinaryOPVFGNode(const BinaryOPPE* edge)
+    inline void addBinaryOPVFGNode(const BinaryOPStmt* edge)
     {
         BinaryOPVFGNode* sNode = new BinaryOPVFGNode(totalVFGNode++, edge->getRes());
         u32_t pos = 0;
@@ -611,7 +611,7 @@ protected:
         PAGNodeToBinaryOPVFGNodeMap[edge->getRes()] = sNode;
     }
     /// Add a UnaryOperator VFG node
-    inline void addUnaryOPVFGNode(const UnaryOPPE* edge)
+    inline void addUnaryOPVFGNode(const UnaryOPStmt* edge)
     {
         UnaryOPVFGNode* sNode = new UnaryOPVFGNode(totalVFGNode++, edge->getRes());
         sNode->setOpVer(0, edge->getOpVar());

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

@@ -40,7 +40,7 @@ namespace SVF
 
 /*!
  * Interprocedural control-flow graph node, representing different kinds of program statements
- * including top-level pointers (ValPN) and address-taken objects (ObjPN)
+ * including top-level pointers (ValVar) and address-taken objects (ObjVar)
  */
 typedef GenericNode<VFGNode,VFGEdge> GenericVFGNodeTy;
 class VFGNode : public GenericVFGNodeTy
@@ -202,7 +202,7 @@ private:
 
 public:
     /// Constructor
-    LoadVFGNode(NodeID id, const LoadPE* edge): StmtVFGNode(id, edge,Load)
+    LoadVFGNode(NodeID id, const LoadStmt* edge): StmtVFGNode(id, edge,Load)
     {
 
     }
@@ -241,7 +241,7 @@ private:
 
 public:
     /// Constructor
-    StoreVFGNode(NodeID id,const StorePE* edge): StmtVFGNode(id,edge,Store)
+    StoreVFGNode(NodeID id,const StoreStmt* edge): StmtVFGNode(id,edge,Store)
     {
 
     }
@@ -280,7 +280,7 @@ private:
 
 public:
     /// Constructor
-    CopyVFGNode(NodeID id,const CopyPE* copy): StmtVFGNode(id,copy,Copy)
+    CopyVFGNode(NodeID id,const CopyStmt* copy): StmtVFGNode(id,copy,Copy)
     {
 
     }
@@ -591,7 +591,7 @@ private:
 
 public:
     /// Constructor
-    GepVFGNode(NodeID id,const GepPE* edge): StmtVFGNode(id,edge,Gep)
+    GepVFGNode(NodeID id,const GepStmt* edge): StmtVFGNode(id,edge,Gep)
     {
 
     }
@@ -753,7 +753,7 @@ private:
 
 public:
     /// Constructor
-    AddrVFGNode(NodeID id, const AddrPE* edge): StmtVFGNode(id, edge,Addr)
+    AddrVFGNode(NodeID id, const AddrStmt* edge): StmtVFGNode(id, edge,Addr)
     {
 
     }

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

@@ -166,13 +166,13 @@ class LoadMU : public MSSAMU<Cond>
 {
 
 private:
-    const LoadPE* inst;
+    const LoadStmt* inst;
     const BasicBlock* bb;
 
 public:
     /// Constructor/Destructor for MU
     //@{
-    LoadMU(const BasicBlock* b,const LoadPE* i, const MemRegion* m, Cond c = true) :
+    LoadMU(const BasicBlock* b,const LoadStmt* i, const MemRegion* m, Cond c = true) :
         MSSAMU<Cond>(MSSAMU<Cond>::LoadMSSAMU,m,c), inst(i), bb(b)
     {
     }
@@ -183,7 +183,7 @@ public:
     //@}
 
     /// Return load instruction
-    inline const LoadPE* getLoadInst() const
+    inline const LoadStmt* getLoadInst() const
     {
         return inst;
     }
@@ -462,11 +462,11 @@ class StoreCHI : public MSSACHI<Cond>
 {
 private:
     const BasicBlock* bb;
-    const StorePE* inst;
+    const StoreStmt* inst;
 public:
     /// Constructors for StoreCHI
     //@{
-    StoreCHI(const BasicBlock* b, const StorePE* i, const MemRegion* m, Cond c = true) :
+    StoreCHI(const BasicBlock* b, const StoreStmt* i, const MemRegion* m, Cond c = true) :
         MSSACHI<Cond>(MSSADEF::StoreMSSACHI,m,c), bb(b), inst(i)
     {
     }
@@ -482,7 +482,7 @@ public:
     }
 
     /// Get store instruction
-    inline const StorePE* getStoreInst() const
+    inline const StoreStmt* getStoreInst() const
     {
         return inst;
     }

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

@@ -146,15 +146,15 @@ public:
     /// Map loads/stores to its mem regions,
     /// TODO:visitAtomicCmpXchgInst, visitAtomicRMWInst??
     //@{
-    typedef Map<const LoadPE*, MRSet> LoadsToMRsMap;
-    typedef Map<const StorePE*, MRSet> StoresToMRsMap;
+    typedef Map<const LoadStmt*, MRSet> LoadsToMRsMap;
+    typedef Map<const StoreStmt*, MRSet> StoresToMRsMap;
     typedef Map<const CallBlockNode*, MRSet> CallSiteToMRsMap;
     //@}
 
     /// Map loads/stores/callsites to their cpts set
     //@{
-    typedef Map<const LoadPE*, NodeBS> LoadsToPointsToMap;
-    typedef Map<const StorePE*, NodeBS> StoresToPointsToMap;
+    typedef Map<const LoadStmt*, NodeBS> LoadsToPointsToMap;
+    typedef Map<const StoreStmt*, NodeBS> StoresToPointsToMap;
     typedef Map<const CallBlockNode*, NodeBS> CallSiteToPointsToMap;
     //@}
 
@@ -334,13 +334,13 @@ protected:
 
     /// Add cpts to store/load
     //@{
-    inline void addCPtsToStore(NodeBS& cpts, const StorePE *st, const SVFFunction* fun)
+    inline void addCPtsToStore(NodeBS& cpts, const StoreStmt *st, const SVFFunction* fun)
     {
         storesToPointsToMap[st] = cpts;
         funToPointsToMap[fun].insert(cpts);
         addModSideEffectOfFunction(fun,cpts);
     }
-    inline void addCPtsToLoad(NodeBS& cpts, const LoadPE *ld, const SVFFunction* fun)
+    inline void addCPtsToLoad(NodeBS& cpts, const LoadStmt *ld, const SVFFunction* fun)
     {
         loadsToPointsToMap[ld] = cpts;
         funToPointsToMap[fun].insert(cpts);
@@ -440,11 +440,11 @@ public:
     {
         return funToMRsMap[fun];
     }
-    inline MRSet& getLoadMRSet(const LoadPE* load)
+    inline MRSet& getLoadMRSet(const LoadStmt* load)
     {
         return loadsToMRsMap[load];
     }
-    inline MRSet& getStoreMRSet(const StorePE* store)
+    inline MRSet& getStoreMRSet(const StoreStmt* store)
     {
         return storesToMRsMap[store];
     }

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

@@ -71,8 +71,8 @@ public:
     /// Map loads/stores to its mem regions,
     /// TODO:visitAtomicCmpXchgInst, visitAtomicRMWInst??
     //@{
-    typedef Map<const LoadPE*, MUSet> LoadToMUSetMap;
-    typedef Map<const StorePE*, CHISet> StoreToChiSetMap;
+    typedef Map<const LoadStmt*, MUSet> LoadToMUSetMap;
+    typedef Map<const StoreStmt*, CHISet> StoreToChiSetMap;
     typedef Map<const CallBlockNode*, MUSet> CallSiteToMUSetMap;
     typedef Map<const CallBlockNode*, CHISet> CallSiteToCHISetMap;
     typedef Map<const BasicBlock*, PHISet> BBToPhiSetMap;
@@ -180,12 +180,12 @@ private:
 
     /// Add methods for mus/chis/phis
     //@{
-    inline void AddLoadMU(const BasicBlock* bb, const LoadPE* load, const MRSet& mrSet)
+    inline void AddLoadMU(const BasicBlock* bb, const LoadStmt* load, const MRSet& mrSet)
     {
         for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
             AddLoadMU(bb,load,*iter);
     }
-    inline void AddStoreCHI(const BasicBlock* bb, const StorePE* store, const MRSet& mrSet)
+    inline void AddStoreCHI(const BasicBlock* bb, const StoreStmt* store, const MRSet& mrSet)
     {
         for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
             AddStoreCHI(bb,store,*iter);
@@ -205,13 +205,13 @@ private:
         for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
             AddMSSAPHI(bb,*iter);
     }
-    inline void AddLoadMU(const BasicBlock* bb, const LoadPE* load, const MemRegion* mr)
+    inline void AddLoadMU(const BasicBlock* bb, const LoadStmt* load, const MemRegion* mr)
     {
         LOADMU* mu = new LOADMU(bb,load, mr);
         load2MuSetMap[load].insert(mu);
         collectRegUses(mr);
     }
-    inline void AddStoreCHI(const BasicBlock* bb, const StorePE* store, const MemRegion* mr)
+    inline void AddStoreCHI(const BasicBlock* bb, const StoreStmt* store, const MemRegion* mr)
     {
         STORECHI* chi = new STORECHI(bb,store, mr);
         store2ChiSetMap[store].insert(chi);
@@ -331,7 +331,7 @@ public:
     //@{
     inline bool hasMU(const PAGEdge* inst) const
     {
-        if (const LoadPE* load = SVFUtil::dyn_cast<LoadPE>(inst))
+        if (const LoadStmt* load = SVFUtil::dyn_cast<LoadStmt>(inst))
         {
             assert(0 != load2MuSetMap.count(load)
                    && "not associated with mem region!");
@@ -342,7 +342,7 @@ public:
     }
     inline bool hasCHI(const PAGEdge* inst) const
     {
-        if (const StorePE* store = SVFUtil::dyn_cast<StorePE>(
+        if (const StoreStmt* store = SVFUtil::dyn_cast<StoreStmt>(
                                        inst))
         {
             assert(0 != store2ChiSetMap.count(store)
@@ -385,11 +385,11 @@ public:
 
     /// Get methods of mu/chi/phi
     //@{
-    inline MUSet& getMUSet(const LoadPE* ld)
+    inline MUSet& getMUSet(const LoadStmt* ld)
     {
         return load2MuSetMap[ld];
     }
-    inline CHISet& getCHISet(const StorePE* st)
+    inline CHISet& getCHISet(const StoreStmt* st)
     {
         return store2ChiSetMap[st];
     }

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

@@ -344,7 +344,7 @@ public:
     ///@{
     inline bool isFIObjNode(NodeID id) const
     {
-        return (SVFUtil::isa<FIObjPN>(pag->getGNode(id)));
+        return (SVFUtil::isa<FIObjVar>(pag->getGNode(id)));
     }
     inline NodeID getBaseObjNode(NodeID id)
     {

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

@@ -577,11 +577,11 @@ public:
             const PAGNode* node = this->getPAG()->getGNode(*nIter);
             if (this->getPAG()->isValidTopLevelPtr(node))
             {
-                if (SVFUtil::isa<DummyObjPN>(node))
+                if (SVFUtil::isa<DummyObjVar>(node))
                 {
                     SVFUtil::outs() << "##<Blackhole or constant> id:" << node->getId();
                 }
-                else if (!SVFUtil::isa<DummyValPN>(node))
+                else if (!SVFUtil::isa<DummyValVar>(node))
                 {
                     SVFUtil::outs() << "##<" << node->getValue()->getName() << "> ";
                     //SVFUtil::outs() << "Source Loc: " << SVFUtil::getSourceLoc(node->getValue());

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

@@ -55,8 +55,8 @@ public:
     typedef Map<NodeID,NodeBS> MemObjToFieldsMap;
     typedef std::vector<const SVFStmt*> PAGEdgeList;
     typedef std::vector<const SVFVar*> PAGNodeList;
-    typedef std::vector<const CopyPE*> CopyPEList;
-    typedef Map<const SVFVar*,PhiPE*> PHINodeMap;
+    typedef std::vector<const CopyStmt*> CopyPEList;
+    typedef Map<const SVFVar*,PhiStmt*> PHINodeMap;
     typedef Map<const SVFFunction*,PAGNodeList> FunToArgsListMap;
     typedef Map<const CallBlockNode*,PAGNodeList> CSToArgsListMap;
     typedef Map<const RetBlockNode*,const SVFVar*> CSToRetMap;
@@ -292,7 +292,7 @@ public:
     }
     //@}
 
-    /// Due to constaint expression, curInst is used to distinguish different instructions (e.g., memorycpy) when creating GepValPN.
+    /// 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
     {
         GepValPNMap::const_iterator iter = GepValNodeMap.find(curInst);
@@ -353,17 +353,17 @@ public:
 
     /// Get memory object - Return memory object according to pag node id
     /// return whole allocated memory object if this node is a gep obj node
-    /// return nullptr is this node is not a ObjPN type
+    /// return nullptr is this node is not a ObjVar type
     //@{
     inline const MemObj*getObject(NodeID id) const
     {
         const SVFVar* node = getGNode(id);
-        if(const ObjPN* objPN = SVFUtil::dyn_cast<ObjPN>(node))
+        if(const ObjVar* objPN = SVFUtil::dyn_cast<ObjVar>(node))
             return getObject(objPN);
         else
             return nullptr;
     }
-    inline const MemObj*getObject(const ObjPN* node) const
+    inline const MemObj*getObject(const ObjVar* node) const
     {
         return node->getMemObj();
     }
@@ -382,8 +382,8 @@ public:
     inline NodeID getFIObjNode(NodeID id) const
     {
         SVFVar* node = pag->getGNode(id);
-        assert(SVFUtil::isa<ObjPN>(node) && "need an object node");
-        ObjPN* obj = SVFUtil::cast<ObjPN>(node);
+        assert(SVFUtil::isa<ObjVar>(node) && "need an object node");
+        ObjVar* obj = SVFUtil::cast<ObjVar>(node);
         return getFIObjNode(obj->getMemObj());
     }
     //@}
@@ -415,7 +415,7 @@ public:
     inline bool isNonPointerObj(NodeID id) const
     {
         SVFVar* node = getGNode(id);
-        if (FIObjPN* fiNode = SVFUtil::dyn_cast<FIObjPN>(node))
+        if (FIObjVar* fiNode = SVFUtil::dyn_cast<FIObjVar>(node))
         {
             return (fiNode->getMemObj()->hasPtrObj() == false);
         }
@@ -423,7 +423,7 @@ public:
         {
             return (gepNode->getMemObj()->isNonPtrFieldObj(gepNode->getLocationSet()));
         }
-        else if (SVFUtil::isa<DummyObjPN>(node))
+        else if (SVFUtil::isa<DummyObjVar>(node))
         {
             return false;
         }
@@ -447,8 +447,8 @@ public:
     inline const MemObj* getBaseObj(NodeID id) const
     {
         const SVFVar* node = pag->getGNode(id);
-        assert(SVFUtil::isa<ObjPN>(node) && "need an object node");
-        const ObjPN* obj = SVFUtil::cast<ObjPN>(node);
+        assert(SVFUtil::isa<ObjVar>(node) && "need an object node");
+        const ObjVar* obj = SVFUtil::cast<ObjVar>(node);
         return obj->getMemObj();
     }
     //@}
@@ -530,7 +530,7 @@ private:
     /// Add a value (pointer) node
     inline NodeID addValNode(const Value* val, NodeID i)
     {
-        SVFVar *node = new ValPN(val,i);
+        SVFVar *node = new ValVar(val,i);
         return addValNode(val, node, i);
     }
     /// Add a memory obj node
@@ -565,12 +565,12 @@ private:
     //@{
     inline NodeID addDummyValNode(NodeID i)
     {
-        return addValNode(nullptr, new DummyValPN(i), i);
+        return addValNode(nullptr, new DummyValVar(i), i);
     }
     inline NodeID addDummyObjNode(NodeID i, const Type* type)
     {
         const MemObj* mem = addDummyMemObj(i, type);
-        return addObjNode(nullptr, new DummyObjPN(i,mem), i);
+        return addObjNode(nullptr, new DummyObjVar(i,mem), i);
     }
     inline const MemObj* addDummyMemObj(NodeID i, const Type* type)
     {
@@ -578,11 +578,11 @@ private:
     }
     inline NodeID addBlackholeObjNode()
     {
-        return addObjNode(nullptr, new DummyObjPN(getBlackHoleNode(),getBlackHoleObj()), getBlackHoleNode());
+        return addObjNode(nullptr, new DummyObjVar(getBlackHoleNode(),getBlackHoleObj()), getBlackHoleNode());
     }
     inline NodeID addConstantObjNode()
     {
-        return addObjNode(nullptr, new DummyObjPN(getConstantNode(),getConstantObj()), getConstantNode());
+        return addObjNode(nullptr, new DummyObjVar(getConstantNode(),getConstantObj()), getConstantNode());
     }
     inline NodeID addBlackholePtrNode()
     {
@@ -626,33 +626,33 @@ private:
     /// Add an edge into SVFIR
     //@{
     /// Add Address edge
-    AddrPE* addAddrPE(NodeID src, NodeID dst);
+    AddrStmt* addAddrPE(NodeID src, NodeID dst);
     /// Add Copy edge
-    CopyPE* addCopyPE(NodeID src, NodeID dst);
+    CopyStmt* addCopyPE(NodeID src, NodeID dst);
     /// Add phi node information
-    PhiPE*  addPhiNode(NodeID res, NodeID opnd);
+    PhiStmt*  addPhiNode(NodeID res, NodeID opnd);
     /// Add Copy edge
-    CmpPE* addCmpPE(NodeID op1, NodeID op2, NodeID dst, u32_t opcode);
+    CmpStmt* addCmpPE(NodeID op1, NodeID op2, NodeID dst, u32_t opcode);
     /// Add Copy edge
-    BinaryOPPE* addBinaryOPPE(NodeID op1, NodeID op2, NodeID dst, u32_t opcode);
+    BinaryOPStmt* addBinaryOPPE(NodeID op1, NodeID op2, NodeID dst, u32_t opcode);
     /// Add Unary edge
-    UnaryOPPE* addUnaryOPPE(NodeID src, NodeID dst, u32_t opcode);
+    UnaryOPStmt* addUnaryOPPE(NodeID src, NodeID dst, u32_t opcode);
     /// Add BranchStmt
     BranchStmt* addBranchStmt(NodeID br, NodeID cond, std::vector<const ICFGNode*> succs);
     /// Add Load edge
-    LoadPE* addLoadPE(NodeID src, NodeID dst);
+    LoadStmt* addLoadPE(NodeID src, NodeID dst);
     /// Add Store edge
-    StorePE* addStorePE(NodeID src, NodeID dst, const IntraBlockNode* val);
+    StoreStmt* addStorePE(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
-    GepPE* addGepPE(NodeID src, NodeID dst, const LocationSet& ls, bool constGep);
+    GepStmt* addGepPE(NodeID src, NodeID dst, const LocationSet& ls, bool constGep);
     /// Add Offset(Gep) edge
-    NormalGepPE* addNormalGepPE(NodeID src, NodeID dst, const LocationSet& ls);
+    NormalGepStmt* addNormalGepPE(NodeID src, NodeID dst, const LocationSet& ls);
     /// Add Variant(Gep) edge
-    VariantGepPE* addVariantGepPE(NodeID src, NodeID dst);
+    VariantGepStmt* addVariantGepPE(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

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

@@ -193,16 +193,16 @@ private:
 /*!
  * Copy edge
  */
-class AddrPE: public SVFStmt
+class AddrStmt: public SVFStmt
 {
 private:
-    AddrPE();                      ///< place holder
-    AddrPE(const AddrPE &);  ///< place holder
-    void operator=(const AddrPE &); ///< place holder
+    AddrStmt();                      ///< place holder
+    AddrStmt(const AddrStmt &);  ///< place holder
+    void operator=(const AddrStmt &); ///< place holder
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const AddrPE *)
+    static inline bool classof(const AddrStmt *)
     {
         return true;
     }
@@ -217,7 +217,7 @@ public:
     //@}
 
     /// constructor
-    AddrPE(SVFVar* s, SVFVar* d) : SVFStmt(s,d,SVFStmt::Addr)
+    AddrStmt(SVFVar* s, SVFVar* d) : SVFStmt(s,d,SVFStmt::Addr)
     {
     }
 
@@ -228,16 +228,16 @@ public:
 /*!
  * Copy edge
  */
-class CopyPE: public SVFStmt
+class CopyStmt: public SVFStmt
 {
 private:
-    CopyPE();                      ///< place holder
-    CopyPE(const CopyPE &);  ///< place holder
-    void operator=(const CopyPE &); ///< place holder
+    CopyStmt();                      ///< place holder
+    CopyStmt(const CopyStmt &);  ///< place holder
+    void operator=(const CopyStmt &); ///< place holder
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const CopyPE *)
+    static inline bool classof(const CopyStmt *)
     {
         return true;
     }
@@ -252,7 +252,7 @@ public:
     //@}
 
     /// constructor
-    CopyPE(SVFVar* s, SVFVar* d) : SVFStmt(s,d,SVFStmt::Copy)
+    CopyStmt(SVFVar* s, SVFVar* d) : SVFStmt(s,d,SVFStmt::Copy)
     {
     }
 
@@ -325,12 +325,12 @@ public:
 /*!
  * Phi instruction edge
  */
-class PhiPE: public MultiOpndStmt
+class PhiStmt: public MultiOpndStmt
 {
 private:
-    PhiPE();                      ///< place holder
-    PhiPE(const PhiPE &);  ///< place holder
-    void operator=(const PhiPE &); ///< place holder
+    PhiStmt();                      ///< place holder
+    PhiStmt(const PhiStmt &);  ///< place holder
+    void operator=(const PhiStmt &); ///< place holder
     SVFVar* getSrcNode();  ///< place holder, not allowed since this SVFStmt has multiple operands but not a single source
     SVFVar* getDstNode();    ///< place holder, use getRes() instead
     SVFVar* getSrcID();  ///< place holder, use getOpVarID(pos) instead
@@ -339,7 +339,7 @@ private:
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const PhiPE *)
+    static inline bool classof(const PhiStmt *)
     {
         return true;
     }
@@ -358,7 +358,7 @@ public:
     //@}
 
     /// constructor
-    PhiPE(SVFVar* s, const OPVars& opnds) : MultiOpndStmt(s,opnds,SVFStmt::Phi)
+    PhiStmt(SVFVar* s, const OPVars& opnds) : MultiOpndStmt(s,opnds,SVFStmt::Phi)
     {
     }
     void addOpVar(SVFVar* op){
@@ -371,12 +371,12 @@ public:
 /*!
  * Compare instruction edge
  */
-class CmpPE: public MultiOpndStmt
+class CmpStmt: public MultiOpndStmt
 {
 private:
-    CmpPE();                      ///< place holder
-    CmpPE(const CmpPE &);  ///< place holder
-    void operator=(const CmpPE &); ///< place holder
+    CmpStmt();                      ///< place holder
+    CmpStmt(const CmpStmt &);  ///< place holder
+    void operator=(const CmpStmt &); ///< place holder
     SVFVar* getSrcNode();  ///< place holder, not allowed since this SVFStmt has multiple operands but not a single source
     SVFVar* getDstNode();    ///< place holder, use getRes() instead
     SVFVar* getSrcID();  ///< place holder, use getOpVarID(pos) instead
@@ -386,7 +386,7 @@ private:
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const CmpPE *)
+    static inline bool classof(const CmpStmt *)
     {
         return true;
     }
@@ -405,7 +405,7 @@ public:
     //@}
 
     /// constructor
-    CmpPE(SVFVar* s, const OPVars& opnds, u32_t oc) : MultiOpndStmt(s,opnds,SVFStmt::Cmp), opcode(oc)
+    CmpStmt(SVFVar* s, const OPVars& opnds, u32_t oc) : MultiOpndStmt(s,opnds,SVFStmt::Cmp), opcode(oc)
     {
     }
 
@@ -421,12 +421,12 @@ public:
 /*!
  * Binary instruction edge
  */
-class BinaryOPPE: public MultiOpndStmt
+class BinaryOPStmt: public MultiOpndStmt
 {
 private:
-    BinaryOPPE();                      ///< place holder
-    BinaryOPPE(const BinaryOPPE &);  ///< place holder
-    void operator=(const BinaryOPPE &); ///< place holder
+    BinaryOPStmt();                      ///< place holder
+    BinaryOPStmt(const BinaryOPStmt &);  ///< place holder
+    void operator=(const BinaryOPStmt &); ///< place holder
     SVFVar* getSrcNode();  ///< place holder, not allowed since this SVFStmt has multiple operands but not a single source
     SVFVar* getDstNode();    ///< place holder, use getRes() instead
     SVFVar* getSrcID();  ///< place holder, use getOpVarID(pos) instead
@@ -437,7 +437,7 @@ private:
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const BinaryOPPE *)
+    static inline bool classof(const BinaryOPStmt *)
     {
         return true;
     }
@@ -456,7 +456,7 @@ public:
     //@}
 
     /// constructor
-    BinaryOPPE(SVFVar* s, const OPVars& opnds, u32_t oc) : MultiOpndStmt(s,opnds,SVFStmt::BinaryOp), opcode(oc)
+    BinaryOPStmt(SVFVar* s, const OPVars& opnds, u32_t oc) : MultiOpndStmt(s,opnds,SVFStmt::BinaryOp), opcode(oc)
     {
     }
 
@@ -471,12 +471,12 @@ public:
 /*!
  * Unary instruction edge
  */
-class UnaryOPPE: public SVFStmt
+class UnaryOPStmt: public SVFStmt
 {
 private:
-    UnaryOPPE();                      ///< place holder
-    UnaryOPPE(const UnaryOPPE &);  ///< place holder
-    void operator=(const UnaryOPPE &); ///< place holder
+    UnaryOPStmt();                      ///< place holder
+    UnaryOPStmt(const UnaryOPStmt &);  ///< place holder
+    void operator=(const UnaryOPStmt &); ///< place holder
     SVFVar* getSrcNode();  ///< place holder, use getOpVar() instead
     SVFVar* getDstNode();    ///< place holder, use getRes() instead
     SVFVar* getSrcID();  ///< place holder, use getOpVarID() instead
@@ -486,7 +486,7 @@ private:
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const UnaryOPPE *)
+    static inline bool classof(const UnaryOPStmt *)
     {
         return true;
     }
@@ -501,7 +501,7 @@ public:
     //@}
 
     /// constructor
-    UnaryOPPE(SVFVar* s, SVFVar* d, u32_t oc) : SVFStmt(s,d,SVFStmt::UnaryOp), opcode(oc)
+    UnaryOPStmt(SVFVar* s, SVFVar* d, u32_t oc) : SVFStmt(s,d,SVFStmt::UnaryOp), opcode(oc)
     {
     }
 
@@ -588,17 +588,17 @@ public:
 /*!
  * Store edge
  */
-class StorePE: public SVFStmt
+class StoreStmt: public SVFStmt
 {
 private:
-    StorePE();                      ///< place holder
-    StorePE(const StorePE &);  ///< place holder
-    void operator=(const StorePE &); ///< place holder
+    StoreStmt();                      ///< place holder
+    StoreStmt(const StoreStmt &);  ///< place holder
+    void operator=(const StoreStmt &); ///< place holder
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const StorePE *)
+    static inline bool classof(const StoreStmt *)
     {
         return true;
     }
@@ -613,7 +613,7 @@ public:
     //@}
 
     /// constructor
-    StorePE(SVFVar* s, SVFVar* d, const IntraBlockNode* st) :
+    StoreStmt(SVFVar* s, SVFVar* d, const IntraBlockNode* st) :
         SVFStmt(s, d, makeEdgeFlagWithStoreInst(SVFStmt::Store, st))
     {
     }
@@ -625,17 +625,17 @@ public:
 /*!
  * Load edge
  */
-class LoadPE: public SVFStmt
+class LoadStmt: public SVFStmt
 {
 private:
-    LoadPE();                      ///< place holder
-    LoadPE(const LoadPE &);  ///< place holder
-    void operator=(const LoadPE &); ///< place holder
+    LoadStmt();                      ///< place holder
+    LoadStmt(const LoadStmt &);  ///< place holder
+    void operator=(const LoadStmt &); ///< place holder
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const LoadPE *)
+    static inline bool classof(const LoadStmt *)
     {
         return true;
     }
@@ -650,7 +650,7 @@ public:
     //@}
 
     /// constructor
-    LoadPE(SVFVar* s, SVFVar* d) : SVFStmt(s,d,SVFStmt::Load)
+    LoadStmt(SVFVar* s, SVFVar* d) : SVFStmt(s,d,SVFStmt::Load)
     {
     }
 
@@ -661,17 +661,17 @@ public:
 /*!
  * Gep edge
  */
-class GepPE: public SVFStmt
+class GepStmt: public SVFStmt
 {
 private:
-    GepPE();                      ///< place holder
-    GepPE(const GepPE &);  ///< place holder
-    void operator=(const GepPE &); ///< place holder
+    GepStmt();                      ///< place holder
+    GepStmt(const GepStmt &);  ///< place holder
+    void operator=(const GepStmt &); ///< place holder
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const GepPE *)
+    static inline bool classof(const GepStmt *)
     {
         return true;
     }
@@ -689,7 +689,7 @@ public:
 
 protected:
     /// constructor
-    GepPE(SVFVar* s, SVFVar* d, PEDGEK k) : SVFStmt(s,d,k)
+    GepStmt(SVFVar* s, SVFVar* d, PEDGEK k) : SVFStmt(s,d,k)
     {
 
     }
@@ -701,23 +701,23 @@ protected:
 /*!
  * Gep edge with a fixed offset
  */
-class NormalGepPE : public GepPE
+class NormalGepStmt : public GepStmt
 {
 private:
-    NormalGepPE(); ///< place holder
-    NormalGepPE(const NormalGepPE&); ///< place holder
-    void operator=(const NormalGepPE&); ///< place holder
+    NormalGepStmt(); ///< place holder
+    NormalGepStmt(const NormalGepStmt&); ///< place holder
+    void operator=(const NormalGepStmt&); ///< place holder
 
     LocationSet ls;	///< location set of the gep edge
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const NormalGepPE *)
+    static inline bool classof(const NormalGepStmt *)
     {
         return true;
     }
-    static inline bool classof(const GepPE *edge)
+    static inline bool classof(const GepStmt *edge)
     {
         return edge->getEdgeKind() == SVFStmt::NormalGep;
     }
@@ -732,7 +732,7 @@ public:
     //@}
 
     /// constructor
-    NormalGepPE(SVFVar* s, SVFVar* d, const LocationSet& l) : GepPE(s,d,SVFStmt::NormalGep), ls(l)
+    NormalGepStmt(SVFVar* s, SVFVar* d, const LocationSet& l) : GepStmt(s,d,SVFStmt::NormalGep), ls(l)
     {}
 
     /// offset of the gep edge
@@ -751,21 +751,21 @@ public:
 /*!
  * Gep edge with a variant offset
  */
-class VariantGepPE : public GepPE
+class VariantGepStmt : public GepStmt
 {
 private:
-    VariantGepPE(); ///< place holder
-    VariantGepPE(const VariantGepPE&); ///< place holder
-    void operator=(const VariantGepPE&); ///< place holder
+    VariantGepStmt(); ///< place holder
+    VariantGepStmt(const VariantGepStmt&); ///< place holder
+    void operator=(const VariantGepStmt&); ///< place holder
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const VariantGepPE *)
+    static inline bool classof(const VariantGepStmt *)
     {
         return true;
     }
-    static inline bool classof(const GepPE *edge)
+    static inline bool classof(const GepStmt *edge)
     {
         return edge->getEdgeKind() == SVFStmt::VariantGep;
     }
@@ -780,7 +780,7 @@ public:
     //@}
 
     /// constructor
-    VariantGepPE(SVFVar* s, SVFVar* d) : GepPE(s,d,SVFStmt::VariantGep) {}
+    VariantGepStmt(SVFVar* s, SVFVar* d) : GepStmt(s,d,SVFStmt::VariantGep) {}
 
     virtual const std::string toString() const override;
 

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

@@ -270,13 +270,13 @@ public:
 /*
  * Value(Pointer) node
  */
-class ValPN: public SVFVar
+class ValVar: public SVFVar
 {
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const ValPN *)
+    static inline bool classof(const ValVar *)
     {
         return true;
     }
@@ -295,7 +295,7 @@ public:
     //@}
 
     /// Constructor
-    ValPN(const Value* val, NodeID i, PNODEK ty = ValNode) :
+    ValVar(const Value* val, NodeID i, PNODEK ty = ValNode) :
         SVFVar(val, i, ty)
     {
     }
@@ -314,20 +314,20 @@ public:
 /*
  * Memory Object node
  */
-class ObjPN: public SVFVar
+class ObjVar: public SVFVar
 {
 
 protected:
     const MemObj* mem;	///< memory object
     /// Constructor
-    ObjPN(const Value* val, NodeID i, const MemObj* m, PNODEK ty = ObjNode) :
+    ObjVar(const Value* val, NodeID i, const MemObj* m, PNODEK ty = ObjNode) :
         SVFVar(val, i, ty), mem(m)
     {
     }
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const ObjPN *)
+    static inline bool classof(const ObjVar *)
     {
         return true;
     }
@@ -381,7 +381,7 @@ public:
  * e.g. memcpy, temp gep value node needs to be created
  * Each Gep Value node is connected to base value node via gep edge
  */
-class GepValPN: public ValPN
+class GepValVar: public ValVar
 {
 
 private:
@@ -392,11 +392,11 @@ private:
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const GepValPN *)
+    static inline bool classof(const GepValVar *)
     {
         return true;
     }
-    static inline bool classof(const ValPN * node)
+    static inline bool classof(const ValVar * node)
     {
         return node->getNodeKind() == SVFVar::GepValNode;
     }
@@ -411,8 +411,8 @@ public:
     //@}
 
     /// Constructor
-    GepValPN(const Value* val, NodeID i, const LocationSet& l, const Type *ty, u32_t idx) :
-        ValPN(val, i, GepValNode), ls(l), gepValType(ty), fieldIdx(idx)
+    GepValVar(const Value* val, NodeID i, const LocationSet& l, const Type *ty, u32_t idx) :
+        ValVar(val, i, GepValNode), ls(l), gepValType(ty), fieldIdx(idx)
     {
     }
 
@@ -448,7 +448,7 @@ public:
  * Gep Obj node, this is dynamic generated for field sensitive analysis
  * Each gep obj node is one field of a MemObj (base)
  */
-class GepObjPN: public ObjPN
+class GepObjPN: public ObjVar
 {
 private:
     LocationSet ls;
@@ -461,7 +461,7 @@ public:
     {
         return true;
     }
-    static inline bool classof(const ObjPN * node)
+    static inline bool classof(const ObjVar * node)
     {
         return node->getNodeKind() == SVFVar::GepObjNode
                || node->getNodeKind() == SVFVar::CloneGepObjNode;
@@ -480,7 +480,7 @@ public:
 
     /// Constructor
     GepObjPN(const MemObj* mem, NodeID i, const LocationSet& l, PNODEK ty = GepObjNode) :
-        ObjPN(mem->getValue(), i, mem, ty), ls(l)
+        ObjVar(mem->getValue(), i, mem, ty), ls(l)
     {
         base = mem->getId();
     }
@@ -524,17 +524,17 @@ public:
  * Field-insensitive Gep Obj node, this is dynamic generated for field sensitive analysis
  * Each field-insensitive gep obj node represents all fields of a MemObj (base)
  */
-class FIObjPN: public ObjPN
+class FIObjVar: public ObjVar
 {
 public:
 
     ///  Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const FIObjPN *)
+    static inline bool classof(const FIObjVar *)
     {
         return true;
     }
-    static inline bool classof(const ObjPN * node)
+    static inline bool classof(const ObjVar * node)
     {
         return node->getNodeKind() == SVFVar::FIObjNode
                || node->getNodeKind() == SVFVar::CloneFIObjNode;
@@ -552,8 +552,8 @@ public:
     //@}
 
     /// Constructor
-    FIObjPN(const Value* val, NodeID i, const MemObj* mem, PNODEK ty = FIObjNode) :
-        ObjPN(val, i, mem, ty)
+    FIObjVar(const Value* val, NodeID i, const MemObj* mem, PNODEK ty = FIObjNode) :
+        ObjVar(val, i, mem, ty)
     {
     }
 
@@ -651,13 +651,13 @@ public:
 /*
  * Dummy node
  */
-class DummyValPN: public ValPN
+class DummyValVar: public ValVar
 {
 
 public:
 
     //@{ Methods for support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const DummyValPN *)
+    static inline bool classof(const DummyValVar *)
     {
         return true;
     }
@@ -672,7 +672,7 @@ public:
     //@}
 
     /// Constructor
-    DummyValPN(NodeID i) : ValPN(nullptr, i, DummyValNode)
+    DummyValVar(NodeID i) : ValVar(nullptr, i, DummyValNode)
     {
     }
 
@@ -690,13 +690,13 @@ public:
 /*
  * Dummy node
  */
-class DummyObjPN: public ObjPN
+class DummyObjVar: public ObjVar
 {
 
 public:
 
     //@{ Methods for support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const DummyObjPN *)
+    static inline bool classof(const DummyObjVar *)
     {
         return true;
     }
@@ -713,8 +713,8 @@ public:
     //@}
 
     /// Constructor
-    DummyObjPN(NodeID i,const MemObj* m, PNODEK ty = DummyObjNode)
-        : ObjPN(nullptr, i, m, ty)
+    DummyObjVar(NodeID i,const MemObj* m, PNODEK ty = DummyObjNode)
+        : ObjVar(nullptr, i, m, ty)
     {
     }
 
@@ -730,11 +730,11 @@ public:
 /*
  * Clone object node for dummy objects.
  */
-class CloneDummyObjPN: public DummyObjPN
+class CloneDummyObjVar: public DummyObjVar
 {
 public:
     //@{ Methods to support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const CloneDummyObjPN *)
+    static inline bool classof(const CloneDummyObjVar *)
     {
         return true;
     }
@@ -749,15 +749,15 @@ public:
     //@}
 
     /// Constructor
-    CloneDummyObjPN(NodeID i, const MemObj* m, PNODEK ty = CloneDummyObjNode)
-        : DummyObjPN(i, m, ty)
+    CloneDummyObjVar(NodeID i, const MemObj* m, PNODEK ty = CloneDummyObjNode)
+        : DummyObjVar(i, m, ty)
     {
     }
 
     /// Return name of this node
     inline const std::string getValueName() const
     {
-        return "clone of " + ObjPN::getValueName();
+        return "clone of " + ObjVar::getValueName();
     }
 
     virtual const std::string toString() const;
@@ -766,11 +766,11 @@ public:
 /*
  * Clone object for GEP objects.
  */
-class CloneGepObjPN : public GepObjPN
+class CloneGepObjVar : public GepObjPN
 {
 public:
     //@{ Methods to support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const CloneGepObjPN *)
+    static inline bool classof(const CloneGepObjVar *)
     {
         return true;
     }
@@ -785,7 +785,7 @@ public:
     //@}
 
     /// Constructor
-    CloneGepObjPN(const MemObj* mem, NodeID i, const LocationSet& l, PNODEK ty = CloneGepObjNode) :
+    CloneGepObjVar(const MemObj* mem, NodeID i, const LocationSet& l, PNODEK ty = CloneGepObjNode) :
         GepObjPN(mem, i, l, ty)
     {
     }
@@ -802,11 +802,11 @@ public:
 /*
  * Clone object for FI objects.
  */
-class CloneFIObjPN : public FIObjPN
+class CloneFIObjVar : public FIObjVar
 {
 public:
     //@{ Methods to support type inquiry through isa, cast, and dyn_cast:
-    static inline bool classof(const CloneFIObjPN *)
+    static inline bool classof(const CloneFIObjVar *)
     {
         return true;
     }
@@ -821,15 +821,15 @@ public:
     //@}
 
     /// Constructor
-    CloneFIObjPN(const Value* val, NodeID i, const MemObj* mem, PNODEK ty = CloneFIObjNode) :
-        FIObjPN(val, i, mem, ty)
+    CloneFIObjVar(const Value* val, NodeID i, const MemObj* mem, PNODEK ty = CloneFIObjNode) :
+        FIObjVar(val, i, mem, ty)
     {
     }
 
     /// Return name of this node
     inline const std::string getValueName() const
     {
-        return "clone (FI) of " + FIObjPN::getValueName();
+        return "clone (FI) of " + FIObjVar::getValueName();
     }
 
     virtual const std::string toString() const;

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

@@ -281,44 +281,44 @@ public:
     }
 
     /// Add Address edge
-    inline AddrPE* addAddrEdge(NodeID src, NodeID dst)
+    inline AddrStmt* addAddrEdge(NodeID src, NodeID dst)
     {
-        AddrPE *edge = pag->addAddrPE(src, dst);
+        AddrStmt *edge = pag->addAddrPE(src, dst);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Copy edge
-    inline CopyPE* addCopyEdge(NodeID src, NodeID dst)
+    inline CopyStmt* addCopyEdge(NodeID src, NodeID dst)
     {
-        CopyPE *edge = pag->addCopyPE(src, dst);
+        CopyStmt *edge = pag->addCopyPE(src, dst);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Copy edge
-    inline PhiPE* addPhiNode(NodeID res, NodeID opnd)
+    inline PhiStmt* addPhiNode(NodeID res, NodeID opnd)
     {
-        PhiPE *edge = pag->addPhiNode(res,opnd);
+        PhiStmt *edge = pag->addPhiNode(res,opnd);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Copy edge
-    inline CmpPE* addCmpEdge(NodeID op1, NodeID op2, NodeID dst, u32_t opcode)
+    inline CmpStmt* addCmpEdge(NodeID op1, NodeID op2, NodeID dst, u32_t opcode)
     {
-        CmpPE *edge = pag->addCmpPE(op1, op2, dst, opcode);
+        CmpStmt *edge = pag->addCmpPE(op1, op2, dst, opcode);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Copy edge
-    inline BinaryOPPE* addBinaryOPEdge(NodeID op1, NodeID op2, NodeID dst, u32_t opcode)
+    inline BinaryOPStmt* addBinaryOPEdge(NodeID op1, NodeID op2, NodeID dst, u32_t opcode)
     {
-        BinaryOPPE *edge = pag->addBinaryOPPE(op1, op2, dst, opcode);
+        BinaryOPStmt *edge = pag->addBinaryOPPE(op1, op2, dst, opcode);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Unary edge
-    inline UnaryOPPE* addUnaryOPEdge(NodeID src, NodeID dst, u32_t opcode)
+    inline UnaryOPStmt* addUnaryOPEdge(NodeID src, NodeID dst, u32_t opcode)
     {
-        UnaryOPPE *edge = pag->addUnaryOPPE(src, dst, opcode);
+        UnaryOPStmt *edge = pag->addUnaryOPPE(src, dst, opcode);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
@@ -329,21 +329,21 @@ public:
         return edge;
     }
     /// Add Load edge
-    inline LoadPE* addLoadEdge(NodeID src, NodeID dst)
+    inline LoadStmt* addLoadEdge(NodeID src, NodeID dst)
     {
-        LoadPE *edge = pag->addLoadPE(src, dst);
+        LoadStmt *edge = pag->addLoadPE(src, dst);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Store edge
-    inline StorePE* addStoreEdge(NodeID src, NodeID dst)
+    inline StoreStmt* addStoreEdge(NodeID src, NodeID dst)
     {
         IntraBlockNode* node;
         if(const Instruction* inst = SVFUtil::dyn_cast<Instruction>(curVal))
             node = pag->getICFG()->getIntraBlockNode(inst);
         else
             node = nullptr;
-        StorePE *edge = pag->addStorePE(src, dst, node);
+        StoreStmt *edge = pag->addStorePE(src, dst, node);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
@@ -362,23 +362,23 @@ public:
         return edge;
     }
     /// Add Gep edge
-    inline GepPE* addGepEdge(NodeID src, NodeID dst, const LocationSet& ls, bool constGep)
+    inline GepStmt* addGepEdge(NodeID src, NodeID dst, const LocationSet& ls, bool constGep)
     {
-        GepPE *edge = pag->addGepPE(src, dst, ls, constGep);
+        GepStmt *edge = pag->addGepPE(src, dst, ls, constGep);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Offset(Gep) edge
-    inline NormalGepPE* addNormalGepEdge(NodeID src, NodeID dst, const LocationSet& ls)
+    inline NormalGepStmt* addNormalGepEdge(NodeID src, NodeID dst, const LocationSet& ls)
     {
-        NormalGepPE *edge = pag->addNormalGepPE(src, dst, ls);
+        NormalGepStmt *edge = pag->addNormalGepPE(src, dst, ls);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Variant(Gep) edge
-    inline VariantGepPE* addVariantGepEdge(NodeID src, NodeID dst)
+    inline VariantGepStmt* addVariantGepEdge(NodeID src, NodeID dst)
     {
-        VariantGepPE *edge = pag->addVariantGepPE(src, dst);
+        VariantGepStmt *edge = pag->addVariantGepPE(src, dst);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }

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

@@ -1,8 +1,8 @@
-//===----- CHG.h -- Base class of pointer analyses ---------------------------//
+//===----- CHG.h -- Class hirachary graph  ---------------------------//
 //
 //                     SVF: Static Value-Flow Analysis
 //
-// Copyright (C) <2013-2017>  <Yulei Sui>
+// Copyright (C) <2013->  <Yulei Sui>
 //
 
 // This program is free software: you can redistribute it and/or modify

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

@@ -103,8 +103,9 @@ protected:
         NodeID phiId = getDef(cs_ret);
         NodeID retdef = getDef(fun_ret);
         /// If a function does not have any return instruction. The def of a FormalRetVFGNode is itself (see VFG.h: addFormalRetVFGNode).
-        /// Therefore, we do not connect return edge from a function without any return instruction.
-        if (retdef == getFormalRetVFGNode(fun_ret)->getId())
+        /// Therefore, we do not connect return edge from a function without any return instruction (i.e., pag->isPhiNode(fun_ret)==false)
+        /// because unique fun_ret PAGNode was not collected as a PhiNode in SVFIRBuilder::visitReturnInst
+        if (pag->isPhiNode(fun_ret)==false)
             return;
 
         SVFGEdge* edge = addRetEdge(retdef, phiId, csId);

package/package.json

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