lib/CodeGen/SelectionDAG/SelectionDAGPrinter.cpp

   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
  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
 139 std::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 ///
 148 void 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.
 161 void 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).
 167 void 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 ///
 179 void 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.
 191 const 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 ///
 209 void 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 ///
 221 bool 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 ///
 253 void 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
 272 std::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
 293 void 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 }