2 * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
3 * Copyright (c) 1991-1994 by Xerox Corporation. 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.
14 /* Boehm, February 7, 1996 4:32 pm PST */
19 extern ptr_t GC_clear_stack(); /* in misc.c, behaves like identity */
20 void GC_extend_size_map(); /* in misc.c. */
22 /* Allocate reclaim list for kind: */
23 /* Return TRUE on success */
24 GC_bool GC_alloc_reclaim_list(kind)
25 register struct obj_kind * kind;
27 struct hblk ** result = (struct hblk **)
28 GC_scratch_alloc((MAXOBJSZ+1) * sizeof(struct hblk *));
29 if (result == 0) return(FALSE);
30 BZERO(result, (MAXOBJSZ+1)*sizeof(struct hblk *));
31 kind -> ok_reclaim_list = result;
35 /* allocate lb bytes for an object of kind. */
36 /* Should not be used to directly to allocate */
37 /* objects such as STUBBORN objects that */
38 /* require special handling on allocation. */
39 /* First a version that assumes we already */
41 ptr_t GC_generic_malloc_inner(lb, k)
50 register struct obj_kind * kind = GC_obj_kinds + k;
54 lw = ALIGNED_WORDS(lb);
57 opp = &(kind -> ok_freelist[lw]);
58 if( (op = *opp) == 0 ) {
60 if (GC_size_map[lb] == 0) {
61 if (!GC_is_initialized) GC_init_inner();
62 if (GC_size_map[lb] == 0) GC_extend_size_map(lb);
63 return(GC_generic_malloc_inner(lb, k));
66 if (!GC_is_initialized) {
68 return(GC_generic_malloc_inner(lb, k));
71 if (kind -> ok_reclaim_list == 0) {
72 if (!GC_alloc_reclaim_list(kind)) goto out;
74 op = GC_allocobj(lw, k);
75 if (op == 0) goto out;
77 /* Here everything is in a consistent state. */
78 /* We assume the following assignment is */
79 /* atomic. If we get aborted */
80 /* after the assignment, we lose an object, */
81 /* but that's benign. */
82 /* Volatile declarations may need to be added */
83 /* to prevent the compiler from breaking things.*/
84 /* If we only execute the second of the */
85 /* following assignments, we lose the free */
86 /* list, but that should still be OK, at least */
87 /* for garbage collected memory. */
91 register struct hblk * h;
92 register word n_blocks = divHBLKSZ(ADD_SLOP(lb)
93 + HDR_BYTES + HBLKSIZE-1);
95 if (!GC_is_initialized) GC_init_inner();
96 /* Do our share of marking work */
97 if(GC_incremental && !GC_dont_gc)
98 GC_collect_a_little_inner((int)n_blocks);
99 lw = ROUNDED_UP_WORDS(lb);
100 h = GC_allochblk(lw, k, 0);
104 h = GC_allochblk(lw, k, 0);
107 while (0 == h && GC_collect_or_expand(n_blocks, FALSE)) {
108 h = GC_allochblk(lw, k, 0);
113 op = (ptr_t) (h -> hb_body);
114 GC_words_wasted += BYTES_TO_WORDS(n_blocks * HBLKSIZE) - lw;
117 GC_words_allocd += lw;
123 ptr_t GC_generic_malloc(lb, k)
130 GC_INVOKE_FINALIZERS();
133 result = GC_generic_malloc_inner(lb, k);
137 return((*GC_oom_fn)(lb));
144 #define GENERAL_MALLOC(lb,k) \
145 (GC_PTR)GC_clear_stack(GC_generic_malloc((word)lb, k))
146 /* We make the GC_clear_stack_call a tail call, hoping to get more of */
149 /* Allocate lb bytes of atomic (pointerfree) data */
151 GC_PTR GC_malloc_atomic(size_t lb)
153 GC_PTR GC_malloc_atomic(lb)
158 register ptr_t * opp;
162 if( SMALL_OBJ(lb) ) {
164 lw = GC_size_map[lb];
166 lw = ALIGNED_WORDS(lb);
168 opp = &(GC_aobjfreelist[lw]);
170 if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {
172 return(GENERAL_MALLOC((word)lb, PTRFREE));
174 /* See above comment on signals. */
176 GC_words_allocd += lw;
180 return(GENERAL_MALLOC((word)lb, PTRFREE));
184 /* Allocate lb bytes of composite (pointerful) data */
186 GC_PTR GC_malloc(size_t lb)
197 if( SMALL_OBJ(lb) ) {
199 lw = GC_size_map[lb];
201 lw = ALIGNED_WORDS(lb);
203 opp = &(GC_objfreelist[lw]);
205 if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {
207 return(GENERAL_MALLOC((word)lb, NORMAL));
209 /* See above comment on signals. */
212 GC_words_allocd += lw;
216 return(GENERAL_MALLOC((word)lb, NORMAL));
220 # ifdef REDIRECT_MALLOC
222 GC_PTR malloc(size_t lb)
228 /* It might help to manually inline the GC_malloc call here. */
229 /* But any decent compiler should reduce the extra procedure call */
230 /* to at most a jump instruction in this case. */
231 # if defined(I386) && defined(SOLARIS_THREADS)
233 * Thread initialisation can call malloc before
234 * we're ready for it.
235 * It's not clear that this is enough to help matters.
236 * The thread implementation may well call malloc at other
239 if (!GC_is_initialized) return sbrk(lb);
240 # endif /* I386 && SOLARIS_THREADS */
241 return(REDIRECT_MALLOC(lb));
245 GC_PTR calloc(size_t n, size_t lb)
251 return(REDIRECT_MALLOC(n*lb));
253 # endif /* REDIRECT_MALLOC */
255 GC_PTR GC_generic_or_special_malloc(lb,knd)
260 # ifdef STUBBORN_ALLOC
262 return(GC_malloc_stubborn((size_t)lb));
265 return(GC_malloc_atomic((size_t)lb));
267 return(GC_malloc((size_t)lb));
269 return(GC_malloc_uncollectable((size_t)lb));
270 # ifdef ATOMIC_UNCOLLECTABLE
272 return(GC_malloc_atomic_uncollectable((size_t)lb));
273 # endif /* ATOMIC_UNCOLLECTABLE */
275 return(GC_generic_malloc(lb,knd));
280 /* Change the size of the block pointed to by p to contain at least */
281 /* lb bytes. The object may be (and quite likely will be) moved. */
282 /* The kind (e.g. atomic) is the same as that of the old. */
283 /* Shrinking of large blocks is not implemented well. */
285 GC_PTR GC_realloc(GC_PTR p, size_t lb)
287 GC_PTR GC_realloc(p,lb)
292 register struct hblk * h;
294 register word sz; /* Current size in bytes */
295 register word orig_sz; /* Original sz in bytes */
298 if (p == 0) return(GC_malloc(lb)); /* Required by ANSI */
302 obj_kind = hhdr -> hb_obj_kind;
303 sz = WORDS_TO_BYTES(sz);
306 if (sz > WORDS_TO_BYTES(MAXOBJSZ)) {
307 /* Round it up to the next whole heap block */
310 sz = (sz+HDR_BYTES+HBLKSIZE-1)
313 hhdr -> hb_sz = BYTES_TO_WORDS(sz);
314 descr = GC_obj_kinds[obj_kind].ok_descriptor;
315 if (GC_obj_kinds[obj_kind].ok_relocate_descr) descr += sz;
316 hhdr -> hb_descr = descr;
317 if (IS_UNCOLLECTABLE(obj_kind)) GC_non_gc_bytes += (sz - orig_sz);
318 /* Extra area is already cleared by allochblk. */
320 if (ADD_SLOP(lb) <= sz) {
321 if (lb >= (sz >> 1)) {
322 # ifdef STUBBORN_ALLOC
323 if (obj_kind == STUBBORN) GC_change_stubborn(p);
326 /* Clear unneeded part of object to avoid bogus pointer */
328 /* Safe for stubborn objects. */
329 BZERO(((ptr_t)p) + lb, orig_sz - lb);
335 GC_generic_or_special_malloc((word)lb, obj_kind);
337 if (result == 0) return(0);
338 /* Could also return original object. But this */
339 /* gives the client warning of imminent disaster. */
340 BCOPY(p, result, lb);
349 GC_generic_or_special_malloc((word)lb, obj_kind);
351 if (result == 0) return(0);
352 BCOPY(p, result, sz);
360 # ifdef REDIRECT_MALLOC
362 GC_PTR realloc(GC_PTR p, size_t lb)
369 return(GC_realloc(p, lb));
371 # endif /* REDIRECT_MALLOC */
373 /* Explicitly deallocate an object p. */
375 void GC_free(GC_PTR p)
381 register struct hblk *h;
383 register signed_word sz;
384 register ptr_t * flh;
386 register struct obj_kind * ok;
390 /* Required by ANSI. It's not my fault ... */
393 # if defined(REDIRECT_MALLOC) && \
394 (defined(SOLARIS_THREADS) || defined(LINUX_THREADS))
395 /* We have to redirect malloc calls during initialization. */
396 /* Don't try to deallocate that memory. */
397 if (0 == hhdr) return;
399 knd = hhdr -> hb_obj_kind;
401 ok = &GC_obj_kinds[knd];
402 if (sz <= MAXOBJSZ) {
408 /* A signal here can make GC_mem_freed and GC_non_gc_bytes */
409 /* inconsistent. We claim this is benign. */
410 if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
411 /* Its unnecessary to clear the mark bit. If the */
412 /* object is reallocated, it doesn't matter. O.w. the */
413 /* collector will do it, since it's on a free list. */
415 BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1));
417 flh = &(ok -> ok_freelist[sz]);
428 if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
435 # ifdef REDIRECT_MALLOC
447 # endif /* REDIRECT_MALLOC */