svf-tools 1.0.330 → 1.0.331

package/include/MemoryModel/LocationSet.h

@@ -42,44 +42,23 @@ namespace SVF
 /*!
  * Field information of an aggregate object
  */
-class FieldInfo
+class FlattenedFieldInfo
 {
-public:
-    typedef std::vector<NodePair > ElemNumStridePairVec;
-
 private:
-    u32_t fldIdx;
-    u32_t byteOffset;
-    const Type* elemTy;
-    ElemNumStridePairVec elemNumStridePair;
+    u32_t flattenedFldIdx;
+    const Type* flattenedElemTy;
 public:
-    FieldInfo(u32_t idx, u32_t byteOff, const Type* ty, ElemNumStridePairVec pa) :
-        fldIdx(idx), byteOffset(byteOff), elemTy(ty), elemNumStridePair(pa)
+    FlattenedFieldInfo(u32_t idx, const Type* ty) :
+        flattenedFldIdx(idx), flattenedElemTy(ty)
     {
     }
     inline u32_t getFlattenFldIdx() const
     {
-        return fldIdx;
-    }
-    inline u32_t getFlattenByteOffset() const
-    {
-        return byteOffset;
+        return flattenedFldIdx;
     }
     inline const Type* getFlattenElemTy() const
     {
-        return elemTy;
-    }
-    inline const ElemNumStridePairVec& getElemNumStridePairVect() const
-    {
-        return elemNumStridePair;
-    }
-    inline ElemNumStridePairVec::const_iterator elemStridePairBegin() const
-    {
-        return elemNumStridePair.begin();
-    }
-    inline ElemNumStridePairVec::const_iterator elemStridePairEnd() const
-    {
-        return elemNumStridePair.end();
+        return flattenedElemTy;
     }
 };
 
@@ -99,32 +78,22 @@ public:
         NonOverlap, Overlap, Subset, Superset, Same
     };
 
-    typedef FieldInfo::ElemNumStridePairVec ElemNumStridePairVec;
+    typedef std::vector<const Value* > OffsetValueVec;
 
     /// Constructor
-    LocationSet(Size_t o = 0) : fldIdx(o), byteOffset(o)
+    LocationSet(Size_t o = 0) : fldIdx(o)
     {}
 
     /// Copy Constructor
     LocationSet(const LocationSet& ls)
-        : fldIdx(ls.fldIdx), byteOffset(ls.byteOffset)
+        : fldIdx(ls.fldIdx)
     {
-        const ElemNumStridePairVec& vec = ls.getNumStridePair();
-        ElemNumStridePairVec::const_iterator it = vec.begin();
-        ElemNumStridePairVec::const_iterator eit = vec.end();
-        for (; it != eit; ++it)
-            addElemNumStridePair(*it);
     }
 
-    /// Initialization from FieldInfo
-    LocationSet(const FieldInfo& fi)
-        : fldIdx(fi.getFlattenFldIdx()), byteOffset(fi.getFlattenByteOffset())
+    /// Initialization from FlattenedFieldInfo
+    LocationSet(const FlattenedFieldInfo& fi)
+        : fldIdx(fi.getFlattenFldIdx())
     {
-        const ElemNumStridePairVec& vec = fi.getElemNumStridePairVect();
-        ElemNumStridePairVec::const_iterator it = vec.begin();
-        ElemNumStridePairVec::const_iterator eit = vec.end();
-        for (; it != eit; ++it)
-            addElemNumStridePair(*it);
     }
 
     ~LocationSet() {}
