svf-lib 1.0.1289 → 1.0.1291

package/SVF-osx/include/Util/CxtStmt.h

@@ -30,7 +30,7 @@
 #ifndef INCLUDE_UTIL_CXTSTMT_H_
 #define INCLUDE_UTIL_CXTSTMT_H_
 
-#include "Util/BasicTypes.h"
+#include "SVFIR/SVFValue.h"
 
 namespace SVF
 {
@@ -96,7 +96,7 @@ public:
     inline std::string cxtToStr() const
     {
         std::string str;
-        raw_string_ostream rawstr(str);
+        std::stringstream rawstr(str);
         rawstr << "[:";
         for(CallStrCxt::const_iterator it = cxt.begin(), eit = cxt.end(); it!=eit; ++it)
         {
@@ -108,7 +108,7 @@ public:
     /// Dump CxtStmt
     inline void dump() const
     {
-        SVFUtil::outs() << "[ Current Stmt: " << SVFUtil::getSourceLoc(inst->getLLVMInstruction()) << " " << SVFUtil::value2String(inst->getLLVMInstruction()) << "\t Contexts: " << cxtToStr() << "  ]\n";
+        SVFUtil::outs() << "[ Current Stmt: " << inst->getSourceLoc() << " " << inst->toString() << "\t Contexts: " << cxtToStr() << "  ]\n";
     }
 
 protected:
@@ -174,7 +174,7 @@ public:
     /// Dump CxtThreadStmt
     inline void dump() const
     {
-        SVFUtil::outs() << "[ Current Thread id: " << tid << "  Stmt: " << SVFUtil::getSourceLoc(inst->getLLVMInstruction()) << " " << SVFUtil::value2String(inst->getLLVMInstruction()) << "\t Contexts: " << cxtToStr() << "  ]\n";
+        SVFUtil::outs() << "[ Current Thread id: " << tid << "  Stmt: " << inst->getSourceLoc() << " " << inst->toString() << "\t Contexts: " << cxtToStr() << "  ]\n";
     }
 
 private:
@@ -244,7 +244,7 @@ public:
     inline std::string cxtToStr() const
     {
         std::string str;
-        raw_string_ostream rawstr(str);
+        std::stringstream rawstr(str);
         rawstr << "[:";
         for(CallStrCxt::const_iterator it = cxt.begin(), eit = cxt.end(); it!=eit; ++it)
         {
@@ -282,8 +282,8 @@ public:
 
         if(forksite)
         {
-            SVFUtil::outs() << "[ Thread: $" << SVFUtil::getSourceLoc(forksite->getLLVMInstruction()) << "$ "
-                            << SVFUtil::value2String(forksite->getLLVMInstruction())  << "\t Contexts: " << cxtToStr()
+            SVFUtil::outs() << "[ Thread: $" << forksite->getSourceLoc() << "$ "
+                            << forksite->toString()  << "\t Contexts: " << cxtToStr()
                             << loop << cycle <<"  ]\n";
         }
         else
@@ -365,7 +365,7 @@ public:
     inline std::string cxtToStr() const
     {
         std::string str;
-        raw_string_ostream rawstr(str);
+        std::stringstream rawstr(str);
         rawstr << "[:";
         for (CallStrCxt::const_iterator it = cxt.begin(), eit = cxt.end(); it != eit; ++it)
         {

package/SVF-osx/include/Util/DPItem.h

@@ -360,7 +360,7 @@ public:
     inline std::string toString() const
     {
         std::string str;
-        raw_string_ostream rawstr(str);
+        std::stringstream rawstr(str);
         rawstr << "[:";
         for(CallStrCxt::const_iterator it = context.begin(), eit = context.end(); it!=eit; ++it)
         {

package/SVF-osx/include/Util/ExtAPI.h

@@ -30,7 +30,7 @@
 #ifndef __ExtAPI_H
 #define __ExtAPI_H
 
-#include "Util/BasicTypes.h"
+#include "SVFIR/SVFValue.h"
 #include "Util/cJSON.h"
 #include "Util/config.h"
 #include <string>

package/SVF-osx/include/Util/NodeIDAllocator.h

@@ -4,7 +4,7 @@
 #define NODEIDALLOCATOR_H_
 
 #include "FastCluster/fastcluster.h"
-#include "Util/SVFBasicTypes.h"
+#include "SVFIR/SVFType.h"
 #include "MemoryModel/PointsTo.h"
 
 namespace SVF

package/SVF-osx/include/Util/Options.h

@@ -10,6 +10,7 @@
 #include "Util/NodeIDAllocator.h"
 #include "MSSA/MemSSA.h"
 #include "WPA/WPAPass.h"
+#include <llvm/Support/CommandLine.h>	// for command line options
 
 namespace SVF
 {

package/SVF-osx/include/Util/PTAStat.h

@@ -30,7 +30,7 @@
 #ifndef ANDERSENSTAT_H_
 #define ANDERSENSTAT_H_
 
-#include "Util/BasicTypes.h"
+#include "SVFIR/SVFValue.h"
 #include "MemoryModel/PointsTo.h"
 #include "Util/SVFStat.h"
 #include <iostream>

package/SVF-osx/include/Util/SCC.h

@@ -40,7 +40,7 @@
 #ifndef SCC_H_
 #define SCC_H_
 
-#include "Util/BasicTypes.h"	// for NodeBS
+#include "SVFIR/SVFValue.h"	// for NodeBS
 #include <limits.h>
 #include <stack>
 #include <map>

package/SVF-osx/include/Util/SVFUtil.h

@@ -31,8 +31,8 @@
 #define AnalysisUtil_H_
 
 #include "FastCluster/fastcluster.h"
-#include "SVF-FE/LLVMModule.h"
-#include "Util/BasicTypes.h"
+#include "SVF-LLVM/LLVMModule.h"
+#include "SVFIR/SVFValue.h"
 #include "MemoryModel/PointsTo.h"
 #include <time.h>
 
@@ -164,47 +164,24 @@ inline NodeBS ptsToNodeBS(const PointsTo &pts)
 typedef OrderedSet<PointsTo, equalPointsTo> PointsToList;
 void dumpPointsToList(const PointsToList& ptl);
 
-inline bool isIntrinsicFun(const Function* func)
-{
-    if (func && (func->getIntrinsicID() == llvm::Intrinsic::donothing ||
-                 func->getIntrinsicID() == llvm::Intrinsic::dbg_addr ||
-                 func->getIntrinsicID() == llvm::Intrinsic::dbg_declare ||
-                 func->getIntrinsicID() == llvm::Intrinsic::dbg_label ||
-                 func->getIntrinsicID() == llvm::Intrinsic::dbg_value))
-    {
-        return true;
-    }
-    return false;
-}
-
-/// Return true if it is an intrinsic instruction
-inline bool isIntrinsicInst(const SVFInstruction* inst)
-{
-    if (const llvm::CallBase* call = llvm::dyn_cast<llvm::CallBase>(inst->getLLVMInstruction()))
-    {
-        const Function* func = call->getCalledFunction();
-        if (isIntrinsicFun(func))
-        {
-            return true;
-        }
-    }
-    return false;
-}
+/// Return true if it is an llvm intrinsic instruction
+bool isIntrinsicInst(const SVFInstruction* inst);
 //@}
 
 /// Whether an instruction is a call or invoke instruction
 inline bool isCallSite(const SVFInstruction* inst)
 {
-    return SVFUtil::isa<CallBase>(inst->getLLVMInstruction());
+    return SVFUtil::isa<SVFCallInst>(inst);
 }
 /// Whether an instruction is a call or invoke instruction
-inline bool isCallSite(const Value* val)
+inline bool isCallSite(const SVFValue* val)
 {
-    if(SVFUtil::isa<CallBase>(val))
+    if(SVFUtil::isa<SVFCallInst>(val))
         return true;
     else
         return false;
 }
+
 /// Whether an instruction is a callsite in the application code, excluding llvm intrinsic calls
 inline bool isNonInstricCallSite(const SVFInstruction* inst)
 {
@@ -214,7 +191,7 @@ inline bool isNonInstricCallSite(const SVFInstruction* inst)
 }
 
 /// Return LLVM callsite given an instruction
-inline CallSite getLLVMCallSite(const SVFInstruction* inst)
+inline CallSite getSVFCallSite(const SVFInstruction* inst)
 {
     assert(isCallSite(inst) && "not a callsite?");
     CallSite cs(inst);
@@ -222,20 +199,14 @@ inline CallSite getLLVMCallSite(const SVFInstruction* inst)
 }
 
 /// Return LLVM callsite given a value
-inline CallSite getLLVMCallSite(const Value* value)
+inline CallSite getSVFCallSite(const SVFValue* value)
 {
     assert(isCallSite(value) && "not a callsite?");
-    const SVFInstruction* svfInst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(SVFUtil::cast<CallBase>(value));
+    const SVFCallInst* svfInst = SVFUtil::cast<SVFCallInst>(value);
     CallSite cs(svfInst);
     return cs;
 }
 
-/// Get the corresponding Function based on its name
-inline const SVFFunction* getFunction(std::string name)
-{
-    return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(name);
-}
-
 /// Split into two substrings around the first occurrence of a separator string.
 inline std::vector<std::string> split(const std::string& s, char seperator)
 {
@@ -251,35 +222,11 @@ inline std::vector<std::string> split(const std::string& s, char seperator)
     return output;
 }
 
-/// find the unique defined global across multiple modules
-inline const Value* getGlobalRep(const Value* val)
-{
-    if(const GlobalVariable* gvar = SVFUtil::dyn_cast<GlobalVariable>(val))
-    {
-        if (LLVMModuleSet::getLLVMModuleSet()->hasGlobalRep(gvar))
-            val = LLVMModuleSet::getLLVMModuleSet()->getGlobalRep(gvar);
-    }
-    return val;
-}
-
-/// Get the definition of a function across multiple modules
-inline const SVFFunction* getDefFunForMultipleModule(const Function* fun)
-{
-    if(fun == nullptr) return nullptr;
-    LLVMModuleSet* llvmModuleset = LLVMModuleSet::getLLVMModuleSet();
-    const SVFFunction* svfFun = llvmModuleset->getSVFFunction(fun);
-    if (fun->isDeclaration() && llvmModuleset->hasDefinition(fun))
-        svfFun = llvmModuleset->getSVFFunction(LLVMModuleSet::getLLVMModuleSet()->getDefinition(fun));
-    return svfFun;
-}
-
 /// Return callee of a callsite. Return null if this is an indirect call
 //@{
 inline const SVFFunction* getCallee(const CallSite cs)
 {
-    // FIXME: do we need to strip-off the casts here to discover more library functions
-    const Function* callee = SVFUtil::dyn_cast<Function>(cs.getCalledValue()->stripPointerCasts());
-    return getDefFunForMultipleModule(callee);
+    return cs.getCalledFunction();
 }
 
 inline const SVFFunction* getCallee(const SVFInstruction *inst)
@@ -291,13 +238,6 @@ inline const SVFFunction* getCallee(const SVFInstruction *inst)
 }
 //@}
 
-/// Return source code including line number and file name from debug information
-//@{
-std::string  getSourceLoc(const Value* val);
-std::string  getSourceLocOfFunction(const Function* F);
-const std::string value2String(const Value* value);
-//@}
-
 /// Given a map mapping points-to sets to a count, adds from into to.
 template <typename Data>
 void mergePtsOccMaps(Map<Data, unsigned> &to, const Map<Data, unsigned> from)
@@ -444,42 +384,33 @@ inline bool isProgExitFunction (const SVFFunction * fun)
                    fun->getName() == "__assert_fail" );
 }
 
-/// Return true if the value refers to constant data, e.g., i32 0
-inline bool isConstantData(const Value* val)
+/// Return true if this argument belongs to an uncalled function
+inline bool isArgOfUncalledFunction(const SVFValue* svfval)
 {
-    return SVFUtil::isa<ConstantData>(val)
-           || SVFUtil::isa<ConstantAggregate>(val)
-           || SVFUtil::isa<MetadataAsValue>(val)
-           || SVFUtil::isa<BlockAddress>(val);
+    if(const SVFArgument* arg = SVFUtil::dyn_cast<SVFArgument>(svfval))
+        return arg->isArgOfUncalledFunction();
+    else
+        return false;
 }
 
 /// Return thread fork function
 //@{
-inline const Value* getForkedFun(const CallSite cs)
+inline const SVFValue* getForkedFun(const CallSite cs)
 {
     return ThreadAPI::getThreadAPI()->getForkedFun(cs);
 }
-inline const Value* getForkedFun(const SVFInstruction *inst)
+inline const SVFValue* getForkedFun(const SVFInstruction *inst)
 {
     return ThreadAPI::getThreadAPI()->getForkedFun(inst);
 }
 //@}
 
-const std::string type2String(const Type* type);
-
 /// This function servers a allocation wrapper detector
 inline bool isAnAllocationWraper(const SVFInstruction*)
 {
     return false;
 }
 
-/// Return LLVM function if this value is
-inline const Function* getLLVMFunction(const Value* val)
-{
-    const Function* fun = SVFUtil::dyn_cast<Function>(val->stripPointerCasts());
-    return fun;
-}
-
 inline bool isExtCall(const CallSite cs)
 {
     return isExtCall(getCallee(cs));
@@ -671,11 +602,11 @@ inline bool isBarrierWaitCall(const SVFInstruction *inst)
 
 /// Return sole argument of the thread routine
 //@{
-inline const Value* getActualParmAtForkSite(const CallSite cs)
+inline const SVFValue* getActualParmAtForkSite(const CallSite cs)
 {
     return ThreadAPI::getThreadAPI()->getActualParmAtForkSite(cs);
 }
-inline const Value* getActualParmAtForkSite(const SVFInstruction *inst)
+inline const SVFValue* getActualParmAtForkSite(const SVFInstruction *inst)
 {
     return ThreadAPI::getThreadAPI()->getActualParmAtForkSite(inst);
 }
@@ -683,11 +614,11 @@ inline const Value* getActualParmAtForkSite(const SVFInstruction *inst)
 
 /// Return the task function of the parallel_for routine
 //@{
-inline const Value* getTaskFuncAtHareParForSite(const CallSite cs)
+inline const SVFValue* getTaskFuncAtHareParForSite(const CallSite cs)
 {
     return ThreadAPI::getThreadAPI()->getTaskFuncAtHareParForSite(cs);
 }
-inline const Value* getTaskFuncAtHareParForSite(const SVFInstruction *inst)
+inline const SVFValue* getTaskFuncAtHareParForSite(const SVFInstruction *inst)
 {
     return ThreadAPI::getThreadAPI()->getTaskFuncAtHareParForSite(inst);
 }
@@ -695,11 +626,11 @@ inline const Value* getTaskFuncAtHareParForSite(const SVFInstruction *inst)
 
 /// Return the task data argument of the parallel_for rountine
 //@{
-inline const Value* getTaskDataAtHareParForSite(const CallSite cs)
+inline const SVFValue* getTaskDataAtHareParForSite(const CallSite cs)
 {
     return ThreadAPI::getThreadAPI()->getTaskDataAtHareParForSite(cs);
 }
-inline const Value* getTaskDataAtHareParForSite(const SVFInstruction *inst)
+inline const SVFValue* getTaskDataAtHareParForSite(const SVFInstruction *inst)
 {
     return ThreadAPI::getThreadAPI()->getTaskDataAtHareParForSite(inst);
 }

package/SVF-osx/include/Util/ThreadAPI.h

@@ -30,7 +30,7 @@
 #ifndef THREADAPI_H_
 #define THREADAPI_H_
 
-#include "Util/BasicTypes.h"
+#include "SVFIR/SVFValue.h"
 
 namespace SVF
 {
@@ -121,7 +121,7 @@ public:
     //@{
     const SVFFunction* getCallee(const SVFInstruction *inst) const;
     const SVFFunction* getCallee(const CallSite cs) const;
-    const CallSite getLLVMCallSite(const SVFInstruction *inst) const;
+    const CallSite getSVFCallSite(const SVFInstruction *inst) const;
     //@}
 
     /// Return true if this call create a new thread
@@ -152,39 +152,39 @@ public:
     //@{
     /// Return the first argument of the call,
     /// Note that, it is the pthread_t pointer
-    inline const Value* getForkedThread(const SVFInstruction *inst) const
+    inline const SVFValue* getForkedThread(const SVFInstruction *inst) const
     {
         assert(isTDFork(inst) && "not a thread fork function!");
-        CallSite cs = getLLVMCallSite(inst);
+        CallSite cs = getSVFCallSite(inst);
         return cs.getArgument(0);
     }
-    inline const Value* getForkedThread(CallSite cs) const
+    inline const SVFValue* getForkedThread(CallSite cs) const
     {
         return getForkedThread(cs.getInstruction());
     }
 
     /// Return the third argument of the call,
     /// Note that, it could be function type or a void* pointer
-    inline const Value* getForkedFun(const SVFInstruction *inst) const
+    inline const SVFValue* getForkedFun(const SVFInstruction *inst) const
     {
         assert(isTDFork(inst) && "not a thread fork function!");
-        CallSite cs = getLLVMCallSite(inst);
-        return cs.getArgument(2)->stripPointerCasts();
+        CallSite cs = getSVFCallSite(inst);
+        return cs.getArgument(2);
     }
-    inline const Value* getForkedFun(CallSite cs) const
+    inline const SVFValue* getForkedFun(CallSite cs) const
     {
         return getForkedFun(cs.getInstruction());
     }
 
     /// Return the forth argument of the call,
     /// Note that, it is the sole argument of start routine ( a void* pointer )
-    inline const Value* getActualParmAtForkSite(const SVFInstruction *inst) const
+    inline const SVFValue* getActualParmAtForkSite(const SVFInstruction *inst) const
     {
         assert(isTDFork(inst) && "not a thread fork function!");
-        CallSite cs = getLLVMCallSite(inst);
+        CallSite cs = getSVFCallSite(inst);
         return cs.getArgument(3);
     }
-    inline const Value* getActualParmAtForkSite(CallSite cs) const
+    inline const SVFValue* getActualParmAtForkSite(CallSite cs) const
     {
         return getActualParmAtForkSite(cs.getInstruction());
     }
@@ -192,13 +192,13 @@ public:
 
     /// Get the task function (i.e., the 5th parameter) of the hare_parallel_for call
     //@{
-    inline const Value* getTaskFuncAtHareParForSite(const SVFInstruction *inst) const
+    inline const SVFValue* getTaskFuncAtHareParForSite(const SVFInstruction *inst) const
     {
         assert(isHareParFor(inst) && "not a hare_parallel_for function!");
-        CallSite cs = getLLVMCallSite(inst);
-        return cs.getArgument(4)->stripPointerCasts();
+        CallSite cs = getSVFCallSite(inst);
+        return cs.getArgument(4);
     }
-    inline const Value* getTaskFuncAtHareParForSite(CallSite cs) const
+    inline const SVFValue* getTaskFuncAtHareParForSite(CallSite cs) const
     {
         return getTaskFuncAtHareParForSite(cs.getInstruction());
     }
@@ -206,13 +206,13 @@ public:
 
     /// Get the task data (i.e., the 6th parameter) of the hare_parallel_for call
     //@{
-    inline const Value* getTaskDataAtHareParForSite(const SVFInstruction *inst) const
+    inline const SVFValue* getTaskDataAtHareParForSite(const SVFInstruction *inst) const
     {
         assert(isHareParFor(inst) && "not a hare_parallel_for function!");
-        CallSite cs = getLLVMCallSite(inst);
+        CallSite cs = getSVFCallSite(inst);
         return cs.getArgument(5);
     }
-    inline const Value* getTaskDataAtHareParForSite(CallSite cs) const
+    inline const SVFValue* getTaskDataAtHareParForSite(CallSite cs) const
     {
         return getTaskDataAtHareParForSite(cs.getInstruction());
     }
@@ -234,20 +234,20 @@ public:
     //@{
     /// Return the first argument of the call,
     /// Note that, it is the pthread_t pointer
-    const Value* getJoinedThread(const SVFInstruction *inst) const;
-    inline const Value* getJoinedThread(CallSite cs) const
+    const SVFValue* getJoinedThread(const SVFInstruction *inst) const;
+    inline const SVFValue* getJoinedThread(CallSite cs) const
     {
         return getJoinedThread(cs.getInstruction());
     }
     /// Return the send argument of the call,
     /// Note that, it is the pthread_t pointer
-    inline const Value* getRetParmAtJoinedSite(const SVFInstruction *inst) const
+    inline const SVFValue* getRetParmAtJoinedSite(const SVFInstruction *inst) const
     {
         assert(isTDJoin(inst) && "not a thread join function!");
-        CallSite cs = getLLVMCallSite(inst);
+        CallSite cs = getSVFCallSite(inst);
         return cs.getArgument(1);
     }
-    inline const Value* getRetParmAtJoinedSite(CallSite cs) const
+    inline const SVFValue* getRetParmAtJoinedSite(CallSite cs) const
     {
         return getRetParmAtJoinedSite(cs.getInstruction());
     }
@@ -296,13 +296,13 @@ public:
     /// Return lock value
     //@{
     /// First argument of pthread_mutex_lock/pthread_mutex_unlock
-    inline const Value* getLockVal(const SVFInstruction *inst) const
+    inline const SVFValue* getLockVal(const SVFInstruction *inst) const
     {
         assert((isTDAcquire(inst) || isTDRelease(inst)) && "not a lock acquire or release function");
-        CallSite cs = getLLVMCallSite(inst);
+        CallSite cs = getSVFCallSite(inst);
         return cs.getArgument(0);
     }
-    inline const Value* getLockVal(CallSite cs) const
+    inline const SVFValue* getLockVal(CallSite cs) const
     {
         return getLockVal(cs.getInstruction());
     }

package/SVF-osx/include/Util/WorkList.h

@@ -36,7 +36,7 @@
 #ifndef WORKLIST_H_
 #define WORKLIST_H_
 
-#include "Util/BasicTypes.h"
+#include "SVFIR/SVFValue.h"
 
 #include <assert.h>
 #include <cstdlib>

package/SVF-osx/include/Util/Z3Expr.h

@@ -30,7 +30,7 @@
 #define Z3_EXAMPLE_Z3EXPR_H
 
 #include "z3++.h"
-#include "Util/SVFBasicTypes.h"
+#include "SVFIR/SVFType.h"
 
 namespace SVF
 {

package/SVF-osx/include/WPA/Andersen.h

@@ -38,7 +38,7 @@
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "WPA/WPAStat.h"
 #include "WPA/WPASolver.h"
-#include "MemoryModel/SVFIR.h"
+#include "SVFIR/SVFIR.h"
 #include "Graphs/ConsG.h"
 #include "Util/Options.h"
 

package/SVF-osx/include/WPA/CSC.h

@@ -31,7 +31,7 @@
 #define PROJECT_CSC_H
 
 #include "Util/SCC.h"
-#include "Util/BasicTypes.h"    // for NodeBS
+#include "SVFIR/SVFValue.h"    // for NodeBS
 #include "Graphs/ConsG.h"
 #include "Util/WorkList.h"
 #include <limits.h>

package/SVF-osx/include/WPA/TypeAnalysis.h

@@ -76,9 +76,6 @@ public:
         return (pta->getAnalysisTy() == TypeCPP_WPA);
     }
     //@}
-
-private:
-    Set<CallSite> virtualCallSites;
 };
 
 } // End namespace SVF

package/SVF-osx/include/WPA/WPAPass.h

@@ -76,7 +76,7 @@ public:
     virtual ~WPAPass();
 
     /// Interface expose to users of our pointer analysis, given Value infos
-    virtual AliasResult alias(const Value* V1,	const Value* V2);
+    virtual AliasResult alias(const SVFValue* V1,	const SVFValue* V2);
 
     /// Print all alias pairs
     virtual void PrintAliasPairs(PointerAnalysis* pta);
@@ -85,19 +85,19 @@ public:
     virtual ModRefInfo getModRefInfo(const CallSite callInst);
 
     /// Interface of mod-ref analysis to determine whether a CallSite instruction can mod or ref a specific memory location, given Location infos
-    virtual inline ModRefInfo getModRefInfo(const CallSite callInst, const MemoryLocation& Loc)
-    {
-        return getModRefInfo(callInst, Loc.Ptr);
-    }
+    // virtual inline ModRefInfo getModRefInfo(const CallSite callInst, const MemoryLocation& Loc)
+    // {
+    //     return getModRefInfo(callInst, Loc.Ptr);
+    // }
 
     /// Interface of mod-ref analysis to determine whether a CallSite instruction can mod or ref a specific memory location, given Value infos
-    virtual ModRefInfo getModRefInfo(const CallSite callInst, const Value* V);
+    virtual ModRefInfo getModRefInfo(const CallSite callInst, const SVFValue* V);
 
     /// Interface of mod-ref analysis between two CallSite instructions
     virtual ModRefInfo getModRefInfo(const CallSite callInst1, const CallSite callInst2);
 
     /// Run pointer analysis on SVFModule
-    virtual void runOnModule(SVFModule* svfModule);
+    virtual void runOnModule(SVFIR* svfModule);
 
     /// PTA name
     virtual inline std::string getPassName() const
@@ -107,7 +107,7 @@ public:
 
 private:
     /// Create pointer analysis according to specified kind and analyze the module.
-    void runPointerAnalysis(SVFModule* svfModule, u32_t kind);
+    void runPointerAnalysis(SVFIR* pag, u32_t kind);
 
     PTAVector ptaVector;	///< all pointer analysis to be executed.
     PointerAnalysis* _pta;	///<  pointer analysis to be executed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.1289",
+  "version": "1.0.1291",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {