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

equal deleted inserted replaced

-:caf5eb7dd4a7
+:882756847a04
 #include "memory/oopFactory.hpp"
 #include "memory/universe.inline.hpp"
 #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"
 #include "prims/jvmtiThreadState.hpp"
 #include "prims/nativeLookup.hpp"
 consider use of a Handle instead of an oop so there is immunity from object
 motion. But note that the "QUICK" entries below do not have a handlemark
 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);
+Klass* privileged_action_klass = SystemDictionary::resolve_or_fail(privileged_action, false, CHECK);
-methodOop last_caller = NULL;
+Method* last_caller = NULL;
 while (!vfst.at_end()) {
-methodOop m = vfst.method();
+Method* m = vfst.method();
-if (!vfst.method()->method_holder()->klass_part()->is_subclass_of(SystemDictionary::ClassLoader_klass())&&
+if (!vfst.method()->method_holder()->is_subclass_of(SystemDictionary::ClassLoader_klass())&&
-!vfst.method()->method_holder()->klass_part()->is_subclass_of(access_controller_klass) &&
+!vfst.method()->method_holder()->is_subclass_of(access_controller_klass) &&
-!vfst.method()->method_holder()->klass_part()->is_subclass_of(privileged_action_klass)) {
+!vfst.method()->method_holder()->is_subclass_of(privileged_action_klass)) {
 break;
 }
 last_caller = m;
 vfst.next();
 }
 // if this is called from Class.forName0 and that is called from Class.forName,
 // then print the caller of Class.forName.  If this is Class.loadClass, then print
 // 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())) {
 found_it = true;
 } else if (!vfst.at_end()) {
 line_number = vfst.method()->line_number_from_bci(vfst.bci());
 if (line_number == -1) {
 // 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();
 }
 }
 }
 }
 }
 }
 }
-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) {
 CLEAR_PENDING_EXCEPTION;
 }
 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);
 }
 ObjectSynchronizer::wait(obj, ms, CHECK);
 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
 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
 JVM_ENTRY(jobject, JVM_Clone(JNIEnv* env, jobject handle))
 const KlassHandle klass (THREAD, obj->klass());
 JvmtiVMObjectAllocEventCollector oam;
 #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");
 bool cloneable = klass->is_subtype_of(SystemDictionary::Cloneable_klass());
 guarantee(cloneable == klass->is_cloneable(), "incorrect cloneable flag");
 }
 // 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 {
 new_obj = CollectedHeap::obj_allocate(klass, size, CHECK_NULL);
 }
 // Caution: this involves a java upcall, so the clone should be
 // "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));
 JVM_END
 // Misc. class handling ///////////////////////////////////////////////////////////
 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
 JVM_ENTRY(jclass, JVM_FindPrimitiveClass(JNIEnv* env, const char* utf))
 // into the constant pool.
 return NULL;
 }
 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;
 }
 if (TraceClassResolution) {
 Handle h_loader(THREAD, JNIHandles::resolve(loader));
 jclass result = find_class_from_class_loader(env, h_name, init, h_loader,
 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
 // into the constant pool.
 THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);
 }
 TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL);
 oop from_class_oop = JNIHandles::resolve(from);
