[bpt/guile.git] / libguile / gc.h

/* classes: h_files */

#ifndef SCM_GC_H
#define SCM_GC_H

/* Copyright (C) 1995,1996,1998,1999,2000,2001 Free Software Foundation, Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this software; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307 USA
 *
 * As a special exception, the Free Software Foundation gives permission
 * for additional uses of the text contained in its release of GUILE.
 *
 * The exception is that, if you link the GUILE library with other files
 * to produce an executable, this does not by itself cause the
 * resulting executable to be covered by the GNU General Public License.
 * Your use of that executable is in no way restricted on account of
 * linking the GUILE library code into it.
 *
 * This exception does not however invalidate any other reasons why
 * the executable file might be covered by the GNU General Public License.
 *
 * This exception applies only to the code released by the
 * Free Software Foundation under the name GUILE.  If you copy
 * code from other Free Software Foundation releases into a copy of
 * GUILE, as the General Public License permits, the exception does
 * not apply to the code that you add in this way.  To avoid misleading
 * anyone as to the status of such modified files, you must delete
 * this exception notice from them.
 *
 * If you write modifications of your own for GUILE, it is your choice
 * whether to permit this exception to apply to your modifications.
 * If you do not wish that, delete this exception notice.  */

\f

#include "libguile/__scm.h"

#include "libguile/hooks.h"

\f

typedef struct scm_t_cell
{
  scm_t_bits word_0;
  scm_t_bits word_1;
} scm_t_cell;

/*
  CARDS

  A card is a small `page' of memory; it will be the unit for lazy
  sweeping, generations, etc. The first cell of a card contains a
  pointer to the mark bitvector, so that we can find the bitvector efficiently: we
  knock off some lowerorder bits.

  The size on a 32 bit machine is 256 cells = 2kb. The card 
*/


/* Cray machines have pointers that are incremented once for each word,
 * rather than each byte, the 3 most significant bits encode the byte
 * within the word.  The following macros deal with this by storing the
 * native Cray pointers like the ones that looks like scm expects.  This
 * is done for any pointers that might appear in the car of a scm_t_cell,
 * pointers to scm_vector elts, functions, &c are not munged.
 */
#ifdef _UNICOS
#  define SCM2PTR(x) ((scm_t_cell *) (SCM_UNPACK (x) >> 3))
#  define PTR2SCM(x) (SCM_PACK (((scm_t_bits) (x)) << 3))
#else
#  define SCM2PTR(x) ((scm_t_cell *) (SCM_UNPACK (x)))
#  define PTR2SCM(x) (SCM_PACK ((scm_t_bits) (x)))
#endif /* def _UNICOS */


#define SCM_GC_CARD_N_HEADER_CELLS 1
#define SCM_GC_CARD_N_CELLS        256
#define SCM_GC_SIZEOF_CARD 		SCM_GC_CARD_N_CELLS * sizeof (scm_t_cell)

#define SCM_GC_CARD_BVEC(card)  ((scm_t_c_bvec_long *) ((card)->word_0))
#define SCM_GC_SET_CARD_BVEC(card, bvec) \
    ((card)->word_0 = (scm_t_bits) (bvec))


#define SCM_GC_GET_CARD_FLAGS(card) ((long) ((card)->word_1))
#define SCM_GC_SET_CARD_FLAGS(card, flags) \
    ((card)->word_1 = (scm_t_bits) (flags))
#define SCM_GC_CLEAR_CARD_FLAGS(card) (SCM_GC_SET_CARD_FLAGS (card, 0L))

#define SCM_GC_GET_CARD_FLAG(card, shift) (SCM_GC_GET_CARD_FLAGS (card) & (1L << (shift)))
#define SCM_GC_SET_CARD_FLAG(card, shift) \
    (SCM_GC_SET_CARD_FLAGS (card, SCM_GC_GET_CARD_FLAGS(card) | (1L << (shift))))
#define SCM_GC_CLEAR_CARD_FLAG(card, shift) \
    (SCM_GC_SET_CARD_FLAGS (card, SCM_GC_GET_CARD_FLAGS(card) & ~(1L << (shift))))

#define SCM_GC_CARDF_DOUBLECELL 0

#define SCM_GC_CARD_DOUBLECELLP(card)    SCM_GC_GET_CARD_FLAG (card, SCM_GC_CARDF_DOUBLECELL)
#define SCM_GC_SET_CARD_DOUBLECELL(card) SCM_GC_SET_CARD_FLAG (card, SCM_GC_CARDF_DOUBLECELL)

/* card addressing. for efficiency, cards are *always* aligned to
   SCM_GC_CARD_SIZE. */

#define SCM_GC_CARD_SIZE_MASK  (SCM_GC_CARD_N_CELLS * sizeof (scm_t_cell) - 1)
#define SCM_GC_CARD_ADDR_MASK  (~SCM_GC_CARD_SIZE_MASK)

#define SCM_GC_CELL_CARD(x)    ((scm_t_cell *) ((long) (x) & SCM_GC_CARD_ADDR_MASK))
#define SCM_GC_CELL_OFFSET(x)  (((long) (x) & SCM_GC_CARD_SIZE_MASK) >> SCM_CELL_SIZE_SHIFT)
#define SCM_GC_CELL_BVEC(x)    SCM_GC_CARD_BVEC (SCM_GC_CELL_CARD (x))
#define SCM_GC_CELL_GET_BIT(x) SCM_C_BVEC_GET (SCM_GC_CELL_BVEC (x), SCM_GC_CELL_OFFSET (x))
#define SCM_GC_CELL_SET_BIT(x) SCM_C_BVEC_SET (SCM_GC_CELL_BVEC (x), SCM_GC_CELL_OFFSET (x))
#define SCM_GC_CELL_CLEAR_BIT(x) SCM_C_BVEC_CLEAR (SCM_GC_CELL_BVEC (x), SCM_GC_CELL_OFFSET (x))

