svf-tools 1.0.673 → 1.0.675

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.673",
+  "version": "1.0.675",
   "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/Graphs/ConsGEdge.h

@@ -306,7 +306,7 @@ public:
     /// Get location set of the gep edge
     inline s32_t getConstantFieldIdx() const
     {
-        return ls.accumulateConstantFieldIdx();
+        return ls.getConstantFieldIdx();
     }
 
 };

package/svf/include/MemoryModel/LocationSet.h

@@ -58,7 +58,8 @@ public:
         NonOverlap, Overlap, Subset, Superset, Same
     };
 
-    typedef std::vector<const SVFVar*> OffsetVarVec;
+    typedef std::pair<const SVFVar*, const SVFType*> VarAndGepTypePair;
+    typedef std::vector<VarAndGepTypePair> OffsetVarAndGepTypePairs;
 
     /// Constructor
     LocationSet(s32_t o = 0) : fldIdx(o)
@@ -66,7 +67,7 @@ public:
 
     /// Copy Constructor
     LocationSet(const LocationSet& ls)
-        : fldIdx(ls.fldIdx), offsetVars(ls.getOffsetVarVec())
+        : fldIdx(ls.fldIdx), offsetVarAndGepTypePairs(ls.getOffsetVarAndGepTypePairVec())
     {
     }
 
@@ -79,19 +80,19 @@ public:
     inline const LocationSet& operator= (const LocationSet& rhs)
     {
         fldIdx = rhs.fldIdx;
-        offsetVars = rhs.getOffsetVarVec();
+        offsetVarAndGepTypePairs = rhs.getOffsetVarAndGepTypePairVec();
         return *this;
     }
     inline bool operator==(const LocationSet& rhs) const
     {
         return this->fldIdx == rhs.fldIdx
-               && this->offsetVars == rhs.offsetVars;
+               && this->offsetVarAndGepTypePairs == rhs.offsetVarAndGepTypePairs;
     }
     //@}
 
     /// Get methods
     //@{
-    inline s32_t accumulateConstantFieldIdx() const
+    inline s32_t getConstantFieldIdx() const
     {
         return fldIdx;
     }
@@ -99,20 +100,20 @@ public:
     {
         fldIdx = idx;
     }
-    inline const OffsetVarVec& getOffsetVarVec() const
+    inline const OffsetVarAndGepTypePairs& getOffsetVarAndGepTypePairVec() const
     {
-        return offsetVars;
+        return offsetVarAndGepTypePairs;
     }
     //@}
 
     /// Return accumulated constant offset given OffsetVarVec
-    s32_t accumulateConstantOffset() const;
+    s32_t computeConstantOffset() const;
 
     /// Return element number of a type.
     u32_t getElementNum(const SVFType* type) const;
 
 
-    bool addOffsetVar(const SVFVar* var);
+    bool addOffsetVarAndGepTypePair(const SVFVar* var, const SVFType* gepIterType);
 
     /// Return TRUE if this is a constant location set.
     bool isConstantOffset() const;
@@ -135,7 +136,7 @@ private:
     NodeBS computeAllLocations() const;
 
     s32_t fldIdx;	///< Accumulated Constant Offsets
-    OffsetVarVec offsetVars;	///< a vector of actual offset in the form of SVF Vars
+    OffsetVarAndGepTypePairs offsetVarAndGepTypePairs;	///< a vector of actual offset in the form of <SVF Var, iterator type>s
 };
 
 } // End namespace SVF
@@ -145,8 +146,8 @@ template <> struct std::hash<SVF::LocationSet>
     size_t operator()(const SVF::LocationSet &ls) const
     {
         SVF::Hash<std::pair<SVF::NodeID, SVF::NodeID>> h;
-        std::hash<SVF::LocationSet::OffsetVarVec> v;
-        return h(std::make_pair(ls.accumulateConstantFieldIdx(), v(ls.getOffsetVarVec())));
+        std::hash<SVF::LocationSet::OffsetVarAndGepTypePairs> v;
+        return h(std::make_pair(ls.getConstantFieldIdx(), v(ls.getOffsetVarAndGepTypePairVec())));
     }
 };
 

