svf-lib 1.0.2112 → 1.0.2114

package/SVF-linux/Release-build/include/Graphs/ThreadCallGraph.h

@@ -31,13 +31,13 @@
 #define RCG_H_
 
 #include "Graphs/CallGraph.h"
-#include "MemoryModel/PointerAnalysisImpl.h"
 
 namespace SVF
 {
 
 class SVFModule;
 class ThreadAPI;
+class PointerAnalysis;
 /*!
  * PTA thread fork edge from fork site to the entry of a start routine function
  */
@@ -201,7 +201,8 @@ public:
     /// whether this call instruction has a valid call graph edge
     inline bool hasThreadForkEdge(const CallICFGNode* cs) const
     {
-        return callinstToThreadForkEdgesMap.find(cs) != callinstToThreadForkEdgesMap.end();
+        return callinstToThreadForkEdgesMap.find(cs) !=
+               callinstToThreadForkEdgesMap.end();
     }
     inline ForkEdgeSet::const_iterator getForkEdgeBegin(const CallICFGNode* cs) const
     {
@@ -345,8 +346,8 @@ public:
 
     /// Add direct/indirect thread fork edges
     //@{
-    void addDirectForkEdge(const CallICFGNode* cs);
-    void addIndirectForkEdge(const CallICFGNode* cs, const SVFFunction* callee);
+    bool addDirectForkEdge(const CallICFGNode* cs);
+    bool addIndirectForkEdge(const CallICFGNode* cs, const SVFFunction* callee);
     //@}
 
     /// Add thread join edges

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

@@ -34,7 +34,7 @@
 #include <signal.h>
 
 #include "Graphs/CHG.h"
-#include "Graphs/CallGraph.h"
+#include "Graphs/ThreadCallGraph.h"
 #include "Graphs/SCC.h"
 #include "MemoryModel/AbstractPointsToDS.h"
 #include "MemoryModel/ConditionalPT.h"

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

@@ -199,6 +199,10 @@ protected:
     /// On the fly call graph construction
     virtual void onTheFlyCallGraphSolve(const CallSiteToFunPtrMap& callsites, CallEdgeMap& newEdges);
 
+    /// On the fly thread call graph construction respecting forksite
+    virtual void onTheFlyThreadCallGraphSolve(const CallSiteToFunPtrMap& callsites,
+            CallEdgeMap& newForkEdges);
+
     /// Normalize points-to information for field-sensitive analysis,
     /// i.e., replace fieldObj with baseObj if it is field-insensitive
     virtual void normalizePointsTo();

package/SVF-linux/Release-build/include/Util/SVFUtil.h

@@ -457,7 +457,7 @@ inline bool isBarrierWaitCall(const CallICFGNode* cs)
 
 /// Return sole argument of the thread routine
 //@{
-inline const SVFValue* getActualParmAtForkSite(const CallICFGNode* cs)
+inline const SVFVar* getActualParmAtForkSite(const CallICFGNode* cs)
 {
     return ThreadAPI::getThreadAPI()->getActualParmAtForkSite(cs);
 }

package/SVF-linux/Release-build/include/Util/ThreadAPI.h

@@ -38,6 +38,7 @@ namespace SVF
 class SVFModule;
 class ICFGNode;
 class CallICFGNode;
+class SVFVar;
 
 /*
  * ThreadAPI class contains interfaces for pthread programs
@@ -128,11 +129,16 @@ public:
     /// Note that, it could be function type or a void* pointer
     const SVFValue* getForkedFun(const CallICFGNode *inst) const;
 
-    /// Return the forth argument of the call,
+    /// Return the actual param of forksite
     /// Note that, it is the sole argument of start routine ( a void* pointer )
-    const SVFValue* getActualParmAtForkSite(const CallICFGNode *inst) const;
+    const SVFVar* getActualParmAtForkSite(const CallICFGNode *inst) const;
+
+    /// Return the formal parm of forked function (the first arg in pthread)
+    const SVFVar* getFormalParmOfForkedFun(const SVFFunction* F) const;
     //@}
 
+
+
     /// Return true if this call create a new thread
     //@{
     bool isTDFork(const CallICFGNode *inst) const;

package/SVF-linux/Release-build/include/WPA/Andersen.h

@@ -47,6 +47,8 @@ namespace SVF
 
 class SVFModule;
 
+class ThreadCallGraph;
+
 /*!
  * Abstract class of inclusion-based Pointer Analysis
  */
@@ -54,6 +56,9 @@ typedef WPASolver<ConstraintGraph*> WPAConstraintSolver;
 
 class AndersenBase:  public WPAConstraintSolver, public BVDataPTAImpl
 {
+public:
+    typedef OrderedMap<const CallICFGNode*, NodeID> CallSite2DummyValPN;
+
 public:
 
     /// Constructor
@@ -81,11 +86,19 @@ public:
     /// Finalize analysis
     virtual void finalize() override;
 
-    /// Implement it in child class to update call graph
-    virtual inline bool updateCallGraph(const CallSiteToFunPtrMap&) override
-    {
-        return false;
-    }
+    /// Update call graph
+    virtual bool updateCallGraph(const CallSiteToFunPtrMap&) override;
+
+    /// Update thread call graph
+    virtual bool updateThreadCallGraph(const CallSiteToFunPtrMap&, NodePairSet&);
+
+    /// Connect formal and actual parameters for indirect forksites
+    virtual void connectCaller2ForkedFunParams(const CallICFGNode* cs, const SVFFunction* F,
+            NodePairSet& cpySrcNodes);
+
+    /// Connect formal and actual parameters for indirect callsites
+    virtual void connectCaller2CalleeParams(const CallICFGNode* cs, const SVFFunction* F,
+                                            NodePairSet& cpySrcNodes);
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
@@ -123,6 +136,9 @@ public:
     }
     //@}
 
+    /// Add copy edge on constraint graph
+    virtual inline bool addCopyEdge(NodeID src, NodeID dst) = 0;
+
     /// dump statistics
     inline void printStat()
     {
@@ -160,6 +176,11 @@ public:
 protected:
     /// Constraint Graph
     ConstraintGraph* consCG;
+    CallSite2DummyValPN
+    callsite2DummyValPN; ///< Map an instruction to a dummy obj which
+    ///< created at an indirect callsite, which invokes
+    ///< a heap allocator
+    void heapAllocatorViaIndCall(const CallICFGNode* cs, NodePairSet& cpySrcNodes);
 };
 
 /*!
@@ -171,7 +192,6 @@ class Andersen:  public AndersenBase
 
 public:
     typedef SCCDetection<ConstraintGraph*> CGSCC;
-    typedef OrderedMap<const CallICFGNode*, NodeID> CallSite2DummyValPN;
 
     /// Constructor
     Andersen(SVFIR* _pag, PTATY type = Andersen_WPA, bool alias_check = true)
@@ -243,7 +263,6 @@ public:
 protected:
 
     CallSite2DummyValPN callsite2DummyValPN;        ///< Map an instruction to a dummy obj which created at an indirect callsite, which invokes a heap allocator
-    void heapAllocatorViaIndCall(const CallICFGNode* cs,NodePairSet &cpySrcNodes);
 
     /// Handle diff points-to set.
     virtual inline void computeDiffPts(NodeID id)
@@ -311,12 +330,6 @@ protected:
         return false;
     }
 
-    /// Update call graph for the input indirect callsites
-    virtual bool updateCallGraph(const CallSiteToFunPtrMap& callsites);
-
-    /// Connect formal and actual parameters for indirect callsites
-    void connectCaller2CalleeParams(const CallICFGNode* cs, const SVFFunction* F, NodePairSet& cpySrcNodes);
-
     /// Merge sub node to its rep
     virtual void mergeNodeToRep(NodeID nodeId,NodeID newRepId);
 

package/SVF-linux/Release-build/include/WPA/Steensgaard.h

@@ -23,7 +23,6 @@ class Steensgaard : public AndersenBase
 public:
     typedef Map<NodeID, NodeID> NodeToEquivClassMap;
     typedef Map<NodeID, Set<NodeID>> NodeToSubsMap;
-    typedef OrderedMap<const CallICFGNode*, NodeID> CallSite2DummyValPN;
 
     /// Constructor
     Steensgaard(SVFIR* _pag) : AndersenBase(_pag, Steensgaard_WPA, true) {}
@@ -46,7 +45,7 @@ public:
         steens = nullptr;
     }
 
-    virtual void solveWorklist();
+    virtual void solveWorklist() override;
 
     void processAllAddr();
 
@@ -69,18 +68,18 @@ public:
     //@}
 
     /// Operation of points-to set
-    virtual inline const PointsTo& getPts(NodeID id)
+    virtual inline const PointsTo& getPts(NodeID id) override
     {
         return getPTDataTy()->getPts(getEC(id));
     }
     /// pts(id) = pts(id) U target
-    virtual inline bool unionPts(NodeID id, const PointsTo& target)
+    virtual inline bool unionPts(NodeID id, const PointsTo& target) override
     {
         id = getEC(id);
         return getPTDataTy()->unionPts(id, target);
     }
     /// pts(id) = pts(id) U pts(ptd)
-    virtual inline bool unionPts(NodeID id, NodeID ptd)
+    virtual inline bool unionPts(NodeID id, NodeID ptd) override
     {
         id = getEC(id);
         ptd = getEC(ptd);
@@ -98,6 +97,11 @@ public:
         else
             return it->second;
     }
+    /// Return getEC(id)
+    inline NodeID sccRepNode(NodeID id) const override
+    {
+        return getEC(id);
+    }
     void setEC(NodeID node, NodeID rep);
 
     inline Set<NodeID>& getSubNodes(NodeID id)
@@ -111,25 +115,11 @@ public:
     }
 
     /// Add copy edge on constraint graph
-    virtual inline bool addCopyEdge(NodeID src, NodeID dst)
+    virtual inline bool addCopyEdge(NodeID src, NodeID dst) override
     {
         return consCG->addCopyCGEdge(src, dst);
     }
 
-protected:
-    CallSite2DummyValPN
-    callsite2DummyValPN; ///< Map an instruction to a dummy obj which
-    ///< created at an indirect callsite, which invokes
-    ///< a heap allocator
-    void heapAllocatorViaIndCall(const CallICFGNode* cs, NodePairSet& cpySrcNodes);
-
-    /// Update call graph for the input indirect callsites
-    virtual bool updateCallGraph(const CallSiteToFunPtrMap& callsites);
-
-    /// Connect formal and actual parameters for indirect callsites
-    void connectCaller2CalleeParams(const CallICFGNode* cs, const SVFFunction* F,
-                                    NodePairSet& cpySrcNodes);
-
 private:
     static Steensgaard* steens; // static instance
     NodeToEquivClassMap nodeToECMap;

package/SVF-linux/Release-build/include/WPA/TypeAnalysis.h

@@ -51,13 +51,20 @@ public:
     }
 
     /// Type analysis
-    void analyze();
+    void analyze() override;
 
     /// Initialize analysis
-    void initialize();
+    void initialize() override;
 
     /// Finalize analysis
-    virtual inline void finalize();
+    virtual inline void finalize() override;
+
+    /// Add copy edge on constraint graph
+    inline bool addCopyEdge(NodeID src, NodeID dst) override
+    {
+        assert(false && "this function should never be executed!");
+        return false;
+    }
 
     /// Resolve callgraph based on CHA
     void callGraphSolveBasedOnCHA(const CallSiteToFunPtrMap& callsites, CallEdgeMap& newEdges);

package/SVF-osx/Release-build/include/Graphs/CDG.h

@@ -96,7 +96,7 @@ public:
 
 public:
     /// Constructor
-    CDGNode(const ICFGNode *icfgNode) : GenericCDGNodeTy(icfgNode->getId(), 0), _icfgNode(icfgNode)
+    CDGNode(const ICFGNode *icfgNode) : GenericCDGNodeTy(icfgNode->getId(), CDNodeKd), _icfgNode(icfgNode)
     {
 
     }
@@ -114,6 +114,23 @@ public:
         return _icfgNode;
     }
 
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const CDGNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const GenericICFGNodeTy* node)
+    {
+        return node->getNodeKind() == CDNodeKd;
+    }
+
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == CDNodeKd;
+    }
+    //@}
 
 private:
     const ICFGNode *_icfgNode;

package/SVF-osx/Release-build/include/Graphs/CFLGraph.h

@@ -76,7 +76,7 @@ typedef GenericNode<CFLNode, CFLEdge> GenericCFLNodeTy;
 class CFLNode: public GenericCFLNodeTy
 {
 public:
-    CFLNode (NodeID i = 0, GNodeK k = 0):
+    CFLNode (NodeID i = 0, GNodeK k = CFLNodeKd):
         GenericCFLNodeTy(i, k)
     {
     }
@@ -148,6 +148,24 @@ public:
 
         return num1 && num2;
     }
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const CFLNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const GenericICFGNodeTy* node)
+    {
+        return node->getNodeKind() == CFLNodeKd;
+    }
+
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == CFLNodeKd;
+    }
+    //@}
 };
 
 /// Edge-labeled graph for CFL Reachability analysis

package/SVF-osx/Release-build/include/Graphs/CHG.h

@@ -120,7 +120,7 @@ public:
 
     typedef std::vector<const SVFFunction*> FuncVector;
 
-    CHNode (const std::string& name, NodeID i = 0, GNodeK k = 0):
+    CHNode (const std::string& name, NodeID i = 0, GNodeK k = CHNodeKd):
         GenericCHNodeTy(i, k), vtable(nullptr), className(name), flags(0)
     {
     }
@@ -191,6 +191,24 @@ public:
         vtable = vtbl;
     }
 
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const CHNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const GenericCHNodeTy * node)
+    {
+        return node->getNodeKind() == CHNodeKd;
+    }
+
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == CHNodeKd;
+    }
+    //@}
+
 private:
     const SVFGlobalValue* vtable;
     std::string className;

package/SVF-osx/Release-build/include/Graphs/CallGraph.h

@@ -184,7 +184,7 @@ private:
 
 public:
     /// Constructor
-    CallGraphNode(NodeID i, const SVFFunction* f) : GenericCallGraphNodeTy(i,0), fun(f)
+    CallGraphNode(NodeID i, const SVFFunction* f) : GenericCallGraphNodeTy(i,CallNodeKd), fun(f)
     {
 
     }
@@ -209,6 +209,24 @@ public:
     //@}
 
     virtual const std::string toString() const;
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const CallGraphNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const GenericICFGNodeTy* node)
+    {
+        return node->getNodeKind() == CallNodeKd;
+    }
+
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == CallNodeKd;
+    }
+    //@}
 };
 
 /*!

package/SVF-osx/Release-build/include/Graphs/ConsGNode.h

@@ -71,7 +71,7 @@ public:
     NodeBS strides;
     NodeBS baseIds;
 
-    ConstraintNode(NodeID i) : GenericConsNodeTy(i, 0), _isPWCNode(false)
+    ConstraintNode(NodeID i) : GenericConsNodeTy(i, ConstraintNodeKd), _isPWCNode(false)
     {
 
     }
@@ -393,6 +393,24 @@ public:
         return o;
     }
     //@}
+
+    /// Methods for support type inquiry through isa, cast, and dyn_cast:
+    //@{
+    static inline bool classof(const ConstraintNode *)
+    {
+        return true;
+    }
+
+    static inline bool classof(const GenericICFGNodeTy* node)
+    {
+        return node->getNodeKind() == ConstraintNodeKd;
+    }
+
+    static inline bool classof(const SVFBaseNode* node)
+    {
+        return node->getNodeKind() == ConstraintNodeKd;
+    }
+    //@}
 };
 
 } // End namespace SVF