mono/metadata/boehm-gc.c

   1 /**
   2  * \file
   3  * GC implementation using either the installed or included Boehm GC.
   4  *
   5  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
   6  * Copyright 2004-2011 Novell, Inc (http://www.novell.com)
   7  * Copyright 2011-2012 Xamarin, Inc (http://www.xamarin.com)
   8  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
   9  */
  10
  11 #include "config.h"
  12
  13 #include <string.h>
  14
  15 #define GC_I_HIDE_POINTERS
  16 #include <mono/metadata/gc-internals.h>
  17 #include <mono/metadata/mono-gc.h>
  18 #include <mono/metadata/profiler-private.h>
  19 #include <mono/metadata/class-internals.h>
  20 #include <mono/metadata/method-builder.h>
  21 #include <mono/metadata/opcodes.h>
  22 #include <mono/metadata/domain-internals.h>
  23 #include <mono/metadata/metadata-internals.h>
  24 #include <mono/metadata/marshal.h>
  25 #include <mono/metadata/runtime.h>
  26 #include <mono/metadata/handle.h>
  27 #include <mono/metadata/sgen-toggleref.h>
  28 #include <mono/metadata/w32handle.h>
  29 #include <mono/utils/atomic.h>
  30 #include <mono/utils/mono-logger-internals.h>
  31 #include <mono/utils/mono-memory-model.h>
  32 #include <mono/utils/mono-time.h>
  33 #include <mono/utils/mono-threads.h>
  34 #include <mono/utils/dtrace.h>
  35 #include <mono/utils/gc_wrapper.h>
  36 #include <mono/utils/mono-os-mutex.h>
  37 #include <mono/utils/mono-counters.h>
  38 #include <mono/utils/mono-compiler.h>
  39
  40 #if HAVE_BOEHM_GC
  41
  42 #undef TRUE
  43 #undef FALSE
  44 #define THREAD_LOCAL_ALLOC 1
  45 #include "private/pthread_support.h"
  46
  47 #if defined(PLATFORM_MACOSX) && defined(HAVE_PTHREAD_GET_STACKADDR_NP)
  48 void *pthread_get_stackaddr_np(pthread_t);
  49 #endif
  50
  51 #define GC_NO_DESCRIPTOR ((gpointer)(0 | GC_DS_LENGTH))
  52 /*Boehm max heap cannot be smaller than 16MB*/
  53 #define MIN_BOEHM_MAX_HEAP_SIZE_IN_MB 16
  54 #define MIN_BOEHM_MAX_HEAP_SIZE (MIN_BOEHM_MAX_HEAP_SIZE_IN_MB << 20)
  55
  56 static gboolean gc_initialized = FALSE;
  57 static mono_mutex_t mono_gc_lock;
  58
  59 static void*
  60 boehm_thread_register (MonoThreadInfo* info, void *baseptr);
  61 static void
  62 boehm_thread_unregister (MonoThreadInfo *p);
  63 static void
  64 boehm_thread_detach (MonoThreadInfo *p);
  65 static void
  66 register_test_toggleref_callback (void);
  67
  68 #define BOEHM_GC_BIT_FINALIZER_AWARE 1
  69 static MonoGCFinalizerCallbacks fin_callbacks;
  70
  71 /* GC Handles */
  72
  73 static mono_mutex_t handle_section;
  74 #define lock_handles(handles) mono_os_mutex_lock (&handle_section)
  75 #define unlock_handles(handles) mono_os_mutex_unlock (&handle_section)
  76
  77 typedef struct {
  78         guint32  *bitmap;
  79         gpointer *entries;
  80         guint32   size;
  81         guint8    type;
  82         guint     slot_hint : 24; /* starting slot for search in bitmap */
  83         /* 2^16 appdomains should be enough for everyone (though I know I'll regret this in 20 years) */
  84         /* we alloc this only for weak refs, since we can get the domain directly in the other cases */
  85         guint16  *domain_ids;
  86 } HandleData;
  87
  88 #define EMPTY_HANDLE_DATA(type) {NULL, NULL, 0, (type), 0, NULL}
  89
  90 /* weak and weak-track arrays will be allocated in malloc memory
  91  */
  92 static HandleData gc_handles [] = {
  93         EMPTY_HANDLE_DATA (HANDLE_WEAK),
  94         EMPTY_HANDLE_DATA (HANDLE_WEAK_TRACK),
  95         EMPTY_HANDLE_DATA (HANDLE_NORMAL),
  96         EMPTY_HANDLE_DATA (HANDLE_PINNED)
  97 };
  98
  99 static void
 100 mono_gc_warning (char *msg, GC_word arg)
 101 {
 102         mono_trace (G_LOG_LEVEL_WARNING, MONO_TRACE_GC, msg, (unsigned long)arg);
 103 }
 104
 105 static void on_gc_notification (GC_EventType event);
 106 static void on_gc_heap_resize (size_t new_size);
 107
 108 void
 109 mono_gc_base_init (void)
 110 {
 111         MonoThreadInfoCallbacks cb;
 112         const char *env;
 113         int dummy;
 114
 115         if (gc_initialized)
 116                 return;
 117
 118         mono_counters_init ();
 119
 120 #ifndef HOST_WIN32
 121         mono_w32handle_init ();
 122 #endif
 123
 124         /*
 125          * Handle the case when we are called from a thread different from the main thread,
 126          * confusing libgc.
 127          * FIXME: Move this to libgc where it belongs.
 128          *
 129          * we used to do this only when running on valgrind,
 130          * but it happens also in other setups.
 131          */
 132 #if defined(HAVE_PTHREAD_GETATTR_NP) && defined(HAVE_PTHREAD_ATTR_GETSTACK) && !defined(__native_client__)
 133         {
 134                 size_t size;
 135                 void *sstart;
 136                 pthread_attr_t attr;
 137                 pthread_getattr_np (pthread_self (), &attr);
 138                 pthread_attr_getstack (&attr, &sstart, &size);
 139                 pthread_attr_destroy (&attr);
 140                 /*g_print ("stackbottom pth is: %p\n", (char*)sstart + size);*/
 141 #ifdef __ia64__
 142                 /*
 143                  * The calculation above doesn't seem to work on ia64, also we need to set
 144                  * GC_register_stackbottom as well, but don't know how.
 145                  */
 146 #else
 147                 /* apparently with some linuxthreads implementations sstart can be NULL,
 148                  * fallback to the more imprecise method (bug# 78096).
 149                  */
 150                 if (sstart) {
 151                         GC_stackbottom = (char*)sstart + size;
 152                 } else {
 153                         int dummy;
 154                         gsize stack_bottom = (gsize)&dummy;
 155                         stack_bottom += 4095;
 156                         stack_bottom &= ~4095;
 157                         GC_stackbottom = (char*)stack_bottom;
 158                 }
 159 #endif
 160         }
 161 #elif defined(HAVE_PTHREAD_GET_STACKSIZE_NP) && defined(HAVE_PTHREAD_GET_STACKADDR_NP)
 162                 GC_stackbottom = (char*)pthread_get_stackaddr_np (pthread_self ());
 163 #elif defined(__OpenBSD__)
 164 #  include <pthread_np.h>
 165         {
 166                 stack_t ss;
 167                 int rslt;
 168
 169                 rslt = pthread_stackseg_np(pthread_self(), &ss);
 170                 g_assert (rslt == 0);
 171
 172                 GC_stackbottom = (char*)ss.ss_sp;
 173         }
 174 #elif defined(__native_client__)
 175         /* Do nothing, GC_stackbottom is set correctly in libgc */
 176 #else
 177         {
 178                 int dummy;
 179                 gsize stack_bottom = (gsize)&dummy;
 180                 stack_bottom += 4095;
 181                 stack_bottom &= ~4095;
 182                 /*g_print ("stackbottom is: %p\n", (char*)stack_bottom);*/
 183                 GC_stackbottom = (char*)stack_bottom;
 184         }
 185 #endif
 186
 187 #if !defined(PLATFORM_ANDROID)
 188         /* If GC_no_dls is set to true, GC_find_limit is not called. This causes a seg fault on Android. */
 189         GC_no_dls = TRUE;
 190 #endif
 191         {
 192                 if ((env = g_getenv ("MONO_GC_DEBUG"))) {
 193                         char **opts = g_strsplit (env, ",", -1);
 194                         for (char **ptr = opts; ptr && *ptr; ptr ++) {
 195                                 char *opt = *ptr;
 196                                 if (!strcmp (opt, "do-not-finalize")) {
 197                                         mono_do_not_finalize = 1;
 198                                 } else if (!strcmp (opt, "log-finalizers")) {
 199                                         log_finalizers = 1;
 200                                 }
 201                         }
 202                 }
 203         }
 204
 205         GC_init ();
 206
 207         GC_set_warn_proc (mono_gc_warning);
 208         GC_finalize_on_demand = 1;
 209         GC_finalizer_notifier = mono_gc_finalize_notify;
 210
 211         GC_init_gcj_malloc (5, NULL);
 212         GC_allow_register_threads ();
 213
 214         if ((env = g_getenv ("MONO_GC_PARAMS"))) {
 215                 char **ptr, **opts = g_strsplit (env, ",", -1);
 216                 for (ptr = opts; *ptr; ++ptr) {
 217                         char *opt = *ptr;
 218                         if (g_str_has_prefix (opt, "max-heap-size=")) {
 219                                 size_t max_heap;
 220
 221                                 opt = strchr (opt, '=') + 1;
 222                                 if (*opt && mono_gc_parse_environment_string_extract_number (opt, &max_heap)) {
 223                                         if (max_heap < MIN_BOEHM_MAX_HEAP_SIZE) {
 224                                                 fprintf (stderr, "max-heap-size must be at least %dMb.\n", MIN_BOEHM_MAX_HEAP_SIZE_IN_MB);
 225                                                 exit (1);
 226                                         }
 227                                         GC_set_max_heap_size (max_heap);
 228                                 } else {
 229                                         fprintf (stderr, "max-heap-size must be an integer.\n");
 230                                         exit (1);
 231                                 }
 232                                 continue;
 233                         } else if (g_str_has_prefix (opt, "toggleref-test")) {
 234                                 register_test_toggleref_callback ();
 235                                 continue;
 236                         } else {
 237                                 /* Could be a parameter for sgen */
 238                                 /*
 239                                 fprintf (stderr, "MONO_GC_PARAMS must be a comma-delimited list of one or more of the following:\n");
 240                                 fprintf (stderr, "  max-heap-size=N (where N is an integer, possibly with a k, m or a g suffix)\n");
 241                                 exit (1);
 242                                 */
 243                         }
 244                 }
 245                 g_strfreev (opts);
 246         }
 247
 248         memset (&cb, 0, sizeof (cb));
 249         cb.thread_register = boehm_thread_register;
 250         cb.thread_unregister = boehm_thread_unregister;
 251         cb.thread_detach = boehm_thread_detach;
 252         cb.mono_method_is_critical = (gboolean (*)(void *))mono_runtime_is_critical_method;
 253
 254         mono_threads_init (&cb, sizeof (MonoThreadInfo));
 255         mono_os_mutex_init (&mono_gc_lock);
 256         mono_os_mutex_init_recursive (&handle_section);
 257
 258         mono_thread_info_attach (&dummy);
 259
 260         GC_set_on_collection_event (on_gc_notification);
 261         GC_on_heap_resize = on_gc_heap_resize;
 262
 263         gc_initialized = TRUE;
 264 }
 265
 266 void
 267 mono_gc_base_cleanup (void)
 268 {
 269         GC_finalizer_notifier = NULL;
 270 }
 271
 272 /**
 273  * mono_gc_collect:
 274  * \param generation GC generation identifier
 275  *
 276  * Perform a garbage collection for the given generation, higher numbers
 277  * mean usually older objects. Collecting a high-numbered generation
 278  * implies collecting also the lower-numbered generations.
 279  * The maximum value for \p generation can be retrieved with a call to
 280  * \c mono_gc_max_generation, so this function is usually called as:
 281  *
 282  * <code>mono_gc_collect (mono_gc_max_generation ());</code>
 283  */
 284 void
 285 mono_gc_collect (int generation)
 286 {
 287 #ifndef DISABLE_PERFCOUNTERS
 288         mono_perfcounters->gc_induced++;
 289 #endif
 290         GC_gcollect ();
 291 }
 292
 293 /**
 294  * mono_gc_max_generation:
 295  *
 296  * Get the maximum generation number used by the current garbage
 297  * collector. The value will be 0 for the Boehm collector, 1 or more
 298  * for the generational collectors.
 299  *
 300  * Returns: the maximum generation number.
 301  */
 302 int
 303 mono_gc_max_generation (void)
 304 {
 305         return 0;
 306 }
 307
 308 /**
 309  * mono_gc_get_generation:
 310  * \param object a managed object
 311  *
 312  * Get the garbage collector's generation that \p object belongs to.
 313  * Use this has a hint only.
 314  *
 315  * \returns a garbage collector generation number
 316  */
 317 int
 318 mono_gc_get_generation  (MonoObject *object)
 319 {
 320         return 0;
 321 }
 322
 323 /**
 324  * mono_gc_collection_count:
 325  * \param generation a GC generation number
 326  *
 327  * Get how many times a garbage collection has been performed
 328  * for the given \p generation number.
 329  *
 330  * \returns the number of garbage collections
 331  */
 332 int
 333 mono_gc_collection_count (int generation)
 334 {
 335         return GC_gc_no;
 336 }
 337
 338 /**
 339  * mono_gc_add_memory_pressure:
 340  * \param value amount of bytes
 341  *
 342  * Adjust the garbage collector's view of how many bytes of memory
 343  * are indirectly referenced by managed objects (for example unmanaged
 344  * memory holding image or other binary data).
 345  * This is a hint only to the garbage collector algorithm.
 346  * Note that negative amounts of p value will decrease the memory
 347  * pressure.
 348  */
 349 void
 350 mono_gc_add_memory_pressure (gint64 value)
 351 {
 352 }
 353
 354 /**
 355  * mono_gc_get_used_size:
 356  *
 357  * Get the approximate amount of memory used by managed objects.
 358  *
 359  * Returns: the amount of memory used in bytes
 360  */
 361 int64_t
 362 mono_gc_get_used_size (void)
 363 {
 364         return GC_get_heap_size () - GC_get_free_bytes ();
 365 }
 366
 367 /**
 368  * mono_gc_get_heap_size:
 369  *
 370  * Get the amount of memory used by the garbage collector.
 371  *
 372  * Returns: the size of the heap in bytes
 373  */
 374 int64_t
 375 mono_gc_get_heap_size (void)
 376 {
 377         return GC_get_heap_size ();
 378 }
 379
 380 gboolean
 381 mono_gc_is_gc_thread (void)
 382 {
 383         return GC_thread_is_registered ();
 384 }
 385
 386 gboolean
 387 mono_gc_register_thread (void *baseptr)
 388 {
 389         return mono_thread_info_attach (baseptr) != NULL;
 390 }
 391
 392 static void*
 393 boehm_thread_register (MonoThreadInfo* info, void *baseptr)
 394 {
 395         struct GC_stack_base sb;
 396         int res;
 397
 398         /* TODO: use GC_get_stack_base instead of baseptr. */
 399         sb.mem_base = baseptr;
 400         res = GC_register_my_thread (&sb);
 401         if (res == GC_UNIMPLEMENTED)
 402             return NULL; /* Cannot happen with GC v7+. */
 403
 404         info->handle_stack = mono_handle_stack_alloc ();
 405
 406         return info;
 407 }
 408
 409 static void
 410 boehm_thread_unregister (MonoThreadInfo *p)
 411 {
 412         MonoNativeThreadId tid;
 413
 414         tid = mono_thread_info_get_tid (p);
 415
 416         if (p->runtime_thread)
 417                 mono_threads_add_joinable_thread ((gpointer)tid);
 418 }
 419
 420 static void
 421 boehm_thread_detach (MonoThreadInfo *p)
 422 {
 423         if (mono_thread_internal_current_is_attached ())
 424                 mono_thread_detach_internal (mono_thread_internal_current ());
 425 }
 426
 427 gboolean
 428 mono_object_is_alive (MonoObject* o)
 429 {
 430         return GC_is_marked ((ptr_t)o);
 431 }
 432
 433 int
 434 mono_gc_walk_heap (int flags, MonoGCReferences callback, void *data)
 435 {
 436         return 1;
 437 }
 438
 439 static gint64 gc_start_time;
 440
 441 static void
 442 on_gc_notification (GC_EventType event)
 443 {
 444         MonoGCEvent e = (MonoGCEvent)event;
 445
 446         switch (e) {
 447         case MONO_GC_EVENT_PRE_STOP_WORLD:
 448                 MONO_GC_WORLD_STOP_BEGIN ();
 449                 break;
 450
 451         case MONO_GC_EVENT_POST_STOP_WORLD:
 452                 MONO_GC_WORLD_STOP_END ();
 453                 break;
 454
 455         case MONO_GC_EVENT_PRE_START_WORLD:
 456                 MONO_GC_WORLD_RESTART_BEGIN (1);
 457                 break;
 458
 459         case MONO_GC_EVENT_POST_START_WORLD:
 460                 MONO_GC_WORLD_RESTART_END (1);
 461                 break;
 462
 463         case MONO_GC_EVENT_START:
 464                 MONO_GC_BEGIN (1);
 465 #ifndef DISABLE_PERFCOUNTERS
 466                 if (mono_perfcounters)
 467                         mono_perfcounters->gc_collections0++;
 468 #endif
 469                 gc_stats.major_gc_count ++;
 470                 gc_start_time = mono_100ns_ticks ();
 471                 break;
 472
 473         case MONO_GC_EVENT_END:
 474                 MONO_GC_END (1);
 475 #if defined(ENABLE_DTRACE) && defined(__sun__)
 476                 /* This works around a dtrace -G problem on Solaris.
 477                    Limit its actual use to when the probe is enabled. */
 478                 if (MONO_GC_END_ENABLED ())
 479                         sleep(0);
 480 #endif
 481
 482 #ifndef DISABLE_PERFCOUNTERS
 483                 if (mono_perfcounters) {
 484                         guint64 heap_size = GC_get_heap_size ();
 485                         guint64 used_size = heap_size - GC_get_free_bytes ();
 486                         mono_perfcounters->gc_total_bytes = used_size;
 487                         mono_perfcounters->gc_committed_bytes = heap_size;
 488                         mono_perfcounters->gc_reserved_bytes = heap_size;
 489                         mono_perfcounters->gc_gen0size = heap_size;
 490                 }
 491 #endif
 492                 gc_stats.major_gc_time += mono_100ns_ticks () - gc_start_time;
 493                 mono_trace_message (MONO_TRACE_GC, "gc took %d usecs", (mono_100ns_ticks () - gc_start_time) / 10);
 494                 break;
 495         default:
 496                 break;
 497         }
 498
 499         mono_profiler_gc_event (e, 0);
 500
 501         switch (e) {
 502         case MONO_GC_EVENT_PRE_STOP_WORLD:
 503                 mono_thread_info_suspend_lock ();
 504                 mono_profiler_gc_event (MONO_GC_EVENT_PRE_STOP_WORLD_LOCKED, 0);
 505                 break;
 506         case MONO_GC_EVENT_POST_START_WORLD:
 507                 mono_thread_info_suspend_unlock ();
 508                 mono_profiler_gc_event (MONO_GC_EVENT_POST_START_WORLD_UNLOCKED, 0);
 509                 break;
 510         default:
 511                 break;
 512         }
 513 }
 514
 515
 516 static void
 517 on_gc_heap_resize (size_t new_size)
 518 {
 519         guint64 heap_size = GC_get_heap_size ();
 520 #ifndef DISABLE_PERFCOUNTERS
 521         if (mono_perfcounters) {
 522                 mono_perfcounters->gc_committed_bytes = heap_size;
 523                 mono_perfcounters->gc_reserved_bytes = heap_size;
 524                 mono_perfcounters->gc_gen0size = heap_size;
 525         }
 526 #endif
 527         mono_profiler_gc_heap_resize (new_size);
 528 }
 529
 530 int
 531 mono_gc_register_root (char *start, size_t size, void *descr, MonoGCRootSource source, const char *msg)
 532 {
 533         /* for some strange reason, they want one extra byte on the end */
 534         GC_add_roots (start, start + size + 1);
 535
 536         return TRUE;
 537 }
 538
 539 int
 540 mono_gc_register_root_wbarrier (char *start, size_t size, MonoGCDescriptor descr, MonoGCRootSource source, const char *msg)
 541 {
 542         return mono_gc_register_root (start, size, descr, source, msg);
 543 }
 544
 545 void
 546 mono_gc_deregister_root (char* addr)
 547 {
 548 #ifndef HOST_WIN32
 549         /* FIXME: libgc doesn't define this work win32 for some reason */
 550         /* FIXME: No size info */
 551         GC_remove_roots (addr, addr + sizeof (gpointer) + 1);
 552 #endif
 553 }
 554
 555 static void
 556 mono_gc_weak_link_add (void **link_addr, MonoObject *obj, gboolean track)
 557 {
 558         /* libgc requires that we use HIDE_POINTER... */
 559         *link_addr = (void*)HIDE_POINTER (obj);
 560         if (track)
 561                 GC_REGISTER_LONG_LINK (link_addr, obj);
 562         else
 563                 GC_GENERAL_REGISTER_DISAPPEARING_LINK (link_addr, obj);
 564 }
 565
 566 static void
 567 mono_gc_weak_link_remove (void **link_addr, gboolean track)
 568 {
 569         if (track)
 570                 GC_unregister_long_link (link_addr);
 571         else
 572                 GC_unregister_disappearing_link (link_addr);
 573         *link_addr = NULL;
 574 }
 575
 576 static gpointer
 577 reveal_link (gpointer link_addr)
 578 {
 579         void **link_a = (void **)link_addr;
 580         return REVEAL_POINTER (*link_a);
 581 }
 582
 583 static MonoObject *
 584 mono_gc_weak_link_get (void **link_addr)
 585 {
 586         MonoObject *obj = (MonoObject *)GC_call_with_alloc_lock (reveal_link, link_addr);
 587         if (obj == (MonoObject *) -1)
 588                 return NULL;
 589         return obj;
 590 }
 591
 592 void*
 593 mono_gc_make_descr_for_string (gsize *bitmap, int numbits)
 594 {
 595         return mono_gc_make_descr_from_bitmap (bitmap, numbits);
 596 }
 597
 598 void*
 599 mono_gc_make_descr_for_object (gsize *bitmap, int numbits, size_t obj_size)
 600 {
 601         return mono_gc_make_descr_from_bitmap (bitmap, numbits);
 602 }
 603
 604 void*
 605 mono_gc_make_descr_for_array (int vector, gsize *elem_bitmap, int numbits, size_t elem_size)
 606 {
 607         /* libgc has no usable support for arrays... */
 608         return GC_NO_DESCRIPTOR;
 609 }
 610
 611 void*
 612 mono_gc_make_descr_from_bitmap (gsize *bitmap, int numbits)
 613 {
 614         /* It seems there are issues when the bitmap doesn't fit: play it safe */
 615         if (numbits >= 30)
 616                 return GC_NO_DESCRIPTOR;
 617         else
 618                 return (gpointer)GC_make_descriptor ((GC_bitmap)bitmap, numbits);
 619 }
 620
 621 void*
 622 mono_gc_make_vector_descr (void)
 623 {
 624         return NULL;
 625 }
 626
 627 void*
 628 mono_gc_make_root_descr_all_refs (int numbits)
 629 {
 630         return NULL;
 631 }
 632
 633 void*
 634 mono_gc_alloc_fixed (size_t size, void *descr, MonoGCRootSource source, const char *msg)
 635 {
 636         return GC_MALLOC_UNCOLLECTABLE (size);
 637 }
 638
 639 void
 640 mono_gc_free_fixed (void* addr)
 641 {
 642         GC_FREE (addr);
 643 }
 644
 645 void *
 646 mono_gc_alloc_obj (MonoVTable *vtable, size_t size)
 647 {
 648         MonoObject *obj;
 649
 650         if (!vtable->klass->has_references) {
 651                 obj = (MonoObject *)GC_MALLOC_ATOMIC (size);
 652                 if (G_UNLIKELY (!obj))
 653                         return NULL;
 654
 655                 obj->vtable = vtable;
 656                 obj->synchronisation = NULL;
 657
 658                 memset ((char *) obj + sizeof (MonoObject), 0, size - sizeof (MonoObject));
 659         } else if (vtable->gc_descr != GC_NO_DESCRIPTOR) {
 660                 obj = (MonoObject *)GC_GCJ_MALLOC (size, vtable);
 661                 if (G_UNLIKELY (!obj))
 662                         return NULL;
 663         } else {
 664                 obj = (MonoObject *)GC_MALLOC (size);
 665                 if (G_UNLIKELY (!obj))
 666                         return NULL;
 667
 668                 obj->vtable = vtable;
 669         }
 670
 671         if (G_UNLIKELY (mono_profiler_events & MONO_PROFILE_ALLOCATIONS))
 672                 mono_profiler_allocation (obj);
 673
 674         return obj;
 675 }
 676
 677 void *
 678 mono_gc_alloc_vector (MonoVTable *vtable, size_t size, uintptr_t max_length)
 679 {
 680         MonoArray *obj;
 681
 682         if (!vtable->klass->has_references) {
 683                 obj = (MonoArray *)GC_MALLOC_ATOMIC (size);
 684                 if (G_UNLIKELY (!obj))
 685                         return NULL;
 686
 687                 obj->obj.vtable = vtable;
 688                 obj->obj.synchronisation = NULL;
 689
 690                 memset ((char *) obj + sizeof (MonoObject), 0, size - sizeof (MonoObject));
 691         } else if (vtable->gc_descr != GC_NO_DESCRIPTOR) {
 692                 obj = (MonoArray *)GC_GCJ_MALLOC (size, vtable);
 693                 if (G_UNLIKELY (!obj))
 694                         return NULL;
 695         } else {
 696                 obj = (MonoArray *)GC_MALLOC (size);
 697                 if (G_UNLIKELY (!obj))
 698                         return NULL;
 699
 700                 obj->obj.vtable = vtable;
 701         }
 702
 703         obj->max_length = max_length;
 704
 705         if (G_UNLIKELY (mono_profiler_events & MONO_PROFILE_ALLOCATIONS))
 706                 mono_profiler_allocation (&obj->obj);
 707
 708         return obj;
 709 }
 710
 711 void *
 712 mono_gc_alloc_array (MonoVTable *vtable, size_t size, uintptr_t max_length, uintptr_t bounds_size)
 713 {
 714         MonoArray *obj;
 715
 716         if (!vtable->klass->has_references) {
 717                 obj = (MonoArray *)GC_MALLOC_ATOMIC (size);
 718                 if (G_UNLIKELY (!obj))
 719                         return NULL;
 720
 721                 obj->obj.vtable = vtable;
 722                 obj->obj.synchronisation = NULL;
 723
 724                 memset ((char *) obj + sizeof (MonoObject), 0, size - sizeof (MonoObject));
 725         } else if (vtable->gc_descr != GC_NO_DESCRIPTOR) {
 726                 obj = (MonoArray *)GC_GCJ_MALLOC (size, vtable);
 727                 if (G_UNLIKELY (!obj))
 728                         return NULL;
 729         } else {
 730                 obj = (MonoArray *)GC_MALLOC (size);
 731                 if (G_UNLIKELY (!obj))
 732                         return NULL;
 733
 734                 obj->obj.vtable = vtable;
 735         }
 736
 737         obj->max_length = max_length;
 738
 739         if (bounds_size)
 740                 obj->bounds = (MonoArrayBounds *) ((char *) obj + size - bounds_size);
 741
 742         if (G_UNLIKELY (mono_profiler_events & MONO_PROFILE_ALLOCATIONS))
 743                 mono_profiler_allocation (&obj->obj);
 744
 745         return obj;
 746 }
 747
 748 void *
 749 mono_gc_alloc_string (MonoVTable *vtable, size_t size, gint32 len)
 750 {
 751         MonoString *obj = (MonoString *)GC_MALLOC_ATOMIC (size);
 752         if (G_UNLIKELY (!obj))
 753                 return NULL;
 754
 755         obj->object.vtable = vtable;
 756         obj->object.synchronisation = NULL;
 757         obj->length = len;
 758         obj->chars [len] = 0;
 759
 760         if (G_UNLIKELY (mono_profiler_events & MONO_PROFILE_ALLOCATIONS))
 761                 mono_profiler_allocation (&obj->object);
 762
 763         return obj;
 764 }
 765
 766 void*
 767 mono_gc_alloc_mature (MonoVTable *vtable, size_t size)
 768 {
 769         return mono_gc_alloc_obj (vtable, size);
 770 }
 771
 772 void*
 773 mono_gc_alloc_pinned_obj (MonoVTable *vtable, size_t size)
 774 {
 775         return mono_gc_alloc_obj (vtable, size);
 776 }
 777
 778 int
 779 mono_gc_invoke_finalizers (void)
 780 {
 781         /* There is a bug in GC_invoke_finalizer () in versions <= 6.2alpha4:
 782          * the 'mem_freed' variable is not initialized when there are no
 783          * objects to finalize, which leads to strange behavior later on.
 784          * The check is necessary to work around that bug.
 785          */
 786         if (GC_should_invoke_finalizers ())
 787                 return GC_invoke_finalizers ();
 788         return 0;
 789 }
 790
 791 MonoBoolean
 792 mono_gc_pending_finalizers (void)
 793 {
 794         return GC_should_invoke_finalizers ();
 795 }
 796
 797 void
 798 mono_gc_wbarrier_set_field (MonoObject *obj, gpointer field_ptr, MonoObject* value)
 799 {
 800         *(void**)field_ptr = value;
 801 }
 802
 803 void
 804 mono_gc_wbarrier_set_arrayref (MonoArray *arr, gpointer slot_ptr, MonoObject* value)
 805 {
 806         *(void**)slot_ptr = value;
 807 }
 808
 809 void
 810 mono_gc_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int count)
 811 {
 812         mono_gc_memmove_aligned (dest_ptr, src_ptr, count * sizeof (gpointer));
 813 }
 814
 815 void
 816 mono_gc_wbarrier_generic_store (gpointer ptr, MonoObject* value)
 817 {
 818         *(void**)ptr = value;
 819 }
 820
 821 void
 822 mono_gc_wbarrier_generic_store_atomic (gpointer ptr, MonoObject *value)
 823 {
 824         InterlockedWritePointer ((volatile gpointer *)ptr, value);
 825 }
 826
 827 void
 828 mono_gc_wbarrier_generic_nostore (gpointer ptr)
 829 {
 830 }
 831
 832 void
 833 mono_gc_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoClass *klass)
 834 {
 835         mono_gc_memmove_atomic (dest, src, count * mono_class_value_size (klass, NULL));
 836 }
 837
 838 void
 839 mono_gc_wbarrier_object_copy (MonoObject* obj, MonoObject *src)
 840 {
 841         /* do not copy the sync state */
 842         mono_gc_memmove_aligned ((char*)obj + sizeof (MonoObject), (char*)src + sizeof (MonoObject),
 843                         mono_object_class (obj)->instance_size - sizeof (MonoObject));
 844 }
 845
 846 void
 847 mono_gc_clear_domain (MonoDomain *domain)
 848 {
 849 }
 850
 851 void
 852 mono_gc_suspend_finalizers (void)
 853 {
 854 }
 855
 856 int
 857 mono_gc_get_suspend_signal (void)
 858 {
 859         return GC_get_suspend_signal ();
 860 }
 861
 862 int
 863 mono_gc_get_restart_signal (void)
 864 {
 865         return GC_get_thr_restart_signal ();
 866 }
 867
 868 #if defined(USE_COMPILER_TLS) && defined(__linux__) && (defined(__i386__) || defined(__x86_64__))
 869 extern __thread void* GC_thread_tls;
 870 #include "metadata-internals.h"
 871
 872 static int
 873 shift_amount (int v)
 874 {
 875         int i = 0;
 876         while (!(v & (1 << i)))
 877                 i++;
 878         return i;
 879 }
 880
 881 enum {
 882         ATYPE_FREEPTR,
 883         ATYPE_FREEPTR_FOR_BOX,
 884         ATYPE_NORMAL,
 885         ATYPE_GCJ,
 886         ATYPE_STRING,
 887         ATYPE_NUM
 888 };
 889
 890 static MonoMethod*
 891 create_allocator (int atype, int tls_key, gboolean slowpath)
 892 {
 893         int index_var, bytes_var, my_fl_var, my_entry_var;
 894         guint32 no_freelist_branch, not_small_enough_branch = 0;
 895         guint32 size_overflow_branch = 0;
 896         MonoMethodBuilder *mb;
 897         MonoMethod *res;
 898         MonoMethodSignature *csig;
 899         const char *name = NULL;
 900         WrapperInfo *info;
 901
 902         g_assert_not_reached ();
 903
 904         if (atype == ATYPE_FREEPTR) {
 905                 name = slowpath ? "SlowAllocPtrfree" : "AllocPtrfree";
 906         } else if (atype == ATYPE_FREEPTR_FOR_BOX) {
 907                 name = slowpath ? "SlowAllocPtrfreeBox" : "AllocPtrfreeBox";
 908         } else if (atype == ATYPE_NORMAL) {
 909                 name = slowpath ? "SlowAlloc" : "Alloc";
 910         } else if (atype == ATYPE_GCJ) {
 911                 name = slowpath ? "SlowAllocGcj" : "AllocGcj";
 912         } else if (atype == ATYPE_STRING) {
 913                 name = slowpath ? "SlowAllocString" : "AllocString";
 914         } else {
 915                 g_assert_not_reached ();
 916         }
 917
 918         csig = mono_metadata_signature_alloc (mono_defaults.corlib, 2);
 919
 920         if (atype == ATYPE_STRING) {
 921                 csig->ret = &mono_defaults.string_class->byval_arg;
 922                 csig->params [0] = &mono_defaults.int_class->byval_arg;
 923                 csig->params [1] = &mono_defaults.int32_class->byval_arg;
 924         } else {
 925                 csig->ret = &mono_defaults.object_class->byval_arg;
 926                 csig->params [0] = &mono_defaults.int_class->byval_arg;
 927                 csig->params [1] = &mono_defaults.int32_class->byval_arg;
 928         }
 929
 930         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_ALLOC);
 931
 932         if (slowpath)
 933                 goto always_slowpath;
 934
 935         bytes_var = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
 936         if (atype == ATYPE_STRING) {
 937                 /* a string alloator method takes the args: (vtable, len) */
 938                 /* bytes = (offsetof (MonoString, chars) + ((len + 1) * 2)); */
 939                 mono_mb_emit_ldarg (mb, 1);
 940                 mono_mb_emit_icon (mb, 1);
 941                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
 942                 mono_mb_emit_icon (mb, 1);
 943                 mono_mb_emit_byte (mb, MONO_CEE_SHL);
 944                 // sizeof (MonoString) might include padding
 945                 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoString, chars));
 946                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
 947                 mono_mb_emit_stloc (mb, bytes_var);
 948         } else {
 949                 mono_mb_emit_ldarg (mb, 1);
 950                 mono_mb_emit_stloc (mb, bytes_var);
 951         }
 952
 953         /* this is needed for strings/arrays only as the other big types are never allocated with this method */
 954         if (atype == ATYPE_STRING) {
 955                 /* check for size */
 956                 /* if (!SMALL_ENOUGH (bytes)) jump slow_path;*/
 957                 mono_mb_emit_ldloc (mb, bytes_var);
 958                 mono_mb_emit_icon (mb, (NFREELISTS-1) * GRANULARITY);
 959                 not_small_enough_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BGT_UN_S);
 960                 /* check for overflow */
 961                 mono_mb_emit_ldloc (mb, bytes_var);
 962                 mono_mb_emit_icon (mb, sizeof (MonoString));
 963                 size_overflow_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BLE_UN_S);
 964         }
 965
 966         /* int index = INDEX_FROM_BYTES(bytes); */
 967         index_var = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
 968
 969         mono_mb_emit_ldloc (mb, bytes_var);
 970         mono_mb_emit_icon (mb, GRANULARITY - 1);
 971         mono_mb_emit_byte (mb, MONO_CEE_ADD);
 972         mono_mb_emit_icon (mb, shift_amount (GRANULARITY));
 973         mono_mb_emit_byte (mb, MONO_CEE_SHR_UN);
 974         mono_mb_emit_icon (mb, shift_amount (sizeof (gpointer)));
 975         mono_mb_emit_byte (mb, MONO_CEE_SHL);
 976         /* index var is already adjusted into bytes */
 977         mono_mb_emit_stloc (mb, index_var);
 978
 979         my_fl_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
 980         my_entry_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
 981         /* my_fl = ((GC_thread)tsd) -> ptrfree_freelists + index; */
 982         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
 983         mono_mb_emit_byte (mb, 0x0D); /* CEE_MONO_TLS */
 984         mono_mb_emit_i4 (mb, tls_key);
 985         if (atype == ATYPE_FREEPTR || atype == ATYPE_FREEPTR_FOR_BOX || atype == ATYPE_STRING)
 986                 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (struct GC_Thread_Rep, tlfs)
 987                                         + G_STRUCT_OFFSET (struct thread_local_freelists,
 988                                                            ptrfree_freelists));
 989         else if (atype == ATYPE_NORMAL)
 990                 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (struct GC_Thread_Rep, tlfs)
 991                                         + G_STRUCT_OFFSET (struct thread_local_freelists,
 992                                                            normal_freelists));
 993         else if (atype == ATYPE_GCJ)
 994                 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (struct GC_Thread_Rep, tlfs)
 995                                         + G_STRUCT_OFFSET (struct thread_local_freelists,
 996                                                            gcj_freelists));
 997         else
 998                 g_assert_not_reached ();
 999         mono_mb_emit_byte (mb, MONO_CEE_ADD);
