mono/metadata/sgen-bridge.c

   1 /*
   2  * sgen-bridge.c: Simple generational GC.
   3  *
   4  * Copyright 2011 Novell, Inc (http://www.novell.com)
   5  *
   6  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
   7  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
   8  *
   9  * Permission is hereby granted to use or copy this program
  10  * for any purpose,  provided the above notices are retained on all copies.
  11  * Permission to modify the code and to distribute modified code is granted,
  12  * provided the above notices are retained, and a notice that the code was
  13  * modified is included with the above copyright notice.
  14  *
  15  *
  16  * Copyright 2001-2003 Ximian, Inc
  17  * Copyright 2003-2010 Novell, Inc.
  18  *
  19  * Permission is hereby granted, free of charge, to any person obtaining
  20  * a copy of this software and associated documentation files (the
  21  * "Software"), to deal in the Software without restriction, including
  22  * without limitation the rights to use, copy, modify, merge, publish,
  23  * distribute, sublicense, and/or sell copies of the Software, and to
  24  * permit persons to whom the Software is furnished to do so, subject to
  25  * the following conditions:
  26  *
  27  * The above copyright notice and this permission notice shall be
  28  * included in all copies or substantial portions of the Software.
  29  *
  30  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  31  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  32  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  33  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  34  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  35  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  36  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  37  */
  38
  39 #include "config.h"
  40
  41 #ifdef HAVE_SGEN_GC
  42
  43 #include <stdlib.h>
  44
  45 #include "sgen-gc.h"
  46 #include "sgen-bridge.h"
  47
  48 typedef struct {
  49         int size;
  50         int elem_size;
  51         int capacity;
  52         char *data;
  53 } DynArray;
  54
  55 #define DYN_ARRAY_REF(da,i)     ((void*)((da)->data + (i) * (da)->elem_size))
  56 #define DYN_ARRAY_PTR_REF(da,i) (((void**)(da)->data) [(i)])
  57 #define DYN_ARRAY_INT_REF(da,i) (((int*)(da)->data) [(i)])
  58
  59 static void
  60 dyn_array_init (DynArray *da, int elem_size)
  61 {
  62         da->size = 0;
  63         da->elem_size = elem_size;
  64         da->capacity = 0;
  65         da->data = NULL;
  66 }
  67
  68 static void
  69 dyn_array_ptr_init (DynArray *da)
  70 {
  71         dyn_array_init (da, sizeof (void*));
  72 }
  73
  74 static void
  75 dyn_array_int_init (DynArray *da)
  76 {
  77         dyn_array_init (da, sizeof (int));
  78 }
  79
  80 static void
  81 dyn_array_uninit (DynArray *da)
  82 {
  83         if (da->capacity <= 0)
  84                 return;
  85
  86         mono_sgen_free_internal_dynamic (da->data, da->elem_size * da->capacity, INTERNAL_MEM_BRIDGE_DATA);
  87         da->data = NULL;
  88 }
  89
  90 static void
  91 dyn_array_ensure_capacity (DynArray *da, int capacity)
  92 {
  93         char *new_data;
  94
  95         if (capacity <= da->capacity)
  96                 return;
  97
  98         if (da->capacity == 0)
  99                 da->capacity = 2;
 100         while (capacity > da->capacity)
 101                 da->capacity *= 2;
 102
 103         new_data = mono_sgen_alloc_internal_dynamic (da->elem_size * da->capacity, INTERNAL_MEM_BRIDGE_DATA);
 104         memcpy (new_data, da->data, da->elem_size * da->size);
 105         mono_sgen_free_internal_dynamic (da->data, da->elem_size * da->size, INTERNAL_MEM_BRIDGE_DATA);
 106         da->data = new_data;
 107 }
 108
 109 static void*
 110 dyn_array_add (DynArray *da)
 111 {
 112         void *p;
 113
 114         dyn_array_ensure_capacity (da, da->size + 1);
 115
 116         p = DYN_ARRAY_REF (da, da->size);
 117         ++da->size;
 118         return p;
 119 }
 120
 121 static void
 122 dyn_array_ptr_add (DynArray *da, void *ptr)
 123 {
 124         void **p = dyn_array_add (da);
 125         *p = ptr;
 126 }
 127
 128 #define dyn_array_ptr_push dyn_array_ptr_add
 129
 130 static void*
 131 dyn_array_ptr_pop (DynArray *da)
 132 {
 133         void *p;
 134         g_assert (da->size > 0);
 135         p = DYN_ARRAY_PTR_REF (da, da->size - 1);
 136         --da->size;
 137         return p;
 138 }
 139
 140 static void
 141 dyn_array_int_add (DynArray *da, int x)
 142 {
 143         int *p = dyn_array_add (da);
 144         *p = x;
 145 }
 146
 147 /*
 148 static gboolean
 149 dyn_array_ptr_contains (DynArray *da, void *ptr)
 150 {
 151         int i;
 152         for (i = 0; i < da->size; ++i)
 153                 if (DYN_ARRAY_PTR_REF (da, i) == ptr)
 154                         return TRUE;
 155         return FALSE;
 156 }
 157 */
 158
 159 static gboolean
 160 dyn_array_int_contains (DynArray *da, int x)
 161 {
 162         int i;
 163         for (i = 0; i < da->size; ++i)
 164                 if (DYN_ARRAY_INT_REF (da, i) == x)
 165                         return TRUE;
 166         return FALSE;
 167 }
 168
 169 static void
 170 dyn_array_append (DynArray *dst, DynArray *src)
 171 {
 172         g_assert (dst->elem_size == src->elem_size);
 173
 174         dyn_array_ensure_capacity (dst, dst->size + src->size);
 175         memcpy (DYN_ARRAY_REF (dst, dst->size), DYN_ARRAY_REF (src, 0), src->size * src->elem_size);
 176         dst->size += src->size;
 177 }
 178
 179 /*
 180  * FIXME: Optimizations:
 181  *
 182  * Don't allocate a scrs array for just one source.  Most objects have
 183  * just one source, so use the srcs pointer itself.
 184  */
 185 typedef struct _HashEntry {
 186         MonoObject *obj;
 187         gboolean is_bridge;
 188         gboolean is_visited;
 189
 190         int finishing_time;
 191
 192         DynArray srcs;
 193
 194         int scc_index;
 195
 196         struct _HashEntry *next;
 197 } HashEntry;
 198
 199 typedef struct _SCC {
 200         int index;
 201         int api_index;
 202         int num_bridge_entries;
 203         DynArray xrefs;         /* these are incoming, not outgoing */
 204 } SCC;
 205
 206 static int num_hash_entries = 0;
 207 static int hash_size = 0;
 208 static HashEntry **hash_table = NULL;
 209
 210 static MonoGCBridgeCallbacks bridge_callbacks;
 211
 212 static int current_time;
 213
 214 void
 215 mono_gc_register_bridge_callbacks (MonoGCBridgeCallbacks *callbacks)
 216 {
 217         bridge_callbacks = *callbacks;
 218 }
 219
 220 gboolean
 221 mono_sgen_need_bridge_processing (void)
 222 {
 223         return bridge_callbacks.cross_references != NULL;
 224 }
 225
 226 static HashEntry**
 227 alloc_hash_table (int size)
 228 {
 229         HashEntry **table;
 230         table = mono_sgen_alloc_internal_dynamic (sizeof (HashEntry*) * size, INTERNAL_MEM_BRIDGE_DATA);
 231         memset (table, 0, sizeof (HashEntry*) * size);
 232         return table;
 233 }
 234
 235 static void
 236 rehash (void)
 237 {
 238         HashEntry **new_table;
 239         int new_size = hash_size << 1;
 240         int i;
 241
 242         new_table = alloc_hash_table (new_size);
 243         for (i = 0; i < hash_size; ++i) {
 244                 HashEntry *entry = hash_table [i];
 245                 while (entry != NULL) {
 246                         HashEntry *next = entry->next;
 247                         int hash = ((mword)entry->obj >> 4) & (new_size - 1);
 248                         entry->next = new_table [hash];
 249                         new_table [hash] = entry;
 250                         entry = next;
 251                 }
 252         }
 253
 254         mono_sgen_free_internal_dynamic (hash_table, sizeof (HashEntry*) * hash_size, INTERNAL_MEM_BRIDGE_DATA);
 255
 256         hash_table = new_table;
 257         hash_size = new_size;
 258 }
 259
 260 static HashEntry*
 261 lookup_hash_entry (MonoObject *obj)
 262 {
 263         int hash = (mword)obj >> 4;
 264         HashEntry *entry;
 265
 266         if (!hash_table) {
 267                 g_assert (hash_size == 0 && num_hash_entries == 0);
 268                 hash_size = 32;
 269                 hash_table = alloc_hash_table (hash_size);
 270         }
 271
 272         hash &= hash_size - 1;
 273         for (entry = hash_table [hash]; entry != NULL; entry = entry->next) {
 274                 if (entry->obj == obj)
 275                         return entry;
 276         }
 277
 278         return NULL;
 279 }
 280
 281 static HashEntry*
 282 get_hash_entry (MonoObject *obj)
 283 {
 284         HashEntry *entry = lookup_hash_entry (obj);
 285         int hash;
 286
 287         if (entry)
 288                 return entry;
 289
 290         entry = mono_sgen_alloc_internal_dynamic (sizeof (HashEntry), INTERNAL_MEM_BRIDGE_DATA);
 291         memset (entry, 0, sizeof (HashEntry));
 292
 293         entry->obj = obj;
 294         dyn_array_ptr_init (&entry->srcs);
 295         entry->finishing_time = -1;
 296         entry->scc_index = -1;
 297
 298         hash = ((mword)obj >> 4) & (hash_size - 1);
 299         entry->next = hash_table [hash];
 300         hash_table [hash] = entry;
 301
 302         ++num_hash_entries;
 303
 304         if (num_hash_entries > hash_size >> 1)
 305                 rehash ();
 306
 307         return entry;
 308 }
 309
 310 static void
 311 add_source (HashEntry *entry, HashEntry *src)
 312 {
 313         dyn_array_ptr_add (&entry->srcs, src);
 314 }
 315
 316 static void
 317 free_data (void)
 318 {
 319         int i;
 320         int total_srcs = 0;
 321         int max_srcs = 0;
 322
 323         if (hash_table == NULL)
 324                 return;
 325
 326         for (i = 0; i < hash_size; ++i) {
 327                 HashEntry *entry = hash_table [i];
 328                 while (entry != NULL) {
 329                         HashEntry *next = entry->next;
 330                         total_srcs += entry->srcs.size;
 331                         if (entry->srcs.size > max_srcs)
 332                                 max_srcs = entry->srcs.size;
 333                         dyn_array_uninit (&entry->srcs);
 334                         mono_sgen_free_internal_dynamic (entry, sizeof (HashEntry), INTERNAL_MEM_BRIDGE_DATA);
 335                         entry = next;
 336                 }
 337         }
 338
 339         mono_sgen_free_internal_dynamic (hash_table, sizeof (HashEntry*) * hash_size, INTERNAL_MEM_BRIDGE_DATA);
 340
 341         hash_size = 0;
 342         num_hash_entries = 0;
 343         hash_table = NULL;
 344
 345         //g_print ("total srcs %d - max %d\n", total_srcs, max_srcs);
 346 }
 347
 348 static void
 349 register_bridge_object (MonoObject *obj)
 350 {
 351         HashEntry *entry = get_hash_entry (obj);
 352         g_assert (!entry->is_bridge);
 353         entry->is_bridge = TRUE;
 354 }
 355
 356 static void
 357 register_finishing_time (HashEntry *entry, int t)
 358 {
 359         g_assert (entry->finishing_time < 0);
 360         entry->finishing_time = t;
 361 }
 362
 363 static gboolean
 364 object_is_live (MonoObject **objp)
 365 {
 366         MonoObject *obj = *objp;
 367         MonoObject *fwd = SGEN_OBJECT_IS_FORWARDED (obj);
 368         if (fwd) {
 369                 *objp = fwd;
 370                 return lookup_hash_entry (fwd) == NULL;
 371         }
 372         if (!mono_sgen_object_is_live (obj))
 373                 return FALSE;
 374         return lookup_hash_entry (obj) == NULL;
 375 }
 376
 377 static DynArray dfs_stack;
 378
 379 #undef HANDLE_PTR
 380 #define HANDLE_PTR(ptr,obj)     do {                                    \
 381                 MonoObject *dst = (MonoObject*)*(ptr);                  \
 382                 if (dst && !object_is_live (&dst)) {                    \
 383                         dyn_array_ptr_push (&dfs_stack, obj_entry);     \
 384                         dyn_array_ptr_push (&dfs_stack, get_hash_entry (dst)); \
 385                 }                                                       \
 386         } while (0)
 387
 388 static void
 389 dfs1 (HashEntry *obj_entry, HashEntry *src)
 390 {
 391         g_assert (dfs_stack.size == 0);
 392
 393         dyn_array_ptr_push (&dfs_stack, src);
 394         dyn_array_ptr_push (&dfs_stack, obj_entry);
 395
 396         do {
 397                 MonoObject *obj;
 398                 char *start;
 399
 400                 obj_entry = dyn_array_ptr_pop (&dfs_stack);
 401                 if (obj_entry) {
 402                         src = dyn_array_ptr_pop (&dfs_stack);
 403
 404                         obj = obj_entry->obj;
 405                         start = (char*)obj;
 406
 407                         if (src) {
 408                                 //g_print ("link %s -> %s\n", mono_sgen_safe_name (src->obj), mono_sgen_safe_name (obj));
 409                                 add_source (obj_entry, src);
 410                         } else {
 411                                 //g_print ("starting with %s\n", mono_sgen_safe_name (obj));
 412                         }
 413
 414                         if (obj_entry->is_visited)
 415                                 continue;
 416
 417                         obj_entry->is_visited = TRUE;
 418
 419                         dyn_array_ptr_push (&dfs_stack, obj_entry);
 420                         /* NULL marks that the next entry is to be finished */
 421                         dyn_array_ptr_push (&dfs_stack, NULL);
 422
 423 #include "sgen-scan-object.h"
 424                 } else {
 425                         obj_entry = dyn_array_ptr_pop (&dfs_stack);
 426
 427                         //g_print ("finish %s\n", mono_sgen_safe_name (obj_entry->obj));
 428                         register_finishing_time (obj_entry, current_time++);
 429                 }
 430         } while (dfs_stack.size > 0);
 431 }
 432
 433 static void
 434 scc_add_xref (SCC *src, SCC *dst)
 435 {
 436         g_assert (src != dst);
 437         g_assert (src->index != dst->index);
 438
 439         if (dyn_array_int_contains (&dst->xrefs, src->index))
 440                 return;
 441         if (src->num_bridge_entries) {
 442                 dyn_array_int_add (&dst->xrefs, src->index);
 443         } else {
 444                 int i;
 445                 // FIXME: uniq here
 446                 dyn_array_append (&dst->xrefs, &src->xrefs);
 447                 for (i = 0; i < dst->xrefs.size; ++i)
 448                         g_assert (DYN_ARRAY_INT_REF (&dst->xrefs, i) != dst->index);
 449         }
 450 }
 451
 452 static void
 453 scc_add_entry (SCC *scc, HashEntry *entry)
 454 {
 455         g_assert (entry->scc_index < 0);
 456         entry->scc_index = scc->index;
 457         if (entry->is_bridge)
 458                 ++scc->num_bridge_entries;
 459 }
 460
 461 static DynArray sccs;
 462 static SCC *current_scc;
 463
 464 static void
 465 dfs2 (HashEntry *entry)
 466 {
 467         int i;
 468
 469         g_assert (dfs_stack.size == 0);
 470
 471         dyn_array_ptr_push (&dfs_stack, entry);
 472
 473         do {
 474                 entry = dyn_array_ptr_pop (&dfs_stack);
 475
 476                 if (entry->scc_index >= 0) {
 477                         if (entry->scc_index != current_scc->index)
 478                                 scc_add_xref (DYN_ARRAY_REF (&sccs, entry->scc_index), current_scc);
 479                         continue;
 480                 }
 481
 482                 scc_add_entry (current_scc, entry);
 483
 484                 for (i = 0; i < entry->srcs.size; ++i)
 485                         dyn_array_ptr_push (&dfs_stack, DYN_ARRAY_PTR_REF (&entry->srcs, i));
 486         } while (dfs_stack.size > 0);
 487 }
 488
 489 static int
 490 compare_hash_entries (const void *ep1, const void *ep2)
 491 {
 492         HashEntry *e1 = *(HashEntry**)ep1;
 493         HashEntry *e2 = *(HashEntry**)ep2;
 494         return e2->finishing_time - e1->finishing_time;
 495 }
 496
 497 void
 498 mono_sgen_bridge_processing (int num_objs, MonoObject **objs)
 499 {
 500         HashEntry **all_entries;
 501         int j = 0;
 502         int num_sccs, num_xrefs;
 503         int max_entries, max_xrefs;
 504         int i;
 505         MonoGCBridgeSCC **api_sccs;
 506         MonoGCBridgeXRef *api_xrefs;
 507
 508         g_assert (mono_sgen_need_bridge_processing ());
 509
 510         //g_print ("%d finalized objects\n", num_objs);
 511
 512         /* remove objects that are not bridge objects */
 513
 514         for (i = 0; i < num_objs; ++i) {
 515                 MonoObject *obj = objs [i];
 516                 //g_assert (!mono_sgen_object_is_live (obj));
 517                 if (bridge_callbacks.is_bridge_object (obj)) {
 518                         register_bridge_object (obj);
 519                         objs [j++] = obj;
 520                 }
 521         }
 522         num_objs = j;
 523
 524         //g_print ("%d bridge objects\n", num_objs);
 525
 526         /* first DFS pass */
 527
 528         dyn_array_ptr_init (&dfs_stack);
 529
 530         current_time = 0;
 531         for (i = 0; i < num_objs; ++i)
 532                 dfs1 (get_hash_entry (objs [i]), NULL);
 533
 534         //g_print ("%d entries - hash size %d\n", num_hash_entries, hash_size);
 535
 536         /* alloc and fill array of all entries */
 537
 538         all_entries = mono_sgen_alloc_internal_dynamic (sizeof (HashEntry*) * num_hash_entries, INTERNAL_MEM_BRIDGE_DATA);
 539
 540         j = 0;
 541         max_entries = 0;
 542         for (i = 0; i < hash_size; ++i) {
 543                 HashEntry *entry;
 544                 int length = 0;
 545                 for (entry = hash_table [i]; entry != NULL; entry = entry->next) {
 546                         g_assert (entry->finishing_time >= 0);
 547                         all_entries [j++] = entry;
 548                         ++length;
 549                 }
 550                 if (length > max_entries)
 551                         max_entries = length;
 552         }
 553         g_assert (j == num_hash_entries);
 554
 555         //g_print ("max hash bucket length %d\n", max_entries);
 556
 557         /* sort array according to decreasing finishing time */
 558
 559         qsort (all_entries, num_hash_entries, sizeof (HashEntry*), compare_hash_entries);
 560
 561         /* second DFS pass */
 562
 563         dyn_array_init (&sccs, sizeof (SCC));
 564         for (i = 0; i < num_hash_entries; ++i) {
 565                 HashEntry *entry = all_entries [i];
 566                 if (entry->scc_index < 0) {
 567                         int index = sccs.size;
 568                         current_scc = dyn_array_add (&sccs);
 569                         current_scc->index = index;
 570                         current_scc->num_bridge_entries = 0;
 571                         current_scc->api_index = -1;
 572                         dyn_array_int_init (&current_scc->xrefs);
 573
 574                         dfs2 (entry);
 575                 }
 576         }
 577
 578         //g_print ("%d sccs\n", sccs.size);
 579
 580         dyn_array_uninit (&dfs_stack);
 581
 582         /* init data for callback */
 583
 584         num_sccs = 0;
 585         for (i = 0; i < sccs.size; ++i) {
 586                 SCC *scc = DYN_ARRAY_REF (&sccs, i);
 587                 g_assert (scc->index == i);
 588                 if (scc->num_bridge_entries)
 589                         ++num_sccs;
 590         }
 591
 592         api_sccs = mono_sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeSCC*) * num_sccs, INTERNAL_MEM_BRIDGE_DATA);
 593         num_xrefs = 0;
 594         j = 0;
 595         for (i = 0; i < sccs.size; ++i) {
 596                 SCC *scc = DYN_ARRAY_REF (&sccs, i);
 597                 if (!scc->num_bridge_entries)
 598                         continue;
 599
 600                 api_sccs [j] = mono_sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeSCC) + sizeof (MonoObject*) * scc->num_bridge_entries, INTERNAL_MEM_BRIDGE_DATA);
 601                 api_sccs [j]->num_objs = scc->num_bridge_entries;
 602                 scc->num_bridge_entries = 0;
 603                 scc->api_index = j++;
 604
 605                 num_xrefs += scc->xrefs.size;
 606         }
 607
 608         for (i = 0; i < hash_size; ++i) {
 609                 HashEntry *entry;
 610                 for (entry = hash_table [i]; entry != NULL; entry = entry->next) {
 611                         SCC *scc;
 612                         if (!entry->is_bridge)
 613                                 continue;
 614                         scc = DYN_ARRAY_REF (&sccs, entry->scc_index);
 615                         api_sccs [scc->api_index]->objs [scc->num_bridge_entries++] = entry->obj;
 616                 }
 617         }
 618
 619         api_xrefs = mono_sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeXRef) * num_xrefs, INTERNAL_MEM_BRIDGE_DATA);
 620         j = 0;
 621         for (i = 0; i < sccs.size; ++i) {
 622                 int k;
 623                 SCC *scc = DYN_ARRAY_REF (&sccs, i);
 624                 if (!scc->num_bridge_entries)
 625                         continue;
 626                 for (k = 0; k < scc->xrefs.size; ++k) {
 627                         SCC *src_scc = DYN_ARRAY_REF (&sccs, DYN_ARRAY_INT_REF (&scc->xrefs, k));
 628                         if (!src_scc->num_bridge_entries)
 629                                 continue;
 630                         api_xrefs [j].src_scc_index = src_scc->api_index;
 631                         api_xrefs [j].dst_scc_index = scc->api_index;
 632                         ++j;
 633                 }
 634         }
 635
 636         /* free data */
 637
 638         j = 0;
 639         max_entries = max_xrefs = 0;
 640         for (i = 0; i < sccs.size; ++i) {
 641                 SCC *scc = DYN_ARRAY_REF (&sccs, i);
 642                 if (scc->num_bridge_entries)
 643                         ++j;
 644                 if (scc->num_bridge_entries > max_entries)
 645                         max_entries = scc->num_bridge_entries;
 646                 if (scc->xrefs.size > max_xrefs)
 647                         max_xrefs = scc->xrefs.size;
 648                 dyn_array_uninit (&scc->xrefs);
 649
 650         }
 651         dyn_array_uninit (&sccs);
 652
 653         mono_sgen_free_internal_dynamic (all_entries, sizeof (HashEntry*) * num_hash_entries, INTERNAL_MEM_BRIDGE_DATA);
 654
 655         free_data ();
 656
 657         //g_print ("%d sccs containing bridges - %d max bridge objects - %d max xrefs\n", j, max_entries, max_xrefs);
 658
 659         /* callback */
 660
 661         bridge_callbacks.cross_references (num_sccs, api_sccs, num_xrefs, api_xrefs);
 662
 663         /* free callback data */
 664
 665         for (i = 0; i < num_sccs; ++i) {
 666                 mono_sgen_free_internal_dynamic (api_sccs [i],
 667                                 sizeof (MonoGCBridgeSCC) + sizeof (MonoObject*) * api_sccs [i]->num_objs,
 668                                 INTERNAL_MEM_BRIDGE_DATA);
 669         }
 670         mono_sgen_free_internal_dynamic (api_sccs, sizeof (MonoGCBridgeSCC*) * num_sccs, INTERNAL_MEM_BRIDGE_DATA);
 671
 672         mono_sgen_free_internal_dynamic (api_xrefs, sizeof (MonoGCBridgeXRef) * num_xrefs, INTERNAL_MEM_BRIDGE_DATA);
 673 }
 674
 675 static gboolean
 676 bridge_test_is_bridge_object (MonoObject *obj)
 677 {
 678         return TRUE;
 679 }
 680
 681 static void
 682 bridge_test_cross_reference (int num_sccs, MonoGCBridgeSCC **sccs, int num_xrefs, MonoGCBridgeXRef *xrefs)
 683 {
 684         int i;
 685         for (i = 0; i < num_sccs; ++i) {
 686                 int j;
 687                 g_print ("--- SCC %d\n", i);
 688                 for (j = 0; j < sccs [i]->num_objs; ++j)
 689                         g_print ("  %s\n", mono_sgen_safe_name (sccs [i]->objs [j]));
 690         }
 691         for (i = 0; i < num_xrefs; ++i) {
 692                 g_assert (xrefs [i].src_scc_index >= 0 && xrefs [i].src_scc_index < num_sccs);
 693                 g_assert (xrefs [i].dst_scc_index >= 0 && xrefs [i].dst_scc_index < num_sccs);
 694                 g_print ("%d -> %d\n", xrefs [i].src_scc_index, xrefs [i].dst_scc_index);
 695         }
 696 }
 697
 698
 699 void
 700 mono_sgen_register_test_bridge_callbacks (void)
 701 {
 702         MonoGCBridgeCallbacks callbacks;
 703         callbacks.is_bridge_object = bridge_test_is_bridge_object;
 704         callbacks.cross_references = bridge_test_cross_reference;
 705         mono_gc_register_bridge_callbacks (&callbacks);
 706 }
 707
 708 #endif