svf-lib 1.0.1998 → 1.0.2000

package/SVF-osx/Release-build/include/AE/Core/AbstractValue.h

@@ -168,317 +168,36 @@ public:
     AbstractValue(const IntervalValue& ival) : type(IntervalType), interval(ival) {}
 
     AbstractValue(const AddressValue& addr) : type(AddressType), addr(addr) {}
-    // TODO: move constructor
+
     IntervalValue& getInterval()
     {
         if (isUnknown())
         {
             interval = IntervalValue::top();
         }
-        assert(isInterval());
+        assert(isInterval() && "Attempting to retrieve an AbstractValue that is not an Interval!");
         return interval;
     }
 
-    //
     const IntervalValue getInterval() const
     {
-        assert(isInterval());
+        assert(isInterval() && "Attempting to retrieve an AbstractValue that is not an Interval!");
         return interval;
     }
 
     AddressValue& getAddrs()
     {
-        assert(isAddr());
+        assert(isAddr() && "Attempting to retrieve an AbstractValue that is not an Address!");
         return addr;
     }
 
     const AddressValue getAddrs() const
     {
-        assert(isAddr());
+        assert(isAddr() && "Attempting to retrieve an AbstractValue that is not an Address!");
         return addr;
     }
-    ~AbstractValue() {};
-
-
-    // interval visit funcs
-    bool isTop() const
-    {
-        assert(isInterval());
-        return interval.isTop();
-    }
-
-    bool isBottom() const
-    {
-        assert(isInterval());
-        return interval.isBottom();
-    }
-
-    const BoundedInt& lb() const
-    {
-        assert(isInterval());
-        return interval.lb();
-    }
-
-    const BoundedInt& ub() const
-    {
-        assert(isInterval());
-        return interval.ub();
-    }
-
-    void setLb(const BoundedInt& lb)
-    {
-        assert(isInterval());
-        interval.setLb(lb);
-    }
-
-    void setUb(const BoundedInt& ub)
-    {
-        assert(isInterval());
-        interval.setUb(ub);
-    }
-
-    void setValue(const BoundedInt &lb, const BoundedInt &ub)
-    {
-        assert(isInterval());
-        interval.setValue(lb, ub);
-    }
-
-    bool is_zero() const
-    {
-        assert(isInterval());
-        return interval.is_zero();
-    }
-
-    bool is_infinite() const
-    {
-        assert(isInterval());
-        return interval.is_infinite();
-    }
-
-    bool is_int() const
-    {
-        assert(isInterval());
-        return interval.is_int();
-    }
-
-    bool is_real() const
-    {
-        assert(isInterval());
-        return interval.is_real();
-    }
-
-    s64_t getIntNumeral() const
-    {
-        assert(isInterval());
-        return interval.getIntNumeral();
-    }
-
-    double getRealNumeral() const
-    {
-        assert(isInterval());
-        return interval.getRealNumeral();
-    }
-
-    bool is_numeral() const
-    {
-        assert(isInterval());
-        return interval.is_numeral();
-    }
-
-    void set_to_bottom()
-    {
-        assert(isInterval());
-        interval.set_to_bottom();
-    }
-
-    void set_to_top()
-    {
-        assert(isInterval());
-        interval.set_to_top();
-    }
 
