1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef vm_Probes_h
#define vm_Probes_h
#ifdef INCLUDE_MOZILLA_DTRACE
# include "javascript-trace.h"
#endif
#include "vm/JSObject.h"
namespace js {
class InterpreterFrame;
namespace probes {
/*
* Static probes
*
* The probe points defined in this file are scattered around the SpiderMonkey
* source tree. The presence of probes::SomeEvent() means that someEvent is
* about to happen or has happened. To the extent possible, probes should be
* inserted in all paths associated with a given event, regardless of the
* active runmode (interpreter/traceJIT/methodJIT/ionJIT).
*
* When a probe fires, it is handled by any probe handling backends that have
* been compiled in. By default, most probes do nothing or at least do nothing
* expensive, so the presence of the probe should have negligible effect on
* running time. (Probes in slow paths may do something by default, as long as
* there is no noticeable slowdown.)
*
* For some probes, the mere existence of the probe is too expensive even if it
* does nothing when called. For example, just having consistent information
* available for a function call entry/exit probe causes the JITs to
* de-optimize function calls. In those cases, the JITs may query at compile
* time whether a probe is desired, and omit the probe invocation if not. If a
* probe is runtime-disabled at compilation time, it is not guaranteed to fire
* within a compiled function if it is later enabled.
*
* Not all backends handle all of the probes listed here.
*/
/*
* Internal use only: remember whether "profiling", whatever that means, is
* currently active. Used for state management.
*/
extern bool ProfilingActive;
extern const char nullName[];
extern const char anonymousName[];
/*
* Test whether we are tracking JS function call enter/exit. The JITs use this
* to decide whether they can optimize in a way that would prevent probes from
* firing.
*/
bool CallTrackingActive(JSContext*);
/* Entering a JS function */
bool EnterScript(JSContext*, JSScript*, JSFunction*, InterpreterFrame*);
/* About to leave a JS function */
void ExitScript(JSContext*, JSScript*, JSFunction*, bool popProfilerFrame);
/* Executing a script */
bool StartExecution(JSScript* script);
/* Script has completed execution */
bool StopExecution(JSScript* script);
/*
* Object has been created. |obj| must exist (its class and size are read)
*/
bool CreateObject(JSContext* cx, JSObject* obj);
/*
* Object is about to be finalized. |obj| must still exist (its class is
* read)
*/
bool FinalizeObject(JSObject* obj);
/*
* Internal: DTrace-specific functions to be called during probes::EnterScript
* and probes::ExitScript. These will not be inlined, but the argument
* marshalling required for these probe points is expensive enough that it
* shouldn't really matter.
*/
void DTraceEnterJSFun(JSContext* cx, JSFunction* fun, JSScript* script);
void DTraceExitJSFun(JSContext* cx, JSFunction* fun, JSScript* script);
} // namespace probes
#ifdef INCLUDE_MOZILLA_DTRACE
static const char* ObjectClassname(JSObject* obj) {
if (!obj) {
return "(null object)";
}
const JSClass* clasp = obj->getClass();
if (!clasp) {
return "(null)";
}
const char* class_name = clasp->name;
if (!class_name) {
return "(null class name)";
}
return class_name;
}
#endif
inline bool probes::CreateObject(JSContext* cx, JSObject* obj) {
bool ok = true;
#ifdef INCLUDE_MOZILLA_DTRACE
if (JAVASCRIPT_OBJECT_CREATE_ENABLED()) {
JAVASCRIPT_OBJECT_CREATE(ObjectClassname(obj), (uintptr_t)obj);
}
#endif
return ok;
}
inline bool probes::FinalizeObject(JSObject* obj) {
bool ok = true;
#ifdef INCLUDE_MOZILLA_DTRACE
if (JAVASCRIPT_OBJECT_FINALIZE_ENABLED()) {
const JSClass* clasp = obj->getClass();
/* the first arg is nullptr - reserved for future use (filename?) */
JAVASCRIPT_OBJECT_FINALIZE(nullptr, (char*)clasp->name, (uintptr_t)obj);
}
#endif
return ok;
}
} /* namespace js */
#endif /* vm_Probes_h */
|
