svf-tools 1.0.321 → 1.0.325

package/lib/Graphs/VFG.cpp

@@ -336,56 +336,56 @@ void VFG::addVFGNodes()
     addNullPtrVFGNode(pag->getGNode(pag->getNullPtr()));
 
     // initialize address nodes
-    PAGEdge::PAGEdgeSetTy& addrs = getPAGEdgeSet(PAGEdge::Addr);
-    for (PAGEdge::PAGEdgeSetTy::iterator iter = addrs.begin(), eiter =
+    PAGEdge::SVFStmtSetTy& addrs = getPAGEdgeSet(PAGEdge::Addr);
+    for (PAGEdge::SVFStmtSetTy::iterator iter = addrs.begin(), eiter =
                 addrs.end(); iter != eiter; ++iter)
     {
-        addAddrVFGNode(SVFUtil::cast<AddrPE>(*iter));
+        addAddrVFGNode(SVFUtil::cast<AddrStmt>(*iter));
     }
 
     // initialize copy nodes
-    PAGEdge::PAGEdgeSetTy& copys = getPAGEdgeSet(PAGEdge::Copy);
-    for (PAGEdge::PAGEdgeSetTy::iterator iter = copys.begin(), eiter =
+    PAGEdge::SVFStmtSetTy& copys = getPAGEdgeSet(PAGEdge::Copy);
+    for (PAGEdge::SVFStmtSetTy::iterator iter = copys.begin(), eiter =
                 copys.end(); iter != eiter; ++iter)
     {
-        const CopyPE* edge = SVFUtil::cast<CopyPE>(*iter);
+        const CopyStmt* edge = SVFUtil::cast<CopyStmt>(*iter);
         assert(!isPhiCopyEdge(edge) && "Copy edges can not be a PhiNode (or from PhiNode)");
         addCopyVFGNode(edge);
     }
 
     // initialize gep nodes
-    PAGEdge::PAGEdgeSetTy& ngeps = getPAGEdgeSet(PAGEdge::NormalGep);
-    for (PAGEdge::PAGEdgeSetTy::iterator iter = ngeps.begin(), eiter =
+    PAGEdge::SVFStmtSetTy& ngeps = getPAGEdgeSet(PAGEdge::NormalGep);
+    for (PAGEdge::SVFStmtSetTy::iterator iter = ngeps.begin(), eiter =
                 ngeps.end(); iter != eiter; ++iter)
     {
-        addGepVFGNode(SVFUtil::cast<NormalGepPE>(*iter));
+        addGepVFGNode(SVFUtil::cast<NormalGepStmt>(*iter));
     }
 
-    PAGEdge::PAGEdgeSetTy& vgeps = getPAGEdgeSet(PAGEdge::VariantGep);
-    for (PAGEdge::PAGEdgeSetTy::iterator iter = vgeps.begin(), eiter =
+    PAGEdge::SVFStmtSetTy& vgeps = getPAGEdgeSet(PAGEdge::VariantGep);
+    for (PAGEdge::SVFStmtSetTy::iterator iter = vgeps.begin(), eiter =
                 vgeps.end(); iter != eiter; ++iter)
     {
-        addGepVFGNode(SVFUtil::cast<VariantGepPE>(*iter));
+        addGepVFGNode(SVFUtil::cast<VariantGepStmt>(*iter));
     }
 
     // initialize load nodes
-    PAGEdge::PAGEdgeSetTy& loads = getPAGEdgeSet(PAGEdge::Load);
-    for (PAGEdge::PAGEdgeSetTy::iterator iter = loads.begin(), eiter =
+    PAGEdge::SVFStmtSetTy& loads = getPAGEdgeSet(PAGEdge::Load);
+    for (PAGEdge::SVFStmtSetTy::iterator iter = loads.begin(), eiter =
                 loads.end(); iter != eiter; ++iter)
     {
-        addLoadVFGNode(SVFUtil::cast<LoadPE>(*iter));
+        addLoadVFGNode(SVFUtil::cast<LoadStmt>(*iter));
     }
 
     // initialize store nodes
-    PAGEdge::PAGEdgeSetTy& stores = getPAGEdgeSet(PAGEdge::Store);
-    for (PAGEdge::PAGEdgeSetTy::iterator iter = stores.begin(), eiter =
+    PAGEdge::SVFStmtSetTy& stores = getPAGEdgeSet(PAGEdge::Store);
+    for (PAGEdge::SVFStmtSetTy::iterator iter = stores.begin(), eiter =
                 stores.end(); iter != eiter; ++iter)
     {
-        addStoreVFGNode(SVFUtil::cast<StorePE>(*iter));
+        addStoreVFGNode(SVFUtil::cast<StoreStmt>(*iter));
     }
 
-    PAGEdge::PAGEdgeSetTy& forks = getPAGEdgeSet(PAGEdge::ThreadFork);
-    for (PAGEdge::PAGEdgeSetTy::iterator iter = forks.begin(), eiter =
+    PAGEdge::SVFStmtSetTy& forks = getPAGEdgeSet(PAGEdge::ThreadFork);
+    for (PAGEdge::SVFStmtSetTy::iterator iter = forks.begin(), eiter =
                 forks.end(); iter != eiter; ++iter)
     {
         TDForkPE* forkedge = SVFUtil::cast<TDForkPE>(*iter);
@@ -396,7 +396,7 @@ void VFG::addVFGNodes()
     for(SVFIR::CSToArgsListMap::iterator it = pag->getCallSiteArgsMap().begin(), eit = pag->getCallSiteArgsMap().end(); it !=eit; ++it)
     {
 
-        for(SVFIR::PAGNodeList::iterator pit = it->second.begin(), epit = it->second.end(); pit!=epit; ++pit)
+        for(SVFIR::SVFVarList::iterator pit = it->second.begin(), epit = it->second.end(); pit!=epit; ++pit)
         {
             const PAGNode* pagNode = *pit;
             if (isInterestedPAGNode(pagNode))
@@ -422,7 +422,7 @@ void VFG::addVFGNodes()
     {
         const SVFFunction* func = it->first;
 
-        for(SVFIR::PAGNodeList::iterator pit = it->second.begin(), epit = it->second.end(); pit!=epit; ++pit)
+        for(SVFIR::SVFVarList::iterator pit = it->second.begin(), epit = it->second.end(); pit!=epit; ++pit)
         {
             const PAGNode* param = *pit;
             if (isInterestedPAGNode(param) == false || hasBlackHoleConstObjAddrAsDef(param))
@@ -431,7 +431,7 @@ void VFG::addVFGNodes()
             CallPESet callPEs;
             if (param->hasIncomingEdges(PAGEdge::Call))
             {
-                for (PAGEdge::PAGEdgeSetTy::const_iterator cit = param->getIncomingEdgesBegin(PAGEdge::Call), ecit =
+                for (PAGEdge::SVFStmtSetTy::const_iterator cit = param->getIncomingEdgesBegin(PAGEdge::Call), ecit =
                             param->getIncomingEdgesEnd(PAGEdge::Call); cit != ecit; ++cit)
                 {
                     CallPE* callPE = SVFUtil::cast<CallPE>(*cit);
@@ -451,7 +451,7 @@ void VFG::addVFGNodes()
             CallPESet callPEs;
             if (varParam->hasIncomingEdges(PAGEdge::Call))
             {
-                for(PAGEdge::PAGEdgeSetTy::const_iterator cit = varParam->getIncomingEdgesBegin(PAGEdge::Call),
+                for(PAGEdge::SVFStmtSetTy::const_iterator cit = varParam->getIncomingEdgesBegin(PAGEdge::Call),
                         ecit = varParam->getIncomingEdgesEnd(PAGEdge::Call); cit!=ecit; ++cit)
                 {
                     CallPE* callPE = SVFUtil::cast<CallPE>(*cit);
@@ -473,7 +473,7 @@ void VFG::addVFGNodes()
         RetPESet retPEs;
         if (uniqueFunRetNode->hasOutgoingEdges(PAGEdge::Ret))
         {
-            for (PAGEdge::PAGEdgeSetTy::const_iterator cit = uniqueFunRetNode->getOutgoingEdgesBegin(PAGEdge::Ret),
+            for (PAGEdge::SVFStmtSetTy::const_iterator cit = uniqueFunRetNode->getOutgoingEdgesBegin(PAGEdge::Ret),
                     ecit = uniqueFunRetNode->getOutgoingEdgesEnd(PAGEdge::Ret);
                     cit != ecit; ++cit)
             {
@@ -488,35 +488,35 @@ void VFG::addVFGNodes()
     }
 
     // initialize llvm phi nodes (phi of top level pointers)
-    PAGEdge::PAGEdgeSetTy& phis = getPAGEdgeSet(PAGEdge::Phi);
-    for (PAGEdge::PAGEdgeSetTy::iterator iter = phis.begin(), eiter =
+    PAGEdge::SVFStmtSetTy& phis = getPAGEdgeSet(PAGEdge::Phi);
+    for (PAGEdge::SVFStmtSetTy::iterator iter = phis.begin(), eiter =
                 phis.end(); iter != eiter; ++iter)
     {
-        const PhiPE* edge = SVFUtil::cast<PhiPE>(*iter);
+        const PhiStmt* edge = SVFUtil::cast<PhiStmt>(*iter);
         if(isInterestedPAGNode(edge->getRes()))
             addIntraPHIVFGNode(edge);
     }
     // initialize llvm binary nodes (binary operators)
-    PAGEdge::PAGEdgeSetTy& binaryops = getPAGEdgeSet(PAGEdge::BinaryOp);
-    for (PAGEdge::PAGEdgeSetTy::iterator iter = binaryops.begin(), eiter =
+    PAGEdge::SVFStmtSetTy& binaryops = getPAGEdgeSet(PAGEdge::BinaryOp);
+    for (PAGEdge::SVFStmtSetTy::iterator iter = binaryops.begin(), eiter =
                 binaryops.end(); iter != eiter; ++iter)
     {
-        const BinaryOPPE* edge = SVFUtil::cast<BinaryOPPE>(*iter);
+        const BinaryOPStmt* edge = SVFUtil::cast<BinaryOPStmt>(*iter);
         if(isInterestedPAGNode(edge->getRes()))
             addBinaryOPVFGNode(edge);
     }
     // initialize llvm unary nodes (unary operators)
-    PAGEdge::PAGEdgeSetTy& unaryops = getPAGEdgeSet(PAGEdge::UnaryOp);
-    for (PAGEdge::PAGEdgeSetTy::iterator iter = unaryops.begin(), eiter =
+    PAGEdge::SVFStmtSetTy& unaryops = getPAGEdgeSet(PAGEdge::UnaryOp);
+    for (PAGEdge::SVFStmtSetTy::iterator iter = unaryops.begin(), eiter =
                 unaryops.end(); iter != eiter; ++iter)
     {
-        const UnaryOPPE* edge = SVFUtil::cast<UnaryOPPE>(*iter);
+        const UnaryOPStmt* edge = SVFUtil::cast<UnaryOPStmt>(*iter);
         if(isInterestedPAGNode(edge->getRes()))
             addUnaryOPVFGNode(edge);
     }
     // initialize llvm unary nodes (unary operators)
-    PAGEdge::PAGEdgeSetTy& brs = getPAGEdgeSet(PAGEdge::Branch);
-    for (PAGEdge::PAGEdgeSetTy::iterator iter = brs.begin(), eiter =
+    PAGEdge::SVFStmtSetTy& brs = getPAGEdgeSet(PAGEdge::Branch);
+    for (PAGEdge::SVFStmtSetTy::iterator iter = brs.begin(), eiter =
                 brs.end(); iter != eiter; ++iter)
     {
         const BranchStmt* edge = SVFUtil::cast<BranchStmt>(*iter);
@@ -524,11 +524,11 @@ void VFG::addVFGNodes()
             addBranchVFGNode(edge);
     }
     // initialize llvm cmp nodes (comparision)
-    PAGEdge::PAGEdgeSetTy& cmps = getPAGEdgeSet(PAGEdge::Cmp);
-    for (PAGEdge::PAGEdgeSetTy::iterator iter = cmps.begin(), eiter =
+    PAGEdge::SVFStmtSetTy& cmps = getPAGEdgeSet(PAGEdge::Cmp);
+    for (PAGEdge::SVFStmtSetTy::iterator iter = cmps.begin(), eiter =
                 cmps.end(); iter != eiter; ++iter)
     {
-        const CmpPE* edge = SVFUtil::cast<CmpPE>(*iter);
+        const CmpStmt* edge = SVFUtil::cast<CmpStmt>(*iter);
         if(isInterestedPAGNode(edge->getRes()))
             addCmpVFGNode(edge);
     }
@@ -692,8 +692,8 @@ void VFG::connectDirectVFGEdges()
     /// connect direct value-flow edges (parameter passing) for thread fork/join
     if(Options::EnableThreadCallGraph){
         /// add fork edge
-        PAGEdge::PAGEdgeSetTy& forks = getPAGEdgeSet(PAGEdge::ThreadFork);
-        for (PAGEdge::PAGEdgeSetTy::iterator iter = forks.begin(), eiter =
+        PAGEdge::SVFStmtSetTy& forks = getPAGEdgeSet(PAGEdge::ThreadFork);
+        for (PAGEdge::SVFStmtSetTy::iterator iter = forks.begin(), eiter =
                 forks.end(); iter != eiter; ++iter)
         {
             TDForkPE* forkedge = SVFUtil::cast<TDForkPE>(*iter);
@@ -702,8 +702,8 @@ void VFG::connectDirectVFGEdges()
             addInterEdgeFromAPToFP(acutalParm,formalParm,getCallSiteID(forkedge->getCallSite(), formalParm->getFun()));
         }
         /// add join edge
-        PAGEdge::PAGEdgeSetTy& joins = getPAGEdgeSet(PAGEdge::ThreadJoin);
-        for (PAGEdge::PAGEdgeSetTy::iterator iter = joins.begin(), eiter =
+        PAGEdge::SVFStmtSetTy& joins = getPAGEdgeSet(PAGEdge::ThreadJoin);
+        for (PAGEdge::SVFStmtSetTy::iterator iter = joins.begin(), eiter =
                 joins.end(); iter != eiter; ++iter)
         {
             TDJoinPE* joinedge = SVFUtil::cast<TDJoinPE>(*iter);
@@ -824,10 +824,10 @@ void VFG::connectCallerAndCallee(const CallBlockNode* callBlockNode, const SVFFu
     // connect actual and formal param
     if (pag->hasCallSiteArgsMap(callBlockNode) && pag->hasFunArgsList(callee))
     {
-        const SVFIR::PAGNodeList& csArgList = pag->getCallSiteArgsList(callBlockNode);
-        const SVFIR::PAGNodeList& funArgList = pag->getFunArgsList(callee);
-        SVFIR::PAGNodeList::const_iterator csArgIt = csArgList.begin(), csArgEit = csArgList.end();
-        SVFIR::PAGNodeList::const_iterator funArgIt = funArgList.begin(), funArgEit = funArgList.end();
+        const SVFIR::SVFVarList& csArgList = pag->getCallSiteArgsList(callBlockNode);
+        const SVFIR::SVFVarList& funArgList = pag->getFunArgsList(callee);
+        SVFIR::SVFVarList::const_iterator csArgIt = csArgList.begin(), csArgEit = csArgList.end();
+        SVFIR::SVFVarList::const_iterator funArgIt = funArgList.begin(), funArgEit = funArgList.end();
         for (; funArgIt != funArgEit && csArgIt != csArgEit; funArgIt++, csArgIt++)
         {
             const PAGNode *cs_arg = *csArgIt;
@@ -1081,11 +1081,11 @@ struct DOTGraphTraits<VFG*> : public DOTGraphTraits<SVFIR*>
         if(StmtVFGNode* stmtNode = SVFUtil::dyn_cast<StmtVFGNode>(node))
         {
             const PAGEdge* edge = stmtNode->getPAGEdge();
-            if (SVFUtil::isa<AddrPE>(edge))
+            if (SVFUtil::isa<AddrStmt>(edge))
             {
                 rawstr <<  "color=green";
             }
-            else if (SVFUtil::isa<CopyPE>(edge))
+            else if (SVFUtil::isa<CopyStmt>(edge))
             {
                 rawstr <<  "color=black";
             }
@@ -1093,15 +1093,15 @@ struct DOTGraphTraits<VFG*> : public DOTGraphTraits<SVFIR*>
             {
                 rawstr <<  "color=black,style=dotted";
             }
-            else if (SVFUtil::isa<GepPE>(edge))
+            else if (SVFUtil::isa<GepStmt>(edge))
             {
                 rawstr <<  "color=purple";
             }
-            else if (SVFUtil::isa<StorePE>(edge))
+            else if (SVFUtil::isa<StoreStmt>(edge))
             {
                 rawstr <<  "color=blue";
             }
-            else if (SVFUtil::isa<LoadPE>(edge))
+            else if (SVFUtil::isa<LoadStmt>(edge))
             {
                 rawstr << "color=red";
             }

package/lib/MSSA/MemRegion.cpp

@@ -107,7 +107,7 @@ void MRGenerator::collectGlobals()
     SVFIR* pag = pta->getPAG();
     for (SVFIR::iterator nIter = pag->begin(); nIter != pag->end(); ++nIter)
     {
-        if(ObjPN* obj = SVFUtil::dyn_cast<ObjPN>(nIter->second))
+        if(ObjVar* obj = SVFUtil::dyn_cast<ObjVar>(nIter->second))
         {
             if (obj->getMemObj()->isGlobalObj())
             {
@@ -148,22 +148,22 @@ void MRGenerator::generateMRs()
     updateAliasMRs();
 }
 
-bool MRGenerator::hasPAGEdgeList(const Instruction* inst)
+bool MRGenerator::hasSVFStmtList(const Instruction* inst)
 {
     SVFIR* pag = pta->getPAG();
     if (ptrOnlyMSSA)
-        return pag->hasPTAPAGEdgeList(pag->getICFG()->getBlockICFGNode(inst));
+        return pag->hasPTASVFStmtList(pag->getICFG()->getBlockICFGNode(inst));
     else
-        return pag->hasPAGEdgeList(pag->getICFG()->getBlockICFGNode(inst));
+        return pag->hasSVFStmtList(pag->getICFG()->getBlockICFGNode(inst));
 }
 
-SVFIR::PAGEdgeList& MRGenerator::getPAGEdgesFromInst(const Instruction* inst)
+SVFIR::SVFStmtList& MRGenerator::getPAGEdgesFromInst(const Instruction* inst)
 {
     SVFIR* pag = pta->getPAG();
     if (ptrOnlyMSSA)
-        return pag->getInstPTAPAGEdgeList(pag->getICFG()->getBlockICFGNode(inst));
+        return pag->getPTASVFStmtList(pag->getICFG()->getBlockICFGNode(inst));
     else
-        return pag->getInstPAGEdgeList(pag->getICFG()->getBlockICFGNode(inst));
+        return pag->getSVFStmtList(pag->getICFG()->getBlockICFGNode(inst));
 }
 
 /*!
@@ -190,13 +190,13 @@ void MRGenerator::collectModRefForLoadStore()
                     bit != ebit; ++bit)
             {
                 const Instruction& inst = *bit;
-                PAGEdgeList& pagEdgeList = getPAGEdgesFromInst(&inst);
-                for (PAGEdgeList::iterator bit = pagEdgeList.begin(), ebit =
+                SVFStmtList& pagEdgeList = getPAGEdgesFromInst(&inst);
+                for (SVFStmtList::iterator bit = pagEdgeList.begin(), ebit =
                             pagEdgeList.end(); bit != ebit; ++bit)
                 {
                     const PAGEdge* inst = *bit;
                     pagEdgeToFunMap[inst] = &fun;
-                    if (const StorePE *st = SVFUtil::dyn_cast<StorePE>(inst))
+                    if (const StoreStmt *st = SVFUtil::dyn_cast<StoreStmt>(inst))
                     {
                         NodeBS cpts(pta->getPts(st->getDstID()).toNodeBS());
                         // TODO: change this assertion check later when we have conditional points-to set
@@ -206,7 +206,7 @@ void MRGenerator::collectModRefForLoadStore()
                         addCPtsToStore(cpts, st, &fun);
                     }
 
-                    else if (const LoadPE *ld = SVFUtil::dyn_cast<LoadPE>(inst))
+                    else if (const LoadStmt *ld = SVFUtil::dyn_cast<LoadStmt>(inst))
                     {
                         NodeBS cpts(pta->getPts(ld->getSrcID()).toNodeBS());
                         // TODO: change this assertion check later when we have conditional points-to set
@@ -487,8 +487,8 @@ void MRGenerator::collectCallSitePts(const CallBlockNode* cs)
     WorkList worklist;
     if (pag->hasCallSiteArgsMap(callBlockNode))
     {
-        const SVFIR::PAGNodeList& args = pta->getPAG()->getCallSiteArgsList(callBlockNode);
-        for(SVFIR::PAGNodeList::const_iterator itA = args.begin(), ieA = args.end(); itA!=ieA; ++itA)
+        const SVFIR::SVFVarList& args = pta->getPAG()->getCallSiteArgsList(callBlockNode);
+        for(SVFIR::SVFVarList::const_iterator itA = args.begin(), ieA = args.end(); itA!=ieA; ++itA)
         {
             const PAGNode* node = *itA;
             if(node->isPointer())
@@ -526,7 +526,7 @@ void MRGenerator::collectCallSitePts(const CallBlockNode* cs)
  */
 NodeBS& MRGenerator::CollectPtsChain(NodeID id)
 {
-    NodeID baseId = pta->getPAG()->getBaseObjNode(id);
+    NodeID baseId = pta->getPAG()->getBaseObjVar(id);
     NodeToPTSSMap::iterator it = cachedPtsChainMap.find(baseId);
     if(it!=cachedPtsChainMap.end())
         return it->second;
@@ -605,12 +605,12 @@ bool MRGenerator::handleCallsiteModRef(NodeBS& mod, NodeBS& ref, const CallBlock
     /// if a callee is a heap allocator function, then its mod set of this callsite is the heap object.
     if(isHeapAllocExtCall(cs->getCallSite()))
     {
-        PAGEdgeList& pagEdgeList = getPAGEdgesFromInst(cs->getCallSite());
-        for (PAGEdgeList::const_iterator bit = pagEdgeList.begin(),
+        SVFStmtList& pagEdgeList = getPAGEdgesFromInst(cs->getCallSite());
+        for (SVFStmtList::const_iterator bit = pagEdgeList.begin(),
                 ebit = pagEdgeList.end(); bit != ebit; ++bit)
         {
             const PAGEdge* edge = *bit;
-            if (const AddrPE* addr = SVFUtil::dyn_cast<AddrPE>(edge))
+            if (const AddrStmt* addr = SVFUtil::dyn_cast<AddrStmt>(edge))
                 mod.set(addr->getSrcID());
         }
     }
@@ -671,13 +671,13 @@ NodeBS MRGenerator::getModInfoForCall(const CallBlockNode* cs)
 {
     if (isExtCall(cs->getCallSite()) && !isHeapAllocExtCall(cs->getCallSite()))
     {
-        PAGEdgeList& pagEdgeList = getPAGEdgesFromInst(cs->getCallSite());
+        SVFStmtList& pagEdgeList = getPAGEdgesFromInst(cs->getCallSite());
         NodeBS mods;
-        for (PAGEdgeList::const_iterator bit = pagEdgeList.begin(), ebit =
+        for (SVFStmtList::const_iterator bit = pagEdgeList.begin(), ebit =
                     pagEdgeList.end(); bit != ebit; ++bit)
         {
             const PAGEdge* edge = *bit;
-            if (const StorePE* st = SVFUtil::dyn_cast<StorePE>(edge))
+            if (const StoreStmt* st = SVFUtil::dyn_cast<StoreStmt>(edge))
                 mods |= pta->getPts(st->getDstID()).toNodeBS();
         }
         return mods;
@@ -695,13 +695,13 @@ NodeBS MRGenerator::getRefInfoForCall(const CallBlockNode* cs)
 {
     if (isExtCall(cs->getCallSite()) && !isHeapAllocExtCall(cs->getCallSite()))
     {
-        PAGEdgeList& pagEdgeList = getPAGEdgesFromInst(cs->getCallSite());
+        SVFStmtList& pagEdgeList = getPAGEdgesFromInst(cs->getCallSite());
         NodeBS refs;
-        for (PAGEdgeList::const_iterator bit = pagEdgeList.begin(), ebit =
+        for (SVFStmtList::const_iterator bit = pagEdgeList.begin(), ebit =
                     pagEdgeList.end(); bit != ebit; ++bit)
         {
             const PAGEdge* edge = *bit;
-            if (const LoadPE* ld = SVFUtil::dyn_cast<LoadPE>(edge))
+            if (const LoadStmt* ld = SVFUtil::dyn_cast<LoadStmt>(edge))
                 refs |= pta->getPts(ld->getSrcID()).toNodeBS();
         }
         return refs;

package/lib/MSSA/MemSSA.cpp

@@ -159,16 +159,16 @@ void MemSSA::createMUCHI(const SVFFunction& fun)
                 it != eit; ++it)
         {
             const Instruction* inst = &*it;
-            if(mrGen->hasPAGEdgeList(inst))
+            if(mrGen->hasSVFStmtList(inst))
             {
-                PAGEdgeList& pagEdgeList = mrGen->getPAGEdgesFromInst(inst);
-                for (PAGEdgeList::const_iterator bit = pagEdgeList.begin(),
+                SVFStmtList& pagEdgeList = mrGen->getPAGEdgesFromInst(inst);
+                for (SVFStmtList::const_iterator bit = pagEdgeList.begin(),
                         ebit = pagEdgeList.end(); bit != ebit; ++bit)
                 {
                     const PAGEdge* inst = *bit;
-                    if (const LoadPE* load = SVFUtil::dyn_cast<LoadPE>(inst))
+                    if (const LoadStmt* load = SVFUtil::dyn_cast<LoadStmt>(inst))
                         AddLoadMU(bb, load, mrGen->getLoadMRSet(load));
-                    else if (const StorePE* store = SVFUtil::dyn_cast<StorePE>(inst))
+                    else if (const StoreStmt* store = SVFUtil::dyn_cast<StoreStmt>(inst))
                         AddStoreCHI(bb, store, mrGen->getStoreMRSet(store));
                 }
             }
@@ -301,17 +301,17 @@ void MemSSA::SSARenameBB(const BasicBlock& bb)
             it != eit; ++it)
     {
         const Instruction* inst = &*it;
-        if(mrGen->hasPAGEdgeList(inst))
+        if(mrGen->hasSVFStmtList(inst))
         {
-            PAGEdgeList& pagEdgeList = mrGen->getPAGEdgesFromInst(inst);
-            for(PAGEdgeList::const_iterator bit = pagEdgeList.begin(), ebit= pagEdgeList.end();
+            SVFStmtList& pagEdgeList = mrGen->getPAGEdgesFromInst(inst);
+            for(SVFStmtList::const_iterator bit = pagEdgeList.begin(), ebit= pagEdgeList.end();
                     bit!=ebit; ++bit)
             {
                 const PAGEdge* inst = *bit;
-                if (const LoadPE* load = SVFUtil::dyn_cast<LoadPE>(inst))
+                if (const LoadStmt* load = SVFUtil::dyn_cast<LoadStmt>(inst))
                     RenameMuSet(getMUSet(load));
 
-                else if (const StorePE* store = SVFUtil::dyn_cast<StorePE>(inst))
+                else if (const StoreStmt* store = SVFUtil::dyn_cast<StoreStmt>(inst))
                     RenameChiSet(getCHISet(store),memRegs);
 
             }
@@ -666,12 +666,12 @@ void MemSSA::dumpMSSA(raw_ostream& Out)
                 else
                 {
                     bool dump_preamble = false;
-                    PAGEdgeList& pagEdgeList = mrGen->getPAGEdgesFromInst(&inst);
-                    for(PAGEdgeList::const_iterator bit = pagEdgeList.begin(), ebit= pagEdgeList.end();
+                    SVFStmtList& pagEdgeList = mrGen->getPAGEdgesFromInst(&inst);
+                    for(SVFStmtList::const_iterator bit = pagEdgeList.begin(), ebit= pagEdgeList.end();
                             bit!=ebit; ++bit)
                     {
                         const PAGEdge* edge = *bit;
-                        if (const LoadPE* load = SVFUtil::dyn_cast<LoadPE>(edge))
+                        if (const LoadStmt* load = SVFUtil::dyn_cast<LoadStmt>(edge))
                         {
                             MUSet& muSet = getMUSet(load);
                             for(MUSet::iterator it = muSet.begin(), eit = muSet.end(); it!=eit; ++it)
@@ -689,11 +689,11 @@ void MemSSA::dumpMSSA(raw_ostream& Out)
                     Out << inst << "\n";
 
                     bool has_chi = false;
-                    for(PAGEdgeList::const_iterator bit = pagEdgeList.begin(), ebit= pagEdgeList.end();
+                    for(SVFStmtList::const_iterator bit = pagEdgeList.begin(), ebit= pagEdgeList.end();
                             bit!=ebit; ++bit)
                     {
                         const PAGEdge* edge = *bit;
-                        if (const StorePE* store = SVFUtil::dyn_cast<StorePE>(edge))
+                        if (const StoreStmt* store = SVFUtil::dyn_cast<StoreStmt>(edge))
                         {
                             CHISet& chiSet = getCHISet(store);
                             for(CHISet::iterator it = chiSet.begin(), eit = chiSet.end(); it!=eit; ++it)

package/lib/MTA/MTAAnnotator.cpp

@@ -122,8 +122,8 @@ void MTAAnnotator::pruneThreadLocal(PointerAnalysis* pta)
     PointsTo worklist;
 
     /// find fork arguments' objects
-    const PAGEdge::PAGEdgeSetTy& forkedges = pag->getPTAEdgeSet(PAGEdge::ThreadFork);
-    for (PAGEdge::PAGEdgeSetTy::const_iterator it = forkedges.begin(), eit = forkedges.end(); it != eit; ++it)
+    const PAGEdge::SVFStmtSetTy& forkedges = pag->getPTASVFStmtSet(PAGEdge::ThreadFork);
+    for (PAGEdge::SVFStmtSetTy::const_iterator it = forkedges.begin(), eit = forkedges.end(); it != eit; ++it)
     {
         PAGEdge* edge = *it;
         worklist |= pta->getPts(edge->getDstID());
@@ -131,8 +131,8 @@ void MTAAnnotator::pruneThreadLocal(PointerAnalysis* pta)
     }
 
     /// find global pointer-to objects
-    const SVFIR::PAGEdgeSet& globaledges = pag->getGlobalPAGEdgeSet();
-    for (SVFIR::PAGEdgeSet::const_iterator it = globaledges.begin(), eit = globaledges.end(); it != eit; ++it)
+    const SVFIR::SVFStmtSet& globaledges = pag->getGlobalSVFStmtSet();
+    for (SVFIR::SVFStmtSet::const_iterator it = globaledges.begin(), eit = globaledges.end(); it != eit; ++it)
     {
         const PAGEdge* edge = *it;
         if (edge->getEdgeKind() == PAGEdge::Addr)
@@ -153,7 +153,7 @@ void MTAAnnotator::pruneThreadLocal(PointerAnalysis* pta)
             if (!nonlocalobjs.test(*pit))
                 worklist.set(*pit);
         }
-        NodeBS fields = pag->getAllFieldsObjNode(obj);
+        NodeBS fields = pag->getAllFieldsObjVars(obj);
         for (NodeBS::iterator pit = fields.begin(), epit = fields.end(); pit != epit; ++pit)
         {
             if (!nonlocalobjs.test(*pit))

package/lib/MemoryModel/PAGBuilderFromFile.cpp

@@ -152,38 +152,38 @@ void PAGBuilderFromFile::addEdge(NodeID srcID, NodeID dstID,
     PAGNode* dstNode = pag->getGNode(dstID);
 
     /// sanity check for SVFIR from txt
-    assert(SVFUtil::isa<ValPN>(dstNode) && "dst not an value node?");
+    assert(SVFUtil::isa<ValVar>(dstNode) && "dst not an value node?");
     if(edge=="addr")
-        assert(SVFUtil::isa<ObjPN>(srcNode) && "src not an value node?");
+        assert(SVFUtil::isa<ObjVar>(srcNode) && "src not an value node?");
     else
-        assert(!SVFUtil::isa<ObjPN>(srcNode) && "src not an object node?");
+        assert(!SVFUtil::isa<ObjVar>(srcNode) && "src not an object node?");
 
     if (edge == "addr")
     {
-        pag->addAddrPE(srcID, dstID);
+        pag->addAddrStmt(srcID, dstID);
     }
     else if (edge == "copy")
-        pag->addCopyPE(srcID, dstID);
+        pag->addCopyStmt(srcID, dstID);
     else if (edge == "load")
-        pag->addLoadPE(srcID, dstID);
+        pag->addLoadStmt(srcID, dstID);
     else if (edge == "store")
-        pag->addStorePE(srcID, dstID, nullptr);
+        pag->addStoreStmt(srcID, dstID, nullptr);
     else if (edge == "gep")
-        pag->addNormalGepPE(srcID, dstID, LocationSet(offsetOrCSId));
+        pag->addNormalGepStmt(srcID, dstID, LocationSet(offsetOrCSId));
     else if (edge == "variant-gep")
-        pag->addVariantGepPE(srcID, dstID);
+        pag->addVariantGepStmt(srcID, dstID);
     else if (edge == "call")
         pag->addEdge(srcNode, dstNode, new CallPE(srcNode, dstNode, nullptr));
     else if (edge == "ret")
         pag->addEdge(srcNode, dstNode, new RetPE(srcNode, dstNode, nullptr));
     else if (edge == "cmp")
-        pag->addCmpPE(srcID, dstID, dstID, dstID);
+        pag->addCmpStmt(srcID, dstID, dstID, dstID);
     else if (edge == "binary-op")
-        pag->addBinaryOPPE(srcID, dstID, dstID, dstID);
+        pag->addBinaryOPStmt(srcID, dstID, dstID, dstID);
     else if (edge == "unary-op")
-        pag->addUnaryOPPE(srcID, dstID, dstID);
+        pag->addUnaryOPStmt(srcID, dstID, dstID);
     else if (edge == "phi")
-        pag->addPhiNode(srcID, dstID);
+        pag->addPhiStmt(srcID, dstID);
     else if (edge == "branch"){
         assert(false && "fix successors here!");
         //pag->addBranchStmt(srcID, dstID, nullptr);

package/lib/MemoryModel/PointerAnalysis.cpp

@@ -185,7 +185,7 @@ void PointerAnalysis::resetObjFieldSensitive()
 {
     for (SVFIR::iterator nIter = pag->begin(); nIter != pag->end(); ++nIter)
     {
-        if(ObjPN* node = SVFUtil::dyn_cast<ObjPN>(nIter->second))
+        if(ObjVar* node = SVFUtil::dyn_cast<ObjVar>(nIter->second))
             const_cast<MemObj*>(node->getMemObj())->setFieldSensitive();
     }
 }
@@ -290,7 +290,7 @@ void PointerAnalysis::dumpAllTypes()
             nIter != this->getAllValidPtrs().end(); ++nIter)
     {
         const PAGNode* node = getPAG()->getGNode(*nIter);
-        if (SVFUtil::isa<DummyObjPN>(node) || SVFUtil::isa<DummyValPN>(node))
+        if (SVFUtil::isa<DummyObjVar>(node) || SVFUtil::isa<DummyValVar>(node))
             continue;
 
         outs() << "##<" << node->getValue()->getName() << "> ";
@@ -305,18 +305,18 @@ void PointerAnalysis::dumpAllTypes()
 }
 
 /*!
- * Dump points-to of top-level pointers (ValPN)
+ * Dump points-to of top-level pointers (ValVar)
  */
 void PointerAnalysis::dumpPts(NodeID ptr, const PointsTo& pts)
 {
 
     const PAGNode* node = pag->getGNode(ptr);
     /// print the points-to set of node which has the maximum pts size.
-    if (SVFUtil::isa<DummyObjPN> (node))
+    if (SVFUtil::isa<DummyObjVar> (node))
     {
         outs() << "##<Dummy Obj > id:" << node->getId();
     }
-    else if (!SVFUtil::isa<DummyValPN>(node) && !SVFModule::pagReadFromTXT()) {
+    else if (!SVFUtil::isa<DummyValVar>(node) && !SVFModule::pagReadFromTXT()) {
 		if (node->hasValue()) {
 			outs() << "##<" << node->getValue()->getName() << "> ";
 			outs() << "Source Loc: " << getSourceLoc(node->getValue());
@@ -342,14 +342,14 @@ void PointerAnalysis::dumpPts(NodeID ptr, const PointsTo& pts)
     for (PointsTo::iterator it = pts.begin(), eit = pts.end(); it != eit; ++it)
     {
         const PAGNode* node = pag->getGNode(*it);
-        if(SVFUtil::isa<ObjPN>(node) == false)
+        if(SVFUtil::isa<ObjVar>(node) == false)
             continue;
         NodeID ptd = node->getId();
         outs() << "!!Target NodeID " << ptd << "\t [";
         const PAGNode* pagNode = pag->getGNode(ptd);
-        if (SVFUtil::isa<DummyValPN>(node))
+        if (SVFUtil::isa<DummyValVar>(node))
             outs() << "DummyVal\n";
-        else if (SVFUtil::isa<DummyObjPN>(node))
+        else if (SVFUtil::isa<DummyObjVar>(node))
             outs() << "Dummy Obj id: " << node->getId() << "]\n";
 		else {
 			if (!SVFModule::pagReadFromTXT()) {
@@ -445,7 +445,7 @@ void PointerAnalysis::resolveIndCalls(const CallBlockNode* cs, const PointsTo& t
             return;
         }
 
-        if(ObjPN* objPN = SVFUtil::dyn_cast<ObjPN>(pag->getGNode(*ii)))
+        if(ObjVar* objPN = SVFUtil::dyn_cast<ObjVar>(pag->getGNode(*ii)))
         {
             const MemObj* obj = pag->getObject(objPN);