svf-lib 1.0.2506 → 1.0.2508

package/SVF-linux-aarch64/include/AE/Core/AbstractState.h

@@ -300,6 +300,8 @@ public:
 
     void printAbstractState() const;
 
+    std::string toString() const;
+
     u32_t hash() const;
 
     // lhs == rhs for varToValMap

package/SVF-linux-aarch64/include/AE/Svfexe/AbstractInterpretation.h

@@ -109,11 +109,11 @@ public:
         detectors.push_back(std::move(detector));
     }
 
-    /// Retrieve the abstract state from the trace for a given ICFG node; asserts if no trace exists
-    AbstractState& getAbstractState(const ICFGNode* node);
-
-    /// Check if an abstract state exists in the trace for a given ICFG node
-    bool hasAbstractState(const ICFGNode* node);
+    /// Retrieve SVFVar given its ID; asserts if no such variable exists
+    inline const SVFVar* getSVFVar(NodeID varId) const
+    {
+        return svfir->getSVFVar(varId);
+    }
 
     /// Retrieve abstract value for a top-level variable at a given ICFG node
     const AbstractValue& getAbstractValue(const ICFGNode* node, const ValVar* var);
@@ -124,6 +124,24 @@ public:
     /// Retrieve abstract value for any SVF variable at a given ICFG node
     const AbstractValue& getAbstractValue(const ICFGNode* node, const SVFVar* var);
 
+    /// Set abstract value for a top-level variable at a given ICFG node
+    void updateAbstractValue(const ICFGNode* node, const ValVar* var, const AbstractValue& val);
+
+    /// Set abstract value for an address-taken variable at a given ICFG node
+    void updateAbstractValue(const ICFGNode* node, const ObjVar* var, const AbstractValue& val);
+
+    /// Set abstract value for any SVF variable at a given ICFG node
+    void updateAbstractValue(const ICFGNode* node, const SVFVar* var, const AbstractValue& val);
+
+    /// Propagate an ObjVar's abstract value from defSite to all its use-site ICFGNodes via SVFG
+    void propagateObjVarAbsVal(const ObjVar* var, const ICFGNode* defSite);
+
+    /// Retrieve the abstract state from the trace for a given ICFG node; asserts if no trace exists
+    AbstractState& getAbstractState(const ICFGNode* node);
+
+    /// Check if an abstract state exists in the trace for a given ICFG node
+    bool hasAbstractState(const ICFGNode* node);
+
     /// Retrieve abstract state filtered to specific top-level variables
     void getAbstractState(const ICFGNode* node, const Set<const ValVar*>& vars, AbstractState& result);
 

package/SVF-linux-aarch64/include/AE/Svfexe/PreAnalysis.h

@@ -65,6 +65,12 @@ public:
     {
         return callGraphSCC;
     }
+    SVFG* getSVFG() const
+    {
+        return svfg;
+    }
+    /// Given an ObjVar and its def-site ICFGNode, find all use-site ICFGNodes
+    const Set<const ICFGNode*> getUseSitesOfObjVar(const ObjVar* obj, const ICFGNode* node) const;
 
     /// Build WTO for each function using call graph SCC
     void initWTO();
@@ -78,6 +84,7 @@ public:
 private:
     SVFIR* svfir;
     ICFG* icfg;
+    SVFG* svfg;
     AndersenWaveDiff* pta;
     CallGraph* callGraph;
     CallGraphSCC* callGraphSCC;

package/SVF-linux-aarch64/include/Graphs/SVFG.h

@@ -181,19 +181,19 @@ public:
 
     /// Given a ValVar and its SVFGNode, find the definition-site ICFGNode
     /// by following incoming direct VFGEdges (asserts unique definition)
-    const ICFGNode* getDefSiteOfValVar(const ValVar* var, const SVFGNode* node) const;
+    const ICFGNode* getDefSiteOfValVar(const ValVar* var) const;
 
-    /// Given an ObjVar and its SVFGNode, find the definition-site ICFGNode
+    /// Given an ObjVar and its use-site ICFGNode, find the definition-site ICFGNode
     /// by following incoming IndirectSVFGEdges whose pts contains the ObjVar (asserts unique definition)
