[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, 2002, 2003 Free Software Foundation, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

\f

#include "libguile/__scm.h"

#include "libguile/hooks.h"

#if SCM_USE_PTHREAD_THREADS
# include "libguile/pthread-threads.h"
#else
# include "libguile/null-threads.h"
#endif

\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))))

/*
  Remove card flags. They hamper lazy initialization, and aren't used
  anyways.
 */

/* 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_SET_CELL_BVEC(x, bvec)    SCM_GC_SET_CARD_BVEC (SCM_GC_CELL_CARD (x), bvec)
#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 (SCM_SIZEOF_UNSIGNED_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
#else
#       define SCM_C_BVEC_LONG_BITS    32
#       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)
/* Set this to != 0 if every cell that is accessed shall be checked:
 */
SCM_API int scm_debug_cell_accesses_p;
SCM_API int scm_expensive_debug_cell_accesses_p;
SCM_API int scm_debug_cells_gc_interval ;
void scm_i_expensive_validation_check (SCM cell);
#endif

SCM_API int scm_block_gc;
SCM_API int scm_gc_heap_lock;
SCM_API unsigned int scm_gc_running_p;
SCM_API scm_t_rec_mutex scm_i_sweep_mutex;
\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;

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