version 1.3, 2000/12/01 09:26:10 |
version 1.6, 2002/07/24 08:00:08 |
|
|
* Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers |
* Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers |
* Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. |
* Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. |
* Copyright (c) 1997 by Silicon Graphics. 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 |
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED |
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK. |
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK. |
|
|
* modified is included with the above copyright notice. |
* modified is included with the above copyright notice. |
*/ |
*/ |
|
|
#include "dbg_mlc.h" |
#include "private/dbg_mlc.h" |
|
|
void GC_default_print_heap_obj_proc(); |
void GC_default_print_heap_obj_proc(); |
GC_API void GC_register_finalizer_no_order |
GC_API void GC_register_finalizer_no_order |
Line 22 GC_API void GC_register_finalizer_no_order |
|
Line 22 GC_API void GC_register_finalizer_no_order |
|
GC_finalization_proc *ofn, GC_PTR *ocd)); |
GC_finalization_proc *ofn, GC_PTR *ocd)); |
|
|
|
|
|
#ifndef SHORT_DBG_HDRS |
/* Check whether object with base pointer p has debugging info */ |
/* Check whether object with base pointer p has debugging info */ |
/* p is assumed to point to a legitimate object in our part */ |
/* p is assumed to point to a legitimate object in our part */ |
/* of the heap. */ |
/* 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; |
ptr_t p; |
{ |
{ |
register oh * ohdr = (oh *)p; |
register oh * ohdr = (oh *)p; |
|
|
register word sz = GC_size((ptr_t) ohdr); |
register word sz = GC_size((ptr_t) ohdr); |
|
|
if (HBLKPTR((ptr_t)ohdr) != HBLKPTR((ptr_t)body) |
if (HBLKPTR((ptr_t)ohdr) != HBLKPTR((ptr_t)body) |
|| sz < sizeof (oh)) { |
|| sz < DEBUG_BYTES + EXTRA_BYTES) { |
return(FALSE); |
return(FALSE); |
} |
} |
if (ohdr -> oh_sz == sz) { |
if (ohdr -> oh_sz == sz) { |
|
|
} |
} |
return(FALSE); |
return(FALSE); |
} |
} |
|
#endif |
|
|
#ifdef KEEP_BACK_PTRS |
#ifdef KEEP_BACK_PTRS |
|
|
|
# include <stdlib.h> |
|
|
|
# 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. */ |
/* Store back pointer to source in dest, if that appears to be possible. */ |
/* This is not completely safe, since we may mistakenly conclude that */ |
/* This is not completely safe, since we may mistakenly conclude that */ |
/* dest has a debugging wrapper. But the error probability is very */ |
/* dest has a debugging wrapper. But the error probability is very */ |
|
|
/* be a pointer to the interior of an object. */ |
/* be a pointer to the interior of an object. */ |
void GC_store_back_pointer(ptr_t source, ptr_t dest) |
void GC_store_back_pointer(ptr_t source, ptr_t dest) |
{ |
{ |
if (GC_has_debug_info(dest)) { |
if (GC_HAS_DEBUG_INFO(dest)) { |
((oh *)dest) -> oh_back_ptr = (ptr_t)HIDE_POINTER(source); |
((oh *)dest) -> oh_back_ptr = HIDE_BACK_PTR(source); |
} |
} |
} |
} |
|
|
|
|
oh * hdr = (oh *)GC_base(dest); |
oh * hdr = (oh *)GC_base(dest); |
ptr_t bp; |
ptr_t bp; |
ptr_t bp_base; |
ptr_t bp_base; |
if (!GC_has_debug_info((ptr_t) hdr)) return GC_NO_SPACE; |
if (!GC_HAS_DEBUG_INFO((ptr_t) hdr)) return GC_NO_SPACE; |
bp = hdr -> oh_back_ptr; |
bp = REVEAL_POINTER(hdr -> oh_back_ptr); |
if (MARKED_FOR_FINALIZATION == bp) return GC_FINALIZER_REFD; |
if (MARKED_FOR_FINALIZATION == bp) return GC_FINALIZER_REFD; |
if (MARKED_FROM_REGISTER == bp) return GC_REFD_FROM_REG; |
if (MARKED_FROM_REGISTER == bp) return GC_REFD_FROM_REG; |
if (0 == bp) return GC_UNREFERENCED; |
if (NOT_MARKED == bp) return GC_UNREFERENCED; |
bp = REVEAL_POINTER(bp); |
# 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); |
bp_base = GC_base(bp); |
if (0 == bp_base) { |
if (0 == bp_base) { |
*base_p = bp; |
*base_p = bp; |
*offset_p = 0; |
*offset_p = 0; |
return GC_REFD_FROM_ROOT; |
return GC_REFD_FROM_ROOT; |
} else { |
} 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; |
*base_p = bp_base; |
*offset_p = bp - bp_base; |
*offset_p = bp - bp_base; |
return GC_REFD_FROM_HEAP; |
return GC_REFD_FROM_HEAP; |
|
|
void *GC_generate_random_heap_address(void) |
void *GC_generate_random_heap_address(void) |
{ |
{ |
int i; |
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) { |
for (i = 0; i < GC_n_heap_sects; ++ i) { |
int size = GC_heap_sects[i].hs_bytes; |
int size = GC_heap_sects[i].hs_bytes; |
if (heap_offset < size) { |
if (heap_offset < size) { |
|
|
ptr_t GC_store_debug_info(p, sz, string, integer) |
ptr_t GC_store_debug_info(p, sz, string, integer) |
register ptr_t p; /* base pointer */ |
register ptr_t p; /* base pointer */ |
word sz; /* bytes */ |
word sz; /* bytes */ |
char * string; |
GC_CONST char * string; |
word integer; |
word integer; |
{ |
{ |
register word * result = (word *)((oh *)p + 1); |
register word * result = (word *)((oh *)p + 1); |
|
|
/* inconsistent while we're in the handler. */ |
/* inconsistent while we're in the handler. */ |
LOCK(); |
LOCK(); |
# ifdef KEEP_BACK_PTRS |
# ifdef KEEP_BACK_PTRS |
((oh *)p) -> oh_back_ptr = 0; |
((oh *)p) -> oh_back_ptr = HIDE_BACK_PTR(NOT_MARKED); |
# endif |
# 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_string = string; |
((oh *)p) -> oh_int = integer; |
((oh *)p) -> oh_int = integer; |
((oh *)p) -> oh_sz = sz; |
# ifndef SHORT_DBG_HDRS |
((oh *)p) -> oh_sf = START_FLAG ^ (word)result; |
((oh *)p) -> oh_sz = sz; |
((word *)p)[BYTES_TO_WORDS(GC_size(p))-1] = |
((oh *)p) -> oh_sf = START_FLAG ^ (word)result; |
result[ROUNDED_UP_WORDS(sz)] = END_FLAG ^ (word)result; |
((word *)p)[BYTES_TO_WORDS(GC_size(p))-1] = |
|
result[SIMPLE_ROUNDED_UP_WORDS(sz)] = END_FLAG ^ (word)result; |
|
# endif |
UNLOCK(); |
UNLOCK(); |
return((ptr_t)result); |
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 = 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 */ |
/* Check the object with debugging info at ohdr */ |
/* return NIL if it's OK. Else return clobbered */ |
/* return NIL if it's OK. Else return clobbered */ |
/* address. */ |
/* address. */ |
Line 232 register oh * ohdr; |
|
Line 311 register oh * ohdr; |
|
if (((word *)ohdr)[BYTES_TO_WORDS(gc_sz)-1] != (END_FLAG ^ (word)body)) { |
if (((word *)ohdr)[BYTES_TO_WORDS(gc_sz)-1] != (END_FLAG ^ (word)body)) { |
return((ptr_t)((word *)ohdr + BYTES_TO_WORDS(gc_sz)-1)); |
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)) { |
!= (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); |
return(0); |
} |
} |
|
#endif /* !SHORT_DBG_HDRS */ |
|
|
void GC_print_obj(p) |
void GC_print_obj(p) |
ptr_t p; |
ptr_t p; |
{ |
{ |
register oh * ohdr = (oh *)GC_base(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_printf1("0x%lx (", ((unsigned long)ohdr + sizeof(oh))); |
GC_err_puts(ohdr -> oh_string); |
GC_err_puts(ohdr -> oh_string); |
GC_err_printf2(":%ld, sz=%ld)\n", (unsigned long)(ohdr -> oh_int), |
# ifdef SHORT_DBG_HDRS |
(unsigned long)(ohdr -> oh_sz)); |
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); |
PRINT_CALL_CHAIN(ohdr); |
} |
} |
|
|
void GC_debug_print_heap_obj_proc(p) |
# if defined(__STDC__) || defined(__cplusplus) |
ptr_t p; |
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); |
GC_print_obj(p); |
} else { |
} else { |
GC_default_print_heap_obj_proc(p); |
GC_default_print_heap_obj_proc(p); |
} |
} |
} |
} |
|
|
|
#ifndef SHORT_DBG_HDRS |
void GC_print_smashed_obj(p, clobbered_addr) |
void GC_print_smashed_obj(p, clobbered_addr) |
ptr_t p, clobbered_addr; |
ptr_t p, clobbered_addr; |
{ |
{ |
register oh * ohdr = (oh *)GC_base(p); |
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, |
GC_err_printf2("0x%lx in object at 0x%lx(", (unsigned long)clobbered_addr, |
(unsigned long)p); |
(unsigned long)p); |
if (clobbered_addr <= (ptr_t)(&(ohdr -> oh_sz)) |
if (clobbered_addr <= (ptr_t)(&(ohdr -> oh_sz)) |
Line 283 ptr_t p, clobbered_addr; |
|
Line 375 ptr_t p, clobbered_addr; |
|
PRINT_CALL_CHAIN(ohdr); |
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() |
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_print_heap_obj = GC_debug_print_heap_obj_proc; |
GC_debugging_started = TRUE; |
GC_debugging_started = TRUE; |
GC_register_displacement((word)sizeof(oh)); |
GC_register_displacement((word)sizeof(oh)); |
Line 333 void GC_start_debugging() |
|
Line 436 void GC_start_debugging() |
|
return (GC_store_debug_info(result, (word)lb, s, (word)i)); |
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 STUBBORN_ALLOC |
# ifdef __STDC__ |
# ifdef __STDC__ |
GC_PTR GC_debug_malloc_stubborn(size_t lb, GC_EXTRA_PARAMS) |
GC_PTR GC_debug_malloc_stubborn(size_t lb, GC_EXTRA_PARAMS) |
|
|
int i; |
int i; |
# endif |
# endif |
{ |
{ |
GC_PTR result = GC_malloc_uncollectable(lb + DEBUG_BYTES); |
GC_PTR result = GC_malloc_uncollectable(lb + UNCOLLECTABLE_DEBUG_BYTES); |
|
|
if (result == 0) { |
if (result == 0) { |
GC_err_printf1("GC_debug_malloc_uncollectable(%ld) returning NIL (", |
GC_err_printf1("GC_debug_malloc_uncollectable(%ld) returning NIL (", |
|
|
int i; |
int i; |
# endif |
# 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) { |
if (result == 0) { |
GC_err_printf1( |
GC_err_printf1( |
|
|
"GC_debug_free called on pointer %lx wo debugging info\n", |
"GC_debug_free called on pointer %lx wo debugging info\n", |
(unsigned long)p); |
(unsigned long)p); |
} else { |
} else { |
clobbered = GC_check_annotated_obj((oh *)base); |
# ifndef SHORT_DBG_HDRS |
if (clobbered != 0) { |
clobbered = GC_check_annotated_obj((oh *)base); |
if (((oh *)base) -> oh_sz == GC_size(base)) { |
if (clobbered != 0) { |
|
if (((oh *)base) -> oh_sz == GC_size(base)) { |
GC_err_printf0( |
GC_err_printf0( |
"GC_debug_free: found previously deallocated (?) object at "); |
"GC_debug_free: found previously deallocated (?) object at "); |
} else { |
} else { |
GC_err_printf0("GC_debug_free: found smashed location at "); |
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 */ |
# endif /* SHORT_DBG_HDRS */ |
((oh *)base) -> oh_sz = GC_size(base); |
|
} |
} |
if (GC_find_leak) { |
if (GC_find_leak) { |
GC_free(base); |
GC_free(base); |
|
|
} /* !GC_find_leak */ |
} /* !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__ |
# ifdef __STDC__ |
GC_PTR GC_debug_realloc(GC_PTR p, size_t lb, GC_EXTRA_PARAMS) |
GC_PTR GC_debug_realloc(GC_PTR p, size_t lb, GC_EXTRA_PARAMS) |
# else |
# else |
|
|
GC_err_printf0("GC_debug_realloc: encountered bad kind\n"); |
GC_err_printf0("GC_debug_realloc: encountered bad kind\n"); |
ABORT("bad kind"); |
ABORT("bad kind"); |
} |
} |
clobbered = GC_check_annotated_obj((oh *)base); |
# ifdef SHORT_DBG_HDRS |
if (clobbered != 0) { |
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_err_printf0("GC_debug_realloc: found smashed location at "); |
GC_print_smashed_obj(p, clobbered); |
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 (old_sz < copy_sz) copy_sz = old_sz; |
if (result == 0) return(0); |
if (result == 0) return(0); |
BCOPY(p, result, copy_sz); |
BCOPY(p, result, copy_sz); |
|
|
return(result); |
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_smashed[GC_n_smashed] = smashed; |
|
if (GC_n_smashed < MAX_SMASHED - 1) ++GC_n_smashed; |
|
} |
|
|
|
/* Print all objects on the list. Clear the list. */ |
|
void GC_print_all_smashed_proc () |
|
{ |
|
int 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 */ |
/* Check all marked objects in the given block for validity */ |
/*ARGSUSED*/ |
/*ARGSUSED*/ |
void GC_check_heap_block(hbp, dummy) |
# if defined(__STDC__) || defined(__cplusplus) |
register struct hblk *hbp; /* ptr to current heap block */ |
void GC_check_heap_block(register struct hblk *hbp, word dummy) |
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 struct hblkhdr * hhdr = HDR(hbp); |
register word sz = hhdr -> hb_sz; |
register word sz = hhdr -> hb_sz; |
|
|
register word *p, *plim; |
register word *p, *plim; |
|
|
p = (word *)(hbp->hb_body); |
p = (word *)(hbp->hb_body); |
word_no = HDR_WORDS; |
word_no = 0; |
if (sz > MAXOBJSZ) { |
if (sz > MAXOBJSZ) { |
plim = p; |
plim = p; |
} else { |
} else { |
|
|
/* go through all words in block */ |
/* go through all words in block */ |
while( p <= plim ) { |
while( p <= plim ) { |
if( mark_bit_from_hdr(hhdr, word_no) |
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); |
ptr_t clobbered = GC_check_annotated_obj((oh *)p); |
|
|
if (clobbered != 0) { |
if (clobbered != 0) GC_add_smashed(clobbered); |
GC_err_printf0( |
|
"GC_check_heap_block: found smashed location at "); |
|
GC_print_smashed_obj((ptr_t)p, clobbered); |
|
} |
|
} |
} |
word_no += sz; |
word_no += sz; |
p += sz; |
p += sz; |
Line 671 void GC_check_heap_proc() |
|
Line 865 void GC_check_heap_proc() |
|
GC_apply_to_all_blocks(GC_check_heap_block, (word)0); |
GC_apply_to_all_blocks(GC_check_heap_block, (word)0); |
} |
} |
|
|
|
#endif /* !SHORT_DBG_HDRS */ |
|
|
struct closure { |
struct closure { |
GC_finalization_proc cl_fn; |
GC_finalization_proc cl_fn; |
GC_PTR cl_data; |
GC_PTR cl_data; |
Line 685 struct closure { |
|
Line 881 struct closure { |
|
# endif |
# endif |
{ |
{ |
struct closure * result = |
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_fn = fn; |
result -> cl_data = data; |
result -> cl_data = data; |
Line 705 struct closure { |
|
Line 906 struct closure { |
|
(*(cl -> cl_fn))((GC_PTR)((char *)obj + sizeof(oh)), cl -> cl_data); |
(*(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__ |
# ifdef __STDC__ |
void GC_debug_register_finalizer(GC_PTR obj, GC_finalization_proc fn, |
void GC_debug_register_finalizer(GC_PTR obj, GC_finalization_proc fn, |
Line 719 struct closure { |
|
Line 942 struct closure { |
|
GC_PTR *ocd; |
GC_PTR *ocd; |
# endif |
# endif |
{ |
{ |
|
GC_finalization_proc my_old_fn; |
|
GC_PTR my_old_cd; |
ptr_t base = GC_base(obj); |
ptr_t base = GC_base(obj); |
if (0 == base || (ptr_t)obj - base != sizeof(oh)) { |
if (0 == base || (ptr_t)obj - base != sizeof(oh)) { |
GC_err_printf1( |
GC_err_printf1( |
"GC_register_finalizer called with non-base-pointer 0x%lx\n", |
"GC_register_finalizer called with non-base-pointer 0x%lx\n", |
obj); |
obj); |
} |
} |
GC_register_finalizer(base, GC_debug_invoke_finalizer, |
if (0 == fn) { |
GC_make_closure(fn,cd), ofn, ocd); |
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__ |
# ifdef __STDC__ |
Line 744 struct closure { |
|
Line 974 struct closure { |
|
GC_PTR *ocd; |
GC_PTR *ocd; |
# endif |
# endif |
{ |
{ |
|
GC_finalization_proc my_old_fn; |
|
GC_PTR my_old_cd; |
ptr_t base = GC_base(obj); |
ptr_t base = GC_base(obj); |
if (0 == base || (ptr_t)obj - base != sizeof(oh)) { |
if (0 == base || (ptr_t)obj - base != sizeof(oh)) { |
GC_err_printf1( |
GC_err_printf1( |
"GC_register_finalizer_no_order called with non-base-pointer 0x%lx\n", |
"GC_register_finalizer_no_order called with non-base-pointer 0x%lx\n", |
obj); |
obj); |
} |
} |
GC_register_finalizer_no_order(base, GC_debug_invoke_finalizer, |
if (0 == fn) { |
GC_make_closure(fn,cd), ofn, ocd); |
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__ |
# ifdef __STDC__ |
Line 769 struct closure { |
|
Line 1007 struct closure { |
|
GC_PTR *ocd; |
GC_PTR *ocd; |
# endif |
# endif |
{ |
{ |
|
GC_finalization_proc my_old_fn; |
|
GC_PTR my_old_cd; |
ptr_t base = GC_base(obj); |
ptr_t base = GC_base(obj); |
if (0 == base || (ptr_t)obj - base != sizeof(oh)) { |
if (0 == base || (ptr_t)obj - base != sizeof(oh)) { |
GC_err_printf1( |
GC_err_printf1( |
"GC_register_finalizer_ignore_self called with non-base-pointer 0x%lx\n", |
"GC_register_finalizer_ignore_self called with non-base-pointer 0x%lx\n", |
obj); |
obj); |
} |
} |
GC_register_finalizer_ignore_self(base, GC_debug_invoke_finalizer, |
if (0 == fn) { |
GC_make_closure(fn,cd), ofn, ocd); |
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); |
} |
} |