[turbofan] basic block profiler

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 "src/base/platform/elapsed-timer.h"
 #include "src/compiler/ast-graph-builder.h"
+#include "src/compiler/basic-block-instrumentor.h"
 #include "src/compiler/change-lowering.h"
 #include "src/compiler/code-generator.h"
 #include "src/compiler/graph-replay.h"
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/instruction.h"
 #include "src/compiler/instruction-selector.h"
 #include "src/compiler/js-context-specialization.h"
 #include "src/compiler/js-generic-lowering.h"
 #include "src/compiler/js-inlining.h"
 #include "src/compiler/js-typed-lowering.h"
@@ skipping 276 matching lines @@
       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();
+
     {
       // 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);
     }
 
@@ skipping 46 matching lines @@
 
 
 Handle<Code> Pipeline::GenerateCode(Linkage* linkage, Graph* graph,
                                     Schedule* schedule,
                                     SourcePositionTable* source_positions) {
   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);
@@ skipping 16 matching lines @@
   }
 
   if (FLAG_trace_turbo) {
     OFStream os(stdout);
     os << "----- Instruction sequence after register allocation -----\n"
        << sequence;
   }
 
   // Generate native sequence.
   CodeGenerator generator(&sequence);
-  return generator.GenerateCode();
+  Handle<Code> code = generator.GenerateCode();
+  if (profiler_data != NULL) {
+#if ENABLE_DISASSEMBLER
+    OStringStream os;
+    code->Disassemble(NULL, os);

[titzer, 2014/09/24 14:59:31]

Why do we need to eagerly disassemble the code?

[dcarney, 2014/09/25 08:15:15]

there's no heap pointers kept alive in the profiler, so a code dump here is
needed for later output.

+    profiler_data->SetCode(&os);
+#endif
+  }
+  return code;
 }
 
 
 void Pipeline::SetUp() {
   InstructionOperand::SetUpCaches();
 }
 
 
 void Pipeline::TearDown() {
   InstructionOperand::TearDownCaches();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8