svf-tools 1.0.330 → 1.0.331

package/lib/MemoryModel/LocationSet.cpp

@@ -31,122 +31,80 @@
 
 #include "Util/Options.h"
 #include "MemoryModel/LocationSet.h"
+#include "Util/SVFUtil.h"
 
 using namespace SVF;
-
+using namespace SVFUtil;
 
 /*!
- * Add element num and stride pair
+ * Add offset value to vector offsetValues
  */
-void LocationSet::addElemNumStridePair(const NodePair& pair)
+bool LocationSet::addOffsetValue(const Value* offsetVal)
 {
-    /// The pair will not be added if any number of a stride is zero,
-    /// because they will not have effect on the locations represented by this LocationSet.
-    if (pair.first == 0 || pair.second == 0)
-        return;
-
-    if (Options::SingleStride)
-    {
-        if (numStridePair.empty())
-            numStridePair.push_back(std::make_pair(StInfo::getMaxFieldLimit(),pair.second));
-        else
-        {
-            /// Find the GCD stride
-            NodeID existStride = (*numStridePair.begin()).second;
-            NodeID newStride = gcd(pair.second, existStride);
-            if (newStride != existStride)
-            {
-                numStridePair.pop_back();
-                numStridePair.push_back(std::make_pair(StInfo::getMaxFieldLimit(),newStride));
-            }
-        }
-    }
-    else
-    {
-        numStridePair.push_back(pair);
+    for(const Value* val : offsetValues){
+        if(val==offsetVal)
+            return false;
     }
+    offsetValues.push_back(offsetVal);
+    return true;
 }
 
-
-/*!
- * Return TRUE if it successfully increases any index by 1
- */
-bool LocationSet::increaseIfNotReachUpperBound(std::vector<NodeID>& indices,
-        const ElemNumStridePairVec& pairVec) const
+/// Return TRUE if all offset values are constants
+bool LocationSet::isConstantOffset() const
 {
-    assert(indices.size() == pairVec.size() && "vector size not match");
-
-    /// Check if all indices reach upper bound
-    bool reachUpperBound = true;
-    for (u32_t i = 0; i < indices.size(); i++)
-    {
-        assert(pairVec[i].first > 0 && "number must be greater than 0");
-        if (indices[i] < (pairVec[i].first - 1))
-            reachUpperBound = false;
+    for(const Value* val : offsetValues){
+        if(SVFUtil::isa<ConstantInt>(val) == false)
+            return false;
     }
-
-    /// Increase index if not reach upper bound
-    bool increased = false;
-    if (reachUpperBound == false)
-    {
-        u32_t i = 0;
-        while (increased == false)
-        {
-            if (indices[i] < (pairVec[i].first - 1))
-            {
-                indices[i] += 1;
-                increased = true;
-            }
-            else
-            {
-                indices[i] = 0;
-                i++;
-            }
-        }
-    }
-
-    return increased;
+    return true;
 }
 
-
 /*!
  * Compute all possible locations according to offset and number-stride pairs.
  */
 NodeBS LocationSet::computeAllLocations() const
 {
-
     NodeBS result;
-    result.set(getOffset());
+    result.set(accumulateConstantOffset());
+    return result;
+}
 
-    if (isConstantOffset() == false)
+SVF::LocationSet::LSRelation LocationSet::checkRelation(const LocationSet& LHS, const LocationSet& RHS)
+{
+    NodeBS lhsLocations = LHS.computeAllLocations();
+    NodeBS rhsLocations = RHS.computeAllLocations();
+    if (lhsLocations.intersects(rhsLocations))
     {
-        const ElemNumStridePairVec& lhsVec = getNumStridePair();
-        std::vector<NodeID> indices;
-        u32_t size = lhsVec.size();
-        while (size)
-        {
-            indices.push_back(0);
-            size--;
-        }
-
-        do
-        {
-            u32_t i = 0;
-            NodeID ofst = getOffset();
-            while (i < lhsVec.size())
-            {
-                ofst += (lhsVec[i].second * indices[i]);
-                i++;
-            }
-
-            result.set(ofst);
-
-        }
-        while (increaseIfNotReachUpperBound(indices, lhsVec));
+        if (lhsLocations == rhsLocations)
+            return Same;
+        else if (lhsLocations.contains(rhsLocations))
+            return Superset;
+        else if (rhsLocations.contains(lhsLocations))
+            return Subset;
+        else
+            return Overlap;
+    }
+    else
+    {
+        return NonOverlap;
     }
-
-    return result;
 }
 
-
-
+/// Dump location set
+std::string LocationSet::dump() const
+{
+    std::string str;
+    raw_string_ostream rawstr(str);
+
+    rawstr << "LocationSet\tField_Index: " << accumulateConstantOffset();
+    rawstr << ",\tNum-Stride: {";
+    const OffsetValueVec& vec = getOffsetValueVec();
+    OffsetValueVec::const_iterator it = vec.begin();
+    OffsetValueVec::const_iterator eit = vec.end();
+    for (; it != eit; ++it)
+    {
+        rawstr << " (" << value2String(*it) << ")";
+    }
+    rawstr << " }\n";
+    return rawstr.str();
+}

package/lib/MemoryModel/PointerAnalysisImpl.cpp

@@ -150,11 +150,11 @@ void BVDataPTAImpl::writeToFile(const string& filename)
     for (auto it = pag->begin(), ie = pag->end(); it != ie; ++it)
     {
         PAGNode* pagNode = it->second;
-        if (GepObjPN *gepObjPN = SVFUtil::dyn_cast<GepObjPN>(pagNode))
+        if (GepObjVar *gepObjPN = SVFUtil::dyn_cast<GepObjVar>(pagNode))
         {
             F.os() << it->first << " ";
             F.os() << pag->getBaseObjVar(it->first) << " ";
-            F.os() << gepObjPN->getLocationSet().getOffset() << "\n";
+            F.os() << gepObjPN->getOffset() << "\n";
         }
     }
 
@@ -411,7 +411,7 @@ void BVDataPTAImpl::normalizePointsTo() {
         assert(memObj && "Invalid memobj in memToFieldsMap");
         if (memObj->isFieldInsensitive()) {
             for (NodeID id : t.second) {
-                if (SVFUtil::isa<GepObjPN>(pag->getGNode(id))) {
+                if (SVFUtil::isa<GepObjVar>(pag->getGNode(id))) {
                     dropNodes.set(id);
                 } else
                     assert(id == base && "Not a GepObj Node or a baseObj Node?");
@@ -437,7 +437,7 @@ void BVDataPTAImpl::normalizePointsTo() {
     // and remove those nodes from pag
     for (NodeID n: dropNodes) {
         NodeID base = pag->getBaseObjVar(n);
-        GepObjPN *gepNode = SVFUtil::dyn_cast<GepObjPN>(pag->getGNode(n));
+        GepObjVar *gepNode = SVFUtil::dyn_cast<GepObjVar>(pag->getGNode(n));
         const LocationSet ls = gepNode->getLocationSet();
         GepObjVarMap.erase(std::make_pair(base, ls));
         memToFieldsMap[base].reset(n);

package/lib/MemoryModel/SVFIR.cpp

@@ -383,7 +383,7 @@ NodeID SVFIR::addGepValNode(const Value* curInst,const Value* gepVal, const Loca
 NodeID SVFIR::getGepObjVar(NodeID id, const LocationSet& ls)
 {
     SVFVar* node = pag->getGNode(id);
-    if (GepObjPN* gepNode = SVFUtil::dyn_cast<GepObjPN>(node))
+    if (GepObjVar* gepNode = SVFUtil::dyn_cast<GepObjVar>(node))
         return getGepObjVar(gepNode->getMemObj(), gepNode->getLocationSet() + ls);
     else if (FIObjVar* baseNode = SVFUtil::dyn_cast<FIObjVar>(node))
         return getGepObjVar(baseNode->getMemObj(), ls);
@@ -413,7 +413,7 @@ NodeID SVFIR::getGepObjVar(const MemObj* obj, const LocationSet& ls)
     LocationSet newLS = SymbolTableInfo::SymbolInfo()->getModulusOffset(obj,ls);
 
     // Base and first field are the same memory location.
-    if (Options::FirstFieldEqBase && newLS.getOffset() == 0) return base;
+    if (Options::FirstFieldEqBase && newLS.accumulateConstantOffset() == 0) return base;
 
     NodeLocationSetMap::iterator iter = GepObjVarMap.find(std::make_pair(base, newLS));
     if (iter == GepObjVarMap.end())
@@ -433,9 +433,9 @@ 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.getOffset(), StInfo::getMaxFieldLimit());
+    NodeID gepId = NodeIDAllocator::get()->allocateGepObjectId(base, ls.accumulateConstantOffset(), StInfo::getMaxFieldLimit());
     GepObjVarMap[std::make_pair(base, ls)] = gepId;
-    GepObjPN *node = new GepObjPN(obj, gepId, ls);
+    GepObjVar *node = new GepObjVar(obj, gepId, ls);
     memToFieldsMap[base].set(gepId);
     return addObjNode(obj->getValue(), node, gepId);
 }

package/lib/MemoryModel/SVFVariables.cpp

@@ -141,10 +141,10 @@ const std::string GepValVar::toString() const {
     return rawstr.str();
 }
 
-const std::string GepObjPN::toString() const {
+const std::string GepObjVar::toString() const {
     std::string str;
     raw_string_ostream rawstr(str);
-    rawstr << "GepObjPN ID: " << getId() << " with offset_" + llvm::itostr(ls.getOffset());
+    rawstr << "GepObjVar ID: " << getId() << " with offset_" + llvm::itostr(ls.accumulateConstantOffset());
     if (Options::PAGDotGraphShorter) {
         rawstr << "\n";
     }

package/lib/MemoryModel/SymbolTableInfo.cpp

@@ -101,22 +101,18 @@ void SymbolTableInfo::collectArrayInfo(const ArrayType* ty)
     }
 
     /// Array itself only has one field which is the inner most element
-    stinfo->addFldWithType(0, 0, elemTy);
+    stinfo->addFldWithType(0,elemTy);
 
     /// Array's flatten field infor is the same as its element's
     /// flatten infor.
     StInfo* elemStInfo = getStructInfo(elemTy);
-    u32_t nfE = elemStInfo->getFlattenFieldInfoVec().size();
+    u32_t nfE = elemStInfo->getFlattenedFieldInfoVec().size();
     for (u32_t j = 0; j < nfE; j++)
     {
-        u32_t idx = elemStInfo->getFlattenFieldInfoVec()[j].getFlattenFldIdx();
-        u32_t off = elemStInfo->getFlattenFieldInfoVec()[j].getFlattenByteOffset();
-        const Type* fieldTy = elemStInfo->getFlattenFieldInfoVec()[j].getFlattenElemTy();
-        FieldInfo::ElemNumStridePairVec pair = elemStInfo->getFlattenFieldInfoVec()[j].getElemNumStridePairVect();
-        /// append the additional number
-        pair.push_back(std::make_pair(out_num, out_stride));
-        FieldInfo field(idx, off, fieldTy, pair);
-        stinfo->getFlattenFieldInfoVec().push_back(field);
+        u32_t idx = elemStInfo->getFlattenedFieldInfoVec()[j].getFlattenFldIdx();
+        const Type* fieldTy = elemStInfo->getFlattenedFieldInfoVec()[j].getFlattenElemTy();
+        FlattenedFieldInfo field(idx, fieldTy);
+        stinfo->getFlattenedFieldInfoVec().push_back(field);
     }
 }
 
@@ -139,36 +135,27 @@ void SymbolTableInfo::collectStructInfo(const StructType *sty)
                 sty->element_end(); it != ie; ++it, ++field_idx)
     {
         const Type *et = *it;
-        // This offset is computed after alignment with the current struct
-        u64_t eOffsetInBytes = getTypeSizeInBytes(sty, field_idx);
-        //The offset is where this element will be placed in the exp. struct.
-        /// FIXME: As the layout size is uint_64, here we assume
         /// offset with uint_32 (Size_t) is large enough and will not cause overflow
-        stinfo->addFldWithType(nf, static_cast<u32_t>(eOffsetInBytes), et);
+        stinfo->addFldWithType(nf, et);
 
         if (SVFUtil::isa<StructType>(et) || SVFUtil::isa<ArrayType>(et))
         {
             StInfo * subStinfo = getStructInfo(et);
-            u32_t nfE = subStinfo->getFlattenFieldInfoVec().size();
+            u32_t nfE = subStinfo->getFlattenedFieldInfoVec().size();
             //Copy ST's info, whose element 0 is the size of ST itself.
             for (u32_t j = 0; j < nfE; j++)
             {
-                u32_t fldIdx = nf + subStinfo->getFlattenFieldInfoVec()[j].getFlattenFldIdx();
-                u32_t off = eOffsetInBytes + subStinfo->getFlattenFieldInfoVec()[j].getFlattenByteOffset();
-                const Type* elemTy = subStinfo->getFlattenFieldInfoVec()[j].getFlattenElemTy();
-                FieldInfo::ElemNumStridePairVec pair = subStinfo->getFlattenFieldInfoVec()[j].getElemNumStridePairVect();
-                pair.push_back(std::make_pair(1, 0));
-                FieldInfo field(fldIdx, off,elemTy,pair);
-                stinfo->getFlattenFieldInfoVec().push_back(field);
+                u32_t fldIdx = nf + subStinfo->getFlattenedFieldInfoVec()[j].getFlattenFldIdx();
+                const Type* elemTy = subStinfo->getFlattenedFieldInfoVec()[j].getFlattenElemTy();
+                FlattenedFieldInfo field(fldIdx, elemTy);
+                stinfo->getFlattenedFieldInfoVec().push_back(field);
             }
             nf += nfE;
         }
         else     //simple type
         {
-            FieldInfo::ElemNumStridePairVec pair;
-            pair.push_back(std::make_pair(1,0));
-            FieldInfo field(nf, eOffsetInBytes, et,pair);
-            stinfo->getFlattenFieldInfoVec().push_back(field);
+            FlattenedFieldInfo field(nf, et);
+            stinfo->getFlattenedFieldInfoVec().push_back(field);
             ++nf;
         }
     }
@@ -191,12 +178,10 @@ void SymbolTableInfo::collectSimpleTypeInfo(const Type* ty)
     typeToFieldInfo[ty] = stinfo;
 
     /// Only one field
-    stinfo->addFldWithType(0,0, ty);
+    stinfo->addFldWithType(0, ty);
 
-    FieldInfo::ElemNumStridePairVec pair;
-    pair.push_back(std::make_pair(1,0));
-    FieldInfo field(0, 0, ty, pair);
-    stinfo->getFlattenFieldInfoVec().push_back(field);
+    FlattenedFieldInfo field(0, ty);
+    stinfo->getFlattenedFieldInfoVec().push_back(field);
 }
 
 
@@ -210,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.getOffset();
+    Size_t offset = ls.accumulateConstantOffset();
     if(offset < 0)
     {
         writeWrnMsg("try to create a gep node with negative offset.");
@@ -294,10 +279,10 @@ bool SymbolTableInfo::isConstantObjSym(const Value *val)
         else
         {
             StInfo *stInfo = getStructInfo(v->getInitializer()->getType());
-            const std::vector<FieldInfo> &fields = stInfo->getFlattenFieldInfoVec();
-            for (std::vector<FieldInfo>::const_iterator it = fields.begin(), eit = fields.end(); it != eit; ++it)
+            const std::vector<FlattenedFieldInfo> &fields = stInfo->getFlattenedFieldInfoVec();
+            for (std::vector<FlattenedFieldInfo>::const_iterator it = fields.begin(), eit = fields.end(); it != eit; ++it)
             {
-                const FieldInfo &field = *it;
+                const FlattenedFieldInfo &field = *it;
                 const Type *elemTy = field.getFlattenElemTy();
                 assert(!SVFUtil::isa<FunctionType>(elemTy) && "Initializer of a global is a function?");
                 if (SVFUtil::isa<PointerType>(elemTy))
@@ -337,29 +322,23 @@ const MemObj* SymbolTableInfo::createDummyObj(SymID symId, const Type* type)
     return memObj;
 }
 
-const std::vector<u32_t>& SymbolTableInfo::getFattenFieldIdxVec(const Type *T)
+const std::vector<u32_t>& SymbolTableInfo::getFlattenedFieldIdxVec(const Type *T)
 {
-    return getStructInfoIter(T)->second->getFieldIdxVec();
+    return getStructInfoIter(T)->second->getFlattenedFieldIdxVec();
 }
 
-const std::vector<u32_t>& SymbolTableInfo::getFattenFieldOffsetVec(const Type *T)
+const std::vector<FlattenedFieldInfo>& SymbolTableInfo::getFlattenedFieldInfoVec(const Type *T)
 {
-    return getStructInfoIter(T)->second->getFieldOffsetVec();
+    return getStructInfoIter(T)->second->getFlattenedFieldInfoVec();
 }
 
-const std::vector<FieldInfo>& SymbolTableInfo::getFlattenFieldInfoVec(const Type *T)
+const Type* SymbolTableInfo::getOriginalFieldType(const Type* baseType, u32_t field_idx)
 {
-    return getStructInfoIter(T)->second->getFlattenFieldInfoVec();
+    return getStructInfoIter(baseType)->second->getOriginalFieldType(field_idx);
 }
 
-const Type* SymbolTableInfo::getOrigSubTypeWithFldInx(const Type* baseType, u32_t field_idx)
-{
-    return getStructInfoIter(baseType)->second->getFieldTypeWithFldIdx(field_idx);
-}
-
-const Type* SymbolTableInfo::getOrigSubTypeWithByteOffset(const Type* baseType, u32_t byteOffset)
-{
-    return getStructInfoIter(baseType)->second->getFieldTypeWithByteOffset(byteOffset);
+const Type* SymbolTableInfo::getFlatternedFieldType(const Type* baseType, u32_t field_idx){
+        return getStructInfoIter(baseType)->second->getFlatternedFieldType(field_idx);
 }
 
 /*
@@ -383,21 +362,15 @@ void SymbolTableInfo::printFlattenFields(const Type* type)
         outs() <<"  {Type: ";
         st->print(outs());
         outs() << "}\n";
-        std::vector<FieldInfo>& finfo = getStructInfo(st)->getFlattenFieldInfoVec();
+        std::vector<FlattenedFieldInfo>& finfo = getStructInfo(st)->getFlattenedFieldInfoVec();
         int field_idx = 0;
-        for(std::vector<FieldInfo>::iterator it = finfo.begin(), eit = finfo.end();
+        for(std::vector<FlattenedFieldInfo>::iterator it = finfo.begin(), eit = finfo.end();
                 it!=eit; ++it, field_idx++)
         {
-            outs() << " \tField_idx = " << (*it).getFlattenFldIdx() << " [offset: " << (*it).getFlattenByteOffset();
+            outs() << " \tField_idx = " << (*it).getFlattenFldIdx();
             outs() << ", field type: ";
             (*it).getFlattenElemTy()->print(outs());
             outs() << ", field size: " << getTypeSizeInBytes((*it).getFlattenElemTy());
-            outs() << ", field stride pair: ";
-            for(FieldInfo::ElemNumStridePairVec::const_iterator pit = (*it).elemStridePairBegin(),
-                    peit = (*it).elemStridePairEnd(); pit!=peit; ++pit)
-            {
-                outs() << "[ " << pit->first << ", " << pit->second << " ] ";
-            }
             outs() << "\n";
         }
         outs() << "\n";
@@ -576,12 +549,12 @@ bool ObjTypeInfo::isNonPtrFieldObj(const LocationSet& ls)
     if (SVFUtil::isa<StructType>(ety) || SVFUtil::isa<ArrayType>(ety))
     {
         bool hasIntersection = false;
-        const vector<FieldInfo> &infovec = SymbolTableInfo::SymbolInfo()->getFlattenFieldInfoVec(ety);
-        vector<FieldInfo>::const_iterator it = infovec.begin();
-        vector<FieldInfo>::const_iterator eit = infovec.end();
+        const vector<FlattenedFieldInfo> &infovec = SymbolTableInfo::SymbolInfo()->getFlattenedFieldInfoVec(ety);
+        vector<FlattenedFieldInfo>::const_iterator it = infovec.begin();
+        vector<FlattenedFieldInfo>::const_iterator eit = infovec.end();
         for (; it != eit; ++it)
         {
-            const FieldInfo& fieldLS = *it;
+            const FlattenedFieldInfo& fieldLS = *it;
             if (ls.intersects(LocationSet(fieldLS)))
             {
                 hasIntersection = true;

package/lib/SABER/SaberSVFGBuilder.cpp

@@ -73,7 +73,7 @@ void SaberSVFGBuilder::collectGlobals(BVDataPTAImpl* pta)
         if(SVFUtil::isa<DummyValVar>(pagNode) || SVFUtil::isa<DummyObjVar>(pagNode))
             continue;
 
-        if(GepObjPN* gepobj = SVFUtil::dyn_cast<GepObjPN>(pagNode)) {
+        if(GepObjVar* gepobj = SVFUtil::dyn_cast<GepObjVar>(pagNode)) {
             if(SVFUtil::isa<DummyObjVar>(pag->getGNode(gepobj->getBaseNode())))
                 continue;
         }

package/lib/SVF-FE/SVFIRBuilder.cpp

@@ -212,13 +212,12 @@ bool SVFIRBuilder::computeGepOffset(const User *V, LocationSet& ls)
     if(gepOp && dataLayout && gepOp->accumulateConstantOffset(*dataLayout,byteOffset))
     {
         Size_t bo = byteOffset.getSExtValue();
-        ls.setByteOffset(bo + ls.getByteOffset());
     }
 
     for (bridge_gep_iterator gi = bridge_gep_begin(*V), ge = bridge_gep_end(*V);
             gi != ge; ++gi)
     {
-
+        ls.addOffsetValue(gi.getOperand());
         // Handling array types, skipe array handling here
         // We treat whole array as one, then we can distinguish different field of an array of struct
         // e.g. s[1].f1 is differet from s[0].f2
@@ -257,14 +256,14 @@ bool SVFIRBuilder::computeGepOffset(const User *V, LocationSet& ls)
         if (const StructType *ST = SVFUtil::dyn_cast<StructType>(*gi) )
         {
             assert(op && "non-const struct index in GEP");
-            const vector<u32_t> &so = SymbolTableInfo::SymbolInfo()->getFattenFieldIdxVec(ST);
+            const vector<u32_t> &so = SymbolTableInfo::SymbolInfo()->getFlattenedFieldIdxVec(ST);
             if ((unsigned)idx >= so.size())
             {
                 outs() << "!! Struct index out of bounds" << idx << "\n";
                 assert(0);
             }
             //add the translated offset
-            ls.setFldIdx(ls.getOffset() + so[idx]);
+            ls.setFldIdx(ls.accumulateConstantOffset() + so[idx]);
         }
     }
     return true;
@@ -483,7 +482,7 @@ void SVFIRBuilder::InitialGlobal(const GlobalVariable *gvar, Constant *C,
     {
         const StructType *sty = SVFUtil::cast<StructType>(C->getType());
         const std::vector<u32_t>& offsetvect =
-            SymbolTableInfo::SymbolInfo()->getFattenFieldIdxVec(sty);
+            SymbolTableInfo::SymbolInfo()->getFlattenedFieldIdxVec(sty);
         for (u32_t i = 0, e = C->getNumOperands(); i != e; i++)
         {
             u32_t off = offsetvect[i];
@@ -1290,7 +1289,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).getOffset();
+                Size_t offset = pag->getLocationSetFromBaseNode(vnArg3).accumulateConstantOffset();
 
                 // We get all flattened fields of base
                 vector<LocationSet> fields;
@@ -1314,7 +1313,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).getOffset();
+                Size_t offset = pag->getLocationSetFromBaseNode(vnArg).accumulateConstantOffset();
 
                 // We get all fields
                 vector<LocationSet> fields;
@@ -1523,7 +1522,7 @@ NodeID SVFIRBuilder::getGepValVar(const Value* val, const LocationSet& ls, const
          * 2. GlobalVariable
          */
         assert((SVFUtil::isa<Instruction>(curVal) || SVFUtil::isa<GlobalVariable>(curVal)) && "curVal not an instruction or a globalvariable?");
-        const std::vector<FieldInfo> &fieldinfo = SymbolTableInfo::SymbolInfo()->getFlattenFieldInfoVec(baseType);
+        const std::vector<FlattenedFieldInfo> &fieldinfo = SymbolTableInfo::SymbolInfo()->getFlattenedFieldInfoVec(baseType);
         const Type *type = fieldinfo[fieldidx].getFlattenElemTy();
 
         // We assume every GepValNode and its GepEdge to the baseNode are unique across the whole program
@@ -1627,13 +1626,13 @@ u32_t SVFIRBuilder::getFields(std::vector<LocationSet>& fields, const Type* T, u
         return 0;
 
     T = T->getContainedType(0);
-    const std::vector<FieldInfo>& stVec = SymbolTableInfo::SymbolInfo()->getFlattenFieldInfoVec(T);
+    const std::vector<FlattenedFieldInfo>& stVec = SymbolTableInfo::SymbolInfo()->getFlattenedFieldInfoVec(T);
     u32_t sz = stVec.size();
     if (msz < sz)
     {
         /// Replace fields with T's flatten fields.
         fields.clear();
-        for(std::vector<FieldInfo>::const_iterator it = stVec.begin(), eit = stVec.end(); it!=eit; ++it)
+        for(std::vector<FlattenedFieldInfo>::const_iterator it = stVec.begin(), eit = stVec.end(); it!=eit; ++it)
             fields.push_back(LocationSet(*it));
     }
 

package/lib/SVF-FE/SymbolTableBuilder.cpp

@@ -444,7 +444,7 @@ void SymbolTableBuilder::handleGlobalInitializerCE(const Constant *C,
     {
         const StructType *sty = SVFUtil::cast<StructType>(C->getType());
         const std::vector<u32_t>& offsetvect =
-            SymbolTableInfo::SymbolInfo()->getFattenFieldIdxVec(sty);
+            SymbolTableInfo::SymbolInfo()->getFlattenedFieldIdxVec(sty);
         for (u32_t i = 0, e = C->getNumOperands(); i != e; i++)
         {
             u32_t off = offsetvect[i];
@@ -515,8 +515,8 @@ void SymbolTableBuilder::analyzeGlobalStackObjType(ObjTypeInfo* typeinfo, const
     }
     if (const StructType *ST= SVFUtil::dyn_cast<StructType>(elemTy))
     {
-        const std::vector<FieldInfo>& flattenFields = SymbolTableInfo::SymbolInfo()->getFlattenFieldInfoVec(ST);
-        for(std::vector<FieldInfo>::const_iterator it = flattenFields.begin(), eit = flattenFields.end();
+        const std::vector<FlattenedFieldInfo>& flattenFields = SymbolTableInfo::SymbolInfo()->getFlattenedFieldInfoVec(ST);
+        for(std::vector<FlattenedFieldInfo>::const_iterator it = flattenFields.begin(), eit = flattenFields.end();
                 it!=eit; ++it)
         {
             if((*it).getFlattenElemTy()->isPointerTy())
@@ -600,7 +600,7 @@ u32_t SymbolTableBuilder::getObjSize(const Value* val)
     u32_t numOfFields = 1;
     if (SVFUtil::isa<StructType>(ety) || SVFUtil::isa<ArrayType>(ety))
     {
-        numOfFields = SymbolTableInfo::SymbolInfo()->getFlattenFieldInfoVec(ety).size();
+        numOfFields = SymbolTableInfo::SymbolInfo()->getFlattenedFieldInfoVec(ety).size();
     }
     return numOfFields;
 }

package/lib/Util/TypeBasedHeapCloning.cpp

@@ -153,9 +153,9 @@ const NodeBS TypeBasedHeapCloning::getGepObjClones(NodeID base, unsigned offset)
     // totalOffset is the offset from the real base (i.e. base of base),
     // offset is the offset into base, whether it is a field itself or not.
     unsigned totalOffset = offset;
-    if (const GepObjPN *baseGep = SVFUtil::dyn_cast<GepObjPN>(baseNode))
+    if (const GepObjVar *baseGep = SVFUtil::dyn_cast<GepObjVar>(baseNode))
     {
-        totalOffset += baseGep->getLocationSet().getOffset();
+        totalOffset += baseGep->getOffset();
     }
 
     const DIType *baseType = getType(base);
@@ -184,12 +184,12 @@ const NodeBS TypeBasedHeapCloning::getGepObjClones(NodeID base, unsigned offset)
     {
         PAGNode *node = ppag->getGNode(gep);
         assert(node && "TBHC: expected gep node doesn't exist.");
-        assert((SVFUtil::isa<GepObjPN>(node) || SVFUtil::isa<FIObjVar>(node))
+        assert((SVFUtil::isa<GepObjVar>(node) || SVFUtil::isa<FIObjVar>(node))
                && "TBHC: expected a GEP or FI object.");
 
-        if (GepObjPN *gepNode = SVFUtil::dyn_cast<GepObjPN>(node))
+        if (GepObjVar *gepNode = SVFUtil::dyn_cast<GepObjVar>(node))
         {
-            if (gepNode->getLocationSet().getOffset() == totalOffset)
+            if (gepNode->getOffset() == totalOffset)
             {
                 geps.set(gep);
             }
@@ -225,7 +225,7 @@ const NodeBS TypeBasedHeapCloning::getGepObjClones(NodeID base, unsigned offset)
             newGep = ppag->getGepObjVar(base, newLS);
         }
 
-        if (GepObjPN *gep = SVFUtil::dyn_cast<GepObjPN>(ppag->getGNode(newGep)))
+        if (GepObjVar *gep = SVFUtil::dyn_cast<GepObjVar>(ppag->getGNode(newGep)))
         {
             gep->setBaseNode(base);
         }
@@ -412,9 +412,9 @@ NodeID TypeBasedHeapCloning::cloneObject(NodeID o, const DIType *type, bool)
 {
     NodeID clone;
     const PAGNode *obj = ppag->getGNode(o);
-    if (const GepObjPN *gepObj = SVFUtil::dyn_cast<GepObjPN>(obj))
+    if (const GepObjVar *gepObj = SVFUtil::dyn_cast<GepObjVar>(obj))
     {
-        const NodeBS &clones = getGepObjClones(gepObj->getBaseNode(), gepObj->getLocationSet().getOffset());
+        const NodeBS &clones = getGepObjClones(gepObj->getBaseNode(), gepObj->getOffset());
         // TODO: a bit of repetition.
         for (NodeID clone : clones)
         {
@@ -427,7 +427,7 @@ NodeID TypeBasedHeapCloning::cloneObject(NodeID o, const DIType *type, bool)
         clone = addCloneGepObjNode(gepObj->getMemObj(), gepObj->getLocationSet());
 
         // The base needs to know about the new clone.
-        addGepToObj(clone, gepObj->getBaseNode(), gepObj->getLocationSet().getOffset());
+        addGepToObj(clone, gepObj->getBaseNode(), gepObj->getOffset());
 
         addClone(o, clone);
         addClone(getOriginalObj(o), clone);
@@ -539,7 +539,7 @@ const DIType *TypeBasedHeapCloning::getTypeFromCTirMetadata(const Value *v)
 bool TypeBasedHeapCloning::isGep(const PAGNode *n) const
 {
     assert(n != nullptr && "TBHC: testing if null is a GEP object!");
-    return SVFUtil::isa<GepObjPN>(n);
+    return SVFUtil::isa<GepObjVar>(n);
 }
 
 /// Returns true if the function name matches MAYALIAS, NOALIAS, etc.

package/lib/WPA/Andersen.cpp

@@ -166,7 +166,7 @@ void AndersenBase::normalizePointsTo()
     // for redundant gepnodes and remove those nodes from pag
     for (NodeID n: redundantGepNodes) {
         NodeID base = pag->getBaseObjVar(n);
-        GepObjPN *gepNode = SVFUtil::dyn_cast<GepObjPN>(pag->getGNode(n));
+        GepObjVar *gepNode = SVFUtil::dyn_cast<GepObjVar>(pag->getGNode(n));
         assert(gepNode && "Not a gep node in redundantGepNodes set");
         const LocationSet ls = gepNode->getLocationSet();
         GepObjVarMap.erase(std::make_pair(base, ls));

package/lib/WPA/AndersenSFR.cpp

@@ -133,8 +133,8 @@ void AndersenSFR::fieldExpand(NodeSet& initials, Size_t offset, NodeBS& strides,
             const MemObj* obj = pag->getBaseObj(init);
             const Size_t maxLimit = obj->getMaxFieldOffsetLimit();
             Size_t initOffset;
-            if (GepObjPN *gepNode = SVFUtil::dyn_cast<GepObjPN>(initPN))
-                initOffset = gepNode->getLocationSet().getOffset();
+            if (GepObjVar *gepNode = SVFUtil::dyn_cast<GepObjVar>(initPN))
+                initOffset = gepNode->getOffset();
             else if (SVFUtil::isa<FIObjVar>(initPN) || SVFUtil::isa<DummyObjVar>(initPN))
                 initOffset = 0;
             else