svf-tools 1.0.771 → 1.0.773

package/SVF-doxygen/html/html/structstd_1_1hash_3_01SVF_1_1BoundedZ3Expr_01_4.html

@@ -86,7 +86,7 @@ Public Member Functions</h2></td></tr>
 <a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
 <div class="textblock"><p>Specialise hash for ConZ3Expr. </p>
 
-<p class="definition">Definition at line <a class="el" href="BoundedZ3Expr_8h_source.html#l00384">384</a> of file <a class="el" href="BoundedZ3Expr_8h_source.html">BoundedZ3Expr.h</a>.</p>
+<p class="definition">Definition at line <a class="el" href="BoundedZ3Expr_8h_source.html#l00383">383</a> of file <a class="el" href="BoundedZ3Expr_8h_source.html">BoundedZ3Expr.h</a>.</p>
 </div><h2 class="groupheader">Member Function Documentation</h2>
 <a id="a232e38e5365af047f57631b121a04e66"></a>
 <h2 class="memtitle"><span class="permalink"><a href="#a232e38e5365af047f57631b121a04e66">&#9670;&nbsp;</a></span>operator()()</h2>
@@ -112,10 +112,10 @@ Public Member Functions</h2></td></tr>
 </table>
 </div><div class="memdoc">
 
-<p class="definition">Definition at line <a class="el" href="BoundedZ3Expr_8h_source.html#l00386">386</a> of file <a class="el" href="BoundedZ3Expr_8h_source.html">BoundedZ3Expr.h</a>.</p>
-<div class="fragment"><div class="line"><a name="l00387"></a><span class="lineno">  387</span>&#160;    {</div>
-<div class="line"><a name="l00388"></a><span class="lineno">  388</span>&#160;        <span class="keywordflow">return</span> z3Expr.<a class="code" href="classSVF_1_1Z3Expr.html#a631cb7cee0e1f9b7204b9293f4e516a9">hash</a>();</div>
-<div class="line"><a name="l00389"></a><span class="lineno">  389</span>&#160;    }</div>
+<p class="definition">Definition at line <a class="el" href="BoundedZ3Expr_8h_source.html#l00385">385</a> of file <a class="el" href="BoundedZ3Expr_8h_source.html">BoundedZ3Expr.h</a>.</p>
+<div class="fragment"><div class="line"><a name="l00386"></a><span class="lineno">  386</span>&#160;    {</div>
+<div class="line"><a name="l00387"></a><span class="lineno">  387</span>&#160;        <span class="keywordflow">return</span> z3Expr.<a class="code" href="classSVF_1_1Z3Expr.html#a631cb7cee0e1f9b7204b9293f4e516a9">hash</a>();</div>
+<div class="line"><a name="l00388"></a><span class="lineno">  388</span>&#160;    }</div>
 </div><!-- fragment -->
 </div>
 </div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.771",
+  "version": "1.0.773",
   "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/AbstractExecution/BoundedZ3Expr.h

@@ -51,11 +51,10 @@ public:
 
     BoundedZ3Expr(s32_t i) : Z3Expr(i) {}
 
-    BoundedZ3Expr(int64_t i) : Z3Expr(getContext().int_val(i)) {}
+    BoundedZ3Expr(s64_t i) : Z3Expr(getContext().int_val((int64_t)i)) {}
 
     BoundedZ3Expr(const BoundedZ3Expr &z3Expr) : Z3Expr(z3Expr) {}
 
-
     inline BoundedZ3Expr &operator=(const BoundedZ3Expr &rhs)
     {
         Z3Expr::operator=(rhs);
@@ -347,13 +346,13 @@ public:
     }
 
     /// Return Numeral
-    inline int64_t getNumeral() const
+    inline s64_t getNumeral() const
     {
         if (is_numeral())
         {
             int64_t i;
             if (getExpr().is_numeral_i64(i))
-                return get_numeral_int64();
+                return (s64_t)get_numeral_int64();
             else
             {
                 return (getExpr() < 0).simplify().is_true() ? INT64_MIN : INT64_MAX;
@@ -374,7 +373,7 @@ public:
         }
     }
 
-    int64_t bvLen() const;
+    s64_t bvLen() const;
     //%}
 }; // end class ConZ3Expr
 } // end namespace SVF

package/svf/include/AbstractExecution/IntervalValue.h

@@ -95,13 +95,13 @@ public:
     explicit IntervalValue() : AbstractValue(AbstractValue::IntervalK), _lb(minus_infinity()), _ub(plus_infinity()) {}
 
     /// Create the IntervalValue [n, n]
-    explicit IntervalValue(int64_t n) : AbstractValue(AbstractValue::IntervalK), _lb(n), _ub(n) {}
+    explicit IntervalValue(s64_t n) : AbstractValue(AbstractValue::IntervalK), _lb(n), _ub(n) {}
 
-    explicit IntervalValue(s32_t n) : IntervalValue((int64_t) n) {}
+    explicit IntervalValue(s32_t n) : IntervalValue((s64_t) n) {}
 
-    explicit IntervalValue(u32_t n) : IntervalValue((int64_t) n) {}
+    explicit IntervalValue(u32_t n) : IntervalValue((s64_t) n) {}
 
-    explicit IntervalValue(double n) : IntervalValue((int64_t) n) {}
+    explicit IntervalValue(double n) : IntervalValue((s64_t) n) {}
 
     explicit IntervalValue(NumericLiteral n) : IntervalValue(n, n) {}
 
@@ -109,15 +109,15 @@ public:
     explicit IntervalValue(NumericLiteral lb, NumericLiteral ub) : AbstractValue(AbstractValue::IntervalK),
         _lb(std::move(lb)), _ub(std::move(ub)) {}
 
-    explicit IntervalValue(int64_t lb, int64_t ub) : IntervalValue(NumericLiteral(lb), NumericLiteral(ub)) {}
+    explicit IntervalValue(s64_t lb, s64_t ub) : IntervalValue(NumericLiteral(lb), NumericLiteral(ub)) {}
 
-    explicit IntervalValue(double lb, double ub) : IntervalValue(NumericLiteral((int64_t) lb), NumericLiteral((int64_t) ub)) {}
+    explicit IntervalValue(double lb, double ub) : IntervalValue(NumericLiteral((s64_t) lb), NumericLiteral((s64_t) ub)) {}
 
-    explicit IntervalValue(s32_t lb, s32_t ub) : IntervalValue((int64_t) lb, (int64_t) ub) {}
+    explicit IntervalValue(s32_t lb, s32_t ub) : IntervalValue((s64_t) lb, (s64_t) ub) {}
 
-    explicit IntervalValue(u32_t lb, u32_t ub) : IntervalValue((int64_t) lb, (int64_t) ub) {}
+    explicit IntervalValue(u32_t lb, u32_t ub) : IntervalValue((s64_t) lb, (s64_t) ub) {}
 
-    explicit IntervalValue(u64_t lb, u64_t ub) : IntervalValue((int64_t) lb, (int64_t) ub) {}
+    explicit IntervalValue(u64_t lb, u64_t ub) : IntervalValue((s64_t) lb, (s64_t) ub) {}
 
     /// Copy constructor
     IntervalValue(const IntervalValue &) = default;
@@ -260,7 +260,7 @@ public:
     }
 
     /// Return
