svf-lib 1.0.1277 → 1.0.1279

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

@@ -59,11 +59,11 @@ public:
 
     typedef NodeBS LockSet;
     typedef TCT::InstVec InstVec;
-    typedef Set<const Instruction*> InstSet;
+    typedef Set<const SVFInstruction*> InstSet;
     typedef InstSet CISpan;
-    typedef Map<const Instruction*, CISpan>CILockToSpan;
-    typedef Set<const Function*> FunSet;
-    typedef Map<const Instruction*, InstSet> InstToInstSetMap;
+    typedef Map<const SVFInstruction*, CISpan>CILockToSpan;
+    typedef Set<const SVFFunction*> FunSet;
+    typedef Map<const SVFInstruction*, InstSet> InstToInstSetMap;
     typedef Map<CxtStmt, ValDomain> CxtStmtToLockFlagMap;
     typedef FIFOWorkList<CxtStmt> CxtStmtWorkList;
     typedef Set<CxtStmt> LockSpan;
@@ -72,13 +72,13 @@ public:
 
     typedef Map<CxtLock, LockSpan> CxtLockToSpan;
     typedef Map<CxtLock, NodeBS> CxtLockToLockSet;
-    typedef Map<const Instruction*, NodeBS> LockSiteToLockSet;
-    typedef Map<const Instruction*, LockSpan> InstToCxtStmtSet;
+    typedef Map<const SVFInstruction*, NodeBS> LockSiteToLockSet;
+    typedef Map<const SVFInstruction*, LockSpan> InstToCxtStmtSet;
     typedef Map<CxtStmt, CxtLockSet> CxtStmtToCxtLockSet;
     typedef FIFOWorkList<CxtLockProc> CxtLockProcVec;
     typedef Set<CxtLockProc> CxtLockProcSet;
 
