boehm-gc/include/gc_mark.h - gcc - Git at Google

 /*
  * 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.
  *
  * Note that this file is not "namespace-clean", i.e. it introduces names
  * not prefixed with GC_, which may collide with the client's names.  It
  * should be included only in those few places that directly provide
  * information to the collector.
  */
 #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 colllector version.)	*/
 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)

 #endif  /* 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.
	*
	* Note that this file is not "namespace-clean", i.e. it introduces names
	* not prefixed with GC_, which may collide with the client's names. It
	* should be included only in those few places that directly provide
	* information to the collector.
	*/
	#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 colllector version.) */
	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)

	#endif /* GC_MARK_H */