svf-tools 1.0.355 → 1.0.359

package/include/Graphs/VFG.h

@@ -408,13 +408,13 @@ protected:
         }
         else
         {
-            assert((it->second == node->getId()) && "a SVFIR node can only have unique definition ");
+            assert((it->second == node->getId()) && "a SVFVar can only have unique definition ");
         }
     }
     inline NodeID getDef(const PAGNode* pagNode) const
     {
         PAGNodeToDefMapTy::const_iterator it = PAGNodeToDefMap.find(pagNode);
-        assert(it!=PAGNodeToDefMap.end() && "SVFIR node does not have a definition??");
+        assert(it!=PAGNodeToDefMap.end() && "SVFVar does not have a definition??");
         return it->second;
     }
     inline bool hasDef(const PAGNode* pagNode) const
@@ -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/MemoryModel/SymbolTableInfo.h

@@ -344,18 +344,7 @@ public:
     /// Get struct info
     //@{
     ///Get an iterator for StructInfo, designed as internal methods
-    TypeToFieldInfoMap::iterator getStructInfoIter(const Type *T)
-    {
-        assert(T);
-        TypeToFieldInfoMap::iterator it = typeToFieldInfo.find(T);
-        if (it != typeToFieldInfo.end())
-            return it;
-        else
-        {
-            collectTypeInfo(T);
-            return typeToFieldInfo.find(T);
-        }
-    }
+    TypeToFieldInfoMap::iterator getStructInfoIter(const Type *T);
 
     ///Get a reference to StructInfo.
     inline StInfo* getStructInfo(const Type *T)
@@ -364,8 +353,12 @@ public:
     }
 
     ///Get a reference to the components of struct_info.
-    /// Flatterned full offset information of a struct including its array fields 
-    const std::vector<u32_t>& getFlattenedOffsetVec(const StructType *T);
+    /// Number of flattenned elements of an array or struct
+    const u32_t getNumOfFlattenElements(const Type *T);
+    /// Number of flattenned fields of a struct
+    const u32_t getNumOfFlattenFields(const StructType *T);
+    /// Flatterned element idx of an array or struct by considering stride
+    const std::vector<u32_t>& getFlattenedElemIdxVec(const Type *T);
     /// Flatterned field index information of a struct ignoring any array field
     const std::vector<u32_t>& getFlattenedFieldIdxVec(const StructType *T);
 
@@ -513,14 +506,18 @@ class StInfo
 private:
     /// flattened field indices of a struct (ignoring arrays)
     std::vector<u32_t> fldIdxVec;
-    /// flattened full offset (including array strides)
-    std::vector<u32_t> fullOffsetVec;
+    /// flattened element indices including structs and arrays by considering strides
+    std::vector<u32_t> elemIdxVec;
     /// Types of all fields of a struct
     Map<u32_t, const Type*> fldIdx2TypeMap;
     /// All field infos after flattening a struct
     std::vector<FlattenedFieldInfo> finfo;
     /// stride represents the number of repetitive elements if this StInfo represent an ArrayType. stride is 1 by default.
     u32_t stride; 
+    /// number of elements after flattenning (including array elements)
+    u32_t numOfFlattenElements; 
+    /// number of fields after flattenning (ignoring array elements)
+    u32_t numOfFlattenFields; 
     /// Max field limit
     static u32_t maxFieldLimit;
 
@@ -530,7 +527,7 @@ private:
 
 public:
     /// Constructor
-    StInfo(u32_t s) : stride(s)
+    StInfo(u32_t s) : stride(s), numOfFlattenElements(s), numOfFlattenFields(s)
     {
     }
     /// Destructor
@@ -552,28 +549,16 @@ public:
     ///  OriginalFieldType of b with field_idx 1 : Struct A
     ///  FlatternedFieldType of b with field_idx 1 : int
     //{@
-    inline const Type* getOriginalFieldType(u32_t fldIdx)
-    {
-        Map<u32_t, const Type*>::const_iterator it = fldIdx2TypeMap.find(fldIdx);
-        if(it!=fldIdx2TypeMap.end())
-            return it->second;
-        return nullptr;
-    }
-    inline const Type* getFlatternedFieldType(u32_t fldIdx)
-    {
-        for(FlattenedFieldInfo& fallenedFld : finfo){
-            if(fallenedFld.getFlattenFldIdx() == fldIdx)
-                return fallenedFld.getFlattenElemTy();
-        }
-        return nullptr;
-    }
+    const Type* getOriginalFieldType(u32_t fldIdx);
+    const Type* getFlatternedFieldType(u32_t fldIdx);
+
     inline std::vector<u32_t>& getFlattenedFieldIdxVec()
     {
         return fldIdxVec;
     }
-    inline std::vector<u32_t>& getFlattenedOffsetVec()
+    inline std::vector<u32_t>& getFlattenedElemIdxVec()
     {
-        return fullOffsetVec;
+        return elemIdxVec;
     }
     inline std::vector<FlattenedFieldInfo>& getFlattenedFieldInfoVec()
     {
@@ -581,16 +566,27 @@ public:
     }
     //@}
 
-    /// Add field (index and offset) with its corresponding type
-    inline void addFldWithType(u32_t fldIdx, const Type* type, u32_t fullOffset)
+    /// Add field index and element index and their corresponding type
+    void addFldWithType(u32_t fldIdx, const Type* type, u32_t elemIdx);
+
+    /// Set number of fields and elements of an aggrate
+    inline void setNumOfFieldsAndElems(u32_t nf, u32_t ne)
     {
-        fldIdxVec.push_back(fldIdx);
-        fullOffsetVec.push_back(fullOffset);
-        fldIdx2TypeMap[fldIdx] = type;
+        numOfFlattenFields = nf;
+        numOfFlattenElements = ne;
     }
 
-    /// Array Type can have 
-    inline u32_t getStride() const {
+    /// Return number of elements after flattenning (including array elements)
+    inline u32_t getNumOfFlattenElements() const {
+        return numOfFlattenElements;
+    }
+
+    /// Return the number of fields after flattenning (ignoring array elements)
+    inline u32_t getNumOfFlattenFields() const {
+        return numOfFlattenFields;
+    }
+    /// Return the stride
+    inline u32_t getStride() const{
         return stride;
     }
 };

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),

package/lib/MTA/TCT.cpp

@@ -476,7 +476,7 @@ void TCT::pushCxt(CallStrCxt& cxt, const Instruction* call, const Function* call
     const Function* caller = call->getParent()->getParent();
     const SVFFunction* svfcaller = getSVFFun(caller);
     const SVFFunction* svfcallee = getSVFFun(callee);
-    CallSiteID csId = tcg->getCallSiteID(getCallBlockNode(call), svfcallee);
+    CallSiteID csId = tcg->getCallSiteID(getCallICFGNode(call), svfcallee);
 
     /// handle calling context for candidate functions only
     if(isCandidateFun(caller) == false)
@@ -498,7 +498,7 @@ bool TCT::matchCxt(CallStrCxt& cxt, const Instruction* call, const Function* cal
 
     const Function* caller = call->getParent()->getParent();
     const SVFFunction* svfcallee = getSVFFun(callee);
-    CallSiteID csId = tcg->getCallSiteID(getCallBlockNode(call), svfcallee);
+    CallSiteID csId = tcg->getCallSiteID(getCallICFGNode(call), svfcallee);
 
     /// handle calling context for candidate functions only
     if(isCandidateFun(caller) == false)