#define SCM_GC_CARD_UP(x)      SCM_GC_CELL_CARD ((char *) (x) + SCM_GC_SIZEOF_CARD - 1)
#define SCM_GC_CARD_DOWN       SCM_GC_CELL_CARD

/* low level bit banging aids */
typedef unsigned long scm_t_c_bvec_long;

#if (SIZEOF_LONG == 8)
#       define SCM_C_BVEC_LONG_BITS    64
#       define SCM_C_BVEC_OFFSET_SHIFT 6
#       define SCM_C_BVEC_POS_MASK     63
#       define SCM_CELL_SIZE_SHIFT     4
#	define SCM_SIZEOF_LONG SIZEOF_LONG
#else
#       define SCM_C_BVEC_LONG_BITS    32
#	define SCM_SIZEOF_LONG SIZEOF_LONG
#       define SCM_C_BVEC_OFFSET_SHIFT 5
#       define SCM_C_BVEC_POS_MASK     31
#       define SCM_CELL_SIZE_SHIFT     3
#endif

#define SCM_C_BVEC_OFFSET(pos) (pos >> SCM_C_BVEC_OFFSET_SHIFT)

#define SCM_C_BVEC_GET(bvec, pos) (bvec[SCM_C_BVEC_OFFSET (pos)] & (1L << (pos & SCM_C_BVEC_POS_MASK)))
#define SCM_C_BVEC_SET(bvec, pos) (bvec[SCM_C_BVEC_OFFSET (pos)] |= (1L << (pos & SCM_C_BVEC_POS_MASK)))
#define SCM_C_BVEC_CLEAR(bvec, pos) (bvec[SCM_C_BVEC_OFFSET (pos)] &= ~(1L << (pos & SCM_C_BVEC_POS_MASK)))

/* testing and changing GC marks */
#define SCM_GC_MARK_P(x)   SCM_GC_CELL_GET_BIT (x)
#define SCM_SET_GC_MARK(x) SCM_GC_CELL_SET_BIT (x)
#define SCM_CLEAR_GC_MARK(x) SCM_GC_CELL_CLEAR_BIT (x)

/* Low level cell data accessing macros.  These macros should only be used
 * from within code related to garbage collection issues, since they will
 * never check the cells they are applied to - not even if guile is compiled
 * in debug mode.  In particular these macros will even work for free cells,
 * which should never be encountered by user code.  */

#define SCM_GC_CELL_WORD(x, n) \
  (((const scm_t_bits *) SCM2PTR (x)) [n])
#define SCM_GC_CELL_OBJECT(x, n) \
  (SCM_PACK (((const scm_t_bits *) SCM2PTR (x)) [n]))
#define SCM_GC_SET_CELL_WORD(x, n, v) \
  (((scm_t_bits *) SCM2PTR (x)) [n] = (scm_t_bits) (v))
#define SCM_GC_SET_CELL_OBJECT(x, n, v) \
 (((scm_t_bits *) SCM2PTR (x)) [n] = SCM_UNPACK (v))
#define SCM_GC_CELL_TYPE(x) SCM_GC_CELL_WORD (x, 0)


/* Except for the garbage collector, no part of guile should ever run over a
 * free cell.  Thus, if guile is compiled in debug mode the SCM_CELL_* and
 * SCM_SET_CELL_* macros below report an error if they are applied to a free
 * cell.  Some other plausibility checks are also performed.  However, if
 * guile is not compiled in debug mode, there won't be any time penalty at all
 * when using these macros.  */

#if (SCM_DEBUG_CELL_ACCESSES == 1)
#  define SCM_VALIDATE_CELL(cell, expr) (scm_assert_cell_valid (cell), (expr))
#else
#  define SCM_VALIDATE_CELL(cell, expr) (expr)
#endif

#define SCM_CELL_WORD(x, n) \
  SCM_VALIDATE_CELL ((x), SCM_GC_CELL_WORD ((x), (n)))
#define SCM_CELL_WORD_0(x) SCM_CELL_WORD (x, 0)
#define SCM_CELL_WORD_1(x) SCM_CELL_WORD (x, 1)
#define SCM_CELL_WORD_2(x) SCM_CELL_WORD (x, 2)
#define SCM_CELL_WORD_3(x) SCM_CELL_WORD (x, 3)

#define SCM_CELL_OBJECT(x, n) \
  SCM_VALIDATE_CELL ((x), SCM_GC_CELL_OBJECT ((x), (n)))
#define SCM_CELL_OBJECT_0(x) SCM_CELL_OBJECT (x, 0)
#define SCM_CELL_OBJECT_1(x) SCM_CELL_OBJECT (x, 1)
#define SCM_CELL_OBJECT_2(x) SCM_CELL_OBJECT (x, 2)
#define SCM_CELL_OBJECT_3(x) SCM_CELL_OBJECT (x, 3)

#define SCM_SET_CELL_WORD(x, n, v) \
  SCM_VALIDATE_CELL ((x), SCM_GC_SET_CELL_WORD ((x), (n), (v)))
#define SCM_SET_CELL_WORD_0(x, v) SCM_SET_CELL_WORD (x, 0, v)
#define SCM_SET_CELL_WORD_1(x, v) SCM_SET_CELL_WORD (x, 1, v)
#define SCM_SET_CELL_WORD_2(x, v) SCM_SET_CELL_WORD (x, 2, v)
#define SCM_SET_CELL_WORD_3(x, v) SCM_SET_CELL_WORD (x, 3, v)

