svf-tools 1.0.812 → 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,12 +66,12 @@ 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 value range of Integer SVF Type, e.g. unsigned i8 Type->[0, 255], signed i8 Type->[-128, 127]
     IntervalValue getRangeLimitFromType(const SVFType* type);
@@ -103,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/lib/AbstractExecution/ConsExeState.cpp

@@ -129,7 +129,7 @@ void ConsExeState::buildGlobES(ConsExeState &globES, Set<u32_t> &vars)
         SingleAbsValue &expr = globES[varId];
         if (expr.is_numeral() && isVirtualMemAddress(expr.get_numeral_int()))
         {
-            if (globES.inLocalLocToVal(expr))
+            if (globES.inLocalLocToValTable(expr))
             {
                 store(expr, globES.load(expr));
             }
@@ -236,13 +236,13 @@ void ConsExeState::applySummary(const ConsExeState &summary)
     {
         _locToVal[item.first] = item.second;
     }
-    for (const auto &item: summary._varToVAddrs)
+    for (const auto &item: summary._varToAddrs)
     {
-        _varToVAddrs[item.first] = item.second;
+        _varToAddrs[item.first] = item.second;
     }
-    for (const auto &item: summary._locToVAddrs)
+    for (const auto &item: summary._locToAddrs)
     {
-        _locToVAddrs[item.first] = item.second;
+        _locToAddrs[item.first] = item.second;
     }
 }
 
@@ -445,18 +445,18 @@ std::string ConsExeState::toString() const
 
 bool ConsExeState::applySelect(u32_t res, u32_t cond, u32_t top, u32_t fop)
 {
-    if (inVarToVal(top) && inVarToVal(fop) && inVarToVal(cond))
+    if (inVarToValTable(top) && inVarToValTable(fop) && inVarToValTable(cond))
     {
         SingleAbsValue &tExpr = (*this)[top], &fExpr = (*this)[fop], &condExpr = (*this)[cond];
 
         return assign((*this)[res], ite(condExpr == 1, tExpr, fExpr));
     }
-    else if (inVarToAddrsTable(top) && inVarToAddrsTable(fop) && inVarToVal(cond))
+    else if (inVarToAddrsTable(top) && inVarToAddrsTable(fop) && inVarToValTable(cond))
     {
         SingleAbsValue &condExpr = (*this)[cond];
         if (condExpr.is_numeral())
         {
-            getVAddrs(res) = condExpr.is_zero() ? getVAddrs(fop) : getVAddrs(top);
+            getAddrs(res) = condExpr.is_zero() ? getAddrs(fop) : getAddrs(top);
         }
     }
     return false;
@@ -467,10 +467,10 @@ bool ConsExeState::applyPhi(u32_t res, std::vector<u32_t> &ops)
     for (u32_t i = 0; i < ops.size(); i++)
     {
         NodeID curId = ops[i];
-        if (inVarToVal(curId))
+        if (inVarToValTable(curId))
         {
             const SingleAbsValue &cur = (*this)[curId];
-            if (!inVarToVal(res))
+            if (!inVarToValTable(res))
             {
                 (*this)[res] = cur;
             }
@@ -481,14 +481,14 @@ bool ConsExeState::applyPhi(u32_t res, std::vector<u32_t> &ops)
         }
         else if (inVarToAddrsTable(curId))
         {
-            const VAddrs &cur = getVAddrs(curId);
+            const Addrs &cur = getAddrs(curId);
             if (!inVarToAddrsTable(res))
             {
-                getVAddrs(res) = cur;
+                getAddrs(res) = cur;
             }
             else
             {
-                getVAddrs(res).join_with(cur);
+                getAddrs(res).join_with(cur);
             }
         }
     }