Subversion Repositories openrisc

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

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