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