[turbofan] Enable concurrent (re)compilation.

src/compiler/pipeline.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/pipeline.h"
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
 
 #include "src/base/adapters.h"
@@ skipping 38 matching lines @@
 #include "src/compiler/verifier.h"
 #include "src/compiler/zone-pool.h"
 #include "src/ostreams.h"
 #include "src/type-info.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
-class PipelineData {
+namespace {
+
+PipelineStatistics* NewPipelineStatistics(CompilationInfo* const info,
+                                          ZonePool* const zone_pool) {
+  if (FLAG_turbo_stats) {
+    PipelineStatistics* pipeline_statistics =
+        new PipelineStatistics(info, zone_pool);
+    pipeline_statistics->BeginPhaseKind("initializing");
+    return pipeline_statistics;
+  }
+  return nullptr;
+}
+
+}  // namespace
+
+
+class PipelineData final {
  public:
   // For main entry point.
-  PipelineData(ZonePool* zone_pool, CompilationInfo* info,
-               PipelineStatistics* pipeline_statistics)
+  explicit PipelineData(CompilationInfo* info)
       : isolate_(info->isolate()),
         info_(info),
         outer_zone_(info_->zone()),
-        zone_pool_(zone_pool),
-        pipeline_statistics_(pipeline_statistics),
+        pipeline_statistics_(NewPipelineStatistics(info, zone_pool())),
         compilation_failed_(false),
         code_(Handle<Code>::null()),
-        graph_zone_scope_(zone_pool_),
+        graph_zone_scope_(&zone_pool_),
         graph_zone_(graph_zone_scope_.zone()),
         graph_(nullptr),
         loop_assignment_(nullptr),
         machine_(nullptr),
         common_(nullptr),
         javascript_(nullptr),
         jsgraph_(nullptr),
         js_type_feedback_(nullptr),
-        typer_(nullptr),
         schedule_(nullptr),
-        instruction_zone_scope_(zone_pool_),
+        linkage_(nullptr),
+        profiler_data_(nullptr),
+        instruction_zone_scope_(&zone_pool_),
         instruction_zone_(instruction_zone_scope_.zone()),
         sequence_(nullptr),
         frame_(nullptr),
-        register_allocation_zone_scope_(zone_pool_),
+        register_allocation_zone_scope_(&zone_pool_),
         register_allocation_zone_(register_allocation_zone_scope_.zone()),
         register_allocation_data_(nullptr) {
-    PhaseScope scope(pipeline_statistics, "init pipeline data");
+    PhaseScope scope(pipeline_statistics(), "init pipeline data");
     graph_ = new (graph_zone_) Graph(graph_zone_);
     source_positions_.Reset(new SourcePositionTable(graph_));
     machine_ = new (graph_zone_) MachineOperatorBuilder(
         graph_zone_, kMachPtr,
         InstructionSelector::SupportedMachineOperatorFlags());
     common_ = new (graph_zone_) CommonOperatorBuilder(graph_zone_);
     javascript_ = new (graph_zone_) JSOperatorBuilder(graph_zone_);
     jsgraph_ = new (graph_zone_)
         JSGraph(isolate_, graph_, common_, javascript_, machine_);
-    typer_.Reset(new Typer(isolate_, graph_, info_->context()));
   }
 
   // For machine graph testing entry point.
-  PipelineData(ZonePool* zone_pool, CompilationInfo* info, Graph* graph,
-               Schedule* schedule)
+  PipelineData(CompilationInfo* info, Graph* graph, Schedule* schedule)
       : isolate_(info->isolate()),
         info_(info),
         outer_zone_(nullptr),
-        zone_pool_(zone_pool),
         pipeline_statistics_(nullptr),
         compilation_failed_(false),
         code_(Handle<Code>::null()),
-        graph_zone_scope_(zone_pool_),
+        graph_zone_scope_(&zone_pool_),
         graph_zone_(nullptr),
         graph_(graph),
         source_positions_(new SourcePositionTable(graph_)),
         loop_assignment_(nullptr),
         machine_(nullptr),
         common_(nullptr),
         javascript_(nullptr),
         jsgraph_(nullptr),
         js_type_feedback_(nullptr),
-        typer_(nullptr),
         schedule_(schedule),
-        instruction_zone_scope_(zone_pool_),
+        linkage_(nullptr),
+        profiler_data_(nullptr),
+        instruction_zone_scope_(&zone_pool_),
         instruction_zone_(instruction_zone_scope_.zone()),
         sequence_(nullptr),
         frame_(nullptr),
-        register_allocation_zone_scope_(zone_pool_),
+        register_allocation_zone_scope_(&zone_pool_),
         register_allocation_zone_(register_allocation_zone_scope_.zone()),
         register_allocation_data_(nullptr) {}
 
   // For register allocation testing entry point.
-  PipelineData(ZonePool* zone_pool, CompilationInfo* info,
-               InstructionSequence* sequence)
+  PipelineData(CompilationInfo* info, InstructionSequence* sequence)
       : isolate_(info->isolate()),
         info_(info),
         outer_zone_(nullptr),
-        zone_pool_(zone_pool),
         pipeline_statistics_(nullptr),
         compilation_failed_(false),
         code_(Handle<Code>::null()),
-        graph_zone_scope_(zone_pool_),
+        graph_zone_scope_(&zone_pool_),
         graph_zone_(nullptr),
         graph_(nullptr),
         loop_assignment_(nullptr),
         machine_(nullptr),
         common_(nullptr),
         javascript_(nullptr),
         jsgraph_(nullptr),
         js_type_feedback_(nullptr),
-        typer_(nullptr),
         schedule_(nullptr),
-        instruction_zone_scope_(zone_pool_),
+        linkage_(nullptr),
+        profiler_data_(nullptr),
+        instruction_zone_scope_(&zone_pool_),
         instruction_zone_(sequence->zone()),
         sequence_(sequence),
         frame_(nullptr),
-        register_allocation_zone_scope_(zone_pool_),
+        register_allocation_zone_scope_(&zone_pool_),
         register_allocation_zone_(register_allocation_zone_scope_.zone()),
         register_allocation_data_(nullptr) {}
 
   ~PipelineData() {
     DeleteRegisterAllocationZone();
     DeleteInstructionZone();
     DeleteGraphZone();
   }
 
   Isolate* isolate() const { return isolate_; }
   CompilationInfo* info() const { return info_; }
-  ZonePool* zone_pool() const { return zone_pool_; }
-  PipelineStatistics* pipeline_statistics() { return pipeline_statistics_; }
+  ZonePool* zone_pool() { return &zone_pool_; }
+  PipelineStatistics* pipeline_statistics() const {
+    return pipeline_statistics_.get();
+  }
   bool compilation_failed() const { return compilation_failed_; }
   void set_compilation_failed() { compilation_failed_ = true; }
   Handle<Code> code() { return code_; }
   void set_code(Handle<Code> code) {
     DCHECK(code_.is_null());
     code_ = code;
   }
 
   // RawMachineAssembler generally produces graphs which cannot be verified.
   bool MayHaveUnverifiableGraph() const { return outer_zone_ == nullptr; }
 
   Zone* graph_zone() const { return graph_zone_; }
   Graph* graph() const { return graph_; }
   SourcePositionTable* source_positions() const {
     return source_positions_.get();
   }
   MachineOperatorBuilder* machine() const { return machine_; }
   CommonOperatorBuilder* common() const { return common_; }
   JSOperatorBuilder* javascript() const { return javascript_; }
   JSGraph* jsgraph() const { return jsgraph_; }
   JSTypeFeedbackTable* js_type_feedback() { return js_type_feedback_; }
   void set_js_type_feedback(JSTypeFeedbackTable* js_type_feedback) {
     js_type_feedback_ = js_type_feedback;
   }
-  Typer* typer() const { return typer_.get(); }
 
   LoopAssignmentAnalysis* loop_assignment() const { return loop_assignment_; }
   void set_loop_assignment(LoopAssignmentAnalysis* loop_assignment) {
     DCHECK(!loop_assignment_);
     loop_assignment_ = loop_assignment;
   }
 
   Schedule* schedule() const { return schedule_; }
   void set_schedule(Schedule* schedule) {
     DCHECK(!schedule_);
     schedule_ = schedule;
   }
 
   Zone* instruction_zone() const { return instruction_zone_; }
   InstructionSequence* sequence() const { return sequence_; }
   Frame* frame() const { return frame_; }
 
+  Linkage* linkage() const { return linkage_; }
+  void set_linkage(Linkage* linkage) { linkage_ = linkage; }
+
+  BasicBlockProfiler::Data* profiler_data() const { return profiler_data_; }
+
   Zone* register_allocation_zone() const { return register_allocation_zone_; }
   RegisterAllocationData* register_allocation_data() const {
     return register_allocation_data_;
   }
 
   void DeleteGraphZone() {
     // Destroy objects with destructors first.
     source_positions_.Reset(nullptr);
-    typer_.Reset(nullptr);
     if (graph_zone_ == nullptr) return;
     // Destroy zone and clear pointers.
     graph_zone_scope_.Destroy();
     graph_zone_ = nullptr;
     graph_ = nullptr;
     loop_assignment_ = nullptr;
     machine_ = nullptr;
     common_ = nullptr;
     javascript_ = nullptr;
     jsgraph_ = nullptr;
@@ skipping 11 matching lines @@
 
   void DeleteRegisterAllocationZone() {
     if (register_allocation_zone_ == nullptr) return;
     register_allocation_zone_scope_.Destroy();
     register_allocation_zone_ = nullptr;
     register_allocation_data_ = nullptr;
   }
 
   void InitializeInstructionSequence() {
     DCHECK(sequence_ == nullptr);
+    if (FLAG_turbo_profiling) {
+      profiler_data_ =
+          BasicBlockInstrumentor::Instrument(info(), graph(), schedule());
+    }
     InstructionBlocks* instruction_blocks =
         InstructionSequence::InstructionBlocksFor(instruction_zone(),
                                                   schedule());
     sequence_ = new (instruction_zone()) InstructionSequence(
         info()->isolate(), instruction_zone(), instruction_blocks);
   }
 
   void InitializeRegisterAllocationData(const RegisterConfiguration* config,
                                         const char* debug_name) {
     DCHECK(frame_ == nullptr);
     DCHECK(register_allocation_data_ == nullptr);
     frame_ = new (instruction_zone()) Frame();
     register_allocation_data_ = new (register_allocation_zone())
         RegisterAllocationData(config, register_allocation_zone(), frame(),
                                sequence(), debug_name);
   }
 
+  std::ostringstream& source_position_output() {
+    return source_position_output_;
+  }
+
  private:
   Isolate* isolate_;
   CompilationInfo* info_;
   Zone* outer_zone_;
-  ZonePool* const zone_pool_;
-  PipelineStatistics* pipeline_statistics_;
+  ZonePool zone_pool_;
+  SmartPointer<PipelineStatistics> pipeline_statistics_;
   bool compilation_failed_;
   Handle<Code> code_;
 
   // All objects in the following group of fields are allocated in graph_zone_.
   // They are all set to NULL when the graph_zone_ is destroyed.
   ZonePool::Scope graph_zone_scope_;
   Zone* graph_zone_;
   Graph* graph_;
   // TODO(dcarney): make this into a ZoneObject.
   SmartPointer<SourcePositionTable> source_positions_;
   LoopAssignmentAnalysis* loop_assignment_;
   MachineOperatorBuilder* machine_;
   CommonOperatorBuilder* common_;
   JSOperatorBuilder* javascript_;
   JSGraph* jsgraph_;
   JSTypeFeedbackTable* js_type_feedback_;
   // TODO(dcarney): make this into a ZoneObject.
-  SmartPointer<Typer> typer_;
   Schedule* schedule_;
+  Linkage* linkage_;
+  BasicBlockProfiler::Data* profiler_data_;
+  std::ostringstream source_position_output_;
 
   // All objects in the following group of fields are allocated in
   // instruction_zone_.  They are all set to NULL when the instruction_zone_ is
   // destroyed.
   ZonePool::Scope instruction_zone_scope_;
   Zone* instruction_zone_;
   InstructionSequence* sequence_;
   Frame* frame_;
 
   // All objects in the following group of fields are allocated in
@@ skipping 138 matching lines @@
   Zone* zone() { return zone_scope_.zone(); }
 
  private:
   PhaseScope phase_scope_;
   ZonePool::Scope zone_scope_;
 };
 
 }  // namespace
 
 
+Pipeline::Pipeline(CompilationInfo* info) : Pipeline(new PipelineData(info)) {}
+
+
+Pipeline::~Pipeline() { delete data_; }
+
+
+CompilationInfo* Pipeline::info() const { return data()->info(); }
+
+
 template <typename Phase>
 void Pipeline::Run() {
-  PipelineRunScope scope(this->data_, Phase::phase_name());
+  PipelineRunScope scope(data(), Phase::phase_name());
   Phase phase;
-  phase.Run(this->data_, scope.zone());
+  phase.Run(data(), scope.zone());
 }
 
 
 template <typename Phase, typename Arg0>
 void Pipeline::Run(Arg0 arg_0) {
-  PipelineRunScope scope(this->data_, Phase::phase_name());
+  PipelineRunScope scope(data(), Phase::phase_name());
   Phase phase;
-  phase.Run(this->data_, scope.zone(), arg_0);
+  phase.Run(data(), scope.zone(), arg_0);
 }
 
 
 struct LoopAssignmentAnalysisPhase {
   static const char* phase_name() { return "loop assignment analysis"; }
 
   void Run(PipelineData* data, Zone* temp_zone) {
     AstLoopAssignmentAnalyzer analyzer(data->graph_zone(), data->info());
     LoopAssignmentAnalysis* loop_assignment = analyzer.Analyze();
     data->set_loop_assignment(loop_assignment);
@@ skipping 39 matching lines @@
                       temp_zone, data->info(), data->jsgraph());
     AddReducer(data, &graph_reducer, &inliner);
     graph_reducer.ReduceGraph();
   }
 };
 
 
 struct TyperPhase {
   static const char* phase_name() { return "typer"; }
 
-  void Run(PipelineData* data, Zone* temp_zone) { data->typer()->Run(); }
+  void Run(PipelineData* data, Zone* temp_zone, Typer* typer) { typer->Run(); }
 };
 
 
 struct OsrDeconstructionPhase {
   static const char* phase_name() { return "OSR deconstruction"; }
 
   void Run(PipelineData* data, Zone* temp_zone) {
     OsrHelper osr_helper(data->info());
     osr_helper.Deconstruct(data->jsgraph(), data->common(), temp_zone);
   }
@@ skipping 159 matching lines @@
                                       : Scheduler::kNoFlags);
     if (FLAG_turbo_verify) ScheduleVerifier::Run(schedule);
     data->set_schedule(schedule);
   }
 };
 
 
 struct InstructionSelectionPhase {
   static const char* phase_name() { return "select instructions"; }
 
-  void Run(PipelineData* data, Zone* temp_zone, Linkage* linkage) {
+  void Run(PipelineData* data, Zone* temp_zone) {
     InstructionSelector selector(
-        temp_zone, data->graph()->NodeCount(), linkage, data->sequence(),
-        data->schedule(), data->source_positions(),
+        temp_zone, data->graph()->NodeCount(), data->linkage(),
+        data->sequence(), data->schedule(), data->source_positions(),
         data->info()->is_source_positions_enabled()
             ? InstructionSelector::kAllSourcePositions
             : InstructionSelector::kCallSourcePositions);
     selector.SelectInstructions();
   }
 };
 
 
 struct MeetRegisterConstraintsPhase {
   static const char* phase_name() { return "meet register constraints"; }
@@ skipping 136 matching lines @@
     if (JumpThreading::ComputeForwarding(temp_zone, result, data->sequence())) {
       JumpThreading::ApplyForwarding(result, data->sequence());
     }
   }
 };
 
 
 struct GenerateCodePhase {
   static const char* phase_name() { return "generate code"; }
 
-  void Run(PipelineData* data, Zone* temp_zone, Linkage* linkage) {
-    CodeGenerator generator(data->frame(), linkage, data->sequence(),
+  void Run(PipelineData* data, Zone* temp_zone) {
+    CodeGenerator generator(data->frame(), data->linkage(), data->sequence(),
                             data->info());
     data->set_code(generator.GenerateCode());
   }
 };
 
 
 struct PrintGraphPhase {
   static const char* phase_name() { return nullptr; }
 
   void Run(PipelineData* data, Zone* temp_zone, const char* phase) {
@@ skipping 47 matching lines @@
 void Pipeline::RunPrintAndVerify(const char* phase, bool untyped) {
   if (FLAG_trace_turbo) {
     Run<PrintGraphPhase>(phase);
   }
   if (FLAG_turbo_verify) {
     Run<VerifyGraphPhase>(untyped);
   }
 }
 
 
-Handle<Code> Pipeline::GenerateCode() {
+bool Pipeline::CreateGraph() {
   // TODO(mstarzinger): This is just a temporary hack to make TurboFan work,
   // the correct solution is to restore the context register after invoking
   // builtins from full-codegen.
   Handle<SharedFunctionInfo> shared = info()->shared_info();
   for (int i = 0; i < Builtins::NumberOfJavaScriptBuiltins(); i++) {
     Builtins::JavaScript id = static_cast<Builtins::JavaScript>(i);
     Object* builtin = isolate()->js_builtins_object()->javascript_builtin(id);
-    if (*info()->closure() == builtin) return Handle<Code>::null();
+    if (*info()->closure() == builtin) return false;
   }
 
   // TODO(dslomov): support turbo optimization of subclass constructors.
   if (IsSubclassConstructor(shared->kind())) {
     shared->DisableOptimization(kSuperReference);
-    return Handle<Code>::null();
-  }
-
-  ZonePool zone_pool;
-  SmartPointer<PipelineStatistics> pipeline_statistics;
-
-  if (FLAG_turbo_stats) {
-    pipeline_statistics.Reset(new PipelineStatistics(info(), &zone_pool));
-    pipeline_statistics->BeginPhaseKind("initializing");
+    return false;
   }
 
   if (FLAG_trace_turbo) {
     FILE* json_file = OpenVisualizerLogFile(info(), NULL, "json", "w+");
     if (json_file != nullptr) {
       OFStream json_of(json_file);
       Handle<Script> script = info()->script();
       FunctionLiteral* function = info()->function();
       SmartArrayPointer<char> function_name =
           info()->shared_info()->DebugName()->ToCString();
       int pos = info()->shared_info()->start_position();
       json_of << "{\"function\":\"" << function_name.get()
               << "\", \"sourcePosition\":" << pos << ", \"source\":\"";
       if (!script->IsUndefined() && !script->source()->IsUndefined()) {
         DisallowHeapAllocation no_allocation;
         int start = function->start_position();
         int len = function->end_position() - start;
         String::SubStringRange source(String::cast(script->source()), start,
                                       len);
         for (const auto& c : source) {
           json_of << AsEscapedUC16ForJSON(c);
         }
       }
       json_of << "\",\n\"phases\":[";
       fclose(json_file);
     }
   }
 
-  PipelineData data(&zone_pool, info(), pipeline_statistics.get());
-  this->data_ = &data;
-
   if (info()->is_type_feedback_enabled()) {
-    data.set_js_type_feedback(new (data.graph_zone())
-                                  JSTypeFeedbackTable(data.graph_zone()));
+    data()->set_js_type_feedback(new (data()->graph_zone())
+                                     JSTypeFeedbackTable(data()->graph_zone()));
   }
 
   BeginPhaseKind("graph creation");
 
   if (FLAG_trace_turbo) {
     OFStream os(stdout);
     os << "---------------------------------------------------\n"
        << "Begin compiling method " << GetDebugName(info()).get()
        << " using Turbofan" << std::endl;
     TurboCfgFile tcf(isolate());
     tcf << AsC1VCompilation(info());
   }
 
-  data.source_positions()->AddDecorator();
+  data()->source_positions()->AddDecorator();
 
   if (FLAG_loop_assignment_analysis) {
     Run<LoopAssignmentAnalysisPhase>();
   }
 
   Run<GraphBuilderPhase>(info()->is_context_specializing());
-  if (data.compilation_failed()) return Handle<Code>::null();
+  if (data()->compilation_failed()) return false;
   RunPrintAndVerify("Initial untyped", true);
 
   Run<EarlyControlReductionPhase>();
   RunPrintAndVerify("Early Control reduced", true);
 
   if (info()->is_context_specializing()) {
     // Specialize the code to the context as aggressively as possible.
     Run<ContextSpecializerPhase>();
     RunPrintAndVerify("Context specialized", true);
   }
 
   Run<InliningPhase>();
   RunPrintAndVerify("Inlined", true);
 
   if (FLAG_print_turbo_replay) {
     // Print a replay of the initial graph.
-    GraphReplayPrinter::PrintReplay(data.graph());
+    GraphReplayPrinter::PrintReplay(data()->graph());
   }
 
   // Bailout here in case target architecture is not supported.
-  if (!SupportedTarget()) return Handle<Code>::null();
+  if (!SupportedTarget()) return false;
 
+  SmartPointer<Typer> typer;
   if (info()->is_typing_enabled()) {
     // Type the graph.
-    Run<TyperPhase>();
+    typer.Reset(new Typer(isolate(), data()->graph(), info()->context()));
+    Run<TyperPhase>(typer.get());
     RunPrintAndVerify("Typed");
   }
 
   BeginPhaseKind("lowering");
 
   if (info()->is_typing_enabled()) {
     // Lower JSOperators where we can determine types.
     Run<TypedLoweringPhase>();
     RunPrintAndVerify("Lowered typed");
 
@@ skipping 25 matching lines @@
     // Lower changes that have been inserted before.
     Run<ChangeLoweringPhase>();
     // TODO(jarin, rossberg): Remove UNTYPED once machine typing works.
     RunPrintAndVerify("Lowered changes", true);
 
     Run<LateControlReductionPhase>();
     RunPrintAndVerify("Late Control reduced");
   } else {
     if (info()->is_osr()) {
       Run<OsrDeconstructionPhase>();
-      if (info()->bailout_reason() != kNoReason) return Handle<Code>::null();
+      if (info()->bailout_reason() != kNoReason) return false;
       RunPrintAndVerify("OSR deconstruction");
     }
   }
 
   // Lower any remaining generic JSOperators.
   Run<GenericLoweringPhase>();
   // TODO(jarin, rossberg): Remove UNTYPED once machine typing works.
   RunPrintAndVerify("Lowered generic", true);
 
   BeginPhaseKind("block building");
 
-  data.source_positions()->RemoveDecorator();
-
-  return ScheduleAndGenerateCode(
-      Linkage::ComputeIncoming(data.instruction_zone(), info()));
+  data()->source_positions()->RemoveDecorator();
+  return true;
 }
 
 
+bool Pipeline::OptimizeGraph() {
+  return ScheduleAndAllocateRegisters(
+      Linkage::ComputeIncoming(data()->instruction_zone(), info()));
+}
+
+
+Handle<Code> Pipeline::GenerateCode() {
+  if (!CreateGraph()) return Handle<Code>::null();
+  return ScheduleAndGenerateCode(
+      Linkage::ComputeIncoming(data()->instruction_zone(), info()));
+}
+
+
 Handle<Code> Pipeline::GenerateCodeForTesting(CompilationInfo* info,
                                               Graph* graph,
                                               Schedule* schedule) {
   CallDescriptor* call_descriptor =
       Linkage::ComputeIncoming(info->zone(), info);
   return GenerateCodeForTesting(info, call_descriptor, graph, schedule);
 }
 
 
 Handle<Code> Pipeline::GenerateCodeForTesting(Isolate* isolate,
                                               CallDescriptor* call_descriptor,
                                               Graph* graph,
                                               Schedule* schedule) {
   FakeStubForTesting stub(isolate);
   CompilationInfo info(&stub, isolate, graph->zone());
   return GenerateCodeForTesting(&info, call_descriptor, graph, schedule);
 }
 
 
 Handle<Code> Pipeline::GenerateCodeForTesting(CompilationInfo* info,
                                               CallDescriptor* call_descriptor,
                                               Graph* graph,
                                               Schedule* schedule) {
   // Construct a pipeline for scheduling and code generation.
-  ZonePool zone_pool;
-  PipelineData data(&zone_pool, info, graph, schedule);
+  PipelineData* data = new PipelineData(info, graph, schedule);
   SmartPointer<PipelineStatistics> pipeline_statistics;
   if (FLAG_turbo_stats) {
-    pipeline_statistics.Reset(new PipelineStatistics(info, &zone_pool));
+    pipeline_statistics.Reset(new PipelineStatistics(info, data->zone_pool()));
     pipeline_statistics->BeginPhaseKind("test codegen");
   }
 
-  Pipeline pipeline(info);
-  pipeline.data_ = &data;
-  if (data.schedule() == nullptr) {
+  Pipeline pipeline(data);
+  if (data->schedule() == nullptr) {
     // TODO(rossberg): Should this really be untyped?
     pipeline.RunPrintAndVerify("Machine", true);
   }
 
   return pipeline.ScheduleAndGenerateCode(call_descriptor);
 }
 
 
 bool Pipeline::AllocateRegistersForTesting(const RegisterConfiguration* config,
                                            InstructionSequence* sequence,
                                            bool run_verifier) {
   FakeStubForTesting stub(sequence->isolate());
   CompilationInfo info(&stub, sequence->isolate(), sequence->zone());
-  ZonePool zone_pool;
-  PipelineData data(&zone_pool, &info, sequence);
-  Pipeline pipeline(&info);
-  pipeline.data_ = &data;
+  PipelineData* data = new PipelineData(&info, sequence);
+  Pipeline pipeline(data);
   pipeline.AllocateRegisters(config, run_verifier);
-  return !data.compilation_failed();
+  return !data->compilation_failed();
 }
 
 
-Handle<Code> Pipeline::ScheduleAndGenerateCode(
-    CallDescriptor* call_descriptor) {
-  PipelineData* data = this->data_;
+bool Pipeline::ScheduleAndAllocateRegisters(CallDescriptor* call_descriptor) {
+  PipelineData* data = this->data();
 
   DCHECK_NOT_NULL(data->graph());
   CHECK(SupportedBackend());
 
   if (data->schedule() == nullptr) Run<ComputeSchedulePhase>();
   TraceSchedule(data->info(), data->schedule());
 
-  BasicBlockProfiler::Data* profiler_data = NULL;
-  if (FLAG_turbo_profiling) {
-    profiler_data = BasicBlockInstrumentor::Instrument(info(), data->graph(),
-                                                       data->schedule());
-  }
-
   data->InitializeInstructionSequence();
 
   // Select and schedule instructions covering the scheduled graph.
-  Linkage linkage(call_descriptor);
-  Run<InstructionSelectionPhase>(&linkage);
+  data->set_linkage(new (data->info()->zone()) Linkage(call_descriptor));
+  Run<InstructionSelectionPhase>();
 
   if (FLAG_trace_turbo && !data->MayHaveUnverifiableGraph()) {
     TurboCfgFile tcf(isolate());
     tcf << AsC1V("CodeGen", data->schedule(), data->source_positions(),
                  data->sequence());
   }
 
-  std::ostringstream source_position_output;
   if (FLAG_trace_turbo) {
     // Output source position information before the graph is deleted.
-    data_->source_positions()->Print(source_position_output);
+    data->source_positions()->Print(data->source_position_output());
   }
 
   data->DeleteGraphZone();
 
   BeginPhaseKind("register allocation");
 
   bool run_verifier = FLAG_turbo_verify_allocation;
   // Allocate registers.
   AllocateRegisters(RegisterConfiguration::ArchDefault(), run_verifier);
   if (data->compilation_failed()) {
     info()->AbortOptimization(kNotEnoughVirtualRegistersRegalloc);
-    return Handle<Code>();
+    return false;
   }
 
   BeginPhaseKind("code generation");
 
   // Optimimize jumps.
   if (FLAG_turbo_jt) {
     Run<JumpThreadingPhase>();
   }
 
+  return true;
+}
+
+
+Handle<Code> Pipeline::DoGenerateCode() {
+  PipelineData* data = this->data_;
+
   // Generate final machine code.
-  Run<GenerateCodePhase>(&linkage);
+  Run<GenerateCodePhase>();
 
   Handle<Code> code = data->code();
-  if (profiler_data != NULL) {
+  if (data->profiler_data()) {
 #if ENABLE_DISASSEMBLER
     std::ostringstream os;
     code->Disassemble(NULL, os);
-    profiler_data->SetCode(&os);
+    data->profiler_data()->SetCode(&os);
 #endif
   }
 
   info()->SetCode(code);
   v8::internal::CodeGenerator::PrintCode(code, info());
 
   if (FLAG_trace_turbo) {
     FILE* json_file = OpenVisualizerLogFile(info(), NULL, "json", "a+");
     if (json_file != nullptr) {
       OFStream json_of(json_file);
       json_of
           << "{\"name\":\"disassembly\",\"type\":\"disassembly\",\"data\":\"";
 #if ENABLE_DISASSEMBLER
       std::stringstream disassembly_stream;
       code->Disassemble(NULL, disassembly_stream);
       std::string disassembly_string(disassembly_stream.str());
       for (const auto& c : disassembly_string) {
         json_of << AsEscapedUC16ForJSON(c);
       }
 #endif  // ENABLE_DISASSEMBLER
       json_of << "\"}\n],\n";
       json_of << "\"nodePositions\":";
-      json_of << source_position_output.str();
+      json_of << data->source_position_output().str();
       json_of << "}";
       fclose(json_file);
     }
     OFStream os(stdout);
     os << "---------------------------------------------------\n"
        << "Finished compiling method " << GetDebugName(info()).get()
        << " using Turbofan" << std::endl;
   }
 
   return code;
 }
 
 
+Handle<Code> Pipeline::ScheduleAndGenerateCode(
+    CallDescriptor* call_descriptor) {
+  if (!ScheduleAndAllocateRegisters(call_descriptor)) {
+    return Handle<Code>::null();
+  }
+  return DoGenerateCode();
+}
+
+
 void Pipeline::AllocateRegisters(const RegisterConfiguration* config,
                                  bool run_verifier) {
-  PipelineData* data = this->data_;
+  PipelineData* data = this->data();
 
   // Don't track usage for this zone in compiler stats.
   SmartPointer<Zone> verifier_zone;
   RegisterAllocatorVerifier* verifier = nullptr;
   if (run_verifier) {
     verifier_zone.Reset(new Zone());
     verifier = new (verifier_zone.get()) RegisterAllocatorVerifier(
         verifier_zone.get(), config, data->sequence());
   }
 
@@ skipping 60 matching lines @@
     tcf << AsC1VRegisterAllocationData("CodeGen",
                                        data->register_allocation_data());
   }
 
   data->DeleteRegisterAllocationZone();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8