svf-lib 1.0.1732 → 1.0.1733

package/SVF-osx/svf/include/AbstractExecution/ConsExeState.h

@@ -54,10 +54,6 @@ public:
 
     static ConsExeState globalConsES;
 
-protected:
-    VarToValMap _varToVal;
-    LocToValMap _locToVal;
-
 public:
     ConsExeState(): ExeState(ExeState::SingleValueK) {}
 
@@ -100,8 +96,7 @@ public:
 
     using ExeState::operator==;
     using ExeState::operator!=;
-    /// Exposed APIs
-    //{%
+
     bool operator==(const ConsExeState &rhs) const;
 
     bool operator!=(const ConsExeState &other) const
@@ -113,113 +108,141 @@ public:
 
     u32_t hash() const override;
 
-    /// Merge rhs into this
-    bool joinWith(const ConsExeState &rhs);
+protected:
 
-    /// Build global execution state
-    void buildGlobES(ConsExeState &globES, Set<u32_t> &vars);
+    VarToValMap _varToVal; ///< Map a variable (symbol) to its constant value
+    LocToValMap _locToVal; ///< Map a memory address to its stored constant value
 
-    /// Update symbolic states based on the summary/side-effect of callee
-    void applySummary(const ConsExeState &summary);
+public:
 
-    /// Whether state is null state (uninitialized state)
-    inline bool isNullState() const
+    /// get memory addresses of variable
+    virtual Addrs &getAddrs(u32_t id) override
     {
-        return _varToVal.size() == 1 && eq((*_varToVal.begin()).second, -1) && _locToVal.empty();
+        auto it = globalConsES._varToAddrs.find(id);
+        if (it != globalConsES._varToAddrs.end()) return it->second;
+        return _varToAddrs[id];
     }
 
-    /// Print values of all expressions
-    void printExprValues() const;
-
-    /// Print values of all expressions
-    void printExprValues(std::ostream &oss) const override;
-
-    std::string toString() const override;
-
-    std::string pcToString() const;
-
-    std::string varToString(u32_t varId) const;
-
-    std::string locToString(u32_t objId) const;
-
-    bool applySelect(u32_t res, u32_t cond, u32_t top, u32_t fop);
+    /// get constant value of variable
+    inline SingleAbsValue &operator[](u32_t varId)
+    {
+        auto it = globalConsES._varToVal.find(varId);
+        if (it != globalConsES._varToVal.end())
+            return it->second;
+        else
+            return _varToVal[varId];
+    }
 
-    bool applyPhi(u32_t res, std::vector<u32_t> &ops);
+    /// whether the variable is in varToAddrs table
+    virtual inline bool inVarToAddrsTable(u32_t id) const override
+    {
+        return _varToAddrs.find(id) != _varToAddrs.end() ||
+               globalConsES._varToAddrs.find(id) != globalConsES._varToAddrs.end();
+    }
 
-    inline bool inVarToVal(u32_t varId) const
+    /// whether the variable is in varToVal table
+    inline bool inVarToValTable(u32_t varId) const
     {
         return _varToVal.count(varId) || globalConsES._varToVal.count(varId);
     }
 
-    inline bool inLocalLocToVal(const SingleAbsValue &loc) const
+    /// whether the memory address stores memory addresses
+    virtual inline bool inLocToAddrsTable(u32_t id) const override
     {
-        assert(loc.is_numeral() && "location must be numeral");
-        s32_t virAddr = z3Expr2NumValue(loc);
-        assert(isVirtualMemAddress(virAddr) && "Pointer operand is not a physical address?");
-        u32_t objId = getInternalID(virAddr);
-        assert(getInternalID(objId) == objId && "SVFVar idx overflow > 0x7f000000?");
-        return inLocalLocToVal(objId);
+        return globalConsES._locToAddrs.find(id) != globalConsES._locToAddrs.end() || inLocalLocToAddrsTable(id);
     }
 
-    inline bool inLocalLocToVal(u32_t varId) const
+    /// whether the memory address stores constant value
+    inline bool inLocToValTable(u32_t varId) const
     {
-        return _locToVal.count(varId);
+        return inLocalLocToValTable(varId) || globalConsES._locToVal.count(varId);
     }
 
-    inline bool inLocToVal(u32_t varId) const
+    inline const VarToValMap &getVarToVal() const
     {
-        return inLocalLocToVal(varId) || globalConsES._locToVal.count(varId);
+        return _varToVal;
     }
 
