153 template <typename T>
154 void ShenandoahSTWRootScanner::roots_do(T* oops, uint worker_id) {
155   MarkingNMethodClosure nmethods_cl(oops);
156   CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong);
157   ResourceMark rm;
158 
159   if (_unload_classes) {
160     _thread_roots.oops_do(oops, &nmethods_cl, worker_id);
161     _cld_roots.always_strong_cld_do(&clds, worker_id);
162   } else {
163     _thread_roots.oops_do(oops, nullptr, worker_id);
164     _code_roots.nmethods_do(&nmethods_cl, worker_id);
165     _cld_roots.cld_do(&clds, worker_id);
166   }
167 
168   _vm_roots.oops_do<T>(oops, worker_id);
169 }
170 
171 template <typename IsAlive, typename KeepAlive>
172 void ShenandoahRootUpdater::roots_do(uint worker_id, IsAlive* is_alive, KeepAlive* keep_alive) {
173   NMethodToOopClosure update_nmethods(keep_alive, NMethodToOopClosure::FixRelocations);
174   ShenandoahNMethodAndDisarmClosure nmethods_and_disarm_Cl(keep_alive);
175   NMethodToOopClosure* codes_cl = ShenandoahCodeRoots::use_nmethod_barriers_for_mark() ?
176                                   static_cast<NMethodToOopClosure*>(&nmethods_and_disarm_Cl) :
177                                   static_cast<NMethodToOopClosure*>(&update_nmethods);
178 
179   CLDToOopClosure clds(keep_alive, ClassLoaderData::_claim_strong);
180 
181   // Process light-weight/limited parallel roots then
182   _vm_roots.oops_do(keep_alive, worker_id);
183   _weak_roots.weak_oops_do<IsAlive, KeepAlive>(is_alive, keep_alive, worker_id);
184   _cld_roots.cld_do(&clds, worker_id);
185 
186   // Process heavy-weight/fully parallel roots the last
187   _code_roots.nmethods_do(codes_cl, worker_id);
188   _thread_roots.oops_do(keep_alive, nullptr, worker_id);
189 }
190 
191 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP

153 template <typename T>
154 void ShenandoahSTWRootScanner::roots_do(T* oops, uint worker_id) {
155   MarkingNMethodClosure nmethods_cl(oops);
156   CLDToOopClosure clds(oops, ClassLoaderData::_claim_strong);
157   ResourceMark rm;
158 
159   if (_unload_classes) {
160     _thread_roots.oops_do(oops, &nmethods_cl, worker_id);
161     _cld_roots.always_strong_cld_do(&clds, worker_id);
162   } else {
163     _thread_roots.oops_do(oops, nullptr, worker_id);
164     _code_roots.nmethods_do(&nmethods_cl, worker_id);
165     _cld_roots.cld_do(&clds, worker_id);
166   }
167 
168   _vm_roots.oops_do<T>(oops, worker_id);
169 }
170 
171 template <typename IsAlive, typename KeepAlive>
172 void ShenandoahRootUpdater::roots_do(uint worker_id, IsAlive* is_alive, KeepAlive* keep_alive) {

173   ShenandoahNMethodAndDisarmClosure nmethods_and_disarm_Cl(keep_alive);
174   NMethodToOopClosure* codes_cl = static_cast<NMethodToOopClosure*>(&nmethods_and_disarm_Cl);


175 
176   CLDToOopClosure clds(keep_alive, ClassLoaderData::_claim_strong);
177 
178   // Process light-weight/limited parallel roots then
179   _vm_roots.oops_do(keep_alive, worker_id);
180   _weak_roots.weak_oops_do<IsAlive, KeepAlive>(is_alive, keep_alive, worker_id);
181   _cld_roots.cld_do(&clds, worker_id);
182 
183   // Process heavy-weight/fully parallel roots the last
184   _code_roots.nmethods_do(codes_cl, worker_id);
185   _thread_roots.oops_do(keep_alive, nullptr, worker_id);
186 }
187 
188 #endif // SHARE_GC_SHENANDOAH_SHENANDOAHROOTPROCESSOR_INLINE_HPP