svf-tools 1.0.908 → 1.0.910

package/svf/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/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
@@ -161,7 +161,7 @@ protected:
      *
      * @param block basic block that has a series of instructions
      */
-    void handleWTONode(const ICFGNode* node);
+    virtual void handleWTONode(const ICFGNode* node);
 
     /**
      * handle one instruction in ICFGNode
@@ -368,10 +368,7 @@ private:
     virtual bool isIndirectCall(const CallICFGNode* callNode);
     virtual void indirectCallFunPass(const CallICFGNode* callNode);
 
-    // helper functions in hasInEdgesES
-    bool isFunEntry(const ICFGNode* node);
-    bool isGlobalEntry(const ICFGNode* node);
-
+protected:
     // helper functions in handleCycle
     bool widenFixpointPass(const ICFGNode* cycle_head,
                            AbstractState& pre_es);
@@ -383,8 +380,6 @@ protected:
     Map<std::string, std::function<void(const CallSite &)>> _func_map;
     Set<const CallICFGNode*> _checkpoints;
     Set<std::string> _checkpoint_names;
-
-private:
     Map<const ICFGNode*, AbstractState> _preAbstractTrace;
     Map<const ICFGNode*, AbstractState> _postAbstractTrace;
     std::string _moduleName;

package/svf/include/AE/Svfexe/SVFIR2AbsState.h

@@ -208,9 +208,6 @@ private:
     SVFIR *_svfir;
     AbstractState _es;
     RelExeState _relEs;
-
-    Map<NodeID, AbstractState*> _br_cond;
-    AbstractValue getZExtValue(const SVFVar* var, const SVFType*);
 };
 }
 

package/svf/lib/AE/Core/AbstractState.cpp

@@ -66,12 +66,12 @@ AbstractState AbstractState::widening(const AbstractState& other)
             if (it->second.isInterval() && other._varToAbsVal.at(key).isInterval())
                 it->second.getInterval().widen_with(other._varToAbsVal.at(key).getInterval());
     }
-    for (auto it = es._locToAbsVal.begin(); it != es._locToAbsVal.end(); ++it)
+    for (auto it = es._addrToAbsVal.begin(); it != es._addrToAbsVal.end(); ++it)
     {
         auto key = it->first;
-        if (other._locToAbsVal.find(key) != other._locToAbsVal.end())
-            if (it->second.isInterval() && other._locToAbsVal.at(key).isInterval())
-                it->second.getInterval().widen_with(other._locToAbsVal.at(key).getInterval());
+        if (other._addrToAbsVal.find(key) != other._addrToAbsVal.end())
+            if (it->second.isInterval() && other._addrToAbsVal.at(key).isInterval())
+                it->second.getInterval().widen_with(other._addrToAbsVal.at(key).getInterval());
     }
     return es;
 }
@@ -86,12 +86,12 @@ AbstractState AbstractState::narrowing(const AbstractState& other)
             if (it->second.isInterval() && other._varToAbsVal.at(key).isInterval())
                 it->second.getInterval().narrow_with(other._varToAbsVal.at(key).getInterval());
     }
-    for (auto it = es._locToAbsVal.begin(); it != es._locToAbsVal.end(); ++it)
+    for (auto it = es._addrToAbsVal.begin(); it != es._addrToAbsVal.end(); ++it)
     {
         auto key = it->first;
-        if (other._locToAbsVal.find(key) != other._locToAbsVal.end())
-            if (it->second.isInterval() && other._locToAbsVal.at(key).isInterval())
-                it->second.getInterval().narrow_with(other._locToAbsVal.at(key).getInterval());
+        if (other._addrToAbsVal.find(key) != other._addrToAbsVal.end())
+            if (it->second.isInterval() && other._addrToAbsVal.at(key).isInterval())
+                it->second.getInterval().narrow_with(other._addrToAbsVal.at(key).getInterval());
     }
     return es;
 
@@ -107,12 +107,12 @@ void AbstractState::widenWith(const AbstractState& other)
             if (it->second.isInterval() && other._varToAbsVal.at(key).isInterval())
                 it->second.getInterval().widen_with(other._varToAbsVal.at(key).getInterval());
     }
-    for (auto it = _locToAbsVal.begin(); it != _locToAbsVal.end(); ++it)
+    for (auto it = _addrToAbsVal.begin(); it != _addrToAbsVal.end(); ++it)
     {
         auto key = it->first;
-        if (other._locToAbsVal.find(key) != other._locToAbsVal.end())
+        if (other._addrToAbsVal.find(key) != other._addrToAbsVal.end())
             if (it->second.isInterval() && other._varToAbsVal.at(key).isInterval())
-                it->second.getInterval().widen_with(other._locToAbsVal.at(key).getInterval());
+                it->second.getInterval().widen_with(other._addrToAbsVal.at(key).getInterval());
     }
 }
 
@@ -143,11 +143,11 @@ void AbstractState::joinWith(const AbstractState& other)
             _varToAbsVal.emplace(key, it->second);
         }
     }
-    for (auto it = other._locToAbsVal.begin(); it != other._locToAbsVal.end(); ++it)
+    for (auto it = other._addrToAbsVal.begin(); it != other._addrToAbsVal.end(); ++it)
     {
         auto key = it->first;
-        auto oit = _locToAbsVal.find(key);
-        if (oit != _locToAbsVal.end())
+        auto oit = _addrToAbsVal.find(key);
+        if (oit != _addrToAbsVal.end())
         {
             if (oit->second.isInterval() && it->second.isInterval())
             {
@@ -164,7 +164,7 @@ void AbstractState::joinWith(const AbstractState& other)
         }
         else
         {
-            _locToAbsVal.emplace(key, it->second);
+            _addrToAbsVal.emplace(key, it->second);
         }
     }
 }
@@ -180,11 +180,11 @@ void AbstractState::narrowWith(const AbstractState& other)
             if (it->second.isInterval() && oit->second.isInterval())
                 it->second.getInterval().narrow_with(oit->second.getInterval());
     }
-    for (auto it = _locToAbsVal.begin(); it != _locToAbsVal.end(); ++it)
+    for (auto it = _addrToAbsVal.begin(); it != _addrToAbsVal.end(); ++it)
     {
         auto key = it->first;
-        auto oit = other._locToAbsVal.find(key);
-        if (oit != other._locToAbsVal.end())
+        auto oit = other._addrToAbsVal.find(key);
+        if (oit != other._addrToAbsVal.end())
             if (it->second.isInterval() && oit->second.isInterval())
                 it->second.getInterval().narrow_with(oit->second.getInterval());
     }
@@ -213,11 +213,11 @@ void AbstractState::meetWith(const AbstractState& other)
             }
         }
     }
-    for (auto it = other._locToAbsVal.begin(); it != other._locToAbsVal.end(); ++it)
+    for (auto it = other._addrToAbsVal.begin(); it != other._addrToAbsVal.end(); ++it)
     {
         auto key = it->first;
-        auto oit = _locToAbsVal.find(key);
-        if (oit != _locToAbsVal.end())
+        auto oit = _addrToAbsVal.find(key);
+        if (oit != _addrToAbsVal.end())
         {
             if (oit->second.isInterval() && it->second.isInterval())
             {
@@ -240,7 +240,7 @@ void AbstractState::printExprValues(std::ostream &oss) const
 {
     oss << "-----------Var and Value-----------\n";
     printTable(_varToAbsVal, oss);
-    printTable(_locToAbsVal, oss);
+    printTable(_addrToAbsVal, oss);
     oss << "-----------------------------------------\n";
 }
 

package/svf/lib/AE/Core/RelExeState.cpp

@@ -106,7 +106,7 @@ RelExeState &RelExeState::operator=(const RelExeState &rhs)
     if (*this != rhs)
     {
         _varToVal = rhs.getVarToVal();
-        _locToVal = rhs.getLocToVal();
+        _addrToVal = rhs.getLocToVal();
     }
     return *this;
 }
@@ -119,7 +119,7 @@ RelExeState &RelExeState::operator=(const RelExeState &rhs)
 bool RelExeState::operator==(const RelExeState &rhs) const
 {
     return eqVarToValMap(_varToVal, rhs.getVarToVal()) &&
-           eqVarToValMap(_locToVal, rhs.getLocToVal());
+           eqVarToValMap(_addrToVal, rhs.getLocToVal());
 }
 
 /*!
@@ -130,7 +130,7 @@ bool RelExeState::operator==(const RelExeState &rhs) const
 bool RelExeState::operator<(const RelExeState &rhs) const
 {
     return lessThanVarToValMap(_varToVal, rhs.getVarToVal()) ||
-           lessThanVarToValMap(_locToVal, rhs.getLocToVal());
+           lessThanVarToValMap(_addrToVal, rhs.getLocToVal());
 }
 
 bool RelExeState::eqVarToValMap(const VarToValMap &lhs, const VarToValMap &rhs) const

package/svf/lib/AE/Svfexe/AbstractInterpretation.cpp

@@ -177,7 +177,7 @@ void AbstractInterpretation::handleGlobalNode()
 /// get execution state by merging states of predecessor blocks
 /// Scenario 1: preblock -----(intraEdge)----> block, join the preES of inEdges
 /// Scenario 2: preblock -----(callEdge)----> block
-bool AbstractInterpretation::propogateAbsStateToCurNode(const ICFGNode *block)
+bool AbstractInterpretation::propagateStateIfFeasible(const ICFGNode *block)
 {
     AbstractState es;
     u32_t inEdgeNum = 0;
@@ -224,29 +224,6 @@ bool AbstractInterpretation::propogateAbsStateToCurNode(const ICFGNode *block)
     assert(false && "implement this part");
 }
 
-bool AbstractInterpretation::isFunEntry(const SVF::ICFGNode *block)
-{
-    if (SVFUtil::isa<FunEntryICFGNode>(block))
-    {
-        if (_preAbstractTrace.find(block) != _preAbstractTrace.end())
-        {
-            return true;
-        }
-    }
-    return false;
-}
-
-bool AbstractInterpretation::isGlobalEntry(const SVF::ICFGNode *block)
-{
-    for (auto *edge : _icfg->getGlobalICFGNode()->getOutEdges())
-    {
-        if (edge->getDstNode() == block)
-        {
-            return true;
-        }
-    }
-    return false;
-}
 
 bool AbstractInterpretation::hasCmpBranchES(const CmpStmt* cmpStmt, s64_t succ,
         AbstractState& es)
@@ -544,7 +521,7 @@ void AbstractInterpretation::handleWTONode(const ICFGNode *node)
 {
     _stat->getBlockTrace()++;
     // Get execution states from in edges
-    if (!propogateAbsStateToCurNode(node))
+    if (!propagateStateIfFeasible(node))
     {
         // No ES on the in edges - Infeasible block
         return;
@@ -717,7 +694,7 @@ void AbstractInterpretation::handleICFGNode(const ICFGNode *curICFGNode)
 void AbstractInterpretation::handleCycle(const ICFGWTOCycle *cycle)
 {
     // Get execution states from in edges
-    if (!propogateAbsStateToCurNode(cycle->head()))
+    if (!propagateStateIfFeasible(cycle->head()))
     {
         // No ES on the in edges - Infeasible block
         return;
@@ -851,7 +828,6 @@ void AbstractInterpretation::handleFunc(const SVFFunction *func)
 
 void AbstractInterpretation::handleSVFStatement(const SVFStmt *stmt)
 {
-    std::cout << stmt->toString() << std::endl;
     if (const AddrStmt *addr = SVFUtil::dyn_cast<AddrStmt>(stmt))
     {
         _svfir2ExeState->handleAddr(addr);

package/svf/lib/AE/Svfexe/SVFIR2AbsState.cpp

@@ -277,9 +277,9 @@ void SVFIR2AbsState::applySummary(AbstractState&es)
     {
         _es._varToAbsVal[item.first] = item.second;
     }
-    for (const auto &item: es._locToAbsVal)
+    for (const auto &item: es._addrToAbsVal)
     {
-        _es._locToAbsVal[item.first] = item.second;
+        _es._addrToAbsVal[item.first] = item.second;
     }
 }
 
@@ -305,10 +305,10 @@ void SVFIR2AbsState::widenAddrs(AbstractState&lhs, const AbstractState&rhs)
             }
         }
     }
-    for (const auto &rhsItem: rhs._locToAbsVal)
+    for (const auto &rhsItem: rhs._addrToAbsVal)
     {
-        auto lhsIter = lhs._locToAbsVal.find(rhsItem.first);
-        if (lhsIter != lhs._locToAbsVal.end())
+        auto lhsIter = lhs._addrToAbsVal.find(rhsItem.first);
+        if (lhsIter != lhs._addrToAbsVal.end())
         {
             if (rhsItem.second.isAddr())
             {
@@ -349,10 +349,10 @@ void SVFIR2AbsState::narrowAddrs(AbstractState&lhs, const AbstractState&rhs)
             }
         }
     }
-    for (const auto &rhsItem: rhs._locToAbsVal)
+    for (const auto &rhsItem: rhs._addrToAbsVal)
     {
-        auto lhsIter = lhs._locToAbsVal.find(rhsItem.first);
-        if (lhsIter != lhs._locToAbsVal.end())
+        auto lhsIter = lhs._addrToAbsVal.find(rhsItem.first);
+        if (lhsIter != lhs._addrToAbsVal.end())
         {
             if (lhsIter->second.isAddr())
             {