svf-tools 1.0.966 → 1.0.968

package/svf/include/MemoryModel/AccessPath.h

@@ -135,6 +135,7 @@ public:
     /// APOffset byteOffset = gep->accumulateConstantByteOffset();
     /// byteOffset should be 8 since i32 is 4 bytes and index is 2.
     APOffset computeConstantByteOffset() const;
+
     /// Return accumulated constant offset given OffsetVarVec
     /// compard to computeConstantByteOffset, it is field offset rather than byte offset
     /// e.g. GepStmt* gep = [i32*4], 2

package/svf/include/SVFIR/SVFStatements.h

@@ -566,6 +566,7 @@ public:
     {
         return getAccessPath().isConstantOffset();
     }
+
     /// Return accumulated constant offset (when accessing array or struct) if this offset is a constant.
     /// elemBytesize is the element byte size of an static alloc or heap alloc array
     /// e.g. GepStmt* gep = **,

package/svf/lib/AE/Core/RelationSolver.cpp

@@ -283,15 +283,15 @@ AbstractState RelationSolver::BS(const AbstractState& domain, const Z3Expr &phi)
     for (const auto& item: domain.getVarToVal())
     {
         IntervalValue interval = item.second.getInterval();
-        updateMap(ret, item.first, interval.ub().getFVal());
+        updateMap(ret, item.first, interval.ub().getIntNumeral());
         if (interval.lb().is_minus_infinity())
             updateMap(low_values, item.first, -infinity);
         else
-            updateMap(low_values, item.first, interval.lb().getFVal());
+            updateMap(low_values, item.first, interval.lb().getIntNumeral());
         if (interval.ub().is_plus_infinity())
             updateMap(high_values, item.first, infinity);
         else
-            updateMap(high_values, item.first, interval.ub().getFVal());
+            updateMap(high_values, item.first, interval.ub().getIntNumeral());
         if (item.first > bias)
             bias = item.first + 1;
     }
@@ -300,15 +300,15 @@ AbstractState RelationSolver::BS(const AbstractState& domain, const Z3Expr &phi)
         /// init objects -x
         IntervalValue interval = item.second.getInterval();
         u32_t reverse_key = item.first + bias;
-        updateMap(ret, reverse_key, -interval.lb().getFVal());
+        updateMap(ret, reverse_key, -interval.lb().getIntNumeral());
         if (interval.ub().is_plus_infinity())
             updateMap(low_values, reverse_key, -infinity);
         else
-            updateMap(low_values, reverse_key, -interval.ub().getFVal());
+            updateMap(low_values, reverse_key, -interval.ub().getIntNumeral());
         if (interval.lb().is_minus_infinity())
             updateMap(high_values, reverse_key, infinity);
         else
-            updateMap(high_values, reverse_key, -interval.lb().getFVal());
+            updateMap(high_values, reverse_key, -interval.lb().getIntNumeral());
         /// add a relation that x == -(x+bias)
         new_phi = (new_phi && (toIntZ3Expr(reverse_key) == -1 * toIntZ3Expr(item.first)));
     }
@@ -320,17 +320,23 @@ AbstractState RelationSolver::BS(const AbstractState& domain, const Z3Expr &phi)
     {
         if (item.first >= bias)
         {
+            if (!retInv.inVarToValTable(item.first-bias))
+                retInv[item.first-bias] = IntervalValue::top();
+
             if (item.second == (infinity))
-                retInv[item.first - bias].getInterval().setLb(BoundedDouble::minus_infinity());
+                retInv[item.first - bias] = IntervalValue(BoundedInt::minus_infinity(),
+                                            retInv[item.first - bias].getInterval().ub());
             else
-                retInv[item.first - bias].getInterval().setLb(float(-item.second));
+                retInv[item.first - bias] = IntervalValue(float(-item.second), retInv[item.first - bias].getInterval().ub());
+
         }
         else
         {
             if (item.second == (infinity))
-                retInv[item.first].getInterval().setUb(BoundedDouble::plus_infinity());
+                retInv[item.first] = IntervalValue(retInv[item.first].getInterval().lb(),
+                                                   BoundedInt::plus_infinity());
             else
-                retInv[item.first].getInterval().setUb(float(item.second));
+                retInv[item.first] = IntervalValue(retInv[item.first].getInterval().lb(), float(item.second));
         }
     }
     return retInv;
@@ -422,4 +428,4 @@ void RelationSolver::decide_cpa_ext(const Z3Expr& phi,
         }
     }
 
-}
+}

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

@@ -1390,16 +1390,7 @@ IntervalValue AbstractInterpretation::traceMemoryAllocationSize(AbstractState& a
                         }
                         else
                         {
-                            IntervalValue byteOffset;
-                            if (gep->isConstantOffset())
-                            {
-                                byteOffset = IntervalValue(gep->accumulateConstantByteOffset());
-                            }
-                            else
-                            {
-                                IntervalValue byteOffset =
-                                    _svfir2AbsState->getByteOffset(as, gep);
-                            }
+                            IntervalValue byteOffset = _svfir2AbsState->getByteOffset(as, gep);
                             // for variable offset, join with accumulate gep offset
                             gep_offsets[gep->getICFGNode()] = byteOffset;
                             total_bytes = total_bytes + byteOffset;

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

@@ -562,15 +562,7 @@ bool BufOverflowChecker::canSafelyAccessMemory(const SVFValue *value, const Inte
                     //  so if getOffsetVarVal > getOffsetVar.TypeSize (overflow)
                     //     else safe and return.
                     IntervalValue byteOffset;
-                    if (gep->isConstantOffset())
-                    {
-                        byteOffset = IntervalValue(gep->accumulateConstantByteOffset());
-                    }
-                    else
-                    {
-                        byteOffset =
-                            _svfir2AbsState->getByteOffset(as, gep);
-                    }
+                    byteOffset = _svfir2AbsState->getByteOffset(as, gep);
                     // for variable offset, join with accumulate gep offset
                     gep_offsets[gep->getICFGNode()] = byteOffset;
                     if (byteOffset.ub().getNumeral() >= Options::MaxFieldLimit() && Options::GepUnknownIdx())

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

@@ -160,60 +160,26 @@ IntervalValue SVFIR2AbsState::getSExtValue(const AbstractState& as, const SVFVar
 
 IntervalValue SVFIR2AbsState::getFPToSIntValue(const AbstractState& as, const SVF::SVFVar* var)
 {
-    if (as[var->getId()].getInterval().is_real())
-    {
-        // get the float value of ub and lb
-        double float_lb = as[var->getId()].getInterval().lb().getRealNumeral();
-        double float_ub = as[var->getId()].getInterval().ub().getRealNumeral();
-        // get the int value of ub and lb
-        s64_t int_lb = static_cast<s64_t>(float_lb);
-        s64_t int_ub = static_cast<s64_t>(float_ub);
-        return IntervalValue(int_lb, int_ub);
-    }
-    else
-    {
-        return getSExtValue(as, var);
-    }
+    // IntervalValue are BoundedInt, so we can directly return the value
+    return getSExtValue(as, var);
 }
 
 IntervalValue SVFIR2AbsState::getFPToUIntValue(const AbstractState& as, const SVF::SVFVar* var)
 {
-    if (as[var->getId()].getInterval().is_real())
-    {
-        // get the float value of ub and lb
-        double float_lb = as[var->getId()].getInterval().lb().getRealNumeral();
-        double float_ub = as[var->getId()].getInterval().ub().getRealNumeral();
-        // get the int value of ub and lb
-        u64_t int_lb = static_cast<u64_t>(float_lb);
-        u64_t int_ub = static_cast<u64_t>(float_ub);
-        return IntervalValue(int_lb, int_ub);
-    }
-    else
-    {
-        return getZExtValue(as, var);
-    }
+    // IntervalValue are BoundedInt, so we can directly return the value
+    return getZExtValue(as, 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();
-    s64_t sint_ub = as[var->getId()].getInterval().ub().getIntNumeral();
-    // get the float value of ub and lb
-    double float_lb = static_cast<double>(sint_lb);
-    double float_ub = static_cast<double>(sint_ub);
-    return IntervalValue(float_lb, float_ub);
+    // IntervalValue are BoundedInt, so we can directly return the value
+    return getSExtValue(as, 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();
-    u64_t uint_ub = as[var->getId()].getInterval().ub().getIntNumeral();
-    // get the float value of ub and lb
-    double float_lb = static_cast<double>(uint_lb);
-    double float_ub = static_cast<double>(uint_ub);
-    return IntervalValue(float_lb, float_ub);
+    // IntervalValue are BoundedInt, so we can directly return the value
+    return getZExtValue(as, var);
 }
 
 IntervalValue SVFIR2AbsState::getTruncValue(const AbstractState& as, const SVF::SVFVar* var, const SVFType* dstType)
@@ -398,64 +364,86 @@ AddressValue SVFIR2AbsState::getGepObjAddress(AbstractState& as, u32_t pointer,
  */
 IntervalValue SVFIR2AbsState::getByteOffset(const AbstractState& as, const GepStmt *gep)
 {
-    if (gep->isConstantOffset())
-        return IntervalValue((s64_t)gep->accumulateConstantByteOffset());
-    IntervalValue res = IntervalValue(0); // Initialize the result interval 'res' to 0.
-    // Loop through the offsetVarAndGepTypePairVec in reverse order.
+    IntervalValue byte_res = IntervalValue(0);
     for (int i = gep->getOffsetVarAndGepTypePairVec().size() - 1; i >= 0; i--)
     {
-        const SVFVar* idxOperandVar =
-            gep->getOffsetVarAndGepTypePairVec()[i].first;
-        const SVFType* idxOperandType =
-            gep->getOffsetVarAndGepTypePairVec()[i].second;
-        // calculating Array/Ptr by elemByteSize * indexOperand
-        if (SVFUtil::isa<SVFArrayType>(idxOperandType) || SVFUtil::isa<SVFPointerType>(idxOperandType))
+        AccessPath::IdxOperandPair IdxVarAndType =
+            gep->getOffsetVarAndGepTypePairVec()[i];
+        const SVFValue *value =
+            gep->getOffsetVarAndGepTypePairVec()[i].first->getValue();
+        const SVFType *type = IdxVarAndType.second;
+        s64_t idxLb = 0;
+        s64_t idxUb = 0;
+        s64_t byteLb = 0;
+        s64_t byteUb = 0;
+        // get lb and ub of the index value
+        if (const SVFConstantInt* constInt = SVFUtil::dyn_cast<SVFConstantInt>(value))
+            idxLb = idxUb = constInt->getSExtValue();
+        else
         {
-            u32_t elemByteSize = 1;
-            if (const SVFArrayType* arrOperandType = SVFUtil::dyn_cast<SVFArrayType>(idxOperandType))
-                elemByteSize = arrOperandType->getTypeOfElement()->getByteSize();
-            else if (SVFUtil::isa<SVFPointerType>(idxOperandType))
-                elemByteSize = gep->getAccessPath().gepSrcPointeeType()->getByteSize();
-            else
-                assert(false && "idxOperandType must be ArrType or PtrType");
-            if (const SVFConstantInt *op = SVFUtil::dyn_cast<SVFConstantInt>(idxOperandVar->getValue()))
-            {
-                s64_t lb = (double)Options::MaxFieldLimit() / elemByteSize >= op->getSExtValue() ?op->getSExtValue() * elemByteSize
-                           : Options::MaxFieldLimit();
-                res = res + IntervalValue(lb, lb);
-            }
+            IntervalValue idxItv = as[_svfir->getValueNode(value)].getInterval();
+            if (idxItv.isBottom())
+                idxLb = idxUb = 0;
             else
             {
-                u32_t idx = _svfir->getValueNode(idxOperandVar->getValue());
-                IntervalValue idxVal = as[idx].getInterval();
-                if (idxVal.isBottom())
-                    res = res + IntervalValue(0, 0);
-                else
-                {
-                    // if lb or ub is negative number, set 0.
-                    // if lb or ub is positive number, guarantee lb/ub * elemByteSize <= MaxFieldLimit
-                    s64_t ub = (idxVal.ub().getIntNumeral() < 0) ? 0 :
-                               (double)Options::MaxFieldLimit() /
-                               elemByteSize >= idxVal.ub().getIntNumeral() ? elemByteSize * idxVal.ub().getIntNumeral(): Options::MaxFieldLimit();
-                    s64_t lb = (idxVal.lb().getIntNumeral() < 0) ? 0 :
-                               ((double)Options::MaxFieldLimit() /
-                                elemByteSize >= idxVal.lb().getIntNumeral()) ? elemByteSize * idxVal.lb().getIntNumeral() : Options::MaxFieldLimit();
-                    res = res + IntervalValue(lb, ub);
-                }
+                idxLb = idxItv.lb().getIntNumeral();
+                idxUb = idxItv.ub().getIntNumeral();
             }
         }
-        // Process struct subtype by calculating the byte offset from beginning to the field of struct
-        else if (const SVFStructType* structOperandType = SVFUtil::dyn_cast<SVFStructType>(idxOperandType))
+        // for pointer type, elemByteSize * indexOperand
+        if (SVFUtil::isa<SVFPointerType>(type))
         {
-            res = res + IntervalValue(gep->getAccessPath().getStructFieldOffset(
-                                          idxOperandVar, structOperandType));
+            u32_t elemByte = gep->getAccessPath().gepSrcPointeeType()->getByteSize();
+            byteLb = (double)Options::MaxFieldLimit() / elemByte < idxLb? Options::MaxFieldLimit(): idxLb * elemByte;
+            byteUb = (double)Options::MaxFieldLimit() / elemByte < idxUb? Options::MaxFieldLimit(): idxUb * elemByte;
+
         }
+        // for array or struct, get flattened index from SymbolTable Info
+        // and then calculate the byte offset from beginning to the field of struct
         else
         {
-            assert(false && "gep type pair only support arr/ptr/struct");
+            if(Options::ModelArrays())
+            {
+                const std::vector<u32_t>& so = SymbolTableInfo::SymbolInfo()
+                                               ->getTypeInfo(type)
+                                               ->getFlattenedElemIdxVec();
+                if (so.empty() || idxUb >= (APOffset)so.size() || idxLb < 0)
+                {
+                    byteLb = byteUb = 0;
+                }
+                else
+                {
+                    idxLb = SymbolTableInfo::SymbolInfo()->getFlattenedElemIdx(
+                                type, idxLb);
+                    idxUb = SymbolTableInfo::SymbolInfo()->getFlattenedElemIdx(
+                                type, idxUb);
+                    for (u32_t idx = 0; idx < idxLb; ++idx)
+                    {
+                        s64_t byte = SymbolTableInfo::SymbolInfo()->getFlatternedElemType(type, idx)->getByteSize();
+                        byteLb += byte;
+                    }
+                    byteUb = byteLb;
+                    for (u32_t idx = idxLb; idx < idxUb; ++idx)
+                    {
+                        s64_t byte = SymbolTableInfo::SymbolInfo()->getFlatternedElemType(type, idx)->getByteSize();
+                        byteUb += byte;
+                    }
+                }
+            }
+            else
+            {
+                byteLb = byteUb = 0;
+            }
+
         }
+        byte_res = byte_res + IntervalValue(byteLb, byteUb);
+    }
+
+    if (byte_res.isBottom())
+    {
+        byte_res = IntervalValue(0);
     }
-    return res; // Return the resulting byte offset as an IntervalValue.
+    return byte_res;
 }
 
 /**

package/svf/lib/MemoryModel/AccessPath.cpp

@@ -89,6 +89,32 @@ u32_t AccessPath::getElementNum(const SVFType* type) const
     }
 }
 
+
+/// Return byte offset from the beginning of the structure to the field where it is located for struct type
+///
+// e.g. idxOperandVar: i32 2  idxOperandType: %struct.Student = type { i32, [i8 x 12], i32 }
+//  we accumulate field 0 (i32) byte size (4 Bytes), and field 1 ([i8x12]) byte size (12 Bytes)
+//  then the return byte offset is 16 Bytes.
+u32_t AccessPath::getStructFieldOffset(const SVFVar* idxOperandVar, const SVFStructType* idxOperandType) const
+{
+    const SVFValue* idxValue = idxOperandVar->getValue();
+    u32_t structByteOffset = 0;
+    if (const SVFConstantInt *op = SVFUtil::dyn_cast<SVFConstantInt>(idxValue))
+    {
+        for (u32_t structField = 0; structField < (u32_t) op->getSExtValue(); ++structField)
+        {
+            u32_t flattenIdx = idxOperandType->getTypeInfo()->getFlattenedFieldIdxVec()[structField];
+            structByteOffset += idxOperandType->getTypeInfo()->getOriginalElemType(flattenIdx)->getByteSize();
+        }
+        return structByteOffset;
+    }
+    else
+    {
+        assert(false && "struct type can only pair with constant idx");
+        abort();
+    }
+}
+
 /// Return accumulated constant offset
 ///
 /// "value" is the offset variable (must be a constant)
@@ -156,31 +182,6 @@ APOffset AccessPath::computeConstantByteOffset() const
     return totalConstOffset;
 }
 
-/// Return byte offset from the beginning of the structure to the field where it is located for struct type
-///
-// e.g. idxOperandVar: i32 2  idxOperandType: %struct.Student = type { i32, [i8 x 12], i32 }
-//  we accumulate field 0 (i32) byte size (4 Bytes), and field 1 ([i8x12]) byte size (12 Bytes)
-//  then the return byte offset is 16 Bytes.
-u32_t AccessPath::getStructFieldOffset(const SVFVar* idxOperandVar, const SVFStructType* idxOperandType) const
-{
-    const SVFValue* idxValue = idxOperandVar->getValue();
-    u32_t structByteOffset = 0;
-    if (const SVFConstantInt *op = SVFUtil::dyn_cast<SVFConstantInt>(idxValue))
-    {
-        for (u32_t structField = 0; structField < (u32_t) op->getSExtValue(); ++structField)
-        {
-            u32_t flattenIdx = idxOperandType->getTypeInfo()->getFlattenedFieldIdxVec()[structField];
-            structByteOffset += idxOperandType->getTypeInfo()->getOriginalElemType(flattenIdx)->getByteSize();
-        }
-        return structByteOffset;
-    }
-    else
-    {
-        assert(false && "struct type can only pair with constant idx");
-        abort();
-    }
-}
-
 /// Return accumulated constant offset
 ///
 /// "value" is the offset variable (must be a constant)
@@ -244,7 +245,7 @@ APOffset AccessPath::computeConstantOffset() const
                 // set offset the last index of getFlattenedElemIdxVec to avoid assertion
                 if (offset >= (APOffset)so.size())
                 {
-                    SVFUtil::errs() << "It is overflow access, we access the last idx\n";
+                    SVFUtil::errs() << "It is an overflow access, hence it is the last idx\n";
                     offset = so.size() - 1;
                 }
                 else

package/svf-llvm/tools/AE/ae.cpp

@@ -46,6 +46,12 @@ static Option<bool> SYMABS(
     false
 );
 
+static Option<bool> AETEST(
+    "aetest",
+    "abstract execution basic function test",
+    false
+);
+
 class SymblicAbstractionTest
 {
 public:
@@ -590,7 +596,7 @@ public:
         // ground truth
         AbstractState::VarToAbsValMap intendedRes = {{0, IntervalValue(0, 10)},
             {1, IntervalValue(0, 10)},
-            {2, IntervalValue(IntervalValue::minus_infinity(), IntervalValue::plus_infinity())}
+            {2, IntervalValue(0, 10)}
         };
         assert(AbstractState::eqVarToValMap(resBS.getVarToVal(), intendedRes) && "inconsistency occurs");
     }
@@ -617,6 +623,210 @@ public:
     }
 };
 
+class AETest
+{
+public:
+    AETest() = default;
+
+    ~AETest() = default;
+
+    void testBinaryOpStmt()
+    {
+//        // test division /
+        assert((IntervalValue(4) / IntervalValue::bottom()).equals(IntervalValue::bottom()));
+        assert((IntervalValue::bottom() / IntervalValue(2)).equals(IntervalValue::bottom()));
+        assert((IntervalValue::top() / IntervalValue(0)).equals(IntervalValue::bottom()));
+        assert((IntervalValue(4) / IntervalValue(2)).equals(IntervalValue(2)));
+        assert((IntervalValue(3) / IntervalValue(2)).equals(IntervalValue(1))); //
+        assert((IntervalValue(-3) / IntervalValue(2)).equals(IntervalValue(-1))); //
+        assert((IntervalValue(1, 3) / IntervalValue(2)).equals(IntervalValue(0, 1))); //
+        assert((IntervalValue(2, 7) / IntervalValue(2)).equals(IntervalValue(1, 3))); //
+        assert((IntervalValue(-3, 3) / IntervalValue(2)).equals(IntervalValue(-1, 1)));
+        assert((IntervalValue(-3, IntervalValue::plus_infinity()) / IntervalValue(2)).equals(IntervalValue(-1, IntervalValue::plus_infinity())));
+        assert((IntervalValue(IntervalValue::minus_infinity(), 3) / IntervalValue(2)).equals(IntervalValue(IntervalValue::minus_infinity(), 1)));
+        assert((IntervalValue(1, 3) / IntervalValue(1, 2)).equals(IntervalValue(0, 3)));//
+        assert((IntervalValue(-3, 3) / IntervalValue(1, 2)).equals(IntervalValue(-3, 3)));
+        assert((IntervalValue(2, 7) / IntervalValue(-2, 3)).equals(IntervalValue(-7, 7))); //
+        assert((IntervalValue(-2, 7) / IntervalValue(-2, 3)).equals(IntervalValue(-7, 7))); //
+        assert((IntervalValue(IntervalValue::minus_infinity(), 7) / IntervalValue(-2, 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(-2, IntervalValue::plus_infinity()) / IntervalValue(-2, 3)).equals(IntervalValue::top()));
+
+        assert((IntervalValue(-2, 7) / IntervalValue(IntervalValue::minus_infinity(), 3)).equals(IntervalValue(-7, 7)));
+        assert((IntervalValue(-2, 7) / IntervalValue(-2, IntervalValue::plus_infinity())).equals(IntervalValue(-7, 7)));
+        assert((IntervalValue(-6, -3) / IntervalValue(3, 9)).equals(IntervalValue(-2, 0)));
+        assert((IntervalValue(-6, 6) / IntervalValue(3, 9)).equals(IntervalValue(-2, 2)));
+
+        // test remainder %
+        assert((IntervalValue(4) % IntervalValue::bottom()).equals(IntervalValue::bottom()));
+        assert((IntervalValue::bottom() % IntervalValue(2)).equals(IntervalValue::bottom()));
+        assert((IntervalValue::top() % IntervalValue(0)).equals(IntervalValue::top()));
+        assert((IntervalValue(4) % IntervalValue(2)).equals(IntervalValue(0)));
+        assert((IntervalValue(3) % IntervalValue(2)).equals(IntervalValue(1)));
+        assert((IntervalValue(-3) % IntervalValue(2)).equals(IntervalValue(-1)));
+        assert((IntervalValue(1, 3) % IntervalValue(2)).equals(IntervalValue(0, 1)));
+        assert((IntervalValue(2, 7) % IntervalValue(2)).equals(IntervalValue(0, 1)));
+        assert((IntervalValue(-3, 3) % IntervalValue(2)).equals(IntervalValue(-1, 1)));
+        assert((IntervalValue(-3, IntervalValue::plus_infinity()) % IntervalValue(2)).equals(IntervalValue(-1, 1)));
+        assert((IntervalValue(IntervalValue::minus_infinity(), 3) % IntervalValue(2)).equals(IntervalValue(-1, 1)));
+        assert((IntervalValue(1, 3) % IntervalValue(1, 2)).equals(IntervalValue(0, 1)));
+        assert((IntervalValue(-3, 3) % IntervalValue(1, 2)).equals(IntervalValue(-1, 1)));
+        assert((IntervalValue(2, 7) % IntervalValue(-2, 3)).equals(IntervalValue::top())); //
+        assert((IntervalValue(-2, 7) % IntervalValue(-2, 3)).equals(IntervalValue::top())); //
+        assert((IntervalValue(IntervalValue::minus_infinity(), 7) % IntervalValue(-2, 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(-2, IntervalValue::plus_infinity()) % IntervalValue(-2, 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(-2, 7) % IntervalValue(IntervalValue::minus_infinity(), 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(-2, 7) % IntervalValue(-2, IntervalValue::plus_infinity())).equals(IntervalValue::top()));
+        assert((IntervalValue(-6, -3) % IntervalValue(3, 9)).equals(IntervalValue(-6, 0)));
+        assert((IntervalValue(-6, 6) % IntervalValue(3, 9)).equals(IntervalValue(-6, 6)));
+
+        // shl  <<
+        assert((IntervalValue(IntervalValue::plus_infinity()) << IntervalValue(IntervalValue::plus_infinity())).equals(IntervalValue(IntervalValue::top())));
+        assert((IntervalValue(IntervalValue::plus_infinity()) << IntervalValue(2, 2)).equals(IntervalValue(IntervalValue::plus_infinity())));
+        assert((IntervalValue(IntervalValue::minus_infinity()) << IntervalValue(IntervalValue::plus_infinity())).equals(IntervalValue(IntervalValue::top())));
+        assert((IntervalValue(IntervalValue::minus_infinity()) << IntervalValue(2, 2)).equals(IntervalValue(IntervalValue::minus_infinity())));
+        assert((IntervalValue(2, 2) << IntervalValue(IntervalValue::plus_infinity())).equals(IntervalValue(IntervalValue::top())));
+        assert((IntervalValue(0, 0) << IntervalValue(IntervalValue::plus_infinity())).equals(IntervalValue(0, 0)));
+        assert((IntervalValue(-2, -2) << IntervalValue(IntervalValue::plus_infinity())).equals(IntervalValue(IntervalValue::top())));
+        assert((IntervalValue(0, 0) << IntervalValue(2, 2)).equals(IntervalValue(0, 0)));
+        assert((IntervalValue(2, 2) << IntervalValue(3, 3)).equals(IntervalValue(16, 16)));
+        assert((IntervalValue(-2, -2) << IntervalValue(3, 3)).equals(IntervalValue(-16, -16)));
+
+        assert((IntervalValue(4) << IntervalValue::bottom()).equals(IntervalValue::bottom()));
+        assert((IntervalValue::bottom() << IntervalValue(2)).equals(IntervalValue::bottom()));
+        assert((IntervalValue::top() << IntervalValue(0)).equals(IntervalValue::top()));
+        assert((IntervalValue(4) << IntervalValue(2)).equals(IntervalValue(16)));
+        assert((IntervalValue(3) << IntervalValue(2)).equals(IntervalValue(12)));
+        assert((IntervalValue(-3) << IntervalValue(2)).equals(IntervalValue(-12)));
+        assert((IntervalValue(4) << IntervalValue(-2)).equals(IntervalValue::bottom()));
+        assert((IntervalValue(1, 3) << IntervalValue(2)).equals(IntervalValue(4, 12)));
+        assert((IntervalValue(2, 7) << IntervalValue(2)).equals(IntervalValue(8, 28)));
+        assert((IntervalValue(-3, 3) << IntervalValue(2)).equals(IntervalValue(-12, 12)));
+        assert((IntervalValue(-3, IntervalValue::plus_infinity()) << IntervalValue(2)).equals(IntervalValue(-12, IntervalValue::plus_infinity())));
+        assert((IntervalValue(IntervalValue::minus_infinity(), 3) << IntervalValue(2)).equals(IntervalValue(IntervalValue::minus_infinity(), 12)));
+        assert((IntervalValue(1, 3) << IntervalValue(1, 2)).equals(IntervalValue(2, 12)));
+        assert((IntervalValue(-3, 3) << IntervalValue(1, 2)).equals(IntervalValue(-12, 12)));
+        assert((IntervalValue(2, 7) << IntervalValue(-2, 3)).equals(IntervalValue(2, 56)));
+        assert((IntervalValue(-2, 7) << IntervalValue(-2, 3)).equals(IntervalValue(-16, 56)));
+        assert((IntervalValue(IntervalValue::minus_infinity(), 7) << IntervalValue(-2, 3)).equals(IntervalValue(IntervalValue::minus_infinity(), 56)));
+        assert((IntervalValue(-2, IntervalValue::plus_infinity()) << IntervalValue(-2, 3)).equals(IntervalValue(-16, IntervalValue::plus_infinity())));
+        assert((IntervalValue(-2, 7) << IntervalValue(IntervalValue::minus_infinity(), 3)).equals(IntervalValue(-16, 56)));
+        assert((IntervalValue(-2, 7) << IntervalValue(-2, IntervalValue::plus_infinity())).equals(IntervalValue::top()));
+        assert((IntervalValue(-6, -3) << IntervalValue(3, 9)).equals(IntervalValue(-3072, -24)));
+        assert((IntervalValue(-6, 6) << IntervalValue(3, 9)).equals(IntervalValue(-3072, 3072)));
+        assert((IntervalValue(-2, 7) << IntervalValue(IntervalValue::minus_infinity(), -1)).equals(IntervalValue::bottom()));
+        assert((IntervalValue(0) << IntervalValue::top()).equals(IntervalValue(0)));
+
+
+        // shr >>
+        assert((IntervalValue(IntervalValue::plus_infinity()) >> IntervalValue(IntervalValue::plus_infinity())).equals(IntervalValue(IntervalValue::plus_infinity())));
+        assert((IntervalValue(IntervalValue::plus_infinity()) >> IntervalValue(2)).equals(IntervalValue(IntervalValue::plus_infinity())));
+        assert((IntervalValue(IntervalValue::minus_infinity()) >> IntervalValue(IntervalValue::plus_infinity())).equals(IntervalValue(IntervalValue::minus_infinity())));
+        assert((IntervalValue(IntervalValue::minus_infinity()) >> IntervalValue(2)).equals(IntervalValue(IntervalValue::minus_infinity())));
+        assert((IntervalValue(2) >> IntervalValue(IntervalValue::plus_infinity())).equals(IntervalValue(0)));
+        assert((IntervalValue(0) >> IntervalValue(IntervalValue::plus_infinity())).equals(IntervalValue(0)));
+        assert((IntervalValue(-2) >> IntervalValue(IntervalValue::plus_infinity())).equals(IntervalValue(-1)));
+        assert((IntervalValue(0) >> IntervalValue(2)).equals(IntervalValue(0)));
+        assert((IntervalValue(15) >> IntervalValue(2)).equals(IntervalValue(3)));
+        assert((IntervalValue(-15) >> IntervalValue(2)).equals(IntervalValue(-4)));
+
+        assert((IntervalValue(4) >> IntervalValue::bottom()).equals(IntervalValue::bottom()));
+        assert((IntervalValue::bottom() >> IntervalValue(2)).equals(IntervalValue::bottom()));
+        assert((IntervalValue::top() >> IntervalValue(0)).equals(IntervalValue::top()));
+        assert((IntervalValue(15) >> IntervalValue(2)).equals(IntervalValue(3)));
+        assert((IntervalValue(1) >> IntervalValue(2)).equals(IntervalValue(0)));
+        assert((IntervalValue(-15) >> IntervalValue(2)).equals(IntervalValue(-4)));
+        assert((IntervalValue(4) >> IntervalValue(-2)).equals(IntervalValue::bottom()));
+        assert((IntervalValue(1, 3) >> IntervalValue(2)).equals(IntervalValue(0)));
+        assert((IntervalValue(2, 7) >> IntervalValue(2)).equals(IntervalValue(0, 1)));
+        assert((IntervalValue(-15, 15) >> IntervalValue(2)).equals(IntervalValue(-4, 3)));
+        assert((IntervalValue(-15, IntervalValue::plus_infinity()) >> IntervalValue(2)).equals(IntervalValue(-4, IntervalValue::plus_infinity())));
+        assert((IntervalValue(IntervalValue::minus_infinity(), 15) >> IntervalValue(2)).equals(IntervalValue(IntervalValue::minus_infinity(), 3)));
+        assert((IntervalValue(0, 15) >> IntervalValue(1, 2)).equals(IntervalValue(0, 7)));
+        assert((IntervalValue(-17, 15) >> IntervalValue(1, 2)).equals(IntervalValue(-9, 7)));
+        assert((IntervalValue(2, 7) >> IntervalValue(-2, 3)).equals(IntervalValue(0, 7)));
+        assert((IntervalValue(-2, 7) >> IntervalValue(-2, 3)).equals(IntervalValue(-2, 7)));
+        assert((IntervalValue(IntervalValue::minus_infinity(), 7) >> IntervalValue(-2, 3)).equals(IntervalValue(IntervalValue::minus_infinity(), 7)));
+        assert((IntervalValue(-2, IntervalValue::plus_infinity()) >> IntervalValue(-2, 3)).equals(IntervalValue(-2, IntervalValue::plus_infinity())));
+        assert((IntervalValue(-2, 7) >> IntervalValue(IntervalValue::minus_infinity(), 3)).equals(IntervalValue(-2, 7)));
+        assert((IntervalValue(-2, 7) >> IntervalValue(-2, IntervalValue::plus_infinity())).equals(IntervalValue(-2, 7)));
+        assert((IntervalValue(-6, -3) >> IntervalValue(2, 3)).equals(IntervalValue(-2, -1)));
+        assert((IntervalValue(-6, 6) >> IntervalValue(2, 3)).equals(IntervalValue(-2, 1)));
+        assert((IntervalValue(-2, 7) >> IntervalValue(IntervalValue::minus_infinity(), -1)).equals(IntervalValue::bottom()));
+        assert((IntervalValue(0) >> IntervalValue::top()).equals(IntervalValue(0)));
+
+        // and &
+        assert((IntervalValue(4) & IntervalValue::bottom()).equals(IntervalValue::bottom()));
+        assert((IntervalValue::bottom() & IntervalValue(2)).equals(IntervalValue::bottom()));
+        assert((IntervalValue::top() & IntervalValue(0)).equals(IntervalValue(0)));
+        assert((IntervalValue(4) & IntervalValue(2)).equals(IntervalValue(0)));
+        assert((IntervalValue(3) & IntervalValue(2)).equals(IntervalValue(2)));
+        assert((IntervalValue(-3) & IntervalValue(2)).equals(IntervalValue(0)));
+        assert((IntervalValue(1, 3) & IntervalValue(2)).equals(IntervalValue(0, 2)));
+        assert((IntervalValue(2, 7) & IntervalValue(2)).equals(IntervalValue(0, 2)));
+        assert((IntervalValue(-3, 3) & IntervalValue(2)).equals(IntervalValue(0, 2)));
+        assert((IntervalValue(-3, IntervalValue::plus_infinity()) & IntervalValue(2)).equals(IntervalValue(0, 2)));
+        assert((IntervalValue(IntervalValue::minus_infinity(), 3) & IntervalValue(2)).equals(IntervalValue(0, 2)));
+        assert((IntervalValue(1, 3) & IntervalValue(1, 2)).equals(IntervalValue(0, 2)));
+        assert((IntervalValue(-3, 3) & IntervalValue(1, 2)).equals(IntervalValue(0, 2)));
+        assert((IntervalValue(2, 7) & IntervalValue(-2, 3)).equals(IntervalValue(0, 7)));
+        assert((IntervalValue(-2, 7) & IntervalValue(-2, 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(IntervalValue::minus_infinity(), 7) & IntervalValue(-2, 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(-2, IntervalValue::plus_infinity()) & IntervalValue(-2, 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(-2, 7) & IntervalValue(IntervalValue::minus_infinity(), 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(-2, 7) & IntervalValue(-2, IntervalValue::plus_infinity())).equals(IntervalValue::top()));
+        assert((IntervalValue(-6, -3) & IntervalValue(3, 9)).equals(IntervalValue(0, 9)));
+        assert((IntervalValue(-6, 6) & IntervalValue(3, 9)).equals(IntervalValue(0, 9)));
+
+        // Or |
+        assert((IntervalValue(4) | IntervalValue::bottom()).equals(IntervalValue::bottom()));
+        assert((IntervalValue::bottom() | IntervalValue(2)).equals(IntervalValue::bottom()));
+        assert((IntervalValue::top() | IntervalValue(-1)).equals(IntervalValue::top()));//
+        assert((IntervalValue(-1) | IntervalValue::top()).equals(IntervalValue::top()));//
+        assert((IntervalValue(4) | IntervalValue(2)).equals(IntervalValue(6)));
+        assert((IntervalValue(3) | IntervalValue(2)).equals(IntervalValue(3)));
+        assert((IntervalValue(-3) | IntervalValue(2)).equals(IntervalValue(-1)));
+        assert((IntervalValue(1, 3) | IntervalValue(2)).equals(IntervalValue(0, 3)));
+        assert((IntervalValue(2, 7) | IntervalValue(2)).equals(IntervalValue(0, 7)));
+        assert((IntervalValue(-3, 3) | IntervalValue(2)).equals(IntervalValue::top()));
+        assert((IntervalValue(-3, IntervalValue::plus_infinity()) | IntervalValue(2)).equals(IntervalValue::top()));
+        assert((IntervalValue(IntervalValue::minus_infinity(), 3) | IntervalValue(2)).equals(IntervalValue::top()));
+        assert((IntervalValue(1, 3) | IntervalValue(1, 2)).equals(IntervalValue(0, 3)));
+        assert((IntervalValue(-3, 3) | IntervalValue(1, 2)).equals(IntervalValue::top()));
+        assert((IntervalValue(2, 7) | IntervalValue(-2, 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(-2, 7) | IntervalValue(-2, 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(IntervalValue::minus_infinity(), 7) | IntervalValue(-2, 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(-2, IntervalValue::plus_infinity()) | IntervalValue(-2, 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(-2, 7) | IntervalValue(IntervalValue::minus_infinity(), 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(-2, 7) | IntervalValue(-2, IntervalValue::plus_infinity())).equals(IntervalValue::top()));
+        assert((IntervalValue(-6, -3) | IntervalValue(3, 9)).equals(IntervalValue::top()));
+        assert((IntervalValue(-6, 6) | IntervalValue(3, 9)).equals(IntervalValue::top()));
+
+        // Xor ^
+        assert((IntervalValue(4) ^ IntervalValue::bottom()).equals(IntervalValue::bottom()));
+        assert((IntervalValue::bottom() ^ IntervalValue(2)).equals(IntervalValue::bottom()));
+        assert((IntervalValue::top() ^ IntervalValue(-1)).equals(IntervalValue::top()));
+        assert((IntervalValue(-1) ^ IntervalValue::top()).equals(IntervalValue::top()));
+        assert((IntervalValue(4) ^ IntervalValue(2)).equals(IntervalValue(6)));
+        assert((IntervalValue(3) ^ IntervalValue(2)).equals(IntervalValue(1)));
+        assert((IntervalValue(-3) ^ IntervalValue(2)).equals(IntervalValue(-1)));
+        assert((IntervalValue(1, 3) ^ IntervalValue(2)).equals(IntervalValue(0, 3)));
+        assert((IntervalValue(2, 7) ^ IntervalValue(2)).equals(IntervalValue(0, 7)));
+        assert((IntervalValue(-3, 3) ^ IntervalValue(2)).equals(IntervalValue::top()));
+        assert((IntervalValue(-3, IntervalValue::plus_infinity()) ^ IntervalValue(2)).equals(IntervalValue::top()));
+        assert((IntervalValue(IntervalValue::minus_infinity(), 3) ^ IntervalValue(2)).equals(IntervalValue::top()));
+        assert((IntervalValue(1, 3) ^ IntervalValue(1, 2)).equals(IntervalValue(0, 3)));
+        assert((IntervalValue(-3, 3) ^ IntervalValue(1, 2)).equals(IntervalValue::top()));
+        assert((IntervalValue(2, 7) ^ IntervalValue(-2, 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(-2, 7) ^ IntervalValue(-2, 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(IntervalValue::minus_infinity(), 7) ^ IntervalValue(-2, 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(-2, IntervalValue::plus_infinity()) ^ IntervalValue(-2, 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(-2, 7) ^ IntervalValue(IntervalValue::minus_infinity(), 3)).equals(IntervalValue::top()));
+        assert((IntervalValue(-2, 7) ^ IntervalValue(-2, IntervalValue::plus_infinity())).equals(IntervalValue::top()));
+        assert((IntervalValue(-6, -3) ^ IntervalValue(3, 9)).equals(IntervalValue::top()));
+        assert((IntervalValue(-6, 6) ^ IntervalValue(3, 9)).equals(IntervalValue::top()));
+    }
+};
+
 
 int main(int argc, char** argv)
 {
@@ -645,6 +855,13 @@ int main(int argc, char** argv)
         return 0;
     }
 
+    if (AETEST())
+    {
+        AETest aeTest;
+        aeTest.testBinaryOpStmt();
+        return 0;
+    }
+
     SVFModule *svfModule = LLVMModuleSet::getLLVMModuleSet()->buildSVFModule(moduleNameVec);
     SVFIRBuilder builder(svfModule);
     SVFIR* pag = builder.build();