Mercurial > emacs
comparison gc/malloc.c @ 51488:5de98dce4bd1
*** empty log message ***
author | Dave Love <fx@gnu.org> |
---|---|
date | Thu, 05 Jun 2003 17:49:22 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
51487:01d68b199093 | 51488:5de98dce4bd1 |
---|---|
1 /* | |
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. | |
5 * | |
6 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED | |
7 * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. | |
8 * | |
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. | |
14 */ | |
15 /* Boehm, February 7, 1996 4:32 pm PST */ | |
16 | |
17 #include <stdio.h> | |
18 #include "private/gc_priv.h" | |
19 | |
20 extern ptr_t GC_clear_stack(); /* in misc.c, behaves like identity */ | |
21 void GC_extend_size_map(); /* in misc.c. */ | |
22 | |
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; | |
27 { | |
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; | |
33 return(TRUE); | |
34 } | |
35 | |
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) | |
40 word lw; | |
41 int k; | |
42 unsigned flags; | |
43 { | |
44 struct hblk * h; | |
45 word n_blocks = OBJ_SZ_TO_BLOCKS(lw); | |
46 ptr_t result; | |
47 | |
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); | |
53 # ifdef USE_MUNMAP | |
54 if (0 == h) { | |
55 GC_merge_unmapped(); | |
56 h = GC_allochblk(lw, k, flags); | |
57 } | |
58 # endif | |
59 while (0 == h && GC_collect_or_expand(n_blocks, (flags != 0))) { | |
60 h = GC_allochblk(lw, k, flags); | |
61 } | |
62 if (h == 0) { | |
63 result = 0; | |
64 } else { | |
65 int total_bytes = BYTES_TO_WORDS(n_blocks * HBLKSIZE); | |
66 if (n_blocks > 1) { | |
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; | |
70 } | |
71 result = (ptr_t) (h -> hb_body); | |
72 GC_words_wasted += total_bytes - lw; | |
73 } | |
74 return result; | |
75 } | |
76 | |
77 | |
78 /* Allocate a large block of size lb bytes. Clear if appropriate. */ | |
79 ptr_t GC_alloc_large_and_clear(lw, k, flags) | |
80 word lw; | |
81 int k; | |
82 unsigned flags; | |
83 { | |
84 ptr_t result = GC_alloc_large(lw, k, flags); | |
85 word n_blocks = OBJ_SZ_TO_BLOCKS(lw); | |
86 | |
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); | |
91 } | |
92 return result; | |
93 } | |
94 | |
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 */ | |
100 /* hold lock: */ | |
101 ptr_t GC_generic_malloc_inner(lb, k) | |
102 register word lb; | |
103 register int k; | |
104 { | |
105 register word lw; | |
106 register ptr_t op; | |
107 register ptr_t *opp; | |
108 | |
109 if( SMALL_OBJ(lb) ) { | |
110 register struct obj_kind * kind = GC_obj_kinds + k; | |
111 # ifdef MERGE_SIZES | |
112 lw = GC_size_map[lb]; | |
113 # else | |
114 lw = ALIGNED_WORDS(lb); | |
115 if (lw == 0) lw = MIN_WORDS; | |
116 # endif | |
117 opp = &(kind -> ok_freelist[lw]); | |
118 if( (op = *opp) == 0 ) { | |
119 # ifdef MERGE_SIZES | |
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)); | |
124 } | |
125 # else | |
126 if (!GC_is_initialized) { | |
127 GC_init_inner(); | |
128 return(GC_generic_malloc_inner(lb, k)); | |
129 } | |
130 # endif | |
131 if (kind -> ok_reclaim_list == 0) { | |
132 if (!GC_alloc_reclaim_list(kind)) goto out; | |
133 } | |
134 op = GC_allocobj(lw, k); | |
135 if (op == 0) goto out; | |
136 } | |
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. */ | |
148 *opp = obj_link(op); | |
149 obj_link(op) = 0; | |
150 } else { | |
151 lw = ROUNDED_UP_WORDS(lb); | |
152 op = (ptr_t)GC_alloc_large_and_clear(lw, k, 0); | |
153 } | |
154 GC_words_allocd += lw; | |
155 | |
156 out: | |
157 return op; | |
158 } | |
159 | |
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) | |
164 register size_t lb; | |
165 register int k; | |
166 { | |
167 register word lw; | |
168 ptr_t op; | |
169 | |
170 if (lb <= HBLKSIZE) | |
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; | |
175 return op; | |
176 } | |
177 | |
178 ptr_t GC_generic_malloc(lb, k) | |
179 register word lb; | |
180 register int k; | |
181 { | |
182 ptr_t result; | |
183 DCL_LOCK_STATE; | |
184 | |
185 if (GC_have_errors) GC_print_all_errors(); | |
186 GC_INVOKE_FINALIZERS(); | |
187 if (SMALL_OBJ(lb)) { | |
188 DISABLE_SIGNALS(); | |
189 LOCK(); | |
190 result = GC_generic_malloc_inner((word)lb, k); | |
191 UNLOCK(); | |
192 ENABLE_SIGNALS(); | |
193 } else { | |
194 word lw; | |
195 word n_blocks; | |
196 GC_bool init; | |
197 lw = ROUNDED_UP_WORDS(lb); | |
198 n_blocks = OBJ_SZ_TO_BLOCKS(lw); | |
199 init = GC_obj_kinds[k].ok_init; | |
200 DISABLE_SIGNALS(); | |
201 LOCK(); | |
202 result = (ptr_t)GC_alloc_large(lw, k, 0); | |
203 if (0 != result) { | |
204 if (GC_debugging_started) { | |
205 BZERO(result, n_blocks * HBLKSIZE); | |
206 } else { | |
207 # ifdef THREADS | |
208 /* Clear any memory that might be used for GC descriptors */ | |
209 /* before we release the lock. */ | |
210 ((word *)result)[0] = 0; | |
211 ((word *)result)[1] = 0; | |
212 ((word *)result)[lw-1] = 0; | |
213 ((word *)result)[lw-2] = 0; | |
214 # endif | |
215 } | |
216 } | |
217 GC_words_allocd += lw; | |
218 UNLOCK(); | |
219 ENABLE_SIGNALS(); | |
220 if (init & !GC_debugging_started && 0 != result) { | |
221 BZERO(result, n_blocks * HBLKSIZE); | |
222 } | |
223 } | |
224 if (0 == result) { | |
225 return((*GC_oom_fn)(lb)); | |
226 } else { | |
227 return(result); | |
228 } | |
229 } | |
230 | |
231 | |
232 #define GENERAL_MALLOC(lb,k) \ | |
233 (GC_PTR)GC_clear_stack(GC_generic_malloc((word)lb, k)) | |
234 /* We make the GC_clear_stack_call a tail call, hoping to get more of */ | |
235 /* the stack. */ | |
236 | |
237 /* Allocate lb bytes of atomic (pointerfree) data */ | |
238 # ifdef __STDC__ | |
239 GC_PTR GC_malloc_atomic(size_t lb) | |
240 # else | |
241 GC_PTR GC_malloc_atomic(lb) | |
242 size_t lb; | |
243 # endif | |
244 { | |
245 register ptr_t op; | |
246 register ptr_t * opp; | |
247 register word lw; | |
248 DCL_LOCK_STATE; | |
249 | |
250 if( EXPECT(SMALL_OBJ(lb), 1) ) { | |
251 # ifdef MERGE_SIZES | |
252 lw = GC_size_map[lb]; | |
253 # else | |
254 lw = ALIGNED_WORDS(lb); | |
255 # endif | |
256 opp = &(GC_aobjfreelist[lw]); | |
257 FASTLOCK(); | |
258 if( EXPECT(!FASTLOCK_SUCCEEDED() || (op = *opp) == 0, 0) ) { | |
259 FASTUNLOCK(); | |
260 return(GENERAL_MALLOC((word)lb, PTRFREE)); | |
261 } | |
262 /* See above comment on signals. */ | |
263 *opp = obj_link(op); | |
264 GC_words_allocd += lw; | |
265 FASTUNLOCK(); | |
266 return((GC_PTR) op); | |
267 } else { | |
268 return(GENERAL_MALLOC((word)lb, PTRFREE)); | |
269 } | |
270 } | |
271 | |
272 /* Allocate lb bytes of composite (pointerful) data */ | |
273 # ifdef __STDC__ | |
274 GC_PTR GC_malloc(size_t lb) | |
275 # else | |
276 GC_PTR GC_malloc(lb) | |
277 size_t lb; | |
278 # endif | |
279 { | |
280 register ptr_t op; | |
281 register ptr_t *opp; | |
282 register word lw; | |
283 DCL_LOCK_STATE; | |
284 | |
285 if( EXPECT(SMALL_OBJ(lb), 1) ) { | |
286 # ifdef MERGE_SIZES | |
287 lw = GC_size_map[lb]; | |
288 # else | |
289 lw = ALIGNED_WORDS(lb); | |
290 # endif | |
291 opp = &(GC_objfreelist[lw]); | |
292 FASTLOCK(); | |
293 if( EXPECT(!FASTLOCK_SUCCEEDED() || (op = *opp) == 0, 0) ) { | |
294 FASTUNLOCK(); | |
295 return(GENERAL_MALLOC((word)lb, NORMAL)); | |
296 } | |
297 /* See above comment on signals. */ | |
298 GC_ASSERT(0 == obj_link(op) | |
299 || (word)obj_link(op) | |
300 <= (word)GC_greatest_plausible_heap_addr | |
301 && (word)obj_link(op) | |
302 >= (word)GC_least_plausible_heap_addr); | |
303 *opp = obj_link(op); | |
304 obj_link(op) = 0; | |
305 GC_words_allocd += lw; | |
306 FASTUNLOCK(); | |
307 return((GC_PTR) op); | |
308 } else { | |
309 return(GENERAL_MALLOC((word)lb, NORMAL)); | |
310 } | |
311 } | |
312 | |
313 # ifdef REDIRECT_MALLOC | |
314 # ifdef __STDC__ | |
315 GC_PTR malloc(size_t lb) | |
316 # else | |
317 GC_PTR malloc(lb) | |
318 size_t lb; | |
319 # endif | |
320 { | |
321 /* It might help to manually inline the GC_malloc call here. */ | |
322 /* But any decent compiler should reduce the extra procedure call */ | |
323 /* to at most a jump instruction in this case. */ | |
324 # if defined(I386) && defined(GC_SOLARIS_THREADS) | |
325 /* | |
326 * Thread initialisation can call malloc before | |
327 * we're ready for it. | |
328 * It's not clear that this is enough to help matters. | |
329 * The thread implementation may well call malloc at other | |
330 * inopportune times. | |
331 */ | |
332 if (!GC_is_initialized) return sbrk(lb); | |
333 # endif /* I386 && GC_SOLARIS_THREADS */ | |
334 return((GC_PTR)REDIRECT_MALLOC(lb)); | |
335 } | |
336 | |
337 # ifdef __STDC__ | |
338 GC_PTR calloc(size_t n, size_t lb) | |
339 # else | |
340 GC_PTR calloc(n, lb) | |
341 size_t n, lb; | |
342 # endif | |
343 { | |
344 return((GC_PTR)REDIRECT_MALLOC(n*lb)); | |
345 } | |
346 | |
347 #ifndef strdup | |
348 # include <string.h> | |
349 # ifdef __STDC__ | |
350 char *strdup(const char *s) | |
351 # else | |
352 char *strdup(s) | |
353 char *s; | |
354 # endif | |
355 { | |
356 size_t len = strlen(s) + 1; | |
357 char * result = ((char *)REDIRECT_MALLOC(len+1)); | |
358 BCOPY(s, result, len+1); | |
359 return result; | |
360 } | |
361 #endif /* !defined(strdup) */ | |
362 /* If strdup is macro defined, we assume that it actually calls malloc, */ | |
363 /* and thus the right thing will happen even without overriding it. */ | |
364 /* This seems to be true on most Linux systems. */ | |
365 | |
366 # endif /* REDIRECT_MALLOC */ | |
367 | |
368 /* Explicitly deallocate an object p. */ | |
369 # ifdef __STDC__ | |
370 void GC_free(GC_PTR p) | |
371 # else | |
372 void GC_free(p) | |
373 GC_PTR p; | |
374 # endif | |
375 { | |
376 register struct hblk *h; | |
377 register hdr *hhdr; | |
378 register signed_word sz; | |
379 register ptr_t * flh; | |
380 register int knd; | |
381 register struct obj_kind * ok; | |
382 DCL_LOCK_STATE; | |
383 | |
384 if (p == 0) return; | |
385 /* Required by ANSI. It's not my fault ... */ | |
386 h = HBLKPTR(p); | |
387 hhdr = HDR(h); | |
388 GC_ASSERT(GC_base(p) == p); | |
389 # if defined(REDIRECT_MALLOC) && \ | |
390 (defined(GC_SOLARIS_THREADS) || defined(GC_LINUX_THREADS) \ | |
391 || defined(__MINGW32__)) /* Should this be MSWIN32 in general? */ | |
392 /* For Solaris, we have to redirect malloc calls during */ | |
393 /* initialization. For the others, this seems to happen */ | |
394 /* implicitly. */ | |
395 /* Don't try to deallocate that memory. */ | |
396 if (0 == hhdr) return; | |
397 # endif | |
398 knd = hhdr -> hb_obj_kind; | |
399 sz = hhdr -> hb_sz; | |
400 ok = &GC_obj_kinds[knd]; | |
401 if (EXPECT((sz <= MAXOBJSZ), 1)) { | |
402 # ifdef THREADS | |
403 DISABLE_SIGNALS(); | |
404 LOCK(); | |
405 # endif | |
406 GC_mem_freed += sz; | |
407 /* A signal here can make GC_mem_freed and GC_non_gc_bytes */ | |
408 /* inconsistent. We claim this is benign. */ | |
409 if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz); | |
410 /* Its unnecessary to clear the mark bit. If the */ | |
411 /* object is reallocated, it doesn't matter. O.w. the */ | |
412 /* collector will do it, since it's on a free list. */ | |
413 if (ok -> ok_init) { | |
414 BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1)); | |
415 } | |
416 flh = &(ok -> ok_freelist[sz]); | |
417 obj_link(p) = *flh; | |
418 *flh = (ptr_t)p; | |
419 # ifdef THREADS | |
420 UNLOCK(); | |
421 ENABLE_SIGNALS(); | |
422 # endif | |
423 } else { | |
424 DISABLE_SIGNALS(); | |
425 LOCK(); | |
426 GC_mem_freed += sz; | |
427 if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz); | |
428 GC_freehblk(h); | |
429 UNLOCK(); | |
430 ENABLE_SIGNALS(); | |
431 } | |
432 } | |
433 | |
434 /* Explicitly deallocate an object p when we already hold lock. */ | |
435 /* Only used for internally allocated objects, so we can take some */ | |
436 /* shortcuts. */ | |
437 #ifdef THREADS | |
438 void GC_free_inner(GC_PTR p) | |
439 { | |
440 register struct hblk *h; | |
441 register hdr *hhdr; | |
442 register signed_word sz; | |
443 register ptr_t * flh; | |
444 register int knd; | |
445 register struct obj_kind * ok; | |
446 DCL_LOCK_STATE; | |
447 | |
448 h = HBLKPTR(p); | |
449 hhdr = HDR(h); | |
450 knd = hhdr -> hb_obj_kind; | |
451 sz = hhdr -> hb_sz; | |
452 ok = &GC_obj_kinds[knd]; | |
453 if (sz <= MAXOBJSZ) { | |
454 GC_mem_freed += sz; | |
455 if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz); | |
456 if (ok -> ok_init) { | |
457 BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1)); | |
458 } | |
459 flh = &(ok -> ok_freelist[sz]); | |
460 obj_link(p) = *flh; | |
461 *flh = (ptr_t)p; | |
462 } else { | |
463 GC_mem_freed += sz; | |
464 if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz); | |
465 GC_freehblk(h); | |
466 } | |
467 } | |
468 #endif /* THREADS */ | |
469 | |
470 # if defined(REDIRECT_MALLOC) && !defined(REDIRECT_FREE) | |
471 # define REDIRECT_FREE GC_free | |
472 # endif | |
473 # ifdef REDIRECT_FREE | |
474 # ifdef __STDC__ | |
475 void free(GC_PTR p) | |
476 # else | |
477 void free(p) | |
478 GC_PTR p; | |
479 # endif | |
480 { | |
481 # ifndef IGNORE_FREE | |
482 REDIRECT_FREE(p); | |
483 # endif | |
484 } | |
485 # endif /* REDIRECT_MALLOC */ |