[turbofan] Improve JSON output

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 <sstream>
 #include <string>
 
 #include "src/code-stubs.h"
@@ skipping 42 matching lines @@
     }
     return false;
   }
 
   const std::string str_;
   const char* const escaped_chars_;
 };
 
 class JSONGraphNodeWriter {
  public:
-  JSONGraphNodeWriter(std::ostream& os, Zone* zone, const Graph* graph)
-      : os_(os), all_(zone, graph), first_node_(true) {}
+  JSONGraphNodeWriter(std::ostream& os, Zone* zone, const Graph* graph,
+                      const SourcePositionTable* positions)
+      : os_(os), all_(zone, graph), positions_(positions), first_node_(true) {}
 
   void Print() {
     for (Node* const node : all_.live) PrintNode(node);
+    os_ << "\n";
   }
 
   void PrintNode(Node* node) {
     if (first_node_) {
       first_node_ = false;
     } else {
-      os_ << ",";
+      os_ << ",\n";
     }
     std::ostringstream label;
     label << *node->op();
     os_ << "{\"id\":" << SafeId(node) << ",\"label\":\"" << Escaped(label, "\"")
         << "\"";
     IrOpcode::Value opcode = node->opcode();
     if (IrOpcode::IsPhiOpcode(opcode)) {
       os_ << ",\"rankInputs\":[0," << NodeProperties::FirstControlIndex(node)
           << "]";
       os_ << ",\"rankWithInput\":[" << NodeProperties::FirstControlIndex(node)
           << "]";
     } else if (opcode == IrOpcode::kIfTrue || opcode == IrOpcode::kIfFalse ||
                opcode == IrOpcode::kLoop) {
       os_ << ",\"rankInputs\":[" << NodeProperties::FirstControlIndex(node)
           << "]";
     }
     if (opcode == IrOpcode::kBranch) {
       os_ << ",\"rankInputs\":[0]";
     }
+    SourcePosition position = positions_->GetSourcePosition(node);
+    if (!position.IsUnknown()) {
+      DCHECK(!position.IsInvalid());
+      os_ << ",\"pos\":" << position.raw();
+    }
     os_ << ",\"opcode\":\"" << IrOpcode::Mnemonic(node->opcode()) << "\"";
     os_ << ",\"control\":" << (NodeProperties::IsControl(node) ? "true"
                                                                : "false");
     os_ << "}";
   }
 
  private:
   std::ostream& os_;
   AllNodes all_;
+  const SourcePositionTable* positions_;
   bool first_node_;
 
   DISALLOW_COPY_AND_ASSIGN(JSONGraphNodeWriter);
 };
 
 
 class JSONGraphEdgeWriter {
  public:
   JSONGraphEdgeWriter(std::ostream& os, Zone* zone, const Graph* graph)
       : os_(os), all_(zone, graph), first_edge_(true) {}
 
   void Print() {
     for (Node* const node : all_.live) PrintEdges(node);
+    os_ << "\n";
   }
 
   void PrintEdges(Node* node) {
     for (int i = 0; i < node->InputCount(); i++) {
       Node* input = node->InputAt(i);
       if (input == NULL) continue;
       PrintEdge(node, i, input);
     }
   }
 
   void PrintEdge(Node* from, int index, Node* to) {
     if (first_edge_) {
       first_edge_ = false;
     } else {
-      os_ << ",";
+      os_ << ",\n";
     }
     const char* edge_type = NULL;
     if (index < NodeProperties::FirstValueIndex(from)) {
       edge_type = "unknown";
     } else if (index < NodeProperties::FirstContextIndex(from)) {
       edge_type = "value";
     } else if (index < NodeProperties::FirstFrameStateIndex(from)) {
       edge_type = "context";
     } else if (index < NodeProperties::FirstEffectIndex(from)) {
       edge_type = "frame-state";
@@ skipping 10 matching lines @@
   std::ostream& os_;
   AllNodes all_;
   bool first_edge_;
 
   DISALLOW_COPY_AND_ASSIGN(JSONGraphEdgeWriter);
 };
 
 
 std::ostream& operator<<(std::ostream& os, const AsJSON& ad) {
   Zone tmp_zone;
-  os << "{\"nodes\":[";
-  JSONGraphNodeWriter(os, &tmp_zone, &ad.graph).Print();
-  os << "],\"edges\":[";
+  os << "{\n\"nodes\":[";
+  JSONGraphNodeWriter(os, &tmp_zone, &ad.graph, ad.positions).Print();
+  os << "],\n\"edges\":[";
   JSONGraphEdgeWriter(os, &tmp_zone, &ad.graph).Print();
   os << "]}";
   return os;
 }
 
 
 class GraphVisualizer {
  public:
   GraphVisualizer(std::ostream& os, Zone* zone, const Graph* graph)
       : all_(zone, graph), os_(os) {}
@@ skipping 596 matching lines @@
         os << "#" << SafeId(i) << ":" << SafeMnemonic(i);
       }
       os << ")" << std::endl;
     }
   }
   return os;
 }
 }
 }
 }  // namespace v8::internal::compiler