mono/metadata/sgen-mono.c

   1 /*
   2  * sgen-mono.c: SGen features specific to Mono.
   3  *
   4  * Copyright (C) 2014 Xamarin Inc
   5  *
   6  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
   7  */
   8
   9 #include "config.h"
  10 #ifdef HAVE_SGEN_GC
  11
  12 #include "sgen/sgen-gc.h"
  13 #include "sgen/sgen-protocol.h"
  14 #include "metadata/monitor.h"
  15 #include "sgen/sgen-layout-stats.h"
  16 #include "sgen/sgen-client.h"
  17 #include "sgen/sgen-cardtable.h"
  18 #include "sgen/sgen-pinning.h"
  19 #include "metadata/marshal.h"
  20 #include "metadata/method-builder.h"
  21 #include "metadata/abi-details.h"
  22 #include "metadata/mono-gc.h"
  23 #include "metadata/runtime.h"
  24 #include "metadata/sgen-bridge-internals.h"
  25 #include "metadata/gc-internals.h"
  26 #include "metadata/handle.h"
  27 #include "utils/mono-memory-model.h"
  28 #include "utils/mono-logger-internals.h"
  29 #include "utils/mono-threads-coop.h"
  30 #include "sgen/sgen-thread-pool.h"
  31
  32 #ifdef HEAVY_STATISTICS
  33 static guint64 stat_wbarrier_set_arrayref = 0;
  34 static guint64 stat_wbarrier_value_copy = 0;
  35 static guint64 stat_wbarrier_object_copy = 0;
  36
  37 static guint64 los_marked_cards;
  38 static guint64 los_array_cards;
  39 static guint64 los_array_remsets;
  40 #endif
  41
  42 /* If set, mark stacks conservatively, even if precise marking is possible */
  43 static gboolean conservative_stack_mark = FALSE;
  44 /* If set, check that there are no references to the domain left at domain unload */
  45 gboolean sgen_mono_xdomain_checks = FALSE;
  46
  47 /* Functions supplied by the runtime to be called by the GC */
  48 static MonoGCCallbacks gc_callbacks;
  49
  50 #ifdef HAVE_KW_THREAD
  51 __thread SgenThreadInfo *sgen_thread_info;
  52 #else
  53 MonoNativeTlsKey thread_info_key;
  54 #endif
  55
  56 #define ALIGN_TO(val,align) ((((guint64)val) + ((align) - 1)) & ~((align) - 1))
  57
  58 #define OPDEF(a,b,c,d,e,f,g,h,i,j) \
  59         a = i,
  60
  61 enum {
  62 #include "mono/cil/opcode.def"
  63         CEE_LAST
  64 };
  65
  66 #undef OPDEF
  67
  68 /*
  69  * Write barriers
  70  */
  71
  72 static gboolean
  73 ptr_on_stack (void *ptr)
  74 {
  75         gpointer stack_start = &stack_start;
  76         SgenThreadInfo *info = mono_thread_info_current ();
  77
  78         if (ptr >= stack_start && ptr < (gpointer)info->client_info.stack_end)
  79                 return TRUE;
  80         return FALSE;
  81 }
  82
  83 #ifdef SGEN_HEAVY_BINARY_PROTOCOL
  84 #undef HANDLE_PTR
  85 #define HANDLE_PTR(ptr,obj) do {                                        \
  86                 gpointer o = *(gpointer*)(ptr);                         \
  87                 if ((o)) {                                              \
  88                         gpointer d = ((char*)dest) + ((char*)(ptr) - (char*)(obj)); \
  89                         binary_protocol_wbarrier (d, o, (gpointer) SGEN_LOAD_VTABLE (o)); \
  90                 }                                                       \
  91         } while (0)
  92
  93 static void
  94 scan_object_for_binary_protocol_copy_wbarrier (gpointer dest, char *start, mword desc)
  95 {
  96 #define SCAN_OBJECT_NOVTABLE
  97 #include "sgen/sgen-scan-object.h"
  98 }
  99 #endif
 100
 101 void
 102 mono_gc_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoClass *klass)
 103 {
 104         HEAVY_STAT (++stat_wbarrier_value_copy);
 105         g_assert (klass->valuetype);
 106
 107         SGEN_LOG (8, "Adding value remset at %p, count %d, descr %p for class %s (%p)", dest, count, (gpointer)klass->gc_descr, klass->name, klass);
 108
 109         if (sgen_ptr_in_nursery (dest) || ptr_on_stack (dest) || !sgen_gc_descr_has_references ((mword)klass->gc_descr)) {
 110                 size_t element_size = mono_class_value_size (klass, NULL);
 111                 size_t size = count * element_size;
 112                 mono_gc_memmove_atomic (dest, src, size);
 113                 return;
 114         }
 115
 116 #ifdef SGEN_HEAVY_BINARY_PROTOCOL
 117         if (binary_protocol_is_heavy_enabled ()) {
 118                 size_t element_size = mono_class_value_size (klass, NULL);
 119                 int i;
 120                 for (i = 0; i < count; ++i) {
 121                         scan_object_for_binary_protocol_copy_wbarrier ((char*)dest + i * element_size,
 122                                         (char*)src + i * element_size - sizeof (MonoObject),
 123                                         (mword) klass->gc_descr);
 124                 }
 125         }
 126 #endif
 127
 128         sgen_get_remset ()->wbarrier_value_copy (dest, src, count, mono_class_value_size (klass, NULL));
 129 }
 130
 131 /**
 132  * mono_gc_wbarrier_object_copy:
 133  *
 134  * Write barrier to call when obj is the result of a clone or copy of an object.
 135  */
 136 void
 137 mono_gc_wbarrier_object_copy (MonoObject* obj, MonoObject *src)
 138 {
 139         int size;
 140
 141         HEAVY_STAT (++stat_wbarrier_object_copy);
 142
 143         SGEN_ASSERT (6, !ptr_on_stack (obj), "Why is this called for a non-reference type?");
 144         if (sgen_ptr_in_nursery (obj) || !SGEN_OBJECT_HAS_REFERENCES (src)) {
 145                 size = mono_object_class (obj)->instance_size;
 146                 mono_gc_memmove_aligned ((char*)obj + sizeof (MonoObject), (char*)src + sizeof (MonoObject),
 147                                 size - sizeof (MonoObject));
 148                 return;
 149         }
 150
 151 #ifdef SGEN_HEAVY_BINARY_PROTOCOL
 152         if (binary_protocol_is_heavy_enabled ())
 153                 scan_object_for_binary_protocol_copy_wbarrier (obj, (char*)src, (mword) src->vtable->gc_descr);
 154 #endif
 155
 156         sgen_get_remset ()->wbarrier_object_copy (obj, src);
 157 }
 158
 159 void
 160 mono_gc_wbarrier_set_arrayref (MonoArray *arr, gpointer slot_ptr, MonoObject* value)
 161 {
 162         HEAVY_STAT (++stat_wbarrier_set_arrayref);
 163         if (sgen_ptr_in_nursery (slot_ptr)) {
 164                 *(void**)slot_ptr = value;
 165                 return;
 166         }
 167         SGEN_LOG (8, "Adding remset at %p", slot_ptr);
 168         if (value)
 169                 binary_protocol_wbarrier (slot_ptr, value, value->vtable);
 170
 171         sgen_get_remset ()->wbarrier_set_field ((GCObject*)arr, slot_ptr, value);
 172 }
 173
 174 void
 175 mono_gc_wbarrier_set_field (MonoObject *obj, gpointer field_ptr, MonoObject* value)
 176 {
 177         mono_gc_wbarrier_set_arrayref ((MonoArray*)obj, field_ptr, value);
 178 }
 179
 180 void
 181 mono_gc_wbarrier_value_copy_bitmap (gpointer _dest, gpointer _src, int size, unsigned bitmap)
 182 {
 183         sgen_wbarrier_value_copy_bitmap (_dest, _src, size, bitmap);
 184 }
 185
 186 static MonoMethod *write_barrier_conc_method;
 187 static MonoMethod *write_barrier_noconc_method;
 188
 189 gboolean
 190 sgen_is_critical_method (MonoMethod *method)
 191 {
 192         return sgen_is_managed_allocator (method);
 193 }
 194
 195 gboolean
 196 sgen_has_critical_method (void)
 197 {
 198         return sgen_has_managed_allocator ();
 199 }
 200
 201 #ifndef DISABLE_JIT
 202
 203 static void
 204 emit_nursery_check (MonoMethodBuilder *mb, int *nursery_check_return_labels, gboolean is_concurrent)
 205 {
 206         int shifted_nursery_start = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
 207
 208         memset (nursery_check_return_labels, 0, sizeof (int) * 2);
 209         // if (ptr_in_nursery (ptr)) return;
 210         /*
 211          * Masking out the bits might be faster, but we would have to use 64 bit
 212          * immediates, which might be slower.
 213          */
 214         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
 215         mono_mb_emit_byte (mb, CEE_MONO_LDPTR_NURSERY_START);
 216         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
 217         mono_mb_emit_byte (mb, CEE_MONO_LDPTR_NURSERY_BITS);
 218         mono_mb_emit_byte (mb, CEE_SHR_UN);
 219         mono_mb_emit_stloc (mb, shifted_nursery_start);
 220
 221         mono_mb_emit_ldarg (mb, 0);
 222         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
 223         mono_mb_emit_byte (mb, CEE_MONO_LDPTR_NURSERY_BITS);
 224         mono_mb_emit_byte (mb, CEE_SHR_UN);
 225         mono_mb_emit_ldloc (mb, shifted_nursery_start);
 226         nursery_check_return_labels [0] = mono_mb_emit_branch (mb, CEE_BEQ);
 227
 228         if (!is_concurrent) {
 229                 // if (!ptr_in_nursery (*ptr)) return;
 230                 mono_mb_emit_ldarg (mb, 0);
 231                 mono_mb_emit_byte (mb, CEE_LDIND_I);
 232                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
 233                 mono_mb_emit_byte (mb, CEE_MONO_LDPTR_NURSERY_BITS);
 234                 mono_mb_emit_byte (mb, CEE_SHR_UN);
 235                 mono_mb_emit_ldloc (mb, shifted_nursery_start);
 236                 nursery_check_return_labels [1] = mono_mb_emit_branch (mb, CEE_BNE_UN);
 237         }
 238 }
 239 #endif
 240
 241 MonoMethod*
 242 mono_gc_get_specific_write_barrier (gboolean is_concurrent)
 243 {
 244         MonoMethod *res;
 245         MonoMethodBuilder *mb;
 246         MonoMethodSignature *sig;
 247         MonoMethod **write_barrier_method_addr;
 248         WrapperInfo *info;
 249 #ifdef MANAGED_WBARRIER
 250         int i, nursery_check_labels [2];
 251 #endif
 252
 253         // FIXME: Maybe create a separate version for ctors (the branch would be
 254         // correctly predicted more times)
 255         if (is_concurrent)
 256                 write_barrier_method_addr = &write_barrier_conc_method;
 257         else
 258                 write_barrier_method_addr = &write_barrier_noconc_method;
 259
 260         if (*write_barrier_method_addr)
 261                 return *write_barrier_method_addr;
 262
 263         /* Create the IL version of mono_gc_barrier_generic_store () */
 264         sig = mono_metadata_signature_alloc (mono_defaults.corlib, 1);
 265         sig->ret = &mono_defaults.void_class->byval_arg;
 266         sig->params [0] = &mono_defaults.int_class->byval_arg;
 267
 268         if (is_concurrent)
 269                 mb = mono_mb_new (mono_defaults.object_class, "wbarrier_conc", MONO_WRAPPER_WRITE_BARRIER);
 270         else
 271                 mb = mono_mb_new (mono_defaults.object_class, "wbarrier_noconc", MONO_WRAPPER_WRITE_BARRIER);
 272
 273 #ifndef DISABLE_JIT
 274 #ifdef MANAGED_WBARRIER
 275         emit_nursery_check (mb, nursery_check_labels, is_concurrent);
 276         /*
 277         addr = sgen_cardtable + ((address >> CARD_BITS) & CARD_MASK)
 278         *addr = 1;
 279
 280         sgen_cardtable:
 281                 LDC_PTR sgen_cardtable
 282
 283         address >> CARD_BITS
 284                 LDARG_0
 285                 LDC_I4 CARD_BITS
 286                 SHR_UN
 287         if (SGEN_HAVE_OVERLAPPING_CARDS) {
 288                 LDC_PTR card_table_mask
 289                 AND
 290         }
 291         AND
 292         ldc_i4_1
 293         stind_i1
 294         */
 295         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
 296         mono_mb_emit_byte (mb, CEE_MONO_LDPTR_CARD_TABLE);
 297         mono_mb_emit_ldarg (mb, 0);
 298         mono_mb_emit_icon (mb, CARD_BITS);
 299         mono_mb_emit_byte (mb, CEE_SHR_UN);
 300         mono_mb_emit_byte (mb, CEE_CONV_I);
 301 #ifdef SGEN_HAVE_OVERLAPPING_CARDS
 302 #if SIZEOF_VOID_P == 8
 303         mono_mb_emit_icon8 (mb, CARD_MASK);
 304 #else
 305         mono_mb_emit_icon (mb, CARD_MASK);
 306 #endif
 307         mono_mb_emit_byte (mb, CEE_CONV_I);
 308         mono_mb_emit_byte (mb, CEE_AND);
 309 #endif
 310         mono_mb_emit_byte (mb, CEE_ADD);
 311         mono_mb_emit_icon (mb, 1);
 312         mono_mb_emit_byte (mb, CEE_STIND_I1);
 313
 314         // return;
 315         for (i = 0; i < 2; ++i) {
 316                 if (nursery_check_labels [i])
 317                         mono_mb_patch_branch (mb, nursery_check_labels [i]);
 318         }
 319         mono_mb_emit_byte (mb, CEE_RET);
 320 #else
 321         mono_mb_emit_ldarg (mb, 0);
 322         mono_mb_emit_icall (mb, mono_gc_wbarrier_generic_nostore);
 323         mono_mb_emit_byte (mb, CEE_RET);
 324 #endif
 325 #endif
 326         res = mono_mb_create_method (mb, sig, 16);
 327         info = mono_wrapper_info_create (mb, WRAPPER_SUBTYPE_NONE);
 328         mono_marshal_set_wrapper_info (res, info);
 329         mono_mb_free (mb);
 330
 331         LOCK_GC;
 332         if (*write_barrier_method_addr) {
 333                 /* Already created */
 334                 mono_free_method (res);
 335         } else {
 336                 /* double-checked locking */
 337                 mono_memory_barrier ();
 338                 *write_barrier_method_addr = res;
 339         }
 340         UNLOCK_GC;
 341
 342         return *write_barrier_method_addr;
 343 }
 344
 345 MonoMethod*
 346 mono_gc_get_write_barrier (void)
 347 {
 348         return mono_gc_get_specific_write_barrier (major_collector.is_concurrent);
 349 }
 350
 351 /*
 352  * Dummy filler objects
 353  */
 354
 355 /* Vtable of the objects used to fill out nursery fragments before a collection */
 356 static GCVTable array_fill_vtable;
 357
 358 static GCVTable
 359 get_array_fill_vtable (void)
 360 {
 361         if (!array_fill_vtable) {
 362                 static MonoClass klass;
 363                 static char _vtable[sizeof(MonoVTable)+8];
 364                 MonoVTable* vtable = (MonoVTable*) ALIGN_TO((mword)_vtable, 8);
 365                 gsize bmap;
 366
 367                 MonoDomain *domain = mono_get_root_domain ();
 368                 g_assert (domain);
 369
 370                 klass.element_class = mono_defaults.byte_class;
 371                 klass.rank = 1;
 372                 klass.instance_size = MONO_SIZEOF_MONO_ARRAY;
 373                 klass.sizes.element_size = 1;
 374                 klass.name = "array_filler_type";
 375
 376                 vtable->klass = &klass;
 377                 bmap = 0;
 378                 vtable->gc_descr = mono_gc_make_descr_for_array (TRUE, &bmap, 0, 1);
 379                 vtable->rank = 1;
 380
 381                 array_fill_vtable = vtable;
 382         }
 383         return array_fill_vtable;
 384 }
 385
 386 gboolean
 387 sgen_client_array_fill_range (char *start, size_t size)
 388 {
 389         MonoArray *o;
 390
 391         if (size < MONO_SIZEOF_MONO_ARRAY) {
 392                 memset (start, 0, size);
 393                 return FALSE;
 394         }
 395
 396         o = (MonoArray*)start;
 397         o->obj.vtable = (MonoVTable*)get_array_fill_vtable ();
 398         /* Mark this as not a real object */
 399         o->obj.synchronisation = (MonoThreadsSync *)GINT_TO_POINTER (-1);
 400         o->bounds = NULL;
 401         o->max_length = (mono_array_size_t)(size - MONO_SIZEOF_MONO_ARRAY);
 402
 403         return TRUE;
 404 }
 405
 406 void
 407 sgen_client_zero_array_fill_header (void *p, size_t size)
 408 {
 409         if (size >= MONO_SIZEOF_MONO_ARRAY) {
 410                 memset (p, 0, MONO_SIZEOF_MONO_ARRAY);
 411         } else {
 412                 static guint8 zeros [MONO_SIZEOF_MONO_ARRAY];
 413
 414                 SGEN_ASSERT (0, !memcmp (p, zeros, size), "TLAB segment must be zeroed out.");
 415         }
 416 }
 417
 418 /*
 419  * Finalization
 420  */
 421
 422 static MonoGCFinalizerCallbacks fin_callbacks;
 423
 424 guint
 425 mono_gc_get_vtable_bits (MonoClass *klass)
 426 {
 427         guint res = 0;
 428         /* FIXME move this to the bridge code */
 429         if (sgen_need_bridge_processing ()) {
 430                 switch (sgen_bridge_class_kind (klass)) {
 431                 case GC_BRIDGE_TRANSPARENT_BRIDGE_CLASS:
 432                 case GC_BRIDGE_OPAQUE_BRIDGE_CLASS:
 433                         res = SGEN_GC_BIT_BRIDGE_OBJECT;
 434                         break;
 435                 case GC_BRIDGE_OPAQUE_CLASS:
 436                         res = SGEN_GC_BIT_BRIDGE_OPAQUE_OBJECT;
 437                         break;
 438                 case GC_BRIDGE_TRANSPARENT_CLASS:
 439                         break;
 440                 }
 441         }
 442         if (fin_callbacks.is_class_finalization_aware) {
 443                 if (fin_callbacks.is_class_finalization_aware (klass))
 444                         res |= SGEN_GC_BIT_FINALIZER_AWARE;
 445         }
 446         return res;
 447 }
 448
 449 static gboolean
 450 is_finalization_aware (MonoObject *obj)
 451 {
 452         MonoVTable *vt = SGEN_LOAD_VTABLE (obj);
 453         return (vt->gc_bits & SGEN_GC_BIT_FINALIZER_AWARE) == SGEN_GC_BIT_FINALIZER_AWARE;
 454 }
 455
 456 void
 457 sgen_client_object_queued_for_finalization (GCObject *obj)
 458 {
 459         if (fin_callbacks.object_queued_for_finalization && is_finalization_aware (obj))
 460                 fin_callbacks.object_queued_for_finalization (obj);
 461
 462 #ifdef ENABLE_DTRACE
 463         if (G_UNLIKELY (MONO_GC_FINALIZE_ENQUEUE_ENABLED ())) {
 464                 int gen = sgen_ptr_in_nursery (obj) ? GENERATION_NURSERY : GENERATION_OLD;
 465                 GCVTable vt = SGEN_LOAD_VTABLE (obj);
 466                 MONO_GC_FINALIZE_ENQUEUE ((mword)obj, sgen_safe_object_get_size (obj),
 467                                 sgen_client_vtable_get_namespace (vt), sgen_client_vtable_get_name (vt), gen,
 468                                 sgen_client_object_has_critical_finalizer (obj));
 469         }
 470 #endif
 471 }
 472
 473 void
 474 mono_gc_register_finalizer_callbacks (MonoGCFinalizerCallbacks *callbacks)
 475 {
 476         if (callbacks->version != MONO_GC_FINALIZER_EXTENSION_VERSION)
 477                 g_error ("Invalid finalizer callback version. Expected %d but got %d\n", MONO_GC_FINALIZER_EXTENSION_VERSION, callbacks->version);
 478
 479         fin_callbacks = *callbacks;
 480 }
 481
 482 void
 483 sgen_client_run_finalize (MonoObject *obj)
 484 {
 485         mono_gc_run_finalize (obj, NULL);
 486 }
 487
 488 int
 489 mono_gc_invoke_finalizers (void)
 490 {
 491         return sgen_gc_invoke_finalizers ();
 492 }
 493
 494 MonoBoolean
 495 mono_gc_pending_finalizers (void)
 496 {
 497         return sgen_have_pending_finalizers ();
 498 }
 499
 500 void
 501 sgen_client_finalize_notify (void)
 502 {
 503         mono_gc_finalize_notify ();
 504 }
 505
 506 void
 507 mono_gc_register_for_finalization (MonoObject *obj, void *user_data)
 508 {
 509         sgen_object_register_for_finalization (obj, user_data);
 510 }
 511
 512 static gboolean
 513 object_in_domain_predicate (MonoObject *obj, void *user_data)
 514 {
 515         MonoDomain *domain = (MonoDomain *)user_data;
 516         if (mono_object_domain (obj) == domain) {
 517                 SGEN_LOG (5, "Unregistering finalizer for object: %p (%s)", obj, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (obj)));
 518                 return TRUE;
 519         }
 520         return FALSE;
 521 }
 522
 523 /**
 524  * mono_gc_finalizers_for_domain:
 525  * @domain: the unloading appdomain
 526  * @out_array: output array
 527  * @out_size: size of output array
 528  *
 529  * Enqueue for finalization all objects that belong to the unloading appdomain @domain
 530  * @suspend is used for early termination of the enqueuing process.
 531  */
 532 void
 533 mono_gc_finalize_domain (MonoDomain *domain)
 534 {
 535         sgen_finalize_if (object_in_domain_predicate, domain);
 536 }
 537
 538 void
 539 mono_gc_suspend_finalizers (void)
 540 {
 541         sgen_set_suspend_finalizers ();
 542 }
 543
 544 /*
 545  * Ephemerons
 546  */
 547
 548 typedef struct _EphemeronLinkNode EphemeronLinkNode;
 549
 550 struct _EphemeronLinkNode {
 551         EphemeronLinkNode *next;
 552         MonoArray *array;
 553 };
 554
 555 typedef struct {
 556        GCObject *key;
 557        GCObject *value;
 558 } Ephemeron;
 559
 560 static EphemeronLinkNode *ephemeron_list;
 561
 562 /* LOCKING: requires that the GC lock is held */
 563 static void
 564 null_ephemerons_for_domain (MonoDomain *domain)
 565 {
 566         EphemeronLinkNode *current = ephemeron_list, *prev = NULL;
 567
 568         while (current) {
 569                 MonoObject *object = (MonoObject*)current->array;
 570
 571                 if (object)
 572                         SGEN_ASSERT (0, object->vtable, "Can't have objects without vtables.");
 573
 574                 if (object && object->vtable->domain == domain) {
 575                         EphemeronLinkNode *tmp = current;
 576
 577                         if (prev)
 578                                 prev->next = current->next;
 579                         else
 580                                 ephemeron_list = current->next;
 581
 582                         current = current->next;
 583                         sgen_free_internal (tmp, INTERNAL_MEM_EPHEMERON_LINK);
 584                 } else {
 585                         prev = current;
 586                         current = current->next;
 587                 }
 588         }
 589 }
 590
 591 /* LOCKING: requires that the GC lock is held */
 592 void
 593 sgen_client_clear_unreachable_ephemerons (ScanCopyContext ctx)
 594 {
 595         CopyOrMarkObjectFunc copy_func = ctx.ops->copy_or_mark_object;
 596         SgenGrayQueue *queue = ctx.queue;
 597         EphemeronLinkNode *current = ephemeron_list, *prev = NULL;
 598         Ephemeron *cur, *array_end;
 599         GCObject *tombstone;
 600
 601         while (current) {
 602                 MonoArray *array = current->array;
 603
 604                 if (!sgen_is_object_alive_for_current_gen ((GCObject*)array)) {
 605                         EphemeronLinkNode *tmp = current;
 606
 607                         SGEN_LOG (5, "Dead Ephemeron array at %p", array);
 608
 609                         if (prev)
 610                                 prev->next = current->next;
 611                         else
 612                                 ephemeron_list = current->next;
 613
 614                         current = current->next;
 615                         sgen_free_internal (tmp, INTERNAL_MEM_EPHEMERON_LINK);
 616
 617                         continue;
 618                 }
 619
 620                 copy_func ((GCObject**)&array, queue);
 621                 current->array = array;
 622
 623                 SGEN_LOG (5, "Clearing unreachable entries for ephemeron array at %p", array);
 624
 625                 cur = mono_array_addr (array, Ephemeron, 0);
 626                 array_end = cur + mono_array_length_fast (array);
 627                 tombstone = SGEN_LOAD_VTABLE ((GCObject*)array)->domain->ephemeron_tombstone;
 628
 629                 for (; cur < array_end; ++cur) {
 630                         GCObject *key = cur->key;
 631
 632                         if (!key || key == tombstone)
 633                                 continue;
 634
 635                         SGEN_LOG (5, "[%zd] key %p (%s) value %p (%s)", cur - mono_array_addr (array, Ephemeron, 0),
 636                                 key, sgen_is_object_alive_for_current_gen (key) ? "reachable" : "unreachable",
 637                                 cur->value, cur->value && sgen_is_object_alive_for_current_gen (cur->value) ? "reachable" : "unreachable");
 638
 639                         if (!sgen_is_object_alive_for_current_gen (key)) {
 640                                 cur->key = tombstone;
 641                                 cur->value = NULL;
 642                                 continue;
 643                         }
 644                 }
 645                 prev = current;
 646                 current = current->next;
 647         }
 648 }
 649
 650 /*
 651 LOCKING: requires that the GC lock is held
 652
 653 Limitations: We scan all ephemerons on every collection since the current design doesn't allow for a simple nursery/mature split.
 654 */
 655 gboolean
 656 sgen_client_mark_ephemerons (ScanCopyContext ctx)
 657 {
 658         CopyOrMarkObjectFunc copy_func = ctx.ops->copy_or_mark_object;
 659         SgenGrayQueue *queue = ctx.queue;
 660         gboolean nothing_marked = TRUE;
 661         EphemeronLinkNode *current = ephemeron_list;
 662         Ephemeron *cur, *array_end;
 663         GCObject *tombstone;
 664
 665         for (current = ephemeron_list; current; current = current->next) {
 666                 MonoArray *array = current->array;
 667                 SGEN_LOG (5, "Ephemeron array at %p", array);
 668
 669                 /*It has to be alive*/
 670                 if (!sgen_is_object_alive_for_current_gen ((GCObject*)array)) {
 671                         SGEN_LOG (5, "\tnot reachable");
 672                         continue;
 673                 }
 674
 675                 copy_func ((GCObject**)&array, queue);
 676
 677                 cur = mono_array_addr (array, Ephemeron, 0);
 678                 array_end = cur + mono_array_length_fast (array);
 679                 tombstone = SGEN_LOAD_VTABLE ((GCObject*)array)->domain->ephemeron_tombstone;
 680
 681                 for (; cur < array_end; ++cur) {
 682                         GCObject *key = cur->key;
 683
 684                         if (!key || key == tombstone)
 685                                 continue;
 686
 687                         SGEN_LOG (5, "[%zd] key %p (%s) value %p (%s)", cur - mono_array_addr (array, Ephemeron, 0),
 688                                 key, sgen_is_object_alive_for_current_gen (key) ? "reachable" : "unreachable",
 689                                 cur->value, cur->value && sgen_is_object_alive_for_current_gen (cur->value) ? "reachable" : "unreachable");
 690
 691                         if (sgen_is_object_alive_for_current_gen (key)) {
 692                                 GCObject *value = cur->value;
 693
 694                                 copy_func (&cur->key, queue);
 695                                 if (value) {
 696                                         if (!sgen_is_object_alive_for_current_gen (value))
 697                                                 nothing_marked = FALSE;
 698                                         copy_func (&cur->value, queue);
 699                                 }
 700                         }
 701                 }
 702         }
 703
 704         SGEN_LOG (5, "Ephemeron run finished. Is it done %d", nothing_marked);
 705         return nothing_marked;
 706 }
 707
 708 gboolean
 709 mono_gc_ephemeron_array_add (MonoObject *obj)
 710 {
 711         EphemeronLinkNode *node;
 712
 713         LOCK_GC;
 714
 715         node = (EphemeronLinkNode *)sgen_alloc_internal (INTERNAL_MEM_EPHEMERON_LINK);
 716         if (!node) {
 717                 UNLOCK_GC;
 718                 return FALSE;
 719         }
 720         node->array = (MonoArray*)obj;
 721         node->next = ephemeron_list;
 722         ephemeron_list = node;
 723
 724         SGEN_LOG (5, "Registered ephemeron array %p", obj);
 725
 726         UNLOCK_GC;
 727         return TRUE;
 728 }
 729
 730 /*
 731  * Appdomain handling
 732  */
 733
 734 void
 735 mono_gc_set_current_thread_appdomain (MonoDomain *domain)
 736 {
 737         SgenThreadInfo *info = mono_thread_info_current ();
 738
 739         /* Could be called from sgen_thread_unregister () with a NULL info */
 740         if (domain) {
 741                 g_assert (info);
 742                 info->client_info.stopped_domain = domain;
 743         }
 744 }
 745
 746 static gboolean
 747 need_remove_object_for_domain (GCObject *start, MonoDomain *domain)
 748 {
 749         if (mono_object_domain (start) == domain) {
 750                 SGEN_LOG (4, "Need to cleanup object %p", start);
 751                 binary_protocol_cleanup (start, (gpointer)SGEN_LOAD_VTABLE (start), sgen_safe_object_get_size ((GCObject*)start));
 752                 return TRUE;
 753         }
 754         return FALSE;
 755 }
 756
 757 static void
 758 process_object_for_domain_clearing (GCObject *start, MonoDomain *domain)
 759 {
 760         MonoVTable *vt = SGEN_LOAD_VTABLE (start);
 761         if (vt->klass == mono_defaults.internal_thread_class)
 762                 g_assert (mono_object_domain (start) == mono_get_root_domain ());
 763         /* The object could be a proxy for an object in the domain
 764            we're deleting. */
 765 #ifndef DISABLE_REMOTING
 766         if (mono_defaults.real_proxy_class->supertypes && mono_class_has_parent_fast (vt->klass, mono_defaults.real_proxy_class)) {
 767                 MonoObject *server = ((MonoRealProxy*)start)->unwrapped_server;
 768
 769                 /* The server could already have been zeroed out, so
 770                    we need to check for that, too. */
 771                 if (server && (!SGEN_LOAD_VTABLE (server) || mono_object_domain (server) == domain)) {
 772                         SGEN_LOG (4, "Cleaning up remote pointer in %p to object %p", start, server);
 773                         ((MonoRealProxy*)start)->unwrapped_server = NULL;
 774                 }
 775         }
 776 #endif
 777 }
 778
 779 static gboolean
 780 clear_domain_process_object (GCObject *obj, MonoDomain *domain)
 781 {
 782         gboolean remove;
 783
 784         process_object_for_domain_clearing (obj, domain);
 785         remove = need_remove_object_for_domain (obj, domain);
 786
 787         if (remove && obj->synchronisation) {
 788                 guint32 dislink = mono_monitor_get_object_monitor_gchandle (obj);
 789                 if (dislink)
 790                         mono_gchandle_free (dislink);
 791         }
 792
 793         return remove;
 794 }
 795
 796 static void
 797 clear_domain_process_minor_object_callback (GCObject *obj, size_t size, MonoDomain *domain)
 798 {
 799         if (clear_domain_process_object (obj, domain)) {
 800                 CANARIFY_SIZE (size);
 801                 memset (obj, 0, size);
 802         }
 803 }
 804
 805 static void
 806 clear_domain_process_major_object_callback (GCObject *obj, size_t size, MonoDomain *domain)
 807 {
 808         clear_domain_process_object (obj, domain);
 809 }
 810
 811 static void
 812 clear_domain_free_major_non_pinned_object_callback (GCObject *obj, size_t size, MonoDomain *domain)
 813 {
 814         if (need_remove_object_for_domain (obj, domain))
 815                 major_collector.free_non_pinned_object (obj, size);
 816 }
 817
 818 static void
 819 clear_domain_free_major_pinned_object_callback (GCObject *obj, size_t size, MonoDomain *domain)
 820 {
 821         if (need_remove_object_for_domain (obj, domain))
 822                 major_collector.free_pinned_object (obj, size);
 823 }
 824
 825 /*
 826  * When appdomains are unloaded we can easily remove objects that have finalizers,
 827  * but all the others could still be present in random places on the heap.
 828  * We need a sweep to get rid of them even though it's going to be costly
 829  * with big heaps.
 830  * The reason we need to remove them is because we access the vtable and class
 831  * structures to know the object size and the reference bitmap: once the domain is
 832  * unloaded the point to random memory.
 833  */
 834 void
 835 mono_gc_clear_domain (MonoDomain * domain)
 836 {
 837         LOSObject *bigobj, *prev;
 838         int i;
 839
 840         LOCK_GC;
 841
 842         binary_protocol_domain_unload_begin (domain);
 843
 844         sgen_stop_world (0);
 845
 846         if (sgen_concurrent_collection_in_progress ())
 847                 sgen_perform_collection (0, GENERATION_OLD, "clear domain", TRUE, FALSE);
 848         SGEN_ASSERT (0, !sgen_concurrent_collection_in_progress (), "We just ordered a synchronous collection.  Why are we collecting concurrently?");
 849
 850         major_collector.finish_sweeping ();
 851
 852         sgen_process_fin_stage_entries ();
 853
 854         sgen_clear_nursery_fragments ();
 855
 856         if (sgen_mono_xdomain_checks && domain != mono_get_root_domain ()) {
 857                 sgen_scan_for_registered_roots_in_domain (domain, ROOT_TYPE_NORMAL);
 858                 sgen_scan_for_registered_roots_in_domain (domain, ROOT_TYPE_WBARRIER);
 859                 sgen_check_for_xdomain_refs ();
 860         }
 861
 862         /*Ephemerons and dislinks must be processed before LOS since they might end up pointing
 863         to memory returned to the OS.*/
 864         null_ephemerons_for_domain (domain);
 865         sgen_null_links_for_domain (domain);
 866
 867         for (i = GENERATION_NURSERY; i < GENERATION_MAX; ++i)
 868                 sgen_remove_finalizers_if (object_in_domain_predicate, domain, i);
 869
 870         sgen_scan_area_with_callback (nursery_section->data, nursery_section->end_data,
 871                         (IterateObjectCallbackFunc)clear_domain_process_minor_object_callback, domain, FALSE, TRUE);
 872
 873         /* We need two passes over major and large objects because
 874            freeing such objects might give their memory back to the OS
 875            (in the case of large objects) or obliterate its vtable
 876            (pinned objects with major-copying or pinned and non-pinned
 877            objects with major-mark&sweep), but we might need to
 878            dereference a pointer from an object to another object if
 879            the first object is a proxy. */
 880         major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_ALL, (IterateObjectCallbackFunc)clear_domain_process_major_object_callback, domain);
 881         for (bigobj = los_object_list; bigobj; bigobj = bigobj->next)
 882                 clear_domain_process_object ((GCObject*)bigobj->data, domain);
 883
 884         prev = NULL;
 885         for (bigobj = los_object_list; bigobj;) {
 886                 if (need_remove_object_for_domain ((GCObject*)bigobj->data, domain)) {
 887                         LOSObject *to_free = bigobj;
 888                         if (prev)
 889                                 prev->next = bigobj->next;
 890                         else
 891                                 los_object_list = bigobj->next;
 892                         bigobj = bigobj->next;
 893                         SGEN_LOG (4, "Freeing large object %p", bigobj->data);
 894                         sgen_los_free_object (to_free);
 895                         continue;
 896                 }
 897                 prev = bigobj;
 898                 bigobj = bigobj->next;
 899         }
 900         major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_NON_PINNED, (IterateObjectCallbackFunc)clear_domain_free_major_non_pinned_object_callback, domain);
 901         major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_PINNED, (IterateObjectCallbackFunc)clear_domain_free_major_pinned_object_callback, domain);
 902
 903         if (domain == mono_get_root_domain ()) {
 904                 sgen_pin_stats_report ();
 905                 sgen_object_layout_dump (stdout);
 906         }
 907
 908         sgen_restart_world (0);
 909
 910         binary_protocol_domain_unload_end (domain);
 911         binary_protocol_flush_buffers (FALSE);
 912
 913         UNLOCK_GC;
 914 }
 915
 916 /*
 917  * Allocation
 918  */
 919
 920 static gboolean alloc_events = FALSE;
 921
 922 void
 923 mono_gc_enable_alloc_events (void)
 924 {
 925         alloc_events = TRUE;
 926 }
 927
 928 void*
 929 mono_gc_alloc_obj (MonoVTable *vtable, size_t size)
 930 {
 931         MonoObject *obj = sgen_alloc_obj (vtable, size);
 932
 933         if (G_UNLIKELY (alloc_events)) {
 934                 if (obj)
 935                         mono_profiler_allocation (obj);
 936         }
 937
 938         return obj;
 939 }
 940
 941 void*
 942 mono_gc_alloc_pinned_obj (MonoVTable *vtable, size_t size)
 943 {
 944         MonoObject *obj = sgen_alloc_obj_pinned (vtable, size);
 945
 946         if (G_UNLIKELY (alloc_events)) {
 947                 if (obj)
 948                         mono_profiler_allocation (obj);
 949         }
 950
 951         return obj;
 952 }
 953
 954 void*
 955 mono_gc_alloc_mature (MonoVTable *vtable, size_t size)
 956 {
 957         MonoObject *obj = sgen_alloc_obj_mature (vtable, size);
 958
 959         if (G_UNLIKELY (alloc_events)) {
 960                 if (obj)
 961                         mono_profiler_allocation (obj);
 962         }
 963
 964         return obj;
 965 }
 966
 967 void*
 968 mono_gc_alloc_fixed (size_t size, MonoGCDescriptor descr, MonoGCRootSource source, const char *msg)
 969 {
 970         /* FIXME: do a single allocation */
 971         void *res = g_calloc (1, size);
 972         if (!res)
 973                 return NULL;
 974         if (!mono_gc_register_root ((char *)res, size, descr, source, msg)) {
 975                 g_free (res);
 976                 res = NULL;
 977         }
 978         return res;
 979 }
 980
 981 void
 982 mono_gc_free_fixed (void* addr)
 983 {
 984         mono_gc_deregister_root ((char *)addr);
 985         g_free (addr);
 986 }
 987
 988 /*
 989  * Managed allocator
 990  */
 991
 992 static MonoMethod* alloc_method_cache [ATYPE_NUM];
 993 static MonoMethod* slowpath_alloc_method_cache [ATYPE_NUM];
 994 static gboolean use_managed_allocator = TRUE;
 995
 996 #ifdef MANAGED_ALLOCATION
 997
 998 #if defined(HAVE_KW_THREAD) || defined(TARGET_OSX) || defined(TARGET_WIN32) || defined(TARGET_ANDROID) || defined(TARGET_IOS)
 999
