svf-lib 1.0.2211 → 1.0.2213

package/SVF-linux/Release-build/include/MSSA/MemSSA.h

@@ -85,8 +85,8 @@ public:
     //@}
 
     /// Map from fun to its entry chi set and return mu set
-    typedef Map<const SVFFunction*, CHISet> FunToEntryChiSetMap;
-    typedef Map<const SVFFunction*, MUSet> FunToReturnMuSetMap;
+    typedef Map<const FunObjVar*, CHISet> FunToEntryChiSetMap;
+    typedef Map<const FunObjVar*, MUSet> FunToReturnMuSetMap;
 
     /// For phi insertion
     //@{
@@ -123,11 +123,11 @@ protected:
     MemSSAStat* stat;
 
     /// Create mu chi for candidate regions in a function
-    virtual void createMUCHI(const SVFFunction& fun);
+    virtual void createMUCHI(const FunObjVar& fun);
     /// Insert phi for candidate regions in a function
-    virtual void insertPHI(const SVFFunction& fun);
+    virtual void insertPHI(const FunObjVar& fun);
     /// SSA rename for a function
-    virtual void SSARename(const SVFFunction& fun);
+    virtual void SSARename(const FunObjVar& fun);
     /// SSA rename for a basic block
     virtual void SSARenameBB(const SVFBasicBlock& bb);
 private:
@@ -315,7 +315,7 @@ public:
         return mrGen;
     }
     /// We start from here
-    virtual void buildMemSSA(const SVFFunction& fun);
+    virtual void buildMemSSA(const FunObjVar& fun);
 
     /// Perform statistics
     void performStat();
@@ -357,20 +357,20 @@ public:
 
     /// Has function entry chi or return mu
     //@{
-    inline bool hasFuncEntryChi(const SVFFunction * fun) const
+    inline bool hasFuncEntryChi(const FunObjVar * fun) const
     {
         return (funToEntryChiSetMap.find(fun) != funToEntryChiSetMap.end());
     }
-    inline bool hasReturnMu(const SVFFunction * fun) const
+    inline bool hasReturnMu(const FunObjVar * fun) const
     {
         return (funToReturnMuSetMap.find(fun) != funToReturnMuSetMap.end());
     }
 
-    inline CHISet& getFuncEntryChiSet(const SVFFunction * fun)
+    inline CHISet& getFuncEntryChiSet(const FunObjVar * fun)
     {
         return funToEntryChiSetMap[fun];
     }
-    inline MUSet& getReturnMuSet(const SVFFunction * fun)
+    inline MUSet& getReturnMuSet(const FunObjVar * fun)
     {
         return funToReturnMuSetMap[fun];
     }

package/SVF-linux/Release-build/include/MTA/LockAnalysis.h

@@ -61,7 +61,7 @@ public:
     typedef Set<const ICFGNode*> InstSet;
     typedef InstSet CISpan;
     typedef Map<const ICFGNode*, CISpan>CILockToSpan;
-    typedef Set<const SVFFunction*> FunSet;
+    typedef Set<const FunObjVar*> FunSet;
     typedef Map<const ICFGNode*, InstSet> InstToInstSetMap;
     typedef Map<CxtStmt, ValDomain> CxtStmtToLockFlagMap;
     typedef FIFOWorkList<CxtStmt> CxtStmtWorkList;
@@ -192,7 +192,7 @@ public:
     //@}
 
     /// Return true if it is a candidate function
-    inline bool isLockCandidateFun(const SVFFunction* fun) const
+    inline bool isLockCandidateFun(const FunObjVar* fun) const
     {
         return lockcandidateFuncSet.find(fun)!=lockcandidateFuncSet.end();
     }
@@ -430,9 +430,9 @@ private:
     //@}
 
     /// Push calling context
-    void pushCxt(CallStrCxt& cxt, const CallICFGNode* call, const SVFFunction* callee);
+    void pushCxt(CallStrCxt& cxt, const CallICFGNode* call, const FunObjVar* callee);
     /// Match context
-    bool matchCxt(CallStrCxt& cxt, const CallICFGNode* call, const SVFFunction* callee);
+    bool matchCxt(CallStrCxt& cxt, const CallICFGNode* call, const FunObjVar* callee);
 
     /// Whether it is a lock site
     inline bool isTDFork(const ICFGNode* call)

