svf-tools 1.0.811 → 1.0.813

package/svf/include/AbstractExecution/ExeState.h

@@ -49,9 +49,9 @@ class ExeState
 
 public:
 
-    typedef AddressValue VAddrs;
-    typedef Map<u32_t, VAddrs> VarToVAddrs;
-    /// Execution state kind
+    typedef AddressValue Addrs;
+    typedef Map<u32_t, Addrs> VarToAddrs;
+    /// Execution state type
     enum ExeState_TYPE
     {
         IntervalK, SingleValueK
@@ -64,18 +64,18 @@ public:
 
     virtual ~ExeState() = default;
 
-    ExeState(const ExeState &rhs) : _varToVAddrs(rhs._varToVAddrs),
-        _locToVAddrs(rhs._locToVAddrs) {}
+    ExeState(const ExeState &rhs) : _varToAddrs(rhs._varToAddrs),
+        _locToAddrs(rhs._locToAddrs) {}
 
-    ExeState(ExeState &&rhs) noexcept: _varToVAddrs(std::move(rhs._varToVAddrs)),
-        _locToVAddrs(std::move(rhs._locToVAddrs)) {}
+    ExeState(ExeState &&rhs) noexcept: _varToAddrs(std::move(rhs._varToAddrs)),
+        _locToAddrs(std::move(rhs._locToAddrs)) {}
 
     ExeState &operator=(const ExeState &rhs)
     {
         if(*this != rhs)
         {
-            _varToVAddrs = rhs._varToVAddrs;
-            _locToVAddrs = rhs._locToVAddrs;
+            _varToAddrs = rhs._varToAddrs;
+            _locToAddrs = rhs._locToAddrs;
         }
         return *this;
     }
@@ -84,24 +84,49 @@ public:
     {
         if (this != &rhs)
         {
-            _varToVAddrs = std::move(rhs._varToVAddrs);
-            _locToVAddrs = std::move(rhs._locToVAddrs);
+            _varToAddrs = std::move(rhs._varToAddrs);
+            _locToAddrs = std::move(rhs._locToAddrs);
         }
         return *this;
     }
 
-    virtual bool operator==(const ExeState &rhs) const;
 
-    inline virtual bool operator!=(const ExeState &rhs) const
+protected:
+    VarToAddrs _varToAddrs{{0, getVirtualMemAddress(0)}}; ///< Map a variable (symbol) to its memory addresses
+    VarToAddrs _locToAddrs;                               ///< Map a memory address to its stored memory addresses
+
+public:
+
+    /// get memory addresses of variable
+    virtual Addrs &getAddrs(u32_t id)
     {
-        return !(*this == rhs);
+        return _varToAddrs[id];
     }
 
-    bool equals(const ExeState *other) const
+    /// whether the variable is in varToAddrs table
+    inline virtual bool inVarToAddrsTable(u32_t id) const
     {
-        return false;
+        return _varToAddrs.find(id) != _varToAddrs.end();
+    }
+
+    /// whether the memory address stores memory addresses
+    inline virtual bool inLocToAddrsTable(u32_t id) const
+    {
+        return _locToAddrs.find(id) != _locToAddrs.end();
     }
 
+
+    inline virtual const VarToAddrs &getVarToAddrs() const
+    {
+        return _varToAddrs;
+    }
+
+    inline virtual const VarToAddrs &getLocToAddrs() const
+    {
+        return _locToAddrs;
+    }
+
+public:
     /// Make all value join with the other
     bool joinWith(const ExeState &other);
 
@@ -123,44 +148,22 @@ public:
         return _kind;
     }
 
-    inline virtual const VarToVAddrs &getVarToVAddrs() const
-    {
-        return _varToVAddrs;
-    }
-
-    inline virtual const VarToVAddrs &getLocToVAddrs() const
-    {
-        return _locToVAddrs;
-    }
-
-    inline virtual bool inVarToAddrsTable(u32_t id) const
-    {
-        return _varToVAddrs.find(id) != _varToVAddrs.end();
-    }
 
