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