#define SCM_SET_CELL_OBJECT(x, n, v) \
  SCM_VALIDATE_CELL ((x), SCM_GC_SET_CELL_OBJECT ((x), (n), (v)))
#define SCM_SET_CELL_OBJECT_0(x, v) SCM_SET_CELL_OBJECT (x, 0, v)
#define SCM_SET_CELL_OBJECT_1(x, v) SCM_SET_CELL_OBJECT (x, 1, v)
#define SCM_SET_CELL_OBJECT_2(x, v) SCM_SET_CELL_OBJECT (x, 2, v)
#define SCM_SET_CELL_OBJECT_3(x, v) SCM_SET_CELL_OBJECT (x, 3, v)

#define SCM_CELL_TYPE(x) SCM_CELL_WORD_0 (x)
#define SCM_SET_CELL_TYPE(x, t) SCM_SET_CELL_WORD_0 (x, t)


/* Freelists consist of linked cells where the type entry holds the value
 * scm_tc_free_cell and the second entry holds a pointer to the next cell of
 * the freelist.  Due to this structure, freelist cells are not cons cells
 * and thus may not be accessed using SCM_CAR and SCM_CDR.  */

/*
  SCM_FREECELL_P removed ; the semantics are ambiguous with lazy
  sweeping. Could mean "this cell is no longer in use (will be swept)"
  or "this cell has just been swept, and is not yet in use".
 */

#define SCM_FREECELL_P  this_macro_has_been_removed_see_gc_header_file

#define SCM_FREE_CELL_CDR(x) \
  (SCM_GC_CELL_OBJECT ((x), 1))
#define SCM_SET_FREE_CELL_CDR(x, v) \
  (SCM_GC_SET_CELL_OBJECT ((x), 1, (v)))


#define SCM_CELL_WORD_LOC(x, n) ((scm_t_bits *) & SCM_CELL_WORD (x, n))
#define SCM_CARLOC(x) ((SCM *) SCM_CELL_WORD_LOC ((x), 0))
#define SCM_CDRLOC(x) ((SCM *) SCM_CELL_WORD_LOC ((x), 1))


#if (SCM_DEBUG_CELL_ACCESSES == 1)
SCM_API unsigned int scm_debug_cell_accesses_p;
#endif

SCM_API int scm_block_gc;
SCM_API int scm_gc_heap_lock;
SCM_API unsigned int scm_gc_running_p;
\f

#if (SCM_ENABLE_DEPRECATED == 1)
SCM_API size_t scm_default_init_heap_size_1;
SCM_API int scm_default_min_yield_1;
SCM_API size_t scm_default_init_heap_size_2;
SCM_API int scm_default_min_yield_2;
SCM_API size_t scm_default_max_segment_size;
#else
#define  scm_default_init_heap_size_1 deprecated
#define  scm_default_min_yield_1 deprecated
#define  scm_default_init_heap_size_2 deprecated
#define  scm_default_min_yield_2 deprecated
#define  scm_default_max_segment_size deprecated
#endif


SCM_API size_t scm_max_segment_size;

/*
  Deprecated scm_freelist, scm_master_freelist.
  No warning; this is not a user serviceable part.
 */
SCM_API SCM scm_i_freelist;
SCM_API struct scm_t_cell_type_statistics scm_i_master_freelist;
SCM_API SCM scm_i_freelist2;
SCM_API struct scm_t_cell_type_statistics scm_i_master_freelist2;

SCM_API unsigned long scm_gc_cells_swept;
SCM_API unsigned long scm_gc_cells_collected;
SCM_API unsigned long scm_gc_cells_collected;
SCM_API unsigned long scm_gc_malloc_collected;
SCM_API unsigned long scm_gc_ports_collected;
SCM_API unsigned long scm_cells_allocated;
SCM_API unsigned long scm_mallocated;
SCM_API unsigned long scm_mtrigger;


SCM_API SCM scm_after_gc_hook;

SCM_API scm_t_c_hook scm_before_gc_c_hook;
SCM_API scm_t_c_hook scm_before_mark_c_hook;
SCM_API scm_t_c_hook scm_before_sweep_c_hook;
SCM_API scm_t_c_hook scm_after_sweep_c_hook;
SCM_API scm_t_c_hook scm_after_gc_c_hook;

#if defined (GUILE_DEBUG) || defined (GUILE_DEBUG_FREELIST)
#define scm_map_free_list deprecated
#define scm_free_list_length deprecated
#endif

#if (SCM_ENABLE_DEPRECATED == 1) && defined (GUILE_DEBUG_FREELIST)
SCM_API SCM scm_gc_set_debug_check_freelist_x (SCM flag);
#endif
\f

#if (SCM_DEBUG_CELL_ACCESSES == 1)
SCM_API void scm_assert_cell_valid (SCM);
#endif

SCM_API SCM scm_set_debug_cell_accesses_x (SCM flag);


SCM_API SCM scm_object_address (SCM obj);
SCM_API SCM scm_gc_stats (void);
SCM_API SCM scm_gc (void);
SCM_API void scm_gc_for_alloc (struct scm_t_cell_type_statistics *freelist);
SCM_API SCM scm_gc_for_newcell (struct scm_t_cell_type_statistics *master, SCM *freelist);
SCM_API void scm_igc (const char *what);
SCM_API void scm_gc_mark (SCM p);
SCM_API void scm_gc_mark_dependencies (SCM p);
SCM_API void scm_mark_locations (SCM_STACKITEM x[], unsigned long n);
SCM_API int scm_in_heap_p (SCM value);
SCM_API void scm_gc_sweep (void);

