1 /* 2 * Copyright (c) 1998, 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 25 #include "precompiled.hpp" 26 #include "jvm.h" 27 #include "code/codeBlob.hpp" 28 #include "code/codeCache.hpp" 29 #include "code/icBuffer.hpp" 30 #include "code/relocInfo.hpp" 31 #include "code/vtableStubs.hpp" 32 #include "compiler/disassembler.hpp" 33 #include "interpreter/bytecode.hpp" 34 #include "memory/allocation.inline.hpp" 35 #include "memory/heap.hpp" 36 #include "memory/resourceArea.hpp" 37 #include "oops/oop.inline.hpp" 38 #include "prims/forte.hpp" 39 #include "runtime/handles.inline.hpp" 40 #include "runtime/interfaceSupport.inline.hpp" 41 #include "runtime/mutexLocker.hpp" 42 #include "runtime/safepoint.hpp" 43 #include "runtime/sharedRuntime.hpp" 44 #include "runtime/vframe.hpp" 45 #include "services/memoryService.hpp" 46 #include "utilities/align.hpp" 47 #ifdef COMPILER1 48 #include "c1/c1_Runtime1.hpp" 49 #endif 50 51 const char* CodeBlob::compiler_name() const { 52 return compilertype2name(_type); 53 } 54 55 unsigned int CodeBlob::align_code_offset(int offset) { 56 // align the size to CodeEntryAlignment 57 return 58 ((offset + (int)CodeHeap::header_size() + (CodeEntryAlignment-1)) & ~(CodeEntryAlignment-1)) 59 - (int)CodeHeap::header_size(); 60 } 61 62 63 // This must be consistent with the CodeBlob constructor's layout actions. 64 unsigned int CodeBlob::allocation_size(CodeBuffer* cb, int header_size) { 65 unsigned int size = header_size; 66 size += align_up(cb->total_relocation_size(), oopSize); 67 // align the size to CodeEntryAlignment 68 size = align_code_offset(size); 69 size += align_up(cb->total_content_size(), oopSize); 70 size += align_up(cb->total_oop_size(), oopSize); 71 size += align_up(cb->total_metadata_size(), oopSize); 72 return size; 73 } 74 75 CodeBlob::CodeBlob(const char* name, CompilerType type, const CodeBlobLayout& layout, int frame_complete_offset, int frame_size, ImmutableOopMapSet* oop_maps, bool caller_must_gc_arguments) : 76 _type(type), 77 _size(layout.size()), 78 _header_size(layout.header_size()), 79 _frame_complete_offset(frame_complete_offset), 80 _data_offset(layout.data_offset()), 81 _frame_size(frame_size), 82 _code_begin(layout.code_begin()), 83 _code_end(layout.code_end()), 84 _content_begin(layout.content_begin()), 85 _data_end(layout.data_end()), 86 _relocation_begin(layout.relocation_begin()), 87 _relocation_end(layout.relocation_end()), 88 _oop_maps(oop_maps), 89 _caller_must_gc_arguments(caller_must_gc_arguments), 90 _strings(CodeStrings()), 91 _name(name) 92 { 93 assert(is_aligned(layout.size(), oopSize), "unaligned size"); 94 assert(is_aligned(layout.header_size(), oopSize), "unaligned size"); 95 assert(is_aligned(layout.relocation_size(), oopSize), "unaligned size"); 96 assert(layout.code_end() == layout.content_end(), "must be the same - see code_end()"); 97 #ifdef COMPILER1 98 // probably wrong for tiered 99 assert(_frame_size >= -1, "must use frame size or -1 for runtime stubs"); 100 #endif // COMPILER1 101 } 102 103 CodeBlob::CodeBlob(const char* name, CompilerType type, const CodeBlobLayout& layout, CodeBuffer* cb, int frame_complete_offset, int frame_size, OopMapSet* oop_maps, bool caller_must_gc_arguments) : 104 _type(type), 105 _size(layout.size()), 106 _header_size(layout.header_size()), 107 _frame_complete_offset(frame_complete_offset), 108 _data_offset(layout.data_offset()), 109 _frame_size(frame_size), 110 _code_begin(layout.code_begin()), 111 _code_end(layout.code_end()), 112 _content_begin(layout.content_begin()), 113 _data_end(layout.data_end()), 114 _relocation_begin(layout.relocation_begin()), 115 _relocation_end(layout.relocation_end()), 116 _caller_must_gc_arguments(caller_must_gc_arguments), 117 _strings(CodeStrings()), 118 _name(name) 119 { 120 assert(is_aligned(_size, oopSize), "unaligned size"); 121 assert(is_aligned(_header_size, oopSize), "unaligned size"); 122 assert(_data_offset <= _size, "codeBlob is too small"); 123 assert(layout.code_end() == layout.content_end(), "must be the same - see code_end()"); 124 125 set_oop_maps(oop_maps); 126 #ifdef COMPILER1 127 // probably wrong for tiered 128 assert(_frame_size >= -1, "must use frame size or -1 for runtime stubs"); 129 #endif // COMPILER1 130 } 131 132 133 // Creates a simple CodeBlob. Sets up the size of the different regions. 134 RuntimeBlob::RuntimeBlob(const char* name, int header_size, int size, int frame_complete, int locs_size) 135 : CodeBlob(name, compiler_none, CodeBlobLayout((address) this, size, header_size, locs_size, size), frame_complete, 0, NULL, false /* caller_must_gc_arguments */) 136 { 137 assert(is_aligned(locs_size, oopSize), "unaligned size"); 138 } 139 140 141 // Creates a RuntimeBlob from a CodeBuffer 142 // and copy code and relocation info. 143 RuntimeBlob::RuntimeBlob( 144 const char* name, 145 CodeBuffer* cb, 146 int header_size, 147 int size, 148 int frame_complete, 149 int frame_size, 150 OopMapSet* oop_maps, 151 bool caller_must_gc_arguments 152 ) : CodeBlob(name, compiler_none, CodeBlobLayout((address) this, size, header_size, cb), cb, frame_complete, frame_size, oop_maps, caller_must_gc_arguments) { 153 cb->copy_code_and_locs_to(this); 154 } 155 156 void CodeBlob::flush() { 157 if (_oop_maps) { 158 FREE_C_HEAP_ARRAY(unsigned char, _oop_maps); 159 _oop_maps = NULL; 160 } 161 _strings.free(); 162 } 163 164 void CodeBlob::set_oop_maps(OopMapSet* p) { 165 // Danger Will Robinson! This method allocates a big 166 // chunk of memory, its your job to free it. 167 if (p != NULL) { 168 _oop_maps = ImmutableOopMapSet::build_from(p); 169 } else { 170 _oop_maps = NULL; 171 } 172 } 173 174 175 void RuntimeBlob::trace_new_stub(RuntimeBlob* stub, const char* name1, const char* name2) { 176 // Do not hold the CodeCache lock during name formatting. 177 assert(!CodeCache_lock->owned_by_self(), "release CodeCache before registering the stub"); 178 179 if (stub != NULL) { 180 char stub_id[256]; 181 assert(strlen(name1) + strlen(name2) < sizeof(stub_id), ""); 182 jio_snprintf(stub_id, sizeof(stub_id), "%s%s", name1, name2); 183 if (PrintStubCode) { 184 ttyLocker ttyl; 185 tty->print_cr("Decoding %s " INTPTR_FORMAT, stub_id, (intptr_t) stub); 186 Disassembler::decode(stub->code_begin(), stub->code_end()); 187 tty->cr(); 188 } 189 Forte::register_stub(stub_id, stub->code_begin(), stub->code_end()); 190 191 if (JvmtiExport::should_post_dynamic_code_generated()) { 192 const char* stub_name = name2; 193 if (name2[0] == '\0') stub_name = name1; 194 JvmtiExport::post_dynamic_code_generated(stub_name, stub->code_begin(), stub->code_end()); 195 } 196 } 197 198 // Track memory usage statistic after releasing CodeCache_lock 199 MemoryService::track_code_cache_memory_usage(); 200 } 201 202 const ImmutableOopMap* CodeBlob::oop_map_for_return_address(address return_address) { 203 assert(_oop_maps != NULL, "nope"); 204 return _oop_maps->find_map_at_offset((intptr_t) return_address - (intptr_t) code_begin()); 205 } 206 207 void CodeBlob::print_code() { 208 ResourceMark m; 209 Disassembler::decode(this, tty); 210 } 211 212 //---------------------------------------------------------------------------------------------------- 213 // Implementation of BufferBlob 214 215 216 BufferBlob::BufferBlob(const char* name, int size) 217 : RuntimeBlob(name, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, /*locs_size:*/ 0) 218 {} 219 220 BufferBlob* BufferBlob::create(const char* name, int buffer_size) { 221 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 222 223 BufferBlob* blob = NULL; 224 unsigned int size = sizeof(BufferBlob); 225 // align the size to CodeEntryAlignment 226 size = CodeBlob::align_code_offset(size); 227 size += align_up(buffer_size, oopSize); 228 assert(name != NULL, "must provide a name"); 229 { 230 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 231 blob = new (size) BufferBlob(name, size); 232 } 233 // Track memory usage statistic after releasing CodeCache_lock 234 MemoryService::track_code_cache_memory_usage(); 235 236 return blob; 237 } 238 239 240 BufferBlob::BufferBlob(const char* name, int size, CodeBuffer* cb) 241 : RuntimeBlob(name, cb, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, 0, NULL) 242 {} 243 244 BufferBlob* BufferBlob::create(const char* name, CodeBuffer* cb) { 245 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 246 247 BufferBlob* blob = NULL; 248 unsigned int size = CodeBlob::allocation_size(cb, sizeof(BufferBlob)); 249 assert(name != NULL, "must provide a name"); 250 { 251 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 252 blob = new (size) BufferBlob(name, size, cb); 253 } 254 // Track memory usage statistic after releasing CodeCache_lock 255 MemoryService::track_code_cache_memory_usage(); 256 257 return blob; 258 } 259 260 void* BufferBlob::operator new(size_t s, unsigned size) throw() { 261 return CodeCache::allocate(size, CodeBlobType::NonNMethod); 262 } 263 264 void BufferBlob::free(BufferBlob *blob) { 265 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 266 blob->flush(); 267 { 268 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 269 CodeCache::free((RuntimeBlob*)blob); 270 } 271 // Track memory usage statistic after releasing CodeCache_lock 272 MemoryService::track_code_cache_memory_usage(); 273 } 274 275 BufferBlob::BufferBlob(const char* name, int size, CodeBuffer* cb, int frame_complete, int frame_size, OopMapSet* oop_maps, bool caller_must_gc_arguments) 276 : RuntimeBlob(name, cb, sizeof(BufferBlob), size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments) 277 {} 278 279 280 //---------------------------------------------------------------------------------------------------- 281 // Implementation of AdapterBlob 282 283 AdapterBlob::AdapterBlob(int size, CodeBuffer* cb, int frame_complete, int frame_size, OopMapSet* oop_maps, bool caller_must_gc_arguments) : 284 BufferBlob("I2C/C2I adapters", size, cb, frame_complete, frame_size, oop_maps, caller_must_gc_arguments) { 285 CodeCache::commit(this); 286 } 287 288 AdapterBlob* AdapterBlob::create(CodeBuffer* cb, int frame_complete, int frame_size, OopMapSet* oop_maps, bool caller_must_gc_arguments) { 289 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 290 291 AdapterBlob* blob = NULL; 292 unsigned int size = CodeBlob::allocation_size(cb, sizeof(AdapterBlob)); 293 { 294 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 295 blob = new (size) AdapterBlob(size, cb, frame_complete, frame_size, oop_maps, caller_must_gc_arguments); 296 } 297 // Track memory usage statistic after releasing CodeCache_lock 298 MemoryService::track_code_cache_memory_usage(); 299 300 return blob; 301 } 302 303 VtableBlob::VtableBlob(const char* name, int size) : 304 BufferBlob(name, size) { 305 } 306 307 VtableBlob* VtableBlob::create(const char* name, int buffer_size) { 308 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 309 310 VtableBlob* blob = NULL; 311 unsigned int size = sizeof(VtableBlob); 312 // align the size to CodeEntryAlignment 313 size = align_code_offset(size); 314 size += align_up(buffer_size, oopSize); 315 assert(name != NULL, "must provide a name"); 316 { 317 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 318 blob = new (size) VtableBlob(name, size); 319 } 320 // Track memory usage statistic after releasing CodeCache_lock 321 MemoryService::track_code_cache_memory_usage(); 322 323 return blob; 324 } 325 326 //---------------------------------------------------------------------------------------------------- 327 // Implementation of MethodHandlesAdapterBlob 328 329 MethodHandlesAdapterBlob* MethodHandlesAdapterBlob::create(int buffer_size) { 330 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 331 332 MethodHandlesAdapterBlob* blob = NULL; 333 unsigned int size = sizeof(MethodHandlesAdapterBlob); 334 // align the size to CodeEntryAlignment 335 size = CodeBlob::align_code_offset(size); 336 size += align_up(buffer_size, oopSize); 337 { 338 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 339 blob = new (size) MethodHandlesAdapterBlob(size); 340 if (blob == NULL) { 341 vm_exit_out_of_memory(size, OOM_MALLOC_ERROR, "CodeCache: no room for method handle adapter blob"); 342 } 343 } 344 // Track memory usage statistic after releasing CodeCache_lock 345 MemoryService::track_code_cache_memory_usage(); 346 347 return blob; 348 } 349 350 //---------------------------------------------------------------------------------------------------- 351 // Implementation of BufferedValueTypeBlob 352 BufferedValueTypeBlob::BufferedValueTypeBlob(int size, CodeBuffer* cb, int pack_fields_off, int unpack_fields_off) : 353 BufferBlob("buffered value type", size, cb), 354 _pack_fields_off(pack_fields_off), 355 _unpack_fields_off(unpack_fields_off) { 356 CodeCache::commit(this); 357 } 358 359 BufferedValueTypeBlob* BufferedValueTypeBlob::create(CodeBuffer* cb, int pack_fields_off, int unpack_fields_off) { 360 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 361 362 BufferedValueTypeBlob* blob = NULL; 363 unsigned int size = CodeBlob::allocation_size(cb, sizeof(BufferedValueTypeBlob)); 364 { 365 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 366 blob = new (size) BufferedValueTypeBlob(size, cb, pack_fields_off, unpack_fields_off); 367 } 368 // Track memory usage statistic after releasing CodeCache_lock 369 MemoryService::track_code_cache_memory_usage(); 370 371 return blob; 372 } 373 374 //---------------------------------------------------------------------------------------------------- 375 // Implementation of RuntimeStub 376 377 RuntimeStub::RuntimeStub( 378 const char* name, 379 CodeBuffer* cb, 380 int size, 381 int frame_complete, 382 int frame_size, 383 OopMapSet* oop_maps, 384 bool caller_must_gc_arguments 385 ) 386 : RuntimeBlob(name, cb, sizeof(RuntimeStub), size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments) 387 { 388 } 389 390 RuntimeStub* RuntimeStub::new_runtime_stub(const char* stub_name, 391 CodeBuffer* cb, 392 int frame_complete, 393 int frame_size, 394 OopMapSet* oop_maps, 395 bool caller_must_gc_arguments) 396 { 397 RuntimeStub* stub = NULL; 398 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 399 { 400 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 401 unsigned int size = CodeBlob::allocation_size(cb, sizeof(RuntimeStub)); 402 stub = new (size) RuntimeStub(stub_name, cb, size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments); 403 } 404 405 trace_new_stub(stub, "RuntimeStub - ", stub_name); 406 407 return stub; 408 } 409 410 411 void* RuntimeStub::operator new(size_t s, unsigned size) throw() { 412 void* p = CodeCache::allocate(size, CodeBlobType::NonNMethod); 413 if (!p) fatal("Initial size of CodeCache is too small"); 414 return p; 415 } 416 417 // operator new shared by all singletons: 418 void* SingletonBlob::operator new(size_t s, unsigned size) throw() { 419 void* p = CodeCache::allocate(size, CodeBlobType::NonNMethod); 420 if (!p) fatal("Initial size of CodeCache is too small"); 421 return p; 422 } 423 424 425 //---------------------------------------------------------------------------------------------------- 426 // Implementation of DeoptimizationBlob 427 428 DeoptimizationBlob::DeoptimizationBlob( 429 CodeBuffer* cb, 430 int size, 431 OopMapSet* oop_maps, 432 int unpack_offset, 433 int unpack_with_exception_offset, 434 int unpack_with_reexecution_offset, 435 int frame_size 436 ) 437 : SingletonBlob("DeoptimizationBlob", cb, sizeof(DeoptimizationBlob), size, frame_size, oop_maps) 438 { 439 _unpack_offset = unpack_offset; 440 _unpack_with_exception = unpack_with_exception_offset; 441 _unpack_with_reexecution = unpack_with_reexecution_offset; 442 #ifdef COMPILER1 443 _unpack_with_exception_in_tls = -1; 444 #endif 445 } 446 447 448 DeoptimizationBlob* DeoptimizationBlob::create( 449 CodeBuffer* cb, 450 OopMapSet* oop_maps, 451 int unpack_offset, 452 int unpack_with_exception_offset, 453 int unpack_with_reexecution_offset, 454 int frame_size) 455 { 456 DeoptimizationBlob* blob = NULL; 457 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 458 { 459 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 460 unsigned int size = CodeBlob::allocation_size(cb, sizeof(DeoptimizationBlob)); 461 blob = new (size) DeoptimizationBlob(cb, 462 size, 463 oop_maps, 464 unpack_offset, 465 unpack_with_exception_offset, 466 unpack_with_reexecution_offset, 467 frame_size); 468 } 469 470 trace_new_stub(blob, "DeoptimizationBlob"); 471 472 return blob; 473 } 474 475 476 //---------------------------------------------------------------------------------------------------- 477 // Implementation of UncommonTrapBlob 478 479 #ifdef COMPILER2 480 UncommonTrapBlob::UncommonTrapBlob( 481 CodeBuffer* cb, 482 int size, 483 OopMapSet* oop_maps, 484 int frame_size 485 ) 486 : SingletonBlob("UncommonTrapBlob", cb, sizeof(UncommonTrapBlob), size, frame_size, oop_maps) 487 {} 488 489 490 UncommonTrapBlob* UncommonTrapBlob::create( 491 CodeBuffer* cb, 492 OopMapSet* oop_maps, 493 int frame_size) 494 { 495 UncommonTrapBlob* blob = NULL; 496 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 497 { 498 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 499 unsigned int size = CodeBlob::allocation_size(cb, sizeof(UncommonTrapBlob)); 500 blob = new (size) UncommonTrapBlob(cb, size, oop_maps, frame_size); 501 } 502 503 trace_new_stub(blob, "UncommonTrapBlob"); 504 505 return blob; 506 } 507 508 509 #endif // COMPILER2 510 511 512 //---------------------------------------------------------------------------------------------------- 513 // Implementation of ExceptionBlob 514 515 #ifdef COMPILER2 516 ExceptionBlob::ExceptionBlob( 517 CodeBuffer* cb, 518 int size, 519 OopMapSet* oop_maps, 520 int frame_size 521 ) 522 : SingletonBlob("ExceptionBlob", cb, sizeof(ExceptionBlob), size, frame_size, oop_maps) 523 {} 524 525 526 ExceptionBlob* ExceptionBlob::create( 527 CodeBuffer* cb, 528 OopMapSet* oop_maps, 529 int frame_size) 530 { 531 ExceptionBlob* blob = NULL; 532 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 533 { 534 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 535 unsigned int size = CodeBlob::allocation_size(cb, sizeof(ExceptionBlob)); 536 blob = new (size) ExceptionBlob(cb, size, oop_maps, frame_size); 537 } 538 539 trace_new_stub(blob, "ExceptionBlob"); 540 541 return blob; 542 } 543 544 545 #endif // COMPILER2 546 547 548 //---------------------------------------------------------------------------------------------------- 549 // Implementation of SafepointBlob 550 551 SafepointBlob::SafepointBlob( 552 CodeBuffer* cb, 553 int size, 554 OopMapSet* oop_maps, 555 int frame_size 556 ) 557 : SingletonBlob("SafepointBlob", cb, sizeof(SafepointBlob), size, frame_size, oop_maps) 558 {} 559 560 561 SafepointBlob* SafepointBlob::create( 562 CodeBuffer* cb, 563 OopMapSet* oop_maps, 564 int frame_size) 565 { 566 SafepointBlob* blob = NULL; 567 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 568 { 569 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 570 unsigned int size = CodeBlob::allocation_size(cb, sizeof(SafepointBlob)); 571 blob = new (size) SafepointBlob(cb, size, oop_maps, frame_size); 572 } 573 574 trace_new_stub(blob, "SafepointBlob"); 575 576 return blob; 577 } 578 579 580 //---------------------------------------------------------------------------------------------------- 581 // Verification and printing 582 583 void CodeBlob::print_on(outputStream* st) const { 584 st->print_cr("[CodeBlob (" INTPTR_FORMAT ")]", p2i(this)); 585 st->print_cr("Framesize: %d", _frame_size); 586 } 587 588 void CodeBlob::print_value_on(outputStream* st) const { 589 st->print_cr("[CodeBlob]"); 590 } 591 592 void CodeBlob::dump_for_addr(address addr, outputStream* st, bool verbose) const { 593 if (is_buffer_blob()) { 594 // the interpreter is generated into a buffer blob 595 InterpreterCodelet* i = Interpreter::codelet_containing(addr); 596 if (i != NULL) { 597 st->print_cr(INTPTR_FORMAT " is at code_begin+%d in an Interpreter codelet", p2i(addr), (int)(addr - i->code_begin())); 598 i->print_on(st); 599 return; 600 } 601 if (Interpreter::contains(addr)) { 602 st->print_cr(INTPTR_FORMAT " is pointing into interpreter code" 603 " (not bytecode specific)", p2i(addr)); 604 return; 605 } 606 // 607 if (AdapterHandlerLibrary::contains(this)) { 608 st->print_cr(INTPTR_FORMAT " is at code_begin+%d in an AdapterHandler", p2i(addr), (int)(addr - code_begin())); 609 AdapterHandlerLibrary::print_handler_on(st, this); 610 } 611 // the stubroutines are generated into a buffer blob 612 StubCodeDesc* d = StubCodeDesc::desc_for(addr); 613 if (d != NULL) { 614 st->print_cr(INTPTR_FORMAT " is at begin+%d in a stub", p2i(addr), (int)(addr - d->begin())); 615 d->print_on(st); 616 st->cr(); 617 return; 618 } 619 if (StubRoutines::contains(addr)) { 620 st->print_cr(INTPTR_FORMAT " is pointing to an (unnamed) stub routine", p2i(addr)); 621 return; 622 } 623 // the InlineCacheBuffer is using stubs generated into a buffer blob 624 if (InlineCacheBuffer::contains(addr)) { 625 st->print_cr(INTPTR_FORMAT " is pointing into InlineCacheBuffer", p2i(addr)); 626 return; 627 } 628 VtableStub* v = VtableStubs::stub_containing(addr); 629 if (v != NULL) { 630 st->print_cr(INTPTR_FORMAT " is at entry_point+%d in a vtable stub", p2i(addr), (int)(addr - v->entry_point())); 631 v->print_on(st); 632 st->cr(); 633 return; 634 } 635 } 636 if (is_nmethod()) { 637 nmethod* nm = (nmethod*)this; 638 ResourceMark rm; 639 st->print(INTPTR_FORMAT " is at entry_point+%d in (nmethod*)" INTPTR_FORMAT, 640 p2i(addr), (int)(addr - nm->entry_point()), p2i(nm)); 641 if (verbose) { 642 st->print(" for "); 643 nm->method()->print_value_on(st); 644 } 645 st->cr(); 646 nm->print_nmethod(verbose); 647 return; 648 } 649 st->print_cr(INTPTR_FORMAT " is at code_begin+%d in ", p2i(addr), (int)(addr - code_begin())); 650 print_on(st); 651 } 652 653 void RuntimeBlob::verify() { 654 ShouldNotReachHere(); 655 } 656 657 void BufferBlob::verify() { 658 // unimplemented 659 } 660 661 void BufferBlob::print_on(outputStream* st) const { 662 RuntimeBlob::print_on(st); 663 print_value_on(st); 664 } 665 666 void BufferBlob::print_value_on(outputStream* st) const { 667 st->print_cr("BufferBlob (" INTPTR_FORMAT ") used for %s", p2i(this), name()); 668 } 669 670 void RuntimeStub::verify() { 671 // unimplemented 672 } 673 674 void RuntimeStub::print_on(outputStream* st) const { 675 ttyLocker ttyl; 676 RuntimeBlob::print_on(st); 677 st->print("Runtime Stub (" INTPTR_FORMAT "): ", p2i(this)); 678 st->print_cr("%s", name()); 679 Disassembler::decode((RuntimeBlob*)this, st); 680 } 681 682 void RuntimeStub::print_value_on(outputStream* st) const { 683 st->print("RuntimeStub (" INTPTR_FORMAT "): ", p2i(this)); st->print("%s", name()); 684 } 685 686 void SingletonBlob::verify() { 687 // unimplemented 688 } 689 690 void SingletonBlob::print_on(outputStream* st) const { 691 ttyLocker ttyl; 692 RuntimeBlob::print_on(st); 693 st->print_cr("%s", name()); 694 Disassembler::decode((RuntimeBlob*)this, st); 695 } 696 697 void SingletonBlob::print_value_on(outputStream* st) const { 698 st->print_cr("%s", name()); 699 } 700 701 void DeoptimizationBlob::print_value_on(outputStream* st) const { 702 st->print_cr("Deoptimization (frame not available)"); 703 }