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 using namespace llvm;
33
34 namespace llvm {
35 template<>
36 struct DOTGraphTraits<SelectionDAG*> : public DefaultDOTGraphTraits {
37
DOTGraphTraitsllvm::DOTGraphTraits38 explicit DOTGraphTraits(bool isSimple=false) :
39 DefaultDOTGraphTraits(isSimple) {}
40
hasEdgeDestLabelsllvm::DOTGraphTraits41 static bool hasEdgeDestLabels() {
42 return true;
43 }
44
numEdgeDestLabelsllvm::DOTGraphTraits45 static unsigned numEdgeDestLabels(const void *Node) {
46 return ((const SDNode *) Node)->getNumValues();
47 }
48
getEdgeDestLabelllvm::DOTGraphTraits49 static std::string getEdgeDestLabel(const void *Node, unsigned i) {
50 return ((const SDNode *) Node)->getValueType(i).getEVTString();
51 }
52
53 template<typename EdgeIter>
getEdgeSourceLabelllvm::DOTGraphTraits54 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>
edgeTargetsEdgeSourcellvm::DOTGraphTraits62 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>
getEdgeTargetllvm::DOTGraphTraits70 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
getGraphNamellvm::DOTGraphTraits77 static std::string getGraphName(const SelectionDAG *G) {
78 return G->getMachineFunction().getFunction()->getName();
79 }
80
renderGraphFromBottomUpllvm::DOTGraphTraits81 static bool renderGraphFromBottomUp() {
82 return true;
83 }
84
hasNodeAddressLabelllvm::DOTGraphTraits85 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>
getEdgeAttributesllvm::DOTGraphTraits93 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
getSimpleNodeLabelllvm::DOTGraphTraits104 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);
getNodeAttributesllvm::DOTGraphTraits114 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
addCustomGraphFeaturesllvm::DOTGraphTraits128 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
getNodeLabel(const SDNode * Node,const SelectionDAG * G)138 std::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 ///
viewGraph(const std::string & Title)147 void 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.
viewGraph()160 void 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).
clearGraphAttrs()166 void 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 ///
setGraphAttrs(const SDNode * N,const char * Attrs)178 void 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.
getGraphAttrs(const SDNode * N) const190 const 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 ///
setGraphColor(const SDNode * N,const char * Color)208 void 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 ///
setSubgraphColorHelper(SDNode * N,const char * Color,DenseSet<SDNode * > & visited,int level,bool & printed)220 bool 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 ///
setSubgraphColor(SDNode * N,const char * Color)252 void 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
getGraphNodeLabel(const SUnit * SU) const271 std::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
getCustomGraphFeatures(GraphWriter<ScheduleDAG * > & GW) const292 void 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