Mercurial > hg > graal-jvmci-8
comparison src/share/vm/code/codeBlob.cpp @ 3464:be4ca325525a
Merge.
author | Thomas Wuerthinger <thomas@wuerthinger.net> |
---|---|
date | Wed, 27 Jul 2011 17:32:44 -0700 |
parents | 167b70ff3abc |
children | d2a62e0f25eb |
comparison
equal
deleted
inserted
replaced
3239:7c4b4daac19b | 3464:be4ca325525a |
---|---|
150 _oop_maps = NULL; | 150 _oop_maps = NULL; |
151 } | 151 } |
152 } | 152 } |
153 | 153 |
154 | 154 |
155 void CodeBlob::trace_new_stub(CodeBlob* stub, const char* name1, const char* name2) { | |
156 // Do not hold the CodeCache lock during name formatting. | |
157 assert(!CodeCache_lock->owned_by_self(), "release CodeCache before registering the stub"); | |
158 | |
159 if (stub != NULL) { | |
160 char stub_id[256]; | |
161 assert(strlen(name1) + strlen(name2) < sizeof(stub_id), ""); | |
162 jio_snprintf(stub_id, sizeof(stub_id), "%s%s", name1, name2); | |
163 if (PrintStubCode) { | |
164 tty->print_cr("Decoding %s " INTPTR_FORMAT, stub_id, (intptr_t) stub); | |
165 Disassembler::decode(stub->code_begin(), stub->code_end()); | |
166 } | |
167 Forte::register_stub(stub_id, stub->code_begin(), stub->code_end()); | |
168 | |
169 if (JvmtiExport::should_post_dynamic_code_generated()) { | |
170 const char* stub_name = name2; | |
171 if (name2[0] == '\0') stub_name = name1; | |
172 JvmtiExport::post_dynamic_code_generated(stub_name, stub->code_begin(), stub->code_end()); | |
173 } | |
174 } | |
175 | |
176 // Track memory usage statistic after releasing CodeCache_lock | |
177 MemoryService::track_code_cache_memory_usage(); | |
178 } | |
179 | |
180 | |
155 void CodeBlob::flush() { | 181 void CodeBlob::flush() { |
156 if (_oop_maps) { | 182 if (_oop_maps) { |
157 FREE_C_HEAP_ARRAY(unsigned char, _oop_maps); | 183 FREE_C_HEAP_ARRAY(unsigned char, _oop_maps); |
158 _oop_maps = NULL; | 184 _oop_maps = NULL; |
159 } | 185 } |
310 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | 336 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
311 unsigned int size = allocation_size(cb, sizeof(RuntimeStub)); | 337 unsigned int size = allocation_size(cb, sizeof(RuntimeStub)); |
312 stub = new (size) RuntimeStub(stub_name, cb, size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments); | 338 stub = new (size) RuntimeStub(stub_name, cb, size, frame_complete, frame_size, oop_maps, caller_must_gc_arguments); |
313 } | 339 } |
314 | 340 |
315 // Do not hold the CodeCache lock during name formatting. | 341 trace_new_stub(stub, "RuntimeStub - ", stub_name); |
316 if (stub != NULL) { | |
317 char stub_id[256]; | |
318 jio_snprintf(stub_id, sizeof(stub_id), "RuntimeStub - %s", stub_name); | |
319 if (PrintStubCode) { | |
320 tty->print_cr("Decoding %s " INTPTR_FORMAT, stub_id, stub); | |
321 Disassembler::decode(stub->code_begin(), stub->code_end()); | |
322 } | |
323 Forte::register_stub(stub_id, stub->code_begin(), stub->code_end()); | |
324 | |
325 if (JvmtiExport::should_post_dynamic_code_generated()) { | |
326 JvmtiExport::post_dynamic_code_generated(stub_name, stub->code_begin(), stub->code_end()); | |
327 } | |
328 } | |
329 | |
330 // Track memory usage statistic after releasing CodeCache_lock | |
331 MemoryService::track_code_cache_memory_usage(); | |
332 | 342 |
333 return stub; | 343 return stub; |
334 } | 344 } |
335 | 345 |
336 | 346 |
337 void* RuntimeStub::operator new(size_t s, unsigned size) { | 347 void* RuntimeStub::operator new(size_t s, unsigned size) { |
338 void* p = CodeCache::allocate(size); | 348 void* p = CodeCache::allocate(size); |
339 if (!p) fatal("Initial size of CodeCache is too small"); | 349 if (!p) fatal("Initial size of CodeCache is too small"); |
340 return p; | 350 return p; |
351 } | |
352 | |
353 // operator new shared by all singletons: | |
354 void* SingletonBlob::operator new(size_t s, unsigned size) { | |
355 void* p = CodeCache::allocate(size); | |
356 if (!p) fatal("Initial size of CodeCache is too small"); | |
357 return p; | |
358 } | |
359 | |
360 | |
361 //---------------------------------------------------------------------------------------------------- | |
362 // Implementation of RicochetBlob | |
363 | |
364 RicochetBlob::RicochetBlob( | |
365 CodeBuffer* cb, | |
366 int size, | |
367 int bounce_offset, | |
368 int exception_offset, | |
369 int frame_size | |
370 ) | |
371 : SingletonBlob("RicochetBlob", cb, sizeof(RicochetBlob), size, frame_size, (OopMapSet*) NULL) | |
372 { | |
373 _bounce_offset = bounce_offset; | |
374 _exception_offset = exception_offset; | |
375 } | |
376 | |
377 | |
378 RicochetBlob* RicochetBlob::create( | |
379 CodeBuffer* cb, | |
380 int bounce_offset, | |
381 int exception_offset, | |
382 int frame_size) | |
383 { | |
384 RicochetBlob* blob = NULL; | |
385 ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock | |
386 { | |
387 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | |
388 unsigned int size = allocation_size(cb, sizeof(RicochetBlob)); | |
389 blob = new (size) RicochetBlob(cb, size, bounce_offset, exception_offset, frame_size); | |
390 } | |
391 | |
392 trace_new_stub(blob, "RicochetBlob"); | |
393 | |
394 return blob; | |
341 } | 395 } |
342 | 396 |
343 | 397 |
344 //---------------------------------------------------------------------------------------------------- | 398 //---------------------------------------------------------------------------------------------------- |
345 // Implementation of DeoptimizationBlob | 399 // Implementation of DeoptimizationBlob |
384 unpack_with_exception_offset, | 438 unpack_with_exception_offset, |
385 unpack_with_reexecution_offset, | 439 unpack_with_reexecution_offset, |
386 frame_size); | 440 frame_size); |
387 } | 441 } |
388 | 442 |
389 // Do not hold the CodeCache lock during name formatting. | 443 trace_new_stub(blob, "DeoptimizationBlob"); |
390 if (blob != NULL) { | 444 |
391 char blob_id[256]; | 445 return blob; |
392 jio_snprintf(blob_id, sizeof(blob_id), "DeoptimizationBlob@" PTR_FORMAT, blob->code_begin()); | 446 } |
393 if (PrintStubCode) { | 447 |
394 tty->print_cr("Decoding %s " INTPTR_FORMAT, blob_id, blob); | |
395 Disassembler::decode(blob->code_begin(), blob->code_end()); | |
396 } | |
397 Forte::register_stub(blob_id, blob->code_begin(), blob->code_end()); | |
398 | |
399 if (JvmtiExport::should_post_dynamic_code_generated()) { | |
400 JvmtiExport::post_dynamic_code_generated("DeoptimizationBlob", blob->code_begin(), blob->code_end()); | |
401 } | |
402 } | |
403 | |
404 // Track memory usage statistic after releasing CodeCache_lock | |
405 MemoryService::track_code_cache_memory_usage(); | |
406 | |
407 return blob; | |
408 } | |
409 | |
410 | |
411 void* DeoptimizationBlob::operator new(size_t s, unsigned size) { | |
412 void* p = CodeCache::allocate(size); | |
413 if (!p) fatal("Initial size of CodeCache is too small"); | |
414 return p; | |
415 } | |
416 | 448 |
417 //---------------------------------------------------------------------------------------------------- | 449 //---------------------------------------------------------------------------------------------------- |
418 // Implementation of UncommonTrapBlob | 450 // Implementation of UncommonTrapBlob |
419 | 451 |
420 #ifdef COMPILER2 | 452 #ifdef COMPILER2 |
439 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | 471 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
440 unsigned int size = allocation_size(cb, sizeof(UncommonTrapBlob)); | 472 unsigned int size = allocation_size(cb, sizeof(UncommonTrapBlob)); |
441 blob = new (size) UncommonTrapBlob(cb, size, oop_maps, frame_size); | 473 blob = new (size) UncommonTrapBlob(cb, size, oop_maps, frame_size); |
442 } | 474 } |
443 | 475 |
444 // Do not hold the CodeCache lock during name formatting. | 476 trace_new_stub(blob, "UncommonTrapBlob"); |
445 if (blob != NULL) { | 477 |
446 char blob_id[256]; | 478 return blob; |
447 jio_snprintf(blob_id, sizeof(blob_id), "UncommonTrapBlob@" PTR_FORMAT, blob->code_begin()); | 479 } |
448 if (PrintStubCode) { | 480 |
449 tty->print_cr("Decoding %s " INTPTR_FORMAT, blob_id, blob); | 481 |
450 Disassembler::decode(blob->code_begin(), blob->code_end()); | |
451 } | |
452 Forte::register_stub(blob_id, blob->code_begin(), blob->code_end()); | |
453 | |
454 if (JvmtiExport::should_post_dynamic_code_generated()) { | |
455 JvmtiExport::post_dynamic_code_generated("UncommonTrapBlob", blob->code_begin(), blob->code_end()); | |
456 } | |
457 } | |
458 | |
459 // Track memory usage statistic after releasing CodeCache_lock | |
460 MemoryService::track_code_cache_memory_usage(); | |
461 | |
462 return blob; | |
463 } | |
464 | |
465 | |
466 void* UncommonTrapBlob::operator new(size_t s, unsigned size) { | |
467 void* p = CodeCache::allocate(size); | |
468 if (!p) fatal("Initial size of CodeCache is too small"); | |
469 return p; | |
470 } | |
471 #endif // COMPILER2 | 482 #endif // COMPILER2 |
472 | 483 |
473 | 484 |
474 //---------------------------------------------------------------------------------------------------- | 485 //---------------------------------------------------------------------------------------------------- |
475 // Implementation of ExceptionBlob | 486 // Implementation of ExceptionBlob |
496 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | 507 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
497 unsigned int size = allocation_size(cb, sizeof(ExceptionBlob)); | 508 unsigned int size = allocation_size(cb, sizeof(ExceptionBlob)); |
498 blob = new (size) ExceptionBlob(cb, size, oop_maps, frame_size); | 509 blob = new (size) ExceptionBlob(cb, size, oop_maps, frame_size); |
499 } | 510 } |
500 | 511 |
501 // We do not need to hold the CodeCache lock during name formatting | 512 trace_new_stub(blob, "ExceptionBlob"); |
502 if (blob != NULL) { | 513 |
503 char blob_id[256]; | 514 return blob; |
504 jio_snprintf(blob_id, sizeof(blob_id), "ExceptionBlob@" PTR_FORMAT, blob->code_begin()); | 515 } |
505 if (PrintStubCode) { | 516 |
506 tty->print_cr("Decoding %s " INTPTR_FORMAT, blob_id, blob); | 517 |
507 Disassembler::decode(blob->code_begin(), blob->code_end()); | |
508 } | |
509 Forte::register_stub(blob_id, blob->code_begin(), blob->code_end()); | |
510 | |
511 if (JvmtiExport::should_post_dynamic_code_generated()) { | |
512 JvmtiExport::post_dynamic_code_generated("ExceptionBlob", blob->code_begin(), blob->code_end()); | |
513 } | |
514 } | |
515 | |
516 // Track memory usage statistic after releasing CodeCache_lock | |
517 MemoryService::track_code_cache_memory_usage(); | |
518 | |
519 return blob; | |
520 } | |
521 | |
522 | |
523 void* ExceptionBlob::operator new(size_t s, unsigned size) { | |
524 void* p = CodeCache::allocate(size); | |
525 if (!p) fatal("Initial size of CodeCache is too small"); | |
526 return p; | |
527 } | |
528 #endif // COMPILER2 | 518 #endif // COMPILER2 |
529 | 519 |
530 | 520 |
531 //---------------------------------------------------------------------------------------------------- | 521 //---------------------------------------------------------------------------------------------------- |
532 // Implementation of SafepointBlob | 522 // Implementation of SafepointBlob |
552 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); | 542 MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag); |
553 unsigned int size = allocation_size(cb, sizeof(SafepointBlob)); | 543 unsigned int size = allocation_size(cb, sizeof(SafepointBlob)); |
554 blob = new (size) SafepointBlob(cb, size, oop_maps, frame_size); | 544 blob = new (size) SafepointBlob(cb, size, oop_maps, frame_size); |
555 } | 545 } |
556 | 546 |
557 // We do not need to hold the CodeCache lock during name formatting. | 547 trace_new_stub(blob, "SafepointBlob"); |
558 if (blob != NULL) { | 548 |
559 char blob_id[256]; | 549 return blob; |
560 jio_snprintf(blob_id, sizeof(blob_id), "SafepointBlob@" PTR_FORMAT, blob->code_begin()); | |
561 if (PrintStubCode) { | |
562 tty->print_cr("Decoding %s " INTPTR_FORMAT, blob_id, blob); | |
563 Disassembler::decode(blob->code_begin(), blob->code_end()); | |
564 } | |
565 Forte::register_stub(blob_id, blob->code_begin(), blob->code_end()); | |
566 | |
567 if (JvmtiExport::should_post_dynamic_code_generated()) { | |
568 JvmtiExport::post_dynamic_code_generated("SafepointBlob", blob->code_begin(), blob->code_end()); | |
569 } | |
570 } | |
571 | |
572 // Track memory usage statistic after releasing CodeCache_lock | |
573 MemoryService::track_code_cache_memory_usage(); | |
574 | |
575 return blob; | |
576 } | |
577 | |
578 | |
579 void* SafepointBlob::operator new(size_t s, unsigned size) { | |
580 void* p = CodeCache::allocate(size); | |
581 if (!p) fatal("Initial size of CodeCache is too small"); | |
582 return p; | |
583 } | 550 } |
584 | 551 |
585 | 552 |
586 //---------------------------------------------------------------------------------------------------- | 553 //---------------------------------------------------------------------------------------------------- |
587 // Verification and printing | 554 // Verification and printing |