svf-lib 1.0.1820 → 1.0.1821

package/SVF-osx/svf/include/Graphs/ConsGEdge.h

@@ -86,6 +86,7 @@ public:
 
 };
 
+
 /*!
  * Copy edge
  */
@@ -116,6 +117,7 @@ public:
     AddrCGEdge(ConstraintNode* s, ConstraintNode* d, EdgeID id);
 };
 
+
 /*!
  * Copy edge
  */
@@ -148,6 +150,7 @@ public:
     }
 };
 
+
 /*!
  * Store edge
  */
@@ -181,6 +184,7 @@ public:
     }
 };
 
+
 /*!
  * Load edge
  */
@@ -214,6 +218,7 @@ public:
     }
 };
 
+
 /*!
  * Gep edge
  */

package/SVF-osx/svf/include/Graphs/ConsGNode.h

@@ -383,6 +383,7 @@ public:
     }
     //@}
 
+
 };
 
 } // End namespace SVF

package/SVF-osx/svf/include/Graphs/DOTGraphTraits.h

@@ -172,6 +172,7 @@ public:
     static void addCustomGraphFeatures(const GraphType &, GraphWriter &) {}
 };
 
+
 /// DOTGraphTraits - Template class that can be specialized to customize how
 /// graphs are converted to 'dot' graphs.  When specializing, you may inherit
 /// from DefaultDOTGraphTraits if you don't need to override everything.

package/SVF-osx/svf/include/Graphs/GenericGraph.h

@@ -133,6 +133,7 @@ protected:
     static constexpr u64_t EdgeKindMask = (~0ULL) >> (64 - EdgeKindMaskBits);
 };
 
+
 /*!
  * Generic node on the graph as base class
  */

package/SVF-osx/svf/include/Graphs/GraphPrinter.h

@@ -20,6 +20,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+
 /*
  * GraphPrinter.h
  *
@@ -105,4 +106,6 @@ public:
 
 } // End namespace llvm
 
+
+
 #endif /* INCLUDE_GRAPHS_GRAPHPRINTER_H_ */

package/SVF-osx/svf/include/Graphs/GraphTraits.h

@@ -115,7 +115,7 @@ nodes(const GraphType &G)
 }
 template <class GraphType>
 iter_range<typename GenericGraphTraits<Inverse<GraphType>>::nodes_iterator>
-        inverse_nodes(const GraphType &G)
+inverse_nodes(const GraphType &G)
 {
     return make_range(GenericGraphTraits<Inverse<GraphType>>::nodes_begin(G),
                       GenericGraphTraits<Inverse<GraphType>>::nodes_end(G));
@@ -131,7 +131,7 @@ children(const typename GenericGraphTraits<GraphType>::NodeRef &G)
 
 template <class GraphType>
 iter_range<typename GenericGraphTraits<Inverse<GraphType>>::ChildIteratorType>
-        inverse_children(const typename GenericGraphTraits<GraphType>::NodeRef &G)
+inverse_children(const typename GenericGraphTraits<GraphType>::NodeRef &G)
 {
     return make_range(GenericGraphTraits<Inverse<GraphType>>::child_begin(G),
                       GenericGraphTraits<Inverse<GraphType>>::child_end(G));

package/SVF-osx/svf/include/Graphs/ICFG.h

@@ -76,6 +76,7 @@ private:
     GlobalICFGNode* globalBlockNode; ///< unique basic block for all globals
     ICFGNodeToSVFLoopVec icfgNodeToSVFLoopVec; ///< map ICFG node to the SVF loops where it resides
 
+
 public:
     /// Constructor
     ICFG();

package/SVF-osx/svf/include/Graphs/ICFGNode.h

@@ -94,6 +94,7 @@ public:
         return bb;
     }
 
+
     /// Overloading operator << for dumping ICFG node ID
     //@{
     friend OutStream &operator<<(OutStream &o, const ICFGNode &node)
@@ -253,6 +254,7 @@ public:
     //@}
 };
 
+
 /*!
  * Function entry ICFGNode containing a set of FormalParmVFGNodes of a function
  */
