gcc/boehm-gc/include/gc_mark.h

/*
 * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
 * Copyright (c) 2001 by Hewlett-Packard Company. All rights reserved.
 *
 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
 * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
 *
 * Permission is hereby granted to use or copy this program
 * for any purpose,  provided the above notices are retained on all copies.
 * Permission to modify the code and to distribute modified code is granted,
 * provided the above notices are retained, and a notice that the code was
 * modified is included with the above copyright notice.
 *
 */

/*
 * This contains interfaces to the GC marker that are likely to be useful to
 * clients that provide detailed heap layout information to the collector.
 * This interface should not be used by normal C or C++ clients.
 * It will be useful to runtimes for other languages.
 * 
 * This is an experts-only interface!  There are many ways to break the
 * collector in subtle ways by using this functionality.
 */
#ifndef GC_MARK_H
# define GC_MARK_H

# ifndef GC_H
#   include "gc.h"
# endif

/* A client supplied mark procedure.  Returns new mark stack pointer.	*/
/* Primary effect should be to push new entries on the mark stack.	*/
/* Mark stack pointer values are passed and returned explicitly.	*/
/* Global variables decribing mark stack are not necessarily valid.	*/
/* (This usually saves a few cycles by keeping things in registers.)	*/
/* Assumed to scan about GC_PROC_BYTES on average.  If it needs to do	*/
/* much more work than that, it should do it in smaller pieces by	*/
/* pushing itself back on the mark stack.				*/
/* Note that it should always do some work (defined as marking some	*/
/* objects) before pushing more than one entry on the mark stack.	*/
/* This is required to ensure termination in the event of mark stack	*/
/* overflows.								*/
/* This procedure is always called with at least one empty entry on the */
/* mark stack.								*/
/* Currently we require that mark procedures look for pointers in a	*/
/* subset of the places the conservative marker would.  It must be safe	*/
/* to invoke the normal mark procedure instead.				*/
/* WARNING: Such a mark procedure may be invoked on an unused object    */
/* residing on a free list.  Such objects are cleared, except for a	*/
/* free list link field in the first word.  Thus mark procedures may	*/
/* not count on the presence of a type descriptor, and must handle this	*/
/* case correctly somehow.						*/
# define GC_PROC_BYTES 100
struct GC_ms_entry;
typedef struct GC_ms_entry * (*GC_mark_proc) GC_PROTO((
		GC_word * addr, struct GC_ms_entry * mark_stack_ptr,
		struct GC_ms_entry * mark_stack_limit, GC_word env));

# define GC_LOG_MAX_MARK_PROCS 6
# define GC_MAX_MARK_PROCS (1 << GC_LOG_MAX_MARK_PROCS)

/* In a few cases it's necessary to assign statically known indices to	*/
/* certain mark procs.  Thus we reserve a few for well known clients.	*/
/* (This is necessary if mark descriptors are compiler generated.)	*/
#define GC_RESERVED_MARK_PROCS 8
#   define GC_GCJ_RESERVED_MARK_PROC_INDEX 0

/* Object descriptors on mark stack or in objects.  Low order two	*/
/* bits are tags distinguishing among the following 4 possibilities	*/
/* for the high order 30 bits.						*/
#define GC_DS_TAG_BITS 2
#define GC_DS_TAGS   ((1 << GC_DS_TAG_BITS) - 1)
#define GC_DS_LENGTH 0	/* The entire word is a length in bytes that	*/
			/* must be a multiple of 4.			*/
#define GC_DS_BITMAP 1	/* 30 (62) bits are a bitmap describing pointer	*/
			/* fields.  The msb is 1 iff the first word	*/
			/* is a pointer.				*/
			/* (This unconventional ordering sometimes	*/
			/* makes the marker slightly faster.)		*/
			/* Zeroes indicate definite nonpointers.  Ones	*/
			/* indicate possible pointers.			*/
			/* Only usable if pointers are word aligned.	*/
#define GC_DS_PROC   2
			/* The objects referenced by this object can be */
			/* pushed on the mark stack by invoking		*/
			/* PROC(descr).  ENV(descr) is passed as the	*/
			/* last argument.				*/
#   define GC_MAKE_PROC(proc_index, env) \
	    (((((env) << GC_LOG_MAX_MARK_PROCS) \
	       | (proc_index)) << GC_DS_TAG_BITS) | GC_DS_PROC)
#define GC_DS_PER_OBJECT 3  /* The real descriptor is at the		*/
			/* byte displacement from the beginning of the	*/
			/* object given by descr & ~DS_TAGS		*/
			/* If the descriptor is negative, the real	*/
			/* descriptor is at (*<object_start>) -		*/
			/* (descr & ~DS_TAGS) - GC_INDIR_PER_OBJ_BIAS	*/
			/* The latter alternative can be used if each	*/
			/* object contains a type descriptor in the	*/
			/* first word.					*/
			/* Note that in multithreaded environments	*/
			/* per object descriptors maust be located in	*/
			/* either the first two or last two words of	*/
			/* the object, since only those are guaranteed	*/
			/* to be cleared while the allocation lock is	*/
			/* held.					*/
