truffle: src/share/vm/oops/instanceKlass.cpp comparison

comparison src/share/vm/oops/instanceKlass.cpp @ 10408:836a62f43af9

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 19 Jun 2013 10:45:56 +0200
parents	89e4d67fdd2a 6c138b9851fb
children	6b0fd0964b87

comparison

equal deleted inserted replaced

-:e0fb8a213650
+:836a62f43af9
 #include "runtime/fieldDescriptor.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/javaCalls.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "runtime/thread.inline.hpp"
+#include "services/classLoadingService.hpp"
 #include "services/threadService.hpp"
 #include "utilities/dtrace.hpp"
 #include "utilities/macros.hpp"
 #if INCLUDE_ALL_GCS
 #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp"
 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);
 }
-volatile oop InstanceKlass::init_lock() const {
-volatile oop lock = _init_lock;  // read once
-assert((oop)lock != NULL || !is_not_initialized(), // initialized or in_error state
-"only fully initialized state can have a null lock");
-return lock;
-}
-// Set the initialization lock to null so the object can be GC'ed.  Any racing
-// threads to get this lock will see a null lock and will not lock.
-// That's okay because they all check for initialized state after getting
-// the lock and return.
-void InstanceKlass::fence_and_clear_init_lock() {
-// make sure previous stores are all done, notably the init_state.
-OrderAccess::storestore();
-klass_oop_store(&_init_lock, NULL);
-assert(!is_not_initialized(), "class must be initialized now");
-}
 bool InstanceKlass::should_be_initialized() const {
 return !is_initialized();
 }
 klassVtable* InstanceKlass::vtable() const {
 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, init_lock != NULL);
+ObjectLocker ol(init_lock, THREAD);
 // abort if someone beat us to the initialization
 if (!this_oop->is_not_initialized()) return;  // note: not equivalent to is_initialized()
 ClassState old_state = this_oop->init_state();
 if( old_state != this_oop->_init_state )
 this_oop->set_init_state (old_state);
 } else {
 // linking successfull, mark class as initialized
 this_oop->set_init_state (fully_initialized);
-this_oop->fence_and_clear_init_lock();
 // trace
 if (TraceClassInitialization) {
 ResourceMark rm(THREAD);
 tty->print_cr("[Initialized %s without side effects]", this_oop->external_name());
 }
 PerfClassTraceTime::CLASS_LINK);
 // verification & rewriting
 {
 volatile oop init_lock = this_oop->init_lock();
-ObjectLocker ol(init_lock, THREAD, init_lock != NULL);
+ObjectLocker ol(init_lock, THREAD);
 // rewritten will have been set if loader constraint error found
 // on an earlier link attempt
 // don't verify or rewrite if already rewritten
 if (!this_oop->is_linked()) {
 // refer to the JVM book page 47 for description of steps
 // Step 1
 {
 volatile oop init_lock = this_oop->init_lock();
-ObjectLocker ol(init_lock, THREAD, init_lock != NULL);
+ObjectLocker ol(init_lock, THREAD);
 Thread *self = THREAD; // it's passed the current thread
 // Step 2
 // If we were to use wait() instead of waitInterruptibly() then
 set_initialization_state_and_notify_impl(kh, state, CHECK);
 }
 void InstanceKlass::set_initialization_state_and_notify_impl(instanceKlassHandle this_oop, ClassState state, TRAPS) {
 volatile oop init_lock = this_oop->init_lock();
-ObjectLocker ol(init_lock, THREAD, init_lock != NULL);
+ObjectLocker ol(init_lock, THREAD);
 this_oop->set_init_state(state);
-this_oop->fence_and_clear_init_lock();
 ol.notify_all(CHECK);
 }
 // The embedded _implementor field can only record one implementor.
 // When there are more than one implementors, the _implementor field
 #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) {
 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);
 }
 static void clear_all_breakpoints(Method* m) {
 m->clear_all_breakpoints();
 }
