mono/metadata/boehm-gc.c

   1 /*
   2  * boehm-gc.c: GC implementation using either the installed or included Boehm GC.
   3  *
   4  * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
   5  * Copyright 2004-2011 Novell, Inc (http://www.novell.com)
   6  * Copyright 2011-2012 Xamarin, Inc (http://www.xamarin.com)
   7  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
   8  */
   9
  10 #include "config.h"
  11
  12 #include <string.h>
  13
  14 #define GC_I_HIDE_POINTERS
  15 #include <mono/metadata/gc-internals.h>
  16 #include <mono/metadata/mono-gc.h>
  17 #include <mono/metadata/profiler-private.h>
  18 #include <mono/metadata/class-internals.h>
  19 #include <mono/metadata/method-builder.h>
  20 #include <mono/metadata/opcodes.h>
  21 #include <mono/metadata/domain-internals.h>
  22 #include <mono/metadata/metadata-internals.h>
  23 #include <mono/metadata/marshal.h>
  24 #include <mono/metadata/runtime.h>
  25 #include <mono/metadata/handle.h>
  26 #include <mono/metadata/sgen-toggleref.h>
  27 #include <mono/utils/atomic.h>
  28 #include <mono/utils/mono-logger-internals.h>
  29 #include <mono/utils/mono-memory-model.h>
  30 #include <mono/utils/mono-time.h>
  31 #include <mono/utils/mono-threads.h>
  32 #include <mono/utils/dtrace.h>
  33 #include <mono/utils/gc_wrapper.h>
  34 #include <mono/utils/mono-os-mutex.h>
  35 #include <mono/utils/mono-counters.h>
  36
  37 #if HAVE_BOEHM_GC
  38
  39 #undef TRUE
  40 #undef FALSE
  41 #define THREAD_LOCAL_ALLOC 1
  42 #include "private/pthread_support.h"
  43
  44 #if defined(PLATFORM_MACOSX) && defined(HAVE_PTHREAD_GET_STACKADDR_NP)
  45 void *pthread_get_stackaddr_np(pthread_t);
  46 #endif
  47
  48 #define GC_NO_DESCRIPTOR ((gpointer)(0 | GC_DS_LENGTH))
  49 /*Boehm max heap cannot be smaller than 16MB*/
  50 #define MIN_BOEHM_MAX_HEAP_SIZE_IN_MB 16
  51 #define MIN_BOEHM_MAX_HEAP_SIZE (MIN_BOEHM_MAX_HEAP_SIZE_IN_MB << 20)
  52
  53 static gboolean gc_initialized = FALSE;
  54 static mono_mutex_t mono_gc_lock;
  55
  56 static void*
  57 boehm_thread_register (MonoThreadInfo* info, void *baseptr);
  58 static void
  59 boehm_thread_unregister (MonoThreadInfo *p);
  60 static void
  61 boehm_thread_detach (MonoThreadInfo *p);
  62 static void
  63 register_test_toggleref_callback (void);
  64
  65 #define BOEHM_GC_BIT_FINALIZER_AWARE 1
  66 static MonoGCFinalizerCallbacks fin_callbacks;
  67
  68 /* GC Handles */
  69
  70 static mono_mutex_t handle_section;
  71 #define lock_handles(handles) mono_os_mutex_lock (&handle_section)
  72 #define unlock_handles(handles) mono_os_mutex_unlock (&handle_section)
  73
  74 typedef struct {
  75         guint32  *bitmap;
  76         gpointer *entries;
  77         guint32   size;
  78         guint8    type;
  79         guint     slot_hint : 24; /* starting slot for search in bitmap */
  80         /* 2^16 appdomains should be enough for everyone (though I know I'll regret this in 20 years) */
  81         /* we alloc this only for weak refs, since we can get the domain directly in the other cases */
  82         guint16  *domain_ids;
  83 } HandleData;
  84
  85 #define EMPTY_HANDLE_DATA(type) {NULL, NULL, 0, (type), 0, NULL}
  86
  87 /* weak and weak-track arrays will be allocated in malloc memory
  88  */
  89 static HandleData gc_handles [] = {
  90         EMPTY_HANDLE_DATA (HANDLE_WEAK),
  91         EMPTY_HANDLE_DATA (HANDLE_WEAK_TRACK),
  92         EMPTY_HANDLE_DATA (HANDLE_NORMAL),
  93         EMPTY_HANDLE_DATA (HANDLE_PINNED)
  94 };
  95
  96 static void
  97 mono_gc_warning (char *msg, GC_word arg)
  98 {
  99         mono_trace (G_LOG_LEVEL_WARNING, MONO_TRACE_GC, msg, (unsigned long)arg);
 100 }
 101
 102 static void on_gc_notification (GC_EventType event);
 103 static void on_gc_heap_resize (size_t new_size);
 104
 105 void
 106 mono_gc_base_init (void)
 107 {
 108         MonoThreadInfoCallbacks cb;
 109         const char *env;
 110         int dummy;
 111
 112         if (gc_initialized)
 113                 return;
 114
 115         mono_counters_init ();
 116
 117 #ifndef HOST_WIN32
 118         mono_w32handle_init ();
 119 #endif
 120
 121         /*
 122          * Handle the case when we are called from a thread different from the main thread,
 123          * confusing libgc.
 124          * FIXME: Move this to libgc where it belongs.
 125          *
 126          * we used to do this only when running on valgrind,
 127          * but it happens also in other setups.
 128          */
 129 #if defined(HAVE_PTHREAD_GETATTR_NP) && defined(HAVE_PTHREAD_ATTR_GETSTACK) && !defined(__native_client__)
 130         {
 131                 size_t size;
 132                 void *sstart;
 133                 pthread_attr_t attr;
 134                 pthread_getattr_np (pthread_self (), &attr);
 135                 pthread_attr_getstack (&attr, &sstart, &size);
 136                 pthread_attr_destroy (&attr);
 137                 /*g_print ("stackbottom pth is: %p\n", (char*)sstart + size);*/
 138 #ifdef __ia64__
 139                 /*
 140                  * The calculation above doesn't seem to work on ia64, also we need to set
 141                  * GC_register_stackbottom as well, but don't know how.
 142                  */
 143 #else
 144                 /* apparently with some linuxthreads implementations sstart can be NULL,
 145                  * fallback to the more imprecise method (bug# 78096).
 146                  */
 147                 if (sstart) {
 148                         GC_stackbottom = (char*)sstart + size;
 149                 } else {
 150                         int dummy;
 151                         gsize stack_bottom = (gsize)&dummy;
 152                         stack_bottom += 4095;
 153                         stack_bottom &= ~4095;
 154                         GC_stackbottom = (char*)stack_bottom;
 155                 }
 156 #endif
 157         }
 158 #elif defined(HAVE_PTHREAD_GET_STACKSIZE_NP) && defined(HAVE_PTHREAD_GET_STACKADDR_NP)
 159                 GC_stackbottom = (char*)pthread_get_stackaddr_np (pthread_self ());
 160 #elif defined(__OpenBSD__)
 161 #  include <pthread_np.h>
 162         {
 163                 stack_t ss;
 164                 int rslt;
 165
 166                 rslt = pthread_stackseg_np(pthread_self(), &ss);
 167                 g_assert (rslt == 0);
 168
 169                 GC_stackbottom = (char*)ss.ss_sp;
 170         }
 171 #elif defined(__native_client__)
 172         /* Do nothing, GC_stackbottom is set correctly in libgc */
 173 #else
 174         {
 175                 int dummy;
 176                 gsize stack_bottom = (gsize)&dummy;
 177                 stack_bottom += 4095;
 178                 stack_bottom &= ~4095;
 179                 /*g_print ("stackbottom is: %p\n", (char*)stack_bottom);*/
 180                 GC_stackbottom = (char*)stack_bottom;
 181         }
 182 #endif
 183
 184 #if !defined(PLATFORM_ANDROID)
 185         /* If GC_no_dls is set to true, GC_find_limit is not called. This causes a seg fault on Android. */
 186         GC_no_dls = TRUE;
 187 #endif
 188         {
 189                 if ((env = g_getenv ("MONO_GC_DEBUG"))) {
 190                         char **opts = g_strsplit (env, ",", -1);
 191                         for (char **ptr = opts; ptr && *ptr; ptr ++) {
 192                                 char *opt = *ptr;
 193                                 if (!strcmp (opt, "do-not-finalize")) {
 194                                         mono_do_not_finalize = 1;
 195                                 } else if (!strcmp (opt, "log-finalizers")) {
 196                                         log_finalizers = 1;
 197                                 }
 198                         }
 199                 }
 200         }
 201
 202         GC_init ();
 203
 204         GC_set_warn_proc (mono_gc_warning);
 205         GC_finalize_on_demand = 1;
 206         GC_finalizer_notifier = mono_gc_finalize_notify;
 207
 208         GC_init_gcj_malloc (5, NULL);
 209         GC_allow_register_threads ();
 210
 211         if ((env = g_getenv ("MONO_GC_PARAMS"))) {
 212                 char **ptr, **opts = g_strsplit (env, ",", -1);
 213                 for (ptr = opts; *ptr; ++ptr) {
 214                         char *opt = *ptr;
 215                         if (g_str_has_prefix (opt, "max-heap-size=")) {
 216                                 size_t max_heap;
 217
 218                                 opt = strchr (opt, '=') + 1;
 219                                 if (*opt && mono_gc_parse_environment_string_extract_number (opt, &max_heap)) {
 220                                         if (max_heap < MIN_BOEHM_MAX_HEAP_SIZE) {
 221                                                 fprintf (stderr, "max-heap-size must be at least %dMb.\n", MIN_BOEHM_MAX_HEAP_SIZE_IN_MB);
 222                                                 exit (1);
 223                                         }
 224                                         GC_set_max_heap_size (max_heap);
 225                                 } else {
 226                                         fprintf (stderr, "max-heap-size must be an integer.\n");
 227                                         exit (1);
 228                                 }
 229                                 continue;
 230                         } else if (g_str_has_prefix (opt, "toggleref-test")) {
 231                                 register_test_toggleref_callback ();
 232                                 continue;
 233                         } else {
 234                                 /* Could be a parameter for sgen */
 235                                 /*
 236                                 fprintf (stderr, "MONO_GC_PARAMS must be a comma-delimited list of one or more of the following:\n");
 237                                 fprintf (stderr, "  max-heap-size=N (where N is an integer, possibly with a k, m or a g suffix)\n");
 238                                 exit (1);
 239                                 */
 240                         }
 241                 }
 242                 g_strfreev (opts);
 243         }
 244
 245         memset (&cb, 0, sizeof (cb));
 246         cb.thread_register = boehm_thread_register;
 247         cb.thread_unregister = boehm_thread_unregister;
 248         cb.thread_detach = boehm_thread_detach;
 249         cb.mono_method_is_critical = (gboolean (*)(void *))mono_runtime_is_critical_method;
 250
 251         mono_threads_init (&cb, sizeof (MonoThreadInfo));
 252         mono_os_mutex_init (&mono_gc_lock);
 253         mono_os_mutex_init_recursive (&handle_section);
 254
 255         mono_thread_info_attach (&dummy);
 256
 257         GC_set_on_collection_event (on_gc_notification);
 258         GC_on_heap_resize = on_gc_heap_resize;
 259
 260         MONO_GC_REGISTER_ROOT_FIXED (gc_handles [HANDLE_NORMAL].entries, MONO_ROOT_SOURCE_GC_HANDLE, "gc handles table");
 261         MONO_GC_REGISTER_ROOT_FIXED (gc_handles [HANDLE_PINNED].entries, MONO_ROOT_SOURCE_GC_HANDLE, "gc handles table");
 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  * @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 @generation can be retrieved with a call to
 280  * mono_gc_max_generation(), so this function is usually called as:
 281  *
 282  *      mono_gc_collect (mono_gc_max_generation ());
 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  * @object: a managed object
 311  *
 312  * Get the garbage collector's generation that @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  * @generation: a GC generation number
 326  *
 327  * Get how many times a garbage collection has been performed
 328  * for the given @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  * @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 @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 void
 540 mono_gc_deregister_root (char* addr)
 541 {
 542 #ifndef HOST_WIN32
 543         /* FIXME: libgc doesn't define this work win32 for some reason */
 544         /* FIXME: No size info */
 545         GC_remove_roots (addr, addr + sizeof (gpointer) + 1);
 546 #endif
 547 }
 548
 549 static void
 550 mono_gc_weak_link_add (void **link_addr, MonoObject *obj, gboolean track)
 551 {
 552         /* libgc requires that we use HIDE_POINTER... */
 553         *link_addr = (void*)HIDE_POINTER (obj);
 554         if (track)
 555                 GC_REGISTER_LONG_LINK (link_addr, obj);
 556         else
 557                 GC_GENERAL_REGISTER_DISAPPEARING_LINK (link_addr, obj);
 558 }
 559
 560 static void
 561 mono_gc_weak_link_remove (void **link_addr, gboolean track)
 562 {
 563         if (track)
 564                 GC_unregister_long_link (link_addr);
 565         else
 566                 GC_unregister_disappearing_link (link_addr);
 567         *link_addr = NULL;
 568 }
 569
 570 static gpointer
 571 reveal_link (gpointer link_addr)
 572 {
 573         void **link_a = (void **)link_addr;
 574         return REVEAL_POINTER (*link_a);
 575 }
 576
 577 static MonoObject *
 578 mono_gc_weak_link_get (void **link_addr)
 579 {
 580         MonoObject *obj = (MonoObject *)GC_call_with_alloc_lock (reveal_link, link_addr);
 581         if (obj == (MonoObject *) -1)
 582                 return NULL;
 583         return obj;
 584 }
 585
 586 void*
 587 mono_gc_make_descr_for_string (gsize *bitmap, int numbits)
 588 {
 589         return mono_gc_make_descr_from_bitmap (bitmap, numbits);
 590 }
 591
 592 void*
 593 mono_gc_make_descr_for_object (gsize *bitmap, int numbits, size_t obj_size)
 594 {
 595         return mono_gc_make_descr_from_bitmap (bitmap, numbits);
 596 }
 597
 598 void*
 599 mono_gc_make_descr_for_array (int vector, gsize *elem_bitmap, int numbits, size_t elem_size)
 600 {
 601         /* libgc has no usable support for arrays... */
 602         return GC_NO_DESCRIPTOR;
 603 }
 604
 605 void*
 606 mono_gc_make_descr_from_bitmap (gsize *bitmap, int numbits)
 607 {
 608         /* It seems there are issues when the bitmap doesn't fit: play it safe */
 609         if (numbits >= 30)
 610                 return GC_NO_DESCRIPTOR;
 611         else
 612                 return (gpointer)GC_make_descriptor ((GC_bitmap)bitmap, numbits);
 613 }
 614
 615 void*
 616 mono_gc_make_root_descr_all_refs (int numbits)
 617 {
 618         return NULL;
 619 }
 620
 621 void*
 622 mono_gc_alloc_fixed (size_t size, void *descr, MonoGCRootSource source, const char *msg)
 623 {
 624         /* To help track down typed allocation bugs */
 625         /*
 626         static int count;
 627         count ++;
 628         if (count == atoi (g_getenv ("COUNT2")))
 629                 printf ("HIT!\n");
 630         if (count > atoi (g_getenv ("COUNT2")))
 631                 return GC_MALLOC (size);
 632         */
 633
 634         if (descr)
 635                 return GC_MALLOC_EXPLICITLY_TYPED (size, (GC_descr)descr);
 636         else
 637                 return GC_MALLOC (size);
 638 }
 639
 640 void
 641 mono_gc_free_fixed (void* addr)
 642 {
 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 MONO_TLS_FAST 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         if (atype == ATYPE_FREEPTR) {
 903                 name = slowpath ? "SlowAllocPtrfree" : "AllocPtrfree";
 904         } else if (atype == ATYPE_FREEPTR_FOR_BOX) {
 905                 name = slowpath ? "SlowAllocPtrfreeBox" : "AllocPtrfreeBox";
 906         } else if (atype == ATYPE_NORMAL) {
 907                 name = slowpath ? "SlowAlloc" : "Alloc";
 908         } else if (atype == ATYPE_GCJ) {
 909                 name = slowpath ? "SlowAllocGcj" : "AllocGcj";
 910         } else if (atype == ATYPE_STRING) {
 911                 name = slowpath ? "SlowAllocString" : "AllocString";
 912         } else {
 913                 g_assert_not_reached ();
 914         }
 915
 916         csig = mono_metadata_signature_alloc (mono_defaults.corlib, 2);
 917
 918         if (atype == ATYPE_STRING) {
 919                 csig->ret = &mono_defaults.string_class->byval_arg;
 920                 csig->params [0] = &mono_defaults.int_class->byval_arg;
 921                 csig->params [1] = &mono_defaults.int32_class->byval_arg;
 922         } else {
 923                 csig->ret = &mono_defaults.object_class->byval_arg;
 924                 csig->params [0] = &mono_defaults.int_class->byval_arg;
 925                 csig->params [1] = &mono_defaults.int32_class->byval_arg;
 926         }
 927
 928         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_ALLOC);
 929
 930         if (slowpath)
 931                 goto always_slowpath;
 932
 933         bytes_var = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
 934         if (atype == ATYPE_STRING) {
 935                 /* a string alloator method takes the args: (vtable, len) */
 936                 /* bytes = (offsetof (MonoString, chars) + ((len + 1) * 2)); */
 937                 mono_mb_emit_ldarg (mb, 1);
 938                 mono_mb_emit_icon (mb, 1);
 939                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
 940                 mono_mb_emit_icon (mb, 1);
 941                 mono_mb_emit_byte (mb, MONO_CEE_SHL);
 942                 // sizeof (MonoString) might include padding
 943                 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoString, chars));
 944                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
 945                 mono_mb_emit_stloc (mb, bytes_var);
 946         } else {
 947                 mono_mb_emit_ldarg (mb, 1);
 948                 mono_mb_emit_stloc (mb, bytes_var);
 949         }
 950
 951         /* this is needed for strings/arrays only as the other big types are never allocated with this method */
 952         if (atype == ATYPE_STRING) {
 953                 /* check for size */
 954                 /* if (!SMALL_ENOUGH (bytes)) jump slow_path;*/
 955                 mono_mb_emit_ldloc (mb, bytes_var);
 956                 mono_mb_emit_icon (mb, (NFREELISTS-1) * GRANULARITY);
 957                 not_small_enough_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BGT_UN_S);
 958                 /* check for overflow */
 959                 mono_mb_emit_ldloc (mb, bytes_var);
 960                 mono_mb_emit_icon (mb, sizeof (MonoString));
 961                 size_overflow_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BLE_UN_S);
 962         }
 963
 964         /* int index = INDEX_FROM_BYTES(bytes); */
 965         index_var = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg);
 966
 967         mono_mb_emit_ldloc (mb, bytes_var);
 968         mono_mb_emit_icon (mb, GRANULARITY - 1);
 969         mono_mb_emit_byte (mb, MONO_CEE_ADD);
 970         mono_mb_emit_icon (mb, shift_amount (GRANULARITY));
 971         mono_mb_emit_byte (mb, MONO_CEE_SHR_UN);
 972         mono_mb_emit_icon (mb, shift_amount (sizeof (gpointer)));
 973         mono_mb_emit_byte (mb, MONO_CEE_SHL);
 974         /* index var is already adjusted into bytes */
 975         mono_mb_emit_stloc (mb, index_var);
 976
 977         my_fl_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
 978         my_entry_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
 979         /* my_fl = ((GC_thread)tsd) -> ptrfree_freelists + index; */
 980         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
 981         mono_mb_emit_byte (mb, 0x0D); /* CEE_MONO_TLS */
 982         mono_mb_emit_i4 (mb, tls_key);
 983         if (atype == ATYPE_FREEPTR || atype == ATYPE_FREEPTR_FOR_BOX || atype == ATYPE_STRING)
 984                 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (struct GC_Thread_Rep, tlfs)
 985                                         + G_STRUCT_OFFSET (struct thread_local_freelists,
 986                                                            ptrfree_freelists));
 987         else if (atype == ATYPE_NORMAL)
 988                 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (struct GC_Thread_Rep, tlfs)
 989                                         + G_STRUCT_OFFSET (struct thread_local_freelists,
 990                                                            normal_freelists));
 991         else if (atype == ATYPE_GCJ)
 992                 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (struct GC_Thread_Rep, tlfs)
 993                                         + G_STRUCT_OFFSET (struct thread_local_freelists,
 994                                                            gcj_freelists));
 995         else
 996                 g_assert_not_reached ();
 997         mono_mb_emit_byte (mb, MONO_CEE_ADD);
 998         mono_mb_emit_ldloc (mb, index_var);
 999         mono_mb_emit_byte (mb, MONO_CEE_ADD);
