Allow use of phase-local zone in GenericGraphVisit.

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"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/ostreams.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 #define DEAD_COLOR "#999999"
 
 class GraphVisualizer : public NullNodeVisitor {
  public:
-  GraphVisualizer(OStream& os, const Graph* graph);  // NOLINT
+  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);
 
+  Zone* zone_;
   NodeSet all_nodes_;
   NodeSet white_nodes_;
   bool use_to_def_;
   OStream& os_;
   const Graph* const graph_;
 
   DISALLOW_COPY_AND_ASSIGN(GraphVisualizer);
 };
 
 
@@ skipping 170 matching lines @@
 
   // 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_), white_nodes_.begin(), white_nodes_.end(),
-      this);
+      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());
     }
   }
   os_ << "}\n";
 }
 
 
-GraphVisualizer::GraphVisualizer(OStream& os, const Graph* graph)  // NOLINT
-    : all_nodes_(NodeSet::key_compare(),
-                 NodeSet::allocator_type(graph->zone())),
-      white_nodes_(NodeSet::key_compare(),
-                   NodeSet::allocator_type(graph->zone())),
+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) {
-  GraphVisualizer(os, &ad.graph).Print();
+  Zone tmp_zone(ad.graph.zone()->isolate());
+  GraphVisualizer(os, &tmp_zone, &ad.graph).Print();
   return os;
 }
 }
 }
 }  // namespace v8::internal::compiler