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;
+
+    default:
+      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();
+
+    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();
 }