svf-tools 1.0.320 → 1.0.324

package/lib/MemoryModel/PointerAnalysisImpl.cpp

@@ -84,9 +84,9 @@ void BVDataPTAImpl::expandFIObjs(const PointsTo& pts, PointsTo& expandedPts)
     expandedPts = pts;;
     for(PointsTo::iterator pit = pts.begin(), epit = pts.end(); pit!=epit; ++pit)
     {
-        if (pag->getBaseObjNode(*pit) == *pit || isFieldInsensitive(*pit))
+        if (pag->getBaseObjVar(*pit) == *pit || isFieldInsensitive(*pit))
         {
-            expandedPts |= pag->getAllFieldsObjNode(*pit);
+            expandedPts |= pag->getAllFieldsObjVars(*pit);
         }
     }
 }
@@ -96,9 +96,9 @@ void BVDataPTAImpl::expandFIObjs(const NodeBS& pts, NodeBS& expandedPts)
     expandedPts = pts;
     for (const NodeID o : pts)
     {
-        if (pag->getBaseObjNode(o) == o || isFieldInsensitive(o))
+        if (pag->getBaseObjVar(o) == o || isFieldInsensitive(o))
         {
-            expandedPts |= pag->getAllFieldsObjNode(o);
+            expandedPts |= pag->getAllFieldsObjVars(o);
         }
     }
 }
@@ -153,7 +153,7 @@ void BVDataPTAImpl::writeToFile(const string& filename)
         if (GepObjPN *gepObjPN = SVFUtil::dyn_cast<GepObjPN>(pagNode))
         {
             F.os() << it->first << " ";
-            F.os() << pag->getBaseObjNode(it->first) << " ";
+            F.os() << pag->getBaseObjVar(it->first) << " ";
             F.os() << gepObjPN->getLocationSet().getOffset() << "\n";
         }
     }
@@ -164,8 +164,8 @@ void BVDataPTAImpl::writeToFile(const string& filename)
     for (auto it = pag->begin(), ie = pag->end(); it != ie; ++it)
     {
         PAGNode* pagNode = it->second;
-        if (!isa<ObjPN>(pagNode)) continue;
-        NodeID n = pag->getBaseObjNode(it->first);
+        if (!isa<ObjVar>(pagNode)) continue;
+        NodeID n = pag->getBaseObjVar(it->first);
         if (NodeIDs.test(n)) continue;
         F.os() << n << " ";
         F.os() << isFieldInsensitive(n) << "\n";
@@ -265,7 +265,7 @@ bool BVDataPTAImpl::readFromFile(const string& filename)
         size_t offset;
         ss >> id >> base >> offset;
 
-        NodeID n = pag->getGepObjNode(pag->getObject(base), LocationSet(offset));
+        NodeID n = pag->getGepObjVar(pag->getObject(base), LocationSet(offset));
         assert(id == n && "Error adding GepObjNode into SVFIR!");
 
         getline(F, line);
@@ -353,7 +353,7 @@ void BVDataPTAImpl::dumpTopLevelPtsTo()
 
 
 /*!
- * Dump all points-to including top-level (ValPN) and address-taken (ObjPN) variables
+ * Dump all points-to including top-level (ValVar) and address-taken (ObjVar) variables
  */
 void BVDataPTAImpl::dumpAllPts()
 {
@@ -401,7 +401,7 @@ void BVDataPTAImpl::onTheFlyCallGraphSolve(const CallSiteToFunPtrMap& callsites,
  */
 void BVDataPTAImpl::normalizePointsTo() {
     SVFIR::MemObjToFieldsMap &memToFieldsMap = pag->getMemToFieldsMap();
-    SVFIR::NodeLocationSetMap &GepObjNodeMap = pag->getGepObjNodeMap();
+    SVFIR::NodeLocationSetMap &GepObjVarMap = pag->getGepObjNodeMap();
 
     // collect each gep node whose base node has been set as field-insensitive
     NodeBS dropNodes;
@@ -427,19 +427,19 @@ void BVDataPTAImpl::normalizePointsTo() {
         for (NodeID obj : tmpPts) {
             if (!dropNodes.test(obj))
                 continue;
-            NodeID baseObj = pag->getBaseObjNode(obj);
+            NodeID baseObj = pag->getBaseObjVar(obj);
             clearPts(n, obj);
             addPts(n, baseObj);
         }
     }
 
-    // clear GepObjNodeMap and memToFieldsMap for redundant gepnodes
+    // clear GepObjVarMap and memToFieldsMap for redundant gepnodes
     // and remove those nodes from pag
     for (NodeID n: dropNodes) {
-        NodeID base = pag->getBaseObjNode(n);
+        NodeID base = pag->getBaseObjVar(n);
         GepObjPN *gepNode = SVFUtil::dyn_cast<GepObjPN>(pag->getGNode(n));
         const LocationSet ls = gepNode->getLocationSet();
-        GepObjNodeMap.erase(std::make_pair(base, ls));
+        GepObjVarMap.erase(std::make_pair(base, ls));
         memToFieldsMap[base].reset(n);
 
         pag->removeGNode(gepNode);

package/lib/MemoryModel/SVFIR.cpp

@@ -48,15 +48,15 @@ SVFIR::SVFIR(bool buildFromFile) : IRGraph(buildFromFile)
 /*!
  * Add Address edge
  */
-AddrPE* SVFIR::addAddrPE(NodeID src, NodeID dst)
+AddrStmt* SVFIR::addAddrStmt(NodeID src, NodeID dst)
 {
     SVFVar* srcNode = getGNode(src);
     SVFVar* dstNode = getGNode(dst);
     if(SVFStmt* edge = hasNonlabeledEdge(srcNode,dstNode, SVFStmt::Addr))
-        return SVFUtil::cast<AddrPE>(edge);
+        return SVFUtil::cast<AddrStmt>(edge);
     else
     {
-        AddrPE* addrPE = new AddrPE(srcNode, dstNode);
+        AddrStmt* addrPE = new AddrStmt(srcNode, dstNode);
         addToStmt2TypeMap(addrPE);
         addEdge(srcNode,dstNode, addrPE);
         return addrPE;
@@ -66,15 +66,15 @@ AddrPE* SVFIR::addAddrPE(NodeID src, NodeID dst)
 /*!
  * Add Copy edge
  */
-CopyPE* SVFIR::addCopyPE(NodeID src, NodeID dst)
+CopyStmt* SVFIR::addCopyStmt(NodeID src, NodeID dst)
 {
     SVFVar* srcNode = getGNode(src);
     SVFVar* dstNode = getGNode(dst);
     if(SVFStmt* edge = hasNonlabeledEdge(srcNode,dstNode, SVFStmt::Copy))
-        return SVFUtil::cast<CopyPE>(edge);
+        return SVFUtil::cast<CopyStmt>(edge);
     else
     {
-        CopyPE* copyPE = new CopyPE(srcNode, dstNode);
+        CopyStmt* copyPE = new CopyStmt(srcNode, dstNode);
         addToStmt2TypeMap(copyPE);
         addEdge(srcNode,dstNode, copyPE);
         return copyPE;
@@ -84,13 +84,13 @@ CopyPE* SVFIR::addCopyPE(NodeID src, NodeID dst)
 /*!
  * Add Phi statement 
  */
-PhiPE* SVFIR::addPhiNode(NodeID res, NodeID opnd)
+PhiStmt* SVFIR::addPhiStmt(NodeID res, NodeID opnd)
 {
     SVFVar* opNode = getGNode(opnd);
     SVFVar* resNode = getGNode(res);
     PHINodeMap::iterator it = phiNodeMap.find(resNode);
     if(it == phiNodeMap.end()){
-        PhiPE* phi = new PhiPE(resNode, {opNode});
+        PhiStmt* phi = new PhiStmt(resNode, {opNode});
         addToStmt2TypeMap(phi);
         addEdge(opNode, resNode, phi);
         phiNodeMap[resNode] = phi;
@@ -105,17 +105,17 @@ PhiPE* SVFIR::addPhiNode(NodeID res, NodeID opnd)
 /*!
  * Add Compare edge
  */
-CmpPE* SVFIR::addCmpPE(NodeID op1, NodeID op2, NodeID dst, u32_t opcode)
+CmpStmt* SVFIR::addCmpStmt(NodeID op1, NodeID op2, NodeID dst, u32_t predicate)
 {
     SVFVar* op1Node = getGNode(op1);
     SVFVar* op2Node = getGNode(op2);
     SVFVar* dstNode = getGNode(dst);
     if(SVFStmt* edge = hasLabeledEdge(op1Node, dstNode, SVFStmt::Cmp, op2Node))
-        return SVFUtil::cast<CmpPE>(edge);
+        return SVFUtil::cast<CmpStmt>(edge);
     else
     {
         std::vector<SVFVar*> opnds = {op1Node, op2Node};
-        CmpPE* cmp = new CmpPE(dstNode, opnds, opcode);
+        CmpStmt* cmp = new CmpStmt(dstNode, opnds, predicate);
         addToStmt2TypeMap(cmp);
         addEdge(op1Node, dstNode, cmp);
         return cmp;
@@ -126,17 +126,17 @@ CmpPE* SVFIR::addCmpPE(NodeID op1, NodeID op2, NodeID dst, u32_t opcode)
 /*!
  * Add Compare edge
  */
-BinaryOPPE* SVFIR::addBinaryOPPE(NodeID op1, NodeID op2, NodeID dst, u32_t opcode)
+BinaryOPStmt* SVFIR::addBinaryOPStmt(NodeID op1, NodeID op2, NodeID dst, u32_t opcode)
 {
     SVFVar* op1Node = getGNode(op1);
     SVFVar* op2Node = getGNode(op2);
     SVFVar* dstNode = getGNode(dst);
     if(SVFStmt* edge = hasLabeledEdge(op1Node, dstNode, SVFStmt::BinaryOp, op2Node))
-        return SVFUtil::cast<BinaryOPPE>(edge);
+        return SVFUtil::cast<BinaryOPStmt>(edge);
     else
     {
         std::vector<SVFVar*> opnds = {op1Node, op2Node};
-        BinaryOPPE* binaryOP = new BinaryOPPE(dstNode, opnds, opcode);
+        BinaryOPStmt* binaryOP = new BinaryOPStmt(dstNode, opnds, opcode);
         addToStmt2TypeMap(binaryOP);
         addEdge(op1Node,dstNode, binaryOP);
         return binaryOP;
@@ -146,15 +146,15 @@ BinaryOPPE* SVFIR::addBinaryOPPE(NodeID op1, NodeID op2, NodeID dst, u32_t opcod
 /*!
  * Add Unary edge
  */
-UnaryOPPE* SVFIR::addUnaryOPPE(NodeID src, NodeID dst, u32_t opcode)
+UnaryOPStmt* SVFIR::addUnaryOPStmt(NodeID src, NodeID dst, u32_t opcode)
 {
     SVFVar* srcNode = getGNode(src);
     SVFVar* dstNode = getGNode(dst);
     if(SVFStmt* edge = hasNonlabeledEdge(srcNode,dstNode, SVFStmt::UnaryOp))
-        return SVFUtil::cast<UnaryOPPE>(edge);
+        return SVFUtil::cast<UnaryOPStmt>(edge);
     else
     {
-        UnaryOPPE* unaryOP = new UnaryOPPE(srcNode, dstNode, opcode);
+        UnaryOPStmt* unaryOP = new UnaryOPStmt(srcNode, dstNode, opcode);
         addToStmt2TypeMap(unaryOP);
         addEdge(srcNode,dstNode, unaryOP);
         return unaryOP;
@@ -182,15 +182,15 @@ BranchStmt* SVFIR::addBranchStmt(NodeID br, NodeID cond, std::vector<const ICFGN
 /*!
  * Add Load edge
  */
-LoadPE* SVFIR::addLoadPE(NodeID src, NodeID dst)
+LoadStmt* SVFIR::addLoadStmt(NodeID src, NodeID dst)
 {
     SVFVar* srcNode = getGNode(src);
     SVFVar* dstNode = getGNode(dst);
     if(SVFStmt* edge = hasNonlabeledEdge(srcNode,dstNode, SVFStmt::Load))
-        return SVFUtil::cast<LoadPE>(edge);
+        return SVFUtil::cast<LoadStmt>(edge);
     else
     {
-        LoadPE* loadPE = new LoadPE(srcNode, dstNode);
+        LoadStmt* loadPE = new LoadStmt(srcNode, dstNode);
         addToStmt2TypeMap(loadPE);
         addEdge(srcNode,dstNode, loadPE);
         return loadPE;
@@ -201,15 +201,15 @@ LoadPE* SVFIR::addLoadPE(NodeID src, NodeID dst)
  * Add Store edge
  * Note that two store instructions may share the same Store SVFStmt
  */
-StorePE* SVFIR::addStorePE(NodeID src, NodeID dst, const IntraBlockNode* curVal)
+StoreStmt* SVFIR::addStoreStmt(NodeID src, NodeID dst, const IntraBlockNode* curVal)
 {
     SVFVar* srcNode = getGNode(src);
     SVFVar* dstNode = getGNode(dst);
     if(SVFStmt* edge = hasLabeledEdge(srcNode,dstNode, SVFStmt::Store, curVal))
-        return SVFUtil::cast<StorePE>(edge);
+        return SVFUtil::cast<StoreStmt>(edge);
     else
     {
-        StorePE* storePE = new StorePE(srcNode, dstNode, curVal);
+        StoreStmt* storePE = new StoreStmt(srcNode, dstNode, curVal);
         addToStmt2TypeMap(storePE);
         addEdge(srcNode,dstNode, storePE);
         return storePE;
@@ -255,12 +255,12 @@ RetPE* SVFIR::addRetPE(NodeID src, NodeID dst, const CallBlockNode* cs)
 /*!
  * Add blackhole/constant edge
  */
-SVFStmt* SVFIR::addBlackHoleAddrPE(NodeID node)
+SVFStmt* SVFIR::addBlackHoleAddrStmt(NodeID node)
 {
     if(Options::HandBlackHole)
-        return pag->addAddrPE(pag->getBlackHoleNode(), node);
+        return pag->addAddrStmt(pag->getBlackHoleNode(), node);
     else
-        return pag->addCopyPE(pag->getNullPtr(), node);
+        return pag->addCopyStmt(pag->getNullPtr(), node);
 }
 
 /*!
@@ -305,35 +305,35 @@ TDJoinPE* SVFIR::addThreadJoinPE(NodeID src, NodeID dst, const CallBlockNode* cs
  * Find the base node id of src and connect base node to dst node
  * Create gep offset:  (offset + baseOff <nested struct gep size>)
  */
-GepPE* SVFIR::addGepPE(NodeID src, NodeID dst, const LocationSet& ls, bool constGep)
+GepStmt* SVFIR::addGepStmt(NodeID src, NodeID dst, const LocationSet& ls, bool constGep)
 {
 
     SVFVar* node = getGNode(src);
     if (!constGep || node->hasIncomingVariantGepEdge())
     {
         /// Since the offset from base to src is variant,
-        /// the new gep edge being created is also a VariantGepPE edge.
-        return addVariantGepPE(src, dst);
+        /// the new gep edge being created is also a VariantGepStmt edge.
+        return addVariantGepStmt(src, dst);
     }
     else
     {
-        return addNormalGepPE(src, dst, ls);
+        return addNormalGepStmt(src, dst, ls);
     }
 }
 
 /*!
  * Add normal (Gep) edge
  */
-NormalGepPE* SVFIR::addNormalGepPE(NodeID src, NodeID dst, const LocationSet& ls)
+NormalGepStmt* SVFIR::addNormalGepStmt(NodeID src, NodeID dst, const LocationSet& ls)
 {
     const LocationSet& baseLS = getLocationSetFromBaseNode(src);
-    SVFVar* baseNode = getGNode(getBaseValNode(src));
+    SVFVar* baseNode = getGNode(getBaseValVar(src));
     SVFVar* dstNode = getGNode(dst);
     if(SVFStmt* edge = hasNonlabeledEdge(baseNode, dstNode, SVFStmt::NormalGep))
-        return SVFUtil::cast<NormalGepPE>(edge);
+        return SVFUtil::cast<NormalGepStmt>(edge);
     else
     {
-        NormalGepPE* gepPE = new NormalGepPE(baseNode, dstNode, ls+baseLS);
+        NormalGepStmt* gepPE = new NormalGepStmt(baseNode, dstNode, ls+baseLS);
         addToStmt2TypeMap(gepPE);
         addEdge(baseNode, dstNode, gepPE);
         return gepPE;
@@ -344,16 +344,16 @@ NormalGepPE* SVFIR::addNormalGepPE(NodeID src, NodeID dst, const LocationSet& ls
  * Add variant(Gep) edge
  * Find the base node id of src and connect base node to dst node
  */
-VariantGepPE* SVFIR::addVariantGepPE(NodeID src, NodeID dst)
+VariantGepStmt* SVFIR::addVariantGepStmt(NodeID src, NodeID dst)
 {
 
-    SVFVar* baseNode = getGNode(getBaseValNode(src));
+    SVFVar* baseNode = getGNode(getBaseValVar(src));
     SVFVar* dstNode = getGNode(dst);
     if(SVFStmt* edge = hasNonlabeledEdge(baseNode, dstNode, SVFStmt::VariantGep))
-        return SVFUtil::cast<VariantGepPE>(edge);
+        return SVFUtil::cast<VariantGepStmt>(edge);
     else
     {
-        VariantGepPE* gepPE = new VariantGepPE(baseNode, dstNode);
+        VariantGepStmt* gepPE = new VariantGepStmt(baseNode, dstNode);
         addToStmt2TypeMap(gepPE);
         addEdge(baseNode, dstNode, gepPE);
         return gepPE;
@@ -363,32 +363,32 @@ VariantGepPE* SVFIR::addVariantGepPE(NodeID src, NodeID dst)
 
 
 /*!
- * Add a temp field value node, this method can only invoked by getGepValNode
- * due to constaint expression, curInst is used to distinguish different instructions (e.g., memorycpy) when creating GepValPN.
+ * Add a temp field value node, this method can only invoked by getGepValVar
+ * due to constaint expression, curInst is used to distinguish different instructions (e.g., memorycpy) when creating GepValVar.
  */
 NodeID SVFIR::addGepValNode(const Value* curInst,const Value* gepVal, const LocationSet& ls, NodeID i, const Type *type, u32_t fieldidx)
 {
-    NodeID base = getBaseValNode(getValueNode(gepVal));
+    NodeID base = getBaseValVar(getValueNode(gepVal));
     //assert(findPAGNode(i) == false && "this node should not be created before");
-    assert(0==GepValNodeMap[curInst].count(std::make_pair(base, ls))
+    assert(0==GepValObjMap[curInst].count(std::make_pair(base, ls))
            && "this node should not be created before");
-    GepValNodeMap[curInst][std::make_pair(base, ls)] = i;
-    GepValPN *node = new GepValPN(gepVal, i, ls, type, fieldidx);
+    GepValObjMap[curInst][std::make_pair(base, ls)] = i;
+    GepValVar *node = new GepValVar(gepVal, i, ls, type, fieldidx);
     return addValNode(gepVal, node, i);
 }
 
 /*!
  * Given an object node, find its field object node
  */
-NodeID SVFIR::getGepObjNode(NodeID id, const LocationSet& ls)
+NodeID SVFIR::getGepObjVar(NodeID id, const LocationSet& ls)
 {
     SVFVar* node = pag->getGNode(id);
     if (GepObjPN* gepNode = SVFUtil::dyn_cast<GepObjPN>(node))
-        return getGepObjNode(gepNode->getMemObj(), gepNode->getLocationSet() + ls);
-    else if (FIObjPN* baseNode = SVFUtil::dyn_cast<FIObjPN>(node))
-        return getGepObjNode(baseNode->getMemObj(), ls);
-    else if (DummyObjPN* baseNode = SVFUtil::dyn_cast<DummyObjPN>(node))
-        return getGepObjNode(baseNode->getMemObj(), ls);
+        return getGepObjVar(gepNode->getMemObj(), gepNode->getLocationSet() + ls);
+    else if (FIObjVar* baseNode = SVFUtil::dyn_cast<FIObjVar>(node))
+        return getGepObjVar(baseNode->getMemObj(), ls);
+    else if (DummyObjVar* baseNode = SVFUtil::dyn_cast<DummyObjVar>(node))
+        return getGepObjVar(baseNode->getMemObj(), ls);
     else
     {
         assert(false && "new gep obj node kind?");
@@ -402,21 +402,21 @@ NodeID SVFIR::getGepObjNode(NodeID id, const LocationSet& ls)
  * offset = offset % obj->getMaxFieldOffsetLimit() to create limited number of mem objects
  * maximum number of field object creation is obj->getMaxFieldOffsetLimit()
  */
-NodeID SVFIR::getGepObjNode(const MemObj* obj, const LocationSet& ls)
+NodeID SVFIR::getGepObjVar(const MemObj* obj, const LocationSet& ls)
 {
     NodeID base = obj->getId();
 
     /// if this obj is field-insensitive, just return the field-insensitive node.
     if (obj->isFieldInsensitive())
-        return getFIObjNode(obj);
+        return getFIObjVar(obj);
 
     LocationSet newLS = SymbolTableInfo::SymbolInfo()->getModulusOffset(obj,ls);
 
     // Base and first field are the same memory location.
     if (Options::FirstFieldEqBase && newLS.getOffset() == 0) return base;
 
-    NodeLocationSetMap::iterator iter = GepObjNodeMap.find(std::make_pair(base, newLS));
-    if (iter == GepObjNodeMap.end())
+    NodeLocationSetMap::iterator iter = GepObjVarMap.find(std::make_pair(base, newLS));
+    if (iter == GepObjVarMap.end())
         return addGepObjNode(obj, newLS);
     else
         return iter->second;
@@ -424,17 +424,17 @@ NodeID SVFIR::getGepObjNode(const MemObj* obj, const LocationSet& ls)
 }
 
 /*!
- * Add a field obj node, this method can only invoked by getGepObjNode
+ * Add a field obj node, this method can only invoked by getGepObjVar
  */
 NodeID SVFIR::addGepObjNode(const MemObj* obj, const LocationSet& ls)
 {
     //assert(findPAGNode(i) == false && "this node should not be created before");
     NodeID base = obj->getId();
-    assert(0==GepObjNodeMap.count(std::make_pair(base, ls))
+    assert(0==GepObjVarMap.count(std::make_pair(base, ls))
            && "this node should not be created before");
 
     NodeID gepId = NodeIDAllocator::get()->allocateGepObjectId(base, ls.getOffset(), StInfo::getMaxFieldLimit());
-    GepObjNodeMap[std::make_pair(base, ls)] = gepId;
+    GepObjVarMap[std::make_pair(base, ls)] = gepId;
     GepObjPN *node = new GepObjPN(obj, gepId, ls);
     memToFieldsMap[base].set(gepId);
     return addObjNode(obj->getValue(), node, gepId);
@@ -448,14 +448,14 @@ NodeID SVFIR::addFIObjNode(const MemObj* obj)
     //assert(findPAGNode(i) == false && "this node should not be created before");
     NodeID base = obj->getId();
     memToFieldsMap[base].set(obj->getId());
-    FIObjPN *node = new FIObjPN(obj->getValue(), obj->getId(), obj);
+    FIObjVar *node = new FIObjVar(obj->getValue(), obj->getId(), obj);
     return addObjNode(obj->getValue(), node, obj->getId());
 }
 
 /*!
  * Get all fields object nodes of an object
  */
-NodeBS& SVFIR::getAllFieldsObjNode(const MemObj* obj)
+NodeBS& SVFIR::getAllFieldsObjVars(const MemObj* obj)
 {
     NodeID base = obj->getId();
     return memToFieldsMap[base];
@@ -464,12 +464,12 @@ NodeBS& SVFIR::getAllFieldsObjNode(const MemObj* obj)
 /*!
  * Get all fields object nodes of an object
  */
-NodeBS& SVFIR::getAllFieldsObjNode(NodeID id)
+NodeBS& SVFIR::getAllFieldsObjVars(NodeID id)
 {
     const SVFVar* node = pag->getGNode(id);
-    assert(SVFUtil::isa<ObjPN>(node) && "need an object node");
-    const ObjPN* obj = SVFUtil::cast<ObjPN>(node);
-    return getAllFieldsObjNode(obj->getMemObj());
+    assert(SVFUtil::isa<ObjVar>(node) && "need an object node");
+    const ObjVar* obj = SVFUtil::cast<ObjVar>(node);
+    return getAllFieldsObjVars(obj->getMemObj());
 }
 
 /*!
@@ -480,16 +480,16 @@ NodeBS& SVFIR::getAllFieldsObjNode(NodeID id)
 NodeBS SVFIR::getFieldsAfterCollapse(NodeID id)
 {
     const SVFVar* node = pag->getGNode(id);
-    assert(SVFUtil::isa<ObjPN>(node) && "need an object node");
-    const MemObj* mem = SVFUtil::cast<ObjPN>(node)->getMemObj();
+    assert(SVFUtil::isa<ObjVar>(node) && "need an object node");
+    const MemObj* mem = SVFUtil::cast<ObjVar>(node)->getMemObj();
     if(mem->isFieldInsensitive())
     {
         NodeBS bs;
-        bs.set(getFIObjNode(mem));
+        bs.set(getFIObjVar(mem));
         return bs;
     }
     else
-        return getAllFieldsObjNode(mem);
+        return getAllFieldsObjVars(mem);
 }
 
 /*!
@@ -497,13 +497,13 @@ NodeBS SVFIR::getFieldsAfterCollapse(NodeID id)
  * Return the source node of its connected gep edge if this pointer has
  * Otherwise return the node id itself
  */
-NodeID SVFIR::getBaseValNode(NodeID nodeId)
+NodeID SVFIR::getBaseValVar(NodeID nodeId)
 {
     SVFVar* node  = getGNode(nodeId);
     if (node->hasIncomingEdges(SVFStmt::NormalGep) ||  node->hasIncomingEdges(SVFStmt::VariantGep))
     {
-        SVFStmt::PAGEdgeSetTy& ngeps = node->getIncomingEdges(SVFStmt::NormalGep);
-        SVFStmt::PAGEdgeSetTy& vgeps = node->getIncomingEdges(SVFStmt::VariantGep);
+        SVFStmt::SVFStmtSetTy& ngeps = node->getIncomingEdges(SVFStmt::NormalGep);
+        SVFStmt::SVFStmtSetTy& vgeps = node->getIncomingEdges(SVFStmt::VariantGep);
 
         assert(((ngeps.size()+vgeps.size())==1) && "one node can only be connected by at most one gep edge!");
 
@@ -513,7 +513,7 @@ NodeID SVFIR::getBaseValNode(NodeID nodeId)
         else
             it = vgeps.begin();
 
-        assert(SVFUtil::isa<GepPE>(*it) && "not a gep edge??");
+        assert(SVFUtil::isa<GepStmt>(*it) && "not a gep edge??");
         return (*it)->getSrcID();
     }
     else
@@ -529,7 +529,7 @@ NodeID SVFIR::getBaseValNode(NodeID nodeId)
 LocationSet SVFIR::getLocationSetFromBaseNode(NodeID nodeId)
 {
     SVFVar* node  = getGNode(nodeId);
-    SVFStmt::PAGEdgeSetTy& geps = node->getIncomingEdges(SVFStmt::NormalGep);
+    SVFStmt::SVFStmtSetTy& geps = node->getIncomingEdges(SVFStmt::NormalGep);
     /// if this node is already a base node
     if(geps.empty())
         return LocationSet(0);
@@ -537,8 +537,8 @@ LocationSet SVFIR::getLocationSetFromBaseNode(NodeID nodeId)
     assert(geps.size()==1 && "one node can only be connected by at most one gep edge!");
     SVFVar::iterator it = geps.begin();
     const SVFStmt* edge = *it;
-    assert(SVFUtil::isa<NormalGepPE>(edge) && "not a get edge??");
-    const NormalGepPE* gepEdge = SVFUtil::cast<NormalGepPE>(edge);
+    assert(SVFUtil::isa<NormalGepStmt>(edge) && "not a get edge??");
+    const NormalGepStmt* gepEdge = SVFUtil::cast<NormalGepStmt>(edge);
     return gepEdge->getLocationSet();
 }
 
@@ -558,81 +558,81 @@ void SVFIR::print()
 {
 
     outs() << "-------------------SVFIR------------------------------------\n";
-    SVFStmt::PAGEdgeSetTy& addrs = pag->getEdgeSet(SVFStmt::Addr);
-    for (SVFStmt::PAGEdgeSetTy::iterator iter = addrs.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& addrs = pag->getSVFStmtSet(SVFStmt::Addr);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = addrs.begin(), eiter =
                 addrs.end(); iter != eiter; ++iter)
     {
         outs() << (*iter)->getSrcID() << " -- Addr --> " << (*iter)->getDstID()
                << "\n";
     }
 
-    SVFStmt::PAGEdgeSetTy& copys = pag->getEdgeSet(SVFStmt::Copy);
-    for (SVFStmt::PAGEdgeSetTy::iterator iter = copys.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& copys = pag->getSVFStmtSet(SVFStmt::Copy);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = copys.begin(), eiter =
                 copys.end(); iter != eiter; ++iter)
     {
         outs() << (*iter)->getSrcID() << " -- Copy --> " << (*iter)->getDstID()
                << "\n";
     }
 
-    SVFStmt::PAGEdgeSetTy& calls = pag->getEdgeSet(SVFStmt::Call);
-    for (SVFStmt::PAGEdgeSetTy::iterator iter = calls.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& calls = pag->getSVFStmtSet(SVFStmt::Call);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = calls.begin(), eiter =
                 calls.end(); iter != eiter; ++iter)
     {
         outs() << (*iter)->getSrcID() << " -- Call --> " << (*iter)->getDstID()
                << "\n";
     }
 
-    SVFStmt::PAGEdgeSetTy& rets = pag->getEdgeSet(SVFStmt::Ret);
-    for (SVFStmt::PAGEdgeSetTy::iterator iter = rets.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& rets = pag->getSVFStmtSet(SVFStmt::Ret);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = rets.begin(), eiter =
                 rets.end(); iter != eiter; ++iter)
     {
         outs() << (*iter)->getSrcID() << " -- Ret --> " << (*iter)->getDstID()
                << "\n";
     }
 
-    SVFStmt::PAGEdgeSetTy& tdfks = pag->getEdgeSet(SVFStmt::ThreadFork);
-    for (SVFStmt::PAGEdgeSetTy::iterator iter = tdfks.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& tdfks = pag->getSVFStmtSet(SVFStmt::ThreadFork);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = tdfks.begin(), eiter =
                 tdfks.end(); iter != eiter; ++iter)
     {
         outs() << (*iter)->getSrcID() << " -- ThreadFork --> "
                << (*iter)->getDstID() << "\n";
     }
 
-    SVFStmt::PAGEdgeSetTy& tdjns = pag->getEdgeSet(SVFStmt::ThreadJoin);
-    for (SVFStmt::PAGEdgeSetTy::iterator iter = tdjns.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& tdjns = pag->getSVFStmtSet(SVFStmt::ThreadJoin);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = tdjns.begin(), eiter =
                 tdjns.end(); iter != eiter; ++iter)
     {
         outs() << (*iter)->getSrcID() << " -- ThreadJoin --> "
                << (*iter)->getDstID() << "\n";
     }
 
-    SVFStmt::PAGEdgeSetTy& ngeps = pag->getEdgeSet(SVFStmt::NormalGep);
-    for (SVFStmt::PAGEdgeSetTy::iterator iter = ngeps.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& ngeps = pag->getSVFStmtSet(SVFStmt::NormalGep);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = ngeps.begin(), eiter =
                 ngeps.end(); iter != eiter; ++iter)
     {
-        NormalGepPE* gep = SVFUtil::cast<NormalGepPE>(*iter);
+        NormalGepStmt* gep = SVFUtil::cast<NormalGepStmt>(*iter);
         outs() << gep->getSrcID() << " -- NormalGep (" << gep->getOffset()
                << ") --> " << gep->getDstID() << "\n";
     }
 
-    SVFStmt::PAGEdgeSetTy& vgeps = pag->getEdgeSet(SVFStmt::VariantGep);
-    for (SVFStmt::PAGEdgeSetTy::iterator iter = vgeps.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& vgeps = pag->getSVFStmtSet(SVFStmt::VariantGep);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = vgeps.begin(), eiter =
                 vgeps.end(); iter != eiter; ++iter)
     {
         outs() << (*iter)->getSrcID() << " -- VariantGep --> "
                << (*iter)->getDstID() << "\n";
     }
 
-    SVFStmt::PAGEdgeSetTy& loads = pag->getEdgeSet(SVFStmt::Load);
-    for (SVFStmt::PAGEdgeSetTy::iterator iter = loads.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& loads = pag->getSVFStmtSet(SVFStmt::Load);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = loads.begin(), eiter =
                 loads.end(); iter != eiter; ++iter)
     {
         outs() << (*iter)->getSrcID() << " -- Load --> " << (*iter)->getDstID()
                << "\n";
     }
 
-    SVFStmt::PAGEdgeSetTy& stores = pag->getEdgeSet(SVFStmt::Store);
-    for (SVFStmt::PAGEdgeSetTy::iterator iter = stores.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& stores = pag->getSVFStmtSet(SVFStmt::Store);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = stores.begin(), eiter =
                 stores.end(); iter != eiter; ++iter)
     {
         outs() << (*iter)->getSrcID() << " -- Store --> " << (*iter)->getDstID()