-klassOop from_class = (from_class_oop == NULL)
+Klass* from_class = (from_class_oop == NULL)
-? (klassOop)NULL
+? (Klass*)NULL
-: java_lang_Class::as_klassOop(from_class_oop);
+: java_lang_Class::as_Klass(from_class_oop);
 oop class_loader = NULL;
 oop protection_domain = NULL;
 if (from_class != NULL) {
 class_loader = Klass::cast(from_class)->class_loader();
 protection_domain = Klass::cast(from_class)->protection_domain();
 if (TraceClassResolution && result != NULL) {
 // 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);
 }
 return result;
 is_lock_held_by_thread(class_loader,
 ClassLoader::sync_JVMDefineClassLockFreeCounter(),
 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);
 if (TraceClassResolution && k != NULL) {
 is_lock_held_by_thread(h_loader,
 ClassLoader::sync_JVMFindLoadedClassLockFreeCounter(),
 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);
 return (k == NULL) ? NULL :
 const char* name;
 if (java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
 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();
 }
 oop result = StringTable::intern((char*) name, CHECK_NULL);
 return (jstring) JNIHandles::make_local(env, result);
 // Primitive objects does not have any interfaces
 objArrayOop r = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
 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;
 }
 objArrayHandle result (THREAD, r);
 // Fill in result
 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 {
 // All arrays implement java.lang.Cloneable and java.io.Serializable
 result->obj_at_put(0, Klass::cast(SystemDictionary::Cloneable_klass())->java_mirror());
 JVM_ENTRY(jobject, JVM_GetClassLoader(JNIEnv *env, jclass cls))
 JVMWrapper("JVM_GetClassLoader");
 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
 JVMWrapper("JVM_IsInterface");
 oop mirror = JNIHandles::resolve_non_null(cls);
 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");
 // The compiler intrinsic for isInterface tests the
 // Klass::_access_flags bits in the same way.
 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
 // There are no signers for primitive types
 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
 // is an array, return NULL.
 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));
 }
 JVMWrapper("JVM_SetClassSigners");
 if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
 // 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
 if (java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
 // Primitive types does not have a protection domain.
 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
 // Obsolete since 1.2 (Class.setProtectionDomain removed), although
 if (JNIHandles::resolve(cls) == NULL) {
 THROW(vmSymbols::java_lang_NullPointerException());
 }
 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
 // Check that action object understands "Object run()"
 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");
 }
 // Compute the frame initiating the do privileged operation and setup the privileged stack
 vframeStream vfst(thread);
 bool is_privileged = false;
 oop protection_domain = NULL;
 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
 if (thread->privileged_stack_top() && thread->privileged_stack_top()->frame_id() == frame_id) {
 // this frame is privileged
 is_privileged = true;
 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)) {
 local_array->push(protection_domain);
 previous_protection_domain = protection_domain;
 JVM_END
 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));
+Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
-return (k != NULL) && Klass::cast(k)->oop_is_javaArray() ? true : false;
+return (k != NULL) && Klass::cast(k)->oop_is_array() ? true : false;
 JVM_END
 JVM_QUICK_ENTRY(jboolean, JVM_IsPrimitiveClass(JNIEnv *env, jclass cls))
 JVMWrapper("JVM_IsPrimitiveClass");
 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
 // Primitive type
 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();
 JVM_END
 // Inner class reflection ///////////////////////////////////////////////////////////////////////////////
 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) {
 // Neither an inner nor outer class
 oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
 if (ioff != 0 && ooff != 0) {
 // 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
 // an inner klass
 Reflection::check_for_inner_class(k, inner_klass, true, CHECK_NULL);
 JVM_ENTRY(jclass, JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass))
 {
 // 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
+Klass* outer_klass
-= instanceKlass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass))
+= 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)
 return (jclass) JNIHandles::make_local(env, Klass::cast(outer_klass)->java_mirror());
 }
 JVM_END
-// should be in instanceKlass.cpp, but is here for historical reasons
+// should be in InstanceKlass.cpp, but is here for historical reasons
-klassOop instanceKlass::compute_enclosing_class_impl(instanceKlassHandle k,
+Klass* InstanceKlass::compute_enclosing_class_impl(instanceKlassHandle k,
 bool* inner_is_member,
 TRAPS) {
 Thread* thread = THREAD;
 InnerClassesIterator iter(k);
 if (iter.length() == 0) {
 }
 constantPoolHandle i_cp(thread, k->constants());
 bool found = false;
-klassOop ok;
+Klass* ok;
 instanceKlassHandle outer_klass;
 *inner_is_member = false;
 // Find inner_klass attribute
 for (; !iter.done() && !found; iter.next()) {
 int noff = iter.inner_name_index();
 if (ioff != 0) {
 // 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);
 outer_klass = instanceKlassHandle(thread, ok);
 *inner_is_member = true;
 JVMWrapper("JVM_GetClassSignature");
 JvmtiVMObjectAllocEventCollector oam;
 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());
 }
 }
 assert (cls != NULL, "illegal class");
 JVMWrapper("JVM_GetClassAnnotations");
 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,
+typeArrayOop a = Annotations::make_java_array(InstanceKlass::cast(k)->class_annotations(), CHECK_NULL);
-instanceKlass::cast(k)->class_annotations());
+return (jbyteArray) JNIHandles::make_local(env, a);
 }
 }
 return NULL;
 JVM_END
 // some of this code was adapted from from jni_FromReflectedField
 // 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,
