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-internals.h>
  13 #include <mono/metadata/runtime.h>
  14 #include <mono/utils/atomic.h>
  15 #include <mono/utils/mono-threads.h>
  16 #include <mono/utils/mono-counters.h>
  17
  18 #ifdef HAVE_NULL_GC
  19
  20 void
  21 mono_gc_base_init (void)
  22 {
  23         MonoThreadInfoCallbacks cb;
  24         int dummy;
  25
  26         mono_counters_init ();
  27
  28         memset (&cb, 0, sizeof (cb));
  29         /* TODO: This casts away an incompatible pointer type warning in the same
  30                  manner that boehm-gc does it. This is probably worth investigating
  31                  more carefully. */
  32         cb.mono_method_is_critical = (gpointer)mono_runtime_is_critical_method;
  33
  34         mono_threads_init (&cb, sizeof (MonoThreadInfo));
  35
  36         mono_thread_info_attach (&dummy);
  37 }
  38
  39 void
  40 mono_gc_base_cleanup (void)
  41 {
  42 }
  43
  44 void
  45 mono_gc_collect (int generation)
  46 {
  47 }
  48
  49 int
  50 mono_gc_max_generation (void)
  51 {
  52         return 0;
  53 }
  54
  55 int
  56 mono_gc_get_generation  (MonoObject *object)
  57 {
  58         return 0;
  59 }
  60
  61 int
  62 mono_gc_collection_count (int generation)
  63 {
  64         return 0;
  65 }
  66
  67 void
  68 mono_gc_add_memory_pressure (gint64 value)
  69 {
  70 }
  71
  72 /* maybe track the size, not important, though */
  73 int64_t
  74 mono_gc_get_used_size (void)
  75 {
  76         return 1024*1024;
  77 }
  78
  79 int64_t
  80 mono_gc_get_heap_size (void)
  81 {
  82         return 2*1024*1024;
  83 }
  84
  85 gboolean
  86 mono_gc_is_gc_thread (void)
  87 {
  88         return TRUE;
  89 }
  90
  91 gboolean
  92 mono_gc_register_thread (void *baseptr)
  93 {
  94         return TRUE;
  95 }
  96
  97 int
  98 mono_gc_walk_heap (int flags, MonoGCReferences callback, void *data)
  99 {
 100         return 1;
 101 }
 102
 103 gboolean
 104 mono_object_is_alive (MonoObject* o)
 105 {
 106         return TRUE;
 107 }
 108
 109 void
 110 mono_gc_enable_events (void)
 111 {
 112 }
 113
 114 void
 115 mono_gc_enable_alloc_events (void)
 116 {
 117 }
 118
 119 int
 120 mono_gc_register_root (char *start, size_t size, void *descr, MonoGCRootSource source, const char *msg)
 121 {
 122         return TRUE;
 123 }
 124
 125 void
 126 mono_gc_deregister_root (char* addr)
 127 {
 128 }
 129
 130 void
 131 mono_gc_weak_link_add (void **link_addr, MonoObject *obj, gboolean track)
 132 {
 133         *link_addr = obj;
 134 }
 135
 136 void
 137 mono_gc_weak_link_remove (void **link_addr, gboolean track)
 138 {
 139         *link_addr = NULL;
 140 }
 141
 142 MonoObject*
 143 mono_gc_weak_link_get (void **link_addr)
 144 {
 145         return *link_addr;
 146 }
 147
 148 void*
 149 mono_gc_make_descr_for_string (gsize *bitmap, int numbits)
 150 {
 151         return NULL;
 152 }
 153
 154 void*
 155 mono_gc_make_descr_for_object (gsize *bitmap, int numbits, size_t obj_size)
 156 {
 157         return NULL;
 158 }
 159
 160 void*
 161 mono_gc_make_descr_for_array (int vector, gsize *elem_bitmap, int numbits, size_t elem_size)
 162 {
 163         return NULL;
 164 }
 165
 166 void*
 167 mono_gc_make_descr_from_bitmap (gsize *bitmap, int numbits)
 168 {
 169         return NULL;
 170 }
 171
 172 void*
 173 mono_gc_make_root_descr_all_refs (int numbits)
 174 {
 175         return NULL;
 176 }
 177
 178 void*
 179 mono_gc_alloc_fixed (size_t size, void *descr, MonoGCRootSource source, const char *msg)
 180 {
 181         return g_malloc0 (size);
 182 }
 183
 184 void
 185 mono_gc_free_fixed (void* addr)
 186 {
 187         g_free (addr);
 188 }
 189
 190 void *
 191 mono_gc_alloc_obj (MonoVTable *vtable, size_t size)
 192 {
 193         MonoObject *obj = calloc (1, size);
 194
 195         obj->vtable = vtable;
 196
 197         return obj;
 198 }
 199
 200 void *
 201 mono_gc_alloc_vector (MonoVTable *vtable, size_t size, uintptr_t max_length)
 202 {
 203         MonoArray *obj = calloc (1, size);
 204
 205         obj->obj.vtable = vtable;
 206         obj->max_length = max_length;
 207
 208         return obj;
 209 }
 210
 211 void *
 212 mono_gc_alloc_array (MonoVTable *vtable, size_t size, uintptr_t max_length, uintptr_t bounds_size)
 213 {
 214         MonoArray *obj = calloc (1, size);
 215
 216         obj->obj.vtable = vtable;
 217         obj->max_length = max_length;
 218
 219         if (bounds_size)
 220                 obj->bounds = (MonoArrayBounds *) ((char *) obj + size - bounds_size);
 221
 222         return obj;
 223 }
 224
 225 void *
 226 mono_gc_alloc_string (MonoVTable *vtable, size_t size, gint32 len)
 227 {
 228         MonoString *obj = calloc (1, size);
 229
 230         obj->object.vtable = vtable;
 231         obj->length = len;
 232         obj->chars [len] = 0;
 233
 234         return obj;
 235 }
 236
 237 void*
 238 mono_gc_alloc_mature (MonoVTable *vtable, size_t size)
 239 {
 240         return mono_gc_alloc_obj (vtable, size);
 241 }
 242
 243 void
 244 mono_gc_wbarrier_set_field (MonoObject *obj, gpointer field_ptr, MonoObject* value)
 245 {
 246         *(void**)field_ptr = value;
 247 }
 248
 249 void
 250 mono_gc_wbarrier_set_arrayref (MonoArray *arr, gpointer slot_ptr, MonoObject* value)
 251 {
 252         *(void**)slot_ptr = value;
 253 }
 254
 255 void
 256 mono_gc_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int count)
 257 {
 258         mono_gc_memmove_aligned (dest_ptr, src_ptr, count * sizeof (gpointer));
 259 }
 260
 261 void
 262 mono_gc_wbarrier_generic_store (gpointer ptr, MonoObject* value)
 263 {
 264         *(void**)ptr = value;
 265 }
 266
 267 void
 268 mono_gc_wbarrier_generic_store_atomic (gpointer ptr, MonoObject *value)
 269 {
 270         InterlockedWritePointer (ptr, value);
 271 }
 272
 273 void
 274 mono_gc_wbarrier_generic_nostore (gpointer ptr)
 275 {
 276 }
 277
 278 void
 279 mono_gc_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoClass *klass)
 280 {
 281         mono_gc_memmove_atomic (dest, src, count * mono_class_value_size (klass, NULL));
 282 }
 283
 284 void
 285 mono_gc_wbarrier_object_copy (MonoObject* obj, MonoObject *src)
 286 {
 287         /* do not copy the sync state */
 288         mono_gc_memmove_aligned ((char*)obj + sizeof (MonoObject), (char*)src + sizeof (MonoObject),
 289                         mono_object_class (obj)->instance_size - sizeof (MonoObject));
 290 }
 291
 292 gboolean
 293 mono_gc_is_critical_method (MonoMethod *method)
 294 {
 295         return FALSE;
 296 }
 297
 298 int
 299 mono_gc_get_aligned_size_for_allocator (int size)
 300 {
 301         return size;
 302 }
 303
 304 MonoMethod*
 305 mono_gc_get_managed_allocator (MonoClass *klass, gboolean for_box, gboolean known_instance_size)
 306 {
 307         return NULL;
 308 }
 309
 310 MonoMethod*
 311 mono_gc_get_managed_array_allocator (MonoClass *klass)
 312 {
 313         return NULL;
 314 }
 315
 316 MonoMethod*
 317 mono_gc_get_managed_allocator_by_type (int atype, gboolean slowpath)
 318 {
 319         return NULL;
 320 }
 321
 322 guint32
 323 mono_gc_get_managed_allocator_types (void)
 324 {
 325         return 0;
 326 }
 327
 328 const char *
 329 mono_gc_get_gc_name (void)
 330 {
 331         return "null";
 332 }
 333
 334 void
 335 mono_gc_add_weak_track_handle (MonoObject *obj, guint32 gchandle)
 336 {
 337 }
 338
 339 void
 340 mono_gc_change_weak_track_handle (MonoObject *old_obj, MonoObject *obj, guint32 gchandle)
 341 {
 342 }
 343
 344 void
 345 mono_gc_remove_weak_track_handle (guint32 gchandle)
 346 {
 347 }
 348
 349 GSList*
 350 mono_gc_remove_weak_track_object (MonoDomain *domain, MonoObject *obj)
 351 {
 352         return NULL;
 353 }
 354
 355 void
 356 mono_gc_clear_domain (MonoDomain *domain)
 357 {
 358 }
 359
 360 int
 361 mono_gc_get_suspend_signal (void)
 362 {
 363         return -1;
 364 }
 365
 366 int
 367 mono_gc_get_restart_signal (void)
 368 {
 369         return -1;
 370 }
 371
 372 MonoMethod*
 373 mono_gc_get_specific_write_barrier (gboolean is_concurrent)
 374 {
 375         g_assert_not_reached ();
 376         return NULL;
 377 }
 378
 379 MonoMethod*
 380 mono_gc_get_write_barrier (void)
 381 {
 382         g_assert_not_reached ();
 383         return NULL;
 384 }
 385
 386 void*
 387 mono_gc_invoke_with_gc_lock (MonoGCLockedCallbackFunc func, void *data)
 388 {
 389         return func (data);
 390 }
 391
 392 char*
 393 mono_gc_get_description (void)
 394 {
 395         return g_strdup (DEFAULT_GC_NAME);
 396 }
 397
 398 void
 399 mono_gc_set_desktop_mode (void)
 400 {
 401 }
 402
 403 gboolean
 404 mono_gc_is_moving (void)
 405 {
 406         return FALSE;
 407 }
 408
 409 gboolean
 410 mono_gc_is_disabled (void)
 411 {
 412         return FALSE;
 413 }
 414
 415 void
 416 mono_gc_wbarrier_value_copy_bitmap (gpointer _dest, gpointer _src, int size, unsigned bitmap)
 417 {
 418         g_assert_not_reached ();
 419 }
 420
 421 guint8*
 422 mono_gc_get_card_table (int *shift_bits, gpointer *card_mask)
 423 {
 424         g_assert_not_reached ();
 425         return NULL;
 426 }
 427
 428 gboolean
 429 mono_gc_card_table_nursery_check (void)
 430 {
 431         g_assert_not_reached ();
 432         return TRUE;
 433 }
 434
 435 void*
 436 mono_gc_get_nursery (int *shift_bits, size_t *size)
 437 {
 438         return NULL;
 439 }
 440
 441 void
 442 mono_gc_set_current_thread_appdomain (MonoDomain *domain)
 443 {
 444 }
 445
 446 gboolean
 447 mono_gc_precise_stack_mark_enabled (void)
 448 {
 449         return FALSE;
 450 }
 451
 452 FILE *
 453 mono_gc_get_logfile (void)
 454 {
 455         return NULL;
 456 }
 457
 458 void
 459 mono_gc_conservatively_scan_area (void *start, void *end)
 460 {
 461         g_assert_not_reached ();
 462 }
 463
 464 void *
 465 mono_gc_scan_object (void *obj, void *gc_data)
 466 {
 467         g_assert_not_reached ();
 468         return NULL;
 469 }
 470
 471 gsize*
 472 mono_gc_get_bitmap_for_descr (void *descr, int *numbits)
 473 {
 474         g_assert_not_reached ();
 475         return NULL;
 476 }
 477
 478 void
 479 mono_gc_set_gc_callbacks (MonoGCCallbacks *callbacks)
 480 {
 481 }
 482
 483 void
 484 mono_gc_set_stack_end (void *stack_end)
 485 {
 486 }
 487
 488 int
 489 mono_gc_get_los_limit (void)
 490 {
 491         return G_MAXINT;
 492 }
 493
 494 gboolean
 495 mono_gc_user_markers_supported (void)
 496 {
 497         return FALSE;
 498 }
 499
 500 void *
 501 mono_gc_make_root_descr_user (MonoGCRootMarkFunc marker)
 502 {
 503         g_assert_not_reached ();
 504         return NULL;
 505 }
 506
 507 #ifndef HOST_WIN32
 508 int
 509 mono_gc_pthread_create (pthread_t *new_thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
 510 {
 511         return pthread_create (new_thread, attr, start_routine, arg);
 512 }
 513 #endif
 514
 515 void mono_gc_set_skip_thread (gboolean value)
 516 {
 517 }
 518
 519 #ifdef HOST_WIN32
 520 BOOL APIENTRY mono_gc_dllmain (HMODULE module_handle, DWORD reason, LPVOID reserved)
 521 {
 522         return TRUE;
 523 }
 524 #endif
 525
 526 guint
 527 mono_gc_get_vtable_bits (MonoClass *klass)
 528 {
 529         return 0;
 530 }
 531
 532 void
 533 mono_gc_register_altstack (gpointer stack, gint32 stack_size, gpointer altstack, gint32 altstack_size)
 534 {
 535 }
 536
 537 gboolean
 538 mono_gc_is_null (void)
 539 {
 540         return TRUE;
 541 }
 542
 543 #endif