-    typedef Map<const Instruction*, CxtStmtSet> InstToCxtStmt;
+    typedef Map<const SVFInstruction*, CxtStmtSet> InstToCxtStmt;
 
     LockAnalysis(TCT* t) : tct(t), lockTime(0),numOfTotalQueries(0), numOfLockedQueries(0), lockQueriesTime(0)
     {
@@ -89,7 +89,7 @@ public:
     /// (2) maps a context-sensitive lock site to its corresponding lock span.
     void analyze();
     void analyzeIntraProcedualLock();
-    bool intraForwardTraverse(const Instruction* lock, InstSet& unlockset, InstSet& forwardInsts);
+    bool intraForwardTraverse(const SVFInstruction* lock, InstSet& unlockset, InstSet& forwardInsts);
     bool intraBackwardTraverse(const InstSet& unlockset, InstSet& backwardInsts);
 
     void collectCxtLock();
@@ -101,14 +101,14 @@ public:
     /// Intraprocedural locks
     //@{
     /// Return true if the lock is an intra-procedural lock
-    inline bool isIntraLock(const Instruction* lock) const
+    inline bool isIntraLock(const SVFInstruction* lock) const
     {
         assert(locksites.find(lock)!=locksites.end() && "not a lock site?");
         return ciLocktoSpan.find(lock)!=ciLocktoSpan.end();
     }
 
     /// Add intra-procedural lock
-    inline void addIntraLock(const Instruction* lockSite, const InstSet& stmts)
+    inline void addIntraLock(const SVFInstruction* lockSite, const InstSet& stmts)
     {
         for(InstSet::const_iterator it = stmts.begin(), eit = stmts.end(); it!=eit; ++it)
         {
@@ -118,7 +118,7 @@ public:
     }
 
     /// Add intra-procedural lock
-    inline void addCondIntraLock(const Instruction* lockSite, const InstSet& stmts)
+    inline void addCondIntraLock(const SVFInstruction* lockSite, const InstSet& stmts)
     {
         for(InstSet::const_iterator it = stmts.begin(), eit = stmts.end(); it!=eit; ++it)
         {
@@ -127,18 +127,18 @@ public:
     }
 
     /// Return true if a statement is inside an intra-procedural lock
-    inline bool isInsideIntraLock(const Instruction* stmt) const
+    inline bool isInsideIntraLock(const SVFInstruction* stmt) const
     {
         return instCILocksMap.find(stmt)!=instCILocksMap.end() || isInsideCondIntraLock(stmt);
     }
 
     /// Return true if a statement is inside a partial lock/unlock pair (conditional lock with unconditional unlock)
-    inline bool isInsideCondIntraLock(const Instruction* stmt) const
+    inline bool isInsideCondIntraLock(const SVFInstruction* stmt) const
     {
         return instTocondCILocksMap.find(stmt)!=instTocondCILocksMap.end();
     }
 
-    inline const InstSet& getIntraLockSet(const Instruction* stmt) const
+    inline const InstSet& getIntraLockSet(const SVFInstruction* stmt) const
     {
         InstToInstSetMap::const_iterator it = instCILocksMap.find(stmt);
         assert(it!=instCILocksMap.end() && "intralock not found!");
@@ -149,7 +149,7 @@ public:
     /// Context-sensitive locks
     //@{
     /// Add inter-procedural context-sensitive lock
-    inline void addCxtLock(const CallStrCxt& cxt,const Instruction* inst)
+    inline void addCxtLock(const CallStrCxt& cxt,const SVFInstruction* inst)
     {
         CxtLock cxtlock(cxt,inst);
         cxtLockset.insert(cxtlock);
@@ -193,7 +193,7 @@ public:
     //@}
 
     /// Return true if it is a candidate function
-    inline bool isLockCandidateFun(const Function* fun) const
+    inline bool isLockCandidateFun(const SVFFunction* fun) const
     {
         return lockcandidateFuncSet.find(fun)!=lockcandidateFuncSet.end();
     }
@@ -201,12 +201,12 @@ public:
     /// Context-sensitive statement and lock spans
     //@{
     /// Get LockSet and LockSpan
-    inline bool hasCxtStmtfromInst(const Instruction* inst) const
+    inline bool hasCxtStmtfromInst(const SVFInstruction* inst) const
     {
         InstToCxtStmtSet::const_iterator it = instToCxtStmtSet.find(inst);
         return (it != instToCxtStmtSet.end());
     }
-    inline const CxtStmtSet& getCxtStmtfromInst(const Instruction* inst) const
+    inline const CxtStmtSet& getCxtStmtfromInst(const SVFInstruction* inst) const
     {
         InstToCxtStmtSet::const_iterator it = instToCxtStmtSet.find(inst);
         assert(it != instToCxtStmtSet.end());
@@ -270,7 +270,7 @@ public:
 
 
     /// Check if one instruction's context stmt is in a lock span
-    inline bool hasOneCxtInLockSpan(const Instruction *I, LockSpan lspan) const
+    inline bool hasOneCxtInLockSpan(const SVFInstruction *I, LockSpan lspan) const
     {
         if(!hasCxtStmtfromInst(I))
             return false;
@@ -285,7 +285,7 @@ public:
         return false;
     }
 
-    inline bool hasAllCxtInLockSpan(const Instruction *I, LockSpan lspan) const
+    inline bool hasAllCxtInLockSpan(const SVFInstruction *I, LockSpan lspan) const
     {
         if(!hasCxtStmtfromInst(I))
             return false;
@@ -304,15 +304,15 @@ public:
     /// Check if two Instructions are protected by common locks
     /// echo inst may have multiple cxt stmt
     /// we check whether every cxt stmt of instructions is protected by a common lock.
-    bool isProtectedByCommonLock(const Instruction *i1, const Instruction *i2);
-    bool isProtectedByCommonCxtLock(const Instruction *i1, const Instruction *i2);
+    bool isProtectedByCommonLock(const SVFInstruction *i1, const SVFInstruction *i2);
+    bool isProtectedByCommonCxtLock(const SVFInstruction *i1, const SVFInstruction *i2);
     bool isProtectedByCommonCxtLock(const CxtStmt& cxtStmt1, const CxtStmt& cxtStmt2);
-    bool isProtectedByCommonCILock(const Instruction *i1, const Instruction *i2);
+    bool isProtectedByCommonCILock(const SVFInstruction *i1, const SVFInstruction *i2);
 
-    bool isInSameSpan(const Instruction *I1, const Instruction *I2);
-    bool isInSameCSSpan(const Instruction *i1, const Instruction *i2) const;
+    bool isInSameSpan(const SVFInstruction *I1, const SVFInstruction *I2);
+    bool isInSameCSSpan(const SVFInstruction *i1, const SVFInstruction *i2) const;
     bool isInSameCSSpan(const CxtStmt& cxtStmt1, const CxtStmt& cxtStmt2) const;
-    bool isInSameCISpan(const Instruction *i1, const Instruction *i2) const;
+    bool isInSameCISpan(const SVFInstruction *i1, const SVFInstruction *i2) const;
 
     inline u32_t getNumOfCxtLocks()
     {
@@ -347,7 +347,7 @@ private:
     {
         return isAliasedLocks(cl1.getStmt(), cl2.getStmt());
     }
-    bool isAliasedLocks(const Instruction* i1, const Instruction* i2)
+    bool isAliasedLocks(const SVFInstruction* i1, const SVFInstruction* i2)
     {
         /// todo: must alias
         return tct->getPTA()->alias(getLockVal(i1), getLockVal(i2));
@@ -433,29 +433,29 @@ private:
     //@}
 
     /// Push calling context
-    void pushCxt(CallStrCxt& cxt, const Instruction* call, const Function* callee);
+    void pushCxt(CallStrCxt& cxt, const SVFInstruction* call, const SVFFunction* callee);
     /// Match context
-    bool matchCxt(CallStrCxt& cxt, const Instruction* call, const Function* callee);
+    bool matchCxt(CallStrCxt& cxt, const SVFInstruction* call, const SVFFunction* callee);
 
     void validateResults();
 
     /// Whether it is a lock site
-    inline bool isTDFork(const Instruction* call)
+    inline bool isTDFork(const SVFInstruction* call)
     {
         return getTCG()->getThreadAPI()->isTDFork(call);
     }
     /// Whether it is a lock site
-    inline bool isTDAcquire(const Instruction* call)
+    inline bool isTDAcquire(const SVFInstruction* call)
     {
         return getTCG()->getThreadAPI()->isTDAcquire(call);
     }
     /// Whether it is a unlock site
-    inline bool isTDRelease(const Instruction* call)
+    inline bool isTDRelease(const SVFInstruction* call)
     {
         return getTCG()->getThreadAPI()->isTDRelease(call);
     }
     /// Get lock value
-    inline const Value* getLockVal(const Instruction* call)
+    inline const Value* getLockVal(const SVFInstruction* call)
     {
         return getTCG()->getThreadAPI()->getLockVal(call);
     }

package/SVF-linux/include/MTA/LockResultValidator.h

@@ -19,7 +19,7 @@ class LockResultValidator
 {
 public:
     typedef Set<std::string> CxtLockSetStr;
-    typedef Map<const Instruction*, CxtLockSetStr> CxtStmtToCxtLockS;
+    typedef Map<const SVFInstruction*, CxtLockSetStr> CxtStmtToCxtLockS;
 
     typedef unsigned LOCK_FLAG;
 
@@ -38,11 +38,11 @@ public:
     }
 private:
     // Get CallICFGNode
-    inline CallICFGNode* getCBN(const Instruction* inst)
+    inline CallICFGNode* getCBN(const SVFInstruction* inst)
     {
         return _la->getTCT()->getCallICFGNode(inst);
     }
-    const Instruction *getPreviousMemoryAccessInst( const Instruction *I)
+    const Instruction* getPreviousMemoryAccessInst( const Instruction* I)
     {
         I = I->getPrevNode();
         while (I)
@@ -51,10 +51,11 @@ private:
                 return I;
             SVFFunction* callee = nullptr;
 
-            if(SVFUtil::isa<CallInst> (I))
+            if(SVFUtil::isCallSite(I))
             {
                 PTACallGraph::FunctionSet callees;
-                _la->getTCT()->getThreadCallGraph()->getCallees(getCBN(I), callees);
+                const SVFInstruction* svfInst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(I);
+                _la->getTCT()->getThreadCallGraph()->getCallees(getCBN(svfInst), callees);
 
                 for(PTACallGraph::FunctionSet::const_iterator cit = callees.begin(),
                         ecit = callees.end(); cit!=ecit; cit++)
@@ -93,7 +94,7 @@ private:
 
     std::string getOutput(const char* scenario, LOCK_FLAG analysisRes);
 
-    Set<std::string> getStringArg(const Instruction* inst, unsigned int arg_num);
+    Set<std::string> getStringArg(const SVFInstruction* inst, unsigned int arg_num);
 
     bool collectLockTargets();
     LOCK_FLAG validateStmtInLock();

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

@@ -47,17 +47,17 @@ class MHP
 {
 
 public:
-    typedef Set<const Function*> FunSet;
-    typedef Set<const Instruction*> InstSet;
+    typedef Set<const SVFFunction*> FunSet;
+    typedef Set<const SVFInstruction*> InstSet;
     typedef TCT::InstVec InstVec;
     typedef FIFOWorkList<CxtThreadStmt> CxtThreadStmtWorkList;
     typedef Set<CxtThreadStmt> CxtThreadStmtSet;
     typedef Map<CxtThreadStmt,NodeBS> ThreadStmtToThreadInterleav;
-    typedef Map<const Instruction*,CxtThreadStmtSet> InstToThreadStmtSetMap;
+    typedef Map<const SVFInstruction*,CxtThreadStmtSet> InstToThreadStmtSetMap;
 
     typedef Set<CxtStmt> LockSpan;
 
-    typedef std::pair<const Function*,const Function*> FuncPair;
+    typedef std::pair<const SVFFunction*,const SVFFunction*> FuncPair;
     typedef Map<FuncPair, bool> FuncPairToBool;
 
     /// Constructor
@@ -85,29 +85,29 @@ public:
     }
 
     // Get CallICFGNode
-    inline CallICFGNode* getCBN(const Instruction* inst)
+    inline CallICFGNode* getCBN(const SVFInstruction* inst)
     {
         return tct->getCallICFGNode(inst);
     }
 
     /// Whether the function is connected from main function in thread call graph
-    bool isConnectedfromMain(const Function* fun);
+    bool isConnectedfromMain(const SVFFunction* fun);
 
 //    /// Interface to query whether two instructions are protected by common locks
-//    virtual bool isProtectedByACommonLock(const Instruction* i1, const Instruction* i2);
-//    virtual bool isAllCxtInSameLockSpan(const Instruction *I1, const Instruction *I2);
-//    virtual bool isOneCxtInSameLockSpan(const Instruction *I1, const Instruction *I2);
+//    virtual bool isProtectedByACommonLock(const SVFInstruction* i1, const SVFInstruction* i2);
+//    virtual bool isAllCxtInSameLockSpan(const SVFInstruction *I1, const SVFInstruction *I2);
+//    virtual bool isOneCxtInSameLockSpan(const SVFInstruction *I1, const SVFInstruction *I2);
 //
-//    bool hasOneCxtInLockSpan(const Instruction *I, LockSpan lspan);
-//    bool hasAllCxtInLockSpan(const Instruction *I, LockSpan lspan);
+//    bool hasOneCxtInLockSpan(const SVFInstruction *I, LockSpan lspan);
+//    bool hasAllCxtInLockSpan(const SVFInstruction *I, LockSpan lspan);
 //
 //
 //    LockSpan getSpanfromCxtLock(NodeID l);
     /// Interface to query whether two instructions may happen-in-parallel
-    virtual bool mayHappenInParallel(const Instruction* i1, const Instruction* i2);
-    virtual bool mayHappenInParallelCache(const Instruction* i1, const Instruction* i2);
-    virtual bool mayHappenInParallelInst(const Instruction* i1, const Instruction* i2);
-    virtual bool executedByTheSameThread(const Instruction* i1, const Instruction* i2);
+    virtual bool mayHappenInParallel(const SVFInstruction* i1, const SVFInstruction* i2);
+    virtual bool mayHappenInParallelCache(const SVFInstruction* i1, const SVFInstruction* i2);
+    virtual bool mayHappenInParallelInst(const SVFInstruction* i1, const SVFInstruction* i2);
+    virtual bool executedByTheSameThread(const SVFInstruction* i1, const SVFInstruction* i2);
 
     /// Get interleaving thread for statement inst
     //@{
@@ -123,13 +123,13 @@ public:
 
     /// Get/has ThreadStmt
     //@{
-    inline const CxtThreadStmtSet& getThreadStmtSet(const Instruction* inst) const
+    inline const CxtThreadStmtSet& getThreadStmtSet(const SVFInstruction* inst) const
     {
         InstToThreadStmtSetMap::const_iterator it = instToTSMap.find(inst);
         assert(it!=instToTSMap.end() && "no thread access the instruction?");
         return it->second;
     }
-    inline bool hasThreadStmtSet(const Instruction* inst) const
+    inline bool hasThreadStmtSet(const SVFInstruction* inst) const
     {
         return instToTSMap.find(inst)!=instToTSMap.end();
     }
@@ -140,7 +140,7 @@ public:
 
 private:
 
-    inline const PTACallGraph::FunctionSet& getCallee(const Instruction* inst, PTACallGraph::FunctionSet& callees)
+    inline const PTACallGraph::FunctionSet& getCallee(const SVFInstruction* inst, PTACallGraph::FunctionSet& callees)
     {
         tcg->getCallees(getCBN(inst), callees);
         return callees;
@@ -189,7 +189,7 @@ private:
             pushToCTSWorkList(tgr);
         }
     }
-    inline void rmInterleavingThread(const CxtThreadStmt& tgr, const NodeBS& tids, const Instruction* joinsite)
+    inline void rmInterleavingThread(const CxtThreadStmt& tgr, const NodeBS& tids, const SVFInstruction* joinsite)
     {
         NodeBS joinedTids;
         for(NodeBS::iterator it = tids.begin(), eit = tids.end(); it!=eit; ++it)
@@ -214,7 +214,7 @@ private:
     bool isRecurFullJoin(NodeID parentTid, NodeID curTid);
 
     /// Whether a join site must join a thread t
-    bool isMustJoin(const NodeID curTid, const Instruction* joinsite);
+    bool isMustJoin(const NodeID curTid, const SVFInstruction* joinsite);
 
     /// A thread is a multiForked thread if it is in a loop or recursion
     inline bool isMultiForkedThread(NodeID curTid)
@@ -223,17 +223,17 @@ private:
     }
 
     /// Get the next instructions following control flow
-    inline void getNextInsts(const Instruction* inst, InstVec& instVec)
+    inline void getNextInsts(const SVFInstruction* inst, InstVec& instVec)
     {
         tct->getNextInsts(inst,instVec);
     }
     /// Push calling context
-    inline void pushCxt(CallStrCxt& cxt, const Instruction* call, const Function* callee)
+    inline void pushCxt(CallStrCxt& cxt, const SVFInstruction* call, const SVFFunction* callee)
     {
         tct->pushCxt(cxt,call,callee);
     }
     /// Match context
-    inline bool matchCxt(CallStrCxt& cxt, const Instruction* call, const Function* callee)
+    inline bool matchCxt(CallStrCxt& cxt, const SVFInstruction* call, const SVFFunction* callee)
     {
         return tct->matchCxt(cxt,call,callee);
     }
@@ -251,21 +251,21 @@ private:
     }
 
     /// Whether it is a fork site
-    inline bool isTDFork(const Instruction* call)
+    inline bool isTDFork(const SVFInstruction* call)
     {
         return tcg->getThreadAPI()->isTDFork(call);
     }
     /// Whether it is a join site
-    inline bool isTDJoin(const Instruction* call)
+    inline bool isTDJoin(const SVFInstruction* call)
     {
         return tcg->getThreadAPI()->isTDJoin(call);
     }
 
     /// Return thread id(s) which are directly or indirectly joined at this join site
-    NodeBS getDirAndIndJoinedTid(const CallStrCxt& cxt, const Instruction* call);
+    NodeBS getDirAndIndJoinedTid(const CallStrCxt& cxt, const SVFInstruction* call);
 
     /// Whether a context-sensitive join satisfies symmetric loop pattern
-    const Loop* isJoinInSymmetricLoop(const CallStrCxt& cxt, const Instruction* call) const;
+    const Loop* isJoinInSymmetricLoop(const CallStrCxt& cxt, const SVFInstruction* call) const;
 
     /// Whether thread t1 happens before t2 based on ForkJoin Analysis
     bool isHBPair(NodeID tid1, NodeID tid2);
@@ -309,7 +309,7 @@ public:
     typedef Set<NodePair> ThreadPairSet;
     typedef Map<CxtStmt, const Loop*> CxtStmtToLoopMap;
     typedef FIFOWorkList<CxtStmt> CxtStmtWorkList;
-    typedef Map<const Instruction*, PTASCEV> forkjoinToPTASCEVMap;
+    typedef Map<const SVFInstruction*, PTASCEV> forkjoinToPTASCEVMap;
     ForkJoinAnalysis(TCT* t) : tct(t)
     {
         collectSCEVInfo();
@@ -358,22 +358,22 @@ public:
     }
 
     /// Get exit instruction of the start routine function of tid's parent thread
-    inline const Instruction* getExitInstOfParentRoutineFun(NodeID tid) const
+    inline const SVFInstruction* getExitInstOfParentRoutineFun(NodeID tid) const
     {
         NodeID parentTid = tct->getParentThread(tid);
         const CxtThread& parentct = tct->getTCTNode(parentTid)->getCxtThread();
-        const Function* parentRoutine = tct->getStartRoutineOfCxtThread(parentct);
-        const SVFFunction* svfFun = LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(parentRoutine);
-        return &(LLVMUtil::getFunExitBB(svfFun)->back());
+        const SVFFunction* parentRoutine = tct->getStartRoutineOfCxtThread(parentct);
+        const SVFInstruction* inst = parentRoutine->getExitBB()->back();
+        return inst;
     }
 
     /// Get loop for join site
-    inline const Loop* getJoinLoop(const Instruction* inst)
+    inline const Loop* getJoinLoop(const SVFInstruction* inst)
     {
         return tct->getJoinLoop(inst);
     }
     /// Get SE for function
-    inline ScalarEvolution* getSE(const Instruction* inst)
+    inline ScalarEvolution* getSE(const SVFInstruction* inst)
     {
         return tct->getSE(inst);
     }
@@ -395,18 +395,18 @@ private:
     void handleIntra(const CxtStmt& cts);
 
     /// Return true if the fork and join have the same SCEV
-    bool isSameSCEV(const Instruction* forkSite, const Instruction* joinSite);
+    bool isSameSCEV(const SVFInstruction* forkSite, const SVFInstruction* joinSite);
 
     /// Same loop trip count
-    bool sameLoopTripCount(const Instruction* forkSite, const Instruction* joinSite);
+    bool sameLoopTripCount(const SVFInstruction* forkSite, const SVFInstruction* joinSite);
 
     /// Whether it is a matched fork join pair
-    bool isAliasedForkJoin(const Instruction* forkSite, const Instruction* joinSite)
+    bool isAliasedForkJoin(const SVFInstruction* forkSite, const SVFInstruction* joinSite)
     {
         return tct->getPTA()->alias(getForkedThread(forkSite), getJoinedThread(joinSite)) && isSameSCEV(forkSite,joinSite);
     }
     // Get CallICFGNode
-    inline CallICFGNode* getCBN(const Instruction* inst)
+    inline CallICFGNode* getCBN(const SVFInstruction* inst)
     {
         return tct->getCallICFGNode(inst);
     }
@@ -477,42 +477,42 @@ private:
     //@}
 
     /// Get the next instructions following control flow
-    inline void getNextInsts(const Instruction* inst, InstVec& instSet)
+    inline void getNextInsts(const SVFInstruction* inst, InstVec& instSet)
     {
         tct->getNextInsts(inst,instSet);
     }
     /// Push calling context
-    inline void pushCxt(CallStrCxt& cxt, const Instruction* call, const Function* callee)
+    inline void pushCxt(CallStrCxt& cxt, const SVFInstruction* call, const SVFFunction* callee)
     {
         tct->pushCxt(cxt,call,callee);
     }
     /// Match context
-    inline bool matchCxt(CallStrCxt& cxt, const Instruction* call, const Function* callee)
+    inline bool matchCxt(CallStrCxt& cxt, const SVFInstruction* call, const SVFFunction* callee)
     {
         return tct->matchCxt(cxt,call,callee);
     }
 
     /// Whether it is a fork site
-    inline bool isTDFork(const Instruction* call)
+    inline bool isTDFork(const SVFInstruction* call)
     {
         return getTCG()->getThreadAPI()->isTDFork(call);
     }
     /// Whether it is a join site
-    inline bool isTDJoin(const Instruction* call)
+    inline bool isTDJoin(const SVFInstruction* call)
     {
         return getTCG()->getThreadAPI()->isTDJoin(call);
     }
     /// Get forked thread
-    inline const Value* getForkedThread(const Instruction* call)
+    inline const Value* getForkedThread(const SVFInstruction* call)
     {
         return getTCG()->getThreadAPI()->getForkedThread(call);
     }
     /// Get joined thread
-    inline const Value* getJoinedThread(const Instruction* call)
+    inline const Value* getJoinedThread(const SVFInstruction* call)
     {
         return getTCG()->getThreadAPI()->getJoinedThread(call);
     }
-    inline const PTACallGraph::FunctionSet& getCallee(const Instruction* inst, PTACallGraph::FunctionSet& callees)
+    inline const PTACallGraph::FunctionSet& getCallee(const SVFInstruction* inst, PTACallGraph::FunctionSet& callees)
     {
         getTCG()->getCallees(getCBN(inst), callees);
         return callees;

package/SVF-linux/include/MTA/MTA.h

@@ -60,8 +60,8 @@ class MTA: public ModulePass
 public:
     typedef Set<const LoadInst*> LoadSet;
     typedef Set<const StoreInst*> StoreSet;
-    typedef Map<const Function*, ScalarEvolution*> FunToSEMap;
-    typedef Map<const Function*, LoopInfo*> FunToLoopInfoMap;
+    typedef Map<const SVFFunction*, ScalarEvolution*> FunToSEMap;
+    typedef Map<const SVFFunction*, LoopInfo*> FunToLoopInfoMap;
 
     /// Pass ID
     static char ID;
@@ -96,12 +96,12 @@ public:
     void dump(Module &module, MHP *mhp, LockAnalysis *lsa);
 
     // Get ScalarEvolution for Function F.
-    static inline ScalarEvolution* getSE(const Function *F)
+    static inline ScalarEvolution* getSE(const SVFFunction* F)
     {
         FunToSEMap::iterator it = func2ScevMap.find(F);
         if (it != func2ScevMap.end())
             return it->second;
-        ScalarEvolutionWrapperPass *scev = &modulePass->getAnalysis<ScalarEvolutionWrapperPass>(*const_cast<Function*>(F));
+        ScalarEvolutionWrapperPass *scev = &modulePass->getAnalysis<ScalarEvolutionWrapperPass>(*const_cast<Function*>(F->getLLVMFun()));
         func2ScevMap[F] = &scev->getSE();
         return &scev->getSE();
     }

package/SVF-linux/include/MTA/MTAAnnotator.h

@@ -68,16 +68,18 @@ public:
 
 
     /// Check if Function "F" is memset
-    inline bool isMemset(const Instruction *I)
+    inline bool isMemset(const Instruction* I)
     {
-        const Function* F =SVFUtil::getCallee(I)->getLLVMFun();
+        const SVFInstruction* svfInst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(I);
+        const Function* F =SVFUtil::getCallee(svfInst)->getLLVMFun();
         return F && F->getName().find("llvm.memset") != std::string::npos;
     }
 
     /// Check if Function "F" is memcpy
-    inline bool isMemcpy(const Instruction *I)
+    inline bool isMemcpy(const Instruction* I)
     {
-        const SVFFunction* F =SVFUtil::getCallee(I);
+        const SVFInstruction* svfInst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(I);
+        const SVFFunction* F = SVFUtil::getCallee(svfInst);
         return F && F->getName().find("llvm.memcpy") != std::string::npos;
     }