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