package/SVF-linux/Release-build/include/MTA/MHP.h

@@ -46,7 +46,7 @@ class MHP
 {
 
 public:
-    typedef Set<const SVFFunction*> FunSet;
+    typedef Set<const FunObjVar*> FunSet;
     typedef FIFOWorkList<CxtThreadStmt> CxtThreadStmtWorkList;
     typedef Set<CxtThreadStmt> CxtThreadStmtSet;
     typedef Map<CxtThreadStmt,NodeBS> ThreadStmtToThreadInterleav;
@@ -55,7 +55,7 @@ public:
 
     typedef Set<CxtStmt> LockSpan;
 
-    typedef std::pair<const SVFFunction*,const SVFFunction*> FuncPair;
+    typedef std::pair<const FunObjVar*,const FunObjVar*> FuncPair;
     typedef Map<FuncPair, bool> FuncPairToBool;
 
     /// Constructor
@@ -83,7 +83,7 @@ public:
     }
 
     /// Whether the function is connected from main function in thread call graph
-    bool isConnectedfromMain(const SVFFunction* fun);
+    bool isConnectedfromMain(const FunObjVar* fun);
 
 //    LockSpan getSpanfromCxtLock(NodeID l);
     /// Interface to query whether two instructions may happen-in-parallel
@@ -202,12 +202,12 @@ private:
         return tct->getTCTNode(curTid)->isMultiforked();
     }
     /// Push calling context
-    inline void pushCxt(CallStrCxt& cxt, const CallICFGNode* call, const SVFFunction* callee)
+    inline void pushCxt(CallStrCxt& cxt, const CallICFGNode* call, const FunObjVar* callee)
     {
         tct->pushCxt(cxt,call,callee);
     }
     /// Match context
-    inline bool matchCxt(CallStrCxt& cxt, const CallICFGNode* call, const SVFFunction* callee)
+    inline bool matchCxt(CallStrCxt& cxt, const CallICFGNode* call, const FunObjVar* callee)
     {
         return tct->matchCxt(cxt,call,callee);
     }
@@ -342,7 +342,7 @@ public:
     {
         NodeID parentTid = tct->getParentThread(tid);
         const CxtThread& parentct = tct->getTCTNode(parentTid)->getCxtThread();
-        const SVFFunction* parentRoutine = tct->getStartRoutineOfCxtThread(parentct);
+        const FunObjVar* parentRoutine = tct->getStartRoutineOfCxtThread(parentct);
         return parentRoutine->getExitBB()->back();
     }
 
@@ -450,12 +450,12 @@ private:
     //@}
 
     /// Push calling context
-    inline void pushCxt(CallStrCxt& cxt, const CallICFGNode* call, const SVFFunction* callee)
+    inline void pushCxt(CallStrCxt& cxt, const CallICFGNode* call, const FunObjVar* callee)
     {
         tct->pushCxt(cxt,call,callee);
     }
     /// Match context
-    inline bool matchCxt(CallStrCxt& cxt, const CallICFGNode* call, const SVFFunction* callee)
+    inline bool matchCxt(CallStrCxt& cxt, const CallICFGNode* call, const FunObjVar* callee)
     {
         return tct->matchCxt(cxt,call,callee);
     }

package/SVF-linux/Release-build/include/MTA/TCT.h

@@ -157,13 +157,13 @@ public:
     typedef SVFLoopAndDomInfo::LoopBBs LoopBBs;
     typedef TCTEdge::ThreadCreateEdgeSet ThreadCreateEdgeSet;
     typedef ThreadCreateEdgeSet::iterator TCTNodeIter;
-    typedef Set<const SVFFunction*> FunSet;
+    typedef Set<const FunObjVar*> FunSet;
     typedef std::vector<const ICFGNode*> InstVec;
     typedef Set<const ICFGNode*> InstSet;
     typedef Set<const CallGraphNode*> PTACGNodeSet;
     typedef Map<CxtThread,TCTNode*> CxtThreadToNodeMap;
     typedef Map<CxtThread,CallStrCxt> CxtThreadToForkCxt;
