[turbofan] Split CodeGenerator::GenerateCode into AssembleCode and FinishCodeObject.

src/compiler/code-generator.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/code-generator.h"
 
 #include "src/address-map.h"
 #include "src/base/adapters.h"
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/linkage.h"
@@ skipping 14 matching lines @@
   Label** targets() const { return targets_; }
   size_t target_count() const { return target_count_; }
 
  private:
   Label label_;
   JumpTable* const next_;
   Label** const targets_;
   size_t const target_count_;
 };
 
-CodeGenerator::CodeGenerator(Frame* frame, Linkage* linkage,
-                             InstructionSequence* code, CompilationInfo* info)
+CodeGenerator::CodeGenerator(Zone* zone, CompilationInfo* info)
     : frame_access_state_(nullptr),
-      linkage_(linkage),
-      code_(code),
-      unwinding_info_writer_(zone()),
+      linkage_(nullptr),
+      code_(nullptr),
+      unwinding_info_writer_(zone),
       info_(info),
-      labels_(zone()->NewArray<Label>(code->InstructionBlockCount())),
+      labels_(nullptr),
       current_block_(RpoNumber::Invalid()),
       current_source_position_(SourcePosition::Unknown()),
       masm_(info->isolate(), nullptr, 0, CodeObjectRequired::kNo),
       resolver_(this),
-      safepoints_(code->zone()),
-      handlers_(code->zone()),
-      deoptimization_exits_(code->zone()),
-      deoptimization_states_(code->zone()),
-      deoptimization_literals_(code->zone()),
+      safepoints_(zone),
+      handlers_(zone),
+      deoptimization_exits_(zone),
+      deoptimization_states_(zone),
+      deoptimization_literals_(zone),
       inlined_function_count_(0),
-      translations_(code->zone()),
+      translations_(zone),
       last_lazy_deopt_pc_(0),
       jump_tables_(nullptr),
       ools_(nullptr),
       osr_pc_offset_(-1),
-      source_position_table_builder_(info->isolate(), code->zone(),
-                                     info->SourcePositionRecordingMode()) {
+      source_position_table_builder_(info->isolate(), zone,
+                                     info->SourcePositionRecordingMode()),
+      assemble_code_successful_(false) {}
+
+void CodeGenerator::Initialize(Frame* frame, Linkage* linkage,
+                               InstructionSequence* code) {
+  linkage_ = linkage;
+  code_ = code;
+  labels_ = zone()->NewArray<Label>(code->InstructionBlockCount());
   for (int i = 0; i < code->InstructionBlockCount(); ++i) {
     new (&labels_[i]) Label;
   }
-  CreateFrameAccessState(frame);
+
+  // Create the FrameAccessState object. The Frame is immutable from here on.
+  FinishFrame(frame);
+  frame_access_state_ = new (code->zone()) FrameAccessState(frame);
 }
 
-void CodeGenerator::CreateFrameAccessState(Frame* frame) {
-  FinishFrame(frame);
-  frame_access_state_ = new (code()->zone()) FrameAccessState(frame);
-}
-
-Handle<Code> CodeGenerator::GenerateCode() {
-  CompilationInfo* info = this->info();
+bool CodeGenerator::AssembleCode() {
+  DCHECK(!assemble_code_successful());
 
   // Open a frame scope to indicate that there is a frame on the stack.  The
   // MANUAL indicates that the scope shouldn't actually generate code to set up
   // the frame (that is done in AssemblePrologue).
   FrameScope frame_scope(masm(), StackFrame::MANUAL);
 
   // Place function entry hook if requested to do so.
   if (linkage()->GetIncomingDescriptor()->IsJSFunctionCall()) {
     ProfileEntryHookStub::MaybeCallEntryHook(masm());
   }
   // Architecture-specific, linkage-specific prologue.
-  info->set_prologue_offset(masm()->pc_offset());
+  info()->set_prologue_offset(masm()->pc_offset());
 
   // Define deoptimization literals for all inlined functions.
   DCHECK_EQ(0u, deoptimization_literals_.size());
   for (const CompilationInfo::InlinedFunctionHolder& inlined :
-       info->inlined_functions()) {
-    if (!inlined.shared_info.is_identical_to(info->shared_info())) {
+       info()->inlined_functions()) {
+    if (!inlined.shared_info.is_identical_to(info()->shared_info())) {
       DefineDeoptimizationLiteral(inlined.shared_info);
     }
   }
   inlined_function_count_ = deoptimization_literals_.size();
 
   // Define deoptimization literals for all unoptimized code objects of inlined
   // functions. This ensures unoptimized code is kept alive by optimized code.
   for (const CompilationInfo::InlinedFunctionHolder& inlined :
-       info->inlined_functions()) {
-    if (!inlined.shared_info.is_identical_to(info->shared_info())) {
+       info()->inlined_functions()) {
+    if (!inlined.shared_info.is_identical_to(info()->shared_info())) {
       DefineDeoptimizationLiteral(inlined.inlined_code_object_root);
     }
   }
 
   unwinding_info_writer_.SetNumberOfInstructionBlocks(
       code()->InstructionBlockCount());
 
   // Assemble all non-deferred blocks, followed by deferred ones.
   for (int deferred = 0; deferred < 2; ++deferred) {
     for (const InstructionBlock* block : code()->instruction_blocks()) {
@@ skipping 49 matching lines @@
         }
       }
 
       CodeGenResult result;
       if (FLAG_enable_embedded_constant_pool && !block->needs_frame()) {
         ConstantPoolUnavailableScope constant_pool_unavailable(masm());
         result = AssembleBlock(block);
       } else {
         result = AssembleBlock(block);
       }
-      if (result != kSuccess) return Handle<Code>();
+      if (result != kSuccess) {
+        assemble_code_successful_ = false;
+        return false;
+      }
       unwinding_info_writer_.EndInstructionBlock(block);
     }
   }
 
+  assemble_code_successful_ = true;
+  return true;
+}
+
+Handle<Code> CodeGenerator::FinishCodeObject() {
+  if (!assemble_code_successful_) {
+    return Handle<Code>::null();
+  }
+
   // Assemble all out-of-line code.
   if (ools_) {
     masm()->RecordComment("-- Out of line code --");
     for (OutOfLineCode* ool = ools_; ool; ool = ool->next()) {
       masm()->bind(ool->entry());
       ool->Generate();
       if (ool->exit()->is_bound()) masm()->jmp(ool->exit());
     }
   }
 
   // Assemble all eager deoptimization exits.
   for (DeoptimizationExit* exit : deoptimization_exits_) {
     masm()->bind(exit->label());
     AssembleDeoptimizerCall(exit->deoptimization_id(), Deoptimizer::EAGER);
   }
 
   // Ensure there is space for lazy deoptimization in the code.
-  if (info->ShouldEnsureSpaceForLazyDeopt()) {
+  if (info()->ShouldEnsureSpaceForLazyDeopt()) {
     int target_offset = masm()->pc_offset() + Deoptimizer::patch_size();
     while (masm()->pc_offset() < target_offset) {
       masm()->nop();
     }
   }
 
   FinishCode(masm());
 
   // Emit the jump tables.
   if (jump_tables_) {
     masm()->Align(kPointerSize);
     for (JumpTable* table = jump_tables_; table; table = table->next()) {
       masm()->bind(table->label());
       AssembleJumpTable(table->targets(), table->target_count());
     }
   }
 
   safepoints()->Emit(masm(), frame()->GetTotalFrameSlotCount());
 
   unwinding_info_writer_.Finish(masm()->pc_offset());
 
   Handle<Code> result = v8::internal::CodeGenerator::MakeCodeEpilogue(
-      masm(), unwinding_info_writer_.eh_frame_writer(), info, Handle<Object>());
+      masm(), unwinding_info_writer_.eh_frame_writer(), info(),
+      Handle<Object>());
   result->set_is_turbofanned(true);
   result->set_stack_slots(frame()->GetTotalFrameSlotCount());
   result->set_safepoint_table_offset(safepoints()->GetCodeOffset());
   Handle<ByteArray> source_positions =
       source_position_table_builder_.ToSourcePositionTable();
   result->set_source_position_table(*source_positions);
   source_position_table_builder_.EndJitLogging(AbstractCode::cast(*result));
 
   // Emit exception handler table.
   if (!handlers_.empty()) {
     Handle<HandlerTable> table =
         Handle<HandlerTable>::cast(isolate()->factory()->NewFixedArray(
             HandlerTable::LengthForReturn(static_cast<int>(handlers_.size())),
             TENURED));
     for (size_t i = 0; i < handlers_.size(); ++i) {
       table->SetReturnOffset(static_cast<int>(i), handlers_[i].pc_offset);
       table->SetReturnHandler(static_cast<int>(i), handlers_[i].handler->pos());
     }
     result->set_handler_table(*table);
   }
 
   PopulateDeoptimizationData(result);
 
   // Ensure there is space for lazy deoptimization in the relocation info.
-  if (info->ShouldEnsureSpaceForLazyDeopt()) {
+  if (info()->ShouldEnsureSpaceForLazyDeopt()) {
     Deoptimizer::EnsureRelocSpaceForLazyDeoptimization(result);
   }
 
   return result;
 }
 
-
 bool CodeGenerator::IsNextInAssemblyOrder(RpoNumber block) const {
   return code()
       ->InstructionBlockAt(current_block_)
       ->ao_number()
       .IsNext(code()->InstructionBlockAt(block)->ao_number());
 }
 
 
 void CodeGenerator::RecordSafepoint(ReferenceMap* references,
                                     Safepoint::Kind kind, int arguments,
@@ skipping 678 matching lines @@
     : frame_(gen->frame()), masm_(gen->masm()), next_(gen->ools_) {
   gen->ools_ = this;
 }
 
 
 OutOfLineCode::~OutOfLineCode() {}
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8