Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/code/codeBlob.cpp@24128c2ffa87 (annotated)

src/share/vm/code/codeBlob.cpp

Fri, 29 Jan 2010 08:33:24 -0800

author
twisti
date
Fri, 29 Jan 2010 08:33:24 -0800
changeset 1636
24128c2ffa87
parent 435
a61af66fc99e
child 1734
9eba43136cb5
permissions
-rw-r--r--

6921339: backout 6917766
Reviewed-by: mr

duke@435 1 /*
duke@435 2 * Copyright 1998-2007 Sun Microsystems, Inc. All Rights Reserved.
duke@435 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435 4 *
duke@435 5 * This code is free software; you can redistribute it and/or modify it
duke@435 6 * under the terms of the GNU General Public License version 2 only, as
duke@435 7 * published by the Free Software Foundation.
duke@435 8 *
duke@435 9 * This code is distributed in the hope that it will be useful, but WITHOUT
duke@435 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435 12 * version 2 for more details (a copy is included in the LICENSE file that
duke@435 13 * accompanied this code).
duke@435 14 *
duke@435 15 * You should have received a copy of the GNU General Public License version
duke@435 16 * 2 along with this work; if not, write to the Free Software Foundation,
duke@435 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435 18 *
duke@435 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@435 20 * CA 95054 USA or visit www.sun.com if you need additional information or
duke@435 21 * have any questions.
duke@435 22 *
duke@435 23 */
duke@435 24
duke@435 25 # include "incls/_precompiled.incl"
duke@435 26 # include "incls/_codeBlob.cpp.incl"
duke@435 27
duke@435 28 unsigned int align_code_offset(int offset) {
duke@435 29 // align the size to CodeEntryAlignment
duke@435 30 return
duke@435 31 ((offset + (int)CodeHeap::header_size() + (CodeEntryAlignment-1)) & ~(CodeEntryAlignment-1))
duke@435 32 - (int)CodeHeap::header_size();
duke@435 33 }
duke@435 34
duke@435 35
duke@435 36 // This must be consistent with the CodeBlob constructor's layout actions.
duke@435 37 unsigned int CodeBlob::allocation_size(CodeBuffer* cb, int header_size) {
duke@435 38 unsigned int size = header_size;
duke@435 39 size += round_to(cb->total_relocation_size(), oopSize);
duke@435 40 // align the size to CodeEntryAlignment
duke@435 41 size = align_code_offset(size);
duke@435 42 size += round_to(cb->total_code_size(), oopSize);
duke@435 43 size += round_to(cb->total_oop_size(), oopSize);
duke@435 44 return size;
duke@435 45 }
duke@435 46
duke@435 47
duke@435 48 // Creates a simple CodeBlob. Sets up the size of the different regions.
duke@435 49 CodeBlob::CodeBlob(const char* name, int header_size, int size, int frame_complete, int locs_size) {
duke@435 50 assert(size == round_to(size, oopSize), "unaligned size");
duke@435 51 assert(locs_size == round_to(locs_size, oopSize), "unaligned size");
duke@435 52 assert(header_size == round_to(header_size, oopSize), "unaligned size");
duke@435 53 assert(!UseRelocIndex, "no space allocated for reloc index yet");
duke@435 54
duke@435 55 // Note: If UseRelocIndex is enabled, there needs to be (at least) one
duke@435 56 // extra word for the relocation information, containing the reloc
duke@435 57 // index table length. Unfortunately, the reloc index table imple-
duke@435 58 // mentation is not easily understandable and thus it is not clear
duke@435 59 // what exactly the format is supposed to be. For now, we just turn
duke@435 60 // off the use of this table (gri 7/6/2000).
duke@435 61
duke@435 62 _name = name;
duke@435 63 _size = size;
duke@435 64 _frame_complete_offset = frame_complete;
duke@435 65 _header_size = header_size;
duke@435 66 _relocation_size = locs_size;
duke@435 67 _instructions_offset = align_code_offset(header_size + locs_size);
duke@435 68 _data_offset = size;
duke@435 69 _oops_offset = size;
duke@435 70 _oops_length = 0;
duke@435 71 _frame_size = 0;
duke@435 72 set_oop_maps(NULL);
duke@435 73 }
duke@435 74
duke@435 75
duke@435 76 // Creates a CodeBlob from a CodeBuffer. Sets up the size of the different regions,
duke@435 77 // and copy code and relocation info.
duke@435 78 CodeBlob::CodeBlob(
duke@435 79 const char* name,
duke@435 80 CodeBuffer* cb,
duke@435 81 int header_size,
duke@435 82 int size,
duke@435 83 int frame_complete,
duke@435 84 int frame_size,
duke@435 85 OopMapSet* oop_maps
duke@435 86 ) {
duke@435 87 assert(size == round_to(size, oopSize), "unaligned size");
duke@435 88 assert(header_size == round_to(header_size, oopSize), "unaligned size");
duke@435 89
duke@435 90 _name = name;
duke@435 91 _size = size;
duke@435 92 _frame_complete_offset = frame_complete;
duke@435 93 _header_size = header_size;
duke@435 94 _relocation_size = round_to(cb->total_relocation_size(), oopSize);
duke@435 95 _instructions_offset = align_code_offset(header_size + _relocation_size);
duke@435 96 _data_offset = _instructions_offset + round_to(cb->total_code_size(), oopSize);
duke@435 97 _oops_offset = _size - round_to(cb->total_oop_size(), oopSize);
duke@435 98 _oops_length = 0; // temporary, until the copy_oops handshake
duke@435 99 assert(_oops_offset >= _data_offset, "codeBlob is too small");
duke@435 100 assert(_data_offset <= size, "codeBlob is too small");
duke@435 101
duke@435 102 cb->copy_code_and_locs_to(this);
duke@435 103 set_oop_maps(oop_maps);
duke@435 104 _frame_size = frame_size;
duke@435 105 #ifdef COMPILER1
duke@435 106 // probably wrong for tiered
duke@435 107 assert(_frame_size >= -1, "must use frame size or -1 for runtime stubs");
duke@435 108 #endif // COMPILER1
duke@435 109 }
duke@435 110
duke@435 111
duke@435 112 void CodeBlob::set_oop_maps(OopMapSet* p) {
duke@435 113 // Danger Will Robinson! This method allocates a big
duke@435 114 // chunk of memory, its your job to free it.
duke@435 115 if (p != NULL) {
duke@435 116 // We need to allocate a chunk big enough to hold the OopMapSet and all of its OopMaps
duke@435 117 _oop_maps = (OopMapSet* )NEW_C_HEAP_ARRAY(unsigned char, p->heap_size());
duke@435 118 p->copy_to((address)_oop_maps);
duke@435 119 } else {
duke@435 120 _oop_maps = NULL;
duke@435 121 }
duke@435 122 }
duke@435 123
duke@435 124
duke@435 125 void CodeBlob::flush() {
duke@435 126 if (_oop_maps) {
duke@435 127 FREE_C_HEAP_ARRAY(unsigned char, _oop_maps);
duke@435 128 _oop_maps = NULL;
duke@435 129 }
duke@435 130 _comments.free();
duke@435 131 }
duke@435 132
duke@435 133
duke@435 134 // Promote one word from an assembly-time handle to a live embedded oop.
duke@435 135 inline void CodeBlob::initialize_immediate_oop(oop* dest, jobject handle) {
duke@435 136 if (handle == NULL ||
duke@435 137 // As a special case, IC oops are initialized to 1 or -1.
duke@435 138 handle == (jobject) Universe::non_oop_word()) {
duke@435 139 (*dest) = (oop)handle;
duke@435 140 } else {
duke@435 141 (*dest) = JNIHandles::resolve_non_null(handle);
duke@435 142 }
duke@435 143 }
duke@435 144
duke@435 145
duke@435 146 void CodeBlob::copy_oops(GrowableArray<jobject>* array) {
duke@435 147 assert(_oops_length == 0, "do this handshake just once, please");
duke@435 148 int length = array->length();
duke@435 149 assert((address)(oops_begin() + length) <= data_end(), "oops big enough");
duke@435 150 oop* dest = oops_begin();
duke@435 151 for (int index = 0 ; index < length; index++) {
duke@435 152 initialize_immediate_oop(&dest[index], array->at(index));
duke@435 153 }
duke@435 154 _oops_length = length;
duke@435 155
duke@435 156 // Now we can fix up all the oops in the code.
duke@435 157 // We need to do this in the code because
duke@435 158 // the assembler uses jobjects as placeholders.
duke@435 159 // The code and relocations have already been
duke@435 160 // initialized by the CodeBlob constructor,
duke@435 161 // so it is valid even at this early point to
duke@435 162 // iterate over relocations and patch the code.
duke@435 163 fix_oop_relocations(NULL, NULL, /*initialize_immediates=*/ true);
duke@435 164 }
duke@435 165
duke@435 166
duke@435 167 relocInfo::relocType CodeBlob::reloc_type_for_address(address pc) {
duke@435 168 RelocIterator iter(this, pc, pc+1);
duke@435 169 while (iter.next()) {
duke@435 170 return (relocInfo::relocType) iter.type();
duke@435 171 }
duke@435 172 // No relocation info found for pc
duke@435 173 ShouldNotReachHere();
duke@435 174 return relocInfo::none; // dummy return value
duke@435 175 }
duke@435 176
duke@435 177
duke@435 178 bool CodeBlob::is_at_poll_return(address pc) {
duke@435 179 RelocIterator iter(this, pc, pc+1);
duke@435 180 while (iter.next()) {
duke@435 181 if (iter.type() == relocInfo::poll_return_type)
duke@435 182 return true;
duke@435 183 }
duke@435 184 return false;
duke@435 185 }
duke@435 186
duke@435 187
duke@435 188 bool CodeBlob::is_at_poll_or_poll_return(address pc) {
duke@435 189 RelocIterator iter(this, pc, pc+1);
duke@435 190 while (iter.next()) {
duke@435 191 relocInfo::relocType t = iter.type();
duke@435 192 if (t == relocInfo::poll_return_type || t == relocInfo::poll_type)
duke@435 193 return true;
duke@435 194 }
duke@435 195 return false;
duke@435 196 }
duke@435 197
duke@435 198
duke@435 199 void CodeBlob::fix_oop_relocations(address begin, address end,
duke@435 200 bool initialize_immediates) {
duke@435 201 // re-patch all oop-bearing instructions, just in case some oops moved
duke@435 202 RelocIterator iter(this, begin, end);
duke@435 203 while (iter.next()) {
duke@435 204 if (iter.type() == relocInfo::oop_type) {
duke@435 205 oop_Relocation* reloc = iter.oop_reloc();
duke@435 206 if (initialize_immediates && reloc->oop_is_immediate()) {
duke@435 207 oop* dest = reloc->oop_addr();
duke@435 208 initialize_immediate_oop(dest, (jobject) *dest);
duke@435 209 }
duke@435 210 // Refresh the oop-related bits of this instruction.
duke@435 211 reloc->fix_oop_relocation();
duke@435 212 }
duke@435 213
duke@435 214 // There must not be any interfering patches or breakpoints.
duke@435 215 assert(!(iter.type() == relocInfo::breakpoint_type
duke@435 216 && iter.breakpoint_reloc()->active()),
duke@435 217 "no active breakpoint");
duke@435 218 }
duke@435 219 }
duke@435 220
duke@435 221 void CodeBlob::do_unloading(BoolObjectClosure* is_alive,
duke@435 222 OopClosure* keep_alive,
duke@435 223 bool unloading_occurred) {
duke@435 224 ShouldNotReachHere();
duke@435 225 }
duke@435 226
duke@435 227 OopMap* CodeBlob::oop_map_for_return_address(address return_address) {
duke@435 228 address pc = return_address ;
duke@435 229 assert (oop_maps() != NULL, "nope");
duke@435 230 return oop_maps()->find_map_at_offset ((intptr_t) pc - (intptr_t) instructions_begin());
duke@435 231 }
duke@435 232
duke@435 233
duke@435 234 //----------------------------------------------------------------------------------------------------
duke@435 235 // Implementation of BufferBlob
duke@435 236
duke@435 237
duke@435 238 BufferBlob::BufferBlob(const char* name, int size)
duke@435 239 : CodeBlob(name, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, /*locs_size:*/ 0)
duke@435 240 {}
duke@435 241
duke@435 242 BufferBlob* BufferBlob::create(const char* name, int buffer_size) {
duke@435 243 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
duke@435 244
duke@435 245 BufferBlob* blob = NULL;
duke@435 246 unsigned int size = sizeof(BufferBlob);
duke@435 247 // align the size to CodeEntryAlignment
duke@435 248 size = align_code_offset(size);
duke@435 249 size += round_to(buffer_size, oopSize);
duke@435 250 assert(name != NULL, "must provide a name");
duke@435 251 {
duke@435 252
duke@435 253 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
duke@435 254 blob = new (size) BufferBlob(name, size);
duke@435 255 }
duke@435 256 // Track memory usage statistic after releasing CodeCache_lock
duke@435 257 MemoryService::track_code_cache_memory_usage();
duke@435 258
duke@435 259 return blob;
duke@435 260 }
duke@435 261
duke@435 262
duke@435 263 BufferBlob::BufferBlob(const char* name, int size, CodeBuffer* cb)
duke@435 264 : CodeBlob(name, cb, sizeof(BufferBlob), size, CodeOffsets::frame_never_safe, 0, NULL)
duke@435 265 {}
duke@435 266
duke@435 267 BufferBlob* BufferBlob::create(const char* name, CodeBuffer* cb) {
duke@435 268 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
duke@435 269
duke@435 270 BufferBlob* blob = NULL;
duke@435 271 unsigned int size = allocation_size(cb, sizeof(BufferBlob));
duke@435 272 assert(name != NULL, "must provide a name");
duke@435 273 {
duke@435 274
duke@435 275 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
duke@435 276 blob = new (size) BufferBlob(name, size, cb);
duke@435 277 }
duke@435 278 // Track memory usage statistic after releasing CodeCache_lock
duke@435 279 MemoryService::track_code_cache_memory_usage();
duke@435 280
duke@435 281 return blob;
duke@435 282 }
duke@435 283
duke@435 284
duke@435 285 void* BufferBlob::operator new(size_t s, unsigned size) {
duke@435 286 void* p = CodeCache::allocate(size);
duke@435 287 return p;
duke@435 288 }
duke@435 289
duke@435 290
duke@435 291 void BufferBlob::free( BufferBlob *blob ) {
duke@435 292 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
duke@435 293 {
duke@435 294 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
duke@435 295 CodeCache::free((CodeBlob*)blob);
duke@435 296 }
duke@435 297 // Track memory usage statistic after releasing CodeCache_lock
duke@435 298 MemoryService::track_code_cache_memory_usage();
duke@435 299 }
duke@435 300
duke@435 301 bool BufferBlob::is_adapter_blob() const {
duke@435 302 return (strcmp(AdapterHandlerEntry::name, name()) == 0);
duke@435 303 }
duke@435 304
duke@435 305 //----------------------------------------------------------------------------------------------------
duke@435 306 // Implementation of RuntimeStub
duke@435 307
duke@435 308 RuntimeStub::RuntimeStub(
duke@435 309 const char* name,
duke@435 310 CodeBuffer* cb,
duke@435 311 int size,
duke@435 312 int frame_complete,
duke@435 313 int frame_size,
duke@435 314 OopMapSet* oop_maps,
duke@435 315 bool caller_must_gc_arguments
duke@435 316 )
duke@435 317 : CodeBlob(name, cb, sizeof(RuntimeStub), size, frame_complete, frame_size, oop_maps)
duke@435 318 {
duke@435 319 _caller_must_gc_arguments = caller_must_gc_arguments;
duke@435 320 }
duke@435 321
duke@435 322
duke@435 323 RuntimeStub* RuntimeStub::new_runtime_stub(const char* stub_name,
duke@435 324 CodeBuffer* cb,
duke@435 325 int frame_complete,
duke@435 326 int frame_size,
duke@435 327 OopMapSet* oop_maps,
duke@435 328 bool caller_must_gc_arguments)
duke@435 329 {
duke@435 330 RuntimeStub* stub = NULL;
duke@435 331 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
duke@435 332 {
duke@435 333 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
duke@435 334 unsigned int size = allocation_size(cb, sizeof(RuntimeStub));
duke@435 335 stub = new (size) RuntimeStub(stub_name, cb, size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments);
duke@435 336 }
duke@435 337
duke@435 338 // Do not hold the CodeCache lock during name formatting.
duke@435 339 if (stub != NULL) {
duke@435 340 char stub_id[256];
duke@435 341 jio_snprintf(stub_id, sizeof(stub_id), "RuntimeStub - %s", stub_name);
duke@435 342 if (PrintStubCode) {
duke@435 343 tty->print_cr("Decoding %s " INTPTR_FORMAT, stub_id, stub);
duke@435 344 Disassembler::decode(stub->instructions_begin(), stub->instructions_end());
duke@435 345 }
duke@435 346 VTune::register_stub(stub_id, stub->instructions_begin(), stub->instructions_end());
duke@435 347 Forte::register_stub(stub_id, stub->instructions_begin(), stub->instructions_end());
duke@435 348
duke@435 349 if (JvmtiExport::should_post_dynamic_code_generated()) {
duke@435 350 JvmtiExport::post_dynamic_code_generated(stub_name, stub->instructions_begin(), stub->instructions_end());
duke@435 351 }
duke@435 352 }
duke@435 353
duke@435 354 // Track memory usage statistic after releasing CodeCache_lock
duke@435 355 MemoryService::track_code_cache_memory_usage();
duke@435 356
duke@435 357 return stub;
duke@435 358 }
duke@435 359
duke@435 360
duke@435 361 void* RuntimeStub::operator new(size_t s, unsigned size) {
duke@435 362 void* p = CodeCache::allocate(size);
duke@435 363 if (!p) fatal("Initial size of CodeCache is too small");
duke@435 364 return p;
duke@435 365 }
duke@435 366
duke@435 367
duke@435 368 //----------------------------------------------------------------------------------------------------
duke@435 369 // Implementation of DeoptimizationBlob
duke@435 370
duke@435 371 DeoptimizationBlob::DeoptimizationBlob(
duke@435 372 CodeBuffer* cb,
duke@435 373 int size,
duke@435 374 OopMapSet* oop_maps,
duke@435 375 int unpack_offset,
duke@435 376 int unpack_with_exception_offset,
duke@435 377 int unpack_with_reexecution_offset,
duke@435 378 int frame_size
duke@435 379 )
duke@435 380 : SingletonBlob("DeoptimizationBlob", cb, sizeof(DeoptimizationBlob), size, frame_size, oop_maps)
duke@435 381 {
duke@435 382 _unpack_offset = unpack_offset;
duke@435 383 _unpack_with_exception = unpack_with_exception_offset;
duke@435 384 _unpack_with_reexecution = unpack_with_reexecution_offset;
duke@435 385 #ifdef COMPILER1
duke@435 386 _unpack_with_exception_in_tls = -1;
duke@435 387 #endif
duke@435 388 }
duke@435 389
duke@435 390
duke@435 391 DeoptimizationBlob* DeoptimizationBlob::create(
duke@435 392 CodeBuffer* cb,
duke@435 393 OopMapSet* oop_maps,
duke@435 394 int unpack_offset,
duke@435 395 int unpack_with_exception_offset,
duke@435 396 int unpack_with_reexecution_offset,
duke@435 397 int frame_size)
duke@435 398 {
duke@435 399 DeoptimizationBlob* blob = NULL;
duke@435 400 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
duke@435 401 {
duke@435 402 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
duke@435 403 unsigned int size = allocation_size(cb, sizeof(DeoptimizationBlob));
duke@435 404 blob = new (size) DeoptimizationBlob(cb,
duke@435 405 size,
duke@435 406 oop_maps,
duke@435 407 unpack_offset,
duke@435 408 unpack_with_exception_offset,
duke@435 409 unpack_with_reexecution_offset,
duke@435 410 frame_size);
duke@435 411 }
duke@435 412
duke@435 413 // Do not hold the CodeCache lock during name formatting.
duke@435 414 if (blob != NULL) {
duke@435 415 char blob_id[256];
duke@435 416 jio_snprintf(blob_id, sizeof(blob_id), "DeoptimizationBlob@" PTR_FORMAT, blob->instructions_begin());
duke@435 417 if (PrintStubCode) {
duke@435 418 tty->print_cr("Decoding %s " INTPTR_FORMAT, blob_id, blob);
duke@435 419 Disassembler::decode(blob->instructions_begin(), blob->instructions_end());
duke@435 420 }
duke@435 421 VTune::register_stub(blob_id, blob->instructions_begin(), blob->instructions_end());
duke@435 422 Forte::register_stub(blob_id, blob->instructions_begin(), blob->instructions_end());
duke@435 423
duke@435 424 if (JvmtiExport::should_post_dynamic_code_generated()) {
duke@435 425 JvmtiExport::post_dynamic_code_generated("DeoptimizationBlob",
duke@435 426 blob->instructions_begin(),
duke@435 427 blob->instructions_end());
duke@435 428 }
duke@435 429 }
duke@435 430
duke@435 431 // Track memory usage statistic after releasing CodeCache_lock
duke@435 432 MemoryService::track_code_cache_memory_usage();
duke@435 433
duke@435 434 return blob;
duke@435 435 }
duke@435 436
duke@435 437
duke@435 438 void* DeoptimizationBlob::operator new(size_t s, unsigned size) {
duke@435 439 void* p = CodeCache::allocate(size);
duke@435 440 if (!p) fatal("Initial size of CodeCache is too small");
duke@435 441 return p;
duke@435 442 }
duke@435 443
duke@435 444 //----------------------------------------------------------------------------------------------------
duke@435 445 // Implementation of UncommonTrapBlob
duke@435 446
duke@435 447 #ifdef COMPILER2
duke@435 448 UncommonTrapBlob::UncommonTrapBlob(
duke@435 449 CodeBuffer* cb,
duke@435 450 int size,
duke@435 451 OopMapSet* oop_maps,
duke@435 452 int frame_size
duke@435 453 )
duke@435 454 : SingletonBlob("UncommonTrapBlob", cb, sizeof(UncommonTrapBlob), size, frame_size, oop_maps)
duke@435 455 {}
duke@435 456
duke@435 457
duke@435 458 UncommonTrapBlob* UncommonTrapBlob::create(
duke@435 459 CodeBuffer* cb,
duke@435 460 OopMapSet* oop_maps,
duke@435 461 int frame_size)
duke@435 462 {
duke@435 463 UncommonTrapBlob* blob = NULL;
duke@435 464 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
duke@435 465 {
duke@435 466 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
duke@435 467 unsigned int size = allocation_size(cb, sizeof(UncommonTrapBlob));
duke@435 468 blob = new (size) UncommonTrapBlob(cb, size, oop_maps, frame_size);
duke@435 469 }
duke@435 470
duke@435 471 // Do not hold the CodeCache lock during name formatting.
duke@435 472 if (blob != NULL) {
duke@435 473 char blob_id[256];
duke@435 474 jio_snprintf(blob_id, sizeof(blob_id), "UncommonTrapBlob@" PTR_FORMAT, blob->instructions_begin());
duke@435 475 if (PrintStubCode) {
duke@435 476 tty->print_cr("Decoding %s " INTPTR_FORMAT, blob_id, blob);
duke@435 477 Disassembler::decode(blob->instructions_begin(), blob->instructions_end());
duke@435 478 }
duke@435 479 VTune::register_stub(blob_id, blob->instructions_begin(), blob->instructions_end());
duke@435 480 Forte::register_stub(blob_id, blob->instructions_begin(), blob->instructions_end());
duke@435 481
duke@435 482 if (JvmtiExport::should_post_dynamic_code_generated()) {
duke@435 483 JvmtiExport::post_dynamic_code_generated("UncommonTrapBlob",
duke@435 484 blob->instructions_begin(),
duke@435 485 blob->instructions_end());
duke@435 486 }
duke@435 487 }
duke@435 488
duke@435 489 // Track memory usage statistic after releasing CodeCache_lock
duke@435 490 MemoryService::track_code_cache_memory_usage();
duke@435 491
duke@435 492 return blob;
duke@435 493 }
duke@435 494
duke@435 495
duke@435 496 void* UncommonTrapBlob::operator new(size_t s, unsigned size) {
duke@435 497 void* p = CodeCache::allocate(size);
duke@435 498 if (!p) fatal("Initial size of CodeCache is too small");
duke@435 499 return p;
duke@435 500 }
duke@435 501 #endif // COMPILER2
duke@435 502
duke@435 503
duke@435 504 //----------------------------------------------------------------------------------------------------
duke@435 505 // Implementation of ExceptionBlob
duke@435 506
duke@435 507 #ifdef COMPILER2
duke@435 508 ExceptionBlob::ExceptionBlob(
duke@435 509 CodeBuffer* cb,
duke@435 510 int size,
duke@435 511 OopMapSet* oop_maps,
duke@435 512 int frame_size
duke@435 513 )
duke@435 514 : SingletonBlob("ExceptionBlob", cb, sizeof(ExceptionBlob), size, frame_size, oop_maps)
duke@435 515 {}
duke@435 516
duke@435 517
duke@435 518 ExceptionBlob* ExceptionBlob::create(
duke@435 519 CodeBuffer* cb,
duke@435 520 OopMapSet* oop_maps,
duke@435 521 int frame_size)
duke@435 522 {
duke@435 523 ExceptionBlob* blob = NULL;
duke@435 524 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
duke@435 525 {
duke@435 526 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
duke@435 527 unsigned int size = allocation_size(cb, sizeof(ExceptionBlob));
duke@435 528 blob = new (size) ExceptionBlob(cb, size, oop_maps, frame_size);
duke@435 529 }
duke@435 530
duke@435 531 // We do not need to hold the CodeCache lock during name formatting
duke@435 532 if (blob != NULL) {
duke@435 533 char blob_id[256];
duke@435 534 jio_snprintf(blob_id, sizeof(blob_id), "ExceptionBlob@" PTR_FORMAT, blob->instructions_begin());
duke@435 535 if (PrintStubCode) {
duke@435 536 tty->print_cr("Decoding %s " INTPTR_FORMAT, blob_id, blob);
duke@435 537 Disassembler::decode(blob->instructions_begin(), blob->instructions_end());
duke@435 538 }
duke@435 539 VTune::register_stub(blob_id, blob->instructions_begin(), blob->instructions_end());
duke@435 540 Forte::register_stub(blob_id, blob->instructions_begin(), blob->instructions_end());
duke@435 541
duke@435 542 if (JvmtiExport::should_post_dynamic_code_generated()) {
duke@435 543 JvmtiExport::post_dynamic_code_generated("ExceptionBlob",
duke@435 544 blob->instructions_begin(),
duke@435 545 blob->instructions_end());
duke@435 546 }
duke@435 547 }
duke@435 548
duke@435 549 // Track memory usage statistic after releasing CodeCache_lock
duke@435 550 MemoryService::track_code_cache_memory_usage();
duke@435 551
duke@435 552 return blob;
duke@435 553 }
duke@435 554
duke@435 555
duke@435 556 void* ExceptionBlob::operator new(size_t s, unsigned size) {
duke@435 557 void* p = CodeCache::allocate(size);
duke@435 558 if (!p) fatal("Initial size of CodeCache is too small");
duke@435 559 return p;
duke@435 560 }
duke@435 561 #endif // COMPILER2
duke@435 562
duke@435 563
duke@435 564 //----------------------------------------------------------------------------------------------------
duke@435 565 // Implementation of SafepointBlob
duke@435 566
duke@435 567 SafepointBlob::SafepointBlob(
duke@435 568 CodeBuffer* cb,
duke@435 569 int size,
duke@435 570 OopMapSet* oop_maps,
duke@435 571 int frame_size
duke@435 572 )
duke@435 573 : SingletonBlob("SafepointBlob", cb, sizeof(SafepointBlob), size, frame_size, oop_maps)
duke@435 574 {}
duke@435 575
duke@435 576
duke@435 577 SafepointBlob* SafepointBlob::create(
duke@435 578 CodeBuffer* cb,
duke@435 579 OopMapSet* oop_maps,
duke@435 580 int frame_size)
duke@435 581 {
duke@435 582 SafepointBlob* blob = NULL;
duke@435 583 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
duke@435 584 {
duke@435 585 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
duke@435 586 unsigned int size = allocation_size(cb, sizeof(SafepointBlob));
duke@435 587 blob = new (size) SafepointBlob(cb, size, oop_maps, frame_size);
duke@435 588 }
duke@435 589
duke@435 590 // We do not need to hold the CodeCache lock during name formatting.
duke@435 591 if (blob != NULL) {
duke@435 592 char blob_id[256];
duke@435 593 jio_snprintf(blob_id, sizeof(blob_id), "SafepointBlob@" PTR_FORMAT, blob->instructions_begin());
duke@435 594 if (PrintStubCode) {
duke@435 595 tty->print_cr("Decoding %s " INTPTR_FORMAT, blob_id, blob);
duke@435 596 Disassembler::decode(blob->instructions_begin(), blob->instructions_end());
duke@435 597 }
duke@435 598 VTune::register_stub(blob_id, blob->instructions_begin(), blob->instructions_end());
duke@435 599 Forte::register_stub(blob_id, blob->instructions_begin(), blob->instructions_end());
duke@435 600
duke@435 601 if (JvmtiExport::should_post_dynamic_code_generated()) {
duke@435 602 JvmtiExport::post_dynamic_code_generated("SafepointBlob",
duke@435 603 blob->instructions_begin(),
duke@435 604 blob->instructions_end());
duke@435 605 }
duke@435 606 }
duke@435 607
duke@435 608 // Track memory usage statistic after releasing CodeCache_lock
duke@435 609 MemoryService::track_code_cache_memory_usage();
duke@435 610
duke@435 611 return blob;
duke@435 612 }
duke@435 613
duke@435 614
duke@435 615 void* SafepointBlob::operator new(size_t s, unsigned size) {
duke@435 616 void* p = CodeCache::allocate(size);
duke@435 617 if (!p) fatal("Initial size of CodeCache is too small");
duke@435 618 return p;
duke@435 619 }
duke@435 620
duke@435 621
duke@435 622 //----------------------------------------------------------------------------------------------------
duke@435 623 // Verification and printing
duke@435 624
duke@435 625 void CodeBlob::verify() {
duke@435 626 ShouldNotReachHere();
duke@435 627 }
duke@435 628
duke@435 629 #ifndef PRODUCT
duke@435 630
duke@435 631 void CodeBlob::print() const {
duke@435 632 tty->print_cr("[CodeBlob (" INTPTR_FORMAT ")]", this);
duke@435 633 tty->print_cr("Framesize: %d", _frame_size);
duke@435 634 }
duke@435 635
duke@435 636
duke@435 637 void CodeBlob::print_value_on(outputStream* st) const {
duke@435 638 st->print_cr("[CodeBlob]");
duke@435 639 }
duke@435 640
duke@435 641 #endif
duke@435 642
duke@435 643 void BufferBlob::verify() {
duke@435 644 // unimplemented
duke@435 645 }
duke@435 646
duke@435 647 #ifndef PRODUCT
duke@435 648
duke@435 649 void BufferBlob::print() const {
duke@435 650 CodeBlob::print();
duke@435 651 print_value_on(tty);
duke@435 652 }
duke@435 653
duke@435 654
duke@435 655 void BufferBlob::print_value_on(outputStream* st) const {
duke@435 656 st->print_cr("BufferBlob (" INTPTR_FORMAT ") used for %s", this, name());
duke@435 657 }
duke@435 658
duke@435 659
duke@435 660 #endif
duke@435 661
duke@435 662 void RuntimeStub::verify() {
duke@435 663 // unimplemented
duke@435 664 }
duke@435 665
duke@435 666 #ifndef PRODUCT
duke@435 667
duke@435 668 void RuntimeStub::print() const {
duke@435 669 CodeBlob::print();
duke@435 670 tty->print("Runtime Stub (" INTPTR_FORMAT "): ", this);
duke@435 671 tty->print_cr(name());
duke@435 672 Disassembler::decode((CodeBlob*)this);
duke@435 673 }
duke@435 674
duke@435 675
duke@435 676 void RuntimeStub::print_value_on(outputStream* st) const {
duke@435 677 st->print("RuntimeStub (" INTPTR_FORMAT "): ", this); st->print(name());
duke@435 678 }
duke@435 679
duke@435 680 #endif
duke@435 681
duke@435 682 void SingletonBlob::verify() {
duke@435 683 // unimplemented
duke@435 684 }
duke@435 685
duke@435 686 #ifndef PRODUCT
duke@435 687
duke@435 688 void SingletonBlob::print() const {
duke@435 689 CodeBlob::print();
duke@435 690 tty->print_cr(name());
duke@435 691 Disassembler::decode((CodeBlob*)this);
duke@435 692 }
duke@435 693
duke@435 694
duke@435 695 void SingletonBlob::print_value_on(outputStream* st) const {
duke@435 696 st->print_cr(name());
duke@435 697 }
duke@435 698
duke@435 699 void DeoptimizationBlob::print_value_on(outputStream* st) const {
duke@435 700 st->print_cr("Deoptimization (frame not available)");
duke@435 701 }
duke@435 702
duke@435 703 #endif // PRODUCT

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial