=================================================================== RCS file: /home/cvs/OpenXM_contrib2/asir2000/gc/dbg_mlc.c,v retrieving revision 1.3 retrieving revision 1.7 diff -u -p -r1.3 -r1.7 --- OpenXM_contrib2/asir2000/gc/dbg_mlc.c 2000/12/01 09:26:10 1.3 +++ OpenXM_contrib2/asir2000/gc/dbg_mlc.c 2003/06/24 05:11:32 1.7 @@ -2,7 +2,7 @@ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers * Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. * Copyright (c) 1997 by Silicon Graphics. All rights reserved. - * Copyright (c) 1999 by Hewlett-Packard Company. All rights reserved. + * Copyright (c) 1999-2000 by Hewlett-Packard Company. All rights reserved. * * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. @@ -14,7 +14,7 @@ * modified is included with the above copyright notice. */ -#include "dbg_mlc.h" +#include "private/dbg_mlc.h" void GC_default_print_heap_obj_proc(); GC_API void GC_register_finalizer_no_order @@ -22,10 +22,17 @@ GC_API void GC_register_finalizer_no_order GC_finalization_proc *ofn, GC_PTR *ocd)); +#ifndef SHORT_DBG_HDRS /* Check whether object with base pointer p has debugging info */ /* p is assumed to point to a legitimate object in our part */ /* of the heap. */ -GC_bool GC_has_debug_info(p) +/* This excludes the check as to whether the back pointer is */ +/* odd, which is added by the GC_HAS_DEBUG_INFO macro. */ +/* Note that if DBG_HDRS_ALL is set, uncollectable objects */ +/* on free lists may not have debug information set. Thus it's */ +/* not always safe to return TRUE, even if the client does */ +/* its part. */ +GC_bool GC_has_other_debug_info(p) ptr_t p; { register oh * ohdr = (oh *)p; @@ -33,7 +40,7 @@ ptr_t p; register word sz = GC_size((ptr_t) ohdr); if (HBLKPTR((ptr_t)ohdr) != HBLKPTR((ptr_t)body) - || sz < sizeof (oh)) { + || sz < DEBUG_BYTES + EXTRA_BYTES) { return(FALSE); } if (ohdr -> oh_sz == sz) { @@ -46,8 +53,19 @@ ptr_t p; } return(FALSE); } +#endif #ifdef KEEP_BACK_PTRS + +# include + +# if defined(LINUX) || defined(SUNOS4) || defined(SUNOS5) \ + || defined(HPUX) || defined(IRIX5) || defined(OSF1) +# define RANDOM() random() +# else +# define RANDOM() (long)rand() +# endif + /* Store back pointer to source in dest, if that appears to be possible. */ /* This is not completely safe, since we may mistakenly conclude that */ /* dest has a debugging wrapper. But the error probability is very */ @@ -56,8 +74,8 @@ ptr_t p; /* be a pointer to the interior of an object. */ void GC_store_back_pointer(ptr_t source, ptr_t dest) { - if (GC_has_debug_info(dest)) { - ((oh *)dest) -> oh_back_ptr = (ptr_t)HIDE_POINTER(source); + if (GC_HAS_DEBUG_INFO(dest)) { + ((oh *)dest) -> oh_back_ptr = HIDE_BACK_PTR(source); } } @@ -76,19 +94,34 @@ ptr_t p; oh * hdr = (oh *)GC_base(dest); ptr_t bp; ptr_t bp_base; - if (!GC_has_debug_info((ptr_t) hdr)) return GC_NO_SPACE; - bp = hdr -> oh_back_ptr; + if (!GC_HAS_DEBUG_INFO((ptr_t) hdr)) return GC_NO_SPACE; + bp = REVEAL_POINTER(hdr -> oh_back_ptr); if (MARKED_FOR_FINALIZATION == bp) return GC_FINALIZER_REFD; if (MARKED_FROM_REGISTER == bp) return GC_REFD_FROM_REG; - if (0 == bp) return GC_UNREFERENCED; - bp = REVEAL_POINTER(bp); + if (NOT_MARKED == bp) return GC_UNREFERENCED; +# if ALIGNMENT == 1 + /* Heuristically try to fix off by 1 errors we introduced by */ + /* insisting on even addresses. */ + { + ptr_t alternate_ptr = bp + 1; + ptr_t target = *(ptr_t *)bp; + ptr_t alternate_target = *(ptr_t *)alternate_ptr; + + if (alternate_target >= GC_least_plausible_heap_addr + && alternate_target <= GC_greatest_plausible_heap_addr + && (target < GC_least_plausible_heap_addr + || target > GC_greatest_plausible_heap_addr)) { + bp = alternate_ptr; + } + } +# endif bp_base = GC_base(bp); if (0 == bp_base) { *base_p = bp; *offset_p = 0; return GC_REFD_FROM_ROOT; } else { - if (GC_has_debug_info(bp_base)) bp_base += sizeof(oh); + if (GC_HAS_DEBUG_INFO(bp_base)) bp_base += sizeof(oh); *base_p = bp_base; *offset_p = bp - bp_base; return GC_REFD_FROM_HEAP; @@ -101,7 +134,15 @@ ptr_t p; void *GC_generate_random_heap_address(void) { int i; - int heap_offset = random() % GC_heapsize; + long heap_offset = RANDOM(); + if (GC_heapsize > RAND_MAX) { + heap_offset *= RAND_MAX; + heap_offset += RANDOM(); + } + heap_offset %= GC_heapsize; + /* This doesn't yield a uniform distribution, especially if */ + /* e.g. RAND_MAX = 1.5* GC_heapsize. But for typical cases, */ + /* it's not too bad. */ for (i = 0; i < GC_n_heap_sects; ++ i) { int size = GC_heap_sects[i].hs_bytes; if (heap_offset < size) { @@ -187,12 +228,14 @@ ptr_t p; #endif /* KEEP_BACK_PTRS */ +# define CROSSES_HBLK(p, sz) \ + (((word)(p + sizeof(oh) + sz - 1) ^ (word)p) >= HBLKSIZE) /* Store debugging info into p. Return displaced pointer. */ /* Assumes we don't hold allocation lock. */ ptr_t GC_store_debug_info(p, sz, string, integer) register ptr_t p; /* base pointer */ word sz; /* bytes */ -char * string; +GC_CONST char * string; word integer; { register word * result = (word *)((oh *)p + 1); @@ -202,19 +245,61 @@ word integer; /* But that's expensive. And this way things should only appear */ /* inconsistent while we're in the handler. */ LOCK(); + GC_ASSERT(GC_size(p) >= sizeof(oh) + sz); + GC_ASSERT(!(SMALL_OBJ(sz) && CROSSES_HBLK(p, sz))); # ifdef KEEP_BACK_PTRS - ((oh *)p) -> oh_back_ptr = 0; + ((oh *)p) -> oh_back_ptr = HIDE_BACK_PTR(NOT_MARKED); # endif +# ifdef MAKE_BACK_GRAPH + ((oh *)p) -> oh_bg_ptr = HIDE_BACK_PTR((ptr_t)0); +# endif ((oh *)p) -> oh_string = string; ((oh *)p) -> oh_int = integer; - ((oh *)p) -> oh_sz = sz; - ((oh *)p) -> oh_sf = START_FLAG ^ (word)result; - ((word *)p)[BYTES_TO_WORDS(GC_size(p))-1] = - result[ROUNDED_UP_WORDS(sz)] = END_FLAG ^ (word)result; +# ifndef SHORT_DBG_HDRS + ((oh *)p) -> oh_sz = sz; + ((oh *)p) -> oh_sf = START_FLAG ^ (word)result; + ((word *)p)[BYTES_TO_WORDS(GC_size(p))-1] = + result[SIMPLE_ROUNDED_UP_WORDS(sz)] = END_FLAG ^ (word)result; +# endif UNLOCK(); return((ptr_t)result); } +#ifdef DBG_HDRS_ALL +/* Store debugging info into p. Return displaced pointer. */ +/* This version assumes we do hold the allocation lock. */ +ptr_t GC_store_debug_info_inner(p, sz, string, integer) +register ptr_t p; /* base pointer */ +word sz; /* bytes */ +char * string; +word integer; +{ + register word * result = (word *)((oh *)p + 1); + + /* There is some argument that we should disable signals here. */ + /* But that's expensive. And this way things should only appear */ + /* inconsistent while we're in the handler. */ + GC_ASSERT(GC_size(p) >= sizeof(oh) + sz); + GC_ASSERT(!(SMALL_OBJ(sz) && CROSSES_HBLK(p, sz))); +# ifdef KEEP_BACK_PTRS + ((oh *)p) -> oh_back_ptr = HIDE_BACK_PTR(NOT_MARKED); +# endif +# ifdef MAKE_BACK_GRAPH + ((oh *)p) -> oh_bg_ptr = HIDE_BACK_PTR((ptr_t)0); +# endif + ((oh *)p) -> oh_string = string; + ((oh *)p) -> oh_int = integer; +# ifndef SHORT_DBG_HDRS + ((oh *)p) -> oh_sz = sz; + ((oh *)p) -> oh_sf = START_FLAG ^ (word)result; + ((word *)p)[BYTES_TO_WORDS(GC_size(p))-1] = + result[SIMPLE_ROUNDED_UP_WORDS(sz)] = END_FLAG ^ (word)result; +# endif + return((ptr_t)result); +} +#endif + +#ifndef SHORT_DBG_HDRS /* Check the object with debugging info at ohdr */ /* return NIL if it's OK. Else return clobbered */ /* address. */ @@ -232,40 +317,53 @@ register oh * ohdr; if (((word *)ohdr)[BYTES_TO_WORDS(gc_sz)-1] != (END_FLAG ^ (word)body)) { return((ptr_t)((word *)ohdr + BYTES_TO_WORDS(gc_sz)-1)); } - if (((word *)body)[ROUNDED_UP_WORDS(ohdr -> oh_sz)] + if (((word *)body)[SIMPLE_ROUNDED_UP_WORDS(ohdr -> oh_sz)] != (END_FLAG ^ (word)body)) { - return((ptr_t)((word *)body + ROUNDED_UP_WORDS(ohdr -> oh_sz))); + return((ptr_t)((word *)body + SIMPLE_ROUNDED_UP_WORDS(ohdr -> oh_sz))); } return(0); } +#endif /* !SHORT_DBG_HDRS */ void GC_print_obj(p) ptr_t p; { register oh * ohdr = (oh *)GC_base(p); + GC_ASSERT(!I_HOLD_LOCK()); GC_err_printf1("0x%lx (", ((unsigned long)ohdr + sizeof(oh))); GC_err_puts(ohdr -> oh_string); - GC_err_printf2(":%ld, sz=%ld)\n", (unsigned long)(ohdr -> oh_int), - (unsigned long)(ohdr -> oh_sz)); +# ifdef SHORT_DBG_HDRS + GC_err_printf1(":%ld)\n", (unsigned long)(ohdr -> oh_int)); +# else + GC_err_printf2(":%ld, sz=%ld)\n", (unsigned long)(ohdr -> oh_int), + (unsigned long)(ohdr -> oh_sz)); +# endif PRINT_CALL_CHAIN(ohdr); } -void GC_debug_print_heap_obj_proc(p) -ptr_t p; +# if defined(__STDC__) || defined(__cplusplus) + void GC_debug_print_heap_obj_proc(ptr_t p) +# else + void GC_debug_print_heap_obj_proc(p) + ptr_t p; +# endif { - if (GC_has_debug_info(p)) { + GC_ASSERT(!I_HOLD_LOCK()); + if (GC_HAS_DEBUG_INFO(p)) { GC_print_obj(p); } else { GC_default_print_heap_obj_proc(p); } } +#ifndef SHORT_DBG_HDRS void GC_print_smashed_obj(p, clobbered_addr) ptr_t p, clobbered_addr; { register oh * ohdr = (oh *)GC_base(p); + GC_ASSERT(!I_HOLD_LOCK()); GC_err_printf2("0x%lx in object at 0x%lx(", (unsigned long)clobbered_addr, (unsigned long)p); if (clobbered_addr <= (ptr_t)(&(ohdr -> oh_sz)) @@ -283,12 +381,23 @@ ptr_t p, clobbered_addr; PRINT_CALL_CHAIN(ohdr); } } +#endif -void GC_check_heap_proc(); +void GC_check_heap_proc GC_PROTO((void)); +void GC_print_all_smashed_proc GC_PROTO((void)); + +void GC_do_nothing() {} + void GC_start_debugging() { - GC_check_heap = GC_check_heap_proc; +# ifndef SHORT_DBG_HDRS + GC_check_heap = GC_check_heap_proc; + GC_print_all_smashed = GC_print_all_smashed_proc; +# else + GC_check_heap = GC_do_nothing; + GC_print_all_smashed = GC_do_nothing; +# endif GC_print_heap_obj = GC_debug_print_heap_obj_proc; GC_debugging_started = TRUE; GC_register_displacement((word)sizeof(oh)); @@ -333,6 +442,99 @@ void GC_start_debugging() return (GC_store_debug_info(result, (word)lb, s, (word)i)); } +# ifdef __STDC__ + GC_PTR GC_debug_malloc_ignore_off_page(size_t lb, GC_EXTRA_PARAMS) +# else + GC_PTR GC_debug_malloc_ignore_off_page(lb, s, i) + size_t lb; + char * s; + int i; +# ifdef GC_ADD_CALLER + --> GC_ADD_CALLER not implemented for K&R C +# endif +# endif +{ + GC_PTR result = GC_malloc_ignore_off_page(lb + DEBUG_BYTES); + + if (result == 0) { + GC_err_printf1("GC_debug_malloc_ignore_off_page(%ld) returning NIL (", + (unsigned long) lb); + GC_err_puts(s); + GC_err_printf1(":%ld)\n", (unsigned long)i); + return(0); + } + if (!GC_debugging_started) { + GC_start_debugging(); + } + ADD_CALL_CHAIN(result, ra); + return (GC_store_debug_info(result, (word)lb, s, (word)i)); +} + +# ifdef __STDC__ + GC_PTR GC_debug_malloc_atomic_ignore_off_page(size_t lb, GC_EXTRA_PARAMS) +# else + GC_PTR GC_debug_malloc_atomic_ignore_off_page(lb, s, i) + size_t lb; + char * s; + int i; +# ifdef GC_ADD_CALLER + --> GC_ADD_CALLER not implemented for K&R C +# endif +# endif +{ + GC_PTR result = GC_malloc_atomic_ignore_off_page(lb + DEBUG_BYTES); + + if (result == 0) { + GC_err_printf1("GC_debug_malloc_atomic_ignore_off_page(%ld)" + " returning NIL (", (unsigned long) lb); + GC_err_puts(s); + GC_err_printf1(":%ld)\n", (unsigned long)i); + return(0); + } + if (!GC_debugging_started) { + GC_start_debugging(); + } + ADD_CALL_CHAIN(result, ra); + return (GC_store_debug_info(result, (word)lb, s, (word)i)); +} + +# ifdef DBG_HDRS_ALL +/* + * An allocation function for internal use. + * Normally internally allocated objects do not have debug information. + * But in this case, we need to make sure that all objects have debug + * headers. + * We assume debugging was started in collector initialization, + * and we already hold the GC lock. + */ + GC_PTR GC_debug_generic_malloc_inner(size_t lb, int k) + { + GC_PTR result = GC_generic_malloc_inner(lb + DEBUG_BYTES, k); + + if (result == 0) { + GC_err_printf1("GC internal allocation (%ld bytes) returning NIL\n", + (unsigned long) lb); + return(0); + } + ADD_CALL_CHAIN(result, GC_RETURN_ADDR); + return (GC_store_debug_info_inner(result, (word)lb, "INTERNAL", (word)0)); + } + + GC_PTR GC_debug_generic_malloc_inner_ignore_off_page(size_t lb, int k) + { + GC_PTR result = GC_generic_malloc_inner_ignore_off_page( + lb + DEBUG_BYTES, k); + + if (result == 0) { + GC_err_printf1("GC internal allocation (%ld bytes) returning NIL\n", + (unsigned long) lb); + return(0); + } + ADD_CALL_CHAIN(result, GC_RETURN_ADDR); + return (GC_store_debug_info_inner(result, (word)lb, "INTERNAL", (word)0)); + } +# endif + #ifdef STUBBORN_ALLOC # ifdef __STDC__ GC_PTR GC_debug_malloc_stubborn(size_t lb, GC_EXTRA_PARAMS) @@ -459,7 +661,7 @@ GC_PTR p; int i; # endif { - GC_PTR result = GC_malloc_uncollectable(lb + DEBUG_BYTES); + GC_PTR result = GC_malloc_uncollectable(lb + UNCOLLECTABLE_DEBUG_BYTES); if (result == 0) { GC_err_printf1("GC_debug_malloc_uncollectable(%ld) returning NIL (", @@ -485,7 +687,8 @@ GC_PTR p; int i; # endif { - GC_PTR result = GC_malloc_atomic_uncollectable(lb + DEBUG_BYTES); + GC_PTR result = + GC_malloc_atomic_uncollectable(lb + UNCOLLECTABLE_DEBUG_BYTES); if (result == 0) { GC_err_printf1( @@ -525,18 +728,20 @@ GC_PTR p; "GC_debug_free called on pointer %lx wo debugging info\n", (unsigned long)p); } else { - clobbered = GC_check_annotated_obj((oh *)base); - if (clobbered != 0) { - if (((oh *)base) -> oh_sz == GC_size(base)) { +# ifndef SHORT_DBG_HDRS + clobbered = GC_check_annotated_obj((oh *)base); + if (clobbered != 0) { + if (((oh *)base) -> oh_sz == GC_size(base)) { GC_err_printf0( "GC_debug_free: found previously deallocated (?) object at "); - } else { + } else { GC_err_printf0("GC_debug_free: found smashed location at "); + } + GC_print_smashed_obj(p, clobbered); } - GC_print_smashed_obj(p, clobbered); - } - /* Invalidate size */ - ((oh *)base) -> oh_sz = GC_size(base); + /* Invalidate size */ + ((oh *)base) -> oh_sz = GC_size(base); +# endif /* SHORT_DBG_HDRS */ } if (GC_find_leak) { GC_free(base); @@ -556,6 +761,17 @@ GC_PTR p; } /* !GC_find_leak */ } +#ifdef THREADS + +extern void GC_free_inner(GC_PTR p); + +/* Used internally; we assume it's called correctly. */ +void GC_debug_free_inner(GC_PTR p) +{ + GC_free_inner(GC_base(p)); +} +#endif + # ifdef __STDC__ GC_PTR GC_debug_realloc(GC_PTR p, size_t lb, GC_EXTRA_PARAMS) # else @@ -610,12 +826,16 @@ GC_PTR p; GC_err_printf0("GC_debug_realloc: encountered bad kind\n"); ABORT("bad kind"); } - clobbered = GC_check_annotated_obj((oh *)base); - if (clobbered != 0) { +# ifdef SHORT_DBG_HDRS + old_sz = GC_size(base) - sizeof(oh); +# else + clobbered = GC_check_annotated_obj((oh *)base); + if (clobbered != 0) { GC_err_printf0("GC_debug_realloc: found smashed location at "); GC_print_smashed_obj(p, clobbered); - } - old_sz = ((oh *)base) -> oh_sz; + } + old_sz = ((oh *)base) -> oh_sz; +# endif if (old_sz < copy_sz) copy_sz = old_sz; if (result == 0) return(0); BCOPY(p, result, copy_sz); @@ -623,11 +843,55 @@ GC_PTR p; return(result); } +#ifndef SHORT_DBG_HDRS + +/* List of smashed objects. We defer printing these, since we can't */ +/* always print them nicely with the allocation lock held. */ +/* We put them here instead of in GC_arrays, since it may be useful to */ +/* be able to look at them with the debugger. */ +#define MAX_SMASHED 20 +ptr_t GC_smashed[MAX_SMASHED]; +unsigned GC_n_smashed = 0; + +# if defined(__STDC__) || defined(__cplusplus) + void GC_add_smashed(ptr_t smashed) +# else + void GC_add_smashed(smashed) + ptr_t smashed; +#endif +{ + GC_ASSERT(GC_is_marked(GC_base(smashed))); + GC_smashed[GC_n_smashed] = smashed; + if (GC_n_smashed < MAX_SMASHED - 1) ++GC_n_smashed; + /* In case of overflow, we keep the first MAX_SMASHED-1 */ + /* entries plus the last one. */ + GC_have_errors = TRUE; +} + +/* Print all objects on the list. Clear the list. */ +void GC_print_all_smashed_proc () +{ + unsigned i; + + GC_ASSERT(!I_HOLD_LOCK()); + if (GC_n_smashed == 0) return; + GC_err_printf0("GC_check_heap_block: found smashed heap objects:\n"); + for (i = 0; i < GC_n_smashed; ++i) { + GC_print_smashed_obj(GC_base(GC_smashed[i]), GC_smashed[i]); + GC_smashed[i] = 0; + } + GC_n_smashed = 0; +} + /* Check all marked objects in the given block for validity */ /*ARGSUSED*/ -void GC_check_heap_block(hbp, dummy) -register struct hblk *hbp; /* ptr to current heap block */ -word dummy; +# if defined(__STDC__) || defined(__cplusplus) + void GC_check_heap_block(register struct hblk *hbp, word dummy) +# else + void GC_check_heap_block(hbp, dummy) + register struct hblk *hbp; /* ptr to current heap block */ + word dummy; +# endif { register struct hblkhdr * hhdr = HDR(hbp); register word sz = hhdr -> hb_sz; @@ -635,7 +899,7 @@ word dummy; register word *p, *plim; p = (word *)(hbp->hb_body); - word_no = HDR_WORDS; + word_no = 0; if (sz > MAXOBJSZ) { plim = p; } else { @@ -644,14 +908,10 @@ word dummy; /* go through all words in block */ while( p <= plim ) { if( mark_bit_from_hdr(hhdr, word_no) - && GC_has_debug_info((ptr_t)p)) { + && GC_HAS_DEBUG_INFO((ptr_t)p)) { ptr_t clobbered = GC_check_annotated_obj((oh *)p); - if (clobbered != 0) { - GC_err_printf0( - "GC_check_heap_block: found smashed location at "); - GC_print_smashed_obj((ptr_t)p, clobbered); - } + if (clobbered != 0) GC_add_smashed(clobbered); } word_no += sz; p += sz; @@ -664,13 +924,17 @@ word dummy; void GC_check_heap_proc() { # ifndef SMALL_CONFIG - if (sizeof(oh) & (2 * sizeof(word) - 1) != 0) { - ABORT("Alignment problem: object header has inappropriate size\n"); - } +# ifdef ALIGN_DOUBLE + GC_STATIC_ASSERT((sizeof(oh) & (2 * sizeof(word) - 1)) == 0); +# else + GC_STATIC_ASSERT((sizeof(oh) & (sizeof(word) - 1)) == 0); +# endif # endif GC_apply_to_all_blocks(GC_check_heap_block, (word)0); } +#endif /* !SHORT_DBG_HDRS */ + struct closure { GC_finalization_proc cl_fn; GC_PTR cl_data; @@ -685,7 +949,12 @@ struct closure { # endif { struct closure * result = - (struct closure *) GC_malloc(sizeof (struct closure)); +# ifdef DBG_HDRS_ALL + (struct closure *) GC_debug_malloc(sizeof (struct closure), + GC_EXTRAS); +# else + (struct closure *) GC_malloc(sizeof (struct closure)); +# endif result -> cl_fn = fn; result -> cl_data = data; @@ -705,6 +974,28 @@ struct closure { (*(cl -> cl_fn))((GC_PTR)((char *)obj + sizeof(oh)), cl -> cl_data); } +/* Set ofn and ocd to reflect the values we got back. */ +static void store_old (obj, my_old_fn, my_old_cd, ofn, ocd) +GC_PTR obj; +GC_finalization_proc my_old_fn; +struct closure * my_old_cd; +GC_finalization_proc *ofn; +GC_PTR *ocd; +{ + if (0 != my_old_fn) { + if (my_old_fn != GC_debug_invoke_finalizer) { + GC_err_printf1("Debuggable object at 0x%lx had non-debug finalizer.\n", + obj); + /* This should probably be fatal. */ + } else { + if (ofn) *ofn = my_old_cd -> cl_fn; + if (ocd) *ocd = my_old_cd -> cl_data; + } + } else { + if (ofn) *ofn = 0; + if (ocd) *ocd = 0; + } +} # ifdef __STDC__ void GC_debug_register_finalizer(GC_PTR obj, GC_finalization_proc fn, @@ -719,14 +1010,21 @@ struct closure { GC_PTR *ocd; # endif { + GC_finalization_proc my_old_fn; + GC_PTR my_old_cd; ptr_t base = GC_base(obj); if (0 == base || (ptr_t)obj - base != sizeof(oh)) { GC_err_printf1( - "GC_register_finalizer called with non-base-pointer 0x%lx\n", + "GC_debug_register_finalizer called with non-base-pointer 0x%lx\n", obj); } - GC_register_finalizer(base, GC_debug_invoke_finalizer, - GC_make_closure(fn,cd), ofn, ocd); + if (0 == fn) { + GC_register_finalizer(base, 0, 0, &my_old_fn, &my_old_cd); + } else { + GC_register_finalizer(base, GC_debug_invoke_finalizer, + GC_make_closure(fn,cd), &my_old_fn, &my_old_cd); + } + store_old(obj, my_old_fn, (struct closure *)my_old_cd, ofn, ocd); } # ifdef __STDC__ @@ -744,14 +1042,22 @@ struct closure { GC_PTR *ocd; # endif { + GC_finalization_proc my_old_fn; + GC_PTR my_old_cd; ptr_t base = GC_base(obj); if (0 == base || (ptr_t)obj - base != sizeof(oh)) { GC_err_printf1( - "GC_register_finalizer_no_order called with non-base-pointer 0x%lx\n", + "GC_debug_register_finalizer_no_order called with non-base-pointer 0x%lx\n", obj); } - GC_register_finalizer_no_order(base, GC_debug_invoke_finalizer, - GC_make_closure(fn,cd), ofn, ocd); + if (0 == fn) { + GC_register_finalizer_no_order(base, 0, 0, &my_old_fn, &my_old_cd); + } else { + GC_register_finalizer_no_order(base, GC_debug_invoke_finalizer, + GC_make_closure(fn,cd), &my_old_fn, + &my_old_cd); + } + store_old(obj, my_old_fn, (struct closure *)my_old_cd, ofn, ocd); } # ifdef __STDC__ @@ -769,12 +1075,39 @@ struct closure { GC_PTR *ocd; # endif { + GC_finalization_proc my_old_fn; + GC_PTR my_old_cd; ptr_t base = GC_base(obj); if (0 == base || (ptr_t)obj - base != sizeof(oh)) { GC_err_printf1( - "GC_register_finalizer_ignore_self called with non-base-pointer 0x%lx\n", + "GC_debug_register_finalizer_ignore_self called with non-base-pointer 0x%lx\n", obj); } - GC_register_finalizer_ignore_self(base, GC_debug_invoke_finalizer, - GC_make_closure(fn,cd), ofn, ocd); + if (0 == fn) { + GC_register_finalizer_ignore_self(base, 0, 0, &my_old_fn, &my_old_cd); + } else { + GC_register_finalizer_ignore_self(base, GC_debug_invoke_finalizer, + GC_make_closure(fn,cd), &my_old_fn, + &my_old_cd); + } + store_old(obj, my_old_fn, (struct closure *)my_old_cd, ofn, ocd); +} + +#ifdef GC_ADD_CALLER +# define RA GC_RETURN_ADDR, +#else +# define RA +#endif + +GC_PTR GC_debug_malloc_replacement(lb) +size_t lb; +{ + return GC_debug_malloc(lb, RA "unknown", 0); +} + +GC_PTR GC_debug_realloc_replacement(p, lb) +GC_PTR p; +size_t lb; +{ + return GC_debug_realloc(p, lb, RA "unknown", 0); }