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