svf-tools 1.0.1057 → 1.0.1059

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.1057",
+  "version": "1.0.1059",
   "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/Graphs/CHG.h

@@ -40,7 +40,6 @@
 namespace SVF
 {
 
-class SVFModule;
 class CHNode;
 class GlobalObjVar;
 

package/svf/include/Graphs/CallGraph.h

@@ -39,7 +39,6 @@ namespace SVF
 {
 
 class CallGraphNode;
-class SVFModule;
 class CallGraph;
 
 

package/svf/include/Graphs/ThreadCallGraph.h

@@ -35,7 +35,6 @@
 namespace SVF
 {
 
-class SVFModule;
 class ThreadAPI;
 class PointerAnalysis;
 /*!

package/svf/include/MTA/MTA.h

@@ -48,7 +48,6 @@ class MTAStat;
 class TCT;
 class MHP;
 class LockAnalysis;
-class SVFModule;
 
 /*!
  * Base data race detector

package/svf/include/MemoryModel/PointerAnalysis.h

@@ -48,7 +48,6 @@ namespace SVF
 
 class CommonCHGraph;
 
-class SVFModule;
 class ICFG;
 class PTAStat;
 /*

package/svf/include/SVFIR/SVFVariables.h

@@ -955,6 +955,7 @@ class FunObjVar : public BaseObjVar
     friend class SVFIRWriter;
     friend class SVFIRReader;
     friend class SVFIRBuilder;
+    friend class LLVMModuleSet;
 
 public:
     typedef SVFLoopAndDomInfo::BBSet BBSet;
@@ -976,7 +977,7 @@ private:
     const FunObjVar * realDefFun;  /// the definition of a function across multiple modules
     BasicBlockGraph* bbGraph; /// the basic block graph of this function
     std::vector<const ArgValVar*> allArgs;    /// all formal arguments of this function
-    SVFBasicBlock *exitBlock;             /// a 'single' basic block having no successors and containing return instruction in a function
+    const SVFBasicBlock *exitBlock;             /// a 'single' basic block having no successors and containing return instruction in a function
 
 
 private:
@@ -1015,9 +1016,16 @@ public:
     /// Constructor
     FunObjVar(NodeID i, ObjTypeInfo* ti, const SVFType* svfType, const ICFGNode* node);
 
+
+    virtual ~FunObjVar()
+    {
+        delete loopAndDom;
+        delete bbGraph;
+    }
+
     void initFunObjVar(bool decl, bool intrinc, bool addr, bool uncalled, bool notret, bool vararg, const SVFFunctionType *ft,
                        SVFLoopAndDomInfo *ld, const FunObjVar *real, BasicBlockGraph *bbg,
-                       const std::vector<const ArgValVar *> &allarg, SVFBasicBlock *exit);
+                       const std::vector<const ArgValVar *> &allarg, const SVFBasicBlock *exit);
 
     void setRelDefFun(const FunObjVar *real)
     {
@@ -1072,7 +1080,7 @@ public:
         return funcType->getReturnType();
     }
 
-    inline SVFLoopAndDomInfo* getLoopAndDomInfo()
+    inline SVFLoopAndDomInfo* getLoopAndDomInfo() const
     {
         return loopAndDom;
     }

package/svf/include/Util/CallGraphBuilder.h

@@ -37,7 +37,6 @@ namespace SVF
 {
 
 class ICFG;
-class SVFModule;
 class CallGraph;
 class ThreadCallGraph;
 

package/svf/include/Util/ThreadAPI.h

@@ -35,7 +35,6 @@
 namespace SVF
 {
 
-class SVFModule;
 class ICFGNode;
 class CallICFGNode;
 class SVFVar;

package/svf/include/WPA/Andersen.h

@@ -45,7 +45,6 @@
 namespace SVF
 {
 
-class SVFModule;
 
 class ThreadCallGraph;
 

package/svf/include/WPA/FlowSensitive.h

@@ -40,7 +40,6 @@ namespace SVF
 {
 
 class AndersenWaveDiff;
-class SVFModule;
 
 /*!
  * Flow sensitive whole program pointer analysis

package/svf/include/WPA/VersionedFlowSensitive.h

@@ -24,7 +24,6 @@ namespace SVF
 {
 
 class AndersenWaveDiff;
-class SVFModule;
 
 /*!
  * Versioned flow sensitive whole program pointer analysis

package/svf/include/WPA/WPAPass.h

@@ -42,7 +42,6 @@
 namespace SVF
 {
 
-class SVFModule;
 class SVFG;
 
 /*!

package/svf/lib/SVFIR/SVFValue.cpp

@@ -7,6 +7,15 @@
 using namespace SVF;
 using namespace SVFUtil;
 
+
+__attribute__((weak))
+const std::string SVFValue::valueOnlyToString() const
+{
+    assert("SVFBaseNode::valueOnlyToString should be implemented or supported by fronted" && false);
+    abort();
+}
+
+
 /// Add field (index and offset) with its corresponding type
 void StInfo::addFldWithType(u32_t fldIdx, const SVFType* type, u32_t elemIdx)
 {
@@ -149,11 +158,4 @@ bool SVFLoopAndDomInfo::isLoopHeader(const SVFBasicBlock* bb) const
         return blocks.front() == bb;
     }
     return false;
-}
-
-__attribute__((weak))
-const std::string SVFValue::valueOnlyToString() const
-{
-    assert("SVFBaseNode::valueOnlyToString should be implemented or supported by fronted" && false);
-    abort();
 }

package/svf/lib/SVFIR/SVFVariables.cpp

@@ -445,7 +445,7 @@ FunObjVar::FunObjVar(NodeID i, ObjTypeInfo* ti, const SVFType* svfType, const IC
 
 void FunObjVar::initFunObjVar(bool decl, bool intrinc, bool addr, bool uncalled, bool notret, bool vararg,
                               const SVFFunctionType *ft, SVFLoopAndDomInfo *ld, const FunObjVar *real, BasicBlockGraph *bbg,
-                              const std::vector<const ArgValVar *> &allarg, SVFBasicBlock *exit)
+                              const std::vector<const ArgValVar *> &allarg, const SVFBasicBlock *exit)
 {
     isDecl = decl;
     intrinsic = intrinc;

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

@@ -15,7 +15,6 @@
 #ifndef BREAKCONSTANTGEPS_H
 #define BREAKCONSTANTGEPS_H
 
-#include "SVF-LLVM/SVFLLVMValue.h"
 
 namespace SVF
 {

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

@@ -30,8 +30,8 @@
 #ifndef CPPUtil_H_
 #define CPPUtil_H_
 
-#include "SVF-LLVM/SVFLLVMValue.h"
 #include "SVF-LLVM/BasicTypes.h"
+#include "Util/GeneralType.h"
 
 namespace SVF
 {

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

@@ -17,14 +17,12 @@
 #include "Graphs/GenericGraph.h"
 #include "Graphs/CHG.h"
 #include "SVF-LLVM/BasicTypes.h"
-#include "SVF-LLVM/SVFModule.h"
 #include "Util/SVFUtil.h"
 #include "Util/WorkList.h"
 
 namespace SVF
 {
 
-class SVFModule;
 class DCHNode;
 
 class DCHEdge : public GenericEdge<DCHNode>
@@ -230,8 +228,8 @@ public:
     static bool isAgg(const DIType* t);
 
 public:
-    DCHGraph(const SVFModule *svfMod)
-        : svfModule(svfMod), numTypes(0)   // vfID(0), buildingCHGTime(0) {
+    DCHGraph()
+        :numTypes(0)   // vfID(0), buildingCHGTime(0) {
     {
         this->kind = DI;
     }
@@ -358,8 +356,6 @@ public:
     bool isFirstField(const DIType* f, const DIType* b);
 
 protected:
-    /// SVF Module this CHG is built from.
-    const SVFModule* svfModule;
     /// Whether this CHG is an extended CHG (first-field). Set by buildCHG.
     bool extended = false;
     /// Maps DITypes to their nodes.
@@ -394,7 +390,7 @@ private:
     void handleDISubroutineType(const DISubroutineType* subroutineType);
 
     /// Finds all defined virtual functions and attaches them to nodes.
-    void buildVTables(const SVFModule& module);
+    void buildVTables();
 
     /// Returns a set of all children of type (CHA). Also gradually builds chaMap.
     const NodeBS& cha(const DIType* type, bool firstField);

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

@@ -31,8 +31,6 @@
 #define INCLUDE_SVF_FE_LLVMMODULE_H_
 
 #include "SVF-LLVM/BasicTypes.h"
-#include "SVF-LLVM/SVFLLVMValue.h"
-#include "SVF-LLVM/SVFModule.h"
 #include "Util/Options.h"
 #include "Graphs/BasicBlockG.h"
 
@@ -54,14 +52,8 @@ public:
     typedef Map<const Function*, FunctionSetType> FunDefToDeclsMapTy;
     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*, SVFLLVMValue*> LLVMInst2SVFInstMap;
-    typedef Map<const Argument*, SVFLLVMValue*> LLVMArgument2SVFArgumentMap;
-    typedef Map<const Constant*, SVFLLVMValue*> LLVMConst2SVFConstMap;
-    typedef Map<const Value*, SVFLLVMValue*> LLVMValue2SVFOtherValueMap;
-    typedef Map<const SVFLLVMValue*, const Value*> SVFValue2LLVMValueMap;
     typedef Map<const SVFValue*, const Value*> SVFBaseNode2LLVMValueMap;
     typedef Map<const Type*, SVFType*> LLVMType2SVFTypeMap;
     typedef Map<const Type*, StInfo*> Type2TypeInfoMap;
@@ -75,16 +67,18 @@ public:
 
     /// llvm value to sym id map
     /// local (%) and global (@) identifiers are pointer types which have a value node id.
-    typedef OrderedMap<const SVFLLVMValue*, NodeID> ValueToIDMapTy;
+    typedef OrderedMap<const Value*, NodeID> ValueToIDMapTy;
 
-    typedef OrderedMap<const SVFFunction*, NodeID> FunToIDMapTy;
+    typedef OrderedMap<const Function*, NodeID> FunToIDMapTy;
 
+    typedef std::vector<const Function*> FunctionSet;
+    typedef Map<const Function*, const SVFBasicBlock*> FunToExitBBMap;
+    typedef Map<const Function*, const Function *> FunToRealDefFunMap;
 
 private:
     static LLVMModuleSet* llvmModuleSet;
     static bool preProcessed;
     SVFIR* svfir;
-    SVFModule* svfModule; ///< Borrowed from singleton SVFModule::svfModule
     std::unique_ptr<LLVMContext> owned_ctx;
     std::vector<std::unique_ptr<Module>> owned_modules;
     std::vector<std::reference_wrapper<Module>> modules;
@@ -95,19 +89,13 @@ private:
     Fun2AnnoMap ExtFun2Annotations;
 
     // Map SVFFunction to its annotations
-    Map<const SVFFunction*, std::vector<std::string>> func2Annotations;
+    Map<const Function*, 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;
-    LLVMConst2SVFConstMap LLVMConst2SVFConst;
-    LLVMValue2SVFOtherValueMap LLVMValue2SVFOtherValue;
-    SVFValue2LLVMValueMap SVFValue2LLVMValue;
     LLVMType2SVFTypeMap LLVMType2SVFType;
     Type2TypeInfoMap Type2TypeInfo;
     ObjTypeInference* typeInference;
@@ -126,6 +114,10 @@ private:
     FunToIDMapTy returnSymMap; ///< return map
     FunToIDMapTy varargSymMap; ///< vararg map
 
+    FunctionSet funSet;
+    FunToExitBBMap funToExitBB;
+    FunToRealDefFunMap funToRealDefFun;
+
     /// Constructor
     LLVMModuleSet();
 
@@ -148,15 +140,10 @@ public:
     }
 
     // Build an SVF module from a given LLVM Module instance (for use e.g. in a LLVM pass)
-    static SVFModule* buildSVFModule(Module& mod);
+    static void buildSVFModule(Module& mod);
 
     // Build an SVF module from the bitcode files provided in `moduleNameVec`
-    static SVFModule* buildSVFModule(const std::vector<std::string>& moduleNameVec);
-
-    inline SVFModule* getSVFModule()
-    {
-        return svfModule;
-    }
+    static void buildSVFModule(const std::vector<std::string>& moduleNameVec);
 
     static void preProcessBCs(std::vector<std::string>& moduleNameVec);
 
@@ -186,6 +173,25 @@ public:
 
 public:
 
+    inline const SVFBasicBlock* getFunExitBB(const Function* fun) const
+    {
+        auto it = funToExitBB.find(fun);
+        if (it == funToExitBB.end()) return nullptr;
+        else return it->second;
+    }
+
+    inline const Function* getRealDefFun(const Function* fun) const
+    {
+        auto it = funToRealDefFun.find(fun);
+        if (it == funToRealDefFun.end()) return nullptr;
+        else return it->second;
+    }
+
+    inline const FunctionSet& getFunctionSet() const
+    {
+        return funSet;
+    }
+
     inline u32_t getValueNodeNum() const
     {
         return valSymMap.size();
@@ -208,36 +214,26 @@ public:
 
     /// Get SVFIR Node according to LLVM value
     ///getNode - Return the node corresponding to the specified pointer.
-    NodeID getValueNode(const SVFLLVMValue* V);
+    NodeID getValueNode(const Value* V);
 
-    bool hasValueNode(const SVFLLVMValue* V);
+    bool hasValueNode(const Value* V);
 
     /// getObject - Return the obj node id refer to the memory object for the
     /// specified global, heap or alloca instruction according to llvm value.
-    NodeID getObjectNode(const SVFLLVMValue* V);
+    NodeID getObjectNode(const Value* V);
 
     void dumpSymTable();
 
 public:
-    inline void addFunctionMap(const Function* func, SVFFunction* svfFunc)
-    {
-        LLVMFunc2SVFFunc[func] = svfFunc;
-        setValueAttr(func,svfFunc);
-    }
 
     // create a SVFBasicBlock according to LLVM BasicBlock, then add it to SVFFunction's BasicBlockGraph
-    inline void addBasicBlock(SVFFunction* fun, const BasicBlock* bb)
+    inline void addBasicBlock(FunObjVar* fun, const BasicBlock* bb)
     {
         SVFBasicBlock* svfBB = fun->getBasicBlockGraph()->addBasicBlock(bb->getName().str());
         LLVMBB2SVFBB[bb] = svfBB;
         SVFBaseNode2LLVMValue[svfBB] = bb;
     }
 
-    inline void addInstructionMap(const Instruction* inst, SVFLLVMValue* svfInst)
-    {
-        LLVMInst2SVFInst[inst] = svfInst;
-        setValueAttr(inst,svfInst);
-    }
     inline void addInstructionMap(const Instruction* inst, CallICFGNode* svfInst)
     {
         CSToCallNodeMap[inst] = svfInst;
@@ -254,46 +250,6 @@ public:
         addToSVFVar2LLVMValueMap(inst, svfInst);
     }
 
-    inline void addArgumentMap(const Argument* arg, SVFLLVMValue* svfArg)
-    {
-        LLVMArgument2SVFArgument[arg] = svfArg;
-        setValueAttr(arg,svfArg);
-    }
-    inline void addGlobalValueMap(const GlobalValue* glob, SVFLLVMValue* svfglob)
-    {
-        if (auto glob_var = llvm::dyn_cast<llvm::GlobalVariable>(glob);
-                hasGlobalRep(glob_var))
-        {
-            glob = getGlobalRep(glob_var);
-        }
-        LLVMConst2SVFConst[glob] = svfglob;
-        setValueAttr(glob,svfglob);
-    }
-    inline void addConstantDataMap(const ConstantData* cd, SVFLLVMValue* svfcd)
-    {
-        LLVMConst2SVFConst[cd] = svfcd;
-        setValueAttr(cd,svfcd);
-    }
-    inline void addOtherConstantMap(const Constant* cons, SVFLLVMValue* svfcons)
-    {
-        LLVMConst2SVFConst[cons] = svfcons;
-        setValueAttr(cons,svfcons);
-    }
-    inline void addOtherValueMap(const Value* ov, SVFLLVMValue* svfov)
-    {
-        LLVMValue2SVFOtherValue[ov] = svfov;
-        setValueAttr(ov,svfov);
-    }
-
-    SVFLLVMValue* getSVFValue(const Value* value);
-
-    const Value* getLLVMValue(const SVFLLVMValue* value) const
-    {
-        SVFValue2LLVMValueMap::const_iterator it = SVFValue2LLVMValue.find(value);
-        assert(it!=SVFValue2LLVMValue.end() && "can't find corresponding llvm value!");
-        return it->second;
-    }
-
     const Value* getLLVMValue(const SVFValue* value) const
     {
         SVFBaseNode2LLVMValueMap ::const_iterator it = SVFBaseNode2LLVMValue.find(value);
@@ -301,13 +257,6 @@ public:
         return it->second;
     }
 
-    inline SVFFunction* getSVFFunction(const Function* fun) const
-    {
-        LLVMFun2SVFFunMap::const_iterator it = LLVMFunc2SVFFunc.find(fun);
-        assert(it!=LLVMFunc2SVFFunc.end() && "SVF Function not found!");
-        return it->second;
-    }
-
     inline const FunObjVar* getFunObjVar(const Function* fun) const
     {
         LLVMFun2FunObjVarMap::const_iterator it = LLVMFun2FunObjVar.find(fun);
@@ -325,14 +274,14 @@ public:
         return varargSymMap;
     }
 
-    NodeID getReturnNode(const SVFFunction *func) const
+    NodeID getReturnNode(const Function *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
+    NodeID getVarargNode(const Function *func) const
     {
         FunToIDMapTy::const_iterator iter =  varargSymMap.find(func);
         assert(iter!=varargSymMap.end() && "vararg sym not found");
@@ -346,39 +295,8 @@ public:
         return it->second;
     }
 
-    inline SVFLLVMValue* getSVFInstruction(const Instruction* inst) const
-    {
-        LLVMInst2SVFInstMap::const_iterator it = LLVMInst2SVFInst.find(inst);
-        assert(it!=LLVMInst2SVFInst.end() && "SVF Instruction not found!");
-        return it->second;
-    }
-
-    inline SVFLLVMValue* getSVFArgument(const Argument* arg) const
-    {
-        LLVMArgument2SVFArgumentMap::const_iterator it = LLVMArgument2SVFArgument.find(arg);
-        assert(it!=LLVMArgument2SVFArgument.end() && "SVF Argument not found!");
-        return it->second;
-    }
-
-    inline SVFLLVMValue* getSVFGlobalValue(const GlobalValue* g) const
-    {
-        if (auto glob_var = llvm::dyn_cast<llvm::GlobalVariable>(g);
-                hasGlobalRep(glob_var))
-        {
-            g = getGlobalRep(glob_var);
-        }
-        LLVMConst2SVFConstMap::const_iterator it = LLVMConst2SVFConst.find(g);
-        assert(it!=LLVMConst2SVFConst.end() && "SVF Global not found!");
-        return it->second;
-    }
-
-    SVFLLVMValue* getSVFConstantData(const ConstantData* cd);
-    SVFLLVMValue* getOtherSVFConstant(const Constant* oc);
-
-    SVFLLVMValue* getSVFOtherValue(const Value* ov);
-
     /// Get the corresponding Function based on its name
-    inline const SVFFunction* getSVFFunction(const std::string& name)
+    inline const Function* getFunction(const std::string& name)
     {
         Function* fun = nullptr;
 
@@ -388,7 +306,7 @@ public:
             fun = mod->getFunction(name);
             if (fun)
             {
-                return llvmModuleSet->getSVFFunction(fun);
+                return fun;
             }
         }
         return nullptr;
@@ -473,45 +391,59 @@ public:
 
     DominatorTree& getDomTree(const Function* fun);
 
-    std::string getExtFuncAnnotation(const SVFFunction* fun, const std::string& funcAnnotation);
+    std::string getExtFuncAnnotation(const Function* fun, const std::string& funcAnnotation);
 
-    const std::vector<std::string>& getExtFuncAnnotations(const SVFFunction* fun);
+    const std::vector<std::string>& getExtFuncAnnotations(const Function* fun);
 
     // Does (F) have some annotation?
-    bool hasExtFuncAnnotation(const SVFFunction* fun, const std::string& funcAnnotation);
+    bool hasExtFuncAnnotation(const Function* 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);
+    bool has_static(const Function *F);
 
     // Does (F) have a memcpy_like operation?
-    bool is_memcpy(const SVFFunction *F);
+    bool is_memcpy(const Function *F);
 
     // Does (F) have a memset_like operation?
-    bool is_memset(const SVFFunction *F);
+    bool is_memset(const Function *F);
 
     // Does (F) allocate a new object and return it?
-    bool is_alloc(const SVFFunction *F);
+    bool is_alloc(const Function *F);
 
     // Does (F) allocate a new object and assign it to one of its arguments?
-    bool is_arg_alloc(const SVFFunction *F);
+    bool is_arg_alloc(const Function *F);
 
     // Does (F) allocate a new stack object and return it?
-    bool is_alloc_stack_ret(const SVFFunction *F);
+    bool is_alloc_stack_ret(const Function *F);
 
     // Get the position of argument which holds the new object
-    s32_t get_alloc_arg_pos(const SVFFunction *F);
+    s32_t get_alloc_arg_pos(const Function *F);
 
     // Does (F) reallocate a new object?
-    bool is_realloc(const SVFFunction *F);
+    bool is_realloc(const Function *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);
+    bool is_ext(const Function *F);
 
     // Set the annotation of (F)
-    void setExtFuncAnnotations(const SVFFunction* fun, const std::vector<std::string>& funcAnnotations);
+    void setExtFuncAnnotations(const Function* fun, const std::vector<std::string>& funcAnnotations);
 
 private:
+    inline void addFunctionSet(const Function* svfFunc)
+    {
+        funSet.push_back(svfFunc);
+    }
+
+    inline void setFunExitBB(const Function* fun, const SVFBasicBlock* bb)
+    {
+        funToExitBB[fun] = bb;
+    }
+
+    inline void setFunRealDefFun(const Function* fun, const Function* realDefFun)
+    {
+        funToRealDefFun[fun] = realDefFun;
+    }
     /// Create SVFTypes
     SVFType* addSVFTypeInfo(const Type* t);
     /// Collect a type info
@@ -531,11 +463,7 @@ private:
     void addSVFMain();
 
     void createSVFDataStructure();
-    void createSVFFunction(const Function* func);
-    void initSVFFunction();
-    void initSVFBasicBlock(const Function* func);
-    void initDomTree(SVFFunction* func, const Function* f);
-    void setValueAttr(const Value* val, SVFLLVMValue* value);
+
     void addToSVFVar2LLVMValueMap(const Value* val, SVFValue* svfBaseNode);
     void buildFunToFunMap();
     void buildGlobalDefToRepMap();

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

@@ -32,7 +32,6 @@
 
 #include "Util/SVFUtil.h"
 #include "SVF-LLVM/BasicTypes.h"
-#include "SVF-LLVM/SVFLLVMValue.h"
 #include "Util/ThreadAPI.h"
 
 namespace SVF
@@ -355,15 +354,14 @@ 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);
 
-bool isExtCall(const SVFFunction* fun);
+bool isExtCall(const Function* fun);
 
-bool isMemcpyExtFun(const SVFFunction *fun);
+bool isMemcpyExtFun(const Function *fun);
 
-bool isMemsetExtFun(const SVFFunction* fun);
+bool isMemsetExtFun(const Function* fun);
 
-u32_t getHeapAllocHoldingArgPosition(const SVFFunction* fun);
+u32_t getHeapAllocHoldingArgPosition(const Function* 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
@@ -376,9 +374,6 @@ inline bool isConstDataOrAggData(const Value* val)
 /// find the unique defined global across multiple modules
 const Value* getGlobalRep(const Value* val);
 
-/// Check whether this value points-to a constant object
-bool isConstantObjSym(const SVFLLVMValue* val);
-
 /// Check whether this value points-to a constant object
 bool isConstantObjSym(const Value* val);
 

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

@@ -32,7 +32,6 @@
 
 #include "Util/SVFUtil.h"
 #include "SVF-LLVM/BasicTypes.h"
-#include "SVF-LLVM/SVFLLVMValue.h"
 #include "Util/ThreadAPI.h"
 
 namespace SVF