svf-tools 1.0.733 → 1.0.734

package/svf/lib/MemoryModel/{LocationSet.cpp → AccessPath.cpp}

@@ -1,4 +1,4 @@
-//===- LocationSet.cpp -- Location set for modeling abstract memory object----//
+//===- AccessPath.cpp -- Location set for modeling abstract memory object----//
 //
 //                     SVF: Static Value-Flow Analysis
 //
@@ -21,7 +21,7 @@
 //===----------------------------------------------------------------------===//
 
 /*
- * @file: LocationSet.cpp
+ * @file: AccessPath.cpp
  * @author: yesen
  * @date: 26 Sep 2014
  *
@@ -30,7 +30,7 @@
  */
 
 #include "Util/Options.h"
-#include "MemoryModel/LocationSet.h"
+#include "MemoryModel/AccessPath.h"
 #include "Util/SVFUtil.h"
 
 using namespace SVF;
@@ -39,14 +39,14 @@ using namespace SVFUtil;
 /*!
  * Add offset value to vector offsetVarAndGepTypePairs
  */
-bool LocationSet::addOffsetVarAndGepTypePair(const SVFVar* var, const SVFType* gepIterType)
+bool AccessPath::addOffsetVarAndGepTypePair(const SVFVar* var, const SVFType* gepIterType)
 {
     offsetVarAndGepTypePairs.emplace_back(var, gepIterType);
     return true;
 }
 
 /// Return true if all offset values are constants