-    inline virtual bool inLocToAddrsTable(u32_t id) const
-    {
-        return _locToVAddrs.find(id) != _locToVAddrs.end();
-    }
-
-    virtual VAddrs &getVAddrs(u32_t id)
-    {
-        return _varToVAddrs[id];
-    }
 
-    inline virtual void storeVAddrs(u32_t addr, const VAddrs &vaddrs)
+public:
+    inline virtual void storeAddrs(u32_t addr, const Addrs &vaddrs)
     {
         assert(isVirtualMemAddress(addr) && "not virtual address?");
         if(isNullPtr(addr)) return;
         u32_t objId = getInternalID(addr);
-        _locToVAddrs[objId] = vaddrs;
+        _locToAddrs[objId] = vaddrs;
     }
 
-    inline virtual VAddrs &loadVAddrs(u32_t addr)
+    inline virtual Addrs &loadAddrs(u32_t addr)
     {
         assert(isVirtualMemAddress(addr) && "not virtual address?");
         u32_t objId = getInternalID(addr);
-        return _locToVAddrs[objId];
+        return _locToAddrs[objId];
     }
 
     inline bool isNullPtr(u32_t addr)
@@ -168,13 +171,23 @@ public:
         return getInternalID(addr) == 0;
     }
 
-protected:
-    VarToVAddrs _varToVAddrs{{0, getVirtualMemAddress(0)}};
-    VarToVAddrs _locToVAddrs;
+public:
+
+    virtual bool operator==(const ExeState &rhs) const;
+
+    inline virtual bool operator!=(const ExeState &rhs) const
+    {
+        return !(*this == rhs);
+    }
+
+    bool equals(const ExeState *other) const
+    {
+        return false;
+    }
 
 protected:
 
