LCOV - code coverage report
Current view: top level - lib/CodeGen/SelectionDAG - SelectionDAGPrinter.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 0 62 0.0 %
Date: 2017-09-14 15:23:50 Functions: 0 12 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13