svf-tools 1.0.358 → 1.0.359

package/include/Graphs/ICFG.h

@@ -163,19 +163,19 @@ public:
     /// Get a basic block ICFGNode
     /// TODO:: need to fix the assertions
     //@{
-    ICFGNode* getBlockICFGNode(const Instruction* inst);
+    ICFGNode* getICFGNode(const Instruction* inst);
 
-    CallICFGNode* getCallBlockNode(const Instruction* inst);
+    CallICFGNode* getCallICFGNode(const Instruction* inst);
 
-    RetICFGNode* getRetBlockNode(const Instruction* inst);
+    RetICFGNode* getRetICFGNode(const Instruction* inst);
 
-    IntraICFGNode* getIntraBlockNode(const Instruction* inst);
+    IntraICFGNode* getIntraICFGNode(const Instruction* inst);
 
-    FunEntryICFGNode* getFunEntryBlockNode(const SVFFunction*  fun);
+    FunEntryICFGNode* getFunEntryICFGNode(const SVFFunction*  fun);
 
-    FunExitICFGNode* getFunExitBlockNode(const SVFFunction*  fun);
+    FunExitICFGNode* getFunExitICFGNode(const SVFFunction*  fun);
 
-    inline GlobalICFGNode* getGlobalBlockNode() const
+    inline GlobalICFGNode* getGlobalICFGNode() const
     {
         return globalBlockNode;
     }
@@ -184,14 +184,14 @@ public:
 private:
 	
     /// Get/Add IntraBlock ICFGNode
-    inline IntraICFGNode* getIntraBlockICFGNode(const Instruction* inst)
+    inline IntraICFGNode* getIntraBlock(const Instruction* inst)
     {
         InstToBlockNodeMapTy::const_iterator it = InstToBlockNodeMap.find(inst);
         if (it == InstToBlockNodeMap.end())
             return nullptr;
         return it->second;
     }
-    inline IntraICFGNode* addIntraBlockICFGNode(const Instruction* inst)
+    inline IntraICFGNode* addIntraBlock(const Instruction* inst)
     {
         IntraICFGNode* sNode = new IntraICFGNode(totalICFGNode++,inst);
         addICFGNode(sNode);
@@ -200,14 +200,14 @@ private:
     }
 
     /// Get/Add a function entry node
-    inline FunEntryICFGNode* getFunEntryICFGNode(const SVFFunction* fun)
+    inline FunEntryICFGNode* getFunEntryBlock(const SVFFunction* fun)
     {
         FunToFunEntryNodeMapTy::const_iterator it = FunToFunEntryNodeMap.find(fun);
         if (it == FunToFunEntryNodeMap.end())
             return nullptr;
         return it->second;
     }
-    inline FunEntryICFGNode* addFunEntryICFGNode(const SVFFunction* fun)
+    inline FunEntryICFGNode* addFunEntryBlock(const SVFFunction* fun)
     {
         FunEntryICFGNode* sNode = new FunEntryICFGNode(totalICFGNode++,fun);
         addICFGNode(sNode);
@@ -216,14 +216,14 @@ private:
     }
 
     /// Get/Add a function exit node
-    inline FunExitICFGNode* getFunExitICFGNode(const SVFFunction* fun)
+    inline FunExitICFGNode* getFunExitBlock(const SVFFunction* fun)
     {
         FunToFunExitNodeMapTy::const_iterator it = FunToFunExitNodeMap.find(fun);
         if (it == FunToFunExitNodeMap.end())
             return nullptr;
         return it->second;
     }
-    inline FunExitICFGNode* addFunExitICFGNode(const SVFFunction* fun)
+    inline FunExitICFGNode* addFunExitBlock(const SVFFunction* fun)
     {
         FunExitICFGNode* sNode = new FunExitICFGNode(totalICFGNode++, fun);
         addICFGNode(sNode);
@@ -232,14 +232,14 @@ private:
     }
 
     /// Get/Add a call node
-    inline CallICFGNode* addCallICFGNode(const Instruction* cs)
+    inline CallICFGNode* addCallBlock(const Instruction* cs)
     {
         CallICFGNode* sNode = new CallICFGNode(totalICFGNode++, cs);
         addICFGNode(sNode);
         CSToCallNodeMap[cs] = sNode;
         return sNode;
     }
