svf-tools 1.0.348 → 1.0.352

package/lib/MemoryModel/LocationSet.cpp

@@ -39,26 +39,29 @@ using namespace SVFUtil;
 /*!
  * Add offset value to vector offsetValues
  */
-bool LocationSet::addOffsetValue(const Value* offsetVal)
+bool LocationSet::addOffsetValue(const Value* offsetVal, const Type* type)
 {
-    for(const Value* val : offsetValues){
-        if(val==offsetVal)
-            return false;
-    }
-    offsetValues.push_back(offsetVal);
+    offsetValues.push_back(std::make_pair(offsetVal,type));
     return true;
 }
 
 /// Return TRUE if all offset values are constants
 bool LocationSet::isConstantOffset() const
 {
-    for(const Value* val : offsetValues){
-        if(SVFUtil::isa<ConstantInt>(val) == false)
+    for(auto it : offsetValues){
+        if(SVFUtil::isa<ConstantInt>(it.first) == false)
             return false;
     }
     return true;
 }
 
+/// Return accmuated constant offset
+/// offsetValues: [(v1,t1), (v2,t2), (v3,t3)]
+/// v1*sz(t2) + v2*sz(t3) + v3 
+s64_t LocationSet::accumulateConstantOffset() const{
+
+    return 0;
+}
 /*!
  * Compute all possible locations according to offset and number-stride pairs.
  */
@@ -69,6 +72,43 @@ NodeBS LocationSet::computeAllLocations() const
     return result;
 }
 