-bool LocationSet::isConstantOffset() const
+bool AccessPath::isConstantOffset() const
 {
     for(auto it : offsetVarAndGepTypePairs)
     {
@@ -60,7 +60,7 @@ bool LocationSet::isConstantOffset() const
 /// (1) StructType or Array, return flatterned number elements.
 /// (2) PointerType, return the element number of the pointee
 /// (3) non-pointer SingleValueType, return 1
-u32_t LocationSet::getElementNum(const SVFType* type) const
+u32_t AccessPath::getElementNum(const SVFType* type) const
 {
 
     if (SVFUtil::isa<SVFArrayType, SVFStructType>(type))
@@ -115,7 +115,7 @@ u32_t LocationSet::getElementNum(const SVFType* type) const
 ///     value1: i64 0  type1: [3 x i8]*
 ///     value2: i64 2  type2: [3 x i8]
 ///     computeConstantOffset = 2
-s32_t LocationSet::computeConstantOffset() const
+APOffset AccessPath::computeConstantOffset() const
 {
 
     assert(isConstantOffset() && "not a constant offset");
@@ -123,7 +123,7 @@ s32_t LocationSet::computeConstantOffset() const
     if(offsetVarAndGepTypePairs.empty())
         return getConstantFieldIdx();
 
-    s32_t totalConstOffset = 0;
+    APOffset totalConstOffset = 0;
     for(int i = offsetVarAndGepTypePairs.size() - 1; i >= 0; i--)
     {
         const SVFValue* value = offsetVarAndGepTypePairs[i].first->getValue();
@@ -140,7 +140,7 @@ s32_t LocationSet::computeConstantOffset() const
             totalConstOffset += op->getSExtValue() * getElementNum(pty->getPtrElementType());
         else
         {
-            s32_t offset = op->getSExtValue();
+            APOffset offset = op->getSExtValue();
             u32_t flattenOffset = SymbolTableInfo::SymbolInfo()->getFlattenedElemIdx(type, offset);
             totalConstOffset += flattenOffset;
         }
@@ -150,16 +150,16 @@ s32_t LocationSet::computeConstantOffset() const
 /*!
  * Compute all possible locations according to offset and number-stride pairs.
  */
-NodeBS LocationSet::computeAllLocations() const
+NodeBS AccessPath::computeAllLocations() const
 {
     NodeBS result;
     result.set(getConstantFieldIdx());
     return result;
 }
 
-LocationSet LocationSet::operator+ (const LocationSet& rhs) const
+AccessPath AccessPath::operator+ (const AccessPath& rhs) const
 {
-    LocationSet ls(rhs);
+    AccessPath ls(rhs);
     ls.fldIdx += getConstantFieldIdx();
     OffsetVarAndGepTypePairs::const_iterator it = getOffsetVarAndGepTypePairVec().begin();
     OffsetVarAndGepTypePairs::const_iterator eit = getOffsetVarAndGepTypePairVec().end();
@@ -170,7 +170,7 @@ LocationSet LocationSet::operator+ (const LocationSet& rhs) const
 }
 
 
-bool LocationSet::operator< (const LocationSet& rhs) const
+bool AccessPath::operator< (const AccessPath& rhs) const
 {
     if (fldIdx != rhs.fldIdx)
         return (fldIdx < rhs.fldIdx);
@@ -194,7 +194,7 @@ bool LocationSet::operator< (const LocationSet& rhs) const
     }
 }
 
-SVF::LocationSet::LSRelation LocationSet::checkRelation(const LocationSet& LHS, const LocationSet& RHS)
+SVF::AccessPath::LSRelation AccessPath::checkRelation(const AccessPath& LHS, const AccessPath& RHS)
 {
     NodeBS lhsLocations = LHS.computeAllLocations();
     NodeBS rhsLocations = RHS.computeAllLocations();
@@ -216,12 +216,12 @@ SVF::LocationSet::LSRelation LocationSet::checkRelation(const LocationSet& LHS,
 }
 
 /// Dump location set
-std::string LocationSet::dump() const
+std::string AccessPath::dump() const
 {
     std::string str;
     std::stringstream rawstr(str);
 
-    rawstr << "LocationSet\tField_Index: " << getConstantFieldIdx();
+    rawstr << "AccessPath\tField_Index: " << getConstantFieldIdx();
     rawstr << ",\tNum-Stride: {";
     const OffsetVarAndGepTypePairs& vec = getOffsetVarAndGepTypePairVec();
     OffsetVarAndGepTypePairs::const_iterator it = vec.begin();

package/svf/lib/MemoryModel/PointerAnalysisImpl.cpp

@@ -366,7 +366,7 @@ bool BVDataPTAImpl::readFromFile(const string& filename)
         NodeID base;
         size_t offset;
         ss >> id >> base >> offset;
-        NodeID n = pag->getGepObjVar(base, LocationSet(offset));
+        NodeID n = pag->getGepObjVar(base, offset);
         bool matched = (id == n);
         (void)matched;
         assert(matched && "Error adding GepObjNode into SVFIR!");
@@ -480,7 +480,7 @@ void BVDataPTAImpl::onTheFlyCallGraphSolve(const CallSiteToFunPtrMap& callsites,
 void BVDataPTAImpl::normalizePointsTo()
 {
     SVFIR::MemObjToFieldsMap &memToFieldsMap = pag->getMemToFieldsMap();
-    SVFIR::NodeLocationSetMap &GepObjVarMap = pag->getGepObjNodeMap();
+    SVFIR::NodeOffsetMap &GepObjVarMap = pag->getGepObjNodeMap();
 
     // collect each gep node whose base node has been set as field-insensitive
     NodeBS dropNodes;
@@ -525,7 +525,7 @@ void BVDataPTAImpl::normalizePointsTo()
     {
         NodeID base = pag->getBaseObjVar(n);
         GepObjVar *gepNode = SVFUtil::dyn_cast<GepObjVar>(pag->getGNode(n));
-        const LocationSet ls = gepNode->getLocationSet();
+        const APOffset ls = gepNode->getConstantFieldIdx();
         GepObjVarMap.erase(std::make_pair(base, ls));
         memToFieldsMap[base].reset(n);
 

package/svf/lib/SVFIR/PAGBuilderFromFile.cpp

@@ -103,7 +103,7 @@ SVFIR* PAGBuilderFromFile::build()
             {
                 NodeID nodeSrc;
                 NodeID nodeDst;
-                s32_t offsetOrCSId;
+                APOffset offsetOrCSId;
                 string edge;
                 istringstream ss(line);
                 ss >> nodeSrc;
@@ -144,7 +144,7 @@ SVFIR* PAGBuilderFromFile::build()
  * Add SVFIR edge according to a file format
  */
 void PAGBuilderFromFile::addEdge(NodeID srcID, NodeID dstID,
-                                 s32_t offsetOrCSId, std::string edge)
+                                 APOffset offsetOrCSId, std::string edge)
 {
 
     //check whether these two nodes available
@@ -169,9 +169,9 @@ void PAGBuilderFromFile::addEdge(NodeID srcID, NodeID dstID,
     else if (edge == "store")
         pag->addStoreStmt(srcID, dstID, nullptr);
     else if (edge == "gep")
-        pag->addNormalGepStmt(srcID, dstID, LocationSet(offsetOrCSId));
+        pag->addNormalGepStmt(srcID, dstID, AccessPath(offsetOrCSId));
     else if (edge == "variant-gep")
-        pag->addVariantGepStmt(srcID, dstID, LocationSet(offsetOrCSId));
+        pag->addVariantGepStmt(srcID, dstID, AccessPath(offsetOrCSId));
     else if (edge == "call")
         pag->addEdge(srcNode, dstNode, new CallPE(srcNode, dstNode, nullptr, nullptr));
     else if (edge == "ret")

package/svf/lib/SVFIR/SVFFileSystem.cpp

@@ -1240,7 +1240,7 @@ cJSON* SVFIRWriter::toJson(const StInfo* stInfo)
     return jsonCreateIndex(svfModuleWriter.getStInfoID(stInfo));
 }
 
-cJSON* SVFIRWriter::toJson(const LocationSet& ls)
+cJSON* SVFIRWriter::toJson(const AccessPath& ls)
 {
     cJSON* root = jsonCreateObject();
     JSON_WRITE_FIELD(root, &ls, fldIdx);
@@ -1844,13 +1844,13 @@ void SVFIRReader::readJson(const cJSON* obj, CallSite& cs)
     readJson(obj, cs.CB);
 }
 
-void SVFIRReader::readJson(const cJSON* obj, LocationSet& ls)
+void SVFIRReader::readJson(const cJSON* obj, AccessPath& ls)
 {
-    ABORT_IFNOT(jsonIsObject(obj), "Expected obj for LocationSet");
+    ABORT_IFNOT(jsonIsObject(obj), "Expected obj for AccessPath");
     obj = obj->child;
     JSON_READ_FIELD_FWD(obj, &ls, fldIdx);
     JSON_READ_FIELD_FWD(obj, &ls, offsetVarAndGepTypePairs);
-    ABORT_IFNOT(!obj, "Extra field " << JSON_KEY(obj) << " in LocationSet");
+    ABORT_IFNOT(!obj, "Extra field " << JSON_KEY(obj) << " in AccessPath");
 }
 
 void SVFIRReader::readJson(const cJSON* obj, SVFLoop*& loop)

package/svf/lib/SVFIR/SVFIR.cpp

@@ -324,7 +324,7 @@ TDJoinPE* SVFIR::addThreadJoinPE(NodeID src, NodeID dst, const CallICFGNode* cs,
  * Find the base node id of src and connect base node to dst node
  * Create gep offset:  (offset + baseOff <nested struct gep size>)
  */
-GepStmt* SVFIR::addGepStmt(NodeID src, NodeID dst, const LocationSet& ls, bool constGep)
+GepStmt* SVFIR::addGepStmt(NodeID src, NodeID dst, const AccessPath& ls, bool constGep)
 {
 
     SVFVar* node = getGNode(src);
@@ -343,7 +343,7 @@ GepStmt* SVFIR::addGepStmt(NodeID src, NodeID dst, const LocationSet& ls, bool c
 /*!
  * Add normal (Gep) edge
  */
-GepStmt* SVFIR::addNormalGepStmt(NodeID src, NodeID dst, const LocationSet& ls)
+GepStmt* SVFIR::addNormalGepStmt(NodeID src, NodeID dst, const AccessPath& ls)
 {
     SVFVar* baseNode = getGNode(src);
     SVFVar* dstNode = getGNode(dst);
@@ -362,7 +362,7 @@ GepStmt* SVFIR::addNormalGepStmt(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
  */
-GepStmt* SVFIR::addVariantGepStmt(NodeID src, NodeID dst, const LocationSet& ls)
+GepStmt* SVFIR::addVariantGepStmt(NodeID src, NodeID dst, const AccessPath& ls)
 {
     SVFVar* baseNode = getGNode(src);
     SVFVar* dstNode = getGNode(dst);
@@ -383,7 +383,7 @@ GepStmt* SVFIR::addVariantGepStmt(NodeID src, NodeID dst, const LocationSet& ls)
  * 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 SVFValue* curInst,const SVFValue* gepVal, const LocationSet& ls, NodeID i, const SVFType* type)
+NodeID SVFIR::addGepValNode(const SVFValue* curInst,const SVFValue* gepVal, const AccessPath& ls, NodeID i, const SVFType* type)
 {
     NodeID base = getBaseValVar(getValueNode(gepVal));
     //assert(findPAGNode(i) == false && "this node should not be created before");
@@ -397,11 +397,11 @@ NodeID SVFIR::addGepValNode(const SVFValue* curInst,const SVFValue* gepVal, cons
 /*!
  * Given an object node, find its field object node
  */
-NodeID SVFIR::getGepObjVar(NodeID id, const LocationSet& ls)
+NodeID SVFIR::getGepObjVar(NodeID id, const APOffset& ls)
 {
     SVFVar* node = pag->getGNode(id);
     if (GepObjVar* gepNode = SVFUtil::dyn_cast<GepObjVar>(node))
-        return getGepObjVar(gepNode->getMemObj(), gepNode->getLocationSet() + ls);
+        return getGepObjVar(gepNode->getMemObj(), gepNode->getConstantFieldIdx() + ls);
     else if (FIObjVar* baseNode = SVFUtil::dyn_cast<FIObjVar>(node))
         return getGepObjVar(baseNode->getMemObj(), ls);
     else if (DummyObjVar* baseNode = SVFUtil::dyn_cast<DummyObjVar>(node))
@@ -419,7 +419,7 @@ NodeID SVFIR::getGepObjVar(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::getGepObjVar(const MemObj* obj, const LocationSet& ls)
+NodeID SVFIR::getGepObjVar(const MemObj* obj, const APOffset& ls)
 {
     NodeID base = obj->getId();
 
@@ -427,12 +427,12 @@ NodeID SVFIR::getGepObjVar(const MemObj* obj, const LocationSet& ls)
     if (obj->isFieldInsensitive())
         return getFIObjVar(obj);
 
-    LocationSet newLS = pag->getSymbolInfo()->getModulusOffset(obj,ls);
+    APOffset newLS = pag->getSymbolInfo()->getModulusOffset(obj,ls);
 
     // Base and first field are the same memory location.
-    if (Options::FirstFieldEqBase() && newLS.getConstantFieldIdx() == 0) return base;
+    if (Options::FirstFieldEqBase() && newLS == 0) return base;
 
-    NodeLocationSetMap::iterator iter = GepObjVarMap.find(std::make_pair(base, newLS));
+    NodeOffsetMap::iterator iter = GepObjVarMap.find(std::make_pair(base, newLS));
     if (iter == GepObjVarMap.end())
         return addGepObjNode(obj, newLS);
     else
@@ -443,14 +443,14 @@ NodeID SVFIR::getGepObjVar(const MemObj* obj, const LocationSet& ls)
 /*!
  * Add a field obj node, this method can only invoked by getGepObjVar
  */
-NodeID SVFIR::addGepObjNode(const MemObj* obj, const LocationSet& ls)
+NodeID SVFIR::addGepObjNode(const MemObj* obj, const APOffset& ls)
 {
     //assert(findPAGNode(i) == false && "this node should not be created before");
     NodeID base = obj->getId();
     assert(0==GepObjVarMap.count(std::make_pair(base, ls))
            && "this node should not be created before");
 
-    NodeID gepId = NodeIDAllocator::get()->allocateGepObjectId(base, ls.getConstantFieldIdx(), Options::MaxFieldLimit());
+    NodeID gepId = NodeIDAllocator::get()->allocateGepObjectId(base, ls, Options::MaxFieldLimit());
     GepObjVarMap[std::make_pair(base, ls)] = gepId;
     GepObjVar *node = new GepObjVar(obj, gepId, ls);
     memToFieldsMap[base].set(gepId);
@@ -535,7 +535,7 @@ NodeID SVFIR::getBaseValVar(NodeID nodeId)
 /*!
  * It is used to create a dummy GepValVar during global initiailzation.
  */
-NodeID SVFIR::getGepValVar(const SVFValue* curInst, NodeID base, const LocationSet& ls) const
+NodeID SVFIR::getGepValVar(const SVFValue* curInst, NodeID base, const AccessPath& ls) const
 {
     GepValueVarMap::const_iterator iter = GepValObjMap.find(curInst);
     if(iter==GepValObjMap.end())
@@ -544,7 +544,7 @@ NodeID SVFIR::getGepValVar(const SVFValue* curInst, NodeID base, const LocationS
     }
     else
     {
-        NodeLocationSetMap::const_iterator lit = iter->second.find(std::make_pair(base, ls));
+        NodeAccessPathMap::const_iterator lit = iter->second.find(std::make_pair(base, ls));
         if(lit==iter->second.end())
             return UINT_MAX;
         else
@@ -679,7 +679,7 @@ bool SVFIR::isNonPointerObj(NodeID id) const
     }
     else if (const GepObjVar* gepNode = SVFUtil::dyn_cast<GepObjVar>(node))
     {
-        return (gepNode->getMemObj()->isNonPtrFieldObj(gepNode->getLocationSet()));
+        return (gepNode->getMemObj()->isNonPtrFieldObj(gepNode->getConstantFieldIdx()));
     }
     else if (const DummyObjVar* dummyNode = SVFUtil::dyn_cast<DummyObjVar>(node))
     {

package/svf/lib/SVFIR/SVFVariables.cpp

@@ -145,7 +145,7 @@ const std::string GepObjVar::toString() const
 {
     std::string str;
     std::stringstream rawstr(str);
-    rawstr << "GepObjVar ID: " << getId() << " with offset_" + std::to_string(ls.getConstantFieldIdx());
+    rawstr << "GepObjVar ID: " << getId() << " with offset_" + std::to_string(ls);
     if (Options::ShowSVFIRValue())
     {
         rawstr << "\n";

package/svf/lib/SVFIR/SymbolTableInfo.cpp

@@ -91,14 +91,14 @@ SymbolTableInfo* SymbolTableInfo::SymbolInfo()
 /*!
  * Get modulus offset given the type information
  */
-LocationSet SymbolTableInfo::getModulusOffset(const MemObj* obj, const LocationSet& ls)
+APOffset SymbolTableInfo::getModulusOffset(const MemObj* obj, const APOffset& ls)
 {
 
     /// if the offset is negative, it's possible that we're looking for an obj node out of range
     /// of current struct. Make the offset positive so we can still get a node within current
     /// struct to represent this obj.
 
-    s32_t offset = ls.getConstantFieldIdx();
+    APOffset offset = ls;
     if(offset < 0)
     {
         writeWrnMsg("try to create a gep node with negative offset.");
@@ -132,7 +132,7 @@ LocationSet SymbolTableInfo::getModulusOffset(const MemObj* obj, const LocationS
             offset = maxOffset - 1;
     }
 
-    return LocationSet(offset);
+    return offset;
 }
 
 
@@ -368,7 +368,7 @@ void SymbolTableInfo::dump()
 /*!
  * Whether a location set is a pointer type or not
  */
-bool ObjTypeInfo::isNonPtrFieldObj(const LocationSet& ls)
+bool ObjTypeInfo::isNonPtrFieldObj(const APOffset& ls)
 {
     if (hasPtrObj() == false)
         return true;
@@ -383,13 +383,13 @@ bool ObjTypeInfo::isNonPtrFieldObj(const LocationSet& ls)
         else
             sz = SymbolTableInfo::SymbolInfo()->getTypeInfo(ety)->getFlattenFieldTypes().size();
 
-        if(sz <= (u32_t) ls.getConstantFieldIdx())
+        if(sz <= (u32_t) ls)
         {
             writeWrnMsg("out of bound error when accessing the struct/array");
             return false;
         }
 
-        const SVFType* elemTy = SymbolTableInfo::SymbolInfo()->getFlatternedElemType(ety, ls.getConstantFieldIdx());
+        const SVFType* elemTy = SymbolTableInfo::SymbolInfo()->getFlatternedElemType(ety, ls);
         return (elemTy->isPointerTy() == false);
     }
     else
@@ -537,7 +537,7 @@ bool MemObj::hasPtrObj() const
     return typeInfo->hasPtrObj();
 }
 
-bool MemObj::isNonPtrFieldObj(const LocationSet& ls) const
+bool MemObj::isNonPtrFieldObj(const APOffset& ls) const
 {
     return typeInfo->isNonPtrFieldObj(ls);
 }

package/svf/lib/Util/Options.cpp

@@ -253,7 +253,7 @@ const Option<bool> Options::DumpVFG(
 );
 
 
-// Location set for modeling abstract memory object (LocationSet.cpp)
+// Location set for modeling abstract memory object (AccessPath.cpp)
 const Option<bool> Options::SingleStride(
     "stride-only",
     "Only use single stride in LocMemoryModel",

package/svf/lib/WPA/Andersen.cpp

@@ -170,7 +170,7 @@ void AndersenBase::cleanConsCG(NodeID id)
 void AndersenBase::normalizePointsTo()
 {
     SVFIR::MemObjToFieldsMap &memToFieldsMap = pag->getMemToFieldsMap();
-    SVFIR::NodeLocationSetMap &GepObjVarMap = pag->getGepObjNodeMap();
+    SVFIR::NodeOffsetMap &GepObjVarMap = pag->getGepObjNodeMap();
 
     // clear GepObjVarMap/memToFieldsMap/nodeToSubsMap/nodeToRepMap
     // for redundant gepnodes and remove those nodes from pag
@@ -179,7 +179,7 @@ void AndersenBase::normalizePointsTo()
         NodeID base = pag->getBaseObjVar(n);
         GepObjVar *gepNode = SVFUtil::dyn_cast<GepObjVar>(pag->getGNode(n));
         assert(gepNode && "Not a gep node in redundantGepNodes set");
-        const LocationSet ls = gepNode->getLocationSet();
+        const APOffset ls = gepNode->getConstantFieldIdx();
         GepObjVarMap.erase(std::make_pair(base, ls));
         memToFieldsMap[base].reset(n);
         cleanConsCG(n);
@@ -437,7 +437,7 @@ bool Andersen::processGepPts(const PointsTo& pts, const GepCGEdge* edge)
                 continue;
             }
 
-            NodeID fieldSrcPtdNode = consCG->getGepObjVar(o, normalGepEdge->getLocationSet());
+            NodeID fieldSrcPtdNode = consCG->getGepObjVar(o, normalGepEdge->getAccessPath().getConstantFieldIdx());
             tmpDstPts.set(fieldSrcPtdNode);
         }
     }

package/svf/lib/WPA/AndersenSFR.cpp

@@ -97,7 +97,7 @@ bool AndersenSFR::processGepPts(const PointsTo& pts, const GepCGEdge* edge)
             for (NodeID ptd : srcInits)
                 sortSrcInits.insert(ptd);
 
-            s32_t offset = SVFUtil::dyn_cast<NormalGepCGEdge>(edge)->getConstantFieldIdx();
+            APOffset offset = SVFUtil::dyn_cast<NormalGepCGEdge>(edge)->getConstantFieldIdx();
             fieldExpand(sortSrcInits, offset, dst->strides, tmpDstPts);
         }
 
@@ -117,7 +117,7 @@ bool AndersenSFR::processGepPts(const PointsTo& pts, const GepCGEdge* edge)
 /*!
  * Expand field IDs in target pts based on the initials and offsets
  */
-void AndersenSFR::fieldExpand(NodeSet& initials, s32_t offset, NodeBS& strides, PointsTo& expandPts)
+void AndersenSFR::fieldExpand(NodeSet& initials, APOffset offset, NodeBS& strides, PointsTo& expandPts)
 {
     numOfFieldExpand++;
 
@@ -133,7 +133,7 @@ void AndersenSFR::fieldExpand(NodeSet& initials, s32_t offset, NodeBS& strides,
             PAGNode* initPN = pag->getGNode(init);
             const MemObj* obj = pag->getBaseObj(init);
             const u32_t maxLimit = obj->getMaxFieldOffsetLimit();
-            s32_t initOffset;
+            APOffset initOffset;
             if (GepObjVar *gepNode = SVFUtil::dyn_cast<GepObjVar>(initPN))
                 initOffset = gepNode->getConstantFieldIdx();
             else if (SVFUtil::isa<FIObjVar, DummyObjVar>(initPN))
@@ -144,7 +144,7 @@ void AndersenSFR::fieldExpand(NodeSet& initials, s32_t offset, NodeBS& strides,
                 abort();
             }
 
-            Set<s32_t> offsets;
+            Set<APOffset> offsets;
             offsets.insert(offset);
 
             // calculate offsets
@@ -155,7 +155,7 @@ void AndersenSFR::fieldExpand(NodeSet& initials, s32_t offset, NodeBS& strides,
                 for (auto _f : offsets)
                     for (auto _s : strides)
                     {
-                        s32_t _f1 = _f + _s;
+                        APOffset _f1 = _f + _s;
                         loopFlag = (offsets.find(_f1) == offsets.end()) && ( (u32_t)(initOffset + _f1) < maxLimit);
                         if (loopFlag)
                             offsets.insert(_f1);
@@ -163,9 +163,9 @@ void AndersenSFR::fieldExpand(NodeSet& initials, s32_t offset, NodeBS& strides,
             }
 
             // get gep objs
-            for (s32_t _f : offsets)
+            for (APOffset _f : offsets)
             {
-                NodeID gepId = consCG->getGepObjVar(init, LocationSet(_f));
+                NodeID gepId = consCG->getGepObjVar(init, _f);
                 initials.erase(gepId);  // gep id in initials should be removed to avoid redundant derivation
                 expandPts.set(gepId);
             }

package/svf/lib/WPA/FlowSensitive.cpp

@@ -487,7 +487,7 @@ bool FlowSensitive::processGep(const GepSVFGNode* edge)
                 continue;
             }
 
-            NodeID fieldSrcPtdNode = getGepObjVar(o, gepStmt->getLocationSet());
+            NodeID fieldSrcPtdNode = getGepObjVar(o, gepStmt->getAccessPath().getConstantFieldIdx());
             tmpDstPts.set(fieldSrcPtdNode);
         }
     }

package/svf-llvm/include/SVF-LLVM/SVFIRBuilder.h

@@ -75,7 +75,7 @@ public:
     //@{
     void initialiseNodes();
     void addEdge(NodeID src, NodeID dst, SVFStmt::PEDGEK kind,
-                 s32_t offset = 0, Instruction* cs = nullptr);
+                 APOffset offset = 0, Instruction* cs = nullptr);
     // @}
 
     /// Sanity check for SVFIR
@@ -216,10 +216,10 @@ protected:
     void processCE(const Value* val);
 
     /// Infer field index from byteoffset.
-    u32_t inferFieldIdxFromByteOffset(const llvm::GEPOperator* gepOp, DataLayout *dl, LocationSet& ls, s32_t idx);
+    u32_t inferFieldIdxFromByteOffset(const llvm::GEPOperator* gepOp, DataLayout *dl, AccessPath& ls, APOffset idx);
 
     /// Compute offset of a gep instruction or gep constant expression
-    bool computeGepOffset(const User *V, LocationSet& ls);
+    bool computeGepOffset(const User *V, AccessPath& ls);
 
     /// Get the base value of (i8* src and i8* dst) for external argument (e.g. memcpy(i8* dst, i8* src, int size))
     const Value* getBaseValueForExtArg(const Value* V);
@@ -287,7 +287,7 @@ protected:
         return nullPtr;
     }
 
-    NodeID getGepValVar(const SVFValue* val, const LocationSet& ls, const SVFType* baseType);
+    NodeID getGepValVar(const SVFValue* val, const AccessPath& ls, const SVFType* baseType);
 
     void setCurrentBBAndValueForPAGEdge(PAGEdge* edge);
 
@@ -384,19 +384,19 @@ protected:
             setCurrentBBAndValueForPAGEdge(edge);
     }
     /// Add Gep edge
-    inline void addGepEdge(NodeID src, NodeID dst, const LocationSet& ls, bool constGep)
+    inline void addGepEdge(NodeID src, NodeID dst, const AccessPath& ls, bool constGep)
     {
         if(GepStmt *edge = pag->addGepStmt(src, dst, ls, constGep))
             setCurrentBBAndValueForPAGEdge(edge);
     }
     /// Add Offset(Gep) edge
-    inline void addNormalGepEdge(NodeID src, NodeID dst, const LocationSet& ls)
+    inline void addNormalGepEdge(NodeID src, NodeID dst, const AccessPath& ls)
     {
         if(GepStmt *edge = pag->addNormalGepStmt(src, dst, ls))
             setCurrentBBAndValueForPAGEdge(edge);
     }
     /// Add Variant(Gep) edge
-    inline void addVariantGepEdge(NodeID src, NodeID dst, const LocationSet& ls)
+    inline void addVariantGepEdge(NodeID src, NodeID dst, const AccessPath& ls)
     {
         if(GepStmt *edge = pag->addVariantGepStmt(src, dst, ls))
             setCurrentBBAndValueForPAGEdge(edge);
@@ -415,7 +415,7 @@ protected:
     }
     //@}
 
-    LocationSet getLocationSetFromBaseNode(NodeID nodeId);
+    AccessPath getAccessPathFromBaseNode(NodeID nodeId);
 };
 
 } // End namespace SVF