svf-tools 1.0.995 → 1.0.997

package/svf/lib/SABER/DoubleFreeChecker.cpp

@@ -94,15 +94,15 @@ void DoubleFreeChecker::validateSuccessTests(ProgSlice *slice, const SVFFunction
     if (success)
     {
         outs() << sucMsg("\t SUCCESS :") << funName << " check <src id:" << source->getId()
-               << ", cs id:" << getSrcCSID(source)->getCallSite()->toString() << "> at ("
-               << cs->getCallSite()->getSourceLoc() << ")\n";
+               << ", cs id:" << (getSrcCSID(source))->toString() << "> at ("
+               << cs->getSourceLoc() << ")\n";
         outs() << "\t\t double free path: \n" << slice->evalFinalCond() << "\n";
     }
     else
     {
         SVFUtil::errs() << errMsg("\t FAILURE :") << funName << " check <src id:" << source->getId()
-                        << ", cs id:" <<getSrcCSID(source)->getCallSite()->toString() << "> at ("
-                        << cs->getCallSite()->getSourceLoc() << ")\n";
+                        << ", cs id:" << (getSrcCSID(source))->toString() << "> at ("
+                        << cs->getSourceLoc() << ")\n";
         SVFUtil::errs() << "\t\t double free path: \n" << slice->evalFinalCond() << "\n";
         assert(false && "test case failed!");
     }
@@ -140,16 +140,16 @@ void DoubleFreeChecker::validateExpectedFailureTests(ProgSlice *slice, const SVF
     if (expectedFailure)
     {
         outs() << sucMsg("\t EXPECTED-FAILURE :") << funName << " check <src id:" << source->getId()
-               << ", cs id:" << getSrcCSID(source)->getCallSite()->toString() << "> at ("
-               << cs->getCallSite()->getSourceLoc() << ")\n";
+               << ", cs id:" << (getSrcCSID(source))->toString() << "> at ("
+               << cs->getSourceLoc() << ")\n";
         outs() << "\t\t double free path: \n" << slice->evalFinalCond() << "\n";
     }
     else
     {
         SVFUtil::errs() << errMsg("\t UNEXPECTED FAILURE :") << funName
                         << " check <src id:" << source->getId()
-                        << ", cs id:" << getSrcCSID(source)->getCallSite()->toString() << "> at ("
-                        << cs->getCallSite()->getSourceLoc() << ")\n";
+                        << ", cs id:" << (getSrcCSID(source))->toString() << "> at ("
+                        << cs->getSourceLoc() << ")\n";
         SVFUtil::errs() << "\t\t double free path: \n" << slice->evalFinalCond() << "\n";
         assert(false && "test case failed!");
     }

package/svf/lib/SABER/LeakChecker.cpp

@@ -48,7 +48,7 @@ void LeakChecker::initSrcs()
         /// if this callsite return reside in a dead function then we do not care about its leaks
         /// for example instruction `int* p = malloc(size)` is in a dead function, then program won't allocate this memory
         /// for example a customized malloc `int p = malloc()` returns an integer value, then program treat it as a system malloc
-        if(cs->getCallSite()->ptrInUncalledFunction() || !cs->getCallSite()->getType()->isPointerTy())
+        if(cs->getFun()->isUncalledFunction() || !cs->getType()->isPointerTy())
             continue;
 
         CallGraph::FunctionSet callees;
@@ -86,7 +86,7 @@ void LeakChecker::initSrcs()
                     else
                     {
                         // exclude sources in dead functions or sources in functions that have summary
-                        if (!cs->getCallSite()->ptrInUncalledFunction() && !isExtCall(cs->getCallSite()->getParent()->getParent()))
+                        if (!cs->getFun()->isUncalledFunction() && !isExtCall(cs->getBB()->getParent()))
                         {
                             addToSources(node);
                             addSrcToCSID(node, cs);
@@ -231,14 +231,14 @@ void LeakChecker::validateSuccessTests(const SVFGNode* source, const SVFFunction
     if (success)
     {
         outs() << sucMsg("\t SUCCESS :") << funName << " check <src id:" << source->getId()
-               << ", cs id:" << getSrcCSID(source)->getCallSite()->toString() << "> at ("
-               << cs->getCallSite()->getSourceLoc() << ")\n";
+               << ", cs id:" << (getSrcCSID(source))->toString() << "> at ("
+               << cs->getSourceLoc() << ")\n";
     }
     else
     {
         SVFUtil::errs() << errMsg("\t FAILURE :") << funName << " check <src id:" << source->getId()
-                        << ", cs id:" << getSrcCSID(source)->getCallSite()->toString() << "> at ("
-                        << cs->getCallSite()->getSourceLoc() << ")\n";
+                        << ", cs id:" << (getSrcCSID(source))->toString() << "> at ("
+                        << cs->getSourceLoc() << ")\n";
         assert(false && "test case failed!");
     }
 }
@@ -281,15 +281,15 @@ void LeakChecker::validateExpectedFailureTests(const SVFGNode* source, const SVF
     if (expectedFailure)
     {
         outs() << sucMsg("\t EXPECTED-FAILURE :") << funName << " check <src id:" << source->getId()
-               << ", cs id:" << getSrcCSID(source)->getCallSite()->toString() << "> at ("
-               << cs->getCallSite()->getSourceLoc() << ")\n";
+               << ", cs id:" << (getSrcCSID(source))->toString() << "> at ("
+               << cs->getSourceLoc() << ")\n";
     }
     else
     {
         SVFUtil::errs() << errMsg("\t UNEXPECTED FAILURE :") << funName
                         << " check <src id:" << source->getId()
-                        << ", cs id:" << getSrcCSID(source)->getCallSite()->toString() << "> at ("
-                        << cs->getCallSite()->getSourceLoc() << ")\n";
+                        << ", cs id:" << (getSrcCSID(source))->toString() << "> at ("
+                        << cs->getSourceLoc() << ")\n";
         assert(false && "test case failed!");
     }
 }

package/svf/lib/SVFIR/SVFFileSystem.cpp

@@ -386,7 +386,7 @@ cJSON* SVFIRWriter::contentToJson(const GlobalICFGNode* node)
 cJSON* SVFIRWriter::contentToJson(const IntraICFGNode* node)
 {
     cJSON* root = contentToJson(static_cast<const ICFGNode*>(node));
-    JSON_WRITE_FIELD(root, node, inst);
+    JSON_WRITE_FIELD(root, node, isRet);
     return root;
 }
 
@@ -1153,10 +1153,10 @@ cJSON* SVFIRWriter::toJson(const CHGraph* graph)
     F(classNameToAncestorsMap);
     F(classNameToInstAndDescsMap);
     F(templateNameToInstancesMap);
-    F(csToClassesMap);
+    F(callNodeToClassesMap);
     F(virtualFunctionToIDMap);
-    F(csToCHAVtblsMap);
-    F(csToCHAVFnsMap);
+    F(callNodeToCHAVtblsMap);
+    F(callNodeToCHAVFnsMap);
 #undef F
     return root;
 }
@@ -1755,10 +1755,10 @@ void SVFIRReader::readJson(CHGraph* graph)
     F(classNameToAncestorsMap);
     F(classNameToInstAndDescsMap);
     F(templateNameToInstancesMap);
-    F(csToClassesMap);
+    F(callNodeToClassesMap);
     F(virtualFunctionToIDMap);
-    F(csToCHAVtblsMap);
-    F(csToCHAVFnsMap);
+    F(callNodeToCHAVtblsMap);
+    F(callNodeToCHAVFnsMap);
 #undef F
 }
 
@@ -2182,7 +2182,7 @@ void SVFIRReader::fill(const cJSON*& fieldJson, GlobalICFGNode* node)
 void SVFIRReader::fill(const cJSON*& fieldJson, IntraICFGNode* node)
 {
     fill(fieldJson, static_cast<ICFGNode*>(node));
-    JSON_READ_FIELD_FWD(fieldJson, node, inst);
+    JSON_READ_FIELD_FWD(fieldJson, node, isRet);
 }
 
 void SVFIRReader::fill(const cJSON*& fieldJson, InterICFGNode* node)

package/svf/lib/Util/CallGraphBuilder.cpp

@@ -31,6 +31,7 @@
 #include "Util/SVFUtil.h"
 #include "Util/CallGraphBuilder.h"
 #include "Graphs/ICFG.h"
+#include "SVFIR/SVFIR.h"
 
 using namespace SVF;
 using namespace SVFUtil;
@@ -84,7 +85,7 @@ CallGraph* ThreadCallGraphBuilder::buildThreadCallGraph(SVFModule* svfModule)
                 {
                     const CallICFGNode* cs = cast<CallICFGNode>(inst);
                     cg->addForksite(cs);
-                    const SVFFunction* forkee = SVFUtil::dyn_cast<SVFFunction>(tdAPI->getForkedFun(cs));
+                    const SVFFunction* forkee = SVFUtil::dyn_cast<SVFFunction>(tdAPI->getForkedFun(cs)->getValue());
                     if (forkee)
                     {
                         cg->addDirectForkEdge(cs);

package/svf/lib/Util/SVFUtil.cpp

@@ -374,13 +374,13 @@ bool SVFUtil::isHeapAllocExtCall(const ICFGNode* cs)
 
 bool SVFUtil::isHeapAllocExtCallViaRet(const CallICFGNode* cs)
 {
-    bool isPtrTy = cs->getCallSite()->getType()->isPointerTy();
+    bool isPtrTy = cs->getType()->isPointerTy();
     return isPtrTy && isHeapAllocExtFunViaRet(cs->getCalledFunction());
 }
 
 bool SVFUtil::isReallocExtCall(const CallICFGNode* cs)
 {
-    bool isPtrTy = cs->getCallSite()->getType()->isPointerTy();
+    bool isPtrTy = cs->getType()->isPointerTy();
     return isPtrTy && isReallocExtFun(cs->getCalledFunction());
 }
 
@@ -388,7 +388,7 @@ bool SVFUtil::isReallocExtCall(const CallICFGNode* cs)
 bool SVFUtil::isRetInstNode(const ICFGNode* node)
 {
     if (const auto& intraNode = dyn_cast<IntraICFGNode>(node))
-        return intraNode->getInst()->isRetInst();
+        return intraNode->isRetInst();
     else
         return false;
 }
@@ -396,4 +396,11 @@ bool SVFUtil::isRetInstNode(const ICFGNode* node)
 bool SVFUtil::isProgExitCall(const CallICFGNode* cs)
 {
     return isProgExitFunction(cs->getCalledFunction());
+}
+
+__attribute__((weak))
+const std::string SVFBaseNode::toString() const
+{
+    assert("SVFBaseNode::toString should be implemented or supported by fronted" && false);
+    abort();
 }

package/svf/lib/Util/ThreadAPI.cpp

@@ -160,25 +160,24 @@ bool ThreadAPI::isTDBarWait(const CallICFGNode *inst) const
 }
 
 
-const SVFValue* ThreadAPI::getForkedThread(const CallICFGNode *inst) const
+const SVFVar* 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
+const SVFVar* ThreadAPI::getForkedFun(const CallICFGNode *inst) const
 {
     assert(isTDFork(inst) && "not a thread fork function!");
     return inst->getArgument(2);
 }
 
-const SVFVar* ThreadAPI::getActualParmAtForkSite(const CallICFGNode* inst) const
+/// Return the forth argument of the call,
+/// Note that, it is the sole argument of start routine ( a void* pointer )
+const SVFVar* ThreadAPI::getActualParmAtForkSite(const CallICFGNode *inst) const
 {
-    assert(PAG::getPAG()->hasCallSiteArgsMap(inst) && "forksite has no args list!");
-    const SVFIR::SVFVarList& csArgList = PAG::getPAG()->getCallSiteArgsList(inst);
-    // pthread_create has 4 parameters
-    assert(csArgList.size() == 4 && "num of forksite args is not 4");
-    return csArgList[3];
+    assert(isTDFork(inst) && "not a thread fork function!");
+    return inst->getArgument(3);
 }
 
 const SVFVar* ThreadAPI::getFormalParmOfForkedFun(const SVFFunction* F) const
@@ -190,13 +189,13 @@ const SVFVar* ThreadAPI::getFormalParmOfForkedFun(const SVFFunction* F) const
     return funArgList[0];
 }
 
-const SVFValue* ThreadAPI::getRetParmAtJoinedSite(const CallICFGNode *inst) const
+const SVFVar* ThreadAPI::getRetParmAtJoinedSite(const CallICFGNode *inst) const
 {
     assert(isTDJoin(inst) && "not a thread join function!");
     return inst->getArgument(1);
 }
 
-const SVFValue* ThreadAPI::getLockVal(const ICFGNode *cs) const
+const SVFVar* ThreadAPI::getLockVal(const ICFGNode *cs) const
 {
     const CallICFGNode* call = SVFUtil::dyn_cast<CallICFGNode>(cs);
     assert(call && "not a call ICFGNode?");
@@ -204,17 +203,16 @@ const SVFValue* ThreadAPI::getLockVal(const ICFGNode *cs) const
     return call->getArgument(0);
 }
 
-const SVFValue* ThreadAPI::getJoinedThread(const CallICFGNode *cs) const
+const SVFVar* ThreadAPI::getJoinedThread(const CallICFGNode *cs) const
 {
     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())
+    const SVFVar* join = cs->getArgument(0);
+    for(const SVFStmt* stmt : join->getInEdges())
     {
         if(SVFUtil::isa<LoadStmt>(stmt))
-            return stmt->getSrcNode()->getValue();
+            return stmt->getSrcNode();
     }
-    if(SVFUtil::isa<SVFArgument>(join))
+    if(SVFUtil::isa<SVFArgument>(join->getValue()))
         return join;
 
     assert(false && "the value of the first argument at join is not a load instruction?");

package/svf/lib/WPA/Andersen.cpp

@@ -379,7 +379,7 @@ void AndersenBase::heapAllocatorViaIndCall(const CallICFGNode* cs, NodePairSet &
     else
     {
         NodeID valNode = pag->addDummyValNode();
-        NodeID objNode = pag->addDummyObjNode(cs->getCallSite()->getType());
+        NodeID objNode = pag->addDummyObjNode(cs->getType());
         addPts(valNode,objNode);
         callsite2DummyValPN.insert(std::make_pair(cs,valNode));
         consCG->addConstraintNode(new ConstraintNode(valNode),valNode);

package/svf-llvm/include/SVF-LLVM/CHGBuilder.h

@@ -33,6 +33,8 @@
 namespace SVF
 {
 
+class LLVMModuleSet;
+
 class CHGBuilder
 {
 
@@ -67,6 +69,9 @@ public:
     void buildCSToCHAVtblsAndVfnsMap();
     const CHNodeSetTy& getCSClasses(const CallBase* cs);
     void addFuncToFuncVector(CHNode::FuncVector &v, const Function *f);
+
+private:
+    LLVMModuleSet* llvmModuleSet();
 };
 
 } // End namespace SVF

package/svf-llvm/include/SVF-LLVM/DCHG.h

@@ -93,7 +93,7 @@ public:
 
     ~DCHNode() { }
 
-    const DIType *getType(void) const
+    const DIType * getDIType(void) const
     {
         return diType;
     }
@@ -275,7 +275,7 @@ public:
     }
 
     virtual const VTableSet &getCSVtblsBasedonCHA(const CallICFGNode* cs) override;
-    virtual void getVFnsFromVtbls(const SVFCallInst* cs, const VTableSet &vtbls, VFunSet &virtualFunctions) override;
+    virtual void getVFnsFromVtbls(const CallICFGNode* cs, const VTableSet &vtbls, VFunSet &virtualFunctions) override;
 
     /// Returns true if a is a transitive base of b. firstField determines
     /// whether to consider first-field edges.

package/svf-llvm/include/SVF-LLVM/LLVMModule.h

@@ -60,6 +60,7 @@ public:
     typedef Map<const Constant*, SVFConstant*> LLVMConst2SVFConstMap;
     typedef Map<const Value*, SVFOtherValue*> LLVMValue2SVFOtherValueMap;
     typedef Map<const SVFValue*, const Value*> SVFValue2LLVMValueMap;
+    typedef Map<const SVFBaseNode*, const Value*> SVFBaseNode2LLVMValueMap;
     typedef Map<const Type*, SVFType*> LLVMType2SVFTypeMap;
     typedef Map<const Type*, StInfo*> Type2TypeInfoMap;
     typedef Map<std::string, std::vector<std::string>> Fun2AnnoMap;
@@ -97,6 +98,7 @@ private:
     Type2TypeInfoMap Type2TypeInfo;
     ObjTypeInference* typeInference;
 
+    SVFBaseNode2LLVMValueMap SVFBaseNode2LLVMValue;
     CSToCallNodeMapTy CSToCallNodeMap; ///< map a callsite to its CallICFGNode
     CSToRetNodeMapTy CSToRetNodeMap; ///< map a callsite to its RetICFGNode
     InstToBlockNodeMapTy InstToBlockNodeMap; ///< map a basic block to its ICFGNode
@@ -216,6 +218,13 @@ public:
         return it->second;
     }
 
+    const Value* getLLVMValue(const SVFBaseNode* value) const
+    {
+        SVFBaseNode2LLVMValueMap ::const_iterator it = SVFBaseNode2LLVMValue.find(value);
+        assert(it!=SVFBaseNode2LLVMValue.end() && "can't find corresponding llvm value!");
+        return it->second;
+    }
+
     inline SVFFunction* getSVFFunction(const Function* fun) const
     {
         LLVMFun2SVFFunMap::const_iterator it = LLVMFunc2SVFFunc.find(fun);
@@ -378,6 +387,7 @@ private:
     void initSVFBasicBlock(const Function* func);
     void initDomTree(SVFFunction* func, const Function* f);
     void setValueAttr(const Value* val, SVFValue* value);
+    void setValueAttr(const Value* val, SVFBaseNode* svfBaseNode);
     void buildFunToFunMap();
     void buildGlobalDefToRepMap();
     /// Invoke llvm passes to modify module

package/svf-llvm/lib/CHGBuilder.cpp

@@ -57,13 +57,17 @@ const string pureVirtualFunName = "__cxa_pure_virtual";
 
 const string ztiLabel = "_ZTI";
 
+LLVMModuleSet* CHGBuilder::llvmModuleSet()
+{
+    return LLVMModuleSet::getLLVMModuleSet();
+}
 
 void CHGBuilder::buildCHG()
 {
 
     double timeStart, timeEnd;
     timeStart = PTAStat::getClk(true);
-    for (Module &M : LLVMModuleSet::getLLVMModuleSet()->getLLVMModules())
+    for (Module &M : llvmModuleSet()->getLLVMModules())
     {
         DBOUT(DGENERAL, outs() << SVFUtil::pasMsg("construct CHGraph From module "
                 + M.getName().str() + "...\n"));
@@ -375,7 +379,7 @@ void CHGBuilder::analyzeVTables(const Module &M)
             assert(node && "node not found?");
 
             SVFGlobalValue* pValue =
-                LLVMModuleSet::getLLVMModuleSet()->getSVFGlobalValue(
+                llvmModuleSet()->getSVFGlobalValue(
                     globalvalue);
             pValue->setName(vtblClassName);
             node->setVTable(pValue);
@@ -655,7 +659,7 @@ void CHGBuilder::buildVirtualFunctionToIDMap()
 void CHGBuilder::buildCSToCHAVtblsAndVfnsMap()
 {
 
-    for (Module &M : LLVMModuleSet::getLLVMModuleSet()->getLLVMModules())
+    for (Module &M : llvmModuleSet()->getLLVMModules())
     {
         for (Module::const_iterator F = M.begin(), E = M.end(); F != E; ++F)
         {
@@ -679,12 +683,13 @@ void CHGBuilder::buildCSToCHAVtblsAndVfnsMap()
                     }
                     if (vtbls.size() > 0)
                     {
-                        const SVFInstruction* cs = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(callInst);
-                        chg->csToCHAVtblsMap[cs] = vtbls;
+                        ICFGNode* icfgNode =
+                            llvmModuleSet()->getICFGNode(callInst);
+                        chg->callNodeToCHAVtblsMap[icfgNode] = vtbls;
                         VFunSet virtualFunctions;
-                        chg->getVFnsFromVtbls(SVFUtil::cast<SVFCallInst>(cs), vtbls, virtualFunctions);
+                        chg->getVFnsFromVtbls(SVFUtil::cast<CallICFGNode>(icfgNode), vtbls, virtualFunctions);
                         if (virtualFunctions.size() > 0)
-                            chg->csToCHAVFnsMap[cs] = virtualFunctions;
+                            chg->callNodeToCHAVFnsMap[icfgNode] = virtualFunctions;
                     }
                 }
             }
@@ -696,10 +701,11 @@ void CHGBuilder::buildCSToCHAVtblsAndVfnsMap()
 const CHGraph::CHNodeSetTy& CHGBuilder::getCSClasses(const CallBase* cs)
 {
     assert(cppUtil::isVirtualCallSite(cs) && "not virtual callsite!");
-    const SVFInstruction* svfcall = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(cs);
 
-    CHGraph::CallSiteToCHNodesMap::const_iterator it = chg->csToClassesMap.find(svfcall);
-    if (it != chg->csToClassesMap.end())
+    ICFGNode* icfgNode = llvmModuleSet()->getICFGNode(cs);
+
+    CHGraph::CallNodeToCHNodesMap::const_iterator it = chg->callNodeToClassesMap.find(icfgNode);
+    if (it != chg->callNodeToClassesMap.end())
     {
         return it->second;
     }
@@ -712,9 +718,9 @@ const CHGraph::CHNodeSetTy& CHGBuilder::getCSClasses(const CallBase* cs)
             // if we cannot infer classname, conservatively push all class nodes
             for (const auto &node: *chg)
             {
-                chg->csToClassesMap[svfcall].insert(node.second);
+                chg->callNodeToClassesMap[icfgNode].insert(node.second);
             }
-            return chg->csToClassesMap[svfcall];
+            return chg->callNodeToClassesMap[icfgNode];
         }
 
         for (const auto &thisPtrClassName: thisPtrClassNames)
@@ -722,12 +728,12 @@ const CHGraph::CHNodeSetTy& CHGBuilder::getCSClasses(const CallBase* cs)
             if (const CHNode* thisNode = chg->getNode(thisPtrClassName))
             {
                 const CHGraph::CHNodeSetTy& instAndDesces = getInstancesAndDescendants(thisPtrClassName);
-                chg->csToClassesMap[svfcall].insert(thisNode);
+                chg->callNodeToClassesMap[icfgNode].insert(thisNode);
                 for (CHGraph::CHNodeSetTy::const_iterator it2 = instAndDesces.begin(), eit = instAndDesces.end(); it2 != eit; ++it2)
-                    chg->csToClassesMap[svfcall].insert(*it2);
+                    chg->callNodeToClassesMap[icfgNode].insert(*it2);
             }
         }
-        return chg->csToClassesMap[svfcall];
+        return chg->callNodeToClassesMap[icfgNode];
     }
 }
 
@@ -738,14 +744,14 @@ void CHGBuilder::addFuncToFuncVector(CHNode::FuncVector &v, const Function *lf)
         if (const auto* tf = cppUtil::getThunkTarget(lf))
         {
             SVFFunction* pFunction =
-                LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(tf);
+                llvmModuleSet()->getSVFFunction(tf);
             v.push_back(pFunction);
         }
     }
     else
     {
         SVFFunction* pFunction =
-            LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(lf);
+            llvmModuleSet()->getSVFFunction(lf);
         v.push_back(pFunction);
     }
 }

package/svf-llvm/lib/DCHG.cpp

@@ -251,7 +251,7 @@ const NodeBS &DCHGraph::cha(const DIType *type, bool firstField)
             continue;
         }
 
