1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#ifndef BASE_DEBUG_PROFILER_H 6#define BASE_DEBUG_PROFILER_H 7 8#include <string> 9 10#include "base/base_export.h" 11#include "base/basictypes.h" 12 13// The Profiler functions allow usage of the underlying sampling based 14// profiler. If the application has not been built with the necessary 15// flags (-DENABLE_PROFILING and not -DNO_TCMALLOC) then these functions 16// are noops. 17namespace base { 18namespace debug { 19 20// Start profiling with the supplied name. 21// {pid} will be replaced by the process' pid and {count} will be replaced 22// by the count of the profile run (starts at 1 with each process). 23BASE_EXPORT void StartProfiling(const std::string& name); 24 25// Stop profiling and write out data. 26BASE_EXPORT void StopProfiling(); 27 28// Force data to be written to file. 29BASE_EXPORT void FlushProfiling(); 30 31// Returns true if process is being profiled. 32BASE_EXPORT bool BeingProfiled(); 33 34// Reset profiling after a fork, which disables timers. 35BASE_EXPORT void RestartProfilingAfterFork(); 36 37// Returns true iff this executable is instrumented with the Syzygy profiler. 38BASE_EXPORT bool IsBinaryInstrumented(); 39 40// There's a class of profilers that use "return address swizzling" to get a 41// hook on function exits. This class of profilers uses some form of entry hook, 42// like e.g. binary instrumentation, or a compiler flag, that calls a hook each 43// time a function is invoked. The hook then switches the return address on the 44// stack for the address of an exit hook function, and pushes the original 45// return address to a shadow stack of some type. When in due course the CPU 46// executes a return to the exit hook, the exit hook will do whatever work it 47// does on function exit, then arrange to return to the original return address. 48// This class of profiler does not play well with programs that look at the 49// return address, as does e.g. V8. V8 uses the return address to certain 50// runtime functions to find the JIT code that called it, and from there finds 51// the V8 data structures associated to the JS function involved. 52// A return address resolution function is used to fix this. It allows such 53// programs to resolve a location on stack where a return address originally 54// resided, to the shadow stack location where the profiler stashed it. 55typedef uintptr_t (*ReturnAddressLocationResolver)( 56 uintptr_t return_addr_location); 57 58// This type declaration must match V8's FunctionEntryHook. 59typedef void (*DynamicFunctionEntryHook)(uintptr_t function, 60 uintptr_t return_addr_location); 61 62// The functions below here are to support profiling V8-generated code. 63// V8 has provisions for generating a call to an entry hook for newly generated 64// JIT code, and it can push symbol information on code generation and advise 65// when the garbage collector moves code. The functions declarations below here 66// make glue between V8's facilities and a profiler. 67 68// This type declaration must match V8's FunctionEntryHook. 69typedef void (*DynamicFunctionEntryHook)(uintptr_t function, 70 uintptr_t return_addr_location); 71 72typedef void (*AddDynamicSymbol)(const void* address, 73 size_t length, 74 const char* name, 75 size_t name_len); 76typedef void (*MoveDynamicSymbol)(const void* address, const void* new_address); 77 78 79// If this binary is instrumented and the instrumentation supplies a function 80// for each of those purposes, find and return the function in question. 81// Otherwise returns NULL. 82BASE_EXPORT ReturnAddressLocationResolver GetProfilerReturnAddrResolutionFunc(); 83BASE_EXPORT DynamicFunctionEntryHook GetProfilerDynamicFunctionEntryHookFunc(); 84BASE_EXPORT AddDynamicSymbol GetProfilerAddDynamicSymbolFunc(); 85BASE_EXPORT MoveDynamicSymbol GetProfilerMoveDynamicSymbolFunc(); 86 87} // namespace debug 88} // namespace base 89 90#endif // BASE_DEBUG_DEBUGGER_H 91