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