svf-lib 1.0.733 → 1.0.737

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

@@ -33,8 +33,7 @@
 #include "Graphs/GenericGraph.h"
 #include "Graphs/VFGEdge.h"
 #include "Graphs/ICFGNode.h"
-#include "Graphs/PAGNode.h"
-#include "Graphs/PAGEdge.h"
+#include "MemoryModel/SVFIR.h"
 
 namespace SVF
 {
@@ -52,7 +51,7 @@ public:
     /// Gep represents offset edge for field sensitivity
     enum VFGNodeK
     {
-        Addr, Copy, Gep, Store, Load, Cmp, BinaryOp, UnaryOp, TPhi, TIntraPhi, TInterPhi,
+        Addr, Copy, Gep, Store, Load, Cmp, BinaryOp, UnaryOp, Branch, TPhi, TIntraPhi, TInterPhi,
         MPhi, MIntraPhi, MInterPhi, FRet, ARet, AParm, FParm,
         FunRet, APIN, APOUT, FPIN, FPOUT, NPtr, DummyVProp
     };
@@ -331,7 +330,7 @@ public:
     CmpVFGNode(NodeID id,const PAGNode* r): VFGNode(id,Cmp), res(r)
     {
         const CmpInst* cmp = SVFUtil::dyn_cast<CmpInst>(r->getValue());
-        assert(cmp && "not a binary operator?");
+        assert(cmp && "not a compare operator?");
     }
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -474,10 +473,7 @@ public:
     /// Constructor
 	UnaryOPVFGNode(NodeID id, const PAGNode *r) : VFGNode(id, UnaryOp), res(r) {
 		const Value *val = r->getValue();
-		bool unop = (SVFUtil::isa<UnaryOperator>(val)
-				|| SVFUtil::isa<BranchInst>(val)
-				|| SVFUtil::isa<SwitchInst>(val));
-		assert(unop && "not a unary operator or a BranchInst or a SwitchInst?");
+		assert(SVFUtil::isa<UnaryOperator>(val) && "not a unary instruction ?");
 	}
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -510,6 +506,11 @@ public:
     {
         return res;
     }
+    inline const PAGNode* getOpVar() const
+    {
+        assert(getOpVerNum()==1 && "UnaryNode can only have one operand!");
+        return getOpVer(0);
+    }
     inline u32_t getOpVerNum() const
     {
         return opVers.size();
@@ -527,6 +528,57 @@ public:
     virtual const std::string toString() const;
 };
 
+/*
+* Branch VFGNode including if/else and switch statements
+*/
+class BranchVFGNode: public VFGNode
+{
+private:
+    BranchVFGNode();                      ///< place holder
+    BranchVFGNode(const BranchVFGNode &);  ///< place holder
+    void operator=(const BranchVFGNode &); ///< place holder
+    const BranchStmt* brstmt;
+public:
+    /// Constructor
+	BranchVFGNode(NodeID id, const BranchStmt* r) : VFGNode(id, Branch), brstmt(r) {
+		const Value *val = r->getValue();
+		assert((SVFUtil::isa<BranchInst>(val) || SVFUtil::isa<SwitchInst>(val)) && "not a BranchInst or a SwitchInst?");
+	}
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const BranchVFGNode *)
+    {
+        return true;
+    }
+    static inline bool classof(const VFGNode *node)
+    {
+        return node->getNodeKind() == Branch;
+    }
+    static inline bool classof(const GenericVFGNodeTy *node)
+    {
+        return node->getNodeKind() == Branch;
+    }
+    //@}
+
+    /// Return the branch statement 
+    const BranchStmt* getBranchStmt() const{
+        return brstmt;
+    }
+    /// Successors of this branch statement
+    ///@{
+    u32_t getNumSuccessors() const{
+        return brstmt->getNumSuccessors();
+    }
+    const std::vector<const ICFGNode*>& getSuccessors() const{
+        return brstmt->getSuccessors();
+    }
+    const ICFGNode* getSuccessor (u32_t i) const{
+        return brstmt->getSuccessor(i);
+    }
+    ///@}
+    virtual const std::string toString() const override;
+};
+
 /*!
  * VFGNode for Gep
  */

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

