svf-tools 1.0.355 → 1.0.359

package/lib/MemoryModel/LocationSet.cpp

@@ -56,71 +56,76 @@ bool LocationSet::isConstantOffset() const
 }
 
 /// Return element number of a type
-/// (1) StructType, return flatterned number elements, i.e., the index of the last element (getFlattenedOffsetVec().back()) plus one.
-/// (2) ArrayType, return number of elements
-/// (3) PointerType, return the element number of the pointee 
-/// (4) non-pointer SingleValueType, return 1
+/// (1) StructType or Array, return flatterned number elements.
+/// (2) PointerType, return the element number of the pointee 
+/// (3) non-pointer SingleValueType, return 1
 u32_t LocationSet::getElementNum(const Type* type) const{
-    u32_t sz = 1;
-    if(const ArrayType* aty = SVFUtil::dyn_cast<ArrayType>(type))
-    {
-        /// handle nested arrays
-        const Type* innerTy = aty;
-        while (const ArrayType* arr = SVFUtil::dyn_cast<ArrayType>(innerTy))
-        {
-            sz *= arr->getNumElements();
-            innerTy = arr->getElementType();
-        }
-    }
-    else if (const StructType *sty = SVFUtil::dyn_cast<StructType>(type) )
+
+    if(SVFUtil::isa<ArrayType>(type) || SVFUtil::isa<StructType>(type))
     {
-        const vector<u32_t> &so = SymbolTableInfo::SymbolInfo()->getFlattenedOffsetVec(sty);
-        sz = so.back() + 1;
+        return SymbolTableInfo::SymbolInfo()->getNumOfFlattenElements(type);
     }
     else if (type->isSingleValueType())
     {
         /// This is a pointer arithmic
-        if(const PointerType* pty = SVFUtil::dyn_cast<PointerType>(type) ){
-            sz = getElementNum(pty->getElementType());
-        }
+        if(const PointerType* pty = SVFUtil::dyn_cast<PointerType>(type))
+            return getElementNum(pty->getElementType());
+        else
+            return 1;
     }
     else{
         SVFUtil::outs() << "GepIter Type" << *type << "\n";
         assert(false && "What other types for this gep?");
+        abort();
     }
-    return sz;
 }
 
 /// Return accumulated constant offset
 /// 
 /// "value" is the offset variable (must be a constant)
 /// "type" is the location where we want to compute offset
