truffle: src/cpu/sparc/vm/c1_LIRAssembler

comparison src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp @ 6725:da91efe96a93

6964458: Reimplement class meta-data storage to use native memory Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>

author	coleenp
date	Sat, 01 Sep 2012 13:25:18 -0400
parents	1d7922586cf6
children	8a02ca5e5576

comparison

equal deleted inserted replaced

-:36d1d483d5d6
+:da91efe96a93
 __ bind(*stub->continuation());
 }
 if (compilation()->env()->dtrace_method_probes()) {
 __ mov(G2_thread, O0);
-jobject2reg(method()->constant_encoding(), O1);
+metadata2reg(method()->constant_encoding(), O1);
 __ call(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_method_exit), relocInfo::runtime_call_type);
 __ delayed()->nop();
 }
 if (method()->is_synchronized() || compilation()->env()->dtrace_method_probes()) {
 void LIR_Assembler::jobject2reg(jobject o, Register reg) {
 if (o == NULL) {
 __ set(NULL_WORD, reg);
 } else {
 int oop_index = __ oop_recorder()->find_index(o);
+assert(Universe::heap()->is_in_reserved(JNIHandles::resolve(o)), "should be real oop");
 RelocationHolder rspec = oop_Relocation::spec(oop_index);
 __ set(NULL_WORD, reg, rspec); // Will be set when the nmethod is created
 }
 }
 void LIR_Assembler::jobject2reg_with_patching(Register reg, CodeEmitInfo *info) {
-// Allocate a new index in oop table to hold the oop once it's been patched
+// Allocate a new index in table to hold the object once it's been patched
-int oop_index = __ oop_recorder()->allocate_index((jobject)NULL);
+int oop_index = __ oop_recorder()->allocate_oop_index(NULL);
-PatchingStub* patch = new PatchingStub(_masm, PatchingStub::load_klass_id, oop_index);
+PatchingStub* patch = new PatchingStub(_masm, PatchingStub::load_mirror_id, oop_index);
 AddressLiteral addrlit(NULL, oop_Relocation::spec(oop_index));
 assert(addrlit.rspec().type() == relocInfo::oop_type, "must be an oop reloc");
 // It may not seem necessary to use a sethi/add pair to load a NULL into dest, but the
 // NULL will be dynamically patched later and the patched value may be large.  We must
 __ patchable_set(addrlit, reg);
 patching_epilog(patch, lir_patch_normal, reg, info);
 }
+void LIR_Assembler::metadata2reg(Metadata* o, Register reg) {
+__ set_metadata_constant(o, reg);
+}
+void LIR_Assembler::klass2reg_with_patching(Register reg, CodeEmitInfo *info) {
+// Allocate a new index in table to hold the klass once it's been patched
+int index = __ oop_recorder()->allocate_metadata_index(NULL);
+PatchingStub* patch = new PatchingStub(_masm, PatchingStub::load_klass_id, index);
+AddressLiteral addrlit(NULL, metadata_Relocation::spec(index));
+assert(addrlit.rspec().type() == relocInfo::metadata_type, "must be an metadata reloc");
+// It may not seem necessary to use a sethi/add pair to load a NULL into dest, but the
+// NULL will be dynamically patched later and the patched value may be large.  We must
+// therefore generate the sethi/add as a placeholders
+__ patchable_set(addrlit, reg);
+patching_epilog(patch, lir_patch_normal, reg, info);
+}
 void LIR_Assembler::emit_op3(LIR_Op3* op) {
 Register Rdividend = op->in_opr1()->as_register();
 Register Rdivisor  = noreg;
 Register Rscratch  = op->in_opr3()->as_register();
 // LIR_Assembler::emit_delay.
 }
 void LIR_Assembler::ic_call(LIR_OpJavaCall* op) {
-RelocationHolder rspec = virtual_call_Relocation::spec(pc());
+__ ic_call(op->addr(), false);
-__ set_oop((jobject)Universe::non_oop_word(), G5_inline_cache_reg);
-__ relocate(rspec);
-__ call(op->addr(), relocInfo::none);
 // The peephole pass fills the delay slot, add_call_info is done in
 // LIR_Assembler::emit_delay.
 }
 // This will generate 2 instructions
 __ set(op->vtable_offset(), G5_method);
 // ld_ptr, set_hi, set
 __ ld_ptr(G3_scratch, G5_method, G5_method);
 }
-__ ld_ptr(G5_method, methodOopDesc::from_compiled_offset(), G3_scratch);
+__ ld_ptr(G5_method, Method::from_compiled_offset(), G3_scratch);
 __ callr(G3_scratch, G0);
 // the peephole pass fills the delay slot
 }
 int LIR_Assembler::store(LIR_Opr from_reg, Register base, int offset, BasicType type, bool wide, bool unaligned) {
 jobject2reg_with_patching(to_reg->as_register(), info);
 }
 }
 break;