+if (!InstanceKlass::cast(kh())->find_local_field_from_offset(offset, true, &fd)) {
-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,
+if (!InstanceKlass::cast(kh())->find_field_from_offset(offset, false, &fd)) {
-&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);
 oop mirror    = NULL;
 int slot      = 0;
 assert(reflected->klass() == SystemDictionary::reflect_Method_klass(),
 "wrong type");
 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
 }
 JVM_ENTRY(jbyteArray, JVM_GetMethodAnnotations(JNIEnv *env, jobject method))
 JVMWrapper("JVM_GetMethodAnnotations");
 // method is a handle to a java.lang.reflect.Method object
-methodOop m = jvm_get_method_common(method, CHECK_NULL);
+Method* m = jvm_get_method_common(method, CHECK_NULL);
-return (jbyteArray) JNIHandles::make_local(env, m->annotations());
+return (jbyteArray) JNIHandles::make_local(env,
+Annotations::make_java_array(m->annotations(), THREAD));
 JVM_END
 JVM_ENTRY(jbyteArray, JVM_GetMethodDefaultAnnotationValue(JNIEnv *env, jobject method))
 JVMWrapper("JVM_GetMethodDefaultAnnotationValue");
 // method is a handle to a java.lang.reflect.Method object
-methodOop m = jvm_get_method_common(method, CHECK_NULL);
+Method* m = jvm_get_method_common(method, CHECK_NULL);
-return (jbyteArray) JNIHandles::make_local(env, m->annotation_default());
+return (jbyteArray) JNIHandles::make_local(env,
+Annotations::make_java_array(m->annotation_default(), THREAD));
 JVM_END
 JVM_ENTRY(jbyteArray, JVM_GetMethodParameterAnnotations(JNIEnv *env, jobject method))
 JVMWrapper("JVM_GetMethodParameterAnnotations");
 // method is a handle to a java.lang.reflect.Method object
-methodOop m = jvm_get_method_common(method, CHECK_NULL);
+Method* m = jvm_get_method_common(method, CHECK_NULL);
-return (jbyteArray) JNIHandles::make_local(env, m->parameter_annotations());
+return (jbyteArray) JNIHandles::make_local(env,
+Annotations::make_java_array(m->parameter_annotations(), THREAD));
 JVM_END
 // New (JDK 1.4) reflection implementation /////////////////////////////////////
 JVMWrapper("JVM_GetClassDeclaredFields");
 JvmtiVMObjectAllocEventCollector oam;
 // 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
 k->link_class(CHECK_NULL);
 JVMWrapper("JVM_GetClassDeclaredMethods");
 JvmtiVMObjectAllocEventCollector oam;
 // 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<Method*>* 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;
 }
 }
 objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_Method_klass(), num_methods, CHECK_NULL);
 objArrayHandle result (THREAD, r);
 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);
 result->obj_at_put(out_idx, m);
 ++out_idx;
 JVMWrapper("JVM_GetClassDeclaredConstructors");
 JvmtiVMObjectAllocEventCollector oam;
 // 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<Method*>* 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;
 }
 }
 objArrayOop r = oopFactory::new_objArray(SystemDictionary::reflect_Constructor_klass(), num_constructors, CHECK_NULL);
 objArrayHandle result(THREAD, r);
 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);
 result->obj_at_put(out_idx, m);
 ++out_idx;
 if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
 // Primitive type
 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
 JVMWrapper("JVM_GetClassConstantPool");
 JvmtiVMObjectAllocEventCollector oam;
 // 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());
 }
 }
 return NULL;
 }
 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
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "Constant pool index out of bounds");
 }
 }
-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());
 }
 JVM_END
 constantTag tag = cp->tag_at(index);
 if (!tag.is_method() && !tag.is_interface_method()) {
 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);
 method = Reflection::new_constructor(m, CHECK_NULL);
 }
 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;
 }
 JVM_END
 constantTag tag = cp->tag_at(index);
 if (!tag.is_field()) {
 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");
 }
 oop field = Reflection::new_field(&fd, true, CHECK_NULL);
 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()) {
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
 }
 dest->obj_at_put(2, str());
 return (jobjectArray) JNIHandles::make_local(dest());
 }
 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()) {
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
 }
 return cp->int_at(index);
 }
 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()) {
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
 }
 return cp->long_at(index);
 }
 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()) {
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
 }
 return cp->float_at(index);
 }
 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()) {
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
 }
 return cp->double_at(index);
 }
 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);
 return (jstring) JNIHandles::make_local(str);
 }
 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()) {
 THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
 }
 oop r = JNIHandles::resolve(cls);
 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;
 ResourceMark rm(THREAD);
 const char* name = Klass::cast(k)->name()->as_C_string();
 // Reflection for the verifier /////////////////////////////////////////////////////////////////
 // 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).
