svf-lib 1.0.1932 → 1.0.1933

package/SVF-linux/Release-build/include/AE/Core/AbstractState.h

@@ -58,7 +58,7 @@ class AbstractState
 public:
     typedef Map<u32_t, AbstractValue> VarToAbsValMap;
 
-    typedef VarToAbsValMap LocToAbsValMap;
+    typedef VarToAbsValMap AddrToAbsValMap;
 
 public:
     /// default constructor
@@ -66,12 +66,10 @@ public:
     {
     }
 
-    AbstractState(VarToAbsValMap&_varToValMap, LocToAbsValMap&_locToValMap) : _varToAbsVal(_varToValMap),
-        _locToAbsVal(_locToValMap) {}
+    AbstractState(VarToAbsValMap&_varToValMap, AddrToAbsValMap&_locToValMap) : _varToAbsVal(_varToValMap), _addrToAbsVal(_locToValMap) {}
 
     /// copy constructor
-    AbstractState(const AbstractState&rhs) : _varToAbsVal(rhs.getVarToVal()),
-        _locToAbsVal(rhs.getLocToVal())
+    AbstractState(const AbstractState&rhs) : _varToAbsVal(rhs.getVarToVal()), _addrToAbsVal(rhs.getLocToVal())
     {
 
     }
@@ -107,14 +105,14 @@ public:
         if (rhs != *this)
         {
             _varToAbsVal = rhs._varToAbsVal;
-            _locToAbsVal = rhs._locToAbsVal;
+            _addrToAbsVal = rhs._addrToAbsVal;
         }
         return *this;
     }
 
     /// move constructor
     AbstractState(AbstractState&&rhs) : _varToAbsVal(std::move(rhs._varToAbsVal)),
-        _locToAbsVal(std::move(rhs._locToAbsVal))
+        _addrToAbsVal(std::move(rhs._addrToAbsVal))
     {
 
     }
@@ -125,7 +123,7 @@ public:
         if (&rhs != this)
         {
             _varToAbsVal = std::move(rhs._varToAbsVal);
-            _locToAbsVal = std::move(rhs._locToAbsVal);
+            _addrToAbsVal = std::move(rhs._addrToAbsVal);
         }
         return *this;
     }
@@ -167,7 +165,8 @@ public:
 
 protected:
     VarToAbsValMap _varToAbsVal; ///< Map a variable (symbol) to its abstract value
-    LocToAbsValMap _locToAbsVal; ///< Map a memory address to its stored abstract value
+    AddrToAbsValMap
+    _addrToAbsVal; ///< Map a memory address to its stored abstract value
 
 public:
 
@@ -227,9 +226,9 @@ public:
     /// whether the memory address stores memory addresses
     inline bool inLocToAddrsTable(u32_t id) const
     {
-        if (_locToAbsVal.find(id)!= _locToAbsVal.end())
+        if (_addrToAbsVal.find(id)!= _addrToAbsVal.end())
         {
-            if (_locToAbsVal.at(id).isAddr())
+            if (_addrToAbsVal.at(id).isAddr())
             {
                 return true;
             }
@@ -240,9 +239,9 @@ public:
     /// whether the memory address stores abstract value
     inline virtual bool inLocToValTable(u32_t id) const
     {
-        if (_locToAbsVal.find(id) != _locToAbsVal.end())
+        if (_addrToAbsVal.find(id) != _addrToAbsVal.end())
         {
-            if (_locToAbsVal.at(id).isInterval())
+            if (_addrToAbsVal.at(id).isInterval())
             {
                 return true;
             }
@@ -257,9 +256,9 @@ public:
     }
 
     /// get loc2val map
-    const LocToAbsValMap&getLocToVal() const
+    const AddrToAbsValMap&getLocToVal() const
     {
-        return _locToAbsVal;
+        return _addrToAbsVal;
     }
 
 public:
@@ -303,7 +302,7 @@ public:
                 }
             }
         }
