Return to gc_gcj.h CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / gc / include

Annotation of OpenXM_contrib2/asir2000/gc/include/gc_gcj.h, Revision 1.1

1.1     ! noro        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 GC_GCJ_H
        !            28:
        !            29: #define GC_GCJ_H
        !            30:
        !            31: #ifndef MARK_DESCR_OFFSET
        !            32: #  define MARK_DESCR_OFFSET    sizeof(word)
        !            33: #endif
        !            34:        /* Gcj keeps GC descriptor as second word of vtable.    This    */
        !            35:        /* probably needs to be adjusted for other clients.             */
        !            36:        /* We currently assume that this offset is such that:           */
        !            37:        /*      - all objects of this kind are large enough to have     */
        !            38:        /*        a value at that offset, and                           */
        !            39:        /*      - it is not zero.                                       */
        !            40:        /* These assumptions allow objects on the free list to be       */
        !            41:        /* marked normally.                                             */
        !            42:
        !            43: #ifndef _GC_H
        !            44: #   include "gc.h"
        !            45: #endif
        !            46:
        !            47: /* The following allocators signal an out of memory condition with     */
        !            48: /* return GC_oom_fn(bytes);                                            */
        !            49:
        !            50: extern void * (*GC_oom_action)(void);
        !            51:
        !            52: /* The following function must be called before the gcj allocators     */
        !            53: /* can be invoked.                                                     */
        !            54: /* mp_index and mp are the index and mark_proc (see gc_mark.h)         */
        !            55: /* respectively for the allocated objects.  Mark_proc will be          */
        !            56: /* used to build the descriptor for objects allocated through the      */
        !            57: /* debugging interface.  The mark_proc will be invoked on all such     */
        !            58: /* objects with an "environment" value of 1.  The client may chose     */
        !            59: /* to use the same mark_proc for some of its generated mark descriptors.*/
        !            60: /* In that case, it should use a different "environment" value to      */
        !            61: /* detect the presence or absence of the debug header.                 */
        !            62: /* Mp is really of type mark_proc, as defined in gc_mark.h.  We don't  */
        !            63: /* want to include that here for namespace pollution reasons.          */
        !            64: extern void GC_init_gcj_malloc(int mp_index, void * /* really mark_proc */mp);
        !            65:
        !            66: /* Allocate an object, clear it, and store the pointer to the  */
        !            67: /* type structure (vtable in gcj).                             */
        !            68: /* This adds a byte at the end of the object if GC_malloc would.*/
        !            69: extern void * GC_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr);
        !            70: /* The debug versions allocate such that the specified mark_proc       */
        !            71: /* is always invoked.                                                  */
        !            72: extern void * GC_debug_gcj_malloc(size_t lb,
        !            73:                                  void * ptr_to_struct_containing_descr,
        !            74:                                  GC_EXTRA_PARAMS);
        !            75:
        !            76: /* Similar to the above, but the size is in words, and we don't        */
        !            77: /* adjust it.  The size is assumed to be such that it can be   */
        !            78: /* allocated as a small object.                                        */
        !            79: /* Unless it is known that the collector is not configured     */
        !            80: /* with USE_MARK_BYTES and unless it is known that the object  */
        !            81: /* has weak alignment requirements, lw must be even.           */
        !            82: extern void * GC_gcj_fast_malloc(size_t lw,
        !            83:                                 void * ptr_to_struct_containing_descr);
        !            84: extern void * GC_debug_gcj_fast_malloc(size_t lw,
        !            85:                                 void * ptr_to_struct_containing_descr,
        !            86:                                 GC_EXTRA_PARAMS);
        !            87:
        !            88: /* Similar to GC_gcj_malloc, but assumes that a pointer to near the    */
        !            89: /* beginning of the resulting object is always maintained.             */
        !            90: extern void * GC_gcj_malloc_ignore_off_page(size_t lb,
        !            91:                                void * ptr_to_struct_containing_descr);
        !            92:
        !            93: # ifdef GC_DEBUG
        !            94: #   define GC_GCJ_MALLOC(s,d) GC_debug_gcj_malloc(s,d,GC_EXTRAS)
        !            95: #   define GC_GCJ_FAST_MALLOC(s,d) GC_debug_gcj_fast_malloc(s,d,GC_EXTRAS)
        !            96: #   define GC_GCJ_MALLOC_IGNORE_OFF_PAGE(s,d) GC_debug_gcj_malloc(s,d,GC_EXTRAS)
        !            97: # else
        !            98: #   define GC_GCJ_MALLOC(s,d) GC_gcj_malloc(s,d)
        !            99: #   define GC_GCJ_FAST_MALLOC(s,d) GC_gcj_fast_malloc(s,d)
        !           100: #   define GC_GCJ_MALLOC_IGNORE_OFF_PAGE(s,d) \
        !           101:        GC_gcj_malloc_ignore_off_page(s,d)
        !           102: # endif
        !           103:
        !           104: #endif /* GC_GCJ_H */