truffle: src/share/vm/code/compiledIC.cpp annotate

annotate src/share/vm/code/compiledIC.cpp @ 13441:df832bd8edb9

8028107: Kitchensink crashed with EAV Summary: check the state of caller and callee nmethods and skip call site patching if any of them is not alive Reviewed-by: jrose, twisti

author	kvn
date	Fri, 06 Dec 2013 12:11:51 -0800
parents	891687731b59
children	02f27ecb4f3a 78bbf4d43a14

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 0 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 0 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 0 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1579 diff changeset	25 #include "precompiled.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1579 diff changeset	26 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1579 diff changeset	27 #include "code/codeCache.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1579 diff changeset	28 #include "code/compiledIC.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1579 diff changeset	29 #include "code/icBuffer.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1579 diff changeset	30 #include "code/nmethod.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1579 diff changeset	31 #include "code/vtableStubs.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1579 diff changeset	32 #include "interpreter/interpreter.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1579 diff changeset	33 #include "interpreter/linkResolver.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	34 #include "memory/metadataFactory.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1579 diff changeset	35 #include "memory/oopFactory.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	36 #include "oops/method.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1579 diff changeset	37 #include "oops/oop.inline.hpp"
2177 3582bf76420e 6990754: Use native memory and reference counting to implement SymbolTable coleenp parents: 1972 diff changeset	38 #include "oops/symbol.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1579 diff changeset	39 #include "runtime/icache.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1579 diff changeset	40 #include "runtime/sharedRuntime.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1579 diff changeset	41 #include "runtime/stubRoutines.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1579 diff changeset	42 #include "utilities/events.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	43
a61af66fc99e Initial load duke parents: diff changeset	44
a61af66fc99e Initial load duke parents: diff changeset	45 // Every time a compiled IC is changed or its type is being accessed,
a61af66fc99e Initial load duke parents: diff changeset	46 // either the CompiledIC_lock must be set or we must be at a safe point.
a61af66fc99e Initial load duke parents: diff changeset	47
a61af66fc99e Initial load duke parents: diff changeset	48 //-----------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	49 // Low-level access to an inline cache. Private, since they might not be
a61af66fc99e Initial load duke parents: diff changeset	50 // MT-safe to use.
a61af66fc99e Initial load duke parents: diff changeset	51
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	52 void* CompiledIC::cached_value() const {
0 a61af66fc99e Initial load duke parents: diff changeset	53 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	54 assert (!is_optimized(), "an optimized virtual call does not have a cached metadata");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	55
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	56 if (!is_in_transition_state()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	57 void* data = (void*)_value->data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	58 // If we let the metadata value here be initialized to zero...
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	59 assert(data != NULL \|\| Universe::non_oop_word() == NULL,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	60 "no raw nulls in CompiledIC metadatas, because of patching races");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	61 return (data == (void*)Universe::non_oop_word()) ? NULL : data;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	62 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	63 return InlineCacheBuffer::cached_value_for((CompiledIC *)this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	64 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	65 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	66
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	67
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	68 void CompiledIC::internal_set_ic_destination(address entry_point, bool is_icstub, void* cache, bool is_icholder) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	69 assert(entry_point != NULL, "must set legal entry point");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	70 assert(CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	71 assert (!is_optimized() \|\| cache == NULL, "an optimized virtual call does not have a cached metadata");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	72 assert (cache == NULL \|\| cache != (Metadata*)badOopVal, "invalid metadata");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	73
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	74 assert(!is_icholder \|\| is_icholder_entry(entry_point), "must be");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	75
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	76 // Don't use ic_destination for this test since that forwards
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	77 // through ICBuffer instead of returning the actual current state of
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	78 // the CompiledIC.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	79 if (is_icholder_entry(_ic_call->destination())) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	80 // When patching for the ICStub case the cached value isn't
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	81 // overwritten until the ICStub copied into the CompiledIC during
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	82 // the next safepoint. Make sure that the CompiledICHolder* is
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	83 // marked for release at this point since it won't be identifiable
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	84 // once the entry point is overwritten.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	85 InlineCacheBuffer::queue_for_release((CompiledICHolder*)_value->data());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	86 }
0 a61af66fc99e Initial load duke parents: diff changeset	87
a61af66fc99e Initial load duke parents: diff changeset	88 if (TraceCompiledIC) {
a61af66fc99e Initial load duke parents: diff changeset	89 tty->print(" ");
a61af66fc99e Initial load duke parents: diff changeset	90 print_compiled_ic();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	91 tty->print(" changing destination to " INTPTR_FORMAT, entry_point);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	92 if (!is_optimized()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	93 tty->print(" changing cached %s to " INTPTR_FORMAT, is_icholder ? "icholder" : "metadata", (address)cache);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	94 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	95 if (is_icstub) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	96 tty->print(" (icstub)");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	97 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	98 tty->cr();
0 a61af66fc99e Initial load duke parents: diff changeset	99 }
a61af66fc99e Initial load duke parents: diff changeset	100
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	101 {
0 a61af66fc99e Initial load duke parents: diff changeset	102 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	103 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	104 CodeBlob* cb = CodeCache::find_blob_unsafe(_ic_call);
a61af66fc99e Initial load duke parents: diff changeset	105 assert(cb != NULL && cb->is_nmethod(), "must be nmethod");
a61af66fc99e Initial load duke parents: diff changeset	106 #endif
a61af66fc99e Initial load duke parents: diff changeset	107 _ic_call->set_destination_mt_safe(entry_point);
a61af66fc99e Initial load duke parents: diff changeset	108 }
a61af66fc99e Initial load duke parents: diff changeset	109
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	110 if (is_optimized() \|\| is_icstub) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	111 // Optimized call sites don't have a cache value and ICStub call
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	112 // sites only change the entry point. Changing the value in that
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	113 // case could lead to MT safety issues.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	114 assert(cache == NULL, "must be null");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	115 return;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	116 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	117
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	118 if (cache == NULL) cache = (void*)Universe::non_oop_word();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	119
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	120 _value->set_data((intptr_t)cache);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	121 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	122
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	123
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	124 void CompiledIC::set_ic_destination(ICStub* stub) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	125 internal_set_ic_destination(stub->code_begin(), true, NULL, false);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	126 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	127
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	128
0 a61af66fc99e Initial load duke parents: diff changeset	129
a61af66fc99e Initial load duke parents: diff changeset	130 address CompiledIC::ic_destination() const {
a61af66fc99e Initial load duke parents: diff changeset	131 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	132 if (!is_in_transition_state()) {
a61af66fc99e Initial load duke parents: diff changeset	133 return _ic_call->destination();
a61af66fc99e Initial load duke parents: diff changeset	134 } else {
a61af66fc99e Initial load duke parents: diff changeset	135 return InlineCacheBuffer::ic_destination_for((CompiledIC *)this);
a61af66fc99e Initial load duke parents: diff changeset	136 }
a61af66fc99e Initial load duke parents: diff changeset	137 }
a61af66fc99e Initial load duke parents: diff changeset	138
a61af66fc99e Initial load duke parents: diff changeset	139
a61af66fc99e Initial load duke parents: diff changeset	140 bool CompiledIC::is_in_transition_state() const {
a61af66fc99e Initial load duke parents: diff changeset	141 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	142 return InlineCacheBuffer::contains(_ic_call->destination());
a61af66fc99e Initial load duke parents: diff changeset	143 }
a61af66fc99e Initial load duke parents: diff changeset	144
a61af66fc99e Initial load duke parents: diff changeset	145
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	146 bool CompiledIC::is_icholder_call() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	147 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	148 return !_is_optimized && is_icholder_entry(ic_destination());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	149 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	150
0 a61af66fc99e Initial load duke parents: diff changeset	151 // Returns native address of 'call' instruction in inline-cache. Used by
a61af66fc99e Initial load duke parents: diff changeset	152 // the InlineCacheBuffer when it needs to find the stub.
a61af66fc99e Initial load duke parents: diff changeset	153 address CompiledIC::stub_address() const {
a61af66fc99e Initial load duke parents: diff changeset	154 assert(is_in_transition_state(), "should only be called when we are in a transition state");
a61af66fc99e Initial load duke parents: diff changeset	155 return _ic_call->destination();
a61af66fc99e Initial load duke parents: diff changeset	156 }
a61af66fc99e Initial load duke parents: diff changeset	157
a61af66fc99e Initial load duke parents: diff changeset	158
a61af66fc99e Initial load duke parents: diff changeset	159 //-----------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	160 // High-level access to an inline cache. Guaranteed to be MT-safe.
a61af66fc99e Initial load duke parents: diff changeset	161
a61af66fc99e Initial load duke parents: diff changeset	162
12294 891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 12264 diff changeset	163 bool CompiledIC::set_to_megamorphic(CallInfo* call_info, Bytecodes::Code bytecode, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	164 assert(CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	165 assert(!is_optimized(), "cannot set an optimized virtual call to megamorphic");
a61af66fc99e Initial load duke parents: diff changeset	166 assert(is_call_to_compiled() \|\| is_call_to_interpreted(), "going directly to megamorphic?");
a61af66fc99e Initial load duke parents: diff changeset	167
a61af66fc99e Initial load duke parents: diff changeset	168 address entry;
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	169 if (call_info->call_kind() == CallInfo::itable_call) {
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	170 assert(bytecode == Bytecodes::_invokeinterface, "");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	171 int itable_index = call_info->itable_index();
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	172 entry = VtableStubs::find_itable_stub(itable_index);
12294 891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 12264 diff changeset	173 if (entry == false) {
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 12264 diff changeset	174 return false;
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 12264 diff changeset	175 }
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	176 #ifdef ASSERT
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	177 int index = call_info->resolved_method()->itable_index();
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	178 assert(index == itable_index, "CallInfo pre-computes this");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	179 #endif //ASSERT
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6725 diff changeset	180 InstanceKlass* k = call_info->resolved_method()->method_holder();
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	181 assert(k->verify_itable_index(itable_index), "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	182 InlineCacheBuffer::create_transition_stub(this, k, entry);
a61af66fc99e Initial load duke parents: diff changeset	183 } else {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	184 assert(call_info->call_kind() == CallInfo::vtable_call, "either itable or vtable");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	185 // Can be different than selected_method->vtable_index(), due to package-private etc.
0 a61af66fc99e Initial load duke parents: diff changeset	186 int vtable_index = call_info->vtable_index();
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	187 assert(call_info->resolved_klass()->verify_vtable_index(vtable_index), "sanity check");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	188 entry = VtableStubs::find_vtable_stub(vtable_index);
12294 891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 12264 diff changeset	189 if (entry == NULL) {
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 12264 diff changeset	190 return false;
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 12264 diff changeset	191 }
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	192 InlineCacheBuffer::create_transition_stub(this, NULL, entry);
0 a61af66fc99e Initial load duke parents: diff changeset	193 }
a61af66fc99e Initial load duke parents: diff changeset	194
a61af66fc99e Initial load duke parents: diff changeset	195 if (TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	196 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	197 tty->print_cr ("IC@" INTPTR_FORMAT ": to megamorphic %s entry: " INTPTR_FORMAT,
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	198 instruction_address(), call_info->selected_method()->print_value_string(), entry);
0 a61af66fc99e Initial load duke parents: diff changeset	199 }
a61af66fc99e Initial load duke parents: diff changeset	200
a61af66fc99e Initial load duke parents: diff changeset	201 // We can't check this anymore. With lazy deopt we could have already
a61af66fc99e Initial load duke parents: diff changeset	202 // cleaned this IC entry before we even return. This is possible if
a61af66fc99e Initial load duke parents: diff changeset	203 // we ran out of space in the inline cache buffer trying to do the
a61af66fc99e Initial load duke parents: diff changeset	204 // set_next and we safepointed to free up space. This is a benign
a61af66fc99e Initial load duke parents: diff changeset	205 // race because the IC entry was complete when we safepointed so
a61af66fc99e Initial load duke parents: diff changeset	206 // cleaning it immediately is harmless.
a61af66fc99e Initial load duke parents: diff changeset	207 // assert(is_megamorphic(), "sanity check");
12294 891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 12264 diff changeset	208 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	209 }
a61af66fc99e Initial load duke parents: diff changeset	210
a61af66fc99e Initial load duke parents: diff changeset	211
a61af66fc99e Initial load duke parents: diff changeset	212 // true if destination is megamorphic stub
a61af66fc99e Initial load duke parents: diff changeset	213 bool CompiledIC::is_megamorphic() const {
a61af66fc99e Initial load duke parents: diff changeset	214 assert(CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	215 assert(!is_optimized(), "an optimized call cannot be megamorphic");
a61af66fc99e Initial load duke parents: diff changeset	216
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	217 // Cannot rely on cached_value. It is either an interface or a method.
0 a61af66fc99e Initial load duke parents: diff changeset	218 return VtableStubs::is_entry_point(ic_destination());
a61af66fc99e Initial load duke parents: diff changeset	219 }
a61af66fc99e Initial load duke parents: diff changeset	220
a61af66fc99e Initial load duke parents: diff changeset	221 bool CompiledIC::is_call_to_compiled() const {
a61af66fc99e Initial load duke parents: diff changeset	222 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	223
a61af66fc99e Initial load duke parents: diff changeset	224 // Use unsafe, since an inline cache might point to a zombie method. However, the zombie
a61af66fc99e Initial load duke parents: diff changeset	225 // method is guaranteed to still exist, since we only remove methods after all inline caches
a61af66fc99e Initial load duke parents: diff changeset	226 // has been cleaned up
a61af66fc99e Initial load duke parents: diff changeset	227 CodeBlob* cb = CodeCache::find_blob_unsafe(ic_destination());
a61af66fc99e Initial load duke parents: diff changeset	228 bool is_monomorphic = (cb != NULL && cb->is_nmethod());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	229 // Check that the cached_value is a klass for non-optimized monomorphic calls
0 a61af66fc99e Initial load duke parents: diff changeset	230 // This assertion is invalid for compiler1: a call that does not look optimized (no static stub) can be used
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	231 // for calling directly to vep without using the inline cache (i.e., cached_value == NULL)
0 a61af66fc99e Initial load duke parents: diff changeset	232 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	233 CodeBlob* caller = CodeCache::find_blob_unsafe(instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	234 bool is_c1_method = caller->is_compiled_by_c1();
a61af66fc99e Initial load duke parents: diff changeset	235 assert( is_c1_method \|\|
a61af66fc99e Initial load duke parents: diff changeset	236 !is_monomorphic \|\|
a61af66fc99e Initial load duke parents: diff changeset	237 is_optimized() \|\|
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	238 (cached_metadata() != NULL && cached_metadata()->is_klass()), "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	239 #endif // ASSERT
a61af66fc99e Initial load duke parents: diff changeset	240 return is_monomorphic;
a61af66fc99e Initial load duke parents: diff changeset	241 }
a61af66fc99e Initial load duke parents: diff changeset	242
a61af66fc99e Initial load duke parents: diff changeset	243
a61af66fc99e Initial load duke parents: diff changeset	244 bool CompiledIC::is_call_to_interpreted() const {
a61af66fc99e Initial load duke parents: diff changeset	245 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	246 // Call to interpreter if destination is either calling to a stub (if it
a61af66fc99e Initial load duke parents: diff changeset	247 // is optimized), or calling to an I2C blob
a61af66fc99e Initial load duke parents: diff changeset	248 bool is_call_to_interpreted = false;
a61af66fc99e Initial load duke parents: diff changeset	249 if (!is_optimized()) {
a61af66fc99e Initial load duke parents: diff changeset	250 // must use unsafe because the destination can be a zombie (and we're cleaning)
a61af66fc99e Initial load duke parents: diff changeset	251 // and the print_compiled_ic code wants to know if site (in the non-zombie)
a61af66fc99e Initial load duke parents: diff changeset	252 // is to the interpreter.
a61af66fc99e Initial load duke parents: diff changeset	253 CodeBlob* cb = CodeCache::find_blob_unsafe(ic_destination());
a61af66fc99e Initial load duke parents: diff changeset	254 is_call_to_interpreted = (cb != NULL && cb->is_adapter_blob());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	255 assert(!is_call_to_interpreted \|\| (is_icholder_call() && cached_icholder() != NULL), "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	256 } else {
a61af66fc99e Initial load duke parents: diff changeset	257 // Check if we are calling into our own codeblob (i.e., to a stub)
a61af66fc99e Initial load duke parents: diff changeset	258 CodeBlob* cb = CodeCache::find_blob(_ic_call->instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	259 address dest = ic_destination();
a61af66fc99e Initial load duke parents: diff changeset	260 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	261 {
a61af66fc99e Initial load duke parents: diff changeset	262 CodeBlob* db = CodeCache::find_blob_unsafe(dest);
a61af66fc99e Initial load duke parents: diff changeset	263 assert(!db->is_adapter_blob(), "must use stub!");
a61af66fc99e Initial load duke parents: diff changeset	264 }
a61af66fc99e Initial load duke parents: diff changeset	265 #endif /* ASSERT */
a61af66fc99e Initial load duke parents: diff changeset	266 is_call_to_interpreted = cb->contains(dest);
a61af66fc99e Initial load duke parents: diff changeset	267 }
a61af66fc99e Initial load duke parents: diff changeset	268 return is_call_to_interpreted;
a61af66fc99e Initial load duke parents: diff changeset	269 }
a61af66fc99e Initial load duke parents: diff changeset	270
a61af66fc99e Initial load duke parents: diff changeset	271
a61af66fc99e Initial load duke parents: diff changeset	272 void CompiledIC::set_to_clean() {
a61af66fc99e Initial load duke parents: diff changeset	273 assert(SafepointSynchronize::is_at_safepoint() \|\| CompiledIC_lock->is_locked() , "MT-unsafe call");
a61af66fc99e Initial load duke parents: diff changeset	274 if (TraceInlineCacheClearing \|\| TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	275 tty->print_cr("IC@" INTPTR_FORMAT ": set to clean", instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	276 print();
a61af66fc99e Initial load duke parents: diff changeset	277 }
a61af66fc99e Initial load duke parents: diff changeset	278
a61af66fc99e Initial load duke parents: diff changeset	279 address entry;
a61af66fc99e Initial load duke parents: diff changeset	280 if (is_optimized()) {
a61af66fc99e Initial load duke parents: diff changeset	281 entry = SharedRuntime::get_resolve_opt_virtual_call_stub();
a61af66fc99e Initial load duke parents: diff changeset	282 } else {
a61af66fc99e Initial load duke parents: diff changeset	283 entry = SharedRuntime::get_resolve_virtual_call_stub();
a61af66fc99e Initial load duke parents: diff changeset	284 }
a61af66fc99e Initial load duke parents: diff changeset	285
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	286 // A zombie transition will always be safe, since the metadata has already been set to NULL, so
0 a61af66fc99e Initial load duke parents: diff changeset	287 // we only need to patch the destination
a61af66fc99e Initial load duke parents: diff changeset	288 bool safe_transition = is_optimized() \|\| SafepointSynchronize::is_at_safepoint();
a61af66fc99e Initial load duke parents: diff changeset	289
a61af66fc99e Initial load duke parents: diff changeset	290 if (safe_transition) {
a61af66fc99e Initial load duke parents: diff changeset	291 // Kill any leftover stub we might have too
a61af66fc99e Initial load duke parents: diff changeset	292 if (is_in_transition_state()) {
a61af66fc99e Initial load duke parents: diff changeset	293 ICStub* old_stub = ICStub_from_destination_address(stub_address());
a61af66fc99e Initial load duke parents: diff changeset	294 old_stub->clear();
a61af66fc99e Initial load duke parents: diff changeset	295 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	296 if (is_optimized()) {
0 a61af66fc99e Initial load duke parents: diff changeset	297 set_ic_destination(entry);
a61af66fc99e Initial load duke parents: diff changeset	298 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	299 set_ic_destination_and_value(entry, (void*)NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	300 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	301 } else {
0 a61af66fc99e Initial load duke parents: diff changeset	302 // Unsafe transition - create stub.
a61af66fc99e Initial load duke parents: diff changeset	303 InlineCacheBuffer::create_transition_stub(this, NULL, entry);
a61af66fc99e Initial load duke parents: diff changeset	304 }
a61af66fc99e Initial load duke parents: diff changeset	305 // We can't check this anymore. With lazy deopt we could have already
a61af66fc99e Initial load duke parents: diff changeset	306 // cleaned this IC entry before we even return. This is possible if
a61af66fc99e Initial load duke parents: diff changeset	307 // we ran out of space in the inline cache buffer trying to do the
a61af66fc99e Initial load duke parents: diff changeset	308 // set_next and we safepointed to free up space. This is a benign
a61af66fc99e Initial load duke parents: diff changeset	309 // race because the IC entry was complete when we safepointed so
a61af66fc99e Initial load duke parents: diff changeset	310 // cleaning it immediately is harmless.
a61af66fc99e Initial load duke parents: diff changeset	311 // assert(is_clean(), "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	312 }
a61af66fc99e Initial load duke parents: diff changeset	313
a61af66fc99e Initial load duke parents: diff changeset	314
a61af66fc99e Initial load duke parents: diff changeset	315 bool CompiledIC::is_clean() const {
a61af66fc99e Initial load duke parents: diff changeset	316 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	317 bool is_clean = false;
a61af66fc99e Initial load duke parents: diff changeset	318 address dest = ic_destination();
a61af66fc99e Initial load duke parents: diff changeset	319 is_clean = dest == SharedRuntime::get_resolve_opt_virtual_call_stub() \|\|
a61af66fc99e Initial load duke parents: diff changeset	320 dest == SharedRuntime::get_resolve_virtual_call_stub();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	321 assert(!is_clean \|\| is_optimized() \|\| cached_value() == NULL, "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	322 return is_clean;
a61af66fc99e Initial load duke parents: diff changeset	323 }
a61af66fc99e Initial load duke parents: diff changeset	324
a61af66fc99e Initial load duke parents: diff changeset	325
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	326 void CompiledIC::set_to_monomorphic(CompiledICInfo& info) {
0 a61af66fc99e Initial load duke parents: diff changeset	327 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	328 // Updating a cache to the wrong entry can cause bugs that are very hard
a61af66fc99e Initial load duke parents: diff changeset	329 // to track down - if cache entry gets invalid - we just clean it. In
a61af66fc99e Initial load duke parents: diff changeset	330 // this way it is always the same code path that is responsible for
a61af66fc99e Initial load duke parents: diff changeset	331 // updating and resolving an inline cache
a61af66fc99e Initial load duke parents: diff changeset	332 //
a61af66fc99e Initial load duke parents: diff changeset	333 // The above is no longer true. SharedRuntime::fixup_callers_callsite will change optimized
a61af66fc99e Initial load duke parents: diff changeset	334 // callsites. In addition ic_miss code will update a site to monomorphic if it determines
a61af66fc99e Initial load duke parents: diff changeset	335 // that an monomorphic call to the interpreter can now be monomorphic to compiled code.
a61af66fc99e Initial load duke parents: diff changeset	336 //
a61af66fc99e Initial load duke parents: diff changeset	337 // In both of these cases the only thing being modifed is the jump/call target and these
a61af66fc99e Initial load duke parents: diff changeset	338 // transitions are mt_safe
a61af66fc99e Initial load duke parents: diff changeset	339
a61af66fc99e Initial load duke parents: diff changeset	340 Thread *thread = Thread::current();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	341 if (info.to_interpreter()) {
0 a61af66fc99e Initial load duke parents: diff changeset	342 // Call to interpreter
a61af66fc99e Initial load duke parents: diff changeset	343 if (info.is_optimized() && is_optimized()) {
a61af66fc99e Initial load duke parents: diff changeset	344 assert(is_clean(), "unsafe IC path");
a61af66fc99e Initial load duke parents: diff changeset	345 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	346 // the call analysis (callee structure) specifies that the call is optimized
a61af66fc99e Initial load duke parents: diff changeset	347 // (either because of CHA or the static target is final)
a61af66fc99e Initial load duke parents: diff changeset	348 // At code generation time, this call has been emitted as static call
a61af66fc99e Initial load duke parents: diff changeset	349 // Call via stub
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	350 assert(info.cached_metadata() != NULL && info.cached_metadata()->is_method(), "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	351 CompiledStaticCall* csc = compiledStaticCall_at(instruction_address());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	352 methodHandle method (thread, (Method*)info.cached_metadata());
0 a61af66fc99e Initial load duke parents: diff changeset	353 csc->set_to_interpreted(method, info.entry());
a61af66fc99e Initial load duke parents: diff changeset	354 if (TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	355 ResourceMark rm(thread);
a61af66fc99e Initial load duke parents: diff changeset	356 tty->print_cr ("IC@" INTPTR_FORMAT ": monomorphic to interpreter: %s",
a61af66fc99e Initial load duke parents: diff changeset	357 instruction_address(),
a61af66fc99e Initial load duke parents: diff changeset	358 method->print_value_string());
a61af66fc99e Initial load duke parents: diff changeset	359 }
a61af66fc99e Initial load duke parents: diff changeset	360 } else {
a61af66fc99e Initial load duke parents: diff changeset	361 // Call via method-klass-holder
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	362 InlineCacheBuffer::create_transition_stub(this, info.claim_cached_icholder(), info.entry());
0 a61af66fc99e Initial load duke parents: diff changeset	363 if (TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	364 ResourceMark rm(thread);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	365 tty->print_cr ("IC@" INTPTR_FORMAT ": monomorphic to interpreter via icholder ", instruction_address());
0 a61af66fc99e Initial load duke parents: diff changeset	366 }
a61af66fc99e Initial load duke parents: diff changeset	367 }
a61af66fc99e Initial load duke parents: diff changeset	368 } else {
a61af66fc99e Initial load duke parents: diff changeset	369 // Call to compiled code
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	370 bool static_bound = info.is_optimized() \|\| (info.cached_metadata() == NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	371 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	372 CodeBlob* cb = CodeCache::find_blob_unsafe(info.entry());
a61af66fc99e Initial load duke parents: diff changeset	373 assert (cb->is_nmethod(), "must be compiled!");
a61af66fc99e Initial load duke parents: diff changeset	374 #endif /* ASSERT */
a61af66fc99e Initial load duke parents: diff changeset	375
a61af66fc99e Initial load duke parents: diff changeset	376 // This is MT safe if we come from a clean-cache and go through a
a61af66fc99e Initial load duke parents: diff changeset	377 // non-verified entry point
a61af66fc99e Initial load duke parents: diff changeset	378 bool safe = SafepointSynchronize::is_at_safepoint() \|\|
a61af66fc99e Initial load duke parents: diff changeset	379 (!is_in_transition_state() && (info.is_optimized() \|\| static_bound \|\| is_clean()));
a61af66fc99e Initial load duke parents: diff changeset	380
a61af66fc99e Initial load duke parents: diff changeset	381 if (!safe) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	382 InlineCacheBuffer::create_transition_stub(this, info.cached_metadata(), info.entry());
0 a61af66fc99e Initial load duke parents: diff changeset	383 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	384 if (is_optimized()) {
0 a61af66fc99e Initial load duke parents: diff changeset	385 set_ic_destination(info.entry());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	386 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	387 set_ic_destination_and_value(info.entry(), info.cached_metadata());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	388 }
0 a61af66fc99e Initial load duke parents: diff changeset	389 }
a61af66fc99e Initial load duke parents: diff changeset	390
a61af66fc99e Initial load duke parents: diff changeset	391 if (TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	392 ResourceMark rm(thread);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	393 assert(info.cached_metadata() == NULL \|\| info.cached_metadata()->is_klass(), "must be");
0 a61af66fc99e Initial load duke parents: diff changeset	394 tty->print_cr ("IC@" INTPTR_FORMAT ": monomorphic to compiled (rcvr klass) %s: %s",
a61af66fc99e Initial load duke parents: diff changeset	395 instruction_address(),
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	396 ((Klass*)info.cached_metadata())->print_value_string(),
0 a61af66fc99e Initial load duke parents: diff changeset	397 (safe) ? "" : "via stub");
a61af66fc99e Initial load duke parents: diff changeset	398 }
a61af66fc99e Initial load duke parents: diff changeset	399 }
a61af66fc99e Initial load duke parents: diff changeset	400 // We can't check this anymore. With lazy deopt we could have already
a61af66fc99e Initial load duke parents: diff changeset	401 // cleaned this IC entry before we even return. This is possible if
a61af66fc99e Initial load duke parents: diff changeset	402 // we ran out of space in the inline cache buffer trying to do the
a61af66fc99e Initial load duke parents: diff changeset	403 // set_next and we safepointed to free up space. This is a benign
a61af66fc99e Initial load duke parents: diff changeset	404 // race because the IC entry was complete when we safepointed so
a61af66fc99e Initial load duke parents: diff changeset	405 // cleaning it immediately is harmless.
a61af66fc99e Initial load duke parents: diff changeset	406 // assert(is_call_to_compiled() \|\| is_call_to_interpreted(), "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	407 }
a61af66fc99e Initial load duke parents: diff changeset	408
a61af66fc99e Initial load duke parents: diff changeset	409
a61af66fc99e Initial load duke parents: diff changeset	410 // is_optimized: Compiler has generated an optimized call (i.e., no inline
a61af66fc99e Initial load duke parents: diff changeset	411 // cache) static_bound: The call can be static bound (i.e, no need to use
a61af66fc99e Initial load duke parents: diff changeset	412 // inline cache)
a61af66fc99e Initial load duke parents: diff changeset	413 void CompiledIC::compute_monomorphic_entry(methodHandle method,
a61af66fc99e Initial load duke parents: diff changeset	414 KlassHandle receiver_klass,
a61af66fc99e Initial load duke parents: diff changeset	415 bool is_optimized,
a61af66fc99e Initial load duke parents: diff changeset	416 bool static_bound,
a61af66fc99e Initial load duke parents: diff changeset	417 CompiledICInfo& info,
a61af66fc99e Initial load duke parents: diff changeset	418 TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	419 nmethod* method_code = method->code();
a61af66fc99e Initial load duke parents: diff changeset	420 address entry = NULL;
13441 df832bd8edb9 8028107: Kitchensink crashed with EAV kvn parents: 12294 diff changeset	421 if (method_code != NULL && method_code->is_in_use()) {
0 a61af66fc99e Initial load duke parents: diff changeset	422 // Call to compiled code
a61af66fc99e Initial load duke parents: diff changeset	423 if (static_bound \|\| is_optimized) {
a61af66fc99e Initial load duke parents: diff changeset	424 entry = method_code->verified_entry_point();
a61af66fc99e Initial load duke parents: diff changeset	425 } else {
a61af66fc99e Initial load duke parents: diff changeset	426 entry = method_code->entry_point();
a61af66fc99e Initial load duke parents: diff changeset	427 }
a61af66fc99e Initial load duke parents: diff changeset	428 }
a61af66fc99e Initial load duke parents: diff changeset	429 if (entry != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	430 // Call to compiled code
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	431 info.set_compiled_entry(entry, (static_bound \|\| is_optimized) ? NULL : receiver_klass(), is_optimized);
0 a61af66fc99e Initial load duke parents: diff changeset	432 } else {
a61af66fc99e Initial load duke parents: diff changeset	433 // Note: the following problem exists with Compiler1:
a61af66fc99e Initial load duke parents: diff changeset	434 // - at compile time we may or may not know if the destination is final
a61af66fc99e Initial load duke parents: diff changeset	435 // - if we know that the destination is final, we will emit an optimized
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	436 // virtual call (no inline cache), and need a Method* to make a call
0 a61af66fc99e Initial load duke parents: diff changeset	437 // to the interpreter
a61af66fc99e Initial load duke parents: diff changeset	438 // - if we do not know if the destination is final, we emit a standard
a61af66fc99e Initial load duke parents: diff changeset	439 // virtual call, and use CompiledICHolder to call interpreted code
a61af66fc99e Initial load duke parents: diff changeset	440 // (no static call stub has been generated)
a61af66fc99e Initial load duke parents: diff changeset	441 // However in that case we will now notice it is static_bound
a61af66fc99e Initial load duke parents: diff changeset	442 // and convert the call into what looks to be an optimized
a61af66fc99e Initial load duke parents: diff changeset	443 // virtual call. This causes problems in verifying the IC because
a61af66fc99e Initial load duke parents: diff changeset	444 // it look vanilla but is optimized. Code in is_call_to_interpreted
a61af66fc99e Initial load duke parents: diff changeset	445 // is aware of this and weakens its asserts.
a61af66fc99e Initial load duke parents: diff changeset	446
a61af66fc99e Initial load duke parents: diff changeset	447 // static_bound should imply is_optimized -- otherwise we have a
a61af66fc99e Initial load duke parents: diff changeset	448 // performance bug (statically-bindable method is called via
a61af66fc99e Initial load duke parents: diff changeset	449 // dynamically-dispatched call note: the reverse implication isn't
a61af66fc99e Initial load duke parents: diff changeset	450 // necessarily true -- the call may have been optimized based on compiler
a61af66fc99e Initial load duke parents: diff changeset	451 // analysis (static_bound is only based on "final" etc.)
a61af66fc99e Initial load duke parents: diff changeset	452 #ifdef COMPILER2
a61af66fc99e Initial load duke parents: diff changeset	453 #ifdef TIERED
a61af66fc99e Initial load duke parents: diff changeset	454 #if defined(ASSERT)
a61af66fc99e Initial load duke parents: diff changeset	455 // can't check the assert because we don't have the CompiledIC with which to
a61af66fc99e Initial load duke parents: diff changeset	456 // find the address if the call instruction.
a61af66fc99e Initial load duke parents: diff changeset	457 //
a61af66fc99e Initial load duke parents: diff changeset	458 // CodeBlob* cb = find_blob_unsafe(instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	459 // assert(cb->is_compiled_by_c1() \|\| !static_bound \|\| is_optimized, "static_bound should imply is_optimized");
a61af66fc99e Initial load duke parents: diff changeset	460 #endif // ASSERT
a61af66fc99e Initial load duke parents: diff changeset	461 #else
a61af66fc99e Initial load duke parents: diff changeset	462 assert(!static_bound \|\| is_optimized, "static_bound should imply is_optimized");
a61af66fc99e Initial load duke parents: diff changeset	463 #endif // TIERED
a61af66fc99e Initial load duke parents: diff changeset	464 #endif // COMPILER2
a61af66fc99e Initial load duke parents: diff changeset	465 if (is_optimized) {
a61af66fc99e Initial load duke parents: diff changeset	466 // Use stub entry
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	467 info.set_interpreter_entry(method()->get_c2i_entry(), method());
0 a61af66fc99e Initial load duke parents: diff changeset	468 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	469 // Use icholder entry
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	470 CompiledICHolder* holder = new CompiledICHolder(method(), receiver_klass());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	471 info.set_icholder_entry(method()->get_c2i_unverified_entry(), holder);
0 a61af66fc99e Initial load duke parents: diff changeset	472 }
a61af66fc99e Initial load duke parents: diff changeset	473 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	474 assert(info.is_optimized() == is_optimized, "must agree");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	475 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	476
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	477
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	478 bool CompiledIC::is_icholder_entry(address entry) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	479 CodeBlob* cb = CodeCache::find_blob_unsafe(entry);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	480 return (cb != NULL && cb->is_adapter_blob());
0 a61af66fc99e Initial load duke parents: diff changeset	481 }
a61af66fc99e Initial load duke parents: diff changeset	482
a61af66fc99e Initial load duke parents: diff changeset	483 // ----------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	484
a61af66fc99e Initial load duke parents: diff changeset	485 void CompiledStaticCall::set_to_clean() {
a61af66fc99e Initial load duke parents: diff changeset	486 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "mt unsafe call");
a61af66fc99e Initial load duke parents: diff changeset	487 // Reset call site
a61af66fc99e Initial load duke parents: diff changeset	488 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	489 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	490 CodeBlob* cb = CodeCache::find_blob_unsafe(this);
a61af66fc99e Initial load duke parents: diff changeset	491 assert(cb != NULL && cb->is_nmethod(), "must be nmethod");
a61af66fc99e Initial load duke parents: diff changeset	492 #endif
a61af66fc99e Initial load duke parents: diff changeset	493 set_destination_mt_safe(SharedRuntime::get_resolve_static_call_stub());
a61af66fc99e Initial load duke parents: diff changeset	494
a61af66fc99e Initial load duke parents: diff changeset	495 // Do not reset stub here: It is too expensive to call find_stub.
a61af66fc99e Initial load duke parents: diff changeset	496 // Instead, rely on caller (nmethod::clear_inline_caches) to clear
a61af66fc99e Initial load duke parents: diff changeset	497 // both the call and its stub.
a61af66fc99e Initial load duke parents: diff changeset	498 }
a61af66fc99e Initial load duke parents: diff changeset	499
a61af66fc99e Initial load duke parents: diff changeset	500
a61af66fc99e Initial load duke parents: diff changeset	501 bool CompiledStaticCall::is_clean() const {
a61af66fc99e Initial load duke parents: diff changeset	502 return destination() == SharedRuntime::get_resolve_static_call_stub();
a61af66fc99e Initial load duke parents: diff changeset	503 }
a61af66fc99e Initial load duke parents: diff changeset	504
a61af66fc99e Initial load duke parents: diff changeset	505 bool CompiledStaticCall::is_call_to_compiled() const {
a61af66fc99e Initial load duke parents: diff changeset	506 return CodeCache::contains(destination());
a61af66fc99e Initial load duke parents: diff changeset	507 }
a61af66fc99e Initial load duke parents: diff changeset	508
a61af66fc99e Initial load duke parents: diff changeset	509
a61af66fc99e Initial load duke parents: diff changeset	510 bool CompiledStaticCall::is_call_to_interpreted() const {
a61af66fc99e Initial load duke parents: diff changeset	511 // It is a call to interpreted, if it calls to a stub. Hence, the destination
a61af66fc99e Initial load duke parents: diff changeset	512 // must be in the stub part of the nmethod that contains the call
a61af66fc99e Initial load duke parents: diff changeset	513 nmethod* nm = CodeCache::find_nmethod(instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	514 return nm->stub_contains(destination());
a61af66fc99e Initial load duke parents: diff changeset	515 }
a61af66fc99e Initial load duke parents: diff changeset	516
a61af66fc99e Initial load duke parents: diff changeset	517 void CompiledStaticCall::set(const StaticCallInfo& info) {
a61af66fc99e Initial load duke parents: diff changeset	518 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "mt unsafe call");
a61af66fc99e Initial load duke parents: diff changeset	519 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	520 // Updating a cache to the wrong entry can cause bugs that are very hard
a61af66fc99e Initial load duke parents: diff changeset	521 // to track down - if cache entry gets invalid - we just clean it. In
a61af66fc99e Initial load duke parents: diff changeset	522 // this way it is always the same code path that is responsible for
a61af66fc99e Initial load duke parents: diff changeset	523 // updating and resolving an inline cache
a61af66fc99e Initial load duke parents: diff changeset	524 assert(is_clean(), "do not update a call entry - use clean");
a61af66fc99e Initial load duke parents: diff changeset	525
a61af66fc99e Initial load duke parents: diff changeset	526 if (info._to_interpreter) {
a61af66fc99e Initial load duke parents: diff changeset	527 // Call to interpreted code
a61af66fc99e Initial load duke parents: diff changeset	528 set_to_interpreted(info.callee(), info.entry());
a61af66fc99e Initial load duke parents: diff changeset	529 } else {
a61af66fc99e Initial load duke parents: diff changeset	530 if (TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	531 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	532 tty->print_cr("CompiledStaticCall@" INTPTR_FORMAT ": set_to_compiled " INTPTR_FORMAT,
a61af66fc99e Initial load duke parents: diff changeset	533 instruction_address(),
a61af66fc99e Initial load duke parents: diff changeset	534 info.entry());
a61af66fc99e Initial load duke parents: diff changeset	535 }
a61af66fc99e Initial load duke parents: diff changeset	536 // Call to compiled code
a61af66fc99e Initial load duke parents: diff changeset	537 assert (CodeCache::contains(info.entry()), "wrong entry point");
a61af66fc99e Initial load duke parents: diff changeset	538 set_destination_mt_safe(info.entry());
a61af66fc99e Initial load duke parents: diff changeset	539 }
a61af66fc99e Initial load duke parents: diff changeset	540 }
a61af66fc99e Initial load duke parents: diff changeset	541
a61af66fc99e Initial load duke parents: diff changeset	542
a61af66fc99e Initial load duke parents: diff changeset	543 // Compute settings for a CompiledStaticCall. Since we might have to set
a61af66fc99e Initial load duke parents: diff changeset	544 // the stub when calling to the interpreter, we need to return arguments.
a61af66fc99e Initial load duke parents: diff changeset	545 void CompiledStaticCall::compute_entry(methodHandle m, StaticCallInfo& info) {
a61af66fc99e Initial load duke parents: diff changeset	546 nmethod* m_code = m->code();
a61af66fc99e Initial load duke parents: diff changeset	547 info._callee = m;
13441 df832bd8edb9 8028107: Kitchensink crashed with EAV kvn parents: 12294 diff changeset	548 if (m_code != NULL && m_code->is_in_use()) {
0 a61af66fc99e Initial load duke parents: diff changeset	549 info._to_interpreter = false;
a61af66fc99e Initial load duke parents: diff changeset	550 info._entry = m_code->verified_entry_point();
a61af66fc99e Initial load duke parents: diff changeset	551 } else {
a61af66fc99e Initial load duke parents: diff changeset	552 // Callee is interpreted code. In any case entering the interpreter
a61af66fc99e Initial load duke parents: diff changeset	553 // puts a converter-frame on the stack to save arguments.
a61af66fc99e Initial load duke parents: diff changeset	554 info._to_interpreter = true;
a61af66fc99e Initial load duke parents: diff changeset	555 info._entry = m()->get_c2i_entry();
a61af66fc99e Initial load duke parents: diff changeset	556 }
a61af66fc99e Initial load duke parents: diff changeset	557 }
a61af66fc99e Initial load duke parents: diff changeset	558
a61af66fc99e Initial load duke parents: diff changeset	559 address CompiledStaticCall::find_stub() {
a61af66fc99e Initial load duke parents: diff changeset	560 // Find reloc. information containing this call-site
a61af66fc99e Initial load duke parents: diff changeset	561 RelocIterator iter((nmethod*)NULL, instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	562 while (iter.next()) {
a61af66fc99e Initial load duke parents: diff changeset	563 if (iter.addr() == instruction_address()) {
a61af66fc99e Initial load duke parents: diff changeset	564 switch(iter.type()) {
a61af66fc99e Initial load duke parents: diff changeset	565 case relocInfo::static_call_type:
a61af66fc99e Initial load duke parents: diff changeset	566 return iter.static_call_reloc()->static_stub();
a61af66fc99e Initial load duke parents: diff changeset	567 // We check here for opt_virtual_call_type, since we reuse the code
a61af66fc99e Initial load duke parents: diff changeset	568 // from the CompiledIC implementation
a61af66fc99e Initial load duke parents: diff changeset	569 case relocInfo::opt_virtual_call_type:
a61af66fc99e Initial load duke parents: diff changeset	570 return iter.opt_virtual_call_reloc()->static_stub();
a61af66fc99e Initial load duke parents: diff changeset	571 case relocInfo::poll_type:
a61af66fc99e Initial load duke parents: diff changeset	572 case relocInfo::poll_return_type: // A safepoint can't overlap a call.
a61af66fc99e Initial load duke parents: diff changeset	573 default:
a61af66fc99e Initial load duke parents: diff changeset	574 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	575 }
a61af66fc99e Initial load duke parents: diff changeset	576 }
a61af66fc99e Initial load duke parents: diff changeset	577 }
a61af66fc99e Initial load duke parents: diff changeset	578 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	579 }
a61af66fc99e Initial load duke parents: diff changeset	580
a61af66fc99e Initial load duke parents: diff changeset	581
a61af66fc99e Initial load duke parents: diff changeset	582 //-----------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	583 // Non-product mode code
a61af66fc99e Initial load duke parents: diff changeset	584 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	585
a61af66fc99e Initial load duke parents: diff changeset	586 void CompiledIC::verify() {
a61af66fc99e Initial load duke parents: diff changeset	587 // make sure code pattern is actually a call imm32 instruction
a61af66fc99e Initial load duke parents: diff changeset	588 _ic_call->verify();
a61af66fc99e Initial load duke parents: diff changeset	589 if (os::is_MP()) {
a61af66fc99e Initial load duke parents: diff changeset	590 _ic_call->verify_alignment();
a61af66fc99e Initial load duke parents: diff changeset	591 }
a61af66fc99e Initial load duke parents: diff changeset	592 assert(is_clean() \|\| is_call_to_compiled() \|\| is_call_to_interpreted()
a61af66fc99e Initial load duke parents: diff changeset	593 \|\| is_optimized() \|\| is_megamorphic(), "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	594 }
a61af66fc99e Initial load duke parents: diff changeset	595
a61af66fc99e Initial load duke parents: diff changeset	596 void CompiledIC::print() {
a61af66fc99e Initial load duke parents: diff changeset	597 print_compiled_ic();
a61af66fc99e Initial load duke parents: diff changeset	598 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	599 }
a61af66fc99e Initial load duke parents: diff changeset	600
a61af66fc99e Initial load duke parents: diff changeset	601 void CompiledIC::print_compiled_ic() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	602 tty->print("Inline cache at " INTPTR_FORMAT ", calling %s " INTPTR_FORMAT " cached_value " INTPTR_FORMAT,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	603 instruction_address(), is_call_to_interpreted() ? "interpreted " : "", ic_destination(), is_optimized() ? NULL : cached_value());
0 a61af66fc99e Initial load duke parents: diff changeset	604 }
a61af66fc99e Initial load duke parents: diff changeset	605
a61af66fc99e Initial load duke parents: diff changeset	606 void CompiledStaticCall::print() {
a61af66fc99e Initial load duke parents: diff changeset	607 tty->print("static call at " INTPTR_FORMAT " -> ", instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	608 if (is_clean()) {
a61af66fc99e Initial load duke parents: diff changeset	609 tty->print("clean");
a61af66fc99e Initial load duke parents: diff changeset	610 } else if (is_call_to_compiled()) {
a61af66fc99e Initial load duke parents: diff changeset	611 tty->print("compiled");
a61af66fc99e Initial load duke parents: diff changeset	612 } else if (is_call_to_interpreted()) {
a61af66fc99e Initial load duke parents: diff changeset	613 tty->print("interpreted");
a61af66fc99e Initial load duke parents: diff changeset	614 }
a61af66fc99e Initial load duke parents: diff changeset	615 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	616 }
a61af66fc99e Initial load duke parents: diff changeset	617
10168 a6e09d6dd8e5 8003853: specify offset of IC load in java_to_interp stub dlong parents: 8776 diff changeset	618 #endif // !PRODUCT

Mercurial > hg > truffle

annotate src/share/vm/code/compiledIC.cpp @ 13441:df832bd8edb9