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