OSDN Git Service

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