GraphWriter.h revision 5b296e307f71bcaf3d31eff4a04ba5d2016eb628 
1//===-- llvm/Support/GraphWriter.h - Write graph to a .dot file -*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines a simple interface that can be used to print out generic
11// LLVM graphs to ".dot" files.  "dot" is a tool that is part of the AT&T
12// graphviz package (http://www.research.att.com/sw/tools/graphviz/) which can
13// be used to turn the files output by this interface into a variety of
14// different graphics formats.
15//
16// Graphs do not need to implement any interface past what is already required
17// by the GraphTraits template, but they can choose to implement specializations
18// of the DOTGraphTraits template if they want to customize the graphs output in
19// any way.
20//
21//===----------------------------------------------------------------------===//
22
23#ifndef LLVM_SUPPORT_GRAPHWRITER_H
24#define LLVM_SUPPORT_GRAPHWRITER_H
25
26#include "llvm/Support/DOTGraphTraits.h"
27#include "llvm/Support/raw_ostream.h"
28#include "llvm/ADT/GraphTraits.h"
29#include "llvm/System/Path.h"
30#include <vector>
31#include <cassert>
32
33namespace llvm {
34
35namespace DOT {  // Private functions...
36  std::string EscapeString(const std::string &Label);
37}
38
39namespace GraphProgram {
40   enum Name {
41      DOT,
42      FDP,
43      NEATO,
44      TWOPI,
45      CIRCO
46   };
47}
48
49void DisplayGraph(const sys::Path& Filename, bool wait=true, GraphProgram::Name program = GraphProgram::DOT);
50
51template<typename GraphType>
52class GraphWriter {
53  raw_ostream &O;
54  const GraphType &G;
55
56  typedef DOTGraphTraits<GraphType>           DOTTraits;
57  typedef GraphTraits<GraphType>              GTraits;
58  typedef typename GTraits::NodeType          NodeType;
59  typedef typename GTraits::nodes_iterator    node_iterator;
60  typedef typename GTraits::ChildIteratorType child_iterator;
61  DOTTraits DTraits;
62
63  // Writes the edge labels of the node to O and returns true if there are any
64  // edge labels not equal to the empty string "".
65  bool getEdgeSourceLabels(raw_ostream &O, NodeType *Node) {
66    child_iterator EI = GTraits::child_begin(Node);
67    child_iterator EE = GTraits::child_end(Node);
68    bool hasEdgeSourceLabels = false;
69
70    for (unsigned i = 0; EI != EE && i != 64; ++EI, ++i) {
71      std::string label = DTraits.getEdgeSourceLabel(Node, EI);
72
73      if (label == "")
74        continue;
75
76      hasEdgeSourceLabels = true;
77
78      if (i)
79        O << "|";
80
81      O << "<s" << i << ">" << DTraits.getEdgeSourceLabel(Node, EI);
82    }
83
84    if (EI != EE && hasEdgeSourceLabels)
85      O << "|<s64>truncated...";
86
87    return hasEdgeSourceLabels;
88  }
89
90public:
91  GraphWriter(raw_ostream &o, const GraphType &g, bool SN) : O(o), G(g) {
92  DTraits = DOTTraits(SN);
93}
94
95  void writeHeader(const std::string &Name) {
96    std::string GraphName = DTraits.getGraphName(G);
97
98    if (!Name.empty())
99      O << "digraph \"" << DOT::EscapeString(Name) << "\" {\n";
100    else if (!GraphName.empty())
101      O << "digraph \"" << DOT::EscapeString(GraphName) << "\" {\n";
102    else
103      O << "digraph unnamed {\n";
104
105    if (DTraits.renderGraphFromBottomUp())
106      O << "\trankdir=\"BT\";\n";
107
108    if (!Name.empty())
109      O << "\tlabel=\"" << DOT::EscapeString(Name) << "\";\n";
110    else if (!GraphName.empty())
111      O << "\tlabel=\"" << DOT::EscapeString(GraphName) << "\";\n";
112    O << DTraits.getGraphProperties(G);
113    O << "\n";
114  }
115
116  void writeFooter() {
117    // Finish off the graph
118    O << "}\n";
119  }
120
121  void writeNodes() {
122    // Loop over the graph, printing it out...
123    for (node_iterator I = GTraits::nodes_begin(G), E = GTraits::nodes_end(G);
124         I != E; ++I)
125      writeNode(*I);
126  }
127
128  void writeNode(NodeType& Node) {
129    writeNode(&Node);
130  }
131
132  void writeNode(NodeType *const *Node) {
133    writeNode(*Node);
134  }
135
136  void writeNode(NodeType *Node) {
137    std::string NodeAttributes = DTraits.getNodeAttributes(Node, G);
138
139    O << "\tNode" << static_cast<const void*>(Node) << " [shape=record,";
140    if (!NodeAttributes.empty()) O << NodeAttributes << ",";
141    O << "label=\"{";
142
143    if (!DTraits.renderGraphFromBottomUp()) {
144      O << DOT::EscapeString(DTraits.getNodeLabel(Node, G));
145
146      // If we should include the address of the node in the label, do so now.
147      if (DTraits.hasNodeAddressLabel(Node, G))
148        O << "|" << (void*)Node;
149    }
150
151    std::string edgeSourceLabels;
152    raw_string_ostream EdgeSourceLabels(edgeSourceLabels);
153    bool hasEdgeSourceLabels = getEdgeSourceLabels(EdgeSourceLabels, Node);
154
155    if (hasEdgeSourceLabels) {
156      if (!DTraits.renderGraphFromBottomUp()) O << "|";
157
158      O << "{" << EdgeSourceLabels.str() << "}";
159
160      if (DTraits.renderGraphFromBottomUp()) O << "|";
161    }
162
163    if (DTraits.renderGraphFromBottomUp()) {
164      O << DOT::EscapeString(DTraits.getNodeLabel(Node, G));
165
166      // If we should include the address of the node in the label, do so now.
167      if (DTraits.hasNodeAddressLabel(Node, G))
168        O << "|" << (void*)Node;
169    }
170
171    if (DTraits.hasEdgeDestLabels()) {
172      O << "|{";
173
174      unsigned i = 0, e = DTraits.numEdgeDestLabels(Node);
175      for (; i != e && i != 64; ++i) {
176        if (i) O << "|";
177        O << "<d" << i << ">"
178          << DOT::EscapeString(DTraits.getEdgeDestLabel(Node, i));
179      }
180
181      if (i != e)
182        O << "|<d64>truncated...";
183      O << "}";
184    }
185
186    O << "}\"];\n";   // Finish printing the "node" line
187
188    // Output all of the edges now
189    child_iterator EI = GTraits::child_begin(Node);
190    child_iterator EE = GTraits::child_end(Node);
191    for (unsigned i = 0; EI != EE && i != 64; ++EI, ++i)
192      writeEdge(Node, i, EI);
193    for (; EI != EE; ++EI)
194      writeEdge(Node, 64, EI);
195  }
196
197  void writeEdge(NodeType *Node, unsigned edgeidx, child_iterator EI) {
198    if (NodeType *TargetNode = *EI) {
199      int DestPort = -1;
200      if (DTraits.edgeTargetsEdgeSource(Node, EI)) {
201        child_iterator TargetIt = DTraits.getEdgeTarget(Node, EI);
202
203        // Figure out which edge this targets...
204        unsigned Offset =
205          (unsigned)std::distance(GTraits::child_begin(TargetNode), TargetIt);
206        DestPort = static_cast<int>(Offset);
207      }
208
209      if (DTraits.getEdgeSourceLabel(Node, EI) == "")
210        edgeidx = -1;
211
212      emitEdge(static_cast<const void*>(Node), edgeidx,
213               static_cast<const void*>(TargetNode), DestPort,
214               DTraits.getEdgeAttributes(Node, EI));
215    }
216  }
217
218  /// emitSimpleNode - Outputs a simple (non-record) node
219  void emitSimpleNode(const void *ID, const std::string &Attr,
220                      const std::string &Label, unsigned NumEdgeSources = 0,
221                      const std::vector<std::string> *EdgeSourceLabels = 0) {
222    O << "\tNode" << ID << "[ ";
223    if (!Attr.empty())
224      O << Attr << ",";
225    O << " label =\"";
226    if (NumEdgeSources) O << "{";
227    O << DOT::EscapeString(Label);
228    if (NumEdgeSources) {
229      O << "|{";
230
231      for (unsigned i = 0; i != NumEdgeSources; ++i) {
232        if (i) O << "|";
233        O << "<s" << i << ">";
234        if (EdgeSourceLabels) O << DOT::EscapeString((*EdgeSourceLabels)[i]);
235      }
236      O << "}}";
237    }
238    O << "\"];\n";
239  }
240
241  /// emitEdge - Output an edge from a simple node into the graph...
242  void emitEdge(const void *SrcNodeID, int SrcNodePort,
243                const void *DestNodeID, int DestNodePort,
244                const std::string &Attrs) {
245    if (SrcNodePort  > 64) return;             // Eminating from truncated part?
246    if (DestNodePort > 64) DestNodePort = 64;  // Targetting the truncated part?
247
248    O << "\tNode" << SrcNodeID;
249    if (SrcNodePort >= 0)
250      O << ":s" << SrcNodePort;
251    O << " -> Node" << DestNodeID;
252    if (DestNodePort >= 0 && DTraits.hasEdgeDestLabels())
253      O << ":d" << DestNodePort;
254
255    if (!Attrs.empty())
256      O << "[" << Attrs << "]";
257    O << ";\n";
258  }
259};
260
261template<typename GraphType>
262raw_ostream &WriteGraph(raw_ostream &O, const GraphType &G,
263                        bool ShortNames = false,
264                        const std::string &Name = "",
265                        const std::string &Title = "") {
266  // Start the graph emission process...
267  GraphWriter<GraphType> W(O, G, ShortNames);
268
269  // Output the header for the graph...
270  W.writeHeader(Title);
271
272  // Emit all of the nodes in the graph...
273  W.writeNodes();
274
275  // Output any customizations on the graph
276  DOTGraphTraits<GraphType>::addCustomGraphFeatures(G, W);
277
278  // Output the end of the graph
279  W.writeFooter();
280  return O;
281}
282
283template<typename GraphType>
284sys::Path WriteGraph(const GraphType &G, const std::string &Name,
285                     bool ShortNames = false, const std::string &Title = "") {
286  std::string ErrMsg;
287  sys::Path Filename = sys::Path::GetTemporaryDirectory(&ErrMsg);
288  if (Filename.isEmpty()) {
289    errs() << "Error: " << ErrMsg << "\n";
290    return Filename;
291  }
292  Filename.appendComponent(Name + ".dot");
293  if (Filename.makeUnique(true,&ErrMsg)) {
294    errs() << "Error: " << ErrMsg << "\n";
295    return sys::Path();
296  }
297
298  errs() << "Writing '" << Filename.str() << "'... ";
299
300  std::string ErrorInfo;
301  raw_fd_ostream O(Filename.c_str(), ErrorInfo);
302
303  if (ErrorInfo.empty()) {
304    WriteGraph(O, G, ShortNames, Name, Title);
305    errs() << " done. \n";
306  } else {
307    errs() << "error opening file '" << Filename.str() << "' for writing!\n";
308    Filename.clear();
309  }
310
311  return Filename;
312}
313
314/// ViewGraph - Emit a dot graph, run 'dot', run gv on the postscript file,
315/// then cleanup.  For use from the debugger.
316///
317template<typename GraphType>
318void ViewGraph(const GraphType &G, const std::string &Name,
319               bool ShortNames = false, const std::string &Title = "",
320               GraphProgram::Name Program = GraphProgram::DOT) {
321  sys::Path Filename = WriteGraph(G, Name, ShortNames, Title);
322
323  if (Filename.isEmpty())
324    return;
325
326  DisplayGraph(Filename, true, Program);
327}
328
329} // End llvm namespace
330
331#endif
332