SCM_API void *scm_malloc (size_t size);
SCM_API void *scm_realloc (void *mem, size_t size);
SCM_API char *scm_strdup (const char *str);
SCM_API char *scm_strndup (const char *str, size_t n);
SCM_API void scm_gc_register_collectable_memory (void *mem, size_t size,
						 const char *what);
SCM_API void scm_gc_unregister_collectable_memory (void *mem, size_t size,
						   const char *what);
SCM_API void *scm_gc_malloc (size_t size, const char *what);
SCM_API void *scm_gc_realloc (void *mem, size_t old_size, 
			      size_t new_size, const char *what);
SCM_API void scm_gc_free (void *mem, size_t size, const char *what);
SCM_API char *scm_gc_strdup (const char *str, const char *what);
SCM_API char *scm_gc_strndup (const char *str, size_t n, const char *what);

SCM_API void scm_remember_upto_here_1 (SCM obj);
SCM_API void scm_remember_upto_here_2 (SCM obj1, SCM obj2);
SCM_API void scm_remember_upto_here (SCM obj1, ...);
SCM_API SCM scm_return_first (SCM elt, ...);
SCM_API int scm_return_first_int (int x, ...);
SCM_API SCM scm_permanent_object (SCM obj);
SCM_API SCM scm_gc_protect_object (SCM obj);
SCM_API SCM scm_gc_unprotect_object (SCM obj);
SCM_API void scm_gc_register_root (SCM *p);
SCM_API void scm_gc_unregister_root (SCM *p);
SCM_API void scm_gc_register_roots (SCM *b, unsigned long n);
SCM_API void scm_gc_unregister_roots (SCM *b, unsigned long n);
SCM_API int scm_init_storage (void);
SCM_API void *scm_get_stack_base (void);
SCM_API void scm_init_gc (void);

#if SCM_ENABLE_DEPRECATED == 1

SCM_API SCM scm_deprecated_newcell (void);
SCM_API SCM scm_deprecated_newcell2 (void);

#define SCM_NEWCELL(_into) \
  do { _into = scm_deprecated_newcell (); } while (0)
#define SCM_NEWCELL2(_into) \
  do { _into = scm_deprecated_newcell2 (); } while (0)

SCM_API void * scm_must_malloc (size_t len, const char *what);
SCM_API void * scm_must_realloc (void *where,
				 size_t olen, size_t len,
				 const char *what);
SCM_API char *scm_must_strdup (const char *str);
SCM_API char *scm_must_strndup (const char *str, size_t n);
SCM_API void scm_done_malloc (long size);
SCM_API void scm_done_free (long size);
SCM_API void scm_must_free (void *obj);

#endif

#endif  /* SCM_GC_H */

/*
  Local Variables:
  c-file-style: "gnu"
  End:
*/
Commit	Line	Data
0f2d19dd JB	1	/* classes: h_files */
0f2d19dd JB	2
61045190 DH	3	#ifndef SCM_GC_H
61045190 DH	4	#define SCM_GC_H
8c494e99	5
61045190	6	/* Copyright (C) 1995,1996,1998,1999,2000,2001 Free Software Foundation, Inc.
a00c95d9	7	*
0f2d19dd JB	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2, or (at your option)
	11	* any later version.
a00c95d9	12	*
0f2d19dd JB	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
a00c95d9	17	*
0f2d19dd JB	18	* You should have received a copy of the GNU General Public License
0f2d19dd JB	19	* along with this software; see the file COPYING. If not, write to
82892bed JB	20	* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
82892bed JB	21	* Boston, MA 02111-1307 USA
0f2d19dd JB	22	*
	23	* As a special exception, the Free Software Foundation gives permission
	24	* for additional uses of the text contained in its release of GUILE.
	25	*
	26	* The exception is that, if you link the GUILE library with other files
	27	* to produce an executable, this does not by itself cause the
	28	* resulting executable to be covered by the GNU General Public License.
	29	* Your use of that executable is in no way restricted on account of
	30	* linking the GUILE library code into it.
	31	*
	32	* This exception does not however invalidate any other reasons why
	33	* the executable file might be covered by the GNU General Public License.
	34	*
	35	* This exception applies only to the code released by the
	36	* Free Software Foundation under the name GUILE. If you copy
	37	* code from other Free Software Foundation releases into a copy of
	38	* GUILE, as the General Public License permits, the exception does
	39	* not apply to the code that you add in this way. To avoid misleading
	40	* anyone as to the status of such modified files, you must delete
	41	* this exception notice from them.
	42	*
	43	* If you write modifications of your own for GUILE, it is your choice
	44	* whether to permit this exception to apply to your modifications.
82892bed	45	* If you do not wish that, delete this exception notice. */
d3a6bc94	46
0f2d19dd JB	47	\f
0f2d19dd JB	48
b4309c3c	49	#include "libguile/__scm.h"
2549a709	50
9b3e180c MD	51	#include "libguile/hooks.h"
9b3e180c MD	52
0f2d19dd JB	53	\f
0f2d19dd JB	54
228a24ef	55	typedef struct scm_t_cell
2549a709	56	{
92c2555f MV	57	scm_t_bits word_0;
92c2555f MV	58	scm_t_bits word_1;
228a24ef	59	} scm_t_cell;
2549a709	60
c8a1bdc4 HWN	61	/*
	62	CARDS
	63
	64	A card is a small `page' of memory; it will be the unit for lazy
	65	sweeping, generations, etc. The first cell of a card contains a
	66	pointer to the mark bitvector, so that we can find the bitvector efficiently: we
	67	knock off some lowerorder bits.
	68
	69	The size on a 32 bit machine is 256 cells = 2kb. The card
	70	*/