-/// e.g., %3 = getelementptr inbounds [10 x i32], [10 x i32]* %1, i64 0, i64 5 
-/// offsetValues[0] value: i64 0, type: [10 x i32]*
-/// offsetValues[1] value: i64 5, type: [10 x i32]
-/// 
-/// Given a vector: [(v1,t1), (v2,t2), (v3,t3)]
-/// totalConstOffset = v1 * sz(t2) + v2 * sz(t3) + v3 * 1
-/// If the vector only has one element (one gep operand), then it must be a pointer arithmetic and type must be a PointerType
-/// totalConstOffset = v1 * sz(t1) 
+/// Given a vector: [(value1,type1), (value2,type2), (value3,type3)]
+/// totalConstOffset = flattenOffset(value1,type1) * flattenOffset(type2,type2) + flattenOffset(type3,type3)
+/// For a pointer type (e.g., t1 is PointerType), we will retrieve the pointee type and times the offset, i.e., getElementNum(t1) X off1
+
+/// For example,
+// struct inner{ int rollNumber; float percentage;};
+// struct Student { struct inner rollNumber; char studentName[10][3];}
+// char x = studentRecord[1].studentName[3][2];
+
+/// %5 = getelementptr inbounds %struct.Student, %struct.Student* %4, i64 1
+///     value1: i64 1 type1: %struct.Student*  
+///     accumulateConstantOffset = 32
+/// %6 = getelementptr inbounds %struct.Student, %struct.Student* %5, i32 0, i32 1 
+///     value1: i32 0  type1: %struct.Student* 
+///     value2: i32 1  type2: %struct.Student = type { %struct.inner, [10 x [3 x i8]] }  
+///     accumulateConstantOffset = 2
+/// %7 = getelementptr inbounds [10 x [3 x i8]], [10 x [3 x i8]]* %6, i64 0, i64 3 
+///     value1: i64 0  type1: [10 x [3 x i8]]*
+///     value2: i64 3  type2: [10 x [3 x i8]]       
+///     accumulateConstantOffset = 9
+/// %8 = getelementptr inbounds [3 x i8], [3 x i8]* %7, i64 0, i64 2 
+///     value1: i64 0  type1: [3 x i8]*
+///     value2: i64 2  type2: [3 x i8]
+///     accumulateConstantOffset = 2
 s64_t LocationSet::accumulateConstantOffset() const{
     
     assert(isConstantOffset() && "not a constant offset");
 
     s64_t totalConstOffset = 0;
-    u32_t sz = 1;
     for(int i = offsetValues.size() - 1; i >= 0; i--){
         const Value* value = offsetValues[i].first;
         const Type* type = offsetValues[i].second;
         const ConstantInt *op = SVFUtil::dyn_cast<ConstantInt>(value);
         assert(op && "not a constant offset?");
-        /// if this gep only has one operand, the gepIterType must be the pointer type, and we will need to retrieve size of its elementType.
-        if(offsetValues.size()==1){
-            assert(SVFUtil::isa<PointerType>(type) && "If gep has only one operand, its gepIterType must be PointerType!");
-            sz = getElementNum(type);
+        if(const PointerType* pty = SVFUtil::dyn_cast<PointerType>(type))
+            totalConstOffset += op->getSExtValue() * getElementNum(pty->getElementType());
+        else{
+            s64_t offset = op->getSExtValue();
+            const std::vector<u32_t>& so = SymbolTableInfo::SymbolInfo()->getFlattenedElemIdxVec(type); 
+            assert((u32_t)offset <= so.size() && "out of bounds or offset is a negative value?");
+            totalConstOffset += so[op->getSExtValue()];
         }
-        totalConstOffset += op->getSExtValue() * sz; 
-        sz *= getElementNum(type);
     }
     return totalConstOffset;
 }

package/lib/MemoryModel/PointerAnalysis.cpp

@@ -515,7 +515,7 @@ void PointerAnalysis::connectVCallToVFns(const CallICFGNode* cs, const VFunSet &
         {
             newEdges[cs].insert(callee);
             getIndCallMap()[cs].insert(callee);
-            const CallICFGNode* callBlockNode = pag->getICFG()->getCallBlockNode(cs->getCallSite());
+            const CallICFGNode* callBlockNode = pag->getICFG()->getCallICFGNode(cs->getCallSite());
             ptaCallGraph->addIndirectCallGraphEdge(callBlockNode, cs->getCaller(),callee);
         }
     }

package/lib/MemoryModel/SymbolTableInfo.cpp

@@ -43,6 +43,48 @@ DataLayout* SymbolTableInfo::dl = nullptr;
 SymbolTableInfo* SymbolTableInfo::symInfo = nullptr;
 u32_t StInfo::maxFieldLimit = 0;
 
+
+/// Add field (index and offset) with its corresponding type
+void StInfo::addFldWithType(u32_t fldIdx, const Type* type, u32_t elemIdx)
+{
+    fldIdxVec.push_back(fldIdx);
+    elemIdxVec.push_back(elemIdx);
+    fldIdx2TypeMap[fldIdx] = type;
+}
+
+///  struct A { int id; int salary; }; struct B { char name[20]; struct A a;}   B b;
+///  OriginalFieldType of b with field_idx 1 : Struct A
+///  FlatternedFieldType of b with field_idx 1 : int
+//{@
+const Type* StInfo::getOriginalFieldType(u32_t fldIdx)
+{
+    Map<u32_t, const Type*>::const_iterator it = fldIdx2TypeMap.find(fldIdx);
+    if(it!=fldIdx2TypeMap.end())
+        return it->second;
+    return nullptr;
+}
+const Type* StInfo::getFlatternedFieldType(u32_t fldIdx)
+{
+    for(FlattenedFieldInfo& fallenedFld : finfo){
+        if(fallenedFld.getFlattenFldIdx() == fldIdx)
+            return fallenedFld.getFlattenElemTy();
+    }
+    return nullptr;
+}
+
+SymbolTableInfo::TypeToFieldInfoMap::iterator SymbolTableInfo::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);
+    }
+}
+
 /*
  * Initial the memory object here (for a dummy object)
  */
