svf-tools 1.0.943 → 1.0.944

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.943",
+  "version": "1.0.944",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf/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/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/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/svf/lib/AE/Core/AbstractState.cpp

@@ -125,18 +125,7 @@ void AbstractState::joinWith(const AbstractState& other)
         auto oit = _varToAbsVal.find(key);
         if (oit != _varToAbsVal.end())
         {
-            if (oit->second.isInterval() && it->second.isInterval())
-            {
-                oit->second.getInterval().join_with(it->second.getInterval());
-            }
-            else if (oit->second.isAddr() && it->second.isAddr())
-            {
-                oit->second.getAddrs().join_with(it->second.getAddrs());
-            }
-            else
-            {
-                // do nothing
-            }
+            oit->second.join_with(it->second);
         }
         else
         {
@@ -149,18 +138,7 @@ void AbstractState::joinWith(const AbstractState& other)
         auto oit = _addrToAbsVal.find(key);
         if (oit != _addrToAbsVal.end())
         {
-            if (oit->second.isInterval() && it->second.isInterval())
-            {
-                oit->second.getInterval().join_with(it->second.getInterval());
-            }
-            else if (oit->second.isAddr() && it->second.isAddr())
-            {
-                oit->second.getAddrs().join_with(it->second.getAddrs());
-            }
-            else
-            {
-                // do nothing
-            }
+            oit->second.join_with(it->second);
         }
         else
         {
@@ -199,18 +177,7 @@ void AbstractState::meetWith(const AbstractState& other)
         auto oit = _varToAbsVal.find(key);
         if (oit != _varToAbsVal.end())
         {
-            if (oit->second.isInterval() && it->second.isInterval())
-            {
-                oit->second.getInterval().meet_with(it->second.getInterval());
-            }
-            else if (oit->second.isAddr() && it->second.isAddr())
-            {
-                oit->second.getAddrs().meet_with(it->second.getAddrs());
-            }
-            else
-            {
-                // do nothing
-            }
+            oit->second.meet_with(it->second);
         }
     }
     for (auto it = other._addrToAbsVal.begin(); it != other._addrToAbsVal.end(); ++it)
@@ -219,18 +186,7 @@ void AbstractState::meetWith(const AbstractState& other)
         auto oit = _addrToAbsVal.find(key);
         if (oit != _addrToAbsVal.end())
         {
-            if (oit->second.isInterval() && it->second.isInterval())
-            {
-                oit->second.getInterval().meet_with(it->second.getInterval());
-            }
-            else if (oit->second.isAddr() && it->second.isAddr())
-            {
-                oit->second.getAddrs().meet_with(it->second.getAddrs());
-            }
-            else
-            {
-                // do nothing
-            }
+            oit->second.meet_with(it->second);
         }
     }
 }
@@ -255,15 +211,6 @@ void AbstractState::printTable(const VarToAbsValMap&table, std::ostream &oss) co
     for (const auto &item: ordered)
     {
         oss << "Var" << std::to_string(item);
-        if (table.at(item).isInterval())
-        {
-            IntervalValue sim = table.at(item).getInterval();
-            oss << "\t Value: " << std::dec << sim << "\n";
-        }
-        else if (table.at(item).isAddr())
-        {
-            AbstractValue sim = table.at(item);
-            oss << "\t Value: " << sim.getAddrs().toString() << "\n";
-        }
+        oss << "\t Value: " << table.at(item).toString() << "\n";
     }
 }

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

