[BACK]Return to dyn_load.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / gc

Diff for /OpenXM_contrib2/asir2000/gc/dyn_load.c between version 1.1 and 1.6

version 1.1, 1999/12/03 07:39:09 version 1.6, 2002/07/24 08:00:08
Line 26 
Line 26 
  * 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(SOLARIS_THREADS) && defined(dlopen)  # if (defined(GC_PTHREADS) || defined(GC_SOLARIS_THREADS)) \
         && defined(dlopen) && !defined(GC_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   */
Line 44 
Line 49 
 #   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(HP_PA) && !(defined(LINUX) && defined(__ELF__)) && \      !(defined(ALPHA) && defined(OSF1)) && \
     !defined(RS6000) && !defined(SCO_ELF)      !defined(HPUX) && !(defined(LINUX) && defined(__ELF__)) && \
       !defined(RS6000) && !defined(SCO_ELF) && !defined(DGUX) && \
       !(defined(FREEBSD) && defined(__ELF__)) && \
       !(defined(NETBSD) && defined(__ELF__)) && !defined(HURD)
  --> 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.
Line 70 
Line 79 
 #   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
Line 80 
Line 106 
 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 94  GC_FirstDLOpenedLinkMap()
Line 120  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 105  GC_FirstDLOpenedLinkMap()
Line 131  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 119  GC_FirstDLOpenedLinkMap()
Line 145  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 192  static ptr_t GC_first_common()
   
 # 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 */
 # endif  # endif
   
 # ifdef SOLARIS_THREADS  
   /* Redefine dlopen to guarantee mutual exclusion with */  
   /* GC_register_dynamic_libraries.                     */  
   /* assumes that dlopen doesn't need to call GC_malloc */  
   /* and friends.                                       */  
 # include <thread.h>  
 # include <synch.h>  
   
 void * GC_dlopen(const char *path, int mode)  
 {  
     void * result;  
   
 #   ifndef USE_PROC_FOR_LIBRARIES  
       mutex_lock(&GC_allocate_ml);  
 #   endif  
     result = dlopen(path, mode);  
 #   ifndef USE_PROC_FOR_LIBRARIES  
       mutex_unlock(&GC_allocate_ml);  
 #   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  
   
 # ifndef USE_PROC_FOR_LIBRARIES  # ifndef USE_PROC_FOR_LIBRARIES
 void GC_register_dynamic_libraries()  void GC_register_dynamic_libraries()
 {  {
Line 214  void GC_register_dynamic_libraries()
Line 217  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 260  void GC_register_dynamic_libraries()
Line 263  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.                                          */
   
   static char *parse_map_entry(char *buf_ptr, word *start, word *end,
                                char *prot_buf, unsigned int *maj_dev);
   
   void GC_register_dynamic_libraries()
   {
       int f;
       int result;
       char prot_buf[5];
       int maps_size;
       char maps_temp[32768];
       char *maps_buf;
       char *buf_ptr;
       int count;
       word start, end;
       unsigned int maj_dev, min_dev;
       word least_ha, greatest_ha;
       unsigned i;
       word datastart = (word)(DATASTART);
   
       /* Read /proc/self/maps     */
           /* Note that we may not allocate, and thus can't use stdio.     */
           f = open("/proc/self/maps", O_RDONLY);
           if (-1 == f) ABORT("Couldn't open /proc/self/maps");
           /* stat() doesn't work for /proc/self/maps, so we have to
              read it to find out how large it is... */
           maps_size = 0;
           do {
               result = GC_repeat_read(f, maps_temp, sizeof(maps_temp));
               if (result <= 0) ABORT("Couldn't read /proc/self/maps");
               maps_size += result;
           } while (result == sizeof(maps_temp));
   
           if (maps_size > sizeof(maps_temp)) {
               /* If larger than our buffer, close and re-read it. */
               close(f);
               f = open("/proc/self/maps", O_RDONLY);
               if (-1 == f) ABORT("Couldn't open /proc/self/maps");
               maps_buf = alloca(maps_size);
               if (NULL == maps_buf) ABORT("/proc/self/maps alloca failed");
               result = GC_repeat_read(f, maps_buf, maps_size);
               if (result <= 0) ABORT("Couldn't read /proc/self/maps");
           } else {
               /* Otherwise use the fixed size buffer */
               maps_buf = maps_temp;
           }
   
           close(f);
           maps_buf[result] = '\0';
           buf_ptr = maps_buf;
       /* Compute heap bounds. 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 = parse_map_entry(buf_ptr, &start, &end, prot_buf, &maj_dev);
           if (buf_ptr == NULL) return;
   
           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;
               }
               if (start <= datastart && end > datastart && maj_dev != 0) {
                   /* Main data segment; discard   */
                   continue;
               }
   #           ifdef THREADS
                 if (GC_segment_is_thread_stack(start, end)) continue;
   #           endif
               /* The rest of this assumes that there is no mapping        */
               /* spanning the beginning of the data segment, or extending */
               /* beyond the entire heap at both ends.                     */
               /* Empirically these assumptions hold.                      */
   
               if (start < (word)DATAEND && end > (word)DATAEND) {
                   /* Rld may use space at the end of the main data        */
                   /* segment.  Thus we add that in.                       */
                   start = (word)DATAEND;
               }
               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);
           }
        }
   }
   
   //
   //  parse_map_entry parses an entry from /proc/self/maps so we can
   //  locate all writable data segments that belong to shared libraries.
   //  The format of one of these entries and the fields we care about
   //  is as follows:
   //  XXXXXXXX-XXXXXXXX r-xp 00000000 30:05 260537     name of mapping...\n
   //  ^^^^^^^^ ^^^^^^^^ ^^^^          ^^
   //  start    end      prot          maj_dev
   //  0        9        18            32
   //
   //  The parser is called with a pointer to the entry and the return value
   //  is either NULL or is advanced to the next entry(the byte after the
   //  trailing '\n'.)
   //
   #define OFFSET_MAP_START   0
   #define OFFSET_MAP_END     9
   #define OFFSET_MAP_PROT   18
   #define OFFSET_MAP_MAJDEV 32
   
   static char *parse_map_entry(char *buf_ptr, word *start, word *end,
                                char *prot_buf, unsigned int *maj_dev)
   {
       int i;
       unsigned int val;
       char *tok;
   
       if (buf_ptr == NULL || *buf_ptr == '\0') {
           return NULL;
       }
   
       memcpy(prot_buf, buf_ptr+OFFSET_MAP_PROT, 4); // do the protections first
       prot_buf[4] = '\0';
   
       if (prot_buf[1] == 'w') { // we can skip all of this if it's not writable
   
           tok = buf_ptr;
           buf_ptr[OFFSET_MAP_START+8] = '\0';
           *start = strtoul(tok, NULL, 16);
   
           tok = buf_ptr+OFFSET_MAP_END;
           buf_ptr[OFFSET_MAP_END+8] = '\0';
           *end = strtoul(tok, NULL, 16);
   
           buf_ptr += OFFSET_MAP_MAJDEV;
           tok = buf_ptr;
           while (*buf_ptr != ':') buf_ptr++;
           *buf_ptr++ = '\0';
           *maj_dev = strtoul(tok, NULL, 16);
       }
   
       while (*buf_ptr && *buf_ptr++ != '\n');
   
       return buf_ptr;
   }
   
   #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;
   
     /* Skip the first object - it is the main program.  */
     if (*(int *)ptr == 0)
       {
         *(int *)ptr = 1;
         return 0;
       }
   
     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;
       }
     }
   
     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()
   {
     int tmp = 0;
   
     if (dl_iterate_phdr) {
       dl_iterate_phdr(GC_register_dynlib_callback, &tmp);
       return TRUE;
     } else {
       return FALSE;
     }
   }
   
   # 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 311  GC_FirstDLOpenedLinkMap()
