graal-compiler: src/share/vm/oops/instanceKlass.cpp comparison

comparison src/share/vm/oops/instanceKlass.cpp @ 12355:cefad50507d8

Merge with hs25-b53

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Fri, 11 Oct 2013 10:38:03 +0200
parents	6b0fd0964b87 36b97be47bde
children	096c224171c4

comparison

equal deleted inserted replaced

-:ccb4f2af2319
+:cefad50507d8
 if (name != NULL) {                                          \
 data = (char*)name->bytes();                               \
 len = name->utf8_length();                                 \
 }                                                            \
 HS_DTRACE_PROBE4(hotspot, class__initialization__##type,     \
-data, len, (clss)->class_loader(), thread_type);           \
+data, len, SOLARIS_ONLY((void *))(clss)->class_loader(), thread_type);           \
 }
 #define DTRACE_CLASSINIT_PROBE_WAIT(type, clss, thread_type, wait) \
 {                                                              \
 char* data = NULL;                                           \
 if (name != NULL) {                                          \
 data = (char*)name->bytes();                               \
 len = name->utf8_length();                                 \
 }                                                            \
 HS_DTRACE_PROBE5(hotspot, class__initialization__##type,     \
-data, len, (clss)->class_loader(), thread_type, wait);     \
+data, len, SOLARIS_ONLY((void *))(clss)->class_loader(), thread_type, wait);     \
 }
 #else /* USDT2 */
 #define HOTSPOT_CLASS_INITIALIZATION_required HOTSPOT_CLASS_INITIALIZATION_REQUIRED
 #define HOTSPOT_CLASS_INITIALIZATION_recursive HOTSPOT_CLASS_INITIALIZATION_RECURSIVE
 set_transitive_interfaces(NULL);
 init_implementor();
 set_fields(NULL, 0);
 set_constants(NULL);
 set_class_loader_data(NULL);
-set_source_file_name(NULL);
+set_source_file_name_index(0);
 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_oop_map_cache(NULL);
 set_jni_ids(NULL);
 set_osr_nmethods_head(NULL);
 set_breakpoints(NULL);
 init_previous_versions();
-set_generic_signature(NULL);
+set_generic_signature_index(0);
 release_set_methods_jmethod_ids(NULL);
-release_set_methods_cached_itable_indices(NULL);
 set_annotations(NULL);
 set_jvmti_cached_class_field_map(NULL);
 set_initial_method_idnum(0);
 _dependencies = NULL;
 set_jvmti_cached_class_field_map(NULL);
 bool InstanceKlass::find_local_field(Symbol* name, Symbol* sig, fieldDescriptor* fd) const {
 for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
 Symbol* f_name = fs.name();
 Symbol* f_sig  = fs.signature();
 if (f_name == name && f_sig == sig) {
-fd->initialize(const_cast<InstanceKlass*>(this), fs.index());
+fd->reinitialize(const_cast<InstanceKlass*>(this), fs.index());
 return true;
 }
 }
 return false;
 }
 bool InstanceKlass::find_local_field_from_offset(int offset, bool is_static, fieldDescriptor* fd) const {
 for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
 if (fs.offset() == offset) {
-fd->initialize(const_cast<InstanceKlass*>(this), fs.index());
+fd->reinitialize(const_cast<InstanceKlass*>(this), fs.index());
 if (fd->is_static() == is_static) return true;
 }
 }
 return false;
 }
 void InstanceKlass::do_local_static_fields(FieldClosure* cl) {
 for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
 if (fs.access_flags().is_static()) {
-fieldDescriptor fd;
+fieldDescriptor& fd = fs.field_descriptor();
-fd.initialize(this, fs.index());
 cl->do_field(&fd);
 }
 }
 }
 void InstanceKlass::do_local_static_fields_impl(instanceKlassHandle this_oop, void f(fieldDescriptor* fd, TRAPS), TRAPS) {
 for (JavaFieldStream fs(this_oop()); !fs.done(); fs.next()) {
 if (fs.access_flags().is_static()) {
-fieldDescriptor fd;
+fieldDescriptor& fd = fs.field_descriptor();
-fd.initialize(this_oop(), fs.index());
 f(&fd, CHECK);
 }
 }
 }
 int length = java_fields_count();
 // In DebugInfo nonstatic fields are sorted by offset.
 int* fields_sorted = NEW_C_HEAP_ARRAY(int, 2*(length+1), mtClass);
 int j = 0;
 for (int i = 0; i < length; i += 1) {
-fd.initialize(this, i);
+fd.reinitialize(this, i);
 if (!fd.is_static()) {
 fields_sorted[j + 0] = fd.offset();
 fields_sorted[j + 1] = i;
 j += 2;
 }
 if (j > 0) {
 length = j;
 // _sort_Fn is defined in growableArray.hpp.
 qsort(fields_sorted, length/2, 2*sizeof(int), (_sort_Fn)compare_fields_by_offset);
 for (int i = 0; i < length; i += 2) {
-fd.initialize(this, fields_sorted[i + 1]);
+fd.reinitialize(this, fields_sorted[i + 1]);
 assert(!fd.is_static() && fd.offset() == fields_sorted[i], "only nonstatic fields");
 cl->do_field(&fd);
 }
 }
 FREE_C_HEAP_ARRAY(int, fields_sorted, mtClass);
 }
 return NULL;
 }
 // lookup a method in all the interfaces that this class implements
+// Do NOT return private or static methods, new in JDK8 which are not externally visible
+// They should only be found in the initial InterfaceMethodRef
 Method* InstanceKlass::lookup_method_in_all_interfaces(Symbol* name,
 Symbol* signature) const {
 Array<Klass*>* all_ifs = transitive_interfaces();
 int num_ifs = all_ifs->length();
 InstanceKlass *ik = NULL;
 for (int i = 0; i < num_ifs; i++) {
 ik = InstanceKlass::cast(all_ifs->at(i));
 Method* m = ik->lookup_method(name, signature);
-if (m != NULL) {
+if (m != NULL && m->is_public() && !m->is_static()) {
 return m;
 }
 }
 return NULL;
 }
 if (jmeths != NULL &&                         // If there is a cache
 (length = (size_t)jmeths[0]) > idnum) {   // and if it is long enough,
 id = jmeths[idnum+1];                       // Look up the id (may be NULL)
 }
 return id;
-}
-// Cache an itable index
-void InstanceKlass::set_cached_itable_index(size_t idnum, int index) {
-int* indices = methods_cached_itable_indices_acquire();
-int* to_dealloc_indices = NULL;
-// We use a double-check locking idiom here because this cache is
-// performance sensitive. In the normal system, this cache only
-// transitions from NULL to non-NULL which is safe because we use
-// release_set_methods_cached_itable_indices() to advertise the
-// new cache. A partially constructed cache should never be seen
-// by a racing thread. Cache reads and writes proceed without a
-// lock, but creation of the cache itself requires no leaks so a
-// lock is generally acquired in that case.
-//
-// If the RedefineClasses() API has been used, then this cache can
-// grow and we'll have transitions from non-NULL to bigger non-NULL.
-// Cache creation requires no leaks and we require safety between all
-// cache accesses and freeing of the old cache so a lock is generally
-// acquired when the RedefineClasses() API has been used.
-if (indices == NULL || idnum_can_increment()) {
-// we need a cache or the cache can grow
-MutexLocker ml(JNICachedItableIndex_lock);
-// reacquire the cache to see if another thread already did the work
-indices = methods_cached_itable_indices_acquire();
-size_t length = 0;
-// cache size is stored in element[0], other elements offset by one
-if (indices == NULL || (length = (size_t)indices[0]) <= idnum) {
-size_t size = MAX2(idnum+1, (size_t)idnum_allocated_count());
-int* new_indices = NEW_C_HEAP_ARRAY(int, size+1, mtClass);
-new_indices[0] = (int)size;
-// copy any existing entries
-size_t i;
-for (i = 0; i < length; i++) {
-new_indices[i+1] = indices[i+1];
-}
-// Set all the rest to -1
-for (i = length; i < size; i++) {
-new_indices[i+1] = -1;
-}
-if (indices != NULL) {
-// We have an old cache to delete so save it for after we
-// drop the lock.
-to_dealloc_indices = indices;
-}
-release_set_methods_cached_itable_indices(indices = new_indices);
-}
-if (idnum_can_increment()) {
-// this cache can grow so we have to write to it safely
-indices[idnum+1] = index;
-}
-} else {
-CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
-}
-if (!idnum_can_increment()) {
-// The cache cannot grow and this JNI itable index value does not
-// have to be unique like a jmethodID. If there is a race to set it,
-// it doesn't matter.
-indices[idnum+1] = index;
-}
-if (to_dealloc_indices != NULL) {
-// we allocated a new cache so free the old one
-FreeHeap(to_dealloc_indices);
-}
-}
-// Retrieve a cached itable index
-int InstanceKlass::cached_itable_index(size_t idnum) {
-int* indices = methods_cached_itable_indices_acquire();
-if (indices != NULL && ((size_t)indices[0]) > idnum) {
-// indices exist and are long enough, retrieve possible cached
-return indices[idnum+1];
-}
-return -1;
 }
 //
 // Walk the list of dependent nmethods searching for nmethods which
 delete mnt;
 set_member_names(NULL);
 }
 }
