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

comparison src/share/vm/c1/c1_Runtime1.cpp @ 12160:f98f5d48f511

7199175: JSR 292: C1 needs patching when invokedynamic/invokehandle call site is not linked Summary: Do patching rather bailing out for unlinked call with appendix Reviewed-by: twisti, kvn

author	roland
date	Wed, 21 Aug 2013 13:34:45 +0200
parents	5888334c9c24
children	b2e698d2276c d68894a09c7c

comparison

equal deleted inserted replaced

-:b17d8f6d9ed7
+:f98f5d48f511
 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_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) {
 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()));
 }
 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((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()) {
 *(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
 }
 }
 // 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()) {
+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);
 // 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-jvmci-8

comparison src/share/vm/c1/c1_Runtime1.cpp @ 12160:f98f5d48f511