Line 561  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 342  void GC_register_dynamic_libraries()
Line 598  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.                                      */
   
 extern ptr_t GC_scratch_last_end_ptr; /* End of GC_scratch_alloc arena  */  
   
 /* 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 413  void GC_register_dynamic_libraries()
Line 674  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 426  void GC_register_dynamic_libraries()
Line 688  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 453  void GC_register_dynamic_libraries()
Line 719  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 465  void GC_register_dynamic_libraries()
Line 732  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 474  void GC_register_dynamic_libraries()
Line 741  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
   
   # ifndef MSWINCE
     extern GC_bool GC_no_win32_dlls;
   # endif
   
   extern GC_bool GC_win32s;  
   
   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 658  void GC_register_dynamic_libraries()
Line 936  void GC_register_dynamic_libraries()
 }  }
 #endif  #endif
   
 #if defined(HP_PA)  #if defined(HPUX)
   
 #include <errno.h>  #include <errno.h>
 #include <dl.h>  #include <dl.h>
Line 681  void GC_register_dynamic_libraries()
Line 959  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 GC_HPUX_THREADS
              /* I've seen errno values of 0.  The man page is not clear   */
              /* as to whether errno should get set on a -1 return.        */
              break;
   #        else
           if (errno == EINVAL) {            if (errno == EINVAL) {
               break; /* Moved past end of shared library list --> finished */                break; /* Moved past end of shared library list --> finished */
           } else {            } else {
Line 691  void GC_register_dynamic_libraries()
Line 974  void GC_register_dynamic_libraries()
               }                }
               ABORT("shl_get failed");                ABORT("shl_get failed");
           }            }
   #        endif
         }          }
   
 #     ifdef VERBOSE  #     ifdef VERBOSE
Line 713  void GC_register_dynamic_libraries()
Line 997  void GC_register_dynamic_libraries()
         index++;          index++;
     }      }
 }  }
 #endif /* HP_PA */  #endif /* HPUX */
   
 #ifdef RS6000  #ifdef RS6000
 #pragma alloca  #pragma alloca
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.6
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>