svf-lib 1.0.2245 → 1.0.2247

package/SVF-linux-aarch64/Release-build/include/Graphs/CHG.h

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

package/SVF-linux-aarch64/Release-build/include/Graphs/CallGraph.h

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

package/SVF-linux-aarch64/Release-build/include/Graphs/ThreadCallGraph.h

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

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

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

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

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

package/SVF-linux-aarch64/Release-build/include/SVF-LLVM/BreakConstantExpr.h

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

package/SVF-linux-aarch64/Release-build/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-linux-aarch64/Release-build/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-linux-aarch64/Release-build/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-linux-aarch64/Release-build/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-linux-aarch64/Release-build/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

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

@@ -39,7 +39,6 @@
 namespace SVF
 {
 
-class SVFModule;
 /*!
  *  SVFIR Builder to create SVF variables and statements and PAG
  */
@@ -48,13 +47,12 @@ class SVFIRBuilder: public llvm::InstVisitor<SVFIRBuilder>
 
 private:
     SVFIR* pag;
-    SVFModule* svfModule;
     const SVFBasicBlock* curBB;	///< Current basic block during SVFIR construction when visiting the module
-    const SVFLLVMValue* curVal;	///< Current Value during SVFIR construction when visiting the module
+    const Value* curVal;	///< Current Value during SVFIR construction when visiting the module
 
 public:
     /// Constructor
-    SVFIRBuilder(SVFModule* mod): pag(SVFIR::getPAG()), svfModule(mod), curBB(nullptr),curVal(nullptr)
+    SVFIRBuilder(): pag(SVFIR::getPAG()), curBB(nullptr),curVal(nullptr)
     {
     }
     /// Destructor
@@ -71,12 +69,19 @@ public:
         return pag;
     }
 
+    void createFunObjVars();
+    void initFunObjVar();
+
     /// Initialize nodes and edges
     //@{
     void initialiseNodes();
     void initialiseBaseObjVars();
     void initialiseValVars();
-    void initialiseFunObjVars();
+
+    void initSVFBasicBlock(const Function* func);
+
+    void initDomTree(FunObjVar* func, const Function* f);
+
     void addEdge(NodeID src, NodeID dst, SVFStmt::PEDGEK kind,
                  APOffset offset = 0, Instruction* cs = nullptr);
     // @}
@@ -93,15 +98,13 @@ public:
         processCE(V);
 
         // strip off the constant cast and return the value node
-        SVFLLVMValue* svfVal = llvmModuleSet()->getSVFValue(V);
-        return llvmModuleSet()->getValueNode(svfVal);
+        return llvmModuleSet()->getValueNode(V);
     }
 
     /// GetObject - Return the object node (stack/global/heap/function) according to a LLVM Value
     inline NodeID getObjectNode(const Value* V)
     {
-        SVFLLVMValue* svfVal = llvmModuleSet()->getSVFValue(V);
-        return llvmModuleSet()->getObjectNode(svfVal);
+        return llvmModuleSet()->getObjectNode(V);
     }
 
     /// getReturnNode - Return the node representing the unique return value of a function.
@@ -209,7 +212,7 @@ public:
 protected:
     /// Handle globals including (global variable and functions)
     //@{
-    void visitGlobal(SVFModule* svfModule);
+    void visitGlobal();
     void InitialGlobal(const GlobalVariable *gvar, Constant *C,
                        u32_t offset);
     NodeID getGlobalVarField(const GlobalVariable *gvar, u32_t offset, SVFType* tpy);
@@ -237,21 +240,21 @@ protected:
     //@{
     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 Function* callee);
     //@}
 
     /// Set current basic block in order to keep track of control flow information
     inline void setCurrentLocation(const Value* val, const BasicBlock* bb)
     {
         curBB = (bb == nullptr? nullptr : llvmModuleSet()->getSVFBasicBlock(bb));
-        curVal = (val == nullptr ? nullptr: llvmModuleSet()->getSVFValue(val));
+        curVal = (val == nullptr ? nullptr: val);
     }
-    inline void setCurrentLocation(const SVFLLVMValue* val, const SVFBasicBlock* bb)
+    inline void setCurrentLocation(const Value* val, const SVFBasicBlock* bb)
     {
         curBB = bb;
         curVal = val;
     }
-    inline const SVFLLVMValue* getCurrentValue() const
+    inline const Value* getCurrentValue() const
     {
         return curVal;
     }
@@ -263,9 +266,9 @@ protected:
     /// Add global black hole Address edge
     void addGlobalBlackHoleAddrEdge(NodeID node, const ConstantExpr *int2Ptrce)
     {
-        const SVFLLVMValue* cval = getCurrentValue();
+        const Value* cval = getCurrentValue();
         const SVFBasicBlock* cbb = getCurrentBB();
-        setCurrentLocation(int2Ptrce,nullptr);
+        setCurrentLocation(int2Ptrce,(SVFBasicBlock*) nullptr);
         addBlackHoleAddrEdge(node);
         setCurrentLocation(cval,cbb);
     }
@@ -277,7 +280,7 @@ protected:
         ConstantPointerNull* constNull = ConstantPointerNull::get(PointerType::getUnqual(cxt));
         NodeID nullPtr = pag->addConstantNullPtrValNode(pag->getNullPtr(), nullptr, llvmModuleSet()->getSVFType(constNull->getType()));
         llvmModuleSet()->addToSVFVar2LLVMValueMap(constNull, pag->getGNode(pag->getNullPtr()));
-        setCurrentLocation(constNull, nullptr);
+        setCurrentLocation(constNull, (SVFBasicBlock*) nullptr);
         addBlackHoleAddrEdge(pag->getBlkPtr());
         return nullPtr;
     }
@@ -454,7 +457,7 @@ protected:
     inline void addStoreEdge(NodeID src, NodeID dst)
     {
         ICFGNode* node;
-        if (const Instruction* inst = SVFUtil::dyn_cast<Instruction>(llvmModuleSet()->getLLVMValue(curVal)))
+        if (const Instruction* inst = SVFUtil::dyn_cast<Instruction>(curVal))
             node = llvmModuleSet()->getICFGNode(
                        SVFUtil::cast<Instruction>(inst));
         else

package/SVF-linux-aarch64/Release-build/include/SVF-LLVM/SymbolTableBuilder.h

@@ -54,7 +54,7 @@ public:
     }
 
     /// Start building memory model
-    void buildMemModel(SVFModule* svfModule);
+    void buildMemModel();
 
     /// Return size of this object based on LLVM value
     u32_t getNumOfElements(const Type* ety);