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 MonoMethod*
 238 mono_gc_get_managed_allocator (MonoClass *klass, gboolean for_box)
 239 {
 240         return NULL;
 241 }
 242
 243 MonoMethod*
 244 mono_gc_get_managed_array_allocator (MonoClass *klass)
 245 {
 246         return NULL;
 247 }
 248
 249 MonoMethod*
 250 mono_gc_get_managed_allocator_by_type (int atype)
 251 {
 252         return NULL;
 253 }
 254
 255 guint32
 256 mono_gc_get_managed_allocator_types (void)
 257 {
 258         return 0;
 259 }
 260
 261 const char *
 262 mono_gc_get_gc_name (void)
 263 {
 264         return "null";
 265 }
 266
 267 void
 268 mono_gc_add_weak_track_handle (MonoObject *obj, guint32 gchandle)
 269 {
 270 }
 271
 272 void
 273 mono_gc_change_weak_track_handle (MonoObject *old_obj, MonoObject *obj, guint32 gchandle)
 274 {
 275 }
 276
 277 void
 278 mono_gc_remove_weak_track_handle (guint32 gchandle)
 279 {
 280 }
 281
 282 GSList*
 283 mono_gc_remove_weak_track_object (MonoDomain *domain, MonoObject *obj)
 284 {
 285         return NULL;
 286 }
 287
 288 void
 289 mono_gc_clear_domain (MonoDomain *domain)
 290 {
 291 }
 292
 293 int
 294 mono_gc_get_suspend_signal (void)
 295 {
 296         return -1;
 297 }
 298
 299 int
 300 mono_gc_get_restart_signal (void)
 301 {
 302         return -1;
 303 }
 304
 305 MonoMethod*
 306 mono_gc_get_write_barrier (void)
 307 {
 308         g_assert_not_reached ();
 309         return NULL;
 310 }
 311
 312 void*
 313 mono_gc_invoke_with_gc_lock (MonoGCLockedCallbackFunc func, void *data)
 314 {
 315         return func (data);
 316 }
 317
 318 char*
 319 mono_gc_get_description (void)
 320 {
 321         return g_strdup (DEFAULT_GC_NAME);
 322 }
 323
 324 void
 325 mono_gc_set_desktop_mode (void)
 326 {
 327 }
 328
 329 gboolean
 330 mono_gc_is_moving (void)
 331 {
 332         return FALSE;
 333 }
 334
 335 gboolean
 336 mono_gc_is_disabled (void)
 337 {
 338         return FALSE;
 339 }
 340
 341 void
 342 mono_gc_wbarrier_value_copy_bitmap (gpointer _dest, gpointer _src, int size, unsigned bitmap)
 343 {
 344         g_assert_not_reached ();
 345 }
 346
 347 guint8*
 348 mono_gc_get_card_table (int *shift_bits, gpointer *card_mask)
 349 {
 350         g_assert_not_reached ();
 351         return NULL;
 352 }
 353
 354 gboolean
 355 mono_gc_card_table_nursery_check (void)
 356 {
 357         g_assert_not_reached ();
 358         return TRUE;
 359 }
 360
 361 void*
 362 mono_gc_get_nursery (int *shift_bits, size_t *size)
 363 {
 364         return NULL;
 365 }
 366
 367 void
 368 mono_gc_set_current_thread_appdomain (MonoDomain *domain)
 369 {
 370 }
 371
 372 gboolean
 373 mono_gc_precise_stack_mark_enabled (void)
 374 {
 375         return FALSE;
 376 }
 377
 378 FILE *
 379 mono_gc_get_logfile (void)
 380 {
 381         return NULL;
 382 }
 383
 384 void
 385 mono_gc_conservatively_scan_area (void *start, void *end)
 386 {
 387         g_assert_not_reached ();
 388 }
 389
 390 void *
 391 mono_gc_scan_object (void *obj, void *gc_data)
 392 {
 393         g_assert_not_reached ();
 394         return NULL;
 395 }
 396
 397 gsize*
 398 mono_gc_get_bitmap_for_descr (void *descr, int *numbits)
 399 {
 400         g_assert_not_reached ();
 401         return NULL;
 402 }
 403
 404 void
 405 mono_gc_set_gc_callbacks (MonoGCCallbacks *callbacks)
 406 {
 407 }
 408
 409 void
 410 mono_gc_set_stack_end (void *stack_end)
 411 {
 412 }
 413
 414 int
 415 mono_gc_get_los_limit (void)
 416 {
 417         return G_MAXINT;
 418 }
 419
 420 gboolean
 421 mono_gc_user_markers_supported (void)
 422 {
 423         return FALSE;
 424 }
 425
 426 void *
 427 mono_gc_make_root_descr_user (MonoGCRootMarkFunc marker)
 428 {
 429         g_assert_not_reached ();
 430         return NULL;
 431 }
 432
 433 #ifndef HOST_WIN32
 434
 435 int
 436 mono_gc_pthread_create (pthread_t *new_thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
 437 {
 438         return pthread_create (new_thread, attr, start_routine, arg);
 439 }
 440
 441 int
 442 mono_gc_pthread_join (pthread_t thread, void **retval)
 443 {
 444         return pthread_join (thread, retval);
 445 }
 446
 447 int
 448 mono_gc_pthread_detach (pthread_t thread)
 449 {
 450         return pthread_detach (thread);
 451 }
 452
 453 void
 454 mono_gc_pthread_exit (void *retval)
 455 {
 456         pthread_exit (retval);
 457 }
 458
 459 void mono_gc_set_skip_thread (gboolean value)
 460 {
 461 }
 462 #endif
 463
 464 #ifdef HOST_WIN32
 465 BOOL APIENTRY mono_gc_dllmain (HMODULE module_handle, DWORD reason, LPVOID reserved)
 466 {
 467         return TRUE;
 468 }
 469 #endif
 470
 471 guint
 472 mono_gc_get_vtable_bits (MonoClass *class)
 473 {
 474         return 0;
 475 }
 476
 477 void
 478 mono_gc_register_altstack (gpointer stack, gint32 stack_size, gpointer altstack, gint32 altstack_size)
 479 {
 480 }
 481
 482 gboolean
 483 mono_gc_set_allow_synchronous_major (gboolean flag)
 484 {
 485         return TRUE;
 486 }
 487
 488 #endif