-    inline CallICFGNode* getCallICFGNode(const Instruction* cs)
+    inline CallICFGNode* getCallBlock(const Instruction* cs)
     {
         CSToCallNodeMapTy::const_iterator it = CSToCallNodeMap.find(cs);
         if (it == CSToCallNodeMap.end())
@@ -248,16 +248,16 @@ private:
     }
 
     /// Get/Add a return node
-    inline RetICFGNode* getRetICFGNode(const Instruction* cs)
+    inline RetICFGNode* getRetBlock(const Instruction* cs)
     {
         CSToRetNodeMapTy::const_iterator it = CSToRetNodeMap.find(cs);
         if (it == CSToRetNodeMap.end())
             return nullptr;
         return it->second;
     }
-    inline RetICFGNode* addRetICFGNode(const Instruction* cs)
+    inline RetICFGNode* addRetBlock(const Instruction* cs)
     {
-        CallICFGNode* callBlockNode = getCallBlockNode(cs);
+        CallICFGNode* callBlockNode = getCallICFGNode(cs);
         RetICFGNode* sNode = new RetICFGNode(totalICFGNode++, cs, callBlockNode);
         callBlockNode->setRetICFGNode(sNode);
         addICFGNode(sNode);

package/include/Graphs/ICFGNode.h

@@ -384,7 +384,7 @@ public:
     }
 
     /// Return callsite
-    inline const RetICFGNode* getRetICFGNode() const
+    inline const RetICFGNode* getRetBlock() const
     {
     	assert(ret && "RetICFGNode not set?");
         return ret;
@@ -477,7 +477,7 @@ public:
         return cs;
     }
 
-    inline const CallICFGNode* getCallBlockNode() const
+    inline const CallICFGNode* getCallICFGNode() const
     {
         return callBlockNode;
     }

package/include/Graphs/SVFG.h

@@ -397,7 +397,7 @@ protected:
     inline void addFormalINSVFGNode(const FunEntryICFGNode* funEntry,  const MRVer* resVer, const NodeID nodeId)
     {
         FormalINSVFGNode* sNode = new FormalINSVFGNode(nodeId, resVer, funEntry);
-        addSVFGNode(sNode, pag->getICFG()->getFunEntryBlockNode(funEntry->getFun()));
+        addSVFGNode(sNode, pag->getICFG()->getFunEntryICFGNode(funEntry->getFun()));
         setDef(resVer,sNode);
         funToFormalINMap[funEntry->getFun()].set(sNode->getId());
     }
@@ -406,7 +406,7 @@ protected:
     inline void addFormalOUTSVFGNode(const FunExitICFGNode* funExit, const MRVer* ver, const NodeID nodeId)
     {
         FormalOUTSVFGNode* sNode = new FormalOUTSVFGNode(nodeId, ver, funExit);
-        addSVFGNode(sNode,pag->getICFG()->getFunExitBlockNode(funExit->getFun()));
+        addSVFGNode(sNode,pag->getICFG()->getFunExitICFGNode(funExit->getFun()));
         funToFormalOUTMap[funExit->getFun()].set(sNode->getId());
     }
 
@@ -414,7 +414,7 @@ protected:
     inline void addActualINSVFGNode(const CallICFGNode* callsite, const MRVer* ver, const NodeID nodeId)
     {
         ActualINSVFGNode* sNode = new ActualINSVFGNode(nodeId, callsite, ver);
-        addSVFGNode(sNode,pag->getICFG()->getCallBlockNode(callsite->getCallSite()));
+        addSVFGNode(sNode,pag->getICFG()->getCallICFGNode(callsite->getCallSite()));
         callSiteToActualINMap[callsite].set(sNode->getId());
     }
 
@@ -422,7 +422,7 @@ protected:
     inline void addActualOUTSVFGNode(const CallICFGNode* callsite, const MRVer* resVer, const NodeID nodeId)
     {
         ActualOUTSVFGNode* sNode = new ActualOUTSVFGNode(nodeId, callsite, resVer);
-        addSVFGNode(sNode, pag->getICFG()->getRetBlockNode(callsite->getCallSite()));
+        addSVFGNode(sNode, pag->getICFG()->getRetICFGNode(callsite->getCallSite()));
         setDef(resVer,sNode);
         callSiteToActualOUTMap[callsite].set(sNode->getId());
     }

package/include/Graphs/SVFGOPT.h

@@ -244,7 +244,7 @@ private:
     inline InterPHISVFGNode* addInterPHIForFP(const FormalParmSVFGNode* fp)
     {
         InterPHISVFGNode* sNode = new InterPHISVFGNode(totalVFGNode++,fp);
-        addSVFGNode(sNode, pag->getICFG()->getFunEntryBlockNode(fp->getFun()));
+        addSVFGNode(sNode, pag->getICFG()->getFunEntryICFGNode(fp->getFun()));
         resetDef(fp->getParam(),sNode);
         return sNode;
     }
