svf-tools 1.0.327 → 1.0.331

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,19 +364,16 @@ 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);
     //@}
 
-    /// Compute gep offset
-    virtual bool computeGepOffset(const User *V, LocationSet& ls);
-    /// Get the base type and max offset
-    const Type *getBaseTypeAndFlattenedFields(const Value *V, std::vector<LocationSet> &fields);
-    /// Replace fields with flatten fields of T if the number of its fields is larger than msz.
-    u32_t getFields(std::vector<LocationSet>& fields, const Type* T, u32_t msz);
     /// Collect type info
     void collectTypeInfo(const Type* T);
     /// Given an offset from a Gep Instruction, return it modulus offset by considering memory layout
@@ -511,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;
@@ -543,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/SVF-FE/SVFIRBuilder.h

@@ -124,6 +124,12 @@ public:
     /// Compute offset of a gep instruction or gep constant expression
     bool computeGepOffset(const User *V, LocationSet& ls);
 
+    /// Get the base type and max offset
+    const Type *getBaseTypeAndFlattenedFields(const Value *V, std::vector<LocationSet> &fields);
+
+    /// Replace fields with flatten fields of T if the number of its fields is larger than msz.
+    u32_t getFields(std::vector<LocationSet>& fields, const Type* T, u32_t msz);
+
     /// Handle direct call
     void handleDirectCall(CallSite cs, const SVFFunction *F);
 
@@ -133,7 +139,6 @@ public:
     /// Handle external call
     //@{
     virtual void handleExtCall(CallSite cs, const SVFFunction *F);
-    const Type *getBaseTypeAndFlattenedFields(Value* v, std::vector<LocationSet> &fields);
     void addComplexConsForExt(Value *D, Value *S,u32_t sz = 0);
     //@}
 

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";

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";
     }