-    typedef Map<CxtThread,const SVFFunction*> CxtThreadToFun;
+    typedef Map<CxtThread,const FunObjVar*> CxtThreadToFun;
     typedef Map<const ICFGNode*, LoopBBs> InstToLoopMap;
     typedef FIFOWorkList<CxtThreadProc> CxtThreadProcVec;
     typedef Set<CxtThreadProc> CxtThreadProcSet;
@@ -298,7 +298,7 @@ public:
         }
         return false;
     }
-    inline bool isCandidateFun(const SVFFunction* fun) const
+    inline bool isCandidateFun(const FunObjVar* fun) const
     {
         return candidateFuncSet.find(fun)!=candidateFuncSet.end();
     }
@@ -374,7 +374,7 @@ public:
     }
 
     /// get the start routine function of a thread
-    const SVFFunction* getStartRoutineOfCxtThread(const CxtThread& ct) const
+    const FunObjVar* getStartRoutineOfCxtThread(const CxtThread& ct) const
     {
         CxtThreadToFun::const_iterator it = ctToRoutineFunMap.find(ct);
         assert(it!=ctToRoutineFunMap.end() && "Cxt Thread not found!!");
@@ -399,7 +399,7 @@ public:
 
     bool hasLoop(const SVFBasicBlock* bb) const
     {
-        const SVFFunction* fun = bb->getFunction();
+        const FunObjVar* fun = bb->getFunction();
         return fun->hasLoopInfo(bb);
     }
     bool hasLoop(const ICFGNode* inst) const
@@ -414,9 +414,9 @@ public:
     const LoopBBs& getLoop(const SVFBasicBlock* bb);
 
     /// Push calling context
-    void pushCxt(CallStrCxt& cxt, const CallICFGNode* call, const SVFFunction* callee);
+    void pushCxt(CallStrCxt& cxt, const CallICFGNode* call, const FunObjVar* callee);
     /// Match context
-    bool matchCxt(CallStrCxt& cxt, const CallICFGNode* call, const SVFFunction* callee);
+    bool matchCxt(CallStrCxt& cxt, const CallICFGNode* call, const FunObjVar* callee);
 
     inline void pushCxt(CallStrCxt& cxt, CallSiteID csId)
     {
@@ -477,7 +477,7 @@ private:
     /// Mark relevant procedures that are backward reachable from any fork/join site
     //@{
     void markRelProcs();
-    void markRelProcs(const SVFFunction* fun);
+    void markRelProcs(const FunObjVar* fun);
     //@}
 
     /// Get entry functions that are neither called by other functions nor extern functions
@@ -510,7 +510,7 @@ private:
 
     /// Get or create a tct node based on CxtThread
     //@{
-    inline TCTNode* getOrCreateTCTNode(const CallStrCxt& cxt, const ICFGNode* fork,const CallStrCxt& oldCxt, const SVFFunction* routine)
+    inline TCTNode* getOrCreateTCTNode(const CallStrCxt& cxt, const ICFGNode* fork,const CallStrCxt& oldCxt, const FunObjVar* routine)
     {
         CxtThread ct(cxt,fork);
         CxtThreadToNodeMap::const_iterator it = ctpToNodeMap.find(ct);
@@ -551,7 +551,7 @@ private:
         ctToForkCxtMap[ct] = cxt;
     }
     /// Add start routine function of a cxt thread
-    void addStartRoutineOfCxtThread(const SVFFunction* fun, const CxtThread& ct)
+    void addStartRoutineOfCxtThread(const FunObjVar* fun, const CxtThread& ct)
     {
         ctToRoutineFunMap[ct] = fun;
     }

package/SVF-linux/Release-build/include/MemoryModel/PointerAnalysis.h

@@ -101,11 +101,11 @@ public:
     //@{
     typedef Set<const CallICFGNode*> CallSiteSet;
     typedef SVFIR::CallSiteToFunPtrMap CallSiteToFunPtrMap;
-    typedef Set<const SVFFunction*> FunctionSet;
+    typedef Set<const FunObjVar*> FunctionSet;
     typedef OrderedMap<const CallICFGNode*, FunctionSet> CallEdgeMap;
     typedef SCCDetection<CallGraph*> CallGraphSCC;
     typedef Set<const GlobalObjVar*> VTableSet;
-    typedef Set<const SVFFunction*> VFunSet;
+    typedef Set<const FunObjVar*> VFunSet;
     //@}
 
     static const std::string aliasTestMayAlias;
@@ -396,13 +396,13 @@ public:
         return callGraphSCC->repNode(id);
     }
     /// Return TRUE if this edge is inside a PTACallGraph SCC, i.e., src node and dst node are in the same SCC on the SVFG.
-    inline bool inSameCallGraphSCC(const SVFFunction* fun1,const SVFFunction* fun2)
+    inline bool inSameCallGraphSCC(const FunObjVar* fun1,const FunObjVar* fun2)
     {
         const CallGraphNode* src = callgraph->getCallGraphNode(fun1);
         const CallGraphNode* dst = callgraph->getCallGraphNode(fun2);
         return (getCallGraphSCCRepNode(src->getId()) == getCallGraphSCCRepNode(dst->getId()));
     }
-    inline bool isInRecursion(const SVFFunction* fun) const
+    inline bool isInRecursion(const FunObjVar* fun) const
     {
         return callGraphSCC->isInCycle(callgraph->getCallGraphNode(fun)->getId());
     }

package/SVF-linux/Release-build/include/SABER/DoubleFreeChecker.h

@@ -67,8 +67,8 @@ public:
 
     /// Validate test cases for regression test purpose
     void testsValidation(ProgSlice* slice);
-    void validateSuccessTests(ProgSlice* slice, const SVFFunction* fun);
-    void validateExpectedFailureTests(ProgSlice* slice, const SVFFunction* fun);
+    void validateSuccessTests(ProgSlice* slice, const FunObjVar* fun);
+    void validateExpectedFailureTests(ProgSlice* slice, const FunObjVar* fun);
 };
 
 } // End namespace SVF

