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