graal-compiler: src/share/vm/c1/c1_Runtime1.cpp comparison

comparison src/share/vm/c1/c1_Runtime1.cpp @ 12355:cefad50507d8

Merge with hs25-b53

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Fri, 11 Oct 2013 10:38:03 +0200
parents	6b0fd0964b87 d0cfa6502dfe
children	096c224171c4

comparison

equal deleted inserted replaced

-:ccb4f2af2319
+:cefad50507d8
 Bytecode_field field_access(caller, bci);
 // This can be static or non-static field access
 Bytecodes::Code code       = field_access.code();
 // We must load class, initialize class and resolvethe field
-FieldAccessInfo result; // initialize class if needed
+fieldDescriptor result; // initialize class if needed
 constantPoolHandle constants(THREAD, caller->constants());
-LinkResolver::resolve_field(result, constants, field_access.index(), Bytecodes::java_code(code), false, CHECK_NULL);
+LinkResolver::resolve_field_access(result, constants, field_access.index(), Bytecodes::java_code(code), CHECK_NULL);
-return result.klass()();
+return result.field_holder();
 }
 //
 // This routine patches sites where a class wasn't loaded or
 bool deoptimize_for_volatile = false;
 int patch_field_offset = -1;
 KlassHandle init_klass(THREAD, NULL); // klass needed by load_klass_patching code
 KlassHandle load_klass(THREAD, NULL); // klass needed by load_klass_patching code
 Handle mirror(THREAD, NULL);                    // oop needed by load_mirror_patching code
+Handle appendix(THREAD, NULL);                  // oop needed by appendix_patching code
 bool load_klass_or_mirror_patch_id =
 (stub_id == Runtime1::load_klass_patching_id || stub_id == Runtime1::load_mirror_patching_id);
 if (stub_id == Runtime1::access_field_patching_id) {
 Bytecode_field field_access(caller_method, bci);
-FieldAccessInfo result; // initialize class if needed
+fieldDescriptor result; // initialize class if needed
 Bytecodes::Code code = field_access.code();
 constantPoolHandle constants(THREAD, caller_method->constants());
-LinkResolver::resolve_field(result, constants, field_access.index(), Bytecodes::java_code(code), false, CHECK);
+LinkResolver::resolve_field_access(result, constants, field_access.index(), Bytecodes::java_code(code), CHECK);
-patch_field_offset = result.field_offset();
+patch_field_offset = result.offset();
 // If we're patching a field which is volatile then at compile it
 // must not have been know to be volatile, so the generated code
 // isn't correct for a volatile reference.  The nmethod has to be
 // deoptimized so that the code can be regenerated correctly.
 Bytecode_loadconstant cc(caller_method, bci);
 oop m = cc.resolve_constant(CHECK);
 mirror = Handle(THREAD, m);
 }
 break;
-default: Unimplemented();
+default: fatal("unexpected bytecode for load_klass_or_mirror_patch_id");
 }
 // convert to handle
 load_klass = KlassHandle(THREAD, k);
+} else if (stub_id == load_appendix_patching_id) {
+Bytecode_invoke bytecode(caller_method, bci);
+Bytecodes::Code bc = bytecode.invoke_code();
+CallInfo info;
+constantPoolHandle pool(thread, caller_method->constants());
+int index = bytecode.index();
+LinkResolver::resolve_invoke(info, Handle(), pool, index, bc, CHECK);
+appendix = info.resolved_appendix();
+switch (bc) {
+case Bytecodes::_invokehandle: {
+int cache_index = ConstantPool::decode_cpcache_index(index, true);
+assert(cache_index >= 0 && cache_index < pool->cache()->length(), "unexpected cache index");
+pool->cache()->entry_at(cache_index)->set_method_handle(pool, info);
+break;
+}
+case Bytecodes::_invokedynamic: {
+pool->invokedynamic_cp_cache_entry_at(index)->set_dynamic_call(pool, info);
+break;
+}
+default: fatal("unexpected bytecode for load_appendix_patching_id");
+}
 } else {
 ShouldNotReachHere();
 }
 if (deoptimize_for_volatile) {
 }
 Deoptimization::deoptimize_frame(thread, caller_frame.id(), Deoptimization::Reason_constraint);
 // Return to the now deoptimized frame.
