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