-    inline bool equalVar(u32_t lhs, u32_t rhs)
+    inline const LocToValMap &getLocToVal() const
     {
-        if (!inVarToVal(lhs) || !inVarToVal(rhs)) return false;
-        return eq((*this)[lhs], (*this)[rhs]);
+        return _locToVal;
     }
-    //%}
 
-    virtual inline bool inVarToAddrsTable(u32_t id) const override
+    virtual inline bool inLocalLocToAddrsTable(u32_t id) const
     {
-        return _varToVAddrs.find(id) != _varToVAddrs.end() ||
-               globalConsES._varToVAddrs.find(id) != globalConsES._varToVAddrs.end();
+        return _locToAddrs.find(id) != _locToAddrs.end();
     }
 
-    virtual inline bool inLocToAddrsTable(u32_t id) const override
+    inline bool inLocalLocToValTable(u32_t varId) const
     {
-        return globalConsES._locToVAddrs.find(id) != globalConsES._locToVAddrs.end() || inLocalLocToAddrsTable(id);
+        return _locToVal.count(varId);
     }
 
-    virtual inline bool inLocalLocToAddrsTable(u32_t id) const
+    inline bool inLocalLocToValTable(const SingleAbsValue& addr) const
     {
-        return _locToVAddrs.find(id) != _locToVAddrs.end();
+        return _locToVal.count(getInternalID(addr.getNumeral()));
     }
 
-    virtual VAddrs &getVAddrs(u32_t id) override
+public:
+
+    /// Merge rhs into this
+    bool joinWith(const ConsExeState &rhs);
+
+    /// Build global execution state
+    void buildGlobES(ConsExeState &globES, Set<u32_t> &vars);
+
+    /// Update symbolic states based on the summary/side-effect of callee
+    void applySummary(const ConsExeState &summary);
+
+    inline bool equalVar(u32_t lhs, u32_t rhs)
     {
-        auto it = globalConsES._varToVAddrs.find(id);
-        if (it != globalConsES._varToVAddrs.end()) return it->second;
-        return _varToVAddrs[id];
+        if (!inVarToValTable(lhs) || !inVarToValTable(rhs)) return false;
+        return eq((*this)[lhs], (*this)[rhs]);
     }
 
-    virtual VAddrs &loadVAddrs(u32_t addr) override
+    /// Whether state is null state (uninitialized state)
+    inline bool isNullState() const
+    {
+        return _varToVal.size() == 1 && eq((*_varToVal.begin()).second, -1) && _locToVal.empty();
+    }
+
+    /// Print values of all expressions
+    void printExprValues() const;
+
+    /// Print values of all expressions
+    void printExprValues(std::ostream &oss) const override;
+
+    std::string toString() const override;
+
+    std::string pcToString() const;
+
+    std::string varToString(u32_t varId) const;
+
+    std::string locToString(u32_t objId) const;
+
+    bool applySelect(u32_t res, u32_t cond, u32_t top, u32_t fop);
+
+    bool applyPhi(u32_t res, std::vector<u32_t> &ops);
+
+    virtual 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 = globalConsES._locToVAddrs.find(objId);
-            if (globIt != globalConsES._locToVAddrs.end())
+            auto globIt = globalConsES._locToAddrs.find(objId);
+            if (globIt != globalConsES._locToAddrs.end())
             {
                 return globIt->second;
             }
             else
             {
-                return getVAddrs(0);
+                return getAddrs(0);
             }
         }
     }
