1 /* 2 * Copyright (c) 1998, 2010, 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 "code/codeBlob.hpp" 27 #include "code/codeCache.hpp" 28 #include "code/relocInfo.hpp" 29 #include "compiler/disassembler.hpp" 30 #include "interpreter/bytecode.hpp" 31 #include "memory/allocation.inline.hpp" 32 #include "memory/heap.hpp" 33 #include "oops/oop.inline.hpp" 34 #include "prims/forte.hpp" 35 #include "runtime/handles.inline.hpp" 36 #include "runtime/interfaceSupport.hpp" 37 #include "runtime/mutexLocker.hpp" 38 #include "runtime/safepoint.hpp" 39 #include "runtime/sharedRuntime.hpp" 40 #include "runtime/vframe.hpp" 41 #include "services/memoryService.hpp" 42 #ifdef TARGET_ARCH_x86 43 # include "nativeInst_x86.hpp" 44 #endif 45 #ifdef TARGET_ARCH_sparc 46 # include "nativeInst_sparc.hpp" 47 #endif 48 #ifdef TARGET_ARCH_zero 49 # include "nativeInst_zero.hpp" 50 #endif 51 #ifdef COMPILER1 52 #include "c1/c1_Runtime1.hpp" 53 #endif 54 55 unsigned int 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 += round_to(cb->total_relocation_size(), oopSize); 67 // align the size to CodeEntryAlignment 68 size = align_code_offset(size); 69 size += round_to(cb->total_content_size(), oopSize); 70 size += round_to(cb->total_oop_size(), oopSize); 71 return size; 72 } 73 74 75 // Creates a simple CodeBlob. Sets up the size of the different regions. 76 CodeBlob::CodeBlob(const char* name, int header_size, int size, int frame_complete, int locs_size) { 77 assert(size == round_to(size, oopSize), "unaligned size"); 78 assert(locs_size == round_to(locs_size, oopSize), "unaligned size"); 79 assert(header_size == round_to(header_size, oopSize), "unaligned size"); 80 assert(!UseRelocIndex, "no space allocated for reloc index yet"); 81 82 // Note: If UseRelocIndex is enabled, there needs to be (at least) one 83 // extra word for the relocation information, containing the reloc 84 // index table length. Unfortunately, the reloc index table imple- 85 // mentation is not easily understandable and thus it is not clear 86 // what exactly the format is supposed to be. For now, we just turn 87 // off the use of this table (gri 7/6/2000). 88 89 _name = name; 90 _size = size; 91 _frame_complete_offset = frame_complete; 92 _header_size = header_size; 93 _relocation_size = locs_size; 94 _content_offset = align_code_offset(header_size + _relocation_size); 95 _code_offset = _content_offset; 96 _data_offset = size; 97 _frame_size = 0; 98 set_oop_maps(NULL); 99 } 100 101 102 // Creates a CodeBlob from a CodeBuffer. Sets up the size of the different regions, 103 // and copy code and relocation info. 104 CodeBlob::CodeBlob( 105 const char* name, 106 CodeBuffer* cb, 107 int header_size, 108 int size, 109 int frame_complete, 110 int frame_size, 111 OopMapSet* oop_maps 112 ) { 113 assert(size == round_to(size, oopSize), "unaligned size"); 114 assert(header_size == round_to(header_size, oopSize), "unaligned size"); 115 116 _name = name; 117 _size = size; 118 _frame_complete_offset = frame_complete; 119 _header_size = header_size; 120 _relocation_size = round_to(cb->total_relocation_size(), oopSize); 121 _content_offset = align_code_offset(header_size + _relocation_size); 122 _code_offset = _content_offset + cb->total_offset_of(cb->insts()); 123 _data_offset = _content_offset + round_to(cb->total_content_size(), oopSize); 124 assert(_data_offset <= size, "codeBlob is too small"); 125 126 cb->copy_code_and_locs_to(this); 127 set_oop_maps(oop_maps); 128 _frame_size = frame_size; 129 #ifdef COMPILER1 130 // probably wrong for tiered 131 assert(_frame_size >= -1, "must use frame size or -1 for runtime stubs"); 132 #endif // COMPILER1 133 } 134 135 136 void CodeBlob::set_oop_maps(OopMapSet* p) { 137 // Danger Will Robinson! This method allocates a big 138 // chunk of memory, its your job to free it. 139 if (p != NULL) { 140 // We need to allocate a chunk big enough to hold the OopMapSet and all of its OopMaps 141 _oop_maps = (OopMapSet* )NEW_C_HEAP_ARRAY(unsigned char, p->heap_size()); 142 p->copy_to((address)_oop_maps); 143 } else { 144 _oop_maps = NULL; 145 } 146 } 147 148 149 void CodeBlob::flush() { 150 if (_oop_maps) { 151 FREE_C_HEAP_ARRAY(unsigned char, _oop_maps); 152 _oop_maps = NULL; 153 } 154 _comments.free(); 155 } 156 157 158 OopMap* CodeBlob::oop_map_for_return_address(address return_address) { 159 assert(oop_maps() != NULL, "nope"); 160 return oop_maps()->find_map_at_offset((intptr_t) return_address - (intptr_t) code_begin()); 161 } 162 163 164 //---------------------------------------------------------------------------------------------------- 165 // Implementation of BufferBlob 166 167 168 BufferBlob::BufferBlob(const char* name, int size) 169 : CodeBlob(name, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, /*locs_size:*/ 0) 170 {} 171 172 BufferBlob* BufferBlob::create(const char* name, int buffer_size) { 173 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 174 175 BufferBlob* blob = NULL; 176 unsigned int size = sizeof(BufferBlob); 177 // align the size to CodeEntryAlignment 178 size = align_code_offset(size); 179 size += round_to(buffer_size, oopSize); 180 assert(name != NULL, "must provide a name"); 181 { 182 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 183 blob = new (size) BufferBlob(name, size); 184 } 185 // Track memory usage statistic after releasing CodeCache_lock 186 MemoryService::track_code_cache_memory_usage(); 187 188 return blob; 189 } 190 191 192 BufferBlob::BufferBlob(const char* name, int size, CodeBuffer* cb) 193 : CodeBlob(name, cb, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, 0, NULL) 194 {} 195 196 BufferBlob* BufferBlob::create(const char* name, CodeBuffer* cb) { 197 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 198 199 BufferBlob* blob = NULL; 200 unsigned int size = allocation_size(cb, sizeof(BufferBlob)); 201 assert(name != NULL, "must provide a name"); 202 { 203 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 204 blob = new (size) BufferBlob(name, size, cb); 205 } 206 // Track memory usage statistic after releasing CodeCache_lock 207 MemoryService::track_code_cache_memory_usage(); 208 209 return blob; 210 } 211 212 213 void* BufferBlob::operator new(size_t s, unsigned size) { 214 void* p = CodeCache::allocate(size); 215 return p; 216 } 217 218 219 void BufferBlob::free( BufferBlob *blob ) { 220 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 221 { 222 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 223 CodeCache::free((CodeBlob*)blob); 224 } 225 // Track memory usage statistic after releasing CodeCache_lock 226 MemoryService::track_code_cache_memory_usage(); 227 } 228 229 230 //---------------------------------------------------------------------------------------------------- 231 // Implementation of AdapterBlob 232 233 AdapterBlob::AdapterBlob(int size, CodeBuffer* cb) : 234 BufferBlob("I2C/C2I adapters", size, cb) { 235 CodeCache::commit(this); 236 } 237 238 AdapterBlob* AdapterBlob::create(CodeBuffer* cb) { 239 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 240 241 AdapterBlob* blob = NULL; 242 unsigned int size = allocation_size(cb, sizeof(AdapterBlob)); 243 { 244 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 245 blob = new (size) AdapterBlob(size, cb); 246 } 247 // Track memory usage statistic after releasing CodeCache_lock 248 MemoryService::track_code_cache_memory_usage(); 249 250 return blob; 251 } 252 253 254 //---------------------------------------------------------------------------------------------------- 255 // Implementation of MethodHandlesAdapterBlob 256 257 MethodHandlesAdapterBlob* MethodHandlesAdapterBlob::create(int buffer_size) { 258 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 259 260 MethodHandlesAdapterBlob* blob = NULL; 261 unsigned int size = sizeof(MethodHandlesAdapterBlob); 262 // align the size to CodeEntryAlignment 263 size = align_code_offset(size); 264 size += round_to(buffer_size, oopSize); 265 { 266 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 267 blob = new (size) MethodHandlesAdapterBlob(size); 268 } 269 // Track memory usage statistic after releasing CodeCache_lock 270 MemoryService::track_code_cache_memory_usage(); 271 272 return blob; 273 } 274 275 276 //---------------------------------------------------------------------------------------------------- 277 // Implementation of RuntimeStub 278 279 RuntimeStub::RuntimeStub( 280 const char* name, 281 CodeBuffer* cb, 282 int size, 283 int frame_complete, 284 int frame_size, 285 OopMapSet* oop_maps, 286 bool caller_must_gc_arguments 287 ) 288 : CodeBlob(name, cb, sizeof(RuntimeStub), size, frame_complete, frame_size, oop_maps) 289 { 290 _caller_must_gc_arguments = caller_must_gc_arguments; 291 } 292 293 294 RuntimeStub* RuntimeStub::new_runtime_stub(const char* stub_name, 295 CodeBuffer* cb, 296 int frame_complete, 297 int frame_size, 298 OopMapSet* oop_maps, 299 bool caller_must_gc_arguments) 300 { 301 RuntimeStub* stub = NULL; 302 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 303 { 304 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 305 unsigned int size = allocation_size(cb, sizeof(RuntimeStub)); 306 stub = new (size) RuntimeStub(stub_name, cb, size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments); 307 } 308 309 // Do not hold the CodeCache lock during name formatting. 310 if (stub != NULL) { 311 char stub_id[256]; 312 jio_snprintf(stub_id, sizeof(stub_id), "RuntimeStub - %s", stub_name); 313 if (PrintStubCode) { 314 tty->print_cr("Decoding %s " INTPTR_FORMAT, stub_id, stub); 315 Disassembler::decode(stub->code_begin(), stub->code_end()); 316 } 317 Forte::register_stub(stub_id, stub->code_begin(), stub->code_end()); 318 319 if (JvmtiExport::should_post_dynamic_code_generated()) { 320 JvmtiExport::post_dynamic_code_generated(stub_name, stub->code_begin(), stub->code_end()); 321 } 322 } 323 324 // Track memory usage statistic after releasing CodeCache_lock 325 MemoryService::track_code_cache_memory_usage(); 326 327 return stub; 328 } 329 330 331 void* RuntimeStub::operator new(size_t s, unsigned size) { 332 void* p = CodeCache::allocate(size); 333 if (!p) fatal("Initial size of CodeCache is too small"); 334 return p; 335 } 336 337 338 //---------------------------------------------------------------------------------------------------- 339 // Implementation of DeoptimizationBlob 340 341 DeoptimizationBlob::DeoptimizationBlob( 342 CodeBuffer* cb, 343 int size, 344 OopMapSet* oop_maps, 345 int unpack_offset, 346 int unpack_with_exception_offset, 347 int unpack_with_reexecution_offset, 348 int frame_size 349 ) 350 : SingletonBlob("DeoptimizationBlob", cb, sizeof(DeoptimizationBlob), size, frame_size, oop_maps) 351 { 352 _unpack_offset = unpack_offset; 353 _unpack_with_exception = unpack_with_exception_offset; 354 _unpack_with_reexecution = unpack_with_reexecution_offset; 355 #ifdef COMPILER1 356 _unpack_with_exception_in_tls = -1; 357 #endif 358 } 359 360 361 DeoptimizationBlob* DeoptimizationBlob::create( 362 CodeBuffer* cb, 363 OopMapSet* oop_maps, 364 int unpack_offset, 365 int unpack_with_exception_offset, 366 int unpack_with_reexecution_offset, 367 int frame_size) 368 { 369 DeoptimizationBlob* blob = NULL; 370 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 371 { 372 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 373 unsigned int size = allocation_size(cb, sizeof(DeoptimizationBlob)); 374 blob = new (size) DeoptimizationBlob(cb, 375 size, 376 oop_maps, 377 unpack_offset, 378 unpack_with_exception_offset, 379 unpack_with_reexecution_offset, 380 frame_size); 381 } 382 383 // Do not hold the CodeCache lock during name formatting. 384 if (blob != NULL) { 385 char blob_id[256]; 386 jio_snprintf(blob_id, sizeof(blob_id), "DeoptimizationBlob@" PTR_FORMAT, blob->code_begin()); 387 if (PrintStubCode) { 388 tty->print_cr("Decoding %s " INTPTR_FORMAT, blob_id, blob); 389 Disassembler::decode(blob->code_begin(), blob->code_end()); 390 } 391 Forte::register_stub(blob_id, blob->code_begin(), blob->code_end()); 392 393 if (JvmtiExport::should_post_dynamic_code_generated()) { 394 JvmtiExport::post_dynamic_code_generated("DeoptimizationBlob", blob->code_begin(), blob->code_end()); 395 } 396 } 397 398 // Track memory usage statistic after releasing CodeCache_lock 399 MemoryService::track_code_cache_memory_usage(); 400 401 return blob; 402 } 403 404 405 void* DeoptimizationBlob::operator new(size_t s, unsigned size) { 406 void* p = CodeCache::allocate(size); 407 if (!p) fatal("Initial size of CodeCache is too small"); 408 return p; 409 } 410 411 //---------------------------------------------------------------------------------------------------- 412 // Implementation of UncommonTrapBlob 413 414 #ifdef COMPILER2 415 UncommonTrapBlob::UncommonTrapBlob( 416 CodeBuffer* cb, 417 int size, 418 OopMapSet* oop_maps, 419 int frame_size 420 ) 421 : SingletonBlob("UncommonTrapBlob", cb, sizeof(UncommonTrapBlob), size, frame_size, oop_maps) 422 {} 423 424 425 UncommonTrapBlob* UncommonTrapBlob::create( 426 CodeBuffer* cb, 427 OopMapSet* oop_maps, 428 int frame_size) 429 { 430 UncommonTrapBlob* blob = NULL; 431 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 432 { 433 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 434 unsigned int size = allocation_size(cb, sizeof(UncommonTrapBlob)); 435 blob = new (size) UncommonTrapBlob(cb, size, oop_maps, frame_size); 436 } 437 438 // Do not hold the CodeCache lock during name formatting. 439 if (blob != NULL) { 440 char blob_id[256]; 441 jio_snprintf(blob_id, sizeof(blob_id), "UncommonTrapBlob@" PTR_FORMAT, blob->code_begin()); 442 if (PrintStubCode) { 443 tty->print_cr("Decoding %s " INTPTR_FORMAT, blob_id, blob); 444 Disassembler::decode(blob->code_begin(), blob->code_end()); 445 } 446 Forte::register_stub(blob_id, blob->code_begin(), blob->code_end()); 447 448 if (JvmtiExport::should_post_dynamic_code_generated()) { 449 JvmtiExport::post_dynamic_code_generated("UncommonTrapBlob", blob->code_begin(), blob->code_end()); 450 } 451 } 452 453 // Track memory usage statistic after releasing CodeCache_lock 454 MemoryService::track_code_cache_memory_usage(); 455 456 return blob; 457 } 458 459 460 void* UncommonTrapBlob::operator new(size_t s, unsigned size) { 461 void* p = CodeCache::allocate(size); 462 if (!p) fatal("Initial size of CodeCache is too small"); 463 return p; 464 } 465 #endif // COMPILER2 466 467 468 //---------------------------------------------------------------------------------------------------- 469 // Implementation of ExceptionBlob 470 471 #ifdef COMPILER2 472 ExceptionBlob::ExceptionBlob( 473 CodeBuffer* cb, 474 int size, 475 OopMapSet* oop_maps, 476 int frame_size 477 ) 478 : SingletonBlob("ExceptionBlob", cb, sizeof(ExceptionBlob), size, frame_size, oop_maps) 479 {} 480 481 482 ExceptionBlob* ExceptionBlob::create( 483 CodeBuffer* cb, 484 OopMapSet* oop_maps, 485 int frame_size) 486 { 487 ExceptionBlob* blob = NULL; 488 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 489 { 490 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 491 unsigned int size = allocation_size(cb, sizeof(ExceptionBlob)); 492 blob = new (size) ExceptionBlob(cb, size, oop_maps, frame_size); 493 } 494 495 // We do not need to hold the CodeCache lock during name formatting 496 if (blob != NULL) { 497 char blob_id[256]; 498 jio_snprintf(blob_id, sizeof(blob_id), "ExceptionBlob@" PTR_FORMAT, blob->code_begin()); 499 if (PrintStubCode) { 500 tty->print_cr("Decoding %s " INTPTR_FORMAT, blob_id, blob); 501 Disassembler::decode(blob->code_begin(), blob->code_end()); 502 } 503 Forte::register_stub(blob_id, blob->code_begin(), blob->code_end()); 504 505 if (JvmtiExport::should_post_dynamic_code_generated()) { 506 JvmtiExport::post_dynamic_code_generated("ExceptionBlob", blob->code_begin(), blob->code_end()); 507 } 508 } 509 510 // Track memory usage statistic after releasing CodeCache_lock 511 MemoryService::track_code_cache_memory_usage(); 512 513 return blob; 514 } 515 516 517 void* ExceptionBlob::operator new(size_t s, unsigned size) { 518 void* p = CodeCache::allocate(size); 519 if (!p) fatal("Initial size of CodeCache is too small"); 520 return p; 521 } 522 #endif // COMPILER2 523 524 525 //---------------------------------------------------------------------------------------------------- 526 // Implementation of SafepointBlob 527 528 SafepointBlob::SafepointBlob( 529 CodeBuffer* cb, 530 int size, 531 OopMapSet* oop_maps, 532 int frame_size 533 ) 534 : SingletonBlob("SafepointBlob", cb, sizeof(SafepointBlob), size, frame_size, oop_maps) 535 {} 536 537 538 SafepointBlob* SafepointBlob::create( 539 CodeBuffer* cb, 540 OopMapSet* oop_maps, 541 int frame_size) 542 { 543 SafepointBlob* blob = NULL; 544 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock 545 { 546 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); 547 unsigned int size = allocation_size(cb, sizeof(SafepointBlob)); 548 blob = new (size) SafepointBlob(cb, size, oop_maps, frame_size); 549 } 550 551 // We do not need to hold the CodeCache lock during name formatting. 552 if (blob != NULL) { 553 char blob_id[256]; 554 jio_snprintf(blob_id, sizeof(blob_id), "SafepointBlob@" PTR_FORMAT, blob->code_begin()); 555 if (PrintStubCode) { 556 tty->print_cr("Decoding %s " INTPTR_FORMAT, blob_id, blob); 557 Disassembler::decode(blob->code_begin(), blob->code_end()); 558 } 559 Forte::register_stub(blob_id, blob->code_begin(), blob->code_end()); 560 561 if (JvmtiExport::should_post_dynamic_code_generated()) { 562 JvmtiExport::post_dynamic_code_generated("SafepointBlob", blob->code_begin(), blob->code_end()); 563 } 564 } 565 566 // Track memory usage statistic after releasing CodeCache_lock 567 MemoryService::track_code_cache_memory_usage(); 568 569 return blob; 570 } 571 572 573 void* SafepointBlob::operator new(size_t s, unsigned size) { 574 void* p = CodeCache::allocate(size); 575 if (!p) fatal("Initial size of CodeCache is too small"); 576 return p; 577 } 578 579 580 //---------------------------------------------------------------------------------------------------- 581 // Verification and printing 582 583 void CodeBlob::verify() { 584 ShouldNotReachHere(); 585 } 586 587 void CodeBlob::print_on(outputStream* st) const { 588 st->print_cr("[CodeBlob (" INTPTR_FORMAT ")]", this); 589 st->print_cr("Framesize: %d", _frame_size); 590 } 591 592 void CodeBlob::print_value_on(outputStream* st) const { 593 st->print_cr("[CodeBlob]"); 594 } 595 596 void BufferBlob::verify() { 597 // unimplemented 598 } 599 600 void BufferBlob::print_on(outputStream* st) const { 601 CodeBlob::print_on(st); 602 print_value_on(st); 603 } 604 605 void BufferBlob::print_value_on(outputStream* st) const { 606 st->print_cr("BufferBlob (" INTPTR_FORMAT ") used for %s", this, name()); 607 } 608 609 void RuntimeStub::verify() { 610 // unimplemented 611 } 612 613 void RuntimeStub::print_on(outputStream* st) const { 614 CodeBlob::print_on(st); 615 st->print("Runtime Stub (" INTPTR_FORMAT "): ", this); 616 st->print_cr(name()); 617 Disassembler::decode((CodeBlob*)this, st); 618 } 619 620 void RuntimeStub::print_value_on(outputStream* st) const { 621 st->print("RuntimeStub (" INTPTR_FORMAT "): ", this); st->print(name()); 622 } 623 624 void SingletonBlob::verify() { 625 // unimplemented 626 } 627 628 void SingletonBlob::print_on(outputStream* st) const { 629 CodeBlob::print_on(st); 630 st->print_cr(name()); 631 Disassembler::decode((CodeBlob*)this, st); 632 } 633 634 void SingletonBlob::print_value_on(outputStream* st) const { 635 st->print_cr(name()); 636 } 637 638 void DeoptimizationBlob::print_value_on(outputStream* st) const { 639 st->print_cr("Deoptimization (frame not available)"); 640 }