← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/chromium/src/base/debug/profiler.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/chromium/src/base/debug/profiler.h
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.
17
 
namespace base {
18
 
namespace 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).
23
 
BASE_EXPORT void StartProfiling(const std::string& name);
24
 
 
25
 
// Stop profiling and write out data.
26
 
BASE_EXPORT void StopProfiling();
27
 
 
28
 
// Force data to be written to file.
29
 
BASE_EXPORT void FlushProfiling();
30
 
 
31
 
// Returns true if process is being profiled.
32
 
BASE_EXPORT bool BeingProfiled();
33
 
 
34
 
// Reset profiling after a fork, which disables timers.
35
 
BASE_EXPORT void RestartProfilingAfterFork();
36
 
 
37
 
// Returns true iff this executable is instrumented with the Syzygy profiler.
38
 
BASE_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.
55
 
typedef uintptr_t (*ReturnAddressLocationResolver)(
56
 
    uintptr_t return_addr_location);
57
 
 
58
 
// This type declaration must match V8's FunctionEntryHook.
59
 
typedef 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.
69
 
typedef void (*DynamicFunctionEntryHook)(uintptr_t function,
70
 
                                         uintptr_t return_addr_location);
71
 
 
72
 
typedef void (*AddDynamicSymbol)(const void* address,
73
 
                                 size_t length,
74
 
                                 const char* name,
75
 
                                 size_t name_len);
76
 
typedef 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.
82
 
BASE_EXPORT ReturnAddressLocationResolver GetProfilerReturnAddrResolutionFunc();
83
 
BASE_EXPORT DynamicFunctionEntryHook GetProfilerDynamicFunctionEntryHookFunc();
84
 
BASE_EXPORT AddDynamicSymbol GetProfilerAddDynamicSymbolFunc();
85
 
BASE_EXPORT MoveDynamicSymbol GetProfilerMoveDynamicSymbolFunc();
86
 
 
87
 
}  // namespace debug
88
 
}  // namespace base
89
 
 
90
 
#endif  // BASE_DEBUG_DEBUGGER_H