svf-lib 1.0.1571 → 1.0.1573

package/SVF-linux/svf/include/Util/ExtAPI.h

@@ -481,7 +481,7 @@ public:
 
     // Get all operations of an extern function
     Operand getBasicOperation(cJSON* obj);
-    ExtFunctionOps getExtFunctionOps(std::string funName);
+    ExtFunctionOps getExtFunctionOps(const SVFFunction* extFunction);
 
     // Get property of the operation, e.g. "EFT_A1R_A0R"
     extType get_type(const SVF::SVFFunction *callee);

package/SVF-linux/svf/include/Util/ExtAPI.json

@@ -1401,7 +1401,7 @@
     },
     "llvm.va_start":    {
         "return":  "void",
-        "arguments":  "(ptr)",
+        "arguments":  "(i8*)",
         "type": "EFT_NOOP",
         "overwrite_app_function": 1
     },
@@ -3346,8 +3346,8 @@
 		}
     },
     "__sysv_signal":    {
-        "return":  "__sighandler_t",
-        "arguments":  "(int, __sighandler_t)",
+        "return":  "void (i32)*",
+        "arguments":  "(i32, void (i32)*)",
         "type": "EFT_ALLOC",
         "overwrite_app_function": 1,
         "AddrStmt": {
@@ -3356,8 +3356,8 @@
 		}
     },
     "signal":   {
-        "return":  "sighandler_t",
-        "arguments":  "(int, sighandler_t)",
+        "return":  "void (i32)*",
+        "arguments":  "(i32, void (i32)*)",
         "type": "EFT_ALLOC",
         "overwrite_app_function": 1,
         "AddrStmt": {
@@ -5009,7 +5009,7 @@
     },
     "llvm.memset.p0i8.i64": {
         "return":  "void",
-        "arguments":  "(i8*, i8, i64, i32, i1)",
+        "arguments":  "(i8*, i8, i64, i1)",
         "type": "EFT_L_A0__A0R_A1",
         "overwrite_app_function": 0,
         "memset_like":  {
@@ -5061,7 +5061,7 @@
     },
     "llvm.memcpy.p0i8.p0i8.i64":    {
         "return":  "void",
-        "arguments":  "(i8*, *i8, i64, i32, i1)",
+        "arguments":  "(i8*, i8*, i64, i1)",
         "type": "EFT_L_A0__A0R_A1R",
         "overwrite_app_function": 0,
         "memcpy_like":  {
@@ -5585,7 +5585,7 @@
     },
     "_ZNSt8__detail15_List_node_base7_M_hookEPS0_":{
         "return":  "void",
-        "arguments":  "(std::__detail::_List_node_base*)",
+        "arguments":  "(struct.std::__detail::_List_node_base*, struct.std::__detail::_List_node_base*)",
         "type": "EFT_STD_LIST_HOOK",
         "overwrite_app_function": 0,
         "StoreStmt": {

package/SVF-osx/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-osx/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-osx/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-osx/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-osx/svf/include/MemoryModel/AccessPath.h

@@ -0,0 +1,157 @@
+//===- AccessPath.h -- Location set of abstract object-----------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013->  <Yulei Sui>
+//
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * @file: AccessPath.h
+ * @author: yesen
+ * @date: 26 Sep 2014
+ *
+ * LICENSE
+ *
+ */
+
+
+#ifndef AccessPath_H_
+#define AccessPath_H_
+
+
+#include "SVFIR/SVFValue.h"
+
+
+namespace SVF
+{
+
+class SVFVar;
+
+
+/*
+* Location set represents a set of locations in a memory block with following offsets:
+*     { offset + \sum_{i=0}^N (stride_i * j_i) | 0 \leq j_i < M_i }
+* 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 AccessPath
+{
+    friend class SymbolTableInfo;
+    friend class SVFIRWriter;
+    friend class SVFIRReader;
+
+public:
+    enum LSRelation
+    {
+        NonOverlap, Overlap, Subset, Superset, Same
+    };
+
+    typedef std::pair<const SVFVar*, const SVFType*> VarAndGepTypePair;
+    typedef std::vector<VarAndGepTypePair> OffsetVarAndGepTypePairs;
+
+    /// Constructor
+    AccessPath(APOffset o = 0) : fldIdx(o) {}
+
+    /// Copy Constructor
+    AccessPath(const AccessPath& ls)
+        : fldIdx(ls.fldIdx),
+          offsetVarAndGepTypePairs(ls.getOffsetVarAndGepTypePairVec())
+    {
+    }
+
+    ~AccessPath() {}
+
+    /// Overload operators
+    //@{
+    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 AccessPath& rhs) const
+    {
+        return this->fldIdx == rhs.fldIdx &&
+               this->offsetVarAndGepTypePairs == rhs.offsetVarAndGepTypePairs;
+    }
+    //@}
+
+    /// Get methods
+    //@{
+    inline APOffset getConstantFieldIdx() const
+    {
+        return fldIdx;
+    }
+    inline void setFldIdx(APOffset idx)
+    {
+        fldIdx = idx;
+    }
+    inline const OffsetVarAndGepTypePairs& getOffsetVarAndGepTypePairVec() const
+    {
+        return offsetVarAndGepTypePairs;
+    }
+    //@}
+
+    /// Return accumulated constant offset given OffsetVarVec
+    APOffset computeConstantOffset() const;
+
+    /// Return element number of a type.
+    u32_t getElementNum(const SVFType* type) const;
+
+
+    bool addOffsetVarAndGepTypePair(const SVFVar* var, const SVFType* gepIterType);
+
+    /// Return TRUE if this is a constant location set.
+    bool isConstantOffset() const;
+
+    /// Return TRUE if we share any location in common with RHS
+    inline bool intersects(const AccessPath& RHS) const
+    {
+        return computeAllLocations().intersects(RHS.computeAllLocations());
+    }
+
+    /// Dump location set
+    std::string dump() const;
+
+private:
+
+    /// Check relations of two location sets
+    LSRelation checkRelation(const AccessPath& LHS, const AccessPath& RHS);
+
+    /// Compute all possible locations according to offset and number-stride pairs.
+    NodeBS computeAllLocations() const;
+
+    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::AccessPath>
+{
+    size_t operator()(const SVF::AccessPath &ls) const
+    {
+        SVF::Hash<std::pair<SVF::NodeID, SVF::NodeID>> h;
+        std::hash<SVF::AccessPath::OffsetVarAndGepTypePairs> v;
+        return h(std::make_pair(ls.getConstantFieldIdx(), v(ls.getOffsetVarAndGepTypePairVec())));
+    }
+};
+
+#endif /* AccessPath_H_ */

package/SVF-osx/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-osx/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-osx/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-osx/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-osx/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-osx/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-osx/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-osx/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-osx/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-osx/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-osx/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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.1571",
+  "version": "1.0.1573",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {