hotspot/src/share/vm/oops/instanceRefKlass.cpp
changeset 6248 2e661807cef0
parent 5547 f4b087cbb361
child 7397 5b173b4ca846
equal deleted inserted replaced
6247:00e5cc407d03 6248:2e661807cef0
   271 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m)
   271 ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m)
   272 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m)
   272 ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m)
   273 
   273 
   274 #ifndef SERIALGC
   274 #ifndef SERIALGC
   275 template <class T>
   275 template <class T>
   276 void specialized_oop_copy_contents(instanceRefKlass *ref,
       
   277                                    PSPromotionManager* pm, oop obj) {
       
   278   assert(!pm->depth_first(), "invariant");
       
   279   T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
       
   280   if (PSScavenge::should_scavenge(referent_addr)) {
       
   281     ReferenceProcessor* rp = PSScavenge::reference_processor();
       
   282     if (rp->discover_reference(obj, ref->reference_type())) {
       
   283       // reference already enqueued, referent and next will be traversed later
       
   284       ref->instanceKlass::oop_copy_contents(pm, obj);
       
   285       return;
       
   286     } else {
       
   287       // treat referent as normal oop
       
   288       pm->claim_or_forward_breadth(referent_addr);
       
   289     }
       
   290   }
       
   291   // treat next as normal oop
       
   292   T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
       
   293   if (PSScavenge::should_scavenge(next_addr)) {
       
   294     pm->claim_or_forward_breadth(next_addr);
       
   295   }
       
   296   ref->instanceKlass::oop_copy_contents(pm, obj);
       
   297 }
       
   298 
       
   299 void instanceRefKlass::oop_copy_contents(PSPromotionManager* pm, oop obj) {
       
   300   if (UseCompressedOops) {
       
   301     specialized_oop_copy_contents<narrowOop>(this, pm, obj);
       
   302   } else {
       
   303     specialized_oop_copy_contents<oop>(this, pm, obj);
       
   304   }
       
   305 }
       
   306 
       
   307 template <class T>
       
   308 void specialized_oop_push_contents(instanceRefKlass *ref,
   276 void specialized_oop_push_contents(instanceRefKlass *ref,
   309                                    PSPromotionManager* pm, oop obj) {
   277                                    PSPromotionManager* pm, oop obj) {
   310   assert(pm->depth_first(), "invariant");
       
   311   T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
   278   T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
   312   if (PSScavenge::should_scavenge(referent_addr)) {
   279   if (PSScavenge::should_scavenge(referent_addr)) {
   313     ReferenceProcessor* rp = PSScavenge::reference_processor();
   280     ReferenceProcessor* rp = PSScavenge::reference_processor();
   314     if (rp->discover_reference(obj, ref->reference_type())) {
   281     if (rp->discover_reference(obj, ref->reference_type())) {
   315       // reference already enqueued, referent and next will be traversed later
   282       // reference already enqueued, referent and next will be traversed later