CpuProfiler: push the collected information about deopts to cpu profiler

src/compiler.h

Index: src/compiler.h
diff --git a/src/compiler.h b/src/compiler.h
index e58562664732af04b5fb4fa589440ec30b5482bc..883dfdbcc172f35518f7ea1d0f0f71a4b6dc1864 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -97,7 +97,7 @@ struct InlinedFunctionInfo {
   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;
 };
@@ -349,6 +349,9 @@ class CompilationInfo {
   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,