svf-tools 1.0.1042 → 1.0.1043

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.1042",
+  "version": "1.0.1043",
   "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/svf/include/AE/Svfexe/AbstractInterpretation.h

@@ -251,8 +251,8 @@ private:
     AEStat* stat;
 
     std::vector<const CallICFGNode*> callSiteStack;
-    Map<const SVFFunction*, ICFGWTO*> funcToWTO;
-    Set<const SVFFunction*> recursiveFuns;
+    Map<const FunObjVar*, ICFGWTO*> funcToWTO;
+    Set<const FunObjVar*> recursiveFuns;
 
 
     AbstractState& getAbsStateFromTrace(const ICFGNode* node)

package/svf/include/CFL/CFLAlias.h

@@ -135,7 +135,7 @@ public:
     virtual void onTheFlyCallGraphSolve(const CallSiteToFunPtrMap& callsites, CallEdgeMap& newEdges);
 
     /// Connect formal and actual parameters for indirect callsites
-    void connectCaller2CalleeParams(const CallICFGNode* cs, const SVFFunction* F);
+    void connectCaller2CalleeParams(const CallICFGNode* cs, const FunObjVar* F);
 
     void heapAllocatorViaIndCall(const CallICFGNode* cs);
 

package/svf/include/DDA/ContextDDA.h

@@ -110,7 +110,7 @@ public:
     virtual bool isHeapCondMemObj(const CxtVar& var, const StoreSVFGNode* store) override;
 
     /// refine indirect call edge
-    bool testIndCallReachability(CxtLocDPItem& dpm, const SVFFunction* callee, const CallICFGNode* cs);
+    bool testIndCallReachability(CxtLocDPItem& dpm, const FunObjVar* callee, const CallICFGNode* cs);
 
     /// get callsite id from call, return 0 if it is a spurious call edge
     CallSiteID getCSIDAtCall(CxtLocDPItem& dpm, const SVFGEdge* edge);
@@ -133,8 +133,8 @@ public:
     /// Whether call/return inside recursion
     inline virtual bool isEdgeInRecursion(CallSiteID csId)
     {
-        const SVFFunction* caller = getCallGraph()->getCallerOfCallSite(csId);
-        const SVFFunction* callee = getCallGraph()->getCalleeOfCallSite(csId);
+        const FunObjVar* caller = getCallGraph()->getCallerOfCallSite(csId);
+        const FunObjVar* callee = getCallGraph()->getCalleeOfCallSite(csId);
         return inSameCallGraphSCC(caller, callee);
     }
     /// Update call graph.
@@ -149,7 +149,7 @@ public:
             const FunctionSet & functions = iter->second;
             for (FunctionSet::const_iterator func_iter = functions.begin(); func_iter != functions.end(); func_iter++)
             {
-                const SVFFunction*  func = *func_iter;
+                const FunObjVar*  func = *func_iter;
                 getSVFG()->connectCallerAndCallee(newcs, func, svfgEdges);
             }
         }
@@ -159,8 +159,8 @@ public:
     /// Return TRUE if this edge is inside a SVFG SCC, i.e., src node and dst node are in the same SCC on the SVFG.
     inline bool edgeInCallGraphSCC(const SVFGEdge* edge)
     {
-        const SVFFunction* srcfun = edge->getSrcNode()->getFun();
-        const SVFFunction* dstfun = edge->getDstNode()->getFun();
+        const FunObjVar* srcfun = edge->getSrcNode()->getFun();
+        const FunObjVar* dstfun = edge->getDstNode()->getFun();
 
         if(srcfun && dstfun)
             return inSameCallGraphSCC(srcfun,dstfun);

package/svf/include/DDA/DDAVFSolver.h

@@ -475,7 +475,7 @@ protected:
         assert(baseObj && "base object is null??");
         if(SVFUtil::isa<StackObjVar>(baseObj))
         {
-            if(const SVFFunction* svffun = _pag->getGNode(id)->getFunction())
+            if(const FunObjVar* svffun = _pag->getGNode(id)->getFunction())
             {
                 return _callGraphSCC->isInCycle(_callGraph->getCallGraphNode(svffun)->getId());
             }
@@ -501,7 +501,7 @@ protected:
                 findPT(funPtrDpm);
             }
         }
