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