v8::internal::compiler::Pipeline Class Reference

#include <pipeline.h>

Collaboration diagram for v8::internal::compiler::Pipeline:

Public Member Functions
	Pipeline (CompilationInfo *info)
Handle< Code >	GenerateCode ()
Handle< Code >	GenerateCodeForMachineGraph (Linkage *linkage, Graph *graph, Schedule *schedule=NULL)

Static Public Member Functions
static bool	SupportedBackend ()
static bool	SupportedTarget ()
static void	SetUp ()
static void	TearDown ()

Private Member Functions
CompilationInfo *	info () const
Isolate *	isolate ()
Zone *	zone ()
Schedule *	ComputeSchedule (Graph *graph)
void	VerifyAndPrintGraph (Graph *graph, const char *phase)
Handle< Code >	GenerateCode (Linkage *linkage, Graph *graph, Schedule *schedule, SourcePositionTable *source_positions)

Private Attributes
CompilationInfo *	info_

Detailed Description

Definition at line 25 of file pipeline.h.

Constructor & Destructor Documentation

Pipeline()

v8::internal::compiler::Pipeline::Pipeline ( CompilationInfo *  info )

inlineexplicit

Definition at line 27 of file pipeline.h.

: info_(info) {}

Member Function Documentation

ComputeSchedule()

Schedule * v8::internal::compiler::Pipeline::ComputeSchedule ( Graph *  graph )

private

Definition at line 347 of file pipeline.cc.

                                                {
  PhaseStats schedule_stats(info(), PhaseStats::CODEGEN, "scheduling");
  Schedule* schedule = Scheduler::ComputeSchedule(graph);
  TraceSchedule(schedule);
  if (VerifyGraphs()) ScheduleVerifier::Run(schedule);
  return schedule;
}

References v8::internal::compiler::PhaseStats::CODEGEN, v8::internal::compiler::Scheduler::ComputeSchedule(), info(), v8::internal::compiler::ScheduleVerifier::Run(), v8::internal::compiler::TraceSchedule(), and v8::internal::compiler::VerifyGraphs().

Referenced by GenerateCode(), and GenerateCodeForMachineGraph().

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateCode() [1/2]

Handle< Code > v8::internal::compiler::Pipeline::GenerateCode

(

)

