Mercurial > hg > truffle
diff src/share/vm/classfile/javaClasses.cpp @ 6725:da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes
Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland
Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>
author | coleenp |
---|---|
date | Sat, 01 Sep 2012 13:25:18 -0400 |
parents | 977007096840 |
children | aed758eda82a |
line wrap: on
line diff
--- a/src/share/vm/classfile/javaClasses.cpp Fri Aug 31 16:39:35 2012 -0700 +++ b/src/share/vm/classfile/javaClasses.cpp Sat Sep 01 13:25:18 2012 -0400 @@ -38,8 +38,7 @@ #include "oops/instanceKlass.hpp" #include "oops/instanceMirrorKlass.hpp" #include "oops/klass.hpp" -#include "oops/klassOop.hpp" -#include "oops/methodOop.hpp" +#include "oops/method.hpp" #include "oops/symbol.hpp" #include "oops/typeArrayOop.hpp" #include "runtime/fieldDescriptor.hpp" @@ -106,7 +105,7 @@ } -static bool find_field(instanceKlass* ik, +static bool find_field(InstanceKlass* ik, Symbol* name_symbol, Symbol* signature_symbol, fieldDescriptor* fd, bool allow_super = false) { @@ -119,17 +118,17 @@ // Helpful routine for computing field offsets at run time rather than hardcoding them static void compute_offset(int &dest_offset, - klassOop klass_oop, Symbol* name_symbol, Symbol* signature_symbol, + Klass* klass_oop, Symbol* name_symbol, Symbol* signature_symbol, bool allow_super = false) { fieldDescriptor fd; - instanceKlass* ik = instanceKlass::cast(klass_oop); + InstanceKlass* ik = InstanceKlass::cast(klass_oop); if (!find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) { ResourceMark rm; tty->print_cr("Invalid layout of %s at %s", ik->external_name(), name_symbol->as_C_string()); #ifndef PRODUCT klass_oop->print(); tty->print_cr("all fields:"); - for (AllFieldStream fs(instanceKlass::cast(klass_oop)); !fs.done(); fs.next()) { + for (AllFieldStream fs(InstanceKlass::cast(klass_oop)); !fs.done(); fs.next()) { tty->print_cr(" name: %s, sig: %s, flags: %08x", fs.name()->as_C_string(), fs.signature()->as_C_string(), fs.access_flags().as_int()); } #endif //PRODUCT @@ -141,10 +140,10 @@ // Same as above but for "optional" offsets that might not be present in certain JDK versions static void compute_optional_offset(int& dest_offset, - klassOop klass_oop, Symbol* name_symbol, Symbol* signature_symbol, + Klass* klass_oop, Symbol* name_symbol, Symbol* signature_symbol, bool allow_super = false) { fieldDescriptor fd; - instanceKlass* ik = instanceKlass::cast(klass_oop); + InstanceKlass* ik = InstanceKlass::cast(klass_oop); if (find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) { dest_offset = fd.offset(); } @@ -161,7 +160,7 @@ void java_lang_String::compute_offsets() { assert(!initialized, "offsets should be initialized only once"); - klassOop k = SystemDictionary::String_klass(); + Klass* k = SystemDictionary::String_klass(); compute_offset(value_offset, k, vmSymbols::value_name(), vmSymbols::char_array_signature()); compute_optional_offset(offset_offset, k, vmSymbols::offset_name(), vmSymbols::int_signature()); compute_optional_offset(count_offset, k, vmSymbols::count_name(), vmSymbols::int_signature()); @@ -170,26 +169,18 @@ initialized = true; } -Handle java_lang_String::basic_create(int length, bool tenured, TRAPS) { +Handle java_lang_String::basic_create(int length, TRAPS) { assert(initialized, "Must be initialized"); // Create the String object first, so there's a chance that the String // and the char array it points to end up in the same cache line. oop obj; - if (tenured) { - obj = instanceKlass::cast(SystemDictionary::String_klass())->allocate_permanent_instance(CHECK_NH); - } else { - obj = instanceKlass::cast(SystemDictionary::String_klass())->allocate_instance(CHECK_NH); - } + obj = InstanceKlass::cast(SystemDictionary::String_klass())->allocate_instance(CHECK_NH); // Create the char array. The String object must be handlized here // because GC can happen as a result of the allocation attempt. Handle h_obj(THREAD, obj); typeArrayOop buffer; - if (tenured) { - buffer = oopFactory::new_permanent_charArray(length, CHECK_NH); - } else { buffer = oopFactory::new_charArray(length, CHECK_NH); - } // Point the String at the char array obj = h_obj(); @@ -202,8 +193,8 @@ return h_obj; } -Handle java_lang_String::basic_create_from_unicode(jchar* unicode, int length, bool tenured, TRAPS) { - Handle h_obj = basic_create(length, tenured, CHECK_NH); +Handle java_lang_String::create_from_unicode(jchar* unicode, int length, TRAPS) { + Handle h_obj = basic_create(length, CHECK_NH); typeArrayOop buffer = value(h_obj()); for (int index = 0; index < length; index++) { buffer->char_at_put(index, unicode[index]); @@ -211,16 +202,8 @@ return h_obj; } -Handle java_lang_String::create_from_unicode(jchar* unicode, int length, TRAPS) { - return basic_create_from_unicode(unicode, length, false, CHECK_NH); -} - -Handle java_lang_String::create_tenured_from_unicode(jchar* unicode, int length, TRAPS) { - return basic_create_from_unicode(unicode, length, JavaObjectsInPerm, CHECK_NH); -} - oop java_lang_String::create_oop_from_unicode(jchar* unicode, int length, TRAPS) { - Handle h_obj = basic_create_from_unicode(unicode, length, false, CHECK_0); + Handle h_obj = create_from_unicode(unicode, length, CHECK_0); return h_obj(); } @@ -229,7 +212,7 @@ return Handle(); } int length = UTF8::unicode_length(utf8_str); - Handle h_obj = basic_create(length, false, CHECK_NH); + Handle h_obj = basic_create(length, CHECK_NH); if (length > 0) { UTF8::convert_to_unicode(utf8_str, value(h_obj())->char_at_addr(0), length); } @@ -243,7 +226,7 @@ Handle java_lang_String::create_from_symbol(Symbol* symbol, TRAPS) { int length = UTF8::unicode_length((char*)symbol->bytes(), symbol->utf8_length()); - Handle h_obj = basic_create(length, false, CHECK_NH); + Handle h_obj = basic_create(length, CHECK_NH); if (length > 0) { UTF8::convert_to_unicode((char*)symbol->bytes(), value(h_obj())->char_at_addr(0), length); } @@ -327,7 +310,7 @@ // Create new UNICODE buffer. Must handlize value because GC // may happen during String and char array creation. typeArrayHandle h_value(THREAD, value); - Handle string = basic_create(length, false, CHECK_NH); + Handle string = basic_create(length, CHECK_NH); typeArrayOop from_buffer = h_value(); typeArrayOop to_buffer = java_lang_String::value(string()); @@ -519,17 +502,20 @@ void java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) { assert(instanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already"); + // If the offset was read from the shared archive, it was fixed up already + if (!k->is_shared()) { if (k->oop_is_instance()) { // During bootstrap, java.lang.Class wasn't loaded so static field // offsets were computed without the size added it. Go back and // update all the static field offsets to included the size. - for (JavaFieldStream fs(instanceKlass::cast(k())); !fs.done(); fs.next()) { + for (JavaFieldStream fs(InstanceKlass::cast(k())); !fs.done(); fs.next()) { if (fs.access_flags().is_static()) { int real_offset = fs.offset() + instanceMirrorKlass::offset_of_static_fields(); fs.set_offset(real_offset); } } } + } create_mirror(k, CHECK); } @@ -541,7 +527,9 @@ // class is put into the system dictionary. int computed_modifiers = k->compute_modifier_flags(CHECK_0); k->set_modifier_flags(computed_modifiers); - if (SystemDictionary::Class_klass_loaded() && (k->oop_is_instance() || k->oop_is_javaArray())) { + // Class_klass has to be loaded because it is used to allocate + // the mirror. + if (SystemDictionary::Class_klass_loaded()) { // Allocate mirror (java.lang.Class instance) Handle mirror = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK_0); @@ -549,33 +537,35 @@ java_lang_Class::set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(mirror())); // It might also have a component mirror. This mirror must already exist. - if (k->oop_is_javaArray()) { + if (k->oop_is_array()) { Handle comp_mirror; if (k->oop_is_typeArray()) { - BasicType type = typeArrayKlass::cast(k->as_klassOop())->element_type(); + BasicType type = typeArrayKlass::cast(k())->element_type(); comp_mirror = Universe::java_mirror(type); - assert(comp_mirror.not_null(), "must have primitive mirror"); - } else if (k->oop_is_objArray()) { - klassOop element_klass = objArrayKlass::cast(k->as_klassOop())->element_klass(); - if (element_klass != NULL - && (Klass::cast(element_klass)->oop_is_instance() || - Klass::cast(element_klass)->oop_is_javaArray())) { + } else { + assert(k->oop_is_objArray(), "Must be"); + Klass* element_klass = objArrayKlass::cast(k())->element_klass(); + assert(element_klass != NULL, "Must have an element klass"); comp_mirror = Klass::cast(element_klass)->java_mirror(); - assert(comp_mirror.not_null(), "must have element mirror"); - } - // else some object array internal to the VM, like systemObjArrayKlassObj } - if (comp_mirror.not_null()) { + assert(comp_mirror.not_null(), "must have a mirror"); + // Two-way link between the array klass and its component mirror: - arrayKlass::cast(k->as_klassOop())->set_component_mirror(comp_mirror()); - set_array_klass(comp_mirror(), k->as_klassOop()); - } - } else if (k->oop_is_instance()) { + arrayKlass::cast(k())->set_component_mirror(comp_mirror()); + set_array_klass(comp_mirror(), k()); + } else { + assert(k->oop_is_instance(), "Must be"); // Initialize static fields - instanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, CHECK_NULL); + InstanceKlass::cast(k())->do_local_static_fields(&initialize_static_field, CHECK_NULL); } return mirror(); } else { + if (fixup_mirror_list() == NULL) { + GrowableArray<Klass*>* list = + new (ResourceObj::C_HEAP, mtClass) GrowableArray<Klass*>(40, true); + set_fixup_mirror_list(list); + } + fixup_mirror_list()->push(k()); return NULL; } } @@ -602,9 +592,9 @@ oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) { // This should be improved by adding a field at the Java level or by // introducing a new VM klass (see comment in ClassFileParser) - oop java_class = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance((oop)NULL, CHECK_0); + oop java_class = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(NULL, CHECK_0); if (type != T_VOID) { - klassOop aklass = Universe::typeArrayKlassObj(type); + Klass* aklass = Universe::typeArrayKlassObj(type); assert(aklass != NULL, "correct bootstrap"); set_array_klass(java_class, aklass); } @@ -616,18 +606,18 @@ } -klassOop java_lang_Class::as_klassOop(oop java_class) { +Klass* java_lang_Class::as_Klass(oop java_class) { //%note memory_2 assert(java_lang_Class::is_instance(java_class), "must be a Class object"); - klassOop k = klassOop(java_class->obj_field(_klass_offset)); + Klass* k = ((Klass*)java_class->metadata_field(_klass_offset)); assert(k == NULL || k->is_klass(), "type check"); return k; } -void java_lang_Class::set_klass(oop java_class, klassOop klass) { +void java_lang_Class::set_klass(oop java_class, Klass* klass) { assert(java_lang_Class::is_instance(java_class), "must be a Class object"); - java_class->obj_field_put(_klass_offset, klass); + java_class->metadata_field_put(_klass_offset, klass); } @@ -638,7 +628,7 @@ if (is_primitive(java_class)) { name = vmSymbols::type_signature(primitive_type(java_class)); } else { - klassOop k = as_klassOop(java_class); + Klass* k = as_Klass(java_class); is_instance = Klass::cast(k)->oop_is_instance(); name = Klass::cast(k)->name(); } @@ -661,7 +651,7 @@ // that are not created or incremented due to a successful lookup. name->increment_refcount(); } else { - klassOop k = as_klassOop(java_class); + Klass* k = as_Klass(java_class); if (!Klass::cast(k)->oop_is_instance()) { name = Klass::cast(k)->name(); name->increment_refcount(); @@ -680,43 +670,52 @@ } -klassOop java_lang_Class::array_klass(oop java_class) { - klassOop k = klassOop(java_class->obj_field(_array_klass_offset)); - assert(k == NULL || k->is_klass() && Klass::cast(k)->oop_is_javaArray(), "should be array klass"); +Klass* java_lang_Class::array_klass(oop java_class) { + Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset)); + assert(k == NULL || k->is_klass() && Klass::cast(k)->oop_is_array(), "should be array klass"); return k; } -void java_lang_Class::set_array_klass(oop java_class, klassOop klass) { - assert(klass->is_klass() && Klass::cast(klass)->oop_is_javaArray(), "should be array klass"); - java_class->obj_field_put(_array_klass_offset, klass); +void java_lang_Class::set_array_klass(oop java_class, Klass* klass) { + assert(klass->is_klass() && Klass::cast(klass)->oop_is_array(), "should be array klass"); + java_class->metadata_field_put(_array_klass_offset, klass); } -methodOop java_lang_Class::resolved_constructor(oop java_class) { - oop constructor = java_class->obj_field(_resolved_constructor_offset); +Method* java_lang_Class::resolved_constructor(oop java_class) { + Metadata* constructor = java_class->metadata_field(_resolved_constructor_offset); assert(constructor == NULL || constructor->is_method(), "should be method"); - return methodOop(constructor); + return ((Method*)constructor); } -void java_lang_Class::set_resolved_constructor(oop java_class, methodOop constructor) { +void java_lang_Class::set_resolved_constructor(oop java_class, Method* constructor) { assert(constructor->is_method(), "should be method"); - java_class->obj_field_put(_resolved_constructor_offset, constructor); + java_class->metadata_field_put(_resolved_constructor_offset, constructor); } bool java_lang_Class::is_primitive(oop java_class) { // should assert: //assert(java_lang_Class::is_instance(java_class), "must be a Class object"); - klassOop k = klassOop(java_class->obj_field(_klass_offset)); - return k == NULL; + bool is_primitive = (java_class->metadata_field(_klass_offset) == NULL); + +#ifdef ASSERT + if (is_primitive) { + Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset)); + assert(k == NULL || is_java_primitive(arrayKlass::cast(k)->element_type()), + "Should be either the T_VOID primitive or a java primitive"); + } +#endif + + return is_primitive; } BasicType java_lang_Class::primitive_type(oop java_class) { assert(java_lang_Class::is_primitive(java_class), "just checking"); - klassOop ak = klassOop(java_class->obj_field(_array_klass_offset)); + Klass* ak = ((Klass*)java_class->metadata_field(_array_klass_offset)); BasicType type = T_VOID; if (ak != NULL) { // Note: create_basic_type_mirror above initializes ak to a non-null value. @@ -728,7 +727,7 @@ return type; } -BasicType java_lang_Class::as_BasicType(oop java_class, klassOop* reference_klass) { +BasicType java_lang_Class::as_BasicType(oop java_class, Klass** reference_klass) { assert(java_lang_Class::is_instance(java_class), "must be a Class object"); if (is_primitive(java_class)) { if (reference_klass != NULL) @@ -736,7 +735,7 @@ return primitive_type(java_class); } else { if (reference_klass != NULL) - (*reference_klass) = as_klassOop(java_class); + (*reference_klass) = as_Klass(java_class); return T_OBJECT; } } @@ -756,7 +755,7 @@ assert(!offsets_computed, "offsets should be initialized only once"); offsets_computed = true; - klassOop klass_oop = SystemDictionary::Class_klass(); + Klass* klass_oop = SystemDictionary::Class_klass(); // The classRedefinedCount field is only present starting in 1.5, // so don't go fatal. compute_optional_offset(classRedefinedCount_offset, @@ -814,7 +813,7 @@ void java_lang_Thread::compute_offsets() { assert(_group_offset == 0, "offsets should be initialized only once"); - klassOop k = SystemDictionary::Thread_klass(); + Klass* k = SystemDictionary::Thread_klass(); compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::char_array_signature()); compute_offset(_group_offset, k, vmSymbols::group_name(), vmSymbols::threadgroup_signature()); compute_offset(_contextClassLoader_offset, k, vmSymbols::contextClassLoader_name(), vmSymbols::classloader_signature()); @@ -1073,7 +1072,7 @@ void java_lang_ThreadGroup::compute_offsets() { assert(_parent_offset == 0, "offsets should be initialized only once"); - klassOop k = SystemDictionary::ThreadGroup_klass(); + Klass* k = SystemDictionary::ThreadGroup_klass(); compute_offset(_parent_offset, k, vmSymbols::parent_name(), vmSymbols::threadgroup_signature()); compute_offset(_name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); @@ -1088,7 +1087,7 @@ } oop java_lang_Throwable::unassigned_stacktrace() { - instanceKlass* ik = instanceKlass::cast(SystemDictionary::Throwable_klass()); + InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Throwable_klass()); address addr = ik->static_field_addr(static_unassigned_stacktrace_offset); if (UseCompressedOops) { return oopDesc::load_decode_heap_oop((narrowOop *)addr); @@ -1134,9 +1133,9 @@ void java_lang_Throwable::print(oop throwable, outputStream* st) { ResourceMark rm; - klassOop k = throwable->klass(); + Klass* k = throwable->klass(); assert(k != NULL, "just checking"); - st->print("%s", instanceKlass::cast(k)->external_name()); + st->print("%s", InstanceKlass::cast(k)->external_name()); oop msg = message(throwable); if (msg != NULL) { st->print(": %s", java_lang_String::as_utf8_string(msg)); @@ -1146,9 +1145,9 @@ void java_lang_Throwable::print(Handle throwable, outputStream* st) { ResourceMark rm; - klassOop k = throwable->klass(); + Klass* k = throwable->klass(); assert(k != NULL, "just checking"); - st->print("%s", instanceKlass::cast(k)->external_name()); + st->print("%s", InstanceKlass::cast(k)->external_name()); oop msg = message(throwable); if (msg != NULL) { st->print(": %s", java_lang_String::as_utf8_string(msg)); @@ -1156,9 +1155,9 @@ } // Print stack trace element to resource allocated buffer -char* java_lang_Throwable::print_stack_element_to_buffer(methodOop method, int bci) { +char* java_lang_Throwable::print_stack_element_to_buffer(Method* method, int bci) { // Get strings and string lengths - instanceKlass* klass = instanceKlass::cast(method->method_holder()); + InstanceKlass* klass = InstanceKlass::cast(method->method_holder()); const char* klass_name = klass->external_name(); int buf_len = (int)strlen(klass_name); char* source_file_name; @@ -1200,13 +1199,13 @@ } -void java_lang_Throwable::print_stack_element(Handle stream, methodOop method, int bci) { +void java_lang_Throwable::print_stack_element(Handle stream, Method* method, int bci) { ResourceMark rm; char* buf = print_stack_element_to_buffer(method, bci); print_to_stream(stream, buf); } -void java_lang_Throwable::print_stack_element(outputStream *st, methodOop method, int bci) { +void java_lang_Throwable::print_stack_element(outputStream *st, Method* method, int bci) { ResourceMark rm; char* buf = print_stack_element_to_buffer(method, bci); st->print_cr("%s", buf); @@ -1252,8 +1251,8 @@ } while (result.not_null()) { - objArrayHandle methods (THREAD, - objArrayOop(result->obj_at(trace_methods_offset))); + typeArrayHandle methods (THREAD, + typeArrayOop(result->obj_at(trace_methods_offset))); typeArrayHandle bcis (THREAD, typeArrayOop(result->obj_at(trace_bcis_offset))); @@ -1264,7 +1263,7 @@ int length = methods()->length(); for (int index = 0; index < length; index++) { - methodOop method = methodOop(methods()->obj_at(index)); + Method* method = ((Method*)methods()->metadata_at(index)); if (method == NULL) goto handle_cause; int bci = bcis->ushort_at(index); print_stack_element(st, method, bci); @@ -1309,8 +1308,8 @@ } while (result.not_null()) { - objArrayHandle methods (thread, - objArrayOop(result->obj_at(trace_methods_offset))); + typeArrayHandle methods(thread, + typeArrayOop(result->obj_at(trace_methods_offset))); typeArrayHandle bcis (thread, typeArrayOop(result->obj_at(trace_bcis_offset))); @@ -1321,7 +1320,7 @@ int length = methods()->length(); for (int index = 0; index < length; index++) { - methodOop method = methodOop(methods()->obj_at(index)); + Method* method = ((Method*)methods()->metadata_at(index)); if (method == NULL) return; int bci = bcis->ushort_at(index); print_stack_element(stream, method, bci); @@ -1337,8 +1336,9 @@ private: Handle _backtrace; objArrayOop _head; - objArrayOop _methods; + typeArrayOop _methods; typeArrayOop _bcis; + objArrayOop _mirrors; int _index; No_Safepoint_Verifier _nsv; @@ -1347,13 +1347,14 @@ enum { trace_methods_offset = java_lang_Throwable::trace_methods_offset, trace_bcis_offset = java_lang_Throwable::trace_bcis_offset, + trace_mirrors_offset = java_lang_Throwable::trace_mirrors_offset, trace_next_offset = java_lang_Throwable::trace_next_offset, trace_size = java_lang_Throwable::trace_size, trace_chunk_size = java_lang_Throwable::trace_chunk_size }; // constructor for new backtrace - BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL) { + BacktraceBuilder(TRAPS): _methods(NULL), _bcis(NULL), _head(NULL), _mirrors(NULL) { expand(CHECK); _backtrace = _head; _index = 0; @@ -1366,21 +1367,26 @@ objArrayOop head = oopFactory::new_objectArray(trace_size, CHECK); objArrayHandle new_head(THREAD, head); - objArrayOop methods = oopFactory::new_objectArray(trace_chunk_size, CHECK); - objArrayHandle new_methods(THREAD, methods); + typeArrayOop methods = oopFactory::new_metaDataArray(trace_chunk_size, CHECK); + typeArrayHandle new_methods(THREAD, methods); typeArrayOop bcis = oopFactory::new_shortArray(trace_chunk_size, CHECK); typeArrayHandle new_bcis(THREAD, bcis); + objArrayOop mirrors = oopFactory::new_objectArray(trace_chunk_size, CHECK); + objArrayHandle new_mirrors(THREAD, mirrors); + if (!old_head.is_null()) { old_head->obj_at_put(trace_next_offset, new_head()); } new_head->obj_at_put(trace_methods_offset, new_methods()); new_head->obj_at_put(trace_bcis_offset, new_bcis()); + new_head->obj_at_put(trace_mirrors_offset, new_mirrors()); _head = new_head(); _methods = new_methods(); _bcis = new_bcis(); + _mirrors = new_mirrors(); _index = 0; } @@ -1388,7 +1394,7 @@ return _backtrace(); } - inline void push(methodOop method, int bci, TRAPS) { + inline void push(Method* method, int bci, TRAPS) { // Smear the -1 bci to 0 since the array only holds unsigned // shorts. The later line number lookup would just smear the -1 // to a 0 even if it could be recorded. @@ -1401,14 +1407,18 @@ method = mhandle(); } - _methods->obj_at_put(_index, method); + _methods->metadata_at_put(_index, method); _bcis->ushort_at_put(_index, bci); + // we need to save the mirrors in the backtrace to keep the methods from + // being unloaded if their class loader is unloaded while we still have + // this stack trace. + _mirrors->obj_at_put(_index, method->method_holder()->java_mirror()); _index++; } - methodOop current_method() { + Method* current_method() { assert(_index >= 0 && _index < trace_chunk_size, "out of range"); - return methodOop(_methods->obj_at(_index)); + return ((Method*)_methods->metadata_at(_index)); } jushort current_bci() { @@ -1465,14 +1475,14 @@ bool skip_hidden = !ShowHiddenFrames; for (frame fr = thread->last_frame(); max_depth != total_count;) { - methodOop method = NULL; + Method* method = NULL; int bci = 0; // Compiled java method case. if (decode_offset != 0) { DebugInfoReadStream stream(nm, decode_offset); decode_offset = stream.read_int(); - method = (methodOop)nm->oop_at(stream.read_int()); + method = (Method*)nm->metadata_at(stream.read_int()); bci = stream.read_bci(); } else { if (fr.is_first_frame()) break; @@ -1508,7 +1518,7 @@ "Wrong stack trace"); st.next(); // vframeStream::method isn't GC-safe so store off a copy - // of the methodOop in case we GC. + // of the Method* in case we GC. if (!st.at_end()) { st_method = st.method(); } @@ -1580,14 +1590,17 @@ objArrayOop h_oop = oopFactory::new_objectArray(trace_size, CHECK); objArrayHandle backtrace (THREAD, h_oop); - objArrayOop m_oop = oopFactory::new_objectArray(trace_chunk_size, CHECK); - objArrayHandle methods (THREAD, m_oop); + typeArrayOop m_oop = oopFactory::new_metaDataArray(trace_chunk_size, CHECK); + typeArrayHandle methods (THREAD, m_oop); typeArrayOop b = oopFactory::new_shortArray(trace_chunk_size, CHECK); typeArrayHandle bcis(THREAD, b); + objArrayOop mirror_oop = oopFactory::new_objectArray(trace_chunk_size, CHECK); + objArrayHandle mirrors (THREAD, mirror_oop); // backtrace has space for one chunk (next is NULL) backtrace->obj_at_put(trace_methods_offset, methods()); backtrace->obj_at_put(trace_bcis_offset, bcis()); + backtrace->obj_at_put(trace_mirrors_offset, mirrors()); set_backtrace(throwable(), backtrace()); } @@ -1600,18 +1613,24 @@ assert(throwable->is_a(SystemDictionary::Throwable_klass()), "sanity check"); - oop backtrace = java_lang_Throwable::backtrace(throwable()); + objArrayOop backtrace = (objArrayOop)java_lang_Throwable::backtrace(throwable()); assert(backtrace != NULL, "backtrace not preallocated"); - oop m = objArrayOop(backtrace)->obj_at(trace_methods_offset); - objArrayOop methods = objArrayOop(m); + oop m = backtrace->obj_at(trace_methods_offset); + typeArrayOop methods = typeArrayOop(m); assert(methods != NULL && methods->length() > 0, "method array not preallocated"); - oop b = objArrayOop(backtrace)->obj_at(trace_bcis_offset); + oop b = backtrace->obj_at(trace_bcis_offset); typeArrayOop bcis = typeArrayOop(b); assert(bcis != NULL, "bci array not preallocated"); - assert(methods->length() == bcis->length(), "method and bci arrays should match"); + oop mr = backtrace->obj_at(trace_mirrors_offset); + objArrayOop mirrors = objArrayOop(mr); + assert(mirrors != NULL, "bci array not preallocated"); + + assert(methods->length() == bcis->length() && + methods->length() == mirrors->length(), + "method and bci arrays should match"); JavaThread* thread = JavaThread::current(); ResourceMark rm(thread); @@ -1632,7 +1651,9 @@ if (bci == SynchronizationEntryBCI) bci = 0; assert(bci == (jushort)bci, "doesn't fit"); bcis->ushort_at_put(chunk_count, bci); - methods->obj_at_put(chunk_count, st.method()); + methods->metadata_at_put(chunk_count, st.method()); + mirrors->obj_at_put(chunk_count, + st.method()->method_holder()->java_mirror()); chunk_count++; @@ -1667,11 +1688,11 @@ } assert(chunk != NULL && chunk->obj_at(trace_next_offset) == NULL, "sanity check"); // Count element in remaining partial chunk - objArrayOop methods = objArrayOop(chunk->obj_at(trace_methods_offset)); + typeArrayOop methods = typeArrayOop(chunk->obj_at(trace_methods_offset)); typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset)); assert(methods != NULL && bcis != NULL, "sanity check"); for (int i = 0; i < methods->length(); i++) { - if (methods->obj_at(i) == NULL) break; + if (methods->metadata_at(i) == NULL) break; depth++; } } @@ -1698,10 +1719,10 @@ THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL); } // Get method,bci from chunk - objArrayOop methods = objArrayOop(chunk->obj_at(trace_methods_offset)); + typeArrayOop methods = typeArrayOop(chunk->obj_at(trace_methods_offset)); typeArrayOop bcis = typeArrayOop(chunk->obj_at(trace_bcis_offset)); assert(methods != NULL && bcis != NULL, "sanity check"); - methodHandle method(THREAD, methodOop(methods->obj_at(chunk_index))); + methodHandle method(THREAD, ((Method*)methods->metadata_at(chunk_index))); int bci = bcis->ushort_at(chunk_index); // Chunk can be partial full if (method.is_null()) { @@ -1717,7 +1738,7 @@ assert(JDK_Version::is_gte_jdk14x_version(), "should only be called in >= 1.4"); // Allocate java.lang.StackTraceElement instance - klassOop k = SystemDictionary::StackTraceElement_klass(); + Klass* k = SystemDictionary::StackTraceElement_klass(); assert(k != NULL, "must be loaded in 1.4+"); instanceKlassHandle ik (THREAD, k); if (ik->should_be_initialized()) { @@ -1727,14 +1748,14 @@ Handle element = ik->allocate_instance_handle(CHECK_0); // Fill in class name ResourceMark rm(THREAD); - const char* str = instanceKlass::cast(method->method_holder())->external_name(); + const char* str = InstanceKlass::cast(method->method_holder())->external_name(); oop classname = StringTable::intern((char*) str, CHECK_0); java_lang_StackTraceElement::set_declaringClass(element(), classname); // Fill in method name oop methodname = StringTable::intern(method->name(), CHECK_0); java_lang_StackTraceElement::set_methodName(element(), methodname); // Fill in source file name - Symbol* source = instanceKlass::cast(method->method_holder())->source_file_name(); + Symbol* source = InstanceKlass::cast(method->method_holder())->source_file_name(); if (ShowHiddenFrames && source == NULL) source = vmSymbols::unknown_class_name(); oop filename = StringTable::intern(source, CHECK_0); @@ -1760,7 +1781,7 @@ void java_lang_reflect_AccessibleObject::compute_offsets() { - klassOop k = SystemDictionary::reflect_AccessibleObject_klass(); + Klass* k = SystemDictionary::reflect_AccessibleObject_klass(); compute_offset(override_offset, k, vmSymbols::override_name(), vmSymbols::bool_signature()); } @@ -1775,7 +1796,7 @@ } void java_lang_reflect_Method::compute_offsets() { - klassOop k = SystemDictionary::reflect_Method_klass(); + Klass* k = SystemDictionary::reflect_Method_klass(); compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); compute_offset(returnType_offset, k, vmSymbols::returnType_name(), vmSymbols::class_signature()); @@ -1796,11 +1817,11 @@ Handle java_lang_reflect_Method::create(TRAPS) { assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); - klassOop klass = SystemDictionary::reflect_Method_klass(); + Klass* klass = SystemDictionary::reflect_Method_klass(); // This class is eagerly initialized during VM initialization, since we keep a refence // to one of the methods - assert(instanceKlass::cast(klass)->is_initialized(), "must be initialized"); - return instanceKlass::cast(klass)->allocate_instance_handle(CHECK_NH); + assert(InstanceKlass::cast(klass)->is_initialized(), "must be initialized"); + return InstanceKlass::cast(klass)->allocate_instance_handle(CHECK_NH); } oop java_lang_reflect_Method::clazz(oop reflect) { @@ -1938,7 +1959,7 @@ } void java_lang_reflect_Constructor::compute_offsets() { - klassOop k = SystemDictionary::reflect_Constructor_klass(); + Klass* k = SystemDictionary::reflect_Constructor_klass(); compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature()); compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature()); @@ -1956,7 +1977,7 @@ Handle java_lang_reflect_Constructor::create(TRAPS) { assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); Symbol* name = vmSymbols::java_lang_reflect_Constructor(); - klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); + Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); instanceKlassHandle klass (THREAD, k); // Ensure it is initialized klass->initialize(CHECK_NH); @@ -2062,7 +2083,7 @@ } void java_lang_reflect_Field::compute_offsets() { - klassOop k = SystemDictionary::reflect_Field_klass(); + Klass* k = SystemDictionary::reflect_Field_klass(); compute_offset(clazz_offset, k, vmSymbols::clazz_name(), vmSymbols::class_signature()); compute_offset(name_offset, k, vmSymbols::name_name(), vmSymbols::string_signature()); compute_offset(type_offset, k, vmSymbols::type_name(), vmSymbols::class_signature()); @@ -2078,7 +2099,7 @@ Handle java_lang_reflect_Field::create(TRAPS) { assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); Symbol* name = vmSymbols::java_lang_reflect_Field(); - klassOop k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); + Klass* k = SystemDictionary::resolve_or_fail(name, true, CHECK_NH); instanceKlassHandle klass (THREAD, k); // Ensure it is initialized klass->initialize(CHECK_NH); @@ -2169,17 +2190,18 @@ void sun_reflect_ConstantPool::compute_offsets() { - klassOop k = SystemDictionary::reflect_ConstantPool_klass(); + Klass* k = SystemDictionary::reflect_ConstantPool_klass(); // This null test can be removed post beta if (k != NULL) { - compute_offset(_cp_oop_offset, k, vmSymbols::constantPoolOop_name(), vmSymbols::object_signature()); + // The field is called ConstantPool* in the sun.reflect.ConstantPool class. + compute_offset(_oop_offset, k, vmSymbols::ConstantPool_name(), vmSymbols::object_signature()); } } Handle sun_reflect_ConstantPool::create(TRAPS) { assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); - klassOop k = SystemDictionary::reflect_ConstantPool_klass(); + Klass* k = SystemDictionary::reflect_ConstantPool_klass(); instanceKlassHandle klass (THREAD, k); // Ensure it is initialized klass->initialize(CHECK_NH); @@ -2187,19 +2209,30 @@ } -oop sun_reflect_ConstantPool::cp_oop(oop reflect) { +void sun_reflect_ConstantPool::set_cp(oop reflect, ConstantPool* value) { assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); - return reflect->obj_field(_cp_oop_offset); + oop mirror = value->pool_holder()->java_mirror(); + // Save the mirror to get back the constant pool. + reflect->obj_field_put(_oop_offset, mirror); } - -void sun_reflect_ConstantPool::set_cp_oop(oop reflect, oop value) { +ConstantPool* sun_reflect_ConstantPool::get_cp(oop reflect) { assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem"); - reflect->obj_field_put(_cp_oop_offset, value); + + oop mirror = reflect->obj_field(_oop_offset); + Klass* k = java_lang_Class::as_Klass(mirror); + assert(k->oop_is_instance(), "Must be"); + + // Get the constant pool back from the klass. Since class redefinition + // merges the new constant pool into the old, this is essentially the + // same constant pool as the original. If constant pool merging is + // no longer done in the future, this will have to change to save + // the original. + return InstanceKlass::cast(k)->constants(); } void sun_reflect_UnsafeStaticFieldAccessorImpl::compute_offsets() { - klassOop k = SystemDictionary::reflect_UnsafeStaticFieldAccessorImpl_klass(); + Klass* k = SystemDictionary::reflect_UnsafeStaticFieldAccessorImpl_klass(); // This null test can be removed post beta if (k != NULL) { compute_offset(_base_offset, k, @@ -2208,7 +2241,7 @@ } oop java_lang_boxing_object::initialize_and_allocate(BasicType type, TRAPS) { - klassOop k = SystemDictionary::box_klass(type); + Klass* k = SystemDictionary::box_klass(type); if (k == NULL) return NULL; instanceKlassHandle h (THREAD, k); if (!h->is_initialized()) h->initialize(CHECK_0); @@ -2344,8 +2377,14 @@ // Support for java_lang_ref_Reference +HeapWord *java_lang_ref_Reference::pending_list_lock_addr() { + InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass()); + address addr = ik->static_field_addr(static_lock_offset); + return (HeapWord*) addr; +} + oop java_lang_ref_Reference::pending_list_lock() { - instanceKlass* ik = instanceKlass::cast(SystemDictionary::Reference_klass()); + InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass()); address addr = ik->static_field_addr(static_lock_offset); if (UseCompressedOops) { return oopDesc::load_decode_heap_oop((narrowOop *)addr); @@ -2355,7 +2394,7 @@ } HeapWord *java_lang_ref_Reference::pending_list_addr() { - instanceKlass* ik = instanceKlass::cast(SystemDictionary::Reference_klass()); + InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::Reference_klass()); address addr = ik->static_field_addr(static_pending_offset); // XXX This might not be HeapWord aligned, almost rather be char *. return (HeapWord*)addr; @@ -2378,13 +2417,13 @@ } jlong java_lang_ref_SoftReference::clock() { - instanceKlass* ik = instanceKlass::cast(SystemDictionary::SoftReference_klass()); + InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::SoftReference_klass()); jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset); return *offset; } void java_lang_ref_SoftReference::set_clock(jlong value) { - instanceKlass* ik = instanceKlass::cast(SystemDictionary::SoftReference_klass()); + InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::SoftReference_klass()); jlong* offset = (jlong*)ik->static_field_addr(static_clock_offset); *offset = value; } @@ -2400,12 +2439,13 @@ int java_lang_invoke_MemberName::_type_offset; int java_lang_invoke_MemberName::_flags_offset; int java_lang_invoke_MemberName::_vmtarget_offset; +int java_lang_invoke_MemberName::_vmloader_offset; int java_lang_invoke_MemberName::_vmindex_offset; int java_lang_invoke_LambdaForm::_vmentry_offset; void java_lang_invoke_MethodHandle::compute_offsets() { - klassOop klass_oop = SystemDictionary::MethodHandle_klass(); + Klass* klass_oop = SystemDictionary::MethodHandle_klass(); if (klass_oop != NULL && EnableInvokeDynamic) { compute_offset(_type_offset, klass_oop, vmSymbols::type_name(), vmSymbols::java_lang_invoke_MethodType_signature()); compute_optional_offset(_form_offset, klass_oop, vmSymbols::form_name(), vmSymbols::java_lang_invoke_LambdaForm_signature()); @@ -2416,7 +2456,7 @@ } void java_lang_invoke_MemberName::compute_offsets() { - klassOop klass_oop = SystemDictionary::MemberName_klass(); + Klass* klass_oop = SystemDictionary::MemberName_klass(); if (klass_oop != NULL && EnableInvokeDynamic) { compute_offset(_clazz_offset, klass_oop, vmSymbols::clazz_name(), vmSymbols::class_signature()); compute_offset(_name_offset, klass_oop, vmSymbols::name_name(), vmSymbols::string_signature()); @@ -2427,7 +2467,7 @@ } void java_lang_invoke_LambdaForm::compute_offsets() { - klassOop klass_oop = SystemDictionary::LambdaForm_klass(); + Klass* klass_oop = SystemDictionary::LambdaForm_klass(); if (klass_oop != NULL && EnableInvokeDynamic) { compute_offset(_vmentry_offset, klass_oop, vmSymbols::vmentry_name(), vmSymbols::java_lang_invoke_MemberName_signature()); } @@ -2493,12 +2533,12 @@ mname->int_field_put(_flags_offset, flags); } -oop java_lang_invoke_MemberName::vmtarget(oop mname) { +Metadata* java_lang_invoke_MemberName::vmtarget(oop mname) { assert(is_instance(mname), "wrong type"); - return mname->obj_field(_vmtarget_offset); + return (Metadata*)mname->address_field(_vmtarget_offset); } -void java_lang_invoke_MemberName::set_vmtarget(oop mname, oop ref) { +void java_lang_invoke_MemberName::set_vmtarget(oop mname, Metadata* ref) { assert(is_instance(mname), "wrong type"); #ifdef ASSERT // check the type of the vmtarget @@ -2518,7 +2558,19 @@ } } #endif //ASSERT - mname->obj_field_put(_vmtarget_offset, ref); + mname->address_field_put(_vmtarget_offset, (address)ref); + oop loader = NULL; + if (ref != NULL) { + if (ref->is_klass()) { + loader = ((Klass*)ref)->class_loader(); + } else if (ref->is_method()) { + loader = ((Method*)ref)->method_holder()->class_loader(); + } else { + ShouldNotReachHere(); + } + } + // Add a reference to the loader to ensure the metadata is kept alive + mname->obj_field_put(_vmloader_offset, loader); } intptr_t java_lang_invoke_MemberName::vmindex(oop mname) { @@ -2543,7 +2595,7 @@ int java_lang_invoke_MethodType::_ptypes_offset; void java_lang_invoke_MethodType::compute_offsets() { - klassOop k = SystemDictionary::MethodType_klass(); + Klass* k = SystemDictionary::MethodType_klass(); if (k != NULL) { compute_offset(_rtype_offset, k, vmSymbols::rtype_name(), vmSymbols::class_signature()); compute_offset(_ptypes_offset, k, vmSymbols::ptypes_name(), vmSymbols::class_array_signature()); @@ -2630,7 +2682,7 @@ void java_lang_invoke_CallSite::compute_offsets() { if (!EnableInvokeDynamic) return; - klassOop k = SystemDictionary::CallSite_klass(); + Klass* k = SystemDictionary::CallSite_klass(); if (k != NULL) { compute_offset(_target_offset, k, vmSymbols::target_name(), vmSymbols::java_lang_invoke_MethodHandle_signature()); } @@ -2646,7 +2698,7 @@ void java_security_AccessControlContext::compute_offsets() { assert(_isPrivileged_offset == 0, "offsets should be initialized only once"); fieldDescriptor fd; - instanceKlass* ik = instanceKlass::cast(SystemDictionary::AccessControlContext_klass()); + InstanceKlass* ik = InstanceKlass::cast(SystemDictionary::AccessControlContext_klass()); if (!ik->find_local_field(vmSymbols::context_name(), vmSymbols::protectiondomain_signature(), &fd)) { fatal("Invalid layout of java.security.AccessControlContext"); @@ -2668,9 +2720,9 @@ oop java_security_AccessControlContext::create(objArrayHandle context, bool isPrivileged, Handle privileged_context, TRAPS) { assert(_isPrivileged_offset != 0, "offsets should have been initialized"); // Ensure klass is initialized - instanceKlass::cast(SystemDictionary::AccessControlContext_klass())->initialize(CHECK_0); + InstanceKlass::cast(SystemDictionary::AccessControlContext_klass())->initialize(CHECK_0); // Allocate result - oop result = instanceKlass::cast(SystemDictionary::AccessControlContext_klass())->allocate_instance(CHECK_0); + oop result = InstanceKlass::cast(SystemDictionary::AccessControlContext_klass())->allocate_instance(CHECK_0); // Fill in values result->obj_field_put(_context_offset, context()); result->obj_field_put(_privilegedContext_offset, privileged_context()); @@ -2680,17 +2732,43 @@ // Support for java_lang_ClassLoader + bool java_lang_ClassLoader::offsets_computed = false; +int java_lang_ClassLoader::_loader_data_offset = -1; +int java_lang_ClassLoader::_dependencies_offset = -1; int java_lang_ClassLoader::parallelCapable_offset = -1; +ClassLoaderData** java_lang_ClassLoader::loader_data_addr(oop loader) { + assert(loader != NULL && loader->is_oop(), "loader must be oop"); + return (ClassLoaderData**) loader->address_field_addr(_loader_data_offset); +} + +ClassLoaderData* java_lang_ClassLoader::loader_data(oop loader) { + return *java_lang_ClassLoader::loader_data_addr(loader); +} + +oop java_lang_ClassLoader::dependencies(oop loader) { + return loader->obj_field(_dependencies_offset); +} + +HeapWord* java_lang_ClassLoader::dependencies_addr(oop loader) { + if (UseCompressedOops) { + return (HeapWord*)loader->obj_field_addr<narrowOop>(_dependencies_offset); + } else { + return (HeapWord*)loader->obj_field_addr<oop>(_dependencies_offset); + } +} + void java_lang_ClassLoader::compute_offsets() { assert(!offsets_computed, "offsets should be initialized only once"); offsets_computed = true; // The field indicating parallelCapable (parallelLockMap) is only present starting in 7, - klassOop k1 = SystemDictionary::ClassLoader_klass(); + Klass* k1 = SystemDictionary::ClassLoader_klass(); compute_optional_offset(parallelCapable_offset, k1, vmSymbols::parallelCapable_name(), vmSymbols::concurrenthashmap_signature()); + + CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET); } oop java_lang_ClassLoader::parent(oop loader) { @@ -2745,7 +2823,7 @@ // the generated bytecodes for reflection, and if so, "magically" // delegate to its parent to prevent class loading from occurring // in places where applications using reflection didn't expect it. - klassOop delegating_cl_class = SystemDictionary::reflect_DelegatingClassLoader_klass(); + Klass* delegating_cl_class = SystemDictionary::reflect_DelegatingClassLoader_klass(); // This might be null in non-1.4 JDKs if (delegating_cl_class != NULL && loader->is_a(delegating_cl_class)) { return parent(loader); @@ -2777,6 +2855,7 @@ int java_lang_Class::_resolved_constructor_offset; int java_lang_Class::_oop_size_offset; int java_lang_Class::_static_oop_field_count_offset; +GrowableArray<Klass*>* java_lang_Class::_fixup_mirror_list = NULL; int java_lang_Throwable::backtrace_offset; int java_lang_Throwable::detailMessage_offset; int java_lang_Throwable::cause_offset; @@ -2835,7 +2914,7 @@ int java_lang_AssertionStatusDirectives::deflt_offset; int java_nio_Buffer::_limit_offset; int java_util_concurrent_locks_AbstractOwnableSynchronizer::_owner_offset = 0; -int sun_reflect_ConstantPool::_cp_oop_offset; +int sun_reflect_ConstantPool::_oop_offset; int sun_reflect_UnsafeStaticFieldAccessorImpl::_base_offset; @@ -2888,7 +2967,7 @@ void java_nio_Buffer::compute_offsets() { - klassOop k = SystemDictionary::nio_Buffer_klass(); + Klass* k = SystemDictionary::nio_Buffer_klass(); assert(k != NULL, "must be loaded in 1.4+"); compute_offset(_limit_offset, k, vmSymbols::limit_name(), vmSymbols::int_signature()); } @@ -2898,7 +2977,7 @@ assert(JDK_Version::is_gte_jdk16x_version(), "Must be JDK 1.6 or later"); SystemDictionary::load_abstract_ownable_synchronizer_klass(CHECK); - klassOop k = SystemDictionary::abstract_ownable_synchronizer_klass(); + Klass* k = SystemDictionary::abstract_ownable_synchronizer_klass(); compute_offset(_owner_offset, k, vmSymbols::exclusive_owner_thread_name(), vmSymbols::thread_signature()); } @@ -3007,7 +3086,7 @@ EXCEPTION_MARK; fieldDescriptor fd; TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH); - klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); + Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); instanceKlassHandle h_klass (THREAD, k); TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH); TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH); @@ -3033,7 +3112,7 @@ EXCEPTION_MARK; fieldDescriptor fd; TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH); - klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); + Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); instanceKlassHandle h_klass (THREAD, k); TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH); TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH); @@ -3058,7 +3137,7 @@ EXCEPTION_MARK; fieldDescriptor fd; TempNewSymbol klass_sym = SymbolTable::new_symbol(klass_name, CATCH); - klassOop k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); + Klass* k = SystemDictionary::resolve_or_fail(klass_sym, true, CATCH); instanceKlassHandle h_klass (THREAD, k); TempNewSymbol f_name = SymbolTable::new_symbol(field_name, CATCH); TempNewSymbol f_sig = SymbolTable::new_symbol(field_sig, CATCH); @@ -3088,6 +3167,7 @@ void JavaClasses::check_offsets() { bool valid = true; + HandleMark hm; #define CHECK_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \ valid &= check_offset(klass_name, cpp_klass_name :: field_name ## _offset, #field_name, field_sig) @@ -3192,8 +3272,8 @@ #endif // PRODUCT int InjectedField::compute_offset() { - klassOop klass_oop = klass(); - for (AllFieldStream fs(instanceKlass::cast(klass_oop)); !fs.done(); fs.next()) { + Klass* klass_oop = klass(); + for (AllFieldStream fs(InstanceKlass::cast(klass_oop)); !fs.done(); fs.next()) { if (!may_be_java && !fs.access_flags().is_internal()) { // Only look at injected fields continue; @@ -3203,11 +3283,11 @@ } } ResourceMark rm; - tty->print_cr("Invalid layout of %s at %s/%s%s", instanceKlass::cast(klass_oop)->external_name(), name()->as_C_string(), signature()->as_C_string(), may_be_java ? " (may_be_java)" : ""); + tty->print_cr("Invalid layout of %s at %s/%s%s", InstanceKlass::cast(klass_oop)->external_name(), name()->as_C_string(), signature()->as_C_string(), may_be_java ? " (may_be_java)" : ""); #ifndef PRODUCT klass_oop->print(); tty->print_cr("all fields:"); - for (AllFieldStream fs(instanceKlass::cast(klass_oop)); !fs.done(); fs.next()) { + for (AllFieldStream fs(InstanceKlass::cast(klass_oop)); !fs.done(); fs.next()) { tty->print_cr(" name: %s, sig: %s, flags: %08x", fs.name()->as_C_string(), fs.signature()->as_C_string(), fs.access_flags().as_int()); } #endif //PRODUCT