-        else if(const SVFFunction* fun = getSVFG()->isFunEntrySVFGNode(dpm.getLoc()))
+        else if(const FunObjVar* fun = getSVFG()->isFunEntrySVFGNode(dpm.getLoc()))
         {
             CallInstSet csSet;
             /// use pre-analysis call graph to approximate all potential callsites

package/svf/include/DDA/FlowDDA.h

@@ -80,7 +80,7 @@ public:
     virtual bool handleBKCondition(LocDPItem& dpm, const SVFGEdge* edge) override;
 
     /// refine indirect call edge
-    bool testIndCallReachability(LocDPItem& dpm, const SVFFunction* callee, CallSiteID csId);
+    bool testIndCallReachability(LocDPItem& dpm, const FunObjVar* callee, CallSiteID csId);
 
     /// Initialization of the analysis
     inline virtual void initialize() override
@@ -142,7 +142,7 @@ public:
             const FunctionSet & functions = iter->second;
             for (FunctionSet::const_iterator func_iter = functions.begin(); func_iter != functions.end(); func_iter++)
             {
-                const SVFFunction* func = *func_iter;
+                const FunObjVar* func = *func_iter;
                 getSVFG()->connectCallerAndCallee(newcs, func, svfgEdges);
             }
         }

package/svf/include/Graphs/BasicBlockG.h

@@ -39,7 +39,8 @@ namespace SVF
 class SVFBasicBlock;
 class BasicBlockEdge;
 class ICFGNode;
-class SVFFunction;
+class FunObjVar;
+
 typedef GenericEdge<SVFBasicBlock> GenericBasicBlockEdgeTy;
 class BasicBlockEdge: public GenericBasicBlockEdgeTy
 {
@@ -75,7 +76,7 @@ class SVFBasicBlock : public GenericBasicBlockNodeTy
     friend class SVFIRWriter;
     friend class SVFIRReader;
     friend class SVFIRBuilder;
-    friend class SVFFunction;
+    friend class FunObjVar;
     friend class ICFGBuilder;
     friend class ICFG;
 
@@ -86,7 +87,7 @@ public:
 
 private:
     std::vector<const ICFGNode*> allICFGNodes;    ///< all ICFGNodes in this BasicBlock
-    const SVFFunction* fun;                 /// Function where this BasicBlock is
+    const FunObjVar* fun;                 /// Function where this BasicBlock is
 
 
 
@@ -104,7 +105,7 @@ protected:
 
 public:
     /// Constructor without name
-    SVFBasicBlock(NodeID id, const SVFFunction* f): GenericBasicBlockNodeTy(id, BasicBlockKd), fun(f)
+    SVFBasicBlock(NodeID id, const FunObjVar* f): GenericBasicBlockNodeTy(id, BasicBlockKd), fun(f)
     {
 
     }
@@ -148,6 +149,12 @@ public:
         return allICFGNodes.end();
     }
 
+
+    inline void setFun(const FunObjVar* f)
+    {
+        fun = f;
+    }
+
     inline void addSuccBasicBlock(const SVFBasicBlock* succ2)
     {
         // check if the edge already exists
@@ -181,13 +188,15 @@ public:
         pred->succBBs.push_back(this);
     }
 
-    inline const SVFFunction* getParent() const
+    inline const FunObjVar* getParent() const
     {
+        assert(fun && "Function is null?");
         return fun;
     }
 
-    inline const SVFFunction* getFunction() const
+    inline const FunObjVar* getFunction() const
     {
+        assert(fun && "Function is null?");
         return fun;
     }
 
