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 */