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