-        for (auto it = _locToAbsVal.begin(); it != _locToAbsVal.end(); ++it)
+        for (auto it = _addrToAbsVal.begin(); it != _addrToAbsVal.end(); ++it)
         {
             if (it->second.isInterval())
             {
@@ -324,20 +323,20 @@ public:
         assert(isVirtualMemAddress(addr) && "not virtual address?");
         if (isNullPtr(addr)) return;
         u32_t objId = getInternalID(addr);
-        _locToAbsVal[objId] = val;
+        _addrToAbsVal[objId] = val;
     }
 
     inline virtual AbstractValue &load(u32_t addr)
     {
         assert(isVirtualMemAddress(addr) && "not virtual address?");
         u32_t objId = getInternalID(addr);
-        auto it = _locToAbsVal.find(objId);
-        if(it != _locToAbsVal.end())
+        auto it = _addrToAbsVal.find(objId);
+        if(it != _addrToAbsVal.end())
             return it->second;
         else
         {
-            _locToAbsVal[objId] = IntervalValue::top();
-            return _locToAbsVal[objId];
+            _addrToAbsVal[objId] = IntervalValue::top();
+            return _addrToAbsVal[objId];
         }
     }
 
@@ -421,7 +420,7 @@ public:
     bool operator==(const AbstractState&rhs) const
     {
         return  eqVarToValMap(_varToAbsVal, rhs.getVarToVal()) &&
-                eqVarToValMap(_locToAbsVal, rhs.getLocToVal());
+                eqVarToValMap(_addrToAbsVal, rhs.getLocToVal());
     }
 
     bool operator!=(const AbstractState&rhs) const
@@ -437,12 +436,12 @@ public:
 
     bool operator>=(const AbstractState&rhs) const
     {
-        return geqVarToValMap(_varToAbsVal, rhs.getVarToVal()) && geqVarToValMap(_locToAbsVal, rhs.getLocToVal());
+        return geqVarToValMap(_varToAbsVal, rhs.getVarToVal()) && geqVarToValMap(_addrToAbsVal, rhs.getLocToVal());
     }
 
     void clear()
     {
-        _locToAbsVal.clear();
+        _addrToAbsVal.clear();
         _varToAbsVal.clear();
     }
 

package/SVF-linux/Release-build/include/AE/Core/RelExeState.h

@@ -42,19 +42,18 @@ class RelExeState
 
 public:
     typedef Map<u32_t, Z3Expr> VarToValMap;
-    typedef VarToValMap LocToValMap;
+    typedef VarToValMap AddrToValMap;
 
 protected:
     VarToValMap _varToVal;
-    LocToValMap _locToVal;
+    AddrToValMap _addrToVal;
 
 public:
     RelExeState() = default;
 
-    RelExeState(VarToValMap &varToVal, LocToValMap &locToVal) : _varToVal(varToVal),
-        _locToVal(locToVal) {}
+    RelExeState(VarToValMap &varToVal, AddrToValMap&locToVal) : _varToVal(varToVal), _addrToVal(locToVal) {}
 
-    RelExeState(const RelExeState &rhs) : _varToVal(rhs.getVarToVal()), _locToVal(rhs.getLocToVal())
+    RelExeState(const RelExeState &rhs) : _varToVal(rhs.getVarToVal()), _addrToVal(rhs.getLocToVal())
     {
 
     }
@@ -64,7 +63,7 @@ public:
     RelExeState &operator=(const RelExeState &rhs);
 
     RelExeState(RelExeState &&rhs) noexcept: _varToVal(std::move(rhs._varToVal)),
-        _locToVal(std::move(rhs._locToVal))
+        _addrToVal(std::move(rhs._addrToVal))
     {
 
     }
@@ -74,7 +73,7 @@ public:
         if (&rhs != this)
         {
             _varToVal = std::move(rhs._varToVal);
-            _locToVal = std::move(rhs._locToVal);
+            _addrToVal = std::move(rhs._addrToVal);
         }
         return *this;
     }
@@ -102,9 +101,9 @@ public:
         return _varToVal;
     }
 
-    const LocToValMap &getLocToVal() const
+    const AddrToValMap&getLocToVal() const
     {
-        return _locToVal;
+        return _addrToVal;
     }
 
     inline Z3Expr &operator[](u32_t varId)
@@ -203,12 +202,12 @@ private:
 protected:
     inline void store(u32_t objId, const Z3Expr &z3Expr)
     {
-        _locToVal[objId] = z3Expr.simplify();
+        _addrToVal[objId] = z3Expr.simplify();
     }
 
     inline Z3Expr &load(u32_t objId)
     {
-        return _locToVal[objId];
+        return _addrToVal[objId];
     }
 }; // end class RelExeState
 } // end namespace SVF

package/SVF-linux/Release-build/include/AE/Svfexe/AbstractInterpretation.h

@@ -143,10 +143,10 @@ protected:
     /**
      * Check if execution state exist by merging states of predecessor nodes
      *
-     * @param block The ICFGNode to analyse
+     * @param curNode The ICFGNode to analyse
      * @return if this node has preceding execution state
      */
-    bool propogateAbsStateToCurNode(const ICFGNode* block);
+    bool propagateStateIfFeasible(const ICFGNode* curNode);
 
     /**
      * Check if execution state exist at the branch edge

package/package.json

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