2
* Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
3
* Copyright (c) 2001 by Hewlett-Packard Company. All rights reserved.
5
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
6
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
8
* Permission is hereby granted to use or copy this program
9
* for any purpose, provided the above notices are retained on all copies.
10
* Permission to modify the code and to distribute modified code is granted,
11
* provided the above notices are retained, and a notice that the code was
12
* modified is included with the above copyright notice.
17
* This contains interfaces to the GC marker that are likely to be useful to
18
* clients that provide detailed heap layout information to the collector.
19
* This interface should not be used by normal C or C++ clients.
20
* It will be useful to runtimes for other languages.
22
* This is an experts-only interface! There are many ways to break the
23
* collector in subtle ways by using this functionality.
32
/* A client supplied mark procedure. Returns new mark stack pointer. */
33
/* Primary effect should be to push new entries on the mark stack. */
34
/* Mark stack pointer values are passed and returned explicitly. */
35
/* Global variables decribing mark stack are not necessarily valid. */
36
/* (This usually saves a few cycles by keeping things in registers.) */
37
/* Assumed to scan about GC_PROC_BYTES on average. If it needs to do */
38
/* much more work than that, it should do it in smaller pieces by */
39
/* pushing itself back on the mark stack. */
40
/* Note that it should always do some work (defined as marking some */
41
/* objects) before pushing more than one entry on the mark stack. */
42
/* This is required to ensure termination in the event of mark stack */
44
/* This procedure is always called with at least one empty entry on the */
46
/* Currently we require that mark procedures look for pointers in a */
47
/* subset of the places the conservative marker would. It must be safe */
48
/* to invoke the normal mark procedure instead. */
49
/* WARNING: Such a mark procedure may be invoked on an unused object */
50
/* residing on a free list. Such objects are cleared, except for a */
51
/* free list link field in the first word. Thus mark procedures may */
52
/* not count on the presence of a type descriptor, and must handle this */
53
/* case correctly somehow. */
54
# define GC_PROC_BYTES 100
56
typedef struct GC_ms_entry * (*GC_mark_proc) GC_PROTO((
57
GC_word * addr, struct GC_ms_entry * mark_stack_ptr,
58
struct GC_ms_entry * mark_stack_limit, GC_word env));
60
# define GC_LOG_MAX_MARK_PROCS 6
61
# define GC_MAX_MARK_PROCS (1 << GC_LOG_MAX_MARK_PROCS)
63
/* In a few cases it's necessary to assign statically known indices to */
64
/* certain mark procs. Thus we reserve a few for well known clients. */
65
/* (This is necessary if mark descriptors are compiler generated.) */
66
#define GC_RESERVED_MARK_PROCS 8
67
# define GC_GCJ_RESERVED_MARK_PROC_INDEX 0
69
/* Object descriptors on mark stack or in objects. Low order two */
70
/* bits are tags distinguishing among the following 4 possibilities */
71
/* for the high order 30 bits. */
72
#define GC_DS_TAG_BITS 2
73
#define GC_DS_TAGS ((1 << GC_DS_TAG_BITS) - 1)
74
#define GC_DS_LENGTH 0 /* The entire word is a length in bytes that */
75
/* must be a multiple of 4. */
76
#define GC_DS_BITMAP 1 /* 30 (62) bits are a bitmap describing pointer */
77
/* fields. The msb is 1 iff the first word */
79
/* (This unconventional ordering sometimes */
80
/* makes the marker slightly faster.) */
81
/* Zeroes indicate definite nonpointers. Ones */
82
/* indicate possible pointers. */
83
/* Only usable if pointers are word aligned. */
85
/* The objects referenced by this object can be */
86
/* pushed on the mark stack by invoking */
87
/* PROC(descr). ENV(descr) is passed as the */
89
# define GC_MAKE_PROC(proc_index, env) \
90
(((((env) << GC_LOG_MAX_MARK_PROCS) \
91
| (proc_index)) << GC_DS_TAG_BITS) | GC_DS_PROC)
92
#define GC_DS_PER_OBJECT 3 /* The real descriptor is at the */
93
/* byte displacement from the beginning of the */
94
/* object given by descr & ~DS_TAGS */
95
/* If the descriptor is negative, the real */
96
/* descriptor is at (*<object_start>) - */
97
/* (descr & ~DS_TAGS) - GC_INDIR_PER_OBJ_BIAS */
98
/* The latter alternative can be used if each */
99
/* object contains a type descriptor in the */
101
/* Note that in multithreaded environments */
102
/* per object descriptors maust be located in */
103
/* either the first two or last two words of */
104
/* the object, since only those are guaranteed */
105
/* to be cleared while the allocation lock is */
107
#define GC_INDIR_PER_OBJ_BIAS 0x10
109
extern GC_PTR GC_least_plausible_heap_addr;
110
extern GC_PTR GC_greatest_plausible_heap_addr;
111
/* Bounds on the heap. Guaranteed valid */
112
/* Likely to include future heap expansion. */
114
/* Handle nested references in a custom mark procedure. */
115
/* Check if obj is a valid object. If so, ensure that it is marked. */
116
/* If it was not previously marked, push its contents onto the mark */
117
/* stack for future scanning. The object will then be scanned using */
118
/* its mark descriptor. */
119
/* Returns the new mark stack pointer. */
120
/* Handles mark stack overflows correctly. */
121
/* Since this marks first, it makes progress even if there are mark */
122
/* stack overflows. */
123
/* Src is the address of the pointer to obj, which is used only */
124
/* for back pointer-based heap debugging. */
125
/* It is strongly recommended that most objects be handled without mark */
126
/* procedures, e.g. with bitmap descriptors, and that mark procedures */
127
/* be reserved for exceptional cases. That will ensure that */
128
/* performance of this call is not extremely performance critical. */
129
/* (Otherwise we would need to inline GC_mark_and_push completely, */
130
/* which would tie the client code to a fixed collector version.) */
131
/* Note that mark procedures should explicitly call FIXUP_POINTER() */
133
struct GC_ms_entry *GC_mark_and_push
134
GC_PROTO((GC_PTR obj,
135
struct GC_ms_entry * mark_stack_ptr,
136
struct GC_ms_entry * mark_stack_limit, GC_PTR *src));
138
#define GC_MARK_AND_PUSH(obj, msp, lim, src) \
139
(((GC_word)obj >= (GC_word)GC_least_plausible_heap_addr && \
140
(GC_word)obj <= (GC_word)GC_greatest_plausible_heap_addr)? \
141
GC_mark_and_push(obj, msp, lim, src) : \
144
extern size_t GC_debug_header_size;
145
/* The size of the header added to objects allocated through */
146
/* the GC_debug routines. */
147
/* Defined as a variable so that client mark procedures don't */
148
/* need to be recompiled for collector version changes. */
149
#define GC_USR_PTR_FROM_BASE(p) ((GC_PTR)((char *)(p) + GC_debug_header_size))
151
/* And some routines to support creation of new "kinds", e.g. with */
152
/* custom mark procedures, by language runtimes. */
153
/* The _inner versions assume the caller holds the allocation lock. */
155
/* Return a new free list array. */
156
void ** GC_new_free_list GC_PROTO((void));
157
void ** GC_new_free_list_inner GC_PROTO((void));
159
/* Return a new kind, as specified. */
160
int GC_new_kind GC_PROTO((void **free_list, GC_word mark_descriptor_template,
161
int add_size_to_descriptor, int clear_new_objects));
162
/* The last two parameters must be zero or one. */
163
int GC_new_kind_inner GC_PROTO((void **free_list,
164
GC_word mark_descriptor_template,
165
int add_size_to_descriptor,
166
int clear_new_objects));
168
/* Return a new mark procedure identifier, suitable for use as */
169
/* the first argument in GC_MAKE_PROC. */
170
int GC_new_proc GC_PROTO((GC_mark_proc));
171
int GC_new_proc_inner GC_PROTO((GC_mark_proc));
173
/* Allocate an object of a given kind. Note that in multithreaded */
174
/* contexts, this is usually unsafe for kinds that have the descriptor */
175
/* in the object itself, since there is otherwise a window in which */
176
/* the descriptor is not correct. Even in the single-threaded case, */
177
/* we need to be sure that cleared objects on a free list don't */
178
/* cause a GC crash if they are accidentally traced. */
179
/* ptr_t */char * GC_generic_malloc GC_PROTO((GC_word lb, int k));
181
/* FIXME - Should return void *, but that requires other changes. */
183
typedef void (*GC_describe_type_fn) GC_PROTO((void *p, char *out_buf));
184
/* A procedure which */
185
/* produces a human-readable */
186
/* description of the "type" of object */
187
/* p into the buffer out_buf of length */
188
/* GC_TYPE_DESCR_LEN. This is used by */
189
/* the debug support when printing */
191
/* These functions should be as robust */
192
/* as possible, though we do avoid */
193
/* invoking them on objects on the */
194
/* global free list. */
195
# define GC_TYPE_DESCR_LEN 40
197
void GC_register_describe_type_fn GC_PROTO((int kind, GC_describe_type_fn knd));
198
/* Register a describe_type function */
199
/* to be used when printing objects */
200
/* of a particular kind. */
202
#endif /* GC_MARK_H */
added
removed
libgc/include/gc_mark.h
