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

annotate src/share/vm/code/compiledIC.cpp @ 14649:f6301b007a16

6498581: ThreadInterruptTest3 produces wrong output on Windows Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set. Reviewed-by: acorn, kvn Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com

author	minqi
date	Wed, 26 Feb 2014 15:20:41 -0800
parents	22ae97935e05
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;
14212 22ae97935e05 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;
14212 22ae97935e05 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 @ 14649:f6301b007a16