svf-lib 1.0.1928 → 1.0.1929

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

@@ -62,7 +62,9 @@ public:
 
 public:
     /// default constructor
-    AbstractState() {}
+    AbstractState()
+    {
+    }
 
     AbstractState(VarToAbsValMap&_varToValMap, LocToAbsValMap&_locToValMap) : _varToAbsVal(_varToValMap),
         _locToAbsVal(_locToValMap) {}
@@ -182,6 +184,20 @@ public:
         return _varToAbsVal.at(varId);
     }
 
+    /// get memory addresses of variable
+    AbstractValue &getAddrs(u32_t id)
+    {
+        if (_varToAbsVal.find(id)!= _varToAbsVal.end())
+        {
+            return _varToAbsVal[id];
+        }
+        else
+        {
+            _varToAbsVal[id] = AddressValue();
+            return _varToAbsVal[id];
+        }
+    }
+
     /// whether the variable is in varToAddrs table
     inline bool inVarToAddrsTable(u32_t id) const
     {
@@ -436,314 +452,7 @@ protected:
 
 };
 
-class SparseAbstractState : public AbstractState
-{
-    friend class SVFIR2AbsState;
-    friend class RelationSolver;
-
-public:
-    static SparseAbstractState globalES;
-
-public:
-    /// default constructor
-    SparseAbstractState() : AbstractState() {}
-
-    SparseAbstractState(VarToAbsValMap&_varToValMap, LocToAbsValMap&_locToValMap) : AbstractState(_varToValMap, _locToValMap) {}
-
-    /// copy constructor
-    SparseAbstractState(const SparseAbstractState&rhs) : AbstractState(rhs)
-    {
-
-    }
-
-    virtual ~SparseAbstractState() = default;
-
-    SparseAbstractState&operator=(const SparseAbstractState&rhs)
-    {
-        AbstractState::operator=(rhs);
-        return *this;
-    }
-
-    virtual void printExprValues(std::ostream &oss) const;
-
-    /// move constructor
-    SparseAbstractState(SparseAbstractState&&rhs) : AbstractState(std::move(rhs))
-    {
-
-    }
-
-    /// operator= move constructor
-    SparseAbstractState&operator=(SparseAbstractState&&rhs)
-    {
-        AbstractState::operator=(std::move(rhs));
-        return *this;
-    }
-
-public:
-
-    /// get memory addresses of variable
-    AbstractValue &getAddrs(u32_t id)
-    {
-        if (_varToAbsVal.find(id)!= _varToAbsVal.end())
-        {
-            return _varToAbsVal[id];
-        }
-        else if (globalES._varToAbsVal.find(id)!= globalES._varToAbsVal.end())
-        {
-            return globalES._varToAbsVal[id];
-        }
-        else
-        {
-            globalES._varToAbsVal[id] = AddressValue();
-            return globalES._varToAbsVal[id];
-        }
-    }
-
-    /// get abstract value of variable
-    inline AbstractValue &operator[](u32_t varId)
-    {
-        auto localIt = _varToAbsVal.find(varId);
-        if(localIt != _varToAbsVal.end())
-            return localIt->second;
-        else
-        {
-            return globalES._varToAbsVal[varId];
-        }
-    }
-
-    /// 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;
-            }
-            else
-            {
-                return false;
-            }
-        }
-        else if (globalES._varToAbsVal.find(id)!= globalES._varToAbsVal.end())
-        {
-            if (globalES._varToAbsVal[id].isAddr())
-            {
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-        else
-        {
-            return false;
-        }
-    }
-
-    /// whether the variable is in varToVal table
-    inline bool inVarToValTable(u32_t id) const
-    {
-        if (_varToAbsVal.find(id)!= _varToAbsVal.end())
-        {
-            if (_varToAbsVal.at(id).isInterval())
-            {
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-        else if (globalES._varToAbsVal.find(id)!= globalES._varToAbsVal.end())
-        {
-            if (globalES._varToAbsVal[id].isInterval())
-            {
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-        else
-        {
-            return false;
-        }
-    }
-
-    /// whether the memory address stores memory addresses
-    inline bool inLocToAddrsTable(u32_t id) const
-    {
-        if (_locToAbsVal.find(id)!= _locToAbsVal.end())
-        {
-            if (_locToAbsVal.at(id).isAddr())
-            {
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-        else if (globalES._locToAbsVal.find(id)!= globalES._locToAbsVal.end())
-        {
-            if (globalES._locToAbsVal[id].isAddr())
-            {
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-        else
-        {
-            return false;
-        }
-    }
-
-    /// whether the memory address stores abstract value
-    inline bool inLocToValTable(u32_t id) const
-    {
-        if (_locToAbsVal.find(id)!= _locToAbsVal.end())
-        {
-            if (_locToAbsVal.at(id).isInterval())
-            {
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-        else if (globalES._locToAbsVal.find(id)!= globalES._locToAbsVal.end())
-        {
-            if (globalES._locToAbsVal[id].isInterval())
-            {
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-        else
-        {
-            return false;
-        }
-    }
-
-    inline bool inLocalLocToValTable(u32_t id) const
-    {
-        if (_locToAbsVal.find(id)!= _locToAbsVal.end())
-        {
-            return _locToAbsVal.at(id).isInterval();
-        }
-        else
-            return false;
-    }
-
-    inline bool inLocalLocToAddrsTable(u32_t id) const
-    {
-        if (_locToAbsVal.find(id)!= _locToAbsVal.end())
-        {
-            return _locToAbsVal.at(id).isAddr();
-        }
-        else
-            return false;
-    }
-
-public:
-
-    inline void cpyItvToLocal(u32_t varId)
-    {
-        auto localIt = _varToAbsVal.find(varId);
-        // local already have varId
-        if (localIt != _varToAbsVal.end()) return;
-        auto globIt = globalES._varToAbsVal.find(varId);
-        if (globIt != globalES._varToAbsVal.end())
-        {
-            _varToAbsVal[varId] = globIt->second;
-        }
-    }
-
-    /// domain widen with other, and return the widened domain
-    SparseAbstractState widening(const SparseAbstractState&other);
-
-    /// domain narrow with other, and return the narrowed domain
-    SparseAbstractState narrowing(const SparseAbstractState&other);
-
-    /// domain widen with other, important! other widen this.
-    void widenWith(const SparseAbstractState&other);
-
-    /// domain join with other, important! other widen this.
-    void joinWith(const SparseAbstractState&other);
-
-    /// domain narrow with other, important! other widen this.
-    void narrowWith(const SparseAbstractState&other);
-
-    /// domain meet with other, important! other widen this.
-    void meetWith(const SparseAbstractState&other);
-
-    u32_t hash() const;
-
-public:
-
-    inline 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())
-            return it->second;
-        else
-        {
-            auto globIt = globalES._locToAbsVal.find(objId);
-            if(globIt != globalES._locToAbsVal.end())
-                return globIt->second;
-            else
-            {
-                return globalES._locToAbsVal[objId];
-            }
-
-        }
-    }
-
-    bool equals(const SparseAbstractState&other) const;
-
-    bool operator==(const SparseAbstractState&rhs) const
-    {
-        return eqVarToValMap(_varToAbsVal, rhs._varToAbsVal) &&
-               eqVarToValMap(_locToAbsVal, rhs._locToAbsVal);
-    }
-
-    bool operator!=(const SparseAbstractState&rhs) const
-    {
-        return !(*this == rhs);
-    }
-
-    bool operator<(const SparseAbstractState&rhs) const
-    {
-        return !(*this >= rhs);
-    }
-
-
-    bool operator>=(const SparseAbstractState&rhs) const
-    {
-        return geqVarToValMap(_varToAbsVal, rhs.getVarToVal()) && geqVarToValMap(_locToAbsVal, rhs._locToAbsVal);
-    }
-};
 }
 
-template<>
-struct std::hash<SVF::SparseAbstractState>
-{
-    size_t operator()(const SVF::SparseAbstractState&exeState) const
-    {
-        return exeState.hash();
-    }
-};
 
 #endif //Z3_EXAMPLE_INTERVAL_DOMAIN_H

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 node The ICFGNode to analyse
+     * @param block The ICFGNode to analyse
      * @return if this node has preceding execution state
      */
-    bool hasInEdgesES(const ICFGNode* node);
+    bool propogateAbsStateToCurNode(const ICFGNode* block);
 
     /**
      * Check if execution state exist at the branch edge
@@ -154,7 +154,7 @@ protected:
      * @param intraEdge the edge from CmpStmt to the next node
      * @return if this edge is feasible
      */
-    bool hasBranchES(const IntraCFGEdge* intraEdge, SparseAbstractState& es);
+    bool hasBranchES(const IntraCFGEdge* intraEdge, AbstractState& es);
 
     /**
      * handle instructions in ICFGNode
@@ -220,7 +220,7 @@ protected:
     * @return if this ICFGNode has preceding execution state
     */
     bool hasCmpBranchES(const CmpStmt* cmpStmt, s64_t succ,
-                        SparseAbstractState& es);
+                        AbstractState& es);
 
     /**
     * Check if this SwitchInst and succ are satisfiable to the execution state.
@@ -230,7 +230,7 @@ protected:
     * @return if this ICFGNode has preceding execution state
     */
     bool hasSwitchBranchES(const SVFVar* var, s64_t succ,
-                           SparseAbstractState& es);
+                           AbstractState& es);
 
 
     /**
@@ -374,9 +374,9 @@ private:
 
     // helper functions in handleCycle
     bool widenFixpointPass(const ICFGNode* cycle_head,
-                           SparseAbstractState& pre_es);
+                           AbstractState& pre_es);
     bool narrowFixpointPass(const ICFGNode* cycle_head,
-                            SparseAbstractState& pre_es);
+                            AbstractState& pre_es);
 
 protected:
     // there data should be shared with subclasses
@@ -385,8 +385,8 @@ protected:
     Set<std::string> _checkpoint_names;
 
 private:
-    Map<const ICFGNode*, SparseAbstractState> _preAbstractTrace;
-    Map<const ICFGNode*, SparseAbstractState> _postAbstractTrace;
+    Map<const ICFGNode*, AbstractState> _preAbstractTrace;
+    Map<const ICFGNode*, AbstractState> _postAbstractTrace;
     std::string _moduleName;
 };
 }

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

@@ -46,12 +46,12 @@ public:
 public:
     SVFIR2AbsState(SVFIR *ir) : _svfir(ir) {}
 
-    void setEs(const SparseAbstractState&es)
+    void setEs(const AbstractState&es)
     {
         _es = es;
     }
 
-    SparseAbstractState& getEs()
+    AbstractState& getEs()
     {
         return _es;
     }
@@ -66,9 +66,9 @@ public:
         return _relEs;
     }
 
-    void widenAddrs(SparseAbstractState&lhs, const SparseAbstractState&rhs);
+    void widenAddrs(AbstractState&lhs, const AbstractState&rhs);
 
-    void narrowAddrs(SparseAbstractState&lhs, const SparseAbstractState&rhs);
+    void narrowAddrs(AbstractState&lhs, const AbstractState&rhs);
 
     /// Return the field address given a pointer points to a struct object and an offset
     AbstractValue getGepObjAddress(u32_t pointer, APOffset offset);
@@ -101,7 +101,7 @@ public:
         return Z3Expr::getContext();
     }
 
-    void applySummary(SparseAbstractState&es);
+    void applySummary(AbstractState&es);
 
 
     /// Init ObjVar
@@ -144,29 +144,27 @@ public:
         return _es.inLocToAddrsTable(id);
     }
 
-    void moveToGlobal();
+    void handleAddr(const AddrStmt *addr);
 
-    void translateAddr(const AddrStmt *addr);
+    void handleBinary(const BinaryOPStmt *binary);
 
-    void translateBinary(const BinaryOPStmt *binary);
+    void handleCmp(const CmpStmt *cmp);
 
-    void translateCmp(const CmpStmt *cmp);
+    void handleLoad(const LoadStmt *load);
 
-    void translateLoad(const LoadStmt *load);
+    void handleStore(const StoreStmt *store);
 
-    void translateStore(const StoreStmt *store);
+    void handleCopy(const CopyStmt *copy);
 
-    void translateCopy(const CopyStmt *copy);
+    void handleCall(const CallPE *callPE);
 
-    void translateCall(const CallPE *callPE);
+    void handleRet(const RetPE *retPE);
 
-    void translateRet(const RetPE *retPE);
+    void handleGep(const GepStmt *gep);
 
-    void translateGep(const GepStmt *gep);
+    void handleSelect(const SelectStmt *select);
 
-    void translateSelect(const SelectStmt *select);
-
-    void translatePhi(const PhiStmt *phi);
+    void handlePhi(const PhiStmt *phi);
 
     /// Return the internal index if idx is an address otherwise return the value of idx
     static inline u32_t getInternalID(u32_t idx)
@@ -188,30 +186,30 @@ public:
 
 protected:
 
-    void translateBinaryRel(const BinaryOPStmt *binary);
+    void handleBinaryRel(const BinaryOPStmt *binary);
 
-    void translateCmpRel(const CmpStmt *cmp);
+    void handleCmpRel(const CmpStmt *cmp);
 
-    void translateLoadRel(const LoadStmt *load);
+    void handleLoadRel(const LoadStmt *load);
 
-    void translateStoreRel(const StoreStmt *store);
+    void handleStoreRel(const StoreStmt *store);
 
-    void translateCopyRel(const CopyStmt *copy);
+    void handleCopyRel(const CopyStmt *copy);
 
-    void translateCallRel(const CallPE *callPE);
+    void handleCallRel(const CallPE *callPE);
 
-    void translateRetRel(const RetPE *retPE);
+    void handleRetRel(const RetPE *retPE);
 
-    void translateSelectRel(const SelectStmt *select);
+    void handleSelectRel(const SelectStmt *select);
 
-    void translatePhiRel(const PhiStmt *phi, const ICFGNode *srcNode, const std::vector<const ICFGEdge *> &path);
+    void handlePhiRel(const PhiStmt *phi, const ICFGNode *srcNode, const std::vector<const ICFGEdge *> &path);
 
 private:
     SVFIR *_svfir;
-    SparseAbstractState _es;
+    AbstractState _es;
     RelExeState _relEs;
 
-    Map<NodeID, SparseAbstractState*> _br_cond;
+    Map<NodeID, AbstractState*> _br_cond;
     AbstractValue getZExtValue(const SVFVar* var, const SVFType*);
 };
 }

package/SVF-linux/Release-build/lib/cmake/SVF/SVFConfig.cmake

@@ -3,7 +3,7 @@
 ####### Any changes to this file will be overwritten by the next CMake run ####
 ####### The input file was .config.cmake.in                            ########
 
-get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)
+get_filename_component(PACKAGE_${CMAKE_FIND_PACKAGE_NAME}_COUNTER_1 "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)
 
 macro(set_and_check _var _file)
   set(${_var} "${_file}")
@@ -24,23 +24,23 @@ endmacro()
 
 ####################################################################################
 
-set_and_check(SVF_INSTALL_ROOT "${PACKAGE_PREFIX_DIR}")
-set_and_check(SVF_INSTALL_BIN_DIR "${PACKAGE_PREFIX_DIR}/bin")
-set_and_check(SVF_INSTALL_LIB_DIR "${PACKAGE_PREFIX_DIR}/lib")
+set_and_check(SVF_INSTALL_ROOT "${PACKAGE_${CMAKE_FIND_PACKAGE_NAME}_COUNTER_1}")
+set_and_check(SVF_INSTALL_BIN_DIR "${PACKAGE_${CMAKE_FIND_PACKAGE_NAME}_COUNTER_1}/bin")
+set_and_check(SVF_INSTALL_LIB_DIR "${PACKAGE_${CMAKE_FIND_PACKAGE_NAME}_COUNTER_1}/lib")
 
-set(SVF_INCLUDE_PATH "${PACKAGE_PREFIX_DIR}/../svf/include")
-set(SVF_LLVM_INCLUDE_PATH "${PACKAGE_PREFIX_DIR}/../svf-llvm/include")
+set(SVF_INCLUDE_PATH "${PACKAGE_${CMAKE_FIND_PACKAGE_NAME}_COUNTER_1}/../svf/include")
+set(SVF_LLVM_INCLUDE_PATH "${PACKAGE_${CMAKE_FIND_PACKAGE_NAME}_COUNTER_1}/../svf-llvm/include")
 
 if(EXISTS ${SVF_INCLUDE_PATH} AND EXISTS ${SVF_LLVM_INCLUDE_PATH})
-    set(SVF_INSTALL_INCLUDE_DIR "${SVF_INCLUDE_PATH};${SVF_LLVM_INCLUDE_PATH};${PACKAGE_PREFIX_DIR}/include")
+    set(SVF_INSTALL_INCLUDE_DIR "${SVF_INCLUDE_PATH};${SVF_LLVM_INCLUDE_PATH};${PACKAGE_${CMAKE_FIND_PACKAGE_NAME}_COUNTER_1}/include")
 else()
-    set_and_check(SVF_INSTALL_INCLUDE_DIR "${PACKAGE_PREFIX_DIR}/include")
+    set_and_check(SVF_INSTALL_INCLUDE_DIR "${PACKAGE_${CMAKE_FIND_PACKAGE_NAME}_COUNTER_1}/include")
 endif()
 
 message(STATUS "SVF_INSTALL_INCLUDE_DIR is set to: ${SVF_INSTALL_INCLUDE_DIR}")
 
-set_and_check(SVF_INSTALL_EXTAPI_DIR "${PACKAGE_PREFIX_DIR}/lib")
-set_and_check(SVF_INSTALL_EXTAPI_FILE "${PACKAGE_PREFIX_DIR}/lib/extapi.bc")
+set_and_check(SVF_INSTALL_EXTAPI_DIR "${PACKAGE_${CMAKE_FIND_PACKAGE_NAME}_COUNTER_1}/lib")
+set_and_check(SVF_INSTALL_EXTAPI_FILE "${PACKAGE_${CMAKE_FIND_PACKAGE_NAME}_COUNTER_1}/lib/extapi.bc")
 
 set(SVF_SANITIZE "")
 

package/package.json

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