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