415 416 void oopDesc::pc_update_contents(ParCompactionManager* cm) { 417 Klass* k = klass(); 418 if (!k->is_typeArray_klass()) { 419 // It might contain oops beyond the header, so take the virtual call. 420 k->oop_pc_update_pointers(this, cm); 421 } 422 // Else skip it. The TypeArrayKlass in the header never needs scavenging. 423 } 424 425 void oopDesc::ps_push_contents(PSPromotionManager* pm) { 426 Klass* k = klass(); 427 if (!k->is_typeArray_klass()) { 428 // It might contain oops beyond the header, so take the virtual call. 429 k->oop_ps_push_contents(this, pm); 430 } 431 // Else skip it. The TypeArrayKlass in the header never needs scavenging. 432 } 433 #endif // INCLUDE_PARALLELGC 434 435 #define OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ 436 \ 437 void oopDesc::oop_iterate(OopClosureType* blk) { \ 438 klass()->oop_oop_iterate##nv_suffix(this, blk); \ 439 } \ 440 \ 441 void oopDesc::oop_iterate(OopClosureType* blk, MemRegion mr) { \ 442 klass()->oop_oop_iterate_bounded##nv_suffix(this, blk, mr); \ 443 } 444 445 #define OOP_ITERATE_SIZE_DEFN(OopClosureType, nv_suffix) \ 446 \ 447 int oopDesc::oop_iterate_size(OopClosureType* blk) { \ 448 Klass* k = klass(); \ 449 int size = size_given_klass(k); \ 450 k->oop_oop_iterate##nv_suffix(this, blk); \ 451 return size; \ 452 } \ 453 \ 454 int oopDesc::oop_iterate_size(OopClosureType* blk, MemRegion mr) { \ 455 Klass* k = klass(); \ 456 int size = size_given_klass(k); \ 457 k->oop_oop_iterate_bounded##nv_suffix(this, blk, mr); \ 458 return size; \ 459 } 460 461 int oopDesc::oop_iterate_no_header(OopClosure* blk) { 462 // The NoHeaderExtendedOopClosure wraps the OopClosure and proxies all 463 // the do_oop calls, but turns off all other features in ExtendedOopClosure. 464 NoHeaderExtendedOopClosure cl(blk); 465 return oop_iterate_size(&cl); 466 } 467 468 int oopDesc::oop_iterate_no_header(OopClosure* blk, MemRegion mr) { 469 NoHeaderExtendedOopClosure cl(blk); 470 return oop_iterate_size(&cl, mr); 471 } 472 473 #if INCLUDE_OOP_OOP_ITERATE_BACKWARDS 474 #define OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \ 475 \ 476 inline void oopDesc::oop_iterate_backwards(OopClosureType* blk) { \ 477 klass()->oop_oop_iterate_backwards##nv_suffix(this, blk); \ 478 } 479 #else 480 #define OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) 481 #endif 482 483 #define ALL_OOPDESC_OOP_ITERATE(OopClosureType, nv_suffix) \ 484 OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ 485 OOP_ITERATE_SIZE_DEFN(OopClosureType, nv_suffix) \ 486 OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) 487 488 ALL_OOP_OOP_ITERATE_CLOSURES_1(ALL_OOPDESC_OOP_ITERATE) 489 ALL_OOP_OOP_ITERATE_CLOSURES_2(ALL_OOPDESC_OOP_ITERATE) 490 491 bool oopDesc::is_instanceof_or_null(oop obj, Klass* klass) { 492 return obj == NULL || obj->klass()->is_subtype_of(klass); 493 } 494 495 intptr_t oopDesc::identity_hash() { 496 // Fast case; if the object is unlocked and the hash value is set, no locking is needed 497 // Note: The mark must be read into local variable to avoid concurrent updates. 498 markOop mrk = mark(); 499 if (mrk->is_unlocked() && !mrk->has_no_hash()) { 500 return mrk->hash(); 501 } else if (mrk->is_marked()) { 502 return mrk->hash(); 503 } else { 504 return slow_identity_hash(); 505 } 506 } 507 508 bool oopDesc::has_displaced_mark_raw() const { 509 return mark_raw()->has_displaced_mark_helper(); | 415 416 void oopDesc::pc_update_contents(ParCompactionManager* cm) { 417 Klass* k = klass(); 418 if (!k->is_typeArray_klass()) { 419 // It might contain oops beyond the header, so take the virtual call. 420 k->oop_pc_update_pointers(this, cm); 421 } 422 // Else skip it. The TypeArrayKlass in the header never needs scavenging. 423 } 424 425 void oopDesc::ps_push_contents(PSPromotionManager* pm) { 426 Klass* k = klass(); 427 if (!k->is_typeArray_klass()) { 428 // It might contain oops beyond the header, so take the virtual call. 429 k->oop_ps_push_contents(this, pm); 430 } 431 // Else skip it. The TypeArrayKlass in the header never needs scavenging. 432 } 433 #endif // INCLUDE_PARALLELGC 434 435 template <typename OopClosureType> 436 void oopDesc::oop_iterate(OopClosureType* cl) { 437 OopClosureDispatch::oop_oop_iterate(cl, this, klass()); 438 } 439 440 template <typename OopClosureType> 441 void oopDesc::oop_iterate(OopClosureType* cl, MemRegion mr) { 442 OopClosureDispatch::oop_oop_iterate(cl, this, klass(), mr); 443 } 444 445 template <typename OopClosureType> 446 int oopDesc::oop_iterate_size(OopClosureType* cl) { 447 Klass* k = klass(); 448 int size = size_given_klass(k); 449 OopClosureDispatch::oop_oop_iterate(cl, this, k); 450 return size; 451 } 452 453 template <typename OopClosureType> 454 int oopDesc::oop_iterate_size(OopClosureType* cl, MemRegion mr) { 455 Klass* k = klass(); 456 int size = size_given_klass(k); 457 OopClosureDispatch::oop_oop_iterate(cl, this, k, mr); 458 return size; 459 } 460 461 template <typename OopClosureType> 462 void oopDesc::oop_iterate_backwards(OopClosureType* cl) { 463 OopClosureDispatch::oop_oop_iterate_backwards(cl, this, klass()); 464 } 465 466 int oopDesc::oop_iterate_no_header(OopClosure* blk) { 467 // The NoHeaderExtendedOopClosure wraps the OopClosure and proxies all 468 // the do_oop calls, but turns off all other features in OopIterateClosure. 469 NoHeaderExtendedOopClosure cl(blk); 470 return oop_iterate_size(&cl); 471 } 472 473 int oopDesc::oop_iterate_no_header(OopClosure* blk, MemRegion mr) { 474 NoHeaderExtendedOopClosure cl(blk); 475 return oop_iterate_size(&cl, mr); 476 } 477 478 bool oopDesc::is_instanceof_or_null(oop obj, Klass* klass) { 479 return obj == NULL || obj->klass()->is_subtype_of(klass); 480 } 481 482 intptr_t oopDesc::identity_hash() { 483 // Fast case; if the object is unlocked and the hash value is set, no locking is needed 484 // Note: The mark must be read into local variable to avoid concurrent updates. 485 markOop mrk = mark(); 486 if (mrk->is_unlocked() && !mrk->has_no_hash()) { 487 return mrk->hash(); 488 } else if (mrk->is_marked()) { 489 return mrk->hash(); 490 } else { 491 return slow_identity_hash(); 492 } 493 } 494 495 bool oopDesc::has_displaced_mark_raw() const { 496 return mark_raw()->has_displaced_mark_helper(); |