svf-lib 1.0.2503 → 1.0.2505

package/SVF-linux-aarch64/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-linux-aarch64/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/SVF-osx/include/AE/Svfexe/AbstractInterpretation.h

@@ -138,15 +138,13 @@ private:
     /// Initialize abstract state for the global ICFG node and process global statements
     virtual void handleGlobalNode();
 
-    /// Merge abstract states from predecessor nodes; return true if icfgNode has feasible incoming state
-    bool mergeStatesFromPredecessors(const ICFGNode * icfgNode);
+    /// Propagate the post-state of a node to all its intra-procedural successors
+    void propagateToSuccessor(const ICFGNode* node,
+                              const Set<const ICFGNode*>* withinSet = nullptr);
 
     /// Check if the branch on intraEdge is feasible under abstract state as
     bool isBranchFeasible(const IntraCFGEdge* intraEdge, AbstractState& as);
 
-    /// Process all SVF statements in a singleton WTO component (single basic block)
-    virtual void handleSingletonWTO(const ICFGSingletonWTO *icfgSingletonWto);
-
     /// Handle a call site node: dispatch to ext-call, direct-call, or indirect-call handling
     virtual void handleCallSite(const ICFGNode* node);
 
@@ -156,15 +154,9 @@ private:
     /// Handle a function body via worklist-driven WTO traversal starting from funEntry
     void handleFunction(const ICFGNode* funEntry, const CallICFGNode* caller = nullptr);
 
-    /// Merge predecessor states, process statements and callsites; return true if state changed
+    /// Handle an ICFG node: execute statements; return true if state changed
     bool handleICFGNode(const ICFGNode* node);
 
-    /// Get intra-procedural successor nodes (including call-to-ret shortcut) within the same function
-    std::vector<const ICFGNode*> getNextNodes(const ICFGNode* node) const;
-
-    /// Get successor nodes that exit the given WTO cycle (skipping inner sub-cycles)
-    std::vector<const ICFGNode*> getNextNodesOfCycle(const ICFGCycleWTO* cycle) const;
-
     /// Dispatch an SVF statement (Addr/Binary/Cmp/Load/Store/Copy/Gep/Select/Phi/Call/Ret) to its handler
     virtual void handleSVFStatement(const SVFStmt* stmt);
 
@@ -232,7 +224,7 @@ private:
     // there data should be shared with subclasses
     Map<std::string, std::function<void(const CallICFGNode*)>> func_map;
 
-    Map<const ICFGNode*, AbstractState> abstractTrace; // abstract states immediately after nodes
+    Map<const ICFGNode*, AbstractState> abstractTrace; // abstract states for nodes (pre-state before execution, post-state after)
     Set<const ICFGNode*> allAnalyzedNodes; // All nodes ever analyzed (across all entry points)
     std::string moduleName;
 

package/package.json

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