2549a709	71
2549a709 DH	72
	73
	74	/* Cray machines have pointers that are incremented once for each word,
	75	* rather than each byte, the 3 most significant bits encode the byte
	76	* within the word. The following macros deal with this by storing the
	77	* native Cray pointers like the ones that looks like scm expects. This
228a24ef	78	* is done for any pointers that might appear in the car of a scm_t_cell,
e618c9a3	79	* pointers to scm_vector elts, functions, &c are not munged.
2549a709 DH	80	*/
2549a709 DH	81	#ifdef _UNICOS
c8a1bdc4	82	# define SCM2PTR(x) ((scm_t_cell *) (SCM_UNPACK (x) >> 3))
92c2555f	83	# define PTR2SCM(x) (SCM_PACK (((scm_t_bits) (x)) << 3))
2549a709	84	#else
c8a1bdc4	85	# define SCM2PTR(x) ((scm_t_cell *) (SCM_UNPACK (x)))
92c2555f	86	# define PTR2SCM(x) (SCM_PACK ((scm_t_bits) (x)))
2549a709 DH	87	#endif /* def _UNICOS */
2549a709 DH	88
c8a1bdc4	89
e618c9a3	90	#define SCM_GC_CARD_N_HEADER_CELLS 1
f91f77e6	91	#define SCM_GC_CARD_N_CELLS 256
c8a1bdc4	92	#define SCM_GC_SIZEOF_CARD SCM_GC_CARD_N_CELLS * sizeof (scm_t_cell)
e618c9a3	93
c8a1bdc4	94	#define SCM_GC_CARD_BVEC(card) ((scm_t_c_bvec_long *) ((card)->word_0))
34d19ef6 HWN	95	#define SCM_GC_SET_CARD_BVEC(card, bvec) \
34d19ef6 HWN	96	((card)->word_0 = (scm_t_bits) (bvec))
34d19ef6 HWN	97
34d19ef6 HWN	98
c014a02e	99	#define SCM_GC_GET_CARD_FLAGS(card) ((long) ((card)->word_1))
322ec19d	100	#define SCM_GC_SET_CARD_FLAGS(card, flags) \
92c2555f	101	((card)->word_1 = (scm_t_bits) (flags))
c8a1bdc4	102	#define SCM_GC_CLEAR_CARD_FLAGS(card) (SCM_GC_SET_CARD_FLAGS (card, 0L))
e618c9a3 ML	103
e618c9a3 ML	104	#define SCM_GC_GET_CARD_FLAG(card, shift) (SCM_GC_GET_CARD_FLAGS (card) & (1L << (shift)))
322ec19d ML	105	#define SCM_GC_SET_CARD_FLAG(card, shift) \
322ec19d ML	106	(SCM_GC_SET_CARD_FLAGS (card, SCM_GC_GET_CARD_FLAGS(card) \| (1L << (shift))))
c8a1bdc4	107	#define SCM_GC_CLEAR_CARD_FLAG(card, shift) \
322ec19d	108	(SCM_GC_SET_CARD_FLAGS (card, SCM_GC_GET_CARD_FLAGS(card) & ~(1L << (shift))))
e618c9a3 ML	109
	110	#define SCM_GC_CARDF_DOUBLECELL 0
	111
	112	#define SCM_GC_CARD_DOUBLECELLP(card) SCM_GC_GET_CARD_FLAG (card, SCM_GC_CARDF_DOUBLECELL)
	113	#define SCM_GC_SET_CARD_DOUBLECELL(card) SCM_GC_SET_CARD_FLAG (card, SCM_GC_CARDF_DOUBLECELL)
	114
	115	/* card addressing. for efficiency, cards are always aligned to
	116	SCM_GC_CARD_SIZE. */
	117
c8a1bdc4	118	#define SCM_GC_CARD_SIZE_MASK (SCM_GC_CARD_N_CELLS * sizeof (scm_t_cell) - 1)
e618c9a3 ML	119	#define SCM_GC_CARD_ADDR_MASK (~SCM_GC_CARD_SIZE_MASK)
e618c9a3 ML	120
c8a1bdc4	121	#define SCM_GC_CELL_CARD(x) ((scm_t_cell *) ((long) (x) & SCM_GC_CARD_ADDR_MASK))
c014a02e	122	#define SCM_GC_CELL_OFFSET(x) (((long) (x) & SCM_GC_CARD_SIZE_MASK) >> SCM_CELL_SIZE_SHIFT)
e618c9a3 ML	123	#define SCM_GC_CELL_BVEC(x) SCM_GC_CARD_BVEC (SCM_GC_CELL_CARD (x))
	124	#define SCM_GC_CELL_GET_BIT(x) SCM_C_BVEC_GET (SCM_GC_CELL_BVEC (x), SCM_GC_CELL_OFFSET (x))
	125	#define SCM_GC_CELL_SET_BIT(x) SCM_C_BVEC_SET (SCM_GC_CELL_BVEC (x), SCM_GC_CELL_OFFSET (x))
c8a1bdc4	126	#define SCM_GC_CELL_CLEAR_BIT(x) SCM_C_BVEC_CLEAR (SCM_GC_CELL_BVEC (x), SCM_GC_CELL_OFFSET (x))
e618c9a3	127
c8a1bdc4	128	#define SCM_GC_CARD_UP(x) SCM_GC_CELL_CARD ((char *) (x) + SCM_GC_SIZEOF_CARD - 1)
e618c9a3 ML	129	#define SCM_GC_CARD_DOWN SCM_GC_CELL_CARD
	130
	131	/* low level bit banging aids */
