svf-lib 1.0.2675 → 1.0.2677

package/SVF-linux-aarch64/include/Graphs/CallGraph.h

@@ -502,6 +502,24 @@ struct GenericGraphTraits<Inverse<SVF::CallGraphNode*> > : public GenericGraphTr
 template<> struct GenericGraphTraits<SVF::CallGraph*> : public GenericGraphTraits<SVF::GenericGraph<SVF::CallGraphNode,SVF::CallGraphEdge>* >
 {
     typedef SVF::CallGraphNode*NodeRef;
+
+    // Graph-intrinsic queries shared with the sliced-view specialisation
+    // (GenericGraphTraits<const SlicedThreadCallGraphView*>).
+    //@{
+    /// In-edges of n under this graph (whole CallGraph: all of them).
+    static void getInEdges(const SVF::CallGraph*, const SVF::CallGraphNode* n,
+                           std::vector<const SVF::CallGraphEdge*>& out)
+    {
+        out.clear();
+        for (SVF::CallGraphEdge* e : n->getInEdges())
+            out.push_back(e);
+    }
+    /// The CallGraph object whose nodes an analysis over this graph scans.
+    static const SVF::CallGraph* getCallGraph(const SVF::CallGraph* g)
+    {
+        return g;
+    }
+    //@}
 };
 
 } // End namespace llvm

package/SVF-linux-aarch64/include/Graphs/DOTGraphTraits.h

@@ -66,18 +66,29 @@ public:
         return false;
     }
 
+    /// getNodeIdentifier - The value written after "Node" as the dot node id.
+    /// Defaults to the node reference reinterpreted as an address, which works
+    /// for pointer NodeRefs; value NodeRefs (e.g. sliced views) override this to
+    /// return a stable per-node address. (Node params below are templated so the
+    /// defaults accept any NodeRef, pointer or value.)
+    template <typename NodeT>
+    static const void *getNodeIdentifier(NodeT N)
+    {
+        return static_cast<const void *>(N);
+    }
+
     /// isNodeHidden - If the function returns true, the given node is not
     /// displayed in the graph.
-    template <typename GraphType>
-    static bool isNodeHidden(const void *, const GraphType &)
+    template <typename NodeT, typename GraphType>
+    static bool isNodeHidden(NodeT, const GraphType &)
     {
         return false;
     }
 
     /// getNodeLabel - Given a node and a pointer to the top level graph, return
     /// the label to print in the node.
-    template<typename GraphType>
-    std::string getNodeLabel(const void *, const GraphType &)
+    template<typename NodeT, typename GraphType>
+    std::string getNodeLabel(NodeT, const GraphType &)
     {
         return "";
     }
@@ -85,22 +96,22 @@ public:
     // getNodeIdentifierLabel - Returns a string representing the
     // address or other unique identifier of the node. (Only used if
     // non-empty.)
-    template <typename GraphType>
-    static std::string getNodeIdentifierLabel(const void *, const GraphType &)
+    template <typename NodeT, typename GraphType>
+    static std::string getNodeIdentifierLabel(NodeT, const GraphType &)
     {
         return "";
     }
 
-    template<typename GraphType>
-    static std::string getNodeDescription(const void *, const GraphType &)
+    template<typename NodeT, typename GraphType>
+    static std::string getNodeDescription(NodeT, const GraphType &)
     {
         return "";
     }
 
     /// If you want to specify custom node attributes, this is the place to do so
     ///
