[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.5 and 1.6

version 1.5, 2002/07/24 07:46:16 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.
  */   */
   #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)  #if !defined(MACOS) && !defined(_WIN32_WCE)
 #  include <sys/types.h>  #  include <sys/types.h>
 #endif  #endif
 #include "private/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(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 52 
Line 55 
     !defined(MSWIN32) && !defined(MSWINCE) && \      !defined(MSWIN32) && !defined(MSWINCE) && \
     !(defined(ALPHA) && defined(OSF1)) && \      !(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(NETBSD) && defined(__ELF__))      !(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 75 
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 85 
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 99  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 110  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 124  GC_FirstDLOpenedLinkMap()
Line 145  GC_FirstDLOpenedLinkMap()
   
 #endif /* SUNOS5DL ... */  #endif /* SUNOS5DL ... */
   
 /* BTL: added to fix circular dlopen definition if SOLARIS_THREADS defined */  /* BTL: added to fix circular dlopen definition if GC_SOLARIS_THREADS defined */
 # if defined(GC_must_restore_redefined_dlopen)  # if defined(GC_must_restore_redefined_dlopen)
 #   define dlopen GC_dlopen  #   define dlopen GC_dlopen
 # endif  # endif
Line 171  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 */
Line 196  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 243  void GC_register_dynamic_libraries()
Line 264  void GC_register_dynamic_libraries()
 # endif /* SUNOS */  # endif /* SUNOS */
   
 #if defined(LINUX) && defined(__ELF__) || defined(SCO_ELF) || \  #if defined(LINUX) && defined(__ELF__) || defined(SCO_ELF) || \
     (defined(NETBSD) && defined(__ELF__))      (defined(FREEBSD) && defined(__ELF__)) || defined(DGUX) || \
       (defined(NETBSD) && defined(__ELF__)) || defined(HURD)
   
   
 #ifdef USE_PROC_FOR_LIBRARIES  #ifdef USE_PROC_FOR_LIBRARIES
Line 417  static char *parse_map_entry(char *buf_ptr, word *star
Line 439  static char *parse_map_entry(char *buf_ptr, word *star
     return buf_ptr;      return buf_ptr;
 }  }
   
 #else /* !USE_PROC_FOR_LIBRARIES */  #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 */
   
   /* This doesn't necessarily work in all cases, e.g. with preloaded
    * dynamic libraries.                                           */
   
 #if defined(NETBSD)  #if defined(NETBSD)
 #  include <sys/exec_elf.h>  #  include <sys/exec_elf.h>
 #else  #else
Line 431  static char *parse_map_entry(char *buf_ptr, word *star
Line 527  static char *parse_map_entry(char *buf_ptr, word *star
 #endif  #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 472  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 514  void GC_register_dynamic_libraries()
Line 609  void GC_register_dynamic_libraries()
 #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, */
Line 575  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 588  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 615  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 639  void GC_register_dynamic_libraries()
Line 744  void GC_register_dynamic_libraries()
   
   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);
     void GC_cond_add_roots(char *base, char * limit)      void GC_cond_add_roots(char *base, char * limit)
     {      {
Line 672  void GC_register_dynamic_libraries()
Line 777  void GC_register_dynamic_libraries()
 # endif  # endif
   
 # ifndef MSWINCE  # ifndef MSWINCE
   extern GC_bool GC_win32s;    extern GC_bool GC_no_win32_dlls;
 # endif  # endif
   
   void GC_register_dynamic_libraries()    void GC_register_dynamic_libraries()
Line 685  void GC_register_dynamic_libraries()
Line 790  void GC_register_dynamic_libraries()
     char * limit, * new_limit;      char * limit, * new_limit;
   
 #   ifdef MSWIN32  #   ifdef MSWIN32
       if (GC_win32s) return;        if (GC_no_win32_dlls) return;
 #   endif  #   endif
     base = limit = p = GC_sysinfo.lpMinimumApplicationAddress;      base = limit = p = GC_sysinfo.lpMinimumApplicationAddress;
 #   if defined(MSWINCE) && !defined(_WIN32_WCE_EMULATION)  #   if defined(MSWINCE) && !defined(_WIN32_WCE_EMULATION)
Line 854  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 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;
Legend:
Removed from v.1.5  
changed lines
  Added in v.1.6
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>