svf-tools 1.0.348 → 1.0.352

package/include/Graphs/GenericGraph.h

@@ -50,7 +50,7 @@ public:
     ///	(1) 0-7 bits encode an edge kind (allow maximum 16 kinds)
     /// (2) 8-63 bits encode a callsite instruction
     typedef u64_t GEdgeFlag;
-    typedef s32_t GEdgeKind;
+    typedef s64_t GEdgeKind;
 private:
     NodeTy* src;		///< source node
     NodeTy* dst;		///< destination node
@@ -132,7 +132,7 @@ public:
     typedef NodeTy NodeType;
     typedef EdgeTy EdgeType;
     /// Edge kind
-    typedef s32_t GNodeK;
+    typedef s64_t GNodeK;
     typedef OrderedSet<EdgeType*, typename EdgeType::equalGEdge> GEdgeSetTy;
     /// Edge iterator
     ///@{
@@ -284,13 +284,13 @@ public:
 
     /// Remove incoming and outgoing edges
     ///@{
-    inline Size_t removeIncomingEdge(EdgeType* edge)
+    inline u32_t removeIncomingEdge(EdgeType* edge)
     {
         iterator it = InEdges.find(edge);
         assert(it != InEdges.end() && "can not find in edge in SVFG node");
         return InEdges.erase(edge);
     }
-    inline Size_t removeOutgoingEdge(EdgeType* edge)
+    inline u32_t removeOutgoingEdge(EdgeType* edge)
     {
         iterator it = OutEdges.find(edge);
         assert(it != OutEdges.end() && "can not find out edge in SVFG node");

package/include/Graphs/IRGraph.h

@@ -166,11 +166,11 @@ public:
         return symInfo->getConstantObj();
     }
 
-    inline Size_t getValueNodeNum() const
+    inline u32_t getValueNodeNum() const
     {
         return symInfo->valSyms().size();
     }
-    inline Size_t getObjectNodeNum() const
+    inline u32_t getObjectNodeNum() const
     {
         return symInfo->idToObjMap().size();
     }
@@ -183,15 +183,15 @@ public:
         nodeNumAfterPAGBuild = num;
     }
 
-    inline Size_t getPAGNodeNum() const
+    inline u32_t getPAGNodeNum() const
     {
         return nodeNum;
     }
-    inline Size_t getPAGEdgeNum() const
+    inline u32_t getPAGEdgeNum() const
     {
         return edgeNum;
     }
-    inline Size_t getPTAPAGEdgeNum() const
+    inline u32_t getPTAPAGEdgeNum() const
     {
         return totalPTAPAGEdge;
     }

package/include/Graphs/PTACallGraph.h

@@ -251,7 +251,7 @@ protected:
     CallInstToCallGraphEdgesMap callinstToCallGraphEdgesMap; ///< Map a call instruction to its corresponding call edges
 
     NodeID callGraphNodeNum;
-    Size_t numOfResolvedIndCallEdge;
+    u32_t numOfResolvedIndCallEdge;
 
     /// Clean up memory
     void destroy();
@@ -297,7 +297,7 @@ public:
         return totalCallSiteNum;
     }
 
-    inline Size_t getNumOfResolvedIndCallEdge() const
+    inline u32_t getNumOfResolvedIndCallEdge() const
     {
         return numOfResolvedIndCallEdge;
     }

package/include/Graphs/VFG.h

@@ -427,7 +427,7 @@ protected:
     void addVFGNodes();
 
     /// Get PAGEdge set
-    virtual inline PAGEdge::SVFStmtSetTy& getPAGEdgeSet(PAGEdge::PEDGEK kind)
+    virtual inline SVFStmt::SVFStmtSetTy& getPAGEdgeSet(SVFStmt::PEDGEK kind)
     {
         if (isPtrOnlySVFG())
             return pag->getPTASVFStmtSet(kind);
@@ -435,7 +435,7 @@ protected:
             return pag->getSVFStmtSet(kind);
     }
 
