src/share/vm/oops/instanceKlass.cpp

*** 284,294 ****
    set_osr_nmethods_head(NULL);
    set_breakpoints(NULL);
    init_previous_versions();
    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);
--- 284,293 ----
*** 1147,1157 ****
  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());
        return true;
      }
    }
    return false;
  }
--- 1146,1156 ----
  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->reinitialize(const_cast<InstanceKlass*>(this), fs.index());
        return true;
      }
    }
    return false;
  }
*** 1216,1226 ****
  
  
  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());
        if (fd->is_static() == is_static) return true;
      }
    }
    return false;
  }
--- 1215,1225 ----
  
  
  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->reinitialize(const_cast<InstanceKlass*>(this), fs.index());
        if (fd->is_static() == is_static) return true;
      }
    }
    return false;
  }
*** 1249,1260 ****
  
  
  void InstanceKlass::do_local_static_fields(FieldClosure* cl) {
    for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
      if (fs.access_flags().is_static()) {
!       fieldDescriptor fd;
!       fd.initialize(this, fs.index());
        cl->do_field(&fd);
      }
    }
  }
  
--- 1248,1258 ----
  
  
  void InstanceKlass::do_local_static_fields(FieldClosure* cl) {
    for (JavaFieldStream fs(this); !fs.done(); fs.next()) {
      if (fs.access_flags().is_static()) {
!       fieldDescriptor& fd = fs.field_descriptor();
        cl->do_field(&fd);
      }
    }
  }
  
*** 1266,1277 ****
  
  
  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;
!       fd.initialize(this_oop(), fs.index());
        f(&fd, CHECK);
      }
    }
  }
  
--- 1264,1274 ----
  
  
  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 = fs.field_descriptor();
        f(&fd, CHECK);
      }
    }
  }
  
*** 1289,1299 ****
    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);
      if (!fd.is_static()) {
        fields_sorted[j + 0] = fd.offset();
        fields_sorted[j + 1] = i;
        j += 2;
      }
--- 1286,1296 ----
    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.reinitialize(this, i);
      if (!fd.is_static()) {
        fields_sorted[j + 0] = fd.offset();
        fields_sorted[j + 1] = i;
        j += 2;
      }
*** 1301,1311 ****
    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]);
        assert(!fd.is_static() && fd.offset() == fields_sorted[i], "only nonstatic fields");
        cl->do_field(&fd);
      }
    }
    FREE_C_HEAP_ARRAY(int, fields_sorted, mtClass);
--- 1298,1308 ----
    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.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);
*** 1684,1774 ****
    }
    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
  // are dependent on the changes that were passed in and mark them for
  // deoptimization.  Returns the number of nmethods found.
  //
--- 1681,1690 ----
*** 2324,2339 ****
        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();
--- 2240,2249 ----
*** 2780,2789 ****
--- 2690,2711 ----
  
  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();
*** 2814,2824 ****
      }
    }
  
    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) {
      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();
      }
    }
--- 2736,2746 ----
      }
    }
  
    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 || 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();
      }
    }
*** 2872,2882 ****
--- 2794,2806 ----
      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);
*** 2894,2903 ****
--- 2818,2828 ----
  
  #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