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