-    virtual inline bool isInterestedPAGNode(const PAGNode* node) const
+    virtual inline bool isInterestedPAGNode(const SVFVar* node) const
     {
         if (isPtrOnlySVFG())
             return node->isPointer();

package/include/MSSA/MSSAMuChi.h

@@ -47,7 +47,7 @@ public:
     typedef MSSADEF MSSADef;
 private:
     /// ver ID 0 is reserved
-    static Size_t totalVERNum;
+    static u32_t totalVERNum;
     const MemRegion* mr;
     MRVERSION version;
     MRVERID vid;

package/include/MSSA/MemRegion.h

@@ -55,7 +55,7 @@ public:
     typedef bool Condition;
 private:
     /// region ID 0 is reserved
-    static Size_t totalMRNum;
+    static u32_t totalMRNum;
     MRID rid;
     const NodeBS cptsSet;
 
@@ -413,7 +413,7 @@ protected:
     //@}
 
 public:
-    inline Size_t getMRNum() const
+    inline u32_t getMRNum() const
     {
         return memRegSet.size();
     }

package/include/MemoryModel/LocationSet.h

@@ -78,10 +78,10 @@ public:
         NonOverlap, Overlap, Subset, Superset, Same
     };
 
-    typedef std::vector<const Value* > OffsetValueVec;
+    typedef std::vector<std::pair<const Value*, const Type*> > OffsetValueVec;
 
     /// Constructor
-    LocationSet(Size_t o = 0) : fldIdx(o)
+    LocationSet(s64_t o = 0) : fldIdx(o)
     {}
 
     /// Copy Constructor
@@ -98,50 +98,16 @@ public:
 
     ~LocationSet() {}
 
-
     /// Overload operators
     //@{
-    inline LocationSet operator+ (const LocationSet& rhs) const
-    {
-        LocationSet ls(rhs);
-        ls.fldIdx += accumulateConstantFieldIdx();
-        OffsetValueVec::const_iterator it = getOffsetValueVec().begin();
-        OffsetValueVec::const_iterator eit = getOffsetValueVec().end();
-        for (; it != eit; ++it)
-            ls.addOffsetValue(*it);
-
-        return ls;
-    }
+    LocationSet operator+ (const LocationSet& rhs) const;
+    bool operator< (const LocationSet& rhs) const;
     inline const LocationSet& operator= (const LocationSet& rhs)
     {
         fldIdx = rhs.fldIdx;
         offsetValues = rhs.getOffsetValueVec();
         return *this;
     }
-    inline bool operator< (const LocationSet& rhs) const
-    {
-        if (fldIdx != rhs.fldIdx)
-            return (fldIdx < rhs.fldIdx);
-        else
-        {
-            const OffsetValueVec& pairVec = getOffsetValueVec();
-            const OffsetValueVec& rhsPairVec = rhs.getOffsetValueVec();
-            if (pairVec.size() != rhsPairVec.size())
-                return (pairVec.size() < rhsPairVec.size());
-            else
-            {
-                OffsetValueVec::const_iterator it = pairVec.begin();
-                OffsetValueVec::const_iterator rhsIt = rhsPairVec.begin();
-                for (; it != pairVec.end() && rhsIt != rhsPairVec.end(); ++it, ++rhsIt)
-                {
-                    return (*it) < (*rhsIt);
-                }
-
-                return false;
-            }
-        }
-    }
-
     inline bool operator==(const LocationSet& rhs) const
     {
         return this->fldIdx == rhs.fldIdx
@@ -151,11 +117,11 @@ public:
 
     /// Get methods
     //@{
-    inline Size_t accumulateConstantFieldIdx() const
+    inline s64_t accumulateConstantFieldIdx() const
     {
         return fldIdx;
     }
-    inline void setFldIdx(Size_t idx)
+    inline void setFldIdx(s64_t idx)
     {
         fldIdx = idx;
     }
@@ -165,7 +131,9 @@ public:
     }
     //@}
 
-    bool addOffsetValue(const Value* offsetValue);
+    s64_t accumulateConstantOffset() const;
+
+    bool addOffsetValue(const Value* offsetValue, const Type* type);
 
     /// Return TRUE if this is a constant location set.
     bool isConstantOffset() const;
@@ -187,13 +155,7 @@ private:
     /// Compute all possible locations according to offset and number-stride pairs.
     NodeBS computeAllLocations() const;
 
-    /// Return greatest common divisor
-    inline unsigned gcd (unsigned n1, unsigned n2) const
-    {
-        return (n2 == 0) ? n1 : gcd (n2, n1 % n2);
-    }
-
-    Size_t fldIdx;	///< Accumulated Constant Offsets
+    s64_t fldIdx;	///< Accumulated Constant Offsets
     OffsetValueVec offsetValues;	///< a vector of actual offset in the form of Values
 };
 

