src/boehm-gc/pcr_interface.c

   1 /*
   2  * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
   3  *
   4  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
   5  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
   6  *
   7  * Permission is hereby granted to use or copy this program
   8  * for any purpose,  provided the above notices are retained on all copies.
   9  * Permission to modify the code and to distribute modified code is granted,
  10  * provided the above notices are retained, and a notice that the code was
  11  * modified is included with the above copyright notice.
  12  */
  13
  14 #include "config.h"
  15
  16 # include "private/gc_priv.h"
  17
  18 # ifdef PCR
  19 /*
  20  * Note that POSIX PCR requires an ANSI C compiler.  Hence we are allowed
  21  * to make the same assumption here.
  22  * We wrap all of the allocator functions to avoid questions of
  23  * compatibility between the prototyped and nonprototyped versions of the f
  24  */
  25 # include "config/PCR_StdTypes.h"
  26 # include "mm/PCR_MM.h"
  27 # include <errno.h>
  28
  29 # define MY_MAGIC 17L
  30 # define MY_DEBUGMAGIC 42L
  31
  32 void * GC_AllocProc(size_t size, PCR_Bool ptrFree, PCR_Bool clear )
  33 {
  34     if (ptrFree) {
  35         void * result = (void *)GC_malloc_atomic(size);
  36         if (clear && result != 0) BZERO(result, size);
  37         return(result);
  38     } else {
  39         return((void *)GC_malloc(size));
  40     }
  41 }
  42
  43 void * GC_DebugAllocProc(size_t size, PCR_Bool ptrFree, PCR_Bool clear )
  44 {
  45     if (ptrFree) {
  46         void * result = (void *)GC_debug_malloc_atomic(size, __FILE__,
  47                                                              __LINE__);
  48         if (clear && result != 0) BZERO(result, size);
  49         return(result);
  50     } else {
  51         return((void *)GC_debug_malloc(size, __FILE__, __LINE__));
  52     }
  53 }
  54
  55 # define GC_ReallocProc GC_realloc
  56 void * GC_DebugReallocProc(void * old_object, size_t new_size_in_bytes)
  57 {
  58     return(GC_debug_realloc(old_object, new_size_in_bytes, __FILE__, __LINE__));
  59 }
  60
  61 # define GC_FreeProc GC_free
  62 # define GC_DebugFreeProc GC_debug_free
  63
  64 typedef struct {
  65   PCR_ERes (*ed_proc)(void *p, size_t size, PCR_Any data);
  66   GC_bool ed_pointerfree;
  67   PCR_ERes ed_fail_code;
  68   PCR_Any ed_client_data;
  69 } enumerate_data;
  70
  71 void GC_enumerate_block(h, ed)
  72 register struct hblk *h;
  73 enumerate_data * ed;
  74 {
  75     register hdr * hhdr;
  76     register int sz;
  77     word *p;
  78     word * lim;
  79
  80     hhdr = HDR(h);
  81     sz = hhdr -> hb_sz;
  82     if (sz >= 0 && ed -> ed_pointerfree
  83         || sz <= 0 && !(ed -> ed_pointerfree)) return;
  84     if (sz < 0) sz = -sz;
  85     lim = (word *)(h+1) - sz;
  86     p = (word *)h;
  87     do {
  88         if (PCR_ERes_IsErr(ed -> ed_fail_code)) return;
  89         ed -> ed_fail_code =
  90             (*(ed -> ed_proc))(p, WORDS_TO_BYTES(sz), ed -> ed_client_data);
  91         p+= sz;
  92     } while (p <= lim);
  93 }
  94
  95 struct PCR_MM_ProcsRep * GC_old_allocator = 0;
  96
  97 PCR_ERes GC_EnumerateProc(
  98     PCR_Bool ptrFree,
  99     PCR_ERes (*proc)(void *p, size_t size, PCR_Any data),
 100     PCR_Any data
 101 )
 102 {
 103     enumerate_data ed;
 104
 105     ed.ed_proc = proc;
 106     ed.ed_pointerfree = ptrFree;
 107     ed.ed_fail_code = PCR_ERes_okay;
 108     ed.ed_client_data = data;
 109     GC_apply_to_all_blocks(GC_enumerate_block, &ed);
 110     if (ed.ed_fail_code != PCR_ERes_okay) {
 111         return(ed.ed_fail_code);
 112     } else {
 113         /* Also enumerate objects allocated by my predecessors */
 114         return((*(GC_old_allocator->mmp_enumerate))(ptrFree, proc, data));
 115     }
 116 }
 117
 118 void GC_DummyFreeProc(void *p) {}
 119
 120 void GC_DummyShutdownProc(void) {}
 121
 122 struct PCR_MM_ProcsRep GC_Rep = {
 123         MY_MAGIC,
 124         GC_AllocProc,
 125         GC_ReallocProc,
 126         GC_DummyFreeProc,       /* mmp_free */
 127         GC_FreeProc,            /* mmp_unsafeFree */
 128         GC_EnumerateProc,
 129         GC_DummyShutdownProc    /* mmp_shutdown */
 130 };
 131
 132 struct PCR_MM_ProcsRep GC_DebugRep = {
 133         MY_DEBUGMAGIC,
 134         GC_DebugAllocProc,
 135         GC_DebugReallocProc,
 136         GC_DummyFreeProc,       /* mmp_free */
 137         GC_DebugFreeProc,               /* mmp_unsafeFree */
 138         GC_EnumerateProc,
 139         GC_DummyShutdownProc    /* mmp_shutdown */
 140 };
 141
 142 GC_bool GC_use_debug = 0;
 143
 144 void GC_pcr_install()
 145 {
 146     PCR_MM_Install((GC_use_debug? &GC_DebugRep : &GC_Rep), &GC_old_allocator);
 147 }
 148
 149 PCR_ERes
 150 PCR_GC_Setup(void)
 151 {
 152     return PCR_ERes_okay;
 153 }
 154
 155 PCR_ERes
 156 PCR_GC_Run(void)
 157 {
 158
 159     if( !PCR_Base_TestPCRArg("-nogc") ) {
 160         GC_quiet = ( PCR_Base_TestPCRArg("-gctrace") ? 0 : 1 );
 161         GC_use_debug = (GC_bool)PCR_Base_TestPCRArg("-debug_alloc");
 162         GC_init();
 163         if( !PCR_Base_TestPCRArg("-nogc_incremental") ) {
 164             /*
 165              * awful hack to test whether VD is implemented ...
 166              */
 167             if( PCR_VD_Start( 0, NIL, 0) != PCR_ERes_FromErr(ENOSYS) ) {
 168                 GC_enable_incremental();
 169             }
 170         }
 171     }
 172     return PCR_ERes_okay;
 173 }
 174
 175 void GC_push_thread_structures(void)
 176 {
 177     /* PCR doesn't work unless static roots are pushed.  Can't get here. */
 178     ABORT("In GC_push_thread_structures()");
 179 }
 180
 181 # endif