Initial revision

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@26246 138bc75d-0d04-0410-961f-82ee72b054a4

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;}}
+
+
+