Annotation of OpenXM_contrib/gc/dbg_mlc.c, Revision 1.1
1.1 ! maekawa 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: *
! 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: /* Boehm, October 9, 1995 1:16 pm PDT */
! 16: # include "gc_priv.h"
! 17:
! 18: void GC_default_print_heap_obj_proc();
! 19: GC_API void GC_register_finalizer_no_order
! 20: GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
! 21: GC_finalization_proc *ofn, GC_PTR *ocd));
! 22:
! 23: /* Do we want to and know how to save the call stack at the time of */
! 24: /* an allocation? How much space do we want to use in each object? */
! 25:
! 26: # define START_FLAG ((word)0xfedcedcb)
! 27: # define END_FLAG ((word)0xbcdecdef)
! 28: /* Stored both one past the end of user object, and one before */
! 29: /* the end of the object as seen by the allocator. */
! 30:
! 31:
! 32: /* Object header */
! 33: typedef struct {
! 34: char * oh_string; /* object descriptor string */
! 35: word oh_int; /* object descriptor integers */
! 36: # ifdef NEED_CALLINFO
! 37: struct callinfo oh_ci[NFRAMES];
! 38: # endif
! 39: word oh_sz; /* Original malloc arg. */
! 40: word oh_sf; /* start flag */
! 41: } oh;
! 42: /* The size of the above structure is assumed not to dealign things, */
! 43: /* and to be a multiple of the word length. */
! 44:
! 45: #define DEBUG_BYTES (sizeof (oh) + sizeof (word))
! 46: #undef ROUNDED_UP_WORDS
! 47: #define ROUNDED_UP_WORDS(n) BYTES_TO_WORDS((n) + WORDS_TO_BYTES(1) - 1)
! 48:
! 49:
! 50: #ifdef SAVE_CALL_CHAIN
! 51: # define ADD_CALL_CHAIN(base, ra) GC_save_callers(((oh *)(base)) -> oh_ci)
! 52: # define PRINT_CALL_CHAIN(base) GC_print_callers(((oh *)(base)) -> oh_ci)
! 53: #else
! 54: # ifdef GC_ADD_CALLER
! 55: # define ADD_CALL_CHAIN(base, ra) ((oh *)(base)) -> oh_ci[0].ci_pc = (ra)
! 56: # define PRINT_CALL_CHAIN(base) GC_print_callers(((oh *)(base)) -> oh_ci)
! 57: # else
! 58: # define ADD_CALL_CHAIN(base, ra)
! 59: # define PRINT_CALL_CHAIN(base)
! 60: # endif
! 61: #endif
! 62:
! 63: /* Check whether object with base pointer p has debugging info */
! 64: /* p is assumed to point to a legitimate object in our part */
! 65: /* of the heap. */
! 66: GC_bool GC_has_debug_info(p)
! 67: ptr_t p;
! 68: {
! 69: register oh * ohdr = (oh *)p;
! 70: register ptr_t body = (ptr_t)(ohdr + 1);
! 71: register word sz = GC_size((ptr_t) ohdr);
! 72:
! 73: if (HBLKPTR((ptr_t)ohdr) != HBLKPTR((ptr_t)body)
! 74: || sz < sizeof (oh)) {
! 75: return(FALSE);
! 76: }
! 77: if (ohdr -> oh_sz == sz) {
! 78: /* Object may have had debug info, but has been deallocated */
! 79: return(FALSE);
! 80: }
! 81: if (ohdr -> oh_sf == (START_FLAG ^ (word)body)) return(TRUE);
! 82: if (((word *)ohdr)[BYTES_TO_WORDS(sz)-1] == (END_FLAG ^ (word)body)) {
! 83: return(TRUE);
! 84: }
! 85: return(FALSE);
! 86: }
! 87:
! 88: /* Store debugging info into p. Return displaced pointer. */
! 89: /* Assumes we don't hold allocation lock. */
! 90: ptr_t GC_store_debug_info(p, sz, string, integer)
! 91: register ptr_t p; /* base pointer */
! 92: word sz; /* bytes */
! 93: char * string;
! 94: word integer;
! 95: {
! 96: register word * result = (word *)((oh *)p + 1);
! 97: DCL_LOCK_STATE;
! 98:
! 99: /* There is some argument that we should dissble signals here. */
! 100: /* But that's expensive. And this way things should only appear */
! 101: /* inconsistent while we're in the handler. */
! 102: LOCK();
! 103: ((oh *)p) -> oh_string = string;
! 104: ((oh *)p) -> oh_int = integer;
! 105: ((oh *)p) -> oh_sz = sz;
! 106: ((oh *)p) -> oh_sf = START_FLAG ^ (word)result;
! 107: ((word *)p)[BYTES_TO_WORDS(GC_size(p))-1] =
! 108: result[ROUNDED_UP_WORDS(sz)] = END_FLAG ^ (word)result;
! 109: UNLOCK();
! 110: return((ptr_t)result);
! 111: }
! 112:
! 113: /* Check the object with debugging info at p */
! 114: /* return NIL if it's OK. Else return clobbered */
! 115: /* address. */
! 116: ptr_t GC_check_annotated_obj(ohdr)
! 117: register oh * ohdr;
! 118: {
! 119: register ptr_t body = (ptr_t)(ohdr + 1);
! 120: register word gc_sz = GC_size((ptr_t)ohdr);
! 121: if (ohdr -> oh_sz + DEBUG_BYTES > gc_sz) {
! 122: return((ptr_t)(&(ohdr -> oh_sz)));
! 123: }
! 124: if (ohdr -> oh_sf != (START_FLAG ^ (word)body)) {
! 125: return((ptr_t)(&(ohdr -> oh_sf)));
! 126: }
! 127: if (((word *)ohdr)[BYTES_TO_WORDS(gc_sz)-1] != (END_FLAG ^ (word)body)) {
! 128: return((ptr_t)((word *)ohdr + BYTES_TO_WORDS(gc_sz)-1));
! 129: }
! 130: if (((word *)body)[ROUNDED_UP_WORDS(ohdr -> oh_sz)]
! 131: != (END_FLAG ^ (word)body)) {
! 132: return((ptr_t)((word *)body + ROUNDED_UP_WORDS(ohdr -> oh_sz)));
! 133: }
! 134: return(0);
! 135: }
! 136:
! 137: void GC_print_obj(p)
! 138: ptr_t p;
! 139: {
! 140: register oh * ohdr = (oh *)GC_base(p);
! 141:
! 142: GC_err_printf1("0x%lx (", ((unsigned long)ohdr + sizeof(oh)));
! 143: GC_err_puts(ohdr -> oh_string);
! 144: GC_err_printf2(":%ld, sz=%ld)\n", (unsigned long)(ohdr -> oh_int),
! 145: (unsigned long)(ohdr -> oh_sz));
! 146: PRINT_CALL_CHAIN(ohdr);
! 147: }
! 148:
! 149: void GC_debug_print_heap_obj_proc(p)
! 150: ptr_t p;
! 151: {
! 152: if (GC_has_debug_info(p)) {
! 153: GC_print_obj(p);
! 154: } else {
! 155: GC_default_print_heap_obj_proc(p);
! 156: }
! 157: }
! 158:
! 159: void GC_print_smashed_obj(p, clobbered_addr)
! 160: ptr_t p, clobbered_addr;
! 161: {
! 162: register oh * ohdr = (oh *)GC_base(p);
! 163:
! 164: GC_err_printf2("0x%lx in object at 0x%lx(", (unsigned long)clobbered_addr,
! 165: (unsigned long)p);
! 166: if (clobbered_addr <= (ptr_t)(&(ohdr -> oh_sz))
! 167: || ohdr -> oh_string == 0) {
! 168: GC_err_printf1("<smashed>, appr. sz = %ld)\n",
! 169: (GC_size((ptr_t)ohdr) - DEBUG_BYTES));
! 170: } else {
! 171: if (ohdr -> oh_string[0] == '\0') {
! 172: GC_err_puts("EMPTY(smashed?)");
! 173: } else {
! 174: GC_err_puts(ohdr -> oh_string);
! 175: }
! 176: GC_err_printf2(":%ld, sz=%ld)\n", (unsigned long)(ohdr -> oh_int),
! 177: (unsigned long)(ohdr -> oh_sz));
! 178: PRINT_CALL_CHAIN(ohdr);
! 179: }
! 180: }
! 181:
! 182: void GC_check_heap_proc();
! 183:
! 184: void GC_start_debugging()
! 185: {
! 186: GC_check_heap = GC_check_heap_proc;
! 187: GC_print_heap_obj = GC_debug_print_heap_obj_proc;
! 188: GC_debugging_started = TRUE;
! 189: GC_register_displacement((word)sizeof(oh));
! 190: }
! 191:
! 192: # if defined(__STDC__) || defined(__cplusplus)
! 193: void GC_debug_register_displacement(GC_word offset)
! 194: # else
! 195: void GC_debug_register_displacement(offset)
! 196: GC_word offset;
! 197: # endif
! 198: {
! 199: GC_register_displacement(offset);
! 200: GC_register_displacement((word)sizeof(oh) + offset);
! 201: }
! 202:
! 203: # ifdef GC_ADD_CALLER
! 204: # define EXTRA_ARGS word ra, char * s, int i
! 205: # define OPT_RA ra,
! 206: # else
! 207: # define EXTRA_ARGS char * s, int i
! 208: # define OPT_RA
! 209: # endif
! 210:
! 211: # ifdef __STDC__
! 212: GC_PTR GC_debug_malloc(size_t lb, EXTRA_ARGS)
! 213: # else
! 214: GC_PTR GC_debug_malloc(lb, s, i)
! 215: size_t lb;
! 216: char * s;
! 217: int i;
! 218: # ifdef GC_ADD_CALLER
! 219: --> GC_ADD_CALLER not implemented for K&R C
! 220: # endif
! 221: # endif
! 222: {
! 223: GC_PTR result = GC_malloc(lb + DEBUG_BYTES);
! 224:
! 225: if (result == 0) {
! 226: GC_err_printf1("GC_debug_malloc(%ld) returning NIL (",
! 227: (unsigned long) lb);
! 228: GC_err_puts(s);
! 229: GC_err_printf1(":%ld)\n", (unsigned long)i);
! 230: return(0);
! 231: }
! 232: if (!GC_debugging_started) {
! 233: GC_start_debugging();
! 234: }
! 235: ADD_CALL_CHAIN(result, ra);
! 236: return (GC_store_debug_info(result, (word)lb, s, (word)i));
! 237: }
! 238:
! 239: #ifdef STUBBORN_ALLOC
! 240: # ifdef __STDC__
! 241: GC_PTR GC_debug_malloc_stubborn(size_t lb, EXTRA_ARGS)
! 242: # else
! 243: GC_PTR GC_debug_malloc_stubborn(lb, s, i)
! 244: size_t lb;
! 245: char * s;
! 246: int i;
! 247: # endif
! 248: {
! 249: GC_PTR result = GC_malloc_stubborn(lb + DEBUG_BYTES);
! 250:
! 251: if (result == 0) {
! 252: GC_err_printf1("GC_debug_malloc(%ld) returning NIL (",
! 253: (unsigned long) lb);
! 254: GC_err_puts(s);
! 255: GC_err_printf1(":%ld)\n", (unsigned long)i);
! 256: return(0);
! 257: }
! 258: if (!GC_debugging_started) {
! 259: GC_start_debugging();
! 260: }
! 261: ADD_CALL_CHAIN(result, ra);
! 262: return (GC_store_debug_info(result, (word)lb, s, (word)i));
! 263: }
! 264:
! 265: void GC_debug_change_stubborn(p)
! 266: GC_PTR p;
! 267: {
! 268: register GC_PTR q = GC_base(p);
! 269: register hdr * hhdr;
! 270:
! 271: if (q == 0) {
! 272: GC_err_printf1("Bad argument: 0x%lx to GC_debug_change_stubborn\n",
! 273: (unsigned long) p);
! 274: ABORT("GC_debug_change_stubborn: bad arg");
! 275: }
! 276: hhdr = HDR(q);
! 277: if (hhdr -> hb_obj_kind != STUBBORN) {
! 278: GC_err_printf1("GC_debug_change_stubborn arg not stubborn: 0x%lx\n",
! 279: (unsigned long) p);
! 280: ABORT("GC_debug_change_stubborn: arg not stubborn");
! 281: }
! 282: GC_change_stubborn(q);
! 283: }
! 284:
! 285: void GC_debug_end_stubborn_change(p)
! 286: GC_PTR p;
! 287: {
! 288: register GC_PTR q = GC_base(p);
! 289: register hdr * hhdr;
! 290:
! 291: if (q == 0) {
! 292: GC_err_printf1("Bad argument: 0x%lx to GC_debug_end_stubborn_change\n",
! 293: (unsigned long) p);
! 294: ABORT("GC_debug_end_stubborn_change: bad arg");
! 295: }
! 296: hhdr = HDR(q);
! 297: if (hhdr -> hb_obj_kind != STUBBORN) {
! 298: GC_err_printf1("debug_end_stubborn_change arg not stubborn: 0x%lx\n",
! 299: (unsigned long) p);
! 300: ABORT("GC_debug_end_stubborn_change: arg not stubborn");
! 301: }
! 302: GC_end_stubborn_change(q);
! 303: }
! 304:
! 305: #endif /* STUBBORN_ALLOC */
! 306:
! 307: # ifdef __STDC__
! 308: GC_PTR GC_debug_malloc_atomic(size_t lb, EXTRA_ARGS)
! 309: # else
! 310: GC_PTR GC_debug_malloc_atomic(lb, s, i)
! 311: size_t lb;
! 312: char * s;
! 313: int i;
! 314: # endif
! 315: {
! 316: GC_PTR result = GC_malloc_atomic(lb + DEBUG_BYTES);
! 317:
! 318: if (result == 0) {
! 319: GC_err_printf1("GC_debug_malloc_atomic(%ld) returning NIL (",
! 320: (unsigned long) lb);
! 321: GC_err_puts(s);
! 322: GC_err_printf1(":%ld)\n", (unsigned long)i);
! 323: return(0);
! 324: }
! 325: if (!GC_debugging_started) {
! 326: GC_start_debugging();
! 327: }
! 328: ADD_CALL_CHAIN(result, ra);
! 329: return (GC_store_debug_info(result, (word)lb, s, (word)i));
! 330: }
! 331:
! 332: # ifdef __STDC__
! 333: GC_PTR GC_debug_malloc_uncollectable(size_t lb, EXTRA_ARGS)
! 334: # else
! 335: GC_PTR GC_debug_malloc_uncollectable(lb, s, i)
! 336: size_t lb;
! 337: char * s;
! 338: int i;
! 339: # endif
! 340: {
! 341: GC_PTR result = GC_malloc_uncollectable(lb + DEBUG_BYTES);
! 342:
! 343: if (result == 0) {
! 344: GC_err_printf1("GC_debug_malloc_uncollectable(%ld) returning NIL (",
! 345: (unsigned long) lb);
! 346: GC_err_puts(s);
! 347: GC_err_printf1(":%ld)\n", (unsigned long)i);
! 348: return(0);
! 349: }
! 350: if (!GC_debugging_started) {
! 351: GC_start_debugging();
! 352: }
! 353: ADD_CALL_CHAIN(result, ra);
! 354: return (GC_store_debug_info(result, (word)lb, s, (word)i));
! 355: }
! 356:
! 357: #ifdef ATOMIC_UNCOLLECTABLE
! 358: # ifdef __STDC__
! 359: GC_PTR GC_debug_malloc_atomic_uncollectable(size_t lb, EXTRA_ARGS)
! 360: # else
! 361: GC_PTR GC_debug_malloc_atomic_uncollectable(lb, s, i)
! 362: size_t lb;
! 363: char * s;
! 364: int i;
! 365: # endif
! 366: {
! 367: GC_PTR result = GC_malloc_atomic_uncollectable(lb + DEBUG_BYTES);
! 368:
! 369: if (result == 0) {
! 370: GC_err_printf1(
! 371: "GC_debug_malloc_atomic_uncollectable(%ld) returning NIL (",
! 372: (unsigned long) lb);
! 373: GC_err_puts(s);
! 374: GC_err_printf1(":%ld)\n", (unsigned long)i);
! 375: return(0);
! 376: }
! 377: if (!GC_debugging_started) {
! 378: GC_start_debugging();
! 379: }
! 380: ADD_CALL_CHAIN(result, ra);
! 381: return (GC_store_debug_info(result, (word)lb, s, (word)i));
! 382: }
! 383: #endif /* ATOMIC_UNCOLLECTABLE */
! 384:
! 385: # ifdef __STDC__
! 386: void GC_debug_free(GC_PTR p)
! 387: # else
! 388: void GC_debug_free(p)
! 389: GC_PTR p;
! 390: # endif
! 391: {
! 392: register GC_PTR base = GC_base(p);
! 393: register ptr_t clobbered;
! 394:
! 395: if (base == 0) {
! 396: GC_err_printf1("Attempt to free invalid pointer %lx\n",
! 397: (unsigned long)p);
! 398: if (p != 0) ABORT("free(invalid pointer)");
! 399: }
! 400: if ((ptr_t)p - (ptr_t)base != sizeof(oh)) {
! 401: GC_err_printf1(
! 402: "GC_debug_free called on pointer %lx wo debugging info\n",
! 403: (unsigned long)p);
! 404: } else {
! 405: clobbered = GC_check_annotated_obj((oh *)base);
! 406: if (clobbered != 0) {
! 407: if (((oh *)base) -> oh_sz == GC_size(base)) {
! 408: GC_err_printf0(
! 409: "GC_debug_free: found previously deallocated (?) object at ");
! 410: } else {
! 411: GC_err_printf0("GC_debug_free: found smashed object at ");
! 412: }
! 413: GC_print_smashed_obj(p, clobbered);
! 414: }
! 415: /* Invalidate size */
! 416: ((oh *)base) -> oh_sz = GC_size(base);
! 417: }
! 418: # ifdef FIND_LEAK
! 419: GC_free(base);
! 420: # else
! 421: {
! 422: register hdr * hhdr = HDR(p);
! 423: GC_bool uncollectable = FALSE;
! 424:
! 425: if (hhdr -> hb_obj_kind == UNCOLLECTABLE) {
! 426: uncollectable = TRUE;
! 427: }
! 428: # ifdef ATOMIC_UNCOLLECTABLE
! 429: if (hhdr -> hb_obj_kind == AUNCOLLECTABLE) {
! 430: uncollectable = TRUE;
! 431: }
! 432: # endif
! 433: if (uncollectable) GC_free(base);
! 434: }
! 435: # endif
! 436: }
! 437:
! 438: # ifdef __STDC__
! 439: GC_PTR GC_debug_realloc(GC_PTR p, size_t lb, EXTRA_ARGS)
! 440: # else
! 441: GC_PTR GC_debug_realloc(p, lb, s, i)
! 442: GC_PTR p;
! 443: size_t lb;
! 444: char *s;
! 445: int i;
! 446: # endif
! 447: {
! 448: register GC_PTR base = GC_base(p);
! 449: register ptr_t clobbered;
! 450: register GC_PTR result;
! 451: register size_t copy_sz = lb;
! 452: register size_t old_sz;
! 453: register hdr * hhdr;
! 454:
! 455: if (p == 0) return(GC_debug_malloc(lb, OPT_RA s, i));
! 456: if (base == 0) {
! 457: GC_err_printf1(
! 458: "Attempt to reallocate invalid pointer %lx\n", (unsigned long)p);
! 459: ABORT("realloc(invalid pointer)");
! 460: }
! 461: if ((ptr_t)p - (ptr_t)base != sizeof(oh)) {
! 462: GC_err_printf1(
! 463: "GC_debug_realloc called on pointer %lx wo debugging info\n",
! 464: (unsigned long)p);
! 465: return(GC_realloc(p, lb));
! 466: }
! 467: hhdr = HDR(base);
! 468: switch (hhdr -> hb_obj_kind) {
! 469: # ifdef STUBBORN_ALLOC
! 470: case STUBBORN:
! 471: result = GC_debug_malloc_stubborn(lb, OPT_RA s, i);
! 472: break;
! 473: # endif
! 474: case NORMAL:
! 475: result = GC_debug_malloc(lb, OPT_RA s, i);
! 476: break;
! 477: case PTRFREE:
! 478: result = GC_debug_malloc_atomic(lb, OPT_RA s, i);
! 479: break;
! 480: case UNCOLLECTABLE:
! 481: result = GC_debug_malloc_uncollectable(lb, OPT_RA s, i);
! 482: break;
! 483: # ifdef ATOMIC_UNCOLLECTABLE
! 484: case AUNCOLLECTABLE:
! 485: result = GC_debug_malloc_atomic_uncollectable(lb, OPT_RA s, i);
! 486: break;
! 487: # endif
! 488: default:
! 489: GC_err_printf0("GC_debug_realloc: encountered bad kind\n");
! 490: ABORT("bad kind");
! 491: }
! 492: clobbered = GC_check_annotated_obj((oh *)base);
! 493: if (clobbered != 0) {
! 494: GC_err_printf0("GC_debug_realloc: found smashed object at ");
! 495: GC_print_smashed_obj(p, clobbered);
! 496: }
! 497: old_sz = ((oh *)base) -> oh_sz;
! 498: if (old_sz < copy_sz) copy_sz = old_sz;
! 499: if (result == 0) return(0);
! 500: BCOPY(p, result, copy_sz);
! 501: GC_debug_free(p);
! 502: return(result);
! 503: }
! 504:
! 505: /* Check all marked objects in the given block for validity */
! 506: /*ARGSUSED*/
! 507: void GC_check_heap_block(hbp, dummy)
! 508: register struct hblk *hbp; /* ptr to current heap block */
! 509: word dummy;
! 510: {
! 511: register struct hblkhdr * hhdr = HDR(hbp);
! 512: register word sz = hhdr -> hb_sz;
! 513: register int word_no;
! 514: register word *p, *plim;
! 515:
! 516: p = (word *)(hbp->hb_body);
! 517: word_no = HDR_WORDS;
! 518: if (sz > MAXOBJSZ) {
! 519: plim = p;
! 520: } else {
! 521: plim = (word *)((((word)hbp) + HBLKSIZE) - WORDS_TO_BYTES(sz));
! 522: }
! 523: /* go through all words in block */
! 524: while( p <= plim ) {
! 525: if( mark_bit_from_hdr(hhdr, word_no)
! 526: && GC_has_debug_info((ptr_t)p)) {
! 527: ptr_t clobbered = GC_check_annotated_obj((oh *)p);
! 528:
! 529: if (clobbered != 0) {
! 530: GC_err_printf0(
! 531: "GC_check_heap_block: found smashed object at ");
! 532: GC_print_smashed_obj((ptr_t)p, clobbered);
! 533: }
! 534: }
! 535: word_no += sz;
! 536: p += sz;
! 537: }
! 538: }
! 539:
! 540:
! 541: /* This assumes that all accessible objects are marked, and that */
! 542: /* I hold the allocation lock. Normally called by collector. */
! 543: void GC_check_heap_proc()
! 544: {
! 545: # ifndef SMALL_CONFIG
! 546: if (sizeof(oh) & (2 * sizeof(word) - 1) != 0) {
! 547: ABORT("Alignment problem: object header has inappropriate size\n");
! 548: }
! 549: # endif
! 550: GC_apply_to_all_blocks(GC_check_heap_block, (word)0);
! 551: }
! 552:
! 553: struct closure {
! 554: GC_finalization_proc cl_fn;
! 555: GC_PTR cl_data;
! 556: };
! 557:
! 558: # ifdef __STDC__
! 559: void * GC_make_closure(GC_finalization_proc fn, void * data)
! 560: # else
! 561: GC_PTR GC_make_closure(fn, data)
! 562: GC_finalization_proc fn;
! 563: GC_PTR data;
! 564: # endif
! 565: {
! 566: struct closure * result =
! 567: (struct closure *) GC_malloc(sizeof (struct closure));
! 568:
! 569: result -> cl_fn = fn;
! 570: result -> cl_data = data;
! 571: return((GC_PTR)result);
! 572: }
! 573:
! 574: # ifdef __STDC__
! 575: void GC_debug_invoke_finalizer(void * obj, void * data)
! 576: # else
! 577: void GC_debug_invoke_finalizer(obj, data)
! 578: char * obj;
! 579: char * data;
! 580: # endif
! 581: {
! 582: register struct closure * cl = (struct closure *) data;
! 583:
! 584: (*(cl -> cl_fn))((GC_PTR)((char *)obj + sizeof(oh)), cl -> cl_data);
! 585: }
! 586:
! 587:
! 588: # ifdef __STDC__
! 589: void GC_debug_register_finalizer(GC_PTR obj, GC_finalization_proc fn,
! 590: GC_PTR cd, GC_finalization_proc *ofn,
! 591: GC_PTR *ocd)
! 592: # else
! 593: void GC_debug_register_finalizer(obj, fn, cd, ofn, ocd)
! 594: GC_PTR obj;
! 595: GC_finalization_proc fn;
! 596: GC_PTR cd;
! 597: GC_finalization_proc *ofn;
! 598: GC_PTR *ocd;
! 599: # endif
! 600: {
! 601: ptr_t base = GC_base(obj);
! 602: if (0 == base || (ptr_t)obj - base != sizeof(oh)) {
! 603: GC_err_printf1(
! 604: "GC_register_finalizer called with non-base-pointer 0x%lx\n",
! 605: obj);
! 606: }
! 607: GC_register_finalizer(base, GC_debug_invoke_finalizer,
! 608: GC_make_closure(fn,cd), ofn, ocd);
! 609: }
! 610:
! 611: # ifdef __STDC__
! 612: void GC_debug_register_finalizer_no_order
! 613: (GC_PTR obj, GC_finalization_proc fn,
! 614: GC_PTR cd, GC_finalization_proc *ofn,
! 615: GC_PTR *ocd)
! 616: # else
! 617: void GC_debug_register_finalizer_no_order
! 618: (obj, fn, cd, ofn, ocd)
! 619: GC_PTR obj;
! 620: GC_finalization_proc fn;
! 621: GC_PTR cd;
! 622: GC_finalization_proc *ofn;
! 623: GC_PTR *ocd;
! 624: # endif
! 625: {
! 626: ptr_t base = GC_base(obj);
! 627: if (0 == base || (ptr_t)obj - base != sizeof(oh)) {
! 628: GC_err_printf1(
! 629: "GC_register_finalizer_no_order called with non-base-pointer 0x%lx\n",
! 630: obj);
! 631: }
! 632: GC_register_finalizer_no_order(base, GC_debug_invoke_finalizer,
! 633: GC_make_closure(fn,cd), ofn, ocd);
! 634: }
! 635:
! 636: # ifdef __STDC__
! 637: void GC_debug_register_finalizer_ignore_self
! 638: (GC_PTR obj, GC_finalization_proc fn,
! 639: GC_PTR cd, GC_finalization_proc *ofn,
! 640: GC_PTR *ocd)
! 641: # else
! 642: void GC_debug_register_finalizer_ignore_self
! 643: (obj, fn, cd, ofn, ocd)
! 644: GC_PTR obj;
! 645: GC_finalization_proc fn;
! 646: GC_PTR cd;
! 647: GC_finalization_proc *ofn;
! 648: GC_PTR *ocd;
! 649: # endif
! 650: {
! 651: ptr_t base = GC_base(obj);
! 652: if (0 == base || (ptr_t)obj - base != sizeof(oh)) {
! 653: GC_err_printf1(
! 654: "GC_register_finalizer_ignore_self called with non-base-pointer 0x%lx\n",
! 655: obj);
! 656: }
! 657: GC_register_finalizer_ignore_self(base, GC_debug_invoke_finalizer,
! 658: GC_make_closure(fn,cd), ofn, ocd);
! 659: }
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_contrib / gc