# HG changeset patch # User coleenp # Date 1348915200 14400 # Node ID e3cf184080bc20af85bdc6ca00f470ea1f7caeea # Parent b01a48301e679935b76b72c9facd475cc2f14f87 8000213: NPG: Should have renamed arrayKlass and typeArrayKlass Summary: Capitalize these metadata types (and objArrayKlass) Reviewed-by: stefank, twisti, kvn diff -r b01a48301e67 -r e3cf184080bc hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ArrayKlass.java --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ArrayKlass.java Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ArrayKlass.java Sat Sep 29 06:40:00 2012 -0400 @@ -44,7 +44,7 @@ } private static synchronized void initialize(TypeDataBase db) throws WrongTypeException { - Type type = db.lookupType("arrayKlass"); + Type type = db.lookupType("ArrayKlass"); dimension = new CIntField(type.getCIntegerField("_dimension"), 0); higherDimension = new MetadataField(type.getAddressField("_higher_dimension"), 0); lowerDimension = new MetadataField(type.getAddressField("_lower_dimension"), 0); diff -r b01a48301e67 -r e3cf184080bc hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Klass.java --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Klass.java Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Klass.java Sat Sep 29 06:40:00 2012 -0400 @@ -188,11 +188,11 @@ public Klass arrayKlassOrNull() { return arrayKlassImpl(true); } public Klass arrayKlassImpl(boolean orNull, int rank) { - throw new RuntimeException("array_klass should be dispatched to InstanceKlass, objArrayKlass or typeArrayKlass"); + throw new RuntimeException("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass"); } public Klass arrayKlassImpl(boolean orNull) { - throw new RuntimeException("array_klass should be dispatched to InstanceKlass, objArrayKlass or typeArrayKlass"); + throw new RuntimeException("array_klass should be dispatched to InstanceKlass, ObjArrayKlass or TypeArrayKlass"); } // This returns the name in the form java/lang/String which isn't really a signature diff -r b01a48301e67 -r e3cf184080bc hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Metadata.java --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Metadata.java Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Metadata.java Sat Sep 29 06:40:00 2012 -0400 @@ -55,8 +55,8 @@ metadataConstructor.addMapping("InstanceMirrorKlass", InstanceMirrorKlass.class); metadataConstructor.addMapping("InstanceRefKlass", InstanceRefKlass.class); metadataConstructor.addMapping("InstanceClassLoaderKlass", InstanceClassLoaderKlass.class); - metadataConstructor.addMapping("typeArrayKlass", TypeArrayKlass.class); - metadataConstructor.addMapping("objArrayKlass", ObjArrayKlass.class); + metadataConstructor.addMapping("TypeArrayKlass", TypeArrayKlass.class); + metadataConstructor.addMapping("ObjArrayKlass", ObjArrayKlass.class); metadataConstructor.addMapping("Method", Method.class); metadataConstructor.addMapping("MethodData", MethodData.class); metadataConstructor.addMapping("ConstMethod", ConstMethod.class); diff -r b01a48301e67 -r e3cf184080bc hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ObjArrayKlass.java --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ObjArrayKlass.java Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/ObjArrayKlass.java Sat Sep 29 06:40:00 2012 -0400 @@ -43,7 +43,7 @@ } private static synchronized void initialize(TypeDataBase db) throws WrongTypeException { - Type type = db.lookupType("objArrayKlass"); + Type type = db.lookupType("ObjArrayKlass"); elementKlass = new MetadataField(type.getAddressField("_element_klass"), 0); bottomKlass = new MetadataField(type.getAddressField("_bottom_klass"), 0); } diff -r b01a48301e67 -r e3cf184080bc hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/TypeArrayKlass.java --- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/TypeArrayKlass.java Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/TypeArrayKlass.java Sat Sep 29 06:40:00 2012 -0400 @@ -31,7 +31,7 @@ import sun.jvm.hotspot.types.*; import sun.jvm.hotspot.utilities.*; -// TypeArrayKlass is a proxy for typeArrayKlass in the JVM +// TypeArrayKlass is a proxy for TypeArrayKlass in the JVM public class TypeArrayKlass extends ArrayKlass { static { @@ -43,7 +43,7 @@ } private static synchronized void initialize(TypeDataBase db) throws WrongTypeException { - Type t = db.lookupType("typeArrayKlass"); + Type t = db.lookupType("TypeArrayKlass"); maxLength = new CIntField(t.getCIntegerField("_max_length"), 0); } diff -r b01a48301e67 -r e3cf184080bc hotspot/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp --- a/hotspot/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -2290,7 +2290,7 @@ __ mov(length, len); __ load_klass(dst, tmp); - int ek_offset = in_bytes(objArrayKlass::element_klass_offset()); + int ek_offset = in_bytes(ObjArrayKlass::element_klass_offset()); __ ld_ptr(tmp, ek_offset, super_k); int sco_offset = in_bytes(Klass::super_check_offset_offset()); @@ -2781,7 +2781,7 @@ __ load_klass(value, klass_RInfo); // get instance klass - __ ld_ptr(Address(k_RInfo, objArrayKlass::element_klass_offset()), k_RInfo); + __ ld_ptr(Address(k_RInfo, ObjArrayKlass::element_klass_offset()), k_RInfo); // perform the fast part of the checking logic __ check_klass_subtype_fast_path(klass_RInfo, k_RInfo, Rtmp1, O7, success_target, failure_target, NULL); diff -r b01a48301e67 -r e3cf184080bc hotspot/src/cpu/sparc/vm/stubGenerator_sparc.cpp --- a/hotspot/src/cpu/sparc/vm/stubGenerator_sparc.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/cpu/sparc/vm/stubGenerator_sparc.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -3091,7 +3091,7 @@ arraycopy_range_checks(src, src_pos, dst, dst_pos, length, O5_temp, G4_dst_klass, L_failed); - // typeArrayKlass + // TypeArrayKlass // // src_addr = (src + array_header_in_bytes()) + (src_pos << log2elemsize); // dst_addr = (dst + array_header_in_bytes()) + (dst_pos << log2elemsize); @@ -3142,7 +3142,7 @@ __ br(Assembler::always, false, Assembler::pt, entry_jlong_arraycopy); __ delayed()->signx(length, count); // length - // objArrayKlass + // ObjArrayKlass __ BIND(L_objArray); // live at this point: G3_src_klass, G4_dst_klass, src[_pos], dst[_pos], length @@ -3198,8 +3198,8 @@ generate_type_check(G3_src_klass, sco_temp, G4_dst_klass, O5_temp, L_plain_copy); - // Fetch destination element klass from the objArrayKlass header. - int ek_offset = in_bytes(objArrayKlass::element_klass_offset()); + // Fetch destination element klass from the ObjArrayKlass header. + int ek_offset = in_bytes(ObjArrayKlass::element_klass_offset()); // the checkcast_copy loop needs two extra arguments: __ ld_ptr(G4_dst_klass, ek_offset, O4); // dest elem klass diff -r b01a48301e67 -r e3cf184080bc hotspot/src/cpu/sparc/vm/templateTable_sparc.cpp --- a/hotspot/src/cpu/sparc/vm/templateTable_sparc.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/cpu/sparc/vm/templateTable_sparc.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -867,7 +867,7 @@ // do fast instanceof cache test - __ ld_ptr(O4, in_bytes(objArrayKlass::element_klass_offset()), O4); + __ ld_ptr(O4, in_bytes(ObjArrayKlass::element_klass_offset()), O4); assert(Otos_i == O0, "just checking"); diff -r b01a48301e67 -r e3cf184080bc hotspot/src/cpu/x86/vm/assembler_x86.cpp --- a/hotspot/src/cpu/x86/vm/assembler_x86.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/cpu/x86/vm/assembler_x86.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -10616,7 +10616,7 @@ // Array header size is 12 bytes in 32-bit VM // + 6 bytes for 3 chars == 18 bytes, // enough space to load vec and shift. - assert(HeapWordSize*typeArrayKlass::header_size() >= 12,"sanity"); + assert(HeapWordSize*TypeArrayKlass::header_size() >= 12,"sanity"); movdqu(vec, Address(str2, (int_cnt2*2)-16)); psrldq(vec, 16-(int_cnt2*2)); } diff -r b01a48301e67 -r e3cf184080bc hotspot/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp --- a/hotspot/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -1881,7 +1881,7 @@ __ load_klass(klass_RInfo, value); // get instance klass (it's already uncompressed) - __ movptr(k_RInfo, Address(k_RInfo, objArrayKlass::element_klass_offset())); + __ movptr(k_RInfo, Address(k_RInfo, ObjArrayKlass::element_klass_offset())); // perform the fast part of the checking logic __ check_klass_subtype_fast_path(klass_RInfo, k_RInfo, Rtmp1, success_target, failure_target, NULL); // call out-of-line instance of __ check_klass_subtype_slow_path(...): @@ -3349,7 +3349,7 @@ #ifndef _LP64 __ movptr(tmp, dst_klass_addr); - __ movptr(tmp, Address(tmp, objArrayKlass::element_klass_offset())); + __ movptr(tmp, Address(tmp, ObjArrayKlass::element_klass_offset())); __ push(tmp); __ movl(tmp, Address(tmp, Klass::super_check_offset_offset())); __ push(tmp); @@ -3375,14 +3375,14 @@ // Allocate abi space for args but be sure to keep stack aligned __ subptr(rsp, 6*wordSize); __ load_klass(c_rarg3, dst); - __ movptr(c_rarg3, Address(c_rarg3, objArrayKlass::element_klass_offset())); + __ movptr(c_rarg3, Address(c_rarg3, ObjArrayKlass::element_klass_offset())); store_parameter(c_rarg3, 4); __ movl(c_rarg3, Address(c_rarg3, Klass::super_check_offset_offset())); __ call(RuntimeAddress(copyfunc_addr)); __ addptr(rsp, 6*wordSize); #else __ load_klass(c_rarg4, dst); - __ movptr(c_rarg4, Address(c_rarg4, objArrayKlass::element_klass_offset())); + __ movptr(c_rarg4, Address(c_rarg4, ObjArrayKlass::element_klass_offset())); __ movl(c_rarg3, Address(c_rarg4, Klass::super_check_offset_offset())); __ call(RuntimeAddress(copyfunc_addr)); #endif diff -r b01a48301e67 -r e3cf184080bc hotspot/src/cpu/x86/vm/stubGenerator_x86_32.cpp --- a/hotspot/src/cpu/x86/vm/stubGenerator_x86_32.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/cpu/x86/vm/stubGenerator_x86_32.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -1801,7 +1801,7 @@ assert_different_registers(src, src_pos, dst, dst_pos, rcx_lh); arraycopy_range_checks(src, src_pos, dst, dst_pos, LENGTH, L_failed); - // typeArrayKlass + // TypeArrayKlass // // src_addr = (src + array_header_in_bytes()) + (src_pos << log2elemsize); // dst_addr = (dst + array_header_in_bytes()) + (dst_pos << log2elemsize); @@ -1864,7 +1864,7 @@ __ leave(); // required for proper stackwalking of RuntimeStub frame __ ret(0); - // objArrayKlass + // ObjArrayKlass __ BIND(L_objArray); // live at this point: rcx_src_klass, src[_pos], dst[_pos] @@ -1894,7 +1894,7 @@ // live at this point: rcx_src_klass, dst[_pos], src[_pos] { // Handy offsets: - int ek_offset = in_bytes(objArrayKlass::element_klass_offset()); + int ek_offset = in_bytes(ObjArrayKlass::element_klass_offset()); int sco_offset = in_bytes(Klass::super_check_offset_offset()); Register rsi_dst_klass = rsi; diff -r b01a48301e67 -r e3cf184080bc hotspot/src/cpu/x86/vm/stubGenerator_x86_64.cpp --- a/hotspot/src/cpu/x86/vm/stubGenerator_x86_64.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/cpu/x86/vm/stubGenerator_x86_64.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -2604,7 +2604,7 @@ arraycopy_range_checks(src, src_pos, dst, dst_pos, r11_length, r10, L_failed); - // typeArrayKlass + // TypeArrayKlass // // src_addr = (src + array_header_in_bytes()) + (src_pos << log2elemsize); // dst_addr = (dst + array_header_in_bytes()) + (dst_pos << log2elemsize); @@ -2670,7 +2670,7 @@ __ movl2ptr(count, r11_length); // length __ jump(RuntimeAddress(long_copy_entry)); - // objArrayKlass + // ObjArrayKlass __ BIND(L_objArray); // live at this point: r10_src_klass, r11_length, src[_pos], dst[_pos] @@ -2723,8 +2723,8 @@ assert_clean_int(sco_temp, rax); generate_type_check(r10_src_klass, sco_temp, r11_dst_klass, L_plain_copy); - // Fetch destination element klass from the objArrayKlass header. - int ek_offset = in_bytes(objArrayKlass::element_klass_offset()); + // Fetch destination element klass from the ObjArrayKlass header. + int ek_offset = in_bytes(ObjArrayKlass::element_klass_offset()); __ movptr(r11_dst_klass, Address(r11_dst_klass, ek_offset)); __ movl( sco_temp, Address(r11_dst_klass, sco_offset)); assert_clean_int(sco_temp, rax); diff -r b01a48301e67 -r e3cf184080bc hotspot/src/cpu/x86/vm/templateTable_x86_32.cpp --- a/hotspot/src/cpu/x86/vm/templateTable_x86_32.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/cpu/x86/vm/templateTable_x86_32.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -949,7 +949,7 @@ __ load_klass(rbx, rax); // Move superklass into EAX __ load_klass(rax, rdx); - __ movptr(rax, Address(rax, objArrayKlass::element_klass_offset())); + __ movptr(rax, Address(rax, ObjArrayKlass::element_klass_offset())); // Compress array+index*wordSize+12 into a single register. Frees ECX. __ lea(rdx, element_address); diff -r b01a48301e67 -r e3cf184080bc hotspot/src/cpu/x86/vm/templateTable_x86_64.cpp --- a/hotspot/src/cpu/x86/vm/templateTable_x86_64.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/cpu/x86/vm/templateTable_x86_64.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -970,7 +970,7 @@ // Move superklass into rax __ load_klass(rax, rdx); __ movptr(rax, Address(rax, - objArrayKlass::element_klass_offset())); + ObjArrayKlass::element_klass_offset())); // Compress array + index*oopSize + 12 into a single register. Frees rcx. __ lea(rdx, element_address); diff -r b01a48301e67 -r e3cf184080bc hotspot/src/cpu/x86/vm/x86_32.ad --- a/hotspot/src/cpu/x86/vm/x86_32.ad Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/cpu/x86/vm/x86_32.ad Sat Sep 29 06:40:00 2012 -0400 @@ -12145,8 +12145,8 @@ ins_cost(1100); // slightly larger than the next version format %{ "MOV EDI,[$sub+Klass::secondary_supers]\n\t" - "MOV ECX,[EDI+arrayKlass::length]\t# length to scan\n\t" - "ADD EDI,arrayKlass::base_offset\t# Skip to start of data; set NZ in case count is zero\n\t" + "MOV ECX,[EDI+ArrayKlass::length]\t# length to scan\n\t" + "ADD EDI,ArrayKlass::base_offset\t# Skip to start of data; set NZ in case count is zero\n\t" "REPNE SCASD\t# Scan *EDI++ for a match with EAX while CX-- != 0\n\t" "JNE,s miss\t\t# Missed: EDI not-zero\n\t" "MOV [$sub+Klass::secondary_super_cache],$super\t# Hit: update cache\n\t" @@ -12164,8 +12164,8 @@ ins_cost(1000); format %{ "MOV EDI,[$sub+Klass::secondary_supers]\n\t" - "MOV ECX,[EDI+arrayKlass::length]\t# length to scan\n\t" - "ADD EDI,arrayKlass::base_offset\t# Skip to start of data; set NZ in case count is zero\n\t" + "MOV ECX,[EDI+ArrayKlass::length]\t# length to scan\n\t" + "ADD EDI,ArrayKlass::base_offset\t# Skip to start of data; set NZ in case count is zero\n\t" "REPNE SCASD\t# Scan *EDI++ for a match with EAX while CX-- != 0\n\t" "JNE,s miss\t\t# Missed: flags NZ\n\t" "MOV [$sub+Klass::secondary_super_cache],$super\t# Hit: update cache, flags Z\n\t" diff -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/c1/c1_Runtime1.cpp --- a/hotspot/src/share/vm/c1/c1_Runtime1.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/c1/c1_Runtime1.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -327,7 +327,7 @@ // 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 @@ // 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 @@ 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 @@ 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/ci/ciArrayKlass.cpp --- a/hotspot/src/share/vm/ci/ciArrayKlass.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/ci/ciArrayKlass.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/ci/ciArrayKlass.hpp --- a/hotspot/src/share/vm/ci/ciArrayKlass.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/ci/ciArrayKlass.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -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 @@ 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/ci/ciEnv.cpp --- a/hotspot/src/share/vm/ci/ciEnv.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/ci/ciEnv.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -326,7 +326,7 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/ci/ciKlass.hpp --- a/hotspot/src/share/vm/ci/ciKlass.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/ci/ciKlass.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/ci/ciObjArrayKlass.cpp --- a/hotspot/src/share/vm/ci/ciObjArrayKlass.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/ci/ciObjArrayKlass.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -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 @@ // 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/ci/ciObjArrayKlass.hpp --- a/hotspot/src/share/vm/ci/ciObjArrayKlass.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/ci/ciObjArrayKlass.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/ci/ciObjectFactory.cpp --- a/hotspot/src/share/vm/ci/ciObjectFactory.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/ci/ciObjectFactory.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -173,7 +173,7 @@ } 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 @@ // 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 @@ // 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/ci/ciTypeArrayKlass.cpp --- a/hotspot/src/share/vm/ci/ciTypeArrayKlass.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/ci/ciTypeArrayKlass.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/ci/ciTypeArrayKlass.hpp --- a/hotspot/src/share/vm/ci/ciTypeArrayKlass.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/ci/ciTypeArrayKlass.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -37,8 +37,8 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/classfile/classFileParser.cpp --- a/hotspot/src/share/vm/classfile/classFileParser.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/classfile/classFileParser.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -782,7 +782,7 @@ Array* ClassFileParser::parse_interfaces(constantPoolHandle cp, int length, - ClassLoaderData* loader_data, + ClassLoaderData* loader_data, Handle protection_domain, Symbol* class_name, TRAPS) { @@ -1072,10 +1072,11 @@ Array* ClassFileParser::parse_fields(ClassLoaderData* loader_data, Symbol* class_name, - constantPoolHandle cp, bool is_interface, - FieldAllocationCount *fac, + constantPoolHandle cp, + bool is_interface, + FieldAllocationCount *fac, Array** 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 @@ } // 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 @@ // are added to klass's access_flags. Array* ClassFileParser::parse_methods(ClassLoaderData* loader_data, - constantPoolHandle cp, - bool is_interface, - AccessFlags* promoted_flags, - bool* has_final_method, - Array** methods_annotations, - Array** methods_parameter_annotations, - Array** methods_default_annotations, - TRAPS) { + constantPoolHandle cp, + bool is_interface, + AccessFlags* promoted_flags, + bool* has_final_method, + Array** methods_annotations, + Array** methods_parameter_annotations, + Array** methods_default_annotations, + TRAPS) { ClassFileStream* cfs = stream(); AnnotationArray* method_annotations = NULL; AnnotationArray* method_parameter_annotations = NULL; @@ -2450,10 +2449,9 @@ } // 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 @@ } 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 @@ 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 @@ Array* methods_parameter_annotations = NULL; Array* methods_default_annotations = NULL; Array* 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 @@ "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 @@ // sort methods Array* 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/classfile/classFileParser.hpp --- a/hotspot/src/share/vm/classfile/classFileParser.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/classfile/classFileParser.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -148,7 +148,7 @@ // Interface parsing Array* parse_interfaces(constantPoolHandle cp, int length, - ClassLoaderData* loader_data, + ClassLoaderData* loader_data, Handle protection_domain, Symbol* class_name, TRAPS); @@ -166,10 +166,10 @@ TRAPS); Array* parse_fields(ClassLoaderData* loader_data, Symbol* class_name, - constantPoolHandle cp, bool is_interface, - FieldAllocationCount *fac, + constantPoolHandle cp, bool is_interface, + FieldAllocationCount *fac, Array** 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 @@ AnnotationArray** method_default_annotations, TRAPS); Array* parse_methods(ClassLoaderData* loader_data, - constantPoolHandle cp, - bool is_interface, + constantPoolHandle cp, + bool is_interface, AccessFlags* promoted_flags, bool* has_final_method, - Array** methods_annotations, - Array** methods_parameter_annotations, - Array** methods_default_annotations, + Array** methods_annotations, + Array** methods_parameter_annotations, + Array** methods_default_annotations, TRAPS); Array* sort_methods(ClassLoaderData* loader_data, Array* methods, @@ -232,9 +232,9 @@ // 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 @@ unsigned int* nonstatic_oop_counts); void set_precomputed_flags(instanceKlassHandle k); Array* compute_transitive_interfaces(ClassLoaderData* loader_data, - instanceKlassHandle super, - Array* local_ifs, TRAPS); + instanceKlassHandle super, + Array* local_ifs, TRAPS); // Format checker methods void classfile_parse_error(const char* msg, TRAPS); diff -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/classfile/javaClasses.cpp --- a/hotspot/src/share/vm/classfile/javaClasses.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/classfile/javaClasses.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -540,18 +540,18 @@ 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 @@ #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 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/classfile/systemDictionary.cpp --- a/hotspot/src/share/vm/classfile/systemDictionary.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/classfile/systemDictionary.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -244,7 +244,7 @@ } } 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 @@ // 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 @@ // 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* cp_patches, - TRAPS) { + Handle class_loader, + Handle protection_domain, + ClassFileStream* st, + KlassHandle host_klass, + GrowableArray* cp_patches, + TRAPS) { TempNewSymbol parsed_name = NULL; // Parse the stream. Note that we do this even though this klass might @@ -1076,11 +1076,11 @@ // 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 @@ // 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/pcTasks.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -204,7 +204,7 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp --- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psCompactionManager.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -188,10 +188,10 @@ // 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/gc_implementation/shared/markSweep.cpp --- a/hotspot/src/share/vm/gc_implementation/shared/markSweep.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/gc_implementation/shared/markSweep.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -115,7 +115,7 @@ // 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/interpreter/bytecodeInterpreter.cpp --- a/hotspot/src/share/vm/interpreter/bytecodeInterpreter.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/interpreter/bytecodeInterpreter.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -1626,7 +1626,7 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/interpreter/interpreterRuntime.cpp --- a/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -211,7 +211,7 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/memory/oopFactory.cpp --- a/hotspot/src/share/vm/memory/oopFactory.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/memory/oopFactory.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -47,12 +47,12 @@ } 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_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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/memory/oopFactory.hpp --- a/hotspot/src/share/vm/memory/oopFactory.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/memory/oopFactory.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -40,19 +40,19 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/memory/specialized_oop_closures.hpp --- a/hotspot/src/share/vm/memory/specialized_oop_closures.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/memory/specialized_oop_closures.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -200,7 +200,7 @@ enum Kind { ik, // InstanceKlass irk, // InstanceRefKlass - oa, // objArrayKlass + oa, // ObjArrayKlass NUM_Kinds }; diff -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/memory/universe.cpp --- a/hotspot/src/share/vm/memory/universe.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/memory/universe.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -265,14 +265,14 @@ 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 @@ { 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/arrayKlass.cpp --- a/hotspot/src/share/vm/oops/arrayKlass.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/arrayKlass.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -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 @@ } -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 @@ } -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 @@ // 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* arrayKlass::compute_secondary_supers(int num_extra_slots) { +GrowableArray* 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 @@ 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 @@ } -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 @@ } 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 @@ // 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 @@ // 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::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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/arrayKlass.hpp --- a/hotspot/src/share/vm/oops/arrayKlass.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/arrayKlass.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -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 @@ // 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 @@ 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 @@ 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* 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/constantPool.cpp --- a/hotspot/src/share/vm/oops/constantPool.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/constantPool.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -519,7 +519,7 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/constantPool.hpp --- a/hotspot/src/share/vm/oops/constantPool.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/constantPool.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -468,7 +468,7 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/instanceKlass.cpp --- a/hotspot/src/share/vm/oops/instanceKlass.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/instanceKlass.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -989,13 +989,13 @@ // 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::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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/klass.cpp --- a/hotspot/src/share/vm/oops/klass.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/klass.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -532,13 +532,13 @@ 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/klassVtable.cpp --- a/hotspot/src/share/vm/oops/klassVtable.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/klassVtable.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -1096,7 +1096,7 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/klassVtable.hpp --- a/hotspot/src/share/vm/oops/klassVtable.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/klassVtable.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/method.cpp --- a/hotspot/src/share/vm/oops/method.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/method.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -1065,7 +1065,7 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/objArrayKlass.cpp --- a/hotspot/src/share/vm/oops/objArrayKlass.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/objArrayKlass.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -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 @@ } // 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ } // Either oop or narrowOop depending on UseCompressedOops. -template void objArrayKlass::do_copy(arrayOop s, T* src, +template 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 @@ 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 @@ 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 @@ } -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 @@ // 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 @@ return Klass::can_be_primary_super_slow(); } -GrowableArray* objArrayKlass::compute_secondary_supers(int num_extra_slots) { +GrowableArray* ObjArrayKlass::compute_secondary_supers(int num_extra_slots) { // interfaces = { cloneable_klass, serializable_klass, elemSuper[], ... }; Array* elem_supers = Klass::cast(element_klass())->secondary_supers(); int num_elem_supers = elem_supers == NULL ? 0 : elem_supers->length(); @@ -402,16 +402,16 @@ } } -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 @@ 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 @@ } #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 @@ #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 @@ #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 @@ // 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_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 @@ } #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 @@ }) } -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 @@ // 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 @@ // 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 @@ #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 @@ #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 @@ 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 @@ } } -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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/objArrayKlass.hpp --- a/hotspot/src/share/vm/oops/objArrayKlass.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/objArrayKlass.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -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 @@ 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 @@ private: // Either oop or narrowOop depending on UseCompressedOops. - // must be called from within objArrayKlass.cpp + // must be called from within ObjArrayKlass.cpp template 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/objArrayKlass.inline.hpp --- a/hotspot/src/share/vm/oops/objArrayKlass.inline.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/objArrayKlass.inline.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -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(obj, index); } else { @@ -41,7 +41,7 @@ } template -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 @@ } #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(cm, obj, index); @@ -74,7 +74,7 @@ } template -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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/objArrayOop.cpp --- a/hotspot/src/share/vm/oops/objArrayOop.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/objArrayOop.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/objArrayOop.hpp --- a/hotspot/src/share/vm/oops/objArrayOop.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/objArrayOop.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/oop.pcgc.inline.hpp --- a/hotspot/src/share/vm/oops/oop.pcgc.inline.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/oop.pcgc.inline.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -44,7 +44,7 @@ // 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/oop.psgc.inline.hpp --- a/hotspot/src/share/vm/oops/oop.psgc.inline.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/oop.psgc.inline.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -39,7 +39,7 @@ // 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/oopsHierarchy.hpp --- a/hotspot/src/share/vm/oops/oopsHierarchy.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/oopsHierarchy.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -128,7 +128,7 @@ #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 InstanceMirrorKlass; class InstanceClassLoaderKlass; class InstanceRefKlass; -class arrayKlass; -class objArrayKlass; -class typeArrayKlass; +class ArrayKlass; +class ObjArrayKlass; +class TypeArrayKlass; #endif // SHARE_VM_OOPS_OOPSHIERARCHY_HPP diff -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/typeArrayKlass.cpp --- a/hotspot/src/share/vm/oops/typeArrayKlass.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/typeArrayKlass.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -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 @@ 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 @@ 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 @@ } } -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 @@ } -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 @@ // 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 @@ 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 @@ // 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 @@ #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 @@ } -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 @@ #endif // PRODUCT -const char* typeArrayKlass::internal_name() const { +const char* TypeArrayKlass::internal_name() const { return Klass::external_name(); } diff -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/typeArrayKlass.hpp --- a/hotspot/src/share/vm/oops/typeArrayKlass.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/typeArrayKlass.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -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 @@ 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/oops/typeArrayOop.hpp --- a/hotspot/src/share/vm/oops/typeArrayOop.hpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/oops/typeArrayOop.hpp Sat Sep 29 06:40:00 2012 -0400 @@ -73,7 +73,7 @@ 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 @@ public: int object_size() { - typeArrayKlass* tk = typeArrayKlass::cast(klass()); + TypeArrayKlass* tk = TypeArrayKlass::cast(klass()); return object_size(tk->layout_helper(), length()); } }; diff -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/opto/library_call.cpp --- a/hotspot/src/share/vm/opto/library_call.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/opto/library_call.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -3435,7 +3435,7 @@ 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/opto/memnode.cpp --- a/hotspot/src/share/vm/opto/memnode.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/opto/memnode.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -1671,9 +1671,9 @@ } 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 @@ 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 @@ } // 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 @@ && (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 @@ ) { 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/opto/parseHelper.cpp --- a/hotspot/src/share/vm/opto/parseHelper.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/opto/parseHelper.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -200,7 +200,7 @@ // 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/opto/runtime.cpp --- a/hotspot/src/share/vm/opto/runtime.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/opto/runtime.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -286,13 +286,13 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/prims/jni.cpp --- a/hotspot/src/share/vm/prims/jni.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/prims/jni.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -3442,8 +3442,8 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/prims/jniCheck.cpp --- a/hotspot/src/share/vm/prims/jniCheck.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/prims/jniCheck.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -290,7 +290,7 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/prims/jvm.cpp --- a/hotspot/src/share/vm/prims/jvm.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/prims/jvm.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -1048,7 +1048,7 @@ 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 @@ 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 @@ } // 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp --- a/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -2606,7 +2606,7 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/prims/jvmtiTagMap.cpp --- a/hotspot/src/share/vm/prims/jvmtiTagMap.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/prims/jvmtiTagMap.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -1075,7 +1075,7 @@ // 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/prims/unsafe.cpp --- a/hotspot/src/share/vm/prims/unsafe.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/prims/unsafe.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -802,7 +802,7 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/runtime/advancedThresholdPolicy.cpp --- a/hotspot/src/share/vm/runtime/advancedThresholdPolicy.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/runtime/advancedThresholdPolicy.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -156,7 +156,7 @@ // 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/runtime/deoptimization.cpp --- a/hotspot/src/share/vm/runtime/deoptimization.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/runtime/deoptimization.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -755,12 +755,12 @@ 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/runtime/reflection.cpp --- a/hotspot/src/share/vm/runtime/reflection.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/runtime/reflection.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -212,7 +212,7 @@ 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 @@ 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 @@ } } 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 @@ 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 @@ } 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_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 @@ } 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 @@ } } 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/runtime/sharedRuntime.cpp --- a/hotspot/src/share/vm/runtime/sharedRuntime.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/runtime/sharedRuntime.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -2705,7 +2705,7 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/runtime/vmStructs.cpp --- a/hotspot/src/share/vm/runtime/vmStructs.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/runtime/vmStructs.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -268,12 +268,12 @@ 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*) \ @@ -379,13 +379,13 @@ 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/services/attachListener.cpp --- a/hotspot/src/share/vm/services/attachListener.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/services/attachListener.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -88,7 +88,7 @@ // 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/services/diagnosticCommand.cpp --- a/hotspot/src/share/vm/services/diagnosticCommand.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/services/diagnosticCommand.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -204,7 +204,7 @@ // 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/services/heapDumper.cpp --- a/hotspot/src/share/vm/services/heapDumper.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/services/heapDumper.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -933,7 +933,7 @@ 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 @@ // 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/services/management.cpp --- a/hotspot/src/share/vm/services/management.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/services/management.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -426,7 +426,7 @@ 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 @@ 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 @@ 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 @@ // 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 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/services/threadService.cpp --- a/hotspot/src/share/vm/services/threadService.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/services/threadService.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -250,7 +250,7 @@ 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 -r b01a48301e67 -r e3cf184080bc hotspot/src/share/vm/shark/sharkRuntime.cpp --- a/hotspot/src/share/vm/shark/sharkRuntime.cpp Fri Sep 28 14:36:20 2012 -0700 +++ b/hotspot/src/share/vm/shark/sharkRuntime.cpp Sat Sep 29 06:40:00 2012 -0400 @@ -129,7 +129,7 @@ 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