-int* indices = methods_cached_itable_indices_acquire();
-if (indices != (int*)NULL) {
-release_set_methods_cached_itable_indices(NULL);
-FreeHeap(indices);
-}
 // release dependencies
 nmethodBucket* b = _dependencies;
 _dependencies = NULL;
 while (b != NULL) {
 nmethodBucket* next = b->next();
 // Decrement symbol reference counts associated with the unloaded class.
 if (_name != NULL) _name->decrement_refcount();
 // unreference array name derived from this class name (arrays of an unloaded
 // class can't be referenced anymore).
 if (_array_name != NULL)  _array_name->decrement_refcount();
-if (_source_file_name != NULL) _source_file_name->decrement_refcount();
 if (_source_debug_extension != NULL) FREE_C_HEAP_ARRAY(char, _source_debug_extension, mtClass);
 assert(_total_instanceKlass_count >= 1, "Sanity check");
 Atomic::dec(&_total_instanceKlass_count);
-}
-void InstanceKlass::set_source_file_name(Symbol* n) {
-_source_file_name = n;
-if (_source_file_name != NULL) _source_file_name->increment_refcount();
 }
 void InstanceKlass::set_source_debug_extension(char* array, int length) {
 if (array == NULL) {
 _source_debug_extension = NULL;
 _source_debug_extension = sde;
 }
 }
 address InstanceKlass::static_field_addr(int offset) {
-return (address)(offset + InstanceMirrorKlass::offset_of_static_fields() + (intptr_t)java_mirror());
+return (address)(offset + InstanceMirrorKlass::offset_of_static_fields() + cast_from_oop<intptr_t>(java_mirror()));
 }
 const char* InstanceKlass::signature_name() const {
 const char* src = (const char*) (name()->as_C_string());
 static const char* state_names[] = {
 "allocated", "loaded", "linked", "being_initialized", "fully_initialized", "initialization_error"
 };
+static void print_vtable(intptr_t* start, int len, outputStream* st) {
+for (int i = 0; i < len; i++) {
+intptr_t e = start[i];
+st->print("%d : " INTPTR_FORMAT, i, e);
+if (e != 0 && ((Metadata*)e)->is_metaspace_object()) {
+st->print(" ");
+((Metadata*)e)->print_value_on(st);
+}
+st->cr();
+}
+}
 void InstanceKlass::print_on(outputStream* st) const {
 assert(is_klass(), "must be klass");
 Klass::print_on(st);
 st->print(BULLET"instance size:     %d", size_helper());                        st->cr();
 }
 }
 st->print(BULLET"arrays:            "); array_klasses()->print_value_on_maybe_null(st); st->cr();
 st->print(BULLET"methods:           "); methods()->print_value_on(st);                  st->cr();
-if (Verbose) {
+if (Verbose || WizardMode) {
 Array<Method*>* method_array = methods();
 for(int i = 0; i < method_array->length(); i++) {
 st->print("%d : ", i); method_array->at(i)->print_value(); st->cr();
 }
 }
 st->print(BULLET"class annotations:       "); class_annotations()->print_value_on(st); st->cr();
 st->print(BULLET"class type annotations:  "); class_type_annotations()->print_value_on(st); st->cr();
 st->print(BULLET"field annotations:       "); fields_annotations()->print_value_on(st); st->cr();
 st->print(BULLET"field type annotations:  "); fields_type_annotations()->print_value_on(st); st->cr();
 {
-ResourceMark rm;
+bool have_pv = false;
-// PreviousVersionInfo objects returned via PreviousVersionWalker
+PreviousVersionWalker pvw(Thread::current(), (InstanceKlass*)this);
-// contain a GrowableArray of handles. We have to clean up the
+for (PreviousVersionNode * pv_node = pvw.next_previous_version();
-// GrowableArray _after_ the PreviousVersionWalker destructor
+pv_node != NULL; pv_node = pvw.next_previous_version()) {
-// has destroyed the handles.
+if (!have_pv)
-{
+st->print(BULLET"previous version:  ");
-bool have_pv = false;
+have_pv = true;
-PreviousVersionWalker pvw((InstanceKlass*)this);
+pv_node->prev_constant_pool()->print_value_on(st);
-for (PreviousVersionInfo * pv_info = pvw.next_previous_version();
+}
-pv_info != NULL; pv_info = pvw.next_previous_version()) {
+if (have_pv) st->cr();
-if (!have_pv)
+} // pvw is cleaned up
-st->print(BULLET"previous version:  ");
-have_pv = true;
-pv_info->prev_constant_pool_handle()()->print_value_on(st);
-}
-if (have_pv)  st->cr();
-} // pvw is cleaned up
-} // rm is cleaned up
 if (generic_signature() != NULL) {
 st->print(BULLET"generic signature: ");
 generic_signature()->print_value_on(st);
 st->cr();
 }
 st->print(BULLET"inner classes:     "); inner_classes()->print_value_on(st);     st->cr();
 st->print(BULLET"java mirror:       "); java_mirror()->print_value_on(st);       st->cr();
 st->print(BULLET"vtable length      %d  (start addr: " INTPTR_FORMAT ")", vtable_length(), start_of_vtable());  st->cr();