package/SVF-linux/Release-build/include/SABER/FileChecker.h

@@ -62,12 +62,12 @@ public:
         return false;
     }
 
-    inline bool isSourceLikeFun(const SVFFunction* fun)
+    inline bool isSourceLikeFun(const FunObjVar* fun)
     {
         return SaberCheckerAPI::getCheckerAPI()->isFOpen(fun);
     }
     /// Whether the function is a heap deallocator (free/release memory)
-    inline bool isSinkLikeFun(const SVFFunction* fun)
+    inline bool isSinkLikeFun(const FunObjVar* fun)
     {
         return SaberCheckerAPI::getCheckerAPI()->isFClose(fun);
     }

package/SVF-linux/Release-build/include/SABER/LeakChecker.h

@@ -78,12 +78,12 @@ public:
     virtual void initSrcs() override;
     virtual void initSnks() override;
     /// Whether the function is a heap allocator/reallocator (allocate memory)
-    virtual inline bool isSourceLikeFun(const SVFFunction* fun) override
+    virtual inline bool isSourceLikeFun(const FunObjVar* fun) override
     {
         return SaberCheckerAPI::getCheckerAPI()->isMemAlloc(fun);
     }
     /// Whether the function is a heap deallocator (free/release memory)
-    virtual inline bool isSinkLikeFun(const SVFFunction* fun) override
+    virtual inline bool isSinkLikeFun(const FunObjVar* fun) override
     {
         return SaberCheckerAPI::getCheckerAPI()->isMemDealloc(fun);
     }
@@ -97,8 +97,8 @@ protected:
 
     /// Validate test cases for regression test purpose
     void testsValidation(const ProgSlice* slice);
-    void validateSuccessTests(const SVFGNode* source, const SVFFunction* fun);
-    void validateExpectedFailureTests(const SVFGNode* source, const SVFFunction* fun);
+    void validateSuccessTests(const SVFGNode* source, const FunObjVar* fun);
+    void validateExpectedFailureTests(const SVFGNode* source, const FunObjVar* fun);
 
     /// Record a source to its callsite
     //@{

package/SVF-linux/Release-build/include/SABER/SaberCheckerAPI.h

@@ -32,6 +32,7 @@
 
 #include "Util/SVFUtil.h"
 #include "Graphs/ICFGNode.h"