@@ -478,6 +480,7 @@ public:
     virtual const std::string toString() const;
 };
 
+
 /*!
  * Return ICFGNode containing (at most one) ActualRetVFGNode at a callsite
  */

package/SVF-osx/svf/include/Graphs/ICFGStat.h

@@ -123,6 +123,7 @@ public:
             else if (SVFUtil::isa<FunExitICFGNode>(node))
                 numOfExitNodes++;
 
+
             ICFGEdge::ICFGEdgeSetTy::iterator edgeIt =
                 it->second->OutEdgeBegin();
             ICFGEdge::ICFGEdgeSetTy::iterator edgeEit =
@@ -160,3 +161,4 @@ public:
 } // End namespace SVF
 
 #endif /* INCLUDE_UTIL_ICFGSTAT_H_ */
+

package/SVF-osx/svf/include/Graphs/IRGraph.h

@@ -27,6 +27,7 @@
  *      Author: Yulei Sui
  */
 
+
 #ifndef IRGRAPH_H_
 #define IRGRAPH_H_
 

package/SVF-osx/svf/include/Graphs/PTACallGraph.h

@@ -41,6 +41,7 @@ namespace SVF
 class PTACallGraphNode;
 class SVFModule;
 
+
 /*
  * Call Graph edge representing a calling relation between two functions
  * Multiple calls from function A to B are merged into one call edge
@@ -57,6 +58,7 @@ public:
         CallRetEdge,TDForkEdge,TDJoinEdge,HareParForEdge
     };
 
+
 private:
     CallInstSet directCalls;
     CallInstSet indirectCalls;
@@ -196,6 +198,7 @@ public:
     /// 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 PTACallGraphNode &node)

package/SVF-osx/svf/include/Graphs/SCC.h

@@ -0,0 +1,354 @@
+//===- SCC.h -- SCC detection algorithm---------------------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2017>  <Yulei Sui>
+//
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * SCC.h
+ *
+ * Esko Nuutila and Eljas Soisalon-Soininen, "On finding the
+ *  strongly connected components in a directed graph".
+ *  Inf. Process. Letters, 49(1):9-14, 1994.
+ *
+ * The implementation is derived from the pseudo code in the following paper:
+ * Pereira and Berlin, "Wave Propagation and Deep Propagation for Pointer Analysis",
+ * CGO 2009, 126-135, 2009.
+ *
+ * And influenced by implementation from Open64 compiler
+ *
+ *  Created on: Jul 12, 2013
+ *      Author: yusui
+ */
+
+#ifndef SCC_H_
+#define SCC_H_
+
+#include "SVFIR/SVFValue.h"	// for NodeBS
+#include <limits.h>
+#include <stack>
+#include <map>
+
+namespace SVF
+{
+
+class GNodeSCCInfo;
+
+template<class GraphType>
+class SCCDetection
+{
+
+private:
+    ///Define the GTraits and node iterator for printing
+    typedef SVF::GenericGraphTraits<GraphType> GTraits;
+    typedef typename GTraits::NodeRef          GNODE;
+    typedef typename GTraits::nodes_iterator node_iterator;
+    typedef typename GTraits::ChildIteratorType child_iterator;
+    typedef unsigned NodeID ;
+
+public:
+    typedef std::stack<NodeID> GNodeStack;
+
+    class GNodeSCCInfo
+    {
+    public:
+        GNodeSCCInfo() : _visited(false), _inSCC(false), _rep(UINT_MAX) {}
+
+        inline bool visited(void) const
+        {
+            return _visited;
+        }
+        inline void visited(bool v)
+        {
+            _visited = v;
+        }
+        inline bool inSCC(void)   const
+        {
+            return _inSCC;
+        }
+        inline void inSCC(bool v)
+        {
+            _inSCC = v;
+        }
+        inline NodeID rep(void)const
+        {
+            return _rep;
+        }
+        inline void rep(NodeID n)
+        {
+            _rep = n;
+        }
+        inline void addSubNodes(NodeID n)
+        {
+            _subNodes.set(n);
+        }
+        inline NodeBS& subNodes()
+        {
+            return _subNodes;
+        }
+        inline const NodeBS& subNodes() const
+        {
+            return _subNodes;
+        }
+    private:
+        bool     _visited;
+        bool     _inSCC;
+        NodeID  _rep;
+        NodeBS _subNodes; /// nodes in the scc represented by this node
+    };
+
+    typedef Map<NodeID,GNodeSCCInfo > GNODESCCInfoMap;
+    typedef Map<NodeID, NodeID> NodeToNodeMap;
+
+    SCCDetection(const GraphType &GT)
+        : _graph(GT),
+          _I(0)
+    {}
+
+
+    // Return a handle to the stack of nodes in topological
+    // order.  This will be used to seed the initial solution
+    // and improve efficiency.
+    inline GNodeStack &topoNodeStack()
+    {
+        return _T;
+    }
+
+    const inline  GNODESCCInfoMap &GNodeSCCInfo() const
+    {
+        return _NodeSCCAuxInfo;
+    }
+
+    /// get the rep node if not found return itself
+    inline NodeID repNode(NodeID n) const
+    {
+        typename GNODESCCInfoMap::const_iterator it = _NodeSCCAuxInfo.find(n);
+        assert(it!=_NodeSCCAuxInfo.end() && "scc rep not found");
+        NodeID rep = it->second.rep();
+        return rep!= UINT_MAX ? rep : n ;
+    }
+
+
+    /// whether the node is in a cycle
+    inline bool isInCycle(NodeID n) const
+    {
+        NodeID rep = repNode(n);
+        // multi-node cycle
+        if (subNodes(rep).count() > 1)
+        {
+            return true;
+        }
+        // self-cycle
+        else
+        {
+            child_iterator EI = GTraits::direct_child_begin(Node(rep));
+            child_iterator EE = GTraits::direct_child_end(Node(rep));
+            for (; EI != EE; ++EI)
+            {
+                NodeID w = Node_Index(*EI);
+                if(w==rep)
+                    return true;
+            }
+            return false;
+        }
+    }
+
+    /// get all subnodes in one scc, if size is empty insert itself into the set
+    inline const NodeBS& subNodes(NodeID n)  const
+    {
+        typename GNODESCCInfoMap::const_iterator it = _NodeSCCAuxInfo.find(n);
+        assert(it!=_NodeSCCAuxInfo.end() && "scc rep not found");
+        return it->second.subNodes();
+    }
+
+    /// get all repNodeID
+    inline const NodeBS &getRepNodes() const
+    {
+        return repNodes;
+    }
+
+    const inline GraphType & graph()
+    {
+        return _graph;
+    }
+private:
+
+    GNODESCCInfoMap  _NodeSCCAuxInfo;
+
+    const GraphType &           _graph;
+    NodeID                   _I;
+    NodeToNodeMap            _D;
+    GNodeStack             _SS;
+    GNodeStack             _T;
+    NodeBS repNodes;
+
+    inline bool visited(NodeID n)
+    {
+        return _NodeSCCAuxInfo[n].visited();
+    }
+    inline bool inSCC(NodeID n)
+    {
+        return _NodeSCCAuxInfo[n].inSCC();
+    }
+
+    inline void setVisited(NodeID n,bool v)
+    {
+        _NodeSCCAuxInfo[n].visited(v);
+    }
+    inline void setInSCC(NodeID n,bool v)
+    {
+        _NodeSCCAuxInfo[n].inSCC(v);
+    }
+    inline void rep(NodeID n, NodeID r)
+    {
+        _NodeSCCAuxInfo[n].rep(r);
+        _NodeSCCAuxInfo[r].addSubNodes(n);
+        if (n != r)
+        {
+            _NodeSCCAuxInfo[n].subNodes().clear();
+            repNodes.reset(n);
+            repNodes.set(r);
+        }
+    }
+
+    inline NodeID rep(NodeID n)
+    {
+        return _NodeSCCAuxInfo[n].rep();
+    }
+    inline bool isInSCC(NodeID n)
+    {
+        return _NodeSCCAuxInfo[n].inSCC();
+    }
+
+    inline GNODE Node(NodeID id) const
+    {
+        return GTraits::getNode(_graph, id);
+    }
+
+    inline NodeID Node_Index(GNODE node) const
+    {
+        return GTraits::getNodeID(node);
+    }
+
+    void visit(NodeID v)
+    {
+        // SVFUtil::outs() << "visit GNODE: " << Node_Index(v)<< "\n";
+        _I += 1;
+        _D[v] = _I;
+        this->rep(v,v);
+        this->setVisited(v,true);
+
+        child_iterator EI = GTraits::direct_child_begin(Node(v));
+        child_iterator EE = GTraits::direct_child_end(Node(v));
+
+        for (; EI != EE; ++EI)
+        {
+            NodeID w = Node_Index(*EI);
+
+            if (!this->visited(w))
+                visit(w);
+            if (!this->inSCC(w))
+            {
+                NodeID rep;
+                rep = _D[this->rep(v)] < _D[this->rep(w)] ?
+                      this->rep(v) : this->rep(w);
+                this->rep(v,rep);
+            }
+        }
+        if (this->rep(v) == v)
+        {
+            this->setInSCC(v,true);
+            while (!_SS.empty())
+            {
+                NodeID w = _SS.top();
+                if (_D[w] <= _D[v])
+                    break;
+                else
+                {
+                    _SS.pop();
+                    this->setInSCC(w,true);
+                    this->rep(w,v);
+                }
+            }
+            _T.push(v);
+        }
+        else
+            _SS.push(v);
+    }
+
+    void clear()
+    {
+        _NodeSCCAuxInfo.clear();
+        _I = 0;
+        _D.clear();
+        repNodes.clear();
+        while(!_SS.empty())
+            _SS.pop();
+        while(!_T.empty())
+            _T.pop();
+    }
+public:
+
+    void find(void)
+    {
+        // Visit each unvisited root node.   A root node is defined
+        // to be a node that has no incoming copy/skew edges
+        clear();
+        node_iterator I = GTraits::nodes_begin(_graph);
+        node_iterator E = GTraits::nodes_end(_graph);
+        for (; I != E; ++I)
+        {
+            NodeID node = Node_Index(*I);
+            if (!this->visited(node))
+            {
+                // We skip any nodes that have a representative other than
+                // themselves.  Such nodes occur as a result of merging
+                // nodes either through unifying an ACC or other node
+                // merging optimizations.  Any such node should have no
+                // outgoing edges and therefore should no longer be a member
+                // of an SCC.
+                if (this->rep(node) == UINT_MAX || this->rep(node) == node)
+                    visit(node);
+                else
+                    this->visited(node);
+            }
+        }
+    }
+
+    void find(NodeSet &candidates)
+    {
+        // This function is reloaded to only visit candidate NODES
+        clear();
+        for (NodeID node : candidates)
+        {
+            if (!this->visited(node))
+            {
+                if (this->rep(node) == UINT_MAX || this->rep(node) == node)
+                    visit(node);
+                else
+                    this->visited(node);
+            }
+        }
+    }
+
+};
+
+} // End namespace SVF
+
+#endif /* SCC_H_ */

