svf-tools 1.0.812 → 1.0.813

package/svf/lib/AbstractExecution/SVFIR2ItvExeState.cpp

@@ -33,7 +33,7 @@
 using namespace SVF;
 using namespace SVFUtil;
 
-SVF::SVFIR2ItvExeState::VAddrs SVF::SVFIR2ItvExeState::globalNullVaddrs =
+SVF::SVFIR2ItvExeState::Addrs SVF::SVFIR2ItvExeState::globalNulladdrs =
     AddressValue();
 
 /**
@@ -112,13 +112,13 @@ void SVFIR2ItvExeState::applySummary(IntervalExeState &es)
     {
         _es._locToItvVal[item.first] = item.second;
     }
-    for (const auto &item: es._varToVAddrs)
+    for (const auto &item: es._varToAddrs)
     {
-        _es._varToVAddrs[item.first] = item.second;
+        _es._varToAddrs[item.first] = item.second;
     }
-    for (const auto &item: es._locToVAddrs)
+    for (const auto &item: es._locToAddrs)
     {
-        _es._locToVAddrs[item.first] = item.second;
+        _es._locToAddrs[item.first] = item.second;
     }
 }
 
@@ -132,29 +132,29 @@ void SVFIR2ItvExeState::moveToGlobal()
     {
         IntervalExeState::globalES._locToItvVal.insert(it);
     }
-    for (const auto &_varToVAddr: _es._varToVAddrs)
+    for (const auto &_varToVAddr: _es._varToAddrs)
     {
-        IntervalExeState::globalES._varToVAddrs.insert(_varToVAddr);
+        IntervalExeState::globalES._varToAddrs.insert(_varToVAddr);
     }
-    for (const auto &_locToVAddr: _es._locToVAddrs)
+    for (const auto &_locToVAddr: _es._locToAddrs)
     {
-        IntervalExeState::globalES._locToVAddrs.insert(_locToVAddr);
+        IntervalExeState::globalES._locToAddrs.insert(_locToVAddr);
     }
 
     _es._varToItvVal.clear();
     IntervalExeState::globalES._varToItvVal.erase(PAG::getPAG()->getBlkPtr());
     _es._varToItvVal[PAG::getPAG()->getBlkPtr()] = IntervalValue::top();
     _es._locToItvVal.clear();
-    _es._varToVAddrs.clear();
-    _es._locToVAddrs.clear();
+    _es._varToAddrs.clear();
+    _es._locToAddrs.clear();
 }
 
-void SVFIR2ItvExeState::widenVAddrs(IntervalExeState &lhs, const IntervalExeState &rhs)
+void SVFIR2ItvExeState::widenAddrs(IntervalExeState &lhs, const IntervalExeState &rhs)
 {
-    for (const auto &rhsItem: rhs._varToVAddrs)
+    for (const auto &rhsItem: rhs._varToAddrs)
     {
-        auto lhsIter = lhs._varToVAddrs.find(rhsItem.first);
-        if (lhsIter != lhs._varToVAddrs.end())
+        auto lhsIter = lhs._varToAddrs.find(rhsItem.first);
+        if (lhsIter != lhs._varToAddrs.end())
         {
             for (const auto &addr: rhsItem.second)
             {
@@ -168,10 +168,10 @@ void SVFIR2ItvExeState::widenVAddrs(IntervalExeState &lhs, const IntervalExeStat
             }
         }
     }
-    for (const auto &rhsItem: rhs._locToVAddrs)
+    for (const auto &rhsItem: rhs._locToAddrs)
     {
-        auto lhsIter = lhs._locToVAddrs.find(rhsItem.first);
-        if (lhsIter != lhs._locToVAddrs.end())
+        auto lhsIter = lhs._locToAddrs.find(rhsItem.first);
+        if (lhsIter != lhs._locToAddrs.end())
         {
             for (const auto &addr: rhsItem.second)
             {
@@ -187,12 +187,12 @@ void SVFIR2ItvExeState::widenVAddrs(IntervalExeState &lhs, const IntervalExeStat
     }
 }
 
-void SVFIR2ItvExeState::narrowVAddrs(IntervalExeState &lhs, const IntervalExeState &rhs)
+void SVFIR2ItvExeState::narrowAddrs(IntervalExeState &lhs, const IntervalExeState &rhs)
 {
-    for (const auto &rhsItem: rhs._varToVAddrs)
+    for (const auto &rhsItem: rhs._varToAddrs)
     {
-        auto lhsIter = lhs._varToVAddrs.find(rhsItem.first);
-        if (lhsIter != lhs._varToVAddrs.end())
+        auto lhsIter = lhs._varToAddrs.find(rhsItem.first);
+        if (lhsIter != lhs._varToAddrs.end())
         {
             for (const auto &addr: lhsIter->second)
             {
@@ -204,10 +204,10 @@ void SVFIR2ItvExeState::narrowVAddrs(IntervalExeState &lhs, const IntervalExeSta
             }
         }
     }
-    for (const auto &rhsItem: rhs._locToVAddrs)
+    for (const auto &rhsItem: rhs._locToAddrs)
     {
-        auto lhsIter = lhs._locToVAddrs.find(rhsItem.first);
-        if (lhsIter != lhs._locToVAddrs.end())
+        auto lhsIter = lhs._locToAddrs.find(rhsItem.first);
+        if (lhsIter != lhs._locToAddrs.end())
         {
             for (const auto &addr: lhsIter->second)
             {
@@ -221,11 +221,11 @@ void SVFIR2ItvExeState::narrowVAddrs(IntervalExeState &lhs, const IntervalExeSta
     }
 }
 
-SVFIR2ItvExeState::VAddrs SVFIR2ItvExeState::getGepObjAddress(u32_t pointer, APOffset offset)
+SVFIR2ItvExeState::Addrs SVFIR2ItvExeState::getGepObjAddress(u32_t pointer, APOffset offset)
 {
-    assert(!getVAddrs(pointer).empty());
-    VAddrs &addrs = getVAddrs(pointer);
-    VAddrs ret;
+    assert(!getAddrs(pointer).empty());
+    Addrs &addrs = getAddrs(pointer);
+    Addrs ret;
     for (const auto &addr: addrs)
     {
         int64_t baseObj = getInternalID(addr);
@@ -458,22 +458,22 @@ void SVFIR2ItvExeState::initObjVar(const ObjVar *objVar, u32_t varId)
             else if (SVFUtil::isa<SVFConstantNullPtr>(obj->getValue()))
                 IntervalExeState::globalES[varId] = IntervalValue(0, 0);
             else if (SVFUtil::isa<SVFGlobalValue>(obj->getValue()))
-                IntervalExeState::globalES.getVAddrs(varId).insert(getVirtualMemAddress(varId));
+                IntervalExeState::globalES.getAddrs(varId).insert(getVirtualMemAddress(varId));
             else if (obj->isConstantArray() || obj->isConstantStruct())
                 IntervalExeState::globalES[varId] = IntervalValue::top();
             else
                 IntervalExeState::globalES[varId] = IntervalValue::top();
         }
         else
-            IntervalExeState::globalES.getVAddrs(varId).insert(getVirtualMemAddress(varId));
+            IntervalExeState::globalES.getAddrs(varId).insert(getVirtualMemAddress(varId));
     }
     else
-        IntervalExeState::globalES.getVAddrs(varId).insert(getVirtualMemAddress(varId));
+        IntervalExeState::globalES.getAddrs(varId).insert(getVirtualMemAddress(varId));
 }
 
 void SVFIR2ItvExeState::initSVFVar(u32_t varId)
 {
-    if (inVarToIValTable(varId) || _es.inVarToAddrsTable(varId)) return;
+    if (inVarToValTable(varId) || _es.inVarToAddrsTable(varId)) return;
     SVFIR *svfir = PAG::getPAG();
     SVFVar *svfVar = svfir->getGNode(varId);
     // write objvar into cache instead of exestate
@@ -498,7 +498,7 @@ void SVFIR2ItvExeState::initSVFVar(u32_t varId)
 void SVFIR2ItvExeState::translateAddr(const AddrStmt *addr)
 {
     initSVFVar(addr->getRHSVarID());
-    if (inVarToIValTable(addr->getRHSVarID()))
+    if (inVarToValTable(addr->getRHSVarID()))
     {
         // if addr RHS is integerType(i8 i32 etc), value should be limited.
         if (addr->getRHSVar()->getType()->getKind() == SVFType::SVFIntegerTy)
@@ -511,7 +511,7 @@ void SVFIR2ItvExeState::translateAddr(const AddrStmt *addr)
     }
     else if (inVarToAddrsTable(addr->getRHSVarID()))
     {
-        IntervalExeState::globalES.getVAddrs(addr->getLHSVarID()) = IntervalExeState::globalES.getVAddrs(
+        IntervalExeState::globalES.getAddrs(addr->getLHSVarID()) = IntervalExeState::globalES.getAddrs(
                     addr->getRHSVarID());
     }
     else
@@ -526,9 +526,9 @@ void SVFIR2ItvExeState::translateBinary(const BinaryOPStmt *binary)
     u32_t op0 = binary->getOpVarID(0);
     u32_t op1 = binary->getOpVarID(1);
     u32_t res = binary->getResID();
-    if (!inVarToIValTable(op0)) _es[op0] = IntervalValue::top();
-    if (!inVarToIValTable(op1)) _es[op1] = IntervalValue::top();
-    if (inVarToIValTable(op0) && inVarToIValTable(op1))
+    if (!inVarToValTable(op0)) _es[op0] = IntervalValue::top();
+    if (!inVarToValTable(op1)) _es[op1] = IntervalValue::top();
+    if (inVarToValTable(op0) && inVarToValTable(op1))
     {
         IntervalValue &lhs = _es[op0], &rhs = _es[op1];
         IntervalValue resVal;
@@ -588,7 +588,7 @@ void SVFIR2ItvExeState::translateCmp(const CmpStmt *cmp)
     u32_t op0 = cmp->getOpVarID(0);
     u32_t op1 = cmp->getOpVarID(1);
     u32_t res = cmp->getResID();
-    if (inVarToIValTable(op0) && inVarToIValTable(op1))
+    if (inVarToValTable(op0) && inVarToValTable(op1))
     {
         IntervalValue resVal;
         IntervalValue &lhs = _es[op0], &rhs = _es[op1];
@@ -645,7 +645,7 @@ void SVFIR2ItvExeState::translateCmp(const CmpStmt *cmp)
     else if (inVarToAddrsTable(op0) && inVarToAddrsTable(op1))
     {
         IntervalValue resVal;
-        VAddrs &lhs = getVAddrs(op0), &rhs = getVAddrs(op1);
+        Addrs &lhs = getAddrs(op0), &rhs = getAddrs(op1);
         assert(!lhs.empty() && !rhs.empty() && "empty address?");
         auto predicate = cmp->getPredicate();
         switch (predicate)
@@ -773,30 +773,26 @@ void SVFIR2ItvExeState::translateLoad(const LoadStmt *load)
     u32_t lhs = load->getLHSVarID();
     if (inVarToAddrsTable(rhs))
     {
-        VAddrs &addrs = getVAddrs(rhs);
+        Addrs &addrs = getAddrs(rhs);
         assert(!addrs.empty());
         IntervalValue rhsItv = IntervalValue::bottom();
         AddressValue rhsAddr;
-        bool isItv = false, isAddr = false;
+        bool isVal = false, isAddr = false;
         for (const auto &addr: addrs)
         {
             u32_t objId = getInternalID(addr);
-            if (inLocToIValTable(objId))
+            if (inLocToValTable(objId))
             {
                 rhsItv.join_with(_es.load(addr));
-                isItv = true;
+                isVal = true;
             }
             else if (inLocToAddrsTable(objId))
             {
-                rhsAddr.join_with(_es.loadVAddrs(addr));
+                rhsAddr.join_with(_es.loadAddrs(addr));
                 isAddr = true;
             }
-            else
-            {
-                // rhs not in table
-            }
         }
-        if (isItv)
+        if (isVal)
         {
             // lhs var is an integer
             _es[lhs] = rhsItv;
@@ -804,11 +800,11 @@ void SVFIR2ItvExeState::translateLoad(const LoadStmt *load)
         else if (isAddr)
         {
             // lhs var is an address
-            _es.getVAddrs(lhs) = rhsAddr;
+            _es.getAddrs(lhs) = rhsAddr;
         }
         else
         {
-            // rhs not in table
+            // rhs not initialized, e.g., absence of a store before load
         }
     }
 }
@@ -819,10 +815,10 @@ void SVFIR2ItvExeState::translateStore(const StoreStmt *store)
     u32_t lhs = store->getLHSVarID();
     if (inVarToAddrsTable(lhs))
     {
-        if (inVarToIValTable(rhs))
+        if (inVarToValTable(rhs))
         {
-            assert(!getVAddrs(lhs).empty());
-            VAddrs &addrs = getVAddrs(lhs);
+            assert(!getAddrs(lhs).empty());
+            Addrs &addrs = getAddrs(lhs);
             for (const auto &addr: addrs)
             {
                 _es.store(addr, _es[rhs]);
@@ -830,12 +826,12 @@ void SVFIR2ItvExeState::translateStore(const StoreStmt *store)
         }
         else if (inVarToAddrsTable(rhs))
         {
-            assert(!getVAddrs(lhs).empty());
-            VAddrs &addrs = getVAddrs(lhs);
+            assert(!getAddrs(lhs).empty());
+            Addrs &addrs = getAddrs(lhs);
             for (const auto &addr: addrs)
             {
-                assert(!getVAddrs(rhs).empty());
-                _es.storeVAddrs(addr, getVAddrs(rhs));
+                assert(!getAddrs(rhs).empty());
+                _es.storeAddrs(addr, getAddrs(rhs));
             }
 
         }
@@ -852,7 +848,7 @@ void SVFIR2ItvExeState::translateCopy(const CopyStmt *copy)
     }
     else
     {
-        if (inVarToIValTable(rhs))
+        if (inVarToValTable(rhs))
         {
             _es[lhs] = _es[rhs];
             // if copy LHS is integerType(i8 i32 etc), value should be limited.
@@ -866,8 +862,8 @@ void SVFIR2ItvExeState::translateCopy(const CopyStmt *copy)
         }
         else if (inVarToAddrsTable(rhs))
         {
-            assert(!getVAddrs(rhs).empty());
-            _es.getVAddrs(lhs) = getVAddrs(rhs);
+            assert(!getAddrs(rhs).empty());
+            _es.getAddrs(lhs) = getAddrs(rhs);
         }
     }
 }
@@ -877,15 +873,15 @@ void SVFIR2ItvExeState::translateGep(const GepStmt *gep)
     u32_t rhs = gep->getRHSVarID();
     u32_t lhs = gep->getLHSVarID();
     if (!inVarToAddrsTable(rhs)) return;
-    assert(!getVAddrs(rhs).empty());
-    VAddrs &rhsVal = getVAddrs(rhs);
+    assert(!getAddrs(rhs).empty());
+    Addrs &rhsVal = getAddrs(rhs);
     if (rhsVal.empty()) return;
     IntervalValue offsetPair = getItvOfFlattenedElemIndex(gep);
     if (!isVirtualMemAddress(*rhsVal.begin()))
         return;
     else
     {
-        VAddrs gepAddrs;
+        Addrs gepAddrs;
         APOffset lb = offsetPair.lb().getNumeral() < Options::MaxFieldLimit()?
                       offsetPair.lb().getNumeral(): Options::MaxFieldLimit();
         APOffset ub = offsetPair.ub().getNumeral() < Options::MaxFieldLimit()?
@@ -893,7 +889,7 @@ void SVFIR2ItvExeState::translateGep(const GepStmt *gep)
         for (APOffset i = lb; i <= ub; i++)
             gepAddrs.join_with(getGepObjAddress(rhs, i));
         if(gepAddrs.empty()) return;
-        _es.getVAddrs(lhs) = gepAddrs;
+        _es.getAddrs(lhs) = gepAddrs;
         return;
     }
 }
@@ -904,7 +900,7 @@ void SVFIR2ItvExeState::translateSelect(const SelectStmt *select)
     u32_t tval = select->getTrueValue()->getId();
     u32_t fval = select->getFalseValue()->getId();
     u32_t cond = select->getCondition()->getId();
-    if (inVarToIValTable(tval) && inVarToIValTable(fval) && inVarToIValTable(cond))
+    if (inVarToValTable(tval) && inVarToValTable(fval) && inVarToValTable(cond))
     {
         if (_es[cond].is_numeral())
         {
@@ -915,13 +911,13 @@ void SVFIR2ItvExeState::translateSelect(const SelectStmt *select)
             _es[res] = _es[cond];
         }
     }
-    else if (inVarToAddrsTable(tval) && inVarToAddrsTable(fval) && inVarToIValTable(cond))
+    else if (inVarToAddrsTable(tval) && inVarToAddrsTable(fval) && inVarToValTable(cond))
     {
         if (_es[cond].is_numeral())
         {
-            assert(!getVAddrs(fval).empty());
-            assert(!getVAddrs(tval).empty());
-            _es.getVAddrs(res) = _es[cond].is_zero() ? getVAddrs(fval) : getVAddrs(tval);
+            assert(!getAddrs(fval).empty());
+            assert(!getAddrs(tval).empty());
+            _es.getAddrs(res) = _es[cond].is_zero() ? getAddrs(fval) : getAddrs(tval);
         }
     }
 }
@@ -931,27 +927,23 @@ void SVFIR2ItvExeState::translatePhi(const PhiStmt *phi)
     u32_t res = phi->getResID();
     IntervalValue rhsItv = IntervalValue::bottom();
     AddressValue rhsAddr;
-    bool isItv = false, isAddr = false;
+    bool isVal = false, isAddr = false;
     for (u32_t i = 0; i < phi->getOpVarNum(); i++)
     {
         NodeID curId = phi->getOpVarID(i);
-        if (inVarToIValTable(curId))
+        if (inVarToValTable(curId))
         {
             rhsItv.join_with(_es[curId]);
-            isItv = true;
+            isVal = true;
         }
         else if (inVarToAddrsTable(curId))
         {
-            assert(!getVAddrs(curId).empty());
-            rhsAddr.join_with(getVAddrs(curId));
+            assert(!getAddrs(curId).empty());
+            rhsAddr.join_with(getAddrs(curId));
             isAddr = true;
         }
-        else
-        {
-            // rhs not in the table
-        }
     }
-    if (isItv)
+    if (isVal)
     {
         // res var is an integer
         _es[res] = rhsItv;
@@ -959,11 +951,7 @@ void SVFIR2ItvExeState::translatePhi(const PhiStmt *phi)
     else if (isAddr)
     {
         // res var is an address
-        _es.getVAddrs(res) = rhsAddr;
-    }
-    else
-    {
-        // rhs not in table
+        _es.getAddrs(res) = rhsAddr;
     }
 }
 
@@ -972,14 +960,14 @@ void SVFIR2ItvExeState::translateCall(const CallPE *callPE)
 {
     NodeID lhs = callPE->getLHSVarID();
     NodeID rhs = callPE->getRHSVarID();
-    if (inVarToIValTable(rhs))
+    if (inVarToValTable(rhs))
     {
         _es[lhs] = _es[rhs];
     }
     else if (inVarToAddrsTable(rhs))
     {
-        assert(!getVAddrs(rhs).empty());
-        _es.getVAddrs(lhs) = getVAddrs(rhs);
+        assert(!getAddrs(rhs).empty());
+        _es.getAddrs(lhs) = getAddrs(rhs);
     }
 }
 
@@ -987,13 +975,13 @@ void SVFIR2ItvExeState::translateRet(const RetPE *retPE)
 {
     NodeID lhs = retPE->getLHSVarID();
     NodeID rhs = retPE->getRHSVarID();
-    if (inVarToIValTable(rhs))
+    if (inVarToValTable(rhs))
     {
         _es[lhs] = _es[rhs];
     }
     else if (inVarToAddrsTable(rhs))
     {
-        assert(!getVAddrs(rhs).empty());
-        _es.getVAddrs(lhs) = getVAddrs(rhs);
+        assert(!getAddrs(rhs).empty());
+        _es.getAddrs(lhs) = getAddrs(rhs);
     }
 }