-}
-// If we are patching in a non-perm oop, make sure the nmethod
-// is on the right list.
-if (ScavengeRootsInCode && mirror.not_null() && mirror()->is_scavengable()) {
-MutexLockerEx ml_code (CodeCache_lock, Mutex::_no_safepoint_check_flag);
-nmethod* nm = CodeCache::find_nmethod(caller_frame.pc());
-guarantee(nm != NULL, "only nmethods can contain non-perm oops");
-if (!nm->on_scavenge_root_list())
-CodeCache::add_scavenge_root_nmethod(nm);
 }
 // Now copy code back
 {
 assert(n_copy->data() == 0 ||
 n_copy->data() == (intptr_t)Universe::non_oop_word(),
 "illegal init value");
 if (stub_id == Runtime1::load_klass_patching_id) {
 assert(load_klass() != NULL, "klass not set");
 n_copy->set_data((intx) (load_klass()));
 } else {
 assert(mirror() != NULL, "klass not set");
-n_copy->set_data((intx) (mirror()));
+n_copy->set_data(cast_from_oop<intx>(mirror()));
 }
 if (TracePatching) {
 Disassembler::decode(copy_buff, copy_buff + *byte_count, tty);
 }
+}
-#if defined(SPARC) || defined(PPC)
+} else if (stub_id == Runtime1::load_appendix_patching_id) {
-// Update the location in the nmethod with the proper
+NativeMovConstReg* n_copy = nativeMovConstReg_at(copy_buff);
-// metadata.  When the code was generated, a NULL was stuffed
+assert(n_copy->data() == 0 ||
-// in the metadata table and that table needs to be update to
+n_copy->data() == (intptr_t)Universe::non_oop_word(),
-// have the right value.  On intel the value is kept
+"illegal init value");
-// directly in the instruction instead of in the metadata
+n_copy->set_data(cast_from_oop<intx>(appendix()));
-// table, so set_data above effectively updated the value.
-nmethod* nm = CodeCache::find_nmethod(instr_pc);
+if (TracePatching) {
-assert(nm != NULL, "invalid nmethod_pc");
+Disassembler::decode(copy_buff, copy_buff + *byte_count, tty);
-RelocIterator mds(nm, copy_buff, copy_buff + 1);
-bool found = false;
-while (mds.next() && !found) {
-if (mds.type() == relocInfo::oop_type) {
-assert(stub_id == Runtime1::load_mirror_patching_id, "wrong stub id");
-oop_Relocation* r = mds.oop_reloc();
-oop* oop_adr = r->oop_addr();
-*oop_adr = mirror();
-r->fix_oop_relocation();
-found = true;
-} else if (mds.type() == relocInfo::metadata_type) {
-assert(stub_id == Runtime1::load_klass_patching_id, "wrong stub id");
-metadata_Relocation* r = mds.metadata_reloc();
-Metadata** metadata_adr = r->metadata_addr();
-*metadata_adr = load_klass();
-r->fix_metadata_relocation();
-found = true;
-}
-}
-assert(found, "the metadata must exist!");
-#endif
 }
 } else {
 ShouldNotReachHere();
 }