+#include "SVFIR/SVFVariables.h" // add header
 
 namespace SVF
 {
@@ -73,7 +74,7 @@ private:
     static SaberCheckerAPI* ckAPI;
 
     /// Get the function type of a function
-    inline CHECKER_TYPE getType(const SVFFunction* F) const
+    inline CHECKER_TYPE getType(const FunObjVar* F) const
     {
         if(F)
         {
@@ -97,7 +98,7 @@ public:
 
     /// Return true if this call is a memory allocation
     //@{
-    inline bool isMemAlloc(const SVFFunction* fun) const
+    inline bool isMemAlloc(const FunObjVar* fun) const
     {
         return getType(fun) == CK_ALLOC;
     }
@@ -109,7 +110,7 @@ public:
 
     /// Return true if this call is a memory deallocation
     //@{
-    inline bool isMemDealloc(const SVFFunction* fun) const
+    inline bool isMemDealloc(const FunObjVar* fun) const
     {
         return getType(fun) == CK_FREE;
     }
@@ -121,7 +122,7 @@ public:
 
     /// Return true if this call is a file open
     //@{
-    inline bool isFOpen(const SVFFunction* fun) const
+    inline bool isFOpen(const FunObjVar* fun) const
     {
         return getType(fun) == CK_FOPEN;
     }
@@ -133,7 +134,7 @@ public:
 
     /// Return true if this call is a file close
     //@{
-    inline bool isFClose(const SVFFunction* fun) const
+    inline bool isFClose(const FunObjVar* fun) const
     {
         return getType(fun) == CK_FCLOSE;
     }

package/SVF-linux/Release-build/include/SABER/SaberCondAllocator.h

@@ -53,7 +53,7 @@ public:
     typedef Map<u32_t,Condition> CondPosMap;		///< map a branch to its Condition
     typedef Map<const SVFBasicBlock*, CondPosMap > BBCondMap;	/// map bb to a Condition
     typedef Set<const SVFBasicBlock*> BasicBlockSet;
-    typedef Map<const SVFFunction*,  BasicBlockSet> FunToExitBBsMap;  ///< map a function to all its basic blocks calling program exit
+    typedef Map<const FunObjVar*,  BasicBlockSet> FunToExitBBsMap;  ///< map a function to all its basic blocks calling program exit
     typedef Map<const SVFBasicBlock*, Condition> BBToCondMap;	///< map a basic block to its condition during control-flow guard computation
     typedef FIFOWorkList<const SVFBasicBlock*> CFWorkList;	///< worklist for control-flow guard computation
     typedef Map<const SVFGNode*, Set<const SVFGNode*>> SVFGNodeToSVFGNodeSetMap;
@@ -146,8 +146,8 @@ public:
 
     inline bool postDominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const
     {
-        const SVFFunction*  keyFunc = bbKey->getParent();
-        const SVFFunction*  valueFunc = bbValue->getParent();
+        const FunObjVar*  keyFunc = bbKey->getParent();
+        const FunObjVar*  valueFunc = bbValue->getParent();
         bool funcEq = (keyFunc == valueFunc);
         (void)funcEq; // Suppress warning of unused variable under release build
         assert(funcEq && "two basicblocks should be in the same function!");
@@ -156,8 +156,8 @@ public:
 
     inline bool dominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const
     {
-        const SVFFunction*  keyFunc = bbKey->getParent();
-        const SVFFunction*  valueFunc = bbValue->getParent();
+        const FunObjVar*  keyFunc = bbKey->getParent();
+        const FunObjVar*  valueFunc = bbValue->getParent();
         bool funcEq = (keyFunc == valueFunc);
         (void)funcEq; // Suppress warning of unused variable under release build
         assert(funcEq && "two basicblocks should be in the same function!");

package/SVF-linux/Release-build/include/SABER/SrcSnkDDA.h

@@ -174,12 +174,12 @@ public:
     ///@{
     virtual void initSrcs() = 0;
     virtual void initSnks() = 0;
-    virtual bool isSourceLikeFun(const SVFFunction* fun)
+    virtual bool isSourceLikeFun(const FunObjVar* fun)
     {
         return false;
     }
 
-    virtual bool isSinkLikeFun(const SVFFunction* fun)
+    virtual bool isSinkLikeFun(const FunObjVar* fun)
     {
         return false;
     }

package/SVF-linux/Release-build/include/SVF-LLVM/LLVMModule.h

@@ -55,6 +55,7 @@ public:
     typedef Map<const GlobalVariable*, GlobalVariable*> GlobalDefToRepMapTy;
 
     typedef Map<const Function*, SVFFunction*> LLVMFun2SVFFunMap;
+    typedef Map<const Function*, FunObjVar*> LLVMFun2FunObjVarMap;
     typedef Map<const BasicBlock*, SVFBasicBlock*> LLVMBB2SVFBBMap;
     typedef Map<const Instruction*, SVFInstruction*> LLVMInst2SVFInstMap;
     typedef Map<const Argument*, SVFArgument*> LLVMArgument2SVFArgumentMap;
@@ -76,12 +77,14 @@ public:
     /// local (%) and global (@) identifiers are pointer types which have a value node id.
     typedef OrderedMap<const SVFValue*, NodeID> ValueToIDMapTy;
 
+    typedef OrderedMap<const SVFFunction*, NodeID> FunToIDMapTy;
+
+
 private:
     static LLVMModuleSet* llvmModuleSet;
     static bool preProcessed;
     SVFIR* svfir;
     SVFModule* svfModule; ///< Borrowed from singleton SVFModule::svfModule
-    ICFG* icfg;
     std::unique_ptr<LLVMContext> owned_ctx;
     std::vector<std::unique_ptr<Module>> owned_modules;
     std::vector<std::reference_wrapper<Module>> modules;
@@ -90,10 +93,15 @@ private:
     FunctionSetType ExtFuncsVec;
     /// Record annotations of function in extapi.bc
     Fun2AnnoMap ExtFun2Annotations;
+
+    // Map SVFFunction to its annotations
+    Map<const SVFFunction*, std::vector<std::string>> func2Annotations;
+
     /// Global definition to a rep definition map
     GlobalDefToRepMapTy GlobalDefToRepMap;
 
     LLVMFun2SVFFunMap LLVMFunc2SVFFunc; ///< Map an LLVM Function to an SVF Function
+    LLVMFun2FunObjVarMap LLVMFun2FunObjVar; ///< Map an LLVM Function to an SVF Funobjvar
     LLVMBB2SVFBBMap LLVMBB2SVFBB;
     LLVMInst2SVFInstMap LLVMInst2SVFInst;
     LLVMArgument2SVFArgumentMap LLVMArgument2SVFArgument;
@@ -110,12 +118,13 @@ private:
     InstToBlockNodeMapTy InstToBlockNodeMap; ///< map a basic block to its ICFGNode
     FunToFunEntryNodeMapTy FunToFunEntryNodeMap; ///< map a function to its FunExitICFGNode
     FunToFunExitNodeMapTy FunToFunExitNodeMap; ///< map a function to its FunEntryICFGNode
-    CallGraph* callgraph;
 
     Map<const Function*, DominatorTree> FunToDominatorTree;
 
     ValueToIDMapTy valSymMap;  ///< map a value to its sym id
     ValueToIDMapTy objSymMap;  ///< map a obj reference to its sym id
+    FunToIDMapTy returnSymMap; ///< return map
+    FunToIDMapTy varargSymMap; ///< vararg map
 
     /// Constructor
     LLVMModuleSet();
@@ -299,6 +308,37 @@ public:
         return it->second;
     }
 
+    inline const FunObjVar* getFunObjVar(const Function* fun) const
+    {
+        LLVMFun2FunObjVarMap::const_iterator it = LLVMFun2FunObjVar.find(fun);
+        assert(it!=LLVMFun2FunObjVar.end() && "SVF Function not found!");
+        return it->second;
+    }
+
+    inline FunToIDMapTy& retSyms()
+    {
+        return returnSymMap;
+    }
+
+    inline FunToIDMapTy& varargSyms()
+    {
+        return varargSymMap;
+    }
+
+    NodeID getReturnNode(const SVFFunction *func) const
+    {
+        FunToIDMapTy::const_iterator iter =  returnSymMap.find(func);
+        assert(iter!=returnSymMap.end() && "ret sym not found");
+        return iter->second;
+    }
+
+    NodeID getVarargNode(const SVFFunction *func) const
+    {
+        FunToIDMapTy::const_iterator iter =  varargSymMap.find(func);
+        assert(iter!=varargSymMap.end() && "vararg sym not found");
+        return iter->second;
+    }
+
     SVFBasicBlock* getSVFBasicBlock(const BasicBlock* bb)
     {
         LLVMBB2SVFBBMap::const_iterator it = LLVMBB2SVFBB.find(bb);
@@ -355,6 +395,9 @@ public:
         return nullptr;
     }
 
+    /// Get the corresponding Function based on its name
+    const FunObjVar* getFunObjVar(const std::string& name);
+
     ICFGNode* getICFGNode(const Instruction* inst);
 
     bool hasICFGNode(const Instruction* inst);
@@ -429,13 +472,46 @@ public:
 
     ObjTypeInference* getTypeInference();
 
-    inline ICFG* getICFG()
-    {
-        return icfg;
-    }
-
     DominatorTree& getDomTree(const Function* fun);
 
+    std::string getExtFuncAnnotation(const SVFFunction* fun, const std::string& funcAnnotation);
+
+    const std::vector<std::string>& getExtFuncAnnotations(const SVFFunction* fun);
+
+    // Does (F) have some annotation?
+    bool hasExtFuncAnnotation(const SVFFunction* fun, const std::string& funcAnnotation);
+
+    // Does (F) have a static var X (unavailable to us) that its return points to?
+    bool has_static(const SVFFunction *F);
+
+    // Does (F) have a memcpy_like operation?
+    bool is_memcpy(const SVFFunction *F);
+
+    // Does (F) have a memset_like operation?
+    bool is_memset(const SVFFunction *F);
+
+    // Does (F) allocate a new object and return it?
+    bool is_alloc(const SVFFunction *F);
+
+    // Does (F) allocate a new object and assign it to one of its arguments?
+    bool is_arg_alloc(const SVFFunction *F);
+
+    // Does (F) allocate a new stack object and return it?
+    bool is_alloc_stack_ret(const SVFFunction *F);
+
+    // Get the position of argument which holds the new object
+    s32_t get_alloc_arg_pos(const SVFFunction *F);
+
+    // Does (F) reallocate a new object?
+    bool is_realloc(const SVFFunction *F);
+
+    // Should (F) be considered "external" (either not defined in the program
+    //   or a user-defined version of a known alloc or no-op)?
+    bool is_ext(const SVFFunction *F);
+
+    // Set the annotation of (F)
+    void setExtFuncAnnotations(const SVFFunction* fun, const std::vector<std::string>& funcAnnotations);
+
 private:
     /// Create SVFTypes
     SVFType* addSVFTypeInfo(const Type* t);

package/SVF-linux/Release-build/include/SVF-LLVM/LLVMUtil.h

@@ -355,8 +355,16 @@ std::vector<const Function *> getCalledFunctions(const Function *F);
 // Converts a mangled name to C naming style to match functions in extapi.c.
 std::string restoreFuncName(std::string funcName);
 
-/// Get the corresponding Function based on its name
+bool isExtCall(const SVFFunction* fun);
+
+bool isMemcpyExtFun(const SVFFunction *fun);
+
+bool isMemsetExtFun(const SVFFunction* fun);
+
+u32_t getHeapAllocHoldingArgPosition(const SVFFunction* fun);
+
 const SVFFunction* getFunction(const std::string& name);
+const FunObjVar* getFunObjVar(const std::string&name);
 
 /// Return true if the value refers to constant data, e.g., i32 0
 inline bool isConstDataOrAggData(const Value* val)

package/SVF-linux/Release-build/include/SVF-LLVM/SVFIRBuilder.h

@@ -74,6 +74,9 @@ public:
     /// Initialize nodes and edges
     //@{
     void initialiseNodes();
+    void initialiseBaseObjVars();
+    void initialiseValVars();
+    void initialiseFunObjVars();
     void addEdge(NodeID src, NodeID dst, SVFStmt::PEDGEK kind,
                  APOffset offset = 0, Instruction* cs = nullptr);
     // @}
@@ -102,13 +105,13 @@ public:
     }
 
     /// getReturnNode - Return the node representing the unique return value of a function.
-    inline NodeID getReturnNode(const SVFFunction *func)
+    inline NodeID getReturnNode(const FunObjVar *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 FunObjVar *func)
     {
         return pag->getVarargNode(func);
     }