2 * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
3 * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
4 * Copyright (c) 2000 by Hewlett-Packard Company. All rights reserved.
6 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
7 * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
9 * Permission is hereby granted to use or copy this program
10 * for any purpose, provided the above notices are retained on all copies.
11 * Permission to modify the code and to distribute modified code is granted,
12 * provided the above notices are retained, and a notice that the code was
13 * modified is included with the above copyright notice.
15 /* Boehm, February 7, 1996 4:32 pm PST */
18 #include "private/gc_priv.h"
20 extern ptr_t GC_clear_stack(); /* in misc.c, behaves like identity */
21 void GC_extend_size_map(); /* in misc.c. */
23 /* Allocate reclaim list for kind: */
24 /* Return TRUE on success */
25 GC_bool GC_alloc_reclaim_list(kind)
26 register struct obj_kind * kind;
28 struct hblk ** result = (struct hblk **)
29 GC_scratch_alloc((MAXOBJSZ+1) * sizeof(struct hblk *));
30 if (result == 0) return(FALSE);
31 BZERO(result, (MAXOBJSZ+1)*sizeof(struct hblk *));
32 kind -> ok_reclaim_list = result;
36 /* Allocate a large block of size lw words. */
37 /* The block is not cleared. */
38 /* Flags is 0 or IGNORE_OFF_PAGE. */
39 ptr_t GC_alloc_large(lw, k, flags)
45 word n_blocks = OBJ_SZ_TO_BLOCKS(lw);
48 if (!GC_is_initialized) GC_init_inner();
49 /* Do our share of marking work */
50 if(GC_incremental && !GC_dont_gc)
51 GC_collect_a_little_inner((int)n_blocks);
52 h = GC_allochblk(lw, k, flags);
56 h = GC_allochblk(lw, k, flags);
59 while (0 == h && GC_collect_or_expand(n_blocks, (flags != 0))) {
60 h = GC_allochblk(lw, k, flags);
65 int total_bytes = BYTES_TO_WORDS(n_blocks * HBLKSIZE);
67 GC_large_allocd_bytes += n_blocks * HBLKSIZE;
68 if (GC_large_allocd_bytes > GC_max_large_allocd_bytes)
69 GC_max_large_allocd_bytes = GC_large_allocd_bytes;
71 result = (ptr_t) (h -> hb_body);
72 GC_words_wasted += total_bytes - lw;
78 /* Allocate a large block of size lb bytes. Clear if appropriate. */
79 ptr_t GC_alloc_large_and_clear(lw, k, flags)
84 ptr_t result = GC_alloc_large(lw, k, flags);
85 word n_blocks = OBJ_SZ_TO_BLOCKS(lw);
87 if (0 == result) return 0;
88 if (GC_debugging_started || GC_obj_kinds[k].ok_init) {
89 /* Clear the whole block, in case of GC_realloc call. */
90 BZERO(result, n_blocks * HBLKSIZE);
95 /* allocate lb bytes for an object of kind k. */
96 /* Should not be used to directly to allocate */
97 /* objects such as STUBBORN objects that */
98 /* require special handling on allocation. */
99 /* First a version that assumes we already */
101 ptr_t GC_generic_malloc_inner(lb, k)
109 if( SMALL_OBJ(lb) ) {
110 register struct obj_kind * kind = GC_obj_kinds + k;
112 lw = GC_size_map[lb];
114 lw = ALIGNED_WORDS(lb);
115 if (lw == 0) lw = MIN_WORDS;
117 opp = &(kind -> ok_freelist[lw]);
118 if( (op = *opp) == 0 ) {
120 if (GC_size_map[lb] == 0) {
121 if (!GC_is_initialized) GC_init_inner();
122 if (GC_size_map[lb] == 0) GC_extend_size_map(lb);
123 return(GC_generic_malloc_inner(lb, k));
126 if (!GC_is_initialized) {
128 return(GC_generic_malloc_inner(lb, k));
131 if (kind -> ok_reclaim_list == 0) {
132 if (!GC_alloc_reclaim_list(kind)) goto out;
134 op = GC_allocobj(lw, k);
135 if (op == 0) goto out;
137 /* Here everything is in a consistent state. */
138 /* We assume the following assignment is */
139 /* atomic. If we get aborted */
140 /* after the assignment, we lose an object, */
141 /* but that's benign. */
142 /* Volatile declarations may need to be added */
143 /* to prevent the compiler from breaking things.*/
144 /* If we only execute the second of the */
145 /* following assignments, we lose the free */
146 /* list, but that should still be OK, at least */
147 /* for garbage collected memory. */
151 lw = ROUNDED_UP_WORDS(lb);
152 op = (ptr_t)GC_alloc_large_and_clear(lw, k, 0);
154 GC_words_allocd += lw;
160 /* Allocate a composite object of size n bytes. The caller guarantees */
161 /* that pointers past the first page are not relevant. Caller holds */
162 /* allocation lock. */
163 ptr_t GC_generic_malloc_inner_ignore_off_page(lb, k)
171 return(GC_generic_malloc_inner((word)lb, k));
172 lw = ROUNDED_UP_WORDS(lb);
173 op = (ptr_t)GC_alloc_large_and_clear(lw, k, IGNORE_OFF_PAGE);
174 GC_words_allocd += lw;
178 ptr_t GC_generic_malloc(lb, k)
185 GC_INVOKE_FINALIZERS();
189 result = GC_generic_malloc_inner((word)lb, k);
196 lw = ROUNDED_UP_WORDS(lb);
197 n_blocks = OBJ_SZ_TO_BLOCKS(lw);
198 init = GC_obj_kinds[k].ok_init;
201 result = (ptr_t)GC_alloc_large(lw, k, 0);
203 if (GC_debugging_started) {
204 BZERO(result, n_blocks * HBLKSIZE);
207 /* Clear any memory that might be used for GC descriptors */
208 /* before we release the lock. */
209 ((word *)result)[0] = 0;
210 ((word *)result)[1] = 0;
211 ((word *)result)[lw-1] = 0;
212 ((word *)result)[lw-2] = 0;
216 GC_words_allocd += lw;
219 if (init & !GC_debugging_started && 0 != result) {
220 BZERO(result, n_blocks * HBLKSIZE);
224 return((*GC_oom_fn)(lb));
231 #define GENERAL_MALLOC(lb,k) \
232 (GC_PTR)GC_clear_stack(GC_generic_malloc((word)lb, k))
233 /* We make the GC_clear_stack_call a tail call, hoping to get more of */
236 /* Allocate lb bytes of atomic (pointerfree) data */
238 GC_PTR GC_malloc_atomic(size_t lb)
240 GC_PTR GC_malloc_atomic(lb)
245 register ptr_t * opp;
249 if( EXPECT(SMALL_OBJ(lb), 1) ) {
251 lw = GC_size_map[lb];
253 lw = ALIGNED_WORDS(lb);
255 opp = &(GC_aobjfreelist[lw]);
257 if( EXPECT(!FASTLOCK_SUCCEEDED() || (op = *opp) == 0, 0) ) {
259 return(GENERAL_MALLOC((word)lb, PTRFREE));
261 /* See above comment on signals. */
263 GC_words_allocd += lw;
267 return(GENERAL_MALLOC((word)lb, PTRFREE));
271 /* Allocate lb bytes of composite (pointerful) data */
273 GC_PTR GC_malloc(size_t lb)
284 if( EXPECT(SMALL_OBJ(lb), 1) ) {
286 lw = GC_size_map[lb];
288 lw = ALIGNED_WORDS(lb);
290 opp = &(GC_objfreelist[lw]);
292 if( EXPECT(!FASTLOCK_SUCCEEDED() || (op = *opp) == 0, 0) ) {
294 return(GENERAL_MALLOC((word)lb, NORMAL));
296 /* See above comment on signals. */
299 GC_words_allocd += lw;
303 return(GENERAL_MALLOC((word)lb, NORMAL));
307 # ifdef REDIRECT_MALLOC
309 GC_PTR malloc(size_t lb)
315 /* It might help to manually inline the GC_malloc call here. */
316 /* But any decent compiler should reduce the extra procedure call */
317 /* to at most a jump instruction in this case. */
318 # if defined(I386) && defined(GC_SOLARIS_THREADS)
320 * Thread initialisation can call malloc before
321 * we're ready for it.
322 * It's not clear that this is enough to help matters.
323 * The thread implementation may well call malloc at other
326 if (!GC_is_initialized) return sbrk(lb);
327 # endif /* I386 && GC_SOLARIS_THREADS */
328 return((GC_PTR)REDIRECT_MALLOC(lb));
332 GC_PTR calloc(size_t n, size_t lb)
338 return((GC_PTR)REDIRECT_MALLOC(n*lb));
343 char *strdup(const char *s)
349 size_t len = strlen + 1;
350 char * result = ((char *)REDIRECT_MALLOC(len+1));
351 BCOPY(s, result, len+1);
354 # endif /* REDIRECT_MALLOC */
356 /* Explicitly deallocate an object p. */
358 void GC_free(GC_PTR p)
364 register struct hblk *h;
366 register signed_word sz;
367 register ptr_t * flh;
369 register struct obj_kind * ok;
373 /* Required by ANSI. It's not my fault ... */
376 # if defined(REDIRECT_MALLOC) && \
377 (defined(GC_SOLARIS_THREADS) || defined(GC_LINUX_THREADS) \
378 || defined(__MINGW32__)) /* Should this be MSWIN32 in general? */
379 /* For Solaris, we have to redirect malloc calls during */
380 /* initialization. For the others, this seems to happen */
382 /* Don't try to deallocate that memory. */
383 if (0 == hhdr) return;
385 knd = hhdr -> hb_obj_kind;
387 ok = &GC_obj_kinds[knd];
388 if (EXPECT((sz <= MAXOBJSZ), 1)) {
394 /* A signal here can make GC_mem_freed and GC_non_gc_bytes */
395 /* inconsistent. We claim this is benign. */
396 if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
397 /* Its unnecessary to clear the mark bit. If the */
398 /* object is reallocated, it doesn't matter. O.w. the */
399 /* collector will do it, since it's on a free list. */
401 BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1));
403 flh = &(ok -> ok_freelist[sz]);
414 if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
421 /* Explicitly deallocate an object p when we already hold lock. */
422 /* Only used for internally allocated objects, so we can take some */
425 void GC_free_inner(GC_PTR p)
427 register struct hblk *h;
429 register signed_word sz;
430 register ptr_t * flh;
432 register struct obj_kind * ok;
437 knd = hhdr -> hb_obj_kind;
439 ok = &GC_obj_kinds[knd];
440 if (sz <= MAXOBJSZ) {
442 if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
444 BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1));
446 flh = &(ok -> ok_freelist[sz]);
451 if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
457 # ifdef REDIRECT_MALLOC
469 # endif /* REDIRECT_MALLOC */