@@ -227,15 +250,15 @@ public:
     virtual std::string varToAddrs(u32_t varId) const override
     {
         std::stringstream exprName;
-        auto it = _varToVAddrs.find(varId);
-        if (it == _varToVAddrs.end())
+        auto it = _varToAddrs.find(varId);
+        if (it == _varToAddrs.end())
         {
-            auto git = globalConsES._varToVAddrs.find(varId);
-            if (git == globalConsES._varToVAddrs.end())
+            auto git = globalConsES._varToAddrs.find(varId);
+            if (git == globalConsES._varToAddrs.end())
                 exprName << "Var not in varToAddrs!\n";
             else
             {
-                const VAddrs &vaddrs = git->second;
+                const Addrs &vaddrs = git->second;
                 if (vaddrs.size() == 1)
                 {
                     exprName << "addr: {" << std::dec << getInternalID(*vaddrs.begin()) << "}\n";
@@ -253,7 +276,7 @@ public:
         }
         else
         {
-            const VAddrs &vaddrs = it->second;
+            const Addrs &vaddrs = it->second;
             if (vaddrs.size() == 1)
             {
                 exprName << "addr: {" << std::dec << getInternalID(*vaddrs.begin()) << "}\n";
@@ -274,15 +297,15 @@ public:
     virtual std::string locToAddrs(u32_t objId) const override
     {
         std::stringstream exprName;
-        auto it = _locToVAddrs.find(objId);
-        if (it == _locToVAddrs.end())
+        auto it = _locToAddrs.find(objId);
+        if (it == _locToAddrs.end())
         {
-            auto git = globalConsES._locToVAddrs.find(objId);
-            if (git == globalConsES._locToVAddrs.end())
+            auto git = globalConsES._locToAddrs.find(objId);
+            if (git == globalConsES._locToAddrs.end())
                 exprName << "Obj not in locToVal!\n";
             else
             {
-                const VAddrs &vaddrs = git->second;
+                const Addrs &vaddrs = git->second;
                 if (vaddrs.size() == 1)
                 {
                     exprName << "addr: {" << std::dec << getInternalID(*vaddrs.begin()) << "}\n";
@@ -300,7 +323,7 @@ public:
         }
         else
         {
-            const VAddrs &vaddrs = it->second;
+            const Addrs &vaddrs = it->second;
             if (vaddrs.size() == 1)
             {
                 exprName << "addr: {" << std::dec << getInternalID(*vaddrs.begin()) << "}\n";
@@ -337,20 +360,8 @@ public:
 
 public:
 
-    inline const VarToValMap &getVarToVal() const
-    {
-        return _varToVal;
-    }
-
-    inline const LocToValMap &getLocToVal() const
-    {
-        return _locToVal;
-    }
-
     s64_t getNumber(u32_t lhs);
 
-public:
-
     static inline SingleAbsValue getIntOneZ3Expr()
     {
         return getContext().int_val(1);
@@ -372,14 +383,6 @@ public:
     }
 
 public:
-    inline SingleAbsValue &operator[](u32_t varId)
-    {
-        auto it = globalConsES._varToVal.find(varId);
-        if (it != globalConsES._varToVal.end())
-            return it->second;
-        else
-            return _varToVal[varId];
-    }
 
     /// Store value to location
     bool store(const SingleAbsValue &loc, const SingleAbsValue &value);

package/SVF-osx/svf/include/AbstractExecution/ExeState.h

@@ -48,9 +48,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
@@ -63,18 +63,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;
     }
@@ -83,24 +83,47 @@ 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;
+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
 
-    inline virtual bool operator!=(const ExeState &rhs) const
+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);
 
@@ -122,44 +145,20 @@ 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)
@@ -167,13 +166,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)
@@ -194,14 +203,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";
@@ -222,14 +231,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-osx/svf/include/AbstractExecution/IntervalExeState.h

@@ -63,17 +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) {}
@@ -85,7 +78,8 @@ 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)
@@ -150,53 +144,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
     {
@@ -209,18 +213,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);
@@ -316,24 +320,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())
@@ -348,18 +352,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];
         }
     }
 
@@ -371,6 +375,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;
@@ -441,14 +447,14 @@ 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-osx/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-osx/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);
@@ -102,29 +102,33 @@ 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
+    /// whether the variable is in varToVal table
+    inline bool inVarToValTable(u32_t id) const
     {
-        return _es.inVarToIValTable(id);
+        return _es.inVarToValTable(id);
     }
 
-    inline bool inLocToIValTable(u32_t id) const
+    /// whether the variable is in varToAddrs table
+    inline bool inVarToAddrsTable(u32_t id) const
     {
-        return _es.inLocToIValTable(id);
+        return _es.inVarToAddrsTable(id);
     }
 
-    inline bool inVarToAddrsTable(u32_t id) const
+    /// whether the memory address stores a interval value
+    inline bool inLocToValTable(u32_t id) const
     {
-        return _es.inVarToAddrsTable(id);
+        return _es.inLocToValTable(id);
     }
 
+    /// whether the memory address stores memory addresses
     inline bool inLocToAddrsTable(u32_t id) const
     {
         return _es.inLocToAddrsTable(id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.1732",
+  "version": "1.0.1733",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {