svf-tools 1.0.770 → 1.0.772

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
@@ -842,7 +862,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 +871,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));
         }

package/svf-llvm/include/SVF-LLVM/BasicTypes.h

@@ -178,6 +178,10 @@ typedef llvm::BinaryOperator BinaryOperator;
 typedef llvm::UnaryOperator UnaryOperator;
 typedef llvm::UndefValue UndefValue;
 
+// Related to Switch Case
+typedef std::pair<const BasicBlock*, const ConstantInt*> SuccBBAndCondValPair;
+typedef std::vector<SuccBBAndCondValPair> SuccBBAndCondValPairVec;
+
 // LLVM Intrinsic Instructions
 #if LLVM_VERSION_MAJOR >= 13
 typedef llvm::IntrinsicInst IntrinsicInst;

package/svf-llvm/include/SVF-LLVM/LLVMUtil.h

@@ -519,6 +519,55 @@ std::string llvmToString(const T& val)
     llvm::raw_string_ostream(str) << val;
     return str;
 }
+
+/**
+ * See more: https://github.com/SVF-tools/SVF/pull/1191
+ *
+ * Given the code:
+ *
+ * switch (a) {
+ *   case 0: printf("0\n"); break;
+ *   case 1:
+ *   case 2:
+ *   case 3: printf("a >=1 && a <= 3\n"); break;
+ *   case 4:
+ *   case 6:
+ *   case 7:  printf("a >= 4 && a <=7\n"); break;
+ *   default: printf("a < 0 || a > 7"); break;
+ * }
+ *
+ * Generate the IR:
+ *
+ * switch i32 %0, label %sw.default [
+ *  i32 0, label %sw.bb
+ *  i32 1, label %sw.bb1
+ *  i32 2, label %sw.bb1
+ *  i32 3, label %sw.bb1
+ *  i32 4, label %sw.bb3
+ *  i32 6, label %sw.bb3
+ *  i32 7, label %sw.bb3
+ * ]
+ *
+ * We can get every case basic block and related case value:
+ * [
+ *   {%sw.default, -1},
+ *   {%sw.bb, 0},
+ *   {%sw.bb1, 1},
+ *   {%sw.bb1, 2},
+ *   {%sw.bb1, 3},
+ *   {%sw.bb3, 4},
+ *   {%sw.bb3, 6},
+ *   {%sw.bb3, 7},
+ * ]
+ * Note: default case value is nullptr
+ */
+void getSuccBBandCondValPairVec(const SwitchInst &switchInst, SuccBBAndCondValPairVec &vec);
+
+/**
+ * Note: default case value is nullptr
+ */
+s64_t getCaseValue(const SwitchInst &switchInst, SuccBBAndCondValPair &succBB2CondVal);
+
 } // End namespace LLVMUtil
 
 } // End namespace SVF

package/svf-llvm/lib/LLVMUtil.cpp

@@ -1152,6 +1152,43 @@ s32_t LLVMUtil::getVCallIdx(const CallBase* cs)
     return idx_value;
 }
 
+void LLVMUtil::getSuccBBandCondValPairVec(const SwitchInst &switchInst, SuccBBAndCondValPairVec &vec)
+{
+    // get default successor basic block and default case value (nullptr)
+    vec.push_back({switchInst.getDefaultDest(), nullptr});
+
+    // get normal case value and it's successor basic block
+    for (const auto& cs : switchInst.cases())
+        vec.push_back({cs.getCaseSuccessor(), cs.getCaseValue()});
+}
+
+s64_t LLVMUtil::getCaseValue(const SwitchInst &switchInst, SuccBBAndCondValPair &succBB2CondVal)
+{
+    const BasicBlock* succBB = succBB2CondVal.first;
+    const ConstantInt* caseValue = succBB2CondVal.second;
+    s64_t val;
+    if (caseValue == nullptr || succBB == switchInst.getDefaultDest())
+    {
+        /// default case value is set to -1
+        val = -1;
+    }
+    else
+    {
+        /// get normal case value
+        if (caseValue->getBitWidth() <= 64)
+        {
+            val = caseValue->getSExtValue();
+        }
+        else
+        {
+            /// For larger number, we preserve case value just -1 now
+            /// see more: https://github.com/SVF-tools/SVF/pull/992
+            val = -1;
+        }
+    }
+    return val;
+}
+
 namespace SVF
 {
 std::string SVFValue::toString() const

package/svf-llvm/lib/SVFIRBuilder.cpp

@@ -946,19 +946,20 @@ void SVFIRBuilder::visitSwitchInst(SwitchInst &inst)
     NodeID cond = getValueNode(inst.getCondition());
 
     BranchStmt::SuccAndCondPairVec successors;
-    for (u32_t i = 0; i < inst.getNumSuccessors(); ++i)
+
+    // get case successor basic block and related case value
+    SuccBBAndCondValPairVec succBB2CondValPairVec;
+    LLVMUtil::getSuccBBandCondValPairVec(inst, succBB2CondValPairVec);
+    for (auto &succBB2CaseValue : succBB2CondValPairVec)
     {
-        const Instruction* succInst = &inst.getSuccessor(i)->front();
-        const ConstantInt* condVal = inst.findCaseDest(inst.getSuccessor(i));
-        /// default case is set to -1;
-        s64_t val = -1;
-        if (condVal && condVal->getBitWidth() <= 64)
-            val = condVal->getSExtValue();
+        s64_t val = LLVMUtil::getCaseValue(inst, succBB2CaseValue);
+        const BasicBlock *succBB = succBB2CaseValue.first;
+        const Instruction* succInst = &succBB->front();
         const SVFInstruction* svfSuccInst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(succInst);
         const ICFGNode* icfgNode = pag->getICFG()->getICFGNode(svfSuccInst);
-        successors.push_back(std::make_pair(icfgNode,val));
+        successors.push_back(std::make_pair(icfgNode, val));
     }
-    addBranchStmt(brinst, cond,successors);
+    addBranchStmt(brinst, cond, successors);
 }
 
 ///   %ap = alloca %struct.va_list