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