[turbofan] remove dependence of InstructionBlock on BasicBlock

src/compiler/jump-threading.cc

 // Copyright 2014 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/jump-threading.h"
 #include "src/compiler/code-generator-impl.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
-typedef BasicBlock::RpoNumber RpoNumber;
-
 #define TRACE(x) \
   if (FLAG_trace_turbo_jt) PrintF x
 
 struct JumpThreadingState {
   bool forwarded;
   ZoneVector<RpoNumber>& result;
   ZoneStack<RpoNumber>& stack;
 
   void Clear(size_t count) { result.assign(count, unvisited()); }
   void PushIfUnvisited(RpoNumber num) {
@@ skipping 39 matching lines @@
 
   // Iterate over the blocks forward, pushing the blocks onto the stack.
   for (auto const block : code->instruction_blocks()) {
     RpoNumber current = block->rpo_number();
     state.PushIfUnvisited(current);
 
     // Process the stack, which implements DFS through empty blocks.
     while (!state.stack.empty()) {
       InstructionBlock* block = code->InstructionBlockAt(state.stack.top());
       // Process the instructions in a block up to a non-empty instruction.
-      TRACE(("jt [%d] B%d RPO%d\n", static_cast<int>(stack.size()),
-             block->id().ToInt(), block->rpo_number().ToInt()));
+      TRACE(("jt [%d] B%d\n", static_cast<int>(stack.size()),
+             block->rpo_number().ToInt()));
       bool fallthru = true;
       RpoNumber fw = block->rpo_number();
       for (int i = block->code_start(); i < block->code_end(); ++i) {
         Instruction* instr = code->InstructionAt(i);
         if (instr->IsGapMoves() && GapInstruction::cast(instr)->IsRedundant()) {
           // skip redundant gap moves.
           TRACE(("  nop gap\n"));
           continue;
         } else if (instr->IsSourcePosition()) {
           // skip source positions.
@@ skipping 28 matching lines @@
   }
 
 #ifdef DEBUG
   for (RpoNumber num : result) {
     CHECK(num.IsValid());
   }
 #endif
 
   if (FLAG_trace_turbo_jt) {
     for (int i = 0; i < static_cast<int>(result.size()); i++) {
-      TRACE(("RPO%d B%d ", i,
-             code->InstructionBlockAt(RpoNumber::FromInt(i))->id().ToInt()));
+      TRACE(("B%d ", i));
       int to = result[i].ToInt();
       if (i != to) {
-        TRACE(("-> B%d\n",
-               code->InstructionBlockAt(RpoNumber::FromInt(to))->id().ToInt()));
+        TRACE(("-> B%d\n", to));
       } else {
         TRACE(("\n"));
       }
     }
   }
 
   return state.forwarded;
 }
 
 
@@ skipping 50 matching lines @@
     if (block->IsDeferred()) {
       block->set_ao_number(RpoNumber::FromInt(ao));
       if (!skip[block->rpo_number().ToInt()]) ao++;
     }
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8