[gcc.git] / boehm-gc / malloc.c

/* 
 * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
 * Copyright (c) 1991-1994 by Xerox Corporation.  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 "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 lb bytes for an object of kind.	*/
/* 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 = 1;
#       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.*/
        *opp = obj_link(op);
        obj_link(op) = 0;
    } else {
	register struct hblk * h;
	register word n_blocks = divHBLKSZ(ADD_SLOP(lb)
					   + HDR_BYTES + HBLKSIZE-1);
	
	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);
	lw = ROUNDED_UP_WORDS(lb);
        h = GC_allochblk(lw, k, 0);
#       ifdef USE_MUNMAP
	  if (0 == h) {
	    GC_merge_unmapped();
	    h = GC_allochblk(lw, k, 0);
	  }
#	endif
	while (0 == h && GC_collect_or_expand(n_blocks, FALSE)) {
	  h = GC_allochblk(lw, k, 0);
	}
	if (h == 0) {
	    op = 0;
	} else {
	    op = (ptr_t) (h -> hb_body);
	    GC_words_wasted += BYTES_TO_WORDS(n_blocks * HBLKSIZE) - lw;
	}
    }
    GC_words_allocd += lw;
    
out:
    return((ptr_t)op);
}

ptr_t GC_generic_malloc(lb, k)
register word lb;
register int k;
{
    ptr_t result;
    DCL_LOCK_STATE;

    GC_INVOKE_FINALIZERS();
    DISABLE_SIGNALS();
    LOCK();
    result = GC_generic_malloc_inner(lb, k);
    UNLOCK();
    ENABLE_SIGNALS();
    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( SMALL_OBJ(lb) ) {
#       ifdef MERGE_SIZES
	  lw = GC_size_map[lb];
#	else
	  lw = ALIGNED_WORDS(lb);
#       endif
	opp = &(GC_aobjfreelist[lw]);
	FASTLOCK();
        if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 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( SMALL_OBJ(lb) ) {
#       ifdef MERGE_SIZES
	  lw = GC_size_map[lb];
#	else
	  lw = ALIGNED_WORDS(lb);
#       endif
	opp = &(GC_objfreelist[lw]);
	FASTLOCK();
        if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 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(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 && SOLARIS_THREADS */
    return(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(REDIRECT_MALLOC(n*lb));
  }
# endif /* REDIRECT_MALLOC */

GC_PTR GC_generic_or_special_malloc(lb,knd)
word lb;
int knd;
{
    switch(knd) {
#     ifdef STUBBORN_ALLOC
	case STUBBORN:
	    return(GC_malloc_stubborn((size_t)lb));
#     endif
	case PTRFREE:
	    return(GC_malloc_atomic((size_t)lb));
	case NORMAL:
	    return(GC_malloc((size_t)lb));
	case UNCOLLECTABLE:
	    return(GC_malloc_uncollectable((size_t)lb));
#       ifdef ATOMIC_UNCOLLECTABLE
	  case AUNCOLLECTABLE:
	    return(GC_malloc_atomic_uncollectable((size_t)lb));
#	endif /* ATOMIC_UNCOLLECTABLE */
	default:
	    return(GC_generic_malloc(lb,knd));
    }
}


/* Change the size of the block pointed to by p to contain at least   */
/* lb bytes.  The object may be (and quite likely will be) moved.     */
/* The kind (e.g. atomic) is the same as that of the old.	      */
/* Shrinking of large blocks is not implemented well.                 */
# ifdef __STDC__
    GC_PTR GC_realloc(GC_PTR p, size_t lb)
# else
    GC_PTR GC_realloc(p,lb)
    GC_PTR p;
    size_t lb;
# endif
{
register struct hblk * h;
register hdr * hhdr;
register word sz;	 /* Current size in bytes	*/
register word orig_sz;	 /* Original sz in bytes	*/
int obj_kind;

    if (p == 0) return(GC_malloc(lb));	/* Required by ANSI */
    h = HBLKPTR(p);
    hhdr = HDR(h);
    sz = hhdr -> hb_sz;
    obj_kind = hhdr -> hb_obj_kind;
    sz = WORDS_TO_BYTES(sz);
    orig_sz = sz;

    if (sz > WORDS_TO_BYTES(MAXOBJSZ)) {
	/* Round it up to the next whole heap block */
	  register word descr;
	  
	  sz = (sz+HDR_BYTES+HBLKSIZE-1)
		& (~HBLKMASK);
	  sz -= HDR_BYTES;
	  hhdr -> hb_sz = BYTES_TO_WORDS(sz);
	  descr = GC_obj_kinds[obj_kind].ok_descriptor;
          if (GC_obj_kinds[obj_kind].ok_relocate_descr) descr += sz;
          hhdr -> hb_descr = descr;
	  if (IS_UNCOLLECTABLE(obj_kind)) GC_non_gc_bytes += (sz - orig_sz);
	  /* Extra area is already cleared by allochblk. */
    }
    if (ADD_SLOP(lb) <= sz) {
	if (lb >= (sz >> 1)) {
#	    ifdef STUBBORN_ALLOC
	        if (obj_kind == STUBBORN) GC_change_stubborn(p);
#	    endif
	    if (orig_sz > lb) {
	      /* Clear unneeded part of object to avoid bogus pointer */
	      /* tracing.					      */
	      /* Safe for stubborn objects.			      */
	        BZERO(((ptr_t)p) + lb, orig_sz - lb);
	    }
	    return(p);
	} else {
	    /* shrink */
	      GC_PTR result =
	      		GC_generic_or_special_malloc((word)lb, obj_kind);

	      if (result == 0) return(0);
	          /* Could also return original object.  But this 	*/
	          /* gives the client warning of imminent disaster.	*/
	      BCOPY(p, result, lb);
#	      ifndef IGNORE_FREE
	        GC_free(p);
#	      endif
	      return(result);
	}
    } else {
	/* grow */
	  GC_PTR result =
	  	GC_generic_or_special_malloc((word)lb, obj_kind);

	  if (result == 0) return(0);
	  BCOPY(p, result, sz);
#	  ifndef IGNORE_FREE
	    GC_free(p);
#	  endif
	  return(result);
    }
}

# ifdef REDIRECT_MALLOC
# ifdef __STDC__
    GC_PTR realloc(GC_PTR p, size_t lb)
# else
    GC_PTR realloc(p,lb)
    GC_PTR p;
    size_t lb;
# endif
  {
    return(GC_realloc(p, lb));
  }
# 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(SOLARIS_THREADS) || defined(LINUX_THREADS))
	/* We have to redirect malloc calls during initialization.	*/
	/* 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 (sz <= MAXOBJSZ) {
#	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();
    }
}

# 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 */
Commit	Line	Data
73ffefd0 TT	1	/*
	2	* Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
	3	* Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
	4	*
	5	* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
	6	* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
	7	*
	8	* Permission is hereby granted to use or copy this program
	9	* for any purpose, provided the above notices are retained on all copies.
	10	* Permission to modify the code and to distribute modified code is granted,
	11	* provided the above notices are retained, and a notice that the code was
	12	* modified is included with the above copyright notice.
	13	*/
	14	/* Boehm, February 7, 1996 4:32 pm PST */
	15
	16	#include <stdio.h>
	17	#include "gc_priv.h"
	18
	19	extern ptr_t GC_clear_stack(); /* in misc.c, behaves like identity */
	20	void GC_extend_size_map(); /* in misc.c. */
	21
	22	/* Allocate reclaim list for kind: */
	23	/* Return TRUE on success */
	24	GC_bool GC_alloc_reclaim_list(kind)
	25	register struct obj_kind * kind;
	26	{
	27	struct hblk result = (struct hblk )
	28	GC_scratch_alloc((MAXOBJSZ+1) * sizeof(struct hblk *));
	29	if (result == 0) return(FALSE);
	30	BZERO(result, (MAXOBJSZ+1)sizeof(struct hblk ));
	31	kind -> ok_reclaim_list = result;
	32	return(TRUE);
	33	}
	34
	35	/* allocate lb bytes for an object of kind. */
	36	/* Should not be used to directly to allocate */
	37	/* objects such as STUBBORN objects that */
	38	/* require special handling on allocation. */
	39	/* First a version that assumes we already */
	40	/* hold lock: */
	41	ptr_t GC_generic_malloc_inner(lb, k)
	42	register word lb;
	43	register int k;
	44	{
	45	register word lw;
	46	register ptr_t op;
	47	register ptr_t *opp;
	48
	49	if( SMALL_OBJ(lb) ) {
	50	register struct obj_kind * kind = GC_obj_kinds + k;
	51	# ifdef MERGE_SIZES
	52	lw = GC_size_map[lb];
	53	# else
	54	lw = ALIGNED_WORDS(lb);
	55	if (lw == 0) lw = 1;
	56	# endif
	57	opp = &(kind -> ok_freelist[lw]);
	58	if( (op = *opp) == 0 ) {
	59	# ifdef MERGE_SIZES
	60	if (GC_size_map[lb] == 0) {
	61	if (!GC_is_initialized) GC_init_inner();
	62	if (GC_size_map[lb] == 0) GC_extend_size_map(lb);
	63	return(GC_generic_malloc_inner(lb, k));
	64	}
65	# else
66	if (!GC_is_initialized) {
67	GC_init_inner();
68	return(GC_generic_malloc_inner(lb, k));
69	}
70	# endif
71	if (kind -> ok_reclaim_list == 0) {
72	if (!GC_alloc_reclaim_list(kind)) goto out;
73	}
74	op = GC_allocobj(lw, k);
75	if (op == 0) goto out;
76	}
77	/* Here everything is in a consistent state. */
78	/* We assume the following assignment is */
79	/* atomic. If we get aborted */
80	/* after the assignment, we lose an object, */
81	/* but that's benign. */
82	/* Volatile declarations may need to be added */
83	/* to prevent the compiler from breaking things.*/
84	*opp = obj_link(op);
85	obj_link(op) = 0;
86	} else {
87	register struct hblk * h;
88	register word n_blocks = divHBLKSZ(ADD_SLOP(lb)
89	+ HDR_BYTES + HBLKSIZE-1);
90
91	if (!GC_is_initialized) GC_init_inner();
92	/* Do our share of marking work */
93	if(GC_incremental && !GC_dont_gc)
94	GC_collect_a_little_inner((int)n_blocks);
95	lw = ROUNDED_UP_WORDS(lb);
20bbd3cd TT	96	h = GC_allochblk(lw, k, 0);
	97	# ifdef USE_MUNMAP
	98	if (0 == h) {
	99	GC_merge_unmapped();
	100	h = GC_allochblk(lw, k, 0);
	101	}
	102	# endif
	103	while (0 == h && GC_collect_or_expand(n_blocks, FALSE)) {
	104	h = GC_allochblk(lw, k, 0);
	105	}
73ffefd0 TT	106	if (h == 0) {
	107	op = 0;
	108	} else {
	109	op = (ptr_t) (h -> hb_body);
	110	GC_words_wasted += BYTES_TO_WORDS(n_blocks * HBLKSIZE) - lw;
	111	}
	112	}
	113	GC_words_allocd += lw;
	114
	115	out:
	116	return((ptr_t)op);
	117	}
	118
	119	ptr_t GC_generic_malloc(lb, k)
	120	register word lb;
	121	register int k;
	122	{
	123	ptr_t result;
	124	DCL_LOCK_STATE;
	125
	126	GC_INVOKE_FINALIZERS();
	127	DISABLE_SIGNALS();
	128	LOCK();
	129	result = GC_generic_malloc_inner(lb, k);
	130	UNLOCK();
	131	ENABLE_SIGNALS();
	132	if (0 == result) {
	133	return((*GC_oom_fn)(lb));
	134	} else {
	135	return(result);
	136	}
	137	}
	138
	139
	140	#define GENERAL_MALLOC(lb,k) \
	141	(GC_PTR)GC_clear_stack(GC_generic_malloc((word)lb, k))
	142	/* We make the GC_clear_stack_call a tail call, hoping to get more of */
	143	/* the stack. */
	144
	145	/* Allocate lb bytes of atomic (pointerfree) data */
	146	# ifdef __STDC__
	147	GC_PTR GC_malloc_atomic(size_t lb)
	148	# else
	149	GC_PTR GC_malloc_atomic(lb)
	150	size_t lb;
	151	# endif
	152	{
	153	register ptr_t op;
	154	register ptr_t * opp;
	155	register word lw;
	156	DCL_LOCK_STATE;
	157
	158	if( SMALL_OBJ(lb) ) {
	159	# ifdef MERGE_SIZES
	160	lw = GC_size_map[lb];
	161	# else
	162	lw = ALIGNED_WORDS(lb);
	163	# endif
	164	opp = &(GC_aobjfreelist[lw]);
	165	FASTLOCK();
	166	if( !FASTLOCK_SUCCEEDED() \|\| (op = *opp) == 0 ) {
	167	FASTUNLOCK();
	168	return(GENERAL_MALLOC((word)lb, PTRFREE));
	169	}
170	/* See above comment on signals. */
171	*opp = obj_link(op);
172	GC_words_allocd += lw;
173	FASTUNLOCK();
174	return((GC_PTR) op);
175	} else {
176	return(GENERAL_MALLOC((word)lb, PTRFREE));
177	}
178	}
179
180	/* Allocate lb bytes of composite (pointerful) data */
181	# ifdef __STDC__
182	GC_PTR GC_malloc(size_t lb)
183	# else
184	GC_PTR GC_malloc(lb)
185	size_t lb;
186	# endif
187	{
188	register ptr_t op;
189	register ptr_t *opp;
190	register word lw;
191	DCL_LOCK_STATE;
192
193	if( SMALL_OBJ(lb) ) {
194	# ifdef MERGE_SIZES
195	lw = GC_size_map[lb];
196	# else
197	lw = ALIGNED_WORDS(lb);
198	# endif
199	opp = &(GC_objfreelist[lw]);
200	FASTLOCK();
201	if( !FASTLOCK_SUCCEEDED() \|\| (op = *opp) == 0 ) {
202	FASTUNLOCK();
203	return(GENERAL_MALLOC((word)lb, NORMAL));
204	}
205	/* See above comment on signals. */
206	*opp = obj_link(op);
207	obj_link(op) = 0;
208	GC_words_allocd += lw;
209	FASTUNLOCK();
210	return((GC_PTR) op);
211	} else {
212	return(GENERAL_MALLOC((word)lb, NORMAL));
213	}
214	}
215
216	# ifdef REDIRECT_MALLOC
217	# ifdef __STDC__
218	GC_PTR malloc(size_t lb)
219	# else
220	GC_PTR malloc(lb)
221	size_t lb;
222	# endif
223	{
224	/* It might help to manually inline the GC_malloc call here. */
225	/* But any decent compiler should reduce the extra procedure call */
226	/* to at most a jump instruction in this case. */
227	# if defined(I386) && defined(SOLARIS_THREADS)
228	/*
229	* Thread initialisation can call malloc before
230	* we're ready for it.
20bbd3cd TT	231	* It's not clear that this is enough to help matters.
	232	* The thread implementation may well call malloc at other
	233	* inopportune times.
73ffefd0 TT	234	*/
	235	if (!GC_is_initialized) return sbrk(lb);
	236	# endif /* I386 && SOLARIS_THREADS */
	237	return(REDIRECT_MALLOC(lb));
	238	}
	239
	240	# ifdef __STDC__
	241	GC_PTR calloc(size_t n, size_t lb)
	242	# else
	243	GC_PTR calloc(n, lb)
	244	size_t n, lb;
	245	# endif
	246	{
	247	return(REDIRECT_MALLOC(n*lb));
	248	}
	249	# endif /* REDIRECT_MALLOC */
	250
	251	GC_PTR GC_generic_or_special_malloc(lb,knd)
	252	word lb;
	253	int knd;
	254	{
	255	switch(knd) {
	256	# ifdef STUBBORN_ALLOC
	257	case STUBBORN:
	258	return(GC_malloc_stubborn((size_t)lb));
	259	# endif
	260	case PTRFREE:
	261	return(GC_malloc_atomic((size_t)lb));
	262	case NORMAL:
	263	return(GC_malloc((size_t)lb));
	264	case UNCOLLECTABLE:
	265	return(GC_malloc_uncollectable((size_t)lb));
	266	# ifdef ATOMIC_UNCOLLECTABLE
	267	case AUNCOLLECTABLE:
	268	return(GC_malloc_atomic_uncollectable((size_t)lb));
	269	# endif /* ATOMIC_UNCOLLECTABLE */
	270	default:
	271	return(GC_generic_malloc(lb,knd));
	272	}
	273	}
	274
	275
	276	/* Change the size of the block pointed to by p to contain at least */
	277	/* lb bytes. The object may be (and quite likely will be) moved. */
	278	/* The kind (e.g. atomic) is the same as that of the old. */
	279	/* Shrinking of large blocks is not implemented well. */
	280	# ifdef __STDC__
	281	GC_PTR GC_realloc(GC_PTR p, size_t lb)
	282	# else
	283	GC_PTR GC_realloc(p,lb)
	284	GC_PTR p;
	285	size_t lb;
	286	# endif
	287	{
	288	register struct hblk * h;
	289	register hdr * hhdr;
	290	register word sz; /* Current size in bytes */
	291	register word orig_sz; /* Original sz in bytes */
	292	int obj_kind;
	293
	294	if (p == 0) return(GC_malloc(lb)); /* Required by ANSI */
	295	h = HBLKPTR(p);
	296	hhdr = HDR(h);
	297	sz = hhdr -> hb_sz;
298	obj_kind = hhdr -> hb_obj_kind;
299	sz = WORDS_TO_BYTES(sz);
300	orig_sz = sz;
301
302	if (sz > WORDS_TO_BYTES(MAXOBJSZ)) {
303	/* Round it up to the next whole heap block */
304	register word descr;
305
306	sz = (sz+HDR_BYTES+HBLKSIZE-1)
307	& (~HBLKMASK);
308	sz -= HDR_BYTES;
309	hhdr -> hb_sz = BYTES_TO_WORDS(sz);
310	descr = GC_obj_kinds[obj_kind].ok_descriptor;
311	if (GC_obj_kinds[obj_kind].ok_relocate_descr) descr += sz;
312	hhdr -> hb_descr = descr;
313	if (IS_UNCOLLECTABLE(obj_kind)) GC_non_gc_bytes += (sz - orig_sz);
314	/* Extra area is already cleared by allochblk. */
315	}
316	if (ADD_SLOP(lb) <= sz) {
317	if (lb >= (sz >> 1)) {
318	# ifdef STUBBORN_ALLOC
319	if (obj_kind == STUBBORN) GC_change_stubborn(p);
320	# endif
321	if (orig_sz > lb) {
322	/* Clear unneeded part of object to avoid bogus pointer */
323	/* tracing. */
324	/* Safe for stubborn objects. */
325	BZERO(((ptr_t)p) + lb, orig_sz - lb);
326	}
327	return(p);
328	} else {
329	/* shrink */
330	GC_PTR result =
331	GC_generic_or_special_malloc((word)lb, obj_kind);
332
333	if (result == 0) return(0);
334	/* Could also return original object. But this */
335	/* gives the client warning of imminent disaster. */
336	BCOPY(p, result, lb);
337	# ifndef IGNORE_FREE
338	GC_free(p);
339	# endif
340	return(result);
341	}
342	} else {
343	/* grow */
344	GC_PTR result =
345	GC_generic_or_special_malloc((word)lb, obj_kind);
346
347	if (result == 0) return(0);
348	BCOPY(p, result, sz);
349	# ifndef IGNORE_FREE
350	GC_free(p);
351	# endif
352	return(result);
353	}
354	}
355
356	# ifdef REDIRECT_MALLOC
357	# ifdef __STDC__
358	GC_PTR realloc(GC_PTR p, size_t lb)
359	# else
360	GC_PTR realloc(p,lb)
361	GC_PTR p;
362	size_t lb;
363	# endif
364	{
365	return(GC_realloc(p, lb));
366	}
367	# endif /* REDIRECT_MALLOC */
368
369	/* Explicitly deallocate an object p. */
370	# ifdef __STDC__
371	void GC_free(GC_PTR p)
372	# else
373	void GC_free(p)
374	GC_PTR p;
375	# endif
376	{
377	register struct hblk *h;
378	register hdr *hhdr;
379	register signed_word sz;
380	register ptr_t * flh;
381	register int knd;
382	register struct obj_kind * ok;
383	DCL_LOCK_STATE;
384
385	if (p == 0) return;
386	/* Required by ANSI. It's not my fault ... */
387	h = HBLKPTR(p);
388	hhdr = HDR(h);
20bbd3cd TT	389	# if defined(REDIRECT_MALLOC) && \
	390	(defined(SOLARIS_THREADS) \|\| defined(LINUX_THREADS))
	391	/* We have to redirect malloc calls during initialization. */
	392	/* Don't try to deallocate that memory. */
	393	if (0 == hhdr) return;
	394	# endif
73ffefd0 TT	395	knd = hhdr -> hb_obj_kind;
	396	sz = hhdr -> hb_sz;
	397	ok = &GC_obj_kinds[knd];
	398	if (sz <= MAXOBJSZ) {
	399	# ifdef THREADS
	400	DISABLE_SIGNALS();
	401	LOCK();
	402	# endif
	403	GC_mem_freed += sz;
	404	/* A signal here can make GC_mem_freed and GC_non_gc_bytes */
	405	/* inconsistent. We claim this is benign. */
	406	if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
	407	/* Its unnecessary to clear the mark bit. If the */
	408	/* object is reallocated, it doesn't matter. O.w. the */
	409	/* collector will do it, since it's on a free list. */
	410	if (ok -> ok_init) {
	411	BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1));
	412	}
	413	flh = &(ok -> ok_freelist[sz]);
	414	obj_link(p) = *flh;
	415	*flh = (ptr_t)p;
	416	# ifdef THREADS
	417	UNLOCK();
	418	ENABLE_SIGNALS();
	419	# endif
	420	} else {
	421	DISABLE_SIGNALS();
	422	LOCK();
	423	GC_mem_freed += sz;
	424	if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
	425	GC_freehblk(h);
	426	UNLOCK();
	427	ENABLE_SIGNALS();
	428	}
	429	}
	430
	431	# ifdef REDIRECT_MALLOC
	432	# ifdef __STDC__
	433	void free(GC_PTR p)
	434	# else
	435	void free(p)
	436	GC_PTR p;
	437	# endif
	438	{
	439	# ifndef IGNORE_FREE
	440	GC_free(p);
	441	# endif
	442	}
	443	# endif /* REDIRECT_MALLOC */