@@ -135,44 +104,37 @@ public:
     inline LocationSet operator+ (const LocationSet& rhs) const
     {
         LocationSet ls(rhs);
-        ls.fldIdx += getOffset();
-        ls.byteOffset += getByteOffset();
-        ElemNumStridePairVec::const_iterator it = getNumStridePair().begin();
-        ElemNumStridePairVec::const_iterator eit = getNumStridePair().end();
+        ls.fldIdx += accumulateConstantOffset();
+        OffsetValueVec::const_iterator it = getOffsetValueVec().begin();
+        OffsetValueVec::const_iterator eit = getOffsetValueVec().end();
         for (; it != eit; ++it)
-            ls.addElemNumStridePair(*it);
+            ls.addOffsetValue(*it);
 
         return ls;
     }
     inline const LocationSet& operator= (const LocationSet& rhs)
     {
         fldIdx = rhs.fldIdx;
-        byteOffset = rhs.byteOffset;
-        numStridePair = rhs.getNumStridePair();
+        offsetValues = rhs.getOffsetValueVec();
         return *this;
     }
     inline bool operator< (const LocationSet& rhs) const
     {
         if (fldIdx != rhs.fldIdx)
             return (fldIdx < rhs.fldIdx);
-//        else if (byteOffset != rhs.byteOffset)
-//            return (byteOffset < rhs.byteOffset);
         else
         {
-            const ElemNumStridePairVec& pairVec = getNumStridePair();
-            const ElemNumStridePairVec& rhsPairVec = rhs.getNumStridePair();
+            const OffsetValueVec& pairVec = getOffsetValueVec();
+            const OffsetValueVec& rhsPairVec = rhs.getOffsetValueVec();
             if (pairVec.size() != rhsPairVec.size())
                 return (pairVec.size() < rhsPairVec.size());
             else
             {
-                ElemNumStridePairVec::const_iterator it = pairVec.begin();
-                ElemNumStridePairVec::const_iterator rhsIt = rhsPairVec.begin();
+                OffsetValueVec::const_iterator it = pairVec.begin();
+                OffsetValueVec::const_iterator rhsIt = rhsPairVec.begin();
                 for (; it != pairVec.end() && rhsIt != rhsPairVec.end(); ++it, ++rhsIt)
                 {
-                    if ((*it).first != (*rhsIt).first)
-                        return ((*it).first < (*rhsIt).first);
-                    else if ((*it).second != (*rhsIt).second)
-                        return ((*it).second < (*rhsIt).second);
+                    return (*it) < (*rhsIt);
                 }
 
                 return false;
@@ -183,42 +145,30 @@ public:
     inline bool operator==(const LocationSet& rhs) const
     {
         return this->fldIdx == rhs.fldIdx
-               && this->byteOffset == rhs.byteOffset
-               && this->numStridePair == rhs.numStridePair;
+               && this->offsetValues == rhs.offsetValues;
     }
     //@}
 
     /// Get methods
     //@{
-    inline Size_t getOffset() const
+    inline Size_t accumulateConstantOffset() const
     {
         return fldIdx;
     }
-    inline Size_t getByteOffset() const
-    {
-        return byteOffset;
-    }
     inline void setFldIdx(Size_t idx)
     {
         fldIdx = idx;
     }
-    inline void setByteOffset(Size_t os)
+    inline const OffsetValueVec& getOffsetValueVec() const
     {
-        byteOffset = os;
-    }
-    inline const ElemNumStridePairVec& getNumStridePair() const
-    {
-        return numStridePair;
+        return offsetValues;
     }
     //@}
 
-    void addElemNumStridePair(const NodePair& pair);
+    bool addOffsetValue(const Value* offsetValue);
 
     /// Return TRUE if this is a constant location set.
-    inline bool isConstantOffset() const
-    {
-        return (numStridePair.size() == 0);
-    }
+    bool isConstantOffset() const;
 
     /// Return TRUE if we share any location in common with RHS
     inline bool intersects(const LocationSet& RHS) const
@@ -226,50 +176,13 @@ public:
         return computeAllLocations().intersects(RHS.computeAllLocations());
     }
 
-    /// Check relations of two location sets
-    static inline LSRelation checkRelation(const LocationSet& LHS, const LocationSet& RHS)
-    {
-        NodeBS lhsLocations = LHS.computeAllLocations();
-        NodeBS rhsLocations = RHS.computeAllLocations();
-        if (lhsLocations.intersects(rhsLocations))
-        {
-            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;
-        }
-    }
-
     /// Dump location set
-    std::string dump() const
-    {
-        std::string str;
-        raw_string_ostream rawstr(str);
-
-        rawstr << "LocationSet\tField_Index: " << getOffset();
-        rawstr << "\tOffset: " << getByteOffset()
-               << ",\tNum-Stride: {";
-        const ElemNumStridePairVec& vec = getNumStridePair();
-        ElemNumStridePairVec::const_iterator it = vec.begin();
-        ElemNumStridePairVec::const_iterator eit = vec.end();
-        for (; it != eit; ++it)
-        {
-            rawstr << " (" << it->first << "," << it->second << ")";
-        }
-        rawstr << " }\n";
-        return rawstr.str();
-    }
+    std::string dump() const;
+
 private:
-    /// Return TRUE if successfully increased any index by 1
-    bool increaseIfNotReachUpperBound(std::vector<NodeID>& indices,	const ElemNumStridePairVec& pairVec) const;
+
+    /// Check relations of two location sets
+    LSRelation checkRelation(const LocationSet& LHS, const LocationSet& RHS);
 
     /// Compute all possible locations according to offset and number-stride pairs.
     NodeBS computeAllLocations() const;
@@ -280,17 +193,17 @@ private:
         return (n2 == 0) ? n1 : gcd (n2, n1 % n2);
     }
 
-    Size_t fldIdx;	///< offset relative to base
-    Size_t byteOffset;	///< offset relative to base
-    ElemNumStridePairVec numStridePair;	///< element number and stride pair
+    Size_t fldIdx;	///< Accumulated Constant Offsets
+    OffsetValueVec offsetValues;	///< a vector of actual offset in the form of Values
 };
 
 } // End namespace SVF
 
 template <> struct std::hash<SVF::LocationSet> {
     size_t operator()(const SVF::LocationSet &ls) const {
-        SVF::Hash<std::pair<SVF::Size_t, SVF::Size_t>> h;
-        return h(std::make_pair(ls.getOffset(), ls.getByteOffset()));
+        SVF::Hash<std::pair<SVF::NodeID, SVF::NodeID>> h;
+        std::hash<SVF::LocationSet::OffsetValueVec> v;
+        return h(std::make_pair(ls.accumulateConstantOffset(), v(ls.getOffsetValueVec())));
     }
 };
 

