247 lines
6.6 KiB
C++
247 lines
6.6 KiB
C++
/* Template classes for directed graphs.
|
|
Copyright (C) 2019-2023 Free Software Foundation, Inc.
|
|
Contributed by David Malcolm <dmalcolm@redhat.com>.
|
|
|
|
This file is part of GCC.
|
|
|
|
GCC is free software; you can redistribute it and/or modify it
|
|
under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3, or (at your option)
|
|
any later version.
|
|
|
|
GCC 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
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING3. If not see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#ifndef GCC_DIGRAPH_H
|
|
#define GCC_DIGRAPH_H
|
|
|
|
#include "diagnostic.h"
|
|
#include "tree-diagnostic.h" /* for default_tree_printer. */
|
|
#include "graphviz.h"
|
|
|
|
/* Templates for a family of classes: digraph, node, edge, and cluster.
|
|
This assumes a traits type with the following typedefs:
|
|
node_t: the node class
|
|
edge_t: the edge class
|
|
dump_args_t: additional args for dot-dumps
|
|
cluster_t: the cluster class (for use when generating .dot files).
|
|
|
|
Using a template allows for typesafe nodes and edges: a node's
|
|
predecessor and successor edges can be of a node-specific edge
|
|
subclass, without needing casting. */
|
|
|
|
/* Abstract base class for a node in a directed graph. */
|
|
|
|
template <typename GraphTraits>
|
|
class dnode
|
|
{
|
|
public:
|
|
typedef typename GraphTraits::edge_t edge_t;
|
|
typedef typename GraphTraits::dump_args_t dump_args_t;
|
|
|
|
virtual ~dnode () {}
|
|
virtual void dump_dot (graphviz_out *gv, const dump_args_t &args) const = 0;
|
|
|
|
auto_vec<edge_t *> m_preds;
|
|
auto_vec<edge_t *> m_succs;
|
|
};
|
|
|
|
/* Abstract base class for an edge in a directed graph. */
|
|
|
|
template <typename GraphTraits>
|
|
class dedge
|
|
{
|
|
public:
|
|
typedef typename GraphTraits::node_t node_t;
|
|
typedef typename GraphTraits::dump_args_t dump_args_t;
|
|
|
|
dedge (node_t *src, node_t *dest)
|
|
: m_src (src), m_dest (dest) {}
|
|
|
|
virtual ~dedge () {}
|
|
|
|
virtual void dump_dot (graphviz_out *gv, const dump_args_t &args) const = 0;
|
|
|
|
node_t *const m_src;
|
|
node_t *const m_dest;
|
|
};
|
|
|
|
/* Abstract base class for a directed graph.
|
|
This class maintains the vectors of nodes and edges,
|
|
and owns the nodes and edges. */
|
|
|
|
template <typename GraphTraits>
|
|
class digraph
|
|
{
|
|
public:
|
|
typedef typename GraphTraits::node_t node_t;
|
|
typedef typename GraphTraits::edge_t edge_t;
|
|
typedef typename GraphTraits::dump_args_t dump_args_t;
|
|
typedef typename GraphTraits::cluster_t cluster_t;
|
|
|
|
digraph () {}
|
|
virtual ~digraph () {}
|
|
|
|
void dump_dot_to_pp (pretty_printer *pp,
|
|
cluster_t *root_cluster,
|
|
const dump_args_t &args) const;
|
|
void dump_dot_to_file (FILE *fp,
|
|
cluster_t *root_cluster,
|
|
const dump_args_t &args) const;
|
|
void dump_dot (const char *path,
|
|
cluster_t *root_cluster,
|
|
const dump_args_t &args) const;
|
|
|
|
void add_node (node_t *node);
|
|
void add_edge (edge_t *edge);
|
|
|
|
auto_delete_vec<node_t> m_nodes;
|
|
auto_delete_vec<edge_t> m_edges;
|
|
};
|
|
|
|
/* Abstract base class for splitting dnodes into hierarchical clusters
|
|
in the generated .dot file.
|
|
|
|
See "Subgraphs and Clusters" within
|
|
https://www.graphviz.org/doc/info/lang.html
|
|
and e.g.
|
|
https://graphviz.gitlab.io/_pages/Gallery/directed/cluster.html
|
|
|
|
If a root_cluster is passed to dump_dot*, then all nodes will be
|
|
added to it at the start of dumping, via calls to add_node.
|
|
|
|
The root cluster can organize the nodes into a hierarchy of
|
|
child clusters.
|
|
|
|
After all nodes are added to the root cluster, dump_dot will then
|
|
be called on it (and not on the nodes themselves). */
|
|
|
|
template <typename GraphTraits>
|
|
class cluster
|
|
{
|
|
public:
|
|
typedef typename GraphTraits::node_t node_t;
|
|
typedef typename GraphTraits::dump_args_t dump_args_t;
|
|
|
|
virtual ~cluster () {}
|
|
|
|
virtual void add_node (node_t *node) = 0;
|
|
|
|
/* Recursively dump the cluster, all nodes, and child clusters. */
|
|
virtual void dump_dot (graphviz_out *gv, const dump_args_t &) const = 0;
|
|
};
|
|
|
|
/* Write .dot information for this graph to PP, passing ARGS to the nodes
|
|
and edges.
|
|
If ROOT_CLUSTER is non-NULL, use it to organize the nodes into clusters. */
|
|
|
|
template <typename GraphTraits>
|
|
inline void
|
|
digraph<GraphTraits>::dump_dot_to_pp (pretty_printer *pp,
|
|
cluster_t *root_cluster,
|
|
const dump_args_t &args) const
|
|
{
|
|
graphviz_out gv (pp);
|
|
|
|
pp_string (pp, "digraph \"");
|
|
pp_string (pp, "base");
|
|
pp_string (pp, "\" {\n");
|
|
|
|
gv.indent ();
|
|
|
|
pp_string (pp, "overlap=false;\n");
|
|
pp_string (pp, "compound=true;\n");
|
|
|
|
/* If using clustering, emit all nodes via clusters. */
|
|
if (root_cluster)
|
|
{
|
|
int i;
|
|
node_t *n;
|
|
FOR_EACH_VEC_ELT (m_nodes, i, n)
|
|
root_cluster->add_node (n);
|
|
root_cluster->dump_dot (&gv, args);
|
|
}
|
|
else
|
|
{
|
|
/* Otherwise, display all nodes at top level. */
|
|
int i;
|
|
node_t *n;
|
|
FOR_EACH_VEC_ELT (m_nodes, i, n)
|
|
n->dump_dot (&gv, args);
|
|
}
|
|
|
|
/* Edges. */
|
|
int i;
|
|
edge_t *e;
|
|
FOR_EACH_VEC_ELT (m_edges, i, e)
|
|
e->dump_dot (&gv, args);
|
|
|
|
/* Terminate "digraph" */
|
|
gv.outdent ();
|
|
pp_string (pp, "}");
|
|
pp_newline (pp);
|
|
}
|
|
|
|
/* Write .dot information for this graph to FP, passing ARGS to the nodes
|
|
and edges.
|
|
If ROOT_CLUSTER is non-NULL, use it to organize the nodes into clusters. */
|
|
|
|
template <typename GraphTraits>
|
|
inline void
|
|
digraph<GraphTraits>::dump_dot_to_file (FILE *fp,
|
|
cluster_t *root_cluster,
|
|
const dump_args_t &args) const
|
|
{
|
|
pretty_printer pp;
|
|
// TODO:
|
|
pp_format_decoder (&pp) = default_tree_printer;
|
|
pp.buffer->stream = fp;
|
|
dump_dot_to_pp (&pp, root_cluster, args);
|
|
pp_flush (&pp);
|
|
}
|
|
|
|
/* Write .dot information for this graph to a file at PATH, passing ARGS
|
|
to the nodes and edges.
|
|
If ROOT_CLUSTER is non-NULL, use it to organize the nodes into clusters. */
|
|
|
|
template <typename GraphTraits>
|
|
inline void
|
|
digraph<GraphTraits>::dump_dot (const char *path,
|
|
cluster_t *root_cluster,
|
|
const dump_args_t &args) const
|
|
{
|
|
FILE *fp = fopen (path, "w");
|
|
dump_dot_to_file (fp, root_cluster, args);
|
|
fclose (fp);
|
|
}
|
|
|
|
/* Add NODE to this DIGRAPH, taking ownership. */
|
|
|
|
template <typename GraphTraits>
|
|
inline void
|
|
digraph<GraphTraits>::add_node (node_t *node)
|
|
{
|
|
m_nodes.safe_push (node);
|
|
}
|
|
|
|
/* Add EDGE to this digraph, and to the preds/succs of its endpoints.
|
|
Take ownership of EDGE. */
|
|
|
|
template <typename GraphTraits>
|
|
inline void
|
|
digraph<GraphTraits>::add_edge (edge_t *edge)
|
|
{
|
|
m_edges.safe_push (edge);
|
|
edge->m_dest->m_preds.safe_push (edge);
|
|
edge->m_src->m_succs.safe_push (edge);
|
|
|
|
}
|
|
|
|
#endif /* GCC_DIGRAPH_H */
|