153   inline void do_oop_nv(narrowOop* p) { PushAndMarkClosure::do_oop_work(p); }

   153   inline void do_oop_nv(narrowOop* p) { PushAndMarkClosure::do_oop_work(p); }

   154   bool do_header() { return true; }

   154   bool do_header() { return true; }

   155   Prefetch::style prefetch_style() {

   155   Prefetch::style prefetch_style() {

   156     return Prefetch::do_read;

   156     return Prefetch::do_read;

   157   }

   157   }

   158 };

   164 };

   159 

   165 

   160 // In the parallel case, the revisit stack, the bit map and the

   166 // In the parallel case, the revisit stack, the bit map and the

   161 // reference processor are currently all shared. Access to

   167 // reference processor are currently all shared. Access to

   162 // these shared mutable structures must use appropriate

   168 // these shared mutable structures must use appropriate

   183   inline void do_oop_nv(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); }

   189   inline void do_oop_nv(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); }

   184   bool do_header() { return true; }

   190   bool do_header() { return true; }

   185   Prefetch::style prefetch_style() {

   191   Prefetch::style prefetch_style() {

   186     return Prefetch::do_read;

   192     return Prefetch::do_read;

   187   }

   193   }

   188 };

   200 };

   189 

   201 

   190 // The non-parallel version (the parallel version appears further below).

   202 // The non-parallel version (the parallel version appears further below).

   191 class MarkRefsIntoAndScanClosure: public OopsInGenClosure {

   203 class MarkRefsIntoAndScanClosure: public OopsInGenClosure {

   192  private:

   204  private:

   301                     MarkFromRootsClosure* parent);

   313                     MarkFromRootsClosure* parent);

   302   virtual void do_oop(oop* p);

   314   virtual void do_oop(oop* p);

   303   virtual void do_oop(narrowOop* p);

   315   virtual void do_oop(narrowOop* p);

   304   inline void do_oop_nv(oop* p)       { PushOrMarkClosure::do_oop_work(p); }

   316   inline void do_oop_nv(oop* p)       { PushOrMarkClosure::do_oop_work(p); }

   305   inline void do_oop_nv(narrowOop* p) { PushOrMarkClosure::do_oop_work(p); }

   317   inline void do_oop_nv(narrowOop* p) { PushOrMarkClosure::do_oop_work(p); }

   306   // Deal with a stack overflow condition

   325   // Deal with a stack overflow condition

   307   void handle_stack_overflow(HeapWord* lost);

   326   void handle_stack_overflow(HeapWord* lost);

   308  private:

   327  private:

   309   inline void do_yield_check();

   328   inline void do_yield_check();

   310 };

   329 };

   338                         Par_MarkFromRootsClosure* parent);

   357                         Par_MarkFromRootsClosure* parent);

   339   virtual void do_oop(oop* p);

   358   virtual void do_oop(oop* p);

   340   virtual void do_oop(narrowOop* p);

   359   virtual void do_oop(narrowOop* p);

   341   inline void do_oop_nv(oop* p)       { Par_PushOrMarkClosure::do_oop_work(p); }

   360   inline void do_oop_nv(oop* p)       { Par_PushOrMarkClosure::do_oop_work(p); }

   342   inline void do_oop_nv(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); }

   361   inline void do_oop_nv(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); }

   343   // Deal with a stack overflow condition

   369   // Deal with a stack overflow condition

   344   void handle_stack_overflow(HeapWord* lost);

   370   void handle_stack_overflow(HeapWord* lost);

   345  private:

   371  private:

   346   inline void do_yield_check();

   372   inline void do_yield_check();

   347 };

   373 };