svf-lib 1.0.1276 → 1.0.1278

package/SVF-osx/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-osx/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-osx/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;
     }
 

package/SVF-osx/include/MTA/MTAResultValidator.h

@@ -52,15 +52,15 @@ protected:
     std::vector<std::string> split(const std::string &s, char delim);
 
     // Get special arguments of given call sites
-    NodeID getIntArg(const Instruction* inst, unsigned int arg_num);
-    std::vector<std::string> getStringArg(const Instruction* inst, unsigned int arg_num);
-    CallStrCxt getCxtArg(const Instruction* inst, unsigned int arg_num);
+    NodeID getIntArg(const SVFInstruction* inst, unsigned int arg_num);
+    std::vector<std::string> getStringArg(const SVFInstruction* inst, unsigned int arg_num);
+    CallStrCxt getCxtArg(const SVFInstruction* inst, unsigned int arg_num);
 
     /*
      * Get the previous LoadInst or StoreInst from Instruction "I" in the
      * same BasicBlock. Return nullptr if none exists.
      */
-    const Instruction *getPreviousMemoryAccessInst(const Instruction *I);
+    const Instruction* getPreviousMemoryAccessInst(const Instruction* I);
 
     // Compare two cxts
     bool matchCxt(const CallStrCxt cxt1, const CallStrCxt cxt2) const;
@@ -77,7 +77,7 @@ protected:
     /*
      * Collect the callsite targets for validations.
      * The targets are labeled by "cs1:", "cs2:"... that are the names of its basic blocks.
-     * The collected targets are stored in csnumToInstMap that maps label "cs1" to CallInst.
+     * The collected targets are stored in csnumToInstMap that maps label "cs1" to its Callsite.
      */
     bool collectCallsiteTargets();
 
@@ -117,7 +117,7 @@ protected:
 
 private:
 
-    typedef Map<NodeID, const CallInst*> csnumToInst;
+    typedef Map<NodeID, const SVFInstruction*> csnumToInst;
     typedef Map<NodeID, CallStrCxt> vthdToCxtMap;
     typedef Map<NodeID, NodeID> vthdTorthdMap;
     typedef Map<NodeID, NodeID> rthdTovthdMap;
