Implement glue for V8 JIT code profiling.

chrome/common/profiling.cc

 // Copyright (c) 2012 The Chromium 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 "chrome/common/profiling.h"
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/profiler.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread.h"
 #include "chrome/common/chrome_switches.h"
 #include "v8/include/v8.h"
 
 namespace {
+
+base::debug::AddDynamicSymbol add_dynamic_symbol_func = NULL;
+base::debug::MoveDynamicSymbol move_dynamic_symbol_func = NULL;
+
+void JitCodeEventHandler(const v8::JitCodeEvent* event) {
+  DCHECK_NE(static_cast<base::debug::AddDynamicSymbol>(NULL),
+            add_dynamic_symbol_func);
+  DCHECK_NE(static_cast<base::debug::MoveDynamicSymbol>(NULL),
+            move_dynamic_symbol_func);
+
+  switch (event->type) {
+    case v8::JitCodeEvent::CODE_ADDED:
+      add_dynamic_symbol_func(event->code_start, event->code_len,
+                              event->name.str, event->name.len);
+      break;
+
+    case v8::JitCodeEvent::CODE_MOVED:
+      move_dynamic_symbol_func(event->code_start, event->new_code_start);
+      break;
+  }
+}
+
 std::string GetProfileName() {
   static const char kDefaultProfileName[] = "chrome-profile-{type}-{pid}";
   CR_DEFINE_STATIC_LOCAL(std::string, profile_name, ());
 
   if (profile_name.empty()) {
     const CommandLine& command_line = *CommandLine::ForCurrentProcess();
     if (command_line.HasSwitch(switches::kProfilingFile))
       profile_name = command_line.GetSwitchValueASCII(switches::kProfilingFile);
     else
       profile_name = std::string(kDefaultProfileName);
@@ skipping 67 matching lines @@
     g_flush_thread_control = LAZY_INSTANCE_INITIALIZER;
 
 } // namespace
 
 // static
 void Profiling::ProcessStarted() {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   std::string process_type =
       command_line.GetSwitchValueASCII(switches::kProcessType);
 
-  // Establish the V8 return address resolution hook if we're
-  // an instrumented binary.
+  // Establish the V8 profiling hooks if we're an instrumented binary.
   if (base::debug::IsBinaryInstrumented()) {
     base::debug::ReturnAddressLocationResolver resolve_func =
         base::debug::GetProfilerReturnAddrResolutionFunc();
 
     if (resolve_func != NULL) {
       v8::V8::SetReturnAddressLocationResolver(resolve_func);
     }
+
+    // Set up the JIT code entry handler and the symbol callbacks if the
+    // profiler supplies them.
+    // TODO(siggi): Maybe add a switch or an environment variable to turn off
+    //     V8 profiling?
+    base::debug::DynamicFunctionEntryHook entry_hook_func =
+        base::debug::GetProfilerDynamicFunctionEntryHookFunc();
+    add_dynamic_symbol_func = base::debug::GetProfilerAddDynamicSymbolFunc();
+    move_dynamic_symbol_func = base::debug::GetProfilerMoveDynamicSymbolFunc();

[Nico, 2013/07/03 19:26:38]

nit: can't you just call this in JitCodeEventHandler() each time?

[Sigurður Ásgeirsson, 2013/07/03 19:35:58]

Retrieving these functions is relatively expensive, as it involves searching
through the import address table of the instrumentation DLL. Adding and moving
dynamic code will happen in spurts, as code is compiled, or as GC moves it
around.
It will significantly affect the performance of compilation or GC if we do a
search each time.

+
+    v8::Isolate* isolate = v8::Isolate::GetCurrent();
+    if (isolate != NULL &&
+        entry_hook_func != NULL &&
+        add_dynamic_symbol_func != NULL &&
+        move_dynamic_symbol_func != NULL) {
+      v8::V8::SetFunctionEntryHook(isolate, entry_hook_func);
+      v8::V8::SetJitCodeEventHandler(v8::kJitCodeEventDefault,
+                                     &JitCodeEventHandler);
+    }
   }
 
   if (command_line.HasSwitch(switches::kProfilingAtStart)) {
     std::string process_type_to_start =
         command_line.GetSwitchValueASCII(switches::kProfilingAtStart);
     if (process_type == process_type_to_start)
       Start();
   }
 }
 
@@ skipping 20 matching lines @@
   return base::debug::BeingProfiled();
 }
 
 // static
 void Profiling::Toggle() {
   if (BeingProfiled())
     Stop();
   else
     Start();
 }