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