Definition at line 166 of file pipeline.cc.

                                    {
  if (info()->function()->dont_optimize_reason() == kTryCatchStatement ||
      info()->function()->dont_optimize_reason() == kTryFinallyStatement ||
      // TODO(turbofan): Make ES6 for-of work and remove this bailout.
      info()->function()->dont_optimize_reason() == kForOfStatement ||
      // TODO(turbofan): Make super work and remove this bailout.
      info()->function()->dont_optimize_reason() == kSuperReference ||
      // TODO(turbofan): Make OSR work and remove this bailout.
      info()->is_osr()) {
    return Handle<Code>::null();
  }
 
  if (FLAG_turbo_stats) isolate()->GetTStatistics()->Initialize(info_);
 
  if (FLAG_trace_turbo) {
    OFStream os(stdout);
    os << "---------------------------------------------------\n"
       << "Begin compiling method "
       << info()->function()->debug_name()->ToCString().get()
       << " using Turbofan" << endl;
  }
 
  // Build the graph.
  Graph graph(zone());
  SourcePositionTable source_positions(&graph);
  source_positions.AddDecorator();
  // TODO(turbofan): there is no need to type anything during initial graph
  // construction.  This is currently only needed for the node cache, which the
  // typer could sweep over later.
  Typer typer(zone());
  MachineOperatorBuilder machine;
  CommonOperatorBuilder common(zone());
  JSOperatorBuilder javascript(zone());
  JSGraph jsgraph(&graph, &common, &javascript, &typer, &machine);
  Node* context_node;
  {
    PhaseStats graph_builder_stats(info(), PhaseStats::CREATE_GRAPH,
                                   "graph builder");
    AstGraphBuilderWithPositions graph_builder(info(), &jsgraph,
                                               &source_positions);
    graph_builder.CreateGraph();
    context_node = graph_builder.GetFunctionContext();
  }
  {
    PhaseStats phi_reducer_stats(info(), PhaseStats::CREATE_GRAPH,
                                 "phi reduction");
    PhiReducer phi_reducer;
    GraphReducer graph_reducer(&graph);
    graph_reducer.AddReducer(&phi_reducer);
    graph_reducer.ReduceGraph();
    // TODO(mstarzinger): Running reducer once ought to be enough for everyone.
    graph_reducer.ReduceGraph();
    graph_reducer.ReduceGraph();
  }
 
  VerifyAndPrintGraph(&graph, "Initial untyped");
 
  if (info()->is_context_specializing()) {
    SourcePositionTable::Scope pos(&source_positions,
                                   SourcePosition::Unknown());
    // Specialize the code to the context as aggressively as possible.
    JSContextSpecializer spec(info(), &jsgraph, context_node);
    spec.SpecializeToContext();
    VerifyAndPrintGraph(&graph, "Context specialized");
  }
 
  if (info()->is_inlining_enabled()) {
    SourcePositionTable::Scope pos(&source_positions,
                                   SourcePosition::Unknown());
    JSInliner inliner(info(), &jsgraph);
    inliner.Inline();
    VerifyAndPrintGraph(&graph, "Inlined");
  }
 
  // Print a replay of the initial graph.
  if (FLAG_print_turbo_replay) {
    GraphReplayPrinter::PrintReplay(&graph);
  }
 
  // Bailout here in case target architecture is not supported.
  if (!SupportedTarget()) return Handle<Code>::null();
 
  if (info()->is_typing_enabled()) {
    {
      // Type the graph.
      PhaseStats typer_stats(info(), PhaseStats::CREATE_GRAPH, "typer");
      typer.Run(&graph, info()->context());
      VerifyAndPrintGraph(&graph, "Typed");
    }
    // All new nodes must be typed.
    typer.DecorateGraph(&graph);
    {
      // Lower JSOperators where we can determine types.
      PhaseStats lowering_stats(info(), PhaseStats::CREATE_GRAPH,
                                "typed lowering");
      SourcePositionTable::Scope pos(&source_positions,
                                     SourcePosition::Unknown());
      JSTypedLowering lowering(&jsgraph);
      GraphReducer graph_reducer(&graph);
      graph_reducer.AddReducer(&lowering);
      graph_reducer.ReduceGraph();
 
      VerifyAndPrintGraph(&graph, "Lowered typed");
    }
    {
      // Lower simplified operators and insert changes.
      PhaseStats lowering_stats(info(), PhaseStats::CREATE_GRAPH,
                                "simplified lowering");
      SourcePositionTable::Scope pos(&source_positions,
                                     SourcePosition::Unknown());
      SimplifiedLowering lowering(&jsgraph);
      lowering.LowerAllNodes();
 
      VerifyAndPrintGraph(&graph, "Lowered simplified");
    }
    {
      // Lower changes that have been inserted before.
      PhaseStats lowering_stats(info(), PhaseStats::OPTIMIZATION,
                                "change lowering");
      SourcePositionTable::Scope pos(&source_positions,
                                     SourcePosition::Unknown());
      Linkage linkage(info());
      // TODO(turbofan): Value numbering disabled for now.
      // ValueNumberingReducer vn_reducer(zone());
      SimplifiedOperatorReducer simple_reducer(&jsgraph);
      ChangeLowering lowering(&jsgraph, &linkage);
      MachineOperatorReducer mach_reducer(&jsgraph);
      GraphReducer graph_reducer(&graph);
      // TODO(titzer): Figure out if we should run all reducers at once here.
      // graph_reducer.AddReducer(&vn_reducer);
      graph_reducer.AddReducer(&simple_reducer);
      graph_reducer.AddReducer(&lowering);
      graph_reducer.AddReducer(&mach_reducer);
      graph_reducer.ReduceGraph();
 
      VerifyAndPrintGraph(&graph, "Lowered changes");
    }
  }
 
  {
    // Lower any remaining generic JSOperators.
    PhaseStats lowering_stats(info(), PhaseStats::CREATE_GRAPH,
                              "generic lowering");
    SourcePositionTable::Scope pos(&source_positions,
                                   SourcePosition::Unknown());
    JSGenericLowering lowering(info(), &jsgraph);
    GraphReducer graph_reducer(&graph);
    graph_reducer.AddReducer(&lowering);
    graph_reducer.ReduceGraph();
 
    VerifyAndPrintGraph(&graph, "Lowered generic");
  }
 
  source_positions.RemoveDecorator();
 
  Handle<Code> code = Handle<Code>::null();
  {
    // Compute a schedule.
    Schedule* schedule = ComputeSchedule(&graph);
    // Generate optimized code.
    PhaseStats codegen_stats(info(), PhaseStats::CODEGEN, "codegen");
    Linkage linkage(info());
    code = GenerateCode(&linkage, &graph, schedule, &source_positions);
    info()->SetCode(code);
  }
 
  // Print optimized code.
  v8::internal::CodeGenerator::PrintCode(code, info());
 
  if (FLAG_trace_turbo) {
    OFStream os(stdout);
    os << "--------------------------------------------------\n"
       << "Finished compiling method "
       << info()->function()->debug_name()->ToCString().get()
       << " using Turbofan" << endl;
  }
 
  return code;
}

