Annotation of OpenXM_contrib2/asir2000/gc5.3/dbg_mlc.c, Revision 1.1
1.1 ! noro 1: /*
! 2: * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
! 3: * Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved.
! 4: * Copyright (c) 1997 by Silicon Graphics. All rights reserved.
! 5: * Copyright (c) 1999 by Hewlett-Packard Company. All rights reserved.
! 6: *
! 7: * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
! 8: * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
! 9: *
! 10: * Permission is hereby granted to use or copy this program
! 11: * for any purpose, provided the above notices are retained on all copies.
! 12: * Permission to modify the code and to distribute modified code is granted,
! 13: * provided the above notices are retained, and a notice that the code was
! 14: * modified is included with the above copyright notice.
! 15: */
! 16:
! 17: #include "dbg_mlc.h"
! 18:
! 19: void GC_default_print_heap_obj_proc();
! 20: GC_API void GC_register_finalizer_no_order
! 21: GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
! 22: GC_finalization_proc *ofn, GC_PTR *ocd));
! 23:
! 24:
! 25: /* Check whether object with base pointer p has debugging info */
! 26: /* p is assumed to point to a legitimate object in our part */
! 27: /* of the heap. */
! 28: GC_bool GC_has_debug_info(p)
! 29: ptr_t p;
! 30: {
! 31: register oh * ohdr = (oh *)p;
! 32: register ptr_t body = (ptr_t)(ohdr + 1);
! 33: register word sz = GC_size((ptr_t) ohdr);
! 34:
! 35: if (HBLKPTR((ptr_t)ohdr) != HBLKPTR((ptr_t)body)
! 36: || sz < sizeof (oh)) {
! 37: return(FALSE);
! 38: }
! 39: if (ohdr -> oh_sz == sz) {
! 40: /* Object may have had debug info, but has been deallocated */
! 41: return(FALSE);
! 42: }
! 43: if (ohdr -> oh_sf == (START_FLAG ^ (word)body)) return(TRUE);
! 44: if (((word *)ohdr)[BYTES_TO_WORDS(sz)-1] == (END_FLAG ^ (word)body)) {
! 45: return(TRUE);
! 46: }
! 47: return(FALSE);
! 48: }
! 49:
! 50: #ifdef KEEP_BACK_PTRS
! 51: /* Store back pointer to source in dest, if that appears to be possible. */
! 52: /* This is not completely safe, since we may mistakenly conclude that */
! 53: /* dest has a debugging wrapper. But the error probability is very */
! 54: /* small, and this shouldn't be used in production code. */
! 55: /* We assume that dest is the real base pointer. Source will usually */
! 56: /* be a pointer to the interior of an object. */
! 57: void GC_store_back_pointer(ptr_t source, ptr_t dest)
! 58: {
! 59: if (GC_has_debug_info(dest)) {
! 60: ((oh *)dest) -> oh_back_ptr = (ptr_t)HIDE_POINTER(source);
! 61: }
! 62: }
! 63:
! 64: void GC_marked_for_finalization(ptr_t dest) {
! 65: GC_store_back_pointer(MARKED_FOR_FINALIZATION, dest);
! 66: }
! 67:
! 68: /* Store information about the object referencing dest in *base_p */
! 69: /* and *offset_p. */
! 70: /* source is root ==> *base_p = address, *offset_p = 0 */
! 71: /* source is heap object ==> *base_p != 0, *offset_p = offset */
! 72: /* Returns 1 on success, 0 if source couldn't be determined. */
! 73: /* Dest can be any address within a heap object. */
! 74: GC_ref_kind GC_get_back_ptr_info(void *dest, void **base_p, size_t *offset_p)
! 75: {
! 76: oh * hdr = (oh *)GC_base(dest);
! 77: ptr_t bp;
! 78: ptr_t bp_base;
! 79: if (!GC_has_debug_info((ptr_t) hdr)) return GC_NO_SPACE;
! 80: bp = hdr -> oh_back_ptr;
! 81: if (MARKED_FOR_FINALIZATION == bp) return GC_FINALIZER_REFD;
! 82: if (MARKED_FROM_REGISTER == bp) return GC_REFD_FROM_REG;
! 83: if (0 == bp) return GC_UNREFERENCED;
! 84: bp = REVEAL_POINTER(bp);
! 85: bp_base = GC_base(bp);
! 86: if (0 == bp_base) {
! 87: *base_p = bp;
! 88: *offset_p = 0;
! 89: return GC_REFD_FROM_ROOT;
! 90: } else {
! 91: if (GC_has_debug_info(bp_base)) bp_base += sizeof(oh);
! 92: *base_p = bp_base;
! 93: *offset_p = bp - bp_base;
! 94: return GC_REFD_FROM_HEAP;
! 95: }
! 96: }
! 97:
! 98: /* Generate a random heap address. */
! 99: /* The resulting address is in the heap, but */
! 100: /* not necessarily inside a valid object. */
! 101: void *GC_generate_random_heap_address(void)
! 102: {
! 103: int i;
! 104: int heap_offset = random() % GC_heapsize;
! 105: for (i = 0; i < GC_n_heap_sects; ++ i) {
! 106: int size = GC_heap_sects[i].hs_bytes;
! 107: if (heap_offset < size) {
! 108: return GC_heap_sects[i].hs_start + heap_offset;
! 109: } else {
! 110: heap_offset -= size;
! 111: }
! 112: }
! 113: ABORT("GC_generate_random_heap_address: size inconsistency");
! 114: /*NOTREACHED*/
! 115: return 0;
! 116: }
! 117:
! 118: /* Generate a random address inside a valid marked heap object. */
! 119: void *GC_generate_random_valid_address(void)
! 120: {
! 121: ptr_t result;
! 122: ptr_t base;
! 123: for (;;) {
! 124: result = GC_generate_random_heap_address();
! 125: base = GC_base(result);
! 126: if (0 == base) continue;
! 127: if (!GC_is_marked(base)) continue;
! 128: return result;
! 129: }
! 130: }
! 131:
! 132: /* Print back trace for p */
! 133: void GC_print_backtrace(void *p)
! 134: {
! 135: void *current = p;
! 136: int i;
! 137: GC_ref_kind source;
! 138: size_t offset;
! 139: void *base;
! 140:
! 141: GC_print_heap_obj(GC_base(current));
! 142: GC_err_printf0("\n");
! 143: for (i = 0; ; ++i) {
! 144: source = GC_get_back_ptr_info(current, &base, &offset);
! 145: if (GC_UNREFERENCED == source) {
! 146: GC_err_printf0("Reference could not be found\n");
! 147: goto out;
! 148: }
! 149: if (GC_NO_SPACE == source) {
! 150: GC_err_printf0("No debug info in object: Can't find reference\n");
! 151: goto out;
! 152: }
! 153: GC_err_printf1("Reachable via %d levels of pointers from ",
! 154: (unsigned long)i);
! 155: switch(source) {
! 156: case GC_REFD_FROM_ROOT:
! 157: GC_err_printf1("root at 0x%lx\n", (unsigned long)base);
! 158: goto out;
! 159: case GC_REFD_FROM_REG:
! 160: GC_err_printf0("root in register\n");
! 161: goto out;
! 162: case GC_FINALIZER_REFD:
! 163: GC_err_printf0("list of finalizable objects\n");
! 164: goto out;
! 165: case GC_REFD_FROM_HEAP:
! 166: GC_err_printf1("offset %ld in object:\n", (unsigned long)offset);
! 167: /* Take GC_base(base) to get real base, i.e. header. */
! 168: GC_print_heap_obj(GC_base(base));
! 169: GC_err_printf0("\n");
! 170: break;
! 171: }
! 172: current = base;
! 173: }
! 174: out:;
! 175: }
! 176:
! 177: /* Force a garbage collection and generate a backtrace from a */
! 178: /* random heap address. */
! 179: void GC_generate_random_backtrace(void)
! 180: {
! 181: void * current;
! 182: GC_gcollect();
! 183: current = GC_generate_random_valid_address();
! 184: GC_printf1("Chose address 0x%lx in object\n", (unsigned long)current);
! 185: GC_print_backtrace(current);
! 186: }
! 187:
! 188: #endif /* KEEP_BACK_PTRS */
! 189:
! 190: /* Store debugging info into p. Return displaced pointer. */
! 191: /* Assumes we don't hold allocation lock. */
! 192: ptr_t GC_store_debug_info(p, sz, string, integer)
! 193: register ptr_t p; /* base pointer */
! 194: word sz; /* bytes */
! 195: char * string;
! 196: word integer;
! 197: {
! 198: register word * result = (word *)((oh *)p + 1);
! 199: DCL_LOCK_STATE;
! 200:
! 201: /* There is some argument that we should dissble signals here. */
! 202: /* But that's expensive. And this way things should only appear */
! 203: /* inconsistent while we're in the handler. */
! 204: LOCK();
! 205: # ifdef KEEP_BACK_PTRS
! 206: ((oh *)p) -> oh_back_ptr = 0;
! 207: # endif
! 208: ((oh *)p) -> oh_string = string;
! 209: ((oh *)p) -> oh_int = integer;
! 210: ((oh *)p) -> oh_sz = sz;
! 211: ((oh *)p) -> oh_sf = START_FLAG ^ (word)result;
! 212: ((word *)p)[BYTES_TO_WORDS(GC_size(p))-1] =
! 213: result[ROUNDED_UP_WORDS(sz)] = END_FLAG ^ (word)result;
! 214: UNLOCK();
! 215: return((ptr_t)result);
! 216: }
! 217:
! 218: /* Check the object with debugging info at ohdr */
! 219: /* return NIL if it's OK. Else return clobbered */
! 220: /* address. */
! 221: ptr_t GC_check_annotated_obj(ohdr)
! 222: register oh * ohdr;
! 223: {
! 224: register ptr_t body = (ptr_t)(ohdr + 1);
! 225: register word gc_sz = GC_size((ptr_t)ohdr);
! 226: if (ohdr -> oh_sz + DEBUG_BYTES > gc_sz) {
! 227: return((ptr_t)(&(ohdr -> oh_sz)));
! 228: }
! 229: if (ohdr -> oh_sf != (START_FLAG ^ (word)body)) {
! 230: return((ptr_t)(&(ohdr -> oh_sf)));
! 231: }
! 232: if (((word *)ohdr)[BYTES_TO_WORDS(gc_sz)-1] != (END_FLAG ^ (word)body)) {
! 233: return((ptr_t)((word *)ohdr + BYTES_TO_WORDS(gc_sz)-1));
! 234: }
! 235: if (((word *)body)[ROUNDED_UP_WORDS(ohdr -> oh_sz)]
! 236: != (END_FLAG ^ (word)body)) {
! 237: return((ptr_t)((word *)body + ROUNDED_UP_WORDS(ohdr -> oh_sz)));
! 238: }
! 239: return(0);
! 240: }
! 241:
! 242: void GC_print_obj(p)
! 243: ptr_t p;
! 244: {
! 245: register oh * ohdr = (oh *)GC_base(p);
! 246:
! 247: GC_err_printf1("0x%lx (", ((unsigned long)ohdr + sizeof(oh)));
! 248: GC_err_puts(ohdr -> oh_string);
! 249: GC_err_printf2(":%ld, sz=%ld)\n", (unsigned long)(ohdr -> oh_int),
! 250: (unsigned long)(ohdr -> oh_sz));
! 251: PRINT_CALL_CHAIN(ohdr);
! 252: }
! 253:
! 254: void GC_debug_print_heap_obj_proc(p)
! 255: ptr_t p;
! 256: {
! 257: if (GC_has_debug_info(p)) {
! 258: GC_print_obj(p);
! 259: } else {
! 260: GC_default_print_heap_obj_proc(p);
! 261: }
! 262: }
! 263:
! 264: void GC_print_smashed_obj(p, clobbered_addr)
! 265: ptr_t p, clobbered_addr;
! 266: {
! 267: register oh * ohdr = (oh *)GC_base(p);
! 268:
! 269: GC_err_printf2("0x%lx in object at 0x%lx(", (unsigned long)clobbered_addr,
! 270: (unsigned long)p);
! 271: if (clobbered_addr <= (ptr_t)(&(ohdr -> oh_sz))
! 272: || ohdr -> oh_string == 0) {
! 273: GC_err_printf1("<smashed>, appr. sz = %ld)\n",
! 274: (GC_size((ptr_t)ohdr) - DEBUG_BYTES));
! 275: } else {
! 276: if (ohdr -> oh_string[0] == '\0') {
! 277: GC_err_puts("EMPTY(smashed?)");
! 278: } else {
! 279: GC_err_puts(ohdr -> oh_string);
! 280: }
! 281: GC_err_printf2(":%ld, sz=%ld)\n", (unsigned long)(ohdr -> oh_int),
! 282: (unsigned long)(ohdr -> oh_sz));
! 283: PRINT_CALL_CHAIN(ohdr);
! 284: }
! 285: }
! 286:
! 287: void GC_check_heap_proc();
! 288:
! 289: void GC_start_debugging()
! 290: {
! 291: GC_check_heap = GC_check_heap_proc;
! 292: GC_print_heap_obj = GC_debug_print_heap_obj_proc;
! 293: GC_debugging_started = TRUE;
! 294: GC_register_displacement((word)sizeof(oh));
! 295: }
! 296:
! 297: # if defined(__STDC__) || defined(__cplusplus)
! 298: void GC_debug_register_displacement(GC_word offset)
! 299: # else
! 300: void GC_debug_register_displacement(offset)
! 301: GC_word offset;
! 302: # endif
! 303: {
! 304: GC_register_displacement(offset);
! 305: GC_register_displacement((word)sizeof(oh) + offset);
! 306: }
! 307:
! 308: # ifdef __STDC__
! 309: GC_PTR GC_debug_malloc(size_t lb, GC_EXTRA_PARAMS)
! 310: # else
! 311: GC_PTR GC_debug_malloc(lb, s, i)
! 312: size_t lb;
! 313: char * s;
! 314: int i;
! 315: # ifdef GC_ADD_CALLER
! 316: --> GC_ADD_CALLER not implemented for K&R C
! 317: # endif
! 318: # endif
! 319: {
! 320: GC_PTR result = GC_malloc(lb + DEBUG_BYTES);
! 321:
! 322: if (result == 0) {
! 323: GC_err_printf1("GC_debug_malloc(%ld) returning NIL (",
! 324: (unsigned long) lb);
! 325: GC_err_puts(s);
! 326: GC_err_printf1(":%ld)\n", (unsigned long)i);
! 327: return(0);
! 328: }
! 329: if (!GC_debugging_started) {
! 330: GC_start_debugging();
! 331: }
! 332: ADD_CALL_CHAIN(result, ra);
! 333: return (GC_store_debug_info(result, (word)lb, s, (word)i));
! 334: }
! 335:
! 336: #ifdef STUBBORN_ALLOC
! 337: # ifdef __STDC__
! 338: GC_PTR GC_debug_malloc_stubborn(size_t lb, GC_EXTRA_PARAMS)
! 339: # else
! 340: GC_PTR GC_debug_malloc_stubborn(lb, s, i)
! 341: size_t lb;
! 342: char * s;
! 343: int i;
! 344: # endif
! 345: {
! 346: GC_PTR result = GC_malloc_stubborn(lb + DEBUG_BYTES);
! 347:
! 348: if (result == 0) {
! 349: GC_err_printf1("GC_debug_malloc(%ld) returning NIL (",
! 350: (unsigned long) lb);
! 351: GC_err_puts(s);
! 352: GC_err_printf1(":%ld)\n", (unsigned long)i);
! 353: return(0);
! 354: }
! 355: if (!GC_debugging_started) {
! 356: GC_start_debugging();
! 357: }
! 358: ADD_CALL_CHAIN(result, ra);
! 359: return (GC_store_debug_info(result, (word)lb, s, (word)i));
! 360: }
! 361:
! 362: void GC_debug_change_stubborn(p)
! 363: GC_PTR p;
! 364: {
! 365: register GC_PTR q = GC_base(p);
! 366: register hdr * hhdr;
! 367:
! 368: if (q == 0) {
! 369: GC_err_printf1("Bad argument: 0x%lx to GC_debug_change_stubborn\n",
! 370: (unsigned long) p);
! 371: ABORT("GC_debug_change_stubborn: bad arg");
! 372: }
! 373: hhdr = HDR(q);
! 374: if (hhdr -> hb_obj_kind != STUBBORN) {
! 375: GC_err_printf1("GC_debug_change_stubborn arg not stubborn: 0x%lx\n",
! 376: (unsigned long) p);
! 377: ABORT("GC_debug_change_stubborn: arg not stubborn");
! 378: }
! 379: GC_change_stubborn(q);
! 380: }
! 381:
! 382: void GC_debug_end_stubborn_change(p)
! 383: GC_PTR p;
! 384: {
! 385: register GC_PTR q = GC_base(p);
! 386: register hdr * hhdr;
! 387:
! 388: if (q == 0) {
! 389: GC_err_printf1("Bad argument: 0x%lx to GC_debug_end_stubborn_change\n",
! 390: (unsigned long) p);
! 391: ABORT("GC_debug_end_stubborn_change: bad arg");
! 392: }
! 393: hhdr = HDR(q);
! 394: if (hhdr -> hb_obj_kind != STUBBORN) {
! 395: GC_err_printf1("debug_end_stubborn_change arg not stubborn: 0x%lx\n",
! 396: (unsigned long) p);
! 397: ABORT("GC_debug_end_stubborn_change: arg not stubborn");
! 398: }
! 399: GC_end_stubborn_change(q);
! 400: }
! 401:
! 402: #else /* !STUBBORN_ALLOC */
! 403:
! 404: # ifdef __STDC__
! 405: GC_PTR GC_debug_malloc_stubborn(size_t lb, GC_EXTRA_PARAMS)
! 406: # else
! 407: GC_PTR GC_debug_malloc_stubborn(lb, s, i)
! 408: size_t lb;
! 409: char * s;
! 410: int i;
! 411: # endif
! 412: {
! 413: return GC_debug_malloc(lb, OPT_RA s, i);
! 414: }
! 415:
! 416: void GC_debug_change_stubborn(p)
! 417: GC_PTR p;
! 418: {
! 419: }
! 420:
! 421: void GC_debug_end_stubborn_change(p)
! 422: GC_PTR p;
! 423: {
! 424: }
! 425:
! 426: #endif /* !STUBBORN_ALLOC */
! 427:
! 428: # ifdef __STDC__
! 429: GC_PTR GC_debug_malloc_atomic(size_t lb, GC_EXTRA_PARAMS)
! 430: # else
! 431: GC_PTR GC_debug_malloc_atomic(lb, s, i)
! 432: size_t lb;
! 433: char * s;
! 434: int i;
! 435: # endif
! 436: {
! 437: GC_PTR result = GC_malloc_atomic(lb + DEBUG_BYTES);
! 438:
! 439: if (result == 0) {
! 440: GC_err_printf1("GC_debug_malloc_atomic(%ld) returning NIL (",
! 441: (unsigned long) lb);
! 442: GC_err_puts(s);
! 443: GC_err_printf1(":%ld)\n", (unsigned long)i);
! 444: return(0);
! 445: }
! 446: if (!GC_debugging_started) {
! 447: GC_start_debugging();
! 448: }
! 449: ADD_CALL_CHAIN(result, ra);
! 450: return (GC_store_debug_info(result, (word)lb, s, (word)i));
! 451: }
! 452:
! 453: # ifdef __STDC__
! 454: GC_PTR GC_debug_malloc_uncollectable(size_t lb, GC_EXTRA_PARAMS)
! 455: # else
! 456: GC_PTR GC_debug_malloc_uncollectable(lb, s, i)
! 457: size_t lb;
! 458: char * s;
! 459: int i;
! 460: # endif
! 461: {
! 462: GC_PTR result = GC_malloc_uncollectable(lb + DEBUG_BYTES);
! 463:
! 464: if (result == 0) {
! 465: GC_err_printf1("GC_debug_malloc_uncollectable(%ld) returning NIL (",
! 466: (unsigned long) lb);
! 467: GC_err_puts(s);
! 468: GC_err_printf1(":%ld)\n", (unsigned long)i);
! 469: return(0);
! 470: }
! 471: if (!GC_debugging_started) {
! 472: GC_start_debugging();
! 473: }
! 474: ADD_CALL_CHAIN(result, ra);
! 475: return (GC_store_debug_info(result, (word)lb, s, (word)i));
! 476: }
! 477:
! 478: #ifdef ATOMIC_UNCOLLECTABLE
! 479: # ifdef __STDC__
! 480: GC_PTR GC_debug_malloc_atomic_uncollectable(size_t lb, GC_EXTRA_PARAMS)
! 481: # else
! 482: GC_PTR GC_debug_malloc_atomic_uncollectable(lb, s, i)
! 483: size_t lb;
! 484: char * s;
! 485: int i;
! 486: # endif
! 487: {
! 488: GC_PTR result = GC_malloc_atomic_uncollectable(lb + DEBUG_BYTES);
! 489:
! 490: if (result == 0) {
! 491: GC_err_printf1(
! 492: "GC_debug_malloc_atomic_uncollectable(%ld) returning NIL (",
! 493: (unsigned long) lb);
! 494: GC_err_puts(s);
! 495: GC_err_printf1(":%ld)\n", (unsigned long)i);
! 496: return(0);
! 497: }
! 498: if (!GC_debugging_started) {
! 499: GC_start_debugging();
! 500: }
! 501: ADD_CALL_CHAIN(result, ra);
! 502: return (GC_store_debug_info(result, (word)lb, s, (word)i));
! 503: }
! 504: #endif /* ATOMIC_UNCOLLECTABLE */
! 505:
! 506: # ifdef __STDC__
! 507: void GC_debug_free(GC_PTR p)
! 508: # else
! 509: void GC_debug_free(p)
! 510: GC_PTR p;
! 511: # endif
! 512: {
! 513: register GC_PTR base;
! 514: register ptr_t clobbered;
! 515:
! 516: if (0 == p) return;
! 517: base = GC_base(p);
! 518: if (base == 0) {
! 519: GC_err_printf1("Attempt to free invalid pointer %lx\n",
! 520: (unsigned long)p);
! 521: ABORT("free(invalid pointer)");
! 522: }
! 523: if ((ptr_t)p - (ptr_t)base != sizeof(oh)) {
! 524: GC_err_printf1(
! 525: "GC_debug_free called on pointer %lx wo debugging info\n",
! 526: (unsigned long)p);
! 527: } else {
! 528: clobbered = GC_check_annotated_obj((oh *)base);
! 529: if (clobbered != 0) {
! 530: if (((oh *)base) -> oh_sz == GC_size(base)) {
! 531: GC_err_printf0(
! 532: "GC_debug_free: found previously deallocated (?) object at ");
! 533: } else {
! 534: GC_err_printf0("GC_debug_free: found smashed location at ");
! 535: }
! 536: GC_print_smashed_obj(p, clobbered);
! 537: }
! 538: /* Invalidate size */
! 539: ((oh *)base) -> oh_sz = GC_size(base);
! 540: }
! 541: if (GC_find_leak) {
! 542: GC_free(base);
! 543: } else {
! 544: register hdr * hhdr = HDR(p);
! 545: GC_bool uncollectable = FALSE;
! 546:
! 547: if (hhdr -> hb_obj_kind == UNCOLLECTABLE) {
! 548: uncollectable = TRUE;
! 549: }
! 550: # ifdef ATOMIC_UNCOLLECTABLE
! 551: if (hhdr -> hb_obj_kind == AUNCOLLECTABLE) {
! 552: uncollectable = TRUE;
! 553: }
! 554: # endif
! 555: if (uncollectable) GC_free(base);
! 556: } /* !GC_find_leak */
! 557: }
! 558:
! 559: # ifdef __STDC__
! 560: GC_PTR GC_debug_realloc(GC_PTR p, size_t lb, GC_EXTRA_PARAMS)
! 561: # else
! 562: GC_PTR GC_debug_realloc(p, lb, s, i)
! 563: GC_PTR p;
! 564: size_t lb;
! 565: char *s;
! 566: int i;
! 567: # endif
! 568: {
! 569: register GC_PTR base = GC_base(p);
! 570: register ptr_t clobbered;
! 571: register GC_PTR result;
! 572: register size_t copy_sz = lb;
! 573: register size_t old_sz;
! 574: register hdr * hhdr;
! 575:
! 576: if (p == 0) return(GC_debug_malloc(lb, OPT_RA s, i));
! 577: if (base == 0) {
! 578: GC_err_printf1(
! 579: "Attempt to reallocate invalid pointer %lx\n", (unsigned long)p);
! 580: ABORT("realloc(invalid pointer)");
! 581: }
! 582: if ((ptr_t)p - (ptr_t)base != sizeof(oh)) {
! 583: GC_err_printf1(
! 584: "GC_debug_realloc called on pointer %lx wo debugging info\n",
! 585: (unsigned long)p);
! 586: return(GC_realloc(p, lb));
! 587: }
! 588: hhdr = HDR(base);
! 589: switch (hhdr -> hb_obj_kind) {
! 590: # ifdef STUBBORN_ALLOC
! 591: case STUBBORN:
! 592: result = GC_debug_malloc_stubborn(lb, OPT_RA s, i);
! 593: break;
! 594: # endif
! 595: case NORMAL:
! 596: result = GC_debug_malloc(lb, OPT_RA s, i);
! 597: break;
! 598: case PTRFREE:
! 599: result = GC_debug_malloc_atomic(lb, OPT_RA s, i);
! 600: break;
! 601: case UNCOLLECTABLE:
! 602: result = GC_debug_malloc_uncollectable(lb, OPT_RA s, i);
! 603: break;
! 604: # ifdef ATOMIC_UNCOLLECTABLE
! 605: case AUNCOLLECTABLE:
! 606: result = GC_debug_malloc_atomic_uncollectable(lb, OPT_RA s, i);
! 607: break;
! 608: # endif
! 609: default:
! 610: GC_err_printf0("GC_debug_realloc: encountered bad kind\n");
! 611: ABORT("bad kind");
! 612: }
! 613: clobbered = GC_check_annotated_obj((oh *)base);
! 614: if (clobbered != 0) {
! 615: GC_err_printf0("GC_debug_realloc: found smashed location at ");
! 616: GC_print_smashed_obj(p, clobbered);
! 617: }
! 618: old_sz = ((oh *)base) -> oh_sz;
! 619: if (old_sz < copy_sz) copy_sz = old_sz;
! 620: if (result == 0) return(0);
! 621: BCOPY(p, result, copy_sz);
! 622: GC_debug_free(p);
! 623: return(result);
! 624: }
! 625:
! 626: /* Check all marked objects in the given block for validity */
! 627: /*ARGSUSED*/
! 628: void GC_check_heap_block(hbp, dummy)
! 629: register struct hblk *hbp; /* ptr to current heap block */
! 630: word dummy;
! 631: {
! 632: register struct hblkhdr * hhdr = HDR(hbp);
! 633: register word sz = hhdr -> hb_sz;
! 634: register int word_no;
! 635: register word *p, *plim;
! 636:
! 637: p = (word *)(hbp->hb_body);
! 638: word_no = HDR_WORDS;
! 639: if (sz > MAXOBJSZ) {
! 640: plim = p;
! 641: } else {
! 642: plim = (word *)((((word)hbp) + HBLKSIZE) - WORDS_TO_BYTES(sz));
! 643: }
! 644: /* go through all words in block */
! 645: while( p <= plim ) {
! 646: if( mark_bit_from_hdr(hhdr, word_no)
! 647: && GC_has_debug_info((ptr_t)p)) {
! 648: ptr_t clobbered = GC_check_annotated_obj((oh *)p);
! 649:
! 650: if (clobbered != 0) {
! 651: GC_err_printf0(
! 652: "GC_check_heap_block: found smashed location at ");
! 653: GC_print_smashed_obj((ptr_t)p, clobbered);
! 654: }
! 655: }
! 656: word_no += sz;
! 657: p += sz;
! 658: }
! 659: }
! 660:
! 661:
! 662: /* This assumes that all accessible objects are marked, and that */
! 663: /* I hold the allocation lock. Normally called by collector. */
! 664: void GC_check_heap_proc()
! 665: {
! 666: # ifndef SMALL_CONFIG
! 667: if (sizeof(oh) & (2 * sizeof(word) - 1) != 0) {
! 668: ABORT("Alignment problem: object header has inappropriate size\n");
! 669: }
! 670: # endif
! 671: GC_apply_to_all_blocks(GC_check_heap_block, (word)0);
! 672: }
! 673:
! 674: struct closure {
! 675: GC_finalization_proc cl_fn;
! 676: GC_PTR cl_data;
! 677: };
! 678:
! 679: # ifdef __STDC__
! 680: void * GC_make_closure(GC_finalization_proc fn, void * data)
! 681: # else
! 682: GC_PTR GC_make_closure(fn, data)
! 683: GC_finalization_proc fn;
! 684: GC_PTR data;
! 685: # endif
! 686: {
! 687: struct closure * result =
! 688: (struct closure *) GC_malloc(sizeof (struct closure));
! 689:
! 690: result -> cl_fn = fn;
! 691: result -> cl_data = data;
! 692: return((GC_PTR)result);
! 693: }
! 694:
! 695: # ifdef __STDC__
! 696: void GC_debug_invoke_finalizer(void * obj, void * data)
! 697: # else
! 698: void GC_debug_invoke_finalizer(obj, data)
! 699: char * obj;
! 700: char * data;
! 701: # endif
! 702: {
! 703: register struct closure * cl = (struct closure *) data;
! 704:
! 705: (*(cl -> cl_fn))((GC_PTR)((char *)obj + sizeof(oh)), cl -> cl_data);
! 706: }
! 707:
! 708:
! 709: # ifdef __STDC__
! 710: void GC_debug_register_finalizer(GC_PTR obj, GC_finalization_proc fn,
! 711: GC_PTR cd, GC_finalization_proc *ofn,
! 712: GC_PTR *ocd)
! 713: # else
! 714: void GC_debug_register_finalizer(obj, fn, cd, ofn, ocd)
! 715: GC_PTR obj;
! 716: GC_finalization_proc fn;
! 717: GC_PTR cd;
! 718: GC_finalization_proc *ofn;
! 719: GC_PTR *ocd;
! 720: # endif
! 721: {
! 722: ptr_t base = GC_base(obj);
! 723: if (0 == base || (ptr_t)obj - base != sizeof(oh)) {
! 724: GC_err_printf1(
! 725: "GC_register_finalizer called with non-base-pointer 0x%lx\n",
! 726: obj);
! 727: }
! 728: GC_register_finalizer(base, GC_debug_invoke_finalizer,
! 729: GC_make_closure(fn,cd), ofn, ocd);
! 730: }
! 731:
! 732: # ifdef __STDC__
! 733: void GC_debug_register_finalizer_no_order
! 734: (GC_PTR obj, GC_finalization_proc fn,
! 735: GC_PTR cd, GC_finalization_proc *ofn,
! 736: GC_PTR *ocd)
! 737: # else
! 738: void GC_debug_register_finalizer_no_order
! 739: (obj, fn, cd, ofn, ocd)
! 740: GC_PTR obj;
! 741: GC_finalization_proc fn;
! 742: GC_PTR cd;
! 743: GC_finalization_proc *ofn;
! 744: GC_PTR *ocd;
! 745: # endif
! 746: {
! 747: ptr_t base = GC_base(obj);
! 748: if (0 == base || (ptr_t)obj - base != sizeof(oh)) {
! 749: GC_err_printf1(
! 750: "GC_register_finalizer_no_order called with non-base-pointer 0x%lx\n",
! 751: obj);
! 752: }
! 753: GC_register_finalizer_no_order(base, GC_debug_invoke_finalizer,
! 754: GC_make_closure(fn,cd), ofn, ocd);
! 755: }
! 756:
! 757: # ifdef __STDC__
! 758: void GC_debug_register_finalizer_ignore_self
! 759: (GC_PTR obj, GC_finalization_proc fn,
! 760: GC_PTR cd, GC_finalization_proc *ofn,
! 761: GC_PTR *ocd)
! 762: # else
! 763: void GC_debug_register_finalizer_ignore_self
! 764: (obj, fn, cd, ofn, ocd)
! 765: GC_PTR obj;
! 766: GC_finalization_proc fn;
! 767: GC_PTR cd;
! 768: GC_finalization_proc *ofn;
! 769: GC_PTR *ocd;
! 770: # endif
! 771: {
! 772: ptr_t base = GC_base(obj);
! 773: if (0 == base || (ptr_t)obj - base != sizeof(oh)) {
! 774: GC_err_printf1(
! 775: "GC_register_finalizer_ignore_self called with non-base-pointer 0x%lx\n",
! 776: obj);
! 777: }
! 778: GC_register_finalizer_ignore_self(base, GC_debug_invoke_finalizer,
! 779: GC_make_closure(fn,cd), ofn, ocd);
! 780: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to dbg_mlc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / gc5.3