svf-tools 1.0.733 → 1.0.735

package/svf/lib/DDA/ContextDDA.cpp

@@ -171,7 +171,7 @@ CxtPtSet ContextDDA::processGepPts(const GepSVFGNode* gep, const CxtPtSet& srcPt
             }
             else
             {
-                CxtVar var(ptd.get_cond(),getGepObjVar(ptd.get_id(),gepStmt->getLocationSet()));
+                CxtVar var(ptd.get_cond(),getGepObjVar(ptd.get_id(),gepStmt->getAccessPath().getConstantFieldIdx()));
                 tmpDstPts.set(var);
             }
         }

package/svf/lib/DDA/FlowDDA.cpp

@@ -156,7 +156,7 @@ PointsTo FlowDDA::processGepPts(const GepSVFGNode* gep, const PointsTo& srcPts)
             }
             else
             {
-                NodeID fieldSrcPtdNode = getGepObjVar(ptd,	gepStmt->getLocationSet());
+                NodeID fieldSrcPtdNode = getGepObjVar(ptd,	gepStmt->getAccessPath().getConstantFieldIdx());
                 tmpDstPts.set(fieldSrcPtdNode);
             }
         }

package/svf/lib/Graphs/ConsG.cpp

@@ -121,7 +121,7 @@ void ConstraintGraph::buildCG()
         if(edge->isVariantFieldGep())
             addVariantGepCGEdge(edge->getRHSVarID(),edge->getLHSVarID());
         else
-            addNormalGepCGEdge(edge->getRHSVarID(),edge->getLHSVarID(),edge->getLocationSet());
+            addNormalGepCGEdge(edge->getRHSVarID(),edge->getLHSVarID(),edge->getAccessPath());
     }
 
     SVFStmt::SVFStmtSetTy& loads = getPAGEdgeSet(SVFStmt::Load);
@@ -210,14 +210,15 @@ CopyCGEdge* ConstraintGraph::addCopyCGEdge(NodeID src, NodeID dst)
 /*!
  * Add Gep edge
  */
