svf-lib 1.0.1276 → 1.0.1278

package/SVF-osx/include/Graphs/VFGNode.h

@@ -182,7 +182,7 @@ public:
                || node->getNodeKind() == Load;
     }
 
-    inline const Instruction* getInst() const
+    inline const SVFInstruction* getInst() const
     {
         /// should return a valid instruction unless it is a global PAGEdge
         return pagEdge->getInst();

package/SVF-osx/include/MSSA/MSSAMuChi.h

@@ -167,12 +167,12 @@ class LoadMU : public MSSAMU<Cond>
 
 private:
     const LoadStmt* inst;
-    const BasicBlock* bb;
+    const SVFBasicBlock* bb;
 
 public:
     /// Constructor/Destructor for MU
     //@{
-    LoadMU(const BasicBlock* b,const LoadStmt* i, const MemRegion* m, Cond c = true) :
+    LoadMU(const SVFBasicBlock* b,const LoadStmt* i, const MemRegion* m, Cond c = true) :
         MSSAMU<Cond>(MSSAMU<Cond>::LoadMSSAMU,m,c), inst(i), bb(b)
     {
     }
@@ -189,7 +189,7 @@ public:
     }
 
     /// Return basic block
-    inline const BasicBlock* getBasicBlock() const
+    inline const SVFBasicBlock* getBasicBlock() const
     {
         return bb;
     }
@@ -244,7 +244,7 @@ public:
     }
 
     /// Return basic block
-    inline const BasicBlock* getBasicBlock() const
+    inline const SVFBasicBlock* getBasicBlock() const
     {
         return callsite->getCallSite()->getParent();
     }
@@ -461,12 +461,12 @@ template<class Cond>
 class StoreCHI : public MSSACHI<Cond>
 {
 private:
-    const BasicBlock* bb;
+    const SVFBasicBlock* bb;
     const StoreStmt* inst;
 public:
     /// Constructors for StoreCHI
     //@{
-    StoreCHI(const BasicBlock* b, const StoreStmt* i, const MemRegion* m, Cond c = true) :
+    StoreCHI(const SVFBasicBlock* b, const StoreStmt* i, const MemRegion* m, Cond c = true) :
         MSSACHI<Cond>(MSSADEF::StoreMSSACHI,m,c), bb(b), inst(i)
     {
     }
@@ -476,7 +476,7 @@ public:
     //@}
 
     /// Get basic block
-    inline const BasicBlock* getBasicBlock() const
+    inline const SVFBasicBlock* getBasicBlock() const
     {
         return bb;
     }
@@ -535,7 +535,7 @@ public:
     //@}
 
     /// Return basic block
-    inline const BasicBlock* getBasicBlock() const
+    inline const SVFBasicBlock* getBasicBlock() const
     {
         return callsite->getCallSite()->getParent();
     }
@@ -632,13 +632,13 @@ class MSSAPHI : public MSSADEF
 public:
     typedef Map<u32_t,const MRVer*> OPVers;
 private:
-    const BasicBlock* bb;
+    const SVFBasicBlock* bb;
     OPVers opVers;
     Cond cond;
 public:
     /// Constructors for PHI
     //@{
-    MSSAPHI(const BasicBlock* b, const MemRegion* m, Cond c = true) :
+    MSSAPHI(const SVFBasicBlock* b, const MemRegion* m, Cond c = true) :
         MSSADEF(MSSADEF::SSAPHI,m), bb(b), cond(c)
     {
     }
@@ -681,7 +681,7 @@ public:
     //@}
 
     /// Return the basic block
-    inline const BasicBlock* getBasicBlock() const
+    inline const SVFBasicBlock* getBasicBlock() const
     {
         return bb;
     }

package/SVF-osx/include/MSSA/MemRegion.h

@@ -470,9 +470,9 @@ public:
     }
     //@}
     /// Whether this instruction has SVFIR Edge
-    bool hasSVFStmtList(const Instruction* inst);
+    bool hasSVFStmtList(const SVFInstruction* inst);
     /// Given an instruction, get all its the PAGEdge (statement) in sequence
-    SVFStmtList& getPAGEdgesFromInst(const Instruction* inst);
+    SVFStmtList& getPAGEdgesFromInst(const SVFInstruction* inst);
 
     /// getModRefInfo APIs
     //@{

package/SVF-osx/include/MSSA/MemSSA.h

@@ -81,7 +81,7 @@ public:
     typedef Map<const StoreStmt*, CHISet> StoreToChiSetMap;
     typedef Map<const CallICFGNode*, MUSet> CallSiteToMUSetMap;
     typedef Map<const CallICFGNode*, CHISet> CallSiteToCHISetMap;
-    typedef OrderedMap<const BasicBlock*, PHISet> BBToPhiSetMap;
+    typedef OrderedMap<const SVFBasicBlock*, PHISet> BBToPhiSetMap;
     //@}
 
     /// Map from fun to its entry chi set and return mu set
