svf-lib 1.0.992 → 1.0.995

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

@@ -22,40 +22,48 @@ class MHP;
 class LockAnalysis;
 
 
-class SVFGNodeLockSpan {
+class SVFGNodeLockSpan
+{
 public:
-	SVFGNodeLockSpan(const StmtSVFGNode* SVFGnode, LockAnalysis::LockSpan lockspan) :
-	SVFGNode(SVFGnode), lockSpan(lockspan) {}
-	virtual ~SVFGNodeLockSpan() {}
-	
-	inline bool operator< (const SVFGNodeLockSpan& rhs) const {
-		if (SVFGNode != rhs.getSVFGNode())
-			return SVFGNode < rhs.getSVFGNode();
-		return lockSpan.size() < rhs.getLockSpan().size();
-	}
-	inline SVFGNodeLockSpan& operator= (const SVFGNodeLockSpan& rhs) {
-		if(*this != rhs) {
-			SVFGNode = rhs.getSVFGNode();
-			lockSpan = rhs.getLockSpan();
-		}
-		return *this;
-	}
-	inline bool operator== (const SVFGNodeLockSpan& rhs) const {
-		return (SVFGNode == rhs.getSVFGNode() && lockSpan == rhs.getLockSpan());
-	}
-	inline bool operator!= (const SVFGNodeLockSpan& rhs) const {
-		return !(*this == rhs);
-	}
-	inline const StmtSVFGNode* getSVFGNode() const {
-		return SVFGNode;
-	}
-	inline const LockAnalysis::LockSpan getLockSpan() const {
-		return lockSpan;
-	}
+    SVFGNodeLockSpan(const StmtSVFGNode* SVFGnode, LockAnalysis::LockSpan lockspan) :
+        SVFGNode(SVFGnode), lockSpan(lockspan) {}
+    virtual ~SVFGNodeLockSpan() {}
+
+    inline bool operator< (const SVFGNodeLockSpan& rhs) const
+    {
+        if (SVFGNode != rhs.getSVFGNode())
+            return SVFGNode < rhs.getSVFGNode();
+        return lockSpan.size() < rhs.getLockSpan().size();
+    }
+    inline SVFGNodeLockSpan& operator= (const SVFGNodeLockSpan& rhs)
+    {
+        if(*this != rhs)
+        {
+            SVFGNode = rhs.getSVFGNode();
+            lockSpan = rhs.getLockSpan();
+        }
+        return *this;
+    }
+    inline bool operator== (const SVFGNodeLockSpan& rhs) const
+    {
+        return (SVFGNode == rhs.getSVFGNode() && lockSpan == rhs.getLockSpan());
+    }
+    inline bool operator!= (const SVFGNodeLockSpan& rhs) const
+    {
+        return !(*this == rhs);
+    }
+    inline const StmtSVFGNode* getSVFGNode() const
+    {
+        return SVFGNode;
+    }
+    inline const LockAnalysis::LockSpan getLockSpan() const
+    {
+        return lockSpan;
+    }
 private:
-	const StmtSVFGNode* SVFGNode;
-	LockAnalysis::LockSpan lockSpan;
-};	
+    const StmtSVFGNode* SVFGNode;
+    LockAnalysis::LockSpan lockSpan;
+};
 
 /*!
  * SVFG builder for DDA
@@ -73,7 +81,7 @@ public:
     typedef Set<const Instruction*> InstSet;
     typedef std::pair<NodeID,NodeID> NodeIDPair;
     typedef Map<SVFGNodeLockSpan, bool> PairToBoolMap;
-    
+
     /// Constructor
     MTASVFGBuilder(MHP* m, LockAnalysis* la) : SVFGBuilder(), mhp(m), lockana(la)
     {
@@ -183,11 +191,12 @@ public:
 
     /// Initialize analysis
     void initialize(SVFModule* module);
-	
-	inline SVFIR* getPAG() {
-		return mhp->getTCT()->getPTA()->getPAG();
-	}
-	
+
+    inline SVFIR* getPAG()
+    {
+        return mhp->getTCT()->getPTA()->getPAG();
+    }
+
     /// Create signle instance of flow-sensitive pointer analysis
     static FSMPTA* createFSMPTA(SVFModule* module, MHP* m, LockAnalysis* la)
     {
@@ -222,12 +231,14 @@ private:
 
 } // End namespace SVF
 
-template <> struct std::hash<SVF::SVFGNodeLockSpan> {
-	size_t operator()(const SVF::SVFGNodeLockSpan &cs) const {
-		std::hash<SVF::StmtSVFGNode* >h;
-		SVF::StmtSVFGNode* node = const_cast<SVF::StmtSVFGNode* > (cs.getSVFGNode());
-		return h(node);
-	}
+template <> struct std::hash<SVF::SVFGNodeLockSpan>
+{
+    size_t operator()(const SVF::SVFGNodeLockSpan &cs) const
+    {
+        std::hash<SVF::StmtSVFGNode* >h;
+        SVF::StmtSVFGNode* node = const_cast<SVF::StmtSVFGNode* > (cs.getSVFGNode());
+        return h(node);
+    }
 };
 
 #endif /* FSPTANALYSIS_H_ */

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

