aboutsummaryrefslogtreecommitdiffstats
path: root/gcc-4.2.1/boehm-gc/gcc_support.c
diff options
context:
space:
mode:
Diffstat (limited to 'gcc-4.2.1/boehm-gc/gcc_support.c')
-rw-r--r--gcc-4.2.1/boehm-gc/gcc_support.c516
1 files changed, 516 insertions, 0 deletions
diff --git a/gcc-4.2.1/boehm-gc/gcc_support.c b/gcc-4.2.1/boehm-gc/gcc_support.c
new file mode 100644
index 000000000..e8a7b8201
--- /dev/null
+++ b/gcc-4.2.1/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;}}
+
+
+