+//   Klass* class_to_verify_considering_redefinition(Klass* klass).
-// The function returns a klassOop of the _scratch_class if the verifier
+// 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
 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 :
+types[index] = (tag.is_unresolved_klass()) ? JVM_CONSTANT_Class : tag.value();
-(tag.is_unresolved_string()) ? JVM_CONSTANT_String : tag.value();
 }
 }
 JVM_END
 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);
+Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
-int length = methodOop(method)->checked_exceptions_length();
+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;
 }
 }
 JVM_END
 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);
+Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
-return methodOop(method)->checked_exceptions_length();
+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);
+Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
-memcpy(code, methodOop(method)->code_base(), methodOop(method)->code_size());
+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);
+Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
-return methodOop(method)->code_size();
+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);
+Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
-ExceptionTable extable((methodOop(method)));
+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);
 entry->catchType  = extable.catch_type_index(entry_index);
 JVM_END
 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);
+Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
-return methodOop(method)->exception_table_length();
+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);
+Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
-return methodOop(method)->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS;
+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);
+Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
-return methodOop(method)->max_locals();
+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);
+Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
-return methodOop(method)->size_of_parameters();
+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);
+Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
-return methodOop(method)->verifier_max_stack();
+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);
+Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
-return methodOop(method)->name() == vmSymbols::object_initializer_name();
+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);
+Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
-return methodOop(method)->name()->as_utf8();
+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);
+Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
-return methodOop(method)->signature()->as_utf8();
+return method->signature()->as_utf8();
 JVM_END
 /**
 * All of these JVM_GetCP-xxx methods are used by the old verifier to
 * read entries in the constant pool.  Since the old verifier always
 * that nothing it calls tries to use the cpCache instead of the raw
 * constant pool, so we must use cp->uncached_x methods when appropriate.
 */
 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();
 default:
 fatal("JVM_GetCPFieldNameUTF: illegal constant");
 JVM_END
 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:
 case JVM_CONSTANT_NameAndType:  // for invokedynamic
 return cp->uncached_name_ref_at(cp_index)->as_utf8();
 JVM_END
 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:
 case JVM_CONSTANT_NameAndType:  // for invokedynamic
 return cp->uncached_signature_ref_at(cp_index)->as_utf8();
 JVM_END
 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();
 default:
 fatal("JVM_GetCPFieldSignatureUTF: illegal constant");
 JVM_END
 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
 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);
 Symbol* classname = cp->klass_name_at(class_index);
 return classname->as_utf8();
 JVM_END
 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: {
 int class_index = cp->uncached_klass_ref_index_at(cp_index);
 Symbol* classname = cp->klass_name_at(class_index);
 JVM_END
 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));
+Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
-klassOop k_called = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(called_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();
-constantPoolOop cp_called = instanceKlass::cast(k_called)->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);
 Symbol* signature = cp->uncached_signature_ref_at(cp_index);
 for (JavaFieldStream fs(k_called); !fs.done(); fs.next()) {
 JVM_END
 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));
+Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
-klassOop k_called = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(called_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<Method*>* 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;
 }
 }
 return -1;
 JVM_ENTRY(jboolean, JVM_IsSameClassPackage(JNIEnv *env, jclass class1, jclass class2))
 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);
+Klass* klass1 = java_lang_Class::as_Klass(class1_mirror);
-klassOop klass2 = java_lang_Class::as_klassOop(class2_mirror);
+Klass* klass2 = java_lang_Class::as_Klass(class2_mirror);
 return (jboolean) Reflection::is_same_class_package(klass1, klass2);
 JVM_END
 // IO functions ////////////////////////////////////////////////////////////////////////////////////////
 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
 // if a method in a class in a trusted loader is in a doPrivileged, return NULL
 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();
-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 (jclass) JNIHandles::make_local(env, Klass::cast(holder)->java_mirror());
 }
 }
 }
 // if a method in a class in a trusted loader is in a doPrivileged, return NULL
 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);
 }
 }
 }
 int depth = 0;
 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));
 if (first == NULL) {
 first = last = l;
 int depth = 0;
 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++;
 }
 }
 for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
 // if a method in a class in a trusted loader is in a doPrivileged, return -1
 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;
 }
 depth++;
 }
 JVM_END
 // 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;
 }
 if ((current_class == field_class) || access.is_public()) {
 return true;
 if (Klass::cast(current_class)->is_subclass_of(field_class)) {
 return true;
 }
 }