+case T_METADATA:
+{
+if (patch_code == lir_patch_none) {
+metadata2reg(c->as_metadata(), to_reg->as_register());
+} else {
+klass2reg_with_patching(to_reg->as_register(), info);
+}
+}
+break;
 case T_FLOAT:
 {
 address const_addr = __ float_constant(c->as_jfloat());
 if (const_addr == NULL) {
 bailout("const section overflow");
 }
 int start = __ offset();
 __ relocate(static_stub_Relocation::spec(call_pc));
-__ set_oop(NULL, G5);
+__ set_metadata(NULL, G5);
 // must be set to -1 at code generation time
 AddressLiteral addrlit(-1);
 __ jump_to(addrlit, G3);
 __ delayed()->nop();
 __ br(Assembler::always, false, Assembler::pt, _unwind_handler_entry);
 __ delayed()->nop();
 }
 void LIR_Assembler::emit_arraycopy(LIR_OpArrayCopy* op) {
 Register src = op->src()->as_register();
 Register dst = op->dst()->as_register();
 Register src_pos = op->src_pos()->as_register();
 Register dst_pos = op->dst_pos()->as_register();
 if (flags & LIR_OpArrayCopy::type_check) {
 // We don't know the array types are compatible
 if (basic_type != T_OBJECT) {
 // Simple test for basic type arrays
-if (UseCompressedOops) {
+if (UseCompressedKlassPointers) {
 // We don't need decode because we just need to compare
 __ lduw(src, oopDesc::klass_offset_in_bytes(), tmp);
 __ lduw(dst, oopDesc::klass_offset_in_bytes(), tmp2);
 __ cmp(tmp, tmp2);
 __ br(Assembler::notEqual, false, Assembler::pt, *stub->entry());
 // object array case, if no type check is needed then either the
 // dst type is exactly the expected type and the src type is a
 // subtype which we can't check or src is the same array as dst
 // but not necessarily exactly of type default_type.
 Label known_ok, halt;
-jobject2reg(op->expected_type()->constant_encoding(), tmp);
+metadata2reg(op->expected_type()->constant_encoding(), tmp);
-if (UseCompressedOops) {
+if (UseCompressedKlassPointers) {
 // tmp holds the default type. It currently comes uncompressed after the
 // load of a constant, so encode it.
 __ encode_heap_oop(tmp);
 // load the raw value of the dst klass, since we will be comparing
 // uncompressed values directly.
 op->tmp3()->as_register()  == G4 &&
 op->obj()->as_register()   == O0 &&
 op->klass()->as_register() == G5, "must be");
 if (op->init_check()) {
 __ ldub(op->klass()->as_register(),
-in_bytes(instanceKlass::init_state_offset()),
+in_bytes(InstanceKlass::init_state_offset()),
 op->tmp1()->as_register());
 add_debug_info_for_null_check_here(op->stub()->info());
-__ cmp(op->tmp1()->as_register(), instanceKlass::fully_initialized);
+__ cmp(op->tmp1()->as_register(), InstanceKlass::fully_initialized);
 __ br(Assembler::notEqual, false, Assembler::pn, *op->stub()->entry());
 __ delayed()->nop();
 }
 __ allocate_object(op->obj()->as_register(),
 op->tmp1()->as_register(),
 Label not_null;
 __ br_notnull_short(obj, Assembler::pn, not_null);
 Register mdo      = k_RInfo;
 Register data_val = Rtmp1;
-jobject2reg(md->constant_encoding(), mdo);
+metadata2reg(md->constant_encoding(), mdo);
 if (mdo_offset_bias > 0) {
 __ set(mdo_offset_bias, data_val);
 __ add(mdo, data_val, mdo);
 }
 Address flags_addr(mdo, md->byte_offset_of_slot(data, DataLayout::flags_offset()) - mdo_offset_bias);
 Label *success_target = op->should_profile() ? &profile_cast_success : success;
 // patching may screw with our temporaries on sparc,
 // so let's do it before loading the class
 if (k->is_loaded()) {
-jobject2reg(k->constant_encoding(), k_RInfo);
+metadata2reg(k->constant_encoding(), k_RInfo);
 } else {
-jobject2reg_with_patching(k_RInfo, op->info_for_patch());
+klass2reg_with_patching(k_RInfo, op->info_for_patch());
 }
 assert(obj != k_RInfo, "must be different");
 // get object class
 // not a safepoint as obj null check happens earlier
 if (op->should_profile()) {
 Register mdo  = klass_RInfo, recv = k_RInfo, tmp1 = Rtmp1;
 assert_different_registers(obj, mdo, recv, tmp1);
 __ bind(profile_cast_success);
-jobject2reg(md->constant_encoding(), mdo);
+metadata2reg(md->constant_encoding(), mdo);
 if (mdo_offset_bias > 0) {
 __ set(mdo_offset_bias, tmp1);
 __ add(mdo, tmp1, mdo);
 }
 __ load_klass(obj, recv);
 // Jump over the failure case
 __ ba(*success);
 __ delayed()->nop();
 // Cast failure case
 __ bind(profile_cast_failure);
-jobject2reg(md->constant_encoding(), mdo);
+metadata2reg(md->constant_encoding(), mdo);
 if (mdo_offset_bias > 0) {
 __ set(mdo_offset_bias, tmp1);
 __ add(mdo, tmp1, mdo);
 }
 Address data_addr(mdo, md->byte_offset_of_slot(data, CounterData::count_offset()) - mdo_offset_bias);
 if (op->should_profile()) {
 Label not_null;
 __ br_notnull_short(value, Assembler::pn, not_null);
 Register mdo      = k_RInfo;
 Register data_val = Rtmp1;
-jobject2reg(md->constant_encoding(), mdo);
+metadata2reg(md->constant_encoding(), mdo);
 if (mdo_offset_bias > 0) {
 __ set(mdo_offset_bias, data_val);
 __ add(mdo, data_val, mdo);
 }
 Address flags_addr(mdo, md->byte_offset_of_slot(data, DataLayout::flags_offset()) - mdo_offset_bias);
 if (op->should_profile()) {
 Register mdo  = klass_RInfo, recv = k_RInfo, tmp1 = Rtmp1;
 assert_different_registers(value, mdo, recv, tmp1);
 __ bind(profile_cast_success);
-jobject2reg(md->constant_encoding(), mdo);
+metadata2reg(md->constant_encoding(), mdo);
 if (mdo_offset_bias > 0) {
 __ set(mdo_offset_bias, tmp1);
 __ add(mdo, tmp1, mdo);
 }
 __ load_klass(value, recv);
 type_profile_helper(mdo, mdo_offset_bias, md, data, recv, tmp1, &done);
 __ ba_short(done);
 // Cast failure case
 __ bind(profile_cast_failure);
-jobject2reg(md->constant_encoding(), mdo);
+metadata2reg(md->constant_encoding(), mdo);
 if (mdo_offset_bias > 0) {
 __ set(mdo_offset_bias, tmp1);
 __ add(mdo, tmp1, mdo);
 }
 Address data_addr(mdo, md->byte_offset_of_slot(data, CounterData::count_offset()) - mdo_offset_bias);
 Register tmp1 = op->tmp1()->as_register_lo();
 #else
 assert(op->tmp1()->is_single_cpu(), "tmp1 must be allocated");
 Register tmp1 = op->tmp1()->as_register();
 #endif
-jobject2reg(md->constant_encoding(), mdo);
+metadata2reg(md->constant_encoding(), mdo);
 int mdo_offset_bias = 0;
 if (!Assembler::is_simm13(md->byte_offset_of_slot(data, CounterData::count_offset()) +
 data->size_in_bytes())) {
 // The offset is large so bias the mdo by the base of the slot so
 // that the ld can use simm13s to reference the slots of the data
 assert_different_registers(mdo, tmp1, recv);
 assert(data->is_VirtualCallData(), "need VirtualCallData for virtual calls");
 ciKlass* known_klass = op->known_holder();
 if (C1OptimizeVirtualCallProfiling && known_klass != NULL) {
 // We know the type that will be seen at this call site; we can
-// statically update the methodDataOop rather than needing to do
+// statically update the MethodData* rather than needing to do
 // dynamic tests on the receiver type
 // NOTE: we should probably put a lock around this search to
 // avoid collisions by concurrent compilations
 ciVirtualCallData* vc_data = (ciVirtualCallData*) data;
 for (i = 0; i < VirtualCallData::row_limit(); i++) {
 ciKlass* receiver = vc_data->receiver(i);
 if (receiver == NULL) {
 Address recv_addr(mdo, md->byte_offset_of_slot(data, VirtualCallData::receiver_offset(i)) -
 mdo_offset_bias);
-jobject2reg(known_klass->constant_encoding(), tmp1);
+metadata2reg(known_klass->constant_encoding(), tmp1);
 __ st_ptr(tmp1, recv_addr);
 Address data_addr(mdo, md->byte_offset_of_slot(data, VirtualCallData::receiver_count_offset(i)) -
 mdo_offset_bias);
 __ ld_ptr(data_addr, tmp1);
 __ add(tmp1, DataLayout::counter_increment, tmp1);

Mercurial > hg > truffle

comparison src/cpu/sparc/vm/c1_LIRAssembler_sparc.cpp @ 6725:da91efe96a93