References v8::internal::compiler::PhaseStats::CODEGEN, ComputeSchedule(), v8::internal::compiler::PhaseStats::CREATE_GRAPH, v8::internal::compiler::AstGraphBuilderWithPositions::CreateGraph(), v8::internal::compiler::Typer::DecorateGraph(), v8::internal::endl(), v8::internal::CompilationInfo::function(), v8::internal::compiler::AstGraphBuilder::GetFunctionContext(), v8::internal::Isolate::GetTStatistics(), info(), info_, v8::internal::compiler::JSInliner::Inline(), isolate(), v8::internal::compiler::SimplifiedLowering::LowerAllNodes(), v8::internal::Handle< T >::null(), v8::internal::compiler::PhaseStats::OPTIMIZATION, v8::internal::CodeGenerator::PrintCode(), v8::internal::compiler::Typer::Run(), v8::internal::CompilationInfo::SetCode(), v8::internal::compiler::JSContextSpecializer::SpecializeToContext(), SupportedTarget(), VerifyAndPrintGraph(), and zone().

Referenced by v8::internal::OptimizedCompileJob::CreateGraph(), and GenerateCodeForMachineGraph().

Here is the call graph for this function:

Here is the caller graph for this function:

GenerateCode() [2/2]

Handle< Code > v8::internal::compiler::Pipeline::GenerateCode ( Linkage *  linkage, Graph *  graph, Schedule *  schedule, SourcePositionTable *  source_positions  )

private

