svf-lib 1.0.993 → 1.0.994

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

@@ -281,28 +281,33 @@ public:
         return false;
     }
 
-	/// Return all the VFGNodes of a function
-	///@{
-	inline VFGNodeSet& getVFGNodes(const SVFFunction *fun) {
-		return funToVFGNodesMap[fun];
-	}
-	inline bool hasVFGNodes(const SVFFunction *fun) const {
-		return funToVFGNodesMap.find(fun) != funToVFGNodesMap.end();
-	}
-	inline bool VFGNodes(const SVFFunction *fun) const {
-		return funToVFGNodesMap.find(fun) != funToVFGNodesMap.end();
-	}
-	inline VFGNodeSet::const_iterator getVFGNodeBegin(const SVFFunction *fun) const {
-		FunToVFGNodesMapTy::const_iterator it = funToVFGNodesMap.find(fun);
-		assert(it != funToVFGNodesMap.end() && "this function does not have any VFGNode");
-		return it->second.begin();
-	}
-	inline VFGNodeSet::const_iterator getVFGNodeEnd(const SVFFunction *fun) const {
-		FunToVFGNodesMapTy::const_iterator it = funToVFGNodesMap.find(fun);
-		assert(it != funToVFGNodesMap.end() && "this function does not have any VFGNode");
-		return it->second.end();
-	}
-	///@}
+    /// Return all the VFGNodes of a function
+    ///@{
+    inline VFGNodeSet& getVFGNodes(const SVFFunction *fun)
+    {
+        return funToVFGNodesMap[fun];
+    }
+    inline bool hasVFGNodes(const SVFFunction *fun) const
+    {
+        return funToVFGNodesMap.find(fun) != funToVFGNodesMap.end();
+    }
+    inline bool VFGNodes(const SVFFunction *fun) const
+    {
+        return funToVFGNodesMap.find(fun) != funToVFGNodesMap.end();
+    }
+    inline VFGNodeSet::const_iterator getVFGNodeBegin(const SVFFunction *fun) const
+    {
+        FunToVFGNodesMapTy::const_iterator it = funToVFGNodesMap.find(fun);
+        assert(it != funToVFGNodesMap.end() && "this function does not have any VFGNode");
+        return it->second.begin();
+    }
+    inline VFGNodeSet::const_iterator getVFGNodeEnd(const SVFFunction *fun) const
+    {
+        FunToVFGNodesMapTy::const_iterator it = funToVFGNodesMap.find(fun);
+        assert(it != funToVFGNodesMap.end() && "this function does not have any VFGNode");
+        return it->second.end();
+    }
+    ///@}
     /// Add control-flow edges for top level pointers
     //@{
     VFGEdge* addIntraDirectVFEdge(NodeID srcId, NodeID dstId);
@@ -462,9 +467,9 @@ protected:
         icfgNode->addVFGNode(vfgNode);
 
         if(const SVFFunction* fun = icfgNode->getFun())
-        	funToVFGNodesMap[fun].insert(vfgNode);
+            funToVFGNodesMap[fun].insert(vfgNode);
         else
-        	globalVFGNodes.insert(vfgNode);
+            globalVFGNodes.insert(vfgNode);
     }
 
     /// Add a VFG node for program statement
@@ -545,20 +550,21 @@ protected:
     /// Otherwise, we need to handle formalRet using <PAGNodeID,CallSiteID> pair to find FormalRetVFG node same as handling actual parameters
     inline void addFormalRetVFGNode(const PAGNode* uniqueFunRet, const SVFFunction* fun, RetPESet& retPEs)
     {
-		FormalRetVFGNode *sNode = new FormalRetVFGNode(totalVFGNode++, uniqueFunRet, fun);
-		addVFGNode(sNode, pag->getICFG()->getFunExitICFGNode(fun));
-		for (RetPESet::const_iterator it = retPEs.begin(), eit = retPEs.end(); it != eit; ++it)
-			sNode->addRetPE(*it);
-
-		PAGNodeToFormalRetMap[uniqueFunRet] = sNode;
-		/// if this uniqueFunRet is a phi node, which means it will receive values from multiple return instructions of fun
-		/// we will set this phi node's def later
-		/// Ideally, every function uniqueFunRet should be a PhiNode (SVFIRBuilder.cpp), unless it does not have ret instruction
-		if (!pag->isPhiNode(uniqueFunRet)){
-			std::string warn = fun->getName();
-			SVFUtil::writeWrnMsg(warn + " does not have any ret instruction!");
-			setDef(uniqueFunRet, sNode);
-		}
+        FormalRetVFGNode *sNode = new FormalRetVFGNode(totalVFGNode++, uniqueFunRet, fun);
+        addVFGNode(sNode, pag->getICFG()->getFunExitICFGNode(fun));
+        for (RetPESet::const_iterator it = retPEs.begin(), eit = retPEs.end(); it != eit; ++it)
+            sNode->addRetPE(*it);
+
+        PAGNodeToFormalRetMap[uniqueFunRet] = sNode;
+        /// if this uniqueFunRet is a phi node, which means it will receive values from multiple return instructions of fun
+        /// we will set this phi node's def later
+        /// Ideally, every function uniqueFunRet should be a PhiNode (SVFIRBuilder.cpp), unless it does not have ret instruction
+        if (!pag->isPhiNode(uniqueFunRet))
+        {
+            std::string warn = fun->getName();
+            SVFUtil::writeWrnMsg(warn + " does not have any ret instruction!");
+            setDef(uniqueFunRet, sNode);
+        }
     }
     /// Add a callsite Receive VFG node
     inline void addActualRetVFGNode(const PAGNode* ret,const CallICFGNode* cs)
@@ -619,7 +625,7 @@ protected:
         setDef(edge->getRes(),sNode);
         PAGNodeToUnaryOPVFGNodeMap[edge->getRes()] = sNode;
     }
-    /// Add a BranchVFGNode 
+    /// Add a BranchVFGNode
     inline void addBranchVFGNode(const BranchStmt* edge)
     {
         BranchVFGNode* sNode = new BranchVFGNode(totalVFGNode++, edge);

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

@@ -563,18 +563,22 @@ public:
     //@}
 
     /// Return the branch statement
-    const BranchStmt* getBranchStmt() const{
+    const BranchStmt* getBranchStmt() const
+    {
         return brstmt;
     }
     /// Successors of this branch statement
     ///@{
-    u32_t getNumSuccessors() const{
+    u32_t getNumSuccessors() const
+    {
         return brstmt->getNumSuccessors();
     }
-    const BranchStmt::SuccAndCondPairVec& getSuccessors() const{
+    const BranchStmt::SuccAndCondPairVec& getSuccessors() const
+    {
         return brstmt->getSuccessors();
     }
-    const ICFGNode* getSuccessor (u32_t i) const{
+    const ICFGNode* getSuccessor (u32_t i) const
+    {
         return brstmt->getSuccessor(i);
     }
     ///@}

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

@@ -343,7 +343,7 @@ public:
     inline bool hasCHI(const PAGEdge* inst) const
     {
         if (const StoreStmt* store = SVFUtil::dyn_cast<StoreStmt>(
-                                       inst))
+                                         inst))
         {
             assert(0 != store2ChiSetMap.count(store)
                    && "not associated with mem region!");

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