Mercurial > jdk8-mips64-public > hotspot / changeset

     1.1 --- a/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceClassLoaderKlass.java	Thu Sep 06 07:28:30 2012 -0700
     1.2 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceClassLoaderKlass.java	Fri Sep 07 12:04:16 2012 -0400
     1.3 @@ -45,7 +45,7 @@
     1.4  
     1.5    private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
     1.6      // Just make sure it's there for now
     1.7 -    Type type = db.lookupType("instanceClassLoaderKlass");
     1.8 +    Type type = db.lookupType("InstanceClassLoaderKlass");
     1.9    }
    1.10  
    1.11    public InstanceClassLoaderKlass(Address addr) {

     2.1 --- a/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceMirrorKlass.java	Thu Sep 06 07:28:30 2012 -0700
     2.2 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceMirrorKlass.java	Fri Sep 07 12:04:16 2012 -0400
     2.3 @@ -45,7 +45,7 @@
     2.4  
     2.5    private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
     2.6      // Just make sure it's there for now
     2.7 -    Type type = db.lookupType("instanceMirrorKlass");
     2.8 +    Type type = db.lookupType("InstanceMirrorKlass");
     2.9    }
    2.10  
    2.11    public InstanceMirrorKlass(Address addr) {

     3.1 --- a/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceRefKlass.java	Thu Sep 06 07:28:30 2012 -0700
     3.2 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceRefKlass.java	Fri Sep 07 12:04:16 2012 -0400
     3.3 @@ -45,7 +45,7 @@
     3.4  
     3.5    private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
     3.6      // Just make sure it's there for now
     3.7 -    Type type = db.lookupType("instanceRefKlass");
     3.8 +    Type type = db.lookupType("InstanceRefKlass");
     3.9    }
    3.10  
    3.11    public InstanceRefKlass(Address addr) {

     4.1 --- a/agent/src/share/classes/sun/jvm/hotspot/oops/Metadata.java	Thu Sep 06 07:28:30 2012 -0700
     4.2 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/Metadata.java	Fri Sep 07 12:04:16 2012 -0400
     4.3 @@ -52,9 +52,9 @@
     4.4      metadataConstructor.addMapping("Metadata", Metadata.class);
     4.5      metadataConstructor.addMapping("Klass", Klass.class);
     4.6      metadataConstructor.addMapping("InstanceKlass", InstanceKlass.class);
     4.7 -    metadataConstructor.addMapping("instanceMirrorKlass", InstanceMirrorKlass.class);
     4.8 -    metadataConstructor.addMapping("instanceRefKlass", InstanceRefKlass.class);
     4.9 -    metadataConstructor.addMapping("instanceClassLoaderKlass", InstanceClassLoaderKlass.class);
    4.10 +    metadataConstructor.addMapping("InstanceMirrorKlass", InstanceMirrorKlass.class);
    4.11 +    metadataConstructor.addMapping("InstanceRefKlass", InstanceRefKlass.class);
    4.12 +    metadataConstructor.addMapping("InstanceClassLoaderKlass", InstanceClassLoaderKlass.class);
    4.13      metadataConstructor.addMapping("typeArrayKlass", TypeArrayKlass.class);
    4.14      metadataConstructor.addMapping("objArrayKlass", ObjArrayKlass.class);
    4.15      metadataConstructor.addMapping("Method", Method.class);

     5.1 --- a/src/share/vm/classfile/classFileParser.cpp	Thu Sep 06 07:28:30 2012 -0700
     5.2 +++ b/src/share/vm/classfile/classFileParser.cpp	Fri Sep 07 12:04:16 2012 -0400
     5.3 @@ -3271,7 +3271,7 @@
     5.4      int next_nonstatic_field_offset;
     5.5  
     5.6      // Calculate the starting byte offsets
     5.7 -    next_static_oop_offset      = instanceMirrorKlass::offset_of_static_fields();
     5.8 +    next_static_oop_offset      = InstanceMirrorKlass::offset_of_static_fields();
     5.9      next_static_double_offset   = next_static_oop_offset +
    5.10                                    (fac.count[STATIC_OOP] * heapOopSize);
    5.11      if ( fac.count[STATIC_DOUBLE] &&

     6.1 --- a/src/share/vm/classfile/javaClasses.cpp	Thu Sep 06 07:28:30 2012 -0700
     6.2 +++ b/src/share/vm/classfile/javaClasses.cpp	Fri Sep 07 12:04:16 2012 -0400
     6.3 @@ -500,7 +500,7 @@
     6.4  
     6.5  
     6.6  void java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) {
     6.7 -  assert(instanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already");
     6.8 +  assert(InstanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already");
     6.9  
    6.10    // If the offset was read from the shared archive, it was fixed up already
    6.11    if (!k->is_shared()) {
    6.12 @@ -510,7 +510,7 @@
    6.13      // update all the static field offsets to included the size.
    6.14        for (JavaFieldStream fs(InstanceKlass::cast(k())); !fs.done(); fs.next()) {
    6.15        if (fs.access_flags().is_static()) {
    6.16 -        int real_offset = fs.offset() + instanceMirrorKlass::offset_of_static_fields();
    6.17 +        int real_offset = fs.offset() + InstanceMirrorKlass::offset_of_static_fields();
    6.18          fs.set_offset(real_offset);
    6.19        }
    6.20      }
    6.21 @@ -531,9 +531,9 @@
    6.22    // the mirror.
    6.23    if (SystemDictionary::Class_klass_loaded()) {
    6.24      // Allocate mirror (java.lang.Class instance)
    6.25 -    Handle mirror = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK_0);
    6.26 -
    6.27 -    instanceMirrorKlass* mk = instanceMirrorKlass::cast(mirror->klass());
    6.28 +    Handle mirror = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK_0);
    6.29 +
    6.30 +    InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass());
    6.31      java_lang_Class::set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(mirror()));
    6.32  
    6.33      // It might also have a component mirror.  This mirror must already exist.
    6.34 @@ -592,14 +592,14 @@
    6.35  oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) {
    6.36    // This should be improved by adding a field at the Java level or by
    6.37    // introducing a new VM klass (see comment in ClassFileParser)
    6.38 -  oop java_class = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(NULL, CHECK_0);
    6.39 +  oop java_class = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(NULL, CHECK_0);
    6.40    if (type != T_VOID) {
    6.41      Klass* aklass = Universe::typeArrayKlassObj(type);
    6.42      assert(aklass != NULL, "correct bootstrap");
    6.43      set_array_klass(java_class, aklass);
    6.44    }
    6.45  #ifdef ASSERT
    6.46 -  instanceMirrorKlass* mk = instanceMirrorKlass::cast(SystemDictionary::Class_klass());
    6.47 +  InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(SystemDictionary::Class_klass());
    6.48    assert(java_lang_Class::static_oop_field_count(java_class) == 0, "should have been zeroed by allocation");
    6.49  #endif
    6.50    return java_class;
    6.51 @@ -2835,17 +2835,17 @@
    6.52  
    6.53  // Support for java_lang_System
    6.54  int java_lang_System::in_offset_in_bytes() {
    6.55 -  return (instanceMirrorKlass::offset_of_static_fields() + static_in_offset);
    6.56 +  return (InstanceMirrorKlass::offset_of_static_fields() + static_in_offset);
    6.57  }
    6.58  
    6.59  
    6.60  int java_lang_System::out_offset_in_bytes() {
    6.61 -  return (instanceMirrorKlass::offset_of_static_fields() + static_out_offset);
    6.62 +  return (InstanceMirrorKlass::offset_of_static_fields() + static_out_offset);
    6.63  }
    6.64  
    6.65  
    6.66  int java_lang_System::err_offset_in_bytes() {
    6.67 -  return (instanceMirrorKlass::offset_of_static_fields() + static_err_offset);
    6.68 +  return (InstanceMirrorKlass::offset_of_static_fields() + static_err_offset);
    6.69  }
    6.70  
    6.71  
    6.72 @@ -3124,10 +3124,10 @@
    6.73      tty->print_cr("Static field %s.%s appears to be nonstatic", klass_name, field_name);
    6.74      return false;
    6.75    }
    6.76 -  if (fd.offset() == hardcoded_offset + instanceMirrorKlass::offset_of_static_fields()) {
    6.77 +  if (fd.offset() == hardcoded_offset + InstanceMirrorKlass::offset_of_static_fields()) {
    6.78      return true;
    6.79    } else {
    6.80 -    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());
    6.81 +    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());
    6.82      return false;
    6.83    }
    6.84  }

     7.1 --- a/src/share/vm/classfile/systemDictionary.cpp	Thu Sep 06 07:28:30 2012 -0700
     7.2 +++ b/src/share/vm/classfile/systemDictionary.cpp	Fri Sep 07 12:04:16 2012 -0400
     7.3 @@ -1976,7 +1976,7 @@
     7.4  
     7.5    // Preload ref klasses and set reference types
     7.6    InstanceKlass::cast(WK_KLASS(Reference_klass))->set_reference_type(REF_OTHER);
     7.7 -  instanceRefKlass::update_nonstatic_oop_maps(WK_KLASS(Reference_klass));
     7.8 +  InstanceRefKlass::update_nonstatic_oop_maps(WK_KLASS(Reference_klass));
     7.9  
    7.10    initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(PhantomReference_klass), scan, CHECK);
    7.11    InstanceKlass::cast(WK_KLASS(SoftReference_klass))->set_reference_type(REF_SOFT);

     8.1 --- a/src/share/vm/compiler/compileBroker.cpp	Thu Sep 06 07:28:30 2012 -0700
     8.2 +++ b/src/share/vm/compiler/compileBroker.cpp	Fri Sep 07 12:04:16 2012 -0400
     8.3 @@ -1108,7 +1108,7 @@
     8.4    // the pending list lock or a 3-way deadlock may occur
     8.5    // between the reference handler thread, a GC (instigated
     8.6    // by a compiler thread), and compiled method registration.
     8.7 -  if (instanceRefKlass::owns_pending_list_lock(JavaThread::current())) {
     8.8 +  if (InstanceRefKlass::owns_pending_list_lock(JavaThread::current())) {
     8.9      return;
    8.10    }
    8.11  
    8.12 @@ -1440,7 +1440,7 @@
    8.13  // Should the current thread be blocked until this compilation request
    8.14  // has been fulfilled?
    8.15  bool CompileBroker::is_compile_blocking(methodHandle method, int osr_bci) {
    8.16 -  assert(!instanceRefKlass::owns_pending_list_lock(JavaThread::current()), "possible deadlock");
    8.17 +  assert(!InstanceRefKlass::owns_pending_list_lock(JavaThread::current()), "possible deadlock");
    8.18    return !BackgroundCompilation;
    8.19  }
    8.20  

     9.1 --- a/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp	Thu Sep 06 07:28:30 2012 -0700
     9.2 +++ b/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp	Fri Sep 07 12:04:16 2012 -0400
     9.3 @@ -839,7 +839,7 @@
     9.4    friend class AdjustKlassClosure;
     9.5    friend class FollowKlassClosure;
     9.6    friend class FollowRootClosure;
     9.7 -  friend class instanceClassLoaderKlass;
     9.8 +  friend class InstanceClassLoaderKlass;
     9.9    friend class RefProcTaskProxy;
    9.10  
    9.11   private:

    10.1 --- a/src/share/vm/gc_implementation/shared/concurrentGCThread.cpp	Thu Sep 06 07:28:30 2012 -0700
    10.2 +++ b/src/share/vm/gc_implementation/shared/concurrentGCThread.cpp	Fri Sep 07 12:04:16 2012 -0400
    10.3 @@ -255,13 +255,13 @@
    10.4      }
    10.5      switch(msg) {
    10.6        case acquirePLL: {
    10.7 -        instanceRefKlass::acquire_pending_list_lock(&pll_basic_lock);
    10.8 +        InstanceRefKlass::acquire_pending_list_lock(&pll_basic_lock);
    10.9          debug_only(owned++;)
   10.10          break;
   10.11        }
   10.12        case releaseAndNotifyPLL: {
   10.13          assert(owned > 0, "Don't have PLL");
   10.14 -        instanceRefKlass::release_and_notify_pending_list_lock(&pll_basic_lock);
   10.15 +        InstanceRefKlass::release_and_notify_pending_list_lock(&pll_basic_lock);
   10.16          debug_only(owned--;)
   10.17          break;
   10.18        }

    11.1 --- a/src/share/vm/gc_implementation/shared/vmGCOperations.cpp	Thu Sep 06 07:28:30 2012 -0700
    11.2 +++ b/src/share/vm/gc_implementation/shared/vmGCOperations.cpp	Fri Sep 07 12:04:16 2012 -0400
    11.3 @@ -70,13 +70,13 @@
    11.4  
    11.5  void VM_GC_Operation::acquire_pending_list_lock() {
    11.6    // we may enter this with pending exception set
    11.7 -  instanceRefKlass::acquire_pending_list_lock(&_pending_list_basic_lock);
    11.8 +  InstanceRefKlass::acquire_pending_list_lock(&_pending_list_basic_lock);
    11.9  }
   11.10  
   11.11  
   11.12  void VM_GC_Operation::release_and_notify_pending_list_lock() {
   11.13  
   11.14 -  instanceRefKlass::release_and_notify_pending_list_lock(&_pending_list_basic_lock);
   11.15 +  InstanceRefKlass::release_and_notify_pending_list_lock(&_pending_list_basic_lock);
   11.16  }
   11.17  
   11.18  // Allocations may fail in several threads at about the same time,

    12.1 --- a/src/share/vm/gc_interface/collectedHeap.cpp	Thu Sep 06 07:28:30 2012 -0700
    12.2 +++ b/src/share/vm/gc_interface/collectedHeap.cpp	Fri Sep 07 12:04:16 2012 -0400
    12.3 @@ -516,7 +516,7 @@
    12.4      real_klass->set_java_mirror(mirror);
    12.5    }
    12.6  
    12.7 -  instanceMirrorKlass* mk = instanceMirrorKlass::cast(mirror->klass());
    12.8 +  InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass());
    12.9    assert(size == mk->instance_size(real_klass), "should have been set");
   12.10  
   12.11    // notify jvmti and dtrace

    13.1 --- a/src/share/vm/memory/referenceProcessor.cpp	Thu Sep 06 07:28:30 2012 -0700
    13.2 +++ b/src/share/vm/memory/referenceProcessor.cpp	Fri Sep 07 12:04:16 2012 -0400
    13.3 @@ -1036,7 +1036,7 @@
    13.4        list = &_discoveredPhantomRefs[id];
    13.5        break;
    13.6      case REF_NONE:
    13.7 -      // we should not reach here if we are an instanceRefKlass
    13.8 +      // we should not reach here if we are an InstanceRefKlass
    13.9      default:
   13.10        ShouldNotReachHere();
   13.11    }

    14.1 --- a/src/share/vm/memory/specialized_oop_closures.hpp	Thu Sep 06 07:28:30 2012 -0700
    14.2 +++ b/src/share/vm/memory/specialized_oop_closures.hpp	Fri Sep 07 12:04:16 2012 -0400
    14.3 @@ -199,7 +199,7 @@
    14.4  public:
    14.5    enum Kind {
    14.6      ik,             // InstanceKlass
    14.7 -    irk,            // instanceRefKlass
    14.8 +    irk,            // InstanceRefKlass
    14.9      oa,             // objArrayKlass
   14.10      NUM_Kinds
   14.11    };

    15.1 --- a/src/share/vm/memory/universe.cpp	Thu Sep 06 07:28:30 2012 -0700
    15.2 +++ b/src/share/vm/memory/universe.cpp	Fri Sep 07 12:04:16 2012 -0400
    15.3 @@ -435,9 +435,9 @@
    15.4  void Universe::init_self_patching_vtbl_list(void** list, int count) {
    15.5    int n = 0;
    15.6    { InstanceKlass o;          add_vtable(list, &n, &o, count); }
    15.7 -  { instanceClassLoaderKlass o; add_vtable(list, &n, &o, count); }
    15.8 -  { instanceMirrorKlass o;    add_vtable(list, &n, &o, count); }
    15.9 -  { instanceRefKlass o;       add_vtable(list, &n, &o, count); }
   15.10 +  { InstanceClassLoaderKlass o; add_vtable(list, &n, &o, count); }
   15.11 +  { InstanceMirrorKlass o;    add_vtable(list, &n, &o, count); }
   15.12 +  { InstanceRefKlass o;       add_vtable(list, &n, &o, count); }
   15.13    { typeArrayKlass o;         add_vtable(list, &n, &o, count); }
   15.14    { objArrayKlass o;          add_vtable(list, &n, &o, count); }
   15.15    { Method o;                 add_vtable(list, &n, &o, count); }
   15.16 @@ -486,7 +486,7 @@
   15.17    assert(SystemDictionary::Class_klass_loaded(), "java.lang.Class should be loaded");
   15.18    HandleMark hm(THREAD);
   15.19    // Cache the start of the static fields
   15.20 -  instanceMirrorKlass::init_offset_of_static_fields();
   15.21 +  InstanceMirrorKlass::init_offset_of_static_fields();
   15.22  
   15.23    GrowableArray <Klass*>* list = java_lang_Class::fixup_mirror_list();
   15.24    int list_length = list->length();

    16.1 --- a/src/share/vm/oops/instanceClassLoaderKlass.cpp	Thu Sep 06 07:28:30 2012 -0700
    16.2 +++ b/src/share/vm/oops/instanceClassLoaderKlass.cpp	Fri Sep 07 12:04:16 2012 -0400
    16.3 @@ -49,14 +49,14 @@
    16.4        "Inconsistency in do_metadata");                                \
    16.5    if (closure->do_metadata##nv_suffix())
    16.6  
    16.7 -// Macro to define instanceClassLoaderKlass::oop_oop_iterate for virtual/nonvirtual for
    16.8 +// Macro to define InstanceClassLoaderKlass::oop_oop_iterate for virtual/nonvirtual for
    16.9  // all closures.  Macros calling macros above for each oop size.
   16.10  // Since ClassLoader objects have only a pointer to the loader_data, they are not
   16.11  // compressed nor does the pointer move.
   16.12  
   16.13  #define InstanceClassLoaderKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix)\
   16.14                                                                                  \
   16.15 -int instanceClassLoaderKlass::                                                  \
   16.16 +int InstanceClassLoaderKlass::                                                  \
   16.17  oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) {                  \
   16.18    /* Get size before changing pointers */                                       \
   16.19    SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\
   16.20 @@ -76,7 +76,7 @@
   16.21  #ifndef SERIALGC
   16.22  #define InstanceClassLoaderKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
   16.23                                                                                  \
   16.24 -int instanceClassLoaderKlass::                                                  \
   16.25 +int InstanceClassLoaderKlass::                                                  \
   16.26  oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) {        \
   16.27    /* Get size before changing pointers */                                       \
   16.28    SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\
   16.29 @@ -88,7 +88,7 @@
   16.30  
   16.31  #define InstanceClassLoaderKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix)      \
   16.32                                                                                  \
   16.33 -int instanceClassLoaderKlass::                                                  \
   16.34 +int InstanceClassLoaderKlass::                                                  \
   16.35  oop_oop_iterate##nv_suffix##_m(oop obj,                                         \
   16.36                                 OopClosureType* closure,                         \
   16.37                                 MemRegion mr) {                                  \
   16.38 @@ -118,7 +118,7 @@
   16.39  ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceClassLoaderKlass_OOP_OOP_ITERATE_DEFN_m)
   16.40  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceClassLoaderKlass_OOP_OOP_ITERATE_DEFN_m)
   16.41  
   16.42 -void instanceClassLoaderKlass::oop_follow_contents(oop obj) {
   16.43 +void InstanceClassLoaderKlass::oop_follow_contents(oop obj) {
   16.44    InstanceKlass::oop_follow_contents(obj);
   16.45    ClassLoaderData * const loader_data = java_lang_ClassLoader::loader_data(obj);
   16.46  
   16.47 @@ -130,7 +130,7 @@
   16.48  }
   16.49  
   16.50  #ifndef SERIALGC
   16.51 -void instanceClassLoaderKlass::oop_follow_contents(ParCompactionManager* cm,
   16.52 +void InstanceClassLoaderKlass::oop_follow_contents(ParCompactionManager* cm,
   16.53          oop obj) {
   16.54    InstanceKlass::oop_follow_contents(cm, obj);
   16.55    ClassLoaderData * const loader_data = java_lang_ClassLoader::loader_data(obj);
   16.56 @@ -139,7 +139,7 @@
   16.57    }
   16.58  }
   16.59  
   16.60 -void instanceClassLoaderKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
   16.61 +void InstanceClassLoaderKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
   16.62    InstanceKlass::oop_push_contents(pm, obj);
   16.63  
   16.64    // This is called by the young collector. It will already have taken care of
   16.65 @@ -147,7 +147,7 @@
   16.66    // class loader data link.
   16.67  }
   16.68  
   16.69 -int instanceClassLoaderKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
   16.70 +int InstanceClassLoaderKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
   16.71    InstanceKlass::oop_update_pointers(cm, obj);
   16.72    ClassLoaderData * const loader_data = java_lang_ClassLoader::loader_data(obj);
   16.73    if (loader_data != NULL) {

    17.1 --- a/src/share/vm/oops/instanceClassLoaderKlass.hpp	Thu Sep 06 07:28:30 2012 -0700
    17.2 +++ b/src/share/vm/oops/instanceClassLoaderKlass.hpp	Fri Sep 07 12:04:16 2012 -0400
    17.3 @@ -27,24 +27,24 @@
    17.4  
    17.5  #include "oops/instanceKlass.hpp"
    17.6  
    17.7 -// An instanceClassLoaderKlass is a specialization of the InstanceKlass. It does
    17.8 +// An InstanceClassLoaderKlass is a specialization of the InstanceKlass. It does
    17.9  // not add any field.  It is added to walk the dependencies for the class loader
   17.10  // key that this class loader points to.  This is how the loader_data graph is
   17.11  // walked and dependant class loaders are kept alive.  I thought we walked
   17.12  // the list later?
   17.13  
   17.14 -class instanceClassLoaderKlass: public InstanceKlass {
   17.15 +class InstanceClassLoaderKlass: public InstanceKlass {
   17.16    friend class VMStructs;
   17.17    friend class InstanceKlass;
   17.18  
   17.19    // Constructor
   17.20 -  instanceClassLoaderKlass(int vtable_len, int itable_len, int static_field_size, int nonstatic_oop_map_size, ReferenceType rt, AccessFlags access_flags, bool is_anonymous)
   17.21 +  InstanceClassLoaderKlass(int vtable_len, int itable_len, int static_field_size, int nonstatic_oop_map_size, ReferenceType rt, AccessFlags access_flags, bool is_anonymous)
   17.22      : InstanceKlass(vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, access_flags, is_anonymous) {}
   17.23  
   17.24  public:
   17.25    virtual bool oop_is_instanceClassLoader() const { return true; }
   17.26  
   17.27 -  instanceClassLoaderKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); }
   17.28 +  InstanceClassLoaderKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); }
   17.29  
   17.30    // Iterators
   17.31    int oop_oop_iterate(oop obj, ExtendedOopClosure* blk) {

    18.1 --- a/src/share/vm/oops/instanceKlass.cpp	Thu Sep 06 07:28:30 2012 -0700
    18.2 +++ b/src/share/vm/oops/instanceKlass.cpp	Fri Sep 07 12:04:16 2012 -0400
    18.3 @@ -191,14 +191,14 @@
    18.4    InstanceKlass* ik;
    18.5    if (rt == REF_NONE) {
    18.6      if (name == vmSymbols::java_lang_Class()) {
    18.7 -      ik = new (loader_data, size, THREAD) instanceMirrorKlass(
    18.8 +      ik = new (loader_data, size, THREAD) InstanceMirrorKlass(
    18.9          vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,
   18.10          access_flags, !host_klass.is_null());
   18.11      } else if (name == vmSymbols::java_lang_ClassLoader() ||
   18.12            (SystemDictionary::ClassLoader_klass_loaded() &&
   18.13            super_klass != NULL &&
   18.14            super_klass->is_subtype_of(SystemDictionary::ClassLoader_klass()))) {
   18.15 -      ik = new (loader_data, size, THREAD) instanceClassLoaderKlass(
   18.16 +      ik = new (loader_data, size, THREAD) InstanceClassLoaderKlass(
   18.17          vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,
   18.18          access_flags, !host_klass.is_null());
   18.19      } else {
   18.20 @@ -209,7 +209,7 @@
   18.21      }
   18.22    } else {
   18.23      // reference klass
   18.24 -    ik = new (loader_data, size, THREAD) instanceRefKlass(
   18.25 +    ik = new (loader_data, size, THREAD) InstanceRefKlass(
   18.26          vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt,
   18.27          access_flags, !host_klass.is_null());
   18.28    }
   18.29 @@ -2284,7 +2284,7 @@
   18.30  }
   18.31  
   18.32  address InstanceKlass::static_field_addr(int offset) {
   18.33 -  return (address)(offset + instanceMirrorKlass::offset_of_static_fields() + (intptr_t)java_mirror());
   18.34 +  return (address)(offset + InstanceMirrorKlass::offset_of_static_fields() + (intptr_t)java_mirror());
   18.35  }
   18.36  
   18.37  
   18.38 @@ -3073,7 +3073,7 @@
   18.39  
   18.40  
   18.41  void JNIid::verify(Klass* holder) {
   18.42 -  int first_field_offset  = instanceMirrorKlass::offset_of_static_fields();
   18.43 +  int first_field_offset  = InstanceMirrorKlass::offset_of_static_fields();
   18.44    int end_field_offset;
   18.45    end_field_offset = first_field_offset + (InstanceKlass::cast(holder)->static_field_size() * wordSize);
   18.46  

    19.1 --- a/src/share/vm/oops/instanceMirrorKlass.cpp	Thu Sep 06 07:28:30 2012 -0700
    19.2 +++ b/src/share/vm/oops/instanceMirrorKlass.cpp	Fri Sep 07 12:04:16 2012 -0400
    19.3 @@ -47,7 +47,7 @@
    19.4  #include "oops/oop.pcgc.inline.hpp"
    19.5  #endif
    19.6  
    19.7 -int instanceMirrorKlass::_offset_of_static_fields = 0;
    19.8 +int InstanceMirrorKlass::_offset_of_static_fields = 0;
    19.9  
   19.10  #ifdef ASSERT
   19.11  template <class T> void assert_is_in(T *p) {
   19.12 @@ -148,7 +148,7 @@
   19.13  }
   19.14  
   19.15  
   19.16 -void instanceMirrorKlass::oop_follow_contents(oop obj) {
   19.17 +void InstanceMirrorKlass::oop_follow_contents(oop obj) {
   19.18    InstanceKlass::oop_follow_contents(obj);
   19.19  
   19.20    // Follow the klass field in the mirror.
   19.21 @@ -169,7 +169,7 @@
   19.22  }
   19.23  
   19.24  #ifndef SERIALGC
   19.25 -void instanceMirrorKlass::oop_follow_contents(ParCompactionManager* cm,
   19.26 +void InstanceMirrorKlass::oop_follow_contents(ParCompactionManager* cm,
   19.27                                                oop obj) {
   19.28    InstanceKlass::oop_follow_contents(cm, obj);
   19.29  
   19.30 @@ -191,7 +191,7 @@
   19.31  }
   19.32  #endif // SERIALGC
   19.33  
   19.34 -int instanceMirrorKlass::oop_adjust_pointers(oop obj) {
   19.35 +int InstanceMirrorKlass::oop_adjust_pointers(oop obj) {
   19.36    int size = oop_size(obj);
   19.37    InstanceKlass::oop_adjust_pointers(obj);
   19.38  
   19.39 @@ -235,12 +235,12 @@
   19.40        "Inconsistency in do_metadata");                                \
   19.41    if (closure->do_metadata##nv_suffix())
   19.42  
   19.43 -// Macro to define instanceMirrorKlass::oop_oop_iterate for virtual/nonvirtual for
   19.44 +// Macro to define InstanceMirrorKlass::oop_oop_iterate for virtual/nonvirtual for
   19.45  // all closures.  Macros calling macros above for each oop size.
   19.46  
   19.47  #define InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix)           \
   19.48                                                                                        \
   19.49 -int instanceMirrorKlass::                                                             \
   19.50 +int InstanceMirrorKlass::                                                             \
   19.51  oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) {                        \
   19.52    /* Get size before changing pointers */                                             \
   19.53    SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);      \
   19.54 @@ -265,7 +265,7 @@
   19.55  #ifndef SERIALGC
   19.56  #define InstanceMirrorKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
   19.57                                                                                        \
   19.58 -int instanceMirrorKlass::                                                             \
   19.59 +int InstanceMirrorKlass::                                                             \
   19.60  oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) {              \
   19.61    /* Get size before changing pointers */                                             \
   19.62    SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);      \
   19.63 @@ -283,7 +283,7 @@
   19.64  
   19.65  #define InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix)         \
   19.66                                                                                        \
   19.67 -int instanceMirrorKlass::                                                             \
   19.68 +int InstanceMirrorKlass::                                                             \
   19.69  oop_oop_iterate##nv_suffix##_m(oop obj,                                               \
   19.70                                 OopClosureType* closure,                               \
   19.71                                 MemRegion mr) {                                        \
   19.72 @@ -318,7 +318,7 @@
   19.73  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN_m)
   19.74  
   19.75  #ifndef SERIALGC
   19.76 -void instanceMirrorKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
   19.77 +void InstanceMirrorKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
   19.78    // Note that we don't have to follow the mirror -> klass pointer, since all
   19.79    // klasses that are dirty will be scavenged when we iterate over the
   19.80    // ClassLoaderData objects.
   19.81 @@ -332,7 +332,7 @@
   19.82      assert_nothing )
   19.83  }
   19.84  
   19.85 -int instanceMirrorKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
   19.86 +int InstanceMirrorKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
   19.87    int size = oop_size(obj);
   19.88    InstanceKlass::oop_update_pointers(cm, obj);
   19.89  
   19.90 @@ -355,14 +355,14 @@
   19.91  }
   19.92  #endif // SERIALGC
   19.93  
   19.94 -int instanceMirrorKlass::instance_size(KlassHandle k) {
   19.95 +int InstanceMirrorKlass::instance_size(KlassHandle k) {
   19.96    if (k() != NULL && k->oop_is_instance()) {
   19.97      return align_object_size(size_helper() + InstanceKlass::cast(k())->static_field_size());
   19.98    }
   19.99    return size_helper();
  19.100  }
  19.101  
  19.102 -instanceOop instanceMirrorKlass::allocate_instance(KlassHandle k, TRAPS) {
  19.103 +instanceOop InstanceMirrorKlass::allocate_instance(KlassHandle k, TRAPS) {
  19.104    // Query before forming handle.
  19.105    int size = instance_size(k);
  19.106    KlassHandle h_k(THREAD, this);
  19.107 @@ -370,11 +370,11 @@
  19.108    return i;
  19.109  }
  19.110  
  19.111 -int instanceMirrorKlass::oop_size(oop obj) const {
  19.112 +int InstanceMirrorKlass::oop_size(oop obj) const {
  19.113    return java_lang_Class::oop_size(obj);
  19.114  }
  19.115  
  19.116 -int instanceMirrorKlass::compute_static_oop_field_count(oop obj) {
  19.117 +int InstanceMirrorKlass::compute_static_oop_field_count(oop obj) {
  19.118    Klass* k = java_lang_Class::as_Klass(obj);
  19.119    if (k != NULL && k->oop_is_instance()) {
  19.120      return InstanceKlass::cast(k)->static_oop_field_count();

    20.1 --- a/src/share/vm/oops/instanceMirrorKlass.hpp	Thu Sep 06 07:28:30 2012 -0700
    20.2 +++ b/src/share/vm/oops/instanceMirrorKlass.hpp	Fri Sep 07 12:04:16 2012 -0400
    20.3 @@ -29,7 +29,7 @@
    20.4  #include "oops/instanceKlass.hpp"
    20.5  #include "runtime/handles.hpp"
    20.6  
    20.7 -// An instanceMirrorKlass is a specialized InstanceKlass for
    20.8 +// An InstanceMirrorKlass is a specialized InstanceKlass for
    20.9  // java.lang.Class instances.  These instances are special because
   20.10  // they contain the static fields of the class in addition to the
   20.11  // normal fields of Class.  This means they are variable sized
   20.12 @@ -37,7 +37,7 @@
   20.13  // iteration of their oops.
   20.14  
   20.15  
   20.16 -class instanceMirrorKlass: public InstanceKlass {
   20.17 +class InstanceMirrorKlass: public InstanceKlass {
   20.18    friend class VMStructs;
   20.19    friend class InstanceKlass;
   20.20  
   20.21 @@ -45,18 +45,18 @@
   20.22    static int _offset_of_static_fields;
   20.23  
   20.24    // Constructor
   20.25 -  instanceMirrorKlass(int vtable_len, int itable_len, int static_field_size, int nonstatic_oop_map_size, ReferenceType rt, AccessFlags access_flags,  bool is_anonymous)
   20.26 +  InstanceMirrorKlass(int vtable_len, int itable_len, int static_field_size, int nonstatic_oop_map_size, ReferenceType rt, AccessFlags access_flags,  bool is_anonymous)
   20.27      : InstanceKlass(vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, access_flags, is_anonymous) {}
   20.28  
   20.29   public:
   20.30 -  instanceMirrorKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); }
   20.31 +  InstanceMirrorKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); }
   20.32    // Type testing
   20.33    bool oop_is_instanceMirror() const             { return true; }
   20.34  
   20.35    // Casting from Klass*
   20.36 -  static instanceMirrorKlass* cast(Klass* k) {
   20.37 -    assert(k->oop_is_instanceMirror(), "cast to instanceMirrorKlass");
   20.38 -    return (instanceMirrorKlass*) k;
   20.39 +  static InstanceMirrorKlass* cast(Klass* k) {
   20.40 +    assert(k->oop_is_instanceMirror(), "cast to InstanceMirrorKlass");
   20.41 +    return (InstanceMirrorKlass*) k;
   20.42    }
   20.43  
   20.44    // Returns the size of the instance including the extra static fields.
   20.45 @@ -71,7 +71,7 @@
   20.46    static void init_offset_of_static_fields() {
   20.47      // Cache the offset of the static fields in the Class instance
   20.48      assert(_offset_of_static_fields == 0, "once");
   20.49 -    _offset_of_static_fields = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->size_helper() << LogHeapWordSize;
   20.50 +    _offset_of_static_fields = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->size_helper() << LogHeapWordSize;
   20.51    }
   20.52  
   20.53    static int offset_of_static_fields() {

    21.1 --- a/src/share/vm/oops/instanceRefKlass.cpp	Thu Sep 06 07:28:30 2012 -0700
    21.2 +++ b/src/share/vm/oops/instanceRefKlass.cpp	Fri Sep 07 12:04:16 2012 -0400
    21.3 @@ -45,12 +45,12 @@
    21.4  #endif
    21.5  
    21.6  template <class T>
    21.7 -void specialized_oop_follow_contents(instanceRefKlass* ref, oop obj) {
    21.8 +void specialized_oop_follow_contents(InstanceRefKlass* ref, oop obj) {
    21.9    T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
   21.10    T heap_oop = oopDesc::load_heap_oop(referent_addr);
   21.11    debug_only(
   21.12      if(TraceReferenceGC && PrintGCDetails) {
   21.13 -      gclog_or_tty->print_cr("instanceRefKlass::oop_follow_contents " INTPTR_FORMAT, obj);
   21.14 +      gclog_or_tty->print_cr("InstanceRefKlass::oop_follow_contents " INTPTR_FORMAT, obj);
   21.15      }
   21.16    )
   21.17    if (!oopDesc::is_null(heap_oop)) {
   21.18 @@ -112,7 +112,7 @@
   21.19    ref->InstanceKlass::oop_follow_contents(obj);
   21.20  }
   21.21  
   21.22 -void instanceRefKlass::oop_follow_contents(oop obj) {
   21.23 +void InstanceRefKlass::oop_follow_contents(oop obj) {
   21.24    if (UseCompressedOops) {
   21.25      specialized_oop_follow_contents<narrowOop>(this, obj);
   21.26    } else {
   21.27 @@ -122,14 +122,14 @@
   21.28  
   21.29  #ifndef SERIALGC
   21.30  template <class T>
   21.31 -void specialized_oop_follow_contents(instanceRefKlass* ref,
   21.32 +void specialized_oop_follow_contents(InstanceRefKlass* ref,
   21.33                                       ParCompactionManager* cm,
   21.34                                       oop obj) {
   21.35    T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
   21.36    T heap_oop = oopDesc::load_heap_oop(referent_addr);
   21.37    debug_only(
   21.38      if(TraceReferenceGC && PrintGCDetails) {
   21.39 -      gclog_or_tty->print_cr("instanceRefKlass::oop_follow_contents " INTPTR_FORMAT, obj);
   21.40 +      gclog_or_tty->print_cr("InstanceRefKlass::oop_follow_contents " INTPTR_FORMAT, obj);
   21.41      }
   21.42    )
   21.43    if (!oopDesc::is_null(heap_oop)) {
   21.44 @@ -186,7 +186,7 @@
   21.45    ref->InstanceKlass::oop_follow_contents(cm, obj);
   21.46  }
   21.47  
   21.48 -void instanceRefKlass::oop_follow_contents(ParCompactionManager* cm,
   21.49 +void InstanceRefKlass::oop_follow_contents(ParCompactionManager* cm,
   21.50                                             oop obj) {
   21.51    if (UseCompressedOops) {
   21.52      specialized_oop_follow_contents<narrowOop>(this, cm, obj);
   21.53 @@ -218,18 +218,18 @@
   21.54  }
   21.55  #endif
   21.56  
   21.57 -template <class T> void specialized_oop_adjust_pointers(instanceRefKlass *ref, oop obj) {
   21.58 +template <class T> void specialized_oop_adjust_pointers(InstanceRefKlass *ref, oop obj) {
   21.59    T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
   21.60    MarkSweep::adjust_pointer(referent_addr);
   21.61    T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
   21.62    MarkSweep::adjust_pointer(next_addr);
   21.63    T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
   21.64    MarkSweep::adjust_pointer(discovered_addr);
   21.65 -  debug_only(trace_reference_gc("instanceRefKlass::oop_adjust_pointers", obj,
   21.66 +  debug_only(trace_reference_gc("InstanceRefKlass::oop_adjust_pointers", obj,
   21.67                                  referent_addr, next_addr, discovered_addr);)
   21.68  }
   21.69  
   21.70 -int instanceRefKlass::oop_adjust_pointers(oop obj) {
   21.71 +int InstanceRefKlass::oop_adjust_pointers(oop obj) {
   21.72    int size = size_helper();
   21.73    InstanceKlass::oop_adjust_pointers(obj);
   21.74  
   21.75 @@ -298,12 +298,12 @@
   21.76  
   21.77  template <class T> bool contains(T *t) { return true; }
   21.78  
   21.79 -// Macro to define instanceRefKlass::oop_oop_iterate for virtual/nonvirtual for
   21.80 +// Macro to define InstanceRefKlass::oop_oop_iterate for virtual/nonvirtual for
   21.81  // all closures.  Macros calling macros above for each oop size.
   21.82  
   21.83  #define InstanceRefKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix)        \
   21.84                                                                                  \
   21.85 -int instanceRefKlass::                                                          \
   21.86 +int InstanceRefKlass::                                                          \
   21.87  oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) {                  \
   21.88    /* Get size before changing pointers */                                       \
   21.89    SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\
   21.90 @@ -320,7 +320,7 @@
   21.91  #ifndef SERIALGC
   21.92  #define InstanceRefKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
   21.93                                                                                  \
   21.94 -int instanceRefKlass::                                                          \
   21.95 +int InstanceRefKlass::                                                          \
   21.96  oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) {        \
   21.97    /* Get size before changing pointers */                                       \
   21.98    SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\
   21.99 @@ -338,7 +338,7 @@
  21.100  
  21.101  #define InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix)      \
  21.102                                                                                  \
  21.103 -int instanceRefKlass::                                                          \
  21.104 +int InstanceRefKlass::                                                          \
  21.105  oop_oop_iterate##nv_suffix##_m(oop obj,                                         \
  21.106                                 OopClosureType* closure,                         \
  21.107                                 MemRegion mr) {                                  \
  21.108 @@ -363,7 +363,7 @@
  21.109  
  21.110  #ifndef SERIALGC
  21.111  template <class T>
  21.112 -void specialized_oop_push_contents(instanceRefKlass *ref,
  21.113 +void specialized_oop_push_contents(InstanceRefKlass *ref,
  21.114                                     PSPromotionManager* pm, oop obj) {
  21.115    T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
  21.116    if (PSScavenge::should_scavenge(referent_addr)) {
  21.117 @@ -414,7 +414,7 @@
  21.118    ref->InstanceKlass::oop_push_contents(pm, obj);
  21.119  }
  21.120  
  21.121 -void instanceRefKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
  21.122 +void InstanceRefKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
  21.123    if (UseCompressedOops) {
  21.124      specialized_oop_push_contents<narrowOop>(this, pm, obj);
  21.125    } else {
  21.126 @@ -423,7 +423,7 @@
  21.127  }
  21.128  
  21.129  template <class T>
  21.130 -void specialized_oop_update_pointers(instanceRefKlass *ref,
  21.131 +void specialized_oop_update_pointers(InstanceRefKlass *ref,
  21.132                                      ParCompactionManager* cm, oop obj) {
  21.133    T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
  21.134    PSParallelCompact::adjust_pointer(referent_addr);
  21.135 @@ -431,11 +431,11 @@
  21.136    PSParallelCompact::adjust_pointer(next_addr);
  21.137    T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
  21.138    PSParallelCompact::adjust_pointer(discovered_addr);
  21.139 -  debug_only(trace_reference_gc("instanceRefKlass::oop_update_ptrs", obj,
  21.140 +  debug_only(trace_reference_gc("InstanceRefKlass::oop_update_ptrs", obj,
  21.141                                  referent_addr, next_addr, discovered_addr);)
  21.142  }
  21.143  
  21.144 -int instanceRefKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
  21.145 +int InstanceRefKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
  21.146    InstanceKlass::oop_update_pointers(cm, obj);
  21.147    if (UseCompressedOops) {
  21.148      specialized_oop_update_pointers<narrowOop>(this, cm, obj);
  21.149 @@ -446,7 +446,7 @@
  21.150  }
  21.151  #endif // SERIALGC
  21.152  
  21.153 -void instanceRefKlass::update_nonstatic_oop_maps(Klass* k) {
  21.154 +void InstanceRefKlass::update_nonstatic_oop_maps(Klass* k) {
  21.155    // Clear the nonstatic oop-map entries corresponding to referent
  21.156    // and nextPending field.  They are treated specially by the
  21.157    // garbage collector.
  21.158 @@ -485,7 +485,7 @@
  21.159  
  21.160  // Verification
  21.161  
  21.162 -void instanceRefKlass::oop_verify_on(oop obj, outputStream* st) {
  21.163 +void InstanceRefKlass::oop_verify_on(oop obj, outputStream* st) {
  21.164    InstanceKlass::oop_verify_on(obj, st);
  21.165    // Verify referent field
  21.166    oop referent = java_lang_ref_Reference::referent(obj);
  21.167 @@ -506,13 +506,13 @@
  21.168    }
  21.169  }
  21.170  
  21.171 -bool instanceRefKlass::owns_pending_list_lock(JavaThread* thread) {
  21.172 +bool InstanceRefKlass::owns_pending_list_lock(JavaThread* thread) {
  21.173    if (java_lang_ref_Reference::pending_list_lock() == NULL) return false;
  21.174    Handle h_lock(thread, java_lang_ref_Reference::pending_list_lock());
  21.175    return ObjectSynchronizer::current_thread_holds_lock(thread, h_lock);
  21.176  }
  21.177  
  21.178 -void instanceRefKlass::acquire_pending_list_lock(BasicLock *pending_list_basic_lock) {
  21.179 +void InstanceRefKlass::acquire_pending_list_lock(BasicLock *pending_list_basic_lock) {
  21.180    // we may enter this with pending exception set
  21.181    PRESERVE_EXCEPTION_MARK;  // exceptions are never thrown, needed for TRAPS argument
  21.182  
  21.183 @@ -529,7 +529,7 @@
  21.184    if (HAS_PENDING_EXCEPTION) CLEAR_PENDING_EXCEPTION;
  21.185  }
  21.186  
  21.187 -void instanceRefKlass::release_and_notify_pending_list_lock(
  21.188 +void InstanceRefKlass::release_and_notify_pending_list_lock(
  21.189    BasicLock *pending_list_basic_lock) {
  21.190    // we may enter this with pending exception set
  21.191    PRESERVE_EXCEPTION_MARK;  // exceptions are never thrown, needed for TRAPS argument

    22.1 --- a/src/share/vm/oops/instanceRefKlass.hpp	Thu Sep 06 07:28:30 2012 -0700
    22.2 +++ b/src/share/vm/oops/instanceRefKlass.hpp	Fri Sep 07 12:04:16 2012 -0400
    22.3 @@ -27,7 +27,7 @@
    22.4  
    22.5  #include "oops/instanceKlass.hpp"
    22.6  
    22.7 -// An instanceRefKlass is a specialized InstanceKlass for Java
    22.8 +// An InstanceRefKlass is a specialized InstanceKlass for Java
    22.9  // classes that are subclasses of java/lang/ref/Reference.
   22.10  //
   22.11  // These classes are used to implement soft/weak/final/phantom
   22.12 @@ -44,22 +44,22 @@
   22.13  // and the pending list lock object in the same class is notified.
   22.14  
   22.15  
   22.16 -class instanceRefKlass: public InstanceKlass {
   22.17 +class InstanceRefKlass: public InstanceKlass {
   22.18    friend class InstanceKlass;
   22.19  
   22.20    // Constructor
   22.21 -  instanceRefKlass(int vtable_len, int itable_len, int static_field_size, int nonstatic_oop_map_size, ReferenceType rt, AccessFlags access_flags, bool is_anonymous)
   22.22 +  InstanceRefKlass(int vtable_len, int itable_len, int static_field_size, int nonstatic_oop_map_size, ReferenceType rt, AccessFlags access_flags, bool is_anonymous)
   22.23      : InstanceKlass(vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, access_flags, is_anonymous) {}
   22.24  
   22.25   public:
   22.26 -  instanceRefKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); }
   22.27 +  InstanceRefKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); }
   22.28    // Type testing
   22.29    bool oop_is_instanceRef() const             { return true; }
   22.30  
   22.31    // Casting from Klass*
   22.32 -  static instanceRefKlass* cast(Klass* k) {
   22.33 -    assert(k->oop_is_instanceRef(), "cast to instanceRefKlass");
   22.34 -    return (instanceRefKlass*) k;
   22.35 +  static InstanceRefKlass* cast(Klass* k) {
   22.36 +    assert(k->oop_is_instanceRef(), "cast to InstanceRefKlass");
   22.37 +    return (InstanceRefKlass*) k;
   22.38    }
   22.39  
   22.40    // Garbage collection

    23.1 --- a/src/share/vm/oops/method.cpp	Thu Sep 06 07:28:30 2012 -0700
    23.2 +++ b/src/share/vm/oops/method.cpp	Fri Sep 07 12:04:16 2012 -0400
    23.3 @@ -376,7 +376,7 @@
    23.4  void Method::build_interpreter_method_data(methodHandle method, TRAPS) {
    23.5    // Do not profile method if current thread holds the pending list lock,
    23.6    // which avoids deadlock for acquiring the MethodData_lock.
    23.7 -  if (instanceRefKlass::owns_pending_list_lock((JavaThread*)THREAD)) {
    23.8 +  if (InstanceRefKlass::owns_pending_list_lock((JavaThread*)THREAD)) {
    23.9      return;
   23.10    }
   23.11  

    24.1 --- a/src/share/vm/oops/oopsHierarchy.hpp	Thu Sep 06 07:28:30 2012 -0700
    24.2 +++ b/src/share/vm/oops/oopsHierarchy.hpp	Fri Sep 07 12:04:16 2012 -0400
    24.3 @@ -169,9 +169,9 @@
    24.4  
    24.5  class Klass;
    24.6  class   InstanceKlass;
    24.7 -class     instanceMirrorKlass;
    24.8 -class     instanceClassLoaderKlass;
    24.9 -class     instanceRefKlass;
   24.10 +class     InstanceMirrorKlass;
   24.11 +class     InstanceClassLoaderKlass;
   24.12 +class     InstanceRefKlass;
   24.13  class   arrayKlass;
   24.14  class     objArrayKlass;
   24.15  class     typeArrayKlass;

    25.1 --- a/src/share/vm/opto/type.cpp	Thu Sep 06 07:28:30 2012 -0700
    25.2 +++ b/src/share/vm/opto/type.cpp	Fri Sep 07 12:04:16 2012 -0400
    25.3 @@ -2380,7 +2380,7 @@
    25.4            assert(this->isa_instptr(), "must be an instance ptr.");
    25.5            _is_ptr_to_narrowoop = false;
    25.6          } else if (klass() == ciEnv::current()->Class_klass() &&
    25.7 -                   _offset >= instanceMirrorKlass::offset_of_static_fields()) {
    25.8 +                   _offset >= InstanceMirrorKlass::offset_of_static_fields()) {
    25.9            // Static fields
   25.10            assert(o != NULL, "must be constant");
   25.11            ciInstanceKlass* k = o->as_instance()->java_lang_Class_klass()->as_instance_klass();

    26.1 --- a/src/share/vm/prims/jvmtiTagMap.cpp	Thu Sep 06 07:28:30 2012 -0700
    26.2 +++ b/src/share/vm/prims/jvmtiTagMap.cpp	Fri Sep 07 12:04:16 2012 -0400
    26.3 @@ -2790,7 +2790,7 @@
    26.4  static inline bool verify_static_oop(InstanceKlass* ik,
    26.5                                       oop mirror, int offset) {
    26.6    address obj_p = (address)mirror + offset;
    26.7 -  address start = (address)instanceMirrorKlass::start_of_static_fields(mirror);
    26.8 +  address start = (address)InstanceMirrorKlass::start_of_static_fields(mirror);
    26.9    address end = start + (java_lang_Class::static_oop_field_count(mirror) * heapOopSize);
   26.10    assert(end >= start, "sanity check");
   26.11  

    27.1 --- a/src/share/vm/runtime/vmStructs.cpp	Thu Sep 06 07:28:30 2012 -0700
    27.2 +++ b/src/share/vm/runtime/vmStructs.cpp	Fri Sep 07 12:04:16 2012 -0400
    27.3 @@ -1374,9 +1374,9 @@
    27.4             declare_type(objArrayKlass, arrayKlass)                        \
    27.5             declare_type(typeArrayKlass, arrayKlass)                       \
    27.6        declare_type(InstanceKlass, Klass)                                  \
    27.7 -        declare_type(instanceClassLoaderKlass, InstanceKlass)             \
    27.8 -        declare_type(instanceMirrorKlass, InstanceKlass)                  \
    27.9 -        declare_type(instanceRefKlass, InstanceKlass)                     \
   27.10 +        declare_type(InstanceClassLoaderKlass, InstanceKlass)             \
   27.11 +        declare_type(InstanceMirrorKlass, InstanceKlass)                  \
   27.12 +        declare_type(InstanceRefKlass, InstanceKlass)                     \
   27.13      declare_type(ConstantPool, Metadata)                           \
   27.14      declare_type(ConstantPoolCache, MetaspaceObj)                  \
   27.15      declare_type(MethodData, Metadata)                             \