source: trunk/gc6.8/gcc_support.c

/***************************************************************************

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