package/SVF-osx/svf/include/Graphs/SVFG.h

@@ -57,6 +57,7 @@ typedef PHIVFGNode PHISVFGNode;
 typedef IntraPHIVFGNode IntraPHISVFGNode;
 typedef InterPHIVFGNode InterPHISVFGNode;
 
+
 /*!
  * Sparse value flow graph
  * Each node stands for a definition, each edge stands for value flow relations
@@ -345,6 +346,7 @@ protected:
     }
     //@}
 
+
     /// Given a PAGNode, set/get its def SVFG node (definition of top level pointers)
     //@{
     inline void setDef(const PAGNode* pagNode, const SVFGNode* node)

package/SVF-osx/svf/include/Graphs/SVFGEdge.h

@@ -198,6 +198,7 @@ public:
     virtual const std::string toString() const;
 };
 
+
 /*!
  * MHP SVFG edge representing indirect value-flows between
  * two memory access may-happen-in-parallel in multithreaded program

package/SVF-osx/svf/include/Graphs/SVFGNode.h

@@ -131,6 +131,7 @@ public:
     virtual const std::string toString() const;
 };
 
+
 /*
  * SVFG Node stands for return mu node (address-taken variables)
  */
@@ -172,6 +173,7 @@ public:
     virtual const std::string toString() const;
 };
 