package/include/MemoryModel/SVFIR.h

@@ -418,7 +418,7 @@ public:
         {
             return (fiNode->getMemObj()->hasPtrObj() == false);
         }
-        else if (GepObjPN* gepNode = SVFUtil::dyn_cast<GepObjPN>(node))
+        else if (GepObjVar* gepNode = SVFUtil::dyn_cast<GepObjVar>(node))
         {
             return (gepNode->getMemObj()->isNonPtrFieldObj(gepNode->getLocationSet()));
         }

package/include/MemoryModel/SVFStatements.h

@@ -743,7 +743,7 @@ public:
     /// offset of the gep edge
     inline u32_t getOffset() const
     {
-        return ls.getOffset();
+        return ls.accumulateConstantOffset();
     }
     inline const LocationSet& getLocationSet() const
     {

package/include/MemoryModel/SVFVariables.h

@@ -419,7 +419,7 @@ public:
     /// offset of the base value variable
     inline u32_t getOffset() const
     {
-        return ls.getOffset();
+        return ls.accumulateConstantOffset();
     }
 
     /// Return name of a LLVM value
@@ -448,7 +448,7 @@ public:
  * Gep Obj variable, this is dynamic generated for field sensitive analysis
  * Each gep obj variable is one field of a MemObj (base)
  */
-class GepObjPN: public ObjVar
+class GepObjVar: public ObjVar
 {
 private:
     LocationSet ls;
@@ -457,7 +457,7 @@ private:
 public:
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const GepObjPN *)
+    static inline bool classof(const GepObjVar *)
     {
         return true;
     }
@@ -479,7 +479,7 @@ public:
     //@}
 
     /// Constructor
-    GepObjPN(const MemObj* mem, NodeID i, const LocationSet& l, PNODEK ty = GepObjNode) :
+    GepObjVar(const MemObj* mem, NodeID i, const LocationSet& l, PNODEK ty = GepObjNode) :
         ObjVar(mem->getValue(), i, mem, ty), ls(l)
     {
         base = mem->getId();
@@ -491,6 +491,12 @@ public:
         return ls;
     }
 
+    /// offset of the mem object
+    inline u32_t getOffset() const
+    {
+        return ls.accumulateConstantOffset();
+    }
+
     /// Set the base object from which this GEP node came from.
     inline void setBaseNode(NodeID base)
     {
@@ -504,17 +510,17 @@ public:
     }
 
     /// Return the type of this gep object
-    inline virtual const llvm::Type* getType() const
+    inline virtual const Type* getType() const
     {
-        return SymbolTableInfo::SymbolInfo()->getOrigSubTypeWithByteOffset(mem->getType(), ls.getByteOffset());
+        return SymbolTableInfo::SymbolInfo()->getOriginalFieldType(mem->getType(), ls.accumulateConstantOffset());
     }
 
     /// Return name of a LLVM value
     inline const std::string getValueName() const
     {
         if (value && value->hasName())
-            return value->getName().str() + "_" + llvm::itostr(ls.getOffset());
-        return "offset_" + llvm::itostr(ls.getOffset());
+            return value->getName().str() + "_" + llvm::itostr(ls.accumulateConstantOffset());
+        return "offset_" + llvm::itostr(ls.accumulateConstantOffset());
     }
 
     virtual const std::string toString() const;
@@ -766,7 +772,7 @@ public:
 /*
  * Clone object for GEP objects.
  */
-class CloneGepObjVar : public GepObjPN
+class CloneGepObjVar : public GepObjVar
 {
 public:
     //@{ Methods to support type inquiry through isa, cast, and dyn_cast:
@@ -786,14 +792,14 @@ public:
 
     /// Constructor
     CloneGepObjVar(const MemObj* mem, NodeID i, const LocationSet& l, PNODEK ty = CloneGepObjNode) :
-        GepObjPN(mem, i, l, ty)
+        GepObjVar(mem, i, l, ty)
     {
     }
 
     /// Return name of this node
     inline const std::string getValueName() const
     {
-        return "clone (gep) of " + GepObjPN::getValueName();
+        return "clone (gep) of " + GepObjVar::getValueName();
     }
 
     virtual const std::string toString() const;

package/include/MemoryModel/SymbolTableInfo.h

@@ -364,11 +364,14 @@ public:
     }
 
     ///Get a reference to the components of struct_info.
-    const std::vector<u32_t>& getFattenFieldIdxVec(const Type *T);
-    const std::vector<u32_t>& getFattenFieldOffsetVec(const Type *T);
-    const std::vector<FieldInfo>& getFlattenFieldInfoVec(const Type *T);
-    const Type* getOrigSubTypeWithFldInx(const Type* baseType, u32_t field_idx);
-    const Type* getOrigSubTypeWithByteOffset(const Type* baseType, u32_t byteOffset);
+    const std::vector<u32_t>& getFlattenedFieldIdxVec(const Type *T);
+    const std::vector<FlattenedFieldInfo>& getFlattenedFieldInfoVec(const Type *T);
+
+    ///  struct A { int id; int salary; }; struct B { char name[20]; struct A a;}   B b;
+    ///  OriginalFieldType of b with field_idx 1 : Struct A
+    ///  FlatternedFieldType of b with field_idx 1 : int
+    const Type* getOriginalFieldType(const Type* baseType, u32_t field_idx);
+    const Type* getFlatternedFieldType(const Type* baseType, u32_t field_idx);
     //@}
 
     /// Collect type info
@@ -505,14 +508,10 @@ class StInfo
 private:
     /// flattened field indices of a struct
     std::vector<u32_t> fldIdxVec;
-    /// flattened field offsets of of a struct
-    std::vector<u32_t> foffset;
     /// Types of all fields of a struct
-    Map<u32_t, const llvm::Type*> fldIdx2TypeMap;
-    /// Types of all fields of a struct
-    Map<u32_t, const llvm::Type*> offset2TypeMap;
+    Map<u32_t, const Type*> fldIdx2TypeMap;
     /// All field infos after flattening a struct
-    std::vector<FieldInfo> finfo;
+    std::vector<FlattenedFieldInfo> finfo;
 
     /// Max field limit
     static u32_t maxFieldLimit;
@@ -537,37 +536,40 @@ public:
         return maxFieldLimit;
     }
 