package/include/MemoryModel/PAGBuilderFromFile.h

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

package/include/MemoryModel/PointerAnalysis.h

@@ -170,7 +170,7 @@ public:
 		return pag->getICFG();
 	}
     /// Return number of resolved indirect call edges
-    inline Size_t getNumOfResolvedIndCallEdge() const
+    inline u32_t getNumOfResolvedIndCallEdge() const
     {
         return getPTACallGraph()->getNumOfResolvedIndCallEdge();
     }

package/include/MemoryModel/SVFIR.h

@@ -63,7 +63,7 @@ public:
     typedef Map<const SVFFunction*,SVFStmtSet> FunToPAGEdgeSetMap;
     typedef Map<const ICFGNode*,SVFStmtList> ICFGNode2SVFStmtsMap;
     typedef Map<NodeID, NodeID> NodeToNodeMap;
-    typedef std::pair<NodeID, Size_t> NodeOffset;
+    typedef std::pair<NodeID, s64_t> NodeOffset;
     typedef std::pair<NodeID, LocationSet> NodeLocationSet;
     typedef Map<NodeOffset,NodeID> NodeOffsetMap;
     typedef Map<NodeLocationSet,NodeID> NodeLocationSetMap;
@@ -281,11 +281,11 @@ public:
 
     /// Node and edge statistics
     //@{
-    inline Size_t getFieldValNodeNum() const
+    inline u32_t getFieldValNodeNum() const
     {
         return GepValObjMap.size();
     }
-    inline Size_t getFieldObjNodeNum() const
+    inline u32_t getFieldObjNodeNum() const
     {
         return GepObjVarMap.size();
     }
@@ -649,9 +649,9 @@ private:
     /// Add Gep edge
     GepStmt* addGepStmt(NodeID src, NodeID dst, const LocationSet& ls, bool constGep);
     /// Add Offset(Gep) edge
-    NormalGepStmt* addNormalGepStmt(NodeID src, NodeID dst, const LocationSet& ls);
+    GepStmt* addNormalGepStmt(NodeID src, NodeID dst, const LocationSet& ls);
     /// Add Variant(Gep) edge
-    VariantGepStmt* addVariantGepStmt(NodeID src, NodeID dst, const LocationSet& ls);
+    GepStmt* addVariantGepStmt(NodeID src, NodeID dst, const LocationSet& ls);
     /// Add Thread fork edge for parameter passing
     TDForkPE* addThreadForkPE(NodeID src, NodeID dst, const CallICFGNode* cs);
     /// Add Thread join edge for parameter passing

package/include/MemoryModel/SVFStatements.h

@@ -53,7 +53,7 @@ public:
     /// ThreadFork/ThreadJoin is to model parameter passings between thread spawners and spawnees.
     enum PEDGEK
     {
-        Addr, Copy, Store, Load, Call, Ret, NormalGep, VariantGep, Phi, Cmp, BinaryOp, UnaryOp, Branch, ThreadFork, ThreadJoin
+        Addr, Copy, Store, Load, Call, Ret, Gep, Phi, Cmp, BinaryOp, UnaryOp, Branch, ThreadFork, ThreadJoin
     };
 
 private:
@@ -62,7 +62,7 @@ private:
     ICFGNode *icfgNode;   ///< ICFGNode
     EdgeID edgeId;					///< Edge ID
 public:
-    static Size_t totalEdgeNum;		///< Total edge number
+    static u32_t totalEdgeNum;		///< Total edge number
 
     /// Constructor
     SVFStmt(SVFVar* s, SVFVar* d, GEdgeFlag k);
@@ -85,8 +85,7 @@ public:
                edge->getEdgeKind() == SVFStmt::Load ||
                edge->getEdgeKind() == SVFStmt::Call ||
                edge->getEdgeKind() == SVFStmt::Ret ||
-               edge->getEdgeKind() == SVFStmt::NormalGep ||
-               edge->getEdgeKind() == SVFStmt::VariantGep ||
+               edge->getEdgeKind() == SVFStmt::Gep ||
                edge->getEdgeKind() == SVFStmt::Cmp ||
                edge->getEdgeKind() == SVFStmt::BinaryOp ||
                edge->getEdgeKind() == SVFStmt::UnaryOp  ||
