Return to gc_gcj.h CVS log

Up to [local] / OpenXM_contrib / gc / include

Annotation of OpenXM_contrib/gc/include/gc_gcj.h, Revision 1.1.1.1

1.1       maekawa     1: /*
                      2:  * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
                      3:  * Copyright (c) 1991-1995 by Xerox Corporation.  All rights reserved.
                      4:  * Copyright 1996-1999 by Silicon Graphics.  All rights reserved.
                      5:  * Copyright 1999 by Hewlett-Packard Company.  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 use or copy this program
                     11:  * for any purpose,  provided the above notices are retained on all copies.
                     12:  * Permission to modify the code and to distribute modified code is granted,
                     13:  * provided the above notices are retained, and a notice that the code was
                     14:  * modified is included with the above copyright notice.
                     15:  */
                     16:
                     17: /* This file assumes the collector has been compiled with GC_GCJ_SUPPORT */
                     18: /* and that an ANSI C compiler is available.                            */
                     19:
                     20: /*
                     21:  * We allocate objects whose first word contains a pointer to a struct
                     22:  * describing the object type.  This struct contains a garbage collector mark
                     23:  * descriptor at offset MARK_DESCR_OFFSET.  Alternatively, the objects
                     24:  * may be marked by the mark procedure passed to GC_init_gcj_malloc.
                     25:  */
                     26:
                     27: #ifndef MARK_DESCR_OFFSET
                     28: #  define MARK_DESCR_OFFSET    sizeof(word)
                     29: #endif
                     30:        /* Gcj keeps GC descriptor as second word of vtable.    This    */
                     31:        /* probably needs to be adjusted for other clients.             */
                     32:        /* We currently assume that this offset is such that:           */
                     33:        /*      - all objects of this kind are large enough to have     */
                     34:        /*        a value at that offset, and                           */
                     35:        /*      - it is not zero.                                       */
                     36:        /* These assumptions allow objects on the free list to be       */
                     37:        /* marked normally.                                             */
                     38:
                     39: #ifndef _GC_H
                     40: #   include "gc.h"
                     41: #endif
                     42:
                     43: /* The following allocators signal an out of memory condition with     */
                     44: /* return GC_oom_action();                                             */
                     45: /* The default GC_oom_action returns 0.                                        */
                     46: /* This functionality is currently restricted to the gcj allocators.   */
                     47: /* We may want to extend it to the others.                             */
                     48:
                     49: extern void * (*GC_oom_action)(void);
                     50:
                     51: /* The following function must be called before the gcj allocators     */
                     52: /* can be invoked.                                                     */
                     53: /* mp_index and mp are the index and mark_proc (see gc_mark.h)         */
                     54: /* respectively for the allocated objects.  Mark_proc will be          */
                     55: /* used to build the descriptor for objects allocated through the      */
                     56: /* debugging interface.  The mark_proc will be invoked on all such     */
                     57: /* objects with an "environment" value of 1.  The client may chose     */
                     58: /* to use the same mark_proc for some of its generated mark descriptors.*/
                     59: /* In that case, it should use a different "environment" value to      */
                     60: /* detect the presence or absence of the debug header.                 */
                     61:
                     62: /* the debugging interface.                                            */
                     63: /* Mp is really of type mark_proc, as defined in gc_mark.h.  We don't  */
                     64: /* want to include that here for namespace pollution reasons.          */
                     65: extern void GC_init_gcj_malloc(int mp_index, void * /* really mark_proc */mp);
                     66:
                     67: /* Allocate an object, clear it, and store the pointer to the  */
                     68: /* type structure (vtable in gcj).                             */
                     69: /* This adds a byte at the end of the object if GC_malloc would.*/
                     70: extern void * GC_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr);
                     71: /* The debug versions allocate such that the specified mark_proc       */
                     72: /* is always invoked.                                                  */
                     73: extern void * GC_debug_gcj_malloc(size_t lb,
                     74:                                  void * ptr_to_struct_containing_descr,
                     75:                                  GC_EXTRA_PARAMS);
                     76:
                     77: /* Similar to the above, but the size is in words, and we don't        */
                     78: /* adjust it.  The size is assumed to be such that it can be   */
                     79: /* allocated as a small object.                                        */
                     80: extern void * GC_gcj_fast_malloc(size_t lw,
                     81:                                 void * ptr_to_struct_containing_descr);
                     82: extern void * GC_debug_gcj_fast_malloc(size_t lw,
                     83:                                 void * ptr_to_struct_containing_descr,
                     84:                                 GC_EXTRA_PARAMS);
                     85:
                     86: /* Similar to GC_gcj_malloc, but assumes that a pointer to near the    */
                     87: /* beginning of the resulting object is always maintained.             */
                     88: extern void * GC_gcj_malloc_ignore_off_page(size_t lb,
                     89:                                void * ptr_to_struct_containing_descr);
                     90:
                     91: # ifdef GC_DEBUG
                     92: #   define GC_GCJ_MALLOC(s,d) GC_debug_gcj_malloc(s,d,GC_EXTRAS)
                     93: #   define GC_GCJ_FAST_MALLOC(s,d) GC_debug_gcj_fast_malloc(s,d,GC_EXTRAS)
                     94: #   define GC_GCJ_MALLOC_IGNORE_OFF_PAGE(s,d) GC_gcj_debug_malloc(s,d,GC_EXTRAS)
                     95: # else
                     96: #   define GC_GCJ_MALLOC(s,d) GC_gcj_malloc(s,d)
                     97: #   define GC_GCJ_FAST_MALLOC(s,d) GC_gcj_fast_malloc(s,d)
                     98: #   define GC_GCJ_MALLOC_IGNORE_OFF_PAGE(s,d) \
                     99:        GC_gcj_debug_malloc_ignore_off_page(s,d)
                    100: # endif
                    101: