=================================================================== RCS file: /home/cvs/OpenXM_contrib2/asir2000/gc/dbg_mlc.c,v retrieving revision 1.1 retrieving revision 1.4 diff -u -p -r1.1 -r1.4 --- OpenXM_contrib2/asir2000/gc/dbg_mlc.c 1999/12/03 07:39:09 1.1 +++ OpenXM_contrib2/asir2000/gc/dbg_mlc.c 2001/04/20 07:39:18 1.4 @@ -2,6 +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-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. @@ -12,69 +13,26 @@ * provided the above notices are retained, and a notice that the code was * modified is included with the above copyright notice. */ -# define I_HIDE_POINTERS -# include "gc_priv.h" -# ifdef KEEP_BACK_PTRS -# include "backptr.h" -# endif +#include "private/dbg_mlc.h" + void GC_default_print_heap_obj_proc(); GC_API void GC_register_finalizer_no_order GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd, GC_finalization_proc *ofn, GC_PTR *ocd)); -/* Do we want to and know how to save the call stack at the time of */ -/* an allocation? How much space do we want to use in each object? */ -# define START_FLAG ((word)0xfedcedcb) -# define END_FLAG ((word)0xbcdecdef) - /* Stored both one past the end of user object, and one before */ - /* the end of the object as seen by the allocator. */ - - -/* Object header */ -typedef struct { -# ifdef KEEP_BACK_PTRS - ptr_t oh_back_ptr; -# define MARKED_FOR_FINALIZATION (ptr_t)(-1) - /* Object was marked because it is finalizable. */ -# ifdef ALIGN_DOUBLE - word oh_dummy; -# endif -# endif - char * oh_string; /* object descriptor string */ - word oh_int; /* object descriptor integers */ -# ifdef NEED_CALLINFO - struct callinfo oh_ci[NFRAMES]; -# endif - word oh_sz; /* Original malloc arg. */ - word oh_sf; /* start flag */ -} oh; -/* The size of the above structure is assumed not to dealign things, */ -/* and to be a multiple of the word length. */ - -#define DEBUG_BYTES (sizeof (oh) + sizeof (word)) -#undef ROUNDED_UP_WORDS -#define ROUNDED_UP_WORDS(n) BYTES_TO_WORDS((n) + WORDS_TO_BYTES(1) - 1) - - -#ifdef SAVE_CALL_CHAIN -# define ADD_CALL_CHAIN(base, ra) GC_save_callers(((oh *)(base)) -> oh_ci) -# define PRINT_CALL_CHAIN(base) GC_print_callers(((oh *)(base)) -> oh_ci) -#else -# ifdef GC_ADD_CALLER -# define ADD_CALL_CHAIN(base, ra) ((oh *)(base)) -> oh_ci[0].ci_pc = (ra) -# define PRINT_CALL_CHAIN(base) GC_print_callers(((oh *)(base)) -> oh_ci) -# else -# define ADD_CALL_CHAIN(base, ra) -# define PRINT_CALL_CHAIN(base) -# endif -#endif - +#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 tha 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; @@ -95,8 +53,19 @@ ptr_t p; } return(FALSE); } +#endif #ifdef KEEP_BACK_PTRS + +# include + +# if defined(LINUX) || defined(SUNOS4) || defined(SUNOS5) \ + || defined(HPUX) || defined(IRIX) || 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 */ @@ -105,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); } } @@ -116,7 +85,7 @@ ptr_t p; /* Store information about the object referencing dest in *base_p */ /* and *offset_p. */ - /* source is root ==> *base_p = 0, *offset_p = address */ + /* source is root ==> *base_p = address, *offset_p = 0 */ /* source is heap object ==> *base_p != 0, *offset_p = offset */ /* Returns 1 on success, 0 if source couldn't be determined. */ /* Dest can be any address within a heap object. */ @@ -125,18 +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 (0 == bp) return GC_UNREFERENCED; - bp = REVEAL_POINTER(bp); + if (MARKED_FROM_REGISTER == bp) return GC_REFD_FROM_REG; + 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; @@ -149,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) { @@ -177,18 +170,15 @@ ptr_t p; } } - /* Force a garbage collection and generate a backtrace from a */ - /* random heap address. */ - void GC_generate_random_backtrace(void) + /* Print back trace for p */ + void GC_print_backtrace(void *p) { - void * current; + void *current = p; int i; - void * base; - size_t offset; GC_ref_kind source; - GC_gcollect(); - current = GC_generate_random_valid_address(); - GC_printf1("Chose address 0x%lx in object\n", (unsigned long)current); + size_t offset; + void *base; + GC_print_heap_obj(GC_base(current)); GC_err_printf0("\n"); for (i = 0; ; ++i) { @@ -207,6 +197,9 @@ ptr_t p; case GC_REFD_FROM_ROOT: GC_err_printf1("root at 0x%lx\n", (unsigned long)base); goto out; + case GC_REFD_FROM_REG: + GC_err_printf0("root in register\n"); + goto out; case GC_FINALIZER_REFD: GC_err_printf0("list of finalizable objects\n"); goto out; @@ -221,6 +214,17 @@ ptr_t p; } out:; } + + /* Force a garbage collection and generate a backtrace from a */ + /* random heap address. */ + void GC_generate_random_backtrace(void) + { + void * current; + GC_gcollect(); + current = GC_generate_random_valid_address(); + GC_printf1("Chose address 0x%lx in object\n", (unsigned long)current); + GC_print_backtrace(current); + } #endif /* KEEP_BACK_PTRS */ @@ -240,18 +244,50 @@ word integer; /* inconsistent while we're in the handler. */ LOCK(); # ifdef KEEP_BACK_PTRS - ((oh *)p) -> oh_back_ptr = 0; + ((oh *)p) -> oh_back_ptr = HIDE_BACK_PTR(NOT_MARKED); # 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] = +# 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[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. */ +# ifdef KEEP_BACK_PTRS + ((oh *)p) -> oh_back_ptr = 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[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. */ @@ -275,6 +311,7 @@ register oh * ohdr; } return(0); } +#endif /* !SHORT_DBG_HDRS */ void GC_print_obj(p) ptr_t p; @@ -283,21 +320,30 @@ ptr_t p; 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, sz=%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)) { + 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; { @@ -320,12 +366,19 @@ 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_do_nothing() {} + void GC_start_debugging() { - GC_check_heap = GC_check_heap_proc; +# ifndef SHORT_DBG_HDRS + GC_check_heap = GC_check_heap_proc; +# else + GC_check_heap = GC_do_nothing; +# endif GC_print_heap_obj = GC_debug_print_heap_obj_proc; GC_debugging_started = TRUE; GC_register_displacement((word)sizeof(oh)); @@ -342,16 +395,8 @@ void GC_start_debugging() GC_register_displacement((word)sizeof(oh) + offset); } -# ifdef GC_ADD_CALLER -# define EXTRA_ARGS word ra, char * s, int i -# define OPT_RA ra, -# else -# define EXTRA_ARGS char * s, int i -# define OPT_RA -# endif - # ifdef __STDC__ - GC_PTR GC_debug_malloc(size_t lb, EXTRA_ARGS) + GC_PTR GC_debug_malloc(size_t lb, GC_EXTRA_PARAMS) # else GC_PTR GC_debug_malloc(lb, s, i) size_t lb; @@ -378,9 +423,46 @@ void GC_start_debugging() 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, ra); + 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, ra); + 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, EXTRA_ARGS) + GC_PTR GC_debug_malloc_stubborn(size_t lb, GC_EXTRA_PARAMS) # else GC_PTR GC_debug_malloc_stubborn(lb, s, i) size_t lb; @@ -444,11 +526,35 @@ GC_PTR p; GC_end_stubborn_change(q); } -#endif /* STUBBORN_ALLOC */ +#else /* !STUBBORN_ALLOC */ # ifdef __STDC__ - GC_PTR GC_debug_malloc_atomic(size_t lb, EXTRA_ARGS) + GC_PTR GC_debug_malloc_stubborn(size_t lb, GC_EXTRA_PARAMS) # else + GC_PTR GC_debug_malloc_stubborn(lb, s, i) + size_t lb; + char * s; + int i; +# endif +{ + return GC_debug_malloc(lb, OPT_RA s, i); +} + +void GC_debug_change_stubborn(p) +GC_PTR p; +{ +} + +void GC_debug_end_stubborn_change(p) +GC_PTR p; +{ +} + +#endif /* !STUBBORN_ALLOC */ + +# ifdef __STDC__ + GC_PTR GC_debug_malloc_atomic(size_t lb, GC_EXTRA_PARAMS) +# else GC_PTR GC_debug_malloc_atomic(lb, s, i) size_t lb; char * s; @@ -472,7 +578,7 @@ GC_PTR p; } # ifdef __STDC__ - GC_PTR GC_debug_malloc_uncollectable(size_t lb, EXTRA_ARGS) + GC_PTR GC_debug_malloc_uncollectable(size_t lb, GC_EXTRA_PARAMS) # else GC_PTR GC_debug_malloc_uncollectable(lb, s, i) size_t lb; @@ -498,7 +604,7 @@ GC_PTR p; #ifdef ATOMIC_UNCOLLECTABLE # ifdef __STDC__ - GC_PTR GC_debug_malloc_atomic_uncollectable(size_t lb, EXTRA_ARGS) + GC_PTR GC_debug_malloc_atomic_uncollectable(size_t lb, GC_EXTRA_PARAMS) # else GC_PTR GC_debug_malloc_atomic_uncollectable(lb, s, i) size_t lb; @@ -531,54 +637,67 @@ GC_PTR p; GC_PTR p; # endif { - register GC_PTR base = GC_base(p); + register GC_PTR base; register ptr_t clobbered; + if (0 == p) return; + base = GC_base(p); if (base == 0) { GC_err_printf1("Attempt to free invalid pointer %lx\n", (unsigned long)p); - if (p != 0) ABORT("free(invalid pointer)"); + ABORT("free(invalid pointer)"); } if ((ptr_t)p - (ptr_t)base != sizeof(oh)) { GC_err_printf1( "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 */ } -# ifdef FIND_LEAK + if (GC_find_leak) { GC_free(base); -# else - { - register hdr * hhdr = HDR(p); - GC_bool uncollectable = FALSE; + } else { + register hdr * hhdr = HDR(p); + GC_bool uncollectable = FALSE; - if (hhdr -> hb_obj_kind == UNCOLLECTABLE) { - uncollectable = TRUE; - } -# ifdef ATOMIC_UNCOLLECTABLE - if (hhdr -> hb_obj_kind == AUNCOLLECTABLE) { - uncollectable = TRUE; - } -# endif - if (uncollectable) GC_free(base); + if (hhdr -> hb_obj_kind == UNCOLLECTABLE) { + uncollectable = TRUE; } -# endif +# ifdef ATOMIC_UNCOLLECTABLE + if (hhdr -> hb_obj_kind == AUNCOLLECTABLE) { + uncollectable = TRUE; + } +# endif + if (uncollectable) GC_free(base); + } /* !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, EXTRA_ARGS) + GC_PTR GC_debug_realloc(GC_PTR p, size_t lb, GC_EXTRA_PARAMS) # else GC_PTR GC_debug_realloc(p, lb, s, i) GC_PTR p; @@ -631,12 +750,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); @@ -644,11 +767,16 @@ GC_PTR p; return(result); } +#ifndef SHORT_DBG_HDRS /* 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; @@ -656,7 +784,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 { @@ -665,7 +793,7 @@ 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) { @@ -692,6 +820,8 @@ void GC_check_heap_proc() 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; @@ -706,7 +836,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; @@ -798,4 +933,17 @@ struct closure { } GC_register_finalizer_ignore_self(base, GC_debug_invoke_finalizer, GC_make_closure(fn,cd), ofn, ocd); +} + +GC_PTR GC_debug_malloc_replacement(lb) +size_t lb; +{ + return GC_debug_malloc(lb, "unknown", 0); +} + +GC_PTR GC_debug_realloc_replacement(p, lb) +GC_PTR p; +size_t lb; +{ + return GC_debug_realloc(p, lb, "unknown", 0); }