svf-tools 1.0.983 → 1.0.985

package/svf/lib/Graphs/CHG.cpp

@@ -29,6 +29,7 @@
 
 #include "Graphs/CHG.h"
 #include "Util/SVFUtil.h"
+#include "Graphs/ICFG.h"
 
 using namespace SVF;
 using namespace SVFUtil;
@@ -48,16 +49,16 @@ static bool hasEdge(const CHNode *src, const CHNode *dst,
     return false;
 }
 
-static bool checkArgTypes(CallSite cs, const SVFFunction* fn)
+static bool checkArgTypes(const SVFCallInst* cs, const SVFFunction* fn)
 {
 
     // here we skip the first argument (i.e., this pointer)
-    u32_t arg_size = (fn->arg_size() > cs.arg_size()) ? cs.arg_size(): fn->arg_size();
+    u32_t arg_size = (fn->arg_size() > cs->arg_size()) ? cs->arg_size(): fn->arg_size();
     if(arg_size > 1)
     {
         for (unsigned i = 1; i < arg_size; i++)
         {
-            auto cs_arg = cs.getArgOperand(i);
+            auto cs_arg = cs->getArgOperand(i);
             auto fn_arg = fn->getArg(i);
             if (cs_arg->getType() != fn_arg->getType())
             {
@@ -69,6 +70,29 @@ static bool checkArgTypes(CallSite cs, const SVFFunction* fn)
     return true;
 }
 
+bool CHGraph::csHasVtblsBasedonCHA(const CallICFGNode* cs)
+{
+    CallSiteToVTableSetMap::const_iterator it = csToCHAVtblsMap.find(cs->getCallSite());
+    return it != csToCHAVtblsMap.end();
+}
+bool CHGraph::csHasVFnsBasedonCHA(const CallICFGNode* cs)
+{
+    CallSiteToVFunSetMap::const_iterator it = csToCHAVFnsMap.find(cs->getCallSite());
+    return it != csToCHAVFnsMap.end();
+}
+const VTableSet& CHGraph::getCSVtblsBasedonCHA(const CallICFGNode* cs)
+{
+    CallSiteToVTableSetMap::const_iterator it = csToCHAVtblsMap.find(cs->getCallSite());
+    assert(it != csToCHAVtblsMap.end() && "cs does not have vtabls based on CHA.");
+    return it->second;
+}
+const VFunSet& CHGraph::getCSVFsBasedonCHA(const CallICFGNode* cs)
+{
+    CallSiteToVFunSetMap::const_iterator it = csToCHAVFnsMap.find(cs->getCallSite());
+    assert(it != csToCHAVFnsMap.end() && "cs does not have vfns based on CHA.");
+    return it->second;
+}
+
 void CHGraph::addEdge(const string className, const string baseClassName,
                       CHEdge::CHEDGETYPE edgeType)
 {
@@ -96,13 +120,13 @@ CHNode *CHGraph::getNode(const string name) const
  * Get virtual functions for callsite "cs" based on vtbls (calculated
  * based on pointsto set)
  */
-void CHGraph::getVFnsFromVtbls(CallSite cs, const VTableSet &vtbls, VFunSet &virtualFunctions)
+void CHGraph::getVFnsFromVtbls(const SVFCallInst* callsite, const VTableSet &vtbls, VFunSet &virtualFunctions)
 {
-
+    const SVFVirtualCallInst* cs = SVFUtil::cast<SVFVirtualCallInst>(callsite);
     /// get target virtual functions
-    size_t idx = cs.getFunIdxInVtable();
+    size_t idx = cs->getFunIdxInVtable();
     /// get the function name of the virtual callsite
-    string funName = cs.getFunNameOfVirtualCall();
+    string funName = cs->getFunNameOfVirtualCall();
     for (const SVFGlobalValue *vt : vtbls)
     {
         const CHNode *child = getNode(vt->getName());
@@ -114,8 +138,8 @@ void CHGraph::getVFnsFromVtbls(CallSite cs, const VTableSet &vtbls, VFunSet &vir
                 feit = vfns.end(); fit != feit; ++fit)
         {
             const SVFFunction* callee = *fit;
-            if (cs.arg_size() == callee->arg_size() ||
-                    (cs.isVarArg() && callee->isVarArg()))
+            if (cs->arg_size() == callee->arg_size() ||
+                    (cs->isVarArg() && callee->isVarArg()))
             {
 
                 // if argument types do not match

package/svf/lib/Graphs/ICFG.cpp

@@ -179,7 +179,7 @@ const std::string CallCFGEdge::toString() const
     std::string str;
     std::stringstream rawstr(str);
     rawstr << "CallCFGEdge " << " [ICFGNode";
-    rawstr << getDstID() << " <-- ICFGNode" << getSrcID() << "]\t CallSite: " << cs->toString() << "\t";
+    rawstr << getDstID() << " <-- ICFGNode" << getSrcID() << "]\t CallSite: " << getSrcNode()->toString() << "\t";
     return rawstr.str();
 }
 
@@ -188,7 +188,7 @@ const std::string RetCFGEdge::toString() const
     std::string str;
     std::stringstream rawstr(str);
     rawstr << "RetCFGEdge " << " [ICFGNode";
-    rawstr << getDstID() << " <-- ICFGNode" << getSrcID() << "]\t CallSite: " << cs->toString() << "\t";
+    rawstr << getDstID() << " <-- ICFGNode" << getSrcID() << "]\t CallSite: " << getDstNode()->toString() << "\t";
     return rawstr.str();
 }
 
@@ -438,7 +438,7 @@ ICFGEdge* ICFG::addConditionalIntraEdge(ICFGNode* srcNode, ICFGNode* dstNode, co
 /*!
  * Add interprocedural call edges between two nodes
  */
-ICFGEdge* ICFG::addCallEdge(ICFGNode* srcNode, ICFGNode* dstNode, const SVFInstruction*  cs)
+ICFGEdge* ICFG::addCallEdge(ICFGNode* srcNode, ICFGNode* dstNode)
 {
     ICFGEdge* edge = hasInterICFGEdge(srcNode,dstNode, ICFGEdge::CallCF);
     if (edge != nullptr)
@@ -448,7 +448,7 @@ ICFGEdge* ICFG::addCallEdge(ICFGNode* srcNode, ICFGNode* dstNode, const SVFInstr
     }
     else
     {
-        CallCFGEdge* callEdge = new CallCFGEdge(srcNode,dstNode,cs);
+        CallCFGEdge* callEdge = new CallCFGEdge(srcNode,dstNode);
         return (addICFGEdge(callEdge) ? callEdge : nullptr);
     }
 }
@@ -456,7 +456,7 @@ ICFGEdge* ICFG::addCallEdge(ICFGNode* srcNode, ICFGNode* dstNode, const SVFInstr
 /*!
  * Add interprocedural return edges between two nodes
  */
-ICFGEdge* ICFG::addRetEdge(ICFGNode* srcNode, ICFGNode* dstNode, const SVFInstruction*  cs)
+ICFGEdge* ICFG::addRetEdge(ICFGNode* srcNode, ICFGNode* dstNode)
 {
     ICFGEdge* edge = hasInterICFGEdge(srcNode, dstNode, ICFGEdge::RetCF);
     if (edge != nullptr)
@@ -466,7 +466,7 @@ ICFGEdge* ICFG::addRetEdge(ICFGNode* srcNode, ICFGNode* dstNode, const SVFInstru
     }
     else
     {
-        RetCFGEdge* retEdge = new RetCFGEdge(srcNode,dstNode,cs);
+        RetCFGEdge* retEdge = new RetCFGEdge(srcNode,dstNode);
         return (addICFGEdge(retEdge) ? retEdge : nullptr);
     }
 }
@@ -513,7 +513,7 @@ void ICFG::updateCallGraph(CallGraph* callgraph)
             {
                 FunEntryICFGNode* calleeEntryNode = getFunEntryBlock(callee);
                 FunExitICFGNode* calleeExitNode = getFunExitBlock(callee);
-                if(ICFGEdge* callEdge = addCallEdge(callBlockNode, calleeEntryNode, cs))
+                if(ICFGEdge* callEdge = addCallEdge(callBlockNode, calleeEntryNode))
                 {
                     for (const SVFStmt *stmt : callBlockNode->getSVFStmts())
                     {
@@ -524,7 +524,7 @@ void ICFG::updateCallGraph(CallGraph* callgraph)
                         }
                     }
                 }
-                if(ICFGEdge* retEdge = addRetEdge(calleeExitNode, retBlockNode, cs))
+                if(ICFGEdge* retEdge = addRetEdge(calleeExitNode, retBlockNode))
                 {
                     for (const SVFStmt *stmt : retBlockNode->getSVFStmts())
                     {
@@ -650,9 +650,12 @@ struct DOTGraphTraits<ICFG*> : public DOTGraphTraits<SVFIR*>
         std::string str;
         std::stringstream rawstr(str);
         if (CallCFGEdge* dirCall = SVFUtil::dyn_cast<CallCFGEdge>(edge))
-            rawstr << dirCall->getCallSite();
+            rawstr << dirCall->getSrcNode();
         else if (RetCFGEdge* dirRet = SVFUtil::dyn_cast<RetCFGEdge>(edge))
-            rawstr << dirRet->getCallSite();
+        {
+            if(RetICFGNode* ret = SVFUtil::dyn_cast<RetICFGNode>(dirRet->getDstNode()))
+                rawstr << ret->getCallICFGNode();
+        }
 
         return rawstr.str();
     }

package/svf/lib/MSSA/MemRegion.cpp

@@ -601,7 +601,7 @@ bool MRGenerator::isNonLocalObject(NodeID id, const SVFFunction* curFun) const
 bool MRGenerator::handleCallsiteModRef(NodeBS& mod, NodeBS& ref, const CallICFGNode* cs, const SVFFunction* callee)
 {
     /// if a callee is a heap allocator function, then its mod set of this callsite is the heap object.
-    if(isHeapAllocExtCall(cs->getCallSite()))
+    if(isHeapAllocExtCall(cs))
     {
         SVFStmtList& pagEdgeList = getPAGEdgesFromInst(cs);
         for (SVFStmtList::const_iterator bit = pagEdgeList.begin(),
@@ -667,7 +667,7 @@ void MRGenerator::modRefAnalysis(CallGraphNode* callGraphNode, WorkList& worklis
  */
 NodeBS MRGenerator::getModInfoForCall(const CallICFGNode* cs)
 {
-    if (isExtCall(cs->getCallSite()) && !isHeapAllocExtCall(cs->getCallSite()))
+    if (isExtCall(cs) && !isHeapAllocExtCall(cs))
     {
         SVFStmtList& pagEdgeList = getPAGEdgesFromInst(cs);
         NodeBS mods;
@@ -691,7 +691,7 @@ NodeBS MRGenerator::getModInfoForCall(const CallICFGNode* cs)
  */
 NodeBS MRGenerator::getRefInfoForCall(const CallICFGNode* cs)
 {
-    if (isExtCall(cs->getCallSite()) && !isHeapAllocExtCall(cs->getCallSite()))
+    if (isExtCall(cs) && !isHeapAllocExtCall(cs))
     {
         SVFStmtList& pagEdgeList = getPAGEdgesFromInst(cs);
         NodeBS refs;

package/svf/lib/MTA/MHP.cpp

@@ -819,7 +819,7 @@ void ForkJoinAnalysis::handleJoin(const CxtStmt& cts, NodeID rootTid)
         const ICFGNode* forkSite = tct->getTCTNode(rootTid)->getCxtThread().getThread();
         const ICFGNode* joinSite = cts.getStmt();
 
-        if (isAliasedForkJoin(forkSite, joinSite))
+        if (isAliasedForkJoin(SVFUtil::cast<CallICFGNode>(forkSite), SVFUtil::cast<CallICFGNode>(joinSite)))
         {
             if (hasJoinLoop(joinSite))
             {

package/svf/lib/MemoryModel/PointerAnalysis.cpp

@@ -320,8 +320,8 @@ void PointerAnalysis::printIndCSTargets(const CallICFGNode* cs, const FunctionSe
 {
     outs() << "\nNodeID: " << getFunPtr(cs);
     outs() << "\nCallSite: ";
-    outs() << cs->getCallSite()->toString();
-    outs() << "\tLocation: " << cs->getCallSite()->getSourceLoc();
+    outs() << cs->toString();
+    outs() << "\tLocation: " << cs->getSourceLoc();
     outs() << "\t with Targets: ";
 
     if (!targets.empty())
@@ -368,8 +368,8 @@ void PointerAnalysis::printIndCSTargets()
         {
             outs() << "\nNodeID: " << csIt->second;
             outs() << "\nCallSite: ";
-            outs() << cs->getCallSite()->toString();
-            outs() << "\tLocation: " << cs->getCallSite()->getSourceLoc();
+            outs() << cs->toString();
+            outs() << "\tLocation: " << cs->getSourceLoc();
             outs() << "\n\t!!!has no targets!!!\n";
         }
     }
@@ -428,8 +428,8 @@ void PointerAnalysis::resolveIndCalls(const CallICFGNode* cs, const PointsTo& ta
  */
 void PointerAnalysis::getVFnsFromCHA(const CallICFGNode* cs, VFunSet &vfns)
 {
-    if (chgraph->csHasVFnsBasedonCHA(SVFUtil::getSVFCallSite(cs)))
-        vfns = chgraph->getCSVFsBasedonCHA(SVFUtil::getSVFCallSite(cs));
+    if (chgraph->csHasVFnsBasedonCHA(cs))
+        vfns = chgraph->getCSVFsBasedonCHA(cs);
 }
 
 /*
@@ -438,10 +438,10 @@ void PointerAnalysis::getVFnsFromCHA(const CallICFGNode* cs, VFunSet &vfns)
 void PointerAnalysis::getVFnsFromPts(const CallICFGNode* cs, const PointsTo &target, VFunSet &vfns)
 {
 
-    if (chgraph->csHasVtblsBasedonCHA(SVFUtil::getSVFCallSite(cs)))
+    if (chgraph->csHasVtblsBasedonCHA(cs))
     {
         Set<const SVFGlobalValue*> vtbls;
-        const VTableSet &chaVtbls = chgraph->getCSVtblsBasedonCHA(SVFUtil::getSVFCallSite(cs));
+        const VTableSet &chaVtbls = chgraph->getCSVtblsBasedonCHA(cs);
         for (PointsTo::iterator it = target.begin(), eit = target.end(); it != eit; ++it)
         {
             const PAGNode *ptdnode = pag->getGNode(*it);
@@ -454,7 +454,7 @@ void PointerAnalysis::getVFnsFromPts(const CallICFGNode* cs, const PointsTo &tar
                 }
             }
         }
-        chgraph->getVFnsFromVtbls(SVFUtil::getSVFCallSite(cs), vtbls, vfns);
+        chgraph->getVFnsFromVtbls(SVFUtil::cast<SVFCallInst>(cs->getCallSite()), vtbls, vfns);
     }
 }
 
@@ -471,12 +471,12 @@ void PointerAnalysis::connectVCallToVFns(const CallICFGNode* cs, const VFunSet &
         callee = callee->getDefFunForMultipleModule();
         if (getIndCallMap()[cs].count(callee) > 0)
             continue;
-        if(SVFUtil::getSVFCallSite(cs).arg_size() == callee->arg_size() ||
-                (SVFUtil::getSVFCallSite(cs).isVarArg() && callee->isVarArg()))
+        if(cs->arg_size() == callee->arg_size() ||
+                (cs->isVarArg() && callee->isVarArg()))
         {
             newEdges[cs].insert(callee);
             getIndCallMap()[cs].insert(callee);
-            const CallICFGNode* callBlockNode = pag->getICFG()->getCallICFGNode(cs->getCallSite());
+            const CallICFGNode* callBlockNode = cs;
             callgraph->addIndirectCallGraphEdge(callBlockNode, cs->getCaller(),callee);
         }
     }
@@ -485,7 +485,7 @@ void PointerAnalysis::connectVCallToVFns(const CallICFGNode* cs, const VFunSet &
 /// Resolve cpp indirect call edges
 void PointerAnalysis::resolveCPPIndCalls(const CallICFGNode* cs, const PointsTo& target, CallEdgeMap& newEdges)
 {
-    assert(SVFUtil::getSVFCallSite(cs).isVirtualCall() && "not cpp virtual call");
+    assert(cs->isVirtualCall() && "not cpp virtual call");
 
     VFunSet vfns;
     if (Options::ConnectVCallOnCHA())
@@ -511,11 +511,10 @@ void PointerAnalysis::validateSuccessTests(std::string fun)
         {
             if (SVFUtil::getCallee(callNode) == checkFun)
             {
-                CallSite cs = SVFUtil::getSVFCallSite(callNode);
-                assert(cs.getNumArgOperands() == 2
+                assert(callNode->getNumArgOperands() == 2
                        && "arguments should be two pointers!!");
-                const SVFValue* V1 = cs.getArgOperand(0);
-                const SVFValue* V2 = cs.getArgOperand(1);
+                const SVFValue* V1 = callNode->getArgOperand(0);
+                const SVFValue* V2 = callNode->getArgOperand(1);
                 AliasResult aliasRes = alias(V1, V2);
 
                 bool checkSuccessful = false;
@@ -577,11 +576,10 @@ void PointerAnalysis::validateExpectedFailureTests(std::string fun)
         {
             if (SVFUtil::getCallee(callNode) == checkFun)
             {
-                CallSite call = getSVFCallSite(callNode);
-                assert(call.arg_size() == 2
+                assert(callNode->arg_size() == 2
                        && "arguments should be two pointers!!");
-                const SVFValue* V1 = call.getArgOperand(0);
-                const SVFValue* V2 = call.getArgOperand(1);
+                const SVFValue* V1 = callNode->getArgOperand(0);
+                const SVFValue* V2 = callNode->getArgOperand(1);
                 AliasResult aliasRes = alias(V1, V2);
 
                 bool expectedFailure = false;
@@ -605,11 +603,11 @@ void PointerAnalysis::validateExpectedFailureTests(std::string fun)
 
                 if (expectedFailure)
                     outs() << sucMsg("\t EXPECTED-FAILURE :") << fun << " check <id:" << id1 << ", id:" << id2 << "> at ("
-                           << call.getInstruction()->getSourceLoc() << ")\n";
+                           << callNode->getSourceLoc() << ")\n";
                 else
                 {
                     SVFUtil::errs() << errMsg("\t UNEXPECTED FAILURE :") << fun << " check <id:" << id1 << ", id:" << id2 << "> at ("
-                                    << call.getInstruction()->getSourceLoc() << ")\n";
+                                    << callNode->getSourceLoc() << ")\n";
                     assert(false && "test case failed!");
                 }
             }

package/svf/lib/MemoryModel/PointerAnalysisImpl.cpp

@@ -495,9 +495,9 @@ void BVDataPTAImpl::onTheFlyCallGraphSolve(const CallSiteToFunPtrMap& callsites,
     {
         const CallICFGNode* cs = iter->first;
 
-        if (SVFUtil::getSVFCallSite(cs).isVirtualCall())
+        if (cs->isVirtualCall())
         {
-            const SVFValue* vtbl = SVFUtil::getSVFCallSite(cs).getVtablePtr();
+            const SVFValue* vtbl = cs->getVtablePtr();
             assert(pag->hasValueNode(vtbl));
             NodeID vtblId = pag->getValueNode(vtbl);
             resolveCPPIndCalls(cs, getPts(vtblId), newEdges);

package/svf/lib/SABER/SaberCondAllocator.cpp

@@ -428,7 +428,7 @@ void SaberCondAllocator::collectBBCallingProgExit(const SVFBasicBlock &bb)
     for (const auto& icfgNode: bb.getICFGNodeList())
     {
         if (const CallICFGNode* cs = SVFUtil::dyn_cast<CallICFGNode>(icfgNode))
-            if (SVFUtil::isProgExitCall(cs->getCallSite()))
+            if (SVFUtil::isProgExitCall(cs))
             {
                 const SVFFunction* svfun = bb.getParent();
                 funToExitBBsMap[svfun].insert(&bb);

package/svf/lib/SABER/SaberSVFGBuilder.cpp

@@ -138,7 +138,7 @@ PointsTo& SaberSVFGBuilder::CollectPtsChain(BVDataPTAImpl* pta, NodeID id, NodeT
             if(pta->isFIObjNode(baseId) && pag->getGNode(baseId)->hasValue())
             {
                 const SVFCallInst* inst = SVFUtil::dyn_cast<SVFCallInst>(pag->getGNode(baseId)->getValue());
-                if(inst && SVFUtil::isExtCall(inst))
+                if(inst && SVFUtil::isExtCall(pag->getICFG()->getCallICFGNode(inst)))
                 {
                     return pts;
                 }

package/svf/lib/SVFIR/SVFFileSystem.cpp

@@ -443,7 +443,6 @@ cJSON* SVFIRWriter::contentToJson(const IntraCFGEdge* edge)
 cJSON* SVFIRWriter::contentToJson(const CallCFGEdge* edge)
 {
     cJSON* root = contentToJson(static_cast<const ICFGEdge*>(edge));
-    JSON_WRITE_FIELD(root, edge, cs);
     JSON_WRITE_FIELD(root, edge, callPEs);
     return root;
 }
@@ -451,7 +450,6 @@ cJSON* SVFIRWriter::contentToJson(const CallCFGEdge* edge)
 cJSON* SVFIRWriter::contentToJson(const RetCFGEdge* edge)
 {
     cJSON* root = contentToJson(static_cast<const ICFGEdge*>(edge));
-    JSON_WRITE_FIELD(root, edge, cs);
     JSON_WRITE_FIELD(root, edge, retPE);
     return root;
 }
@@ -571,8 +569,6 @@ cJSON* SVFIRWriter::contentToJson(const SVFInstruction* value)
     JSON_WRITE_FIELD(root, value, bb);
     JSON_WRITE_FIELD(root, value, terminator);
     JSON_WRITE_FIELD(root, value, ret);
-    JSON_WRITE_FIELD(root, value, succInsts);
-    JSON_WRITE_FIELD(root, value, predInsts);
     return root;
 }
 
@@ -1179,11 +1175,6 @@ cJSON* SVFIRWriter::toJson(const CHEdge* edge)
     return jsonCreateIndex(chgWriter.getEdgeID(edge));
 }
 
-cJSON* SVFIRWriter::toJson(const CallSite& cs)
-{
-    return toJson(cs.getInstruction());
-}
-
 cJSON* SVFIRWriter::toJson(const SVFLoop* loop)
 {
     return jsonCreateIndex(icfgWriter.getSvfLoopID(loop));
@@ -1613,9 +1604,9 @@ ICFGEdge* SVFIRReader::createICFGEdge(GEdgeKind kind)
     case ICFGEdge::IntraCF:
         return new IntraCFGEdge(src, dst);
     case ICFGEdge::CallCF:
-        return new CallCFGEdge(src, dst, nullptr);
+        return new CallCFGEdge(src, dst);
     case ICFGEdge::RetCF:
-        return new RetCFGEdge(src, dst, nullptr);
+        return new RetCFGEdge(src, dst);
     }
 }
 
@@ -1855,11 +1846,6 @@ void SVFIRReader::readJson(const cJSON* obj, CHEdge*& edge)
     edge = chGraphReader.getEdgePtr(jsonGetNumber(obj));
 }
 
-void SVFIRReader::readJson(const cJSON* obj, CallSite& cs)
-{
-    readJson(obj, cs.CB);
-}
-
 void SVFIRReader::readJson(const cJSON* obj, AccessPath& ap)
 {
     ABORT_IFNOT(jsonIsObject(obj), "Expected obj for AccessPath");
@@ -2270,14 +2256,12 @@ void SVFIRReader::fill(const cJSON*& fieldJson, IntraCFGEdge* edge)
 void SVFIRReader::fill(const cJSON*& fieldJson, CallCFGEdge* edge)
 {
     fill(fieldJson, static_cast<ICFGEdge*>(edge));
-    JSON_READ_FIELD_FWD(fieldJson, edge, cs);
     JSON_READ_FIELD_FWD(fieldJson, edge, callPEs);
 }
 
 void SVFIRReader::fill(const cJSON*& fieldJson, RetCFGEdge* edge)
 {
     fill(fieldJson, static_cast<ICFGEdge*>(edge));
-    JSON_READ_FIELD_FWD(fieldJson, edge, cs);
     JSON_READ_FIELD_FWD(fieldJson, edge, retPE);
 }
 
@@ -2391,8 +2375,6 @@ void SVFIRReader::fill(const cJSON*& fieldJson, SVFInstruction* value)
     JSON_READ_FIELD_FWD(fieldJson, value, bb);
     JSON_READ_FIELD_FWD(fieldJson, value, terminator);
     JSON_READ_FIELD_FWD(fieldJson, value, ret);
-    JSON_READ_FIELD_FWD(fieldJson, value, succInsts);
-    JSON_READ_FIELD_FWD(fieldJson, value, predInsts);
 }
 
 void SVFIRReader::fill(const cJSON*& fieldJson, SVFCallInst* value)

package/svf/lib/Util/SVFUtil.cpp

@@ -319,11 +319,10 @@ void SVFUtil::stopAnalysisLimitTimer(bool limitTimerSet)
 /// for variadic function, callsite arg size must be greater than or equal to callee arg size
 bool SVFUtil::matchArgs(const CallICFGNode* call, const SVFFunction* callee)
 {
-    CallSite cs(call->getCallSite());
     if (callee->isVarArg() || ThreadAPI::getThreadAPI()->isTDFork(call))
-        return cs.arg_size() >= callee->arg_size();
+        return call->arg_size() >= callee->arg_size();
     else
-        return cs.arg_size() == callee->arg_size();
+        return call->arg_size() == callee->arg_size();
 }
 
 bool SVFUtil::isCallSite(const ICFGNode* inst)
@@ -331,19 +330,11 @@ bool SVFUtil::isCallSite(const ICFGNode* inst)
     return SVFUtil::isa<CallICFGNode>(inst);
 }
 
-CallSite SVFUtil::getSVFCallSite(const ICFGNode* inst)
-{
-    assert(isCallSite(inst) && "not a callsite?");
-    CallSite cs(cast<CallICFGNode>(inst)->getCallSite());
-    return cs;
-}
-
 bool SVFUtil::isIntrinsicInst(const ICFGNode* inst)
 {
     if (const CallICFGNode* call = SVFUtil::dyn_cast<CallICFGNode>(inst))
     {
-        CallSite cs(call->getCallSite());
-        const SVFFunction* func = cs.getCalledFunction();
+        const SVFFunction* func = call->getCalledFunction();
         if (func && func->isIntrinsic())
         {
             return true;
@@ -356,22 +347,47 @@ const SVFFunction* SVFUtil::getCallee(const ICFGNode *inst)
 {
     if (!isCallSite(inst))
         return nullptr;
-    CallSite cs(cast<CallICFGNode>(inst)->getCallSite());
-    return getCallee(cs);
+    const CallICFGNode* call = SVFUtil::cast<CallICFGNode>(inst);
+    return call->getCalledFunction();
+}
+
+const SVFFunction* SVFUtil::getCallee(const CallICFGNode *inst)
+{
+    return inst->getCalledFunction();
 }
 
+
 bool SVFUtil::isExtCall(const ICFGNode* node)
 {
     if(!isCallSite(node)) return false;
-    CallSite cs(cast<CallICFGNode>(node)->getCallSite());
-    return isExtCall(getCallee(cs));
+    return isExtCall(getCallee(node));
 }
 
 bool SVFUtil::isHeapAllocExtCall(const ICFGNode* cs)
 {
     if(!isCallSite(cs)) return false;
-    CallSite callSite(cast<CallICFGNode>(cs)->getCallSite());
-    return isHeapAllocExtCallViaRet(callSite) || isHeapAllocExtCallViaArg(callSite);
+    return isHeapAllocExtCallViaRet(cast<CallICFGNode>(cs)) || isHeapAllocExtCallViaArg(cast<CallICFGNode>(cs));
+}
+
+bool SVFUtil::isHeapAllocExtCallViaRet(const CallICFGNode* cs)
+{
+    bool isPtrTy = cs->getCallSite()->getType()->isPointerTy();
+    return isPtrTy && isHeapAllocExtFunViaRet(getCallee(cs));
+}
+
+bool SVFUtil::isReallocExtCall(const CallICFGNode* cs)
+{
+    bool isPtrTy = cs->getCallSite()->getType()->isPointerTy();
+    return isPtrTy && isReallocExtFun(getCallee(cs));
+}
+
+bool SVFUtil::isHeapAllocExtCallViaRet(const SVFInstruction *inst)
+{
+    bool isPtrTy = inst->getType()->isPointerTy();
+    if(const SVFCallInst* call = SVFUtil::dyn_cast<SVFCallInst>(inst))
+        return isPtrTy && isHeapAllocExtFunViaRet(call->getCalledFunction());
+    else
+        return false;
 }
 
 bool SVFUtil::isRetInstNode(const ICFGNode* node)

package/svf/lib/Util/ThreadAPI.cpp

@@ -129,6 +129,32 @@ void ThreadAPI::init()
     }
 }
 
+const SVFValue* ThreadAPI::getForkedThread(const CallICFGNode *inst) const
+{
+    assert(isTDFork(inst) && "not a thread fork function!");
+    return inst->getArgument(0);
+}
+
+const SVFValue* ThreadAPI::getForkedFun(const CallICFGNode *inst) const
+{
+    assert(isTDFork(inst) && "not a thread fork function!");
+    return inst->getArgument(2);
+}
+
+/// Return the forth argument of the call,
+/// Note that, it is the sole argument of start routine ( a void* pointer )
+const SVFValue* ThreadAPI::getActualParmAtForkSite(const CallICFGNode *inst) const
+{
+    assert(isTDFork(inst) && "not a thread fork function!");
+    return inst->getArgument(3);
+}
+
+const SVFValue* ThreadAPI::getRetParmAtJoinedSite(const CallICFGNode *inst) const
+{
+    assert(isTDJoin(inst) && "not a thread join function!");
+    return inst->getArgument(1);
+}
+
 /*!
  *
  */
@@ -140,27 +166,18 @@ const SVFFunction* ThreadAPI::getCallee(const ICFGNode *inst) const
         return nullptr;
 }
 
-const CallSite ThreadAPI::getSVFCallSite(const ICFGNode *inst) const
+const SVFValue* ThreadAPI::getLockVal(const ICFGNode *cs) const
 {
-    assert(SVFUtil::isa<CallICFGNode>(inst) && "not a callsite?");
-    CallSite cs(SVFUtil::cast<CallICFGNode>(inst)->getCallSite());
-    return cs;
-}
-
-const SVFValue* ThreadAPI::getLockVal(const ICFGNode *inst) const
-{
-    const CallICFGNode* call = SVFUtil::dyn_cast<CallICFGNode>(inst);
+    const CallICFGNode* call = SVFUtil::dyn_cast<CallICFGNode>(cs);
     assert(call && "not a call ICFGNode?");
     assert((isTDAcquire(call) || isTDRelease(call)) && "not a lock acquire or release function");
-    CallSite cs = getSVFCallSite(call);
-    return cs.getArgument(0);
+    return call->getArgument(0);
 }
 
-const SVFValue* ThreadAPI::getJoinedThread(const ICFGNode *inst) const
+const SVFValue* ThreadAPI::getJoinedThread(const CallICFGNode *cs) const
 {
-    assert(isTDJoin(inst) && "not a thread join function!");
-    CallSite cs = getSVFCallSite(inst);
-    const SVFValue* join = cs.getArgument(0);
+    assert(isTDJoin(cs) && "not a thread join function!");
+    const SVFValue* join = cs->getArgument(0);
     const SVFVar* var = PAG::getPAG()->getGNode(PAG::getPAG()->getValueNode(join));
     for(const SVFStmt* stmt : var->getInEdges())
     {

package/svf/lib/WPA/Andersen.cpp

@@ -661,10 +661,9 @@ bool Andersen::updateCallGraph(const CallSiteToFunPtrMap& callsites)
     NodePairSet cpySrcNodes;	/// nodes as a src of a generated new copy edge
     for(CallEdgeMap::iterator it = newEdges.begin(), eit = newEdges.end(); it!=eit; ++it )
     {
-        CallSite cs = SVFUtil::getSVFCallSite(it->first);
         for(FunctionSet::iterator cit = it->second.begin(), ecit = it->second.end(); cit!=ecit; ++cit)
         {
-            connectCaller2CalleeParams(cs,*cit,cpySrcNodes);
+            connectCaller2CalleeParams(it->first,*cit,cpySrcNodes);
         }
     }
     for(NodePairSet::iterator it = cpySrcNodes.begin(), eit = cpySrcNodes.end(); it!=eit; ++it)
@@ -678,10 +677,10 @@ bool Andersen::updateCallGraph(const CallSiteToFunPtrMap& callsites)
     return (!newEdges.empty());
 }
 
-void Andersen::heapAllocatorViaIndCall(CallSite cs, NodePairSet &cpySrcNodes)
+void Andersen::heapAllocatorViaIndCall(const CallICFGNode* cs, NodePairSet &cpySrcNodes)
 {
     assert(SVFUtil::getCallee(cs) == nullptr && "not an indirect callsite?");
-    RetICFGNode* retBlockNode = pag->getICFG()->getRetICFGNode(cs.getInstruction());
+    const RetICFGNode* retBlockNode = cs->getRetICFGNode();
     const PAGNode* cs_return = pag->getCallSiteRet(retBlockNode);
     NodeID srcret;
     CallSite2DummyValPN::const_iterator it = callsite2DummyValPN.find(cs);
@@ -692,7 +691,7 @@ void Andersen::heapAllocatorViaIndCall(CallSite cs, NodePairSet &cpySrcNodes)
     else
     {
         NodeID valNode = pag->addDummyValNode();
-        NodeID objNode = pag->addDummyObjNode(cs.getType());
+        NodeID objNode = pag->addDummyObjNode(cs->getCallSite()->getType());
         addPts(valNode,objNode);
         callsite2DummyValPN.insert(std::make_pair(cs,valNode));
         consCG->addConstraintNode(new ConstraintNode(valNode),valNode);
@@ -708,14 +707,14 @@ void Andersen::heapAllocatorViaIndCall(CallSite cs, NodePairSet &cpySrcNodes)
 /*!
  * Connect formal and actual parameters for indirect callsites
  */
-void Andersen::connectCaller2CalleeParams(CallSite cs, const SVFFunction* F, NodePairSet &cpySrcNodes)
+void Andersen::connectCaller2CalleeParams(const CallICFGNode* cs, const SVFFunction* F, NodePairSet &cpySrcNodes)
 {
     assert(F);
 
     DBOUT(DAndersen, outs() << "connect parameters from indirect callsite " << cs.getInstruction()->toString() << " to callee " << *F << "\n");
 
-    CallICFGNode* callBlockNode = pag->getICFG()->getCallICFGNode(cs.getInstruction());
-    RetICFGNode* retBlockNode = pag->getICFG()->getRetICFGNode(cs.getInstruction());
+    const CallICFGNode* callBlockNode = cs;
+    const RetICFGNode* retBlockNode = cs->getRetICFGNode();
 
     if(SVFUtil::isHeapAllocExtFunViaRet(F) && pag->callsiteHasRet(retBlockNode))
     {
@@ -795,7 +794,7 @@ void Andersen::connectCaller2CalleeParams(CallSite cs, const SVFFunction* F, Nod
         if(csArgIt != csArgEit)
         {
             writeWrnMsg("too many args to non-vararg func.");
-            writeWrnMsg("(" + cs.getInstruction()->getSourceLoc() + ")");
+            writeWrnMsg("(" + cs->getSourceLoc() + ")");
         }
     }
 }