Mercurial > hg > graal-compiler
annotate src/share/vm/prims/jvmtiExport.hpp @ 3992:d1bdeef3e3e2
7098282: G1: assert(interval >= 0) failed: Sanity check, referencePolicy.cpp: 76
Summary: There is a race between one thread successfully forwarding and copying the klass mirror for the SoftReference class (including the static master clock) and another thread attempting to use the master clock while attempting to discover a soft reference object. Maintain a shadow copy of the soft reference master clock and use the shadow during reference discovery and reference processing.
Reviewed-by: tonyp, brutisso, ysr
author | johnc |
---|---|
date | Wed, 12 Oct 2011 10:25:51 -0700 |
parents | f6f3bb0ee072 |
children | a735aec54ea4 |
rev | line source |
---|---|
0 | 1 /* |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
2 * Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved. |
0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 * | |
5 * This code is free software; you can redistribute it and/or modify it | |
6 * under the terms of the GNU General Public License version 2 only, as | |
7 * published by the Free Software Foundation. | |
8 * | |
9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
12 * version 2 for more details (a copy is included in the LICENSE file that | |
13 * accompanied this code). | |
14 * | |
15 * You should have received a copy of the GNU General Public License version | |
16 * 2 along with this work; if not, write to the Free Software Foundation, | |
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
18 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1397
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1397
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1397
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
1972 | 25 #ifndef SHARE_VM_PRIMS_JVMTIEXPORT_HPP |
26 #define SHARE_VM_PRIMS_JVMTIEXPORT_HPP | |
27 | |
28 #include "jvmtifiles/jvmti.h" | |
29 #include "memory/allocation.hpp" | |
30 #include "memory/iterator.hpp" | |
31 #include "oops/oop.hpp" | |
32 #include "oops/oopsHierarchy.hpp" | |
33 #include "runtime/frame.hpp" | |
34 #include "runtime/handles.hpp" | |
35 #include "utilities/globalDefinitions.hpp" | |
36 #include "utilities/growableArray.hpp" | |
0 | 37 |
1983
c760f78e0a53
7003125: precompiled.hpp is included when precompiled headers are not used
stefank
parents:
1972
diff
changeset
|
38 // Must be included after jvmti.h. |
c760f78e0a53
7003125: precompiled.hpp is included when precompiled headers are not used
stefank
parents:
1972
diff
changeset
|
39 #include "code/jvmticmlr.h" |
c760f78e0a53
7003125: precompiled.hpp is included when precompiled headers are not used
stefank
parents:
1972
diff
changeset
|
40 |
0 | 41 // Forward declarations |
42 | |
43 class JvmtiEventControllerPrivate; | |
44 class JvmtiManageCapabilities; | |
45 class JvmtiEnv; | |
46 class JvmtiThreadState; | |
47 class AttachOperation; | |
48 | |
49 #ifndef JVMTI_KERNEL | |
50 #define JVMTI_SUPPORT_FLAG(key) \ | |
51 private: \ | |
52 static bool _##key; \ | |
53 public: \ | |
54 inline static void set_##key(bool on) { _##key = (on != 0); } \ | |
55 inline static bool key() { return _##key; } | |
56 #else // JVMTI_KERNEL | |
57 #define JVMTI_SUPPORT_FLAG(key) \ | |
58 private: \ | |
59 const static bool _##key = false; \ | |
60 public: \ | |
61 inline static void set_##key(bool on) { report_unsupported(on); } \ | |
62 inline static bool key() { return _##key; } | |
63 #endif // JVMTI_KERNEL | |
64 | |
65 | |
66 // This class contains the JVMTI interface for the rest of hotspot. | |
67 // | |
68 class JvmtiExport : public AllStatic { | |
3939 | 69 friend class VMStructs; |
0 | 70 private: |
71 static int _field_access_count; | |
72 static int _field_modification_count; | |
73 | |
74 static bool _can_access_local_variables; | |
75 static bool _can_hotswap_or_post_breakpoint; | |
76 static bool _can_modify_any_class; | |
77 static bool _can_walk_any_space; | |
78 | |
79 JVMTI_SUPPORT_FLAG(can_get_source_debug_extension) | |
80 JVMTI_SUPPORT_FLAG(can_maintain_original_method_order) | |
81 JVMTI_SUPPORT_FLAG(can_post_interpreter_events) | |
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1121
diff
changeset
|
82 JVMTI_SUPPORT_FLAG(can_post_on_exceptions) |
0 | 83 JVMTI_SUPPORT_FLAG(can_post_breakpoint) |
84 JVMTI_SUPPORT_FLAG(can_post_field_access) | |
85 JVMTI_SUPPORT_FLAG(can_post_field_modification) | |
86 JVMTI_SUPPORT_FLAG(can_post_method_entry) | |
87 JVMTI_SUPPORT_FLAG(can_post_method_exit) | |
88 JVMTI_SUPPORT_FLAG(can_pop_frame) | |
89 JVMTI_SUPPORT_FLAG(can_force_early_return) | |
90 | |
91 friend class JvmtiEventControllerPrivate; // should only modify these flags | |
92 JVMTI_SUPPORT_FLAG(should_post_single_step) | |
93 JVMTI_SUPPORT_FLAG(should_post_field_access) | |
94 JVMTI_SUPPORT_FLAG(should_post_field_modification) | |
95 JVMTI_SUPPORT_FLAG(should_post_class_load) | |
96 JVMTI_SUPPORT_FLAG(should_post_class_prepare) | |
97 JVMTI_SUPPORT_FLAG(should_post_class_unload) | |
98 JVMTI_SUPPORT_FLAG(should_post_native_method_bind) | |
99 JVMTI_SUPPORT_FLAG(should_post_compiled_method_load) | |
100 JVMTI_SUPPORT_FLAG(should_post_compiled_method_unload) | |
101 JVMTI_SUPPORT_FLAG(should_post_dynamic_code_generated) | |
102 JVMTI_SUPPORT_FLAG(should_post_monitor_contended_enter) | |
103 JVMTI_SUPPORT_FLAG(should_post_monitor_contended_entered) | |
104 JVMTI_SUPPORT_FLAG(should_post_monitor_wait) | |
105 JVMTI_SUPPORT_FLAG(should_post_monitor_waited) | |
106 JVMTI_SUPPORT_FLAG(should_post_data_dump) | |
107 JVMTI_SUPPORT_FLAG(should_post_garbage_collection_start) | |
108 JVMTI_SUPPORT_FLAG(should_post_garbage_collection_finish) | |
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1121
diff
changeset
|
109 JVMTI_SUPPORT_FLAG(should_post_on_exceptions) |
0 | 110 |
111 // ------ the below maybe don't have to be (but are for now) | |
112 // fixed conditions here ------------ | |
113 // any events can be enabled | |
114 JVMTI_SUPPORT_FLAG(should_post_thread_life) | |
115 JVMTI_SUPPORT_FLAG(should_post_object_free) | |
116 JVMTI_SUPPORT_FLAG(should_post_resource_exhausted) | |
117 | |
118 // we are holding objects on the heap - need to talk to GC - e.g. | |
119 // breakpoint info | |
120 JVMTI_SUPPORT_FLAG(should_clean_up_heap_objects) | |
121 JVMTI_SUPPORT_FLAG(should_post_vm_object_alloc) | |
122 | |
123 // If flag cannot be implemented, give an error if on=true | |
124 static void report_unsupported(bool on); | |
125 | |
126 // these should only be called by the friend class | |
127 friend class JvmtiManageCapabilities; | |
128 inline static void set_can_modify_any_class(bool on) { _can_modify_any_class = (on != 0); } | |
129 inline static void set_can_access_local_variables(bool on) { _can_access_local_variables = (on != 0); } | |
130 inline static void set_can_hotswap_or_post_breakpoint(bool on) { _can_hotswap_or_post_breakpoint = (on != 0); } | |
131 inline static void set_can_walk_any_space(bool on) { _can_walk_any_space = (on != 0); } | |
132 | |
133 enum { | |
134 JVMTI_VERSION_MASK = 0x70000000, | |
135 JVMTI_VERSION_VALUE = 0x30000000, | |
136 JVMDI_VERSION_VALUE = 0x20000000 | |
137 }; | |
138 | |
139 static void post_field_modification(JavaThread *thread, methodOop method, address location, | |
140 KlassHandle field_klass, Handle object, jfieldID field, | |
141 char sig_type, jvalue *value); | |
142 | |
143 | |
144 // posts a DynamicCodeGenerated event (internal/private implementation). | |
145 // The public post_dynamic_code_generated* functions make use of the | |
2301
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
146 // internal implementation. Also called from JvmtiDeferredEvent::post() |
0 | 147 static void post_dynamic_code_generated_internal(const char *name, const void *code_begin, const void *code_end) KERNEL_RETURN; |
148 | |
2301
f91db74a6810
7017640: Fix for 6766644 deadlocks on some NSK tests when running with -Xcomp
kamg
parents:
2195
diff
changeset
|
149 private: |
0 | 150 |
151 // GenerateEvents support to allow posting of CompiledMethodLoad and | |
152 // DynamicCodeGenerated events for a given environment. | |
153 friend class JvmtiCodeBlobEvents; | |
154 | |
155 static void post_compiled_method_load(JvmtiEnv* env, const jmethodID method, const jint length, | |
156 const void *code_begin, const jint map_length, | |
157 const jvmtiAddrLocationMap* map) KERNEL_RETURN; | |
158 static void post_dynamic_code_generated(JvmtiEnv* env, const char *name, const void *code_begin, | |
159 const void *code_end) KERNEL_RETURN; | |
160 | |
161 // The RedefineClasses() API breaks some invariants in the "regular" | |
162 // system. For example, there are sanity checks when GC'ing nmethods | |
163 // that require the containing class to be unloading. However, when a | |
164 // method is redefined, the old method and nmethod can become GC'able | |
165 // without the containing class unloading. The state of becoming | |
166 // GC'able can be asynchronous to the RedefineClasses() call since | |
167 // the old method may still be running and cannot be GC'ed until | |
168 // after all old invocations have finished. Additionally, a method | |
169 // that has not been redefined may have an nmethod that depends on | |
170 // the redefined method. The dependent nmethod will get deopted in | |
171 // this case and may also be GC'able without the containing class | |
172 // being unloaded. | |
173 // | |
174 // This flag indicates whether RedefineClasses() has ever redefined | |
175 // one or more classes during the lifetime of the VM. The flag should | |
176 // only be set by the friend class and can be queried by other sub | |
177 // systems as needed to relax invariant checks. | |
178 static bool _has_redefined_a_class; | |
179 friend class VM_RedefineClasses; | |
180 inline static void set_has_redefined_a_class() { | |
181 _has_redefined_a_class = true; | |
182 } | |
183 | |
184 // Flag to indicate if the compiler has recorded all dependencies. When the | |
185 // can_redefine_classes capability is enabled in the OnLoad phase then the compiler | |
186 // records all dependencies from startup. However if the capability is first | |
187 // enabled some time later then the dependencies recorded by the compiler | |
188 // are incomplete. This flag is used by RedefineClasses to know if the | |
189 // dependency information is complete or not. | |
190 static bool _all_dependencies_are_recorded; | |
191 | |
192 public: | |
193 inline static bool has_redefined_a_class() { | |
194 return _has_redefined_a_class; | |
195 } | |
196 | |
197 inline static bool all_dependencies_are_recorded() { | |
198 return _all_dependencies_are_recorded; | |
199 } | |
200 | |
201 inline static void set_all_dependencies_are_recorded(bool on) { | |
202 _all_dependencies_are_recorded = (on != 0); | |
203 } | |
204 | |
205 | |
206 // let JVMTI know that the JVM_OnLoad code is running | |
207 static void enter_onload_phase(); | |
208 | |
209 // let JVMTI know that the VM isn't up yet (and JVM_OnLoad code isn't running) | |
210 static void enter_primordial_phase(); | |
211 | |
212 // let JVMTI know that the VM isn't up yet but JNI is live | |
213 static void enter_start_phase(); | |
214 | |
215 // let JVMTI know that the VM is fully up and running now | |
216 static void enter_live_phase(); | |
217 | |
218 // ------ can_* conditions (below) are set at OnLoad and never changed ------------ | |
219 inline static bool can_modify_any_class() { return _can_modify_any_class; } | |
220 inline static bool can_access_local_variables() { return _can_access_local_variables; } | |
221 inline static bool can_hotswap_or_post_breakpoint() { return _can_hotswap_or_post_breakpoint; } | |
222 inline static bool can_walk_any_space() { return _can_walk_any_space; } | |
223 | |
224 // field access management | |
225 static address get_field_access_count_addr(); | |
226 | |
227 // field modification management | |
228 static address get_field_modification_count_addr(); | |
229 | |
230 // ----------------- | |
231 | |
232 static bool is_jvmti_version(jint version) { return (version & JVMTI_VERSION_MASK) == JVMTI_VERSION_VALUE; } | |
233 static bool is_jvmdi_version(jint version) { return (version & JVMTI_VERSION_MASK) == JVMDI_VERSION_VALUE; } | |
234 static jint get_jvmti_interface(JavaVM *jvm, void **penv, jint version); | |
1121 | 235 static void decode_version_values(jint version, int * major, int * minor, |
236 int * micro); | |
0 | 237 |
238 // single stepping management methods | |
239 static void at_single_stepping_point(JavaThread *thread, methodOop method, address location) KERNEL_RETURN; | |
240 static void expose_single_stepping(JavaThread *thread) KERNEL_RETURN; | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
241 static bool hide_single_stepping(JavaThread *thread) KERNEL_RETURN_(false); |
0 | 242 |
243 // Methods that notify the debugger that something interesting has happened in the VM. | |
244 static void post_vm_start (); | |
245 static void post_vm_initialized (); | |
246 static void post_vm_death (); | |
247 | |
248 static void post_single_step (JavaThread *thread, methodOop method, address location) KERNEL_RETURN; | |
249 static void post_raw_breakpoint (JavaThread *thread, methodOop method, address location) KERNEL_RETURN; | |
250 | |
251 static void post_exception_throw (JavaThread *thread, methodOop method, address location, oop exception) KERNEL_RETURN; | |
252 static void notice_unwind_due_to_exception (JavaThread *thread, methodOop method, address location, oop exception, bool in_handler_frame) KERNEL_RETURN; | |
253 | |
254 static oop jni_GetField_probe (JavaThread *thread, jobject jobj, | |
255 oop obj, klassOop klass, jfieldID fieldID, bool is_static) | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
256 KERNEL_RETURN_(NULL); |
0 | 257 static oop jni_GetField_probe_nh (JavaThread *thread, jobject jobj, |
258 oop obj, klassOop klass, jfieldID fieldID, bool is_static) | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
259 KERNEL_RETURN_(NULL); |
0 | 260 static void post_field_access_by_jni (JavaThread *thread, oop obj, |
261 klassOop klass, jfieldID fieldID, bool is_static) KERNEL_RETURN; | |
262 static void post_field_access (JavaThread *thread, methodOop method, | |
263 address location, KlassHandle field_klass, Handle object, jfieldID field) KERNEL_RETURN; | |
264 static oop jni_SetField_probe (JavaThread *thread, jobject jobj, | |
265 oop obj, klassOop klass, jfieldID fieldID, bool is_static, char sig_type, | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
266 jvalue *value) KERNEL_RETURN_(NULL); |
0 | 267 static oop jni_SetField_probe_nh (JavaThread *thread, jobject jobj, |
268 oop obj, klassOop klass, jfieldID fieldID, bool is_static, char sig_type, | |
2195
bf8517f4e4d0
6766644: Redefinition of compiled method fails with assertion "Can not load classes with the Compiler thread"
kamg
parents:
2177
diff
changeset
|
269 jvalue *value) KERNEL_RETURN_(NULL); |
0 | 270 static void post_field_modification_by_jni(JavaThread *thread, oop obj, |
271 klassOop klass, jfieldID fieldID, bool is_static, char sig_type, | |
272 jvalue *value); | |
273 static void post_raw_field_modification(JavaThread *thread, methodOop method, | |
274 address location, KlassHandle field_klass, Handle object, jfieldID field, | |
275 char sig_type, jvalue *value) KERNEL_RETURN; | |
276 | |
277 static void post_method_entry (JavaThread *thread, methodOop method, frame current_frame) KERNEL_RETURN; | |
278 static void post_method_exit (JavaThread *thread, methodOop method, frame current_frame) KERNEL_RETURN; | |
279 | |
280 static void post_class_load (JavaThread *thread, klassOop klass) KERNEL_RETURN; | |
281 static void post_class_unload (klassOop klass) KERNEL_RETURN; | |
282 static void post_class_prepare (JavaThread *thread, klassOop klass) KERNEL_RETURN; | |
283 | |
284 static void post_thread_start (JavaThread *thread) KERNEL_RETURN; | |
285 static void post_thread_end (JavaThread *thread) KERNEL_RETURN; | |
286 | |
287 // Support for java.lang.instrument agent loading. | |
288 static bool _should_post_class_file_load_hook; | |
289 inline static void set_should_post_class_file_load_hook(bool on) { _should_post_class_file_load_hook = on; } | |
290 inline static bool should_post_class_file_load_hook() { return _should_post_class_file_load_hook; } | |
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
2147
diff
changeset
|
291 static void post_class_file_load_hook(Symbol* h_name, Handle class_loader, |
0 | 292 Handle h_protection_domain, |
293 unsigned char **data_ptr, unsigned char **end_ptr, | |
294 unsigned char **cached_data_ptr, | |
295 jint *cached_length_ptr); | |
296 static void post_native_method_bind(methodOop method, address* function_ptr) KERNEL_RETURN; | |
297 static void post_compiled_method_load(nmethod *nm) KERNEL_RETURN; | |
298 static void post_dynamic_code_generated(const char *name, const void *code_begin, const void *code_end) KERNEL_RETURN; | |
299 | |
1577
852d0157c696
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
1397
diff
changeset
|
300 // used to post a CompiledMethodUnload event |
852d0157c696
6956931: assert(SafepointSynchronize::is_at_safepoint()) failed: must be executed at a safepoint
never
parents:
1397
diff
changeset
|
301 static void post_compiled_method_unload(jmethodID mid, const void *code_begin) KERNEL_RETURN; |
0 | 302 |
303 // similiar to post_dynamic_code_generated except that it can be used to | |
304 // post a DynamicCodeGenerated event while holding locks in the VM. Any event | |
305 // posted using this function is recorded by the enclosing event collector | |
306 // -- JvmtiDynamicCodeEventCollector. | |
307 static void post_dynamic_code_generated_while_holding_locks(const char* name, address code_begin, address code_end) KERNEL_RETURN; | |
308 | |
309 static void post_garbage_collection_finish() KERNEL_RETURN; | |
310 static void post_garbage_collection_start() KERNEL_RETURN; | |
311 static void post_data_dump() KERNEL_RETURN; | |
312 static void post_monitor_contended_enter(JavaThread *thread, ObjectMonitor *obj_mntr) KERNEL_RETURN; | |
313 static void post_monitor_contended_entered(JavaThread *thread, ObjectMonitor *obj_mntr) KERNEL_RETURN; | |
314 static void post_monitor_wait(JavaThread *thread, oop obj, jlong timeout) KERNEL_RETURN; | |
315 static void post_monitor_waited(JavaThread *thread, ObjectMonitor *obj_mntr, jboolean timed_out) KERNEL_RETURN; | |
316 static void post_object_free(JvmtiEnv* env, jlong tag) KERNEL_RETURN; | |
317 static void post_resource_exhausted(jint resource_exhausted_flags, const char* detail) KERNEL_RETURN; | |
318 static void record_vm_internal_object_allocation(oop object) KERNEL_RETURN; | |
319 // Post objects collected by vm_object_alloc_event_collector. | |
320 static void post_vm_object_alloc(JavaThread *thread, oop object) KERNEL_RETURN; | |
321 // Collects vm internal objects for later event posting. | |
322 inline static void vm_object_alloc_event_collector(oop object) { | |
323 if (should_post_vm_object_alloc()) { | |
324 record_vm_internal_object_allocation(object); | |
325 } | |
326 } | |
327 | |
328 static void cleanup_thread (JavaThread* thread) KERNEL_RETURN; | |
329 | |
330 static void oops_do(OopClosure* f) KERNEL_RETURN; | |
2147
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
331 static void weak_oops_do(BoolObjectClosure* b, OopClosure* f) KERNEL_RETURN; |
9afee0b9fc1d
7012505: BreakpointWithFullGC.sh fails with Internal Error (src/share/vm/oops/methodOop.cpp:220)
kamg
parents:
2125
diff
changeset
|
332 static void gc_epilogue() KERNEL_RETURN; |
0 | 333 |
334 static void transition_pending_onload_raw_monitors() KERNEL_RETURN; | |
335 | |
336 #ifndef SERVICES_KERNEL | |
337 // attach support | |
338 static jint load_agent_library(AttachOperation* op, outputStream* out); | |
339 #endif // SERVICES_KERNEL | |
340 | |
341 // SetNativeMethodPrefix support | |
342 static char** get_all_native_method_prefixes(int* count_ptr); | |
343 }; | |
344 | |
345 // Support class used by JvmtiDynamicCodeEventCollector and others. It | |
346 // describes a single code blob by name and address range. | |
347 class JvmtiCodeBlobDesc : public CHeapObj { | |
348 private: | |
349 char _name[64]; | |
350 address _code_begin; | |
351 address _code_end; | |
352 | |
353 public: | |
354 JvmtiCodeBlobDesc(const char *name, address code_begin, address code_end) { | |
355 assert(name != NULL, "all code blobs must be named"); | |
356 strncpy(_name, name, sizeof(_name)); | |
357 _name[sizeof(_name)-1] = '\0'; | |
358 _code_begin = code_begin; | |
359 _code_end = code_end; | |
360 } | |
361 char* name() { return _name; } | |
362 address code_begin() { return _code_begin; } | |
363 address code_end() { return _code_end; } | |
364 }; | |
365 | |
366 // JvmtiEventCollector is a helper class to setup thread for | |
367 // event collection. | |
368 class JvmtiEventCollector : public StackObj { | |
369 private: | |
370 JvmtiEventCollector* _prev; // Save previous one to support nested event collector. | |
371 | |
372 public: | |
373 void setup_jvmti_thread_state(); // Set this collector in current thread. | |
374 void unset_jvmti_thread_state(); // Reset previous collector in current thread. | |
375 virtual bool is_dynamic_code_event() { return false; } | |
376 virtual bool is_vm_object_alloc_event(){ return false; } | |
377 JvmtiEventCollector *get_prev() { return _prev; } | |
378 }; | |
379 | |
380 // A JvmtiDynamicCodeEventCollector is a helper class for the JvmtiExport | |
381 // interface. It collects "dynamic code generated" events that are posted | |
382 // while holding locks. When the event collector goes out of scope the | |
383 // events will be posted. | |
384 // | |
385 // Usage :- | |
386 // | |
387 // { | |
388 // JvmtiDynamicCodeEventCollector event_collector; | |
389 // : | |
390 // { MutexLocker ml(...) | |
391 // : | |
392 // JvmtiExport::post_dynamic_code_generated_while_holding_locks(...) | |
393 // } | |
394 // // event collector goes out of scope => post events to profiler. | |
395 // } | |
396 | |
397 class JvmtiDynamicCodeEventCollector : public JvmtiEventCollector { | |
398 private: | |
399 GrowableArray<JvmtiCodeBlobDesc*>* _code_blobs; // collected code blob events | |
400 | |
401 friend class JvmtiExport; | |
402 void register_stub(const char* name, address start, address end); | |
403 | |
404 public: | |
405 JvmtiDynamicCodeEventCollector() KERNEL_RETURN; | |
406 ~JvmtiDynamicCodeEventCollector() KERNEL_RETURN; | |
407 bool is_dynamic_code_event() { return true; } | |
408 | |
409 }; | |
410 | |
411 // Used to record vm internally allocated object oops and post | |
412 // vm object alloc event for objects visible to java world. | |
413 // Constructor enables JvmtiThreadState flag and all vm allocated | |
414 // objects are recorded in a growable array. When destructor is | |
415 // called the vm object alloc event is posted for each objects | |
416 // visible to java world. | |
417 // See jvm.cpp file for its usage. | |
418 // | |
419 class JvmtiVMObjectAllocEventCollector : public JvmtiEventCollector { | |
420 private: | |
421 GrowableArray<oop>* _allocated; // field to record vm internally allocated object oop. | |
422 bool _enable; // This flag is enabled in constructor and disabled | |
423 // in destructor before posting event. To avoid | |
424 // collection of objects allocated while running java code inside | |
425 // agent post_vm_object_alloc() event handler. | |
426 | |
427 //GC support | |
428 void oops_do(OopClosure* f); | |
429 | |
430 friend class JvmtiExport; | |
431 // Record vm allocated object oop. | |
432 inline void record_allocation(oop obj); | |
433 | |
434 //GC support | |
435 static void oops_do_for_all_threads(OopClosure* f); | |
436 | |
437 public: | |
438 JvmtiVMObjectAllocEventCollector() KERNEL_RETURN; | |
439 ~JvmtiVMObjectAllocEventCollector() KERNEL_RETURN; | |
440 bool is_vm_object_alloc_event() { return true; } | |
441 | |
442 bool is_enabled() { return _enable; } | |
443 void set_enabled(bool on) { _enable = on; } | |
444 }; | |
445 | |
446 | |
447 | |
448 // Marker class to disable the posting of VMObjectAlloc events | |
449 // within its scope. | |
450 // | |
451 // Usage :- | |
452 // | |
453 // { | |
454 // NoJvmtiVMObjectAllocMark njm; | |
455 // : | |
456 // // VMObjAlloc event will not be posted | |
457 // JvmtiExport::vm_object_alloc_event_collector(obj); | |
458 // : | |
459 // } | |
460 | |
461 class NoJvmtiVMObjectAllocMark : public StackObj { | |
462 private: | |
463 // enclosing collector if enabled, NULL otherwise | |
464 JvmtiVMObjectAllocEventCollector *_collector; | |
465 | |
466 bool was_enabled() { return _collector != NULL; } | |
467 | |
468 public: | |
469 NoJvmtiVMObjectAllocMark() KERNEL_RETURN; | |
470 ~NoJvmtiVMObjectAllocMark() KERNEL_RETURN; | |
471 }; | |
472 | |
473 | |
474 // Base class for reporting GC events to JVMTI. | |
475 class JvmtiGCMarker : public StackObj { | |
2125
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
1983
diff
changeset
|
476 public: |
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
1983
diff
changeset
|
477 JvmtiGCMarker() KERNEL_RETURN; |
7246a374a9f2
6458402: 3 jvmti tests fail with CMS and +ExplicitGCInvokesConcurrent
kamg
parents:
1983
diff
changeset
|
478 ~JvmtiGCMarker() KERNEL_RETURN; |
0 | 479 }; |
480 | |
481 // JvmtiHideSingleStepping is a helper class for hiding | |
482 // internal single step events. | |
483 class JvmtiHideSingleStepping : public StackObj { | |
484 private: | |
485 bool _single_step_hidden; | |
486 JavaThread * _thread; | |
487 | |
488 public: | |
489 JvmtiHideSingleStepping(JavaThread * thread) { | |
490 assert(thread != NULL, "sanity check"); | |
491 | |
492 _single_step_hidden = false; | |
493 _thread = thread; | |
494 if (JvmtiExport::should_post_single_step()) { | |
495 _single_step_hidden = JvmtiExport::hide_single_stepping(_thread); | |
496 } | |
497 } | |
498 | |
499 ~JvmtiHideSingleStepping() { | |
500 if (_single_step_hidden) { | |
501 JvmtiExport::expose_single_stepping(_thread); | |
502 } | |
503 } | |
504 }; | |
505 | |
1972 | 506 #endif // SHARE_VM_PRIMS_JVMTIEXPORT_HPP |