mono/metadata/null-gc.c

   1 /**
   2  * \file
   3  * GC implementation using malloc: will leak everything, just for testing.
   4  *
   5  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
   6  * Copyright 2004-2011 Novell, Inc (http://www.novell.com)
   7  * Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
   8  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
   9  */
  10
  11 #include "config.h"
  12 #include <glib.h>
  13 #include <mono/metadata/mono-gc.h>
  14 #include <mono/metadata/gc-internals.h>
  15 #include <mono/metadata/runtime.h>
  16 #include <mono/metadata/w32handle.h>
  17 #include <mono/metadata/abi-details.h>
  18 #include <mono/utils/atomic.h>
  19 #include <mono/utils/mono-threads.h>
  20 #include <mono/utils/mono-counters.h>
  21 #include <mono/metadata/null-gc-handles.h>
  22
  23 #ifdef HAVE_NULL_GC
  24
  25 static gboolean gc_inited = FALSE;
  26
  27 void
  28 mono_gc_base_init (void)
  29 {
  30         if (gc_inited)
  31                 return;
  32
  33         mono_counters_init ();
  34
  35 #ifndef HOST_WIN32
  36         mono_w32handle_init ();
  37 #endif
  38
  39         mono_thread_callbacks_init ();
  40         mono_thread_info_init (sizeof (MonoThreadInfo));
  41
  42         mono_thread_info_attach ();
  43
  44         null_gc_handles_init ();
  45
  46         gc_inited = TRUE;
  47 }
  48
  49 void
  50 mono_gc_base_cleanup (void)
  51 {
  52 }
  53
  54 void
  55 mono_gc_collect (int generation)
  56 {
  57 }
  58
  59 int
  60 mono_gc_max_generation (void)
  61 {
  62         return 0;
  63 }
  64
  65 int
  66 mono_gc_get_generation  (MonoObject *object)
  67 {
  68         return 0;
  69 }
  70
  71 int
  72 mono_gc_collection_count (int generation)
  73 {
  74         return 0;
  75 }
  76
  77 void
  78 mono_gc_add_memory_pressure (gint64 value)
  79 {
  80 }
  81
  82 /* maybe track the size, not important, though */
  83 int64_t
  84 mono_gc_get_used_size (void)
  85 {
  86         return 1024*1024;
  87 }
  88
  89 int64_t
  90 mono_gc_get_heap_size (void)
  91 {
  92         return 2*1024*1024;
  93 }
  94
  95 gboolean
  96 mono_gc_is_gc_thread (void)
  97 {
  98         return TRUE;
  99 }
 100
 101 int
 102 mono_gc_walk_heap (int flags, MonoGCReferences callback, void *data)
 103 {
 104         return 1;
 105 }
 106
 107 gboolean
 108 mono_object_is_alive (MonoObject* o)
 109 {
 110         return TRUE;
 111 }
 112
 113 int
 114 mono_gc_register_root (char *start, size_t size, void *descr, MonoGCRootSource source, void *key, const char *msg)
 115 {
 116         return TRUE;
 117 }
 118
 119 int
 120 mono_gc_register_root_wbarrier (char *start, size_t size, MonoGCDescriptor descr, MonoGCRootSource source, void *key, const char *msg)
 121 {
 122         return TRUE;
 123 }
 124
 125
 126 void
 127 mono_gc_deregister_root (char* addr)
 128 {
 129 }
 130
 131 void*
 132 mono_gc_make_descr_for_string (gsize *bitmap, int numbits)
 133 {
 134         return NULL;
 135 }
 136
 137 void*
 138 mono_gc_make_descr_for_object (gsize *bitmap, int numbits, size_t obj_size)
 139 {
 140         return NULL;
 141 }
 142
 143 void*
 144 mono_gc_make_descr_for_array (int vector, gsize *elem_bitmap, int numbits, size_t elem_size)
 145 {
 146         return NULL;
 147 }
 148
 149 void*
 150 mono_gc_make_descr_from_bitmap (gsize *bitmap, int numbits)
 151 {
 152         return NULL;
 153 }
 154
 155 void*
 156 mono_gc_make_vector_descr (void)
 157 {
 158         return NULL;
 159 }
 160
 161 void*
 162 mono_gc_make_root_descr_all_refs (int numbits)
 163 {
 164         return NULL;
 165 }
 166
 167 MonoObject*
 168 mono_gc_alloc_fixed (size_t size, void *descr, MonoGCRootSource source, void *key, const char *msg)
 169 {
 170         return (MonoObject*)g_malloc0 (size);
 171 }
 172
 173 MonoObject*
 174 mono_gc_alloc_fixed_no_descriptor (size_t size, MonoGCRootSource source, void *key, const char *msg)
 175 {
 176         return mono_gc_alloc_fixed (size, NULL, source, key, msg);
 177 }
 178
 179 void
 180 mono_gc_free_fixed (void* addr)
 181 {
 182         g_free (addr);
 183 }
 184
 185 MonoObject*
 186 mono_gc_alloc_obj (MonoVTable *vtable, size_t size)
 187 {
 188         MonoObject *obj = g_calloc (1, size);
 189
 190         obj->vtable = vtable;
 191
 192         return obj;
 193 }
 194
 195 MonoArray*
 196 mono_gc_alloc_vector (MonoVTable *vtable, size_t size, uintptr_t max_length)
 197 {
 198         MonoArray *obj = g_calloc (1, size);
 199
 200         obj->obj.vtable = vtable;
 201         obj->max_length = max_length;
 202
 203         return obj;
 204 }
 205
 206 MonoArray*
 207 mono_gc_alloc_array (MonoVTable *vtable, size_t size, uintptr_t max_length, uintptr_t bounds_size)
 208 {
 209         MonoArray *obj = g_calloc (1, size);
 210
 211         obj->obj.vtable = vtable;
 212         obj->max_length = max_length;
 213
 214         if (bounds_size)
 215                 obj->bounds = (MonoArrayBounds *) ((char *) obj + size - bounds_size);
 216
 217         return obj;
 218 }
 219
 220 MonoString*
 221 mono_gc_alloc_string (MonoVTable *vtable, size_t size, gint32 len)
 222 {
 223         MonoString *obj = g_calloc (1, size);
 224
 225         obj->object.vtable = vtable;
 226         obj->length = len;
 227         obj->chars [len] = 0;
 228
 229         return obj;
 230 }
 231
 232 MonoObject*
 233 mono_gc_alloc_mature (MonoVTable *vtable, size_t size)
 234 {
 235         return mono_gc_alloc_obj (vtable, size);
 236 }
 237
 238 MonoObject*
 239 mono_gc_alloc_pinned_obj (MonoVTable *vtable, size_t size)
 240 {
 241         return mono_gc_alloc_obj (vtable, size);
 242 }
 243
 244 void
 245 mono_gc_wbarrier_set_field_internal (MonoObject *obj, gpointer field_ptr, MonoObject* value)
 246 {
 247         *(void**)field_ptr = value;
 248 }
 249
 250 void
 251 mono_gc_wbarrier_set_arrayref_internal (MonoArray *arr, gpointer slot_ptr, MonoObject* value)
 252 {
 253         *(void**)slot_ptr = value;
 254 }
 255
 256 void
 257 mono_gc_wbarrier_arrayref_copy_internal (gpointer dest_ptr, gpointer src_ptr, int count)
 258 {
 259         mono_gc_memmove_aligned (dest_ptr, src_ptr, count * sizeof (gpointer));
 260 }
 261
 262 void
 263 mono_gc_wbarrier_generic_store_internal (gpointer ptr, MonoObject* value)
 264 {
 265         *(void**)ptr = value;
 266 }
 267
 268 void
 269 mono_gc_wbarrier_generic_store_atomic_internal (gpointer ptr, MonoObject *value)
 270 {
 271         mono_atomic_store_ptr (ptr, value);
 272 }
 273
 274 void
 275 mono_gc_wbarrier_generic_nostore_internal (gpointer ptr)
 276 {
 277 }
 278
 279 void
 280 mono_gc_wbarrier_value_copy_internal (gpointer dest, gpointer src, int count, MonoClass *klass)
 281 {
 282         mono_gc_memmove_atomic (dest, src, count * mono_class_value_size (klass, NULL));
 283 }
 284
 285 void
 286 mono_gc_wbarrier_object_copy_internal (MonoObject* obj, MonoObject *src)
 287 {
 288         /* do not copy the sync state */
 289         mono_gc_memmove_aligned (mono_object_get_data (obj), (char*)src + MONO_ABI_SIZEOF (MonoObject),
 290                         mono_object_class (obj)->instance_size - MONO_ABI_SIZEOF (MonoObject));
 291 }
 292
 293 gboolean
 294 mono_gc_is_critical_method (MonoMethod *method)
 295 {
 296         return FALSE;
 297 }
 298
 299 gpointer
 300 mono_gc_thread_attach (MonoThreadInfo* info)
 301 {
 302         info->handle_stack = mono_handle_stack_alloc ();
 303         return info;
 304 }
 305
 306 void
 307 mono_gc_thread_detach_with_lock (MonoThreadInfo *p)
 308 {
 309         mono_handle_stack_free (p->handle_stack);
 310 }
 311
 312 gboolean
 313 mono_gc_thread_in_critical_region (MonoThreadInfo *info)
 314 {
 315         return FALSE;
 316 }
 317
 318 int
 319 mono_gc_get_aligned_size_for_allocator (int size)
 320 {
 321         return size;
 322 }
 323
 324 MonoMethod*
 325 mono_gc_get_managed_allocator (MonoClass *klass, gboolean for_box, gboolean known_instance_size)
 326 {
 327         return NULL;
 328 }
 329
 330 MonoMethod*
 331 mono_gc_get_managed_array_allocator (MonoClass *klass)
 332 {
 333         return NULL;
 334 }
 335
 336 MonoMethod*
 337 mono_gc_get_managed_allocator_by_type (int atype, ManagedAllocatorVariant variant)
 338 {
 339         return NULL;
 340 }
 341
 342 guint32
 343 mono_gc_get_managed_allocator_types (void)
 344 {
 345         return 0;
 346 }
 347
 348 const char *
 349 mono_gc_get_gc_name (void)
 350 {
 351         return "null";
 352 }
 353
 354 void
 355 mono_gc_clear_domain (MonoDomain *domain)
 356 {
 357 }
 358
 359 void
 360 mono_gc_suspend_finalizers (void)
 361 {
 362 }
 363
 364 int
 365 mono_gc_get_suspend_signal (void)
 366 {
 367         return -1;
 368 }
 369
 370 int
 371 mono_gc_get_restart_signal (void)
 372 {
 373         return -1;
 374 }
 375
 376 MonoMethod*
 377 mono_gc_get_specific_write_barrier (gboolean is_concurrent)
 378 {
 379         g_assert_not_reached ();
 380         return NULL;
 381 }
 382
 383 MonoMethod*
 384 mono_gc_get_write_barrier (void)
 385 {
 386         g_assert_not_reached ();
 387         return NULL;
 388 }
 389
 390 void*
 391 mono_gc_invoke_with_gc_lock (MonoGCLockedCallbackFunc func, void *data)
 392 {
 393         return func (data);
 394 }
 395
 396 char*
 397 mono_gc_get_description (void)
 398 {
 399         return g_strdup (DEFAULT_GC_NAME);
 400 }
 401
 402 void
 403 mono_gc_set_desktop_mode (void)
 404 {
 405 }
 406
 407 gboolean
 408 mono_gc_is_moving (void)
 409 {
 410         return FALSE;
 411 }
 412
 413 gboolean
 414 mono_gc_is_disabled (void)
 415 {
 416         return FALSE;
 417 }
 418
 419 void
 420 mono_gc_wbarrier_range_copy (gpointer _dest, gconstpointer _src, int size)
 421 {
 422         g_assert_not_reached ();
 423 }
 424
 425 MonoRangeCopyFunction
 426 mono_gc_get_range_copy_func (void)
 427 {
 428         return &mono_gc_wbarrier_range_copy;
 429 }
 430
 431 guint8*
 432 mono_gc_get_card_table (int *shift_bits, gpointer *card_mask)
 433 {
 434         g_assert_not_reached ();
 435         return NULL;
 436 }
 437
 438 guint8*
 439 mono_gc_get_target_card_table (int *shift_bits, target_mgreg_t *card_mask)
 440 {
 441         *shift_bits = 0;
 442         *card_mask = 0;
 443         return NULL;
 444 }
 445
 446 gboolean
 447 mono_gc_card_table_nursery_check (void)
 448 {
 449         g_assert_not_reached ();
 450         return TRUE;
 451 }
 452
 453 void*
 454 mono_gc_get_nursery (int *shift_bits, size_t *size)
 455 {
 456         return NULL;
 457 }
 458
 459 gboolean
 460 mono_gc_precise_stack_mark_enabled (void)
 461 {
 462         return FALSE;
 463 }
 464
 465 FILE *
 466 mono_gc_get_logfile (void)
 467 {
 468         return NULL;
 469 }
 470
 471 void
 472 mono_gc_params_set (const char* options)
 473 {
 474 }
 475
 476 void
 477 mono_gc_debug_set (const char* options)
 478 {
 479 }
 480
 481 void
 482 mono_gc_conservatively_scan_area (void *start, void *end)
 483 {
 484         g_assert_not_reached ();
 485 }
 486
 487 void *
 488 mono_gc_scan_object (void *obj, void *gc_data)
 489 {
 490         g_assert_not_reached ();
 491         return NULL;
 492 }
 493
 494 gsize*
 495 mono_gc_get_bitmap_for_descr (void *descr, int *numbits)
 496 {
 497         g_assert_not_reached ();
 498         return NULL;
 499 }
 500
 501 void
 502 mono_gc_set_gc_callbacks (MonoGCCallbacks *callbacks)
 503 {
 504 }
 505
 506 void
 507 mono_gc_set_stack_end (void *stack_end)
 508 {
 509 }
 510
 511 int
 512 mono_gc_get_los_limit (void)
 513 {
 514         return G_MAXINT;
 515 }
 516
 517 gboolean
 518 mono_gc_user_markers_supported (void)
 519 {
 520         return FALSE;
 521 }
 522
 523 void *
 524 mono_gc_make_root_descr_user (MonoGCRootMarkFunc marker)
 525 {
 526         g_assert_not_reached ();
 527         return NULL;
 528 }
 529
 530 #ifndef HOST_WIN32
 531 int
 532 mono_gc_pthread_create (pthread_t *new_thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
 533 {
 534         return pthread_create (new_thread, attr, start_routine, arg);
 535 }
 536 #endif
 537
 538 void
 539 mono_gc_skip_thread_changing (gboolean skip)
 540 {
 541         // No STW, nothing needs to be done.
 542 }
 543
 544 void
 545 mono_gc_skip_thread_changed (gboolean skip)
 546 {
 547 }
 548
 549 #ifdef HOST_WIN32
 550 BOOL APIENTRY mono_gc_dllmain (HMODULE module_handle, DWORD reason, LPVOID reserved)
 551 {
 552         return TRUE;
 553 }
 554 #endif
 555
 556 MonoVTable *
 557 mono_gc_get_vtable (MonoObject *obj)
 558 {
 559         // No pointer tagging.
 560         return obj->vtable;
 561 }
 562
 563 guint
 564 mono_gc_get_vtable_bits (MonoClass *klass)
 565 {
 566         return 0;
 567 }
 568
 569 void
 570 mono_gc_register_altstack (gpointer stack, gint32 stack_size, gpointer altstack, gint32 altstack_size)
 571 {
 572 }
 573
 574 gboolean
 575 mono_gc_is_null (void)
 576 {
 577         return TRUE;
 578 }
 579
 580 int
 581 mono_gc_invoke_finalizers (void)
 582 {
 583         return 0;
 584 }
 585
 586 MonoBoolean
 587 mono_gc_pending_finalizers (void)
 588 {
 589         return FALSE;
 590 }
 591
 592 gboolean
 593 mono_gc_ephemeron_array_add (MonoObject *obj)
 594 {
 595         return TRUE;
 596 }
 597
 598 #else
 599
 600 MONO_EMPTY_SOURCE_FILE (null_gc);
 601 #endif /* HAVE_NULL_GC */