Definition at line 379 of file pipeline.cc.

                                                                           {
  DCHECK_NOT_NULL(graph);
  DCHECK_NOT_NULL(linkage);
  DCHECK_NOT_NULL(schedule);
  CHECK(SupportedBackend());
 
  BasicBlockProfiler::Data* profiler_data = NULL;
  if (FLAG_turbo_profiling) {
    profiler_data = BasicBlockInstrumentor::Instrument(info_, graph, schedule);
  }
 
  InstructionSequence sequence(linkage, graph, schedule);
 
  // Select and schedule instructions covering the scheduled graph.
  {
    InstructionSelector selector(&sequence, source_positions);
    selector.SelectInstructions();
  }
 
  if (FLAG_trace_turbo) {
    OFStream os(stdout);
    os << "----- Instruction sequence before register allocation -----\n"
       << sequence;
  }
 
  // Allocate registers.
  {
    int node_count = graph->NodeCount();
    if (node_count > UnallocatedOperand::kMaxVirtualRegisters) {
      linkage->info()->AbortOptimization(kNotEnoughVirtualRegistersForValues);
      return Handle<Code>::null();
    }
    RegisterAllocator allocator(&sequence);
    if (!allocator.Allocate()) {
      linkage->info()->AbortOptimization(kNotEnoughVirtualRegistersRegalloc);
      return Handle<Code>::null();
    }
  }
 
  if (FLAG_trace_turbo) {
    OFStream os(stdout);
    os << "----- Instruction sequence after register allocation -----\n"
       << sequence;
  }
 
  // Generate native sequence.
  CodeGenerator generator(&sequence);
  Handle<Code> code = generator.GenerateCode();
  if (profiler_data != NULL) {
#if ENABLE_DISASSEMBLER
    OStringStream os;
    code->Disassemble(NULL, os);
    profiler_data->SetCode(&os);
#endif
  }
  return code;
}

References v8::internal::CompilationInfo::AbortOptimization(), CHECK, DCHECK_NOT_NULL, v8::internal::compiler::Linkage::info(), info_, v8::internal::compiler::BasicBlockInstrumentor::Instrument(), v8::internal::compiler::UnallocatedOperand::kMaxVirtualRegisters, v8::internal::compiler::GenericGraphBase::NodeCount(), NULL, v8::internal::Handle< T >::null(), v8::internal::BasicBlockProfiler::Data::SetCode(), and SupportedBackend().

Here is the call graph for this function:

GenerateCodeForMachineGraph()

Handle< Code > v8::internal::compiler::Pipeline::GenerateCodeForMachineGraph	(	Linkage *	linkage,
		Graph *	graph,
		Schedule *	schedule = NULL
	)

Definition at line 356 of file pipeline.cc.

                                                                       {
  CHECK(SupportedBackend());
  if (schedule == NULL) {
    VerifyAndPrintGraph(graph, "Machine");
    schedule = ComputeSchedule(graph);
  }
  TraceSchedule(schedule);
 
  SourcePositionTable source_positions(graph);
  Handle<Code> code = GenerateCode(linkage, graph, schedule, &source_positions);
#if ENABLE_DISASSEMBLER
  if (!code.is_null() && FLAG_print_opt_code) {
    CodeTracer::Scope tracing_scope(isolate()->GetCodeTracer());
    OFStream os(tracing_scope.file());
    code->Disassemble("test code", os);
  }
#endif
  return code;
}

References CHECK, ComputeSchedule(), GenerateCode(), v8::internal::Handle< T >::is_null(), isolate(), NULL, SupportedBackend(), v8::internal::compiler::TraceSchedule(), and VerifyAndPrintGraph().

Here is the call graph for this function:

info()

CompilationInfo* v8::internal::compiler::Pipeline::info ( ) const

inlineprivate

Definition at line 46 of file pipeline.h.

{ return info_; }

References info_.

Referenced by ComputeSchedule(), and GenerateCode().

Here is the caller graph for this function:

isolate()

Isolate* v8::internal::compiler::Pipeline::isolate ( )

inlineprivate

Definition at line 47 of file pipeline.h.

{ return info_->isolate(); }

References info_, and v8::internal::CompilationInfo::isolate().

Referenced by GenerateCode(), and GenerateCodeForMachineGraph().

Here is the call graph for this function:

Here is the caller graph for this function:

SetUp()

void v8::internal::compiler::Pipeline::SetUp ( )

static

Definition at line 440 of file pipeline.cc.

                     {
  InstructionOperand::SetUpCaches();
}

References v8::internal::compiler::InstructionOperand::SetUpCaches().

Referenced by v8::internal::V8::InitializeOncePerProcessImpl().

Here is the call graph for this function:

Here is the caller graph for this function:

SupportedBackend()

static bool v8::internal::compiler::Pipeline::SupportedBackend ( )

