remove all SVFFunction in svf

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

@@ -50,10 +50,9 @@ class LLVMModuleSet
 public:
 
     typedef std::vector<const Function*> FunctionSetType;
-    typedef Map<const Function*, const Function*> FunDeclToDefMapTy;
-    typedef Map<const Function*, FunctionSetType> FunDefToDeclsMapTy;
     typedef Map<const GlobalVariable*, GlobalVariable*> GlobalDefToRepMapTy;
 
+    typedef Map<const CallGraphNode*, SVFFunction*> CGN2SVFFunMap;
     typedef Map<const Function*, SVFFunction*> LLVMFun2SVFFunMap;
     typedef Map<const Function*, CallGraphNode*> LLVMFun2CallGraphNodeMap;
     typedef Map<const BasicBlock*, SVFBasicBlock*> LLVMBB2SVFBBMap;
@@ -113,6 +112,7 @@ class LLVMModuleSet
     FunToFunEntryNodeMapTy FunToFunEntryNodeMap; ///< map a function to its FunExitICFGNode
     FunToFunExitNodeMapTy FunToFunExitNodeMap; ///< map a function to its FunEntryICFGNode
     CallGraph* callgraph;
+    CGN2SVFFunMap CallGraphNode2SVFFunMap;
 
     Map<const Function*, DominatorTree> FunToDominatorTree;
 
@@ -218,7 +218,7 @@ class LLVMModuleSet
         setValueAttr(func,svfFunc);
     }
 
-    void addFunctionMap(const Function* func, CallGraphNode* svfFunc);
+    void addFunctionMap(const Function* func, CallGraphNode* node);
 
     // create a SVFBasicBlock according to LLVM BasicBlock, then add it to SVFFunction's BasicBlockGraph
     inline void addBasicBlock(SVFFunction* fun, const BasicBlock* bb)
@@ -366,6 +366,22 @@ class LLVMModuleSet
         return nullptr;
     }
 
+    inline const CallGraphNode* getFunctionNode(const std::string& name)
+    {
+        Function* fun = nullptr;
+
+        for (u32_t i = 0; i < llvmModuleSet->getModuleNum(); ++i)
+        {
+            Module* mod = llvmModuleSet->getModule(i);
+            fun = mod->getFunction(name);
+            if (fun)
+            {
+                return llvmModuleSet->getCallGraphNode(fun);
+            }
+        }
+        return nullptr;
+    }
+
     ICFGNode* getICFGNode(const Instruction* inst);
 
     bool hasICFGNode(const Instruction* inst);

svf-llvm/include/SVF-LLVM/SVFIRBuilder.h

@@ -102,13 +102,13 @@ class SVFIRBuilder: public llvm::InstVisitor<SVFIRBuilder>
     }
 
     /// getReturnNode - Return the node representing the unique return value of a function.
-    inline NodeID getReturnNode(const SVFFunction *func)
+    inline NodeID getReturnNode(const CallGraphNode *func)
     {
         return pag->getReturnNode(func);
     }
 
     /// getVarargNode - Return the node representing the unique variadic argument of a function.
-    inline NodeID getVarargNode(const SVFFunction *func)
+    inline NodeID getVarargNode(const CallGraphNode *func)
     {
         return pag->getVarargNode(func);
     }
@@ -234,7 +234,7 @@ class SVFIRBuilder: public llvm::InstVisitor<SVFIRBuilder>
     //@{
     virtual const Type *getBaseTypeAndFlattenedFields(const Value *V, std::vector<AccessPath> &fields, const Value* szValue);
     virtual void addComplexConsForExt(Value *D, Value *S, const Value* sz);
-    virtual void handleExtCall(const CallBase* cs, const SVFFunction* svfCallee);
+    virtual void handleExtCall(const CallBase* cs, const CallGraphNode* svfCallee);
     //@}
 
     /// Set current basic block in order to keep track of control flow information

svf-llvm/lib/CHGBuilder.cpp

@@ -539,7 +539,7 @@
                     {
                         for (int i = 0; i < null_ptr_num; ++i)
                         {
-                            const SVFFunction* fun = virtualFunctions[i];
+                            const CallGraphNode* fun = virtualFunctions[i];
                             virtualFunctions.insert(virtualFunctions.begin(), fun);
                         }
                     }