+void InstanceKlass::notify_unload_class(InstanceKlass* ik) {
+// notify the debugger
+if (JvmtiExport::should_post_class_unload()) {
+JvmtiExport::post_class_unload(ik);
+}
+// notify ClassLoadingService of class unload
+ClassLoadingService::notify_class_unloaded(ik);
+}
+void InstanceKlass::release_C_heap_structures(InstanceKlass* ik) {
+// Clean up C heap
+ik->release_C_heap_structures();
+ik->constants()->release_C_heap_structures();
+}
 void InstanceKlass::release_C_heap_structures() {
+// Can't release the constant pool here because the constant pool can be
+// deallocated separately from the InstanceKlass for default methods and
+// redefine classes.
 // Deallocate oop map cache
 if (_oop_map_cache != NULL) {
 delete _oop_map_cache;
 _oop_map_cache = NULL;
 }
 jmethodID* jmeths = methods_jmethod_ids_acquire();
 if (jmeths != (jmethodID*)NULL) {
 release_set_methods_jmethod_ids(NULL);
 FreeHeap(jmeths);
+}
+// Deallocate MemberNameTable
+{
+Mutex* lock_or_null = SafepointSynchronize::is_at_safepoint() ? NULL : MemberNameTable_lock;
+MutexLockerEx ml(lock_or_null, Mutex::_no_safepoint_check_flag);
+MemberNameTable* mnt = member_names();
+if (mnt != NULL) {
+delete mnt;
+set_member_names(NULL);
+}
 }
 int* indices = methods_cached_itable_indices_acquire();
 if (indices != (int*)NULL) {
 release_set_methods_cached_itable_indices(NULL);
 }
 // Remember to unlock again
 OsrList_lock->unlock();
 }
-nmethod* InstanceKlass::lookup_osr_nmethod(Method* const m, int bci, int comp_level, bool match_level) const {
+nmethod* InstanceKlass::lookup_osr_nmethod(const Method* m, int bci, int comp_level, bool match_level) const {
 // This is a short non-blocking critical region, so the no safepoint check is ok.
 OsrList_lock->lock_without_safepoint_check();
 nmethod* osr = osr_nmethods_head();
 nmethod* best = NULL;
 while (osr != NULL) {
 return best;
 }
 return NULL;
 }
+void InstanceKlass::add_member_name(int index, Handle mem_name) {
+jweak mem_name_wref = JNIHandles::make_weak_global(mem_name);
+MutexLocker ml(MemberNameTable_lock);
+assert(0 <= index && index < idnum_allocated_count(), "index is out of bounds");
+DEBUG_ONLY(No_Safepoint_Verifier nsv);
+if (_member_names == NULL) {
+_member_names = new (ResourceObj::C_HEAP, mtClass) MemberNameTable(idnum_allocated_count());
+}
+_member_names->add_member_name(index, mem_name_wref);
+}
+oop InstanceKlass::get_member_name(int index) {
+MutexLocker ml(MemberNameTable_lock);
+assert(0 <= index && index < idnum_allocated_count(), "index is out of bounds");
+DEBUG_ONLY(No_Safepoint_Verifier nsv);
+if (_member_names == NULL) {
+return NULL;
+}
+oop mem_name =_member_names->get_member_name(index);
+return mem_name;
+}
 // -----------------------------------------------------------------------------------------------------
 // Printing
 #ifndef PRODUCT
 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) {
+const Klass* host = host_klass();
-guarantee(protection_domain()->is_oop(), "should be oop");
+if (host != NULL) {
-}
+guarantee(host->is_metadata(), "should be in metaspace");
-if (host_klass() != NULL) {
+guarantee(host->is_klass(), "should be klass");
-guarantee(host_klass()->is_metadata(), "should be in metaspace");
-guarantee(host_klass()->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);

Mercurial > hg > truffle

comparison src/share/vm/oops/instanceKlass.cpp @ 10408:836a62f43af9