[turbofan] split register allocator into little pieces

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 389 matching lines @@
 
 
 class GraphC1Visualizer {
  public:
   GraphC1Visualizer(std::ostream& os, Zone* zone);  // NOLINT
 
   void PrintCompilation(const CompilationInfo* info);
   void PrintSchedule(const char* phase, const Schedule* schedule,
                      const SourcePositionTable* positions,
                      const InstructionSequence* instructions);
-  void PrintAllocator(const char* phase, const RegisterAllocator* allocator);
+  void PrintLiveRanges(const char* phase,
+                       const LiveRangeBuilder* live_range_builder);
   Zone* zone() const { return zone_; }
 
  private:
   void PrintIndent();
   void PrintStringProperty(const char* name, const char* value);
   void PrintLongProperty(const char* name, int64_t value);
   void PrintIntProperty(const char* name, int value);
   void PrintBlockProperty(const char* name, int rpo_number);
   void PrintNodeId(Node* n);
   void PrintNode(Node* n);
@@ skipping 265 matching lines @@
         PrintIndent();
         PrintableInstruction printable = {RegisterConfiguration::ArchDefault(),
                                           instructions->InstructionAt(j)};
         os_ << j << " " << printable << " <|@\n";
       }
     }
   }
 }
 
 
-void GraphC1Visualizer::PrintAllocator(const char* phase,
-                                       const RegisterAllocator* allocator) {
+void GraphC1Visualizer::PrintLiveRanges(
+    const char* phase, const LiveRangeBuilder* live_range_builder) {
   Tag tag(this, "intervals");
   PrintStringProperty("name", phase);
 
-  for (auto range : allocator->fixed_double_live_ranges()) {
+  for (auto range : live_range_builder->fixed_double_live_ranges()) {
     PrintLiveRange(range, "fixed");
   }
 
-  for (auto range : allocator->fixed_live_ranges()) {
+  for (auto range : live_range_builder->fixed_live_ranges()) {
     PrintLiveRange(range, "fixed");
   }
 
-  for (auto range : allocator->live_ranges()) {
+  for (auto range : live_range_builder->live_ranges()) {
     PrintLiveRange(range, "object");
   }
 }
 
 
 void GraphC1Visualizer::PrintLiveRange(LiveRange* range, const char* type) {
   if (range != NULL && !range->IsEmpty()) {
     PrintIndent();
     os_ << range->id() << " " << type;
     if (range->HasRegisterAssigned()) {
@@ skipping 64 matching lines @@
 
 
 std::ostream& operator<<(std::ostream& os, const AsC1V& ac) {
   Zone tmp_zone;
   GraphC1Visualizer(os, &tmp_zone)
       .PrintSchedule(ac.phase_, ac.schedule_, ac.positions_, ac.instructions_);
   return os;
 }
 
 
-std::ostream& operator<<(std::ostream& os, const AsC1VAllocator& ac) {
+std::ostream& operator<<(std::ostream& os, const AsC1VLiveRangeBuilder& ac) {
   Zone tmp_zone;
-  GraphC1Visualizer(os, &tmp_zone).PrintAllocator(ac.phase_, ac.allocator_);
+  GraphC1Visualizer(os, &tmp_zone)
+      .PrintLiveRanges(ac.phase_, ac.live_range_builder_);
   return os;
 }
 
 const int kUnvisited = 0;
 const int kOnStack = 1;
 const int kVisited = 2;
 
 std::ostream& operator<<(std::ostream& os, const AsRPO& ar) {
   Zone local_zone;
   ZoneVector<byte> state(ar.graph.NodeCount(), kUnvisited, &local_zone);
@@ skipping 22 matching lines @@
         os << "#" << SafeId(i) << ":" << SafeMnemonic(i);
       }
       os << ")" << std::endl;
     }
   }
   return os;
 }
 }
 }
 }  // namespace v8::internal::compiler