+
 /*
  * SVFG Node stands for callsite mu node (address-taken variables)
  */
@@ -200,6 +202,7 @@ public:
         return ver;
     }
 
+
     /// Methods for support type inquiry through isa, cast, and dyn_cast:
     //@{
     static inline bool classof(const ActualINSVFGNode *)
@@ -219,6 +222,7 @@ public:
     virtual const std::string toString() const;
 };
 
+
 /*
  * SVFG Node stands for callsite chi node (address-taken variables)
  */
@@ -265,6 +269,7 @@ public:
     virtual const std::string toString() const;
 };
 
+
 /*
  * SVFG Node stands for a memory ssa phi node or formalIn or ActualOut
  */
@@ -392,6 +397,7 @@ public:
     virtual const std::string toString() const;
 };
 
+
 /*
  * Inter MSSA PHI (formalIN/ActualOUT)
  */
@@ -501,6 +507,7 @@ private:
     const Version version;
 };
 
+
 } // End namespace SVF
 
 #endif /* INCLUDE_MSSA_SVFGNODE_H_ */

package/SVF-osx/svf/include/Graphs/SVFGOPT.h

@@ -32,9 +32,11 @@
  *
  */
 
+
 #ifndef SVFGOPT_H_
 #define SVFGOPT_H_
 