@@ -224,10 +224,11 @@ public:
         }
         return find;
     }
-	
-	CxtStmtToCxtLockSet getCSTCLS() {
-		return cxtStmtToCxtLockSet;
-	}
+
+    CxtStmtToCxtLockSet getCSTCLS()
+    {
+        return cxtStmtToCxtLockSet;
+    }
     /// Touch this context statement
     inline void touchCxtStmt(CxtStmt& cts)
     {
@@ -297,11 +298,12 @@ public:
     }
     /// Print locks and spans
     void printLocks(const CxtStmt& cts);
-    
-	/// Get tct 
-	TCT* getTCT() {
-		return tct;
-	}
+
+    /// Get tct
+    TCT* getTCT()
+    {
+        return tct;
+    }
 private:
     /// Handle fork
     void handleFork(const CxtStmt& cts);

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

@@ -13,53 +13,61 @@
 
 /* Validate the result of lock analysis */
 
-namespace SVF {
-class LockResultValidator {
+namespace SVF
+{
+class LockResultValidator
+{
 public:
-	typedef Set<std::string> CxtLockSetStr;
-	typedef Map<const Instruction*, CxtLockSetStr> CxtStmtToCxtLockS;
-	
-	typedef unsigned LOCK_FLAG;
-	
-	LockResultValidator(LockAnalysis* la) : _la(la) {
-		_mod = _la->getTCT()->getSVFModule();
-	}
-	
-	~LockResultValidator() {}
-	
-	void analyze();
-	
-	inline SVFModule* getModule() const {
-		return _mod;
-	}
+    typedef Set<std::string> CxtLockSetStr;
+    typedef Map<const Instruction*, CxtLockSetStr> CxtStmtToCxtLockS;
+
+    typedef unsigned LOCK_FLAG;
+
+    LockResultValidator(LockAnalysis* la) : _la(la)
+    {
+        _mod = _la->getTCT()->getSVFModule();
+    }
+
+    ~LockResultValidator() {}
+
+    void analyze();
+
+    inline SVFModule* getModule() const
+    {
+        return _mod;
+    }
 private:
-	// Get CallICFGNode
-	inline CallICFGNode* getCBN(const Instruction* inst) {
-		return _la->getTCT()->getCallICFGNode(inst);
-	}
-	const Instruction *getPreviousMemoryAccessInst( const Instruction *I) {
+    // Get CallICFGNode
+    inline CallICFGNode* getCBN(const Instruction* inst)
+    {
+        return _la->getTCT()->getCallICFGNode(inst);
+    }
+    const Instruction *getPreviousMemoryAccessInst( const Instruction *I)
+    {
         I = I->getPrevNode();
         while (I)
         {
             if (SVFUtil::isa<LoadInst>(I) || SVFUtil::isa<StoreInst>(I))
                 return I;
             SVFFunction* callee = nullptr;
-            
-            if(SVFUtil::isa<CallInst> (I)) {
-            	PTACallGraph::FunctionSet callees;
-		        _la->getTCT()->getThreadCallGraph()->getCallees(getCBN(I), callees);
-		        
-		        for(PTACallGraph::FunctionSet::const_iterator cit = callees.begin(),
-		                	ecit = callees.end(); cit!=ecit; cit++)
-		    	{
-					if(*cit != nullptr) {
-						callee = const_cast<SVFFunction*> (*cit);
-						break;
-					}
-						
-		    	}
+
+            if(SVFUtil::isa<CallInst> (I))
+            {
+                PTACallGraph::FunctionSet callees;
+                _la->getTCT()->getThreadCallGraph()->getCallees(getCBN(I), callees);
+
+                for(PTACallGraph::FunctionSet::const_iterator cit = callees.begin(),
+                        ecit = callees.end(); cit!=ecit; cit++)
+                {
+                    if(*cit != nullptr)
+                    {
+                        callee = const_cast<SVFFunction*> (*cit);
+                        break;
+                    }
+
+                }
             }
-            
+
             if (callee)
             {
                 if (ExtAPI::EFT_L_A0__A0R_A1R == ExtAPI::getExtAPI()->get_type(callee)
@@ -70,39 +78,41 @@ private:
         }
         return nullptr;
     }
-    
-    inline bool inFilter(std::string name) {
-    	return filterFun.find(name) != filterFun.end();
+
+    inline bool inFilter(std::string name)
+    {
+        return filterFun.find(name) != filterFun.end();
     }
-    
-    inline bool match(std::string lockName, CxtLockSetStr LS) {
-    	return LS.find(lockName) != LS.end();
+
+    inline bool match(std::string lockName, CxtLockSetStr LS)
+    {
+        return LS.find(lockName) != LS.end();
     }
-    
+
     Set<std::string> &split(const std::string &s, char delim, Set<std::string> &elems);
     Set<std::string> split(const std::string &s, char delim);
-    
+
     std::string getOutput(const char* scenario, LOCK_FLAG analysisRes);
-    
+
     Set<std::string> getStringArg(const Instruction* inst, unsigned int arg_num);
-    
+
     bool collectLockTargets();
     LOCK_FLAG validateStmtInLock();
-    
+
     CxtStmtToCxtLockS instToCxtLockSet;
     LockAnalysis::CxtStmtToCxtLockSet cxtStmtToCxtLockSet;
     LockAnalysis::CxtLockSet cxtLockSet;
-    
+
     LockAnalysis* _la;
     SVFModule* _mod;
-    
+
     static const LOCK_FLAG LOCK_TRUE = 0x01;
     static const LOCK_FLAG LOCK_IMPRECISE = 0x02;
     static const LOCK_FLAG LOCK_UNSOUND = 0x04;
-    
+
     static constexpr char const *LOCK = "LOCK";
-    
+
     Set<std::string> filterFun = {"LOCK", "INTERLEV_ACCESS", "PAUSE", "CXT_THREAD", "TCT_ACCESS"};
-};	
+};
 }	// End namespace SVF
 #endif /* LOCKRESULTVALIDATOR_H_ */

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

@@ -60,11 +60,12 @@ public:
     {
         return tct;
     }
-	
-	// Get CallICFGNode
-	inline CallICFGNode* getCBN(const Instruction* inst) {
-		return tct->getCallICFGNode(inst);
-	}
+
+    // Get CallICFGNode
+    inline CallICFGNode* getCBN(const Instruction* inst)
+    {
+        return tct->getCallICFGNode(inst);
+    }
 
     /// Whether the function is connected from main function in thread call graph
     bool isConnectedfromMain(const Function* fun);
@@ -115,11 +116,12 @@ public:
     void printInterleaving();
 
 private:
-	
-	inline const PTACallGraph::FunctionSet& getCallee(const Instruction* inst, PTACallGraph::FunctionSet& callees) {
+
+    inline const PTACallGraph::FunctionSet& getCallee(const Instruction* inst, PTACallGraph::FunctionSet& callees)
+    {
         tcg->getCallees(getCBN(inst), callees);
         return callees;
-	}
+    }
     /// Update non-candidate functions' interleaving.
     /// Copy interleaving threads of the entry inst to other insts.
     void updateNonCandidateFunInterleaving();
@@ -380,9 +382,10 @@ private:
         return tct->getPTA()->alias(getForkedThread(forkSite), getJoinedThread(joinSite)) && isSameSCEV(forkSite,joinSite);
     }
     // Get CallICFGNode
-	inline CallICFGNode* getCBN(const Instruction* inst) {
-		return tct->getCallICFGNode(inst);
-	}
+    inline CallICFGNode* getCBN(const Instruction* inst)
+    {
+        return tct->getCallICFGNode(inst);
+    }
     /// Mark thread flags for cxtStmt
     //@{
     /// Get the flag for a cxtStmt
@@ -485,10 +488,11 @@ private:
     {
         return getTCG()->getThreadAPI()->getJoinedThread(call);
     }
-    inline const PTACallGraph::FunctionSet& getCallee(const Instruction* inst, PTACallGraph::FunctionSet& callees) {
+    inline const PTACallGraph::FunctionSet& getCallee(const Instruction* inst, PTACallGraph::FunctionSet& callees)
+    {
         getTCG()->getCallees(getCBN(inst), callees);
         return callees;
-	}
+    }
     /// ThreadCallGraph
     inline ThreadCallGraph* getTCG() const
     {

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

@@ -14,9 +14,10 @@
  * Validate the result of context-sensitive analysis, including context-sensitive
  * thread detection and thread interleaving.
  */
- namespace SVF{
- typedef unsigned NodeID;
- 
+namespace SVF
+{
+typedef unsigned NodeID;
+
 class MTAResultValidator
 {
 
@@ -36,9 +37,10 @@ public:
 
     // Analysis
     void analyze();
-	inline SVFModule* getModule() const {
-		return mod;
-	}
+    inline SVFModule* getModule() const
+    {
+        return mod;
+    }
 protected:
 
     /*
@@ -132,12 +134,12 @@ private:
     ThreadAPI* tdAPI;
     ThreadCallGraph* tcg;
     MHP* mhp;
-	vthdToCxtMap vthdToCxt;
-	vthdTorthdMap vthdTorthd;
-	rthdTovthdMap rthdTovthd;
-	csnumToInst	csnumToInstMap;
-	rthdToChildrenMap rthdToChildren;
-	SVFModule* mod;
+    vthdToCxtMap vthdToCxt;
+    vthdTorthdMap vthdTorthd;
+    rthdTovthdMap rthdTovthd;
+    csnumToInst	csnumToInstMap;
+    rthdToChildrenMap rthdToChildren;
+    SVFModule* mod;
     /// Constant INTERLEV_FLAG values
     //@{
     static const INTERLEV_FLAG INTERLEV_TRUE = 0x01;
@@ -274,13 +276,15 @@ protected:
         // 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++){
- 			const std::string fName = (*it)->getName().str();
- 			if(fName.find(RC_ACCESS) != std::string::npos) {
- 				F = (*it);
- 				break;
- 			}
- 		}       
+        for(auto it = M->llvmFunBegin(); it != M->llvmFunEnd(); it++)
+        {
+            const std::string fName = (*it)->getName().str();
+            if(fName.find(RC_ACCESS) != std::string::npos)
+            {
+                F = (*it);
+                break;
+            }
+        }
         if (!F)     return;
 
         for (Value::const_use_iterator it = F->use_begin(), ie =
@@ -409,7 +413,7 @@ private:
         {
             if (SVFUtil::isa<LoadInst>(I) || SVFUtil::isa<StoreInst>(I))
                 return I;
-                
+
             if (const SVFFunction *callee = SVFUtil::getCallee(I))
             {
                 if (ExtAPI::EFT_L_A0__A0R_A1R == ExtAPI::getExtAPI()->get_type(callee)

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

@@ -122,13 +122,15 @@ public:
     virtual ~PCG()
     {
     }
-	
-	CallICFGNode* getCallICFGNode(const Instruction* inst) {
-		return pta->getICFG()->getCallICFGNode(inst);
-	}
-	const SVFFunction* getSVFFun(const Function* fun) const {
-		return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
-	}
+
+    CallICFGNode* getCallICFGNode(const Instruction* 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;

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

@@ -148,18 +148,21 @@ public:
         destroy();
     }
     /// Get CallICFGNode given inst
-    CallICFGNode* getCallICFGNode(const Instruction* inst) {
-		return pta->getICFG()->getCallICFGNode(inst);
-	}
-	/// Get SVFFuntion given Function 
-	const SVFFunction* getSVFFun(const Function* fun) const {
-		return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
-	}
-	/// Get SVFFModule
-	SVFModule* getSVFModule() const {
-		return pta->getModule();
-	}
-	
+    CallICFGNode* getCallICFGNode(const Instruction* inst)
+    {
+        return pta->getICFG()->getCallICFGNode(inst);
+    }
+    /// Get SVFFuntion given Function
+    const SVFFunction* getSVFFun(const Function* fun) const
+    {
+        return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
+    }
+    /// Get SVFFModule
+    SVFModule* getSVFModule() const
+    {
+        return pta->getModule();
+    }
+
     /// Get TCG
     inline ThreadCallGraph* getThreadCallGraph() const
     {
@@ -245,20 +248,22 @@ public:
     /// Whether it is a candidate function for indirect call
     inline bool isCandidateFun(const PTACallGraph::FunctionSet& callees) const
     {
-    	for(PTACallGraph::FunctionSet::const_iterator cit = callees.begin(),
-                    	ecit = callees.end(); cit!=ecit; cit++)
+        for(PTACallGraph::FunctionSet::const_iterator cit = callees.begin(),
+                ecit = callees.end(); cit!=ecit; cit++)
         {
-        	if(candidateFuncSet.find((*cit)->getLLVMFun())!=candidateFuncSet.end())
-        		return true;
+            if(candidateFuncSet.find((*cit)->getLLVMFun())!=candidateFuncSet.end())
+                return true;
         }
         return false;
     }
-	inline bool isCandidateFun(const Function* fun) const {
-		return candidateFuncSet.find(fun)!=candidateFuncSet.end();
-	}
-	inline bool isCandidateFun(const SVFFunction* fun) const {
-		return isCandidateFun(fun->getLLVMFun());
-	}
+    inline bool isCandidateFun(const Function* fun) const
+    {
+        return candidateFuncSet.find(fun)!=candidateFuncSet.end();
+    }
+    inline bool isCandidateFun(const SVFFunction* fun) const
+    {
+        return isCandidateFun(fun->getLLVMFun());
+    }
     /// Whether two functions in the same callgraph scc
     inline bool inSameCallGraphSCC(const PTACallGraphNode* src,const PTACallGraphNode* dst)
     {

package/SVF-linux/include/MemoryModel/LocationSet.h

@@ -104,7 +104,7 @@ public:
     /// Return accumulated constant offset given OffsetValueVec
     s32_t accumulateConstantOffset() const;
 
-    /// Return element number of a type. 
+    /// Return element number of a type.
     u32_t getElementNum(const Type* type) const;
 
     bool addOffsetValue(const Value* offsetValue, const Type* type);
@@ -135,8 +135,10 @@ private:
 
 } // End namespace SVF
 
-template <> struct std::hash<SVF::LocationSet> {
-    size_t operator()(const SVF::LocationSet &ls) const {
+template <> struct std::hash<SVF::LocationSet>
+{
+    size_t operator()(const SVF::LocationSet &ls) const
+    {
         SVF::Hash<std::pair<SVF::NodeID, SVF::NodeID>> h;
         std::hash<SVF::LocationSet::OffsetValueVec> v;
         return h(std::make_pair(ls.accumulateConstantFieldIdx(), v(ls.getOffsetValueVec())));

package/SVF-linux/include/MemoryModel/PersistentPointsToCache.h

@@ -34,7 +34,10 @@ public:
     // TODO: an unordered pair type may be better.
     typedef Map<std::pair<PointsToID, PointsToID>, PointsToID> OpCache;
 
-    static PointsToID emptyPointsToId(void) { return 0; };
+    static PointsToID emptyPointsToId(void)
+    {
+        return 0;
+    };
 
 public:
     PersistentPointsToCache(void) : idCounter(1)
@@ -48,13 +51,13 @@ public:
     /// Clear the cache.
     void clear()
     {
-      for (const Data *d : idToPts) delete d;
-      idToPts.clear();
-      ptsToId.clear();
+        for (const Data *d : idToPts) delete d;
+        idToPts.clear();
+        ptsToId.clear();
 
-      unionCache.clear();
-      complementCache.clear();
-      intersectionCache.clear();
+        unionCache.clear();
+        complementCache.clear();
+        intersectionCache.clear();
     }
 
     /// Resets the cache removing everything except the emptyData it was initialised with.
@@ -108,7 +111,10 @@ public:
     /// Unions lhs and rhs and returns their union's ID.
     PointsToID unionPts(PointsToID lhs, PointsToID rhs)
     {
-        static const DataOp unionOp = [](const Data &lhs, const Data &rhs) { return lhs | rhs; };
+        static const DataOp unionOp = [](const Data &lhs, const Data &rhs)
+        {
+            return lhs | rhs;
+        };
 
         ++totalUnions;
 
@@ -155,7 +161,8 @@ public:
                 ++preemptiveUnions;
                 ++totalUnions;
             }
-        } else ++lookupUnions;
+        }
+        else ++lookupUnions;
 
         return result;
     }
@@ -163,7 +170,10 @@ public:
     /// Relatively complements lhs and rhs (lhs \ rhs) and returns it's ID.
     PointsToID complementPts(PointsToID lhs, PointsToID rhs)
     {
-        static const DataOp complementOp = [](const Data &lhs, const Data &rhs) { return lhs - rhs; };
+        static const DataOp complementOp = [](const Data &lhs, const Data &rhs)
+        {
+            return lhs - rhs;
+        };
 
         ++totalComplements;
 
@@ -214,7 +224,8 @@ public:
                 ++preemptiveComplements;
                 ++totalComplements;
             }
-        } else ++lookupComplements;
+        }
+        else ++lookupComplements;
 
         return result;
     }
@@ -222,7 +233,10 @@ public:
     /// Intersects lhs and rhs (lhs AND rhs) and returns the intersection's ID.
     PointsToID intersectPts(PointsToID lhs, PointsToID rhs)
     {
-        static const DataOp intersectionOp = [](const Data &lhs, const Data &rhs) { return lhs & rhs; };
+        static const DataOp intersectionOp = [](const Data &lhs, const Data &rhs)
+        {
+            return lhs & rhs;
+        };
 
         ++totalIntersections;
 
@@ -287,7 +301,8 @@ public:
                     ++totalUnions;
                 }
             }
-        } else ++lookupIntersections;
+        }
+        else ++lookupIntersections;
 
         return result;
     }