svf-tools 1.0.351 → 1.0.352

package/lib/Graphs/VFG.cpp

@@ -336,16 +336,16 @@ void VFG::addVFGNodes()
     addNullPtrVFGNode(pag->getGNode(pag->getNullPtr()));
 
     // initialize address nodes
-    PAGEdge::SVFStmtSetTy& addrs = getPAGEdgeSet(PAGEdge::Addr);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = addrs.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& addrs = getPAGEdgeSet(SVFStmt::Addr);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = addrs.begin(), eiter =
                 addrs.end(); iter != eiter; ++iter)
     {
         addAddrVFGNode(SVFUtil::cast<AddrStmt>(*iter));
     }
 
     // initialize copy nodes
-    PAGEdge::SVFStmtSetTy& copys = getPAGEdgeSet(PAGEdge::Copy);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = copys.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& copys = getPAGEdgeSet(SVFStmt::Copy);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = copys.begin(), eiter =
                 copys.end(); iter != eiter; ++iter)
     {
         const CopyStmt* edge = SVFUtil::cast<CopyStmt>(*iter);
@@ -354,38 +354,31 @@ void VFG::addVFGNodes()
     }
 
     // initialize gep nodes
-    PAGEdge::SVFStmtSetTy& ngeps = getPAGEdgeSet(PAGEdge::NormalGep);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = ngeps.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& ngeps = getPAGEdgeSet(SVFStmt::Gep);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = ngeps.begin(), eiter =
                 ngeps.end(); iter != eiter; ++iter)
     {
-        addGepVFGNode(SVFUtil::cast<NormalGepStmt>(*iter));
-    }
-
-    PAGEdge::SVFStmtSetTy& vgeps = getPAGEdgeSet(PAGEdge::VariantGep);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = vgeps.begin(), eiter =
-                vgeps.end(); iter != eiter; ++iter)
-    {
-        addGepVFGNode(SVFUtil::cast<VariantGepStmt>(*iter));
+        addGepVFGNode(SVFUtil::cast<GepStmt>(*iter));
     }
 
     // initialize load nodes
-    PAGEdge::SVFStmtSetTy& loads = getPAGEdgeSet(PAGEdge::Load);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = loads.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& loads = getPAGEdgeSet(SVFStmt::Load);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = loads.begin(), eiter =
                 loads.end(); iter != eiter; ++iter)
     {
         addLoadVFGNode(SVFUtil::cast<LoadStmt>(*iter));
     }
 
     // initialize store nodes
-    PAGEdge::SVFStmtSetTy& stores = getPAGEdgeSet(PAGEdge::Store);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = stores.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& stores = getPAGEdgeSet(SVFStmt::Store);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = stores.begin(), eiter =
                 stores.end(); iter != eiter; ++iter)
     {
         addStoreVFGNode(SVFUtil::cast<StoreStmt>(*iter));
     }
 
