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

annotate src/share/vm/code/compiledIC.cpp @ 20432:aff6ccb506cb

8056154: JVM crash with EXCEPTION_ACCESS_VIOLATION when there are many threads running Summary: Don't make compiled MH intrinsics not entrant when redefining classes Reviewed-by: kvn, vlivanov

author	iveresov
date	Fri, 05 Sep 2014 14:39:45 -0700
parents	2c6ef90f030a
children	7848fc12602b

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 13441 diff changeset	2 * Copyright (c) 1997, 2014, 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();
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 13441 diff changeset	91 tty->print(" changing destination to " INTPTR_FORMAT, p2i(entry_point));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	92 if (!is_optimized()) {
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 13441 diff changeset	93 tty->print(" changing cached %s to " INTPTR_FORMAT, is_icholder ? "icholder" : "metadata", p2i((address)cache));
6725 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 {
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20277 diff changeset	102 MutexLockerEx pl(SafepointSynchronize::is_at_safepoint() ? NULL : Patching_lock, Mutex::_no_safepoint_check_flag);
0 a61af66fc99e Initial load duke parents: diff changeset	103 #ifdef ASSERT
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20277 diff changeset	104 CodeBlob* cb = CodeCache::find_blob_unsafe(_ic_call);
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20277 diff changeset	105 assert(cb != NULL && cb->is_nmethod(), "must be nmethod");
0 a61af66fc99e Initial load duke parents: diff changeset	106 #endif
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20277 diff changeset	107 _ic_call->set_destination_mt_safe(entry_point);
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20277 diff changeset	108 }
0 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
20277 882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	162 void CompiledIC::initialize_from_iter(RelocIterator* iter) {
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	163 assert(iter->addr() == _ic_call->instruction_address(), "must find ic_call");
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	164
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	165 if (iter->type() == relocInfo::virtual_call_type) {
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	166 virtual_call_Relocation* r = iter->virtual_call_reloc();
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	167 _is_optimized = false;
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	168 _value = nativeMovConstReg_at(r->cached_value());
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	169 } else {
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	170 assert(iter->type() == relocInfo::opt_virtual_call_type, "must be a virtual call");
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	171 _is_optimized = true;
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	172 _value = NULL;
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	173 }
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	174 }
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	175
20271 c64b6b0c40c8 8047326: Consolidate all CompiledIC::CompiledIC implementations and move it to compiledIC.cpp stefank parents: 17937 diff changeset	176 CompiledIC::CompiledIC(nmethod* nm, NativeCall* call)
c64b6b0c40c8 8047326: Consolidate all CompiledIC::CompiledIC implementations and move it to compiledIC.cpp stefank parents: 17937 diff changeset	177 : _ic_call(call)
c64b6b0c40c8 8047326: Consolidate all CompiledIC::CompiledIC implementations and move it to compiledIC.cpp stefank parents: 17937 diff changeset	178 {
20277 882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	179 address ic_call = _ic_call->instruction_address();
20271 c64b6b0c40c8 8047326: Consolidate all CompiledIC::CompiledIC implementations and move it to compiledIC.cpp stefank parents: 17937 diff changeset	180
c64b6b0c40c8 8047326: Consolidate all CompiledIC::CompiledIC implementations and move it to compiledIC.cpp stefank parents: 17937 diff changeset	181 assert(ic_call != NULL, "ic_call address must be set");
c64b6b0c40c8 8047326: Consolidate all CompiledIC::CompiledIC implementations and move it to compiledIC.cpp stefank parents: 17937 diff changeset	182 assert(nm != NULL, "must pass nmethod");
c64b6b0c40c8 8047326: Consolidate all CompiledIC::CompiledIC implementations and move it to compiledIC.cpp stefank parents: 17937 diff changeset	183 assert(nm->contains(ic_call), "must be in nmethod");
c64b6b0c40c8 8047326: Consolidate all CompiledIC::CompiledIC implementations and move it to compiledIC.cpp stefank parents: 17937 diff changeset	184
c64b6b0c40c8 8047326: Consolidate all CompiledIC::CompiledIC implementations and move it to compiledIC.cpp stefank parents: 17937 diff changeset	185 // Search for the ic_call at the given address.
c64b6b0c40c8 8047326: Consolidate all CompiledIC::CompiledIC implementations and move it to compiledIC.cpp stefank parents: 17937 diff changeset	186 RelocIterator iter(nm, ic_call, ic_call+1);
c64b6b0c40c8 8047326: Consolidate all CompiledIC::CompiledIC implementations and move it to compiledIC.cpp stefank parents: 17937 diff changeset	187 bool ret = iter.next();
c64b6b0c40c8 8047326: Consolidate all CompiledIC::CompiledIC implementations and move it to compiledIC.cpp stefank parents: 17937 diff changeset	188 assert(ret == true, "relocInfo must exist at this address");
c64b6b0c40c8 8047326: Consolidate all CompiledIC::CompiledIC implementations and move it to compiledIC.cpp stefank parents: 17937 diff changeset	189 assert(iter.addr() == ic_call, "must find ic_call");
20277 882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	190
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	191 initialize_from_iter(&iter);
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	192 }
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	193
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	194 CompiledIC::CompiledIC(RelocIterator* iter)
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	195 : _ic_call(nativeCall_at(iter->addr()))
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	196 {
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	197 address ic_call = _ic_call->instruction_address();
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	198
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	199 nmethod* nm = iter->code();
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	200 assert(ic_call != NULL, "ic_call address must be set");
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	201 assert(nm != NULL, "must pass nmethod");
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	202 assert(nm->contains(ic_call), "must be in nmethod");
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	203
882004b9e7e1 8047362: Add a version of CompiledIC_at that doesn't create a new RelocIterator stefank parents: 20271 diff changeset	204 initialize_from_iter(iter);
20271 c64b6b0c40c8 8047326: Consolidate all CompiledIC::CompiledIC implementations and move it to compiledIC.cpp stefank parents: 17937 diff changeset	205 }
0 a61af66fc99e Initial load duke parents: diff changeset	206
12294 891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 12264 diff changeset	207 bool CompiledIC::set_to_megamorphic(CallInfo* call_info, Bytecodes::Code bytecode, TRAPS) {
0 a61af66fc99e Initial load duke parents: diff changeset	208 assert(CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	209 assert(!is_optimized(), "cannot set an optimized virtual call to megamorphic");
a61af66fc99e Initial load duke parents: diff changeset	210 assert(is_call_to_compiled() \|\| is_call_to_interpreted(), "going directly to megamorphic?");
a61af66fc99e Initial load duke parents: diff changeset	211
a61af66fc99e Initial load duke parents: diff changeset	212 address entry;
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	213 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	214 assert(bytecode == Bytecodes::_invokeinterface, "");
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	215 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	216 entry = VtableStubs::find_itable_stub(itable_index);
12294 891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 12264 diff changeset	217 if (entry == false) {
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 12264 diff changeset	218 return false;
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 12264 diff changeset	219 }
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	220 #ifdef ASSERT
b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	221 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	222 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	223 #endif //ASSERT
6940 18fb7da42534 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass coleenp parents: 6725 diff changeset	224 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	225 assert(k->verify_itable_index(itable_index), "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	226 InlineCacheBuffer::create_transition_stub(this, k, entry);
a61af66fc99e Initial load duke parents: diff changeset	227 } else {
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	228 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	229 // Can be different than selected_method->vtable_index(), due to package-private etc.
0 a61af66fc99e Initial load duke parents: diff changeset	230 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	231 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	232 entry = VtableStubs::find_vtable_stub(vtable_index);
12294 891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 12264 diff changeset	233 if (entry == NULL) {
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 12264 diff changeset	234 return false;
891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 12264 diff changeset	235 }
12264 b2e698d2276c 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation drchase parents: 10168 diff changeset	236 InlineCacheBuffer::create_transition_stub(this, NULL, entry);
0 a61af66fc99e Initial load duke parents: diff changeset	237 }
a61af66fc99e Initial load duke parents: diff changeset	238
a61af66fc99e Initial load duke parents: diff changeset	239 if (TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	240 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	241 tty->print_cr ("IC@" INTPTR_FORMAT ": to megamorphic %s entry: " INTPTR_FORMAT,
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 13441 diff changeset	242 p2i(instruction_address()), call_info->selected_method()->print_value_string(), p2i(entry));
0 a61af66fc99e Initial load duke parents: diff changeset	243 }
a61af66fc99e Initial load duke parents: diff changeset	244
a61af66fc99e Initial load duke parents: diff changeset	245 // We can't check this anymore. With lazy deopt we could have already
a61af66fc99e Initial load duke parents: diff changeset	246 // cleaned this IC entry before we even return. This is possible if
a61af66fc99e Initial load duke parents: diff changeset	247 // we ran out of space in the inline cache buffer trying to do the
a61af66fc99e Initial load duke parents: diff changeset	248 // set_next and we safepointed to free up space. This is a benign
a61af66fc99e Initial load duke parents: diff changeset	249 // race because the IC entry was complete when we safepointed so
a61af66fc99e Initial load duke parents: diff changeset	250 // cleaning it immediately is harmless.
a61af66fc99e Initial load duke parents: diff changeset	251 // assert(is_megamorphic(), "sanity check");
12294 891687731b59 7009641: Don't fail VM when CodeCache is full anoll parents: 12264 diff changeset	252 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	253 }
a61af66fc99e Initial load duke parents: diff changeset	254
a61af66fc99e Initial load duke parents: diff changeset	255
a61af66fc99e Initial load duke parents: diff changeset	256 // true if destination is megamorphic stub
a61af66fc99e Initial load duke parents: diff changeset	257 bool CompiledIC::is_megamorphic() const {
a61af66fc99e Initial load duke parents: diff changeset	258 assert(CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	259 assert(!is_optimized(), "an optimized call cannot be megamorphic");
a61af66fc99e Initial load duke parents: diff changeset	260
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	261 // Cannot rely on cached_value. It is either an interface or a method.
0 a61af66fc99e Initial load duke parents: diff changeset	262 return VtableStubs::is_entry_point(ic_destination());
a61af66fc99e Initial load duke parents: diff changeset	263 }
a61af66fc99e Initial load duke parents: diff changeset	264
a61af66fc99e Initial load duke parents: diff changeset	265 bool CompiledIC::is_call_to_compiled() const {
a61af66fc99e Initial load duke parents: diff changeset	266 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	267
a61af66fc99e Initial load duke parents: diff changeset	268 // Use unsafe, since an inline cache might point to a zombie method. However, the zombie
a61af66fc99e Initial load duke parents: diff changeset	269 // method is guaranteed to still exist, since we only remove methods after all inline caches
a61af66fc99e Initial load duke parents: diff changeset	270 // has been cleaned up
a61af66fc99e Initial load duke parents: diff changeset	271 CodeBlob* cb = CodeCache::find_blob_unsafe(ic_destination());
a61af66fc99e Initial load duke parents: diff changeset	272 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	273 // Check that the cached_value is a klass for non-optimized monomorphic calls
0 a61af66fc99e Initial load duke parents: diff changeset	274 // 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	275 // for calling directly to vep without using the inline cache (i.e., cached_value == NULL)
0 a61af66fc99e Initial load duke parents: diff changeset	276 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	277 CodeBlob* caller = CodeCache::find_blob_unsafe(instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	278 bool is_c1_method = caller->is_compiled_by_c1();
a61af66fc99e Initial load duke parents: diff changeset	279 assert( is_c1_method \|\|
a61af66fc99e Initial load duke parents: diff changeset	280 !is_monomorphic \|\|
a61af66fc99e Initial load duke parents: diff changeset	281 is_optimized() \|\|
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	282 (cached_metadata() != NULL && cached_metadata()->is_klass()), "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	283 #endif // ASSERT
a61af66fc99e Initial load duke parents: diff changeset	284 return is_monomorphic;
a61af66fc99e Initial load duke parents: diff changeset	285 }
a61af66fc99e Initial load duke parents: diff changeset	286
a61af66fc99e Initial load duke parents: diff changeset	287
a61af66fc99e Initial load duke parents: diff changeset	288 bool CompiledIC::is_call_to_interpreted() const {
a61af66fc99e Initial load duke parents: diff changeset	289 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	290 // Call to interpreter if destination is either calling to a stub (if it
a61af66fc99e Initial load duke parents: diff changeset	291 // is optimized), or calling to an I2C blob
a61af66fc99e Initial load duke parents: diff changeset	292 bool is_call_to_interpreted = false;
a61af66fc99e Initial load duke parents: diff changeset	293 if (!is_optimized()) {
a61af66fc99e Initial load duke parents: diff changeset	294 // must use unsafe because the destination can be a zombie (and we're cleaning)
a61af66fc99e Initial load duke parents: diff changeset	295 // and the print_compiled_ic code wants to know if site (in the non-zombie)
a61af66fc99e Initial load duke parents: diff changeset	296 // is to the interpreter.
a61af66fc99e Initial load duke parents: diff changeset	297 CodeBlob* cb = CodeCache::find_blob_unsafe(ic_destination());
a61af66fc99e Initial load duke parents: diff changeset	298 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	299 assert(!is_call_to_interpreted \|\| (is_icholder_call() && cached_icholder() != NULL), "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	300 } else {
a61af66fc99e Initial load duke parents: diff changeset	301 // Check if we are calling into our own codeblob (i.e., to a stub)
a61af66fc99e Initial load duke parents: diff changeset	302 CodeBlob* cb = CodeCache::find_blob(_ic_call->instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	303 address dest = ic_destination();
a61af66fc99e Initial load duke parents: diff changeset	304 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	305 {
a61af66fc99e Initial load duke parents: diff changeset	306 CodeBlob* db = CodeCache::find_blob_unsafe(dest);
a61af66fc99e Initial load duke parents: diff changeset	307 assert(!db->is_adapter_blob(), "must use stub!");
a61af66fc99e Initial load duke parents: diff changeset	308 }
a61af66fc99e Initial load duke parents: diff changeset	309 #endif /* ASSERT */
a61af66fc99e Initial load duke parents: diff changeset	310 is_call_to_interpreted = cb->contains(dest);
a61af66fc99e Initial load duke parents: diff changeset	311 }
a61af66fc99e Initial load duke parents: diff changeset	312 return is_call_to_interpreted;
a61af66fc99e Initial load duke parents: diff changeset	313 }
a61af66fc99e Initial load duke parents: diff changeset	314
a61af66fc99e Initial load duke parents: diff changeset	315
a61af66fc99e Initial load duke parents: diff changeset	316 void CompiledIC::set_to_clean() {
a61af66fc99e Initial load duke parents: diff changeset	317 assert(SafepointSynchronize::is_at_safepoint() \|\| CompiledIC_lock->is_locked() , "MT-unsafe call");
a61af66fc99e Initial load duke parents: diff changeset	318 if (TraceInlineCacheClearing \|\| TraceICs) {
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 13441 diff changeset	319 tty->print_cr("IC@" INTPTR_FORMAT ": set to clean", p2i(instruction_address()));
0 a61af66fc99e Initial load duke parents: diff changeset	320 print();
a61af66fc99e Initial load duke parents: diff changeset	321 }
a61af66fc99e Initial load duke parents: diff changeset	322
a61af66fc99e Initial load duke parents: diff changeset	323 address entry;
a61af66fc99e Initial load duke parents: diff changeset	324 if (is_optimized()) {
a61af66fc99e Initial load duke parents: diff changeset	325 entry = SharedRuntime::get_resolve_opt_virtual_call_stub();
a61af66fc99e Initial load duke parents: diff changeset	326 } else {
a61af66fc99e Initial load duke parents: diff changeset	327 entry = SharedRuntime::get_resolve_virtual_call_stub();
a61af66fc99e Initial load duke parents: diff changeset	328 }
a61af66fc99e Initial load duke parents: diff changeset	329
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	330 // 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	331 // we only need to patch the destination
a61af66fc99e Initial load duke parents: diff changeset	332 bool safe_transition = is_optimized() \|\| SafepointSynchronize::is_at_safepoint();
a61af66fc99e Initial load duke parents: diff changeset	333
a61af66fc99e Initial load duke parents: diff changeset	334 if (safe_transition) {
a61af66fc99e Initial load duke parents: diff changeset	335 // Kill any leftover stub we might have too
a61af66fc99e Initial load duke parents: diff changeset	336 if (is_in_transition_state()) {
a61af66fc99e Initial load duke parents: diff changeset	337 ICStub* old_stub = ICStub_from_destination_address(stub_address());
a61af66fc99e Initial load duke parents: diff changeset	338 old_stub->clear();
a61af66fc99e Initial load duke parents: diff changeset	339 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	340 if (is_optimized()) {
0 a61af66fc99e Initial load duke parents: diff changeset	341 set_ic_destination(entry);
a61af66fc99e Initial load duke parents: diff changeset	342 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	343 set_ic_destination_and_value(entry, (void*)NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	344 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	345 } else {
0 a61af66fc99e Initial load duke parents: diff changeset	346 // Unsafe transition - create stub.
a61af66fc99e Initial load duke parents: diff changeset	347 InlineCacheBuffer::create_transition_stub(this, NULL, entry);
a61af66fc99e Initial load duke parents: diff changeset	348 }
a61af66fc99e Initial load duke parents: diff changeset	349 // We can't check this anymore. With lazy deopt we could have already
a61af66fc99e Initial load duke parents: diff changeset	350 // cleaned this IC entry before we even return. This is possible if
a61af66fc99e Initial load duke parents: diff changeset	351 // we ran out of space in the inline cache buffer trying to do the
a61af66fc99e Initial load duke parents: diff changeset	352 // set_next and we safepointed to free up space. This is a benign
a61af66fc99e Initial load duke parents: diff changeset	353 // race because the IC entry was complete when we safepointed so
a61af66fc99e Initial load duke parents: diff changeset	354 // cleaning it immediately is harmless.
a61af66fc99e Initial load duke parents: diff changeset	355 // assert(is_clean(), "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	356 }
a61af66fc99e Initial load duke parents: diff changeset	357
a61af66fc99e Initial load duke parents: diff changeset	358
a61af66fc99e Initial load duke parents: diff changeset	359 bool CompiledIC::is_clean() const {
a61af66fc99e Initial load duke parents: diff changeset	360 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	361 bool is_clean = false;
a61af66fc99e Initial load duke parents: diff changeset	362 address dest = ic_destination();
a61af66fc99e Initial load duke parents: diff changeset	363 is_clean = dest == SharedRuntime::get_resolve_opt_virtual_call_stub() \|\|
a61af66fc99e Initial load duke parents: diff changeset	364 dest == SharedRuntime::get_resolve_virtual_call_stub();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	365 assert(!is_clean \|\| is_optimized() \|\| cached_value() == NULL, "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	366 return is_clean;
a61af66fc99e Initial load duke parents: diff changeset	367 }
a61af66fc99e Initial load duke parents: diff changeset	368
a61af66fc99e Initial load duke parents: diff changeset	369
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	370 void CompiledIC::set_to_monomorphic(CompiledICInfo& info) {
0 a61af66fc99e Initial load duke parents: diff changeset	371 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	372 // Updating a cache to the wrong entry can cause bugs that are very hard
a61af66fc99e Initial load duke parents: diff changeset	373 // to track down - if cache entry gets invalid - we just clean it. In
a61af66fc99e Initial load duke parents: diff changeset	374 // this way it is always the same code path that is responsible for
a61af66fc99e Initial load duke parents: diff changeset	375 // updating and resolving an inline cache
a61af66fc99e Initial load duke parents: diff changeset	376 //
a61af66fc99e Initial load duke parents: diff changeset	377 // The above is no longer true. SharedRuntime::fixup_callers_callsite will change optimized
a61af66fc99e Initial load duke parents: diff changeset	378 // callsites. In addition ic_miss code will update a site to monomorphic if it determines
a61af66fc99e Initial load duke parents: diff changeset	379 // that an monomorphic call to the interpreter can now be monomorphic to compiled code.
a61af66fc99e Initial load duke parents: diff changeset	380 //
a61af66fc99e Initial load duke parents: diff changeset	381 // In both of these cases the only thing being modifed is the jump/call target and these
a61af66fc99e Initial load duke parents: diff changeset	382 // transitions are mt_safe
a61af66fc99e Initial load duke parents: diff changeset	383
a61af66fc99e Initial load duke parents: diff changeset	384 Thread *thread = Thread::current();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	385 if (info.to_interpreter()) {
0 a61af66fc99e Initial load duke parents: diff changeset	386 // Call to interpreter
a61af66fc99e Initial load duke parents: diff changeset	387 if (info.is_optimized() && is_optimized()) {
a61af66fc99e Initial load duke parents: diff changeset	388 assert(is_clean(), "unsafe IC path");
a61af66fc99e Initial load duke parents: diff changeset	389 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	390 // the call analysis (callee structure) specifies that the call is optimized
a61af66fc99e Initial load duke parents: diff changeset	391 // (either because of CHA or the static target is final)
a61af66fc99e Initial load duke parents: diff changeset	392 // At code generation time, this call has been emitted as static call
a61af66fc99e Initial load duke parents: diff changeset	393 // Call via stub
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	394 assert(info.cached_metadata() != NULL && info.cached_metadata()->is_method(), "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	395 CompiledStaticCall* csc = compiledStaticCall_at(instruction_address());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	396 methodHandle method (thread, (Method*)info.cached_metadata());
0 a61af66fc99e Initial load duke parents: diff changeset	397 csc->set_to_interpreted(method, info.entry());
a61af66fc99e Initial load duke parents: diff changeset	398 if (TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	399 ResourceMark rm(thread);
a61af66fc99e Initial load duke parents: diff changeset	400 tty->print_cr ("IC@" INTPTR_FORMAT ": monomorphic to interpreter: %s",
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 13441 diff changeset	401 p2i(instruction_address()),
0 a61af66fc99e Initial load duke parents: diff changeset	402 method->print_value_string());
a61af66fc99e Initial load duke parents: diff changeset	403 }
a61af66fc99e Initial load duke parents: diff changeset	404 } else {
a61af66fc99e Initial load duke parents: diff changeset	405 // Call via method-klass-holder
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	406 InlineCacheBuffer::create_transition_stub(this, info.claim_cached_icholder(), info.entry());
0 a61af66fc99e Initial load duke parents: diff changeset	407 if (TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	408 ResourceMark rm(thread);
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 13441 diff changeset	409 tty->print_cr ("IC@" INTPTR_FORMAT ": monomorphic to interpreter via icholder ", p2i(instruction_address()));
0 a61af66fc99e Initial load duke parents: diff changeset	410 }
a61af66fc99e Initial load duke parents: diff changeset	411 }
a61af66fc99e Initial load duke parents: diff changeset	412 } else {
a61af66fc99e Initial load duke parents: diff changeset	413 // Call to compiled code
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	414 bool static_bound = info.is_optimized() \|\| (info.cached_metadata() == NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	415 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	416 CodeBlob* cb = CodeCache::find_blob_unsafe(info.entry());
a61af66fc99e Initial load duke parents: diff changeset	417 assert (cb->is_nmethod(), "must be compiled!");
a61af66fc99e Initial load duke parents: diff changeset	418 #endif /* ASSERT */
a61af66fc99e Initial load duke parents: diff changeset	419
a61af66fc99e Initial load duke parents: diff changeset	420 // This is MT safe if we come from a clean-cache and go through a
a61af66fc99e Initial load duke parents: diff changeset	421 // non-verified entry point
a61af66fc99e Initial load duke parents: diff changeset	422 bool safe = SafepointSynchronize::is_at_safepoint() \|\|
a61af66fc99e Initial load duke parents: diff changeset	423 (!is_in_transition_state() && (info.is_optimized() \|\| static_bound \|\| is_clean()));
a61af66fc99e Initial load duke parents: diff changeset	424
a61af66fc99e Initial load duke parents: diff changeset	425 if (!safe) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	426 InlineCacheBuffer::create_transition_stub(this, info.cached_metadata(), info.entry());
0 a61af66fc99e Initial load duke parents: diff changeset	427 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	428 if (is_optimized()) {
0 a61af66fc99e Initial load duke parents: diff changeset	429 set_ic_destination(info.entry());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	430 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	431 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	432 }
0 a61af66fc99e Initial load duke parents: diff changeset	433 }
a61af66fc99e Initial load duke parents: diff changeset	434
a61af66fc99e Initial load duke parents: diff changeset	435 if (TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	436 ResourceMark rm(thread);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	437 assert(info.cached_metadata() == NULL \|\| info.cached_metadata()->is_klass(), "must be");
0 a61af66fc99e Initial load duke parents: diff changeset	438 tty->print_cr ("IC@" INTPTR_FORMAT ": monomorphic to compiled (rcvr klass) %s: %s",
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 13441 diff changeset	439 p2i(instruction_address()),
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	440 ((Klass*)info.cached_metadata())->print_value_string(),
0 a61af66fc99e Initial load duke parents: diff changeset	441 (safe) ? "" : "via stub");
a61af66fc99e Initial load duke parents: diff changeset	442 }
a61af66fc99e Initial load duke parents: diff changeset	443 }
a61af66fc99e Initial load duke parents: diff changeset	444 // We can't check this anymore. With lazy deopt we could have already
a61af66fc99e Initial load duke parents: diff changeset	445 // cleaned this IC entry before we even return. This is possible if
a61af66fc99e Initial load duke parents: diff changeset	446 // we ran out of space in the inline cache buffer trying to do the
a61af66fc99e Initial load duke parents: diff changeset	447 // set_next and we safepointed to free up space. This is a benign
a61af66fc99e Initial load duke parents: diff changeset	448 // race because the IC entry was complete when we safepointed so
a61af66fc99e Initial load duke parents: diff changeset	449 // cleaning it immediately is harmless.
a61af66fc99e Initial load duke parents: diff changeset	450 // assert(is_call_to_compiled() \|\| is_call_to_interpreted(), "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	451 }
a61af66fc99e Initial load duke parents: diff changeset	452
a61af66fc99e Initial load duke parents: diff changeset	453
a61af66fc99e Initial load duke parents: diff changeset	454 // is_optimized: Compiler has generated an optimized call (i.e., no inline
a61af66fc99e Initial load duke parents: diff changeset	455 // cache) static_bound: The call can be static bound (i.e, no need to use
a61af66fc99e Initial load duke parents: diff changeset	456 // inline cache)
a61af66fc99e Initial load duke parents: diff changeset	457 void CompiledIC::compute_monomorphic_entry(methodHandle method,
a61af66fc99e Initial load duke parents: diff changeset	458 KlassHandle receiver_klass,
a61af66fc99e Initial load duke parents: diff changeset	459 bool is_optimized,
a61af66fc99e Initial load duke parents: diff changeset	460 bool static_bound,
a61af66fc99e Initial load duke parents: diff changeset	461 CompiledICInfo& info,
a61af66fc99e Initial load duke parents: diff changeset	462 TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	463 nmethod* method_code = method->code();
a61af66fc99e Initial load duke parents: diff changeset	464 address entry = NULL;
13441 df832bd8edb9 8028107: Kitchensink crashed with EAV kvn parents: 12294 diff changeset	465 if (method_code != NULL && method_code->is_in_use()) {
0 a61af66fc99e Initial load duke parents: diff changeset	466 // Call to compiled code
a61af66fc99e Initial load duke parents: diff changeset	467 if (static_bound \|\| is_optimized) {
a61af66fc99e Initial load duke parents: diff changeset	468 entry = method_code->verified_entry_point();
a61af66fc99e Initial load duke parents: diff changeset	469 } else {
a61af66fc99e Initial load duke parents: diff changeset	470 entry = method_code->entry_point();
a61af66fc99e Initial load duke parents: diff changeset	471 }
a61af66fc99e Initial load duke parents: diff changeset	472 }
a61af66fc99e Initial load duke parents: diff changeset	473 if (entry != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	474 // Call to compiled code
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	475 info.set_compiled_entry(entry, (static_bound \|\| is_optimized) ? NULL : receiver_klass(), is_optimized);
0 a61af66fc99e Initial load duke parents: diff changeset	476 } else {
a61af66fc99e Initial load duke parents: diff changeset	477 // Note: the following problem exists with Compiler1:
a61af66fc99e Initial load duke parents: diff changeset	478 // - at compile time we may or may not know if the destination is final
a61af66fc99e Initial load duke parents: diff changeset	479 // - 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	480 // virtual call (no inline cache), and need a Method* to make a call
0 a61af66fc99e Initial load duke parents: diff changeset	481 // to the interpreter
a61af66fc99e Initial load duke parents: diff changeset	482 // - if we do not know if the destination is final, we emit a standard
a61af66fc99e Initial load duke parents: diff changeset	483 // virtual call, and use CompiledICHolder to call interpreted code
a61af66fc99e Initial load duke parents: diff changeset	484 // (no static call stub has been generated)
a61af66fc99e Initial load duke parents: diff changeset	485 // However in that case we will now notice it is static_bound
a61af66fc99e Initial load duke parents: diff changeset	486 // and convert the call into what looks to be an optimized
a61af66fc99e Initial load duke parents: diff changeset	487 // virtual call. This causes problems in verifying the IC because
a61af66fc99e Initial load duke parents: diff changeset	488 // it look vanilla but is optimized. Code in is_call_to_interpreted
a61af66fc99e Initial load duke parents: diff changeset	489 // is aware of this and weakens its asserts.
a61af66fc99e Initial load duke parents: diff changeset	490
a61af66fc99e Initial load duke parents: diff changeset	491 // static_bound should imply is_optimized -- otherwise we have a
a61af66fc99e Initial load duke parents: diff changeset	492 // performance bug (statically-bindable method is called via
a61af66fc99e Initial load duke parents: diff changeset	493 // dynamically-dispatched call note: the reverse implication isn't
a61af66fc99e Initial load duke parents: diff changeset	494 // necessarily true -- the call may have been optimized based on compiler
a61af66fc99e Initial load duke parents: diff changeset	495 // analysis (static_bound is only based on "final" etc.)
a61af66fc99e Initial load duke parents: diff changeset	496 #ifdef COMPILER2
a61af66fc99e Initial load duke parents: diff changeset	497 #ifdef TIERED
a61af66fc99e Initial load duke parents: diff changeset	498 #if defined(ASSERT)
a61af66fc99e Initial load duke parents: diff changeset	499 // can't check the assert because we don't have the CompiledIC with which to
a61af66fc99e Initial load duke parents: diff changeset	500 // find the address if the call instruction.
a61af66fc99e Initial load duke parents: diff changeset	501 //
a61af66fc99e Initial load duke parents: diff changeset	502 // CodeBlob* cb = find_blob_unsafe(instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	503 // assert(cb->is_compiled_by_c1() \|\| !static_bound \|\| is_optimized, "static_bound should imply is_optimized");
a61af66fc99e Initial load duke parents: diff changeset	504 #endif // ASSERT
a61af66fc99e Initial load duke parents: diff changeset	505 #else
a61af66fc99e Initial load duke parents: diff changeset	506 assert(!static_bound \|\| is_optimized, "static_bound should imply is_optimized");
a61af66fc99e Initial load duke parents: diff changeset	507 #endif // TIERED
a61af66fc99e Initial load duke parents: diff changeset	508 #endif // COMPILER2
a61af66fc99e Initial load duke parents: diff changeset	509 if (is_optimized) {
a61af66fc99e Initial load duke parents: diff changeset	510 // Use stub entry
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	511 info.set_interpreter_entry(method()->get_c2i_entry(), method());
0 a61af66fc99e Initial load duke parents: diff changeset	512 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	513 // Use icholder entry
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	514 CompiledICHolder* holder = new CompiledICHolder(method(), receiver_klass());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	515 info.set_icholder_entry(method()->get_c2i_unverified_entry(), holder);
0 a61af66fc99e Initial load duke parents: diff changeset	516 }
a61af66fc99e Initial load duke parents: diff changeset	517 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	518 assert(info.is_optimized() == is_optimized, "must agree");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	519 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	520
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	521
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	522 bool CompiledIC::is_icholder_entry(address entry) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	523 CodeBlob* cb = CodeCache::find_blob_unsafe(entry);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	524 return (cb != NULL && cb->is_adapter_blob());
0 a61af66fc99e Initial load duke parents: diff changeset	525 }
a61af66fc99e Initial load duke parents: diff changeset	526
a61af66fc99e Initial load duke parents: diff changeset	527 // ----------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	528
a61af66fc99e Initial load duke parents: diff changeset	529 void CompiledStaticCall::set_to_clean() {
a61af66fc99e Initial load duke parents: diff changeset	530 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "mt unsafe call");
a61af66fc99e Initial load duke parents: diff changeset	531 // Reset call site
20278 2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle stefank parents: 20277 diff changeset	532 MutexLockerEx pl(SafepointSynchronize::is_at_safepoint() ? NULL : Patching_lock, Mutex::_no_safepoint_check_flag);
0 a61af66fc99e Initial load duke parents: diff changeset	533 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	534 CodeBlob* cb = CodeCache::find_blob_unsafe(this);
a61af66fc99e Initial load duke parents: diff changeset	535 assert(cb != NULL && cb->is_nmethod(), "must be nmethod");
a61af66fc99e Initial load duke parents: diff changeset	536 #endif
a61af66fc99e Initial load duke parents: diff changeset	537 set_destination_mt_safe(SharedRuntime::get_resolve_static_call_stub());
a61af66fc99e Initial load duke parents: diff changeset	538
a61af66fc99e Initial load duke parents: diff changeset	539 // Do not reset stub here: It is too expensive to call find_stub.
a61af66fc99e Initial load duke parents: diff changeset	540 // Instead, rely on caller (nmethod::clear_inline_caches) to clear
a61af66fc99e Initial load duke parents: diff changeset	541 // both the call and its stub.
a61af66fc99e Initial load duke parents: diff changeset	542 }
a61af66fc99e Initial load duke parents: diff changeset	543
a61af66fc99e Initial load duke parents: diff changeset	544
a61af66fc99e Initial load duke parents: diff changeset	545 bool CompiledStaticCall::is_clean() const {
a61af66fc99e Initial load duke parents: diff changeset	546 return destination() == SharedRuntime::get_resolve_static_call_stub();
a61af66fc99e Initial load duke parents: diff changeset	547 }
a61af66fc99e Initial load duke parents: diff changeset	548
a61af66fc99e Initial load duke parents: diff changeset	549 bool CompiledStaticCall::is_call_to_compiled() const {
a61af66fc99e Initial load duke parents: diff changeset	550 return CodeCache::contains(destination());
a61af66fc99e Initial load duke parents: diff changeset	551 }
a61af66fc99e Initial load duke parents: diff changeset	552
a61af66fc99e Initial load duke parents: diff changeset	553
a61af66fc99e Initial load duke parents: diff changeset	554 bool CompiledStaticCall::is_call_to_interpreted() const {
a61af66fc99e Initial load duke parents: diff changeset	555 // It is a call to interpreted, if it calls to a stub. Hence, the destination
a61af66fc99e Initial load duke parents: diff changeset	556 // must be in the stub part of the nmethod that contains the call
a61af66fc99e Initial load duke parents: diff changeset	557 nmethod* nm = CodeCache::find_nmethod(instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	558 return nm->stub_contains(destination());
a61af66fc99e Initial load duke parents: diff changeset	559 }
a61af66fc99e Initial load duke parents: diff changeset	560
a61af66fc99e Initial load duke parents: diff changeset	561 void CompiledStaticCall::set(const StaticCallInfo& info) {
a61af66fc99e Initial load duke parents: diff changeset	562 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "mt unsafe call");
a61af66fc99e Initial load duke parents: diff changeset	563 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	564 // Updating a cache to the wrong entry can cause bugs that are very hard
a61af66fc99e Initial load duke parents: diff changeset	565 // to track down - if cache entry gets invalid - we just clean it. In
a61af66fc99e Initial load duke parents: diff changeset	566 // this way it is always the same code path that is responsible for
a61af66fc99e Initial load duke parents: diff changeset	567 // updating and resolving an inline cache
a61af66fc99e Initial load duke parents: diff changeset	568 assert(is_clean(), "do not update a call entry - use clean");
a61af66fc99e Initial load duke parents: diff changeset	569
a61af66fc99e Initial load duke parents: diff changeset	570 if (info._to_interpreter) {
a61af66fc99e Initial load duke parents: diff changeset	571 // Call to interpreted code
a61af66fc99e Initial load duke parents: diff changeset	572 set_to_interpreted(info.callee(), info.entry());
a61af66fc99e Initial load duke parents: diff changeset	573 } else {
a61af66fc99e Initial load duke parents: diff changeset	574 if (TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	575 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	576 tty->print_cr("CompiledStaticCall@" INTPTR_FORMAT ": set_to_compiled " INTPTR_FORMAT,
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 13441 diff changeset	577 p2i(instruction_address()),
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 13441 diff changeset	578 p2i(info.entry()));
0 a61af66fc99e Initial load duke parents: diff changeset	579 }
a61af66fc99e Initial load duke parents: diff changeset	580 // Call to compiled code
a61af66fc99e Initial load duke parents: diff changeset	581 assert (CodeCache::contains(info.entry()), "wrong entry point");
a61af66fc99e Initial load duke parents: diff changeset	582 set_destination_mt_safe(info.entry());
a61af66fc99e Initial load duke parents: diff changeset	583 }
a61af66fc99e Initial load duke parents: diff changeset	584 }
a61af66fc99e Initial load duke parents: diff changeset	585
a61af66fc99e Initial load duke parents: diff changeset	586
a61af66fc99e Initial load duke parents: diff changeset	587 // Compute settings for a CompiledStaticCall. Since we might have to set
a61af66fc99e Initial load duke parents: diff changeset	588 // the stub when calling to the interpreter, we need to return arguments.
a61af66fc99e Initial load duke parents: diff changeset	589 void CompiledStaticCall::compute_entry(methodHandle m, StaticCallInfo& info) {
a61af66fc99e Initial load duke parents: diff changeset	590 nmethod* m_code = m->code();
a61af66fc99e Initial load duke parents: diff changeset	591 info._callee = m;
13441 df832bd8edb9 8028107: Kitchensink crashed with EAV kvn parents: 12294 diff changeset	592 if (m_code != NULL && m_code->is_in_use()) {
0 a61af66fc99e Initial load duke parents: diff changeset	593 info._to_interpreter = false;
a61af66fc99e Initial load duke parents: diff changeset	594 info._entry = m_code->verified_entry_point();
a61af66fc99e Initial load duke parents: diff changeset	595 } else {
a61af66fc99e Initial load duke parents: diff changeset	596 // Callee is interpreted code. In any case entering the interpreter
a61af66fc99e Initial load duke parents: diff changeset	597 // puts a converter-frame on the stack to save arguments.
20432 aff6ccb506cb 8056154: JVM crash with EXCEPTION_ACCESS_VIOLATION when there are many threads running iveresov parents: 20278 diff changeset	598 assert(!m->is_method_handle_intrinsic(), "Compiled code should never call interpreter MH intrinsics");
0 a61af66fc99e Initial load duke parents: diff changeset	599 info._to_interpreter = true;
a61af66fc99e Initial load duke parents: diff changeset	600 info._entry = m()->get_c2i_entry();
a61af66fc99e Initial load duke parents: diff changeset	601 }
a61af66fc99e Initial load duke parents: diff changeset	602 }
a61af66fc99e Initial load duke parents: diff changeset	603
a61af66fc99e Initial load duke parents: diff changeset	604 address CompiledStaticCall::find_stub() {
a61af66fc99e Initial load duke parents: diff changeset	605 // Find reloc. information containing this call-site
a61af66fc99e Initial load duke parents: diff changeset	606 RelocIterator iter((nmethod*)NULL, instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	607 while (iter.next()) {
a61af66fc99e Initial load duke parents: diff changeset	608 if (iter.addr() == instruction_address()) {
a61af66fc99e Initial load duke parents: diff changeset	609 switch(iter.type()) {
a61af66fc99e Initial load duke parents: diff changeset	610 case relocInfo::static_call_type:
a61af66fc99e Initial load duke parents: diff changeset	611 return iter.static_call_reloc()->static_stub();
a61af66fc99e Initial load duke parents: diff changeset	612 // We check here for opt_virtual_call_type, since we reuse the code
a61af66fc99e Initial load duke parents: diff changeset	613 // from the CompiledIC implementation
a61af66fc99e Initial load duke parents: diff changeset	614 case relocInfo::opt_virtual_call_type:
a61af66fc99e Initial load duke parents: diff changeset	615 return iter.opt_virtual_call_reloc()->static_stub();
a61af66fc99e Initial load duke parents: diff changeset	616 case relocInfo::poll_type:
a61af66fc99e Initial load duke parents: diff changeset	617 case relocInfo::poll_return_type: // A safepoint can't overlap a call.
a61af66fc99e Initial load duke parents: diff changeset	618 default:
a61af66fc99e Initial load duke parents: diff changeset	619 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	620 }
a61af66fc99e Initial load duke parents: diff changeset	621 }
a61af66fc99e Initial load duke parents: diff changeset	622 }
a61af66fc99e Initial load duke parents: diff changeset	623 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	624 }
a61af66fc99e Initial load duke parents: diff changeset	625
a61af66fc99e Initial load duke parents: diff changeset	626
a61af66fc99e Initial load duke parents: diff changeset	627 //-----------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	628 // Non-product mode code
a61af66fc99e Initial load duke parents: diff changeset	629 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	630
a61af66fc99e Initial load duke parents: diff changeset	631 void CompiledIC::verify() {
a61af66fc99e Initial load duke parents: diff changeset	632 // make sure code pattern is actually a call imm32 instruction
a61af66fc99e Initial load duke parents: diff changeset	633 _ic_call->verify();
a61af66fc99e Initial load duke parents: diff changeset	634 if (os::is_MP()) {
a61af66fc99e Initial load duke parents: diff changeset	635 _ic_call->verify_alignment();
a61af66fc99e Initial load duke parents: diff changeset	636 }
a61af66fc99e Initial load duke parents: diff changeset	637 assert(is_clean() \|\| is_call_to_compiled() \|\| is_call_to_interpreted()
a61af66fc99e Initial load duke parents: diff changeset	638 \|\| is_optimized() \|\| is_megamorphic(), "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	639 }
a61af66fc99e Initial load duke parents: diff changeset	640
a61af66fc99e Initial load duke parents: diff changeset	641 void CompiledIC::print() {
a61af66fc99e Initial load duke parents: diff changeset	642 print_compiled_ic();
a61af66fc99e Initial load duke parents: diff changeset	643 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	644 }
a61af66fc99e Initial load duke parents: diff changeset	645
a61af66fc99e Initial load duke parents: diff changeset	646 void CompiledIC::print_compiled_ic() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	647 tty->print("Inline cache at " INTPTR_FORMAT ", calling %s " INTPTR_FORMAT " cached_value " INTPTR_FORMAT,
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 13441 diff changeset	648 p2i(instruction_address()), is_call_to_interpreted() ? "interpreted " : "", p2i(ic_destination()), p2i(is_optimized() ? NULL : cached_value()));
0 a61af66fc99e Initial load duke parents: diff changeset	649 }
a61af66fc99e Initial load duke parents: diff changeset	650
a61af66fc99e Initial load duke parents: diff changeset	651 void CompiledStaticCall::print() {
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 13441 diff changeset	652 tty->print("static call at " INTPTR_FORMAT " -> ", p2i(instruction_address()));
0 a61af66fc99e Initial load duke parents: diff changeset	653 if (is_clean()) {
a61af66fc99e Initial load duke parents: diff changeset	654 tty->print("clean");
a61af66fc99e Initial load duke parents: diff changeset	655 } else if (is_call_to_compiled()) {
a61af66fc99e Initial load duke parents: diff changeset	656 tty->print("compiled");
a61af66fc99e Initial load duke parents: diff changeset	657 } else if (is_call_to_interpreted()) {
a61af66fc99e Initial load duke parents: diff changeset	658 tty->print("interpreted");
a61af66fc99e Initial load duke parents: diff changeset	659 }
a61af66fc99e Initial load duke parents: diff changeset	660 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	661 }
a61af66fc99e Initial load duke parents: diff changeset	662
10168 a6e09d6dd8e5 8003853: specify offset of IC load in java_to_interp stub dlong parents: 8776 diff changeset	663 #endif // !PRODUCT

Mercurial > hg > truffle

annotate src/share/vm/code/compiledIC.cpp @ 20432:aff6ccb506cb