PR c++/14032
[official-gcc.git] / boehm-gc / dyn_load.c
blob27c1b07387aa6c149147050578b901c1128765f0
1 /*
2 * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
3 * Copyright (c) 1997 by Silicon Graphics. All rights reserved.
5 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
6 * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
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.
14 * Original author: Bill Janssen
15 * Heavily modified by Hans Boehm and others
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 ...
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.
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"
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
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
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
83 #if defined(NETBSD)
84 # include <machine/elf_machdep.h>
85 # define ELFSIZE ARCH_ELFSIZE
86 #endif
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
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
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))
130 GC_has_static_roots = callback;
133 #if defined(SUNOS5DL) && !defined(USE_PROC_FOR_LIBRARIES)
135 #ifdef LINT
136 Elf32_Dyn _DYNAMIC;
137 #endif
139 static struct link_map *
140 GC_FirstDLOpenedLinkMap()
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 */
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");
158 # else
159 dynStructureAddr = &_DYNAMIC;
160 # endif
162 if( dynStructureAddr == 0) {
163 return(0);
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;
176 return cachedResult;
179 #endif /* SUNOS5DL ... */
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
186 #if defined(SUNOS4) && !defined(USE_PROC_FOR_LIBRARIES)
188 #ifdef LINT
189 struct link_dynamic _DYNAMIC;
190 #endif
192 static struct link_map *
193 GC_FirstDLOpenedLinkMap()
195 extern struct link_dynamic _DYNAMIC;
197 if( &_DYNAMIC == 0) {
198 return(0);
200 return(_DYNAMIC.ld_un.ld_1->ld_loaded);
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()
207 ptr_t result = 0;
208 extern struct link_dynamic _DYNAMIC;
209 struct rtc_symb * curr_symbol;
211 if( &_DYNAMIC == 0) {
212 return(0);
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);
221 return(result);
224 #endif /* SUNOS4 ... */
226 # if defined(SUNOS4) || defined(SUNOS5DL)
227 /* Add dynamic library data sections to the root set. */
228 # if !defined(PCR) && !defined(GC_SOLARIS_PTHREADS) && defined(THREADS)
229 # ifndef SRC_M3
230 --> fix mutual exclusion with dlopen
231 # endif /* We assume M3 programs don't call dlopen for now */
232 # endif
234 # ifndef USE_PROC_FOR_LIBRARIES
235 void GC_register_dynamic_libraries()
237 struct link_map *lm = GC_FirstDLOpenedLinkMap();
240 for (lm = GC_FirstDLOpenedLinkMap();
241 lm != (struct link_map *) 0; lm = lm->l_next)
243 # ifdef SUNOS4
244 struct exec *e;
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;
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:
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
274 break;
275 default:
276 break;
279 # endif
281 # ifdef SUNOS4
283 static ptr_t common_start = 0;
284 ptr_t common_end;
285 extern ptr_t GC_find_limit();
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);
293 # endif
296 # endif /* !USE_PROC ... */
297 # endif /* SUNOS */
299 #if defined(LINUX) && defined(__ELF__) || defined(SCO_ELF) || \
300 (defined(FREEBSD) && defined(__ELF__)) || defined(DGUX) || \
301 (defined(NETBSD) && defined(__ELF__)) || defined(HURD)
304 #ifdef USE_PROC_FOR_LIBRARIES
306 #include <string.h>
308 #include <sys/stat.h>
309 #include <fcntl.h>
310 #include <unistd.h>
312 #define MAPS_BUF_SIZE (32*1024)
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. */
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 */
323 word GC_register_map_entries(char *maps)
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);
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;
343 if (greatest_ha < (word)GC_scratch_last_end_ptr)
344 greatest_ha = (word)GC_scratch_last_end_ptr;
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;
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;
364 if (start < greatest_ha && end > greatest_ha) {
365 start = greatest_ha;
367 if (start >= least_ha && end <= greatest_ha) continue;
368 GC_add_roots_inner((char *)start, (char *)end, TRUE);
371 return 1;
374 void GC_register_dynamic_libraries()
376 if (!GC_apply_to_maps(GC_register_map_entries))
377 ABORT("Failed to read /proc for library registration.");
380 /* We now take care of the main data segment ourselves: */
381 GC_bool GC_register_main_static_data()
383 return FALSE;
386 # define HAVE_REGISTER_MAIN_STATIC_DATA
388 #endif /* USE_PROC_FOR_LIBRARIES */
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. */
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)))
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
404 static int GC_register_dynlib_callback(info, size, ptr)
405 struct dl_phdr_info * info;
406 size_t size;
407 void * ptr;
409 const ElfW(Phdr) * p;
410 char * start;
411 register int i;
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;
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:
423 if( !(p->p_flags & PF_W) ) break;
424 start = ((char *)(p->p_vaddr)) + info->dlpi_addr;
426 if (GC_has_static_roots
427 && !GC_has_static_roots(info->dlpi_name, start, p->p_memsz))
428 break;
430 GC_add_roots_inner(start, start + p->p_memsz, TRUE);
432 break;
433 default:
434 break;
438 * (int *)ptr = 1; /* Signal that we were called */
439 return 0;
442 /* Return TRUE if we succeed, FALSE if dl_iterate_phdr wasn't there. */
444 #pragma weak dl_iterate_phdr
446 GC_bool GC_register_dynamic_libraries_dl_iterate_phdr()
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
460 return TRUE;
461 } else {
462 return FALSE;
466 /* Do we need to separately register the main static data segment? */
467 GC_bool GC_register_main_static_data()
469 return (dl_iterate_phdr == 0);
472 #define HAVE_REGISTER_MAIN_STATIC_DATA
474 # else /* !LINUX || version(glibc) < 2.2.4 */
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 */
481 /* This doesn't necessarily work in all cases, e.g. with preloaded
482 * dynamic libraries. */
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>
501 # endif
503 #ifdef __GNUC__
504 # pragma weak _DYNAMIC
505 #endif
506 extern ElfW(Dyn) _DYNAMIC[];
508 static struct link_map *
509 GC_FirstDLOpenedLinkMap()
511 ElfW(Dyn) *dp;
512 static struct link_map *cachedResult = 0;
514 if( _DYNAMIC == 0) {
515 return(0);
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;
534 return cachedResult;
538 void GC_register_dynamic_libraries()
540 struct link_map *lm;
543 # ifdef HAVE_DL_ITERATE_PHDR
544 if (GC_register_dynamic_libraries_dl_iterate_phdr()) {
545 return;
547 # endif
548 lm = GC_FirstDLOpenedLinkMap();
549 for (lm = GC_FirstDLOpenedLinkMap();
550 lm != (struct link_map *) 0; lm = lm->l_next)
552 ElfW(Ehdr) * e;
553 ElfW(Phdr) * p;
554 unsigned long offset;
555 char * start;
556 register int i;
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:
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);
569 break;
570 default:
571 break;
577 #endif /* !USE_PROC_FOR_LIBRARIES */
579 #endif /* LINUX */
581 #if defined(IRIX5) || (defined(USE_PROC_FOR_LIBRARIES) && !defined(LINUX))
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
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. */
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()
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;
615 # ifdef SUNOS5DL
616 # define MA_PHYS 0
617 # endif /* SUNOS5DL */
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");
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");
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)));
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");
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;
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 */
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;
684 for (i = 0; i < n_irr; i++) {
685 if (map_irr[i] == start) goto irrelevant;
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;
696 goto irrelevant;
700 # endif /* !IRIX6 */
701 GC_add_roots_inner(start, limit, TRUE);
702 irrelevant: ;
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;
710 # endif /* USE_PROC || IRIX5 */
712 # if defined(MSWIN32) || defined(MSWINCE)
714 # define WIN32_LEAN_AND_MEAN
715 # define NOSERVICE
716 # include <windows.h>
717 # include <stdlib.h>
719 /* We traverse the entire address space and register all segments */
720 /* that could possibly have been written to. */
722 extern GC_bool GC_is_heap_base (ptr_t p);
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)
728 char * curr_base = base;
729 char * next_stack_lo;
730 char * next_stack_hi;
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;
739 if (curr_base < limit) GC_add_roots_inner(curr_base, limit, TRUE);
741 # else
742 void GC_cond_add_roots(char *base, char * limit)
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;
752 GC_add_roots_inner(base, limit, TRUE);
754 # endif
756 # ifdef MSWINCE
757 /* Do we need to separately register the main static data segment? */
758 GC_bool GC_register_main_static_data()
760 return FALSE;
762 # else /* win32 */
763 extern GC_bool GC_no_win32_dlls;
765 GC_bool GC_register_main_static_data()
767 return GC_no_win32_dlls;
769 # endif /* win32 */
771 # define HAVE_REGISTER_MAIN_STATIC_DATA
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. */
785 /* Issue warning if tracing apparent framebuffer. */
786 /* This limits us to one warning, and it's a back door to */
787 /* disable that. */
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)
806 static GC_bool initialized = FALSE;
807 # define MB (1024*1024)
808 # define DEFAULT_FB_MB 15
809 # define MIN_FB_MB 3
811 if (GC_disallow_ignore_fb || tp != MEM_MAPPED) return FALSE;
812 if (!initialized) {
813 char * ignore_fb_string = GETENV("GC_IGNORE_FB");
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;
827 GC_ignore_fb = TRUE;
828 } else {
829 GC_ignore_fb_mb = DEFAULT_FB_MB; /* For warning */
831 initialized = TRUE;
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;
843 return FALSE;
845 } else {
846 return FALSE;
850 # ifdef DEBUG_VIRTUALQUERY
851 void GC_dump_meminfo(MEMORY_BASIC_INFORMATION *buf)
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);
861 # endif /* DEBUG_VIRTUALQUERY */
863 extern GC_bool GC_wnt; /* Is Windows NT derivative. */
864 /* Defined and set in os_dep.c. */
866 void GC_register_dynamic_libraries()
868 MEMORY_BASIC_INFORMATION buf;
869 DWORD result;
870 DWORD protect;
871 LPVOID p;
872 char * base;
873 char * limit, * new_limit;
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
894 if (result != sizeof(buf)) {
895 ABORT("Weird VirtualQuery result");
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;
920 limit = new_limit;
923 if (p > (LPVOID)new_limit /* overflow */) break;
924 p = (LPVOID)new_limit;
926 GC_cond_add_roots(base, limit);
929 #endif /* MSWIN32 || MSWINCE */
931 #if defined(ALPHA) && defined(OSF1)
933 #include <loader.h>
935 void GC_register_dynamic_libraries()
937 int status;
938 ldr_process_t mypid;
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;
946 /* region */
947 ldr_region_t region;
948 ldr_region_info_t regioninfo;
949 size_t regioninfosize = sizeof(regioninfo);
950 size_t regionreturnsize;
952 /* Obtain id of this process */
953 mypid = ldr_my_process();
955 /* For each module */
956 while (TRUE) {
958 /* Get the next (first) module */
959 status = ldr_next_module(mypid, &moduleid);
961 /* Any more modules? */
962 if (moduleid == LDR_NULL_MODULE)
963 break; /* No more modules */
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);
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);
979 ABORT("ldr_next_module failed");
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");
988 /* is module for the main program (i.e. nonshared portion)? */
989 if (moduleinfo.lmi_flags & LDR_MAIN)
990 continue; /* skip the main module */
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
1000 /* For each region in this module */
1001 for (region = 0; region < moduleinfo.lmi_nregion; region++) {
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");
1009 /* only process writable (data) regions */
1010 if (! (regioninfo.lri_prot & LDR_W))
1011 continue;
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
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);
1033 #endif
1035 #if defined(HPUX)
1037 #include <errno.h>
1038 #include <dl.h>
1040 extern int errno;
1041 extern char *sys_errlist[];
1042 extern int sys_nerr;
1044 void GC_register_dynamic_libraries()
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 */
1050 /* For each dynamic library loaded */
1051 while (TRUE) {
1053 /* Get info about next shared library */
1054 status = shl_get(index, &shl_desc);
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);
1071 ABORT("shl_get failed");
1073 # endif
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
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);
1093 index++;
1096 #endif /* HPUX */
1098 #ifdef RS6000
1099 #pragma alloca
1100 #include <sys/ldr.h>
1101 #include <sys/errno.h>
1102 void GC_register_dynamic_libraries()
1104 int len;
1105 char *ldibuf;
1106 int ldibuflen;
1107 struct ld_info *ldi;
1109 ldibuf = alloca(ldibuflen = 8192);
1111 while ( (len = loadquery(L_GETINFO,ldibuf,ldibuflen)) < 0) {
1112 if (errno != ENOMEM) {
1113 ABORT("loadquery failed");
1115 ldibuf = alloca(ldibuflen *= 2);
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;
1129 #endif /* RS6000 */
1131 #ifdef DARWIN
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>
1143 /*#define DARWIN_DEBUG*/
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 }
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;
1162 #endif
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)
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);
1186 # ifdef DARWIN_DEBUG
1187 GC_print_static_roots();
1188 # endif
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);
1212 # ifdef DARWIN_DEBUG
1213 GC_print_static_roots();
1214 # endif
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. */
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. */
1228 void GC_init_dyld() {
1229 static GC_bool initialized = FALSE;
1230 char *bind_fully_env = NULL;
1232 if(initialized) return;
1234 # ifdef DARWIN_DEBUG
1235 GC_printf0("Registering dyld callbacks...\n");
1236 # endif
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.
1245 This WILL properly register already linked libraries and libraries
1246 linked in the future
1249 _dyld_register_func_for_add_image(GC_dyld_image_add);
1250 _dyld_register_func_for_remove_image(GC_dyld_image_remove);
1252 /* Set this early to avoid reentrancy issues. */
1253 initialized = TRUE;
1255 bind_fully_env = getenv("DYLD_BIND_AT_LAUNCH");
1257 if (bind_fully_env == NULL) {
1258 # ifdef DARWIN_DEBUG
1259 GC_printf0("Forcing full bind of GC code...\n");
1260 # endif
1262 if(!_dyld_bind_fully_image_containing_address((unsigned long*)GC_malloc))
1263 GC_abort("_dyld_bind_fully_image_containing_address failed");
1268 #define HAVE_REGISTER_MAIN_STATIC_DATA
1269 GC_bool GC_register_main_static_data()
1271 /* Already done through dyld callbacks */
1272 return FALSE;
1275 #endif /* DARWIN */
1277 #else /* !DYNAMIC_LOADING */
1279 #ifdef PCR
1281 # include "il/PCR_IL.h"
1282 # include "th/PCR_ThCtl.h"
1283 # include "mm/PCR_MM.h"
1285 void GC_register_dynamic_libraries()
1287 /* Add new static data areas of dynamically loaded modules. */
1289 PCR_IL_LoadedFile * p = PCR_IL_GetLastLoadedFile();
1290 PCR_IL_LoadedSegment * q;
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;
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);
1316 #else /* !PCR */
1318 void GC_register_dynamic_libraries(){}
1320 int GC_no_dynamic_loading;
1322 #endif /* !PCR */
1324 #endif /* !DYNAMIC_LOADING */
1326 #ifndef HAVE_REGISTER_MAIN_STATIC_DATA
1328 /* Do we need to separately register the main static data segment? */
1329 GC_bool GC_register_main_static_data()
1331 return TRUE;
1333 #endif /* HAVE_REGISTER_MAIN_STATIC_DATA */