svf-lib 1.0.1925 → 1.0.1926

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

@@ -1,4 +1,4 @@
-//===- IntervalValue.h ----Interval Value for Interval Domain-------------//
+//===- IntervalValue.h ----Interval Value for Abstract Domain-------------//
 //
 //                     SVF: Static Value-Flow Analysis
 //
@@ -31,7 +31,6 @@
 #ifndef Z3_EXAMPLE_IntervalValue_H
 #define Z3_EXAMPLE_IntervalValue_H
 
-#include "AE/Core/AbstractValue.h"
 #include "AE/Core/NumericLiteral.h"
 
 namespace SVF
@@ -40,7 +39,7 @@ namespace SVF
 /// IntervalValue abstract value
 ///
 /// Implemented as a pair of bounds
-class IntervalValue final : public AbstractValue
+class IntervalValue
 {
 private:
     // Lower bound
@@ -52,12 +51,12 @@ private:
     // Invariant: isBottom() <=> _lb = 1 && _ub = 0
 public:
 
-    bool isTop() const override
+    bool isTop() const
     {
         return this->_lb.is_minus_infinity() && this->_ub.is_plus_infinity();
     }
 
-    bool isBottom() const override
+    bool isBottom() const
     {
         return !_ub.geq(_lb);
     }
@@ -92,22 +91,21 @@ public:
     }
 
     /// Create default IntervalValue
-    explicit IntervalValue() : AbstractValue(AbstractValue::IntervalK), _lb(minus_infinity()), _ub(plus_infinity()) {}
+    explicit IntervalValue() : _lb(minus_infinity()), _ub(plus_infinity()) {}
 
     /// Create the IntervalValue [n, n]
-    explicit IntervalValue(s64_t n) : AbstractValue(AbstractValue::IntervalK), _lb(n), _ub(n) {}
+    explicit IntervalValue(s64_t n) : _lb(n), _ub(n) {}
 
     explicit IntervalValue(s32_t n) : IntervalValue((s64_t) n) {}
 
     explicit IntervalValue(u32_t n) : IntervalValue((s64_t) n) {}
 
-    explicit IntervalValue(double n) : AbstractValue(AbstractValue::IntervalK), _lb(n), _ub(n) {}
+    explicit IntervalValue(double n) : _lb(n), _ub(n) {}
 
     explicit IntervalValue(NumericLiteral n) : IntervalValue(n, n) {}
 
     /// Create the IntervalValue [lb, ub]
-    explicit IntervalValue(NumericLiteral lb, NumericLiteral ub) : AbstractValue(AbstractValue::IntervalK),
-        _lb(std::move(lb)), _ub(std::move(ub)) {}
+    explicit IntervalValue(NumericLiteral lb, NumericLiteral ub) : _lb(std::move(lb)), _ub(std::move(ub)) {}
 
     explicit IntervalValue(s64_t lb, s64_t ub) : IntervalValue(NumericLiteral(lb), NumericLiteral(ub)) {}
 
@@ -201,20 +199,7 @@ public:
     }
 
     /// Destructor
-    ~IntervalValue() override = default;
-
-    /// Methods for support type inquiry through isa, cast, and dyn_cast:
-    //@{
-    static inline bool classof(const IntervalValue *)
-    {
-        return true;
-    }
-
-    static inline bool classof(const AbstractValue *v)
-    {
-        return v->getAbstractValueKind() == AbstractValue::IntervalK;
-    }
-    //@}
+    ~IntervalValue()  = default;
 
     /// Return the lower bound
     const NumericLiteral &lb() const

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

@@ -30,7 +30,7 @@
 #ifndef Z3_EXAMPLE_RELATIONSOLVER_H
 #define Z3_EXAMPLE_RELATIONSOLVER_H
 
-#include "AE/Core/IntervalExeState.h"
+#include "AE/Core/AbstractState.h"
 #include "Util/Z3Expr.h"
 
 namespace SVF
@@ -44,17 +44,17 @@ public:
     IntervalESBase (the last element of inputs) for RSY or bilateral solver */
 
     /// Return Z3Expr according to valToValMap
-    Z3Expr gamma_hat(const IntervalESBase &exeState) const;
+    Z3Expr gamma_hat(const AbstractState&exeState) const;
 
     /// Return Z3Expr according to another valToValMap
-    Z3Expr gamma_hat(const IntervalESBase &alpha, const IntervalESBase &exeState) const;
+    Z3Expr gamma_hat(const AbstractState&alpha, const AbstractState&exeState) const;
 
     /// Return Z3Expr from a NodeID
-    Z3Expr gamma_hat(u32_t id, const IntervalESBase &exeState) const;
+    Z3Expr gamma_hat(u32_t id, const AbstractState&exeState) const;
 
