[turbofan] remove dependence of InstructionBlock on BasicBlock

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 388 matching lines @@
                      const SourcePositionTable* positions,
                      const InstructionSequence* instructions);
   void PrintAllocator(const char* phase, const RegisterAllocator* allocator);
   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, BasicBlock::Id block_id);
+  void PrintBlockProperty(const char* name, int rpo_number);
   void PrintNodeId(Node* n);
   void PrintNode(Node* n);
   void PrintInputs(Node* n);
   template <typename InputIterator>
   void PrintInputs(InputIterator* i, int count, const char* prefix);
   void PrintType(Node* node);
 
   void PrintLiveRange(LiveRange* range, const char* type);
   class Tag FINAL BASE_EMBEDDED {
    public:
@@ skipping 42 matching lines @@
   os_ << name << " \"" << value << "\"\n";
 }
 
 
 void GraphC1Visualizer::PrintLongProperty(const char* name, int64_t value) {
   PrintIndent();
   os_ << name << " " << static_cast<int>(value / 1000) << "\n";
 }
 
 
-void GraphC1Visualizer::PrintBlockProperty(const char* name,
-                                           BasicBlock::Id block_id) {
+void GraphC1Visualizer::PrintBlockProperty(const char* name, int rpo_number) {
   PrintIndent();
-  os_ << name << " \"B" << block_id << "\"\n";
+  os_ << name << " \"B" << rpo_number << "\"\n";
 }
 
 
 void GraphC1Visualizer::PrintIntProperty(const char* name, int value) {
   PrintIndent();
   os_ << name << " " << value << "\n";
 }
 
 
 void GraphC1Visualizer::PrintCompilation(const CompilationInfo* info) {
@@ skipping 65 matching lines @@
 void GraphC1Visualizer::PrintSchedule(const char* phase,
                                       const Schedule* schedule,
                                       const SourcePositionTable* positions,
                                       const InstructionSequence* instructions) {
   Tag tag(this, "cfg");
   PrintStringProperty("name", phase);
   const BasicBlockVector* rpo = schedule->rpo_order();
   for (size_t i = 0; i < rpo->size(); i++) {
     BasicBlock* current = (*rpo)[i];
     Tag block_tag(this, "block");
-    PrintBlockProperty("name", current->id());
+    PrintBlockProperty("name", current->rpo_number());
     PrintIntProperty("from_bci", -1);
     PrintIntProperty("to_bci", -1);
 
     PrintIndent();
     os_ << "predecessors";
     for (BasicBlock* predecessor : current->predecessors()) {
-      os_ << " \"B" << predecessor->id() << "\"";
+      os_ << " \"B" << predecessor->rpo_number() << "\"";
     }
     os_ << "\n";
 
     PrintIndent();
     os_ << "successors";
     for (BasicBlock* successor : current->successors()) {
-      os_ << " \"B" << successor->id() << "\"";
+      os_ << " \"B" << successor->rpo_number() << "\"";
     }
     os_ << "\n";
 
     PrintIndent();
     os_ << "xhandlers\n";
 
     PrintIndent();
     os_ << "flags\n";
 
     if (current->dominator() != NULL) {
-      PrintBlockProperty("dominator", current->dominator()->id());
+      PrintBlockProperty("dominator", current->dominator()->rpo_number());
     }
 
     PrintIntProperty("loop_depth", current->loop_depth());
 
     const InstructionBlock* instruction_block =
-        instructions->InstructionBlockAt(current->GetRpoNumber());
+        instructions->InstructionBlockAt(
+            RpoNumber::FromInt(current->rpo_number()));
     if (instruction_block->code_start() >= 0) {
       int first_index = instruction_block->first_instruction_index();
       int last_index = instruction_block->last_instruction_index();
       PrintIntProperty("first_lir_id", LifetimePosition::FromInstructionIndex(
                                            first_index).Value());
       PrintIntProperty("last_lir_id", LifetimePosition::FromInstructionIndex(
                                           last_index).Value());
     }
 
     {
@@ skipping 44 matching lines @@
         os_ << " <|@\n";
       }
 
       BasicBlock::Control control = current->control();
       if (control != BasicBlock::kNone) {
         PrintIndent();
         os_ << "0 0 ";
         if (current->control_input() != NULL) {
           PrintNode(current->control_input());
         } else {
-          os_ << -1 - current->id().ToInt() << " Goto";
+          os_ << -1 - current->rpo_number() << " Goto";
         }
         os_ << " ->";
         for (BasicBlock* successor : current->successors()) {
-          os_ << " B" << successor->id();
+          os_ << " B" << successor->rpo_number();
         }
         if (FLAG_trace_turbo_types && current->control_input() != NULL) {
           os_ << " ";
           PrintType(current->control_input());
         }
         os_ << " <|@\n";
       }
     }
 
     if (instructions != NULL) {
@@ skipping 143 matching lines @@
         os << "#" << SafeId(i) << ":" << SafeMnemonic(i);
       }
       os << ")" << std::endl;
     }
   }
   return os;
 }
 }
 }
 }  // namespace v8::internal::compiler