/* 
 * Copyright (c) 1999 by Silicon Graphics.  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.
 */

/*
 * THIS IMPLEMENTATION FOR THIS INTERFACE IS INCOMPLETE.
 * NONE OF THIS HAS BEEN TESTED.  DO NOT USE.
 *
 * Comments on the interface are appreciated, especially from
 * potential users of the interface.
 *
 * This is a Bartlett style copying collector for young objects.
 * We assume for now that all objects allocated through this
 * mechanism have pointers only in the first BITMAP_BITS words.
 * (On a 32-bit machine, BITMAP_BITS is 30.)
 * Objects allocated in this manner should be rarely referenced
 * by objects not allocated either through this interface, or through
 * the typed allocation interface.
 * If this interface is used, we assume that type information provided
 * through either this or the typed allocation interface is valid
 * in a stronger sense:
 *
 * 1) No pointers are stored in fields not marked as such.
 *    (Otherwise it is only necessary that objects referenced by
 *    fields marked as nonpointers are also reachable via another
 *    path.)
 * 2) Values stored in pointer fields are either not addresses in
 *    the heap, or they really are pointers.  In the latter case, it
 *    is acceptable to move the object they refer to, and to update
 *    the pointer.
 *
 * GC_free may not be invoked on objects allocated with GC_copying_malloc.
 *
 * No extra space is added to the end of objects allocated through this
 * interface.  If the client needs to maintain pointers past the
 * end, the size should be explicitly padded.
 * 
 * We assume that calls to this will usually be compiler generated.
 * Hence the interface is allowed to be a bit ugly in return for speed.
 */

#include "gc_copy_descr.h"

/* GC_copy_descr.h must define						*/
/* GC_SIZE_FROM_DESCRIPTOR(descr) and					*/
/* GC_BIT_MAP_FROM_DESCRIPTOR(descr).					*/
/* It may either be the GC supplied version of the header file, or a	*/
/* client specific one that derives the information from a client-	*/
/* specific type descriptor.						*/

typedef GC_PTR GC_copy_alloc_state;
				/* Current allocator state.	*/
				/* Multiple allocation states	*/
				/* may be used for concurrent	*/
				/* allocation, or to enhance	*/
				/* locality.			*/
				/* Should be treated as opaque.	*/

/* Allocate a memory block of size given in the descriptor, and with	*/
/* pointer layout given by the descriptor.  The resulting block may not	*/
/* be cleared, and should immediately be initialized by the client.	*/
/* (A concurrent GC may see an uninitialized pointer field.  If it	*/
/* points outside the nursery, that's fine.  If it points inside, it	*/
/* may retain an object, and be relocated.  But that's also fine, since	*/
/* the new value will be immediately overwritten.			*/
/* This variant acquires the allocation lock, and uses a default 	*/
/* global allocation state.						*/
GC_PTR GC_copying_malloc(GC_copy_descriptor);

/* A variant of the above that does no locking on the fast path,	*/
/* and passes an explicit pointer to an allocation state.		*/
/* The allocation state is updated.					*/
/* There will eventually need to be a macro or inline function version	*/
/* of this.								*/
GC_PTR GC_copying_malloc2(GC_copy_descriptor, GC_copy_alloc_state *);

/* Initialize an allocation state so that it can be used for 	*/
/* allocation.  This implicitly reserves a small section of the	*/
/* nursery for use with this allocator.				*/
void GC_init_copy_alloc_state(GC_copy_alloc_state *);