-    static bool eqVarToVAddrs(const VarToVAddrs &lhs, const VarToVAddrs &rhs)
+    static bool eqVarToAddrs(const VarToAddrs &lhs, const VarToAddrs &rhs)
     {
         if (lhs.size() != rhs.size()) return false;
         for (const auto &item: lhs)
@@ -195,14 +208,14 @@ public:
     virtual std::string varToAddrs(u32_t varId) const
     {
         std::stringstream exprName;
-        auto it = _varToVAddrs.find(varId);
-        if (it == _varToVAddrs.end())
+        auto it = _varToAddrs.find(varId);
+        if (it == _varToAddrs.end())
         {
             exprName << "Var not in varToAddrs!\n";
         }
         else
         {
-            const VAddrs &vaddrs = it->second;
+            const Addrs &vaddrs = it->second;
             if (vaddrs.size() == 1)
             {
                 exprName << "addr: {" << std::dec << getInternalID(*vaddrs.begin()) << "}\n";
@@ -223,14 +236,14 @@ public:
     virtual std::string locToAddrs(u32_t objId) const
     {
         std::stringstream exprName;
-        auto it = _locToVAddrs.find(objId);
-        if (it == _locToVAddrs.end())
+        auto it = _locToAddrs.find(objId);
+        if (it == _locToAddrs.end())
         {
             exprName << "Var not in varToAddrs!\n";
         }
         else
         {
-            const VAddrs &vaddrs = it->second;
+            const Addrs &vaddrs = it->second;
             if (vaddrs.size() == 1)
             {
                 exprName << "addr: {" << std::dec << getInternalID(*vaddrs.begin()) << "}\n";

package/svf/include/AbstractExecution/IntervalExeState.h

@@ -63,18 +63,10 @@ public:
 
     static IntervalExeState globalES;
 
-protected:
-    /// key: nodeID value: Domain Value
-    VarToValMap _varToItvVal;
-    /// key: nodeID value: Domain Value
-    LocToValMap _locToItvVal;
-
-
 public:
-    /// default constructor, default pc is true
+    /// default constructor
     IntervalExeState() : ExeState(ExeState::IntervalK) {}
 
-    /// set path constraints, val2val and loc2val map
     IntervalExeState(VarToValMap &_varToValMap, LocToValMap &_locToValMap) : ExeState(ExeState::IntervalK),
         _varToItvVal(_varToValMap),
         _locToItvVal(_locToValMap) {}
@@ -86,7 +78,9 @@ public:
 
     }
 
-    /// check two interval exe state are equal or not. _varToItvVal and _locToItvVal map should be equivalent
+    virtual ~IntervalExeState() = default;
+
+
     IntervalExeState &operator=(const IntervalExeState &rhs)
     {
         if (rhs != *this)
@@ -151,54 +145,63 @@ public:
         return inv;
     }
 
-    VAddrs &getVAddrs(u32_t id) override
+protected:
+
+    VarToValMap _varToItvVal; ///< Map a variable (symbol) to its interval value
+    LocToValMap _locToItvVal; ///< Map a memory address to its stored interval value
+
+public:
+
+    /// get memory addresses of variable
+    Addrs &getAddrs(u32_t id) override
     {
-        auto it = _varToVAddrs.find(id);
-        if (it != _varToVAddrs.end())
+        auto it = _varToAddrs.find(id);
+        if (it != _varToAddrs.end())
             return it->second;
         else
-            return globalES._varToVAddrs[id];
+            return globalES._varToAddrs[id];
     }
 
-    inline bool inVarToIValTable(u32_t id) const
+    /// get interval value of variable
+    inline IntervalValue &operator[](u32_t varId)
     {
-        return _varToItvVal.find(id) != _varToItvVal.end() ||
-               globalES._varToItvVal.find(id) != globalES._varToItvVal.end();
+        auto localIt = _varToItvVal.find(varId);
+        if(localIt != _varToItvVal.end())
+            return localIt->second;
+        else
+        {
+            return globalES._varToItvVal[varId];
+        }
     }
 
+    /// whether the variable is in varToAddrs table
     inline bool inVarToAddrsTable(u32_t id) const override
     {
-        return _varToVAddrs.find(id) != _varToVAddrs.end() ||
-               globalES._varToVAddrs.find(id) != globalES._varToVAddrs.end();
+        return _varToAddrs.find(id) != _varToAddrs.end() ||
+               globalES._varToAddrs.find(id) != globalES._varToAddrs.end();
     }
 
-    inline bool inLocToIValTable(u32_t id) const
+    /// whether the variable is in varToVal table
+    inline bool inVarToValTable(u32_t id) const
     {
-        return _locToItvVal.find(id) != _locToItvVal.end() ||
-               globalES._locToItvVal.find(id) != globalES._locToItvVal.end();
-    }
-
-    inline bool inLocalLocToIValTable(u32_t id) const
-    {
-        return _locToItvVal.find(id) != _locToItvVal.end();
+        return _varToItvVal.find(id) != _varToItvVal.end() ||
+               globalES._varToItvVal.find(id) != globalES._varToItvVal.end();
     }
 
+    /// whether the memory address stores memory addresses
     inline bool inLocToAddrsTable(u32_t id) const override
     {
-        return _locToVAddrs.find(id) != _locToVAddrs.end() ||
-               globalES._locToVAddrs.find(id) != globalES._locToVAddrs.end();
+        return _locToAddrs.find(id) != _locToAddrs.end() ||
+               globalES._locToAddrs.find(id) != globalES._locToAddrs.end();
     }
 
-    inline bool inLocalLocToAddrsTable(u32_t id) const
+    /// whether the memory address stores interval value
+    inline bool inLocToValTable(u32_t id) const
     {
-        return _locToVAddrs.find(id) != _locToVAddrs.end();
+        return _locToItvVal.find(id) != _locToItvVal.end() ||
+               globalES._locToItvVal.find(id) != globalES._locToItvVal.end();
     }
 
-    bool equals(const IntervalExeState &other) const;
-
-    virtual ~IntervalExeState() = default;
-
-
     /// get var2val map
     const VarToValMap &getVarToVal() const
     {
@@ -211,18 +214,18 @@ public:
         return _locToItvVal;
     }
 
-    ///  [], call getValueExpr()
-    inline IntervalValue &operator[](u32_t varId)
+    inline bool inLocalLocToValTable(u32_t id) const
     {
-        auto localIt = _varToItvVal.find(varId);
-        if(localIt != _varToItvVal.end())
-            return localIt->second;
-        else
-        {
-            return globalES._varToItvVal[varId];
-        }
+        return _locToItvVal.find(id) != _locToItvVal.end();
     }
 
+    inline bool inLocalLocToAddrsTable(u32_t id) const
+    {
+        return _locToAddrs.find(id) != _locToAddrs.end();
+    }
+
+public:
+
     inline void cpyItvToLocal(u32_t varId)
     {
         auto localIt = _varToItvVal.find(varId);
@@ -319,24 +322,24 @@ public:
         }
     }
 
-    inline VAddrs &loadVAddrs(u32_t addr) override
+    inline Addrs &loadAddrs(u32_t addr) override
     {
         assert(isVirtualMemAddress(addr) && "not virtual address?");
         u32_t objId = getInternalID(addr);
-        auto it = _locToVAddrs.find(objId);
-        if(it != _locToVAddrs.end())
+        auto it = _locToAddrs.find(objId);
+        if(it != _locToAddrs.end())
             return it->second;
         else
         {
-            auto globIt = globalES._locToVAddrs.find(objId);
-            if(globIt != globalES._locToVAddrs.end())
+            auto globIt = globalES._locToAddrs.find(objId);
+            if(globIt != globalES._locToAddrs.end())
                 return globIt->second;
             else
-                return _locToVAddrs[objId];
+                return _locToAddrs[objId];
         }
     }
 
-    inline IntervalValue& getLocToItv(u32_t id)
+    inline IntervalValue& getLocToVal(u32_t id)
     {
         auto it = _locToItvVal.find(id);
         if(it != _locToItvVal.end())
@@ -351,18 +354,18 @@ public:
         }
     }
 
-    inline VAddrs& getLocVAddrs(u32_t id)
+    inline Addrs& getLocAddrs(u32_t id)
     {
-        auto it = _locToVAddrs.find(id);
-        if(it != _locToVAddrs.end())
+        auto it = _locToAddrs.find(id);
+        if(it != _locToAddrs.end())
             return it->second;
         else
         {
-            auto globIt = globalES._locToVAddrs.find(id);
-            if(globIt != globalES._locToVAddrs.end())
+            auto globIt = globalES._locToAddrs.find(id);
+            if(globIt != globalES._locToAddrs.end())
                 return globIt->second;
             else
-                return _locToVAddrs[id];
+                return _locToAddrs[id];
         }
     }
 
@@ -374,6 +377,8 @@ public:
         return "";
     }
 
+    bool equals(const IntervalExeState &other) const;
+
     static bool eqVarToValMap(const VarToValMap &lhs, const VarToValMap &rhs)
     {
         if (lhs.size() != rhs.size()) return false;
@@ -446,15 +451,15 @@ public:
     {
         _locToItvVal.clear();
         _varToItvVal.clear();
-        _locToVAddrs.clear();
-        _varToVAddrs.clear();
+        _locToAddrs.clear();
+        _varToAddrs.clear();
     }
 
 
 private:
     void printTable(const VarToValMap &table, std::ostream &oss) const;
 
-    void printTable(const VarToVAddrs &table, std::ostream &oss) const;
+    void printTable(const VarToAddrs &table, std::ostream &oss) const;
 };
 }
 

package/svf/include/AbstractExecution/SVFIR2ConsExeState.h

@@ -35,7 +35,7 @@ namespace SVF
 class SVFIR2ConsExeState
 {
 public:
-    typedef ExeState::VAddrs VAddrs;
+    typedef ExeState::Addrs Addrs;
 
     SVFIR2ConsExeState() = default;
 
@@ -89,7 +89,7 @@ public:
     //%}
 
     /// Return the expr of gep object given a base and offset
-    VAddrs getGepObjAddress(u32_t base, s32_t offset);
+    Addrs getGepObjAddress(u32_t base, s32_t offset);
 
     /// Return the offset expression of a GepStmt
     std::pair<s32_t, s32_t> getGepOffset(const GepStmt *gep);
@@ -123,17 +123,17 @@ public:
 
     inline bool inVarToValTable(u32_t id) const
     {
-        return _es->inVarToVal(id);
+        return _es->inVarToValTable(id);
     }
 
-    inline bool inLocToValTable(u32_t id) const
+    inline bool inVarToAddrsTable(u32_t id) const
     {
-        return _es->inLocToVal(id);
+        return _es->inVarToAddrsTable(id);
     }
 
-    inline bool inVarToAddrsTable(u32_t id) const
+    inline bool inLocToValTable(u32_t id) const
     {
-        return _es->inVarToAddrsTable(id);
+        return _es->inLocToValTable(id);
     }
 
     inline bool inLocToAddrsTable(u32_t id) const

package/svf/include/AbstractExecution/SVFIR2ItvExeState.h

@@ -41,8 +41,8 @@ namespace SVF
 class SVFIR2ItvExeState
 {
 public:
-    typedef ExeState::VAddrs VAddrs;
-    static VAddrs globalNullVaddrs;
+    typedef ExeState::Addrs Addrs;
+    static Addrs globalNulladdrs;
 public:
     SVFIR2ItvExeState(SVFIR *ir) : _svfir(ir) {}
 
@@ -66,18 +66,15 @@ public:
         return _relEs;
     }
 
-    void widenVAddrs(IntervalExeState &lhs, const IntervalExeState &rhs);
+    void widenAddrs(IntervalExeState &lhs, const IntervalExeState &rhs);
 
-    void narrowVAddrs(IntervalExeState &lhs, const IntervalExeState &rhs);
+    void narrowAddrs(IntervalExeState &lhs, const IntervalExeState &rhs);
 
     /// Return the field address given a pointer points to a struct object and an offset
-    VAddrs getGepObjAddress(u32_t pointer, APOffset offset);
+    Addrs getGepObjAddress(u32_t pointer, APOffset offset);
 
-    /// Return the byte offset from one gep param offset
-    IntervalValue getByteOffsetfromGepTypePair(const AccessPath::IdxVarAndGepTypePair& gep_pair, const GepStmt *gep);
-
-    /// Return the Index offset from one gep param offset
-    IntervalValue getItvOfFlattenedElemIndexFromGepTypePair(const AccessPath::IdxVarAndGepTypePair& gep_pair, const GepStmt *gep);
+    /// Return the value range of Integer SVF Type, e.g. unsigned i8 Type->[0, 255], signed i8 Type->[-128, 127]
+    IntervalValue getRangeLimitFromType(const SVFType* type);
 
     /// Return the byte offset expression of a GepStmt
     /// elemBytesize is the element byte size of an static alloc or heap alloc array
@@ -106,29 +103,35 @@ public:
     /// Init SVFVar
     void initSVFVar(u32_t varId);
 
-    inline VAddrs &getVAddrs(u32_t id)
+    inline Addrs &getAddrs(u32_t id)
     {
         if (inVarToAddrsTable(id))
-            return _es.getVAddrs(id);
+            return _es.getAddrs(id);
         else
-            return globalNullVaddrs;
+            return globalNulladdrs;
     }
 
-    inline bool inVarToIValTable(u32_t id) const
-    {
-        return _es.inVarToIValTable(id);
-    }
 
-    inline bool inLocToIValTable(u32_t id) const
+    /// whether the variable is in varToVal table
+    inline bool inVarToValTable(u32_t id) const
     {
-        return _es.inLocToIValTable(id);
+        return _es.inVarToValTable(id);
     }
 
+    /// whether the variable is in varToAddrs table
     inline bool inVarToAddrsTable(u32_t id) const
     {
         return _es.inVarToAddrsTable(id);
     }
 
+
+    /// whether the memory address stores a interval value
+    inline bool inLocToValTable(u32_t id) const
+    {
+        return _es.inLocToValTable(id);
+    }
+
+    /// whether the memory address stores memory addresses
     inline bool inLocToAddrsTable(u32_t id) const
     {
         return _es.inLocToAddrsTable(id);

package/svf/include/MemoryModel/AccessPath.h

@@ -61,8 +61,8 @@ public:
         NonOverlap, Overlap, Subset, Superset, Same
     };
 
-    typedef std::pair<const SVFVar*, const SVFType*> IdxVarAndGepTypePair;
-    typedef std::vector<IdxVarAndGepTypePair> IdxVarAndGepTypePairs;
+    typedef std::pair<const SVFVar*, const SVFType*> IdxOperandPair;
+    typedef std::vector<IdxOperandPair> IdxOperandPairs;
 
     /// Constructor
     AccessPath(APOffset o = 0) : fldIdx(o) {}
@@ -70,7 +70,7 @@ public:
     /// Copy Constructor
     AccessPath(const AccessPath& ap)
         : fldIdx(ap.fldIdx),
-          offsetVarAndGepTypePairs(ap.getOffsetVarAndGepTypePairVec())
+          idxOperandPairs(ap.getIdxOperandPairVec())
     {
     }
 
@@ -83,13 +83,13 @@ public:
     inline const AccessPath& operator=(const AccessPath& rhs)
     {
         fldIdx = rhs.fldIdx;
-        offsetVarAndGepTypePairs = rhs.getOffsetVarAndGepTypePairVec();
+        idxOperandPairs = rhs.getIdxOperandPairVec();
         return *this;
     }
     inline bool operator==(const AccessPath& rhs) const
     {
         return this->fldIdx == rhs.fldIdx &&
-               this->offsetVarAndGepTypePairs == rhs.offsetVarAndGepTypePairs;
+               this->idxOperandPairs == rhs.idxOperandPairs;
     }
     //@}
 
@@ -103,9 +103,9 @@ public:
     {
         fldIdx = idx;
     }
-    inline const IdxVarAndGepTypePairs& getOffsetVarAndGepTypePairVec() const
+    inline const IdxOperandPairs& getIdxOperandPairVec() const
     {
-        return offsetVarAndGepTypePairs;
+        return idxOperandPairs;
     }
     //@}
 
@@ -151,6 +151,9 @@ public:
         return computeAllLocations().intersects(RHS.computeAllLocations());
     }
 
+    /// Return byte offset from the beginning of the structure to the field where it is located for struct type
+    u32_t getStructFieldOffset(const SVFVar* idxOperandVar, const SVFStructType* idxOperandType) const;
+
     /// Dump location set
     std::string dump() const;
 
@@ -163,8 +166,7 @@ private:
     NodeBS computeAllLocations() const;
 
     APOffset fldIdx;	///< Accumulated Constant Offsets
-    IdxVarAndGepTypePairs
-    offsetVarAndGepTypePairs;	///< a vector of actual offset in the form of <SVF Var, iterator type>s
+    IdxOperandPairs idxOperandPairs;	///< a vector of actual offset in the form of <SVF Var, iterator type>
 };
 
 } // End namespace SVF
@@ -174,9 +176,9 @@ template <> struct std::hash<SVF::AccessPath>
     size_t operator()(const SVF::AccessPath &ap) const
     {
         SVF::Hash<std::pair<SVF::NodeID, SVF::NodeID>> h;
-        std::hash<SVF::AccessPath::IdxVarAndGepTypePairs> v;
+        std::hash<SVF::AccessPath::IdxOperandPairs> v;
         return h(std::make_pair(ap.getConstantFieldIdx(),
-                                v(ap.getOffsetVarAndGepTypePairVec())));
+                                v(ap.getIdxOperandPairVec())));
     }
 };
 

package/svf/include/SVFIR/SVFStatements.h

@@ -492,10 +492,9 @@ public:
     {
         return ap;
     }
-    inline const AccessPath::IdxVarAndGepTypePairs
-    getOffsetVarAndGepTypePairVec() const
+    inline const AccessPath::IdxOperandPairs getOffsetVarAndGepTypePairVec() const
     {
-        return getAccessPath().getOffsetVarAndGepTypePairVec();
+        return getAccessPath().getIdxOperandPairVec();
     }
     /// Return TRUE if this is a constant location set.
     inline bool isConstantOffset() const