Perform all initializations, including those that */ may require allocation. */ Called without allocation lock. */ Must be called before a second

Set things up so that GC_size_map[i] >= granules(i), */ but not too much bigger */ and so that size_map contains relatively few distinct entries

Initiate a garbage collection. Initiates a full collection if the */ mark state is invalid. */ ARGSUSED*/

Set up forwarding counts for block h of size sz */

Primarily for debugging support: */ Is the address p in one of the registered static */ root sections? */

Check that p is visible */ to the collector as a possibly pointer containing location. */ If it isn't invoke *GC_is_visible_print_proc. */ Ret

Return the smallest address a such that VirtualQuery */ returns correct results for all addresses between a and start. */ Assumes VirtualQuery return

We must explicitly mark ptrfree and gcj free lists, since the free */ list links wouldn't otherwise be found. We also set them in the */ normal fre

* Initiate a garbage collection if appropriate. * Choose judiciously * between partial, full, and stop-world collections. * Assumes lock held, sign

Merge all unmapped blocks that are adjacent to other free */ blocks. This may involve remapping, since all blocks are either */ fully mapped or full

Should only be called by the mprotect thread */

Return the number of set mark bits in the given header */

* Allocate a new heapblock for small objects of size gran granules. * Add all of the heapblock's objects to the free list for objects * of that size

Add a thread to GC_threads. We assume it wasn't already there. */ Caller holds allocation lock. */ Unlike the pthreads version, the id field is s

Possible finalization_marker procedures. Note that mark stack */ overflow is handled by the caller, and is not a disaster. */

Return the number of blacklisted blocks in a given range. */ Used only for statistical purposes. */ Looks only at the GC_incomplete_stack_bl. */

Could p be a stack address? */

Add all pages in pht2 to pht1 */

Get the last (highest address) block whose address is */ at most h. Return 0 if there is none. */ Unlike the above, this may return a free block.

Print back trace for p */

Print a type description for the object whose client-visible address */ is p. */

* A version of GC_push_all that treats all interior pointers as valid * and scans part of the area immediately, to make sure that saved * register v

Push descriptors for the object at addr with complex descriptor d */ onto the mark stack. Return 0 if the mark stack overflowed. */

Invoke push_conditional on ranges that are not excluded. */

* Push GC internal roots. Only called if there is some reason to believe * these would not otherwise get registered. */

Push all objects reachable from marked objects in the given block */ containing objects of size 1 granule. */

Push all objects reachable from marked objects in the given block */ of size 2 (granules) objects. */

Push all objects reachable from marked objects in the given block */ of size 4 (granules) objects. */ There is a risk of mark stack overflow h

Similar to GC_push_next_marked, but return address of next block */

Identical to above, but mark only from dirty pages */

Similar to above, but for uncollectable pages. Needed since we */ do not clear marks for such pages, even for full collections. */

No asm implementation */

* Call the mark routines (GC_tl_push for a single pointer, GC_push_conditional * on groups of pointers) on every top level accessible pointer. * If

* Analogous to the above, but push only those pages h with dirty_fn(h) != 0. * We use push_fn to actually push the block. * Used both to selectively

Don't really reclaim objects, just check for unmarked ones: */ ARGSUSED*/

* Restore unmarked small objects in h of size sz to the object * free list. Returns the new list. * Clears unmarked objects. Sz is in bytes. */ A

The same thing, but don't clear objects: */ ARGSUSED*/

Remove all entries from the GC_threads table, except the */ one for the current thread. We need to do this in the child */ process after a fork(), si

Remove the signals that we want to allow in thread stopping */ handler from a set. */

Should only be called when the lock is held */

Internal use only; lock held. */

Repeatedly perform a read call until the buffer is filled or */ we encounter EOF. */

Copy back a local mark stack. */ low and high are inclusive bounds. */

* H is a free block. N points at an address inside it. * A new header for n has already been set up. Fix up h's header * to reflect the fact that

* Perform GC_reclaim_block on the entire heap, after first clearing * small object free lists (if we are not just looking for leaks). */

Return TRUE if an thread was attached since we last asked or */ since GC_attached_thread was explicitly reset. */

Steal mark stack entries starting at mse low into mark stack local */ until we either steal mse high, or we have max entries. */ Return a pointer to

Store back pointer to source in dest, if that appears to be possible. */ This is not completely safe, since we may mistakenly conclude that */ dest

Suspend the given thread, if it's still active. */

We hold the allocation lock. Suspend all threads that might */ still be running. Return the number of suspend signals that */ were sent. */

returns true if there's a thread in act_list that wasn't in old_list */

Find the text(code) mapping for the library whose name starts with nm. */

We hold the allocation lock. */