2 * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
3 * Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved.
4 * Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved.
5 * Copyright (c) 1999 by Hewlett-Packard Company. All rights reserved.
7 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
8 * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
10 * Permission is hereby granted to use or copy this program
11 * for any purpose, provided the above notices are retained on all copies.
12 * Permission to modify the code and to distribute modified code is granted,
13 * provided the above notices are retained, and a notice that the code was
14 * modified is included with the above copyright notice.
17 # include "private/gc_priv.h"
19 # if defined(LINUX) && !defined(POWERPC)
20 # include <linux/version.h>
21 # if (LINUX_VERSION_CODE <= 0x10400)
22 /* Ugly hack to get struct sigcontext_struct definition. Required */
23 /* for some early 1.3.X releases. Will hopefully go away soon. */
24 /* in some later Linux releases, asm/sigcontext.h may have to */
25 /* be included instead. */
27 # include <asm/signal.h>
30 /* Kernels prior to 2.1.1 defined struct sigcontext_struct instead of */
31 /* struct sigcontext. libc6 (glibc2) uses "struct sigcontext" in */
32 /* prototypes, so we have to include the top-level sigcontext.h to */
33 /* make sure the former gets defined to be the latter if appropriate. */
34 # include <features.h>
36 # if 2 == __GLIBC__ && 0 == __GLIBC_MINOR__
37 /* glibc 2.1 no longer has sigcontext.h. But signal.h */
38 /* has the right declaration for glibc 2.1. */
39 # include <sigcontext.h>
40 # endif /* 0 == __GLIBC_MINOR__ */
41 # else /* not 2 <= __GLIBC__ */
42 /* libc5 doesn't have <sigcontext.h>: go directly with the kernel */
43 /* one. Check LINUX_VERSION_CODE to see which we should reference. */
44 # include <asm/sigcontext.h>
45 # endif /* 2 <= __GLIBC__ */
48 # if !defined(OS2) && !defined(PCR) && !defined(AMIGA) && !defined(MACOS) \
50 # include <sys/types.h>
51 # if !defined(MSWIN32) && !defined(SUNOS4)
58 # define SIGSEGV 0 /* value is irrelevant */
63 /* Blatantly OS dependent routines, except for those that are related */
64 /* to dynamic loading. */
66 # if defined(HEURISTIC2) || defined(SEARCH_FOR_DATA_START)
67 # define NEED_FIND_LIMIT
70 # if !defined(STACKBOTTOM) && defined(HEURISTIC2)
71 # define NEED_FIND_LIMIT
74 # if (defined(SUNOS4) && defined(DYNAMIC_LOADING)) && !defined(PCR)
75 # define NEED_FIND_LIMIT
78 # if (defined(SVR4) || defined(AUX) || defined(DGUX) \
79 || (defined(LINUX) && defined(SPARC))) && !defined(PCR)
80 # define NEED_FIND_LIMIT
83 #if defined(FREEBSD) && defined(I386)
84 # include <machine/trap.h>
86 # define NEED_FIND_LIMIT
90 #if (defined(NETBSD) || defined(OPENBSD)) && defined(__ELF__) \
91 && !defined(NEED_FIND_LIMIT)
92 /* Used by GC_init_netbsd_elf() below. */
93 # define NEED_FIND_LIMIT
96 #ifdef NEED_FIND_LIMIT
101 # define GC_AMIGA_DEF
102 # include "AmigaOS.c"
106 #if defined(MSWIN32) || defined(MSWINCE)
107 # define WIN32_LEAN_AND_MEAN
109 # include <windows.h>
113 # include <Processes.h>
117 # include <sys/uio.h>
118 # include <malloc.h> /* for locking */
120 #if defined(USE_MUNMAP)
122 --> USE_MUNMAP requires USE_MMAP
125 #if defined(USE_MMAP) || defined(USE_MUNMAP) || defined(FALLBACK_TO_MMAP)
126 # include <sys/types.h>
127 # include <sys/mman.h>
128 # include <sys/stat.h>
136 #if (defined(SUNOS5SIGS) || defined (HURD) || defined(LINUX) || defined(NETBSD)) && !defined(FREEBSD)
138 # include <sys/siginfo.h>
140 /* Define SETJMP and friends to be the version that restores */
141 /* the signal mask. */
142 # define SETJMP(env) sigsetjmp(env, 1)
143 # define LONGJMP(env, val) siglongjmp(env, val)
144 # define JMP_BUF sigjmp_buf
146 # define SETJMP(env) setjmp(env)
147 # define LONGJMP(env, val) longjmp(env, val)
148 # define JMP_BUF jmp_buf
152 /* for get_etext and friends */
153 #include <mach-o/getsect.h>
157 /* Apparently necessary for djgpp 2.01. May cause problems with */
158 /* other versions. */
159 typedef long unsigned int caddr_t;
163 # include "il/PCR_IL.h"
164 # include "th/PCR_ThCtl.h"
165 # include "mm/PCR_MM.h"
168 #if !defined(NO_EXECUTE_PERMISSION)
169 # define OPT_PROT_EXEC PROT_EXEC
171 # define OPT_PROT_EXEC 0
174 #if defined(LINUX) && \
175 (defined(USE_PROC_FOR_LIBRARIES) || defined(IA64) || !defined(SMALL_CONFIG))
177 /* We need to parse /proc/self/maps, either to find dynamic libraries, */
178 /* and/or to find the register backing store base (IA64). Do it once */
183 /* Repeatedly perform a read call until the buffer is filled or */
184 /* we encounter EOF. */
185 ssize_t GC_repeat_read(int fd, char *buf, size_t count)
187 ssize_t num_read = 0;
190 while (num_read < count) {
191 result = READ(fd, buf + num_read, count - num_read);
192 if (result < 0) return result;
193 if (result == 0) break;
200 * Apply fn to a buffer containing the contents of /proc/self/maps.
201 * Return the result of fn or, if we failed, 0.
202 * We currently do nothing to /proc/self/maps other than simply read
203 * it. This code could be simplified if we could determine its size
207 word GC_apply_to_maps(word (*fn)(char *))
211 size_t maps_size = 4000; /* Initial guess. */
212 static char init_buf[1];
213 static char *maps_buf = init_buf;
214 static size_t maps_buf_sz = 1;
216 /* Read /proc/self/maps, growing maps_buf as necessary. */
217 /* Note that we may not allocate conventionally, and */
218 /* thus can't use stdio. */
220 if (maps_size >= maps_buf_sz) {
221 /* Grow only by powers of 2, since we leak "too small" buffers. */
222 while (maps_size >= maps_buf_sz) maps_buf_sz *= 2;
223 maps_buf = GC_scratch_alloc(maps_buf_sz);
224 if (maps_buf == 0) return 0;
226 f = open("/proc/self/maps", O_RDONLY);
227 if (-1 == f) return 0;
230 result = GC_repeat_read(f, maps_buf, maps_buf_sz-1);
231 if (result <= 0) return 0;
233 } while (result == maps_buf_sz-1);
235 } while (maps_size >= maps_buf_sz);
236 maps_buf[maps_size] = '\0';
238 /* Apply fn to result. */
242 #endif /* Need GC_apply_to_maps */
244 #if defined(LINUX) && (defined(USE_PROC_FOR_LIBRARIES) || defined(IA64))
246 // GC_parse_map_entry parses an entry from /proc/self/maps so we can
247 // locate all writable data segments that belong to shared libraries.
248 // The format of one of these entries and the fields we care about
250 // XXXXXXXX-XXXXXXXX r-xp 00000000 30:05 260537 name of mapping...\n
251 // ^^^^^^^^ ^^^^^^^^ ^^^^ ^^
252 // start end prot maj_dev
258 // The parser is called with a pointer to the entry and the return value
259 // is either NULL or is advanced to the next entry(the byte after the
263 # define OFFSET_MAP_START 0
264 # define OFFSET_MAP_END 9
265 # define OFFSET_MAP_PROT 18
266 # define OFFSET_MAP_MAJDEV 32
267 # define ADDR_WIDTH 8
271 # define OFFSET_MAP_START 0
272 # define OFFSET_MAP_END 17
273 # define OFFSET_MAP_PROT 34
274 # define OFFSET_MAP_MAJDEV 56
275 # define ADDR_WIDTH 16
279 * Assign various fields of the first line in buf_ptr to *start, *end,
280 * *prot_buf and *maj_dev. Only *prot_buf may be set for unwritable maps.
282 char *GC_parse_map_entry(char *buf_ptr, word *start, word *end,
283 char *prot_buf, unsigned int *maj_dev)
288 if (buf_ptr == NULL || *buf_ptr == '\0') {
292 memcpy(prot_buf, buf_ptr+OFFSET_MAP_PROT, 4);
293 /* do the protections first. */
296 if (prot_buf[1] == 'w') {/* we can skip all of this if it's not writable. */
299 buf_ptr[OFFSET_MAP_START+ADDR_WIDTH] = '\0';
300 *start = strtoul(tok, NULL, 16);
302 tok = buf_ptr+OFFSET_MAP_END;
303 buf_ptr[OFFSET_MAP_END+ADDR_WIDTH] = '\0';
304 *end = strtoul(tok, NULL, 16);
306 buf_ptr += OFFSET_MAP_MAJDEV;
308 while (*buf_ptr != ':') buf_ptr++;
310 *maj_dev = strtoul(tok, NULL, 16);
313 while (*buf_ptr && *buf_ptr++ != '\n');
318 #endif /* Need to parse /proc/self/maps. */
320 #if defined(SEARCH_FOR_DATA_START)
321 /* The I386 case can be handled without a search. The Alpha case */
322 /* used to be handled differently as well, but the rules changed */
323 /* for recent Linux versions. This seems to be the easiest way to */
324 /* cover all versions. */
327 /* Some Linux distributions arrange to define __data_start. Some */
328 /* define data_start as a weak symbol. The latter is technically */
329 /* broken, since the user program may define data_start, in which */
330 /* case we lose. Nonetheless, we try both, prefering __data_start. */
331 /* We assume gcc-compatible pragmas. */
332 # pragma weak __data_start
333 extern int __data_start[];
334 # pragma weak data_start
335 extern int data_start[];
341 void GC_init_linux_data_start()
343 extern ptr_t GC_find_limit();
346 /* Try the easy approaches first: */
347 if ((ptr_t)__data_start != 0) {
348 GC_data_start = (ptr_t)(__data_start);
351 if ((ptr_t)data_start != 0) {
352 GC_data_start = (ptr_t)(data_start);
356 GC_data_start = GC_find_limit((ptr_t)(_end), FALSE);
362 # ifndef ECOS_GC_MEMORY_SIZE
363 # define ECOS_GC_MEMORY_SIZE (448 * 1024)
364 # endif /* ECOS_GC_MEMORY_SIZE */
366 // setjmp() function, as described in ANSI para 7.6.1.1
368 #define SETJMP( __env__ ) hal_setjmp( __env__ )
370 // FIXME: This is a simple way of allocating memory which is
371 // compatible with ECOS early releases. Later releases use a more
372 // sophisticated means of allocating memory than this simple static
373 // allocator, but this method is at least bound to work.
374 static char memory[ECOS_GC_MEMORY_SIZE];
375 static char *brk = memory;
377 static void *tiny_sbrk(ptrdiff_t increment)
383 if (brk > memory + sizeof memory)
391 #define sbrk tiny_sbrk
394 #if (defined(NETBSD) || defined(OPENBSD)) && defined(__ELF__)
397 void GC_init_netbsd_elf()
399 extern ptr_t GC_find_limit();
400 extern char **environ;
401 /* This may need to be environ, without the underscore, for */
403 GC_data_start = GC_find_limit((ptr_t)&environ, FALSE);
411 # if !defined(__IBMC__) && !defined(__WATCOMC__) /* e.g. EMX */
414 unsigned short magic_number;
415 unsigned short padding[29];
419 #define E_MAGIC(x) (x).magic_number
420 #define EMAGIC 0x5A4D
421 #define E_LFANEW(x) (x).new_exe_offset
424 unsigned char magic_number[2];
425 unsigned char byte_order;
426 unsigned char word_order;
427 unsigned long exe_format_level;
430 unsigned long padding1[13];
431 unsigned long object_table_offset;
432 unsigned long object_count;
433 unsigned long padding2[31];
436 #define E32_MAGIC1(x) (x).magic_number[0]
437 #define E32MAGIC1 'L'
438 #define E32_MAGIC2(x) (x).magic_number[1]
439 #define E32MAGIC2 'X'
440 #define E32_BORDER(x) (x).byte_order
442 #define E32_WORDER(x) (x).word_order
444 #define E32_CPU(x) (x).cpu
446 #define E32_OBJTAB(x) (x).object_table_offset
447 #define E32_OBJCNT(x) (x).object_count
453 unsigned long pagemap;
454 unsigned long mapsize;
455 unsigned long reserved;
458 #define O32_FLAGS(x) (x).flags
459 #define OBJREAD 0x0001L
460 #define OBJWRITE 0x0002L
461 #define OBJINVALID 0x0080L
462 #define O32_SIZE(x) (x).size
463 #define O32_BASE(x) (x).base
465 # else /* IBM's compiler */
467 /* A kludge to get around what appears to be a header file bug */
469 # define WORD unsigned short
472 # define DWORD unsigned long
479 # endif /* __IBMC__ */
481 # define INCL_DOSEXCEPTIONS
482 # define INCL_DOSPROCESS
483 # define INCL_DOSERRORS
484 # define INCL_DOSMODULEMGR
485 # define INCL_DOSMEMMGR
489 /* Disable and enable signals during nontrivial allocations */
491 void GC_disable_signals(void)
495 DosEnterMustComplete(&nest);
496 if (nest != 1) ABORT("nested GC_disable_signals");
499 void GC_enable_signals(void)
503 DosExitMustComplete(&nest);
504 if (nest != 0) ABORT("GC_enable_signals");
510 # if !defined(PCR) && !defined(AMIGA) && !defined(MSWIN32) \
511 && !defined(MSWINCE) \
512 && !defined(MACOS) && !defined(DJGPP) && !defined(DOS4GW) \
513 && !defined(NOSYS) && !defined(ECOS)
515 # if defined(sigmask) && !defined(UTS4) && !defined(HURD)
516 /* Use the traditional BSD interface */
517 # define SIGSET_T int
518 # define SIG_DEL(set, signal) (set) &= ~(sigmask(signal))
519 # define SIG_FILL(set) (set) = 0x7fffffff
520 /* Setting the leading bit appears to provoke a bug in some */
521 /* longjmp implementations. Most systems appear not to have */
523 # define SIGSETMASK(old, new) (old) = sigsetmask(new)
525 /* Use POSIX/SYSV interface */
526 # define SIGSET_T sigset_t
527 # define SIG_DEL(set, signal) sigdelset(&(set), (signal))
528 # define SIG_FILL(set) sigfillset(&set)
529 # define SIGSETMASK(old, new) sigprocmask(SIG_SETMASK, &(new), &(old))
532 static GC_bool mask_initialized = FALSE;
534 static SIGSET_T new_mask;
536 static SIGSET_T old_mask;
538 static SIGSET_T dummy;
540 #if defined(PRINTSTATS) && !defined(THREADS)
541 # define CHECK_SIGNALS
542 int GC_sig_disabled = 0;
545 void GC_disable_signals()
547 if (!mask_initialized) {
550 SIG_DEL(new_mask, SIGSEGV);
551 SIG_DEL(new_mask, SIGILL);
552 SIG_DEL(new_mask, SIGQUIT);
554 SIG_DEL(new_mask, SIGBUS);
557 SIG_DEL(new_mask, SIGIOT);
560 SIG_DEL(new_mask, SIGEMT);
563 SIG_DEL(new_mask, SIGTRAP);
565 mask_initialized = TRUE;
567 # ifdef CHECK_SIGNALS
568 if (GC_sig_disabled != 0) ABORT("Nested disables");
571 SIGSETMASK(old_mask,new_mask);
574 void GC_enable_signals()
576 # ifdef CHECK_SIGNALS
577 if (GC_sig_disabled != 1) ABORT("Unmatched enable");
580 SIGSETMASK(dummy,old_mask);
587 /* Ivan Demakov: simplest way (to me) */
589 void GC_disable_signals() { }
590 void GC_enable_signals() { }
593 /* Find the page size */
596 # if defined(MSWIN32) || defined(MSWINCE)
597 void GC_setpagesize()
599 GetSystemInfo(&GC_sysinfo);
600 GC_page_size = GC_sysinfo.dwPageSize;
604 # if defined(MPROTECT_VDB) || defined(PROC_VDB) || defined(USE_MMAP) \
605 || defined(USE_MUNMAP) || defined(FALLBACK_TO_MMAP)
606 void GC_setpagesize()
608 GC_page_size = GETPAGESIZE();
611 /* It's acceptable to fake it. */
612 void GC_setpagesize()
614 GC_page_size = HBLKSIZE;
620 * Find the base of the stack.
621 * Used only in single-threaded environment.
622 * With threads, GC_mark_roots needs to know how to do this.
623 * Called with allocator lock held.
625 # if defined(MSWIN32) || defined(MSWINCE)
626 # define is_writable(prot) ((prot) == PAGE_READWRITE \
627 || (prot) == PAGE_WRITECOPY \
628 || (prot) == PAGE_EXECUTE_READWRITE \
629 || (prot) == PAGE_EXECUTE_WRITECOPY)
630 /* Return the number of bytes that are writable starting at p. */
631 /* The pointer p is assumed to be page aligned. */
632 /* If base is not 0, *base becomes the beginning of the */
633 /* allocation region containing p. */
634 word GC_get_writable_length(ptr_t p, ptr_t *base)
636 MEMORY_BASIC_INFORMATION buf;
640 result = VirtualQuery(p, &buf, sizeof(buf));
641 if (result != sizeof(buf)) ABORT("Weird VirtualQuery result");
642 if (base != 0) *base = (ptr_t)(buf.AllocationBase);
643 protect = (buf.Protect & ~(PAGE_GUARD | PAGE_NOCACHE));
644 if (!is_writable(protect)) {
647 if (buf.State != MEM_COMMIT) return(0);
648 return(buf.RegionSize);
651 ptr_t GC_get_stack_base()
654 ptr_t sp = (ptr_t)(&dummy);
655 ptr_t trunc_sp = (ptr_t)((word)sp & ~(GC_page_size - 1));
656 word size = GC_get_writable_length(trunc_sp, 0);
658 return(trunc_sp + size);
662 # endif /* MS Windows */
665 # include <kernel/OS.h>
666 ptr_t GC_get_stack_base(){
668 get_thread_info(find_thread(NULL),&th);
676 ptr_t GC_get_stack_base()
681 if (DosGetInfoBlocks(&ptib, &ppib) != NO_ERROR) {
682 GC_err_printf0("DosGetInfoBlocks failed\n");
683 ABORT("DosGetInfoBlocks failed\n");
685 return((ptr_t)(ptib -> tib_pstacklimit));
692 # include "AmigaOS.c"
696 # if defined(NEED_FIND_LIMIT) || defined(UNIX_LIKE)
699 typedef void (*handler)(int);
701 typedef void (*handler)();
704 # if defined(SUNOS5SIGS) || defined(IRIX5) || defined(OSF1) \
705 || defined(HURD) || defined(NETBSD) || defined(FREEBSD)
706 static struct sigaction old_segv_act;
707 # if defined(_sigargs) /* !Irix6.x */ || defined(HPUX) \
708 || defined(HURD) || defined(NETBSD) || defined(FREEBSD)
709 static struct sigaction old_bus_act;
712 static handler old_segv_handler, old_bus_handler;
716 void GC_set_and_save_fault_handler(handler h)
718 void GC_set_and_save_fault_handler(h)
722 # if defined(SUNOS5SIGS) || defined(IRIX5) \
723 || defined(OSF1) || defined(HURD) || defined(NETBSD) || defined(FREEBSD)
724 struct sigaction act;
727 # if 0 /* Was necessary for Solaris 2.3 and very temporary */
729 act.sa_flags = SA_RESTART | SA_NODEFER;
731 act.sa_flags = SA_RESTART;
734 (void) sigemptyset(&act.sa_mask);
735 # ifdef GC_IRIX_THREADS
736 /* Older versions have a bug related to retrieving and */
737 /* and setting a handler at the same time. */
738 (void) sigaction(SIGSEGV, 0, &old_segv_act);
739 (void) sigaction(SIGSEGV, &act, 0);
741 (void) sigaction(SIGSEGV, &act, &old_segv_act);
742 # if defined(IRIX5) && defined(_sigargs) /* Irix 5.x, not 6.x */ \
743 || defined(HPUX) || defined(HURD) || defined(NETBSD) || defined(FREEBSD)
744 /* Under Irix 5.x or HP/UX, we may get SIGBUS. */
745 /* Pthreads doesn't exist under Irix 5.x, so we */
746 /* don't have to worry in the threads case. */
747 (void) sigaction(SIGBUS, &act, &old_bus_act);
749 # endif /* GC_IRIX_THREADS */
751 old_segv_handler = signal(SIGSEGV, h);
753 old_bus_handler = signal(SIGBUS, h);
757 # endif /* NEED_FIND_LIMIT || UNIX_LIKE */
759 # ifdef NEED_FIND_LIMIT
760 /* Some tools to implement HEURISTIC2 */
761 # define MIN_PAGE_SIZE 256 /* Smallest conceivable page size, bytes */
762 /* static */ JMP_BUF GC_jmp_buf;
765 void GC_fault_handler(sig)
768 LONGJMP(GC_jmp_buf, 1);
771 void GC_setup_temporary_fault_handler()
773 GC_set_and_save_fault_handler(GC_fault_handler);
776 void GC_reset_fault_handler()
778 # if defined(SUNOS5SIGS) || defined(IRIX5) \
779 || defined(OSF1) || defined(HURD) || defined(NETBSD) || defined(FREEBSD)
780 (void) sigaction(SIGSEGV, &old_segv_act, 0);
781 # if defined(IRIX5) && defined(_sigargs) /* Irix 5.x, not 6.x */ \
782 || defined(HPUX) || defined(HURD) || defined(NETBSD) || defined(FREEBSD)
783 (void) sigaction(SIGBUS, &old_bus_act, 0);
786 (void) signal(SIGSEGV, old_segv_handler);
788 (void) signal(SIGBUS, old_bus_handler);
793 /* Return the first nonaddressible location > p (up) or */
794 /* the smallest location q s.t. [q,p) is addressable (!up). */
795 /* We assume that p (up) or p-1 (!up) is addressable. */
796 ptr_t GC_find_limit(p, up)
800 static VOLATILE ptr_t result;
801 /* Needs to be static, since otherwise it may not be */
802 /* preserved across the longjmp. Can safely be */
803 /* static since it's only called once, with the */
804 /* allocation lock held. */
807 GC_setup_temporary_fault_handler();
808 if (SETJMP(GC_jmp_buf) == 0) {
809 result = (ptr_t)(((word)(p))
810 & ~(MIN_PAGE_SIZE-1));
813 result += MIN_PAGE_SIZE;
815 result -= MIN_PAGE_SIZE;
817 GC_noop1((word)(*result));
820 GC_reset_fault_handler();
822 result += MIN_PAGE_SIZE;
828 #if defined(ECOS) || defined(NOSYS)
829 ptr_t GC_get_stack_base()
835 #ifdef HPUX_STACKBOTTOM
837 #include <sys/param.h>
838 #include <sys/pstat.h>
840 ptr_t GC_get_register_stack_base(void)
842 struct pst_vm_status vm_status;
845 while (pstat_getprocvm(&vm_status, sizeof(vm_status), 0, i++) == 1) {
846 if (vm_status.pst_type == PS_RSESTACK) {
847 return (ptr_t) vm_status.pst_vaddr;
851 /* old way to get the register stackbottom */
852 return (ptr_t)(((word)GC_stackbottom - BACKING_STORE_DISPLACEMENT - 1)
853 & ~(BACKING_STORE_ALIGNMENT - 1));
856 #endif /* HPUX_STACK_BOTTOM */
858 #ifdef LINUX_STACKBOTTOM
860 #include <sys/types.h>
861 #include <sys/stat.h>
864 # define STAT_SKIP 27 /* Number of fields preceding startstack */
865 /* field in /proc/self/stat */
867 # pragma weak __libc_stack_end
868 extern ptr_t __libc_stack_end;
871 /* Try to read the backing store base from /proc/self/maps. */
872 /* We look for the writable mapping with a 0 major device, */
873 /* which is as close to our frame as possible, but below it.*/
874 static word backing_store_base_from_maps(char *maps)
877 char *buf_ptr = maps;
879 unsigned int maj_dev;
880 word current_best = 0;
884 buf_ptr = GC_parse_map_entry(buf_ptr, &start, &end, prot_buf, &maj_dev);
885 if (buf_ptr == NULL) return current_best;
886 if (prot_buf[1] == 'w' && maj_dev == 0) {
887 if (end < (word)(&dummy) && start > current_best) current_best = start;
893 static word backing_store_base_from_proc(void)
895 return GC_apply_to_maps(backing_store_base_from_maps);
898 # pragma weak __libc_ia64_register_backing_store_base
899 extern ptr_t __libc_ia64_register_backing_store_base;
901 ptr_t GC_get_register_stack_base(void)
903 if (0 != &__libc_ia64_register_backing_store_base
904 && 0 != __libc_ia64_register_backing_store_base) {
905 /* Glibc 2.2.4 has a bug such that for dynamically linked */
906 /* executables __libc_ia64_register_backing_store_base is */
907 /* defined but uninitialized during constructor calls. */
908 /* Hence we check for both nonzero address and value. */
909 return __libc_ia64_register_backing_store_base;
911 word result = backing_store_base_from_proc();
913 /* Use dumb heuristics. Works only for default configuration. */
914 result = (word)GC_stackbottom - BACKING_STORE_DISPLACEMENT;
915 result += BACKING_STORE_ALIGNMENT - 1;
916 result &= ~(BACKING_STORE_ALIGNMENT - 1);
917 /* Verify that it's at least readable. If not, we goofed. */
918 GC_noop1(*(word *)result);
920 return (ptr_t)result;
925 ptr_t GC_linux_stack_base(void)
927 /* We read the stack base value from /proc/self/stat. We do this */
928 /* using direct I/O system calls in order to avoid calling malloc */
929 /* in case REDIRECT_MALLOC is defined. */
930 # define STAT_BUF_SIZE 4096
931 # define STAT_READ read
932 /* Should probably call the real read, if read is wrapped. */
933 char stat_buf[STAT_BUF_SIZE];
937 size_t i, buf_offset = 0;
939 /* First try the easy way. This should work for glibc 2.2 */
940 /* This fails in a prelinked ("prelink" command) executable */
941 /* since the correct value of __libc_stack_end never */
942 /* becomes visible to us. The second test works around */
944 #if USE_LIBC_PRIVATE_SYMBOLS
945 if (0 != &__libc_stack_end && 0 != __libc_stack_end ) {
947 /* Some versions of glibc set the address 16 bytes too */
948 /* low while the initialization code is running. */
949 if (((word)__libc_stack_end & 0xfff) + 0x10 < 0x1000) {
950 return __libc_stack_end + 0x10;
951 } /* Otherwise it's not safe to add 16 bytes and we fall */
952 /* back to using /proc. */
954 return __libc_stack_end;
958 f = open("/proc/self/stat", O_RDONLY);
959 if (f < 0 || STAT_READ(f, stat_buf, STAT_BUF_SIZE) < 2 * STAT_SKIP) {
960 ABORT("Couldn't read /proc/self/stat");
962 c = stat_buf[buf_offset++];
963 /* Skip the required number of fields. This number is hopefully */
964 /* constant across all Linux implementations. */
965 for (i = 0; i < STAT_SKIP; ++i) {
966 while (isspace(c)) c = stat_buf[buf_offset++];
967 while (!isspace(c)) c = stat_buf[buf_offset++];
969 while (isspace(c)) c = stat_buf[buf_offset++];
973 c = stat_buf[buf_offset++];
976 if (result < 0x10000000) ABORT("Absurd stack bottom value");
977 return (ptr_t)result;
980 #endif /* LINUX_STACKBOTTOM */
982 #ifdef FREEBSD_STACKBOTTOM
984 /* This uses an undocumented sysctl call, but at least one expert */
985 /* believes it will stay. */
988 #include <sys/types.h>
989 #include <sys/sysctl.h>
991 ptr_t GC_freebsd_stack_base(void)
993 int nm[2] = {CTL_KERN, KERN_USRSTACK};
995 size_t len = sizeof(ptr_t);
996 int r = sysctl(nm, 2, &base, &len, NULL, 0);
998 if (r) ABORT("Error getting stack base");
1003 #endif /* FREEBSD_STACKBOTTOM */
1005 #if !defined(BEOS) && !defined(AMIGA) && !defined(MSWIN32) \
1006 && !defined(MSWINCE) && !defined(OS2) && !defined(NOSYS) && !defined(ECOS)
1008 ptr_t GC_get_stack_base()
1010 # if defined(HEURISTIC1) || defined(HEURISTIC2) || \
1011 defined(LINUX_STACKBOTTOM) || defined(FREEBSD_STACKBOTTOM)
1016 # define STACKBOTTOM_ALIGNMENT_M1 ((word)STACK_GRAN - 1)
1019 return(STACKBOTTOM);
1022 # ifdef STACK_GROWS_DOWN
1023 result = (ptr_t)((((word)(&dummy))
1024 + STACKBOTTOM_ALIGNMENT_M1)
1025 & ~STACKBOTTOM_ALIGNMENT_M1);
1027 result = (ptr_t)(((word)(&dummy))
1028 & ~STACKBOTTOM_ALIGNMENT_M1);
1030 # endif /* HEURISTIC1 */
1031 # ifdef LINUX_STACKBOTTOM
1032 result = GC_linux_stack_base();
1034 # ifdef FREEBSD_STACKBOTTOM
1035 result = GC_freebsd_stack_base();
1038 # ifdef STACK_GROWS_DOWN
1039 result = GC_find_limit((ptr_t)(&dummy), TRUE);
1040 # ifdef HEURISTIC2_LIMIT
1041 if (result > HEURISTIC2_LIMIT
1042 && (ptr_t)(&dummy) < HEURISTIC2_LIMIT) {
1043 result = HEURISTIC2_LIMIT;
1047 result = GC_find_limit((ptr_t)(&dummy), FALSE);
1048 # ifdef HEURISTIC2_LIMIT
1049 if (result < HEURISTIC2_LIMIT
1050 && (ptr_t)(&dummy) > HEURISTIC2_LIMIT) {
1051 result = HEURISTIC2_LIMIT;
1056 # endif /* HEURISTIC2 */
1057 # ifdef STACK_GROWS_DOWN
1058 if (result == 0) result = (ptr_t)(signed_word)(-sizeof(ptr_t));
1061 # endif /* STACKBOTTOM */
1064 # endif /* ! AMIGA, !OS 2, ! MS Windows, !BEOS, !NOSYS, !ECOS */
1067 * Register static data segment(s) as roots.
1068 * If more data segments are added later then they need to be registered
1069 * add that point (as we do with SunOS dynamic loading),
1070 * or GC_mark_roots needs to check for them (as we do with PCR).
1071 * Called with allocator lock held.
1076 void GC_register_data_segments()
1080 HMODULE module_handle;
1081 # define PBUFSIZ 512
1082 UCHAR path[PBUFSIZ];
1084 struct exe_hdr hdrdos; /* MSDOS header. */
1085 struct e32_exe hdr386; /* Real header for my executable */
1086 struct o32_obj seg; /* Currrent segment */
1090 if (DosGetInfoBlocks(&ptib, &ppib) != NO_ERROR) {
1091 GC_err_printf0("DosGetInfoBlocks failed\n");
1092 ABORT("DosGetInfoBlocks failed\n");
1094 module_handle = ppib -> pib_hmte;
1095 if (DosQueryModuleName(module_handle, PBUFSIZ, path) != NO_ERROR) {
1096 GC_err_printf0("DosQueryModuleName failed\n");
1097 ABORT("DosGetInfoBlocks failed\n");
1099 myexefile = fopen(path, "rb");
1100 if (myexefile == 0) {
1101 GC_err_puts("Couldn't open executable ");
1102 GC_err_puts(path); GC_err_puts("\n");
1103 ABORT("Failed to open executable\n");
1105 if (fread((char *)(&hdrdos), 1, sizeof hdrdos, myexefile) < sizeof hdrdos) {
1106 GC_err_puts("Couldn't read MSDOS header from ");
1107 GC_err_puts(path); GC_err_puts("\n");
1108 ABORT("Couldn't read MSDOS header");
1110 if (E_MAGIC(hdrdos) != EMAGIC) {
1111 GC_err_puts("Executable has wrong DOS magic number: ");
1112 GC_err_puts(path); GC_err_puts("\n");
1113 ABORT("Bad DOS magic number");
1115 if (fseek(myexefile, E_LFANEW(hdrdos), SEEK_SET) != 0) {
1116 GC_err_puts("Seek to new header failed in ");
1117 GC_err_puts(path); GC_err_puts("\n");
1118 ABORT("Bad DOS magic number");
1120 if (fread((char *)(&hdr386), 1, sizeof hdr386, myexefile) < sizeof hdr386) {
1121 GC_err_puts("Couldn't read MSDOS header from ");
1122 GC_err_puts(path); GC_err_puts("\n");
1123 ABORT("Couldn't read OS/2 header");
1125 if (E32_MAGIC1(hdr386) != E32MAGIC1 || E32_MAGIC2(hdr386) != E32MAGIC2) {
1126 GC_err_puts("Executable has wrong OS/2 magic number:");
1127 GC_err_puts(path); GC_err_puts("\n");
1128 ABORT("Bad OS/2 magic number");
1130 if ( E32_BORDER(hdr386) != E32LEBO || E32_WORDER(hdr386) != E32LEWO) {
1131 GC_err_puts("Executable %s has wrong byte order: ");
1132 GC_err_puts(path); GC_err_puts("\n");
1133 ABORT("Bad byte order");
1135 if ( E32_CPU(hdr386) == E32CPU286) {
1136 GC_err_puts("GC can't handle 80286 executables: ");
1137 GC_err_puts(path); GC_err_puts("\n");
1140 if (fseek(myexefile, E_LFANEW(hdrdos) + E32_OBJTAB(hdr386),
1142 GC_err_puts("Seek to object table failed: ");
1143 GC_err_puts(path); GC_err_puts("\n");
1144 ABORT("Seek to object table failed");
1146 for (nsegs = E32_OBJCNT(hdr386); nsegs > 0; nsegs--) {
1148 if (fread((char *)(&seg), 1, sizeof seg, myexefile) < sizeof seg) {
1149 GC_err_puts("Couldn't read obj table entry from ");
1150 GC_err_puts(path); GC_err_puts("\n");
1151 ABORT("Couldn't read obj table entry");
1153 flags = O32_FLAGS(seg);
1154 if (!(flags & OBJWRITE)) continue;
1155 if (!(flags & OBJREAD)) continue;
1156 if (flags & OBJINVALID) {
1157 GC_err_printf0("Object with invalid pages?\n");
1160 GC_add_roots_inner(O32_BASE(seg), O32_BASE(seg)+O32_SIZE(seg), FALSE);
1166 # if defined(MSWIN32) || defined(MSWINCE)
1169 /* Unfortunately, we have to handle win32s very differently from NT, */
1170 /* Since VirtualQuery has very different semantics. In particular, */
1171 /* under win32s a VirtualQuery call on an unmapped page returns an */
1172 /* invalid result. Under NT, GC_register_data_segments is a noop and */
1173 /* all real work is done by GC_register_dynamic_libraries. Under */
1174 /* win32s, we cannot find the data segments associated with dll's. */
1175 /* We register the main data segment here. */
1176 GC_bool GC_no_win32_dlls = FALSE;
1177 /* This used to be set for gcc, to avoid dealing with */
1178 /* the structured exception handling issues. But we now have */
1179 /* assembly code to do that right. */
1181 void GC_init_win32()
1183 /* if we're running under win32s, assume that no DLLs will be loaded */
1184 DWORD v = GetVersion();
1185 GC_no_win32_dlls |= ((v & 0x80000000) && (v & 0xff) <= 3);
1188 /* Return the smallest address a such that VirtualQuery */
1189 /* returns correct results for all addresses between a and start. */
1190 /* Assumes VirtualQuery returns correct information for start. */
1191 ptr_t GC_least_described_address(ptr_t start)
1193 MEMORY_BASIC_INFORMATION buf;
1199 limit = GC_sysinfo.lpMinimumApplicationAddress;
1200 p = (ptr_t)((word)start & ~(GC_page_size - 1));
1202 q = (LPVOID)(p - GC_page_size);
1203 if ((ptr_t)q > (ptr_t)p /* underflow */ || q < limit) break;
1204 result = VirtualQuery(q, &buf, sizeof(buf));
1205 if (result != sizeof(buf) || buf.AllocationBase == 0) break;
1206 p = (ptr_t)(buf.AllocationBase);
1212 # ifndef REDIRECT_MALLOC
1213 /* We maintain a linked list of AllocationBase values that we know */
1214 /* correspond to malloc heap sections. Currently this is only called */
1215 /* during a GC. But there is some hope that for long running */
1216 /* programs we will eventually see most heap sections. */
1218 /* In the long run, it would be more reliable to occasionally walk */
1219 /* the malloc heap with HeapWalk on the default heap. But that */
1220 /* apparently works only for NT-based Windows. */
1222 /* In the long run, a better data structure would also be nice ... */
1223 struct GC_malloc_heap_list {
1224 void * allocation_base;
1225 struct GC_malloc_heap_list *next;
1226 } *GC_malloc_heap_l = 0;
1228 /* Is p the base of one of the malloc heap sections we already know */
1230 GC_bool GC_is_malloc_heap_base(ptr_t p)
1232 struct GC_malloc_heap_list *q = GC_malloc_heap_l;
1235 if (q -> allocation_base == p) return TRUE;
1241 void *GC_get_allocation_base(void *p)
1243 MEMORY_BASIC_INFORMATION buf;
1244 DWORD result = VirtualQuery(p, &buf, sizeof(buf));
1245 if (result != sizeof(buf)) {
1246 ABORT("Weird VirtualQuery result");
1248 return buf.AllocationBase;
1251 size_t GC_max_root_size = 100000; /* Appr. largest root size. */
1253 void GC_add_current_malloc_heap()
1255 struct GC_malloc_heap_list *new_l =
1256 malloc(sizeof(struct GC_malloc_heap_list));
1257 void * candidate = GC_get_allocation_base(new_l);
1259 if (new_l == 0) return;
1260 if (GC_is_malloc_heap_base(candidate)) {
1261 /* Try a little harder to find malloc heap. */
1262 size_t req_size = 10000;
1264 void *p = malloc(req_size);
1265 if (0 == p) { free(new_l); return; }
1266 candidate = GC_get_allocation_base(p);
1269 } while (GC_is_malloc_heap_base(candidate)
1270 && req_size < GC_max_root_size/10 && req_size < 500000);
1271 if (GC_is_malloc_heap_base(candidate)) {
1272 free(new_l); return;
1277 GC_printf1("Found new system malloc AllocationBase at 0x%lx\n",
1280 new_l -> allocation_base = candidate;
1281 new_l -> next = GC_malloc_heap_l;
1282 GC_malloc_heap_l = new_l;
1284 # endif /* REDIRECT_MALLOC */
1286 /* Is p the start of either the malloc heap, or of one of our */
1287 /* heap sections? */
1288 GC_bool GC_is_heap_base (ptr_t p)
1293 # ifndef REDIRECT_MALLOC
1294 static word last_gc_no = -1;
1296 if (last_gc_no != GC_gc_no) {
1297 GC_add_current_malloc_heap();
1298 last_gc_no = GC_gc_no;
1300 if (GC_root_size > GC_max_root_size) GC_max_root_size = GC_root_size;
1301 if (GC_is_malloc_heap_base(p)) return TRUE;
1303 for (i = 0; i < GC_n_heap_bases; i++) {
1304 if (GC_heap_bases[i] == p) return TRUE;
1310 void GC_register_root_section(ptr_t static_root)
1312 MEMORY_BASIC_INFORMATION buf;
1317 char * limit, * new_limit;
1319 if (!GC_no_win32_dlls) return;
1320 p = base = limit = GC_least_described_address(static_root);
1321 while (p < GC_sysinfo.lpMaximumApplicationAddress) {
1322 result = VirtualQuery(p, &buf, sizeof(buf));
1323 if (result != sizeof(buf) || buf.AllocationBase == 0
1324 || GC_is_heap_base(buf.AllocationBase)) break;
1325 new_limit = (char *)p + buf.RegionSize;
1326 protect = buf.Protect;
1327 if (buf.State == MEM_COMMIT
1328 && is_writable(protect)) {
1329 if ((char *)p == limit) {
1332 if (base != limit) GC_add_roots_inner(base, limit, FALSE);
1337 if (p > (LPVOID)new_limit /* overflow */) break;
1338 p = (LPVOID)new_limit;
1340 if (base != limit) GC_add_roots_inner(base, limit, FALSE);
1344 void GC_register_data_segments()
1348 GC_register_root_section((ptr_t)(&dummy));
1352 # else /* !OS2 && !Windows */
1354 # if (defined(SVR4) || defined(AUX) || defined(DGUX) \
1355 || (defined(LINUX) && defined(SPARC))) && !defined(PCR)
1356 ptr_t GC_SysVGetDataStart(max_page_size, etext_addr)
1360 word text_end = ((word)(etext_addr) + sizeof(word) - 1)
1361 & ~(sizeof(word) - 1);
1362 /* etext rounded to word boundary */
1363 word next_page = ((text_end + (word)max_page_size - 1)
1364 & ~((word)max_page_size - 1));
1365 word page_offset = (text_end & ((word)max_page_size - 1));
1366 VOLATILE char * result = (char *)(next_page + page_offset);
1367 /* Note that this isnt equivalent to just adding */
1368 /* max_page_size to &etext if &etext is at a page boundary */
1370 GC_setup_temporary_fault_handler();
1371 if (SETJMP(GC_jmp_buf) == 0) {
1372 /* Try writing to the address. */
1374 GC_reset_fault_handler();
1376 GC_reset_fault_handler();
1377 /* We got here via a longjmp. The address is not readable. */
1378 /* This is known to happen under Solaris 2.4 + gcc, which place */
1379 /* string constants in the text segment, but after etext. */
1380 /* Use plan B. Note that we now know there is a gap between */
1381 /* text and data segments, so plan A bought us something. */
1382 result = (char *)GC_find_limit((ptr_t)(DATAEND), FALSE);
1384 return((ptr_t)result);
1388 # if defined(FREEBSD) && defined(I386) && !defined(PCR)
1389 /* Its unclear whether this should be identical to the above, or */
1390 /* whether it should apply to non-X86 architectures. */
1391 /* For now we don't assume that there is always an empty page after */
1392 /* etext. But in some cases there actually seems to be slightly more. */
1393 /* This also deals with holes between read-only data and writable data. */
1394 ptr_t GC_FreeBSDGetDataStart(max_page_size, etext_addr)
1398 word text_end = ((word)(etext_addr) + sizeof(word) - 1)
1399 & ~(sizeof(word) - 1);
1400 /* etext rounded to word boundary */
1401 VOLATILE word next_page = (text_end + (word)max_page_size - 1)
1402 & ~((word)max_page_size - 1);
1403 VOLATILE ptr_t result = (ptr_t)text_end;
1404 GC_setup_temporary_fault_handler();
1405 if (SETJMP(GC_jmp_buf) == 0) {
1406 /* Try reading at the address. */
1407 /* This should happen before there is another thread. */
1408 for (; next_page < (word)(DATAEND); next_page += (word)max_page_size)
1409 *(VOLATILE char *)next_page;
1410 GC_reset_fault_handler();
1412 GC_reset_fault_handler();
1413 /* As above, we go to plan B */
1414 result = GC_find_limit((ptr_t)(DATAEND), FALSE);
1424 # define GC_AMIGA_DS
1425 # include "AmigaOS.c"
1428 #else /* !OS2 && !Windows && !AMIGA */
1430 void GC_register_data_segments()
1432 # if !defined(PCR) && !defined(SRC_M3) && !defined(MACOS)
1433 # if defined(REDIRECT_MALLOC) && defined(GC_SOLARIS_THREADS)
1434 /* As of Solaris 2.3, the Solaris threads implementation */
1435 /* allocates the data structure for the initial thread with */
1436 /* sbrk at process startup. It needs to be scanned, so that */
1437 /* we don't lose some malloc allocated data structures */
1438 /* hanging from it. We're on thin ice here ... */
1439 extern caddr_t sbrk();
1441 GC_add_roots_inner(DATASTART, (char *)sbrk(0), FALSE);
1443 GC_add_roots_inner(DATASTART, (char *)(DATAEND), FALSE);
1444 # if defined(DATASTART2)
1445 GC_add_roots_inner(DATASTART2, (char *)(DATAEND2), FALSE);
1451 # if defined(THINK_C)
1452 extern void* GC_MacGetDataStart(void);
1453 /* globals begin above stack and end at a5. */
1454 GC_add_roots_inner((ptr_t)GC_MacGetDataStart(),
1455 (ptr_t)LMGetCurrentA5(), FALSE);
1457 # if defined(__MWERKS__)
1459 extern void* GC_MacGetDataStart(void);
1460 /* MATTHEW: Function to handle Far Globals (CW Pro 3) */
1461 # if __option(far_data)
1462 extern void* GC_MacGetDataEnd(void);
1464 /* globals begin above stack and end at a5. */
1465 GC_add_roots_inner((ptr_t)GC_MacGetDataStart(),
1466 (ptr_t)LMGetCurrentA5(), FALSE);
1467 /* MATTHEW: Handle Far Globals */
1468 # if __option(far_data)
1469 /* Far globals follow he QD globals: */
1470 GC_add_roots_inner((ptr_t)LMGetCurrentA5(),
1471 (ptr_t)GC_MacGetDataEnd(), FALSE);
1474 extern char __data_start__[], __data_end__[];
1475 GC_add_roots_inner((ptr_t)&__data_start__,
1476 (ptr_t)&__data_end__, FALSE);
1477 # endif /* __POWERPC__ */
1478 # endif /* __MWERKS__ */
1479 # endif /* !THINK_C */
1483 /* Dynamic libraries are added at every collection, since they may */
1487 # endif /* ! AMIGA */
1488 # endif /* ! MSWIN32 && ! MSWINCE*/
1492 * Auxiliary routines for obtaining memory from OS.
1495 # if !defined(OS2) && !defined(PCR) && !defined(AMIGA) \
1496 && !defined(MSWIN32) && !defined(MSWINCE) \
1497 && !defined(MACOS) && !defined(DOS4GW)
1500 extern caddr_t sbrk();
1503 # define SBRK_ARG_T ptrdiff_t
1505 # define SBRK_ARG_T int
1510 /* The compiler seems to generate speculative reads one past the end of */
1511 /* an allocated object. Hence we need to make sure that the page */
1512 /* following the last heap page is also mapped. */
1513 ptr_t GC_unix_get_mem(bytes)
1516 caddr_t cur_brk = (caddr_t)sbrk(0);
1518 SBRK_ARG_T lsbs = (word)cur_brk & (GC_page_size-1);
1519 static caddr_t my_brk_val = 0;
1521 if ((SBRK_ARG_T)bytes < 0) return(0); /* too big */
1523 if((caddr_t)(sbrk(GC_page_size - lsbs)) == (caddr_t)(-1)) return(0);
1525 if (cur_brk == my_brk_val) {
1526 /* Use the extra block we allocated last time. */
1527 result = (ptr_t)sbrk((SBRK_ARG_T)bytes);
1528 if (result == (caddr_t)(-1)) return(0);
1529 result -= GC_page_size;
1531 result = (ptr_t)sbrk(GC_page_size + (SBRK_ARG_T)bytes);
1532 if (result == (caddr_t)(-1)) return(0);
1534 my_brk_val = result + bytes + GC_page_size; /* Always page aligned */
1535 return((ptr_t)result);
1538 #else /* Not RS6000 */
1540 #if defined(USE_MMAP) || defined(USE_MUNMAP) || defined(FALLBACK_TO_MMAP)
1542 #ifdef USE_MMAP_FIXED
1543 # define GC_MMAP_FLAGS MAP_FIXED | MAP_PRIVATE
1544 /* Seems to yield better performance on Solaris 2, but can */
1545 /* be unreliable if something is already mapped at the address. */
1547 # define GC_MMAP_FLAGS MAP_PRIVATE
1550 #ifdef USE_MMAP_ANON
1552 # if defined(MAP_ANONYMOUS)
1553 # define OPT_MAP_ANON MAP_ANONYMOUS
1555 # define OPT_MAP_ANON MAP_ANON
1559 # define OPT_MAP_ANON 0
1562 #endif /* defined(USE_MMAP) || defined(USE_MUNMAP) */
1564 #if defined(USE_MMAP) || defined(FALLBACK_TO_MMAP)
1565 /* Tested only under Linux, IRIX5 and Solaris 2 */
1568 # define HEAP_START 0
1571 #ifdef FALLBACK_TO_MMAP
1572 static ptr_t GC_unix_get_mem_mmap(bytes)
1574 ptr_t GC_unix_get_mem(bytes)
1579 static ptr_t last_addr = HEAP_START;
1581 # ifndef USE_MMAP_ANON
1582 static GC_bool initialized = FALSE;
1585 zero_fd = open("/dev/zero", O_RDONLY);
1586 fcntl(zero_fd, F_SETFD, FD_CLOEXEC);
1591 if (bytes & (GC_page_size -1)) ABORT("Bad GET_MEM arg");
1592 result = mmap(last_addr, bytes, PROT_READ | PROT_WRITE | OPT_PROT_EXEC,
1593 GC_MMAP_FLAGS | OPT_MAP_ANON, zero_fd, 0/* offset */);
1594 if (result == MAP_FAILED) return(0);
1595 last_addr = (ptr_t)result + bytes + GC_page_size - 1;
1596 last_addr = (ptr_t)((word)last_addr & ~(GC_page_size - 1));
1597 # if !defined(LINUX)
1598 if (last_addr == 0) {
1599 /* Oops. We got the end of the address space. This isn't */
1600 /* usable by arbitrary C code, since one-past-end pointers */
1601 /* don't work, so we discard it and try again. */
1602 munmap(result, (size_t)(-GC_page_size) - (size_t)result);
1603 /* Leave last page mapped, so we can't repeat. */
1604 return GC_unix_get_mem(bytes);
1607 GC_ASSERT(last_addr != 0);
1609 return((ptr_t)result);
1616 ptr_t GC_unix_get_mem(bytes)
1621 /* Bare sbrk isn't thread safe. Play by malloc rules. */
1622 /* The equivalent may be needed on other systems as well. */
1626 ptr_t cur_brk = (ptr_t)sbrk(0);
1627 SBRK_ARG_T lsbs = (word)cur_brk & (GC_page_size-1);
1629 if ((SBRK_ARG_T)bytes < 0) return(0); /* too big */
1631 if((ptr_t)sbrk(GC_page_size - lsbs) == (ptr_t)(-1)) return(0);
1633 result = (ptr_t)sbrk((SBRK_ARG_T)bytes);
1634 if (result == (ptr_t)(-1)) {
1635 #ifdef FALLBACK_TO_MMAP
1636 result = GC_unix_get_mem_mmap (bytes);
1648 #endif /* Not USE_MMAP */
1649 #endif /* Not RS6000 */
1655 void * os2_alloc(size_t bytes)
1659 if (DosAllocMem(&result, bytes, PAG_EXECUTE | PAG_READ |
1660 PAG_WRITE | PAG_COMMIT)
1664 if (result == 0) return(os2_alloc(bytes));
1671 # if defined(MSWIN32) || defined(MSWINCE)
1672 SYSTEM_INFO GC_sysinfo;
1677 # ifdef USE_GLOBAL_ALLOC
1678 # define GLOBAL_ALLOC_TEST 1
1680 # define GLOBAL_ALLOC_TEST GC_no_win32_dlls
1683 word GC_n_heap_bases = 0;
1685 ptr_t GC_win32_get_mem(bytes)
1690 if (GLOBAL_ALLOC_TEST) {
1691 /* VirtualAlloc doesn't like PAGE_EXECUTE_READWRITE. */
1692 /* There are also unconfirmed rumors of other */
1693 /* problems, so we dodge the issue. */
1694 result = (ptr_t) GlobalAlloc(0, bytes + HBLKSIZE);
1695 result = (ptr_t)(((word)result + HBLKSIZE) & ~(HBLKSIZE-1));
1697 /* VirtualProtect only works on regions returned by a */
1698 /* single VirtualAlloc call. Thus we allocate one */
1699 /* extra page, which will prevent merging of blocks */
1700 /* in separate regions, and eliminate any temptation */
1701 /* to call VirtualProtect on a range spanning regions. */
1702 /* This wastes a small amount of memory, and risks */
1703 /* increased fragmentation. But better alternatives */
1704 /* would require effort. */
1705 result = (ptr_t) VirtualAlloc(NULL, bytes + 1,
1706 MEM_COMMIT | MEM_RESERVE,
1707 PAGE_EXECUTE_READWRITE);
1709 if (HBLKDISPL(result) != 0) ABORT("Bad VirtualAlloc result");
1710 /* If I read the documentation correctly, this can */
1711 /* only happen if HBLKSIZE > 64k or not a power of 2. */
1712 if (GC_n_heap_bases >= MAX_HEAP_SECTS) ABORT("Too many heap sections");
1713 GC_heap_bases[GC_n_heap_bases++] = result;
1717 void GC_win32_free_heap ()
1719 if (GC_no_win32_dlls) {
1720 while (GC_n_heap_bases > 0) {
1721 GlobalFree (GC_heap_bases[--GC_n_heap_bases]);
1722 GC_heap_bases[GC_n_heap_bases] = 0;
1729 # define GC_AMIGA_AM
1730 # include "AmigaOS.c"
1736 word GC_n_heap_bases = 0;
1738 ptr_t GC_wince_get_mem(bytes)
1744 /* Round up allocation size to multiple of page size */
1745 bytes = (bytes + GC_page_size-1) & ~(GC_page_size-1);
1747 /* Try to find reserved, uncommitted pages */
1748 for (i = 0; i < GC_n_heap_bases; i++) {
1749 if (((word)(-(signed_word)GC_heap_lengths[i])
1750 & (GC_sysinfo.dwAllocationGranularity-1))
1752 result = GC_heap_bases[i] + GC_heap_lengths[i];
1757 if (i == GC_n_heap_bases) {
1758 /* Reserve more pages */
1759 word res_bytes = (bytes + GC_sysinfo.dwAllocationGranularity-1)
1760 & ~(GC_sysinfo.dwAllocationGranularity-1);
1761 /* If we ever support MPROTECT_VDB here, we will probably need to */
1762 /* ensure that res_bytes is strictly > bytes, so that VirtualProtect */
1763 /* never spans regions. It seems to be OK for a VirtualFree argument */
1764 /* to span regions, so we should be OK for now. */
1765 result = (ptr_t) VirtualAlloc(NULL, res_bytes,
1766 MEM_RESERVE | MEM_TOP_DOWN,
1767 PAGE_EXECUTE_READWRITE);
1768 if (HBLKDISPL(result) != 0) ABORT("Bad VirtualAlloc result");
1769 /* If I read the documentation correctly, this can */
1770 /* only happen if HBLKSIZE > 64k or not a power of 2. */
1771 if (GC_n_heap_bases >= MAX_HEAP_SECTS) ABORT("Too many heap sections");
1772 GC_heap_bases[GC_n_heap_bases] = result;
1773 GC_heap_lengths[GC_n_heap_bases] = 0;
1778 result = (ptr_t) VirtualAlloc(result, bytes,
1780 PAGE_EXECUTE_READWRITE);
1781 if (result != NULL) {
1782 if (HBLKDISPL(result) != 0) ABORT("Bad VirtualAlloc result");
1783 GC_heap_lengths[i] += bytes;
1792 /* For now, this only works on Win32/WinCE and some Unix-like */
1793 /* systems. If you have something else, don't define */
1795 /* We assume ANSI C to support this feature. */
1797 #if !defined(MSWIN32) && !defined(MSWINCE)
1800 #include <sys/mman.h>
1801 #include <sys/stat.h>
1802 #include <sys/types.h>
1806 /* Compute a page aligned starting address for the unmap */
1807 /* operation on a block of size bytes starting at start. */
1808 /* Return 0 if the block is too small to make this feasible. */
1809 ptr_t GC_unmap_start(ptr_t start, word bytes)
1811 ptr_t result = start;
1812 /* Round start to next page boundary. */
1813 result += GC_page_size - 1;
1814 result = (ptr_t)((word)result & ~(GC_page_size - 1));
1815 if (result + GC_page_size > start + bytes) return 0;
1819 /* Compute end address for an unmap operation on the indicated */
1821 ptr_t GC_unmap_end(ptr_t start, word bytes)
1823 ptr_t end_addr = start + bytes;
1824 end_addr = (ptr_t)((word)end_addr & ~(GC_page_size - 1));
1828 /* Under Win32/WinCE we commit (map) and decommit (unmap) */
1829 /* memory using VirtualAlloc and VirtualFree. These functions */
1830 /* work on individual allocations of virtual memory, made */
1831 /* previously using VirtualAlloc with the MEM_RESERVE flag. */
1832 /* The ranges we need to (de)commit may span several of these */
1833 /* allocations; therefore we use VirtualQuery to check */
1834 /* allocation lengths, and split up the range as necessary. */
1836 /* We assume that GC_remap is called on exactly the same range */
1837 /* as a previous call to GC_unmap. It is safe to consistently */
1838 /* round the endpoints in both places. */
1839 void GC_unmap(ptr_t start, word bytes)
1841 ptr_t start_addr = GC_unmap_start(start, bytes);
1842 ptr_t end_addr = GC_unmap_end(start, bytes);
1843 word len = end_addr - start_addr;
1844 if (0 == start_addr) return;
1845 # if defined(MSWIN32) || defined(MSWINCE)
1847 MEMORY_BASIC_INFORMATION mem_info;
1849 if (VirtualQuery(start_addr, &mem_info, sizeof(mem_info))
1850 != sizeof(mem_info))
1851 ABORT("Weird VirtualQuery result");
1852 free_len = (len < mem_info.RegionSize) ? len : mem_info.RegionSize;
1853 if (!VirtualFree(start_addr, free_len, MEM_DECOMMIT))
1854 ABORT("VirtualFree failed");
1855 GC_unmapped_bytes += free_len;
1856 start_addr += free_len;
1860 /* We immediately remap it to prevent an intervening mmap from */
1861 /* accidentally grabbing the same address space. */
1864 result = mmap(start_addr, len, PROT_NONE,
1865 MAP_PRIVATE | MAP_FIXED | OPT_MAP_ANON,
1866 zero_fd, 0/* offset */);
1867 if (result != (void *)start_addr) ABORT("mmap(...PROT_NONE...) failed");
1869 GC_unmapped_bytes += len;
1874 void GC_remap(ptr_t start, word bytes)
1876 ptr_t start_addr = GC_unmap_start(start, bytes);
1877 ptr_t end_addr = GC_unmap_end(start, bytes);
1878 word len = end_addr - start_addr;
1880 # if defined(MSWIN32) || defined(MSWINCE)
1883 if (0 == start_addr) return;
1885 MEMORY_BASIC_INFORMATION mem_info;
1887 if (VirtualQuery(start_addr, &mem_info, sizeof(mem_info))
1888 != sizeof(mem_info))
1889 ABORT("Weird VirtualQuery result");
1890 alloc_len = (len < mem_info.RegionSize) ? len : mem_info.RegionSize;
1891 result = VirtualAlloc(start_addr, alloc_len,
1893 PAGE_EXECUTE_READWRITE);
1894 if (result != start_addr) {
1895 ABORT("VirtualAlloc remapping failed");
1897 GC_unmapped_bytes -= alloc_len;
1898 start_addr += alloc_len;
1902 /* It was already remapped with PROT_NONE. */
1905 if (0 == start_addr) return;
1906 result = mprotect(start_addr, len,
1907 PROT_READ | PROT_WRITE | OPT_PROT_EXEC);
1910 "Mprotect failed at 0x%lx (length %ld) with errno %ld\n",
1911 start_addr, len, errno);
1912 ABORT("Mprotect remapping failed");
1914 GC_unmapped_bytes -= len;
1918 /* Two adjacent blocks have already been unmapped and are about to */
1919 /* be merged. Unmap the whole block. This typically requires */
1920 /* that we unmap a small section in the middle that was not previously */
1921 /* unmapped due to alignment constraints. */
1922 void GC_unmap_gap(ptr_t start1, word bytes1, ptr_t start2, word bytes2)
1924 ptr_t start1_addr = GC_unmap_start(start1, bytes1);
1925 ptr_t end1_addr = GC_unmap_end(start1, bytes1);
1926 ptr_t start2_addr = GC_unmap_start(start2, bytes2);
1927 ptr_t end2_addr = GC_unmap_end(start2, bytes2);
1928 ptr_t start_addr = end1_addr;
1929 ptr_t end_addr = start2_addr;
1931 GC_ASSERT(start1 + bytes1 == start2);
1932 if (0 == start1_addr) start_addr = GC_unmap_start(start1, bytes1 + bytes2);
1933 if (0 == start2_addr) end_addr = GC_unmap_end(start1, bytes1 + bytes2);
1934 if (0 == start_addr) return;
1935 len = end_addr - start_addr;
1936 # if defined(MSWIN32) || defined(MSWINCE)
1938 MEMORY_BASIC_INFORMATION mem_info;
1940 if (VirtualQuery(start_addr, &mem_info, sizeof(mem_info))
1941 != sizeof(mem_info))
1942 ABORT("Weird VirtualQuery result");
1943 free_len = (len < mem_info.RegionSize) ? len : mem_info.RegionSize;
1944 if (!VirtualFree(start_addr, free_len, MEM_DECOMMIT))
1945 ABORT("VirtualFree failed");
1946 GC_unmapped_bytes += free_len;
1947 start_addr += free_len;
1951 if (len != 0 && munmap(start_addr, len) != 0) ABORT("munmap failed");
1952 GC_unmapped_bytes += len;
1956 #endif /* USE_MUNMAP */
1958 /* Routine for pushing any additional roots. In THREADS */
1959 /* environment, this is also responsible for marking from */
1960 /* thread stacks. */
1962 void (*GC_push_other_roots)() = 0;
1966 PCR_ERes GC_push_thread_stack(PCR_Th_T *t, PCR_Any dummy)
1968 struct PCR_ThCtl_TInfoRep info;
1971 info.ti_stkLow = info.ti_stkHi = 0;
1972 result = PCR_ThCtl_GetInfo(t, &info);
1973 GC_push_all_stack((ptr_t)(info.ti_stkLow), (ptr_t)(info.ti_stkHi));
1977 /* Push the contents of an old object. We treat this as stack */
1978 /* data only becasue that makes it robust against mark stack */
1980 PCR_ERes GC_push_old_obj(void *p, size_t size, PCR_Any data)
1982 GC_push_all_stack((ptr_t)p, (ptr_t)p + size);
1983 return(PCR_ERes_okay);
1987 void GC_default_push_other_roots GC_PROTO((void))
1989 /* Traverse data allocated by previous memory managers. */
1991 extern struct PCR_MM_ProcsRep * GC_old_allocator;
1993 if ((*(GC_old_allocator->mmp_enumerate))(PCR_Bool_false,
1996 ABORT("Old object enumeration failed");
1999 /* Traverse all thread stacks. */
2001 PCR_ThCtl_ApplyToAllOtherThreads(GC_push_thread_stack,0))
2002 || PCR_ERes_IsErr(GC_push_thread_stack(PCR_Th_CurrThread(), 0))) {
2003 ABORT("Thread stack marking failed\n");
2011 # ifdef ALL_INTERIOR_POINTERS
2015 void GC_push_thread_structures GC_PROTO((void))
2017 /* Not our responsibibility. */
2020 extern void ThreadF__ProcessStacks();
2022 void GC_push_thread_stack(start, stop)
2025 GC_push_all_stack((ptr_t)start, (ptr_t)stop + sizeof(word));
2028 /* Push routine with M3 specific calling convention. */
2029 GC_m3_push_root(dummy1, p, dummy2, dummy3)
2031 ptr_t dummy1, dummy2;
2036 GC_PUSH_ONE_STACK(q, p);
2039 /* M3 set equivalent to RTHeap.TracedRefTypes */
2040 typedef struct { int elts[1]; } RefTypeSet;
2041 RefTypeSet GC_TracedRefTypes = {{0x1}};
2043 void GC_default_push_other_roots GC_PROTO((void))
2045 /* Use the M3 provided routine for finding static roots. */
2046 /* This is a bit dubious, since it presumes no C roots. */
2047 /* We handle the collector roots explicitly in GC_push_roots */
2048 RTMain__GlobalMapProc(GC_m3_push_root, 0, GC_TracedRefTypes);
2049 if (GC_words_allocd > 0) {
2050 ThreadF__ProcessStacks(GC_push_thread_stack);
2052 /* Otherwise this isn't absolutely necessary, and we have */
2053 /* startup ordering problems. */
2056 # endif /* SRC_M3 */
2058 # if defined(GC_SOLARIS_THREADS) || defined(GC_PTHREADS) || \
2059 defined(GC_WIN32_THREADS)
2061 extern void GC_push_all_stacks();
2063 void GC_default_push_other_roots GC_PROTO((void))
2065 GC_push_all_stacks();
2068 # endif /* GC_SOLARIS_THREADS || GC_PTHREADS */
2070 void (*GC_push_other_roots) GC_PROTO((void)) = GC_default_push_other_roots;
2072 #endif /* THREADS */
2075 * Routines for accessing dirty bits on virtual pages.
2076 * We plan to eventually implement four strategies for doing so:
2077 * DEFAULT_VDB: A simple dummy implementation that treats every page
2078 * as possibly dirty. This makes incremental collection
2079 * useless, but the implementation is still correct.
2080 * PCR_VDB: Use PPCRs virtual dirty bit facility.
2081 * PROC_VDB: Use the /proc facility for reading dirty bits. Only
2082 * works under some SVR4 variants. Even then, it may be
2083 * too slow to be entirely satisfactory. Requires reading
2084 * dirty bits for entire address space. Implementations tend
2085 * to assume that the client is a (slow) debugger.
2086 * MPROTECT_VDB:Protect pages and then catch the faults to keep track of
2087 * dirtied pages. The implementation (and implementability)
2088 * is highly system dependent. This usually fails when system
2089 * calls write to a protected page. We prevent the read system
2090 * call from doing so. It is the clients responsibility to
2091 * make sure that other system calls are similarly protected
2092 * or write only to the stack.
2094 GC_bool GC_dirty_maintained = FALSE;
2098 /* All of the following assume the allocation lock is held, and */
2099 /* signals are disabled. */
2101 /* The client asserts that unallocated pages in the heap are never */
2104 /* Initialize virtual dirty bit implementation. */
2105 void GC_dirty_init()
2108 GC_printf0("Initializing DEFAULT_VDB...\n");
2110 GC_dirty_maintained = TRUE;
2113 /* Retrieve system dirty bits for heap to a local buffer. */
2114 /* Restore the systems notion of which pages are dirty. */
2115 void GC_read_dirty()
2118 /* Is the HBLKSIZE sized page at h marked dirty in the local buffer? */
2119 /* If the actual page size is different, this returns TRUE if any */
2120 /* of the pages overlapping h are dirty. This routine may err on the */
2121 /* side of labelling pages as dirty (and this implementation does). */
2123 GC_bool GC_page_was_dirty(h)
2130 * The following two routines are typically less crucial. They matter
2131 * most with large dynamic libraries, or if we can't accurately identify
2132 * stacks, e.g. under Solaris 2.X. Otherwise the following default
2133 * versions are adequate.
2136 /* Could any valid GC heap pointer ever have been written to this page? */
2138 GC_bool GC_page_was_ever_dirty(h)
2144 /* Reset the n pages starting at h to "was never dirty" status. */
2145 void GC_is_fresh(h, n)
2152 /* I) hints that [h, h+nblocks) is about to be written. */
2153 /* II) guarantees that protection is removed. */
2154 /* (I) may speed up some dirty bit implementations. */
2155 /* (II) may be essential if we need to ensure that */
2156 /* pointer-free system call buffers in the heap are */
2157 /* not protected. */
2159 void GC_remove_protection(h, nblocks, is_ptrfree)
2166 # endif /* DEFAULT_VDB */
2169 # ifdef MPROTECT_VDB
2172 * See DEFAULT_VDB for interface descriptions.
2176 * This implementation maintains dirty bits itself by catching write
2177 * faults and keeping track of them. We assume nobody else catches
2178 * SIGBUS or SIGSEGV. We assume no write faults occur in system calls.
2179 * This means that clients must ensure that system calls don't write
2180 * to the write-protected heap. Probably the best way to do this is to
2181 * ensure that system calls write at most to POINTERFREE objects in the
2182 * heap, and do even that only if we are on a platform on which those
2183 * are not protected. Another alternative is to wrap system calls
2184 * (see example for read below), but the current implementation holds
2185 * a lock across blocking calls, making it problematic for multithreaded
2187 * We assume the page size is a multiple of HBLKSIZE.
2188 * We prefer them to be the same. We avoid protecting POINTERFREE
2189 * objects only if they are the same.
2192 # if !defined(MSWIN32) && !defined(MSWINCE) && !defined(DARWIN)
2194 # include <sys/mman.h>
2195 # include <signal.h>
2196 # include <sys/syscall.h>
2198 # define PROTECT(addr, len) \
2199 if (mprotect((caddr_t)(addr), (size_t)(len), \
2200 PROT_READ | OPT_PROT_EXEC) < 0) { \
2201 ABORT("mprotect failed"); \
2203 # define UNPROTECT(addr, len) \
2204 if (mprotect((caddr_t)(addr), (size_t)(len), \
2205 PROT_WRITE | PROT_READ | OPT_PROT_EXEC ) < 0) { \
2206 ABORT("un-mprotect failed"); \
2212 /* Using vm_protect (mach syscall) over mprotect (BSD syscall) seems to
2213 decrease the likelihood of some of the problems described below. */
2214 #include <mach/vm_map.h>
2215 static mach_port_t GC_task_self;
2216 #define PROTECT(addr,len) \
2217 if(vm_protect(GC_task_self,(vm_address_t)(addr),(vm_size_t)(len), \
2218 FALSE,VM_PROT_READ) != KERN_SUCCESS) { \
2219 ABORT("vm_portect failed"); \
2221 #define UNPROTECT(addr,len) \
2222 if(vm_protect(GC_task_self,(vm_address_t)(addr),(vm_size_t)(len), \
2223 FALSE,VM_PROT_READ|VM_PROT_WRITE) != KERN_SUCCESS) { \
2224 ABORT("vm_portect failed"); \
2229 # include <signal.h>
2232 static DWORD protect_junk;
2233 # define PROTECT(addr, len) \
2234 if (!VirtualProtect((addr), (len), PAGE_EXECUTE_READ, \
2236 DWORD last_error = GetLastError(); \
2237 GC_printf1("Last error code: %lx\n", last_error); \
2238 ABORT("VirtualProtect failed"); \
2240 # define UNPROTECT(addr, len) \
2241 if (!VirtualProtect((addr), (len), PAGE_EXECUTE_READWRITE, \
2243 ABORT("un-VirtualProtect failed"); \
2245 # endif /* !DARWIN */
2246 # endif /* MSWIN32 || MSWINCE || DARWIN */
2248 #if defined(SUNOS4) || (defined(FREEBSD) && !defined(SUNOS5SIGS))
2249 typedef void (* SIG_PF)();
2250 #endif /* SUNOS4 || (FREEBSD && !SUNOS5SIGS) */
2252 #if defined(SUNOS5SIGS) || defined(OSF1) || defined(LINUX) \
2255 typedef void (* SIG_PF)(int);
2257 typedef void (* SIG_PF)();
2259 #endif /* SUNOS5SIGS || OSF1 || LINUX || HURD */
2261 #if defined(MSWIN32)
2262 typedef LPTOP_LEVEL_EXCEPTION_FILTER SIG_PF;
2264 # define SIG_DFL (LPTOP_LEVEL_EXCEPTION_FILTER) (-1)
2266 #if defined(MSWINCE)
2267 typedef LONG (WINAPI *SIG_PF)(struct _EXCEPTION_POINTERS *);
2269 # define SIG_DFL (SIG_PF) (-1)
2272 #if defined(IRIX5) || defined(OSF1) || defined(HURD)
2273 typedef void (* REAL_SIG_PF)(int, int, struct sigcontext *);
2274 #endif /* IRIX5 || OSF1 || HURD */
2276 #if defined(SUNOS5SIGS)
2277 # if defined(HPUX) || defined(FREEBSD)
2278 # define SIGINFO_T siginfo_t
2280 # define SIGINFO_T struct siginfo
2283 typedef void (* REAL_SIG_PF)(int, SIGINFO_T *, void *);
2285 typedef void (* REAL_SIG_PF)();
2287 #endif /* SUNOS5SIGS */
2290 # if __GLIBC__ > 2 || __GLIBC__ == 2 && __GLIBC_MINOR__ >= 2
2291 typedef struct sigcontext s_c;
2292 # else /* glibc < 2.2 */
2293 # include <linux/version.h>
2294 # if (LINUX_VERSION_CODE >= 0x20100) && !defined(M68K) || defined(ALPHA) || defined(ARM32)
2295 typedef struct sigcontext s_c;
2297 typedef struct sigcontext_struct s_c;
2299 # endif /* glibc < 2.2 */
2300 # if defined(ALPHA) || defined(M68K)
2301 typedef void (* REAL_SIG_PF)(int, int, s_c *);
2303 # if defined(IA64) || defined(HP_PA)
2304 typedef void (* REAL_SIG_PF)(int, siginfo_t *, s_c *);
2306 typedef void (* REAL_SIG_PF)(int, s_c);
2310 /* Retrieve fault address from sigcontext structure by decoding */
2312 char * get_fault_addr(s_c *sc) {
2316 instr = *((unsigned *)(sc->sc_pc));
2317 faultaddr = sc->sc_regs[(instr >> 16) & 0x1f];
2318 faultaddr += (word) (((int)instr << 16) >> 16);
2319 return (char *)faultaddr;
2321 # endif /* !ALPHA */
2325 SIG_PF GC_old_bus_handler;
2326 SIG_PF GC_old_segv_handler; /* Also old MSWIN32 ACCESS_VIOLATION filter */
2327 #endif /* !DARWIN */
2329 #if defined(THREADS)
2330 /* We need to lock around the bitmap update in the write fault handler */
2331 /* in order to avoid the risk of losing a bit. We do this with a */
2332 /* test-and-set spin lock if we know how to do that. Otherwise we */
2333 /* check whether we are already in the handler and use the dumb but */
2334 /* safe fallback algorithm of setting all bits in the word. */
2335 /* Contention should be very rare, so we do the minimum to handle it */
2337 #ifdef GC_TEST_AND_SET_DEFINED
2338 static VOLATILE unsigned int fault_handler_lock = 0;
2339 void async_set_pht_entry_from_index(VOLATILE page_hash_table db, int index) {
2340 while (GC_test_and_set(&fault_handler_lock)) {}
2341 /* Could also revert to set_pht_entry_from_index_safe if initial */
2342 /* GC_test_and_set fails. */
2343 set_pht_entry_from_index(db, index);
2344 GC_clear(&fault_handler_lock);
2346 #else /* !GC_TEST_AND_SET_DEFINED */
2347 /* THIS IS INCORRECT! The dirty bit vector may be temporarily wrong, */
2348 /* just before we notice the conflict and correct it. We may end up */
2349 /* looking at it while it's wrong. But this requires contention */
2350 /* exactly when a GC is triggered, which seems far less likely to */
2351 /* fail than the old code, which had no reported failures. Thus we */
2352 /* leave it this way while we think of something better, or support */
2353 /* GC_test_and_set on the remaining platforms. */
2354 static VOLATILE word currently_updating = 0;
2355 void async_set_pht_entry_from_index(VOLATILE page_hash_table db, int index) {
2356 unsigned int update_dummy;
2357 currently_updating = (word)(&update_dummy);
2358 set_pht_entry_from_index(db, index);
2359 /* If we get contention in the 10 or so instruction window here, */
2360 /* and we get stopped by a GC between the two updates, we lose! */
2361 if (currently_updating != (word)(&update_dummy)) {
2362 set_pht_entry_from_index_safe(db, index);
2363 /* We claim that if two threads concurrently try to update the */
2364 /* dirty bit vector, the first one to execute UPDATE_START */
2365 /* will see it changed when UPDATE_END is executed. (Note that */
2366 /* &update_dummy must differ in two distinct threads.) It */
2367 /* will then execute set_pht_entry_from_index_safe, thus */
2368 /* returning us to a safe state, though not soon enough. */
2371 #endif /* !GC_TEST_AND_SET_DEFINED */
2372 #else /* !THREADS */
2373 # define async_set_pht_entry_from_index(db, index) \
2374 set_pht_entry_from_index(db, index)
2375 #endif /* !THREADS */
2378 #if !defined(DARWIN)
2379 # if defined (SUNOS4) || (defined(FREEBSD) && !defined(SUNOS5SIGS))
2380 void GC_write_fault_handler(sig, code, scp, addr)
2382 struct sigcontext *scp;
2385 # define SIG_OK (sig == SIGSEGV || sig == SIGBUS)
2386 # define CODE_OK (FC_CODE(code) == FC_PROT \
2387 || (FC_CODE(code) == FC_OBJERR \
2388 && FC_ERRNO(code) == FC_PROT))
2391 # define SIG_OK (sig == SIGBUS)
2392 # define CODE_OK (code == BUS_PAGE_FAULT)
2394 # endif /* SUNOS4 || (FREEBSD && !SUNOS5SIGS) */
2396 # if defined(IRIX5) || defined(OSF1) || defined(HURD)
2398 void GC_write_fault_handler(int sig, int code, struct sigcontext *scp)
2400 # define SIG_OK (sig == SIGSEGV)
2401 # define CODE_OK (code == 2 /* experimentally determined */)
2404 # define SIG_OK (sig == SIGSEGV)
2405 # define CODE_OK (code == EACCES)
2408 # define SIG_OK (sig == SIGBUS || sig == SIGSEGV)
2409 # define CODE_OK TRUE
2411 # endif /* IRIX5 || OSF1 || HURD */
2414 # if defined(ALPHA) || defined(M68K)
2415 void GC_write_fault_handler(int sig, int code, s_c * sc)
2417 # if defined(IA64) || defined(HP_PA)
2418 void GC_write_fault_handler(int sig, siginfo_t * si, s_c * scp)
2421 void GC_write_fault_handler(int sig, int a2, int a3, int a4, s_c sc)
2423 void GC_write_fault_handler(int sig, s_c sc)
2427 # define SIG_OK (sig == SIGSEGV)
2428 # define CODE_OK TRUE
2429 /* Empirically c.trapno == 14, on IA32, but is that useful? */
2430 /* Should probably consider alignment issues on other */
2431 /* architectures. */
2434 # if defined(SUNOS5SIGS)
2436 void GC_write_fault_handler(int sig, SIGINFO_T *scp, void * context)
2438 void GC_write_fault_handler(sig, scp, context)
2444 # define SIG_OK (sig == SIGSEGV || sig == SIGBUS)
2445 # define CODE_OK (scp -> si_code == SEGV_ACCERR) \
2446 || (scp -> si_code == BUS_ADRERR) \
2447 || (scp -> si_code == BUS_UNKNOWN) \
2448 || (scp -> si_code == SEGV_UNKNOWN) \
2449 || (scp -> si_code == BUS_OBJERR)
2452 # define SIG_OK (sig == SIGBUS)
2453 # define CODE_OK (scp -> si_code == BUS_PAGE_FAULT)
2455 # define SIG_OK (sig == SIGSEGV)
2456 # define CODE_OK (scp -> si_code == SEGV_ACCERR)
2459 # endif /* SUNOS5SIGS */
2461 # if defined(MSWIN32) || defined(MSWINCE)
2462 LONG WINAPI GC_write_fault_handler(struct _EXCEPTION_POINTERS *exc_info)
2463 # define SIG_OK (exc_info -> ExceptionRecord -> ExceptionCode == \
2464 STATUS_ACCESS_VIOLATION)
2465 # define CODE_OK (exc_info -> ExceptionRecord -> ExceptionInformation[0] == 1)
2467 # endif /* MSWIN32 || MSWINCE */
2469 register unsigned i;
2471 char *addr = (char *) code;
2474 char * addr = (char *) (size_t) (scp -> sc_badvaddr);
2476 # if defined(OSF1) && defined(ALPHA)
2477 char * addr = (char *) (scp -> sc_traparg_a0);
2480 char * addr = (char *) (scp -> si_addr);
2483 # if defined(I386) || defined (X86_64)
2484 char * addr = (char *) (sc.cr2);
2489 struct sigcontext *scp = (struct sigcontext *)(sc);
2491 int format = (scp->sc_formatvec >> 12) & 0xf;
2492 unsigned long *framedata = (unsigned long *)(scp + 1);
2495 if (format == 0xa || format == 0xb) {
2498 } else if (format == 7) {
2501 if (framedata[1] & 0x08000000) {
2502 /* correct addr on misaligned access */
2503 ea = (ea+4095)&(~4095);
2505 } else if (format == 4) {
2508 if (framedata[1] & 0x08000000) {
2509 /* correct addr on misaligned access */
2510 ea = (ea+4095)&(~4095);
2516 char * addr = get_fault_addr(sc);
2518 # if defined(IA64) || defined(HP_PA)
2519 char * addr = si -> si_addr;
2520 /* I believe this is claimed to work on all platforms for */
2521 /* Linux 2.3.47 and later. Hopefully we don't have to */
2522 /* worry about earlier kernels on IA64. */
2524 # if defined(POWERPC)
2525 char * addr = (char *) (sc.regs->dar);
2528 char * addr = (char *)sc.fault_address;
2530 --> architecture not supported
2538 # if defined(MSWIN32) || defined(MSWINCE)
2539 char * addr = (char *) (exc_info -> ExceptionRecord
2540 -> ExceptionInformation[1]);
2541 # define sig SIGSEGV
2544 if (SIG_OK && CODE_OK) {
2545 register struct hblk * h =
2546 (struct hblk *)((word)addr & ~(GC_page_size-1));
2547 GC_bool in_allocd_block;
2550 /* Address is only within the correct physical page. */
2551 in_allocd_block = FALSE;
2552 for (i = 0; i < divHBLKSZ(GC_page_size); i++) {
2553 if (HDR(h+i) != 0) {
2554 in_allocd_block = TRUE;
2558 in_allocd_block = (HDR(addr) != 0);
2560 if (!in_allocd_block) {
2561 /* FIXME - We should make sure that we invoke the */
2562 /* old handler with the appropriate calling */
2563 /* sequence, which often depends on SA_SIGINFO. */
2565 /* Heap blocks now begin and end on page boundaries */
2568 if (sig == SIGSEGV) {
2569 old_handler = GC_old_segv_handler;
2571 old_handler = GC_old_bus_handler;
2573 if (old_handler == SIG_DFL) {
2574 # if !defined(MSWIN32) && !defined(MSWINCE)
2575 GC_err_printf1("Segfault at 0x%lx\n", addr);
2576 ABORT("Unexpected bus error or segmentation fault");
2578 return(EXCEPTION_CONTINUE_SEARCH);
2581 # if defined (SUNOS4) \
2582 || (defined(FREEBSD) && !defined(SUNOS5SIGS))
2583 (*old_handler) (sig, code, scp, addr);
2586 # if defined (SUNOS5SIGS)
2588 * FIXME: For FreeBSD, this code should check if the
2589 * old signal handler used the traditional BSD style and
2590 * if so call it using that style.
2592 (*(REAL_SIG_PF)old_handler) (sig, scp, context);
2595 # if defined (LINUX)
2596 # if defined(ALPHA) || defined(M68K)
2597 (*(REAL_SIG_PF)old_handler) (sig, code, sc);
2599 # if defined(IA64) || defined(HP_PA)
2600 (*(REAL_SIG_PF)old_handler) (sig, si, scp);
2602 (*(REAL_SIG_PF)old_handler) (sig, sc);
2607 # if defined (IRIX5) || defined(OSF1) || defined(HURD)
2608 (*(REAL_SIG_PF)old_handler) (sig, code, scp);
2612 return((*old_handler)(exc_info));
2616 UNPROTECT(h, GC_page_size);
2617 /* We need to make sure that no collection occurs between */
2618 /* the UNPROTECT and the setting of the dirty bit. Otherwise */
2619 /* a write by a third thread might go unnoticed. Reversing */
2620 /* the order is just as bad, since we would end up unprotecting */
2621 /* a page in a GC cycle during which it's not marked. */
2622 /* Currently we do this by disabling the thread stopping */
2623 /* signals while this handler is running. An alternative might */
2624 /* be to record the fact that we're about to unprotect, or */
2625 /* have just unprotected a page in the GC's thread structure, */
2626 /* and then to have the thread stopping code set the dirty */
2627 /* flag, if necessary. */
2628 for (i = 0; i < divHBLKSZ(GC_page_size); i++) {
2629 register int index = PHT_HASH(h+i);
2631 async_set_pht_entry_from_index(GC_dirty_pages, index);
2634 /* These reset the signal handler each time by default. */
2635 signal(SIGSEGV, (SIG_PF) GC_write_fault_handler);
2637 /* The write may not take place before dirty bits are read. */
2638 /* But then we'll fault again ... */
2639 # if defined(MSWIN32) || defined(MSWINCE)
2640 return(EXCEPTION_CONTINUE_EXECUTION);
2645 #if defined(MSWIN32) || defined(MSWINCE)
2646 return EXCEPTION_CONTINUE_SEARCH;
2648 GC_err_printf1("Segfault at 0x%lx\n", addr);
2649 ABORT("Unexpected bus error or segmentation fault");
2652 #endif /* !DARWIN */
2655 * We hold the allocation lock. We expect block h to be written
2656 * shortly. Ensure that all pages containing any part of the n hblks
2657 * starting at h are no longer protected. If is_ptrfree is false,
2658 * also ensure that they will subsequently appear to be dirty.
2660 void GC_remove_protection(h, nblocks, is_ptrfree)
2665 struct hblk * h_trunc; /* Truncated to page boundary */
2666 struct hblk * h_end; /* Page boundary following block end */
2667 struct hblk * current;
2668 GC_bool found_clean;
2670 if (!GC_dirty_maintained) return;
2671 h_trunc = (struct hblk *)((word)h & ~(GC_page_size-1));
2672 h_end = (struct hblk *)(((word)(h + nblocks) + GC_page_size-1)
2673 & ~(GC_page_size-1));
2674 found_clean = FALSE;
2675 for (current = h_trunc; current < h_end; ++current) {
2676 int index = PHT_HASH(current);
2678 if (!is_ptrfree || current < h || current >= h + nblocks) {
2679 async_set_pht_entry_from_index(GC_dirty_pages, index);
2682 UNPROTECT(h_trunc, (ptr_t)h_end - (ptr_t)h_trunc);
2685 #if !defined(DARWIN)
2686 void GC_dirty_init()
2688 # if defined(SUNOS5SIGS) || defined(IRIX5) || defined(LINUX) || \
2689 defined(OSF1) || defined(HURD)
2690 struct sigaction act, oldact;
2691 /* We should probably specify SA_SIGINFO for Linux, and handle */
2692 /* the different architectures more uniformly. */
2693 # if defined(IRIX5) || defined(LINUX) || defined(OSF1) || defined(HURD)
2694 act.sa_flags = SA_RESTART;
2695 act.sa_handler = (SIG_PF)GC_write_fault_handler;
2697 act.sa_flags = SA_RESTART | SA_SIGINFO;
2698 act.sa_sigaction = GC_write_fault_handler;
2700 (void)sigemptyset(&act.sa_mask);
2702 /* Arrange to postpone SIG_SUSPEND while we're in a write fault */
2703 /* handler. This effectively makes the handler atomic w.r.t. */
2704 /* stopping the world for GC. */
2705 (void)sigaddset(&act.sa_mask, SIG_SUSPEND);
2706 # endif /* SIG_SUSPEND */
2709 GC_printf0("Inititalizing mprotect virtual dirty bit implementation\n");
2711 GC_dirty_maintained = TRUE;
2712 if (GC_page_size % HBLKSIZE != 0) {
2713 GC_err_printf0("Page size not multiple of HBLKSIZE\n");
2714 ABORT("Page size not multiple of HBLKSIZE");
2716 # if defined(SUNOS4) || (defined(FREEBSD) && !defined(SUNOS5SIGS))
2717 GC_old_bus_handler = signal(SIGBUS, GC_write_fault_handler);
2718 if (GC_old_bus_handler == SIG_IGN) {
2719 GC_err_printf0("Previously ignored bus error!?");
2720 GC_old_bus_handler = SIG_DFL;
2722 if (GC_old_bus_handler != SIG_DFL) {
2724 GC_err_printf0("Replaced other SIGBUS handler\n");
2728 # if defined(SUNOS4)
2729 GC_old_segv_handler = signal(SIGSEGV, (SIG_PF)GC_write_fault_handler);
2730 if (GC_old_segv_handler == SIG_IGN) {
2731 GC_err_printf0("Previously ignored segmentation violation!?");
2732 GC_old_segv_handler = SIG_DFL;
2734 if (GC_old_segv_handler != SIG_DFL) {
2736 GC_err_printf0("Replaced other SIGSEGV handler\n");
2740 # if (defined(SUNOS5SIGS) && !defined(FREEBSD)) || defined(IRIX5) \
2741 || defined(LINUX) || defined(OSF1) || defined(HURD)
2742 /* SUNOS5SIGS includes HPUX */
2743 # if defined(GC_IRIX_THREADS)
2744 sigaction(SIGSEGV, 0, &oldact);
2745 sigaction(SIGSEGV, &act, 0);
2748 int res = sigaction(SIGSEGV, &act, &oldact);
2749 if (res != 0) ABORT("Sigaction failed");
2752 # if defined(_sigargs) || defined(HURD) || !defined(SA_SIGINFO)
2753 /* This is Irix 5.x, not 6.x. Irix 5.x does not have */
2755 GC_old_segv_handler = oldact.sa_handler;
2756 # else /* Irix 6.x or SUNOS5SIGS or LINUX */
2757 if (oldact.sa_flags & SA_SIGINFO) {
2758 GC_old_segv_handler = (SIG_PF)(oldact.sa_sigaction);
2760 GC_old_segv_handler = oldact.sa_handler;
2763 if (GC_old_segv_handler == SIG_IGN) {
2764 GC_err_printf0("Previously ignored segmentation violation!?");
2765 GC_old_segv_handler = SIG_DFL;
2767 if (GC_old_segv_handler != SIG_DFL) {
2769 GC_err_printf0("Replaced other SIGSEGV handler\n");
2772 # endif /* (SUNOS5SIGS && !FREEBSD) || IRIX5 || LINUX || OSF1 || HURD */
2773 # if defined(HPUX) || defined(LINUX) || defined(HURD) \
2774 || (defined(FREEBSD) && defined(SUNOS5SIGS))
2775 sigaction(SIGBUS, &act, &oldact);
2776 GC_old_bus_handler = oldact.sa_handler;
2777 if (GC_old_bus_handler == SIG_IGN) {
2778 GC_err_printf0("Previously ignored bus error!?");
2779 GC_old_bus_handler = SIG_DFL;
2781 if (GC_old_bus_handler != SIG_DFL) {
2783 GC_err_printf0("Replaced other SIGBUS handler\n");
2786 # endif /* HPUX || LINUX || HURD || (FREEBSD && SUNOS5SIGS) */
2787 # if defined(MSWIN32)
2788 GC_old_segv_handler = SetUnhandledExceptionFilter(GC_write_fault_handler);
2789 if (GC_old_segv_handler != NULL) {
2791 GC_err_printf0("Replaced other UnhandledExceptionFilter\n");
2794 GC_old_segv_handler = SIG_DFL;
2798 #endif /* !DARWIN */
2800 int GC_incremental_protection_needs()
2802 if (GC_page_size == HBLKSIZE) {
2803 return GC_PROTECTS_POINTER_HEAP;
2805 return GC_PROTECTS_POINTER_HEAP | GC_PROTECTS_PTRFREE_HEAP;
2809 #define HAVE_INCREMENTAL_PROTECTION_NEEDS
2811 #define IS_PTRFREE(hhdr) ((hhdr)->hb_descr == 0)
2813 #define PAGE_ALIGNED(x) !((word)(x) & (GC_page_size - 1))
2814 void GC_protect_heap()
2818 struct hblk * current;
2819 struct hblk * current_start; /* Start of block to be protected. */
2820 struct hblk * limit;
2822 GC_bool protect_all =
2823 (0 != (GC_incremental_protection_needs() & GC_PROTECTS_PTRFREE_HEAP));
2824 for (i = 0; i < GC_n_heap_sects; i++) {
2825 start = GC_heap_sects[i].hs_start;
2826 len = GC_heap_sects[i].hs_bytes;
2828 PROTECT(start, len);
2830 GC_ASSERT(PAGE_ALIGNED(len))
2831 GC_ASSERT(PAGE_ALIGNED(start))
2832 current_start = current = (struct hblk *)start;
2833 limit = (struct hblk *)(start + len);
2834 while (current < limit) {
2839 GC_ASSERT(PAGE_ALIGNED(current));
2840 GET_HDR(current, hhdr);
2841 if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
2842 /* This can happen only if we're at the beginning of a */
2843 /* heap segment, and a block spans heap segments. */
2844 /* We will handle that block as part of the preceding */
2846 GC_ASSERT(current_start == current);
2847 current_start = ++current;
2850 if (HBLK_IS_FREE(hhdr)) {
2851 GC_ASSERT(PAGE_ALIGNED(hhdr -> hb_sz));
2852 nhblks = divHBLKSZ(hhdr -> hb_sz);
2853 is_ptrfree = TRUE; /* dirty on alloc */
2855 nhblks = OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz);
2856 is_ptrfree = IS_PTRFREE(hhdr);
2859 if (current_start < current) {
2860 PROTECT(current_start, (ptr_t)current - (ptr_t)current_start);
2862 current_start = (current += nhblks);
2867 if (current_start < current) {
2868 PROTECT(current_start, (ptr_t)current - (ptr_t)current_start);
2874 /* We assume that either the world is stopped or its OK to lose dirty */
2875 /* bits while this is happenning (as in GC_enable_incremental). */
2876 void GC_read_dirty()
2878 BCOPY((word *)GC_dirty_pages, GC_grungy_pages,
2879 (sizeof GC_dirty_pages));
2880 BZERO((word *)GC_dirty_pages, (sizeof GC_dirty_pages));
2884 GC_bool GC_page_was_dirty(h)
2887 register word index = PHT_HASH(h);
2889 return(HDR(h) == 0 || get_pht_entry_from_index(GC_grungy_pages, index));
2893 * Acquiring the allocation lock here is dangerous, since this
2894 * can be called from within GC_call_with_alloc_lock, and the cord
2895 * package does so. On systems that allow nested lock acquisition, this
2897 * On other systems, SET_LOCK_HOLDER and friends must be suitably defined.
2900 static GC_bool syscall_acquired_lock = FALSE; /* Protected by GC lock. */
2902 void GC_begin_syscall()
2904 if (!I_HOLD_LOCK()) {
2906 syscall_acquired_lock = TRUE;
2910 void GC_end_syscall()
2912 if (syscall_acquired_lock) {
2913 syscall_acquired_lock = FALSE;
2918 void GC_unprotect_range(addr, len)
2922 struct hblk * start_block;
2923 struct hblk * end_block;
2924 register struct hblk *h;
2927 if (!GC_dirty_maintained) return;
2928 obj_start = GC_base(addr);
2929 if (obj_start == 0) return;
2930 if (GC_base(addr + len - 1) != obj_start) {
2931 ABORT("GC_unprotect_range(range bigger than object)");
2933 start_block = (struct hblk *)((word)addr & ~(GC_page_size - 1));
2934 end_block = (struct hblk *)((word)(addr + len - 1) & ~(GC_page_size - 1));
2935 end_block += GC_page_size/HBLKSIZE - 1;
2936 for (h = start_block; h <= end_block; h++) {
2937 register word index = PHT_HASH(h);
2939 async_set_pht_entry_from_index(GC_dirty_pages, index);
2941 UNPROTECT(start_block,
2942 ((ptr_t)end_block - (ptr_t)start_block) + HBLKSIZE);
2947 /* We no longer wrap read by default, since that was causing too many */
2948 /* problems. It is preferred that the client instead avoids writing */
2949 /* to the write-protected heap with a system call. */
2950 /* This still serves as sample code if you do want to wrap system calls.*/
2952 #if !defined(MSWIN32) && !defined(MSWINCE) && !defined(GC_USE_LD_WRAP)
2953 /* Replacement for UNIX system call. */
2954 /* Other calls that write to the heap should be handled similarly. */
2955 /* Note that this doesn't work well for blocking reads: It will hold */
2956 /* the allocation lock for the entire duration of the call. Multithreaded */
2957 /* clients should really ensure that it won't block, either by setting */
2958 /* the descriptor nonblocking, or by calling select or poll first, to */
2959 /* make sure that input is available. */
2960 /* Another, preferred alternative is to ensure that system calls never */
2961 /* write to the protected heap (see above). */
2962 # if defined(__STDC__) && !defined(SUNOS4)
2963 # include <unistd.h>
2964 # include <sys/uio.h>
2965 ssize_t read(int fd, void *buf, size_t nbyte)
2968 int read(fd, buf, nbyte)
2970 int GC_read(fd, buf, nbyte)
2980 GC_unprotect_range(buf, (word)nbyte);
2981 # if defined(IRIX5) || defined(GC_LINUX_THREADS)
2982 /* Indirect system call may not always be easily available. */
2983 /* We could call _read, but that would interfere with the */
2984 /* libpthread interception of read. */
2985 /* On Linux, we have to be careful with the linuxthreads */
2986 /* read interception. */
2991 iov.iov_len = nbyte;
2992 result = readv(fd, &iov, 1);
2996 result = __read(fd, buf, nbyte);
2998 /* The two zero args at the end of this list are because one
2999 IA-64 syscall() implementation actually requires six args
3000 to be passed, even though they aren't always used. */
3001 result = syscall(SYS_read, fd, buf, nbyte, 0, 0);
3007 #endif /* !MSWIN32 && !MSWINCE && !GC_LINUX_THREADS */
3009 #if defined(GC_USE_LD_WRAP) && !defined(THREADS)
3010 /* We use the GNU ld call wrapping facility. */
3011 /* This requires that the linker be invoked with "--wrap read". */
3012 /* This can be done by passing -Wl,"--wrap read" to gcc. */
3013 /* I'm not sure that this actually wraps whatever version of read */
3014 /* is called by stdio. That code also mentions __read. */
3015 # include <unistd.h>
3016 ssize_t __wrap_read(int fd, void *buf, size_t nbyte)
3021 GC_unprotect_range(buf, (word)nbyte);
3022 result = __real_read(fd, buf, nbyte);
3027 /* We should probably also do this for __read, or whatever stdio */
3028 /* actually calls. */
3034 GC_bool GC_page_was_ever_dirty(h)
3040 /* Reset the n pages starting at h to "was never dirty" status. */
3042 void GC_is_fresh(h, n)
3048 # endif /* MPROTECT_VDB */
3053 * See DEFAULT_VDB for interface descriptions.
3057 * This implementaion assumes a Solaris 2.X like /proc pseudo-file-system
3058 * from which we can read page modified bits. This facility is far from
3059 * optimal (e.g. we would like to get the info for only some of the
3060 * address space), but it avoids intercepting system calls.
3064 #include <sys/types.h>
3065 #include <sys/signal.h>
3066 #include <sys/fault.h>
3067 #include <sys/syscall.h>
3068 #include <sys/procfs.h>
3069 #include <sys/stat.h>
3071 #define INITIAL_BUF_SZ 4096
3072 word GC_proc_buf_size = INITIAL_BUF_SZ;
3075 #ifdef GC_SOLARIS_THREADS
3076 /* We don't have exact sp values for threads. So we count on */
3077 /* occasionally declaring stack pages to be fresh. Thus we */
3078 /* need a real implementation of GC_is_fresh. We can't clear */
3079 /* entries in GC_written_pages, since that would declare all */
3080 /* pages with the given hash address to be fresh. */
3081 # define MAX_FRESH_PAGES 8*1024 /* Must be power of 2 */
3082 struct hblk ** GC_fresh_pages; /* A direct mapped cache. */
3083 /* Collisions are dropped. */
3085 # define FRESH_PAGE_SLOT(h) (divHBLKSZ((word)(h)) & (MAX_FRESH_PAGES-1))
3086 # define ADD_FRESH_PAGE(h) \
3087 GC_fresh_pages[FRESH_PAGE_SLOT(h)] = (h)
3088 # define PAGE_IS_FRESH(h) \
3089 (GC_fresh_pages[FRESH_PAGE_SLOT(h)] == (h) && (h) != 0)
3092 /* Add all pages in pht2 to pht1 */
3093 void GC_or_pages(pht1, pht2)
3094 page_hash_table pht1, pht2;
3098 for (i = 0; i < PHT_SIZE; i++) pht1[i] |= pht2[i];
3103 void GC_dirty_init()
3108 GC_dirty_maintained = TRUE;
3109 if (GC_words_allocd != 0 || GC_words_allocd_before_gc != 0) {
3112 for (i = 0; i < PHT_SIZE; i++) GC_written_pages[i] = (word)(-1);
3114 GC_printf1("Allocated words:%lu:all pages may have been written\n",
3116 (GC_words_allocd + GC_words_allocd_before_gc));
3119 sprintf(buf, "/proc/%d", getpid());
3120 fd = open(buf, O_RDONLY);
3122 ABORT("/proc open failed");
3124 GC_proc_fd = syscall(SYS_ioctl, fd, PIOCOPENPD, 0);
3126 syscall(SYS_fcntl, GC_proc_fd, F_SETFD, FD_CLOEXEC);
3127 if (GC_proc_fd < 0) {
3128 ABORT("/proc ioctl failed");
3130 GC_proc_buf = GC_scratch_alloc(GC_proc_buf_size);
3131 # ifdef GC_SOLARIS_THREADS
3132 GC_fresh_pages = (struct hblk **)
3133 GC_scratch_alloc(MAX_FRESH_PAGES * sizeof (struct hblk *));
3134 if (GC_fresh_pages == 0) {
3135 GC_err_printf0("No space for fresh pages\n");
3138 BZERO(GC_fresh_pages, MAX_FRESH_PAGES * sizeof (struct hblk *));
3142 /* Ignore write hints. They don't help us here. */
3144 void GC_remove_protection(h, nblocks, is_ptrfree)
3151 #ifdef GC_SOLARIS_THREADS
3152 # define READ(fd,buf,nbytes) syscall(SYS_read, fd, buf, nbytes)
3154 # define READ(fd,buf,nbytes) read(fd, buf, nbytes)
3157 void GC_read_dirty()
3159 unsigned long ps, np;
3162 struct prasmap * map;
3164 ptr_t current_addr, limit;
3168 BZERO(GC_grungy_pages, (sizeof GC_grungy_pages));
3171 if (READ(GC_proc_fd, bufp, GC_proc_buf_size) <= 0) {
3173 GC_printf1("/proc read failed: GC_proc_buf_size = %lu\n",
3177 /* Retry with larger buffer. */
3178 word new_size = 2 * GC_proc_buf_size;
3179 char * new_buf = GC_scratch_alloc(new_size);
3182 GC_proc_buf = bufp = new_buf;
3183 GC_proc_buf_size = new_size;
3185 if (READ(GC_proc_fd, bufp, GC_proc_buf_size) <= 0) {
3186 WARN("Insufficient space for /proc read\n", 0);
3188 memset(GC_grungy_pages, 0xff, sizeof (page_hash_table));
3189 memset(GC_written_pages, 0xff, sizeof(page_hash_table));
3190 # ifdef GC_SOLARIS_THREADS
3191 BZERO(GC_fresh_pages,
3192 MAX_FRESH_PAGES * sizeof (struct hblk *));
3198 /* Copy dirty bits into GC_grungy_pages */
3199 nmaps = ((struct prpageheader *)bufp) -> pr_nmap;
3200 /* printf( "nmaps = %d, PG_REFERENCED = %d, PG_MODIFIED = %d\n",
3201 nmaps, PG_REFERENCED, PG_MODIFIED); */
3202 bufp = bufp + sizeof(struct prpageheader);
3203 for (i = 0; i < nmaps; i++) {
3204 map = (struct prasmap *)bufp;
3205 vaddr = (ptr_t)(map -> pr_vaddr);
3206 ps = map -> pr_pagesize;
3207 np = map -> pr_npage;
3208 /* printf("vaddr = 0x%X, ps = 0x%X, np = 0x%X\n", vaddr, ps, np); */
3209 limit = vaddr + ps * np;
3210 bufp += sizeof (struct prasmap);
3211 for (current_addr = vaddr;
3212 current_addr < limit; current_addr += ps){
3213 if ((*bufp++) & PG_MODIFIED) {
3214 register struct hblk * h = (struct hblk *) current_addr;
3216 while ((ptr_t)h < current_addr + ps) {
3217 register word index = PHT_HASH(h);
3219 set_pht_entry_from_index(GC_grungy_pages, index);
3220 # ifdef GC_SOLARIS_THREADS
3222 register int slot = FRESH_PAGE_SLOT(h);
3224 if (GC_fresh_pages[slot] == h) {
3225 GC_fresh_pages[slot] = 0;
3233 bufp += sizeof(long) - 1;
3234 bufp = (char *)((unsigned long)bufp & ~(sizeof(long)-1));
3236 /* Update GC_written_pages. */
3237 GC_or_pages(GC_written_pages, GC_grungy_pages);
3238 # ifdef GC_SOLARIS_THREADS
3239 /* Make sure that old stacks are considered completely clean */
3240 /* unless written again. */
3241 GC_old_stacks_are_fresh();
3247 GC_bool GC_page_was_dirty(h)
3250 register word index = PHT_HASH(h);
3251 register GC_bool result;
3253 result = get_pht_entry_from_index(GC_grungy_pages, index);
3254 # ifdef GC_SOLARIS_THREADS
3255 if (result && PAGE_IS_FRESH(h)) result = FALSE;
3256 /* This happens only if page was declared fresh since */
3257 /* the read_dirty call, e.g. because it's in an unused */
3258 /* thread stack. It's OK to treat it as clean, in */
3259 /* that case. And it's consistent with */
3260 /* GC_page_was_ever_dirty. */
3265 GC_bool GC_page_was_ever_dirty(h)
3268 register word index = PHT_HASH(h);
3269 register GC_bool result;
3271 result = get_pht_entry_from_index(GC_written_pages, index);
3272 # ifdef GC_SOLARIS_THREADS
3273 if (result && PAGE_IS_FRESH(h)) result = FALSE;
3278 /* Caller holds allocation lock. */
3279 void GC_is_fresh(h, n)
3284 register word index;
3286 # ifdef GC_SOLARIS_THREADS
3289 if (GC_fresh_pages != 0) {
3290 for (i = 0; i < n; i++) {
3291 ADD_FRESH_PAGE(h + i);
3297 # endif /* PROC_VDB */
3302 # include "vd/PCR_VD.h"
3304 # define NPAGES (32*1024) /* 128 MB */
3306 PCR_VD_DB GC_grungy_bits[NPAGES];
3308 ptr_t GC_vd_base; /* Address corresponding to GC_grungy_bits[0] */
3309 /* HBLKSIZE aligned. */
3311 void GC_dirty_init()
3313 GC_dirty_maintained = TRUE;
3314 /* For the time being, we assume the heap generally grows up */
3315 GC_vd_base = GC_heap_sects[0].hs_start;
3316 if (GC_vd_base == 0) {
3317 ABORT("Bad initial heap segment");
3319 if (PCR_VD_Start(HBLKSIZE, GC_vd_base, NPAGES*HBLKSIZE)
3321 ABORT("dirty bit initialization failed");
3325 void GC_read_dirty()
3327 /* lazily enable dirty bits on newly added heap sects */
3329 static int onhs = 0;
3330 int nhs = GC_n_heap_sects;
3331 for( ; onhs < nhs; onhs++ ) {
3332 PCR_VD_WriteProtectEnable(
3333 GC_heap_sects[onhs].hs_start,
3334 GC_heap_sects[onhs].hs_bytes );
3339 if (PCR_VD_Clear(GC_vd_base, NPAGES*HBLKSIZE, GC_grungy_bits)
3341 ABORT("dirty bit read failed");
3345 GC_bool GC_page_was_dirty(h)
3348 if((ptr_t)h < GC_vd_base || (ptr_t)h >= GC_vd_base + NPAGES*HBLKSIZE) {
3351 return(GC_grungy_bits[h - (struct hblk *)GC_vd_base] & PCR_VD_DB_dirtyBit);
3355 void GC_remove_protection(h, nblocks, is_ptrfree)
3360 PCR_VD_WriteProtectDisable(h, nblocks*HBLKSIZE);
3361 PCR_VD_WriteProtectEnable(h, nblocks*HBLKSIZE);
3364 # endif /* PCR_VDB */
3366 #if defined(MPROTECT_VDB) && defined(DARWIN)
3367 /* The following sources were used as a *reference* for this exception handling
3369 1. Apple's mach/xnu documentation
3370 2. Timothy J. Wood's "Mach Exception Handlers 101" post to the
3371 omnigroup's macosx-dev list.
3372 www.omnigroup.com/mailman/archive/macosx-dev/2000-June/002030.html
3373 3. macosx-nat.c from Apple's GDB source code.
3376 /* The bug that caused all this trouble should now be fixed. This should
3377 eventually be removed if all goes well. */
3378 /* define BROKEN_EXCEPTION_HANDLING */
3380 #include <mach/mach.h>
3381 #include <mach/mach_error.h>
3382 #include <mach/thread_status.h>
3383 #include <mach/exception.h>
3384 #include <mach/task.h>
3385 #include <pthread.h>
3387 /* These are not defined in any header, although they are documented */
3388 extern boolean_t exc_server(mach_msg_header_t *,mach_msg_header_t *);
3389 extern kern_return_t exception_raise(
3390 mach_port_t,mach_port_t,mach_port_t,
3391 exception_type_t,exception_data_t,mach_msg_type_number_t);
3392 extern kern_return_t exception_raise_state(
3393 mach_port_t,mach_port_t,mach_port_t,
3394 exception_type_t,exception_data_t,mach_msg_type_number_t,
3395 thread_state_flavor_t*,thread_state_t,mach_msg_type_number_t,
3396 thread_state_t,mach_msg_type_number_t*);
3397 extern kern_return_t exception_raise_state_identity(
3398 mach_port_t,mach_port_t,mach_port_t,
3399 exception_type_t,exception_data_t,mach_msg_type_number_t,
3400 thread_state_flavor_t*,thread_state_t,mach_msg_type_number_t,
3401 thread_state_t,mach_msg_type_number_t*);
3404 #define MAX_EXCEPTION_PORTS 16
3406 static mach_port_t GC_task_self;
3409 mach_msg_type_number_t count;
3410 exception_mask_t masks[MAX_EXCEPTION_PORTS];
3411 exception_handler_t ports[MAX_EXCEPTION_PORTS];
3412 exception_behavior_t behaviors[MAX_EXCEPTION_PORTS];
3413 thread_state_flavor_t flavors[MAX_EXCEPTION_PORTS];
3417 mach_port_t exception;
3418 #if defined(THREADS)
3424 mach_msg_header_t head;
3428 GC_MP_NORMAL, GC_MP_DISCARDING, GC_MP_STOPPED
3429 } GC_mprotect_state_t;
3431 /* FIXME: 1 and 2 seem to be safe to use in the msgh_id field,
3432 but it isn't documented. Use the source and see if they
3437 /* These values are only used on the reply port */
3440 #if defined(THREADS)
3442 GC_mprotect_state_t GC_mprotect_state;
3444 /* The following should ONLY be called when the world is stopped */
3445 static void GC_mprotect_thread_notify(mach_msg_id_t id) {
3448 mach_msg_trailer_t trailer;
3450 mach_msg_return_t r;
3452 buf.msg.head.msgh_bits =
3453 MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND,0);
3454 buf.msg.head.msgh_size = sizeof(buf.msg);
3455 buf.msg.head.msgh_remote_port = GC_ports.exception;
3456 buf.msg.head.msgh_local_port = MACH_PORT_NULL;
3457 buf.msg.head.msgh_id = id;
3461 MACH_SEND_MSG|MACH_RCV_MSG|MACH_RCV_LARGE,
3465 MACH_MSG_TIMEOUT_NONE,
3467 if(r != MACH_MSG_SUCCESS)
3468 ABORT("mach_msg failed in GC_mprotect_thread_notify");
3469 if(buf.msg.head.msgh_id != ID_ACK)
3470 ABORT("invalid ack in GC_mprotect_thread_notify");
3473 /* Should only be called by the mprotect thread */
3474 static void GC_mprotect_thread_reply() {
3476 mach_msg_return_t r;
3478 msg.head.msgh_bits =
3479 MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND,0);
3480 msg.head.msgh_size = sizeof(msg);
3481 msg.head.msgh_remote_port = GC_ports.reply;
3482 msg.head.msgh_local_port = MACH_PORT_NULL;
3483 msg.head.msgh_id = ID_ACK;
3491 MACH_MSG_TIMEOUT_NONE,
3493 if(r != MACH_MSG_SUCCESS)
3494 ABORT("mach_msg failed in GC_mprotect_thread_reply");
3497 void GC_mprotect_stop() {
3498 GC_mprotect_thread_notify(ID_STOP);
3500 void GC_mprotect_resume() {
3501 GC_mprotect_thread_notify(ID_RESUME);
3504 #else /* !THREADS */
3505 /* The compiler should optimize away any GC_mprotect_state computations */
3506 #define GC_mprotect_state GC_MP_NORMAL
3509 static void *GC_mprotect_thread(void *arg) {
3510 mach_msg_return_t r;
3511 /* These two structures contain some private kernel data. We don't need to
3512 access any of it so we don't bother defining a proper struct. The
3513 correct definitions are in the xnu source code. */
3515 mach_msg_header_t head;
3519 mach_msg_header_t head;
3520 mach_msg_body_t msgh_body;
3526 GC_darwin_register_mach_handler_thread(mach_thread_self());
3531 MACH_RCV_MSG|MACH_RCV_LARGE|
3532 (GC_mprotect_state == GC_MP_DISCARDING ? MACH_RCV_TIMEOUT : 0),
3536 GC_mprotect_state == GC_MP_DISCARDING ? 0 : MACH_MSG_TIMEOUT_NONE,
3539 id = r == MACH_MSG_SUCCESS ? msg.head.msgh_id : -1;
3541 #if defined(THREADS)
3542 if(GC_mprotect_state == GC_MP_DISCARDING) {
3543 if(r == MACH_RCV_TIMED_OUT) {
3544 GC_mprotect_state = GC_MP_STOPPED;
3545 GC_mprotect_thread_reply();
3548 if(r == MACH_MSG_SUCCESS && (id == ID_STOP || id == ID_RESUME))
3549 ABORT("out of order mprotect thread request");
3553 if(r != MACH_MSG_SUCCESS) {
3554 GC_err_printf2("mach_msg failed with %d %s\n",
3555 (int)r,mach_error_string(r));
3556 ABORT("mach_msg failed");
3560 #if defined(THREADS)
3562 if(GC_mprotect_state != GC_MP_NORMAL)
3563 ABORT("Called mprotect_stop when state wasn't normal");
3564 GC_mprotect_state = GC_MP_DISCARDING;
3567 if(GC_mprotect_state != GC_MP_STOPPED)
3568 ABORT("Called mprotect_resume when state wasn't stopped");
3569 GC_mprotect_state = GC_MP_NORMAL;
3570 GC_mprotect_thread_reply();
3572 #endif /* THREADS */
3574 /* Handle the message (calls catch_exception_raise) */
3575 if(!exc_server(&msg.head,&reply.head))
3576 ABORT("exc_server failed");
3577 /* Send the reply */
3581 reply.head.msgh_size,
3584 MACH_MSG_TIMEOUT_NONE,
3586 if(r != MACH_MSG_SUCCESS) {
3587 /* This will fail if the thread dies, but the thread shouldn't
3589 #ifdef BROKEN_EXCEPTION_HANDLING
3591 "mach_msg failed with %d %s while sending exc reply\n",
3592 (int)r,mach_error_string(r));
3594 ABORT("mach_msg failed while sending exception reply");
3603 /* All this SIGBUS code shouldn't be necessary. All protection faults should
3604 be going throught the mach exception handler. However, it seems a SIGBUS is
3605 occasionally sent for some unknown reason. Even more odd, it seems to be
3606 meaningless and safe to ignore. */
3607 #ifdef BROKEN_EXCEPTION_HANDLING
3609 typedef void (* SIG_PF)();
3610 static SIG_PF GC_old_bus_handler;
3612 /* Updates to this aren't atomic, but the SIGBUSs seem pretty rare.
3613 Even if this doesn't get updated property, it isn't really a problem */
3614 static int GC_sigbus_count;
3616 static void GC_darwin_sigbus(int num,siginfo_t *sip,void *context) {
3617 if(num != SIGBUS) ABORT("Got a non-sigbus signal in the sigbus handler");
3619 /* Ugh... some seem safe to ignore, but too many in a row probably means
3620 trouble. GC_sigbus_count is reset for each mach exception that is
3622 if(GC_sigbus_count >= 8) {
3623 ABORT("Got more than 8 SIGBUSs in a row!");
3626 GC_err_printf0("GC: WARNING: Ignoring SIGBUS.\n");
3629 #endif /* BROKEN_EXCEPTION_HANDLING */
3631 void GC_dirty_init() {
3635 pthread_attr_t attr;
3636 exception_mask_t mask;
3639 GC_printf0("Inititalizing mach/darwin mprotect virtual dirty bit "
3640 "implementation\n");
3642 # ifdef BROKEN_EXCEPTION_HANDLING
3643 GC_err_printf0("GC: WARNING: Enabling workarounds for various darwin "
3644 "exception handling bugs.\n");
3646 GC_dirty_maintained = TRUE;
3647 if (GC_page_size % HBLKSIZE != 0) {
3648 GC_err_printf0("Page size not multiple of HBLKSIZE\n");
3649 ABORT("Page size not multiple of HBLKSIZE");
3652 GC_task_self = me = mach_task_self();
3654 r = mach_port_allocate(me,MACH_PORT_RIGHT_RECEIVE,&GC_ports.exception);
3655 if(r != KERN_SUCCESS) ABORT("mach_port_allocate failed (exception port)");
3657 r = mach_port_insert_right(me,GC_ports.exception,GC_ports.exception,
3658 MACH_MSG_TYPE_MAKE_SEND);
3659 if(r != KERN_SUCCESS)
3660 ABORT("mach_port_insert_right failed (exception port)");
3662 #if defined(THREADS)
3663 r = mach_port_allocate(me,MACH_PORT_RIGHT_RECEIVE,&GC_ports.reply);
3664 if(r != KERN_SUCCESS) ABORT("mach_port_allocate failed (reply port)");
3667 /* The exceptions we want to catch */
3668 mask = EXC_MASK_BAD_ACCESS;
3670 r = task_get_exception_ports(
3673 GC_old_exc_ports.masks,
3674 &GC_old_exc_ports.count,
3675 GC_old_exc_ports.ports,
3676 GC_old_exc_ports.behaviors,
3677 GC_old_exc_ports.flavors
3679 if(r != KERN_SUCCESS) ABORT("task_get_exception_ports failed");
3681 r = task_set_exception_ports(
3686 MACHINE_THREAD_STATE
3688 if(r != KERN_SUCCESS) ABORT("task_set_exception_ports failed");
3690 if(pthread_attr_init(&attr) != 0) ABORT("pthread_attr_init failed");
3691 if(pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED) != 0)
3692 ABORT("pthread_attr_setdetachedstate failed");
3694 # undef pthread_create
3695 /* This will call the real pthread function, not our wrapper */
3696 if(pthread_create(&thread,&attr,GC_mprotect_thread,NULL) != 0)
3697 ABORT("pthread_create failed");
3698 pthread_attr_destroy(&attr);
3700 /* Setup the sigbus handler for ignoring the meaningless SIGBUSs */
3701 #ifdef BROKEN_EXCEPTION_HANDLING
3703 struct sigaction sa, oldsa;
3704 sa.sa_handler = (SIG_PF)GC_darwin_sigbus;
3705 sigemptyset(&sa.sa_mask);
3706 sa.sa_flags = SA_RESTART|SA_SIGINFO;
3707 if(sigaction(SIGBUS,&sa,&oldsa) < 0) ABORT("sigaction");
3708 GC_old_bus_handler = (SIG_PF)oldsa.sa_handler;
3709 if (GC_old_bus_handler != SIG_DFL) {
3711 GC_err_printf0("Replaced other SIGBUS handler\n");
3715 #endif /* BROKEN_EXCEPTION_HANDLING */
3718 /* The source code for Apple's GDB was used as a reference for the exception
3719 forwarding code. This code is similar to be GDB code only because there is
3720 only one way to do it. */
3721 static kern_return_t GC_forward_exception(
3724 exception_type_t exception,
3725 exception_data_t data,
3726 mach_msg_type_number_t data_count
3731 exception_behavior_t behavior;
3732 thread_state_flavor_t flavor;
3734 thread_state_data_t thread_state;
3735 mach_msg_type_number_t thread_state_count = THREAD_STATE_MAX;
3737 for(i=0;i<GC_old_exc_ports.count;i++)
3738 if(GC_old_exc_ports.masks[i] & (1 << exception))
3740 if(i==GC_old_exc_ports.count) ABORT("No handler for exception!");
3742 port = GC_old_exc_ports.ports[i];
3743 behavior = GC_old_exc_ports.behaviors[i];
3744 flavor = GC_old_exc_ports.flavors[i];
3746 if(behavior != EXCEPTION_DEFAULT) {
3747 r = thread_get_state(thread,flavor,thread_state,&thread_state_count);
3748 if(r != KERN_SUCCESS)
3749 ABORT("thread_get_state failed in forward_exception");
3753 case EXCEPTION_DEFAULT:
3754 r = exception_raise(port,thread,task,exception,data,data_count);
3756 case EXCEPTION_STATE:
3757 r = exception_raise_state(port,thread,task,exception,data,
3758 data_count,&flavor,thread_state,thread_state_count,
3759 thread_state,&thread_state_count);
3761 case EXCEPTION_STATE_IDENTITY:
3762 r = exception_raise_state_identity(port,thread,task,exception,data,
3763 data_count,&flavor,thread_state,thread_state_count,
3764 thread_state,&thread_state_count);
3767 r = KERN_FAILURE; /* make gcc happy */
3768 ABORT("forward_exception: unknown behavior");
3772 if(behavior != EXCEPTION_DEFAULT) {
3773 r = thread_set_state(thread,flavor,thread_state,thread_state_count);
3774 if(r != KERN_SUCCESS)
3775 ABORT("thread_set_state failed in forward_exception");
3781 #define FWD() GC_forward_exception(thread,task,exception,code,code_count)
3783 /* This violates the namespace rules but there isn't anything that can be done
3784 about it. The exception handling stuff is hard coded to call this */
3786 catch_exception_raise(
3787 mach_port_t exception_port,mach_port_t thread,mach_port_t task,
3788 exception_type_t exception,exception_data_t code,
3789 mach_msg_type_number_t code_count
3796 thread_state_flavor_t flavor = PPC_EXCEPTION_STATE;
3797 mach_msg_type_number_t exc_state_count = PPC_EXCEPTION_STATE_COUNT;
3798 ppc_exception_state_t exc_state;
3800 # error FIXME for non-ppc darwin
3804 if(exception != EXC_BAD_ACCESS || code[0] != KERN_PROTECTION_FAILURE) {
3805 #ifdef DEBUG_EXCEPTION_HANDLING
3806 /* We aren't interested, pass it on to the old handler */
3807 GC_printf3("Exception: 0x%x Code: 0x%x 0x%x in catch....\n",
3809 code_count > 0 ? code[0] : -1,
3810 code_count > 1 ? code[1] : -1);
3815 r = thread_get_state(thread,flavor,
3816 (natural_t*)&exc_state,&exc_state_count);
3817 if(r != KERN_SUCCESS) {
3818 /* The thread is supposed to be suspended while the exception handler
3819 is called. This shouldn't fail. */
3820 #ifdef BROKEN_EXCEPTION_HANDLING
3821 GC_err_printf0("thread_get_state failed in "
3822 "catch_exception_raise\n");
3823 return KERN_SUCCESS;
3825 ABORT("thread_get_state failed in catch_exception_raise");
3829 /* This is the address that caused the fault */
3830 addr = (char*) exc_state.dar;
3832 if((HDR(addr)) == 0) {
3833 /* Ugh... just like the SIGBUS problem above, it seems we get a bogus
3834 KERN_PROTECTION_FAILURE every once and a while. We wait till we get
3835 a bunch in a row before doing anything about it. If a "real" fault
3836 ever occurres it'll just keep faulting over and over and we'll hit
3837 the limit pretty quickly. */
3838 #ifdef BROKEN_EXCEPTION_HANDLING
3839 static char *last_fault;
3840 static int last_fault_count;
3842 if(addr != last_fault) {
3844 last_fault_count = 0;
3846 if(++last_fault_count < 32) {
3847 if(last_fault_count == 1)
3849 "GC: WARNING: Ignoring KERN_PROTECTION_FAILURE at %p\n",
3851 return KERN_SUCCESS;
3854 GC_err_printf1("Unexpected KERN_PROTECTION_FAILURE at %p\n",addr);
3855 /* Can't pass it along to the signal handler because that is
3856 ignoring SIGBUS signals. We also shouldn't call ABORT here as
3857 signals don't always work too well from the exception handler. */
3858 GC_err_printf0("Aborting\n");
3860 #else /* BROKEN_EXCEPTION_HANDLING */
3861 /* Pass it along to the next exception handler
3862 (which should call SIGBUS/SIGSEGV) */
3864 #endif /* !BROKEN_EXCEPTION_HANDLING */
3867 #ifdef BROKEN_EXCEPTION_HANDLING
3868 /* Reset the number of consecutive SIGBUSs */
3869 GC_sigbus_count = 0;
3872 if(GC_mprotect_state == GC_MP_NORMAL) { /* common case */
3873 h = (struct hblk*)((word)addr & ~(GC_page_size-1));
3874 UNPROTECT(h, GC_page_size);
3875 for (i = 0; i < divHBLKSZ(GC_page_size); i++) {
3876 register int index = PHT_HASH(h+i);
3877 async_set_pht_entry_from_index(GC_dirty_pages, index);
3879 } else if(GC_mprotect_state == GC_MP_DISCARDING) {
3880 /* Lie to the thread for now. No sense UNPROTECT()ing the memory
3881 when we're just going to PROTECT() it again later. The thread
3882 will just fault again once it resumes */
3884 /* Shouldn't happen, i don't think */
3885 GC_printf0("KERN_PROTECTION_FAILURE while world is stopped\n");
3888 return KERN_SUCCESS;
3892 /* These should never be called, but just in case... */
3893 kern_return_t catch_exception_raise_state(mach_port_name_t exception_port,
3894 int exception, exception_data_t code, mach_msg_type_number_t codeCnt,
3895 int flavor, thread_state_t old_state, int old_stateCnt,
3896 thread_state_t new_state, int new_stateCnt)
3898 ABORT("catch_exception_raise_state");
3899 return(KERN_INVALID_ARGUMENT);
3901 kern_return_t catch_exception_raise_state_identity(
3902 mach_port_name_t exception_port, mach_port_t thread, mach_port_t task,
3903 int exception, exception_data_t code, mach_msg_type_number_t codeCnt,
3904 int flavor, thread_state_t old_state, int old_stateCnt,
3905 thread_state_t new_state, int new_stateCnt)
3907 ABORT("catch_exception_raise_state_identity");
3908 return(KERN_INVALID_ARGUMENT);
3912 #endif /* DARWIN && MPROTECT_VDB */
3914 # ifndef HAVE_INCREMENTAL_PROTECTION_NEEDS
3915 int GC_incremental_protection_needs()
3917 return GC_PROTECTS_NONE;
3919 # endif /* !HAVE_INCREMENTAL_PROTECTION_NEEDS */
3922 * Call stack save code for debugging.
3923 * Should probably be in mach_dep.c, but that requires reorganization.
3926 /* I suspect the following works for most X86 *nix variants, so */
3927 /* long as the frame pointer is explicitly stored. In the case of gcc, */
3928 /* compiler flags (e.g. -fomit-frame-pointer) determine whether it is. */
3929 #if defined(I386) && defined(LINUX) && defined(SAVE_CALL_CHAIN)
3930 # include <features.h>
3933 struct frame *fr_savfp;
3935 long fr_arg[NARGS]; /* All the arguments go here. */
3941 # include <features.h>
3946 struct frame *fr_savfp;
3955 # if defined(SUNOS4)
3956 # include <machine/frame.h>
3958 # if defined (DRSNX)
3959 # include <sys/sparc/frame.h>
3961 # if defined(OPENBSD) || defined(NETBSD)
3964 # include <sys/frame.h>
3970 --> We only know how to to get the first 6 arguments
3974 #ifdef NEED_CALLINFO
3975 /* Fill in the pc and argument information for up to NFRAMES of my */
3976 /* callers. Ignore my frame and my callers frame. */
3979 # include <unistd.h>
3982 #endif /* NEED_CALLINFO */
3984 #if defined(GC_HAVE_BUILTIN_BACKTRACE)
3985 # include <execinfo.h>
3988 #ifdef SAVE_CALL_CHAIN
3990 #if NARGS == 0 && NFRAMES % 2 == 0 /* No padding */ \
3991 && defined(GC_HAVE_BUILTIN_BACKTRACE)
3993 void GC_save_callers (info)
3994 struct callinfo info[NFRAMES];
3996 void * tmp_info[NFRAMES + 1];
3998 # define IGNORE_FRAMES 1
4000 /* We retrieve NFRAMES+1 pc values, but discard the first, since it */
4001 /* points to our own frame. */
4002 GC_ASSERT(sizeof(struct callinfo) == sizeof(void *));
4003 npcs = backtrace((void **)tmp_info, NFRAMES + IGNORE_FRAMES);
4004 BCOPY(tmp_info+IGNORE_FRAMES, info, (npcs - IGNORE_FRAMES) * sizeof(void *));
4005 for (i = npcs - IGNORE_FRAMES; i < NFRAMES; ++i) info[i].ci_pc = 0;
4008 #else /* No builtin backtrace; do it ourselves */
4010 #if (defined(OPENBSD) || defined(NETBSD)) && defined(SPARC)
4011 # define FR_SAVFP fr_fp
4012 # define FR_SAVPC fr_pc
4014 # define FR_SAVFP fr_savfp
4015 # define FR_SAVPC fr_savpc
4018 #if defined(SPARC) && (defined(__arch64__) || defined(__sparcv9))
4024 void GC_save_callers (info)
4025 struct callinfo info[NFRAMES];
4027 struct frame *frame;
4031 /* We assume this is turned on only with gcc as the compiler. */
4032 asm("movl %%ebp,%0" : "=r"(frame));
4035 frame = (struct frame *) GC_save_regs_in_stack ();
4036 fp = (struct frame *)((long) frame -> FR_SAVFP + BIAS);
4039 for (; (!(fp HOTTER_THAN frame) && !(GC_stackbottom HOTTER_THAN (ptr_t)fp)
4040 && (nframes < NFRAMES));
4041 fp = (struct frame *)((long) fp -> FR_SAVFP + BIAS), nframes++) {
4044 info[nframes].ci_pc = fp->FR_SAVPC;
4046 for (i = 0; i < NARGS; i++) {
4047 info[nframes].ci_arg[i] = ~(fp->fr_arg[i]);
4049 # endif /* NARGS > 0 */
4051 if (nframes < NFRAMES) info[nframes].ci_pc = 0;
4054 #endif /* No builtin backtrace */
4056 #endif /* SAVE_CALL_CHAIN */
4058 #ifdef NEED_CALLINFO
4060 /* Print info to stderr. We do NOT hold the allocation lock */
4061 void GC_print_callers (info)
4062 struct callinfo info[NFRAMES];
4065 static int reentry_count = 0;
4066 GC_bool stop = FALSE;
4068 /* FIXME: This should probably use a different lock, so that we */
4069 /* become callable with or without the allocation lock. */
4075 GC_err_printf0("\tCaller at allocation:\n");
4077 GC_err_printf0("\tCall chain at allocation:\n");
4079 for (i = 0; i < NFRAMES && !stop ; i++) {
4080 if (info[i].ci_pc == 0) break;
4085 GC_err_printf0("\t\targs: ");
4086 for (j = 0; j < NARGS; j++) {
4087 if (j != 0) GC_err_printf0(", ");
4088 GC_err_printf2("%d (0x%X)", ~(info[i].ci_arg[j]),
4089 ~(info[i].ci_arg[j]));
4091 GC_err_printf0("\n");
4094 if (reentry_count > 1) {
4095 /* We were called during an allocation during */
4096 /* a previous GC_print_callers call; punt. */
4097 GC_err_printf1("\t\t##PC##= 0x%lx\n", info[i].ci_pc);
4104 # if defined(GC_HAVE_BUILTIN_BACKTRACE) \
4105 && !defined(GC_BACKTRACE_SYMBOLS_BROKEN)
4107 backtrace_symbols((void **)(&(info[i].ci_pc)), 1);
4108 char *name = sym_name[0];
4112 sprintf(buf, "##PC##= 0x%lx", info[i].ci_pc);
4114 # if defined(LINUX) && !defined(SMALL_CONFIG)
4115 /* Try for a line number. */
4118 static char exe_name[EXE_SZ];
4120 char cmd_buf[CMD_SZ];
4121 # define RESULT_SZ 200
4122 static char result_buf[RESULT_SZ];
4125 # define PRELOAD_SZ 200
4126 char preload_buf[PRELOAD_SZ];
4127 static GC_bool found_exe_name = FALSE;
4128 static GC_bool will_fail = FALSE;
4130 /* Try to get it via a hairy and expensive scheme. */
4131 /* First we get the name of the executable: */
4132 if (will_fail) goto out;
4133 if (!found_exe_name) {
4134 ret_code = readlink("/proc/self/exe", exe_name, EXE_SZ);
4135 if (ret_code < 0 || ret_code >= EXE_SZ
4136 || exe_name[0] != '/') {
4137 will_fail = TRUE; /* Dont try again. */
4140 exe_name[ret_code] = '\0';
4141 found_exe_name = TRUE;
4143 /* Then we use popen to start addr2line -e <exe> <addr> */
4144 /* There are faster ways to do this, but hopefully this */
4145 /* isn't time critical. */
4146 sprintf(cmd_buf, "/usr/bin/addr2line -f -e %s 0x%lx", exe_name,
4147 (unsigned long)info[i].ci_pc);
4148 old_preload = getenv ("LD_PRELOAD");
4149 if (0 != old_preload) {
4150 if (strlen (old_preload) >= PRELOAD_SZ) {
4154 strcpy (preload_buf, old_preload);
4155 unsetenv ("LD_PRELOAD");
4157 pipe = popen(cmd_buf, "r");
4158 if (0 != old_preload
4159 && 0 != setenv ("LD_PRELOAD", preload_buf, 0)) {
4160 WARN("Failed to reset LD_PRELOAD\n", 0);
4163 || (result_len = fread(result_buf, 1, RESULT_SZ - 1, pipe))
4165 if (pipe != NULL) pclose(pipe);
4169 if (result_buf[result_len - 1] == '\n') --result_len;
4170 result_buf[result_len] = 0;
4171 if (result_buf[0] == '?'
4172 || result_buf[result_len-2] == ':'
4173 && result_buf[result_len-1] == '0') {
4177 /* Get rid of embedded newline, if any. Test for "main" */
4179 char * nl = strchr(result_buf, '\n');
4180 if (nl != NULL && nl < result_buf + result_len) {
4183 if (strncmp(result_buf, "main", nl - result_buf) == 0) {
4187 if (result_len < RESULT_SZ - 25) {
4188 /* Add in hex address */
4189 sprintf(result_buf + result_len, " [0x%lx]",
4190 (unsigned long)info[i].ci_pc);
4197 GC_err_printf1("\t\t%s\n", name);
4198 # if defined(GC_HAVE_BUILTIN_BACKTRACE) \
4199 && !defined(GC_BACKTRACE_SYMBOLS_BROKEN)
4200 free(sym_name); /* May call GC_free; that's OK */
4209 #endif /* NEED_CALLINFO */
4213 #if defined(LINUX) && defined(__ELF__) && !defined(SMALL_CONFIG)
4215 /* Dump /proc/self/maps to GC_stderr, to enable looking up names for
4216 addresses in FIND_LEAK output. */
4218 static word dump_maps(char *maps)
4220 GC_err_write(maps, strlen(maps));
4224 void GC_print_address_map()
4226 GC_err_printf0("---------- Begin address map ----------\n");
4227 GC_apply_to_maps(dump_maps);
4228 GC_err_printf0("---------- End address map ----------\n");