?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* config.gcc: Quote target_cpu_default2 correctly for
[official-gcc.git] / boehm-gc / os_dep.c
bloba7f6d1940054120b3b6ad2ed1ec63f816849549e
1 /*
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.
6 *
7 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
8 * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
9 *
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.
15 */
16
17 # include "private/gc_priv.h"
18
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. */
26 # define __KERNEL__
27 # include <asm/signal.h>
28 # undef __KERNEL__
29 # else
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>
35 # if 2 <= __GLIBC__
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__ */
46 # endif
47 # endif
48 # if !defined(OS2) && !defined(PCR) && !defined(AMIGA) && !defined(MACOS) \
49 && !defined(MSWINCE)
50 # include <sys/types.h>
51 # if !defined(MSWIN32) && !defined(SUNOS4)
52 # include <unistd.h>
53 # endif
54 # endif
55
56 # include <stdio.h>
57 # if defined(MSWINCE)
58 # define SIGSEGV 0 /* value is irrelevant */
59 # else
60 # include <signal.h>
61 # endif
62
63 /* Blatantly OS dependent routines, except for those that are related */
64 /* to dynamic loading. */
65
66 # if !defined(THREADS) && !defined(STACKBOTTOM) && defined(HEURISTIC2)
67 # define NEED_FIND_LIMIT
68 # endif
69
70 # if defined(IRIX_THREADS) || defined(HPUX_THREADS)
71 # define NEED_FIND_LIMIT
72 # endif
73
74 # if (defined(SUNOS4) && defined(DYNAMIC_LOADING)) && !defined(PCR)
75 # define NEED_FIND_LIMIT
76 # endif
77
78 # if (defined(SVR4) || defined(AUX) || defined(DGUX)) && !defined(PCR)
79 # define NEED_FIND_LIMIT
80 # endif
81
82 # if defined(LINUX) && \
83 (defined(POWERPC) || defined(SPARC) || defined(ALPHA) || defined(IA64) \
84 || defined(MIPS))
85 # define NEED_FIND_LIMIT
86 # endif
87
88 #ifdef NEED_FIND_LIMIT
89 # include <setjmp.h>
90 #endif
91
92 #ifdef FREEBSD
93 # include <machine/trap.h>
94 #endif
95
96 #ifdef AMIGA
97 # define GC_AMIGA_DEF
98 # include "AmigaOS.c"
99 # undef GC_AMIGA_DEF
100 #endif
101
102 #if defined(MSWIN32) || defined(MSWINCE)
103 # define WIN32_LEAN_AND_MEAN
104 # define NOSERVICE
105 # include <windows.h>
106 #endif
107
108 #ifdef MACOS
109 # include <Processes.h>
110 #endif
111
112 #ifdef IRIX5
113 # include <sys/uio.h>
114 # include <malloc.h> /* for locking */
115 #endif
116 #ifdef USE_MMAP
117 # include <sys/types.h>
118 # include <sys/mman.h>
119 # include <sys/stat.h>
120 #endif
121
122 #ifdef UNIX_LIKE
123 # include <fcntl.h>
124 #endif
125
126 #ifdef SUNOS5SIGS
127 # include <sys/siginfo.h>
128 # undef setjmp
129 # undef longjmp
130 # define setjmp(env) sigsetjmp(env, 1)
131 # define longjmp(env, val) siglongjmp(env, val)
132 # define jmp_buf sigjmp_buf
133 #endif
134
135 #ifdef DJGPP
136 /* Apparently necessary for djgpp 2.01. May cause problems with */
137 /* other versions. */
138 typedef long unsigned int caddr_t;
139 #endif
140
141 #ifdef PCR
142 # include "il/PCR_IL.h"
143 # include "th/PCR_ThCtl.h"
144 # include "mm/PCR_MM.h"
145 #endif
146
147 #if !defined(NO_EXECUTE_PERMISSION)
148 # define OPT_PROT_EXEC PROT_EXEC
149 #else
150 # define OPT_PROT_EXEC 0
151 #endif
152
153 #if defined(SEARCH_FOR_DATA_START)
154 /* The I386 case can be handled without a search. The Alpha case */
155 /* used to be handled differently as well, but the rules changed */
156 /* for recent Linux versions. This seems to be the easiest way to */
157 /* cover all versions. */
158
159 # ifdef LINUX
160 # pragma weak __data_start
161 extern int __data_start;
162 # pragma weak data_start
163 extern int data_start;
164 # endif /* LINUX */
165 extern int _end;
166
167 ptr_t GC_data_start;
168
169 void GC_init_linux_data_start()
170 {
171 extern ptr_t GC_find_limit();
172
173 # ifdef LINUX
174 /* Try the easy approaches first: */
175 if (&__data_start != 0) {
176 GC_data_start = (ptr_t)(&__data_start);
177 return;
178 }
179 if (&data_start != 0) {
180 GC_data_start = (ptr_t)(&data_start);
181 return;
182 }
183 # endif /* LINUX */
184 GC_data_start = GC_find_limit((ptr_t)(&_end), FALSE);
185 }
186 #endif
187
188 # ifdef ECOS
189
190 # ifndef ECOS_GC_MEMORY_SIZE
191 # define ECOS_GC_MEMORY_SIZE (448 * 1024)
192 # endif /* ECOS_GC_MEMORY_SIZE */
193
194 // setjmp() function, as described in ANSI para 7.6.1.1
195 #define setjmp( __env__ ) hal_setjmp( __env__ )
196
197 // FIXME: This is a simple way of allocating memory which is
198 // compatible with ECOS early releases. Later releases use a more
199 // sophisticated means of allocating memory than this simple static
200 // allocator, but this method is at least bound to work.
201 static char memory[ECOS_GC_MEMORY_SIZE];
202 static char *brk = memory;
203
204 static void *tiny_sbrk(ptrdiff_t increment)
205 {
206 void *p = brk;
207
208 brk += increment;
209
210 if (brk > memory + sizeof memory)
211 {
212 brk -= increment;
213 return NULL;
214 }
215
216 return p;
217 }
218 #define sbrk tiny_sbrk
219 # endif /* ECOS */
220
221 #if defined(NETBSD) && defined(__ELF__)
222 ptr_t GC_data_start;
223
224 void GC_init_netbsd_elf()
225 {
226 extern ptr_t GC_find_limit();
227 extern char **environ;
228 /* This may need to be environ, without the underscore, for */
229 /* some versions. */
230 GC_data_start = GC_find_limit((ptr_t)&environ, FALSE);
231 }
232 #endif
233
234 # ifdef OS2
235
236 # include <stddef.h>
237
238 # if !defined(__IBMC__) && !defined(__WATCOMC__) /* e.g. EMX */
239
240 struct exe_hdr {
241 unsigned short magic_number;
242 unsigned short padding[29];
243 long new_exe_offset;
244 };
245
246 #define E_MAGIC(x) (x).magic_number
247 #define EMAGIC 0x5A4D
248 #define E_LFANEW(x) (x).new_exe_offset
249
250 struct e32_exe {
251 unsigned char magic_number[2];
252 unsigned char byte_order;
253 unsigned char word_order;
254 unsigned long exe_format_level;
255 unsigned short cpu;
256 unsigned short os;
257 unsigned long padding1[13];
258 unsigned long object_table_offset;
259 unsigned long object_count;
260 unsigned long padding2[31];
261 };
262
263 #define E32_MAGIC1(x) (x).magic_number[0]
264 #define E32MAGIC1 'L'
265 #define E32_MAGIC2(x) (x).magic_number[1]
266 #define E32MAGIC2 'X'
267 #define E32_BORDER(x) (x).byte_order
268 #define E32LEBO 0
269 #define E32_WORDER(x) (x).word_order
270 #define E32LEWO 0
271 #define E32_CPU(x) (x).cpu
272 #define E32CPU286 1
273 #define E32_OBJTAB(x) (x).object_table_offset
274 #define E32_OBJCNT(x) (x).object_count
275
276 struct o32_obj {
277 unsigned long size;
278 unsigned long base;
279 unsigned long flags;
280 unsigned long pagemap;
281 unsigned long mapsize;
282 unsigned long reserved;
283 };
284
285 #define O32_FLAGS(x) (x).flags
286 #define OBJREAD 0x0001L
287 #define OBJWRITE 0x0002L
288 #define OBJINVALID 0x0080L
289 #define O32_SIZE(x) (x).size
290 #define O32_BASE(x) (x).base
291
292 # else /* IBM's compiler */
293
294 /* A kludge to get around what appears to be a header file bug */
295 # ifndef WORD
296 # define WORD unsigned short
297 # endif
298 # ifndef DWORD
299 # define DWORD unsigned long
300 # endif
301
302 # define EXE386 1
303 # include <newexe.h>
304 # include <exe386.h>
305
306 # endif /* __IBMC__ */
307
308 # define INCL_DOSEXCEPTIONS
309 # define INCL_DOSPROCESS
310 # define INCL_DOSERRORS
311 # define INCL_DOSMODULEMGR
312 # define INCL_DOSMEMMGR
313 # include <os2.h>
314
315
316 /* Disable and enable signals during nontrivial allocations */
317
318 void GC_disable_signals(void)
319 {
320 ULONG nest;
321
322 DosEnterMustComplete(&nest);
323 if (nest != 1) ABORT("nested GC_disable_signals");
324 }
325
326 void GC_enable_signals(void)
327 {
328 ULONG nest;
329
330 DosExitMustComplete(&nest);
331 if (nest != 0) ABORT("GC_enable_signals");
332 }
333
334
335 # else
336
337 # if !defined(PCR) && !defined(AMIGA) && !defined(MSWIN32) \
338 && !defined(MSWINCE) \
339 && !defined(MACOS) && !defined(DJGPP) && !defined(DOS4GW)
340
341 # if defined(sigmask) && !defined(UTS4)
342 /* Use the traditional BSD interface */
343 # define SIGSET_T int
344 # define SIG_DEL(set, signal) (set) &= ~(sigmask(signal))
345 # define SIG_FILL(set) (set) = 0x7fffffff
346 /* Setting the leading bit appears to provoke a bug in some */
347 /* longjmp implementations. Most systems appear not to have */
348 /* a signal 32. */
349 # define SIGSETMASK(old, new) (old) = sigsetmask(new)
350 # else
351 /* Use POSIX/SYSV interface */
352 # define SIGSET_T sigset_t
353 # define SIG_DEL(set, signal) sigdelset(&(set), (signal))
354 # define SIG_FILL(set) sigfillset(&set)
355 # define SIGSETMASK(old, new) sigprocmask(SIG_SETMASK, &(new), &(old))
356 # endif
357
358 static GC_bool mask_initialized = FALSE;
359
360 static SIGSET_T new_mask;
361
362 static SIGSET_T old_mask;
363
364 static SIGSET_T dummy;
365
366 #if defined(PRINTSTATS) && !defined(THREADS)
367 # define CHECK_SIGNALS
368 int GC_sig_disabled = 0;
369 #endif
370
371 void GC_disable_signals()
372 {
373 if (!mask_initialized) {
374 SIG_FILL(new_mask);
375
376 SIG_DEL(new_mask, SIGSEGV);
377 SIG_DEL(new_mask, SIGILL);
378 SIG_DEL(new_mask, SIGQUIT);
379 # ifdef SIGBUS
380 SIG_DEL(new_mask, SIGBUS);
381 # endif
382 # ifdef SIGIOT
383 SIG_DEL(new_mask, SIGIOT);
384 # endif
385 # ifdef SIGEMT
386 SIG_DEL(new_mask, SIGEMT);
387 # endif
388 # ifdef SIGTRAP
389 SIG_DEL(new_mask, SIGTRAP);
390 # endif
391 mask_initialized = TRUE;
392 }
393 # ifdef CHECK_SIGNALS
394 if (GC_sig_disabled != 0) ABORT("Nested disables");
395 GC_sig_disabled++;
396 # endif
397 SIGSETMASK(old_mask,new_mask);
398 }
399
400 void GC_enable_signals()
401 {
402 # ifdef CHECK_SIGNALS
403 if (GC_sig_disabled != 1) ABORT("Unmatched enable");
404 GC_sig_disabled--;
405 # endif
406 SIGSETMASK(dummy,old_mask);
407 }
408
409 # endif /* !PCR */
410
411 # endif /*!OS/2 */
412
413 /* Ivan Demakov: simplest way (to me) */
414 #if defined (DOS4GW)
415 void GC_disable_signals() { }
416 void GC_enable_signals() { }
417 #endif
418
419 /* Find the page size */
420 word GC_page_size;
421
422 # if defined(MSWIN32) || defined(MSWINCE)
423 void GC_setpagesize()
424 {
425 GetSystemInfo(&GC_sysinfo);
426 GC_page_size = GC_sysinfo.dwPageSize;
427 }
428
429 # else
430 # if defined(MPROTECT_VDB) || defined(PROC_VDB) || defined(USE_MMAP) \
431 || defined(USE_MUNMAP)
432 void GC_setpagesize()
433 {
434 GC_page_size = GETPAGESIZE();
435 }
436 # else
437 /* It's acceptable to fake it. */
438 void GC_setpagesize()
439 {
440 GC_page_size = HBLKSIZE;
441 }
442 # endif
443 # endif
444
445 /*
446 * Find the base of the stack.
447 * Used only in single-threaded environment.
448 * With threads, GC_mark_roots needs to know how to do this.
449 * Called with allocator lock held.
450 */
451 # if defined(MSWIN32) || defined(MSWINCE)
452 # define is_writable(prot) ((prot) == PAGE_READWRITE \
453 || (prot) == PAGE_WRITECOPY \
454 || (prot) == PAGE_EXECUTE_READWRITE \
455 || (prot) == PAGE_EXECUTE_WRITECOPY)
456 /* Return the number of bytes that are writable starting at p. */
457 /* The pointer p is assumed to be page aligned. */
458 /* If base is not 0, *base becomes the beginning of the */
459 /* allocation region containing p. */
460 word GC_get_writable_length(ptr_t p, ptr_t *base)
461 {
462 MEMORY_BASIC_INFORMATION buf;
463 word result;
464 word protect;
465
466 result = VirtualQuery(p, &buf, sizeof(buf));
467 if (result != sizeof(buf)) ABORT("Weird VirtualQuery result");
468 if (base != 0) *base = (ptr_t)(buf.AllocationBase);
469 protect = (buf.Protect & ~(PAGE_GUARD | PAGE_NOCACHE));
470 if (!is_writable(protect)) {
471 return(0);
472 }
473 if (buf.State != MEM_COMMIT) return(0);
474 return(buf.RegionSize);
475 }
476
477 ptr_t GC_get_stack_base()
478 {
479 int dummy;
480 ptr_t sp = (ptr_t)(&dummy);
481 ptr_t trunc_sp = (ptr_t)((word)sp & ~(GC_page_size - 1));
482 word size = GC_get_writable_length(trunc_sp, 0);
483
484 return(trunc_sp + size);
485 }
486
487
488 # endif /* MS Windows */
489
490 # ifdef BEOS
491 # include <kernel/OS.h>
492 ptr_t GC_get_stack_base(){
493 thread_info th;
494 get_thread_info(find_thread(NULL),&th);
495 return th.stack_end;
496 }
497 # endif /* BEOS */
498
499
500 # ifdef OS2
501
502 ptr_t GC_get_stack_base()
503 {
504 PTIB ptib;
505 PPIB ppib;
506
507 if (DosGetInfoBlocks(&ptib, &ppib) != NO_ERROR) {
508 GC_err_printf0("DosGetInfoBlocks failed\n");
509 ABORT("DosGetInfoBlocks failed\n");
510 }
511 return((ptr_t)(ptib -> tib_pstacklimit));
512 }
513
514 # endif /* OS2 */
515
516 # ifdef AMIGA
517 # define GC_AMIGA_SB
518 # include "AmigaOS.c"
519 # undef GC_AMIGA_SB
520 # endif /* AMIGA */
521
522 # if defined(NEED_FIND_LIMIT) || defined(UNIX_LIKE)
523
524 # ifdef __STDC__
525 typedef void (*handler)(int);
526 # else
527 typedef void (*handler)();
528 # endif
529
530 # if defined(SUNOS5SIGS) || defined(IRIX5) || defined(OSF1)
531 static struct sigaction old_segv_act;
532 # if defined(_sigargs) || defined(HPUX) /* !Irix6.x */
533 static struct sigaction old_bus_act;
534 # endif
535 # else
536 static handler old_segv_handler, old_bus_handler;
537 # endif
538
539 # ifdef __STDC__
540 void GC_set_and_save_fault_handler(handler h)
541 # else
542 void GC_set_and_save_fault_handler(h)
543 handler h;
544 # endif
545 {
546 # ifndef ECOS
547 # if defined(SUNOS5SIGS) || defined(IRIX5) || defined(OSF1)
548 struct sigaction act;
549
550 act.sa_handler = h;
551 act.sa_flags = SA_RESTART | SA_NODEFER;
552 /* The presence of SA_NODEFER represents yet another gross */
553 /* hack. Under Solaris 2.3, siglongjmp doesn't appear to */
554 /* interact correctly with -lthread. We hide the confusion */
555 /* by making sure that signal handling doesn't affect the */
556 /* signal mask. */
557
558 (void) sigemptyset(&act.sa_mask);
559 # ifdef IRIX_THREADS
560 /* Older versions have a bug related to retrieving and */
561 /* and setting a handler at the same time. */
562 (void) sigaction(SIGSEGV, 0, &old_segv_act);
563 (void) sigaction(SIGSEGV, &act, 0);
564 # else
565 (void) sigaction(SIGSEGV, &act, &old_segv_act);
566 # if defined(IRIX5) && defined(_sigargs) /* Irix 5.x, not 6.x */ \
567 || defined(HPUX)
568 /* Under Irix 5.x or HP/UX, we may get SIGBUS. */
569 /* Pthreads doesn't exist under Irix 5.x, so we */
570 /* don't have to worry in the threads case. */
571 (void) sigaction(SIGBUS, &act, &old_bus_act);
572 # endif
573 # endif /* IRIX_THREADS */
574 # else
575 old_segv_handler = signal(SIGSEGV, h);
576 # ifdef SIGBUS
577 old_bus_handler = signal(SIGBUS, h);
578 # endif
579 # endif
580 # endif /* ECOS */
581 }
582 # endif /* NEED_FIND_LIMIT || UNIX_LIKE */
583
584 # ifdef NEED_FIND_LIMIT
585 /* Some tools to implement HEURISTIC2 */
586 # define MIN_PAGE_SIZE 256 /* Smallest conceivable page size, bytes */
587 /* static */ jmp_buf GC_jmp_buf;
588
589 /*ARGSUSED*/
590 void GC_fault_handler(sig)
591 int sig;
592 {
593 longjmp(GC_jmp_buf, 1);
594 }
595
596 void GC_setup_temporary_fault_handler()
597 {
598 GC_set_and_save_fault_handler(GC_fault_handler);
599 }
600
601 void GC_reset_fault_handler()
602 {
603 # ifndef ECOS
604 # if defined(SUNOS5SIGS) || defined(IRIX5) || defined(OSF1)
605 (void) sigaction(SIGSEGV, &old_segv_act, 0);
606 # if defined(IRIX5) && defined(_sigargs) /* Irix 5.x, not 6.x */ \
607 || defined(HPUX)
608 (void) sigaction(SIGBUS, &old_bus_act, 0);
609 # endif
610 # else
611 (void) signal(SIGSEGV, old_segv_handler);
612 # ifdef SIGBUS
613 (void) signal(SIGBUS, old_bus_handler);
614 # endif
615 # endif
616 # endif /* ECOS */
617 }
618
619 /* Return the first nonaddressible location > p (up) or */
620 /* the smallest location q s.t. [q,p] is addressible (!up). */
621 ptr_t GC_find_limit(p, up)
622 ptr_t p;
623 GC_bool up;
624 {
625 # ifndef ECOS
626 static VOLATILE ptr_t result;
627 /* Needs to be static, since otherwise it may not be */
628 /* preserved across the longjmp. Can safely be */
629 /* static since it's only called once, with the */
630 /* allocation lock held. */
631
632
633 GC_setup_temporary_fault_handler();
634 if (setjmp(GC_jmp_buf) == 0) {
635 result = (ptr_t)(((word)(p))
636 & ~(MIN_PAGE_SIZE-1));
637 for (;;) {
638 if (up) {
639 result += MIN_PAGE_SIZE;
640 } else {
641 result -= MIN_PAGE_SIZE;
642 }
643 GC_noop1((word)(*result));
644 }
645 }
646 GC_reset_fault_handler();
647 if (!up) {
648 result += MIN_PAGE_SIZE;
649 }
650 return(result);
651 # else /* ECOS */
652 abort();
653 # endif /* ECOS */
654 }
655 # endif
656
657 # ifndef ECOS
658
659 #ifdef LINUX_STACKBOTTOM
660
661 #include <sys/types.h>
662 #include <sys/stat.h>
663
664 # define STAT_SKIP 27 /* Number of fields preceding startstack */
665 /* field in /proc/self/stat */
666
667 # pragma weak __libc_stack_end
668 extern ptr_t __libc_stack_end;
669
670 # ifdef IA64
671 # pragma weak __libc_ia64_register_backing_store_base
672 extern ptr_t __libc_ia64_register_backing_store_base;
673
674 ptr_t GC_get_register_stack_base(void)
675 {
676 if (0 != &__libc_ia64_register_backing_store_base) {
677 return __libc_ia64_register_backing_store_base;
678 } else {
679 word result = (word)GC_stackbottom - BACKING_STORE_DISPLACEMENT;
680 result += BACKING_STORE_ALIGNMENT - 1;
681 result &= ~(BACKING_STORE_ALIGNMENT - 1);
682 return (ptr_t)result;
683 }
684 }
685 # endif
686
687 ptr_t GC_linux_stack_base(void)
688 {
689 /* We read the stack base value from /proc/self/stat. We do this */
690 /* using direct I/O system calls in order to avoid calling malloc */
691 /* in case REDIRECT_MALLOC is defined. */
692 # define STAT_BUF_SIZE 4096
693 # if defined(GC_USE_LD_WRAP)
694 # define STAT_READ __real_read
695 # else
696 # define STAT_READ read
697 # endif
698 char stat_buf[STAT_BUF_SIZE];
699 int f;
700 char c;
701 word result = 0;
702 size_t i, buf_offset = 0;
703
704 /* First try the easy way. This should work for glibc 2.2 */
705 if (0 != &__libc_stack_end) {
706 return __libc_stack_end;
707 }
708 f = open("/proc/self/stat", O_RDONLY);
709 if (f < 0 || STAT_READ(f, stat_buf, STAT_BUF_SIZE) < 2 * STAT_SKIP) {
710 ABORT("Couldn't read /proc/self/stat");
711 }
712 c = stat_buf[buf_offset++];
713 /* Skip the required number of fields. This number is hopefully */
714 /* constant across all Linux implementations. */
715 for (i = 0; i < STAT_SKIP; ++i) {
716 while (isspace(c)) c = stat_buf[buf_offset++];
717 while (!isspace(c)) c = stat_buf[buf_offset++];
718 }
719 while (isspace(c)) c = stat_buf[buf_offset++];
720 while (isdigit(c)) {
721 result *= 10;
722 result += c - '0';
723 c = stat_buf[buf_offset++];
724 }
725 close(f);
726 if (result < 0x10000000) ABORT("Absurd stack bottom value");
727 return (ptr_t)result;
728 }
729
730 #endif /* LINUX_STACKBOTTOM */
731
732 #ifdef FREEBSD_STACKBOTTOM
733
734 /* This uses an undocumented sysctl call, but at least one expert */
735 /* believes it will stay. */
736
737 #include <unistd.h>
738 #include <sys/types.h>
739 #include <sys/sysctl.h>
740
741 ptr_t GC_freebsd_stack_base(void)
742 {
743 int nm[2] = { CTL_KERN, KERN_USRSTACK}, base, len, r;
744
745 len = sizeof(int);
746 r = sysctl(nm, 2, &base, &len, NULL, 0);
747
748 if (r) ABORT("Error getting stack base");
749
750 return (ptr_t)base;
751 }
752
753 #endif /* FREEBSD_STACKBOTTOM */
754
755 #if !defined(BEOS) && !defined(AMIGA) && !defined(MSWIN32) \
756 && !defined(MSWINCE) && !defined(OS2)
757
758 ptr_t GC_get_stack_base()
759 {
760 word dummy;
761 ptr_t result;
762
763 # define STACKBOTTOM_ALIGNMENT_M1 ((word)STACK_GRAN - 1)
764
765 # ifdef STACKBOTTOM
766 return(STACKBOTTOM);
767 # else
768 # ifdef HEURISTIC1
769 # ifdef STACK_GROWS_DOWN
770 result = (ptr_t)((((word)(&dummy))
771 + STACKBOTTOM_ALIGNMENT_M1)
772 & ~STACKBOTTOM_ALIGNMENT_M1);
773 # else
774 result = (ptr_t)(((word)(&dummy))
775 & ~STACKBOTTOM_ALIGNMENT_M1);
776 # endif
777 # endif /* HEURISTIC1 */
778 # ifdef LINUX_STACKBOTTOM
779 result = GC_linux_stack_base();
780 # endif
781 # ifdef FREEBSD_STACKBOTTOM
782 result = GC_freebsd_stack_base();
783 # endif
784 # ifdef HEURISTIC2
785 # ifdef STACK_GROWS_DOWN
786 result = GC_find_limit((ptr_t)(&dummy), TRUE);
787 # ifdef HEURISTIC2_LIMIT
788 if (result > HEURISTIC2_LIMIT
789 && (ptr_t)(&dummy) < HEURISTIC2_LIMIT) {
790 result = HEURISTIC2_LIMIT;
791 }
792 # endif
793 # else
794 result = GC_find_limit((ptr_t)(&dummy), FALSE);
795 # ifdef HEURISTIC2_LIMIT
796 if (result < HEURISTIC2_LIMIT
797 && (ptr_t)(&dummy) > HEURISTIC2_LIMIT) {
798 result = HEURISTIC2_LIMIT;
799 }
800 # endif
801 # endif
802
803 # endif /* HEURISTIC2 */
804 # ifdef STACK_GROWS_DOWN
805 if (result == 0) result = (ptr_t)(signed_word)(-sizeof(ptr_t));
806 # endif
807 return(result);
808 # endif /* STACKBOTTOM */
809 }
810 # endif /* ECOS */
811
812 # endif /* ! AMIGA, !OS 2, ! MS Windows, !BEOS */
813
814 /*
815 * Register static data segment(s) as roots.
816 * If more data segments are added later then they need to be registered
817 * add that point (as we do with SunOS dynamic loading),
818 * or GC_mark_roots needs to check for them (as we do with PCR).
819 * Called with allocator lock held.
820 */
821
822 # ifdef OS2
823
824 void GC_register_data_segments()
825 {
826 PTIB ptib;
827 PPIB ppib;
828 HMODULE module_handle;
829 # define PBUFSIZ 512
830 UCHAR path[PBUFSIZ];
831 FILE * myexefile;
832 struct exe_hdr hdrdos; /* MSDOS header. */
833 struct e32_exe hdr386; /* Real header for my executable */
834 struct o32_obj seg; /* Currrent segment */
835 int nsegs;
836
837
838 if (DosGetInfoBlocks(&ptib, &ppib) != NO_ERROR) {
839 GC_err_printf0("DosGetInfoBlocks failed\n");
840 ABORT("DosGetInfoBlocks failed\n");
841 }
842 module_handle = ppib -> pib_hmte;
843 if (DosQueryModuleName(module_handle, PBUFSIZ, path) != NO_ERROR) {
844 GC_err_printf0("DosQueryModuleName failed\n");
845 ABORT("DosGetInfoBlocks failed\n");
846 }
847 myexefile = fopen(path, "rb");
848 if (myexefile == 0) {
849 GC_err_puts("Couldn't open executable ");
850 GC_err_puts(path); GC_err_puts("\n");
851 ABORT("Failed to open executable\n");
852 }
853 if (fread((char *)(&hdrdos), 1, sizeof hdrdos, myexefile) < sizeof hdrdos) {
854 GC_err_puts("Couldn't read MSDOS header from ");
855 GC_err_puts(path); GC_err_puts("\n");
856 ABORT("Couldn't read MSDOS header");
857 }
858 if (E_MAGIC(hdrdos) != EMAGIC) {
859 GC_err_puts("Executable has wrong DOS magic number: ");
860 GC_err_puts(path); GC_err_puts("\n");
861 ABORT("Bad DOS magic number");
862 }
863 if (fseek(myexefile, E_LFANEW(hdrdos), SEEK_SET) != 0) {
864 GC_err_puts("Seek to new header failed in ");
865 GC_err_puts(path); GC_err_puts("\n");
866 ABORT("Bad DOS magic number");
867 }
868 if (fread((char *)(&hdr386), 1, sizeof hdr386, myexefile) < sizeof hdr386) {
869 GC_err_puts("Couldn't read MSDOS header from ");
870 GC_err_puts(path); GC_err_puts("\n");
871 ABORT("Couldn't read OS/2 header");
872 }
873 if (E32_MAGIC1(hdr386) != E32MAGIC1 || E32_MAGIC2(hdr386) != E32MAGIC2) {
874 GC_err_puts("Executable has wrong OS/2 magic number:");
875 GC_err_puts(path); GC_err_puts("\n");
876 ABORT("Bad OS/2 magic number");
877 }
878 if ( E32_BORDER(hdr386) != E32LEBO || E32_WORDER(hdr386) != E32LEWO) {
879 GC_err_puts("Executable %s has wrong byte order: ");
880 GC_err_puts(path); GC_err_puts("\n");
881 ABORT("Bad byte order");
882 }
883 if ( E32_CPU(hdr386) == E32CPU286) {
884 GC_err_puts("GC can't handle 80286 executables: ");
885 GC_err_puts(path); GC_err_puts("\n");
886 EXIT();
887 }
888 if (fseek(myexefile, E_LFANEW(hdrdos) + E32_OBJTAB(hdr386),
889 SEEK_SET) != 0) {
890 GC_err_puts("Seek to object table failed: ");
891 GC_err_puts(path); GC_err_puts("\n");
892 ABORT("Seek to object table failed");
893 }
894 for (nsegs = E32_OBJCNT(hdr386); nsegs > 0; nsegs--) {
895 int flags;
896 if (fread((char *)(&seg), 1, sizeof seg, myexefile) < sizeof seg) {
897 GC_err_puts("Couldn't read obj table entry from ");
898 GC_err_puts(path); GC_err_puts("\n");
899 ABORT("Couldn't read obj table entry");
900 }
901 flags = O32_FLAGS(seg);
902 if (!(flags & OBJWRITE)) continue;
903 if (!(flags & OBJREAD)) continue;
904 if (flags & OBJINVALID) {
905 GC_err_printf0("Object with invalid pages?\n");
906 continue;
907 }
908 GC_add_roots_inner(O32_BASE(seg), O32_BASE(seg)+O32_SIZE(seg), FALSE);
909 }
910 }
911
912 # else /* !OS2 */
913
914 # if defined(MSWIN32) || defined(MSWINCE)
915
916 # ifdef MSWIN32
917 /* Unfortunately, we have to handle win32s very differently from NT, */
918 /* Since VirtualQuery has very different semantics. In particular, */
919 /* under win32s a VirtualQuery call on an unmapped page returns an */
920 /* invalid result. Under GC_register_data_segments is a noop and */
921 /* all real work is done by GC_register_dynamic_libraries. Under */
922 /* win32s, we cannot find the data segments associated with dll's. */
923 /* We rgister the main data segment here. */
924 GC_bool GC_win32s = FALSE; /* We're running under win32s. */
925
926 GC_bool GC_is_win32s()
927 {
928 DWORD v = GetVersion();
929
930 /* Check that this is not NT, and Windows major version <= 3 */
931 return ((v & 0x80000000) && (v & 0xff) <= 3);
932 }
933
934 void GC_init_win32()
935 {
936 GC_win32s = GC_is_win32s();
937 }
938
939 /* Return the smallest address a such that VirtualQuery */
940 /* returns correct results for all addresses between a and start. */
941 /* Assumes VirtualQuery returns correct information for start. */
942 ptr_t GC_least_described_address(ptr_t start)
943 {
944 MEMORY_BASIC_INFORMATION buf;
945 DWORD result;
946 LPVOID limit;
947 ptr_t p;
948 LPVOID q;
949
950 limit = GC_sysinfo.lpMinimumApplicationAddress;
951 p = (ptr_t)((word)start & ~(GC_page_size - 1));
952 for (;;) {
953 q = (LPVOID)(p - GC_page_size);
954 if ((ptr_t)q > (ptr_t)p /* underflow */ || q < limit) break;
955 result = VirtualQuery(q, &buf, sizeof(buf));
956 if (result != sizeof(buf) || buf.AllocationBase == 0) break;
957 p = (ptr_t)(buf.AllocationBase);
958 }
959 return(p);
960 }
961 # endif
962
963 /* Is p the start of either the malloc heap, or of one of our */
964 /* heap sections? */
965 GC_bool GC_is_heap_base (ptr_t p)
966 {
967
968 register unsigned i;
969
970 # ifndef REDIRECT_MALLOC
971 static ptr_t malloc_heap_pointer = 0;
972
973 if (0 == malloc_heap_pointer) {
974 MEMORY_BASIC_INFORMATION buf;
975 void *pTemp = malloc( 1 );
976 register DWORD result = VirtualQuery(pTemp, &buf, sizeof(buf));
977
978 free( pTemp );
979
980
981 if (result != sizeof(buf)) {
982 ABORT("Weird VirtualQuery result");
983 }
984 malloc_heap_pointer = (ptr_t)(buf.AllocationBase);
985 }
986 if (p == malloc_heap_pointer) return(TRUE);
987 # endif
988 for (i = 0; i < GC_n_heap_bases; i++) {
989 if (GC_heap_bases[i] == p) return(TRUE);
990 }
991 return(FALSE);
992 }
993
994 # ifdef MSWIN32
995 void GC_register_root_section(ptr_t static_root)
996 {
997 MEMORY_BASIC_INFORMATION buf;
998 DWORD result;
999 DWORD protect;
1000 LPVOID p;
1001 char * base;
1002 char * limit, * new_limit;
1003
1004 if (!GC_win32s) return;
1005 p = base = limit = GC_least_described_address(static_root);
1006 while (p < GC_sysinfo.lpMaximumApplicationAddress) {
1007 result = VirtualQuery(p, &buf, sizeof(buf));
1008 if (result != sizeof(buf) || buf.AllocationBase == 0
1009 || GC_is_heap_base(buf.AllocationBase)) break;
1010 new_limit = (char *)p + buf.RegionSize;
1011 protect = buf.Protect;
1012 if (buf.State == MEM_COMMIT
1013 && is_writable(protect)) {
1014 if ((char *)p == limit) {
1015 limit = new_limit;
1016 } else {
1017 if (base != limit) GC_add_roots_inner(base, limit, FALSE);
1018 base = p;
1019 limit = new_limit;
1020 }
1021 }
1022 if (p > (LPVOID)new_limit /* overflow */) break;
1023 p = (LPVOID)new_limit;
1024 }
1025 if (base != limit) GC_add_roots_inner(base, limit, FALSE);
1026 }
1027 #endif
1028
1029 void GC_register_data_segments()
1030 {
1031 # ifdef MSWIN32
1032 static char dummy;
1033 GC_register_root_section((ptr_t)(&dummy));
1034 # endif
1035 }
1036
1037 # else /* !OS2 && !Windows */
1038
1039 # if (defined(SVR4) || defined(AUX) || defined(DGUX) \
1040 || (defined(LINUX) && defined(SPARC))) && !defined(PCR)
1041 char * GC_SysVGetDataStart(max_page_size, etext_addr)
1042 int max_page_size;
1043 int * etext_addr;
1044 {
1045 word text_end = ((word)(etext_addr) + sizeof(word) - 1)
1046 & ~(sizeof(word) - 1);
1047 /* etext rounded to word boundary */
1048 word next_page = ((text_end + (word)max_page_size - 1)
1049 & ~((word)max_page_size - 1));
1050 word page_offset = (text_end & ((word)max_page_size - 1));
1051 VOLATILE char * result = (char *)(next_page + page_offset);
1052 /* Note that this isnt equivalent to just adding */
1053 /* max_page_size to &etext if &etext is at a page boundary */
1054
1055 GC_setup_temporary_fault_handler();
1056 if (setjmp(GC_jmp_buf) == 0) {
1057 /* Try writing to the address. */
1058 *result = *result;
1059 GC_reset_fault_handler();
1060 } else {
1061 GC_reset_fault_handler();
1062 /* We got here via a longjmp. The address is not readable. */
1063 /* This is known to happen under Solaris 2.4 + gcc, which place */
1064 /* string constants in the text segment, but after etext. */
1065 /* Use plan B. Note that we now know there is a gap between */
1066 /* text and data segments, so plan A bought us something. */
1067 result = (char *)GC_find_limit((ptr_t)(DATAEND) - MIN_PAGE_SIZE, FALSE);
1068 }
1069 return((char *)result);
1070 }
1071 # endif
1072
1073
1074 #ifdef AMIGA
1075
1076 # define GC_AMIGA_DS
1077 # include "AmigaOS.c"
1078 # undef GC_AMIGA_DS
1079
1080 #else /* !OS2 && !Windows && !AMIGA */
1081
1082 void GC_register_data_segments()
1083 {
1084 # if !defined(PCR) && !defined(SRC_M3) && !defined(NEXT) && !defined(MACOS) \
1085 && !defined(MACOSX)
1086 # if defined(REDIRECT_MALLOC) && defined(SOLARIS_THREADS)
1087 /* As of Solaris 2.3, the Solaris threads implementation */
1088 /* allocates the data structure for the initial thread with */
1089 /* sbrk at process startup. It needs to be scanned, so that */
1090 /* we don't lose some malloc allocated data structures */
1091 /* hanging from it. We're on thin ice here ... */
1092 extern caddr_t sbrk();
1093
1094 GC_add_roots_inner(DATASTART, (char *)sbrk(0), FALSE);
1095 # else
1096 GC_add_roots_inner(DATASTART, (char *)(DATAEND), FALSE);
1097 # endif
1098 # endif
1099 # if !defined(PCR) && (defined(NEXT) || defined(MACOSX))
1100 GC_add_roots_inner(DATASTART, (char *) get_end(), FALSE);
1101 # endif
1102 # if defined(MACOS)
1103 {
1104 # if defined(THINK_C)
1105 extern void* GC_MacGetDataStart(void);
1106 /* globals begin above stack and end at a5. */
1107 GC_add_roots_inner((ptr_t)GC_MacGetDataStart(),
1108 (ptr_t)LMGetCurrentA5(), FALSE);
1109 # else
1110 # if defined(__MWERKS__)
1111 # if !__POWERPC__
1112 extern void* GC_MacGetDataStart(void);
1113 /* MATTHEW: Function to handle Far Globals (CW Pro 3) */
1114 # if __option(far_data)
1115 extern void* GC_MacGetDataEnd(void);
1116 # endif
1117 /* globals begin above stack and end at a5. */
1118 GC_add_roots_inner((ptr_t)GC_MacGetDataStart(),
1119 (ptr_t)LMGetCurrentA5(), FALSE);
1120 /* MATTHEW: Handle Far Globals */
1121 # if __option(far_data)
1122 /* Far globals follow he QD globals: */
1123 GC_add_roots_inner((ptr_t)LMGetCurrentA5(),
1124 (ptr_t)GC_MacGetDataEnd(), FALSE);
1125 # endif
1126 # else
1127 extern char __data_start__[], __data_end__[];
1128 GC_add_roots_inner((ptr_t)&__data_start__,
1129 (ptr_t)&__data_end__, FALSE);
1130 # endif /* __POWERPC__ */
1131 # endif /* __MWERKS__ */
1132 # endif /* !THINK_C */
1133 }
1134 # endif /* MACOS */
1135
1136 /* Dynamic libraries are added at every collection, since they may */
1137 /* change. */
1138 }
1139
1140 # endif /* ! AMIGA */
1141 # endif /* ! MSWIN32 && ! MSWINCE*/
1142 # endif /* ! OS2 */
1143
1144 /*
1145 * Auxiliary routines for obtaining memory from OS.
1146 */
1147
1148 # if !defined(OS2) && !defined(PCR) && !defined(AMIGA) \
1149 && !defined(MSWIN32) && !defined(MSWINCE) \
1150 && !defined(MACOS) && !defined(DOS4GW)
1151
1152 # ifdef SUNOS4
1153 extern caddr_t sbrk();
1154 # endif
1155 # ifdef __STDC__
1156 # define SBRK_ARG_T ptrdiff_t
1157 # else
1158 # define SBRK_ARG_T int
1159 # endif
1160
1161
1162 # ifdef RS6000
1163 /* The compiler seems to generate speculative reads one past the end of */
1164 /* an allocated object. Hence we need to make sure that the page */
1165 /* following the last heap page is also mapped. */
1166 ptr_t GC_unix_get_mem(bytes)
1167 word bytes;
1168 {
1169 caddr_t cur_brk = (caddr_t)sbrk(0);
1170 caddr_t result;
1171 SBRK_ARG_T lsbs = (word)cur_brk & (GC_page_size-1);
1172 static caddr_t my_brk_val = 0;
1173
1174 if ((SBRK_ARG_T)bytes < 0) return(0); /* too big */
1175 if (lsbs != 0) {
1176 if((caddr_t)(sbrk(GC_page_size - lsbs)) == (caddr_t)(-1)) return(0);
1177 }
1178 if (cur_brk == my_brk_val) {
1179 /* Use the extra block we allocated last time. */
1180 result = (ptr_t)sbrk((SBRK_ARG_T)bytes);
1181 if (result == (caddr_t)(-1)) return(0);
1182 result -= GC_page_size;
1183 } else {
1184 result = (ptr_t)sbrk(GC_page_size + (SBRK_ARG_T)bytes);
1185 if (result == (caddr_t)(-1)) return(0);
1186 }
1187 my_brk_val = result + bytes + GC_page_size; /* Always page aligned */
1188 return((ptr_t)result);
1189 }
1190
1191 #else /* Not RS6000 */
1192
1193 #if defined(USE_MMAP)
1194 /* Tested only under Linux, IRIX5 and Solaris 2 */
1195
1196 #ifdef USE_MMAP_FIXED
1197 # define GC_MMAP_FLAGS MAP_FIXED | MAP_PRIVATE
1198 /* Seems to yield better performance on Solaris 2, but can */
1199 /* be unreliable if something is already mapped at the address. */
1200 #else
1201 # define GC_MMAP_FLAGS MAP_PRIVATE
1202 #endif
1203
1204 #ifndef HEAP_START
1205 # define HEAP_START 0
1206 #endif
1207
1208 ptr_t GC_unix_get_mem(bytes)
1209 word bytes;
1210 {
1211 static GC_bool initialized = FALSE;
1212 static int fd;
1213 void *result;
1214 static ptr_t last_addr = HEAP_START;
1215
1216 if (!initialized) {
1217 fd = open("/dev/zero", O_RDONLY);
1218 initialized = TRUE;
1219 }
1220 if (bytes & (GC_page_size -1)) ABORT("Bad GET_MEM arg");
1221 result = mmap(last_addr, bytes, PROT_READ | PROT_WRITE | OPT_PROT_EXEC,
1222 GC_MMAP_FLAGS, fd, 0/* offset */);
1223 if (result == MAP_FAILED) return(0);
1224 last_addr = (ptr_t)result + bytes + GC_page_size - 1;
1225 last_addr = (ptr_t)((word)last_addr & ~(GC_page_size - 1));
1226 # if !defined(LINUX)
1227 if (last_addr == 0) {
1228 /* Oops. We got the end of the address space. This isn't */
1229 /* usable by arbitrary C code, since one-past-end pointers */
1230 /* don't work, so we discard it and try again. */
1231 munmap(result, (size_t)(-GC_page_size) - (size_t)result);
1232 /* Leave last page mapped, so we can't repeat. */
1233 return GC_unix_get_mem(bytes);
1234 }
1235 # else
1236 GC_ASSERT(last_addr != 0);
1237 # endif
1238 return((ptr_t)result);
1239 }
1240
1241 #else /* Not RS6000, not USE_MMAP */
1242 ptr_t GC_unix_get_mem(bytes)
1243 word bytes;
1244 {
1245 ptr_t result;
1246 # ifdef IRIX5
1247 /* Bare sbrk isn't thread safe. Play by malloc rules. */
1248 /* The equivalent may be needed on other systems as well. */
1249 __LOCK_MALLOC();
1250 # endif
1251 {
1252 ptr_t cur_brk = (ptr_t)sbrk(0);
1253 SBRK_ARG_T lsbs = (word)cur_brk & (GC_page_size-1);
1254
1255 if ((SBRK_ARG_T)bytes < 0) return(0); /* too big */
1256 if (lsbs != 0) {
1257 if((ptr_t)sbrk(GC_page_size - lsbs) == (ptr_t)(-1)) return(0);
1258 }
1259 result = (ptr_t)sbrk((SBRK_ARG_T)bytes);
1260 if (result == (ptr_t)(-1)) result = 0;
1261 }
1262 # ifdef IRIX5
1263 __UNLOCK_MALLOC();
1264 # endif
1265 return(result);
1266 }
1267
1268 #endif /* Not USE_MMAP */
1269 #endif /* Not RS6000 */
1270
1271 # endif /* UN*X */
1272
1273 # ifdef OS2
1274
1275 void * os2_alloc(size_t bytes)
1276 {
1277 void * result;
1278
1279 if (DosAllocMem(&result, bytes, PAG_EXECUTE | PAG_READ |
1280 PAG_WRITE | PAG_COMMIT)
1281 != NO_ERROR) {
1282 return(0);
1283 }
1284 if (result == 0) return(os2_alloc(bytes));
1285 return(result);
1286 }
1287
1288 # endif /* OS2 */
1289
1290
1291 # if defined(MSWIN32) || defined(MSWINCE)
1292 SYSTEM_INFO GC_sysinfo;
1293 # endif
1294
1295
1296 # ifdef MSWIN32
1297 word GC_n_heap_bases = 0;
1298
1299 ptr_t GC_win32_get_mem(bytes)
1300 word bytes;
1301 {
1302 ptr_t result;
1303
1304 if (GC_win32s) {
1305 /* VirtualAlloc doesn't like PAGE_EXECUTE_READWRITE. */
1306 /* There are also unconfirmed rumors of other */
1307 /* problems, so we dodge the issue. */
1308 result = (ptr_t) GlobalAlloc(0, bytes + HBLKSIZE);
1309 result = (ptr_t)(((word)result + HBLKSIZE) & ~(HBLKSIZE-1));
1310 } else {
1311 result = (ptr_t) VirtualAlloc(NULL, bytes,
1312 MEM_COMMIT | MEM_RESERVE,
1313 PAGE_EXECUTE_READWRITE);
1314 }
1315 if (HBLKDISPL(result) != 0) ABORT("Bad VirtualAlloc result");
1316 /* If I read the documentation correctly, this can */
1317 /* only happen if HBLKSIZE > 64k or not a power of 2. */
1318 if (GC_n_heap_bases >= MAX_HEAP_SECTS) ABORT("Too many heap sections");
1319 GC_heap_bases[GC_n_heap_bases++] = result;
1320 return(result);
1321 }
1322
1323 void GC_win32_free_heap ()
1324 {
1325 if (GC_win32s) {
1326 while (GC_n_heap_bases > 0) {
1327 GlobalFree (GC_heap_bases[--GC_n_heap_bases]);
1328 GC_heap_bases[GC_n_heap_bases] = 0;
1329 }
1330 }
1331 }
1332 # endif
1333
1334 #ifdef AMIGA
1335 # define GC_AMIGA_AM
1336 # include "AmigaOS.c"
1337 # undef GC_AMIGA_AM
1338 #endif
1339
1340
1341 # ifdef MSWINCE
1342 word GC_n_heap_bases = 0;
1343
1344 ptr_t GC_wince_get_mem(bytes)
1345 word bytes;
1346 {
1347 ptr_t result;
1348 word i;
1349
1350 /* Round up allocation size to multiple of page size */
1351 bytes = (bytes + GC_page_size-1) & ~(GC_page_size-1);
1352
1353 /* Try to find reserved, uncommitted pages */
1354 for (i = 0; i < GC_n_heap_bases; i++) {
1355 if (((word)(-(signed_word)GC_heap_lengths[i])
1356 & (GC_sysinfo.dwAllocationGranularity-1))
1357 >= bytes) {
1358 result = GC_heap_bases[i] + GC_heap_lengths[i];
1359 break;
1360 }
1361 }
1362
1363 if (i == GC_n_heap_bases) {
1364 /* Reserve more pages */
1365 word res_bytes = (bytes + GC_sysinfo.dwAllocationGranularity-1)
1366 & ~(GC_sysinfo.dwAllocationGranularity-1);
1367 result = (ptr_t) VirtualAlloc(NULL, res_bytes,
1368 MEM_RESERVE | MEM_TOP_DOWN,
1369 PAGE_EXECUTE_READWRITE);
1370 if (HBLKDISPL(result) != 0) ABORT("Bad VirtualAlloc result");
1371 /* If I read the documentation correctly, this can */
1372 /* only happen if HBLKSIZE > 64k or not a power of 2. */
1373 if (GC_n_heap_bases >= MAX_HEAP_SECTS) ABORT("Too many heap sections");
1374 GC_heap_bases[GC_n_heap_bases] = result;
1375 GC_heap_lengths[GC_n_heap_bases] = 0;
1376 GC_n_heap_bases++;
1377 }
1378
1379 /* Commit pages */
1380 result = (ptr_t) VirtualAlloc(result, bytes,
1381 MEM_COMMIT,
1382 PAGE_EXECUTE_READWRITE);
1383 if (result != NULL) {
1384 if (HBLKDISPL(result) != 0) ABORT("Bad VirtualAlloc result");
1385 GC_heap_lengths[i] += bytes;
1386 }
1387
1388 return(result);
1389 }
1390 # endif
1391
1392 #ifdef USE_MUNMAP
1393
1394 /* For now, this only works on Win32/WinCE and some Unix-like */
1395 /* systems. If you have something else, don't define */
1396 /* USE_MUNMAP. */
1397 /* We assume ANSI C to support this feature. */
1398
1399 #if !defined(MSWIN32) && !defined(MSWINCE)
1400
1401 #include <unistd.h>
1402 #include <sys/mman.h>
1403 #include <sys/stat.h>
1404 #include <sys/types.h>
1405
1406 #endif
1407
1408 /* Compute a page aligned starting address for the unmap */
1409 /* operation on a block of size bytes starting at start. */
1410 /* Return 0 if the block is too small to make this feasible. */
1411 ptr_t GC_unmap_start(ptr_t start, word bytes)
1412 {
1413 ptr_t result = start;
1414 /* Round start to next page boundary. */
1415 result += GC_page_size - 1;
1416 result = (ptr_t)((word)result & ~(GC_page_size - 1));
1417 if (result + GC_page_size > start + bytes) return 0;
1418 return result;
1419 }
1420
1421 /* Compute end address for an unmap operation on the indicated */
1422 /* block. */
1423 ptr_t GC_unmap_end(ptr_t start, word bytes)
1424 {
1425 ptr_t end_addr = start + bytes;
1426 end_addr = (ptr_t)((word)end_addr & ~(GC_page_size - 1));
1427 return end_addr;
1428 }
1429
1430 /* Under Win32/WinCE we commit (map) and decommit (unmap) */
1431 /* memory using VirtualAlloc and VirtualFree. These functions */
1432 /* work on individual allocations of virtual memory, made */
1433 /* previously using VirtualAlloc with the MEM_RESERVE flag. */
1434 /* The ranges we need to (de)commit may span several of these */
1435 /* allocations; therefore we use VirtualQuery to check */
1436 /* allocation lengths, and split up the range as necessary. */
1437
1438 /* We assume that GC_remap is called on exactly the same range */
1439 /* as a previous call to GC_unmap. It is safe to consistently */
1440 /* round the endpoints in both places. */
1441 void GC_unmap(ptr_t start, word bytes)
1442 {
1443 ptr_t start_addr = GC_unmap_start(start, bytes);
1444 ptr_t end_addr = GC_unmap_end(start, bytes);
1445 word len = end_addr - start_addr;
1446 if (0 == start_addr) return;
1447 # if defined(MSWIN32) || defined(MSWINCE)
1448 while (len != 0) {
1449 MEMORY_BASIC_INFORMATION mem_info;
1450 GC_word free_len;
1451 if (VirtualQuery(start_addr, &mem_info, sizeof(mem_info))
1452 != sizeof(mem_info))
1453 ABORT("Weird VirtualQuery result");
1454 free_len = (len < mem_info.RegionSize) ? len : mem_info.RegionSize;
1455 if (!VirtualFree(start_addr, free_len, MEM_DECOMMIT))
1456 ABORT("VirtualFree failed");
1457 GC_unmapped_bytes += free_len;
1458 start_addr += free_len;
1459 len -= free_len;
1460 }
1461 # else
1462 if (munmap(start_addr, len) != 0) ABORT("munmap failed");
1463 GC_unmapped_bytes += len;
1464 # endif
1465 }
1466
1467
1468 void GC_remap(ptr_t start, word bytes)
1469 {
1470 static int zero_descr = -1;
1471 ptr_t start_addr = GC_unmap_start(start, bytes);
1472 ptr_t end_addr = GC_unmap_end(start, bytes);
1473 word len = end_addr - start_addr;
1474 ptr_t result;
1475
1476 # if defined(MSWIN32) || defined(MSWINCE)
1477 if (0 == start_addr) return;
1478 while (len != 0) {
1479 MEMORY_BASIC_INFORMATION mem_info;
1480 GC_word alloc_len;
1481 if (VirtualQuery(start_addr, &mem_info, sizeof(mem_info))
1482 != sizeof(mem_info))
1483 ABORT("Weird VirtualQuery result");
1484 alloc_len = (len < mem_info.RegionSize) ? len : mem_info.RegionSize;
1485 result = VirtualAlloc(start_addr, alloc_len,
1486 MEM_COMMIT,
1487 PAGE_EXECUTE_READWRITE);
1488 if (result != start_addr) {
1489 ABORT("VirtualAlloc remapping failed");
1490 }
1491 GC_unmapped_bytes -= alloc_len;
1492 start_addr += alloc_len;
1493 len -= alloc_len;
1494 }
1495 # else
1496 if (-1 == zero_descr) zero_descr = open("/dev/zero", O_RDWR);
1497 if (0 == start_addr) return;
1498 result = mmap(start_addr, len, PROT_READ | PROT_WRITE | OPT_PROT_EXEC,
1499 MAP_FIXED | MAP_PRIVATE, zero_descr, 0);
1500 if (result != start_addr) {
1501 ABORT("mmap remapping failed");
1502 }
1503 GC_unmapped_bytes -= len;
1504 # endif
1505 }
1506
1507 /* Two adjacent blocks have already been unmapped and are about to */
1508 /* be merged. Unmap the whole block. This typically requires */
1509 /* that we unmap a small section in the middle that was not previously */
1510 /* unmapped due to alignment constraints. */
1511 void GC_unmap_gap(ptr_t start1, word bytes1, ptr_t start2, word bytes2)
1512 {
1513 ptr_t start1_addr = GC_unmap_start(start1, bytes1);
1514 ptr_t end1_addr = GC_unmap_end(start1, bytes1);
1515 ptr_t start2_addr = GC_unmap_start(start2, bytes2);
1516 ptr_t end2_addr = GC_unmap_end(start2, bytes2);
1517 ptr_t start_addr = end1_addr;
1518 ptr_t end_addr = start2_addr;
1519 word len;
1520 GC_ASSERT(start1 + bytes1 == start2);
1521 if (0 == start1_addr) start_addr = GC_unmap_start(start1, bytes1 + bytes2);
1522 if (0 == start2_addr) end_addr = GC_unmap_end(start1, bytes1 + bytes2);
1523 if (0 == start_addr) return;
1524 len = end_addr - start_addr;
1525 # if defined(MSWIN32) || defined(MSWINCE)
1526 while (len != 0) {
1527 MEMORY_BASIC_INFORMATION mem_info;
1528 GC_word free_len;
1529 if (VirtualQuery(start_addr, &mem_info, sizeof(mem_info))
1530 != sizeof(mem_info))
1531 ABORT("Weird VirtualQuery result");
1532 free_len = (len < mem_info.RegionSize) ? len : mem_info.RegionSize;
1533 if (!VirtualFree(start_addr, free_len, MEM_DECOMMIT))
1534 ABORT("VirtualFree failed");
1535 GC_unmapped_bytes += free_len;
1536 start_addr += free_len;
1537 len -= free_len;
1538 }
1539 # else
1540 if (len != 0 && munmap(start_addr, len) != 0) ABORT("munmap failed");
1541 GC_unmapped_bytes += len;
1542 # endif
1543 }
1544
1545 #endif /* USE_MUNMAP */
1546
1547 /* Routine for pushing any additional roots. In THREADS */
1548 /* environment, this is also responsible for marking from */
1549 /* thread stacks. */
1550 #ifndef THREADS
1551 void (*GC_push_other_roots)() = 0;
1552 #else /* THREADS */
1553
1554 # ifdef PCR
1555 PCR_ERes GC_push_thread_stack(PCR_Th_T *t, PCR_Any dummy)
1556 {
1557 struct PCR_ThCtl_TInfoRep info;
1558 PCR_ERes result;
1559
1560 info.ti_stkLow = info.ti_stkHi = 0;
1561 result = PCR_ThCtl_GetInfo(t, &info);
1562 GC_push_all_stack((ptr_t)(info.ti_stkLow), (ptr_t)(info.ti_stkHi));
1563 return(result);
1564 }
1565
1566 /* Push the contents of an old object. We treat this as stack */
1567 /* data only becasue that makes it robust against mark stack */
1568 /* overflow. */
1569 PCR_ERes GC_push_old_obj(void *p, size_t size, PCR_Any data)
1570 {
1571 GC_push_all_stack((ptr_t)p, (ptr_t)p + size);
1572 return(PCR_ERes_okay);
1573 }
1574
1575
1576 void GC_default_push_other_roots GC_PROTO((void))
1577 {
1578 /* Traverse data allocated by previous memory managers. */
1579 {
1580 extern struct PCR_MM_ProcsRep * GC_old_allocator;
1581
1582 if ((*(GC_old_allocator->mmp_enumerate))(PCR_Bool_false,
1583 GC_push_old_obj, 0)
1584 != PCR_ERes_okay) {
1585 ABORT("Old object enumeration failed");
1586 }
1587 }
1588 /* Traverse all thread stacks. */
1589 if (PCR_ERes_IsErr(
1590 PCR_ThCtl_ApplyToAllOtherThreads(GC_push_thread_stack,0))
1591 || PCR_ERes_IsErr(GC_push_thread_stack(PCR_Th_CurrThread(), 0))) {
1592 ABORT("Thread stack marking failed\n");
1593 }
1594 }
1595
1596 # endif /* PCR */
1597
1598 # ifdef SRC_M3
1599
1600 # ifdef ALL_INTERIOR_POINTERS
1601 --> misconfigured
1602 # endif
1603
1604 void GC_push_thread_structures GC_PROTO((void))
1605 {
1606 /* Not our responsibibility. */
1607 }
1608
1609 extern void ThreadF__ProcessStacks();
1610
1611 void GC_push_thread_stack(start, stop)
1612 word start, stop;
1613 {
1614 GC_push_all_stack((ptr_t)start, (ptr_t)stop + sizeof(word));
1615 }
1616
1617 /* Push routine with M3 specific calling convention. */
1618 GC_m3_push_root(dummy1, p, dummy2, dummy3)
1619 word *p;
1620 ptr_t dummy1, dummy2;
1621 int dummy3;
1622 {
1623 word q = *p;
1624
1625 GC_PUSH_ONE_STACK(q, p);
1626 }
1627
1628 /* M3 set equivalent to RTHeap.TracedRefTypes */
1629 typedef struct { int elts[1]; } RefTypeSet;
1630 RefTypeSet GC_TracedRefTypes = {{0x1}};
1631
1632 void GC_default_push_other_roots GC_PROTO((void))
1633 {
1634 /* Use the M3 provided routine for finding static roots. */
1635 /* This is a bit dubious, since it presumes no C roots. */
1636 /* We handle the collector roots explicitly in GC_push_roots */
1637 RTMain__GlobalMapProc(GC_m3_push_root, 0, GC_TracedRefTypes);
1638 if (GC_words_allocd > 0) {
1639 ThreadF__ProcessStacks(GC_push_thread_stack);
1640 }
1641 /* Otherwise this isn't absolutely necessary, and we have */
1642 /* startup ordering problems. */
1643 }
1644
1645 # endif /* SRC_M3 */
1646
1647 # if defined(SOLARIS_THREADS) || defined(WIN32_THREADS) \
1648 || defined(IRIX_THREADS) || defined(LINUX_THREADS) \
1649 || defined(HPUX_THREADS)
1650
1651 extern void GC_push_all_stacks();
1652
1653 void GC_default_push_other_roots GC_PROTO((void))
1654 {
1655 GC_push_all_stacks();
1656 }
1657
1658 # endif /* SOLARIS_THREADS || ... */
1659
1660 void (*GC_push_other_roots) GC_PROTO((void)) = GC_default_push_other_roots;
1661
1662 #endif
1663
1664 /*
1665 * Routines for accessing dirty bits on virtual pages.
1666 * We plan to eventually implement four strategies for doing so:
1667 * DEFAULT_VDB: A simple dummy implementation that treats every page
1668 * as possibly dirty. This makes incremental collection
1669 * useless, but the implementation is still correct.
1670 * PCR_VDB: Use PPCRs virtual dirty bit facility.
1671 * PROC_VDB: Use the /proc facility for reading dirty bits. Only
1672 * works under some SVR4 variants. Even then, it may be
1673 * too slow to be entirely satisfactory. Requires reading
1674 * dirty bits for entire address space. Implementations tend
1675 * to assume that the client is a (slow) debugger.
1676 * MPROTECT_VDB:Protect pages and then catch the faults to keep track of
1677 * dirtied pages. The implementation (and implementability)
1678 * is highly system dependent. This usually fails when system
1679 * calls write to a protected page. We prevent the read system
1680 * call from doing so. It is the clients responsibility to
1681 * make sure that other system calls are similarly protected
1682 * or write only to the stack.
1683 */
1684
1685 GC_bool GC_dirty_maintained = FALSE;
1686
1687 # ifdef DEFAULT_VDB
1688
1689 /* All of the following assume the allocation lock is held, and */
1690 /* signals are disabled. */
1691
1692 /* The client asserts that unallocated pages in the heap are never */
1693 /* written. */
1694
1695 /* Initialize virtual dirty bit implementation. */
1696 void GC_dirty_init()
1697 {
1698 GC_dirty_maintained = TRUE;
1699 }
1700
1701 /* Retrieve system dirty bits for heap to a local buffer. */
1702 /* Restore the systems notion of which pages are dirty. */
1703 void GC_read_dirty()
1704 {}
1705
1706 /* Is the HBLKSIZE sized page at h marked dirty in the local buffer? */
1707 /* If the actual page size is different, this returns TRUE if any */
1708 /* of the pages overlapping h are dirty. This routine may err on the */
1709 /* side of labelling pages as dirty (and this implementation does). */
1710 /*ARGSUSED*/
1711 GC_bool GC_page_was_dirty(h)
1712 struct hblk *h;
1713 {
1714 return(TRUE);
1715 }
1716
1717 /*
1718 * The following two routines are typically less crucial. They matter
1719 * most with large dynamic libraries, or if we can't accurately identify
1720 * stacks, e.g. under Solaris 2.X. Otherwise the following default
1721 * versions are adequate.
1722 */
1723
1724 /* Could any valid GC heap pointer ever have been written to this page? */
1725 /*ARGSUSED*/
1726 GC_bool GC_page_was_ever_dirty(h)
1727 struct hblk *h;
1728 {
1729 return(TRUE);
1730 }
1731
1732 /* Reset the n pages starting at h to "was never dirty" status. */
1733 void GC_is_fresh(h, n)
1734 struct hblk *h;
1735 word n;
1736 {
1737 }
1738
1739 /* A call hints that h is about to be written. */
1740 /* May speed up some dirty bit implementations. */
1741 /*ARGSUSED*/
1742 void GC_write_hint(h)
1743 struct hblk *h;
1744 {
1745 }
1746
1747 # endif /* DEFAULT_VDB */
1748
1749
1750 # ifdef MPROTECT_VDB
1751
1752 /*
1753 * See DEFAULT_VDB for interface descriptions.
1754 */
1755
1756 /*
1757 * This implementation maintains dirty bits itself by catching write
1758 * faults and keeping track of them. We assume nobody else catches
1759 * SIGBUS or SIGSEGV. We assume no write faults occur in system calls
1760 * except as a result of a read system call. This means clients must
1761 * either ensure that system calls do not touch the heap, or must
1762 * provide their own wrappers analogous to the one for read.
1763 * We assume the page size is a multiple of HBLKSIZE.
1764 * This implementation is currently SunOS 4.X and IRIX 5.X specific, though we
1765 * tried to use portable code where easily possible. It is known
1766 * not to work under a number of other systems.
1767 */
1768
1769 # if !defined(MSWIN32) && !defined(MSWINCE)
1770
1771 # include <sys/mman.h>
1772 # include <signal.h>
1773 # include <sys/syscall.h>
1774
1775 # define PROTECT(addr, len) \
1776 if (mprotect((caddr_t)(addr), (size_t)(len), \
1777 PROT_READ | OPT_PROT_EXEC) < 0) { \
1778 ABORT("mprotect failed"); \
1779 }
1780 # define UNPROTECT(addr, len) \
1781 if (mprotect((caddr_t)(addr), (size_t)(len), \
1782 PROT_WRITE | PROT_READ | OPT_PROT_EXEC ) < 0) { \
1783 ABORT("un-mprotect failed"); \
1784 }
1785
1786 # else
1787
1788 # ifndef MSWINCE
1789 # include <signal.h>
1790 # endif
1791
1792 static DWORD protect_junk;
1793 # define PROTECT(addr, len) \
1794 if (!VirtualProtect((addr), (len), PAGE_EXECUTE_READ, \
1795 &protect_junk)) { \
1796 DWORD last_error = GetLastError(); \
1797 GC_printf1("Last error code: %lx\n", last_error); \
1798 ABORT("VirtualProtect failed"); \
1799 }
1800 # define UNPROTECT(addr, len) \
1801 if (!VirtualProtect((addr), (len), PAGE_EXECUTE_READWRITE, \
1802 &protect_junk)) { \
1803 ABORT("un-VirtualProtect failed"); \
1804 }
1805
1806 # endif
1807
1808 #if defined(SUNOS4) || defined(FREEBSD)
1809 typedef void (* SIG_PF)();
1810 #endif
1811 #if defined(SUNOS5SIGS) || defined(OSF1) || defined(LINUX) || defined(MACOSX)
1812 # ifdef __STDC__
1813 typedef void (* SIG_PF)(int);
1814 # else
1815 typedef void (* SIG_PF)();
1816 # endif
1817 #endif
1818 #if defined(MSWIN32)
1819 typedef LPTOP_LEVEL_EXCEPTION_FILTER SIG_PF;
1820 # undef SIG_DFL
1821 # define SIG_DFL (LPTOP_LEVEL_EXCEPTION_FILTER) (-1)
1822 #endif
1823 #if defined(MSWINCE)
1824 typedef LONG (WINAPI *SIG_PF)(struct _EXCEPTION_POINTERS *);
1825 # undef SIG_DFL
1826 # define SIG_DFL (SIG_PF) (-1)
1827 #endif
1828
1829 #if defined(IRIX5) || defined(OSF1)
1830 typedef void (* REAL_SIG_PF)(int, int, struct sigcontext *);
1831 #endif
1832 #if defined(SUNOS5SIGS)
1833 # ifdef HPUX
1834 # define SIGINFO __siginfo
1835 # else
1836 # define SIGINFO siginfo
1837 # endif
1838 # ifdef __STDC__
1839 typedef void (* REAL_SIG_PF)(int, struct SIGINFO *, void *);
1840 # else
1841 typedef void (* REAL_SIG_PF)();
1842 # endif
1843 #endif
1844 #if defined(LINUX)
1845 # include <linux/version.h>
1846 # if (LINUX_VERSION_CODE >= 0x20100) && !defined(M68K) || defined(ALPHA) || defined(IA64)
1847 typedef struct sigcontext s_c;
1848 # else
1849 typedef struct sigcontext_struct s_c;
1850 # endif
1851 # if defined(ALPHA) || defined(M68K)
1852 typedef void (* REAL_SIG_PF)(int, int, s_c *);
1853 # else
1854 # if defined(IA64) || defined(HP_PA)
1855 typedef void (* REAL_SIG_PF)(int, siginfo_t *, s_c *);
1856 # else
1857 typedef void (* REAL_SIG_PF)(int, s_c);
1858 # endif
1859 # endif
1860 # ifdef ALPHA
1861 /* Retrieve fault address from sigcontext structure by decoding */
1862 /* instruction. */
1863 char * get_fault_addr(s_c *sc) {
1864 unsigned instr;
1865 word faultaddr;
1866
1867 instr = *((unsigned *)(sc->sc_pc));
1868 faultaddr = sc->sc_regs[(instr >> 16) & 0x1f];
1869 faultaddr += (word) (((int)instr << 16) >> 16);
1870 return (char *)faultaddr;
1871 }
1872 # endif /* !ALPHA */
1873 # endif
1874
1875 # if defined(MACOSX) /* Should also test for PowerPC? */
1876 typedef void (* REAL_SIG_PF)(int, int, struct sigcontext *);
1877
1878 /* Decodes the machine instruction which was responsible for the sending of the
1879 SIGBUS signal. Sadly this is the only way to find the faulting address because
1880 the signal handler doesn't get it directly from the kernel (although it is
1881 available on the Mach level, but droppped by the BSD personality before it
1882 calls our signal handler...)
1883 This code should be able to deal correctly with all PPCs starting from the
1884 601 up to and including the G4s (including Velocity Engine). */
1885 #define EXTRACT_OP1(iw) (((iw) & 0xFC000000) >> 26)
1886 #define EXTRACT_OP2(iw) (((iw) & 0x000007FE) >> 1)
1887 #define EXTRACT_REGA(iw) (((iw) & 0x001F0000) >> 16)
1888 #define EXTRACT_REGB(iw) (((iw) & 0x03E00000) >> 21)
1889 #define EXTRACT_REGC(iw) (((iw) & 0x0000F800) >> 11)
1890 #define EXTRACT_DISP(iw) ((short *) &(iw))[1]
1891
1892 static char *get_fault_addr(struct sigcontext *scp)
1893 {
1894 unsigned int instr = *((unsigned int *) scp->sc_ir);
1895 unsigned int * regs = &((unsigned int *) scp->sc_regs)[2];
1896 int disp = 0, tmp;
1897 unsigned int baseA = 0, baseB = 0;
1898 unsigned int addr, alignmask = 0xFFFFFFFF;
1899
1900 #ifdef GC_DEBUG_DECODER
1901 GC_err_printf1("Instruction: 0x%lx\n", instr);
1902 GC_err_printf1("Opcode 1: d\n", (int)EXTRACT_OP1(instr));
1903 #endif
1904 switch(EXTRACT_OP1(instr)) {
1905 case 38: /* stb */
1906 case 39: /* stbu */
1907 case 54: /* stfd */
1908 case 55: /* stfdu */
1909 case 52: /* stfs */
1910 case 53: /* stfsu */
1911 case 44: /* sth */
1912 case 45: /* sthu */
1913 case 47: /* stmw */
1914 case 36: /* stw */
1915 case 37: /* stwu */
1916 tmp = EXTRACT_REGA(instr);
1917 if(tmp > 0)
1918 baseA = regs[tmp];
1919 disp = EXTRACT_DISP(instr);
1920 break;
1921 case 31:
1922 #ifdef GC_DEBUG_DECODER
1923 GC_err_printf1("Opcode 2: %d\n", (int)EXTRACT_OP2(instr));
1924 #endif
1925 switch(EXTRACT_OP2(instr)) {
1926 case 86: /* dcbf */
1927 case 54: /* dcbst */
1928 case 1014: /* dcbz */
1929 case 247: /* stbux */
1930 case 215: /* stbx */
1931 case 759: /* stfdux */
1932 case 727: /* stfdx */
1933 case 983: /* stfiwx */
1934 case 695: /* stfsux */
1935 case 663: /* stfsx */
1936 case 918: /* sthbrx */
1937 case 439: /* sthux */
1938 case 407: /* sthx */
1939 case 661: /* stswx */
1940 case 662: /* stwbrx */
1941 case 150: /* stwcx. */
1942 case 183: /* stwux */
1943 case 151: /* stwx */
1944 case 135: /* stvebx */
1945 case 167: /* stvehx */
1946 case 199: /* stvewx */
1947 case 231: /* stvx */
1948 case 487: /* stvxl */
1949 tmp = EXTRACT_REGA(instr);
1950 if(tmp > 0)
1951 baseA = regs[tmp];
1952 baseB = regs[EXTRACT_REGC(instr)];
1953 /* determine Altivec alignment mask */
1954 switch(EXTRACT_OP2(instr)) {
1955 case 167: /* stvehx */
1956 alignmask = 0xFFFFFFFE;
1957 break;
1958 case 199: /* stvewx */
1959 alignmask = 0xFFFFFFFC;
1960 break;
1961 case 231: /* stvx */
1962 alignmask = 0xFFFFFFF0;
1963 break;
1964 case 487: /* stvxl */
1965 alignmask = 0xFFFFFFF0;
1966 break;
1967 }
1968 break;
1969 case 725: /* stswi */
1970 tmp = EXTRACT_REGA(instr);
1971 if(tmp > 0)
1972 baseA = regs[tmp];
1973 break;
1974 default: /* ignore instruction */
1975 #ifdef GC_DEBUG_DECODER
1976 GC_err_printf("Ignored by inner handler\n");
1977 #endif
1978 return NULL;
1979 break;
1980 }
1981 break;
1982 default: /* ignore instruction */
1983 #ifdef GC_DEBUG_DECODER
1984 GC_err_printf("Ignored by main handler\n");
1985 #endif
1986 return NULL;
1987 break;
1988 }
1989
1990 addr = (baseA + baseB) + disp;
1991 addr &= alignmask;
1992 #ifdef GC_DEBUG_DECODER
1993 GC_err_printf1("BaseA: %d\n", baseA);
1994 GC_err_printf1("BaseB: %d\n", baseB);
1995 GC_err_printf1("Disp: %d\n", disp);
1996 GC_err_printf1("Address: %d\n", addr);
1997 #endif
1998 return (char *)addr;
1999 }
2000 #endif /* MACOSX */
2001
2002 SIG_PF GC_old_bus_handler;
2003 SIG_PF GC_old_segv_handler; /* Also old MSWIN32 ACCESS_VIOLATION filter */
2004
2005 #ifdef THREADS
2006 /* We need to lock around the bitmap update in the write fault handler */
2007 /* in order to avoid the risk of losing a bit. We do this with a */
2008 /* test-and-set spin lock if we know how to do that. Otherwise we */
2009 /* check whether we are already in the handler and use the dumb but */
2010 /* safe fallback algorithm of setting all bits in the word. */
2011 /* Contention should be very rare, so we do the minimum to handle it */
2012 /* correctly. */
2013 #ifdef GC_TEST_AND_SET_DEFINED
2014 static VOLATILE unsigned int fault_handler_lock = 0;
2015 void async_set_pht_entry_from_index(VOLATILE page_hash_table db, int index) {
2016 while (GC_test_and_set(&fault_handler_lock));
2017 /* Could also revert to set_pht_entry_from_index_safe if initial */
2018 /* GC_test_and_set fails. */
2019 set_pht_entry_from_index(db, index);
2020 GC_clear(&fault_handler_lock);
2021 }
2022 #else /* !GC_TEST_AND_SET_DEFINED */
2023 /* THIS IS INCORRECT! The dirty bit vector may be temporarily wrong, */
2024 /* just before we notice the conflict and correct it. We may end up */
2025 /* looking at it while it's wrong. But this requires contention */
2026 /* exactly when a GC is triggered, which seems far less likely to */
2027 /* fail than the old code, which had no reported failures. Thus we */
2028 /* leave it this way while we think of something better, or support */
2029 /* GC_test_and_set on the remaining platforms. */
2030 static VOLATILE word currently_updating = 0;
2031 void async_set_pht_entry_from_index(VOLATILE page_hash_table db, int index) {
2032 unsigned int update_dummy;
2033 currently_updating = (word)(&update_dummy);
2034 set_pht_entry_from_index(db, index);
2035 /* If we get contention in the 10 or so instruction window here, */
2036 /* and we get stopped by a GC between the two updates, we lose! */
2037 if (currently_updating != (word)(&update_dummy)) {
2038 set_pht_entry_from_index_safe(db, index);
2039 /* We claim that if two threads concurrently try to update the */
2040 /* dirty bit vector, the first one to execute UPDATE_START */
2041 /* will see it changed when UPDATE_END is executed. (Note that */
2042 /* &update_dummy must differ in two distinct threads.) It */
2043 /* will then execute set_pht_entry_from_index_safe, thus */
2044 /* returning us to a safe state, though not soon enough. */
2045 }
2046 }
2047 #endif /* !GC_TEST_AND_SET_DEFINED */
2048 #else /* !THREADS */
2049 # define async_set_pht_entry_from_index(db, index) \
2050 set_pht_entry_from_index(db, index)
2051 #endif /* !THREADS */
2052
2053 /*ARGSUSED*/
2054 # if defined (SUNOS4) || defined(FREEBSD)
2055 void GC_write_fault_handler(sig, code, scp, addr)
2056 int sig, code;
2057 struct sigcontext *scp;
2058 char * addr;
2059 # ifdef SUNOS4
2060 # define SIG_OK (sig == SIGSEGV || sig == SIGBUS)
2061 # define CODE_OK (FC_CODE(code) == FC_PROT \
2062 || (FC_CODE(code) == FC_OBJERR \
2063 && FC_ERRNO(code) == FC_PROT))
2064 # endif
2065 # ifdef FREEBSD
2066 # define SIG_OK (sig == SIGBUS)
2067 # define CODE_OK (code == BUS_PAGE_FAULT)
2068 # endif
2069 # endif
2070 # if defined(IRIX5) || defined(OSF1)
2071 # include <errno.h>
2072 void GC_write_fault_handler(int sig, int code, struct sigcontext *scp)
2073 # define SIG_OK (sig == SIGSEGV)
2074 # ifdef OSF1
2075 # define CODE_OK (code == 2 /* experimentally determined */)
2076 # endif
2077 # ifdef IRIX5
2078 # define CODE_OK (code == EACCES)
2079 # endif
2080 # endif
2081 # if defined(LINUX)
2082 # if defined(ALPHA) || defined(M68K)
2083 void GC_write_fault_handler(int sig, int code, s_c * sc)
2084 # else
2085 # if defined(IA64) || defined(HP_PA)
2086 void GC_write_fault_handler(int sig, siginfo_t * si, s_c * scp)
2087 # else
2088 void GC_write_fault_handler(int sig, s_c sc)
2089 # endif
2090 # endif
2091 # define SIG_OK (sig == SIGSEGV)
2092 # define CODE_OK TRUE
2093 /* Empirically c.trapno == 14, on IA32, but is that useful? */
2094 /* Should probably consider alignment issues on other */
2095 /* architectures. */
2096 # endif
2097 # if defined(SUNOS5SIGS)
2098 # ifdef __STDC__
2099 void GC_write_fault_handler(int sig, struct SIGINFO *scp, void * context)
2100 # else
2101 void GC_write_fault_handler(sig, scp, context)
2102 int sig;
2103 struct SIGINFO *scp;
2104 void * context;
2105 # endif
2106 # ifdef HPUX
2107 # define SIG_OK (sig == SIGSEGV || sig == SIGBUS)
2108 # define CODE_OK (scp -> si_code == SEGV_ACCERR) \
2109 || (scp -> si_code == BUS_ADRERR) \
2110 || (scp -> si_code == BUS_UNKNOWN) \
2111 || (scp -> si_code == SEGV_UNKNOWN) \
2112 || (scp -> si_code == BUS_OBJERR)
2113 # else
2114 # define SIG_OK (sig == SIGSEGV)
2115 # define CODE_OK (scp -> si_code == SEGV_ACCERR)
2116 # endif
2117 # endif
2118
2119 # if defined(MACOSX)
2120 void GC_write_fault_handler(int sig, int code, struct sigcontext *scp)
2121 # define SIG_OK (sig == SIGBUS)
2122 # define CODE_OK (code == 0 /* experimentally determined */)
2123 # endif
2124
2125 # if defined(MSWIN32) || defined(MSWINCE)
2126 LONG WINAPI GC_write_fault_handler(struct _EXCEPTION_POINTERS *exc_info)
2127 # define SIG_OK (exc_info -> ExceptionRecord -> ExceptionCode == \
2128 STATUS_ACCESS_VIOLATION)
2129 # define CODE_OK (exc_info -> ExceptionRecord -> ExceptionInformation[0] == 1)
2130 /* Write fault */
2131 # endif
2132 {
2133 register unsigned i;
2134 # ifdef IRIX5
2135 char * addr = (char *) (size_t) (scp -> sc_badvaddr);
2136 # endif
2137 # if defined(OSF1) && defined(ALPHA)
2138 char * addr = (char *) (scp -> sc_traparg_a0);
2139 # endif
2140 # ifdef SUNOS5SIGS
2141 char * addr = (char *) (scp -> si_addr);
2142 # endif
2143 # ifdef LINUX
2144 # ifdef I386
2145 char * addr = (char *) (sc.cr2);
2146 # else
2147 # if defined(M68K)
2148 char * addr = NULL;
2149
2150 struct sigcontext *scp = (struct sigcontext *)(sc);
2151
2152 int format = (scp->sc_formatvec >> 12) & 0xf;
2153 unsigned long *framedata = (unsigned long *)(scp + 1);
2154 unsigned long ea;
2155
2156 if (format == 0xa || format == 0xb) {
2157 /* 68020/030 */
2158 ea = framedata[2];
2159 } else if (format == 7) {
2160 /* 68040 */
2161 ea = framedata[3];
2162 if (framedata[1] & 0x08000000) {
2163 /* correct addr on misaligned access */
2164 ea = (ea+4095)&(~4095);
2165 }
2166 } else if (format == 4) {
2167 /* 68060 */
2168 ea = framedata[0];
2169 if (framedata[1] & 0x08000000) {
2170 /* correct addr on misaligned access */
2171 ea = (ea+4095)&(~4095);
2172 }
2173 }
2174 addr = (char *)ea;
2175 # else
2176 # ifdef ALPHA
2177 char * addr = get_fault_addr(sc);
2178 # else
2179 # if defined(IA64) || defined(HP_PA)
2180 char * addr = si -> si_addr;
2181 /* I believe this is claimed to work on all platforms for */
2182 /* Linux 2.3.47 and later. Hopefully we don't have to */
2183 /* worry about earlier kernels on IA64. */
2184 # else
2185 # if defined(POWERPC)
2186 char * addr = (char *) (sc.regs->dar);
2187 # else
2188 --> architecture not supported
2189 # endif
2190 # endif
2191 # endif
2192 # endif
2193 # endif
2194 # endif
2195 # if defined(MACOSX)
2196 char * addr = get_fault_addr(scp);
2197 # endif
2198 # if defined(MSWIN32) || defined(MSWINCE)
2199 char * addr = (char *) (exc_info -> ExceptionRecord
2200 -> ExceptionInformation[1]);
2201 # define sig SIGSEGV
2202 # endif
2203
2204 if (SIG_OK && CODE_OK) {
2205 register struct hblk * h =
2206 (struct hblk *)((word)addr & ~(GC_page_size-1));
2207 GC_bool in_allocd_block;
2208
2209 # ifdef SUNOS5SIGS
2210 /* Address is only within the correct physical page. */
2211 in_allocd_block = FALSE;
2212 for (i = 0; i < divHBLKSZ(GC_page_size); i++) {
2213 if (HDR(h+i) != 0) {
2214 in_allocd_block = TRUE;
2215 }
2216 }
2217 # else
2218 in_allocd_block = (HDR(addr) != 0);
2219 # endif
2220 if (!in_allocd_block) {
2221 /* Heap blocks now begin and end on page boundaries */
2222 SIG_PF old_handler;
2223
2224 if (sig == SIGSEGV) {
2225 old_handler = GC_old_segv_handler;
2226 } else {
2227 old_handler = GC_old_bus_handler;
2228 }
2229 if (old_handler == SIG_DFL) {
2230 # if !defined(MSWIN32) && !defined(MSWINCE)
2231 GC_err_printf1("Segfault at 0x%lx\n", addr);
2232 ABORT("Unexpected bus error or segmentation fault");
2233 # else
2234 return(EXCEPTION_CONTINUE_SEARCH);
2235 # endif
2236 } else {
2237 # if defined (SUNOS4) || defined(FREEBSD)
2238 (*old_handler) (sig, code, scp, addr);
2239 return;
2240 # endif
2241 # if defined (SUNOS5SIGS)
2242 (*(REAL_SIG_PF)old_handler) (sig, scp, context);
2243 return;
2244 # endif
2245 # if defined (LINUX)
2246 # if defined(ALPHA) || defined(M68K)
2247 (*(REAL_SIG_PF)old_handler) (sig, code, sc);
2248 # else
2249 # if defined(IA64) || defined(HP_PA)
2250 (*(REAL_SIG_PF)old_handler) (sig, si, scp);
2251 # else
2252 (*(REAL_SIG_PF)old_handler) (sig, sc);
2253 # endif
2254 # endif
2255 return;
2256 # endif
2257 # if defined (IRIX5) || defined(OSF1)
2258 (*(REAL_SIG_PF)old_handler) (sig, code, scp);
2259 return;
2260 # endif
2261 # ifdef MACOSX
2262 (*(REAL_SIG_PF)old_handler) (sig, code, scp);
2263 # endif
2264 # ifdef MSWIN32
2265 return((*old_handler)(exc_info));
2266 # endif
2267 }
2268 }
2269 for (i = 0; i < divHBLKSZ(GC_page_size); i++) {
2270 register int index = PHT_HASH(h+i);
2271
2272 async_set_pht_entry_from_index(GC_dirty_pages, index);
2273 }
2274 UNPROTECT(h, GC_page_size);
2275 # if defined(OSF1) || defined(LINUX)
2276 /* These reset the signal handler each time by default. */
2277 signal(SIGSEGV, (SIG_PF) GC_write_fault_handler);
2278 # endif
2279 /* The write may not take place before dirty bits are read. */
2280 /* But then we'll fault again ... */
2281 # if defined(MSWIN32) || defined(MSWINCE)
2282 return(EXCEPTION_CONTINUE_EXECUTION);
2283 # else
2284 return;
2285 # endif
2286 }
2287 #if defined(MSWIN32) || defined(MSWINCE)
2288 return EXCEPTION_CONTINUE_SEARCH;
2289 #else
2290 GC_err_printf1("Segfault at 0x%lx\n", addr);
2291 ABORT("Unexpected bus error or segmentation fault");
2292 #endif
2293 }
2294
2295 /*
2296 * We hold the allocation lock. We expect block h to be written
2297 * shortly.
2298 */
2299 void GC_write_hint(h)
2300 struct hblk *h;
2301 {
2302 register struct hblk * h_trunc;
2303 register unsigned i;
2304 register GC_bool found_clean;
2305
2306 if (!GC_dirty_maintained) return;
2307 h_trunc = (struct hblk *)((word)h & ~(GC_page_size-1));
2308 found_clean = FALSE;
2309 for (i = 0; i < divHBLKSZ(GC_page_size); i++) {
2310 register int index = PHT_HASH(h_trunc+i);
2311
2312 if (!get_pht_entry_from_index(GC_dirty_pages, index)) {
2313 found_clean = TRUE;
2314 async_set_pht_entry_from_index(GC_dirty_pages, index);
2315 }
2316 }
2317 if (found_clean) {
2318 UNPROTECT(h_trunc, GC_page_size);
2319 }
2320 }
2321
2322 void GC_dirty_init()
2323 {
2324 # if defined(SUNOS5SIGS) || defined(IRIX5) /* || defined(OSF1) */
2325 struct sigaction act, oldact;
2326 # ifdef IRIX5
2327 act.sa_flags = SA_RESTART;
2328 act.sa_handler = GC_write_fault_handler;
2329 # else
2330 act.sa_flags = SA_RESTART | SA_SIGINFO;
2331 act.sa_sigaction = GC_write_fault_handler;
2332 # endif
2333 (void)sigemptyset(&act.sa_mask);
2334 # endif
2335 # if defined(MACOSX)
2336 struct sigaction act, oldact;
2337
2338 act.sa_flags = SA_RESTART;
2339 act.sa_handler = GC_write_fault_handler;
2340 sigemptyset(&act.sa_mask);
2341 # endif
2342 # ifdef PRINTSTATS
2343 GC_printf0("Inititalizing mprotect virtual dirty bit implementation\n");
2344 # endif
2345 GC_dirty_maintained = TRUE;
2346 if (GC_page_size % HBLKSIZE != 0) {
2347 GC_err_printf0("Page size not multiple of HBLKSIZE\n");
2348 ABORT("Page size not multiple of HBLKSIZE");
2349 }
2350 # if defined(SUNOS4) || defined(FREEBSD)
2351 GC_old_bus_handler = signal(SIGBUS, GC_write_fault_handler);
2352 if (GC_old_bus_handler == SIG_IGN) {
2353 GC_err_printf0("Previously ignored bus error!?");
2354 GC_old_bus_handler = SIG_DFL;
2355 }
2356 if (GC_old_bus_handler != SIG_DFL) {
2357 # ifdef PRINTSTATS
2358 GC_err_printf0("Replaced other SIGBUS handler\n");
2359 # endif
2360 }
2361 # endif
2362 # if defined(OSF1) || defined(SUNOS4) || defined(LINUX)
2363 GC_old_segv_handler = signal(SIGSEGV, (SIG_PF)GC_write_fault_handler);
2364 if (GC_old_segv_handler == SIG_IGN) {
2365 GC_err_printf0("Previously ignored segmentation violation!?");
2366 GC_old_segv_handler = SIG_DFL;
2367 }
2368 if (GC_old_segv_handler != SIG_DFL) {
2369 # ifdef PRINTSTATS
2370 GC_err_printf0("Replaced other SIGSEGV handler\n");
2371 # endif
2372 }
2373 # endif
2374 # if defined(SUNOS5SIGS) || defined(IRIX5)
2375 # if defined(IRIX_THREADS)
2376 sigaction(SIGSEGV, 0, &oldact);
2377 sigaction(SIGSEGV, &act, 0);
2378 # else
2379 sigaction(SIGSEGV, &act, &oldact);
2380 # endif
2381 # if defined(_sigargs)
2382 /* This is Irix 5.x, not 6.x. Irix 5.x does not have */
2383 /* sa_sigaction. */
2384 GC_old_segv_handler = oldact.sa_handler;
2385 # else /* Irix 6.x or SUNOS5SIGS */
2386 if (oldact.sa_flags & SA_SIGINFO) {
2387 GC_old_segv_handler = (SIG_PF)(oldact.sa_sigaction);
2388 } else {
2389 GC_old_segv_handler = oldact.sa_handler;
2390 }
2391 # endif
2392 if (GC_old_segv_handler == SIG_IGN) {
2393 GC_err_printf0("Previously ignored segmentation violation!?");
2394 GC_old_segv_handler = SIG_DFL;
2395 }
2396 if (GC_old_segv_handler != SIG_DFL) {
2397 # ifdef PRINTSTATS
2398 GC_err_printf0("Replaced other SIGSEGV handler\n");
2399 # endif
2400 }
2401 # endif
2402 # if defined(MACOSX) || defined(HPUX)
2403 sigaction(SIGBUS, &act, &oldact);
2404 GC_old_bus_handler = oldact.sa_handler;
2405 if (GC_old_bus_handler == SIG_IGN) {
2406 GC_err_printf0("Previously ignored bus error!?");
2407 GC_old_bus_handler = SIG_DFL;
2408 }
2409 if (GC_old_bus_handler != SIG_DFL) {
2410 # ifdef PRINTSTATS
2411 GC_err_printf0("Replaced other SIGBUS handler\n");
2412 # endif
2413 }
2414 # endif /* MACOS || HPUX */
2415 # if defined(MSWIN32)
2416 GC_old_segv_handler = SetUnhandledExceptionFilter(GC_write_fault_handler);
2417 if (GC_old_segv_handler != NULL) {
2418 # ifdef PRINTSTATS
2419 GC_err_printf0("Replaced other UnhandledExceptionFilter\n");
2420 # endif
2421 } else {
2422 GC_old_segv_handler = SIG_DFL;
2423 }
2424 # endif
2425 }
2426
2427
2428
2429 void GC_protect_heap()
2430 {
2431 ptr_t start;
2432 word len;
2433 unsigned i;
2434
2435 for (i = 0; i < GC_n_heap_sects; i++) {
2436 start = GC_heap_sects[i].hs_start;
2437 len = GC_heap_sects[i].hs_bytes;
2438 PROTECT(start, len);
2439 }
2440 }
2441
2442 /* We assume that either the world is stopped or its OK to lose dirty */
2443 /* bits while this is happenning (as in GC_enable_incremental). */
2444 void GC_read_dirty()
2445 {
2446 BCOPY((word *)GC_dirty_pages, GC_grungy_pages,
2447 (sizeof GC_dirty_pages));
2448 BZERO((word *)GC_dirty_pages, (sizeof GC_dirty_pages));
2449 GC_protect_heap();
2450 }
2451
2452 GC_bool GC_page_was_dirty(h)
2453 struct hblk * h;
2454 {
2455 register word index = PHT_HASH(h);
2456
2457 return(HDR(h) == 0 || get_pht_entry_from_index(GC_grungy_pages, index));
2458 }
2459
2460 /*
2461 * Acquiring the allocation lock here is dangerous, since this
2462 * can be called from within GC_call_with_alloc_lock, and the cord
2463 * package does so. On systems that allow nested lock acquisition, this
2464 * happens to work.
2465 * On other systems, SET_LOCK_HOLDER and friends must be suitably defined.
2466 */
2467
2468 static GC_bool syscall_acquired_lock = FALSE; /* Protected by GC lock. */
2469
2470 void GC_begin_syscall()
2471 {
2472 if (!I_HOLD_LOCK()) {
2473 LOCK();
2474 syscall_acquired_lock = TRUE;
2475 }
2476 }
2477
2478 void GC_end_syscall()
2479 {
2480 if (syscall_acquired_lock) {
2481 syscall_acquired_lock = FALSE;
2482 UNLOCK();
2483 }
2484 }
2485
2486 void GC_unprotect_range(addr, len)
2487 ptr_t addr;
2488 word len;
2489 {
2490 struct hblk * start_block;
2491 struct hblk * end_block;
2492 register struct hblk *h;
2493 ptr_t obj_start;
2494
2495 if (!GC_incremental) return;
2496 obj_start = GC_base(addr);
2497 if (obj_start == 0) return;
2498 if (GC_base(addr + len - 1) != obj_start) {
2499 ABORT("GC_unprotect_range(range bigger than object)");
2500 }
2501 start_block = (struct hblk *)((word)addr & ~(GC_page_size - 1));
2502 end_block = (struct hblk *)((word)(addr + len - 1) & ~(GC_page_size - 1));
2503 end_block += GC_page_size/HBLKSIZE - 1;
2504 for (h = start_block; h <= end_block; h++) {
2505 register word index = PHT_HASH(h);
2506
2507 async_set_pht_entry_from_index(GC_dirty_pages, index);
2508 }
2509 UNPROTECT(start_block,
2510 ((ptr_t)end_block - (ptr_t)start_block) + HBLKSIZE);
2511 }
2512
2513 #if !defined(MSWIN32) && !defined(MSWINCE) && !defined(LINUX_THREADS) \
2514 && !defined(GC_USE_LD_WRAP)
2515 /* Replacement for UNIX system call. */
2516 /* Other calls that write to the heap */
2517 /* should be handled similarly. */
2518 # if defined(__STDC__) && !defined(SUNOS4)
2519 # include <unistd.h>
2520 # include <sys/uio.h>
2521 ssize_t read(int fd, void *buf, size_t nbyte)
2522 # else
2523 # ifndef LINT
2524 int read(fd, buf, nbyte)
2525 # else
2526 int GC_read(fd, buf, nbyte)
2527 # endif
2528 int fd;
2529 char *buf;
2530 int nbyte;
2531 # endif
2532 {
2533 int result;
2534
2535 GC_begin_syscall();
2536 GC_unprotect_range(buf, (word)nbyte);
2537 # if defined(IRIX5) || defined(LINUX_THREADS)
2538 /* Indirect system call may not always be easily available. */
2539 /* We could call _read, but that would interfere with the */
2540 /* libpthread interception of read. */
2541 /* On Linux, we have to be careful with the linuxthreads */
2542 /* read interception. */
2543 {
2544 struct iovec iov;
2545
2546 iov.iov_base = buf;
2547 iov.iov_len = nbyte;
2548 result = readv(fd, &iov, 1);
2549 }
2550 # else
2551 /* The two zero args at the end of this list are because one
2552 IA-64 syscall() implementation actually requires six args
2553 to be passed, even though they aren't always used. */
2554 result = syscall(SYS_read, fd, buf, nbyte, 0, 0);
2555 # endif
2556 GC_end_syscall();
2557 return(result);
2558 }
2559 #endif /* !MSWIN32 && !MSWINCE && !LINUX_THREADS */
2560
2561 #ifdef GC_USE_LD_WRAP
2562 /* We use the GNU ld call wrapping facility. */
2563 /* This requires that the linker be invoked with "--wrap read". */
2564 /* This can be done by passing -Wl,"--wrap read" to gcc. */
2565 /* I'm not sure that this actually wraps whatever version of read */
2566 /* is called by stdio. That code also mentions __read. */
2567 # include <unistd.h>
2568 ssize_t __wrap_read(int fd, void *buf, size_t nbyte)
2569 {
2570 int result;
2571
2572 GC_begin_syscall();
2573 GC_unprotect_range(buf, (word)nbyte);
2574 result = __real_read(fd, buf, nbyte);
2575 GC_end_syscall();
2576 return(result);
2577 }
2578
2579 /* We should probably also do this for __read, or whatever stdio */
2580 /* actually calls. */
2581 #endif
2582
2583 /*ARGSUSED*/
2584 GC_bool GC_page_was_ever_dirty(h)
2585 struct hblk *h;
2586 {
2587 return(TRUE);
2588 }
2589
2590 /* Reset the n pages starting at h to "was never dirty" status. */
2591 /*ARGSUSED*/
2592 void GC_is_fresh(h, n)
2593 struct hblk *h;
2594 word n;
2595 {
2596 }
2597
2598 # else /* !MPROTECT_VDB */
2599
2600 # ifdef GC_USE_LD_WRAP
2601 ssize_t __wrap_read(int fd, void *buf, size_t nbyte)
2602 { return __real_read(fd, buf, nbyte); }
2603 # endif
2604
2605 # endif /* MPROTECT_VDB */
2606
2607 # ifdef PROC_VDB
2608
2609 /*
2610 * See DEFAULT_VDB for interface descriptions.
2611 */
2612
2613 /*
2614 * This implementaion assumes a Solaris 2.X like /proc pseudo-file-system
2615 * from which we can read page modified bits. This facility is far from
2616 * optimal (e.g. we would like to get the info for only some of the
2617 * address space), but it avoids intercepting system calls.
2618 */
2619
2620 #include <errno.h>
2621 #include <sys/types.h>
2622 #include <sys/signal.h>
2623 #include <sys/fault.h>
2624 #include <sys/syscall.h>
2625 #include <sys/procfs.h>
2626 #include <sys/stat.h>
2627
2628 #define INITIAL_BUF_SZ 4096
2629 word GC_proc_buf_size = INITIAL_BUF_SZ;
2630 char *GC_proc_buf;
2631
2632 #ifdef SOLARIS_THREADS
2633 /* We don't have exact sp values for threads. So we count on */
2634 /* occasionally declaring stack pages to be fresh. Thus we */
2635 /* need a real implementation of GC_is_fresh. We can't clear */
2636 /* entries in GC_written_pages, since that would declare all */
2637 /* pages with the given hash address to be fresh. */
2638 # define MAX_FRESH_PAGES 8*1024 /* Must be power of 2 */
2639 struct hblk ** GC_fresh_pages; /* A direct mapped cache. */
2640 /* Collisions are dropped. */
2641
2642 # define FRESH_PAGE_SLOT(h) (divHBLKSZ((word)(h)) & (MAX_FRESH_PAGES-1))
2643 # define ADD_FRESH_PAGE(h) \
2644 GC_fresh_pages[FRESH_PAGE_SLOT(h)] = (h)
2645 # define PAGE_IS_FRESH(h) \
2646 (GC_fresh_pages[FRESH_PAGE_SLOT(h)] == (h) && (h) != 0)
2647 #endif
2648
2649 /* Add all pages in pht2 to pht1 */
2650 void GC_or_pages(pht1, pht2)
2651 page_hash_table pht1, pht2;
2652 {
2653 register int i;
2654
2655 for (i = 0; i < PHT_SIZE; i++) pht1[i] |= pht2[i];
2656 }
2657
2658 int GC_proc_fd;
2659
2660 void GC_dirty_init()
2661 {
2662 int fd;
2663 char buf[30];
2664
2665 GC_dirty_maintained = TRUE;
2666 if (GC_words_allocd != 0 || GC_words_allocd_before_gc != 0) {
2667 register int i;
2668
2669 for (i = 0; i < PHT_SIZE; i++) GC_written_pages[i] = (word)(-1);
2670 # ifdef PRINTSTATS
2671 GC_printf1("Allocated words:%lu:all pages may have been written\n",
2672 (unsigned long)
2673 (GC_words_allocd + GC_words_allocd_before_gc));
2674 # endif
2675 }
2676 sprintf(buf, "/proc/%d", getpid());
2677 fd = open(buf, O_RDONLY);
2678 if (fd < 0) {
2679 ABORT("/proc open failed");
2680 }
2681 GC_proc_fd = syscall(SYS_ioctl, fd, PIOCOPENPD, 0);
2682 close(fd);
2683 if (GC_proc_fd < 0) {
2684 ABORT("/proc ioctl failed");
2685 }
2686 GC_proc_buf = GC_scratch_alloc(GC_proc_buf_size);
2687 # ifdef SOLARIS_THREADS
2688 GC_fresh_pages = (struct hblk **)
2689 GC_scratch_alloc(MAX_FRESH_PAGES * sizeof (struct hblk *));
2690 if (GC_fresh_pages == 0) {
2691 GC_err_printf0("No space for fresh pages\n");
2692 EXIT();
2693 }
2694 BZERO(GC_fresh_pages, MAX_FRESH_PAGES * sizeof (struct hblk *));
2695 # endif
2696 }
2697
2698 /* Ignore write hints. They don't help us here. */
2699 /*ARGSUSED*/
2700 void GC_write_hint(h)
2701 struct hblk *h;
2702 {
2703 }
2704
2705 #ifdef SOLARIS_THREADS
2706 # define READ(fd,buf,nbytes) syscall(SYS_read, fd, buf, nbytes)
2707 #else
2708 # define READ(fd,buf,nbytes) read(fd, buf, nbytes)
2709 #endif
2710
2711 void GC_read_dirty()
2712 {
2713 unsigned long ps, np;
2714 int nmaps;
2715 ptr_t vaddr;
2716 struct prasmap * map;
2717 char * bufp;
2718 ptr_t current_addr, limit;
2719 int i;
2720 int dummy;
2721
2722 BZERO(GC_grungy_pages, (sizeof GC_grungy_pages));
2723
2724 bufp = GC_proc_buf;
2725 if (READ(GC_proc_fd, bufp, GC_proc_buf_size) <= 0) {
2726 # ifdef PRINTSTATS
2727 GC_printf1("/proc read failed: GC_proc_buf_size = %lu\n",
2728 GC_proc_buf_size);
2729 # endif
2730 {
2731 /* Retry with larger buffer. */
2732 word new_size = 2 * GC_proc_buf_size;
2733 char * new_buf = GC_scratch_alloc(new_size);
2734
2735 if (new_buf != 0) {
2736 GC_proc_buf = bufp = new_buf;
2737 GC_proc_buf_size = new_size;
2738 }
2739 if (syscall(SYS_read, GC_proc_fd, bufp, GC_proc_buf_size) <= 0) {
2740 WARN("Insufficient space for /proc read\n", 0);
2741 /* Punt: */
2742 memset(GC_grungy_pages, 0xff, sizeof (page_hash_table));
2743 memset(GC_written_pages, 0xff, sizeof(page_hash_table));
2744 # ifdef SOLARIS_THREADS
2745 BZERO(GC_fresh_pages,
2746 MAX_FRESH_PAGES * sizeof (struct hblk *));
2747 # endif
2748 return;
2749 }
2750 }
2751 }
2752 /* Copy dirty bits into GC_grungy_pages */
2753 nmaps = ((struct prpageheader *)bufp) -> pr_nmap;
2754 /* printf( "nmaps = %d, PG_REFERENCED = %d, PG_MODIFIED = %d\n",
2755 nmaps, PG_REFERENCED, PG_MODIFIED); */
2756 bufp = bufp + sizeof(struct prpageheader);
2757 for (i = 0; i < nmaps; i++) {
2758 map = (struct prasmap *)bufp;
2759 vaddr = (ptr_t)(map -> pr_vaddr);
2760 ps = map -> pr_pagesize;
2761 np = map -> pr_npage;
2762 /* printf("vaddr = 0x%X, ps = 0x%X, np = 0x%X\n", vaddr, ps, np); */
2763 limit = vaddr + ps * np;
2764 bufp += sizeof (struct prasmap);
2765 for (current_addr = vaddr;
2766 current_addr < limit; current_addr += ps){
2767 if ((*bufp++) & PG_MODIFIED) {
2768 register struct hblk * h = (struct hblk *) current_addr;
2769
2770 while ((ptr_t)h < current_addr + ps) {
2771 register word index = PHT_HASH(h);
2772
2773 set_pht_entry_from_index(GC_grungy_pages, index);
2774 # ifdef SOLARIS_THREADS
2775 {
2776 register int slot = FRESH_PAGE_SLOT(h);
2777
2778 if (GC_fresh_pages[slot] == h) {
2779 GC_fresh_pages[slot] = 0;
2780 }
2781 }
2782 # endif
2783 h++;
2784 }
2785 }
2786 }
2787 bufp += sizeof(long) - 1;
2788 bufp = (char *)((unsigned long)bufp & ~(sizeof(long)-1));
2789 }
2790 /* Update GC_written_pages. */
2791 GC_or_pages(GC_written_pages, GC_grungy_pages);
2792 # ifdef SOLARIS_THREADS
2793 /* Make sure that old stacks are considered completely clean */
2794 /* unless written again. */
2795 GC_old_stacks_are_fresh();
2796 # endif
2797 }
2798
2799 #undef READ
2800
2801 GC_bool GC_page_was_dirty(h)
2802 struct hblk *h;
2803 {
2804 register word index = PHT_HASH(h);
2805 register GC_bool result;
2806
2807 result = get_pht_entry_from_index(GC_grungy_pages, index);
2808 # ifdef SOLARIS_THREADS
2809 if (result && PAGE_IS_FRESH(h)) result = FALSE;
2810 /* This happens only if page was declared fresh since */
2811 /* the read_dirty call, e.g. because it's in an unused */
2812 /* thread stack. It's OK to treat it as clean, in */
2813 /* that case. And it's consistent with */
2814 /* GC_page_was_ever_dirty. */
2815 # endif
2816 return(result);
2817 }
2818
2819 GC_bool GC_page_was_ever_dirty(h)
2820 struct hblk *h;
2821 {
2822 register word index = PHT_HASH(h);
2823 register GC_bool result;
2824
2825 result = get_pht_entry_from_index(GC_written_pages, index);
2826 # ifdef SOLARIS_THREADS
2827 if (result && PAGE_IS_FRESH(h)) result = FALSE;
2828 # endif
2829 return(result);
2830 }
2831
2832 /* Caller holds allocation lock. */
2833 void GC_is_fresh(h, n)
2834 struct hblk *h;
2835 word n;
2836 {
2837
2838 register word index;
2839
2840 # ifdef SOLARIS_THREADS
2841 register word i;
2842
2843 if (GC_fresh_pages != 0) {
2844 for (i = 0; i < n; i++) {
2845 ADD_FRESH_PAGE(h + i);
2846 }
2847 }
2848 # endif
2849 }
2850
2851 # endif /* PROC_VDB */
2852
2853
2854 # ifdef PCR_VDB
2855
2856 # include "vd/PCR_VD.h"
2857
2858 # define NPAGES (32*1024) /* 128 MB */
2859
2860 PCR_VD_DB GC_grungy_bits[NPAGES];
2861
2862 ptr_t GC_vd_base; /* Address corresponding to GC_grungy_bits[0] */
2863 /* HBLKSIZE aligned. */
2864
2865 void GC_dirty_init()
2866 {
2867 GC_dirty_maintained = TRUE;
2868 /* For the time being, we assume the heap generally grows up */
2869 GC_vd_base = GC_heap_sects[0].hs_start;
2870 if (GC_vd_base == 0) {
2871 ABORT("Bad initial heap segment");
2872 }
2873 if (PCR_VD_Start(HBLKSIZE, GC_vd_base, NPAGES*HBLKSIZE)
2874 != PCR_ERes_okay) {
2875 ABORT("dirty bit initialization failed");
2876 }
2877 }
2878
2879 void GC_read_dirty()
2880 {
2881 /* lazily enable dirty bits on newly added heap sects */
2882 {
2883 static int onhs = 0;
2884 int nhs = GC_n_heap_sects;
2885 for( ; onhs < nhs; onhs++ ) {
2886 PCR_VD_WriteProtectEnable(
2887 GC_heap_sects[onhs].hs_start,
2888 GC_heap_sects[onhs].hs_bytes );
2889 }
2890 }
2891
2892
2893 if (PCR_VD_Clear(GC_vd_base, NPAGES*HBLKSIZE, GC_grungy_bits)
2894 != PCR_ERes_okay) {
2895 ABORT("dirty bit read failed");
2896 }
2897 }
2898
2899 GC_bool GC_page_was_dirty(h)
2900 struct hblk *h;
2901 {
2902 if((ptr_t)h < GC_vd_base || (ptr_t)h >= GC_vd_base + NPAGES*HBLKSIZE) {
2903 return(TRUE);
2904 }
2905 return(GC_grungy_bits[h - (struct hblk *)GC_vd_base] & PCR_VD_DB_dirtyBit);
2906 }
2907
2908 /*ARGSUSED*/
2909 void GC_write_hint(h)
2910 struct hblk *h;
2911 {
2912 PCR_VD_WriteProtectDisable(h, HBLKSIZE);
2913 PCR_VD_WriteProtectEnable(h, HBLKSIZE);
2914 }
2915
2916 # endif /* PCR_VDB */
2917
2918 /*
2919 * Call stack save code for debugging.
2920 * Should probably be in mach_dep.c, but that requires reorganization.
2921 */
2922
2923 /* I suspect the following works for most X86 *nix variants, so */
2924 /* long as the frame pointer is explicitly stored. In the case of gcc, */
2925 /* compiler flags (e.g. -fomit-frame-pointer) determine whether it is. */
2926 #if defined(I386) && defined(LINUX) && defined(SAVE_CALL_CHAIN)
2927 struct frame {
2928 struct frame *fr_savfp;
2929 long fr_savpc;
2930 long fr_arg[NARGS]; /* All the arguments go here. */
2931 };
2932 #endif
2933
2934 #if defined(SPARC)
2935 # if defined(LINUX)
2936 struct frame {
2937 long fr_local[8];
2938 long fr_arg[6];
2939 struct frame *fr_savfp;
2940 long fr_savpc;
2941 # ifndef __arch64__
2942 char *fr_stret;
2943 # endif
2944 long fr_argd[6];
2945 long fr_argx[0];
2946 };
2947 # else
2948 # if defined(SUNOS4)
2949 # include <machine/frame.h>
2950 # else
2951 # if defined (DRSNX)
2952 # include <sys/sparc/frame.h>
2953 # else
2954 # if defined(OPENBSD) || defined(NETBSD)
2955 # include <frame.h>
2956 # else
2957 # include <sys/frame.h>
2958 # endif
2959 # endif
2960 # endif
2961 # endif
2962 # if NARGS > 6
2963 --> We only know how to to get the first 6 arguments
2964 # endif
2965 #endif /* SPARC */
2966
2967 #ifdef SAVE_CALL_CHAIN
2968 /* Fill in the pc and argument information for up to NFRAMES of my */
2969 /* callers. Ignore my frame and my callers frame. */
2970
2971 #if (defined(OPENBSD) || defined(NETBSD)) && defined(SPARC)
2972 # define FR_SAVFP fr_fp
2973 # define FR_SAVPC fr_pc
2974 #else
2975 # define FR_SAVFP fr_savfp
2976 # define FR_SAVPC fr_savpc
2977 #endif
2978
2979 #if defined(SPARC) && (defined(__arch64__) || defined(__sparcv9))
2980 # define BIAS 2047
2981 #else
2982 # define BIAS 0
2983 #endif
2984
2985 void GC_save_callers (info)
2986 struct callinfo info[NFRAMES];
2987 {
2988 struct frame *frame;
2989 struct frame *fp;
2990 int nframes = 0;
2991 # ifdef I386
2992 /* We assume this is turned on only with gcc as the compiler. */
2993 asm("movl %%ebp,%0" : "=r"(frame));
2994 fp = frame;
2995 # else
2996 word GC_save_regs_in_stack();
2997
2998 frame = (struct frame *) GC_save_regs_in_stack ();
2999 fp = (struct frame *)((long) frame -> FR_SAVFP + BIAS);
3000 #endif
3001
3002 for (; (!(fp HOTTER_THAN frame) && !(GC_stackbottom HOTTER_THAN (ptr_t)fp)
3003 && (nframes < NFRAMES));
3004 fp = (struct frame *)((long) fp -> FR_SAVFP + BIAS), nframes++) {
3005 register int i;
3006
3007 info[nframes].ci_pc = fp->FR_SAVPC;
3008 for (i = 0; i < NARGS; i++) {
3009 info[nframes].ci_arg[i] = ~(fp->fr_arg[i]);
3010 }
3011 }
3012 if (nframes < NFRAMES) info[nframes].ci_pc = 0;
3013 }
3014
3015 #endif /* SAVE_CALL_CHAIN */
3016
3017 #if defined(LINUX) && defined(__ELF__) && \
3018 (!defined(SMALL_CONFIG) || defined(USE_PROC_FOR_LIBRARIES))
3019 #ifdef GC_USE_LD_WRAP
3020 # define READ __real_read
3021 #else
3022 # define READ read
3023 #endif
3024
3025
3026 /* Repeatedly perform a read call until the buffer is filled or */
3027 /* we encounter EOF. */
3028 ssize_t GC_repeat_read(int fd, char *buf, size_t count)
3029 {
3030 ssize_t num_read = 0;
3031 ssize_t result;
3032
3033 while (num_read < count) {
3034 result = READ(fd, buf + num_read, count - num_read);
3035 if (result < 0) return result;
3036 if (result == 0) break;
3037 num_read += result;
3038 }
3039 return num_read;
3040 }
3041 #endif /* LINUX && ... */
3042
3043
3044 #if defined(LINUX) && defined(__ELF__) && !defined(SMALL_CONFIG)
3045
3046 /* Dump /proc/self/maps to GC_stderr, to enable looking up names for
3047 addresses in FIND_LEAK output. */
3048
3049 void GC_print_address_map()
3050 {
3051 int f;
3052 int result;
3053 char maps_temp[32768];
3054 GC_err_printf0("---------- Begin address map ----------\n");
3055 f = open("/proc/self/maps", O_RDONLY);
3056 if (-1 == f) ABORT("Couldn't open /proc/self/maps");
3057 do {
3058 result = GC_repeat_read(f, maps_temp, sizeof(maps_temp));
3059 if (result <= 0) ABORT("Couldn't read /proc/self/maps");
3060 GC_err_write(maps_temp, result);
3061 } while (result == sizeof(maps_temp));
3062
3063 GC_err_printf0("---------- End address map ----------\n");
3064 }
3065
3066 #endif
3067
3068
Mirror of the offical gcc git repository hosted at gcc.gnu.org