1000 // Cache the SgenThreadInfo pointer in a local 'var'.
1001 #define EMIT_TLS_ACCESS_VAR(mb, var) \
1002         do { \
1003                 var = mono_mb_add_local ((mb), &mono_defaults.int_class->byval_arg); \
1004                 mono_mb_emit_byte ((mb), MONO_CUSTOM_PREFIX); \
1005                 mono_mb_emit_byte ((mb), CEE_MONO_TLS); \
1006                 mono_mb_emit_i4 ((mb), TLS_KEY_SGEN_THREAD_INFO); \
1007                 mono_mb_emit_stloc ((mb), (var)); \
1008         } while (0)
1009
1010 #define EMIT_TLS_ACCESS_IN_CRITICAL_REGION_ADDR(mb, var) \
1011         do { \
1012                 mono_mb_emit_ldloc ((mb), (var)); \
1013                 mono_mb_emit_icon ((mb), MONO_STRUCT_OFFSET (SgenClientThreadInfo, in_critical_region)); \
1014                 mono_mb_emit_byte ((mb), CEE_ADD); \
1015         } while (0)
1016
1017 #define EMIT_TLS_ACCESS_NEXT_ADDR(mb, var)      do {    \
1018         mono_mb_emit_ldloc ((mb), (var));               \
1019         mono_mb_emit_icon ((mb), MONO_STRUCT_OFFSET (SgenThreadInfo, tlab_next));       \
1020         mono_mb_emit_byte ((mb), CEE_ADD);              \
1021         } while (0)
1022
1023 #define EMIT_TLS_ACCESS_TEMP_END(mb, var)       do {    \
1024         mono_mb_emit_ldloc ((mb), (var));               \
1025         mono_mb_emit_icon ((mb), MONO_STRUCT_OFFSET (SgenThreadInfo, tlab_temp_end));   \
1026         mono_mb_emit_byte ((mb), CEE_ADD);              \
1027         mono_mb_emit_byte ((mb), CEE_LDIND_I);          \
1028         } while (0)
1029
1030 #else
1031 #define EMIT_TLS_ACCESS_VAR(mb, _var)   do { g_error ("sgen is not supported when using --with-tls=pthread.\n"); } while (0)
1032 #define EMIT_TLS_ACCESS_NEXT_ADDR(mb, _var)     do { g_error ("sgen is not supported when using --with-tls=pthread.\n"); } while (0)
1033 #define EMIT_TLS_ACCESS_TEMP_END(mb, _var)      do { g_error ("sgen is not supported when using --with-tls=pthread.\n"); } while (0)
1034 #define EMIT_TLS_ACCESS_IN_CRITICAL_REGION_ADDR(mb, _var)       do { g_error ("sgen is not supported when using --with-tls=pthread.\n"); } while (0)
1035
1036 #endif
1037
1038 /* FIXME: Do this in the JIT, where specialized allocation sequences can be created
1039  * for each class. This is currently not easy to do, as it is hard to generate basic
1040  * blocks + branches, but it is easy with the linear IL codebase.
1041  *
1042  * For this to work we'd need to solve the TLAB race, first.  Now we
1043  * require the allocator to be in a few known methods to make sure
1044  * that they are executed atomically via the restart mechanism.
1045  */
1046 static MonoMethod*
1047 create_allocator (int atype, ManagedAllocatorVariant variant)
1048 {
1049         int p_var, size_var, thread_var G_GNUC_UNUSED;
1050         gboolean slowpath = variant == MANAGED_ALLOCATOR_SLOW_PATH;
1051         guint32 slowpath_branch, max_size_branch;
1052         MonoMethodBuilder *mb;
1053         MonoMethod *res;
1054         MonoMethodSignature *csig;
1055         static gboolean registered = FALSE;
1056         int tlab_next_addr_var, new_next_var;
1057         const char *name = NULL;
1058         WrapperInfo *info;
1059         int num_params, i;
1060
1061         if (!registered) {
1062                 mono_register_jit_icall (mono_gc_alloc_obj, "mono_gc_alloc_obj", mono_create_icall_signature ("object ptr int"), FALSE);
1063                 mono_register_jit_icall (mono_gc_alloc_vector, "mono_gc_alloc_vector", mono_create_icall_signature ("object ptr int int"), FALSE);
1064                 mono_register_jit_icall (mono_gc_alloc_string, "mono_gc_alloc_string", mono_create_icall_signature ("object ptr int int32"), FALSE);
1065                 registered = TRUE;
1066         }
1067
1068         if (atype == ATYPE_SMALL) {
1069                 name = slowpath ? "SlowAllocSmall" : "AllocSmall";
1070         } else if (atype == ATYPE_NORMAL) {
1071                 name = slowpath ? "SlowAlloc" : "Alloc";
1072         } else if (atype == ATYPE_VECTOR) {
1073                 name = slowpath ? "SlowAllocVector" : "AllocVector";
1074         } else if (atype == ATYPE_STRING) {
1075                 name = slowpath ? "SlowAllocString" : "AllocString";
1076         } else {
1077                 g_assert_not_reached ();
1078         }
1079
1080         if (atype == ATYPE_NORMAL)
1081                 num_params = 1;
1082         else
1083                 num_params = 2;
1084
1085         csig = mono_metadata_signature_alloc (mono_defaults.corlib, num_params);
1086         if (atype == ATYPE_STRING) {
1087                 csig->ret = &mono_defaults.string_class->byval_arg;
1088                 csig->params [0] = &mono_defaults.int_class->byval_arg;
1089                 csig->params [1] = &mono_defaults.int32_class->byval_arg;
1090         } else {
1091                 csig->ret = &mono_defaults.object_class->byval_arg;
1092                 for (i = 0; i < num_params; i++)
1093                         csig->params [i] = &mono_defaults.int_class->byval_arg;
1094         }
1095
1096         mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_ALLOC);
1097
1098 #ifndef DISABLE_JIT
1099         if (slowpath) {
1100                 switch (atype) {
1101                 case ATYPE_NORMAL:
1102                 case ATYPE_SMALL:
1103                         mono_mb_emit_ldarg (mb, 0);
1104                         mono_mb_emit_icall (mb, ves_icall_object_new_specific);
1105                         break;
1106                 case ATYPE_VECTOR:
1107                         mono_mb_emit_ldarg (mb, 0);
1108                         mono_mb_emit_ldarg (mb, 1);
1109                         mono_mb_emit_icall (mb, ves_icall_array_new_specific);
1110                         break;
1111                 case ATYPE_STRING:
1112                         mono_mb_emit_ldarg (mb, 1);
1113                         mono_mb_emit_icall (mb, ves_icall_string_alloc);
1114                         break;
1115                 default:
1116                         g_assert_not_reached ();
1117                 }
1118
1119                 goto done;
1120         }
1121
1122         /*
1123          * Tls access might call foreign code or code without jinfo. This can
1124          * only happen if we are outside of the critical region.
1125          */
1126         EMIT_TLS_ACCESS_VAR (mb, thread_var);
1127
1128         size_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1129         if (atype == ATYPE_SMALL) {
1130                 /* size_var = size_arg */
1131                 mono_mb_emit_ldarg (mb, 1);
1132                 mono_mb_emit_stloc (mb, size_var);
1133         } else if (atype == ATYPE_NORMAL) {
1134                 /* size = vtable->klass->instance_size; */
1135                 mono_mb_emit_ldarg (mb, 0);
1136                 mono_mb_emit_icon (mb, MONO_STRUCT_OFFSET (MonoVTable, klass));
1137                 mono_mb_emit_byte (mb, CEE_ADD);
1138                 mono_mb_emit_byte (mb, CEE_LDIND_I);
1139                 mono_mb_emit_icon (mb, MONO_STRUCT_OFFSET (MonoClass, instance_size));
1140                 mono_mb_emit_byte (mb, CEE_ADD);
1141                 /* FIXME: assert instance_size stays a 4 byte integer */
1142                 mono_mb_emit_byte (mb, CEE_LDIND_U4);
1143                 mono_mb_emit_byte (mb, CEE_CONV_I);
1144                 mono_mb_emit_stloc (mb, size_var);
1145         } else if (atype == ATYPE_VECTOR) {
1146                 MonoExceptionClause *clause;
1147                 int pos, pos_leave, pos_error;
1148                 MonoClass *oom_exc_class;
1149                 MonoMethod *ctor;
1150
1151                 /*
1152                  * n > MONO_ARRAY_MAX_INDEX => OutOfMemoryException
1153                  * n < 0                    => OverflowException
1154                  *
1155                  * We can do an unsigned comparison to catch both cases, then in the error
1156                  * case compare signed to distinguish between them.
1157                  */
1158                 mono_mb_emit_ldarg (mb, 1);
1159                 mono_mb_emit_icon (mb, MONO_ARRAY_MAX_INDEX);
1160                 mono_mb_emit_byte (mb, CEE_CONV_U);
1161                 pos = mono_mb_emit_short_branch (mb, CEE_BLE_UN_S);
1162
1163                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1164                 mono_mb_emit_byte (mb, CEE_MONO_NOT_TAKEN);
1165                 mono_mb_emit_ldarg (mb, 1);
1166                 mono_mb_emit_icon (mb, 0);
1167                 pos_error = mono_mb_emit_short_branch (mb, CEE_BLT_S);
1168                 mono_mb_emit_exception (mb, "OutOfMemoryException", NULL);
1169                 mono_mb_patch_short_branch (mb, pos_error);
1170                 mono_mb_emit_exception (mb, "OverflowException", NULL);
1171
1172                 mono_mb_patch_short_branch (mb, pos);
1173
1174                 clause = (MonoExceptionClause *)mono_image_alloc0 (mono_defaults.corlib, sizeof (MonoExceptionClause));
1175                 clause->try_offset = mono_mb_get_label (mb);
1176
1177                 /* vtable->klass->sizes.element_size */
1178                 mono_mb_emit_ldarg (mb, 0);
1179                 mono_mb_emit_icon (mb, MONO_STRUCT_OFFSET (MonoVTable, klass));
1180                 mono_mb_emit_byte (mb, CEE_ADD);
1181                 mono_mb_emit_byte (mb, CEE_LDIND_I);
1182                 mono_mb_emit_icon (mb, MONO_STRUCT_OFFSET (MonoClass, sizes));
1183                 mono_mb_emit_byte (mb, CEE_ADD);
1184                 mono_mb_emit_byte (mb, CEE_LDIND_U4);
1185                 mono_mb_emit_byte (mb, CEE_CONV_I);
1186
1187                 /* * n */
1188                 mono_mb_emit_ldarg (mb, 1);
1189                 mono_mb_emit_byte (mb, CEE_MUL_OVF_UN);
1190                 /* + sizeof (MonoArray) */
1191                 mono_mb_emit_icon (mb, MONO_SIZEOF_MONO_ARRAY);
1192                 mono_mb_emit_byte (mb, CEE_ADD_OVF_UN);
1193                 mono_mb_emit_stloc (mb, size_var);
1194
1195                 pos_leave = mono_mb_emit_branch (mb, CEE_LEAVE);
1196
1197                 /* catch */
1198                 clause->flags = MONO_EXCEPTION_CLAUSE_NONE;
1199                 clause->try_len = mono_mb_get_pos (mb) - clause->try_offset;
1200                 clause->data.catch_class = mono_class_load_from_name (mono_defaults.corlib,
1201                                 "System", "OverflowException");
1202                 clause->handler_offset = mono_mb_get_label (mb);
1203
1204                 oom_exc_class = mono_class_load_from_name (mono_defaults.corlib,
1205                                 "System", "OutOfMemoryException");
1206                 ctor = mono_class_get_method_from_name (oom_exc_class, ".ctor", 0);
1207                 g_assert (ctor);
1208
1209                 mono_mb_emit_byte (mb, CEE_POP);
1210                 mono_mb_emit_op (mb, CEE_NEWOBJ, ctor);
1211                 mono_mb_emit_byte (mb, CEE_THROW);
1212
1213                 clause->handler_len = mono_mb_get_pos (mb) - clause->handler_offset;
1214                 mono_mb_set_clauses (mb, 1, clause);
1215                 mono_mb_patch_branch (mb, pos_leave);
1216                 /* end catch */
1217         } else if (atype == ATYPE_STRING) {
1218                 int pos;
1219
1220                 /*
1221                  * a string allocator method takes the args: (vtable, len)
1222                  *
1223                  * bytes = offsetof (MonoString, chars) + ((len + 1) * 2)
1224                  *
1225                  * condition:
1226                  *
1227                  * bytes <= INT32_MAX - (SGEN_ALLOC_ALIGN - 1)
1228                  *
1229                  * therefore:
1230                  *
1231                  * offsetof (MonoString, chars) + ((len + 1) * 2) <= INT32_MAX - (SGEN_ALLOC_ALIGN - 1)
1232                  * len <= (INT32_MAX - (SGEN_ALLOC_ALIGN - 1) - offsetof (MonoString, chars)) / 2 - 1
1233                  */
1234                 mono_mb_emit_ldarg (mb, 1);
1235                 mono_mb_emit_icon (mb, (INT32_MAX - (SGEN_ALLOC_ALIGN - 1) - MONO_STRUCT_OFFSET (MonoString, chars)) / 2 - 1);
1236                 pos = mono_mb_emit_short_branch (mb, MONO_CEE_BLE_UN_S);
1237
1238                 mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1239                 mono_mb_emit_byte (mb, CEE_MONO_NOT_TAKEN);
1240                 mono_mb_emit_exception (mb, "OutOfMemoryException", NULL);
1241                 mono_mb_patch_short_branch (mb, pos);
1242
1243                 mono_mb_emit_ldarg (mb, 1);
1244                 mono_mb_emit_icon (mb, 1);
1245                 mono_mb_emit_byte (mb, MONO_CEE_SHL);
1246                 //WE manually fold the above + 2 here
1247                 mono_mb_emit_icon (mb, MONO_STRUCT_OFFSET (MonoString, chars) + 2);
1248                 mono_mb_emit_byte (mb, CEE_ADD);
1249                 mono_mb_emit_stloc (mb, size_var);
1250         } else {
1251                 g_assert_not_reached ();
1252         }
1253
1254 #ifdef MANAGED_ALLOCATOR_CAN_USE_CRITICAL_REGION
1255         EMIT_TLS_ACCESS_IN_CRITICAL_REGION_ADDR (mb, thread_var);
1256         mono_mb_emit_byte (mb, CEE_LDC_I4_1);
1257         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1258         mono_mb_emit_byte (mb, CEE_MONO_ATOMIC_STORE_I4);
1259         mono_mb_emit_i4 (mb, MONO_MEMORY_BARRIER_NONE);
1260 #endif
1261
1262         /* size += ALLOC_ALIGN - 1; */
1263         mono_mb_emit_ldloc (mb, size_var);
1264         mono_mb_emit_icon (mb, SGEN_ALLOC_ALIGN - 1);
1265         mono_mb_emit_byte (mb, CEE_ADD);
1266         /* size &= ~(ALLOC_ALIGN - 1); */
1267         mono_mb_emit_icon (mb, ~(SGEN_ALLOC_ALIGN - 1));
1268         mono_mb_emit_byte (mb, CEE_AND);
1269         mono_mb_emit_stloc (mb, size_var);
1270
1271         /* if (size > MAX_SMALL_OBJ_SIZE) goto slowpath */
1272         if (atype != ATYPE_SMALL) {
1273                 mono_mb_emit_ldloc (mb, size_var);
1274                 mono_mb_emit_icon (mb, SGEN_MAX_SMALL_OBJ_SIZE);
1275                 max_size_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BGT_UN_S);
1276         }
1277
1278         /*
1279          * We need to modify tlab_next, but the JIT only supports reading, so we read
1280          * another tls var holding its address instead.
1281          */
1282
1283         /* tlab_next_addr (local) = tlab_next_addr (TLS var) */
1284         tlab_next_addr_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1285         EMIT_TLS_ACCESS_NEXT_ADDR (mb, thread_var);
1286         mono_mb_emit_stloc (mb, tlab_next_addr_var);
1287
1288         /* p = (void**)tlab_next; */
1289         p_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1290         mono_mb_emit_ldloc (mb, tlab_next_addr_var);
1291         mono_mb_emit_byte (mb, CEE_LDIND_I);
1292         mono_mb_emit_stloc (mb, p_var);
1293
1294         /* new_next = (char*)p + size; */
1295         new_next_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
1296         mono_mb_emit_ldloc (mb, p_var);
1297         mono_mb_emit_ldloc (mb, size_var);
1298         mono_mb_emit_byte (mb, CEE_CONV_I);
1299         mono_mb_emit_byte (mb, CEE_ADD);
1300         mono_mb_emit_stloc (mb, new_next_var);
1301
1302         /* if (G_LIKELY (new_next < tlab_temp_end)) */
1303         mono_mb_emit_ldloc (mb, new_next_var);
1304         EMIT_TLS_ACCESS_TEMP_END (mb, thread_var);
1305         slowpath_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BLT_UN_S);
1306
1307         /* Slowpath */
1308         if (atype != ATYPE_SMALL)
1309                 mono_mb_patch_short_branch (mb, max_size_branch);
1310
1311         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1312         mono_mb_emit_byte (mb, CEE_MONO_NOT_TAKEN);
1313         /*
1314          * We are no longer in a critical section. We need to do this before calling
1315          * to unmanaged land in order to avoid stw deadlocks since unmanaged code
1316          * might take locks.
1317          */
1318 #ifdef MANAGED_ALLOCATOR_CAN_USE_CRITICAL_REGION
1319         EMIT_TLS_ACCESS_IN_CRITICAL_REGION_ADDR (mb, thread_var);
1320         mono_mb_emit_byte (mb, CEE_LDC_I4_0);
1321         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1322         mono_mb_emit_byte (mb, CEE_MONO_ATOMIC_STORE_I4);
1323         mono_mb_emit_i4 (mb, MONO_MEMORY_BARRIER_NONE);
1324 #endif
1325
1326         /* FIXME: mono_gc_alloc_obj takes a 'size_t' as an argument, not an int32 */
1327         mono_mb_emit_ldarg (mb, 0);
1328         mono_mb_emit_ldloc (mb, size_var);
1329         if (atype == ATYPE_NORMAL || atype == ATYPE_SMALL) {
1330                 mono_mb_emit_icall (mb, mono_gc_alloc_obj);
1331         } else if (atype == ATYPE_VECTOR) {
1332                 mono_mb_emit_ldarg (mb, 1);
1333                 mono_mb_emit_icall (mb, mono_gc_alloc_vector);
1334         } else if (atype == ATYPE_STRING) {
1335                 mono_mb_emit_ldarg (mb, 1);
1336                 mono_mb_emit_icall (mb, mono_gc_alloc_string);
1337         } else {
1338                 g_assert_not_reached ();
1339         }
1340         mono_mb_emit_byte (mb, CEE_RET);
1341
1342         /* Fastpath */
1343         mono_mb_patch_short_branch (mb, slowpath_branch);
1344
1345         /* FIXME: Memory barrier */
1346
1347         /* tlab_next = new_next */
1348         mono_mb_emit_ldloc (mb, tlab_next_addr_var);
1349         mono_mb_emit_ldloc (mb, new_next_var);
1350         mono_mb_emit_byte (mb, CEE_STIND_I);
1351
1352         /* *p = vtable; */
1353         mono_mb_emit_ldloc (mb, p_var);
1354         mono_mb_emit_ldarg (mb, 0);
1355         mono_mb_emit_byte (mb, CEE_STIND_I);
1356
1357         if (atype == ATYPE_VECTOR) {
1358                 /* arr->max_length = max_length; */
1359                 mono_mb_emit_ldloc (mb, p_var);
1360                 mono_mb_emit_ldflda (mb, MONO_STRUCT_OFFSET (MonoArray, max_length));
1361                 mono_mb_emit_ldarg (mb, 1);
1362 #ifdef MONO_BIG_ARRAYS
1363                 mono_mb_emit_byte (mb, CEE_STIND_I);
1364 #else
1365                 mono_mb_emit_byte (mb, CEE_STIND_I4);
1366 #endif
1367         } else  if (atype == ATYPE_STRING) {
1368                 /* need to set length and clear the last char */
1369                 /* s->length = len; */
1370                 mono_mb_emit_ldloc (mb, p_var);
1371                 mono_mb_emit_icon (mb, MONO_STRUCT_OFFSET (MonoString, length));
1372                 mono_mb_emit_byte (mb, MONO_CEE_ADD);
1373                 mono_mb_emit_ldarg (mb, 1);
1374                 mono_mb_emit_byte (mb, MONO_CEE_STIND_I4);
1375         }
1376
1377 #ifdef MANAGED_ALLOCATOR_CAN_USE_CRITICAL_REGION
1378         EMIT_TLS_ACCESS_IN_CRITICAL_REGION_ADDR (mb, thread_var);
1379         mono_mb_emit_byte (mb, CEE_LDC_I4_0);
1380         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1381         mono_mb_emit_byte (mb, CEE_MONO_ATOMIC_STORE_I4);
1382 #else
1383         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
1384         mono_mb_emit_byte (mb, CEE_MONO_MEMORY_BARRIER);
1385 #endif
1386         /*
1387         We must make sure both vtable and max_length are globaly visible before returning to managed land.
1388         */
1389         mono_mb_emit_i4 (mb, MONO_MEMORY_BARRIER_REL);
1390
1391         /* return p */
1392         mono_mb_emit_ldloc (mb, p_var);
1393
1394  done:
1395         mono_mb_emit_byte (mb, CEE_RET);
1396 #endif
1397
1398         info = mono_wrapper_info_create (mb, WRAPPER_SUBTYPE_NONE);
1399         info->d.alloc.gc_name = "sgen";
1400         info->d.alloc.alloc_type = atype;
1401
1402 #ifndef DISABLE_JIT
1403         mb->init_locals = FALSE;
1404 #endif
1405
1406         res = mono_mb_create (mb, csig, 8, info);
1407         mono_mb_free (mb);
1408
1409
1410         return res;
1411 }
1412 #endif
1413
1414 int
1415 mono_gc_get_aligned_size_for_allocator (int size)
1416 {
1417         return SGEN_ALIGN_UP (size);
1418 }
1419
1420 /*
1421  * Generate an allocator method implementing the fast path of mono_gc_alloc_obj ().
1422  * The signature of the called method is:
1423  *      object allocate (MonoVTable *vtable)
1424  */
1425 MonoMethod*
1426 mono_gc_get_managed_allocator (MonoClass *klass, gboolean for_box, gboolean known_instance_size)
1427 {
1428 #ifdef MANAGED_ALLOCATION
1429         if (collect_before_allocs)
1430                 return NULL;
1431         if (!mono_runtime_has_tls_get ())
1432                 return NULL;
1433         if (klass->instance_size > tlab_size)
1434                 return NULL;
1435         if (known_instance_size && ALIGN_TO (klass->instance_size, SGEN_ALLOC_ALIGN) >= SGEN_MAX_SMALL_OBJ_SIZE)
1436                 return NULL;
1437         if (mono_class_has_finalizer (klass) || mono_class_is_marshalbyref (klass))
1438                 return NULL;
1439         if (klass->rank)
1440                 return NULL;
1441         if (mono_profiler_get_events () & MONO_PROFILE_ALLOCATIONS)
1442                 return NULL;
1443         if (klass->byval_arg.type == MONO_TYPE_STRING)
1444                 return mono_gc_get_managed_allocator_by_type (ATYPE_STRING, MANAGED_ALLOCATOR_REGULAR);
1445         /* Generic classes have dynamic field and can go above MAX_SMALL_OBJ_SIZE. */
1446         if (known_instance_size)
1447                 return mono_gc_get_managed_allocator_by_type (ATYPE_SMALL, MANAGED_ALLOCATOR_REGULAR);
1448         else
1449                 return mono_gc_get_managed_allocator_by_type (ATYPE_NORMAL, MANAGED_ALLOCATOR_REGULAR);
1450 #else
1451         return NULL;
1452 #endif
1453 }
1454
1455 MonoMethod*
1456 mono_gc_get_managed_array_allocator (MonoClass *klass)
1457 {
1458 #ifdef MANAGED_ALLOCATION
1459         if (klass->rank != 1)
1460                 return NULL;
1461         if (!mono_runtime_has_tls_get ())
1462                 return NULL;
1463         if (mono_profiler_get_events () & MONO_PROFILE_ALLOCATIONS)
1464                 return NULL;
1465         if (has_per_allocation_action)
1466                 return NULL;
1467         g_assert (!mono_class_has_finalizer (klass) && !mono_class_is_marshalbyref (klass));
1468
1469         return mono_gc_get_managed_allocator_by_type (ATYPE_VECTOR, MANAGED_ALLOCATOR_REGULAR);
1470 #else
1471         return NULL;
1472 #endif
1473 }
1474
1475 void
1476 sgen_set_use_managed_allocator (gboolean flag)
1477 {
1478         use_managed_allocator = flag;
1479 }
1480
1481 MonoMethod*
1482 mono_gc_get_managed_allocator_by_type (int atype, ManagedAllocatorVariant variant)
1483 {
1484 #ifdef MANAGED_ALLOCATION
1485         MonoMethod *res;
1486         MonoMethod **cache;
1487
1488         if (variant == MANAGED_ALLOCATOR_REGULAR && !use_managed_allocator)
1489                 return NULL;
1490
1491         if (variant == MANAGED_ALLOCATOR_REGULAR && !mono_runtime_has_tls_get ())
1492                 return NULL;
1493
1494         switch (variant) {
1495         case MANAGED_ALLOCATOR_REGULAR: cache = alloc_method_cache; break;
1496         case MANAGED_ALLOCATOR_SLOW_PATH: cache = slowpath_alloc_method_cache; break;
1497         default: g_assert_not_reached (); break;
1498         }
1499
1500         res = cache [atype];
1501         if (res)
1502                 return res;
1503
1504         res = create_allocator (atype, variant);
1505         LOCK_GC;
1506         if (cache [atype]) {
1507                 mono_free_method (res);
1508                 res = cache [atype];
1509         } else {
1510                 mono_memory_barrier ();
1511                 cache [atype] = res;
1512         }
1513         UNLOCK_GC;
1514
1515         return res;
1516 #else
1517         return NULL;
1518 #endif
1519 }
1520
1521 guint32
1522 mono_gc_get_managed_allocator_types (void)
1523 {
1524         return ATYPE_NUM;
1525 }
1526
1527 gboolean
1528 sgen_is_managed_allocator (MonoMethod *method)
1529 {
1530         int i;
1531
1532         for (i = 0; i < ATYPE_NUM; ++i)
1533                 if (method == alloc_method_cache [i] || method == slowpath_alloc_method_cache [i])
1534                         return TRUE;
1535         return FALSE;
1536 }
1537
1538 gboolean
1539 sgen_has_managed_allocator (void)
1540 {
1541         int i;
1542
1543         for (i = 0; i < ATYPE_NUM; ++i)
1544                 if (alloc_method_cache [i] || slowpath_alloc_method_cache [i])
1545                         return TRUE;
1546         return FALSE;
1547 }
1548
1549 /*
1550  * Cardtable scanning
1551  */
1552
1553 #define MWORD_MASK (sizeof (mword) - 1)
1554
1555 static inline int
1556 find_card_offset (mword card)
1557 {
1558 /*XXX Use assembly as this generates some pretty bad code */
1559 #if defined(__i386__) && defined(__GNUC__)
1560         return  (__builtin_ffs (card) - 1) / 8;
1561 #elif defined(__x86_64__) && defined(__GNUC__)
1562         return (__builtin_ffsll (card) - 1) / 8;
1563 #elif defined(__s390x__)
1564         return (__builtin_ffsll (GUINT64_TO_LE(card)) - 1) / 8;
1565 #else
1566         int i;
1567         guint8 *ptr = (guint8 *) &card;
1568         for (i = 0; i < sizeof (mword); ++i) {
1569                 if (ptr[i])
1570                         return i;
1571         }
1572         return 0;
1573 #endif
1574 }
1575
1576 static guint8*
1577 find_next_card (guint8 *card_data, guint8 *end)
1578 {
1579         mword *cards, *cards_end;
1580         mword card;
1581
1582         while ((((mword)card_data) & MWORD_MASK) && card_data < end) {
1583                 if (*card_data)
1584                         return card_data;
1585                 ++card_data;
1586         }
1587
1588         if (card_data == end)
1589                 return end;
1590
1591         cards = (mword*)card_data;
1592         cards_end = (mword*)((mword)end & ~MWORD_MASK);
1593         while (cards < cards_end) {
1594                 card = *cards;
1595                 if (card)
1596                         return (guint8*)cards + find_card_offset (card);
1597                 ++cards;
1598         }
1599
1600         card_data = (guint8*)cards_end;
1601         while (card_data < end) {
1602                 if (*card_data)
1603                         return card_data;
1604                 ++card_data;
1605         }
1606
1607         return end;
1608 }
1609
1610 #define ARRAY_OBJ_INDEX(ptr,array,elem_size) (((char*)(ptr) - ((char*)(array) + G_STRUCT_OFFSET (MonoArray, vector))) / (elem_size))
1611
1612 gboolean
1613 sgen_client_cardtable_scan_object (GCObject *obj, mword block_obj_size, guint8 *cards, ScanCopyContext ctx)
1614 {
1615         MonoVTable *vt = SGEN_LOAD_VTABLE (obj);
1616         MonoClass *klass = vt->klass;
1617
1618         SGEN_ASSERT (0, SGEN_VTABLE_HAS_REFERENCES (vt), "Why would we ever call this on reference-free objects?");
1619
1620         if (vt->rank) {
1621                 MonoArray *arr = (MonoArray*)obj;
1622                 guint8 *card_data, *card_base;
1623                 guint8 *card_data_end;
1624                 char *obj_start = (char *)sgen_card_table_align_pointer (obj);
1625                 mword bounds_size;
1626                 mword obj_size = sgen_mono_array_size (vt, arr, &bounds_size, sgen_vtable_get_descriptor (vt));
1627                 /* We don't want to scan the bounds entries at the end of multidimensional arrays */
1628                 char *obj_end = (char*)obj + obj_size - bounds_size;
1629                 size_t card_count;
1630                 size_t extra_idx = 0;
1631
1632                 mword desc = (mword)klass->element_class->gc_descr;
1633                 int elem_size = mono_array_element_size (klass);
1634
1635 #ifdef SGEN_HAVE_OVERLAPPING_CARDS
1636                 guint8 *overflow_scan_end = NULL;
1637 #endif
1638
1639 #ifdef SGEN_OBJECT_LAYOUT_STATISTICS
1640                 if (klass->element_class->valuetype)
1641                         sgen_object_layout_scanned_vtype_array ();
1642                 else
1643                         sgen_object_layout_scanned_ref_array ();
1644 #endif
1645
1646                 if (cards)
1647                         card_data = cards;
1648                 else
1649                         card_data = sgen_card_table_get_card_scan_address ((mword)obj);
1650
1651                 card_base = card_data;
1652                 card_count = sgen_card_table_number_of_cards_in_range ((mword)obj, obj_size);
1653                 card_data_end = card_data + card_count;
1654
1655
1656 #ifdef SGEN_HAVE_OVERLAPPING_CARDS
1657                 /*Check for overflow and if so, setup to scan in two steps*/
1658                 if (!cards && card_data_end >= SGEN_SHADOW_CARDTABLE_END) {
1659                         overflow_scan_end = sgen_shadow_cardtable + (card_data_end - SGEN_SHADOW_CARDTABLE_END);
1660                         card_data_end = SGEN_SHADOW_CARDTABLE_END;
1661                 }
1662
1663 LOOP_HEAD:
1664 #endif
1665
1666                 card_data = find_next_card (card_data, card_data_end);
1667                 for (; card_data < card_data_end; card_data = find_next_card (card_data + 1, card_data_end)) {
1668                         size_t index;
1669                         size_t idx = (card_data - card_base) + extra_idx;
1670                         char *start = (char*)(obj_start + idx * CARD_SIZE_IN_BYTES);
1671                         char *card_end = start + CARD_SIZE_IN_BYTES;
1672                         char *first_elem, *elem;
1673
1674                         HEAVY_STAT (++los_marked_cards);
1675
1676                         if (!cards)
1677                                 sgen_card_table_prepare_card_for_scanning (card_data);
1678
1679                         card_end = MIN (card_end, obj_end);
1680
1681                         if (start <= (char*)arr->vector)
1682                                 index = 0;
1683                         else
1684                                 index = ARRAY_OBJ_INDEX (start, obj, elem_size);
1685
1686                         elem = first_elem = (char*)mono_array_addr_with_size_fast ((MonoArray*)obj, elem_size, index);
1687                         if (klass->element_class->valuetype) {
1688                                 ScanVTypeFunc scan_vtype_func = ctx.ops->scan_vtype;
1689
1690                                 for (; elem < card_end; elem += elem_size)
1691                                         scan_vtype_func (obj, elem, desc, ctx.queue BINARY_PROTOCOL_ARG (elem_size));
1692                         } else {
1693                                 ScanPtrFieldFunc scan_ptr_field_func = ctx.ops->scan_ptr_field;
1694
1695                                 HEAVY_STAT (++los_array_cards);
1696                                 for (; elem < card_end; elem += SIZEOF_VOID_P)
1697                                         scan_ptr_field_func (obj, (GCObject**)elem, ctx.queue);
1698                         }
1699
1700                         binary_protocol_card_scan (first_elem, elem - first_elem);
1701                 }
1702
1703 #ifdef SGEN_HAVE_OVERLAPPING_CARDS
1704                 if (overflow_scan_end) {
1705                         extra_idx = card_data - card_base;
1706                         card_base = card_data = sgen_shadow_cardtable;
1707                         card_data_end = overflow_scan_end;
1708                         overflow_scan_end = NULL;
1709                         goto LOOP_HEAD;
1710                 }
1711 #endif
1712                 return TRUE;
1713         }
1714
1715         return FALSE;
1716 }
1717
1718 /*
1719  * Array and string allocation
1720  */
1721
1722 void*
1723 mono_gc_alloc_vector (MonoVTable *vtable, size_t size, uintptr_t max_length)
1724 {
1725         MonoArray *arr;
1726         TLAB_ACCESS_INIT;
1727
1728         if (!SGEN_CAN_ALIGN_UP (size))
1729                 return NULL;
1730
1731 #ifndef DISABLE_CRITICAL_REGION
1732         ENTER_CRITICAL_REGION;
1733         arr = (MonoArray*)sgen_try_alloc_obj_nolock (vtable, size);
1734         if (arr) {
1735                 /*This doesn't require fencing since EXIT_CRITICAL_REGION already does it for us*/
1736                 arr->max_length = (mono_array_size_t)max_length;
1737                 EXIT_CRITICAL_REGION;
1738                 goto done;
1739         }
1740         EXIT_CRITICAL_REGION;
1741 #endif
1742
1743         LOCK_GC;
1744
1745         arr = (MonoArray*)sgen_alloc_obj_nolock (vtable, size);
1746         if (G_UNLIKELY (!arr)) {
1747                 UNLOCK_GC;
1748                 return NULL;
1749         }
1750
1751         arr->max_length = (mono_array_size_t)max_length;
1752
1753         UNLOCK_GC;
1754
1755  done:
1756         if (G_UNLIKELY (alloc_events))
1757                 mono_profiler_allocation (&arr->obj);
1758
1759         SGEN_ASSERT (6, SGEN_ALIGN_UP (size) == SGEN_ALIGN_UP (sgen_client_par_object_get_size (vtable, (GCObject*)arr)), "Vector has incorrect size.");
1760         return arr;
1761 }
1762
1763 void*
1764 mono_gc_alloc_array (MonoVTable *vtable, size_t size, uintptr_t max_length, uintptr_t bounds_size)
1765 {
1766         MonoArray *arr;
1767         MonoArrayBounds *bounds;
1768         TLAB_ACCESS_INIT;
1769
1770         if (!SGEN_CAN_ALIGN_UP (size))
1771                 return NULL;
1772
1773 #ifndef DISABLE_CRITICAL_REGION
1774         ENTER_CRITICAL_REGION;
1775         arr = (MonoArray*)sgen_try_alloc_obj_nolock (vtable, size);
1776         if (arr) {
1777                 /*This doesn't require fencing since EXIT_CRITICAL_REGION already does it for us*/
1778                 arr->max_length = (mono_array_size_t)max_length;
1779
1780                 bounds = (MonoArrayBounds*)((char*)arr + size - bounds_size);
1781                 arr->bounds = bounds;
1782                 EXIT_CRITICAL_REGION;
1783                 goto done;
1784         }
1785         EXIT_CRITICAL_REGION;
1786 #endif
1787
1788         LOCK_GC;
1789
1790         arr = (MonoArray*)sgen_alloc_obj_nolock (vtable, size);
1791         if (G_UNLIKELY (!arr)) {
1792                 UNLOCK_GC;
1793                 return NULL;
1794         }
1795
1796         arr->max_length = (mono_array_size_t)max_length;
1797
1798         bounds = (MonoArrayBounds*)((char*)arr + size - bounds_size);
1799         arr->bounds = bounds;
1800
1801         UNLOCK_GC;
1802
1803  done:
1804         if (G_UNLIKELY (alloc_events))
1805                 mono_profiler_allocation (&arr->obj);
1806
1807         SGEN_ASSERT (6, SGEN_ALIGN_UP (size) == SGEN_ALIGN_UP (sgen_client_par_object_get_size (vtable, (GCObject*)arr)), "Array has incorrect size.");
1808         return arr;
1809 }
1810
1811 void*
1812 mono_gc_alloc_string (MonoVTable *vtable, size_t size, gint32 len)
1813 {
1814         MonoString *str;
1815         TLAB_ACCESS_INIT;
1816
1817         if (!SGEN_CAN_ALIGN_UP (size))
1818                 return NULL;
1819
1820 #ifndef DISABLE_CRITICAL_REGION
1821         ENTER_CRITICAL_REGION;
1822         str = (MonoString*)sgen_try_alloc_obj_nolock (vtable, size);
1823         if (str) {
1824                 /*This doesn't require fencing since EXIT_CRITICAL_REGION already does it for us*/
1825                 str->length = len;
1826                 EXIT_CRITICAL_REGION;
1827                 goto done;
1828         }
1829         EXIT_CRITICAL_REGION;
1830 #endif
1831
1832         LOCK_GC;
1833
1834         str = (MonoString*)sgen_alloc_obj_nolock (vtable, size);
1835         if (G_UNLIKELY (!str)) {
1836                 UNLOCK_GC;
1837                 return NULL;
1838         }
1839
1840         str->length = len;
1841
1842         UNLOCK_GC;
1843
1844  done:
1845         if (G_UNLIKELY (alloc_events))
1846                 mono_profiler_allocation (&str->object);
1847
1848         return str;
1849 }
1850
1851 /*
1852  * Strings
1853  */
1854
1855 void
1856 mono_gc_set_string_length (MonoString *str, gint32 new_length)
1857 {
1858         mono_unichar2 *new_end = str->chars + new_length;
1859
1860         /* zero the discarded string. This null-delimits the string and allows
1861          * the space to be reclaimed by SGen. */
1862
1863         if (nursery_canaries_enabled () && sgen_ptr_in_nursery (str)) {
1864                 CHECK_CANARY_FOR_OBJECT ((GCObject*)str, TRUE);
1865                 memset (new_end, 0, (str->length - new_length + 1) * sizeof (mono_unichar2) + CANARY_SIZE);
1866                 memcpy (new_end + 1 , CANARY_STRING, CANARY_SIZE);
1867         } else {
1868                 memset (new_end, 0, (str->length - new_length + 1) * sizeof (mono_unichar2));
1869         }
1870
1871         str->length = new_length;
1872 }
1873
1874 /*
1875  * Profiling
1876  */
1877
1878 #define GC_ROOT_NUM 32
1879 typedef struct {
1880         int count;              /* must be the first field */
1881         void *objects [GC_ROOT_NUM];
1882         int root_types [GC_ROOT_NUM];
1883         uintptr_t extra_info [GC_ROOT_NUM];
1884 } GCRootReport;
1885
1886 static void
1887 notify_gc_roots (GCRootReport *report)
1888 {
1889         if (!report->count)
1890                 return;
1891         mono_profiler_gc_roots (report->count, report->objects, report->root_types, report->extra_info);
1892         report->count = 0;
1893 }
1894
1895 static void
1896 add_profile_gc_root (GCRootReport *report, void *object, int rtype, uintptr_t extra_info)
1897 {
1898         if (report->count == GC_ROOT_NUM)
1899                 notify_gc_roots (report);
1900         report->objects [report->count] = object;
1901         report->root_types [report->count] = rtype;
1902         report->extra_info [report->count++] = (uintptr_t)SGEN_LOAD_VTABLE (object)->klass;
1903 }
1904
1905 void
1906 sgen_client_nursery_objects_pinned (void **definitely_pinned, int count)
1907 {
1908         if (mono_profiler_get_events () & MONO_PROFILE_GC_ROOTS) {
1909                 GCRootReport report;
1910                 int idx;
1911                 report.count = 0;
1912                 for (idx = 0; idx < count; ++idx)
1913                         add_profile_gc_root (&report, definitely_pinned [idx], MONO_PROFILE_GC_ROOT_PINNING | MONO_PROFILE_GC_ROOT_MISC, 0);
1914                 notify_gc_roots (&report);
1915         }
1916 }
1917
1918 static void
1919 report_finalizer_roots_from_queue (SgenPointerQueue *queue)
1920 {
1921         GCRootReport report;
1922         size_t i;
1923
1924         report.count = 0;
1925         for (i = 0; i < queue->next_slot; ++i) {
1926                 void *obj = queue->data [i];
1927                 if (!obj)
1928                         continue;
1929                 add_profile_gc_root (&report, obj, MONO_PROFILE_GC_ROOT_FINALIZER, 0);
1930         }
1931         notify_gc_roots (&report);
1932 }
1933
1934 static void
1935 report_finalizer_roots (SgenPointerQueue *fin_ready_queue, SgenPointerQueue *critical_fin_queue)
1936 {
1937         report_finalizer_roots_from_queue (fin_ready_queue);
1938         report_finalizer_roots_from_queue (critical_fin_queue);
1939 }
1940
1941 static GCRootReport *root_report;
1942
1943 static void
1944 single_arg_report_root (MonoObject **obj, void *gc_data)
1945 {
1946         if (*obj)
1947                 add_profile_gc_root (root_report, *obj, MONO_PROFILE_GC_ROOT_OTHER, 0);
1948 }
1949
1950 static void
1951 precisely_report_roots_from (GCRootReport *report, void** start_root, void** end_root, mword desc)
1952 {
1953         switch (desc & ROOT_DESC_TYPE_MASK) {
1954         case ROOT_DESC_BITMAP:
1955                 desc >>= ROOT_DESC_TYPE_SHIFT;
1956                 while (desc) {
1957                         if ((desc & 1) && *start_root) {
1958                                 add_profile_gc_root (report, *start_root, MONO_PROFILE_GC_ROOT_OTHER, 0);
1959                         }
1960                         desc >>= 1;
1961                         start_root++;
1962                 }
1963                 return;
1964         case ROOT_DESC_COMPLEX: {
1965                 gsize *bitmap_data = (gsize *)sgen_get_complex_descriptor_bitmap (desc);
1966                 gsize bwords = (*bitmap_data) - 1;
1967                 void **start_run = start_root;
1968                 bitmap_data++;
1969                 while (bwords-- > 0) {
1970                         gsize bmap = *bitmap_data++;
1971                         void **objptr = start_run;
1972                         while (bmap) {
1973                                 if ((bmap & 1) && *objptr) {
1974                                         add_profile_gc_root (report, *objptr, MONO_PROFILE_GC_ROOT_OTHER, 0);
1975                                 }
1976                                 bmap >>= 1;
1977                                 ++objptr;
1978                         }
1979                         start_run += GC_BITS_PER_WORD;
1980                 }
1981                 break;
1982         }
1983         case ROOT_DESC_USER: {
1984                 MonoGCRootMarkFunc marker = (MonoGCRootMarkFunc)sgen_get_user_descriptor_func (desc);
1985                 root_report = report;
1986                 marker ((MonoObject**)start_root, single_arg_report_root, NULL);
1987                 break;
1988         }
1989         case ROOT_DESC_RUN_LEN:
1990                 g_assert_not_reached ();
1991         default:
1992                 g_assert_not_reached ();
1993         }
1994 }
1995
1996 static void
1997 report_registered_roots_by_type (int root_type)
1998 {
1999         GCRootReport report;
2000         void **start_root;
2001         RootRecord *root;
2002         report.count = 0;
2003         SGEN_HASH_TABLE_FOREACH (&roots_hash [root_type], void **, start_root, RootRecord *, root) {
2004                 SGEN_LOG (6, "Precise root scan %p-%p (desc: %p)", start_root, root->end_root, (void*)root->root_desc);
2005                 precisely_report_roots_from (&report, start_root, (void**)root->end_root, root->root_desc);
2006         } SGEN_HASH_TABLE_FOREACH_END;
2007         notify_gc_roots (&report);
2008 }
2009
2010 static void
2011 report_registered_roots (void)
2012 {
2013         report_registered_roots_by_type (ROOT_TYPE_NORMAL);
2014         report_registered_roots_by_type (ROOT_TYPE_WBARRIER);
2015 }
2016
2017 void
2018 sgen_client_collecting_minor (SgenPointerQueue *fin_ready_queue, SgenPointerQueue *critical_fin_queue)
2019 {
2020         if (mono_profiler_get_events () & MONO_PROFILE_GC_ROOTS)
2021                 report_registered_roots ();
2022         if (mono_profiler_get_events () & MONO_PROFILE_GC_ROOTS)
2023                 report_finalizer_roots (fin_ready_queue, critical_fin_queue);
2024 }
2025
2026 static GCRootReport major_root_report;
2027 static gboolean profile_roots;
2028
2029 void
2030 sgen_client_collecting_major_1 (void)
2031 {
2032         profile_roots = mono_profiler_get_events () & MONO_PROFILE_GC_ROOTS;
2033         memset (&major_root_report, 0, sizeof (GCRootReport));
2034 }
2035
2036 void
2037 sgen_client_pinned_los_object (GCObject *obj)
2038 {
2039         if (profile_roots)
2040                 add_profile_gc_root (&major_root_report, (char*)obj, MONO_PROFILE_GC_ROOT_PINNING | MONO_PROFILE_GC_ROOT_MISC, 0);
2041 }
2042
2043 void
2044 sgen_client_collecting_major_2 (void)
2045 {
2046         if (profile_roots)
2047                 notify_gc_roots (&major_root_report);
2048
2049         if (mono_profiler_get_events () & MONO_PROFILE_GC_ROOTS)
2050                 report_registered_roots ();
2051 }
2052
2053 void
2054 sgen_client_collecting_major_3 (SgenPointerQueue *fin_ready_queue, SgenPointerQueue *critical_fin_queue)
2055 {
2056         if (mono_profiler_get_events () & MONO_PROFILE_GC_ROOTS)
2057                 report_finalizer_roots (fin_ready_queue, critical_fin_queue);
2058 }
2059
2060 #define MOVED_OBJECTS_NUM 64
2061 static void *moved_objects [MOVED_OBJECTS_NUM];
2062 static int moved_objects_idx = 0;
2063
2064 void
2065 mono_sgen_register_moved_object (void *obj, void *destination)
2066 {
2067         g_assert (mono_profiler_events & MONO_PROFILE_GC_MOVES);
2068
2069         if (moved_objects_idx == MOVED_OBJECTS_NUM) {
2070                 mono_profiler_gc_moves (moved_objects, moved_objects_idx);
2071                 moved_objects_idx = 0;
2072         }
2073         moved_objects [moved_objects_idx++] = obj;
2074         moved_objects [moved_objects_idx++] = destination;
2075 }
2076
2077 void
2078 mono_sgen_gc_event_moves (void)
2079 {
2080         if (moved_objects_idx) {
2081                 mono_profiler_gc_moves (moved_objects, moved_objects_idx);
2082                 moved_objects_idx = 0;
2083         }
2084 }
2085
2086 /*
2087  * Heap walking
2088  */
2089
2090 #define REFS_SIZE 128
2091 typedef struct {
2092         void *data;
2093         MonoGCReferences callback;
2094         int flags;
2095         int count;
2096         int called;
2097         MonoObject *refs [REFS_SIZE];
2098         uintptr_t offsets [REFS_SIZE];
2099 } HeapWalkInfo;
2100
2101 #undef HANDLE_PTR
2102 #define HANDLE_PTR(ptr,obj)     do {    \
2103                 if (*(ptr)) {   \
2104                         if (hwi->count == REFS_SIZE) {  \
2105                                 hwi->callback ((MonoObject*)start, mono_object_class (start), hwi->called? 0: size, hwi->count, hwi->refs, hwi->offsets, hwi->data);    \
2106                                 hwi->count = 0; \
2107                                 hwi->called = 1;        \
2108                         }       \
2109                         hwi->offsets [hwi->count] = (char*)(ptr)-(char*)start;  \
2110                         hwi->refs [hwi->count++] = *(ptr);      \
2111                 }       \
2112         } while (0)
2113
2114 static void
2115 collect_references (HeapWalkInfo *hwi, GCObject *obj, size_t size)
2116 {
2117         char *start = (char*)obj;
2118         mword desc = sgen_obj_get_descriptor (obj);
2119
2120 #include "sgen/sgen-scan-object.h"
2121 }
2122
2123 static void
2124 walk_references (GCObject *start, size_t size, void *data)
2125 {
2126         HeapWalkInfo *hwi = (HeapWalkInfo *)data;
2127         hwi->called = 0;
2128         hwi->count = 0;
2129         collect_references (hwi, start, size);
2130         if (hwi->count || !hwi->called)
2131                 hwi->callback (start, mono_object_class (start), hwi->called? 0: size, hwi->count, hwi->refs, hwi->offsets, hwi->data);
2132 }
2133
2134 /**
2135  * mono_gc_walk_heap:
2136  * @flags: flags for future use
2137  * @callback: a function pointer called for each object in the heap
2138  * @data: a user data pointer that is passed to callback
2139  *
2140  * This function can be used to iterate over all the live objects in the heap:
2141  * for each object, @callback is invoked, providing info about the object's
2142  * location in memory, its class, its size and the objects it references.
2143  * For each referenced object it's offset from the object address is
2144  * reported in the offsets array.
2145  * The object references may be buffered, so the callback may be invoked
2146  * multiple times for the same object: in all but the first call, the size
2147  * argument will be zero.
2148  * Note that this function can be only called in the #MONO_GC_EVENT_PRE_START_WORLD
2149  * profiler event handler.
2150  *
2151  * Returns: a non-zero value if the GC doesn't support heap walking
2152  */
2153 int
2154 mono_gc_walk_heap (int flags, MonoGCReferences callback, void *data)
2155 {
2156         HeapWalkInfo hwi;
2157
2158         hwi.flags = flags;
2159         hwi.callback = callback;
2160         hwi.data = data;
2161
2162         sgen_clear_nursery_fragments ();
2163         sgen_scan_area_with_callback (nursery_section->data, nursery_section->end_data, walk_references, &hwi, FALSE, TRUE);
2164
2165         major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_ALL, walk_references, &hwi);
2166         sgen_los_iterate_objects (walk_references, &hwi);
2167
2168         return 0;
2169 }
2170
2171 /*
2172  * Threads
2173  */
2174
2175 void
2176 mono_gc_set_gc_callbacks (MonoGCCallbacks *callbacks)
2177 {
2178         gc_callbacks = *callbacks;
2179 }
2180
2181 MonoGCCallbacks *
2182 mono_gc_get_gc_callbacks ()
2183 {
2184         return &gc_callbacks;
2185 }
2186
2187 void
2188 sgen_client_thread_register (SgenThreadInfo* info, void *stack_bottom_fallback)
2189 {
2190         size_t stsize = 0;
2191         guint8 *staddr = NULL;
2192
2193 #ifndef HAVE_KW_THREAD
2194         g_assert (!mono_native_tls_get_value (thread_info_key));
2195         mono_native_tls_set_value (thread_info_key, info);
2196 #else
2197         sgen_thread_info = info;
2198 #endif
2199
2200         info->client_info.skip = 0;
2201         info->client_info.stopped_ip = NULL;
2202         info->client_info.stopped_domain = NULL;
2203
2204         info->client_info.stack_start = NULL;
2205
2206 #ifdef SGEN_POSIX_STW
2207         info->client_info.stop_count = -1;
2208         info->client_info.signal = 0;
2209 #endif
2210
2211         /* On win32, stack_start_limit should be 0, since the stack can grow dynamically */
2212         mono_thread_info_get_stack_bounds (&staddr, &stsize);
2213         if (staddr) {
2214 #ifndef HOST_WIN32
2215                 info->client_info.stack_start_limit = staddr;
2216 #endif
2217                 info->client_info.stack_end = staddr + stsize;
2218         } else {
2219                 gsize stack_bottom = (gsize)stack_bottom_fallback;
2220                 stack_bottom += 4095;
2221                 stack_bottom &= ~4095;
2222                 info->client_info.stack_end = (char*)stack_bottom;
2223         }
2224
2225         memset (&info->client_info.ctx, 0, sizeof (MonoContext));
2226
2227         if (mono_gc_get_gc_callbacks ()->thread_attach_func)
2228                 info->client_info.runtime_data = mono_gc_get_gc_callbacks ()->thread_attach_func ();
2229
2230         binary_protocol_thread_register ((gpointer)mono_thread_info_get_tid (info));
2231
2232         SGEN_LOG (3, "registered thread %p (%p) stack end %p", info, (gpointer)mono_thread_info_get_tid (info), info->client_info.stack_end);
2233
2234         info->client_info.info.handle_stack = mono_handle_stack_alloc ();
2235 }
2236
2237 void
2238 sgen_client_thread_unregister (SgenThreadInfo *p)
2239 {
2240         MonoNativeThreadId tid;
2241
2242 #ifndef HAVE_KW_THREAD
2243         mono_native_tls_set_value (thread_info_key, NULL);
2244 #else
2245         sgen_thread_info = NULL;
2246 #endif
2247
2248         tid = mono_thread_info_get_tid (p);
2249
2250         if (p->client_info.info.runtime_thread)
2251                 mono_threads_add_joinable_thread ((gpointer)tid);
2252
2253         if (mono_gc_get_gc_callbacks ()->thread_detach_func) {
2254                 mono_gc_get_gc_callbacks ()->thread_detach_func (p->client_info.runtime_data);
2255                 p->client_info.runtime_data = NULL;
2256         }
2257
2258         binary_protocol_thread_unregister ((gpointer)tid);
2259         SGEN_LOG (3, "unregister thread %p (%p)", p, (gpointer)tid);
2260
2261         HandleStack *handles = (HandleStack*) p->client_info.info.handle_stack;
2262         p->client_info.info.handle_stack = NULL;
2263         mono_handle_stack_free (handles);
2264 }
2265
2266 void
2267 mono_gc_set_skip_thread (gboolean skip)
2268 {
2269         SgenThreadInfo *info = mono_thread_info_current ();
2270
2271         LOCK_GC;
2272         info->client_info.gc_disabled = skip;
2273         UNLOCK_GC;
2274 }
2275
2276 static gboolean
2277 is_critical_method (MonoMethod *method)
2278 {
2279         return mono_runtime_is_critical_method (method) || sgen_is_critical_method (method);
2280 }
2281
2282 static gboolean
2283 thread_in_critical_region (SgenThreadInfo *info)
2284 {
2285         return info->client_info.in_critical_region;
2286 }
2287
2288 static void
2289 sgen_thread_attach (SgenThreadInfo *info)
2290 {
2291         if (mono_gc_get_gc_callbacks ()->thread_attach_func && !info->client_info.runtime_data)
2292                 info->client_info.runtime_data = mono_gc_get_gc_callbacks ()->thread_attach_func ();
2293 }
2294
2295 static void
2296 sgen_thread_detach (SgenThreadInfo *p)
2297 {
2298         /* If a delegate is passed to native code and invoked on a thread we dont
2299          * know about, marshal will register it with mono_threads_attach_coop, but
2300          * we have no way of knowing when that thread goes away.  SGen has a TSD
2301          * so we assume that if the domain is still registered, we can detach
2302          * the thread
2303          */
2304         if (mono_thread_internal_current_is_attached ())
2305                 mono_thread_detach_internal (mono_thread_internal_current ());
2306 }
2307
2308 gboolean
2309 mono_gc_register_thread (void *baseptr)
2310 {
2311         return mono_thread_info_attach (baseptr) != NULL;
2312 }
2313
2314 gboolean
2315 mono_gc_is_gc_thread (void)
2316 {
2317         gboolean result;
2318         LOCK_GC;
2319         result = mono_thread_info_current () != NULL;
2320         UNLOCK_GC;
2321         return result;
2322 }
2323
2324 void
2325 sgen_client_thread_register_worker (void)
2326 {
2327         mono_thread_info_register_small_id ();
2328         mono_native_thread_set_name (mono_native_thread_id_get (), "SGen worker");
2329 }
2330
2331 /* Variables holding start/end nursery so it won't have to be passed at every call */
2332 static void *scan_area_arg_start, *scan_area_arg_end;
2333
2334 void
2335 mono_gc_conservatively_scan_area (void *start, void *end)
2336 {
2337         sgen_conservatively_pin_objects_from ((void **)start, (void **)end, scan_area_arg_start, scan_area_arg_end, PIN_TYPE_STACK);
2338 }
2339
2340 void*
2341 mono_gc_scan_object (void *obj, void *gc_data)
2342 {
2343         ScanCopyContext *ctx = (ScanCopyContext *)gc_data;
2344         ctx->ops->copy_or_mark_object ((GCObject**)&obj, ctx->queue);
2345         return obj;
2346 }
2347
2348 /*
2349  * Mark from thread stacks and registers.
2350  */
2351 void
2352 sgen_client_scan_thread_data (void *start_nursery, void *end_nursery, gboolean precise, ScanCopyContext ctx)
2353 {
2354         scan_area_arg_start = start_nursery;
2355         scan_area_arg_end = end_nursery;
2356
2357         FOREACH_THREAD (info) {
2358                 int skip_reason = 0;
2359                 void *aligned_stack_start;
2360
2361                 if (info->client_info.skip) {
2362                         SGEN_LOG (3, "Skipping dead thread %p, range: %p-%p, size: %zd", info, info->client_info.stack_start, info->client_info.stack_end, (char*)info->client_info.stack_end - (char*)info->client_info.stack_start);
2363                         skip_reason = 1;
2364                 } else if (info->client_info.gc_disabled) {
2365                         SGEN_LOG (3, "GC disabled for thread %p, range: %p-%p, size: %zd", info, info->client_info.stack_start, info->client_info.stack_end, (char*)info->client_info.stack_end - (char*)info->client_info.stack_start);
2366                         skip_reason = 2;
2367                 } else if (!mono_thread_info_is_live (info)) {
2368                         SGEN_LOG (3, "Skipping non-running thread %p, range: %p-%p, size: %zd (state %x)", info, info->client_info.stack_start, info->client_info.stack_end, (char*)info->client_info.stack_end - (char*)info->client_info.stack_start, info->client_info.info.thread_state);
2369                         skip_reason = 3;
2370                 } else if (!info->client_info.stack_start) {
2371                         SGEN_LOG (3, "Skipping starting or detaching thread %p", info);
2372                         skip_reason = 4;
2373                 }
2374
2375                 binary_protocol_scan_stack ((gpointer)mono_thread_info_get_tid (info), info->client_info.stack_start, info->client_info.stack_end, skip_reason);
2376
2377                 if (skip_reason)
2378                         continue;
2379
2380                 g_assert (info->client_info.stack_start);
2381                 g_assert (info->client_info.stack_end);
2382
2383                 aligned_stack_start = (void*)(mword) ALIGN_TO ((mword)info->client_info.stack_start, SIZEOF_VOID_P);
2384 #ifdef HOST_WIN32
2385                 /* Windows uses a guard page before the committed stack memory pages to detect when the
2386                    stack needs to be grown. If we suspend a thread just after a function prolog has
2387                    decremented the stack pointer to point into the guard page but before the thread has
2388                    been able to read or write to that page, starting the stack scan at aligned_stack_start
2389                    will raise a STATUS_GUARD_PAGE_VIOLATION and the process will crash. This code uses
2390                    VirtualQuery() to determine whether stack_start points into the guard page and then
2391                    updates aligned_stack_start to point at the next non-guard page. */
2392                 MEMORY_BASIC_INFORMATION mem_info;
2393                 SIZE_T result = VirtualQuery(info->client_info.stack_start, &mem_info, sizeof(mem_info));
2394                 g_assert (result != 0);
2395                 if (mem_info.Protect & PAGE_GUARD) {
2396                         aligned_stack_start = ((char*) mem_info.BaseAddress) + mem_info.RegionSize;
2397                 }
2398 #endif
2399
2400                 g_assert (info->client_info.suspend_done);
2401                 SGEN_LOG (3, "Scanning thread %p, range: %p-%p, size: %zd, pinned=%zd", info, info->client_info.stack_start, info->client_info.stack_end, (char*)info->client_info.stack_end - (char*)info->client_info.stack_start, sgen_get_pinned_count ());
2402                 if (mono_gc_get_gc_callbacks ()->thread_mark_func && !conservative_stack_mark) {
2403                         mono_gc_get_gc_callbacks ()->thread_mark_func (info->client_info.runtime_data, (guint8 *)aligned_stack_start, (guint8 *)info->client_info.stack_end, precise, &ctx);
2404                 } else if (!precise) {
2405                         if (!conservative_stack_mark) {
2406                                 fprintf (stderr, "Precise stack mark not supported - disabling.\n");
2407                                 conservative_stack_mark = TRUE;
2408                         }
2409                         //FIXME we should eventually use the new stack_mark from coop
2410                         sgen_conservatively_pin_objects_from ((void **)aligned_stack_start, (void **)info->client_info.stack_end, start_nursery, end_nursery, PIN_TYPE_STACK);
2411                 }
2412
2413                 if (!precise) {
2414                         sgen_conservatively_pin_objects_from ((void**)&info->client_info.ctx, (void**)(&info->client_info.ctx + 1),
2415                                 start_nursery, end_nursery, PIN_TYPE_STACK);
2416
2417                         {
2418                                 // This is used on Coop GC for platforms where we cannot get the data for individual registers.
2419                                 // We force a spill of all registers into the stack and pass a chunk of data into sgen.
2420                                 //FIXME under coop, for now, what we need to ensure is that we scan any extra memory from info->client_info.stack_end to stack_mark
2421                                 MonoThreadUnwindState *state = &info->client_info.info.thread_saved_state [SELF_SUSPEND_STATE_INDEX];
2422                                 if (state && state->gc_stackdata) {
2423                                         sgen_conservatively_pin_objects_from ((void **)state->gc_stackdata, (void**)((char*)state->gc_stackdata + state->gc_stackdata_size),
2424                                                 start_nursery, end_nursery, PIN_TYPE_STACK);
2425                                 }
2426                         }
2427                 }
2428                 if (precise && info->client_info.info.handle_stack) {
2429                         mono_handle_stack_scan ((HandleStack*)info->client_info.info.handle_stack, (GcScanFunc)ctx.ops->copy_or_mark_object, ctx.queue);
2430                 }
2431         } FOREACH_THREAD_END
2432 }
2433
2434 /*
2435  * mono_gc_set_stack_end:
2436  *
2437  *   Set the end of the current threads stack to STACK_END. The stack space between
2438  * STACK_END and the real end of the threads stack will not be scanned during collections.
2439  */
2440 void
2441 mono_gc_set_stack_end (void *stack_end)
2442 {
2443         SgenThreadInfo *info;
2444
2445         LOCK_GC;
2446         info = mono_thread_info_current ();
2447         if (info) {
2448                 SGEN_ASSERT (0, stack_end < info->client_info.stack_end, "Can only lower stack end");
2449                 info->client_info.stack_end = stack_end;
2450         }
2451         UNLOCK_GC;
2452 }
2453
2454 /*
2455  * Roots
2456  */
2457
2458 int
2459 mono_gc_register_root (char *start, size_t size, MonoGCDescriptor descr, MonoGCRootSource source, const char *msg)
2460 {
2461         return sgen_register_root (start, size, descr, descr ? ROOT_TYPE_NORMAL : ROOT_TYPE_PINNED, source, msg);
2462 }
2463
2464 int
2465 mono_gc_register_root_wbarrier (char *start, size_t size, MonoGCDescriptor descr, MonoGCRootSource source, const char *msg)
2466 {
2467         return sgen_register_root (start, size, descr, ROOT_TYPE_WBARRIER, source, msg);
2468 }
2469
2470 void
2471 mono_gc_deregister_root (char* addr)
2472 {
2473         sgen_deregister_root (addr);
2474 }
2475
2476 /*
2477  * PThreads
2478  */
2479
2480 #ifndef HOST_WIN32
2481 int
2482 mono_gc_pthread_create (pthread_t *new_thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
2483 {
2484         return pthread_create (new_thread, attr, start_routine, arg);
2485 }
2486 #endif
2487
2488 /*
2489  * Miscellaneous
2490  */
2491
2492 void
2493 sgen_client_total_allocated_heap_changed (size_t allocated_heap)
2494 {
2495         mono_runtime_resource_check_limit (MONO_RESOURCE_GC_HEAP, allocated_heap);
2496 }
2497
2498 gboolean
2499 mono_gc_user_markers_supported (void)
2500 {
2501         return TRUE;
2502 }
2503
2504 gboolean
2505 mono_object_is_alive (MonoObject* o)
2506 {
2507         return TRUE;
2508 }
2509
2510 int
2511 mono_gc_get_generation (MonoObject *obj)
2512 {
2513         if (sgen_ptr_in_nursery (obj))
2514                 return 0;
2515         return 1;
2516 }
2517
2518 void
2519 mono_gc_enable_events (void)
2520 {
2521 }
2522
2523 const char *
2524 mono_gc_get_gc_name (void)
2525 {
2526         return "sgen";
2527 }
2528
2529 char*
2530 mono_gc_get_description (void)
2531 {
2532 #ifdef HAVE_CONC_GC_AS_DEFAULT
2533         return g_strdup ("sgen (concurrent by default)");
2534 #else
2535         return g_strdup ("sgen");
2536 #endif
2537 }
2538
2539 void
2540 mono_gc_set_desktop_mode (void)
2541 {
2542 }
2543
2544 gboolean
2545 mono_gc_is_moving (void)
2546 {
2547         return TRUE;
2548 }
2549
2550 gboolean
2551 mono_gc_is_disabled (void)
2552 {
2553         return FALSE;
2554 }
2555
2556 #ifdef HOST_WIN32
2557 BOOL APIENTRY mono_gc_dllmain (HMODULE module_handle, DWORD reason, LPVOID reserved)
2558 {
2559         return TRUE;
2560 }
2561 #endif
2562
2563 int
2564 mono_gc_max_generation (void)
2565 {
2566         return 1;
2567 }
2568
2569 gboolean
2570 mono_gc_precise_stack_mark_enabled (void)
2571 {
2572         return !conservative_stack_mark;
2573 }
2574
2575 void
2576 mono_gc_collect (int generation)
2577 {
2578         sgen_gc_collect (generation);
2579 }
2580
2581 int
2582 mono_gc_collection_count (int generation)
2583 {
2584         return sgen_gc_collection_count (generation);
2585 }
2586
2587 int64_t
2588 mono_gc_get_used_size (void)
2589 {
2590         return (int64_t)sgen_gc_get_used_size ();
2591 }
2592
2593 int64_t
2594 mono_gc_get_heap_size (void)
2595 {
2596         return (int64_t)sgen_gc_get_total_heap_allocation ();
2597 }
2598
2599 MonoGCDescriptor
2600 mono_gc_make_root_descr_user (MonoGCRootMarkFunc marker)
2601 {
2602         return sgen_make_user_root_descriptor (marker);
2603 }
2604
2605 MonoGCDescriptor
2606 mono_gc_make_descr_for_string (gsize *bitmap, int numbits)
2607 {
2608         return SGEN_DESC_STRING;
2609 }
2610
2611 void*
2612 mono_gc_get_nursery (int *shift_bits, size_t *size)
2613 {
2614         *size = sgen_nursery_size;
2615         *shift_bits = DEFAULT_NURSERY_BITS;
2616         return sgen_get_nursery_start ();
2617 }
2618
2619 int
2620 mono_gc_get_los_limit (void)
2621 {
2622         return SGEN_MAX_SMALL_OBJ_SIZE;
2623 }
2624
2625 gpointer
2626 sgen_client_default_metadata (void)
2627 {
2628         return mono_domain_get ();
2629 }
2630
2631 gpointer
2632 sgen_client_metadata_for_object (GCObject *obj)
2633 {
2634         return mono_object_domain (obj);
2635 }
2636
2637 /**
2638  * mono_gchandle_is_in_domain:
2639  * @gchandle: a GCHandle's handle.
2640  * @domain: An application domain.
2641  *
2642  * Returns: TRUE if the object wrapped by the @gchandle belongs to the specific @domain.
2643  */
2644 gboolean
2645 mono_gchandle_is_in_domain (guint32 gchandle, MonoDomain *domain)
2646 {
2647         MonoDomain *gchandle_domain = (MonoDomain *)sgen_gchandle_get_metadata (gchandle);
2648         return domain->domain_id == gchandle_domain->domain_id;
2649 }
2650
2651 /**
2652  * mono_gchandle_free_domain:
2653  * @unloading: domain that is unloading
2654  *
2655  * Function used internally to cleanup any GC handle for objects belonging
2656  * to the specified domain during appdomain unload.
2657  */
2658 void
2659 mono_gchandle_free_domain (MonoDomain *unloading)
2660 {
2661 }
2662
2663 static gpointer
2664 null_link_if_in_domain (gpointer hidden, GCHandleType handle_type, int max_generation, gpointer user)
2665 {
2666         MonoDomain *unloading_domain = (MonoDomain *)user;
2667         MonoDomain *obj_domain;
2668         gboolean is_weak = MONO_GC_HANDLE_TYPE_IS_WEAK (handle_type);
2669         if (MONO_GC_HANDLE_IS_OBJECT_POINTER (hidden)) {
2670                 MonoObject *obj = (MonoObject *)MONO_GC_REVEAL_POINTER (hidden, is_weak);
2671                 obj_domain = mono_object_domain (obj);
2672         } else {
2673                 obj_domain = (MonoDomain *)MONO_GC_REVEAL_POINTER (hidden, is_weak);
2674         }
2675         if (unloading_domain->domain_id == obj_domain->domain_id)
2676                 return NULL;
2677         return hidden;
2678 }
2679
2680 void
2681 sgen_null_links_for_domain (MonoDomain *domain)
2682 {
2683         guint type;
2684         for (type = HANDLE_TYPE_MIN; type < HANDLE_TYPE_MAX; ++type)
2685                 sgen_gchandle_iterate ((GCHandleType)type, GENERATION_OLD, null_link_if_in_domain, domain);
2686 }
2687
2688 void
2689 mono_gchandle_set_target (guint32 gchandle, MonoObject *obj)
2690 {
2691         sgen_gchandle_set_target (gchandle, obj);
2692 }
2693
2694 void
2695 sgen_client_gchandle_created (int handle_type, GCObject *obj, guint32 handle)
2696 {
2697 #ifndef DISABLE_PERFCOUNTERS
2698         mono_perfcounters->gc_num_handles++;
2699 #endif
2700         mono_profiler_gc_handle (MONO_PROFILER_GC_HANDLE_CREATED, handle_type, handle, obj);
2701 }
2702
2703 void
2704 sgen_client_gchandle_destroyed (int handle_type, guint32 handle)
2705 {
2706 #ifndef DISABLE_PERFCOUNTERS
2707         mono_perfcounters->gc_num_handles--;
2708 #endif
2709         mono_profiler_gc_handle (MONO_PROFILER_GC_HANDLE_DESTROYED, handle_type, handle, NULL);
2710 }
2711
2712 void
2713 sgen_client_ensure_weak_gchandles_accessible (void)
2714 {
2715         /*
2716          * During the second bridge processing step the world is
2717          * running again.  That step processes all weak links once
2718          * more to null those that refer to dead objects.  Before that
2719          * is completed, those links must not be followed, so we
2720          * conservatively wait for bridge processing when any weak
2721          * link is dereferenced.
2722          */
2723         /* FIXME: A GC can occur after this check fails, in which case we
2724          * should wait for bridge processing but would fail to do so.
2725          */
2726         if (G_UNLIKELY (bridge_processing_in_progress))
2727                 mono_gc_wait_for_bridge_processing ();
2728 }
2729
2730 void*
2731 mono_gc_invoke_with_gc_lock (MonoGCLockedCallbackFunc func, void *data)
2732 {
2733         void *result;
2734         LOCK_INTERRUPTION;
2735         result = func (data);
2736         UNLOCK_INTERRUPTION;
2737         return result;
2738 }
2739
2740 void
2741 mono_gc_register_altstack (gpointer stack, gint32 stack_size, gpointer altstack, gint32 altstack_size)
2742 {
2743         // FIXME:
2744 }
2745
2746 guint8*
2747 mono_gc_get_card_table (int *shift_bits, gpointer *mask)
2748 {
2749         return sgen_get_card_table_configuration (shift_bits, mask);
2750 }
2751
2752 gboolean
2753 mono_gc_card_table_nursery_check (void)
2754 {
2755         return !sgen_get_major_collector ()->is_concurrent;
2756 }
2757
2758 /* Negative value to remove */
2759 void
2760 mono_gc_add_memory_pressure (gint64 value)
2761 {
2762         /* FIXME: Implement at some point? */
2763 }
2764
2765 /*
2766  * Logging
2767  */
2768
2769 void
2770 sgen_client_degraded_allocation (size_t size)
2771 {
2772         static int last_major_gc_warned = -1;
2773         static int num_degraded = 0;
2774
2775         if (last_major_gc_warned < (int)gc_stats.major_gc_count) {
2776                 ++num_degraded;
2777                 if (num_degraded == 1 || num_degraded == 3)
2778                         mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC, "Warning: Degraded allocation.  Consider increasing nursery-size if the warning persists.");
2779                 else if (num_degraded == 10)
2780                         mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC, "Warning: Repeated degraded allocation.  Consider increasing nursery-size.");
2781                 last_major_gc_warned = gc_stats.major_gc_count;
2782         }
2783 }
2784
2785 /*
2786  * Debugging
2787  */
2788
2789 const char*
2790 sgen_client_description_for_internal_mem_type (int type)
2791 {
2792         switch (type) {
2793         case INTERNAL_MEM_EPHEMERON_LINK: return "ephemeron-link";
2794         default:
2795                 return NULL;
2796         }
2797 }
2798
2799 void
2800 sgen_client_pre_collection_checks (void)
2801 {
2802         if (sgen_mono_xdomain_checks) {
2803                 sgen_clear_nursery_fragments ();
2804                 sgen_check_for_xdomain_refs ();
2805         }
2806 }
2807
2808 gboolean
2809 sgen_client_vtable_is_inited (MonoVTable *vt)
2810 {
2811         return vt->klass->inited;
2812 }
2813
2814 const char*
2815 sgen_client_vtable_get_namespace (MonoVTable *vt)
2816 {
2817         return vt->klass->name_space;
2818 }
2819
2820 const char*
2821 sgen_client_vtable_get_name (MonoVTable *vt)
2822 {
2823         return vt->klass->name;
2824 }
2825
2826 /*
2827  * Initialization
2828  */
2829
2830 void
2831 sgen_client_init (void)
2832 {
2833         int dummy;
2834         MonoThreadInfoCallbacks cb;
2835
2836         cb.thread_register = sgen_thread_register;
2837         cb.thread_detach = sgen_thread_detach;
2838         cb.thread_unregister = sgen_thread_unregister;
2839         cb.thread_attach = sgen_thread_attach;
2840         cb.mono_method_is_critical = (gboolean (*)(void *))is_critical_method;
2841         cb.mono_thread_in_critical_region = thread_in_critical_region;
2842
2843         mono_threads_init (&cb, sizeof (SgenThreadInfo));
2844
2845         ///* Keep this the default for now */
2846         /* Precise marking is broken on all supported targets. Disable until fixed. */
2847         conservative_stack_mark = TRUE;
2848
2849         sgen_register_fixed_internal_mem_type (INTERNAL_MEM_EPHEMERON_LINK, sizeof (EphemeronLinkNode));
2850
2851         mono_sgen_init_stw ();
2852
2853 #ifndef HAVE_KW_THREAD
2854         mono_native_tls_alloc (&thread_info_key, NULL);
2855 #if defined(TARGET_OSX) || defined(TARGET_WIN32) || defined(TARGET_ANDROID) || defined(TARGET_IOS)
2856         /*
2857          * CEE_MONO_TLS requires the tls offset, not the key, so the code below only works on darwin,
2858          * where the two are the same.
2859          */
2860         mono_tls_key_set_offset (TLS_KEY_SGEN_THREAD_INFO, thread_info_key);
2861 #endif
2862 #else
2863         {
2864                 int tls_offset = -1;
2865                 MONO_THREAD_VAR_OFFSET (sgen_thread_info, tls_offset);
2866                 mono_tls_key_set_offset (TLS_KEY_SGEN_THREAD_INFO, tls_offset);
2867         }
2868 #endif
2869
2870         /*
2871          * This needs to happen before any internal allocations because
2872          * it inits the small id which is required for hazard pointer
2873          * operations.
2874          */
2875         sgen_os_init ();
2876
2877         mono_gc_register_thread (&dummy);
2878 }
2879
2880 gboolean
2881 sgen_client_handle_gc_param (const char *opt)
2882 {
2883         if (g_str_has_prefix (opt, "stack-mark=")) {
2884                 opt = strchr (opt, '=') + 1;
2885                 if (!strcmp (opt, "precise")) {
2886                         conservative_stack_mark = FALSE;
2887                 } else if (!strcmp (opt, "conservative")) {
2888                         conservative_stack_mark = TRUE;
2889                 } else {
2890                         sgen_env_var_error (MONO_GC_PARAMS_NAME, conservative_stack_mark ? "Using `conservative`." : "Using `precise`.",
2891                                         "Invalid value `%s` for `stack-mark` option, possible values are: `precise`, `conservative`.", opt);
2892                 }
2893         } else if (g_str_has_prefix (opt, "bridge-implementation=")) {
2894                 opt = strchr (opt, '=') + 1;
2895                 sgen_set_bridge_implementation (opt);
2896         } else if (g_str_has_prefix (opt, "toggleref-test")) {
2897                 /* FIXME: This should probably in MONO_GC_DEBUG */
2898                 sgen_register_test_toggleref_callback ();
2899         } else if (!sgen_bridge_handle_gc_param (opt)) {
2900                 return FALSE;
2901         }
2902         return TRUE;
2903 }
2904
2905 void
2906 sgen_client_print_gc_params_usage (void)
2907 {
2908         fprintf (stderr, "  stack-mark=MARK-METHOD (where MARK-METHOD is 'precise' or 'conservative')\n");
2909 }
2910
2911 gboolean
2912 sgen_client_handle_gc_debug (const char *opt)
2913 {
2914         if (!strcmp (opt, "xdomain-checks")) {
2915                 sgen_mono_xdomain_checks = TRUE;
2916         } else if (!strcmp (opt, "do-not-finalize")) {
2917                 mono_do_not_finalize = TRUE;
2918         } else if (g_str_has_prefix (opt, "do-not-finalize=")) {
2919                 opt = strchr (opt, '=') + 1;
2920                 mono_do_not_finalize = TRUE;
2921                 mono_do_not_finalize_class_names = g_strsplit (opt, ",", 0);
2922         } else if (!strcmp (opt, "log-finalizers")) {
2923                 log_finalizers = TRUE;
2924         } else if (!strcmp (opt, "no-managed-allocator")) {
2925                 sgen_set_use_managed_allocator (FALSE);
2926         } else if (!sgen_bridge_handle_gc_debug (opt)) {
2927                 return FALSE;
2928         }
2929         return TRUE;
2930 }
2931
2932 void
2933 sgen_client_print_gc_debug_usage (void)
2934 {
2935         fprintf (stderr, "  xdomain-checks\n");
2936         fprintf (stderr, "  do-not-finalize\n");
2937         fprintf (stderr, "  log-finalizers\n");
2938         fprintf (stderr, "  no-managed-allocator\n");
2939         sgen_bridge_print_gc_debug_usage ();
2940 }
2941
2942
2943 gpointer
2944 sgen_client_get_provenance (void)
2945 {
2946 #ifdef SGEN_OBJECT_PROVENANCE
2947         MonoGCCallbacks *cb = mono_gc_get_gc_callbacks ();
2948         gpointer (*get_provenance_func) (void);
2949         if (!cb)
2950                 return NULL;
2951         get_provenance_func = cb->get_provenance_func;
2952         if (get_provenance_func)
2953                 return get_provenance_func ();
2954         return NULL;
2955 #else
2956         return NULL;
2957 #endif
2958 }
2959
2960 void
2961 sgen_client_describe_invalid_pointer (GCObject *ptr)
2962 {
2963         sgen_bridge_describe_pointer (ptr);
2964 }
2965
2966 static gboolean gc_inited;
2967
2968 void
2969 mono_gc_base_init (void)
2970 {
2971         if (gc_inited)
2972                 return;
2973
2974         mono_counters_init ();
2975
2976 #ifdef HEAVY_STATISTICS
2977         mono_counters_register ("los marked cards", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &los_marked_cards);
2978         mono_counters_register ("los array cards scanned ", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &los_array_cards);
2979         mono_counters_register ("los array remsets", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &los_array_remsets);
2980
2981         mono_counters_register ("WBarrier set arrayref", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_wbarrier_set_arrayref);
2982         mono_counters_register ("WBarrier value copy", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_wbarrier_value_copy);
2983         mono_counters_register ("WBarrier object copy", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_wbarrier_object_copy);
2984 #endif
2985
2986         sgen_gc_init ();
2987
2988         if (nursery_canaries_enabled ())
2989                 sgen_set_use_managed_allocator (FALSE);
2990
2991 #if defined(HAVE_KW_THREAD)
2992         /* This can happen with using libmonosgen.so */
2993         if (mono_tls_key_get_offset (TLS_KEY_SGEN_THREAD_INFO) == -1)
2994                 sgen_set_use_managed_allocator (FALSE);
2995 #endif
2996
2997         gc_inited = TRUE;
2998 }
2999
3000 void
3001 mono_gc_base_cleanup (void)
3002 {
3003         sgen_thread_pool_shutdown ();
3004 }
3005
3006 gboolean
3007 mono_gc_is_null (void)
3008 {
3009         return FALSE;
3010 }
3011
3012 #endif