Make generic algorithm less generic.

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 48 matching lines @@
 class JSONGraphNodeWriter : public NullNodeVisitor {
  public:
   JSONGraphNodeWriter(std::ostream& os, Zone* zone,
                       const Graph* graph)  // NOLINT
       : os_(os),
         graph_(graph),
         first_node_(true) {}
 
   void Print() { const_cast<Graph*>(graph_)->VisitNodeInputsFromEnd(this); }
 
-  GenericGraphVisit::Control Pre(Node* node);
+  void Pre(Node* node);
 
  private:
   std::ostream& os_;
   const Graph* const graph_;
   bool first_node_;
 
   DISALLOW_COPY_AND_ASSIGN(JSONGraphNodeWriter);
 };
 
 
-GenericGraphVisit::Control JSONGraphNodeWriter::Pre(Node* node) {
+void JSONGraphNodeWriter::Pre(Node* node) {
   if (first_node_) {
     first_node_ = false;
   } else {
     os_ << ",";
   }
   std::ostringstream label;
   label << *node->op();
   os_ << "{\"id\":" << node->id() << ",\"label\":\"" << Escaped(label, "\"")
       << "\"";
   IrOpcode::Value opcode = node->opcode();
   if (opcode == IrOpcode::kPhi || opcode == IrOpcode::kEffectPhi) {
     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]";
   }
   os_ << ",\"opcode\":\"" << IrOpcode::Mnemonic(node->opcode()) << "\"";
   os_ << ",\"control\":" << (NodeProperties::IsControl(node) ? "true"
                                                              : "false");
   os_ << "}";
-  return GenericGraphVisit::CONTINUE;
 }
 
 
 class JSONGraphEdgeWriter : public NullNodeVisitor {
  public:
   JSONGraphEdgeWriter(std::ostream& os, Zone* zone,
                       const Graph* graph)  // NOLINT
       : os_(os),
         graph_(graph),
         first_edge_(true) {}
@@ skipping 46 matching lines @@
   return os;
 }
 
 
 class GraphVisualizer : public NullNodeVisitor {
  public:
   GraphVisualizer(std::ostream& os, Zone* zone, const Graph* graph);  // NOLINT
 
   void Print();
 
-  GenericGraphVisit::Control Pre(Node* node);
+  void Pre(Node* node);
 
  private:
   void AnnotateNode(Node* node);
   void PrintEdge(Node::Edge edge);
 
   Zone* zone_;
   NodeSet all_nodes_;
   NodeSet white_nodes_;
   bool use_to_def_;
   std::ostream& os_;
   const Graph* const graph_;
 
   DISALLOW_COPY_AND_ASSIGN(GraphVisualizer);
 };
 
 
 static Node* GetControlCluster(Node* node) {
   if (OperatorProperties::IsBasicBlockBegin(node->op())) {
     return node;
   } else if (node->op()->ControlInputCount() == 1) {
     Node* control = NodeProperties::GetControlInput(node, 0);
     return OperatorProperties::IsBasicBlockBegin(control->op()) ? control
                                                                 : NULL;
   } else {
     return NULL;
   }
 }
 
 
-GenericGraphVisit::Control GraphVisualizer::Pre(Node* node) {
+void GraphVisualizer::Pre(Node* node) {
   if (all_nodes_.count(node) == 0) {
     Node* control_cluster = GetControlCluster(node);
     if (control_cluster != NULL) {
       os_ << "  subgraph cluster_BasicBlock" << control_cluster->id() << " {\n";
     }
     os_ << "  ID" << node->id() << " [\n";
     AnnotateNode(node);
     os_ << "  ]\n";
     if (control_cluster != NULL) os_ << "  }\n";
     all_nodes_.insert(node);
     if (use_to_def_) white_nodes_.insert(node);
   }
-  return GenericGraphVisit::CONTINUE;
 }
 
 
 static bool IsLikelyBackEdge(Node* from, int index, Node* to) {
   if (from->opcode() == IrOpcode::kPhi ||
       from->opcode() == IrOpcode::kEffectPhi) {
     Node* control = NodeProperties::GetControlInput(from, 0);
     return control->opcode() != IrOpcode::kMerge && control != to && index != 0;
   } else if (from->opcode() == IrOpcode::kLoop) {
     return index != 0;
@@ skipping 532 matching lines @@
 
 
 std::ostream& operator<<(std::ostream& os, const AsC1VAllocator& ac) {
   Zone tmp_zone(ac.allocator_->code()->zone()->isolate());
   GraphC1Visualizer(os, &tmp_zone).PrintAllocator(ac.phase_, ac.allocator_);
   return os;
 }
 }
 }
 }  // namespace v8::internal::compiler