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