@@ -252,7 +252,7 @@ private:
     inline InterPHISVFGNode* addInterPHIForAR(const ActualRetSVFGNode* ar)
     {
         InterPHISVFGNode* sNode = new InterPHISVFGNode(totalVFGNode++,ar);
-        addSVFGNode(sNode, pag->getICFG()->getRetBlockNode(ar->getCallSite()->getCallSite()));
+        addSVFGNode(sNode, pag->getICFG()->getRetICFGNode(ar->getCallSite()->getCallSite()));
         resetDef(ar->getRev(),sNode);
         return sNode;
     }

package/include/Graphs/VFG.h

@@ -479,7 +479,7 @@ protected:
     inline void addNullPtrVFGNode(const PAGNode* pagNode)
     {
         NullPtrVFGNode* sNode = new NullPtrVFGNode(totalVFGNode++,pagNode);
-        addVFGNode(sNode, pag->getICFG()->getGlobalBlockNode());
+        addVFGNode(sNode, pag->getICFG()->getGlobalICFGNode());
         setDef(pagNode,sNode);
     }
     /// Add an Address VFG node
@@ -524,7 +524,7 @@ protected:
     inline void addActualParmVFGNode(const PAGNode* aparm, const CallICFGNode* cs)
     {
         ActualParmVFGNode* sNode = new ActualParmVFGNode(totalVFGNode++,aparm,cs);
-        addVFGNode(sNode, pag->getICFG()->getCallBlockNode(cs->getCallSite()));
+        addVFGNode(sNode, pag->getICFG()->getCallICFGNode(cs->getCallSite()));
         PAGNodeToActualParmMap[std::make_pair(aparm->getId(),cs)] = sNode;
         /// do not set def here, this node is not a variable definition
     }
