svf-tools 1.0.733 → 1.0.735

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.733",
+  "version": "1.0.735",
   "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

@@ -52,7 +52,7 @@ public:
     typedef FIFOWorkList<NodeID> WorkList;
 
 protected:
-    SVFIR*pag;
+    SVFIR* pag;
     NodeToRepMap nodeToRepMap;
     NodeToSubsMap nodeToSubsMap;
     WorkList nodesToBeCollapsed;
@@ -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& ap);
     VariantGepCGEdge* addVariantGepCGEdge(NodeID src, NodeID dst);
     /// Add Load edge
     LoadCGEdge* addLoadCGEdge(NodeID src, NodeID dst);
@@ -325,9 +325,9 @@ 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& apOffset)
     {
-        NodeID gep =  pag->getGepObjVar(id,ls);
+        NodeID gep =  pag->getGepObjVar(id, apOffset);
         /// Create a node when it is (1) not exist on graph and (2) not merged
         if(sccRepNode(gep)==gep && hasConstraintNode(gep)==false)
             addConstraintNode(new ConstraintNode(gep),gep);

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 ap;	///< Access path of the gep edge
 
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
@@ -293,20 +293,22 @@ public:
     //@}
 
     /// Constructor
-    NormalGepCGEdge(ConstraintNode* s, ConstraintNode* d, const LocationSet& l, EdgeID id)
-        : GepCGEdge(s,d,NormalGep,id), ls(l)
-    {}
+    NormalGepCGEdge(ConstraintNode* s, ConstraintNode* d, const AccessPath& ap,
+                    EdgeID id)
+        : GepCGEdge(s, d, NormalGep, id), ap(ap)
+    {
+    }
 
     /// Get location set of the gep edge
-    inline const LocationSet& getLocationSet() const
+    inline const AccessPath& getAccessPath() const
     {
-        return ls;
+        return ap;
     }
 
     /// Get location set of the gep edge
-    inline s32_t getConstantFieldIdx() const
+    inline APOffset getConstantFieldIdx() const
     {
-        return ls.getConstantFieldIdx();
+        return ap.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)
-        : fldIdx(ls.fldIdx),
-          offsetVarAndGepTypePairs(ls.getOffsetVarAndGepTypePairVec())
+    AccessPath(const AccessPath& ap)
+        : fldIdx(ap.fldIdx),
+          offsetVarAndGepTypePairs(ap.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,26 @@ 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 &ap) const
     {
         SVF::Hash<std::pair<SVF::NodeID, SVF::NodeID>> h;
-        std::hash<SVF::LocationSet::OffsetVarAndGepTypePairs> v;
-        return h(std::make_pair(ls.getConstantFieldIdx(), v(ls.getOffsetVarAndGepTypePairVec())));
+        std::hash<SVF::AccessPath::OffsetVarAndGepTypePairs> v;
+        return h(std::make_pair(ap.getConstantFieldIdx(),
+                                v(ap.getOffsetVarAndGepTypePairVec())));
     }
 };
 
-#endif /* LOCATIONSET_H_ */
+#endif /* AccessPath_H_ */

package/svf/include/MemoryModel/PointerAnalysis.h

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

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& ap);
     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& ap);
     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,8 @@ 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& ap) const;
 
     /// Add/get indirect callsites
     //@{
@@ -392,9 +393,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& ap);
     /// 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& ap) ;
     /// Get a field-insensitive obj SVFIR node according to a mem obj
     //@{
     inline NodeID getFIObjVar(const MemObj* obj) const
@@ -557,9 +558,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& ap, 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& apOffset);
     /// Add a field-insensitive node, this method can only invoked by getFIGepObjNode
     NodeID addFIObjNode(const MemObj* obj);
     //@}
@@ -665,12 +666,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& ap,
                         bool constGep);
     /// Add Offset(Gep) edge
-    GepStmt* addNormalGepStmt(NodeID src, NodeID dst, const LocationSet& ls);
+    GepStmt* addNormalGepStmt(NodeID src, NodeID dst, const AccessPath& ap);
     /// Add Variant(Gep) edge