inlinestatic

Definition at line 37 of file pipeline.h.

{ return V8_TURBOFAN_BACKEND != 0; }

References V8_TURBOFAN_BACKEND.

Referenced by GenerateCode(), and GenerateCodeForMachineGraph().

Here is the caller graph for this function:

SupportedTarget()

static bool v8::internal::compiler::Pipeline::SupportedTarget ( )

inlinestatic

Definition at line 38 of file pipeline.h.

{ return V8_TURBOFAN_TARGET != 0; }

References V8_TURBOFAN_TARGET.

Referenced by GenerateCode().

Here is the caller graph for this function:

TearDown()

void v8::internal::compiler::Pipeline::TearDown ( )

static

Definition at line 445 of file pipeline.cc.

                        {
  InstructionOperand::TearDownCaches();
}

References v8::internal::compiler::InstructionOperand::TearDownCaches().

Referenced by v8::internal::V8::TearDown().

Here is the call graph for this function:

Here is the caller graph for this function:

VerifyAndPrintGraph()

void v8::internal::compiler::Pipeline::VerifyAndPrintGraph ( Graph *  graph, const char *  phase  )

private

Definition at line 91 of file pipeline.cc.

                                                                  {
  if (FLAG_trace_turbo) {
    char buffer[256];
    Vector<char> filename(buffer, sizeof(buffer));
    if (!info_->shared_info().is_null()) {
      SmartArrayPointer<char> functionname =
          info_->shared_info()->DebugName()->ToCString();
      if (strlen(functionname.get()) > 0) {
        SNPrintF(filename, "turbo-%s-%s", functionname.get(), phase);
      } else {
        SNPrintF(filename, "turbo-%p-%s", static_cast<void*>(info_), phase);
      }
    } else {
      SNPrintF(filename, "turbo-none-%s", phase);
    }
    std::replace(filename.start(), filename.start() + filename.length(), ' ',
                 '_');
 
    char dot_buffer[256];
    Vector<char> dot_filename(dot_buffer, sizeof(dot_buffer));
    SNPrintF(dot_filename, "%s.dot", filename.start());
    FILE* dot_file = base::OS::FOpen(dot_filename.start(), "w+");
    OFStream dot_of(dot_file);
    dot_of << AsDOT(*graph);
    fclose(dot_file);
 
    char json_buffer[256];
    Vector<char> json_filename(json_buffer, sizeof(json_buffer));
    SNPrintF(json_filename, "%s.json", filename.start());
    FILE* json_file = base::OS::FOpen(json_filename.start(), "w+");
    OFStream json_of(json_file);
    json_of << AsJSON(*graph);
    fclose(json_file);
 
    OFStream os(stdout);
    os << "-- " << phase << " graph printed to file " << filename.start()
       << "\n";
  }
  if (VerifyGraphs()) Verifier::Run(graph);
}

References v8::base::OS::FOpen(), v8::internal::SmartPointerBase< Deallocator, T >::get(), info_, v8::internal::Vector< T >::length(), v8::internal::compiler::Verifier::Run(), v8::internal::CompilationInfo::shared_info(), v8::internal::SNPrintF(), v8::internal::Vector< T >::start(), and v8::internal::compiler::VerifyGraphs().

Referenced by GenerateCode(), and GenerateCodeForMachineGraph().

Here is the call graph for this function:

Here is the caller graph for this function:

zone()

Zone* v8::internal::compiler::Pipeline::zone ( )

inlineprivate

Definition at line 48 of file pipeline.h.

{ return info_->zone(); }

References info_, and v8::internal::CompilationInfo::zone().

Referenced by GenerateCode().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

info_

CompilationInfo* v8::internal::compiler::Pipeline::info_

private

Definition at line 44 of file pipeline.h.

Referenced by GenerateCode(), info(), isolate(), VerifyAndPrintGraph(), and zone().

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/compiler/pipeline.h
• /mnt/V8SourceCode/src/compiler/pipeline.cc