1000         mono_mb_emit_stloc (mb, my_fl_var);
1001
1002         /* my_entry = *my_fl; */
1003         mono_mb_emit_ldloc (mb, my_fl_var);
1004         mono_mb_emit_byte (mb, MONO_CEE_LDIND_I);
1005         mono_mb_emit_stloc (mb, my_entry_var);
1006
1007         /* if (EXPECT((word)my_entry >= HBLKSIZE, 1)) { */
1008         mono_mb_emit_ldloc (mb, my_entry_var);
1009         mono_mb_emit_icon (mb, HBLKSIZE);
1010         no_freelist_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BLT_UN_S);
1011
1012         /* ptr_t next = obj_link(my_entry); *my_fl = next; */
1013         mono_mb_emit_ldloc (mb, my_fl_var);
1014         mono_mb_emit_ldloc (mb, my_entry_var);
1015         mono_mb_emit_byte (mb, MONO_CEE_LDIND_I);
1016         mono_mb_emit_byte (mb, MONO_CEE_STIND_I);
1017
1018         /* set the vtable and clear the words in the object */
1019         mono_mb_emit_ldloc (mb, my_entry_var);
1020         mono_mb_emit_ldarg (mb, 0);
1021         mono_mb_emit_byte (mb, MONO_CEE_STIND_I);
1022
1023         if (atype == ATYPE_FREEPTR) {
1024                 int start_var, end_var, start_loop;
1025                 /* end = my_entry + bytes; start = my_entry + sizeof (gpointer);
1026                  */
1027                 start_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1028                 end_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1029                 mono_mb_emit_ldloc (mb, my_entry_var);
1030                 mono_mb_emit_ldloc (mb, bytes_var);
1031                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
1032                 mono_mb_emit_stloc (mb, end_var);
1033                 mono_mb_emit_ldloc (mb, my_entry_var);
1034                 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoObject, synchronisation));
1035                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
1036                 mono_mb_emit_stloc (mb, start_var);
1037                 /*
1038                  * do {
1039                  *      *start++ = NULL;
1040                  * } while (start < end);
1041                  */
1042                 start_loop = mono_mb_get_label (mb);
1043                 mono_mb_emit_ldloc (mb, start_var);
1044                 mono_mb_emit_icon (mb, 0);
1045                 mono_mb_emit_byte (mb, MONO_CEE_STIND_I);
1046                 mono_mb_emit_ldloc (mb, start_var);
1047                 mono_mb_emit_icon (mb, sizeof (gpointer));
1048                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
1049                 mono_mb_emit_stloc (mb, start_var);
1050
1051                 mono_mb_emit_ldloc (mb, start_var);
1052                 mono_mb_emit_ldloc (mb, end_var);
1053                 mono_mb_emit_byte (mb, MONO_CEE_BLT_UN_S);
1054                 mono_mb_emit_byte (mb, start_loop - (mono_mb_get_label (mb) + 1));
1055         } else if (atype == ATYPE_FREEPTR_FOR_BOX || atype == ATYPE_STRING) {
1056                 /* need to clear just the sync pointer */
1057                 mono_mb_emit_ldloc (mb, my_entry_var);
1058                 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoObject, synchronisation));
1059                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
1060                 mono_mb_emit_icon (mb, 0);
1061                 mono_mb_emit_byte (mb, MONO_CEE_STIND_I);
1062         }
1063
1064         if (atype == ATYPE_STRING) {
1065                 /* need to set length and clear the last char */
1066                 /* s->length = len; */
1067                 mono_mb_emit_ldloc (mb, my_entry_var);
1068                 mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoString, length));
1069                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
1070                 mono_mb_emit_ldarg (mb, 1);
1071                 mono_mb_emit_byte (mb, MONO_CEE_STIND_I4);
1072                 /* s->chars [len] = 0; */
1073                 mono_mb_emit_ldloc (mb, my_entry_var);
1074                 mono_mb_emit_ldloc (mb, bytes_var);
1075                 mono_mb_emit_icon (mb, 2);
1076                 mono_mb_emit_byte (mb, MONO_CEE_SUB);
1077                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
1078                 mono_mb_emit_icon (mb, 0);
1079                 mono_mb_emit_byte (mb, MONO_CEE_STIND_I2);
1080         }
1081
1082         /* return my_entry; */
1083         mono_mb_emit_ldloc (mb, my_entry_var);
1084         mono_mb_emit_byte (mb, MONO_CEE_RET);
1085
1086         mono_mb_patch_short_branch (mb, no_freelist_branch);
1087         if (not_small_enough_branch > 0)
1088                 mono_mb_patch_short_branch (mb, not_small_enough_branch);
1089         if (size_overflow_branch > 0)
1090                 mono_mb_patch_short_branch (mb, size_overflow_branch);
1091
1092         /* the slow path: we just call back into the runtime */
1093  always_slowpath:
1094         if (atype == ATYPE_STRING) {
1095                 mono_mb_emit_ldarg (mb, 1);
1096                 mono_mb_emit_icall (mb, ves_icall_string_alloc);
1097         } else {
1098                 mono_mb_emit_ldarg (mb, 0);
1099                 mono_mb_emit_icall (mb, ves_icall_object_new_specific);
1100         }
1101
1102         mono_mb_emit_byte (mb, MONO_CEE_RET);
1103
1104         info = mono_wrapper_info_create (mb, WRAPPER_SUBTYPE_NONE);
1105         info->d.alloc.gc_name = "boehm";
1106         info->d.alloc.alloc_type = atype;
1107         mb->init_locals = FALSE;
1108
1109         res = mono_mb_create (mb, csig, 8, info);
1110         mono_mb_free (mb);
1111
1112         return res;
1113 }
1114
1115 static MonoMethod* alloc_method_cache [ATYPE_NUM];
1116 static MonoMethod* slowpath_alloc_method_cache [ATYPE_NUM];
1117
1118 gboolean
1119 mono_gc_is_critical_method (MonoMethod *method)
1120 {
1121         int i;
1122
1123         for (i = 0; i < ATYPE_NUM; ++i)
1124                 if (method == alloc_method_cache [i] || method == slowpath_alloc_method_cache [i])
1125                         return TRUE;
1126
1127         return FALSE;
1128 }
1129
1130 /*
1131  * If possible, generate a managed method that can quickly allocate objects in class
1132  * @klass. The method will typically have an thread-local inline allocation sequence.
1133  * The signature of the called method is:
1134  *      object allocate (MonoVTable *vtable)
1135  * Some of the logic here is similar to mono_class_get_allocation_ftn () i object.c,
1136  * keep in sync.
1137  * The thread local alloc logic is taken from libgc/pthread_support.c.
1138  */
1139
1140 MonoMethod*
1141 mono_gc_get_managed_allocator (MonoClass *klass, gboolean for_box, gboolean known_instance_size)
1142 {
1143         int offset = -1;
1144         int atype;
1145         MONO_THREAD_VAR_OFFSET (GC_thread_tls, offset);
1146
1147         /*g_print ("thread tls: %d\n", offset);*/
1148         if (offset == -1)
1149                 return NULL;
1150         if (!SMALL_ENOUGH (klass->instance_size))
1151                 return NULL;
1152         if (mono_class_has_finalizer (klass) || mono_class_is_marshalbyref (klass))
1153                 return NULL;
1154         if (mono_profiler_get_events () & (MONO_PROFILE_ALLOCATIONS | MONO_PROFILE_STATISTICAL))
1155                 return NULL;
1156         if (klass->rank)
1157                 return NULL;
1158         if (mono_class_is_open_constructed_type (&klass->byval_arg))
1159                 return NULL;
1160         if (klass->byval_arg.type == MONO_TYPE_STRING) {
1161                 atype = ATYPE_STRING;
1162         } else if (!known_instance_size) {
1163                 return NULL;
1164         } else if (!klass->has_references) {
1165                 if (for_box)
1166                         atype = ATYPE_FREEPTR_FOR_BOX;
1167                 else
1168                         atype = ATYPE_FREEPTR;
1169         } else {
1170                 return NULL;
1171                 /*
1172                  * disabled because we currently do a runtime choice anyway, to
1173                  * deal with multiple appdomains.
1174                 if (vtable->gc_descr != GC_NO_DESCRIPTOR)
1175                         atype = ATYPE_GCJ;
1176                 else
1177                         atype = ATYPE_NORMAL;
1178                 */
1179         }
1180         return mono_gc_get_managed_allocator_by_type (atype, MANAGED_ALLOCATOR_REGULAR);
1181 }
1182
1183 MonoMethod*
1184 mono_gc_get_managed_array_allocator (MonoClass *klass)
1185 {
1186         return NULL;
1187 }
1188
1189 /**
1190  * mono_gc_get_managed_allocator_by_type:
1191  *
1192  *   Return a managed allocator method corresponding to allocator type ATYPE.
1193  */
1194 MonoMethod*
1195 mono_gc_get_managed_allocator_by_type (int atype, ManagedAllocatorVariant variant)
1196 {
1197         int offset = -1;
1198         MonoMethod *res;
1199         gboolean slowpath = variant != MANAGED_ALLOCATOR_REGULAR;
1200         MonoMethod **cache = slowpath ? slowpath_alloc_method_cache : alloc_method_cache;
1201         MONO_THREAD_VAR_OFFSET (GC_thread_tls, offset);
1202
1203         mono_tls_key_set_offset (TLS_KEY_BOEHM_GC_THREAD, offset);
1204
1205         res = cache [atype];
1206         if (res)
1207                 return res;
1208
1209         res = create_allocator (atype, TLS_KEY_BOEHM_GC_THREAD, slowpath);
1210         mono_os_mutex_lock (&mono_gc_lock);
1211         if (cache [atype]) {
1212                 mono_free_method (res);
1213                 res = cache [atype];
1214         } else {
1215                 mono_memory_barrier ();
1216                 cache [atype] = res;
1217         }
1218         mono_os_mutex_unlock (&mono_gc_lock);
1219         return res;
1220 }
1221
1222 guint32
1223 mono_gc_get_managed_allocator_types (void)
1224 {
1225         return ATYPE_NUM;
1226 }
1227
1228 MonoMethod*
1229 mono_gc_get_write_barrier (void)
1230 {
1231         g_assert_not_reached ();
1232         return NULL;
1233 }
1234
1235 #else
1236
1237 gboolean
1238 mono_gc_is_critical_method (MonoMethod *method)
1239 {
1240         return FALSE;
1241 }
1242
1243 MonoMethod*
1244 mono_gc_get_managed_allocator (MonoClass *klass, gboolean for_box, gboolean known_instance_size)
1245 {
1246         return NULL;
1247 }
1248
1249 MonoMethod*
1250 mono_gc_get_managed_array_allocator (MonoClass *klass)
1251 {
1252         return NULL;
1253 }
1254
1255 MonoMethod*
1256 mono_gc_get_managed_allocator_by_type (int atype, ManagedAllocatorVariant variant)
1257 {
1258         return NULL;
1259 }
1260
1261 guint32
1262 mono_gc_get_managed_allocator_types (void)
1263 {
1264         return 0;
1265 }
1266
1267 MonoMethod*
1268 mono_gc_get_write_barrier (void)
1269 {
1270         g_assert_not_reached ();
1271         return NULL;
1272 }
1273
1274 #endif
1275
1276 MonoMethod*
1277 mono_gc_get_specific_write_barrier (gboolean is_concurrent)
1278 {
1279         g_assert_not_reached ();
1280         return NULL;
1281 }
1282
1283 int
1284 mono_gc_get_aligned_size_for_allocator (int size)
1285 {
1286         return size;
1287 }
1288
1289 const char *
1290 mono_gc_get_gc_name (void)
1291 {
1292         return "boehm";
1293 }
1294
1295 void*
1296 mono_gc_invoke_with_gc_lock (MonoGCLockedCallbackFunc func, void *data)
1297 {
1298         return GC_call_with_alloc_lock (func, data);
1299 }
1300
1301 char*
1302 mono_gc_get_description (void)
1303 {
1304         return g_strdup (DEFAULT_GC_NAME);
1305 }
1306
1307 void
1308 mono_gc_set_desktop_mode (void)
1309 {
1310         GC_dont_expand = 1;
1311 }
1312
1313 gboolean
1314 mono_gc_is_moving (void)
1315 {
1316         return FALSE;
1317 }
1318
1319 gboolean
1320 mono_gc_is_disabled (void)
1321 {
1322         if (GC_dont_gc || g_getenv ("GC_DONT_GC"))
1323                 return TRUE;
1324         else
1325                 return FALSE;
1326 }
1327
1328 void
1329 mono_gc_wbarrier_value_copy_bitmap (gpointer _dest, gpointer _src, int size, unsigned bitmap)
1330 {
1331         g_assert_not_reached ();
1332 }
1333
1334
1335 guint8*
1336 mono_gc_get_card_table (int *shift_bits, gpointer *card_mask)
1337 {
1338         g_assert_not_reached ();
1339         return NULL;
1340 }
1341
1342 gboolean
1343 mono_gc_card_table_nursery_check (void)
1344 {
1345         g_assert_not_reached ();
1346         return TRUE;
1347 }
1348
1349 void*
1350 mono_gc_get_nursery (int *shift_bits, size_t *size)
1351 {
1352         return NULL;
1353 }
1354
1355 gboolean
1356 mono_gc_precise_stack_mark_enabled (void)
1357 {
1358         return FALSE;
1359 }
1360
1361 FILE *
1362 mono_gc_get_logfile (void)
1363 {
1364         return NULL;
1365 }
1366
1367 void
1368 mono_gc_params_set (const char* options)
1369 {
1370 }
1371
1372 void
1373 mono_gc_debug_set (const char* options)
1374 {
1375 }
1376
1377 void
1378 mono_gc_conservatively_scan_area (void *start, void *end)
1379 {
1380         g_assert_not_reached ();
1381 }
1382
1383 void *
1384 mono_gc_scan_object (void *obj, void *gc_data)
1385 {
1386         g_assert_not_reached ();
1387         return NULL;
1388 }
1389
1390 gsize*
1391 mono_gc_get_bitmap_for_descr (void *descr, int *numbits)
1392 {
1393         g_assert_not_reached ();
1394         return NULL;
1395 }
1396
1397 void
1398 mono_gc_set_gc_callbacks (MonoGCCallbacks *callbacks)
1399 {
1400 }
1401
1402 void
1403 mono_gc_set_stack_end (void *stack_end)
1404 {
1405 }
1406
1407 void mono_gc_set_skip_thread (gboolean value)
1408 {
1409 }
1410
1411 void
1412 mono_gc_register_for_finalization (MonoObject *obj, void *user_data)
1413 {
1414         guint offset = 0;
1415
1416 #ifndef GC_DEBUG
1417         /* This assertion is not valid when GC_DEBUG is defined */
1418         g_assert (GC_base (obj) == (char*)obj - offset);
1419 #endif
1420
1421         GC_REGISTER_FINALIZER_NO_ORDER ((char*)obj - offset, (GC_finalization_proc)user_data, GUINT_TO_POINTER (offset), NULL, NULL);
1422 }
1423
1424 #ifndef HOST_WIN32
1425 int
1426 mono_gc_pthread_create (pthread_t *new_thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
1427 {
1428         /* it is being replaced by GC_pthread_create on some
1429          * platforms, see libgc/include/gc_pthread_redirects.h */
1430         return pthread_create (new_thread, attr, start_routine, arg);
1431 }
1432 #endif
1433
1434 #ifdef HOST_WIN32
1435 BOOL APIENTRY mono_gc_dllmain (HMODULE module_handle, DWORD reason, LPVOID reserved)
1436 {
1437         return GC_DllMain (module_handle, reason, reserved);
1438 }
1439 #endif
1440
1441 guint
1442 mono_gc_get_vtable_bits (MonoClass *klass)
1443 {
1444         if (fin_callbacks.is_class_finalization_aware) {
1445                 if (fin_callbacks.is_class_finalization_aware (klass))
1446                         return BOEHM_GC_BIT_FINALIZER_AWARE;
1447         }
1448         return 0;
1449 }
1450
1451 /*
1452  * mono_gc_register_altstack:
1453  *
1454  *   Register the dimensions of the normal stack and altstack with the collector.
1455  * Currently, STACK/STACK_SIZE is only used when the thread is suspended while it is on an altstack.
1456  */
1457 void
1458 mono_gc_register_altstack (gpointer stack, gint32 stack_size, gpointer altstack, gint32 altstack_size)
1459 {
1460         GC_register_altstack (stack, stack_size, altstack, altstack_size);
1461 }
1462
1463 int
1464 mono_gc_get_los_limit (void)
1465 {
1466         return G_MAXINT;
1467 }
1468
1469 void
1470 mono_gc_set_string_length (MonoString *str, gint32 new_length)
1471 {
1472         mono_unichar2 *new_end = str->chars + new_length;
1473
1474         /* zero the discarded string. This null-delimits the string and allows
1475          * the space to be reclaimed by SGen. */
1476
1477         memset (new_end, 0, (str->length - new_length + 1) * sizeof (mono_unichar2));
1478         str->length = new_length;
1479 }
1480
1481 gboolean
1482 mono_gc_user_markers_supported (void)
1483 {
1484         return FALSE;
1485 }
1486
1487 void *
1488 mono_gc_make_root_descr_user (MonoGCRootMarkFunc marker)
1489 {
1490         g_assert_not_reached ();
1491         return NULL;
1492 }
1493
1494 /* Toggleref support */
1495
1496 void
1497 mono_gc_toggleref_add (MonoObject *object, mono_bool strong_ref)
1498 {
1499         if (GC_toggleref_add ((GC_PTR)object, (int)strong_ref) != GC_SUCCESS)
1500             g_error ("GC_toggleref_add failed\n");
1501 }
1502
1503 void
1504 mono_gc_toggleref_register_callback (MonoToggleRefStatus (*proccess_toggleref) (MonoObject *obj))
1505 {
1506         GC_set_toggleref_func ((GC_ToggleRefStatus (*) (GC_PTR obj)) proccess_toggleref);
1507 }
1508
1509 /* Test support code */
1510
1511 static MonoToggleRefStatus
1512 test_toggleref_callback (MonoObject *obj)
1513 {
1514         static MonoClassField *mono_toggleref_test_field;
1515         MonoToggleRefStatus status = MONO_TOGGLE_REF_DROP;
1516
1517         if (!mono_toggleref_test_field) {
1518                 mono_toggleref_test_field = mono_class_get_field_from_name (mono_object_get_class (obj), "__test");
1519                 g_assert (mono_toggleref_test_field);
1520         }
1521
1522         mono_field_get_value (obj, mono_toggleref_test_field, &status);
1523         printf ("toggleref-cb obj %d\n", status);
1524         return status;
1525 }
1526
1527 static void
1528 register_test_toggleref_callback (void)
1529 {
1530         mono_gc_toggleref_register_callback (test_toggleref_callback);
1531 }
1532
1533 static gboolean
1534 is_finalization_aware (MonoObject *obj)
1535 {
1536         MonoVTable *vt = obj->vtable;
1537         return (vt->gc_bits & BOEHM_GC_BIT_FINALIZER_AWARE) == BOEHM_GC_BIT_FINALIZER_AWARE;
1538 }
1539
1540 static void
1541 fin_notifier (MonoObject *obj)
1542 {
1543         if (is_finalization_aware (obj))
1544                 fin_callbacks.object_queued_for_finalization (obj);
1545 }
1546
1547 void
1548 mono_gc_register_finalizer_callbacks (MonoGCFinalizerCallbacks *callbacks)
1549 {
1550         if (callbacks->version != MONO_GC_FINALIZER_EXTENSION_VERSION)
1551                 g_error ("Invalid finalizer callback version. Expected %d but got %d\n", MONO_GC_FINALIZER_EXTENSION_VERSION, callbacks->version);
1552
1553         fin_callbacks = *callbacks;
1554
1555         GC_set_await_finalize_proc ((void (*) (GC_PTR))fin_notifier);
1556 }
1557
1558 #define BITMAP_SIZE (sizeof (*((HandleData *)NULL)->bitmap) * CHAR_BIT)
1559
1560 static inline gboolean
1561 slot_occupied (HandleData *handles, guint slot) {
1562         return handles->bitmap [slot / BITMAP_SIZE] & (1 << (slot % BITMAP_SIZE));
1563 }
1564
1565 static inline void
1566 vacate_slot (HandleData *handles, guint slot) {
1567         handles->bitmap [slot / BITMAP_SIZE] &= ~(1 << (slot % BITMAP_SIZE));
1568 }
1569
1570 static inline void
1571 occupy_slot (HandleData *handles, guint slot) {
1572         handles->bitmap [slot / BITMAP_SIZE] |= 1 << (slot % BITMAP_SIZE);
1573 }
1574
1575 static int
1576 find_first_unset (guint32 bitmap)
1577 {
1578         int i;
1579         for (i = 0; i < 32; ++i) {
1580                 if (!(bitmap & (1 << i)))
1581                         return i;
1582         }
1583         return -1;
1584 }
1585
1586 static void
1587 handle_data_alloc_entries (HandleData *handles)
1588 {
1589         handles->size = 32;
1590         if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
1591                 handles->entries = (void **)g_malloc0 (sizeof (*handles->entries) * handles->size);
1592                 handles->domain_ids = (guint16 *)g_malloc0 (sizeof (*handles->domain_ids) * handles->size);
1593         } else {
1594                 handles->entries = (void **)mono_gc_alloc_fixed (sizeof (*handles->entries) * handles->size, NULL, MONO_ROOT_SOURCE_GC_HANDLE, "gc handles table");
1595         }
1596         handles->bitmap = (guint32 *)g_malloc0 (handles->size / CHAR_BIT);
1597 }
1598
1599 static gint
1600 handle_data_next_unset (HandleData *handles)
1601 {
1602         gint slot;
1603         for (slot = handles->slot_hint; slot < handles->size / BITMAP_SIZE; ++slot) {
1604                 if (handles->bitmap [slot] == 0xffffffff)
1605                         continue;
1606                 handles->slot_hint = slot;
1607                 return find_first_unset (handles->bitmap [slot]);
1608         }
1609         return -1;
1610 }
1611
1612 static gint
1613 handle_data_first_unset (HandleData *handles)
1614 {
1615         gint slot;
1616         for (slot = 0; slot < handles->slot_hint; ++slot) {
1617                 if (handles->bitmap [slot] == 0xffffffff)
1618                         continue;
1619                 handles->slot_hint = slot;
1620                 return find_first_unset (handles->bitmap [slot]);
1621         }
1622         return -1;
1623 }
1624
1625 /* Returns the index of the current slot in the bitmap. */
1626 static void
1627 handle_data_grow (HandleData *handles, gboolean track)
1628 {
1629         guint32 *new_bitmap;
1630         guint32 new_size = handles->size * 2; /* always double: we memset to 0 based on this below */
1631
1632         /* resize and copy the bitmap */
1633         new_bitmap = (guint32 *)g_malloc0 (new_size / CHAR_BIT);
1634         memcpy (new_bitmap, handles->bitmap, handles->size / CHAR_BIT);
1635         g_free (handles->bitmap);
1636         handles->bitmap = new_bitmap;
1637
1638         /* resize and copy the entries */
1639         if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
1640                 gpointer *entries;
1641                 guint16 *domain_ids;
1642                 gint i;
1643                 domain_ids = (guint16 *)g_malloc0 (sizeof (*handles->domain_ids) * new_size);
1644                 entries = (void **)g_malloc0 (sizeof (*handles->entries) * new_size);
1645                 memcpy (domain_ids, handles->domain_ids, sizeof (*handles->domain_ids) * handles->size);
1646                 for (i = 0; i < handles->size; ++i) {
1647                         MonoObject *obj = mono_gc_weak_link_get (&(handles->entries [i]));
1648                         if (obj) {
1649                                 mono_gc_weak_link_add (&(entries [i]), obj, track);
1650                                 mono_gc_weak_link_remove (&(handles->entries [i]), track);
1651                         } else {
1652                                 g_assert (!handles->entries [i]);
1653                         }
1654                 }
1655                 g_free (handles->entries);
1656                 g_free (handles->domain_ids);
1657                 handles->entries = entries;
1658                 handles->domain_ids = domain_ids;
1659         } else {
1660                 gpointer *entries;
1661                 entries = (void **)mono_gc_alloc_fixed (sizeof (*handles->entries) * new_size, NULL, MONO_ROOT_SOURCE_GC_HANDLE, "gc handles table");
1662                 mono_gc_memmove_aligned (entries, handles->entries, sizeof (*handles->entries) * handles->size);
1663                 mono_gc_free_fixed (handles->entries);
1664                 handles->entries = entries;
1665         }
1666         handles->slot_hint = handles->size / BITMAP_SIZE;
1667         handles->size = new_size;
1668 }
1669
1670 static guint32
1671 alloc_handle (HandleData *handles, MonoObject *obj, gboolean track)
1672 {
1673         gint slot, i;
1674         guint32 res;
1675         lock_handles (handles);
1676         if (!handles->size)
1677                 handle_data_alloc_entries (handles);
1678         i = handle_data_next_unset (handles);
1679         if (i == -1 && handles->slot_hint != 0)
1680                 i = handle_data_first_unset (handles);
1681         if (i == -1) {
1682                 handle_data_grow (handles, track);
1683                 i = 0;
1684         }
1685         slot = handles->slot_hint * BITMAP_SIZE + i;
1686         occupy_slot (handles, slot);
1687         handles->entries [slot] = NULL;
1688         if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
1689                 /*FIXME, what to use when obj == null?*/
1690                 handles->domain_ids [slot] = (obj ? mono_object_get_domain (obj) : mono_domain_get ())->domain_id;
1691                 if (obj)
1692                         mono_gc_weak_link_add (&(handles->entries [slot]), obj, track);
1693         } else {
1694                 handles->entries [slot] = obj;
1695         }
1696
1697 #ifndef DISABLE_PERFCOUNTERS
1698         mono_perfcounters->gc_num_handles++;
1699 #endif
1700         unlock_handles (handles);
1701         res = MONO_GC_HANDLE (slot, handles->type);
1702         mono_profiler_gc_handle (MONO_PROFILER_GC_HANDLE_CREATED, handles->type, res, obj);
1703         return res;
1704 }
1705
1706 /**
1707  * mono_gchandle_new:
1708  * @obj: managed object to get a handle for
1709  * @pinned: whether the object should be pinned
1710  *
1711  * This returns a handle that wraps the object, this is used to keep a
1712  * reference to a managed object from the unmanaged world and preventing the
1713  * object from being disposed.
1714  *
1715  * If @pinned is false the address of the object can not be obtained, if it is
1716  * true the address of the object can be obtained.  This will also pin the
1717  * object so it will not be possible by a moving garbage collector to move the
1718  * object.
1719  *
1720  * Returns: a handle that can be used to access the object from
1721  * unmanaged code.
1722  */
1723 guint32
1724 mono_gchandle_new (MonoObject *obj, gboolean pinned)
1725 {
1726         return alloc_handle (&gc_handles [pinned? HANDLE_PINNED: HANDLE_NORMAL], obj, FALSE);
1727 }
1728
1729 /**
1730  * mono_gchandle_new_weakref:
1731  * @obj: managed object to get a handle for
1732  * @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.
1733  *
1734  * This returns a weak handle that wraps the object, this is used to
1735  * keep a reference to a managed object from the unmanaged world.
1736  * Unlike the mono_gchandle_new the object can be reclaimed by the
1737  * garbage collector.  In this case the value of the GCHandle will be
1738  * set to zero.
1739  *
1740  * If @track_resurrection is TRUE the object will be tracked through
1741  * finalization and if the object is resurrected during the execution
1742  * of the finalizer, then the returned weakref will continue to hold
1743  * a reference to the object.   If @track_resurrection is FALSE, then
1744  * the weak reference's target will become NULL as soon as the object
1745  * is passed on to the finalizer.
1746  *
1747  * Returns: a handle that can be used to access the object from
1748  * unmanaged code.
1749  */
1750 guint32
1751 mono_gchandle_new_weakref (MonoObject *obj, gboolean track_resurrection)
1752 {
1753         return alloc_handle (&gc_handles [track_resurrection? HANDLE_WEAK_TRACK: HANDLE_WEAK], obj, track_resurrection);
1754 }
1755
1756 /**
1757  * mono_gchandle_get_target:
1758  * @gchandle: a GCHandle's handle.
1759  *
1760  * The handle was previously created by calling `mono_gchandle_new` or
1761  * `mono_gchandle_new_weakref`.
1762  *
1763  * Returns: A pointer to the `MonoObject*` represented by the handle or
1764  * NULL for a collected object if using a weakref handle.
1765  */
1766 MonoObject*
1767 mono_gchandle_get_target (guint32 gchandle)
1768 {
1769         guint slot = MONO_GC_HANDLE_SLOT (gchandle);
1770         guint type = MONO_GC_HANDLE_TYPE (gchandle);
1771         HandleData *handles = &gc_handles [type];
1772         MonoObject *obj = NULL;
1773         if (type >= HANDLE_TYPE_MAX)
1774                 return NULL;
1775
1776         lock_handles (handles);
1777         if (slot < handles->size && slot_occupied (handles, slot)) {
1778                 if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
1779                         obj = mono_gc_weak_link_get (&handles->entries [slot]);
1780                 } else {
1781                         obj = (MonoObject *)handles->entries [slot];
1782                 }
1783         } else {
1784                 /* print a warning? */
1785         }
1786         unlock_handles (handles);
1787         /*g_print ("get target of entry %d of type %d: %p\n", slot, handles->type, obj);*/
1788         return obj;
1789 }
1790
1791 void
1792 mono_gchandle_set_target (guint32 gchandle, MonoObject *obj)
1793 {
1794         guint slot = MONO_GC_HANDLE_SLOT (gchandle);
1795         guint type = MONO_GC_HANDLE_TYPE (gchandle);
1796         HandleData *handles = &gc_handles [type];
1797         MonoObject *old_obj = NULL;
1798
1799         g_assert (type < HANDLE_TYPE_MAX);
1800         lock_handles (handles);
1801         if (slot < handles->size && slot_occupied (handles, slot)) {
1802                 if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
1803                         old_obj = (MonoObject *)handles->entries [slot];
1804                         if (handles->entries [slot])
1805                                 mono_gc_weak_link_remove (&handles->entries [slot], handles->type == HANDLE_WEAK_TRACK);
1806                         if (obj)
1807                                 mono_gc_weak_link_add (&handles->entries [slot], obj, handles->type == HANDLE_WEAK_TRACK);
1808                         /*FIXME, what to use when obj == null?*/
1809                         handles->domain_ids [slot] = (obj ? mono_object_get_domain (obj) : mono_domain_get ())->domain_id;
1810                 } else {
1811                         handles->entries [slot] = obj;
1812                 }
1813         } else {
1814                 /* print a warning? */
1815         }
1816         /*g_print ("changed entry %d of type %d to object %p (in slot: %p)\n", slot, handles->type, obj, handles->entries [slot]);*/
1817         unlock_handles (handles);
1818 }
1819
1820 gboolean
1821 mono_gc_is_null (void)
1822 {
1823         return FALSE;
1824 }
1825
1826 /**
1827  * mono_gchandle_is_in_domain:
1828  * @gchandle: a GCHandle's handle.
1829  * @domain: An application domain.
1830  *
1831  * Use this function to determine if the @gchandle points to an
1832  * object allocated in the specified @domain.
1833  *
1834  * Returns: TRUE if the object wrapped by the @gchandle belongs to the specific @domain.
1835  */
1836 gboolean
1837 mono_gchandle_is_in_domain (guint32 gchandle, MonoDomain *domain)
1838 {
1839         guint slot = MONO_GC_HANDLE_SLOT (gchandle);
1840         guint type = MONO_GC_HANDLE_TYPE (gchandle);
1841         HandleData *handles = &gc_handles [type];
1842         gboolean result = FALSE;
1843
1844         if (type >= HANDLE_TYPE_MAX)
1845                 return FALSE;
1846
1847         lock_handles (handles);
1848         if (slot < handles->size && slot_occupied (handles, slot)) {
1849                 if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
1850                         result = domain->domain_id == handles->domain_ids [slot];
1851                 } else {
1852                         MonoObject *obj;
1853                         obj = (MonoObject *)handles->entries [slot];
1854                         if (obj == NULL)
1855                                 result = TRUE;
1856                         else
1857                                 result = domain == mono_object_domain (obj);
1858                 }
1859         } else {
1860                 /* print a warning? */
1861         }
1862         unlock_handles (handles);
1863         return result;
1864 }
1865
1866 /**
1867  * mono_gchandle_free:
1868  * @gchandle: a GCHandle's handle.
1869  *
1870  * Frees the @gchandle handle.  If there are no outstanding
1871  * references, the garbage collector can reclaim the memory of the
1872  * object wrapped.
1873  */
1874 void
1875 mono_gchandle_free (guint32 gchandle)
1876 {
1877         guint slot = MONO_GC_HANDLE_SLOT (gchandle);
1878         guint type = MONO_GC_HANDLE_TYPE (gchandle);
1879         HandleData *handles = &gc_handles [type];
1880         if (type >= HANDLE_TYPE_MAX)
1881                 return;
1882
1883         lock_handles (handles);
1884         if (slot < handles->size && slot_occupied (handles, slot)) {
1885                 if (MONO_GC_HANDLE_TYPE_IS_WEAK (handles->type)) {
1886                         if (handles->entries [slot])
1887                                 mono_gc_weak_link_remove (&handles->entries [slot], handles->type == HANDLE_WEAK_TRACK);
1888                 } else {
1889                         handles->entries [slot] = NULL;
1890                 }
1891                 vacate_slot (handles, slot);
1892         } else {
1893                 /* print a warning? */
1894         }
1895 #ifndef DISABLE_PERFCOUNTERS
1896         mono_perfcounters->gc_num_handles--;
1897 #endif
1898         /*g_print ("freed entry %d of type %d\n", slot, handles->type);*/
1899         unlock_handles (handles);
1900         mono_profiler_gc_handle (MONO_PROFILER_GC_HANDLE_DESTROYED, handles->type, gchandle, NULL);
1901 }
1902
1903 /**
1904  * mono_gchandle_free_domain:
1905  * @domain: domain that is unloading
1906  *
1907  * Function used internally to cleanup any GC handle for objects belonging
1908  * to the specified domain during appdomain unload.
1909  */
1910 void
1911 mono_gchandle_free_domain (MonoDomain *domain)
1912 {
1913         guint type;
1914
1915         for (type = HANDLE_TYPE_MIN; type < HANDLE_PINNED; ++type) {
1916                 guint slot;
1917                 HandleData *handles = &gc_handles [type];
1918                 lock_handles (handles);
1919                 for (slot = 0; slot < handles->size; ++slot) {
1920                         if (!slot_occupied (handles, slot))
1921                                 continue;
1922                         if (MONO_GC_HANDLE_TYPE_IS_WEAK (type)) {
1923                                 if (domain->domain_id == handles->domain_ids [slot]) {
1924                                         vacate_slot (handles, slot);
1925                                         if (handles->entries [slot])
1926                                                 mono_gc_weak_link_remove (&handles->entries [slot], handles->type == HANDLE_WEAK_TRACK);
1927                                 }
1928                         } else {
1929                                 if (handles->entries [slot] && mono_object_domain (handles->entries [slot]) == domain) {
1930                                         vacate_slot (handles, slot);
1931                                         handles->entries [slot] = NULL;
1932                                 }
1933                         }
1934                 }
1935                 unlock_handles (handles);
1936         }
1937
1938 }
1939 #else
1940
1941 #ifdef _MSC_VER
1942 // Quiet Visual Studio linker warning, LNK4221, in cases when this source file intentional ends up empty.
1943 void __mono_win32_boehm_gc_quiet_lnk4221(void) {}
1944 #endif
1945 #endif /* no Boehm GC */