[turbofan] Move some member methods off Pipeline.

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 269 matching lines @@
   }
 
   void InitializeRegisterAllocationData(const RegisterConfiguration* config,
                                         CallDescriptor* descriptor) {
     DCHECK(register_allocation_data_ == nullptr);
     register_allocation_data_ = new (register_allocation_zone())
         RegisterAllocationData(config, register_allocation_zone(), frame(),
                                sequence(), debug_name_.get());
   }
 
+  void BeginPhaseKind(const char* phase_kind_name) {
+    if (pipeline_statistics() != nullptr) {
+      pipeline_statistics()->BeginPhaseKind(phase_kind_name);
+    }
+  }
+
+  void EndPhaseKind() {
+    if (pipeline_statistics() != nullptr) {
+      pipeline_statistics()->EndPhaseKind();
+    }
+  }
+
  private:
   Isolate* const isolate_;
   CompilationInfo* const info_;
   base::SmartArrayPointer<char> debug_name_;
   Zone* outer_zone_ = nullptr;
   ZonePool* const zone_pool_;
   PipelineStatistics* pipeline_statistics_ = nullptr;
   bool compilation_failed_ = false;
   Handle<Code> code_ = Handle<Code>::null();
 
@@ skipping 977 matching lines @@
   static const char* phase_name() { return nullptr; }
 
   void Run(PipelineData* data, Zone* temp_zone, const bool untyped,
            bool values_only = false) {
     Verifier::Run(data->graph(), !untyped ? Verifier::TYPED : Verifier::UNTYPED,
                   values_only ? Verifier::kValuesOnly : Verifier::kAll);
   }
 };
 
 
-void Pipeline::BeginPhaseKind(const char* phase_kind_name) {
-  if (data_->pipeline_statistics() != nullptr) {
-    data_->pipeline_statistics()->BeginPhaseKind(phase_kind_name);
-  }
-}
-
-void Pipeline::EndPhaseKind() {
-  if (data_->pipeline_statistics() != nullptr) {
-    data_->pipeline_statistics()->EndPhaseKind();
-  }
-}
-
 void Pipeline::RunPrintAndVerify(const char* phase, bool untyped) {
   if (FLAG_trace_turbo) {
     Run<PrintGraphPhase>(phase);
   }
   if (FLAG_turbo_verify) {
     Run<VerifyGraphPhase>(untyped);
   }
 }
 
 bool Pipeline::CreateGraph() {
   PipelineData* data = this->data_;
 
-  BeginPhaseKind("graph creation");
+  data->BeginPhaseKind("graph creation");
 
   if (FLAG_trace_turbo) {
     OFStream os(stdout);
     os << "---------------------------------------------------\n"
        << "Begin compiling method " << info()->GetDebugName().get()
        << " using Turbofan" << std::endl;
     TurboCfgFile tcf(isolate());
     tcf << AsC1VCompilation(info());
   }
 
   data->source_positions()->AddDecorator();
 
   if (FLAG_loop_assignment_analysis) {
     Run<LoopAssignmentAnalysisPhase>();
   }
 
   Run<TypeHintAnalysisPhase>();
 
   Run<GraphBuilderPhase>();
   if (data->compilation_failed()) {
-    EndPhaseKind();
+    data->EndPhaseKind();
     return false;
   }
   RunPrintAndVerify("Initial untyped", true);
 
   // Perform OSR deconstruction.
   if (info()->is_osr()) {
     Run<OsrDeconstructionPhase>();
     RunPrintAndVerify("OSR deconstruction", true);
   }
 
@@ skipping 15 matching lines @@
     // Type the graph and keep the Typer running on newly created nodes within
     // this scope; the Typer is automatically unlinked from the Graph once we
     // leave this scope below.
     Typer typer(isolate(), data->graph(), info()->is_deoptimization_enabled()
                                               ? Typer::kDeoptimizationEnabled
                                               : Typer::kNoFlags,
                 info()->dependencies());
     Run<TyperPhase>(&typer);
     RunPrintAndVerify("Typed");
 
-    BeginPhaseKind("lowering");
+    data->BeginPhaseKind("lowering");
 
     // Lower JSOperators where we can determine types.
     Run<TypedLoweringPhase>();
     RunPrintAndVerify("Lowered typed");
 
     if (FLAG_turbo_stress_loop_peeling) {
       Run<StressLoopPeelingPhase>();
       RunPrintAndVerify("Loop peeled");
     }
 
@@ skipping 21 matching lines @@
   //      selection due to the way we handle truncations; if we'd want to look
   //      at types afterwards we'd essentially need to re-type (large portions
   //      of) the graph.
   //
   // In order to catch bugs related to type access after this point we remove
   // the types from the nodes at this point (currently only in Debug builds).
   Run<UntyperPhase>();
   RunPrintAndVerify("Untyped", true);
 #endif
 
-  EndPhaseKind();
+  data->EndPhaseKind();
 
   return true;
 }
 
 bool Pipeline::OptimizeGraph(Linkage* linkage) {
   PipelineData* data = this->data_;
 
-  BeginPhaseKind("block building");
+  data->BeginPhaseKind("block building");
 
   Run<EffectControlLinearizationPhase>();
   RunPrintAndVerify("Effect and control linearized", true);
 
   Run<BranchEliminationPhase>();
   RunPrintAndVerify("Branch conditions eliminated", true);
 
   // Optimize control flow.
   if (FLAG_turbo_cf_optimization) {
     Run<ControlFlowOptimizationPhase>();
     RunPrintAndVerify("Control flow optimized", true);
   }
 
   // Lower changes that have been inserted before.
   Run<LateOptimizationPhase>();
   // TODO(jarin, rossberg): Remove UNTYPED once machine typing works.
   RunPrintAndVerify("Late optimized", true);
 
   Run<LateGraphTrimmingPhase>();
   // TODO(jarin, rossberg): Remove UNTYPED once machine typing works.
   RunPrintAndVerify("Late trimmed", true);
 
   data->source_positions()->RemoveDecorator();
 
   return ScheduleAndSelectInstructions(linkage);
 }
 
-Handle<Code> Pipeline::GenerateCode() {
-  PipelineData* data = this->data_;
-
-  Linkage linkage(Linkage::ComputeIncoming(data->instruction_zone(), info()));
-
-  if (!CreateGraph()) return Handle<Code>::null();
-  if (!OptimizeGraph(&linkage)) return Handle<Code>::null();
-  return GenerateCode(&linkage);
-}
-
 Handle<Code> Pipeline::GenerateCodeForCodeStub(Isolate* isolate,
                                                CallDescriptor* call_descriptor,
                                                Graph* graph, Schedule* schedule,
                                                Code::Flags flags,
                                                const char* debug_name) {
   CompilationInfo info(CStrVector(debug_name), isolate, graph->zone(), flags);
 
   // Construct a pipeline for scheduling and code generation.
   ZonePool zone_pool(isolate->allocator());
   PipelineData data(&zone_pool, &info, graph, schedule);
@@ skipping 21 matching lines @@
   return pipeline.ScheduleAndGenerateCode(call_descriptor);
 }
 
 // static
 Handle<Code> Pipeline::GenerateCodeForTesting(CompilationInfo* info) {
   ZonePool zone_pool(info->isolate()->allocator());
   base::SmartPointer<PipelineStatistics> pipeline_statistics(
       CreatePipelineStatistics(info, &zone_pool));
   PipelineData data(&zone_pool, info, pipeline_statistics.get());
   Pipeline pipeline(&data);
-  return pipeline.GenerateCode();
+
+  Linkage linkage(Linkage::ComputeIncoming(data.instruction_zone(), info));
+
+  if (!pipeline.CreateGraph()) return Handle<Code>::null();
+  if (!pipeline.OptimizeGraph(&linkage)) return Handle<Code>::null();
+  return pipeline.GenerateCode(&linkage);
 }
 
 // static
 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);
 }
@@ skipping 83 matching lines @@
 
   if (FLAG_trace_turbo) {
     std::ostringstream source_position_output;
     // Output source position information before the graph is deleted.
     data_->source_positions()->Print(source_position_output);
     data_->set_source_position_output(source_position_output.str());
   }
 
   data->DeleteGraphZone();
 
-  BeginPhaseKind("register allocation");
+  data->BeginPhaseKind("register allocation");
 
   bool run_verifier = FLAG_turbo_verify_allocation;
 
   // Allocate registers.
   AllocateRegisters(
       RegisterConfiguration::ArchDefault(RegisterConfiguration::TURBOFAN),
       call_descriptor, run_verifier);
   Run<FrameElisionPhase>();
   if (data->compilation_failed()) {
     info()->AbortOptimization(kNotEnoughVirtualRegistersRegalloc);
-    EndPhaseKind();
+    data->EndPhaseKind();
     return false;
   }
 
   // TODO(mtrofin): move this off to the register allocator.
   bool generate_frame_at_start =
       data_->sequence()->instruction_blocks().front()->must_construct_frame();
   // Optimimize jumps.
   if (FLAG_turbo_jt) {
     Run<JumpThreadingPhase>(generate_frame_at_start);
   }
 
-  EndPhaseKind();
+  data->EndPhaseKind();
 
   return true;
 }
 
 Handle<Code> Pipeline::GenerateCode(Linkage* linkage) {
   PipelineData* data = this->data_;
 
-  BeginPhaseKind("code generation");
+  data->BeginPhaseKind("code generation");
 
   // Generate final machine code.
   Run<GenerateCodePhase>(linkage);
 
   Handle<Code> code = data->code();
   if (data->profiler_data()) {
 #if ENABLE_DISASSEMBLER
     std::ostringstream os;
     code->Disassemble(nullptr, os);
     data->profiler_data()->SetCode(&os);
@@ skipping 132 matching lines @@
   data->DeleteRegisterAllocationZone();
 }
 
 CompilationInfo* Pipeline::info() const { return data_->info(); }
 
 Isolate* Pipeline::isolate() const { return info()->isolate(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8