svf-tools 1.0.733 → 1.0.734

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.733",
+  "version": "1.0.734",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf/include/AbstractExecution/SVFIR2ConsExeState.h

@@ -89,7 +89,7 @@ public:
     //%}
 
     /// Return the expr of gep object given a base and offset
-    VAddrs getGepObjAddress(u32_t base, u32_t offset);
+    VAddrs getGepObjAddress(u32_t base, s32_t offset);
 
     /// Return the offset expression of a GepStmt
     std::pair<s32_t, s32_t> getGepOffset(const GepStmt *gep);

package/svf/include/AbstractExecution/SVFIR2ItvExeState.h

@@ -71,7 +71,7 @@ public:
     void narrowVAddrs(IntervalExeState &lhs, const IntervalExeState &rhs);
 
     /// Return the field address given a pointer points to a struct object and an offset
-    VAddrs getGepObjAddress(u32_t pointer, u32_t offset);
+    VAddrs getGepObjAddress(u32_t pointer, s32_t offset);
 
     /// Return the offset expression of a GepStmt
     std::pair<s32_t, s32_t> getGepOffset(const GepStmt *gep);

package/svf/include/Graphs/ConsG.h

@@ -180,7 +180,7 @@ public:
     /// Add Copy edge
     CopyCGEdge* addCopyCGEdge(NodeID src, NodeID dst);
     /// Add Gep edge
-    NormalGepCGEdge*  addNormalGepCGEdge(NodeID src, NodeID dst, const LocationSet& ls);
+    NormalGepCGEdge*  addNormalGepCGEdge(NodeID src, NodeID dst, const AccessPath& ls);
     VariantGepCGEdge* addVariantGepCGEdge(NodeID src, NodeID dst);
     /// Add Load edge
     LoadCGEdge* addLoadCGEdge(NodeID src, NodeID dst);
@@ -325,7 +325,7 @@ public:
         return (mem->getMaxFieldOffsetLimit() == 1);
     }
     /// Get a field of a memory object