@@ -532,7 +532,7 @@ protected:
     inline void addFormalParmVFGNode(const PAGNode* fparm, const SVFFunction* fun, CallPESet& callPEs)
     {
         FormalParmVFGNode* sNode = new FormalParmVFGNode(totalVFGNode++,fparm,fun);
-        addVFGNode(sNode, pag->getICFG()->getFunEntryBlockNode(fun));
+        addVFGNode(sNode, pag->getICFG()->getFunEntryICFGNode(fun));
         for(CallPESet::const_iterator it = callPEs.begin(), eit=callPEs.end();
                 it!=eit; ++it)
             sNode->addCallPE(*it);
@@ -546,7 +546,7 @@ protected:
     inline void addFormalRetVFGNode(const PAGNode* uniqueFunRet, const SVFFunction* fun, RetPESet& retPEs)
     {
 		FormalRetVFGNode *sNode = new FormalRetVFGNode(totalVFGNode++, uniqueFunRet, fun);
-		addVFGNode(sNode, pag->getICFG()->getFunExitBlockNode(fun));
+		addVFGNode(sNode, pag->getICFG()->getFunExitICFGNode(fun));
 		for (RetPESet::const_iterator it = retPEs.begin(), eit = retPEs.end(); it != eit; ++it)
 			sNode->addRetPE(*it);
 
@@ -564,7 +564,7 @@ protected:
     inline void addActualRetVFGNode(const PAGNode* ret,const CallICFGNode* cs)
     {
         ActualRetVFGNode* sNode = new ActualRetVFGNode(totalVFGNode++,ret,cs);
-        addVFGNode(sNode, pag->getICFG()->getRetBlockNode(cs->getCallSite()));
+        addVFGNode(sNode, pag->getICFG()->getRetICFGNode(cs->getCallSite()));
         setDef(ret,sNode);
         PAGNodeToActualRetMap[ret] = sNode;
     }

package/include/MTA/LockResultValidator.h

@@ -35,7 +35,7 @@ public:
 private:
 	// Get CallICFGNode
 	inline CallICFGNode* getCBN(const Instruction* inst) {
-		return _la->getTCT()->getCallBlockNode(inst);
+		return _la->getTCT()->getCallICFGNode(inst);
 	}
 	const Instruction *getPreviousMemoryAccessInst( const Instruction *I) {
         I = I->getPrevNode();

package/include/MTA/MHP.h

@@ -63,7 +63,7 @@ public:
 	
 	// Get CallICFGNode
 	inline CallICFGNode* getCBN(const Instruction* inst) {
-		return tct->getCallBlockNode(inst);
+		return tct->getCallICFGNode(inst);
 	}
 
     /// Whether the function is connected from main function in thread call graph
@@ -381,7 +381,7 @@ private:
     }
     // Get CallICFGNode
 	inline CallICFGNode* getCBN(const Instruction* inst) {
-		return tct->getCallBlockNode(inst);
+		return tct->getCallICFGNode(inst);
 	}
     /// Mark thread flags for cxtStmt
     //@{

package/include/MTA/PCG.h

@@ -123,8 +123,8 @@ public:
     {
     }
 	
-	CallICFGNode* getCallBlockNode(const Instruction* inst) {
-		return pta->getICFG()->getCallBlockNode(inst);
+	CallICFGNode* getCallICFGNode(const Instruction* inst) {
+		return pta->getICFG()->getCallICFGNode(inst);
 	}
 	const SVFFunction* getSVFFun(const Function* fun) const {
 		return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);

package/include/MTA/TCT.h

@@ -148,8 +148,8 @@ public:
         destroy();
     }
     /// Get CallICFGNode given inst
-    CallICFGNode* getCallBlockNode(const Instruction* inst) {
-		return pta->getICFG()->getCallBlockNode(inst);
+    CallICFGNode* getCallICFGNode(const Instruction* inst) {
+		return pta->getICFG()->getCallICFGNode(inst);
 	}
 	/// Get SVFFuntion given Function 
 	const SVFFunction* getSVFFun(const Function* fun) const {

package/include/MemoryModel/SVFIR.h

@@ -493,14 +493,14 @@ private:
     /// Add function arguments
     inline void addFunArgs(const SVFFunction* fun, const SVFVar* arg)
     {
-        FunEntryICFGNode* funEntryBlockNode = icfg->getFunEntryBlockNode(fun);
+        FunEntryICFGNode* funEntryBlockNode = icfg->getFunEntryICFGNode(fun);
         funEntryBlockNode->addFormalParms(arg);
         funArgsListMap[fun].push_back(arg);
     }
     /// Add function returns
     inline void addFunRet(const SVFFunction* fun, const SVFVar* ret)
     {
-        FunExitICFGNode* funExitBlockNode = icfg->getFunExitBlockNode(fun);
+        FunExitICFGNode* funExitBlockNode = icfg->getFunExitICFGNode(fun);
         funExitBlockNode->addFormalRet(ret);
         funRetMap[fun] = ret;
     }

package/include/SVF-FE/ICFGBuilder.h

@@ -84,20 +84,20 @@ private:
     void addICFGInterEdges(const Instruction*  cs, const SVFFunction*  callee);
 
     /// Add a call node
-    inline CallICFGNode* getOrAddCallICFGNode(const Instruction*  cs)
+    inline CallICFGNode* getCallICFGNode(const Instruction*  cs)
     {
-        return icfg->getCallBlockNode(cs);
+        return icfg->getCallICFGNode(cs);
     }
     /// Add a return node
-    inline RetICFGNode* getOrAddRetICFGNode(const Instruction*  cs)
+    inline RetICFGNode* getRetICFGNode(const Instruction*  cs)
     {
-        return icfg->getRetBlockNode(cs);
+        return icfg->getRetICFGNode(cs);
     }
 
     /// Add and get IntraBlock ICFGNode
     IntraICFGNode* getOrAddIntraBlockICFGNode(const Instruction* inst)
     {
-        return icfg->getIntraBlockNode(inst);
+        return icfg->getIntraICFGNode(inst);
     }
 };
 

package/include/SVF-FE/SVFIRBuilder.h

@@ -348,7 +348,7 @@ public:
     {
         IntraICFGNode* node;
         if(const Instruction* inst = SVFUtil::dyn_cast<Instruction>(curVal))
-            node = pag->getICFG()->getIntraBlockNode(inst);
+            node = pag->getICFG()->getIntraICFGNode(inst);
         else
             node = nullptr;
         StoreStmt *edge = pag->addStoreStmt(src, dst, node);

package/lib/Graphs/ICFG.cpp

@@ -190,69 +190,69 @@ ICFG::ICFG(): totalICFGNode(0)
 
 
 /// Get a basic block ICFGNode
-ICFGNode* ICFG::getBlockICFGNode(const Instruction* inst)
+ICFGNode* ICFG::getICFGNode(const Instruction* inst)
 {
     ICFGNode* node;
     if(SVFUtil::isNonInstricCallSite(inst))
-        node = getCallBlockNode(inst);
+        node = getCallICFGNode(inst);
     else if(SVFUtil::isIntrinsicInst(inst))
-        node = getIntraBlockNode(inst);
+        node = getIntraICFGNode(inst);
 //			assert (false && "associating an intrinsic instruction with an ICFGNode!");
     else
-        node = getIntraBlockNode(inst);
+        node = getIntraICFGNode(inst);
 
     assert (node!=nullptr && "no ICFGNode for this instruction?");
     return node;
 }
 
 
-CallICFGNode* ICFG::getCallBlockNode(const Instruction* inst)
+CallICFGNode* ICFG::getCallICFGNode(const Instruction* inst)
 {
 	if(SVFUtil::isCallSite(inst) ==false)
 		outs() << *inst << "\n";
     assert(SVFUtil::isCallSite(inst) && "not a call instruction?");
     assert(SVFUtil::isNonInstricCallSite(inst) && "associating an intrinsic debug instruction with an ICFGNode!");
-    CallICFGNode* node = getCallICFGNode(inst);
+    CallICFGNode* node = getCallBlock(inst);
     if(node==nullptr)
-        node = addCallICFGNode(inst);
+        node = addCallBlock(inst);
     assert (node!=nullptr && "no CallICFGNode for this instruction?");
     return node;
 }
 
-RetICFGNode* ICFG::getRetBlockNode(const Instruction* inst)
+RetICFGNode* ICFG::getRetICFGNode(const Instruction* inst)
 {
     assert(SVFUtil::isCallSite(inst) && "not a call instruction?");
     assert(SVFUtil::isNonInstricCallSite(inst) && "associating an intrinsic debug instruction with an ICFGNode!");
-    RetICFGNode* node = getRetICFGNode(inst);
+    RetICFGNode* node = getRetBlock(inst);
     if(node==nullptr)
-        node = addRetICFGNode(inst);
+        node = addRetBlock(inst);
     assert (node!=nullptr && "no RetICFGNode for this instruction?");
     return node;
 }
 
-IntraICFGNode* ICFG::getIntraBlockNode(const Instruction* inst)
+IntraICFGNode* ICFG::getIntraICFGNode(const Instruction* inst)
 {
-    IntraICFGNode* node = getIntraBlockICFGNode(inst);
+    IntraICFGNode* node = getIntraBlock(inst);
     if(node==nullptr)
-        node = addIntraBlockICFGNode(inst);
+        node = addIntraBlock(inst);
     return node;
 }
 
 /// Add a function entry node
-FunEntryICFGNode* ICFG::getFunEntryBlockNode(const SVFFunction*  fun)
+FunEntryICFGNode* ICFG::getFunEntryICFGNode(const SVFFunction*  fun)
 {
-    FunEntryICFGNode* b = getFunEntryICFGNode(fun);
+    FunEntryICFGNode* b = getFunEntryBlock(fun);
     if (b == nullptr)
-        return addFunEntryICFGNode(fun);
+        return addFunEntryBlock(fun);
     else
         return b;
 }
 /// Add a function exit node
-FunExitICFGNode* ICFG::getFunExitBlockNode(const SVFFunction*  fun)
+FunExitICFGNode* ICFG::getFunExitICFGNode(const SVFFunction*  fun)
 {
-    FunExitICFGNode* b = getFunExitICFGNode(fun);
+    FunExitICFGNode* b = getFunExitBlock(fun);
     if (b == nullptr)
-        return addFunExitICFGNode(fun);
+        return addFunExitBlock(fun);
     else
         return b;
 }
@@ -436,10 +436,10 @@ void ICFG::updateCallGraph(PTACallGraph* callgraph)
         for (PTACallGraph::FunctionSet::const_iterator func_iter = functions.begin(); func_iter != functions.end(); func_iter++)
         {
             const SVFFunction*  callee = *func_iter;
-            CallICFGNode* callBlockNode = getCallBlockNode(cs);
-            RetICFGNode* retBlockNode = getRetBlockNode(cs);
-            FunEntryICFGNode* calleeEntryNode = getFunEntryICFGNode(callee);
-            FunExitICFGNode* calleeExitNode = getFunExitICFGNode(callee);
+            CallICFGNode* callBlockNode = getCallICFGNode(cs);
+            RetICFGNode* retBlockNode = getRetICFGNode(cs);
+            FunEntryICFGNode* calleeEntryNode = getFunEntryBlock(callee);
+            FunExitICFGNode* calleeExitNode = getFunExitBlock(callee);
             addCallEdge(callBlockNode, calleeEntryNode, cs);
             addRetEdge(calleeExitNode, retBlockNode, cs);
 

package/lib/Graphs/SVFG.cpp

@@ -242,7 +242,7 @@ void SVFG::addSVFGNodesForAddrTakenVars()
     {
         for(PHISet::iterator pi = it->second.begin(), epi = it->second.end(); pi!=epi; ++pi){
             MemSSA::PHI* phi =  *pi;
-            addIntraMSSAPHISVFGNode(pag->getICFG()->getBlockICFGNode(&(phi->getBasicBlock()->front())), phi->opVerBegin(), phi->opVerEnd(),phi->getResVer(), totalVFGNode++);
+            addIntraMSSAPHISVFGNode(pag->getICFG()->getICFGNode(&(phi->getBasicBlock()->front())), phi->opVerBegin(), phi->opVerEnd(),phi->getResVer(), totalVFGNode++);
         }
     }
     /// initialize memory SSA entry chi nodes
@@ -251,7 +251,7 @@ void SVFG::addSVFGNodesForAddrTakenVars()
     {
         for(CHISet::iterator pi = it->second.begin(), epi = it->second.end(); pi!=epi; ++pi){
             const MemSSA::ENTRYCHI* chi = SVFUtil::cast<ENTRYCHI>(*pi);
-            addFormalINSVFGNode(pag->getICFG()->getFunEntryBlockNode(chi->getFunction()), chi->getResVer(), totalVFGNode++);
+            addFormalINSVFGNode(pag->getICFG()->getFunEntryICFGNode(chi->getFunction()), chi->getResVer(), totalVFGNode++);
         }
     }
     /// initialize memory SSA return mu nodes
@@ -260,7 +260,7 @@ void SVFG::addSVFGNodesForAddrTakenVars()
     {
         for(MUSet::iterator pi = it->second.begin(), epi = it->second.end(); pi!=epi; ++pi){
               const MemSSA::RETMU* mu = SVFUtil::cast<RETMU>(*pi);
-              addFormalOUTSVFGNode(pag->getICFG()->getFunExitBlockNode(mu->getFunction()), mu->getMRVer(), totalVFGNode++);
+              addFormalOUTSVFGNode(pag->getICFG()->getFunExitICFGNode(mu->getFunction()), mu->getMRVer(), totalVFGNode++);
         }
     }
     /// initialize memory SSA callsite mu nodes
@@ -567,7 +567,7 @@ std::set<const SVFGNode*> SVFG::fromValue(const llvm::Value* value) const
 void SVFG::getInterVFEdgesForIndirectCallSite(const CallICFGNode* callBlockNode, const SVFFunction* callee, SVFGEdgeSetTy& edges)
 {
     CallSiteID csId = getCallSiteID(callBlockNode, callee);
-    RetICFGNode* retBlockNode = pag->getICFG()->getRetBlockNode(callBlockNode->getCallSite());
+    RetICFGNode* retBlockNode = pag->getICFG()->getRetICFGNode(callBlockNode->getCallSite());
 
     // Find inter direct call edges between actual param and formal param.
     if (pag->hasCallSiteArgsMap(callBlockNode) && pag->hasFunArgsList(callee))

package/lib/Graphs/VFG.cpp

@@ -407,7 +407,7 @@ void VFG::addVFGNodes()
         if(isInterestedPAGNode(it->second) == false || hasDef(it->second))
             continue;
 
-        addActualRetVFGNode(it->second,it->first->getCallBlockNode());
+        addActualRetVFGNode(it->second,it->first->getCallICFGNode());
     }
 
     // initialize formal parameter nodes
@@ -674,7 +674,7 @@ void VFG::connectDirectVFGEdges()
             {
                 ActualRetVFGNode* callsiteRev = getActualRetVFGNode((*it)->getLHSVar());
                 const CallICFGNode* retBlockNode = (*it)->getCallSite();
-                CallICFGNode* callBlockNode = pag->getICFG()->getCallBlockNode(retBlockNode->getCallSite());
+                CallICFGNode* callBlockNode = pag->getICFG()->getCallICFGNode(retBlockNode->getCallSite());
                 addInterEdgeFromFRToAR(calleeRet,callsiteRev, getCallSiteID(callBlockNode, calleeRet->getFun()));
             }
         }
@@ -813,7 +813,7 @@ void VFG::connectCallerAndCallee(const CallICFGNode* callBlockNode, const SVFFun
     SVFIR * pag = SVFIR::getPAG();
     ICFG * icfg = pag->getICFG();
     CallSiteID csId = getCallSiteID(callBlockNode, callee);
-    RetICFGNode* retBlockNode = icfg->getRetBlockNode(callBlockNode->getCallSite());
+    RetICFGNode* retBlockNode = icfg->getRetICFGNode(callBlockNode->getCallSite());
     // connect actual and formal param
     if (pag->hasCallSiteArgsMap(callBlockNode) && pag->hasFunArgsList(callee))
     {

package/lib/MSSA/MemRegion.cpp

@@ -152,18 +152,18 @@ bool MRGenerator::hasSVFStmtList(const Instruction* inst)
 {
     SVFIR* pag = pta->getPAG();
     if (ptrOnlyMSSA)
-        return pag->hasPTASVFStmtList(pag->getICFG()->getBlockICFGNode(inst));
+        return pag->hasPTASVFStmtList(pag->getICFG()->getICFGNode(inst));
     else
-        return pag->hasSVFStmtList(pag->getICFG()->getBlockICFGNode(inst));
+        return pag->hasSVFStmtList(pag->getICFG()->getICFGNode(inst));
 }
 
 SVFIR::SVFStmtList& MRGenerator::getPAGEdgesFromInst(const Instruction* inst)
 {
     SVFIR* pag = pta->getPAG();
     if (ptrOnlyMSSA)
-        return pag->getPTASVFStmtList(pag->getICFG()->getBlockICFGNode(inst));
+        return pag->getPTASVFStmtList(pag->getICFG()->getICFGNode(inst));
     else
-        return pag->getSVFStmtList(pag->getICFG()->getBlockICFGNode(inst));
+        return pag->getSVFStmtList(pag->getICFG()->getICFGNode(inst));
 }
 
 /*!
@@ -259,7 +259,7 @@ void MRGenerator::collectModRefForCall()
 
     for (CallSite cs : SymbolTableInfo::SymbolInfo()->getCallSiteSet())
     {
-        const CallICFGNode* callBlockNode = pta->getPAG()->getICFG()->getCallBlockNode(cs.getInstruction());
+        const CallICFGNode* callBlockNode = pta->getPAG()->getICFG()->getCallICFGNode(cs.getInstruction());
         if(hasRefSideEffectOfCallSite(callBlockNode))
         {
             NodeBS refs = getRefSideEffectOfCallSite(callBlockNode);
@@ -481,8 +481,8 @@ void MRGenerator::collectCallSitePts(const CallICFGNode* cs)
     /// collect the pts chain of the callsite arguments
     NodeBS& argsPts = csToCallSiteArgsPtsMap[cs];
     SVFIR* pag = pta->getPAG();
-    CallICFGNode* callBlockNode = pag->getICFG()->getCallBlockNode(cs->getCallSite());
-    RetICFGNode* retBlockNode = pag->getICFG()->getRetBlockNode(cs->getCallSite());
+    CallICFGNode* callBlockNode = pag->getICFG()->getCallICFGNode(cs->getCallSite());
+    RetICFGNode* retBlockNode = pag->getICFG()->getRetICFGNode(cs->getCallSite());
 
     WorkList worklist;
     if (pag->hasCallSiteArgsMap(callBlockNode))

package/lib/MSSA/MemSSA.cpp

@@ -174,7 +174,7 @@ void MemSSA::createMUCHI(const SVFFunction& fun)
             }
             if (isNonInstricCallSite(inst))
             {
-                const CallICFGNode* cs = pag->getICFG()->getCallBlockNode(inst);
+                const CallICFGNode* cs = pag->getICFG()->getCallICFGNode(inst);
                 if(mrGen->hasRefMRSet(cs))
                     AddCallSiteMU(cs,mrGen->getCallSiteRefMRSet(cs));
 
@@ -318,7 +318,7 @@ void MemSSA::SSARenameBB(const BasicBlock& bb)
         }
         if (isNonInstricCallSite(inst))
         {
-            const CallICFGNode* cs = pag->getICFG()->getCallBlockNode(inst);
+            const CallICFGNode* cs = pag->getICFG()->getCallICFGNode(inst);
             if(mrGen->hasRefMRSet(cs))
                 RenameMuSet(getMUSet(cs));
 
@@ -634,7 +634,7 @@ void MemSSA::dumpMSSA(raw_ostream& Out)
                 bool isAppCall = isNonInstricCallSite(&inst) && !isExtCall(&inst);
                 if (isAppCall || isHeapAllocExtCall(&inst))
                 {
-                    const CallICFGNode* cs = pag->getICFG()->getCallBlockNode(&inst);
+                    const CallICFGNode* cs = pag->getICFG()->getCallICFGNode(&inst);
                     if(hasMU(cs))
                     {
                         if (!last_is_chi)

package/lib/MTA/LockAnalysis.cpp

@@ -406,7 +406,7 @@ void LockAnalysis::handleFork(const CxtStmt& cts)
 {
     const CallInst* call = SVFUtil::cast<CallInst>(cts.getStmt());
     const CallStrCxt& curCxt = cts.getContext();
-	CallICFGNode* cbn = tct->getCallBlockNode(call);
+	CallICFGNode* cbn = tct->getCallICFGNode(call);
     if(getTCG()->hasThreadForkEdge(cbn))
     {
         for (ThreadCallGraph::ForkEdgeSet::const_iterator cgIt = getTCG()->getForkEdgeBegin(cbn),
@@ -429,7 +429,7 @@ void LockAnalysis::handleCall(const CxtStmt& cts)
 
     const CallInst* call = SVFUtil::cast<CallInst>(cts.getStmt());
     const CallStrCxt& curCxt = cts.getContext();
-	CallICFGNode* cbn = tct->getCallBlockNode(call);
+	CallICFGNode* cbn = tct->getCallICFGNode(call);
     if (getTCG()->hasCallGraphEdge(cbn))
     {
         for (PTACallGraph::CallGraphEdgeSet::const_iterator cgIt = getTCG()->getCallEdgeBegin(cbn), ecgIt = getTCG()->getCallEdgeEnd(cbn);
@@ -518,7 +518,7 @@ void LockAnalysis::pushCxt(CallStrCxt& cxt, const Instruction* call, const Funct
     const Function* caller = call->getParent()->getParent();
     const SVFFunction* svfcallee = tct->getSVFFun(callee);
     const SVFFunction* svfcaller = tct->getSVFFun(caller);
-    CallICFGNode* cbn = tct->getCallBlockNode(call);
+    CallICFGNode* cbn = tct->getCallICFGNode(call);
     CallSiteID csId = getTCG()->getCallSiteID(cbn, svfcallee);
 	
 //    /// handle calling context for candidate functions only
@@ -537,7 +537,7 @@ bool LockAnalysis::matchCxt(CallStrCxt& cxt, const Instruction* call, const Func
     const Function* caller = call->getParent()->getParent();
     const SVFFunction* svfcallee = tct->getSVFFun(callee);
     const SVFFunction* svfcaller = tct->getSVFFun(caller);
-    CallICFGNode* cbn = tct->getCallBlockNode(call);
+    CallICFGNode* cbn = tct->getCallICFGNode(call);
     CallSiteID csId = getTCG()->getCallSiteID(cbn, svfcallee);
 
 //    /// handle calling context for candidate functions only

package/lib/MTA/MTAResultValidator.cpp

@@ -96,7 +96,7 @@ CallStrCxt MTAResultValidator::getCxtArg(const Instruction* inst, unsigned int a
         const SVFFunction* callee = SVFUtil::getFunction(y[1]);
         CallSite cs = SVFUtil::getLLVMCallSite(csnumToInstMap[atoi(y[0].c_str())]);
         assert(callee && "callee error");
-        CallICFGNode* cbn = mhp->getTCT()->getCallBlockNode(cs.getInstruction());
+        CallICFGNode* cbn = mhp->getTCT()->getCallICFGNode(cs.getInstruction());
         CallSiteID csId = tcg->getCallSiteID(cbn, callee);
         cxt.push_back(csId);
     }

package/lib/MTA/PCG.cpp

@@ -206,7 +206,7 @@ void PCG::identifyFollowers()
                 // if this is an call/invoke instruction but not a spawn site
                 if ((SVFUtil::isa<CallInst>(inst) || SVFUtil::isa<InvokeInst>(inst)) && !isSpawnsite(inst))
                 {
-                	CallICFGNode* cbn = getCallBlockNode(inst);
+                	CallICFGNode* cbn = getCallICFGNode(inst);
                     if (callgraph->hasCallGraphEdge(cbn))
                     {
                         for (PTACallGraph::CallGraphEdgeSet::const_iterator cgIt = callgraph->getCallEdgeBegin(cbn),