-        const NodeBS &cchildren = cha(edge->getSrcNode()->getType(), firstField);
+        const NodeBS &cchildren = cha(edge->getSrcNode()->getDIType(), firstField);
         // Children's children are my children.
         for (NodeID cchild : cchildren)
         {
@@ -530,10 +530,10 @@ void DCHGraph::buildCHG(bool extend)
         for (iterator nodeI = begin(); nodeI != end(); ++nodeI)
         {
             // Everything without a parent gets char as a parent.
-            if (nodeI->second->getType() != nullptr
+            if (nodeI->second->getDIType() != nullptr
                     && nodeI->second->getOutEdges().size() == 0)
             {
-                addEdge(nodeI->second->getType(), charType, DCHEdge::STD_DEF);
+                addEdge(nodeI->second->getDIType(), charType, DCHEdge::STD_DEF);
             }
         }
     }
@@ -553,7 +553,7 @@ const VFunSet &DCHGraph::getCSVFsBasedonCHA(const CallICFGNode* cs)
 
     VFunSet vfns;
     const VTableSet &vtbls = getCSVtblsBasedonCHA(cs);
-    getVFnsFromVtbls(SVFUtil::cast<SVFCallInst>(cs->getCallSite()), vtbls, vfns);
+    getVFnsFromVtbls(cs, vtbls, vfns);
 
     // Cache.
     csCHAMap.insert({cs, vfns});
@@ -589,11 +589,10 @@ const VTableSet &DCHGraph::getCSVtblsBasedonCHA(const CallICFGNode* cs)
     return vtblCHAMap[type];
 }
 
-void DCHGraph::getVFnsFromVtbls(const SVFCallInst* callsite, const VTableSet &vtbls, VFunSet &virtualFunctions)
+void DCHGraph::getVFnsFromVtbls(const CallICFGNode* callsite, const VTableSet &vtbls, VFunSet &virtualFunctions)
 {
-    const SVFVirtualCallInst* cs = SVFUtil::cast<SVFVirtualCallInst>(callsite);
-    size_t idx = cs->getFunIdxInVtable();
-    std::string funName = cs->getFunNameOfVirtualCall();
+    size_t idx = callsite->getFunIdxInVtable();
+    std::string funName = callsite->getFunNameOfVirtualCall();
     for (const SVFGlobalValue *vtbl : vtbls)
     {
         assert(vtblToTypeMap.find(vtbl) != vtblToTypeMap.end() && "floating vtbl");
@@ -611,7 +610,7 @@ void DCHGraph::getVFnsFromVtbls(const SVFCallInst* callsite, const VTableSet &vt
 
             const Function* callee = vfnV[idx];
             // Practically a copy of that in lib/MemoryModel/CHA.cpp
-            if (cs->arg_size() == callee->arg_size() || (cs->isVarArg() && callee->isVarArg()))
+            if (callsite->arg_size() == callee->arg_size() || (callsite->isVarArg() && callee->isVarArg()))
             {
                 cppUtil::DemangledName dname = cppUtil::demangle(callee->getName().str());
                 std::string calleeName = dname.funcName;
@@ -957,8 +956,8 @@ bool DCHGraph::isFirstField(const DIType *f, const DIType *b)
         // Only care about first-field edges.
         if (edge->getEdgeKind() == DCHEdge::FIRST_FIELD)
         {
-            if (edge->getSrcNode()->getType() == b) return true;
-            if (isFirstField(edge->getSrcNode()->getType(), b)) return true;
+            if (edge->getSrcNode()->getDIType() == b) return true;
+            if (isFirstField(edge->getSrcNode()->getDIType(), b)) return true;
         }
     }
 
@@ -1163,13 +1162,14 @@ void DCHGraph::print(void)
 
         const DCHNode *node = getGNode(id);
 
-        SVFUtil::outs() << indent(currIndent) << id << ": " << diTypeToStr(node->getType()) << " [" << node->getType() << "]" << "\n";
-        if (node->getType() != nullptr
-                && (node->getType()->getTag() == dwarf::DW_TAG_class_type
-                    || node->getType()->getTag() == dwarf::DW_TAG_structure_type))
+        SVFUtil::outs() << indent(currIndent) << id << ": " << diTypeToStr(node->getDIType()) << " [" << node->getDIType() << "]" << "\n";
+        if (node->getDIType() != nullptr
+                && (node->getDIType()->getTag() == dwarf::DW_TAG_class_type
+                    ||
+                    node->getDIType()->getTag() == dwarf::DW_TAG_structure_type))
         {
             ++numStructs;
-            unsigned numFields = getFieldTypes(node->getType()).size();
+            unsigned numFields = getFieldTypes(node->getDIType()).size();
             largestStruct = numFields > largestStruct ? numFields : largestStruct;
         }
 
@@ -1225,8 +1225,8 @@ void DCHGraph::print(void)
                 arrow = "----unknown---->";
             }
 
-            SVFUtil::outs() << indent(currIndent) << "[ " << diTypeToStr(node->getType()) << " ] "
-                            << arrow << " [ " << diTypeToStr(edge->getDstNode()->getType()) << " ]\n";
+            SVFUtil::outs() << indent(currIndent) << "[ " << diTypeToStr(node->getDIType()) << " ] "
+                            << arrow << " [ " << diTypeToStr(edge->getDstNode()->getDIType()) << " ]\n";
         }
 
         if (node->getOutEdges().size() == 0)

package/svf-llvm/lib/ICFGBuilder.cpp

@@ -239,15 +239,19 @@ InterICFGNode* ICFGBuilder::addInterBlockICFGNode(const Instruction* inst)
     assert(LLVMUtil::isCallSite(inst) && "not a call instruction?");
     assert(LLVMUtil::isNonInstricCallSite(inst) && "associating an intrinsic debug instruction with an ICFGNode!");
     assert(llvmModuleSet()->getCallBlock(inst)==nullptr && "duplicate CallICFGNode");
-    CallICFGNode* callICFGNode = new CallICFGNode(icfg->totalICFGNode++, svfInst);
+    CallICFGNode* callICFGNode =
+        new CallICFGNode(icfg->totalICFGNode++, svfInst,
+                         llvmModuleSet()->getSVFType(inst->getType()));
     icfg->addICFGNode(callICFGNode);
     csToCallNodeMap()[inst] = callICFGNode;
+    llvmModuleSet()->setValueAttr(inst, callICFGNode);
 
     assert(llvmModuleSet()->getRetBlock(inst)==nullptr && "duplicate RetICFGNode");
     RetICFGNode* retICFGNode = new RetICFGNode(icfg->totalICFGNode++, svfInst, callICFGNode);
     callICFGNode->setRetICFGNode(retICFGNode);
     icfg->addICFGNode(retICFGNode);
     csToRetNodeMap()[inst] = retICFGNode;
+    llvmModuleSet()->setValueAttr(inst, retICFGNode);
 
     addICFGInterEdges(inst, LLVMUtil::getCallee(SVFUtil::cast<CallBase>(inst)));    //creating interprocedural edges
     return callICFGNode;
@@ -329,9 +333,12 @@ IntraICFGNode* ICFGBuilder::addIntraBlockICFGNode(const Instruction* inst)
         llvmModuleSet()->getSVFInstruction(inst);
     IntraICFGNode* node = llvmModuleSet()->getIntraBlock(inst);
     assert (node==nullptr && "no IntraICFGNode for this instruction?");
-    IntraICFGNode* sNode = new IntraICFGNode(icfg->totalICFGNode++,svfInst);
+    IntraICFGNode* sNode =
+        new IntraICFGNode(icfg->totalICFGNode++, svfInst->getParent(),
+                          SVFUtil::isa<ReturnInst>(inst));
     icfg->addICFGNode(sNode);
     instToBlockNodeMap()[inst] = sNode;
+    llvmModuleSet()->setValueAttr(inst, sNode);
     return sNode;
 }
 

package/svf-llvm/lib/LLVMModule.cpp

@@ -1230,6 +1230,12 @@ void LLVMModuleSet::setValueAttr(const Value* val, SVFValue* svfvalue)
     svfvalue->setSourceLoc(LLVMUtil::getSourceLoc(val));
 }
 
+void LLVMModuleSet::setValueAttr(const SVF::Value* val, SVF::SVFBaseNode* svfBaseNode)
+{
+    SVFBaseNode2LLVMValue[svfBaseNode] = val;
+    svfBaseNode->setSourceLoc(LLVMUtil::getSourceLoc(val));
+}
+
 SVFConstantData* LLVMModuleSet::getSVFConstantData(const ConstantData* cd)
 {
     LLVMConst2SVFConstMap::const_iterator it = LLVMConst2SVFConst.find(cd);