truffle: src/share/vm/classfile/javaClasses.cpp comparison

comparison src/share/vm/classfile/javaClasses.cpp @ 6948:e522a00b91aa

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works

author	Doug Simon <doug.simon@oracle.com>
date	Mon, 12 Nov 2012 23:14:12 +0100
parents	18fb7da42534
children	2cb439954abf

comparison

equal deleted inserted replaced

-:ae13cc658b80
+:e522a00b91aa
 #include "memory/universe.inline.hpp"
 #include "oops/fieldStreams.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/instanceMirrorKlass.hpp"
 #include "oops/klass.hpp"
-#include "oops/klassOop.hpp"
+#include "oops/method.hpp"
-#include "oops/methodOop.hpp"
 #include "oops/symbol.hpp"
 #include "oops/typeArrayOop.hpp"
 #include "runtime/fieldDescriptor.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/interfaceSupport.hpp"
 }
 return NULL;
 }
-static bool find_field(instanceKlass* ik,
+static bool find_field(InstanceKlass* ik,
 Symbol* name_symbol, Symbol* signature_symbol,
 fieldDescriptor* fd,
 bool allow_super = false) {
 if (allow_super)
 return ik->find_field(name_symbol, signature_symbol, fd) != NULL;
 }
 // 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
 fatal("Invalid layout of preloaded class");
 }
 }
 // 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();
 }
 }
 bool java_lang_String::initialized  = false;
 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());
 compute_optional_offset(hash_offset,   k, vmSymbols::hash_name(),   vmSymbols::int_signature());
 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_instance(CHECK_NH);
-obj = instanceKlass::cast(SystemDictionary::String_klass())->allocate_permanent_instance(CHECK_NH);
-} else {
-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();
 set_value(obj, buffer);
 // No need to zero the offset, allocation zero'ed the entire String object
 set_count(obj, length);
 return h_obj;
 }
-Handle java_lang_String::basic_create_from_unicode(jchar* unicode, int length, bool tenured, TRAPS) {
+Handle java_lang_String::create_from_unicode(jchar* unicode, int length, TRAPS) {
-Handle h_obj = basic_create(length, tenured, CHECK_NH);
+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]);
 }
 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();
 }
 Handle java_lang_String::create_from_str(const char* utf8_str, TRAPS) {
 if (utf8_str == NULL) {
 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);
 }
 return h_obj;
 }
 return h_obj();
 }
 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);
 }
 return h_obj;
 }
 }
 // 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());
 // Copy contents
 jchar* position = value->char_at_addr(offset + start);
 return UNICODE::as_utf8(position, len);
 }
 bool java_lang_String::equals(oop java_string, jchar* chars, int len) {
-assert(SharedSkipVerify ||
+assert(java_string->klass() == SystemDictionary::String_klass(),
-java_string->klass() == SystemDictionary::String_klass(),
 "must be java_string");
 typeArrayOop value  = java_lang_String::value(java_string);
 int          offset = java_lang_String::offset(java_string);
 int          length = java_lang_String::length(java_string);
 if (length != len) {
 }
 }
 void java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) {
-assert(instanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already");
+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();
+int real_offset = fs.offset() + InstanceMirrorKlass::offset_of_static_fields();
 fs.set_offset(real_offset);
 }
 }
+}
 }
 create_mirror(k, CHECK);
 }
 oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) {
 // to support Class.getModifiers().  Instance classes recalculate
 // the cached flags after the class file is parsed, but before the
 // 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);
+Handle mirror = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK_0);
-instanceMirrorKlass* mk = instanceMirrorKlass::cast(mirror->klass());
+InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass());
 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 {
-} else if (k->oop_is_objArray()) {
+assert(k->oop_is_objArray(), "Must be");
-klassOop element_klass = objArrayKlass::cast(k->as_klassOop())->element_klass();
+Klass* element_klass = ObjArrayKlass::cast(k())->element_klass();
-if (element_klass != NULL
+assert(element_klass != NULL, "Must have an element klass");
-&& (Klass::cast(element_klass)->oop_is_instance() ||
-Klass::cast(element_klass)->oop_is_javaArray())) {
 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());
+ArrayKlass::cast(k())->set_component_mirror(comp_mirror());
-set_array_klass(comp_mirror(), k->as_klassOop());
+set_array_klass(comp_mirror(), k());
-}
+} else {
-} else if (k->oop_is_instance()) {
+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;
 }
 }
 }
 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);
 }
 #ifdef ASSERT
