remove gc

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