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

annotate src/share/vm/code/compiledIC.cpp @ 6725:da91efe96a93

6964458: Reimplement class meta-data storage to use native memory Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>

author	coleenp
date	Sat, 01 Sep 2012 13:25:18 -0400
parents	aa3d708d67c4
children	18fb7da42534

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
4872 aa3d708d67c4 7141200: log some interesting information in ring buffers for crashes never parents: 2426 diff changeset	2 * Copyright (c) 1997, 2012, 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
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	48
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	49 // Release the CompiledICHolder* associated with this call site is there is one.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	50 void CompiledIC::cleanup_call_site(virtual_call_Relocation* call_site) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	51 // This call site might have become stale so inspect it carefully.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	52 NativeCall* call = nativeCall_at(call_site->addr());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	53 if (is_icholder_entry(call->destination())) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	54 NativeMovConstReg* value = nativeMovConstReg_at(call_site->cached_value());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	55 InlineCacheBuffer::queue_for_release((CompiledICHolder*)value->data());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	56 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	57 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	58
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	59
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	60 bool CompiledIC::is_icholder_call_site(virtual_call_Relocation* call_site) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	61 // This call site might have become stale so inspect it carefully.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	62 NativeCall* call = nativeCall_at(call_site->addr());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	63 return is_icholder_entry(call->destination());
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
0 a61af66fc99e Initial load duke parents: diff changeset	67 //-----------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	68 // Low-level access to an inline cache. Private, since they might not be
a61af66fc99e Initial load duke parents: diff changeset	69 // MT-safe to use.
a61af66fc99e Initial load duke parents: diff changeset	70
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	71 void* CompiledIC::cached_value() const {
0 a61af66fc99e Initial load duke parents: diff changeset	72 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	73 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	74
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	75 if (!is_in_transition_state()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	76 void* data = (void*)_value->data();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	77 // 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	78 assert(data != NULL \|\| Universe::non_oop_word() == NULL,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	79 "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	80 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	81 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	82 return InlineCacheBuffer::cached_value_for((CompiledIC *)this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	83 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	84 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	85
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	86
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	87 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	88 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	89 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	90 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	91 assert (cache == NULL \|\| cache != (Metadata*)badOopVal, "invalid metadata");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	92
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	93 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	94
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	95 // 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	96 // 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	97 // the CompiledIC.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	98 if (is_icholder_entry(_ic_call->destination())) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	99 // 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	100 // 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	101 // 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	102 // 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	103 // once the entry point is overwritten.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	104 InlineCacheBuffer::queue_for_release((CompiledICHolder*)_value->data());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	105 }
0 a61af66fc99e Initial load duke parents: diff changeset	106
a61af66fc99e Initial load duke parents: diff changeset	107 if (TraceCompiledIC) {
a61af66fc99e Initial load duke parents: diff changeset	108 tty->print(" ");
a61af66fc99e Initial load duke parents: diff changeset	109 print_compiled_ic();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	110 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	111 if (!is_optimized()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	112 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	113 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	114 if (is_icstub) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	115 tty->print(" (icstub)");
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 tty->cr();
0 a61af66fc99e Initial load duke parents: diff changeset	118 }
a61af66fc99e Initial load duke parents: diff changeset	119
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	120 {
0 a61af66fc99e Initial load duke parents: diff changeset	121 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	122 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	123 CodeBlob* cb = CodeCache::find_blob_unsafe(_ic_call);
a61af66fc99e Initial load duke parents: diff changeset	124 assert(cb != NULL && cb->is_nmethod(), "must be nmethod");
a61af66fc99e Initial load duke parents: diff changeset	125 #endif
a61af66fc99e Initial load duke parents: diff changeset	126 _ic_call->set_destination_mt_safe(entry_point);
a61af66fc99e Initial load duke parents: diff changeset	127 }
a61af66fc99e Initial load duke parents: diff changeset	128
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	129 if (is_optimized() \|\| is_icstub) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	130 // 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	131 // 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	132 // case could lead to MT safety issues.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	133 assert(cache == NULL, "must be null");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	134 return;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	135 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	136
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	137 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	138
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	139 _value->set_data((intptr_t)cache);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	140 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	141
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	142
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	143 void CompiledIC::set_ic_destination(ICStub* stub) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	144 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	145 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	146
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	147
0 a61af66fc99e Initial load duke parents: diff changeset	148
a61af66fc99e Initial load duke parents: diff changeset	149 address CompiledIC::ic_destination() const {
a61af66fc99e Initial load duke parents: diff changeset	150 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	151 if (!is_in_transition_state()) {
a61af66fc99e Initial load duke parents: diff changeset	152 return _ic_call->destination();
a61af66fc99e Initial load duke parents: diff changeset	153 } else {
a61af66fc99e Initial load duke parents: diff changeset	154 return InlineCacheBuffer::ic_destination_for((CompiledIC *)this);
a61af66fc99e Initial load duke parents: diff changeset	155 }
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 bool CompiledIC::is_in_transition_state() const {
a61af66fc99e Initial load duke parents: diff changeset	160 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	161 return InlineCacheBuffer::contains(_ic_call->destination());
a61af66fc99e Initial load duke parents: diff changeset	162 }
a61af66fc99e Initial load duke parents: diff changeset	163
a61af66fc99e Initial load duke parents: diff changeset	164
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	165 bool CompiledIC::is_icholder_call() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	166 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	167 return !_is_optimized && is_icholder_entry(ic_destination());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	168 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	169
0 a61af66fc99e Initial load duke parents: diff changeset	170 // Returns native address of 'call' instruction in inline-cache. Used by
a61af66fc99e Initial load duke parents: diff changeset	171 // the InlineCacheBuffer when it needs to find the stub.
a61af66fc99e Initial load duke parents: diff changeset	172 address CompiledIC::stub_address() const {
a61af66fc99e Initial load duke parents: diff changeset	173 assert(is_in_transition_state(), "should only be called when we are in a transition state");
a61af66fc99e Initial load duke parents: diff changeset	174 return _ic_call->destination();
a61af66fc99e Initial load duke parents: diff changeset	175 }
a61af66fc99e Initial load duke parents: diff changeset	176
a61af66fc99e Initial load duke parents: diff changeset	177
a61af66fc99e Initial load duke parents: diff changeset	178 //-----------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	179 // High-level access to an inline cache. Guaranteed to be MT-safe.
a61af66fc99e Initial load duke parents: diff changeset	180
a61af66fc99e Initial load duke parents: diff changeset	181
a61af66fc99e Initial load duke parents: diff changeset	182 void CompiledIC::set_to_megamorphic(CallInfo* call_info, Bytecodes::Code bytecode, TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	183 methodHandle method = call_info->selected_method();
a61af66fc99e Initial load duke parents: diff changeset	184 bool is_invoke_interface = (bytecode == Bytecodes::_invokeinterface && !call_info->has_vtable_index());
a61af66fc99e Initial load duke parents: diff changeset	185 assert(CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	186 assert(!is_optimized(), "cannot set an optimized virtual call to megamorphic");
a61af66fc99e Initial load duke parents: diff changeset	187 assert(is_call_to_compiled() \|\| is_call_to_interpreted(), "going directly to megamorphic?");
a61af66fc99e Initial load duke parents: diff changeset	188
a61af66fc99e Initial load duke parents: diff changeset	189 address entry;
a61af66fc99e Initial load duke parents: diff changeset	190 if (is_invoke_interface) {
a61af66fc99e Initial load duke parents: diff changeset	191 int index = klassItable::compute_itable_index(call_info->resolved_method()());
a61af66fc99e Initial load duke parents: diff changeset	192 entry = VtableStubs::create_stub(false, index, method());
a61af66fc99e Initial load duke parents: diff changeset	193 assert(entry != NULL, "entry not computed");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	194 Klass* k = call_info->resolved_method()->method_holder();
0 a61af66fc99e Initial load duke parents: diff changeset	195 assert(Klass::cast(k)->is_interface(), "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	196 InlineCacheBuffer::create_transition_stub(this, k, entry);
a61af66fc99e Initial load duke parents: diff changeset	197 } else {
a61af66fc99e Initial load duke parents: diff changeset	198 // Can be different than method->vtable_index(), due to package-private etc.
a61af66fc99e Initial load duke parents: diff changeset	199 int vtable_index = call_info->vtable_index();
a61af66fc99e Initial load duke parents: diff changeset	200 entry = VtableStubs::create_stub(true, vtable_index, method());
a61af66fc99e Initial load duke parents: diff changeset	201 InlineCacheBuffer::create_transition_stub(this, method(), entry);
a61af66fc99e Initial load duke parents: diff changeset	202 }
a61af66fc99e Initial load duke parents: diff changeset	203
a61af66fc99e Initial load duke parents: diff changeset	204 if (TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	205 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	206 tty->print_cr ("IC@" INTPTR_FORMAT ": to megamorphic %s entry: " INTPTR_FORMAT,
a61af66fc99e Initial load duke parents: diff changeset	207 instruction_address(), method->print_value_string(), entry);
a61af66fc99e Initial load duke parents: diff changeset	208 }
a61af66fc99e Initial load duke parents: diff changeset	209
a61af66fc99e Initial load duke parents: diff changeset	210 // We can't check this anymore. With lazy deopt we could have already
a61af66fc99e Initial load duke parents: diff changeset	211 // cleaned this IC entry before we even return. This is possible if
a61af66fc99e Initial load duke parents: diff changeset	212 // we ran out of space in the inline cache buffer trying to do the
a61af66fc99e Initial load duke parents: diff changeset	213 // set_next and we safepointed to free up space. This is a benign
a61af66fc99e Initial load duke parents: diff changeset	214 // race because the IC entry was complete when we safepointed so
a61af66fc99e Initial load duke parents: diff changeset	215 // cleaning it immediately is harmless.
a61af66fc99e Initial load duke parents: diff changeset	216 // assert(is_megamorphic(), "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	217 }
a61af66fc99e Initial load duke parents: diff changeset	218
a61af66fc99e Initial load duke parents: diff changeset	219
a61af66fc99e Initial load duke parents: diff changeset	220 // true if destination is megamorphic stub
a61af66fc99e Initial load duke parents: diff changeset	221 bool CompiledIC::is_megamorphic() 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 assert(!is_optimized(), "an optimized call cannot be megamorphic");
a61af66fc99e Initial load duke parents: diff changeset	224
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	225 // Cannot rely on cached_value. It is either an interface or a method.
0 a61af66fc99e Initial load duke parents: diff changeset	226 return VtableStubs::is_entry_point(ic_destination());
a61af66fc99e Initial load duke parents: diff changeset	227 }
a61af66fc99e Initial load duke parents: diff changeset	228
a61af66fc99e Initial load duke parents: diff changeset	229 bool CompiledIC::is_call_to_compiled() const {
a61af66fc99e Initial load duke parents: diff changeset	230 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	231
a61af66fc99e Initial load duke parents: diff changeset	232 // Use unsafe, since an inline cache might point to a zombie method. However, the zombie
a61af66fc99e Initial load duke parents: diff changeset	233 // method is guaranteed to still exist, since we only remove methods after all inline caches
a61af66fc99e Initial load duke parents: diff changeset	234 // has been cleaned up
a61af66fc99e Initial load duke parents: diff changeset	235 CodeBlob* cb = CodeCache::find_blob_unsafe(ic_destination());
a61af66fc99e Initial load duke parents: diff changeset	236 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	237 // Check that the cached_value is a klass for non-optimized monomorphic calls
0 a61af66fc99e Initial load duke parents: diff changeset	238 // 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	239 // for calling directly to vep without using the inline cache (i.e., cached_value == NULL)
0 a61af66fc99e Initial load duke parents: diff changeset	240 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	241 CodeBlob* caller = CodeCache::find_blob_unsafe(instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	242 bool is_c1_method = caller->is_compiled_by_c1();
a61af66fc99e Initial load duke parents: diff changeset	243 assert( is_c1_method \|\|
a61af66fc99e Initial load duke parents: diff changeset	244 !is_monomorphic \|\|
a61af66fc99e Initial load duke parents: diff changeset	245 is_optimized() \|\|
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	246 (cached_metadata() != NULL && cached_metadata()->is_klass()), "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	247 #endif // ASSERT
a61af66fc99e Initial load duke parents: diff changeset	248 return is_monomorphic;
a61af66fc99e Initial load duke parents: diff changeset	249 }
a61af66fc99e Initial load duke parents: diff changeset	250
a61af66fc99e Initial load duke parents: diff changeset	251
a61af66fc99e Initial load duke parents: diff changeset	252 bool CompiledIC::is_call_to_interpreted() const {
a61af66fc99e Initial load duke parents: diff changeset	253 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	254 // Call to interpreter if destination is either calling to a stub (if it
a61af66fc99e Initial load duke parents: diff changeset	255 // is optimized), or calling to an I2C blob
a61af66fc99e Initial load duke parents: diff changeset	256 bool is_call_to_interpreted = false;
a61af66fc99e Initial load duke parents: diff changeset	257 if (!is_optimized()) {
a61af66fc99e Initial load duke parents: diff changeset	258 // must use unsafe because the destination can be a zombie (and we're cleaning)
a61af66fc99e Initial load duke parents: diff changeset	259 // and the print_compiled_ic code wants to know if site (in the non-zombie)
a61af66fc99e Initial load duke parents: diff changeset	260 // is to the interpreter.
a61af66fc99e Initial load duke parents: diff changeset	261 CodeBlob* cb = CodeCache::find_blob_unsafe(ic_destination());
a61af66fc99e Initial load duke parents: diff changeset	262 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	263 assert(!is_call_to_interpreted \|\| (is_icholder_call() && cached_icholder() != NULL), "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	264 } else {
a61af66fc99e Initial load duke parents: diff changeset	265 // Check if we are calling into our own codeblob (i.e., to a stub)
a61af66fc99e Initial load duke parents: diff changeset	266 CodeBlob* cb = CodeCache::find_blob(_ic_call->instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	267 address dest = ic_destination();
a61af66fc99e Initial load duke parents: diff changeset	268 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	269 {
a61af66fc99e Initial load duke parents: diff changeset	270 CodeBlob* db = CodeCache::find_blob_unsafe(dest);
a61af66fc99e Initial load duke parents: diff changeset	271 assert(!db->is_adapter_blob(), "must use stub!");
a61af66fc99e Initial load duke parents: diff changeset	272 }
a61af66fc99e Initial load duke parents: diff changeset	273 #endif /* ASSERT */
a61af66fc99e Initial load duke parents: diff changeset	274 is_call_to_interpreted = cb->contains(dest);
a61af66fc99e Initial load duke parents: diff changeset	275 }
a61af66fc99e Initial load duke parents: diff changeset	276 return is_call_to_interpreted;
a61af66fc99e Initial load duke parents: diff changeset	277 }
a61af66fc99e Initial load duke parents: diff changeset	278
a61af66fc99e Initial load duke parents: diff changeset	279
a61af66fc99e Initial load duke parents: diff changeset	280 void CompiledIC::set_to_clean() {
a61af66fc99e Initial load duke parents: diff changeset	281 assert(SafepointSynchronize::is_at_safepoint() \|\| CompiledIC_lock->is_locked() , "MT-unsafe call");
a61af66fc99e Initial load duke parents: diff changeset	282 if (TraceInlineCacheClearing \|\| TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	283 tty->print_cr("IC@" INTPTR_FORMAT ": set to clean", instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	284 print();
a61af66fc99e Initial load duke parents: diff changeset	285 }
a61af66fc99e Initial load duke parents: diff changeset	286
a61af66fc99e Initial load duke parents: diff changeset	287 address entry;
a61af66fc99e Initial load duke parents: diff changeset	288 if (is_optimized()) {
a61af66fc99e Initial load duke parents: diff changeset	289 entry = SharedRuntime::get_resolve_opt_virtual_call_stub();
a61af66fc99e Initial load duke parents: diff changeset	290 } else {
a61af66fc99e Initial load duke parents: diff changeset	291 entry = SharedRuntime::get_resolve_virtual_call_stub();
a61af66fc99e Initial load duke parents: diff changeset	292 }
a61af66fc99e Initial load duke parents: diff changeset	293
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	294 // 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	295 // we only need to patch the destination
a61af66fc99e Initial load duke parents: diff changeset	296 bool safe_transition = is_optimized() \|\| SafepointSynchronize::is_at_safepoint();
a61af66fc99e Initial load duke parents: diff changeset	297
a61af66fc99e Initial load duke parents: diff changeset	298 if (safe_transition) {
a61af66fc99e Initial load duke parents: diff changeset	299 // Kill any leftover stub we might have too
a61af66fc99e Initial load duke parents: diff changeset	300 if (is_in_transition_state()) {
a61af66fc99e Initial load duke parents: diff changeset	301 ICStub* old_stub = ICStub_from_destination_address(stub_address());
a61af66fc99e Initial load duke parents: diff changeset	302 old_stub->clear();
a61af66fc99e Initial load duke parents: diff changeset	303 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	304 if (is_optimized()) {
0 a61af66fc99e Initial load duke parents: diff changeset	305 set_ic_destination(entry);
a61af66fc99e Initial load duke parents: diff changeset	306 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	307 set_ic_destination_and_value(entry, (void*)NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	308 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	309 } else {
0 a61af66fc99e Initial load duke parents: diff changeset	310 // Unsafe transition - create stub.
a61af66fc99e Initial load duke parents: diff changeset	311 InlineCacheBuffer::create_transition_stub(this, NULL, entry);
a61af66fc99e Initial load duke parents: diff changeset	312 }
a61af66fc99e Initial load duke parents: diff changeset	313 // We can't check this anymore. With lazy deopt we could have already
a61af66fc99e Initial load duke parents: diff changeset	314 // cleaned this IC entry before we even return. This is possible if
a61af66fc99e Initial load duke parents: diff changeset	315 // we ran out of space in the inline cache buffer trying to do the
a61af66fc99e Initial load duke parents: diff changeset	316 // set_next and we safepointed to free up space. This is a benign
a61af66fc99e Initial load duke parents: diff changeset	317 // race because the IC entry was complete when we safepointed so
a61af66fc99e Initial load duke parents: diff changeset	318 // cleaning it immediately is harmless.
a61af66fc99e Initial load duke parents: diff changeset	319 // assert(is_clean(), "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	320 }
a61af66fc99e Initial load duke parents: diff changeset	321
a61af66fc99e Initial load duke parents: diff changeset	322
a61af66fc99e Initial load duke parents: diff changeset	323 bool CompiledIC::is_clean() const {
a61af66fc99e Initial load duke parents: diff changeset	324 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	325 bool is_clean = false;
a61af66fc99e Initial load duke parents: diff changeset	326 address dest = ic_destination();
a61af66fc99e Initial load duke parents: diff changeset	327 is_clean = dest == SharedRuntime::get_resolve_opt_virtual_call_stub() \|\|
a61af66fc99e Initial load duke parents: diff changeset	328 dest == SharedRuntime::get_resolve_virtual_call_stub();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	329 assert(!is_clean \|\| is_optimized() \|\| cached_value() == NULL, "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	330 return is_clean;
a61af66fc99e Initial load duke parents: diff changeset	331 }
a61af66fc99e Initial load duke parents: diff changeset	332
a61af66fc99e Initial load duke parents: diff changeset	333
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	334 void CompiledIC::set_to_monomorphic(CompiledICInfo& info) {
0 a61af66fc99e Initial load duke parents: diff changeset	335 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load duke parents: diff changeset	336 // Updating a cache to the wrong entry can cause bugs that are very hard
a61af66fc99e Initial load duke parents: diff changeset	337 // to track down - if cache entry gets invalid - we just clean it. In
a61af66fc99e Initial load duke parents: diff changeset	338 // this way it is always the same code path that is responsible for
a61af66fc99e Initial load duke parents: diff changeset	339 // updating and resolving an inline cache
a61af66fc99e Initial load duke parents: diff changeset	340 //
a61af66fc99e Initial load duke parents: diff changeset	341 // The above is no longer true. SharedRuntime::fixup_callers_callsite will change optimized
a61af66fc99e Initial load duke parents: diff changeset	342 // callsites. In addition ic_miss code will update a site to monomorphic if it determines
a61af66fc99e Initial load duke parents: diff changeset	343 // that an monomorphic call to the interpreter can now be monomorphic to compiled code.
a61af66fc99e Initial load duke parents: diff changeset	344 //
a61af66fc99e Initial load duke parents: diff changeset	345 // In both of these cases the only thing being modifed is the jump/call target and these
a61af66fc99e Initial load duke parents: diff changeset	346 // transitions are mt_safe
a61af66fc99e Initial load duke parents: diff changeset	347
a61af66fc99e Initial load duke parents: diff changeset	348 Thread *thread = Thread::current();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	349 if (info.to_interpreter()) {
0 a61af66fc99e Initial load duke parents: diff changeset	350 // Call to interpreter
a61af66fc99e Initial load duke parents: diff changeset	351 if (info.is_optimized() && is_optimized()) {
a61af66fc99e Initial load duke parents: diff changeset	352 assert(is_clean(), "unsafe IC path");
a61af66fc99e Initial load duke parents: diff changeset	353 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	354 // the call analysis (callee structure) specifies that the call is optimized
a61af66fc99e Initial load duke parents: diff changeset	355 // (either because of CHA or the static target is final)
a61af66fc99e Initial load duke parents: diff changeset	356 // At code generation time, this call has been emitted as static call
a61af66fc99e Initial load duke parents: diff changeset	357 // Call via stub
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	358 assert(info.cached_metadata() != NULL && info.cached_metadata()->is_method(), "sanity check");
0 a61af66fc99e Initial load duke parents: diff changeset	359 CompiledStaticCall* csc = compiledStaticCall_at(instruction_address());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	360 methodHandle method (thread, (Method*)info.cached_metadata());
0 a61af66fc99e Initial load duke parents: diff changeset	361 csc->set_to_interpreted(method, info.entry());
a61af66fc99e Initial load duke parents: diff changeset	362 if (TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	363 ResourceMark rm(thread);
a61af66fc99e Initial load duke parents: diff changeset	364 tty->print_cr ("IC@" INTPTR_FORMAT ": monomorphic to interpreter: %s",
a61af66fc99e Initial load duke parents: diff changeset	365 instruction_address(),
a61af66fc99e Initial load duke parents: diff changeset	366 method->print_value_string());
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 via method-klass-holder
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	370 InlineCacheBuffer::create_transition_stub(this, info.claim_cached_icholder(), info.entry());
0 a61af66fc99e Initial load duke parents: diff changeset	371 if (TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	372 ResourceMark rm(thread);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	373 tty->print_cr ("IC@" INTPTR_FORMAT ": monomorphic to interpreter via icholder ", instruction_address());
0 a61af66fc99e Initial load duke parents: diff changeset	374 }
a61af66fc99e Initial load duke parents: diff changeset	375 }
a61af66fc99e Initial load duke parents: diff changeset	376 } else {
a61af66fc99e Initial load duke parents: diff changeset	377 // Call to compiled code
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	378 bool static_bound = info.is_optimized() \|\| (info.cached_metadata() == NULL);
0 a61af66fc99e Initial load duke parents: diff changeset	379 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	380 CodeBlob* cb = CodeCache::find_blob_unsafe(info.entry());
a61af66fc99e Initial load duke parents: diff changeset	381 assert (cb->is_nmethod(), "must be compiled!");
a61af66fc99e Initial load duke parents: diff changeset	382 #endif /* ASSERT */
a61af66fc99e Initial load duke parents: diff changeset	383
a61af66fc99e Initial load duke parents: diff changeset	384 // This is MT safe if we come from a clean-cache and go through a
a61af66fc99e Initial load duke parents: diff changeset	385 // non-verified entry point
a61af66fc99e Initial load duke parents: diff changeset	386 bool safe = SafepointSynchronize::is_at_safepoint() \|\|
a61af66fc99e Initial load duke parents: diff changeset	387 (!is_in_transition_state() && (info.is_optimized() \|\| static_bound \|\| is_clean()));
a61af66fc99e Initial load duke parents: diff changeset	388
a61af66fc99e Initial load duke parents: diff changeset	389 if (!safe) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	390 InlineCacheBuffer::create_transition_stub(this, info.cached_metadata(), info.entry());
0 a61af66fc99e Initial load duke parents: diff changeset	391 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	392 if (is_optimized()) {
0 a61af66fc99e Initial load duke parents: diff changeset	393 set_ic_destination(info.entry());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	394 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	395 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	396 }
0 a61af66fc99e Initial load duke parents: diff changeset	397 }
a61af66fc99e Initial load duke parents: diff changeset	398
a61af66fc99e Initial load duke parents: diff changeset	399 if (TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	400 ResourceMark rm(thread);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	401 assert(info.cached_metadata() == NULL \|\| info.cached_metadata()->is_klass(), "must be");
0 a61af66fc99e Initial load duke parents: diff changeset	402 tty->print_cr ("IC@" INTPTR_FORMAT ": monomorphic to compiled (rcvr klass) %s: %s",
a61af66fc99e Initial load duke parents: diff changeset	403 instruction_address(),
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	404 ((Klass*)info.cached_metadata())->print_value_string(),
0 a61af66fc99e Initial load duke parents: diff changeset	405 (safe) ? "" : "via stub");
a61af66fc99e Initial load duke parents: diff changeset	406 }
a61af66fc99e Initial load duke parents: diff changeset	407 }
a61af66fc99e Initial load duke parents: diff changeset	408 // We can't check this anymore. With lazy deopt we could have already
a61af66fc99e Initial load duke parents: diff changeset	409 // cleaned this IC entry before we even return. This is possible if
a61af66fc99e Initial load duke parents: diff changeset	410 // we ran out of space in the inline cache buffer trying to do the
a61af66fc99e Initial load duke parents: diff changeset	411 // set_next and we safepointed to free up space. This is a benign
a61af66fc99e Initial load duke parents: diff changeset	412 // race because the IC entry was complete when we safepointed so
a61af66fc99e Initial load duke parents: diff changeset	413 // cleaning it immediately is harmless.
a61af66fc99e Initial load duke parents: diff changeset	414 // assert(is_call_to_compiled() \|\| is_call_to_interpreted(), "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	415 }
a61af66fc99e Initial load duke parents: diff changeset	416
a61af66fc99e Initial load duke parents: diff changeset	417
a61af66fc99e Initial load duke parents: diff changeset	418 // is_optimized: Compiler has generated an optimized call (i.e., no inline
a61af66fc99e Initial load duke parents: diff changeset	419 // cache) static_bound: The call can be static bound (i.e, no need to use
a61af66fc99e Initial load duke parents: diff changeset	420 // inline cache)
a61af66fc99e Initial load duke parents: diff changeset	421 void CompiledIC::compute_monomorphic_entry(methodHandle method,
a61af66fc99e Initial load duke parents: diff changeset	422 KlassHandle receiver_klass,
a61af66fc99e Initial load duke parents: diff changeset	423 bool is_optimized,
a61af66fc99e Initial load duke parents: diff changeset	424 bool static_bound,
a61af66fc99e Initial load duke parents: diff changeset	425 CompiledICInfo& info,
a61af66fc99e Initial load duke parents: diff changeset	426 TRAPS) {
a61af66fc99e Initial load duke parents: diff changeset	427 nmethod* method_code = method->code();
a61af66fc99e Initial load duke parents: diff changeset	428 address entry = NULL;
a61af66fc99e Initial load duke parents: diff changeset	429 if (method_code != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	430 // Call to compiled code
a61af66fc99e Initial load duke parents: diff changeset	431 if (static_bound \|\| is_optimized) {
a61af66fc99e Initial load duke parents: diff changeset	432 entry = method_code->verified_entry_point();
a61af66fc99e Initial load duke parents: diff changeset	433 } else {
a61af66fc99e Initial load duke parents: diff changeset	434 entry = method_code->entry_point();
a61af66fc99e Initial load duke parents: diff changeset	435 }
a61af66fc99e Initial load duke parents: diff changeset	436 }
a61af66fc99e Initial load duke parents: diff changeset	437 if (entry != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	438 // Call to compiled code
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	439 info.set_compiled_entry(entry, (static_bound \|\| is_optimized) ? NULL : receiver_klass(), is_optimized);
0 a61af66fc99e Initial load duke parents: diff changeset	440 } else {
a61af66fc99e Initial load duke parents: diff changeset	441 // Note: the following problem exists with Compiler1:
a61af66fc99e Initial load duke parents: diff changeset	442 // - at compile time we may or may not know if the destination is final
a61af66fc99e Initial load duke parents: diff changeset	443 // - 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	444 // virtual call (no inline cache), and need a Method* to make a call
0 a61af66fc99e Initial load duke parents: diff changeset	445 // to the interpreter
a61af66fc99e Initial load duke parents: diff changeset	446 // - if we do not know if the destination is final, we emit a standard
a61af66fc99e Initial load duke parents: diff changeset	447 // virtual call, and use CompiledICHolder to call interpreted code
a61af66fc99e Initial load duke parents: diff changeset	448 // (no static call stub has been generated)
a61af66fc99e Initial load duke parents: diff changeset	449 // However in that case we will now notice it is static_bound
a61af66fc99e Initial load duke parents: diff changeset	450 // and convert the call into what looks to be an optimized
a61af66fc99e Initial load duke parents: diff changeset	451 // virtual call. This causes problems in verifying the IC because
a61af66fc99e Initial load duke parents: diff changeset	452 // it look vanilla but is optimized. Code in is_call_to_interpreted
a61af66fc99e Initial load duke parents: diff changeset	453 // is aware of this and weakens its asserts.
a61af66fc99e Initial load duke parents: diff changeset	454
a61af66fc99e Initial load duke parents: diff changeset	455 // static_bound should imply is_optimized -- otherwise we have a
a61af66fc99e Initial load duke parents: diff changeset	456 // performance bug (statically-bindable method is called via
a61af66fc99e Initial load duke parents: diff changeset	457 // dynamically-dispatched call note: the reverse implication isn't
a61af66fc99e Initial load duke parents: diff changeset	458 // necessarily true -- the call may have been optimized based on compiler
a61af66fc99e Initial load duke parents: diff changeset	459 // analysis (static_bound is only based on "final" etc.)
a61af66fc99e Initial load duke parents: diff changeset	460 #ifdef COMPILER2
a61af66fc99e Initial load duke parents: diff changeset	461 #ifdef TIERED
a61af66fc99e Initial load duke parents: diff changeset	462 #if defined(ASSERT)
a61af66fc99e Initial load duke parents: diff changeset	463 // can't check the assert because we don't have the CompiledIC with which to
a61af66fc99e Initial load duke parents: diff changeset	464 // find the address if the call instruction.
a61af66fc99e Initial load duke parents: diff changeset	465 //
a61af66fc99e Initial load duke parents: diff changeset	466 // CodeBlob* cb = find_blob_unsafe(instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	467 // assert(cb->is_compiled_by_c1() \|\| !static_bound \|\| is_optimized, "static_bound should imply is_optimized");
a61af66fc99e Initial load duke parents: diff changeset	468 #endif // ASSERT
a61af66fc99e Initial load duke parents: diff changeset	469 #else
a61af66fc99e Initial load duke parents: diff changeset	470 assert(!static_bound \|\| is_optimized, "static_bound should imply is_optimized");
a61af66fc99e Initial load duke parents: diff changeset	471 #endif // TIERED
a61af66fc99e Initial load duke parents: diff changeset	472 #endif // COMPILER2
a61af66fc99e Initial load duke parents: diff changeset	473 if (is_optimized) {
a61af66fc99e Initial load duke parents: diff changeset	474 // Use stub entry
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	475 info.set_interpreter_entry(method()->get_c2i_entry(), method());
0 a61af66fc99e Initial load duke parents: diff changeset	476 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	477 // Use icholder entry
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	478 CompiledICHolder* holder = new CompiledICHolder(method(), receiver_klass());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	479 info.set_icholder_entry(method()->get_c2i_unverified_entry(), holder);
0 a61af66fc99e Initial load duke parents: diff changeset	480 }
a61af66fc99e Initial load duke parents: diff changeset	481 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	482 assert(info.is_optimized() == is_optimized, "must agree");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	483 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	484
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	485
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	486 bool CompiledIC::is_icholder_entry(address entry) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	487 CodeBlob* cb = CodeCache::find_blob_unsafe(entry);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	488 return (cb != NULL && cb->is_adapter_blob());
0 a61af66fc99e Initial load duke parents: diff changeset	489 }
a61af66fc99e Initial load duke parents: diff changeset	490
a61af66fc99e Initial load duke parents: diff changeset	491
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	492 CompiledIC::CompiledIC(nmethod* nm, NativeCall* call)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	493 : _ic_call(call)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	494 {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	495 address ic_call = call->instruction_address();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	496
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	497 assert(ic_call != NULL, "ic_call address must be set");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	498 assert(nm != NULL, "must pass nmethod");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	499 assert(nm->contains(ic_call), "must be in nmethod");
0 a61af66fc99e Initial load duke parents: diff changeset	500
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	501 // search for the ic_call at the given address
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	502 RelocIterator iter(nm, ic_call, ic_call+1);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	503 bool ret = iter.next();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	504 assert(ret == true, "relocInfo must exist at this address");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	505 assert(iter.addr() == ic_call, "must find ic_call");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	506 if (iter.type() == relocInfo::virtual_call_type) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	507 virtual_call_Relocation* r = iter.virtual_call_reloc();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	508 _is_optimized = false;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	509 _value = nativeMovConstReg_at(r->cached_value());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	510 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	511 assert(iter.type() == relocInfo::opt_virtual_call_type, "must be a virtual call");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	512 _is_optimized = true;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	513 _value = NULL;
0 a61af66fc99e Initial load duke parents: diff changeset	514 }
a61af66fc99e Initial load duke parents: diff changeset	515 }
a61af66fc99e Initial load duke parents: diff changeset	516
a61af66fc99e Initial load duke parents: diff changeset	517
a61af66fc99e Initial load duke parents: diff changeset	518 // ----------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	519
a61af66fc99e Initial load duke parents: diff changeset	520 void CompiledStaticCall::set_to_clean() {
a61af66fc99e Initial load duke parents: diff changeset	521 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "mt unsafe call");
a61af66fc99e Initial load duke parents: diff changeset	522 // Reset call site
a61af66fc99e Initial load duke parents: diff changeset	523 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	524 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	525 CodeBlob* cb = CodeCache::find_blob_unsafe(this);
a61af66fc99e Initial load duke parents: diff changeset	526 assert(cb != NULL && cb->is_nmethod(), "must be nmethod");
a61af66fc99e Initial load duke parents: diff changeset	527 #endif
a61af66fc99e Initial load duke parents: diff changeset	528 set_destination_mt_safe(SharedRuntime::get_resolve_static_call_stub());
a61af66fc99e Initial load duke parents: diff changeset	529
a61af66fc99e Initial load duke parents: diff changeset	530 // Do not reset stub here: It is too expensive to call find_stub.
a61af66fc99e Initial load duke parents: diff changeset	531 // Instead, rely on caller (nmethod::clear_inline_caches) to clear
a61af66fc99e Initial load duke parents: diff changeset	532 // both the call and its stub.
a61af66fc99e Initial load duke parents: diff changeset	533 }
a61af66fc99e Initial load duke parents: diff changeset	534
a61af66fc99e Initial load duke parents: diff changeset	535
a61af66fc99e Initial load duke parents: diff changeset	536 bool CompiledStaticCall::is_clean() const {
a61af66fc99e Initial load duke parents: diff changeset	537 return destination() == SharedRuntime::get_resolve_static_call_stub();
a61af66fc99e Initial load duke parents: diff changeset	538 }
a61af66fc99e Initial load duke parents: diff changeset	539
a61af66fc99e Initial load duke parents: diff changeset	540 bool CompiledStaticCall::is_call_to_compiled() const {
a61af66fc99e Initial load duke parents: diff changeset	541 return CodeCache::contains(destination());
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_call_to_interpreted() const {
a61af66fc99e Initial load duke parents: diff changeset	546 // It is a call to interpreted, if it calls to a stub. Hence, the destination
a61af66fc99e Initial load duke parents: diff changeset	547 // must be in the stub part of the nmethod that contains the call
a61af66fc99e Initial load duke parents: diff changeset	548 nmethod* nm = CodeCache::find_nmethod(instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	549 return nm->stub_contains(destination());
a61af66fc99e Initial load duke parents: diff changeset	550 }
a61af66fc99e Initial load duke parents: diff changeset	551
a61af66fc99e Initial load duke parents: diff changeset	552
a61af66fc99e Initial load duke parents: diff changeset	553 void CompiledStaticCall::set_to_interpreted(methodHandle callee, address entry) {
a61af66fc99e Initial load duke parents: diff changeset	554 address stub=find_stub();
a61af66fc99e Initial load duke parents: diff changeset	555 assert(stub!=NULL, "stub not found");
a61af66fc99e Initial load duke parents: diff changeset	556
a61af66fc99e Initial load duke parents: diff changeset	557 if (TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	558 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	559 tty->print_cr("CompiledStaticCall@" INTPTR_FORMAT ": set_to_interpreted %s",
a61af66fc99e Initial load duke parents: diff changeset	560 instruction_address(),
a61af66fc99e Initial load duke parents: diff changeset	561 callee->name_and_sig_as_C_string());
a61af66fc99e Initial load duke parents: diff changeset	562 }
a61af66fc99e Initial load duke parents: diff changeset	563
a61af66fc99e Initial load duke parents: diff changeset	564 NativeMovConstReg* method_holder = nativeMovConstReg_at(stub); // creation also verifies the object
a61af66fc99e Initial load duke parents: diff changeset	565 NativeJump* jump = nativeJump_at(method_holder->next_instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	566
a61af66fc99e Initial load duke parents: diff changeset	567 assert(method_holder->data() == 0 \|\| method_holder->data() == (intptr_t)callee(), "a) MT-unsafe modification of inline cache");
a61af66fc99e Initial load duke parents: diff changeset	568 assert(jump->jump_destination() == (address)-1 \|\| jump->jump_destination() == entry, "b) MT-unsafe modification of inline cache");
a61af66fc99e Initial load duke parents: diff changeset	569
a61af66fc99e Initial load duke parents: diff changeset	570 // Update stub
a61af66fc99e Initial load duke parents: diff changeset	571 method_holder->set_data((intptr_t)callee());
a61af66fc99e Initial load duke parents: diff changeset	572 jump->set_jump_destination(entry);
a61af66fc99e Initial load duke parents: diff changeset	573
a61af66fc99e Initial load duke parents: diff changeset	574 // Update jump to call
a61af66fc99e Initial load duke parents: diff changeset	575 set_destination_mt_safe(stub);
a61af66fc99e Initial load duke parents: diff changeset	576 }
a61af66fc99e Initial load duke parents: diff changeset	577
a61af66fc99e Initial load duke parents: diff changeset	578
a61af66fc99e Initial load duke parents: diff changeset	579 void CompiledStaticCall::set(const StaticCallInfo& info) {
a61af66fc99e Initial load duke parents: diff changeset	580 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "mt unsafe call");
a61af66fc99e Initial load duke parents: diff changeset	581 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load duke parents: diff changeset	582 // Updating a cache to the wrong entry can cause bugs that are very hard
a61af66fc99e Initial load duke parents: diff changeset	583 // to track down - if cache entry gets invalid - we just clean it. In
a61af66fc99e Initial load duke parents: diff changeset	584 // this way it is always the same code path that is responsible for
a61af66fc99e Initial load duke parents: diff changeset	585 // updating and resolving an inline cache
a61af66fc99e Initial load duke parents: diff changeset	586 assert(is_clean(), "do not update a call entry - use clean");
a61af66fc99e Initial load duke parents: diff changeset	587
a61af66fc99e Initial load duke parents: diff changeset	588 if (info._to_interpreter) {
a61af66fc99e Initial load duke parents: diff changeset	589 // Call to interpreted code
a61af66fc99e Initial load duke parents: diff changeset	590 set_to_interpreted(info.callee(), info.entry());
a61af66fc99e Initial load duke parents: diff changeset	591 } else {
a61af66fc99e Initial load duke parents: diff changeset	592 if (TraceICs) {
a61af66fc99e Initial load duke parents: diff changeset	593 ResourceMark rm;
a61af66fc99e Initial load duke parents: diff changeset	594 tty->print_cr("CompiledStaticCall@" INTPTR_FORMAT ": set_to_compiled " INTPTR_FORMAT,
a61af66fc99e Initial load duke parents: diff changeset	595 instruction_address(),
a61af66fc99e Initial load duke parents: diff changeset	596 info.entry());
a61af66fc99e Initial load duke parents: diff changeset	597 }
a61af66fc99e Initial load duke parents: diff changeset	598 // Call to compiled code
a61af66fc99e Initial load duke parents: diff changeset	599 assert (CodeCache::contains(info.entry()), "wrong entry point");
a61af66fc99e Initial load duke parents: diff changeset	600 set_destination_mt_safe(info.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
a61af66fc99e Initial load duke parents: diff changeset	605 // Compute settings for a CompiledStaticCall. Since we might have to set
a61af66fc99e Initial load duke parents: diff changeset	606 // the stub when calling to the interpreter, we need to return arguments.
a61af66fc99e Initial load duke parents: diff changeset	607 void CompiledStaticCall::compute_entry(methodHandle m, StaticCallInfo& info) {
a61af66fc99e Initial load duke parents: diff changeset	608 nmethod* m_code = m->code();
a61af66fc99e Initial load duke parents: diff changeset	609 info._callee = m;
a61af66fc99e Initial load duke parents: diff changeset	610 if (m_code != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	611 info._to_interpreter = false;
a61af66fc99e Initial load duke parents: diff changeset	612 info._entry = m_code->verified_entry_point();
a61af66fc99e Initial load duke parents: diff changeset	613 } else {
a61af66fc99e Initial load duke parents: diff changeset	614 // Callee is interpreted code. In any case entering the interpreter
a61af66fc99e Initial load duke parents: diff changeset	615 // puts a converter-frame on the stack to save arguments.
a61af66fc99e Initial load duke parents: diff changeset	616 info._to_interpreter = true;
a61af66fc99e Initial load duke parents: diff changeset	617 info._entry = m()->get_c2i_entry();
a61af66fc99e Initial load duke parents: diff changeset	618 }
a61af66fc99e Initial load duke parents: diff changeset	619 }
a61af66fc99e Initial load duke parents: diff changeset	620
a61af66fc99e Initial load duke parents: diff changeset	621
a61af66fc99e Initial load duke parents: diff changeset	622 void CompiledStaticCall::set_stub_to_clean(static_stub_Relocation* static_stub) {
a61af66fc99e Initial load duke parents: diff changeset	623 assert (CompiledIC_lock->is_locked() \|\| SafepointSynchronize::is_at_safepoint(), "mt unsafe call");
a61af66fc99e Initial load duke parents: diff changeset	624 // Reset stub
a61af66fc99e Initial load duke parents: diff changeset	625 address stub = static_stub->addr();
a61af66fc99e Initial load duke parents: diff changeset	626 assert(stub!=NULL, "stub not found");
a61af66fc99e Initial load duke parents: diff changeset	627 NativeMovConstReg* method_holder = nativeMovConstReg_at(stub); // creation also verifies the object
a61af66fc99e Initial load duke parents: diff changeset	628 NativeJump* jump = nativeJump_at(method_holder->next_instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	629 method_holder->set_data(0);
a61af66fc99e Initial load duke parents: diff changeset	630 jump->set_jump_destination((address)-1);
a61af66fc99e Initial load duke parents: diff changeset	631 }
a61af66fc99e Initial load duke parents: diff changeset	632
a61af66fc99e Initial load duke parents: diff changeset	633
a61af66fc99e Initial load duke parents: diff changeset	634 address CompiledStaticCall::find_stub() {
a61af66fc99e Initial load duke parents: diff changeset	635 // Find reloc. information containing this call-site
a61af66fc99e Initial load duke parents: diff changeset	636 RelocIterator iter((nmethod*)NULL, instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	637 while (iter.next()) {
a61af66fc99e Initial load duke parents: diff changeset	638 if (iter.addr() == instruction_address()) {
a61af66fc99e Initial load duke parents: diff changeset	639 switch(iter.type()) {
a61af66fc99e Initial load duke parents: diff changeset	640 case relocInfo::static_call_type:
a61af66fc99e Initial load duke parents: diff changeset	641 return iter.static_call_reloc()->static_stub();
a61af66fc99e Initial load duke parents: diff changeset	642 // We check here for opt_virtual_call_type, since we reuse the code
a61af66fc99e Initial load duke parents: diff changeset	643 // from the CompiledIC implementation
a61af66fc99e Initial load duke parents: diff changeset	644 case relocInfo::opt_virtual_call_type:
a61af66fc99e Initial load duke parents: diff changeset	645 return iter.opt_virtual_call_reloc()->static_stub();
a61af66fc99e Initial load duke parents: diff changeset	646 case relocInfo::poll_type:
a61af66fc99e Initial load duke parents: diff changeset	647 case relocInfo::poll_return_type: // A safepoint can't overlap a call.
a61af66fc99e Initial load duke parents: diff changeset	648 default:
a61af66fc99e Initial load duke parents: diff changeset	649 ShouldNotReachHere();
a61af66fc99e Initial load duke parents: diff changeset	650 }
a61af66fc99e Initial load duke parents: diff changeset	651 }
a61af66fc99e Initial load duke parents: diff changeset	652 }
a61af66fc99e Initial load duke parents: diff changeset	653 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	654 }
a61af66fc99e Initial load duke parents: diff changeset	655
a61af66fc99e Initial load duke parents: diff changeset	656
a61af66fc99e Initial load duke parents: diff changeset	657 //-----------------------------------------------------------------------------
a61af66fc99e Initial load duke parents: diff changeset	658 // Non-product mode code
a61af66fc99e Initial load duke parents: diff changeset	659 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	660
a61af66fc99e Initial load duke parents: diff changeset	661 void CompiledIC::verify() {
a61af66fc99e Initial load duke parents: diff changeset	662 // make sure code pattern is actually a call imm32 instruction
a61af66fc99e Initial load duke parents: diff changeset	663 _ic_call->verify();
a61af66fc99e Initial load duke parents: diff changeset	664 if (os::is_MP()) {
a61af66fc99e Initial load duke parents: diff changeset	665 _ic_call->verify_alignment();
a61af66fc99e Initial load duke parents: diff changeset	666 }
a61af66fc99e Initial load duke parents: diff changeset	667 assert(is_clean() \|\| is_call_to_compiled() \|\| is_call_to_interpreted()
a61af66fc99e Initial load duke parents: diff changeset	668 \|\| is_optimized() \|\| is_megamorphic(), "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	669 }
a61af66fc99e Initial load duke parents: diff changeset	670
a61af66fc99e Initial load duke parents: diff changeset	671
a61af66fc99e Initial load duke parents: diff changeset	672 void CompiledIC::print() {
a61af66fc99e Initial load duke parents: diff changeset	673 print_compiled_ic();
a61af66fc99e Initial load duke parents: diff changeset	674 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	675 }
a61af66fc99e Initial load duke parents: diff changeset	676
a61af66fc99e Initial load duke parents: diff changeset	677
a61af66fc99e Initial load duke parents: diff changeset	678 void CompiledIC::print_compiled_ic() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 4872 diff changeset	679 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	680 instruction_address(), is_call_to_interpreted() ? "interpreted " : "", ic_destination(), is_optimized() ? NULL : cached_value());
0 a61af66fc99e Initial load duke parents: diff changeset	681 }
a61af66fc99e Initial load duke parents: diff changeset	682
a61af66fc99e Initial load duke parents: diff changeset	683
a61af66fc99e Initial load duke parents: diff changeset	684 void CompiledStaticCall::print() {
a61af66fc99e Initial load duke parents: diff changeset	685 tty->print("static call at " INTPTR_FORMAT " -> ", instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	686 if (is_clean()) {
a61af66fc99e Initial load duke parents: diff changeset	687 tty->print("clean");
a61af66fc99e Initial load duke parents: diff changeset	688 } else if (is_call_to_compiled()) {
a61af66fc99e Initial load duke parents: diff changeset	689 tty->print("compiled");
a61af66fc99e Initial load duke parents: diff changeset	690 } else if (is_call_to_interpreted()) {
a61af66fc99e Initial load duke parents: diff changeset	691 tty->print("interpreted");
a61af66fc99e Initial load duke parents: diff changeset	692 }
a61af66fc99e Initial load duke parents: diff changeset	693 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	694 }
a61af66fc99e Initial load duke parents: diff changeset	695
a61af66fc99e Initial load duke parents: diff changeset	696 void CompiledStaticCall::verify() {
a61af66fc99e Initial load duke parents: diff changeset	697 // Verify call
a61af66fc99e Initial load duke parents: diff changeset	698 NativeCall::verify();
a61af66fc99e Initial load duke parents: diff changeset	699 if (os::is_MP()) {
a61af66fc99e Initial load duke parents: diff changeset	700 verify_alignment();
a61af66fc99e Initial load duke parents: diff changeset	701 }
a61af66fc99e Initial load duke parents: diff changeset	702
a61af66fc99e Initial load duke parents: diff changeset	703 // Verify stub
a61af66fc99e Initial load duke parents: diff changeset	704 address stub = find_stub();
a61af66fc99e Initial load duke parents: diff changeset	705 assert(stub != NULL, "no stub found for static call");
a61af66fc99e Initial load duke parents: diff changeset	706 NativeMovConstReg* method_holder = nativeMovConstReg_at(stub); // creation also verifies the object
a61af66fc99e Initial load duke parents: diff changeset	707 NativeJump* jump = nativeJump_at(method_holder->next_instruction_address());
a61af66fc99e Initial load duke parents: diff changeset	708
a61af66fc99e Initial load duke parents: diff changeset	709 // Verify state
a61af66fc99e Initial load duke parents: diff changeset	710 assert(is_clean() \|\| is_call_to_compiled() \|\| is_call_to_interpreted(), "sanity check");
a61af66fc99e Initial load duke parents: diff changeset	711 }
a61af66fc99e Initial load duke parents: diff changeset	712
a61af66fc99e Initial load duke parents: diff changeset	713 #endif

Mercurial > hg > truffle

annotate src/share/vm/code/compiledIC.cpp @ 6725:da91efe96a93