+if (vtable_length() > 0 && (Verbose || WizardMode))  print_vtable(start_of_vtable(), vtable_length(), st);
 st->print(BULLET"itable length      %d (start addr: " INTPTR_FORMAT ")", itable_length(), start_of_itable()); st->cr();
+if (itable_length() > 0 && (Verbose || WizardMode))  print_vtable(start_of_itable(), itable_length(), st);
 st->print_cr(BULLET"---- static fields (%d words):", static_field_size());
 FieldPrinter print_static_field(st);
 ((InstanceKlass*)this)->do_local_static_fields(&print_static_field);
 st->print_cr(BULLET"---- non-static fields (%d words):", nonstatic_field_size());
 FieldPrinter print_nonstatic_field(st);
 #endif //PRODUCT
 void InstanceKlass::print_value_on(outputStream* st) const {
 assert(is_klass(), "must be klass");
+if (Verbose || WizardMode)  access_flags().print_on(st);
 name()->print_value_on(st);
 }
 #ifndef PRODUCT
 // we don't need to create a new PreviousVersionNode. However,
 // we still need to examine older previous versions below.
 Array<Method*>* old_methods = ikh->methods();
 if (cp_ref->on_stack()) {
 PreviousVersionNode * pv_node = NULL;
 if (emcp_method_count == 0) {
 // non-shared ConstantPool gets a reference
-pv_node = new PreviousVersionNode(cp_ref, !cp_ref->is_shared(), NULL);
+pv_node = new PreviousVersionNode(cp_ref, NULL);
 RC_TRACE(0x00000400,
 ("add: all methods are obsolete; flushing any EMCP refs"));
 } else {
 int local_count = 0;
 GrowableArray<Method*>* method_refs = new (ResourceObj::C_HEAP, mtClass)
 GrowableArray<Method*>(emcp_method_count, true);
 for (int i = 0; i < old_methods->length(); i++) {
 if (emcp_methods->at(i)) {
 // this old method is EMCP. Save it only if it's on the stack
 Method* old_method = old_methods->at(i);
 if (old_method->on_stack()) {
 method_refs->append(old_method);
+}
+if (++local_count >= emcp_method_count) {
+// no more EMCP methods so bail out now
+break;
 }
-if (++local_count >= emcp_method_count) {
-// no more EMCP methods so bail out now
-break;
 }
 }
-}
 // non-shared ConstantPool gets a reference
-pv_node = new PreviousVersionNode(cp_ref, !cp_ref->is_shared(), method_refs);
+pv_node = new PreviousVersionNode(cp_ref, method_refs);
 }
 // append new previous version.
 _previous_versions->append(pv_node);
 }
 // Since the caller is the VMThread and we are at a safepoint, this
 // is a good time to clear out unused references.
 m = methods()->at(index);
 if (m->method_idnum() == idnum) {
 return m;
 }
 }
+// None found, return null for the caller to handle.
+return NULL;
 }
 return m;
 }
 jint InstanceKlass::get_cached_class_file_len() {
 // Construct a PreviousVersionNode entry for the array hung off
 // the InstanceKlass.
 PreviousVersionNode::PreviousVersionNode(ConstantPool* prev_constant_pool,
-bool prev_cp_is_weak, GrowableArray<Method*>* prev_EMCP_methods) {
+GrowableArray<Method*>* prev_EMCP_methods) {
 _prev_constant_pool = prev_constant_pool;
-_prev_cp_is_weak = prev_cp_is_weak;
 _prev_EMCP_methods = prev_EMCP_methods;
 }
 // Destroy a PreviousVersionNode
 if (_prev_EMCP_methods != NULL) {
 delete _prev_EMCP_methods;
 }
 }
-// Construct a PreviousVersionInfo entry
-PreviousVersionInfo::PreviousVersionInfo(PreviousVersionNode *pv_node) {
-_prev_constant_pool_handle = constantPoolHandle();  // NULL handle
-_prev_EMCP_method_handles = NULL;
-ConstantPool* cp = pv_node->prev_constant_pool();
-assert(cp != NULL, "constant pool ref was unexpectedly cleared");
-if (cp == NULL) {
-return;  // robustness
-}
-// make the ConstantPool* safe to return
-_prev_constant_pool_handle = constantPoolHandle(cp);
-GrowableArray<Method*>* method_refs = pv_node->prev_EMCP_methods();
-if (method_refs == NULL) {
-// the InstanceKlass did not have any EMCP methods
-return;
-}
-_prev_EMCP_method_handles = new GrowableArray<methodHandle>(10);
-int n_methods = method_refs->length();
-for (int i = 0; i < n_methods; i++) {
-Method* method = method_refs->at(i);
-assert (method != NULL, "method has been cleared");
-if (method == NULL) {
-continue;  // robustness
-}
-// make the Method* safe to return
-_prev_EMCP_method_handles->append(methodHandle(method));
-}
-}
-// Destroy a PreviousVersionInfo
-PreviousVersionInfo::~PreviousVersionInfo() {
-// Since _prev_EMCP_method_handles is not C-heap allocated, we
-// don't have to delete it.
-}
 // Construct a helper for walking the previous versions array
-PreviousVersionWalker::PreviousVersionWalker(InstanceKlass *ik) {
+PreviousVersionWalker::PreviousVersionWalker(Thread* thread, InstanceKlass *ik) {
+_thread = thread;
 _previous_versions = ik->previous_versions();
 _current_index = 0;
-// _hm needs no initialization
 _current_p = NULL;
-}
+_current_constant_pool_handle = constantPoolHandle(thread, ik->constants());
-// Destroy a PreviousVersionWalker
-PreviousVersionWalker::~PreviousVersionWalker() {
-// Delete the current info just in case the caller didn't walk to
-// the end of the previous versions list. No harm if _current_p is
-// already NULL.
-delete _current_p;
-// When _hm is destroyed, all the Handles returned in
-// PreviousVersionInfo objects will be destroyed.
-// Also, after this destructor is finished it will be
-// safe to delete the GrowableArray allocated in the
-// PreviousVersionInfo objects.
 }
 // Return the interesting information for the next previous version
 // of the klass. Returns NULL if there are no more previous versions.
-PreviousVersionInfo* PreviousVersionWalker::next_previous_version() {
+PreviousVersionNode* PreviousVersionWalker::next_previous_version() {
 if (_previous_versions == NULL) {
 // no previous versions so nothing to return
 return NULL;
 }
-delete _current_p;  // cleanup the previous info for the caller
+_current_p = NULL;  // reset to NULL
-_current_p = NULL;  // reset to NULL so we don't delete same object twice
+_current_constant_pool_handle = NULL;
 int length = _previous_versions->length();
 while (_current_index < length) {
 PreviousVersionNode * pv_node = _previous_versions->at(_current_index++);
-PreviousVersionInfo * pv_info = new (ResourceObj::C_HEAP, mtClass)
-PreviousVersionInfo(pv_node);
+// Save a handle to the constant pool for this previous version,
+// which keeps all the methods from being deallocated.
-constantPoolHandle cp_h = pv_info->prev_constant_pool_handle();
+_current_constant_pool_handle = constantPoolHandle(_thread, pv_node->prev_constant_pool());
-assert (!cp_h.is_null(), "null cp found in previous version");
+_current_p = pv_node;
+return pv_node;
-// The caller will need to delete pv_info when they are done with it.
+}
-_current_p = pv_info;
-return pv_info;
-}
-// all of the underlying nodes' info has been deleted
 return NULL;
 } // end next_previous_version()

Mercurial > hg > graal-compiler

comparison src/share/vm/oops/instanceKlass.cpp @ 12355:cefad50507d8