c8a1bdc4	132	typedef unsigned long scm_t_c_bvec_long;
e618c9a3 ML	133
e618c9a3 ML	134	#if (SIZEOF_LONG == 8)
c8a1bdc4	135	# define SCM_C_BVEC_LONG_BITS 64
e618c9a3 ML	136	# define SCM_C_BVEC_OFFSET_SHIFT 6
	137	# define SCM_C_BVEC_POS_MASK 63
	138	# define SCM_CELL_SIZE_SHIFT 4
c8a1bdc4	139	# define SCM_SIZEOF_LONG SIZEOF_LONG
e618c9a3	140	#else
c8a1bdc4 HWN	141	# define SCM_C_BVEC_LONG_BITS 32
c8a1bdc4 HWN	142	# define SCM_SIZEOF_LONG SIZEOF_LONG
e618c9a3 ML	143	# define SCM_C_BVEC_OFFSET_SHIFT 5
	144	# define SCM_C_BVEC_POS_MASK 31
	145	# define SCM_CELL_SIZE_SHIFT 3
	146	#endif
	147
	148	#define SCM_C_BVEC_OFFSET(pos) (pos >> SCM_C_BVEC_OFFSET_SHIFT)
	149
	150	#define SCM_C_BVEC_GET(bvec, pos) (bvec[SCM_C_BVEC_OFFSET (pos)] & (1L << (pos & SCM_C_BVEC_POS_MASK)))
	151	#define SCM_C_BVEC_SET(bvec, pos) (bvec[SCM_C_BVEC_OFFSET (pos)] \|= (1L << (pos & SCM_C_BVEC_POS_MASK)))
c8a1bdc4	152	#define SCM_C_BVEC_CLEAR(bvec, pos) (bvec[SCM_C_BVEC_OFFSET (pos)] &= ~(1L << (pos & SCM_C_BVEC_POS_MASK)))
e618c9a3 ML	153
e618c9a3 ML	154	/* testing and changing GC marks */
c8a1bdc4 HWN	155	#define SCM_GC_MARK_P(x) SCM_GC_CELL_GET_BIT (x)
	156	#define SCM_SET_GC_MARK(x) SCM_GC_CELL_SET_BIT (x)
	157	#define SCM_CLEAR_GC_MARK(x) SCM_GC_CELL_CLEAR_BIT (x)
1fc8902f DH	158
	159	/* Low level cell data accessing macros. These macros should only be used
	160	* from within code related to garbage collection issues, since they will
	161	* never check the cells they are applied to - not even if guile is compiled
	162	* in debug mode. In particular these macros will even work for free cells,
	163	* which should never be encountered by user code. */
	164
	165	#define SCM_GC_CELL_WORD(x, n) \
	166	(((const scm_t_bits *) SCM2PTR (x)) [n])
	167	#define SCM_GC_CELL_OBJECT(x, n) \
	168	(SCM_PACK (((const scm_t_bits *) SCM2PTR (x)) [n]))
	169	#define SCM_GC_SET_CELL_WORD(x, n, v) \
	170	(((scm_t_bits *) SCM2PTR (x)) [n] = (scm_t_bits) (v))
	171	#define SCM_GC_SET_CELL_OBJECT(x, n, v) \
c8a1bdc4	172	(((scm_t_bits *) SCM2PTR (x)) [n] = SCM_UNPACK (v))
1fc8902f DH	173	#define SCM_GC_CELL_TYPE(x) SCM_GC_CELL_WORD (x, 0)
	174
	175
	176	/* Except for the garbage collector, no part of guile should ever run over a
	177	* free cell. Thus, if guile is compiled in debug mode the SCM_CELL_* and
	178	* SCM_SET_CELL_* macros below report an error if they are applied to a free
	179	* cell. Some other plausibility checks are also performed. However, if
	180	* guile is not compiled in debug mode, there won't be any time penalty at all
	181	* when using these macros. */
2549a709	182
406c7d90 DH	183	#if (SCM_DEBUG_CELL_ACCESSES == 1)
406c7d90 DH	184	# define SCM_VALIDATE_CELL(cell, expr) (scm_assert_cell_valid (cell), (expr))
708cb87c	185	#else
61045190	186	# define SCM_VALIDATE_CELL(cell, expr) (expr)
708cb87c	187	#endif
46d53380	188
f706a58b	189	#define SCM_CELL_WORD(x, n) \
1fc8902f	190	SCM_VALIDATE_CELL ((x), SCM_GC_CELL_WORD ((x), (n)))
2549a709 DH	191	#define SCM_CELL_WORD_0(x) SCM_CELL_WORD (x, 0)
	192	#define SCM_CELL_WORD_1(x) SCM_CELL_WORD (x, 1)
	193	#define SCM_CELL_WORD_2(x) SCM_CELL_WORD (x, 2)
	194	#define SCM_CELL_WORD_3(x) SCM_CELL_WORD (x, 3)
	195
f706a58b	196	#define SCM_CELL_OBJECT(x, n) \
1fc8902f	197	SCM_VALIDATE_CELL ((x), SCM_GC_CELL_OBJECT ((x), (n)))
2549a709 DH	198	#define SCM_CELL_OBJECT_0(x) SCM_CELL_OBJECT (x, 0)
	199	#define SCM_CELL_OBJECT_1(x) SCM_CELL_OBJECT (x, 1)
	200	#define SCM_CELL_OBJECT_2(x) SCM_CELL_OBJECT (x, 2)
	201	#define SCM_CELL_OBJECT_3(x) SCM_CELL_OBJECT (x, 3)
	202
