mirror of
git://gcc.gnu.org/git/gcc.git
synced 2024-12-19 14:19:39 +08:00
91 lines
3.9 KiB
C
91 lines
3.9 KiB
C
|
|
/*
|
|
* 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 *);
|