@@ -227,8 +226,7 @@ public:
                edge->getEdgeKind() == SVFStmt::Load ||
                edge->getEdgeKind() == SVFStmt::Call ||
                edge->getEdgeKind() == SVFStmt::Ret ||
-               edge->getEdgeKind() == SVFStmt::NormalGep ||
-               edge->getEdgeKind() == SVFStmt::VariantGep ||
+               edge->getEdgeKind() == SVFStmt::Gep ||
                edge->getEdgeKind() == SVFStmt::ThreadFork ||
                edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
@@ -240,8 +238,7 @@ public:
                edge->getEdgeKind() == SVFStmt::Load ||
                edge->getEdgeKind() == SVFStmt::Call ||
                edge->getEdgeKind() == SVFStmt::Ret ||
-               edge->getEdgeKind() == SVFStmt::NormalGep ||
-               edge->getEdgeKind() == SVFStmt::VariantGep ||
+               edge->getEdgeKind() == SVFStmt::Gep ||
                edge->getEdgeKind() == SVFStmt::ThreadFork ||
                edge->getEdgeKind() == SVFStmt::ThreadJoin;
     }
@@ -417,7 +414,7 @@ private:
     void operator=(const GepStmt &); ///< place holder
 
     LocationSet 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:
     //@{
@@ -427,111 +424,37 @@ public:
     }
     static inline bool classof(const SVFStmt *edge)
     {
-        return 	edge->getEdgeKind() == SVFStmt::NormalGep ||
-                edge->getEdgeKind() == SVFStmt::VariantGep;
+        return 	edge->getEdgeKind() == SVFStmt::Gep;
     }
     static inline bool classof(const GenericPAGEdgeTy *edge)
     {
-        return	edge->getEdgeKind() == SVFStmt::NormalGep ||
-                edge->getEdgeKind() == SVFStmt::VariantGep;
+        return	edge->getEdgeKind() == SVFStmt::Gep;
     }
     //@}
 
     inline const LocationSet& getLocationSet() const
     {
+        assert(isVariantFieldGep()==false && "Can't retrieve the LocationSet if using a variable field index (pointer arithmetic) for struct field access ");
         return ls;
     }
 
-protected:
-    /// constructor
-    GepStmt(SVFVar* s, SVFVar* d, const LocationSet& l, PEDGEK k) : AssignStmt(s,d,k), ls(l)
-    {
-    }
-
-    virtual const std::string toString() const;
-
-};
-
-
-/*!
- * Gep statement with a fixed field index for struct field access 
- */
-class NormalGepStmt : public GepStmt
-{
-private:
-    NormalGepStmt(); ///< place holder
-    NormalGepStmt(const NormalGepStmt&); ///< place holder
-    void operator=(const NormalGepStmt&); ///< place holder
-
-public:
-    /// Methods for support type inquiry through isa, cast, and dyn_cast:
-    //@{
-    static inline bool classof(const NormalGepStmt *)
+    /// offset of the gep statement
+    inline s64_t getConstantFieldIdx() const
     {
-        return true;
-    }
-    static inline bool classof(const GepStmt *edge)
-    {
-        return edge->getEdgeKind() == SVFStmt::NormalGep;
-    }
-    static inline bool classof(const SVFStmt *edge)
-    {
-        return edge->getEdgeKind() == SVFStmt::NormalGep;
+        return getLocationSet().accumulateConstantFieldIdx();
     }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
+    /// Gep statement with a variant field index (pointer arithmetic) for struct field access 
+    inline bool isVariantFieldGep() const
     {
-        return edge->getEdgeKind() == SVFStmt::NormalGep;
-    }
-    //@}
+        return variantField;
+    }   
 
     /// constructor
-    NormalGepStmt(SVFVar* s, SVFVar* d, const LocationSet& l) : GepStmt(s,d,l, SVFStmt::NormalGep)
-    {}
-
-    /// offset of the gep edge
-    inline u32_t getFieldOffset() const
+    GepStmt(SVFVar* s, SVFVar* d, const LocationSet& l, bool varfld=false) : AssignStmt(s,d,SVFStmt::Gep), ls(l), variantField(varfld)
     {
-        return getLocationSet().accumulateConstantFieldIdx();
     }
 
