[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.6 and 1.7

version 1.6, 2002/07/24 08:00:08 version 1.7, 2003/06/24 05:11:32
Line 57 
Line 57 
     !defined(HPUX) && !(defined(LINUX) && defined(__ELF__)) && \      !defined(HPUX) && !(defined(LINUX) && defined(__ELF__)) && \
     !defined(RS6000) && !defined(SCO_ELF) && !defined(DGUX) && \      !defined(RS6000) && !defined(SCO_ELF) && !defined(DGUX) && \
     !(defined(FREEBSD) && defined(__ELF__)) && \      !(defined(FREEBSD) && defined(__ELF__)) && \
     !(defined(NETBSD) && defined(__ELF__)) && !defined(HURD)      !(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.
Line 282  extern ssize_t GC_repeat_read(int fd, char *buf, size_
Line 283  extern ssize_t GC_repeat_read(int fd, char *buf, size_
         /* Repeatedly read until buffer is filled, or EOF is encountered */          /* Repeatedly read until buffer is filled, or EOF is encountered */
         /* Defined in os_dep.c.                                          */          /* Defined in os_dep.c.                                          */
   
 static char *parse_map_entry(char *buf_ptr, word *start, word *end,  char *GC_parse_map_entry(char *buf_ptr, word *start, word *end,
                              char *prot_buf, unsigned int *maj_dev);                           char *prot_buf, unsigned int *maj_dev);
   word GC_apply_to_maps(word (*fn)(char *));
           /* From os_dep.c        */
   
 void GC_register_dynamic_libraries()  word GC_register_map_entries(char *maps)
 {  {
     int f;  
     int result;  
     char prot_buf[5];      char prot_buf[5];
     int maps_size;      char *buf_ptr = maps;
     char maps_temp[32768];  
     char *maps_buf;  
     char *buf_ptr;  
     int count;      int count;
     word start, end;      word start, end;
     unsigned int maj_dev, min_dev;      unsigned int maj_dev;
     word least_ha, greatest_ha;      word least_ha, greatest_ha;
     unsigned i;      unsigned i;
     word datastart = (word)(DATASTART);      word datastart = (word)(DATASTART);
   
     /* Read /proc/self/maps     */      /* Compute heap bounds. FIXME: Should be done by add_to_heap?       */
         /* 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);          least_ha = (word)(-1);
         greatest_ha = 0;          greatest_ha = 0;
         for (i = 0; i < GC_n_heap_sects; ++i) {          for (i = 0; i < GC_n_heap_sects; ++i) {
Line 342  void GC_register_dynamic_libraries()
Line 310  void GC_register_dynamic_libraries()
         }          }
         if (greatest_ha < (word)GC_scratch_last_end_ptr)          if (greatest_ha < (word)GC_scratch_last_end_ptr)
             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);      for (;;) {
         if (buf_ptr == NULL) return;          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') {          if (prot_buf[1] == 'w') {
             /* This is a writable mapping.  Add it to           */              /* This is a writable mapping.  Add it to           */
             /* the root set unless it is already otherwise      */              /* the root set unless it is already otherwise      */
Line 355  void GC_register_dynamic_libraries()
Line 322  void GC_register_dynamic_libraries()
                 /* Stack mapping; discard       */                  /* Stack mapping; discard       */
                 continue;                  continue;
             }              }
             if (start <= datastart && end > datastart && maj_dev != 0) {  
                 /* Main data segment; discard   */  
                 continue;  
             }  
 #           ifdef THREADS  #           ifdef THREADS
               if (GC_segment_is_thread_stack(start, end)) continue;                if (GC_segment_is_thread_stack(start, end)) continue;
 #           endif  #           endif
             /* The rest of this assumes that there is no mapping        */              /* We no longer exclude the main data segment.              */
             /* 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) {              if (start < least_ha && end > least_ha) {
                 end = least_ha;                  end = least_ha;
             }              }
Line 381  void GC_register_dynamic_libraries()
Line 335  void GC_register_dynamic_libraries()
             if (start >= least_ha && end <= greatest_ha) continue;              if (start >= least_ha && end <= greatest_ha) continue;
             GC_add_roots_inner((char *)start, (char *)end, TRUE);              GC_add_roots_inner((char *)start, (char *)end, TRUE);
         }          }
      }      }
       return 1;
 }  }
   
 //  void GC_register_dynamic_libraries()
 //  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;     if (!GC_apply_to_maps(GC_register_map_entries))
     unsigned int val;         ABORT("Failed to read /proc for library registration.");
     char *tok;  }
   
     if (buf_ptr == NULL || *buf_ptr == '\0') {  /* We now take care of the main data segment ourselves: */
         return NULL;  GC_bool GC_register_main_static_data()
     }  {
     return FALSE;
     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;  
 }  }
   
   # define HAVE_REGISTER_MAIN_STATIC_DATA
   
 #endif /* USE_PROC_FOR_LIBRARIES */  #endif /* USE_PROC_FOR_LIBRARIES */
   
Line 469  static int GC_register_dynlib_callback(info, size, ptr
Line 383  static int GC_register_dynlib_callback(info, size, ptr
       + sizeof (info->dlpi_phnum))        + sizeof (info->dlpi_phnum))
     return -1;      return -1;
   
   /* Skip the first object - it is the main program.  */  
   if (*(int *)ptr == 0)  
     {  
       *(int *)ptr = 1;  
       return 0;  
     }  
   
   p = info->dlpi_phdr;    p = info->dlpi_phdr;
   for( i = 0; i < (int)(info->dlpi_phnum); ((i++),(p++)) ) {    for( i = 0; i < (int)(info->dlpi_phnum); ((i++),(p++)) ) {
     switch( p->p_type ) {      switch( p->p_type ) {
Line 491  static int GC_register_dynlib_callback(info, size, ptr
Line 398  static int GC_register_dynlib_callback(info, size, ptr
     }      }
   }    }
   
     * (int *)ptr = 1;     /* Signal that we were called */
   return 0;    return 0;
 }  }
   
Line 500  static int GC_register_dynlib_callback(info, size, ptr
Line 408  static int GC_register_dynlib_callback(info, size, ptr
   
 GC_bool GC_register_dynamic_libraries_dl_iterate_phdr()  GC_bool GC_register_dynamic_libraries_dl_iterate_phdr()
 {  {
   int tmp = 0;  
   
   if (dl_iterate_phdr) {    if (dl_iterate_phdr) {
     dl_iterate_phdr(GC_register_dynlib_callback, &tmp);      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;      return TRUE;
   } else {    } else {
     return FALSE;      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 */  # 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
Line 776  void GC_register_dynamic_libraries()
Line 700  void GC_register_dynamic_libraries()
     }      }
 # endif  # endif
   
 # ifndef MSWINCE  # 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;    extern GC_bool GC_no_win32_dlls;
 # endif  
     GC_bool GC_register_main_static_data()
     {
       return GC_no_win32_dlls;
     }
   # endif /* win32 */
   
   # define HAVE_REGISTER_MAIN_STATIC_DATA
   
   void GC_register_dynamic_libraries()    void GC_register_dynamic_libraries()
   {    {
     MEMORY_BASIC_INFORMATION buf;      MEMORY_BASIC_INFORMATION buf;
Line 1024  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 1032  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 1080  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 */
   
Legend:
Removed from v.1.6  
changed lines
  Added in v.1.7
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>