< prev index next >

src/hotspot/share/oops/oop.inline.hpp

Print this page




 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();
< prev index next >