-    inline NodeID getGepObjVar(NodeID id, const LocationSet& ls)
+    inline NodeID getGepObjVar(NodeID id, const APOffset& ls)
     {
         NodeID gep =  pag->getGepObjVar(id,ls);
         /// Create a node when it is (1) not exist on graph and (2) not merged

package/svf/include/Graphs/ConsGEdge.h

@@ -269,7 +269,7 @@ private:
     NormalGepCGEdge(const NormalGepCGEdge &);  ///< place holder
     void operator=(const NormalGepCGEdge &); ///< place holder
 
-    LocationSet ls;	///< location set of the gep edge
+    AccessPath ls;	///< location set of the gep edge
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -293,18 +293,18 @@ public:
     //@}
 
     /// Constructor
-    NormalGepCGEdge(ConstraintNode* s, ConstraintNode* d, const LocationSet& l, EdgeID id)
+    NormalGepCGEdge(ConstraintNode* s, ConstraintNode* d, const AccessPath& l, EdgeID id)
         : GepCGEdge(s,d,NormalGep,id), ls(l)
     {}
 
     /// Get location set of the gep edge
-    inline const LocationSet& getLocationSet() const
+    inline const AccessPath& getAccessPath() const
     {
         return ls;
     }
 
     /// Get location set of the gep edge
-    inline s32_t getConstantFieldIdx() const
+    inline APOffset getConstantFieldIdx() const
     {
         return ls.getConstantFieldIdx();
     }

package/svf/include/MemoryModel/{LocationSet.h → AccessPath.h}

@@ -1,4 +1,4 @@
-//===- LocationSet.h -- Location set of abstract object-----------------------//
+//===- AccessPath.h -- Location set of abstract object-----------------------//
 //
 //                     SVF: Static Value-Flow Analysis
 //
@@ -21,7 +21,7 @@
 //===----------------------------------------------------------------------===//
 
 /*
- * @file: LocationSet.h
+ * @file: AccessPath.h
  * @author: yesen
  * @date: 26 Sep 2014
  *
@@ -30,8 +30,8 @@
  */
 
 
-#ifndef LOCATIONSET_H_
-#define LOCATIONSET_H_
+#ifndef AccessPath_H_
+#define AccessPath_H_
 
 
 #include "SVFIR/SVFValue.h"
@@ -49,7 +49,7 @@ class SVFVar;
 * where N is the size of number-stride pair vector, M_i (stride_i) is i-th number (stride)
 * in the number-stride pair vector.
 */
-class LocationSet
+class AccessPath
 {
     friend class SymbolTableInfo;
     friend class SVFIRWriter;
@@ -65,28 +65,28 @@ public:
     typedef std::vector<VarAndGepTypePair> OffsetVarAndGepTypePairs;
 
     /// Constructor
-    LocationSet(s32_t o = 0) : fldIdx(o) {}
+    AccessPath(APOffset o = 0) : fldIdx(o) {}
 
     /// Copy Constructor
-    LocationSet(const LocationSet& ls)
+    AccessPath(const AccessPath& ls)
         : fldIdx(ls.fldIdx),
           offsetVarAndGepTypePairs(ls.getOffsetVarAndGepTypePairVec())
     {
     }
 
-    ~LocationSet() {}
+    ~AccessPath() {}
 
     /// Overload operators
     //@{
-    LocationSet operator+(const LocationSet& rhs) const;
-    bool operator<(const LocationSet& rhs) const;
-    inline const LocationSet& operator=(const LocationSet& rhs)
+    AccessPath operator+(const AccessPath& rhs) const;
+    bool operator<(const AccessPath& rhs) const;
+    inline const AccessPath& operator=(const AccessPath& rhs)
     {
         fldIdx = rhs.fldIdx;
         offsetVarAndGepTypePairs = rhs.getOffsetVarAndGepTypePairVec();
         return *this;
     }
-    inline bool operator==(const LocationSet& rhs) const
+    inline bool operator==(const AccessPath& rhs) const
     {
         return this->fldIdx == rhs.fldIdx &&
                this->offsetVarAndGepTypePairs == rhs.offsetVarAndGepTypePairs;
@@ -95,11 +95,11 @@ public:
 
     /// Get methods
     //@{
-    inline s32_t getConstantFieldIdx() const
+    inline APOffset getConstantFieldIdx() const
     {
         return fldIdx;
     }
-    inline void setFldIdx(s32_t idx)
+    inline void setFldIdx(APOffset idx)
     {
         fldIdx = idx;
     }
@@ -110,7 +110,7 @@ public:
     //@}
 
     /// Return accumulated constant offset given OffsetVarVec
-    s32_t computeConstantOffset() const;
+    APOffset computeConstantOffset() const;
 
     /// Return element number of a type.
     u32_t getElementNum(const SVFType* type) const;
@@ -122,7 +122,7 @@ public:
     bool isConstantOffset() const;
 
     /// Return TRUE if we share any location in common with RHS
-    inline bool intersects(const LocationSet& RHS) const
+    inline bool intersects(const AccessPath& RHS) const
     {
         return computeAllLocations().intersects(RHS.computeAllLocations());
     }
@@ -133,25 +133,25 @@ public:
 private:
 
     /// Check relations of two location sets
-    LSRelation checkRelation(const LocationSet& LHS, const LocationSet& RHS);
+    LSRelation checkRelation(const AccessPath& LHS, const AccessPath& RHS);
 
     /// Compute all possible locations according to offset and number-stride pairs.
     NodeBS computeAllLocations() const;
 
-    s32_t fldIdx;	///< Accumulated Constant Offsets
+    APOffset fldIdx;	///< Accumulated Constant Offsets
     OffsetVarAndGepTypePairs offsetVarAndGepTypePairs;	///< a vector of actual offset in the form of <SVF Var, iterator type>s
 };
 
 } // End namespace SVF
 
-template <> struct std::hash<SVF::LocationSet>
+template <> struct std::hash<SVF::AccessPath>
 {
-    size_t operator()(const SVF::LocationSet &ls) const
+    size_t operator()(const SVF::AccessPath &ls) const
     {
         SVF::Hash<std::pair<SVF::NodeID, SVF::NodeID>> h;
-        std::hash<SVF::LocationSet::OffsetVarAndGepTypePairs> v;
+        std::hash<SVF::AccessPath::OffsetVarAndGepTypePairs> v;
         return h(std::make_pair(ls.getConstantFieldIdx(), v(ls.getOffsetVarAndGepTypePairVec())));
     }
 };
 
-#endif /* LOCATIONSET_H_ */
+#endif /* AccessPath_H_ */

package/svf/include/MemoryModel/PointerAnalysis.h

@@ -338,7 +338,7 @@ public:
     {
         return pag->getFIObjVar(id);
     }
-    inline NodeID getGepObjVar(NodeID id, const LocationSet& ls)
+    inline NodeID getGepObjVar(NodeID id, const APOffset& ls)
     {
         return pag->getGepObjVar(id,ls);
     }

package/svf/include/SVFIR/PAGBuilderFromFile.h

@@ -71,7 +71,7 @@ public:
     SVFIR* build();
 
     // Add edges
-    void addEdge(NodeID nodeSrc, NodeID nodeDst, s32_t offset,
+    void addEdge(NodeID nodeSrc, NodeID nodeDst, APOffset offset,
                  std::string edge);
 };
 

package/svf/include/SVFIR/SVFFileSystem.h

@@ -159,7 +159,7 @@ class SymbolTableInfo;
 
 class SVFModule;
 
-class LocationSet;
+class AccessPath;
 class ObjTypeInfo; // Need SVFType
 
 class SVFVar;
@@ -422,7 +422,7 @@ private:
     cJSON* toJson(const CHEdge* edge);         // CHGraph Edge
 
     cJSON* toJson(const CallSite& cs);
-    cJSON* toJson(const LocationSet& ls);
+    cJSON* toJson(const AccessPath& ls);
     cJSON* toJson(const SVFLoop* loop);
     cJSON* toJson(const MemObj* memObj);
     cJSON* toJson(const ObjTypeInfo* objTypeInfo);  // Only owned by MemObj
@@ -1104,7 +1104,7 @@ private:
     void readJson(const cJSON* obj, CHEdge*& edge); // CHGraph Edge
     void readJson(const cJSON* obj, CallSite& cs); // CHGraph's csToClassMap
 
-    void readJson(const cJSON* obj, LocationSet& ls);
+    void readJson(const cJSON* obj, AccessPath& ls);
     void readJson(const cJSON* obj, SVFLoop*& loop);
     void readJson(const cJSON* obj, MemObj*& memObj);
     void readJson(const cJSON* obj,

package/svf/include/SVFIR/SVFIR.h

@@ -64,12 +64,12 @@ public:
     typedef Map<const SVFFunction*,SVFStmtSet> FunToPAGEdgeSetMap;
     typedef Map<const ICFGNode*,SVFStmtList> ICFGNode2SVFStmtsMap;
     typedef Map<NodeID, NodeID> NodeToNodeMap;
-    typedef std::pair<NodeID, s32_t> NodeOffset;
-    typedef std::pair<NodeID, LocationSet> NodeLocationSet;
+    typedef std::pair<NodeID, APOffset> NodeOffset;
+    typedef std::pair<NodeID, AccessPath> NodeAccessPath;
     typedef Map<NodeOffset,NodeID> NodeOffsetMap;
-    typedef Map<NodeLocationSet,NodeID> NodeLocationSetMap;
-    typedef Map<const SVFValue*, NodeLocationSetMap> GepValueVarMap;
-    typedef std::pair<const SVFType*, std::vector<LocationSet>> SVFTypeLocSetsPair;
+    typedef Map<NodeAccessPath,NodeID> NodeAccessPathMap;
+    typedef Map<const SVFValue*, NodeAccessPathMap> GepValueVarMap;
+    typedef std::pair<const SVFType*, std::vector<AccessPath>> SVFTypeLocSetsPair;
     typedef Map<NodeID, SVFTypeLocSetsPair> TypeLocSetsMap;
     typedef Map<NodePair,NodeID> NodePairSetMap;
 
@@ -80,7 +80,7 @@ private:
     ICFGNode2SVFStmtsMap icfgNode2PTASVFStmtsMap;	///< Map an ICFGNode to its PointerAnalysis related SVFStmts
     GepValueVarMap GepValObjMap;	///< Map a pair<base,off> to a gep value node id
     TypeLocSetsMap typeLocSetsMap;	///< Map an arg to its base SVFType* and all its field location sets
-    NodeLocationSetMap GepObjVarMap;	///< Map a pair<base,off> to a gep obj node id
+    NodeOffsetMap GepObjVarMap;	///< Map a pair<base,off> to a gep obj node id
     MemObjToFieldsMap memToFieldsMap;	///< Map a mem object id to all its fields
     SVFStmtSet globSVFStmtSet;	///< Global PAGEdges without control flow information
     PHINodeMap phiNodeMap;	///< A set of phi copy edges
@@ -129,7 +129,7 @@ public:
         return memToFieldsMap;
     }
     /// Return GepObjVarMap
-    inline NodeLocationSetMap& getGepObjNodeMap()
+    inline NodeOffsetMap& getGepObjNodeMap()
     {
         return GepObjVarMap;
     }
@@ -328,7 +328,7 @@ public:
     //@}
 
     /// Due to constaint expression, curInst is used to distinguish different instructions (e.g., memorycpy) when creating GepValVar.
-    NodeID getGepValVar(const SVFValue* curInst, NodeID base, const LocationSet& ls) const;
+    NodeID getGepValVar(const SVFValue* curInst, NodeID base, const AccessPath& ls) const;
 
     /// Add/get indirect callsites
     //@{
@@ -392,9 +392,9 @@ public:
     //@}
 
     /// Get a field SVFIR Object node according to base mem obj and offset
-    NodeID getGepObjVar(const MemObj* obj, const LocationSet& ls);
+    NodeID getGepObjVar(const MemObj* obj, const APOffset& ls);
     /// Get a field obj SVFIR node according to a mem obj and a given offset
-    NodeID getGepObjVar(NodeID id, const LocationSet& ls) ;
+    NodeID getGepObjVar(NodeID id, const APOffset& ls) ;
     /// Get a field-insensitive obj SVFIR node according to a mem obj
     //@{
     inline NodeID getFIObjVar(const MemObj* obj) const
@@ -557,9 +557,9 @@ private:
     }
 
     /// Add a temp field value node, this method can only invoked by getGepValVar
-    NodeID addGepValNode(const SVFValue* curInst,const SVFValue* val, const LocationSet& ls, NodeID i, const SVFType* type);
+    NodeID addGepValNode(const SVFValue* curInst,const SVFValue* val, const AccessPath& ls, NodeID i, const SVFType* type);
     /// Add a field obj node, this method can only invoked by getGepObjVar
-    NodeID addGepObjNode(const MemObj* obj, const LocationSet& ls);
+    NodeID addGepObjNode(const MemObj* obj, const APOffset& ls);
     /// Add a field-insensitive node, this method can only invoked by getFIGepObjNode
     NodeID addFIObjNode(const MemObj* obj);
     //@}
@@ -665,12 +665,12 @@ private:
     RetPE* addRetPE(NodeID src, NodeID dst, const CallICFGNode* cs,
                     const FunExitICFGNode* exit);
     /// Add Gep edge
-    GepStmt* addGepStmt(NodeID src, NodeID dst, const LocationSet& ls,
+    GepStmt* addGepStmt(NodeID src, NodeID dst, const AccessPath& ls,
                         bool constGep);
     /// Add Offset(Gep) edge
-    GepStmt* addNormalGepStmt(NodeID src, NodeID dst, const LocationSet& ls);
+    GepStmt* addNormalGepStmt(NodeID src, NodeID dst, const AccessPath& ls);
     /// Add Variant(Gep) edge
-    GepStmt* addVariantGepStmt(NodeID src, NodeID dst, const LocationSet& ls);
+    GepStmt* addVariantGepStmt(NodeID src, NodeID dst, const AccessPath& ls);
     /// Add Thread fork edge for parameter passing
     TDForkPE* addThreadForkPE(NodeID src, NodeID dst, const CallICFGNode* cs,
                               const FunEntryICFGNode* entry);

package/svf/include/SVFIR/SVFStatements.h

@@ -32,7 +32,7 @@
 #define INCLUDE_SVFIR_SVFSTATEMENT_H_
 
 #include "Graphs/GenericGraph.h"
-#include "MemoryModel/LocationSet.h"
+#include "MemoryModel/AccessPath.h"
 
 namespace SVF
 {
@@ -465,7 +465,7 @@ private:
     GepStmt(const GepStmt &);  ///< place holder
     void operator=(const GepStmt &); ///< place holder
 
-    LocationSet ls;	///< location set of the gep edge
+    AccessPath ls;	///< location set of the gep edge
     bool variantField;  ///< Gep statement with a variant field index (pointer arithmetic) for struct field access (e.g., p = &(q + f), where f is a variable)
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -484,29 +484,29 @@ public:
     }
     //@}
 
-    inline const LocationSet& getLocationSet() const
+    inline const AccessPath& getAccessPath() const
     {
         return ls;
     }
-    inline const LocationSet::OffsetVarAndGepTypePairs getOffsetVarAndGepTypePairVec() const
+    inline const AccessPath::OffsetVarAndGepTypePairs getOffsetVarAndGepTypePairVec() const
     {
-        return getLocationSet().getOffsetVarAndGepTypePairVec();
+        return getAccessPath().getOffsetVarAndGepTypePairVec();
     }
     /// Return TRUE if this is a constant location set.
     inline bool isConstantOffset() const
     {
-        return getLocationSet().isConstantOffset();
+        return getAccessPath().isConstantOffset();
     }
     /// Return accumulated constant offset (when accessing array or struct) if this offset is a constant.
-    inline s32_t accumulateConstantOffset() const
+    inline APOffset accumulateConstantOffset() const
     {
-        return getLocationSet().computeConstantOffset();
+        return getAccessPath().computeConstantOffset();
     }
     /// Field index of the gep statement if it access the field of a struct
-    inline s32_t getConstantFieldIdx() const
+    inline APOffset getConstantFieldIdx() const
     {
-        assert(isVariantFieldGep()==false && "Can't retrieve the LocationSet if using a variable field index (pointer arithmetic) for struct field access ");
-        return getLocationSet().getConstantFieldIdx();
+        assert(isVariantFieldGep()==false && "Can't retrieve the AccessPath if using a variable field index (pointer arithmetic) for struct field access ");
+        return getAccessPath().getConstantFieldIdx();
     }
     /// Gep statement with a variant field index (pointer arithmetic) for struct field access
     inline bool isVariantFieldGep() const
@@ -515,7 +515,7 @@ public:
     }
 
     /// constructor
