version 1.3, 2000/12/01 09:26:10 |
version 1.7, 2003/06/24 05:11:32 |
|
|
* None of this is safe with dlclose and incremental collection. |
* None of this is safe with dlclose and incremental collection. |
* But then not much of anything is safe in the presence of dlclose. |
* But then not much of anything is safe in the presence of dlclose. |
*/ |
*/ |
#ifndef MACOS |
#if defined(__linux__) && !defined(_GNU_SOURCE) |
|
/* Can't test LINUX, since this must be define before other includes */ |
|
# define _GNU_SOURCE |
|
#endif |
|
#if !defined(MACOS) && !defined(_WIN32_WCE) |
# include <sys/types.h> |
# include <sys/types.h> |
#endif |
#endif |
#include "gc_priv.h" |
#include "private/gc_priv.h" |
|
|
/* BTL: avoid circular redefinition of dlopen if SOLARIS_THREADS defined */ |
/* BTL: avoid circular redefinition of dlopen if GC_SOLARIS_THREADS defined */ |
# if (defined(LINUX_THREADS) || defined(SOLARIS_THREADS) \ |
# if (defined(GC_PTHREADS) || defined(GC_SOLARIS_THREADS)) \ |
|| defined(HPUX_THREADS) || defined(IRIX_THREADS)) && defined(dlopen) \ |
&& defined(dlopen) && !defined(GC_USE_LD_WRAP) |
&& !defined(USE_LD_WRAP) |
|
/* To support threads in Solaris, gc.h interposes on dlopen by */ |
/* To support threads in Solaris, gc.h interposes on dlopen by */ |
/* defining "dlopen" to be "GC_dlopen", which is implemented below. */ |
/* defining "dlopen" to be "GC_dlopen", which is implemented below. */ |
/* However, both GC_FirstDLOpenedLinkMap() and GC_dlopen() use the */ |
/* However, both GC_FirstDLOpenedLinkMap() and GC_dlopen() use the */ |
|
|
# undef GC_must_restore_redefined_dlopen |
# undef GC_must_restore_redefined_dlopen |
# endif |
# endif |
|
|
#if (defined(DYNAMIC_LOADING) || defined(MSWIN32)) && !defined(PCR) |
#if (defined(DYNAMIC_LOADING) || defined(MSWIN32) || defined(MSWINCE)) \ |
|
&& !defined(PCR) |
#if !defined(SUNOS4) && !defined(SUNOS5DL) && !defined(IRIX5) && \ |
#if !defined(SUNOS4) && !defined(SUNOS5DL) && !defined(IRIX5) && \ |
!defined(MSWIN32) && !(defined(ALPHA) && defined(OSF1)) && \ |
!defined(MSWIN32) && !defined(MSWINCE) && \ |
|
!(defined(ALPHA) && defined(OSF1)) && \ |
!defined(HPUX) && !(defined(LINUX) && defined(__ELF__)) && \ |
!defined(HPUX) && !(defined(LINUX) && defined(__ELF__)) && \ |
!defined(RS6000) && !defined(SCO_ELF) |
!defined(RS6000) && !defined(SCO_ELF) && !defined(DGUX) && \ |
|
!(defined(FREEBSD) && defined(__ELF__)) && \ |
|
!(defined(NETBSD) && defined(__ELF__)) && !defined(HURD) && \ |
|
!defined(DARWIN) |
--> We only know how to find data segments of dynamic libraries for the |
--> We only know how to find data segments of dynamic libraries for the |
--> above. Additional SVR4 variants might not be too |
--> above. Additional SVR4 variants might not be too |
--> hard to add. |
--> hard to add. |
|
|
# define l_name lm_name |
# define l_name lm_name |
#endif |
#endif |
|
|
|
#if defined(LINUX) && defined(__ELF__) || defined(SCO_ELF) || \ |
|
(defined(FREEBSD) && defined(__ELF__)) || defined(DGUX) || \ |
|
(defined(NETBSD) && defined(__ELF__)) || defined(HURD) |
|
# include <stddef.h> |
|
# include <elf.h> |
|
# include <link.h> |
|
#endif |
|
|
|
/* Newer versions of GNU/Linux define this macro. We |
|
* define it similarly for any ELF systems that don't. */ |
|
# ifndef ElfW |
|
# if !defined(ELF_CLASS) || ELF_CLASS == ELFCLASS32 |
|
# define ElfW(type) Elf32_##type |
|
# else |
|
# define ElfW(type) Elf64_##type |
|
# endif |
|
# endif |
|
|
#if defined(SUNOS5DL) && !defined(USE_PROC_FOR_LIBRARIES) |
#if defined(SUNOS5DL) && !defined(USE_PROC_FOR_LIBRARIES) |
|
|
#ifdef LINT |
#ifdef LINT |
|
|
static struct link_map * |
static struct link_map * |
GC_FirstDLOpenedLinkMap() |
GC_FirstDLOpenedLinkMap() |
{ |
{ |
extern Elf32_Dyn _DYNAMIC; |
extern ElfW(Dyn) _DYNAMIC; |
Elf32_Dyn *dp; |
ElfW(Dyn) *dp; |
struct r_debug *r; |
struct r_debug *r; |
static struct link_map * cachedResult = 0; |
static struct link_map * cachedResult = 0; |
static Elf32_Dyn *dynStructureAddr = 0; |
static ElfW(Dyn) *dynStructureAddr = 0; |
/* BTL: added to avoid Solaris 5.3 ld.so _DYNAMIC bug */ |
/* BTL: added to avoid Solaris 5.3 ld.so _DYNAMIC bug */ |
|
|
# ifdef SUNOS53_SHARED_LIB |
# ifdef SUNOS53_SHARED_LIB |
Line 96 GC_FirstDLOpenedLinkMap() |
|
Line 121 GC_FirstDLOpenedLinkMap() |
|
/* at program startup. */ |
/* at program startup. */ |
if( dynStructureAddr == 0 ) { |
if( dynStructureAddr == 0 ) { |
void* startupSyms = dlopen(0, RTLD_LAZY); |
void* startupSyms = dlopen(0, RTLD_LAZY); |
dynStructureAddr = (Elf32_Dyn*)dlsym(startupSyms, "_DYNAMIC"); |
dynStructureAddr = (ElfW(Dyn)*)dlsym(startupSyms, "_DYNAMIC"); |
} |
} |
# else |
# else |
dynStructureAddr = &_DYNAMIC; |
dynStructureAddr = &_DYNAMIC; |
Line 107 GC_FirstDLOpenedLinkMap() |
|
Line 132 GC_FirstDLOpenedLinkMap() |
|
} |
} |
if( cachedResult == 0 ) { |
if( cachedResult == 0 ) { |
int tag; |
int tag; |
for( dp = ((Elf32_Dyn *)(&_DYNAMIC)); (tag = dp->d_tag) != 0; dp++ ) { |
for( dp = ((ElfW(Dyn) *)(&_DYNAMIC)); (tag = dp->d_tag) != 0; dp++ ) { |
if( tag == DT_DEBUG ) { |
if( tag == DT_DEBUG ) { |
struct link_map *lm |
struct link_map *lm |
= ((struct r_debug *)(dp->d_un.d_ptr))->r_map; |
= ((struct r_debug *)(dp->d_un.d_ptr))->r_map; |
Line 121 GC_FirstDLOpenedLinkMap() |
|
Line 146 GC_FirstDLOpenedLinkMap() |
|
|
|
#endif /* SUNOS5DL ... */ |
#endif /* SUNOS5DL ... */ |
|
|
|
/* BTL: added to fix circular dlopen definition if GC_SOLARIS_THREADS defined */ |
|
# if defined(GC_must_restore_redefined_dlopen) |
|
# define dlopen GC_dlopen |
|
# endif |
|
|
#if defined(SUNOS4) && !defined(USE_PROC_FOR_LIBRARIES) |
#if defined(SUNOS4) && !defined(USE_PROC_FOR_LIBRARIES) |
|
|
#ifdef LINT |
#ifdef LINT |
Line 161 static ptr_t GC_first_common() |
|
Line 191 static ptr_t GC_first_common() |
|
|
|
#endif /* SUNOS4 ... */ |
#endif /* SUNOS4 ... */ |
|
|
# if defined(LINUX_THREADS) || defined(SOLARIS_THREADS) \ |
|
|| defined(HPUX_THREADS) || defined(IRIX_THREADS) |
|
/* Make sure we're not in the middle of a collection, and make */ |
|
/* sure we don't start any. Returns previous value of GC_dont_gc. */ |
|
/* This is invoked prior to a dlopen call to avoid synchronization */ |
|
/* issues. We can't just acquire the allocation lock, since startup */ |
|
/* code in dlopen may try to allocate. */ |
|
/* This solution risks heap growth in the presence of many dlopen */ |
|
/* calls in either a multithreaded environment, or if the library */ |
|
/* initialization code allocates substantial amounts of GC'ed memory. */ |
|
/* But I don't know of a better solution. */ |
|
/* This can still deadlock if the client explicitly starts a GC */ |
|
/* during the dlopen. He shouldn't do that. */ |
|
static GC_bool disable_gc_for_dlopen() |
|
{ |
|
GC_bool result; |
|
LOCK(); |
|
result = GC_dont_gc; |
|
while (GC_incremental && GC_collection_in_progress()) { |
|
GC_collect_a_little_inner(1000); |
|
} |
|
GC_dont_gc = TRUE; |
|
UNLOCK(); |
|
return(result); |
|
} |
|
|
|
/* Redefine dlopen to guarantee mutual exclusion with */ |
|
/* GC_register_dynamic_libraries. */ |
|
/* Should probably happen for other operating systems, too. */ |
|
|
|
#include <dlfcn.h> |
|
|
|
#ifdef USE_LD_WRAP |
|
void * __wrap_dlopen(const char *path, int mode) |
|
#else |
|
void * GC_dlopen(path, mode) |
|
GC_CONST char * path; |
|
int mode; |
|
#endif |
|
{ |
|
void * result; |
|
GC_bool dont_gc_save; |
|
|
|
# ifndef USE_PROC_FOR_LIBRARIES |
|
dont_gc_save = disable_gc_for_dlopen(); |
|
# endif |
|
# ifdef USE_LD_WRAP |
|
result = __real_dlopen(path, mode); |
|
# else |
|
result = dlopen(path, mode); |
|
# endif |
|
# ifndef USE_PROC_FOR_LIBRARIES |
|
GC_dont_gc = dont_gc_save; |
|
# endif |
|
return(result); |
|
} |
|
# endif /* SOLARIS_THREADS */ |
|
|
|
/* BTL: added to fix circular dlopen definition if SOLARIS_THREADS defined */ |
|
# if defined(GC_must_restore_redefined_dlopen) |
|
# define dlopen GC_dlopen |
|
# endif |
|
|
|
# if defined(SUNOS4) || defined(SUNOS5DL) |
# if defined(SUNOS4) || defined(SUNOS5DL) |
/* Add dynamic library data sections to the root set. */ |
/* Add dynamic library data sections to the root set. */ |
# if !defined(PCR) && !defined(SOLARIS_THREADS) && defined(THREADS) |
# if !defined(PCR) && !defined(GC_SOLARIS_THREADS) && defined(THREADS) |
# ifndef SRC_M3 |
# ifndef SRC_M3 |
--> fix mutual exclusion with dlopen |
--> fix mutual exclusion with dlopen |
# endif /* We assume M3 programs don't call dlopen for now */ |
# endif /* We assume M3 programs don't call dlopen for now */ |
Line 251 void GC_register_dynamic_libraries() |
|
Line 218 void GC_register_dynamic_libraries() |
|
TRUE); |
TRUE); |
# endif |
# endif |
# ifdef SUNOS5DL |
# ifdef SUNOS5DL |
Elf32_Ehdr * e; |
ElfW(Ehdr) * e; |
Elf32_Phdr * p; |
ElfW(Phdr) * p; |
unsigned long offset; |
unsigned long offset; |
char * start; |
char * start; |
register int i; |
register int i; |
|
|
e = (Elf32_Ehdr *) lm->l_addr; |
e = (ElfW(Ehdr) *) lm->l_addr; |
p = ((Elf32_Phdr *)(((char *)(e)) + e->e_phoff)); |
p = ((ElfW(Phdr) *)(((char *)(e)) + e->e_phoff)); |
offset = ((unsigned long)(lm->l_addr)); |
offset = ((unsigned long)(lm->l_addr)); |
for( i = 0; i < (int)(e->e_phnum); ((i++),(p++)) ) { |
for( i = 0; i < (int)(e->e_phnum); ((i++),(p++)) ) { |
switch( p->p_type ) { |
switch( p->p_type ) { |
Line 297 void GC_register_dynamic_libraries() |
|
Line 264 void GC_register_dynamic_libraries() |
|
# endif /* !USE_PROC ... */ |
# endif /* !USE_PROC ... */ |
# endif /* SUNOS */ |
# endif /* SUNOS */ |
|
|
#if defined(LINUX) && defined(__ELF__) || defined(SCO_ELF) |
#if defined(LINUX) && defined(__ELF__) || defined(SCO_ELF) || \ |
|
(defined(FREEBSD) && defined(__ELF__)) || defined(DGUX) || \ |
|
(defined(NETBSD) && defined(__ELF__)) || defined(HURD) |
|
|
|
|
|
#ifdef USE_PROC_FOR_LIBRARIES |
|
|
|
#include <string.h> |
|
|
|
#include <sys/stat.h> |
|
#include <fcntl.h> |
|
#include <unistd.h> |
|
|
|
#define MAPS_BUF_SIZE (32*1024) |
|
|
|
extern ssize_t GC_repeat_read(int fd, char *buf, size_t count); |
|
/* Repeatedly read until buffer is filled, or EOF is encountered */ |
|
/* Defined in os_dep.c. */ |
|
|
|
char *GC_parse_map_entry(char *buf_ptr, word *start, word *end, |
|
char *prot_buf, unsigned int *maj_dev); |
|
word GC_apply_to_maps(word (*fn)(char *)); |
|
/* From os_dep.c */ |
|
|
|
word GC_register_map_entries(char *maps) |
|
{ |
|
char prot_buf[5]; |
|
char *buf_ptr = maps; |
|
int count; |
|
word start, end; |
|
unsigned int maj_dev; |
|
word least_ha, greatest_ha; |
|
unsigned i; |
|
word datastart = (word)(DATASTART); |
|
|
|
/* Compute heap bounds. FIXME: Should be done by add_to_heap? */ |
|
least_ha = (word)(-1); |
|
greatest_ha = 0; |
|
for (i = 0; i < GC_n_heap_sects; ++i) { |
|
word sect_start = (word)GC_heap_sects[i].hs_start; |
|
word sect_end = sect_start + GC_heap_sects[i].hs_bytes; |
|
if (sect_start < least_ha) least_ha = sect_start; |
|
if (sect_end > greatest_ha) greatest_ha = sect_end; |
|
} |
|
if (greatest_ha < (word)GC_scratch_last_end_ptr) |
|
greatest_ha = (word)GC_scratch_last_end_ptr; |
|
|
|
for (;;) { |
|
buf_ptr = GC_parse_map_entry(buf_ptr, &start, &end, prot_buf, &maj_dev); |
|
if (buf_ptr == NULL) return 1; |
|
if (prot_buf[1] == 'w') { |
|
/* This is a writable mapping. Add it to */ |
|
/* the root set unless it is already otherwise */ |
|
/* accounted for. */ |
|
if (start <= (word)GC_stackbottom && end >= (word)GC_stackbottom) { |
|
/* Stack mapping; discard */ |
|
continue; |
|
} |
|
# ifdef THREADS |
|
if (GC_segment_is_thread_stack(start, end)) continue; |
|
# endif |
|
/* We no longer exclude the main data segment. */ |
|
if (start < least_ha && end > least_ha) { |
|
end = least_ha; |
|
} |
|
if (start < greatest_ha && end > greatest_ha) { |
|
start = greatest_ha; |
|
} |
|
if (start >= least_ha && end <= greatest_ha) continue; |
|
GC_add_roots_inner((char *)start, (char *)end, TRUE); |
|
} |
|
} |
|
return 1; |
|
} |
|
|
|
void GC_register_dynamic_libraries() |
|
{ |
|
if (!GC_apply_to_maps(GC_register_map_entries)) |
|
ABORT("Failed to read /proc for library registration."); |
|
} |
|
|
|
/* We now take care of the main data segment ourselves: */ |
|
GC_bool GC_register_main_static_data() |
|
{ |
|
return FALSE; |
|
} |
|
|
|
# define HAVE_REGISTER_MAIN_STATIC_DATA |
|
|
|
#endif /* USE_PROC_FOR_LIBRARIES */ |
|
|
|
#if !defined(USE_PROC_FOR_LIBRARIES) |
|
/* The following is the preferred way to walk dynamic libraries */ |
|
/* For glibc 2.2.4+. Unfortunately, it doesn't work for older */ |
|
/* versions. Thanks to Jakub Jelinek for most of the code. */ |
|
|
|
# if defined(LINUX) /* Are others OK here, too? */ \ |
|
&& (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2) \ |
|
|| (__GLIBC__ == 2 && __GLIBC_MINOR__ == 2 && defined(DT_CONFIG))) |
|
|
|
/* We have the header files for a glibc that includes dl_iterate_phdr. */ |
|
/* It may still not be available in the library on the target system. */ |
|
/* Thus we also treat it as a weak symbol. */ |
|
#define HAVE_DL_ITERATE_PHDR |
|
|
|
static int GC_register_dynlib_callback(info, size, ptr) |
|
struct dl_phdr_info * info; |
|
size_t size; |
|
void * ptr; |
|
{ |
|
const ElfW(Phdr) * p; |
|
char * start; |
|
register int i; |
|
|
|
/* Make sure struct dl_phdr_info is at least as big as we need. */ |
|
if (size < offsetof (struct dl_phdr_info, dlpi_phnum) |
|
+ sizeof (info->dlpi_phnum)) |
|
return -1; |
|
|
|
p = info->dlpi_phdr; |
|
for( i = 0; i < (int)(info->dlpi_phnum); ((i++),(p++)) ) { |
|
switch( p->p_type ) { |
|
case PT_LOAD: |
|
{ |
|
if( !(p->p_flags & PF_W) ) break; |
|
start = ((char *)(p->p_vaddr)) + info->dlpi_addr; |
|
GC_add_roots_inner(start, start + p->p_memsz, TRUE); |
|
} |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
|
|
* (int *)ptr = 1; /* Signal that we were called */ |
|
return 0; |
|
} |
|
|
|
/* Return TRUE if we succeed, FALSE if dl_iterate_phdr wasn't there. */ |
|
|
|
#pragma weak dl_iterate_phdr |
|
|
|
GC_bool GC_register_dynamic_libraries_dl_iterate_phdr() |
|
{ |
|
if (dl_iterate_phdr) { |
|
int did_something = 0; |
|
dl_iterate_phdr(GC_register_dynlib_callback, &did_something); |
|
if (!did_something) { |
|
/* dl_iterate_phdr may forget the static data segment in */ |
|
/* statically linked executables. */ |
|
GC_add_roots_inner(DATASTART, (char *)(DATAEND), TRUE); |
|
# if defined(DATASTART2) |
|
GC_add_roots_inner(DATASTART2, (char *)(DATAEND2), TRUE); |
|
# endif |
|
} |
|
|
|
return TRUE; |
|
} else { |
|
return FALSE; |
|
} |
|
} |
|
|
|
/* Do we need to separately register the main static data segment? */ |
|
GC_bool GC_register_main_static_data() |
|
{ |
|
return (dl_iterate_phdr == 0); |
|
} |
|
|
|
#define HAVE_REGISTER_MAIN_STATIC_DATA |
|
|
|
# else /* !LINUX || version(glibc) < 2.2.4 */ |
|
|
/* Dynamic loading code for Linux running ELF. Somewhat tested on |
/* Dynamic loading code for Linux running ELF. Somewhat tested on |
* Linux/x86, untested but hopefully should work on Linux/Alpha. |
* Linux/x86, untested but hopefully should work on Linux/Alpha. |
* This code was derived from the Solaris/ELF support. Thanks to |
* This code was derived from the Solaris/ELF support. Thanks to |
* whatever kind soul wrote that. - Patrick Bridges */ |
* whatever kind soul wrote that. - Patrick Bridges */ |
|
|
#include <elf.h> |
/* This doesn't necessarily work in all cases, e.g. with preloaded |
|
* dynamic libraries. */ |
|
|
|
#if defined(NETBSD) |
|
# include <sys/exec_elf.h> |
|
#else |
|
# include <elf.h> |
|
#endif |
#include <link.h> |
#include <link.h> |
|
|
/* Newer versions of Linux/Alpha and Linux/x86 define this macro. We |
# endif |
* define it for those older versions that don't. */ |
|
# ifndef ElfW |
|
# if !defined(ELF_CLASS) || ELF_CLASS == ELFCLASS32 |
|
# define ElfW(type) Elf32_##type |
|
# else |
|
# define ElfW(type) Elf64_##type |
|
# endif |
|
# endif |
|
|
|
|
#ifdef __GNUC__ |
|
# pragma weak _DYNAMIC |
|
#endif |
|
extern ElfW(Dyn) _DYNAMIC[]; |
|
|
static struct link_map * |
static struct link_map * |
GC_FirstDLOpenedLinkMap() |
GC_FirstDLOpenedLinkMap() |
{ |
{ |
# ifdef __GNUC__ |
|
# pragma weak _DYNAMIC |
|
# endif |
|
extern ElfW(Dyn) _DYNAMIC[]; |
|
ElfW(Dyn) *dp; |
ElfW(Dyn) *dp; |
struct r_debug *r; |
struct r_debug *r; |
static struct link_map *cachedResult = 0; |
static struct link_map *cachedResult = 0; |
Line 348 GC_FirstDLOpenedLinkMap() |
|
Line 485 GC_FirstDLOpenedLinkMap() |
|
|
|
void GC_register_dynamic_libraries() |
void GC_register_dynamic_libraries() |
{ |
{ |
struct link_map *lm = GC_FirstDLOpenedLinkMap(); |
struct link_map *lm; |
|
|
|
|
|
# ifdef HAVE_DL_ITERATE_PHDR |
|
if (GC_register_dynamic_libraries_dl_iterate_phdr()) { |
|
return; |
|
} |
|
# endif |
|
lm = GC_FirstDLOpenedLinkMap(); |
for (lm = GC_FirstDLOpenedLinkMap(); |
for (lm = GC_FirstDLOpenedLinkMap(); |
lm != (struct link_map *) 0; lm = lm->l_next) |
lm != (struct link_map *) 0; lm = lm->l_next) |
{ |
{ |
Line 379 void GC_register_dynamic_libraries() |
|
Line 522 void GC_register_dynamic_libraries() |
|
} |
} |
} |
} |
|
|
#endif |
#endif /* !USE_PROC_FOR_LIBRARIES */ |
|
|
#if defined(IRIX5) || defined(USE_PROC_FOR_LIBRARIES) |
#endif /* LINUX */ |
|
|
|
#if defined(IRIX5) || (defined(USE_PROC_FOR_LIBRARIES) && !defined(LINUX)) |
|
|
#include <sys/procfs.h> |
#include <sys/procfs.h> |
#include <sys/stat.h> |
#include <sys/stat.h> |
#include <fcntl.h> |
#include <fcntl.h> |
#include <elf.h> |
#include <elf.h> |
#include <errno.h> |
#include <errno.h> |
|
#include <signal.h> /* Only for the following test. */ |
|
#ifndef _sigargs |
|
# define IRIX6 |
|
#endif |
|
|
extern void * GC_roots_present(); |
extern void * GC_roots_present(); |
/* The type is a lie, since the real type doesn't make sense here, */ |
/* The type is a lie, since the real type doesn't make sense here, */ |
/* and we only test for NULL. */ |
/* and we only test for NULL. */ |
|
|
#ifndef GC_scratch_last_end_ptr /* Never an extern any more? */ |
|
extern ptr_t GC_scratch_last_end_ptr; /* End of GC_scratch_alloc arena */ |
|
#endif |
|
|
|
/* We use /proc to track down all parts of the address space that are */ |
/* We use /proc to track down all parts of the address space that are */ |
/* mapped by the process, and throw out regions we know we shouldn't */ |
/* mapped by the process, and throw out regions we know we shouldn't */ |
Line 452 void GC_register_dynamic_libraries() |
|
Line 598 void GC_register_dynamic_libraries() |
|
if ((flags & (MA_BREAK | MA_STACK | MA_PHYS)) != 0) goto irrelevant; |
if ((flags & (MA_BREAK | MA_STACK | MA_PHYS)) != 0) goto irrelevant; |
if ((flags & (MA_READ | MA_WRITE)) != (MA_READ | MA_WRITE)) |
if ((flags & (MA_READ | MA_WRITE)) != (MA_READ | MA_WRITE)) |
goto irrelevant; |
goto irrelevant; |
/* The latter test is empirically useless. Other than the */ |
/* The latter test is empirically useless in very old Irix */ |
|
/* versions. Other than the */ |
/* main data and stack segments, everything appears to be */ |
/* main data and stack segments, everything appears to be */ |
/* mapped readable, writable, executable, and shared(!!). */ |
/* mapped readable, writable, executable, and shared(!!). */ |
/* This makes no sense to me. - HB */ |
/* This makes no sense to me. - HB */ |
Line 465 void GC_register_dynamic_libraries() |
|
Line 612 void GC_register_dynamic_libraries() |
|
# endif /* MMAP_STACKS */ |
# endif /* MMAP_STACKS */ |
|
|
limit = start + addr_map[i].pr_size; |
limit = start + addr_map[i].pr_size; |
if (addr_map[i].pr_off == 0 && strncmp(start, ELFMAG, 4) == 0) { |
/* The following seemed to be necessary for very old versions */ |
|
/* of Irix, but it has been reported to discard relevant */ |
|
/* segments under Irix 6.5. */ |
|
# ifndef IRIX6 |
|
if (addr_map[i].pr_off == 0 && strncmp(start, ELFMAG, 4) == 0) { |
/* Discard text segments, i.e. 0-offset mappings against */ |
/* Discard text segments, i.e. 0-offset mappings against */ |
/* executable files which appear to have ELF headers. */ |
/* executable files which appear to have ELF headers. */ |
caddr_t arg; |
caddr_t arg; |
Line 492 void GC_register_dynamic_libraries() |
|
Line 643 void GC_register_dynamic_libraries() |
|
goto irrelevant; |
goto irrelevant; |
} |
} |
} |
} |
} |
} |
|
# endif /* !IRIX6 */ |
GC_add_roots_inner(start, limit, TRUE); |
GC_add_roots_inner(start, limit, TRUE); |
irrelevant: ; |
irrelevant: ; |
} |
} |
Line 504 void GC_register_dynamic_libraries() |
|
Line 656 void GC_register_dynamic_libraries() |
|
|
|
# endif /* USE_PROC || IRIX5 */ |
# endif /* USE_PROC || IRIX5 */ |
|
|
# ifdef MSWIN32 |
# if defined(MSWIN32) || defined(MSWINCE) |
|
|
# define WIN32_LEAN_AND_MEAN |
# define WIN32_LEAN_AND_MEAN |
# define NOSERVICE |
# define NOSERVICE |
Line 513 void GC_register_dynamic_libraries() |
|
Line 665 void GC_register_dynamic_libraries() |
|
|
|
/* We traverse the entire address space and register all segments */ |
/* We traverse the entire address space and register all segments */ |
/* that could possibly have been written to. */ |
/* that could possibly have been written to. */ |
DWORD GC_allocation_granularity; |
|
|
|
extern GC_bool GC_is_heap_base (ptr_t p); |
extern GC_bool GC_is_heap_base (ptr_t p); |
|
|
# ifdef WIN32_THREADS |
# ifdef GC_WIN32_THREADS |
extern void GC_get_next_stack(char *start, char **lo, char **hi); |
extern void GC_get_next_stack(char *start, char **lo, char **hi); |
# endif |
void GC_cond_add_roots(char *base, char * limit) |
|
|
void GC_cond_add_roots(char *base, char * limit) |
|
{ |
|
char dummy; |
|
char * stack_top |
|
= (char *) ((word)(&dummy) & ~(GC_allocation_granularity-1)); |
|
if (base == limit) return; |
|
# ifdef WIN32_THREADS |
|
{ |
{ |
char * curr_base = base; |
char * curr_base = base; |
char * next_stack_lo; |
char * next_stack_lo; |
char * next_stack_hi; |
char * next_stack_hi; |
|
|
for(;;) { |
if (base == limit) return; |
GC_get_next_stack(curr_base, &next_stack_lo, &next_stack_hi); |
for(;;) { |
if (next_stack_lo >= limit) break; |
GC_get_next_stack(curr_base, &next_stack_lo, &next_stack_hi); |
GC_add_roots_inner(curr_base, next_stack_lo, TRUE); |
if (next_stack_lo >= limit) break; |
curr_base = next_stack_hi; |
GC_add_roots_inner(curr_base, next_stack_lo, TRUE); |
} |
curr_base = next_stack_hi; |
if (curr_base < limit) GC_add_roots_inner(curr_base, limit, TRUE); |
} |
|
if (curr_base < limit) GC_add_roots_inner(curr_base, limit, TRUE); |
} |
} |
# else |
# else |
if (limit > stack_top && base < GC_stackbottom) { |
void GC_cond_add_roots(char *base, char * limit) |
/* Part of the stack; ignore it. */ |
{ |
return; |
char dummy; |
} |
char * stack_top |
GC_add_roots_inner(base, limit, TRUE); |
= (char *) ((word)(&dummy) & ~(GC_sysinfo.dwAllocationGranularity-1)); |
# endif |
if (base == limit) return; |
|
if (limit > stack_top && base < GC_stackbottom) { |
|
/* Part of the stack; ignore it. */ |
|
return; |
|
} |
|
GC_add_roots_inner(base, limit, TRUE); |
|
} |
|
# endif |
|
|
|
# ifdef MSWINCE |
|
/* Do we need to separately register the main static data segment? */ |
|
GC_bool GC_register_main_static_data() |
|
{ |
|
return FALSE; |
} |
} |
|
# else /* win32 */ |
|
extern GC_bool GC_no_win32_dlls; |
|
|
|
GC_bool GC_register_main_static_data() |
|
{ |
|
return GC_no_win32_dlls; |
|
} |
|
# endif /* win32 */ |
|
|
extern GC_bool GC_win32s; |
# define HAVE_REGISTER_MAIN_STATIC_DATA |
|
|
void GC_register_dynamic_libraries() |
void GC_register_dynamic_libraries() |
{ |
{ |
MEMORY_BASIC_INFORMATION buf; |
MEMORY_BASIC_INFORMATION buf; |
SYSTEM_INFO sysinfo; |
|
DWORD result; |
DWORD result; |
DWORD protect; |
DWORD protect; |
LPVOID p; |
LPVOID p; |
char * base; |
char * base; |
char * limit, * new_limit; |
char * limit, * new_limit; |
|
|
if (GC_win32s) return; |
# ifdef MSWIN32 |
GetSystemInfo(&sysinfo); |
if (GC_no_win32_dlls) return; |
base = limit = p = sysinfo.lpMinimumApplicationAddress; |
# endif |
GC_allocation_granularity = sysinfo.dwAllocationGranularity; |
base = limit = p = GC_sysinfo.lpMinimumApplicationAddress; |
while (p < sysinfo.lpMaximumApplicationAddress) { |
# if defined(MSWINCE) && !defined(_WIN32_WCE_EMULATION) |
|
/* Only the first 32 MB of address space belongs to the current process */ |
|
while (p < (LPVOID)0x02000000) { |
result = VirtualQuery(p, &buf, sizeof(buf)); |
result = VirtualQuery(p, &buf, sizeof(buf)); |
if (result != sizeof(buf)) { |
if (result == 0) { |
ABORT("Weird VirtualQuery result"); |
/* Page is free; advance to the next possible allocation base */ |
} |
new_limit = (char *) |
new_limit = (char *)p + buf.RegionSize; |
(((DWORD) p + GC_sysinfo.dwAllocationGranularity) |
protect = buf.Protect; |
& ~(GC_sysinfo.dwAllocationGranularity-1)); |
if (buf.State == MEM_COMMIT |
} else |
&& (protect == PAGE_EXECUTE_READWRITE |
# else |
|| protect == PAGE_READWRITE) |
while (p < GC_sysinfo.lpMaximumApplicationAddress) { |
&& !GC_is_heap_base(buf.AllocationBase)) { |
result = VirtualQuery(p, &buf, sizeof(buf)); |
if ((char *)p == limit) { |
# endif |
limit = new_limit; |
{ |
} else { |
if (result != sizeof(buf)) { |
GC_cond_add_roots(base, limit); |
ABORT("Weird VirtualQuery result"); |
base = p; |
} |
limit = new_limit; |
new_limit = (char *)p + buf.RegionSize; |
} |
protect = buf.Protect; |
} |
if (buf.State == MEM_COMMIT |
|
&& (protect == PAGE_EXECUTE_READWRITE |
|
|| protect == PAGE_READWRITE) |
|
&& !GC_is_heap_base(buf.AllocationBase)) { |
|
if ((char *)p != limit) { |
|
GC_cond_add_roots(base, limit); |
|
base = p; |
|
} |
|
limit = new_limit; |
|
} |
|
} |
if (p > (LPVOID)new_limit /* overflow */) break; |
if (p > (LPVOID)new_limit /* overflow */) break; |
p = (LPVOID)new_limit; |
p = (LPVOID)new_limit; |
} |
} |
GC_cond_add_roots(base, limit); |
GC_cond_add_roots(base, limit); |
} |
} |
|
|
#endif /* MSWIN32 */ |
#endif /* MSWIN32 || MSWINCE */ |
|
|
#if defined(ALPHA) && defined(OSF1) |
#if defined(ALPHA) && defined(OSF1) |
|
|
#include <loader.h> |
#include <loader.h> |
Line 720 void GC_register_dynamic_libraries() |
|
Line 896 void GC_register_dynamic_libraries() |
|
|
|
/* Check if this is the end of the list or if some error occured */ |
/* Check if this is the end of the list or if some error occured */ |
if (status != 0) { |
if (status != 0) { |
# ifdef HPUX_THREADS |
# ifdef GC_HPUX_THREADS |
/* I've seen errno values of 0. The man page is not clear */ |
/* I've seen errno values of 0. The man page is not clear */ |
/* as to whether errno should get set on a -1 return. */ |
/* as to whether errno should get set on a -1 return. */ |
break; |
break; |
Line 785 void GC_register_dynamic_libraries() |
|
Line 961 void GC_register_dynamic_libraries() |
|
len = ldi->ldinfo_next; |
len = ldi->ldinfo_next; |
GC_add_roots_inner( |
GC_add_roots_inner( |
ldi->ldinfo_dataorg, |
ldi->ldinfo_dataorg, |
(unsigned long)ldi->ldinfo_dataorg |
(ptr_t)(unsigned long)ldi->ldinfo_dataorg |
+ ldi->ldinfo_datasize, |
+ ldi->ldinfo_datasize, |
TRUE); |
TRUE); |
ldi = len ? (struct ld_info *)((char *)ldi + len) : 0; |
ldi = len ? (struct ld_info *)((char *)ldi + len) : 0; |
Line 793 void GC_register_dynamic_libraries() |
|
Line 969 void GC_register_dynamic_libraries() |
|
} |
} |
#endif /* RS6000 */ |
#endif /* RS6000 */ |
|
|
|
#ifdef DARWIN |
|
|
|
#include <mach-o/dyld.h> |
|
#include <mach-o/getsect.h> |
|
|
|
/*#define DARWIN_DEBUG*/ |
|
|
|
const static struct { |
|
const char *seg; |
|
const char *sect; |
|
} GC_dyld_sections[] = { |
|
{ SEG_DATA, SECT_DATA }, |
|
{ SEG_DATA, SECT_BSS }, |
|
{ SEG_DATA, SECT_COMMON } |
|
}; |
|
|
|
#ifdef DARWIN_DEBUG |
|
static const char *GC_dyld_name_for_hdr(struct mach_header *hdr) { |
|
unsigned long i,c; |
|
c = _dyld_image_count(); |
|
for(i=0;i<c;i++) if(_dyld_get_image_header(i) == hdr) |
|
return _dyld_get_image_name(i); |
|
return NULL; |
|
} |
|
#endif |
|
|
|
/* This should never be called by a thread holding the lock */ |
|
static void GC_dyld_image_add(struct mach_header* hdr, unsigned long slide) { |
|
unsigned long start,end,i; |
|
const struct section *sec; |
|
for(i=0;i<sizeof(GC_dyld_sections)/sizeof(GC_dyld_sections[0]);i++) { |
|
sec = getsectbynamefromheader( |
|
hdr,GC_dyld_sections[i].seg,GC_dyld_sections[i].sect); |
|
if(sec == NULL || sec->size == 0) continue; |
|
start = slide + sec->addr; |
|
end = start + sec->size; |
|
# ifdef DARWIN_DEBUG |
|
GC_printf4("Adding section at %p-%p (%lu bytes) from image %s\n", |
|
start,end,sec->size,GC_dyld_name_for_hdr(hdr)); |
|
# endif |
|
GC_add_roots((char*)start,(char*)end); |
|
} |
|
# ifdef DARWIN_DEBUG |
|
GC_print_static_roots(); |
|
# endif |
|
} |
|
|
|
/* This should never be called by a thread holding the lock */ |
|
static void GC_dyld_image_remove(struct mach_header* hdr, unsigned long slide) { |
|
unsigned long start,end,i; |
|
const struct section *sec; |
|
for(i=0;i<sizeof(GC_dyld_sections)/sizeof(GC_dyld_sections[0]);i++) { |
|
sec = getsectbynamefromheader( |
|
hdr,GC_dyld_sections[i].seg,GC_dyld_sections[i].sect); |
|
if(sec == NULL || sec->size == 0) continue; |
|
start = slide + sec->addr; |
|
end = start + sec->size; |
|
# ifdef DARWIN_DEBUG |
|
GC_printf4("Removing section at %p-%p (%lu bytes) from image %s\n", |
|
start,end,sec->size,GC_dyld_name_for_hdr(hdr)); |
|
# endif |
|
GC_remove_roots((char*)start,(char*)end); |
|
} |
|
# ifdef DARWIN_DEBUG |
|
GC_print_static_roots(); |
|
# endif |
|
} |
|
|
|
void GC_register_dynamic_libraries() { |
|
/* Currently does nothing. The callbacks are setup by GC_init_dyld() |
|
The dyld library takes it from there. */ |
|
} |
|
|
|
/* The _dyld_* functions have an internal lock so no _dyld functions |
|
can be called while the world is stopped without the risk of a deadlock. |
|
Because of this we MUST setup callbacks BEFORE we ever stop the world. |
|
This should be called BEFORE any thread in created and WITHOUT the |
|
allocation lock held. */ |
|
|
|
void GC_init_dyld() { |
|
static GC_bool initialized = FALSE; |
|
|
|
if(initialized) return; |
|
|
|
# ifdef DARWIN_DEBUG |
|
GC_printf0("Forcing full bind of GC code...\n"); |
|
# endif |
|
if(!_dyld_bind_fully_image_containing_address((unsigned long*)GC_malloc)) |
|
GC_abort("_dyld_bind_fully_image_containing_addres failed"); |
|
|
|
# ifdef DARWIN_DEBUG |
|
GC_printf0("Registering dyld callbacks...\n"); |
|
# endif |
|
|
|
/* Apple's Documentation: |
|
When you call _dyld_register_func_for_add_image, the dynamic linker runtime |
|
calls the specified callback (func) once for each of the images that is |
|
currently loaded into the program. When a new image is added to the program, |
|
your callback is called again with the mach_header for the new image, and the virtual memory slide amount of the new image. |
|
|
|
This WILL properly register existing and all future libraries |
|
*/ |
|
|
|
_dyld_register_func_for_add_image(GC_dyld_image_add); |
|
_dyld_register_func_for_remove_image(GC_dyld_image_remove); |
|
initialized = TRUE; |
|
} |
|
|
|
#define HAVE_REGISTER_MAIN_STATIC_DATA |
|
GC_bool GC_register_main_static_data() |
|
{ |
|
/* Already done through dyld callbacks */ |
|
return FALSE; |
|
} |
|
|
|
#endif /* DARWIN */ |
|
|
#else /* !DYNAMIC_LOADING */ |
#else /* !DYNAMIC_LOADING */ |
|
|
#ifdef PCR |
#ifdef PCR |
Line 841 void GC_register_dynamic_libraries(){} |
|
Line 1132 void GC_register_dynamic_libraries(){} |
|
int GC_no_dynamic_loading; |
int GC_no_dynamic_loading; |
|
|
#endif /* !PCR */ |
#endif /* !PCR */ |
|
|
#endif /* !DYNAMIC_LOADING */ |
#endif /* !DYNAMIC_LOADING */ |
|
|
|
#ifndef HAVE_REGISTER_MAIN_STATIC_DATA |
|
|
|
/* Do we need to separately register the main static data segment? */ |
|
GC_bool GC_register_main_static_data() |
|
{ |
|
return TRUE; |
|
} |
|
#endif /* HAVE_REGISTER_MAIN_STATIC_DATA */ |
|
|