mono/metadata/null-gc.c

   1 /*
   2  * null-gc.c: GC implementation using malloc: will leak everything, just for testing.
   3  *
   4  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
   5  * Copyright 2004-2011 Novell, Inc (http://www.novell.com)
   6  * Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
   7  */
   8
   9 #include "config.h"
  10 #include <glib.h>
  11 #include <mono/metadata/mono-gc.h>
  12 #include <mono/metadata/gc-internal.h>
  13 #include <mono/metadata/runtime.h>
  14
  15 #ifdef HAVE_NULL_GC
  16
  17 void
  18 mono_gc_base_init (void)
  19 {
  20         MonoThreadInfoCallbacks cb;
  21
  22         memset (&cb, 0, sizeof (cb));
  23         cb.mono_method_is_critical = mono_runtime_is_critical_method;
  24         cb.mono_gc_pthread_create = (gpointer)mono_gc_pthread_create;
  25 }
  26
  27 void
  28 mono_gc_collect (int generation)
  29 {
  30 }
  31
  32 int
  33 mono_gc_max_generation (void)
  34 {
  35         return 0;
  36 }
  37
  38 int
  39 mono_gc_get_generation  (MonoObject *object)
  40 {
  41         return 0;
  42 }
  43
  44 int
  45 mono_gc_collection_count (int generation)
  46 {
  47         return 0;
  48 }
  49
  50 void
  51 mono_gc_add_memory_pressure (gint64 value)
  52 {
  53 }
  54
  55 /* maybe track the size, not important, though */
  56 int64_t
  57 mono_gc_get_used_size (void)
  58 {
  59         return 1024*1024;
  60 }
  61
  62 int64_t
  63 mono_gc_get_heap_size (void)
  64 {
  65         return 2*1024*1024;
  66 }
  67
  68 void
  69 mono_gc_disable (void)
  70 {
  71 }
  72
  73 void
  74 mono_gc_enable (void)
  75 {
  76 }
  77
  78 gboolean
  79 mono_gc_is_gc_thread (void)
  80 {
  81         return TRUE;
  82 }
  83
  84 gboolean
  85 mono_gc_register_thread (void *baseptr)
  86 {
  87         return TRUE;
  88 }
  89
  90 int
  91 mono_gc_walk_heap (int flags, MonoGCReferences callback, void *data)
  92 {
  93         return 1;
  94 }
  95
  96 gboolean
  97 mono_object_is_alive (MonoObject* o)
  98 {
  99         return TRUE;
 100 }
 101
 102 void
 103 mono_gc_enable_events (void)
 104 {
 105 }
 106
 107 int
 108 mono_gc_register_root (char *start, size_t size, void *descr)
 109 {
 110         return TRUE;
 111 }
 112
 113 void
 114 mono_gc_deregister_root (char* addr)
 115 {
 116 }
 117
 118 void
 119 mono_gc_weak_link_add (void **link_addr, MonoObject *obj, gboolean track)
 120 {
 121         *link_addr = obj;
 122 }
 123
 124 void
 125 mono_gc_weak_link_remove (void **link_addr)
 126 {
 127         *link_addr = NULL;
 128 }
 129
 130 MonoObject*
 131 mono_gc_weak_link_get (void **link_addr)
 132 {
 133         return *link_addr;
 134 }
 135
 136 void*
 137 mono_gc_make_descr_for_string (gsize *bitmap, int numbits)
 138 {
 139         return NULL;
 140 }
 141
 142 void*
 143 mono_gc_make_descr_for_object (gsize *bitmap, int numbits, size_t obj_size)
 144 {
 145         return NULL;
 146 }
 147
 148 void*
 149 mono_gc_make_descr_for_array (int vector, gsize *elem_bitmap, int numbits, size_t elem_size)
 150 {
 151         return NULL;
 152 }
 153
 154 void*
 155 mono_gc_make_descr_from_bitmap (gsize *bitmap, int numbits)
 156 {
 157         return NULL;
 158 }
 159
 160 void*
 161 mono_gc_make_root_descr_all_refs (int numbits)
 162 {
 163         return NULL;
 164 }
 165
 166 void*
 167 mono_gc_alloc_fixed (size_t size, void *descr)
 168 {
 169         return g_malloc0 (size);
 170 }
 171
 172 void
 173 mono_gc_free_fixed (void* addr)
 174 {
 175         g_free (addr);
 176 }
 177
 178 void
 179 mono_gc_wbarrier_set_field (MonoObject *obj, gpointer field_ptr, MonoObject* value)
 180 {
 181         *(void**)field_ptr = value;
 182 }
 183
 184 void
 185 mono_gc_wbarrier_set_arrayref (MonoArray *arr, gpointer slot_ptr, MonoObject* value)
 186 {
 187         *(void**)slot_ptr = value;
 188 }
 189
 190 void
 191 mono_gc_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int count)
 192 {
 193         mono_gc_memmove (dest_ptr, src_ptr, count * sizeof (gpointer));
 194 }
 195
 196 void
 197 mono_gc_wbarrier_generic_store (gpointer ptr, MonoObject* value)
 198 {
 199         *(void**)ptr = value;
 200 }
 201
 202 void
 203 mono_gc_wbarrier_generic_nostore (gpointer ptr)
 204 {
 205 }
 206
 207 void
 208 mono_gc_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoClass *klass)
 209 {
 210         mono_gc_memmove (dest, src, count * mono_class_value_size (klass, NULL));
 211 }
 212
 213 void
 214 mono_gc_wbarrier_object_copy (MonoObject* obj, MonoObject *src)
 215 {
 216         /* do not copy the sync state */
 217         mono_gc_memmove ((char*)obj + sizeof (MonoObject), (char*)src + sizeof (MonoObject),
 218                         mono_object_class (obj)->instance_size - sizeof (MonoObject));
 219 }
 220
 221 gboolean
 222 mono_gc_is_critical_method (MonoMethod *method)
 223 {
 224         return FALSE;
 225 }
 226
 227 MonoMethod*
 228 mono_gc_get_managed_allocator (MonoVTable *vtable, gboolean for_box)
 229 {
 230         return NULL;
 231 }
 232
 233 MonoMethod*
 234 mono_gc_get_managed_array_allocator (MonoVTable *vtable, int rank)
 235 {
 236         return NULL;
 237 }
 238
 239 MonoMethod*
 240 mono_gc_get_managed_allocator_by_type (int atype)
 241 {
 242         return NULL;
 243 }
 244
 245 guint32
 246 mono_gc_get_managed_allocator_types (void)
 247 {
 248         return 0;
 249 }
 250
 251 const char *
 252 mono_gc_get_gc_name (void)
 253 {
 254         return "null";
 255 }
 256
 257 void
 258 mono_gc_add_weak_track_handle (MonoObject *obj, guint32 gchandle)
 259 {
 260 }
 261
 262 void
 263 mono_gc_change_weak_track_handle (MonoObject *old_obj, MonoObject *obj, guint32 gchandle)
 264 {
 265 }
 266
 267 void
 268 mono_gc_remove_weak_track_handle (guint32 gchandle)
 269 {
 270 }
 271
 272 GSList*
 273 mono_gc_remove_weak_track_object (MonoDomain *domain, MonoObject *obj)
 274 {
 275         return NULL;
 276 }
 277
 278 void
 279 mono_gc_clear_domain (MonoDomain *domain)
 280 {
 281 }
 282
 283 int
 284 mono_gc_get_suspend_signal (void)
 285 {
 286         return -1;
 287 }
 288
 289 MonoMethod*
 290 mono_gc_get_write_barrier (void)
 291 {
 292         g_assert_not_reached ();
 293         return NULL;
 294 }
 295
 296 void*
 297 mono_gc_invoke_with_gc_lock (MonoGCLockedCallbackFunc func, void *data)
 298 {
 299         return func (data);
 300 }
 301
 302 char*
 303 mono_gc_get_description (void)
 304 {
 305         return g_strdup (DEFAULT_GC_NAME);
 306 }
 307
 308 void
 309 mono_gc_set_desktop_mode (void)
 310 {
 311 }
 312
 313 gboolean
 314 mono_gc_is_moving (void)
 315 {
 316         return FALSE;
 317 }
 318
 319 gboolean
 320 mono_gc_is_disabled (void)
 321 {
 322         return FALSE;
 323 }
 324
 325 void
 326 mono_gc_wbarrier_value_copy_bitmap (gpointer _dest, gpointer _src, int size, unsigned bitmap)
 327 {
 328         g_assert_not_reached ();
 329 }
 330
 331 guint8*
 332 mono_gc_get_card_table (int *shift_bits, gpointer *card_mask)
 333 {
 334         g_assert_not_reached ();
 335         return NULL;
 336 }
 337
 338 void*
 339 mono_gc_get_nursery (int *shift_bits, size_t *size)
 340 {
 341         return NULL;
 342 }
 343
 344 gboolean
 345 mono_gc_precise_stack_mark_enabled (void)
 346 {
 347         return FALSE;
 348 }
 349
 350 FILE *
 351 mono_gc_get_logfile (void)
 352 {
 353         return NULL;
 354 }
 355
 356 void
 357 mono_gc_conservatively_scan_area (void *start, void *end)
 358 {
 359         g_assert_not_reached ();
 360 }
 361
 362 void *
 363 mono_gc_scan_object (void *obj)
 364 {
 365         g_assert_not_reached ();
 366         return NULL;
 367 }
 368
 369 gsize*
 370 mono_gc_get_bitmap_for_descr (void *descr, int *numbits)
 371 {
 372         g_assert_not_reached ();
 373         return NULL;
 374 }
 375
 376 void
 377 mono_gc_set_gc_callbacks (MonoGCCallbacks *callbacks)
 378 {
 379 }
 380
 381 #ifndef HOST_WIN32
 382
 383 int
 384 mono_gc_pthread_create (pthread_t *new_thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
 385 {
 386         return pthread_create (new_thread, attr, start_routine, arg);
 387 }
 388
 389 int
 390 mono_gc_pthread_join (pthread_t thread, void **retval)
 391 {
 392         return pthread_join (thread, retval);
 393 }
 394
 395 int
 396 mono_gc_pthread_detach (pthread_t thread)
 397 {
 398         return pthread_detach (thread);
 399 }
 400
 401 void
 402 mono_gc_pthread_exit (void *retval)
 403 {
 404         pthread_exit (retval);
 405 }
 406
 407 #endif
 408
 409 #ifdef HOST_WIN32
 410 BOOL APIENTRY mono_gc_dllmain (HMODULE module_handle, DWORD reason, LPVOID reserved)
 411 {
 412         return TRUE;
 413 }
 414 #endif
 415
 416 #endif