diff options
Diffstat (limited to 'gc/malloc.c')
| -rw-r--r-- | gc/malloc.c | 476 |
1 files changed, 0 insertions, 476 deletions
diff --git a/gc/malloc.c b/gc/malloc.c deleted file mode 100644 index e2db9b4..0000000 --- a/gc/malloc.c +++ /dev/null @@ -1,476 +0,0 @@ -/* - * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers - * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. - * Copyright (c) 2000 by Hewlett-Packard Company. All rights reserved. - * - * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED - * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. - * - * Permission is hereby granted to use or copy this program - * for any purpose, provided the above notices are retained on all copies. - * Permission to modify the code and to distribute modified code is granted, - * provided the above notices are retained, and a notice that the code was - * modified is included with the above copyright notice. - */ -/* Boehm, February 7, 1996 4:32 pm PST */ - -#include <stdio.h> -#include "private/gc_priv.h" - -extern ptr_t GC_clear_stack(); /* in misc.c, behaves like identity */ -void GC_extend_size_map(); /* in misc.c. */ - -/* Allocate reclaim list for kind: */ -/* Return TRUE on success */ -GC_bool GC_alloc_reclaim_list(kind) -register struct obj_kind * kind; -{ - struct hblk ** result = (struct hblk **) - GC_scratch_alloc((MAXOBJSZ+1) * sizeof(struct hblk *)); - if (result == 0) return(FALSE); - BZERO(result, (MAXOBJSZ+1)*sizeof(struct hblk *)); - kind -> ok_reclaim_list = result; - return(TRUE); -} - -/* Allocate a large block of size lw words. */ -/* The block is not cleared. */ -/* Flags is 0 or IGNORE_OFF_PAGE. */ -ptr_t GC_alloc_large(lw, k, flags) -word lw; -int k; -unsigned flags; -{ - struct hblk * h; - word n_blocks = OBJ_SZ_TO_BLOCKS(lw); - ptr_t result; - - if (!GC_is_initialized) GC_init_inner(); - /* Do our share of marking work */ - if(GC_incremental && !GC_dont_gc) - GC_collect_a_little_inner((int)n_blocks); - h = GC_allochblk(lw, k, flags); -# ifdef USE_MUNMAP - if (0 == h) { - GC_merge_unmapped(); - h = GC_allochblk(lw, k, flags); - } -# endif - while (0 == h && GC_collect_or_expand(n_blocks, (flags != 0))) { - h = GC_allochblk(lw, k, flags); - } - if (h == 0) { - result = 0; - } else { - int total_bytes = BYTES_TO_WORDS(n_blocks * HBLKSIZE); - if (n_blocks > 1) { - GC_large_allocd_bytes += n_blocks * HBLKSIZE; - if (GC_large_allocd_bytes > GC_max_large_allocd_bytes) - GC_max_large_allocd_bytes = GC_large_allocd_bytes; - } - result = (ptr_t) (h -> hb_body); - GC_words_wasted += total_bytes - lw; - } - return result; -} - - -/* Allocate a large block of size lb bytes. Clear if appropriate. */ -ptr_t GC_alloc_large_and_clear(lw, k, flags) -word lw; -int k; -unsigned flags; -{ - ptr_t result = GC_alloc_large(lw, k, flags); - word n_blocks = OBJ_SZ_TO_BLOCKS(lw); - - if (0 == result) return 0; - if (GC_debugging_started || GC_obj_kinds[k].ok_init) { - /* Clear the whole block, in case of GC_realloc call. */ - BZERO(result, n_blocks * HBLKSIZE); - } - return result; -} - -/* allocate lb bytes for an object of kind k. */ -/* Should not be used to directly to allocate */ -/* objects such as STUBBORN objects that */ -/* require special handling on allocation. */ -/* First a version that assumes we already */ -/* hold lock: */ -ptr_t GC_generic_malloc_inner(lb, k) -register word lb; -register int k; -{ -register word lw; -register ptr_t op; -register ptr_t *opp; - - if( SMALL_OBJ(lb) ) { - register struct obj_kind * kind = GC_obj_kinds + k; -# ifdef MERGE_SIZES - lw = GC_size_map[lb]; -# else - lw = ALIGNED_WORDS(lb); - if (lw == 0) lw = MIN_WORDS; -# endif - opp = &(kind -> ok_freelist[lw]); - if( (op = *opp) == 0 ) { -# ifdef MERGE_SIZES - if (GC_size_map[lb] == 0) { - if (!GC_is_initialized) GC_init_inner(); - if (GC_size_map[lb] == 0) GC_extend_size_map(lb); - return(GC_generic_malloc_inner(lb, k)); - } -# else - if (!GC_is_initialized) { - GC_init_inner(); - return(GC_generic_malloc_inner(lb, k)); - } -# endif - if (kind -> ok_reclaim_list == 0) { - if (!GC_alloc_reclaim_list(kind)) goto out; - } - op = GC_allocobj(lw, k); - if (op == 0) goto out; - } - /* Here everything is in a consistent state. */ - /* We assume the following assignment is */ - /* atomic. If we get aborted */ - /* after the assignment, we lose an object, */ - /* but that's benign. */ - /* Volatile declarations may need to be added */ - /* to prevent the compiler from breaking things.*/ - /* If we only execute the second of the */ - /* following assignments, we lose the free */ - /* list, but that should still be OK, at least */ - /* for garbage collected memory. */ - *opp = obj_link(op); - obj_link(op) = 0; - } else { - lw = ROUNDED_UP_WORDS(lb); - op = (ptr_t)GC_alloc_large_and_clear(lw, k, 0); - } - GC_words_allocd += lw; - -out: - return op; -} - -/* Allocate a composite object of size n bytes. The caller guarantees */ -/* that pointers past the first page are not relevant. Caller holds */ -/* allocation lock. */ -ptr_t GC_generic_malloc_inner_ignore_off_page(lb, k) -register size_t lb; -register int k; -{ - register word lw; - ptr_t op; - - if (lb <= HBLKSIZE) - return(GC_generic_malloc_inner((word)lb, k)); - lw = ROUNDED_UP_WORDS(lb); - op = (ptr_t)GC_alloc_large_and_clear(lw, k, IGNORE_OFF_PAGE); - GC_words_allocd += lw; - return op; -} - -ptr_t GC_generic_malloc(lb, k) -register word lb; -register int k; -{ - ptr_t result; - DCL_LOCK_STATE; - - if (GC_debugging_started) GC_print_all_smashed(); - GC_INVOKE_FINALIZERS(); - if (SMALL_OBJ(lb)) { - DISABLE_SIGNALS(); - LOCK(); - result = GC_generic_malloc_inner((word)lb, k); - UNLOCK(); - ENABLE_SIGNALS(); - } else { - word lw; - word n_blocks; - GC_bool init; - lw = ROUNDED_UP_WORDS(lb); - n_blocks = OBJ_SZ_TO_BLOCKS(lw); - init = GC_obj_kinds[k].ok_init; - DISABLE_SIGNALS(); - LOCK(); - result = (ptr_t)GC_alloc_large(lw, k, 0); - if (0 != result) { - if (GC_debugging_started) { - BZERO(result, n_blocks * HBLKSIZE); - } else { -# ifdef THREADS - /* Clear any memory that might be used for GC descriptors */ - /* before we release the lock. */ - ((word *)result)[0] = 0; - ((word *)result)[1] = 0; - ((word *)result)[lw-1] = 0; - ((word *)result)[lw-2] = 0; -# endif - } - } - GC_words_allocd += lw; - UNLOCK(); - ENABLE_SIGNALS(); - if (init & !GC_debugging_started && 0 != result) { - BZERO(result, n_blocks * HBLKSIZE); - } - } - if (0 == result) { - return((*GC_oom_fn)(lb)); - } else { - return(result); - } -} - - -#define GENERAL_MALLOC(lb,k) \ - (GC_PTR)GC_clear_stack(GC_generic_malloc((word)lb, k)) -/* We make the GC_clear_stack_call a tail call, hoping to get more of */ -/* the stack. */ - -/* Allocate lb bytes of atomic (pointerfree) data */ -# ifdef __STDC__ - GC_PTR GC_malloc_atomic(size_t lb) -# else - GC_PTR GC_malloc_atomic(lb) - size_t lb; -# endif -{ -register ptr_t op; -register ptr_t * opp; -register word lw; -DCL_LOCK_STATE; - - if( EXPECT(SMALL_OBJ(lb), 1) ) { -# ifdef MERGE_SIZES - lw = GC_size_map[lb]; -# else - lw = ALIGNED_WORDS(lb); -# endif - opp = &(GC_aobjfreelist[lw]); - FASTLOCK(); - if( EXPECT(!FASTLOCK_SUCCEEDED() || (op = *opp) == 0, 0) ) { - FASTUNLOCK(); - return(GENERAL_MALLOC((word)lb, PTRFREE)); - } - /* See above comment on signals. */ - *opp = obj_link(op); - GC_words_allocd += lw; - FASTUNLOCK(); - return((GC_PTR) op); - } else { - return(GENERAL_MALLOC((word)lb, PTRFREE)); - } -} - -/* Allocate lb bytes of composite (pointerful) data */ -# ifdef __STDC__ - GC_PTR GC_malloc(size_t lb) -# else - GC_PTR GC_malloc(lb) - size_t lb; -# endif -{ -register ptr_t op; -register ptr_t *opp; -register word lw; -DCL_LOCK_STATE; - - if( EXPECT(SMALL_OBJ(lb), 1) ) { -# ifdef MERGE_SIZES - lw = GC_size_map[lb]; -# else - lw = ALIGNED_WORDS(lb); -# endif - opp = &(GC_objfreelist[lw]); - FASTLOCK(); - if( EXPECT(!FASTLOCK_SUCCEEDED() || (op = *opp) == 0, 0) ) { - FASTUNLOCK(); - return(GENERAL_MALLOC((word)lb, NORMAL)); - } - /* See above comment on signals. */ - *opp = obj_link(op); - obj_link(op) = 0; - GC_words_allocd += lw; - FASTUNLOCK(); - return((GC_PTR) op); - } else { - return(GENERAL_MALLOC((word)lb, NORMAL)); - } -} - -# ifdef REDIRECT_MALLOC -# ifdef __STDC__ - GC_PTR malloc(size_t lb) -# else - GC_PTR malloc(lb) - size_t lb; -# endif - { - /* It might help to manually inline the GC_malloc call here. */ - /* But any decent compiler should reduce the extra procedure call */ - /* to at most a jump instruction in this case. */ -# if defined(I386) && defined(GC_SOLARIS_THREADS) - /* - * Thread initialisation can call malloc before - * we're ready for it. - * It's not clear that this is enough to help matters. - * The thread implementation may well call malloc at other - * inopportune times. - */ - if (!GC_is_initialized) return sbrk(lb); -# endif /* I386 && GC_SOLARIS_THREADS */ - return((GC_PTR)REDIRECT_MALLOC(lb)); - } - -# ifdef __STDC__ - GC_PTR calloc(size_t n, size_t lb) -# else - GC_PTR calloc(n, lb) - size_t n, lb; -# endif - { - return((GC_PTR)REDIRECT_MALLOC(n*lb)); - } - -#ifndef strdup -# include <string.h> -# ifdef __STDC__ - char *strdup(const char *s) -# else - char *strdup(s) - char *s; -# endif - { - size_t len = strlen(s) + 1; - char * result = ((char *)REDIRECT_MALLOC(len+1)); - BCOPY(s, result, len+1); - return result; - } -#endif /* !defined(strdup) */ - /* If strdup is macro defined, we assume that it actually calls malloc, */ - /* and thus the right thing will happen even without overriding it. */ - /* This seems to be true on most Linux systems. */ - -# endif /* REDIRECT_MALLOC */ - -/* Explicitly deallocate an object p. */ -# ifdef __STDC__ - void GC_free(GC_PTR p) -# else - void GC_free(p) - GC_PTR p; -# endif -{ - register struct hblk *h; - register hdr *hhdr; - register signed_word sz; - register ptr_t * flh; - register int knd; - register struct obj_kind * ok; - DCL_LOCK_STATE; - - if (p == 0) return; - /* Required by ANSI. It's not my fault ... */ - h = HBLKPTR(p); - hhdr = HDR(h); -# if defined(REDIRECT_MALLOC) && \ - (defined(GC_SOLARIS_THREADS) || defined(GC_LINUX_THREADS) \ - || defined(__MINGW32__)) /* Should this be MSWIN32 in general? */ - /* For Solaris, we have to redirect malloc calls during */ - /* initialization. For the others, this seems to happen */ - /* implicitly. */ - /* Don't try to deallocate that memory. */ - if (0 == hhdr) return; -# endif - knd = hhdr -> hb_obj_kind; - sz = hhdr -> hb_sz; - ok = &GC_obj_kinds[knd]; - if (EXPECT((sz <= MAXOBJSZ), 1)) { -# ifdef THREADS - DISABLE_SIGNALS(); - LOCK(); -# endif - GC_mem_freed += sz; - /* A signal here can make GC_mem_freed and GC_non_gc_bytes */ - /* inconsistent. We claim this is benign. */ - if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz); - /* Its unnecessary to clear the mark bit. If the */ - /* object is reallocated, it doesn't matter. O.w. the */ - /* collector will do it, since it's on a free list. */ - if (ok -> ok_init) { - BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1)); - } - flh = &(ok -> ok_freelist[sz]); - obj_link(p) = *flh; - *flh = (ptr_t)p; -# ifdef THREADS - UNLOCK(); - ENABLE_SIGNALS(); -# endif - } else { - DISABLE_SIGNALS(); - LOCK(); - GC_mem_freed += sz; - if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz); - GC_freehblk(h); - UNLOCK(); - ENABLE_SIGNALS(); - } -} - -/* Explicitly deallocate an object p when we already hold lock. */ -/* Only used for internally allocated objects, so we can take some */ -/* shortcuts. */ -#ifdef THREADS -void GC_free_inner(GC_PTR p) -{ - register struct hblk *h; - register hdr *hhdr; - register signed_word sz; - register ptr_t * flh; - register int knd; - register struct obj_kind * ok; - DCL_LOCK_STATE; - - h = HBLKPTR(p); - hhdr = HDR(h); - knd = hhdr -> hb_obj_kind; - sz = hhdr -> hb_sz; - ok = &GC_obj_kinds[knd]; - if (sz <= MAXOBJSZ) { - GC_mem_freed += sz; - if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz); - if (ok -> ok_init) { - BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1)); - } - flh = &(ok -> ok_freelist[sz]); - obj_link(p) = *flh; - *flh = (ptr_t)p; - } else { - GC_mem_freed += sz; - if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz); - GC_freehblk(h); - } -} -#endif /* THREADS */ - -# ifdef REDIRECT_MALLOC -# ifdef __STDC__ - void free(GC_PTR p) -# else - void free(p) - GC_PTR p; -# endif - { -# ifndef IGNORE_FREE - GC_free(p); -# endif - } -# endif /* REDIRECT_MALLOC */ |