svf-tools 1.0.985 → 1.0.987

package/svf/lib/MemoryModel/PointerAnalysis.cpp

@@ -509,7 +509,7 @@ void PointerAnalysis::validateSuccessTests(std::string fun)
 
         for(const CallICFGNode* callNode : pag->getCallSiteSet())
         {
-            if (SVFUtil::getCallee(callNode) == checkFun)
+            if (callNode->getCalledFunction() == checkFun)
             {
                 assert(callNode->getNumArgOperands() == 2
                        && "arguments should be two pointers!!");
@@ -574,7 +574,7 @@ void PointerAnalysis::validateExpectedFailureTests(std::string fun)
 
         for(const CallICFGNode* callNode : pag->getCallSiteSet())
         {
-            if (SVFUtil::getCallee(callNode) == checkFun)
+            if (callNode->getCalledFunction() == checkFun)
             {
                 assert(callNode->arg_size() == 2
                        && "arguments should be two pointers!!");

package/svf/lib/SABER/DoubleFreeChecker.cpp

@@ -55,7 +55,7 @@ void DoubleFreeChecker::testsValidation(ProgSlice *slice)
 {
     const SVFGNode* source = slice->getSource();
     const CallICFGNode* cs = getSrcCSID(source);
-    const SVFFunction* fun = getCallee(cs->getCallSite());
+    const SVFFunction* fun = cs->getCalledFunction();
     if(fun==nullptr)
         return;
     validateSuccessTests(slice,fun);

package/svf/lib/SABER/LeakChecker.cpp

@@ -180,7 +180,7 @@ void LeakChecker::testsValidation(const ProgSlice* slice)
 {
     const SVFGNode* source = slice->getSource();
     const CallICFGNode* cs = getSrcCSID(source);
-    const SVFFunction* fun = getCallee(cs->getCallSite());
+    const SVFFunction* fun = cs->getCalledFunction();
     if(fun==nullptr)
         return;
 

package/svf/lib/Util/CallGraphBuilder.cpp

@@ -52,9 +52,9 @@ CallGraph* CallGraphBuilder::buildCallGraph(SVFModule* svfModule)
             {
                 if (SVFUtil::isNonInstricCallSite(inst))
                 {
-                    if(const SVFFunction* callee = getCallee(inst))
+                    const CallICFGNode* callBlockNode = cast<CallICFGNode>(inst);
+                    if(const SVFFunction* callee = callBlockNode->getCalledFunction())
                     {
-                        const CallICFGNode* callBlockNode = cast<CallICFGNode>(inst);
                         callgraph->addDirectCallGraphEdge(callBlockNode,*F,callee);
                     }
                 }
@@ -80,7 +80,7 @@ CallGraph* ThreadCallGraphBuilder::buildThreadCallGraph(SVFModule* svfModule)
         {
             for (const ICFGNode* inst : svfbb->getICFGNodeList())
             {
-                if (tdAPI->isTDFork(inst))
+                if (SVFUtil::isa<CallICFGNode>(inst) && tdAPI->isTDFork(SVFUtil::cast<CallICFGNode>(inst)))
                 {
                     const CallICFGNode* cs = cast<CallICFGNode>(inst);
                     cg->addForksite(cs);
@@ -105,7 +105,7 @@ CallGraph* ThreadCallGraphBuilder::buildThreadCallGraph(SVFModule* svfModule)
         {
             for (const ICFGNode* node : svfbb->getICFGNodeList())
             {
-                if (tdAPI->isTDJoin(node))
+                if (SVFUtil::isa<CallICFGNode>(node) && tdAPI->isTDJoin(SVFUtil::cast<CallICFGNode>(node)))
                 {
                     const CallICFGNode* cs = SVFUtil::cast<CallICFGNode>(node);
                     cg->addJoinsite(cs);

package/svf/lib/Util/SVFBugReport.cpp

@@ -303,7 +303,8 @@ const std::string SVFBugEvent::getEventDescription() const
     case SVFBugEvent::CallSite:
     {
         std::string description("calls ");
-        const SVFFunction *callee = SVFUtil::getCallee(eventInst);
+        assert(SVFUtil::isa<CallICFGNode>(eventInst) && "not a call ICFGNode?");
+        const SVFFunction *callee = SVFUtil::cast<CallICFGNode>(eventInst)->getCalledFunction();
         if(callee == nullptr)
         {
             description += "<unknown>";

package/svf/lib/Util/SVFUtil.cpp

@@ -343,24 +343,34 @@ bool SVFUtil::isIntrinsicInst(const ICFGNode* inst)
     return false;
 }
 
-const SVFFunction* SVFUtil::getCallee(const ICFGNode *inst)
+bool SVFUtil::isExtCall(const CallICFGNode* cs)
 {
-    if (!isCallSite(inst))
-        return nullptr;
-    const CallICFGNode* call = SVFUtil::cast<CallICFGNode>(inst);
-    return call->getCalledFunction();
+    return isExtCall(cs->getCalledFunction());
 }
 
-const SVFFunction* SVFUtil::getCallee(const CallICFGNode *inst)
+bool SVFUtil::isHeapAllocExtCallViaArg(const CallICFGNode* cs)
 {
-    return inst->getCalledFunction();
+    return isHeapAllocExtFunViaArg(cs->getCalledFunction());
+}
+
+bool SVFUtil::isHeapAllocExtCallViaArg(const SVFInstruction *inst)
+{
+    if(const SVFCallInst* call = SVFUtil::dyn_cast<SVFCallInst>(inst))
+        return isHeapAllocExtFunViaArg(call->getCalledFunction());
+    else
+        return false;
+}
+
+u32_t SVFUtil::getHeapAllocHoldingArgPosition(const CallICFGNode* cs)
+{
+    return getHeapAllocHoldingArgPosition(cs->getCalledFunction());
 }
 
 
 bool SVFUtil::isExtCall(const ICFGNode* node)
 {
     if(!isCallSite(node)) return false;
-    return isExtCall(getCallee(node));
+    return isExtCall(cast<CallICFGNode>(node)->getCalledFunction());
 }
 
 bool SVFUtil::isHeapAllocExtCall(const ICFGNode* cs)
@@ -372,13 +382,13 @@ bool SVFUtil::isHeapAllocExtCall(const ICFGNode* cs)
 bool SVFUtil::isHeapAllocExtCallViaRet(const CallICFGNode* cs)
 {
     bool isPtrTy = cs->getCallSite()->getType()->isPointerTy();
-    return isPtrTy && isHeapAllocExtFunViaRet(getCallee(cs));
+    return isPtrTy && isHeapAllocExtFunViaRet(cs->getCalledFunction());
 }
 
 bool SVFUtil::isReallocExtCall(const CallICFGNode* cs)
 {
     bool isPtrTy = cs->getCallSite()->getType()->isPointerTy();
-    return isPtrTy && isReallocExtFun(getCallee(cs));
+    return isPtrTy && isReallocExtFun(cs->getCalledFunction());
 }
 
 bool SVFUtil::isHeapAllocExtCallViaRet(const SVFInstruction *inst)
@@ -396,4 +406,9 @@ bool SVFUtil::isRetInstNode(const ICFGNode* node)
         return intraNode->getInst()->isRetInst();
     else
         return false;
+}
+
+bool SVFUtil::isProgExitCall(const CallICFGNode* cs)
+{
+    return isProgExitFunction(cs->getCalledFunction());
 }

package/svf/lib/Util/ThreadAPI.cpp

@@ -129,6 +129,37 @@ void ThreadAPI::init()
     }
 }
 
+bool ThreadAPI::isTDFork(const CallICFGNode *inst) const
+{
+    return getType(inst->getCalledFunction()) == TD_FORK;
+}
+
+bool ThreadAPI::isTDJoin(const CallICFGNode *inst) const
+{
+    return getType(inst->getCalledFunction()) == TD_JOIN;
+}
+
+bool ThreadAPI::isTDExit(const CallICFGNode *inst) const
+{
+    return getType(inst->getCalledFunction()) == TD_EXIT;
+}
+
+bool ThreadAPI::isTDAcquire(const CallICFGNode* inst) const
+{
+    return getType(inst->getCalledFunction()) == TD_ACQUIRE;
+}
+
+bool ThreadAPI::isTDRelease(const CallICFGNode *inst) const
+{
+    return getType(inst->getCalledFunction()) == TD_RELEASE;
+}
+
+bool ThreadAPI::isTDBarWait(const CallICFGNode *inst) const
+{
+    return getType(inst->getCalledFunction()) == TD_BAR_WAIT;
+}
+
+
 const SVFValue* ThreadAPI::getForkedThread(const CallICFGNode *inst) const
 {
     assert(isTDFork(inst) && "not a thread fork function!");
@@ -155,17 +186,6 @@ const SVFValue* ThreadAPI::getRetParmAtJoinedSite(const CallICFGNode *inst) cons
     return inst->getArgument(1);
 }
 
-/*!
- *
- */
-const SVFFunction* ThreadAPI::getCallee(const ICFGNode *inst) const
-{
-    if(const CallICFGNode* call = SVFUtil::dyn_cast<CallICFGNode>(inst))
-        return SVFUtil::getCallee(call->getCallSite());
-    else
-        return nullptr;
-}
-
 const SVFValue* ThreadAPI::getLockVal(const ICFGNode *cs) const
 {
     const CallICFGNode* call = SVFUtil::dyn_cast<CallICFGNode>(cs);
@@ -251,7 +271,7 @@ void ThreadAPI::performAPIStat(SVFModule* module)
                 if (!SVFUtil::isCallSite(svfInst))
                     continue;
 
-                const SVFFunction* fun = SVFUtil::getCallee(svfInst);
+                const SVFFunction* fun = SVFUtil::cast<CallICFGNode>(svfInst)->getCalledFunction();
                 TD_TYPE type = getType(fun);
                 switch (type)
                 {

package/svf/lib/WPA/Andersen.cpp

@@ -679,7 +679,7 @@ bool Andersen::updateCallGraph(const CallSiteToFunPtrMap& callsites)
 
 void Andersen::heapAllocatorViaIndCall(const CallICFGNode* cs, NodePairSet &cpySrcNodes)
 {
-    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 = pag->getCallSiteRet(retBlockNode);
     NodeID srcret;

package/svf/lib/WPA/Steensgaard.cpp

@@ -157,7 +157,7 @@ bool Steensgaard::updateCallGraph(const CallSiteToFunPtrMap& callsites)
 
 void Steensgaard::heapAllocatorViaIndCall(const CallICFGNode* cs, NodePairSet& cpySrcNodes)
 {
-    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 = pag->getCallSiteRet(retBlockNode);
     NodeID srcret;

package/svf-llvm/lib/ICFGBuilder.cpp

@@ -233,7 +233,7 @@ InterICFGNode* ICFGBuilder::addInterBlockICFGNode(const SVFInstruction* inst)
     assert(SVFUtil::isNonInstricCallSite(inst) && "associating an intrinsic debug instruction with an ICFGNode!");
     CallICFGNode* callICFGNode = icfg->addCallICFGNode(inst);
     (void) icfg->addRetICFGNode(inst);
-    addICFGInterEdges(inst, getCallee(inst));                       //creating interprocedural edges
+    addICFGInterEdges(inst, callICFGNode->getCalledFunction());                       //creating interprocedural edges
     return callICFGNode;
 }
 

package/svf-llvm/lib/SymbolTableBuilder.cpp

@@ -608,7 +608,7 @@ const Type* SymbolTableBuilder::inferTypeOfHeapObjOrStaticObj(const Instruction
     else if(SVFUtil::isHeapAllocExtCallViaArg(svfinst))
     {
         const CallBase* cs = LLVMUtil::getLLVMCallSite(inst);
-        int arg_pos = SVFUtil::getHeapAllocHoldingArgPosition(getCallee(svfinst));
+        u32_t arg_pos = SVFUtil::getHeapAllocHoldingArgPosition(SVFUtil::cast<SVFCallInst>(svfinst)->getCalledFunction());
         const Value* arg = cs->getArgOperand(arg_pos);
         originalPType = SVFUtil::dyn_cast<PointerType>(arg->getType());
         inferedType = inferObjType(startValue = arg);