author | herrick |
Wed, 27 Mar 2019 08:27:58 -0400 | |
branch | JDK-8200758-branch |
changeset 57288 | 0be43184f52a |
parent 53582 | 881c5fbeb849 |
child 54847 | 59ea39bb2809 |
permissions | -rw-r--r-- |
42650 | 1 |
/* |
53147
db1d11c253d8
8216010: Change callers of build_u2_from() to call Bytes::get_Java_u2() instead
hseigel
parents:
49480
diff
changeset
|
2 |
* Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved. |
42650 | 3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
4 |
* |
|
5 |
* This code is free software; you can redistribute it and/or modify it |
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
|
7 |
* published by the Free Software Foundation. |
|
8 |
* |
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
|
13 |
* accompanied this code). |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License version |
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 |
* |
|
19 |
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
20 |
* or visit www.oracle.com if you need additional information or have any |
|
21 |
* questions. |
|
22 |
*/ |
|
23 |
||
24 |
#include "precompiled.hpp" |
|
53582 | 25 |
#include "aot/aotLoader.hpp" |
42650 | 26 |
#include "classfile/stringTable.hpp" |
27 |
#include "classfile/symbolTable.hpp" |
|
47668 | 28 |
#include "interpreter/linkResolver.hpp" |
42650 | 29 |
#include "jvmci/compilerRuntime.hpp" |
49340
4e82736053ae
8191102: Incorrect include file use in classLoader.hpp
hseigel
parents:
47668
diff
changeset
|
30 |
#include "oops/cpCache.inline.hpp" |
47668 | 31 |
#include "oops/oop.inline.hpp" |
42650 | 32 |
#include "runtime/compilationPolicy.hpp" |
53582 | 33 |
#include "runtime/deoptimization.hpp" |
49480
d7df2dd501ce
8199809: Don't include frame.inline.hpp and other.inline.hpp from .hpp files
coleenp
parents:
49449
diff
changeset
|
34 |
#include "runtime/frame.inline.hpp" |
53582 | 35 |
#include "runtime/handles.inline.hpp" |
49449
ef5d5d343e2a
8199263: Split interfaceSupport.hpp to not require including .inline.hpp files
coleenp
parents:
49340
diff
changeset
|
36 |
#include "runtime/interfaceSupport.inline.hpp" |
49480
d7df2dd501ce
8199809: Don't include frame.inline.hpp and other.inline.hpp from .hpp files
coleenp
parents:
49449
diff
changeset
|
37 |
#include "runtime/vframe.inline.hpp" |
53147
db1d11c253d8
8216010: Change callers of build_u2_from() to call Bytes::get_Java_u2() instead
hseigel
parents:
49480
diff
changeset
|
38 |
#include "utilities/sizes.hpp" |
42650 | 39 |
|
40 |
// Resolve and allocate String |
|
41 |
JRT_BLOCK_ENTRY(void, CompilerRuntime::resolve_string_by_symbol(JavaThread *thread, void* string_result, const char* name)) |
|
42 |
JRT_BLOCK |
|
43 |
oop str = *(oop*)string_result; // Is it resolved already? |
|
44 |
if (str == NULL) { // Do resolution |
|
45 |
// First 2 bytes of name contains length (number of bytes). |
|
53147
db1d11c253d8
8216010: Change callers of build_u2_from() to call Bytes::get_Java_u2() instead
hseigel
parents:
49480
diff
changeset
|
46 |
int len = Bytes::get_Java_u2((address)name); |
42650 | 47 |
name += 2; |
48 |
TempNewSymbol sym = SymbolTable::new_symbol(name, len, CHECK); |
|
49 |
str = StringTable::intern(sym, CHECK); |
|
50 |
assert(java_lang_String::is_instance(str), "must be string"); |
|
51 |
*(oop*)string_result = str; // Store result |
|
52 |
} |
|
53 |
assert(str != NULL, "Should be allocated!"); |
|
54 |
thread->set_vm_result(str); |
|
55 |
JRT_BLOCK_END |
|
56 |
JRT_END |
|
57 |
||
58 |
||
59 |
||
60 |
Klass* CompilerRuntime::resolve_klass_helper(JavaThread *thread, const char* name, int len, TRAPS) { |
|
61 |
ResourceMark rm(THREAD); |
|
62 |
// last java frame on stack (which includes native call frames) |
|
63 |
RegisterMap cbl_map(thread, false); |
|
64 |
// Skip stub |
|
65 |
frame caller_frame = thread->last_frame().sender(&cbl_map); |
|
66 |
CodeBlob* caller_cb = caller_frame.cb(); |
|
67 |
guarantee(caller_cb != NULL && caller_cb->is_compiled(), "must be called from compiled method"); |
|
68 |
CompiledMethod* caller_nm = caller_cb->as_compiled_method_or_null(); |
|
69 |
methodHandle caller(THREAD, caller_nm->method()); |
|
70 |
||
71 |
// Use class loader of aot method. |
|
72 |
Handle loader(THREAD, caller->method_holder()->class_loader()); |
|
73 |
Handle protection_domain(THREAD, caller->method_holder()->protection_domain()); |
|
74 |
||
75 |
// Ignore wrapping L and ; |
|
76 |
if (name[0] == 'L') { |
|
77 |
assert(len > 2, "small name %s", name); |
|
78 |
name++; |
|
79 |
len -= 2; |
|
80 |
} |
|
81 |
TempNewSymbol sym = SymbolTable::new_symbol(name, len, CHECK_NULL); |
|
82 |
if (sym == NULL) { |
|
83 |
return NULL; |
|
84 |
} |
|
85 |
Klass* k = SystemDictionary::resolve_or_fail(sym, loader, protection_domain, true, CHECK_NULL); |
|
86 |
||
87 |
return k; |
|
88 |
} |
|
89 |
||
90 |
// Resolve Klass |
|
91 |
JRT_BLOCK_ENTRY(Klass*, CompilerRuntime::resolve_klass_by_symbol(JavaThread *thread, Klass** klass_result, const char* name)) |
|
92 |
Klass* k = NULL; |
|
93 |
JRT_BLOCK |
|
94 |
k = *klass_result; // Is it resolved already? |
|
95 |
if (k == NULL) { // Do resolution |
|
96 |
// First 2 bytes of name contains length (number of bytes). |
|
53147
db1d11c253d8
8216010: Change callers of build_u2_from() to call Bytes::get_Java_u2() instead
hseigel
parents:
49480
diff
changeset
|
97 |
int len = Bytes::get_Java_u2((address)name); |
42650 | 98 |
name += 2; |
99 |
k = CompilerRuntime::resolve_klass_helper(thread, name, len, CHECK_NULL); |
|
100 |
*klass_result = k; // Store result |
|
101 |
} |
|
102 |
JRT_BLOCK_END |
|
103 |
assert(k != NULL, " Should be loaded!"); |
|
104 |
return k; |
|
105 |
JRT_END |
|
106 |
||
107 |
||
108 |
Method* CompilerRuntime::resolve_method_helper(Klass* klass, const char* method_name, int method_name_len, |
|
109 |
const char* signature_name, int signature_name_len) { |
|
110 |
Method* m = NULL; |
|
111 |
TempNewSymbol name_symbol = SymbolTable::probe(method_name, method_name_len); |
|
112 |
TempNewSymbol signature_symbol = SymbolTable::probe(signature_name, signature_name_len); |
|
113 |
if (name_symbol != NULL && signature_symbol != NULL) { |
|
114 |
if (name_symbol == vmSymbols::object_initializer_name() || |
|
115 |
name_symbol == vmSymbols::class_initializer_name()) { |
|
116 |
// Never search superclasses for constructors |
|
117 |
if (klass->is_instance_klass()) { |
|
118 |
m = InstanceKlass::cast(klass)->find_method(name_symbol, signature_symbol); |
|
119 |
} |
|
120 |
} else { |
|
121 |
m = klass->lookup_method(name_symbol, signature_symbol); |
|
122 |
if (m == NULL && klass->is_instance_klass()) { |
|
123 |
m = InstanceKlass::cast(klass)->lookup_method_in_ordered_interfaces(name_symbol, signature_symbol); |
|
124 |
} |
|
125 |
} |
|
126 |
} |
|
127 |
return m; |
|
128 |
} |
|
129 |
||
47668 | 130 |
JRT_BLOCK_ENTRY(void, CompilerRuntime::resolve_dynamic_invoke(JavaThread *thread, oop* appendix_result)) |
131 |
JRT_BLOCK |
|
132 |
{ |
|
133 |
ResourceMark rm(THREAD); |
|
134 |
vframeStream vfst(thread, true); // Do not skip and javaCalls |
|
135 |
assert(!vfst.at_end(), "Java frame must exist"); |
|
136 |
methodHandle caller(THREAD, vfst.method()); |
|
137 |
InstanceKlass* holder = caller->method_holder(); |
|
138 |
int bci = vfst.bci(); |
|
139 |
Bytecode_invoke bytecode(caller, bci); |
|
140 |
int index = bytecode.index(); |
|
141 |
||
142 |
// Make sure it's resolved first |
|
143 |
CallInfo callInfo; |
|
144 |
constantPoolHandle cp(holder->constants()); |
|
145 |
ConstantPoolCacheEntry* cp_cache_entry = cp->cache()->entry_at(cp->decode_cpcache_index(index, true)); |
|
146 |
Bytecodes::Code invoke_code = bytecode.invoke_code(); |
|
147 |
if (!cp_cache_entry->is_resolved(invoke_code)) { |
|
148 |
LinkResolver::resolve_invoke(callInfo, Handle(), cp, index, invoke_code, CHECK); |
|
149 |
if (bytecode.is_invokedynamic()) { |
|
150 |
cp_cache_entry->set_dynamic_call(cp, callInfo); |
|
151 |
} else { |
|
152 |
cp_cache_entry->set_method_handle(cp, callInfo); |
|
153 |
} |
|
154 |
vmassert(cp_cache_entry->is_resolved(invoke_code), "sanity"); |
|
155 |
} |
|
156 |
||
157 |
Handle appendix(THREAD, cp_cache_entry->appendix_if_resolved(cp)); |
|
158 |
Klass *appendix_klass = appendix.is_null() ? NULL : appendix->klass(); |
|
159 |
||
160 |
methodHandle adapter_method(cp_cache_entry->f1_as_method()); |
|
161 |
InstanceKlass *adapter_klass = adapter_method->method_holder(); |
|
162 |
||
163 |
if (appendix_klass != NULL && appendix_klass->is_instance_klass()) { |
|
164 |
vmassert(InstanceKlass::cast(appendix_klass)->is_initialized(), "sanity"); |
|
165 |
} |
|
166 |
if (!adapter_klass->is_initialized()) { |
|
167 |
// Force initialization of adapter class |
|
168 |
adapter_klass->initialize(CHECK); |
|
169 |
// Double-check that it was really initialized, |
|
170 |
// because we could be doing a recursive call |
|
171 |
// from inside <clinit>. |
|
172 |
} |
|
173 |
||
174 |
int cpi = cp_cache_entry->constant_pool_index(); |
|
175 |
if (!AOTLoader::reconcile_dynamic_invoke(holder, cpi, adapter_method(), |
|
176 |
appendix_klass)) { |
|
177 |
return; |
|
178 |
} |
|
179 |
||
180 |
*appendix_result = appendix(); |
|
181 |
thread->set_vm_result(appendix()); |
|
182 |
} |
|
183 |
JRT_BLOCK_END |
|
184 |
JRT_END |
|
185 |
||
42650 | 186 |
JRT_BLOCK_ENTRY(MethodCounters*, CompilerRuntime::resolve_method_by_symbol_and_load_counters(JavaThread *thread, MethodCounters** counters_result, Klass* klass, const char* data)) |
187 |
MethodCounters* c = *counters_result; // Is it resolved already? |
|
188 |
JRT_BLOCK |
|
189 |
if (c == NULL) { // Do resolution |
|
190 |
// Get method name and its length |
|
53147
db1d11c253d8
8216010: Change callers of build_u2_from() to call Bytes::get_Java_u2() instead
hseigel
parents:
49480
diff
changeset
|
191 |
int method_name_len = Bytes::get_Java_u2((address)data); |
42650 | 192 |
data += sizeof(u2); |
193 |
const char* method_name = data; |
|
194 |
data += method_name_len; |
|
195 |
||
196 |
// Get signature and its length |
|
53147
db1d11c253d8
8216010: Change callers of build_u2_from() to call Bytes::get_Java_u2() instead
hseigel
parents:
49480
diff
changeset
|
197 |
int signature_name_len = Bytes::get_Java_u2((address)data); |
42650 | 198 |
data += sizeof(u2); |
199 |
const char* signature_name = data; |
|
200 |
||
201 |
assert(klass != NULL, "Klass parameter must not be null"); |
|
202 |
Method* m = resolve_method_helper(klass, method_name, method_name_len, signature_name, signature_name_len); |
|
203 |
assert(m != NULL, "Method must resolve successfully"); |
|
204 |
||
205 |
// Create method counters immediately to avoid check at runtime. |
|
206 |
c = m->get_method_counters(thread); |
|
207 |
if (c == NULL) { |
|
208 |
THROW_MSG_NULL(vmSymbols::java_lang_OutOfMemoryError(), "Cannot allocate method counters"); |
|
209 |
} |
|
210 |
||
211 |
*counters_result = c; |
|
212 |
} |
|
213 |
JRT_BLOCK_END |
|
214 |
return c; |
|
215 |
JRT_END |
|
216 |
||
217 |
// Resolve and initialize Klass |
|
218 |
JRT_BLOCK_ENTRY(Klass*, CompilerRuntime::initialize_klass_by_symbol(JavaThread *thread, Klass** klass_result, const char* name)) |
|
219 |
Klass* k = NULL; |
|
220 |
JRT_BLOCK |
|
221 |
k = klass_result[0]; // Is it initialized already? |
|
222 |
if (k == NULL) { // Do initialized |
|
223 |
k = klass_result[1]; // Is it resolved already? |
|
224 |
if (k == NULL) { // Do resolution |
|
225 |
// First 2 bytes of name contains length (number of bytes). |
|
53147
db1d11c253d8
8216010: Change callers of build_u2_from() to call Bytes::get_Java_u2() instead
hseigel
parents:
49480
diff
changeset
|
226 |
int len = Bytes::get_Java_u2((address)name); |
42650 | 227 |
const char *cname = name + 2; |
228 |
k = CompilerRuntime::resolve_klass_helper(thread, cname, len, CHECK_NULL); |
|
229 |
klass_result[1] = k; // Store resolved result |
|
230 |
} |
|
231 |
Klass* k0 = klass_result[0]; // Is it initialized already? |
|
232 |
if (k0 == NULL && k != NULL && k->is_instance_klass()) { |
|
233 |
// Force initialization of instance class |
|
234 |
InstanceKlass::cast(k)->initialize(CHECK_NULL); |
|
235 |
// Double-check that it was really initialized, |
|
236 |
// because we could be doing a recursive call |
|
237 |
// from inside <clinit>. |
|
238 |
if (InstanceKlass::cast(k)->is_initialized()) { |
|
239 |
klass_result[0] = k; // Store initialized result |
|
240 |
} |
|
241 |
} |
|
242 |
} |
|
243 |
JRT_BLOCK_END |
|
244 |
assert(k != NULL, " Should be loaded!"); |
|
245 |
return k; |
|
246 |
JRT_END |
|
247 |
||
248 |
||
249 |
JRT_BLOCK_ENTRY(void, CompilerRuntime::invocation_event(JavaThread *thread, MethodCounters* counters)) |
|
250 |
if (!TieredCompilation) { |
|
251 |
// Ignore the event if tiered is off |
|
252 |
return; |
|
253 |
} |
|
254 |
JRT_BLOCK |
|
255 |
methodHandle mh(THREAD, counters->method()); |
|
256 |
RegisterMap map(thread, false); |
|
257 |
||
258 |
// Compute the enclosing method |
|
259 |
frame fr = thread->last_frame().sender(&map); |
|
260 |
CompiledMethod* cm = fr.cb()->as_compiled_method_or_null(); |
|
261 |
assert(cm != NULL && cm->is_compiled(), "Sanity check"); |
|
262 |
methodHandle emh(THREAD, cm->method()); |
|
263 |
||
264 |
assert(!HAS_PENDING_EXCEPTION, "Should not have any exceptions pending"); |
|
265 |
CompilationPolicy::policy()->event(emh, mh, InvocationEntryBci, InvocationEntryBci, CompLevel_aot, cm, thread); |
|
266 |
assert(!HAS_PENDING_EXCEPTION, "Event handler should not throw any exceptions"); |
|
267 |
JRT_BLOCK_END |
|
268 |
JRT_END |
|
269 |
||
270 |
JRT_BLOCK_ENTRY(void, CompilerRuntime::backedge_event(JavaThread *thread, MethodCounters* counters, int branch_bci, int target_bci)) |
|
271 |
if (!TieredCompilation) { |
|
272 |
// Ignore the event if tiered is off |
|
273 |
return; |
|
274 |
} |
|
275 |
assert(branch_bci != InvocationEntryBci && target_bci != InvocationEntryBci, "Wrong bci"); |
|
276 |
assert(target_bci <= branch_bci, "Expected a back edge"); |
|
277 |
JRT_BLOCK |
|
278 |
methodHandle mh(THREAD, counters->method()); |
|
279 |
RegisterMap map(thread, false); |
|
280 |
||
281 |
// Compute the enclosing method |
|
282 |
frame fr = thread->last_frame().sender(&map); |
|
283 |
CompiledMethod* cm = fr.cb()->as_compiled_method_or_null(); |
|
284 |
assert(cm != NULL && cm->is_compiled(), "Sanity check"); |
|
285 |
methodHandle emh(THREAD, cm->method()); |
|
286 |
assert(!HAS_PENDING_EXCEPTION, "Should not have any exceptions pending"); |
|
287 |
nmethod* osr_nm = CompilationPolicy::policy()->event(emh, mh, branch_bci, target_bci, CompLevel_aot, cm, thread); |
|
288 |
assert(!HAS_PENDING_EXCEPTION, "Event handler should not throw any exceptions"); |
|
289 |
if (osr_nm != NULL) { |
|
290 |
Deoptimization::deoptimize_frame(thread, fr.id()); |
|
291 |
} |
|
292 |
JRT_BLOCK_END |
|
293 |
JRT_END |