+LocationSet 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->first, it->second);
+
+    return ls;
+}
+
+
+bool LocationSet::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;
+        }
+    }
+}
+
 SVF::LocationSet::LSRelation LocationSet::checkRelation(const LocationSet& LHS, const LocationSet& RHS)
 {
     NodeBS lhsLocations = LHS.computeAllLocations();
@@ -103,7 +143,7 @@ std::string LocationSet::dump() const
     OffsetValueVec::const_iterator eit = vec.end();
     for (; it != eit; ++it)
     {
-        rawstr << " (" << value2String(*it) << ")";
+        rawstr << " (value: " << value2String(it->first) << " type: " << it->second << ")";
     }
     rawstr << " }\n";
     return rawstr.str();

package/lib/MemoryModel/PAGBuilderFromFile.cpp

@@ -67,7 +67,7 @@ SVFIR* PAGBuilderFromFile::build()
         {
             getline(myfile, line);
 
-            Size_t token_count = 0;
+            u32_t token_count = 0;
             string tmps;
             istringstream ss(line);
             while (ss.good())
@@ -103,7 +103,7 @@ SVFIR* PAGBuilderFromFile::build()
             {
                 NodeID nodeSrc;
                 NodeID nodeDst;
-                Size_t offsetOrCSId;
+                s64_t offsetOrCSId;
                 string edge;
                 istringstream ss(line);
                 ss >> nodeSrc;
@@ -144,7 +144,7 @@ SVFIR* PAGBuilderFromFile::build()
  * Add SVFIR edge according to a file format
  */
 void PAGBuilderFromFile::addEdge(NodeID srcID, NodeID dstID,
-                                 Size_t offsetOrCSId, std::string edge)
+                                 s64_t offsetOrCSId, std::string edge)
 {
 
     //check whether these two nodes available

package/lib/MemoryModel/PointerAnalysisImpl.cpp

@@ -154,7 +154,7 @@ void BVDataPTAImpl::writeToFile(const string& filename)
         {
             F.os() << it->first << " ";
             F.os() << pag->getBaseObjVar(it->first) << " ";
-            F.os() << gepObjPN->getFieldOffset() << "\n";
+            F.os() << gepObjPN->getConstantFieldIdx() << "\n";
         }
     }
 

package/lib/MemoryModel/SVFIR.cpp

@@ -312,7 +312,7 @@ GepStmt* SVFIR::addGepStmt(NodeID src, NodeID dst, const LocationSet& ls, bool c
     if (!constGep || node->hasIncomingVariantGepEdge())
     {
         /// Since the offset from base to src is variant,
-        /// the new gep edge being created is also a VariantGepStmt edge.
+        /// the new gep edge being created is also a Variant GepStmt edge.
         return addVariantGepStmt(src, dst, ls);
     }
     else
@@ -324,16 +324,16 @@ GepStmt* SVFIR::addGepStmt(NodeID src, NodeID dst, const LocationSet& ls, bool c
 /*!
  * Add normal (Gep) edge
  */
-NormalGepStmt* SVFIR::addNormalGepStmt(NodeID src, NodeID dst, const LocationSet& ls)
+GepStmt* SVFIR::addNormalGepStmt(NodeID src, NodeID dst, const LocationSet& ls)
 {
     const LocationSet& baseLS = getLocationSetFromBaseNode(src);
     SVFVar* baseNode = getGNode(getBaseValVar(src));
     SVFVar* dstNode = getGNode(dst);
-    if(SVFStmt* edge = hasNonlabeledEdge(baseNode, dstNode, SVFStmt::NormalGep))
-        return SVFUtil::cast<NormalGepStmt>(edge);
+    if(SVFStmt* edge = hasNonlabeledEdge(baseNode, dstNode, SVFStmt::Gep))
+        return SVFUtil::cast<GepStmt>(edge);
     else
     {
-        NormalGepStmt* gepPE = new NormalGepStmt(baseNode, dstNode, baseLS+ls);
+        GepStmt* gepPE = new GepStmt(baseNode, dstNode, baseLS+ls);
         addToStmt2TypeMap(gepPE);
         addEdge(baseNode, dstNode, gepPE);
         return gepPE;
@@ -344,16 +344,16 @@ NormalGepStmt* SVFIR::addNormalGepStmt(NodeID src, NodeID dst, const LocationSet
  * Add variant(Gep) edge
  * Find the base node id of src and connect base node to dst node
  */
-VariantGepStmt* SVFIR::addVariantGepStmt(NodeID src, NodeID dst, const LocationSet& ls)
+GepStmt* SVFIR::addVariantGepStmt(NodeID src, NodeID dst, const LocationSet& ls)
 {
     const LocationSet& baseLS = getLocationSetFromBaseNode(src);
     SVFVar* baseNode = getGNode(getBaseValVar(src));
     SVFVar* dstNode = getGNode(dst);
-    if(SVFStmt* edge = hasNonlabeledEdge(baseNode, dstNode, SVFStmt::VariantGep))
-        return SVFUtil::cast<VariantGepStmt>(edge);
+    if(SVFStmt* edge = hasNonlabeledEdge(baseNode, dstNode, SVFStmt::Gep))
+        return SVFUtil::cast<GepStmt>(edge);
     else
     {
-        VariantGepStmt* gepPE = new VariantGepStmt(baseNode, dstNode,baseLS+ls);
+        GepStmt* gepPE = new GepStmt(baseNode, dstNode,baseLS+ls, true);
         addToStmt2TypeMap(gepPE);
         addEdge(baseNode, dstNode, gepPE);
         return gepPE;
@@ -500,18 +500,13 @@ NodeBS SVFIR::getFieldsAfterCollapse(NodeID id)
 NodeID SVFIR::getBaseValVar(NodeID nodeId)
 {
     SVFVar* node  = getGNode(nodeId);
-    if (node->hasIncomingEdges(SVFStmt::NormalGep) ||  node->hasIncomingEdges(SVFStmt::VariantGep))
+    if (node->hasIncomingEdges(SVFStmt::Gep))
     {
-        SVFStmt::SVFStmtSetTy& ngeps = node->getIncomingEdges(SVFStmt::NormalGep);
-        SVFStmt::SVFStmtSetTy& vgeps = node->getIncomingEdges(SVFStmt::VariantGep);
+        SVFStmt::SVFStmtSetTy& geps = node->getIncomingEdges(SVFStmt::Gep);
 
-        assert(((ngeps.size()+vgeps.size())==1) && "one node can only be connected by at most one gep edge!");
+        assert((geps.size()==1) && "one node can only be connected by at most one gep edge!");
 
-        SVFVar::iterator it;
-        if(!ngeps.empty())
-            it = ngeps.begin();
-        else
-            it = vgeps.begin();
+        SVFVar::iterator it = geps.begin();
 
         assert(SVFUtil::isa<GepStmt>(*it) && "not a gep edge??");
         return (*it)->getSrcID();
@@ -524,22 +519,23 @@ NodeID SVFIR::getBaseValVar(NodeID nodeId)
  * Get a base SVFVar given a pointer
  * Return the source node of its connected normal gep edge
  * Otherwise return the node id itself
- * Size_t offset : gep offset
+ * s64_t offset : gep offset
  */
 LocationSet SVFIR::getLocationSetFromBaseNode(NodeID nodeId)
 {
     SVFVar* node  = getGNode(nodeId);
-    SVFStmt::SVFStmtSetTy& geps = node->getIncomingEdges(SVFStmt::NormalGep);
+    SVFStmt::SVFStmtSetTy& geps = node->getIncomingEdges(SVFStmt::Gep);
     /// if this node is already a base node
     if(geps.empty())
         return LocationSet(0);
 
     assert(geps.size()==1 && "one node can only be connected by at most one gep edge!");
     SVFVar::iterator it = geps.begin();
-    const SVFStmt* edge = *it;
-    assert(SVFUtil::isa<NormalGepStmt>(edge) && "not a get edge??");
-    const NormalGepStmt* gepEdge = SVFUtil::cast<NormalGepStmt>(edge);
-    return gepEdge->getLocationSet();
+    const GepStmt* gepEdge = SVFUtil::cast<GepStmt>(*it);
+    if(gepEdge->isVariantFieldGep())
+        return LocationSet(0);
+    else
+        return gepEdge->getLocationSet();
 }
 
 /*!
@@ -606,21 +602,17 @@ void SVFIR::print()
                << (*iter)->getDstID() << "\n";
     }
 
-    SVFStmt::SVFStmtSetTy& ngeps = pag->getSVFStmtSet(SVFStmt::NormalGep);
+    SVFStmt::SVFStmtSetTy& ngeps = pag->getSVFStmtSet(SVFStmt::Gep);
     for (SVFStmt::SVFStmtSetTy::iterator iter = ngeps.begin(), eiter =
                 ngeps.end(); iter != eiter; ++iter)
     {
-        NormalGepStmt* gep = SVFUtil::cast<NormalGepStmt>(*iter);
-        outs() << gep->getRHSVarID() << " -- NormalGep (" << gep->getFieldOffset()
-               << ") --> " << gep->getLHSVarID() << "\n";
-    }
-
-    SVFStmt::SVFStmtSetTy& vgeps = pag->getSVFStmtSet(SVFStmt::VariantGep);
-    for (SVFStmt::SVFStmtSetTy::iterator iter = vgeps.begin(), eiter =
-                vgeps.end(); iter != eiter; ++iter)
-    {
-        outs() << (*iter)->getSrcID() << " -- VariantGep --> "
+        GepStmt* gep = SVFUtil::cast<GepStmt>(*iter);
+        if(gep->isVariantFieldGep())
+                outs() << (*iter)->getSrcID() << " -- VariantGep --> "
                << (*iter)->getDstID() << "\n";
+        else
+                outs() << gep->getRHSVarID() << " -- Gep (" << gep->getConstantFieldIdx()
+               << ") --> " << gep->getLHSVarID() << "\n";
     }
 
     SVFStmt::SVFStmtSetTy& loads = pag->getSVFStmtSet(SVFStmt::Load);

package/lib/MemoryModel/SVFStatements.cpp

@@ -186,28 +186,6 @@ const std::string GepStmt::toString() const{
     return rawstr.str();
 }
 
-const std::string NormalGepStmt::toString() const{
-    std::string str;
-    raw_string_ostream rawstr(str);
-    rawstr << "NormalGepStmt: [Var" << getLHSVarID() << " <-- Var" << getRHSVarID() << "]\t";
-    if (Options::ShowSVFIRValue) {
-        rawstr << "\n";
-        rawstr << value2String(getValue());
-    }
-    return rawstr.str();
-}
-
-const std::string VariantGepStmt::toString() const{
-    std::string str;
-    raw_string_ostream rawstr(str);
-    rawstr << "VariantGepStmt: [Var" << getLHSVarID() << " <-- Var" << getRHSVarID() << "]\t";
-    if (Options::ShowSVFIRValue) {
-        rawstr << "\n";
-        rawstr << value2String(getValue());
-    }
-    return rawstr.str();
-}
-
 const std::string CallPE::toString() const{
     std::string str;
     raw_string_ostream rawstr(str);

package/lib/MemoryModel/SVFVariables.cpp

@@ -133,7 +133,7 @@ const std::string ObjVar::toString() const {
 const std::string GepValVar::toString() const {
     std::string str;
     raw_string_ostream rawstr(str);
-    rawstr << "GepValVar ID: " << getId() << " with offset_" + llvm::utostr(getFieldOffset());
+    rawstr << "GepValVar ID: " << getId() << " with offset_" + llvm::utostr(getConstantFieldIdx());
     if (Options::ShowSVFIRValue) {
         rawstr << "\n";
         rawstr << value2String(value);

package/lib/MemoryModel/SymbolTableInfo.cpp

@@ -135,7 +135,7 @@ void SymbolTableInfo::collectStructInfo(const StructType *sty)
                 sty->element_end(); it != ie; ++it, ++field_idx)
     {
         const Type *et = *it;
-        /// offset with uint_32 (Size_t) is large enough and will not cause overflow
+        /// offset with int_32 (s64_t) is large enough and will not cause overflow
         stinfo->addFldWithType(nf, et);
 
         if (SVFUtil::isa<StructType>(et) || SVFUtil::isa<ArrayType>(et))
@@ -195,7 +195,7 @@ LocationSet SymbolTableInfo::getModulusOffset(const MemObj* obj, const LocationS
     /// of current struct. Make the offset positive so we can still get a node within current
     /// struct to represent this obj.
 
-    Size_t offset = ls.accumulateConstantFieldIdx();
+    s64_t offset = ls.accumulateConstantFieldIdx();
     if(offset < 0)
     {
         writeWrnMsg("try to create a gep node with negative offset.");
@@ -582,7 +582,7 @@ bool ObjTypeInfo::isNonPtrFieldObj(const LocationSet& ls)
             //       as we simply return new offset by mod operation without checking its
             //       correctness in LocSymTableInfo::getModulusOffset(). So the following
             //       assertion may fail. Try to refine the new memory model.
-            //assert(ls.getFieldOffset() == 0 && "cannot get a field from a non-struct type");
+            //assert(ls.getConstantFieldIdx() == 0 && "cannot get a field from a non-struct type");
             return (hasPtrObj() == false);
         }
     }
@@ -640,7 +640,7 @@ void MemObj::destroy()
 }
 
 /// Get max field offset limit
-Size_t MemObj::getMaxFieldOffsetLimit() const
+u32_t MemObj::getMaxFieldOffsetLimit() const
 {
     return typeInfo->getMaxFieldOffsetLimit();
 }

package/lib/SVF-FE/CPPUtil.cpp

@@ -55,7 +55,7 @@ const string structName = "struct.";
 
 static bool isOperOverload(const string name)
 {
-    s32_t leftnum = 0, rightnum = 0;
+    s64_t leftnum = 0, rightnum = 0;
     string subname = name;
     size_t leftpos, rightpos;
     leftpos = subname.find("<");
@@ -88,7 +88,7 @@ static string getBeforeParenthesis(const string &name)
     size_t lastRightParen = name.rfind(")");
     assert(lastRightParen > 0);
 
-    s32_t paren_num = 1, pos;
+    s64_t paren_num = 1, pos;
     for (pos = lastRightParen - 1; pos >= 0; pos--)
     {
         if (name[pos] == ')')
@@ -107,7 +107,7 @@ string cppUtil::getBeforeBrackets(const string &name)
     {
         return name;
     }
-    s32_t bracket_num = 1, pos;
+    s64_t bracket_num = 1, pos;
     for (pos = name.size() - 2; pos >= 0; pos--)
     {
         if (name[pos] == '>')
@@ -183,7 +183,7 @@ struct cppUtil::DemangledName cppUtil::demangle(const string &name)
     struct cppUtil::DemangledName dname;
     dname.isThunkFunc = false;
 
-    s32_t status;
+    s64_t status;
     char *realname = abi::__cxa_demangle(name.c_str(), 0, 0, &status);
     if (realname == nullptr)
     {
@@ -228,7 +228,7 @@ bool cppUtil::isLoadVtblInst(const LoadInst *loadInst)
     const Value *loadSrc = loadInst->getPointerOperand();
     const Type *valTy = loadSrc->getType();
     const Type *elemTy = valTy;
-    for (s32_t i = 0; i < 3; ++i)
+    for (s64_t i = 0; i < 3; ++i)
     {
         if (const PointerType *ptrTy = SVFUtil::dyn_cast<PointerType>(elemTy))
             elemTy = ptrTy->getElementType();
@@ -435,7 +435,7 @@ string cppUtil::getClassNameFromVtblObj(const Value *value)
     string className = "";
 
     string vtblName = value->getName().str();
-    s32_t status;
+    s64_t status;
     char *realname = abi::__cxa_demangle(vtblName.c_str(), 0, 0, &status);
     if (realname != nullptr)
     {

package/lib/SVF-FE/DCHG.cpp

@@ -103,7 +103,7 @@ void DCHGraph::handleDIDerivedType(const DIDerivedType *derivedType)
         assert(SVFUtil::isa<DIType>(derivedType->getScope()) && "inheriting from non-type?");
         DCHEdge *edge = addEdge(SVFUtil::dyn_cast<DIType>(derivedType->getScope()),
                                 derivedType->getBaseType(), DCHEdge::INHERITANCE);
-        // If the offset does not exist (for primary base), getFieldOffset should return 0.
+        // If the offset does not exist (for primary base), getConstantFieldIdx should return 0.
         edge->setOffset(derivedType->getOffsetInBits());
         break;
     }

package/lib/SVF-FE/Graph2Json.cpp

@@ -50,10 +50,10 @@ void ICFGPrinter::printICFGToJson(const std::string& filename)
                 edge_obj["Edge Type"] = getPAGEdgeKindValue(edge->getEdgeKind());
                 edge_obj["srcValueName"] = edge->getSrcNode()->getValueName();
                 edge_obj["dstValueName"] = edge->getDstNode()->getValueName();
-                if(edge->getEdgeKind()==PAGEdge::NormalGep)
+                if(edge->getEdgeKind()==SVFStmt::Gep)
                 {
-                    const NormalGepStmt* gepEdge = SVFUtil::cast<NormalGepStmt>(edge);
-                    edge_obj["offset"] = gepEdge->getFieldOffset();
+                    const GepStmt* gepEdge = SVFUtil::cast<GepStmt>(edge);
+                    edge_obj["offset"] = gepEdge->getConstantFieldIdx();
                 }
                 llvm::json::Value edge_value = llvm::json::Object{edge_obj};
                 PAGEdge_array.push_back(edge_value);
@@ -169,31 +169,31 @@ std::string ICFGPrinter::getPAGNodeKindValue(int kind)
 {
     switch (kind)
     {
-    case (PAGNode::ValNode):
+    case (SVFVar::ValNode):
         return "ValNode";
         break;
-    case PAGNode::ObjNode:
+    case SVFVar::ObjNode:
         return "ObjNode";
         break;
-    case PAGNode::RetNode:
+    case SVFVar::RetNode:
         return "RetNode";
         break;
-    case PAGNode::VarargNode:
+    case SVFVar::VarargNode:
         return "VarargNode";
         break;
-    case PAGNode::GepValNode:
+    case SVFVar::GepValNode:
         return "GepValNode";
         break;
-    case PAGNode::GepObjNode:
+    case SVFVar::GepObjNode:
         return "GepObjNode";
         break;
-    case PAGNode::FIObjNode:
+    case SVFVar::FIObjNode:
         return "FIObjNode";
         break;
-    case PAGNode::DummyValNode:
+    case SVFVar::DummyValNode:
         return "DummyValNode";
         break;
-    case PAGNode::DummyObjNode:
+    case SVFVar::DummyObjNode:
         return "DummyObjNode";
         break;
     }
@@ -204,43 +204,40 @@ std::string ICFGPrinter::getPAGEdgeKindValue(int kind)
 {
     switch(kind)
     {
-    case (PAGEdge::Addr):
+    case (SVFStmt::Addr):
         return "Addr";
         break;
-    case (PAGEdge::Copy):
+    case (SVFStmt::Copy):
         return "Copy";
         break;
-    case (PAGEdge::Store):
+    case (SVFStmt::Store):
         return "Store";
         break;
-    case (PAGEdge::Load):
+    case (SVFStmt::Load):
         return "Load";
         break;
-    case (PAGEdge::Call):
+    case (SVFStmt::Call):
         return "Call";
         break;
-    case (PAGEdge::Ret):
+    case (SVFStmt::Ret):
         return "Ret";
         break;
-    case (PAGEdge::NormalGep):
+    case (SVFStmt::Gep):
         return "NormalGep";
         break;
-    case (PAGEdge::VariantGep):
-        return "VariantGep";
-        break;
-    case (PAGEdge::ThreadFork):
+    case (SVFStmt::ThreadFork):
         return "ThreadFork";
         break;
-    case (PAGEdge::ThreadJoin):
+    case (SVFStmt::ThreadJoin):
         return "ThreadJoin";
         break;
-    case (PAGEdge::Cmp):
+    case (SVFStmt::Cmp):
         return "Cmp";
         break;
-    case (PAGEdge::BinaryOp):
+    case (SVFStmt::BinaryOp):
         return "BinaryOp";
         break;
-    case (PAGEdge::UnaryOp):
+    case (SVFStmt::UnaryOp):
         return "UnaryOp";
         break;
     }

package/lib/SVF-FE/LLVMUtil.cpp

@@ -370,7 +370,7 @@ void SVFUtil::processArguments(int argc, char **argv, int &arg_num, char **arg_v
                                std::vector<std::string> &moduleNameVec)
 {
     bool first_ir_file = true;
-    for (s32_t i = 0; i < argc; ++i)
+    for (s64_t i = 0; i < argc; ++i)
     {
         std::string argument(argv[i]);
         if (SVFUtil::isIRFile(argument))

package/lib/SVF-FE/SVFIRBuilder.cpp

@@ -210,11 +210,12 @@ void SVFIRBuilder::initialiseNodes()
 }
 
 /*
+    https://github.com/SVF-tools/SVF/issues/524
     Handling single value types, for constant index, including pointer, integer, etc 
     e.g. field_idx = getelementptr i8, %i8* %p, i64 -4
     We can obtain the field index by inferring the byteoffset if %p is casted from a pointer to a struct
 */
-u32_t SVFIRBuilder::inferFieldIdxFromByteOffset(const llvm::GEPOperator* gepOp, DataLayout *dl, LocationSet& ls, Size_t idx){
+u32_t SVFIRBuilder::inferFieldIdxFromByteOffset(const llvm::GEPOperator* gepOp, DataLayout *dl, LocationSet& ls, s64_t idx){
     auto srcptr = gepOp->getOperand(0);
     llvm::BitCastOperator* castop1 = SVFUtil::dyn_cast<llvm::BitCastOperator>(srcptr);
     Type* sttype = nullptr;
@@ -262,23 +263,23 @@ bool SVFIRBuilder::computeGepOffset(const User *V, LocationSet& ls)
     llvm::APInt byteOffset(dataLayout->getIndexSizeInBits(gepOp->getPointerAddressSpace()),0,true);
     if(gepOp && dataLayout && gepOp->accumulateConstantOffset(*dataLayout,byteOffset))
     {
-        Size_t bo = byteOffset.getSExtValue();
+        s64_t bo = byteOffset.getSExtValue();
     }
 
     for (bridge_gep_iterator gi = bridge_gep_begin(*V), ge = bridge_gep_end(*V);
             gi != ge; ++gi)
     {
-        ls.addOffsetValue(gi.getOperand());
-        
+        ls.addOffsetValue(gi.getOperand(), *gi);
+
+        //The int value of the current index operand
+        ConstantInt *op = SVFUtil::dyn_cast<ConstantInt>(gi.getOperand());
+
         // Handling array types, skipe array handling here
         // We treat whole array as one, but we can distinguish different field of an array of struct
         // e.g. s[1].f1 is differet from s[0].f2
         if(SVFUtil::isa<ArrayType>(*gi))
             continue;
 
-        //The int value of the current index operand
-        ConstantInt *op = SVFUtil::dyn_cast<ConstantInt>(gi.getOperand());
- 
         // Handling struct here
         if (const StructType *ST = SVFUtil::dyn_cast<StructType>(*gi) )
         {
@@ -289,7 +290,7 @@ bool SVFIRBuilder::computeGepOffset(const User *V, LocationSet& ls)
             }
             assert(op && "non-const index in an operand in GEP");
             //The actual index
-            Size_t idx = op->getSExtValue();
+            s64_t idx = op->getSExtValue();
             const vector<u32_t> &so = SymbolTableInfo::SymbolInfo()->getFlattenedFieldIdxVec(ST);
             if ((unsigned)idx >= so.size())
             {
@@ -308,7 +309,7 @@ bool SVFIRBuilder::computeGepOffset(const User *V, LocationSet& ls)
                 return false;
             }
             // The actual index
-            Size_t idx = op->getSExtValue();
+            s64_t idx = op->getSExtValue();
 
             // infer the field offset based on the byte offset
             u32_t fieldOffset = inferFieldIdxFromByteOffset(gepOp, dataLayout, ls, idx);
@@ -623,7 +624,7 @@ void SVFIRBuilder::visitPHINode(PHINode &inst)
 
     NodeID dst = getValueNode(&inst);
 
-    for (Size_t i = 0; i < inst.getNumIncomingValues(); ++i)
+    for (u32_t i = 0; i < inst.getNumIncomingValues(); ++i)
     {
         const Value* val = inst.getIncomingValue(i);
         const Instruction* incomingInst = SVFUtil::dyn_cast<Instruction>(val);
@@ -1172,7 +1173,7 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
                 if(!SVFUtil::isa<PointerType>(inst->getType()))
                     break;
                 NodeID dstNode = getValueNode(inst);
-                Size_t arg_pos;
+                u32_t arg_pos;
                 switch(tF)
                 {
                 case ExtAPI::EFT_L_A1:
@@ -1338,7 +1339,7 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
                 // We have vArg3 points to the entry of _Rb_tree_node_base { color; parent; left; right; }.
                 // Now we calculate the offset from base to vArg3
                 NodeID vnArg3 = pag->getValueNode(vArg3);
-                Size_t offset = pag->getLocationSetFromBaseNode(vnArg3).accumulateConstantFieldIdx();
+                s64_t offset = pag->getLocationSetFromBaseNode(vnArg3).accumulateConstantFieldIdx();
 
                 // We get all flattened fields of base
                 vector<LocationSet> fields;
@@ -1362,7 +1363,7 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
 
                 Value *vArg = cs.getArgument(0);
                 NodeID vnArg = pag->getValueNode(vArg);
-                Size_t offset = pag->getLocationSetFromBaseNode(vnArg).accumulateConstantFieldIdx();
+                s64_t offset = pag->getLocationSetFromBaseNode(vnArg).accumulateConstantFieldIdx();
 
                 // We get all fields
                 vector<LocationSet> fields;

package/lib/SVF-FE/SymbolTableBuilder.cpp

@@ -549,7 +549,7 @@ void SymbolTableBuilder::analyzeGlobalStackObjType(ObjTypeInfo* typeinfo, const
  */
 void SymbolTableBuilder::initTypeInfo(ObjTypeInfo* typeinfo, const Value* val){
     
-    Size_t objSize = 1;
+    s64_t objSize = 1;
     // Global variable
     if (SVFUtil::isa<Function>(val))
     {

package/lib/Util/Conditions.cpp

@@ -182,7 +182,7 @@ void CondManager::printModel()
     z3::model m = sol.get_model();
     for (u32_t i = 0; i < m.size(); i++)
     {
-        z3::func_decl v = m[static_cast<s32_t>(i)];
+        z3::func_decl v = m[static_cast<s64_t>(i)];
         std::cout << v.name() << " = " << m.get_const_interp(v) << "\n";
     }
 }