42650
|
1 |
/*
|
|
2 |
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
|
|
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"
|
|
25 |
|
|
26 |
#include "aot/aotCodeHeap.hpp"
|
|
27 |
#include "aot/aotLoader.hpp"
|
|
28 |
#include "aot/compiledIC_aot.hpp"
|
|
29 |
#include "code/codeCache.hpp"
|
|
30 |
#include "code/compiledIC.hpp"
|
|
31 |
#include "code/nativeInst.hpp"
|
|
32 |
#include "compiler/compilerOracle.hpp"
|
|
33 |
#include "gc/shared/cardTableModRefBS.hpp"
|
|
34 |
#include "gc/shared/collectedHeap.hpp"
|
|
35 |
#include "gc/shared/gcLocker.hpp"
|
|
36 |
#include "jvmci/compilerRuntime.hpp"
|
|
37 |
#include "jvmci/jvmciRuntime.hpp"
|
|
38 |
#include "oops/method.hpp"
|
|
39 |
#include "runtime/java.hpp"
|
|
40 |
#include "runtime/os.hpp"
|
|
41 |
#include "runtime/sharedRuntime.hpp"
|
|
42 |
#include "utilities/array.hpp"
|
|
43 |
#include "utilities/xmlstream.hpp"
|
|
44 |
|
|
45 |
#include <dlfcn.h>
|
|
46 |
#include <stdio.h>
|
|
47 |
|
|
48 |
#if 0
|
|
49 |
static void metadata_oops_do(Metadata** metadata_begin, Metadata **metadata_end, OopClosure* f) {
|
|
50 |
// Visit the metadata/oops section
|
|
51 |
for (Metadata** p = metadata_begin; p < metadata_end; p++) {
|
|
52 |
Metadata* m = *p;
|
|
53 |
|
|
54 |
intptr_t meta = (intptr_t)m;
|
|
55 |
if ((meta & 1) == 1) {
|
|
56 |
// already resolved
|
|
57 |
m = (Metadata*)(meta & ~1);
|
|
58 |
} else {
|
|
59 |
continue;
|
|
60 |
}
|
|
61 |
assert(Metaspace::contains(m), "");
|
|
62 |
if (m->is_method()) {
|
|
63 |
m = ((Method*)m)->method_holder();
|
|
64 |
}
|
|
65 |
assert(m->is_klass(), "must be");
|
|
66 |
oop o = ((Klass*)m)->klass_holder();
|
|
67 |
if (o != NULL) {
|
|
68 |
f->do_oop(&o);
|
|
69 |
}
|
|
70 |
}
|
|
71 |
}
|
|
72 |
#endif
|
|
73 |
|
43461
|
74 |
void AOTCompiledMethod::oops_do(OopClosure* f) {
|
|
75 |
if (_oop != NULL) {
|
|
76 |
f->do_oop(&_oop);
|
|
77 |
}
|
|
78 |
#if 0
|
|
79 |
metadata_oops_do(metadata_begin(), metadata_end(), f);
|
|
80 |
#endif
|
|
81 |
}
|
|
82 |
|
42650
|
83 |
bool AOTCompiledMethod::do_unloading_oops(address low_boundary, BoolObjectClosure* is_alive, bool unloading_occurred) {
|
|
84 |
return false;
|
|
85 |
}
|
|
86 |
|
|
87 |
oop AOTCompiledMethod::oop_at(int index) const {
|
|
88 |
if (index == 0) { // 0 is reserved
|
|
89 |
return NULL;
|
|
90 |
}
|
|
91 |
Metadata** entry = _metadata_got + (index - 1);
|
|
92 |
intptr_t meta = (intptr_t)*entry;
|
|
93 |
if ((meta & 1) == 1) {
|
|
94 |
// already resolved
|
|
95 |
Klass* k = (Klass*)(meta & ~1);
|
|
96 |
return k->java_mirror();
|
|
97 |
}
|
|
98 |
// The entry is string which we need to resolve.
|
|
99 |
const char* meta_name = _heap->get_name_at((int)meta);
|
|
100 |
int klass_len = build_u2_from((address)meta_name);
|
|
101 |
const char* klass_name = meta_name + 2;
|
|
102 |
// Quick check the current method's holder.
|
|
103 |
Klass* k = _method->method_holder();
|
|
104 |
|
|
105 |
ResourceMark rm; // for signature_name()
|
|
106 |
if (strncmp(k->signature_name(), klass_name, klass_len) != 0) { // Does not match?
|
|
107 |
// Search klass in got cells in DSO which have this compiled method.
|
|
108 |
k = _heap->get_klass_from_got(klass_name, klass_len, _method);
|
|
109 |
}
|
|
110 |
int method_name_len = build_u2_from((address)klass_name + klass_len);
|
|
111 |
guarantee(method_name_len == 0, "only klass is expected here");
|
|
112 |
meta = ((intptr_t)k) | 1;
|
|
113 |
*entry = (Metadata*)meta; // Should be atomic on x64
|
|
114 |
return k->java_mirror();
|
|
115 |
}
|
|
116 |
|
|
117 |
Metadata* AOTCompiledMethod::metadata_at(int index) const {
|
|
118 |
if (index == 0) { // 0 is reserved
|
|
119 |
return NULL;
|
|
120 |
}
|
|
121 |
assert(index - 1 < _metadata_size, "");
|
|
122 |
{
|
|
123 |
Metadata** entry = _metadata_got + (index - 1);
|
|
124 |
intptr_t meta = (intptr_t)*entry;
|
|
125 |
if ((meta & 1) == 1) {
|
|
126 |
// already resolved
|
|
127 |
Metadata *m = (Metadata*)(meta & ~1);
|
|
128 |
return m;
|
|
129 |
}
|
|
130 |
// The entry is string which we need to resolve.
|
|
131 |
const char* meta_name = _heap->get_name_at((int)meta);
|
|
132 |
int klass_len = build_u2_from((address)meta_name);
|
|
133 |
const char* klass_name = meta_name + 2;
|
|
134 |
// Quick check the current method's holder.
|
|
135 |
Klass* k = _method->method_holder();
|
|
136 |
bool klass_matched = true;
|
|
137 |
|
|
138 |
ResourceMark rm; // for signature_name() and find_method()
|
|
139 |
if (strncmp(k->signature_name(), klass_name, klass_len) != 0) { // Does not match?
|
|
140 |
// Search klass in got cells in DSO which have this compiled method.
|
|
141 |
k = _heap->get_klass_from_got(klass_name, klass_len, _method);
|
|
142 |
klass_matched = false;
|
|
143 |
}
|
|
144 |
int method_name_len = build_u2_from((address)klass_name + klass_len);
|
|
145 |
if (method_name_len == 0) { // Array or Klass name only?
|
|
146 |
meta = ((intptr_t)k) | 1;
|
|
147 |
*entry = (Metadata*)meta; // Should be atomic on x64
|
|
148 |
return (Metadata*)k;
|
|
149 |
} else { // Method
|
|
150 |
// Quick check the current method's name.
|
|
151 |
Method* m = _method;
|
|
152 |
int signature_len = build_u2_from((address)klass_name + klass_len + 2 + method_name_len);
|
|
153 |
int full_len = 2 + klass_len + 2 + method_name_len + 2 + signature_len;
|
|
154 |
if (!klass_matched || memcmp(_name, meta_name, full_len) != 0) { // Does not match?
|
|
155 |
Thread* thread = Thread::current();
|
|
156 |
KlassHandle klass = KlassHandle(thread, k);
|
|
157 |
const char* method_name = klass_name + klass_len;
|
|
158 |
m = AOTCodeHeap::find_method(klass, thread, method_name);
|
|
159 |
}
|
|
160 |
meta = ((intptr_t)m) | 1;
|
|
161 |
*entry = (Metadata*)meta; // Should be atomic on x64
|
|
162 |
return (Metadata*)m;
|
|
163 |
}
|
43461
|
164 |
// need to resolve it here..., patching of GOT need to be CAS or atomic operation.
|
|
165 |
// FIXIT: need methods for debuginfo.
|
|
166 |
// return _method;
|
42650
|
167 |
}
|
|
168 |
ShouldNotReachHere(); return NULL;
|
|
169 |
}
|
|
170 |
|
|
171 |
bool AOTCompiledMethod::make_not_entrant_helper(int new_state) {
|
|
172 |
// Make sure the method is not flushed in case of a safepoint in code below.
|
|
173 |
methodHandle the_method(method());
|
|
174 |
NoSafepointVerifier nsv;
|
|
175 |
|
|
176 |
{
|
|
177 |
// Enter critical section. Does not block for safepoint.
|
|
178 |
MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
|
|
179 |
|
|
180 |
if (*_state_adr == new_state) {
|
|
181 |
// another thread already performed this transition so nothing
|
|
182 |
// to do, but return false to indicate this.
|
|
183 |
return false;
|
|
184 |
}
|
|
185 |
|
|
186 |
// Change state
|
|
187 |
OrderAccess::storestore();
|
|
188 |
*_state_adr = new_state;
|
|
189 |
|
|
190 |
// Log the transition once
|
|
191 |
log_state_change();
|
|
192 |
|
|
193 |
#ifdef TIERED
|
|
194 |
// Remain non-entrant forever
|
|
195 |
if (new_state == not_entrant && method() != NULL) {
|
|
196 |
method()->set_aot_code(NULL);
|
|
197 |
}
|
|
198 |
#endif
|
|
199 |
|
|
200 |
// Remove AOTCompiledMethod from method.
|
|
201 |
if (method() != NULL && (method()->code() == this ||
|
|
202 |
method()->from_compiled_entry() == verified_entry_point())) {
|
|
203 |
HandleMark hm;
|
|
204 |
method()->clear_code(false /* already owns Patching_lock */);
|
|
205 |
}
|
|
206 |
} // leave critical region under Patching_lock
|
|
207 |
|
|
208 |
|
|
209 |
if (TraceCreateZombies) {
|
|
210 |
ResourceMark m;
|
|
211 |
const char *new_state_str = (new_state == not_entrant) ? "not entrant" : "not used";
|
|
212 |
tty->print_cr("aot method <" INTPTR_FORMAT "> %s code made %s", p2i(this), this->method() ? this->method()->name_and_sig_as_C_string() : "null", new_state_str);
|
|
213 |
}
|
|
214 |
|
|
215 |
return true;
|
|
216 |
}
|
|
217 |
|
|
218 |
bool AOTCompiledMethod::make_entrant() {
|
|
219 |
assert(!method()->is_old(), "reviving evolved method!");
|
|
220 |
assert(*_state_adr != not_entrant, "%s", method()->has_aot_code() ? "has_aot_code() not cleared" : "caller didn't check has_aot_code()");
|
|
221 |
|
|
222 |
// Make sure the method is not flushed in case of a safepoint in code below.
|
|
223 |
methodHandle the_method(method());
|
|
224 |
NoSafepointVerifier nsv;
|
|
225 |
|
|
226 |
{
|
|
227 |
// Enter critical section. Does not block for safepoint.
|
|
228 |
MutexLockerEx pl(Patching_lock, Mutex::_no_safepoint_check_flag);
|
|
229 |
|
|
230 |
if (*_state_adr == in_use) {
|
|
231 |
// another thread already performed this transition so nothing
|
|
232 |
// to do, but return false to indicate this.
|
|
233 |
return false;
|
|
234 |
}
|
|
235 |
|
|
236 |
// Change state
|
|
237 |
OrderAccess::storestore();
|
|
238 |
*_state_adr = in_use;
|
|
239 |
|
|
240 |
// Log the transition once
|
|
241 |
log_state_change();
|
|
242 |
} // leave critical region under Patching_lock
|
|
243 |
|
|
244 |
|
|
245 |
if (TraceCreateZombies) {
|
|
246 |
ResourceMark m;
|
|
247 |
tty->print_cr("aot method <" INTPTR_FORMAT "> %s code made entrant", p2i(this), this->method() ? this->method()->name_and_sig_as_C_string() : "null");
|
|
248 |
}
|
|
249 |
|
|
250 |
return true;
|
|
251 |
}
|
|
252 |
|
|
253 |
// We don't have full dependencies for AOT methods, so flushing is
|
|
254 |
// more conservative than for nmethods.
|
|
255 |
void AOTCompiledMethod::flush_evol_dependents_on(instanceKlassHandle dependee) {
|
|
256 |
if (is_java_method()) {
|
|
257 |
cleanup_inline_caches();
|
|
258 |
mark_for_deoptimization();
|
|
259 |
make_not_entrant();
|
|
260 |
}
|
|
261 |
}
|
|
262 |
|
|
263 |
// Iterate over metadata calling this function. Used by RedefineClasses
|
|
264 |
// Copied from nmethod::metadata_do
|
|
265 |
void AOTCompiledMethod::metadata_do(void f(Metadata*)) {
|
|
266 |
address low_boundary = verified_entry_point();
|
|
267 |
{
|
|
268 |
// Visit all immediate references that are embedded in the instruction stream.
|
|
269 |
RelocIterator iter(this, low_boundary);
|
|
270 |
while (iter.next()) {
|
|
271 |
if (iter.type() == relocInfo::metadata_type ) {
|
|
272 |
metadata_Relocation* r = iter.metadata_reloc();
|
|
273 |
// In this metadata, we must only follow those metadatas directly embedded in
|
|
274 |
// the code. Other metadatas (oop_index>0) are seen as part of
|
|
275 |
// the metadata section below.
|
|
276 |
assert(1 == (r->metadata_is_immediate()) +
|
|
277 |
(r->metadata_addr() >= metadata_begin() && r->metadata_addr() < metadata_end()),
|
|
278 |
"metadata must be found in exactly one place");
|
|
279 |
if (r->metadata_is_immediate() && r->metadata_value() != NULL) {
|
|
280 |
Metadata* md = r->metadata_value();
|
|
281 |
if (md != _method) f(md);
|
|
282 |
}
|
|
283 |
} else if (iter.type() == relocInfo::virtual_call_type) {
|
|
284 |
// Check compiledIC holders associated with this nmethod
|
|
285 |
CompiledIC *ic = CompiledIC_at(&iter);
|
|
286 |
if (ic->is_icholder_call()) {
|
|
287 |
CompiledICHolder* cichk = ic->cached_icholder();
|
|
288 |
f(cichk->holder_method());
|
|
289 |
f(cichk->holder_klass());
|
|
290 |
} else {
|
|
291 |
Metadata* ic_oop = ic->cached_metadata();
|
|
292 |
if (ic_oop != NULL) {
|
|
293 |
f(ic_oop);
|
|
294 |
}
|
|
295 |
}
|
|
296 |
}
|
|
297 |
}
|
|
298 |
}
|
|
299 |
|
|
300 |
// Visit the metadata section
|
|
301 |
for (Metadata** p = metadata_begin(); p < metadata_end(); p++) {
|
|
302 |
Metadata* m = *p;
|
|
303 |
|
|
304 |
intptr_t meta = (intptr_t)m;
|
|
305 |
if ((meta & 1) == 1) {
|
|
306 |
// already resolved
|
|
307 |
m = (Metadata*)(meta & ~1);
|
|
308 |
} else {
|
|
309 |
continue;
|
|
310 |
}
|
|
311 |
assert(Metaspace::contains(m), "");
|
|
312 |
f(m);
|
|
313 |
}
|
|
314 |
|
|
315 |
// Visit metadata not embedded in the other places.
|
|
316 |
if (_method != NULL) f(_method);
|
|
317 |
}
|
|
318 |
|
|
319 |
void AOTCompiledMethod::print() const {
|
|
320 |
print_on(tty, "AOTCompiledMethod");
|
|
321 |
}
|
|
322 |
|
|
323 |
void AOTCompiledMethod::print_on(outputStream* st) const {
|
|
324 |
print_on(st, "AOTCompiledMethod");
|
|
325 |
}
|
|
326 |
|
|
327 |
// Print out more verbose output usually for a newly created aot method.
|
|
328 |
void AOTCompiledMethod::print_on(outputStream* st, const char* msg) const {
|
|
329 |
if (st != NULL) {
|
|
330 |
ttyLocker ttyl;
|
|
331 |
st->print("%7d ", (int) st->time_stamp().milliseconds());
|
|
332 |
st->print("%4d ", _aot_id); // print compilation number
|
|
333 |
st->print(" aot[%2d]", _heap->dso_id());
|
|
334 |
// Stubs have _method == NULL
|
43461
|
335 |
st->print(" %s", (_method == NULL ? _name : _method->name_and_sig_as_C_string()));
|
42650
|
336 |
if (Verbose) {
|
|
337 |
st->print(" entry at " INTPTR_FORMAT, p2i(_code));
|
|
338 |
}
|
|
339 |
if (msg != NULL) {
|
|
340 |
st->print(" %s", msg);
|
|
341 |
}
|
|
342 |
st->cr();
|
|
343 |
}
|
|
344 |
}
|
|
345 |
|
|
346 |
void AOTCompiledMethod::print_value_on(outputStream* st) const {
|
|
347 |
st->print("AOTCompiledMethod ");
|
|
348 |
print_on(st, NULL);
|
|
349 |
}
|
|
350 |
|
|
351 |
// Print a short set of xml attributes to identify this aot method. The
|
|
352 |
// output should be embedded in some other element.
|
|
353 |
void AOTCompiledMethod::log_identity(xmlStream* log) const {
|
|
354 |
log->print(" aot_id='%d'", _aot_id);
|
|
355 |
log->print(" aot='%2d'", _heap->dso_id());
|
|
356 |
}
|
|
357 |
|
|
358 |
void AOTCompiledMethod::log_state_change() const {
|
|
359 |
if (LogCompilation) {
|
|
360 |
ResourceMark m;
|
|
361 |
if (xtty != NULL) {
|
|
362 |
ttyLocker ttyl; // keep the following output all in one block
|
|
363 |
if (*_state_adr == not_entrant) {
|
|
364 |
xtty->begin_elem("make_not_entrant thread='" UINTX_FORMAT "'",
|
|
365 |
os::current_thread_id());
|
|
366 |
} else if (*_state_adr == not_used) {
|
|
367 |
xtty->begin_elem("make_not_used thread='" UINTX_FORMAT "'",
|
|
368 |
os::current_thread_id());
|
|
369 |
} else if (*_state_adr == in_use) {
|
|
370 |
xtty->begin_elem("make_entrant thread='" UINTX_FORMAT "'",
|
|
371 |
os::current_thread_id());
|
|
372 |
}
|
|
373 |
log_identity(xtty);
|
|
374 |
xtty->stamp();
|
|
375 |
xtty->end_elem();
|
|
376 |
}
|
|
377 |
}
|
|
378 |
if (PrintCompilation) {
|
|
379 |
ResourceMark m;
|
|
380 |
if (*_state_adr == not_entrant) {
|
|
381 |
print_on(tty, "made not entrant");
|
|
382 |
} else if (*_state_adr == not_used) {
|
|
383 |
print_on(tty, "made not used");
|
|
384 |
} else if (*_state_adr == in_use) {
|
|
385 |
print_on(tty, "made entrant");
|
|
386 |
}
|
|
387 |
}
|
|
388 |
}
|
|
389 |
|
|
390 |
|
|
391 |
NativeInstruction* PltNativeCallWrapper::get_load_instruction(virtual_call_Relocation* r) const {
|
|
392 |
return nativeLoadGot_at(_call->plt_load_got());
|
|
393 |
}
|
|
394 |
|
|
395 |
void PltNativeCallWrapper::verify_resolve_call(address dest) const {
|
|
396 |
CodeBlob* db = CodeCache::find_blob_unsafe(dest);
|
|
397 |
if (db == NULL) {
|
|
398 |
assert(dest == _call->plt_resolve_call(), "sanity");
|
|
399 |
}
|
|
400 |
}
|
|
401 |
|
|
402 |
void PltNativeCallWrapper::set_to_interpreted(const methodHandle& method, CompiledICInfo& info) {
|
|
403 |
assert(!info.to_aot(), "only for nmethod");
|
|
404 |
CompiledPltStaticCall* csc = CompiledPltStaticCall::at(instruction_address());
|
|
405 |
csc->set_to_interpreted(method, info.entry());
|
|
406 |
}
|
|
407 |
|
|
408 |
NativeCallWrapper* AOTCompiledMethod::call_wrapper_at(address call) const {
|
|
409 |
return new PltNativeCallWrapper((NativePltCall*) call);
|
|
410 |
}
|
|
411 |
|
|
412 |
NativeCallWrapper* AOTCompiledMethod::call_wrapper_before(address return_pc) const {
|
|
413 |
return new PltNativeCallWrapper(nativePltCall_before(return_pc));
|
|
414 |
}
|
|
415 |
|
|
416 |
CompiledStaticCall* AOTCompiledMethod::compiledStaticCall_at(Relocation* call_site) const {
|
|
417 |
return CompiledPltStaticCall::at(call_site);
|
|
418 |
}
|
|
419 |
|
|
420 |
CompiledStaticCall* AOTCompiledMethod::compiledStaticCall_at(address call_site) const {
|
|
421 |
return CompiledPltStaticCall::at(call_site);
|
|
422 |
}
|
|
423 |
|
|
424 |
CompiledStaticCall* AOTCompiledMethod::compiledStaticCall_before(address return_addr) const {
|
|
425 |
return CompiledPltStaticCall::before(return_addr);
|
|
426 |
}
|
|
427 |
|
|
428 |
address AOTCompiledMethod::call_instruction_address(address pc) const {
|
|
429 |
NativePltCall* pltcall = nativePltCall_before(pc);
|
|
430 |
return pltcall->instruction_address();
|
|
431 |
}
|
|
432 |
|
|
433 |
bool AOTCompiledMethod::is_evol_dependent_on(Klass* dependee) {
|
|
434 |
return !is_aot_runtime_stub() && _heap->is_dependent_method(dependee, this);
|
|
435 |
}
|
|
436 |
|
|
437 |
void AOTCompiledMethod::clear_inline_caches() {
|
|
438 |
assert(SafepointSynchronize::is_at_safepoint(), "cleaning of IC's only allowed at safepoint");
|
|
439 |
if (is_zombie()) {
|
|
440 |
return;
|
|
441 |
}
|
|
442 |
|
|
443 |
RelocIterator iter(this);
|
|
444 |
while (iter.next()) {
|
|
445 |
iter.reloc()->clear_inline_cache();
|
|
446 |
if (iter.type() == relocInfo::opt_virtual_call_type) {
|
|
447 |
CompiledIC* cic = CompiledIC_at(&iter);
|
|
448 |
assert(cic->is_clean(), "!");
|
|
449 |
nativePltCall_at(iter.addr())->set_stub_to_clean();
|
|
450 |
}
|
|
451 |
}
|
|
452 |
}
|
|
453 |
|