-    PAGEdge::SVFStmtSetTy& forks = getPAGEdgeSet(PAGEdge::ThreadFork);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = forks.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& forks = getPAGEdgeSet(SVFStmt::ThreadFork);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = forks.begin(), eiter =
                 forks.end(); iter != eiter; ++iter)
     {
         TDForkPE* forkedge = SVFUtil::cast<TDForkPE>(*iter);
@@ -429,10 +422,10 @@ void VFG::addVFGNodes()
                 continue;
 
             CallPESet callPEs;
-            if (param->hasIncomingEdges(PAGEdge::Call))
+            if (param->hasIncomingEdges(SVFStmt::Call))
             {
-                for (PAGEdge::SVFStmtSetTy::const_iterator cit = param->getIncomingEdgesBegin(PAGEdge::Call), ecit =
-                            param->getIncomingEdgesEnd(PAGEdge::Call); cit != ecit; ++cit)
+                for (SVFStmt::SVFStmtSetTy::const_iterator cit = param->getIncomingEdgesBegin(SVFStmt::Call), ecit =
+                            param->getIncomingEdgesEnd(SVFStmt::Call); cit != ecit; ++cit)
                 {
                     CallPE* callPE = SVFUtil::cast<CallPE>(*cit);
                     if (isInterestedPAGNode(callPE->getRHSVar()))
@@ -449,10 +442,10 @@ void VFG::addVFGNodes()
                 continue;
 
             CallPESet callPEs;
-            if (varParam->hasIncomingEdges(PAGEdge::Call))
+            if (varParam->hasIncomingEdges(SVFStmt::Call))
             {
-                for(PAGEdge::SVFStmtSetTy::const_iterator cit = varParam->getIncomingEdgesBegin(PAGEdge::Call),
-                        ecit = varParam->getIncomingEdgesEnd(PAGEdge::Call); cit!=ecit; ++cit)
+                for(SVFStmt::SVFStmtSetTy::const_iterator cit = varParam->getIncomingEdgesBegin(SVFStmt::Call),
+                        ecit = varParam->getIncomingEdgesEnd(SVFStmt::Call); cit!=ecit; ++cit)
                 {
                     CallPE* callPE = SVFUtil::cast<CallPE>(*cit);
                     if(isInterestedPAGNode(callPE->getRHSVar()))
@@ -471,10 +464,10 @@ void VFG::addVFGNodes()
         const PAGNode* uniqueFunRetNode = it->second;
 
         RetPESet retPEs;
-        if (uniqueFunRetNode->hasOutgoingEdges(PAGEdge::Ret))
+        if (uniqueFunRetNode->hasOutgoingEdges(SVFStmt::Ret))
         {
-            for (PAGEdge::SVFStmtSetTy::const_iterator cit = uniqueFunRetNode->getOutgoingEdgesBegin(PAGEdge::Ret),
-                    ecit = uniqueFunRetNode->getOutgoingEdgesEnd(PAGEdge::Ret);
+            for (SVFStmt::SVFStmtSetTy::const_iterator cit = uniqueFunRetNode->getOutgoingEdgesBegin(SVFStmt::Ret),
+                    ecit = uniqueFunRetNode->getOutgoingEdgesEnd(SVFStmt::Ret);
                     cit != ecit; ++cit)
             {
                 const RetPE* retPE = SVFUtil::cast<RetPE>(*cit);
@@ -488,8 +481,8 @@ void VFG::addVFGNodes()
     }
 
     // initialize llvm phi nodes (phi of top level pointers)
-    PAGEdge::SVFStmtSetTy& phis = getPAGEdgeSet(PAGEdge::Phi);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = phis.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& phis = getPAGEdgeSet(SVFStmt::Phi);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = phis.begin(), eiter =
                 phis.end(); iter != eiter; ++iter)
     {
         const PhiStmt* edge = SVFUtil::cast<PhiStmt>(*iter);
@@ -497,8 +490,8 @@ void VFG::addVFGNodes()
             addIntraPHIVFGNode(edge);
     }
     // initialize llvm binary nodes (binary operators)
-    PAGEdge::SVFStmtSetTy& binaryops = getPAGEdgeSet(PAGEdge::BinaryOp);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = binaryops.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& binaryops = getPAGEdgeSet(SVFStmt::BinaryOp);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = binaryops.begin(), eiter =
                 binaryops.end(); iter != eiter; ++iter)
     {
         const BinaryOPStmt* edge = SVFUtil::cast<BinaryOPStmt>(*iter);
@@ -506,8 +499,8 @@ void VFG::addVFGNodes()
             addBinaryOPVFGNode(edge);
     }
     // initialize llvm unary nodes (unary operators)
-    PAGEdge::SVFStmtSetTy& unaryops = getPAGEdgeSet(PAGEdge::UnaryOp);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = unaryops.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& unaryops = getPAGEdgeSet(SVFStmt::UnaryOp);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = unaryops.begin(), eiter =
                 unaryops.end(); iter != eiter; ++iter)
     {
         const UnaryOPStmt* edge = SVFUtil::cast<UnaryOPStmt>(*iter);
@@ -515,8 +508,8 @@ void VFG::addVFGNodes()
             addUnaryOPVFGNode(edge);
     }
     // initialize llvm unary nodes (unary operators)
-    PAGEdge::SVFStmtSetTy& brs = getPAGEdgeSet(PAGEdge::Branch);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = brs.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& brs = getPAGEdgeSet(SVFStmt::Branch);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = brs.begin(), eiter =
                 brs.end(); iter != eiter; ++iter)
     {
         const BranchStmt* edge = SVFUtil::cast<BranchStmt>(*iter);
@@ -524,8 +517,8 @@ void VFG::addVFGNodes()
             addBranchVFGNode(edge);
     }
     // initialize llvm cmp nodes (comparision)
-    PAGEdge::SVFStmtSetTy& cmps = getPAGEdgeSet(PAGEdge::Cmp);
-    for (PAGEdge::SVFStmtSetTy::iterator iter = cmps.begin(), eiter =
+    SVFStmt::SVFStmtSetTy& cmps = getPAGEdgeSet(SVFStmt::Cmp);
+    for (SVFStmt::SVFStmtSetTy::iterator iter = cmps.begin(), eiter =
                 cmps.end(); iter != eiter; ++iter)
     {
         const CmpStmt* edge = SVFUtil::cast<CmpStmt>(*iter);
@@ -692,8 +685,8 @@ void VFG::connectDirectVFGEdges()
     /// connect direct value-flow edges (parameter passing) for thread fork/join
     if(Options::EnableThreadCallGraph){
         /// add fork edge
-        PAGEdge::SVFStmtSetTy& forks = getPAGEdgeSet(PAGEdge::ThreadFork);
-        for (PAGEdge::SVFStmtSetTy::iterator iter = forks.begin(), eiter =
+        SVFStmt::SVFStmtSetTy& forks = getPAGEdgeSet(SVFStmt::ThreadFork);
+        for (SVFStmt::SVFStmtSetTy::iterator iter = forks.begin(), eiter =
                 forks.end(); iter != eiter; ++iter)
         {
             TDForkPE* forkedge = SVFUtil::cast<TDForkPE>(*iter);
@@ -702,8 +695,8 @@ void VFG::connectDirectVFGEdges()
             addInterEdgeFromAPToFP(acutalParm,formalParm,getCallSiteID(forkedge->getCallSite(), formalParm->getFun()));
         }
         /// add join edge
-        PAGEdge::SVFStmtSetTy& joins = getPAGEdgeSet(PAGEdge::ThreadJoin);
-        for (PAGEdge::SVFStmtSetTy::iterator iter = joins.begin(), eiter =
+        SVFStmt::SVFStmtSetTy& joins = getPAGEdgeSet(SVFStmt::ThreadJoin);
+        for (SVFStmt::SVFStmtSetTy::iterator iter = joins.begin(), eiter =
                 joins.end(); iter != eiter; ++iter)
         {
             TDJoinPE* joinedge = SVFUtil::cast<TDJoinPE>(*iter);

package/lib/MTA/MTAAnnotator.cpp

@@ -122,8 +122,8 @@ void MTAAnnotator::pruneThreadLocal(PointerAnalysis* pta)
     PointsTo worklist;
 
     /// find fork arguments' objects
-    const PAGEdge::SVFStmtSetTy& forkedges = pag->getPTASVFStmtSet(PAGEdge::ThreadFork);
-    for (PAGEdge::SVFStmtSetTy::const_iterator it = forkedges.begin(), eit = forkedges.end(); it != eit; ++it)
+    const SVFStmt::SVFStmtSetTy& forkedges = pag->getPTASVFStmtSet(SVFStmt::ThreadFork);
+    for (SVFStmt::SVFStmtSetTy::const_iterator it = forkedges.begin(), eit = forkedges.end(); it != eit; ++it)
     {
         PAGEdge* edge = *it;
         worklist |= pta->getPts(edge->getDstID());
@@ -135,7 +135,7 @@ void MTAAnnotator::pruneThreadLocal(PointerAnalysis* pta)
     for (SVFIR::SVFStmtSet::const_iterator it = globaledges.begin(), eit = globaledges.end(); it != eit; ++it)
     {
         const PAGEdge* edge = *it;
-        if (edge->getEdgeKind() == PAGEdge::Addr)
+        if (edge->getEdgeKind() == SVFStmt::Addr)
         {
             worklist.set(edge->getSrcID());
         }

package/lib/MemoryModel/PointerAnalysisImpl.cpp

@@ -154,7 +154,7 @@ void BVDataPTAImpl::writeToFile(const string& filename)
         {
             F.os() << it->first << " ";
             F.os() << pag->getBaseObjVar(it->first) << " ";
-            F.os() << gepObjPN->getFieldOffset() << "\n";
+            F.os() << gepObjPN->getConstantFieldIdx() << "\n";
         }
     }
 

package/lib/MemoryModel/SVFIR.cpp

@@ -312,7 +312,7 @@ GepStmt* SVFIR::addGepStmt(NodeID src, NodeID dst, const LocationSet& ls, bool c
     if (!constGep || node->hasIncomingVariantGepEdge())
     {
         /// Since the offset from base to src is variant,
-        /// the new gep edge being created is also a VariantGepStmt edge.
+        /// the new gep edge being created is also a Variant GepStmt edge.
         return addVariantGepStmt(src, dst, ls);
     }
     else
@@ -324,16 +324,16 @@ GepStmt* SVFIR::addGepStmt(NodeID src, NodeID dst, const LocationSet& ls, bool c
 /*!
  * Add normal (Gep) edge
  */
-NormalGepStmt* SVFIR::addNormalGepStmt(NodeID src, NodeID dst, const LocationSet& ls)
+GepStmt* SVFIR::addNormalGepStmt(NodeID src, NodeID dst, const LocationSet& ls)
 {
     const LocationSet& baseLS = getLocationSetFromBaseNode(src);
     SVFVar* baseNode = getGNode(getBaseValVar(src));
     SVFVar* dstNode = getGNode(dst);
-    if(SVFStmt* edge = hasNonlabeledEdge(baseNode, dstNode, SVFStmt::NormalGep))
-        return SVFUtil::cast<NormalGepStmt>(edge);
+    if(SVFStmt* edge = hasNonlabeledEdge(baseNode, dstNode, SVFStmt::Gep))
+        return SVFUtil::cast<GepStmt>(edge);
     else
     {
-        NormalGepStmt* gepPE = new NormalGepStmt(baseNode, dstNode, baseLS+ls);
+        GepStmt* gepPE = new GepStmt(baseNode, dstNode, baseLS+ls);
         addToStmt2TypeMap(gepPE);
         addEdge(baseNode, dstNode, gepPE);
         return gepPE;
@@ -344,16 +344,16 @@ NormalGepStmt* SVFIR::addNormalGepStmt(NodeID src, NodeID dst, const LocationSet
  * Add variant(Gep) edge
  * Find the base node id of src and connect base node to dst node
  */
-VariantGepStmt* SVFIR::addVariantGepStmt(NodeID src, NodeID dst, const LocationSet& ls)
+GepStmt* SVFIR::addVariantGepStmt(NodeID src, NodeID dst, const LocationSet& ls)
 {
     const LocationSet& baseLS = getLocationSetFromBaseNode(src);
     SVFVar* baseNode = getGNode(getBaseValVar(src));
     SVFVar* dstNode = getGNode(dst);
-    if(SVFStmt* edge = hasNonlabeledEdge(baseNode, dstNode, SVFStmt::VariantGep))
-        return SVFUtil::cast<VariantGepStmt>(edge);
+    if(SVFStmt* edge = hasNonlabeledEdge(baseNode, dstNode, SVFStmt::Gep))
+        return SVFUtil::cast<GepStmt>(edge);
     else
     {
-        VariantGepStmt* gepPE = new VariantGepStmt(baseNode, dstNode,baseLS+ls);
+        GepStmt* gepPE = new GepStmt(baseNode, dstNode,baseLS+ls, true);
         addToStmt2TypeMap(gepPE);
         addEdge(baseNode, dstNode, gepPE);
         return gepPE;
@@ -500,18 +500,13 @@ NodeBS SVFIR::getFieldsAfterCollapse(NodeID id)
 NodeID SVFIR::getBaseValVar(NodeID nodeId)
 {
     SVFVar* node  = getGNode(nodeId);
-    if (node->hasIncomingEdges(SVFStmt::NormalGep) ||  node->hasIncomingEdges(SVFStmt::VariantGep))
+    if (node->hasIncomingEdges(SVFStmt::Gep))
     {
-        SVFStmt::SVFStmtSetTy& ngeps = node->getIncomingEdges(SVFStmt::NormalGep);
-        SVFStmt::SVFStmtSetTy& vgeps = node->getIncomingEdges(SVFStmt::VariantGep);
+        SVFStmt::SVFStmtSetTy& geps = node->getIncomingEdges(SVFStmt::Gep);
 
-        assert(((ngeps.size()+vgeps.size())==1) && "one node can only be connected by at most one gep edge!");
+        assert((geps.size()==1) && "one node can only be connected by at most one gep edge!");
 
-        SVFVar::iterator it;
-        if(!ngeps.empty())
-            it = ngeps.begin();
-        else
-            it = vgeps.begin();
+        SVFVar::iterator it = geps.begin();
 
         assert(SVFUtil::isa<GepStmt>(*it) && "not a gep edge??");
         return (*it)->getSrcID();
@@ -529,17 +524,18 @@ NodeID SVFIR::getBaseValVar(NodeID nodeId)
 LocationSet SVFIR::getLocationSetFromBaseNode(NodeID nodeId)
 {
     SVFVar* node  = getGNode(nodeId);
-    SVFStmt::SVFStmtSetTy& geps = node->getIncomingEdges(SVFStmt::NormalGep);
+    SVFStmt::SVFStmtSetTy& geps = node->getIncomingEdges(SVFStmt::Gep);
     /// if this node is already a base node
     if(geps.empty())
         return LocationSet(0);
 
     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<NormalGepStmt>(edge) && "not a get edge??");
-    const NormalGepStmt* gepEdge = SVFUtil::cast<NormalGepStmt>(edge);
-    return gepEdge->getLocationSet();
+    const GepStmt* gepEdge = SVFUtil::cast<GepStmt>(*it);
+    if(gepEdge->isVariantFieldGep())
+        return LocationSet(0);
+    else
+        return gepEdge->getLocationSet();
 }
 
 /*!
@@ -606,21 +602,17 @@ void SVFIR::print()
                << (*iter)->getDstID() << "\n";
     }
 
-    SVFStmt::SVFStmtSetTy& ngeps = pag->getSVFStmtSet(SVFStmt::NormalGep);
+    SVFStmt::SVFStmtSetTy& ngeps = pag->getSVFStmtSet(SVFStmt::Gep);
     for (SVFStmt::SVFStmtSetTy::iterator iter = ngeps.begin(), eiter =
                 ngeps.end(); iter != eiter; ++iter)
     {
-        NormalGepStmt* gep = SVFUtil::cast<NormalGepStmt>(*iter);
-        outs() << gep->getRHSVarID() << " -- NormalGep (" << gep->getFieldOffset()
-               << ") --> " << gep->getLHSVarID() << "\n";
-    }
-
-    SVFStmt::SVFStmtSetTy& vgeps = pag->getSVFStmtSet(SVFStmt::VariantGep);
-    for (SVFStmt::SVFStmtSetTy::iterator iter = vgeps.begin(), eiter =
-                vgeps.end(); iter != eiter; ++iter)
-    {
-        outs() << (*iter)->getSrcID() << " -- VariantGep --> "
+        GepStmt* gep = SVFUtil::cast<GepStmt>(*iter);
+        if(gep->isVariantFieldGep())
+                outs() << (*iter)->getSrcID() << " -- VariantGep --> "
                << (*iter)->getDstID() << "\n";
+        else
+                outs() << gep->getRHSVarID() << " -- Gep (" << gep->getConstantFieldIdx()
+               << ") --> " << gep->getLHSVarID() << "\n";
     }
 
     SVFStmt::SVFStmtSetTy& loads = pag->getSVFStmtSet(SVFStmt::Load);

package/lib/MemoryModel/SVFStatements.cpp

@@ -186,28 +186,6 @@ const std::string GepStmt::toString() const{
     return rawstr.str();
 }
 
-const std::string NormalGepStmt::toString() const{
-    std::string str;
-    raw_string_ostream rawstr(str);
-    rawstr << "NormalGepStmt: [Var" << getLHSVarID() << " <-- Var" << getRHSVarID() << "]\t";
-    if (Options::ShowSVFIRValue) {
-        rawstr << "\n";
-        rawstr << value2String(getValue());
-    }
-    return rawstr.str();
-}
-
-const std::string VariantGepStmt::toString() const{
-    std::string str;
-    raw_string_ostream rawstr(str);
-    rawstr << "VariantGepStmt: [Var" << getLHSVarID() << " <-- Var" << getRHSVarID() << "]\t";
-    if (Options::ShowSVFIRValue) {
-        rawstr << "\n";
-        rawstr << value2String(getValue());
-    }
-    return rawstr.str();
-}
-
 const std::string CallPE::toString() const{
     std::string str;
     raw_string_ostream rawstr(str);

package/lib/MemoryModel/SVFVariables.cpp

@@ -133,7 +133,7 @@ const std::string ObjVar::toString() const {
 const std::string GepValVar::toString() const {
     std::string str;
     raw_string_ostream rawstr(str);
-    rawstr << "GepValVar ID: " << getId() << " with offset_" + llvm::utostr(getFieldOffset());
+    rawstr << "GepValVar ID: " << getId() << " with offset_" + llvm::utostr(getConstantFieldIdx());
     if (Options::ShowSVFIRValue) {
         rawstr << "\n";
         rawstr << value2String(value);

package/lib/MemoryModel/SymbolTableInfo.cpp

@@ -582,7 +582,7 @@ bool ObjTypeInfo::isNonPtrFieldObj(const LocationSet& ls)
             //       as we simply return new offset by mod operation without checking its
             //       correctness in LocSymTableInfo::getModulusOffset(). So the following
             //       assertion may fail. Try to refine the new memory model.
-            //assert(ls.getFieldOffset() == 0 && "cannot get a field from a non-struct type");
+            //assert(ls.getConstantFieldIdx() == 0 && "cannot get a field from a non-struct type");
             return (hasPtrObj() == false);
         }
     }

package/lib/SVF-FE/DCHG.cpp

@@ -103,7 +103,7 @@ void DCHGraph::handleDIDerivedType(const DIDerivedType *derivedType)
         assert(SVFUtil::isa<DIType>(derivedType->getScope()) && "inheriting from non-type?");
         DCHEdge *edge = addEdge(SVFUtil::dyn_cast<DIType>(derivedType->getScope()),
                                 derivedType->getBaseType(), DCHEdge::INHERITANCE);
-        // If the offset does not exist (for primary base), getFieldOffset should return 0.
+        // If the offset does not exist (for primary base), getConstantFieldIdx should return 0.
         edge->setOffset(derivedType->getOffsetInBits());
         break;
     }

package/lib/SVF-FE/Graph2Json.cpp

@@ -50,10 +50,10 @@ void ICFGPrinter::printICFGToJson(const std::string& filename)
                 edge_obj["Edge Type"] = getPAGEdgeKindValue(edge->getEdgeKind());
                 edge_obj["srcValueName"] = edge->getSrcNode()->getValueName();
                 edge_obj["dstValueName"] = edge->getDstNode()->getValueName();
-                if(edge->getEdgeKind()==PAGEdge::NormalGep)
+                if(edge->getEdgeKind()==SVFStmt::Gep)
                 {
-                    const NormalGepStmt* gepEdge = SVFUtil::cast<NormalGepStmt>(edge);
-                    edge_obj["offset"] = gepEdge->getFieldOffset();
+                    const GepStmt* gepEdge = SVFUtil::cast<GepStmt>(edge);
+                    edge_obj["offset"] = gepEdge->getConstantFieldIdx();
                 }
                 llvm::json::Value edge_value = llvm::json::Object{edge_obj};
                 PAGEdge_array.push_back(edge_value);
@@ -169,31 +169,31 @@ std::string ICFGPrinter::getPAGNodeKindValue(int kind)
 {
     switch (kind)
     {
-    case (PAGNode::ValNode):
+    case (SVFVar::ValNode):
         return "ValNode";
         break;
-    case PAGNode::ObjNode:
+    case SVFVar::ObjNode:
         return "ObjNode";
         break;
-    case PAGNode::RetNode:
+    case SVFVar::RetNode:
         return "RetNode";
         break;
-    case PAGNode::VarargNode:
+    case SVFVar::VarargNode:
         return "VarargNode";
         break;
-    case PAGNode::GepValNode:
+    case SVFVar::GepValNode:
         return "GepValNode";
         break;
-    case PAGNode::GepObjNode:
+    case SVFVar::GepObjNode:
         return "GepObjNode";
         break;
-    case PAGNode::FIObjNode:
+    case SVFVar::FIObjNode:
         return "FIObjNode";
         break;
-    case PAGNode::DummyValNode:
+    case SVFVar::DummyValNode:
         return "DummyValNode";
         break;
-    case PAGNode::DummyObjNode:
+    case SVFVar::DummyObjNode:
         return "DummyObjNode";
         break;
     }
@@ -204,43 +204,40 @@ std::string ICFGPrinter::getPAGEdgeKindValue(int kind)
 {
     switch(kind)
     {
-    case (PAGEdge::Addr):
+    case (SVFStmt::Addr):
         return "Addr";
         break;
-    case (PAGEdge::Copy):
+    case (SVFStmt::Copy):
         return "Copy";
         break;
-    case (PAGEdge::Store):
+    case (SVFStmt::Store):
         return "Store";
         break;
-    case (PAGEdge::Load):
+    case (SVFStmt::Load):
         return "Load";
         break;
-    case (PAGEdge::Call):
+    case (SVFStmt::Call):
         return "Call";
         break;
-    case (PAGEdge::Ret):
+    case (SVFStmt::Ret):
         return "Ret";
         break;
-    case (PAGEdge::NormalGep):
+    case (SVFStmt::Gep):
         return "NormalGep";
         break;
-    case (PAGEdge::VariantGep):
-        return "VariantGep";
-        break;
-    case (PAGEdge::ThreadFork):
+    case (SVFStmt::ThreadFork):
         return "ThreadFork";
         break;
-    case (PAGEdge::ThreadJoin):
+    case (SVFStmt::ThreadJoin):
         return "ThreadJoin";
         break;
-    case (PAGEdge::Cmp):
+    case (SVFStmt::Cmp):
         return "Cmp";
         break;
-    case (PAGEdge::BinaryOp):
+    case (SVFStmt::BinaryOp):
         return "BinaryOp";
         break;
-    case (PAGEdge::UnaryOp):
+    case (SVFStmt::UnaryOp):
         return "UnaryOp";
         break;
     }

package/lib/Util/PTAStat.cpp

@@ -48,7 +48,7 @@ const char* PTAStat:: TotalNumOfPointers = "TotalPointers";	///< SVFIR value nod
 const char* PTAStat:: TotalNumOfObjects = "TotalObjects";	///< Total SVFIR object node
 const char* PTAStat:: TotalNumOfFieldObjects = "TotalFieldObjects";	///< Total SVFIR field object node
 const char* PTAStat:: MaxStructSize = "MaxStructSize";	///< Max struct size (bytes)
-const char* PTAStat:: TotalNumOfEdges = "TotalPAGEdges";	///< Total SVFIR edge number
+const char* PTAStat:: TotalNumOfEdges = "TotalSVFStmts";	///< Total SVFIR edge number
 
 const char* PTAStat:: NumOfFunctionObjs = "FunctionObjs";	///< function numbers
 const char* PTAStat:: NumOfGlobalObjs = "GlobalObjs";	///< SVFIR global object node
@@ -198,17 +198,17 @@ void PTAStat::performStat()
     generalNumMap[TotalNumOfFieldObjects] = pag->getFieldObjNodeNum();
     generalNumMap[MaxStructSize] = SymbolTableInfo::SymbolInfo()->getMaxStructSize();
     generalNumMap[TotalNumOfEdges] = pag->getPAGEdgeNum();
-    generalNumMap["TotalPTAPAGEdges"] = pag->getPTAPAGEdgeNum();
+    generalNumMap["TotalPTASVFStmts"] = pag->getPTAPAGEdgeNum();
     generalNumMap[NumberOfFieldInsensitiveObj] = fiObjNumber;
     generalNumMap[NumberOfFieldSensitiveObj] = fsObjNumber;
 
-    generalNumMap[NumOfAddrs] = pag->getSVFStmtSet(PAGEdge::Addr).size();
-    generalNumMap[NumOfLoads] = pag->getSVFStmtSet(PAGEdge::Load).size();
-    generalNumMap[NumOfStores] = pag->getSVFStmtSet(PAGEdge::Store).size();
-    generalNumMap[NumOfCopys] =  pag->getSVFStmtSet(PAGEdge::Copy).size();
-    generalNumMap[NumOfGeps] =  pag->getSVFStmtSet(PAGEdge::NormalGep).size() + pag->getSVFStmtSet(PAGEdge::VariantGep).size();
-    generalNumMap[NumOfCalls] = pag->getSVFStmtSet(PAGEdge::Call).size();
-    generalNumMap[NumOfReturns] = pag->getSVFStmtSet(PAGEdge::Ret).size();
+    generalNumMap[NumOfAddrs] = pag->getSVFStmtSet(SVFStmt::Addr).size();
+    generalNumMap[NumOfLoads] = pag->getSVFStmtSet(SVFStmt::Load).size();
+    generalNumMap[NumOfStores] = pag->getSVFStmtSet(SVFStmt::Store).size();
+    generalNumMap[NumOfCopys] =  pag->getSVFStmtSet(SVFStmt::Copy).size();
+    generalNumMap[NumOfGeps] =  pag->getSVFStmtSet(SVFStmt::Gep).size();
+    generalNumMap[NumOfCalls] = pag->getSVFStmtSet(SVFStmt::Call).size();
+    generalNumMap[NumOfReturns] = pag->getSVFStmtSet(SVFStmt::Ret).size();
 
     generalNumMap[NumOfFunctionObjs] = numOfFunction;
     generalNumMap[NumOfGlobalObjs] = numOfGlobal;

package/lib/Util/TypeBasedHeapCloning.cpp

@@ -155,7 +155,7 @@ const NodeBS TypeBasedHeapCloning::getGepObjClones(NodeID base, unsigned offset)
     s64_t totalOffset = offset;
     if (const GepObjVar *baseGep = SVFUtil::dyn_cast<GepObjVar>(baseNode))
     {
-        totalOffset += baseGep->getFieldOffset();
+        totalOffset += baseGep->getConstantFieldIdx();
     }
 
     const DIType *baseType = getType(base);
@@ -189,7 +189,7 @@ const NodeBS TypeBasedHeapCloning::getGepObjClones(NodeID base, unsigned offset)
 
         if (GepObjVar *gepNode = SVFUtil::dyn_cast<GepObjVar>(node))
         {
-            if (gepNode->getFieldOffset() == totalOffset)
+            if (gepNode->getConstantFieldIdx() == totalOffset)
             {
                 geps.set(gep);
             }
@@ -211,7 +211,7 @@ const NodeBS TypeBasedHeapCloning::getGepObjClones(NodeID base, unsigned offset)
         // No gep node has even be created, so create one.
         NodeID newGep;
         LocationSet newLS;
-        // fldIdx is what is returned by getFieldOffset.
+        // fldIdx is what is returned by getConstantFieldIdx.
         newLS.setFldIdx(totalOffset);
 
         if (isClone(base))
@@ -414,7 +414,7 @@ NodeID TypeBasedHeapCloning::cloneObject(NodeID o, const DIType *type, bool)
     const PAGNode *obj = ppag->getGNode(o);
     if (const GepObjVar *gepObj = SVFUtil::dyn_cast<GepObjVar>(obj))
     {
-        const NodeBS &clones = getGepObjClones(gepObj->getBaseNode(), gepObj->getFieldOffset());
+        const NodeBS &clones = getGepObjClones(gepObj->getBaseNode(), gepObj->getConstantFieldIdx());
         // TODO: a bit of repetition.
         for (NodeID clone : clones)
         {
@@ -427,7 +427,7 @@ NodeID TypeBasedHeapCloning::cloneObject(NodeID o, const DIType *type, bool)
         clone = addCloneGepObjNode(gepObj->getMemObj(), gepObj->getLocationSet());
 
         // The base needs to know about the new clone.
-        addGepToObj(clone, gepObj->getBaseNode(), gepObj->getFieldOffset());
+        addGepToObj(clone, gepObj->getBaseNode(), gepObj->getConstantFieldIdx());
 
         addClone(o, clone);
         addClone(getOriginalObj(o), clone);

package/lib/WPA/AndersenSFR.cpp

@@ -96,7 +96,7 @@ bool AndersenSFR::processGepPts(PointsTo& pts, const GepCGEdge* edge)
             for (NodeID ptd : srcInits)
                 sortSrcInits.insert(ptd);
 
-            s64_t offset = SVFUtil::dyn_cast<NormalGepCGEdge>(edge)->getFieldOffset();
+            s64_t offset = SVFUtil::dyn_cast<NormalGepCGEdge>(edge)->getConstantFieldIdx();
             fieldExpand(sortSrcInits, offset, dst->strides, tmpDstPts);
         }
 
@@ -134,7 +134,7 @@ void AndersenSFR::fieldExpand(NodeSet& initials, s64_t offset, NodeBS& strides,
             const u32_t maxLimit = obj->getMaxFieldOffsetLimit();
             s64_t initOffset;
             if (GepObjVar *gepNode = SVFUtil::dyn_cast<GepObjVar>(initPN))
-                initOffset = gepNode->getFieldOffset();
+                initOffset = gepNode->getConstantFieldIdx();
             else if (SVFUtil::isa<FIObjVar>(initPN) || SVFUtil::isa<DummyObjVar>(initPN))
                 initOffset = 0;
             else

package/lib/WPA/AndersenStat.cpp

@@ -228,8 +228,8 @@ void AndersenStat::statNullPtr()
         PAGNode* pagNode = iter->second;
         if (pagNode->isTopLevelPtr() == false)
             continue;
-        PAGEdge::SVFStmtSetTy& inComingStore = pagNode->getIncomingEdges(PAGEdge::Store);
-        PAGEdge::SVFStmtSetTy& outGoingLoad = pagNode->getOutgoingEdges(PAGEdge::Load);
+        SVFStmt::SVFStmtSetTy& inComingStore = pagNode->getIncomingEdges(SVFStmt::Store);
+        SVFStmt::SVFStmtSetTy& outGoingLoad = pagNode->getOutgoingEdges(SVFStmt::Load);
         if (inComingStore.empty()==false || outGoingLoad.empty()==false)
         {
             ///TODO: change the condition here to fetch the points-to set

package/lib/WPA/CSC.cpp

@@ -87,7 +87,7 @@ void CSC::visit(NodeID nodeId, s64_t _w)
     {
         s64_t offset;
         if (NormalGepCGEdge* gepCGEdge = SVFUtil::dyn_cast<NormalGepCGEdge>(*eit))
-            offset = gepCGEdge->getFieldOffset();
+            offset = gepCGEdge->getConstantFieldIdx();
         else
             offset = 0;
         NodeID dstId = (*eit)->getDstID();
@@ -107,7 +107,7 @@ void CSC::visit(NodeID nodeId, s64_t _w)
         if (_consG->hasEdge(node, backNode, ConstraintEdge::NormalGep))
         {
             NormalGepCGEdge* normalGep = SVFUtil::dyn_cast<NormalGepCGEdge>(_consG->getEdge(node, backNode, ConstraintEdge::NormalGep));
-            s64_t _w = normalGep->getFieldOffset();
+            s64_t _w = normalGep->getConstantFieldIdx();
             s64_t _l = _D[nodeId] +_w - _D[backNodeId];
             backNode->strides.set(_l);
             for (auto cNodeId : _C)