Mercurial > hg > graal-jvmci-8

annotate src/share/vm/code/compiledIC.cpp @ 21559:be896a1983c0

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
recast all Graal native code as JVMCI code (JBS:GRAAL-53)
author Doug Simon <doug.simon@oracle.com>
date Thu, 28 May 2015 15:36:48 +0200
parents 7848fc12602b
children b5f3a471e646
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
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
15101
9f7eac122d61 Update comment message about unoptimized virtual call sites
Tom Rodriguez <tom.rodriguez@oracle.com>
parents: 15069
diff changeset
275 // for calling directly to vep without using the inline cache (i.e., cached_value == NULL).
21559
be896a1983c0 recast all Graal native code as JVMCI code (JBS:GRAAL-53)
Doug Simon <doug.simon@oracle.com>
parents: 20804
diff changeset
276 // For JVMCI this occurs because CHA is only used to improve inlining so call sites which could be optimized
15101
9f7eac122d61 Update comment message about unoptimized virtual call sites
Tom Rodriguez <tom.rodriguez@oracle.com>
parents: 15069
diff changeset
277 // virtuals because there are no currently loaded subclasses of a type are left as virtual call sites.
0
a61af66fc99e Initial load
duke
parents:
diff changeset
278 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
279 CodeBlob* caller = CodeCache::find_blob_unsafe(instruction_address());
21559
be896a1983c0 recast all Graal native code as JVMCI code (JBS:GRAAL-53)
Doug Simon <doug.simon@oracle.com>
parents: 20804
diff changeset
280 bool is_c1_or_jvmci_method = caller->is_compiled_by_c1() || caller->is_compiled_by_jvmci();
be896a1983c0 recast all Graal native code as JVMCI code (JBS:GRAAL-53)
Doug Simon <doug.simon@oracle.com>
parents: 20804
diff changeset
281 assert( is_c1_or_jvmci_method ||
0
a61af66fc99e Initial load
duke
parents:
diff changeset
282 !is_monomorphic ||
a61af66fc99e Initial load
duke
parents:
diff changeset
283 is_optimized() ||
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
284 (cached_metadata() != NULL && cached_metadata()->is_klass()), "sanity check");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
285 #endif // ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
286 return is_monomorphic;
a61af66fc99e Initial load
duke
parents:
diff changeset
287 }
a61af66fc99e Initial load
duke
parents:
diff changeset
288
a61af66fc99e Initial load
duke
parents:
diff changeset
289
a61af66fc99e Initial load
duke
parents:
diff changeset
290 bool CompiledIC::is_call_to_interpreted() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
291 assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load
duke
parents:
diff changeset
292 // Call to interpreter if destination is either calling to a stub (if it
a61af66fc99e Initial load
duke
parents:
diff changeset
293 // is optimized), or calling to an I2C blob
a61af66fc99e Initial load
duke
parents:
diff changeset
294 bool is_call_to_interpreted = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
295 if (!is_optimized()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
296 // must use unsafe because the destination can be a zombie (and we're cleaning)
a61af66fc99e Initial load
duke
parents:
diff changeset
297 // and the print_compiled_ic code wants to know if site (in the non-zombie)
a61af66fc99e Initial load
duke
parents:
diff changeset
298 // is to the interpreter.
a61af66fc99e Initial load
duke
parents:
diff changeset
299 CodeBlob* cb = CodeCache::find_blob_unsafe(ic_destination());
a61af66fc99e Initial load
duke
parents:
diff changeset
300 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
301 assert(!is_call_to_interpreted || (is_icholder_call() && cached_icholder() != NULL), "sanity check");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
302 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
303 // Check if we are calling into our own codeblob (i.e., to a stub)
a61af66fc99e Initial load
duke
parents:
diff changeset
304 CodeBlob* cb = CodeCache::find_blob(_ic_call->instruction_address());
a61af66fc99e Initial load
duke
parents:
diff changeset
305 address dest = ic_destination();
a61af66fc99e Initial load
duke
parents:
diff changeset
306 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
307 {
a61af66fc99e Initial load
duke
parents:
diff changeset
308 CodeBlob* db = CodeCache::find_blob_unsafe(dest);
a61af66fc99e Initial load
duke
parents:
diff changeset
309 assert(!db->is_adapter_blob(), "must use stub!");
a61af66fc99e Initial load
duke
parents:
diff changeset
310 }
a61af66fc99e Initial load
duke
parents:
diff changeset
311 #endif /* ASSERT */
a61af66fc99e Initial load
duke
parents:
diff changeset
312 is_call_to_interpreted = cb->contains(dest);
a61af66fc99e Initial load
duke
parents:
diff changeset
313 }
a61af66fc99e Initial load
duke
parents:
diff changeset
314 return is_call_to_interpreted;
a61af66fc99e Initial load
duke
parents:
diff changeset
315 }
a61af66fc99e Initial load
duke
parents:
diff changeset
316
a61af66fc99e Initial load
duke
parents:
diff changeset
317
a61af66fc99e Initial load
duke
parents:
diff changeset
318 void CompiledIC::set_to_clean() {
a61af66fc99e Initial load
duke
parents:
diff changeset
319 assert(SafepointSynchronize::is_at_safepoint() || CompiledIC_lock->is_locked() , "MT-unsafe call");
a61af66fc99e Initial load
duke
parents:
diff changeset
320 if (TraceInlineCacheClearing || TraceICs) {
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 13441
diff changeset
321 tty->print_cr("IC@" INTPTR_FORMAT ": set to clean", p2i(instruction_address()));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
322 print();
a61af66fc99e Initial load
duke
parents:
diff changeset
323 }
a61af66fc99e Initial load
duke
parents:
diff changeset
324
a61af66fc99e Initial load
duke
parents:
diff changeset
325 address entry;
a61af66fc99e Initial load
duke
parents:
diff changeset
326 if (is_optimized()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
327 entry = SharedRuntime::get_resolve_opt_virtual_call_stub();
a61af66fc99e Initial load
duke
parents:
diff changeset
328 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
329 entry = SharedRuntime::get_resolve_virtual_call_stub();
a61af66fc99e Initial load
duke
parents:
diff changeset
330 }
a61af66fc99e Initial load
duke
parents:
diff changeset
331
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
332 // 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
333 // we only need to patch the destination
a61af66fc99e Initial load
duke
parents:
diff changeset
334 bool safe_transition = is_optimized() || SafepointSynchronize::is_at_safepoint();
a61af66fc99e Initial load
duke
parents:
diff changeset
335
a61af66fc99e Initial load
duke
parents:
diff changeset
336 if (safe_transition) {
a61af66fc99e Initial load
duke
parents:
diff changeset
337 // Kill any leftover stub we might have too
a61af66fc99e Initial load
duke
parents:
diff changeset
338 if (is_in_transition_state()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
339 ICStub* old_stub = ICStub_from_destination_address(stub_address());
a61af66fc99e Initial load
duke
parents:
diff changeset
340 old_stub->clear();
a61af66fc99e Initial load
duke
parents:
diff changeset
341 }
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
342 if (is_optimized()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
343 set_ic_destination(entry);
a61af66fc99e Initial load
duke
parents:
diff changeset
344 } else {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
345 set_ic_destination_and_value(entry, (void*)NULL);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
346 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
347 } else {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
348 // Unsafe transition - create stub.
a61af66fc99e Initial load
duke
parents:
diff changeset
349 InlineCacheBuffer::create_transition_stub(this, NULL, entry);
a61af66fc99e Initial load
duke
parents:
diff changeset
350 }
a61af66fc99e Initial load
duke
parents:
diff changeset
351 // We can't check this anymore. With lazy deopt we could have already
a61af66fc99e Initial load
duke
parents:
diff changeset
352 // cleaned this IC entry before we even return. This is possible if
a61af66fc99e Initial load
duke
parents:
diff changeset
353 // we ran out of space in the inline cache buffer trying to do the
a61af66fc99e Initial load
duke
parents:
diff changeset
354 // set_next and we safepointed to free up space. This is a benign
a61af66fc99e Initial load
duke
parents:
diff changeset
355 // race because the IC entry was complete when we safepointed so
a61af66fc99e Initial load
duke
parents:
diff changeset
356 // cleaning it immediately is harmless.
a61af66fc99e Initial load
duke
parents:
diff changeset
357 // assert(is_clean(), "sanity check");
a61af66fc99e Initial load
duke
parents:
diff changeset
358 }
a61af66fc99e Initial load
duke
parents:
diff changeset
359
a61af66fc99e Initial load
duke
parents:
diff changeset
360
a61af66fc99e Initial load
duke
parents:
diff changeset
361 bool CompiledIC::is_clean() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
362 assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load
duke
parents:
diff changeset
363 bool is_clean = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
364 address dest = ic_destination();
a61af66fc99e Initial load
duke
parents:
diff changeset
365 is_clean = dest == SharedRuntime::get_resolve_opt_virtual_call_stub() ||
a61af66fc99e Initial load
duke
parents:
diff changeset
366 dest == SharedRuntime::get_resolve_virtual_call_stub();
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
367 assert(!is_clean || is_optimized() || cached_value() == NULL, "sanity check");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
368 return is_clean;
a61af66fc99e Initial load
duke
parents:
diff changeset
369 }
a61af66fc99e Initial load
duke
parents:
diff changeset
370
a61af66fc99e Initial load
duke
parents:
diff changeset
371
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
372 void CompiledIC::set_to_monomorphic(CompiledICInfo& info) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
373 assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "");
a61af66fc99e Initial load
duke
parents:
diff changeset
374 // Updating a cache to the wrong entry can cause bugs that are very hard
a61af66fc99e Initial load
duke
parents:
diff changeset
375 // to track down - if cache entry gets invalid - we just clean it. In
a61af66fc99e Initial load
duke
parents:
diff changeset
376 // this way it is always the same code path that is responsible for
a61af66fc99e Initial load
duke
parents:
diff changeset
377 // updating and resolving an inline cache
a61af66fc99e Initial load
duke
parents:
diff changeset
378 //
a61af66fc99e Initial load
duke
parents:
diff changeset
379 // The above is no longer true. SharedRuntime::fixup_callers_callsite will change optimized
a61af66fc99e Initial load
duke
parents:
diff changeset
380 // callsites. In addition ic_miss code will update a site to monomorphic if it determines
a61af66fc99e Initial load
duke
parents:
diff changeset
381 // that an monomorphic call to the interpreter can now be monomorphic to compiled code.
a61af66fc99e Initial load
duke
parents:
diff changeset
382 //
a61af66fc99e Initial load
duke
parents:
diff changeset
383 // In both of these cases the only thing being modifed is the jump/call target and these
a61af66fc99e Initial load
duke
parents:
diff changeset
384 // transitions are mt_safe
a61af66fc99e Initial load
duke
parents:
diff changeset
385
a61af66fc99e Initial load
duke
parents:
diff changeset
386 Thread *thread = Thread::current();
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
387 if (info.to_interpreter()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
388 // Call to interpreter
a61af66fc99e Initial load
duke
parents:
diff changeset
389 if (info.is_optimized() && is_optimized()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
390 assert(is_clean(), "unsafe IC path");
a61af66fc99e Initial load
duke
parents:
diff changeset
391 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load
duke
parents:
diff changeset
392 // the call analysis (callee structure) specifies that the call is optimized
a61af66fc99e Initial load
duke
parents:
diff changeset
393 // (either because of CHA or the static target is final)
a61af66fc99e Initial load
duke
parents:
diff changeset
394 // At code generation time, this call has been emitted as static call
a61af66fc99e Initial load
duke
parents:
diff changeset
395 // Call via stub
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
396 assert(info.cached_metadata() != NULL && info.cached_metadata()->is_method(), "sanity check");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
397 CompiledStaticCall* csc = compiledStaticCall_at(instruction_address());
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
398 methodHandle method (thread, (Method*)info.cached_metadata());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
399 csc->set_to_interpreted(method, info.entry());
a61af66fc99e Initial load
duke
parents:
diff changeset
400 if (TraceICs) {
a61af66fc99e Initial load
duke
parents:
diff changeset
401 ResourceMark rm(thread);
a61af66fc99e Initial load
duke
parents:
diff changeset
402 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
403 p2i(instruction_address()),
0
a61af66fc99e Initial load
duke
parents:
diff changeset
404 method->print_value_string());
a61af66fc99e Initial load
duke
parents:
diff changeset
405 }
a61af66fc99e Initial load
duke
parents:
diff changeset
406 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
407 // Call via method-klass-holder
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
408 InlineCacheBuffer::create_transition_stub(this, info.claim_cached_icholder(), info.entry());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
409 if (TraceICs) {
a61af66fc99e Initial load
duke
parents:
diff changeset
410 ResourceMark rm(thread);
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 13441
diff changeset
411 tty->print_cr ("IC@" INTPTR_FORMAT ": monomorphic to interpreter via icholder ", p2i(instruction_address()));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
412 }
a61af66fc99e Initial load
duke
parents:
diff changeset
413 }
a61af66fc99e Initial load
duke
parents:
diff changeset
414 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
415 // Call to compiled code
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
416 bool static_bound = info.is_optimized() || (info.cached_metadata() == NULL);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
417 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
418 CodeBlob* cb = CodeCache::find_blob_unsafe(info.entry());
a61af66fc99e Initial load
duke
parents:
diff changeset
419 assert (cb->is_nmethod(), "must be compiled!");
a61af66fc99e Initial load
duke
parents:
diff changeset
420 #endif /* ASSERT */
a61af66fc99e Initial load
duke
parents:
diff changeset
421
a61af66fc99e Initial load
duke
parents:
diff changeset
422 // This is MT safe if we come from a clean-cache and go through a
a61af66fc99e Initial load
duke
parents:
diff changeset
423 // non-verified entry point
a61af66fc99e Initial load
duke
parents:
diff changeset
424 bool safe = SafepointSynchronize::is_at_safepoint() ||
a61af66fc99e Initial load
duke
parents:
diff changeset
425 (!is_in_transition_state() && (info.is_optimized() || static_bound || is_clean()));
a61af66fc99e Initial load
duke
parents:
diff changeset
426
a61af66fc99e Initial load
duke
parents:
diff changeset
427 if (!safe) {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
428 InlineCacheBuffer::create_transition_stub(this, info.cached_metadata(), info.entry());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
429 } else {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
430 if (is_optimized()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
431 set_ic_destination(info.entry());
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
432 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
433 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
434 }
0
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 (TraceICs) {
a61af66fc99e Initial load
duke
parents:
diff changeset
438 ResourceMark rm(thread);
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
439 assert(info.cached_metadata() == NULL || info.cached_metadata()->is_klass(), "must be");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
440 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
441 p2i(instruction_address()),
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
442 ((Klass*)info.cached_metadata())->print_value_string(),
0
a61af66fc99e Initial load
duke
parents:
diff changeset
443 (safe) ? "" : "via stub");
a61af66fc99e Initial load
duke
parents:
diff changeset
444 }
a61af66fc99e Initial load
duke
parents:
diff changeset
445 }
a61af66fc99e Initial load
duke
parents:
diff changeset
446 // We can't check this anymore. With lazy deopt we could have already
a61af66fc99e Initial load
duke
parents:
diff changeset
447 // cleaned this IC entry before we even return. This is possible if
a61af66fc99e Initial load
duke
parents:
diff changeset
448 // we ran out of space in the inline cache buffer trying to do the
a61af66fc99e Initial load
duke
parents:
diff changeset
449 // set_next and we safepointed to free up space. This is a benign
a61af66fc99e Initial load
duke
parents:
diff changeset
450 // race because the IC entry was complete when we safepointed so
a61af66fc99e Initial load
duke
parents:
diff changeset
451 // cleaning it immediately is harmless.
a61af66fc99e Initial load
duke
parents:
diff changeset
452 // assert(is_call_to_compiled() || is_call_to_interpreted(), "sanity check");
a61af66fc99e Initial load
duke
parents:
diff changeset
453 }
a61af66fc99e Initial load
duke
parents:
diff changeset
454
a61af66fc99e Initial load
duke
parents:
diff changeset
455
a61af66fc99e Initial load
duke
parents:
diff changeset
456 // is_optimized: Compiler has generated an optimized call (i.e., no inline
a61af66fc99e Initial load
duke
parents:
diff changeset
457 // cache) static_bound: The call can be static bound (i.e, no need to use
a61af66fc99e Initial load
duke
parents:
diff changeset
458 // inline cache)
a61af66fc99e Initial load
duke
parents:
diff changeset
459 void CompiledIC::compute_monomorphic_entry(methodHandle method,
a61af66fc99e Initial load
duke
parents:
diff changeset
460 KlassHandle receiver_klass,
a61af66fc99e Initial load
duke
parents:
diff changeset
461 bool is_optimized,
a61af66fc99e Initial load
duke
parents:
diff changeset
462 bool static_bound,
a61af66fc99e Initial load
duke
parents:
diff changeset
463 CompiledICInfo& info,
a61af66fc99e Initial load
duke
parents:
diff changeset
464 TRAPS) {
a61af66fc99e Initial load
duke
parents:
diff changeset
465 nmethod* method_code = method->code();
a61af66fc99e Initial load
duke
parents:
diff changeset
466 address entry = NULL;
13441
df832bd8edb9 8028107: Kitchensink crashed with EAV
kvn
parents: 12294
diff changeset
467 if (method_code != NULL && method_code->is_in_use()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
468 // Call to compiled code
a61af66fc99e Initial load
duke
parents:
diff changeset
469 if (static_bound || is_optimized) {
a61af66fc99e Initial load
duke
parents:
diff changeset
470 entry = method_code->verified_entry_point();
a61af66fc99e Initial load
duke
parents:
diff changeset
471 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
472 entry = method_code->entry_point();
a61af66fc99e Initial load
duke
parents:
diff changeset
473 }
a61af66fc99e Initial load
duke
parents:
diff changeset
474 }
a61af66fc99e Initial load
duke
parents:
diff changeset
475 if (entry != NULL) {
a61af66fc99e Initial load
duke
parents:
diff changeset
476 // Call to compiled code
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
477 info.set_compiled_entry(entry, (static_bound || is_optimized) ? NULL : receiver_klass(), is_optimized);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
478 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
479 // Note: the following problem exists with Compiler1:
a61af66fc99e Initial load
duke
parents:
diff changeset
480 // - at compile time we may or may not know if the destination is final
a61af66fc99e Initial load
duke
parents:
diff changeset
481 // - 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
482 // virtual call (no inline cache), and need a Method* to make a call
0
a61af66fc99e Initial load
duke
parents:
diff changeset
483 // to the interpreter
a61af66fc99e Initial load
duke
parents:
diff changeset
484 // - if we do not know if the destination is final, we emit a standard
a61af66fc99e Initial load
duke
parents:
diff changeset
485 // virtual call, and use CompiledICHolder to call interpreted code
a61af66fc99e Initial load
duke
parents:
diff changeset
486 // (no static call stub has been generated)
a61af66fc99e Initial load
duke
parents:
diff changeset
487 // However in that case we will now notice it is static_bound
a61af66fc99e Initial load
duke
parents:
diff changeset
488 // and convert the call into what looks to be an optimized
a61af66fc99e Initial load
duke
parents:
diff changeset
489 // virtual call. This causes problems in verifying the IC because
a61af66fc99e Initial load
duke
parents:
diff changeset
490 // it look vanilla but is optimized. Code in is_call_to_interpreted
a61af66fc99e Initial load
duke
parents:
diff changeset
491 // is aware of this and weakens its asserts.
a61af66fc99e Initial load
duke
parents:
diff changeset
492
a61af66fc99e Initial load
duke
parents:
diff changeset
493 // static_bound should imply is_optimized -- otherwise we have a
a61af66fc99e Initial load
duke
parents:
diff changeset
494 // performance bug (statically-bindable method is called via
a61af66fc99e Initial load
duke
parents:
diff changeset
495 // dynamically-dispatched call note: the reverse implication isn't
a61af66fc99e Initial load
duke
parents:
diff changeset
496 // necessarily true -- the call may have been optimized based on compiler
a61af66fc99e Initial load
duke
parents:
diff changeset
497 // analysis (static_bound is only based on "final" etc.)
a61af66fc99e Initial load
duke
parents:
diff changeset
498 #ifdef COMPILER2
a61af66fc99e Initial load
duke
parents:
diff changeset
499 #ifdef TIERED
a61af66fc99e Initial load
duke
parents:
diff changeset
500 #if defined(ASSERT)
a61af66fc99e Initial load
duke
parents:
diff changeset
501 // can't check the assert because we don't have the CompiledIC with which to
a61af66fc99e Initial load
duke
parents:
diff changeset
502 // find the address if the call instruction.
a61af66fc99e Initial load
duke
parents:
diff changeset
503 //
a61af66fc99e Initial load
duke
parents:
diff changeset
504 // CodeBlob* cb = find_blob_unsafe(instruction_address());
a61af66fc99e Initial load
duke
parents:
diff changeset
505 // assert(cb->is_compiled_by_c1() || !static_bound || is_optimized, "static_bound should imply is_optimized");
a61af66fc99e Initial load
duke
parents:
diff changeset
506 #endif // ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
507 #else
a61af66fc99e Initial load
duke
parents:
diff changeset
508 assert(!static_bound || is_optimized, "static_bound should imply is_optimized");
a61af66fc99e Initial load
duke
parents:
diff changeset
509 #endif // TIERED
a61af66fc99e Initial load
duke
parents:
diff changeset
510 #endif // COMPILER2
a61af66fc99e Initial load
duke
parents:
diff changeset
511 if (is_optimized) {
a61af66fc99e Initial load
duke
parents:
diff changeset
512 // Use stub entry
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
513 info.set_interpreter_entry(method()->get_c2i_entry(), method());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
514 } else {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
515 // Use icholder entry
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
516 CompiledICHolder* holder = new CompiledICHolder(method(), receiver_klass());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
517 info.set_icholder_entry(method()->get_c2i_unverified_entry(), holder);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
518 }
a61af66fc99e Initial load
duke
parents:
diff changeset
519 }
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
520 assert(info.is_optimized() == is_optimized, "must agree");
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
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
523
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
524 bool CompiledIC::is_icholder_entry(address entry) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
525 CodeBlob* cb = CodeCache::find_blob_unsafe(entry);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
526 return (cb != NULL && cb->is_adapter_blob());
0
a61af66fc99e Initial load
duke
parents:
diff changeset
527 }
a61af66fc99e Initial load
duke
parents:
diff changeset
528
a61af66fc99e Initial load
duke
parents:
diff changeset
529 // ----------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
530
a61af66fc99e Initial load
duke
parents:
diff changeset
531 void CompiledStaticCall::set_to_clean() {
a61af66fc99e Initial load
duke
parents:
diff changeset
532 assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "mt unsafe call");
a61af66fc99e Initial load
duke
parents:
diff changeset
533 // Reset call site
20278
2c6ef90f030a 8049421: G1 Class Unloading after completing a concurrent mark cycle
stefank
parents: 20277
diff changeset
534 MutexLockerEx pl(SafepointSynchronize::is_at_safepoint() ? NULL : Patching_lock, Mutex::_no_safepoint_check_flag);
0
a61af66fc99e Initial load
duke
parents:
diff changeset
535 #ifdef ASSERT
a61af66fc99e Initial load
duke
parents:
diff changeset
536 CodeBlob* cb = CodeCache::find_blob_unsafe(this);
a61af66fc99e Initial load
duke
parents:
diff changeset
537 assert(cb != NULL && cb->is_nmethod(), "must be nmethod");
a61af66fc99e Initial load
duke
parents:
diff changeset
538 #endif
a61af66fc99e Initial load
duke
parents:
diff changeset
539 set_destination_mt_safe(SharedRuntime::get_resolve_static_call_stub());
a61af66fc99e Initial load
duke
parents:
diff changeset
540
a61af66fc99e Initial load
duke
parents:
diff changeset
541 // Do not reset stub here: It is too expensive to call find_stub.
a61af66fc99e Initial load
duke
parents:
diff changeset
542 // Instead, rely on caller (nmethod::clear_inline_caches) to clear
a61af66fc99e Initial load
duke
parents:
diff changeset
543 // both the call and its stub.
a61af66fc99e Initial load
duke
parents:
diff changeset
544 }
a61af66fc99e Initial load
duke
parents:
diff changeset
545
a61af66fc99e Initial load
duke
parents:
diff changeset
546
a61af66fc99e Initial load
duke
parents:
diff changeset
547 bool CompiledStaticCall::is_clean() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
548 return destination() == SharedRuntime::get_resolve_static_call_stub();
a61af66fc99e Initial load
duke
parents:
diff changeset
549 }
a61af66fc99e Initial load
duke
parents:
diff changeset
550
a61af66fc99e Initial load
duke
parents:
diff changeset
551 bool CompiledStaticCall::is_call_to_compiled() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
552 return CodeCache::contains(destination());
a61af66fc99e Initial load
duke
parents:
diff changeset
553 }
a61af66fc99e Initial load
duke
parents:
diff changeset
554
a61af66fc99e Initial load
duke
parents:
diff changeset
555
a61af66fc99e Initial load
duke
parents:
diff changeset
556 bool CompiledStaticCall::is_call_to_interpreted() const {
a61af66fc99e Initial load
duke
parents:
diff changeset
557 // It is a call to interpreted, if it calls to a stub. Hence, the destination
a61af66fc99e Initial load
duke
parents:
diff changeset
558 // must be in the stub part of the nmethod that contains the call
a61af66fc99e Initial load
duke
parents:
diff changeset
559 nmethod* nm = CodeCache::find_nmethod(instruction_address());
a61af66fc99e Initial load
duke
parents:
diff changeset
560 return nm->stub_contains(destination());
a61af66fc99e Initial load
duke
parents:
diff changeset
561 }
a61af66fc99e Initial load
duke
parents:
diff changeset
562
a61af66fc99e Initial load
duke
parents:
diff changeset
563 void CompiledStaticCall::set(const StaticCallInfo& info) {
a61af66fc99e Initial load
duke
parents:
diff changeset
564 assert (CompiledIC_lock->is_locked() || SafepointSynchronize::is_at_safepoint(), "mt unsafe call");
a61af66fc99e Initial load
duke
parents:
diff changeset
565 MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
a61af66fc99e Initial load
duke
parents:
diff changeset
566 // Updating a cache to the wrong entry can cause bugs that are very hard
a61af66fc99e Initial load
duke
parents:
diff changeset
567 // to track down - if cache entry gets invalid - we just clean it. In
a61af66fc99e Initial load
duke
parents:
diff changeset
568 // this way it is always the same code path that is responsible for
a61af66fc99e Initial load
duke
parents:
diff changeset
569 // updating and resolving an inline cache
a61af66fc99e Initial load
duke
parents:
diff changeset
570 assert(is_clean(), "do not update a call entry - use clean");
a61af66fc99e Initial load
duke
parents:
diff changeset
571
a61af66fc99e Initial load
duke
parents:
diff changeset
572 if (info._to_interpreter) {
a61af66fc99e Initial load
duke
parents:
diff changeset
573 // Call to interpreted code
a61af66fc99e Initial load
duke
parents:
diff changeset
574 set_to_interpreted(info.callee(), info.entry());
a61af66fc99e Initial load
duke
parents:
diff changeset
575 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
576 if (TraceICs) {
a61af66fc99e Initial load
duke
parents:
diff changeset
577 ResourceMark rm;
a61af66fc99e Initial load
duke
parents:
diff changeset
578 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
579 p2i(instruction_address()),
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 13441
diff changeset
580 p2i(info.entry()));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
581 }
a61af66fc99e Initial load
duke
parents:
diff changeset
582 // Call to compiled code
a61af66fc99e Initial load
duke
parents:
diff changeset
583 assert (CodeCache::contains(info.entry()), "wrong entry point");
a61af66fc99e Initial load
duke
parents:
diff changeset
584 set_destination_mt_safe(info.entry());
a61af66fc99e Initial load
duke
parents:
diff changeset
585 }
a61af66fc99e Initial load
duke
parents:
diff changeset
586 }
a61af66fc99e Initial load
duke
parents:
diff changeset
587
a61af66fc99e Initial load
duke
parents:
diff changeset
588
a61af66fc99e Initial load
duke
parents:
diff changeset
589 // Compute settings for a CompiledStaticCall. Since we might have to set
a61af66fc99e Initial load
duke
parents:
diff changeset
590 // the stub when calling to the interpreter, we need to return arguments.
a61af66fc99e Initial load
duke
parents:
diff changeset
591 void CompiledStaticCall::compute_entry(methodHandle m, StaticCallInfo& info) {
a61af66fc99e Initial load
duke
parents:
diff changeset
592 nmethod* m_code = m->code();
a61af66fc99e Initial load
duke
parents:
diff changeset
593 info._callee = m;
13441
df832bd8edb9 8028107: Kitchensink crashed with EAV
kvn
parents: 12294
diff changeset
594 if (m_code != NULL && m_code->is_in_use()) {
0
a61af66fc99e Initial load
duke
parents:
diff changeset
595 info._to_interpreter = false;
a61af66fc99e Initial load
duke
parents:
diff changeset
596 info._entry = m_code->verified_entry_point();
a61af66fc99e Initial load
duke
parents:
diff changeset
597 } else {
a61af66fc99e Initial load
duke
parents:
diff changeset
598 // Callee is interpreted code. In any case entering the interpreter
a61af66fc99e Initial load
duke
parents:
diff changeset
599 // 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
600 assert(!m->is_method_handle_intrinsic(), "Compiled code should never call interpreter MH intrinsics");
0
a61af66fc99e Initial load
duke
parents:
diff changeset
601 info._to_interpreter = true;
a61af66fc99e Initial load
duke
parents:
diff changeset
602 info._entry = m()->get_c2i_entry();
a61af66fc99e Initial load
duke
parents:
diff changeset
603 }
a61af66fc99e Initial load
duke
parents:
diff changeset
604 }
a61af66fc99e Initial load
duke
parents:
diff changeset
605
a61af66fc99e Initial load
duke
parents:
diff changeset
606 address CompiledStaticCall::find_stub() {
a61af66fc99e Initial load
duke
parents:
diff changeset
607 // Find reloc. information containing this call-site
a61af66fc99e Initial load
duke
parents:
diff changeset
608 RelocIterator iter((nmethod*)NULL, instruction_address());
a61af66fc99e Initial load
duke
parents:
diff changeset
609 while (iter.next()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
610 if (iter.addr() == instruction_address()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
611 switch(iter.type()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
612 case relocInfo::static_call_type:
a61af66fc99e Initial load
duke
parents:
diff changeset
613 return iter.static_call_reloc()->static_stub();
a61af66fc99e Initial load
duke
parents:
diff changeset
614 // We check here for opt_virtual_call_type, since we reuse the code
a61af66fc99e Initial load
duke
parents:
diff changeset
615 // from the CompiledIC implementation
a61af66fc99e Initial load
duke
parents:
diff changeset
616 case relocInfo::opt_virtual_call_type:
a61af66fc99e Initial load
duke
parents:
diff changeset
617 return iter.opt_virtual_call_reloc()->static_stub();
a61af66fc99e Initial load
duke
parents:
diff changeset
618 case relocInfo::poll_type:
a61af66fc99e Initial load
duke
parents:
diff changeset
619 case relocInfo::poll_return_type: // A safepoint can't overlap a call.
a61af66fc99e Initial load
duke
parents:
diff changeset
620 default:
a61af66fc99e Initial load
duke
parents:
diff changeset
621 ShouldNotReachHere();
a61af66fc99e Initial load
duke
parents:
diff changeset
622 }
a61af66fc99e Initial load
duke
parents:
diff changeset
623 }
a61af66fc99e Initial load
duke
parents:
diff changeset
624 }
a61af66fc99e Initial load
duke
parents:
diff changeset
625 return NULL;
a61af66fc99e Initial load
duke
parents:
diff changeset
626 }
a61af66fc99e Initial load
duke
parents:
diff changeset
627
a61af66fc99e Initial load
duke
parents:
diff changeset
628
a61af66fc99e Initial load
duke
parents:
diff changeset
629 //-----------------------------------------------------------------------------
a61af66fc99e Initial load
duke
parents:
diff changeset
630 // Non-product mode code
a61af66fc99e Initial load
duke
parents:
diff changeset
631 #ifndef PRODUCT
a61af66fc99e Initial load
duke
parents:
diff changeset
632
a61af66fc99e Initial load
duke
parents:
diff changeset
633 void CompiledIC::verify() {
a61af66fc99e Initial load
duke
parents:
diff changeset
634 // make sure code pattern is actually a call imm32 instruction
a61af66fc99e Initial load
duke
parents:
diff changeset
635 _ic_call->verify();
a61af66fc99e Initial load
duke
parents:
diff changeset
636 if (os::is_MP()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
637 _ic_call->verify_alignment();
a61af66fc99e Initial load
duke
parents:
diff changeset
638 }
a61af66fc99e Initial load
duke
parents:
diff changeset
639 assert(is_clean() || is_call_to_compiled() || is_call_to_interpreted()
a61af66fc99e Initial load
duke
parents:
diff changeset
640 || is_optimized() || is_megamorphic(), "sanity check");
a61af66fc99e Initial load
duke
parents:
diff changeset
641 }
a61af66fc99e Initial load
duke
parents:
diff changeset
642
a61af66fc99e Initial load
duke
parents:
diff changeset
643 void CompiledIC::print() {
a61af66fc99e Initial load
duke
parents:
diff changeset
644 print_compiled_ic();
a61af66fc99e Initial load
duke
parents:
diff changeset
645 tty->cr();
a61af66fc99e Initial load
duke
parents:
diff changeset
646 }
a61af66fc99e Initial load
duke
parents:
diff changeset
647
a61af66fc99e Initial load
duke
parents:
diff changeset
648 void CompiledIC::print_compiled_ic() {
6725
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 4872
diff changeset
649 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
650 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
651 }
a61af66fc99e Initial load
duke
parents:
diff changeset
652
a61af66fc99e Initial load
duke
parents:
diff changeset
653 void CompiledStaticCall::print() {
17937
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 13441
diff changeset
654 tty->print("static call at " INTPTR_FORMAT " -> ", p2i(instruction_address()));
0
a61af66fc99e Initial load
duke
parents:
diff changeset
655 if (is_clean()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
656 tty->print("clean");
a61af66fc99e Initial load
duke
parents:
diff changeset
657 } else if (is_call_to_compiled()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
658 tty->print("compiled");
a61af66fc99e Initial load
duke
parents:
diff changeset
659 } else if (is_call_to_interpreted()) {
a61af66fc99e Initial load
duke
parents:
diff changeset
660 tty->print("interpreted");
a61af66fc99e Initial load
duke
parents:
diff changeset
661 }
a61af66fc99e Initial load
duke
parents:
diff changeset
662 tty->cr();
a61af66fc99e Initial load
duke
parents:
diff changeset
663 }
a61af66fc99e Initial load
duke
parents:
diff changeset
664
10168
a6e09d6dd8e5 8003853: specify offset of IC load in java_to_interp stub
dlong
parents: 8776
diff changeset
665 #endif // !PRODUCT