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