jdk-sandbox: comparison hotspot/src/share/vm/prims/jvmtiExport.cpp

equal deleted inserted replaced

-:caf5eb7dd4a7
+:882756847a04
 /*
-* Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 // we want to use the code above - but that needs the JNIHandle changes - later...
 // for now, use regular make_local
 jobject to_jobject(oop obj) { return JNIHandles::make_local(_thread,obj); }
 #endif
-jclass to_jclass(klassOop klass) { return (klass == NULL ? NULL : (jclass)to_jobject(Klass::cast(klass)->java_mirror())); }
+jclass to_jclass(Klass* klass) { return (klass == NULL ? NULL : (jclass)to_jobject(Klass::cast(klass)->java_mirror())); }
 jmethodID to_jmethodID(methodHandle method) { return method->jmethod_id(); }
 JNIEnv* jni_env() { return _jni_env; }
 };
 class JvmtiClassEventMark : public JvmtiThreadEventMark {
 private:
 jclass _jc;
 public:
-JvmtiClassEventMark(JavaThread *thread, klassOop klass) :
+JvmtiClassEventMark(JavaThread *thread, Klass* klass) :
 JvmtiThreadEventMark(thread) {
 _jc = to_jclass(klass);
 };
 jclass jni_class() { return _jc; }
 };
 }
 }
 #ifndef JVMTI_KERNEL
-static inline klassOop oop_to_klassOop(oop obj) {
+static inline Klass* oop_to_klass(oop obj) {
-klassOop k = obj->klass();
+Klass* k = obj->klass();
 // if the object is a java.lang.Class then return the java mirror
 if (k == SystemDictionary::Class_klass()) {
 if (!java_lang_Class::is_primitive(obj)) {
-k = java_lang_Class::as_klassOop(obj);
+k = java_lang_Class::as_Klass(obj);
 assert(k != NULL, "class for non-primitive mirror must exist");
 }
 }
 return k;
 }
 class JvmtiVMObjectAllocEventMark : public JvmtiClassEventMark  {
 private:
 jobject _jobj;
 jlong    _size;
 public:
-JvmtiVMObjectAllocEventMark(JavaThread *thread, oop obj) : JvmtiClassEventMark(thread, oop_to_klassOop(obj)) {
+JvmtiVMObjectAllocEventMark(JavaThread *thread, oop obj) : JvmtiClassEventMark(thread, oop_to_klass(obj)) {
 _jobj = (jobject)to_jobject(obj);
 _size = obj->size() * wordSize;
 };
 jobject jni_jobject() { return _jobj; }
 jlong size() { return _size; }
 ///////////////////////////////////////////////////////////////
 //
 // JvmtiExport
 //
-void JvmtiExport::post_raw_breakpoint(JavaThread *thread, methodOop method, address location) {
+void JvmtiExport::post_raw_breakpoint(JavaThread *thread, Method* method, address location) {
 HandleMark hm(thread);
 methodHandle mh(thread, method);
 JvmtiThreadState *state = thread->jvmti_thread_state();
 if (state == NULL) {
 //
 // JVMTI single step management
 //
-void JvmtiExport::at_single_stepping_point(JavaThread *thread, methodOop method, address location) {
+void JvmtiExport::at_single_stepping_point(JavaThread *thread, Method* method, address location) {
 assert(JvmtiExport::should_post_single_step(), "must be single stepping");
 HandleMark hm(thread);
 methodHandle mh(thread, method);
 } else {
 return false;
 }
 }
-void JvmtiExport::post_class_load(JavaThread *thread, klassOop klass) {
+void JvmtiExport::post_class_load(JavaThread *thread, Klass* klass) {
 HandleMark hm(thread);
 KlassHandle kh(thread, klass);
 EVT_TRIG_TRACE(JVMTI_EVENT_CLASS_LOAD, ("JVMTI [%s] Trg Class Load triggered",
 JvmtiTrace::safe_get_thread_name(thread)));
 }
 }
 }
-void JvmtiExport::post_class_prepare(JavaThread *thread, klassOop klass) {
+void JvmtiExport::post_class_prepare(JavaThread *thread, Klass* klass) {
 HandleMark hm(thread);
 KlassHandle kh(thread, klass);
 EVT_TRIG_TRACE(JVMTI_EVENT_CLASS_PREPARE, ("JVMTI [%s] Trg Class Prepare triggered",
 JvmtiTrace::safe_get_thread_name(thread)));
 }
 }
 }
 }
-void JvmtiExport::post_class_unload(klassOop klass) {
+void JvmtiExport::post_class_unload(Klass* klass) {
 Thread *thread = Thread::current();
 HandleMark hm(thread);
 KlassHandle kh(thread, klass);
 EVT_TRIG_TRACE(EXT_EVENT_CLASS_UNLOAD, ("JVMTI [?] Trg Class Unload triggered" ));
 }
 }
 }
 }
-void JvmtiExport::post_method_entry(JavaThread *thread, methodOop method, frame current_frame) {
+void JvmtiExport::post_method_entry(JavaThread *thread, Method* method, frame current_frame) {
 HandleMark hm(thread);
 methodHandle mh(thread, method);
 EVT_TRIG_TRACE(JVMTI_EVENT_METHOD_ENTRY, ("JVMTI [%s] Trg Method Entry triggered %s.%s",
 JvmtiTrace::safe_get_thread_name(thread),
 }
 }
 }
 }
-void JvmtiExport::post_method_exit(JavaThread *thread, methodOop method, frame current_frame) {
+void JvmtiExport::post_method_exit(JavaThread *thread, Method* method, frame current_frame) {
 HandleMark hm(thread);
 methodHandle mh(thread, method);
 EVT_TRIG_TRACE(JVMTI_EVENT_METHOD_EXIT, ("JVMTI [%s] Trg Method Exit triggered %s.%s",
 JvmtiTrace::safe_get_thread_name(thread),
 state->decr_cur_stack_depth();
 }
 // Todo: inline this for optimization
-void JvmtiExport::post_single_step(JavaThread *thread, methodOop method, address location) {
+void JvmtiExport::post_single_step(JavaThread *thread, Method* method, address location) {
 HandleMark hm(thread);
 methodHandle mh(thread, method);
 JvmtiThreadState *state = thread->jvmti_thread_state();
 if (state == NULL) {
 }
 }
 }
-void JvmtiExport::post_exception_throw(JavaThread *thread, methodOop method, address location, oop exception) {
+void JvmtiExport::post_exception_throw(JavaThread *thread, Method* method, address location, oop exception) {
 HandleMark hm(thread);
 methodHandle mh(thread, method);
 Handle exception_handle(thread, exception);
 JvmtiThreadState *state = thread->jvmti_thread_state();
 EXCEPTION_MARK;
 bool should_repeat;
 vframeStream st(thread);
 assert(!st.at_end(), "cannot be at end");
-methodOop current_method = NULL;
+Method* current_method = NULL;
 int current_bci = -1;
 do {
 current_method = st.method();
 current_bci = st.bci();
 do {
 should_repeat = false;
 KlassHandle eh_klass(thread, exception_handle()->klass());
 current_bci = current_method->fast_exception_handler_bci_for(
 eh_klass, current_bci, THREAD);
 if (HAS_PENDING_EXCEPTION) {
-exception_handle = KlassHandle(thread, PENDING_EXCEPTION);
+exception_handle = Handle(thread, PENDING_EXCEPTION);
 CLEAR_PENDING_EXCEPTION;
 should_repeat = true;
 }
 } while (should_repeat && (current_bci != -1));
 st.next();
 // frames may get popped because of this throw, be safe - invalidate cached depth
 state->invalidate_cur_stack_depth();
 }
-void JvmtiExport::notice_unwind_due_to_exception(JavaThread *thread, methodOop method, address location, oop exception, bool in_handler_frame) {
+void JvmtiExport::notice_unwind_due_to_exception(JavaThread *thread, Method* method, address location, oop exception, bool in_handler_frame) {
 HandleMark hm(thread);
 methodHandle mh(thread, method);
 Handle exception_handle(thread, exception);
 JvmtiThreadState *state = thread->jvmti_thread_state();
 }
 }
 }
 oop JvmtiExport::jni_GetField_probe(JavaThread *thread, jobject jobj, oop obj,
-klassOop klass, jfieldID fieldID, bool is_static) {
+Klass* klass, jfieldID fieldID, bool is_static) {
 if (*((int *)get_field_access_count_addr()) > 0 && thread->has_last_Java_frame()) {
 // At least one field access watch is set so we have more work
 // to do. This wrapper is used by entry points that allow us
 // to create handles in post_field_access_by_jni().
 post_field_access_by_jni(thread, obj, klass, fieldID, is_static);
 }
 return obj;
 }
 oop JvmtiExport::jni_GetField_probe_nh(JavaThread *thread, jobject jobj, oop obj,
-klassOop klass, jfieldID fieldID, bool is_static) {
+Klass* klass, jfieldID fieldID, bool is_static) {
 if (*((int *)get_field_access_count_addr()) > 0 && thread->has_last_Java_frame()) {
 // At least one field access watch is set so we have more work
 // to do. This wrapper is used by "quick" entry points that don't
 // allow us to create handles in post_field_access_by_jni(). We
 // override that with a ResetNoHandleMark.
 }
 return obj;
 }
 void JvmtiExport::post_field_access_by_jni(JavaThread *thread, oop obj,
-klassOop klass, jfieldID fieldID, bool is_static) {
+Klass* klass, jfieldID fieldID, bool is_static) {
 // We must be called with a Java context in order to provide reasonable
 // values for the klazz, method, and location fields. The callers of this
 // function don't make the call unless there is a Java context.
 assert(thread->has_last_Java_frame(), "must be called with a Java context");
 thread->last_frame().interpreter_frame_method(),
 thread->last_frame().interpreter_frame_bcp(),
 h_klass, h_obj, fieldID);
 }
-void JvmtiExport::post_field_access(JavaThread *thread, methodOop method,
+void JvmtiExport::post_field_access(JavaThread *thread, Method* method,
 address location, KlassHandle field_klass, Handle object, jfieldID field) {
 HandleMark hm(thread);
 methodHandle mh(thread, method);
 }
 }
 }
 oop JvmtiExport::jni_SetField_probe(JavaThread *thread, jobject jobj, oop obj,
-klassOop klass, jfieldID fieldID, bool is_static,
+Klass* klass, jfieldID fieldID, bool is_static,
 char sig_type, jvalue *value) {
 if (*((int *)get_field_modification_count_addr()) > 0 && thread->has_last_Java_frame()) {
 // At least one field modification watch is set so we have more work
 // to do. This wrapper is used by entry points that allow us
 // to create handles in post_field_modification_by_jni().
 }
 return obj;
 }
 oop JvmtiExport::jni_SetField_probe_nh(JavaThread *thread, jobject jobj, oop obj,
-klassOop klass, jfieldID fieldID, bool is_static,
+Klass* klass, jfieldID fieldID, bool is_static,
 char sig_type, jvalue *value) {
 if (*((int *)get_field_modification_count_addr()) > 0 && thread->has_last_Java_frame()) {
 // At least one field modification watch is set so we have more work
 // to do. This wrapper is used by "quick" entry points that don't
 // allow us to create handles in post_field_modification_by_jni(). We
 }
 return obj;
 }
 void JvmtiExport::post_field_modification_by_jni(JavaThread *thread, oop obj,
-klassOop klass, jfieldID fieldID, bool is_static,
+Klass* klass, jfieldID fieldID, bool is_static,
 char sig_type, jvalue *value) {
 // We must be called with a Java context in order to provide reasonable
 // values for the klazz, method, and location fields. The callers of this
 // function don't make the call unless there is a Java context.
 assert(thread->has_last_Java_frame(), "must be called with Java context");
 thread->last_frame().interpreter_frame_method(),
 thread->last_frame().interpreter_frame_bcp(),
 h_klass, h_obj, fieldID, sig_type, value);
 }
-void JvmtiExport::post_raw_field_modification(JavaThread *thread, methodOop method,
+void JvmtiExport::post_raw_field_modification(JavaThread *thread, Method* method,
 address location, KlassHandle field_klass, Handle object, jfieldID field,
 char sig_type, jvalue *value) {
 if (sig_type == 'I' || sig_type == 'Z' || sig_type == 'C' || sig_type == 'S') {
 // 'I' instructions are used for byte, char, short and int.
 if (sig_type == 'L') {
 JNIHandles::destroy_local(value->l);
 }
 }
-void JvmtiExport::post_field_modification(JavaThread *thread, methodOop method,
+void JvmtiExport::post_field_modification(JavaThread *thread, Method* method,
 address location, KlassHandle field_klass, Handle object, jfieldID field,
 char sig_type, jvalue *value_ptr) {
 HandleMark hm(thread);
 methodHandle mh(thread, method);
 }
 }
 }
 }
-void JvmtiExport::post_native_method_bind(methodOop method, address* function_ptr) {
+void JvmtiExport::post_native_method_bind(Method* method, address* function_ptr) {
 JavaThread* thread = JavaThread::current();
 assert(thread->thread_state() == _thread_in_vm, "must be in vm state");
 HandleMark hm(thread);
 methodHandle mh(thread, method);
 record->pcinfo[scope].bcis = (jint *)NEW_RESOURCE_ARRAY(jint, numstackframes);
 record->pcinfo[scope].numstackframes = numstackframes;
 int stackframe = 0;
 for(ScopeDesc* sd = nm->scope_desc_at(p->real_pc(nm));sd != NULL;sd = sd->sender()) {
 // sd->method() can be NULL for stubs but not for nmethods. To be completely robust, include an assert that we should never see a null sd->method()
-assert(!sd->method().is_null(), "sd->method() cannot be null.");
+assert(sd->method() != NULL, "sd->method() cannot be null.");
 record->pcinfo[scope].methods[stackframe] = sd->method()->jmethod_id();
 record->pcinfo[scope].bcis[stackframe] = sd->bci();
 stackframe++;
 }
 scope++;
 JvmtiEnvIterator it;
 for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {
 if (env->is_enabled(JVMTI_EVENT_VM_OBJECT_ALLOC)) {
 EVT_TRACE(JVMTI_EVENT_VM_OBJECT_ALLOC, ("JVMTI [%s] Evt vmobject alloc sent %s",
 JvmtiTrace::safe_get_thread_name(thread),
-object==NULL? "NULL" : Klass::cast(java_lang_Class::as_klassOop(object))->external_name()));
+object==NULL? "NULL" : Klass::cast(java_lang_Class::as_Klass(object))->external_name()));
 JvmtiVMObjectAllocEventMark jem(thread, h());
 JvmtiJavaThreadEventTransition jet(thread);
 jvmtiEventVMObjectAlloc callback = env->callbacks()->VMObjectAlloc;
 if (callback != NULL) {

changeset 13728	882756847a04
parent 13195	be27e1b6a4b9
child 14488	ab48109f7d1b
child 14471	f3a6b82e25cf