-    virtual const std::string toString() const override;
-};
-
-/*!
- * Gep statement with a variant field index for struct field access 
- */
-class VariantGepStmt : public GepStmt
-{
-private:
-    VariantGepStmt(); ///< place holder
-    VariantGepStmt(const VariantGepStmt&); ///< place holder
-    void operator=(const VariantGepStmt&); ///< place holder
-
-public:
-    /// Methods for support type inquiry through isa, cast, and dyn_cast:
-    //@{
-    static inline bool classof(const VariantGepStmt *)
-    {
-        return true;
-    }
-    static inline bool classof(const GepStmt *edge)
-    {
-        return edge->getEdgeKind() == SVFStmt::VariantGep;
-    }
-    static inline bool classof(const SVFStmt *edge)
-    {
-        return edge->getEdgeKind() == SVFStmt::VariantGep;
-    }
-    static inline bool classof(const GenericPAGEdgeTy *edge)
-    {
-        return edge->getEdgeKind() == SVFStmt::VariantGep;
-    }
-    //@}
-
-    /// constructor
-    VariantGepStmt(SVFVar* s, SVFVar* d, const LocationSet& l) : GepStmt(s,d,l, SVFStmt::VariantGep) {}
-
-    virtual const std::string toString() const override;
+    virtual const std::string toString() const;
 
 };
 

package/include/MemoryModel/SVFVariables.h

@@ -241,10 +241,13 @@ private:
     /// Has incoming VariantGepEdges
     inline bool hasIncomingVariantGepEdge() const
     {
-        SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(SVFStmt::VariantGep);
+        SVFStmt::KindToSVFStmtMapTy::const_iterator it = InEdgeKindToSetMap.find(SVFStmt::Gep);
         if (it != InEdgeKindToSetMap.end())
         {
-            return (!it->second.empty());
+            for(auto gep : it->second){
+                if(SVFUtil::cast<GepStmt>(gep)->isVariantFieldGep())
+                    return true;
+            }
         }
         return false;
     }
@@ -422,7 +425,7 @@ public:
     }
 
     /// offset of the base value variable
-    inline u32_t getFieldOffset() const
+    inline s64_t getConstantFieldIdx() const
     {
         return ls.accumulateConstantFieldIdx();
     }
@@ -431,8 +434,8 @@ public:
     inline const std::string getValueName() const
     {
         if (value && value->hasName())
-            return value->getName().str() + "_" + llvm::utostr(getFieldOffset());
-        return "offset_" + llvm::utostr(getFieldOffset());
+            return value->getName().str() + "_" + llvm::utostr(getConstantFieldIdx());
+        return "offset_" + llvm::utostr(getConstantFieldIdx());
     }
 
     inline const Type* getType() const
@@ -497,7 +500,7 @@ public:
     }
 
     /// offset of the mem object
-    inline u32_t getFieldOffset() const
+    inline s64_t getConstantFieldIdx() const
     {
         return ls.accumulateConstantFieldIdx();
     }

package/include/MemoryModel/SymbolTableInfo.h

@@ -302,7 +302,7 @@ public:
  
     /// Statistics
     //@{
-    inline Size_t getTotalSymNum() const
+    inline u32_t getTotalSymNum() const
     {
         return totalSymNum;
     }
@@ -454,7 +454,7 @@ public:
     const Type* getType() const;
 
     /// Get max field offset limit
-    Size_t getMaxFieldOffsetLimit() const;
+    u32_t getMaxFieldOffsetLimit() const;
 
     /// Return true if its field limit is 0
     bool isFieldInsensitive() const;
@@ -601,7 +601,7 @@ private:
     /// LLVM type
     const Type* type;
     /// Type flags
-    Size_t flags;
+    u32_t flags;
     /// Max offset for flexible field sensitive analysis
     /// maximum number of field object can be created
     /// minimum number is 0 (field insensitive analysis)

package/include/SVF-FE/DCHG.h

@@ -46,7 +46,7 @@ public:
     {
     }
 
-    u32_t getFieldOffset(void) const
+    u32_t getConstantFieldIdx(void) const
     {
         return offset;
     }

package/include/SVF-FE/SVFIRBuilder.h

