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