@@ -30,7 +30,7 @@
 #ifndef MEMORYREGION_H_
 #define MEMORYREGION_H_
 
-#include "Graphs/PAG.h"
+#include "MemoryModel/SVFIR.h"
 #include "Graphs/PTACallGraph.h"
 #include "Util/SCC.h"
 #include "Util/WorkList.h"
@@ -168,8 +168,8 @@ public:
 
     typedef Map<NodeID, NodeBS> NodeToPTSSMap;
 
-    /// PAG edge list
-    typedef PAG::PAGEdgeList PAGEdgeList;
+    /// SVFIR edge list
+    typedef SVFIR::PAGEdgeList PAGEdgeList;
     /// Call Graph SCC
     typedef SCCDetection<PTACallGraph*> SCC;
 
@@ -197,17 +197,17 @@ private:
 
     /// Map a function to all its memory regions
     FunToMRsMap funToMRsMap;
-    /// Map a load PAG Edge to its memory regions sets in order for inserting mus in Memory SSA
+    /// Map a load SVFIR Edge to its memory regions sets in order for inserting mus in Memory SSA
     LoadsToMRsMap loadsToMRsMap;
-    /// Map a store PAG Edge to its memory regions sets in order for inserting chis in Memory SSA
+    /// Map a store SVFIR Edge to its memory regions sets in order for inserting chis in Memory SSA
     StoresToMRsMap storesToMRsMap;
     /// Map a callsite to its refs regions
     CallSiteToMRsMap callsiteToRefMRsMap;
     /// Map a callsite to its mods regions
     CallSiteToMRsMap callsiteToModMRsMap;
-    /// Map a load PAG Edge to its CPts set map
+    /// Map a load SVFIR Edge to its CPts set map
     LoadsToPointsToMap loadsToPointsToMap;
-    /// Map a store PAG Edge to its CPts set map
+    /// Map a store SVFIR Edge to its CPts set map
     StoresToPointsToMap	storesToPointsToMap;
     /// Map a callsite to it refs cpts set
     CallSiteToPointsToMap callsiteToRefPointsToMap;
@@ -235,7 +235,7 @@ private:
     /// Map a pointer to its cached points-to chain;
     NodeToPTSSMap cachedPtsChainMap;
 
-    /// All global variable PAG node ids
+    /// All global variable SVFIR node ids
     NodeBS allGlobals;
 
     /// Clean up memory
@@ -427,11 +427,11 @@ public:
     /// Start generating memory regions
     virtual void generateMRs();
 
-    /// Get the function which PAG Edge located
+    /// Get the function which SVFIR Edge located
     const SVFFunction* getFunction(const PAGEdge* pagEdge) const
     {
         PAGEdgeToFunMap::const_iterator it = pagEdgeToFunMap.find(pagEdge);
-        assert(it!=pagEdgeToFunMap.end() && "can not find its function, it is a global PAG edge");
+        assert(it!=pagEdgeToFunMap.end() && "can not find its function, it is a global SVFIR edge");
         return it->second;
     }
     /// Get Memory Region set
@@ -465,7 +465,7 @@ public:
         return callsiteToModMRsMap[cs];
     }
     //@}
-    /// Whether this instruction has PAG Edge
+    /// Whether this instruction has SVFIR Edge
     bool hasPAGEdgeList(const Instruction* inst);
     /// Given an instruction, get all its the PAGEdge (statement) in sequence
     PAGEdgeList& getPAGEdgesFromInst(const Instruction* inst);

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

@@ -93,8 +93,8 @@ public:
     typedef Map<const MemRegion*, std::vector<MRVer*> > MemRegToVerStackMap;
     typedef Map<const MemRegion*, MRVERSION> MemRegToCounterMap;
 
-    /// PAG edge list
-    typedef PAG::PAGEdgeList PAGEdgeList;
+    /// SVFIR edge list
+    typedef SVFIR::PAGEdgeList PAGEdgeList;
 
     /// Statistics
     //@{
