diff -r caf5eb7dd4a7 -r 882756847a04 hotspot/src/share/vm/prims/jvm.cpp --- a/hotspot/src/share/vm/prims/jvm.cpp Fri Aug 31 16:39:35 2012 -0700 +++ b/hotspot/src/share/vm/prims/jvm.cpp Sat Sep 01 13:25:18 2012 -0400 @@ -35,7 +35,7 @@ #include "oops/fieldStreams.hpp" #include "oops/instanceKlass.hpp" #include "oops/objArrayKlass.hpp" -#include "oops/methodOop.hpp" +#include "oops/method.hpp" #include "prims/jvm.h" #include "prims/jvm_misc.hpp" #include "prims/jvmtiExport.hpp" @@ -120,29 +120,29 @@ and thus can only support use of handles passed in. */ -static void trace_class_resolution_impl(klassOop to_class, TRAPS) { +static void trace_class_resolution_impl(Klass* to_class, TRAPS) { ResourceMark rm; int line_number = -1; const char * source_file = NULL; const char * trace = "explicit"; - klassOop caller = NULL; + Klass* caller = NULL; JavaThread* jthread = JavaThread::current(); if (jthread->has_last_Java_frame()) { vframeStream vfst(jthread); // scan up the stack skipping ClassLoader, AccessController and PrivilegedAction frames TempNewSymbol access_controller = SymbolTable::new_symbol("java/security/AccessController", CHECK); - klassOop access_controller_klass = SystemDictionary::resolve_or_fail(access_controller, false, CHECK); + Klass* access_controller_klass = SystemDictionary::resolve_or_fail(access_controller, false, CHECK); TempNewSymbol privileged_action = SymbolTable::new_symbol("java/security/PrivilegedAction", CHECK); - klassOop privileged_action_klass = SystemDictionary::resolve_or_fail(privileged_action, false, CHECK); - - methodOop last_caller = NULL; + Klass* privileged_action_klass = SystemDictionary::resolve_or_fail(privileged_action, false, CHECK); + + Method* last_caller = NULL; while (!vfst.at_end()) { - methodOop m = vfst.method(); - if (!vfst.method()->method_holder()->klass_part()->is_subclass_of(SystemDictionary::ClassLoader_klass())&& - !vfst.method()->method_holder()->klass_part()->is_subclass_of(access_controller_klass) && - !vfst.method()->method_holder()->klass_part()->is_subclass_of(privileged_action_klass)) { + Method* m = vfst.method(); + if (!vfst.method()->method_holder()->is_subclass_of(SystemDictionary::ClassLoader_klass())&& + !vfst.method()->method_holder()->is_subclass_of(access_controller_klass) && + !vfst.method()->method_holder()->is_subclass_of(privileged_action_klass)) { break; } last_caller = m; @@ -153,17 +153,17 @@ // that caller, otherwise keep quiet since this should be picked up elsewhere. bool found_it = false; if (!vfst.at_end() && - instanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class() && + InstanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class() && vfst.method()->name() == vmSymbols::forName0_name()) { vfst.next(); if (!vfst.at_end() && - instanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class() && + InstanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class() && vfst.method()->name() == vmSymbols::forName_name()) { vfst.next(); found_it = true; } } else if (last_caller != NULL && - instanceKlass::cast(last_caller->method_holder())->name() == + InstanceKlass::cast(last_caller->method_holder())->name() == vmSymbols::java_lang_ClassLoader() && (last_caller->name() == vmSymbols::loadClassInternal_name() || last_caller->name() == vmSymbols::loadClass_name())) { @@ -182,7 +182,7 @@ // show method name if it's a native method trace = vfst.method()->name_and_sig_as_C_string(); } - Symbol* s = instanceKlass::cast(caller)->source_file_name(); + Symbol* s = InstanceKlass::cast(caller)->source_file_name(); if (s != NULL) { source_file = s->as_C_string(); } @@ -202,7 +202,7 @@ } } -void trace_class_resolution(klassOop to_class) { +void trace_class_resolution(Klass* to_class) { EXCEPTION_MARK; trace_class_resolution_impl(to_class, THREAD); if (HAS_PENDING_EXCEPTION) { @@ -522,7 +522,6 @@ JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms)) JVMWrapper("JVM_MonitorWait"); Handle obj(THREAD, JNIHandles::resolve_non_null(handle)); - assert(obj->is_instance() || obj->is_array(), "JVM_MonitorWait must apply to an object"); JavaThreadInObjectWaitState jtiows(thread, ms != 0); if (JvmtiExport::should_post_monitor_wait()) { JvmtiExport::post_monitor_wait((JavaThread *)THREAD, (oop)obj(), ms); @@ -534,7 +533,6 @@ JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle)) JVMWrapper("JVM_MonitorNotify"); Handle obj(THREAD, JNIHandles::resolve_non_null(handle)); - assert(obj->is_instance() || obj->is_array(), "JVM_MonitorNotify must apply to an object"); ObjectSynchronizer::notify(obj, CHECK); JVM_END @@ -542,7 +540,6 @@ JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle)) JVMWrapper("JVM_MonitorNotifyAll"); Handle obj(THREAD, JNIHandles::resolve_non_null(handle)); - assert(obj->is_instance() || obj->is_array(), "JVM_MonitorNotifyAll must apply to an object"); ObjectSynchronizer::notifyall(obj, CHECK); JVM_END @@ -555,7 +552,7 @@ #ifdef ASSERT // Just checking that the cloneable flag is set correct - if (obj->is_javaArray()) { + if (obj->is_array()) { guarantee(klass->is_cloneable(), "all arrays are cloneable"); } else { guarantee(obj->is_instance(), "should be instanceOop"); @@ -574,7 +571,7 @@ // Make shallow object copy const int size = obj->size(); oop new_obj = NULL; - if (obj->is_javaArray()) { + if (obj->is_array()) { const int length = ((arrayOop)obj())->length(); new_obj = CollectedHeap::array_allocate(klass, size, length, CHECK_NULL); } else { @@ -604,7 +601,7 @@ // "gc-robust" by this stage. if (klass->has_finalizer()) { assert(obj->is_instance(), "should be instanceOop"); - new_obj = instanceKlass::register_finalizer(instanceOop(new_obj), CHECK_NULL); + new_obj = InstanceKlass::register_finalizer(instanceOop(new_obj), CHECK_NULL); } return JNIHandles::make_local(env, oop(new_obj)); @@ -677,7 +674,7 @@ JVM_ENTRY(jclass, JVM_GetCallerClass(JNIEnv* env, int depth)) JVMWrapper("JVM_GetCallerClass"); - klassOop k = thread->security_get_caller_class(depth); + Klass* k = thread->security_get_caller_class(depth); return (k == NULL) ? NULL : (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror()); JVM_END @@ -734,7 +731,7 @@ } TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL); - klassOop k = SystemDictionary::resolve_or_null(h_name, CHECK_NULL); + Klass* k = SystemDictionary::resolve_or_null(h_name, CHECK_NULL); if (k == NULL) { return NULL; } @@ -766,7 +763,7 @@ Handle(), throwError, THREAD); if (TraceClassResolution && result != NULL) { - trace_class_resolution(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(result))); + trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result))); } return result; JVM_END @@ -782,9 +779,9 @@ } TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL); oop from_class_oop = JNIHandles::resolve(from); - klassOop from_class = (from_class_oop == NULL) - ? (klassOop)NULL - : java_lang_Class::as_klassOop(from_class_oop); + Klass* from_class = (from_class_oop == NULL) + ? (Klass*)NULL + : java_lang_Class::as_Klass(from_class_oop); oop class_loader = NULL; oop protection_domain = NULL; if (from_class != NULL) { @@ -800,11 +797,11 @@ // this function is generally only used for class loading during verification. ResourceMark rm; oop from_mirror = JNIHandles::resolve_non_null(from); - klassOop from_class = java_lang_Class::as_klassOop(from_mirror); + Klass* from_class = java_lang_Class::as_Klass(from_mirror); const char * from_name = Klass::cast(from_class)->external_name(); oop mirror = JNIHandles::resolve_non_null(result); - klassOop to_class = java_lang_Class::as_klassOop(mirror); + Klass* to_class = java_lang_Class::as_Klass(mirror); const char * to = Klass::cast(to_class)->external_name(); tty->print("RESOLVE %s %s (verification)\n", from_name, to); } @@ -869,7 +866,7 @@ THREAD); } Handle protection_domain (THREAD, JNIHandles::resolve(pd)); - klassOop k = SystemDictionary::resolve_from_stream(class_name, class_loader, + Klass* k = SystemDictionary::resolve_from_stream(class_name, class_loader, protection_domain, &st, verify != 0, CHECK_NULL); @@ -933,7 +930,7 @@ THREAD); } - klassOop k = SystemDictionary::find_instance_or_array_klass(klass_name, + Klass* k = SystemDictionary::find_instance_or_array_klass(klass_name, h_loader, Handle(), CHECK_NULL); @@ -955,7 +952,7 @@ name = type2name(java_lang_Class::primitive_type(JNIHandles::resolve(cls))); } else { // Consider caching interned string in Klass - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); assert(k->is_klass(), "just checking"); name = Klass::cast(k)->external_name(); } @@ -976,11 +973,11 @@ return (jobjectArray) JNIHandles::make_local(env, r); } - KlassHandle klass(thread, java_lang_Class::as_klassOop(mirror)); + KlassHandle klass(thread, java_lang_Class::as_Klass(mirror)); // Figure size of result array int size; if (klass->oop_is_instance()) { - size = instanceKlass::cast(klass())->local_interfaces()->length(); + size = InstanceKlass::cast(klass())->local_interfaces()->length(); } else { assert(klass->oop_is_objArray() || klass->oop_is_typeArray(), "Illegal mirror klass"); size = 2; @@ -993,7 +990,7 @@ if (klass->oop_is_instance()) { // Regular instance klass, fill in all local interfaces for (int index = 0; index < size; index++) { - klassOop k = klassOop(instanceKlass::cast(klass())->local_interfaces()->obj_at(index)); + Klass* k = InstanceKlass::cast(klass())->local_interfaces()->at(index); result->obj_at_put(index, Klass::cast(k)->java_mirror()); } } else { @@ -1010,7 +1007,7 @@ if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { return NULL; } - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); oop loader = Klass::cast(k)->class_loader(); return JNIHandles::make_local(env, loader); JVM_END @@ -1022,7 +1019,7 @@ if (java_lang_Class::is_primitive(mirror)) { return JNI_FALSE; } - klassOop k = java_lang_Class::as_klassOop(mirror); + Klass* k = java_lang_Class::as_Klass(mirror); jboolean result = Klass::cast(k)->is_interface(); assert(!result || Klass::cast(k)->oop_is_instance(), "all interfaces are instance types"); @@ -1040,10 +1037,10 @@ return NULL; } - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); objArrayOop signers = NULL; if (Klass::cast(k)->oop_is_instance()) { - signers = instanceKlass::cast(k)->signers(); + signers = InstanceKlass::cast(k)->signers(); } // If there are no signers set in the class, or if the class @@ -1051,7 +1048,7 @@ if (signers == NULL) return NULL; // copy of the signers array - klassOop element = objArrayKlass::cast(signers->klass())->element_klass(); + Klass* element = objArrayKlass::cast(signers->klass())->element_klass(); objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL); for (int index = 0; index < signers->length(); index++) { signers_copy->obj_at_put(index, signers->obj_at(index)); @@ -1068,9 +1065,9 @@ // This call is ignored for primitive types and arrays. // Signers are only set once, ClassLoader.java, and thus shouldn't // be called with an array. Only the bootstrap loader creates arrays. - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); if (Klass::cast(k)->oop_is_instance()) { - instanceKlass::cast(k)->set_signers(objArrayOop(JNIHandles::resolve(signers))); + InstanceKlass::cast(k)->set_signers(objArrayOop(JNIHandles::resolve(signers))); } } JVM_END @@ -1087,7 +1084,7 @@ return NULL; } - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); return (jobject) JNIHandles::make_local(env, Klass::cast(k)->protection_domain()); JVM_END @@ -1101,13 +1098,13 @@ } if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { // Call is ignored for primitive types - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); // cls won't be an array, as this called only from ClassLoader.defineClass if (Klass::cast(k)->oop_is_instance()) { oop pd = JNIHandles::resolve(protection_domain); assert(pd == NULL || pd->is_oop(), "just checking"); - instanceKlass::cast(k)->set_protection_domain(pd); + InstanceKlass::cast(k)->set_protection_domain(pd); } } JVM_END @@ -1127,11 +1124,11 @@ Handle object (THREAD, JNIHandles::resolve(action)); // get run() method - methodOop m_oop = Klass::cast(object->klass())->uncached_lookup_method( + Method* m_oop = Klass::cast(object->klass())->uncached_lookup_method( vmSymbols::run_method_name(), vmSymbols::void_object_signature()); methodHandle m (THREAD, m_oop); - if (m.is_null() || !m->is_method() || !methodOop(m())->is_public() || methodOop(m())->is_static()) { + if (m.is_null() || !m->is_method() || !m()->is_public() || m()->is_static()) { THROW_MSG_0(vmSymbols::java_lang_InternalError(), "No run method"); } @@ -1221,7 +1218,7 @@ for(; !vfst.at_end(); vfst.next()) { // get method of frame - methodOop method = vfst.method(); + Method* method = vfst.method(); intptr_t* frame_id = vfst.frame_id(); // check the privileged frames to see if we have a match @@ -1231,7 +1228,7 @@ privileged_context = Handle(thread, thread->privileged_stack_top()->privileged_context()); protection_domain = thread->privileged_stack_top()->protection_domain(); } else { - protection_domain = instanceKlass::cast(method->method_holder())->protection_domain(); + protection_domain = InstanceKlass::cast(method->method_holder())->protection_domain(); } if ((previous_protection_domain != protection_domain) && (protection_domain != NULL)) { @@ -1269,8 +1266,8 @@ JVM_QUICK_ENTRY(jboolean, JVM_IsArrayClass(JNIEnv *env, jclass cls)) JVMWrapper("JVM_IsArrayClass"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); - return (k != NULL) && Klass::cast(k)->oop_is_javaArray() ? true : false; + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); + return (k != NULL) && Klass::cast(k)->oop_is_array() ? true : false; JVM_END @@ -1296,7 +1293,7 @@ return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC; } - Klass* k = Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls))); + Klass* k = Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls))); debug_only(int computed_modifiers = k->compute_modifier_flags(CHECK_0)); assert(k->modifier_flags() == computed_modifiers, "modifiers cache is OK"); return k->modifier_flags(); @@ -1308,15 +1305,15 @@ JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass)) JvmtiVMObjectAllocEventCollector oam; // ofClass is a reference to a java_lang_Class object. The mirror object - // of an instanceKlass + // of an InstanceKlass if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) || - ! Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_instance()) { + ! Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)))->oop_is_instance()) { oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL); return (jobjectArray)JNIHandles::make_local(env, result); } - instanceKlassHandle k(thread, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass))); + instanceKlassHandle k(thread, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))); InnerClassesIterator iter(k); if (iter.length() == 0) { @@ -1342,9 +1339,9 @@ // Check to see if the name matches the class we're looking for // before attempting to find the class. if (cp->klass_name_at_matches(k, ooff)) { - klassOop outer_klass = cp->klass_at(ooff, CHECK_NULL); + Klass* outer_klass = cp->klass_at(ooff, CHECK_NULL); if (outer_klass == k()) { - klassOop ik = cp->klass_at(ioff, CHECK_NULL); + Klass* ik = cp->klass_at(ioff, CHECK_NULL); instanceKlassHandle inner_klass (THREAD, ik); // Throws an exception if outer klass has not declared k as @@ -1375,13 +1372,13 @@ { // ofClass is a reference to a java_lang_Class object. if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) || - ! Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_instance()) { + ! Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)))->oop_is_instance()) { return NULL; } bool inner_is_member = false; - klassOop outer_klass - = instanceKlass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)) + Klass* outer_klass + = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)) )->compute_enclosing_class(&inner_is_member, CHECK_NULL); if (outer_klass == NULL) return NULL; // already a top-level class if (!inner_is_member) return NULL; // an anonymous class (inside a method) @@ -1389,8 +1386,8 @@ } JVM_END -// should be in instanceKlass.cpp, but is here for historical reasons -klassOop instanceKlass::compute_enclosing_class_impl(instanceKlassHandle k, +// should be in InstanceKlass.cpp, but is here for historical reasons +Klass* InstanceKlass::compute_enclosing_class_impl(instanceKlassHandle k, bool* inner_is_member, TRAPS) { Thread* thread = THREAD; @@ -1403,7 +1400,7 @@ constantPoolHandle i_cp(thread, k->constants()); bool found = false; - klassOop ok; + Klass* ok; instanceKlassHandle outer_klass; *inner_is_member = false; @@ -1416,7 +1413,7 @@ // Check to see if the name matches the class we're looking for // before attempting to find the class. if (i_cp->klass_name_at_matches(k, ioff)) { - klassOop inner_klass = i_cp->klass_at(ioff, CHECK_NULL); + Klass* inner_klass = i_cp->klass_at(ioff, CHECK_NULL); found = (k() == inner_klass); if (found && ooff != 0) { ok = i_cp->klass_at(ooff, CHECK_NULL); @@ -1454,9 +1451,9 @@ ResourceMark rm(THREAD); // Return null for arrays and primatives if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); if (Klass::cast(k)->oop_is_instance()) { - Symbol* sym = instanceKlass::cast(k)->generic_signature(); + Symbol* sym = InstanceKlass::cast(k)->generic_signature(); if (sym == NULL) return NULL; Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL); return (jstring) JNIHandles::make_local(env, str()); @@ -1472,10 +1469,10 @@ ResourceMark rm(THREAD); // Return null for arrays and primitives if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) { - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls)); if (Klass::cast(k)->oop_is_instance()) { - return (jbyteArray) JNIHandles::make_local(env, - instanceKlass::cast(k)->class_annotations()); + typeArrayOop a = Annotations::make_java_array(InstanceKlass::cast(k)->class_annotations(), CHECK_NULL); + return (jbyteArray) JNIHandles::make_local(env, a); } } return NULL; @@ -1491,36 +1488,34 @@ // field is a handle to a java.lang.reflect.Field object oop reflected = JNIHandles::resolve_non_null(field); oop mirror = java_lang_reflect_Field::clazz(reflected); - klassOop k = java_lang_Class::as_klassOop(mirror); + Klass* k = java_lang_Class::as_Klass(mirror); int slot = java_lang_reflect_Field::slot(reflected); int modifiers = java_lang_reflect_Field::modifiers(reflected); fieldDescriptor fd; KlassHandle kh(THREAD, k); - intptr_t offset = instanceKlass::cast(kh())->field_offset(slot); + intptr_t offset = InstanceKlass::cast(kh())->field_offset(slot); if (modifiers & JVM_ACC_STATIC) { // for static fields we only look in the current class - if (!instanceKlass::cast(kh())->find_local_field_from_offset(offset, - true, &fd)) { + if (!InstanceKlass::cast(kh())->find_local_field_from_offset(offset, true, &fd)) { assert(false, "cannot find static field"); return NULL; // robustness } } else { // for instance fields we start with the current class and work // our way up through the superclass chain - if (!instanceKlass::cast(kh())->find_field_from_offset(offset, false, - &fd)) { + if (!InstanceKlass::cast(kh())->find_field_from_offset(offset, false, &fd)) { assert(false, "cannot find instance field"); return NULL; // robustness } } - return (jbyteArray) JNIHandles::make_local(env, fd.annotations()); + return (jbyteArray) JNIHandles::make_local(env, Annotations::make_java_array(fd.annotations(), THREAD)); JVM_END -static methodOop jvm_get_method_common(jobject method, TRAPS) { +static Method* jvm_get_method_common(jobject method, TRAPS) { // some of this code was adapted from from jni_FromReflectedMethod oop reflected = JNIHandles::resolve_non_null(method); @@ -1536,10 +1531,10 @@ mirror = java_lang_reflect_Method::clazz(reflected); slot = java_lang_reflect_Method::slot(reflected); } - klassOop k = java_lang_Class::as_klassOop(mirror); + Klass* k = java_lang_Class::as_Klass(mirror); KlassHandle kh(THREAD, k); - methodOop m = instanceKlass::cast(kh())->method_with_idnum(slot); + Method* m = InstanceKlass::cast(kh())->method_with_idnum(slot); if (m == NULL) { assert(false, "cannot find method"); return NULL; // robustness @@ -1553,8 +1548,9 @@ JVMWrapper("JVM_GetMethodAnnotations"); // method is a handle to a java.lang.reflect.Method object - methodOop m = jvm_get_method_common(method, CHECK_NULL); - return (jbyteArray) JNIHandles::make_local(env, m->annotations()); + Method* m = jvm_get_method_common(method, CHECK_NULL); + return (jbyteArray) JNIHandles::make_local(env, + Annotations::make_java_array(m->annotations(), THREAD)); JVM_END @@ -1562,8 +1558,9 @@ JVMWrapper("JVM_GetMethodDefaultAnnotationValue"); // method is a handle to a java.lang.reflect.Method object - methodOop m = jvm_get_method_common(method, CHECK_NULL); - return (jbyteArray) JNIHandles::make_local(env, m->annotation_default()); + Method* m = jvm_get_method_common(method, CHECK_NULL); + return (jbyteArray) JNIHandles::make_local(env, + Annotations::make_java_array(m->annotation_default(), THREAD)); JVM_END @@ -1571,8 +1568,9 @@ JVMWrapper("JVM_GetMethodParameterAnnotations"); // method is a handle to a java.lang.reflect.Method object - methodOop m = jvm_get_method_common(method, CHECK_NULL); - return (jbyteArray) JNIHandles::make_local(env, m->parameter_annotations()); + Method* m = jvm_get_method_common(method, CHECK_NULL); + return (jbyteArray) JNIHandles::make_local(env, + Annotations::make_java_array(m->parameter_annotations(), THREAD)); JVM_END @@ -1585,13 +1583,13 @@ // Exclude primitive types and array types if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) || - Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_javaArray()) { + Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)))->oop_is_array()) { // Return empty array oop res = oopFactory::new_objArray(SystemDictionary::reflect_Field_klass(), 0, CHECK_NULL); return (jobjectArray) JNIHandles::make_local(env, res); } - instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass))); + instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))); constantPoolHandle cp(THREAD, k->constants()); // Ensure class is linked @@ -1648,24 +1646,24 @@ // Exclude primitive types and array types if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) - || Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_javaArray()) { + || Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)))->oop_is_array()) { // Return empty array oop res = oopFactory::new_objArray(SystemDictionary::reflect_Method_klass(), 0, CHECK_NULL); return (jobjectArray) JNIHandles::make_local(env, res); } - instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass))); + instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))); // Ensure class is linked k->link_class(CHECK_NULL); - objArrayHandle methods (THREAD, k->methods()); + Array* methods = k->methods(); int methods_length = methods->length(); int num_methods = 0; int i; for (i = 0; i < methods_length; i++) { - methodHandle method(THREAD, (methodOop) methods->obj_at(i)); + methodHandle method(THREAD, methods->at(i)); if (!method->is_initializer()) { if (!publicOnly || method->is_public()) { ++num_methods; @@ -1679,7 +1677,7 @@ int out_idx = 0; for (i = 0; i < methods_length; i++) { - methodHandle method(THREAD, (methodOop) methods->obj_at(i)); + methodHandle method(THREAD, methods->at(i)); if (!method->is_initializer()) { if (!publicOnly || method->is_public()) { oop m = Reflection::new_method(method, UseNewReflection, false, CHECK_NULL); @@ -1700,24 +1698,24 @@ // Exclude primitive types and array types if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) - || Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_javaArray()) { + || Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)))->oop_is_array()) { // Return empty array oop res = oopFactory::new_objArray(SystemDictionary::reflect_Constructor_klass(), 0 , CHECK_NULL); return (jobjectArray) JNIHandles::make_local(env, res); } - instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass))); + instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))); // Ensure class is linked k->link_class(CHECK_NULL); - objArrayHandle methods (THREAD, k->methods()); + Array* methods = k->methods(); int methods_length = methods->length(); int num_constructors = 0; int i; for (i = 0; i < methods_length; i++) { - methodHandle method(THREAD, (methodOop) methods->obj_at(i)); + methodHandle method(THREAD, methods->at(i)); if (method->is_initializer() && !method->is_static()) { if (!publicOnly || method->is_public()) { ++num_constructors; @@ -1731,7 +1729,7 @@ int out_idx = 0; for (i = 0; i < methods_length; i++) { - methodHandle method(THREAD, (methodOop) methods->obj_at(i)); + methodHandle method(THREAD, methods->at(i)); if (method->is_initializer() && !method->is_static()) { if (!publicOnly || method->is_public()) { oop m = Reflection::new_constructor(method, CHECK_NULL); @@ -1753,7 +1751,7 @@ return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC; } - Klass* k = Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls))); + Klass* k = Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls))); return k->access_flags().as_int() & JVM_ACC_WRITTEN_FLAGS; } JVM_END @@ -1768,11 +1766,11 @@ // Return null for primitives and arrays if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) { - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); if (Klass::cast(k)->oop_is_instance()) { instanceKlassHandle k_h(THREAD, k); Handle jcp = sun_reflect_ConstantPool::create(CHECK_NULL); - sun_reflect_ConstantPool::set_cp_oop(jcp(), k_h->constants()); + sun_reflect_ConstantPool::set_cp(jcp(), k_h->constants()); return JNIHandles::make_local(jcp()); } } @@ -1781,10 +1779,10 @@ JVM_END -JVM_ENTRY(jint, JVM_ConstantPoolGetSize(JNIEnv *env, jobject unused, jobject jcpool)) +JVM_ENTRY(jint, JVM_ConstantPoolGetSize(JNIEnv *env, jobject obj, jobject unused)) { JVMWrapper("JVM_ConstantPoolGetSize"); - constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); + constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); return cp->length(); } JVM_END @@ -1797,31 +1795,31 @@ } -JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) +JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject obj, jobject unused, jint index)) { JVMWrapper("JVM_ConstantPoolGetClassAt"); - constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); + constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); bounds_check(cp, index, CHECK_NULL); constantTag tag = cp->tag_at(index); if (!tag.is_klass() && !tag.is_unresolved_klass()) { THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); } - klassOop k = cp->klass_at(index, CHECK_NULL); + Klass* k = cp->klass_at(index, CHECK_NULL); return (jclass) JNIHandles::make_local(k->java_mirror()); } JVM_END -JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)) +JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index)) { JVMWrapper("JVM_ConstantPoolGetClassAtIfLoaded"); - constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); + constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); bounds_check(cp, index, CHECK_NULL); constantTag tag = cp->tag_at(index); if (!tag.is_klass() && !tag.is_unresolved_klass()) { THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); } - klassOop k = constantPoolOopDesc::klass_at_if_loaded(cp, index); + Klass* k = ConstantPool::klass_at_if_loaded(cp, index); if (k == NULL) return NULL; return (jclass) JNIHandles::make_local(k->java_mirror()); } @@ -1833,11 +1831,11 @@ THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); } int klass_ref = cp->uncached_klass_ref_index_at(index); - klassOop k_o; + Klass* k_o; if (force_resolution) { k_o = cp->klass_at(klass_ref, CHECK_NULL); } else { - k_o = constantPoolOopDesc::klass_at_if_loaded(cp, klass_ref); + k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref); if (k_o == NULL) return NULL; } instanceKlassHandle k(THREAD, k_o); @@ -1856,22 +1854,22 @@ return JNIHandles::make_local(method); } -JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) +JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jobject unused, jint index)) { JVMWrapper("JVM_ConstantPoolGetMethodAt"); JvmtiVMObjectAllocEventCollector oam; - constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); + constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); bounds_check(cp, index, CHECK_NULL); jobject res = get_method_at_helper(cp, index, true, CHECK_NULL); return res; } JVM_END -JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)) +JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index)) { JVMWrapper("JVM_ConstantPoolGetMethodAtIfLoaded"); JvmtiVMObjectAllocEventCollector oam; - constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); + constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); bounds_check(cp, index, CHECK_NULL); jobject res = get_method_at_helper(cp, index, false, CHECK_NULL); return res; @@ -1884,18 +1882,18 @@ THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); } int klass_ref = cp->uncached_klass_ref_index_at(index); - klassOop k_o; + Klass* k_o; if (force_resolution) { k_o = cp->klass_at(klass_ref, CHECK_NULL); } else { - k_o = constantPoolOopDesc::klass_at_if_loaded(cp, klass_ref); + k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref); if (k_o == NULL) return NULL; } instanceKlassHandle k(THREAD, k_o); Symbol* name = cp->uncached_name_ref_at(index); Symbol* sig = cp->uncached_signature_ref_at(index); fieldDescriptor fd; - klassOop target_klass = k->find_field(name, sig, &fd); + Klass* target_klass = k->find_field(name, sig, &fd); if (target_klass == NULL) { THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up field in target class"); } @@ -1903,33 +1901,33 @@ return JNIHandles::make_local(field); } -JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) +JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject obj, jobject unusedl, jint index)) { JVMWrapper("JVM_ConstantPoolGetFieldAt"); JvmtiVMObjectAllocEventCollector oam; - constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); + constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); bounds_check(cp, index, CHECK_NULL); jobject res = get_field_at_helper(cp, index, true, CHECK_NULL); return res; } JVM_END -JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index)) +JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index)) { JVMWrapper("JVM_ConstantPoolGetFieldAtIfLoaded"); JvmtiVMObjectAllocEventCollector oam; - constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); + constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); bounds_check(cp, index, CHECK_NULL); jobject res = get_field_at_helper(cp, index, false, CHECK_NULL); return res; } JVM_END -JVM_ENTRY(jobjectArray, JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) +JVM_ENTRY(jobjectArray, JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject obj, jobject unused, jint index)) { JVMWrapper("JVM_ConstantPoolGetMemberRefInfoAt"); JvmtiVMObjectAllocEventCollector oam; - constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); + constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); bounds_check(cp, index, CHECK_NULL); constantTag tag = cp->tag_at(index); if (!tag.is_field_or_method()) { @@ -1951,10 +1949,10 @@ } JVM_END -JVM_ENTRY(jint, JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) +JVM_ENTRY(jint, JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject obj, jobject unused, jint index)) { JVMWrapper("JVM_ConstantPoolGetIntAt"); - constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); + constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); bounds_check(cp, index, CHECK_0); constantTag tag = cp->tag_at(index); if (!tag.is_int()) { @@ -1964,10 +1962,10 @@ } JVM_END -JVM_ENTRY(jlong, JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) +JVM_ENTRY(jlong, JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject obj, jobject unused, jint index)) { JVMWrapper("JVM_ConstantPoolGetLongAt"); - constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); + constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); bounds_check(cp, index, CHECK_(0L)); constantTag tag = cp->tag_at(index); if (!tag.is_long()) { @@ -1977,10 +1975,10 @@ } JVM_END -JVM_ENTRY(jfloat, JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) +JVM_ENTRY(jfloat, JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject obj, jobject unused, jint index)) { JVMWrapper("JVM_ConstantPoolGetFloatAt"); - constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); + constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); bounds_check(cp, index, CHECK_(0.0f)); constantTag tag = cp->tag_at(index); if (!tag.is_float()) { @@ -1990,10 +1988,10 @@ } JVM_END -JVM_ENTRY(jdouble, JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) +JVM_ENTRY(jdouble, JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject obj, jobject unused, jint index)) { JVMWrapper("JVM_ConstantPoolGetDoubleAt"); - constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); + constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); bounds_check(cp, index, CHECK_(0.0)); constantTag tag = cp->tag_at(index); if (!tag.is_double()) { @@ -2003,13 +2001,13 @@ } JVM_END -JVM_ENTRY(jstring, JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject unused, jobject jcpool, jint index)) +JVM_ENTRY(jstring, JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject obj, jobject unused, jint index)) { JVMWrapper("JVM_ConstantPoolGetStringAt"); - constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); + constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); bounds_check(cp, index, CHECK_NULL); constantTag tag = cp->tag_at(index); - if (!tag.is_string() && !tag.is_unresolved_string()) { + if (!tag.is_string()) { THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index"); } oop str = cp->string_at(index, CHECK_NULL); @@ -2017,11 +2015,11 @@ } JVM_END -JVM_ENTRY(jstring, JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject unused, jobject jcpool, jint index)) +JVM_ENTRY(jstring, JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject obj, jobject unused, jint index)) { JVMWrapper("JVM_ConstantPoolGetUTF8At"); JvmtiVMObjectAllocEventCollector oam; - constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool))); + constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj))); bounds_check(cp, index, CHECK_NULL); constantTag tag = cp->tag_at(index); if (!tag.is_symbol()) { @@ -2044,7 +2042,7 @@ assert(! java_lang_Class::is_primitive(r), "primitive classes not allowed"); if (java_lang_Class::is_primitive(r)) return false; - klassOop k = java_lang_Class::as_klassOop(r); + Klass* k = java_lang_Class::as_Klass(r); assert(Klass::cast(k)->oop_is_instance(), "must be an instance klass"); if (! Klass::cast(k)->oop_is_instance()) return false; @@ -2071,15 +2069,15 @@ // RedefineClasses support: bug 6214132 caused verification to fail. // All functions from this section should call the jvmtiThreadSate function: -// klassOop class_to_verify_considering_redefinition(klassOop klass). -// The function returns a klassOop of the _scratch_class if the verifier +// Klass* class_to_verify_considering_redefinition(Klass* klass). +// The function returns a Klass* of the _scratch_class if the verifier // was invoked in the middle of the class redefinition. -// Otherwise it returns its argument value which is the _the_class klassOop. +// Otherwise it returns its argument value which is the _the_class Klass*. // Please, refer to the description in the jvmtiThreadSate.hpp. JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls)) JVMWrapper("JVM_GetClassNameUTF"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); return Klass::cast(k)->name()->as_utf8(); JVM_END @@ -2087,16 +2085,15 @@ JVM_QUICK_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types)) JVMWrapper("JVM_GetClassCPTypes"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - // types will have length zero if this is not an instanceKlass + // types will have length zero if this is not an InstanceKlass // (length is determined by call to JVM_GetClassCPEntriesCount) if (Klass::cast(k)->oop_is_instance()) { - constantPoolOop cp = instanceKlass::cast(k)->constants(); + ConstantPool* cp = InstanceKlass::cast(k)->constants(); for (int index = cp->length() - 1; index >= 0; index--) { constantTag tag = cp->tag_at(index); - types[index] = (tag.is_unresolved_klass()) ? JVM_CONSTANT_Class : - (tag.is_unresolved_string()) ? JVM_CONSTANT_String : tag.value(); + types[index] = (tag.is_unresolved_klass()) ? JVM_CONSTANT_Class : tag.value(); } } JVM_END @@ -2104,47 +2101,47 @@ JVM_QUICK_ENTRY(jint, JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls)) JVMWrapper("JVM_GetClassCPEntriesCount"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); if (!Klass::cast(k)->oop_is_instance()) return 0; - return instanceKlass::cast(k)->constants()->length(); + return InstanceKlass::cast(k)->constants()->length(); JVM_END JVM_QUICK_ENTRY(jint, JVM_GetClassFieldsCount(JNIEnv *env, jclass cls)) JVMWrapper("JVM_GetClassFieldsCount"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); if (!Klass::cast(k)->oop_is_instance()) return 0; - return instanceKlass::cast(k)->java_fields_count(); + return InstanceKlass::cast(k)->java_fields_count(); JVM_END JVM_QUICK_ENTRY(jint, JVM_GetClassMethodsCount(JNIEnv *env, jclass cls)) JVMWrapper("JVM_GetClassMethodsCount"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); if (!Klass::cast(k)->oop_is_instance()) return 0; - return instanceKlass::cast(k)->methods()->length(); + return InstanceKlass::cast(k)->methods()->length(); JVM_END // The following methods, used for the verifier, are never called with -// array klasses, so a direct cast to instanceKlass is safe. +// array klasses, so a direct cast to InstanceKlass is safe. // Typically, these methods are called in a loop with bounds determined // by the results of JVM_GetClass{Fields,Methods}Count, which return // zero for arrays. JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions)) JVMWrapper("JVM_GetMethodIxExceptionIndexes"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); - int length = methodOop(method)->checked_exceptions_length(); + Method* method = InstanceKlass::cast(k)->methods()->at(method_index); + int length = method->checked_exceptions_length(); if (length > 0) { - CheckedExceptionElement* table= methodOop(method)->checked_exceptions_start(); + CheckedExceptionElement* table= method->checked_exceptions_start(); for (int i = 0; i < length; i++) { exceptions[i] = table[i].class_cp_index; } @@ -2154,37 +2151,37 @@ JVM_QUICK_ENTRY(jint, JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index)) JVMWrapper("JVM_GetMethodIxExceptionsCount"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); - return methodOop(method)->checked_exceptions_length(); + Method* method = InstanceKlass::cast(k)->methods()->at(method_index); + return method->checked_exceptions_length(); JVM_END JVM_QUICK_ENTRY(void, JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code)) JVMWrapper("JVM_GetMethodIxByteCode"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); - memcpy(code, methodOop(method)->code_base(), methodOop(method)->code_size()); + Method* method = InstanceKlass::cast(k)->methods()->at(method_index); + memcpy(code, method->code_base(), method->code_size()); JVM_END JVM_QUICK_ENTRY(jint, JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index)) JVMWrapper("JVM_GetMethodIxByteCodeLength"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); - return methodOop(method)->code_size(); + Method* method = InstanceKlass::cast(k)->methods()->at(method_index); + return method->code_size(); JVM_END JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry)) JVMWrapper("JVM_GetMethodIxExceptionTableEntry"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); - ExceptionTable extable((methodOop(method))); + Method* method = InstanceKlass::cast(k)->methods()->at(method_index); + ExceptionTable extable(method); entry->start_pc = extable.start_pc(entry_index); entry->end_pc = extable.end_pc(entry_index); entry->handler_pc = extable.handler_pc(entry_index); @@ -2194,82 +2191,82 @@ JVM_QUICK_ENTRY(jint, JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index)) JVMWrapper("JVM_GetMethodIxExceptionTableLength"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); - return methodOop(method)->exception_table_length(); + Method* method = InstanceKlass::cast(k)->methods()->at(method_index); + return method->exception_table_length(); JVM_END JVM_QUICK_ENTRY(jint, JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index)) JVMWrapper("JVM_GetMethodIxModifiers"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); - return methodOop(method)->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS; + Method* method = InstanceKlass::cast(k)->methods()->at(method_index); + return method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS; JVM_END JVM_QUICK_ENTRY(jint, JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index)) JVMWrapper("JVM_GetFieldIxModifiers"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - return instanceKlass::cast(k)->field_access_flags(field_index) & JVM_RECOGNIZED_FIELD_MODIFIERS; + return InstanceKlass::cast(k)->field_access_flags(field_index) & JVM_RECOGNIZED_FIELD_MODIFIERS; JVM_END JVM_QUICK_ENTRY(jint, JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index)) JVMWrapper("JVM_GetMethodIxLocalsCount"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); - return methodOop(method)->max_locals(); + Method* method = InstanceKlass::cast(k)->methods()->at(method_index); + return method->max_locals(); JVM_END JVM_QUICK_ENTRY(jint, JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index)) JVMWrapper("JVM_GetMethodIxArgsSize"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); - return methodOop(method)->size_of_parameters(); + Method* method = InstanceKlass::cast(k)->methods()->at(method_index); + return method->size_of_parameters(); JVM_END JVM_QUICK_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index)) JVMWrapper("JVM_GetMethodIxMaxStack"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); - return methodOop(method)->verifier_max_stack(); + Method* method = InstanceKlass::cast(k)->methods()->at(method_index); + return method->verifier_max_stack(); JVM_END JVM_QUICK_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index)) JVMWrapper("JVM_IsConstructorIx"); ResourceMark rm(THREAD); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); - return methodOop(method)->name() == vmSymbols::object_initializer_name(); + Method* method = InstanceKlass::cast(k)->methods()->at(method_index); + return method->name() == vmSymbols::object_initializer_name(); JVM_END JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index)) JVMWrapper("JVM_GetMethodIxIxUTF"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); - return methodOop(method)->name()->as_utf8(); + Method* method = InstanceKlass::cast(k)->methods()->at(method_index); + return method->name()->as_utf8(); JVM_END JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index)) JVMWrapper("JVM_GetMethodIxSignatureUTF"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - oop method = instanceKlass::cast(k)->methods()->obj_at(method_index); - return methodOop(method)->signature()->as_utf8(); + Method* method = InstanceKlass::cast(k)->methods()->at(method_index); + return method->signature()->as_utf8(); JVM_END /** @@ -2282,9 +2279,9 @@ */ JVM_ENTRY(const char*, JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index)) JVMWrapper("JVM_GetCPFieldNameUTF"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - constantPoolOop cp = instanceKlass::cast(k)->constants(); + ConstantPool* cp = InstanceKlass::cast(k)->constants(); switch (cp->tag_at(cp_index).value()) { case JVM_CONSTANT_Fieldref: return cp->uncached_name_ref_at(cp_index)->as_utf8(); @@ -2298,9 +2295,9 @@ JVM_ENTRY(const char*, JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index)) JVMWrapper("JVM_GetCPMethodNameUTF"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - constantPoolOop cp = instanceKlass::cast(k)->constants(); + ConstantPool* cp = InstanceKlass::cast(k)->constants(); switch (cp->tag_at(cp_index).value()) { case JVM_CONSTANT_InterfaceMethodref: case JVM_CONSTANT_Methodref: @@ -2316,9 +2313,9 @@ JVM_ENTRY(const char*, JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)) JVMWrapper("JVM_GetCPMethodSignatureUTF"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - constantPoolOop cp = instanceKlass::cast(k)->constants(); + ConstantPool* cp = InstanceKlass::cast(k)->constants(); switch (cp->tag_at(cp_index).value()) { case JVM_CONSTANT_InterfaceMethodref: case JVM_CONSTANT_Methodref: @@ -2334,9 +2331,9 @@ JVM_ENTRY(const char*, JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index)) JVMWrapper("JVM_GetCPFieldSignatureUTF"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - constantPoolOop cp = instanceKlass::cast(k)->constants(); + ConstantPool* cp = InstanceKlass::cast(k)->constants(); switch (cp->tag_at(cp_index).value()) { case JVM_CONSTANT_Fieldref: return cp->uncached_signature_ref_at(cp_index)->as_utf8(); @@ -2350,9 +2347,9 @@ JVM_ENTRY(const char*, JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)) JVMWrapper("JVM_GetCPClassNameUTF"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - constantPoolOop cp = instanceKlass::cast(k)->constants(); + ConstantPool* cp = InstanceKlass::cast(k)->constants(); Symbol* classname = cp->klass_name_at(cp_index); return classname->as_utf8(); JVM_END @@ -2360,9 +2357,9 @@ JVM_ENTRY(const char*, JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)) JVMWrapper("JVM_GetCPFieldClassNameUTF"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - constantPoolOop cp = instanceKlass::cast(k)->constants(); + ConstantPool* cp = InstanceKlass::cast(k)->constants(); switch (cp->tag_at(cp_index).value()) { case JVM_CONSTANT_Fieldref: { int class_index = cp->uncached_klass_ref_index_at(cp_index); @@ -2379,9 +2376,9 @@ JVM_ENTRY(const char*, JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index)) JVMWrapper("JVM_GetCPMethodClassNameUTF"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); - constantPoolOop cp = instanceKlass::cast(k)->constants(); + ConstantPool* cp = InstanceKlass::cast(k)->constants(); switch (cp->tag_at(cp_index).value()) { case JVM_CONSTANT_Methodref: case JVM_CONSTANT_InterfaceMethodref: { @@ -2399,12 +2396,12 @@ JVM_ENTRY(jint, JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)) JVMWrapper("JVM_GetCPFieldModifiers"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); - klassOop k_called = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(called_cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); + Klass* k_called = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(called_cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread); - constantPoolOop cp = instanceKlass::cast(k)->constants(); - constantPoolOop cp_called = instanceKlass::cast(k_called)->constants(); + ConstantPool* cp = InstanceKlass::cast(k)->constants(); + ConstantPool* cp_called = InstanceKlass::cast(k_called)->constants(); switch (cp->tag_at(cp_index).value()) { case JVM_CONSTANT_Fieldref: { Symbol* name = cp->uncached_name_ref_at(cp_index); @@ -2426,20 +2423,20 @@ JVM_QUICK_ENTRY(jint, JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls)) JVMWrapper("JVM_GetCPMethodModifiers"); - klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)); - klassOop k_called = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(called_cls)); + Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)); + Klass* k_called = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(called_cls)); k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread); k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread); - constantPoolOop cp = instanceKlass::cast(k)->constants(); + ConstantPool* cp = InstanceKlass::cast(k)->constants(); switch (cp->tag_at(cp_index).value()) { case JVM_CONSTANT_Methodref: case JVM_CONSTANT_InterfaceMethodref: { Symbol* name = cp->uncached_name_ref_at(cp_index); Symbol* signature = cp->uncached_signature_ref_at(cp_index); - objArrayOop methods = instanceKlass::cast(k_called)->methods(); + Array* methods = InstanceKlass::cast(k_called)->methods(); int methods_count = methods->length(); for (int i = 0; i < methods_count; i++) { - methodOop method = methodOop(methods->obj_at(i)); + Method* method = methods->at(i); if (method->name() == name && method->signature() == signature) { return method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS; } @@ -2465,8 +2462,8 @@ JVMWrapper("JVM_IsSameClassPackage"); oop class1_mirror = JNIHandles::resolve_non_null(class1); oop class2_mirror = JNIHandles::resolve_non_null(class2); - klassOop klass1 = java_lang_Class::as_klassOop(class1_mirror); - klassOop klass2 = java_lang_Class::as_klassOop(class2_mirror); + Klass* klass1 = java_lang_Class::as_Klass(class1_mirror); + Klass* klass2 = java_lang_Class::as_Klass(class2_mirror); return (jboolean) Reflection::is_same_class_package(klass1, klass2); JVM_END @@ -3049,10 +3046,10 @@ bool trusted = is_trusted_frame(thread, &vfst); if (trusted) return NULL; - methodOop m = vfst.method(); + Method* m = vfst.method(); if (!m->is_native()) { - klassOop holder = m->method_holder(); - oop loader = instanceKlass::cast(holder)->class_loader(); + Klass* holder = m->method_holder(); + oop loader = InstanceKlass::cast(holder)->class_loader(); if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) { return (jclass) JNIHandles::make_local(env, Klass::cast(holder)->java_mirror()); } @@ -3072,11 +3069,11 @@ bool trusted = is_trusted_frame(thread, &vfst); if (trusted) return NULL; - methodOop m = vfst.method(); + Method* m = vfst.method(); if (!m->is_native()) { - klassOop holder = m->method_holder(); + Klass* holder = m->method_holder(); assert(holder->is_klass(), "just checking"); - oop loader = instanceKlass::cast(holder)->class_loader(); + oop loader = InstanceKlass::cast(holder)->class_loader(); if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) { return JNIHandles::make_local(env, loader); } @@ -3108,7 +3105,7 @@ for(vframeStream vfst(thread); !vfst.at_end(); vfst.security_get_caller_frame(1)) { // Native frames are not returned if (!vfst.method()->is_native()) { - klassOop holder = vfst.method()->method_holder(); + Klass* holder = vfst.method()->method_holder(); assert(holder->is_klass(), "just checking"); depth++; KlassLink* l = new KlassLink(KlassHandle(thread, holder)); @@ -3151,9 +3148,9 @@ for(vframeStream vfst(thread); !vfst.at_end(); vfst.next()) { if (!vfst.method()->is_native()) { - klassOop holder = vfst.method()->method_holder(); + Klass* holder = vfst.method()->method_holder(); assert(holder->is_klass(), "just checking"); - if (instanceKlass::cast(holder)->name() == class_name_sym) { + if (InstanceKlass::cast(holder)->name() == class_name_sym) { return depth; } depth++; @@ -3172,11 +3169,11 @@ bool trusted = is_trusted_frame(thread, &vfst); if (trusted) return -1; - methodOop m = vfst.method(); + Method* m = vfst.method(); if (!m->is_native()) { - klassOop holder = m->method_holder(); + Klass* holder = m->method_holder(); assert(holder->is_klass(), "just checking"); - oop loader = instanceKlass::cast(holder)->class_loader(); + oop loader = InstanceKlass::cast(holder)->class_loader(); if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) { return depth; } @@ -3210,7 +3207,7 @@ // ObjectInputStream /////////////////////////////////////////////////////////////// -bool force_verify_field_access(klassOop current_class, klassOop field_class, AccessFlags access, bool classloader_only) { +bool force_verify_field_access(Klass* current_class, Klass* field_class, AccessFlags access, bool classloader_only) { if (current_class == NULL) { return true; } @@ -3225,7 +3222,7 @@ } } - return (!access.is_private() && instanceKlass::cast(current_class)->is_same_class_package(field_class)); + return (!access.is_private() && InstanceKlass::cast(current_class)->is_same_class_package(field_class)); } @@ -3244,14 +3241,14 @@ } // Arrays not allowed here, must use JVM_AllocateNewArray - if (Klass::cast(java_lang_Class::as_klassOop(curr_mirror))->oop_is_javaArray() || - Klass::cast(java_lang_Class::as_klassOop(init_mirror))->oop_is_javaArray()) { + if (Klass::cast(java_lang_Class::as_Klass(curr_mirror))->oop_is_array() || + Klass::cast(java_lang_Class::as_Klass(init_mirror))->oop_is_array()) { ResourceMark rm(THREAD); THROW_0(vmSymbols::java_lang_InvalidClassException()); } - instanceKlassHandle curr_klass (THREAD, java_lang_Class::as_klassOop(curr_mirror)); - instanceKlassHandle init_klass (THREAD, java_lang_Class::as_klassOop(init_mirror)); + instanceKlassHandle curr_klass (THREAD, java_lang_Class::as_Klass(curr_mirror)); + instanceKlassHandle init_klass (THREAD, java_lang_Class::as_Klass(init_mirror)); assert(curr_klass->is_subclass_of(init_klass()), "just checking"); @@ -3267,7 +3264,7 @@ if (m.is_null()) { ResourceMark rm(THREAD); THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), - methodOopDesc::name_and_sig_as_C_string(Klass::cast(init_klass()), + Method::name_and_sig_as_C_string(Klass::cast(init_klass()), vmSymbols::object_initializer_name(), vmSymbols::void_method_signature())); } @@ -3300,15 +3297,15 @@ if (java_lang_Class::is_primitive(mirror)) { THROW_0(vmSymbols::java_lang_InvalidClassException()); } - klassOop k = java_lang_Class::as_klassOop(mirror); + Klass* k = java_lang_Class::as_Klass(mirror); oop result; - if (k->klass_part()->oop_is_typeArray()) { + if (k->oop_is_typeArray()) { // typeArray result = typeArrayKlass::cast(k)->allocate(length, CHECK_NULL); - } else if (k->klass_part()->oop_is_objArray()) { + } else if (k->oop_is_objArray()) { // objArray - objArrayKlassHandle oak(THREAD, k); + objArrayKlass* oak = objArrayKlass::cast(k); oak->initialize(CHECK_NULL); // make sure class is initialized (matches Classic VM behavior) result = oak->allocate(length, CHECK_NULL); } else { @@ -3325,8 +3322,8 @@ for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) { // UseNewReflection vfst.skip_reflection_related_frames(); // Only needed for 1.4 reflection - klassOop holder = vfst.method()->method_holder(); - oop loader = instanceKlass::cast(holder)->class_loader(); + Klass* holder = vfst.method()->method_holder(); + oop loader = InstanceKlass::cast(holder)->class_loader(); if (loader != NULL) { return JNIHandles::make_local(env, loader); } @@ -3368,22 +3365,22 @@ !vfst.at_end() && loader == NULL; vfst.next()) { if (!vfst.method()->is_native()) { - klassOop holder = vfst.method()->method_holder(); - loader = instanceKlass::cast(holder)->class_loader(); - protection_domain = instanceKlass::cast(holder)->protection_domain(); + Klass* holder = vfst.method()->method_holder(); + loader = InstanceKlass::cast(holder)->class_loader(); + protection_domain = InstanceKlass::cast(holder)->protection_domain(); } } } else { - klassOop curr_klass_oop = java_lang_Class::as_klassOop(curr_klass()); - loader = instanceKlass::cast(curr_klass_oop)->class_loader(); - protection_domain = instanceKlass::cast(curr_klass_oop)->protection_domain(); + Klass* curr_klass_oop = java_lang_Class::as_Klass(curr_klass()); + loader = InstanceKlass::cast(curr_klass_oop)->class_loader(); + protection_domain = InstanceKlass::cast(curr_klass_oop)->protection_domain(); } Handle h_loader(THREAD, loader); Handle h_prot (THREAD, protection_domain); jclass result = find_class_from_class_loader(env, name, true, h_loader, h_prot, false, thread); if (TraceClassResolution && result != NULL) { - trace_class_resolution(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(result))); + trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result))); } return result; JVM_END @@ -3398,7 +3395,7 @@ THROW_0(vmSymbols::java_lang_NullPointerException()); } oop a = JNIHandles::resolve_non_null(arr); - if (!a->is_javaArray() || (type_array_only && !a->is_typeArray())) { + if (!a->is_array() || (type_array_only && !a->is_typeArray())) { THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Argument is not an array"); } return arrayOop(a); @@ -4019,7 +4016,7 @@ // Security Note: // The Java level wrapper will perform the necessary security check allowing // us to pass the NULL as the initiating class loader. - klassOop klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL); + Klass* klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL); KlassHandle klass_handle(THREAD, klass); // Check if we should initialize the class @@ -4196,7 +4193,7 @@ } // check if threads is not an array of objects of Thread class - klassOop k = objArrayKlass::cast(ah->klass())->element_klass(); + Klass* k = objArrayKlass::cast(ah->klass())->element_klass(); if (k != SystemDictionary::Thread_klass()) { THROW_(vmSymbols::java_lang_IllegalArgumentException(), 0); } @@ -4248,7 +4245,7 @@ if (java_lang_Class::is_primitive(mirror())) { return NULL; } - klassOop k = java_lang_Class::as_klassOop(mirror()); + Klass* k = java_lang_Class::as_Klass(mirror()); if (!Klass::cast(k)->oop_is_instance()) { return NULL; } @@ -4259,7 +4256,7 @@ } objArrayOop dest_o = oopFactory::new_objArray(SystemDictionary::Object_klass(), 3, CHECK_NULL); objArrayHandle dest(THREAD, dest_o); - klassOop enc_k = ik_h->constants()->klass_at(encl_method_class_idx, CHECK_NULL); + Klass* enc_k = ik_h->constants()->klass_at(encl_method_class_idx, CHECK_NULL); dest->obj_at_put(0, Klass::cast(enc_k)->java_mirror()); int encl_method_method_idx = ik_h->enclosing_method_method_index(); if (encl_method_method_idx != 0) {