-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));
 }
 // JVM_AllocateNewObject and JVM_AllocateNewArray are unused as of 1.4
 JVM_ENTRY(jobject, JVM_AllocateNewObject(JNIEnv *env, jobject receiver, jclass currClass, jclass initClass))
 ResourceMark rm(THREAD);
 THROW_0(vmSymbols::java_lang_InvalidClassException());
 }
 // Arrays not allowed here, must use JVM_AllocateNewArray
-if (Klass::cast(java_lang_Class::as_klassOop(curr_mirror))->oop_is_javaArray() ||
+if (Klass::cast(java_lang_Class::as_Klass(curr_mirror))->oop_is_array() ||
-Klass::cast(java_lang_Class::as_klassOop(init_mirror))->oop_is_javaArray()) {
+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 curr_klass (THREAD, java_lang_Class::as_Klass(curr_mirror));
-instanceKlassHandle init_klass (THREAD, java_lang_Class::as_klassOop(init_mirror));
+instanceKlassHandle init_klass (THREAD, java_lang_Class::as_Klass(init_mirror));
 assert(curr_klass->is_subclass_of(init_klass()), "just checking");
 // Interfaces, abstract classes, and java.lang.Class classes cannot be instantiated directly.
 curr_klass->check_valid_for_instantiation(false, CHECK_NULL);
 init_klass->find_method(vmSymbols::object_initializer_name(),
 vmSymbols::void_method_signature()));
 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()));
 }
 if (curr_klass ==  init_klass && !m->is_public()) {
 oop mirror = JNIHandles::resolve_non_null(currClass);
 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 {
 THROW_0(vmSymbols::java_lang_InvalidClassException());
 }
 JVM_ENTRY(jobject, JVM_LatestUserDefinedLoader(JNIEnv *env))
 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();
+Klass* holder = vfst.method()->method_holder();
-oop loader = instanceKlass::cast(holder)->class_loader();
+oop loader = InstanceKlass::cast(holder)->class_loader();
 if (loader != NULL) {
 return JNIHandles::make_local(env, loader);
 }
 }
 return NULL;
 if (curr_klass.is_null()) {
 for (vframeStream vfst(thread);
 !vfst.at_end() && loader == NULL;
 vfst.next()) {
 if (!vfst.method()->is_native()) {
-klassOop holder = vfst.method()->method_holder();
+Klass* holder = vfst.method()->method_holder();
-loader             = instanceKlass::cast(holder)->class_loader();
+loader             = InstanceKlass::cast(holder)->class_loader();
-protection_domain  = instanceKlass::cast(holder)->protection_domain();
+protection_domain  = InstanceKlass::cast(holder)->protection_domain();
 }
 }
 } else {
-klassOop curr_klass_oop = java_lang_Class::as_klassOop(curr_klass());
+Klass* curr_klass_oop = java_lang_Class::as_Klass(curr_klass());
-loader            = instanceKlass::cast(curr_klass_oop)->class_loader();
+loader            = InstanceKlass::cast(curr_klass_oop)->class_loader();
-protection_domain = instanceKlass::cast(curr_klass_oop)->protection_domain();
+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
 static inline arrayOop check_array(JNIEnv *env, jobject arr, bool type_array_only, TRAPS) {
 if (arr == NULL) {
 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);
 }
 jclass find_class_from_class_loader(JNIEnv* env, Symbol* name, jboolean init, Handle loader, Handle protection_domain, jboolean throwError, TRAPS) {
 // 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
 if (init && klass_handle->oop_is_instance()) {
 klass_handle->initialize(CHECK_NULL);
 if (num_threads == 0) {
 THROW_(vmSymbols::java_lang_IllegalArgumentException(), 0);
 }
 // 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);
 }
 ResourceMark rm(THREAD);
 Handle mirror(THREAD, JNIHandles::resolve_non_null(ofClass));
 // Special handling for primitive objects
 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;
 }
 instanceKlassHandle ik_h(THREAD, k);
 int encl_method_class_idx = ik_h->enclosing_method_class_index();
 if (encl_method_class_idx == 0) {
 return NULL;
 }
 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) {
 Symbol* sym = ik_h->constants()->symbol_at(
 extract_low_short_from_int(

changeset 13728	882756847a04
parent 13396	1b2b5f740ee0
child 13952	e3cf184080bc