38 void InstanceRefKlass::oop_oop_iterate_ref_processing_specialized(oop obj, OopClosureType* closure, Contains& contains) {
  39   T* disc_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
  40   if (closure->apply_to_weak_ref_discovered_field()) {
  41     Devirtualizer<nv>::do_oop(closure, disc_addr);
  42   }
  43 
  44   T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
  45   T heap_oop = oopDesc::load_heap_oop(referent_addr);
  46   ReferenceProcessor* rp = closure->_ref_processor;
  47   if (!oopDesc::is_null(heap_oop)) {
  48     oop referent = oopDesc::decode_heap_oop_not_null(heap_oop);
  49     if (!referent->is_gc_marked() && (rp != NULL) &&
  50         rp->discover_reference(obj, reference_type())) {
  51       return;
  52     } else if (contains(referent_addr)) {
  53       // treat referent as normal oop
  54       Devirtualizer<nv>::do_oop(closure, referent_addr);
  55     }
  56   }
  57   T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);
  58   if (ReferenceProcessor::pending_list_uses_discovered_field()) {
  59     T next_oop  = oopDesc::load_heap_oop(next_addr);
  60     // Treat discovered as normal oop, if ref is not "active" (next non-NULL)
  61     if (!oopDesc::is_null(next_oop) && contains(disc_addr)) {
  62       // i.e. ref is not "active"
  63       debug_only(
  64         if(TraceReferenceGC && PrintGCDetails) {
  65           gclog_or_tty->print_cr("   Process discovered as normal "
  66                                  PTR_FORMAT, p2i(disc_addr));
  67         }
  68       )
  69       Devirtualizer<nv>::do_oop(closure, disc_addr);
  70     }
  71   } else {
  72     // In the case of older JDKs which do not use the discovered field for
  73     // the pending list, an inactive ref (next != NULL) must always have a
  74     // NULL discovered field.
  75     debug_only(
  76       T next_oop = oopDesc::load_heap_oop(next_addr);
  77       T disc_oop = oopDesc::load_heap_oop(disc_addr);
  78       assert(oopDesc::is_null(next_oop) || oopDesc::is_null(disc_oop),
  79            err_msg("Found an inactive reference " PTR_FORMAT " with a non-NULL"
  80                    "discovered field", p2i(obj)));
  81     )
  82   }
  83   // treat next as normal oop
  84   if (contains(next_addr)) {
  85     Devirtualizer<nv>::do_oop(closure, next_addr);
  86   }
  87 }
  88 
  89 class AlwaysContains {
  90  public:
  91   template <typename T> bool operator()(T* p) const { return true; }
  92 };
  93 
  94 template <bool nv, class OopClosureType>
  95 void InstanceRefKlass::oop_oop_iterate_ref_processing(oop obj, OopClosureType* closure) {
  96   AlwaysContains always_contains;
  97   if (UseCompressedOops) {
  98     oop_oop_iterate_ref_processing_specialized<nv, narrowOop>(obj, closure, always_contains);
  99   } else {
 100     oop_oop_iterate_ref_processing_specialized<nv, oop>(obj, closure, always_contains);
 101   }

  38 void InstanceRefKlass::oop_oop_iterate_ref_processing_specialized(oop obj, OopClosureType* closure, Contains& contains) {
  39   T* disc_addr = (T*)java_lang_ref_Reference::discovered_addr(obj);
  40   if (closure->apply_to_weak_ref_discovered_field()) {
  41     Devirtualizer<nv>::do_oop(closure, disc_addr);
  42   }
  43 
  44   T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj);
  45   T heap_oop = oopDesc::load_heap_oop(referent_addr);
  46   ReferenceProcessor* rp = closure->_ref_processor;
  47   if (!oopDesc::is_null(heap_oop)) {
  48     oop referent = oopDesc::decode_heap_oop_not_null(heap_oop);
  49     if (!referent->is_gc_marked() && (rp != NULL) &&
  50         rp->discover_reference(obj, reference_type())) {
  51       return;
  52     } else if (contains(referent_addr)) {
  53       // treat referent as normal oop
  54       Devirtualizer<nv>::do_oop(closure, referent_addr);
  55     }
  56   }
  57   T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj);

  58   T next_oop  = oopDesc::load_heap_oop(next_addr);
  59   // Treat discovered as normal oop, if ref is not "active" (next non-NULL)
  60   if (!oopDesc::is_null(next_oop) && contains(disc_addr)) {
  61     // i.e. ref is not "active"
  62     debug_only(
  63       if(TraceReferenceGC && PrintGCDetails) {
  64         gclog_or_tty->print_cr("   Process discovered as normal "
  65                                PTR_FORMAT, p2i(disc_addr));
  66       }
  67     )
  68     Devirtualizer<nv>::do_oop(closure, disc_addr);












  69   }
  70   // treat next as normal oop
  71   if (contains(next_addr)) {
  72     Devirtualizer<nv>::do_oop(closure, next_addr);
  73   }
  74 }
  75 
  76 class AlwaysContains {
  77  public:
  78   template <typename T> bool operator()(T* p) const { return true; }
  79 };
  80 
  81 template <bool nv, class OopClosureType>
  82 void InstanceRefKlass::oop_oop_iterate_ref_processing(oop obj, OopClosureType* closure) {
  83   AlwaysContains always_contains;
  84   if (UseCompressedOops) {
  85     oop_oop_iterate_ref_processing_specialized<nv, narrowOop>(obj, closure, always_contains);
  86   } else {
  87     oop_oop_iterate_ref_processing_specialized<nv, oop>(obj, closure, always_contains);
  88   }