@@ -287,10 +296,9 @@ class BasicBlockGraph: public GenericBasicBlockGraphTy
 {
 private:
     NodeID id{0};
-    const SVFFunction* fun;
 public:
     /// Constructor
-    BasicBlockGraph(const SVFFunction* f): fun(f)
+    BasicBlockGraph()
     {
 
     }
@@ -298,7 +306,7 @@ public:
     SVFBasicBlock* addBasicBlock(const std::string& bbname)
     {
         id++;
-        SVFBasicBlock* bb = new SVFBasicBlock(id, fun);
+        SVFBasicBlock* bb = new SVFBasicBlock(id, nullptr);
         addGNode(id, bb);
         bb->setName(bbname);
         return bb;

package/svf/include/Graphs/CHG.h

@@ -45,7 +45,7 @@ class CHNode;
 class GlobalObjVar;
 
 typedef Set<const GlobalObjVar*> VTableSet;
-typedef Set<const SVFFunction*> VFunSet;
+typedef Set<const FunObjVar*> VFunSet;
 
 /// Common base for class hierarchy graph. Only implements what PointerAnalysis needs.
 class CommonCHGraph
@@ -119,7 +119,7 @@ public:
         TEMPLATE = 0x04 // template class
     } CLASSATTR;
 
-    typedef std::vector<const SVFFunction*> FuncVector;
+    typedef std::vector<const FunObjVar*> FuncVector;
 
     CHNode (const std::string& name, NodeID i = 0, GNodeK k = CHNodeKd):
         GenericCHNodeTy(i, k), vtable(nullptr), className(name), flags(0)
@@ -267,18 +267,18 @@ public:
     void view();
     void printCH();
 
-    inline u32_t getVirtualFunctionID(const SVFFunction* vfn) const
+    inline u32_t getVirtualFunctionID(const FunObjVar* vfn) const
     {
-        Map<const SVFFunction*, u32_t>::const_iterator it =
+        Map<const FunObjVar*, u32_t>::const_iterator it =
             virtualFunctionToIDMap.find(vfn);
         if (it != virtualFunctionToIDMap.end())
             return it->second;
         else
             return -1;
     }
-    inline const SVFFunction* getVirtualFunctionBasedonID(u32_t id) const
+    inline const FunObjVar* getVirtualFunctionBasedonID(u32_t id) const
     {
-        Map<const SVFFunction*, u32_t>::const_iterator it, eit;
+        Map<const FunObjVar*, u32_t>::const_iterator it, eit;
         for (it = virtualFunctionToIDMap.begin(), eit =
                     virtualFunctionToIDMap.end(); it != eit; ++it)
         {
@@ -329,7 +329,7 @@ private:
     NameToCHNodesMap templateNameToInstancesMap;
     CallNodeToCHNodesMap callNodeToClassesMap;
 
-    Map<const SVFFunction*, u32_t> virtualFunctionToIDMap;
+    Map<const FunObjVar*, u32_t> virtualFunctionToIDMap;
 
     CallNodeToVTableSetMap callNodeToCHAVtblsMap;
     CallNodeToVFunSetMap callNodeToCHAVFnsMap;

package/svf/include/Graphs/CallGraph.h

@@ -168,6 +168,8 @@ public:
 
 };
 
+class FunObjVar;
+
 /*
  * Call Graph node representing a function
  */
@@ -175,22 +177,19 @@ typedef GenericNode<CallGraphNode, CallGraphEdge> GenericPTACallGraphNodeTy;
 class CallGraphNode : public GenericPTACallGraphNodeTy
 {
 private:
-    const SVFFunction* fun;
+    const FunObjVar* fun;
 
 public:
     /// Constructor
-    CallGraphNode(NodeID i, const SVFFunction* f) : GenericPTACallGraphNodeTy(i,CallNodeKd), fun(f)
+    CallGraphNode(NodeID i, const FunObjVar* f) : GenericPTACallGraphNodeTy(i,CallNodeKd), fun(f)
     {
 
     }
 
-    inline const std::string &getName() const
-    {
-        return fun->getName();
-    }
+    const std::string &getName() const;
 
     /// Get function of this call node
-    inline const SVFFunction* getFunction() const
+    inline const FunObjVar* getFunction() const
     {
         return fun;
     }
@@ -238,12 +237,12 @@ class CallGraph : public GenericPTACallGraphTy
 
 public:
     typedef CallGraphEdge::CallGraphEdgeSet CallGraphEdgeSet;
-    typedef Map<const SVFFunction*, CallGraphNode*> FunToCallGraphNodeMap;
+    typedef Map<const FunObjVar*, CallGraphNode*> FunToCallGraphNodeMap;
     typedef Map<const CallICFGNode*, CallGraphEdgeSet> CallInstToCallGraphEdgesMap;
-    typedef std::pair<const CallICFGNode*, const SVFFunction*> CallSitePair;
+    typedef std::pair<const CallICFGNode*, const FunObjVar*> CallSitePair;
     typedef Map<CallSitePair, CallSiteID> CallSiteToIdMap;
     typedef Map<CallSiteID, CallSitePair> IdToCallSiteMap;
-    typedef Set<const SVFFunction*> FunctionSet;
+    typedef Set<const FunObjVar*> FunctionSet;
     typedef OrderedMap<const CallICFGNode*, FunctionSet> CallEdgeMap;
     typedef CallGraphEdgeSet::iterator CallGraphEdgeIter;
     typedef CallGraphEdgeSet::const_iterator CallGraphEdgeConstIter;
@@ -275,9 +274,9 @@ protected:
 
 protected:
     /// Add CallSiteID
-    inline CallSiteID addCallSite(const CallICFGNode* cs, const SVFFunction* callee)
+    inline CallSiteID addCallSite(const CallICFGNode* cs, const FunObjVar* callee)
     {
-        std::pair<const CallICFGNode*, const SVFFunction*> newCS(std::make_pair(cs, callee));
+        std::pair<const CallICFGNode*, const FunObjVar*> newCS(std::make_pair(cs, callee));
         CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS);
         //assert(it == csToIdMap.end() && "cannot add a callsite twice");
         if(it == csToIdMap.end())
@@ -352,9 +351,9 @@ public:
     void verifyCallGraph();
 
     /// Add direct call edges
-    void addDirectCallGraphEdge(const CallICFGNode* call, const SVFFunction* callerFun, const SVFFunction* calleeFun);
+    void addDirectCallGraphEdge(const CallICFGNode* call, const FunObjVar* callerFun, const FunObjVar* calleeFun);
 
-    void addCallGraphNode(const SVFFunction* fun);
+    void addCallGraphNode(const FunObjVar* fun);
 
     /// Get call graph node
     //@{
@@ -365,7 +364,7 @@ public:
     {
         return getGNode(id);
     }
-    inline CallGraphNode* getCallGraphNode(const SVFFunction* fun) const
+    inline CallGraphNode* getCallGraphNode(const FunObjVar* fun) const
     {
         FunToCallGraphNodeMap::const_iterator it = funToCallGraphNodeMap.find(fun);
         assert(it!=funToCallGraphNodeMap.end() && "call graph node not found!!");
@@ -376,14 +375,14 @@ public:
 
     /// Get CallSiteID
     //@{
-    inline CallSiteID getCallSiteID(const CallICFGNode* cs, const SVFFunction* callee) const
+    inline CallSiteID getCallSiteID(const CallICFGNode* cs, const FunObjVar* callee) const
     {
         CallSitePair newCS(std::make_pair(cs, callee));
         CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS);
         assert(it != csToIdMap.end() && "callsite id not found! This maybe a partially resolved callgraph, please check the indCallEdge limit");
         return it->second;
     }
-    inline bool hasCallSiteID(const CallICFGNode* cs, const SVFFunction* callee) const
+    inline bool hasCallSiteID(const CallICFGNode* cs, const FunObjVar* callee) const
     {
         CallSitePair newCS(std::make_pair(cs, callee));
         CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS);
@@ -399,11 +398,8 @@ public:
     {
         return getCallSitePair(id).first;
     }
-    inline const SVFFunction* getCallerOfCallSite(CallSiteID id) const
-    {
-        return getCallSite(id)->getCaller();
-    }
-    inline const SVFFunction* getCalleeOfCallSite(CallSiteID id) const
+    const FunObjVar* getCallerOfCallSite(CallSiteID id) const;
+    inline const FunObjVar* getCalleeOfCallSite(CallSiteID id) const
     {
         return getCallSitePair(id).second;
     }
@@ -454,18 +450,18 @@ public:
 
     /// Add indirect call edges
     //@{
-    void addIndirectCallGraphEdge(const CallICFGNode* cs,const SVFFunction* callerFun, const SVFFunction* calleeFun);
+    void addIndirectCallGraphEdge(const CallICFGNode* cs,const FunObjVar* callerFun, const FunObjVar* calleeFun);
     //@}
 
     /// Get callsites invoking the callee
     //@{
-    void getAllCallSitesInvokingCallee(const SVFFunction* callee, CallGraphEdge::CallInstSet& csSet);
-    void getDirCallSitesInvokingCallee(const SVFFunction* callee, CallGraphEdge::CallInstSet& csSet);
-    void getIndCallSitesInvokingCallee(const SVFFunction* callee, CallGraphEdge::CallInstSet& csSet);
+    void getAllCallSitesInvokingCallee(const FunObjVar* callee, CallGraphEdge::CallInstSet& csSet);
+    void getDirCallSitesInvokingCallee(const FunObjVar* callee, CallGraphEdge::CallInstSet& csSet);
+    void getIndCallSitesInvokingCallee(const FunObjVar* callee, CallGraphEdge::CallInstSet& csSet);
     //@}
 
     /// Whether its reachable between two functions
-    bool isReachableBetweenFunctions(const SVFFunction* srcFn, const SVFFunction* dstFn) const;
+    bool isReachableBetweenFunctions(const FunObjVar* srcFn, const FunObjVar* dstFn) const;
 
     /// Dump the graph
     void dump(const std::string& filename);

package/svf/include/Graphs/ConsG.h

@@ -76,12 +76,12 @@ protected:
 
     /// Wrappers used internally, not expose to Andersen Pass
     //@{
-    inline NodeID getReturnNode(const SVFFunction* value) const
+    inline NodeID getReturnNode(const FunObjVar* value) const
     {
         return pag->getReturnNode(value);
     }
 
-    inline NodeID getVarargNode(const SVFFunction* value) const
+    inline NodeID getVarargNode(const FunObjVar* value) const
     {
         return pag->getVarargNode(value);
     }

package/svf/include/Graphs/ICFG.h

@@ -58,8 +58,8 @@ public:
     typedef ICFGNodeIDToNodeMapTy::iterator iterator;
     typedef ICFGNodeIDToNodeMapTy::const_iterator const_iterator;
 
-    typedef Map<const SVFFunction*, FunEntryICFGNode *> FunToFunEntryNodeMapTy;
-    typedef Map<const SVFFunction*, FunExitICFGNode *> FunToFunExitNodeMapTy;
+    typedef Map<const FunObjVar*, FunEntryICFGNode *> FunToFunEntryNodeMapTy;
+    typedef Map<const FunObjVar*, FunExitICFGNode *> FunToFunExitNodeMapTy;
     typedef std::vector<const SVFLoop *> SVFLoopVec;
     typedef Map<const ICFGNode *, SVFLoopVec> ICFGNodeToSVFLoopVec;
 
@@ -164,8 +164,8 @@ protected:
     /// sanitize Intra edges, verify that both nodes belong to the same function.
     inline void checkIntraEdgeParents(const ICFGNode *srcNode, const ICFGNode *dstNode)
     {
-        const SVFFunction* srcfun = srcNode->getFun();
-        const SVFFunction* dstfun = dstNode->getFun();
+        const FunObjVar* srcfun = srcNode->getFun();
+        const FunObjVar* dstfun = dstNode->getFun();
         if(srcfun != nullptr && dstfun != nullptr)
         {
             assert((srcfun == dstfun) && "src and dst nodes of an intra edge should in the same function!" );
@@ -182,7 +182,7 @@ protected:
 
     virtual inline CallICFGNode* addCallICFGNode(
         const SVFBasicBlock* bb, const SVFType* ty,
-        const SVFFunction* calledFunc, bool isVararg, bool isvcall,
+        const FunObjVar* calledFunc, bool isVararg, bool isvcall,
         s32_t vcallIdx, const std::string& funNameOfVcall)
     {
 
@@ -201,14 +201,14 @@ protected:
         return retICFGNode;
     }
 
-    virtual inline FunEntryICFGNode* addFunEntryICFGNode(const SVFFunction* svfFunc)
+    virtual inline FunEntryICFGNode* addFunEntryICFGNode(const FunObjVar* svfFunc)
     {
         FunEntryICFGNode* sNode = new FunEntryICFGNode(totalICFGNode++,svfFunc);
         addICFGNode(sNode);
         return FunToFunEntryNodeMap[svfFunc] = sNode;
     }
 
-    virtual inline FunExitICFGNode* addFunExitICFGNode(const SVFFunction* svfFunc)
+    virtual inline FunExitICFGNode* addFunExitICFGNode(const FunObjVar* svfFunc)
     {
         FunExitICFGNode* sNode = new FunExitICFGNode(totalICFGNode++, svfFunc);
         addICFGNode(sNode);
@@ -229,9 +229,9 @@ public:
     //@{
 
 
-    FunEntryICFGNode* getFunEntryICFGNode(const SVFFunction*  fun);
+    FunEntryICFGNode* getFunEntryICFGNode(const FunObjVar*  fun);
 
-    FunExitICFGNode* getFunExitICFGNode(const SVFFunction*  fun);
+    FunExitICFGNode* getFunExitICFGNode(const FunObjVar*  fun);
 
     inline GlobalICFGNode* getGlobalICFGNode() const
     {
@@ -284,7 +284,7 @@ private:
     }
 
     /// Get/Add a function entry node
-    inline FunEntryICFGNode* getFunEntryBlock(const SVFFunction* fun)
+    inline FunEntryICFGNode* getFunEntryBlock(const FunObjVar* fun)
     {
         FunToFunEntryNodeMapTy::const_iterator it = FunToFunEntryNodeMap.find(fun);
         if (it == FunToFunEntryNodeMap.end())
@@ -293,7 +293,7 @@ private:
     }
 
     /// Get/Add a function exit node
-    inline FunExitICFGNode* getFunExitBlock(const SVFFunction* fun)
+    inline FunExitICFGNode* getFunExitBlock(const FunObjVar* fun)
     {
         FunToFunExitNodeMapTy::const_iterator it = FunToFunExitNodeMap.find(fun);
         if (it == FunToFunExitNodeMap.end())

package/svf/include/Graphs/ICFGNode.h

@@ -73,7 +73,7 @@ public:
     }
 
     /// Return the function of this ICFGNode
-    virtual const SVFFunction* getFun() const
+    virtual const FunObjVar* getFun() const
     {
         return fun;
     }
@@ -145,7 +145,7 @@ public:
 
 
 protected:
-    const SVFFunction* fun;
+    const FunObjVar* fun;
     const SVFBasicBlock* bb;
     VFGNodeList VFGNodes; //< a list of VFGNodes
     SVFStmtList pagEdges; //< a list of PAGEdges
@@ -289,10 +289,10 @@ private:
     FunEntryICFGNode(NodeID id) : InterICFGNode(id, FunEntryBlock) {}
 
 public:
-    FunEntryICFGNode(NodeID id, const SVFFunction* f);
+    FunEntryICFGNode(NodeID id, const FunObjVar* f);
 
     /// Return function
-    inline const SVFFunction* getFun() const override
+    inline const FunObjVar* getFun() const override
     {
         return fun;
     }
@@ -339,10 +339,7 @@ public:
 
     const std::string toString() const override;
 
-    const std::string getSourceLoc() const override
-    {
-        return "function entry: " + fun->getSourceLoc();
-    }
+    const std::string getSourceLoc() const override;
 };
 
 /*!
@@ -360,10 +357,10 @@ private:
     FunExitICFGNode(NodeID id) : InterICFGNode(id, FunExitBlock), formalRet{} {}
 
 public:
-    FunExitICFGNode(NodeID id, const SVFFunction* f);
+    FunExitICFGNode(NodeID id, const FunObjVar* f);
 
     /// Return function
-    inline const SVFFunction* getFun() const override
+    inline const FunObjVar* getFun() const override
     {
         return fun;
     }
@@ -410,10 +407,7 @@ public:
 
     const std::string toString() const override;
 
-    const std::string getSourceLoc() const override
-    {
-        return "function ret: " + fun->getSourceLoc();
-    }
+    const std::string getSourceLoc() const override;
 };
 
 /*!
@@ -430,7 +424,7 @@ public:
 protected:
     const RetICFGNode* ret;
     ActualParmNodeVec APNodes;      /// arguments
-    const SVFFunction* calledFunc;  /// called function
+    const FunObjVar* calledFunc;  /// called function
     bool isvararg;                  /// is variable argument
     bool isVirCallInst;             /// is virtual call inst
     SVFVar* vtabPtr;                /// virtual table pointer
@@ -442,7 +436,7 @@ protected:
 
 public:
     CallICFGNode(NodeID id, const SVFBasicBlock* b, const SVFType* ty,
-                 const SVFFunction* cf, bool iv, bool ivc, s32_t vfi,
+                 const FunObjVar* cf, bool iv, bool ivc, s32_t vfi,
                  const std::string& fnv)
         : InterICFGNode(id, FunCallBlock), ret(nullptr), calledFunc(cf),
           isvararg(iv), isVirCallInst(ivc), vtabPtr(nullptr),
@@ -467,7 +461,7 @@ public:
     }
 
     /// Return callsite
-    inline const SVFFunction* getCaller() const
+    inline const FunObjVar* getCaller() const
     {
         return getFun();
     }
@@ -515,7 +509,7 @@ public:
     {
         return arg_size();
     }
-    inline const SVFFunction* getCalledFunction() const
+    inline const FunObjVar* getCalledFunction() const
     {
         return calledFunc;
     }

package/svf/include/Graphs/IRGraph.h

@@ -52,6 +52,7 @@ class IRGraph : public GenericGraph<SVFVar, SVFStmt>
 {
     friend class SVFIRWriter;
     friend class SVFIRReader;
+    friend class SVFIRBuilder;
     friend class SymbolTableBuilder;
 
 public:
@@ -75,14 +76,15 @@ public:
     typedef OrderedMap<NodeID, ObjTypeInfo*> IDToTypeInfoMapTy;
 
     /// function to sym id map
-    typedef OrderedMap<const SVFFunction*, NodeID> FunToIDMapTy;
+    typedef OrderedMap<const FunObjVar*, NodeID> FunObjVarToIDMapTy;
+
     /// struct type to struct info map
     typedef Set<const SVFType*> SVFTypeSet;
     //@}
 
 private:
-    FunToIDMapTy returnSymMap; ///< return map
-    FunToIDMapTy varargSymMap; ///< vararg map
+    FunObjVarToIDMapTy returnFunObjSymMap; ///< return map
+    FunObjVarToIDMapTy varargFunObjSymMap; ///< vararg map
     IDToTypeInfoMapTy objTypeInfoMap;       ///< map a memory sym id to its obj
 
     /// (owned) All SVF Types
@@ -217,14 +219,14 @@ public:
         return objTypeInfoMap;
     }
 
-    inline FunToIDMapTy& retSyms()
+    inline FunObjVarToIDMapTy& retFunObjSyms()
     {
-        return returnSymMap;
+        return returnFunObjSymMap;
     }
 
-    inline FunToIDMapTy& varargSyms()
+    inline FunObjVarToIDMapTy& varargFunObjSyms()
     {
-        return varargSymMap;
+        return varargFunObjSymMap;
     }
 
     //@}
@@ -237,10 +239,10 @@ public:
     }
 
     /// GetReturnNode - Return the unique node representing the return value of a function
-    NodeID getReturnNode(const SVFFunction* func) const;
+    NodeID getReturnNode(const FunObjVar*func) const;
 
     /// getVarargNode - Return the unique node representing the variadic argument of a variadic function.
-    NodeID getVarargNode(const SVFFunction* func) const;
+    NodeID getVarargNode(const FunObjVar*func) const;
 
     inline NodeID getBlackHoleNode() const
     {