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 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 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 } 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; 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 335 st->print(" %s", (_method == NULL ? _name : _method->name_and_sig_as_C_string())); 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