package/svf/include/SVFIR/SVFStatements.h

@@ -444,9 +444,9 @@ public:
     {
         return ls;
     }
-    inline const LocationSet::OffsetVarVec getOffsetVarVec() const
+    inline const LocationSet::OffsetVarAndGepTypePairs getOffsetVarAndGepTypePairVec() const
     {
-        return getLocationSet().getOffsetVarVec();
+        return getLocationSet().getOffsetVarAndGepTypePairVec();
     }
     /// Return TRUE if this is a constant location set.
     inline bool isConstantOffset() const
@@ -456,13 +456,13 @@ public:
     /// Return accumulated constant offset (when accessing array or struct) if this offset is a constant.
     inline s32_t accumulateConstantOffset() const
     {
-        return getLocationSet().accumulateConstantOffset();
+        return getLocationSet().computeConstantOffset();
     }
     /// Field index of the gep statement if it access the field of a struct
     inline s32_t getConstantFieldIdx() const
     {
         assert(isVariantFieldGep()==false && "Can't retrieve the LocationSet if using a variable field index (pointer arithmetic) for struct field access ");
-        return getLocationSet().accumulateConstantFieldIdx();
+        return getLocationSet().getConstantFieldIdx();
     }
     /// Gep statement with a variant field index (pointer arithmetic) for struct field access
     inline bool isVariantFieldGep() const

package/svf/include/SVFIR/SVFVariables.h

@@ -399,7 +399,7 @@ public:
     /// offset of the base value variable
     inline s32_t getConstantFieldIdx() const
     {
-        return ls.accumulateConstantFieldIdx();
+        return ls.getConstantFieldIdx();
     }
 
     /// Return name of a LLVM value
@@ -466,7 +466,7 @@ public:
     /// offset of the mem object
     inline s32_t getConstantFieldIdx() const
     {
-        return ls.accumulateConstantFieldIdx();
+        return ls.getConstantFieldIdx();
     }
 
     /// Set the base object from which this GEP node came from.
@@ -484,15 +484,15 @@ public:
     /// Return the type of this gep object
     inline virtual const SVFType* getType() const
     {
-        return SymbolTableInfo::SymbolInfo()->getFlatternedElemType(mem->getType(), ls.accumulateConstantFieldIdx());
+        return SymbolTableInfo::SymbolInfo()->getFlatternedElemType(mem->getType(), ls.getConstantFieldIdx());
     }
 
     /// Return name of a LLVM value
     inline const std::string getValueName() const
     {
         if (value)
-            return value->getName() + "_" + std::to_string(ls.accumulateConstantFieldIdx());
-        return "offset_" + std::to_string(ls.accumulateConstantFieldIdx());
+            return value->getName() + "_" + std::to_string(ls.getConstantFieldIdx());
+        return "offset_" + std::to_string(ls.getConstantFieldIdx());
     }
 
     virtual const std::string toString() const;

package/svf/lib/AbstractExecution/SVFIR2ItvExeState.cpp

@@ -104,15 +104,15 @@ SVFIR2ItvExeState::VAddrs SVFIR2ItvExeState::getGepObjAddress(u32_t pointer, u32
 
 std::pair<s32_t, s32_t> SVFIR2ItvExeState::getGepOffset(const GepStmt *gep)
 {
-    if (gep->getOffsetVarVec().empty())
+    if (gep->getOffsetVarAndGepTypePairVec().empty())
         return std::make_pair(gep->getConstantFieldIdx(), gep->getConstantFieldIdx());
 
     s32_t totalOffsetLb = 0;
     s32_t totalOffsetUb = 0;
-    for (int i = gep->getOffsetVarVec().size() - 1; i >= 0; i--)
+    for (int i = gep->getOffsetVarAndGepTypePairVec().size() - 1; i >= 0; i--)
     {
-        const SVFValue *value = gep->getOffsetVarVec()[i]->getValue();
-        const SVFType *type = gep->getOffsetVarVec()[i]->getType();
+        const SVFValue *value = gep->getOffsetVarAndGepTypePairVec()[i].first->getValue();
+        const SVFType *type = gep->getOffsetVarAndGepTypePairVec()[i].second;
         const SVFConstantInt *op = SVFUtil::dyn_cast<SVFConstantInt>(value);
         s32_t offsetLb = 0;
         s32_t offsetUb = 0;

package/svf/lib/Graphs/VFG.cpp

@@ -757,11 +757,11 @@ void VFG::connectDirectVFGEdges()
                 addIntraDirectVFEdge(getDef(stmtNode->getPAGSrcNode()), nodeId);
             if (const GepStmt* gepStmt = SVFUtil::dyn_cast<GepStmt>(stmtNode->getPAGEdge()))
             {
-                for (const auto &var: gepStmt->getOffsetVarVec())
+                for (const auto &varType: gepStmt->getOffsetVarAndGepTypePairVec())
                 {
-                    if(var->isConstDataOrAggDataButNotNullPtr() || isInterestedPAGNode(var) == false)
+                    if(varType.first->isConstDataOrAggDataButNotNullPtr() || isInterestedPAGNode(varType.first) == false)
                         continue;
-                    addIntraDirectVFEdge(getDef(var), nodeId);
+                    addIntraDirectVFEdge(getDef(varType.first), nodeId);
                 }
             }
             /// for store, connect the RHS/LHS pointer to its def

package/svf/lib/MemoryModel/LocationSet.cpp

@@ -37,20 +37,20 @@ using namespace SVF;
 using namespace SVFUtil;
 
 /*!
- * Add offset value to vector offsetVars
+ * Add offset value to vector offsetVarAndGepTypePairs
  */
-bool LocationSet::addOffsetVar(const SVFVar* var)
+bool LocationSet::addOffsetVarAndGepTypePair(const SVFVar* var, const SVFType* gepIterType)
 {
-    offsetVars.push_back(var);
+    offsetVarAndGepTypePairs.emplace_back(var, gepIterType);
     return true;
 }
 
 /// Return true if all offset values are constants
 bool LocationSet::isConstantOffset() const
 {
-    for(auto it : offsetVars)
+    for(auto it : offsetVarAndGepTypePairs)
     {
-        if(SVFUtil::isa<SVFConstantInt>(it->getValue()) == false)
+        if(SVFUtil::isa<SVFConstantInt>(it.first->getValue()) == false)
             return false;
     }
     return true;
@@ -102,32 +102,32 @@ u32_t LocationSet::getElementNum(const SVFType* type) const
 
 /// %5 = getelementptr inbounds %struct.Student, %struct.Student* %4, i64 1
 ///     value1: i64 1 type1: %struct.Student*
-///     accumulateConstantOffset = 32
+///     computeConstantOffset = 32
 /// %6 = getelementptr inbounds %struct.Student, %struct.Student* %5, i32 0, i32 1
 ///     value1: i32 0  type1: %struct.Student*
 ///     value2: i32 1  type2: %struct.Student = type { %struct.inner, [10 x [3 x i8]] }
-///     accumulateConstantOffset = 2
+///     computeConstantOffset = 2
 /// %7 = getelementptr inbounds [10 x [3 x i8]], [10 x [3 x i8]]* %6, i64 0, i64 3
 ///     value1: i64 0  type1: [10 x [3 x i8]]*
 ///     value2: i64 3  type2: [10 x [3 x i8]]
-///     accumulateConstantOffset = 9
+///     computeConstantOffset = 9
 /// %8 = getelementptr inbounds [3 x i8], [3 x i8]* %7, i64 0, i64 2
 ///     value1: i64 0  type1: [3 x i8]*
 ///     value2: i64 2  type2: [3 x i8]
-///     accumulateConstantOffset = 2
-s32_t LocationSet::accumulateConstantOffset() const
+///     computeConstantOffset = 2
+s32_t LocationSet::computeConstantOffset() const
 {
 
     assert(isConstantOffset() && "not a constant offset");
 
-    if(offsetVars.empty())
-        return accumulateConstantFieldIdx();
+    if(offsetVarAndGepTypePairs.empty())
+        return getConstantFieldIdx();
 
     s32_t totalConstOffset = 0;
-    for(int i = offsetVars.size() - 1; i >= 0; i--)
+    for(int i = offsetVarAndGepTypePairs.size() - 1; i >= 0; i--)
     {
-        const SVFValue* value = offsetVars[i]->getValue();
-        const SVFType* type = offsetVars[i]->getType();
+        const SVFValue* value = offsetVarAndGepTypePairs[i].first->getValue();
+        const SVFType* type = offsetVarAndGepTypePairs[i].second;
         const SVFConstantInt* op = SVFUtil::dyn_cast<SVFConstantInt>(value);
         assert(op && "not a constant offset?");
         if(type==nullptr)
@@ -153,18 +153,18 @@ s32_t LocationSet::accumulateConstantOffset() const
 NodeBS LocationSet::computeAllLocations() const
 {
     NodeBS result;
-    result.set(accumulateConstantFieldIdx());
+    result.set(getConstantFieldIdx());
     return result;
 }
 
 LocationSet LocationSet::operator+ (const LocationSet& rhs) const
 {
     LocationSet ls(rhs);
-    ls.fldIdx += accumulateConstantFieldIdx();
-    OffsetVarVec::const_iterator it = getOffsetVarVec().begin();
-    OffsetVarVec::const_iterator eit = getOffsetVarVec().end();
+    ls.fldIdx += getConstantFieldIdx();
+    OffsetVarAndGepTypePairs::const_iterator it = getOffsetVarAndGepTypePairVec().begin();
+    OffsetVarAndGepTypePairs::const_iterator eit = getOffsetVarAndGepTypePairVec().end();
     for (; it != eit; ++it)
-        ls.addOffsetVar(*it);
+        ls.addOffsetVarAndGepTypePair(it->first, it->second);
 
     return ls;
 }
@@ -176,14 +176,14 @@ bool LocationSet::operator< (const LocationSet& rhs) const
         return (fldIdx < rhs.fldIdx);
     else
     {
-        const OffsetVarVec& pairVec = getOffsetVarVec();
-        const OffsetVarVec& rhsPairVec = rhs.getOffsetVarVec();
+        const OffsetVarAndGepTypePairs& pairVec = getOffsetVarAndGepTypePairVec();
+        const OffsetVarAndGepTypePairs& rhsPairVec = rhs.getOffsetVarAndGepTypePairVec();
         if (pairVec.size() != rhsPairVec.size())
             return (pairVec.size() < rhsPairVec.size());
         else
         {
-            OffsetVarVec::const_iterator it = pairVec.begin();
-            OffsetVarVec::const_iterator rhsIt = rhsPairVec.begin();
+            OffsetVarAndGepTypePairs::const_iterator it = pairVec.begin();
+            OffsetVarAndGepTypePairs::const_iterator rhsIt = rhsPairVec.begin();
             for (; it != pairVec.end() && rhsIt != rhsPairVec.end(); ++it, ++rhsIt)
             {
                 return (*it) < (*rhsIt);
@@ -221,14 +221,14 @@ std::string LocationSet::dump() const
     std::string str;
     std::stringstream rawstr(str);
 
-    rawstr << "LocationSet\tField_Index: " << accumulateConstantFieldIdx();
+    rawstr << "LocationSet\tField_Index: " << getConstantFieldIdx();
     rawstr << ",\tNum-Stride: {";
-    const OffsetVarVec& vec = getOffsetVarVec();
-    OffsetVarVec::const_iterator it = vec.begin();
-    OffsetVarVec::const_iterator eit = vec.end();
+    const OffsetVarAndGepTypePairs& vec = getOffsetVarAndGepTypePairVec();
+    OffsetVarAndGepTypePairs::const_iterator it = vec.begin();
+    OffsetVarAndGepTypePairs::const_iterator eit = vec.end();
     for (; it != eit; ++it)
     {
-        rawstr << " (var: " << (*it)->toString() << ")";
+        rawstr << " (Svf var: " << it->first->toString() << ", Iter type: " << it->second->toString() << ")";
     }
     rawstr << " }\n";
     return rawstr.str();

package/svf/lib/SVFIR/SVFIR.cpp

@@ -430,7 +430,7 @@ NodeID SVFIR::getGepObjVar(const MemObj* obj, const LocationSet& ls)
     LocationSet newLS = pag->getSymbolInfo()->getModulusOffset(obj,ls);
 
     // Base and first field are the same memory location.
-    if (Options::FirstFieldEqBase() && newLS.accumulateConstantFieldIdx() == 0) return base;
+    if (Options::FirstFieldEqBase() && newLS.getConstantFieldIdx() == 0) return base;
 
     NodeLocationSetMap::iterator iter = GepObjVarMap.find(std::make_pair(base, newLS));
     if (iter == GepObjVarMap.end())
@@ -450,7 +450,7 @@ NodeID SVFIR::addGepObjNode(const MemObj* obj, const LocationSet& ls)
     assert(0==GepObjVarMap.count(std::make_pair(base, ls))
            && "this node should not be created before");
 
-    NodeID gepId = NodeIDAllocator::get()->allocateGepObjectId(base, ls.accumulateConstantFieldIdx(), Options::MaxFieldLimit());
+    NodeID gepId = NodeIDAllocator::get()->allocateGepObjectId(base, ls.getConstantFieldIdx(), Options::MaxFieldLimit());
     GepObjVarMap[std::make_pair(base, ls)] = gepId;
     GepObjVar *node = new GepObjVar(obj, gepId, ls);
     memToFieldsMap[base].set(gepId);

package/svf/lib/SVFIR/SVFVariables.cpp

@@ -145,7 +145,7 @@ const std::string GepObjVar::toString() const
 {
     std::string str;
     std::stringstream rawstr(str);
-    rawstr << "GepObjVar ID: " << getId() << " with offset_" + std::to_string(ls.accumulateConstantFieldIdx());
+    rawstr << "GepObjVar ID: " << getId() << " with offset_" + std::to_string(ls.getConstantFieldIdx());
     if (Options::ShowSVFIRValue())
     {
         rawstr << "\n";

package/svf/lib/SVFIR/SymbolTableInfo.cpp

@@ -98,7 +98,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.
 
-    s32_t offset = ls.accumulateConstantFieldIdx();
+    s32_t offset = ls.getConstantFieldIdx();
     if(offset < 0)
     {
         writeWrnMsg("try to create a gep node with negative offset.");
@@ -392,13 +392,13 @@ bool ObjTypeInfo::isNonPtrFieldObj(const LocationSet& ls)
         else
             sz = SymbolTableInfo::SymbolInfo()->getTypeInfo(ety)->getFlattenFieldTypes().size();
 
-        if(sz <= (u32_t)ls.accumulateConstantFieldIdx())
+        if(sz <= (u32_t) ls.getConstantFieldIdx())
         {
             writeWrnMsg("out of bound error when accessing the struct/array");
             return false;
         }
 
-        const SVFType* elemTy = SymbolTableInfo::SymbolInfo()->getFlatternedElemType(ety, ls.accumulateConstantFieldIdx());
+        const SVFType* elemTy = SymbolTableInfo::SymbolInfo()->getFlatternedElemType(ety, ls.getConstantFieldIdx());
         return (elemTy->isPointerTy() == false);
     }
     else

package/svf-llvm/lib/SVFIRBuilder.cpp

@@ -272,13 +272,17 @@ bool SVFIRBuilder::computeGepOffset(const User *V, LocationSet& ls)
         //s32_t bo = byteOffset.getSExtValue();
     }
 
+    bool isConst = true;
+
     for (bridge_gep_iterator gi = bridge_gep_begin(*V), ge = bridge_gep_end(*V);
             gi != ge; ++gi)
     {
         const Type* gepTy = *gi;
+        const SVFType* svfGepTy = LLVMModuleSet::getLLVMModuleSet()->getSVFType(gepTy);
         const Value* offsetVal = gi.getOperand();
         const SVFValue* offsetSvfVal = LLVMModuleSet::getLLVMModuleSet()->getSVFValue(offsetVal);
-        ls.addOffsetVar(getPAG()->getGNode(getPAG()->getValueNode(offsetSvfVal)));
+        assert(gepTy != offsetVal->getType() && "iteration and operand have the same type?");
+        ls.addOffsetVarAndGepTypePair(getPAG()->getGNode(getPAG()->getValueNode(offsetSvfVal)), svfGepTy);
 
         //The int value of the current index operand
         const ConstantInt* op = SVFUtil::dyn_cast<ConstantInt>(offsetVal);
@@ -291,7 +295,7 @@ bool SVFIRBuilder::computeGepOffset(const User *V, LocationSet& ls)
                 continue;
             s32_t idx = op->getSExtValue();
             u32_t offset = pag->getSymbolInfo()->getFlattenedElemIdx(LLVMModuleSet::getLLVMModuleSet()->getSVFType(arrTy), idx);
-            ls.setFldIdx(ls.accumulateConstantFieldIdx() + offset);
+            ls.setFldIdx(ls.getConstantFieldIdx() + offset);
         }
         else if (const StructType *ST = SVFUtil::dyn_cast<StructType>(gepTy))
         {
@@ -299,7 +303,7 @@ bool SVFIRBuilder::computeGepOffset(const User *V, LocationSet& ls)
             //The actual index
             s32_t idx = op->getSExtValue();
             u32_t offset = pag->getSymbolInfo()->getFlattenedElemIdx(LLVMModuleSet::getLLVMModuleSet()->getSVFType(ST), idx);
-            ls.setFldIdx(ls.accumulateConstantFieldIdx() + offset);
+            ls.setFldIdx(ls.getConstantFieldIdx() + offset);
         }
         else if (gepTy->isSingleValueType())
         {
@@ -307,17 +311,17 @@ bool SVFIRBuilder::computeGepOffset(const User *V, LocationSet& ls)
             // If its point-to target is struct or array, it's likely an array accessing (%result = gep %struct.A* %a, i32 %non-const-index)
             // If its point-to target is single value (pointer arithmetic), then it's a variant gep (%result = gep i8* %p, i32 %non-const-index)
             if(!op && gepTy->isPointerTy() && getPtrElementType(SVFUtil::dyn_cast<PointerType>(gepTy))->isSingleValueType())
-                return false;
+                isConst = false;
 
             // The actual index
             //s32_t idx = op->getSExtValue();
 
             // For pointer arithmetic we ignore the byte offset
             // consider using inferFieldIdxFromByteOffset(geopOp,dataLayout,ls,idx)?
-            // ls.setFldIdx(ls.accumulateConstantFieldIdx() + inferFieldIdxFromByteOffset(geopOp,idx));
+            // ls.setFldIdx(ls.getConstantFieldIdx() + inferFieldIdxFromByteOffset(geopOp,idx));
         }
     }
-    return true;
+    return isConst;
 }
 
 /*!
@@ -1132,7 +1136,7 @@ const Type* SVFIRBuilder::getBaseTypeAndFlattenedFields(const Value* V, std::vec
             builder.collectSym(offset);
             pag->addValNode(svfOffset, pag->getSymbolInfo()->getValSym(svfOffset));
         }
-        ls.addOffsetVar(getPAG()->getGNode(getPAG()->getValueNode(svfOffset)));
+        ls.addOffsetVarAndGepTypePair(getPAG()->getGNode(getPAG()->getValueNode(svfOffset)), nullptr);
         fields.push_back(ls);
     }
     return T;
@@ -1176,8 +1180,10 @@ void SVFIRBuilder::addComplexConsForExt(const Value* D, const Value* S, const Va
     for (u32_t index = 0; index < sz; index++)
     {
         LLVMModuleSet* llvmmodule = LLVMModuleSet::getLLVMModuleSet();
-        const SVFType* dElementType = pag->getSymbolInfo()->getFlatternedElemType(llvmmodule->getSVFType(dtype), fields[index].accumulateConstantFieldIdx());
-        const SVFType* sElementType = pag->getSymbolInfo()->getFlatternedElemType(llvmmodule->getSVFType(stype), fields[index].accumulateConstantFieldIdx());
+        const SVFType* dElementType = pag->getSymbolInfo()->getFlatternedElemType(llvmmodule->getSVFType(dtype),
+                                      fields[index].getConstantFieldIdx());
+        const SVFType* sElementType = pag->getSymbolInfo()->getFlatternedElemType(llvmmodule->getSVFType(stype),
+                                      fields[index].getConstantFieldIdx());
         NodeID dField = getGepValVar(D,fields[index],dElementType);
         NodeID sField = getGepValVar(S,fields[index],sElementType);
         NodeID dummy = pag->addDummyValNode();
@@ -1385,7 +1391,8 @@ void SVFIRBuilder::handleExtCall(CallBase* cs, const Function *callee)
                         //For each field (i), add store edge *(arg0 + i) = arg1
                         for (u32_t index = 0; index < sz; index++)
                         {
-                            const SVFType* dElementType = pag->getSymbolInfo()->getFlatternedElemType(LLVMModuleSet::getLLVMModuleSet()->getSVFType(dtype), dstFields[index].accumulateConstantFieldIdx());
+                            const SVFType* dElementType = pag->getSymbolInfo()->getFlatternedElemType(LLVMModuleSet::getLLVMModuleSet()->getSVFType(dtype),
+                                                          dstFields[index].getConstantFieldIdx());
                             NodeID dField = getGepValVar(cs->getArgOperand(op.getOperands()[0]), dstFields[index], dElementType);
                             addStoreEdge(getValueNode(cs->getArgOperand(op.getOperands()[1])),dField);
                         }
@@ -1428,7 +1435,7 @@ void SVFIRBuilder::handleExtCall(CallBase* cs, const Function *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(LLVMModuleSet::getLLVMModuleSet()->getSVFValue(vArg3));
-                        s32_t offset = getLocationSetFromBaseNode(vnArg3).accumulateConstantFieldIdx();
+                        s32_t offset = getLocationSetFromBaseNode(vnArg3).getConstantFieldIdx();
 
                         // We get all flattened fields of base
                         vector<LocationSet> fields;
@@ -1440,7 +1447,8 @@ void SVFIRBuilder::handleExtCall(CallBase* cs, const Function *callee)
                         {
                             if((u32_t)i >= fields.size())
                                 break;
-                            const SVFType* elementType = pag->getSymbolInfo()->getFlatternedElemType(LLVMModuleSet::getLLVMModuleSet()->getSVFType(type), fields[i].accumulateConstantFieldIdx());
+                            const SVFType* elementType = pag->getSymbolInfo()->getFlatternedElemType(LLVMModuleSet::getLLVMModuleSet()->getSVFType(type),
+                                                         fields[i].getConstantFieldIdx());
                             NodeID vnD = getGepValVar(vArg3, fields[i], elementType);
                             NodeID vnS = getValueNode(vArg1);
                             if(vnD && vnS)