Remove unused return values from PreEdge visitor.

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/compiler/generic-algorithm.h"
@@ skipping 100 matching lines @@
 class JSONGraphEdgeWriter : public NullNodeVisitor {
  public:
   JSONGraphEdgeWriter(std::ostream& os, Zone* zone,
                       const Graph* graph)  // NOLINT
       : os_(os),
         graph_(graph),
         first_edge_(true) {}
 
   void Print() { const_cast<Graph*>(graph_)->VisitNodeInputsFromEnd(this); }
 
-  GenericGraphVisit::Control PreEdge(Node* from, int index, Node* to);
+  void PreEdge(Node* from, int index, Node* to);
 
  private:
   std::ostream& os_;
   const Graph* const graph_;
   bool first_edge_;
 
   DISALLOW_COPY_AND_ASSIGN(JSONGraphEdgeWriter);
 };
 
 
-GenericGraphVisit::Control JSONGraphEdgeWriter::PreEdge(Node* from, int index,
-                                                        Node* to) {
+void JSONGraphEdgeWriter::PreEdge(Node* from, int index, Node* to) {
   if (first_edge_) {
     first_edge_ = false;
   } else {
     os_ << ",";
   }
   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";
   } else if (index < NodeProperties::FirstControlIndex(from)) {
     edge_type = "effect";
   } else {
     edge_type = "control";
   }
   os_ << "{\"source\":" << to->id() << ",\"target\":" << from->id()
       << ",\"index\":" << index << ",\"type\":\"" << edge_type << "\"}";
-  return GenericGraphVisit::CONTINUE;
 }
 
 
 std::ostream& operator<<(std::ostream& os, const AsJSON& ad) {
   Zone tmp_zone(ad.graph.zone()->isolate());
   os << "{\"nodes\":[";
   JSONGraphNodeWriter(os, &tmp_zone, &ad.graph).Print();
   os << "],\"edges\":[";
   JSONGraphEdgeWriter(os, &tmp_zone, &ad.graph).Print();
   os << "]}";
   return os;
 }
 
 
 class GraphVisualizer : public NullNodeVisitor {
  public:
   GraphVisualizer(std::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::Edge edge);
 
   Zone* zone_;
   NodeSet all_nodes_;
   NodeSet white_nodes_;
   bool use_to_def_;
   std::ostream& os_;
@@ skipping 26 matching lines @@
     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;
 }
 
 
-GenericGraphVisit::Control GraphVisualizer::PreEdge(Node* from, int index,
-                                                    Node* to) {
-  if (use_to_def_) return GenericGraphVisit::CONTINUE;
-  // When going from def to use, only consider white -> other edges, which are
-  // the dead nodes that use live nodes. We're probably not interested in
-  // dead nodes that only use other dead nodes.
-  if (white_nodes_.count(from) > 0) return GenericGraphVisit::CONTINUE;
-  return GenericGraphVisit::SKIP;
-}
-
-
 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;
   } else {
     return false;
   }
@@ skipping 536 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