mono/metadata/sgen-debug.c

   1 /*
   2  * sgen-debug.c: Collector debugging
   3  *
   4  * Author:
   5  *      Paolo Molaro (lupus@ximian.com)
   6  *  Rodrigo Kumpera (kumpera@gmail.com)
   7  *
   8  * Copyright 2005-2011 Novell, Inc (http://www.novell.com)
   9  * Copyright 2011 Xamarin Inc (http://www.xamarin.com)
  10  * Copyright 2011 Xamarin, Inc.
  11  * Copyright (C) 2012 Xamarin Inc
  12  *
  13  * This library is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU Library General Public
  15  * License 2.0 as published by the Free Software Foundation;
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Library General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Library General Public
  23  * License 2.0 along with this library; if not, write to the Free
  24  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25  */
  26
  27 #include "config.h"
  28 #ifdef HAVE_SGEN_GC
  29
  30 #include "metadata/sgen-gc.h"
  31 #include "metadata/sgen-cardtable.h"
  32 #include "metadata/sgen-protocol.h"
  33 #include "metadata/sgen-memory-governor.h"
  34 #include "metadata/sgen-pinning.h"
  35 #include "metadata/threadpool-internals.h"
  36
  37 #define LOAD_VTABLE     SGEN_LOAD_VTABLE
  38
  39 #define object_is_forwarded     SGEN_OBJECT_IS_FORWARDED
  40 #define object_is_pinned        SGEN_OBJECT_IS_PINNED
  41 #define safe_object_get_size    sgen_safe_object_get_size
  42
  43 void describe_ptr (char *ptr);
  44 void check_object (char *start);
  45
  46 /*
  47  * ######################################################################
  48  * ########  Collector debugging
  49  * ######################################################################
  50  */
  51
  52 const char*descriptor_types [] = {
  53         "INVALID",
  54         "run_length",
  55         "small_bitmap",
  56         "complex",
  57         "vector",
  58         "large_bitmap",
  59         "complex_arr",
  60         "complex_ptrfree"
  61 };
  62
  63 static char* describe_nursery_ptr (char *ptr, gboolean need_setup);
  64
  65 static void
  66 describe_pointer (char *ptr, gboolean need_setup)
  67 {
  68         MonoVTable *vtable;
  69         mword desc;
  70         int type;
  71         char *start;
  72         char *forwarded;
  73         mword size;
  74
  75  restart:
  76         if (sgen_ptr_in_nursery (ptr)) {
  77                 start = describe_nursery_ptr (ptr, need_setup);
  78                 if (!start)
  79                         return;
  80                 ptr = start;
  81                 vtable = (MonoVTable*)LOAD_VTABLE (ptr);
  82         } else {
  83                 if (sgen_ptr_is_in_los (ptr, &start)) {
  84                         if (ptr == start)
  85                                 printf ("Pointer is the start of object %p in LOS space.\n", start);
  86                         else
  87                                 printf ("Pointer is at offset 0x%x of object %p in LOS space.\n", (int)(ptr - start), start);
  88                         ptr = start;
  89                         mono_sgen_los_describe_pointer (ptr);
  90                         vtable = (MonoVTable*)LOAD_VTABLE (ptr);
  91                 } else if (major_collector.ptr_is_in_non_pinned_space (ptr, &start)) {
  92                         if (ptr == start)
  93                                 printf ("Pointer is the start of object %p in oldspace.\n", start);
  94                         else if (start)
  95                                 printf ("Pointer is at offset 0x%x of object %p in oldspace.\n", (int)(ptr - start), start);
  96                         else
  97                                 printf ("Pointer inside oldspace.\n");
  98                         if (start)
  99                                 ptr = start;
 100                         vtable = major_collector.describe_pointer (ptr);
 101                 } else if (major_collector.obj_is_from_pinned_alloc (ptr)) {
 102                         // FIXME: Handle pointers to the inside of objects
 103                         printf ("Pointer is inside a pinned chunk.\n");
 104                         vtable = (MonoVTable*)LOAD_VTABLE (ptr);
 105                 } else {
 106                         printf ("Pointer unknown.\n");
 107                         return;
 108                 }
 109         }
 110
 111         if (object_is_pinned (ptr))
 112                 printf ("Object is pinned.\n");
 113
 114         if ((forwarded = object_is_forwarded (ptr))) {
 115                 printf ("Object is forwarded to %p:\n", forwarded);
 116                 ptr = forwarded;
 117                 goto restart;
 118         }
 119
 120         printf ("VTable: %p\n", vtable);
 121         if (vtable == NULL) {
 122                 printf ("VTable is invalid (empty).\n");
 123                 goto bridge;
 124         }
 125         if (sgen_ptr_in_nursery (vtable)) {
 126                 printf ("VTable is invalid (points inside nursery).\n");
 127                 goto bridge;
 128         }
 129         printf ("Class: %s\n", vtable->klass->name);
 130
 131         desc = ((GCVTable*)vtable)->desc;
 132         printf ("Descriptor: %lx\n", (long)desc);
 133
 134         type = desc & 0x7;
 135         printf ("Descriptor type: %d (%s)\n", type, descriptor_types [type]);
 136
 137         size = sgen_safe_object_get_size ((MonoObject*)ptr);
 138         printf ("Size: %d\n", (int)size);
 139
 140  bridge:
 141         sgen_bridge_describe_pointer ((MonoObject*)ptr);
 142 }
 143
 144 void
 145 describe_ptr (char *ptr)
 146 {
 147         describe_pointer (ptr, TRUE);
 148 }
 149
 150 static gboolean missing_remsets;
 151
 152 /*
 153  * We let a missing remset slide if the target object is pinned,
 154  * because the store might have happened but the remset not yet added,
 155  * but in that case the target must be pinned.  We might theoretically
 156  * miss some missing remsets this way, but it's very unlikely.
 157  */
 158 #undef HANDLE_PTR
 159 #define HANDLE_PTR(ptr,obj)     do {    \
 160         if (*(ptr) && sgen_ptr_in_nursery ((char*)*(ptr))) { \
 161                 if (!sgen_get_remset ()->find_address ((char*)(ptr)) && !sgen_cement_lookup (*(ptr))) { \
 162                         SGEN_LOG (0, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.", *(ptr), (char*)(ptr) - (char*)(obj), (obj), ((MonoObject*)(obj))->vtable->klass->name_space, ((MonoObject*)(obj))->vtable->klass->name); \
 163                         binary_protocol_missing_remset ((obj), (gpointer)LOAD_VTABLE ((obj)), (int) ((char*)(ptr) - (char*)(obj)), *(ptr), (gpointer)LOAD_VTABLE(*(ptr)), object_is_pinned (*(ptr))); \
 164                         if (!object_is_pinned (*(ptr)))                                                         \
 165                                 missing_remsets = TRUE;                                                                 \
 166                 }                                                                                                                               \
 167         }                                                                                                                                       \
 168         } while (0)
 169
 170 /*
 171  * Check that each object reference which points into the nursery can
 172  * be found in the remembered sets.
 173  */
 174 static void
 175 check_consistency_callback (char *start, size_t size, void *dummy)
 176 {
 177         MonoVTable *vt = (MonoVTable*)LOAD_VTABLE (start);
 178         mword desc = sgen_vtable_get_descriptor (vt);
 179         SGEN_LOG (8, "Scanning object %p, vtable: %p (%s)", start, vt, vt->klass->name);
 180
 181 #include "sgen-scan-object.h"
 182 }
 183
 184 /*
 185  * Perform consistency check of the heap.
 186  *
 187  * Assumes the world is stopped.
 188  */
 189 void
 190 sgen_check_consistency (void)
 191 {
 192         // Need to add more checks
 193
 194         missing_remsets = FALSE;
 195
 196         SGEN_LOG (1, "Begin heap consistency check...");
 197
 198         // Check that oldspace->newspace pointers are registered with the collector
 199         major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_ALL, (IterateObjectCallbackFunc)check_consistency_callback, NULL);
 200
 201         sgen_los_iterate_objects ((IterateObjectCallbackFunc)check_consistency_callback, NULL);
 202
 203         SGEN_LOG (1, "Heap consistency check done.");
 204
 205         if (!binary_protocol_is_enabled ())
 206                 g_assert (!missing_remsets);
 207 }
 208
 209 static gboolean
 210 is_major_or_los_object_marked (char *obj)
 211 {
 212         if (sgen_safe_object_get_size ((MonoObject*)obj) > SGEN_MAX_SMALL_OBJ_SIZE) {
 213                 return sgen_los_object_is_pinned (obj);
 214         } else {
 215                 return sgen_get_major_collector ()->is_object_live (obj);
 216         }
 217 }
 218
 219 #undef HANDLE_PTR
 220 #define HANDLE_PTR(ptr,obj)     do {    \
 221         if (*(ptr) && !sgen_ptr_in_nursery ((char*)*(ptr)) && !is_major_or_los_object_marked ((char*)*(ptr))) { \
 222                 if (!sgen_get_remset ()->find_address_with_cards (start, cards, (char*)(ptr))) { \
 223                         SGEN_LOG (0, "major->major reference %p at offset %td in object %p (%s.%s) not found in remsets.", *(ptr), (char*)(ptr) - (char*)(obj), (obj), ((MonoObject*)(obj))->vtable->klass->name_space, ((MonoObject*)(obj))->vtable->klass->name); \
 224                         binary_protocol_missing_remset ((obj), (gpointer)LOAD_VTABLE ((obj)), (int) ((char*)(ptr) - (char*)(obj)), *(ptr), (gpointer)LOAD_VTABLE(*(ptr)), object_is_pinned (*(ptr))); \
 225                         missing_remsets = TRUE;                         \
 226                 }                                                                                                                               \
 227         }                                                                                                                                       \
 228         } while (0)
 229
 230 static void
 231 check_mod_union_callback (char *start, size_t size, void *dummy)
 232 {
 233         gboolean in_los = (gboolean) (size_t) dummy;
 234         MonoVTable *vt = (MonoVTable*)LOAD_VTABLE (start);
 235         mword desc = sgen_vtable_get_descriptor (vt);
 236         guint8 *cards;
 237         SGEN_LOG (8, "Scanning object %p, vtable: %p (%s)", start, vt, vt->klass->name);
 238
 239         if (!is_major_or_los_object_marked (start))
 240                 return;
 241
 242         if (in_los)
 243                 cards = sgen_los_header_for_object (start)->cardtable_mod_union;
 244         else
 245                 cards = sgen_get_major_collector ()->get_cardtable_mod_union_for_object (start);
 246
 247         SGEN_ASSERT (0, cards, "we must have mod union for marked major objects");
 248
 249 #include "sgen-scan-object.h"
 250 }
 251
 252 void
 253 sgen_check_mod_union_consistency (void)
 254 {
 255         missing_remsets = FALSE;
 256
 257         major_collector.iterate_objects (ITERATE_OBJECTS_ALL, (IterateObjectCallbackFunc)check_mod_union_callback, (void*)FALSE);
 258
 259         sgen_los_iterate_objects ((IterateObjectCallbackFunc)check_mod_union_callback, (void*)TRUE);
 260
 261         if (!binary_protocol_is_enabled ())
 262                 g_assert (!missing_remsets);
 263 }
 264
 265 #undef HANDLE_PTR
 266 #define HANDLE_PTR(ptr,obj)     do {                                    \
 267                 if (*(ptr) && !LOAD_VTABLE (*(ptr)))                                            \
 268                         g_error ("Could not load vtable for obj %p slot %d (size %d)", obj, (char*)ptr - (char*)obj, safe_object_get_size ((MonoObject*)obj));          \
 269         } while (0)
 270
 271 static void
 272 check_major_refs_callback (char *start, size_t size, void *dummy)
 273 {
 274         mword desc = sgen_obj_get_descriptor (start);
 275
 276 #include "sgen-scan-object.h"
 277 }
 278
 279 void
 280 sgen_check_major_refs (void)
 281 {
 282         major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_ALL, (IterateObjectCallbackFunc)check_major_refs_callback, NULL);
 283         sgen_los_iterate_objects ((IterateObjectCallbackFunc)check_major_refs_callback, NULL);
 284 }
 285
 286 /* Check that the reference is valid */
 287 #undef HANDLE_PTR
 288 #define HANDLE_PTR(ptr,obj)     do {    \
 289                 if (*(ptr)) {   \
 290                         g_assert (sgen_safe_name (*(ptr)) != NULL);     \
 291                 }       \
 292         } while (0)
 293
 294 /*
 295  * check_object:
 296  *
 297  *   Perform consistency check on an object. Currently we only check that the
 298  * reference fields are valid.
 299  */
 300 void
 301 check_object (char *start)
 302 {
 303         mword desc;
 304
 305         if (!start)
 306                 return;
 307
 308         desc = sgen_obj_get_descriptor (start);
 309
 310 #include "sgen-scan-object.h"
 311 }
 312
 313
 314 static char **valid_nursery_objects;
 315 static int valid_nursery_object_count;
 316 static gboolean broken_heap;
 317
 318 static void
 319 setup_mono_sgen_scan_area_with_callback (char *object, size_t size, void *data)
 320 {
 321         valid_nursery_objects [valid_nursery_object_count++] = object;
 322 }
 323
 324 static void
 325 setup_valid_nursery_objects (void)
 326 {
 327         if (!valid_nursery_objects)
 328                 valid_nursery_objects = sgen_alloc_os_memory (DEFAULT_NURSERY_SIZE, SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE, "debugging data");
 329         valid_nursery_object_count = 0;
 330         sgen_scan_area_with_callback (nursery_section->data, nursery_section->end_data, setup_mono_sgen_scan_area_with_callback, NULL, FALSE);
 331 }
 332
 333 static gboolean
 334 find_object_in_nursery_dump (char *object)
 335 {
 336         int first = 0, last = valid_nursery_object_count;
 337         while (first < last) {
 338                 int middle = first + ((last - first) >> 1);
 339                 if (object == valid_nursery_objects [middle])
 340                         return TRUE;
 341
 342                 if (object < valid_nursery_objects [middle])
 343                         last = middle;
 344                 else
 345                         first = middle + 1;
 346         }
 347         g_assert (first == last);
 348         return FALSE;
 349 }
 350
 351 static char*
 352 describe_nursery_ptr (char *ptr, gboolean need_setup)
 353 {
 354         int i;
 355
 356         if (need_setup)
 357                 setup_valid_nursery_objects ();
 358
 359         for (i = 0; i < valid_nursery_object_count; ++i) {
 360                 if (valid_nursery_objects [i] >= ptr)
 361                         break;
 362         }
 363
 364         if (i >= valid_nursery_object_count || valid_nursery_objects [i] + safe_object_get_size ((MonoObject *)valid_nursery_objects [i]) < ptr) {
 365                 SGEN_LOG (0, "nursery-ptr (unalloc'd-memory)\n");
 366                 return NULL;
 367         } else {
 368                 char *obj = valid_nursery_objects [i];
 369                 if (obj == ptr)
 370                         SGEN_LOG (0, "nursery-ptr\n");
 371                 else
 372                         SGEN_LOG (0, "nursery-ptr (interior-ptr offset %td)\n", ptr - obj);
 373                 return obj;
 374         }
 375 }
 376
 377 static gboolean
 378 is_valid_object_pointer (char *object)
 379 {
 380         if (sgen_ptr_in_nursery (object))
 381                 return find_object_in_nursery_dump (object);
 382
 383         if (sgen_los_is_valid_object (object))
 384                 return TRUE;
 385
 386         if (major_collector.is_valid_object (object))
 387                 return TRUE;
 388         return FALSE;
 389 }
 390
 391 static void
 392 bad_pointer_spew (char *obj, char **slot)
 393 {
 394         char *ptr = *slot;
 395         MonoVTable *vtable = (MonoVTable*)LOAD_VTABLE (obj);
 396
 397         SGEN_LOG (0, "Invalid object pointer %p at offset %td in object %p (%s.%s):", ptr,
 398                 (char*)slot - obj,
 399                 obj, vtable->klass->name_space, vtable->klass->name);
 400         describe_pointer (ptr, FALSE);
 401         broken_heap = TRUE;
 402 }
 403
 404 static void
 405 missing_remset_spew (char *obj, char **slot)
 406 {
 407         char *ptr = *slot;
 408         MonoVTable *vtable = (MonoVTable*)LOAD_VTABLE (obj);
 409
 410         SGEN_LOG (0, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.",
 411                 ptr, (char*)slot - obj, obj,
 412                 vtable->klass->name_space, vtable->klass->name);
 413
 414         broken_heap = TRUE;
 415 }
 416
 417 /*
 418 FIXME Flag missing remsets due to pinning as non fatal
 419 */
 420 #undef HANDLE_PTR
 421 #define HANDLE_PTR(ptr,obj)     do {    \
 422                 if (*(char**)ptr) {     \
 423                         if (!is_valid_object_pointer (*(char**)ptr)) {  \
 424                                 bad_pointer_spew ((char*)obj, (char**)ptr);     \
 425                         } else if (!sgen_ptr_in_nursery (obj) && sgen_ptr_in_nursery ((char*)*ptr)) {   \
 426                                 if (!sgen_get_remset ()->find_address ((char*)(ptr)) && !sgen_cement_lookup ((char*)*(ptr)) && (!allow_missing_pinned || !SGEN_OBJECT_IS_PINNED ((char*)*(ptr)))) \
 427                                 missing_remset_spew ((char*)obj, (char**)ptr);  \
 428                         }       \
 429         } \
 430         } while (0)
 431
 432 static void
 433 verify_object_pointers_callback (char *start, size_t size, void *data)
 434 {
 435         gboolean allow_missing_pinned = (gboolean) (size_t) data;
 436         mword desc = sgen_obj_get_descriptor (start);
 437
 438 #include "sgen-scan-object.h"
 439 }
 440
 441 /*
 442 FIXME:
 443 -This heap checker is racy regarding inlined write barriers and other JIT tricks that
 444 depend on OP_DUMMY_USE.
 445 */
 446 void
 447 sgen_check_whole_heap (gboolean allow_missing_pinned)
 448 {
 449         setup_valid_nursery_objects ();
 450
 451         broken_heap = FALSE;
 452         sgen_scan_area_with_callback (nursery_section->data, nursery_section->end_data, verify_object_pointers_callback, (void*) (size_t) allow_missing_pinned, FALSE);
 453         major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_ALL, verify_object_pointers_callback, (void*) (size_t) allow_missing_pinned);
 454         sgen_los_iterate_objects (verify_object_pointers_callback, (void*) (size_t) allow_missing_pinned);
 455
 456         g_assert (!broken_heap);
 457 }
 458
 459 static gboolean
 460 ptr_in_heap (char *object)
 461 {
 462         if (sgen_ptr_in_nursery (object))
 463                 return TRUE;
 464
 465         if (sgen_los_is_valid_object (object))
 466                 return TRUE;
 467
 468         if (major_collector.is_valid_object (object))
 469                 return TRUE;
 470         return FALSE;
 471 }
 472
 473 /*
 474  * sgen_check_objref:
 475  *   Do consistency checks on the object reference OBJ. Assert on failure.
 476  */
 477 void
 478 sgen_check_objref (char *obj)
 479 {
 480         g_assert (ptr_in_heap (obj));
 481 }
 482
 483 static void
 484 find_pinning_ref_from_thread (char *obj, size_t size)
 485 {
 486         int j;
 487         SgenThreadInfo *info;
 488         char *endobj = obj + size;
 489
 490         FOREACH_THREAD (info) {
 491                 char **start = (char**)info->stack_start;
 492                 if (info->skip)
 493                         continue;
 494                 while (start < (char**)info->stack_end) {
 495                         if (*start >= obj && *start < endobj) {
 496                                 SGEN_LOG (0, "Object %p referenced in thread %p (id %p) at %p, stack: %p-%p", obj, info, (gpointer)mono_thread_info_get_tid (info), start, info->stack_start, info->stack_end);
 497                         }
 498                         start++;
 499                 }
 500
 501                 for (j = 0; j < ARCH_NUM_REGS; ++j) {
 502 #ifdef USE_MONO_CTX
 503                         mword w = ((mword*)&info->ctx) [j];
 504 #else
 505                         mword w = (mword)&info->regs [j];
 506 #endif
 507
 508                         if (w >= (mword)obj && w < (mword)obj + size)
 509                                 SGEN_LOG (0, "Object %p referenced in saved reg %d of thread %p (id %p)", obj, j, info, (gpointer)mono_thread_info_get_tid (info));
 510                 } END_FOREACH_THREAD
 511         }
 512 }
 513
 514 /*
 515  * Debugging function: find in the conservative roots where @obj is being pinned.
 516  */
 517 static G_GNUC_UNUSED void
 518 find_pinning_reference (char *obj, size_t size)
 519 {
 520         char **start;
 521         RootRecord *root;
 522         char *endobj = obj + size;
 523
 524         SGEN_HASH_TABLE_FOREACH (&roots_hash [ROOT_TYPE_NORMAL], start, root) {
 525                 /* if desc is non-null it has precise info */
 526                 if (!root->root_desc) {
 527                         while (start < (char**)root->end_root) {
 528                                 if (*start >= obj && *start < endobj) {
 529                                         SGEN_LOG (0, "Object %p referenced in pinned roots %p-%p\n", obj, start, root->end_root);
 530                                 }
 531                                 start++;
 532                         }
 533                 }
 534         } SGEN_HASH_TABLE_FOREACH_END;
 535
 536         find_pinning_ref_from_thread (obj, size);
 537 }
 538
 539 #undef HANDLE_PTR
 540 #define HANDLE_PTR(ptr,obj)     do {                                    \
 541                 char* __target = *(char**)ptr;                          \
 542                 if (__target) {                                         \
 543                         g_assert (is_valid_object_pointer (__target));  \
 544                         if (sgen_ptr_in_nursery (__target)) {           \
 545                                 g_assert (SGEN_OBJECT_IS_PINNED (__target)); \
 546                         } else if (sgen_los_is_valid_object (__target)) { \
 547                                 g_assert (sgen_los_object_is_pinned (__target)); \
 548                         } else if (major_collector.is_valid_object (__target)) { \
 549                                 g_assert (major_collector.is_object_live (__target)); \
 550                         } else {                                        \
 551                                 g_assert_not_reached ();                \
 552                         }                                               \
 553                 }                                                       \
 554         } while (0)
 555
 556 static void
 557 check_marked_callback (char *start, size_t size, void *dummy)
 558 {
 559         gboolean is_los = (gboolean) (size_t) dummy;
 560         mword desc;
 561
 562         if (is_los) {
 563                 if (!sgen_los_object_is_pinned (start))
 564                         return;
 565         } else {
 566                 if (!major_collector.is_object_live (start))
 567                         return;
 568         }
 569
 570         desc = sgen_obj_get_descriptor (start);
 571
 572 #include "sgen-scan-object.h"
 573 }
 574
 575 void
 576 sgen_check_major_heap_marked (void)
 577 {
 578         setup_valid_nursery_objects ();
 579
 580         major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_ALL, check_marked_callback, (void*)FALSE);
 581         sgen_los_iterate_objects (check_marked_callback, (void*)TRUE);
 582 }
 583
 584 static void
 585 check_nursery_objects_pinned_callback (char *obj, size_t size, void *data /* ScanCopyContext *ctx */)
 586 {
 587         gboolean pinned = (gboolean) (size_t) data;
 588
 589         g_assert (!SGEN_OBJECT_IS_FORWARDED (obj));
 590         if (pinned)
 591                 g_assert (SGEN_OBJECT_IS_PINNED (obj));
 592         else
 593                 g_assert (!SGEN_OBJECT_IS_PINNED (obj));
 594 }
 595
 596 void
 597 sgen_check_nursery_objects_pinned (gboolean pinned)
 598 {
 599         sgen_clear_nursery_fragments ();
 600         sgen_scan_area_with_callback (nursery_section->data, nursery_section->end_data,
 601                         (IterateObjectCallbackFunc)check_nursery_objects_pinned_callback, (void*) (size_t) pinned /* (void*)&ctx */, FALSE);
 602 }
 603
 604 static gboolean scan_object_for_specific_ref_precise = TRUE;
 605
 606 #undef HANDLE_PTR
 607 #define HANDLE_PTR(ptr,obj) do {                \
 608         if ((MonoObject*)*(ptr) == key) {       \
 609         g_print ("found ref to %p in object %p (%s) at offset %td\n",   \
 610                         key, (obj), sgen_safe_name ((obj)), ((char*)(ptr) - (char*)(obj))); \
 611         }                                                               \
 612         } while (0)
 613
 614 static void
 615 scan_object_for_specific_ref (char *start, MonoObject *key)
 616 {
 617         char *forwarded;
 618
 619         if ((forwarded = SGEN_OBJECT_IS_FORWARDED (start)))
 620                 start = forwarded;
 621
 622         if (scan_object_for_specific_ref_precise) {
 623                 mword desc = sgen_obj_get_descriptor (start);
 624                 #include "sgen-scan-object.h"
 625         } else {
 626                 mword *words = (mword*)start;
 627                 size_t size = safe_object_get_size ((MonoObject*)start);
 628                 int i;
 629                 for (i = 0; i < size / sizeof (mword); ++i) {
 630                         if (words [i] == (mword)key) {
 631                                 g_print ("found possible ref to %p in object %p (%s) at offset %td\n",
 632                                                 key, start, sgen_safe_name (start), i * sizeof (mword));
 633                         }
 634                 }
 635         }
 636 }
 637
 638 static void
 639 scan_object_for_specific_ref_callback (char *obj, size_t size, MonoObject *key)
 640 {
 641         scan_object_for_specific_ref (obj, key);
 642 }
 643
 644 static void
 645 check_root_obj_specific_ref (RootRecord *root, MonoObject *key, MonoObject *obj)
 646 {
 647         if (key != obj)
 648                 return;
 649         g_print ("found ref to %p in root record %p\n", key, root);
 650 }
 651
 652 static MonoObject *check_key = NULL;
 653 static RootRecord *check_root = NULL;
 654
 655 static void
 656 check_root_obj_specific_ref_from_marker (void **obj, void *gc_data)
 657 {
 658         check_root_obj_specific_ref (check_root, check_key, *obj);
 659 }
 660
 661 static void
 662 scan_roots_for_specific_ref (MonoObject *key, int root_type)
 663 {
 664         void **start_root;
 665         RootRecord *root;
 666         check_key = key;
 667
 668         SGEN_HASH_TABLE_FOREACH (&roots_hash [root_type], start_root, root) {
 669                 mword desc = root->root_desc;
 670
 671                 check_root = root;
 672
 673                 switch (desc & ROOT_DESC_TYPE_MASK) {
 674                 case ROOT_DESC_BITMAP:
 675                         desc >>= ROOT_DESC_TYPE_SHIFT;
 676                         while (desc) {
 677                                 if (desc & 1)
 678                                         check_root_obj_specific_ref (root, key, *start_root);
 679                                 desc >>= 1;
 680                                 start_root++;
 681                         }
 682                         return;
 683                 case ROOT_DESC_COMPLEX: {
 684                         gsize *bitmap_data = sgen_get_complex_descriptor_bitmap (desc);
 685                         int bwords = (int) ((*bitmap_data) - 1);
 686                         void **start_run = start_root;
 687                         bitmap_data++;
 688                         while (bwords-- > 0) {
 689                                 gsize bmap = *bitmap_data++;
 690                                 void **objptr = start_run;
 691                                 while (bmap) {
 692                                         if (bmap & 1)
 693                                                 check_root_obj_specific_ref (root, key, *objptr);
 694                                         bmap >>= 1;
 695                                         ++objptr;
 696                                 }
 697                                 start_run += GC_BITS_PER_WORD;
 698                         }
 699                         break;
 700                 }
 701                 case ROOT_DESC_USER: {
 702                         MonoGCRootMarkFunc marker = sgen_get_user_descriptor_func (desc);
 703                         marker (start_root, check_root_obj_specific_ref_from_marker, NULL);
 704                         break;
 705                 }
 706                 case ROOT_DESC_RUN_LEN:
 707                         g_assert_not_reached ();
 708                 default:
 709                         g_assert_not_reached ();
 710                 }
 711         } SGEN_HASH_TABLE_FOREACH_END;
 712
 713         check_key = NULL;
 714         check_root = NULL;
 715 }
 716
 717 void
 718 mono_gc_scan_for_specific_ref (MonoObject *key, gboolean precise)
 719 {
 720         void **ptr;
 721         RootRecord *root;
 722
 723         scan_object_for_specific_ref_precise = precise;
 724
 725         sgen_scan_area_with_callback (nursery_section->data, nursery_section->end_data,
 726                         (IterateObjectCallbackFunc)scan_object_for_specific_ref_callback, key, TRUE);
 727
 728         major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_ALL, (IterateObjectCallbackFunc)scan_object_for_specific_ref_callback, key);
 729
 730         sgen_los_iterate_objects ((IterateObjectCallbackFunc)scan_object_for_specific_ref_callback, key);
 731
 732         scan_roots_for_specific_ref (key, ROOT_TYPE_NORMAL);
 733         scan_roots_for_specific_ref (key, ROOT_TYPE_WBARRIER);
 734
 735         SGEN_HASH_TABLE_FOREACH (&roots_hash [ROOT_TYPE_PINNED], ptr, root) {
 736                 while (ptr < (void**)root->end_root) {
 737                         check_root_obj_specific_ref (root, *ptr, key);
 738                         ++ptr;
 739                 }
 740         } SGEN_HASH_TABLE_FOREACH_END;
 741 }
 742
 743 static MonoDomain *check_domain = NULL;
 744
 745 static void
 746 check_obj_not_in_domain (void **o)
 747 {
 748         g_assert (((MonoObject*)(*o))->vtable->domain != check_domain);
 749 }
 750
 751
 752 static void
 753 check_obj_not_in_domain_callback (void **o, void *gc_data)
 754 {
 755         g_assert (((MonoObject*)(*o))->vtable->domain != check_domain);
 756 }
 757
 758 void
 759 sgen_scan_for_registered_roots_in_domain (MonoDomain *domain, int root_type)
 760 {
 761         void **start_root;
 762         RootRecord *root;
 763         check_domain = domain;
 764         SGEN_HASH_TABLE_FOREACH (&roots_hash [root_type], start_root, root) {
 765                 mword desc = root->root_desc;
 766
 767                 /* The MonoDomain struct is allowed to hold
 768                    references to objects in its own domain. */
 769                 if (start_root == (void**)domain)
 770                         continue;
 771
 772                 switch (desc & ROOT_DESC_TYPE_MASK) {
 773                 case ROOT_DESC_BITMAP:
 774                         desc >>= ROOT_DESC_TYPE_SHIFT;
 775                         while (desc) {
 776                                 if ((desc & 1) && *start_root)
 777                                         check_obj_not_in_domain (*start_root);
 778                                 desc >>= 1;
 779                                 start_root++;
 780                         }
 781                         break;
 782                 case ROOT_DESC_COMPLEX: {
 783                         gsize *bitmap_data = sgen_get_complex_descriptor_bitmap (desc);
 784                         int bwords = (int)((*bitmap_data) - 1);
 785                         void **start_run = start_root;
 786                         bitmap_data++;
 787                         while (bwords-- > 0) {
 788                                 gsize bmap = *bitmap_data++;
 789                                 void **objptr = start_run;
 790                                 while (bmap) {
 791                                         if ((bmap & 1) && *objptr)
 792                                                 check_obj_not_in_domain (*objptr);
 793                                         bmap >>= 1;
 794                                         ++objptr;
 795                                 }
 796                                 start_run += GC_BITS_PER_WORD;
 797                         }
 798                         break;
 799                 }
 800                 case ROOT_DESC_USER: {
 801                         MonoGCRootMarkFunc marker = sgen_get_user_descriptor_func (desc);
 802                         marker (start_root, check_obj_not_in_domain_callback, NULL);
 803                         break;
 804                 }
 805                 case ROOT_DESC_RUN_LEN:
 806                         g_assert_not_reached ();
 807                 default:
 808                         g_assert_not_reached ();
 809                 }
 810         } SGEN_HASH_TABLE_FOREACH_END;
 811
 812         check_domain = NULL;
 813 }
 814
 815 static gboolean
 816 is_xdomain_ref_allowed (gpointer *ptr, char *obj, MonoDomain *domain)
 817 {
 818         MonoObject *o = (MonoObject*)(obj);
 819         MonoObject *ref = (MonoObject*)*(ptr);
 820         size_t offset = (char*)(ptr) - (char*)o;
 821
 822         if (o->vtable->klass == mono_defaults.thread_class && offset == G_STRUCT_OFFSET (MonoThread, internal_thread))
 823                 return TRUE;
 824         if (o->vtable->klass == mono_defaults.internal_thread_class && offset == G_STRUCT_OFFSET (MonoInternalThread, current_appcontext))
 825                 return TRUE;
 826
 827 #ifndef DISABLE_REMOTING
 828         if (mono_defaults.real_proxy_class->supertypes && mono_class_has_parent_fast (o->vtable->klass, mono_defaults.real_proxy_class) &&
 829                         offset == G_STRUCT_OFFSET (MonoRealProxy, unwrapped_server))
 830                 return TRUE;
 831 #endif
 832         /* Thread.cached_culture_info */
 833         if (!strcmp (ref->vtable->klass->name_space, "System.Globalization") &&
 834                         !strcmp (ref->vtable->klass->name, "CultureInfo") &&
 835                         !strcmp(o->vtable->klass->name_space, "System") &&
 836                         !strcmp(o->vtable->klass->name, "Object[]"))
 837                 return TRUE;
 838         /*
 839          *  at System.IO.MemoryStream.InternalConstructor (byte[],int,int,bool,bool) [0x0004d] in /home/schani/Work/novell/trunk/mcs/class/corlib/System.IO/MemoryStream.cs:121
 840          * at System.IO.MemoryStream..ctor (byte[]) [0x00017] in /home/schani/Work/novell/trunk/mcs/class/corlib/System.IO/MemoryStream.cs:81
 841          * at (wrapper remoting-invoke-with-check) System.IO.MemoryStream..ctor (byte[]) <IL 0x00020, 0xffffffff>
 842          * at System.Runtime.Remoting.Messaging.CADMethodCallMessage.GetArguments () [0x0000d] in /home/schani/Work/novell/trunk/mcs/class/corlib/System.Runtime.Remoting.Messaging/CADMessages.cs:327
 843          * at System.Runtime.Remoting.Messaging.MethodCall..ctor (System.Runtime.Remoting.Messaging.CADMethodCallMessage) [0x00017] in /home/schani/Work/novell/trunk/mcs/class/corlib/System.Runtime.Remoting.Messaging/MethodCall.cs:87
 844          * at System.AppDomain.ProcessMessageInDomain (byte[],System.Runtime.Remoting.Messaging.CADMethodCallMessage,byte[]&,System.Runtime.Remoting.Messaging.CADMethodReturnMessage&) [0x00018] in /home/schani/Work/novell/trunk/mcs/class/corlib/System/AppDomain.cs:1213
 845          * at (wrapper remoting-invoke-with-check) System.AppDomain.ProcessMessageInDomain (byte[],System.Runtime.Remoting.Messaging.CADMethodCallMessage,byte[]&,System.Runtime.Remoting.Messaging.CADMethodReturnMessage&) <IL 0x0003d, 0xffffffff>
 846          * at System.Runtime.Remoting.Channels.CrossAppDomainSink.ProcessMessageInDomain (byte[],System.Runtime.Remoting.Messaging.CADMethodCallMessage) [0x00008] in /home/schani/Work/novell/trunk/mcs/class/corlib/System.Runtime.Remoting.Channels/CrossAppDomainChannel.cs:198
 847          * at (wrapper runtime-invoke) object.runtime_invoke_CrossAppDomainSink/ProcessMessageRes_object_object (object,intptr,intptr,intptr) <IL 0x0004c, 0xffffffff>
 848          */
 849         if (!strcmp (ref->vtable->klass->name_space, "System") &&
 850                         !strcmp (ref->vtable->klass->name, "Byte[]") &&
 851                         !strcmp (o->vtable->klass->name_space, "System.IO") &&
 852                         !strcmp (o->vtable->klass->name, "MemoryStream"))
 853                 return TRUE;
 854         /* append_job() in threadpool.c */
 855         if (!strcmp (ref->vtable->klass->name_space, "System.Runtime.Remoting.Messaging") &&
 856                         !strcmp (ref->vtable->klass->name, "AsyncResult") &&
 857                         !strcmp (o->vtable->klass->name_space, "System") &&
 858                         !strcmp (o->vtable->klass->name, "Object[]") &&
 859                         mono_thread_pool_is_queue_array ((MonoArray*) o))
 860                 return TRUE;
 861         return FALSE;
 862 }
 863
 864 static void
 865 check_reference_for_xdomain (gpointer *ptr, char *obj, MonoDomain *domain)
 866 {
 867         MonoObject *o = (MonoObject*)(obj);
 868         MonoObject *ref = (MonoObject*)*(ptr);
 869         size_t offset = (char*)(ptr) - (char*)o;
 870         MonoClass *class;
 871         MonoClassField *field;
 872         char *str;
 873
 874         if (!ref || ref->vtable->domain == domain)
 875                 return;
 876         if (is_xdomain_ref_allowed (ptr, obj, domain))
 877                 return;
 878
 879         field = NULL;
 880         for (class = o->vtable->klass; class; class = class->parent) {
 881                 int i;
 882
 883                 for (i = 0; i < class->field.count; ++i) {
 884                         if (class->fields[i].offset == offset) {
 885                                 field = &class->fields[i];
 886                                 break;
 887                         }
 888                 }
 889                 if (field)
 890                         break;
 891         }
 892
 893         if (ref->vtable->klass == mono_defaults.string_class)
 894                 str = mono_string_to_utf8 ((MonoString*)ref);
 895         else
 896                 str = NULL;
 897         g_print ("xdomain reference in %p (%s.%s) at offset %d (%s) to %p (%s.%s) (%s)  -  pointed to by:\n",
 898                         o, o->vtable->klass->name_space, o->vtable->klass->name,
 899                         offset, field ? field->name : "",
 900                         ref, ref->vtable->klass->name_space, ref->vtable->klass->name, str ? str : "");
 901         mono_gc_scan_for_specific_ref (o, TRUE);
 902         if (str)
 903                 g_free (str);
 904 }
 905
 906 #undef HANDLE_PTR
 907 #define HANDLE_PTR(ptr,obj)     check_reference_for_xdomain ((ptr), (obj), domain)
 908
 909 static void
 910 scan_object_for_xdomain_refs (char *start, mword size, void *data)
 911 {
 912         MonoVTable *vt = (MonoVTable*)SGEN_LOAD_VTABLE (start);
 913         MonoDomain *domain = vt->domain;
 914         mword desc = sgen_vtable_get_descriptor (vt);
 915
 916         #include "sgen-scan-object.h"
 917 }
 918
 919 void
 920 sgen_check_for_xdomain_refs (void)
 921 {
 922         LOSObject *bigobj;
 923
 924         sgen_scan_area_with_callback (nursery_section->data, nursery_section->end_data,
 925                         (IterateObjectCallbackFunc)scan_object_for_xdomain_refs, NULL, FALSE);
 926
 927         major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_ALL, (IterateObjectCallbackFunc)scan_object_for_xdomain_refs, NULL);
 928
 929         for (bigobj = los_object_list; bigobj; bigobj = bigobj->next)
 930                 scan_object_for_xdomain_refs (bigobj->data, sgen_los_object_size (bigobj), NULL);
 931 }
 932
 933 static int
 934 compare_xrefs (const void *a_ptr, const void *b_ptr)
 935 {
 936         const MonoGCBridgeXRef *a = a_ptr;
 937         const MonoGCBridgeXRef *b = b_ptr;
 938
 939         if (a->src_scc_index < b->src_scc_index)
 940                 return -1;
 941         if (a->src_scc_index > b->src_scc_index)
 942                 return 1;
 943
 944         if (a->dst_scc_index < b->dst_scc_index)
 945                 return -1;
 946         if (a->dst_scc_index > b->dst_scc_index)
 947                 return 1;
 948
 949         return 0;
 950 }
 951
 952 /*
 953 static void
 954 dump_processor_state (SgenBridgeProcessor *p)
 955 {
 956         int i;
 957
 958         printf ("------\n");
 959         printf ("SCCS %d\n", p->num_sccs);
 960         for (i = 0; i < p->num_sccs; ++i) {
 961                 int j;
 962                 MonoGCBridgeSCC *scc = p->api_sccs [i];
 963                 printf ("\tSCC %d:", i);
 964                 for (j = 0; j < scc->num_objs; ++j) {
 965                         MonoObject *obj = scc->objs [j];
 966                         printf (" %p", obj);
 967                 }
 968                 printf ("\n");
 969         }
 970
 971         printf ("XREFS %d\n", p->num_xrefs);
 972         for (i = 0; i < p->num_xrefs; ++i)
 973                 printf ("\t%d -> %d\n", p->api_xrefs [i].src_scc_index, p->api_xrefs [i].dst_scc_index);
 974
 975         printf ("-------\n");
 976 }
 977 */
 978
 979 gboolean
 980 sgen_compare_bridge_processor_results (SgenBridgeProcessor *a, SgenBridgeProcessor *b)
 981 {
 982         int i;
 983         SgenHashTable obj_to_a_scc = SGEN_HASH_TABLE_INIT (INTERNAL_MEM_BRIDGE_DEBUG, INTERNAL_MEM_BRIDGE_DEBUG, sizeof (int), mono_aligned_addr_hash, NULL);
 984         SgenHashTable b_scc_to_a_scc = SGEN_HASH_TABLE_INIT (INTERNAL_MEM_BRIDGE_DEBUG, INTERNAL_MEM_BRIDGE_DEBUG, sizeof (int), g_direct_hash, NULL);
 985         MonoGCBridgeXRef *a_xrefs, *b_xrefs;
 986         size_t xrefs_alloc_size;
 987
 988         // dump_processor_state (a);
 989         // dump_processor_state (b);
 990
 991         if (a->num_sccs != b->num_sccs)
 992                 g_error ("SCCS count expected %d but got %d", a->num_sccs, b->num_sccs);
 993         if (a->num_xrefs != b->num_xrefs)
 994                 g_error ("SCCS count expected %d but got %d", a->num_xrefs, b->num_xrefs);
 995
 996         /*
 997          * First we build a hash of each object in `a` to its respective SCC index within
 998          * `a`.  Along the way we also assert that no object is more than one SCC.
 999          */
1000         for (i = 0; i < a->num_sccs; ++i) {
1001                 int j;
1002                 MonoGCBridgeSCC *scc = a->api_sccs [i];
1003
1004                 g_assert (scc->num_objs > 0);
1005
1006                 for (j = 0; j < scc->num_objs; ++j) {
1007                         MonoObject *obj = scc->objs [j];
1008                         gboolean new_entry = sgen_hash_table_replace (&obj_to_a_scc, obj, &i, NULL);
1009                         g_assert (new_entry);
1010                 }
1011         }
1012
1013         /*
1014          * Now we check whether each of the objects in `b` are in `a`, and whether the SCCs
1015          * of `b` contain the same sets of objects as those of `a`.
1016          *
1017          * While we're doing this, build a hash table to map from `b` SCC indexes to `a` SCC
1018          * indexes.
1019          */
1020         for (i = 0; i < b->num_sccs; ++i) {
1021                 MonoGCBridgeSCC *scc = b->api_sccs [i];
1022                 MonoGCBridgeSCC *a_scc;
1023                 int *a_scc_index_ptr;
1024                 int a_scc_index;
1025                 int j;
1026                 gboolean new_entry;
1027
1028                 g_assert (scc->num_objs > 0);
1029                 a_scc_index_ptr = sgen_hash_table_lookup (&obj_to_a_scc, scc->objs [0]);
1030                 g_assert (a_scc_index_ptr);
1031                 a_scc_index = *a_scc_index_ptr;
1032
1033                 //g_print ("A SCC %d -> B SCC %d\n", a_scc_index, i);
1034
1035                 a_scc = a->api_sccs [a_scc_index];
1036                 g_assert (a_scc->num_objs == scc->num_objs);
1037
1038                 for (j = 1; j < scc->num_objs; ++j) {
1039                         a_scc_index_ptr = sgen_hash_table_lookup (&obj_to_a_scc, scc->objs [j]);
1040                         g_assert (a_scc_index_ptr);
1041                         g_assert (*a_scc_index_ptr == a_scc_index);
1042                 }
1043
1044                 new_entry = sgen_hash_table_replace (&b_scc_to_a_scc, GINT_TO_POINTER (i), &a_scc_index, NULL);
1045                 g_assert (new_entry);
1046         }
1047
1048         /*
1049          * Finally, check that we have the same xrefs.  We do this by making copies of both
1050          * xref arrays, and replacing the SCC indexes in the copy for `b` with the
1051          * corresponding indexes in `a`.  Then we sort both arrays and assert that they're
1052          * the same.
1053          *
1054          * At the same time, check that no xref is self-referential and that there are no
1055          * duplicate ones.
1056          */
1057
1058         xrefs_alloc_size = a->num_xrefs * sizeof (MonoGCBridgeXRef);
1059         a_xrefs = sgen_alloc_internal_dynamic (xrefs_alloc_size, INTERNAL_MEM_BRIDGE_DEBUG, TRUE);
1060         b_xrefs = sgen_alloc_internal_dynamic (xrefs_alloc_size, INTERNAL_MEM_BRIDGE_DEBUG, TRUE);
1061
1062         memcpy (a_xrefs, a->api_xrefs, xrefs_alloc_size);
1063         for (i = 0; i < b->num_xrefs; ++i) {
1064                 MonoGCBridgeXRef *xref = &b->api_xrefs [i];
1065                 int *scc_index_ptr;
1066
1067                 g_assert (xref->src_scc_index != xref->dst_scc_index);
1068
1069                 scc_index_ptr = sgen_hash_table_lookup (&b_scc_to_a_scc, GINT_TO_POINTER (xref->src_scc_index));
1070                 g_assert (scc_index_ptr);
1071                 b_xrefs [i].src_scc_index = *scc_index_ptr;
1072
1073                 scc_index_ptr = sgen_hash_table_lookup (&b_scc_to_a_scc, GINT_TO_POINTER (xref->dst_scc_index));
1074                 g_assert (scc_index_ptr);
1075                 b_xrefs [i].dst_scc_index = *scc_index_ptr;
1076         }
1077
1078         qsort (a_xrefs, a->num_xrefs, sizeof (MonoGCBridgeXRef), compare_xrefs);
1079         qsort (b_xrefs, a->num_xrefs, sizeof (MonoGCBridgeXRef), compare_xrefs);
1080
1081         for (i = 0; i < a->num_xrefs; ++i) {
1082                 g_assert (a_xrefs [i].src_scc_index == b_xrefs [i].src_scc_index);
1083                 g_assert (a_xrefs [i].dst_scc_index == b_xrefs [i].dst_scc_index);
1084         }
1085
1086         sgen_hash_table_clean (&obj_to_a_scc);
1087         sgen_hash_table_clean (&b_scc_to_a_scc);
1088         sgen_free_internal_dynamic (a_xrefs, xrefs_alloc_size, INTERNAL_MEM_BRIDGE_DEBUG);
1089         sgen_free_internal_dynamic (b_xrefs, xrefs_alloc_size, INTERNAL_MEM_BRIDGE_DEBUG);
1090
1091         return TRUE;
1092 }
1093
1094 #endif /*HAVE_SGEN_GC*/