SelectionDAGPrinter.cpp revision d23e0f81bc76902052e9198cad3a0d87a412a632 
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 "llvm/Constants.h"
15#include "llvm/Function.h"
16#include "llvm/Assembly/Writer.h"
17#include "llvm/CodeGen/SelectionDAG.h"
18#include "llvm/CodeGen/ScheduleDAG.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/Target/TargetRegisterInfo.h"
24#include "llvm/Target/TargetMachine.h"
25#include "llvm/Support/Debug.h"
26#include "llvm/Support/GraphWriter.h"
27#include "llvm/Support/raw_ostream.h"
28#include "llvm/ADT/DenseSet.h"
29#include "llvm/ADT/StringExtras.h"
30#include "llvm/Config/config.h"
31#include <fstream>
32using namespace llvm;
33
34namespace llvm {
35  template<>
36  struct DOTGraphTraits<SelectionDAG*> : public DefaultDOTGraphTraits {
37    static bool hasEdgeDestLabels() {
38      return true;
39    }
40
41    static unsigned numEdgeDestLabels(const void *Node) {
42      return ((const SDNode *) Node)->getNumValues();
43    }
44
45    static std::string getEdgeDestLabel(const void *Node, unsigned i) {
46      return ((const SDNode *) Node)->getValueType(i).getMVTString();
47    }
48
49    /// edgeTargetsEdgeSource - This method returns true if this outgoing edge
50    /// should actually target another edge source, not a node.  If this method is
51    /// implemented, getEdgeTarget should be implemented.
52    template<typename EdgeIter>
53    static bool edgeTargetsEdgeSource(const void *Node, EdgeIter I) {
54      return true;
55    }
56
57    /// getEdgeTarget - If edgeTargetsEdgeSource returns true, this method is
58    /// called to determine which outgoing edge of Node is the target of this
59    /// edge.
60    template<typename EdgeIter>
61    static EdgeIter getEdgeTarget(const void *Node, EdgeIter I) {
62      SDNode *TargetNode = *I;
63      SDNodeIterator NI = SDNodeIterator::begin(TargetNode);
64      std::advance(NI, I.getNode()->getOperand(I.getOperand()).getResNo());
65      return NI;
66    }
67
68    static std::string getGraphName(const SelectionDAG *G) {
69      return G->getMachineFunction().getFunction()->getName();
70    }
71
72    static bool renderGraphFromBottomUp() {
73      return true;
74    }
75
76    static bool hasNodeAddressLabel(const SDNode *Node,
77                                    const SelectionDAG *Graph) {
78      return true;
79    }
80
81    /// If you want to override the dot attributes printed for a particular
82    /// edge, override this method.
83    template<typename EdgeIter>
84    static std::string getEdgeAttributes(const void *Node, EdgeIter EI) {
85      SDValue Op = EI.getNode()->getOperand(EI.getOperand());
86      MVT VT = Op.getValueType();
87      if (VT == MVT::Flag)
88        return "color=red,style=bold";
89      else if (VT == MVT::Other)
90        return "color=blue,style=dashed";
91      return "";
92    }
93
94
95    static std::string getNodeLabel(const SDNode *Node,
96                                    const SelectionDAG *Graph);
97    static std::string getNodeAttributes(const SDNode *N,
98                                         const SelectionDAG *Graph) {
99#ifndef NDEBUG
100      const std::string &Attrs = Graph->getGraphAttrs(N);
101      if (!Attrs.empty()) {
102        if (Attrs.find("shape=") == std::string::npos)
103          return std::string("shape=Mrecord,") + Attrs;
104        else
105          return Attrs;
106      }
107#endif
108      return "shape=Mrecord";
109    }
110
111    static void addCustomGraphFeatures(SelectionDAG *G,
112                                       GraphWriter<SelectionDAG*> &GW) {
113      GW.emitSimpleNode(0, "plaintext=circle", "GraphRoot");
114      if (G->getRoot().getNode())
115        GW.emitEdge(0, -1, G->getRoot().getNode(), G->getRoot().getResNo(),
116                    "color=blue,style=dashed");
117    }
118  };
119}
120
121std::string DOTGraphTraits<SelectionDAG*>::getNodeLabel(const SDNode *Node,
122                                                        const SelectionDAG *G) {
123  std::string Op = Node->getOperationName(G);
124
125  if (const ConstantSDNode *CSDN = dyn_cast<ConstantSDNode>(Node)) {
126    Op += ": " + utostr(CSDN->getZExtValue());
127  } else if (const ConstantFPSDNode *CSDN = dyn_cast<ConstantFPSDNode>(Node)) {
128    Op += ": " + ftostr(CSDN->getValueAPF());
129  } else if (const GlobalAddressSDNode *GADN =
130             dyn_cast<GlobalAddressSDNode>(Node)) {
131    Op += ": " + GADN->getGlobal()->getName();
132    if (int64_t Offset = GADN->getOffset()) {
133      if (Offset > 0)
134        Op += "+" + itostr(Offset);
135      else
136        Op += itostr(Offset);
137    }
138  } else if (const FrameIndexSDNode *FIDN = dyn_cast<FrameIndexSDNode>(Node)) {
139    Op += " " + itostr(FIDN->getIndex());
140  } else if (const JumpTableSDNode *JTDN = dyn_cast<JumpTableSDNode>(Node)) {
141    Op += " " + itostr(JTDN->getIndex());
142  } else if (const ConstantPoolSDNode *CP = dyn_cast<ConstantPoolSDNode>(Node)){
143    if (CP->isMachineConstantPoolEntry()) {
144      Op += '<';
145      {
146        raw_string_ostream OSS(Op);
147        OSS << *CP->getMachineCPVal();
148      }
149      Op += '>';
150    } else {
151      if (ConstantFP *CFP = dyn_cast<ConstantFP>(CP->getConstVal()))
152        Op += "<" + ftostr(CFP->getValueAPF()) + ">";
153      else if (ConstantInt *CI = dyn_cast<ConstantInt>(CP->getConstVal()))
154        Op += "<" + utostr(CI->getZExtValue()) + ">";
155      else {
156        Op += '<';
157        {
158          raw_string_ostream OSS(Op);
159          WriteAsOperand(OSS, CP->getConstVal(), false);
160        }
161        Op += '>';
162      }
163    }
164    Op += " A=" + itostr(1 << CP->getAlignment());
165  } else if (const BasicBlockSDNode *BBDN = dyn_cast<BasicBlockSDNode>(Node)) {
166    Op = "BB: ";
167    const Value *LBB = (const Value*)BBDN->getBasicBlock()->getBasicBlock();
168    if (LBB)
169      Op += LBB->getName();
170    //Op += " " + (const void*)BBDN->getBasicBlock();
171  } else if (const RegisterSDNode *R = dyn_cast<RegisterSDNode>(Node)) {
172    if (G && R->getReg() != 0 &&
173        TargetRegisterInfo::isPhysicalRegister(R->getReg())) {
174      Op = Op + " " +
175        G->getTarget().getRegisterInfo()->getName(R->getReg());
176    } else {
177      Op += " #" + utostr(R->getReg());
178    }
179  } else if (const DbgStopPointSDNode *D = dyn_cast<DbgStopPointSDNode>(Node)) {
180    Op += ": " + D->getCompileUnit()->getFileName();
181    Op += ":" + utostr(D->getLine());
182    if (D->getColumn() != 0)
183      Op += ":" + utostr(D->getColumn());
184  } else if (const LabelSDNode *L = dyn_cast<LabelSDNode>(Node)) {
185    Op += ": LabelID=" + utostr(L->getLabelID());
186  } else if (const CallSDNode *C = dyn_cast<CallSDNode>(Node)) {
187    Op += ": CallingConv=" + utostr(C->getCallingConv());
188    if (C->isVarArg())
189      Op += ", isVarArg";
190    if (C->isTailCall())
191      Op += ", isTailCall";
192  } else if (const ExternalSymbolSDNode *ES =
193             dyn_cast<ExternalSymbolSDNode>(Node)) {
194    Op += "'" + std::string(ES->getSymbol()) + "'";
195  } else if (const SrcValueSDNode *M = dyn_cast<SrcValueSDNode>(Node)) {
196    if (M->getValue())
197      Op += "<" + M->getValue()->getName() + ">";
198    else
199      Op += "<null>";
200  } else if (const MemOperandSDNode *M = dyn_cast<MemOperandSDNode>(Node)) {
201    const Value *V = M->MO.getValue();
202    Op += '<';
203    if (!V) {
204      Op += "(unknown)";
205    } else if (isa<PseudoSourceValue>(V)) {
206      // PseudoSourceValues don't have names, so use their print method.
207      {
208        raw_string_ostream OSS(Op);
209        OSS << *M->MO.getValue();
210      }
211    } else {
212      Op += V->getName();
213    }
214    Op += '+' + itostr(M->MO.getOffset()) + '>';
215  } else if (const ARG_FLAGSSDNode *N = dyn_cast<ARG_FLAGSSDNode>(Node)) {
216    Op = Op + " AF=" + N->getArgFlags().getArgFlagsString();
217  } else if (const VTSDNode *N = dyn_cast<VTSDNode>(Node)) {
218    Op = Op + " VT=" + N->getVT().getMVTString();
219  } else if (const LoadSDNode *LD = dyn_cast<LoadSDNode>(Node)) {
220    bool doExt = true;
221    switch (LD->getExtensionType()) {
222    default: doExt = false; break;
223    case ISD::EXTLOAD:
224      Op = Op + "<anyext ";
225      break;
226    case ISD::SEXTLOAD:
227      Op = Op + " <sext ";
228      break;
229    case ISD::ZEXTLOAD:
230      Op = Op + " <zext ";
231      break;
232    }
233    if (doExt)
234      Op += LD->getMemoryVT().getMVTString() + ">";
235    if (LD->isVolatile())
236      Op += "<V>";
237    Op += LD->getIndexedModeName(LD->getAddressingMode());
238    if (LD->getAlignment() > 1)
239      Op += " A=" + utostr(LD->getAlignment());
240  } else if (const StoreSDNode *ST = dyn_cast<StoreSDNode>(Node)) {
241    if (ST->isTruncatingStore())
242      Op += "<trunc " + ST->getMemoryVT().getMVTString() + ">";
243    if (ST->isVolatile())
244      Op += "<V>";
245    Op += ST->getIndexedModeName(ST->getAddressingMode());
246    if (ST->getAlignment() > 1)
247      Op += " A=" + utostr(ST->getAlignment());
248  }
249
250#if 0
251  Op += " Id=" + itostr(Node->getNodeId());
252#endif
253
254  return Op;
255}
256
257
258/// viewGraph - Pop up a ghostview window with the reachable parts of the DAG
259/// rendered using 'dot'.
260///
261void SelectionDAG::viewGraph(const std::string &Title) {
262// This code is only for debugging!
263#ifndef NDEBUG
264  ViewGraph(this, "dag." + getMachineFunction().getFunction()->getName(),
265            Title);
266#else
267  cerr << "SelectionDAG::viewGraph is only available in debug builds on "
268       << "systems with Graphviz or gv!\n";
269#endif  // NDEBUG
270}
271
272// This overload is defined out-of-line here instead of just using a
273// default parameter because this is easiest for gdb to call.
274void SelectionDAG::viewGraph() {
275  viewGraph("");
276}
277
278/// clearGraphAttrs - Clear all previously defined node graph attributes.
279/// Intended to be used from a debugging tool (eg. gdb).
280void SelectionDAG::clearGraphAttrs() {
281#ifndef NDEBUG
282  NodeGraphAttrs.clear();
283#else
284  cerr << "SelectionDAG::clearGraphAttrs is only available in debug builds"
285       << " on systems with Graphviz or gv!\n";
286#endif
287}
288
289
290/// setGraphAttrs - Set graph attributes for a node. (eg. "color=red".)
291///
292void SelectionDAG::setGraphAttrs(const SDNode *N, const char *Attrs) {
293#ifndef NDEBUG
294  NodeGraphAttrs[N] = Attrs;
295#else
296  cerr << "SelectionDAG::setGraphAttrs is only available in debug builds"
297       << " on systems with Graphviz or gv!\n";
298#endif
299}
300
301
302/// getGraphAttrs - Get graph attributes for a node. (eg. "color=red".)
303/// Used from getNodeAttributes.
304const std::string SelectionDAG::getGraphAttrs(const SDNode *N) const {
305#ifndef NDEBUG
306  std::map<const SDNode *, std::string>::const_iterator I =
307    NodeGraphAttrs.find(N);
308
309  if (I != NodeGraphAttrs.end())
310    return I->second;
311  else
312    return "";
313#else
314  cerr << "SelectionDAG::getGraphAttrs is only available in debug builds"
315       << " on systems with Graphviz or gv!\n";
316  return std::string("");
317#endif
318}
319
320/// setGraphColor - Convenience for setting node color attribute.
321///
322void SelectionDAG::setGraphColor(const SDNode *N, const char *Color) {
323#ifndef NDEBUG
324  NodeGraphAttrs[N] = std::string("color=") + Color;
325#else
326  cerr << "SelectionDAG::setGraphColor is only available in debug builds"
327       << " on systems with Graphviz or gv!\n";
328#endif
329}
330
331/// setSubgraphColorHelper - Implement setSubgraphColor.  Return
332/// whether we truncated the search.
333///
334bool SelectionDAG::setSubgraphColorHelper(SDNode *N, const char *Color, DenseSet<SDNode *> &visited,
335                                          int level, bool &printed) {
336  bool hit_limit = false;
337
338#ifndef NDEBUG
339  if (level >= 20) {
340    if (!printed) {
341      printed = true;
342      DOUT << "setSubgraphColor hit max level\n";
343    }
344    return true;
345  }
346
347  unsigned oldSize = visited.size();
348  visited.insert(N);
349  if (visited.size() != oldSize) {
350    setGraphColor(N, Color);
351    for(SDNodeIterator i = SDNodeIterator::begin(N), iend = SDNodeIterator::end(N);
352        i != iend;
353        ++i) {
354      hit_limit = setSubgraphColorHelper(*i, Color, visited, level+1, printed) || hit_limit;
355    }
356  }
357#else
358  cerr << "SelectionDAG::setSubgraphColor is only available in debug builds"
359       << " on systems with Graphviz or gv!\n";
360#endif
361  return hit_limit;
362}
363
364/// setSubgraphColor - Convenience for setting subgraph color attribute.
365///
366void SelectionDAG::setSubgraphColor(SDNode *N, const char *Color) {
367#ifndef NDEBUG
368  DenseSet<SDNode *> visited;
369  bool printed = false;
370  if (setSubgraphColorHelper(N, Color, visited, 0, printed)) {
371    // Visually mark that we hit the limit
372    if (strcmp(Color, "red") == 0) {
373      setSubgraphColorHelper(N, "blue", visited, 0, printed);
374    }
375    else if (strcmp(Color, "yellow") == 0) {
376      setSubgraphColorHelper(N, "green", visited, 0, printed);
377    }
378  }
379
380#else
381  cerr << "SelectionDAG::setSubgraphColor is only available in debug builds"
382       << " on systems with Graphviz or gv!\n";
383#endif
384}
385
386namespace llvm {
387  template<>
388  struct DOTGraphTraits<ScheduleDAG*> : public DefaultDOTGraphTraits {
389    static std::string getGraphName(const ScheduleDAG *G) {
390      return DOTGraphTraits<SelectionDAG*>::getGraphName(G->DAG);
391    }
392
393    static bool renderGraphFromBottomUp() {
394      return true;
395    }
396
397    static bool hasNodeAddressLabel(const SUnit *Node,
398                                    const ScheduleDAG *Graph) {
399      return true;
400    }
401
402    /// If you want to override the dot attributes printed for a particular
403    /// edge, override this method.
404    template<typename EdgeIter>
405    static std::string getEdgeAttributes(const void *Node, EdgeIter EI) {
406      if (EI.isSpecialDep())
407        return "color=cyan,style=dashed";
408      if (EI.isCtrlDep())
409        return "color=blue,style=dashed";
410      return "";
411    }
412
413
414    static std::string getNodeLabel(const SUnit *Node,
415                                    const ScheduleDAG *Graph);
416    static std::string getNodeAttributes(const SUnit *N,
417                                         const ScheduleDAG *Graph) {
418      return "shape=Mrecord";
419    }
420
421    static void addCustomGraphFeatures(ScheduleDAG *G,
422                                       GraphWriter<ScheduleDAG*> &GW) {
423      GW.emitSimpleNode(0, "plaintext=circle", "GraphRoot");
424      const SDNode *N = G->DAG->getRoot().getNode();
425      if (N && N->getNodeId() != -1)
426        GW.emitEdge(0, -1, &G->SUnits[N->getNodeId()], -1,
427                    "color=blue,style=dashed");
428    }
429  };
430}
431
432std::string DOTGraphTraits<ScheduleDAG*>::getNodeLabel(const SUnit *SU,
433                                                       const ScheduleDAG *G) {
434  std::string Op;
435
436  if (!SU->getNode())
437    Op = "<CROSS RC COPY>";
438  else {
439    SmallVector<SDNode *, 4> FlaggedNodes;
440    for (SDNode *N = SU->getNode(); N; N = N->getFlaggedNode())
441      FlaggedNodes.push_back(N);
442    while (!FlaggedNodes.empty()) {
443      Op += DOTGraphTraits<SelectionDAG*>::getNodeLabel(FlaggedNodes.back(),
444                                                        G->DAG) + "\n";
445      FlaggedNodes.pop_back();
446    }
447  }
448
449  return Op;
450}
451
452
453/// viewGraph - Pop up a ghostview window with the reachable parts of the DAG
454/// rendered using 'dot'.
455///
456void ScheduleDAG::viewGraph() {
457// This code is only for debugging!
458#ifndef NDEBUG
459  ViewGraph(this, "dag." + MF->getFunction()->getName(),
460            "Scheduling-Units Graph for " + MF->getFunction()->getName() + ':' +
461            BB->getBasicBlock()->getName());
462#else
463  cerr << "ScheduleDAG::viewGraph is only available in debug builds on "
464       << "systems with Graphviz or gv!\n";
465#endif  // NDEBUG
466}
467