Fill buf with len characters starting at i. */ Assumes len characters are available. */

A version of CORD_substr that assumes i >= 0, n > 0, and i + n < length(x).*/

A version of CORD_substr that simply returns a function node, thus */ postponing its work. The fourth argument is a function that may */ be used for e

Add a multiword bitmap to GC_ext_descriptors arrays. Return */ starting index. */ Returns -1 on failure. */ Caller does not hold allocation

Add a heap block map for objects of size granules to obj_map. */ Return FALSE on failure. */ A size of 0 granules is used for large objects. */

Return the number of bytes allocated, adjusted for explicit storage */ management, etc.. This number is used in deciding when to trigger */ collectio

Allocate reclaim list for kind: */ Return TRUE on success */

* The same, but with search restricted to nth free list. * Flags is IGNORE_OFF_PAGE or zero. * Unlike the above, sz is in bytes. */

* Make sure the object free list for size gran (in granules) is not empty. * Return a pointer to the first object on the free list. * The object MUS

Test whether any page in the given block is dirty */

Rebuild the representation of the backward reachability graph. */ Does not examine mark bits. Can be called before GC. */

The same for size 2 uncleared objects */

The same for size 4 uncleared objects */

* Build a free list for size 2 (words) cleared objects inside hblk h. * Set the last link to * be ofl. Return a pointer tpo the first free list ent

The same for size 4 cleared objects */

Should be called immediately after GC_read_dirty and GC_read_changed. */

Check that all mark bits for the free list whose first entry is q */ are set. */

Check that all thread-local free-lists are completely marked. */ also check that thread-specific-data structures are marked. */

Clear up a few frames worth of garbage left at the top of the stack. */ This is used to prevent us from accidentally treating garbade left */ on the s

* Clear all obj_link pointers in the list of free objects *flp. * Clear *flp. * This must be done before dropping a list of free gcj-style objects,

Clear all mark bits for the free list whose first entry is q */ Decrement GC_bytes_found by number of bytes on free list. */

Clear some of the inaccessible part of the stack. Returns its */ argument, so it can be used in a tail call position, hence clearing */ another fram

Clear the stack up to about limit. Return arg. */ ARGSUSED*/

* Sweep blocks of the indicated object size and kind until either the * appropriate free list is nonempty, or there are no more blocks to * sweep.

Delete a thread from GC_threads. We assume it is there. */ (The code intentionally traps if it wasn't.) */

Return the size of the object described by d. It would be faster to */ store this directly, or to compute it as part of */ GC_push_complex_descript

Mark from the local mark stack. */ On return, the local mark stack is empty. */ But this may be achieved by copying the */ local mark stack back into

Perform Parallel mark. */ We hold the GC lock, not the mark lock. */ Currently runs until the mark stack is */ empty. */

Return a descriptor for the concatenation of 2 nwords long objects, */ each of which is described by descriptor. */ The result is known to be short

ARGSUSED*/

Enqueue all remaining finalizers to be run - Assumes lock is * held, and signals are disabled */

Fill in additional entries in GC_size_map, including the ith one */ We assume the ith entry is currently 0. */ Note that a filled in section of the

Called with world stopped. Cause disappearing links to disappear, */ and invoke finalizers. */

Generate a random heap address. */ The resulting address is in the heap, but */ not necessarily inside a valid object. */

Generate a random address inside a valid marked heap object. */

Allocate a composite object of size n bytes. The caller guarantees */ that pointers past the first page are not relevant. Caller holds */ alloca

Store information about the object referencing dest in *base_p */ and *offset_p. */ source is root ==> *base_p = address, *offset_p = 0 */ sour

Determine the length of a file by incrementally reading it into a */ This would be sily to use on a file supporting lseek, but Linux */ /proc files u

* Return a pointer to a block starting at h of length bytes. * Memory for the block is mapped. * Remove the block from its free list, and return the

This is always called from the main thread. */

Return the number of processors, or i<= 0 if it can't be determined. */

Return the number of bytes that are writable starting at p. */ The pointer p is assumed to be page aligned. */ If base is not 0, *base becomes the b

Find the largest stack_base smaller than bound. May be used */ to find the boundary between a register stack and adjacent */ immediately preceding me

Try to help out the marker, if it's running. */ We do not hold the GC lock, but the requestor does. */

Increment GC_bytes_allocd from code that doesn't have direct access */ to GC_arrays. */

Caller does not hold allocation lock. */

Caller does not hold allocation lock. */