-    GepStmt(SVFVar* s, SVFVar* d, const LocationSet& l, bool varfld = false)
+    GepStmt(SVFVar* s, SVFVar* d, const AccessPath& l, bool varfld = false)
         : AssignStmt(s, d, SVFStmt::Gep), ls(l), variantField(varfld)
     {
     }

package/svf/include/SVFIR/SVFType.h

@@ -58,6 +58,7 @@ typedef u32_t EdgeID;
 typedef unsigned SymID;
 typedef unsigned CallSiteID;
 typedef unsigned ThreadID;
+typedef s64_t APOffset;
 
 typedef SparseBitVector<> NodeBS;
 typedef unsigned PointsToID;

package/svf/include/SVFIR/SVFVariables.h

@@ -383,7 +383,7 @@ class GepValVar: public ValVar
     friend class SVFIRReader;
 
 private:
-    LocationSet ls;	// LocationSet
+    AccessPath ls;	// AccessPath
     const SVFType* gepValType;
 
     /// Constructor to create empty GeValVar (for SVFIRReader/deserialization)
@@ -411,14 +411,14 @@ public:
     //@}
 
     /// Constructor
-    GepValVar(const SVFValue* val, NodeID i, const LocationSet& l,
+    GepValVar(const SVFValue* val, NodeID i, const AccessPath& l,
               const SVFType* ty)
         : ValVar(val, i, GepValNode), ls(l), gepValType(ty)
     {
     }
 
     /// offset of the base value variable
-    inline s32_t getConstantFieldIdx() const
+    inline APOffset getConstantFieldIdx() const
     {
         return ls.getConstantFieldIdx();
     }
@@ -451,7 +451,7 @@ class GepObjVar: public ObjVar
     friend class SVFIRReader;
 
 private:
-    LocationSet ls;
+    APOffset ls = 0;
     NodeID base = 0;
 
     /// Constructor to create empty GepObjVar (for SVFIRReader/deserialization)
@@ -480,7 +480,7 @@ public:
     //@}
 
     /// Constructor
-    GepObjVar(const MemObj* mem, NodeID i, const LocationSet& l,
+    GepObjVar(const MemObj* mem, NodeID i, const APOffset& l,
               PNODEK ty = GepObjNode)
         : ObjVar(mem->getValue(), i, mem, ty), ls(l)
     {
@@ -488,17 +488,11 @@ public:
     }
 
     /// offset of the mem object
-    inline const LocationSet& getLocationSet() const
+    inline APOffset getConstantFieldIdx() const
     {
         return ls;
     }
 
-    /// offset of the mem object
-    inline s32_t getConstantFieldIdx() const
-    {
-        return ls.getConstantFieldIdx();
-    }
-
     /// Set the base object from which this GEP node came from.
     inline void setBaseNode(NodeID base)
     {
@@ -514,15 +508,15 @@ public:
     /// Return the type of this gep object
     inline virtual const SVFType* getType() const
     {
-        return SymbolTableInfo::SymbolInfo()->getFlatternedElemType(mem->getType(), ls.getConstantFieldIdx());
+        return SymbolTableInfo::SymbolInfo()->getFlatternedElemType(mem->getType(), ls);
     }
 
     /// Return name of a LLVM value
     inline const std::string getValueName() const
     {
         if (value)
-            return value->getName() + "_" + std::to_string(ls.getConstantFieldIdx());
-        return "offset_" + std::to_string(ls.getConstantFieldIdx());
+            return value->getName() + "_" + std::to_string(ls);
+        return "offset_" + std::to_string(ls);
     }
 
     virtual const std::string toString() const;

package/svf/include/SVFIR/SymbolTableInfo.h

@@ -32,7 +32,7 @@
 
 
 #include "Util/SVFUtil.h"
-#include "MemoryModel/LocationSet.h"
+#include "MemoryModel/AccessPath.h"
 #include "SVFIR/SVFModule.h"
 namespace SVF
 {
@@ -333,7 +333,7 @@ public:
     virtual void dump();
 
     /// Given an offset from a Gep Instruction, return it modulus offset by considering memory layout
-    virtual LocationSet getModulusOffset(const MemObj* obj, const LocationSet& ls);
+    virtual APOffset getModulusOffset(const MemObj* obj, const APOffset& ls);
 
     ///The struct type with the most fields
     const SVFType* maxStruct;
@@ -453,7 +453,7 @@ public:
     bool isConstDataOrConstGlobal() const;
     bool isConstDataOrAggData() const;
     bool hasPtrObj() const;
-    bool isNonPtrFieldObj(const LocationSet& ls) const;
+    bool isNonPtrFieldObj(const APOffset& ls) const;
     //@}
 
     /// Operator overloading
@@ -621,7 +621,7 @@ public:
     {
         return hasFlag(HASPTR_OBJ);
     }
-    virtual bool isNonPtrFieldObj(const LocationSet& ls);
+    virtual bool isNonPtrFieldObj(const APOffset& ls);
     //@}
 };
 

package/svf/include/Util/Options.h

@@ -121,7 +121,7 @@ public:
     // Sparse value-flow graph (VFG.cpp)
     static const Option<bool> DumpVFG;
 
-    // Location set for modeling abstract memory object (LocationSet.cpp)
+    // Location set for modeling abstract memory object (AccessPath.cpp)
     static const Option<bool> SingleStride;
 
     // Base class of pointer analyses (PointerAnalysis.cpp)

package/svf/include/WPA/AndersenPWC.h

@@ -149,7 +149,7 @@ public:
 protected:
     void initialize();
     void PWCDetect();
-    void fieldExpand(NodeSet& initials, s32_t offset, NodeBS& strides, PointsTo& expandPts);
+    void fieldExpand(NodeSet& initials, APOffset offset, NodeBS& strides, PointsTo& expandPts);
     bool processGepPts(const PointsTo& pts, const GepCGEdge* edge);
     bool mergeSrcToTgt(NodeID nodeId, NodeID newRepId);
 

package/svf/lib/AbstractExecution/SVFIR2ConsExeState.cpp

@@ -579,7 +579,7 @@ void SVFIR2ConsExeState::translatePhi(const PhiStmt *phi)
  * @param offset
  * @return
  */
-SVFIR2ConsExeState::VAddrs SVFIR2ConsExeState::getGepObjAddress(u32_t base, u32_t offset)
+SVFIR2ConsExeState::VAddrs SVFIR2ConsExeState::getGepObjAddress(u32_t base, s32_t offset)
 {
     const VAddrs &addrs = _es->getVAddrs(base);
     VAddrs ret;
@@ -655,7 +655,7 @@ std::pair<s32_t, s32_t> SVFIR2ConsExeState::getGepOffset(const SVF::GepStmt *gep
 
         if (const SVFPointerType *pty = SVFUtil::dyn_cast<SVFPointerType>(type))
         {
-            offset = offset * gep->getLocationSet().getElementNum(pty->getPtrElementType());
+            offset = offset * gep->getAccessPath().getElementNum(pty->getPtrElementType());
         }
         else
         {

package/svf/lib/AbstractExecution/SVFIR2ItvExeState.cpp

@@ -152,7 +152,7 @@ void SVFIR2ItvExeState::narrowVAddrs(IntervalExeState &lhs, const IntervalExeSta
     }
 }
 
-SVFIR2ItvExeState::VAddrs SVFIR2ItvExeState::getGepObjAddress(u32_t pointer, u32_t offset)
+SVFIR2ItvExeState::VAddrs SVFIR2ItvExeState::getGepObjAddress(u32_t pointer, s32_t offset)
 {
     assert(!getVAddrs(pointer).empty());
     VAddrs &addrs = getVAddrs(pointer);
@@ -242,8 +242,8 @@ std::pair<s32_t, s32_t> SVFIR2ItvExeState::getGepOffset(const GepStmt *gep)
 
         if (const SVFPointerType *pty = SVFUtil::dyn_cast<SVFPointerType>(type))
         {
-            offsetLb = offsetLb * gep->getLocationSet().getElementNum(pty->getPtrElementType());
-            offsetUb = offsetUb * gep->getLocationSet().getElementNum(pty->getPtrElementType());
+            offsetLb = offsetLb * gep->getAccessPath().getElementNum(pty->getPtrElementType());
+            offsetUb = offsetUb * gep->getAccessPath().getElementNum(pty->getPtrElementType());
 
         }
         else

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,7 +210,7 @@ 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& ls)
 {
     ConstraintNode* srcNode = getConstraintNode(src);
     ConstraintNode* dstNode = getConstraintNode(dst);
@@ -320,7 +320,7 @@ void ConstraintGraph::reTargetDstOfEdge(ConstraintEdge* edge, ConstraintNode* ne
     }
     else if(NormalGepCGEdge* gep = SVFUtil::dyn_cast<NormalGepCGEdge>(edge))
     {
-        const LocationSet ls = gep->getLocationSet();
+        const AccessPath ls = gep->getAccessPath();
         removeDirectEdge(gep);
         addNormalGepCGEdge(srcId,newDstNodeID,ls);
     }
@@ -364,7 +364,7 @@ void ConstraintGraph::reTargetSrcOfEdge(ConstraintEdge* edge, ConstraintNode* ne
     }
     else if(NormalGepCGEdge* gep = SVFUtil::dyn_cast<NormalGepCGEdge>(edge))
     {
-        const LocationSet ls = gep->getLocationSet();
+        const AccessPath ls = gep->getAccessPath();
         removeDirectEdge(gep);
         addNormalGepCGEdge(newSrcNodeID,dstId,ls);
     }