Mercurial > hg > truffle

comparison src/share/vm/prims/jvmtiExport.hpp @ 6854:fb19af007ffc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
7189254: Change makefiles for more flexibility to override defaults Summary: Change makefiles so that targets and parameters can be overridden by alternate makefiles. Reviewed-by: dholmes, coleenp
author jprovino
date Wed, 10 Oct 2012 14:35:58 -0400
parents da91efe96a93
children bd7a7ce2e264
comparison
equal deleted inserted replaced
6830:81e878c53615 6854:fb19af007ffc
44 class JvmtiManageCapabilities; 44 class JvmtiManageCapabilities;
45 class JvmtiEnv; 45 class JvmtiEnv;
46 class JvmtiThreadState; 46 class JvmtiThreadState;
47 class AttachOperation; 47 class AttachOperation;
48 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) \ 49 #define JVMTI_SUPPORT_FLAG(key) \
58 private: \ 50 private: \
59 const static bool _##key = false; \ 51 static bool _##key; \
60 public: \ 52 public: \
61 inline static void set_##key(bool on) { report_unsupported(on); } \ 53 inline static void set_##key(bool on) { \
62 inline static bool key() { return _##key; } 54 JVMTI_ONLY(_##key = (on != 0)); \
63 #endif // JVMTI_KERNEL 55 NOT_JVMTI(report_unsupported(on)); \
56 } \
57 inline static bool key() { \
58 JVMTI_ONLY(return _##key); \
59 NOT_JVMTI(return false); \
60 }
64 61
65 62
66 // This class contains the JVMTI interface for the rest of hotspot. 63 // This class contains the JVMTI interface for the rest of hotspot.
67 // 64 //
68 class JvmtiExport : public AllStatic { 65 class JvmtiExport : public AllStatic {
69 friend class VMStructs; 66 friend class VMStructs;
70 private: 67 private:
68
69 #if INCLUDE_JVMTI
71 static int _field_access_count; 70 static int _field_access_count;
72 static int _field_modification_count; 71 static int _field_modification_count;
73 72
74 static bool _can_access_local_variables; 73 static bool _can_access_local_variables;
75 static bool _can_hotswap_or_post_breakpoint; 74 static bool _can_hotswap_or_post_breakpoint;
76 static bool _can_modify_any_class; 75 static bool _can_modify_any_class;
77 static bool _can_walk_any_space; 76 static bool _can_walk_any_space;
77 #endif // INCLUDE_JVMTI
78 78
79 JVMTI_SUPPORT_FLAG(can_get_source_debug_extension) 79 JVMTI_SUPPORT_FLAG(can_get_source_debug_extension)
80 JVMTI_SUPPORT_FLAG(can_maintain_original_method_order) 80 JVMTI_SUPPORT_FLAG(can_maintain_original_method_order)
81 JVMTI_SUPPORT_FLAG(can_post_interpreter_events) 81 JVMTI_SUPPORT_FLAG(can_post_interpreter_events)
82 JVMTI_SUPPORT_FLAG(can_post_on_exceptions) 82 JVMTI_SUPPORT_FLAG(can_post_on_exceptions)
123 // If flag cannot be implemented, give an error if on=true 123 // If flag cannot be implemented, give an error if on=true
124 static void report_unsupported(bool on); 124 static void report_unsupported(bool on);
125 125
126 // these should only be called by the friend class 126 // these should only be called by the friend class
127 friend class JvmtiManageCapabilities; 127 friend class JvmtiManageCapabilities;
128 inline static void set_can_modify_any_class(bool on) { _can_modify_any_class = (on != 0); } 128 inline static void set_can_modify_any_class(bool on) {
129 inline static void set_can_access_local_variables(bool on) { _can_access_local_variables = (on != 0); } 129 JVMTI_ONLY(_can_modify_any_class = (on != 0);)
130 inline static void set_can_hotswap_or_post_breakpoint(bool on) { _can_hotswap_or_post_breakpoint = (on != 0); } 130 }
131 inline static void set_can_walk_any_space(bool on) { _can_walk_any_space = (on != 0); } 131 inline static void set_can_access_local_variables(bool on) {
132 JVMTI_ONLY(_can_access_local_variables = (on != 0);)
133 }
134 inline static void set_can_hotswap_or_post_breakpoint(bool on) {
135 JVMTI_ONLY(_can_hotswap_or_post_breakpoint = (on != 0);)
136 }
137 inline static void set_can_walk_any_space(bool on) {
138 JVMTI_ONLY(_can_walk_any_space = (on != 0);)
139 }
132 140
133 enum { 141 enum {
134 JVMTI_VERSION_MASK = 0x70000000, 142 JVMTI_VERSION_MASK = 0x70000000,
135 JVMTI_VERSION_VALUE = 0x30000000, 143 JVMTI_VERSION_VALUE = 0x30000000,
136 JVMDI_VERSION_VALUE = 0x20000000 144 JVMDI_VERSION_VALUE = 0x20000000
142 150
143 151
144 // posts a DynamicCodeGenerated event (internal/private implementation). 152 // posts a DynamicCodeGenerated event (internal/private implementation).
145 // The public post_dynamic_code_generated* functions make use of the 153 // The public post_dynamic_code_generated* functions make use of the
146 // internal implementation. Also called from JvmtiDeferredEvent::post() 154 // internal implementation. Also called from JvmtiDeferredEvent::post()
147 static void post_dynamic_code_generated_internal(const char *name, const void *code_begin, const void *code_end) KERNEL_RETURN; 155 static void post_dynamic_code_generated_internal(const char *name, const void *code_begin, const void *code_end) NOT_JVMTI_RETURN;
148 156
149 private: 157 private:
150 158
151 // GenerateEvents support to allow posting of CompiledMethodLoad and 159 // GenerateEvents support to allow posting of CompiledMethodLoad and
152 // DynamicCodeGenerated events for a given environment. 160 // DynamicCodeGenerated events for a given environment.
153 friend class JvmtiCodeBlobEvents; 161 friend class JvmtiCodeBlobEvents;
154 162
155 static void post_compiled_method_load(JvmtiEnv* env, const jmethodID method, const jint length, 163 static void post_compiled_method_load(JvmtiEnv* env, const jmethodID method, const jint length,
156 const void *code_begin, const jint map_length, 164 const void *code_begin, const jint map_length,
157 const jvmtiAddrLocationMap* map) KERNEL_RETURN; 165 const jvmtiAddrLocationMap* map) NOT_JVMTI_RETURN;
158 static void post_dynamic_code_generated(JvmtiEnv* env, const char *name, const void *code_begin, 166 static void post_dynamic_code_generated(JvmtiEnv* env, const char *name, const void *code_begin,
159 const void *code_end) KERNEL_RETURN; 167 const void *code_end) NOT_JVMTI_RETURN;
160 168
161 // The RedefineClasses() API breaks some invariants in the "regular" 169 // The RedefineClasses() API breaks some invariants in the "regular"
162 // system. For example, there are sanity checks when GC'ing nmethods 170 // system. For example, there are sanity checks when GC'ing nmethods
163 // that require the containing class to be unloading. However, when a 171 // that require the containing class to be unloading. However, when a
164 // method is redefined, the old method and nmethod can become GC'able 172 // method is redefined, the old method and nmethod can become GC'able
176 // only be set by the friend class and can be queried by other sub 184 // only be set by the friend class and can be queried by other sub
177 // systems as needed to relax invariant checks. 185 // systems as needed to relax invariant checks.
178 static bool _has_redefined_a_class; 186 static bool _has_redefined_a_class;
179 friend class VM_RedefineClasses; 187 friend class VM_RedefineClasses;
180 inline static void set_has_redefined_a_class() { 188 inline static void set_has_redefined_a_class() {
181 _has_redefined_a_class = true; 189 JVMTI_ONLY(_has_redefined_a_class = true;)
182 } 190 }
183
184 // Flag to indicate if the compiler has recorded all dependencies. When the 191 // 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 192 // 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 193 // records all dependencies from startup. However if the capability is first
187 // enabled some time later then the dependencies recorded by the compiler 194 // enabled some time later then the dependencies recorded by the compiler
188 // are incomplete. This flag is used by RedefineClasses to know if the 195 // are incomplete. This flag is used by RedefineClasses to know if the
189 // dependency information is complete or not. 196 // dependency information is complete or not.
190 static bool _all_dependencies_are_recorded; 197 static bool _all_dependencies_are_recorded;
191 198
192 public: 199 public:
193 inline static bool has_redefined_a_class() { 200 inline static bool has_redefined_a_class() {
194 return _has_redefined_a_class; 201 JVMTI_ONLY(return _has_redefined_a_class);
202 NOT_JVMTI(return false);
195 } 203 }
196 204
197 inline static bool all_dependencies_are_recorded() { 205 inline static bool all_dependencies_are_recorded() {
198 return _all_dependencies_are_recorded; 206 return _all_dependencies_are_recorded;
199 } 207 }
202 _all_dependencies_are_recorded = (on != 0); 210 _all_dependencies_are_recorded = (on != 0);
203 } 211 }
204 212
205 213
206 // let JVMTI know that the JVM_OnLoad code is running 214 // let JVMTI know that the JVM_OnLoad code is running
207 static void enter_onload_phase(); 215 static void enter_onload_phase() NOT_JVMTI_RETURN;
208 216
209 // let JVMTI know that the VM isn't up yet (and JVM_OnLoad code isn't running) 217 // let JVMTI know that the VM isn't up yet (and JVM_OnLoad code isn't running)
210 static void enter_primordial_phase(); 218 static void enter_primordial_phase() NOT_JVMTI_RETURN;
211 219
212 // let JVMTI know that the VM isn't up yet but JNI is live 220 // let JVMTI know that the VM isn't up yet but JNI is live
213 static void enter_start_phase(); 221 static void enter_start_phase() NOT_JVMTI_RETURN;
214 222
215 // let JVMTI know that the VM is fully up and running now 223 // let JVMTI know that the VM is fully up and running now
216 static void enter_live_phase(); 224 static void enter_live_phase() NOT_JVMTI_RETURN;
217 225
218 // ------ can_* conditions (below) are set at OnLoad and never changed ------------ 226 // ------ can_* conditions (below) are set at OnLoad and never changed ------------
219 inline static bool can_modify_any_class() { return _can_modify_any_class; } 227 inline static bool can_modify_any_class() {
220 inline static bool can_access_local_variables() { return _can_access_local_variables; } 228 JVMTI_ONLY(return _can_modify_any_class);
221 inline static bool can_hotswap_or_post_breakpoint() { return _can_hotswap_or_post_breakpoint; } 229 NOT_JVMTI(return false);
222 inline static bool can_walk_any_space() { return _can_walk_any_space; } 230 }
231 inline static bool can_access_local_variables() {
232 JVMTI_ONLY(return _can_access_local_variables);
233 NOT_JVMTI(return false);
234 }
235 inline static bool can_hotswap_or_post_breakpoint() {
236 JVMTI_ONLY(return _can_hotswap_or_post_breakpoint);
237 NOT_JVMTI(return false);
238 }
239 inline static bool can_walk_any_space() {
240 JVMTI_ONLY(return _can_walk_any_space);
241 NOT_JVMTI(return false);
242 }
223 243
224 // field access management 244 // field access management
225 static address get_field_access_count_addr(); 245 static address get_field_access_count_addr() NOT_JVMTI_RETURN_(0);
226 246
227 // field modification management 247 // field modification management
228 static address get_field_modification_count_addr(); 248 static address get_field_modification_count_addr() NOT_JVMTI_RETURN_(0);
229 249
230 // ----------------- 250 // -----------------
231 251
232 static bool is_jvmti_version(jint version) { return (version & JVMTI_VERSION_MASK) == JVMTI_VERSION_VALUE; } 252 static bool is_jvmti_version(jint version) {
233 static bool is_jvmdi_version(jint version) { return (version & JVMTI_VERSION_MASK) == JVMDI_VERSION_VALUE; } 253 JVMTI_ONLY(return (version & JVMTI_VERSION_MASK) == JVMTI_VERSION_VALUE);
234 static jint get_jvmti_interface(JavaVM *jvm, void **penv, jint version); 254 NOT_JVMTI(return false);
255 }
256 static bool is_jvmdi_version(jint version) {
257 JVMTI_ONLY(return (version & JVMTI_VERSION_MASK) == JVMDI_VERSION_VALUE);
258 NOT_JVMTI(return false);
259 }
260 static jint get_jvmti_interface(JavaVM *jvm, void **penv, jint version) NOT_JVMTI_RETURN_(0);
235 static void decode_version_values(jint version, int * major, int * minor, 261 static void decode_version_values(jint version, int * major, int * minor,
236 int * micro); 262 int * micro) NOT_JVMTI_RETURN;
237 263
238 // single stepping management methods 264 // single stepping management methods
239 static void at_single_stepping_point(JavaThread *thread, Method* method, address location) KERNEL_RETURN; 265 static void at_single_stepping_point(JavaThread *thread, Method* method, address location) NOT_JVMTI_RETURN;
240 static void expose_single_stepping(JavaThread *thread) KERNEL_RETURN; 266 static void expose_single_stepping(JavaThread *thread) NOT_JVMTI_RETURN;
241 static bool hide_single_stepping(JavaThread *thread) KERNEL_RETURN_(false); 267 static bool hide_single_stepping(JavaThread *thread) NOT_JVMTI_RETURN_(false);
242 268
243 // Methods that notify the debugger that something interesting has happened in the VM. 269 // Methods that notify the debugger that something interesting has happened in the VM.
244 static void post_vm_start (); 270 static void post_vm_start () NOT_JVMTI_RETURN;
245 static void post_vm_initialized (); 271 static void post_vm_initialized () NOT_JVMTI_RETURN;
246 static void post_vm_death (); 272 static void post_vm_death () NOT_JVMTI_RETURN;
247 273
248 static void post_single_step (JavaThread *thread, Method* method, address location) KERNEL_RETURN; 274 static void post_single_step (JavaThread *thread, Method* method, address location) NOT_JVMTI_RETURN;
249 static void post_raw_breakpoint (JavaThread *thread, Method* method, address location) KERNEL_RETURN; 275 static void post_raw_breakpoint (JavaThread *thread, Method* method, address location) NOT_JVMTI_RETURN;
250 276
251 static void post_exception_throw (JavaThread *thread, Method* method, address location, oop exception) KERNEL_RETURN; 277 static void post_exception_throw (JavaThread *thread, Method* method, address location, oop exception) NOT_JVMTI_RETURN;
252 static void notice_unwind_due_to_exception (JavaThread *thread, Method* method, address location, oop exception, bool in_handler_frame) KERNEL_RETURN; 278 static void notice_unwind_due_to_exception (JavaThread *thread, Method* method, address location, oop exception, bool in_handler_frame) NOT_JVMTI_RETURN;
253 279
254 static oop jni_GetField_probe (JavaThread *thread, jobject jobj, 280 static oop jni_GetField_probe (JavaThread *thread, jobject jobj,
255 oop obj, Klass* klass, jfieldID fieldID, bool is_static) 281 oop obj, Klass* klass, jfieldID fieldID, bool is_static)
256 KERNEL_RETURN_(NULL); 282 NOT_JVMTI_RETURN_(NULL);
257 static oop jni_GetField_probe_nh (JavaThread *thread, jobject jobj, 283 static oop jni_GetField_probe_nh (JavaThread *thread, jobject jobj,
258 oop obj, Klass* klass, jfieldID fieldID, bool is_static) 284 oop obj, Klass* klass, jfieldID fieldID, bool is_static)
259 KERNEL_RETURN_(NULL); 285 NOT_JVMTI_RETURN_(NULL);
260 static void post_field_access_by_jni (JavaThread *thread, oop obj, 286 static void post_field_access_by_jni (JavaThread *thread, oop obj,
261 Klass* klass, jfieldID fieldID, bool is_static) KERNEL_RETURN; 287 Klass* klass, jfieldID fieldID, bool is_static) NOT_JVMTI_RETURN;
262 static void post_field_access (JavaThread *thread, Method* method, 288 static void post_field_access (JavaThread *thread, Method* method,
263 address location, KlassHandle field_klass, Handle object, jfieldID field) KERNEL_RETURN; 289 address location, KlassHandle field_klass, Handle object, jfieldID field) NOT_JVMTI_RETURN;
264 static oop jni_SetField_probe (JavaThread *thread, jobject jobj, 290 static oop jni_SetField_probe (JavaThread *thread, jobject jobj,
265 oop obj, Klass* klass, jfieldID fieldID, bool is_static, char sig_type, 291 oop obj, Klass* klass, jfieldID fieldID, bool is_static, char sig_type,
266 jvalue *value) KERNEL_RETURN_(NULL); 292 jvalue *value) NOT_JVMTI_RETURN_(NULL);
267 static oop jni_SetField_probe_nh (JavaThread *thread, jobject jobj, 293 static oop jni_SetField_probe_nh (JavaThread *thread, jobject jobj,
268 oop obj, Klass* klass, jfieldID fieldID, bool is_static, char sig_type, 294 oop obj, Klass* klass, jfieldID fieldID, bool is_static, char sig_type,
269 jvalue *value) KERNEL_RETURN_(NULL); 295 jvalue *value) NOT_JVMTI_RETURN_(NULL);
270 static void post_field_modification_by_jni(JavaThread *thread, oop obj, 296 static void post_field_modification_by_jni(JavaThread *thread, oop obj,
271 Klass* klass, jfieldID fieldID, bool is_static, char sig_type, 297 Klass* klass, jfieldID fieldID, bool is_static, char sig_type,
272 jvalue *value); 298 jvalue *value);
273 static void post_raw_field_modification(JavaThread *thread, Method* method, 299 static void post_raw_field_modification(JavaThread *thread, Method* method,
274 address location, KlassHandle field_klass, Handle object, jfieldID field, 300 address location, KlassHandle field_klass, Handle object, jfieldID field,
275 char sig_type, jvalue *value) KERNEL_RETURN; 301 char sig_type, jvalue *value) NOT_JVMTI_RETURN;
276 302
277 static void post_method_entry (JavaThread *thread, Method* method, frame current_frame) KERNEL_RETURN; 303 static void post_method_entry (JavaThread *thread, Method* method, frame current_frame) NOT_JVMTI_RETURN;
278 static void post_method_exit (JavaThread *thread, Method* method, frame current_frame) KERNEL_RETURN; 304 static void post_method_exit (JavaThread *thread, Method* method, frame current_frame) NOT_JVMTI_RETURN;
279 305
280 static void post_class_load (JavaThread *thread, Klass* klass) KERNEL_RETURN; 306 static void post_class_load (JavaThread *thread, Klass* klass) NOT_JVMTI_RETURN;
281 static void post_class_unload (Klass* klass) KERNEL_RETURN; 307 static void post_class_unload (Klass* klass) NOT_JVMTI_RETURN;
282 static void post_class_prepare (JavaThread *thread, Klass* klass) KERNEL_RETURN; 308 static void post_class_prepare (JavaThread *thread, Klass* klass) NOT_JVMTI_RETURN;
283 309
284 static void post_thread_start (JavaThread *thread) KERNEL_RETURN; 310 static void post_thread_start (JavaThread *thread) NOT_JVMTI_RETURN;
285 static void post_thread_end (JavaThread *thread) KERNEL_RETURN; 311 static void post_thread_end (JavaThread *thread) NOT_JVMTI_RETURN;
286 312
287 // Support for java.lang.instrument agent loading. 313 // Support for java.lang.instrument agent loading.
288 static bool _should_post_class_file_load_hook; 314 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; } 315 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; } 316 inline static bool should_post_class_file_load_hook() {
317 JVMTI_ONLY(return _should_post_class_file_load_hook);
318 NOT_JVMTI(return false;)
319 }
291 static void post_class_file_load_hook(Symbol* h_name, Handle class_loader, 320 static void post_class_file_load_hook(Symbol* h_name, Handle class_loader,
292 Handle h_protection_domain, 321 Handle h_protection_domain,
293 unsigned char **data_ptr, unsigned char **end_ptr, 322 unsigned char **data_ptr, unsigned char **end_ptr,
294 unsigned char **cached_data_ptr, 323 unsigned char **cached_data_ptr,
295 jint *cached_length_ptr); 324 jint *cached_length_ptr) NOT_JVMTI_RETURN;
296 static void post_native_method_bind(Method* method, address* function_ptr) KERNEL_RETURN; 325 static void post_native_method_bind(Method* method, address* function_ptr) NOT_JVMTI_RETURN;
297 static void post_compiled_method_load(nmethod *nm) KERNEL_RETURN; 326 static void post_compiled_method_load(nmethod *nm) NOT_JVMTI_RETURN;
298 static void post_dynamic_code_generated(const char *name, const void *code_begin, const void *code_end) KERNEL_RETURN; 327 static void post_dynamic_code_generated(const char *name, const void *code_begin, const void *code_end) NOT_JVMTI_RETURN;
299 328
300 // used to post a CompiledMethodUnload event 329 // used to post a CompiledMethodUnload event
301 static void post_compiled_method_unload(jmethodID mid, const void *code_begin) KERNEL_RETURN; 330 static void post_compiled_method_unload(jmethodID mid, const void *code_begin) NOT_JVMTI_RETURN;
302 331
303 // similiar to post_dynamic_code_generated except that it can be used to 332 // 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 333 // post a DynamicCodeGenerated event while holding locks in the VM. Any event
305 // posted using this function is recorded by the enclosing event collector 334 // posted using this function is recorded by the enclosing event collector
306 // -- JvmtiDynamicCodeEventCollector. 335 // -- JvmtiDynamicCodeEventCollector.
307 static void post_dynamic_code_generated_while_holding_locks(const char* name, address code_begin, address code_end) KERNEL_RETURN; 336 static void post_dynamic_code_generated_while_holding_locks(const char* name, address code_begin, address code_end) NOT_JVMTI_RETURN;
308 337
309 static void post_garbage_collection_finish() KERNEL_RETURN; 338 static void post_garbage_collection_finish() NOT_JVMTI_RETURN;
310 static void post_garbage_collection_start() KERNEL_RETURN; 339 static void post_garbage_collection_start() NOT_JVMTI_RETURN;
311 static void post_data_dump() KERNEL_RETURN; 340 static void post_data_dump() NOT_JVMTI_RETURN;
312 static void post_monitor_contended_enter(JavaThread *thread, ObjectMonitor *obj_mntr) KERNEL_RETURN; 341 static void post_monitor_contended_enter(JavaThread *thread, ObjectMonitor *obj_mntr) NOT_JVMTI_RETURN;
313 static void post_monitor_contended_entered(JavaThread *thread, ObjectMonitor *obj_mntr) KERNEL_RETURN; 342 static void post_monitor_contended_entered(JavaThread *thread, ObjectMonitor *obj_mntr) NOT_JVMTI_RETURN;
314 static void post_monitor_wait(JavaThread *thread, oop obj, jlong timeout) KERNEL_RETURN; 343 static void post_monitor_wait(JavaThread *thread, oop obj, jlong timeout) NOT_JVMTI_RETURN;
315 static void post_monitor_waited(JavaThread *thread, ObjectMonitor *obj_mntr, jboolean timed_out) KERNEL_RETURN; 344 static void post_monitor_waited(JavaThread *thread, ObjectMonitor *obj_mntr, jboolean timed_out) NOT_JVMTI_RETURN;
316 static void post_object_free(JvmtiEnv* env, jlong tag) KERNEL_RETURN; 345 static void post_object_free(JvmtiEnv* env, jlong tag) NOT_JVMTI_RETURN;
317 static void post_resource_exhausted(jint resource_exhausted_flags, const char* detail) KERNEL_RETURN; 346 static void post_resource_exhausted(jint resource_exhausted_flags, const char* detail) NOT_JVMTI_RETURN;
318 static void record_vm_internal_object_allocation(oop object) KERNEL_RETURN; 347 static void record_vm_internal_object_allocation(oop object) NOT_JVMTI_RETURN;
319 // Post objects collected by vm_object_alloc_event_collector. 348 // Post objects collected by vm_object_alloc_event_collector.
320 static void post_vm_object_alloc(JavaThread *thread, oop object) KERNEL_RETURN; 349 static void post_vm_object_alloc(JavaThread *thread, oop object) NOT_JVMTI_RETURN;
321 // Collects vm internal objects for later event posting. 350 // Collects vm internal objects for later event posting.
322 inline static void vm_object_alloc_event_collector(oop object) { 351 inline static void vm_object_alloc_event_collector(oop object) {
323 if (should_post_vm_object_alloc()) { 352 if (should_post_vm_object_alloc()) {
324 record_vm_internal_object_allocation(object); 353 record_vm_internal_object_allocation(object);
325 } 354 }
329 post_resource_exhausted(JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR, 358 post_resource_exhausted(JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR,
330 "Requested array size exceeds VM limit"); 359 "Requested array size exceeds VM limit");
331 } 360 }
332 } 361 }
333 362
334 static void cleanup_thread (JavaThread* thread) KERNEL_RETURN; 363 static void cleanup_thread (JavaThread* thread) NOT_JVMTI_RETURN;
335 364
336 static void oops_do(OopClosure* f) KERNEL_RETURN; 365 static void oops_do(OopClosure* f) NOT_JVMTI_RETURN;
337 static void weak_oops_do(BoolObjectClosure* b, OopClosure* f) KERNEL_RETURN; 366 static void weak_oops_do(BoolObjectClosure* b, OopClosure* f) NOT_JVMTI_RETURN;
338 static void gc_epilogue() KERNEL_RETURN; 367 static void gc_epilogue() NOT_JVMTI_RETURN;
339 368
340 static void transition_pending_onload_raw_monitors() KERNEL_RETURN; 369 static void transition_pending_onload_raw_monitors() NOT_JVMTI_RETURN;
341 370
342 #ifndef SERVICES_KERNEL
343 // attach support 371 // attach support
344 static jint load_agent_library(AttachOperation* op, outputStream* out); 372 static jint load_agent_library(AttachOperation* op, outputStream* out) NOT_JVMTI_RETURN_(JNI_ERR);
345 #endif // SERVICES_KERNEL
346 373
347 // SetNativeMethodPrefix support 374 // SetNativeMethodPrefix support
348 static char** get_all_native_method_prefixes(int* count_ptr); 375 static char** get_all_native_method_prefixes(int* count_ptr) NOT_JVMTI_RETURN_(NULL);
349 }; 376 };
350 377
351 // Support class used by JvmtiDynamicCodeEventCollector and others. It 378 // Support class used by JvmtiDynamicCodeEventCollector and others. It
352 // describes a single code blob by name and address range. 379 // describes a single code blob by name and address range.
353 class JvmtiCodeBlobDesc : public CHeapObj<mtInternal> { 380 class JvmtiCodeBlobDesc : public CHeapObj<mtInternal> {
406 433
407 friend class JvmtiExport; 434 friend class JvmtiExport;
408 void register_stub(const char* name, address start, address end); 435 void register_stub(const char* name, address start, address end);
409 436
410 public: 437 public:
411 JvmtiDynamicCodeEventCollector() KERNEL_RETURN; 438 JvmtiDynamicCodeEventCollector() NOT_JVMTI_RETURN;
412 ~JvmtiDynamicCodeEventCollector() KERNEL_RETURN; 439 ~JvmtiDynamicCodeEventCollector() NOT_JVMTI_RETURN;
413 bool is_dynamic_code_event() { return true; } 440 bool is_dynamic_code_event() { return true; }
414 441
415 }; 442 };
416 443
417 // Used to record vm internally allocated object oops and post 444 // Used to record vm internally allocated object oops and post
439 466
440 //GC support 467 //GC support
441 static void oops_do_for_all_threads(OopClosure* f); 468 static void oops_do_for_all_threads(OopClosure* f);
442 469
443 public: 470 public:
444 JvmtiVMObjectAllocEventCollector() KERNEL_RETURN; 471 JvmtiVMObjectAllocEventCollector() NOT_JVMTI_RETURN;
445 ~JvmtiVMObjectAllocEventCollector() KERNEL_RETURN; 472 ~JvmtiVMObjectAllocEventCollector() NOT_JVMTI_RETURN;
446 bool is_vm_object_alloc_event() { return true; } 473 bool is_vm_object_alloc_event() { return true; }
447 474
448 bool is_enabled() { return _enable; } 475 bool is_enabled() { return _enable; }
449 void set_enabled(bool on) { _enable = on; } 476 void set_enabled(bool on) { _enable = on; }
450 }; 477 };
470 JvmtiVMObjectAllocEventCollector *_collector; 497 JvmtiVMObjectAllocEventCollector *_collector;
471 498
472 bool was_enabled() { return _collector != NULL; } 499 bool was_enabled() { return _collector != NULL; }
473 500
474 public: 501 public:
475 NoJvmtiVMObjectAllocMark() KERNEL_RETURN; 502 NoJvmtiVMObjectAllocMark() NOT_JVMTI_RETURN;
476 ~NoJvmtiVMObjectAllocMark() KERNEL_RETURN; 503 ~NoJvmtiVMObjectAllocMark() NOT_JVMTI_RETURN;
477 }; 504 };
478 505
479 506
480 // Base class for reporting GC events to JVMTI. 507 // Base class for reporting GC events to JVMTI.
481 class JvmtiGCMarker : public StackObj { 508 class JvmtiGCMarker : public StackObj {
482 public: 509 public:
483 JvmtiGCMarker() KERNEL_RETURN; 510 JvmtiGCMarker() NOT_JVMTI_RETURN;
484 ~JvmtiGCMarker() KERNEL_RETURN; 511 ~JvmtiGCMarker() NOT_JVMTI_RETURN;
485 }; 512 };
486 513
487 // JvmtiHideSingleStepping is a helper class for hiding 514 // JvmtiHideSingleStepping is a helper class for hiding
488 // internal single step events. 515 // internal single step events.
489 class JvmtiHideSingleStepping : public StackObj { 516 class JvmtiHideSingleStepping : public StackObj {