Quote the first argument to `AC_DEFINE_UNQUOTED'.
[bpt/guile.git] / libguile / gc.h
... / ...
CommitLineData
1/* classes: h_files */
2
3#ifndef SCM_GC_H
4#define SCM_GC_H
5
6/* Copyright (C) 1995,1996,1998,1999,2000,2001, 2002, 2003, 2004, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public License
10 * as published by the Free Software Foundation; either version 3 of
11 * the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
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., 51 Franklin Street, Fifth Floor, Boston, MA
21 * 02110-1301 USA
22 */
23
24\f
25
26#include "libguile/__scm.h"
27
28#include "libguile/hooks.h"
29#include "libguile/threads.h"
30
31\f
32typedef struct scm_t_cell
33{
34 SCM word_0;
35 SCM word_1;
36} scm_t_cell;
37
38/* Cray machines have pointers that are incremented once for each
39 * word, rather than each byte, the 3 most significant bits encode the
40 * byte within the word. The following macros deal with this by
41 * storing the native Cray pointers like the ones that looks like scm
42 * expects. This is done for any pointers that point to a cell,
43 * pointers to scm_vector elts, functions, &c are not munged.
44 */
45#ifdef _UNICOS
46# define SCM2PTR(x) ((scm_t_cell *) (SCM_UNPACK (x) >> 3))
47# define PTR2SCM(x) (SCM_PACK (((scm_t_bits) (x)) << 3))
48#else
49# define SCM2PTR(x) ((scm_t_cell *) (SCM_UNPACK (x)))
50# define PTR2SCM(x) (SCM_PACK ((scm_t_bits) (x)))
51#endif /* def _UNICOS */
52
53
54
55/* Low level cell data accessing macros. These macros should only be used
56 * from within code related to garbage collection issues, since they will
57 * never check the cells they are applied to - not even if guile is compiled
58 * in debug mode. In particular these macros will even work for free cells,
59 * which should never be encountered by user code. */
60
61#define SCM_GC_CELL_OBJECT(x, n) (((SCM *)SCM2PTR (x)) [n])
62#define SCM_GC_CELL_WORD(x, n) (SCM_UNPACK (SCM_GC_CELL_OBJECT ((x), (n))))
63
64#define SCM_GC_SET_CELL_OBJECT(x, n, v) ((((SCM *)SCM2PTR (x)) [n]) = (v))
65#define SCM_GC_SET_CELL_WORD(x, n, v) \
66 (SCM_GC_SET_CELL_OBJECT ((x), (n), SCM_PACK (v)))
67
68#define SCM_GC_CELL_TYPE(x) (SCM_GC_CELL_OBJECT ((x), 0))
69
70
71/* Except for the garbage collector, no part of guile should ever run over a
72 * free cell. Thus, if guile is compiled in debug mode the SCM_CELL_* and
73 * SCM_SET_CELL_* macros below report an error if they are applied to a free
74 * cell. Some other plausibility checks are also performed. However, if
75 * guile is not compiled in debug mode, there won't be any time penalty at all
76 * when using these macros. */
77
78#if (SCM_DEBUG_CELL_ACCESSES == 1)
79# define SCM_VALIDATE_CELL(cell, expr) (scm_assert_cell_valid (cell), (expr))
80#else
81# define SCM_VALIDATE_CELL(cell, expr) (expr)
82#endif
83
84#define SCM_CELL_WORD(x, n) \
85 SCM_VALIDATE_CELL ((x), SCM_GC_CELL_WORD ((x), (n)))
86#define SCM_CELL_WORD_0(x) SCM_CELL_WORD ((x), 0)
87#define SCM_CELL_WORD_1(x) SCM_CELL_WORD ((x), 1)
88#define SCM_CELL_WORD_2(x) SCM_CELL_WORD ((x), 2)
89#define SCM_CELL_WORD_3(x) SCM_CELL_WORD ((x), 3)
90
91#define SCM_CELL_OBJECT(x, n) \
92 SCM_VALIDATE_CELL ((x), SCM_GC_CELL_OBJECT ((x), (n)))
93#define SCM_CELL_OBJECT_0(x) SCM_CELL_OBJECT ((x), 0)
94#define SCM_CELL_OBJECT_1(x) SCM_CELL_OBJECT ((x), 1)
95#define SCM_CELL_OBJECT_2(x) SCM_CELL_OBJECT ((x), 2)
96#define SCM_CELL_OBJECT_3(x) SCM_CELL_OBJECT ((x), 3)
97
98#define SCM_SET_CELL_WORD(x, n, v) \
99 SCM_VALIDATE_CELL ((x), SCM_GC_SET_CELL_WORD ((x), (n), (v)))
100#define SCM_SET_CELL_WORD_0(x, v) SCM_SET_CELL_WORD ((x), 0, (v))
101#define SCM_SET_CELL_WORD_1(x, v) SCM_SET_CELL_WORD ((x), 1, (v))
102#define SCM_SET_CELL_WORD_2(x, v) SCM_SET_CELL_WORD ((x), 2, (v))
103#define SCM_SET_CELL_WORD_3(x, v) SCM_SET_CELL_WORD ((x), 3, (v))
104
105#define SCM_SET_CELL_OBJECT(x, n, v) \
106 SCM_VALIDATE_CELL ((x), SCM_GC_SET_CELL_OBJECT ((x), (n), (v)))
107#define SCM_SET_CELL_OBJECT_0(x, v) SCM_SET_CELL_OBJECT ((x), 0, (v))
108#define SCM_SET_CELL_OBJECT_1(x, v) SCM_SET_CELL_OBJECT ((x), 1, (v))
109#define SCM_SET_CELL_OBJECT_2(x, v) SCM_SET_CELL_OBJECT ((x), 2, (v))
110#define SCM_SET_CELL_OBJECT_3(x, v) SCM_SET_CELL_OBJECT ((x), 3, (v))
111
112#define SCM_CELL_OBJECT_LOC(x, n) (SCM_VALIDATE_CELL((x), &SCM_GC_CELL_OBJECT ((x), (n))))
113#define SCM_CARLOC(x) (SCM_CELL_OBJECT_LOC ((x), 0))
114#define SCM_CDRLOC(x) (SCM_CELL_OBJECT_LOC ((x), 1))
115
116#define SCM_CELL_TYPE(x) SCM_CELL_WORD_0 (x)
117#define SCM_SET_CELL_TYPE(x, t) SCM_SET_CELL_WORD_0 ((x), (t))
118
119
120#if (SCM_DEBUG_CELL_ACCESSES == 1)
121/* Set this to != 0 if every cell that is accessed shall be checked:
122 */
123SCM_API int scm_debug_cell_accesses_p;
124SCM_API int scm_expensive_debug_cell_accesses_p;
125SCM_API int scm_debug_cells_gc_interval ;
126SCM_API void scm_i_expensive_validation_check (SCM cell);
127#endif
128
129SCM_INTERNAL scm_i_pthread_mutex_t scm_i_gc_admin_mutex;
130
131#define scm_gc_running_p 0
132SCM_INTERNAL scm_i_pthread_mutex_t scm_i_sweep_mutex;
133
134#ifdef __ia64__
135void *scm_ia64_register_backing_store_base (void);
136void *scm_ia64_ar_bsp (const void *);
137#endif
138
139\f
140
141#if (SCM_ENABLE_DEPRECATED == 1)
142SCM_DEPRECATED size_t scm_default_init_heap_size_1;
143SCM_DEPRECATED int scm_default_min_yield_1;
144SCM_DEPRECATED size_t scm_default_init_heap_size_2;
145SCM_DEPRECATED int scm_default_min_yield_2;
146SCM_DEPRECATED size_t scm_default_max_segment_size;
147#else
148#define scm_default_init_heap_size_1 deprecated
149#define scm_default_min_yield_1 deprecated
150#define scm_default_init_heap_size_2 deprecated
151#define scm_default_min_yield_2 deprecated
152#define scm_default_max_segment_size deprecated
153#endif
154
155SCM_API unsigned long scm_gc_ports_collected;
156
157SCM_API SCM scm_after_gc_hook;
158
159SCM_API scm_t_c_hook scm_before_gc_c_hook;
160SCM_API scm_t_c_hook scm_before_mark_c_hook;
161SCM_API scm_t_c_hook scm_before_sweep_c_hook;
162SCM_API scm_t_c_hook scm_after_sweep_c_hook;
163SCM_API scm_t_c_hook scm_after_gc_c_hook;
164
165\f
166
167#if (SCM_DEBUG_CELL_ACCESSES == 1)
168SCM_API void scm_assert_cell_valid (SCM);
169#endif
170
171SCM_API SCM scm_set_debug_cell_accesses_x (SCM flag);
172
173
174SCM_API SCM scm_object_address (SCM obj);
175SCM_API SCM scm_gc_enable (void);
176SCM_API SCM scm_gc_disable (void);
177SCM_API SCM scm_gc_dump (void);
178SCM_API SCM scm_gc_stats (void);
179SCM_API SCM scm_gc_live_object_stats (void);
180SCM_API SCM scm_gc (void);
181SCM_API void scm_i_gc (const char *what);
182SCM_API void scm_gc_mark (SCM p);
183SCM_API void scm_gc_sweep (void);
184
185SCM_API void *scm_malloc (size_t size) SCM_MALLOC;
186SCM_API void *scm_calloc (size_t size) SCM_MALLOC;
187SCM_API void *scm_realloc (void *mem, size_t size);
188SCM_API char *scm_strdup (const char *str) SCM_MALLOC;
189SCM_API char *scm_strndup (const char *str, size_t n) SCM_MALLOC;
190SCM_API void scm_gc_register_collectable_memory (void *mem, size_t size,
191 const char *what);
192SCM_API void scm_gc_unregister_collectable_memory (void *mem, size_t size,
193 const char *what);
194SCM_API void *scm_gc_malloc_pointerless (size_t size, const char *what)
195 SCM_MALLOC;
196SCM_API void *scm_gc_calloc (size_t size, const char *what)
197 SCM_MALLOC;
198SCM_API void *scm_gc_malloc (size_t size, const char *what)
199 SCM_MALLOC;
200SCM_API void *scm_gc_realloc (void *mem, size_t old_size,
201 size_t new_size, const char *what);
202SCM_API void scm_gc_free (void *mem, size_t size, const char *what);
203SCM_API char *scm_gc_strdup (const char *str, const char *what)
204 SCM_MALLOC;
205SCM_API char *scm_gc_strndup (const char *str, size_t n, const char *what)
206 SCM_MALLOC;
207
208SCM_API void scm_remember_upto_here_1 (SCM obj);
209SCM_API void scm_remember_upto_here_2 (SCM obj1, SCM obj2);
210SCM_API void scm_remember_upto_here (SCM obj1, ...);
211
212/* In GCC we can force a reference to an SCM by making it an input to an
213 empty asm. This avoids the code size and slowdown of an actual function
214 call. Unfortunately there doesn't seem to be any way to do the varargs
215 scm_remember_upto_here like this.
216
217 __volatile__ ensures nothing will be moved across the asm, and it won't
218 be optimized away (or only if proved unreachable). Constraint "g" can be
219 used on all processors and allows any memory or general register (or
220 immediate) operand. The actual asm syntax doesn't matter, we don't want
221 to use it, just ensure the operand is still alive. See "Extended Asm" in
222 the GCC manual for more. */
223
224#ifdef __GNUC__
225#define scm_remember_upto_here_1(x) \
226 do { \
227 __asm__ __volatile__ ("" : : "g" (x)); \
228 } while (0)
229#define scm_remember_upto_here_2(x, y) \
230 do { \
231 scm_remember_upto_here_1 (x); \
232 scm_remember_upto_here_1 (y); \
233 } while (0)
234#endif
235
236SCM_API SCM scm_return_first (SCM elt, ...);
237SCM_API int scm_return_first_int (int x, ...);
238SCM_API SCM scm_permanent_object (SCM obj);
239SCM_API SCM scm_gc_protect_object (SCM obj);
240SCM_API SCM scm_gc_unprotect_object (SCM obj);
241SCM_API void scm_gc_register_root (SCM *p);
242SCM_API void scm_gc_unregister_root (SCM *p);
243SCM_API void scm_gc_register_roots (SCM *b, unsigned long n);
244SCM_API void scm_gc_unregister_roots (SCM *b, unsigned long n);
245SCM_API SCM scm_protects;
246SCM_INTERNAL void scm_storage_prehistory (void);
247SCM_INTERNAL void scm_init_gc_protect_object (void);
248SCM_INTERNAL void scm_init_gc (void);
249
250#if SCM_ENABLE_DEPRECATED == 1
251
252SCM_DEPRECATED SCM scm_deprecated_newcell (void);
253SCM_DEPRECATED SCM scm_deprecated_newcell2 (void);
254
255#define SCM_NEWCELL(_into) \
256 do { _into = scm_deprecated_newcell (); } while (0)
257#define SCM_NEWCELL2(_into) \
258 do { _into = scm_deprecated_newcell2 (); } while (0)
259
260SCM_DEPRECATED void * scm_must_malloc (size_t len, const char *what);
261SCM_DEPRECATED void * scm_must_realloc (void *where,
262 size_t olen, size_t len,
263 const char *what);
264SCM_DEPRECATED char *scm_must_strdup (const char *str);
265SCM_DEPRECATED char *scm_must_strndup (const char *str, size_t n);
266SCM_DEPRECATED void scm_done_malloc (long size);
267SCM_DEPRECATED void scm_done_free (long size);
268SCM_DEPRECATED void scm_must_free (void *obj);
269
270#endif
271
272#endif /* SCM_GC_H */
273
274/*
275 Local Variables:
276 c-file-style: "gnu"
277 End:
278*/