CpuProfiler: push the collected information about deopts to cpu profiler

src/compiler.h

 // 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.
 
 #ifndef V8_COMPILER_H_
 #define V8_COMPILER_H_
 
 #include "src/allocation.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
@@ skipping 79 matching lines @@
   InlinedFunctionInfo(int parent_id, SourcePosition inline_position,
                       int script_id, int start_position)
       : parent_id(parent_id),
         inline_position(inline_position),
         script_id(script_id),
         start_position(start_position) {}
   int parent_id;
   SourcePosition inline_position;
   int script_id;
   int start_position;
-  std::vector<int> deopt_pc_offsets;
+  std::vector<size_t> deopt_pc_offsets;
 
   static const int kNoParentId = -1;
 };
 
 
 // CompilationInfo encapsulates some information known at compile time.  It
 // is constructed based on the resources available at compile-time.
 class CompilationInfo {
  public:
   // Various configuration flags for a compilation, as well as some properties
@@ skipping 231 matching lines @@
 
   List<OffsetRange>* ReleaseNoFrameRanges() {
     List<OffsetRange>* result = no_frame_ranges_;
     no_frame_ranges_ = NULL;
     return result;
   }
 
   int start_position_for(uint32_t inlining_id) {
     return inlined_function_infos_.at(inlining_id).start_position;
   }
+  const std::vector<InlinedFunctionInfo>& inlined_function_infos() {

[Sven Panne, 2015/03/24 10:25:30]

Hmmm, returning this by reference is not nice: Looking at the use sites of this
function, I fail to see why it is even correct, i.e. why the CompilationInfo is
still alive at that point. Even if it *was* correct, let's not do this,
reasoning globally about tricky lifetimes is a recipe for bugs later: Just
return this by value, there should only be a tiny handful of entries in it
(AFAICT).

[loislo, 2015/03/24 10:46:34]

1) We pass CompilationInfo to logger when we finished compilation, so it is
alive. 

2) Profiler copies the inlining info into CodeCreateEvent (it used to take the
ownership in the previous versions of the patch).

3) event processor processes all the events (CodeCreate, CodeDeopt, Sample with
stacktrace, etc) and copies the inlining info into CodeEntry objects when it
processes CodeCreateEvents. (it used to take the ownership in the previous
versions of the patch). JFYI: CodeEntry maps to Code object one to one.

4) event processor resolves a stack of addresses (stacktrace) into a stack of
CodeEntries.

5) event processor appends the stack of CodeEntries to the profiler tree,
construct new ProfileNodes if necessary, creates DeoptInfo with help of
pc_offset and the InliningInfo and puts it into top-level ProfileNode. We always
have a stack which finishes in the deopted code because we explicitly create
StackTrace in order of logging the deopt event.

[Sven Panne, 2015/03/24 10:56:54]

To be exact: It doesn't copy the inlining info at all, it just puts a reference
to CompilationInfo's internal field into the event (i.e. basically copying a
pointer).
Hopefully the CompilationInfo is still alive here. :-)
I still don't like this, but I don't want to hold up your progress and
CompilationInfo needs to be refactored heavily, anyway (e.g. the current part
we're talking about is totally Crankshaft-specific), so let's land this, but at
least put your reasoning as a comment here if you still want to keep using the
reference.

+    return inlined_function_infos_;
+  }
 
   void LogDeoptCallPosition(int pc_offset, int inlining_id);
   int TraceInlinedFunction(Handle<SharedFunctionInfo> shared,
                            SourcePosition position, int pareint_id);
 
   Handle<Foreign> object_wrapper() {
     if (object_wrapper_.is_null()) {
       object_wrapper_ =
           isolate()->factory()->NewForeign(reinterpret_cast<Address>(this));
     }
@@ skipping 339 matching lines @@
   Zone zone_;
   size_t info_zone_start_allocation_size_;
   base::ElapsedTimer timer_;
 
   DISALLOW_COPY_AND_ASSIGN(CompilationPhase);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_COMPILER_H_