boehm-gc/dyn_load.c

   1 /*
   2  * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
   3  * Copyright (c) 1997 by Silicon Graphics.  All rights reserved.
   4  *
   5  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
   6  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
   7  *
   8  * Permission is hereby granted to use or copy this program
   9  * for any purpose,  provided the above notices are retained on all copies.
  10  * Permission to modify the code and to distribute modified code is granted,
  11  * provided the above notices are retained, and a notice that the code was
  12  * modified is included with the above copyright notice.
  13  *
  14  * Original author: Bill Janssen
  15  * Heavily modified by Hans Boehm and others
  16  */
  17
  18 /*
  19  * This is incredibly OS specific code for tracking down data sections in
  20  * dynamic libraries.  There appears to be no way of doing this quickly
  21  * without groveling through undocumented data structures.  We would argue
  22  * that this is a bug in the design of the dlopen interface.  THIS CODE
  23  * MAY BREAK IN FUTURE OS RELEASES.  If this matters to you, don't hesitate
  24  * to let your vendor know ...
  25  *
  26  * None of this is safe with dlclose and incremental collection.
  27  * But then not much of anything is safe in the presence of dlclose.
  28  */
  29 #if (defined(__linux__) || defined(__GLIBC__)) && !defined(_GNU_SOURCE)
  30     /* Can't test LINUX, since this must be define before other includes */
  31 #   define _GNU_SOURCE
  32 #endif
  33 #if !defined(MACOS) && !defined(_WIN32_WCE)
  34 #  include <sys/types.h>
  35 #endif
  36 #include "private/gc_priv.h"
  37
  38 /* BTL: avoid circular redefinition of dlopen if GC_SOLARIS_THREADS defined */
  39 # if (defined(GC_PTHREADS) || defined(GC_SOLARIS_THREADS)) \
  40       && defined(dlopen) && !defined(GC_USE_LD_WRAP)
  41     /* To support threads in Solaris, gc.h interposes on dlopen by       */
  42     /* defining "dlopen" to be "GC_dlopen", which is implemented below.  */
  43     /* However, both GC_FirstDLOpenedLinkMap() and GC_dlopen() use the   */
  44     /* real system dlopen() in their implementation. We first remove     */
  45     /* gc.h's dlopen definition and restore it later, after GC_dlopen(). */
  46 #   undef dlopen
  47 #   define GC_must_restore_redefined_dlopen
  48 # else
  49 #   undef GC_must_restore_redefined_dlopen
  50 # endif
  51
  52 #if (defined(DYNAMIC_LOADING) || defined(MSWIN32) || defined(MSWINCE)) \
  53     && !defined(PCR)
  54 #if !defined(SUNOS4) && !defined(SUNOS5DL) && !defined(IRIX5) && \
  55     !defined(MSWIN32) && !defined(MSWINCE) && \
  56     !(defined(ALPHA) && defined(OSF1)) && \
  57     !defined(HPUX) && !(defined(LINUX) && defined(__ELF__)) && \
  58     !defined(RS6000) && !defined(SCO_ELF) && !defined(DGUX) && \
  59     !(defined(FREEBSD) && defined(__ELF__)) && \
  60     !(defined(NETBSD) && defined(__ELF__)) && !defined(HURD) && \
  61     !defined(DARWIN)
  62  --> We only know how to find data segments of dynamic libraries for the
  63  --> above.  Additional SVR4 variants might not be too
  64  --> hard to add.
  65 #endif
  66
  67 #include <stdio.h>
  68 #ifdef SUNOS5DL
  69 #   include <sys/elf.h>
  70 #   include <dlfcn.h>
  71 #   include <link.h>
  72 #endif
  73 #ifdef SUNOS4
  74 #   include <dlfcn.h>
  75 #   include <link.h>
  76 #   include <a.out.h>
  77   /* struct link_map field overrides */
  78 #   define l_next       lm_next
  79 #   define l_addr       lm_addr
  80 #   define l_name       lm_name
  81 #endif
  82
  83 #if defined(NETBSD)
  84 #   include <machine/elf_machdep.h>
  85 #   define ELFSIZE ARCH_ELFSIZE
  86 #endif
  87
  88 #if defined(LINUX) && defined(__ELF__) || defined(SCO_ELF) || \
  89     (defined(FREEBSD) && defined(__ELF__)) || defined(DGUX) || \
  90     (defined(NETBSD) && defined(__ELF__)) || defined(HURD)
  91 #   include <stddef.h>
  92 #   include <elf.h>
  93 #   include <link.h>
  94 #endif
  95
  96 /* Newer versions of GNU/Linux define this macro.  We
  97  * define it similarly for any ELF systems that don't.  */
  98 #  ifndef ElfW
  99 #    if defined(FREEBSD)
 100 #      if __ELF_WORD_SIZE == 32
 101 #        define ElfW(type) Elf32_##type
 102 #      else
 103 #        define ElfW(type) Elf64_##type
 104 #      endif
 105 #    else
 106 #      ifdef NETBSD
 107 #        if ELFSIZE == 32
 108 #          define ElfW(type) Elf32_##type
 109 #        else
 110 #          define ElfW(type) Elf64_##type
 111 #        endif
 112 #      else
 113 #        if !defined(ELF_CLASS) || ELF_CLASS == ELFCLASS32
 114 #          define ElfW(type) Elf32_##type
 115 #        else
 116 #          define ElfW(type) Elf64_##type
 117 #        endif
 118 #      endif
 119 #    endif
 120 #  endif
 121
 122 /* An user-supplied routine that is called to dtermine if a DSO must
 123    be scanned by the gc.  */
 124 static int (*GC_has_static_roots)(const char *, void *, size_t);
 125 /* Register the routine.  */
 126 void
 127 GC_register_has_static_roots_callback
 128   (int (*callback)(const char *, void *, size_t))
 129 {
 130   GC_has_static_roots = callback;
 131 }
 132
 133 #if defined(SUNOS5DL) && !defined(USE_PROC_FOR_LIBRARIES)
 134
 135 #ifdef LINT
 136     Elf32_Dyn _DYNAMIC;
 137 #endif
 138
 139 static struct link_map *
 140 GC_FirstDLOpenedLinkMap()
 141 {
 142     extern ElfW(Dyn) _DYNAMIC;
 143     ElfW(Dyn) *dp;
 144     struct r_debug *r;
 145     static struct link_map * cachedResult = 0;
 146     static ElfW(Dyn) *dynStructureAddr = 0;
 147                         /* BTL: added to avoid Solaris 5.3 ld.so _DYNAMIC bug */
 148
 149 #   ifdef SUNOS53_SHARED_LIB
 150         /* BTL: Avoid the Solaris 5.3 bug that _DYNAMIC isn't being set */
 151         /* up properly in dynamically linked .so's. This means we have  */
 152         /* to use its value in the set of original object files loaded  */
 153         /* at program startup.                                          */
 154         if( dynStructureAddr == 0 ) {
 155           void* startupSyms = dlopen(0, RTLD_LAZY);
 156           dynStructureAddr = (ElfW(Dyn)*)dlsym(startupSyms, "_DYNAMIC");
 157                 }
 158 #   else
 159         dynStructureAddr = &_DYNAMIC;
 160 #   endif
 161
 162     if( dynStructureAddr == 0) {
 163         return(0);
 164     }
 165     if( cachedResult == 0 ) {
 166         int tag;
 167         for( dp = ((ElfW(Dyn) *)(&_DYNAMIC)); (tag = dp->d_tag) != 0; dp++ ) {
 168             if( tag == DT_DEBUG ) {
 169                 struct link_map *lm
 170                         = ((struct r_debug *)(dp->d_un.d_ptr))->r_map;
 171                 if( lm != 0 ) cachedResult = lm->l_next; /* might be NIL */
 172                 break;
 173             }
 174         }
 175     }
 176     return cachedResult;
 177 }
 178
 179 #endif /* SUNOS5DL ... */
 180
 181 /* BTL: added to fix circular dlopen definition if GC_SOLARIS_THREADS defined */
 182 # if defined(GC_must_restore_redefined_dlopen)
 183 #   define dlopen GC_dlopen
 184 # endif
 185
 186 #if defined(SUNOS4) && !defined(USE_PROC_FOR_LIBRARIES)
 187
 188 #ifdef LINT
 189     struct link_dynamic _DYNAMIC;
 190 #endif
 191
 192 static struct link_map *
 193 GC_FirstDLOpenedLinkMap()
 194 {
 195     extern struct link_dynamic _DYNAMIC;
 196
 197     if( &_DYNAMIC == 0) {
 198         return(0);
 199     }
 200     return(_DYNAMIC.ld_un.ld_1->ld_loaded);
 201 }
 202
 203 /* Return the address of the ld.so allocated common symbol      */
 204 /* with the least address, or 0 if none.                        */
 205 static ptr_t GC_first_common()
 206 {
 207     ptr_t result = 0;
 208     extern struct link_dynamic _DYNAMIC;
 209     struct rtc_symb * curr_symbol;
 210
 211     if( &_DYNAMIC == 0) {
 212         return(0);
 213     }
 214     curr_symbol = _DYNAMIC.ldd -> ldd_cp;
 215     for (; curr_symbol != 0; curr_symbol = curr_symbol -> rtc_next) {
 216         if (result == 0
 217             || (ptr_t)(curr_symbol -> rtc_sp -> n_value) < result) {
 218             result = (ptr_t)(curr_symbol -> rtc_sp -> n_value);
 219         }
 220     }
 221     return(result);
 222 }
 223
 224 #endif  /* SUNOS4 ... */
 225
 226 # if defined(SUNOS4) || defined(SUNOS5DL)
 227 /* Add dynamic library data sections to the root set.           */
 228 # if !defined(PCR) && !defined(GC_SOLARIS_PTHREADS) && defined(THREADS)
 229 #   ifndef SRC_M3
 230         --> fix mutual exclusion with dlopen
 231 #   endif  /* We assume M3 programs don't call dlopen for now */
 232 # endif
 233
 234 # ifndef USE_PROC_FOR_LIBRARIES
 235 void GC_register_dynamic_libraries()
 236 {
 237   struct link_map *lm = GC_FirstDLOpenedLinkMap();
 238
 239
 240   for (lm = GC_FirstDLOpenedLinkMap();
 241        lm != (struct link_map *) 0;  lm = lm->l_next)
 242     {
 243 #     ifdef SUNOS4
 244         struct exec *e;
 245
 246         e = (struct exec *) lm->lm_addr;
 247         GC_add_roots_inner(
 248                     ((char *) (N_DATOFF(*e) + lm->lm_addr)),
 249                     ((char *) (N_BSSADDR(*e) + e->a_bss + lm->lm_addr)),
 250                     TRUE);
 251 #     endif
 252 #     ifdef SUNOS5DL
 253         ElfW(Ehdr) * e;
 254         ElfW(Phdr) * p;
 255         unsigned long offset;
 256         char * start;
 257         register int i;
 258
 259         e = (ElfW(Ehdr) *) lm->l_addr;
 260         p = ((ElfW(Phdr) *)(((char *)(e)) + e->e_phoff));
 261         offset = ((unsigned long)(lm->l_addr));
 262         for( i = 0; i < (int)(e->e_phnum); ((i++),(p++)) ) {
 263           switch( p->p_type ) {
 264             case PT_LOAD:
 265               {
 266                 if( !(p->p_flags & PF_W) ) break;
 267                 start = ((char *)(p->p_vaddr)) + offset;
 268                 GC_add_roots_inner(
 269                   start,
 270                   start + p->p_memsz,
 271                   TRUE
 272                 );
 273               }
 274               break;
 275             default:
 276               break;
 277           }
 278         }
 279 #     endif
 280     }
 281 #   ifdef SUNOS4
 282       {
 283         static ptr_t common_start = 0;
 284         ptr_t common_end;
 285         extern ptr_t GC_find_limit();
 286
 287         if (common_start == 0) common_start = GC_first_common();
 288         if (common_start != 0) {
 289             common_end = GC_find_limit(common_start, TRUE);
 290             GC_add_roots_inner((char *)common_start, (char *)common_end, TRUE);
 291         }
 292       }
 293 #   endif
 294 }
 295
 296 # endif /* !USE_PROC ... */
 297 # endif /* SUNOS */
 298
 299 #if defined(LINUX) && defined(__ELF__) || defined(SCO_ELF) || \
 300     (defined(FREEBSD) && defined(__ELF__)) || defined(DGUX) || \
 301     (defined(NETBSD) && defined(__ELF__)) || defined(HURD)
 302
 303
 304 #ifdef USE_PROC_FOR_LIBRARIES
 305
 306 #include <string.h>
 307
 308 #include <sys/stat.h>
 309 #include <fcntl.h>
 310 #include <unistd.h>
 311
 312 #define MAPS_BUF_SIZE (32*1024)
 313
 314 extern ssize_t GC_repeat_read(int fd, char *buf, size_t count);
 315         /* Repeatedly read until buffer is filled, or EOF is encountered */
 316         /* Defined in os_dep.c.                                          */
 317
 318 char *GC_parse_map_entry(char *buf_ptr, word *start, word *end,
 319                          char *prot_buf, unsigned int *maj_dev);
 320 word GC_apply_to_maps(word (*fn)(char *));
 321         /* From os_dep.c        */
 322
 323 word GC_register_map_entries(char *maps)
 324 {
 325     char prot_buf[5];
 326     char *buf_ptr = maps;
 327     int count;
 328     word start, end;
 329     unsigned int maj_dev;
 330     word least_ha, greatest_ha;
 331     unsigned i;
 332     word datastart = (word)(DATASTART);
 333
 334     /* Compute heap bounds. FIXME: Should be done by add_to_heap?       */
 335         least_ha = (word)(-1);
 336         greatest_ha = 0;
 337         for (i = 0; i < GC_n_heap_sects; ++i) {
 338             word sect_start = (word)GC_heap_sects[i].hs_start;
 339             word sect_end = sect_start + GC_heap_sects[i].hs_bytes;
 340             if (sect_start < least_ha) least_ha = sect_start;
 341             if (sect_end > greatest_ha) greatest_ha = sect_end;
 342         }
 343         if (greatest_ha < (word)GC_scratch_last_end_ptr)
 344             greatest_ha = (word)GC_scratch_last_end_ptr;
 345
 346     for (;;) {
 347         buf_ptr = GC_parse_map_entry(buf_ptr, &start, &end, prot_buf, &maj_dev);
 348         if (buf_ptr == NULL) return 1;
 349         if (prot_buf[1] == 'w') {
 350             /* This is a writable mapping.  Add it to           */
 351             /* the root set unless it is already otherwise      */
 352             /* accounted for.                                   */
 353             if (start <= (word)GC_stackbottom && end >= (word)GC_stackbottom) {
 354                 /* Stack mapping; discard       */
 355                 continue;
 356             }
 357 #           ifdef THREADS
 358               if (GC_segment_is_thread_stack(start, end)) continue;
 359 #           endif
 360             /* We no longer exclude the main data segment.              */
 361             if (start < least_ha && end > least_ha) {
 362                 end = least_ha;
 363             }
 364             if (start < greatest_ha && end > greatest_ha) {
 365                 start = greatest_ha;
 366             }
 367             if (start >= least_ha && end <= greatest_ha) continue;
 368             GC_add_roots_inner((char *)start, (char *)end, TRUE);
 369         }
 370     }
 371     return 1;
 372 }
 373
 374 void GC_register_dynamic_libraries()
 375 {
 376    if (!GC_apply_to_maps(GC_register_map_entries))
 377        ABORT("Failed to read /proc for library registration.");
 378 }
 379
 380 /* We now take care of the main data segment ourselves: */
 381 GC_bool GC_register_main_static_data()
 382 {
 383   return FALSE;
 384 }
 385
 386 # define HAVE_REGISTER_MAIN_STATIC_DATA
 387
 388 #endif /* USE_PROC_FOR_LIBRARIES */
 389
 390 #if !defined(USE_PROC_FOR_LIBRARIES)
 391 /* The following is the preferred way to walk dynamic libraries */
 392 /* For glibc 2.2.4+.  Unfortunately, it doesn't work for older  */
 393 /* versions.  Thanks to Jakub Jelinek for most of the code.     */
 394
 395 # if (defined(LINUX) || defined (__GLIBC__)) /* Are others OK here, too? */ \
 396      && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ > 2) \
 397          || (__GLIBC__ == 2 && __GLIBC_MINOR__ == 2 && defined(DT_CONFIG)))
 398
 399 /* We have the header files for a glibc that includes dl_iterate_phdr.  */
 400 /* It may still not be available in the library on the target system.   */
 401 /* Thus we also treat it as a weak symbol.                              */
 402 #define HAVE_DL_ITERATE_PHDR
 403 #pragma weak dl_iterate_phdr
 404 #endif
 405
 406 # if (defined(FREEBSD) && __FreeBSD__ >= 7)
 407 /* On the FreeBSD system, any target system at major version 7 shall    */
 408 /* have dl_iterate_phdr; therefore, we need not make it weak as above.  */
 409 #define HAVE_DL_ITERATE_PHDR
 410 #endif
 411
 412 #if defined(HAVE_DL_ITERATE_PHDR)
 413
 414 static int GC_register_dynlib_callback(info, size, ptr)
 415      struct dl_phdr_info * info;
 416      size_t size;
 417      void * ptr;
 418 {
 419   const ElfW(Phdr) * p;
 420   char * start;
 421   register int i;
 422
 423   /* Make sure struct dl_phdr_info is at least as big as we need.  */
 424   if (size < offsetof (struct dl_phdr_info, dlpi_phnum)
 425       + sizeof (info->dlpi_phnum))
 426     return -1;
 427
 428   p = info->dlpi_phdr;
 429   for( i = 0; i < (int)(info->dlpi_phnum); ((i++),(p++)) ) {
 430     switch( p->p_type ) {
 431       case PT_LOAD:
 432         {
 433           if( !(p->p_flags & PF_W) ) break;
 434           start = ((char *)(p->p_vaddr)) + info->dlpi_addr;
 435
 436           if (GC_has_static_roots
 437               && !GC_has_static_roots(info->dlpi_name, start, p->p_memsz))
 438             break;
 439
 440           GC_add_roots_inner(start, start + p->p_memsz, TRUE);
 441         }
 442       break;
 443       default:
 444         break;
 445     }
 446   }
 447
 448   * (int *)ptr = 1;     /* Signal that we were called */
 449   return 0;
 450 }
 451
 452 /* Return TRUE if we succeed, FALSE if dl_iterate_phdr wasn't there. */
 453
 454 GC_bool GC_register_dynamic_libraries_dl_iterate_phdr()
 455 {
 456   if (dl_iterate_phdr) {
 457     int did_something = 0;
 458     dl_iterate_phdr(GC_register_dynlib_callback, &did_something);
 459     if (!did_something) {
 460         /* dl_iterate_phdr may forget the static data segment in        */
 461         /* statically linked executables.                               */
 462         GC_add_roots_inner(DATASTART, (char *)(DATAEND), TRUE);
 463 #       if defined(DATASTART2)
 464           GC_add_roots_inner(DATASTART2, (char *)(DATAEND2), TRUE);
 465 #       endif
 466     }
 467
 468     return TRUE;
 469   } else {
 470     return FALSE;
 471   }
 472 }
 473
 474 /* Do we need to separately register the main static data segment? */
 475 GC_bool GC_register_main_static_data()
 476 {
 477   return (dl_iterate_phdr == 0);
 478 }
 479
 480 #define HAVE_REGISTER_MAIN_STATIC_DATA
 481
 482 # else /* !LINUX || version(glibc) < 2.2.4 */
 483
 484 /* Dynamic loading code for Linux running ELF. Somewhat tested on
 485  * Linux/x86, untested but hopefully should work on Linux/Alpha.
 486  * This code was derived from the Solaris/ELF support. Thanks to
 487  * whatever kind soul wrote that.  - Patrick Bridges */
 488
 489 /* This doesn't necessarily work in all cases, e.g. with preloaded
 490  * dynamic libraries.                                           */
 491
 492 #if defined(NETBSD)
 493 #  include <sys/exec_elf.h>
 494 /* for compatibility with 1.4.x */
 495 #  ifndef DT_DEBUG
 496 #  define DT_DEBUG     21
 497 #  endif
 498 #  ifndef PT_LOAD
 499 #  define PT_LOAD      1
 500 #  endif
 501 #  ifndef PF_W
 502 #  define PF_W         2
 503 #  endif
 504 #else
 505 #  include <elf.h>
 506 #endif
 507 #include <link.h>
 508
 509 # endif
 510
 511 #ifdef __GNUC__
 512 # pragma weak _DYNAMIC
 513 #endif
 514 extern ElfW(Dyn) _DYNAMIC[];
 515
 516 static struct link_map *
 517 GC_FirstDLOpenedLinkMap()
 518 {
 519     ElfW(Dyn) *dp;
 520     static struct link_map *cachedResult = 0;
 521
 522     if( _DYNAMIC == 0) {
 523         return(0);
 524     }
 525     if( cachedResult == 0 ) {
 526         int tag;
 527         for( dp = _DYNAMIC; (tag = dp->d_tag) != 0; dp++ ) {
 528             /* FIXME: The DT_DEBUG header is not mandated by the        */
 529             /* ELF spec.  This code appears to be dependent on          */
 530             /* idiosynchracies of older GNU tool chains.  If this code  */
 531             /* fails for you, the real problem is probably that it is   */
 532             /* being used at all.  You should be getting the            */
 533             /* dl_iterate_phdr version.                                 */
 534             if( tag == DT_DEBUG ) {
 535                 struct link_map *lm
 536                         = ((struct r_debug *)(dp->d_un.d_ptr))->r_map;
 537                 if( lm != 0 ) cachedResult = lm->l_next; /* might be NIL */
 538                 break;
 539             }
 540         }
 541     }
 542     return cachedResult;
 543 }
 544
 545
 546 void GC_register_dynamic_libraries()
 547 {
 548   struct link_map *lm;
 549
 550
 551 # ifdef HAVE_DL_ITERATE_PHDR
 552     if (GC_register_dynamic_libraries_dl_iterate_phdr()) {
 553         return;
 554     }
 555 # endif
 556   lm = GC_FirstDLOpenedLinkMap();
 557   for (lm = GC_FirstDLOpenedLinkMap();
 558        lm != (struct link_map *) 0;  lm = lm->l_next)
 559     {
 560         ElfW(Ehdr) * e;
 561         ElfW(Phdr) * p;
 562         unsigned long offset;
 563         char * start;
 564         register int i;
 565
 566         e = (ElfW(Ehdr) *) lm->l_addr;
 567         p = ((ElfW(Phdr) *)(((char *)(e)) + e->e_phoff));
 568         offset = ((unsigned long)(lm->l_addr));
 569         for( i = 0; i < (int)(e->e_phnum); ((i++),(p++)) ) {
 570           switch( p->p_type ) {
 571             case PT_LOAD:
 572               {
 573                 if( !(p->p_flags & PF_W) ) break;
 574                 start = ((char *)(p->p_vaddr)) + offset;
 575                 GC_add_roots_inner(start, start + p->p_memsz, TRUE);
 576               }
 577               break;
 578             default:
 579               break;
 580           }
 581         }
 582     }
 583 }
 584
 585 #endif /* !USE_PROC_FOR_LIBRARIES */
 586
 587 #endif /* LINUX */
 588
 589 #if defined(IRIX5) || (defined(USE_PROC_FOR_LIBRARIES) && !defined(LINUX))
 590
 591 #include <sys/procfs.h>
 592 #include <sys/stat.h>
 593 #include <fcntl.h>
 594 #include <elf.h>
 595 #include <errno.h>
 596 #include <signal.h>  /* Only for the following test. */
 597 #ifndef _sigargs
 598 # define IRIX6
 599 #endif
 600
 601 extern void * GC_roots_present();
 602         /* The type is a lie, since the real type doesn't make sense here, */
 603         /* and we only test for NULL.                                      */
 604
 605
 606 /* We use /proc to track down all parts of the address space that are   */
 607 /* mapped by the process, and throw out regions we know we shouldn't    */
 608 /* worry about.  This may also work under other SVR4 variants.          */
 609 void GC_register_dynamic_libraries()
 610 {
 611     static int fd = -1;
 612     char buf[30];
 613     static prmap_t * addr_map = 0;
 614     static int current_sz = 0;  /* Number of records currently in addr_map */
 615     static int needed_sz;       /* Required size of addr_map            */
 616     register int i;
 617     register long flags;
 618     register ptr_t start;
 619     register ptr_t limit;
 620     ptr_t heap_start = (ptr_t)HEAP_START;
 621     ptr_t heap_end = heap_start;
 622
 623 #   ifdef SUNOS5DL
 624 #     define MA_PHYS 0
 625 #   endif /* SUNOS5DL */
 626
 627     if (fd < 0) {
 628       sprintf(buf, "/proc/%d", getpid());
 629         /* The above generates a lint complaint, since pid_t varies.    */
 630         /* It's unclear how to improve this.                            */
 631       fd = open(buf, O_RDONLY);
 632       if (fd < 0) {
 633         ABORT("/proc open failed");
 634       }
 635     }
 636     if (ioctl(fd, PIOCNMAP, &needed_sz) < 0) {
 637         GC_err_printf2("fd = %d, errno = %d\n", fd, errno);
 638         ABORT("/proc PIOCNMAP ioctl failed");
 639     }
 640     if (needed_sz >= current_sz) {
 641         current_sz = needed_sz * 2 + 1;
 642                         /* Expansion, plus room for 0 record */
 643         addr_map = (prmap_t *)GC_scratch_alloc((word)
 644                                                 (current_sz * sizeof(prmap_t)));
 645     }
 646     if (ioctl(fd, PIOCMAP, addr_map) < 0) {
 647         GC_err_printf4("fd = %d, errno = %d, needed_sz = %d, addr_map = 0x%X\n",
 648                         fd, errno, needed_sz, addr_map);
 649         ABORT("/proc PIOCMAP ioctl failed");
 650     };
 651     if (GC_n_heap_sects > 0) {
 652         heap_end = GC_heap_sects[GC_n_heap_sects-1].hs_start
 653                         + GC_heap_sects[GC_n_heap_sects-1].hs_bytes;
 654         if (heap_end < GC_scratch_last_end_ptr) heap_end = GC_scratch_last_end_ptr;
 655     }
 656     for (i = 0; i < needed_sz; i++) {
 657         flags = addr_map[i].pr_mflags;
 658         if ((flags & (MA_BREAK | MA_STACK | MA_PHYS
 659                       | MA_FETCHOP | MA_NOTCACHED)) != 0) goto irrelevant;
 660         if ((flags & (MA_READ | MA_WRITE)) != (MA_READ | MA_WRITE))
 661             goto irrelevant;
 662           /* The latter test is empirically useless in very old Irix    */
 663           /* versions.  Other than the                                  */
 664           /* main data and stack segments, everything appears to be     */
 665           /* mapped readable, writable, executable, and shared(!!).     */
 666           /* This makes no sense to me. - HB                            */
 667         start = (ptr_t)(addr_map[i].pr_vaddr);
 668         if (GC_roots_present(start)) goto irrelevant;
 669         if (start < heap_end && start >= heap_start)
 670                 goto irrelevant;
 671 #       ifdef MMAP_STACKS
 672           if (GC_is_thread_stack(start)) goto irrelevant;
 673 #       endif /* MMAP_STACKS */
 674
 675         limit = start + addr_map[i].pr_size;
 676         /* The following seemed to be necessary for very old versions   */
 677         /* of Irix, but it has been reported to discard relevant        */
 678         /* segments under Irix 6.5.                                     */
 679 #       ifndef IRIX6
 680           if (addr_map[i].pr_off == 0 && strncmp(start, ELFMAG, 4) == 0) {
 681             /* Discard text segments, i.e. 0-offset mappings against    */
 682             /* executable files which appear to have ELF headers.       */
 683             caddr_t arg;
 684             int obj;
 685 #           define MAP_IRR_SZ 10
 686             static ptr_t map_irr[MAP_IRR_SZ];
 687                                         /* Known irrelevant map entries */
 688             static int n_irr = 0;
 689             struct stat buf;
 690             register int i;
 691
 692             for (i = 0; i < n_irr; i++) {
 693                 if (map_irr[i] == start) goto irrelevant;
 694             }
 695             arg = (caddr_t)start;
 696             obj = ioctl(fd, PIOCOPENM, &arg);
 697             if (obj >= 0) {
 698                 fstat(obj, &buf);
 699                 close(obj);
 700                 if ((buf.st_mode & 0111) != 0) {
 701                     if (n_irr < MAP_IRR_SZ) {
 702                         map_irr[n_irr++] = start;
 703                     }
 704                     goto irrelevant;
 705                 }
 706             }
 707           }
 708 #       endif /* !IRIX6 */
 709         GC_add_roots_inner(start, limit, TRUE);
 710       irrelevant: ;
 711     }
 712     /* Dont keep cached descriptor, for now.  Some kernels don't like us */
 713     /* to keep a /proc file descriptor around during kill -9.            */
 714         if (close(fd) < 0) ABORT("Couldnt close /proc file");
 715         fd = -1;
 716 }
 717
 718 # endif /* USE_PROC || IRIX5 */
 719
 720 # if defined(MSWIN32) || defined(MSWINCE)
 721
 722 # define WIN32_LEAN_AND_MEAN
 723 # define NOSERVICE
 724 # include <windows.h>
 725 # include <stdlib.h>
 726
 727   /* We traverse the entire address space and register all segments     */
 728   /* that could possibly have been written to.                          */
 729
 730   extern GC_bool GC_is_heap_base (ptr_t p);
 731
 732 # ifdef GC_WIN32_THREADS
 733     extern void GC_get_next_stack(char *start, char **lo, char **hi);
 734     void GC_cond_add_roots(char *base, char * limit)
 735     {
 736       char * curr_base = base;
 737       char * next_stack_lo;
 738       char * next_stack_hi;
 739
 740       if (base == limit) return;
 741       for(;;) {
 742           GC_get_next_stack(curr_base, &next_stack_lo, &next_stack_hi);
 743           if (next_stack_lo >= limit) break;
 744           GC_add_roots_inner(curr_base, next_stack_lo, TRUE);
 745           curr_base = next_stack_hi;
 746       }
 747       if (curr_base < limit) GC_add_roots_inner(curr_base, limit, TRUE);
 748     }
 749 # else
 750     void GC_cond_add_roots(char *base, char * limit)
 751     {
 752       char dummy;
 753       char * stack_top
 754          = (char *) ((word)(&dummy) & ~(GC_sysinfo.dwAllocationGranularity-1));
 755       if (base == limit) return;
 756       if (limit > stack_top && base < GC_stackbottom) {
 757           /* Part of the stack; ignore it. */
 758           return;
 759       }
 760       GC_add_roots_inner(base, limit, TRUE);
 761     }
 762 # endif
 763
 764 # ifdef MSWINCE
 765   /* Do we need to separately register the main static data segment? */
 766   GC_bool GC_register_main_static_data()
 767   {
 768     return FALSE;
 769   }
 770 # else /* win32 */
 771   extern GC_bool GC_no_win32_dlls;
 772
 773   GC_bool GC_register_main_static_data()
 774   {
 775     return GC_no_win32_dlls;
 776   }
 777 # endif /* win32 */
 778
 779 # define HAVE_REGISTER_MAIN_STATIC_DATA
 780
 781   /* The frame buffer testing code is dead in this version.     */
 782   /* We leave it here temporarily in case the switch to just    */
 783   /* testing for MEM_IMAGE sections causes un expected          */
 784   /* problems.                                                  */
 785   GC_bool GC_warn_fb = TRUE;    /* Warn about traced likely     */
 786                                 /* graphics memory.             */
 787   GC_bool GC_disallow_ignore_fb = FALSE;
 788   int GC_ignore_fb_mb;  /* Ignore mappings bigger than the      */
 789                         /* specified number of MB.              */
 790   GC_bool GC_ignore_fb = FALSE; /* Enable frame buffer  */
 791                                 /* checking.            */
 792
 793   /* Issue warning if tracing apparent framebuffer.             */
 794   /* This limits us to one warning, and it's a back door to     */
 795   /* disable that.                                              */
 796
 797   /* Should [start, start+len) be treated as a frame buffer     */
 798   /* and ignored?                                               */
 799   /* Unfortunately, we currently are not quite sure how to tell */
 800   /* this automatically, and rely largely on user input.        */
 801   /* We expect that any mapping with type MEM_MAPPED (which     */
 802   /* apparently excludes library data sections) can be safely   */
 803   /* ignored.  But we're too chicken to do that in this         */
 804   /* version.                                                   */
 805   /* Based on a very limited sample, it appears that:           */
 806   /*    - Frame buffer mappings appear as mappings of large     */
 807   /*      length, usually a bit less than a power of two.       */
 808   /*    - The definition of "a bit less" in the above cannot    */
 809   /*      be made more precise.                                 */
 810   /*    - Have a starting address at best 64K aligned.          */
 811   /*    - Have type == MEM_MAPPED.                              */
 812   static GC_bool is_frame_buffer(ptr_t start, size_t len, DWORD tp)
 813   {
 814     static GC_bool initialized = FALSE;
 815 #   define MB (1024*1024)
 816 #   define DEFAULT_FB_MB 15
 817 #   define MIN_FB_MB 3
 818
 819     if (GC_disallow_ignore_fb || tp != MEM_MAPPED) return FALSE;
 820     if (!initialized) {
 821       char * ignore_fb_string =  GETENV("GC_IGNORE_FB");
 822
 823       if (0 != ignore_fb_string) {
 824         while (*ignore_fb_string == ' ' || *ignore_fb_string == '\t')
 825           ++ignore_fb_string;
 826         if (*ignore_fb_string == '\0') {
 827           GC_ignore_fb_mb = DEFAULT_FB_MB;
 828         } else {
 829           GC_ignore_fb_mb = atoi(ignore_fb_string);
 830           if (GC_ignore_fb_mb < MIN_FB_MB) {
 831             WARN("Bad GC_IGNORE_FB value.  Using %ld\n", DEFAULT_FB_MB);
 832             GC_ignore_fb_mb = DEFAULT_FB_MB;
 833           }
 834         }
 835         GC_ignore_fb = TRUE;
 836       } else {
 837         GC_ignore_fb_mb = DEFAULT_FB_MB;  /* For warning */
 838       }
 839       initialized = TRUE;
 840     }
 841     if (len >= ((size_t)GC_ignore_fb_mb << 20)) {
 842       if (GC_ignore_fb) {
 843         return TRUE;
 844       } else {
 845         if (GC_warn_fb) {
 846           WARN("Possible frame buffer mapping at 0x%lx: \n"
 847                "\tConsider setting GC_IGNORE_FB to improve performance.\n",
 848                start);
 849           GC_warn_fb = FALSE;
 850         }
 851         return FALSE;
 852       }
 853     } else {
 854       return FALSE;
 855     }
 856   }
 857
 858 # ifdef DEBUG_VIRTUALQUERY
 859   void GC_dump_meminfo(MEMORY_BASIC_INFORMATION *buf)
 860   {
 861     GC_printf4("BaseAddress = %lx, AllocationBase = %lx, RegionSize = %lx(%lu)\n",
 862                buf -> BaseAddress, buf -> AllocationBase, buf -> RegionSize,
 863                buf -> RegionSize);
 864     GC_printf4("\tAllocationProtect = %lx, State = %lx, Protect = %lx, "
 865                "Type = %lx\n",
 866                buf -> AllocationProtect, buf -> State, buf -> Protect,
 867                buf -> Type);
 868   }
 869 # endif /* DEBUG_VIRTUALQUERY */
 870
 871   extern GC_bool GC_wnt;  /* Is Windows NT derivative.          */
 872                           /* Defined and set in os_dep.c.       */
 873
 874   void GC_register_dynamic_libraries()
 875   {
 876     MEMORY_BASIC_INFORMATION buf;
 877     DWORD result;
 878     DWORD protect;
 879     LPVOID p;
 880     char * base;
 881     char * limit, * new_limit;
 882
 883 #   ifdef MSWIN32
 884       if (GC_no_win32_dlls) return;
 885 #   endif
 886     base = limit = p = GC_sysinfo.lpMinimumApplicationAddress;
 887 #   if defined(MSWINCE) && !defined(_WIN32_WCE_EMULATION)
 888     /* Only the first 32 MB of address space belongs to the current process */
 889     while (p < (LPVOID)0x02000000) {
 890         result = VirtualQuery(p, &buf, sizeof(buf));
 891         if (result == 0) {
 892             /* Page is free; advance to the next possible allocation base */
 893             new_limit = (char *)
 894                 (((DWORD) p + GC_sysinfo.dwAllocationGranularity)
 895                  & ~(GC_sysinfo.dwAllocationGranularity-1));
 896         } else
 897 #   else
 898     while (p < GC_sysinfo.lpMaximumApplicationAddress) {
 899         result = VirtualQuery(p, &buf, sizeof(buf));
 900 #   endif
 901         {
 902             if (result != sizeof(buf)) {
 903                 ABORT("Weird VirtualQuery result");
 904             }
 905             new_limit = (char *)p + buf.RegionSize;
 906             protect = buf.Protect;
 907             if (buf.State == MEM_COMMIT
 908                 && (protect == PAGE_EXECUTE_READWRITE
 909                     || protect == PAGE_READWRITE)
 910                 && !GC_is_heap_base(buf.AllocationBase)
 911                 /* This used to check for
 912                  * !is_frame_buffer(p, buf.RegionSize, buf.Type)
 913                  * instead of just checking for MEM_IMAGE.
 914                  * If something breaks, change it back. */
 915                 /* There is some evidence that we cannot always
 916                  * ignore MEM_PRIVATE sections under Windows ME
 917                  * and predecessors.  Hence we now also check for
 918                  * that case.   */
 919                 && (buf.Type == MEM_IMAGE ||
 920                     !GC_wnt && buf.Type == MEM_PRIVATE)) {
 921 #               ifdef DEBUG_VIRTUALQUERY
 922                   GC_dump_meminfo(&buf);
 923 #               endif
 924                 if ((char *)p != limit) {
 925                     GC_cond_add_roots(base, limit);
 926                     base = p;
 927                 }
 928                 limit = new_limit;
 929             }
 930         }
 931         if (p > (LPVOID)new_limit /* overflow */) break;
 932         p = (LPVOID)new_limit;
 933     }
 934     GC_cond_add_roots(base, limit);
 935   }
 936
 937 #endif /* MSWIN32 || MSWINCE */
 938
 939 #if defined(ALPHA) && defined(OSF1)
 940
 941 #include <loader.h>
 942
 943 void GC_register_dynamic_libraries()
 944 {
 945   int status;
 946   ldr_process_t mypid;
 947
 948   /* module */
 949     ldr_module_t moduleid = LDR_NULL_MODULE;
 950     ldr_module_info_t moduleinfo;
 951     size_t moduleinfosize = sizeof(moduleinfo);
 952     size_t modulereturnsize;
 953
 954   /* region */
 955     ldr_region_t region;
 956     ldr_region_info_t regioninfo;
 957     size_t regioninfosize = sizeof(regioninfo);
 958     size_t regionreturnsize;
 959
 960   /* Obtain id of this process */
 961     mypid = ldr_my_process();
 962
 963   /* For each module */
 964     while (TRUE) {
 965
 966       /* Get the next (first) module */
 967         status = ldr_next_module(mypid, &moduleid);
 968
 969       /* Any more modules? */
 970         if (moduleid == LDR_NULL_MODULE)
 971             break;    /* No more modules */
 972
 973       /* Check status AFTER checking moduleid because */
 974       /* of a bug in the non-shared ldr_next_module stub */
 975         if (status != 0 ) {
 976             GC_printf1("dynamic_load: status = %ld\n", (long)status);
 977             {
 978                 extern char *sys_errlist[];
 979                 extern int sys_nerr;
 980                 extern int errno;
 981                 if (errno <= sys_nerr) {
 982                     GC_printf1("dynamic_load: %s\n", (long)sys_errlist[errno]);
 983                } else {
 984                     GC_printf1("dynamic_load: %d\n", (long)errno);
 985                 }
 986         }
 987             ABORT("ldr_next_module failed");
 988          }
 989
 990       /* Get the module information */
 991         status = ldr_inq_module(mypid, moduleid, &moduleinfo,
 992                                 moduleinfosize, &modulereturnsize);
 993         if (status != 0 )
 994             ABORT("ldr_inq_module failed");
 995
 996       /* is module for the main program (i.e. nonshared portion)? */
 997           if (moduleinfo.lmi_flags & LDR_MAIN)
 998               continue;    /* skip the main module */
 999
1000 #     ifdef VERBOSE
1001           GC_printf("---Module---\n");
1002           GC_printf("Module ID            = %16ld\n", moduleinfo.lmi_modid);
1003           GC_printf("Count of regions     = %16d\n", moduleinfo.lmi_nregion);
1004           GC_printf("flags for module     = %16lx\n", moduleinfo.lmi_flags);
1005           GC_printf("pathname of module   = \"%s\"\n", moduleinfo.lmi_name);
1006 #     endif
1007
1008       /* For each region in this module */
1009         for (region = 0; region < moduleinfo.lmi_nregion; region++) {
1010
1011           /* Get the region information */
1012             status = ldr_inq_region(mypid, moduleid, region, &regioninfo,
1013                                     regioninfosize, &regionreturnsize);
1014             if (status != 0 )
1015                 ABORT("ldr_inq_region failed");
1016
1017           /* only process writable (data) regions */
1018             if (! (regioninfo.lri_prot & LDR_W))
1019                 continue;
1020
1021 #         ifdef VERBOSE
1022               GC_printf("--- Region ---\n");
1023               GC_printf("Region number    = %16ld\n",
1024                         regioninfo.lri_region_no);
1025               GC_printf("Protection flags = %016x\n",  regioninfo.lri_prot);
1026               GC_printf("Virtual address  = %16p\n",   regioninfo.lri_vaddr);
1027               GC_printf("Mapped address   = %16p\n",   regioninfo.lri_mapaddr);
1028               GC_printf("Region size      = %16ld\n",  regioninfo.lri_size);
1029               GC_printf("Region name      = \"%s\"\n", regioninfo.lri_name);
1030 #         endif
1031
1032           /* register region as a garbage collection root */
1033             GC_add_roots_inner (
1034                 (char *)regioninfo.lri_mapaddr,
1035                 (char *)regioninfo.lri_mapaddr + regioninfo.lri_size,
1036                 TRUE);
1037
1038         }
1039     }
1040 }
1041 #endif
1042
1043 #if defined(HPUX)
1044
1045 #include <errno.h>
1046 #include <dl.h>
1047
1048 extern int errno;
1049 extern char *sys_errlist[];
1050 extern int sys_nerr;
1051
1052 void GC_register_dynamic_libraries()
1053 {
1054   int status;
1055   int index = 1; /* Ordinal position in shared library search list */
1056   struct shl_descriptor *shl_desc; /* Shared library info, see dl.h */
1057
1058   /* For each dynamic library loaded */
1059     while (TRUE) {
1060
1061       /* Get info about next shared library */
1062         status = shl_get(index, &shl_desc);
1063
1064       /* Check if this is the end of the list or if some error occured */
1065         if (status != 0) {
1066 #        ifdef GC_HPUX_THREADS
1067            /* I've seen errno values of 0.  The man page is not clear   */
1068            /* as to whether errno should get set on a -1 return.        */
1069            break;
1070 #        else
1071           if (errno == EINVAL) {
1072               break; /* Moved past end of shared library list --> finished */
1073           } else {
1074               if (errno <= sys_nerr) {
1075                     GC_printf1("dynamic_load: %s\n", (long) sys_errlist[errno]);
1076               } else {
1077                     GC_printf1("dynamic_load: %d\n", (long) errno);
1078               }
1079               ABORT("shl_get failed");
1080           }
1081 #        endif
1082         }
1083
1084 #     ifdef VERBOSE
1085           GC_printf0("---Shared library---\n");
1086           GC_printf1("\tfilename        = \"%s\"\n", shl_desc->filename);
1087           GC_printf1("\tindex           = %d\n", index);
1088           GC_printf1("\thandle          = %08x\n",
1089                                         (unsigned long) shl_desc->handle);
1090           GC_printf1("\ttext seg. start = %08x\n", shl_desc->tstart);
1091           GC_printf1("\ttext seg. end   = %08x\n", shl_desc->tend);
1092           GC_printf1("\tdata seg. start = %08x\n", shl_desc->dstart);
1093           GC_printf1("\tdata seg. end   = %08x\n", shl_desc->dend);
1094           GC_printf1("\tref. count      = %lu\n", shl_desc->ref_count);
1095 #     endif
1096
1097       /* register shared library's data segment as a garbage collection root */
1098         GC_add_roots_inner((char *) shl_desc->dstart,
1099                            (char *) shl_desc->dend, TRUE);
1100
1101         index++;
1102     }
1103 }
1104 #endif /* HPUX */
1105
1106 #ifdef RS6000
1107 #pragma alloca
1108 #include <sys/ldr.h>
1109 #include <sys/errno.h>
1110 void GC_register_dynamic_libraries()
1111 {
1112         int len;
1113         char *ldibuf;
1114         int ldibuflen;
1115         struct ld_info *ldi;
1116
1117         ldibuf = alloca(ldibuflen = 8192);
1118
1119         while ( (len = loadquery(L_GETINFO,ldibuf,ldibuflen)) < 0) {
1120                 if (errno != ENOMEM) {
1121                         ABORT("loadquery failed");
1122                 }
1123                 ldibuf = alloca(ldibuflen *= 2);
1124         }
1125
1126         ldi = (struct ld_info *)ldibuf;
1127         while (ldi) {
1128                 len = ldi->ldinfo_next;
1129                 GC_add_roots_inner(
1130                                 ldi->ldinfo_dataorg,
1131                                 (ptr_t)(unsigned long)ldi->ldinfo_dataorg
1132                                 + ldi->ldinfo_datasize,
1133                                 TRUE);
1134                 ldi = len ? (struct ld_info *)((char *)ldi + len) : 0;
1135         }
1136 }
1137 #endif /* RS6000 */
1138
1139 #ifdef DARWIN
1140
1141 /* __private_extern__ hack required for pre-3.4 gcc versions.   */
1142 #ifndef __private_extern__
1143 # define __private_extern__ extern
1144 # include <mach-o/dyld.h>
1145 # undef __private_extern__
1146 #else
1147 # include <mach-o/dyld.h>
1148 #endif
1149 #include <mach-o/getsect.h>
1150
1151 /*#define DARWIN_DEBUG*/
1152
1153 const static struct {
1154         const char *seg;
1155         const char *sect;
1156 } GC_dyld_sections[] = {
1157         { SEG_DATA, SECT_DATA },
1158         { SEG_DATA, SECT_BSS },
1159         { SEG_DATA, SECT_COMMON }
1160 };
1161
1162 #ifdef DARWIN_DEBUG
1163 static const char *GC_dyld_name_for_hdr(const struct GC_MACH_HEADER *hdr) {
1164     unsigned long i,c;
1165     c = _dyld_image_count();
1166     for(i=0;i<c;i++) if(_dyld_get_image_header(i) == hdr)
1167         return _dyld_get_image_name(i);
1168     return NULL;
1169 }
1170 #endif
1171
1172 /* This should never be called by a thread holding the lock */
1173 static void GC_dyld_image_add(const struct GC_MACH_HEADER *hdr, intptr_t slide)
1174 {
1175     unsigned long start,end,i;
1176     const struct GC_MACH_SECTION *sec;
1177     if (GC_no_dls) return;
1178     for(i=0;i<sizeof(GC_dyld_sections)/sizeof(GC_dyld_sections[0]);i++) {
1179
1180       sec = GC_GETSECTBYNAME (hdr, GC_dyld_sections[i].seg,
1181                               GC_dyld_sections[i].sect);
1182         if(sec == NULL || sec->size == 0) continue;
1183         start = slide + sec->addr;
1184         end = start + sec->size;
1185 #       ifdef DARWIN_DEBUG
1186             GC_printf4("Adding section at %p-%p (%lu bytes) from image %s\n",
1187                 start,end,sec->size,GC_dyld_name_for_hdr(hdr));
1188 #       endif
1189         GC_add_roots((char*)start,(char*)end);
1190     }
1191 #   ifdef DARWIN_DEBUG
1192         GC_print_static_roots();
1193 #   endif
1194 }
1195
1196 /* This should never be called by a thread holding the lock */
1197 static void GC_dyld_image_remove(const struct GC_MACH_HEADER *hdr,
1198                                  intptr_t slide) {
1199     unsigned long start,end,i;
1200     const struct GC_MACH_SECTION *sec;
1201     for(i=0;i<sizeof(GC_dyld_sections)/sizeof(GC_dyld_sections[0]);i++) {
1202       sec = GC_GETSECTBYNAME (hdr, GC_dyld_sections[i].seg,
1203                               GC_dyld_sections[i].sect);
1204         if(sec == NULL || sec->size == 0) continue;
1205         start = slide + sec->addr;
1206         end = start + sec->size;
1207 #       ifdef DARWIN_DEBUG
1208             GC_printf4("Removing section at %p-%p (%lu bytes) from image %s\n",
1209                 start,end,sec->size,GC_dyld_name_for_hdr(hdr));
1210 #               endif
1211         GC_remove_roots((char*)start,(char*)end);
1212     }
1213 #   ifdef DARWIN_DEBUG
1214         GC_print_static_roots();
1215 #   endif
1216 }
1217
1218 void GC_register_dynamic_libraries() {
1219     /* Currently does nothing. The callbacks are setup by GC_init_dyld()
1220     The dyld library takes it from there. */
1221 }
1222
1223 /* The _dyld_* functions have an internal lock so no _dyld functions
1224    can be called while the world is stopped without the risk of a deadlock.
1225    Because of this we MUST setup callbacks BEFORE we ever stop the world.
1226    This should be called BEFORE any thread in created and WITHOUT the
1227    allocation lock held. */
1228
1229 void GC_init_dyld() {
1230   static GC_bool initialized = FALSE;
1231   char *bind_fully_env = NULL;
1232
1233   if(initialized) return;
1234
1235 #   ifdef DARWIN_DEBUG
1236   GC_printf0("Registering dyld callbacks...\n");
1237 #   endif
1238
1239   /* Apple's Documentation:
1240      When you call _dyld_register_func_for_add_image, the dynamic linker runtime
1241      calls the specified callback (func) once for each of the images that is
1242      currently loaded into the program. When a new image is added to the program,
1243      your callback is called again with the mach_header for the new image, and the
1244      virtual memory slide amount of the new image.
1245
1246      This WILL properly register already linked libraries and libraries
1247      linked in the future
1248   */
1249
1250     _dyld_register_func_for_add_image(GC_dyld_image_add);
1251     _dyld_register_func_for_remove_image(GC_dyld_image_remove);
1252
1253     /* Set this early to avoid reentrancy issues. */
1254     initialized = TRUE;
1255
1256     bind_fully_env = getenv("DYLD_BIND_AT_LAUNCH");
1257
1258     if (bind_fully_env == NULL) {
1259 #   ifdef DARWIN_DEBUG
1260       GC_printf0("Forcing full bind of GC code...\n");
1261 #   endif
1262
1263       if(!_dyld_bind_fully_image_containing_address((unsigned long*)GC_malloc))
1264         GC_abort("_dyld_bind_fully_image_containing_address failed");
1265     }
1266
1267 }
1268
1269 #define HAVE_REGISTER_MAIN_STATIC_DATA
1270 GC_bool GC_register_main_static_data()
1271 {
1272   /* Already done through dyld callbacks */
1273   return FALSE;
1274 }
1275
1276 #endif /* DARWIN */
1277
1278 #else /* !DYNAMIC_LOADING */
1279
1280 #ifdef PCR
1281
1282 #   include "il/PCR_IL.h"
1283 #   include "th/PCR_ThCtl.h"
1284 #   include "mm/PCR_MM.h"
1285
1286 void GC_register_dynamic_libraries()
1287 {
1288     /* Add new static data areas of dynamically loaded modules. */
1289         {
1290           PCR_IL_LoadedFile * p = PCR_IL_GetLastLoadedFile();
1291           PCR_IL_LoadedSegment * q;
1292
1293           /* Skip uncommited files */
1294           while (p != NIL && !(p -> lf_commitPoint)) {
1295               /* The loading of this file has not yet been committed    */
1296               /* Hence its description could be inconsistent.           */
1297               /* Furthermore, it hasn't yet been run.  Hence its data   */
1298               /* segments can't possibly reference heap allocated       */
1299               /* objects.                                               */
1300               p = p -> lf_prev;
1301           }
1302           for (; p != NIL; p = p -> lf_prev) {
1303             for (q = p -> lf_ls; q != NIL; q = q -> ls_next) {
1304               if ((q -> ls_flags & PCR_IL_SegFlags_Traced_MASK)
1305                   == PCR_IL_SegFlags_Traced_on) {
1306                 GC_add_roots_inner
1307                         ((char *)(q -> ls_addr),
1308                          (char *)(q -> ls_addr) + q -> ls_bytes,
1309                          TRUE);
1310               }
1311             }
1312           }
1313         }
1314 }
1315
1316
1317 #else /* !PCR */
1318
1319 void GC_register_dynamic_libraries(){}
1320
1321 int GC_no_dynamic_loading;
1322
1323 #endif /* !PCR */
1324
1325 #endif /* !DYNAMIC_LOADING */
1326
1327 #ifndef HAVE_REGISTER_MAIN_STATIC_DATA
1328
1329 /* Do we need to separately register the main static data segment? */
1330 GC_bool GC_register_main_static_data()
1331 {
1332   return TRUE;
1333 }
1334 #endif /* HAVE_REGISTER_MAIN_STATIC_DATA */
1335