jdk-sandbox: comparison hotspot/src/share/vm/oops/instanceKlass.cpp

equal deleted inserted replaced

-:b6fc2755ec91
+:9ad5cd464a75
 set_transitive_interfaces(NULL);
 init_implementor();
 set_fields(NULL, 0);
 set_constants(NULL);
 set_class_loader_data(NULL);
-set_protection_domain(NULL);
-set_signers(NULL);
 set_source_file_name(NULL);
 set_source_debug_extension(NULL, 0);
 set_array_name(NULL);
 set_inner_classes(NULL);
 set_static_oop_field_count(0);
 set_nonstatic_field_size(0);
 set_is_marked_dependent(false);
 set_init_state(InstanceKlass::allocated);
 set_init_thread(NULL);
-set_init_lock(NULL);
 set_reference_type(rt);
 set_oop_map_cache(NULL);
 set_jni_ids(NULL);
 set_osr_nmethods_head(NULL);
 set_breakpoints(NULL);
 if (inner_classes() != Universe::the_empty_short_array()) {
 MetadataFactory::free_array<jushort>(loader_data, inner_classes());
 }
 set_inner_classes(NULL);
-// Null out Java heap objects, although these won't be walked to keep
-// alive once this InstanceKlass is deallocated.
-set_protection_domain(NULL);
-set_signers(NULL);
-set_init_lock(NULL);
 // We should deallocate the Annotations instance
 MetadataFactory::free_metadata(loader_data, annotations());
 set_annotations(NULL);
 }
 instanceKlassHandle this_oop(thread, this);
 eager_initialize_impl(this_oop);
 }
 }
+// JVMTI spec thinks there are signers and protection domain in the
+// instanceKlass.  These accessors pretend these fields are there.
+// The hprof specification also thinks these fields are in InstanceKlass.
+oop InstanceKlass::protection_domain() const {
+// return the protection_domain from the mirror
+return java_lang_Class::protection_domain(java_mirror());
+}
+// To remove these from requires an incompatible change and CCC request.
+objArrayOop InstanceKlass::signers() const {
+// return the signers from the mirror
+return java_lang_Class::signers(java_mirror());
+}
+volatile oop InstanceKlass::init_lock() const {
+// return the init lock from the mirror
+return java_lang_Class::init_lock(java_mirror());
+}
 void InstanceKlass::eager_initialize_impl(instanceKlassHandle this_oop) {
 EXCEPTION_MARK;
 volatile oop init_lock = this_oop->init_lock();
 ObjectLocker ol(init_lock, THREAD);
 #endif //PRODUCT
 // Garbage collection
-void InstanceKlass::oops_do(OopClosure* cl) {
-Klass::oops_do(cl);
-cl->do_oop(adr_protection_domain());
-cl->do_oop(adr_signers());
-cl->do_oop(adr_init_lock());
-// Don't walk the arrays since they are walked from the ClassLoaderData objects.
-}
 #ifdef ASSERT
 template <class T> void assert_is_in(T *p) {
 T heap_oop = oopDesc::load_heap_oop(p);
 if (!oopDesc::is_null(heap_oop)) {
 oop o = oopDesc::decode_heap_oop_not_null(heap_oop);
 for (int i = 0; i < methods()->length(); i++) {
 Method* m = methods()->at(i);
 m->remove_unshareable_info();
 }
-// Need to reinstate when reading back the class.
-set_init_lock(NULL);
 // do array classes also.
 array_klasses_do(remove_unshareable_in_class);
 }
 void restore_unshareable_in_class(Klass* k, TRAPS) {
 // It also redefines the itable too so fix that too.
 ResourceMark rm(THREAD);
 ik->vtable()->initialize_vtable(false, CHECK);
 ik->itable()->initialize_itable(false, CHECK);
 }
-// Allocate a simple java object for a lock.
-// This needs to be a java object because during class initialization
-// it can be held across a java call.
-typeArrayOop r = oopFactory::new_typeArray(T_INT, 0, CHECK);
-Handle h(THREAD, (oop)r);
-ik->set_init_lock(h());
 // restore constant pool resolved references
 ik->constants()->restore_unshareable_info(CHECK);
 ik->array_klasses_do(restore_unshareable_in_class, CHECK);
 if (class_loader_data() != NULL) {
 st->print(BULLET"class loader data:  ");
 class_loader_data()->print_value_on(st);
 st->cr();
 }
-st->print(BULLET"protection domain: "); ((InstanceKlass*)this)->protection_domain()->print_value_on(st); st->cr();
 st->print(BULLET"host class:        "); host_klass()->print_value_on_maybe_null(st); st->cr();
-st->print(BULLET"signers:           "); signers()->print_value_on(st);               st->cr();
-st->print(BULLET"init_lock:         "); ((oop)_init_lock)->print_value_on(st);       st->cr();
 if (source_file_name() != NULL) {
 st->print(BULLET"source file:       ");
 source_file_name()->print_value_on(st);
 st->cr();
 }
 int n = 0;
 n += (sz->_methods_array_bytes         = sz->count_array(methods()));
 n += (sz->_method_ordering_bytes       = sz->count_array(method_ordering()));
 n += (sz->_local_interfaces_bytes      = sz->count_array(local_interfaces()));
 n += (sz->_transitive_interfaces_bytes = sz->count_array(transitive_interfaces()));
-n += (sz->_signers_bytes               = sz->count_array(signers()));
 n += (sz->_fields_bytes                = sz->count_array(fields()));
 n += (sz->_inner_classes_bytes         = sz->count_array(inner_classes()));
 sz->_ro_bytes += n;
 const ConstantPool* cp = constants();
 }
 if (constants() != NULL) {
 guarantee(constants()->is_metadata(), "should be in metaspace");
 guarantee(constants()->is_constantPool(), "should be constant pool");
 }
-if (protection_domain() != NULL) {
-guarantee(protection_domain()->is_oop(), "should be oop");
-}
 const Klass* host = host_klass();
 if (host != NULL) {
 guarantee(host->is_metadata(), "should be in metaspace");
 guarantee(host->is_klass(), "should be klass");
-}
-if (signers() != NULL) {
-guarantee(signers()->is_objArray(), "should be obj array");
 }
 }
 void InstanceKlass::oop_verify_on(oop obj, outputStream* st) {
 Klass::oop_verify_on(obj, st);

changeset 17826	9ad5cd464a75
parent 17370	59a0620561fa
child 17828	17131ab4b3b5