@@ -87,20 +129,17 @@ void SymbolTableInfo::collectTypeInfo(const Type* ty)
  */
 void SymbolTableInfo::collectArrayInfo(const ArrayType* ty)
 {
-    u64_t out_num = ty->getNumElements();
+    u64_t totalElemNum = ty->getNumElements();
     const Type* elemTy = ty->getElementType();
     while (const ArrayType* aty = SVFUtil::dyn_cast<ArrayType>(elemTy))
     {
-        out_num *= aty->getNumElements();
+        totalElemNum *= aty->getNumElements();
         elemTy = aty->getElementType();
     }
     
-    StInfo* stinfo = new StInfo(out_num);
+    StInfo* stinfo = new StInfo(totalElemNum);
     typeToFieldInfo[ty] = stinfo;
 
-    /// Array itself only has one field which is the inner most element
-    stinfo->addFldWithType(0, elemTy, 0);
-
     /// Array's flatten field infor is the same as its element's
     /// flatten infor.
     StInfo* elemStInfo = getStructInfo(elemTy);
@@ -112,6 +151,14 @@ void SymbolTableInfo::collectArrayInfo(const ArrayType* ty)
         FlattenedFieldInfo field(idx, fieldTy);
         stinfo->getFlattenedFieldInfoVec().push_back(field);
     }
+
+    /// Flatten arrays, map each array element index `i` to flattened index `(i * nfE * totalElemNum)/outArrayElemNum`
+    /// nfE>1 if the array element is a struct with more than one field.
+    u32_t outArrayElemNum = ty->getNumElements();
+    for(u32_t i = 0; i < outArrayElemNum; i++)
+        stinfo->addFldWithType(0, elemTy, (i * nfE * totalElemNum)/outArrayElemNum);
+
+    stinfo->setNumOfFieldsAndElems(nfE, nfE * totalElemNum);
 }
 
 
@@ -160,6 +207,8 @@ void SymbolTableInfo::collectStructInfo(const StructType *sty)
         }
     }
 
+    stinfo->setNumOfFieldsAndElems(nf,strideOffset);
+
     //Record the size of the complete struct and update max_struct.
     if (nf > maxStSize)
     {
@@ -182,6 +231,8 @@ void SymbolTableInfo::collectSimpleTypeInfo(const Type* ty)
 
     FlattenedFieldInfo field(0, ty);
     stinfo->getFlattenedFieldInfoVec().push_back(field);
+
+    stinfo->setNumOfFieldsAndElems(1,1);
 }
 
 
@@ -322,10 +373,22 @@ const MemObj* SymbolTableInfo::createDummyObj(SymID symId, const Type* type)
     return memObj;
 }
 
+/// Number of flattenned elements of an array or struct
+const u32_t SymbolTableInfo::getNumOfFlattenElements(const Type *T)
+{
+    return getStructInfoIter(T)->second->getNumOfFlattenElements();
+}
+
+/// Number of flattenned fields of a struct
+const u32_t SymbolTableInfo::getNumOfFlattenFields(const StructType *T)
+{
+    return getStructInfoIter(T)->second->getNumOfFlattenFields();
+}
+
 /// Flatterned full offset information of a struct including its array fields 
-const std::vector<u32_t>& SymbolTableInfo::getFlattenedOffsetVec(const StructType *T)
+const std::vector<u32_t>& SymbolTableInfo::getFlattenedElemIdxVec(const Type *T)
 {
-    return getStructInfoIter(T)->second->getFlattenedOffsetVec();
+    return getStructInfoIter(T)->second->getFlattenedElemIdxVec();
 }
 
 /// Flatterned field index information of a struct ignoring any array field

package/lib/SABER/LeakChecker.cpp

@@ -54,7 +54,7 @@ void LeakChecker::initSrcs()
             continue;
 
         PTACallGraph::FunctionSet callees;