-instanceMirrorKlass* mk = instanceMirrorKlass::cast(SystemDictionary::Class_klass());
+InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(SystemDictionary::Class_klass());
 assert(java_lang_Class::static_oop_field_count(java_class) == 0, "should have been zeroed by allocation");
 #endif
 return java_class;
 }
+#ifdef GRAAL
-klassOop java_lang_Class::as_klassOop(oop java_class) {
+oop java_lang_Class::graal_mirror(oop java_class) {
+assert(_graal_mirror_offset != 0, "must be set");
+return java_class->obj_field(_graal_mirror_offset);
+}
+#endif
+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);
 }
 void java_lang_Class::print_signature(oop java_class, outputStream* st) {
 assert(java_lang_Class::is_instance(java_class), "must be a Class object");
 Symbol* name = NULL;
 bool is_instance = false;
 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();
 }
 if (name == NULL) {
 st->print("<null>");
 // Because this can create a new symbol, the caller has to decrement
 // the refcount, so make adjustment here and below for symbols returned
 // 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();
 } else {
 ResourceMark rm;
 }
 return name;
 }
-klassOop java_lang_Class::array_klass(oop java_class) {
+Klass* java_lang_Class::array_klass(oop java_class) {
-klassOop k = klassOop(java_class->obj_field(_array_klass_offset));
+Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset));
-assert(k == NULL || k->is_klass() && Klass::cast(k)->oop_is_javaArray(), "should be array klass");
+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) {
+void java_lang_Class::set_array_klass(oop java_class, Klass* klass) {
-assert(klass->is_klass() && Klass::cast(klass)->oop_is_javaArray(), "should be array klass");
+assert(klass->is_klass() && Klass::cast(klass)->oop_is_array(), "should be array klass");
-java_class->obj_field_put(_array_klass_offset, klass);
+java_class->metadata_field_put(_array_klass_offset, klass);
 }
-methodOop java_lang_Class::resolved_constructor(oop java_class) {
+Method* java_lang_Class::resolved_constructor(oop java_class) {
-oop constructor = java_class->obj_field(_resolved_constructor_offset);
+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));
+bool is_primitive = (java_class->metadata_field(_klass_offset) == NULL);
-return k == 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.
-type = arrayKlass::cast(ak)->element_type();
+type = ArrayKlass::cast(ak)->element_type();
 } else {
 assert(java_class == Universe::void_mirror(), "only valid non-array primitive");
 }
 assert(Universe::java_mirror(type) == java_class, "must be consistent");
 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)
 (*reference_klass) = NULL;
 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;
 }
 }
 void java_lang_Class::compute_offsets() {
 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,
 klass_oop, vmSymbols::classRedefinedCount_name(), vmSymbols::int_signature());
 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());
 compute_offset(_inheritedAccessControlContext_offset, k, vmSymbols::inheritedAccessControlContext_name(), vmSymbols::accesscontrolcontext_signature());
 compute_offset(_priority_offset,  k, vmSymbols::priority_name(),  vmSymbols::int_signature());
 }
 typeArrayOop java_lang_Thread::name(oop java_thread) {
 oop name = java_thread->obj_field(_name_offset);
-assert(name == NULL || (name->is_typeArray() && typeArrayKlass::cast(name->klass())->element_type() == T_CHAR), "just checking");
+assert(name == NULL || (name->is_typeArray() && TypeArrayKlass::cast(name->klass())->element_type() == T_CHAR), "just checking");
 return typeArrayOop(name);
 }
 void java_lang_Thread::set_name(oop java_thread, typeArrayOop name) {
 }
 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());
 compute_offset(_threads_offset,     k, vmSymbols::threads_name(),     vmSymbols::thread_array_signature());
 compute_offset(_groups_offset,      k, vmSymbols::groups_name(),      vmSymbols::threadgroup_array_signature());
 compute_offset(_nthreads_offset,    k, vmSymbols::nthreads_name(),    vmSymbols::int_signature());
 compute_offset(_ngroups_offset,     k, vmSymbols::ngroups_name(),     vmSymbols::int_signature());
 }
 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);
 } else {
 return oopDesc::load_decode_heap_oop((oop*)addr);
 }
 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));
 }
 }
 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));
 }
 }
 // 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 = method->method_holder();
 const char* klass_name  = klass->external_name();
 int buf_len = (int)strlen(klass_name);
 char* source_file_name;
 if (klass->source_file_name() == NULL) {
 source_file_name = NULL;
 return buf;
 }
