mcs/class/System.Windows.Forms/System.Windows.Forms/monogc.c

   1 //
   2 // monogc.c
   3 //
   4 // Author:
   5 // implementation started by John Sohn (jsohn@columbus.rr.com)
   6 // Alexandre Pigolkine (pigolkine@gmx.de)
   7 // Jonathan Gilbert
   8 //
   9 // (C) Ximian, Inc., 2002/2003
  10 //
  11 #include <windows.h>
  12 #include <stdio.h>
  13 #include <gc/gc.h>
  14 #include <gc/gc_typed.h>
  15 #include <pthread.h>
  16
  17 int GC_finalize_on_demand = -1;
  18 void (* GC_finalizer_notifier)() = (void (*) GC_PROTO((void)))0;
  19 HMODULE moduleGC;
  20
  21 typedef GC_PTR (*gc_malloc_ptrt)(size_t lb);
  22 typedef int (*gc_push_all_stack_ptrt)(GC_PTR b, GC_PTR t);
  23 typedef int (*gc_init_gcj_malloc_ptrt)(int mp_index, void * mp);
  24 typedef void* (* gc_gcj_malloc_ptrt)(size_t lb, void * ptr_to_struct_containing_descr);
  25 typedef int (*gc_make_descriptor_ptrt)(GC_bitmap b, size_t t);
  26 typedef int (*gc_should_invoke_finalizers_ptrt)(void);
  27 typedef void (*gc_register_finalizer_ptrt)(GC_PTR obj, GC_finalization_proc fn,
  28                                            GC_PTR cd, GC_finalization_proc *ofn, GC_PTR *ocd);
  29 typedef GC_PTR (*gc_malloc_atomic_ptrt)(size_t lb);
  30 typedef GC_PTR (*gc_realloc_ptrt)(GC_PTR old_object, size_t new_size_in_bytes);
  31 typedef GC_PTR (*gc_base_ptrt)(GC_PTR displaced_pointer);
  32 typedef GC_PTR (*gc_free_ptrt)(GC_PTR object_addr);
  33 typedef GC_PTR (*gc_gcollect_ptrt)();
  34 typedef size_t (*gc_get_heap_size_ptrt)();
  35 typedef int (*gc_invoke_finalizers_ptrt)();
  36
  37 gc_malloc_ptrt             gc_malloc;
  38 gc_push_all_stack_ptrt     gc_push_all_stack;
  39 gc_init_gcj_malloc_ptrt    gc_init_gcj_malloc;
  40 gc_gcj_malloc_ptrt         gc_gcj_malloc;
  41 gc_make_descriptor_ptrt    gc_make_descriptor;
  42 gc_should_invoke_finalizers_ptrt  gc_should_invoke_finalizers;
  43 gc_register_finalizer_ptrt gc_register_finalizer;
  44 gc_malloc_atomic_ptrt      gc_malloc_atomic;
  45 gc_realloc_ptrt            gc_realloc;
  46 gc_base_ptrt               gc_base;
  47 gc_free_ptrt               gc_free;
  48 gc_gcollect_ptrt           gc_gcollect;
  49 gc_get_heap_size_ptrt      gc_get_heap_size;
  50 gc_invoke_finalizers_ptrt  gc_invoke_finalizers;
  51
  52 static int printf_stub(const char *format,...)
  53 {
  54         return 0;
  55 }
  56
  57 #define TRACE printf_stub
  58
  59 void InitGC ()
  60 {
  61         printf_stub(0); // suppress warning
  62         if(moduleGC == 0){
  63                 printf ("Initializing Boehm GC library...\n");
  64                 moduleGC = LoadLibraryA ("gc.dll");
  65
  66                 if (moduleGC == NULL) {
  67                         printf ("Boehm GC library cannot be loaded");
  68                         exit (1);
  69                 }
  70
  71                 gc_malloc = (gc_malloc_ptrt)GetProcAddress (moduleGC, "GC_malloc");
  72                 gc_push_all_stack = (gc_push_all_stack_ptrt) GetProcAddress (moduleGC, "GC_push_all_stack");
  73                 gc_init_gcj_malloc = (gc_init_gcj_malloc_ptrt) GetProcAddress (moduleGC, "GC_init_gcj_malloc");
  74                 gc_gcj_malloc = (gc_gcj_malloc_ptrt) GetProcAddress (moduleGC, "GC_gcj_malloc");
  75                 gc_make_descriptor = (gc_make_descriptor_ptrt) GetProcAddress (moduleGC, "GC_make_descriptor");
  76                 gc_should_invoke_finalizers = (gc_should_invoke_finalizers_ptrt)
  77                                         GetProcAddress (moduleGC, "GC_should_invoke_finalizers");
  78                 gc_register_finalizer =
  79                         (gc_register_finalizer_ptrt)GetProcAddress (moduleGC, "GC_register_finalizer");
  80                 gc_malloc_atomic = (gc_malloc_atomic_ptrt)GetProcAddress (moduleGC, "GC_malloc_atomic");
  81                 gc_realloc = (gc_realloc_ptrt)GetProcAddress (moduleGC, "GC_realloc");
  82                 gc_base = (gc_base_ptrt)GetProcAddress (moduleGC, "GC_base");
  83                 gc_free = (gc_free_ptrt) GetProcAddress (moduleGC, "GC_free");
  84                 gc_gcollect = (gc_gcollect_ptrt) GetProcAddress (moduleGC, "GC_gcollect");
  85                 gc_get_heap_size = (gc_get_heap_size_ptrt) GetProcAddress (moduleGC, "GC_get_heap_size");
  86                 gc_invoke_finalizers =
  87                         (gc_invoke_finalizers_ptrt) GetProcAddress (moduleGC, "GC_invoke_finalizers");
  88
  89                 printf("done!\n");
  90         }
  91 }
  92
  93 GC_PTR GC_malloc (size_t lb)
  94 {
  95         GC_PTR status = NULL;
  96         InitGC ();
  97
  98         TRACE ("GC_malloc start\n");
  99         status = gc_malloc (lb);
 100         TRACE ("GC_malloc end\n");
 101         return status;
 102 }
 103
 104 void GC_push_all_stack (GC_PTR b, GC_PTR t)
 105 {
 106         InitGC ();
 107         TRACE ("GC_push_all_stack\n");
 108         gc_push_all_stack (b,t);
 109         TRACE ("GC_push_all_stack end\n");
 110 }
 111
 112 void GC_init_gcj_malloc(int mp_index, void * /* really GC_mark_proc */mp)
 113 {
 114         InitGC ();
 115         TRACE ("GC_init_gcj_malloc\n");
 116         gc_init_gcj_malloc (mp_index,mp);
 117         TRACE ("GC_init_gcj_malloc end\n");
 118 }
 119
 120 void * GC_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr)
 121 {
 122         void *result = 0;
 123         InitGC ();
 124         TRACE ("gc_gcj_malloc bytes %d\n", lb);
 125         result = gc_gcj_malloc (lb,ptr_to_struct_containing_descr);
 126         TRACE ("gc_gcj_malloc end %p\n", result);
 127         return result;
 128 }
 129
 130 GC_descr GC_make_descriptor(GC_bitmap bm, size_t len)
 131 {
 132         GC_descr result = 0;
 133         InitGC ();
 134         TRACE ("GC_make_descriptor\n");
 135         result = gc_make_descriptor (bm,len);
 136         TRACE ("GC_make_descriptor end\n");
 137         return result;
 138 }
 139
 140 int GC_should_invoke_finalizers(void)
 141 {
 142         int result = 0;
 143         InitGC ();
 144         TRACE ("GC_should_invoke_finalizers\n");
 145         result = gc_should_invoke_finalizers ();
 146         TRACE ("GC_should_invoke_finalizers end\n");
 147         return result;
 148 }
 149
 150 void GC_register_finalizer (GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
 151                 GC_finalization_proc *ofn, GC_PTR *ocd)
 152 {
 153         InitGC ();
 154         TRACE ("GC_register_finalizer\n");
 155         gc_register_finalizer (obj, fn, cd, ofn, ocd);
 156         TRACE ("GC_register_finalizer end\n");
 157 }
 158
 159 void GC_register_finalizer_no_order (GC_PTR obj, GC_finalization_proc fn,
 160                                      GC_PTR cd, GC_finalization_proc *ofn,
 161                                      GC_PTR *ocd)
 162 {
 163         InitGC ();
 164         TRACE ("GC_register_finalizer_no_order\n");
 165         gc_register_finalizer (obj, fn, cd, ofn, ocd);
 166         TRACE ("GC_register_finalizer_no_order end\n");
 167 }
 168
 169
 170 GC_PTR GC_debug_malloc (size_t size_in_bytes, GC_EXTRA_PARAMS)
 171 {
 172         return GC_malloc (size_in_bytes);
 173 }
 174
 175 GC_PTR GC_malloc_atomic (size_t size_in_bytes)
 176 {
 177         GC_PTR status = NULL;
 178         InitGC ();
 179         TRACE ("GC_malloc_atomic start\n");
 180         status = gc_malloc_atomic (size_in_bytes);
 181         TRACE ("GC_malloc_atomic end\n");
 182         return status;
 183 }
 184
 185 GC_PTR GC_realloc (GC_PTR old_object, size_t new_size_in_bytes)
 186 {
 187         GC_PTR status = NULL;
 188         InitGC ();
 189         TRACE ("GC_realloc start\n");
 190         status = gc_realloc (old_object, new_size_in_bytes);
 191         TRACE ("GC_realloc end\n");
 192         return status;
 193 }
 194
 195 GC_PTR GC_base (GC_PTR displaced_pointer)
 196 {
 197         GC_PTR status = NULL;
 198         InitGC ();
 199
 200         TRACE ("GC_base start\n");
 201         status = gc_base (displaced_pointer);
 202         TRACE ("GC_base end\n");
 203         return status;
 204 }
 205
 206 void GC_free (GC_PTR object_addr)
 207 {
 208         InitGC ();
 209         TRACE ("GC_free start\n");
 210         gc_free (object_addr);
 211         TRACE ("GC_free end\n");
 212 }
 213
 214 void GC_gcollect ()
 215 {
 216         InitGC ();
 217         TRACE ("GC_gcollect start\n");
 218         gc_gcollect ();
 219         TRACE ("GC_gcollect end\n");
 220 }
 221
 222 size_t GC_get_heap_size ()
 223 {
 224         size_t status = 0;
 225         InitGC ();
 226
 227         TRACE ("GC_get_heap_size start\n");
 228         status = gc_get_heap_size ();
 229         TRACE ("GC_get_heap_size end\n");
 230         return status;
 231 }
 232
 233 int GC_invoke_finalizers ()
 234 {
 235         int status = 0;
 236         InitGC ();
 237
 238         TRACE ("GC_invoke_finalizers start\n");
 239         status = gc_invoke_finalizers ();
 240         TRACE ("GC_invoke_finalizers end\n");
 241         return status;
 242 }
 243
 244 int GC_unregister_disappearing_link (GC_PTR *link)
 245 {
 246         TRACE ("GC_unregister_disappearing_link (not implenented)\n");
 247         return 0;
 248 }
 249
 250 int GC_general_register_disappearing_link (GC_PTR *link, GC_PTR obj)
 251 {
 252         TRACE ("GC_general_register_disappearing_link (not implemented)\n");
 253         return 0;
 254 }
 255
 256 // GC pthread wrapper
 257 int GC_pthread_create (pthread_t *new_thread,
 258                        const pthread_attr_t *attr,
 259                        void *(*start_routine)(void *), void *arg)
 260 {
 261         TRACE ("GC_pthread_create\n");
 262         return pthread_create (new_thread, attr, start_routine, arg);
 263 }
 264
 265 int GC_pthread_sigmask (int how, const sigset_t *set, sigset_t *oset)
 266 {
 267         TRACE ("GC_pthread_sigmask\n");
 268         pthread_sigmask (how, set, oset);
 269 }
 270
 271 int GC_pthread_join (pthread_t thread, void **retval)
 272 {
 273         TRACE ("GC_pthread_join\n");
 274         return pthread_join (thread, retval);
 275 }
 276
 277 int GC_pthread_detach (pthread_t thread)
 278 {
 279         TRACE ("GC_pthread_detach\n");
 280         return pthread_detach (thread);
 281 }