-    template<typename GraphType>
-    static std::string getNodeAttributes(const void *,
+    template<typename NodeT, typename GraphType>
+    static std::string getNodeAttributes(NodeT,
                                          const GraphType &)
     {
         return "";
@@ -108,8 +119,8 @@ public:
 
     /// If you want to override the dot attributes printed for a particular edge,
     /// override this method.
-    template<typename EdgeIter, typename GraphType>
-    static std::string getEdgeAttributes(const void *, EdgeIter,
+    template<typename NodeT, typename EdgeIter, typename GraphType>
+    static std::string getEdgeAttributes(NodeT, EdgeIter,
                                          const GraphType &)
     {
         return "";
@@ -117,8 +128,8 @@ public:
 
     /// getEdgeSourceLabel - If you want to label the edge source itself,
     /// implement this method.
-    template<typename EdgeIter>
-    static std::string getEdgeSourceLabel(const void *, EdgeIter)
+    template<typename NodeT, typename EdgeIter>
+    static std::string getEdgeSourceLabel(NodeT, EdgeIter)
     {
         return "";
     }
@@ -126,8 +137,8 @@ public:
     /// edgeTargetsEdgeSource - This method returns true if this outgoing edge
     /// should actually target another edge source, not a node.  If this method is
     /// implemented, getEdgeTarget should be implemented.
-    template<typename EdgeIter>
-    static bool edgeTargetsEdgeSource(const void *, EdgeIter)
+    template<typename NodeT, typename EdgeIter>
+    static bool edgeTargetsEdgeSource(NodeT, EdgeIter)
     {
         return false;
     }
@@ -135,8 +146,8 @@ public:
     /// getEdgeTarget - If edgeTargetsEdgeSource returns true, this method is
     /// called to determine which outgoing edge of Node is the target of this
     /// edge.
-    template<typename EdgeIter>
-    static EdgeIter getEdgeTarget(const void *, EdgeIter I)
+    template<typename NodeT, typename EdgeIter>
+    static EdgeIter getEdgeTarget(NodeT, EdgeIter I)
     {
         return I;
     }
@@ -150,14 +161,16 @@ public:
 
     /// numEdgeDestLabels - If hasEdgeDestLabels, this function returns the
     /// number of incoming edge labels the given node has.
-    static unsigned numEdgeDestLabels(const void *)
+    template<typename NodeT>
+    static unsigned numEdgeDestLabels(NodeT)
     {
         return 0;
     }
 
     /// getEdgeDestLabel - If hasEdgeDestLabels, this function returns the
     /// incoming edge label with the given index in the given node.
-    static std::string getEdgeDestLabel(const void *, unsigned)
+    template<typename NodeT>
+    static std::string getEdgeDestLabel(NodeT, unsigned)
     {
         return "";
     }

package/SVF-linux-aarch64/include/Graphs/GraphPrinter.h

@@ -92,7 +92,7 @@ public:
         node_iterator E = GTraits::nodes_end(GT);
         for (; I != E; ++I)
         {
-            NodeRef *Node = *I;
+            NodeRef Node = *I;
             O << "node :" << Node << "'\n";
             child_iterator EI = GTraits::child_begin(Node);
             child_iterator EE = GTraits::child_end(Node);

package/SVF-linux-aarch64/include/Graphs/GraphWriter.h

@@ -72,10 +72,9 @@ class GraphWriter
     using child_iterator = typename GTraits::ChildIteratorType;
     DOTTraits DTraits;
 
-    static_assert(std::is_pointer<NodeRef>::value,
-                  "FIXME: Currently GraphWriter requires the NodeRef type to be "
-                  "a pointer.\nThe pointer usage should be moved to "
-                  "DOTGraphTraits, and removed from GraphWriter itself.");
+    // NodeRef may be a pointer or a value type (e.g. a sliced-view contextual
+    // NodeRef). Node identity for the dot output is obtained from
+    // DOTGraphTraits::getNodeIdentifier (defaults to the pointer value).
 
     // Writes the edge labels of the node to O and returns true if there are any
     // edge labels not equal to the empty string "".
@@ -172,7 +171,7 @@ public:
     {
         std::string NodeAttributes = DTraits.getNodeAttributes(Node, G);
 
-        O << "\tNode" << static_cast<const void*>(Node) << " [";
+        O << "\tNode" << DTraits.getNodeIdentifier(Node) << " [";
         if (!NodeAttributes.empty()) O << NodeAttributes << ",";
         O << "label=\"{";
 
@@ -271,8 +270,8 @@ public:
             if (DTraits.getEdgeSourceLabel(Node, EI).empty())
                 edgeidx = -1;
 
-            emitEdge(static_cast<const void*>(Node), edgeidx,
-                     static_cast<const void*>(TargetNode), DestPort,
+            emitEdge(DTraits.getNodeIdentifier(Node), edgeidx,
+                     DTraits.getNodeIdentifier(TargetNode), DestPort,
                      DTraits.getEdgeAttributes(Node, EI, G));
         }
     }

package/SVF-linux-aarch64/include/Graphs/ICFG.h

@@ -299,6 +299,46 @@ struct GenericGraphTraits<Inverse<SVF::ICFGNode *> > : public GenericGraphTraits
 template<> struct GenericGraphTraits<SVF::ICFG*> : public GenericGraphTraits<SVF::GenericGraph<SVF::ICFGNode,SVF::ICFGEdge>* >
 {
     typedef SVF::ICFGNode *NodeRef;
+
+    // Graph-intrinsic queries shared with the sliced-view specialisation
+    // (GenericGraphTraits<const SlicedICFGView*>), so a graph-parameterised
+    // analysis resolves the right behaviour from the graph type alone.
+    //@{
+    /// Entry node of fun under this graph (whole ICFG: the entry block's front).
+    static const SVF::ICFGNode* getFunEntry(SVF::ICFG*, const SVF::FunObjVar* fun)
+    {
+        return fun->getEntryBlock()->front();
+    }
+    /// Nodes of fun contained in this graph (whole ICFG: all of them).
+    static void getFunICFGNodes(SVF::ICFG*, const SVF::FunObjVar* fun,
+                                std::vector<const SVF::ICFGNode*>& out)
+    {
+        out.clear();
+        for (auto it : *fun)
+            for (const SVF::ICFGNode* n : it.second->getICFGNodeList())
+                out.push_back(n);
+    }
+    /// Successors / predecessors of n under this graph.
+    static void getSuccNodes(SVF::ICFG*, const SVF::ICFGNode* n,
+                             std::vector<const SVF::ICFGNode*>& out)
+    {
+        out.clear();
+        for (const SVF::ICFGEdge* e : n->getOutEdges())
+            out.push_back(e->getDstNode());
+    }
+    static void getPredNodes(SVF::ICFG*, const SVF::ICFGNode* n,
+                             std::vector<const SVF::ICFGNode*>& out)
+    {
+        out.clear();
+        for (const SVF::ICFGEdge* e : n->getInEdges())
+            out.push_back(e->getSrcNode());
+    }
+    /// Whether n belongs to this graph (whole ICFG contains every node).
+    static bool containsNode(SVF::ICFG*, const SVF::ICFGNode*)
+    {
+        return true;
+    }
+    //@}
 };
 
 } // End namespace llvm

package/SVF-linux-aarch64/include/Graphs/SVFG.h

@@ -500,6 +500,14 @@ namespace SVF
 template<> struct GenericGraphTraits<SVF::SVFG*> : public GenericGraphTraits<SVF::GenericGraph<SVF::SVFGNode,SVF::SVFGEdge>* >
 {
     typedef SVF::SVFGNode *NodeRef;
+
+    /// Whether n belongs to this graph (the whole SVFG contains every node).
+    /// Mirrored by GenericGraphTraits<const SlicedSVFGView*>, so a solver
+    /// templated on the graph type restricts itself to the graph's nodes.
+    static bool containsNode(SVF::SVFG*, const SVF::SVFGNode*)
+    {
+        return true;
+    }
 };
 
 } // End namespace llvm