2 * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
3 * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
4 * Copyright (c) 1996 by Silicon Graphics. All rights reserved.
6 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
7 * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
9 * Permission is hereby granted to use or copy this program
10 * for any purpose, provided the above notices are retained on all copies.
11 * Permission to modify the code and to distribute modified code is granted,
12 * provided the above notices are retained, and a notice that the code was
13 * modified is included with the above copyright notice.
20 /* Machine dependent parameters. Some tuning parameters can be found */
21 /* near the top of gc_private.h. */
23 /* Machine specific parts contributed by various people. See README file. */
25 /* First a unified test for Linux: */
26 # if defined(linux) || defined(__linux__)
30 /* Determine the machine type: */
31 # if defined(sun) && defined(mc68000)
34 # define mach_type_known
36 # if defined(hp9000s300)
39 # define mach_type_known
41 # if defined(__OpenBSD__) && defined(m68k)
44 # define mach_type_known
46 # if defined(__OpenBSD__) && defined(__sparc__)
49 # define mach_type_known
51 # if defined(__NetBSD__) && defined(m68k)
54 # define mach_type_known
56 # if defined(__NetBSD__) && defined(arm32)
59 # define mach_type_known
68 # define mach_type_known
70 # if defined(mips) || defined(__mips)
73 # if defined(ultrix) || defined(__ultrix) || defined(__NetBSD__)
76 # if defined(_SYSTYPE_SVR4) || defined(SYSTYPE_SVR4) \
77 || defined(__SYSTYPE_SVR4__)
78 # define IRIX5 /* or IRIX 6.X */
80 # define RISCOS /* or IRIX 4.X */
84 # define mach_type_known
86 # if defined(sequent) && defined(i386)
89 # define mach_type_known
91 # if defined(sun) && defined(i386)
94 # define mach_type_known
96 # if (defined(__OS2__) || defined(__EMX__)) && defined(__32BIT__)
99 # define mach_type_known
103 # define mach_type_known
105 # if defined(sun) && (defined(sparc) || defined(__sparc))
107 /* Test for SunOS 5.x */
114 # define mach_type_known
116 # if defined(sparc) && defined(unix) && !defined(sun) && !defined(linux) \
117 && !defined(__OpenBSD__)
120 # define mach_type_known
124 # define mach_type_known
126 # if defined(_M_XENIX) && defined(_M_SYSV) && defined(_M_I386)
127 /* The above test may need refinement */
129 # if defined(_SCO_ELF)
134 # define mach_type_known
136 # if defined(_AUX_SOURCE)
139 # define mach_type_known
141 # if defined(_PA_RISC1_0) || defined(_PA_RISC1_1) || defined(_PA_RISC2_0) \
142 || defined(hppa) || defined(__hppa__)
147 # define mach_type_known
149 # if defined(LINUX) && (defined(i386) || defined(__i386__))
151 # define mach_type_known
153 # if defined(LINUX) && (defined(__ia64__) || defined(__ia64))
155 # define mach_type_known
157 # if defined(LINUX) && defined(powerpc)
159 # define mach_type_known
161 # if defined(LINUX) && defined(__mc68000__)
163 # define mach_type_known
165 # if defined(LINUX) && (defined(sparc) || defined(__sparc__))
167 # define mach_type_known
169 # if defined(LINUX) && defined(arm)
171 # define mach_type_known
173 # if defined(__alpha) || defined(__alpha__)
176 # define OSF1 /* a.k.a Digital Unix */
178 # define mach_type_known
180 # if defined(_AMIGA) && !defined(AMIGA)
185 # define mach_type_known
187 # if defined(THINK_C) || defined(__MWERKS__) && !defined(__powerc)
190 # define mach_type_known
192 # if defined(__MWERKS__) && defined(__powerc)
195 # define mach_type_known
200 # define mach_type_known
202 # if defined(NeXT) && defined(mc68000)
205 # define mach_type_known
207 # if defined(NeXT) && defined(i386)
210 # define mach_type_known
212 # if defined(__OpenBSD__) && defined(i386)
215 # define mach_type_known
217 # if defined(__FreeBSD__) && defined(i386)
220 # define mach_type_known
222 # if defined(__NetBSD__) && defined(i386)
225 # define mach_type_known
227 # if defined(bsdi) && defined(i386)
230 # define mach_type_known
232 # if !defined(mach_type_known) && defined(__386BSD__)
235 # define mach_type_known
237 # if defined(_CX_UX) && defined(_M88K)
240 # define mach_type_known
245 # define mach_type_known
247 # if (defined(_MSDOS) || defined(_MSC_VER)) && (_M_IX86 >= 300) \
248 || defined(_WIN32) && !defined(__CYGWIN32__) && !defined(__CYGWIN__)
250 # define MSWIN32 /* or Win32s */
251 # define mach_type_known
253 # if defined(__DJGPP__)
256 # define DJGPP /* MSDOS running the DJGPP port of GCC */
258 # define mach_type_known
260 # if defined(__CYGWIN32__) || defined(__CYGWIN__)
263 # define mach_type_known
265 # if defined(__MINGW32__)
268 # define mach_type_known
270 # if defined(__BORLANDC__)
273 # define mach_type_known
275 # if defined(_UTS) && !defined(mach_type_known)
278 # define mach_type_known
282 # define mach_type_known
285 # if defined(__WATCOMC__) && defined(__386__)
287 # if !defined(OS2) && !defined(MSWIN32) && !defined(DOS4GW)
288 # if defined(__OS2__)
291 # if defined(__WINDOWS_386__) || defined(__NT__)
298 # define mach_type_known
301 /* Feel free to add more clauses here */
303 /* Or manually define the machine type here. A machine type is */
304 /* characterized by the architecture. Some */
305 /* machine types are further subdivided by OS. */
306 /* the macros ULTRIX, RISCOS, and BSD to distinguish. */
307 /* Note that SGI IRIX is treated identically to RISCOS. */
308 /* SYSV on an M68K actually means A/UX. */
309 /* The distinction in these cases is usually the stack starting address */
310 # ifndef mach_type_known
311 --> unknown machine type
313 /* Mapping is: M68K ==> Motorola 680X0 */
314 /* (SUNOS4,HP,NEXT, and SYSV (A/UX), */
315 /* MACOS and AMIGA variants) */
316 /* I386 ==> Intel 386 */
317 /* (SEQUENT, OS2, SCO, LINUX, NETBSD, */
318 /* FREEBSD, THREE86BSD, MSWIN32, */
319 /* BSDI,SUNOS5, NEXT, other variants) */
320 /* NS32K ==> Encore Multimax */
321 /* MIPS ==> R2000 or R3000 */
322 /* (RISCOS, ULTRIX variants) */
323 /* VAX ==> DEC VAX */
324 /* (BSD, ULTRIX variants) */
325 /* RS6000 ==> IBM RS/6000 AIX3.X */
326 /* RT ==> IBM PC/RT */
327 /* HP_PA ==> HP9000/700 & /800 */
329 /* SPARC ==> SPARC v7/v8/v9 */
330 /* (SUNOS4, SUNOS5, LINUX, */
331 /* DRSNX variants) */
332 /* ALPHA ==> DEC Alpha */
333 /* (OSF1 and LINUX variants) */
334 /* M88K ==> Motorola 88XX0 */
335 /* (CX_UX and DGUX) */
336 /* S370 ==> 370-like machine */
337 /* running Amdahl UTS4 */
338 /* ARM32 ==> Intel StrongARM */
339 /* IA64 ==> Intel IA64 */
344 * For each architecture and OS, the following need to be defined:
346 * CPP_WORD_SZ is a simple integer constant representing the word size.
347 * in bits. We assume byte addressibility, where a byte has 8 bits.
348 * We also assume CPP_WORD_SZ is either 32 or 64.
349 * (We care about the length of pointers, not hardware
350 * bus widths. Thus a 64 bit processor with a C compiler that uses
351 * 32 bit pointers should use CPP_WORD_SZ of 32, not 64. Default is 32.)
353 * MACH_TYPE is a string representation of the machine type.
354 * OS_TYPE is analogous for the OS.
356 * ALIGNMENT is the largest N, such that
357 * all pointer are guaranteed to be aligned on N byte boundaries.
358 * defining it to be 1 will always work, but perform poorly.
360 * DATASTART is the beginning of the data segment.
361 * On UNIX systems, the collector will scan the area between DATASTART
362 * and DATAEND for root pointers.
364 * DATAEND, if not &end.
366 * ALIGN_DOUBLE of GC_malloc should return blocks aligned to twice
369 * STACKBOTTOM is the cool end of the stack, which is usually the
370 * highest address in the stack.
371 * Under PCR or OS/2, we have other ways of finding thread stacks.
372 * For each machine, the following should:
373 * 1) define STACK_GROWS_UP if the stack grows toward higher addresses, and
374 * 2) define exactly one of
375 * STACKBOTTOM (should be defined to be an expression)
378 * If either of the last two macros are defined, then STACKBOTTOM is computed
379 * during collector startup using one of the following two heuristics:
380 * HEURISTIC1: Take an address inside GC_init's frame, and round it up to
381 * the next multiple of STACK_GRAN.
382 * HEURISTIC2: Take an address inside GC_init's frame, increment it repeatedly
383 * in small steps (decrement if STACK_GROWS_UP), and read the value
384 * at each location. Remember the value when the first
385 * Segmentation violation or Bus error is signalled. Round that
386 * to the nearest plausible page boundary, and use that instead
389 * If no expression for STACKBOTTOM can be found, and neither of the above
390 * heuristics are usable, the collector can still be used with all of the above
391 * undefined, provided one of the following is done:
392 * 1) GC_mark_roots can be changed to somehow mark from the correct stack(s)
393 * without reference to STACKBOTTOM. This is appropriate for use in
394 * conjunction with thread packages, since there will be multiple stacks.
395 * (Allocating thread stacks in the heap, and treating them as ordinary
396 * heap data objects is also possible as a last resort. However, this is
397 * likely to introduce significant amounts of excess storage retention
398 * unless the dead parts of the thread stacks are periodically cleared.)
399 * 2) Client code may set GC_stackbottom before calling any GC_ routines.
400 * If the author of the client code controls the main program, this is
401 * easily accomplished by introducing a new main program, setting
402 * GC_stackbottom to the address of a local variable, and then calling
403 * the original main program. The new main program would read something
406 * # include "gc_private.h"
408 * main(argc, argv, envp)
410 * char **argv, **envp;
414 * GC_stackbottom = (ptr_t)(&dummy);
415 * return(real_main(argc, argv, envp));
419 * Each architecture may also define the style of virtual dirty bit
420 * implementation to be used:
421 * MPROTECT_VDB: Write protect the heap and catch faults.
422 * PROC_VDB: Use the SVR4 /proc primitives to read dirty bits.
424 * An architecture may define DYNAMIC_LOADING if dynamic_load.c
425 * defined GC_register_dynamic_libraries() for the architecture.
427 * An architecture may define PREFETCH(x) to preload the cache with *x.
428 * This defaults to a no-op.
430 * PREFETCH_FOR_WRITE(x) is used if *x is about to be written.
432 * An architecture may also define CLEAR_DOUBLE(x) to be a fast way to
433 * clear the two words at GC_malloc-aligned address x. By default,
434 * word stores of 0 are used instead.
438 # define STACK_GRAN 0x1000000
440 # define MACH_TYPE "M68K"
443 # define OS_TYPE "OPENBSD"
446 # define DATASTART ((ptr_t)(&etext))
449 # define OS_TYPE "NETBSD"
452 # define DATASTART ((ptr_t)(&etext))
455 # define OS_TYPE "LINUX"
456 # define STACKBOTTOM ((ptr_t)0xf0000000)
457 # define MPROTECT_VDB
459 # define DYNAMIC_LOADING
460 extern char **__environ;
461 # define DATASTART ((ptr_t)(&__environ))
462 /* hideous kludge: __environ is the first */
463 /* word in crt0.o, and delimits the start */
464 /* of the data segment, no matter which */
465 /* ld options were passed through. */
466 /* We could use _etext instead, but that */
467 /* would include .rodata, which may */
468 /* contain large read-only data tables */
469 /* that we'd rather not scan. */
471 # define DATAEND (&_end)
474 # define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
478 # define OS_TYPE "SUNOS4"
480 # define DATASTART ((ptr_t)((((word) (&etext)) + 0x1ffff) & ~0x1ffff))
481 # define HEURISTIC1 /* differs */
482 # define DYNAMIC_LOADING
485 # define OS_TYPE "HP"
487 # define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
488 # define STACKBOTTOM ((ptr_t) 0xffeffffc)
489 /* empirically determined. seems to work. */
491 # define GETPAGESIZE() sysconf(_SC_PAGE_SIZE)
494 # define OS_TYPE "SYSV"
496 # define DATASTART ((ptr_t)((((word) (&etext)) + 0x3fffff) \
498 +((word)&etext & 0x1fff))
499 /* This only works for shared-text binaries with magic number 0413.
500 The other sorts of SysV binaries put the data at the end of the text,
501 in which case the default of &etext would work. Unfortunately,
502 handling both would require having the magic-number available.
505 # define STACKBOTTOM ((ptr_t)0xFFFFFFFE)
506 /* The stack starts at the top of memory, but */
507 /* 0x0 cannot be used as setjump_test complains */
508 /* that the stack direction is incorrect. Two */
509 /* bytes down from 0x0 should be safe enough. */
511 # include <sys/mmu.h>
512 # define GETPAGESIZE() PAGESIZE /* Is this still right? */
515 # define OS_TYPE "AMIGA"
516 /* STACKBOTTOM and DATASTART handled specially */
518 # define DATAEND /* not needed */
519 # define GETPAGESIZE() 4096
525 # define OS_TYPE "MACOS"
526 /* see os_dep.c for details of global data segments. */
527 # define STACKBOTTOM ((ptr_t) LMGetCurStackBase())
528 # define DATAEND /* not needed */
529 # define GETPAGESIZE() 4096
532 # define OS_TYPE "NEXT"
533 # define DATASTART ((ptr_t) get_etext())
534 # define STACKBOTTOM ((ptr_t) 0x4000000)
535 # define DATAEND /* not needed */
540 # define MACH_TYPE "POWERPC"
542 # define ALIGNMENT 2 /* Still necessary? Could it be 4? */
546 # define OS_TYPE "MACOS"
547 /* see os_dep.c for details of global data segments. */
548 # define STACKBOTTOM ((ptr_t) LMGetCurStackBase())
549 # define DATAEND /* not needed */
552 # define ALIGNMENT 4 /* Guess. Can someone verify? */
553 /* This was 2, but that didn't sound right. */
554 # define OS_TYPE "LINUX"
556 # define DYNAMIC_LOADING
558 # define STACK_GRAN 0x10000000
559 /* Stack usually starts at 0x80000000 */
560 # define LINUX_DATA_START
562 # define DATAEND (&_end)
566 # define OS_TYPE "MACOSX"
567 # define DATASTART ((ptr_t) get_etext())
568 # define STACKBOTTOM ((ptr_t) 0xc0000000)
569 # define DATAEND /* not needed */
574 # define MACH_TYPE "VAX"
575 # define ALIGNMENT 4 /* Pointers are longword aligned by 4.2 C compiler */
577 # define DATASTART ((ptr_t)(&etext))
579 # define OS_TYPE "BSD"
581 /* HEURISTIC2 may be OK, but it's hard to test. */
584 # define OS_TYPE "ULTRIX"
585 # define STACKBOTTOM ((ptr_t) 0x7fffc800)
590 # define MACH_TYPE "RT"
592 # define DATASTART ((ptr_t) 0x10000000)
593 # define STACKBOTTOM ((ptr_t) 0x1fffd800)
597 # define MACH_TYPE "SPARC"
598 # if defined(__arch64__) || defined(__sparcv9)
601 # define ALIGNMENT 4 /* Required by hardware */
603 # define ALIGN_DOUBLE
606 # define OS_TYPE "SUNOS5"
609 extern char * GC_SysVGetDataStart();
610 # define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &_etext)
611 # define DATAEND (&_end)
616 # define HEAP_START (ptr_t)0x40000000
618 # define HEAP_START DATAEND
621 /* HEURISTIC1 reportedly no longer works under 2.7. Thus we */
622 /* switched to HEURISTIC2, eventhough it creates some debugging */
626 # define GETPAGESIZE() sysconf(_SC_PAGESIZE)
627 /* getpagesize() appeared to be missing from at least one */
628 /* Solaris 5.4 installation. Weird. */
629 # define DYNAMIC_LOADING
632 # define OS_TYPE "SUNOS4"
633 /* [If you have a weak stomach, don't read this.] */
634 /* We would like to use: */
635 /* # define DATASTART ((ptr_t)((((word) (&etext)) + 0x1fff) & ~0x1fff)) */
636 /* This fails occasionally, due to an ancient, but very */
637 /* persistent ld bug. &etext is set 32 bytes too high. */
638 /* We instead read the text segment size from the a.out */
639 /* header, which happens to be mapped into our address space */
640 /* at the start of the text segment. The detective work here */
641 /* was done by Robert Ehrlich, Manuel Serrano, and Bernard */
642 /* Serpette of INRIA. */
643 /* This assumes ZMAGIC, i.e. demand-loadable executables. */
644 # define TEXTSTART 0x2000
645 # define DATASTART ((ptr_t)(*(int *)(TEXTSTART+0x4)+TEXTSTART))
646 # define MPROTECT_VDB
648 # define DYNAMIC_LOADING
651 # define CPP_WORDSZ 32
652 # define OS_TYPE "DRSNX"
653 extern char * GC_SysVGetDataStart();
655 # define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &etext)
656 # define MPROTECT_VDB
657 # define STACKBOTTOM ((ptr_t) 0xdfff0000)
658 # define DYNAMIC_LOADING
661 # define OS_TYPE "LINUX"
663 # define DYNAMIC_LOADING
665 Linux Sparc/a.out not supported
669 # define DATAEND (&_end)
672 # define STACKBOTTOM ((ptr_t) 0x80000000000ULL)
673 # define DATASTART (ptr_t)GC_SysVGetDataStart(0x100000, &_etext)
674 # define CPP_WORDSZ 64
676 # define STACKBOTTOM ((ptr_t) 0xf0000000)
677 # define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &_etext)
681 # define OS_TYPE "OPENBSD"
682 # define STACKBOTTOM ((ptr_t) 0xf8000000)
683 # define DATASTART ((ptr_t)(&etext))
688 # define MACH_TYPE "I386"
689 # define ALIGNMENT 4 /* Appears to hold for all "32 bit" compilers */
690 /* except Borland. The -a4 option fixes */
692 /* Ivan Demakov: For Watcom the option is -zp4. */
693 # ifndef SMALL_CONFIG
694 # define ALIGN_DOUBLE /* Not strictly necessary, but may give speed */
695 /* improvement on Pentiums. */
698 # define OS_TYPE "SEQUENT"
700 # define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
701 # define STACKBOTTOM ((ptr_t) 0x3ffff000)
704 # define OS_TYPE "SUNOS5"
705 extern int etext, _start;
706 extern char * GC_SysVGetDataStart();
707 # define DATASTART GC_SysVGetDataStart(0x1000, &etext)
708 # define STACKBOTTOM ((ptr_t)(&_start))
709 /** At least in Solaris 2.5, PROC_VDB gives wrong values for dirty bits. */
710 /*# define PROC_VDB*/
711 # define DYNAMIC_LOADING
716 # define HEAP_START (ptr_t)0x40000000
718 # define HEAP_START DATAEND
722 # define OS_TYPE "SCO"
724 # define DATASTART ((ptr_t)((((word) (&etext)) + 0x3fffff) \
726 +((word)&etext & 0xfff))
727 # define STACKBOTTOM ((ptr_t) 0x7ffffffc)
730 # define OS_TYPE "SCO_ELF"
732 # define DATASTART ((ptr_t)(&etext))
733 # define STACKBOTTOM ((ptr_t) 0x08048000)
734 # define DYNAMIC_LOADING
735 # define ELF_CLASS ELFCLASS32
738 # define OS_TYPE "LINUX"
739 # define LINUX_STACKBOTTOM
743 # define STACK_GRAN 0x10000000
744 /* STACKBOTTOM is usually 0xc0000000, but this changes with */
745 /* different kernel configurations. In particular, systems */
746 /* with 2GB physical memory will usually move the user */
747 /* address space limit, and hence initial SP to 0x80000000. */
749 # if !defined(LINUX_THREADS) || !defined(REDIRECT_MALLOC)
750 /* libgcj: Linux threads don't interact well with the read() wrapper.
751 Not defining MPROTECT_VDB fixes this. */
752 /* # define MPROTECT_VDB */
754 /* We seem to get random errors in incremental mode, */
755 /* possibly because Linux threads is itself a malloc client */
756 /* and can't deal with the signals. */
759 # define DYNAMIC_LOADING
760 # ifdef UNDEFINED /* includes ro data */
762 # define DATASTART ((ptr_t)((((word) (&_etext)) + 0xfff) & ~0xfff))
764 # include <features.h>
765 # if defined(__GLIBC__) && __GLIBC__ >= 2
766 # define LINUX_DATA_START
768 extern char **__environ;
769 # define DATASTART ((ptr_t)(&__environ))
770 /* hideous kludge: __environ is the first */
771 /* word in crt0.o, and delimits the start */
772 /* of the data segment, no matter which */
773 /* ld options were passed through. */
774 /* We could use _etext instead, but that */
775 /* would include .rodata, which may */
776 /* contain large read-only data tables */
777 /* that we'd rather not scan. */
780 # define DATAEND (&_end)
783 # define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
785 # ifdef USE_I686_PREFETCH
786 # define PREFETCH(x) \
787 __asm__ __volatile__ (" prefetchnta %0": : "m"(*(char *)(x)))
788 /* Empirically prefetcht0 is much more effective at reducing */
789 /* cache miss stalls for the targetted load instructions. But it */
790 /* seems to interfere enough with other cache traffic that the net */
791 /* result is worse than prefetchnta. */
793 /* Using prefetches for write seems to have a slight negative */
794 /* impact on performance, at least for a PIII/500. */
795 # define PREFETCH_FOR_WRITE(x) \
796 __asm__ __volatile__ (" prefetcht0 %0": : "m"(*(char *)(x)))
799 # ifdef USE_3DNOW_PREFETCH
800 # define PREFETCH(x) \
801 __asm__ __volatile__ (" prefetch %0": : "m"(*(char *)(x)))
802 # define PREFETCH_FOR_WRITE(x)
803 __asm__ __volatile__ (" prefetchw %0": : "m"(*(char *)(x)))
807 # define OS_TYPE "CYGWIN32"
808 extern int _data_start__;
809 extern int _data_end__;
810 extern int _bss_start__;
811 extern int _bss_end__;
812 /* For binutils 2.9.1, we have */
813 /* DATASTART = _data_start__ */
814 /* DATAEND = _bss_end__ */
815 /* whereas for some earlier versions it was */
816 /* DATASTART = _bss_start__ */
817 /* DATAEND = _data_end__ */
818 /* To get it right for both, we take the */
819 /* minumum/maximum of the two. */
820 # define MAX(x,y) ((x) > (y) ? (x) : (y))
821 # define MIN(x,y) ((x) < (y) ? (x) : (y))
822 # define DATASTART ((ptr_t) MIN(&_data_start__, &_bss_start__))
823 # define DATAEND ((ptr_t) MAX(&_data_end__, &_bss_end__))
825 # define STACK_GRAN 0x10000
829 # define OS_TYPE "OS2"
830 /* STACKBOTTOM and DATASTART are handled specially in */
831 /* os_dep.c. OS2 actually has the right */
833 # define DATAEND /* not needed */
836 # define OS_TYPE "MSWIN32"
837 /* STACKBOTTOM and DATASTART are handled specially in */
840 # define MPROTECT_VDB
842 # define DATAEND /* not needed */
845 # define OS_TYPE "DJGPP"
846 # include "stubinfo.h"
849 extern int __djgpp_stack_limit;
850 # define DATASTART ((ptr_t)((((word) (&etext)) + 0x1ff) & ~0x1ff))
851 /* # define STACKBOTTOM ((ptr_t)((word) _stubinfo + _stubinfo->size \
853 # define STACKBOTTOM ((ptr_t)((word) __djgpp_stack_limit + _stklen))
854 /* This may not be right. */
857 # define OS_TYPE "OPENBSD"
860 # define OS_TYPE "FREEBSD"
861 # define MPROTECT_VDB
864 # define OS_TYPE "NETBSD"
867 # define OS_TYPE "THREE86BSD"
870 # define OS_TYPE "BSDI"
872 # if defined(OPENBSD) || defined(FREEBSD) || defined(NETBSD) \
873 || defined(THREE86BSD) || defined(BSDI)
876 # define DATASTART ((ptr_t)(&etext))
879 # define OS_TYPE "NEXT"
880 # define DATASTART ((ptr_t) get_etext())
881 # define STACKBOTTOM ((ptr_t)0xc0000000)
882 # define DATAEND /* not needed */
885 # define OS_TYPE "DOS4GW"
886 extern long __nullarea;
888 extern char *_STACKTOP;
889 /* Depending on calling conventions Watcom C either precedes
890 or does not precedes with undescore names of C-variables.
891 Make sure startup code variables always have the same names. */
892 #pragma aux __nullarea "*";
893 #pragma aux _end "*";
894 # define STACKBOTTOM ((ptr_t) _STACKTOP)
895 /* confused? me too. */
896 # define DATASTART ((ptr_t) &__nullarea)
897 # define DATAEND ((ptr_t) &_end)
902 # define MACH_TYPE "NS32K"
904 extern char **environ;
905 # define DATASTART ((ptr_t)(&environ))
906 /* hideous kludge: environ is the first */
907 /* word in crt0.o, and delimits the start */
908 /* of the data segment, no matter which */
909 /* ld options were passed through. */
910 # define STACKBOTTOM ((ptr_t) 0xfffff000) /* for Encore */
915 # define MACH_TYPE "MIPS"
916 /* LIBGCJ LOCAL: respect predefined DATASTART_IS_ETEXT. */
917 # ifdef DATASTART_IS_ETEXT
919 # define DATASTART ((ptr_t)(&_etext))
921 /* # define STACKBOTTOM ((ptr_t)0x7fff8000) sometimes also works. */
923 /* This was developed for a linuxce style platform. Probably */
924 /* needs to be tweaked for workstation class machines. */
925 # define OS_TYPE "LINUX"
926 extern int __data_start;
927 # define DATASTART ((ptr_t)(&__data_start))
929 # define USE_GENERIC_PUSH_REGS 1
930 # define STACKBOTTOM 0x80000000
931 /* In many cases, this should probably use LINUX_STACKBOTTOM */
932 /* instead. But some kernel versions seem to give the wrong */
933 /* value from /proc. */
937 # define DATASTART (ptr_t)0x10000000
938 /* Could probably be slightly higher since */
939 /* startup code allocates lots of stuff. */
940 # define OS_TYPE "ULTRIX"
945 # define DATASTART (ptr_t)0x10000000
946 # define OS_TYPE "RISCOS"
947 # define ALIGNMENT 4 /* Required by hardware */
952 # define DATASTART ((ptr_t)(&_fdata))
954 # define HEAP_START (ptr_t)0x30000000
956 # define HEAP_START DATASTART
958 /* Lowest plausible heap address. */
959 /* In the MMAP case, we map there. */
960 /* In either case it is used to identify */
961 /* heap sections so they're not */
962 /* considered as roots. */
963 # define OS_TYPE "IRIX5"
964 # define MPROTECT_VDB
966 # define CPP_WORDSZ _MIPS_SZPTR
967 # define ALIGNMENT (_MIPS_SZPTR/8)
968 # if CPP_WORDSZ != 64
969 # define ALIGN_DOUBLE
973 # define ALIGN_DOUBLE
975 # define DYNAMIC_LOADING
977 # endif /* DATASTART_IS_ETEXT */
980 extern char __ram_data_start;
981 extern char __ram_data_end;
982 # define MACH_TYPE "MIPS"
983 # define DATASTART (ptr_t)(&__ram_data_start)
984 # define DATAEND (ptr_t)(&__ram_data_end)
988 # define ALIGN_DOUBLE
993 # define MACH_TYPE "RS6000"
995 # define DATASTART ((ptr_t)0x20000000)
997 # define STACKBOTTOM ((ptr_t)((ulong)&errno))
998 # define DYNAMIC_LOADING
999 /* For really old versions of AIX, this may have to be removed. */
1003 /* OS is assumed to be HP/UX */
1004 # define MACH_TYPE "HP_PA"
1005 # define OS_TYPE "HPUX"
1007 # define CPP_WORDSZ 64
1008 # define ALIGNMENT 8
1010 # define CPP_WORDSZ 32
1011 # define ALIGNMENT 4
1012 # define ALIGN_DOUBLE
1014 extern int __data_start;
1015 # define DATASTART ((ptr_t)(&__data_start))
1017 /* The following appears to work for 7xx systems running HP/UX */
1018 /* 9.xx Furthermore, it might result in much faster */
1019 /* collections than HEURISTIC2, which may involve scanning */
1020 /* segments that directly precede the stack. It is not the */
1021 /* default, since it may not work on older machine/OS */
1022 /* combinations. (Thanks to Raymond X.T. Nijssen for uncovering */
1024 # define STACKBOTTOM ((ptr_t) 0x7b033000) /* from /etc/conf/h/param.h */
1028 # define STACK_GROWS_UP
1029 # define DYNAMIC_LOADING
1030 # ifndef HPUX_THREADS
1031 # define MPROTECT_VDB
1033 # include <unistd.h>
1034 # define GETPAGESIZE() sysconf(_SC_PAGE_SIZE)
1038 # define MACH_TYPE "ALPHA"
1039 # define ALIGNMENT 8
1040 # define USE_GENERIC_PUSH_REGS
1041 /* Gcc and probably the DEC/Compaq compiler spill pointers to preserved */
1042 /* fp registers in some cases when the target is a 21264. The assembly */
1043 /* code doesn't handle that yet, and version dependencies make that a */
1044 /* bit tricky. Do the easy thing for now. */
1046 # define OS_TYPE "OSF1"
1047 # define DATASTART ((ptr_t) 0x140000000)
1049 # define DATAEND ((ptr_t) &_end)
1051 /* Normally HEURISTIC2 is too conervative, since */
1052 /* the text segment immediately follows the stack. */
1053 /* Hence we give an upper pound. */
1055 # define HEURISTIC2_LIMIT ((ptr_t)((word)(&__start) & ~(getpagesize()-1)))
1056 # define CPP_WORDSZ 64
1057 # define MPROTECT_VDB
1058 # define DYNAMIC_LOADING
1061 # define OS_TYPE "LINUX"
1062 # define CPP_WORDSZ 64
1063 # define STACKBOTTOM ((ptr_t) 0x120000000)
1065 # define LINUX_DATA_START
1066 # define DYNAMIC_LOADING
1067 /* This doesn't work if the collector is in a dynamic library. */
1069 # define DATASTART ((ptr_t) 0x140000000)
1072 # define DATAEND (&_end)
1073 # undef MPROTECT_VDB
1074 /* Has only been superficially tested. May not */
1075 /* work on all versions. */
1080 # define MACH_TYPE "IA64"
1081 # define ALIGN_DOUBLE
1082 /* Requires 16 byte alignment for malloc */
1083 # define ALIGNMENT 8
1084 # define USE_GENERIC_PUSH_REGS
1085 /* We need to get preserved registers in addition to register windows. */
1086 /* That's easiest to do with setjmp. */
1091 # define OS_TYPE "LINUX"
1092 # define CPP_WORDSZ 64
1093 /* This should really be done through /proc, but that */
1094 /* requires we run on an IA64 kernel. */
1095 # define STACKBOTTOM ((ptr_t) 0xa000000000000000l)
1096 /* We also need the base address of the register stack */
1097 /* backing store. There is probably a better way to */
1098 /* get that, too ... */
1099 # define BACKING_STORE_BASE ((ptr_t) 0x9fffffff80000000l)
1101 # define SEARCH_FOR_DATA_START
1102 # define DATASTART GC_data_start
1104 extern int data_start;
1105 # define DATASTART ((ptr_t)(&data_start))
1107 # define DYNAMIC_LOADING
1108 # define MPROTECT_VDB
1109 /* Requires Linux 2.3.47 or later. */
1111 # define DATAEND (&_end)
1112 /* PREFETCH appears to have a large performance impact. */
1113 # define PREFETCH(x) \
1114 __asm__ (" lfetch [%0]": : "r"((void *)(x)))
1115 # define PREFETCH_FOR_WRITE(x) \
1116 __asm__ (" lfetch.excl [%0]": : "r"((void *)(x)))
1117 # define CLEAR_DOUBLE(x) \
1118 __asm__ (" stf.spill [%0]=f0": : "r"((void *)(x)))
1123 # define MACH_TYPE "M88K"
1124 # define ALIGNMENT 4
1125 # define ALIGN_DOUBLE
1128 # define OS_TYPE "CX_UX"
1129 # define DATASTART ((((word)&etext + 0x3fffff) & ~0x3fffff) + 0x10000)
1132 # define OS_TYPE "DGUX"
1133 extern char * GC_SysVGetDataStart();
1134 # define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &etext)
1136 # define STACKBOTTOM ((char*)0xf0000000) /* determined empirically */
1140 # define MACH_TYPE "S370"
1141 # define OS_TYPE "UTS4"
1142 # define ALIGNMENT 4 /* Required by hardware */
1146 extern char * GC_SysVGetDataStart();
1147 # define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &_etext)
1148 # define DATAEND (&_end)
1153 # define ALIGNMENT 4
1155 # define DATASTART ((ptr_t)(&_etext))
1160 # define CPP_WORDSZ 32
1161 # define MACH_TYPE "ARM32"
1162 # define ALIGNMENT 4
1164 # define OS_TYPE "NETBSD"
1167 # define DATASTART ((ptr_t)(&etext))
1168 # define USE_GENERIC_PUSH_REGS
1171 # define OS_TYPE "LINUX"
1174 # define STACK_GRAN 0x10000000
1175 # define USE_GENERIC_PUSH_REGS
1177 # define DYNAMIC_LOADING
1178 # include <features.h>
1179 # if defined(__GLIBC__) && __GLIBC__ >= 2
1180 # define LINUX_DATA_START
1182 extern char **__environ;
1183 # define DATASTART ((ptr_t)(&__environ))
1184 /* hideous kludge: __environ is the first */
1185 /* word in crt0.o, and delimits the start */
1186 /* of the data segment, no matter which */
1187 /* ld options were passed through. */
1188 /* We could use _etext instead, but that */
1189 /* would include .rodata, which may */
1190 /* contain large read-only data tables */
1191 /* that we'd rather not scan. */
1194 # define DATAEND (&_end)
1197 # define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
1202 #ifdef LINUX_DATA_START
1203 /* Some Linux distributions arrange to define __data_start. Some */
1204 /* define data_start as a weak symbol. The latter is technically */
1205 /* broken, since the user program may define data_start, in which */
1206 /* case we lose. Nonetheless, we try both, prefering __data_start. */
1207 /* We assume gcc. */
1208 # pragma weak __data_start
1209 extern int __data_start;
1210 # pragma weak data_start
1211 extern int data_start;
1212 # define DATASTART ((ptr_t)(&__data_start != 0? &__data_start : &data_start))
1215 # ifndef STACK_GROWS_UP
1216 # define STACK_GROWS_DOWN
1220 # define CPP_WORDSZ 32
1229 # define DATAEND (&end)
1232 # if defined(SVR4) && !defined(GETPAGESIZE)
1233 # include <unistd.h>
1234 # define GETPAGESIZE() sysconf(_SC_PAGESIZE)
1237 # ifndef GETPAGESIZE
1238 # if defined(SUNOS5) || defined(IRIX5)
1239 # include <unistd.h>
1241 # define GETPAGESIZE() getpagesize()
1244 # if defined(SUNOS5) || defined(DRSNX) || defined(UTS4)
1245 /* OS has SVR4 generic features. Probably others also qualify. */
1249 # if defined(SUNOS5) || defined(DRSNX)
1250 /* OS has SUNOS5 style semi-undocumented interface to dynamic */
1253 /* OS has SUNOS5 style signal handlers. */
1261 # if CPP_WORDSZ != 32 && CPP_WORDSZ != 64
1266 # undef DYNAMIC_LOADING
1271 # undef MPROTECT_VDB
1276 /* Postponed for now. */
1278 # undef MPROTECT_VDB
1281 # ifdef SMALL_CONFIG
1282 /* Presumably not worth the space it takes. */
1284 # undef MPROTECT_VDB
1288 # undef MPROTECT_VDB /* Can't deal with address space holes. */
1291 # if !defined(PCR_VDB) && !defined(PROC_VDB) && !defined(MPROTECT_VDB)
1292 # define DEFAULT_VDB
1296 # define PREFETCH(x)
1297 # define NO_PREFETCH
1300 # ifndef PREFETCH_FOR_WRITE
1301 # define PREFETCH_FOR_WRITE(x)
1302 # define NO_PREFETCH_FOR_WRITE
1305 # ifndef CACHE_LINE_SIZE
1306 # define CACHE_LINE_SIZE 32 /* Wild guess */
1309 # ifndef CLEAR_DOUBLE
1310 # define CLEAR_DOUBLE(x) \
1311 ((word*)x)[0] = 0; \
1313 # endif /* CLEAR_DOUBLE */
1315 # if defined(_SOLARIS_PTHREADS) && !defined(SOLARIS_THREADS)
1316 # define SOLARIS_THREADS
1318 # if defined(IRIX_THREADS) && !defined(IRIX5)
1319 --> inconsistent configuration
1321 # if defined(IRIX_JDK_THREADS) && !defined(IRIX5)
1322 --> inconsistent configuration
1324 # if defined(LINUX_THREADS) && !defined(LINUX)
1325 --> inconsistent configuration
1327 # if defined(SOLARIS_THREADS) && !defined(SUNOS5)
1328 --> inconsistent configuration
1330 # if defined(HPUX_THREADS) && !defined(HPUX)
1331 --> inconsistent configuration
1333 # if defined(PCR) || defined(SRC_M3) || \
1334 defined(SOLARIS_THREADS) || defined(WIN32_THREADS) || \
1335 defined(IRIX_THREADS) || defined(LINUX_THREADS) || \
1336 defined(IRIX_JDK_THREADS) || defined(HPUX_THREADS)
1340 # if defined(HP_PA) || defined(M88K) || defined(POWERPC) \
1341 || (defined(I386) && defined(OS2)) || defined(UTS4) || defined(LINT)
1342 /* Use setjmp based hack to mark from callee-save registers. */
1343 # define USE_GENERIC_PUSH_REGS
1346 # define SAVE_CALL_CHAIN
1347 # define ASM_CLEAR_CODE /* Stack clearing is crucial, and we */
1348 /* include assembly code to do it well. */
1351 # endif /* GCCONFIG_H */