8000213: NPG: Should have renamed arrayKlass and typeArrayKlass

Summary: Capitalize these metadata types (and objArrayKlass)
Reviewed-by: stefank, twisti, kvn

64 files changed, 407 insertions, 410 deletions

diff --git a/src/share/vm/c1/c1_Runtime1.cpp b/src/share/vm/c1/c1_Runtime1.cpp
index e1a4e62b5..893611458 100644
--- a/src/share/vm/c1/c1_Runtime1.cpp
+++ b/src/share/vm/c1/c1_Runtime1.cpp
@@ -327,7 +327,7 @@ JRT_ENTRY(void, Runtime1::new_type_array(JavaThread* thread, Klass* klass, jint
   //       anymore after new_typeArray() and no GC can happen before.
   //       (This may have to change if this code changes!)
   assert(klass->is_klass(), "not a class");
-  BasicType elt_type = typeArrayKlass::cast(klass)->element_type();
+  BasicType elt_type = TypeArrayKlass::cast(klass)->element_type();
   oop obj = oopFactory::new_typeArray(elt_type, length, CHECK);
   thread->set_vm_result(obj);
   // This is pretty rare but this runtime patch is stressful to deoptimization
@@ -346,7 +346,7 @@ JRT_ENTRY(void, Runtime1::new_object_array(JavaThread* thread, Klass* array_klas
   //       anymore after new_objArray() and no GC can happen before.
   //       (This may have to change if this code changes!)
   assert(array_klass->is_klass(), "not a class");
-  Klass* elem_klass = objArrayKlass::cast(array_klass)->element_klass();
+  Klass* elem_klass = ObjArrayKlass::cast(array_klass)->element_klass();
   objArrayOop obj = oopFactory::new_objArray(elem_klass, length, CHECK);
   thread->set_vm_result(obj);
   // This is pretty rare but this runtime patch is stressful to deoptimization
@@ -362,7 +362,7 @@ JRT_ENTRY(void, Runtime1::new_multi_array(JavaThread* thread, Klass* klass, int
 
   assert(klass->is_klass(), "not a class");
   assert(rank >= 1, "rank must be nonzero");
-  oop obj = arrayKlass::cast(klass)->multi_allocate(rank, dims, CHECK);
+  oop obj = ArrayKlass::cast(klass)->multi_allocate(rank, dims, CHECK);
   thread->set_vm_result(obj);
 JRT_END
 
@@ -1234,8 +1234,8 @@ template <class T> int obj_arraycopy_work(oopDesc* src, T* src_addr,
     bs->write_ref_array((HeapWord*)dst_addr, length);
     return ac_ok;
   } else {
-    Klass* bound = objArrayKlass::cast(dst->klass())->element_klass();
-    Klass* stype = objArrayKlass::cast(src->klass())->element_klass();
+    Klass* bound = ObjArrayKlass::cast(dst->klass())->element_klass();
+    Klass* stype = ObjArrayKlass::cast(src->klass())->element_klass();
     if (stype == bound || Klass::cast(stype)->is_subtype_of(bound)) {
       // Elements are guaranteed to be subtypes, so no check necessary
       bs->write_ref_array_pre(dst_addr, length);
@@ -1263,7 +1263,7 @@ JRT_LEAF(int, Runtime1::arraycopy(oopDesc* src, int src_pos, oopDesc* dst, int d
   if (src->is_typeArray()) {
     Klass* const klass_oop = src->klass();
     if (klass_oop != dst->klass()) return ac_failed;
-    typeArrayKlass* klass = typeArrayKlass::cast(klass_oop);
+    TypeArrayKlass* klass = TypeArrayKlass::cast(klass_oop);
     const int l2es = klass->log2_element_size();
     const int ihs = klass->array_header_in_bytes() / wordSize;
     char* src_addr = (char*) ((oopDesc**)src + ihs) + (src_pos << l2es);
diff --git a/src/share/vm/ci/ciArrayKlass.cpp b/src/share/vm/ci/ciArrayKlass.cpp
index b280cfb03..7d2d19774 100644
--- a/src/share/vm/ci/ciArrayKlass.cpp
+++ b/src/share/vm/ci/ciArrayKlass.cpp
@@ -31,7 +31,7 @@
 // ciArrayKlass
 //
 // This class represents a Klass* in the HotSpot virtual machine
-// whose Klass part in an arrayKlass.
+// whose Klass part in an ArrayKlass.
 
 // ------------------------------------------------------------------
 // ciArrayKlass::ciArrayKlass
@@ -39,7 +39,7 @@
 // Loaded array klass.
 ciArrayKlass::ciArrayKlass(KlassHandle h_k) : ciKlass(h_k) {
   assert(get_Klass()->oop_is_array(), "wrong type");
-  _dimension = get_arrayKlass()->dimension();
+  _dimension = get_ArrayKlass()->dimension();
 }
 
 // ------------------------------------------------------------------
diff --git a/src/share/vm/ci/ciArrayKlass.hpp b/src/share/vm/ci/ciArrayKlass.hpp
index 5451327c9..da749cdc6 100644
--- a/src/share/vm/ci/ciArrayKlass.hpp
+++ b/src/share/vm/ci/ciArrayKlass.hpp
@@ -30,7 +30,7 @@
 // ciArrayKlass
 //
 // This class, and its subclasses represent Klass*s in the
-// HotSpot virtual machine whose Klass part is an arrayKlass.
+// HotSpot virtual machine whose Klass part is an ArrayKlass.
 class ciArrayKlass : public ciKlass {
   CI_PACKAGE_ACCESS
 private:
@@ -40,8 +40,8 @@ protected:
   ciArrayKlass(KlassHandle h_k);
   ciArrayKlass(ciSymbol* name, int dimension, BasicType bt);
 
-  arrayKlass* get_arrayKlass() {
-    return (arrayKlass*)get_Klass();
+  ArrayKlass* get_ArrayKlass() {
+    return (ArrayKlass*)get_Klass();
   }
 
   const char* type_string() { return "ciArrayKlass"; }
@@ -53,7 +53,7 @@ public:
   bool is_leaf_type();          // No subtypes of this array type.
 
   ciInstance* component_mirror() {
-    // This is a real field in arrayKlass, but we derive it from element_type.
+    // This is a real field in ArrayKlass, but we derive it from element_type.
     return element_type()->java_mirror();
   }
 
diff --git a/src/share/vm/ci/ciEnv.cpp b/src/share/vm/ci/ciEnv.cpp
index a895e97d0..62bc2ac59 100644
--- a/src/share/vm/ci/ciEnv.cpp
+++ b/src/share/vm/ci/ciEnv.cpp
@@ -326,7 +326,7 @@ bool ciEnv::check_klass_accessibility(ciKlass* accessing_klass,
 
   if (resolved_klass->oop_is_objArray()) {
     // Find the element klass, if this is an array.
-    resolved_klass = objArrayKlass::cast(resolved_klass)->bottom_klass();
+    resolved_klass = ObjArrayKlass::cast(resolved_klass)->bottom_klass();
   }
   if (resolved_klass->oop_is_instance()) {
     return Reflection::verify_class_access(accessing_klass->get_Klass(),
diff --git a/src/share/vm/ci/ciKlass.hpp b/src/share/vm/ci/ciKlass.hpp
index edf192f3d..d378059fc 100644
--- a/src/share/vm/ci/ciKlass.hpp
+++ b/src/share/vm/ci/ciKlass.hpp
@@ -33,7 +33,7 @@
 // HotSpot virtual machine.  In the vm, each Klass* contains an
 // embedded Klass object.  ciKlass is subclassed to explicitly
 // represent the kind of Klass embedded in the Klass*.  For
-// example, a Klass* with an embedded objArrayKlass object is
+// example, a Klass* with an embedded ObjArrayKlass object is
 // represented in the ciObject hierarchy by the class
 // ciObjArrayKlass.
 class ciKlass : public ciType {
diff --git a/src/share/vm/ci/ciObjArrayKlass.cpp b/src/share/vm/ci/ciObjArrayKlass.cpp
index 18097b8eb..3ccb54eac 100644
--- a/src/share/vm/ci/ciObjArrayKlass.cpp
+++ b/src/share/vm/ci/ciObjArrayKlass.cpp
@@ -32,7 +32,7 @@
 // ciObjArrayKlass
 //
 // This class represents a Klass* in the HotSpot virtual machine
-// whose Klass part is an objArrayKlass.
+// whose Klass part is an ObjArrayKlass.
 
 // ------------------------------------------------------------------
 // ciObjArrayKlass::ciObjArrayKlass
@@ -40,7 +40,7 @@
 // Constructor for loaded object array klasses.
 ciObjArrayKlass::ciObjArrayKlass(KlassHandle h_k) : ciArrayKlass(h_k) {
   assert(get_Klass()->oop_is_objArray(), "wrong type");
-  Klass* element_Klass = get_objArrayKlass()->bottom_klass();
+  Klass* element_Klass = get_ObjArrayKlass()->bottom_klass();
   _base_element_klass = CURRENT_ENV->get_klass(element_Klass);
   assert(_base_element_klass->is_instance_klass() ||
          _base_element_klass->is_type_array_klass(), "bad base klass");
@@ -83,7 +83,7 @@ ciKlass* ciObjArrayKlass::element_klass() {
     // Produce the element klass.
     if (is_loaded()) {
       VM_ENTRY_MARK;
-      Klass* element_Klass = get_objArrayKlass()->element_klass();
+      Klass* element_Klass = get_ObjArrayKlass()->element_klass();
       _element_klass = CURRENT_THREAD_ENV->get_klass(element_Klass);
     } else {
       VM_ENTRY_MARK;
diff --git a/src/share/vm/ci/ciObjArrayKlass.hpp b/src/share/vm/ci/ciObjArrayKlass.hpp
index bc4cb792b..ffbf85028 100644
--- a/src/share/vm/ci/ciObjArrayKlass.hpp
+++ b/src/share/vm/ci/ciObjArrayKlass.hpp
@@ -30,7 +30,7 @@
 // ciObjArrayKlass
 //
 // This class represents a Klass* in the HotSpot virtual machine
-// whose Klass part is an objArrayKlass.
+// whose Klass part is an ObjArrayKlass.
 class ciObjArrayKlass : public ciArrayKlass {
   CI_PACKAGE_ACCESS
   friend class ciEnv;
@@ -45,8 +45,8 @@ protected:
                   ciKlass* base_element_klass,
                   int dimension);
 
-  objArrayKlass* get_objArrayKlass() {
-    return (objArrayKlass*)get_Klass();
+  ObjArrayKlass* get_ObjArrayKlass() {
+    return (ObjArrayKlass*)get_Klass();
   }
 
   static ciObjArrayKlass* make_impl(ciKlass* element_klass);
diff --git a/src/share/vm/ci/ciObjectFactory.cpp b/src/share/vm/ci/ciObjectFactory.cpp
index 2ca0c4443..dd72b84a9 100644
--- a/src/share/vm/ci/ciObjectFactory.cpp
+++ b/src/share/vm/ci/ciObjectFactory.cpp
@@ -173,7 +173,7 @@ void ciObjectFactory::init_shared_objects() {
   }
 
   ciEnv::_unloaded_cisymbol = ciObjectFactory::get_symbol(vmSymbols::dummy_symbol());
-  // Create dummy InstanceKlass and objArrayKlass object and assign them idents
+  // Create dummy InstanceKlass and ObjArrayKlass object and assign them idents
   ciEnv::_unloaded_ciinstance_klass = new (_arena) ciInstanceKlass(ciEnv::_unloaded_cisymbol, NULL, NULL);
   init_ident_of(ciEnv::_unloaded_ciinstance_klass);
   ciEnv::_unloaded_ciobjarrayklass = new (_arena) ciObjArrayKlass(ciEnv::_unloaded_cisymbol, ciEnv::_unloaded_ciinstance_klass, 1);
@@ -451,7 +451,7 @@ ciKlass* ciObjectFactory::get_unloaded_klass(ciKlass* accessing_klass,
   // the cache.
   ciKlass* new_klass = NULL;
 
-  // Two cases: this is an unloaded objArrayKlass or an
+  // Two cases: this is an unloaded ObjArrayKlass or an
   // unloaded InstanceKlass.  Deal with both.
   if (name->byte_at(0) == '[') {
     // Decompose the name.'
@@ -477,7 +477,7 @@ ciKlass* ciObjectFactory::get_unloaded_klass(ciKlass* accessing_klass,
       // The type array itself takes care of one of the dimensions.
       dimension--;
 
-      // The element klass is a typeArrayKlass.
+      // The element klass is a TypeArrayKlass.
       element_klass = ciTypeArrayKlass::make(element_type);
     }
     new_klass = new (arena()) ciObjArrayKlass(name, element_klass, dimension);
diff --git a/src/share/vm/ci/ciTypeArrayKlass.cpp b/src/share/vm/ci/ciTypeArrayKlass.cpp
index 486785f43..991fc2831 100644
--- a/src/share/vm/ci/ciTypeArrayKlass.cpp
+++ b/src/share/vm/ci/ciTypeArrayKlass.cpp
@@ -35,7 +35,7 @@
 // ciTypeArrayKlass::ciTypeArrayKlass
 ciTypeArrayKlass::ciTypeArrayKlass(KlassHandle h_k) : ciArrayKlass(h_k) {
   assert(get_Klass()->oop_is_typeArray(), "wrong type");
-  assert(element_type() == get_typeArrayKlass()->element_type(), "");
+  assert(element_type() == get_TypeArrayKlass()->element_type(), "");
 }
 
 // ------------------------------------------------------------------
diff --git a/src/share/vm/ci/ciTypeArrayKlass.hpp b/src/share/vm/ci/ciTypeArrayKlass.hpp
index 6272ab838..5a57f74c4 100644
--- a/src/share/vm/ci/ciTypeArrayKlass.hpp
+++ b/src/share/vm/ci/ciTypeArrayKlass.hpp
@@ -37,8 +37,8 @@ class ciTypeArrayKlass : public ciArrayKlass {
 protected:
   ciTypeArrayKlass(KlassHandle h_k);
 
-  typeArrayKlass* get_typeArrayKlass() {
-    return (typeArrayKlass*)get_Klass();
+  TypeArrayKlass* get_TypeArrayKlass() {
+    return (TypeArrayKlass*)get_Klass();
   }
 
   const char* type_string() { return "ciTypeArrayKlass"; }
diff --git a/src/share/vm/classfile/classFileParser.cpp b/src/share/vm/classfile/classFileParser.cpp
index 5dcd87cc3..5d260d564 100644
--- a/src/share/vm/classfile/classFileParser.cpp
+++ b/src/share/vm/classfile/classFileParser.cpp
@@ -782,7 +782,7 @@ bool put_after_lookup(Symbol* name, Symbol* sig, NameSigHash** table) {
 
 Array<Klass*>* ClassFileParser::parse_interfaces(constantPoolHandle cp,
                                                  int length,
-                                                   ClassLoaderData* loader_data,
+                                                 ClassLoaderData* loader_data,
                                                  Handle protection_domain,
                                                  Symbol* class_name,
                                                  TRAPS) {
@@ -1072,10 +1072,11 @@ class FieldAllocationCount: public ResourceObj {
 
 Array<u2>* ClassFileParser::parse_fields(ClassLoaderData* loader_data,
                                          Symbol* class_name,
-                                              constantPoolHandle cp, bool is_interface,
-                                              FieldAllocationCount *fac,
+                                         constantPoolHandle cp,
+                                         bool is_interface,
+                                         FieldAllocationCount *fac,
                                          Array<AnnotationArray*>** fields_annotations,
-                                              u2* java_fields_count_ptr, TRAPS) {
+                                         u2* java_fields_count_ptr, TRAPS) {
   ClassFileStream* cfs = stream();
   cfs->guarantee_more(2, CHECK_NULL);  // length
   u2 length = cfs->get_u2_fast();
@@ -2169,14 +2170,12 @@ methodHandle ClassFileParser::parse_method(ClassLoaderData* loader_data,
   }
 
   // All sizing information for a Method* is finally available, now create it
-  Method* m = Method::allocate(loader_data,
-                                        code_length,
-                                        access_flags,
-                                            linenumber_table_length,
-                                            total_lvt_length,
-                                            exception_table_length,
-                                            checked_exceptions_length,
-                                            CHECK_(nullHandle));
+  Method* m = Method::allocate(loader_data, code_length, access_flags,
+                               linenumber_table_length,
+                               total_lvt_length,
+                               exception_table_length,
+                               checked_exceptions_length,
+                               CHECK_(nullHandle));
 
   ClassLoadingService::add_class_method_size(m->size()*HeapWordSize);
 
@@ -2351,14 +2350,14 @@ methodHandle ClassFileParser::parse_method(ClassLoaderData* loader_data,
 // are added to klass's access_flags.
 
 Array<Method*>* ClassFileParser::parse_methods(ClassLoaderData* loader_data,
-                                                 constantPoolHandle cp,
-                                                 bool is_interface,
-                                              AccessFlags* promoted_flags,
-                                              bool* has_final_method,
-                                                 Array<AnnotationArray*>** methods_annotations,
-                                                 Array<AnnotationArray*>** methods_parameter_annotations,
-                                                 Array<AnnotationArray*>** methods_default_annotations,
-                                              TRAPS) {
+                                               constantPoolHandle cp,
+                                               bool is_interface,
+                                               AccessFlags* promoted_flags,
+                                               bool* has_final_method,
+                                               Array<AnnotationArray*>** methods_annotations,
+                                               Array<AnnotationArray*>** methods_parameter_annotations,
+                                               Array<AnnotationArray*>** methods_default_annotations,
+                                               TRAPS) {
   ClassFileStream* cfs = stream();
   AnnotationArray* method_annotations = NULL;
   AnnotationArray* method_parameter_annotations = NULL;
@@ -2450,10 +2449,9 @@ Array<int>* ClassFileParser::sort_methods(ClassLoaderData* loader_data,
   }
   // Sort method array by ascending method name (for faster lookups & vtable construction)
   // Note that the ordering is not alphabetical, see Symbol::fast_compare
-  Method::sort_methods(methods,
-                              methods_annotations,
-                              methods_parameter_annotations,
-                              methods_default_annotations);
+  Method::sort_methods(methods, methods_annotations,
+                       methods_parameter_annotations,
+                       methods_default_annotations);
 
   // If JVMTI original method ordering or sharing is enabled construct int
   // array remembering the original ordering
@@ -2835,10 +2833,10 @@ void ClassFileParser::parse_classfile_attributes(ClassLoaderData* loader_data,
   }
   AnnotationArray* annotations = assemble_annotations(loader_data,
                                                       runtime_visible_annotations,
-                                                     runtime_visible_annotations_length,
-                                                     runtime_invisible_annotations,
-                                                     runtime_invisible_annotations_length,
-                                                     CHECK);
+                                                      runtime_visible_annotations_length,
+                                                      runtime_invisible_annotations,
+                                                      runtime_invisible_annotations_length,
+                                                      CHECK);
   set_class_annotations(annotations);
 
   if (parsed_innerclasses_attribute || parsed_enclosingmethod_attribute) {
@@ -2884,9 +2882,9 @@ void ClassFileParser::apply_parsed_class_attributes(instanceKlassHandle k) {
 
 AnnotationArray* ClassFileParser::assemble_annotations(ClassLoaderData* loader_data,
                                                        u1* runtime_visible_annotations,
-                                                      int runtime_visible_annotations_length,
-                                                      u1* runtime_invisible_annotations,
-                                                      int runtime_invisible_annotations_length, TRAPS) {
+                                                       int runtime_visible_annotations_length,
+                                                       u1* runtime_invisible_annotations,
+                                                       int runtime_invisible_annotations_length, TRAPS) {
   AnnotationArray* annotations = NULL;
   if (runtime_visible_annotations != NULL ||
       runtime_invisible_annotations != NULL) {
@@ -3161,13 +3159,13 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
     Array<AnnotationArray*>* methods_parameter_annotations = NULL;
     Array<AnnotationArray*>* methods_default_annotations = NULL;
     Array<Method*>* methods = parse_methods(loader_data,
-                                              cp, access_flags.is_interface(),
-                                           &promoted_flags,
-                                           &has_final_method,
-                                              &methods_annotations,
-                                              &methods_parameter_annotations,
-                                              &methods_default_annotations,
-                                           CHECK_(nullHandle));
+                                            cp, access_flags.is_interface(),
+                                            &promoted_flags,
+                                            &has_final_method,
+                                            &methods_annotations,
+                                            &methods_parameter_annotations,
+                                            &methods_default_annotations,
+                                            CHECK_(nullHandle));
 
     // Additional attributes
     ClassAnnotationCollector parsed_annotations;
@@ -3186,12 +3184,11 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
                            "Interfaces must have java.lang.Object as superclass in class file %s",
                            CHECK_(nullHandle));
       }
-      Klass* k = SystemDictionary::resolve_super_or_fail(class_name,
-                                                           sk,
-                                                           class_loader,
-                                                           protection_domain,
-                                                           true,
-                                                           CHECK_(nullHandle));
+      Klass* k = SystemDictionary::resolve_super_or_fail(class_name, sk,
+                                                         class_loader,
+                                                         protection_domain,
+                                                         true,
+                                                         CHECK_(nullHandle));
 
       KlassHandle kh (THREAD, k);
       super_klass = instanceKlassHandle(THREAD, kh());
@@ -3222,10 +3219,10 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
     // sort methods
     Array<int>* method_ordering = sort_methods(loader_data,
                                                methods,
-                                                   methods_annotations,
-                                                   methods_parameter_annotations,
-                                                   methods_default_annotations,
-                                                   CHECK_(nullHandle));
+                                               methods_annotations,
+                                               methods_parameter_annotations,
+                                               methods_default_annotations,
+                                               CHECK_(nullHandle));
 
     // promote flags from parse_methods() to the klass' flags
     access_flags.add_promoted_flags(promoted_flags.as_int());
@@ -3591,16 +3588,16 @@ instanceKlassHandle ClassFileParser::parseClassFile(Symbol* name,
       InstanceKlass::nonstatic_oop_map_size(total_oop_map_count);
 
     Klass* ik = InstanceKlass::allocate_instance_klass(loader_data,
-                                                         vtable_size,
-                                                         itable_size,
-                                                static_field_size,
-                                                         total_oop_map_size2,
-                                                         rt,
-                                                access_flags,
-                                                         name,
-                                                         super_klass(),
-                                                         host_klass,
-                                                CHECK_(nullHandle));
+                                                       vtable_size,
+                                                       itable_size,
+                                                       static_field_size,
+                                                       total_oop_map_size2,
+                                                       rt,
+                                                       access_flags,
+                                                       name,
+                                                       super_klass(),
+                                                       host_klass,
+                                                       CHECK_(nullHandle));
 
     // Add all classes to our internal class loader list here,
     // including classes in the bootstrap (NULL) class loader.
diff --git a/src/share/vm/classfile/classFileParser.hpp b/src/share/vm/classfile/classFileParser.hpp
index 17106125a..922547757 100644
--- a/src/share/vm/classfile/classFileParser.hpp
+++ b/src/share/vm/classfile/classFileParser.hpp
@@ -148,7 +148,7 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC {
   // Interface parsing
   Array<Klass*>* parse_interfaces(constantPoolHandle cp,
                                   int length,
-                                    ClassLoaderData* loader_data,
+                                  ClassLoaderData* loader_data,
                                   Handle protection_domain,
                                   Symbol* class_name,
                                   TRAPS);
@@ -166,10 +166,10 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC {
                               TRAPS);
   Array<u2>* parse_fields(ClassLoaderData* loader_data,
                           Symbol* class_name,
-                               constantPoolHandle cp, bool is_interface,
-                               FieldAllocationCount *fac,
+                          constantPoolHandle cp, bool is_interface,
+                          FieldAllocationCount *fac,
                           Array<AnnotationArray*>** fields_annotations,
-                               u2* java_fields_count_ptr, TRAPS);
+                          u2* java_fields_count_ptr, TRAPS);
 
   // Method parsing
   methodHandle parse_method(ClassLoaderData* loader_data,
@@ -181,13 +181,13 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC {
                             AnnotationArray** method_default_annotations,
                             TRAPS);
   Array<Method*>* parse_methods(ClassLoaderData* loader_data,
-                                  constantPoolHandle cp,
-                                  bool is_interface,
+                                constantPoolHandle cp,
+                                bool is_interface,
                                 AccessFlags* promoted_flags,
                                 bool* has_final_method,
-                                  Array<AnnotationArray*>** methods_annotations,
-                                  Array<AnnotationArray*>** methods_parameter_annotations,
-                                  Array<AnnotationArray*>** methods_default_annotations,
+                                Array<AnnotationArray*>** methods_annotations,
+                                Array<AnnotationArray*>** methods_parameter_annotations,
+                                Array<AnnotationArray*>** methods_default_annotations,
                                 TRAPS);
   Array<int>* sort_methods(ClassLoaderData* loader_data,
                            Array<Method*>* methods,
@@ -232,9 +232,9 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC {
   // Annotations handling
   AnnotationArray* assemble_annotations(ClassLoaderData* loader_data,
                                         u1* runtime_visible_annotations,
-                                       int runtime_visible_annotations_length,
-                                       u1* runtime_invisible_annotations,
-                                       int runtime_invisible_annotations_length, TRAPS);
+                                        int runtime_visible_annotations_length,
+                                        u1* runtime_invisible_annotations,
+                                        int runtime_invisible_annotations_length, TRAPS);
   int skip_annotation(u1* buffer, int limit, int index);
   int skip_annotation_value(u1* buffer, int limit, int index);
   void parse_annotations(u1* buffer, int limit, constantPoolHandle cp,
@@ -252,8 +252,8 @@ class ClassFileParser VALUE_OBJ_CLASS_SPEC {
                      unsigned int* nonstatic_oop_counts);
   void set_precomputed_flags(instanceKlassHandle k);
   Array<Klass*>* compute_transitive_interfaces(ClassLoaderData* loader_data,
-                                                 instanceKlassHandle super,
-                                                 Array<Klass*>* local_ifs, TRAPS);
+                                               instanceKlassHandle super,
+                                               Array<Klass*>* local_ifs, TRAPS);
 
   // Format checker methods
   void classfile_parse_error(const char* msg, TRAPS);
diff --git a/src/share/vm/classfile/javaClasses.cpp b/src/share/vm/classfile/javaClasses.cpp
index bf539191a..7e8c39cdd 100644
--- a/src/share/vm/classfile/javaClasses.cpp
+++ b/src/share/vm/classfile/javaClasses.cpp
@@ -540,18 +540,18 @@ oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) {
     if (k->oop_is_array()) {
       Handle comp_mirror;
       if (k->oop_is_typeArray()) {
-        BasicType type = typeArrayKlass::cast(k())->element_type();
+        BasicType type = TypeArrayKlass::cast(k())->element_type();
         comp_mirror = Universe::java_mirror(type);
       } else {
         assert(k->oop_is_objArray(), "Must be");
-        Klass* element_klass = objArrayKlass::cast(k())->element_klass();
+        Klass* element_klass = ObjArrayKlass::cast(k())->element_klass();
         assert(element_klass != NULL, "Must have an element klass");
           comp_mirror = Klass::cast(element_klass)->java_mirror();
       }
       assert(comp_mirror.not_null(), "must have a mirror");
 
         // Two-way link between the array klass and its component mirror:
-      arrayKlass::cast(k())->set_component_mirror(comp_mirror());
+      ArrayKlass::cast(k())->set_component_mirror(comp_mirror());
       set_array_klass(comp_mirror(), k());
     } else {
       assert(k->oop_is_instance(), "Must be");
@@ -704,7 +704,7 @@ bool java_lang_Class::is_primitive(oop java_class) {
 #ifdef ASSERT
   if (is_primitive) {
     Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset));
-    assert(k == NULL || is_java_primitive(arrayKlass::cast(k)->element_type()),
+    assert(k == NULL || is_java_primitive(ArrayKlass::cast(k)->element_type()),
         "Should be either the T_VOID primitive or a java primitive");
   }
 #endif
@@ -719,7 +719,7 @@ BasicType java_lang_Class::primitive_type(oop java_class) {
   BasicType type = T_VOID;
   if (ak != NULL) {
     // Note: create_basic_type_mirror above initializes ak to a non-null value.
-    type = arrayKlass::cast(ak)->element_type();
+    type = ArrayKlass::cast(ak)->element_type();
   } else {
     assert(java_class == Universe::void_mirror(), "only valid non-array primitive");
   }
@@ -846,7 +846,7 @@ void java_lang_Thread::set_thread(oop java_thread, JavaThread* thread) {
 
 typeArrayOop java_lang_Thread::name(oop java_thread) {
   oop name = java_thread->obj_field(_name_offset);
-  assert(name == NULL || (name->is_typeArray() && typeArrayKlass::cast(name->klass())->element_type() == T_CHAR), "just checking");
+  assert(name == NULL || (name->is_typeArray() && TypeArrayKlass::cast(name->klass())->element_type() == T_CHAR), "just checking");
   return typeArrayOop(name);
 }
 
diff --git a/src/share/vm/classfile/systemDictionary.cpp b/src/share/vm/classfile/systemDictionary.cpp
index 3af4219e4..ed875dada 100644
--- a/src/share/vm/classfile/systemDictionary.cpp
+++ b/src/share/vm/classfile/systemDictionary.cpp
@@ -244,7 +244,7 @@ Klass* SystemDictionary::resolve_array_class_or_null(Symbol* class_name,
     }
   } else {
     k = Universe::typeArrayKlassObj(t);
-    k = typeArrayKlass::cast(k)->array_klass(fd.dimension(), CHECK_NULL);
+    k = TypeArrayKlass::cast(k)->array_klass(fd.dimension(), CHECK_NULL);
   }
   return k;
 }
@@ -920,9 +920,9 @@ Klass* SystemDictionary::find(Symbol* class_name,
 // Look for a loaded instance or array klass by name.  Do not do any loading.
 // return NULL in case of error.
 Klass* SystemDictionary::find_instance_or_array_klass(Symbol* class_name,
-                                                        Handle class_loader,
-                                                        Handle protection_domain,
-                                                        TRAPS) {
+                                                      Handle class_loader,
+                                                      Handle protection_domain,
+                                                      TRAPS) {
   Klass* k = NULL;
   assert(class_name != NULL, "class name must be non NULL");
 
@@ -990,12 +990,12 @@ Klass* SystemDictionary::find_well_known_klass(Symbol* class_name) {
 // updates no supplemental data structures.
 // TODO consolidate the two methods with a helper routine?
 Klass* SystemDictionary::parse_stream(Symbol* class_name,
-                                        Handle class_loader,
-                                        Handle protection_domain,
-                                        ClassFileStream* st,
-                                        KlassHandle host_klass,
-                                        GrowableArray<Handle>* cp_patches,
-                                        TRAPS) {
+                                      Handle class_loader,
+                                      Handle protection_domain,
+                                      ClassFileStream* st,
+                                      KlassHandle host_klass,
+                                      GrowableArray<Handle>* cp_patches,
+                                      TRAPS) {
   TempNewSymbol parsed_name = NULL;
 
   // Parse the stream. Note that we do this even though this klass might
@@ -1076,11 +1076,11 @@ Klass* SystemDictionary::parse_stream(Symbol* class_name,
 // the class until we have parsed the stream.
 
 Klass* SystemDictionary::resolve_from_stream(Symbol* class_name,
-                                               Handle class_loader,
-                                               Handle protection_domain,
-                                               ClassFileStream* st,
-                                               bool verify,
-                                               TRAPS) {
+                                             Handle class_loader,
+                                             Handle protection_domain,
+                                             ClassFileStream* st,
+                                             bool verify,
+                                             TRAPS) {
 
   // Classloaders that support parallelism, e.g. bootstrap classloader,
   // or all classloaders with UnsyncloadClass do not acquire lock here
@@ -2187,7 +2187,7 @@ Klass* SystemDictionary::find_constrained_instance_or_array_klass(
   // Force the protection domain to be null.  (This removes protection checks.)
   Handle no_protection_domain;
   Klass* klass = find_instance_or_array_klass(class_name, class_loader,
-                                                no_protection_domain, CHECK_NULL);
+                                              no_protection_domain, CHECK_NULL);
   if (klass != NULL)
     return klass;
 
@@ -2523,7 +2523,7 @@ Handle SystemDictionary::find_method_handle_type(Symbol* signature,
       mirror = NULL;  // safety
       // Emulate ConstantPool::verify_constant_pool_resolve.
       if (Klass::cast(sel_klass)->oop_is_objArray())
-        sel_klass = objArrayKlass::cast(sel_klass)->bottom_klass();
+        sel_klass = ObjArrayKlass::cast(sel_klass)->bottom_klass();
       if (Klass::cast(sel_klass)->oop_is_instance()) {
         KlassHandle sel_kh(THREAD, sel_klass);
         LinkResolver::check_klass_accessability(accessing_klass, sel_kh, CHECK_(empty));
diff --git a/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp b/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp
index fd71e4a6c..7b9ff1650 100644
--- a/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp
+++ b/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp
@@ -204,7 +204,7 @@ void StealMarkingTask::do_it(GCTaskManager* manager, uint which) {
   int random_seed = 17;
   do {
     while (ParCompactionManager::steal_objarray(which, &random_seed, task)) {
-      objArrayKlass* const k = (objArrayKlass*)task.obj()->klass();
+      ObjArrayKlass* const k = (ObjArrayKlass*)task.obj()->klass();
       k->oop_follow_contents(cm, task.obj(), task.index());
       cm->follow_marking_stacks();
     }
diff --git a/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp b/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp
index b08c93076..62c578f33 100644
--- a/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp
+++ b/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp
@@ -188,10 +188,10 @@ void ParCompactionManager::follow_marking_stacks() {
     // Process ObjArrays one at a time to avoid marking stack bloat.
     ObjArrayTask task;
     if (_objarray_stack.pop_overflow(task)) {
-      objArrayKlass* const k = (objArrayKlass*)task.obj()->klass();
+      ObjArrayKlass* const k = (ObjArrayKlass*)task.obj()->klass();
       k->oop_follow_contents(this, task.obj(), task.index());
     } else if (_objarray_stack.pop_local(task)) {
-      objArrayKlass* const k = (objArrayKlass*)task.obj()->klass();
+      ObjArrayKlass* const k = (ObjArrayKlass*)task.obj()->klass();
       k->oop_follow_contents(this, task.obj(), task.index());
     }
   } while (!marking_stacks_empty());
diff --git a/src/share/vm/gc_implementation/shared/markSweep.cpp b/src/share/vm/gc_implementation/shared/markSweep.cpp
index 9c4b22e78..bbbd1a055 100644
--- a/src/share/vm/gc_implementation/shared/markSweep.cpp
+++ b/src/share/vm/gc_implementation/shared/markSweep.cpp
@@ -115,7 +115,7 @@ void MarkSweep::follow_stack() {
     // Process ObjArrays one at a time to avoid marking stack bloat.
     if (!_objarray_stack.is_empty()) {
       ObjArrayTask task = _objarray_stack.pop();
-      objArrayKlass* const k = (objArrayKlass*)task.obj()->klass();
+      ObjArrayKlass* const k = (ObjArrayKlass*)task.obj()->klass();
       k->oop_follow_contents(task.obj(), task.index());
     }
   } while (!_marking_stack.is_empty() || !_objarray_stack.is_empty());
diff --git a/src/share/vm/interpreter/bytecodeInterpreter.cpp b/src/share/vm/interpreter/bytecodeInterpreter.cpp
index e74826847..6c18761db 100644
--- a/src/share/vm/interpreter/bytecodeInterpreter.cpp
+++ b/src/share/vm/interpreter/bytecodeInterpreter.cpp
@@ -1626,7 +1626,7 @@ run:
           if (rhsObject != NULL) {
             /* Check assignability of rhsObject into arrObj */
             Klass* rhsKlassOop = rhsObject->klass(); // EBX (subclass)
-            Klass* elemKlassOop = objArrayKlass::cast(arrObj->klass())->element_klass(); // superklass EAX
+            Klass* elemKlassOop = ObjArrayKlass::cast(arrObj->klass())->element_klass(); // superklass EAX
             //
             // Check for compatibilty. This check must not GC!!
             // Seems way more expensive now that we must dispatch
diff --git a/src/share/vm/interpreter/interpreterRuntime.cpp b/src/share/vm/interpreter/interpreterRuntime.cpp
index d5ba01d8e..df5361a77 100644
--- a/src/share/vm/interpreter/interpreterRuntime.cpp
+++ b/src/share/vm/interpreter/interpreterRuntime.cpp
@@ -211,7 +211,7 @@ IRT_ENTRY(void, InterpreterRuntime::multianewarray(JavaThread* thread, jint* fir
     int n = Interpreter::local_offset_in_bytes(index)/jintSize;
     dims[index] = first_size_address[n];
   }
-  oop obj = arrayKlass::cast(klass)->multi_allocate(nof_dims, dims, CHECK);
+  oop obj = ArrayKlass::cast(klass)->multi_allocate(nof_dims, dims, CHECK);
   thread->set_vm_result(obj);
 IRT_END
 
diff --git a/src/share/vm/memory/oopFactory.cpp b/src/share/vm/memory/oopFactory.cpp
index 996022e4c..8318e3bf0 100644
--- a/src/share/vm/memory/oopFactory.cpp
+++ b/src/share/vm/memory/oopFactory.cpp
@@ -47,12 +47,12 @@ typeArrayOop oopFactory::new_charArray(const char* utf8_str, TRAPS) {
 }
 
 typeArrayOop oopFactory::new_tenured_charArray(int length, TRAPS) {
-  return typeArrayKlass::cast(Universe::charArrayKlassObj())->allocate(length, THREAD);
+  return TypeArrayKlass::cast(Universe::charArrayKlassObj())->allocate(length, THREAD);
 }
 
 typeArrayOop oopFactory::new_typeArray(BasicType type, int length, TRAPS) {
   Klass* type_asKlassOop = Universe::typeArrayKlassObj(type);
-  typeArrayKlass* type_asArrayKlass = typeArrayKlass::cast(type_asKlassOop);
+  TypeArrayKlass* type_asArrayKlass = TypeArrayKlass::cast(type_asKlassOop);
   typeArrayOop result = type_asArrayKlass->allocate(length, THREAD);
   return result;
 }
@@ -66,14 +66,14 @@ typeArrayOop oopFactory::new_typeArray(BasicType type, int length, TRAPS) {
 typeArrayOop oopFactory::new_metaDataArray(int length, TRAPS) {
   BasicType type = LP64_ONLY(T_LONG) NOT_LP64(T_INT);
   Klass* type_asKlassOop = Universe::typeArrayKlassObj(type);
-  typeArrayKlass* type_asArrayKlass = typeArrayKlass::cast(type_asKlassOop);
+  TypeArrayKlass* type_asArrayKlass = TypeArrayKlass::cast(type_asKlassOop);
   typeArrayOop result = type_asArrayKlass->allocate_common(length, true, THREAD);
   return result;
 }
 
 typeArrayOop oopFactory::new_typeArray_nozero(BasicType type, int length, TRAPS) {
   Klass* type_asKlassOop = Universe::typeArrayKlassObj(type);
-  typeArrayKlass* type_asArrayKlass = typeArrayKlass::cast(type_asKlassOop);
+  TypeArrayKlass* type_asArrayKlass = TypeArrayKlass::cast(type_asKlassOop);
   typeArrayOop result = type_asArrayKlass->allocate_common(length, false, THREAD);
   return result;
 }
@@ -82,7 +82,7 @@ typeArrayOop oopFactory::new_typeArray_nozero(BasicType type, int length, TRAPS)
 objArrayOop oopFactory::new_objArray(Klass* klass, int length, TRAPS) {
   assert(klass->is_klass(), "must be instance class");
   if (klass->oop_is_array()) {
-    return ((arrayKlass*)klass)->allocate_arrayArray(1, length, THREAD);
+    return ((ArrayKlass*)klass)->allocate_arrayArray(1, length, THREAD);
   } else {
     assert (klass->oop_is_instance(), "new object array with klass not an InstanceKlass");
     return ((InstanceKlass*)klass)->allocate_objArray(1, length, THREAD);
diff --git a/src/share/vm/memory/oopFactory.hpp b/src/share/vm/memory/oopFactory.hpp
index 60c0e24c0..bd0346690 100644
--- a/src/share/vm/memory/oopFactory.hpp
+++ b/src/share/vm/memory/oopFactory.hpp
@@ -40,19 +40,19 @@ class vframeArray;
 class oopFactory: AllStatic {
  public:
   // Basic type leaf array allocation
-  static typeArrayOop    new_boolArray  (int length, TRAPS) { return typeArrayKlass::cast(Universe::boolArrayKlassObj  ())->allocate(length, CHECK_NULL); }
-  static typeArrayOop    new_charArray  (int length, TRAPS) { return typeArrayKlass::cast(Universe::charArrayKlassObj  ())->allocate(length, CHECK_NULL); }
-  static typeArrayOop    new_singleArray(int length, TRAPS) { return typeArrayKlass::cast(Universe::singleArrayKlassObj())->allocate(length, CHECK_NULL); }
-  static typeArrayOop    new_doubleArray(int length, TRAPS) { return typeArrayKlass::cast(Universe::doubleArrayKlassObj())->allocate(length, CHECK_NULL); }
-  static typeArrayOop    new_byteArray  (int length, TRAPS) { return typeArrayKlass::cast(Universe::byteArrayKlassObj  ())->allocate(length, CHECK_NULL); }
-  static typeArrayOop    new_shortArray (int length, TRAPS) { return typeArrayKlass::cast(Universe::shortArrayKlassObj ())->allocate(length, CHECK_NULL); }
-  static typeArrayOop    new_intArray   (int length, TRAPS) { return typeArrayKlass::cast(Universe::intArrayKlassObj   ())->allocate(length, CHECK_NULL); }
-  static typeArrayOop    new_longArray  (int length, TRAPS) { return typeArrayKlass::cast(Universe::longArrayKlassObj  ())->allocate(length, CHECK_NULL); }
+  static typeArrayOop    new_boolArray  (int length, TRAPS) { return TypeArrayKlass::cast(Universe::boolArrayKlassObj  ())->allocate(length, CHECK_NULL); }
+  static typeArrayOop    new_charArray  (int length, TRAPS) { return TypeArrayKlass::cast(Universe::charArrayKlassObj  ())->allocate(length, CHECK_NULL); }
+  static typeArrayOop    new_singleArray(int length, TRAPS) { return TypeArrayKlass::cast(Universe::singleArrayKlassObj())->allocate(length, CHECK_NULL); }
+  static typeArrayOop    new_doubleArray(int length, TRAPS) { return TypeArrayKlass::cast(Universe::doubleArrayKlassObj())->allocate(length, CHECK_NULL); }
+  static typeArrayOop    new_byteArray  (int length, TRAPS) { return TypeArrayKlass::cast(Universe::byteArrayKlassObj  ())->allocate(length, CHECK_NULL); }
+  static typeArrayOop    new_shortArray (int length, TRAPS) { return TypeArrayKlass::cast(Universe::shortArrayKlassObj ())->allocate(length, CHECK_NULL); }
+  static typeArrayOop    new_intArray   (int length, TRAPS) { return TypeArrayKlass::cast(Universe::intArrayKlassObj   ())->allocate(length, CHECK_NULL); }
+  static typeArrayOop    new_longArray  (int length, TRAPS) { return TypeArrayKlass::cast(Universe::longArrayKlassObj  ())->allocate(length, CHECK_NULL); }
 
   // create java.lang.Object[]
   static objArrayOop     new_objectArray(int length, TRAPS)  {
     assert(Universe::objectArrayKlassObj() != NULL, "Too early?");
-    return objArrayKlass::
+    return ObjArrayKlass::
       cast(Universe::objectArrayKlassObj())->allocate(length, CHECK_NULL);
   }
 
diff --git a/src/share/vm/memory/specialized_oop_closures.hpp b/src/share/vm/memory/specialized_oop_closures.hpp
index 8c0b8fe45..a13660d40 100644
--- a/src/share/vm/memory/specialized_oop_closures.hpp
+++ b/src/share/vm/memory/specialized_oop_closures.hpp
@@ -200,7 +200,7 @@ public:
   enum Kind {
     ik,             // InstanceKlass
     irk,            // InstanceRefKlass
-    oa,             // objArrayKlass
+    oa,             // ObjArrayKlass
     NUM_Kinds
   };
 
diff --git a/src/share/vm/memory/universe.cpp b/src/share/vm/memory/universe.cpp
index b2398259f..f8e733bb4 100644
--- a/src/share/vm/memory/universe.cpp
+++ b/src/share/vm/memory/universe.cpp
@@ -265,14 +265,14 @@ void Universe::genesis(TRAPS) {
       compute_base_vtable_size();
 
       if (!UseSharedSpaces) {
-        _boolArrayKlassObj      = typeArrayKlass::create_klass(T_BOOLEAN, sizeof(jboolean), CHECK);
-        _charArrayKlassObj      = typeArrayKlass::create_klass(T_CHAR,    sizeof(jchar),    CHECK);
-        _singleArrayKlassObj    = typeArrayKlass::create_klass(T_FLOAT,   sizeof(jfloat),   CHECK);
-        _doubleArrayKlassObj    = typeArrayKlass::create_klass(T_DOUBLE,  sizeof(jdouble),  CHECK);
-        _byteArrayKlassObj      = typeArrayKlass::create_klass(T_BYTE,    sizeof(jbyte),    CHECK);
-        _shortArrayKlassObj     = typeArrayKlass::create_klass(T_SHORT,   sizeof(jshort),   CHECK);
-        _intArrayKlassObj       = typeArrayKlass::create_klass(T_INT,     sizeof(jint),     CHECK);
-        _longArrayKlassObj      = typeArrayKlass::create_klass(T_LONG,    sizeof(jlong),    CHECK);
+        _boolArrayKlassObj      = TypeArrayKlass::create_klass(T_BOOLEAN, sizeof(jboolean), CHECK);
+        _charArrayKlassObj      = TypeArrayKlass::create_klass(T_CHAR,    sizeof(jchar),    CHECK);
+        _singleArrayKlassObj    = TypeArrayKlass::create_klass(T_FLOAT,   sizeof(jfloat),   CHECK);
+        _doubleArrayKlassObj    = TypeArrayKlass::create_klass(T_DOUBLE,  sizeof(jdouble),  CHECK);
+        _byteArrayKlassObj      = TypeArrayKlass::create_klass(T_BYTE,    sizeof(jbyte),    CHECK);
+        _shortArrayKlassObj     = TypeArrayKlass::create_klass(T_SHORT,   sizeof(jshort),   CHECK);
+        _intArrayKlassObj       = TypeArrayKlass::create_klass(T_INT,     sizeof(jint),     CHECK);
+        _longArrayKlassObj      = TypeArrayKlass::create_klass(T_LONG,    sizeof(jlong),    CHECK);
 
         _typeArrayKlassObjs[T_BOOLEAN] = _boolArrayKlassObj;
         _typeArrayKlassObjs[T_CHAR]    = _charArrayKlassObj;
@@ -440,8 +440,8 @@ void Universe::init_self_patching_vtbl_list(void** list, int count) {
   { InstanceClassLoaderKlass o; add_vtable(list, &n, &o, count); }
   { InstanceMirrorKlass o;    add_vtable(list, &n, &o, count); }
   { InstanceRefKlass o;       add_vtable(list, &n, &o, count); }
-  { typeArrayKlass o;         add_vtable(list, &n, &o, count); }
-  { objArrayKlass o;          add_vtable(list, &n, &o, count); }
+  { TypeArrayKlass o;         add_vtable(list, &n, &o, count); }
+  { ObjArrayKlass o;          add_vtable(list, &n, &o, count); }
   { Method o;                 add_vtable(list, &n, &o, count); }
   { ConstantPool o;           add_vtable(list, &n, &o, count); }
 }
diff --git a/src/share/vm/oops/arrayKlass.cpp b/src/share/vm/oops/arrayKlass.cpp
index 89191ab7b..781c89453 100644
--- a/src/share/vm/oops/arrayKlass.cpp
+++ b/src/share/vm/oops/arrayKlass.cpp
@@ -36,7 +36,7 @@
 #include "oops/objArrayOop.hpp"
 #include "oops/oop.inline.hpp"
 
-int arrayKlass::static_size(int header_size) {
+int ArrayKlass::static_size(int header_size) {
   // size of an array klass object
   assert(header_size <= InstanceKlass::header_size(), "bad header size");
   // If this assert fails, see comments in base_create_array_klass.
@@ -51,7 +51,7 @@ int arrayKlass::static_size(int header_size) {
 }
 
 
-Klass* arrayKlass::java_super() const {
+Klass* ArrayKlass::java_super() const {
   if (super() == NULL)  return NULL;  // bootstrap case
   // Array klasses have primary supertypes which are not reported to Java.
   // Example super chain:  String[][] -> Object[][] -> Object[] -> Object
@@ -59,18 +59,18 @@ Klass* arrayKlass::java_super() const {
 }
 
 
-oop arrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
+oop ArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
   ShouldNotReachHere();
   return NULL;
 }
 
-Method* arrayKlass::uncached_lookup_method(Symbol* name, Symbol* signature) const {
+Method* ArrayKlass::uncached_lookup_method(Symbol* name, Symbol* signature) const {
   // There are no methods in an array klass but the super class (Object) has some
   assert(super(), "super klass must be present");
   return Klass::cast(super())->uncached_lookup_method(name, signature);
 }
 
-arrayKlass::arrayKlass(Symbol* name) {
+ArrayKlass::ArrayKlass(Symbol* name) {
   set_alloc_size(0);
   set_name(name);
 
@@ -89,15 +89,15 @@ arrayKlass::arrayKlass(Symbol* name) {
 
 
 // Initialization of vtables and mirror object is done separatly from base_create_array_klass,
-// since a GC can happen. At this point all instance variables of the arrayKlass must be setup.
-void arrayKlass::complete_create_array_klass(arrayKlass* k, KlassHandle super_klass, TRAPS) {
+// since a GC can happen. At this point all instance variables of the ArrayKlass must be setup.
+void ArrayKlass::complete_create_array_klass(ArrayKlass* k, KlassHandle super_klass, TRAPS) {
   ResourceMark rm(THREAD);
   k->initialize_supers(super_klass(), CHECK);
   k->vtable()->initialize_vtable(false, CHECK);
   java_lang_Class::create_mirror(k, CHECK);
 }
 
-GrowableArray<Klass*>* arrayKlass::compute_secondary_supers(int num_extra_slots) {
+GrowableArray<Klass*>* ArrayKlass::compute_secondary_supers(int num_extra_slots) {
   // interfaces = { cloneable_klass, serializable_klass };
   assert(num_extra_slots == 0, "sanity of primitive array type");
   // Must share this for correct bootstrapping!
@@ -105,7 +105,7 @@ GrowableArray<Klass*>* arrayKlass::compute_secondary_supers(int num_extra_slots)
   return NULL;
 }
 
-bool arrayKlass::compute_is_subtype_of(Klass* k) {
+bool ArrayKlass::compute_is_subtype_of(Klass* k) {
   // An array is a subtype of Serializable, Clonable, and Object
   return    k == SystemDictionary::Object_klass()
          || k == SystemDictionary::Cloneable_klass()
@@ -113,19 +113,19 @@ bool arrayKlass::compute_is_subtype_of(Klass* k) {
 }
 
 
-inline intptr_t* arrayKlass::start_of_vtable() const {
+inline intptr_t* ArrayKlass::start_of_vtable() const {
   // all vtables start at the same place, that's why we use InstanceKlass::header_size here
   return ((intptr_t*)this) + InstanceKlass::header_size();
 }
 
 
-klassVtable* arrayKlass::vtable() const {
+klassVtable* ArrayKlass::vtable() const {
   KlassHandle kh(Thread::current(), this);
   return new klassVtable(kh, start_of_vtable(), vtable_length() / vtableEntry::size());
 }
 
 
-objArrayOop arrayKlass::allocate_arrayArray(int n, int length, TRAPS) {
+objArrayOop ArrayKlass::allocate_arrayArray(int n, int length, TRAPS) {
   if (length < 0) {
     THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
   }
@@ -136,40 +136,40 @@ objArrayOop arrayKlass::allocate_arrayArray(int n, int length, TRAPS) {
   }
   int size = objArrayOopDesc::object_size(length);
   Klass* k = array_klass(n+dimension(), CHECK_0);
-  arrayKlass* ak = arrayKlass::cast(k);
+  ArrayKlass* ak = ArrayKlass::cast(k);
   objArrayOop o =
     (objArrayOop)CollectedHeap::array_allocate(ak, size, length, CHECK_0);
   // initialization to NULL not necessary, area already cleared
   return o;
 }
 
-void arrayKlass::array_klasses_do(void f(Klass* k, TRAPS), TRAPS) {
+void ArrayKlass::array_klasses_do(void f(Klass* k, TRAPS), TRAPS) {
   Klass* k = this;
   // Iterate over this array klass and all higher dimensions
   while (k != NULL) {
     f(k, CHECK);
-    k = arrayKlass::cast(k)->higher_dimension();
+    k = ArrayKlass::cast(k)->higher_dimension();
   }
 }
 
-void arrayKlass::array_klasses_do(void f(Klass* k)) {
+void ArrayKlass::array_klasses_do(void f(Klass* k)) {
   Klass* k = this;
   // Iterate over this array klass and all higher dimensions
   while (k != NULL) {
     f(k);
-    k = arrayKlass::cast(k)->higher_dimension();
+    k = ArrayKlass::cast(k)->higher_dimension();
   }
 }
 
 
-void arrayKlass::with_array_klasses_do(void f(Klass* k)) {
+void ArrayKlass::with_array_klasses_do(void f(Klass* k)) {
   array_klasses_do(f);
 }
 
 
 // GC support
 
-void arrayKlass::oops_do(OopClosure* cl) {
+void ArrayKlass::oops_do(OopClosure* cl) {
   Klass::oops_do(cl);
 
   cl->do_oop(adr_component_mirror());
@@ -177,42 +177,42 @@ void arrayKlass::oops_do(OopClosure* cl) {
 
 // JVM support
 
-jint arrayKlass::compute_modifier_flags(TRAPS) const {
+jint ArrayKlass::compute_modifier_flags(TRAPS) const {
   return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;
 }
 
 // JVMTI support
 
-jint arrayKlass::jvmti_class_status() const {
+jint ArrayKlass::jvmti_class_status() const {
   return JVMTI_CLASS_STATUS_ARRAY;
 }
 
-void arrayKlass::remove_unshareable_info() {
+void ArrayKlass::remove_unshareable_info() {
   Klass::remove_unshareable_info();
   // Clear the java mirror
   set_component_mirror(NULL);
 }
 
-void arrayKlass::restore_unshareable_info(TRAPS) {
+void ArrayKlass::restore_unshareable_info(TRAPS) {
   Klass::restore_unshareable_info(CHECK);
   // Klass recreates the component mirror also
 }
 
 // Printing
 
-void arrayKlass::print_on(outputStream* st) const {
+void ArrayKlass::print_on(outputStream* st) const {
   assert(is_klass(), "must be klass");
   Klass::print_on(st);
 }
 
-void arrayKlass::print_value_on(outputStream* st) const {
+void ArrayKlass::print_value_on(outputStream* st) const {
   assert(is_klass(), "must be klass");
   for(int index = 0; index < dimension(); index++) {
     st->print("[]");
   }
 }
 
-void arrayKlass::oop_print_on(oop obj, outputStream* st) {
+void ArrayKlass::oop_print_on(oop obj, outputStream* st) {
   assert(obj->is_array(), "must be array");
   Klass::oop_print_on(obj, st);
   st->print_cr(" - length: %d", arrayOop(obj)->length());
@@ -221,7 +221,7 @@ void arrayKlass::oop_print_on(oop obj, outputStream* st) {
 
 // Verification
 
-void arrayKlass::verify_on(outputStream* st) {
+void ArrayKlass::verify_on(outputStream* st) {
   Klass::verify_on(st);
 
   if (component_mirror() != NULL) {
@@ -229,7 +229,7 @@ void arrayKlass::verify_on(outputStream* st) {
   }
 }
 
-void arrayKlass::oop_verify_on(oop obj, outputStream* st) {
+void ArrayKlass::oop_verify_on(oop obj, outputStream* st) {
   guarantee(obj->is_array(), "must be array");
   arrayOop a = arrayOop(obj);
   guarantee(a->length() >= 0, "array with negative length?");
diff --git a/src/share/vm/oops/arrayKlass.hpp b/src/share/vm/oops/arrayKlass.hpp
index 35e4949e0..38a5340e3 100644
--- a/src/share/vm/oops/arrayKlass.hpp
+++ b/src/share/vm/oops/arrayKlass.hpp
@@ -30,9 +30,9 @@
 
 class klassVtable;
 
-// arrayKlass is the abstract baseclass for all array classes
+// ArrayKlass is the abstract baseclass for all array classes
 
-class arrayKlass: public Klass {
+class ArrayKlass: public Klass {
   friend class VMStructs;
  private:
   int      _dimension;         // This is n'th-dimensional array.
@@ -46,8 +46,8 @@ class arrayKlass: public Klass {
   // Constructors
   // The constructor with the Symbol argument does the real array
   // initialization, the other is a dummy
-  arrayKlass(Symbol* name);
-  arrayKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for cds"); }
+  ArrayKlass(Symbol* name);
+  ArrayKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for cds"); }
 
  public:
   // Testing operation
@@ -80,7 +80,7 @@ class arrayKlass: public Klass {
   oop* adr_component_mirror()           { return (oop*)&this->_component_mirror;}
 
   // Compiler/Interpreter offset
-  static ByteSize component_mirror_offset() { return in_ByteSize(offset_of(arrayKlass, _component_mirror)); }
+  static ByteSize component_mirror_offset() { return in_ByteSize(offset_of(ArrayKlass, _component_mirror)); }
 
   virtual Klass* java_super() const;//{ return SystemDictionary::Object_klass(); }
 
@@ -94,16 +94,16 @@ class arrayKlass: public Klass {
   Method* uncached_lookup_method(Symbol* name, Symbol* signature) const;
 
   // Casting from Klass*
-  static arrayKlass* cast(Klass* k) {
-    assert(k->oop_is_array(), "cast to arrayKlass");
-    return (arrayKlass*) k;
+  static ArrayKlass* cast(Klass* k) {
+    assert(k->oop_is_array(), "cast to ArrayKlass");
+    return (ArrayKlass*) k;
   }
 
   GrowableArray<Klass*>* compute_secondary_supers(int num_extra_slots);
   bool compute_is_subtype_of(Klass* k);
 
   // Sizing
-  static int header_size()                 { return sizeof(arrayKlass)/HeapWordSize; }
+  static int header_size()                 { return sizeof(ArrayKlass)/HeapWordSize; }
   static int static_size(int header_size);
 
   // Java vtable
@@ -124,7 +124,7 @@ class arrayKlass: public Klass {
   virtual void oops_do(OopClosure* cl);
 
   // Return a handle.
-  static void     complete_create_array_klass(arrayKlass* k, KlassHandle super_klass, TRAPS);
+  static void     complete_create_array_klass(ArrayKlass* k, KlassHandle super_klass, TRAPS);
 
 
   // jvm support
diff --git a/src/share/vm/oops/constantPool.cpp b/src/share/vm/oops/constantPool.cpp
index b708e1ed3..fbe7eee27 100644
--- a/src/share/vm/oops/constantPool.cpp
+++ b/src/share/vm/oops/constantPool.cpp
@@ -519,7 +519,7 @@ int ConstantPool::remap_instruction_operand_from_cache(int operand) {
 void ConstantPool::verify_constant_pool_resolve(constantPoolHandle this_oop, KlassHandle k, TRAPS) {
  if (k->oop_is_instance() || k->oop_is_objArray()) {
     instanceKlassHandle holder (THREAD, this_oop->pool_holder());
-    Klass* elem_oop = k->oop_is_instance() ? k() : objArrayKlass::cast(k())->bottom_klass();
+    Klass* elem_oop = k->oop_is_instance() ? k() : ObjArrayKlass::cast(k())->bottom_klass();
     KlassHandle element (THREAD, elem_oop);
 
     // The element type could be a typeArray - we only need the access check if it is
diff --git a/src/share/vm/oops/constantPool.hpp b/src/share/vm/oops/constantPool.hpp
index d290f003d..96f2f0714 100644
--- a/src/share/vm/oops/constantPool.hpp
+++ b/src/share/vm/oops/constantPool.hpp
@@ -468,7 +468,7 @@ class ConstantPool : public Metadata {
     assert(tag_at(which).is_string(), "Corrupted constant pool");
     // Must do an acquire here in case another thread resolved the klass
     // behind our back, lest we later load stale values thru the oop.
-    // we might want a volatile_obj_at in objArrayKlass.
+    // we might want a volatile_obj_at in ObjArrayKlass.
     int obj_index = cp_to_object_index(which);
     return resolved_references()->obj_at(obj_index);
   }
diff --git a/src/share/vm/oops/instanceKlass.cpp b/src/share/vm/oops/instanceKlass.cpp
index b9decf179..89452acdc 100644
--- a/src/share/vm/oops/instanceKlass.cpp
+++ b/src/share/vm/oops/instanceKlass.cpp
@@ -989,13 +989,13 @@ Klass* InstanceKlass::array_klass_impl(instanceKlassHandle this_oop, bool or_nul
 
       // Check if update has already taken place
       if (this_oop->array_klasses() == NULL) {
-        Klass*    k = objArrayKlass::allocate_objArray_klass(this_oop->class_loader_data(), 1, this_oop, CHECK_NULL);
+        Klass*    k = ObjArrayKlass::allocate_objArray_klass(this_oop->class_loader_data(), 1, this_oop, CHECK_NULL);
         this_oop->set_array_klasses(k);
       }
     }
   }
   // _this will always be set at this point
-  objArrayKlass* oak = (objArrayKlass*)this_oop->array_klasses();
+  ObjArrayKlass* oak = (ObjArrayKlass*)this_oop->array_klasses();
   if (or_null) {
     return oak->array_klass_or_null(n);
   }
@@ -1224,12 +1224,12 @@ void InstanceKlass::do_nonstatic_fields(FieldClosure* cl) {
 
 void InstanceKlass::array_klasses_do(void f(Klass* k, TRAPS), TRAPS) {
   if (array_klasses() != NULL)
-    arrayKlass::cast(array_klasses())->array_klasses_do(f, THREAD);
+    ArrayKlass::cast(array_klasses())->array_klasses_do(f, THREAD);
 }
 
 void InstanceKlass::array_klasses_do(void f(Klass* k)) {
   if (array_klasses() != NULL)
-    arrayKlass::cast(array_klasses())->array_klasses_do(f);
+    ArrayKlass::cast(array_klasses())->array_klasses_do(f);
 }
 
 
@@ -2310,7 +2310,7 @@ bool InstanceKlass::is_same_class_package(Klass* class2) {
   Symbol* classname1 = Klass::cast(class1)->name();
 
   if (Klass::cast(class2)->oop_is_objArray()) {
-    class2 = objArrayKlass::cast(class2)->bottom_klass();
+    class2 = ObjArrayKlass::cast(class2)->bottom_klass();
   }
   oop classloader2;
   if (Klass::cast(class2)->oop_is_instance()) {
diff --git a/src/share/vm/oops/klass.cpp b/src/share/vm/oops/klass.cpp
index 9013c1e97..94546f0d7 100644
--- a/src/share/vm/oops/klass.cpp
+++ b/src/share/vm/oops/klass.cpp
@@ -532,13 +532,13 @@ Klass* Klass::array_klass_or_null() {
 
 
 Klass* Klass::array_klass_impl(bool or_null, int rank, TRAPS) {
-  fatal("array_klass should be dispatched to InstanceKlass, objArrayKlass or typeArrayKlass");
+  fatal("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
   return NULL;
 }
 
 
 Klass* Klass::array_klass_impl(bool or_null, TRAPS) {
-  fatal("array_klass should be dispatched to InstanceKlass, objArrayKlass or typeArrayKlass");
+  fatal("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass");
   return NULL;
 }
 
@@ -674,7 +674,7 @@ void Klass::verify_vtable_index(int i) {
     assert(i>=0 && i<((InstanceKlass*)this)->vtable_length()/vtableEntry::size(), "index out of bounds");
   } else {
     assert(oop_is_array(), "Must be");
-    assert(i>=0 && i<((arrayKlass*)this)->vtable_length()/vtableEntry::size(), "index out of bounds");
+    assert(i>=0 && i<((ArrayKlass*)this)->vtable_length()/vtableEntry::size(), "index out of bounds");
   }
 }
 
diff --git a/src/share/vm/oops/klassVtable.cpp b/src/share/vm/oops/klassVtable.cpp
index c6cdb3f84..a522ab515 100644
--- a/src/share/vm/oops/klassVtable.cpp
+++ b/src/share/vm/oops/klassVtable.cpp
@@ -1096,7 +1096,7 @@ class VtableStats : AllStatic {
     SystemDictionary::classes_do(do_class);
     fixed  = no_klasses * oopSize;      // vtable length
     // filler size is a conservative approximation
-    filler = oopSize * (no_klasses - no_instance_klasses) * (sizeof(InstanceKlass) - sizeof(arrayKlass) - 1);
+    filler = oopSize * (no_klasses - no_instance_klasses) * (sizeof(InstanceKlass) - sizeof(ArrayKlass) - 1);
     entries = sizeof(vtableEntry) * sum_of_vtable_len;
     array_entries = sizeof(vtableEntry) * sum_of_array_vtable_len;
   }
diff --git a/src/share/vm/oops/klassVtable.hpp b/src/share/vm/oops/klassVtable.hpp
index 8abf6332b..ca0ba34bd 100644
--- a/src/share/vm/oops/klassVtable.hpp
+++ b/src/share/vm/oops/klassVtable.hpp
@@ -31,7 +31,7 @@
 #include "utilities/growableArray.hpp"
 
 // A klassVtable abstracts the variable-length vtable that is embedded in InstanceKlass
-// and arrayKlass.  klassVtable objects are used just as convenient transient accessors to the vtable,
+// and ArrayKlass.  klassVtable objects are used just as convenient transient accessors to the vtable,
 // not to actually hold the vtable data.
 // Note: the klassVtable should not be accessed before the class has been verified
 // (until that point, the vtable is uninitialized).
diff --git a/src/share/vm/oops/method.cpp b/src/share/vm/oops/method.cpp
index d57f5df26..595124494 100644
--- a/src/share/vm/oops/method.cpp
+++ b/src/share/vm/oops/method.cpp
@@ -1065,7 +1065,7 @@ methodHandle Method::make_method_handle_intrinsic(vmIntrinsics::ID iid,
 Klass* Method::check_non_bcp_klass(Klass* klass) {
   if (klass != NULL && Klass::cast(klass)->class_loader() != NULL) {
     if (Klass::cast(klass)->oop_is_objArray())
-      klass = objArrayKlass::cast(klass)->bottom_klass();
+      klass = ObjArrayKlass::cast(klass)->bottom_klass();
     return klass;
   }
   return NULL;
diff --git a/src/share/vm/oops/objArrayKlass.cpp b/src/share/vm/oops/objArrayKlass.cpp
index b0d901412..6165900b5 100644
--- a/src/share/vm/oops/objArrayKlass.cpp
+++ b/src/share/vm/oops/objArrayKlass.cpp
@@ -56,16 +56,16 @@
 #include "oops/oop.pcgc.inline.hpp"
 #endif
 
-objArrayKlass* objArrayKlass::allocate(ClassLoaderData* loader_data, int n, KlassHandle klass_handle, Symbol* name, TRAPS) {
-  assert(objArrayKlass::header_size() <= InstanceKlass::header_size(),
+ObjArrayKlass* ObjArrayKlass::allocate(ClassLoaderData* loader_data, int n, KlassHandle klass_handle, Symbol* name, TRAPS) {
+  assert(ObjArrayKlass::header_size() <= InstanceKlass::header_size(),
       "array klasses must be same size as InstanceKlass");
 
-  int size = arrayKlass::static_size(objArrayKlass::header_size());
+  int size = ArrayKlass::static_size(ObjArrayKlass::header_size());
 
-  return new (loader_data, size, THREAD) objArrayKlass(n, klass_handle, name);
+  return new (loader_data, size, THREAD) ObjArrayKlass(n, klass_handle, name);
 }
 
-Klass* objArrayKlass::allocate_objArray_klass(ClassLoaderData* loader_data,
+Klass* ObjArrayKlass::allocate_objArray_klass(ClassLoaderData* loader_data,
                                                 int n, KlassHandle element_klass, TRAPS) {
 
   // Eagerly allocate the direct array supertype.
@@ -145,7 +145,7 @@ Klass* objArrayKlass::allocate_objArray_klass(ClassLoaderData* loader_data,
   }
 
   // Initialize instance variables
-  objArrayKlass* oak = objArrayKlass::allocate(loader_data, n, element_klass, name, CHECK_0);
+  ObjArrayKlass* oak = ObjArrayKlass::allocate(loader_data, n, element_klass, name, CHECK_0);
 
   // Add all classes to our internal class loader list here,
   // including classes in the bootstrap (NULL) class loader.
@@ -153,12 +153,12 @@ Klass* objArrayKlass::allocate_objArray_klass(ClassLoaderData* loader_data,
   loader_data->add_class(oak);
 
   // Call complete_create_array_klass after all instance variables has been initialized.
-  arrayKlass::complete_create_array_klass(oak, super_klass, CHECK_0);
+  ArrayKlass::complete_create_array_klass(oak, super_klass, CHECK_0);
 
   return oak;
 }
 
-objArrayKlass::objArrayKlass(int n, KlassHandle element_klass, Symbol* name) : arrayKlass(name) {
+ObjArrayKlass::ObjArrayKlass(int n, KlassHandle element_klass, Symbol* name) : ArrayKlass(name) {
   this->set_dimension(n);
   this->set_element_klass(element_klass());
   // decrement refcount because object arrays are not explicitly freed.  The
@@ -168,7 +168,7 @@ objArrayKlass::objArrayKlass(int n, KlassHandle element_klass, Symbol* name) : a
 
   Klass* bk;
   if (element_klass->oop_is_objArray()) {
-    bk = objArrayKlass::cast(element_klass())->bottom_klass();
+    bk = ObjArrayKlass::cast(element_klass())->bottom_klass();
   } else {
     bk = element_klass();
   }
@@ -181,12 +181,12 @@ objArrayKlass::objArrayKlass(int n, KlassHandle element_klass, Symbol* name) : a
   assert(this->oop_is_objArray(), "sanity");
 }
 
-int objArrayKlass::oop_size(oop obj) const {
+int ObjArrayKlass::oop_size(oop obj) const {
   assert(obj->is_objArray(), "must be object array");
   return objArrayOop(obj)->object_size();
 }
 
-objArrayOop objArrayKlass::allocate(int length, TRAPS) {
+objArrayOop ObjArrayKlass::allocate(int length, TRAPS) {
   if (length >= 0) {
     if (length <= arrayOopDesc::max_array_length(T_OBJECT)) {
       int size = objArrayOopDesc::object_size(length);
@@ -204,7 +204,7 @@ objArrayOop objArrayKlass::allocate(int length, TRAPS) {
 
 static int multi_alloc_counter = 0;
 
-oop objArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
+oop ObjArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
   int length = *sizes;
   // Call to lower_dimension uses this pointer, so most be called before a
   // possible GC
@@ -215,7 +215,7 @@ oop objArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
   if (rank > 1) {
     if (length != 0) {
       for (int index = 0; index < length; index++) {
-        arrayKlass* ak = arrayKlass::cast(h_lower_dimension());
+        ArrayKlass* ak = ArrayKlass::cast(h_lower_dimension());
         oop sub_array = ak->multi_allocate(rank-1, &sizes[1], CHECK_NULL);
         h_array->obj_at_put(index, sub_array);
       }
@@ -235,7 +235,7 @@ oop objArrayKlass::multi_allocate(int rank, jint* sizes, TRAPS) {
 }
 
 // Either oop or narrowOop depending on UseCompressedOops.
-template <class T> void objArrayKlass::do_copy(arrayOop s, T* src,
+template <class T> void ObjArrayKlass::do_copy(arrayOop s, T* src,
                                arrayOop d, T* dst, int length, TRAPS) {
 
   BarrierSet* bs = Universe::heap()->barrier_set();
@@ -252,8 +252,8 @@ template <class T> void objArrayKlass::do_copy(arrayOop s, T* src,
     Copy::conjoint_oops_atomic(src, dst, length);
   } else {
     // We have to make sure all elements conform to the destination array
-    Klass* bound = objArrayKlass::cast(d->klass())->element_klass();
-    Klass* stype = objArrayKlass::cast(s->klass())->element_klass();
+    Klass* bound = ObjArrayKlass::cast(d->klass())->element_klass();
+    Klass* stype = ObjArrayKlass::cast(s->klass())->element_klass();
     if (stype == bound || Klass::cast(stype)->is_subtype_of(bound)) {
       // elements are guaranteed to be subtypes, so no check necessary
       bs->write_ref_array_pre(dst, length);
@@ -290,7 +290,7 @@ template <class T> void objArrayKlass::do_copy(arrayOop s, T* src,
   bs->write_ref_array((HeapWord*)dst, length);
 }
 
-void objArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d,
+void ObjArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d,
                                int dst_pos, int length, TRAPS) {
   assert(s->is_objArray(), "must be obj array");
 
@@ -327,7 +327,7 @@ void objArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d,
 }
 
 
-Klass* objArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
+Klass* ObjArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
 
   assert(dimension() <= n, "check order of chain");
   int dim = dimension();
@@ -348,30 +348,30 @@ Klass* objArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
 
         // Create multi-dim klass object and link them together
         Klass* k =
-          objArrayKlass::allocate_objArray_klass(class_loader_data(), dim + 1, this, CHECK_NULL);
-        objArrayKlass* ak = objArrayKlass::cast(k);
+          ObjArrayKlass::allocate_objArray_klass(class_loader_data(), dim + 1, this, CHECK_NULL);
+        ObjArrayKlass* ak = ObjArrayKlass::cast(k);
         ak->set_lower_dimension(this);
         OrderAccess::storestore();
         set_higher_dimension(ak);
-        assert(ak->oop_is_objArray(), "incorrect initialization of objArrayKlass");
+        assert(ak->oop_is_objArray(), "incorrect initialization of ObjArrayKlass");
       }
     }
   } else {
     CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
   }
 
-  objArrayKlass *ak = objArrayKlass::cast(higher_dimension());
+  ObjArrayKlass *ak = ObjArrayKlass::cast(higher_dimension());
   if (or_null) {
     return ak->array_klass_or_null(n);
   }
   return ak->array_klass(n, CHECK_NULL);
 }
 
-Klass* objArrayKlass::array_klass_impl(bool or_null, TRAPS) {
+Klass* ObjArrayKlass::array_klass_impl(bool or_null, TRAPS) {
   return array_klass_impl(or_null, dimension() +  1, CHECK_NULL);
 }
 
-bool objArrayKlass::can_be_primary_super_slow() const {
+bool ObjArrayKlass::can_be_primary_super_slow() const {
   if (!bottom_klass()->can_be_primary_super())
     // array of interfaces
     return false;
@@ -379,7 +379,7 @@ bool objArrayKlass::can_be_primary_super_slow() const {
     return Klass::can_be_primary_super_slow();
 }
 
-GrowableArray<Klass*>* objArrayKlass::compute_secondary_supers(int num_extra_slots) {
+GrowableArray<Klass*>* ObjArrayKlass::compute_secondary_supers(int num_extra_slots) {
   // interfaces = { cloneable_klass, serializable_klass, elemSuper[], ... };
   Array<Klass*>* elem_supers = Klass::cast(element_klass())->secondary_supers();
   int num_elem_supers = elem_supers == NULL ? 0 : elem_supers->length();
@@ -402,16 +402,16 @@ GrowableArray<Klass*>* objArrayKlass::compute_secondary_supers(int num_extra_slo
   }
 }
 
-bool objArrayKlass::compute_is_subtype_of(Klass* k) {
+bool ObjArrayKlass::compute_is_subtype_of(Klass* k) {
   if (!k->oop_is_objArray())
-    return arrayKlass::compute_is_subtype_of(k);
+    return ArrayKlass::compute_is_subtype_of(k);
 
-  objArrayKlass* oak = objArrayKlass::cast(k);
+  ObjArrayKlass* oak = ObjArrayKlass::cast(k);
   return element_klass()->is_subtype_of(oak->element_klass());
 }
 
-void objArrayKlass::initialize(TRAPS) {
-  Klass::cast(bottom_klass())->initialize(THREAD);  // dispatches to either InstanceKlass or typeArrayKlass
+void ObjArrayKlass::initialize(TRAPS) {
+  Klass::cast(bottom_klass())->initialize(THREAD);  // dispatches to either InstanceKlass or TypeArrayKlass
 }
 
 #define ObjArrayKlass_SPECIALIZED_OOP_ITERATE(T, a, p, do_oop) \
@@ -456,7 +456,7 @@ void objArrayKlass::initialize(TRAPS) {
       a, p, low, high, do_oop)                               \
   }
 
-void objArrayKlass::oop_follow_contents(oop obj) {
+void ObjArrayKlass::oop_follow_contents(oop obj) {
   assert (obj->is_array(), "obj must be array");
   MarkSweep::follow_klass(obj->klass());
   if (UseCompressedOops) {
@@ -467,7 +467,7 @@ void objArrayKlass::oop_follow_contents(oop obj) {
 }
 
 #ifndef SERIALGC
-void objArrayKlass::oop_follow_contents(ParCompactionManager* cm,
+void ObjArrayKlass::oop_follow_contents(ParCompactionManager* cm,
                                         oop obj) {
   assert(obj->is_array(), "obj must be array");
   PSParallelCompact::follow_klass(cm, obj->klass());
@@ -487,7 +487,7 @@ void objArrayKlass::oop_follow_contents(ParCompactionManager* cm,
 
 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix)           \
                                                                                 \
-int objArrayKlass::oop_oop_iterate##nv_suffix(oop obj,                          \
+int ObjArrayKlass::oop_oop_iterate##nv_suffix(oop obj,                          \
                                               OopClosureType* closure) {        \
   SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
   assert (obj->is_array(), "obj must be array");                                \
@@ -504,7 +504,7 @@ int objArrayKlass::oop_oop_iterate##nv_suffix(oop obj,
 
 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix)         \
                                                                                 \
-int objArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj,                      \
+int ObjArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj,                      \
                                                   OopClosureType* closure,      \
                                                   MemRegion mr) {               \
   SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
@@ -526,7 +526,7 @@ int objArrayKlass::oop_oop_iterate##nv_suffix##_m(oop obj,
 // for objArrayOops.
 #define ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r(OopClosureType, nv_suffix)         \
                                                                                 \
-int objArrayKlass::oop_oop_iterate_range##nv_suffix(oop obj,                    \
+int ObjArrayKlass::oop_oop_iterate_range##nv_suffix(oop obj,                    \
                                                   OopClosureType* closure,      \
                                                   int start, int end) {         \
   SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::oa); \
@@ -567,7 +567,7 @@ ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_m)
 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r)
 ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayKlass_OOP_OOP_ITERATE_DEFN_r)
 
-int objArrayKlass::oop_adjust_pointers(oop obj) {
+int ObjArrayKlass::oop_adjust_pointers(oop obj) {
   assert(obj->is_objArray(), "obj must be obj array");
   objArrayOop a = objArrayOop(obj);
   // Get size before changing pointers.
@@ -579,7 +579,7 @@ int objArrayKlass::oop_adjust_pointers(oop obj) {
 }
 
 #ifndef SERIALGC
-void objArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
+void ObjArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
   assert(obj->is_objArray(), "obj must be obj array");
   ObjArrayKlass_OOP_ITERATE( \
     objArrayOop(obj), p, \
@@ -588,7 +588,7 @@ void objArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
     })
 }
 
-int objArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
+int ObjArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
   assert (obj->is_objArray(), "obj must be obj array");
   objArrayOop a = objArrayOop(obj);
   int size = a->object_size();
@@ -600,7 +600,7 @@ int objArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
 
 // JVM support
 
-jint objArrayKlass::compute_modifier_flags(TRAPS) const {
+jint ObjArrayKlass::compute_modifier_flags(TRAPS) const {
   // The modifier for an objectArray is the same as its element
   if (element_klass() == NULL) {
     assert(Universe::is_bootstrapping(), "partial objArray only at startup");
@@ -616,7 +616,7 @@ jint objArrayKlass::compute_modifier_flags(TRAPS) const {
 
 // Printing
 
-void objArrayKlass::print_on(outputStream* st) const {
+void ObjArrayKlass::print_on(outputStream* st) const {
 #ifndef PRODUCT
   Klass::print_on(st);
   st->print(" - instance klass: ");
@@ -625,7 +625,7 @@ void objArrayKlass::print_on(outputStream* st) const {
 #endif //PRODUCT
 }
 
-void objArrayKlass::print_value_on(outputStream* st) const {
+void ObjArrayKlass::print_value_on(outputStream* st) const {
   assert(is_klass(), "must be klass");
 
   element_klass()->print_value_on(st);
@@ -634,8 +634,8 @@ void objArrayKlass::print_value_on(outputStream* st) const {
 
 #ifndef PRODUCT
 
-void objArrayKlass::oop_print_on(oop obj, outputStream* st) {
-  arrayKlass::oop_print_on(obj, st);
+void ObjArrayKlass::oop_print_on(oop obj, outputStream* st) {
+  ArrayKlass::oop_print_on(obj, st);
   assert(obj->is_objArray(), "must be objArray");
   objArrayOop oa = objArrayOop(obj);
   int print_len = MIN2((intx) oa->length(), MaxElementPrintSize);
@@ -654,7 +654,7 @@ void objArrayKlass::oop_print_on(oop obj, outputStream* st) {
 
 static int max_objArray_print_length = 4;
 
-void objArrayKlass::oop_print_value_on(oop obj, outputStream* st) {
+void ObjArrayKlass::oop_print_value_on(oop obj, outputStream* st) {
   assert(obj->is_objArray(), "must be objArray");
   st->print("a ");
   element_klass()->print_value_on(st);
@@ -673,15 +673,15 @@ void objArrayKlass::oop_print_value_on(oop obj, outputStream* st) {
   }
 }
 
-const char* objArrayKlass::internal_name() const {
+const char* ObjArrayKlass::internal_name() const {
   return external_name();
 }
 
 
 // Verification
 
-void objArrayKlass::verify_on(outputStream* st) {
-  arrayKlass::verify_on(st);
+void ObjArrayKlass::verify_on(outputStream* st) {
+  ArrayKlass::verify_on(st);
   guarantee(element_klass()->is_metadata(), "should be in metaspace");
   guarantee(element_klass()->is_klass(), "should be klass");
   guarantee(bottom_klass()->is_metadata(), "should be in metaspace");
@@ -690,8 +690,8 @@ void objArrayKlass::verify_on(outputStream* st) {
   guarantee(bk->oop_is_instance() || bk->oop_is_typeArray(),  "invalid bottom klass");
 }
 
-void objArrayKlass::oop_verify_on(oop obj, outputStream* st) {
-  arrayKlass::oop_verify_on(obj, st);
+void ObjArrayKlass::oop_verify_on(oop obj, outputStream* st) {
+  ArrayKlass::oop_verify_on(obj, st);
   guarantee(obj->is_objArray(), "must be objArray");
   objArrayOop oa = objArrayOop(obj);
   for(int index = 0; index < oa->length(); index++) {
diff --git a/src/share/vm/oops/objArrayKlass.hpp b/src/share/vm/oops/objArrayKlass.hpp
index f5d471675..7cb778e77 100644
--- a/src/share/vm/oops/objArrayKlass.hpp
+++ b/src/share/vm/oops/objArrayKlass.hpp
@@ -29,20 +29,20 @@
 #include "memory/specialized_oop_closures.hpp"
 #include "oops/arrayKlass.hpp"
 
-// objArrayKlass is the klass for objArrays
+// ObjArrayKlass is the klass for objArrays
 
-class objArrayKlass : public arrayKlass {
+class ObjArrayKlass : public ArrayKlass {
   friend class VMStructs;
  private:
   Klass* _element_klass;            // The klass of the elements of this array type
-  Klass* _bottom_klass;             // The one-dimensional type (InstanceKlass or typeArrayKlass)
+  Klass* _bottom_klass;             // The one-dimensional type (InstanceKlass or TypeArrayKlass)
 
   // Constructor
-  objArrayKlass(int n, KlassHandle element_klass, Symbol* name);
-  static objArrayKlass* allocate(ClassLoaderData* loader_data, int n, KlassHandle klass_handle, Symbol* name, TRAPS);
+  ObjArrayKlass(int n, KlassHandle element_klass, Symbol* name);
+  static ObjArrayKlass* allocate(ClassLoaderData* loader_data, int n, KlassHandle klass_handle, Symbol* name, TRAPS);
  public:
   // For dummy objects
-  objArrayKlass() {}
+  ObjArrayKlass() {}
 
   // Instance variables
   Klass* element_klass() const      { return _element_klass; }
@@ -54,7 +54,7 @@ class objArrayKlass : public arrayKlass {
   Klass** bottom_klass_addr()       { return &_bottom_klass; }
 
   // Compiler/Interpreter offset
-  static ByteSize element_klass_offset() { return in_ByteSize(offset_of(objArrayKlass, _element_klass)); }
+  static ByteSize element_klass_offset() { return in_ByteSize(offset_of(ObjArrayKlass, _element_klass)); }
 
   // Dispatched operation
   bool can_be_primary_super_slow() const;
@@ -78,11 +78,11 @@ class objArrayKlass : public arrayKlass {
 
  private:
   // Either oop or narrowOop depending on UseCompressedOops.
-  // must be called from within objArrayKlass.cpp
+  // must be called from within ObjArrayKlass.cpp
   template <class T> void do_copy(arrayOop s, T* src, arrayOop d,
                                   T* dst, int length, TRAPS);
  protected:
-  // Returns the objArrayKlass for n'th dimension.
+  // Returns the ObjArrayKlass for n'th dimension.
   virtual Klass* array_klass_impl(bool or_null, int n, TRAPS);
 
   // Returns the array class with this class as element type.
@@ -90,14 +90,14 @@ class objArrayKlass : public arrayKlass {
 
  public:
   // Casting from Klass*
-  static objArrayKlass* cast(Klass* k) {
-    assert(k->oop_is_objArray(), "cast to objArrayKlass");
-    return (objArrayKlass*) k;
+  static ObjArrayKlass* cast(Klass* k) {
+    assert(k->oop_is_objArray(), "cast to ObjArrayKlass");
+    return (ObjArrayKlass*) k;
   }
 
   // Sizing
-  static int header_size()                { return sizeof(objArrayKlass)/HeapWordSize; }
-  int size() const                        { return arrayKlass::static_size(header_size()); }
+  static int header_size()                { return sizeof(ObjArrayKlass)/HeapWordSize; }
+  int size() const                        { return ArrayKlass::static_size(header_size()); }
 
   // Initialization (virtual from Klass)
   void initialize(TRAPS);
diff --git a/src/share/vm/oops/objArrayKlass.inline.hpp b/src/share/vm/oops/objArrayKlass.inline.hpp
index b99b68893..4a948d82e 100644
--- a/src/share/vm/oops/objArrayKlass.inline.hpp
+++ b/src/share/vm/oops/objArrayKlass.inline.hpp
@@ -32,7 +32,7 @@
 #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
 #endif
 
-void objArrayKlass::oop_follow_contents(oop obj, int index) {
+void ObjArrayKlass::oop_follow_contents(oop obj, int index) {
   if (UseCompressedOops) {
     objarray_follow_contents<narrowOop>(obj, index);
   } else {
@@ -41,7 +41,7 @@ void objArrayKlass::oop_follow_contents(oop obj, int index) {
 }
 
 template <class T>
-void objArrayKlass::objarray_follow_contents(oop obj, int index) {
+void ObjArrayKlass::objarray_follow_contents(oop obj, int index) {
   objArrayOop a = objArrayOop(obj);
   const size_t len = size_t(a->length());
   const size_t beg_index = size_t(index);
@@ -64,7 +64,7 @@ void objArrayKlass::objarray_follow_contents(oop obj, int index) {
 }
 
 #ifndef SERIALGC
-void objArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj,
+void ObjArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj,
                                         int index) {
   if (UseCompressedOops) {
     objarray_follow_contents<narrowOop>(cm, obj, index);
@@ -74,7 +74,7 @@ void objArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj,
 }
 
 template <class T>
-void objArrayKlass::objarray_follow_contents(ParCompactionManager* cm, oop obj,
+void ObjArrayKlass::objarray_follow_contents(ParCompactionManager* cm, oop obj,
                                              int index) {
   objArrayOop a = objArrayOop(obj);
   const size_t len = size_t(a->length());
diff --git a/src/share/vm/oops/objArrayOop.cpp b/src/share/vm/oops/objArrayOop.cpp
index 1cfd8962e..00c4abe5e 100644
--- a/src/share/vm/oops/objArrayOop.cpp
+++ b/src/share/vm/oops/objArrayOop.cpp
@@ -31,7 +31,7 @@
                                                                                    \
 int objArrayOopDesc::oop_iterate_range(OopClosureType* blk, int start, int end) {  \
   SpecializationStats::record_call();                                              \
-  return ((objArrayKlass*)klass())->oop_oop_iterate_range##nv_suffix(this, blk, start, end); \
+  return ((ObjArrayKlass*)klass())->oop_oop_iterate_range##nv_suffix(this, blk, start, end); \
 }
 
 ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayOop_OOP_ITERATE_DEFN)
diff --git a/src/share/vm/oops/objArrayOop.hpp b/src/share/vm/oops/objArrayOop.hpp
index a7cf54720..38246a4e6 100644
--- a/src/share/vm/oops/objArrayOop.hpp
+++ b/src/share/vm/oops/objArrayOop.hpp
@@ -31,7 +31,7 @@
 // Evaluating "String arg[10]" will create an objArrayOop.
 
 class objArrayOopDesc : public arrayOopDesc {
-  friend class objArrayKlass;
+  friend class ObjArrayKlass;
   friend class Runtime1;
   friend class psPromotionManager;
   friend class CSetMarkOopClosure;
diff --git a/src/share/vm/oops/oop.pcgc.inline.hpp b/src/share/vm/oops/oop.pcgc.inline.hpp
index 16164ff49..050678185 100644
--- a/src/share/vm/oops/oop.pcgc.inline.hpp
+++ b/src/share/vm/oops/oop.pcgc.inline.hpp
@@ -44,7 +44,7 @@ inline void oopDesc::update_contents(ParCompactionManager* cm) {
     // It might contain oops beyond the header, so take the virtual call.
     new_klass->oop_update_pointers(cm, this);
   }
-  // Else skip it.  The typeArrayKlass in the header never needs scavenging.
+  // Else skip it.  The TypeArrayKlass in the header never needs scavenging.
 }
 
 inline void oopDesc::follow_contents(ParCompactionManager* cm) {
diff --git a/src/share/vm/oops/oop.psgc.inline.hpp b/src/share/vm/oops/oop.psgc.inline.hpp
index addd5e9fb..4d8c3d63d 100644
--- a/src/share/vm/oops/oop.psgc.inline.hpp
+++ b/src/share/vm/oops/oop.psgc.inline.hpp
@@ -39,7 +39,7 @@ inline void oopDesc::push_contents(PSPromotionManager* pm) {
     // It might contain oops beyond the header, so take the virtual call.
     k->oop_push_contents(pm, this);
   }
-  // Else skip it.  The typeArrayKlass in the header never needs scavenging.
+  // Else skip it.  The TypeArrayKlass in the header never needs scavenging.
 }
 
 #endif // SHARE_VM_OOPS_OOP_PSGC_INLINE_HPP
diff --git a/src/share/vm/oops/oopsHierarchy.hpp b/src/share/vm/oops/oopsHierarchy.hpp
index db6f75888..d599b1bae 100644
--- a/src/share/vm/oops/oopsHierarchy.hpp
+++ b/src/share/vm/oops/oopsHierarchy.hpp
@@ -128,7 +128,7 @@ public:
 #endif
 
   // from parNewGeneration and other things that want to get to the end of
-  // an oop for stuff (like objArrayKlass.cpp)
+  // an oop for stuff (like ObjArrayKlass.cpp)
   operator oop* () const              { return (oop *)obj(); }
 };
 
@@ -172,8 +172,8 @@ class   InstanceKlass;
 class     InstanceMirrorKlass;
 class     InstanceClassLoaderKlass;
 class     InstanceRefKlass;
-class   arrayKlass;
-class     objArrayKlass;
-class     typeArrayKlass;
+class   ArrayKlass;
+class     ObjArrayKlass;
+class     TypeArrayKlass;
 
 #endif // SHARE_VM_OOPS_OOPSHIERARCHY_HPP
diff --git a/src/share/vm/oops/typeArrayKlass.cpp b/src/share/vm/oops/typeArrayKlass.cpp
index f9d0c69b7..f1fcd4f2f 100644
--- a/src/share/vm/oops/typeArrayKlass.cpp
+++ b/src/share/vm/oops/typeArrayKlass.cpp
@@ -40,18 +40,18 @@
 #include "oops/typeArrayOop.hpp"
 #include "runtime/handles.inline.hpp"
 
-bool typeArrayKlass::compute_is_subtype_of(Klass* k) {
+bool TypeArrayKlass::compute_is_subtype_of(Klass* k) {
   if (!k->oop_is_typeArray()) {
-    return arrayKlass::compute_is_subtype_of(k);
+    return ArrayKlass::compute_is_subtype_of(k);
   }
 
-  typeArrayKlass* tak = typeArrayKlass::cast(k);
+  TypeArrayKlass* tak = TypeArrayKlass::cast(k);
   if (dimension() != tak->dimension()) return false;
 
   return element_type() == tak->element_type();
 }
 
-typeArrayKlass* typeArrayKlass::create_klass(BasicType type,
+TypeArrayKlass* TypeArrayKlass::create_klass(BasicType type,
                                       const char* name_str, TRAPS) {
   Symbol* sym = NULL;
   if (name_str != NULL) {
@@ -60,7 +60,7 @@ typeArrayKlass* typeArrayKlass::create_klass(BasicType type,
 
   ClassLoaderData* null_loader_data = ClassLoaderData::the_null_class_loader_data();
 
-  typeArrayKlass* ak = typeArrayKlass::allocate(null_loader_data, type, sym, CHECK_NULL);
+  TypeArrayKlass* ak = TypeArrayKlass::allocate(null_loader_data, type, sym, CHECK_NULL);
 
   // Add all classes to our internal class loader list here,
   // including classes in the bootstrap (NULL) class loader.
@@ -73,27 +73,27 @@ typeArrayKlass* typeArrayKlass::create_klass(BasicType type,
   return ak;
 }
 
-typeArrayKlass* typeArrayKlass::allocate(ClassLoaderData* loader_data, BasicType type, Symbol* name, TRAPS) {
-  assert(typeArrayKlass::header_size() <= InstanceKlass::header_size(),
+TypeArrayKlass* TypeArrayKlass::allocate(ClassLoaderData* loader_data, BasicType type, Symbol* name, TRAPS) {
+  assert(TypeArrayKlass::header_size() <= InstanceKlass::header_size(),
       "array klasses must be same size as InstanceKlass");
 
-  int size = arrayKlass::static_size(typeArrayKlass::header_size());
+  int size = ArrayKlass::static_size(TypeArrayKlass::header_size());
 
-  return new (loader_data, size, THREAD) typeArrayKlass(type, name);
+  return new (loader_data, size, THREAD) TypeArrayKlass(type, name);
 }
 
-typeArrayKlass::typeArrayKlass(BasicType type, Symbol* name) : arrayKlass(name) {
+TypeArrayKlass::TypeArrayKlass(BasicType type, Symbol* name) : ArrayKlass(name) {
   set_layout_helper(array_layout_helper(type));
   assert(oop_is_array(), "sanity");
   assert(oop_is_typeArray(), "sanity");
 
   set_max_length(arrayOopDesc::max_array_length(type));
-  assert(size() >= typeArrayKlass::header_size(), "bad size");
+  assert(size() >= TypeArrayKlass::header_size(), "bad size");
 
   set_class_loader_data(ClassLoaderData::the_null_class_loader_data());
 }
 
-typeArrayOop typeArrayKlass::allocate_common(int length, bool do_zero, TRAPS) {
+typeArrayOop TypeArrayKlass::allocate_common(int length, bool do_zero, TRAPS) {
   assert(log2_element_size() >= 0, "bad scale");
   if (length >= 0) {
     if (length <= max_length()) {
@@ -117,7 +117,7 @@ typeArrayOop typeArrayKlass::allocate_common(int length, bool do_zero, TRAPS) {
   }
 }
 
-oop typeArrayKlass::multi_allocate(int rank, jint* last_size, TRAPS) {
+oop TypeArrayKlass::multi_allocate(int rank, jint* last_size, TRAPS) {
   // For typeArrays this is only called for the last dimension
   assert(rank == 1, "just checking");
   int length = *last_size;
@@ -125,11 +125,11 @@ oop typeArrayKlass::multi_allocate(int rank, jint* last_size, TRAPS) {
 }
 
 
-void typeArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) {
+void TypeArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos, int length, TRAPS) {
   assert(s->is_typeArray(), "must be type array");
 
   // Check destination
-  if (!d->is_typeArray() || element_type() != typeArrayKlass::cast(d->klass())->element_type()) {
+  if (!d->is_typeArray() || element_type() != TypeArrayKlass::cast(d->klass())->element_type()) {
     THROW(vmSymbols::java_lang_ArrayStoreException());
   }
 
@@ -156,7 +156,7 @@ void typeArrayKlass::copy_array(arrayOop s, int src_pos, arrayOop d, int dst_pos
 
 
 // create a klass of array holding typeArrays
-Klass* typeArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
+Klass* TypeArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
   int dim = dimension();
   assert(dim <= n, "check order of chain");
     if (dim == n)
@@ -173,92 +173,92 @@ Klass* typeArrayKlass::array_klass_impl(bool or_null, int n, TRAPS) {
       MutexLocker mu(MultiArray_lock, THREAD);
 
       if (higher_dimension() == NULL) {
-        Klass* oak = objArrayKlass::allocate_objArray_klass(
+        Klass* oak = ObjArrayKlass::allocate_objArray_klass(
               class_loader_data(), dim + 1, this, CHECK_NULL);
-        objArrayKlass* h_ak = objArrayKlass::cast(oak);
+        ObjArrayKlass* h_ak = ObjArrayKlass::cast(oak);
         h_ak->set_lower_dimension(this);
         OrderAccess::storestore();
         set_higher_dimension(h_ak);
-        assert(h_ak->oop_is_objArray(), "incorrect initialization of objArrayKlass");
+        assert(h_ak->oop_is_objArray(), "incorrect initialization of ObjArrayKlass");
       }
     }
   } else {
     CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
   }
-  objArrayKlass* h_ak = objArrayKlass::cast(higher_dimension());
+  ObjArrayKlass* h_ak = ObjArrayKlass::cast(higher_dimension());
   if (or_null) {
     return h_ak->array_klass_or_null(n);
   }
   return h_ak->array_klass(n, CHECK_NULL);
 }
 
-Klass* typeArrayKlass::array_klass_impl(bool or_null, TRAPS) {
+Klass* TypeArrayKlass::array_klass_impl(bool or_null, TRAPS) {
   return array_klass_impl(or_null, dimension() +  1, THREAD);
 }
 
-int typeArrayKlass::oop_size(oop obj) const {
+int TypeArrayKlass::oop_size(oop obj) const {
   assert(obj->is_typeArray(),"must be a type array");
   typeArrayOop t = typeArrayOop(obj);
   return t->object_size();
 }
 
-void typeArrayKlass::oop_follow_contents(oop obj) {
+void TypeArrayKlass::oop_follow_contents(oop obj) {
   assert(obj->is_typeArray(),"must be a type array");
   // Performance tweak: We skip iterating over the klass pointer since we
-  // know that Universe::typeArrayKlass never moves.
+  // know that Universe::TypeArrayKlass never moves.
 }
 
 #ifndef SERIALGC
-void typeArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj) {
+void TypeArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj) {
   assert(obj->is_typeArray(),"must be a type array");
   // Performance tweak: We skip iterating over the klass pointer since we
-  // know that Universe::typeArrayKlass never moves.
+  // know that Universe::TypeArrayKlass never moves.
 }
 #endif // SERIALGC
 
-int typeArrayKlass::oop_adjust_pointers(oop obj) {
+int TypeArrayKlass::oop_adjust_pointers(oop obj) {
   assert(obj->is_typeArray(),"must be a type array");
   typeArrayOop t = typeArrayOop(obj);
   // Performance tweak: We skip iterating over the klass pointer since we
-  // know that Universe::typeArrayKlass never moves.
+  // know that Universe::TypeArrayKlass never moves.
   return t->object_size();
 }
 
-int typeArrayKlass::oop_oop_iterate(oop obj, ExtendedOopClosure* blk) {
+int TypeArrayKlass::oop_oop_iterate(oop obj, ExtendedOopClosure* blk) {
   assert(obj->is_typeArray(),"must be a type array");
   typeArrayOop t = typeArrayOop(obj);
   // Performance tweak: We skip iterating over the klass pointer since we
-  // know that Universe::typeArrayKlass never moves.
+  // know that Universe::TypeArrayKlass never moves.
   return t->object_size();
 }
 
-int typeArrayKlass::oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) {
+int TypeArrayKlass::oop_oop_iterate_m(oop obj, ExtendedOopClosure* blk, MemRegion mr) {
   assert(obj->is_typeArray(),"must be a type array");
   typeArrayOop t = typeArrayOop(obj);
   // Performance tweak: We skip iterating over the klass pointer since we
-  // know that Universe::typeArrayKlass never moves.
+  // know that Universe::TypeArrayKlass never moves.
   return t->object_size();
 }
 
 #ifndef SERIALGC
-void typeArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
+void TypeArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
   ShouldNotReachHere();
   assert(obj->is_typeArray(),"must be a type array");
 }
 
 int
-typeArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
+TypeArrayKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) {
   assert(obj->is_typeArray(),"must be a type array");
   return typeArrayOop(obj)->object_size();
 }
 #endif // SERIALGC
 
-void typeArrayKlass::initialize(TRAPS) {
+void TypeArrayKlass::initialize(TRAPS) {
   // Nothing to do. Having this function is handy since objArrayKlasses can be
-  // initialized by calling initialize on their bottom_klass, see objArrayKlass::initialize
+  // initialized by calling initialize on their bottom_klass, see ObjArrayKlass::initialize
 }
 
-const char* typeArrayKlass::external_name(BasicType type) {
+const char* TypeArrayKlass::external_name(BasicType type) {
   switch (type) {
     case T_BOOLEAN: return "[Z";
     case T_CHAR:    return "[C";
@@ -276,7 +276,7 @@ const char* typeArrayKlass::external_name(BasicType type) {
 
 // Printing
 
-void typeArrayKlass::print_on(outputStream* st) const {
+void TypeArrayKlass::print_on(outputStream* st) const {
 #ifndef PRODUCT
   assert(is_klass(), "must be klass");
   print_value_on(st);
@@ -284,7 +284,7 @@ void typeArrayKlass::print_on(outputStream* st) const {
 #endif //PRODUCT
 }
 
-void typeArrayKlass::print_value_on(outputStream* st) const {
+void TypeArrayKlass::print_value_on(outputStream* st) const {
   assert(is_klass(), "must be klass");
   st->print("{type array ");
   switch (element_type()) {
@@ -364,8 +364,8 @@ static void print_long_array(typeArrayOop ta, int print_len, outputStream* st) {
 }
 
 
-void typeArrayKlass::oop_print_on(oop obj, outputStream* st) {
-  arrayKlass::oop_print_on(obj, st);
+void TypeArrayKlass::oop_print_on(oop obj, outputStream* st) {
+  ArrayKlass::oop_print_on(obj, st);
   typeArrayOop ta = typeArrayOop(obj);
   int print_len = MIN2((intx) ta->length(), MaxElementPrintSize);
   switch (element_type()) {
@@ -387,6 +387,6 @@ void typeArrayKlass::oop_print_on(oop obj, outputStream* st) {
 
 #endif // PRODUCT
 
-const char* typeArrayKlass::internal_name() const {
+const char* TypeArrayKlass::internal_name() const {
   return Klass::external_name();
 }
diff --git a/src/share/vm/oops/typeArrayKlass.hpp b/src/share/vm/oops/typeArrayKlass.hpp
index da45fa775..3fe8312a0 100644
--- a/src/share/vm/oops/typeArrayKlass.hpp
+++ b/src/share/vm/oops/typeArrayKlass.hpp
@@ -28,19 +28,19 @@
 #include "classfile/classLoaderData.hpp"
 #include "oops/arrayKlass.hpp"
 
-// A typeArrayKlass is the klass of a typeArray
+// A TypeArrayKlass is the klass of a typeArray
 // It contains the type and size of the elements
 
-class typeArrayKlass : public arrayKlass {
+class TypeArrayKlass : public ArrayKlass {
   friend class VMStructs;
  private:
   jint _max_length;            // maximum number of elements allowed in an array
 
   // Constructor
-  typeArrayKlass(BasicType type, Symbol* name);
-  static typeArrayKlass* allocate(ClassLoaderData* loader_data, BasicType type, Symbol* name, TRAPS);
+  TypeArrayKlass(BasicType type, Symbol* name);
+  static TypeArrayKlass* allocate(ClassLoaderData* loader_data, BasicType type, Symbol* name, TRAPS);
  public:
-  typeArrayKlass() {} // For dummy objects.
+  TypeArrayKlass() {} // For dummy objects.
 
   // instance variables
   jint max_length()                     { return _max_length; }
@@ -50,10 +50,10 @@ class typeArrayKlass : public arrayKlass {
   bool oop_is_typeArray_slow() const    { return true; }
 
   // klass allocation
-  static typeArrayKlass* create_klass(BasicType type, const char* name_str,
+  static TypeArrayKlass* create_klass(BasicType type, const char* name_str,
                                TRAPS);
   static inline Klass* create_klass(BasicType type, int scale, TRAPS) {
-    typeArrayKlass* tak = create_klass(type, external_name(type), CHECK_NULL);
+    TypeArrayKlass* tak = create_klass(type, external_name(type), CHECK_NULL);
     assert(scale == (1 << tak->log2_element_size()), "scale must check out");
     return tak;
   }
@@ -90,17 +90,17 @@ class typeArrayKlass : public arrayKlass {
 
  public:
   // Casting from Klass*
-  static typeArrayKlass* cast(Klass* k) {
-    assert(k->oop_is_typeArray(), "cast to typeArrayKlass");
-    return (typeArrayKlass*) k;
+  static TypeArrayKlass* cast(Klass* k) {
+    assert(k->oop_is_typeArray(), "cast to TypeArrayKlass");
+    return (TypeArrayKlass*) k;
   }
 
   // Naming
   static const char* external_name(BasicType type);
 
   // Sizing
-  static int header_size()  { return sizeof(typeArrayKlass)/HeapWordSize; }
-  int size() const          { return arrayKlass::static_size(header_size()); }
+  static int header_size()  { return sizeof(TypeArrayKlass)/HeapWordSize; }
+  int size() const          { return ArrayKlass::static_size(header_size()); }
 
   // Initialization (virtual from Klass)
   void initialize(TRAPS);
diff --git a/src/share/vm/oops/typeArrayOop.hpp b/src/share/vm/oops/typeArrayOop.hpp
index 62e9fa6cd..cee2b8a5e 100644
--- a/src/share/vm/oops/typeArrayOop.hpp
+++ b/src/share/vm/oops/typeArrayOop.hpp
@@ -73,7 +73,7 @@ class typeArrayOopDesc : public arrayOopDesc {
   jfloat*   float_base()  const { return (jfloat*)  base(T_FLOAT); }
   jdouble*  double_base() const { return (jdouble*) base(T_DOUBLE); }
 
-  friend class typeArrayKlass;
+  friend class TypeArrayKlass;
 
  public:
   jbyte* byte_at_addr(int which) const {
@@ -190,7 +190,7 @@ class typeArrayOopDesc : public arrayOopDesc {
 
  public:
   int object_size() {
-    typeArrayKlass* tk = typeArrayKlass::cast(klass());
+    TypeArrayKlass* tk = TypeArrayKlass::cast(klass());
     return object_size(tk->layout_helper(), length());
   }
 };
diff --git a/src/share/vm/opto/library_call.cpp b/src/share/vm/opto/library_call.cpp
index 386662e15..4e3449e4f 100644
--- a/src/share/vm/opto/library_call.cpp
+++ b/src/share/vm/opto/library_call.cpp
@@ -3435,7 +3435,7 @@ bool LibraryCallKit::inline_native_Class_query(vmIntrinsics::ID id) {
     if (generate_array_guard(kls, region) != NULL) {
       // Be sure to pin the oop load to the guard edge just created:
       Node* is_array_ctrl = region->in(region->req()-1);
-      Node* cma = basic_plus_adr(kls, in_bytes(arrayKlass::component_mirror_offset()));
+      Node* cma = basic_plus_adr(kls, in_bytes(ArrayKlass::component_mirror_offset()));
       Node* cmo = make_load(is_array_ctrl, cma, TypeInstPtr::MIRROR, T_OBJECT);
       phi->add_req(cmo);
     }
@@ -5032,7 +5032,7 @@ LibraryCallKit::generate_arraycopy(const TypePtr* adr_type,
       PreserveJVMState pjvms(this);
       set_control(not_subtype_ctrl);
       // (At this point we can assume disjoint_bases, since types differ.)
-      int ek_offset = in_bytes(objArrayKlass::element_klass_offset());
+      int ek_offset = in_bytes(ObjArrayKlass::element_klass_offset());
       Node* p1 = basic_plus_adr(dest_klass, ek_offset);
       Node* n1 = LoadKlassNode::make(_gvn, immutable_memory(), p1, TypeRawPtr::BOTTOM);
       Node* dest_elem_klass = _gvn.transform(n1);
diff --git a/src/share/vm/opto/memnode.cpp b/src/share/vm/opto/memnode.cpp
index 657d33105..351a17b3b 100644
--- a/src/share/vm/opto/memnode.cpp
+++ b/src/share/vm/opto/memnode.cpp
@@ -1671,9 +1671,9 @@ const Type *LoadNode::Value( PhaseTransform *phase ) const {
       }
       const Type* aift = load_array_final_field(tkls, klass);
       if (aift != NULL)  return aift;
-      if (tkls->offset() == in_bytes(arrayKlass::component_mirror_offset())
+      if (tkls->offset() == in_bytes(ArrayKlass::component_mirror_offset())
           && klass->is_array_klass()) {
-        // The field is arrayKlass::_component_mirror.  Return its (constant) value.
+        // The field is ArrayKlass::_component_mirror.  Return its (constant) value.
         // (Folds up aClassConstant.getComponentType, common in Arrays.copyOf.)
         assert(Opcode() == Op_LoadP, "must load an oop from _component_mirror");
         return TypeInstPtr::make(klass->as_array_klass()->component_mirror());
@@ -2014,7 +2014,7 @@ const Type *LoadNode::klass_value_common( PhaseTransform *phase ) const {
     if( !klass->is_loaded() )
       return _type;             // Bail out if not loaded
     if( klass->is_obj_array_klass() &&
-        tkls->offset() == in_bytes(objArrayKlass::element_klass_offset())) {
+        tkls->offset() == in_bytes(ObjArrayKlass::element_klass_offset())) {
       ciKlass* elem = klass->as_obj_array_klass()->element_klass();
       // // Always returning precise element type is incorrect,
       // // e.g., element type could be object and array may contain strings
@@ -2067,7 +2067,7 @@ Node* LoadNode::klass_identity_common(PhaseTransform *phase ) {
   }
 
   // Simplify k.java_mirror.as_klass to plain k, where k is a Klass*.
-  // Simplify ak.component_mirror.array_klass to plain ak, ak an arrayKlass.
+  // Simplify ak.component_mirror.array_klass to plain ak, ak an ArrayKlass.
   // See inline_native_Class_query for occurrences of these patterns.
   // Java Example:  x.getClass().isAssignableFrom(y)
   // Java Example:  Array.newInstance(x.getClass().getComponentType(), n)
@@ -2080,7 +2080,7 @@ Node* LoadNode::klass_identity_common(PhaseTransform *phase ) {
       && (offset == java_lang_Class::klass_offset_in_bytes() ||
           offset == java_lang_Class::array_klass_offset_in_bytes())) {
     // We are loading a special hidden field from a Class mirror,
-    // the field which points to its Klass or arrayKlass metaobject.
+    // the field which points to its Klass or ArrayKlass metaobject.
     if (base->is_Load()) {
       Node* adr2 = base->in(MemNode::Address);
       const TypeKlassPtr* tkls = phase->type(adr2)->isa_klassptr();
@@ -2091,7 +2091,7 @@ Node* LoadNode::klass_identity_common(PhaseTransform *phase ) {
           ) {
         int mirror_field = in_bytes(Klass::java_mirror_offset());
         if (offset == java_lang_Class::array_klass_offset_in_bytes()) {
-          mirror_field = in_bytes(arrayKlass::component_mirror_offset());
+          mirror_field = in_bytes(ArrayKlass::component_mirror_offset());
         }
         if (tkls->offset() == mirror_field) {
           return adr2->in(AddPNode::Base);
diff --git a/src/share/vm/opto/parseHelper.cpp b/src/share/vm/opto/parseHelper.cpp
index 5cb6bd241..19b0f5133 100644
--- a/src/share/vm/opto/parseHelper.cpp
+++ b/src/share/vm/opto/parseHelper.cpp
@@ -200,7 +200,7 @@ void Parse::array_store_check() {
   // Come here for polymorphic array klasses
 
   // Extract the array element class
-  int element_klass_offset = in_bytes(objArrayKlass::element_klass_offset());
+  int element_klass_offset = in_bytes(ObjArrayKlass::element_klass_offset());
   Node *p2 = basic_plus_adr(array_klass, array_klass, element_klass_offset);
   Node *a_e_klass = _gvn.transform( LoadKlassNode::make(_gvn, immutable_memory(), p2, tak) );
 
diff --git a/src/share/vm/opto/runtime.cpp b/src/share/vm/opto/runtime.cpp
index e33c042e1..bb050533d 100644
--- a/src/share/vm/opto/runtime.cpp
+++ b/src/share/vm/opto/runtime.cpp
@@ -286,13 +286,13 @@ JRT_BLOCK_ENTRY(void, OptoRuntime::new_array_C(Klass* array_type, int len, JavaT
   if (Klass::cast(array_type)->oop_is_typeArray()) {
     // The oopFactory likes to work with the element type.
     // (We could bypass the oopFactory, since it doesn't add much value.)
-    BasicType elem_type = typeArrayKlass::cast(array_type)->element_type();
+    BasicType elem_type = TypeArrayKlass::cast(array_type)->element_type();
     result = oopFactory::new_typeArray(elem_type, len, THREAD);
   } else {
     // Although the oopFactory likes to work with the elem_type,
     // the compiler prefers the array_type, since it must already have
     // that latter value in hand for the fast path.
-    Klass* elem_type = objArrayKlass::cast(array_type)->element_klass();
+    Klass* elem_type = ObjArrayKlass::cast(array_type)->element_klass();
     result = oopFactory::new_objArray(elem_type, len, THREAD);
   }
 
@@ -323,7 +323,7 @@ JRT_BLOCK_ENTRY(void, OptoRuntime::new_array_nozero_C(Klass* array_type, int len
 
   assert(Klass::cast(array_type)->oop_is_typeArray(), "should be called only for type array");
   // The oopFactory likes to work with the element type.
-  BasicType elem_type = typeArrayKlass::cast(array_type)->element_type();
+  BasicType elem_type = TypeArrayKlass::cast(array_type)->element_type();
   result = oopFactory::new_typeArray_nozero(elem_type, len, THREAD);
 
   // Pass oops back through thread local storage.  Our apparent type to Java
@@ -344,7 +344,7 @@ JRT_BLOCK_ENTRY(void, OptoRuntime::new_array_nozero_C(Klass* array_type, int len
       is_deoptimized_caller_frame(thread)) {
     // Zero array here if the caller is deoptimized.
     int size = ((typeArrayOop)result)->object_size();
-    BasicType elem_type = typeArrayKlass::cast(array_type)->element_type();
+    BasicType elem_type = TypeArrayKlass::cast(array_type)->element_type();
     const size_t hs = arrayOopDesc::header_size(elem_type);
     // Align to next 8 bytes to avoid trashing arrays's length.
     const size_t aligned_hs = align_object_offset(hs);
@@ -370,7 +370,7 @@ JRT_ENTRY(void, OptoRuntime::multianewarray2_C(Klass* elem_type, int len1, int l
   jint dims[2];
   dims[0] = len1;
   dims[1] = len2;
-  oop obj = arrayKlass::cast(elem_type)->multi_allocate(2, dims, THREAD);
+  oop obj = ArrayKlass::cast(elem_type)->multi_allocate(2, dims, THREAD);
   deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
   thread->set_vm_result(obj);
 JRT_END
@@ -386,7 +386,7 @@ JRT_ENTRY(void, OptoRuntime::multianewarray3_C(Klass* elem_type, int len1, int l
   dims[0] = len1;
   dims[1] = len2;
   dims[2] = len3;
-  oop obj = arrayKlass::cast(elem_type)->multi_allocate(3, dims, THREAD);
+  oop obj = ArrayKlass::cast(elem_type)->multi_allocate(3, dims, THREAD);
   deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
   thread->set_vm_result(obj);
 JRT_END
@@ -403,7 +403,7 @@ JRT_ENTRY(void, OptoRuntime::multianewarray4_C(Klass* elem_type, int len1, int l
   dims[1] = len2;
   dims[2] = len3;
   dims[3] = len4;
-  oop obj = arrayKlass::cast(elem_type)->multi_allocate(4, dims, THREAD);
+  oop obj = ArrayKlass::cast(elem_type)->multi_allocate(4, dims, THREAD);
   deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
   thread->set_vm_result(obj);
 JRT_END
@@ -421,7 +421,7 @@ JRT_ENTRY(void, OptoRuntime::multianewarray5_C(Klass* elem_type, int len1, int l
   dims[2] = len3;
   dims[3] = len4;
   dims[4] = len5;
-  oop obj = arrayKlass::cast(elem_type)->multi_allocate(5, dims, THREAD);
+  oop obj = ArrayKlass::cast(elem_type)->multi_allocate(5, dims, THREAD);
   deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
   thread->set_vm_result(obj);
 JRT_END
@@ -438,7 +438,7 @@ JRT_ENTRY(void, OptoRuntime::multianewarrayN_C(Klass* elem_type, arrayOopDesc* d
   jint *c_dims = NEW_RESOURCE_ARRAY(jint, len);
   Copy::conjoint_jints_atomic(j_dims, c_dims, len);
 
-  oop obj = arrayKlass::cast(elem_type)->multi_allocate(len, c_dims, THREAD);
+  oop obj = ArrayKlass::cast(elem_type)->multi_allocate(len, c_dims, THREAD);
   deoptimize_caller_frame(thread, HAS_PENDING_EXCEPTION);
   thread->set_vm_result(obj);
 JRT_END
diff --git a/src/share/vm/prims/jni.cpp b/src/share/vm/prims/jni.cpp
index c9450e9dc..a9d6ac222 100644
--- a/src/share/vm/prims/jni.cpp
+++ b/src/share/vm/prims/jni.cpp
@@ -3442,8 +3442,8 @@ JNI_ENTRY(jobjectArray, jni_NewObjectArray(JNIEnv *env, jsize length, jclass ele
   KlassHandle ek(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(elementClass)));
   Klass* ako = Klass::cast(ek())->array_klass(CHECK_NULL);
   KlassHandle ak = KlassHandle(THREAD, ako);
-  objArrayKlass::cast(ak())->initialize(CHECK_NULL);
-  objArrayOop result = objArrayKlass::cast(ak())->allocate(length, CHECK_NULL);
+  ObjArrayKlass::cast(ak())->initialize(CHECK_NULL);
+  objArrayOop result = ObjArrayKlass::cast(ak())->allocate(length, CHECK_NULL);
   oop initial_value = JNIHandles::resolve(initialElement);
   if (initial_value != NULL) {  // array already initialized with NULL
     for (int index = 0; index < length; index++) {
@@ -3502,7 +3502,7 @@ JNI_ENTRY(void, jni_SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize
   objArrayOop a = objArrayOop(JNIHandles::resolve_non_null(array));
   oop v = JNIHandles::resolve(value);
   if (a->is_within_bounds(index)) {
-    if (v == NULL || v->is_a(objArrayKlass::cast(a->klass())->element_klass())) {
+    if (v == NULL || v->is_a(ObjArrayKlass::cast(a->klass())->element_klass())) {
       a->obj_at_put(index, v);
     } else {
       THROW(vmSymbols::java_lang_ArrayStoreException());
@@ -3787,7 +3787,7 @@ jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start,
     THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
   } else { \
     if (len > 0) { \
-      int sc = typeArrayKlass::cast(src->klass())->log2_element_size(); \
+      int sc = TypeArrayKlass::cast(src->klass())->log2_element_size(); \
       memcpy((u_char*) buf, \
              (u_char*) src->Tag##_at_addr(start), \
              len << sc);                          \
@@ -3822,7 +3822,7 @@ jni_Get##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start,
     THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
   } else { \
     if (len > 0) { \
-      int sc = typeArrayKlass::cast(src->klass())->log2_element_size(); \
+      int sc = TypeArrayKlass::cast(src->klass())->log2_element_size(); \
       memcpy((u_char*) buf, \
              (u_char*) src->Tag##_at_addr(start), \
              len << sc);                          \
@@ -3871,7 +3871,7 @@ jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start,
     THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
   } else { \
     if (len > 0) { \
-      int sc = typeArrayKlass::cast(dst->klass())->log2_element_size(); \
+      int sc = TypeArrayKlass::cast(dst->klass())->log2_element_size(); \
       memcpy((u_char*) dst->Tag##_at_addr(start), \
              (u_char*) buf, \
              len << sc);    \
@@ -3906,7 +3906,7 @@ jni_Set##Result##ArrayRegion(JNIEnv *env, ElementType##Array array, jsize start,
     THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException()); \
   } else { \
     if (len > 0) { \
-      int sc = typeArrayKlass::cast(dst->klass())->log2_element_size(); \
+      int sc = TypeArrayKlass::cast(dst->klass())->log2_element_size(); \
       memcpy((u_char*) dst->Tag##_at_addr(start), \
              (u_char*) buf, \
              len << sc);    \
@@ -4251,7 +4251,7 @@ JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboole
   if (a->is_objArray()) {
     type = T_OBJECT;
   } else {
-    type = typeArrayKlass::cast(a->klass())->element_type();
+    type = TypeArrayKlass::cast(a->klass())->element_type();
   }
   void* ret = arrayOop(a)->base(type);
 #ifndef USDT2
diff --git a/src/share/vm/prims/jniCheck.cpp b/src/share/vm/prims/jniCheck.cpp
index 8182f8b56..aa8475f06 100644
--- a/src/share/vm/prims/jniCheck.cpp
+++ b/src/share/vm/prims/jniCheck.cpp
@@ -290,7 +290,7 @@ checkArray(JavaThread* thr, jarray jArray, int elementType)
 
   if (elementType != -1) {
     if (aOop->is_typeArray()) {
-      BasicType array_type = typeArrayKlass::cast(aOop->klass())->element_type();
+      BasicType array_type = TypeArrayKlass::cast(aOop->klass())->element_type();
       if (array_type != elementType)
         ReportJNIFatalError(thr, fatal_element_type_mismatch);
       } else if (aOop->is_objArray()) {
diff --git a/src/share/vm/prims/jvm.cpp b/src/share/vm/prims/jvm.cpp
index 63748cf36..34e1683ab 100644
--- a/src/share/vm/prims/jvm.cpp
+++ b/src/share/vm/prims/jvm.cpp
@@ -1048,7 +1048,7 @@ JVM_ENTRY(jobjectArray, JVM_GetClassSigners(JNIEnv *env, jclass cls))
   if (signers == NULL) return NULL;
 
   // copy of the signers array
-  Klass* element = objArrayKlass::cast(signers->klass())->element_klass();
+  Klass* element = ObjArrayKlass::cast(signers->klass())->element_klass();
   objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);
   for (int index = 0; index < signers->length(); index++) {
     signers_copy->obj_at_put(index, signers->obj_at(index));
@@ -3302,10 +3302,10 @@ JVM_ENTRY(jobject, JVM_AllocateNewArray(JNIEnv *env, jobject obj, jclass currCla
 
   if (k->oop_is_typeArray()) {
     // typeArray
-    result = typeArrayKlass::cast(k)->allocate(length, CHECK_NULL);
+    result = TypeArrayKlass::cast(k)->allocate(length, CHECK_NULL);
   } else if (k->oop_is_objArray()) {
     // objArray
-    objArrayKlass* oak = objArrayKlass::cast(k);
+    ObjArrayKlass* oak = ObjArrayKlass::cast(k);
     oak->initialize(CHECK_NULL); // make sure class is initialized (matches Classic VM behavior)
     result = oak->allocate(length, CHECK_NULL);
   } else {
@@ -4193,7 +4193,7 @@ JVM_ENTRY(jobjectArray, JVM_DumpThreads(JNIEnv *env, jclass threadClass, jobject
   }
 
   // check if threads is not an array of objects of Thread class
-  Klass* k = objArrayKlass::cast(ah->klass())->element_klass();
+  Klass* k = ObjArrayKlass::cast(ah->klass())->element_klass();
   if (k != SystemDictionary::Thread_klass()) {
     THROW_(vmSymbols::java_lang_IllegalArgumentException(), 0);
   }
diff --git a/src/share/vm/prims/jvmtiRedefineClasses.cpp b/src/share/vm/prims/jvmtiRedefineClasses.cpp
index ef614ff41..44be3d5f2 100644
--- a/src/share/vm/prims/jvmtiRedefineClasses.cpp
+++ b/src/share/vm/prims/jvmtiRedefineClasses.cpp
@@ -2606,7 +2606,7 @@ void VM_RedefineClasses::set_new_constant_pool(
 
 
 void VM_RedefineClasses::adjust_array_vtable(Klass* k_oop) {
-  arrayKlass* ak = arrayKlass::cast(k_oop);
+  ArrayKlass* ak = ArrayKlass::cast(k_oop);
   bool trace_name_printed = false;
   ak->vtable()->adjust_method_entries(_matching_old_methods,
                                       _matching_new_methods,
diff --git a/src/share/vm/prims/jvmtiTagMap.cpp b/src/share/vm/prims/jvmtiTagMap.cpp
index cd91a0c8d..56715bce1 100644
--- a/src/share/vm/prims/jvmtiTagMap.cpp
+++ b/src/share/vm/prims/jvmtiTagMap.cpp
@@ -1075,7 +1075,7 @@ static jint invoke_array_primitive_value_callback(jvmtiArrayPrimitiveValueCallba
 
   // get base address of first element
   typeArrayOop array = typeArrayOop(obj);
-  BasicType type = typeArrayKlass::cast(array->klass())->element_type();
+  BasicType type = TypeArrayKlass::cast(array->klass())->element_type();
   void* elements = array->base(type);
 
   // jvmtiPrimitiveType is defined so this mapping is always correct
@@ -2750,7 +2750,7 @@ inline bool VM_HeapWalkOperation::iterate_over_array(oop o) {
   objArrayOop array = objArrayOop(o);
 
   // array reference to its class
-  oop mirror = objArrayKlass::cast(array->klass())->java_mirror();
+  oop mirror = ObjArrayKlass::cast(array->klass())->java_mirror();
   if (!CallbackInvoker::report_class_reference(o, mirror)) {
     return false;
   }
diff --git a/src/share/vm/prims/unsafe.cpp b/src/share/vm/prims/unsafe.cpp
index c91a827e5..051c85975 100644
--- a/src/share/vm/prims/unsafe.cpp
+++ b/src/share/vm/prims/unsafe.cpp
@@ -802,7 +802,7 @@ static void getBaseAndScale(int& base, int& scale, jclass acls, TRAPS) {
     base  = arrayOopDesc::base_offset_in_bytes(T_OBJECT);
     scale = heapOopSize;
   } else if (k->oop_is_typeArray()) {
-    typeArrayKlass* tak = typeArrayKlass::cast(k);
+    TypeArrayKlass* tak = TypeArrayKlass::cast(k);
     base  = tak->array_header_in_bytes();
     assert(base == arrayOopDesc::base_offset_in_bytes(tak->element_type()), "array_header_size semantics ok");
     scale = (1 << tak->log2_element_size());
diff --git a/src/share/vm/runtime/advancedThresholdPolicy.cpp b/src/share/vm/runtime/advancedThresholdPolicy.cpp
index e111ea7b7..ce5804a60 100644
--- a/src/share/vm/runtime/advancedThresholdPolicy.cpp
+++ b/src/share/vm/runtime/advancedThresholdPolicy.cpp
@@ -156,7 +156,7 @@ bool AdvancedThresholdPolicy::is_method_profiled(Method* method) {
 // Called with the queue locked and with at least one element
 CompileTask* AdvancedThresholdPolicy::select_task(CompileQueue* compile_queue) {
   CompileTask *max_task = NULL;
-  Method* max_method;
+  Method* max_method = NULL;
   jlong t = os::javaTimeMillis();
   // Iterate through the queue and find a method with a maximum rate.
   for (CompileTask* task = compile_queue->first(); task != NULL;) {
diff --git a/src/share/vm/runtime/deoptimization.cpp b/src/share/vm/runtime/deoptimization.cpp
index 4fdd9deda..ad946a28f 100644
--- a/src/share/vm/runtime/deoptimization.cpp
+++ b/src/share/vm/runtime/deoptimization.cpp
@@ -755,12 +755,12 @@ bool Deoptimization::realloc_objects(JavaThread* thread, frame* fr, GrowableArra
       InstanceKlass* ik = InstanceKlass::cast(k());
       obj = ik->allocate_instance(CHECK_(false));
     } else if (k->oop_is_typeArray()) {
-      typeArrayKlass* ak = typeArrayKlass::cast(k());
+      TypeArrayKlass* ak = TypeArrayKlass::cast(k());
       assert(sv->field_size() % type2size[ak->element_type()] == 0, "non-integral array length");
       int len = sv->field_size() / type2size[ak->element_type()];
       obj = ak->allocate(len, CHECK_(false));
     } else if (k->oop_is_objArray()) {
-      objArrayKlass* ak = objArrayKlass::cast(k());
+      ObjArrayKlass* ak = ObjArrayKlass::cast(k());
       obj = ak->allocate(sv->field_size(), CHECK_(false));
     }
 
@@ -923,7 +923,7 @@ void Deoptimization::reassign_fields(frame* fr, RegisterMap* reg_map, GrowableAr
       FieldReassigner reassign(fr, reg_map, sv, obj());
       ik->do_nonstatic_fields(&reassign);
     } else if (k->oop_is_typeArray()) {
-      typeArrayKlass* ak = typeArrayKlass::cast(k());
+      TypeArrayKlass* ak = TypeArrayKlass::cast(k());
       reassign_type_array_elements(fr, reg_map, sv, (typeArrayOop) obj(), ak->element_type());
     } else if (k->oop_is_objArray()) {
       reassign_object_array_elements(fr, reg_map, sv, (objArrayOop) obj());
diff --git a/src/share/vm/runtime/reflection.cpp b/src/share/vm/runtime/reflection.cpp
index 2c5d26ed9..a999eadb2 100644
--- a/src/share/vm/runtime/reflection.cpp
+++ b/src/share/vm/runtime/reflection.cpp
@@ -212,7 +212,7 @@ BasicType Reflection::array_get(jvalue* value, arrayOop a, int index, TRAPS) {
     return T_OBJECT;
   } else {
     assert(a->is_typeArray(), "just checking");
-    BasicType type = typeArrayKlass::cast(a->klass())->element_type();
+    BasicType type = TypeArrayKlass::cast(a->klass())->element_type();
     switch (type) {
       case T_BOOLEAN:
         value->z = typeArrayOop(a)->bool_at(index);
@@ -254,7 +254,7 @@ void Reflection::array_set(jvalue* value, arrayOop a, int index, BasicType value
     if (value_type == T_OBJECT) {
       oop obj = (oop) value->l;
       if (obj != NULL) {
-        Klass* element_klass = objArrayKlass::cast(a->klass())->element_klass();
+        Klass* element_klass = ObjArrayKlass::cast(a->klass())->element_klass();
         if (!obj->is_a(element_klass)) {
           THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "array element type mismatch");
         }
@@ -263,7 +263,7 @@ void Reflection::array_set(jvalue* value, arrayOop a, int index, BasicType value
     }
   } else {
     assert(a->is_typeArray(), "just checking");
-    BasicType array_type = typeArrayKlass::cast(a->klass())->element_type();
+    BasicType array_type = TypeArrayKlass::cast(a->klass())->element_type();
     if (array_type != value_type) {
       // The widen operation can potentially throw an exception, but cannot block,
       // so typeArrayOop a is safe if the call succeeds.
@@ -313,7 +313,7 @@ Klass* Reflection::basic_type_mirror_to_arrayklass(oop basic_type_mirror, TRAPS)
 
 
 oop Reflection:: basic_type_arrayklass_to_mirror(Klass* basic_type_arrayklass, TRAPS) {
-  BasicType type = typeArrayKlass::cast(basic_type_arrayklass)->element_type();
+  BasicType type = TypeArrayKlass::cast(basic_type_arrayklass)->element_type();
   return Universe::java_mirror(type);
 }
 
@@ -327,10 +327,10 @@ arrayOop Reflection::reflect_new_array(oop element_mirror, jint length, TRAPS) {
   }
   if (java_lang_Class::is_primitive(element_mirror)) {
     Klass* tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);
-    return typeArrayKlass::cast(tak)->allocate(length, THREAD);
+    return TypeArrayKlass::cast(tak)->allocate(length, THREAD);
   } else {
     Klass* k = java_lang_Class::as_Klass(element_mirror);
-    if (Klass::cast(k)->oop_is_array() && arrayKlass::cast(k)->dimension() >= MAX_DIM) {
+    if (Klass::cast(k)->oop_is_array() && ArrayKlass::cast(k)->dimension() >= MAX_DIM) {
       THROW_0(vmSymbols::java_lang_IllegalArgumentException());
     }
     return oopFactory::new_objArray(k, length, THREAD);
@@ -340,7 +340,7 @@ arrayOop Reflection::reflect_new_array(oop element_mirror, jint length, TRAPS) {
 
 arrayOop Reflection::reflect_new_multi_array(oop element_mirror, typeArrayOop dim_array, TRAPS) {
   assert(dim_array->is_typeArray(), "just checking");
-  assert(typeArrayKlass::cast(dim_array->klass())->element_type() == T_INT, "just checking");
+  assert(TypeArrayKlass::cast(dim_array->klass())->element_type() == T_INT, "just checking");
 
   if (element_mirror == NULL) {
     THROW_0(vmSymbols::java_lang_NullPointerException());
@@ -367,7 +367,7 @@ arrayOop Reflection::reflect_new_multi_array(oop element_mirror, typeArrayOop di
   } else {
     klass = java_lang_Class::as_Klass(element_mirror);
     if (Klass::cast(klass)->oop_is_array()) {
-      int k_dim = arrayKlass::cast(klass)->dimension();
+      int k_dim = ArrayKlass::cast(klass)->dimension();
       if (k_dim + len > MAX_DIM) {
         THROW_0(vmSymbols::java_lang_IllegalArgumentException());
       }
@@ -375,7 +375,7 @@ arrayOop Reflection::reflect_new_multi_array(oop element_mirror, typeArrayOop di
     }
   }
   klass = Klass::cast(klass)->array_klass(dim, CHECK_NULL);
-  oop obj = arrayKlass::cast(klass)->multi_allocate(len, dimensions, THREAD);
+  oop obj = ArrayKlass::cast(klass)->multi_allocate(len, dimensions, THREAD);
   assert(obj->is_array(), "just checking");
   return arrayOop(obj);
 }
@@ -391,17 +391,17 @@ oop Reflection::array_component_type(oop mirror, TRAPS) {
     return NULL;
   }
 
-  oop result = arrayKlass::cast(klass)->component_mirror();
+  oop result = ArrayKlass::cast(klass)->component_mirror();
 #ifdef ASSERT
   oop result2 = NULL;
-  if (arrayKlass::cast(klass)->dimension() == 1) {
+  if (ArrayKlass::cast(klass)->dimension() == 1) {
     if (Klass::cast(klass)->oop_is_typeArray()) {
       result2 = basic_type_arrayklass_to_mirror(klass, CHECK_NULL);
     } else {
-      result2 = Klass::cast(objArrayKlass::cast(klass)->element_klass())->java_mirror();
+      result2 = Klass::cast(ObjArrayKlass::cast(klass)->element_klass())->java_mirror();
     }
   } else {
-    Klass* lower_dim = arrayKlass::cast(klass)->lower_dimension();
+    Klass* lower_dim = ArrayKlass::cast(klass)->lower_dimension();
     assert(Klass::cast(lower_dim)->oop_is_array(), "just checking");
     result2 = Klass::cast(lower_dim)->java_mirror();
   }
diff --git a/src/share/vm/runtime/sharedRuntime.cpp b/src/share/vm/runtime/sharedRuntime.cpp
index a0ef0abc2..7a7c97e13 100644
--- a/src/share/vm/runtime/sharedRuntime.cpp
+++ b/src/share/vm/runtime/sharedRuntime.cpp
@@ -2705,7 +2705,7 @@ void SharedRuntime::get_utf(oopDesc* src, address dst) {
   int          jlsLen    = java_lang_String::length(src);
   jchar*       jlsPos    = (jlsLen == 0) ? NULL :
                                            jlsValue->char_at_addr(jlsOffset);
-  assert(typeArrayKlass::cast(jlsValue->klass())->element_type() == T_CHAR, "compressed string");
+  assert(TypeArrayKlass::cast(jlsValue->klass())->element_type() == T_CHAR, "compressed string");
   (void) UNICODE::as_utf8(jlsPos, jlsLen, (char *)dst, max_dtrace_string_size);
 }
 #endif // ndef HAVE_DTRACE_H
diff --git a/src/share/vm/runtime/vmStructs.cpp b/src/share/vm/runtime/vmStructs.cpp
index 1f0f2becc..38ebcc184 100644
--- a/src/share/vm/runtime/vmStructs.cpp
+++ b/src/share/vm/runtime/vmStructs.cpp
@@ -268,12 +268,12 @@ typedef TwoOopHashtable<Symbol*, mtClass>     SymbolTwoOopHashtable;
   volatile_nonstatic_field(oopDesc,            _metadata._klass,                              Klass*)                                \
   volatile_nonstatic_field(oopDesc,            _metadata._compressed_klass,                   narrowOop)                             \
      static_field(oopDesc,                     _bs,                                           BarrierSet*)                           \
-  nonstatic_field(arrayKlass,                  _dimension,                                    int)                                   \
-  volatile_nonstatic_field(arrayKlass,         _higher_dimension,                             Klass*)                                \
-  volatile_nonstatic_field(arrayKlass,         _lower_dimension,                              Klass*)                                \
-  nonstatic_field(arrayKlass,                  _vtable_len,                                   int)                                   \
-  nonstatic_field(arrayKlass,                  _alloc_size,                                   juint)                                 \
-  nonstatic_field(arrayKlass,                  _component_mirror,                             oop)                                   \
+  nonstatic_field(ArrayKlass,                  _dimension,                                    int)                                   \
+  volatile_nonstatic_field(ArrayKlass,         _higher_dimension,                             Klass*)                                \
+  volatile_nonstatic_field(ArrayKlass,         _lower_dimension,                              Klass*)                                \
+  nonstatic_field(ArrayKlass,                  _vtable_len,                                   int)                                   \
+  nonstatic_field(ArrayKlass,                  _alloc_size,                                   juint)                                 \
+  nonstatic_field(ArrayKlass,                  _component_mirror,                             oop)                                   \
   nonstatic_field(CompiledICHolder,     _holder_method,                                Method*)                        \
   nonstatic_field(CompiledICHolder,     _holder_klass,                                 Klass*)                                \
   nonstatic_field(ConstantPool,         _tags,                                         Array<u1>*)                            \
@@ -379,13 +379,13 @@ typedef TwoOopHashtable<Symbol*, mtClass>     SymbolTwoOopHashtable;
   nonstatic_field(ConstMethod,          _signature_index,                              u2)                                    \
   nonstatic_field(ConstMethod,          _method_idnum,                                 u2)                                    \
   nonstatic_field(ConstMethod,          _generic_signature_index,                      u2)                                    \
-  nonstatic_field(objArrayKlass,               _element_klass,                                Klass*)                                \
-  nonstatic_field(objArrayKlass,               _bottom_klass,                                 Klass*)                                \
+  nonstatic_field(ObjArrayKlass,               _element_klass,                                Klass*)                                \
+  nonstatic_field(ObjArrayKlass,               _bottom_klass,                                 Klass*)                                \
   volatile_nonstatic_field(Symbol,             _refcount,                                     int)                                   \
   nonstatic_field(Symbol,                      _identity_hash,                                int)                                   \
   nonstatic_field(Symbol,                      _length,                                       unsigned short)                        \
   unchecked_nonstatic_field(Symbol,            _body,                                         sizeof(jbyte)) /* NOTE: no type */     \
-  nonstatic_field(typeArrayKlass,              _max_length,                                   int)                                   \
+  nonstatic_field(TypeArrayKlass,              _max_length,                                   int)                                   \
                                                                                                                                      \
   /***********************/                                                                                                          \
   /* Constant Pool Cache */                                                                                                          \
@@ -1370,9 +1370,9 @@ typedef TwoOopHashtable<Symbol*, mtClass>     SymbolTwoOopHashtable;
   declare_toplevel_type(MetaspaceObj)                                     \
     declare_type(Metadata, MetaspaceObj)                                  \
     declare_type(Klass, Metadata)                                         \
-           declare_type(arrayKlass, Klass)                                \
-           declare_type(objArrayKlass, arrayKlass)                        \
-           declare_type(typeArrayKlass, arrayKlass)                       \
+           declare_type(ArrayKlass, Klass)                                \
+           declare_type(ObjArrayKlass, ArrayKlass)                        \
+           declare_type(TypeArrayKlass, ArrayKlass)                       \
       declare_type(InstanceKlass, Klass)                                  \
         declare_type(InstanceClassLoaderKlass, InstanceKlass)             \
         declare_type(InstanceMirrorKlass, InstanceKlass)                  \
diff --git a/src/share/vm/services/attachListener.cpp b/src/share/vm/services/attachListener.cpp
index 91378b5d7..983f3f95f 100644
--- a/src/share/vm/services/attachListener.cpp
+++ b/src/share/vm/services/attachListener.cpp
@@ -88,7 +88,7 @@ static jint get_properties(AttachOperation* op, outputStream* out, Symbol* seria
   // The result should be a [B
   oop res = (oop)result.get_jobject();
   assert(res->is_typeArray(), "just checking");
-  assert(typeArrayKlass::cast(res->klass())->element_type() == T_BYTE, "just checking");
+  assert(TypeArrayKlass::cast(res->klass())->element_type() == T_BYTE, "just checking");
 
   // copy the bytes to the output stream
   typeArrayOop ba = typeArrayOop(res);
diff --git a/src/share/vm/services/diagnosticCommand.cpp b/src/share/vm/services/diagnosticCommand.cpp
index 9be87ee3d..e5e8a3e9a 100644
--- a/src/share/vm/services/diagnosticCommand.cpp
+++ b/src/share/vm/services/diagnosticCommand.cpp
@@ -204,7 +204,7 @@ void PrintSystemPropertiesDCmd::execute(TRAPS) {
   // The result should be a [B
   oop res = (oop)result.get_jobject();
   assert(res->is_typeArray(), "just checking");
-  assert(typeArrayKlass::cast(res->klass())->element_type() == T_BYTE, "just checking");
+  assert(TypeArrayKlass::cast(res->klass())->element_type() == T_BYTE, "just checking");
 
   // copy the bytes to the output stream
   typeArrayOop ba = typeArrayOop(res);
diff --git a/src/share/vm/services/heapDumper.cpp b/src/share/vm/services/heapDumper.cpp
index 64f0251b6..fe3f50df6 100644
--- a/src/share/vm/services/heapDumper.cpp
+++ b/src/share/vm/services/heapDumper.cpp
@@ -933,7 +933,7 @@ void DumperSupport::dump_class_and_array_classes(DumpWriter* writer, Klass* k) {
   k = klass->array_klass_or_null();
   while (k != NULL) {
     Klass* klass = Klass::cast(k);
-    assert(klass->oop_is_objArray(), "not an objArrayKlass");
+    assert(klass->oop_is_objArray(), "not an ObjArrayKlass");
 
     writer->write_u1(HPROF_GC_CLASS_DUMP);
     writer->write_classID(klass);
@@ -1016,7 +1016,7 @@ void DumperSupport::dump_object_array(DumpWriter* writer, objArrayOop array) {
 
 // creates HPROF_GC_PRIM_ARRAY_DUMP record for the given type array
 void DumperSupport::dump_prim_array(DumpWriter* writer, typeArrayOop array) {
-  BasicType type = typeArrayKlass::cast(array->klass())->element_type();
+  BasicType type = TypeArrayKlass::cast(array->klass())->element_type();
 
   writer->write_u1(HPROF_GC_PRIM_ARRAY_DUMP);
   writer->write_objectID(array);
diff --git a/src/share/vm/services/management.cpp b/src/share/vm/services/management.cpp
index f73f113da..12d4c3397 100644
--- a/src/share/vm/services/management.cpp
+++ b/src/share/vm/services/management.cpp
@@ -426,7 +426,7 @@ static void validate_thread_id_array(typeArrayHandle ids_ah, TRAPS) {
 static void validate_thread_info_array(objArrayHandle infoArray_h, TRAPS) {
   // check if the element of infoArray is of type ThreadInfo class
   Klass* threadinfo_klass = Management::java_lang_management_ThreadInfo_klass(CHECK);
-  Klass* element_klass = objArrayKlass::cast(infoArray_h->klass())->element_klass();
+  Klass* element_klass = ObjArrayKlass::cast(infoArray_h->klass())->element_klass();
   if (element_klass != threadinfo_klass) {
     THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
               "infoArray element type is not ThreadInfo class");
@@ -1715,7 +1715,7 @@ JVM_ENTRY(jint, jmm_GetVMGlobals(JNIEnv *env,
     objArrayOop ta = objArrayOop(JNIHandles::resolve_non_null(names));
     objArrayHandle names_ah(THREAD, ta);
     // Make sure we have a String array
-    Klass* element_klass = objArrayKlass::cast(names_ah->klass())->element_klass();
+    Klass* element_klass = ObjArrayKlass::cast(names_ah->klass())->element_klass();
     if (element_klass != SystemDictionary::String_klass()) {
       THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
                  "Array element type is not String class", 0);
@@ -1891,7 +1891,7 @@ JVM_ENTRY(jint, jmm_GetInternalThreadTimes(JNIEnv *env,
   objArrayHandle names_ah(THREAD, na);
 
   // Make sure we have a String array
-  Klass* element_klass = objArrayKlass::cast(names_ah->klass())->element_klass();
+  Klass* element_klass = ObjArrayKlass::cast(names_ah->klass())->element_klass();
   if (element_klass != SystemDictionary::String_klass()) {
     THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
                "Array element type is not String class", 0);
@@ -2008,7 +2008,7 @@ static objArrayOop get_memory_usage_objArray(jobjectArray array, int length, TRA
 
   // check if the element of array is of type MemoryUsage class
   Klass* usage_klass = Management::java_lang_management_MemoryUsage_klass(CHECK_0);
-  Klass* element_klass = objArrayKlass::cast(array_h->klass())->element_klass();
+  Klass* element_klass = ObjArrayKlass::cast(array_h->klass())->element_klass();
   if (element_klass != usage_klass) {
     THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
                "The element type is not MemoryUsage class", 0);
@@ -2156,7 +2156,7 @@ JVM_ENTRY(void, jmm_GetDiagnosticCommandInfo(JNIEnv *env, jobjectArray cmds,
   objArrayHandle cmds_ah(THREAD, ca);
 
   // Make sure we have a String array
-  Klass* element_klass = objArrayKlass::cast(cmds_ah->klass())->element_klass();
+  Klass* element_klass = ObjArrayKlass::cast(cmds_ah->klass())->element_klass();
   if (element_klass != SystemDictionary::String_klass()) {
     THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
                "Array element type is not String class");
diff --git a/src/share/vm/services/threadService.cpp b/src/share/vm/services/threadService.cpp
index dd33b7a6d..b1c92c0b1 100644
--- a/src/share/vm/services/threadService.cpp
+++ b/src/share/vm/services/threadService.cpp
@@ -250,7 +250,7 @@ Handle ThreadService::dump_stack_traces(GrowableArray<instanceHandle>* threads,
 
   ResourceMark rm(THREAD);
   Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_StackTraceElement_array(), true, CHECK_NH);
-  objArrayKlass* ik = objArrayKlass::cast(k);
+  ObjArrayKlass* ik = ObjArrayKlass::cast(k);
   objArrayOop r = oopFactory::new_objArray(ik, num_threads, CHECK_NH);
   objArrayHandle result_obj(THREAD, r);
 
diff --git a/src/share/vm/shark/sharkRuntime.cpp b/src/share/vm/shark/sharkRuntime.cpp
index 14a886bc5..fd9916e11 100644
--- a/src/share/vm/shark/sharkRuntime.cpp
+++ b/src/share/vm/shark/sharkRuntime.cpp
@@ -129,7 +129,7 @@ JRT_ENTRY(void, SharkRuntime::multianewarray(JavaThread* thread,
                                              int         ndims,
                                              int*        dims))
   Klass* klass = method(thread)->constants()->klass_at(index, CHECK);
-  oop obj = arrayKlass::cast(klass)->multi_allocate(ndims, dims, CHECK);
+  oop obj = ArrayKlass::cast(klass)->multi_allocate(ndims, dims, CHECK);
   thread->set_vm_result(obj);
 JRT_END