#define GC_INDIR_PER_OBJ_BIAS 0x10
			
extern GC_PTR GC_least_plausible_heap_addr;
extern GC_PTR GC_greatest_plausible_heap_addr;
			/* Bounds on the heap.  Guaranteed valid	*/
			/* Likely to include future heap expansion.	*/

/* Handle nested references in a custom mark procedure.			*/
/* Check if obj is a valid object. If so, ensure that it is marked.	*/
/* If it was not previously marked, push its contents onto the mark 	*/
/* stack for future scanning.  The object will then be scanned using	*/
/* its mark descriptor.  						*/
/* Returns the new mark stack pointer.					*/
/* Handles mark stack overflows correctly.				*/
/* Since this marks first, it makes progress even if there are mark	*/
/* stack overflows.							*/
/* Src is the address of the pointer to obj, which is used only		*/
/* for back pointer-based heap debugging.				*/
/* It is strongly recommended that most objects be handled without mark	*/
/* procedures, e.g. with bitmap descriptors, and that mark procedures	*/
/* be reserved for exceptional cases.  That will ensure that 		*/
/* performance of this call is not extremely performance critical.	*/
/* (Otherwise we would need to inline GC_mark_and_push completely,	*/
/* which would tie the client code to a fixed collector version.)	*/
/* Note that mark procedures should explicitly call FIXUP_POINTER()	*/
/* if required.								*/
struct GC_ms_entry *GC_mark_and_push
		GC_PROTO((GC_PTR obj,
			  struct GC_ms_entry * mark_stack_ptr,
		          struct GC_ms_entry * mark_stack_limit, GC_PTR *src));

#define GC_MARK_AND_PUSH(obj, msp, lim, src) \
	(((GC_word)obj >= (GC_word)GC_least_plausible_heap_addr && \
	  (GC_word)obj <= (GC_word)GC_greatest_plausible_heap_addr)? \
	  GC_mark_and_push(obj, msp, lim, src) : \
	  msp)

extern size_t GC_debug_header_size;
       /* The size of the header added to objects allocated through    */
       /* the GC_debug routines.                                       */
       /* Defined as a variable so that client mark procedures don't   */
       /* need to be recompiled for collector version changes.         */
#define GC_USR_PTR_FROM_BASE(p) ((GC_PTR)((char *)(p) + GC_debug_header_size))

/* And some routines to support creation of new "kinds", e.g. with	*/
/* custom mark procedures, by language runtimes.			*/
/* The _inner versions assume the caller holds the allocation lock.	*/

/* Return a new free list array.	*/
void ** GC_new_free_list GC_PROTO((void));
void ** GC_new_free_list_inner GC_PROTO((void));

/* Return a new kind, as specified. */
int GC_new_kind GC_PROTO((void **free_list, GC_word mark_descriptor_template,
		          int add_size_to_descriptor, int clear_new_objects));
		/* The last two parameters must be zero or one. */
int GC_new_kind_inner GC_PROTO((void **free_list,
				GC_word mark_descriptor_template,
		                int add_size_to_descriptor,
				int clear_new_objects));

/* Return a new mark procedure identifier, suitable for use as	*/
/* the first argument in GC_MAKE_PROC.				*/
int GC_new_proc GC_PROTO((GC_mark_proc));
int GC_new_proc_inner GC_PROTO((GC_mark_proc));

/* Allocate an object of a given kind.  Note that in multithreaded	*/
/* contexts, this is usually unsafe for kinds that have the descriptor	*/
/* in the object itself, since there is otherwise a window in which	*/
/* the descriptor is not correct.  Even in the single-threaded case,	*/
/* we need to be sure that cleared objects on a free list don't		*/
/* cause a GC crash if they are accidentally traced.			*/
/* ptr_t */char * GC_generic_malloc GC_PROTO((GC_word lb, int k));

/* FIXME - Should return void *, but that requires other changes.	*/

typedef void (*GC_describe_type_fn) GC_PROTO((void *p, char *out_buf));
				/* A procedure which			*/
				/* produces a human-readable 		*/
				/* description of the "type" of object	*/
				/* p into the buffer out_buf of length	*/
				/* GC_TYPE_DESCR_LEN.  This is used by	*/
				/* the debug support when printing 	*/
				/* objects.				*/ 
				/* These functions should be as robust	*/
				/* as possible, though we do avoid 	*/
				/* invoking them on objects on the 	*/
				/* global free list.			*/
#	define GC_TYPE_DESCR_LEN 40

void GC_register_describe_type_fn GC_PROTO((int kind, GC_describe_type_fn knd));
				/* Register a describe_type function	*/
				/* to be used when printing objects	*/
				/* of a particular kind.		*/

#endif  /* GC_MARK_H */