svf-tools 1.0.328 → 1.0.332

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/PointerAnalysis.cpp

@@ -53,7 +53,6 @@ using namespace SVFUtil;
 using namespace cppUtil;
 
 
-CommonCHGraph* PointerAnalysis::chgraph = nullptr;
 SVFIR* PointerAnalysis::pag = nullptr;
 
 const std::string PointerAnalysis::aliasTestMayAlias            = "MAYALIAS";
@@ -73,7 +72,7 @@ const std::string PointerAnalysis::aliasTestFailNoAliasMangled  = "_Z20EXPECTEDF
  * Constructor
  */
 PointerAnalysis::PointerAnalysis(SVFIR* p, PTATY ty, bool alias_check) :
-    svfMod(nullptr),ptaTy(ty),stat(nullptr),ptaCallGraph(nullptr),callGraphSCC(nullptr),icfg(nullptr),typeSystem(nullptr)
+    svfMod(nullptr),ptaTy(ty),stat(nullptr),ptaCallGraph(nullptr),callGraphSCC(nullptr),icfg(nullptr),typeSystem(nullptr), chgraph(nullptr)
 {
     pag = p;
 	OnTheFlyIterBudgetForStat = Options::StatBudget;
@@ -103,6 +102,9 @@ void PointerAnalysis::destroy()
 
     delete stat;
     stat = nullptr;
+
+    delete chgraph;
+    chgraph = nullptr;
 }
 
 /*!

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,161 +178,12 @@ 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);
 }
 
-/*!
- * Compute gep offset
- */
-bool SymbolTableInfo::computeGepOffset(const User *V, LocationSet& ls)
-{
-    assert(V);
-
-    const llvm::GEPOperator *gepOp = SVFUtil::dyn_cast<const llvm::GEPOperator>(V);
-    DataLayout * dataLayout = getDataLayout(LLVMModuleSet::getLLVMModuleSet()->getMainLLVMModule());
-    llvm::APInt byteOffset(dataLayout->getIndexSizeInBits(gepOp->getPointerAddressSpace()),0,true);
-    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)
-    {
-
-        // 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
-        if(SVFUtil::isa<ArrayType>(*gi))
-            continue;
-
-        //The int-value object of the current index operand
-        //  (may not be constant for arrays).
-        ConstantInt *op = SVFUtil::dyn_cast<ConstantInt>(gi.getOperand());
-
-        /// given a gep edge p = q + i,
-        if(!op)
-        {
-            return false;
-        }
-        //The actual index
-        Size_t idx = op->getSExtValue();
-
-
-        // Handling pointer types
-        // These GEP instructions are simply making address computations from the base pointer address
-        // e.g. idx = (char*) &p + 4,  at this case gep only one offset index (idx)
-        // Case 1: This operation is likely accessing an array through pointer p.
-        // Case 2: It may also be used to access a field of a struct (which is not ANSI-compliant)
-        // Since this is a field-index based memory model,
-        // for case 1: we consider the whole array as one element, This can be improved by LocMemModel as it can distinguish different
-        // elements of the same array.
-        // for case 2: we treat idx the same as &p by ignoring const 4 (This handling is unsound since the program itself is not ANSI-compliant).
-        if (SVFUtil::isa<PointerType>(*gi))
-        {
-            //off += idx;
-        }
-
-
-        // Handling struct here
-        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);
-            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]);
-        }
-    }
-    return true;
-}
-
-
-/*!
- * Replace fields with flatten fields of T if the number of its fields is larger than msz.
- */
-u32_t SymbolTableInfo::getFields(std::vector<LocationSet>& fields, const Type* T, u32_t msz)
-{
-    if (!SVFUtil::isa<PointerType>(T))
-        return 0;
-
-    T = T->getContainedType(0);
-    const std::vector<FieldInfo>& stVec = SymbolTableInfo::SymbolInfo()->getFlattenFieldInfoVec(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)
-            fields.push_back(LocationSet(*it));
-    }
-
-    return sz;
-}
-
-
-/*!
- * Find the base type and the max possible offset for an object pointed to by (V).
- */
-const Type *SymbolTableInfo::getBaseTypeAndFlattenedFields(const Value *V, std::vector<LocationSet> &fields)
-{
-    assert(V);
-    fields.push_back(LocationSet(0));
-
-    const Type *T = V->getType();
-    // Use the biggest struct type out of all operands.
-    if (const User *U = SVFUtil::dyn_cast<User>(V))
-    {
-        u32_t msz = 1;      //the max size seen so far
-        // In case of BitCast, try the target type itself
-        if (SVFUtil::isa<BitCastInst>(V))
-        {
-            u32_t sz = getFields(fields, T, msz);
-            if (msz < sz)
-            {
-                msz = sz;
-            }
-        }
-        // Try the types of all operands
-        for (User::const_op_iterator it = U->op_begin(), ie = U->op_end();
-                it != ie; ++it)
-        {
-            const Type *operandtype = it->get()->getType();
-
-            u32_t sz = getFields(fields, operandtype, msz);
-            if (msz < sz)
-            {
-                msz = sz;
-                T = operandtype;
-            }
-        }
-    }
-    // If V is a CE, the actual pointer type is its operand.
-    else if (const ConstantExpr *E = SVFUtil::dyn_cast<ConstantExpr>(V))
-    {
-        T = E->getOperand(0)->getType();
-        getFields(fields, T, 0);
-    }
-    // Handle Argument case
-    else if (SVFUtil::isa<Argument>(V))
-    {
-        getFields(fields, T, 0);
-    }
-
-    while (const PointerType *ptype = SVFUtil::dyn_cast<PointerType>(T))
-        T = ptype->getElementType();
-    return T;
-}
 
 /*!
  * Get modulus offset given the type information
@@ -357,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.");
@@ -441,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))
@@ -484,29 +322,23 @@ const MemObj* SymbolTableInfo::createDummyObj(SymID symId, const Type* type)
     return memObj;
 }
 
-const std::vector<u32_t>& SymbolTableInfo::getFattenFieldIdxVec(const Type *T)
-{
-    return getStructInfoIter(T)->second->getFieldIdxVec();
-}
-
-const std::vector<u32_t>& SymbolTableInfo::getFattenFieldOffsetVec(const Type *T)
+const std::vector<u32_t>& SymbolTableInfo::getFlattenedFieldIdxVec(const Type *T)
 {
-    return getStructInfoIter(T)->second->getFieldOffsetVec();
+    return getStructInfoIter(T)->second->getFlattenedFieldIdxVec();
 }
 
-const std::vector<FieldInfo>& SymbolTableInfo::getFlattenFieldInfoVec(const Type *T)
+const std::vector<FlattenedFieldInfo>& SymbolTableInfo::getFlattenedFieldInfoVec(const Type *T)
 {
-    return getStructInfoIter(T)->second->getFlattenFieldInfoVec();
+    return getStructInfoIter(T)->second->getFlattenedFieldInfoVec();
 }
 
-const Type* SymbolTableInfo::getOrigSubTypeWithFldInx(const Type* baseType, u32_t field_idx)
+const Type* SymbolTableInfo::getOriginalFieldType(const Type* baseType, u32_t field_idx)
 {
-    return getStructInfoIter(baseType)->second->getFieldTypeWithFldIdx(field_idx);
+    return getStructInfoIter(baseType)->second->getOriginalFieldType(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);
 }
 
 /*
@@ -530,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";
@@ -723,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;
         }