231   // Returns true if the reference is to an object in the reserved space
 232   // for the young generation.
 233   // Assumes the the young gen address range is less than that of the old gen.
 234   bool is_in_young(oop p);
 235 
 236 #ifdef ASSERT
 237   bool is_in_partial_collection(const void* p);
 238 #endif
 239 
 240   // Optimized nmethod scanning support routines
 241   virtual void register_nmethod(nmethod* nm);
 242   virtual void unregister_nmethod(nmethod* nm);
 243   virtual void verify_nmethod(nmethod* nm);
 244   virtual void flush_nmethod(nmethod* nm);
 245 
 246   void prune_scavengable_nmethods();
 247 
 248   // Iteration functions.
 249   void oop_iterate(OopIterateClosure* cl);
 250   void object_iterate(ObjectClosure* cl);
 251   void safe_object_iterate(ObjectClosure* cl);
 252   Space* space_containing(const void* addr) const;
 253 
 254   // A CollectedHeap is divided into a dense sequence of "blocks"; that is,
 255   // each address in the (reserved) heap is a member of exactly
 256   // one block.  The defining characteristic of a block is that it is
 257   // possible to find its size, and thus to progress forward to the next
 258   // block.  (Blocks may be of different sizes.)  Thus, blocks may
 259   // represent Java objects, or they might be free blocks in a
 260   // free-list-based heap (or subheap), as long as the two kinds are
 261   // distinguishable and the size of each is determinable.
 262 
 263   // Returns the address of the start of the "block" that contains the
 264   // address "addr".  We say "blocks" instead of "object" since some heaps
 265   // may not pack objects densely; a chunk may either be an object or a
 266   // non-object.
 267   HeapWord* block_start(const void* addr) const;
 268 
 269   // Requires "addr" to be the start of a block, and returns "TRUE" iff
 270   // the block is an object. Assumes (and verifies in non-product
 271   // builds) that addr is in the allocated part of the heap and is

 231   // Returns true if the reference is to an object in the reserved space
 232   // for the young generation.
 233   // Assumes the the young gen address range is less than that of the old gen.
 234   bool is_in_young(oop p);
 235 
 236 #ifdef ASSERT
 237   bool is_in_partial_collection(const void* p);
 238 #endif
 239 
 240   // Optimized nmethod scanning support routines
 241   virtual void register_nmethod(nmethod* nm);
 242   virtual void unregister_nmethod(nmethod* nm);
 243   virtual void verify_nmethod(nmethod* nm);
 244   virtual void flush_nmethod(nmethod* nm);
 245 
 246   void prune_scavengable_nmethods();
 247 
 248   // Iteration functions.
 249   void oop_iterate(OopIterateClosure* cl);
 250   void object_iterate(ObjectClosure* cl);

 251   Space* space_containing(const void* addr) const;
 252 
 253   // A CollectedHeap is divided into a dense sequence of "blocks"; that is,
 254   // each address in the (reserved) heap is a member of exactly
 255   // one block.  The defining characteristic of a block is that it is
 256   // possible to find its size, and thus to progress forward to the next
 257   // block.  (Blocks may be of different sizes.)  Thus, blocks may
 258   // represent Java objects, or they might be free blocks in a
 259   // free-list-based heap (or subheap), as long as the two kinds are
 260   // distinguishable and the size of each is determinable.
 261 
 262   // Returns the address of the start of the "block" that contains the
 263   // address "addr".  We say "blocks" instead of "object" since some heaps
 264   // may not pack objects densely; a chunk may either be an object or a
 265   // non-object.
 266   HeapWord* block_start(const void* addr) const;
 267 
 268   // Requires "addr" to be the start of a block, and returns "TRUE" iff
 269   // the block is an object. Assumes (and verifies in non-product
 270   // builds) that addr is in the allocated part of the heap and is