@@ -309,8 +309,8 @@ public:
     {
         destroy();
     }
-    /// Return PAG
-    inline PAG* getPAG();
+    /// Return SVFIR
+    inline SVFIR* getPAG();
     /// Return PTA
     inline BVDataPTAImpl* getPTA() const
     {

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

@@ -184,7 +184,7 @@ public:
     /// Initialize analysis
     void initialize(SVFModule* module);
 	
-	inline PAG* getPAG() {
+	inline SVFIR* getPAG() {
 		return mhp->getTCT()->getPTA()->getPAG();
 	}
 	

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

@@ -1,4 +1,4 @@
-//===- PAGBuilderFromFile.h -- Building PAG from File--------------------------------//
+//===- PAGBuilderFromFile.h -- Building SVFIR from File--------------------------------//
 //
 //                     SVF: Static Value-Flow Analysis
 //
@@ -30,24 +30,24 @@
 #ifndef INCLUDE_MEMORYMODEL_PAGBUILDERFROMFILE_H_
 #define INCLUDE_MEMORYMODEL_PAGBUILDERFROMFILE_H_
 
-#include "Graphs/PAG.h"
+#include "MemoryModel/SVFIR.h"
 
 namespace SVF
 {
 
 /*!
- * Build PAG from a user specified file (for debugging purpose)
+ * Build SVFIR from a user specified file (for debugging purpose)
  */
 class PAGBuilderFromFile
 {
 
 private:
-    PAG* pag;
+    SVFIR* pag;
     std::string file;
 public:
     /// Constructor
     PAGBuilderFromFile(std::string f) :
-        pag(PAG::getPAG(true)), file(f)
+        pag(SVFIR::getPAG(true)), file(f)
     {
     }
     /// Destructor
@@ -55,8 +55,8 @@ public:
     {
     }
 
-    /// Return PAG
-    PAG* getPAG() const
+    /// Return SVFIR
+    SVFIR* getPAG() const
     {
         return pag;
     }
@@ -68,7 +68,7 @@ public:
     }
 
     /// Start building
-    PAG* build();
+    SVFIR* build();
 
     // Add edges
     void addEdge(NodeID nodeSrc, NodeID nodeDst, Size_t offset,

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

@@ -57,49 +57,49 @@ public:
     static const char* ProcessCopyGepTime;	///< time of processing copys and geps
     static const char* UpdateCallGraphTime;	///< time of updating call graph
 
-    static const char* TotalNumOfPointers;	///< Total PAG value node
-    static const char* TotalNumOfObjects;	///< Total PAG object node
-    static const char* TotalNumOfFieldObjects;	///< Total PAG field object node
+    static const char* TotalNumOfPointers;	///< Total SVFIR value node
+    static const char* TotalNumOfObjects;	///< Total SVFIR object node
+    static const char* TotalNumOfFieldObjects;	///< Total SVFIR field object node
     static const char* MaxStructSize;	///< Max struct size
-    static const char* TotalNumOfEdges;	///< Total PAG edge number
-
-    static const char* NumOfAddrs;		///< PAG addr edge
-    static const char* NumOfLoads;		///< PAG load edge
-    static const char* NumOfStores;		///< PAG store edge
-    static const char* NumOfCopys;		///< PAG copy edge
-    static const char* NumOfGeps;		///< PAG gep edge
-    static const char* NumOfCalls;		///< PAG call edge
-    static const char* NumOfReturns;	///< PAG return edge
-
-    static const char* NumOfProcessedAddrs;		///< PAG processed addr edge
-    static const char* NumOfProcessedLoads;		///< PAG processed load edge
-    static const char* NumOfProcessedStores;	///< PAG processed store edge
-    static const char* NumOfProcessedCopys;		///< PAG processed copy edge
-    static const char* NumOfProcessedGeps;		///< PAG processed gep edge
+    static const char* TotalNumOfEdges;	///< Total SVFIR edge number
+
+    static const char* NumOfAddrs;		///< SVFIR addr edge
+    static const char* NumOfLoads;		///< SVFIR load edge
+    static const char* NumOfStores;		///< SVFIR store edge
+    static const char* NumOfCopys;		///< SVFIR copy edge
+    static const char* NumOfGeps;		///< SVFIR gep edge
+    static const char* NumOfCalls;		///< SVFIR call edge
+    static const char* NumOfReturns;	///< SVFIR return edge
+
+    static const char* NumOfProcessedAddrs;		///< SVFIR processed addr edge
+    static const char* NumOfProcessedLoads;		///< SVFIR processed load edge
+    static const char* NumOfProcessedStores;	///< SVFIR processed store edge
+    static const char* NumOfProcessedCopys;		///< SVFIR processed copy edge
+    static const char* NumOfProcessedGeps;		///< SVFIR processed gep edge
 
     static const char* NumOfSfr;                ///< num of field representatives
     static const char* NumOfFieldExpand;
 
     static const char* NumOfFunctionObjs;	///< Function numbers
-    static const char* NumOfGlobalObjs;	///< PAG global object node
-    static const char* NumOfHeapObjs;	///< PAG heap object node
-    static const char* NumOfStackObjs;	///< PAG stack object node
+    static const char* NumOfGlobalObjs;	///< SVFIR global object node
+    static const char* NumOfHeapObjs;	///< SVFIR heap object node
+    static const char* NumOfStackObjs;	///< SVFIR stack object node
 
-    static const char* NumOfObjsHasVarStruct;	///< PAG object node has var struct (maybe nested with array)
-    static const char* NumOfObjsHasVarArray;	///< PAG object node has var array (maybe nested with struct)
-    static const char* NumOfObjsHasConstStruct;	///< PAG object node has const struct (maybe nested with array)
-    static const char* NumOfObjsHasConstArray;	///< PAG object node has const array (maybe nested with struct)
-    static const char* NumOfNonPtrObjs;	///< PAG object node which is non pointer type object (do not have pts)
-    static const char* NumOfConstantObjs;	///< PAG object node which is purely constant
+    static const char* NumOfObjsHasVarStruct;	///< SVFIR object node has var struct (maybe nested with array)
+    static const char* NumOfObjsHasVarArray;	///< SVFIR object node has var array (maybe nested with struct)
+    static const char* NumOfObjsHasConstStruct;	///< SVFIR object node has const struct (maybe nested with array)
+    static const char* NumOfObjsHasConstArray;	///< SVFIR object node has const array (maybe nested with struct)
+    static const char* NumOfNonPtrObjs;	///< SVFIR object node which is non pointer type object (do not have pts)
+    static const char* NumOfConstantObjs;	///< SVFIR object node which is purely constant
 
     static const char* NumberOfFieldInsensitiveObj;
     static const char* NumberOfFieldSensitiveObj;
 
-    static const char* NumOfPointers;	///< PAG value node, each of them maps to a llvm value
-    static const char* NumOfGepFieldPointers;	///< PAG gep value node (field value, dynamically created dummy node)
+    static const char* NumOfPointers;	///< SVFIR value node, each of them maps to a llvm value
+    static const char* NumOfGepFieldPointers;	///< SVFIR gep value node (field value, dynamically created dummy node)
 
-    static const char* NumOfMemObjects;	///< PAG object node, each of them maps to a llvm value
-    static const char* NumOfGepFieldObjects;	///< PAG gep object node (field obj, dynamically created dummy node)
+    static const char* NumOfMemObjects;	///< SVFIR object node, each of them maps to a llvm value
+    static const char* NumOfGepFieldObjects;	///< SVFIR gep object node (field obj, dynamically created dummy node)
 
     static const char* AveragePointsToSetSize;		///< Average points-to size of all variables
     static const char* AverageTopLevPointsToSetSize; ///< Average points-to size of top-level variables

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

@@ -33,7 +33,7 @@
 #include <unistd.h>
 #include <signal.h>
 
-#include "Graphs/PAG.h"
+#include "MemoryModel/SVFIR.h"
 #include "MemoryModel/ConditionalPT.h"
 #include "MemoryModel/AbstractPointsToDS.h"
 #include "MemoryModel/MutablePointsToDS.h"
@@ -106,7 +106,7 @@ public:
     //@{
     typedef llvm::AliasAnalysis AliasAnalysis;
     typedef Set<const CallBlockNode*> CallSiteSet;
-    typedef PAG::CallSiteToFunPtrMap CallSiteToFunPtrMap;
+    typedef SVFIR::CallSiteToFunPtrMap CallSiteToFunPtrMap;
     typedef Set<const SVFFunction*> FunctionSet;
     typedef OrderedMap<const CallBlockNode*, FunctionSet> CallEdgeMap;
     typedef SCCDetection<PTACallGraph*> CallGraphSCC;
@@ -143,8 +143,8 @@ protected:
     u32_t OnTheFlyIterBudgetForStat;
     //@}
 
-    /// PAG
-    static PAG* pag;
+    /// SVFIR
+    static SVFIR* pag;
     /// Module
     SVFModule* svfMod;
     /// Pointer analysis Type
@@ -186,7 +186,7 @@ public:
     }
 
     /// Constructor
-    PointerAnalysis(PAG* pag, PTATY ty = Default_PTA, bool alias_check = true);
+    PointerAnalysis(SVFIR* pag, PTATY ty = Default_PTA, bool alias_check = true);
 
     /// Type of pointer analysis
     inline PTATY getAnalysisTy() const
@@ -200,9 +200,9 @@ public:
         return ptaImplTy;
     }
 
-    /// Get/set PAG
+    /// Get/set SVFIR
     ///@{
-    inline PAG* getPAG() const
+    inline SVFIR* getPAG() const
     {
         return pag;
     }
@@ -227,7 +227,7 @@ public:
     /// Destructor
     virtual ~PointerAnalysis();
 
-    /// Initialization of a pointer analysis, including building symbol table and PAG etc.
+    /// Initialization of a pointer analysis, including building symbol table and SVFIR etc.
     virtual void initialize();
 
     /// Finalization of a pointer analysis, including checking alias correctness
@@ -344,7 +344,7 @@ public:
     ///@{
     inline bool isFIObjNode(NodeID id) const
     {
-        return (SVFUtil::isa<FIObjPN>(pag->getPAGNode(id)));
+        return (SVFUtil::isa<FIObjPN>(pag->getGNode(id)));
     }
     inline NodeID getBaseObjNode(NodeID id)
     {

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

@@ -68,7 +68,7 @@ public:
     };
 
     /// Constructor
-    BVDataPTAImpl(PAG* pag, PointerAnalysis::PTATY type, bool alias_check = true);
+    BVDataPTAImpl(SVFIR* pag, PointerAnalysis::PTATY type, bool alias_check = true);
 
     /// Destructor
     virtual ~BVDataPTAImpl()
@@ -261,7 +261,7 @@ public:
     typedef Map<NodeID,CPtSet> PtrToCPtsMap;	 /// map a pointer to its conditional points-to set
 
     /// Constructor
-    CondPTAImpl(PAG* pag, PointerAnalysis::PTATY type) : PointerAnalysis(pag, type), normalized(false)
+    CondPTAImpl(SVFIR* pag, PointerAnalysis::PTATY type) : PointerAnalysis(pag, type), normalized(false)
     {
         if (type == PathS_DDA || type == Cxt_DDA)
             ptD = new MutPTDataTy();
@@ -574,7 +574,7 @@ public:
     {
         for (OrderedNodeSet::iterator nIter = this->getAllValidPtrs().begin(); nIter != this->getAllValidPtrs().end(); ++nIter)
         {
-            const PAGNode* node = this->getPAG()->getPAGNode(*nIter);
+            const PAGNode* node = this->getPAG()->getGNode(*nIter);
             if (this->getPAG()->isValidTopLevelPtr(node))
             {
                 if (SVFUtil::isa<DummyObjPN>(node))