svf-tools 1.0.1004 → 1.0.1006

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.1004",
+  "version": "1.0.1006",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf/include/AE/Svfexe/AbstractInterpretation.h

@@ -106,7 +106,7 @@ class AbstractInterpretation
     friend class BufOverflowDetector;
 
 public:
-    typedef SCCDetection<CallGraph*> CallGraphSCC;
+    typedef SCCDetection<PTACallGraph*> CallGraphSCC;
     /// Constructor
     AbstractInterpretation();
 

package/svf/include/DDA/DDAVFSolver.h

@@ -49,8 +49,8 @@ class DDAVFSolver
     friend class DDAStat;
 public:
     typedef SCCDetection<SVFG*> SVFGSCC;
-    typedef SCCDetection<CallGraph*> CallGraphSCC;
-    typedef CallGraphEdge::CallInstSet CallInstSet;
+    typedef SCCDetection<PTACallGraph*> CallGraphSCC;
+    typedef PTACallGraphEdge::CallInstSet CallInstSet;
     typedef SVFIR::CallSiteSet CallSiteSet;
     typedef OrderedSet<DPIm> DPTItemSet;
     typedef OrderedMap<DPIm, CPtSet> DPImToCPtSetMap;
@@ -624,7 +624,7 @@ protected:
         return (getSVFGSCCRepNode(edge->getSrcID()) == getSVFGSCCRepNode(edge->getDstID()));
     }
     /// Set callgraph
-    inline void setCallGraph (CallGraph* cg)
+    inline void setCallGraph (PTACallGraph* cg)
     {
         _callGraph = cg;
     }
@@ -775,8 +775,8 @@ protected:
     SVFG* _svfg;					///< SVFG
     AndersenWaveDiff* _ander;		///< Andersen's analysis
     NodeBS candidateQueries;		///< candidate pointers;
-    CallGraph* _callGraph;		///< CallGraph
-    CallGraphSCC* _callGraphSCC;	///< SCC for CallGraph
+    PTACallGraph* _callGraph;		///< PTACallGraph
+    CallGraphSCC* _callGraphSCC;	///< SCC for PTACallGraph
     SVFGSCC* _svfgSCC;				///< SCC for SVFG
     DPTItemSet backwardVisited;		///< visited map during backward traversing
     DPImToCPtSetMap dpmToTLCPtSetMap;	///< points-to caching map for top-level vars

package/svf/include/Graphs/CallGraph.h

@@ -53,68 +53,23 @@ class CallGraphEdge : public GenericCallGraphEdgeTy
 
 public:
     typedef Set<const CallICFGNode*> CallInstSet;
-    enum CEDGEK
-    {
-        CallRetEdge,TDForkEdge,TDJoinEdge,HareParForEdge
-    };
-
 
 private:
     CallInstSet directCalls;
-    CallInstSet indirectCalls;
-    CallSiteID csId;
 public:
     /// Constructor
-    CallGraphEdge(CallGraphNode* s, CallGraphNode* d, CEDGEK kind, CallSiteID cs) :
-        GenericCallGraphEdgeTy(s, d, makeEdgeFlagWithInvokeID(kind, cs)), csId(cs)
+    CallGraphEdge(CallGraphNode* s, CallGraphNode* d, const CallICFGNode* icfgNode) :
+        GenericCallGraphEdgeTy(s, d, icfgNode->getId())
     {
     }
     /// Destructor
     virtual ~CallGraphEdge()
     {
     }
-    /// Compute the unique edgeFlag value from edge kind and CallSiteID.
-    static inline GEdgeFlag makeEdgeFlagWithInvokeID(GEdgeKind k, CallSiteID cs)
-    {
-        return (cs << EdgeKindMaskBits) | k;
-    }
-    /// Get direct and indirect calls
-    //@{
-    inline CallSiteID getCallSiteID() const
-    {
-        return csId;
-    }
-    inline bool isDirectCallEdge() const
-    {
-        return !directCalls.empty() && indirectCalls.empty();
-    }
-    inline bool isIndirectCallEdge() const
-    {
-        return directCalls.empty() && !indirectCalls.empty();
-    }
-    inline CallInstSet& getDirectCalls()
-    {
-        return directCalls;
-    }
-    inline CallInstSet& getIndirectCalls()
-    {
-        return indirectCalls;
-    }
-    inline const CallInstSet& getDirectCalls() const
-    {
-        return directCalls;
-    }
-    inline const CallInstSet& getIndirectCalls() const
-    {
-        return indirectCalls;
-    }
-    //@}
 
-    /// Add direct and indirect callsite
+    /// Add direct callsite
     //@{
     void addDirectCallSite(const CallICFGNode* call);
-
-    void addInDirectCallSite(const CallICFGNode* call);
     //@}
 
     /// Iterators for direct and indirect callsites
@@ -127,15 +82,6 @@ public:
     {
         return directCalls.end();
     }
-
-    inline CallInstSet::const_iterator indirectCallsBegin() const
-    {
-        return indirectCalls.begin();
-    }
-    inline CallInstSet::const_iterator indirectCallsEnd() const
-    {
-        return indirectCalls.end();
-    }
     //@}
 
     /// ClassOf
@@ -144,17 +90,11 @@ public:
     {
         return true;
     }
-    static inline bool classof(const GenericCallGraphEdgeTy *edge)
-    {
-        return edge->getEdgeKind() == CallGraphEdge::CallRetEdge ||
-               edge->getEdgeKind() == CallGraphEdge::TDForkEdge ||
-               edge->getEdgeKind() == CallGraphEdge::TDJoinEdge;
-    }
     //@}
 
     /// Overloading operator << for dumping ICFG node ID
     //@{
-    friend OutStream& operator<< (OutStream &o, const CallGraphEdge &edge)
+    friend OutStream& operator<< (OutStream &o, const CallGraphEdge&edge)
     {
         o << edge.toString();
         return o;
@@ -163,22 +103,16 @@ public:
 
     virtual const std::string toString() const;
 
-    typedef GenericNode<CallGraphNode,CallGraphEdge>::GEdgeSetTy CallGraphEdgeSet;
+    typedef GenericNode<CallGraphNode, CallGraphEdge>::GEdgeSetTy CallGraphEdgeSet;
 
 };
 
 /*
  * Call Graph node representing a function
  */
-typedef GenericNode<CallGraphNode,CallGraphEdge> GenericCallGraphNodeTy;
+typedef GenericNode<CallGraphNode, CallGraphEdge> GenericCallGraphNodeTy;
 class CallGraphNode : public GenericCallGraphNodeTy
 {
-
-public:
-    typedef CallGraphEdge::CallGraphEdgeSet CallGraphEdgeSet;
-    typedef CallGraphEdge::CallGraphEdgeSet::iterator iterator;
-    typedef CallGraphEdge::CallGraphEdgeSet::const_iterator const_iterator;
-
 private:
     const SVFFunction* fun;
 
@@ -186,7 +120,6 @@ public:
     /// Constructor
     CallGraphNode(NodeID i, const SVFFunction* f) : GenericCallGraphNodeTy(i,CallNodeKd), fun(f)
     {
-
     }
 
     inline const std::string &getName() const
@@ -200,13 +133,10 @@ public:
         return fun;
     }
 
-    /// Return TRUE if this function can be reached from main.
-    bool isReachableFromProgEntry() const;
-
 
     /// Overloading operator << for dumping ICFG node ID
     //@{
