SelectionDAGPrinter.cpp revision ab01069fcdb1fed655cf0ca851400a104e4b46d1 
1//===-- SelectionDAGPrinter.cpp - Implement SelectionDAG::viewGraph() -----===//
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 implements the SelectionDAG::viewGraph method.
11//
12//===----------------------------------------------------------------------===//
13
14#include "ScheduleDAGSDNodes.h"
15#include "llvm/Constants.h"
16#include "llvm/Function.h"
17#include "llvm/Assembly/Writer.h"
18#include "llvm/CodeGen/SelectionDAG.h"
19#include "llvm/CodeGen/MachineConstantPool.h"
20#include "llvm/CodeGen/MachineFunction.h"
21#include "llvm/CodeGen/MachineModuleInfo.h"
22#include "llvm/CodeGen/PseudoSourceValue.h"
23#include "llvm/Analysis/DebugInfo.h"
24#include "llvm/Target/TargetRegisterInfo.h"
25#include "llvm/Target/TargetMachine.h"
26#include "llvm/Support/Debug.h"
27#include "llvm/Support/GraphWriter.h"
28#include "llvm/Support/raw_ostream.h"
29#include "llvm/ADT/DenseSet.h"
30#include "llvm/ADT/StringExtras.h"
31#include "llvm/Config/config.h"
32#include <fstream>
33using namespace llvm;
34
35namespace llvm {
36  template<>
37  struct DOTGraphTraits<SelectionDAG*> : public DefaultDOTGraphTraits {
38
39    DOTGraphTraits (bool isSimple=false) : DefaultDOTGraphTraits(isSimple) {}
40
41    static bool hasEdgeDestLabels() {
42      return true;
43    }
44
45    static unsigned numEdgeDestLabels(const void *Node) {
46      return ((const SDNode *) Node)->getNumValues();
47    }
48
49    static std::string getEdgeDestLabel(const void *Node, unsigned i) {
50      return ((const SDNode *) Node)->getValueType(i).getEVTString();
51    }
52
53    /// edgeTargetsEdgeSource - This method returns true if this outgoing edge
54    /// should actually target another edge source, not a node.  If this method
55    /// is implemented, getEdgeTarget should be implemented.
56    template<typename EdgeIter>
57    static bool edgeTargetsEdgeSource(const void *Node, EdgeIter I) {
58      return true;
59    }
60
61    /// getEdgeTarget - If edgeTargetsEdgeSource returns true, this method is
62    /// called to determine which outgoing edge of Node is the target of this
63    /// edge.
64    template<typename EdgeIter>
65    static EdgeIter getEdgeTarget(const void *Node, EdgeIter I) {
66      SDNode *TargetNode = *I;
67      SDNodeIterator NI = SDNodeIterator::begin(TargetNode);
68      std::advance(NI, I.getNode()->getOperand(I.getOperand()).getResNo());
69      return NI;
70    }
71
72    static std::string getGraphName(const SelectionDAG *G) {
73      return G->getMachineFunction().getFunction()->getName();
74    }
75
76    static bool renderGraphFromBottomUp() {
77      return true;
78    }
79
80    static bool hasNodeAddressLabel(const SDNode *Node,
81                                    const SelectionDAG *Graph) {
82      return true;
83    }
84
85    /// If you want to override the dot attributes printed for a particular
86    /// edge, override this method.
87    template<typename EdgeIter>
88    static std::string getEdgeAttributes(const void *Node, EdgeIter EI) {
89      SDValue Op = EI.getNode()->getOperand(EI.getOperand());
90      EVT VT = Op.getValueType();
91      if (VT == MVT::Flag)
92        return "color=red,style=bold";
93      else if (VT == MVT::Other)
94        return "color=blue,style=dashed";
95      return "";
96    }
97
98
99    static std::string getSimpleNodeLabel(const SDNode *Node,
100                                          const SelectionDAG *G) {
101      std::string Result = Node->getOperationName(G);
102      {
103        raw_string_ostream OS(Result);
104        Node->print_details(OS, G);
105      }
106      return Result;
107    }
108    std::string getNodeLabel(const SDNode *Node, const SelectionDAG *Graph);
109    static std::string getNodeAttributes(const SDNode *N,
110                                         const SelectionDAG *Graph) {
111#ifndef NDEBUG
112      const std::string &Attrs = Graph->getGraphAttrs(N);
113      if (!Attrs.empty()) {
114        if (Attrs.find("shape=") == std::string::npos)
115          return std::string("shape=Mrecord,") + Attrs;
116        else
117          return Attrs;
118      }
119#endif
120      return "shape=Mrecord";
121    }
122
123    static void addCustomGraphFeatures(SelectionDAG *G,
124                                       GraphWriter<SelectionDAG*> &GW) {
125      GW.emitSimpleNode(0, "plaintext=circle", "GraphRoot");
126      if (G->getRoot().getNode())
127        GW.emitEdge(0, -1, G->getRoot().getNode(), G->getRoot().getResNo(),
128                    "color=blue,style=dashed");
129    }
130  };
131}
132
133std::string DOTGraphTraits<SelectionDAG*>::getNodeLabel(const SDNode *Node,
134                                                        const SelectionDAG *G) {
135  return DOTGraphTraits<SelectionDAG*>::getSimpleNodeLabel (Node, G);
136}
137
138
139/// viewGraph - Pop up a ghostview window with the reachable parts of the DAG
140/// rendered using 'dot'.
141///
142void SelectionDAG::viewGraph(const std::string &Title) {
143// This code is only for debugging!
144#ifndef NDEBUG
145  ViewGraph(this, "dag." + getMachineFunction().getFunction()->getNameStr(),
146            false, Title);
147#else
148  errs() << "SelectionDAG::viewGraph is only available in debug builds on "
149         << "systems with Graphviz or gv!\n";
150#endif  // NDEBUG
151}
152
153// This overload is defined out-of-line here instead of just using a
154// default parameter because this is easiest for gdb to call.
155void SelectionDAG::viewGraph() {
156  viewGraph("");
157}
158
159/// clearGraphAttrs - Clear all previously defined node graph attributes.
160/// Intended to be used from a debugging tool (eg. gdb).
161void SelectionDAG::clearGraphAttrs() {
162#ifndef NDEBUG
163  NodeGraphAttrs.clear();
164#else
165  errs() << "SelectionDAG::clearGraphAttrs is only available in debug builds"
166         << " on systems with Graphviz or gv!\n";
167#endif
168}
169
170
171/// setGraphAttrs - Set graph attributes for a node. (eg. "color=red".)
172///
173void SelectionDAG::setGraphAttrs(const SDNode *N, const char *Attrs) {
174#ifndef NDEBUG
175  NodeGraphAttrs[N] = Attrs;
176#else
177  errs() << "SelectionDAG::setGraphAttrs is only available in debug builds"
178         << " on systems with Graphviz or gv!\n";
179#endif
180}
181
182
183/// getGraphAttrs - Get graph attributes for a node. (eg. "color=red".)
184/// Used from getNodeAttributes.
185const std::string SelectionDAG::getGraphAttrs(const SDNode *N) const {
186#ifndef NDEBUG
187  std::map<const SDNode *, std::string>::const_iterator I =
188    NodeGraphAttrs.find(N);
189
190  if (I != NodeGraphAttrs.end())
191    return I->second;
192  else
193    return "";
194#else
195  errs() << "SelectionDAG::getGraphAttrs is only available in debug builds"
196         << " on systems with Graphviz or gv!\n";
197  return std::string("");
198#endif
199}
200
201/// setGraphColor - Convenience for setting node color attribute.
202///
203void SelectionDAG::setGraphColor(const SDNode *N, const char *Color) {
204#ifndef NDEBUG
205  NodeGraphAttrs[N] = std::string("color=") + Color;
206#else
207  errs() << "SelectionDAG::setGraphColor is only available in debug builds"
208         << " on systems with Graphviz or gv!\n";
209#endif
210}
211
212/// setSubgraphColorHelper - Implement setSubgraphColor.  Return
213/// whether we truncated the search.
214///
215bool SelectionDAG::setSubgraphColorHelper(SDNode *N, const char *Color, DenseSet<SDNode *> &visited,
216                                          int level, bool &printed) {
217  bool hit_limit = false;
218
219#ifndef NDEBUG
220  if (level >= 20) {
221    if (!printed) {
222      printed = true;
223      DEBUG(errs() << "setSubgraphColor hit max level\n");
224    }
225    return true;
226  }
227
228  unsigned oldSize = visited.size();
229  visited.insert(N);
230  if (visited.size() != oldSize) {
231    setGraphColor(N, Color);
232    for(SDNodeIterator i = SDNodeIterator::begin(N), iend = SDNodeIterator::end(N);
233        i != iend;
234        ++i) {
235      hit_limit = setSubgraphColorHelper(*i, Color, visited, level+1, printed) || hit_limit;
236    }
237  }
238#else
239  errs() << "SelectionDAG::setSubgraphColor is only available in debug builds"
240         << " on systems with Graphviz or gv!\n";
241#endif
242  return hit_limit;
243}
244
245/// setSubgraphColor - Convenience for setting subgraph color attribute.
246///
247void SelectionDAG::setSubgraphColor(SDNode *N, const char *Color) {
248#ifndef NDEBUG
249  DenseSet<SDNode *> visited;
250  bool printed = false;
251  if (setSubgraphColorHelper(N, Color, visited, 0, printed)) {
252    // Visually mark that we hit the limit
253    if (strcmp(Color, "red") == 0) {
254      setSubgraphColorHelper(N, "blue", visited, 0, printed);
255    }
256    else if (strcmp(Color, "yellow") == 0) {
257      setSubgraphColorHelper(N, "green", visited, 0, printed);
258    }
259  }
260
261#else
262  errs() << "SelectionDAG::setSubgraphColor is only available in debug builds"
263         << " on systems with Graphviz or gv!\n";
264#endif
265}
266
267std::string ScheduleDAGSDNodes::getGraphNodeLabel(const SUnit *SU) const {
268  std::string s;
269  raw_string_ostream O(s);
270  O << "SU(" << SU->NodeNum << "): ";
271  if (SU->getNode()) {
272    SmallVector<SDNode *, 4> FlaggedNodes;
273    for (SDNode *N = SU->getNode(); N; N = N->getFlaggedNode())
274      FlaggedNodes.push_back(N);
275    while (!FlaggedNodes.empty()) {
276      O << DOTGraphTraits<SelectionDAG*>
277	     ::getSimpleNodeLabel(FlaggedNodes.back(), DAG);
278      FlaggedNodes.pop_back();
279      if (!FlaggedNodes.empty())
280        O << "\n    ";
281    }
282  } else {
283    O << "CROSS RC COPY";
284  }
285  return O.str();
286}
287
288void ScheduleDAGSDNodes::getCustomGraphFeatures(GraphWriter<ScheduleDAG*> &GW) const {
289  if (DAG) {
290    // Draw a special "GraphRoot" node to indicate the root of the graph.
291    GW.emitSimpleNode(0, "plaintext=circle", "GraphRoot");
292    const SDNode *N = DAG->getRoot().getNode();
293    if (N && N->getNodeId() != -1)
294      GW.emitEdge(0, -1, &SUnits[N->getNodeId()], -1,
295                  "color=blue,style=dashed");
296  }
297}
298