@@ -177,7 +177,7 @@ public:
     {
     public:
         /// Constructor
-        AccessPair(const Instruction *I1, const Instruction *I2,
+        AccessPair(const Instruction* I1, const Instruction* I2,
                    const RC_FLAG flags) :
             I1(I1), I2(I2), flags(flags)
         {
@@ -189,19 +189,19 @@ public:
         {
             return flags & flag;
         }
-        inline const Instruction *getInstruction1() const
+        inline const Instruction* getInstruction1() const
         {
             return I1;
         }
-        inline const Instruction *getInstruction2() const
+        inline const Instruction* getInstruction2() const
         {
             return I2;
         }
         //@}
 
     private:
-        const Instruction *I1;
-        const Instruction *I2;
+        const Instruction* I1;
+        const Instruction* I2;
         RC_FLAG flags;
     };
 
@@ -240,26 +240,26 @@ protected:
     /// Interface to the specific validation properties.
     /// Override one or more to implement your own analysis.
     //@{
-    virtual bool mayAccessAliases(const Instruction *I1,
-                                  const Instruction *I2)
+    virtual bool mayAccessAliases(const Instruction* I1,
+                                  const Instruction* I2)
     {
         selectedValidationScenarios &= ~RC_ALIASES;
         return true;
     }
-    virtual bool mayHappenInParallel(const Instruction *I1,
-                                     const Instruction *I2)
+    virtual bool mayHappenInParallel(const Instruction* I1,
+                                     const Instruction* I2)
     {
         selectedValidationScenarios &= ~RC_MHP;
         return true;
     }
-    virtual bool protectedByCommonLocks(const Instruction *I1,
-                                        const Instruction *I2)
+    virtual bool protectedByCommonLocks(const Instruction* I1,
+                                        const Instruction* I2)
     {
         selectedValidationScenarios &= ~RC_PROTECTED;
         return true;
     }
-    virtual bool mayHaveDataRace(const Instruction *I1,
-                                 const Instruction *I2)
+    virtual bool mayHaveDataRace(const Instruction* I1,
+                                 const Instruction* I2)
     {
         selectedValidationScenarios &= ~RC_RACE;
         return true;
@@ -274,15 +274,18 @@ protected:
     void collectValidationTargets()
     {
         // Collect call sites of all RC_ACCESS function calls.
-        std::vector<const CallInst*> csInsts;
-        const Function *F = nullptr;
-        for(auto it = M->llvmFunBegin(); it != M->llvmFunEnd(); it++)
+        std::vector<CallSite> csInsts;
+        const Function* F = nullptr;
+        for (Module &M : LLVMModuleSet::getLLVMModuleSet()->getLLVMModules())
         {
-            const std::string fName = (*it)->getName().str();
-            if(fName.find(RC_ACCESS) != std::string::npos)
+            for(auto it = M.begin(); it != M.end(); it++)
             {
-                F = (*it);
-                break;
+                const std::string fName = (*it).getName().str();
+                if(fName.find(RC_ACCESS) != std::string::npos)
+                {
+                    F = &(*it);
+                    break;
+                }
             }
         }
         if (!F)     return;
@@ -292,9 +295,11 @@ protected:
         {
             const Use *u = &*it;
             const Value *user = u->getUser();
-            const CallInst *csInst = SVFUtil::dyn_cast<CallInst>(user);
-            assert(csInst);
-            csInsts.push_back(csInst);
+            if(SVFUtil::isCallSite(user))
+            {
+                CallSite csInst = SVFUtil::getLLVMCallSite(user);
+                csInsts.push_back(csInst);
+            }
         }
         assert(csInsts.size() % 2 == 0 && "We should have RC_ACCESS called in pairs.");
 
@@ -304,12 +309,12 @@ protected:
         // Generate access pairs.
         for (int i = 0, e = csInsts.size(); i != e;)
         {
-            const CallInst *CI1 = csInsts[i++];
-            const CallInst *CI2 = csInsts[i++];
-            const ConstantInt *C = SVFUtil::dyn_cast<ConstantInt>(CI1->getOperand(1));
+            CallSite CI1 = csInsts[i++];
+            CallSite CI2 = csInsts[i++];
+            const ConstantInt* C = SVFUtil::dyn_cast<ConstantInt>(CI1.getArgOperand(1));
             assert(C);
-            const Instruction *I1 = getPreviousMemoryAccessInst(CI1);
-            const Instruction *I2 = getPreviousMemoryAccessInst(CI2);
+            const Instruction* I1 = getPreviousMemoryAccessInst(CI1.getInstruction()->getLLVMInstruction());
+            const Instruction* I2 = getPreviousMemoryAccessInst(CI2.getInstruction()->getLLVMInstruction());
             assert(I1 && I2 && "RC_ACCESS should be placed immediately after the target memory access.");
             RC_FLAG flags = C->getZExtValue();
             accessPairs.push_back(AccessPair(I1, I2, flags));
@@ -325,8 +330,8 @@ protected:
         for (int i = 0, e = accessPairs.size(); i != e; ++i)
         {
             const AccessPair &ap = accessPairs[i];
-            const Instruction *I1 = ap.getInstruction1();
-            const Instruction *I2 = ap.getInstruction2();
+            const Instruction* I1 = ap.getInstruction1();
+            const Instruction* I2 = ap.getInstruction2();
 
             bool mhp = mayHappenInParallel(I1, I2);
             bool alias = mayAccessAliases(I1, I2);
@@ -390,12 +395,12 @@ private:
      * Comparison function to sort the validation targets in ascending order of
      * the validation id (i.e., the 1st argument of RC_ACCESS function call).
      */
-    static bool compare(const CallInst *CI1, const CallInst *CI2)
+    static bool compare(CallSite CI1, CallSite CI2)
     {
-        const Value *V1 = CI1->getOperand(0);
-        const Value *V2 = CI2->getOperand(0);
-        const ConstantInt *C1 = SVFUtil::dyn_cast<ConstantInt>(V1);
-        const ConstantInt *C2 = SVFUtil::dyn_cast<ConstantInt>(V2);
+        const Value *V1 = CI1.getArgOperand(0);
+        const Value *V2 = CI2.getArgOperand(0);
+        const ConstantInt* C1 = SVFUtil::dyn_cast<ConstantInt>(V1);
+        const ConstantInt* C2 = SVFUtil::dyn_cast<ConstantInt>(V2);
         assert(0 != C1 && 0 != C2);
         return C1->getZExtValue() < C2->getZExtValue();
     }
@@ -405,8 +410,8 @@ private:
      * same BasicBlock.
      * Return nullptr if none exists.
      */
-    const Instruction *getPreviousMemoryAccessInst(
-        const Instruction *I)
+    const Instruction* getPreviousMemoryAccessInst(
+        const Instruction* I)
     {
         I = I->getPrevNode();
         while (I)
@@ -414,7 +419,9 @@ private:
             if (SVFUtil::isa<LoadInst>(I) || SVFUtil::isa<StoreInst>(I))
                 return I;
 
-            if (const SVFFunction *callee = SVFUtil::getCallee(I))
+            const SVFInstruction* inst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(I);
+
+            if (const SVFFunction *callee = SVFUtil::getCallee(inst))
             {
                 if (callee->getName().find("llvm.memset") != std::string::npos)
                     return I;

package/SVF-osx/include/MTA/PCG.h

@@ -51,11 +51,11 @@ class PCG
 {
 
 public:
-    typedef Set<const Function*> FunSet;
-    typedef std::vector<const Function*> FunVec;
-    typedef Set<const Instruction*> CallInstSet;
-    typedef FIFOWorkList<const Function*> FunWorkList;
-    typedef FIFOWorkList<const BasicBlock*> BBWorkList;
+    typedef Set<const SVFFunction*> FunSet;
+    typedef std::vector<const SVFFunction*> FunVec;
+    typedef Set<const SVFInstruction*> CallInstSet;
+    typedef FIFOWorkList<const SVFFunction*> FunWorkList;
+    typedef FIFOWorkList<const SVFBasicBlock*> BBWorkList;
 
 private:
     FunSet spawners;
@@ -72,31 +72,31 @@ private:
 
     /// Add/Get methods for thread properties of a procedure
     //@{
-    inline bool isSpawnerFun(const Function* fun) const
+    inline bool isSpawnerFun(const SVFFunction* fun) const
     {
         return spawners.find(fun) != spawners.end();
     }
-    inline bool isSpawneeFun(const Function* fun) const
+    inline bool isSpawneeFun(const SVFFunction* fun) const
     {
         return spawnees.find(fun) != spawnees.end();
     }
-    inline bool isFollowerFun(const Function* fun) const
+    inline bool isFollowerFun(const SVFFunction* fun) const
     {
         return followers.find(fun) != followers.end();
     }
-    inline bool addSpawnerFun(const Function* fun)
+    inline bool addSpawnerFun(const SVFFunction* fun)
     {
         if (fun->isDeclaration())
             return false;
         return spawners.insert(fun).second;
     }
-    inline bool addSpawneeFun(const Function* fun)
+    inline bool addSpawneeFun(const SVFFunction* fun)
     {
         if (fun->isDeclaration())
             return false;
         return spawnees.insert(fun).second;
     }
-    inline bool addFollowerFun(const Function* fun)
+    inline bool addFollowerFun(const SVFFunction* fun)
     {
         if (fun->isDeclaration())
             return false;
@@ -106,11 +106,11 @@ private:
 
     /// Add/search spawn sites which directly or indirectly create a thread
     //@{
-    inline bool addSpawnsite(const Instruction* callInst)
+    inline bool addSpawnsite(const SVFInstruction* callInst)
     {
         return spawnCallSites.insert(callInst).second;
     }
-    inline bool isSpawnsite(const Instruction* callInst)
+    inline bool isSpawnsite(const SVFInstruction* callInst)
     {
         return spawnCallSites.find(callInst) != spawnCallSites.end();
     }
@@ -145,18 +145,13 @@ public:
     {
     }
 
-    CallICFGNode* getCallICFGNode(const Instruction* inst)
+    CallICFGNode* getCallICFGNode(const SVFInstruction* inst)
     {
         return pta->getICFG()->getCallICFGNode(inst);
     }
-    const SVFFunction* getSVFFun(const Function* fun) const
-    {
-        return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
-    }
     /// Interface to query whether two function may happen-in-parallel
-    virtual bool mayHappenInParallel(const Instruction* i1, const Instruction* i2) const;
-    bool mayHappenInParallelBetweenFunctions(const Function* fun1, const Function* fun2) const;
-    //bool mayHappenInParallel(const Function* fun1, const Function* fun2) const;
+    virtual bool mayHappenInParallel(const SVFInstruction* i1, const SVFInstruction* i2) const;
+    bool mayHappenInParallelBetweenFunctions(const SVFFunction* fun1, const SVFFunction* fun2) const;
     inline const FunSet& getMHPFunctions() const
     {
         return mhpfuns;
@@ -192,27 +187,27 @@ public:
 
     /// Iterators for thread properties of a procedure
     //@{
-    inline FunSet::const_iterator spawnersBegin(const Function* fun) const
+    inline FunSet::const_iterator spawnersBegin(const SVFFunction* fun) const
     {
         return spawners.begin();
     }
-    inline FunSet::const_iterator spawnersEnd(const Function* fun) const
+    inline FunSet::const_iterator spawnersEnd(const SVFFunction* fun) const
     {
         return spawners.end();
     }
-    inline FunSet::const_iterator spawneesBegin(const Function* fun) const
+    inline FunSet::const_iterator spawneesBegin(const SVFFunction* fun) const
     {
         return spawnees.begin();
     }
-    inline FunSet::const_iterator spawneesEnd(const Function* fun) const
+    inline FunSet::const_iterator spawneesEnd(const SVFFunction* fun) const
     {
         return spawnees.end();
     }
-    inline FunSet::const_iterator followersBegin(const Function* fun) const
+    inline FunSet::const_iterator followersBegin(const SVFFunction* fun) const
     {
         return followers.begin();
     }
-    inline FunSet::const_iterator followersEnd(const Function* fun) const
+    inline FunSet::const_iterator followersEnd(const SVFFunction* fun) const
     {
         return followers.end();
     }