Annotation of OpenXM_contrib2/asir2000/gc/gcc_support.c, Revision 1.1
1.1 ! noro 1: /***************************************************************************
! 2:
! 3: Interface between g++ and Boehm GC
! 4:
! 5: Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved.
! 6:
! 7: THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
! 8: OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
! 9:
! 10: Permission is hereby granted to copy this code for any purpose,
! 11: provided the above notices are retained on all copies.
! 12:
! 13: Last modified on Sun Jul 16 23:21:14 PDT 1995 by ellis
! 14:
! 15: This module provides runtime support for implementing the
! 16: Ellis/Detlefs GC proposal, "Safe, Efficient Garbage Collection for
! 17: C++", within g++, using its -fgc-keyword extension. It defines
! 18: versions of __builtin_new, __builtin_new_gc, __builtin_vec_new,
! 19: __builtin_vec_new_gc, __builtin_delete, and __builtin_vec_delete that
! 20: invoke the Bohem GC. It also implements the WeakPointer.h interface.
! 21:
! 22: This module assumes the following configuration options of the Boehm GC:
! 23:
! 24: -DALL_INTERIOR_POINTERS
! 25: -DDONT_ADD_BYTE_AT_END
! 26:
! 27: This module adds its own required padding to the end of objects to
! 28: support C/C++ "one-past-the-object" pointer semantics.
! 29:
! 30: ****************************************************************************/
! 31:
! 32: #include <stddef.h>
! 33: #include "gc.h"
! 34:
! 35: #if defined(__STDC__)
! 36: # define PROTO( args ) args
! 37: #else
! 38: # define PROTO( args ) ()
! 39: # endif
! 40:
! 41: #define BITSPERBYTE 8
! 42: /* What's the portable way to do this? */
! 43:
! 44:
! 45: typedef void (*vfp) PROTO(( void ));
! 46: extern vfp __new_handler;
! 47: extern void __default_new_handler PROTO(( void ));
! 48:
! 49:
! 50: /* A destructor_proc is the compiler generated procedure representing a
! 51: C++ destructor. The "flag" argument is a hidden argument following some
! 52: compiler convention. */
! 53:
! 54: typedef (*destructor_proc) PROTO(( void* this, int flag ));
! 55:
! 56:
! 57: /***************************************************************************
! 58:
! 59: A BI_header is the header the compiler adds to the front of
! 60: new-allocated arrays of objects with destructors. The header is
! 61: padded out to a double, because that's what the compiler does to
! 62: ensure proper alignment of array elements on some architectures.
! 63:
! 64: int NUM_ARRAY_ELEMENTS (void* o)
! 65: returns the number of array elements for array object o.
! 66:
! 67: char* FIRST_ELEMENT_P (void* o)
! 68: returns the address of the first element of array object o.
! 69:
! 70: ***************************************************************************/
! 71:
! 72: typedef struct BI_header {
! 73: int nelts;
! 74: char padding [sizeof( double ) - sizeof( int )];
! 75: /* Better way to do this? */
! 76: } BI_header;
! 77:
! 78: #define NUM_ARRAY_ELEMENTS( o ) \
! 79: (((BI_header*) o)->nelts)
! 80:
! 81: #define FIRST_ELEMENT_P( o ) \
! 82: ((char*) o + sizeof( BI_header ))
! 83:
! 84:
! 85: /***************************************************************************
! 86:
! 87: The __builtin_new routines add a descriptor word to the end of each
! 88: object. The descriptor serves two purposes.
! 89:
! 90: First, the descriptor acts as padding, implementing C/C++ pointer
! 91: semantics. C and C++ allow a valid array pointer to be incremented
! 92: one past the end of an object. The extra padding ensures that the
! 93: collector will recognize that such a pointer points to the object and
! 94: not the next object in memory.
! 95:
! 96: Second, the descriptor stores three extra pieces of information,
! 97: whether an object has a registered finalizer (destructor), whether it
! 98: may have any weak pointers referencing it, and for collectible arrays,
! 99: the element size of the array. The element size is required for the
! 100: array's finalizer to iterate through the elements of the array. (An
! 101: alternative design would have the compiler generate a finalizer
! 102: procedure for each different array type. But given the overhead of
! 103: finalization, there isn't any efficiency to be gained by that.)
! 104:
! 105: The descriptor must be added to non-collectible as well as collectible
! 106: objects, since the Ellis/Detlefs proposal allows "pointer to gc T" to
! 107: be assigned to a "pointer to T", which could then be deleted. Thus,
! 108: __builtin_delete must determine at runtime whether an object is
! 109: collectible, whether it has weak pointers referencing it, and whether
! 110: it may have a finalizer that needs unregistering. Though
! 111: GC_REGISTER_FINALIZER doesn't care if you ask it to unregister a
! 112: finalizer for an object that doesn't have one, it is a non-trivial
! 113: procedure that does a hash look-up, etc. The descriptor trades a
! 114: little extra space for a significant increase in time on the fast path
! 115: through delete. (A similar argument applies to
! 116: GC_UNREGISTER_DISAPPEARING_LINK).
! 117:
! 118: For non-array types, the space for the descriptor could be shrunk to a
! 119: single byte for storing the "has finalizer" flag. But this would save
! 120: space only on arrays of char (whose size is not a multiple of the word
! 121: size) and structs whose largest member is less than a word in size
! 122: (very infrequent). And it would require that programmers actually
! 123: remember to call "delete[]" instead of "delete" (which they should,
! 124: but there are probably lots of buggy programs out there). For the
! 125: moment, the space savings seems not worthwhile, especially considering
! 126: that the Boehm GC is already quite space competitive with other
! 127: malloc's.
! 128:
! 129:
! 130: Given a pointer o to the base of an object:
! 131:
! 132: Descriptor* DESCRIPTOR (void* o)
! 133: returns a pointer to the descriptor for o.
! 134:
! 135: The implementation of descriptors relies on the fact that the GC
! 136: implementation allocates objects in units of the machine's natural
! 137: word size (e.g. 32 bits on a SPARC, 64 bits on an Alpha).
! 138:
! 139: **************************************************************************/
! 140:
! 141: typedef struct Descriptor {
! 142: unsigned has_weak_pointers: 1;
! 143: unsigned has_finalizer: 1;
! 144: unsigned element_size: BITSPERBYTE * sizeof( unsigned ) - 2;
! 145: } Descriptor;
! 146:
! 147: #define DESCRIPTOR( o ) \
! 148: ((Descriptor*) ((char*)(o) + GC_size( o ) - sizeof( Descriptor )))
! 149:
! 150:
! 151: /**************************************************************************
! 152:
! 153: Implementations of global operator new() and operator delete()
! 154:
! 155: ***************************************************************************/
! 156:
! 157:
! 158: void* __builtin_new( size )
! 159: size_t size;
! 160: /*
! 161: For non-gc non-array types, the compiler generates calls to
! 162: __builtin_new, which allocates non-collected storage via
! 163: GC_MALLOC_UNCOLLECTABLE. This ensures that the non-collected
! 164: storage will be part of the collector's root set, required by the
! 165: Ellis/Detlefs semantics. */
! 166: {
! 167: vfp handler = __new_handler ? __new_handler : __default_new_handler;
! 168:
! 169: while (1) {
! 170: void* o = GC_MALLOC_UNCOLLECTABLE( size + sizeof( Descriptor ) );
! 171: if (o != 0) return o;
! 172: (*handler) ();}}
! 173:
! 174:
! 175: void* __builtin_vec_new( size )
! 176: size_t size;
! 177: /*
! 178: For non-gc array types, the compiler generates calls to
! 179: __builtin_vec_new. */
! 180: {
! 181: return __builtin_new( size );}
! 182:
! 183:
! 184: void* __builtin_new_gc( size )
! 185: size_t size;
! 186: /*
! 187: For gc non-array types, the compiler generates calls to
! 188: __builtin_new_gc, which allocates collected storage via
! 189: GC_MALLOC. */
! 190: {
! 191: vfp handler = __new_handler ? __new_handler : __default_new_handler;
! 192:
! 193: while (1) {
! 194: void* o = GC_MALLOC( size + sizeof( Descriptor ) );
! 195: if (o != 0) return o;
! 196: (*handler) ();}}
! 197:
! 198:
! 199: void* __builtin_new_gc_a( size )
! 200: size_t size;
! 201: /*
! 202: For non-pointer-containing gc non-array types, the compiler
! 203: generates calls to __builtin_new_gc_a, which allocates collected
! 204: storage via GC_MALLOC_ATOMIC. */
! 205: {
! 206: vfp handler = __new_handler ? __new_handler : __default_new_handler;
! 207:
! 208: while (1) {
! 209: void* o = GC_MALLOC_ATOMIC( size + sizeof( Descriptor ) );
! 210: if (o != 0) return o;
! 211: (*handler) ();}}
! 212:
! 213:
! 214: void* __builtin_vec_new_gc( size )
! 215: size_t size;
! 216: /*
! 217: For gc array types, the compiler generates calls to
! 218: __builtin_vec_new_gc. */
! 219: {
! 220: return __builtin_new_gc( size );}
! 221:
! 222:
! 223: void* __builtin_vec_new_gc_a( size )
! 224: size_t size;
! 225: /*
! 226: For non-pointer-containing gc array types, the compiler generates
! 227: calls to __builtin_vec_new_gc_a. */
! 228: {
! 229: return __builtin_new_gc_a( size );}
! 230:
! 231:
! 232: static void call_destructor( o, data )
! 233: void* o;
! 234: void* data;
! 235: /*
! 236: call_destructor is the GC finalizer proc registered for non-array
! 237: gc objects with destructors. Its client data is the destructor
! 238: proc, which it calls with the magic integer 2, a special flag
! 239: obeying the compiler convention for destructors. */
! 240: {
! 241: ((destructor_proc) data)( o, 2 );}
! 242:
! 243:
! 244: void* __builtin_new_gc_dtor( o, d )
! 245: void* o;
! 246: destructor_proc d;
! 247: /*
! 248: The compiler generates a call to __builtin_new_gc_dtor to register
! 249: the destructor "d" of a non-array gc object "o" as a GC finalizer.
! 250: The destructor is registered via
! 251: GC_REGISTER_FINALIZER_IGNORE_SELF, which causes the collector to
! 252: ignore pointers from the object to itself when determining when
! 253: the object can be finalized. This is necessary due to the self
! 254: pointers used in the internal representation of multiply-inherited
! 255: objects. */
! 256: {
! 257: Descriptor* desc = DESCRIPTOR( o );
! 258:
! 259: GC_REGISTER_FINALIZER_IGNORE_SELF( o, call_destructor, d, 0, 0 );
! 260: desc->has_finalizer = 1;}
! 261:
! 262:
! 263: static void call_array_destructor( o, data )
! 264: void* o;
! 265: void* data;
! 266: /*
! 267: call_array_destructor is the GC finalizer proc registered for gc
! 268: array objects whose elements have destructors. Its client data is
! 269: the destructor proc. It iterates through the elements of the
! 270: array in reverse order, calling the destructor on each. */
! 271: {
! 272: int num = NUM_ARRAY_ELEMENTS( o );
! 273: Descriptor* desc = DESCRIPTOR( o );
! 274: size_t size = desc->element_size;
! 275: char* first_p = FIRST_ELEMENT_P( o );
! 276: char* p = first_p + (num - 1) * size;
! 277:
! 278: if (num > 0) {
! 279: while (1) {
! 280: ((destructor_proc) data)( p, 2 );
! 281: if (p == first_p) break;
! 282: p -= size;}}}
! 283:
! 284:
! 285: void* __builtin_vec_new_gc_dtor( first_elem, d, element_size )
! 286: void* first_elem;
! 287: destructor_proc d;
! 288: size_t element_size;
! 289: /*
! 290: The compiler generates a call to __builtin_vec_new_gc_dtor to
! 291: register the destructor "d" of a gc array object as a GC
! 292: finalizer. "first_elem" points to the first element of the array,
! 293: *not* the beginning of the object (this makes the generated call
! 294: to this function smaller). The elements of the array are of size
! 295: "element_size". The destructor is registered as in
! 296: _builtin_new_gc_dtor. */
! 297: {
! 298: void* o = (char*) first_elem - sizeof( BI_header );
! 299: Descriptor* desc = DESCRIPTOR( o );
! 300:
! 301: GC_REGISTER_FINALIZER_IGNORE_SELF( o, call_array_destructor, d, 0, 0 );
! 302: desc->element_size = element_size;
! 303: desc->has_finalizer = 1;}
! 304:
! 305:
! 306: void __builtin_delete( o )
! 307: void* o;
! 308: /*
! 309: The compiler generates calls to __builtin_delete for operator
! 310: delete(). The GC currently requires that any registered
! 311: finalizers be unregistered before explicitly freeing an object.
! 312: If the object has any weak pointers referencing it, we can't
! 313: actually free it now. */
! 314: {
! 315: if (o != 0) {
! 316: Descriptor* desc = DESCRIPTOR( o );
! 317: if (desc->has_finalizer) GC_REGISTER_FINALIZER( o, 0, 0, 0, 0 );
! 318: if (! desc->has_weak_pointers) GC_FREE( o );}}
! 319:
! 320:
! 321: void __builtin_vec_delete( o )
! 322: void* o;
! 323: /*
! 324: The compiler generates calls to __builitn_vec_delete for operator
! 325: delete[](). */
! 326: {
! 327: __builtin_delete( o );}
! 328:
! 329:
! 330: /**************************************************************************
! 331:
! 332: Implementations of the template class WeakPointer from WeakPointer.h
! 333:
! 334: ***************************************************************************/
! 335:
! 336: typedef struct WeakPointer {
! 337: void* pointer;
! 338: } WeakPointer;
! 339:
! 340:
! 341: void* _WeakPointer_New( t )
! 342: void* t;
! 343: {
! 344: if (t == 0) {
! 345: return 0;}
! 346: else {
! 347: void* base = GC_base( t );
! 348: WeakPointer* wp =
! 349: (WeakPointer*) GC_MALLOC_ATOMIC( sizeof( WeakPointer ) );
! 350: Descriptor* desc = DESCRIPTOR( base );
! 351:
! 352: wp->pointer = t;
! 353: desc->has_weak_pointers = 1;
! 354: GC_general_register_disappearing_link( &wp->pointer, base );
! 355: return wp;}}
! 356:
! 357:
! 358: static void* PointerWithLock( wp )
! 359: WeakPointer* wp;
! 360: {
! 361: if (wp == 0 || wp->pointer == 0) {
! 362: return 0;}
! 363: else {
! 364: return (void*) wp->pointer;}}
! 365:
! 366:
! 367: void* _WeakPointer_Pointer( wp )
! 368: WeakPointer* wp;
! 369: {
! 370: return (void*) GC_call_with_alloc_lock( PointerWithLock, wp );}
! 371:
! 372:
! 373: typedef struct EqualClosure {
! 374: WeakPointer* wp1;
! 375: WeakPointer* wp2;
! 376: } EqualClosure;
! 377:
! 378:
! 379: static void* EqualWithLock( ec )
! 380: EqualClosure* ec;
! 381: {
! 382: if (ec->wp1 == 0 || ec->wp2 == 0) {
! 383: return (void*) (ec->wp1 == ec->wp2);}
! 384: else {
! 385: return (void*) (ec->wp1->pointer == ec->wp2->pointer);}}
! 386:
! 387:
! 388: int _WeakPointer_Equal( wp1, wp2 )
! 389: WeakPointer* wp1;
! 390: WeakPointer* wp2;
! 391: {
! 392: EqualClosure ec;
! 393:
! 394: ec.wp1 = wp1;
! 395: ec.wp2 = wp2;
! 396: return (int) GC_call_with_alloc_lock( EqualWithLock, &ec );}
! 397:
! 398:
! 399: int _WeakPointer_Hash( wp )
! 400: WeakPointer* wp;
! 401: {
! 402: return (int) _WeakPointer_Pointer( wp );}
! 403:
! 404:
! 405: /**************************************************************************
! 406:
! 407: Implementations of the template class CleanUp from WeakPointer.h
! 408:
! 409: ***************************************************************************/
! 410:
! 411: typedef struct Closure {
! 412: void (*c) PROTO(( void* d, void* t ));
! 413: ptrdiff_t t_offset;
! 414: void* d;
! 415: } Closure;
! 416:
! 417:
! 418: static void _CleanUp_CallClosure( obj, data )
! 419: void* obj;
! 420: void* data;
! 421: {
! 422: Closure* closure = (Closure*) data;
! 423: closure->c( closure->d, (char*) obj + closure->t_offset );}
! 424:
! 425:
! 426: void _CleanUp_Set( t, c, d )
! 427: void* t;
! 428: void (*c) PROTO(( void* d, void* t ));
! 429: void* d;
! 430: {
! 431: void* base = GC_base( t );
! 432: Descriptor* desc = DESCRIPTOR( t );
! 433:
! 434: if (c == 0) {
! 435: GC_REGISTER_FINALIZER_IGNORE_SELF( base, 0, 0, 0, 0 );
! 436: desc->has_finalizer = 0;}
! 437: else {
! 438: Closure* closure = (Closure*) GC_MALLOC( sizeof( Closure ) );
! 439: closure->c = c;
! 440: closure->t_offset = (char*) t - (char*) base;
! 441: closure->d = d;
! 442: GC_REGISTER_FINALIZER_IGNORE_SELF( base, _CleanUp_CallClosure,
! 443: closure, 0, 0 );
! 444: desc->has_finalizer = 1;}}
! 445:
! 446:
! 447: void _CleanUp_Call( t )
! 448: void* t;
! 449: {
! 450: /* ? Aren't we supposed to deactivate weak pointers to t too?
! 451: Why? */
! 452: void* base = GC_base( t );
! 453: void* d;
! 454: GC_finalization_proc f;
! 455:
! 456: GC_REGISTER_FINALIZER( base, 0, 0, &f, &d );
! 457: f( base, d );}
! 458:
! 459:
! 460: typedef struct QueueElem {
! 461: void* o;
! 462: GC_finalization_proc f;
! 463: void* d;
! 464: struct QueueElem* next;
! 465: } QueueElem;
! 466:
! 467:
! 468: void* _CleanUp_Queue_NewHead()
! 469: {
! 470: return GC_MALLOC( sizeof( QueueElem ) );}
! 471:
! 472:
! 473: static void _CleanUp_Queue_Enqueue( obj, data )
! 474: void* obj;
! 475: void* data;
! 476: {
! 477: QueueElem* q = (QueueElem*) data;
! 478: QueueElem* head = q->next;
! 479:
! 480: q->o = obj;
! 481: q->next = head->next;
! 482: head->next = q;}
! 483:
! 484:
! 485: void _CleanUp_Queue_Set( h, t )
! 486: void* h;
! 487: void* t;
! 488: {
! 489: QueueElem* head = (QueueElem*) h;
! 490: void* base = GC_base( t );
! 491: void* d;
! 492: GC_finalization_proc f;
! 493: QueueElem* q = (QueueElem*) GC_MALLOC( sizeof( QueueElem ) );
! 494:
! 495: GC_REGISTER_FINALIZER( base, _CleanUp_Queue_Enqueue, q, &f, &d );
! 496: q->f = f;
! 497: q->d = d;
! 498: q->next = head;}
! 499:
! 500:
! 501: int _CleanUp_Queue_Call( h )
! 502: void* h;
! 503: {
! 504: QueueElem* head = (QueueElem*) h;
! 505: QueueElem* q = head->next;
! 506:
! 507: if (q == 0) {
! 508: return 0;}
! 509: else {
! 510: head->next = q->next;
! 511: q->next = 0;
! 512: if (q->f != 0) q->f( q->o, q->d );
! 513: return 1;}}
! 514:
! 515:
! 516:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gcc_support.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / gc