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