-    bool leq(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval.leq(other.interval);
-    }
-
-    bool geq(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval.geq(other.interval);
-    }
-
-    bool contains(s64_t n) const
-    {
-        assert(isInterval());
-        return interval.contains(n);
-    }
-    // operator +-*/%>< >= <= << >> & | ^
-    AbstractValue operator+(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval + other.interval;
-    }
-    AbstractValue operator+(const IntervalValue &other) const
-    {
-        assert(isInterval());
-        return interval + other;
-    }
-
-    AbstractValue operator-(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval - other.interval;
-    }
-    AbstractValue operator-(const IntervalValue &other) const
-    {
-        assert(isInterval());
-        return interval - other;
-    }
-
-    AbstractValue operator*(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval * other.interval;
-    }
-    AbstractValue operator*(const IntervalValue &other) const
-    {
-        assert(isInterval());
-        return interval * other;
-    }
-
-    AbstractValue operator/(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval / other.interval;
-    }
-    AbstractValue operator/(const IntervalValue &other) const
-    {
-        assert(isInterval());
-        return interval / other;
-    }
-
-    AbstractValue operator%(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval % other.interval;
-    }
-    AbstractValue operator%(const IntervalValue &other) const
-    {
-        assert(isInterval());
-        return interval % other;
-    }
-
-    AbstractValue operator>>(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval >> other.interval;
-    }
-    AbstractValue operator>>(const IntervalValue &other) const
-    {
-        assert(isInterval());
-        return interval >> other;
-    }
-
-    AbstractValue operator<<(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval << other.interval;
-    }
-    AbstractValue operator<<(const IntervalValue &other) const
-    {
-        assert(isInterval());
-        return interval << other;
-    }
-
-    AbstractValue operator&(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval & other.interval;
-    }
-    AbstractValue operator&(const IntervalValue &other) const
-    {
-        assert(isInterval());
-        return interval & other;
-    }
-
-    AbstractValue operator|(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval | other.interval;
-    }
-    AbstractValue operator|(const IntervalValue &other) const
-    {
-        assert(isInterval());
-        return interval | other;
-    }
-
-    AbstractValue operator^(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval ^ other.interval;
-    }
-    AbstractValue operator^(const IntervalValue &other) const
-    {
-        assert(isInterval());
-        return interval ^ other;
-    }
-
-    AbstractValue operator>(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval > other.interval;
-    }
-    AbstractValue operator>(const IntervalValue &other) const
-    {
-        assert(isInterval());
-        return interval > other;
-    }
-
-    AbstractValue operator<(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval < other.interval;
-    }
-    AbstractValue operator<(const IntervalValue &other) const
-    {
-        assert(isInterval());
-        return interval < other;
-    }
-
-    AbstractValue operator>=(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval >= other.interval;
-    }
-    AbstractValue operator>=(const IntervalValue &other) const
-    {
-        assert(isInterval());
-        return interval >= other;
-    }
-
-    AbstractValue operator<=(const AbstractValue &other) const
-    {
-        assert(isInterval() && other.isInterval());
-        return interval <= other.interval;
-    }
-    AbstractValue operator<=(const IntervalValue &other) const
-    {
-        assert(isInterval());
-        return interval <= other;
-    }
-
-
-    // address visit funcs
-    std::pair<AddressValue::AddrSet::iterator, bool> insertAddr(u32_t id)   // insertAddr
-    {
-        assert(isAddr());
-        return addr.insert(id);
-    }
-
-    // TODO: equals, join_with, meet_with, widen_with, narrow_with, toString,
-    // These should be merged with AddressValue
+    ~AbstractValue() {};
 
     bool equals(const AbstractValue &rhs) const
     {

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

@@ -264,9 +264,9 @@ protected:
     * e.g. source code str = "abc", return 3
     *
     * @param strValue SVFValue of string
-    * @return AbstractValue of string length
+    * @return IntervalValue of string length
     */
-    AbstractValue getStrlen(AbstractState& as, const SVF::SVFValue *strValue);
+    IntervalValue getStrlen(AbstractState& as, const SVF::SVFValue *strValue);
 
     /**
     * get memory allocation size
@@ -275,9 +275,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 AbstractValue of allocation size
+    * @return IntervalValue of allocation size
     */
-    AbstractValue traceMemoryAllocationSize(AbstractState& as, const SVFValue *value);
+    IntervalValue traceMemoryAllocationSize(AbstractState& as, const SVFValue *value);
     /**
     * execute strcpy in abstract execution
     * e.g  arr = new char[10]
@@ -304,7 +304,7 @@ protected:
     * we can set arr[3]='d', arr[4]='e', arr[5]='\0'
     * @param call callnode of memcpy like api
     */
-    virtual void handleMemcpy(AbstractState& as, const SVFValue* dst, const SVFValue* src, AbstractValue len, u32_t start_idx);
+    virtual void handleMemcpy(AbstractState& as, const SVFValue* dst, const SVFValue* src, IntervalValue len, u32_t start_idx);
     /**
     * execute memset in abstract execution
     * e.g  arr = new char[10]
@@ -312,7 +312,7 @@ protected:
     * we can set arr[0]='c', arr[1]='c', arr[2]='\0'
     * @param call callnode of memset like api
     */
-    virtual void handleMemset(AbstractState& as, const SVFValue* dst, AbstractValue elem, AbstractValue len);
+    virtual void handleMemset(AbstractState& as, const SVFValue* dst, IntervalValue elem, IntervalValue len);
 
     /**
     * if this NodeID in SVFIR is a pointer, get the pointee type

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

@@ -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 AbstractValue &len, const ICFGNode *curNode);
+    bool canSafelyAccessMemory(const SVFValue *value, const IntervalValue &len, const ICFGNode *curNode);
 
 private:
     /**

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

@@ -81,10 +81,10 @@ public:
     /// 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.
-    AbstractValue getByteOffset(const AbstractState& es, const GepStmt *gep);
+    IntervalValue getByteOffset(const AbstractState& es, const GepStmt *gep);
 
     /// Return the offset expression of a GepStmt
-    AbstractValue getElementIndex(const AbstractState& es, const GepStmt *gep);
+    IntervalValue getElementIndex(const AbstractState& es, const GepStmt *gep);
 
 
     static z3::context &getContext()

package/package.json

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