-    int64_t getNumeral() const
+    s64_t getNumeral() const
     {
         assert(is_numeral() && "this IntervalValue is not numeral");
         return _lb.getNumeral();
@@ -800,15 +800,15 @@ inline IntervalValue operator&(const IntervalValue &lhs, const IntervalValue &rh
     }
     else if (lhs.lb().getNumeral() >= 0 && rhs.lb().getNumeral() >= 0)
     {
-        return IntervalValue((int64_t) 0, min(lhs.ub(), rhs.ub()));
+        return IntervalValue((s64_t) 0, min(lhs.ub(), rhs.ub()));
     }
     else if (lhs.lb().getNumeral() >= 0)
     {
-        return IntervalValue((int64_t) 0, lhs.ub());
+        return IntervalValue((s64_t) 0, lhs.ub());
     }
     else if (rhs.lb().getNumeral() >= 0)
     {
-        return IntervalValue((int64_t) 0, rhs.ub());
+        return IntervalValue((s64_t) 0, rhs.ub());
     }
     else
     {
@@ -835,9 +835,9 @@ inline IntervalValue operator|(const IntervalValue &lhs, const IntervalValue &rh
     else if (lhs.lb().getNumeral() >= 0 && !lhs.ub().is_infinity() &&
              rhs.lb().getNumeral() >= 0 && !rhs.ub().is_infinity())
     {
-        int64_t m = std::max(lhs.ub().getNumeral(), rhs.ub().getNumeral());
-        int64_t ub = next_power_of_2(s64_t(m+1));
-        return IntervalValue((int64_t) 0, (int64_t) ub);
+        s64_t m = std::max(lhs.ub().getNumeral(), rhs.ub().getNumeral());
+        s64_t ub = next_power_of_2(s64_t(m+1));
+        return IntervalValue((s64_t) 0, (s64_t) ub);
     }
     else
     {
@@ -864,9 +864,9 @@ inline IntervalValue operator^(const IntervalValue &lhs, const IntervalValue &rh
     else if (lhs.lb().getNumeral() >= 0 && !lhs.ub().is_infinity() &&
              rhs.lb().getNumeral() >= 0 && !rhs.ub().is_infinity())
     {
-        int64_t m = std::max(lhs.ub().getNumeral(), rhs.ub().getNumeral());
-        int64_t ub = next_power_of_2(s64_t(m+1));
-        return IntervalValue((int64_t) 0, (int64_t) ub);
+        s64_t m = std::max(lhs.ub().getNumeral(), rhs.ub().getNumeral());
+        s64_t ub = next_power_of_2(s64_t(m+1));
+        return IntervalValue((s64_t) 0, (s64_t) ub);
     }
     else
     {

package/svf/include/AbstractExecution/NumericLiteral.h

@@ -54,7 +54,7 @@ public:
 
     NumericLiteral(s32_t i) : _n(i) {}
 
-    NumericLiteral(int64_t i) : _n(i) {}
+    NumericLiteral(s64_t i) : _n(i) {}
 
     NumericLiteral(BoundedZ3Expr z3Expr) : _n(std::move(z3Expr)) {}
 
@@ -117,7 +117,7 @@ public:
     }
 
     /// Return Numeral
-    inline int64_t getNumeral() const
+    inline s64_t getNumeral() const
     {
         return _n.getNumeral();
     }

package/svf/include/AbstractExecution/SVFIR2ItvExeState.h

@@ -71,23 +71,23 @@ public:
     void narrowVAddrs(IntervalExeState &lhs, const IntervalExeState &rhs);
 
     /// Return the field address given a pointer points to a struct object and an offset
-    VAddrs getGepObjAddress(u32_t pointer, s32_t offset);
+    VAddrs getGepObjAddress(u32_t pointer, APOffset offset);
 
     /// Return the byte offset from one gep param offset
-    std::pair<s32_t, s32_t> getBytefromGepTypePair(const AccessPath::VarAndGepTypePair& gep_pair, const GepStmt *gep, s32_t elem_bytesize);
+    std::pair<APOffset, APOffset> getBytefromGepTypePair(const AccessPath::VarAndGepTypePair& gep_pair, const GepStmt *gep, APOffset elem_bytesize);
 
     /// Return the Index offset from one gep param offset
-    std::pair<s32_t, s32_t> getIndexfromGepTypePair(const AccessPath::VarAndGepTypePair& gep_pair, const GepStmt *gep);
+    std::pair<APOffset, APOffset> getIndexfromGepTypePair(const AccessPath::VarAndGepTypePair& gep_pair, const GepStmt *gep);
 
     /// Return the byte offset expression of a GepStmt
     /// elemBytesize is the element byte size of an static alloc or heap alloc array
     /// e.g. GepStmt* gep = **,
     /// s32_t elemBytesize = LLVMUtil::SVFType2ByteSize(gep->getRHSVar()->getValue()->getType());
     /// std::pair<s32_t, s32_t> byteOffset = getGepByteOffset(gep, elemBytesize);
-    std::pair<s32_t, s32_t> getGepByteOffset(const GepStmt *gep, s32_t elemBytesize);
+    std::pair<APOffset, APOffset> getGepByteOffset(const GepStmt *gep, APOffset elemBytesize);
 
     /// Return the offset expression of a GepStmt
-    std::pair<s32_t, s32_t> getGepOffset(const GepStmt *gep);
+    std::pair<APOffset, APOffset> getGepOffset(const GepStmt *gep);
 
 
     static z3::context &getContext()

package/svf/lib/AbstractExecution/BoundedZ3Expr.cpp

@@ -31,11 +31,11 @@
 
 using namespace SVF;
 
-int64_t BoundedZ3Expr::bvLen() const
+s64_t BoundedZ3Expr::bvLen() const
 {
-    if(is_infinite()) return Options::MaxBVLen();
+    if(is_infinite()) return (s64_t)Options::MaxBVLen();
     // No overflow
-    if(getNumeral() != INT64_MIN && getNumeral() != INT64_MAX) return Options::MaxBVLen();
+    if(getNumeral() != INT64_MIN && getNumeral() != INT64_MAX) return (s64_t)Options::MaxBVLen();
     // Create a symbolic variable
     Z3Expr x = getContext().real_const("x");
     Z3Expr y = getContext().real_const("y");
@@ -54,11 +54,11 @@ int64_t BoundedZ3Expr::bvLen() const
         z3::model model = solver->get_model();
         Z3Expr log2_x = model.eval(y.getExpr(), true);
         Z3Expr::getSolver().pop();
-        return BoundedZ3Expr(log2_x + 1).simplify().getNumeral();
+        return (s64_t)BoundedZ3Expr(log2_x + 1).simplify().getNumeral();
     }
     else
     {
         Z3Expr::getSolver().pop();
-        return Options::MaxBVLen();
+        return (s64_t)Options::MaxBVLen();
     }
 }

package/svf/lib/AbstractExecution/SVFIR2ItvExeState.cpp

@@ -152,7 +152,7 @@ void SVFIR2ItvExeState::narrowVAddrs(IntervalExeState &lhs, const IntervalExeSta
     }
 }
 
-SVFIR2ItvExeState::VAddrs SVFIR2ItvExeState::getGepObjAddress(u32_t pointer, s32_t offset)
+SVFIR2ItvExeState::VAddrs SVFIR2ItvExeState::getGepObjAddress(u32_t pointer, APOffset offset)
 {
     assert(!getVAddrs(pointer).empty());
     VAddrs &addrs = getVAddrs(pointer);
@@ -173,37 +173,53 @@ SVFIR2ItvExeState::VAddrs SVFIR2ItvExeState::getGepObjAddress(u32_t pointer, s32
     return ret;
 }
 
-std::pair<s32_t, s32_t> SVFIR2ItvExeState::getBytefromGepTypePair(const AccessPath::VarAndGepTypePair& gep_pair, const GepStmt *gep, s32_t elemBytesize)
+std::pair<APOffset, APOffset> SVFIR2ItvExeState::getBytefromGepTypePair(const AccessPath::VarAndGepTypePair& gep_pair, const GepStmt *gep, APOffset elemBytesize)
 {
     const SVFValue *value = gep_pair.first->getValue();
     const SVFType *type = gep_pair.second;
     const SVFConstantInt *op = SVFUtil::dyn_cast<SVFConstantInt>(value);
-    s32_t offsetLb = 0;
-    s32_t offsetUb = 0;
+    APOffset offsetLb = 0;
+    APOffset offsetUb = 0;
     /// set largest byte offset is 0xFFFFFF in case of int32 overflow
-    s32_t maxFieldLimit = 0xFFFFFF;
+    APOffset maxByteLimit = 99999;
+    APOffset minByteLimit = -99999;
+    auto valueReshape = [&](s64_t offset)
+    {
+        if (offset < (s64_t)minByteLimit)
+        {
+            return minByteLimit;
+        }
+        else if (offset > (s64_t)maxByteLimit)
+        {
+            return maxByteLimit;
+        }
+        else
+        {
+            return offset;
+        }
+    };
     /// offset is constant but stored in variable
     if (op)
     {
-        offsetLb = offsetUb = op->getSExtValue() >
-                              maxFieldLimit? maxFieldLimit: op->getSExtValue();
+        offsetLb = offsetUb = op->getSExtValue() > maxByteLimit
+                              ? maxByteLimit
+                              : op->getSExtValue();
     }
     else
     {
         u32_t idx = _svfir->getValueNode(value);
         IntervalValue &idxVal = _es[idx];
         if (idxVal.isBottom() || idxVal.isTop())
-            return std::make_pair(0, maxFieldLimit);
+            return std::make_pair(0, maxByteLimit);
         // if idxVal is a concrete value
         if (idxVal.is_numeral())
         {
-            offsetLb = offsetUb = idxVal.lb().getNumeral()>
-                                  maxFieldLimit? maxFieldLimit: idxVal.lb().getNumeral();
+            offsetLb = offsetUb = valueReshape(idxVal.lb().getNumeral());
         }
         else
         {
-            offsetLb = idxVal.lb().getNumeral()> maxFieldLimit? maxFieldLimit:idxVal.lb().getNumeral() * elemBytesize ;
-            offsetUb = idxVal.ub().getNumeral() > maxFieldLimit? maxFieldLimit:idxVal.ub().getNumeral() * elemBytesize;
+            offsetLb = valueReshape(idxVal.lb().getNumeral());
+            offsetUb = valueReshape(idxVal.ub().getNumeral());
         }
     }
 
@@ -224,19 +240,34 @@ std::pair<s32_t, s32_t> SVFIR2ItvExeState::getBytefromGepTypePair(const AccessPa
 }
 
 
-std::pair<s32_t, s32_t> SVFIR2ItvExeState::getIndexfromGepTypePair(const AccessPath::VarAndGepTypePair& gep_pair, const GepStmt *gep)
+std::pair<APOffset, APOffset> SVFIR2ItvExeState::getIndexfromGepTypePair(const AccessPath::VarAndGepTypePair& gep_pair, const GepStmt *gep)
 {
     const SVFValue *value = gep_pair.first->getValue();
     const SVFType *type = gep_pair.second;
     const SVFConstantInt *op = SVFUtil::dyn_cast<SVFConstantInt>(value);
-    s32_t offsetLb = 0;
-    s32_t offsetUb = 0;
-    s32_t maxFieldLimit = (s32_t)Options::MaxFieldLimit();
+    APOffset offsetLb = 0;
+    APOffset offsetUb = 0;
+    APOffset maxFieldLimit = (APOffset)Options::MaxFieldLimit();
+    APOffset minFieldLimit = 0;
+    auto valueReshape = [&](s64_t offset)
+    {
+        if (offset < minFieldLimit)
+        {
+            return minFieldLimit;
+        }
+        else if (offset > maxFieldLimit)
+        {
+            return maxFieldLimit;
+        }
+        else
+        {
+            return offset;
+        }
+    };
     /// offset is constant but stored in variable
     if (op)
     {
-        offsetLb = offsetUb = op->getSExtValue() >
-                              maxFieldLimit? maxFieldLimit: op->getSExtValue();
+        offsetLb = offsetUb = valueReshape(op->getSExtValue());
     }
     else
     {
@@ -244,27 +275,16 @@ std::pair<s32_t, s32_t> SVFIR2ItvExeState::getIndexfromGepTypePair(const AccessP
         //if (!inVarToIValTable(idx)) return std::make_pair(-1, -1);
         IntervalValue &idxVal = _es[idx];
         if (idxVal.isBottom() || idxVal.isTop())
-            return std::make_pair(0, (s32_t)Options::MaxFieldLimit());
+            return std::make_pair(0, Options::MaxFieldLimit());
         // if idxVal is a concrete value
         if (idxVal.is_numeral())
         {
-            offsetLb = offsetUb = idxVal.lb().getNumeral()>
-                                  maxFieldLimit? maxFieldLimit: idxVal.lb().getNumeral();
+            offsetLb = offsetUb = valueReshape(idxVal.lb().getNumeral());
         }
         else
         {
-            offsetLb = idxVal.lb().getNumeral() < 0
-                       ? 0
-                       : idxVal.lb().getNumeral();
-            offsetLb = idxVal.lb().getNumeral() > maxFieldLimit
-                       ? maxFieldLimit
-                       : offsetLb;
-            offsetUb = idxVal.ub().getNumeral() < 0
-                       ? 0
-                       : idxVal.ub().getNumeral();
-            offsetUb = idxVal.ub().getNumeral() > maxFieldLimit
-                       ? maxFieldLimit
-                       : offsetUb;
+            offsetLb = valueReshape(idxVal.lb().getNumeral());
+            offsetUb = valueReshape(idxVal.ub().getNumeral());
         }
     }
 
@@ -280,8 +300,8 @@ std::pair<s32_t, s32_t> SVFIR2ItvExeState::getIndexfromGepTypePair(const AccessP
             const std::vector<u32_t>& so = SymbolTableInfo::SymbolInfo()
                                            ->getTypeInfo(type)
                                            ->getFlattenedElemIdxVec();
-            if (so.empty() || (u32_t)offsetUb >= so.size() ||
-                    (u32_t)offsetLb >= so.size())
+            if (so.empty() || offsetUb >= (APOffset)so.size() ||
+                    offsetLb >= (APOffset)so.size())
             {
                 offsetLb = 0;
                 offsetUb = maxFieldLimit;
@@ -301,26 +321,26 @@ std::pair<s32_t, s32_t> SVFIR2ItvExeState::getIndexfromGepTypePair(const AccessP
 }
 
 
-std::pair<s32_t, s32_t> SVFIR2ItvExeState::getGepByteOffset(const GepStmt *gep, s32_t elemBytesize)
+std::pair<APOffset, APOffset> SVFIR2ItvExeState::getGepByteOffset(const GepStmt *gep, APOffset elemBytesize)
 {
     /// for instant constant index, e.g.  gep arr, 1
     if (gep->getOffsetVarAndGepTypePairVec().empty())
         return std::make_pair(gep->getConstantFieldIdx(), gep->getConstantFieldIdx());
-    s32_t totalOffsetLb = 0;
-    s32_t totalOffsetUb = 0;
+    APOffset totalOffsetLb = 0;
+    APOffset totalOffsetUb = 0;
     /// default value of MaxFieldLimit is 512
-    u32_t maxFieldLimit = 0xFFFFFF;
+    APOffset maxFieldLimit = 0xFFFFFF;
     for (int i = gep->getOffsetVarAndGepTypePairVec().size() - 1; i >= 0; i--)
     {
-        std::pair<s32_t, s32_t> offsetIdx = getBytefromGepTypePair(
-                                                gep->getOffsetVarAndGepTypePairVec()[i], gep, elemBytesize);
-        s32_t offsetLb = offsetIdx.first;
-        s32_t offsetUb = offsetIdx.second;
-        if ((long long) (totalOffsetLb + offsetLb) > maxFieldLimit)
+        std::pair<APOffset, APOffset> offsetIdx = getBytefromGepTypePair(
+                    gep->getOffsetVarAndGepTypePairVec()[i], gep, elemBytesize);
+        APOffset offsetLb = offsetIdx.first;
+        APOffset offsetUb = offsetIdx.second;
+        if (totalOffsetLb + offsetLb > maxFieldLimit)
             totalOffsetLb = maxFieldLimit;
         else
             totalOffsetLb += offsetLb;
-        if ((long long) (totalOffsetUb + offsetUb) > maxFieldLimit)
+        if (totalOffsetUb + offsetUb > maxFieldLimit)
             totalOffsetUb = maxFieldLimit;
         else
             totalOffsetUb += offsetUb ;
@@ -329,21 +349,21 @@ std::pair<s32_t, s32_t> SVFIR2ItvExeState::getGepByteOffset(const GepStmt *gep,
 }
 
 
-std::pair<s32_t, s32_t> SVFIR2ItvExeState::getGepOffset(const GepStmt *gep)
+std::pair<APOffset, APOffset> SVFIR2ItvExeState::getGepOffset(const GepStmt *gep)
 {
     /// for instant constant index, e.g.  gep arr, 1
     if (gep->getOffsetVarAndGepTypePairVec().empty())
         return std::make_pair(gep->getConstantFieldIdx(), gep->getConstantFieldIdx());
-    s32_t totalOffsetLb = 0;
-    s32_t totalOffsetUb = 0;
+    APOffset totalOffsetLb = 0;
+    APOffset totalOffsetUb = 0;
     /// default value of MaxFieldLimit is 512
-    u32_t maxFieldLimit = Options::MaxFieldLimit() - 1;
+    APOffset maxFieldLimit = Options::MaxFieldLimit() - 1;
     for (int i = gep->getOffsetVarAndGepTypePairVec().size() - 1; i >= 0; i--)
     {
-        std::pair<s32_t, s32_t> offsetIdx = getIndexfromGepTypePair(
-                                                gep->getOffsetVarAndGepTypePairVec()[i], gep);
-        s32_t offsetLb = offsetIdx.first;
-        s32_t offsetUb = offsetIdx.second;
+        std::pair<APOffset, APOffset> offsetIdx = getIndexfromGepTypePair(
+                    gep->getOffsetVarAndGepTypePairVec()[i], gep);
+        APOffset offsetLb = offsetIdx.first;
+        APOffset offsetUb = offsetIdx.second;
         if ((long long) (totalOffsetLb + offsetLb) > maxFieldLimit)
             totalOffsetLb = maxFieldLimit;
         else
@@ -612,10 +632,6 @@ void SVFIR2ItvExeState::translateCmp(const CmpStmt *cmp)
     {
         IntervalValue resVal;
         VAddrs &lhs = getVAddrs(op0), &rhs = getVAddrs(op1);
-//        if (lhs.empty() || rhs.empty()) {
-//            outs() << "empty address cmp?\n";
-//            return;
-//        }
         assert(!lhs.empty() && !rhs.empty() && "empty address?");
         auto predicate = cmp->getPredicate();
         switch (predicate)
@@ -842,7 +858,7 @@ void SVFIR2ItvExeState::translateGep(const GepStmt *gep)
     assert(!getVAddrs(rhs).empty());
     VAddrs &rhsVal = getVAddrs(rhs);
     if (rhsVal.empty()) return;
-    std::pair<s32_t, s32_t> offsetPair = getGepOffset(gep);
+    std::pair<APOffset, APOffset> offsetPair = getGepOffset(gep);
     if (offsetPair.first == -1 && offsetPair.second == -1) return;
     if (!isVirtualMemAddress(*rhsVal.begin()))
     {
@@ -851,12 +867,12 @@ void SVFIR2ItvExeState::translateGep(const GepStmt *gep)
     else
     {
         VAddrs gepAddrs;
-        s32_t ub = offsetPair.second;
-        if (offsetPair.second > (s32_t) Options::MaxFieldLimit() - 1)
+        APOffset ub = offsetPair.second;
+        if (offsetPair.second > Options::MaxFieldLimit() - 1)
         {
             ub = Options::MaxFieldLimit() - 1;
         }
-        for (s32_t i = offsetPair.first; i <= ub; i++)
+        for (APOffset i = offsetPair.first; i <= ub; i++)
         {
             gepAddrs.join_with(getGepObjAddress(rhs, i));
         }