f706a58b	203	#define SCM_SET_CELL_WORD(x, n, v) \
1fc8902f	204	SCM_VALIDATE_CELL ((x), SCM_GC_SET_CELL_WORD ((x), (n), (v)))
2549a709 DH	205	#define SCM_SET_CELL_WORD_0(x, v) SCM_SET_CELL_WORD (x, 0, v)
	206	#define SCM_SET_CELL_WORD_1(x, v) SCM_SET_CELL_WORD (x, 1, v)
	207	#define SCM_SET_CELL_WORD_2(x, v) SCM_SET_CELL_WORD (x, 2, v)
	208	#define SCM_SET_CELL_WORD_3(x, v) SCM_SET_CELL_WORD (x, 3, v)
	209
f706a58b	210	#define SCM_SET_CELL_OBJECT(x, n, v) \
1fc8902f	211	SCM_VALIDATE_CELL ((x), SCM_GC_SET_CELL_OBJECT ((x), (n), (v)))
2549a709 DH	212	#define SCM_SET_CELL_OBJECT_0(x, v) SCM_SET_CELL_OBJECT (x, 0, v)
	213	#define SCM_SET_CELL_OBJECT_1(x, v) SCM_SET_CELL_OBJECT (x, 1, v)
	214	#define SCM_SET_CELL_OBJECT_2(x, v) SCM_SET_CELL_OBJECT (x, 2, v)
	215	#define SCM_SET_CELL_OBJECT_3(x, v) SCM_SET_CELL_OBJECT (x, 3, v)
	216
	217	#define SCM_CELL_TYPE(x) SCM_CELL_WORD_0 (x)
	218	#define SCM_SET_CELL_TYPE(x, t) SCM_SET_CELL_WORD_0 (x, t)
	219
61045190	220
1fc8902f DH	221	/* Freelists consist of linked cells where the type entry holds the value
	222	* scm_tc_free_cell and the second entry holds a pointer to the next cell of
	223	* the freelist. Due to this structure, freelist cells are not cons cells
	224	* and thus may not be accessed using SCM_CAR and SCM_CDR. */
61045190	225
c8a1bdc4 HWN	226	/*
	227	SCM_FREECELL_P removed ; the semantics are ambiguous with lazy
	228	sweeping. Could mean "this cell is no longer in use (will be swept)"
	229	or "this cell has just been swept, and is not yet in use".
	230	*/
	231
	232	#define SCM_FREECELL_P this_macro_has_been_removed_see_gc_header_file
	233
1fc8902f DH	234	#define SCM_FREE_CELL_CDR(x) \
	235	(SCM_GC_CELL_OBJECT ((x), 1))
	236	#define SCM_SET_FREE_CELL_CDR(x, v) \
	237	(SCM_GC_SET_CELL_OBJECT ((x), 1, (v)))
61045190 DH	238
61045190 DH	239
92c2555f	240	#define SCM_CELL_WORD_LOC(x, n) ((scm_t_bits *) & SCM_CELL_WORD (x, n))
f706a58b DH	241	#define SCM_CARLOC(x) ((SCM *) SCM_CELL_WORD_LOC ((x), 0))
f706a58b DH	242	#define SCM_CDRLOC(x) ((SCM *) SCM_CELL_WORD_LOC ((x), 1))
2549a709 DH	243
2549a709 DH	244
2549a709	245
79e3f9e2	246
61045190	247	#if (SCM_DEBUG_CELL_ACCESSES == 1)
33b001fd	248	SCM_API unsigned int scm_debug_cell_accesses_p;
61045190 DH	249	#endif
61045190 DH	250
33b001fd MV	251	SCM_API int scm_block_gc;
	252	SCM_API int scm_gc_heap_lock;
	253	SCM_API unsigned int scm_gc_running_p;
0f2d19dd JB	254	\f
0f2d19dd JB	255
c8a1bdc4	256	#if (SCM_ENABLE_DEPRECATED == 1)
33b001fd MV	257	SCM_API size_t scm_default_init_heap_size_1;
	258	SCM_API int scm_default_min_yield_1;
	259	SCM_API size_t scm_default_init_heap_size_2;
	260	SCM_API int scm_default_min_yield_2;
	261	SCM_API size_t scm_default_max_segment_size;
c8a1bdc4 HWN	262	#else
	263	#define scm_default_init_heap_size_1 deprecated
	264	#define scm_default_min_yield_1 deprecated
	265	#define scm_default_init_heap_size_2 deprecated
	266	#define scm_default_min_yield_2 deprecated
	267	#define scm_default_max_segment_size deprecated
	268	#endif
	269
33b001fd MV	270
33b001fd MV	271	SCM_API size_t scm_max_segment_size;
c8a1bdc4 HWN	272
	273	/*
	274	Deprecated scm_freelist, scm_master_freelist.
	275	No warning; this is not a user serviceable part.
	276	*/
	277	SCM_API SCM scm_i_freelist;
	278	SCM_API struct scm_t_cell_type_statistics scm_i_master_freelist;
	279	SCM_API SCM scm_i_freelist2;
	280	SCM_API struct scm_t_cell_type_statistics scm_i_master_freelist2;
	281
	282	SCM_API unsigned long scm_gc_cells_swept;
	283	SCM_API unsigned long scm_gc_cells_collected;
33b001fd	284	SCM_API unsigned long scm_gc_cells_collected;
33b001fd MV	285	SCM_API unsigned long scm_gc_malloc_collected;
	286	SCM_API unsigned long scm_gc_ports_collected;
	287	SCM_API unsigned long scm_cells_allocated;
	288	SCM_API unsigned long scm_mallocated;
	289	SCM_API unsigned long scm_mtrigger;
	290
