diff options
Diffstat (limited to 'boehm-gc/gcc_support.c')
| -rw-r--r-- | boehm-gc/gcc_support.c | 516 |
1 files changed, 516 insertions, 0 deletions
diff --git a/boehm-gc/gcc_support.c b/boehm-gc/gcc_support.c new file mode 100644 index 00000000000..e8a7b8201db --- /dev/null +++ b/boehm-gc/gcc_support.c @@ -0,0 +1,516 @@ +/*************************************************************************** + +Interface between g++ and Boehm GC + + Copyright (c) 1991-1995 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 copy this code for any purpose, + provided the above notices are retained on all copies. + + Last modified on Sun Jul 16 23:21:14 PDT 1995 by ellis + +This module provides runtime support for implementing the +Ellis/Detlefs GC proposal, "Safe, Efficient Garbage Collection for +C++", within g++, using its -fgc-keyword extension. It defines +versions of __builtin_new, __builtin_new_gc, __builtin_vec_new, +__builtin_vec_new_gc, __builtin_delete, and __builtin_vec_delete that +invoke the Bohem GC. It also implements the WeakPointer.h interface. + +This module assumes the following configuration options of the Boehm GC: + + -DALL_INTERIOR_POINTERS + -DDONT_ADD_BYTE_AT_END + +This module adds its own required padding to the end of objects to +support C/C++ "one-past-the-object" pointer semantics. + +****************************************************************************/ + +#include <stddef.h> +#include "gc.h" + +#if defined(__STDC__) +# define PROTO( args ) args +#else +# define PROTO( args ) () +# endif + +#define BITSPERBYTE 8 + /* What's the portable way to do this? */ + + +typedef void (*vfp) PROTO(( void )); +extern vfp __new_handler; +extern void __default_new_handler PROTO(( void )); + + +/* A destructor_proc is the compiler generated procedure representing a +C++ destructor. The "flag" argument is a hidden argument following some +compiler convention. */ + +typedef (*destructor_proc) PROTO(( void* this, int flag )); + + +/*************************************************************************** + +A BI_header is the header the compiler adds to the front of +new-allocated arrays of objects with destructors. The header is +padded out to a double, because that's what the compiler does to +ensure proper alignment of array elements on some architectures. + +int NUM_ARRAY_ELEMENTS (void* o) + returns the number of array elements for array object o. + +char* FIRST_ELEMENT_P (void* o) + returns the address of the first element of array object o. + +***************************************************************************/ + +typedef struct BI_header { + int nelts; + char padding [sizeof( double ) - sizeof( int )]; + /* Better way to do this? */ +} BI_header; + +#define NUM_ARRAY_ELEMENTS( o ) \ + (((BI_header*) o)->nelts) + +#define FIRST_ELEMENT_P( o ) \ + ((char*) o + sizeof( BI_header )) + + +/*************************************************************************** + +The __builtin_new routines add a descriptor word to the end of each +object. The descriptor serves two purposes. + +First, the descriptor acts as padding, implementing C/C++ pointer +semantics. C and C++ allow a valid array pointer to be incremented +one past the end of an object. The extra padding ensures that the +collector will recognize that such a pointer points to the object and +not the next object in memory. + +Second, the descriptor stores three extra pieces of information, +whether an object has a registered finalizer (destructor), whether it +may have any weak pointers referencing it, and for collectible arrays, +the element size of the array. The element size is required for the +array's finalizer to iterate through the elements of the array. (An +alternative design would have the compiler generate a finalizer +procedure for each different array type. But given the overhead of +finalization, there isn't any efficiency to be gained by that.) + +The descriptor must be added to non-collectible as well as collectible +objects, since the Ellis/Detlefs proposal allows "pointer to gc T" to +be assigned to a "pointer to T", which could then be deleted. Thus, +__builtin_delete must determine at runtime whether an object is +collectible, whether it has weak pointers referencing it, and whether +it may have a finalizer that needs unregistering. Though +GC_REGISTER_FINALIZER doesn't care if you ask it to unregister a +finalizer for an object that doesn't have one, it is a non-trivial +procedure that does a hash look-up, etc. The descriptor trades a +little extra space for a significant increase in time on the fast path +through delete. (A similar argument applies to +GC_UNREGISTER_DISAPPEARING_LINK). + +For non-array types, the space for the descriptor could be shrunk to a +single byte for storing the "has finalizer" flag. But this would save +space only on arrays of char (whose size is not a multiple of the word +size) and structs whose largest member is less than a word in size +(very infrequent). And it would require that programmers actually +remember to call "delete[]" instead of "delete" (which they should, +but there are probably lots of buggy programs out there). For the +moment, the space savings seems not worthwhile, especially considering +that the Boehm GC is already quite space competitive with other +malloc's. + + +Given a pointer o to the base of an object: + +Descriptor* DESCRIPTOR (void* o) + returns a pointer to the descriptor for o. + +The implementation of descriptors relies on the fact that the GC +implementation allocates objects in units of the machine's natural +word size (e.g. 32 bits on a SPARC, 64 bits on an Alpha). + +**************************************************************************/ + +typedef struct Descriptor { + unsigned has_weak_pointers: 1; + unsigned has_finalizer: 1; + unsigned element_size: BITSPERBYTE * sizeof( unsigned ) - 2; +} Descriptor; + +#define DESCRIPTOR( o ) \ + ((Descriptor*) ((char*)(o) + GC_size( o ) - sizeof( Descriptor ))) + + +/************************************************************************** + +Implementations of global operator new() and operator delete() + +***************************************************************************/ + + +void* __builtin_new( size ) + size_t size; + /* + For non-gc non-array types, the compiler generates calls to + __builtin_new, which allocates non-collected storage via + GC_MALLOC_UNCOLLECTABLE. This ensures that the non-collected + storage will be part of the collector's root set, required by the + Ellis/Detlefs semantics. */ +{ + vfp handler = __new_handler ? __new_handler : __default_new_handler; + + while (1) { + void* o = GC_MALLOC_UNCOLLECTABLE( size + sizeof( Descriptor ) ); + if (o != 0) return o; + (*handler) ();}} + + +void* __builtin_vec_new( size ) + size_t size; + /* + For non-gc array types, the compiler generates calls to + __builtin_vec_new. */ +{ + return __builtin_new( size );} + + +void* __builtin_new_gc( size ) + size_t size; + /* + For gc non-array types, the compiler generates calls to + __builtin_new_gc, which allocates collected storage via + GC_MALLOC. */ +{ + vfp handler = __new_handler ? __new_handler : __default_new_handler; + + while (1) { + void* o = GC_MALLOC( size + sizeof( Descriptor ) ); + if (o != 0) return o; + (*handler) ();}} + + +void* __builtin_new_gc_a( size ) + size_t size; + /* + For non-pointer-containing gc non-array types, the compiler + generates calls to __builtin_new_gc_a, which allocates collected + storage via GC_MALLOC_ATOMIC. */ +{ + vfp handler = __new_handler ? __new_handler : __default_new_handler; + + while (1) { + void* o = GC_MALLOC_ATOMIC( size + sizeof( Descriptor ) ); + if (o != 0) return o; + (*handler) ();}} + + +void* __builtin_vec_new_gc( size ) + size_t size; + /* + For gc array types, the compiler generates calls to + __builtin_vec_new_gc. */ +{ + return __builtin_new_gc( size );} + + +void* __builtin_vec_new_gc_a( size ) + size_t size; + /* + For non-pointer-containing gc array types, the compiler generates + calls to __builtin_vec_new_gc_a. */ +{ + return __builtin_new_gc_a( size );} + + +static void call_destructor( o, data ) + void* o; + void* data; + /* + call_destructor is the GC finalizer proc registered for non-array + gc objects with destructors. Its client data is the destructor + proc, which it calls with the magic integer 2, a special flag + obeying the compiler convention for destructors. */ +{ + ((destructor_proc) data)( o, 2 );} + + +void* __builtin_new_gc_dtor( o, d ) + void* o; + destructor_proc d; + /* + The compiler generates a call to __builtin_new_gc_dtor to register + the destructor "d" of a non-array gc object "o" as a GC finalizer. + The destructor is registered via + GC_REGISTER_FINALIZER_IGNORE_SELF, which causes the collector to + ignore pointers from the object to itself when determining when + the object can be finalized. This is necessary due to the self + pointers used in the internal representation of multiply-inherited + objects. */ +{ + Descriptor* desc = DESCRIPTOR( o ); + + GC_REGISTER_FINALIZER_IGNORE_SELF( o, call_destructor, d, 0, 0 ); + desc->has_finalizer = 1;} + + +static void call_array_destructor( o, data ) + void* o; + void* data; + /* + call_array_destructor is the GC finalizer proc registered for gc + array objects whose elements have destructors. Its client data is + the destructor proc. It iterates through the elements of the + array in reverse order, calling the destructor on each. */ +{ + int num = NUM_ARRAY_ELEMENTS( o ); + Descriptor* desc = DESCRIPTOR( o ); + size_t size = desc->element_size; + char* first_p = FIRST_ELEMENT_P( o ); + char* p = first_p + (num - 1) * size; + + if (num > 0) { + while (1) { + ((destructor_proc) data)( p, 2 ); + if (p == first_p) break; + p -= size;}}} + + +void* __builtin_vec_new_gc_dtor( first_elem, d, element_size ) + void* first_elem; + destructor_proc d; + size_t element_size; + /* + The compiler generates a call to __builtin_vec_new_gc_dtor to + register the destructor "d" of a gc array object as a GC + finalizer. "first_elem" points to the first element of the array, + *not* the beginning of the object (this makes the generated call + to this function smaller). The elements of the array are of size + "element_size". The destructor is registered as in + _builtin_new_gc_dtor. */ +{ + void* o = (char*) first_elem - sizeof( BI_header ); + Descriptor* desc = DESCRIPTOR( o ); + + GC_REGISTER_FINALIZER_IGNORE_SELF( o, call_array_destructor, d, 0, 0 ); + desc->element_size = element_size; + desc->has_finalizer = 1;} + + +void __builtin_delete( o ) + void* o; + /* + The compiler generates calls to __builtin_delete for operator + delete(). The GC currently requires that any registered + finalizers be unregistered before explicitly freeing an object. + If the object has any weak pointers referencing it, we can't + actually free it now. */ +{ + if (o != 0) { + Descriptor* desc = DESCRIPTOR( o ); + if (desc->has_finalizer) GC_REGISTER_FINALIZER( o, 0, 0, 0, 0 ); + if (! desc->has_weak_pointers) GC_FREE( o );}} + + +void __builtin_vec_delete( o ) + void* o; + /* + The compiler generates calls to __builitn_vec_delete for operator + delete[](). */ +{ + __builtin_delete( o );} + + +/************************************************************************** + +Implementations of the template class WeakPointer from WeakPointer.h + +***************************************************************************/ + +typedef struct WeakPointer { + void* pointer; +} WeakPointer; + + +void* _WeakPointer_New( t ) + void* t; +{ + if (t == 0) { + return 0;} + else { + void* base = GC_base( t ); + WeakPointer* wp = + (WeakPointer*) GC_MALLOC_ATOMIC( sizeof( WeakPointer ) ); + Descriptor* desc = DESCRIPTOR( base ); + + wp->pointer = t; + desc->has_weak_pointers = 1; + GC_general_register_disappearing_link( &wp->pointer, base ); + return wp;}} + + +static void* PointerWithLock( wp ) + WeakPointer* wp; +{ + if (wp == 0 || wp->pointer == 0) { + return 0;} + else { + return (void*) wp->pointer;}} + + +void* _WeakPointer_Pointer( wp ) + WeakPointer* wp; +{ + return (void*) GC_call_with_alloc_lock( PointerWithLock, wp );} + + +typedef struct EqualClosure { + WeakPointer* wp1; + WeakPointer* wp2; +} EqualClosure; + + +static void* EqualWithLock( ec ) + EqualClosure* ec; +{ + if (ec->wp1 == 0 || ec->wp2 == 0) { + return (void*) (ec->wp1 == ec->wp2);} + else { + return (void*) (ec->wp1->pointer == ec->wp2->pointer);}} + + +int _WeakPointer_Equal( wp1, wp2 ) + WeakPointer* wp1; + WeakPointer* wp2; +{ + EqualClosure ec; + + ec.wp1 = wp1; + ec.wp2 = wp2; + return (int) GC_call_with_alloc_lock( EqualWithLock, &ec );} + + +int _WeakPointer_Hash( wp ) + WeakPointer* wp; +{ + return (int) _WeakPointer_Pointer( wp );} + + +/************************************************************************** + +Implementations of the template class CleanUp from WeakPointer.h + +***************************************************************************/ + +typedef struct Closure { + void (*c) PROTO(( void* d, void* t )); + ptrdiff_t t_offset; + void* d; +} Closure; + + +static void _CleanUp_CallClosure( obj, data ) + void* obj; + void* data; +{ + Closure* closure = (Closure*) data; + closure->c( closure->d, (char*) obj + closure->t_offset );} + + +void _CleanUp_Set( t, c, d ) + void* t; + void (*c) PROTO(( void* d, void* t )); + void* d; +{ + void* base = GC_base( t ); + Descriptor* desc = DESCRIPTOR( t ); + + if (c == 0) { + GC_REGISTER_FINALIZER_IGNORE_SELF( base, 0, 0, 0, 0 ); + desc->has_finalizer = 0;} + else { + Closure* closure = (Closure*) GC_MALLOC( sizeof( Closure ) ); + closure->c = c; + closure->t_offset = (char*) t - (char*) base; + closure->d = d; + GC_REGISTER_FINALIZER_IGNORE_SELF( base, _CleanUp_CallClosure, + closure, 0, 0 ); + desc->has_finalizer = 1;}} + + +void _CleanUp_Call( t ) + void* t; +{ + /* ? Aren't we supposed to deactivate weak pointers to t too? + Why? */ + void* base = GC_base( t ); + void* d; + GC_finalization_proc f; + + GC_REGISTER_FINALIZER( base, 0, 0, &f, &d ); + f( base, d );} + + +typedef struct QueueElem { + void* o; + GC_finalization_proc f; + void* d; + struct QueueElem* next; +} QueueElem; + + +void* _CleanUp_Queue_NewHead() +{ + return GC_MALLOC( sizeof( QueueElem ) );} + + +static void _CleanUp_Queue_Enqueue( obj, data ) + void* obj; + void* data; +{ + QueueElem* q = (QueueElem*) data; + QueueElem* head = q->next; + + q->o = obj; + q->next = head->next; + head->next = q;} + + +void _CleanUp_Queue_Set( h, t ) + void* h; + void* t; +{ + QueueElem* head = (QueueElem*) h; + void* base = GC_base( t ); + void* d; + GC_finalization_proc f; + QueueElem* q = (QueueElem*) GC_MALLOC( sizeof( QueueElem ) ); + + GC_REGISTER_FINALIZER( base, _CleanUp_Queue_Enqueue, q, &f, &d ); + q->f = f; + q->d = d; + q->next = head;} + + +int _CleanUp_Queue_Call( h ) + void* h; +{ + QueueElem* head = (QueueElem*) h; + QueueElem* q = head->next; + + if (q == 0) { + return 0;} + else { + head->next = q->next; + q->next = 0; + if (q->f != 0) q->f( q->o, q->d ); + return 1;}} + + + |