-    /// Get method for fields of a struct
+    ///  struct A { int id; int salary; }; struct B { char name[20]; struct A a;}   B b;
+    ///  OriginalFieldType of b with field_idx 1 : Struct A
+    ///  FlatternedFieldType of b with field_idx 1 : int
     //{@
-    inline const llvm::Type* getFieldTypeWithFldIdx(u32_t fldIdx)
+    inline const Type* getOriginalFieldType(u32_t fldIdx)
     {
-        return fldIdx2TypeMap[fldIdx];
+        Map<u32_t, const Type*>::const_iterator it = fldIdx2TypeMap.find(fldIdx);
+        if(it!=fldIdx2TypeMap.end())
+            return it->second;
+        return nullptr;
     }
-    inline const llvm::Type* getFieldTypeWithByteOffset(u32_t offset)
+    inline const Type* getFlatternedFieldType(u32_t fldIdx)
     {
-        return offset2TypeMap[offset];
+        for(FlattenedFieldInfo& fallenedFld : finfo){
+            if(fallenedFld.getFlattenFldIdx() == fldIdx)
+                return fallenedFld.getFlattenElemTy();
+        }
+        return nullptr;
     }
-    inline std::vector<u32_t>& getFieldIdxVec()
+    inline std::vector<u32_t>& getFlattenedFieldIdxVec()
     {
         return fldIdxVec;
     }
