Improve graph visualizer for deoptimization and readablity.

src/compiler/graph-visualizer.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/graph-visualizer.h"
 
 #include "src/compiler/generic-algorithm.h"
 #include "src/compiler/generic-node.h"
 #include "src/compiler/generic-node-inl.h"
 #include "src/compiler/graph.h"
@@ skipping 15 matching lines @@
  public:
   GraphVisualizer(OStream& os, Zone* zone, const Graph* graph);  // NOLINT
 
   void Print();
 
   GenericGraphVisit::Control Pre(Node* node);
   GenericGraphVisit::Control PreEdge(Node* from, int index, Node* to);
 
  private:
   void AnnotateNode(Node* node);
-  void PrintEdge(Node* from, int index, Node* to);
+  void PrintEdge(Node::Edge edge);
 
   Zone* zone_;
   NodeSet all_nodes_;
   NodeSet white_nodes_;
   bool use_to_def_;
   OStream& os_;
   const Graph* const graph_;
 
   DISALLOW_COPY_AND_ASSIGN(GraphVisualizer);
 };
@@ skipping 114 matching lines @@
   for (int j = OperatorProperties::GetValueInputCount(node->op()); j > 0;
        ++i, j--) {
     os_ << "|<I" << i.index() << ">#" << (*i)->id();
   }
   for (int j = OperatorProperties::GetContextInputCount(node->op()); j > 0;
        ++i, j--) {
     os_ << "|<I" << i.index() << ">X #" << (*i)->id();
   }
   for (int j = OperatorProperties::GetFrameStateInputCount(node->op()); j > 0;
        ++i, j--) {
-    os_ << "|<I" << i.index() << ">X #" << (*i)->id();
+    os_ << "|<I" << i.index() << ">F #" << (*i)->id();
   }
   for (int j = OperatorProperties::GetEffectInputCount(node->op()); j > 0;
        ++i, j--) {
     os_ << "|<I" << i.index() << ">E #" << (*i)->id();
   }
 
   if (!use_to_def_ || OperatorProperties::IsBasicBlockBegin(node->op()) ||
       GetControlCluster(node) == NULL) {
     for (int j = OperatorProperties::GetControlInputCount(node->op()); j > 0;
          ++i, j--) {
       os_ << "|<I" << i.index() << ">C #" << (*i)->id();
     }
   }
   os_ << "}";
 
   if (FLAG_trace_turbo_types && !NodeProperties::IsControl(node)) {
     Bounds bounds = NodeProperties::GetBounds(node);
     OStringStream upper;
     bounds.upper->PrintTo(upper);
     OStringStream lower;
     bounds.lower->PrintTo(lower);
     os_ << "|" << Escaped(upper) << "|" << Escaped(lower);
   }
   os_ << "}\"\n";
 }
 
 
-void GraphVisualizer::PrintEdge(Node* from, int index, Node* to) {
+void GraphVisualizer::PrintEdge(Node::Edge edge) {
+  Node* from = edge.from();
+  int index = edge.index();
+  Node* to = edge.to();
   bool unconstrained = IsLikelyBackEdge(from, index, to);
   os_ << "  ID" << from->id();
   if (all_nodes_.count(to) == 0) {
     os_ << ":I" << index << ":n -> DEAD_INPUT";
   } else if (OperatorProperties::IsBasicBlockBegin(from->op()) ||
              GetControlCluster(from) == NULL ||
              (OperatorProperties::GetControlInputCount(from->op()) > 0 &&
               NodeProperties::GetControlInput(from) != to)) {
-    os_ << ":I" << index << ":n -> ID" << to->id() << ":s";
-    if (unconstrained) os_ << " [constraint=false,style=dotted]";
+    os_ << ":I" << index << ":n -> ID" << to->id() << ":s"
+        << "[" << (unconstrained ? "constraint=false" : "")
+        << (NodeProperties::IsControlEdge(edge) ? "style=bold" : "")
+        << (NodeProperties::IsEffectEdge(edge) ? "style=dotted" : "")
+        << (NodeProperties::IsContextEdge(edge) ? "style=dashed" : "") << "]";
   } else {
     os_ << " -> ID" << to->id() << ":s [color=transparent"
-        << (unconstrained ? ", constraint=false" : "") << "]";
+        << (unconstrained ? ", constraint=false" : "")
+        << (NodeProperties::IsControlEdge(edge) ? ", style=dashed" : "") << "]";
   }
   os_ << "\n";
 }
 
 
 void GraphVisualizer::Print() {
   os_ << "digraph D {\n"
       << "  node [fontsize=8,height=0.25]\n"
       << "  rankdir=\"BT\"\n"
+      << "  ranksep=\"1.2 equally\"\n"
+      << "  overlap=\"false\"\n"
+      << "  splines=\"true\"\n"
+      << "  concentrate=\"true\"\n"
       << "  \n";
 
   // Make sure all nodes have been output before writing out the edges.
   use_to_def_ = true;
   // TODO(svenpanne) Remove the need for the const_casts.
   const_cast<Graph*>(graph_)->VisitNodeInputsFromEnd(this);
   white_nodes_.insert(const_cast<Graph*>(graph_)->start());
 
   // Visit all uses of white nodes.
   use_to_def_ = false;
   GenericGraphVisit::Visit<GraphVisualizer, NodeUseIterationTraits<Node> >(
       const_cast<Graph*>(graph_), zone_, white_nodes_.begin(),
       white_nodes_.end(), this);
 
   os_ << "  DEAD_INPUT [\n"
       << "    style=\"filled\" \n"
       << "    fillcolor=\"" DEAD_COLOR "\"\n"
       << "  ]\n"
       << "\n";
 
   // With all the nodes written, add the edges.
   for (NodeSetIter i = all_nodes_.begin(); i != all_nodes_.end(); ++i) {
     Node::Inputs inputs = (*i)->inputs();
     for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
          ++iter) {
-      PrintEdge(iter.edge().from(), iter.edge().index(), iter.edge().to());
+      PrintEdge(iter.edge());
     }
   }
   os_ << "}\n";
 }
 
 
 GraphVisualizer::GraphVisualizer(OStream& os, Zone* zone,
                                  const Graph* graph)  // NOLINT
     : zone_(zone),
       all_nodes_(NodeSet::key_compare(), NodeSet::allocator_type(zone)),
       white_nodes_(NodeSet::key_compare(), NodeSet::allocator_type(zone)),
       use_to_def_(true),
       os_(os),
       graph_(graph) {}
 
 
 OStream& operator<<(OStream& os, const AsDOT& ad) {
   Zone tmp_zone(ad.graph.zone()->isolate());
   GraphVisualizer(os, &tmp_zone, &ad.graph).Print();
   return os;
 }
 }
 }
 }  // namespace v8::internal::compiler