@@ -331,7 +331,7 @@ bool AbstractInterpretation::isCmpBranchFeasible(const CmpStmt* cmpStmt, s64_t s
     // change interval range according to the compare predicate
     AddressValue addrs;
     if(load_op0 && new_es.inVarToAddrsTable(load_op0->getRHSVarID()))
-        addrs = new_es.getAddrs(load_op0->getRHSVarID()).getAddrs();
+        addrs = new_es[load_op0->getRHSVarID()].getAddrs();
 
     IntervalValue &lhs = new_es[op0].getInterval(), &rhs = new_es[op1].getInterval();
     switch (predicate)
@@ -472,7 +472,7 @@ bool AbstractInterpretation::isSwitchBranchFeasible(const SVFVar* var, s64_t suc
         {
             if (new_es.inVarToAddrsTable(load->getRHSVarID()))
             {
-                AddressValue &addrs = new_es.getAddrs(load->getRHSVarID()).getAddrs();
+                AddressValue &addrs = new_es[load->getRHSVarID()].getAddrs();
                 for (const auto &addr: addrs)
                 {
                     NodeID objId = new_es.getInternalID(addr);
@@ -930,7 +930,7 @@ void AbstractInterpretation::SkipRecursiveCall(const CallICFGNode *callNode)
                     {
                         if (!rhsVar->isPointer() && !rhsVar->isConstDataOrAggDataButNotNullPtr())
                         {
-                            const AbstractValue &addrs = as.getAddrs(lhs);
+                            const AbstractValue &addrs = as[lhs];
                             for (const auto &addr: addrs.getAddrs())
                             {
                                 as.store(addr, IntervalValue::top());
@@ -1147,13 +1147,11 @@ std::string AbstractInterpretation::strRead(AbstractState& as, const SVFValue* r
         if (!as.inVarToAddrsTable(_svfir->getValueNode(rhs))) continue;
         AbstractValue expr0 =
             _svfir2AbsState->getGepObjAddress(as, _svfir->getValueNode(rhs), index);
-        AbstractValue val(AbstractValue::UnknownType);
+        AbstractValue val;
         for (const auto &addr: expr0.getAddrs())
         {
             val.join_with(as.load(addr));
         }
-        if (val.isUnknown())
-            return str0;
         if (!val.getInterval().is_numeral())
         {
             break;
@@ -1464,15 +1462,11 @@ IntervalValue AbstractInterpretation::getStrlen(AbstractState& as, const SVF::SV
         {
             AbstractValue expr0 =
                 _svfir2AbsState->getGepObjAddress(as, dstid, index);
-            AbstractValue val(AbstractValue::UnknownType);
+            AbstractValue val;
             for (const auto &addr: expr0.getAddrs())
             {
                 val.join_with(as.load(addr));
             }
-            if (val.isUnknown())
-            {
-                return IntervalValue((s64_t)0, (s64_t)Options::MaxFieldLimit());
-            }
             if (val.getInterval().is_numeral() && (char) val.getInterval().getIntNumeral() == '\0')
             {
                 break;

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

@@ -46,7 +46,7 @@ AbstractValue SVF::SVFIR2AbsState::globalNulladdrs = AddressValue();
  *
  * @return       An IntervalValue representing the lower and upper bounds of the range.
  */
-AbstractValue SVFIR2AbsState::getRangeLimitFromType(const SVFType* type)
+IntervalValue SVFIR2AbsState::getRangeLimitFromType(const SVFType* type)
 {
     if (const SVFIntegerType* intType = SVFUtil::dyn_cast<SVFIntegerType>(type))
     {
@@ -108,7 +108,7 @@ AbstractValue SVFIR2AbsState::getRangeLimitFromType(const SVFType* type)
     }
 }
 
-AbstractValue SVFIR2AbsState::getZExtValue(const AbstractState& as, const SVFVar* var)
+IntervalValue SVFIR2AbsState::getZExtValue(const AbstractState& as, const SVFVar* var)
 {
     const SVFType* type = var->getType();
     if (SVFUtil::isa<SVFIntegerType>(type))
@@ -153,12 +153,12 @@ AbstractValue SVFIR2AbsState::getZExtValue(const AbstractState& as, const SVFVar
     return IntervalValue::top(); // TODO: may have better solution
 }
 
-AbstractValue SVFIR2AbsState::getSExtValue(const AbstractState& as, const SVFVar* var)
+IntervalValue SVFIR2AbsState::getSExtValue(const AbstractState& as, const SVFVar* var)
 {
     return as[var->getId()].getInterval();
 }
 
-AbstractValue SVFIR2AbsState::getFPToSIntValue(const AbstractState& as, const SVF::SVFVar* var)
+IntervalValue SVFIR2AbsState::getFPToSIntValue(const AbstractState& as, const SVF::SVFVar* var)
 {
     if (as[var->getId()].getInterval().is_real())
     {
@@ -176,7 +176,7 @@ AbstractValue SVFIR2AbsState::getFPToSIntValue(const AbstractState& as, const SV
     }
 }
 
-AbstractValue SVFIR2AbsState::getFPToUIntValue(const AbstractState& as, const SVF::SVFVar* var)
+IntervalValue SVFIR2AbsState::getFPToUIntValue(const AbstractState& as, const SVF::SVFVar* var)
 {
     if (as[var->getId()].getInterval().is_real())
     {
@@ -194,7 +194,7 @@ AbstractValue SVFIR2AbsState::getFPToUIntValue(const AbstractState& as, const SV
     }
 }
 
-AbstractValue SVFIR2AbsState::getSIntToFPValue(const AbstractState& as, const SVF::SVFVar* var)
+IntervalValue SVFIR2AbsState::getSIntToFPValue(const AbstractState& as, const SVF::SVFVar* var)
 {
     // get the sint value of ub and lb
     s64_t sint_lb = as[var->getId()].getInterval().lb().getIntNumeral();
@@ -205,7 +205,7 @@ AbstractValue SVFIR2AbsState::getSIntToFPValue(const AbstractState& as, const SV
     return IntervalValue(float_lb, float_ub);
 }
 
-AbstractValue SVFIR2AbsState::getUIntToFPValue(const AbstractState& as, const SVF::SVFVar* var)
+IntervalValue SVFIR2AbsState::getUIntToFPValue(const AbstractState& as, const SVF::SVFVar* var)
 {
     // get the uint value of ub and lb
     u64_t uint_lb = as[var->getId()].getInterval().lb().getIntNumeral();
@@ -216,7 +216,7 @@ AbstractValue SVFIR2AbsState::getUIntToFPValue(const AbstractState& as, const SV
     return IntervalValue(float_lb, float_ub);
 }
 
-AbstractValue SVFIR2AbsState::getTruncValue(const AbstractState& as, const SVF::SVFVar* var, const SVFType* dstType)
+IntervalValue SVFIR2AbsState::getTruncValue(const AbstractState& as, const SVF::SVFVar* var, const SVFType* dstType)
 {
     // get the value of ub and lb
     s64_t int_lb = as[var->getId()].getInterval().lb().getIntNumeral();
@@ -265,7 +265,7 @@ AbstractValue SVFIR2AbsState::getTruncValue(const AbstractState& as, const SVF::
     }
 }
 
-AbstractValue SVFIR2AbsState::getFPTruncValue(const AbstractState& as, const SVF::SVFVar* var, const SVFType* dstType)
+IntervalValue SVFIR2AbsState::getFPTruncValue(const AbstractState& as, const SVF::SVFVar* var, const SVFType* dstType)
 {
     // TODO: now we do not really handle fptrunc
     return as[var->getId()].getInterval();
@@ -357,7 +357,7 @@ void SVFIR2AbsState::narrowAddrs(AbstractState& as, AbstractState&lhs, const Abs
     }
 }
 
-AbstractValue SVFIR2AbsState::getGepObjAddress(AbstractState& as, u32_t pointer, APOffset offset)
+AddressValue SVFIR2AbsState::getGepObjAddress(AbstractState& as, u32_t pointer, APOffset offset)
 {
     AbstractValue addrs = getAddrs(as, pointer);
     AddressValue ret = AddressValue();
@@ -573,25 +573,9 @@ void SVFIR2AbsState::initObjVar(AbstractState& as, const ObjVar* var)
 void SVFIR2AbsState::handleAddr(AbstractState& as, const AddrStmt *addr)
 {
     initObjVar(as, SVFUtil::cast<ObjVar>(addr->getRHSVar()));
-    if (inVarToValTable(as, addr->getRHSVarID()))
-    {
-        // if addr RHS is integerType(i8 i32 etc), value should be limited.
-        if (addr->getRHSVar()->getType()->getKind() == SVFType::SVFIntegerTy)
-        {
-            as[addr->getRHSVarID()].meet_with(getRangeLimitFromType(addr->getRHSVar()->getType()));
-        }
-        as[addr->getLHSVarID()] = as[addr->getRHSVarID()];
-
-    }
-    else if (inVarToAddrsTable(as, addr->getRHSVarID()))
-    {
-        as[addr->getLHSVarID()] =
-            as[addr->getRHSVarID()];
-    }
-    else
-    {
-        assert(false && "not number or virtual addrs?");
-    }
+    if (addr->getRHSVar()->getType()->getKind() == SVFType::SVFIntegerTy)
+        as[addr->getRHSVarID()].getInterval().meet_with(getRangeLimitFromType(addr->getRHSVar()->getType()));
+    as[addr->getLHSVarID()] = as[addr->getRHSVarID()];
 }
 
 
@@ -602,65 +586,62 @@ void SVFIR2AbsState::handleBinary(AbstractState& as, const BinaryOPStmt *binary)
     u32_t res = binary->getResID();
     if (!inVarToValTable(as, op0)) as[op0] = IntervalValue::top();
     if (!inVarToValTable(as, op1)) as[op1] = IntervalValue::top();
-    if (inVarToValTable(as, op0) && inVarToValTable(as, op1))
-    {
-        IntervalValue &lhs = as[op0].getInterval(), &rhs = as[op1].getInterval();
-        IntervalValue resVal;
-        switch (binary->getOpcode())
-        {
-        case BinaryOPStmt::Add:
-        case BinaryOPStmt::FAdd:
-            resVal = (lhs + rhs);
-            break;
-        case BinaryOPStmt::Sub:
-        case BinaryOPStmt::FSub:
-            resVal = (lhs - rhs);
-            break;
-        case BinaryOPStmt::Mul:
-        case BinaryOPStmt::FMul:
-            resVal = (lhs * rhs);
-            break;
-        case BinaryOPStmt::SDiv:
-        case BinaryOPStmt::FDiv:
-        case BinaryOPStmt::UDiv:
-            resVal = (lhs / rhs);
-            break;
-        case BinaryOPStmt::SRem:
-        case BinaryOPStmt::FRem:
-        case BinaryOPStmt::URem:
-            resVal = (lhs % rhs);
-            break;
-        case BinaryOPStmt::Xor:
-            resVal = (lhs ^ rhs);
-            break;
-        case BinaryOPStmt::And:
-            resVal = (lhs & rhs);
-            break;
-        case BinaryOPStmt::Or:
-            resVal = (lhs | rhs);
-            break;
-        case BinaryOPStmt::AShr:
-            resVal = (lhs >> rhs);
-            break;
-        case BinaryOPStmt::Shl:
-            resVal = (lhs << rhs);
-            break;
-        case BinaryOPStmt::LShr:
-            resVal = (lhs >> rhs);
-            break;
-        default:
-        {
-            assert(false && "undefined binary: ");
-        }
-        }
-        as[res] = resVal;
-    }
+    IntervalValue &lhs = as[op0].getInterval(), &rhs = as[op1].getInterval();
+    IntervalValue resVal;
+    switch (binary->getOpcode())
+    {
+    case BinaryOPStmt::Add:
+    case BinaryOPStmt::FAdd:
+        resVal = (lhs + rhs);
+        break;
+    case BinaryOPStmt::Sub:
+    case BinaryOPStmt::FSub:
+        resVal = (lhs - rhs);
+        break;
+    case BinaryOPStmt::Mul:
+    case BinaryOPStmt::FMul:
+        resVal = (lhs * rhs);
+        break;
+    case BinaryOPStmt::SDiv:
+    case BinaryOPStmt::FDiv:
+    case BinaryOPStmt::UDiv:
+        resVal = (lhs / rhs);
+        break;
+    case BinaryOPStmt::SRem:
+    case BinaryOPStmt::FRem:
+    case BinaryOPStmt::URem:
+        resVal = (lhs % rhs);
+        break;
+    case BinaryOPStmt::Xor:
+        resVal = (lhs ^ rhs);
+        break;
+    case BinaryOPStmt::And:
+        resVal = (lhs & rhs);
+        break;
+    case BinaryOPStmt::Or:
+        resVal = (lhs | rhs);
+        break;
+    case BinaryOPStmt::AShr:
+        resVal = (lhs >> rhs);
+        break;
+    case BinaryOPStmt::Shl:
+        resVal = (lhs << rhs);
+        break;
+    case BinaryOPStmt::LShr:
+        resVal = (lhs >> rhs);
+        break;
+    default:
+        assert(false && "undefined binary: ");
+    }
+    as[res] = resVal;
 }
 
 void SVFIR2AbsState::handleCmp(AbstractState& as, const CmpStmt *cmp)
 {
     u32_t op0 = cmp->getOpVarID(0);
     u32_t op1 = cmp->getOpVarID(1);
+    if (!inVarToValTable(as, op0)) as[op0] = IntervalValue::top();
+    if (!inVarToValTable(as, op1)) as[op1] = IntervalValue::top();
     u32_t res = cmp->getResID();
     if (inVarToValTable(as, op0) && inVarToValTable(as, op1))
     {
@@ -840,40 +821,22 @@ void SVFIR2AbsState::handleLoad(AbstractState& as, const LoadStmt *load)
 {
     u32_t rhs = load->getRHSVarID();
     u32_t lhs = load->getLHSVarID();
-    if (inVarToAddrsTable(as, rhs))
-    {
-        AbstractValue &addrs = getAddrs(as, rhs);
-        AbstractValue rhsVal(AbstractValue::UnknownType); // interval::bottom Address::bottom
-        // AbstractValue absRhs
-        for (const auto &addr: addrs.getAddrs())
-        {
-            // inLocToAbsVal()
-            // absRhs.join_with
-            // as.load()
-            u32_t objId = getInternalID(addr);
-            if (inAddrTable(as, objId))
-            {
-                rhsVal.join_with(as.load(addr));
-            }
-        }
-        if (!rhsVal.isUnknown())
-            as[lhs] = rhsVal;
-    }
+    AbstractValue &addrs = as[rhs];
+    AbstractValue rhsVal; // interval::bottom Address::bottom
+    // AbstractValue absRhs
+    for (const auto &addr: addrs.getAddrs())
+        rhsVal.join_with(as.load(addr));
+    as[lhs] = rhsVal;
 }
 
 void SVFIR2AbsState::handleStore(AbstractState& as, const StoreStmt *store)
 {
     u32_t rhs = store->getRHSVarID();
     u32_t lhs = store->getLHSVarID();
-    if (inVarToAddrsTable(as, lhs))
+
+    for (const auto &addr: as[lhs].getAddrs())
     {
-        if (inVarTable(as, rhs))
-        {
-            for (const auto &addr: as[lhs].getAddrs())
-            {
-                as.store(addr, as[rhs]);
-            }
-        }
+        as.store(addr, as[rhs]);
     }
 }
 
@@ -882,72 +845,65 @@ void SVFIR2AbsState::handleCopy(AbstractState& as, const CopyStmt *copy)
     u32_t lhs = copy->getLHSVarID();
     u32_t rhs = copy->getRHSVarID();
 
-    if (inVarToValTable(as, rhs))
+    if (copy->getCopyKind() == CopyStmt::COPYVAL)
+    {
+        as[lhs] = as[rhs];
+    }
+    else if (copy->getCopyKind() == CopyStmt::ZEXT)
+    {
+        as[lhs] = getZExtValue(as, copy->getRHSVar());
+    }
+    else if (copy->getCopyKind() == CopyStmt::SEXT)
+    {
+        as[lhs] = getSExtValue(as, copy->getRHSVar());
+    }
+    else if (copy->getCopyKind() == CopyStmt::FPTOSI)
+    {
+        as[lhs] = getFPToSIntValue(as, copy->getRHSVar());
+    }
+    else if (copy->getCopyKind() == CopyStmt::FPTOUI)
+    {
+        as[lhs] = getFPToUIntValue(as, copy->getRHSVar());
+    }
+    else if (copy->getCopyKind() == CopyStmt::SITOFP)
+    {
+        as[lhs] = getSIntToFPValue(as, copy->getRHSVar());
+    }
+    else if (copy->getCopyKind() == CopyStmt::UITOFP)
     {
-        if (copy->getCopyKind() == CopyStmt::COPYVAL)
+        as[lhs] = getUIntToFPValue(as, copy->getRHSVar());
+    }
+    else if (copy->getCopyKind() == CopyStmt::TRUNC)
+    {
+        as[lhs] = getTruncValue(as, copy->getRHSVar(), copy->getLHSVar()->getType());
+    }
+    else if (copy->getCopyKind() == CopyStmt::FPTRUNC)
+    {
+        as[lhs] = getFPTruncValue(as, copy->getRHSVar(), copy->getLHSVar()->getType());
+    }
+    else if (copy->getCopyKind() == CopyStmt::INTTOPTR)
+    {
+        //insert nullptr
+    }
+    else if (copy->getCopyKind() == CopyStmt::PTRTOINT)
+    {
+        as[lhs] = IntervalValue::top();
+    }
+    else if (copy->getCopyKind() == CopyStmt::BITCAST)
+    {
+        if (as[rhs].isAddr())
         {
             as[lhs] = as[rhs];
         }
-        else if (copy->getCopyKind() == CopyStmt::ZEXT)
-        {
-            as[lhs] = getZExtValue(as, copy->getRHSVar());
-        }
-        else if (copy->getCopyKind() == CopyStmt::SEXT)
-        {
-            as[lhs] = getSExtValue(as, copy->getRHSVar());
-        }
-        else if (copy->getCopyKind() == CopyStmt::FPTOSI)
-        {
-            as[lhs] = getFPToSIntValue(as, copy->getRHSVar());
-        }
-        else if (copy->getCopyKind() == CopyStmt::FPTOUI)
-        {
-            as[lhs] = getFPToUIntValue(as, copy->getRHSVar());
-        }
-        else if (copy->getCopyKind() == CopyStmt::SITOFP)
-        {
-            as[lhs] = getSIntToFPValue(as, copy->getRHSVar());
-        }
-        else if (copy->getCopyKind() == CopyStmt::UITOFP)
-        {
-            as[lhs] = getUIntToFPValue(as, copy->getRHSVar());
-        }
-        else if (copy->getCopyKind() == CopyStmt::TRUNC)
-        {
-            as[lhs] = getTruncValue(as, copy->getRHSVar(), copy->getLHSVar()->getType());
-        }
-        else if (copy->getCopyKind() == CopyStmt::FPTRUNC)
-        {
-            as[lhs] = getFPTruncValue(as, copy->getRHSVar(), copy->getLHSVar()->getType());
-        }
-        else if (copy->getCopyKind() == CopyStmt::INTTOPTR)
-        {
-            //insert nullptr
-        }
-        else if (copy->getCopyKind() == CopyStmt::PTRTOINT)
-        {
-            as[lhs] = IntervalValue::top();
-        }
-        else if (copy->getCopyKind() == CopyStmt::BITCAST)
-        {
-            if (as[rhs].isAddr())
-            {
-                as[lhs] = as[rhs];
-            }
-            else
-            {
-                // do nothing
-            }
-        }
         else
         {
-            assert(false && "undefined copy kind");
-            abort();
+            // do nothing
         }
     }
-    else if (inVarToAddrsTable(as, rhs))
+    else
     {
-        as[lhs] = as[rhs];
+        assert(false && "undefined copy kind");
+        abort();
     }
 }
 
@@ -955,24 +911,15 @@ void SVFIR2AbsState::handleGep(AbstractState& as, const GepStmt *gep)
 {
     u32_t rhs = gep->getRHSVarID();
     u32_t lhs = gep->getLHSVarID();
-    if (!inVarToAddrsTable(as, rhs)) return;
-    AbstractValue &rhsVal = as[rhs];
     IntervalValue offsetPair = getElementIndex(as, gep);
-    if (!isVirtualMemAddress(*rhsVal.getAddrs().begin()))
-        return;
-    else
-    {
-        AbstractValue gepAddrs(AbstractValue::UnknownType);
-        APOffset lb = offsetPair.lb().getIntNumeral() < Options::MaxFieldLimit()?
-                      offsetPair.lb().getIntNumeral(): Options::MaxFieldLimit();
-        APOffset ub = offsetPair.ub().getIntNumeral() < Options::MaxFieldLimit()?
-                      offsetPair.ub().getIntNumeral(): Options::MaxFieldLimit();
-        for (APOffset i = lb; i <= ub; i++)
-            gepAddrs.join_with(getGepObjAddress(as, rhs, i));
-        if (!rhsVal.isUnknown())
-            as[lhs] = gepAddrs;
-        return;
-    }
+    AbstractValue gepAddrs;
+    APOffset lb = offsetPair.lb().getIntNumeral() < Options::MaxFieldLimit()?
+                  offsetPair.lb().getIntNumeral(): Options::MaxFieldLimit();
+    APOffset ub = offsetPair.ub().getIntNumeral() < Options::MaxFieldLimit()?
+                  offsetPair.ub().getIntNumeral(): Options::MaxFieldLimit();
+    for (APOffset i = lb; i <= ub; i++)
+        gepAddrs.join_with(getGepObjAddress(as, rhs, i));
+    as[lhs] = gepAddrs;
 }
 
 void SVFIR2AbsState::handleSelect(AbstractState& as, const SelectStmt *select)
@@ -981,41 +928,27 @@ void SVFIR2AbsState::handleSelect(AbstractState& as, const SelectStmt *select)
     u32_t tval = select->getTrueValue()->getId();
     u32_t fval = select->getFalseValue()->getId();
     u32_t cond = select->getCondition()->getId();
-    if (inVarToValTable(as, tval) && inVarToValTable(as, fval) && inVarToValTable(as, cond))
+    if (as[cond].getInterval().is_numeral())
     {
-        if (as[cond].getInterval().is_numeral())
-        {
-            as[res] = as[cond].getInterval().is_zero() ? as[fval] : as[tval];
-        }
-        else
-        {
-            as[res] = as[cond];
-        }
+        as[res] = as[cond].getInterval().is_zero() ? as[fval] : as[tval];
     }
-    else if (inVarToAddrsTable(as, tval) && inVarToAddrsTable(as, fval) && inVarToValTable(as, cond))
+    else
     {
-        if (as[cond].getInterval().is_numeral())
-        {
-            as.getAddrs(res) = as[cond].getInterval().is_zero() ? getAddrs(as, fval) : getAddrs(as, tval);
-        }
+        as[res] = as[tval];
+        as[res].join_with(as[fval]);
     }
 }
 
 void SVFIR2AbsState::handlePhi(AbstractState& as, const PhiStmt *phi)
 {
     u32_t res = phi->getResID();
-    AbstractValue rhs(AbstractValue::UnknownType);
+    AbstractValue rhs;
     for (u32_t i = 0; i < phi->getOpVarNum(); i++)
     {
         NodeID curId = phi->getOpVarID(i);
-
-        if (inVarToValTable(as, curId) || inVarToAddrsTable(as, curId))
-        {
-            rhs.join_with(as[curId]);
-        }
+        rhs.join_with(as[curId]);
     }
-    if (!rhs.isUnknown())
-        as[res] = rhs;
+    as[res] = rhs;
 }
 
 
@@ -1023,18 +956,12 @@ void SVFIR2AbsState::handleCall(AbstractState& as, const CallPE *callPE)
 {
     NodeID lhs = callPE->getLHSVarID();
     NodeID rhs = callPE->getRHSVarID();
-    if (inVarToValTable(as, rhs) || inVarToAddrsTable(as, rhs))
-    {
-        as[lhs] = as[rhs];
-    }
+    as[lhs] = as[rhs];
 }
 
 void SVFIR2AbsState::handleRet(AbstractState& as, const RetPE *retPE)
 {
     NodeID lhs = retPE->getLHSVarID();
     NodeID rhs = retPE->getRHSVarID();
-    if (inVarToValTable(as, rhs) || inVarToAddrsTable(as, rhs))
-    {
-        as[lhs] = as[rhs];
-    }
+    as[lhs] = as[rhs];
 }