-    const ICFGNode* getDefSiteOfObjVar(const ObjVar* obj, const SVFGNode* node) const;
+    const ICFGNode* getDefSiteOfObjVar(const ObjVar* obj, const ICFGNode* node) const;
 
-    /// Given a ValVar and its SVFStmt, find all use-site ICFGNodes
-    /// by following outgoing direct VFGEdges from its definition SVFGNode
-    const Set<const ICFGNode*> getUseSitesOfValVar(const ValVar* var, const SVFGNode* vNode) const;
+    /// Given a ValVar, find all use-site ICFGNodes
+    /// by following outgoing direct VFGEdges from its unique definition SVFGNode
+    const Set<const ICFGNode*> getUseSitesOfValVar(const ValVar* var) const;
 
-    /// Given an ObjVar and its SVFStmt, find all use-site ICFGNodes
+    /// Given an ObjVar and its def-site ICFGNode, find all use-site ICFGNodes
     /// by following outgoing IndirectSVFGEdges whose pts contains the ObjVar
-    const Set<const ICFGNode*> getUseSitesOfObjVar(const ObjVar* obj, const SVFGNode* vNode) const;
+    const Set<const ICFGNode*> getUseSitesOfObjVar(const ObjVar* obj, const ICFGNode* node) const;
 
     /// Perform statistics
     void performStat();

package/SVF-linux-aarch64/include/Util/Options.h

@@ -240,6 +240,7 @@ public:
     static const Option<u32_t> LoopBound;
 
     // Abstract Execution
+    static const Option<bool> SparseAE;
     static const Option<u32_t> WidenDelay;
     /// recursion handling mode, Default: TOP
     static const OptionMap<u32_t> HandleRecur;

package/SVF-osx/include/AE/Core/AbstractState.h

@@ -49,9 +49,6 @@
 #include "AE/Core/AbstractValue.h"
 #include "AE/Core/IntervalValue.h"
 #include "SVFIR/SVFVariables.h"
-#include "Util/Z3Expr.h"
-
-#include <iomanip>
 
 namespace SVF
 {
@@ -62,10 +59,6 @@ class AbstractState
 public:
     typedef Map<u32_t, AbstractValue> VarToAbsValMap;
     typedef VarToAbsValMap AddrToAbsValMap;
-    Set<NodeID> _freedAddrs;
-
-
-public:
     /// default constructor
     AbstractState()
     {
@@ -74,7 +67,7 @@ public:
     AbstractState(VarToAbsValMap&_varToValMap, AddrToAbsValMap&_locToValMap) : _varToAbsVal(_varToValMap), _addrToAbsVal(_locToValMap) {}
 
     /// copy constructor
-    AbstractState(const AbstractState&rhs) : _freedAddrs(rhs._freedAddrs), _varToAbsVal(rhs.getVarToVal()), _addrToAbsVal(rhs.getLocToVal())
+    AbstractState(const AbstractState&rhs) : _varToAbsVal(rhs.getVarToVal()), _addrToAbsVal(rhs.getLocToVal()), _freedAddrs(rhs._freedAddrs)
     {
 
     }
@@ -112,41 +105,19 @@ public:
     }
 
     /// Return the internal index if addr is an address otherwise return the value of idx
-    inline u32_t getIDFromAddr(u32_t addr)
+    inline u32_t getIDFromAddr(u32_t addr) const
     {
         return _freedAddrs.count(addr) ?  AddressValue::getInternalID(BlackHoleObjAddr) : AddressValue::getInternalID(addr);
     }
 
-    AbstractState&operator=(const AbstractState&rhs)
-    {
-        if (rhs != *this)
-        {
-            _varToAbsVal = rhs._varToAbsVal;
-            _addrToAbsVal = rhs._addrToAbsVal;
-            _freedAddrs = rhs._freedAddrs;
-        }
-        return *this;
-    }
-
     /// move constructor
     AbstractState(AbstractState&&rhs) : _varToAbsVal(std::move(rhs._varToAbsVal)),
-        _addrToAbsVal(std::move(rhs._addrToAbsVal))
+        _addrToAbsVal(std::move(rhs._addrToAbsVal)),
+        _freedAddrs(std::move(rhs._freedAddrs))
     {
 
     }
 
-    /// operator= move constructor
-    AbstractState&operator=(AbstractState&&rhs)
-    {
-        if (&rhs != this)
-        {
-            _varToAbsVal = std::move(rhs._varToAbsVal);
-            _addrToAbsVal = std::move(rhs._addrToAbsVal);
-            _freedAddrs = std::move(rhs._freedAddrs);
-        }
-        return *this;
-    }
-
     /// Set all value bottom
     AbstractState bottom() const
     {
@@ -176,9 +147,7 @@ public:
     {
         AbstractState inv;
         for (u32_t id: sl)
-        {
             inv._varToAbsVal[id] = _varToAbsVal[id];
-        }
         return inv;
     }
 
@@ -196,6 +165,7 @@ public:
 protected:
     VarToAbsValMap _varToAbsVal; ///< Map a variable (symbol) to its abstract value
     AddrToAbsValMap _addrToAbsVal; ///< Map a memory address to its stored abstract value
+    Set<NodeID> _freedAddrs;
 
 public:
 
@@ -203,24 +173,46 @@ public:
     /// get abstract value of variable
     inline virtual AbstractValue &operator[](u32_t varId)
     {
+        assert(!isVirtualMemAddress(varId) && "varId is a virtual memory address, use load() instead");
         return _varToAbsVal[varId];
     }
 
     /// get abstract value of variable
     inline virtual const AbstractValue &operator[](u32_t varId) const
     {
+        assert(!isVirtualMemAddress(varId) && "varId is a virtual memory address, use load() instead");
         return _varToAbsVal.at(varId);
     }
 
+    inline virtual AbstractValue &load(u32_t addr)
+    {
+        assert(isVirtualMemAddress(addr) && "not virtual address?");
+        u32_t objId = getIDFromAddr(addr);
+        return _addrToAbsVal[objId];
+    }
+
+    inline virtual const AbstractValue &load(u32_t addr) const
+    {
+        assert(isVirtualMemAddress(addr) && "not virtual address?");
+        u32_t objId = getIDFromAddr(addr);
+        return _addrToAbsVal.at(objId);
+    }
+
+    inline void store(u32_t addr, const AbstractValue &val)
+    {
+        assert(isVirtualMemAddress(addr) && "not virtual address?");
+        u32_t objId = getIDFromAddr(addr);
+        if (isNullMem(addr)) return;
+        _addrToAbsVal[objId] = val;
+    }
+
     /// whether the variable is in varToAddrs table
     inline bool inVarToAddrsTable(u32_t id) const
     {
         if (_varToAbsVal.find(id)!= _varToAbsVal.end())
         {
             if (_varToAbsVal.at(id).isAddr())
-            {
                 return true;
-            }
         }
         return false;
     }
@@ -231,9 +223,7 @@ public:
         if (_varToAbsVal.find(id) != _varToAbsVal.end())
         {
             if (_varToAbsVal.at(id).isInterval())
-            {
                 return true;
-            }
         }
         return false;
     }
@@ -265,19 +255,17 @@ public:
     }
 
     /// get var2val map
-    const VarToAbsValMap&getVarToVal() const
+    inline const VarToAbsValMap&getVarToVal() const
     {
         return _varToAbsVal;
     }
 
     /// get loc2val map
-    const AddrToAbsValMap&getLocToVal() const
+    inline const AddrToAbsValMap&getLocToVal() const
     {
         return _addrToAbsVal;
     }
 
-public:
-
     /// domain widen with other, and return the widened domain
     AbstractState widening(const AbstractState&other);
 
@@ -310,81 +298,39 @@ public:
      */
     const SVFType* getPointeeElement(NodeID id);
 
-
-    u32_t hash() const;
-
-public:
-    inline void store(u32_t addr, const AbstractValue &val)
-    {
-        assert(isVirtualMemAddress(addr) && "not virtual address?");
-        u32_t objId = getIDFromAddr(addr);
-        if (isNullMem(addr)) return;
-        _addrToAbsVal[objId] = val;
-    }
-
-    inline virtual AbstractValue &load(u32_t addr)
-    {
-        assert(isVirtualMemAddress(addr) && "not virtual address?");
-        u32_t objId = getIDFromAddr(addr);
-        return _addrToAbsVal[objId];
-
-    }
-
     void printAbstractState() const;
 