-NormalGepCGEdge*  ConstraintGraph::addNormalGepCGEdge(NodeID src, NodeID dst, const LocationSet& ls)
+NormalGepCGEdge*  ConstraintGraph::addNormalGepCGEdge(NodeID src, NodeID dst, const AccessPath& ap)
 {
     ConstraintNode* srcNode = getConstraintNode(src);
     ConstraintNode* dstNode = getConstraintNode(dst);
     if (hasEdge(srcNode, dstNode, ConstraintEdge::NormalGep))
         return nullptr;
 
-    NormalGepCGEdge* edge = new NormalGepCGEdge(srcNode, dstNode,ls, edgeIndex++);
+    NormalGepCGEdge* edge =
+        new NormalGepCGEdge(srcNode, dstNode, ap, edgeIndex++);
 
     bool inserted = directEdgeSet.insert(edge).second;
     (void)inserted; // Suppress warning of unused variable under release build
@@ -320,9 +321,9 @@ void ConstraintGraph::reTargetDstOfEdge(ConstraintEdge* edge, ConstraintNode* ne
     }
     else if(NormalGepCGEdge* gep = SVFUtil::dyn_cast<NormalGepCGEdge>(edge))
     {
-        const LocationSet ls = gep->getLocationSet();
+        const AccessPath ap = gep->getAccessPath();
         removeDirectEdge(gep);
-        addNormalGepCGEdge(srcId,newDstNodeID,ls);
+        addNormalGepCGEdge(srcId,newDstNodeID, ap);
     }
     else if(VariantGepCGEdge* gep = SVFUtil::dyn_cast<VariantGepCGEdge>(edge))
     {
@@ -364,9 +365,9 @@ void ConstraintGraph::reTargetSrcOfEdge(ConstraintEdge* edge, ConstraintNode* ne
     }
     else if(NormalGepCGEdge* gep = SVFUtil::dyn_cast<NormalGepCGEdge>(edge))
     {
-        const LocationSet ls = gep->getLocationSet();
+        const AccessPath ap = gep->getAccessPath();
         removeDirectEdge(gep);
-        addNormalGepCGEdge(newSrcNodeID,dstId,ls);
+        addNormalGepCGEdge(newSrcNodeID, dstId, ap);
     }
     else if(VariantGepCGEdge* gep = SVFUtil::dyn_cast<VariantGepCGEdge>(edge))
     {

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,27 +150,24 @@ 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);
-    ls.fldIdx += getConstantFieldIdx();
-    OffsetVarAndGepTypePairs::const_iterator it = getOffsetVarAndGepTypePairVec().begin();
-    OffsetVarAndGepTypePairs::const_iterator eit = getOffsetVarAndGepTypePairVec().end();
-    for (; it != eit; ++it)
-        ls.addOffsetVarAndGepTypePair(it->first, it->second);
+    AccessPath ap(rhs);
+    ap.fldIdx += getConstantFieldIdx();
+    for (auto &p : ap.getOffsetVarAndGepTypePairVec())
+        ap.addOffsetVarAndGepTypePair(p.first, p.second);
 
-    return ls;
+    return ap;
 }
 
-
-bool LocationSet::operator< (const LocationSet& rhs) const
+bool AccessPath::operator< (const AccessPath& rhs) const
 {
     if (fldIdx != rhs.fldIdx)
         return (fldIdx < rhs.fldIdx);
@@ -194,7 +191,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 +213,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,8 +525,8 @@ void BVDataPTAImpl::normalizePointsTo()
     {
         NodeID base = pag->getBaseObjVar(n);
         GepObjVar *gepNode = SVFUtil::dyn_cast<GepObjVar>(pag->getGNode(n));
-        const LocationSet ls = gepNode->getLocationSet();
-        GepObjVarMap.erase(std::make_pair(base, ls));
+        const APOffset apOffset = gepNode->getConstantFieldIdx();
+        GepObjVarMap.erase(std::make_pair(base, apOffset));
         memToFieldsMap[base].reset(n);
 
         pag->removeGNode(gepNode);

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

@@ -323,7 +323,7 @@ cJSON* SVFIRWriter::contentToJson(const ObjVar* var)
 cJSON* SVFIRWriter::contentToJson(const GepValVar* var)
 {
     cJSON* root = contentToJson(static_cast<const ValVar*>(var));
-    JSON_WRITE_FIELD(root, var, ls);
+    JSON_WRITE_FIELD(root, var, ap);
     JSON_WRITE_FIELD(root, var, gepValType);
     return root;
 }
@@ -331,7 +331,7 @@ cJSON* SVFIRWriter::contentToJson(const GepValVar* var)
 cJSON* SVFIRWriter::contentToJson(const GepObjVar* var)
 {
     cJSON* root = contentToJson(static_cast<const ObjVar*>(var));
-    JSON_WRITE_FIELD(root, var, ls);
+    JSON_WRITE_FIELD(root, var, apOffset);
     JSON_WRITE_FIELD(root, var, base);
     return root;
 }
@@ -701,7 +701,7 @@ cJSON* SVFIRWriter::contentToJson(const LoadStmt* edge)
 cJSON* SVFIRWriter::contentToJson(const GepStmt* edge)
 {
     cJSON* root = contentToJson(static_cast<const AssignStmt*>(edge));
-    JSON_WRITE_FIELD(root, edge, ls);
+    JSON_WRITE_FIELD(root, edge, ap);
     JSON_WRITE_FIELD(root, edge, variantField);
     return root;
 }
@@ -1240,11 +1240,11 @@ cJSON* SVFIRWriter::toJson(const StInfo* stInfo)
     return jsonCreateIndex(svfModuleWriter.getStInfoID(stInfo));
 }
 
-cJSON* SVFIRWriter::toJson(const LocationSet& ls)
+cJSON* SVFIRWriter::toJson(const AccessPath& ap)
 {
     cJSON* root = jsonCreateObject();
-    JSON_WRITE_FIELD(root, &ls, fldIdx);
-    JSON_WRITE_FIELD(root, &ls, offsetVarAndGepTypePairs);
+    JSON_WRITE_FIELD(root, &ap, fldIdx);
+    JSON_WRITE_FIELD(root, &ap, offsetVarAndGepTypePairs);
     return root;
 }
 
@@ -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& ap)
 {
-    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");
+    JSON_READ_FIELD_FWD(obj, &ap, fldIdx);
+    JSON_READ_FIELD_FWD(obj, &ap, offsetVarAndGepTypePairs);
+    ABORT_IFNOT(!obj, "Extra field " << JSON_KEY(obj) << " in AccessPath");
 }
 
 void SVFIRReader::readJson(const cJSON* obj, SVFLoop*& loop)
@@ -1948,14 +1948,14 @@ void SVFIRReader::fill(const cJSON*& fieldJson, ObjVar* var)
 void SVFIRReader::fill(const cJSON*& fieldJson, GepValVar* var)
 {
     fill(fieldJson, static_cast<ValVar*>(var));
-    JSON_READ_FIELD_FWD(fieldJson, var, ls);
+    JSON_READ_FIELD_FWD(fieldJson, var, ap);
     JSON_READ_FIELD_FWD(fieldJson, var, gepValType);
 }
 
 void SVFIRReader::fill(const cJSON*& fieldJson, GepObjVar* var)
 {
     fill(fieldJson, static_cast<ObjVar*>(var));
-    JSON_READ_FIELD_FWD(fieldJson, var, ls);
+    JSON_READ_FIELD_FWD(fieldJson, var, apOffset);
     JSON_READ_FIELD_FWD(fieldJson, var, base);
 }
 
@@ -2053,7 +2053,7 @@ void SVFIRReader::fill(const cJSON*& fieldJson, LoadStmt* stmt)
 void SVFIRReader::fill(const cJSON*& fieldJson, GepStmt* stmt)
 {
     fill(fieldJson, static_cast<AssignStmt*>(stmt));
-    JSON_READ_FIELD_FWD(fieldJson, stmt, ls);
+    JSON_READ_FIELD_FWD(fieldJson, stmt, ap);
     JSON_READ_FIELD_FWD(fieldJson, stmt, variantField);
 }
 

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& ap, bool constGep)
 {
 
     SVFVar* node = getGNode(src);
@@ -332,18 +332,18 @@ GepStmt* SVFIR::addGepStmt(NodeID src, NodeID dst, const LocationSet& ls, bool c
     {
         /// Since the offset from base to src is variant,
         /// the new gep edge being created is also a Variant GepStmt edge.
-        return addVariantGepStmt(src, dst, ls);
+        return addVariantGepStmt(src, dst, ap);
     }
     else
     {
-        return addNormalGepStmt(src, dst, ls);
+        return addNormalGepStmt(src, dst, ap);
     }
 }
 
 /*!
  * Add normal (Gep) edge
  */
-GepStmt* SVFIR::addNormalGepStmt(NodeID src, NodeID dst, const LocationSet& ls)
+GepStmt* SVFIR::addNormalGepStmt(NodeID src, NodeID dst, const AccessPath& ap)
 {
     SVFVar* baseNode = getGNode(src);
     SVFVar* dstNode = getGNode(dst);
@@ -351,7 +351,7 @@ GepStmt* SVFIR::addNormalGepStmt(NodeID src, NodeID dst, const LocationSet& ls)
         return nullptr;
     else
     {
-        GepStmt* gepPE = new GepStmt(baseNode, dstNode, ls);
+        GepStmt* gepPE = new GepStmt(baseNode, dstNode, ap);
         addToStmt2TypeMap(gepPE);
         addEdge(baseNode, dstNode, gepPE);
         return gepPE;
@@ -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& ap)
 {
     SVFVar* baseNode = getGNode(src);
     SVFVar* dstNode = getGNode(dst);
@@ -370,7 +370,7 @@ GepStmt* SVFIR::addVariantGepStmt(NodeID src, NodeID dst, const LocationSet& ls)
         return nullptr;
     else
     {
-        GepStmt* gepPE = new GepStmt(baseNode, dstNode,ls, true);
+        GepStmt* gepPE = new GepStmt(baseNode, dstNode, ap, true);
         addToStmt2TypeMap(gepPE);
         addEdge(baseNode, dstNode, gepPE);
         return gepPE;
@@ -383,29 +383,29 @@ 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& ap, NodeID i, const SVFType* type)
 {
     NodeID base = getBaseValVar(getValueNode(gepVal));
     //assert(findPAGNode(i) == false && "this node should not be created before");
-    assert(0==GepValObjMap[curInst].count(std::make_pair(base, ls))
+    assert(0==GepValObjMap[curInst].count(std::make_pair(base, ap))
            && "this node should not be created before");
-    GepValObjMap[curInst][std::make_pair(base, ls)] = i;
-    GepValVar *node = new GepValVar(gepVal, i, ls, type);
+    GepValObjMap[curInst][std::make_pair(base, ap)] = i;
+    GepValVar *node = new GepValVar(gepVal, i, ap, type);
     return addValNode(gepVal, node, i);
 }
 
 /*!
  * Given an object node, find its field object node
  */
-NodeID SVFIR::getGepObjVar(NodeID id, const LocationSet& ls)
+NodeID SVFIR::getGepObjVar(NodeID id, const APOffset& apOffset)
 {
     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() + apOffset);
     else if (FIObjVar* baseNode = SVFUtil::dyn_cast<FIObjVar>(node))
-        return getGepObjVar(baseNode->getMemObj(), ls);
+        return getGepObjVar(baseNode->getMemObj(), apOffset);
     else if (DummyObjVar* baseNode = SVFUtil::dyn_cast<DummyObjVar>(node))
-        return getGepObjVar(baseNode->getMemObj(), ls);
+        return getGepObjVar(baseNode->getMemObj(), apOffset);
     else
     {
         assert(false && "new gep obj node kind?");
@@ -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& apOffset)
 {
     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, apOffset);
 
     // 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,16 +443,16 @@ 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& apOffset)
 {
     //assert(findPAGNode(i) == false && "this node should not be created before");
     NodeID base = obj->getId();
-    assert(0==GepObjVarMap.count(std::make_pair(base, ls))
+    assert(0==GepObjVarMap.count(std::make_pair(base, apOffset))
            && "this node should not be created before");
 
-    NodeID gepId = NodeIDAllocator::get()->allocateGepObjectId(base, ls.getConstantFieldIdx(), Options::MaxFieldLimit());
-    GepObjVarMap[std::make_pair(base, ls)] = gepId;
-    GepObjVar *node = new GepObjVar(obj, gepId, ls);
+    NodeID gepId = NodeIDAllocator::get()->allocateGepObjectId(base, apOffset, Options::MaxFieldLimit());
+    GepObjVarMap[std::make_pair(base, apOffset)] = gepId;
+    GepObjVar *node = new GepObjVar(obj, gepId, apOffset);
     memToFieldsMap[base].set(gepId);
     return addObjNode(obj->getValue(), node, 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& ap) const
 {
     GepValueVarMap::const_iterator iter = GepValObjMap.find(curInst);
     if(iter==GepValObjMap.end())
@@ -544,8 +544,9 @@ NodeID SVFIR::getGepValVar(const SVFValue* curInst, NodeID base, const LocationS
     }
     else
     {
-        NodeLocationSetMap::const_iterator lit = iter->second.find(std::make_pair(base, ls));
-        if(lit==iter->second.end())
+        NodeAccessPathMap::const_iterator lit =
+            iter->second.find(std::make_pair(base, ap));
+        if (lit == iter->second.end())
             return UINT_MAX;
         else
             return lit->second;
@@ -679,7 +680,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(apOffset);
     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& apOffset)
 {
 
     /// 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 = apOffset;
     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& apOffset)
 {
     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) apOffset)
         {
             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, apOffset);
         return (elemTy->isPointerTy() == false);
     }
     else
@@ -537,9 +537,9 @@ bool MemObj::hasPtrObj() const
     return typeInfo->hasPtrObj();
 }
 
-bool MemObj::isNonPtrFieldObj(const LocationSet& ls) const
+bool MemObj::isNonPtrFieldObj(const APOffset& apOffset) const
 {
-    return typeInfo->isNonPtrFieldObj(ls);
+    return typeInfo->isNonPtrFieldObj(apOffset);
 }
 
 const std::string MemObj::toString() const

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/Util/Z3Expr.cpp

@@ -105,7 +105,7 @@ Z3Expr Z3Expr::AND(const Z3Expr &lhs, const Z3Expr &rhs)
     }
     else
     {
-        Z3Expr expr = lhs && rhs;
+        Z3Expr expr = (lhs && rhs).simplify();
         // check subexpression size and option limit
         if (Z3Expr::getExprSize(expr) > Options::MaxZ3Size())
         {
@@ -143,7 +143,7 @@ Z3Expr Z3Expr::OR(const Z3Expr &lhs, const Z3Expr &rhs)
     }
     else
     {
-        Z3Expr expr = lhs || rhs;
+        Z3Expr expr = (lhs || rhs).simplify();
         // check subexpression size and option limit
         if (Z3Expr::getExprSize(expr) > Options::MaxZ3Size())
         {

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,8 +179,8 @@ 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();
-        GepObjVarMap.erase(std::make_pair(base, ls));
+        const APOffset apOffset = gepNode->getConstantFieldIdx();
+        GepObjVarMap.erase(std::make_pair(base, apOffset));
         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);
         }
     }