-    GepStmt* addVariantGepStmt(NodeID src, NodeID dst, const LocationSet& ls);
+    GepStmt* addVariantGepStmt(NodeID src, NodeID dst, const AccessPath& ap);
     /// 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 ap;	///< Access path 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;
+        return ap;
     }
-    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,8 +515,8 @@ public:
     }
 
     /// constructor
-    GepStmt(SVFVar* s, SVFVar* d, const LocationSet& l, bool varfld = false)
-        : AssignStmt(s, d, SVFStmt::Gep), ls(l), variantField(varfld)
+    GepStmt(SVFVar* s, SVFVar* d, const AccessPath& ap, bool varfld = false)
+        : AssignStmt(s, d, SVFStmt::Gep), ap(ap), 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 ap;	// AccessPath
     const SVFType* gepValType;
 
     /// Constructor to create empty GeValVar (for SVFIRReader/deserialization)
@@ -411,16 +411,16 @@ public:
     //@}
 
     /// Constructor
-    GepValVar(const SVFValue* val, NodeID i, const LocationSet& l,
+    GepValVar(const SVFValue* val, NodeID i, const AccessPath& ap,
               const SVFType* ty)
-        : ValVar(val, i, GepValNode), ls(l), gepValType(ty)
+        : ValVar(val, i, GepValNode), ap(ap), gepValType(ty)
     {
     }
 
     /// offset of the base value variable
-    inline s32_t getConstantFieldIdx() const
+    inline APOffset getConstantFieldIdx() const
     {
-        return ls.getConstantFieldIdx();
+        return ap.getConstantFieldIdx();
     }
 
     /// Return name of a LLVM value
@@ -451,7 +451,7 @@ class GepObjVar: public ObjVar
     friend class SVFIRReader;
 
 private:
-    LocationSet ls;
+    APOffset apOffset = 0;
     NodeID base = 0;
 
     /// Constructor to create empty GepObjVar (for SVFIRReader/deserialization)
@@ -480,23 +480,17 @@ public:
     //@}
 
     /// Constructor
-    GepObjVar(const MemObj* mem, NodeID i, const LocationSet& l,
+    GepObjVar(const MemObj* mem, NodeID i, const APOffset& apOffset,
               PNODEK ty = GepObjNode)
-        : ObjVar(mem->getValue(), i, mem, ty), ls(l)
+        : ObjVar(mem->getValue(), i, mem, ty), apOffset(apOffset)
     {
         base = mem->getId();
     }
 
     /// 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();
+        return apOffset;
     }
 
     /// Set the base object from which this GEP node came from.
@@ -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(), apOffset);
     }
 
     /// 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(apOffset);
+        return "offset_" + std::to_string(apOffset);
     }
 
     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,8 @@ 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& apOffset);
 
     ///The struct type with the most fields
     const SVFType* maxStruct;
@@ -453,7 +454,7 @@ public:
     bool isConstDataOrConstGlobal() const;
     bool isConstDataOrAggData() const;
     bool hasPtrObj() const;
-    bool isNonPtrFieldObj(const LocationSet& ls) const;
+    bool isNonPtrFieldObj(const APOffset& apOffset) const;
     //@}
 
     /// Operator overloading
@@ -621,7 +622,7 @@ public:
     {
         return hasFlag(HASPTR_OBJ);
     }
-    virtual bool isNonPtrFieldObj(const LocationSet& ls);
+    virtual bool isNonPtrFieldObj(const APOffset& apOffset);
     //@}
 };
 

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

@@ -261,7 +261,7 @@ public:
 
     friend bool eq(const Z3Expr &lhs, const Z3Expr &rhs)
     {
-        return eq(lhs.getExpr(), rhs.getExpr());
+        return eq(lhs.getExpr().simplify(), rhs.getExpr().simplify());
     }
 
     z3::sort get_sort() const
@@ -293,7 +293,7 @@ public:
     /// compute NEG
     static inline Z3Expr NEG(const Z3Expr &z3Expr)
     {
-        return !z3Expr;
+        return (!z3Expr).simplify();
     }
 
     /// compute AND, used for branch condition

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