-    inline std::vector<u32_t>& getFieldOffsetVec()
-    {
-        return foffset;
-    }
-    inline std::vector<FieldInfo>& getFlattenFieldInfoVec()
+    inline std::vector<FlattenedFieldInfo>& getFlattenedFieldInfoVec()
     {
         return finfo;
     }
     //@}
 
     /// Add field (index and offset) with its corresponding type
-    inline void addFldWithType(u32_t fldIdx, u32_t offset, const llvm::Type* type)
+    inline void addFldWithType(u32_t fldIdx, const Type* type)
     {
         fldIdxVec.push_back(fldIdx);
-        foffset.push_back(offset);
         fldIdx2TypeMap[fldIdx] = type;
-        offset2TypeMap[offset] = type;
     }
 };
 

package/include/Util/IRAnnotator.h

@@ -42,7 +42,7 @@ public:
         {
             auto nodeId = it->first;
             auto pagNode = it->second;
-            auto gepNode = SVFUtil::dyn_cast<GepObjPN>(pagNode);
+            auto gepNode = SVFUtil::dyn_cast<GepObjVar>(pagNode);
 
             if (gepNode && writeFlag)
             {
@@ -61,10 +61,10 @@ public:
 private:
     // Write the PAGgepNode to the IR such that metadata name is the SVFIR node id and the operands
     // are its base node's id and location offset
-    void writePAGgepNode(SVF::NodeID nodeId, GepObjPN* gepNode)
+    void writePAGgepNode(SVF::NodeID nodeId, GepObjVar* gepNode)
     {
         auto baseNodeId = gepNode->getBaseNode();
-        auto locationSetOffset = gepNode->getLocationSet().getOffset();
+        auto locationSetOffset = gepNode->getOffset();
 
         LLVMContext &context = mainModule->getContext();
         llvm::SmallVector<llvm::Metadata *, 32> operands;

package/lib/DDA/ContextDDA.cpp

@@ -318,7 +318,7 @@ bool ContextDDA::isHeapCondMemObj(const CxtVar& var, const StoreSVFGNode*)
     {
         if (!mem->getValue()) {
             PAGNode *pnode = _pag->getGNode(getPtrNodeID(var));
-            if(GepObjPN* gepobj = SVFUtil::dyn_cast<GepObjPN>(pnode)){
+            if(GepObjVar* gepobj = SVFUtil::dyn_cast<GepObjVar>(pnode)){
                 assert(SVFUtil::isa<DummyObjVar>(_pag->getGNode(gepobj->getBaseNode())) && "emtpy refVal in a gep object whose base is a non-dummy object");
             }
             else{

package/lib/Graphs/ConsG.cpp

@@ -681,7 +681,7 @@ struct DOTGraphTraits<ConstraintGraph*> : public DOTGraphTraits<SVFIR*>
         }
         else if (SVFUtil::isa<ObjVar>(node))
         {
-            if(SVFUtil::isa<GepObjPN>(node))
+            if(SVFUtil::isa<GepObjVar>(node))
                return "shape=doubleoctagon";
             else if(SVFUtil::isa<FIObjVar>(node))
                 return "shape=box3d";

package/lib/Graphs/IRGraph.cpp

@@ -174,7 +174,7 @@ struct DOTGraphTraits<IRGraph*> : public DefaultDOTGraphTraits
         }
         else if (SVFUtil::isa<ObjVar>(node))
         {
-            if(SVFUtil::isa<GepObjPN>(node))
+            if(SVFUtil::isa<GepObjVar>(node))
                return "shape=doubleoctagon";
             else if(SVFUtil::isa<FIObjVar>(node))
                 return "shape=box3d";

package/lib/Graphs/OfflineConsG.cpp

@@ -254,7 +254,7 @@ struct DOTGraphTraits<OfflineConsG*> : public DOTGraphTraits<SVFIR*>
             }
             else if (SVFUtil::isa<ObjVar>(node))
             {
-                if(SVFUtil::isa<GepObjPN>(node))
+                if(SVFUtil::isa<GepObjVar>(node))
                     return "shape=doubleoctagon";
                 else if(SVFUtil::isa<FIObjVar>(node))
                     return "shape=box3d";