@@ -607,15 +607,15 @@
         /*
          * get all virtual functions in a specific group
          */
-        set<const SVFFunction*> virtualFunctions;
+        set<const CallGraphNode*> virtualFunctions;
         for (CHGraph::CHNodeSetTy::iterator it = group.begin(),
                 eit = group.end(); it != eit; ++it)
         {
             const vector<CHNode::FuncVector> &vecs = (*it)->getVirtualFunctionVectors();
             for (vector<CHNode::FuncVector>::const_iterator vit = vecs.begin(),
                     veit = vecs.end(); vit != veit; ++vit)
             {
-                for (vector<const SVFFunction*>::const_iterator fit = (*vit).begin(),
+                for (vector<const CallGraphNode*>::const_iterator fit = (*vit).begin(),
                         feit = (*vit).end(); fit != feit; ++fit)
                 {
                     virtualFunctions.insert(*fit);
@@ -638,15 +638,15 @@
          * <~C, C::~C>
          * ...
          */
-        set<pair<string, const SVFFunction*> > fNameSet;
-        for (set<const SVFFunction*>::iterator fit = virtualFunctions.begin(),
+        set<pair<string, const CallGraphNode*> > fNameSet;
+        for (set<const CallGraphNode*>::iterator fit = virtualFunctions.begin(),
                 feit = virtualFunctions.end(); fit != feit; ++fit)
         {
-            const SVFFunction* f = *fit;
+            const CallGraphNode* f = *fit;
             struct DemangledName dname = demangle(f->getName());
-            fNameSet.insert(pair<string, const SVFFunction*>(dname.funcName, f));
+            fNameSet.insert(pair<string, const CallGraphNode*>(dname.funcName, f));
         }
-        for (set<pair<string, const SVFFunction*>>::iterator it = fNameSet.begin(),
+        for (set<pair<string, const CallGraphNode*>>::iterator it = fNameSet.begin(),
                 eit = fNameSet.end(); it != eit; ++it)
         {
             chg->virtualFunctionToIDMap[it->second] = chg->vfID++;
@@ -742,15 +742,15 @@
     {
         if (const auto* tf = cppUtil::getThunkTarget(lf))
         {
-            SVFFunction* pFunction =
-                llvmModuleSet()->getSVFFunction(tf);
+            CallGraphNode* pFunction =
+                llvmModuleSet()->getCallGraphNode(tf);
             v.push_back(pFunction);
         }
     }
     else
     {
-        SVFFunction* pFunction =
-            llvmModuleSet()->getSVFFunction(lf);
+        CallGraphNode* pFunction =
+            llvmModuleSet()->getCallGraphNode(lf);
         v.push_back(pFunction);
     }
 }

svf-llvm/lib/DCHG.cpp

@@ -640,7 +640,7 @@
                  */
                 if (funName.size() == 0)
                 {
-                    virtualFunctions.insert(LLVMUtil::getFunction(callee->getName().str()));
+                    virtualFunctions.insert(LLVMUtil::getFunction(callee->getName().str())->getCallGraphNode());
                 }
                 else if (funName[0] == '~')
                 {
@@ -656,7 +656,7 @@
                      */
                     if (calleeName[0] == '~')
                     {
-                        virtualFunctions.insert(LLVMUtil::getFunction(callee->getName().str()));
+                        virtualFunctions.insert(LLVMUtil::getFunction(callee->getName().str())->getCallGraphNode());
                     }
                 }
                 else
@@ -667,7 +667,7 @@
                      */
                     if (funName.compare(calleeName) == 0)
                     {
-                        virtualFunctions.insert(LLVMUtil::getFunction(callee->getName().str()));
+                        virtualFunctions.insert(LLVMUtil::getFunction(callee->getName().str())->getCallGraphNode());
                     }
                 }
             }

svf-llvm/lib/ICFGBuilder.cpp

@@ -241,16 +241,11 @@ InterICFGNode* ICFGBuilder::addInterBlockICFGNode(const Instruction* inst)
     assert(llvmModuleSet()->getCallBlock(inst)==nullptr && "duplicate CallICFGNode");
     const CallBase* cb = SVFUtil::dyn_cast<CallBase>(inst);
     bool isvcall = cppUtil::isVirtualCallSite(cb);
-    SVFFunction* calledFunc = nullptr;
+    const CallGraphNode* calledFunc = nullptr;
     auto called_llvmval = cb->getCalledOperand()->stripPointerCasts();
     if (const Function* called_llvmfunc = SVFUtil::dyn_cast<Function>(called_llvmval))
     {
-        calledFunc = llvmModuleSet()->getSVFFunction(called_llvmfunc);
-    }
-    else
-    {
-        calledFunc = SVFUtil::dyn_cast<SVFFunction>(
-                         llvmModuleSet()->getSVFValue(called_llvmval));
+        calledFunc = llvmModuleSet()->getCallGraphNode(called_llvmfunc);
     }
 
     SVFBasicBlock* bb = llvmModuleSet()->getSVFBasicBlock(inst->getParent());
@@ -282,8 +277,8 @@ void ICFGBuilder::addICFGInterEdges(const Instruction* cs, const Function* calle
     /// direct call
     if(callee)
     {
-        SVFFunction* svfFun =
-            llvmModuleSet()->getSVFFunction(callee);
+        CallGraphNode* svfFun =
+            llvmModuleSet()->getCallGraphNode(callee);
         /// if this is an external function (no function body)
         if (SVFUtil::isExtCall(svfFun))
         {
@@ -352,11 +347,11 @@ IntraICFGNode* ICFGBuilder::addIntraBlockICFGNode(const Instruction* inst)
 FunEntryICFGNode* ICFGBuilder::addFunEntryBlock(const Function* fun)
 {
     return llvmModuleSet()->FunToFunEntryNodeMap[fun] =
-               icfg->addFunEntryICFGNode(llvmModuleSet()->getSVFFunction(fun));
+               icfg->addFunEntryICFGNode(llvmModuleSet()->getCallGraphNode(fun));
 }
 
 inline FunExitICFGNode* ICFGBuilder::addFunExitBlock(const Function* fun)
 {
     return llvmModuleSet()->FunToFunExitNodeMap[fun] =
-               icfg->addFunExitICFGNode(llvmModuleSet()->getSVFFunction(fun));
+               icfg->addFunExitICFGNode(llvmModuleSet()->getCallGraphNode(fun));
 }

svf-llvm/lib/LLVMLoopAnalysis.cpp

@@ -54,7 +54,7 @@ void LLVMLoopAnalysis::buildLLVMLoops(SVFModule *mod, ICFG* icfg)
         for (Module::const_iterator F = M.begin(), E = M.end(); F != E; ++F)
         {
             const Function* func = &*F;
-            const SVFFunction* svffun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(func);
+            const CallGraphNode* svffun = LLVMModuleSet::getLLVMModuleSet()->getCallGraphNode(func);
             if (func->isDeclaration()) continue;
             // do not analyze external call
             if (SVFUtil::isExtCall(svffun)) continue;

svf-llvm/lib/LLVMModule.cpp

@@ -91,6 +91,11 @@ LLVMModuleSet::~LLVMModuleSet()
         item.second = nullptr;
     }
 
+    for (auto& item : CallGraphNode2SVFFunMap){
+        delete item.second;
+    }
+
+
     for (auto& item: LLVMArgument2SVFArgument)
     {
         delete item.second;
@@ -182,27 +187,39 @@ void LLVMModuleSet::build()
     if (Options::SVFMain())
         addSVFMain();
 
+    CallGraphBuilder callGraphBuilder;
+    callgraph = callGraphBuilder.createSVFIRCallGraph();
+
     createSVFDataStructure();
     initSVFFunction();
 
+    for (auto& item : CallGraphNode2SVFFunMap)
+    {
+        CallGraphNode* callNode = const_cast<CallGraphNode*>(item.first);
+        SVFFunction* fun = item.second;
+        callNode->init(fun->getFunctionType(),
+                       fun->isUncalledFunction(),
+                       !(fun->hasReturn()),
+                       fun->isDeclaration(),
+                       fun->isIntrinsic(),
+                       fun->hasAddressTaken(),
+                       fun->isVarArg(),
+                       fun->getLoopAndDomInfo(),
+            const_cast<CallGraphNode*>(fun->getDefFunForMultipleModule()->getCallGraphNode()),
+                       const_cast<SVF::BasicBlockGraph*>(fun->getBasicBlockGraph()),
+                       fun->getArgsList(),
+                       fun->hasBasicBlock()?  const_cast<SVFBasicBlock*>(fun->getExitBB()) : nullptr
+        );
+    }
 
     ICFGBuilder icfgbuilder;
     icfg = icfgbuilder.build();
 
-    CallGraphBuilder callGraphBuilder;
-    callgraph = callGraphBuilder.buildSVFIRCallGraph(svfModule);
-    for (const auto& func : svfModule->getFunctionSet())
-    {
-        SVFFunction* svffunc = const_cast<SVFFunction*>(func);
-        svffunc->setCallGraphNode(callgraph->getCallGraphNode(func));
-    }
 
-    for (const auto& it : *callgraph)
-    {
-        addFunctionMap(
-            SVFUtil::cast<Function>(getLLVMValue(it.second->getFunction())),
-            it.second);
-    }
+
+    callGraphBuilder.addSVFIRCallGraphEdges(callgraph);
+
+
 }
 
 void LLVMModuleSet::createSVFDataStructure()
@@ -242,8 +259,8 @@ void LLVMModuleSet::createSVFDataStructure()
     // Store annotations of functions in extapi.bc
     for (const auto& pair : ExtFun2Annotations)
     {
-        const SVFFunction* svffun = getSVFFunction(pair.first);
-        ExtAPI::getExtAPI()->setExtFuncAnnotations(svffun, pair.second);
+        const CallGraphNode* funNode = getFunctionNode(pair.first);
+        ExtAPI::getExtAPI()->setExtFuncAnnotations(funNode, pair.second);
     }
 
     /// then traverse candidate sets
@@ -286,10 +303,19 @@ void LLVMModuleSet::createSVFFunction(const Function* func)
             getSVFType(func->getFunctionType())),
         func->isDeclaration(), LLVMUtil::isIntrinsicFun(func),
         func->hasAddressTaken(), func->isVarArg(), new SVFLoopAndDomInfo);
-    BasicBlockGraph* bbGraph = new BasicBlockGraph(svfFunc);
+    CallGraphNode* funcNode = callgraph->addCallGraphNode(getSVFType(func->getType()),
+                                                          SVFUtil::cast<SVFFunctionType>(
+                                                              getSVFType(func->getFunctionType())),
+                                                          func->isDeclaration(), LLVMUtil::isIntrinsicFun(func),
+                                                          func->hasAddressTaken(), func->isVarArg(), nullptr);
+    svfFunc->setCallGraphNode(funcNode);
+    BasicBlockGraph* bbGraph = new BasicBlockGraph(funcNode);
     svfFunc->setBasicBlockGraph(bbGraph);
-    svfModule->addFunctionSet(svfFunc);
+    svfModule->addFunctionSet(funcNode);
+    addFunctionMap(func, funcNode);
     addFunctionMap(func, svfFunc);
+    CallGraphNode2SVFFunMap[funcNode] = svfFunc;
+
 
     for (const Argument& arg : func->args())
     {
@@ -339,7 +365,7 @@ void LLVMModuleSet::initSVFFunction()
             SVFFunction* svffun = getSVFFunction(&f);
             initSVFBasicBlock(&f);
 
-            if (!SVFUtil::isExtCall(svffun))
+            if (!SVFUtil::isExtCall(svffun->getCallGraphNode()))
             {
                 initDomTree(svffun, &f);
             }
@@ -1294,10 +1320,10 @@ void LLVMModuleSet::dumpSymTable()
     SVFUtil::outs() << "}\n";
 }
 
-void LLVMModuleSet::addFunctionMap(const Function* func, CallGraphNode* svfFunc)
+void LLVMModuleSet::addFunctionMap(const Function* func, CallGraphNode* node)
 {
-    LLVMFunc2CallGraphNode[func] = svfFunc;
-    addToSVFVar2LLVMValueMap(func, svfFunc);
+    LLVMFunc2CallGraphNode[func] = node;
+    addToSVFVar2LLVMValueMap(func, node);
 }
 
 void LLVMModuleSet::setValueAttr(const Value* val, SVFValue* svfvalue)