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.
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)
49 # include <sys/types.h>
50 # if !defined(MSWIN32) && !defined(SUNOS4)
58 /* Blatantly OS dependent routines, except for those that are related */
59 /* to dynamic loading. */
61 # if !defined(THREADS) && !defined(STACKBOTTOM) && defined(HEURISTIC2)
62 # define NEED_FIND_LIMIT
65 # if defined(IRIX_THREADS) || defined(HPUX_THREADS)
66 # define NEED_FIND_LIMIT
69 # if (defined(SUNOS4) & defined(DYNAMIC_LOADING)) && !defined(PCR)
70 # define NEED_FIND_LIMIT
73 # if (defined(SVR4) || defined(AUX) || defined(DGUX)) && !defined(PCR)
74 # define NEED_FIND_LIMIT
77 # if defined(LINUX) && \
78 (defined(POWERPC) || defined(SPARC) || defined(ALPHA) || defined(IA64))
79 # define NEED_FIND_LIMIT
82 #ifdef NEED_FIND_LIMIT
87 # include <machine/trap.h>
91 # include <proto/exec.h>
92 # include <proto/dos.h>
93 # include <dos/dosextens.h>
94 # include <workbench/startup.h>
98 # define WIN32_LEAN_AND_MEAN
100 # include <windows.h>
104 # include <Processes.h>
108 # include <sys/uio.h>
109 # include <malloc.h> /* for locking */
112 # include <sys/types.h>
113 # include <sys/mman.h>
114 # include <sys/stat.h>
119 # include <sys/siginfo.h>
122 # define setjmp(env) sigsetjmp(env, 1)
123 # define longjmp(env, val) siglongjmp(env, val)
124 # define jmp_buf sigjmp_buf
128 /* Apparently necessary for djgpp 2.01. May casuse problems with */
129 /* other versions. */
130 typedef long unsigned int caddr_t
;
134 # include "il/PCR_IL.h"
135 # include "th/PCR_ThCtl.h"
136 # include "mm/PCR_MM.h"
139 #if !defined(NO_EXECUTE_PERMISSION)
140 # define OPT_PROT_EXEC PROT_EXEC
142 # define OPT_PROT_EXEC 0
145 #if defined(LINUX) && (defined(POWERPC) || defined(SPARC) || defined(ALPHA) \
147 /* The I386 case can be handled without a search. The Alpha case */
148 /* used to be handled differently as well, but the rules changed */
149 /* for recent Linux versions. This seems to be the easiest way to */
150 /* cover all versions. */
153 extern char * GC_copyright
[]; /* Any data symbol would do. */
155 void GC_init_linux_data_start()
157 extern ptr_t
GC_find_limit();
159 GC_data_start
= GC_find_limit((ptr_t
)GC_copyright
, FALSE
);
165 # ifndef ECOS_GC_MEMORY_SIZE
166 # define ECOS_GC_MEMORY_SIZE (448 * 1024)
167 # endif /* ECOS_GC_MEMORY_SIZE */
169 // setjmp() function, as described in ANSI para 7.6.1.1
170 #define setjmp( __env__ ) hal_setjmp( __env__ )
172 // FIXME: This is a simple way of allocating memory which is
173 // compatible with ECOS early releases. Later releases use a more
174 // sophisticated means of allocating memory than this simple static
175 // allocator, but this method is at least bound to work.
176 static char memory
[ECOS_GC_MEMORY_SIZE
];
177 static char *brk
= memory
;
179 static void *tiny_sbrk(ptrdiff_t increment
)
185 if (brk
> memory
+ sizeof memory
)
193 #define sbrk tiny_sbrk
200 # if !defined(__IBMC__) && !defined(__WATCOMC__) /* e.g. EMX */
203 unsigned short magic_number
;
204 unsigned short padding
[29];
208 #define E_MAGIC(x) (x).magic_number
209 #define EMAGIC 0x5A4D
210 #define E_LFANEW(x) (x).new_exe_offset
213 unsigned char magic_number
[2];
214 unsigned char byte_order
;
215 unsigned char word_order
;
216 unsigned long exe_format_level
;
219 unsigned long padding1
[13];
220 unsigned long object_table_offset
;
221 unsigned long object_count
;
222 unsigned long padding2
[31];
225 #define E32_MAGIC1(x) (x).magic_number[0]
226 #define E32MAGIC1 'L'
227 #define E32_MAGIC2(x) (x).magic_number[1]
228 #define E32MAGIC2 'X'
229 #define E32_BORDER(x) (x).byte_order
231 #define E32_WORDER(x) (x).word_order
233 #define E32_CPU(x) (x).cpu
235 #define E32_OBJTAB(x) (x).object_table_offset
236 #define E32_OBJCNT(x) (x).object_count
242 unsigned long pagemap
;
243 unsigned long mapsize
;
244 unsigned long reserved
;
247 #define O32_FLAGS(x) (x).flags
248 #define OBJREAD 0x0001L
249 #define OBJWRITE 0x0002L
250 #define OBJINVALID 0x0080L
251 #define O32_SIZE(x) (x).size
252 #define O32_BASE(x) (x).base
254 # else /* IBM's compiler */
256 /* A kludge to get around what appears to be a header file bug */
258 # define WORD unsigned short
261 # define DWORD unsigned long
268 # endif /* __IBMC__ */
270 # define INCL_DOSEXCEPTIONS
271 # define INCL_DOSPROCESS
272 # define INCL_DOSERRORS
273 # define INCL_DOSMODULEMGR
274 # define INCL_DOSMEMMGR
278 /* Disable and enable signals during nontrivial allocations */
280 void GC_disable_signals(void)
284 DosEnterMustComplete(&nest
);
285 if (nest
!= 1) ABORT("nested GC_disable_signals");
288 void GC_enable_signals(void)
292 DosExitMustComplete(&nest
);
293 if (nest
!= 0) ABORT("GC_enable_signals");
299 # if !defined(PCR) && !defined(AMIGA) && !defined(MSWIN32) \
300 && !defined(MACOS) && !defined(DJGPP) && !defined(DOS4GW) \
301 && !defined(NO_SIGSET)
303 # if defined(sigmask) && !defined(UTS4)
304 /* Use the traditional BSD interface */
305 # define SIGSET_T int
306 # define SIG_DEL(set, signal) (set) &= ~(sigmask(signal))
307 # define SIG_FILL(set) (set) = 0x7fffffff
308 /* Setting the leading bit appears to provoke a bug in some */
309 /* longjmp implementations. Most systems appear not to have */
311 # define SIGSETMASK(old, new) (old) = sigsetmask(new)
313 /* Use POSIX/SYSV interface */
314 # define SIGSET_T sigset_t
315 # define SIG_DEL(set, signal) sigdelset(&(set), (signal))
316 # define SIG_FILL(set) sigfillset(&set)
317 # define SIGSETMASK(old, new) sigprocmask(SIG_SETMASK, &(new), &(old))
320 static GC_bool mask_initialized
= FALSE
;
322 static SIGSET_T new_mask
;
324 static SIGSET_T old_mask
;
326 static SIGSET_T dummy
;
328 #if defined(PRINTSTATS) && !defined(THREADS)
329 # define CHECK_SIGNALS
330 int GC_sig_disabled
= 0;
333 void GC_disable_signals()
335 if (!mask_initialized
) {
338 SIG_DEL(new_mask
, SIGSEGV
);
339 SIG_DEL(new_mask
, SIGILL
);
340 SIG_DEL(new_mask
, SIGQUIT
);
342 SIG_DEL(new_mask
, SIGBUS
);
345 SIG_DEL(new_mask
, SIGIOT
);
348 SIG_DEL(new_mask
, SIGEMT
);
351 SIG_DEL(new_mask
, SIGTRAP
);
353 mask_initialized
= TRUE
;
355 # ifdef CHECK_SIGNALS
356 if (GC_sig_disabled
!= 0) ABORT("Nested disables");
359 SIGSETMASK(old_mask
,new_mask
);
362 void GC_enable_signals()
364 # ifdef CHECK_SIGNALS
365 if (GC_sig_disabled
!= 1) ABORT("Unmatched enable");
368 SIGSETMASK(dummy
,old_mask
);
375 /* Ivan Demakov: simplest way (to me) */
376 #if defined (DOS4GW) || defined (NO_SIGSET)
377 void GC_disable_signals() { }
378 void GC_enable_signals() { }
381 /* Find the page size */
385 void GC_setpagesize()
389 GetSystemInfo(&sysinfo
);
390 GC_page_size
= sysinfo
.dwPageSize
;
394 # if defined(MPROTECT_VDB) || defined(PROC_VDB) || defined(USE_MMAP) \
395 || defined(USE_MUNMAP)
396 void GC_setpagesize()
398 GC_page_size
= GETPAGESIZE();
401 /* It's acceptable to fake it. */
402 void GC_setpagesize()
404 GC_page_size
= HBLKSIZE
;
410 * Find the base of the stack.
411 * Used only in single-threaded environment.
412 * With threads, GC_mark_roots needs to know how to do this.
413 * Called with allocator lock held.
416 # define is_writable(prot) ((prot) == PAGE_READWRITE \
417 || (prot) == PAGE_WRITECOPY \
418 || (prot) == PAGE_EXECUTE_READWRITE \
419 || (prot) == PAGE_EXECUTE_WRITECOPY)
420 /* Return the number of bytes that are writable starting at p. */
421 /* The pointer p is assumed to be page aligned. */
422 /* If base is not 0, *base becomes the beginning of the */
423 /* allocation region containing p. */
424 word
GC_get_writable_length(ptr_t p
, ptr_t
*base
)
426 MEMORY_BASIC_INFORMATION buf
;
430 result
= VirtualQuery(p
, &buf
, sizeof(buf
));
431 if (result
!= sizeof(buf
)) ABORT("Weird VirtualQuery result");
432 if (base
!= 0) *base
= (ptr_t
)(buf
.AllocationBase
);
433 protect
= (buf
.Protect
& ~(PAGE_GUARD
| PAGE_NOCACHE
));
434 if (!is_writable(protect
)) {
437 if (buf
.State
!= MEM_COMMIT
) return(0);
438 return(buf
.RegionSize
);
441 ptr_t
GC_get_stack_base()
444 ptr_t sp
= (ptr_t
)(&dummy
);
445 ptr_t trunc_sp
= (ptr_t
)((word
)sp
& ~(GC_page_size
- 1));
446 word size
= GC_get_writable_length(trunc_sp
, 0);
448 return(trunc_sp
+ size
);
456 ptr_t
GC_get_stack_base()
461 if (DosGetInfoBlocks(&ptib
, &ppib
) != NO_ERROR
) {
462 GC_err_printf0("DosGetInfoBlocks failed\n");
463 ABORT("DosGetInfoBlocks failed\n");
465 return((ptr_t
)(ptib
-> tib_pstacklimit
));
472 ptr_t
GC_get_stack_base()
474 struct Process
*proc
= (struct Process
*)SysBase
->ThisTask
;
476 /* Reference: Amiga Guru Book Pages: 42,567,574 */
477 if (proc
->pr_Task
.tc_Node
.ln_Type
==NT_PROCESS
478 && proc
->pr_CLI
!= NULL
) {
479 /* first ULONG is StackSize */
480 /*longPtr = proc->pr_ReturnAddr;
483 return (char *)proc
->pr_ReturnAddr
+ sizeof(ULONG
);
485 return (char *)proc
->pr_Task
.tc_SPUpper
;
489 #if 0 /* old version */
490 ptr_t
GC_get_stack_base()
492 extern struct WBStartup
*_WBenchMsg
;
496 struct Process
*proc
;
497 struct CommandLineInterface
*cli
;
500 if ((task
= FindTask(0)) == 0) {
501 GC_err_puts("Cannot find own task structure\n");
502 ABORT("task missing");
504 proc
= (struct Process
*)task
;
505 cli
= BADDR(proc
->pr_CLI
);
507 if (_WBenchMsg
!= 0 || cli
== 0) {
508 size
= (char *)task
->tc_SPUpper
- (char *)task
->tc_SPLower
;
510 size
= cli
->cli_DefaultStack
* 4;
512 return (ptr_t
)(__base
+ GC_max(size
, __stack
));
516 # else /* !AMIGA, !OS2, ... */
518 # ifdef NEED_FIND_LIMIT
519 /* Some tools to implement HEURISTIC2 */
520 # define MIN_PAGE_SIZE 256 /* Smallest conceivable page size, bytes */
521 /* static */ jmp_buf GC_jmp_buf
;
524 void GC_fault_handler(sig
)
527 longjmp(GC_jmp_buf
, 1);
531 typedef void (*handler
)(int);
533 typedef void (*handler
)();
536 # if defined(SUNOS5SIGS) || defined(IRIX5) || defined(OSF1)
537 static struct sigaction old_segv_act
;
538 # if defined(_sigargs) || defined(HPUX) /* !Irix6.x */
539 static struct sigaction old_bus_act
;
542 static handler old_segv_handler
, old_bus_handler
;
545 void GC_setup_temporary_fault_handler()
548 # if defined(SUNOS5SIGS) || defined(IRIX5) || defined(OSF1)
549 struct sigaction act
;
551 act
.sa_handler
= GC_fault_handler
;
552 act
.sa_flags
= SA_RESTART
| SA_NODEFER
;
553 /* The presence of SA_NODEFER represents yet another gross */
554 /* hack. Under Solaris 2.3, siglongjmp doesn't appear to */
555 /* interact correctly with -lthread. We hide the confusion */
556 /* by making sure that signal handling doesn't affect the */
559 (void) sigemptyset(&act
.sa_mask
);
561 /* Older versions have a bug related to retrieving and */
562 /* and setting a handler at the same time. */
563 (void) sigaction(SIGSEGV
, 0, &old_segv_act
);
564 (void) sigaction(SIGSEGV
, &act
, 0);
566 (void) sigaction(SIGSEGV
, &act
, &old_segv_act
);
567 # if defined(IRIX5) && defined(_sigargs) /* Irix 5.x, not 6.x */ \
569 /* Under Irix 5.x or HP/UX, we may get SIGBUS. */
570 /* Pthreads doesn't exist under Irix 5.x, so we */
571 /* don't have to worry in the threads case. */
572 (void) sigaction(SIGBUS
, &act
, &old_bus_act
);
574 # endif /* IRIX_THREADS */
576 old_segv_handler
= signal(SIGSEGV
, GC_fault_handler
);
578 old_bus_handler
= signal(SIGBUS
, GC_fault_handler
);
584 void GC_reset_fault_handler()
587 # if defined(SUNOS5SIGS) || defined(IRIX5) || defined(OSF1)
588 (void) sigaction(SIGSEGV
, &old_segv_act
, 0);
589 # if defined(IRIX5) && defined(_sigargs) /* Irix 5.x, not 6.x */ \
591 (void) sigaction(SIGBUS
, &old_bus_act
, 0);
594 (void) signal(SIGSEGV
, old_segv_handler
);
596 (void) signal(SIGBUS
, old_bus_handler
);
602 /* Return the first nonaddressible location > p (up) or */
603 /* the smallest location q s.t. [q,p] is addressible (!up). */
604 ptr_t
GC_find_limit(p
, up
)
609 static VOLATILE ptr_t result
;
610 /* Needs to be static, since otherwise it may not be */
611 /* preserved across the longjmp. Can safely be */
612 /* static since it's only called once, with the */
613 /* allocation lock held. */
616 GC_setup_temporary_fault_handler();
617 if (setjmp(GC_jmp_buf
) == 0) {
618 result
= (ptr_t
)(((word
)(p
))
619 & ~(MIN_PAGE_SIZE
-1));
622 result
+= MIN_PAGE_SIZE
;
624 result
-= MIN_PAGE_SIZE
;
626 GC_noop1((word
)(*result
));
629 GC_reset_fault_handler();
631 result
+= MIN_PAGE_SIZE
;
642 #ifdef LINUX_STACKBOTTOM
644 # define STAT_SKIP 27 /* Number of fields preceding startstack */
645 /* field in /proc/<pid>/stat */
647 ptr_t
GC_linux_stack_base(void)
655 sprintf(buf
, "/proc/%d/stat", getpid());
657 if (NULL
== f
) ABORT("Couldn't open /proc/<pid>/stat");
659 /* Skip the required number of fields. This number is hopefully */
660 /* constant across all Linux implementations. */
661 for (i
= 0; i
< STAT_SKIP
; ++i
) {
662 while (isspace(c
)) c
= getc(f
);
663 while (!isspace(c
)) c
= getc(f
);
665 while (isspace(c
)) c
= getc(f
);
671 if (result
< 0x10000000) ABORT("Absurd stack bottom value");
672 return (ptr_t
)result
;
675 #endif /* LINUX_STACKBOTTOM */
677 ptr_t
GC_get_stack_base()
682 # define STACKBOTTOM_ALIGNMENT_M1 ((word)STACK_GRAN - 1)
684 # if defined(STACKBASE)
685 extern ptr_t STACKBASE
;
692 # ifdef STACK_GROWS_DOWN
693 result
= (ptr_t
)((((word
)(&dummy
))
694 + STACKBOTTOM_ALIGNMENT_M1
)
695 & ~STACKBOTTOM_ALIGNMENT_M1
);
697 result
= (ptr_t
)(((word
)(&dummy
))
698 & ~STACKBOTTOM_ALIGNMENT_M1
);
700 # endif /* HEURISTIC1 */
701 # ifdef LINUX_STACKBOTTOM
702 result
= GC_linux_stack_base();
705 # ifdef STACK_GROWS_DOWN
706 result
= GC_find_limit((ptr_t
)(&dummy
), TRUE
);
707 # ifdef HEURISTIC2_LIMIT
708 if (result
> HEURISTIC2_LIMIT
709 && (ptr_t
)(&dummy
) < HEURISTIC2_LIMIT
) {
710 result
= HEURISTIC2_LIMIT
;
714 result
= GC_find_limit((ptr_t
)(&dummy
), FALSE
);
715 # ifdef HEURISTIC2_LIMIT
716 if (result
< HEURISTIC2_LIMIT
717 && (ptr_t
)(&dummy
) > HEURISTIC2_LIMIT
) {
718 result
= HEURISTIC2_LIMIT
;
723 # endif /* HEURISTIC2 */
724 # ifdef STACK_GROWS_DOWN
725 if (result
== 0) result
= (ptr_t
)(signed_word
)(-sizeof(ptr_t
));
728 # endif /* STACKBOTTOM */
729 # endif /* STACKBASE */
733 # endif /* ! AMIGA */
735 # endif /* ! MSWIN32 */
738 * Register static data segment(s) as roots.
739 * If more data segments are added later then they need to be registered
740 * add that point (as we do with SunOS dynamic loading),
741 * or GC_mark_roots needs to check for them (as we do with PCR).
742 * Called with allocator lock held.
747 void GC_register_data_segments()
751 HMODULE module_handle
;
755 struct exe_hdr hdrdos
; /* MSDOS header. */
756 struct e32_exe hdr386
; /* Real header for my executable */
757 struct o32_obj seg
; /* Currrent segment */
761 if (DosGetInfoBlocks(&ptib
, &ppib
) != NO_ERROR
) {
762 GC_err_printf0("DosGetInfoBlocks failed\n");
763 ABORT("DosGetInfoBlocks failed\n");
765 module_handle
= ppib
-> pib_hmte
;
766 if (DosQueryModuleName(module_handle
, PBUFSIZ
, path
) != NO_ERROR
) {
767 GC_err_printf0("DosQueryModuleName failed\n");
768 ABORT("DosGetInfoBlocks failed\n");
770 myexefile
= fopen(path
, "rb");
771 if (myexefile
== 0) {
772 GC_err_puts("Couldn't open executable ");
773 GC_err_puts(path
); GC_err_puts("\n");
774 ABORT("Failed to open executable\n");
776 if (fread((char *)(&hdrdos
), 1, sizeof hdrdos
, myexefile
) < sizeof hdrdos
) {
777 GC_err_puts("Couldn't read MSDOS header from ");
778 GC_err_puts(path
); GC_err_puts("\n");
779 ABORT("Couldn't read MSDOS header");
781 if (E_MAGIC(hdrdos
) != EMAGIC
) {
782 GC_err_puts("Executable has wrong DOS magic number: ");
783 GC_err_puts(path
); GC_err_puts("\n");
784 ABORT("Bad DOS magic number");
786 if (fseek(myexefile
, E_LFANEW(hdrdos
), SEEK_SET
) != 0) {
787 GC_err_puts("Seek to new header failed in ");
788 GC_err_puts(path
); GC_err_puts("\n");
789 ABORT("Bad DOS magic number");
791 if (fread((char *)(&hdr386
), 1, sizeof hdr386
, myexefile
) < sizeof hdr386
) {
792 GC_err_puts("Couldn't read MSDOS header from ");
793 GC_err_puts(path
); GC_err_puts("\n");
794 ABORT("Couldn't read OS/2 header");
796 if (E32_MAGIC1(hdr386
) != E32MAGIC1
|| E32_MAGIC2(hdr386
) != E32MAGIC2
) {
797 GC_err_puts("Executable has wrong OS/2 magic number:");
798 GC_err_puts(path
); GC_err_puts("\n");
799 ABORT("Bad OS/2 magic number");
801 if ( E32_BORDER(hdr386
) != E32LEBO
|| E32_WORDER(hdr386
) != E32LEWO
) {
802 GC_err_puts("Executable %s has wrong byte order: ");
803 GC_err_puts(path
); GC_err_puts("\n");
804 ABORT("Bad byte order");
806 if ( E32_CPU(hdr386
) == E32CPU286
) {
807 GC_err_puts("GC can't handle 80286 executables: ");
808 GC_err_puts(path
); GC_err_puts("\n");
811 if (fseek(myexefile
, E_LFANEW(hdrdos
) + E32_OBJTAB(hdr386
),
813 GC_err_puts("Seek to object table failed: ");
814 GC_err_puts(path
); GC_err_puts("\n");
815 ABORT("Seek to object table failed");
817 for (nsegs
= E32_OBJCNT(hdr386
); nsegs
> 0; nsegs
--) {
819 if (fread((char *)(&seg
), 1, sizeof seg
, myexefile
) < sizeof seg
) {
820 GC_err_puts("Couldn't read obj table entry from ");
821 GC_err_puts(path
); GC_err_puts("\n");
822 ABORT("Couldn't read obj table entry");
824 flags
= O32_FLAGS(seg
);
825 if (!(flags
& OBJWRITE
)) continue;
826 if (!(flags
& OBJREAD
)) continue;
827 if (flags
& OBJINVALID
) {
828 GC_err_printf0("Object with invalid pages?\n");
831 GC_add_roots_inner(O32_BASE(seg
), O32_BASE(seg
)+O32_SIZE(seg
), FALSE
);
838 /* Unfortunately, we have to handle win32s very differently from NT, */
839 /* Since VirtualQuery has very different semantics. In particular, */
840 /* under win32s a VirtualQuery call on an unmapped page returns an */
841 /* invalid result. Under GC_register_data_segments is a noop and */
842 /* all real work is done by GC_register_dynamic_libraries. Under */
843 /* win32s, we cannot find the data segments associated with dll's. */
844 /* We rgister the main data segment here. */
845 GC_bool GC_win32s
= FALSE
; /* We're running under win32s. */
847 GC_bool
GC_is_win32s()
849 DWORD v
= GetVersion();
851 /* Check that this is not NT, and Windows major version <= 3 */
852 return ((v
& 0x80000000) && (v
& 0xff) <= 3);
857 GC_win32s
= GC_is_win32s();
860 /* Return the smallest address a such that VirtualQuery */
861 /* returns correct results for all addresses between a and start. */
862 /* Assumes VirtualQuery returns correct information for start. */
863 ptr_t
GC_least_described_address(ptr_t start
)
865 MEMORY_BASIC_INFORMATION buf
;
872 GetSystemInfo(&sysinfo
);
873 limit
= sysinfo
.lpMinimumApplicationAddress
;
874 p
= (ptr_t
)((word
)start
& ~(GC_page_size
- 1));
876 q
= (LPVOID
)(p
- GC_page_size
);
877 if ((ptr_t
)q
> (ptr_t
)p
/* underflow */ || q
< limit
) break;
878 result
= VirtualQuery(q
, &buf
, sizeof(buf
));
879 if (result
!= sizeof(buf
) || buf
.AllocationBase
== 0) break;
880 p
= (ptr_t
)(buf
.AllocationBase
);
885 /* Is p the start of either the malloc heap, or of one of our */
887 GC_bool
GC_is_heap_base (ptr_t p
)
892 # ifndef REDIRECT_MALLOC
893 static ptr_t malloc_heap_pointer
= 0;
895 if (0 == malloc_heap_pointer
) {
896 MEMORY_BASIC_INFORMATION buf
;
897 register DWORD result
= VirtualQuery(malloc(1), &buf
, sizeof(buf
));
899 if (result
!= sizeof(buf
)) {
900 ABORT("Weird VirtualQuery result");
902 malloc_heap_pointer
= (ptr_t
)(buf
.AllocationBase
);
904 if (p
== malloc_heap_pointer
) return(TRUE
);
906 for (i
= 0; i
< GC_n_heap_bases
; i
++) {
907 if (GC_heap_bases
[i
] == p
) return(TRUE
);
912 void GC_register_root_section(ptr_t static_root
)
914 MEMORY_BASIC_INFORMATION buf
;
920 char * limit
, * new_limit
;
922 if (!GC_win32s
) return;
923 p
= base
= limit
= GC_least_described_address(static_root
);
924 GetSystemInfo(&sysinfo
);
925 while (p
< sysinfo
.lpMaximumApplicationAddress
) {
926 result
= VirtualQuery(p
, &buf
, sizeof(buf
));
927 if (result
!= sizeof(buf
) || buf
.AllocationBase
== 0
928 || GC_is_heap_base(buf
.AllocationBase
)) break;
929 new_limit
= (char *)p
+ buf
.RegionSize
;
930 protect
= buf
.Protect
;
931 if (buf
.State
== MEM_COMMIT
932 && is_writable(protect
)) {
933 if ((char *)p
== limit
) {
936 if (base
!= limit
) GC_add_roots_inner(base
, limit
, FALSE
);
941 if (p
> (LPVOID
)new_limit
/* overflow */) break;
942 p
= (LPVOID
)new_limit
;
944 if (base
!= limit
) GC_add_roots_inner(base
, limit
, FALSE
);
947 void GC_register_data_segments()
951 GC_register_root_section((ptr_t
)(&dummy
));
956 void GC_register_data_segments()
958 struct Process
*proc
;
959 struct CommandLineInterface
*cli
;
968 GC_bool found_segment
= FALSE
;
969 extern char __data_size
[];
971 dataSegSize
=__data_size
+8;
972 /* Can`t find the Location of __data_size, because
973 it`s possible that is it, inside the segment. */
977 proc
= (struct Process
*)SysBase
->ThisTask
;
979 /* Reference: Amiga Guru Book Pages: 538ff,565,573
981 if (proc
->pr_Task
.tc_Node
.ln_Type
==NT_PROCESS
) {
982 if (proc
->pr_CLI
== NULL
) {
983 myseglist
= proc
->pr_SegList
;
985 /* ProcLoaded 'Loaded as a command: '*/
986 cli
= BADDR(proc
->pr_CLI
);
987 myseglist
= cli
->cli_Module
;
990 ABORT("Not a Process.");
993 if (myseglist
== NULL
) {
994 ABORT("Arrrgh.. can't find segments, aborting");
997 /* xoper hunks Shell Process */
1000 for (data
= (ULONG
*)BADDR(myseglist
); data
!= NULL
;
1001 data
= (ULONG
*)BADDR(data
[0])) {
1002 if (((ULONG
) GC_register_data_segments
< (ULONG
) &data
[1]) ||
1003 ((ULONG
) GC_register_data_segments
> (ULONG
) &data
[1] + data
[-1])) {
1005 if (dataSegSize
== data
[-1]) {
1006 found_segment
= TRUE
;
1009 GC_add_roots_inner((char *)&data
[1],
1010 ((char *)&data
[1]) + data
[-1], FALSE
);
1015 if (!found_segment
) {
1016 ABORT("Can`t find correct Segments.\nSolution: Use an newer version of ixemul.library");
1021 #if 0 /* old version */
1022 void GC_register_data_segments()
1024 extern struct WBStartup
*_WBenchMsg
;
1025 struct Process
*proc
;
1026 struct CommandLineInterface
*cli
;
1030 if ( _WBenchMsg
!= 0 ) {
1031 if ((myseglist
= _WBenchMsg
->sm_Segment
) == 0) {
1032 GC_err_puts("No seglist from workbench\n");
1036 if ((proc
= (struct Process
*)FindTask(0)) == 0) {
1037 GC_err_puts("Cannot find process structure\n");
1040 if ((cli
= BADDR(proc
->pr_CLI
)) == 0) {
1041 GC_err_puts("No CLI\n");
1044 if ((myseglist
= cli
->cli_Module
) == 0) {
1045 GC_err_puts("No seglist from CLI\n");
1050 for (data
= (ULONG
*)BADDR(myseglist
); data
!= 0;
1051 data
= (ULONG
*)BADDR(data
[0])) {
1052 # ifdef AMIGA_SKIP_SEG
1053 if (((ULONG
) GC_register_data_segments
< (ULONG
) &data
[1]) ||
1054 ((ULONG
) GC_register_data_segments
> (ULONG
) &data
[1] + data
[-1])) {
1057 # endif /* AMIGA_SKIP_SEG */
1058 GC_add_roots_inner((char *)&data
[1],
1059 ((char *)&data
[1]) + data
[-1], FALSE
);
1063 #endif /* old version */
1068 # if (defined(SVR4) || defined(AUX) || defined(DGUX)) && !defined(PCR)
1069 char * GC_SysVGetDataStart(max_page_size
, etext_addr
)
1073 word text_end
= ((word
)(etext_addr
) + sizeof(word
) - 1)
1074 & ~(sizeof(word
) - 1);
1075 /* etext rounded to word boundary */
1076 word next_page
= ((text_end
+ (word
)max_page_size
- 1)
1077 & ~((word
)max_page_size
- 1));
1078 word page_offset
= (text_end
& ((word
)max_page_size
- 1));
1079 VOLATILE
char * result
= (char *)(next_page
+ page_offset
);
1080 /* Note that this isnt equivalent to just adding */
1081 /* max_page_size to &etext if &etext is at a page boundary */
1083 GC_setup_temporary_fault_handler();
1084 if (setjmp(GC_jmp_buf
) == 0) {
1085 /* Try writing to the address. */
1087 GC_reset_fault_handler();
1089 GC_reset_fault_handler();
1090 /* We got here via a longjmp. The address is not readable. */
1091 /* This is known to happen under Solaris 2.4 + gcc, which place */
1092 /* string constants in the text segment, but after etext. */
1093 /* Use plan B. Note that we now know there is a gap between */
1094 /* text and data segments, so plan A bought us something. */
1095 result
= (char *)GC_find_limit((ptr_t
)(DATAEND
) - MIN_PAGE_SIZE
, FALSE
);
1097 return((char *)result
);
1102 void GC_register_data_segments()
1104 # if !defined(PCR) && !defined(SRC_M3) && !defined(NEXT) && !defined(MACOS) \
1106 # if defined(REDIRECT_MALLOC) && defined(SOLARIS_THREADS)
1107 /* As of Solaris 2.3, the Solaris threads implementation */
1108 /* allocates the data structure for the initial thread with */
1109 /* sbrk at process startup. It needs to be scanned, so that */
1110 /* we don't lose some malloc allocated data structures */
1111 /* hanging from it. We're on thin ice here ... */
1112 extern caddr_t
sbrk();
1114 GC_add_roots_inner(DATASTART
, (char *)sbrk(0), FALSE
);
1116 GC_add_roots_inner(DATASTART
, (char *)(DATAEND
), FALSE
);
1119 # if !defined(PCR) && (defined(NEXT) || defined(MACOSX))
1120 GC_add_roots_inner(DATASTART
, (char *) get_end(), FALSE
);
1124 # if defined(THINK_C)
1125 extern void* GC_MacGetDataStart(void);
1126 /* globals begin above stack and end at a5. */
1127 GC_add_roots_inner((ptr_t
)GC_MacGetDataStart(),
1128 (ptr_t
)LMGetCurrentA5(), FALSE
);
1130 # if defined(__MWERKS__)
1132 extern void* GC_MacGetDataStart(void);
1133 /* MATTHEW: Function to handle Far Globals (CW Pro 3) */
1134 # if __option(far_data)
1135 extern void* GC_MacGetDataEnd(void);
1137 /* globals begin above stack and end at a5. */
1138 GC_add_roots_inner((ptr_t
)GC_MacGetDataStart(),
1139 (ptr_t
)LMGetCurrentA5(), FALSE
);
1140 /* MATTHEW: Handle Far Globals */
1141 # if __option(far_data)
1142 /* Far globals follow he QD globals: */
1143 GC_add_roots_inner((ptr_t
)LMGetCurrentA5(),
1144 (ptr_t
)GC_MacGetDataEnd(), FALSE
);
1147 extern char __data_start__
[], __data_end__
[];
1148 GC_add_roots_inner((ptr_t
)&__data_start__
,
1149 (ptr_t
)&__data_end__
, FALSE
);
1150 # endif /* __POWERPC__ */
1151 # endif /* __MWERKS__ */
1152 # endif /* !THINK_C */
1156 /* Dynamic libraries are added at every collection, since they may */
1160 # endif /* ! AMIGA */
1161 # endif /* ! MSWIN32 */
1165 * Auxiliary routines for obtaining memory from OS.
1168 # if !defined(OS2) && !defined(PCR) && !defined(AMIGA) \
1169 && !defined(MSWIN32) && !defined(MACOS) && !defined(DOS4GW)
1172 extern caddr_t
sbrk();
1175 # define SBRK_ARG_T ptrdiff_t
1177 # define SBRK_ARG_T int
1181 /* The compiler seems to generate speculative reads one past the end of */
1182 /* an allocated object. Hence we need to make sure that the page */
1183 /* following the last heap page is also mapped. */
1184 ptr_t
GC_unix_get_mem(bytes
)
1187 caddr_t cur_brk
= (caddr_t
)sbrk(0);
1189 SBRK_ARG_T lsbs
= (word
)cur_brk
& (GC_page_size
-1);
1190 static caddr_t my_brk_val
= 0;
1192 if ((SBRK_ARG_T
)bytes
< 0) return(0); /* too big */
1194 if((caddr_t
)(sbrk(GC_page_size
- lsbs
)) == (caddr_t
)(-1)) return(0);
1196 if (cur_brk
== my_brk_val
) {
1197 /* Use the extra block we allocated last time. */
1198 result
= (ptr_t
)sbrk((SBRK_ARG_T
)bytes
);
1199 if (result
== (caddr_t
)(-1)) return(0);
1200 result
-= GC_page_size
;
1202 result
= (ptr_t
)sbrk(GC_page_size
+ (SBRK_ARG_T
)bytes
);
1203 if (result
== (caddr_t
)(-1)) return(0);
1205 my_brk_val
= result
+ bytes
+ GC_page_size
; /* Always page aligned */
1206 return((ptr_t
)result
);
1209 #else /* Not RS6000 */
1211 #if defined(USE_MMAP)
1212 /* Tested only under IRIX5 and Solaris 2 */
1214 #ifdef USE_MMAP_FIXED
1215 # define GC_MMAP_FLAGS MAP_FIXED | MAP_PRIVATE
1216 /* Seems to yield better performance on Solaris 2, but can */
1217 /* be unreliable if something is already mapped at the address. */
1219 # define GC_MMAP_FLAGS MAP_PRIVATE
1222 ptr_t
GC_unix_get_mem(bytes
)
1225 static GC_bool initialized
= FALSE
;
1228 static ptr_t last_addr
= HEAP_START
;
1231 fd
= open("/dev/zero", O_RDONLY
);
1234 if (bytes
& (GC_page_size
-1)) ABORT("Bad GET_MEM arg");
1235 result
= mmap(last_addr
, bytes
, PROT_READ
| PROT_WRITE
| OPT_PROT_EXEC
,
1236 GC_MMAP_FLAGS
, fd
, 0/* offset */);
1237 if (result
== MAP_FAILED
) return(0);
1238 last_addr
= (ptr_t
)result
+ bytes
+ GC_page_size
- 1;
1239 last_addr
= (ptr_t
)((word
)last_addr
& ~(GC_page_size
- 1));
1240 return((ptr_t
)result
);
1243 #else /* Not RS6000, not USE_MMAP */
1244 ptr_t
GC_unix_get_mem(bytes
)
1249 /* Bare sbrk isn't thread safe. Play by malloc rules. */
1250 /* The equivalent may be needed on other systems as well. */
1254 ptr_t cur_brk
= (ptr_t
)sbrk(0);
1255 SBRK_ARG_T lsbs
= (word
)cur_brk
& (GC_page_size
-1);
1257 if ((SBRK_ARG_T
)bytes
< 0) return(0); /* too big */
1259 if((ptr_t
)sbrk(GC_page_size
- lsbs
) == (ptr_t
)(-1)) return(0);
1261 result
= (ptr_t
)sbrk((SBRK_ARG_T
)bytes
);
1262 if (result
== (ptr_t
)(-1)) result
= 0;
1270 #endif /* Not USE_MMAP */
1271 #endif /* Not RS6000 */
1277 void * os2_alloc(size_t bytes
)
1281 if (DosAllocMem(&result
, bytes
, PAG_EXECUTE
| PAG_READ
|
1282 PAG_WRITE
| PAG_COMMIT
)
1286 if (result
== 0) return(os2_alloc(bytes
));
1294 word GC_n_heap_bases
= 0;
1296 ptr_t
GC_win32_get_mem(bytes
)
1302 /* VirtualAlloc doesn't like PAGE_EXECUTE_READWRITE. */
1303 /* There are also unconfirmed rumors of other */
1304 /* problems, so we dodge the issue. */
1305 result
= (ptr_t
) GlobalAlloc(0, bytes
+ HBLKSIZE
);
1306 result
= (ptr_t
)(((word
)result
+ HBLKSIZE
) & ~(HBLKSIZE
-1));
1308 result
= (ptr_t
) VirtualAlloc(NULL
, bytes
,
1309 MEM_COMMIT
| MEM_RESERVE
,
1310 PAGE_EXECUTE_READWRITE
);
1312 if (HBLKDISPL(result
) != 0) ABORT("Bad VirtualAlloc result");
1313 /* If I read the documentation correctly, this can */
1314 /* only happen if HBLKSIZE > 64k or not a power of 2. */
1315 if (GC_n_heap_bases
>= MAX_HEAP_SECTS
) ABORT("Too many heap sections");
1316 GC_heap_bases
[GC_n_heap_bases
++] = result
;
1320 void GC_win32_free_heap ()
1323 while (GC_n_heap_bases
> 0) {
1324 GlobalFree (GC_heap_bases
[--GC_n_heap_bases
]);
1325 GC_heap_bases
[GC_n_heap_bases
] = 0;
1335 /* For now, this only works on some Unix-like systems. If you */
1336 /* have something else, don't define USE_MUNMAP. */
1337 /* We assume ANSI C to support this feature. */
1339 #include <sys/mman.h>
1340 #include <sys/stat.h>
1341 #include <sys/types.h>
1344 /* Compute a page aligned starting address for the unmap */
1345 /* operation on a block of size bytes starting at start. */
1346 /* Return 0 if the block is too small to make this feasible. */
1347 ptr_t
GC_unmap_start(ptr_t start
, word bytes
)
1349 ptr_t result
= start
;
1350 /* Round start to next page boundary. */
1351 result
+= GC_page_size
- 1;
1352 result
= (ptr_t
)((word
)result
& ~(GC_page_size
- 1));
1353 if (result
+ GC_page_size
> start
+ bytes
) return 0;
1357 /* Compute end address for an unmap operation on the indicated */
1359 ptr_t
GC_unmap_end(ptr_t start
, word bytes
)
1361 ptr_t end_addr
= start
+ bytes
;
1362 end_addr
= (ptr_t
)((word
)end_addr
& ~(GC_page_size
- 1));
1366 /* We assume that GC_remap is called on exactly the same range */
1367 /* as a previous call to GC_unmap. It is safe to consistently */
1368 /* round the endpoints in both places. */
1369 void GC_unmap(ptr_t start
, word bytes
)
1371 ptr_t start_addr
= GC_unmap_start(start
, bytes
);
1372 ptr_t end_addr
= GC_unmap_end(start
, bytes
);
1373 word len
= end_addr
- start_addr
;
1374 if (0 == start_addr
) return;
1375 if (munmap(start_addr
, len
) != 0) ABORT("munmap failed");
1376 GC_unmapped_bytes
+= len
;
1380 void GC_remap(ptr_t start
, word bytes
)
1382 static int zero_descr
= -1;
1383 ptr_t start_addr
= GC_unmap_start(start
, bytes
);
1384 ptr_t end_addr
= GC_unmap_end(start
, bytes
);
1385 word len
= end_addr
- start_addr
;
1388 if (-1 == zero_descr
) zero_descr
= open("/dev/zero", O_RDWR
);
1389 if (0 == start_addr
) return;
1390 result
= mmap(start_addr
, len
, PROT_READ
| PROT_WRITE
| OPT_PROT_EXEC
,
1391 MAP_FIXED
| MAP_PRIVATE
, zero_descr
, 0);
1392 if (result
!= start_addr
) {
1393 ABORT("mmap remapping failed");
1395 GC_unmapped_bytes
-= len
;
1398 /* Two adjacent blocks have already been unmapped and are about to */
1399 /* be merged. Unmap the whole block. This typically requires */
1400 /* that we unmap a small section in the middle that was not previously */
1401 /* unmapped due to alignment constraints. */
1402 void GC_unmap_gap(ptr_t start1
, word bytes1
, ptr_t start2
, word bytes2
)
1404 ptr_t start1_addr
= GC_unmap_start(start1
, bytes1
);
1405 ptr_t end1_addr
= GC_unmap_end(start1
, bytes1
);
1406 ptr_t start2_addr
= GC_unmap_start(start2
, bytes2
);
1407 ptr_t end2_addr
= GC_unmap_end(start2
, bytes2
);
1408 ptr_t start_addr
= end1_addr
;
1409 ptr_t end_addr
= start2_addr
;
1411 GC_ASSERT(start1
+ bytes1
== start2
);
1412 if (0 == start1_addr
) start_addr
= GC_unmap_start(start1
, bytes1
+ bytes2
);
1413 if (0 == start2_addr
) end_addr
= GC_unmap_end(start1
, bytes1
+ bytes2
);
1414 if (0 == start_addr
) return;
1415 len
= end_addr
- start_addr
;
1416 if (len
!= 0 && munmap(start_addr
, len
) != 0) ABORT("munmap failed");
1417 GC_unmapped_bytes
+= len
;
1420 #endif /* USE_MUNMAP */
1422 /* Routine for pushing any additional roots. In THREADS */
1423 /* environment, this is also responsible for marking from */
1424 /* thread stacks. In the SRC_M3 case, it also handles */
1425 /* global variables. */
1427 void (*GC_push_other_roots
)() = 0;
1431 PCR_ERes
GC_push_thread_stack(PCR_Th_T
*t
, PCR_Any dummy
)
1433 struct PCR_ThCtl_TInfoRep info
;
1436 info
.ti_stkLow
= info
.ti_stkHi
= 0;
1437 result
= PCR_ThCtl_GetInfo(t
, &info
);
1438 GC_push_all_stack((ptr_t
)(info
.ti_stkLow
), (ptr_t
)(info
.ti_stkHi
));
1442 /* Push the contents of an old object. We treat this as stack */
1443 /* data only becasue that makes it robust against mark stack */
1445 PCR_ERes
GC_push_old_obj(void *p
, size_t size
, PCR_Any data
)
1447 GC_push_all_stack((ptr_t
)p
, (ptr_t
)p
+ size
);
1448 return(PCR_ERes_okay
);
1452 void GC_default_push_other_roots()
1454 /* Traverse data allocated by previous memory managers. */
1456 extern struct PCR_MM_ProcsRep
* GC_old_allocator
;
1458 if ((*(GC_old_allocator
->mmp_enumerate
))(PCR_Bool_false
,
1461 ABORT("Old object enumeration failed");
1464 /* Traverse all thread stacks. */
1466 PCR_ThCtl_ApplyToAllOtherThreads(GC_push_thread_stack
,0))
1467 || PCR_ERes_IsErr(GC_push_thread_stack(PCR_Th_CurrThread(), 0))) {
1468 ABORT("Thread stack marking failed\n");
1476 # ifdef ALL_INTERIOR_POINTERS
1481 extern void ThreadF__ProcessStacks();
1483 void GC_push_thread_stack(start
, stop
)
1486 GC_push_all_stack((ptr_t
)start
, (ptr_t
)stop
+ sizeof(word
));
1489 /* Push routine with M3 specific calling convention. */
1490 GC_m3_push_root(dummy1
, p
, dummy2
, dummy3
)
1492 ptr_t dummy1
, dummy2
;
1497 if ((ptr_t
)(q
) >= GC_least_plausible_heap_addr
1498 && (ptr_t
)(q
) < GC_greatest_plausible_heap_addr
) {
1499 GC_push_one_checked(q
,FALSE
);
1503 /* M3 set equivalent to RTHeap.TracedRefTypes */
1504 typedef struct { int elts
[1]; } RefTypeSet
;
1505 RefTypeSet GC_TracedRefTypes
= {{0x1}};
1507 /* From finalize.c */
1508 extern void GC_push_finalizer_structures();
1510 /* From stubborn.c: */
1511 # ifdef STUBBORN_ALLOC
1512 extern GC_PTR
* GC_changing_list_start
;
1516 void GC_default_push_other_roots()
1518 /* Use the M3 provided routine for finding static roots. */
1519 /* This is a bit dubious, since it presumes no C roots. */
1520 /* We handle the collector roots explicitly. */
1522 # ifdef STUBBORN_ALLOC
1523 GC_push_one(GC_changing_list_start
);
1525 GC_push_finalizer_structures();
1526 RTMain__GlobalMapProc(GC_m3_push_root
, 0, GC_TracedRefTypes
);
1528 if (GC_words_allocd
> 0) {
1529 ThreadF__ProcessStacks(GC_push_thread_stack
);
1531 /* Otherwise this isn't absolutely necessary, and we have */
1532 /* startup ordering problems. */
1535 # endif /* SRC_M3 */
1537 # if defined(SOLARIS_THREADS) || defined(WIN32_THREADS) \
1538 || defined(IRIX_THREADS) || defined(LINUX_THREADS) \
1539 || defined(IRIX_JDK_THREADS) || defined(HPUX_THREADS) \
1540 || defined(QUICK_THREADS)
1542 extern void GC_push_all_stacks();
1544 void GC_default_push_other_roots()
1546 GC_push_all_stacks();
1549 # endif /* SOLARIS_THREADS || ... */
1551 void (*GC_push_other_roots
)() = GC_default_push_other_roots
;
1556 * Routines for accessing dirty bits on virtual pages.
1557 * We plan to eventaually implement four strategies for doing so:
1558 * DEFAULT_VDB: A simple dummy implementation that treats every page
1559 * as possibly dirty. This makes incremental collection
1560 * useless, but the implementation is still correct.
1561 * PCR_VDB: Use PPCRs virtual dirty bit facility.
1562 * PROC_VDB: Use the /proc facility for reading dirty bits. Only
1563 * works under some SVR4 variants. Even then, it may be
1564 * too slow to be entirely satisfactory. Requires reading
1565 * dirty bits for entire address space. Implementations tend
1566 * to assume that the client is a (slow) debugger.
1567 * MPROTECT_VDB:Protect pages and then catch the faults to keep track of
1568 * dirtied pages. The implementation (and implementability)
1569 * is highly system dependent. This usually fails when system
1570 * calls write to a protected page. We prevent the read system
1571 * call from doing so. It is the clients responsibility to
1572 * make sure that other system calls are similarly protected
1573 * or write only to the stack.
1576 GC_bool GC_dirty_maintained
= FALSE
;
1580 /* All of the following assume the allocation lock is held, and */
1581 /* signals are disabled. */
1583 /* The client asserts that unallocated pages in the heap are never */
1586 /* Initialize virtual dirty bit implementation. */
1587 void GC_dirty_init()
1589 GC_dirty_maintained
= TRUE
;
1592 /* Retrieve system dirty bits for heap to a local buffer. */
1593 /* Restore the systems notion of which pages are dirty. */
1594 void GC_read_dirty()
1597 /* Is the HBLKSIZE sized page at h marked dirty in the local buffer? */
1598 /* If the actual page size is different, this returns TRUE if any */
1599 /* of the pages overlapping h are dirty. This routine may err on the */
1600 /* side of labelling pages as dirty (and this implementation does). */
1602 GC_bool
GC_page_was_dirty(h
)
1609 * The following two routines are typically less crucial. They matter
1610 * most with large dynamic libraries, or if we can't accurately identify
1611 * stacks, e.g. under Solaris 2.X. Otherwise the following default
1612 * versions are adequate.
1615 /* Could any valid GC heap pointer ever have been written to this page? */
1617 GC_bool
GC_page_was_ever_dirty(h
)
1623 /* Reset the n pages starting at h to "was never dirty" status. */
1624 void GC_is_fresh(h
, n
)
1630 /* A call hints that h is about to be written. */
1631 /* May speed up some dirty bit implementations. */
1633 void GC_write_hint(h
)
1638 # endif /* DEFAULT_VDB */
1641 # ifdef MPROTECT_VDB
1644 * See DEFAULT_VDB for interface descriptions.
1648 * This implementation maintains dirty bits itself by catching write
1649 * faults and keeping track of them. We assume nobody else catches
1650 * SIGBUS or SIGSEGV. We assume no write faults occur in system calls
1651 * except as a result of a read system call. This means clients must
1652 * either ensure that system calls do not touch the heap, or must
1653 * provide their own wrappers analogous to the one for read.
1654 * We assume the page size is a multiple of HBLKSIZE.
1655 * This implementation is currently SunOS 4.X and IRIX 5.X specific, though we
1656 * tried to use portable code where easily possible. It is known
1657 * not to work under a number of other systems.
1662 # include <sys/mman.h>
1663 # include <signal.h>
1664 # include <sys/syscall.h>
1666 # define PROTECT(addr, len) \
1667 if (mprotect((caddr_t)(addr), (size_t)(len), \
1668 PROT_READ | OPT_PROT_EXEC) < 0) { \
1669 ABORT("mprotect failed"); \
1671 # define UNPROTECT(addr, len) \
1672 if (mprotect((caddr_t)(addr), (size_t)(len), \
1673 PROT_WRITE | PROT_READ | OPT_PROT_EXEC ) < 0) { \
1674 ABORT("un-mprotect failed"); \
1679 # include <signal.h>
1681 static DWORD protect_junk
;
1682 # define PROTECT(addr, len) \
1683 if (!VirtualProtect((addr), (len), PAGE_EXECUTE_READ, \
1685 DWORD last_error = GetLastError(); \
1686 GC_printf1("Last error code: %lx\n", last_error); \
1687 ABORT("VirtualProtect failed"); \
1689 # define UNPROTECT(addr, len) \
1690 if (!VirtualProtect((addr), (len), PAGE_EXECUTE_READWRITE, \
1692 ABORT("un-VirtualProtect failed"); \
1697 #if defined(SUNOS4) || defined(FREEBSD)
1698 typedef void (* SIG_PF
)();
1700 #if defined(SUNOS5SIGS) || defined(OSF1) || defined(LINUX)
1702 typedef void (* SIG_PF
)(int);
1704 typedef void (* SIG_PF
)();
1707 #if defined(MSWIN32)
1708 typedef LPTOP_LEVEL_EXCEPTION_FILTER SIG_PF
;
1710 # define SIG_DFL (LPTOP_LEVEL_EXCEPTION_FILTER) (-1)
1713 #if defined(IRIX5) || defined(OSF1)
1714 typedef void (* REAL_SIG_PF
)(int, int, struct sigcontext
*);
1716 #if defined(SUNOS5SIGS)
1718 # define SIGINFO __siginfo
1720 # define SIGINFO siginfo
1723 typedef void (* REAL_SIG_PF
)(int, struct SIGINFO
*, void *);
1725 typedef void (* REAL_SIG_PF
)();
1729 # include <linux/version.h>
1730 # if (LINUX_VERSION_CODE >= 0x20100) && !defined(M68K) || defined(ALPHA) || defined(IA64)
1731 typedef struct sigcontext s_c
;
1733 typedef struct sigcontext_struct s_c
;
1735 # if defined(ALPHA) || defined(M68K)
1736 typedef void (* REAL_SIG_PF
)(int, int, s_c
*);
1739 typedef void (* REAL_SIG_PF
)(int, siginfo_t
*, s_c
*);
1741 typedef void (* REAL_SIG_PF
)(int, s_c
);
1745 /* Retrieve fault address from sigcontext structure by decoding */
1747 char * get_fault_addr(s_c
*sc
) {
1751 instr
= *((unsigned *)(sc
->sc_pc
));
1752 faultaddr
= sc
->sc_regs
[(instr
>> 16) & 0x1f];
1753 faultaddr
+= (word
) (((int)instr
<< 16) >> 16);
1754 return (char *)faultaddr
;
1756 # endif /* !ALPHA */
1759 SIG_PF GC_old_bus_handler
;
1760 SIG_PF GC_old_segv_handler
; /* Also old MSWIN32 ACCESS_VIOLATION filter */
1763 # if defined (SUNOS4) || defined(FREEBSD)
1764 void GC_write_fault_handler(sig
, code
, scp
, addr
)
1766 struct sigcontext
*scp
;
1769 # define SIG_OK (sig == SIGSEGV || sig == SIGBUS)
1770 # define CODE_OK (FC_CODE(code) == FC_PROT \
1771 || (FC_CODE(code) == FC_OBJERR \
1772 && FC_ERRNO(code) == FC_PROT))
1775 # define SIG_OK (sig == SIGBUS)
1776 # define CODE_OK (code == BUS_PAGE_FAULT)
1779 # if defined(IRIX5) || defined(OSF1)
1781 void GC_write_fault_handler(int sig
, int code
, struct sigcontext
*scp
)
1782 # define SIG_OK (sig == SIGSEGV)
1784 # define CODE_OK (code == 2 /* experimentally determined */)
1787 # define CODE_OK (code == EACCES)
1791 # if defined(ALPHA) || defined(M68K)
1792 void GC_write_fault_handler(int sig
, int code
, s_c
* sc
)
1795 void GC_write_fault_handler(int sig
, siginfo_t
* si
, s_c
* scp
)
1797 void GC_write_fault_handler(int sig
, s_c sc
)
1800 # define SIG_OK (sig == SIGSEGV)
1801 # define CODE_OK TRUE
1802 /* Empirically c.trapno == 14, on IA32, but is that useful? */
1803 /* Should probably consider alignment issues on other */
1804 /* architectures. */
1806 # if defined(SUNOS5SIGS)
1808 void GC_write_fault_handler(int sig
, struct SIGINFO
*scp
, void * context
)
1810 void GC_write_fault_handler(sig
, scp
, context
)
1812 struct SIGINFO
*scp
;
1816 # define SIG_OK (sig == SIGSEGV || sig == SIGBUS)
1817 # define CODE_OK (scp -> si_code == SEGV_ACCERR) \
1818 || (scp -> si_code == BUS_ADRERR) \
1819 || (scp -> si_code == BUS_UNKNOWN) \
1820 || (scp -> si_code == SEGV_UNKNOWN) \
1821 || (scp -> si_code == BUS_OBJERR)
1823 # define SIG_OK (sig == SIGSEGV)
1824 # define CODE_OK (scp -> si_code == SEGV_ACCERR)
1827 # if defined(MSWIN32)
1828 LONG WINAPI
GC_write_fault_handler(struct _EXCEPTION_POINTERS
*exc_info
)
1829 # define SIG_OK (exc_info -> ExceptionRecord -> ExceptionCode == \
1830 EXCEPTION_ACCESS_VIOLATION)
1831 # define CODE_OK (exc_info -> ExceptionRecord -> ExceptionInformation[0] == 1)
1835 register unsigned i
;
1837 char * addr
= (char *) (size_t) (scp
-> sc_badvaddr
);
1839 # if defined(OSF1) && defined(ALPHA)
1840 char * addr
= (char *) (scp
-> sc_traparg_a0
);
1843 char * addr
= (char *) (scp
-> si_addr
);
1847 char * addr
= (char *) (sc
.cr2
);
1852 struct sigcontext
*scp
= (struct sigcontext
*)(&sc
);
1854 int format
= (scp
->sc_formatvec
>> 12) & 0xf;
1855 unsigned long *framedata
= (unsigned long *)(scp
+ 1);
1858 if (format
== 0xa || format
== 0xb) {
1861 } else if (format
== 7) {
1864 } else if (format
== 4) {
1867 if (framedata
[1] & 0x08000000) {
1868 /* correct addr on misaligned access */
1869 ea
= (ea
+4095)&(~4095);
1875 char * addr
= get_fault_addr(sc
);
1878 char * addr
= si
-> si_addr
;
1880 # if defined(POWERPC)
1881 char * addr
= (char *) (sc
.regs
->dar
);
1883 --> architecture
not supported
1890 # if defined(MSWIN32)
1891 char * addr
= (char *) (exc_info
-> ExceptionRecord
1892 -> ExceptionInformation
[1]);
1893 # define sig SIGSEGV
1896 if (SIG_OK
&& CODE_OK
) {
1897 register struct hblk
* h
=
1898 (struct hblk
*)((word
)addr
& ~(GC_page_size
-1));
1899 GC_bool in_allocd_block
;
1902 /* Address is only within the correct physical page. */
1903 in_allocd_block
= FALSE
;
1904 for (i
= 0; i
< divHBLKSZ(GC_page_size
); i
++) {
1905 if (HDR(h
+i
) != 0) {
1906 in_allocd_block
= TRUE
;
1910 in_allocd_block
= (HDR(addr
) != 0);
1912 if (!in_allocd_block
) {
1913 /* Heap blocks now begin and end on page boundaries */
1916 if (sig
== SIGSEGV
) {
1917 old_handler
= GC_old_segv_handler
;
1919 old_handler
= GC_old_bus_handler
;
1921 if (old_handler
== SIG_DFL
) {
1923 GC_err_printf1("Segfault at 0x%lx\n", addr
);
1924 ABORT("Unexpected bus error or segmentation fault");
1926 return(EXCEPTION_CONTINUE_SEARCH
);
1929 # if defined (SUNOS4) || defined(FREEBSD)
1930 (*old_handler
) (sig
, code
, scp
, addr
);
1933 # if defined (SUNOS5SIGS)
1934 (*(REAL_SIG_PF
)old_handler
) (sig
, scp
, context
);
1937 # if defined (LINUX)
1938 # if defined(ALPHA) || defined(M68K)
1939 (*(REAL_SIG_PF
)old_handler
) (sig
, code
, sc
);
1942 (*(REAL_SIG_PF
)old_handler
) (sig
, si
, scp
);
1944 (*(REAL_SIG_PF
)old_handler
) (sig
, sc
);
1949 # if defined (IRIX5) || defined(OSF1)
1950 (*(REAL_SIG_PF
)old_handler
) (sig
, code
, scp
);
1954 return((*old_handler
)(exc_info
));
1958 for (i
= 0; i
< divHBLKSZ(GC_page_size
); i
++) {
1959 register int index
= PHT_HASH(h
+i
);
1961 set_pht_entry_from_index(GC_dirty_pages
, index
);
1963 UNPROTECT(h
, GC_page_size
);
1964 # if defined(OSF1) || defined(LINUX)
1965 /* These reset the signal handler each time by default. */
1966 signal(SIGSEGV
, (SIG_PF
) GC_write_fault_handler
);
1968 /* The write may not take place before dirty bits are read. */
1969 /* But then we'll fault again ... */
1971 return(EXCEPTION_CONTINUE_EXECUTION
);
1977 return EXCEPTION_CONTINUE_SEARCH
;
1979 GC_err_printf1("Segfault at 0x%lx\n", addr
);
1980 ABORT("Unexpected bus error or segmentation fault");
1985 * We hold the allocation lock. We expect block h to be written
1988 void GC_write_hint(h
)
1991 register struct hblk
* h_trunc
;
1992 register unsigned i
;
1993 register GC_bool found_clean
;
1995 if (!GC_dirty_maintained
) return;
1996 h_trunc
= (struct hblk
*)((word
)h
& ~(GC_page_size
-1));
1997 found_clean
= FALSE
;
1998 for (i
= 0; i
< divHBLKSZ(GC_page_size
); i
++) {
1999 register int index
= PHT_HASH(h_trunc
+i
);
2001 if (!get_pht_entry_from_index(GC_dirty_pages
, index
)) {
2003 set_pht_entry_from_index(GC_dirty_pages
, index
);
2007 UNPROTECT(h_trunc
, GC_page_size
);
2011 void GC_dirty_init()
2013 #if defined(SUNOS5SIGS) || defined(IRIX5) /* || defined(OSF1) */
2014 struct sigaction act
, oldact
;
2016 act
.sa_flags
= SA_RESTART
;
2017 act
.sa_handler
= GC_write_fault_handler
;
2019 act
.sa_flags
= SA_RESTART
| SA_SIGINFO
;
2020 act
.sa_sigaction
= GC_write_fault_handler
;
2022 (void)sigemptyset(&act
.sa_mask
);
2025 GC_printf0("Inititalizing mprotect virtual dirty bit implementation\n");
2027 GC_dirty_maintained
= TRUE
;
2028 if (GC_page_size
% HBLKSIZE
!= 0) {
2029 GC_err_printf0("Page size not multiple of HBLKSIZE\n");
2030 ABORT("Page size not multiple of HBLKSIZE");
2032 # if defined(SUNOS4) || defined(FREEBSD)
2033 GC_old_bus_handler
= signal(SIGBUS
, GC_write_fault_handler
);
2034 if (GC_old_bus_handler
== SIG_IGN
) {
2035 GC_err_printf0("Previously ignored bus error!?");
2036 GC_old_bus_handler
= SIG_DFL
;
2038 if (GC_old_bus_handler
!= SIG_DFL
) {
2040 GC_err_printf0("Replaced other SIGBUS handler\n");
2044 # if defined(OSF1) || defined(SUNOS4) || defined(LINUX)
2045 GC_old_segv_handler
= signal(SIGSEGV
, (SIG_PF
)GC_write_fault_handler
);
2046 if (GC_old_segv_handler
== SIG_IGN
) {
2047 GC_err_printf0("Previously ignored segmentation violation!?");
2048 GC_old_segv_handler
= SIG_DFL
;
2050 if (GC_old_segv_handler
!= SIG_DFL
) {
2052 GC_err_printf0("Replaced other SIGSEGV handler\n");
2056 # if defined(SUNOS5SIGS) || defined(IRIX5)
2057 # if defined(IRIX_THREADS) || defined(IRIX_JDK_THREADS)
2058 sigaction(SIGSEGV
, 0, &oldact
);
2059 sigaction(SIGSEGV
, &act
, 0);
2061 sigaction(SIGSEGV
, &act
, &oldact
);
2063 # if defined(_sigargs)
2064 /* This is Irix 5.x, not 6.x. Irix 5.x does not have */
2066 GC_old_segv_handler
= oldact
.sa_handler
;
2067 # else /* Irix 6.x or SUNOS5SIGS */
2068 if (oldact
.sa_flags
& SA_SIGINFO
) {
2069 GC_old_segv_handler
= (SIG_PF
)(oldact
.sa_sigaction
);
2071 GC_old_segv_handler
= oldact
.sa_handler
;
2074 if (GC_old_segv_handler
== SIG_IGN
) {
2075 GC_err_printf0("Previously ignored segmentation violation!?");
2076 GC_old_segv_handler
= SIG_DFL
;
2078 if (GC_old_segv_handler
!= SIG_DFL
) {
2080 GC_err_printf0("Replaced other SIGSEGV handler\n");
2084 sigaction(SIGBUS
, &act
, &oldact
);
2085 GC_old_bus_handler
= oldact
.sa_handler
;
2086 if (GC_old_segv_handler
!= SIG_DFL
) {
2088 GC_err_printf0("Replaced other SIGBUS handler\n");
2093 # if defined(MSWIN32)
2094 GC_old_segv_handler
= SetUnhandledExceptionFilter(GC_write_fault_handler
);
2095 if (GC_old_segv_handler
!= NULL
) {
2097 GC_err_printf0("Replaced other UnhandledExceptionFilter\n");
2100 GC_old_segv_handler
= SIG_DFL
;
2107 void GC_protect_heap()
2113 for (i
= 0; i
< GC_n_heap_sects
; i
++) {
2114 start
= GC_heap_sects
[i
].hs_start
;
2115 len
= GC_heap_sects
[i
].hs_bytes
;
2116 PROTECT(start
, len
);
2120 /* We assume that either the world is stopped or its OK to lose dirty */
2121 /* bits while this is happenning (as in GC_enable_incremental). */
2122 void GC_read_dirty()
2124 BCOPY((word
*)GC_dirty_pages
, GC_grungy_pages
,
2125 (sizeof GC_dirty_pages
));
2126 BZERO((word
*)GC_dirty_pages
, (sizeof GC_dirty_pages
));
2130 GC_bool
GC_page_was_dirty(h
)
2133 register word index
= PHT_HASH(h
);
2135 return(HDR(h
) == 0 || get_pht_entry_from_index(GC_grungy_pages
, index
));
2139 * Acquiring the allocation lock here is dangerous, since this
2140 * can be called from within GC_call_with_alloc_lock, and the cord
2141 * package does so. On systems that allow nested lock acquisition, this
2143 * On other systems, SET_LOCK_HOLDER and friends must be suitably defined.
2146 void GC_begin_syscall()
2148 if (!I_HOLD_LOCK()) LOCK();
2151 void GC_end_syscall()
2153 if (!I_HOLD_LOCK()) UNLOCK();
2156 void GC_unprotect_range(addr
, len
)
2160 struct hblk
* start_block
;
2161 struct hblk
* end_block
;
2162 register struct hblk
*h
;
2165 if (!GC_incremental
) return;
2166 obj_start
= GC_base(addr
);
2167 if (obj_start
== 0) return;
2168 if (GC_base(addr
+ len
- 1) != obj_start
) {
2169 ABORT("GC_unprotect_range(range bigger than object)");
2171 start_block
= (struct hblk
*)((word
)addr
& ~(GC_page_size
- 1));
2172 end_block
= (struct hblk
*)((word
)(addr
+ len
- 1) & ~(GC_page_size
- 1));
2173 end_block
+= GC_page_size
/HBLKSIZE
- 1;
2174 for (h
= start_block
; h
<= end_block
; h
++) {
2175 register word index
= PHT_HASH(h
);
2177 set_pht_entry_from_index(GC_dirty_pages
, index
);
2179 UNPROTECT(start_block
,
2180 ((ptr_t
)end_block
- (ptr_t
)start_block
) + HBLKSIZE
);
2184 /* Replacement for UNIX system call. */
2185 /* Other calls that write to the heap */
2186 /* should be handled similarly. */
2187 # if defined(__STDC__) && !defined(SUNOS4)
2188 # include <unistd.h>
2189 ssize_t
read(int fd
, void *buf
, size_t nbyte
)
2192 int read(fd
, buf
, nbyte
)
2194 int GC_read(fd
, buf
, nbyte
)
2204 GC_unprotect_range(buf
, (word
)nbyte
);
2206 /* Indirect system call may not always be easily available. */
2207 /* We could call _read, but that would interfere with the */
2208 /* libpthread interception of read. */
2213 iov
.iov_len
= nbyte
;
2214 result
= readv(fd
, &iov
, 1);
2217 result
= syscall(SYS_read
, fd
, buf
, nbyte
);
2222 #endif /* !MSWIN32 */
2225 GC_bool
GC_page_was_ever_dirty(h
)
2231 /* Reset the n pages starting at h to "was never dirty" status. */
2233 void GC_is_fresh(h
, n
)
2239 # endif /* MPROTECT_VDB */
2244 * See DEFAULT_VDB for interface descriptions.
2248 * This implementaion assumes a Solaris 2.X like /proc pseudo-file-system
2249 * from which we can read page modified bits. This facility is far from
2250 * optimal (e.g. we would like to get the info for only some of the
2251 * address space), but it avoids intercepting system calls.
2255 #include <sys/types.h>
2256 #include <sys/signal.h>
2257 #include <sys/fault.h>
2258 #include <sys/syscall.h>
2259 #include <sys/procfs.h>
2260 #include <sys/stat.h>
2263 #define INITIAL_BUF_SZ 4096
2264 word GC_proc_buf_size
= INITIAL_BUF_SZ
;
2267 #ifdef SOLARIS_THREADS
2268 /* We don't have exact sp values for threads. So we count on */
2269 /* occasionally declaring stack pages to be fresh. Thus we */
2270 /* need a real implementation of GC_is_fresh. We can't clear */
2271 /* entries in GC_written_pages, since that would declare all */
2272 /* pages with the given hash address to be fresh. */
2273 # define MAX_FRESH_PAGES 8*1024 /* Must be power of 2 */
2274 struct hblk
** GC_fresh_pages
; /* A direct mapped cache. */
2275 /* Collisions are dropped. */
2277 # define FRESH_PAGE_SLOT(h) (divHBLKSZ((word)(h)) & (MAX_FRESH_PAGES-1))
2278 # define ADD_FRESH_PAGE(h) \
2279 GC_fresh_pages[FRESH_PAGE_SLOT(h)] = (h)
2280 # define PAGE_IS_FRESH(h) \
2281 (GC_fresh_pages[FRESH_PAGE_SLOT(h)] == (h) && (h) != 0)
2284 /* Add all pages in pht2 to pht1 */
2285 void GC_or_pages(pht1
, pht2
)
2286 page_hash_table pht1
, pht2
;
2290 for (i
= 0; i
< PHT_SIZE
; i
++) pht1
[i
] |= pht2
[i
];
2295 void GC_dirty_init()
2300 GC_dirty_maintained
= TRUE
;
2301 if (GC_words_allocd
!= 0 || GC_words_allocd_before_gc
!= 0) {
2304 for (i
= 0; i
< PHT_SIZE
; i
++) GC_written_pages
[i
] = (word
)(-1);
2306 GC_printf1("Allocated words:%lu:all pages may have been written\n",
2308 (GC_words_allocd
+ GC_words_allocd_before_gc
));
2311 sprintf(buf
, "/proc/%d", getpid());
2312 fd
= open(buf
, O_RDONLY
);
2314 ABORT("/proc open failed");
2316 GC_proc_fd
= syscall(SYS_ioctl
, fd
, PIOCOPENPD
, 0);
2318 if (GC_proc_fd
< 0) {
2319 ABORT("/proc ioctl failed");
2321 GC_proc_buf
= GC_scratch_alloc(GC_proc_buf_size
);
2322 # ifdef SOLARIS_THREADS
2323 GC_fresh_pages
= (struct hblk
**)
2324 GC_scratch_alloc(MAX_FRESH_PAGES
* sizeof (struct hblk
*));
2325 if (GC_fresh_pages
== 0) {
2326 GC_err_printf0("No space for fresh pages\n");
2329 BZERO(GC_fresh_pages
, MAX_FRESH_PAGES
* sizeof (struct hblk
*));
2333 /* Ignore write hints. They don't help us here. */
2335 void GC_write_hint(h
)
2340 #ifdef SOLARIS_THREADS
2341 # define READ(fd,buf,nbytes) syscall(SYS_read, fd, buf, nbytes)
2343 # define READ(fd,buf,nbytes) read(fd, buf, nbytes)
2346 void GC_read_dirty()
2348 unsigned long ps
, np
;
2351 struct prasmap
* map
;
2353 ptr_t current_addr
, limit
;
2357 BZERO(GC_grungy_pages
, (sizeof GC_grungy_pages
));
2360 if (READ(GC_proc_fd
, bufp
, GC_proc_buf_size
) <= 0) {
2362 GC_printf1("/proc read failed: GC_proc_buf_size = %lu\n",
2366 /* Retry with larger buffer. */
2367 word new_size
= 2 * GC_proc_buf_size
;
2368 char * new_buf
= GC_scratch_alloc(new_size
);
2371 GC_proc_buf
= bufp
= new_buf
;
2372 GC_proc_buf_size
= new_size
;
2374 if (syscall(SYS_read
, GC_proc_fd
, bufp
, GC_proc_buf_size
) <= 0) {
2375 WARN("Insufficient space for /proc read\n", 0);
2377 memset(GC_grungy_pages
, 0xff, sizeof (page_hash_table
));
2378 memset(GC_written_pages
, 0xff, sizeof(page_hash_table
));
2379 # ifdef SOLARIS_THREADS
2380 BZERO(GC_fresh_pages
,
2381 MAX_FRESH_PAGES
* sizeof (struct hblk
*));
2387 /* Copy dirty bits into GC_grungy_pages */
2388 nmaps
= ((struct prpageheader
*)bufp
) -> pr_nmap
;
2389 /* printf( "nmaps = %d, PG_REFERENCED = %d, PG_MODIFIED = %d\n",
2390 nmaps, PG_REFERENCED, PG_MODIFIED); */
2391 bufp
= bufp
+ sizeof(struct prpageheader
);
2392 for (i
= 0; i
< nmaps
; i
++) {
2393 map
= (struct prasmap
*)bufp
;
2394 vaddr
= (ptr_t
)(map
-> pr_vaddr
);
2395 ps
= map
-> pr_pagesize
;
2396 np
= map
-> pr_npage
;
2397 /* printf("vaddr = 0x%X, ps = 0x%X, np = 0x%X\n", vaddr, ps, np); */
2398 limit
= vaddr
+ ps
* np
;
2399 bufp
+= sizeof (struct prasmap
);
2400 for (current_addr
= vaddr
;
2401 current_addr
< limit
; current_addr
+= ps
){
2402 if ((*bufp
++) & PG_MODIFIED
) {
2403 register struct hblk
* h
= (struct hblk
*) current_addr
;
2405 while ((ptr_t
)h
< current_addr
+ ps
) {
2406 register word index
= PHT_HASH(h
);
2408 set_pht_entry_from_index(GC_grungy_pages
, index
);
2409 # ifdef SOLARIS_THREADS
2411 register int slot
= FRESH_PAGE_SLOT(h
);
2413 if (GC_fresh_pages
[slot
] == h
) {
2414 GC_fresh_pages
[slot
] = 0;
2422 bufp
+= sizeof(long) - 1;
2423 bufp
= (char *)((unsigned long)bufp
& ~(sizeof(long)-1));
2425 /* Update GC_written_pages. */
2426 GC_or_pages(GC_written_pages
, GC_grungy_pages
);
2427 # ifdef SOLARIS_THREADS
2428 /* Make sure that old stacks are considered completely clean */
2429 /* unless written again. */
2430 GC_old_stacks_are_fresh();
2436 GC_bool
GC_page_was_dirty(h
)
2439 register word index
= PHT_HASH(h
);
2440 register GC_bool result
;
2442 result
= get_pht_entry_from_index(GC_grungy_pages
, index
);
2443 # ifdef SOLARIS_THREADS
2444 if (result
&& PAGE_IS_FRESH(h
)) result
= FALSE
;
2445 /* This happens only if page was declared fresh since */
2446 /* the read_dirty call, e.g. because it's in an unused */
2447 /* thread stack. It's OK to treat it as clean, in */
2448 /* that case. And it's consistent with */
2449 /* GC_page_was_ever_dirty. */
2454 GC_bool
GC_page_was_ever_dirty(h
)
2457 register word index
= PHT_HASH(h
);
2458 register GC_bool result
;
2460 result
= get_pht_entry_from_index(GC_written_pages
, index
);
2461 # ifdef SOLARIS_THREADS
2462 if (result
&& PAGE_IS_FRESH(h
)) result
= FALSE
;
2467 /* Caller holds allocation lock. */
2468 void GC_is_fresh(h
, n
)
2473 register word index
;
2475 # ifdef SOLARIS_THREADS
2478 if (GC_fresh_pages
!= 0) {
2479 for (i
= 0; i
< n
; i
++) {
2480 ADD_FRESH_PAGE(h
+ i
);
2486 # endif /* PROC_VDB */
2491 # include "vd/PCR_VD.h"
2493 # define NPAGES (32*1024) /* 128 MB */
2495 PCR_VD_DB GC_grungy_bits
[NPAGES
];
2497 ptr_t GC_vd_base
; /* Address corresponding to GC_grungy_bits[0] */
2498 /* HBLKSIZE aligned. */
2500 void GC_dirty_init()
2502 GC_dirty_maintained
= TRUE
;
2503 /* For the time being, we assume the heap generally grows up */
2504 GC_vd_base
= GC_heap_sects
[0].hs_start
;
2505 if (GC_vd_base
== 0) {
2506 ABORT("Bad initial heap segment");
2508 if (PCR_VD_Start(HBLKSIZE
, GC_vd_base
, NPAGES
*HBLKSIZE
)
2510 ABORT("dirty bit initialization failed");
2514 void GC_read_dirty()
2516 /* lazily enable dirty bits on newly added heap sects */
2518 static int onhs
= 0;
2519 int nhs
= GC_n_heap_sects
;
2520 for( ; onhs
< nhs
; onhs
++ ) {
2521 PCR_VD_WriteProtectEnable(
2522 GC_heap_sects
[onhs
].hs_start
,
2523 GC_heap_sects
[onhs
].hs_bytes
);
2528 if (PCR_VD_Clear(GC_vd_base
, NPAGES
*HBLKSIZE
, GC_grungy_bits
)
2530 ABORT("dirty bit read failed");
2534 GC_bool
GC_page_was_dirty(h
)
2537 if((ptr_t
)h
< GC_vd_base
|| (ptr_t
)h
>= GC_vd_base
+ NPAGES
*HBLKSIZE
) {
2540 return(GC_grungy_bits
[h
- (struct hblk
*)GC_vd_base
] & PCR_VD_DB_dirtyBit
);
2544 void GC_write_hint(h
)
2547 PCR_VD_WriteProtectDisable(h
, HBLKSIZE
);
2548 PCR_VD_WriteProtectEnable(h
, HBLKSIZE
);
2551 # endif /* PCR_VDB */
2554 * Call stack save code for debugging.
2555 * Should probably be in mach_dep.c, but that requires reorganization.
2557 #if defined(SPARC) && !defined(LINUX)
2558 # if defined(SUNOS4)
2559 # include <machine/frame.h>
2561 # if defined (DRSNX)
2562 # include <sys/sparc/frame.h>
2564 # if defined(OPENBSD)
2567 # include <sys/frame.h>
2572 --> We only know how to to get the first
6 arguments
2575 #ifdef SAVE_CALL_CHAIN
2576 /* Fill in the pc and argument information for up to NFRAMES of my */
2577 /* callers. Ignore my frame and my callers frame. */
2580 # define FR_SAVFP fr_fp
2581 # define FR_SAVPC fr_pc
2583 # define FR_SAVFP fr_savfp
2584 # define FR_SAVPC fr_savpc
2587 void GC_save_callers (info
)
2588 struct callinfo info
[NFRAMES
];
2590 struct frame
*frame
;
2593 word
GC_save_regs_in_stack();
2595 frame
= (struct frame
*) GC_save_regs_in_stack ();
2597 for (fp
= frame
-> FR_SAVFP
; fp
!= 0 && nframes
< NFRAMES
;
2598 fp
= fp
-> FR_SAVFP
, nframes
++) {
2601 info
[nframes
].ci_pc
= fp
->FR_SAVPC
;
2602 for (i
= 0; i
< NARGS
; i
++) {
2603 info
[nframes
].ci_arg
[i
] = ~(fp
->fr_arg
[i
]);
2606 if (nframes
< NFRAMES
) info
[nframes
].ci_pc
= 0;
2609 #endif /* SAVE_CALL_CHAIN */