@@ -90,8 +90,8 @@ public:
 
     /// For phi insertion
     //@{
-    typedef std::vector<const BasicBlock*> BBList;
-    typedef Map<const BasicBlock*, MRSet> BBToMRSetMap;
+    typedef std::vector<const SVFBasicBlock*> BBList;
+    typedef Map<const SVFBasicBlock*, MRSet> BBToMRSetMap;
     typedef Map<const MemRegion*, BBList> MemRegToBBsMap;
     //@}
 
@@ -129,7 +129,7 @@ protected:
     /// SSA rename for a function
     virtual void SSARename(const SVFFunction& fun);
     /// SSA rename for a basic block
-    virtual void SSARenameBB(const BasicBlock& bb);
+    virtual void SSARenameBB(const SVFBasicBlock& bb);
 private:
     LoadToMUSetMap load2MuSetMap;
     StoreToChiSetMap store2ChiSetMap;
@@ -175,7 +175,7 @@ private:
         if (0 == varKills.count(mr))
             usedRegs.insert(mr);
     }
-    inline void collectRegDefs(const BasicBlock* bb, const MemRegion* mr)
+    inline void collectRegDefs(const SVFBasicBlock* bb, const MemRegion* mr)
     {
         varKills.insert(mr);
         reg2BBMap[mr].push_back(bb);
@@ -184,12 +184,12 @@ private:
 
     /// Add methods for mus/chis/phis
     //@{
-    inline void AddLoadMU(const BasicBlock* bb, const LoadStmt* load, const MRSet& mrSet)
+    inline void AddLoadMU(const SVFBasicBlock* bb, const LoadStmt* load, const MRSet& mrSet)
     {
         for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
             AddLoadMU(bb,load,*iter);
     }
-    inline void AddStoreCHI(const BasicBlock* bb, const StoreStmt* store, const MRSet& mrSet)
+    inline void AddStoreCHI(const SVFBasicBlock* bb, const StoreStmt* store, const MRSet& mrSet)
     {
         for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
             AddStoreCHI(bb,store,*iter);
@@ -204,18 +204,18 @@ private:
         for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
             AddCallSiteCHI(cs,*iter);
     }
-    inline void AddMSSAPHI(const BasicBlock* bb, const MRSet& mrSet)
+    inline void AddMSSAPHI(const SVFBasicBlock* bb, const MRSet& mrSet)
     {
         for (MRSet::iterator iter = mrSet.begin(), eiter = mrSet.end(); iter != eiter; ++iter)
             AddMSSAPHI(bb,*iter);
     }
-    inline void AddLoadMU(const BasicBlock* bb, const LoadStmt* load, const MemRegion* mr)
+    inline void AddLoadMU(const SVFBasicBlock* bb, const LoadStmt* load, const MemRegion* mr)
     {
         LOADMU* mu = new LOADMU(bb,load, mr);
         load2MuSetMap[load].insert(mu);
         collectRegUses(mr);
     }
-    inline void AddStoreCHI(const BasicBlock* bb, const StoreStmt* store, const MemRegion* mr)
+    inline void AddStoreCHI(const SVFBasicBlock* bb, const StoreStmt* store, const MemRegion* mr)
     {
         STORECHI* chi = new STORECHI(bb,store, mr);
         store2ChiSetMap[store].insert(chi);
@@ -235,7 +235,7 @@ private:
         collectRegUses(mr);
         collectRegDefs(chi->getBasicBlock(),mr);
     }
-    inline void AddMSSAPHI(const BasicBlock* bb, const MemRegion* mr)
+    inline void AddMSSAPHI(const SVFBasicBlock* bb, const MemRegion* mr)
     {
         bb2PhiSetMap[bb].insert(new PHI(bb, mr));
     }
@@ -392,11 +392,11 @@ public:
     {
         return callsiteToChiSetMap[cs];
     }
-    inline PHISet& getPHISet(const BasicBlock* bb)
+    inline PHISet& getPHISet(const SVFBasicBlock* bb)
     {
         return bb2PhiSetMap[bb];
     }
-    inline bool hasPHISet(const BasicBlock* bb) const
+    inline bool hasPHISet(const SVFBasicBlock* bb) const
     {
         return bb2PhiSetMap.find(bb)!=bb2PhiSetMap.end();
     }

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

@@ -104,7 +104,7 @@ public:
     typedef Set<const SVFGNode*> SVFGNodeSet;
     typedef std::vector<const SVFGNode*> SVFGNodeVec;
     typedef NodeBS SVFGNodeIDSet;
-    typedef Set<const Instruction*> InstSet;
+    typedef Set<const SVFInstruction*> InstSet;
     typedef std::pair<NodeID,NodeID> NodeIDPair;
     typedef Map<SVFGNodeLockSpan, bool> PairToBoolMap;
 

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