-    IntervalESBase abstract_consequence(const IntervalESBase &lower, const IntervalESBase &upper, const IntervalESBase &domain) const;
+    AbstractState abstract_consequence(const AbstractState&lower, const AbstractState&upper, const AbstractState&domain) const;
 
-    IntervalESBase beta(const Map<u32_t, s32_t> &sigma, const IntervalESBase &exeState) const;
+    AbstractState beta(const Map<u32_t, s32_t> &sigma, const AbstractState&exeState) const;
 
 
     /// Return Z3 expression lazily based on SVFVar ID
@@ -65,13 +65,13 @@ public:
 
     /* two optional solvers: RSY and bilateral */
 
-    IntervalESBase bilateral(const IntervalESBase& domain, const Z3Expr &phi, u32_t descend_check = 0);
+    AbstractState bilateral(const AbstractState& domain, const Z3Expr &phi, u32_t descend_check = 0);
 
-    IntervalESBase RSY(const IntervalESBase& domain, const Z3Expr &phi);
+    AbstractState RSY(const AbstractState& domain, const Z3Expr &phi);
 
     Map<u32_t, NumericLiteral> BoxedOptSolver(const Z3Expr& phi, Map<u32_t, NumericLiteral>& ret, Map<u32_t, NumericLiteral>& low_values, Map<u32_t, NumericLiteral>& high_values);
 
-    IntervalESBase BS(const IntervalESBase& domain, const Z3Expr &phi);
+    AbstractState BS(const AbstractState& domain, const Z3Expr &phi);
 
     void updateMap(Map<u32_t, NumericLiteral>& map, u32_t key, const NumericLiteral& value);
 

package/SVF-linux/Release-build/include/AE/Svfexe/{AbstractExecution.h → AbstractInterpretation.h}

@@ -1,4 +1,4 @@
-//===- AE.cpp -- Abstract Execution---------------------------------//
+//===- AbstractInterpretation.h -- Abstract Execution----------//
 //
 //                     SVF: Static Value-Flow Analysis
 //
@@ -35,10 +35,9 @@
 
 namespace SVF
 {
-class AbstractExecution;
+class AbstractInterpretation;
 class AEStat;
 class AEAPI;
-class IntervalValue;
 class ExeState;
 
 template<typename T> class FILOWorkList;
@@ -54,7 +53,7 @@ class AEStat : public SVFStat
 {
 public:
     void countStateSize();
-    AEStat(AbstractExecution* ae) : _ae(ae)
+    AEStat(AbstractInterpretation* ae) : _ae(ae)
     {
         startTime = getClk(true);
     }
@@ -72,7 +71,7 @@ public:
     void reportBug();
 
 public:
-    AbstractExecution* _ae;
+    AbstractInterpretation* _ae;
     s32_t count{0};
     std::string memory_usage;
     std::string memUsage;
@@ -105,7 +104,8 @@ public:
     }
 };
 