c8a1bdc4 HWN	291
c8a1bdc4 HWN	292
33b001fd MV	293	SCM_API SCM scm_after_gc_hook;
	294
	295	SCM_API scm_t_c_hook scm_before_gc_c_hook;
	296	SCM_API scm_t_c_hook scm_before_mark_c_hook;
	297	SCM_API scm_t_c_hook scm_before_sweep_c_hook;
	298	SCM_API scm_t_c_hook scm_after_sweep_c_hook;
	299	SCM_API scm_t_c_hook scm_after_gc_c_hook;
9b3e180c	300
bb2c57fa	301	#if defined (GUILE_DEBUG) \|\| defined (GUILE_DEBUG_FREELIST)
c8a1bdc4 HWN	302	#define scm_map_free_list deprecated
c8a1bdc4 HWN	303	#define scm_free_list_length deprecated
bb2c57fa	304	#endif
c8a1bdc4 HWN	305
c8a1bdc4 HWN	306	#if (SCM_ENABLE_DEPRECATED == 1) && defined (GUILE_DEBUG_FREELIST)
33b001fd	307	SCM_API SCM scm_gc_set_debug_check_freelist_x (SCM flag);
88256b2e	308	#endif
0f2d19dd	309	\f
0f2d19dd	310
61045190	311	#if (SCM_DEBUG_CELL_ACCESSES == 1)
33b001fd	312	SCM_API void scm_assert_cell_valid (SCM);
61045190	313	#endif
c8a1bdc4 HWN	314
	315	SCM_API SCM scm_set_debug_cell_accesses_x (SCM flag);
	316
	317
33b001fd	318	SCM_API SCM scm_object_address (SCM obj);
33b001fd MV	319	SCM_API SCM scm_gc_stats (void);
33b001fd MV	320	SCM_API SCM scm_gc (void);
c8a1bdc4 HWN	321	SCM_API void scm_gc_for_alloc (struct scm_t_cell_type_statistics *freelist);
c8a1bdc4 HWN	322	SCM_API SCM scm_gc_for_newcell (struct scm_t_cell_type_statistics master, SCM freelist);
33b001fd MV	323	SCM_API void scm_igc (const char *what);
	324	SCM_API void scm_gc_mark (SCM p);
	325	SCM_API void scm_gc_mark_dependencies (SCM p);
	326	SCM_API void scm_mark_locations (SCM_STACKITEM x[], unsigned long n);
c8a1bdc4	327	SCM_API int scm_in_heap_p (SCM value);
33b001fd	328	SCM_API void scm_gc_sweep (void);
4c9419ac MV	329
	330	SCM_API void *scm_malloc (size_t size);
	331	SCM_API void scm_realloc (void mem, size_t size);
	332	SCM_API char scm_strdup (const char str);
	333	SCM_API char scm_strndup (const char str, size_t n);
	334	SCM_API void scm_gc_register_collectable_memory (void *mem, size_t size,
	335	const char *what);
	336	SCM_API void scm_gc_unregister_collectable_memory (void *mem, size_t size,
	337	const char *what);
	338	SCM_API void scm_gc_malloc (size_t size, const char what);
	339	SCM_API void scm_gc_realloc (void mem, size_t old_size,
	340	size_t new_size, const char *what);
	341	SCM_API void scm_gc_free (void mem, size_t size, const char what);
	342	SCM_API char scm_gc_strdup (const char str, const char *what);
	343	SCM_API char scm_gc_strndup (const char str, size_t n, const char *what);
	344
33b001fd MV	345	SCM_API void scm_remember_upto_here_1 (SCM obj);
	346	SCM_API void scm_remember_upto_here_2 (SCM obj1, SCM obj2);
	347	SCM_API void scm_remember_upto_here (SCM obj1, ...);
	348	SCM_API SCM scm_return_first (SCM elt, ...);
	349	SCM_API int scm_return_first_int (int x, ...);
	350	SCM_API SCM scm_permanent_object (SCM obj);
	351	SCM_API SCM scm_gc_protect_object (SCM obj);
	352	SCM_API SCM scm_gc_unprotect_object (SCM obj);
	353	SCM_API void scm_gc_register_root (SCM *p);
	354	SCM_API void scm_gc_unregister_root (SCM *p);
	355	SCM_API void scm_gc_register_roots (SCM *b, unsigned long n);
	356	SCM_API void scm_gc_unregister_roots (SCM *b, unsigned long n);
	357	SCM_API int scm_init_storage (void);
	358	SCM_API void *scm_get_stack_base (void);
	359	SCM_API void scm_init_gc (void);
d1ca2c64	360
d678e25c MV	361	#if SCM_ENABLE_DEPRECATED == 1
	362
	363	SCM_API SCM scm_deprecated_newcell (void);
	364	SCM_API SCM scm_deprecated_newcell2 (void);
	365
	366	#define SCM_NEWCELL(_into) \
	367	do { _into = scm_deprecated_newcell (); } while (0)
	368	#define SCM_NEWCELL2(_into) \
	369	do { _into = scm_deprecated_newcell2 (); } while (0)
	370
539b08a4 MV	371	SCM_API void * scm_must_malloc (size_t len, const char *what);
	372	SCM_API void * scm_must_realloc (void *where,
	373	size_t olen, size_t len,
	374	const char *what);
	375	SCM_API char scm_must_strdup (const char str);
	376	SCM_API char scm_must_strndup (const char str, size_t n);
	377	SCM_API void scm_done_malloc (long size);
	378	SCM_API void scm_done_free (long size);
	379	SCM_API void scm_must_free (void *obj);
	380
d678e25c MV	381	#endif
d678e25c MV	382
61045190	383	#endif /* SCM_GC_H */
89e00824 ML	384
	385	/*
	386	Local Variables:
	387	c-file-style: "gnu"
	388	End:
	389	*/