-    friend OutStream& operator<< (OutStream &o, const CallGraphNode &node)
+    friend OutStream& operator<< (OutStream &o, const CallGraphNode&node)
     {
         o << node.toString();
         return o;
@@ -217,7 +147,7 @@ public:
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
-    static inline bool classof(const CallGraphNode *)
+    static inline bool classof(const CallGraphNode*)
     {
         return true;
     }
@@ -237,53 +167,38 @@ public:
 /*!
  * Pointer Analysis Call Graph used internally for various pointer analysis
  */
-typedef GenericGraph<CallGraphNode,CallGraphEdge> GenericCallGraphTy;
+typedef GenericGraph<CallGraphNode, CallGraphEdge> GenericCallGraphTy;
 class CallGraph : public GenericCallGraphTy
 {
+    friend class PTACallGraph;
 
 public:
     typedef CallGraphEdge::CallGraphEdgeSet CallGraphEdgeSet;
-    typedef Map<const SVFFunction*, CallGraphNode *> FunToCallGraphNodeMap;
+    typedef Map<const SVFFunction*, CallGraphNode*> FunToCallGraphNodeMap;
     typedef Map<const CallICFGNode*, CallGraphEdgeSet> CallInstToCallGraphEdgesMap;
-    typedef std::pair<const CallICFGNode*, const SVFFunction*> CallSitePair;
-    typedef Map<CallSitePair, CallSiteID> CallSiteToIdMap;
-    typedef Map<CallSiteID, CallSitePair> IdToCallSiteMap;
     typedef Set<const SVFFunction*> FunctionSet;
     typedef OrderedMap<const CallICFGNode*, FunctionSet> CallEdgeMap;
-    typedef CallGraphEdgeSet::iterator CallGraphEdgeIter;
-    typedef CallGraphEdgeSet::const_iterator CallGraphEdgeConstIter;
-
-    enum CGEK
-    {
-        NormCallGraph, ThdCallGraph
-    };
-
-private:
-    /// Indirect call map
-    CallEdgeMap indirectCallMap;
-
-    /// Call site information
-    static CallSiteToIdMap csToIdMap;	///< Map a pair of call instruction and callee to a callsite ID
-    static IdToCallSiteMap idToCSMap;	///< Map a callsite ID to a pair of call instruction and callee
-    static CallSiteID totalCallSiteNum;	///< CallSiteIDs, start from 1;
 
 protected:
     FunToCallGraphNodeMap funToCallGraphNodeMap; ///< Call Graph node map
     CallInstToCallGraphEdgesMap callinstToCallGraphEdgesMap; ///< Map a call instruction to its corresponding call edges
 
     NodeID callGraphNodeNum;
-    u32_t numOfResolvedIndCallEdge;
-    CGEK kind;
 
     /// Clean up memory
     void destroy();
 
+    /// Add call graph edge
+    inline void addEdge(CallGraphEdge* edge)
+    {
+        edge->getDstNode()->addIncomingEdge(edge);
+        edge->getSrcNode()->addOutgoingEdge(edge);
+    }
+
+
 public:
     /// Constructor
-    CallGraph(CGEK k = NormCallGraph);
-
-    /// Copy constructor
-    CallGraph(const CallGraph& other);
+    CallGraph();
 
     void addCallGraphNode(const SVFFunction* fun);
 
@@ -293,47 +208,6 @@ public:
         destroy();
     }
 
-    /// Return type of this callgraph
-    inline CGEK getKind() const
-    {
-        return kind;
-    }
-
-    /// Get callees from an indirect callsite
-    //@{
-    inline CallEdgeMap& getIndCallMap()
-    {
-        return indirectCallMap;
-    }
-    inline bool hasIndCSCallees(const CallICFGNode* cs) const
-    {
-        return (indirectCallMap.find(cs) != indirectCallMap.end());
-    }
-    inline const FunctionSet& getIndCSCallees(const CallICFGNode* cs) const
-    {
-        CallEdgeMap::const_iterator it = indirectCallMap.find(cs);
-        assert(it!=indirectCallMap.end() && "not an indirect callsite!");
-        return it->second;
-    }
-    //@}
-    inline u32_t getTotalCallSiteNumber() const
-    {
-        return totalCallSiteNum;
-    }
-
-    inline u32_t getNumOfResolvedIndCallEdge() const
-    {
-        return numOfResolvedIndCallEdge;
-    }
-
-    inline const CallInstToCallGraphEdgesMap& getCallInstToCallGraphEdgesMap() const
-    {
-        return callinstToCallGraphEdgesMap;
-    }
-
-    /// Issue a warning if the function which has indirect call sites can not be reached from program entry.
-    void verifyCallGraph();
-
     /// Get call graph node
     //@{
     inline CallGraphNode* getCallGraphNode(NodeID id) const
@@ -349,117 +223,12 @@ public:
 
     //@}
 
-    /// Add/Get CallSiteID
-    //@{
-    inline CallSiteID addCallSite(const CallICFGNode* cs, const SVFFunction* callee)
-    {
-        std::pair<const CallICFGNode*, const SVFFunction*> newCS(std::make_pair(cs, callee));
-        CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS);
-        //assert(it == csToIdMap.end() && "cannot add a callsite twice");
-        if(it == csToIdMap.end())
-        {
-            CallSiteID id = totalCallSiteNum++;
-            csToIdMap.insert(std::make_pair(newCS, id));
-            idToCSMap.insert(std::make_pair(id, newCS));
-            return id;
-        }
-        return it->second;
-    }
-    inline CallSiteID getCallSiteID(const CallICFGNode* cs, const SVFFunction* callee) const
-    {
-        CallSitePair newCS(std::make_pair(cs, callee));
-        CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS);
-        assert(it != csToIdMap.end() && "callsite id not found! This maybe a partially resolved callgraph, please check the indCallEdge limit");
-        return it->second;
-    }
-    inline bool hasCallSiteID(const CallICFGNode* cs, const SVFFunction* callee) const
-    {
-        CallSitePair newCS(std::make_pair(cs, callee));
-        CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS);
-        return it != csToIdMap.end();
-    }
-    inline const CallSitePair& getCallSitePair(CallSiteID id) const
-    {
-        IdToCallSiteMap::const_iterator it = idToCSMap.find(id);
-        assert(it != idToCSMap.end() && "cannot find call site for this CallSiteID");
-        return (it->second);
-    }
-    inline const CallICFGNode* getCallSite(CallSiteID id) const
-    {
-        return getCallSitePair(id).first;
-    }
-    inline const SVFFunction* getCallerOfCallSite(CallSiteID id) const
-    {
-        return getCallSite(id)->getCaller();
-    }
-    inline const SVFFunction* getCalleeOfCallSite(CallSiteID id) const
-    {
-        return getCallSitePair(id).second;
-    }
-    //@}
     /// Whether we have already created this call graph edge
