svf-lib 1.0.741 → 1.0.745

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