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

src/compiler/code-generator.h

 // 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.
 
 #ifndef V8_COMPILER_CODE_GENERATOR_H_
 #define V8_COMPILER_CODE_GENERATOR_H_
 
 #include "src/compiler/gap-resolver.h"
 #include "src/compiler/instruction.h"
 #include "src/compiler/unwinding-info-writer.h"
@@ skipping 30 matching lines @@
 
  private:
   Instruction* instr_;
   size_t pos_;
 };
 
 
 // Generates native code for a sequence of instructions.
 class CodeGenerator final : public GapResolver::Assembler {
  public:
-  explicit CodeGenerator(Frame* frame, Linkage* linkage,
-                         InstructionSequence* code, CompilationInfo* info);
+  explicit CodeGenerator(Zone* zone, CompilationInfo* info);

[Michael Starzinger, 2016/08/11 14:16:26]

nit: Doesn't need to be "explicit" with more than one argument.

[ahaas, 2016/08/11 14:54:19]

Done.

 
+  void Initialize(Frame* frame, Linkage* linkage, InstructionSequence* code);

[Michael Starzinger, 2016/08/11 14:16:26]

nit: Can we add a "// Initialize before calling assembling or finishing code
object."

[ahaas, 2016/08/11 14:54:19]

Done.

   // Generate native code.

[Michael Starzinger, 2016/08/11 14:16:26]

nit: Empty whitespace between declarations for readability. Also lets adapt the
comment to make clear that this can be run off the main thread.

[ahaas, 2016/08/11 14:54:19]

Done.

-  Handle<Code> GenerateCode();
+  bool AssembleCode();
+  // Finishes the code object generated in AssembleCode.

[Michael Starzinger, 2016/08/11 14:16:26]

nit: Empty whitespace between declarations for readability. Also it might be
good to mention that this will return an empty handle when AssembleCode failed
or wasn't called (to clarify that is is safe to call).

[ahaas, 2016/08/11 14:54:19]

Done.

+  Handle<Code> FinishCodeObject();
 
   InstructionSequence* code() const { return code_; }
   FrameAccessState* frame_access_state() const { return frame_access_state_; }
   const Frame* frame() const { return frame_access_state_->frame(); }
   Isolate* isolate() const { return info_->isolate(); }
   Linkage* linkage() const { return linkage_; }
+  bool assemble_code_successful() { return assemble_code_successful_; }
 
   Label* GetLabel(RpoNumber rpo) { return &labels_[rpo.ToSize()]; }
 
  private:
   MacroAssembler* masm() { return &masm_; }
   GapResolver* resolver() { return &resolver_; }
   SafepointTableBuilder* safepoints() { return &safepoints_; }
   Zone* zone() const { return code()->zone(); }
   CompilationInfo* info() const { return info_; }
 
-  // Create the FrameAccessState object. The Frame is immutable from here on.
-  void CreateFrameAccessState(Frame* frame);
-
   // Architecture - specific frame finalization.
   void FinishFrame(Frame* frame);
 
   // Checks if {block} will appear directly after {current_block_} when
   // assembling code, in which case, a fall-through can be used.
   bool IsNextInAssemblyOrder(RpoNumber block) const;
 
   // Record a safepoint with the given pointer map.
   void RecordSafepoint(ReferenceMap* references, Safepoint::Kind kind,
                        int arguments, Safepoint::DeoptMode deopt_mode);
@@ skipping 165 matching lines @@
   };
 
   struct HandlerInfo {
     Label* handler;
     int pc_offset;
   };
 
   friend class OutOfLineCode;
 
   FrameAccessState* frame_access_state_;
-  Linkage* const linkage_;
-  InstructionSequence* const code_;
+  Linkage* linkage_;
+  InstructionSequence* code_;
   UnwindingInfoWriter unwinding_info_writer_;
   CompilationInfo* const info_;
-  Label* const labels_;
+  Label* labels_;
   Label return_label_;
   RpoNumber current_block_;
   SourcePosition current_source_position_;
   MacroAssembler masm_;
   GapResolver resolver_;
   SafepointTableBuilder safepoints_;
   ZoneVector<HandlerInfo> handlers_;
   ZoneDeque<DeoptimizationExit*> deoptimization_exits_;
   ZoneDeque<DeoptimizationState*> deoptimization_states_;
   ZoneDeque<Handle<Object>> deoptimization_literals_;
   size_t inlined_function_count_;
   TranslationBuffer translations_;
   int last_lazy_deopt_pc_;
   JumpTable* jump_tables_;
   OutOfLineCode* ools_;
   int osr_pc_offset_;
   SourcePositionTableBuilder source_position_table_builder_;
+  bool assemble_code_successful_;
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_CODE_GENERATOR_H