-        getCallgraph()->getCallees(cs->getCallBlockNode(),callees);
+        getCallgraph()->getCallees(cs->getCallICFGNode(),callees);
         for(PTACallGraph::FunctionSet::const_iterator cit = callees.begin(), ecit = callees.end(); cit!=ecit; cit++)
         {
             const SVFFunction* fun = *cit;
@@ -62,11 +62,11 @@ void LeakChecker::initSrcs()
             {
                 CSWorkList worklist;
                 SVFGNodeBS visited;
-                worklist.push(it->first->getCallBlockNode());
+                worklist.push(it->first->getCallICFGNode());
                 while (!worklist.empty())
                 {
                     const CallICFGNode* cs = worklist.pop();
-                    const RetICFGNode* retBlockNode = icfg->getRetBlockNode(cs->getCallSite());
+                    const RetICFGNode* retBlockNode = icfg->getRetICFGNode(cs->getCallSite());
                     const PAGNode* pagNode = pag->getCallSiteRet(retBlockNode);
                     const SVFGNode* node = getSVFG()->getDefSVFGNode(pagNode);
                     if (visited.test(node->getId()) == 0)

package/lib/SVF-FE/CallGraphBuilder.cpp

@@ -55,7 +55,7 @@ PTACallGraph* CallGraphBuilder::buildCallGraph(SVFModule* svfModule)
             {
                 if(const SVFFunction* callee = getCallee(inst))
                 {
-                    const CallICFGNode* callBlockNode = icfg->getCallBlockNode(inst);
+                    const CallICFGNode* callBlockNode = icfg->getCallICFGNode(inst);
                     const SVFFunction* caller = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
                     callgraph->addDirectCallGraphEdge(callBlockNode,caller,callee);
                 }
@@ -83,7 +83,7 @@ PTACallGraph* ThreadCallGraphBuilder::buildThreadCallGraph(SVFModule* svfModule)
             const Instruction *inst = &*II;
             if (tdAPI->isTDFork(inst))
             {
-                const CallICFGNode* cs = icfg->getCallBlockNode(inst);
+                const CallICFGNode* cs = icfg->getCallICFGNode(inst);
                 cg->addForksite(cs);
                 const Function* forkee = SVFUtil::dyn_cast<Function>(tdAPI->getForkedFun(inst));
                 if (forkee)
@@ -98,7 +98,7 @@ PTACallGraph* ThreadCallGraphBuilder::buildThreadCallGraph(SVFModule* svfModule)
             }
             else if (tdAPI->isHareParFor(inst))
             {
-                const CallICFGNode* cs = icfg->getCallBlockNode(inst);
+                const CallICFGNode* cs = icfg->getCallICFGNode(inst);
                 cg->addParForSite(cs);
                 const Function* taskFunc = SVFUtil::dyn_cast<Function>(tdAPI->getTaskFuncAtHareParForSite(inst));
                 if (taskFunc)
@@ -122,7 +122,7 @@ PTACallGraph* ThreadCallGraphBuilder::buildThreadCallGraph(SVFModule* svfModule)
             const Instruction *inst = &*II;
             if (tdAPI->isTDJoin(inst))
             {
-                const CallICFGNode* cs = icfg->getCallBlockNode(inst);
+                const CallICFGNode* cs = icfg->getCallICFGNode(inst);
                 cg->addJoinsite(cs);
             }
         }

package/lib/SVF-FE/ICFGBuilder.cpp

@@ -58,7 +58,7 @@ void ICFGBuilder::build(SVFModule* svfModule)
  */
 void ICFGBuilder::processFunEntry(const SVFFunction*  fun, WorkList& worklist)
 {
-    FunEntryICFGNode* FunEntryICFGNode = icfg->getFunEntryBlockNode(fun);
+    FunEntryICFGNode* FunEntryICFGNode = icfg->getFunEntryICFGNode(fun);
     const Instruction* entryInst = &((fun->getLLVMFun()->getEntryBlock()).front());
     InstVec insts;
     if (isIntrinsicInst(entryInst))
@@ -92,7 +92,7 @@ void ICFGBuilder::processFunBody(WorkList& worklist)
             {
                 const Function* fun = inst->getFunction();
                 const SVFFunction* svfFun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
-                FunExitICFGNode* FunExitICFGNode = icfg->getFunExitBlockNode(svfFun);
+                FunExitICFGNode* FunExitICFGNode = icfg->getFunExitICFGNode(svfFun);
                 icfg->addIntraEdge(srcNode, FunExitICFGNode);
             }
             InstVec nextInsts;
@@ -105,7 +105,7 @@ void ICFGBuilder::processFunBody(WorkList& worklist)
                 ICFGNode* dstNode = getOrAddBlockICFGNode(succ);
                 if (isNonInstricCallSite(inst))
                 {
-                    RetICFGNode* retICFGNode = getOrAddRetICFGNode(inst);
+                    RetICFGNode* retICFGNode = getRetICFGNode(inst);
                     srcNode = retICFGNode;
                 }
 
@@ -138,7 +138,7 @@ void ICFGBuilder::processFunBody(WorkList& worklist)
  */
 void ICFGBuilder::processFunExit(const SVFFunction*  fun)
 {
-    FunExitICFGNode* FunExitICFGNode = icfg->getFunExitBlockNode(fun);
+    FunExitICFGNode* FunExitICFGNode = icfg->getFunExitICFGNode(fun);
 
     for (inst_iterator II = inst_begin(fun->getLLVMFun()), EE = inst_end(fun->getLLVMFun()); II != EE; ++II)
     {
@@ -161,7 +161,7 @@ InterICFGNode* ICFGBuilder::getOrAddInterBlockICFGNode(const Instruction* inst)
 {
     assert(SVFUtil::isCallSite(inst) && "not a call instruction?");
     assert(SVFUtil::isNonInstricCallSite(inst) && "associating an intrinsic debug instruction with an ICFGNode!");
-    CallICFGNode* callICFGNode = getOrAddCallICFGNode(inst);
+    CallICFGNode* callICFGNode = getCallICFGNode(inst);
     addICFGInterEdges(inst, getCallee(inst));                       //creating interprocedural edges
     return callICFGNode;
 }
@@ -171,19 +171,23 @@ InterICFGNode* ICFGBuilder::getOrAddInterBlockICFGNode(const Instruction* inst)
  */
 void ICFGBuilder::addICFGInterEdges(const Instruction* cs, const SVFFunction* callee)
 {
-    CallICFGNode* CallICFGNode = getOrAddCallICFGNode(cs);
-    RetICFGNode* retBlockNode = getOrAddRetICFGNode(cs);
+    CallICFGNode* CallICFGNode = getCallICFGNode(cs);
+    RetICFGNode* retBlockNode = getRetICFGNode(cs);
 
     /// direct call  
     if(callee){
-        FunEntryICFGNode* calleeEntryNode = icfg->getFunEntryBlockNode(callee);
-        FunExitICFGNode* calleeExitNode = icfg->getFunExitBlockNode(callee);
-        icfg->addCallEdge(CallICFGNode, calleeEntryNode, cs);
-        icfg->addRetEdge(calleeExitNode, retBlockNode, cs);
         /// if this is an external function (no function body)
         if (isExtCall(callee))
         {
-           icfg->addIntraEdge(calleeEntryNode, calleeExitNode); 
+           icfg->addIntraEdge(CallICFGNode, retBlockNode); 
+        }
+        /// otherwise connect interprocedural edges 
+        else
+        {
+            FunEntryICFGNode* calleeEntryNode = icfg->getFunEntryICFGNode(callee);
+            FunExitICFGNode* calleeExitNode = icfg->getFunExitICFGNode(callee);
+            icfg->addCallEdge(CallICFGNode, calleeEntryNode, cs);
+            icfg->addRetEdge(calleeExitNode, retBlockNode, cs);
         }
     }
     /// indirect call (don't know callee)
@@ -202,21 +206,9 @@ void ICFGBuilder::connectGlobalToProgEntry(SVFModule* svfModule)
     if(mainFunc == nullptr)
         return;
 
-    FunEntryICFGNode* entryNode = icfg->getFunEntryBlockNode(mainFunc);
-    GlobalICFGNode* globalNode = icfg->getGlobalBlockNode();
-
-    std::vector<ICFGEdge*> toBeRemovedEdges;
-    for(ICFGEdge* edge : entryNode->getOutEdges())
-        toBeRemovedEdges.push_back(edge);
-    
-    for(ICFGEdge* edge : toBeRemovedEdges){
-        assert(SVFUtil::isa<IntraCFGEdge>(edge) && "the outgoing edge of FunEntryICFGNode is not an intraCFGEdge?");
-        icfg->removeICFGEdge(edge);
-        IntraCFGEdge* intraEdge = new IntraCFGEdge(globalNode, edge->getDstNode());
-        icfg->addICFGEdge(intraEdge); 
-    }
-
-    IntraCFGEdge* intraEdge = new IntraCFGEdge(entryNode, globalNode);
+    FunEntryICFGNode* entryNode = icfg->getFunEntryICFGNode(mainFunc);
+    GlobalICFGNode* globalNode = icfg->getGlobalICFGNode();
+    IntraCFGEdge* intraEdge = new IntraCFGEdge(globalNode, entryNode);
     icfg->addICFGEdge(intraEdge);
 }
 

package/lib/SVF-FE/SVFIRBuilder.cpp

@@ -791,8 +791,8 @@ void SVFIRBuilder::visitCallSite(CallSite cs)
     DBOUT(DPAGBuild,
           outs() << "process callsite " << *cs.getInstruction() << "\n");
 
-    CallICFGNode* callBlockNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
-    RetICFGNode* retBlockNode = pag->getICFG()->getRetBlockNode(cs.getInstruction());
+    CallICFGNode* callBlockNode = pag->getICFG()->getCallICFGNode(cs.getInstruction());
+    RetICFGNode* retBlockNode = pag->getICFG()->getRetICFGNode(cs.getInstruction());
 
     pag->addCallSite(callBlockNode);
 
@@ -893,7 +893,7 @@ void SVFIRBuilder::visitBranchInst(BranchInst &inst){
     for (u32_t i = 0; i < inst.getNumSuccessors(); ++i)
     {
         const Instruction* succInst = &inst.getSuccessor(i)->front();
-        const ICFGNode* icfgNode = pag->getICFG()->getBlockICFGNode(succInst);
+        const ICFGNode* icfgNode = pag->getICFG()->getICFGNode(succInst);
         successors.push_back(std::make_pair(icfgNode, 1-i));
     }
     const BranchStmt *brStmt = addBranchStmt(brinst, cond,successors);
@@ -910,7 +910,7 @@ void SVFIRBuilder::visitSwitchInst(SwitchInst &inst){
         const ConstantInt* condVal = inst.findCaseDest(inst.getSuccessor(i));
         /// default case is set to -1;
         s64_t val = condVal ? condVal->getSExtValue() : -1;
-        const ICFGNode* icfgNode = pag->getICFG()->getBlockICFGNode(succInst);
+        const ICFGNode* icfgNode = pag->getICFG()->getICFGNode(succInst);
         successors.push_back(std::make_pair(icfgNode,val));
     }
     const BranchStmt *brStmt = addBranchStmt(brinst, cond,successors);
@@ -960,7 +960,7 @@ void SVFIRBuilder::handleDirectCall(CallSite cs, const SVFFunction *F)
     if (!cs.getType()->isVoidTy())
     {
         NodeID srcret = getReturnNode(F);
-        CallICFGNode* icfgNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
+        CallICFGNode* icfgNode = pag->getICFG()->getCallICFGNode(cs.getInstruction());
         addRetEdge(srcret, dstrec,icfgNode);
     }
     //Iterators for the actual and formal parameters
@@ -982,7 +982,7 @@ void SVFIRBuilder::handleDirectCall(CallSite cs, const SVFFunction *F)
 
         NodeID dstFA = getValueNode(FA);
         NodeID srcAA = getValueNode(AA);
-        CallICFGNode* icfgNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
+        CallICFGNode* icfgNode = pag->getICFG()->getCallICFGNode(cs.getInstruction());
         addCallEdge(srcAA, dstFA, icfgNode);
     }
     //Any remaining actual args must be varargs.
@@ -994,7 +994,7 @@ void SVFIRBuilder::handleDirectCall(CallSite cs, const SVFFunction *F)
         {
             Value *AA = *itA;
             NodeID vnAA = getValueNode(AA);
-            CallICFGNode* icfgNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
+            CallICFGNode* icfgNode = pag->getICFG()->getCallICFGNode(cs.getInstruction());
             addCallEdge(vnAA,vaF, icfgNode);
         }
     }
@@ -1477,7 +1477,7 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
                     /// Connect actual parameter to formal parameter of the start routine
                     if(SVFUtil::isa<PointerType>(actualParm->getType()) && SVFUtil::isa<PointerType>(formalParm->getType()) )
                     {
-                        CallICFGNode* icfgNode = pag->getICFG()->getCallBlockNode(inst);
+                        CallICFGNode* icfgNode = pag->getICFG()->getCallICFGNode(inst);
                         addThreadForkEdge(pag->getValueNode(actualParm), pag->getValueNode(formalParm),icfgNode);
                     }
                 }
@@ -1506,7 +1506,7 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
                 /// Connect actual parameter to formal parameter of the start routine
                 if(SVFUtil::isa<PointerType>(actualParm->getType()) && SVFUtil::isa<PointerType>(formalParm->getType()) )
                 {
-                    CallICFGNode* icfgNode = pag->getICFG()->getCallBlockNode(inst);
+                    CallICFGNode* icfgNode = pag->getICFG()->getCallICFGNode(inst);
                     addThreadForkEdge(pag->getValueNode(actualParm), pag->getValueNode(formalParm),icfgNode);
                 }
             }
@@ -1528,7 +1528,7 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
  */
 void SVFIRBuilder::handleIndCall(CallSite cs)
 {
-    const CallICFGNode* cbn = pag->getICFG()->getCallBlockNode(cs.getInstruction());
+    const CallICFGNode* cbn = pag->getICFG()->getCallICFGNode(cs.getInstruction());
     pag->addIndirectCallsites(cbn,pag->getValueNode(cs.getCalledValue()));
 }
 
@@ -1618,7 +1618,7 @@ void SVFIRBuilder::setCurrentBBAndValueForPAGEdge(PAGEdge* edge)
     edge->setValue(curVal);
     // backmap in valuToEdgeMap
     pag->mapValueToEdge(curVal, edge);
-    ICFGNode* icfgNode = pag->getICFG()->getGlobalBlockNode();
+    ICFGNode* icfgNode = pag->getICFG()->getGlobalICFGNode();
     if (const Instruction *curInst = SVFUtil::dyn_cast<Instruction>(curVal))
     {
         const Function* srcFun = edge->getSrcNode()->getFunction();
@@ -1637,23 +1637,23 @@ void SVFIRBuilder::setCurrentBBAndValueForPAGEdge(PAGEdge* edge)
         /// We will have one unique function exit ICFGNode for all returns
         if(const ReturnInst* retInst = SVFUtil::dyn_cast<ReturnInst>(curVal)){
             const SVFFunction *fun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(retInst->getParent()->getParent());
-            icfgNode = pag->getICFG()->getFunExitBlockNode(fun);
+            icfgNode = pag->getICFG()->getFunExitICFGNode(fun);
         }
         else
-            icfgNode = pag->getICFG()->getBlockICFGNode(curInst);
+            icfgNode = pag->getICFG()->getICFGNode(curInst);
     }
     else if (const Argument* arg = SVFUtil::dyn_cast<Argument>(curVal))
     {
         assert(curBB && (&curBB->getParent()->getEntryBlock() == curBB));
         const SVFFunction* fun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(arg->getParent());
-        icfgNode = pag->getICFG()->getFunEntryBlockNode(fun);
+        icfgNode = pag->getICFG()->getFunEntryICFGNode(fun);
     }
     else if (SVFUtil::isa<ConstantExpr>(curVal))
     {
         if (!curBB)
             pag->addGlobalPAGEdge(edge);
         else
-    		icfgNode = pag->getICFG()->getBlockICFGNode(&curBB->front());
+    		icfgNode = pag->getICFG()->getICFGNode(&curBB->front());
     }
     else if (SVFUtil::isa<GlobalVariable>(curVal) ||
              SVFUtil::isa<Function>(curVal) ||

package/lib/WPA/Andersen.cpp

@@ -654,7 +654,7 @@ bool Andersen::updateCallGraph(const CallSiteToFunPtrMap& callsites)
 void Andersen::heapAllocatorViaIndCall(CallSite cs, NodePairSet &cpySrcNodes)
 {
     assert(SVFUtil::getCallee(cs) == nullptr && "not an indirect callsite?");
-    RetICFGNode* retBlockNode = pag->getICFG()->getRetBlockNode(cs.getInstruction());
+    RetICFGNode* retBlockNode = pag->getICFG()->getRetICFGNode(cs.getInstruction());
     const PAGNode* cs_return = pag->getCallSiteRet(retBlockNode);
     NodeID srcret;
     CallSite2DummyValPN::const_iterator it = callsite2DummyValPN.find(cs);
@@ -687,8 +687,8 @@ void Andersen::connectCaller2CalleeParams(CallSite cs, const SVFFunction* F, Nod
 
     DBOUT(DAndersen, outs() << "connect parameters from indirect callsite " << *cs.getInstruction() << " to callee " << *F << "\n");
 
-    CallICFGNode* callBlockNode = pag->getICFG()->getCallBlockNode(cs.getInstruction());
-    RetICFGNode* retBlockNode = pag->getICFG()->getRetBlockNode(cs.getInstruction());
+    CallICFGNode* callBlockNode = pag->getICFG()->getCallICFGNode(cs.getInstruction());
+    RetICFGNode* retBlockNode = pag->getICFG()->getRetICFGNode(cs.getInstruction());
 
     if(SVFUtil::isHeapAllocExtFunViaRet(F) && pag->callsiteHasRet(retBlockNode))
     {

package/lib/WPA/WPAPass.cpp

@@ -239,7 +239,7 @@ ModRefInfo WPAPass::getModRefInfo(const CallInst* callInst)
 {
     assert(Options::PASelected.isSet(PointerAnalysis::AndersenWaveDiff_WPA) && Options::AnderSVFG && "mod-ref query is only support with -ander and -svfg turned on");
     ICFG* icfg = _svfg->getPAG()->getICFG();
-    const CallICFGNode* cbn = icfg->getCallBlockNode(callInst);
+    const CallICFGNode* cbn = icfg->getCallICFGNode(callInst);
     return _svfg->getMSSA()->getMRGenerator()->getModRefInfo(cbn);
 }
 
@@ -250,7 +250,7 @@ ModRefInfo WPAPass::getModRefInfo(const CallInst* callInst, const Value* V)
 {
     assert(Options::PASelected.isSet(PointerAnalysis::AndersenWaveDiff_WPA) && Options::AnderSVFG && "mod-ref query is only support with -ander and -svfg turned on");
     ICFG* icfg = _svfg->getPAG()->getICFG();
-    const CallICFGNode* cbn = icfg->getCallBlockNode(callInst);
+    const CallICFGNode* cbn = icfg->getCallICFGNode(callInst);
     return _svfg->getMSSA()->getMRGenerator()->getModRefInfo(cbn, V);
 }
 
@@ -261,7 +261,7 @@ ModRefInfo WPAPass::getModRefInfo(const CallInst* callInst1, const CallInst* cal
 {
     assert(Options::PASelected.isSet(PointerAnalysis::AndersenWaveDiff_WPA) && Options::AnderSVFG && "mod-ref query is only support with -ander and -svfg turned on");
     ICFG* icfg = _svfg->getPAG()->getICFG();
-    const CallICFGNode* cbn1 = icfg->getCallBlockNode(callInst1);
-    const CallICFGNode* cbn2 = icfg->getCallBlockNode(callInst2);
+    const CallICFGNode* cbn1 = icfg->getCallICFGNode(callInst1);
+    const CallICFGNode* cbn2 = icfg->getCallICFGNode(callInst2);
     return _svfg->getMSSA()->getMRGenerator()->getModRefInfo(cbn1, cbn2);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.355",
+  "version": "1.0.359",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/tools/Example/svf-ex.cpp

@@ -79,7 +79,7 @@ std::string printPts(PointerAnalysis* pta, Value* val)
  */
 void traverseOnICFG(ICFG* icfg, const Instruction* inst)
 {
-    ICFGNode* iNode = icfg->getBlockICFGNode(inst);
+    ICFGNode* iNode = icfg->getICFGNode(inst);
     FIFOWorkList<const ICFGNode*> worklist;
     Set<const ICFGNode*> visited;
     worklist.push(iNode);