CpuProfiler: push the collected information about deopts to cpu profiler

src/compiler.cc

 // Copyright 2012 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.h"
 
 #include <algorithm>
 
 #include "src/ast-numbering.h"
 #include "src/bootstrapper.h"
@@ skipping 105 matching lines @@
     : parse_info_(parse_info),
       isolate_(isolate),
       flags_(0),
       code_stub_(code_stub),
       mode_(mode),
       osr_ast_id_(BailoutId::None()),
       zone_(zone),
       deferred_handles_(nullptr),
       bailout_reason_(kNoReason),
       prologue_offset_(Code::kPrologueOffsetNotSet),
-      no_frame_ranges_(isolate->cpu_profiler()->is_profiling()
-                           ? new List<OffsetRange>(2)
-                           : nullptr),
       track_positions_(FLAG_hydrogen_track_positions),
       opt_count_(has_shared_info() ? shared_info()->opt_count() : 0),
       parameter_count_(0),
       optimization_id_(-1),
       aborted_due_to_dependency_change_(false),
       osr_expr_stack_height_(0) {
   std::fill_n(dependencies_, DependentCode::kGroupCount, nullptr);
+  if (isolate->cpu_profiler()->is_profiling()) {
+    no_frame_ranges_.Reset(new List<OffsetRange>(2));

[Sven Panne, 2015/03/23 10:13:26]

No need for this, see comment in the header.

+    track_positions_ = true;

[Sven Panne, 2015/03/23 10:13:26]

Instead of doing this assignment to track_positions, just do it in the
initializer list.

+  }
+  if (track_positions_) {
+    inlined_function_infos_.Reset(new std::vector<InlinedFunctionInfo>());

[Sven Panne, 2015/03/23 10:13:26]

No need for this, see comment in the header.

+  }
 }
 
 
 CompilationInfo::~CompilationInfo() {
   DisableFutureOptimization();
   delete deferred_handles_;
-  delete no_frame_ranges_;
 #ifdef DEBUG
   // Check that no dependent maps have been added or added dependent maps have
   // been rolled back or committed.
   for (int i = 0; i < DependentCode::kGroupCount; i++) {
     DCHECK(!dependencies_[i]);
   }
 #endif  // DEBUG
 }
 
 
@@ skipping 85 matching lines @@
 bool CompilationInfo::is_simple_parameter_list() {
   return scope()->is_simple_parameter_list();
 }
 
 
 int CompilationInfo::TraceInlinedFunction(Handle<SharedFunctionInfo> shared,
                                           SourcePosition position,
                                           int parent_id) {
   DCHECK(track_positions_);
 
-  int inline_id = static_cast<int>(inlined_function_infos_.size());
+  int inline_id = static_cast<int>(inlined_function_infos_->size());
   InlinedFunctionInfo info(parent_id, position, UnboundScript::kNoScriptId,
       shared->start_position());
   if (!shared->script()->IsUndefined()) {
     Handle<Script> script(Script::cast(shared->script()));
     info.script_id = script->id()->value();
 
     if (FLAG_hydrogen_track_positions && !script->source()->IsUndefined()) {
       CodeTracer::Scope tracing_scope(isolate()->GetCodeTracer());
       OFStream os(tracing_scope.file());
       os << "--- FUNCTION SOURCE (" << shared->DebugName()->ToCString().get()
          << ") id{" << optimization_id() << "," << inline_id << "} ---\n";
       {
         DisallowHeapAllocation no_allocation;
         int start = shared->start_position();
         int len = shared->end_position() - start;
         String::SubStringRange source(String::cast(script->source()), start,
                                       len);
         for (const auto& c : source) {
           os << AsReversiblyEscapedUC16(c);
         }
       }
-
       os << "\n--- END ---\n";
     }
   }
 
-  inlined_function_infos_.push_back(info);
+  inlined_function_infos_->push_back(info);
 
   if (FLAG_hydrogen_track_positions && inline_id != 0) {
     CodeTracer::Scope tracing_scope(isolate()->GetCodeTracer());
     OFStream os(tracing_scope.file());
     os << "INLINE (" << shared->DebugName()->ToCString().get() << ") id{"
        << optimization_id() << "," << inline_id << "} AS " << inline_id
        << " AT " << position << std::endl;
   }
 
   return inline_id;
 }
 
 
 void CompilationInfo::LogDeoptCallPosition(int pc_offset, int inlining_id) {
   if (!track_positions_ || IsStub()) return;
-  DCHECK_LT(static_cast<size_t>(inlining_id), inlined_function_infos_.size());
-  inlined_function_infos_.at(inlining_id).deopt_pc_offsets.push_back(pc_offset);
+  DCHECK_LT(static_cast<size_t>(inlining_id), inlined_function_infos_->size());
+  inlined_function_infos_->at(inlining_id)
+      .deopt_pc_offsets.push_back(pc_offset);
 }
 
 
 class HOptimizedGraphBuilderWithPositions: public HOptimizedGraphBuilder {
  public:
   explicit HOptimizedGraphBuilderWithPositions(CompilationInfo* info)
       : HOptimizedGraphBuilder(info) {
   }
 
 #define DEF_VISIT(type)                                      \
@@ skipping 1262 matching lines @@
   parse_info_ = nullptr;
 }
 
 #if DEBUG
 void CompilationInfo::PrintAstForTesting() {
   PrintF("--- Source from AST ---\n%s\n",
          PrettyPrinter(isolate(), zone()).PrintProgram(function()));
 }
 #endif
 } }  // namespace v8::internal