svf-lib 1.0.2010 → 1.0.2011

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

@@ -183,20 +183,6 @@ 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
     {
@@ -289,31 +275,6 @@ public:
         return (s32_t) e.lb().getNumeral();
     }
 
-    /// Return true if map has bottom value
-    inline bool has_bottom()
-    {
-        for (auto it = _varToAbsVal.begin(); it != _varToAbsVal.end(); ++it)
-        {
-            if (it->second.isInterval())
-            {
-                if (it->second.getInterval().isBottom())
-                {
-                    return true;
-                }
-            }
-        }
-        for (auto it = _addrToAbsVal.begin(); it != _addrToAbsVal.end(); ++it)
-        {
-            if (it->second.isInterval())
-            {
-                if (it->second.getInterval().isBottom())
-                {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
 
     u32_t hash() const;
 
@@ -330,14 +291,8 @@ public:
     {
         assert(isVirtualMemAddress(addr) && "not virtual address?");
         u32_t objId = getInternalID(addr);
-        auto it = _addrToAbsVal.find(objId);
-        if(it != _addrToAbsVal.end())
-            return it->second;
-        else
-        {
-            _addrToAbsVal[objId] = IntervalValue::top();
-            return _addrToAbsVal[objId];
-        }
+        return _addrToAbsVal[objId];
+
     }
 
 
@@ -351,6 +306,7 @@ public:
 
     bool equals(const AbstractState&other) const;
 
+
     static bool eqVarToValMap(const VarToAbsValMap&lhs, const VarToAbsValMap&rhs)
     {
         if (lhs.size() != rhs.size()) return false;
@@ -359,32 +315,15 @@ public:
             auto it = rhs.find(item.first);
             if (it == rhs.end())
                 return false;
-            if (item.second.getType() == it->second.getType())
-            {
-                if (item.second.isInterval())
-                {
-                    if (!item.second.getInterval().equals(it->second.getInterval()))
-                    {
-                        return false;
-                    }
-                }
-                else if (item.second.isAddr())
-                {
-                    if (!item.second.getAddrs().equals(it->second.getAddrs()))
-                    {
-                        return false;
-                    }
-                }
-            }
+            if (!item.second.equals(it->second))
+                return false;
             else
             {
-                return false;
             }
         }
         return true;
     }
 
-
     static bool lessThanVarToValMap(const VarToAbsValMap&lhs, const VarToAbsValMap&rhs)
     {
         if (lhs.empty()) return !rhs.empty();
@@ -407,12 +346,9 @@ public:
             auto it = lhs.find(item.first);
             if (it == lhs.end()) return false;
             // judge from expr id
-            if (it->second.isInterval() && item.second.isInterval())
-            {
-                if (!it->second.getInterval().contain(
-                            item.second.getInterval()))
-                    return false;
-            }
+            if (!it->second.getInterval().contain(
+                        item.second.getInterval()))
+                return false;
 
         }
         return true;

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

@@ -22,6 +22,7 @@
 
 #include "AE/Core/IntervalValue.h"
 #include "AE/Core/AddressValue.h"
+#include "Util/SVFUtil.h"
 
 namespace SVF
 {
@@ -30,126 +31,71 @@ class AbstractValue
 {
 
 public:
-
-    enum DataType
-    {
-        IntervalType,
-        AddressType,
-        UnknownType,
-    };
-    DataType type;
     IntervalValue interval;
     AddressValue addrs;
 
-    AbstractValue() : type(IntervalType)
-    {
-        interval = IntervalValue::top();
-    }
-    AbstractValue(DataType type) : type(type)
+    AbstractValue()
     {
-        switch (type)
-        {
-        case IntervalType:
-            interval = IntervalValue::top();
-            break;
-        case AddressType:
-            addrs = AddressValue();
-            break;
-        case UnknownType:
-            break;
-        }
+        interval = IntervalValue::bottom();
+        addrs = AddressValue();
     }
 
-    AbstractValue(const AbstractValue& other): type(other.type)
+    AbstractValue(const AbstractValue& other)
     {
-        switch (type)
-        {
-        case IntervalType:
-            interval = other.interval;
-            break;
-        case AddressType:
-            addrs = other.addrs;
-            break;
-        case UnknownType:
-            break;
-        }
+        interval = other.interval;
+        addrs = other.addrs;
     }
 
     inline bool isInterval() const
     {
-        return type == IntervalType;
+        return !interval.isBottom();
     }
     inline bool isAddr() const
     {
-        return type == AddressType;
-    }
-    inline bool isUnknown() const
-    {
-        return type == UnknownType;
+        return !addrs.isBottom();
     }
 
-    inline DataType getType() const
+    AbstractValue(AbstractValue &&other)
     {
-        return type;
+        interval = SVFUtil::move(other.interval);
+        addrs = SVFUtil::move(other.addrs);
     }
 
-    AbstractValue(AbstractValue &&other) : type(other.type)
+    // operator overload, supporting both interval and address
+    AbstractValue& operator=(const AbstractValue& other)
     {
-        switch (type)
-        {
-        case IntervalType:
-            interval = other.interval;
-            break;
-        case AddressType:
-            addrs = other.addrs;
-            break;
-        case UnknownType:
-            break;
-        }
+        interval = other.interval;
+        addrs = other.addrs;
+        return *this;
     }
 
-    // operator overload, supporting both interval and address
-    AbstractValue& operator=(const AbstractValue& other)
+    AbstractValue& operator=(const AbstractValue&& other)
     {
-        type = other.type;
-        switch (type)
-        {
-        case IntervalType:
-            interval = other.interval;
-            break;
-        case AddressType:
-            addrs = other.addrs;
-            break;
-        case UnknownType:
-            break;
-        }
+        interval = SVFUtil::move(other.interval);
+        addrs = SVFUtil::move(other.addrs);
         return *this;
     }
 
     AbstractValue& operator=(const IntervalValue& other)
     {
-        type = IntervalType;
         interval = other;
+        addrs = AddressValue();
         return *this;
     }
 
     AbstractValue& operator=(const AddressValue& other)
     {
-        type = AddressType;
         addrs = other;
+        interval = IntervalValue::bottom();
         return *this;
     }
 
-    AbstractValue(const IntervalValue& ival) : type(IntervalType), interval(ival) {}
+    AbstractValue(const IntervalValue& ival) : interval(ival), addrs(AddressValue()) {}
 
-    AbstractValue(const AddressValue& addr) : type(AddressType), addrs(addr) {}
+    AbstractValue(const AddressValue& addr) : interval(IntervalValue::bottom()), addrs(addr) {}
 
     IntervalValue& getInterval()
     {
-        if (isUnknown())
-        {
-            interval = IntervalValue::top();
-        }
         return interval;
     }
 
@@ -172,90 +118,36 @@ public:
 
     bool equals(const AbstractValue &rhs) const
     {
-        if (type != rhs.type)
-        {
-            return false;
-        }
-        if (isInterval())
-        {
-            return interval.equals(rhs.interval);
-        }
-        if (isAddr())
-        {
-            return addrs.equals(rhs.addrs);
-        }
-        return false;
+        return interval.equals(rhs.interval) && addrs.equals(rhs.addrs);
     }
 
     void join_with(const AbstractValue &other)
     {
-        if (isUnknown())
-        {
-            *this = other;
-            return;
-        }
-        else if (type != other.type)
-        {
-            return;
-        }
-        if (isInterval() && other.isInterval())
-        {
-            interval.join_with(other.interval);
-        }
-        if (isAddr() && other.isAddr())
-        {
-            addrs.join_with(other.addrs);
-        }
-        return;
+        interval.join_with(other.interval);
+        addrs.join_with(other.addrs);
     }
 
     void meet_with(const AbstractValue &other)
     {
-        if (type != other.type)
-        {
-            return;
-        }
-        if (isInterval() && other.isInterval())
-        {
-            interval.meet_with(other.interval);
-        }
-        if (isAddr() && other.isAddr())
-        {
-            addrs.meet_with(other.addrs);
-        }
-        return;
+        interval.meet_with(other.interval);
+        addrs.meet_with(other.addrs);
     }
 
     void widen_with(const AbstractValue &other)
     {
-        // widen_with only in interval
-        if (isInterval() && other.isInterval())
-        {
-            interval.widen_with(other.interval);
-        }
+        interval.widen_with(other.interval);
+        // TODO: widen Addrs
     }
 
     void narrow_with(const AbstractValue &other)
     {
-        // narrow_with only in interval
-        if (isInterval() && other.isInterval())
-        {
-            interval.narrow_with(other.interval);
-        }
+        interval.narrow_with(other.interval);
+        // TODO: narrow Addrs
     }
 
     std::string toString() const
     {
-        if (isInterval())
-        {
-            return interval.toString();
-        }
-        else if (isAddr())
-        {
-            return addrs.toString();
-        }
-        return "";
+        return "<" + interval.toString() + ", " + addrs.toString() + ">";
     }
-
 };
 }

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

@@ -62,19 +62,19 @@ public:
     void narrowAddrs(AbstractState& es, AbstractState&lhs, const AbstractState&rhs);
 
     /// Return the field address given a pointer points to a struct object and an offset
-    AbstractValue getGepObjAddress(AbstractState& es, u32_t pointer, APOffset offset);
+    AddressValue getGepObjAddress(AbstractState& es, 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]
-    AbstractValue getRangeLimitFromType(const SVFType* type);
+    IntervalValue getRangeLimitFromType(const SVFType* type);
 
-    AbstractValue getZExtValue(const AbstractState& es, const SVFVar* var);
-    AbstractValue getSExtValue(const AbstractState& es, const SVFVar* var);
-    AbstractValue getFPToSIntValue(const AbstractState& es, const SVFVar* var);
-    AbstractValue getFPToUIntValue(const AbstractState& es, const SVFVar* var);
-    AbstractValue getSIntToFPValue(const AbstractState& es, const SVFVar* var);
-    AbstractValue getUIntToFPValue(const AbstractState& es, const SVFVar* var);
-    AbstractValue getTruncValue(const AbstractState& es, const SVFVar* var, const SVFType* dstType);
-    AbstractValue getFPTruncValue(const AbstractState& es, const SVFVar* var, const SVFType* dstType);
+    IntervalValue getZExtValue(const AbstractState& es, const SVFVar* var);
+    IntervalValue getSExtValue(const AbstractState& es, const SVFVar* var);
+    IntervalValue getFPToSIntValue(const AbstractState& es, const SVFVar* var);
+    IntervalValue getFPToUIntValue(const AbstractState& es, const SVFVar* var);
+    IntervalValue getSIntToFPValue(const AbstractState& es, const SVFVar* var);
+    IntervalValue getUIntToFPValue(const AbstractState& es, const SVFVar* var);
+    IntervalValue getTruncValue(const AbstractState& es, const SVFVar* var, const SVFType* dstType);
+    IntervalValue getFPTruncValue(const AbstractState& es, 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
@@ -102,7 +102,7 @@ public:
     inline AbstractValue &getAddrs(AbstractState& es, u32_t id)
     {
         if (inVarToAddrsTable(es, id))
-            return es.getAddrs(id);
+            return es[id];
         else
             return globalNulladdrs;
     }

package/package.json

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