svf-tools 1.0.985 → 1.0.987

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

@@ -616,8 +616,7 @@ void AbstractInterpretation::handleCallSite(const ICFGNode* node)
 
 bool AbstractInterpretation::isExtCall(const SVF::CallICFGNode *callNode)
 {
-    const SVFFunction *callfun = SVFUtil::getCallee(callNode->getCallSite());
-    return SVFUtil::isExtCall(callfun);
+    return SVFUtil::isExtCall(callNode->getCalledFunction());
 }
 
 void AbstractInterpretation::extCallPass(const SVF::CallICFGNode *callNode)
@@ -629,8 +628,7 @@ void AbstractInterpretation::extCallPass(const SVF::CallICFGNode *callNode)
 
 bool AbstractInterpretation::isRecursiveCall(const SVF::CallICFGNode *callNode)
 {
-    const SVFFunction *callfun = SVFUtil::getCallee(callNode->getCallSite());
-    return recursiveFuns.find(callfun) != recursiveFuns.end();
+    return recursiveFuns.find(callNode->getCalledFunction()) != recursiveFuns.end();
 }
 
 void AbstractInterpretation::recursiveCallPass(const SVF::CallICFGNode *callNode)
@@ -654,18 +652,16 @@ void AbstractInterpretation::recursiveCallPass(const SVF::CallICFGNode *callNode
 
 bool AbstractInterpretation::isDirectCall(const SVF::CallICFGNode *callNode)
 {
-    const SVFFunction *callfun = SVFUtil::getCallee(callNode->getCallSite());
-    return funcToWTO.find(callfun) != funcToWTO.end();
+    return funcToWTO.find(callNode->getCalledFunction()) != funcToWTO.end();
 }
 void AbstractInterpretation::directCallFunPass(const SVF::CallICFGNode *callNode)
 {
     AbstractState& as = getAbsStateFromTrace(callNode);
-    const SVFFunction *callfun = SVFUtil::getCallee(callNode->getCallSite());
     callSiteStack.push_back(callNode);
 
     abstractTrace[callNode] = as;
 
-    ICFGWTO* wto = funcToWTO[callfun];
+    ICFGWTO* wto = funcToWTO[callNode->getCalledFunction()];
     handleWTOComponents(wto->getWTOComponents());
 
     callSiteStack.pop_back();
@@ -819,7 +815,6 @@ void AbstractInterpretation::handleSVFStatement(const SVFStmt *stmt)
 void AbstractInterpretation::SkipRecursiveCall(const CallICFGNode *callNode)
 {
     AbstractState& as = getAbsStateFromTrace(callNode);
-    const SVFFunction *callfun = SVFUtil::getCallee(callNode->getCallSite());
     const RetICFGNode *retNode = callNode->getRetICFGNode();
     if (retNode->getSVFStmts().size() > 0)
     {
@@ -843,7 +838,7 @@ void AbstractInterpretation::SkipRecursiveCall(const CallICFGNode *callNode)
     }
     FIFOWorkList<const SVFBasicBlock *> blkWorkList;
     FIFOWorkList<const ICFGNode *> instWorklist;
-    for (const SVFBasicBlock * bb: callfun->getReachableBBs())
+    for (const SVFBasicBlock * bb: callNode->getCalledFunction()->getReachableBBs())
     {
         for (const ICFGNode* node: bb->getICFGNodeList())
         {
@@ -1000,7 +995,6 @@ void AbstractInterpretation::initExtFunMap()
         checkpoints.erase(callNode);
         u32_t arg0 = svfir->getValueNode(callNode->getArgument(0));
         AbstractState&as = getAbsStateFromTrace(callNode);
-        as[arg0].getInterval().meet_with(IntervalValue(1, 1));
         if (as[arg0].getInterval().equals(IntervalValue(1, 1)))
         {
             SVFUtil::errs() << SVFUtil::sucMsg("The assertion is successfully verified!!\n");
@@ -1014,6 +1008,25 @@ void AbstractInterpretation::initExtFunMap()
     };
     func_map["svf_assert"] = sse_svf_assert;
 
+    auto svf_assert_eq = [this](const CallICFGNode* callNode)
+    {
+        checkpoints.erase(callNode);
+        u32_t arg0 = svfir->getValueNode(callNode->getArgument(0));
+        u32_t arg1 = svfir->getValueNode(callNode->getArgument(1));
+        AbstractState&as = getAbsStateFromTrace(callNode);
+        if (as[arg0].getInterval().equals(as[arg1].getInterval()))
+        {
+            SVFUtil::errs() << SVFUtil::sucMsg("The assertion is successfully verified!!\n");
+        }
+        else
+        {
+            SVFUtil::errs() <<"svf_assert_eq Fail. " << callNode->toString() << "\n";
+            assert(false);
+        }
+        return;
+    };
+    func_map["svf_assert_eq"] = svf_assert_eq;
+
     auto svf_print = [&](const CallICFGNode* callNode)
     {
         if (callNode->arg_size() < 2) return;
@@ -1022,11 +1035,38 @@ void AbstractInterpretation::initExtFunMap()
         std::string text = strRead(as, callNode->getArgument(1));
         assert(as.inVarToValTable(num_id) && "print() should pass integer");
         IntervalValue itv = as[num_id].getInterval();
-        std::cout << "Text: " << text <<", Value: " << callNode->getArgument(0)->toString() << ", PrintVal: " << itv.toString() << std::endl;
+        std::cout << "Text: " << text <<", Value: " << callNode->getArgument(0)->toString()
+                  << ", PrintVal: " << itv.toString() << ", Loc:" << callNode->getSourceLoc() << std::endl;
         return;
     };
     func_map["svf_print"] = svf_print;
 
+    auto svf_set_value = [&](const CallICFGNode* callNode)
+    {
+        if (callNode->arg_size() < 2) return;
+        AbstractState&as = getAbsStateFromTrace(callNode);
+        AbstractValue& num = as[svfir->getValueNode(callNode->getArgument(0))];
+        AbstractValue& lb = as[svfir->getValueNode(callNode->getArgument(1))];
+        AbstractValue& ub = as[svfir->getValueNode(callNode->getArgument(2))];
+        assert(lb.getInterval().is_numeral() && ub.getInterval().is_numeral());
+        num.getInterval().set_to_top();
+        num.getInterval().meet_with(IntervalValue(lb.getInterval().lb(), ub.getInterval().ub()));
+        if (icfg->hasICFGNode(SVFUtil::cast<SVFInstruction>(callNode->getArgument(0))))
+        {
+            const ICFGNode* node = icfg->getICFGNode(SVFUtil::cast<SVFInstruction>(callNode->getArgument(0)));
+            for (const SVFStmt* stmt: node->getSVFStmts())
+            {
+                if (SVFUtil::isa<LoadStmt>(stmt))
+                {
+                    const LoadStmt* load = SVFUtil::cast<LoadStmt>(stmt);
+                    NodeID rhsId = load->getRHSVarID();
+                    as.storeValue(rhsId, num);
+                }
+            }
+        }
+        return;
+    };
+    func_map["set_value"] = svf_set_value;
 
     auto sse_scanf = [&](const CallICFGNode* callNode)
     {
@@ -1333,7 +1373,7 @@ std::string AbstractInterpretation::strRead(AbstractState& as, const SVFValue* r
 void AbstractInterpretation::handleExtAPI(const CallICFGNode *call)
 {
     AbstractState& as = getAbsStateFromTrace(call);
-    const SVFFunction *fun = SVFUtil::getCallee(call->getCallSite());
+    const SVFFunction *fun = call->getCalledFunction();
     assert(fun && "SVFFunction* is nullptr");
     ExtAPIType extType = UNCLASSIFIED;
     // get type of mem api
@@ -1404,7 +1444,7 @@ void AbstractInterpretation::collectCheckPoint()
         const ICFGNode* node = it->second;
         if (const CallICFGNode *call = SVFUtil::dyn_cast<CallICFGNode>(node))
         {
-            if (const SVFFunction *fun = SVFUtil::getCallee(call->getCallSite()))
+            if (const SVFFunction *fun = call->getCalledFunction())
             {
                 if (checkpoint_names.find(fun->getName()) !=
                         checkpoint_names.end())
@@ -1527,7 +1567,7 @@ void AbstractInterpretation::handleStrcat(const SVF::CallICFGNode *call)
     // __strcat_chk, strcat, __wcscat_chk, wcscat, __strncat_chk, strncat, __wcsncat_chk, wcsncat
     // to check it is  strcat group or strncat group
     AbstractState& as = getAbsStateFromTrace(call);
-    const SVFFunction *fun = SVFUtil::getCallee(call);
+    const SVFFunction *fun = call->getCalledFunction();
     const std::vector<std::string> strcatGroup = {"__strcat_chk", "strcat", "__wcscat_chk", "wcscat"};
     const std::vector<std::string> strncatGroup = {"__strncat_chk", "strncat", "__wcsncat_chk", "wcsncat"};
     if (std::find(strcatGroup.begin(), strcatGroup.end(), fun->getName()) != strcatGroup.end())
@@ -1713,8 +1753,27 @@ void AbstractInterpretation::updateStateOnPhi(const PhiStmt *phi)
         const ICFGNode* opICFGNode = phi->getOpICFGNode(i);
         if (hasAbsStateFromTrace(opICFGNode))
         {
+            AbstractState tmpEs = abstractTrace[opICFGNode];
             AbstractState& opAs = getAbsStateFromTrace(opICFGNode);
-            rhs.join_with(opAs[curId]);
+            const ICFGEdge* edge =  icfg->getICFGEdge(opICFGNode, icfgNode, ICFGEdge::IntraCF);
+            // if IntraEdge, check the condition, if it is feasible, join the value
+            // if IntraEdge but not conditional edge, join the value
+            // if not IntraEdge, join the value
+            if (edge)
+            {
+                const IntraCFGEdge* intraEdge = SVFUtil::cast<IntraCFGEdge>(edge);
+                if (intraEdge->getCondition())
+                {
+                    if (isBranchFeasible(intraEdge, tmpEs))
+                        rhs.join_with(opAs[curId]);
+                }
+                else
+                    rhs.join_with(opAs[curId]);
+            }
+            else
+            {
+                rhs.join_with(opAs[curId]);
+            }
         }
     }
     as[res] = rhs;
@@ -1815,181 +1874,209 @@ void AbstractInterpretation::updateStateOnCmp(const CmpStmt *cmp)
     AbstractState& as = getAbsStateFromTrace(cmp->getICFGNode());
     u32_t op0 = cmp->getOpVarID(0);
     u32_t op1 = cmp->getOpVarID(1);
-    if (!as.inVarToValTable(op0)) as[op0] = IntervalValue::top();
-    if (!as.inVarToValTable(op1)) as[op1] = IntervalValue::top();
-    u32_t res = cmp->getResID();
-    if (as.inVarToValTable(op0) && as.inVarToValTable(op1))
+    // if it is address
+    if (as.inVarToAddrsTable(op0) && as.inVarToAddrsTable(op1))
     {
         IntervalValue resVal;
-        if (as[op0].isInterval() && as[op1].isInterval())
+        AddressValue addrOp0 = as[op0].getAddrs();
+        AddressValue addrOp1 = as[op1].getAddrs();
+        u32_t res = cmp->getResID();
+        if (addrOp0.equals(addrOp1))
         {
-            IntervalValue &lhs = as[op0].getInterval(), &rhs = as[op1].getInterval();
-            //AbstractValue
-            auto predicate = cmp->getPredicate();
-            switch (predicate)
-            {
-            case CmpStmt::ICMP_EQ:
-            case CmpStmt::FCMP_OEQ:
-            case CmpStmt::FCMP_UEQ:
-                resVal = (lhs == rhs);
-                // resVal = (lhs.getInterval() == rhs.getInterval());
-                break;
-            case CmpStmt::ICMP_NE:
-            case CmpStmt::FCMP_ONE:
-            case CmpStmt::FCMP_UNE:
-                resVal = (lhs != rhs);
-                break;
-            case CmpStmt::ICMP_UGT:
-            case CmpStmt::ICMP_SGT:
-            case CmpStmt::FCMP_OGT:
-            case CmpStmt::FCMP_UGT:
-                resVal = (lhs > rhs);
-                break;
-            case CmpStmt::ICMP_UGE:
-            case CmpStmt::ICMP_SGE:
-            case CmpStmt::FCMP_OGE:
-            case CmpStmt::FCMP_UGE:
-                resVal = (lhs >= rhs);
-                break;
-            case CmpStmt::ICMP_ULT:
-            case CmpStmt::ICMP_SLT:
-            case CmpStmt::FCMP_OLT:
-            case CmpStmt::FCMP_ULT:
-                resVal = (lhs < rhs);
-                break;
-            case CmpStmt::ICMP_ULE:
-            case CmpStmt::ICMP_SLE:
-            case CmpStmt::FCMP_OLE:
-            case CmpStmt::FCMP_ULE:
-                resVal = (lhs <= rhs);
-                break;
-            case CmpStmt::FCMP_FALSE:
-                resVal = IntervalValue(0, 0);
-                break;
-            case CmpStmt::FCMP_TRUE:
-                resVal = IntervalValue(1, 1);
-                break;
-            default:
-            {
-                assert(false && "undefined compare: ");
-            }
-            }
-            as[res] = resVal;
+            resVal = IntervalValue(1, 1);
         }
-        else if (as[op0].isAddr() && as[op1].isAddr())
+        else if (addrOp0.hasIntersect(addrOp1))
         {
-            AddressValue &lhs = as[op0].getAddrs(), &rhs = as[op1].getAddrs();
-            auto predicate = cmp->getPredicate();
-            switch (predicate)
-            {
-            case CmpStmt::ICMP_EQ:
-            case CmpStmt::FCMP_OEQ:
-            case CmpStmt::FCMP_UEQ:
+            resVal = IntervalValue(0, 1);
+        }
+        else
+        {
+            resVal = IntervalValue(0, 0);
+        }
+        as[res] = resVal;
+    }
+    else
+    {
+        if (!as.inVarToValTable(op0))
+            as[op0] = IntervalValue::top();
+        if (!as.inVarToValTable(op1))
+            as[op1] = IntervalValue::top();
+        u32_t res = cmp->getResID();
+        if (as.inVarToValTable(op0) && as.inVarToValTable(op1))
+        {
+            IntervalValue resVal;
+            if (as[op0].isInterval() && as[op1].isInterval())
             {
-                if (lhs.hasIntersect(rhs))
-                {
-                    resVal = IntervalValue(0, 1);
-                }
-                else if (lhs.empty() && rhs.empty())
-                {
-                    resVal = IntervalValue(1, 1);
-                }
-                else
+                IntervalValue &lhs = as[op0].getInterval(),
+                               &rhs = as[op1].getInterval();
+                // AbstractValue
+                auto predicate = cmp->getPredicate();
+                switch (predicate)
                 {
+                case CmpStmt::ICMP_EQ:
+                case CmpStmt::FCMP_OEQ:
+                case CmpStmt::FCMP_UEQ:
+                    resVal = (lhs == rhs);
+                    // resVal = (lhs.getInterval() == rhs.getInterval());
+                    break;
+                case CmpStmt::ICMP_NE:
+                case CmpStmt::FCMP_ONE:
+                case CmpStmt::FCMP_UNE:
+                    resVal = (lhs != rhs);
+                    break;
+                case CmpStmt::ICMP_UGT:
+                case CmpStmt::ICMP_SGT:
+                case CmpStmt::FCMP_OGT:
+                case CmpStmt::FCMP_UGT:
+                    resVal = (lhs > rhs);
+                    break;
+                case CmpStmt::ICMP_UGE:
+                case CmpStmt::ICMP_SGE:
+                case CmpStmt::FCMP_OGE:
+                case CmpStmt::FCMP_UGE:
+                    resVal = (lhs >= rhs);
+                    break;
+                case CmpStmt::ICMP_ULT:
+                case CmpStmt::ICMP_SLT:
+                case CmpStmt::FCMP_OLT:
+                case CmpStmt::FCMP_ULT:
+                    resVal = (lhs < rhs);
+                    break;
+                case CmpStmt::ICMP_ULE:
+                case CmpStmt::ICMP_SLE:
+                case CmpStmt::FCMP_OLE:
+                case CmpStmt::FCMP_ULE:
+                    resVal = (lhs <= rhs);
+                    break;
+                case CmpStmt::FCMP_FALSE:
                     resVal = IntervalValue(0, 0);
-                }
-                break;
-            }
-            case CmpStmt::ICMP_NE:
-            case CmpStmt::FCMP_ONE:
-            case CmpStmt::FCMP_UNE:
-            {
-                if (lhs.hasIntersect(rhs))
-                {
-                    resVal = IntervalValue(0, 1);
-                }
-                else if (lhs.empty() && rhs.empty())
+                    break;
+                case CmpStmt::FCMP_TRUE:
+                    resVal = IntervalValue(1, 1);
+                    break;
+                default:
                 {
-                    resVal = IntervalValue(0, 0);
+                    assert(false && "undefined compare: ");
                 }
-                else
-                {
-                    resVal = IntervalValue(1, 1);
                 }
-                break;
+                as[res] = resVal;
             }
-            case CmpStmt::ICMP_UGT:
-            case CmpStmt::ICMP_SGT:
-            case CmpStmt::FCMP_OGT:
-            case CmpStmt::FCMP_UGT:
+            else if (as[op0].isAddr() && as[op1].isAddr())
             {
-                if (lhs.size() == 1 && rhs.size() == 1)
+                AddressValue &lhs = as[op0].getAddrs(),
+                              &rhs = as[op1].getAddrs();
+                auto predicate = cmp->getPredicate();
+                switch (predicate)
                 {
-                    resVal = IntervalValue(*lhs.begin() > *rhs.begin());
-                }
-                else
+                case CmpStmt::ICMP_EQ:
+                case CmpStmt::FCMP_OEQ:
+                case CmpStmt::FCMP_UEQ:
                 {
-                    resVal = IntervalValue(0, 1);
+                    if (lhs.hasIntersect(rhs))
+                    {
+                        resVal = IntervalValue(0, 1);
+                    }
+                    else if (lhs.empty() && rhs.empty())
+                    {
+                        resVal = IntervalValue(1, 1);
+                    }
+                    else
+                    {
+                        resVal = IntervalValue(0, 0);
+                    }
+                    break;
                 }
-                break;
-            }
-            case CmpStmt::ICMP_UGE:
-            case CmpStmt::ICMP_SGE:
-            case CmpStmt::FCMP_OGE:
-            case CmpStmt::FCMP_UGE:
-            {
-                if (lhs.size() == 1 && rhs.size() == 1)
+                case CmpStmt::ICMP_NE:
+                case CmpStmt::FCMP_ONE:
+                case CmpStmt::FCMP_UNE:
                 {
-                    resVal = IntervalValue(*lhs.begin() >= *rhs.begin());
+                    if (lhs.hasIntersect(rhs))
+                    {
+                        resVal = IntervalValue(0, 1);
+                    }
+                    else if (lhs.empty() && rhs.empty())
+                    {
+                        resVal = IntervalValue(0, 0);
+                    }
+                    else
+                    {
+                        resVal = IntervalValue(1, 1);
+                    }
+                    break;
                 }
-                else
+                case CmpStmt::ICMP_UGT:
+                case CmpStmt::ICMP_SGT:
+                case CmpStmt::FCMP_OGT:
+                case CmpStmt::FCMP_UGT:
                 {
-                    resVal = IntervalValue(0, 1);
+                    if (lhs.size() == 1 && rhs.size() == 1)
+                    {
+                        resVal = IntervalValue(*lhs.begin() > *rhs.begin());
+                    }
+                    else
+                    {
+                        resVal = IntervalValue(0, 1);
+                    }
+                    break;
                 }
-                break;
-            }
-            case CmpStmt::ICMP_ULT:
-            case CmpStmt::ICMP_SLT:
-            case CmpStmt::FCMP_OLT:
-            case CmpStmt::FCMP_ULT:
-            {
-                if (lhs.size() == 1 && rhs.size() == 1)
+                case CmpStmt::ICMP_UGE:
+                case CmpStmt::ICMP_SGE:
+                case CmpStmt::FCMP_OGE:
+                case CmpStmt::FCMP_UGE:
                 {
-                    resVal = IntervalValue(*lhs.begin() < *rhs.begin());
+                    if (lhs.size() == 1 && rhs.size() == 1)
+                    {
+                        resVal = IntervalValue(*lhs.begin() >= *rhs.begin());
+                    }
+                    else
+                    {
+                        resVal = IntervalValue(0, 1);
+                    }
+                    break;
                 }
-                else
+                case CmpStmt::ICMP_ULT:
+                case CmpStmt::ICMP_SLT:
+                case CmpStmt::FCMP_OLT:
+                case CmpStmt::FCMP_ULT:
                 {
-                    resVal = IntervalValue(0, 1);
+                    if (lhs.size() == 1 && rhs.size() == 1)
+                    {
+                        resVal = IntervalValue(*lhs.begin() < *rhs.begin());
+                    }
+                    else
+                    {
+                        resVal = IntervalValue(0, 1);
+                    }
+                    break;
                 }
-                break;
-            }
-            case CmpStmt::ICMP_ULE:
-            case CmpStmt::ICMP_SLE:
-            case CmpStmt::FCMP_OLE:
-            case CmpStmt::FCMP_ULE:
-            {
-                if (lhs.size() == 1 && rhs.size() == 1)
+                case CmpStmt::ICMP_ULE:
+                case CmpStmt::ICMP_SLE:
+                case CmpStmt::FCMP_OLE:
+                case CmpStmt::FCMP_ULE:
                 {
-                    resVal = IntervalValue(*lhs.begin() <= *rhs.begin());
+                    if (lhs.size() == 1 && rhs.size() == 1)
+                    {
+                        resVal = IntervalValue(*lhs.begin() <= *rhs.begin());
+                    }
+                    else
+                    {
+                        resVal = IntervalValue(0, 1);
+                    }
+                    break;
                 }
-                else
+                case CmpStmt::FCMP_FALSE:
+                    resVal = IntervalValue(0, 0);
+                    break;
+                case CmpStmt::FCMP_TRUE:
+                    resVal = IntervalValue(1, 1);
+                    break;
+                default:
                 {
-                    resVal = IntervalValue(0, 1);
+                    assert(false && "undefined compare: ");
                 }
-                break;
-            }
-            case CmpStmt::FCMP_FALSE:
-                resVal = IntervalValue(0, 0);
-                break;
-            case CmpStmt::FCMP_TRUE:
-                resVal = IntervalValue(1, 1);
-                break;
-            default:
-            {
-                assert(false && "undefined compare: ");
-            }
+                }
+                as[res] = resVal;
             }
-            as[res] = resVal;
         }
     }
 }
@@ -2057,8 +2144,8 @@ void AbstractInterpretation::updateStateOnCopy(const CopyStmt *copy)
         return IntervalValue::top(); // TODO: may have better solution
     };
 
-    auto getTruncValue = [](const AbstractState& as, const SVF::SVFVar* var,
-                            const SVFType* dstType)
+    auto getTruncValue = [&](const AbstractState& as, const SVF::SVFVar* var,
+                             const SVFType* dstType)
     {
         const IntervalValue& itv = as[var->getId()].getInterval();
         if(itv.isBottom()) return itv;
@@ -2075,7 +2162,7 @@ void AbstractInterpretation::updateStateOnCopy(const CopyStmt *copy)
             if (s8_lb > s8_ub)
             {
                 // return range of s8
-                return IntervalValue::top();
+                return this->getRangeLimitFromType(dstType);
             }
             return IntervalValue(s8_lb, s8_ub);
         }
@@ -2087,7 +2174,7 @@ void AbstractInterpretation::updateStateOnCopy(const CopyStmt *copy)
             if (s16_lb > s16_ub)
             {
                 // return range of s16
-                return IntervalValue::top();
+                return this->getRangeLimitFromType(dstType);
             }
             return IntervalValue(s16_lb, s16_ub);
         }
@@ -2099,7 +2186,7 @@ void AbstractInterpretation::updateStateOnCopy(const CopyStmt *copy)
             if (s32_lb > s32_ub)
             {
                 // return range of s32
-                return IntervalValue::top();
+                return this->getRangeLimitFromType(dstType);
             }
             return IntervalValue(s32_lb, s32_ub);
         }

package/svf/lib/CFL/CFLAlias.cpp

@@ -143,7 +143,7 @@ void CFLAlias::connectCaller2CalleeParams(const CallICFGNode* cs, const SVFFunct
 
 void CFLAlias::heapAllocatorViaIndCall(const CallICFGNode* cs)
 {
-    assert(SVFUtil::getCallee(cs) == nullptr && "not an indirect callsite?");
+    assert(cs->getCalledFunction() == nullptr && "not an indirect callsite?");
     const RetICFGNode* retBlockNode = cs->getRetICFGNode();
     const PAGNode* cs_return = svfir->getCallSiteRet(retBlockNode);
     NodeID srcret;

package/svf/lib/Graphs/CallGraph.cpp

@@ -45,13 +45,13 @@ CallSiteID CallGraph::totalCallSiteNum = 1;
 //@{
 void CallGraphEdge::addDirectCallSite(const CallICFGNode* call)
 {
-    assert(SVFUtil::getCallee(call->getCallSite()) && "not a direct callsite??");
+    assert(call->getCalledFunction() && "not a direct callsite??");
     directCalls.insert(call);
 }
 
 void CallGraphEdge::addInDirectCallSite(const CallICFGNode* call)
 {
-    assert((nullptr == SVFUtil::getCallee(call->getCallSite()) || nullptr == SVFUtil::dyn_cast<SVFFunction> (SVFUtil::getForkedFun(call))) && "not an indirect callsite??");
+    assert((nullptr == call->getCalledFunction() || nullptr == SVFUtil::dyn_cast<SVFFunction> (SVFUtil::getForkedFun(call))) && "not an indirect callsite??");
     indirectCalls.insert(call);
 }
 //@}

package/svf/lib/MTA/LockAnalysis.cpp

@@ -76,11 +76,11 @@ void LockAnalysis::collectLockUnlocksites()
         {
             for (const ICFGNode* icfgNode : bb->getICFGNodeList())
             {
-                if (tcg->getThreadAPI()->isTDRelease(icfgNode))
+                if (isa<CallICFGNode>(icfgNode) && tcg->getThreadAPI()->isTDRelease(cast<CallICFGNode>(icfgNode)))
                 {
                     unlocksites.insert(icfgNode);
                 }
-                if (tcg->getThreadAPI()->isTDAcquire(icfgNode))
+                if (isa<CallICFGNode>(icfgNode) && tcg->getThreadAPI()->isTDAcquire(cast<CallICFGNode>(icfgNode)))
                 {
                     locksites.insert(icfgNode);
                 }

package/svf/lib/MTA/MHP.cpp

@@ -233,10 +233,11 @@ void MHP::handleFork(const CxtThreadStmt& cts, NodeID rootTid)
 void MHP::handleJoin(const CxtThreadStmt& cts, NodeID rootTid)
 {
 
-    const ICFGNode* call = cts.getStmt();
     const CallStrCxt& curCxt = cts.getContext();
 
-    assert(isTDJoin(call));
+    assert(isTDJoin(cts.getStmt()));
+
+    const CallICFGNode* call = SVFUtil::cast<CallICFGNode>(cts.getStmt());
 
     NodeBS joinedTids = getDirAndIndJoinedTid(curCxt, call);
     if (!joinedTids.empty())
@@ -479,8 +480,9 @@ bool MHP::isRecurFullJoin(NodeID parentTid, NodeID curTid)
  */
 bool MHP::isMustJoin(NodeID curTid, const ICFGNode* joinsite)
 {
-    assert(isTDJoin(joinsite) && "not a join site!");
-    return !isMultiForkedThread(curTid) && !tct->isJoinSiteInRecursion(joinsite);
+    const CallICFGNode* call = SVFUtil::dyn_cast<CallICFGNode>(joinsite);
+    assert(call && isTDJoin(call) && "not a join site!");
+    return !isMultiForkedThread(curTid) && !tct->isJoinSiteInRecursion(call);
 }
 
 /*!
@@ -821,9 +823,9 @@ void ForkJoinAnalysis::handleJoin(const CxtStmt& cts, NodeID rootTid)
 
         if (isAliasedForkJoin(SVFUtil::cast<CallICFGNode>(forkSite), SVFUtil::cast<CallICFGNode>(joinSite)))
         {
-            if (hasJoinLoop(joinSite))
+            if (hasJoinLoop(SVFUtil::cast<CallICFGNode>(forkSite)))
             {
-                LoopBBs& joinLoop = getJoinLoop(joinSite);
+                LoopBBs& joinLoop = getJoinLoop(SVFUtil::cast<CallICFGNode>(forkSite));
                 std::vector<const SVFBasicBlock *> exitbbs;
                 joinSite->getFun()->getExitBlocksOfLoop(joinSite->getBB(), exitbbs);
                 while (!exitbbs.empty())
@@ -853,7 +855,7 @@ void ForkJoinAnalysis::handleJoin(const CxtStmt& cts, NodeID rootTid)
         /// we process the loop exit
         else
         {
-            if (hasJoinLoop(joinSite))
+            if (hasJoinLoop(SVFUtil::cast<CallICFGNode>(forkSite)))
             {
                 std::vector<const SVFBasicBlock*> exitbbs;
                 joinSite->getFun()->getExitBlocksOfLoop(joinSite->getBB(), exitbbs);