+
 #include "Graphs/SVFG.h"
 #include "Util/WorkList.h"
 
@@ -343,6 +345,7 @@ private:
     }
     //@}
 
+
     NodeIDToNodeIDMap actualInToDefMap;	///< map actual-in to its def-site node
     NodeIDToNodeIDMap formalOutToDefMap;	///< map formal-out to its def-site node
     NodeBS defNodes;	///< preserved def nodes of formal-in/actual-out

package/SVF-osx/svf/include/Graphs/SVFGStat.h

@@ -32,12 +32,13 @@
  *
  */
 
+
 #ifndef SVFGSTAT_H_
 #define SVFGSTAT_H_
 
 #include "Graphs/SVFG.h"
+#include "SCC.h"
 #include "Util/PTAStat.h"
-#include "Util/SCC.h"
 
 namespace SVF
 {
@@ -87,6 +88,7 @@ private:
     MemSSA* mssa;
 };
 
+
 class SVFGStat : public PTAStat
 {
 public:

package/SVF-osx/svf/include/Graphs/ThreadCallGraph.h

@@ -153,6 +153,7 @@ public:
     typedef GenericNode<PTACallGraphNode, HareParForEdge>::GEdgeSetTy ParForEdgeSet;
 };
 
+
 /*!
  * Thread sensitive call graph
  */
@@ -196,6 +197,7 @@ public:
     /// Update join edge using pointer analysis results
     void updateJoinEdge(PointerAnalysis* pta);
 
+
     /// Get call graph edge via call instruction
     //@{
     /// whether this call instruction has a valid call graph edge
@@ -360,6 +362,7 @@ public:
     void addIndirectParForEdge(const CallICFGNode* cs, const SVFFunction* callee);
     //@}
 
+
     /// map call instruction to its CallGraphEdge map
     inline void addThreadForkEdgeSetMap(const CallICFGNode* cs, ThreadForkEdge* edge)
     {

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

@@ -30,6 +30,7 @@
 #ifndef INCLUDE_UTIL_VFG_H_
 #define INCLUDE_UTIL_VFG_H_
 
+
 #include "SVFIR/SVFIR.h"
 #include "Graphs/PTACallGraph.h"
 #include "Graphs/VFGNode.h"
@@ -82,6 +83,7 @@ public:
     typedef Set<const VFGNode*> GlobalVFGNodeSet;
     typedef Set<const PAGNode*> PAGNodeSet;
 
+
 protected:
     NodeID totalVFGNode;
     PAGNodeToDefMapTy PAGNodeToDefMap;	///< map a pag node to its definition SVG node