@@ -72,8 +72,8 @@ public:
     /// Initialize nodes and edges
     //@{
     void initialiseNodes();
-    void addEdge(NodeID src, NodeID dst, PAGEdge::PEDGEK kind,
-                 Size_t offset = 0, Instruction* cs = nullptr);
+    void addEdge(NodeID src, NodeID dst, SVFStmt::PEDGEK kind,
+                 s64_t offset = 0, Instruction* cs = nullptr);
     // @}
 
     /// Sanity check for SVFIR
@@ -122,7 +122,7 @@ public:
     void processCE(const Value *val);
 
     /// Infer field index from byteoffset.
-    u32_t inferFieldIdxFromByteOffset(const llvm::GEPOperator* gepOp, DataLayout *dl, LocationSet& ls, Size_t idx);
+    u32_t inferFieldIdxFromByteOffset(const llvm::GEPOperator* gepOp, DataLayout *dl, LocationSet& ls, s64_t idx);
 
     /// Compute offset of a gep instruction or gep constant expression
     bool computeGepOffset(const User *V, LocationSet& ls);
@@ -377,16 +377,16 @@ public:
         return edge;
     }
     /// Add Offset(Gep) edge
-    inline NormalGepStmt* addNormalGepEdge(NodeID src, NodeID dst, const LocationSet& ls)
+    inline GepStmt* addNormalGepEdge(NodeID src, NodeID dst, const LocationSet& ls)
     {
-        NormalGepStmt *edge = pag->addNormalGepStmt(src, dst, ls);
+        GepStmt *edge = pag->addNormalGepStmt(src, dst, ls);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }
     /// Add Variant(Gep) edge
-    inline VariantGepStmt* addVariantGepEdge(NodeID src, NodeID dst, const LocationSet& ls)
+    inline GepStmt* addVariantGepEdge(NodeID src, NodeID dst, const LocationSet& ls)
     {
-        VariantGepStmt *edge = pag->addVariantGepStmt(src, dst, ls);
+        GepStmt *edge = pag->addVariantGepStmt(src, dst, ls);
         setCurrentBBAndValueForPAGEdge(edge);
         return edge;
     }

package/include/Util/IRAnnotator.h

@@ -64,7 +64,7 @@ private:
     void writePAGgepNode(SVF::NodeID nodeId, GepObjVar* gepNode)
     {
         auto baseNodeId = gepNode->getBaseNode();
-        auto locationSetOffset = gepNode->getFieldOffset();
+        auto locationSetOffset = gepNode->getConstantFieldIdx();
 
         LLVMContext &context = mainModule->getContext();
         llvm::SmallVector<llvm::Metadata *, 32> operands;
@@ -85,7 +85,7 @@ private:
         {
             std::string label = it->getName().str();
             std::string toErase = "gepnode-";
-            SVF::Size_t pos = label.find(toErase);
+            SVF::s64_t pos = label.find(toErase);
             if (pos == std::string::npos)
             {
                 continue;
@@ -96,7 +96,7 @@ private:
             auto mdNode = it->getOperand(0);
 
             SVF::NodeID baseNodeId = std::stoi(llvm::cast<llvm::MDString>(mdNode->getOperand(0))->getString().str());
-            SVF::Size_t locationSetOffset = std::stoi(llvm::cast<llvm::MDString>(mdNode->getOperand(1))->getString().str());
+            SVF::s64_t locationSetOffset = std::stoi(llvm::cast<llvm::MDString>(mdNode->getOperand(1))->getString().str());
 
             LocationSet locationSet = LocationSet(locationSetOffset);
             SVF::NodeID gepnodeId = pag->getGepObjVar(baseNodeId, locationSet);

package/include/Util/SVFBasicTypes.h

@@ -73,9 +73,9 @@ template <class T> struct Hash {
 };
 
 typedef unsigned u32_t;
-typedef unsigned long long u64_t;
 typedef signed s32_t;
-typedef signed long Size_t;
+typedef unsigned long long u64_t;
+typedef signed s64_t;
 
 typedef u32_t NodeID;
 typedef u32_t EdgeID;
@@ -183,7 +183,7 @@ class SVFValue
 {
 
 public:
-    typedef s32_t GNodeK;
+    typedef s64_t GNodeK;
 
     enum SVFValKind
     {