-    CallGraphEdge* hasGraphEdge(CallGraphNode* src, CallGraphNode* dst,CallGraphEdge::CEDGEK kind, CallSiteID csId) const;
-    /// Get call graph edge via nodes
-    CallGraphEdge* getGraphEdge(CallGraphNode* src, CallGraphNode* dst,CallGraphEdge::CEDGEK kind, CallSiteID csId);
-
-    /// Get all callees for a callsite
-    inline void getCallees(const CallICFGNode* cs, FunctionSet& callees)
-    {
-        if(hasCallGraphEdge(cs))
-        {
-            for (CallGraphEdgeSet::const_iterator it = getCallEdgeBegin(cs), eit =
-                        getCallEdgeEnd(cs); it != eit; ++it)
-            {
-                callees.insert((*it)->getDstNode()->getFunction());
-            }
-        }
-    }
-
-    /// Get call graph edge via call instruction
-    //@{
-    /// whether this call instruction has a valid call graph edge
-    inline bool hasCallGraphEdge(const CallICFGNode* inst) const
-    {
-        return callinstToCallGraphEdgesMap.find(inst)!=callinstToCallGraphEdgesMap.end();
-    }
-    inline CallGraphEdgeSet::const_iterator getCallEdgeBegin(const CallICFGNode* inst) const
-    {
-        CallInstToCallGraphEdgesMap::const_iterator it = callinstToCallGraphEdgesMap.find(inst);
-        assert(it!=callinstToCallGraphEdgesMap.end()
-               && "call instruction does not have a valid callee");
-        return it->second.begin();
-    }
-    inline CallGraphEdgeSet::const_iterator getCallEdgeEnd(const CallICFGNode* inst) const
-    {
-        CallInstToCallGraphEdgesMap::const_iterator it = callinstToCallGraphEdgesMap.find(inst);
-        assert(it!=callinstToCallGraphEdgesMap.end()
-               && "call instruction does not have a valid callee");
-        return it->second.end();
-    }
-    //@}
-    /// Add call graph edge
-    inline void addEdge(CallGraphEdge* edge)
-    {
-        edge->getDstNode()->addIncomingEdge(edge);
-        edge->getSrcNode()->addOutgoingEdge(edge);
-    }
+    CallGraphEdge* hasGraphEdge(CallGraphNode* src, CallGraphNode* dst,
+                                const CallICFGNode* callIcfgNode) const;
 
-    /// Add direct/indirect call edges
-    //@{
+    /// Add direct call edges
     void addDirectCallGraphEdge(const CallICFGNode* call, const SVFFunction* callerFun, const SVFFunction* calleeFun);
-    void addIndirectCallGraphEdge(const CallICFGNode* cs,const SVFFunction* callerFun, const SVFFunction* calleeFun);
-    //@}
-
-    /// Get callsites invoking the callee
-    //@{
-    void getAllCallSitesInvokingCallee(const SVFFunction* callee, CallGraphEdge::CallInstSet& csSet);
-    void getDirCallSitesInvokingCallee(const SVFFunction* callee, CallGraphEdge::CallInstSet& csSet);
-    void getIndCallSitesInvokingCallee(const SVFFunction* callee, CallGraphEdge::CallInstSet& csSet);
-    //@}
-
-    /// Whether its reachable between two functions
-    bool isReachableBetweenFunctions(const SVFFunction* srcFn, const SVFFunction* dstFn) const;
-
     /// Dump the graph
     void dump(const std::string& filename);
 
@@ -481,13 +250,13 @@ template<> struct GenericGraphTraits<SVF::CallGraphNode*> : public GenericGraphT
 
 /// Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal.
 template<>
-struct GenericGraphTraits<Inverse<SVF::CallGraphNode *> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::CallGraphNode,SVF::CallGraphEdge>* > >
+struct GenericGraphTraits<Inverse<SVF::CallGraphNode*> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::CallGraphNode,SVF::CallGraphEdge>* > >
 {
 };
 
 template<> struct GenericGraphTraits<SVF::CallGraph*> : public GenericGraphTraits<SVF::GenericGraph<SVF::CallGraphNode,SVF::CallGraphEdge>* >
 {
-    typedef SVF::CallGraphNode *NodeRef;
+    typedef SVF::CallGraphNode*NodeRef;
 };
 
 } // End namespace llvm

package/svf/include/Graphs/ICFG.h

@@ -38,7 +38,7 @@
 namespace SVF
 {
 
-class CallGraph;
+class PTACallGraph;
 
 /*!
  * Interprocedural Control-Flow Graph (ICFG)
@@ -111,7 +111,7 @@ public:
     void view();
 
     /// update ICFG for indirect calls
-    void updateCallGraph(CallGraph* callgraph);
+    void updateCallGraph(PTACallGraph* callgraph);
 
     /// Whether node is in a loop
     inline bool isInLoop(const ICFGNode *node)