-    std::string toString() const
-    {
-        return "";
-    }
+    u32_t hash() const;
 
+    // lhs == rhs for varToValMap
+    bool eqVarToValMap(const VarToAbsValMap&lhs, const VarToAbsValMap&rhs) const;
+    // lhs >= rhs for varToValMap
+    bool geqVarToValMap(const VarToAbsValMap&lhs, const VarToAbsValMap&rhs) const;
+    // lhs == rhs for AbstractState
     bool equals(const AbstractState&other) const;
 
-
-    static bool eqVarToValMap(const VarToAbsValMap&lhs, const VarToAbsValMap&rhs)
-    {
-        if (lhs.size() != rhs.size()) return false;
-        for (const auto &item: lhs)
-        {
-            auto it = rhs.find(item.first);
-            if (it == rhs.end())
-                return false;
-            if (!item.second.equals(it->second))
-                return false;
-            else
-            {
-            }
-        }
-        return true;
-    }
-
-    static bool lessThanVarToValMap(const VarToAbsValMap&lhs, const VarToAbsValMap&rhs)
+    /// Assignment operator
+    AbstractState&operator=(const AbstractState&rhs)
     {
-        if (lhs.empty()) return !rhs.empty();
-        for (const auto &item: lhs)
+        if (&rhs != this)
         {
-            auto it = rhs.find(item.first);
-            if (it == rhs.end()) return false;
-            // judge from expr id
-            if (item.second.getInterval().contain(it->second.getInterval())) return false;
+            _varToAbsVal = rhs._varToAbsVal;
+            _addrToAbsVal = rhs._addrToAbsVal;
+            _freedAddrs = rhs._freedAddrs;
         }
-        return true;
+        return *this;
     }
 
-    // lhs >= rhs
-    static bool geqVarToValMap(const VarToAbsValMap&lhs, const VarToAbsValMap&rhs)
+    /// operator= move constructor
+    AbstractState&operator=(AbstractState&&rhs)
     {
-        if (rhs.empty()) return true;
-        for (const auto &item: rhs)
+        if (&rhs != this)
         {
-            auto it = lhs.find(item.first);
-            if (it == lhs.end()) return false;
-            // judge from expr id
-            if (!it->second.getInterval().contain(
-                        item.second.getInterval()))
-                return false;
-
+            _varToAbsVal = std::move(rhs._varToAbsVal);
+            _addrToAbsVal = std::move(rhs._addrToAbsVal);
+            _freedAddrs = std::move(rhs._freedAddrs);
         }
-        return true;
+        return *this;
     }
 
     bool operator==(const AbstractState&rhs) const
@@ -403,7 +349,6 @@ public:
         return !(*this >= rhs);
     }
 
-
     bool operator>=(const AbstractState&rhs) const
     {
         return geqVarToValMap(_varToAbsVal, rhs.getVarToVal()) && geqVarToValMap(_addrToAbsVal, rhs.getLocToVal());

package/SVF-osx/include/AE/Svfexe/AbstractInterpretation.h

@@ -113,16 +113,16 @@ public:
     AbstractState& getAbstractState(const ICFGNode* node);
 
     /// Check if an abstract state exists in the trace for a given ICFG node
-    bool hasAbsStateFromTrace(const ICFGNode* node);
+    bool hasAbstractState(const ICFGNode* node);
 
     /// Retrieve abstract value for a top-level variable at a given ICFG node
-    AbstractValue& getAbstractValue(const ICFGNode* node, const ValVar* var);
+    const AbstractValue& getAbstractValue(const ICFGNode* node, const ValVar* var);
 
     /// Retrieve abstract value for an address-taken variable at a given ICFG node
-    AbstractValue& getAbstractValue(const ICFGNode* node, const ObjVar* var);
+    const AbstractValue& getAbstractValue(const ICFGNode* node, const ObjVar* var);
 
     /// Retrieve abstract value for any SVF variable at a given ICFG node
-    AbstractValue& getAbstractValue(const ICFGNode* node, const SVFVar* var);
+    const AbstractValue& getAbstractValue(const ICFGNode* node, const SVFVar* var);
 
     /// Retrieve abstract state filtered to specific top-level variables
     void getAbstractState(const ICFGNode* node, const Set<const ValVar*>& vars, AbstractState& result);

package/package.json

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