-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);
 }
 st->print_cr(no_stack_trace_message());
 return;
 }
 while (result.not_null()) {
-objArrayHandle methods (THREAD,
+typeArrayHandle methods (THREAD,
-objArrayOop(result->obj_at(trace_methods_offset)));
+typeArrayOop(result->obj_at(trace_methods_offset)));
 typeArrayHandle bcis (THREAD,
 typeArrayOop(result->obj_at(trace_bcis_offset)));
 if (methods.is_null() || bcis.is_null()) {
 st->print_cr(no_stack_trace_message());
 return;
 }
 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);
 }
 result = objArrayHandle(THREAD, objArrayOop(result->obj_at(trace_next_offset)));
 print_to_stream(stream, no_stack_trace_message());
 return;
 }
 while (result.not_null()) {
-objArrayHandle methods (thread,
+typeArrayHandle methods(thread,
-objArrayOop(result->obj_at(trace_methods_offset)));
+typeArrayOop(result->obj_at(trace_methods_offset)));
 typeArrayHandle bcis (thread,
 typeArrayOop(result->obj_at(trace_bcis_offset)));
 if (methods.is_null() || bcis.is_null()) {
 print_to_stream(stream, no_stack_trace_message());
 return;
 }
 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);
 }
 result = objArrayHandle(thread, objArrayOop(result->obj_at(trace_next_offset)));
 // to know what it looks like.
 class BacktraceBuilder: public StackObj {
 private:
 Handle          _backtrace;
 objArrayOop     _head;
-objArrayOop     _methods;
+typeArrayOop    _methods;
 typeArrayOop    _bcis;
+objArrayOop     _mirrors;
 int             _index;
 No_Safepoint_Verifier _nsv;
 public:
 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;
 }
 Pause_No_Safepoint_Verifier pnsv(&_nsv);
 objArrayOop head = oopFactory::new_objectArray(trace_size, CHECK);
 objArrayHandle new_head(THREAD, head);
-objArrayOop methods = oopFactory::new_objectArray(trace_chunk_size, CHECK);
+typeArrayOop methods = oopFactory::new_metaDataArray(trace_chunk_size, CHECK);
-objArrayHandle new_methods(THREAD, methods);
+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;
 }
 oop backtrace() {
 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.
 if (bci == SynchronizationEntryBCI) bci = 0;
 assert(bci == (jushort)bci, "doesn't fit");
 methodHandle mhandle(THREAD, method);
 expand(CHECK);
 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() {
 assert(_index >= 0 && _index < trace_chunk_size, "out of range");
 return _bcis->ushort_at(_index);
 bool skip_fillInStackTrace_check = false;
 bool skip_throwableInit_check = false;
 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;
 address pc = fr.pc();
 if (fr.is_interpreted_frame()) {
 #ifdef ASSERT
 assert(st_method() == method && st.bci() == bci,
 "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();
 }
 #endif
 // No-op if stack trace is disabled
 if (!StackTraceInThrowable) return;
 objArrayOop h_oop = oopFactory::new_objectArray(trace_size, CHECK);
 objArrayHandle backtrace  (THREAD, h_oop);
-objArrayOop m_oop = oopFactory::new_objectArray(trace_chunk_size, CHECK);
+typeArrayOop m_oop = oopFactory::new_metaDataArray(trace_chunk_size, CHECK);
-objArrayHandle methods (THREAD, m_oop);
+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());
 }
 void java_lang_Throwable::fill_in_stack_trace_of_preallocated_backtrace(Handle throwable) {
 // No-op if stack trace is disabled
 if (!StackTraceInThrowable) return;
 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);
+oop m = backtrace->obj_at(trace_methods_offset);
-objArrayOop methods = objArrayOop(m);
+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);
 vframeStream st(thread);
 // the -1 to a 0 even if it could be recorded.
 int bci = st.bci();
 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++;
 // Bail-out for deep stacks
 if (chunk_count >= max_chunks) break;
 depth += trace_chunk_size;
 chunk = next;
 }
 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++;
 }
 }
 return depth;
 }
 }
 if (chunk == NULL) {
 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()) {
 THROW_(vmSymbols::java_lang_IndexOutOfBoundsException(), NULL);
 }
 oop java_lang_StackTraceElement::create(methodHandle method, int bci, TRAPS) {
 // SystemDictionary::stackTraceElement_klass() will be null for pre-1.4 JDKs
 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()) {
 ik->initialize(CHECK_0);
 }
 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 = 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 = method->method_holder()->source_file_name();
 if (ShowHiddenFrames && source == NULL)
 source = vmSymbols::unknown_class_name();
 oop filename = StringTable::intern(source, CHECK_0);
 java_lang_StackTraceElement::set_fileName(element(), filename);
 // File in source line number
 return element();
 }
 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());
 }
 jboolean java_lang_reflect_AccessibleObject::override(oop reflect) {
 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
 reflect->bool_field_put(override_offset, (int) value);
 }
 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());
 compute_offset(parameterTypes_offset, k, vmSymbols::parameterTypes_name(), vmSymbols::class_array_signature());
 compute_offset(exceptionTypes_offset, k, vmSymbols::exceptionTypes_name(), vmSymbols::class_array_signature());
 compute_optional_offset(annotation_default_offset,    k, vmSymbols::annotation_default_name(),    vmSymbols::byte_array_signature());
 }
 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");