+#if defined(SPARC) || defined(PPC)
+if (load_klass_or_mirror_patch_id ||
+stub_id == Runtime1::load_appendix_patching_id) {
+// Update the location in the nmethod with the proper
+// metadata.  When the code was generated, a NULL was stuffed
+// in the metadata table and that table needs to be update to
+// have the right value.  On intel the value is kept
+// directly in the instruction instead of in the metadata
+// table, so set_data above effectively updated the value.
+nmethod* nm = CodeCache::find_nmethod(instr_pc);
+assert(nm != NULL, "invalid nmethod_pc");
+RelocIterator mds(nm, copy_buff, copy_buff + 1);
+bool found = false;
+while (mds.next() && !found) {
+if (mds.type() == relocInfo::oop_type) {
+assert(stub_id == Runtime1::load_mirror_patching_id ||
+stub_id == Runtime1::load_appendix_patching_id, "wrong stub id");
+oop_Relocation* r = mds.oop_reloc();
+oop* oop_adr = r->oop_addr();
+*oop_adr = stub_id == Runtime1::load_mirror_patching_id ? mirror() : appendix();
+r->fix_oop_relocation();
+found = true;
+} else if (mds.type() == relocInfo::metadata_type) {
+assert(stub_id == Runtime1::load_klass_patching_id, "wrong stub id");
+metadata_Relocation* r = mds.metadata_reloc();
+Metadata** metadata_adr = r->metadata_addr();
+*metadata_adr = load_klass();
+r->fix_metadata_relocation();
+found = true;
+}
+}
+assert(found, "the metadata must exist!");
+}
+#endif
 if (do_patch) {
 // replace instructions
 // first replace the tail, then the call
 #ifdef ARM
-if(load_klass_or_mirror_patch_id && !VM_Version::supports_movw()) {
+if((load_klass_or_mirror_patch_id ||
+stub_id == Runtime1::load_appendix_patching_id) &&
+!VM_Version::supports_movw()) {
 nmethod* nm = CodeCache::find_nmethod(instr_pc);
 address addr = NULL;
 assert(nm != NULL, "invalid nmethod_pc");
 RelocIterator mds(nm, copy_buff, copy_buff + 1);
 while (mds.next()) {
 if (mds.type() == relocInfo::oop_type) {
-assert(stub_id == Runtime1::load_mirror_patching_id, "wrong stub id");
+assert(stub_id == Runtime1::load_mirror_patching_id ||
+stub_id == Runtime1::load_appendix_patching_id, "wrong stub id");
 oop_Relocation* r = mds.oop_reloc();
 addr = (address)r->oop_addr();
 break;
 } else if (mds.type() == relocInfo::metadata_type) {
 assert(stub_id == Runtime1::load_klass_patching_id, "wrong stub id");
 *(unsigned char*)dst = (unsigned char) a_byte;
 }
 ICache::invalidate_range(instr_pc, *byte_count);
 NativeGeneralJump::replace_mt_safe(instr_pc, copy_buff);
-if (load_klass_or_mirror_patch_id) {
+if (load_klass_or_mirror_patch_id ||
+stub_id == Runtime1::load_appendix_patching_id) {
 relocInfo::relocType rtype =
 (stub_id == Runtime1::load_klass_patching_id) ?
 relocInfo::metadata_type :
 relocInfo::oop_type;
 // update relocInfo to metadata
 NativeGeneralJump::insert_unconditional(instr_pc, being_initialized_entry);
 }
 }
 }
 }
+// If we are patching in a non-perm oop, make sure the nmethod
+// is on the right list.
+if (ScavengeRootsInCode && ((mirror.not_null() && mirror()->is_scavengable()) ||
+(appendix.not_null() && appendix->is_scavengable()))) {
+MutexLockerEx ml_code (CodeCache_lock, Mutex::_no_safepoint_check_flag);
+nmethod* nm = CodeCache::find_nmethod(caller_frame.pc());
+guarantee(nm != NULL, "only nmethods can contain non-perm oops");
+if (!nm->on_scavenge_root_list()) {
+CodeCache::add_scavenge_root_nmethod(nm);
+}
+// Since we've patched some oops in the nmethod,
+// (re)register it with the heap.
+Universe::heap()->register_nmethod(nm);
+}
 JRT_END
 //
 // Entry point for compiled code. We want to patch a nmethod.
 // We don't do a normal VM transition here because we want to
 // Return true if calling code is deoptimized
 return caller_is_deopted();
 }
+int Runtime1::move_appendix_patching(JavaThread* thread) {
+//
+// NOTE: we are still in Java
+//
+Thread* THREAD = thread;
+debug_only(NoHandleMark nhm;)
+{
+// Enter VM mode
+ResetNoHandleMark rnhm;
+patch_code(thread, load_appendix_patching_id);
+}
+// Back in JAVA, use no oops DON'T safepoint
+// Return true if calling code is deoptimized
+return caller_is_deopted();
+}
 //
 // Entry point for compiled code. We want to patch a nmethod.
 // We don't do a normal VM transition here because we want to
 // know after the patching is complete and any safepoint(s) are taken
 // if the calling nmethod was deoptimized. We do this by calling a

Mercurial > hg > graal-compiler

comparison src/share/vm/c1/c1_Runtime1.cpp @ 12355:cefad50507d8