1000         mono_mb_emit_ldloc (mb, index_var);
1001         mono_mb_emit_byte (mb, MONO_CEE_ADD);
1002         mono_mb_emit_stloc (mb, my_fl_var);
1003
1004         /* my_entry = *my_fl; */
1005         mono_mb_emit_ldloc (mb, my_fl_var);
1006         mono_mb_emit_byte (mb, MONO_CEE_LDIND_I);
1007         mono_mb_emit_stloc (mb, my_entry_var);
1008
1009         /* if (EXPECT((word)my_entry >= HBLKSIZE, 1)) { */
1010         mono_mb_emit_ldloc (mb, my_entry_var);
1011         mono_mb_emit_icon (mb, HBLKSIZE);
1012         no_freelist_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BLT_UN_S);
1013
1014         /* ptr_t next = obj_link(my_entry); *my_fl = next; */
1015         mono_mb_emit_ldloc (mb, my_fl_var);
1016         mono_mb_emit_ldloc (mb, my_entry_var);
1017         mono_mb_emit_byte (mb, MONO_CEE_LDIND_I);
1018         mono_mb_emit_byte (mb, MONO_CEE_STIND_I);
1019
1020         /* set the vtable and clear the words in the object */
1021         mono_mb_emit_ldloc (mb, my_entry_var);
1022         mono_mb_emit_ldarg (mb, 0);
1023         mono_mb_emit_byte (mb, MONO_CEE_STIND_I);
1024
1025         if (atype == ATYPE_FREEPTR) {
1026                 int start_var, end_var, start_loop;
1027                 /* end = my_entry + bytes; start = my_entry + sizeof (gpointer);
1028                  */
1029                 start_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1030                 end_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1031                 mono_mb_emit_ldloc (mb, my_entry_var);
1032                 mono_mb_emit_ldloc (mb, bytes_var);
1033                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
1034                 mono_mb_emit_stloc (mb, end_var);
1035                 mono_mb_emit_ldloc (mb, my_entry_var);
1036                 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoObject, synchronisation));
1037                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
1038                 mono_mb_emit_stloc (mb, start_var);
1039                 /*
1040                  * do {
1041                  *      *start++ = NULL;
1042                  * } while (start < end);
1043                  */
1044                 start_loop = mono_mb_get_label (mb);
1045                 mono_mb_emit_ldloc (mb, start_var);
1046                 mono_mb_emit_icon (mb, 0);
1047                 mono_mb_emit_byte (mb, MONO_CEE_STIND_I);
1048                 mono_mb_emit_ldloc (mb, start_var);
1049                 mono_mb_emit_icon (mb, sizeof (gpointer));
1050                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
1051                 mono_mb_emit_stloc (mb, start_var);
1052
1053                 mono_mb_emit_ldloc (mb, start_var);
1054                 mono_mb_emit_ldloc (mb, end_var);
1055                 mono_mb_emit_byte (mb, MONO_CEE_BLT_UN_S);
1056                 mono_mb_emit_byte (mb, start_loop - (mono_mb_get_label (mb) + 1));
1057         } else if (atype == ATYPE_FREEPTR_FOR_BOX || atype == ATYPE_STRING) {
1058                 /* need to clear just the sync pointer */
1059                 mono_mb_emit_ldloc (mb, my_entry_var);
1060                 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoObject, synchronisation));
1061                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
1062                 mono_mb_emit_icon (mb, 0);
1063                 mono_mb_emit_byte (mb, MONO_CEE_STIND_I);
1064         }
1065
1066         if (atype == ATYPE_STRING) {
1067                 /* need to set length and clear the last char */
1068                 /* s->length = len; */
1069                 mono_mb_emit_ldloc (mb, my_entry_var);
1070                 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoString, length));
1071                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
1072                 mono_mb_emit_ldarg (mb, 1);
1073                 mono_mb_emit_byte (mb, MONO_CEE_STIND_I4);
1074                 /* s->chars [len] = 0; */
1075                 mono_mb_emit_ldloc (mb, my_entry_var);
1076                 mono_mb_emit_ldloc (mb, bytes_var);
1077                 mono_mb_emit_icon (mb, 2);
1078                 mono_mb_emit_byte (mb, MONO_CEE_SUB);
1079                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
1080                 mono_mb_emit_icon (mb, 0);
1081                 mono_mb_emit_byte (mb, MONO_CEE_STIND_I2);
1082         }
1083
1084         /* return my_entry; */
1085         mono_mb_emit_ldloc (mb, my_entry_var);
1086         mono_mb_emit_byte (mb, MONO_CEE_RET);
1087
1088         mono_mb_patch_short_branch (mb, no_freelist_branch);
1089         if (not_small_enough_branch > 0)
1090                 mono_mb_patch_short_branch (mb, not_small_enough_branch);
1091         if (size_overflow_branch > 0)
1092                 mono_mb_patch_short_branch (mb, size_overflow_branch);
1093
1094         /* the slow path: we just call back into the runtime */
1095  always_slowpath:
1096         if (atype == ATYPE_STRING) {
1097                 mono_mb_emit_ldarg (mb, 1);
1098                 mono_mb_emit_icall (mb, ves_icall_string_alloc);
1099         } else {
1100                 mono_mb_emit_ldarg (mb, 0);
1101                 mono_mb_emit_icall (mb, ves_icall_object_new_specific);
1102         }
1103
1104         mono_mb_emit_byte (mb, MONO_CEE_RET);
1105
1106         info = mono_wrapper_info_create (mb, WRAPPER_SUBTYPE_NONE);
1107         info->d.alloc.gc_name = "boehm";
1108         info->d.alloc.alloc_type = atype;
1109         mb->init_locals = FALSE;
1110
1111         res = mono_mb_create (mb, csig, 8, info);
1112         mono_mb_free (mb);
1113
1114         return res;
1115 }
1116
1117 static MonoMethod* alloc_method_cache [ATYPE_NUM];
1118 static MonoMethod* slowpath_alloc_method_cache [ATYPE_NUM];
1119
1120 gboolean
1121 mono_gc_is_critical_method (MonoMethod *method)
1122 {
1123         int i;
1124
1125         for (i = 0; i < ATYPE_NUM; ++i)
1126                 if (method == alloc_method_cache [i] || method == slowpath_alloc_method_cache [i])
1127                         return TRUE;
1128
1129         return FALSE;
1130 }
1131
1132 /*
1133  * If possible, generate a managed method that can quickly allocate objects in class
1134  * @klass. The method will typically have an thread-local inline allocation sequence.
1135  * The signature of the called method is:
1136  *      object allocate (MonoVTable *vtable)
1137  * Some of the logic here is similar to mono_class_get_allocation_ftn () i object.c,
1138  * keep in sync.
1139  * The thread local alloc logic is taken from libgc/pthread_support.c.
1140  */
1141
1142 MonoMethod*
1143 mono_gc_get_managed_allocator (MonoClass *klass, gboolean for_box, gboolean known_instance_size)
1144 {
1145         int atype;
1146
1147         /*
1148          * Tls implementation changed, we jump to tls native getters/setters.
1149          * Is boehm managed allocator ok with this ? Do we even care ?
1150          */
1151         return NULL;
1152
1153         if (!SMALL_ENOUGH (klass->instance_size))
1154                 return NULL;
1155         if (mono_class_has_finalizer (klass) || mono_class_is_marshalbyref (klass))
1156                 return NULL;
1157         if (mono_profiler_get_events () & (MONO_PROFILE_ALLOCATIONS | MONO_PROFILE_STATISTICAL))
1158                 return NULL;
1159         if (klass->rank)
1160                 return NULL;
1161         if (mono_class_is_open_constructed_type (&klass->byval_arg))
1162                 return NULL;
1163         if (klass->byval_arg.type == MONO_TYPE_STRING) {
1164                 atype = ATYPE_STRING;
1165         } else if (!known_instance_size) {
1166                 return NULL;
1167         } else if (!klass->has_references) {
1168                 if (for_box)
1169                         atype = ATYPE_FREEPTR_FOR_BOX;
1170                 else
1171                         atype = ATYPE_FREEPTR;
1172         } else {
1173                 return NULL;
1174                 /*
1175                  * disabled because we currently do a runtime choice anyway, to
1176                  * deal with multiple appdomains.
1177                 if (vtable->gc_descr != GC_NO_DESCRIPTOR)
1178                         atype = ATYPE_GCJ;
1179                 else
1180                         atype = ATYPE_NORMAL;
1181                 */
1182         }
1183         return mono_gc_get_managed_allocator_by_type (atype, MANAGED_ALLOCATOR_REGULAR);
1184 }
1185
1186 MonoMethod*
1187 mono_gc_get_managed_array_allocator (MonoClass *klass)
1188 {
1189         return NULL;
1190 }
1191
1192 /**
1193  * mono_gc_get_managed_allocator_by_type:
1194  *
1195  *   Return a managed allocator method corresponding to allocator type ATYPE.
1196  */
1197 MonoMethod*
1198 mono_gc_get_managed_allocator_by_type (int atype, ManagedAllocatorVariant variant)
1199 {
1200         MonoMethod *res;
1201         gboolean slowpath = variant != MANAGED_ALLOCATOR_REGULAR;
1202         MonoMethod **cache = slowpath ? slowpath_alloc_method_cache : alloc_method_cache;
1203
1204         return NULL;
1205
1206         res = cache [atype];
1207         if (res)
1208                 return res;
1209
1210         res = create_allocator (atype, -1, slowpath);
1211         mono_os_mutex_lock (&mono_gc_lock);
1212         if (cache [atype]) {
1213                 mono_free_method (res);
1214                 res = cache [atype];
1215         } else {
1216                 mono_memory_barrier ();
1217                 cache [atype] = res;
1218         }
1219         mono_os_mutex_unlock (&mono_gc_lock);
1220         return res;
1221 }
1222
1223 guint32
1224 mono_gc_get_managed_allocator_types (void)
1225 {
1226         return ATYPE_NUM;
1227 }
1228
1229 MonoMethod*
1230 mono_gc_get_write_barrier (void)
1231 {
1232         g_assert_not_reached ();
1233         return NULL;
1234 }
1235
1236 #else
1237
1238 gboolean
1239 mono_gc_is_critical_method (MonoMethod *method)
1240 {
1241         return FALSE;
1242 }
1243
1244 MonoMethod*
1245 mono_gc_get_managed_allocator (MonoClass *klass, gboolean for_box, gboolean known_instance_size)
1246 {
1247         return NULL;
1248 }
1249
1250 MonoMethod*
1251 mono_gc_get_managed_array_allocator (MonoClass *klass)
1252 {
1253         return NULL;
1254 }
1255
1256 MonoMethod*
1257 mono_gc_get_managed_allocator_by_type (int atype, ManagedAllocatorVariant variant)
1258 {
1259         return NULL;
1260 }
1261
1262 guint32
1263 mono_gc_get_managed_allocator_types (void)
1264 {
1265         return 0;
1266 }
1267
1268 MonoMethod*
1269 mono_gc_get_write_barrier (void)
1270 {
1271         g_assert_not_reached ();
1272         return NULL;
1273 }
1274
1275 #endif
1276
1277 MonoMethod*
1278 mono_gc_get_specific_write_barrier (gboolean is_concurrent)
1279 {
1280         g_assert_not_reached ();
1281         return NULL;
1282 }
1283
1284 int
1285 mono_gc_get_aligned_size_for_allocator (int size)
1286 {
1287         return size;
1288 }
1289
1290 const char *
1291 mono_gc_get_gc_name (void)
1292 {
1293         return "boehm";
1294 }
1295
1296 void*
1297 mono_gc_invoke_with_gc_lock (MonoGCLockedCallbackFunc func, void *data)
1298 {
1299         return GC_call_with_alloc_lock (func, data);
1300 }
1301
1302 char*
1303 mono_gc_get_description (void)
1304 {
1305         return g_strdup (DEFAULT_GC_NAME);
1306 }
1307
1308 void
1309 mono_gc_set_desktop_mode (void)
1310 {
1311         GC_dont_expand = 1;
1312 }
1313
1314 gboolean
1315 mono_gc_is_moving (void)
1316 {
1317         return FALSE;
1318 }
1319
1320 gboolean
1321 mono_gc_is_disabled (void)
1322 {
1323         if (GC_dont_gc || g_getenv ("GC_DONT_GC"))
1324                 return TRUE;
1325         else
1326                 return FALSE;
1327 }
1328
1329 void
1330 mono_gc_wbarrier_value_copy_bitmap (gpointer _dest, gpointer _src, int size, unsigned bitmap)
1331 {
1332         g_assert_not_reached ();
1333 }
1334
1335
1336 guint8*
1337 mono_gc_get_card_table (int *shift_bits, gpointer *card_mask)
1338 {
1339         g_assert_not_reached ();
1340         return NULL;
1341 }
1342
1343 gboolean
1344 mono_gc_card_table_nursery_check (void)
1345 {
1346         g_assert_not_reached ();
1347         return TRUE;
1348 }
1349
1350 void*
1351 mono_gc_get_nursery (int *shift_bits, size_t *size)
1352 {
1353         return NULL;
1354 }
1355
1356 gboolean
1357 mono_gc_precise_stack_mark_enabled (void)
1358 {
1359         return FALSE;
1360 }
1361
1362 FILE *
1363 mono_gc_get_logfile (void)
1364 {
1365         return NULL;
1366 }
1367
1368 void
1369 mono_gc_params_set (const char* options)
1370 {
1371 }
1372
1373 void
1374 mono_gc_debug_set (const char* options)
1375 {
1376 }
1377
1378 void
1379 mono_gc_conservatively_scan_area (void *start, void *end)
1380 {
1381         g_assert_not_reached ();
1382 }
1383
1384 void *
1385 mono_gc_scan_object (void *obj, void *gc_data)
1386 {
1387         g_assert_not_reached ();
1388         return NULL;
1389 }
1390
1391 gsize*
1392 mono_gc_get_bitmap_for_descr (void *descr, int *numbits)
1393 {
1394         g_assert_not_reached ();
1395         return NULL;
1396 }
1397
1398 void
1399 mono_gc_set_gc_callbacks (MonoGCCallbacks *callbacks)
1400 {
1401 }
1402
1403 void
1404 mono_gc_set_stack_end (void *stack_end)
1405 {
1406 }
1407
1408 void mono_gc_set_skip_thread (gboolean value)
1409 {
1410 }
1411
1412 void
1413 mono_gc_register_for_finalization (MonoObject *obj, void *user_data)
1414 {
1415         guint offset = 0;
1416
1417 #ifndef GC_DEBUG
1418         /* This assertion is not valid when GC_DEBUG is defined */
1419         g_assert (GC_base (obj) == (char*)obj - offset);
1420 #endif
1421
1422         GC_REGISTER_FINALIZER_NO_ORDER ((char*)obj - offset, (GC_finalization_proc)user_data, GUINT_TO_POINTER (offset), NULL, NULL);
1423 }
1424
1425 #ifndef HOST_WIN32
1426 int
1427 mono_gc_pthread_create (pthread_t *new_thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
1428 {
1429         /* it is being replaced by GC_pthread_create on some
1430          * platforms, see libgc/include/gc_pthread_redirects.h */
1431         return pthread_create (new_thread, attr, start_routine, arg);
1432 }
1433 #endif
1434
1435 #ifdef HOST_WIN32
1436 BOOL APIENTRY mono_gc_dllmain (HMODULE module_handle, DWORD reason, LPVOID reserved)
1437 {
1438         return GC_DllMain (module_handle, reason, reserved);
1439 }
1440 #endif
1441
1442 guint
1443 mono_gc_get_vtable_bits (MonoClass *klass)
1444 {
1445         if (fin_callbacks.is_class_finalization_aware) {
1446                 if (fin_callbacks.is_class_finalization_aware (klass))
1447                         return BOEHM_GC_BIT_FINALIZER_AWARE;
1448         }
1449         return 0;
1450 }
1451
1452 /*
1453  * mono_gc_register_altstack:
1454  *
1455  *   Register the dimensions of the normal stack and altstack with the collector.
1456  * Currently, STACK/STACK_SIZE is only used when the thread is suspended while it is on an altstack.
1457  */
1458 void
1459 mono_gc_register_altstack (gpointer stack, gint32 stack_size, gpointer altstack, gint32 altstack_size)
1460 {
1461         GC_register_altstack (stack, stack_size, altstack, altstack_size);
1462 }
1463
1464 int
1465 mono_gc_get_los_limit (void)
1466 {
1467         return G_MAXINT;
1468 }
1469
1470 void
1471 mono_gc_set_string_length (MonoString *str, gint32 new_length)
1472 {
1473         mono_unichar2 *new_end = str->chars + new_length;
1474
1475         /* zero the discarded string. This null-delimits the string and allows
1476          * the space to be reclaimed by SGen. */
1477
1478         memset (new_end, 0, (str->length - new_length + 1) * sizeof (mono_unichar2));
1479         str->length = new_length;
1480 }
1481
1482 gboolean
1483 mono_gc_user_markers_supported (void)
1484 {
1485         return FALSE;
1486 }
1487
1488 void *
1489 mono_gc_make_root_descr_user (MonoGCRootMarkFunc marker)
1490 {
1491         g_assert_not_reached ();
1492         return NULL;
1493 }
1494
1495 /* Toggleref support */
1496
1497 void
1498 mono_gc_toggleref_add (MonoObject *object, mono_bool strong_ref)
1499 {
1500         if (GC_toggleref_add ((GC_PTR)object, (int)strong_ref) != GC_SUCCESS)
1501             g_error ("GC_toggleref_add failed\n");
1502 }
1503
1504 void
1505 mono_gc_toggleref_register_callback (MonoToggleRefStatus (*proccess_toggleref) (MonoObject *obj))
1506 {
1507         GC_set_toggleref_func ((GC_ToggleRefStatus (*) (GC_PTR obj)) proccess_toggleref);
1508 }
1509
1510 /* Test support code */
1511
1512 static MonoToggleRefStatus
1513 test_toggleref_callback (MonoObject *obj)
1514 {
1515         static MonoClassField *mono_toggleref_test_field;
1516         MonoToggleRefStatus status = MONO_TOGGLE_REF_DROP;
1517
1518         if (!mono_toggleref_test_field) {
1519                 mono_toggleref_test_field = mono_class_get_field_from_name (mono_object_get_class (obj), "__test");
1520                 g_assert (mono_toggleref_test_field);
1521         }
1522
1523         mono_field_get_value (obj, mono_toggleref_test_field, &status);
1524         printf ("toggleref-cb obj %d\n", status);
1525         return status;
1526 }
1527
1528 static void
1529 register_test_toggleref_callback (void)
1530 {
1531         mono_gc_toggleref_register_callback (test_toggleref_callback);
1532 }
1533
1534 static gboolean
1535 is_finalization_aware (MonoObject *obj)
1536 {
1537         MonoVTable *vt = obj->vtable;
1538         return (vt->gc_bits & BOEHM_GC_BIT_FINALIZER_AWARE) == BOEHM_GC_BIT_FINALIZER_AWARE;
1539 }
1540
1541 static void
1542 fin_notifier (MonoObject *obj)
1543 {
1544         if (is_finalization_aware (obj))
1545                 fin_callbacks.object_queued_for_finalization (obj);
1546 }
1547
1548 void
1549 mono_gc_register_finalizer_callbacks (MonoGCFinalizerCallbacks *callbacks)
1550 {
1551         if (callbacks->version != MONO_GC_FINALIZER_EXTENSION_VERSION)
1552                 g_error ("Invalid finalizer callback version. Expected %d but got %d\n", MONO_GC_FINALIZER_EXTENSION_VERSION, callbacks->version);
1553
1554         fin_callbacks = *callbacks;
1555
1556         GC_set_await_finalize_proc ((void (*) (GC_PTR))fin_notifier);
1557 }
1558
1559 #define BITMAP_SIZE (sizeof (*((HandleData *)NULL)->bitmap) * CHAR_BIT)
1560
1561 static inline gboolean
1562 slot_occupied (HandleData *handles, guint slot) {
1563         return handles->bitmap [slot / BITMAP_SIZE] & (1 << (slot % BITMAP_SIZE));
1564 }
1565
1566 static inline void
1567 vacate_slot (HandleData *handles, guint slot) {
1568         handles->bitmap [slot / BITMAP_SIZE] &= ~(1 << (slot % BITMAP_SIZE));
1569 }
1570
1571 static inline void
1572 occupy_slot (HandleData *handles, guint slot) {
1573         handles->bitmap [slot / BITMAP_SIZE] |= 1 << (slot % BITMAP_SIZE);
1574 }
1575
1576 static int
1577 find_first_unset (guint32 bitmap)
1578 {
1579         int i;
1580         for (i = 0; i < 32; ++i) {
1581                 if (!(bitmap & (1 << i)))
1582                         return i;
1583         }
1584         return -1;
1585 }
1586
1587 static void
1588 handle_data_alloc_entries (HandleData *handles)
1589 {
1590         handles->size = 32;
1591         if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
1592                 handles->entries = (void **)g_malloc0 (sizeof (*handles->entries) * handles->size);
1593                 handles->domain_ids = (guint16 *)g_malloc0 (sizeof (*handles->domain_ids) * handles->size);
1594         } else {
1595                 handles->entries = (void **)mono_gc_alloc_fixed (sizeof (*handles->entries) * handles->size, NULL, MONO_ROOT_SOURCE_GC_HANDLE, "gc handles table");
1596         }
1597         handles->bitmap = (guint32 *)g_malloc0 (handles->size / CHAR_BIT);
1598 }
1599
1600 static gint
1601 handle_data_next_unset (HandleData *handles)
1602 {
1603         gint slot;
1604         for (slot = handles->slot_hint; slot < handles->size / BITMAP_SIZE; ++slot) {
1605                 if (handles->bitmap [slot] == 0xffffffff)
1606                         continue;
1607                 handles->slot_hint = slot;
1608                 return find_first_unset (handles->bitmap [slot]);
1609         }
1610         return -1;
1611 }
1612
1613 static gint
1614 handle_data_first_unset (HandleData *handles)
1615 {
1616         gint slot;
1617         for (slot = 0; slot < handles->slot_hint; ++slot) {
1618                 if (handles->bitmap [slot] == 0xffffffff)
1619                         continue;
1620                 handles->slot_hint = slot;
1621                 return find_first_unset (handles->bitmap [slot]);
1622         }
1623         return -1;
1624 }
1625
1626 /* Returns the index of the current slot in the bitmap. */
1627 static void
1628 handle_data_grow (HandleData *handles, gboolean track)
1629 {
1630         guint32 *new_bitmap;
1631         guint32 new_size = handles->size * 2; /* always double: we memset to 0 based on this below */
1632
1633         /* resize and copy the bitmap */
1634         new_bitmap = (guint32 *)g_malloc0 (new_size / CHAR_BIT);
1635         memcpy (new_bitmap, handles->bitmap, handles->size / CHAR_BIT);
1636         g_free (handles->bitmap);
1637         handles->bitmap = new_bitmap;
1638
1639         /* resize and copy the entries */
1640         if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
1641                 gpointer *entries;
1642                 guint16 *domain_ids;
1643                 gint i;
1644                 domain_ids = (guint16 *)g_malloc0 (sizeof (*handles->domain_ids) * new_size);
1645                 entries = (void **)g_malloc0 (sizeof (*handles->entries) * new_size);
1646                 memcpy (domain_ids, handles->domain_ids, sizeof (*handles->domain_ids) * handles->size);
1647                 for (i = 0; i < handles->size; ++i) {
1648                         MonoObject *obj = mono_gc_weak_link_get (&(handles->entries [i]));
1649                         if (obj) {
1650                                 mono_gc_weak_link_add (&(entries [i]), obj, track);
1651                                 mono_gc_weak_link_remove (&(handles->entries [i]), track);
1652                         } else {
1653                                 g_assert (!handles->entries [i]);
1654                         }
1655                 }
1656                 g_free (handles->entries);
1657                 g_free (handles->domain_ids);
1658                 handles->entries = entries;
1659                 handles->domain_ids = domain_ids;
1660         } else {
1661                 gpointer *entries;
1662                 entries = (void **)mono_gc_alloc_fixed (sizeof (*handles->entries) * new_size, NULL, MONO_ROOT_SOURCE_GC_HANDLE, "gc handles table");
1663                 mono_gc_memmove_aligned (entries, handles->entries, sizeof (*handles->entries) * handles->size);
1664                 mono_gc_free_fixed (handles->entries);
1665                 handles->entries = entries;
1666         }
1667         handles->slot_hint = handles->size / BITMAP_SIZE;
1668         handles->size = new_size;
1669 }
1670
1671 static guint32
1672 alloc_handle (HandleData *handles, MonoObject *obj, gboolean track)
1673 {
1674         gint slot, i;
1675         guint32 res;
1676         lock_handles (handles);
1677         if (!handles->size)
1678                 handle_data_alloc_entries (handles);
1679         i = handle_data_next_unset (handles);
1680         if (i == -1 && handles->slot_hint != 0)
1681                 i = handle_data_first_unset (handles);
1682         if (i == -1) {
1683                 handle_data_grow (handles, track);
1684                 i = 0;
1685         }
1686         slot = handles->slot_hint * BITMAP_SIZE + i;
1687         occupy_slot (handles, slot);
1688         handles->entries [slot] = NULL;
1689         if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
1690                 /*FIXME, what to use when obj == null?*/
1691                 handles->domain_ids [slot] = (obj ? mono_object_get_domain (obj) : mono_domain_get ())->domain_id;
1692                 if (obj)
1693                         mono_gc_weak_link_add (&(handles->entries [slot]), obj, track);
1694         } else {
1695                 handles->entries [slot] = obj;
1696         }
1697
1698 #ifndef DISABLE_PERFCOUNTERS
1699         mono_perfcounters->gc_num_handles++;
1700 #endif
1701         unlock_handles (handles);
1702         res = MONO_GC_HANDLE (slot, handles->type);
1703         mono_profiler_gc_handle (MONO_PROFILER_GC_HANDLE_CREATED, handles->type, res, obj);
1704         return res;
1705 }
1706
1707 /**
1708  * mono_gchandle_new:
1709  * \param obj managed object to get a handle for
1710  * \param pinned whether the object should be pinned
1711  *
1712  * This returns a handle that wraps the object, this is used to keep a
1713  * reference to a managed object from the unmanaged world and preventing the
1714  * object from being disposed.
1715  *
1716  * If \p pinned is false the address of the object can not be obtained, if it is
1717  * true the address of the object can be obtained.  This will also pin the
1718  * object so it will not be possible by a moving garbage collector to move the
1719  * object.
1720  *
1721  * \returns a handle that can be used to access the object from
1722  * unmanaged code.
1723  */
1724 guint32
1725 mono_gchandle_new (MonoObject *obj, gboolean pinned)
1726 {
1727         return alloc_handle (&gc_handles [pinned? HANDLE_PINNED: HANDLE_NORMAL], obj, FALSE);
1728 }
1729
1730 /**
1731  * mono_gchandle_new_weakref:
1732  * \param obj managed object to get a handle for
1733  * \param track_resurrection Determines how long to track the object, if this is set to TRUE, the object is tracked after finalization, if FALSE, the object is only tracked up until the point of finalization.
1734  *
1735  * This returns a weak handle that wraps the object, this is used to
1736  * keep a reference to a managed object from the unmanaged world.
1737  * Unlike the \c mono_gchandle_new the object can be reclaimed by the
1738  * garbage collector.  In this case the value of the GCHandle will be
1739  * set to zero.
1740  *
1741  * If \p track_resurrection is TRUE the object will be tracked through
1742  * finalization and if the object is resurrected during the execution
1743  * of the finalizer, then the returned weakref will continue to hold
1744  * a reference to the object.   If \p track_resurrection is FALSE, then
1745  * the weak reference's target will become NULL as soon as the object
1746  * is passed on to the finalizer.
1747  *
1748  * \returns a handle that can be used to access the object from
1749  * unmanaged code.
1750  */
1751 guint32
1752 mono_gchandle_new_weakref (MonoObject *obj, gboolean track_resurrection)
1753 {
1754         return alloc_handle (&gc_handles [track_resurrection? HANDLE_WEAK_TRACK: HANDLE_WEAK], obj, track_resurrection);
1755 }
1756
1757 /**
1758  * mono_gchandle_get_target:
1759  * \param gchandle a GCHandle's handle.
1760  *
1761  * The handle was previously created by calling \c mono_gchandle_new or
1762  * \c mono_gchandle_new_weakref.
1763  *
1764  * \returns A pointer to the \c MonoObject* represented by the handle or
1765  * NULL for a collected object if using a weakref handle.
1766  */
1767 MonoObject*
1768 mono_gchandle_get_target (guint32 gchandle)
1769 {
1770         guint slot = MONO_GC_HANDLE_SLOT (gchandle);
1771         guint type = MONO_GC_HANDLE_TYPE (gchandle);
1772         HandleData *handles = &gc_handles [type];
1773         MonoObject *obj = NULL;
1774         if (type >= HANDLE_TYPE_MAX)
1775                 return NULL;
1776
1777         lock_handles (handles);
1778         if (slot < handles->size && slot_occupied (handles, slot)) {
1779                 if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
1780                         obj = mono_gc_weak_link_get (&handles->entries [slot]);
1781                 } else {
1782                         obj = (MonoObject *)handles->entries [slot];
1783                 }
1784         } else {
1785                 /* print a warning? */
1786         }
1787         unlock_handles (handles);
1788         /*g_print ("get target of entry %d of type %d: %p\n", slot, handles->type, obj);*/
1789         return obj;
1790 }
1791
1792 void
1793 mono_gchandle_set_target (guint32 gchandle, MonoObject *obj)
1794 {
1795         guint slot = MONO_GC_HANDLE_SLOT (gchandle);
1796         guint type = MONO_GC_HANDLE_TYPE (gchandle);
1797         HandleData *handles = &gc_handles [type];
1798         MonoObject *old_obj = NULL;
1799
1800         g_assert (type < HANDLE_TYPE_MAX);
1801         lock_handles (handles);
1802         if (slot < handles->size && slot_occupied (handles, slot)) {
1803                 if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
1804                         old_obj = (MonoObject *)handles->entries [slot];
1805                         if (handles->entries [slot])
1806                                 mono_gc_weak_link_remove (&handles->entries [slot], handles->type == HANDLE_WEAK_TRACK);
1807                         if (obj)
1808                                 mono_gc_weak_link_add (&handles->entries [slot], obj, handles->type == HANDLE_WEAK_TRACK);
1809                         /*FIXME, what to use when obj == null?*/
1810                         handles->domain_ids [slot] = (obj ? mono_object_get_domain (obj) : mono_domain_get ())->domain_id;
1811                 } else {
1812                         handles->entries [slot] = obj;
1813                 }
1814         } else {
1815                 /* print a warning? */
1816         }
1817         /*g_print ("changed entry %d of type %d to object %p (in slot: %p)\n", slot, handles->type, obj, handles->entries [slot]);*/
1818         unlock_handles (handles);
1819 }
1820
1821 gboolean
1822 mono_gc_is_null (void)
1823 {
1824         return FALSE;
1825 }
1826
1827 /**
1828  * mono_gchandle_is_in_domain:
1829  * \param gchandle a GCHandle's handle.
1830  * \param domain An application domain.
1831  *
1832  * Use this function to determine if the \p gchandle points to an
1833  * object allocated in the specified \p domain.
1834  *
1835  * \returns TRUE if the object wrapped by the \p gchandle belongs to the specific \p domain.
1836  */
1837 gboolean
1838 mono_gchandle_is_in_domain (guint32 gchandle, MonoDomain *domain)
1839 {
1840         guint slot = MONO_GC_HANDLE_SLOT (gchandle);
1841         guint type = MONO_GC_HANDLE_TYPE (gchandle);
1842         HandleData *handles = &gc_handles [type];
1843         gboolean result = FALSE;
1844
1845         if (type >= HANDLE_TYPE_MAX)
1846                 return FALSE;
1847
1848         lock_handles (handles);
1849         if (slot < handles->size && slot_occupied (handles, slot)) {
1850                 if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
1851                         result = domain->domain_id == handles->domain_ids [slot];
1852                 } else {
1853                         MonoObject *obj;
1854                         obj = (MonoObject *)handles->entries [slot];
1855                         if (obj == NULL)
1856                                 result = TRUE;
1857                         else
1858                                 result = domain == mono_object_domain (obj);
1859                 }
1860         } else {
1861                 /* print a warning? */
1862         }
1863         unlock_handles (handles);
1864         return result;
1865 }
1866
1867 /**
1868  * mono_gchandle_free:
1869  * \param gchandle a GCHandle's handle.
1870  *
1871  * Frees the \p gchandle handle.  If there are no outstanding
1872  * references, the garbage collector can reclaim the memory of the
1873  * object wrapped.
1874  */
1875 void
1876 mono_gchandle_free (guint32 gchandle)
1877 {
1878         guint slot = MONO_GC_HANDLE_SLOT (gchandle);
1879         guint type = MONO_GC_HANDLE_TYPE (gchandle);
1880         HandleData *handles = &gc_handles [type];
1881         if (type >= HANDLE_TYPE_MAX)
1882                 return;
1883
1884         lock_handles (handles);
1885         if (slot < handles->size && slot_occupied (handles, slot)) {
1886                 if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
1887                         if (handles->entries [slot])
1888                                 mono_gc_weak_link_remove (&handles->entries [slot], handles->type == HANDLE_WEAK_TRACK);
1889                 } else {
1890                         handles->entries [slot] = NULL;
1891                 }
1892                 vacate_slot (handles, slot);
1893         } else {
1894                 /* print a warning? */
1895         }
1896 #ifndef DISABLE_PERFCOUNTERS
1897         mono_perfcounters->gc_num_handles--;
1898 #endif
1899         /*g_print ("freed entry %d of type %d\n", slot, handles->type);*/
1900         unlock_handles (handles);
1901         mono_profiler_gc_handle (MONO_PROFILER_GC_HANDLE_DESTROYED, handles->type, gchandle, NULL);
1902 }
1903
1904 /**
1905  * mono_gchandle_free_domain:
1906  * \param domain domain that is unloading
1907  *
1908  * Function used internally to cleanup any GC handle for objects belonging
1909  * to the specified domain during appdomain unload.
1910  */
1911 void
1912 mono_gchandle_free_domain (MonoDomain *domain)
1913 {
1914         guint type;
1915
1916         for (type = HANDLE_TYPE_MIN; type < HANDLE_PINNED; ++type) {
1917                 guint slot;
1918                 HandleData *handles = &gc_handles [type];
1919                 lock_handles (handles);
1920                 for (slot = 0; slot < handles->size; ++slot) {
1921                         if (!slot_occupied (handles, slot))
1922                                 continue;
1923                         if (MONO_GC_HANDLE_TYPE_IS_WEAK (type)) {
1924                                 if (domain->domain_id == handles->domain_ids [slot]) {
1925                                         vacate_slot (handles, slot);
1926                                         if (handles->entries [slot])
1927                                                 mono_gc_weak_link_remove (&handles->entries [slot], handles->type == HANDLE_WEAK_TRACK);
1928                                 }
1929                         } else {
1930                                 if (handles->entries [slot] && mono_object_domain (handles->entries [slot]) == domain) {
1931                                         vacate_slot (handles, slot);
1932                                         handles->entries [slot] = NULL;
1933                                 }
1934                         }
1935                 }
1936                 unlock_handles (handles);
1937         }
1938
1939 }
1940 #else
1941
1942 MONO_EMPTY_SOURCE_FILE (boehm_gc);
1943 #endif /* no Boehm GC */