+assert(InstanceKlass::cast(klass)->is_initialized(), "must be initialized");
-return instanceKlass::cast(klass)->allocate_instance_handle(CHECK_NH);
+return InstanceKlass::cast(klass)->allocate_instance_handle(CHECK_NH);
 }
 oop java_lang_reflect_Method::clazz(oop reflect) {
 assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
 return reflect->obj_field(clazz_offset);
 assert(has_annotation_default_field(), "annotation default field must be present");
 method->obj_field_put(annotation_default_offset, value);
 }
 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());
 compute_offset(slot_offset,           k, vmSymbols::slot_name(),           vmSymbols::int_signature());
 compute_offset(modifiers_offset,      k, vmSymbols::modifiers_name(),      vmSymbols::int_signature());
 }
 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);
 return klass->allocate_instance_handle(CHECK_NH);
 }
 assert(has_parameter_annotations_field(), "parameter annotations field must be present");
 method->obj_field_put(parameter_annotations_offset, value);
 }
 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());
 compute_offset(slot_offset,      k, vmSymbols::slot_name(),      vmSymbols::int_signature());
 compute_offset(modifiers_offset, k, vmSymbols::modifiers_name(), vmSymbols::int_signature());
 }
 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);
 return klass->allocate_instance_handle(CHECK_NH);
 }
 field->obj_field_put(annotations_offset, value);
 }
 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);
 return klass->allocate_instance_handle(CHECK_NH);
 }
-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) {
-assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
+ConstantPool* sun_reflect_ConstantPool::get_cp(oop reflect) {
-reflect->obj_field_put(_cp_oop_offset, value);
+assert(Universe::is_fully_initialized(), "Need to find another solution to the reflection problem");
+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,
 vmSymbols::base_name(), vmSymbols::object_signature());
 }
 }
 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);
 return h->allocate_instance(THREAD);
 }
 }
 }
 // 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);
 } else {
 return oopDesc::load_decode_heap_oop((oop*)addr);
 }
 }
 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;
 }
 jlong java_lang_ref_SoftReference::timestamp(oop ref) {
 return ref->long_field(timestamp_offset);
 }
 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;
 }
 int java_lang_invoke_MemberName::_clazz_offset;
 int java_lang_invoke_MemberName::_name_offset;
 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());
 if (_form_offset == 0) {
 EnableInvokeDynamic = false;
 }
 }
 }
 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());
 compute_offset(_type_offset,      klass_oop, vmSymbols::type_name(),      vmSymbols::object_signature());
 compute_offset(_flags_offset,     klass_oop, vmSymbols::flags_name(),     vmSymbols::int_signature());
 MEMBERNAME_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
 }
 }
 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());
 }
 }
 void java_lang_invoke_MemberName::set_flags(oop mname, int flags) {
 assert(is_instance(mname), "wrong type");
 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
 if (ref != NULL) {
 switch (flags(mname) & (MN_IS_METHOD |
 default:
 ShouldNotReachHere();
 }
 }
 #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) {
 assert(is_instance(mname), "wrong type");
 return (intptr_t) mname->address_field(_vmindex_offset);
 int java_lang_invoke_MethodType::_rtype_offset;
 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());
 }
 }
 int java_lang_invoke_CallSite::_target_offset;
 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());
 }
 }
 int java_security_AccessControlContext::_isPrivileged_offset = 0;
 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");
 }
 _context_offset = fd.offset();
 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());
 result->bool_field_put(_isPrivileged_offset, isPrivileged);
 return result;
 }
 // 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) {
 assert(is_instance(loader), "loader must be oop");
 return loader->obj_field(parent_offset);
 if (loader != NULL) {
 // See whether this is one of the class loaders associated with
 // 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);
 }
 }
 }
 // Support for java_lang_System
 int java_lang_System::in_offset_in_bytes() {
-return (instanceMirrorKlass::offset_of_static_fields() + static_in_offset);
+return (InstanceMirrorKlass::offset_of_static_fields() + static_in_offset);
 }
 int java_lang_System::out_offset_in_bytes() {
-return (instanceMirrorKlass::offset_of_static_fields() + static_out_offset);
+return (InstanceMirrorKlass::offset_of_static_fields() + static_out_offset);
 }
 int java_lang_System::err_offset_in_bytes() {
-return (instanceMirrorKlass::offset_of_static_fields() + static_err_offset);
+return (InstanceMirrorKlass::offset_of_static_fields() + static_err_offset);
 }
 int java_lang_Class::_klass_offset;
 int java_lang_Class::_array_klass_offset;
 int java_lang_Class::_resolved_constructor_offset;
 int java_lang_Class::_oop_size_offset;
 int java_lang_Class::_static_oop_field_count_offset;
