[turbofan] Add support for deferred code.

src/compiler/instruction.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/instruction.h"
 
 #include "src/compiler/common-operator.h"
 #include "src/compiler/generic-node-inl.h"
 #include "src/compiler/graph.h"
 
@@ skipping 318 matching lines @@
 }
 
 
 InstructionBlock::InstructionBlock(Zone* zone, const BasicBlock* block)
     : successors_(static_cast<int>(block->SuccessorCount()),
                   BasicBlock::RpoNumber::Invalid(), zone),
       predecessors_(static_cast<int>(block->PredecessorCount()),
                     BasicBlock::RpoNumber::Invalid(), zone),
       phis_(zone),
       id_(block->id()),
+      ao_number_(block->GetAoNumber()),
       rpo_number_(block->GetRpoNumber()),
       loop_header_(GetRpo(block->loop_header())),
       loop_end_(GetLoopEndRpo(block)),
       code_start_(-1),
-      code_end_(-1) {
+      code_end_(-1),
+      deferred_(block->deferred()) {
   // Map successors and precessors
   size_t index = 0;
   for (BasicBlock::Successors::const_iterator it = block->successors_begin();
        it != block->successors_end(); ++it, ++index) {
     successors_[index] = (*it)->GetRpoNumber();
   }
   index = 0;
   for (BasicBlock::Predecessors::const_iterator
            it = block->predecessors_begin();
        it != block->predecessors_end(); ++it, ++index) {
@@ skipping 243 matching lines @@
   int i = 0;
   for (ConstantMap::const_iterator it = code.constants_.begin();
        it != code.constants_.end(); ++i, ++it) {
     os << "CST#" << i << ": v" << it->first << " = " << it->second << "\n";
   }
   for (int i = 0; i < code.InstructionBlockCount(); i++) {
     BasicBlock::RpoNumber rpo = BasicBlock::RpoNumber::FromInt(i);
     const InstructionBlock* block = code.InstructionBlockAt(rpo);
     CHECK(block->rpo_number() == rpo);
 
-    os << "RPO#" << block->rpo_number() << ": B" << block->id();
+    os << "RPO#" << block->rpo_number();
+    os << ": AO#" << block->ao_number();
+    os << ": B" << block->id();
+    if (block->IsDeferred()) os << " (deferred)";
     if (block->IsLoopHeader()) {
       os << " loop blocks: [" << block->rpo_number() << ", "
          << block->loop_end() << ")";
     }
     os << "  instructions: [" << block->code_start() << ", "
        << block->code_end() << ")\n  predecessors:";
 
     for (auto pred : block->predecessors()) {
       const InstructionBlock* pred_block = code.InstructionBlockAt(pred);
       os << " B" << pred_block->id();
@@ skipping 28 matching lines @@
       os << " B" << succ_block->id();
     }
     os << "\n";
   }
   return os;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8