+++ /dev/null
-/*
- * 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;
-
- 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));
- }
-
-# include <string.h>
-# ifdef __STDC__
- char *strdup(const char *s)
-# else
- char *strdup(s)
- char *s;
-# endif
- {
- size_t len = strlen + 1;
- char * result = ((char *)REDIRECT_MALLOC(len+1));
- BCOPY(s, result, len+1);
- return result;
- }
-# 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 */
projects / msp430-gcc.git / blobdiff