+#ifdef GRAAL
+int java_lang_Class::_graal_mirror_offset;
+#endif
+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;
 int java_lang_Throwable::stackTrace_offset;
 int java_lang_Throwable::static_unassigned_stacktrace_offset;
 int java_lang_AssertionStatusDirectives::packages_offset;
 int java_lang_AssertionStatusDirectives::packageEnabled_offset;
 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;
 // Support for java_lang_StackTraceElement
 return _limit_offset;
 }
 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());
 }
 void java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(TRAPS) {
 if (_owner_offset != 0) return;
 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());
 }
 oop java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(oop obj) {
 bool JavaClasses::check_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) {
 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);
 if (!h_klass->find_local_field(f_name, f_sig, &fd)) {
 tty->print_cr("Nonstatic field %s.%s not found", klass_name, field_name);
 bool JavaClasses::check_static_offset(const char *klass_name, int hardcoded_offset, const char *field_name, const char* field_sig) {
 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);
 if (!h_klass->find_local_field(f_name, f_sig, &fd)) {
 tty->print_cr("Static field %s.%s not found", klass_name, field_name);
 }
 if (!fd.is_static()) {
 tty->print_cr("Static field %s.%s appears to be nonstatic", klass_name, field_name);
 return false;
 }
-if (fd.offset() == hardcoded_offset + instanceMirrorKlass::offset_of_static_fields()) {
+if (fd.offset() == hardcoded_offset + InstanceMirrorKlass::offset_of_static_fields()) {
 return true;
 } else {
-tty->print_cr("Offset of static field %s.%s is hardcoded as %d but should really be %d.", klass_name, field_name, hardcoded_offset, fd.offset() - instanceMirrorKlass::offset_of_static_fields());
+tty->print_cr("Offset of static field %s.%s is hardcoded as %d but should really be %d.", klass_name, field_name, hardcoded_offset, fd.offset() - InstanceMirrorKlass::offset_of_static_fields());
 return false;
 }
 }
 bool JavaClasses::check_constant(const char *klass_name, int hardcoded_constant, const char *field_name, const char* field_sig) {
 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);
 if (!h_klass->find_local_field(f_name, f_sig, &fd)) {
 tty->print_cr("Static field %s.%s not found", klass_name, field_name);
 // Check the hard-coded field offsets of all the classes in this file
 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)
 #define CHECK_LONG_OFFSET(klass_name, cpp_klass_name, field_name, field_sig) \
 }
 #endif // PRODUCT
 int InjectedField::compute_offset() {
-klassOop klass_oop = klass();
+Klass* klass_oop = klass();
-for (AllFieldStream fs(instanceKlass::cast(klass_oop)); !fs.done(); fs.next()) {
+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;
 }
 if (fs.name() == name() && fs.signature() == signature()) {
 return fs.offset();
 }
 }
 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
 fatal("Invalid layout of preloaded class");
 return -1;

Mercurial > hg > truffle

comparison src/share/vm/classfile/javaClasses.cpp @ 6948:e522a00b91aa