-class AbstractExecution
+/// AbstractInterpretation is same as Abstract Execution
+class AbstractInterpretation
 {
     friend class AEStat;
     friend class AEAPI;
@@ -114,17 +114,17 @@ public:
     enum ExtAPIType { UNCLASSIFIED, MEMCPY, MEMSET, STRCPY, STRCAT };
     typedef SCCDetection<PTACallGraph*> CallGraphSCC;
     /// Constructor
-    AbstractExecution();
+    AbstractInterpretation();
 
     virtual void runOnModule(ICFG* icfg);
 
     /// Destructor
-    virtual ~AbstractExecution();
+    virtual ~AbstractInterpretation();
 
     /// Program entry
     void analyse();
 
-    static bool classof(const AbstractExecution* ae)
+    static bool classof(const AbstractInterpretation* ae)
     {
         return ae->getKind() == AEKind::AbstractExecution;
     }
@@ -155,7 +155,7 @@ protected:
      * @param intraEdge the edge from CmpStmt to the next node
      * @return if this edge is feasible
      */
-    bool hasBranchES(const IntraCFGEdge* intraEdge, IntervalExeState& es);
+    bool hasBranchES(const IntraCFGEdge* intraEdge, SparseAbstractState& es);
 
     /**
      * handle instructions in ICFGNode
@@ -220,7 +220,8 @@ protected:
     * @param succ the value of cmpStmt (True or False)
     * @return if this ICFGNode has preceding execution state
     */
-    bool hasCmpBranchES(const CmpStmt* cmpStmt, s64_t succ, IntervalExeState& es);
+    bool hasCmpBranchES(const CmpStmt* cmpStmt, s64_t succ,
+                        SparseAbstractState& es);
 
     /**
     * Check if this SwitchInst and succ are satisfiable to the execution state.
@@ -229,7 +230,8 @@ protected:
     * @param succ the case value of switch inst
     * @return if this ICFGNode has preceding execution state
     */
-    bool hasSwitchBranchES(const SVFVar* var, s64_t succ, IntervalExeState& es);
+    bool hasSwitchBranchES(const SVFVar* var, s64_t succ,
+                           SparseAbstractState& es);
 
 
     /**
@@ -269,9 +271,9 @@ protected:
     * e.g. source code str = "abc", return 3
     *
     * @param strValue SVFValue of string
-    * @return IntervalValue of string length
+    * @return AbstractValue of string length
     */
-    IntervalValue getStrlen(const SVF::SVFValue *strValue);
+    AbstractValue getStrlen(const SVF::SVFValue *strValue);
 
     /**
     * get memory allocation size
@@ -280,9 +282,9 @@ protected:
     *      memset(arr, 1, 10* sizeof(int))
     * when we trace the 'arr', we can get the alloc size [40, 40]
     * @param value to be traced
-    * @return IntervalValue of allocation size
+    * @return AbstractValue of allocation size
     */
-    IntervalValue traceMemoryAllocationSize(const SVFValue *value);
+    AbstractValue traceMemoryAllocationSize(const SVFValue *value);
     /**
     * execute strcpy in abstract execution
     * e.g  arr = new char[10]
@@ -309,7 +311,7 @@ protected:
     * we can set arr[3]='d', arr[4]='e', arr[5]='\0'
     * @param call callnode of memcpy like api
     */
-    virtual void handleMemcpy(const SVFValue* dst, const SVFValue* src, IntervalValue len, u32_t start_idx);
+    virtual void handleMemcpy(const SVFValue* dst, const SVFValue* src, AbstractValue len, u32_t start_idx);
     /**
     * execute memset in abstract execution
     * e.g  arr = new char[10]
@@ -317,7 +319,7 @@ protected:
     * we can set arr[0]='c', arr[1]='c', arr[2]='\0'
     * @param call callnode of memset like api
     */
-    virtual void handleMemset(const SVFValue* dst, IntervalValue elem, IntervalValue len);
+    virtual void handleMemset(const SVFValue* dst, AbstractValue elem, AbstractValue len);
 
     /**
     * if this NodeID in SVFIR is a pointer, get the pointee type
@@ -373,9 +375,9 @@ private:
 
     // helper functions in handleCycle
     bool widenFixpointPass(const ICFGNode* cycle_head,
-                           IntervalExeState& pre_es);
+                           SparseAbstractState& pre_es);
     bool narrowFixpointPass(const ICFGNode* cycle_head,
-                            IntervalExeState& pre_es);
+                            SparseAbstractState& pre_es);
 
 protected:
     // there data should be shared with subclasses
@@ -384,8 +386,8 @@ protected:
     Set<std::string> _checkpoint_names;
 
 private:
-    Map<const ICFGNode*, IntervalExeState> _preES;
-    Map<const ICFGNode*, IntervalExeState> _postES;
+    Map<const ICFGNode*, SparseAbstractState> _preAbstractTrace;
+    Map<const ICFGNode*, SparseAbstractState> _postAbstractTrace;
     std::string _moduleName;
 };
 }

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

@@ -28,7 +28,7 @@
 // Created by Jiawei Wang on 2024/1/12.
 //
 
-#include "AE/Svfexe/AbstractExecution.h"
+#include "AE/Svfexe/AbstractInterpretation.h"
 
 namespace SVF
 {
@@ -100,17 +100,17 @@ protected:
     const SVFValue* _allocVar;
 };
 
-class BufOverflowChecker: public AbstractExecution
+class BufOverflowChecker: public AbstractInterpretation
 {
 public:
-    BufOverflowChecker() : AbstractExecution()
+    BufOverflowChecker() : AbstractInterpretation()
     {
         initExtFunMap();
         _kind = AEKind::BufOverflowChecker;
         initExtAPIBufOverflowCheckRules();
     }
 
-    static bool classof(const AbstractExecution* ae)
+    static bool classof(const AbstractInterpretation* ae)
     {
         return ae->getKind() == AEKind::BufOverflowChecker;
     }
@@ -164,7 +164,7 @@ protected:
      * @param len the length of the buffer overflow checkpoint
      * @return true if the buffer overflow is detected
      */
-    bool canSafelyAccessMemory(const SVFValue *value, const IntervalValue &len, const ICFGNode *curNode);
+    bool canSafelyAccessMemory(const SVFValue *value, const AbstractValue &len, const ICFGNode *curNode);
 
 private:
     /**

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

@@ -33,9 +33,8 @@
 #ifndef Z3_EXAMPLE_SVFIR2ITVEXESTATE_H
 #define Z3_EXAMPLE_SVFIR2ITVEXESTATE_H
 
+#include "AE/Core/AbstractState.h"
 #include "AE/Core/ExeState.h"
-#include "AE/Core/IntervalExeState.h"
-#include "AE/Core/IntervalValue.h"
 #include "AE/Core/RelExeState.h"
 #include "SVFIR/SVFIR.h"
 
@@ -44,17 +43,16 @@ namespace SVF
 class SVFIR2ItvExeState
 {
 public:
-    typedef ExeState::Addrs Addrs;
-    static Addrs globalNulladdrs;
+    static AbstractValue globalNulladdrs;
 public:
     SVFIR2ItvExeState(SVFIR *ir) : _svfir(ir) {}
 
-    void setEs(const IntervalExeState &es)
+    void setEs(const SparseAbstractState&es)
     {
         _es = es;
     }
 
-    IntervalExeState &getEs()
+    SparseAbstractState&getEs()
     {
         return _es;
     }
@@ -69,34 +67,34 @@ public:
         return _relEs;
     }
 
-    void widenAddrs(IntervalExeState &lhs, const IntervalExeState &rhs);
+    void widenAddrs(SparseAbstractState&lhs, const SparseAbstractState&rhs);
 
-    void narrowAddrs(IntervalExeState &lhs, const IntervalExeState &rhs);
+    void narrowAddrs(SparseAbstractState&lhs, const SparseAbstractState&rhs);
 
     /// Return the field address given a pointer points to a struct object and an offset
-    Addrs getGepObjAddress(u32_t pointer, APOffset offset);
+    AbstractValue getGepObjAddress(u32_t pointer, APOffset offset);
 
     /// Return the value range of Integer SVF Type, e.g. unsigned i8 Type->[0, 255], signed i8 Type->[-128, 127]
-    IntervalValue getRangeLimitFromType(const SVFType* type);
+    AbstractValue getRangeLimitFromType(const SVFType* type);
 
-    IntervalValue getZExtValue(const SVFVar* var);
-    IntervalValue getSExtValue(const SVFVar* var);
-    IntervalValue getFPToSIntValue(const SVFVar* var);
-    IntervalValue getFPToUIntValue(const SVFVar* var);
-    IntervalValue getSIntToFPValue(const SVFVar* var);
-    IntervalValue getUIntToFPValue(const SVFVar* var);
-    IntervalValue getTruncValue(const SVFVar* var, const SVFType* dstType);
-    IntervalValue getFPTruncValue(const SVFVar* var, const SVFType* dstType);
+    AbstractValue getZExtValue(const SVFVar* var);
+    AbstractValue getSExtValue(const SVFVar* var);
+    AbstractValue getFPToSIntValue(const SVFVar* var);
+    AbstractValue getFPToUIntValue(const SVFVar* var);
+    AbstractValue getSIntToFPValue(const SVFVar* var);
+    AbstractValue getUIntToFPValue(const SVFVar* var);
+    AbstractValue getTruncValue(const SVFVar* var, const SVFType* dstType);
+    AbstractValue getFPTruncValue(const SVFVar* var, const SVFType* dstType);
 
     /// Return the byte offset expression of a GepStmt
     /// elemBytesize is the element byte size of an static alloc or heap alloc array
     /// e.g. GepStmt* gep = [i32*10], x, and x is [0,3]
     /// std::pair<s32_t, s32_t> byteOffset = getByteOffset(gep);
     /// byteOffset should be [0, 12] since i32 is 4 bytes.
-    IntervalValue getByteOffset(const GepStmt *gep);
+    AbstractValue getByteOffset(const GepStmt *gep);
 
     /// Return the offset expression of a GepStmt
-    IntervalValue getItvOfFlattenedElemIndex(const GepStmt *gep);
+    AbstractValue getItvOfFlattenedElemIndex(const GepStmt *gep);
 
 
     static z3::context &getContext()
@@ -104,7 +102,7 @@ public:
         return Z3Expr::getContext();
     }
 
-    void applySummary(IntervalExeState &es);
+    void applySummary(SparseAbstractState&es);
 
 
     /// Init ObjVar
@@ -113,7 +111,7 @@ public:
     /// Init SVFVar
     void initSVFVar(u32_t varId);
 
-    inline Addrs &getAddrs(u32_t id)
+    inline AbstractValue &getAddrs(u32_t id)
     {
         if (inVarToAddrsTable(id))
             return _es.getAddrs(id);
@@ -211,11 +209,11 @@ protected:
 
 private:
     SVFIR *_svfir;
-    IntervalExeState _es;
+    SparseAbstractState _es;
     RelExeState _relEs;
 
-    Map<NodeID, IntervalExeState *> _br_cond;
-    IntervalValue getZExtValue(const SVFVar* var, const SVFType*);
+    Map<NodeID, SparseAbstractState*> _br_cond;
+    AbstractValue getZExtValue(const SVFVar* var, const SVFType*);
 };
 }
 

package/package.json

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