206 return is_in_reserved(p);
207 } else {
208 return is_in(p);
209 }
210 }
211
212 // Returns true if the reference is to an object in the reserved space
213 // for the young generation.
214 // Assumes the the young gen address range is less than that of the old gen.
215 bool is_in_young(oop p);
216
217 #ifdef ASSERT
218 bool is_in_partial_collection(const void* p);
219 #endif
220
221 virtual bool is_scavengable(const void* addr) {
222 return is_in_young((oop)addr);
223 }
224
225 // Iteration functions.
226 void oop_iterate(ExtendedOopClosure* cl);
227 void object_iterate(ObjectClosure* cl);
228 void safe_object_iterate(ObjectClosure* cl);
229 Space* space_containing(const void* addr) const;
230
231 // A CollectedHeap is divided into a dense sequence of "blocks"; that is,
232 // each address in the (reserved) heap is a member of exactly
233 // one block. The defining characteristic of a block is that it is
234 // possible to find its size, and thus to progress forward to the next
235 // block. (Blocks may be of different sizes.) Thus, blocks may
236 // represent Java objects, or they might be free blocks in a
237 // free-list-based heap (or subheap), as long as the two kinds are
238 // distinguishable and the size of each is determinable.
239
240 // Returns the address of the start of the "block" that contains the
241 // address "addr". We say "blocks" instead of "object" since some heaps
242 // may not pack objects densely; a chunk may either be an object or a
243 // non-object.
244 virtual HeapWord* block_start(const void* addr) const;
245
|
206 return is_in_reserved(p);
207 } else {
208 return is_in(p);
209 }
210 }
211
212 // Returns true if the reference is to an object in the reserved space
213 // for the young generation.
214 // Assumes the the young gen address range is less than that of the old gen.
215 bool is_in_young(oop p);
216
217 #ifdef ASSERT
218 bool is_in_partial_collection(const void* p);
219 #endif
220
221 virtual bool is_scavengable(const void* addr) {
222 return is_in_young((oop)addr);
223 }
224
225 // Iteration functions.
226 void oop_iterate_no_header(OopClosure* cl);
227 void oop_iterate(ExtendedOopClosure* cl);
228 void object_iterate(ObjectClosure* cl);
229 void safe_object_iterate(ObjectClosure* cl);
230 Space* space_containing(const void* addr) const;
231
232 // A CollectedHeap is divided into a dense sequence of "blocks"; that is,
233 // each address in the (reserved) heap is a member of exactly
234 // one block. The defining characteristic of a block is that it is
235 // possible to find its size, and thus to progress forward to the next
236 // block. (Blocks may be of different sizes.) Thus, blocks may
237 // represent Java objects, or they might be free blocks in a
238 // free-list-based heap (or subheap), as long as the two kinds are
239 // distinguishable and the size of each is determinable.
240
241 // Returns the address of the start of the "block" that contains the
242 // address "addr". We say "blocks" instead of "object" since some heaps
243 // may not pack objects densely; a chunk may either be an object or a
244 // non-object.
245 virtual HeapWord* block_start(const void* addr) const;
246
|