Mercurial > hg > truffle
changeset 6742:3f18d439b402
Merge
| author | zgu |
|---|---|
| date | Tue, 11 Sep 2012 18:28:51 -0700 |
| parents | 33143ee07800 (current diff) 8a02ca5e5576 (diff) |
| children | 43d524adb671 |
| files | |
| diffstat | 61 files changed, 448 insertions(+), 228 deletions(-) [+] |
line wrap: on
line diff
--- a/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceClassLoaderKlass.java Tue Sep 11 20:53:17 2012 -0400 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceClassLoaderKlass.java Tue Sep 11 18:28:51 2012 -0700 @@ -45,7 +45,7 @@ private static synchronized void initialize(TypeDataBase db) throws WrongTypeException { // Just make sure it's there for now - Type type = db.lookupType("instanceClassLoaderKlass"); + Type type = db.lookupType("InstanceClassLoaderKlass"); } public InstanceClassLoaderKlass(Address addr) {
--- a/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceMirrorKlass.java Tue Sep 11 20:53:17 2012 -0400 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceMirrorKlass.java Tue Sep 11 18:28:51 2012 -0700 @@ -45,7 +45,7 @@ private static synchronized void initialize(TypeDataBase db) throws WrongTypeException { // Just make sure it's there for now - Type type = db.lookupType("instanceMirrorKlass"); + Type type = db.lookupType("InstanceMirrorKlass"); } public InstanceMirrorKlass(Address addr) {
--- a/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceRefKlass.java Tue Sep 11 20:53:17 2012 -0400 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceRefKlass.java Tue Sep 11 18:28:51 2012 -0700 @@ -45,7 +45,7 @@ private static synchronized void initialize(TypeDataBase db) throws WrongTypeException { // Just make sure it's there for now - Type type = db.lookupType("instanceRefKlass"); + Type type = db.lookupType("InstanceRefKlass"); } public InstanceRefKlass(Address addr) {
--- a/agent/src/share/classes/sun/jvm/hotspot/oops/Metadata.java Tue Sep 11 20:53:17 2012 -0400 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/Metadata.java Tue Sep 11 18:28:51 2012 -0700 @@ -52,9 +52,9 @@ metadataConstructor.addMapping("Metadata", Metadata.class); metadataConstructor.addMapping("Klass", Klass.class); metadataConstructor.addMapping("InstanceKlass", InstanceKlass.class); - metadataConstructor.addMapping("instanceMirrorKlass", InstanceMirrorKlass.class); - metadataConstructor.addMapping("instanceRefKlass", InstanceRefKlass.class); - metadataConstructor.addMapping("instanceClassLoaderKlass", InstanceClassLoaderKlass.class); + metadataConstructor.addMapping("InstanceMirrorKlass", InstanceMirrorKlass.class); + metadataConstructor.addMapping("InstanceRefKlass", InstanceRefKlass.class); + metadataConstructor.addMapping("InstanceClassLoaderKlass", InstanceClassLoaderKlass.class); metadataConstructor.addMapping("typeArrayKlass", TypeArrayKlass.class); metadataConstructor.addMapping("objArrayKlass", ObjArrayKlass.class); metadataConstructor.addMapping("Method", Method.class);
--- a/make/solaris/makefiles/fastdebug.make Tue Sep 11 20:53:17 2012 -0400 +++ b/make/solaris/makefiles/fastdebug.make Tue Sep 11 18:28:51 2012 -0700 @@ -41,9 +41,6 @@ OPT_CFLAGS/simpleThresholdPolicy.o = $(OPT_CFLAGS/DEFAULT) $(OPT_CCFLAGS/NO_TAIL_CALL_OPT) # CC 5.10 has bug XXXXX with -xO4 OPT_CFLAGS/jvmtiClassFileReconstituter.o = $(OPT_CFLAGS/SLOWER) -# jvm98 crashes on solaris-i586-fastdebug and solaris-sparc-fastdebug with stack overflow -OPT_CFLAGS/escape.o = $(OPT_CFLAGS) -xspace -OPT_CFLAGS/matcher.o = $(OPT_CFLAGS) -xspace endif # COMPILER_REV_NUMERIC == 510 ifeq ($(COMPILER_REV_NUMERIC), 509)
--- a/src/cpu/sparc/vm/c1_FrameMap_sparc.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/cpu/sparc/vm/c1_FrameMap_sparc.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -147,6 +147,39 @@ LIR_Opr FrameMap::I6_oop_opr; LIR_Opr FrameMap::I7_oop_opr; +LIR_Opr FrameMap::G0_metadata_opr; +LIR_Opr FrameMap::G1_metadata_opr; +LIR_Opr FrameMap::G2_metadata_opr; +LIR_Opr FrameMap::G3_metadata_opr; +LIR_Opr FrameMap::G4_metadata_opr; +LIR_Opr FrameMap::G5_metadata_opr; +LIR_Opr FrameMap::G6_metadata_opr; +LIR_Opr FrameMap::G7_metadata_opr; +LIR_Opr FrameMap::O0_metadata_opr; +LIR_Opr FrameMap::O1_metadata_opr; +LIR_Opr FrameMap::O2_metadata_opr; +LIR_Opr FrameMap::O3_metadata_opr; +LIR_Opr FrameMap::O4_metadata_opr; +LIR_Opr FrameMap::O5_metadata_opr; +LIR_Opr FrameMap::O6_metadata_opr; +LIR_Opr FrameMap::O7_metadata_opr; +LIR_Opr FrameMap::L0_metadata_opr; +LIR_Opr FrameMap::L1_metadata_opr; +LIR_Opr FrameMap::L2_metadata_opr; +LIR_Opr FrameMap::L3_metadata_opr; +LIR_Opr FrameMap::L4_metadata_opr; +LIR_Opr FrameMap::L5_metadata_opr; +LIR_Opr FrameMap::L6_metadata_opr; +LIR_Opr FrameMap::L7_metadata_opr; +LIR_Opr FrameMap::I0_metadata_opr; +LIR_Opr FrameMap::I1_metadata_opr; +LIR_Opr FrameMap::I2_metadata_opr; +LIR_Opr FrameMap::I3_metadata_opr; +LIR_Opr FrameMap::I4_metadata_opr; +LIR_Opr FrameMap::I5_metadata_opr; +LIR_Opr FrameMap::I6_metadata_opr; +LIR_Opr FrameMap::I7_metadata_opr; + LIR_Opr FrameMap::SP_opr; LIR_Opr FrameMap::FP_opr; @@ -310,6 +343,39 @@ I6_oop_opr = as_oop_opr(I6); I7_oop_opr = as_oop_opr(I7); + G0_metadata_opr = as_metadata_opr(G0); + G1_metadata_opr = as_metadata_opr(G1); + G2_metadata_opr = as_metadata_opr(G2); + G3_metadata_opr = as_metadata_opr(G3); + G4_metadata_opr = as_metadata_opr(G4); + G5_metadata_opr = as_metadata_opr(G5); + G6_metadata_opr = as_metadata_opr(G6); + G7_metadata_opr = as_metadata_opr(G7); + O0_metadata_opr = as_metadata_opr(O0); + O1_metadata_opr = as_metadata_opr(O1); + O2_metadata_opr = as_metadata_opr(O2); + O3_metadata_opr = as_metadata_opr(O3); + O4_metadata_opr = as_metadata_opr(O4); + O5_metadata_opr = as_metadata_opr(O5); + O6_metadata_opr = as_metadata_opr(O6); + O7_metadata_opr = as_metadata_opr(O7); + L0_metadata_opr = as_metadata_opr(L0); + L1_metadata_opr = as_metadata_opr(L1); + L2_metadata_opr = as_metadata_opr(L2); + L3_metadata_opr = as_metadata_opr(L3); + L4_metadata_opr = as_metadata_opr(L4); + L5_metadata_opr = as_metadata_opr(L5); + L6_metadata_opr = as_metadata_opr(L6); + L7_metadata_opr = as_metadata_opr(L7); + I0_metadata_opr = as_metadata_opr(I0); + I1_metadata_opr = as_metadata_opr(I1); + I2_metadata_opr = as_metadata_opr(I2); + I3_metadata_opr = as_metadata_opr(I3); + I4_metadata_opr = as_metadata_opr(I4); + I5_metadata_opr = as_metadata_opr(I5); + I6_metadata_opr = as_metadata_opr(I6); + I7_metadata_opr = as_metadata_opr(I7); + FP_opr = as_pointer_opr(FP); SP_opr = as_pointer_opr(SP);
--- a/src/cpu/sparc/vm/c1_FrameMap_sparc.hpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/cpu/sparc/vm/c1_FrameMap_sparc.hpp Tue Sep 11 18:28:51 2012 -0700 @@ -104,6 +104,39 @@ static LIR_Opr I6_oop_opr; static LIR_Opr I7_oop_opr; + static LIR_Opr G0_metadata_opr; + static LIR_Opr G1_metadata_opr; + static LIR_Opr G2_metadata_opr; + static LIR_Opr G3_metadata_opr; + static LIR_Opr G4_metadata_opr; + static LIR_Opr G5_metadata_opr; + static LIR_Opr G6_metadata_opr; + static LIR_Opr G7_metadata_opr; + static LIR_Opr O0_metadata_opr; + static LIR_Opr O1_metadata_opr; + static LIR_Opr O2_metadata_opr; + static LIR_Opr O3_metadata_opr; + static LIR_Opr O4_metadata_opr; + static LIR_Opr O5_metadata_opr; + static LIR_Opr O6_metadata_opr; + static LIR_Opr O7_metadata_opr; + static LIR_Opr L0_metadata_opr; + static LIR_Opr L1_metadata_opr; + static LIR_Opr L2_metadata_opr; + static LIR_Opr L3_metadata_opr; + static LIR_Opr L4_metadata_opr; + static LIR_Opr L5_metadata_opr; + static LIR_Opr L6_metadata_opr; + static LIR_Opr L7_metadata_opr; + static LIR_Opr I0_metadata_opr; + static LIR_Opr I1_metadata_opr; + static LIR_Opr I2_metadata_opr; + static LIR_Opr I3_metadata_opr; + static LIR_Opr I4_metadata_opr; + static LIR_Opr I5_metadata_opr; + static LIR_Opr I6_metadata_opr; + static LIR_Opr I7_metadata_opr; + static LIR_Opr in_long_opr; static LIR_Opr out_long_opr; static LIR_Opr g1_long_single_opr;
--- a/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -447,9 +447,12 @@ if (compilation()->env()->dtrace_method_probes()) { __ mov(G2_thread, O0); + __ save_thread(I1); // need to preserve thread in G2 across + // runtime call metadata2reg(method()->constant_encoding(), O1); __ call(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_exit), relocInfo::runtime_call_type); __ delayed()->nop(); + __ restore_thread(I1); } if (method()->is_synchronized() || compilation()->env()->dtrace_method_probes()) { @@ -843,6 +846,7 @@ #endif break; case T_ADDRESS: + case T_METADATA: __ st_ptr(from_reg->as_register(), base, offset); break; case T_ARRAY : // fall through @@ -965,6 +969,7 @@ #endif } break; + case T_METADATA: case T_ADDRESS: __ ld_ptr(base, offset, to_reg->as_register()); break; case T_ARRAY : // fall through case T_OBJECT: @@ -1366,6 +1371,7 @@ void LIR_Assembler::mem2reg(LIR_Opr src_opr, LIR_Opr dest, BasicType type, LIR_PatchCode patch_code, CodeEmitInfo* info, bool wide, bool unaligned) { + assert(type != T_METADATA, "load of metadata ptr not supported"); LIR_Address* addr = src_opr->as_address_ptr(); LIR_Opr to_reg = dest; @@ -1513,6 +1519,7 @@ void LIR_Assembler::reg2mem(LIR_Opr from_reg, LIR_Opr dest, BasicType type, LIR_PatchCode patch_code, CodeEmitInfo* info, bool pop_fpu_stack, bool wide, bool unaligned) { + assert(type != T_METADATA, "store of metadata ptr not supported"); LIR_Address* addr = dest->as_address_ptr(); Register src = addr->base()->as_pointer_register();
--- a/src/cpu/sparc/vm/c1_LIRGenerator_sparc.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/cpu/sparc/vm/c1_LIRGenerator_sparc.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -884,7 +884,7 @@ LIR_Opr tmp2 = FrameMap::G3_oop_opr; LIR_Opr tmp3 = FrameMap::G4_oop_opr; LIR_Opr tmp4 = FrameMap::O1_oop_opr; - LIR_Opr klass_reg = FrameMap::G5_oop_opr; + LIR_Opr klass_reg = FrameMap::G5_metadata_opr; new_instance(reg, x->klass(), tmp1, tmp2, tmp3, tmp4, klass_reg, info); LIR_Opr result = rlock_result(x); __ move(reg, result); @@ -903,11 +903,11 @@ LIR_Opr tmp2 = FrameMap::G3_oop_opr; LIR_Opr tmp3 = FrameMap::G4_oop_opr; LIR_Opr tmp4 = FrameMap::O1_oop_opr; - LIR_Opr klass_reg = FrameMap::G5_oop_opr; + LIR_Opr klass_reg = FrameMap::G5_metadata_opr; LIR_Opr len = length.result(); BasicType elem_type = x->elt_type(); - __ oop2reg(ciTypeArrayKlass::make(elem_type)->constant_encoding(), klass_reg); + __ metadata2reg(ciTypeArrayKlass::make(elem_type)->constant_encoding(), klass_reg); CodeStub* slow_path = new NewTypeArrayStub(klass_reg, len, reg, info); __ allocate_array(reg, len, tmp1, tmp2, tmp3, tmp4, elem_type, klass_reg, slow_path); @@ -935,7 +935,7 @@ LIR_Opr tmp2 = FrameMap::G3_oop_opr; LIR_Opr tmp3 = FrameMap::G4_oop_opr; LIR_Opr tmp4 = FrameMap::O1_oop_opr; - LIR_Opr klass_reg = FrameMap::G5_oop_opr; + LIR_Opr klass_reg = FrameMap::G5_metadata_opr; LIR_Opr len = length.result(); CodeStub* slow_path = new NewObjectArrayStub(klass_reg, len, reg, info); @@ -985,8 +985,8 @@ // This instruction can be deoptimized in the slow path : use // O0 as result register. - const LIR_Opr reg = result_register_for(x->type()); - klass2reg_with_patching(reg, x->klass(), patching_info); + const LIR_Opr klass_reg = FrameMap::O0_metadata_opr; + klass2reg_with_patching(klass_reg, x->klass(), patching_info); LIR_Opr rank = FrameMap::O1_opr; __ move(LIR_OprFact::intConst(x->rank()), rank); LIR_Opr varargs = FrameMap::as_pointer_opr(O2); @@ -995,9 +995,10 @@ LIR_OprFact::intptrConst(offset_from_sp), varargs); LIR_OprList* args = new LIR_OprList(3); - args->append(reg); + args->append(klass_reg); args->append(rank); args->append(varargs); + const LIR_Opr reg = result_register_for(x->type()); __ call_runtime(Runtime1::entry_for(Runtime1::new_multi_array_id), LIR_OprFact::illegalOpr, reg, args, info);
--- a/src/cpu/sparc/vm/sharedRuntime_sparc.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/cpu/sparc/vm/sharedRuntime_sparc.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -1340,6 +1340,7 @@ case T_ADDRESS: // raw pointers, like current thread, for VM calls case T_ARRAY: case T_OBJECT: + case T_METADATA: regs[i].set2( int_stk_helper( j ) ); break; case T_FLOAT: @@ -1388,6 +1389,7 @@ case T_FLOAT: case T_INT: case T_OBJECT: + case T_METADATA: case T_SHORT: regs[i].set1( int_stk_helper( i ) ); break;
--- a/src/cpu/x86/vm/c1_FrameMap_x86.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/cpu/x86/vm/c1_FrameMap_x86.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -96,6 +96,13 @@ LIR_Opr FrameMap::rdx_oop_opr; LIR_Opr FrameMap::rcx_oop_opr; +LIR_Opr FrameMap::rsi_metadata_opr; +LIR_Opr FrameMap::rdi_metadata_opr; +LIR_Opr FrameMap::rbx_metadata_opr; +LIR_Opr FrameMap::rax_metadata_opr; +LIR_Opr FrameMap::rdx_metadata_opr; +LIR_Opr FrameMap::rcx_metadata_opr; + LIR_Opr FrameMap::long0_opr; LIR_Opr FrameMap::long1_opr; LIR_Opr FrameMap::fpu0_float_opr; @@ -122,6 +129,13 @@ LIR_Opr FrameMap::r12_oop_opr; LIR_Opr FrameMap::r13_oop_opr; LIR_Opr FrameMap::r14_oop_opr; + +LIR_Opr FrameMap::r8_metadata_opr; +LIR_Opr FrameMap::r9_metadata_opr; +LIR_Opr FrameMap::r11_metadata_opr; +LIR_Opr FrameMap::r12_metadata_opr; +LIR_Opr FrameMap::r13_metadata_opr; +LIR_Opr FrameMap::r14_metadata_opr; #endif // _LP64 LIR_Opr FrameMap::_caller_save_cpu_regs[] = { 0, }; @@ -236,6 +250,13 @@ rdx_oop_opr = as_oop_opr(rdx); rcx_oop_opr = as_oop_opr(rcx); + rsi_metadata_opr = as_metadata_opr(rsi); + rdi_metadata_opr = as_metadata_opr(rdi); + rbx_metadata_opr = as_metadata_opr(rbx); + rax_metadata_opr = as_metadata_opr(rax); + rdx_metadata_opr = as_metadata_opr(rdx); + rcx_metadata_opr = as_metadata_opr(rcx); + rsp_opr = as_pointer_opr(rsp); rbp_opr = as_pointer_opr(rbp); @@ -246,6 +267,13 @@ r12_oop_opr = as_oop_opr(r12); r13_oop_opr = as_oop_opr(r13); r14_oop_opr = as_oop_opr(r14); + + r8_metadata_opr = as_metadata_opr(r8); + r9_metadata_opr = as_metadata_opr(r9); + r11_metadata_opr = as_metadata_opr(r11); + r12_metadata_opr = as_metadata_opr(r12); + r13_metadata_opr = as_metadata_opr(r13); + r14_metadata_opr = as_metadata_opr(r14); #endif // _LP64 VMRegPair regs;
--- a/src/cpu/x86/vm/c1_FrameMap_x86.hpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/cpu/x86/vm/c1_FrameMap_x86.hpp Tue Sep 11 18:28:51 2012 -0700 @@ -73,6 +73,14 @@ static LIR_Opr rax_oop_opr; static LIR_Opr rdx_oop_opr; static LIR_Opr rcx_oop_opr; + + static LIR_Opr rsi_metadata_opr; + static LIR_Opr rdi_metadata_opr; + static LIR_Opr rbx_metadata_opr; + static LIR_Opr rax_metadata_opr; + static LIR_Opr rdx_metadata_opr; + static LIR_Opr rcx_metadata_opr; + #ifdef _LP64 static LIR_Opr r8_opr; @@ -92,6 +100,14 @@ static LIR_Opr r13_oop_opr; static LIR_Opr r14_oop_opr; + static LIR_Opr r8_metadata_opr; + static LIR_Opr r9_metadata_opr; + + static LIR_Opr r11_metadata_opr; + static LIR_Opr r12_metadata_opr; + static LIR_Opr r13_metadata_opr; + static LIR_Opr r14_metadata_opr; + #endif // _LP64 static LIR_Opr long0_opr;
--- a/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/cpu/x86/vm/c1_LIRAssembler_x86.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -950,6 +950,8 @@ if (type == T_OBJECT || type == T_ARRAY) { __ verify_oop(src->as_register()); __ movptr (dst, src->as_register()); + } else if (type == T_METADATA) { + __ movptr (dst, src->as_register()); } else { __ movl (dst, src->as_register()); } @@ -1041,6 +1043,14 @@ __ movptr(as_Address(to_addr), src->as_register()); } break; + case T_METADATA: + // We get here to store a method pointer to the stack to pass to + // a dtrace runtime call. This can't work on 64 bit with + // compressed klass ptrs: T_METADATA can be a compressed klass + // ptr or a 64 bit method pointer. + LP64_ONLY(ShouldNotReachHere()); + __ movptr(as_Address(to_addr), src->as_register()); + break; case T_ADDRESS: __ movptr(as_Address(to_addr), src->as_register()); break; @@ -1118,6 +1128,8 @@ if (type == T_ARRAY || type == T_OBJECT) { __ movptr(dest->as_register(), frame_map()->address_for_slot(src->single_stack_ix())); __ verify_oop(dest->as_register()); + } else if (type == T_METADATA) { + __ movptr(dest->as_register(), frame_map()->address_for_slot(src->single_stack_ix())); } else { __ movl(dest->as_register(), frame_map()->address_for_slot(src->single_stack_ix())); }
--- a/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/cpu/x86/vm/c1_LIRGenerator_x86.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -1002,13 +1002,12 @@ #endif CodeEmitInfo* info = state_for(x, x->state()); LIR_Opr reg = result_register_for(x->type()); - LIR_Opr klass_reg = new_register(objectType); new_instance(reg, x->klass(), FrameMap::rcx_oop_opr, FrameMap::rdi_oop_opr, FrameMap::rsi_oop_opr, LIR_OprFact::illegalOpr, - FrameMap::rdx_oop_opr, info); + FrameMap::rdx_metadata_opr, info); LIR_Opr result = rlock_result(x); __ move(reg, result); } @@ -1025,11 +1024,11 @@ LIR_Opr tmp2 = FrameMap::rsi_oop_opr; LIR_Opr tmp3 = FrameMap::rdi_oop_opr; LIR_Opr tmp4 = reg; - LIR_Opr klass_reg = FrameMap::rdx_oop_opr; + LIR_Opr klass_reg = FrameMap::rdx_metadata_opr; LIR_Opr len = length.result(); BasicType elem_type = x->elt_type(); - __ oop2reg(ciTypeArrayKlass::make(elem_type)->constant_encoding(), klass_reg); + __ metadata2reg(ciTypeArrayKlass::make(elem_type)->constant_encoding(), klass_reg); CodeStub* slow_path = new NewTypeArrayStub(klass_reg, len, reg, info); __ allocate_array(reg, len, tmp1, tmp2, tmp3, tmp4, elem_type, klass_reg, slow_path); @@ -1055,7 +1054,7 @@ LIR_Opr tmp2 = FrameMap::rsi_oop_opr; LIR_Opr tmp3 = FrameMap::rdi_oop_opr; LIR_Opr tmp4 = reg; - LIR_Opr klass_reg = FrameMap::rdx_oop_opr; + LIR_Opr klass_reg = FrameMap::rdx_metadata_opr; length.load_item_force(FrameMap::rbx_opr); LIR_Opr len = length.result(); @@ -1103,17 +1102,18 @@ store_stack_parameter(size->result(), in_ByteSize(i*4)); } - LIR_Opr reg = result_register_for(x->type()); - klass2reg_with_patching(reg, x->klass(), patching_info); + LIR_Opr klass_reg = FrameMap::rax_metadata_opr; + klass2reg_with_patching(klass_reg, x->klass(), patching_info); LIR_Opr rank = FrameMap::rbx_opr; __ move(LIR_OprFact::intConst(x->rank()), rank); LIR_Opr varargs = FrameMap::rcx_opr; __ move(FrameMap::rsp_opr, varargs); LIR_OprList* args = new LIR_OprList(3); - args->append(reg); + args->append(klass_reg); args->append(rank); args->append(varargs); + LIR_Opr reg = result_register_for(x->type()); __ call_runtime(Runtime1::entry_for(Runtime1::new_multi_array_id), LIR_OprFact::illegalOpr, reg, args, info);
--- a/src/cpu/x86/vm/sharedRuntime_x86_32.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/cpu/x86/vm/sharedRuntime_x86_32.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -938,6 +938,7 @@ case T_OBJECT: case T_ARRAY: case T_ADDRESS: + case T_METADATA: regs[i].set1(VMRegImpl::stack2reg(stack++)); break; case T_LONG:
--- a/src/cpu/x86/vm/sharedRuntime_x86_64.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/cpu/x86/vm/sharedRuntime_x86_64.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -903,6 +903,7 @@ case T_OBJECT: case T_ARRAY: case T_ADDRESS: + case T_METADATA: if (int_args < Argument::n_int_register_parameters_c) { regs[i].set2(INT_ArgReg[int_args++]->as_VMReg()); #ifdef _WIN64
--- a/src/share/vm/c1/c1_FrameMap.hpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/c1/c1_FrameMap.hpp Tue Sep 11 18:28:51 2012 -0700 @@ -194,6 +194,10 @@ return LIR_OprFact::single_cpu_oop(cpu_reg2rnr(r)); } + static LIR_Opr as_metadata_opr(Register r) { + return LIR_OprFact::single_cpu_metadata(cpu_reg2rnr(r)); + } + FrameMap(ciMethod* method, int monitors, int reserved_argument_area_size); bool finalize_frame(int nof_slots);
--- a/src/share/vm/c1/c1_LIR.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/c1/c1_LIR.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -89,8 +89,12 @@ ClassConstant* c = type->as_ClassConstant(); if (c != NULL && !c->value()->is_loaded()) { return LIR_OprFact::metadataConst(NULL); + } else if (c != NULL) { + return LIR_OprFact::metadataConst(c->value()->constant_encoding()); } else { - return LIR_OprFact::metadataConst(c->value()->constant_encoding()); + MethodConstant* m = type->as_MethodConstant(); + assert (m != NULL, "not a class or a method?"); + return LIR_OprFact::metadataConst(m->value()->constant_encoding()); } } case objectTag : { @@ -1166,10 +1170,12 @@ void LIR_List::oop2reg_patch(jobject o, LIR_Opr reg, CodeEmitInfo* info) { + assert(reg->type() == T_OBJECT, "bad reg"); append(new LIR_Op1(lir_move, LIR_OprFact::oopConst(o), reg, T_OBJECT, lir_patch_normal, info)); } void LIR_List::klass2reg_patch(Metadata* o, LIR_Opr reg, CodeEmitInfo* info) { + assert(reg->type() == T_METADATA, "bad reg"); append(new LIR_Op1(lir_move, LIR_OprFact::metadataConst(o), reg, T_METADATA, lir_patch_normal, info)); }
--- a/src/share/vm/c1/c1_LIR.hpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/c1/c1_LIR.hpp Tue Sep 11 18:28:51 2012 -0700 @@ -299,6 +299,7 @@ , address_type = 4 << type_shift , float_type = 5 << type_shift , double_type = 6 << type_shift + , metadata_type = 7 << type_shift }; friend OprType as_OprType(BasicType t); friend BasicType as_BasicType(OprType t); @@ -322,6 +323,7 @@ case T_ADDRESS: case T_OBJECT: case T_ARRAY: + case T_METADATA: return single_size; break; @@ -474,6 +476,7 @@ case T_OBJECT: case T_ARRAY: return LIR_OprDesc::object_type; case T_ADDRESS: return LIR_OprDesc::address_type; + case T_METADATA: return LIR_OprDesc::metadata_type; case T_ILLEGAL: // fall through default: ShouldNotReachHere(); return LIR_OprDesc::unknown_type; } @@ -487,6 +490,7 @@ case LIR_OprDesc::double_type: return T_DOUBLE; case LIR_OprDesc::object_type: return T_OBJECT; case LIR_OprDesc::address_type: return T_ADDRESS; + case LIR_OprDesc::metadata_type:return T_METADATA; case LIR_OprDesc::unknown_type: // fall through default: ShouldNotReachHere(); return T_ILLEGAL; } @@ -587,6 +591,12 @@ LIR_OprDesc::cpu_register | LIR_OprDesc::single_size); } + static LIR_Opr single_cpu_metadata(int reg) { + return (LIR_Opr)(intptr_t)((reg << LIR_OprDesc::reg1_shift) | + LIR_OprDesc::metadata_type | + LIR_OprDesc::cpu_register | + LIR_OprDesc::single_size); + } static LIR_Opr double_cpu(int reg1, int reg2) { LP64_ONLY(assert(reg1 == reg2, "must be identical")); return (LIR_Opr)(intptr_t)((reg1 << LIR_OprDesc::reg1_shift) | @@ -660,6 +670,14 @@ LIR_OprDesc::virtual_mask); break; + case T_METADATA: + res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) | + LIR_OprDesc::metadata_type| + LIR_OprDesc::cpu_register | + LIR_OprDesc::single_size | + LIR_OprDesc::virtual_mask); + break; + case T_INT: res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) | LIR_OprDesc::int_type | @@ -757,6 +775,12 @@ LIR_OprDesc::single_size); break; + case T_METADATA: + res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) | + LIR_OprDesc::metadata_type | + LIR_OprDesc::stack_value | + LIR_OprDesc::single_size); + break; case T_INT: res = (LIR_Opr)(intptr_t)((index << LIR_OprDesc::data_shift) | LIR_OprDesc::int_type | @@ -2006,10 +2030,10 @@ } void volatile_move(LIR_Opr src, LIR_Opr dst, BasicType type, CodeEmitInfo* info = NULL, LIR_PatchCode patch_code = lir_patch_none) { append(new LIR_Op1(lir_move, src, dst, type, patch_code, info, lir_move_volatile)); } - void oop2reg (jobject o, LIR_Opr reg) { append(new LIR_Op1(lir_move, LIR_OprFact::oopConst(o), reg)); } + void oop2reg (jobject o, LIR_Opr reg) { assert(reg->type() == T_OBJECT, "bad reg"); append(new LIR_Op1(lir_move, LIR_OprFact::oopConst(o), reg)); } void oop2reg_patch(jobject o, LIR_Opr reg, CodeEmitInfo* info); - void oop2reg (Metadata* o, LIR_Opr reg) { append(new LIR_Op1(lir_move, LIR_OprFact::metadataConst(o), reg)); } + void metadata2reg (Metadata* o, LIR_Opr reg) { assert(reg->type() == T_METADATA, "bad reg"); append(new LIR_Op1(lir_move, LIR_OprFact::metadataConst(o), reg)); } void klass2reg_patch(Metadata* o, LIR_Opr reg, CodeEmitInfo* info); void return_op(LIR_Opr result) { append(new LIR_Op1(lir_return, result)); }
--- a/src/share/vm/c1/c1_LIRGenerator.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/c1/c1_LIRGenerator.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -467,7 +467,7 @@ __ klass2reg_patch(NULL, r, info); } else { // no patching needed - __ oop2reg(obj->constant_encoding(), r); + __ metadata2reg(obj->constant_encoding(), r); } } @@ -955,8 +955,8 @@ not_taken_count_offset = t; } - LIR_Opr md_reg = new_register(T_OBJECT); - __ oop2reg(md->constant_encoding(), md_reg); + LIR_Opr md_reg = new_register(T_METADATA); + __ metadata2reg(md->constant_encoding(), md_reg); LIR_Opr data_offset_reg = new_pointer_register(); __ cmove(lir_cond(cond), @@ -1192,8 +1192,8 @@ signature.append(T_OBJECT); // Method* LIR_OprList* args = new LIR_OprList(); args->append(getThreadPointer()); - LIR_Opr meth = new_register(T_OBJECT); - __ oop2reg(method()->constant_encoding(), meth); + LIR_Opr meth = new_register(T_METADATA); + __ metadata2reg(method()->constant_encoding(), meth); args->append(meth); call_runtime(&signature, args, CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_exit), voidType, NULL); } @@ -2292,7 +2292,7 @@ if (gen_type_check) { // We have determined that offset == referent_offset && src != null. // if (src->_klass->_reference_type == REF_NONE) -> continue - __ move(new LIR_Address(src.result(), oopDesc::klass_offset_in_bytes(), T_OBJECT), src_klass); + __ move(new LIR_Address(src.result(), oopDesc::klass_offset_in_bytes(), UseCompressedKlassPointers ? T_OBJECT : T_ADDRESS), src_klass); LIR_Address* reference_type_addr = new LIR_Address(src_klass, in_bytes(InstanceKlass::reference_type_offset()), T_BYTE); LIR_Opr reference_type = new_register(T_INT); __ move(reference_type_addr, reference_type); @@ -2553,8 +2553,8 @@ assert(data->is_JumpData(), "need JumpData for branches"); offset = md->byte_offset_of_slot(data, JumpData::taken_offset()); } - LIR_Opr md_reg = new_register(T_OBJECT); - __ oop2reg(md->constant_encoding(), md_reg); + LIR_Opr md_reg = new_register(T_METADATA); + __ metadata2reg(md->constant_encoding(), md_reg); increment_counter(new LIR_Address(md_reg, offset, NOT_LP64(T_INT) LP64_ONLY(T_LONG)), DataLayout::counter_increment); @@ -2611,8 +2611,8 @@ signature.append(T_OBJECT); // Method* LIR_OprList* args = new LIR_OprList(); args->append(getThreadPointer()); - LIR_Opr meth = new_register(T_OBJECT); - __ oop2reg(method()->constant_encoding(), meth); + LIR_Opr meth = new_register(T_METADATA); + __ metadata2reg(method()->constant_encoding(), meth); args->append(meth); call_runtime(&signature, args, CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_entry), voidType, NULL); } @@ -3032,21 +3032,21 @@ assert(level > CompLevel_simple, "Shouldn't be here"); int offset = -1; - LIR_Opr counter_holder = new_register(T_OBJECT); + LIR_Opr counter_holder = new_register(T_METADATA); LIR_Opr meth; if (level == CompLevel_limited_profile) { offset = in_bytes(backedge ? Method::backedge_counter_offset() : Method::invocation_counter_offset()); - __ oop2reg(method->constant_encoding(), counter_holder); + __ metadata2reg(method->constant_encoding(), counter_holder); meth = counter_holder; } else if (level == CompLevel_full_profile) { offset = in_bytes(backedge ? MethodData::backedge_counter_offset() : MethodData::invocation_counter_offset()); ciMethodData* md = method->method_data_or_null(); assert(md != NULL, "Sanity"); - __ oop2reg(md->constant_encoding(), counter_holder); - meth = new_register(T_OBJECT); - __ oop2reg(method->constant_encoding(), meth); + __ metadata2reg(md->constant_encoding(), counter_holder); + meth = new_register(T_METADATA); + __ metadata2reg(method->constant_encoding(), meth); } else { ShouldNotReachHere(); }
--- a/src/share/vm/c1/c1_LinearScan.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/c1/c1_LinearScan.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -2067,6 +2067,12 @@ return LIR_OprFact::single_cpu_address(assigned_reg); } + case T_METADATA: { + assert(assigned_reg >= pd_first_cpu_reg && assigned_reg <= pd_last_cpu_reg, "no cpu register"); + assert(interval->assigned_regHi() == any_reg, "must not have hi register"); + return LIR_OprFact::single_cpu_metadata(assigned_reg); + } + #ifdef __SOFTFP__ case T_FLOAT: // fall through #endif // __SOFTFP__
--- a/src/share/vm/c1/c1_ValueType.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/c1/c1_ValueType.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -168,6 +168,7 @@ case floatTag: return T_FLOAT; case doubleTag: return T_DOUBLE; case objectTag: return T_OBJECT; + case metaDataTag:return T_METADATA; case addressTag: return T_ADDRESS; case illegalTag: return T_ILLEGAL; }
--- a/src/share/vm/classfile/classFileParser.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/classfile/classFileParser.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -3271,7 +3271,7 @@ int next_nonstatic_field_offset; // Calculate the starting byte offsets - next_static_oop_offset = instanceMirrorKlass::offset_of_static_fields(); + next_static_oop_offset = InstanceMirrorKlass::offset_of_static_fields(); next_static_double_offset = next_static_oop_offset + (fac.count[STATIC_OOP] * heapOopSize); if ( fac.count[STATIC_DOUBLE] &&
--- a/src/share/vm/classfile/javaClasses.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/classfile/javaClasses.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -500,7 +500,7 @@ void java_lang_Class::fixup_mirror(KlassHandle k, TRAPS) { - assert(instanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already"); + assert(InstanceMirrorKlass::offset_of_static_fields() != 0, "must have been computed already"); // If the offset was read from the shared archive, it was fixed up already if (!k->is_shared()) { @@ -510,7 +510,7 @@ // update all the static field offsets to included the size. for (JavaFieldStream fs(InstanceKlass::cast(k())); !fs.done(); fs.next()) { if (fs.access_flags().is_static()) { - int real_offset = fs.offset() + instanceMirrorKlass::offset_of_static_fields(); + int real_offset = fs.offset() + InstanceMirrorKlass::offset_of_static_fields(); fs.set_offset(real_offset); } } @@ -531,9 +531,9 @@ // the mirror. if (SystemDictionary::Class_klass_loaded()) { // Allocate mirror (java.lang.Class instance) - Handle mirror = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK_0); - - instanceMirrorKlass* mk = instanceMirrorKlass::cast(mirror->klass()); + Handle mirror = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(k, CHECK_0); + + InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass()); java_lang_Class::set_static_oop_field_count(mirror(), mk->compute_static_oop_field_count(mirror())); // It might also have a component mirror. This mirror must already exist. @@ -592,14 +592,14 @@ oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) { // This should be improved by adding a field at the Java level or by // introducing a new VM klass (see comment in ClassFileParser) - oop java_class = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(NULL, CHECK_0); + oop java_class = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->allocate_instance(NULL, CHECK_0); if (type != T_VOID) { Klass* aklass = Universe::typeArrayKlassObj(type); assert(aklass != NULL, "correct bootstrap"); set_array_klass(java_class, aklass); } #ifdef ASSERT - instanceMirrorKlass* mk = instanceMirrorKlass::cast(SystemDictionary::Class_klass()); + InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(SystemDictionary::Class_klass()); assert(java_lang_Class::static_oop_field_count(java_class) == 0, "should have been zeroed by allocation"); #endif return java_class; @@ -2835,17 +2835,17 @@ // Support for java_lang_System int java_lang_System::in_offset_in_bytes() { - return (instanceMirrorKlass::offset_of_static_fields() + static_in_offset); + return (InstanceMirrorKlass::offset_of_static_fields() + static_in_offset); } int java_lang_System::out_offset_in_bytes() { - return (instanceMirrorKlass::offset_of_static_fields() + static_out_offset); + return (InstanceMirrorKlass::offset_of_static_fields() + static_out_offset); } int java_lang_System::err_offset_in_bytes() { - return (instanceMirrorKlass::offset_of_static_fields() + static_err_offset); + return (InstanceMirrorKlass::offset_of_static_fields() + static_err_offset); } @@ -3124,10 +3124,10 @@ tty->print_cr("Static field %s.%s appears to be nonstatic", klass_name, field_name); return false; } - if (fd.offset() == hardcoded_offset + instanceMirrorKlass::offset_of_static_fields()) { + if (fd.offset() == hardcoded_offset + InstanceMirrorKlass::offset_of_static_fields()) { return true; } else { - tty->print_cr("Offset of static field %s.%s is hardcoded as %d but should really be %d.", klass_name, field_name, hardcoded_offset, fd.offset() - instanceMirrorKlass::offset_of_static_fields()); + tty->print_cr("Offset of static field %s.%s is hardcoded as %d but should really be %d.", klass_name, field_name, hardcoded_offset, fd.offset() - InstanceMirrorKlass::offset_of_static_fields()); return false; } }
--- a/src/share/vm/classfile/systemDictionary.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/classfile/systemDictionary.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -1953,7 +1953,7 @@ // Initialize the constant pool for the Object_class InstanceKlass* ik = InstanceKlass::cast(Object_klass()); ik->constants()->restore_unshareable_info(CHECK); - initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK); + initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK); } else { initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(Class_klass), scan, CHECK); } @@ -1976,7 +1976,7 @@ // Preload ref klasses and set reference types InstanceKlass::cast(WK_KLASS(Reference_klass))->set_reference_type(REF_OTHER); - instanceRefKlass::update_nonstatic_oop_maps(WK_KLASS(Reference_klass)); + InstanceRefKlass::update_nonstatic_oop_maps(WK_KLASS(Reference_klass)); initialize_wk_klasses_through(WK_KLASS_ENUM_NAME(PhantomReference_klass), scan, CHECK); InstanceKlass::cast(WK_KLASS(SoftReference_klass))->set_reference_type(REF_SOFT);
--- a/src/share/vm/compiler/compileBroker.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/compiler/compileBroker.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -1108,7 +1108,7 @@ // the pending list lock or a 3-way deadlock may occur // between the reference handler thread, a GC (instigated // by a compiler thread), and compiled method registration. - if (instanceRefKlass::owns_pending_list_lock(JavaThread::current())) { + if (InstanceRefKlass::owns_pending_list_lock(JavaThread::current())) { return; } @@ -1440,7 +1440,7 @@ // Should the current thread be blocked until this compilation request // has been fulfilled? bool CompileBroker::is_compile_blocking(methodHandle method, int osr_bci) { - assert(!instanceRefKlass::owns_pending_list_lock(JavaThread::current()), "possible deadlock"); + assert(!InstanceRefKlass::owns_pending_list_lock(JavaThread::current()), "possible deadlock"); return !BackgroundCompilation; }
--- a/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.hpp Tue Sep 11 18:28:51 2012 -0700 @@ -839,7 +839,7 @@ friend class AdjustKlassClosure; friend class FollowKlassClosure; friend class FollowRootClosure; - friend class instanceClassLoaderKlass; + friend class InstanceClassLoaderKlass; friend class RefProcTaskProxy; private:
--- a/src/share/vm/gc_implementation/shared/concurrentGCThread.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/gc_implementation/shared/concurrentGCThread.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -255,13 +255,13 @@ } switch(msg) { case acquirePLL: { - instanceRefKlass::acquire_pending_list_lock(&pll_basic_lock); + InstanceRefKlass::acquire_pending_list_lock(&pll_basic_lock); debug_only(owned++;) break; } case releaseAndNotifyPLL: { assert(owned > 0, "Don't have PLL"); - instanceRefKlass::release_and_notify_pending_list_lock(&pll_basic_lock); + InstanceRefKlass::release_and_notify_pending_list_lock(&pll_basic_lock); debug_only(owned--;) break; }
--- a/src/share/vm/gc_implementation/shared/vmGCOperations.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/gc_implementation/shared/vmGCOperations.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -70,13 +70,13 @@ void VM_GC_Operation::acquire_pending_list_lock() { // we may enter this with pending exception set - instanceRefKlass::acquire_pending_list_lock(&_pending_list_basic_lock); + InstanceRefKlass::acquire_pending_list_lock(&_pending_list_basic_lock); } void VM_GC_Operation::release_and_notify_pending_list_lock() { - instanceRefKlass::release_and_notify_pending_list_lock(&_pending_list_basic_lock); + InstanceRefKlass::release_and_notify_pending_list_lock(&_pending_list_basic_lock); } // Allocations may fail in several threads at about the same time,
--- a/src/share/vm/gc_interface/collectedHeap.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/gc_interface/collectedHeap.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -516,7 +516,7 @@ real_klass->set_java_mirror(mirror); } - instanceMirrorKlass* mk = instanceMirrorKlass::cast(mirror->klass()); + InstanceMirrorKlass* mk = InstanceMirrorKlass::cast(mirror->klass()); assert(size == mk->instance_size(real_klass), "should have been set"); // notify jvmti and dtrace
--- a/src/share/vm/interpreter/interpreterRuntime.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/interpreter/interpreterRuntime.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -734,6 +734,7 @@ } // end JvmtiHideSingleStepping cache_entry(thread)->set_method_handle( + pool, info.resolved_method(), info.resolved_appendix(), pool->resolved_references()); @@ -761,6 +762,7 @@ ConstantPoolCacheEntry* cp_cache_entry = pool->invokedynamic_cp_cache_entry_at(index); cp_cache_entry->set_dynamic_call( + pool, info.resolved_method(), info.resolved_appendix(), pool->resolved_references());
--- a/src/share/vm/memory/iterator.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/memory/iterator.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -26,6 +26,10 @@ #include "memory/iterator.hpp" #include "oops/oop.inline.hpp" +void KlassToOopClosure::do_klass(Klass* k) { + k->oops_do(_oop_closure); +} + void ObjectToOopClosure::do_object(oop obj) { obj->oop_iterate(_cl); }
--- a/src/share/vm/memory/iterator.hpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/memory/iterator.hpp Tue Sep 11 18:28:51 2012 -0700 @@ -128,6 +128,13 @@ virtual void do_klass(Klass* k) = 0; }; +class KlassToOopClosure : public KlassClosure { + OopClosure* _oop_closure; + public: + KlassToOopClosure(OopClosure* oop_closure) : _oop_closure(oop_closure) {} + virtual void do_klass(Klass* k); +}; + // ObjectClosure is used for iterating through an object space class ObjectClosure : public Closure {
--- a/src/share/vm/memory/metaspace.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/memory/metaspace.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -2541,7 +2541,7 @@ // MetaspaceAux -size_t MetaspaceAux::used_in_bytes_unsafe(Metaspace::MetadataType mdtype) { +size_t MetaspaceAux::used_in_bytes(Metaspace::MetadataType mdtype) { size_t used = 0; ClassLoaderDataGraphMetaspaceIterator iter; while (iter.repeat()) { @@ -2554,33 +2554,6 @@ return used * BytesPerWord; } -size_t MetaspaceAux::used_in_bytes(Metaspace::MetadataType mdtype) { - assert(SafepointSynchronize::is_at_safepoint(), - "Consistency checks require being at a safepoint"); - size_t used = 0; -#ifdef ASSERT - size_t free = 0; - size_t capacity = 0; -#endif - ClassLoaderDataGraphMetaspaceIterator iter; - while (iter.repeat()) { - Metaspace* msp = iter.get_next(); - // Sum allocation_total for each metaspace - if (msp != NULL) { - used += msp->used_words(mdtype); -#ifdef ASSERT - free += msp->free_words(mdtype); - capacity += msp->capacity_words(mdtype); - assert(used + free == capacity, - err_msg("Accounting is wrong used " SIZE_FORMAT - " free " SIZE_FORMAT " capacity " SIZE_FORMAT, - used, free, capacity)); -#endif - } - } - return used * BytesPerWord; -} - size_t MetaspaceAux::free_in_bytes(Metaspace::MetadataType mdtype) { size_t free = 0; ClassLoaderDataGraphMetaspaceIterator iter; @@ -2661,15 +2634,15 @@ out->print_cr(" Metaspace total " SIZE_FORMAT "K, used " SIZE_FORMAT "K," " reserved " SIZE_FORMAT "K", - capacity_in_bytes()/K, used_in_bytes_unsafe()/K, reserved_in_bytes()/K); + capacity_in_bytes()/K, used_in_bytes()/K, reserved_in_bytes()/K); out->print_cr(" data space " SIZE_FORMAT "K, used " SIZE_FORMAT "K," " reserved " SIZE_FORMAT "K", - capacity_in_bytes(nct)/K, used_in_bytes_unsafe(nct)/K, reserved_in_bytes(nct)/K); + capacity_in_bytes(nct)/K, used_in_bytes(nct)/K, reserved_in_bytes(nct)/K); out->print_cr(" class space " SIZE_FORMAT "K, used " SIZE_FORMAT "K," " reserved " SIZE_FORMAT "K", - capacity_in_bytes(ct)/K, used_in_bytes_unsafe(ct)/K, reserved_in_bytes(ct)/K); + capacity_in_bytes(ct)/K, used_in_bytes(ct)/K, reserved_in_bytes(ct)/K); } // Print information for class space and data space separately. @@ -2806,19 +2779,22 @@ _class_space_list = new VirtualSpaceList(rs); } -// Class space probably needs a lot less than data space -const int class_space_divisor = 4; void Metaspace::initialize(Mutex* lock, size_t initial_size) { - // Use SmallChunk size if not specified, adjust class to smaller size if so. + // Use SmallChunk size if not specified. If specified, use this size for + // the data metaspace. size_t word_size; size_t class_word_size; if (initial_size == 0) { word_size = (size_t) SpaceManager::SmallChunk; - class_word_size = word_size; + class_word_size = (size_t) SpaceManager::SmallChunk; } else { word_size = initial_size; - class_word_size = initial_size/class_space_divisor; + // Make the first class chunk bigger than a medium chunk so it's not put + // on the medium chunk list. The next chunk will be small and progress + // from there. This size calculated by -version. + class_word_size = MIN2((size_t)SpaceManager::MediumChunk*5, + (ClassMetaspaceSize/BytesPerWord)*2); } assert(space_list() != NULL,
--- a/src/share/vm/memory/metaspace.hpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/memory/metaspace.hpp Tue Sep 11 18:28:51 2012 -0700 @@ -149,10 +149,6 @@ // Statistics for class space and data space in metaspace. static size_t used_in_bytes(Metaspace::MetadataType mdtype); - // Same as used_in_bytes() without the consistency checking. - // Use this version if not at a safepoint (so consistency is - // not necessarily expected). - static size_t used_in_bytes_unsafe(Metaspace::MetadataType mdtype); static size_t free_in_bytes(Metaspace::MetadataType mdtype); static size_t capacity_in_bytes(Metaspace::MetadataType mdtype); static size_t reserved_in_bytes(Metaspace::MetadataType mdtype); @@ -167,11 +163,6 @@ used_in_bytes(Metaspace::NonClassType); } - static size_t used_in_bytes_unsafe() { - return used_in_bytes_unsafe(Metaspace::ClassType) + - used_in_bytes_unsafe(Metaspace::NonClassType); - } - // Total of available space in all Metaspaces // Total of capacity allocated to all Metaspaces. This includes // space in Metachunks not yet allocated and in the Metachunk
--- a/src/share/vm/memory/metaspaceCounters.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/memory/metaspaceCounters.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -35,7 +35,7 @@ size_t min_capacity = MetaspaceAux::min_chunk_size(); size_t max_capacity = MetaspaceAux::reserved_in_bytes(); size_t curr_capacity = MetaspaceAux::capacity_in_bytes(); - size_t used = MetaspaceAux::used_in_bytes_unsafe(); + size_t used = MetaspaceAux::used_in_bytes(); initialize(min_capacity, max_capacity, curr_capacity, used); } @@ -131,7 +131,7 @@ void MetaspaceCounters::update_used() { assert(UsePerfData, "Should not be called unless being used"); - size_t used_in_bytes = MetaspaceAux::used_in_bytes_unsafe(); + size_t used_in_bytes = MetaspaceAux::used_in_bytes(); _used->set_value(used_in_bytes); }
--- a/src/share/vm/memory/metaspaceShared.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/memory/metaspaceShared.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -153,9 +153,9 @@ // // Execution time: // First virtual method call for any object of these metadata types: -// 1. object->klass->klass_part -// 2. vtable entry for that klass_part points to the jump table entries -// 3. branches to common_code with %O0/klass_part, %L0: Klass index <<8 + method index +// 1. object->klass +// 2. vtable entry for that klass points to the jump table entries +// 3. branches to common_code with %O0/klass, %L0: Klass index <<8 + method index // 4. common_code: // Get address of new vtbl pointer for this Klass from updated table // Update new vtbl pointer in the Klass: future virtual calls go direct
--- a/src/share/vm/memory/referenceProcessor.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/memory/referenceProcessor.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -1036,7 +1036,7 @@ list = &_discoveredPhantomRefs[id]; break; case REF_NONE: - // we should not reach here if we are an instanceRefKlass + // we should not reach here if we are an InstanceRefKlass default: ShouldNotReachHere(); }
--- a/src/share/vm/memory/specialized_oop_closures.hpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/memory/specialized_oop_closures.hpp Tue Sep 11 18:28:51 2012 -0700 @@ -199,7 +199,7 @@ public: enum Kind { ik, // InstanceKlass - irk, // instanceRefKlass + irk, // InstanceRefKlass oa, // objArrayKlass NUM_Kinds };
--- a/src/share/vm/memory/universe.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/memory/universe.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -435,9 +435,9 @@ void Universe::init_self_patching_vtbl_list(void** list, int count) { int n = 0; { InstanceKlass o; add_vtable(list, &n, &o, 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); } + { 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); } { Method o; add_vtable(list, &n, &o, count); } @@ -486,7 +486,7 @@ assert(SystemDictionary::Class_klass_loaded(), "java.lang.Class should be loaded"); HandleMark hm(THREAD); // Cache the start of the static fields - instanceMirrorKlass::init_offset_of_static_fields(); + InstanceMirrorKlass::init_offset_of_static_fields(); GrowableArray <Klass*>* list = java_lang_Class::fixup_mirror_list(); int list_length = list->length(); @@ -858,7 +858,7 @@ ReservedSpace Universe::reserve_heap(size_t heap_size, size_t alignment) { // Add in the class metaspace area so the classes in the headers can // be compressed the same as instances. - size_t total_reserved = heap_size + ClassMetaspaceSize; + size_t total_reserved = align_size_up(heap_size + ClassMetaspaceSize, alignment); char* addr = Universe::preferred_heap_base(total_reserved, Universe::UnscaledNarrowOop); ReservedHeapSpace total_rs(total_reserved, alignment, UseLargePages, addr);
--- a/src/share/vm/oops/constantPool.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/oops/constantPool.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -152,6 +152,10 @@ // CDS support. Create a new resolved_references array. void ConstantPool::restore_unshareable_info(TRAPS) { + + // restore the C++ vtable from the shared archive + restore_vtable(); + if (SystemDictionary::Object_klass_loaded()) { // Recreate the object array and add to ClassLoaderData. int map_length = resolved_reference_length();
--- a/src/share/vm/oops/constantPool.hpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/oops/constantPool.hpp Tue Sep 11 18:28:51 2012 -0700 @@ -643,6 +643,11 @@ void remove_unshareable_info(); void restore_unshareable_info(TRAPS); bool resolve_class_constants(TRAPS); + // The ConstantPool vtable is restored by this call when the ConstantPool is + // in the shared archive. See patch_klass_vtables() in metaspaceShared.cpp for + // all the gory details. SA, dtrace and pstack helpers distinguish metadata + // by their vtable. + void restore_vtable() { guarantee(is_constantPool(), "vtable restored by this call"); } private: enum { _no_index_sentinel = -1, _possible_index_sentinel = -2 };
--- a/src/share/vm/oops/cpCache.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/oops/cpCache.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -243,17 +243,20 @@ } -void ConstantPoolCacheEntry::set_method_handle(methodHandle adapter, Handle appendix, +void ConstantPoolCacheEntry::set_method_handle(constantPoolHandle cpool, + methodHandle adapter, Handle appendix, objArrayHandle resolved_references) { - set_method_handle_common(Bytecodes::_invokehandle, adapter, appendix, resolved_references); + set_method_handle_common(cpool, Bytecodes::_invokehandle, adapter, appendix, resolved_references); } -void ConstantPoolCacheEntry::set_dynamic_call(methodHandle adapter, Handle appendix, +void ConstantPoolCacheEntry::set_dynamic_call(constantPoolHandle cpool, + methodHandle adapter, Handle appendix, objArrayHandle resolved_references) { - set_method_handle_common(Bytecodes::_invokedynamic, adapter, appendix, resolved_references); + set_method_handle_common(cpool, Bytecodes::_invokedynamic, adapter, appendix, resolved_references); } -void ConstantPoolCacheEntry::set_method_handle_common(Bytecodes::Code invoke_code, +void ConstantPoolCacheEntry::set_method_handle_common(constantPoolHandle cpool, + Bytecodes::Code invoke_code, methodHandle adapter, Handle appendix, objArrayHandle resolved_references) { @@ -261,28 +264,23 @@ // There are three words to update: flags, refs[f2], f1 (in that order). // Writers must store all other values before f1. // Readers must test f1 first for non-null before reading other fields. - // Competing writers must acquire exclusive access on the first - // write, to flags, using a compare/exchange. - // A losing writer to flags must spin until the winner writes f1, - // so that when he returns, he can use the linked cache entry. + // Competing writers must acquire exclusive access via a lock. + // A losing writer waits on the lock until the winner writes f1 and leaves + // the lock, so that when the losing writer returns, he can use the linked + // cache entry. + + MonitorLockerEx ml(cpool->lock()); + if (!is_f1_null()) { + return; + } bool has_appendix = appendix.not_null(); // Write the flags. - bool owner = - init_method_flags_atomic(as_TosState(adapter->result_type()), + set_method_flags(as_TosState(adapter->result_type()), ((has_appendix ? 1 : 0) << has_appendix_shift) | ( 1 << is_final_shift), adapter->size_of_parameters()); - if (!owner) { - // Somebody else is working on the same CPCE. Let them proceed. - while (is_f1_null()) { - // Pause momentarily on a low-level lock, to allow racing thread to win. - MutexLockerEx mu(Patching_lock, Mutex::_no_safepoint_check_flag); - os::yield(); - } - return; - } if (TraceInvokeDynamic) { tty->print_cr("set_method_handle bc=%d appendix="PTR_FORMAT"%s method="PTR_FORMAT" ",
--- a/src/share/vm/oops/cpCache.hpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/oops/cpCache.hpp Tue Sep 11 18:28:51 2012 -0700 @@ -221,12 +221,14 @@ ); void set_method_handle( + constantPoolHandle cpool, // holding constant pool (required for locking) methodHandle method, // adapter for invokeExact, etc. Handle appendix, // stored in refs[f2]; could be a java.lang.invoke.MethodType objArrayHandle resolved_references ); void set_dynamic_call( + constantPoolHandle cpool, // holding constant pool (required for locking) methodHandle method, // adapter for this call site Handle appendix, // stored in refs[f2]; could be a java.lang.invoke.CallSite objArrayHandle resolved_references @@ -248,6 +250,7 @@ // resolution logic needs to make slightly different assessments about the // number and types of arguments. void set_method_handle_common( + constantPoolHandle cpool, // holding constant pool (required for locking) Bytecodes::Code invoke_code, // _invokehandle or _invokedynamic methodHandle adapter, // invoker method (f1) Handle appendix, // appendix such as CallSite, MethodType, etc. (refs[f2])
--- a/src/share/vm/oops/instanceClassLoaderKlass.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/oops/instanceClassLoaderKlass.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -49,14 +49,14 @@ "Inconsistency in do_metadata"); \ if (closure->do_metadata##nv_suffix()) -// Macro to define instanceClassLoaderKlass::oop_oop_iterate for virtual/nonvirtual for +// Macro to define InstanceClassLoaderKlass::oop_oop_iterate for virtual/nonvirtual for // all closures. Macros calling macros above for each oop size. // Since ClassLoader objects have only a pointer to the loader_data, they are not // compressed nor does the pointer move. #define InstanceClassLoaderKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix)\ \ -int instanceClassLoaderKlass:: \ +int InstanceClassLoaderKlass:: \ oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) { \ /* Get size before changing pointers */ \ SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\ @@ -76,7 +76,7 @@ #ifndef SERIALGC #define InstanceClassLoaderKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \ \ -int instanceClassLoaderKlass:: \ +int InstanceClassLoaderKlass:: \ oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) { \ /* Get size before changing pointers */ \ SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\ @@ -88,7 +88,7 @@ #define InstanceClassLoaderKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \ \ -int instanceClassLoaderKlass:: \ +int InstanceClassLoaderKlass:: \ oop_oop_iterate##nv_suffix##_m(oop obj, \ OopClosureType* closure, \ MemRegion mr) { \ @@ -118,7 +118,7 @@ ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceClassLoaderKlass_OOP_OOP_ITERATE_DEFN_m) ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceClassLoaderKlass_OOP_OOP_ITERATE_DEFN_m) -void instanceClassLoaderKlass::oop_follow_contents(oop obj) { +void InstanceClassLoaderKlass::oop_follow_contents(oop obj) { InstanceKlass::oop_follow_contents(obj); ClassLoaderData * const loader_data = java_lang_ClassLoader::loader_data(obj); @@ -130,7 +130,7 @@ } #ifndef SERIALGC -void instanceClassLoaderKlass::oop_follow_contents(ParCompactionManager* cm, +void InstanceClassLoaderKlass::oop_follow_contents(ParCompactionManager* cm, oop obj) { InstanceKlass::oop_follow_contents(cm, obj); ClassLoaderData * const loader_data = java_lang_ClassLoader::loader_data(obj); @@ -139,7 +139,7 @@ } } -void instanceClassLoaderKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { +void InstanceClassLoaderKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { InstanceKlass::oop_push_contents(pm, obj); // This is called by the young collector. It will already have taken care of @@ -147,7 +147,7 @@ // class loader data link. } -int instanceClassLoaderKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { +int InstanceClassLoaderKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { InstanceKlass::oop_update_pointers(cm, obj); ClassLoaderData * const loader_data = java_lang_ClassLoader::loader_data(obj); if (loader_data != NULL) {
--- a/src/share/vm/oops/instanceClassLoaderKlass.hpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/oops/instanceClassLoaderKlass.hpp Tue Sep 11 18:28:51 2012 -0700 @@ -27,24 +27,24 @@ #include "oops/instanceKlass.hpp" -// An instanceClassLoaderKlass is a specialization of the InstanceKlass. It does +// An InstanceClassLoaderKlass is a specialization of the InstanceKlass. It does // not add any field. It is added to walk the dependencies for the class loader // key that this class loader points to. This is how the loader_data graph is // walked and dependant class loaders are kept alive. I thought we walked // the list later? -class instanceClassLoaderKlass: public InstanceKlass { +class InstanceClassLoaderKlass: public InstanceKlass { friend class VMStructs; friend class InstanceKlass; // Constructor - instanceClassLoaderKlass(int vtable_len, int itable_len, int static_field_size, int nonstatic_oop_map_size, ReferenceType rt, AccessFlags access_flags, bool is_anonymous) + InstanceClassLoaderKlass(int vtable_len, int itable_len, int static_field_size, int nonstatic_oop_map_size, ReferenceType rt, AccessFlags access_flags, bool is_anonymous) : InstanceKlass(vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, access_flags, is_anonymous) {} public: virtual bool oop_is_instanceClassLoader() const { return true; } - instanceClassLoaderKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); } + InstanceClassLoaderKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); } // Iterators int oop_oop_iterate(oop obj, ExtendedOopClosure* blk) {
--- a/src/share/vm/oops/instanceKlass.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/oops/instanceKlass.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -191,14 +191,14 @@ InstanceKlass* ik; if (rt == REF_NONE) { if (name == vmSymbols::java_lang_Class()) { - ik = new (loader_data, size, THREAD) instanceMirrorKlass( + ik = new (loader_data, size, THREAD) InstanceMirrorKlass( vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, access_flags, !host_klass.is_null()); } else if (name == vmSymbols::java_lang_ClassLoader() || (SystemDictionary::ClassLoader_klass_loaded() && super_klass != NULL && super_klass->is_subtype_of(SystemDictionary::ClassLoader_klass()))) { - ik = new (loader_data, size, THREAD) instanceClassLoaderKlass( + ik = new (loader_data, size, THREAD) InstanceClassLoaderKlass( vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, access_flags, !host_klass.is_null()); } else { @@ -209,7 +209,7 @@ } } else { // reference klass - ik = new (loader_data, size, THREAD) instanceRefKlass( + ik = new (loader_data, size, THREAD) InstanceRefKlass( vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, access_flags, !host_klass.is_null()); } @@ -2165,6 +2165,8 @@ for (int index2 = 0; index2 < num_methods; ++index2) { methodHandle m(THREAD, methods->at(index2)); m()->link_method(m, CHECK); + // restore method's vtable by calling a virtual function + m->restore_vtable(); } if (JvmtiExport::has_redefined_a_class()) { // Reinitialize vtable because RedefineClasses may have changed some @@ -2282,7 +2284,7 @@ } address InstanceKlass::static_field_addr(int offset) { - return (address)(offset + instanceMirrorKlass::offset_of_static_fields() + (intptr_t)java_mirror()); + return (address)(offset + InstanceMirrorKlass::offset_of_static_fields() + (intptr_t)java_mirror()); } @@ -3071,7 +3073,7 @@ void JNIid::verify(Klass* holder) { - int first_field_offset = instanceMirrorKlass::offset_of_static_fields(); + int first_field_offset = InstanceMirrorKlass::offset_of_static_fields(); int end_field_offset; end_field_offset = first_field_offset + (InstanceKlass::cast(holder)->static_field_size() * wordSize);
--- a/src/share/vm/oops/instanceMirrorKlass.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/oops/instanceMirrorKlass.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -47,7 +47,7 @@ #include "oops/oop.pcgc.inline.hpp" #endif -int instanceMirrorKlass::_offset_of_static_fields = 0; +int InstanceMirrorKlass::_offset_of_static_fields = 0; #ifdef ASSERT template <class T> void assert_is_in(T *p) { @@ -148,7 +148,7 @@ } -void instanceMirrorKlass::oop_follow_contents(oop obj) { +void InstanceMirrorKlass::oop_follow_contents(oop obj) { InstanceKlass::oop_follow_contents(obj); // Follow the klass field in the mirror. @@ -169,7 +169,7 @@ } #ifndef SERIALGC -void instanceMirrorKlass::oop_follow_contents(ParCompactionManager* cm, +void InstanceMirrorKlass::oop_follow_contents(ParCompactionManager* cm, oop obj) { InstanceKlass::oop_follow_contents(cm, obj); @@ -191,7 +191,7 @@ } #endif // SERIALGC -int instanceMirrorKlass::oop_adjust_pointers(oop obj) { +int InstanceMirrorKlass::oop_adjust_pointers(oop obj) { int size = oop_size(obj); InstanceKlass::oop_adjust_pointers(obj); @@ -235,12 +235,12 @@ "Inconsistency in do_metadata"); \ if (closure->do_metadata##nv_suffix()) -// Macro to define instanceMirrorKlass::oop_oop_iterate for virtual/nonvirtual for +// Macro to define InstanceMirrorKlass::oop_oop_iterate for virtual/nonvirtual for // all closures. Macros calling macros above for each oop size. #define InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ \ -int instanceMirrorKlass:: \ +int InstanceMirrorKlass:: \ oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) { \ /* Get size before changing pointers */ \ SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk); \ @@ -265,7 +265,7 @@ #ifndef SERIALGC #define InstanceMirrorKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \ \ -int instanceMirrorKlass:: \ +int InstanceMirrorKlass:: \ oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) { \ /* Get size before changing pointers */ \ SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk); \ @@ -283,7 +283,7 @@ #define InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \ \ -int instanceMirrorKlass:: \ +int InstanceMirrorKlass:: \ oop_oop_iterate##nv_suffix##_m(oop obj, \ OopClosureType* closure, \ MemRegion mr) { \ @@ -318,7 +318,7 @@ ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN_m) #ifndef SERIALGC -void instanceMirrorKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { +void InstanceMirrorKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { // Note that we don't have to follow the mirror -> klass pointer, since all // klasses that are dirty will be scavenged when we iterate over the // ClassLoaderData objects. @@ -332,7 +332,7 @@ assert_nothing ) } -int instanceMirrorKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { +int InstanceMirrorKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { int size = oop_size(obj); InstanceKlass::oop_update_pointers(cm, obj); @@ -355,14 +355,14 @@ } #endif // SERIALGC -int instanceMirrorKlass::instance_size(KlassHandle k) { +int InstanceMirrorKlass::instance_size(KlassHandle k) { if (k() != NULL && k->oop_is_instance()) { return align_object_size(size_helper() + InstanceKlass::cast(k())->static_field_size()); } return size_helper(); } -instanceOop instanceMirrorKlass::allocate_instance(KlassHandle k, TRAPS) { +instanceOop InstanceMirrorKlass::allocate_instance(KlassHandle k, TRAPS) { // Query before forming handle. int size = instance_size(k); KlassHandle h_k(THREAD, this); @@ -370,11 +370,11 @@ return i; } -int instanceMirrorKlass::oop_size(oop obj) const { +int InstanceMirrorKlass::oop_size(oop obj) const { return java_lang_Class::oop_size(obj); } -int instanceMirrorKlass::compute_static_oop_field_count(oop obj) { +int InstanceMirrorKlass::compute_static_oop_field_count(oop obj) { Klass* k = java_lang_Class::as_Klass(obj); if (k != NULL && k->oop_is_instance()) { return InstanceKlass::cast(k)->static_oop_field_count();
--- a/src/share/vm/oops/instanceMirrorKlass.hpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/oops/instanceMirrorKlass.hpp Tue Sep 11 18:28:51 2012 -0700 @@ -29,7 +29,7 @@ #include "oops/instanceKlass.hpp" #include "runtime/handles.hpp" -// An instanceMirrorKlass is a specialized InstanceKlass for +// An InstanceMirrorKlass is a specialized InstanceKlass for // java.lang.Class instances. These instances are special because // they contain the static fields of the class in addition to the // normal fields of Class. This means they are variable sized @@ -37,7 +37,7 @@ // iteration of their oops. -class instanceMirrorKlass: public InstanceKlass { +class InstanceMirrorKlass: public InstanceKlass { friend class VMStructs; friend class InstanceKlass; @@ -45,18 +45,18 @@ static int _offset_of_static_fields; // Constructor - instanceMirrorKlass(int vtable_len, int itable_len, int static_field_size, int nonstatic_oop_map_size, ReferenceType rt, AccessFlags access_flags, bool is_anonymous) + InstanceMirrorKlass(int vtable_len, int itable_len, int static_field_size, int nonstatic_oop_map_size, ReferenceType rt, AccessFlags access_flags, bool is_anonymous) : InstanceKlass(vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, access_flags, is_anonymous) {} public: - instanceMirrorKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); } + InstanceMirrorKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); } // Type testing bool oop_is_instanceMirror() const { return true; } // Casting from Klass* - static instanceMirrorKlass* cast(Klass* k) { - assert(k->oop_is_instanceMirror(), "cast to instanceMirrorKlass"); - return (instanceMirrorKlass*) k; + static InstanceMirrorKlass* cast(Klass* k) { + assert(k->oop_is_instanceMirror(), "cast to InstanceMirrorKlass"); + return (InstanceMirrorKlass*) k; } // Returns the size of the instance including the extra static fields. @@ -71,7 +71,7 @@ static void init_offset_of_static_fields() { // Cache the offset of the static fields in the Class instance assert(_offset_of_static_fields == 0, "once"); - _offset_of_static_fields = instanceMirrorKlass::cast(SystemDictionary::Class_klass())->size_helper() << LogHeapWordSize; + _offset_of_static_fields = InstanceMirrorKlass::cast(SystemDictionary::Class_klass())->size_helper() << LogHeapWordSize; } static int offset_of_static_fields() {
--- a/src/share/vm/oops/instanceRefKlass.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/oops/instanceRefKlass.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -45,12 +45,12 @@ #endif template <class T> -void specialized_oop_follow_contents(instanceRefKlass* ref, oop obj) { +void specialized_oop_follow_contents(InstanceRefKlass* ref, oop obj) { T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj); T heap_oop = oopDesc::load_heap_oop(referent_addr); debug_only( if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr("instanceRefKlass::oop_follow_contents " INTPTR_FORMAT, obj); + gclog_or_tty->print_cr("InstanceRefKlass::oop_follow_contents " INTPTR_FORMAT, obj); } ) if (!oopDesc::is_null(heap_oop)) { @@ -112,7 +112,7 @@ ref->InstanceKlass::oop_follow_contents(obj); } -void instanceRefKlass::oop_follow_contents(oop obj) { +void InstanceRefKlass::oop_follow_contents(oop obj) { if (UseCompressedOops) { specialized_oop_follow_contents<narrowOop>(this, obj); } else { @@ -122,14 +122,14 @@ #ifndef SERIALGC template <class T> -void specialized_oop_follow_contents(instanceRefKlass* ref, +void specialized_oop_follow_contents(InstanceRefKlass* ref, ParCompactionManager* cm, oop obj) { T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj); T heap_oop = oopDesc::load_heap_oop(referent_addr); debug_only( if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr("instanceRefKlass::oop_follow_contents " INTPTR_FORMAT, obj); + gclog_or_tty->print_cr("InstanceRefKlass::oop_follow_contents " INTPTR_FORMAT, obj); } ) if (!oopDesc::is_null(heap_oop)) { @@ -186,7 +186,7 @@ ref->InstanceKlass::oop_follow_contents(cm, obj); } -void instanceRefKlass::oop_follow_contents(ParCompactionManager* cm, +void InstanceRefKlass::oop_follow_contents(ParCompactionManager* cm, oop obj) { if (UseCompressedOops) { specialized_oop_follow_contents<narrowOop>(this, cm, obj); @@ -218,18 +218,18 @@ } #endif -template <class T> void specialized_oop_adjust_pointers(instanceRefKlass *ref, oop obj) { +template <class T> void specialized_oop_adjust_pointers(InstanceRefKlass *ref, oop obj) { T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj); MarkSweep::adjust_pointer(referent_addr); T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj); MarkSweep::adjust_pointer(next_addr); T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj); MarkSweep::adjust_pointer(discovered_addr); - debug_only(trace_reference_gc("instanceRefKlass::oop_adjust_pointers", obj, + debug_only(trace_reference_gc("InstanceRefKlass::oop_adjust_pointers", obj, referent_addr, next_addr, discovered_addr);) } -int instanceRefKlass::oop_adjust_pointers(oop obj) { +int InstanceRefKlass::oop_adjust_pointers(oop obj) { int size = size_helper(); InstanceKlass::oop_adjust_pointers(obj); @@ -298,12 +298,12 @@ template <class T> bool contains(T *t) { return true; } -// Macro to define instanceRefKlass::oop_oop_iterate for virtual/nonvirtual for +// Macro to define InstanceRefKlass::oop_oop_iterate for virtual/nonvirtual for // all closures. Macros calling macros above for each oop size. #define InstanceRefKlass_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ \ -int instanceRefKlass:: \ +int InstanceRefKlass:: \ oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) { \ /* Get size before changing pointers */ \ SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\ @@ -320,7 +320,7 @@ #ifndef SERIALGC #define InstanceRefKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \ \ -int instanceRefKlass:: \ +int InstanceRefKlass:: \ oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) { \ /* Get size before changing pointers */ \ SpecializationStats::record_iterate_call##nv_suffix(SpecializationStats::irk);\ @@ -338,7 +338,7 @@ #define InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \ \ -int instanceRefKlass:: \ +int InstanceRefKlass:: \ oop_oop_iterate##nv_suffix##_m(oop obj, \ OopClosureType* closure, \ MemRegion mr) { \ @@ -363,7 +363,7 @@ #ifndef SERIALGC template <class T> -void specialized_oop_push_contents(instanceRefKlass *ref, +void specialized_oop_push_contents(InstanceRefKlass *ref, PSPromotionManager* pm, oop obj) { T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj); if (PSScavenge::should_scavenge(referent_addr)) { @@ -414,7 +414,7 @@ ref->InstanceKlass::oop_push_contents(pm, obj); } -void instanceRefKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { +void InstanceRefKlass::oop_push_contents(PSPromotionManager* pm, oop obj) { if (UseCompressedOops) { specialized_oop_push_contents<narrowOop>(this, pm, obj); } else { @@ -423,7 +423,7 @@ } template <class T> -void specialized_oop_update_pointers(instanceRefKlass *ref, +void specialized_oop_update_pointers(InstanceRefKlass *ref, ParCompactionManager* cm, oop obj) { T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj); PSParallelCompact::adjust_pointer(referent_addr); @@ -431,11 +431,11 @@ PSParallelCompact::adjust_pointer(next_addr); T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj); PSParallelCompact::adjust_pointer(discovered_addr); - debug_only(trace_reference_gc("instanceRefKlass::oop_update_ptrs", obj, + debug_only(trace_reference_gc("InstanceRefKlass::oop_update_ptrs", obj, referent_addr, next_addr, discovered_addr);) } -int instanceRefKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { +int InstanceRefKlass::oop_update_pointers(ParCompactionManager* cm, oop obj) { InstanceKlass::oop_update_pointers(cm, obj); if (UseCompressedOops) { specialized_oop_update_pointers<narrowOop>(this, cm, obj); @@ -446,7 +446,7 @@ } #endif // SERIALGC -void instanceRefKlass::update_nonstatic_oop_maps(Klass* k) { +void InstanceRefKlass::update_nonstatic_oop_maps(Klass* k) { // Clear the nonstatic oop-map entries corresponding to referent // and nextPending field. They are treated specially by the // garbage collector. @@ -485,7 +485,7 @@ // Verification -void instanceRefKlass::oop_verify_on(oop obj, outputStream* st) { +void InstanceRefKlass::oop_verify_on(oop obj, outputStream* st) { InstanceKlass::oop_verify_on(obj, st); // Verify referent field oop referent = java_lang_ref_Reference::referent(obj); @@ -506,13 +506,13 @@ } } -bool instanceRefKlass::owns_pending_list_lock(JavaThread* thread) { +bool InstanceRefKlass::owns_pending_list_lock(JavaThread* thread) { if (java_lang_ref_Reference::pending_list_lock() == NULL) return false; Handle h_lock(thread, java_lang_ref_Reference::pending_list_lock()); return ObjectSynchronizer::current_thread_holds_lock(thread, h_lock); } -void instanceRefKlass::acquire_pending_list_lock(BasicLock *pending_list_basic_lock) { +void InstanceRefKlass::acquire_pending_list_lock(BasicLock *pending_list_basic_lock) { // we may enter this with pending exception set PRESERVE_EXCEPTION_MARK; // exceptions are never thrown, needed for TRAPS argument @@ -529,7 +529,7 @@ if (HAS_PENDING_EXCEPTION) CLEAR_PENDING_EXCEPTION; } -void instanceRefKlass::release_and_notify_pending_list_lock( +void InstanceRefKlass::release_and_notify_pending_list_lock( BasicLock *pending_list_basic_lock) { // we may enter this with pending exception set PRESERVE_EXCEPTION_MARK; // exceptions are never thrown, needed for TRAPS argument
--- a/src/share/vm/oops/instanceRefKlass.hpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/oops/instanceRefKlass.hpp Tue Sep 11 18:28:51 2012 -0700 @@ -27,7 +27,7 @@ #include "oops/instanceKlass.hpp" -// An instanceRefKlass is a specialized InstanceKlass for Java +// An InstanceRefKlass is a specialized InstanceKlass for Java // classes that are subclasses of java/lang/ref/Reference. // // These classes are used to implement soft/weak/final/phantom @@ -44,22 +44,22 @@ // and the pending list lock object in the same class is notified. -class instanceRefKlass: public InstanceKlass { +class InstanceRefKlass: public InstanceKlass { friend class InstanceKlass; // Constructor - instanceRefKlass(int vtable_len, int itable_len, int static_field_size, int nonstatic_oop_map_size, ReferenceType rt, AccessFlags access_flags, bool is_anonymous) + InstanceRefKlass(int vtable_len, int itable_len, int static_field_size, int nonstatic_oop_map_size, ReferenceType rt, AccessFlags access_flags, bool is_anonymous) : InstanceKlass(vtable_len, itable_len, static_field_size, nonstatic_oop_map_size, rt, access_flags, is_anonymous) {} public: - instanceRefKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); } + InstanceRefKlass() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); } // Type testing bool oop_is_instanceRef() const { return true; } // Casting from Klass* - static instanceRefKlass* cast(Klass* k) { - assert(k->oop_is_instanceRef(), "cast to instanceRefKlass"); - return (instanceRefKlass*) k; + static InstanceRefKlass* cast(Klass* k) { + assert(k->oop_is_instanceRef(), "cast to InstanceRefKlass"); + return (InstanceRefKlass*) k; } // Garbage collection
--- a/src/share/vm/oops/method.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/oops/method.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -376,7 +376,7 @@ void Method::build_interpreter_method_data(methodHandle method, TRAPS) { // Do not profile method if current thread holds the pending list lock, // which avoids deadlock for acquiring the MethodData_lock. - if (instanceRefKlass::owns_pending_list_lock((JavaThread*)THREAD)) { + if (InstanceRefKlass::owns_pending_list_lock((JavaThread*)THREAD)) { return; }
--- a/src/share/vm/oops/method.hpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/oops/method.hpp Tue Sep 11 18:28:51 2012 -0700 @@ -168,9 +168,16 @@ TRAPS); Method() { assert(DumpSharedSpaces || UseSharedSpaces, "only for CDS"); } + + // The Method vtable is restored by this call when the Method is in the + // shared archive. See patch_klass_vtables() in metaspaceShared.cpp for + // all the gory details. SA, dtrace and pstack helpers distinguish metadata + // by their vtable. + void restore_vtable() { guarantee(is_method(), "vtable restored by this call"); } bool is_method() const volatile { return true; } // accessors for instance variables + ConstMethod* constMethod() const { return _constMethod; } void set_constMethod(ConstMethod* xconst) { _constMethod = xconst; }
--- a/src/share/vm/oops/oopsHierarchy.hpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/oops/oopsHierarchy.hpp Tue Sep 11 18:28:51 2012 -0700 @@ -169,9 +169,9 @@ class Klass; class InstanceKlass; -class instanceMirrorKlass; -class instanceClassLoaderKlass; -class instanceRefKlass; +class InstanceMirrorKlass; +class InstanceClassLoaderKlass; +class InstanceRefKlass; class arrayKlass; class objArrayKlass; class typeArrayKlass;
--- a/src/share/vm/opto/runtime.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/opto/runtime.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -1148,7 +1148,7 @@ // create input type (domain) const Type **fields = TypeTuple::fields(2); fields[TypeFunc::Parms+0] = TypeRawPtr::BOTTOM; // Thread-local storage - fields[TypeFunc::Parms+1] = TypeInstPtr::NOTNULL; // Method*; Method we are entering + fields[TypeFunc::Parms+1] = TypeMetadataPtr::BOTTOM; // Method*; Method we are entering const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+2,fields); // create result type (range)
--- a/src/share/vm/opto/type.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/opto/type.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -2380,7 +2380,7 @@ assert(this->isa_instptr(), "must be an instance ptr."); _is_ptr_to_narrowoop = false; } else if (klass() == ciEnv::current()->Class_klass() && - _offset >= instanceMirrorKlass::offset_of_static_fields()) { + _offset >= InstanceMirrorKlass::offset_of_static_fields()) { // Static fields assert(o != NULL, "must be constant"); ciInstanceKlass* k = o->as_instance()->java_lang_Class_klass()->as_instance_klass();
--- a/src/share/vm/prims/jvmtiTagMap.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/prims/jvmtiTagMap.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -2552,15 +2552,17 @@ return; } + assert(Universe::heap()->is_in_reserved(o), "should be impossible"); + jvmtiHeapReferenceKind kind = root_kind(); - - assert(Universe::heap()->is_in_reserved(o), "should be impossible"); + if (kind == JVMTI_HEAP_REFERENCE_SYSTEM_CLASS) { // SystemDictionary::always_strong_oops_do reports the application // class loader as a root. We want this root to be reported as // a root kind of "OTHER" rather than "SYSTEM_CLASS". - if (o->is_instance() && root_kind() == JVMTI_HEAP_REFERENCE_SYSTEM_CLASS) { + if (!o->is_instanceMirror()) { kind = JVMTI_HEAP_REFERENCE_OTHER; } + } // some objects are ignored - in the case of simple // roots it's mostly Symbol*s that we are skipping @@ -2790,7 +2792,7 @@ static inline bool verify_static_oop(InstanceKlass* ik, oop mirror, int offset) { address obj_p = (address)mirror + offset; - address start = (address)instanceMirrorKlass::start_of_static_fields(mirror); + address start = (address)InstanceMirrorKlass::start_of_static_fields(mirror); address end = start + (java_lang_Class::static_oop_field_count(mirror) * heapOopSize); assert(end >= start, "sanity check"); @@ -2991,7 +2993,8 @@ // Preloaded classes and loader from the system dictionary blk.set_kind(JVMTI_HEAP_REFERENCE_SYSTEM_CLASS); SystemDictionary::always_strong_oops_do(&blk); - ClassLoaderDataGraph::always_strong_oops_do(&blk, NULL, false); + KlassToOopClosure klass_blk(&blk); + ClassLoaderDataGraph::always_strong_oops_do(&blk, &klass_blk, false); if (blk.stopped()) { return false; }
--- a/src/share/vm/runtime/arguments.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/runtime/arguments.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -1427,6 +1427,16 @@ // if (FLAG_IS_DEFAULT(UseCompressedKlassPointers)) { // FLAG_SET_ERGO(bool, UseCompressedKlassPointers, true); // } + // Set the ClassMetaspaceSize to something that will not need to be + // expanded, since it cannot be expanded. + if (UseCompressedKlassPointers && FLAG_IS_DEFAULT(ClassMetaspaceSize)) { + // 100,000 classes seems like a good size, so 100M assumes around 1K + // per klass. The vtable and oopMap is embedded so we don't have a fixed + // size per klass. Eventually, this will be parameterized because it + // would also be useful to determine the optimal size of the + // systemDictionary. + FLAG_SET_ERGO(uintx, ClassMetaspaceSize, 100*M); + } } // Also checks that certain machines are slower with compressed oops // in vm_version initialization code. @@ -1965,6 +1975,9 @@ status = status && verify_object_alignment(); + status = status && verify_min_value(ClassMetaspaceSize, 1*M, + "ClassMetaspaceSize"); + return status; } @@ -2916,7 +2929,7 @@ (UseLargePages && FLAG_IS_CMDLINE(UseLargePages)); if (cannot_share) { if (must_share) { - warning("disabling large pages%s" + warning("disabling large pages %s" "because of %s", "" LP64_ONLY("and compressed oops "), DumpSharedSpaces ? "-Xshare:dump" : "-Xshare:on"); FLAG_SET_CMDLINE(bool, UseLargePages, false);
--- a/src/share/vm/runtime/globals.hpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/runtime/globals.hpp Tue Sep 11 18:28:51 2012 -0700 @@ -2993,7 +2993,7 @@ product(uintx, MaxMetaspaceSize, max_uintx, \ "Maximum size of Metaspaces (in bytes)") \ \ - product(uintx, ClassMetaspaceSize, NOT_LP64(1*M) LP64_ONLY(512*M), \ + product(uintx, ClassMetaspaceSize, 2*M, \ "Maximum size of InstanceKlass area in Metaspace used for " \ "UseCompressedKlassPointers") \ \
--- a/src/share/vm/runtime/vmStructs.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/runtime/vmStructs.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -1374,9 +1374,9 @@ declare_type(objArrayKlass, arrayKlass) \ declare_type(typeArrayKlass, arrayKlass) \ declare_type(InstanceKlass, Klass) \ - declare_type(instanceClassLoaderKlass, InstanceKlass) \ - declare_type(instanceMirrorKlass, InstanceKlass) \ - declare_type(instanceRefKlass, InstanceKlass) \ + declare_type(InstanceClassLoaderKlass, InstanceKlass) \ + declare_type(InstanceMirrorKlass, InstanceKlass) \ + declare_type(InstanceRefKlass, InstanceKlass) \ declare_type(ConstantPool, Metadata) \ declare_type(ConstantPoolCache, MetaspaceObj) \ declare_type(MethodData, Metadata) \
--- a/src/share/vm/utilities/globalDefinitions.cpp Tue Sep 11 20:53:17 2012 -0400 +++ b/src/share/vm/utilities/globalDefinitions.cpp Tue Sep 11 18:28:51 2012 -0700 @@ -213,7 +213,7 @@ // Map BasicType to size in words -int type2size[T_CONFLICT+1]={ -1, 0, 0, 0, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 0, 1, 1, -1}; +int type2size[T_CONFLICT+1]={ -1, 0, 0, 0, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 0, 1, 1, 1, -1}; BasicType type2field[T_CONFLICT+1] = { (BasicType)0, // 0,