OSDN Git Service

Initial revision
authortromey <tromey@138bc75d-0d04-0410-961f-82ee72b054a4>
Wed, 30 Jun 1999 20:04:37 +0000 (20:04 +0000)
committertromey <tromey@138bc75d-0d04-0410-961f-82ee72b054a4>
Wed, 30 Jun 1999 20:04:37 +0000 (20:04 +0000)
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@27855 138bc75d-0d04-0410-961f-82ee72b054a4

boehm-gc/gcconfig.h [new file with mode: 0644]
boehm-gc/include/javaxfc.h [new file with mode: 0644]
boehm-gc/include/new_gc_alloc.h [new file with mode: 0644]
boehm-gc/include/private/gcconfig.h [new file with mode: 0644]

diff --git a/boehm-gc/gcconfig.h b/boehm-gc/gcconfig.h
new file mode 100644 (file)
index 0000000..b1a9dc3
--- /dev/null
@@ -0,0 +1,1061 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+#ifndef CONFIG_H
+
+# define CONFIG_H
+
+/* Machine dependent parameters.  Some tuning parameters can be found  */
+/* near the top of gc_private.h.                                       */
+
+/* Machine specific parts contributed by various people.  See README file. */
+
+/* First a unified test for Linux: */
+# if defined(linux) || defined(__linux__)
+#    define LINUX
+# endif
+
+/* Determine the machine type: */
+# if defined(sun) && defined(mc68000)
+#    define M68K
+#    define SUNOS4
+#    define mach_type_known
+# endif
+# if defined(hp9000s300)
+#    define M68K
+#    define HP
+#    define mach_type_known
+# endif
+# if defined(__OpenBSD__) && defined(m68k)
+#    define M68K
+#    define OPENBSD
+#    define mach_type_known
+# endif
+# if defined(__NetBSD__) && defined(m68k)
+#    define M68K
+#    define NETBSD
+#    define mach_type_known
+# endif
+# if defined(vax)
+#    define VAX
+#    ifdef ultrix
+#      define ULTRIX
+#    else
+#      define BSD
+#    endif
+#    define mach_type_known
+# endif
+# if defined(mips) || defined(__mips)
+#    define MIPS
+#    if defined(ultrix) || defined(__ultrix) || defined(__NetBSD__)
+#      define ULTRIX
+#    else
+#      if defined(_SYSTYPE_SVR4) || defined(SYSTYPE_SVR4) || defined(__SYSTYPE_SVR4__)
+#        define IRIX5   /* or IRIX 6.X */
+#      else
+#        define RISCOS  /* or IRIX 4.X */
+#      endif
+#    endif
+#    define mach_type_known
+# endif
+# if defined(sequent) && defined(i386)
+#    define I386
+#    define SEQUENT
+#    define mach_type_known
+# endif
+# if defined(sun) && defined(i386)
+#    define I386
+#    define SUNOS5
+#    define mach_type_known
+# endif
+# if (defined(__OS2__) || defined(__EMX__)) && defined(__32BIT__)
+#    define I386
+#    define OS2
+#    define mach_type_known
+# endif
+# if defined(ibm032)
+#   define RT
+#   define mach_type_known
+# endif
+# if defined(sun) && (defined(sparc) || defined(__sparc))
+#   define SPARC
+    /* Test for SunOS 5.x */
+#     include <errno.h>
+#     ifdef ECHRNG
+#       define SUNOS5
+#     else
+#      define SUNOS4
+#     endif
+#   define mach_type_known
+# endif
+# if defined(sparc) && defined(unix) && !defined(sun) && !defined(linux)
+#   define SPARC
+#   define DRSNX
+#   define mach_type_known
+# endif
+# if defined(_IBMR2)
+#   define RS6000
+#   define mach_type_known
+# endif
+# if defined(_M_XENIX) && defined(_M_SYSV) && defined(_M_I386)
+       /* The above test may need refinement   */
+#   define I386
+#   if defined(_SCO_ELF)
+#     define SCO_ELF
+#   else
+#     define SCO
+#   endif
+#   define mach_type_known
+# endif
+# if defined(_AUX_SOURCE)
+#   define M68K
+#   define SYSV
+#   define mach_type_known
+# endif
+# if defined(_PA_RISC1_0) || defined(_PA_RISC1_1) \
+     || defined(hppa) || defined(__hppa__)
+#   define HP_PA
+#   define mach_type_known
+# endif
+# if defined(LINUX) && defined(i386)
+#    define I386
+#    define mach_type_known
+# endif
+# if defined(LINUX) && defined(powerpc)
+#    define POWERPC
+#    define mach_type_known
+# endif
+# if defined(LINUX) && defined(__mc68000__)
+#    define M68K
+#    define mach_type_known
+# endif
+# if defined(linux) && defined(sparc)
+#    define SPARC
+#    define LINUX
+#    define mach_type_known
+# endif
+# if defined(__alpha) || defined(__alpha__)
+#   define ALPHA
+#   if !defined(LINUX)
+#     define OSF1      /* a.k.a Digital Unix */
+#   endif
+#   define mach_type_known
+# endif
+# if defined(_AMIGA)
+#   define M68K
+#   define AMIGA
+#   define mach_type_known
+# endif
+# if defined(THINK_C) || defined(__MWERKS__) && !defined(__powerc)
+#   define M68K
+#   define MACOS
+#   define mach_type_known
+# endif
+# if defined(__MWERKS__) && defined(__powerc)
+#   define POWERPC
+#   define MACOS
+#   define mach_type_known
+# endif
+# if defined(NeXT) && defined(mc68000)
+#   define M68K
+#   define NEXT
+#   define mach_type_known
+# endif
+# if defined(NeXT) && defined(i386)
+#   define I386
+#   define NEXT
+#   define mach_type_known
+# endif
+# if defined(__OpenBSD__) && defined(i386)
+#   define I386
+#   define OPENBSD
+#   define mach_type_known
+# endif
+# if defined(__FreeBSD__) && defined(i386)
+#   define I386
+#   define FREEBSD
+#   define mach_type_known
+# endif
+# if defined(__NetBSD__) && defined(i386)
+#   define I386
+#   define NETBSD
+#   define mach_type_known
+# endif
+# if defined(bsdi) && defined(i386)
+#    define I386
+#    define BSDI
+#    define mach_type_known
+# endif
+# if !defined(mach_type_known) && defined(__386BSD__)
+#   define I386
+#   define THREE86BSD
+#   define mach_type_known
+# endif
+# if defined(_CX_UX) && defined(_M88K)
+#   define M88K
+#   define CX_UX
+#   define mach_type_known
+# endif
+# if defined(DGUX)
+#   define M88K
+    /* DGUX defined */
+#   define mach_type_known
+# endif
+# if (defined(_MSDOS) || defined(_MSC_VER)) && (_M_IX86 >= 300) \
+     || defined(_WIN32) && !defined(__CYGWIN32__) && !defined(__CYGWIN__)
+#   define I386
+#   define MSWIN32     /* or Win32s */
+#   define mach_type_known
+# endif
+# if defined(__DJGPP__)
+#   define I386
+#   ifndef DJGPP
+#     define DJGPP  /* MSDOS running the DJGPP port of GCC */
+#   endif
+#   define mach_type_known
+# endif
+# if defined(__CYGWIN32__) || defined(__CYGWIN__)
+#   define I386
+#   define CYGWIN32
+#   define mach_type_known
+# endif
+# if defined(__BORLANDC__)
+#   define I386
+#   define MSWIN32
+#   define mach_type_known
+# endif
+# if defined(_UTS) && !defined(mach_type_known)
+#   define S370
+#   define UTS4
+#   define mach_type_known
+# endif
+/* Ivan Demakov */
+# if defined(__WATCOMC__) && defined(__386__)
+#   define I386
+#   if !defined(OS2) && !defined(MSWIN32) && !defined(DOS4GW)
+#     if defined(__OS2__)
+#       define OS2
+#     else
+#       if defined(__WINDOWS_386__) || defined(__NT__)
+#         define MSWIN32
+#       else
+#         define DOS4GW
+#       endif
+#     endif
+#   endif
+#   define mach_type_known
+# endif
+
+/* Feel free to add more clauses here */
+
+/* Or manually define the machine type here.  A machine type is        */
+/* characterized by the architecture.  Some                            */
+/* machine types are further subdivided by OS.                         */
+/* the macros ULTRIX, RISCOS, and BSD to distinguish.                  */
+/* Note that SGI IRIX is treated identically to RISCOS.                        */
+/* SYSV on an M68K actually means A/UX.                                        */
+/* The distinction in these cases is usually the stack starting address */
+# ifndef mach_type_known
+       --> unknown machine type
+# endif
+                   /* Mapping is: M68K       ==> Motorola 680X0        */
+                   /*             (SUNOS4,HP,NEXT, and SYSV (A/UX),    */
+                   /*             MACOS and AMIGA variants)            */
+                   /*             I386       ==> Intel 386             */
+                   /*              (SEQUENT, OS2, SCO, LINUX, NETBSD,  */
+                   /*               FREEBSD, THREE86BSD, MSWIN32,      */
+                   /*               BSDI,SUNOS5, NEXT, other variants) */
+                    /*             NS32K      ==> Encore Multimax      */
+                    /*             MIPS       ==> R2000 or R3000       */
+                    /*                 (RISCOS, ULTRIX variants)       */
+                    /*            VAX        ==> DEC VAX               */
+                    /*                 (BSD, ULTRIX variants)          */
+                    /*            RS6000     ==> IBM RS/6000 AIX3.X    */
+                    /*            RT         ==> IBM PC/RT             */
+                    /*            HP_PA      ==> HP9000/700 & /800     */
+                    /*                           HP/UX                 */
+                   /*             SPARC      ==> SPARC under SunOS     */
+                   /*                  (SUNOS4, SUNOS5,                */
+                   /*                   DRSNX variants)                */
+                   /*             ALPHA      ==> DEC Alpha             */
+                   /*                  (OSF1 and LINUX variants)       */
+                   /*             M88K       ==> Motorola 88XX0        */
+                   /*                  (CX_UX and DGUX)                */
+                   /*             S370       ==> 370-like machine      */
+                   /*                  running Amdahl UTS4             */
+
+
+/*
+ * For each architecture and OS, the following need to be defined:
+ *
+ * CPP_WORD_SZ is a simple integer constant representing the word size.
+ * in bits.  We assume byte addressibility, where a byte has 8 bits.
+ * We also assume CPP_WORD_SZ is either 32 or 64.
+ * (We care about the length of pointers, not hardware
+ * bus widths.  Thus a 64 bit processor with a C compiler that uses
+ * 32 bit pointers should use CPP_WORD_SZ of 32, not 64. Default is 32.)
+ *
+ * MACH_TYPE is a string representation of the machine type.
+ * OS_TYPE is analogous for the OS.
+ *
+ * ALIGNMENT is the largest N, such that
+ * all pointer are guaranteed to be aligned on N byte boundaries.
+ * defining it to be 1 will always work, but perform poorly.
+ *
+ * DATASTART is the beginning of the data segment.
+ * On UNIX systems, the collector will scan the area between DATASTART
+ * and DATAEND for root pointers.
+ *
+ * DATAEND, if not &end.
+ *
+ * ALIGN_DOUBLE of GC_malloc should return blocks aligned to twice
+ * the pointer size.
+ *
+ * STACKBOTTOM is the cool end of the stack, which is usually the
+ * highest address in the stack.
+ * Under PCR or OS/2, we have other ways of finding thread stacks.
+ * For each machine, the following should:
+ * 1) define STACK_GROWS_UP if the stack grows toward higher addresses, and
+ * 2) define exactly one of
+ *     STACKBOTTOM (should be defined to be an expression)
+ *     HEURISTIC1
+ *     HEURISTIC2
+ * If either of the last two macros are defined, then STACKBOTTOM is computed
+ * during collector startup using one of the following two heuristics:
+ * HEURISTIC1:  Take an address inside GC_init's frame, and round it up to
+ *             the next multiple of STACK_GRAN.
+ * HEURISTIC2:  Take an address inside GC_init's frame, increment it repeatedly
+ *             in small steps (decrement if STACK_GROWS_UP), and read the value
+ *             at each location.  Remember the value when the first
+ *             Segmentation violation or Bus error is signalled.  Round that
+ *             to the nearest plausible page boundary, and use that instead
+ *             of STACKBOTTOM.
+ *
+ * If no expression for STACKBOTTOM can be found, and neither of the above
+ * heuristics are usable, the collector can still be used with all of the above
+ * undefined, provided one of the following is done:
+ * 1) GC_mark_roots can be changed to somehow mark from the correct stack(s)
+ *    without reference to STACKBOTTOM.  This is appropriate for use in
+ *    conjunction with thread packages, since there will be multiple stacks.
+ *    (Allocating thread stacks in the heap, and treating them as ordinary
+ *    heap data objects is also possible as a last resort.  However, this is
+ *    likely to introduce significant amounts of excess storage retention
+ *    unless the dead parts of the thread stacks are periodically cleared.)
+ * 2) Client code may set GC_stackbottom before calling any GC_ routines.
+ *    If the author of the client code controls the main program, this is
+ *    easily accomplished by introducing a new main program, setting
+ *    GC_stackbottom to the address of a local variable, and then calling
+ *    the original main program.  The new main program would read something
+ *    like:
+ *
+ *             # include "gc_private.h"
+ *
+ *             main(argc, argv, envp)
+ *             int argc;
+ *             char **argv, **envp;
+ *             {
+ *                 int dummy;
+ *
+ *                 GC_stackbottom = (ptr_t)(&dummy);
+ *                 return(real_main(argc, argv, envp));
+ *             }
+ *
+ *
+ * Each architecture may also define the style of virtual dirty bit
+ * implementation to be used:
+ *   MPROTECT_VDB: Write protect the heap and catch faults.
+ *   PROC_VDB: Use the SVR4 /proc primitives to read dirty bits.
+ *
+ * An architecture may define DYNAMIC_LOADING if dynamic_load.c
+ * defined GC_register_dynamic_libraries() for the architecture.
+ */
+
+
+# define STACK_GRAN 0x1000000
+# ifdef M68K
+#   define MACH_TYPE "M68K"
+#   define ALIGNMENT 2
+#   ifdef OPENBSD
+#      define OS_TYPE "OPENBSD"
+#      define HEURISTIC2
+       extern char etext;
+#      define DATASTART ((ptr_t)(&etext))
+#   endif
+#   ifdef NETBSD
+#      define OS_TYPE "NETBSD"
+#      define HEURISTIC2
+       extern char etext;
+#      define DATASTART ((ptr_t)(&etext))
+#   endif
+#   ifdef LINUX
+#       define OS_TYPE "LINUX"
+#       define STACKBOTTOM ((ptr_t)0xf0000000)
+#       define MPROTECT_VDB
+#       ifdef __ELF__
+#            define DYNAMIC_LOADING
+             extern char **__environ;
+#            define DATASTART ((ptr_t)(&__environ))
+                             /* hideous kludge: __environ is the first */
+                             /* word in crt0.o, and delimits the start */
+                             /* of the data segment, no matter which   */
+                             /* ld options were passed through.        */
+                             /* We could use _etext instead, but that  */
+                             /* would include .rodata, which may       */
+                             /* contain large read-only data tables    */
+                             /* that we'd rather not scan.             */
+             extern int _end;
+#            define DATAEND (&_end)
+#       else
+             extern int etext;
+#            define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
+#       endif
+#   endif
+#   ifdef SUNOS4
+#      define OS_TYPE "SUNOS4"
+       extern char etext;
+#      define DATASTART ((ptr_t)((((word) (&etext)) + 0x1ffff) & ~0x1ffff))
+#      define HEURISTIC1       /* differs      */
+#      define DYNAMIC_LOADING
+#   endif
+#   ifdef HP
+#      define OS_TYPE "HP"
+       extern char etext;
+#       define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
+#       define STACKBOTTOM ((ptr_t) 0xffeffffc)
+                             /* empirically determined.  seems to work. */
+#      include <unistd.h>
+#      define GETPAGESIZE() sysconf(_SC_PAGE_SIZE)
+#   endif
+#   ifdef SYSV
+#      define OS_TYPE "SYSV"
+       extern etext;
+#      define DATASTART ((ptr_t)((((word) (&etext)) + 0x3fffff) \
+                                  & ~0x3fffff) \
+                                 +((word)&etext & 0x1fff))
+       /* This only works for shared-text binaries with magic number 0413.
+          The other sorts of SysV binaries put the data at the end of the text,
+          in which case the default of &etext would work.  Unfortunately,
+          handling both would require having the magic-number available.
+                               -- Parag
+          */
+#      define STACKBOTTOM ((ptr_t)0xFFFFFFFE)
+                       /* The stack starts at the top of memory, but   */
+                       /* 0x0 cannot be used as setjump_test complains */
+                       /* that the stack direction is incorrect.  Two  */
+                       /* bytes down from 0x0 should be safe enough.   */
+                       /*              --Parag                         */
+#      include <sys/mmu.h>
+#      define GETPAGESIZE() PAGESIZE   /* Is this still right? */
+#   endif
+#   ifdef AMIGA
+#      define OS_TYPE "AMIGA"
+               /* STACKBOTTOM and DATASTART handled specially  */
+               /* in os_dep.c                                  */
+#      define DATAEND  /* not needed */
+#      define GETPAGESIZE() 4096
+#   endif
+#   ifdef MACOS
+#     ifndef __LOWMEM__
+#     include <LowMem.h>
+#     endif
+#     define OS_TYPE "MACOS"
+                       /* see os_dep.c for details of global data segments. */
+#     define STACKBOTTOM ((ptr_t) LMGetCurStackBase())
+#     define DATAEND   /* not needed */
+#     define GETPAGESIZE() 4096
+#   endif
+#   ifdef NEXT
+#      define OS_TYPE "NEXT"
+#      define DATASTART ((ptr_t) get_etext())
+#      define STACKBOTTOM ((ptr_t) 0x4000000)
+#      define DATAEND  /* not needed */
+#   endif
+# endif
+
+# ifdef POWERPC
+#   define MACH_TYPE "POWERPC"
+#   define ALIGNMENT 2
+#   ifdef MACOS
+#     ifndef __LOWMEM__
+#     include <LowMem.h>
+#     endif
+#     define OS_TYPE "MACOS"
+                       /* see os_dep.c for details of global data segments. */
+#     define STACKBOTTOM ((ptr_t) LMGetCurStackBase())
+#     define DATAEND  /* not needed */
+#   endif
+#   ifdef LINUX
+#     define OS_TYPE "LINUX"
+#     define HEURISTIC1
+#     undef STACK_GRAN
+#     define STACK_GRAN 0x10000000
+#     define DATASTART GC_data_start
+      extern int _end;
+#     define DATAEND (&_end)
+#   endif
+# endif
+
+# ifdef VAX
+#   define MACH_TYPE "VAX"
+#   define ALIGNMENT 4 /* Pointers are longword aligned by 4.2 C compiler */
+    extern char etext;
+#   define DATASTART ((ptr_t)(&etext))
+#   ifdef BSD
+#      define OS_TYPE "BSD"
+#      define HEURISTIC1
+                       /* HEURISTIC2 may be OK, but it's hard to test. */
+#   endif
+#   ifdef ULTRIX
+#      define OS_TYPE "ULTRIX"
+#      define STACKBOTTOM ((ptr_t) 0x7fffc800)
+#   endif
+# endif
+
+# ifdef RT
+#   define MACH_TYPE "RT"
+#   define ALIGNMENT 4
+#   define DATASTART ((ptr_t) 0x10000000)
+#   define STACKBOTTOM ((ptr_t) 0x1fffd800)
+# endif
+
+# ifdef SPARC
+#   define MACH_TYPE "SPARC"
+#   define ALIGNMENT 4 /* Required by hardware */
+#   define ALIGN_DOUBLE
+    extern int etext;
+#   ifdef SUNOS5
+#      define OS_TYPE "SUNOS5"
+       extern int _etext;
+       extern int _end;
+       extern char * GC_SysVGetDataStart();
+#       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &_etext)
+#      define DATAEND (&_end)
+#      ifndef USE_MMAP
+#          define USE_MMAP
+#      endif
+#       ifdef USE_MMAP
+#         define HEAP_START (ptr_t)0x40000000
+#       else
+#        define HEAP_START DATAEND
+#       endif
+#      define PROC_VDB
+/*     HEURISTIC1 reportedly no longer works under 2.7.  Thus we       */
+/*     switched to HEURISTIC2, eventhough it creates some debugging    */
+/*     issues.                                                         */
+#      define HEURISTIC2
+#      include <unistd.h>
+#       define GETPAGESIZE()  sysconf(_SC_PAGESIZE)
+               /* getpagesize() appeared to be missing from at least one */
+               /* Solaris 5.4 installation.  Weird.                      */
+#      define DYNAMIC_LOADING
+#   endif
+#   ifdef SUNOS4
+#      define OS_TYPE "SUNOS4"
+       /* [If you have a weak stomach, don't read this.]               */
+       /* We would like to use:                                        */
+/* #       define DATASTART ((ptr_t)((((word) (&etext)) + 0x1fff) & ~0x1fff)) */
+       /* This fails occasionally, due to an ancient, but very         */
+       /* persistent ld bug.  &etext is set 32 bytes too high.         */
+       /* We instead read the text segment size from the a.out         */
+       /* header, which happens to be mapped into our address space    */
+       /* at the start of the text segment.  The detective work here   */
+       /* was done by Robert Ehrlich, Manuel Serrano, and Bernard      */
+       /* Serpette of INRIA.                                           */
+       /* This assumes ZMAGIC, i.e. demand-loadable executables.       */
+#      define TEXTSTART 0x2000
+#       define DATASTART ((ptr_t)(*(int *)(TEXTSTART+0x4)+TEXTSTART))
+#      define MPROTECT_VDB
+#      define HEURISTIC1
+#      define DYNAMIC_LOADING
+#   endif
+#   ifdef DRSNX
+#       define CPP_WORDSZ 32
+#      define OS_TYPE "DRSNX"
+       extern char * GC_SysVGetDataStart();
+       extern int etext;
+#       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &etext)
+#      define MPROTECT_VDB
+#       define STACKBOTTOM ((ptr_t) 0xdfff0000)
+#      define DYNAMIC_LOADING
+#   endif
+#   ifdef LINUX
+#     define OS_TYPE "LINUX"
+#     ifdef __ELF__
+#         define DATASTART GC_data_start
+#         define DYNAMIC_LOADING
+#     else
+          Linux Sparc non elf ?
+#     endif
+      extern int _end;
+#     define DATAEND (&_end)
+#     define SVR4
+#     define STACKBOTTOM ((ptr_t) 0xf0000000)
+#   endif
+# endif
+
+# ifdef I386
+#   define MACH_TYPE "I386"
+#   define ALIGNMENT 4 /* Appears to hold for all "32 bit" compilers   */
+                       /* except Borland.  The -a4 option fixes        */
+                       /* Borland.                                     */
+                        /* Ivan Demakov: For Watcom the option is -zp4. */
+#   ifndef SMALL_CONFIG
+#     define ALIGN_DOUBLE /* Not strictly necessary, but may give speed   */
+                         /* improvement on Pentiums.                     */
+#   endif
+#   ifdef SEQUENT
+#      define OS_TYPE "SEQUENT"
+       extern int etext;
+#       define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
+#       define STACKBOTTOM ((ptr_t) 0x3ffff000) 
+#   endif
+#   ifdef SUNOS5
+#      define OS_TYPE "SUNOS5"
+       extern int etext, _start;
+       extern char * GC_SysVGetDataStart();
+#       define DATASTART GC_SysVGetDataStart(0x1000, &etext)
+#      define STACKBOTTOM ((ptr_t)(&_start))
+/** At least in Solaris 2.5, PROC_VDB gives wrong values for dirty bits. */
+/*#    define PROC_VDB*/
+#      define DYNAMIC_LOADING
+#      ifndef USE_MMAP
+#          define USE_MMAP
+#      endif
+#       ifdef USE_MMAP
+#         define HEAP_START (ptr_t)0x40000000
+#       else
+#        define HEAP_START DATAEND
+#       endif
+#   endif
+#   ifdef SCO
+#      define OS_TYPE "SCO"
+       extern int etext;
+#      define DATASTART ((ptr_t)((((word) (&etext)) + 0x3fffff) \
+                                 & ~0x3fffff) \
+                                +((word)&etext & 0xfff))
+#      define STACKBOTTOM ((ptr_t) 0x7ffffffc)
+#   endif
+#   ifdef SCO_ELF
+#       define OS_TYPE "SCO_ELF"
+        extern int etext;
+#       define DATASTART ((ptr_t)(&etext))
+#       define STACKBOTTOM ((ptr_t) 0x08048000)
+#       define DYNAMIC_LOADING
+#      define ELF_CLASS ELFCLASS32
+#   endif
+#   ifdef LINUX
+#      define OS_TYPE "LINUX"
+#      define STACKBOTTOM ((ptr_t)0xc0000000)
+       /* Appears to be 0xe0000000 for at least one 2.1.91 kernel.     */
+       /* Probably needs to be more flexible, but I don't yet          */
+       /* fully understand how flexible.                               */
+#       if !defined(LINUX_THREADS) || !defined(REDIRECT_MALLOC)
+#          define MPROTECT_VDB
+#      else
+           /* We seem to get random errors in incremental mode,        */
+           /* possibly because Linux threads is itself a malloc client */
+           /* and can't deal with the signals.                         */
+#      endif
+#       ifdef __ELF__
+#            define DYNAMIC_LOADING
+#           ifdef UNDEFINED    /* includes ro data */
+              extern int _etext;
+#              define DATASTART ((ptr_t)((((word) (&_etext)) + 0xfff) & ~0xfff))
+#           endif
+#           include <features.h>
+#           if defined(__GLIBC__) && __GLIBC__ >= 2
+                extern int __data_start;
+#               define DATASTART ((ptr_t)(&__data_start))
+#           else
+                extern char **__environ;
+#                define DATASTART ((ptr_t)(&__environ))
+                             /* hideous kludge: __environ is the first */
+                             /* word in crt0.o, and delimits the start */
+                             /* of the data segment, no matter which   */
+                             /* ld options were passed through.        */
+                             /* We could use _etext instead, but that  */
+                             /* would include .rodata, which may       */
+                             /* contain large read-only data tables    */
+                             /* that we'd rather not scan.             */
+#           endif
+            extern int _end;
+#           define DATAEND (&_end)
+#      else
+            extern int etext;
+#            define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
+#       endif
+#   endif
+#   ifdef CYGWIN32
+#       define OS_TYPE "CYGWIN32"
+          extern int _data_start__;
+          extern int _data_end__;
+          extern int _bss_start__;
+          extern int _bss_end__;
+       /* For binutils 2.9.1, we have                  */
+       /*      DATASTART   = _data_start__             */
+       /*      DATAEND     = _bss_end__                */
+       /* whereas for some earlier versions it was     */
+       /*      DATASTART   = _bss_start__              */
+       /*      DATAEND     = _data_end__               */
+       /* To get it right for both, we take the        */
+       /* minumum/maximum of the two.                  */
+#      define MAX(x,y) ((x) > (y) ? (x) : (y))
+#      define MIN(x,y) ((x) < (y) ? (x) : (y))
+#       define DATASTART ((ptr_t) MIN(&_data_start__, &_bss_start__))
+#       define DATAEND  ((ptr_t) MAX(&_data_end__, &_bss_end__))
+#      undef STACK_GRAN
+#       define STACK_GRAN 0x10000
+#       define HEURISTIC1
+#   endif
+#   ifdef OS2
+#      define OS_TYPE "OS2"
+               /* STACKBOTTOM and DATASTART are handled specially in   */
+               /* os_dep.c. OS2 actually has the right                 */
+               /* system call!                                         */
+#      define DATAEND  /* not needed */
+#   endif
+#   ifdef MSWIN32
+#      define OS_TYPE "MSWIN32"
+               /* STACKBOTTOM and DATASTART are handled specially in   */
+               /* os_dep.c.                                            */
+#       ifndef __WATCOMC__
+#        define MPROTECT_VDB
+#      endif
+#       define DATAEND  /* not needed */
+#   endif
+#   ifdef DJGPP
+#       define OS_TYPE "DJGPP"
+#       include "stubinfo.h"
+        extern int etext;
+        extern int _stklen;
+        extern int __djgpp_stack_limit;
+#       define DATASTART ((ptr_t)((((word) (&etext)) + 0x1ff) & ~0x1ff))
+/* #       define STACKBOTTOM ((ptr_t)((word) _stubinfo + _stubinfo->size \
+                                                     + _stklen)) */
+#       define STACKBOTTOM ((ptr_t)((word) __djgpp_stack_limit + _stklen))
+               /* This may not be right.  */
+#   endif
+#   ifdef OPENBSD
+#      define OS_TYPE "OPENBSD"
+#   endif
+#   ifdef FREEBSD
+#      define OS_TYPE "FREEBSD"
+#      define MPROTECT_VDB
+#   endif
+#   ifdef NETBSD
+#      define OS_TYPE "NETBSD"
+#   endif
+#   ifdef THREE86BSD
+#      define OS_TYPE "THREE86BSD"
+#   endif
+#   ifdef BSDI
+#      define OS_TYPE "BSDI"
+#   endif
+#   if defined(OPENBSD) || defined(FREEBSD) || defined(NETBSD) \
+        || defined(THREE86BSD) || defined(BSDI)
+#      define HEURISTIC2
+       extern char etext;
+#      define DATASTART ((ptr_t)(&etext))
+#   endif
+#   ifdef NEXT
+#      define OS_TYPE "NEXT"
+#      define DATASTART ((ptr_t) get_etext())
+#      define STACKBOTTOM ((ptr_t)0xc0000000)
+#      define DATAEND  /* not needed */
+#   endif
+#   ifdef DOS4GW
+#     define OS_TYPE "DOS4GW"
+      extern long __nullarea;
+      extern char _end;
+      extern char *_STACKTOP;
+      /* Depending on calling conventions Watcom C either precedes
+         or does not precedes with undescore names of C-variables.
+         Make sure startup code variables always have the same names.  */
+      #pragma aux __nullarea "*";
+      #pragma aux _end "*";
+#     define STACKBOTTOM ((ptr_t) _STACKTOP)
+                         /* confused? me too. */
+#     define DATASTART ((ptr_t) &__nullarea)
+#     define DATAEND ((ptr_t) &_end)
+#   endif
+# endif
+
+# ifdef NS32K
+#   define MACH_TYPE "NS32K"
+#   define ALIGNMENT 4
+    extern char **environ;
+#   define DATASTART ((ptr_t)(&environ))
+                             /* hideous kludge: environ is the first   */
+                             /* word in crt0.o, and delimits the start */
+                             /* of the data segment, no matter which   */
+                             /* ld options were passed through.        */
+#   define STACKBOTTOM ((ptr_t) 0xfffff000) /* for Encore */
+# endif
+
+# ifdef MIPS
+#   define MACH_TYPE "MIPS"
+#   ifndef IRIX5
+#     define DATASTART (ptr_t)0x10000000
+                             /* Could probably be slightly higher since */
+                             /* startup code allocates lots of stuff.   */
+#   else
+      extern int _fdata;
+#     define DATASTART ((ptr_t)(&_fdata))
+#     ifdef USE_MMAP
+#         define HEAP_START (ptr_t)0x30000000
+#     else
+#        define HEAP_START DATASTART
+#     endif
+                             /* Lowest plausible heap address.         */
+                             /* In the MMAP case, we map there.        */
+                             /* In either case it is used to identify  */
+                             /* heap sections so they're not           */
+                             /* considered as roots.                   */
+#   endif /* IRIX5 */
+#   define HEURISTIC2
+/* #   define STACKBOTTOM ((ptr_t)0x7fff8000)  sometimes also works.  */
+#   ifdef ULTRIX
+#      define OS_TYPE "ULTRIX"
+#       define ALIGNMENT 4
+#   endif
+#   ifdef RISCOS
+#      define OS_TYPE "RISCOS"
+#      define ALIGNMENT 4  /* Required by hardware */
+#   endif
+#   ifdef IRIX5
+#      define OS_TYPE "IRIX5"
+#       define MPROTECT_VDB
+#       ifdef _MIPS_SZPTR
+#        define CPP_WORDSZ _MIPS_SZPTR
+#        define ALIGNMENT (_MIPS_SZPTR/8)
+#        if CPP_WORDSZ != 64
+#          define ALIGN_DOUBLE
+#        endif
+#      else
+#         define ALIGNMENT 4
+#        define ALIGN_DOUBLE
+#      endif
+#      define DYNAMIC_LOADING
+#   endif
+# endif
+
+# ifdef RS6000
+#   define MACH_TYPE "RS6000"
+#   define ALIGNMENT 4
+#   define DATASTART ((ptr_t)0x20000000)
+    extern int errno;
+#   define STACKBOTTOM ((ptr_t)((ulong)&errno))
+#   define DYNAMIC_LOADING
+       /* For really old versions of AIX, this may have to be removed. */
+# endif
+
+# ifdef HP_PA
+#   define MACH_TYPE "HP_PA"
+#   define ALIGNMENT 4
+#   define ALIGN_DOUBLE
+    extern int __data_start;
+#   define DATASTART ((ptr_t)(&__data_start))
+#   if 0
+       /* The following appears to work for 7xx systems running HP/UX  */
+       /* 9.xx Furthermore, it might result in much faster             */
+       /* collections than HEURISTIC2, which may involve scanning      */
+       /* segments that directly precede the stack.  It is not the     */
+       /* default, since it may not work on older machine/OS           */
+       /* combinations. (Thanks to Raymond X.T. Nijssen for uncovering */
+       /* this.)                                                       */
+#       define STACKBOTTOM ((ptr_t) 0x7b033000)  /* from /etc/conf/h/param.h */
+#   else
+#       define HEURISTIC2
+#   endif
+#   define STACK_GROWS_UP
+#   define DYNAMIC_LOADING
+#   include <unistd.h>
+#   define GETPAGESIZE() sysconf(_SC_PAGE_SIZE)
+       /* They misspelled the Posix macro?     */
+# endif
+
+# ifdef ALPHA
+#   define MACH_TYPE "ALPHA"
+#   define ALIGNMENT 8
+#   ifdef OSF1
+#      define OS_TYPE "OSF1"
+#      define DATASTART ((ptr_t) 0x140000000)
+       extern _end;
+#      define DATAEND ((ptr_t) &_end)
+#      define HEURISTIC2
+       /* Normally HEURISTIC2 is too conervative, since                */
+       /* the text segment immediately follows the stack.              */
+       /* Hence we give an upper pound.                                */
+       extern int __start;
+#      define HEURISTIC2_LIMIT ((ptr_t)((word)(&__start) & ~(getpagesize()-1)))
+#      define CPP_WORDSZ 64
+#      define MPROTECT_VDB
+#      define DYNAMIC_LOADING
+#   endif
+#   ifdef LINUX
+#       define OS_TYPE "LINUX"
+#       define CPP_WORDSZ 64
+#       define STACKBOTTOM ((ptr_t) 0x120000000)
+#       ifdef __ELF__
+            extern int __data_start;
+#           define DATASTART &__data_start
+#           define DYNAMIC_LOADING
+#       else
+#           define DATASTART ((ptr_t) 0x140000000)
+#       endif
+       extern int _end;
+#      define DATAEND (&_end)
+#      define MPROTECT_VDB
+               /* Has only been superficially tested.  May not */
+               /* work on all versions.                        */
+#   endif
+# endif
+
+# ifdef M88K
+#   define MACH_TYPE "M88K"
+#   define ALIGNMENT 4
+#   define ALIGN_DOUBLE
+    extern int etext;
+#   ifdef CX_UX
+#      define OS_TYPE "CX_UX"
+#       define DATASTART ((((word)&etext + 0x3fffff) & ~0x3fffff) + 0x10000)
+#   endif
+#   ifdef  DGUX
+#      define OS_TYPE "DGUX"
+       extern char * GC_SysVGetDataStart();
+#       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &etext)
+#   endif
+#   define STACKBOTTOM ((char*)0xf0000000) /* determined empirically */
+# endif
+
+# ifdef S370
+#   define MACH_TYPE "S370"
+#   define OS_TYPE "UTS4"
+#   define ALIGNMENT 4 /* Required by hardware */
+    extern int etext;
+       extern int _etext;
+       extern int _end;
+       extern char * GC_SysVGetDataStart();
+#       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &_etext)
+#      define DATAEND (&_end)
+#      define HEURISTIC2
+# endif
+
+# ifndef STACK_GROWS_UP
+#   define STACK_GROWS_DOWN
+# endif
+
+# ifndef CPP_WORDSZ
+#   define CPP_WORDSZ 32
+# endif
+
+# ifndef OS_TYPE
+#   define OS_TYPE ""
+# endif
+
+# ifndef DATAEND
+    extern int end;
+#   define DATAEND (&end)
+# endif
+
+# if defined(SVR4) && !defined(GETPAGESIZE)
+#    include <unistd.h>
+#    define GETPAGESIZE()  sysconf(_SC_PAGESIZE)
+# endif
+
+# ifndef GETPAGESIZE
+#   if defined(SUNOS5) || defined(IRIX5)
+#      include <unistd.h>
+#   endif
+#   define GETPAGESIZE() getpagesize()
+# endif
+
+# if defined(SUNOS5) || defined(DRSNX) || defined(UTS4)
+    /* OS has SVR4 generic features.  Probably others also qualify.    */
+#   define SVR4
+# endif
+
+# if defined(SUNOS5) || defined(DRSNX)
+    /* OS has SUNOS5 style semi-undocumented interface to dynamic      */
+    /* loader.                                                         */
+#   define SUNOS5DL
+    /* OS has SUNOS5 style signal handlers.                            */
+#   define SUNOS5SIGS
+# endif
+
+# if CPP_WORDSZ != 32 && CPP_WORDSZ != 64
+   -> bad word size
+# endif
+
+# ifdef PCR
+#   undef DYNAMIC_LOADING
+#   undef STACKBOTTOM
+#   undef HEURISTIC1
+#   undef HEURISTIC2
+#   undef PROC_VDB
+#   undef MPROTECT_VDB
+#   define PCR_VDB
+# endif
+
+# ifdef SRC_M3
+/* Postponed for now. */
+#   undef PROC_VDB
+#   undef MPROTECT_VDB
+# endif
+
+# ifdef SMALL_CONFIG
+/* Presumably not worth the space it takes. */
+#   undef PROC_VDB
+#   undef MPROTECT_VDB
+# endif
+
+# if !defined(PCR_VDB) && !defined(PROC_VDB) && !defined(MPROTECT_VDB)
+#   define DEFAULT_VDB
+# endif
+
+# if defined(_SOLARIS_PTHREADS) && !defined(SOLARIS_THREADS)
+#   define SOLARIS_THREADS
+# endif
+# if defined(IRIX_THREADS) && !defined(IRIX5)
+--> inconsistent configuration
+# endif
+# if defined(IRIX_JDK_THREADS) && !defined(IRIX5)
+--> inconsistent configuration
+# endif
+# if defined(LINUX_THREADS) && !defined(LINUX)
+--> inconsistent configuration
+# endif
+# if defined(SOLARIS_THREADS) && !defined(SUNOS5)
+--> inconsistent configuration
+# endif
+# if defined(PCR) || defined(SRC_M3) || \
+       defined(SOLARIS_THREADS) || defined(WIN32_THREADS) || \
+       defined(IRIX_THREADS) || defined(LINUX_THREADS) || \
+       defined(IRIX_JDK_THREADS)
+#   define THREADS
+# endif
+
+# if defined(HP_PA) || defined(M88K) || defined(POWERPC) \
+     || (defined(I386) && defined(OS2)) || defined(UTS4) || defined(LINT)
+       /* Use setjmp based hack to mark from callee-save registers. */
+#      define USE_GENERIC_PUSH_REGS
+# endif
+# if defined(SPARC) && !defined(LINUX)
+#   define SAVE_CALL_CHAIN
+#   define ASM_CLEAR_CODE      /* Stack clearing is crucial, and we    */
+                               /* include assembly code to do it well. */
+# endif
+
+# endif
diff --git a/boehm-gc/include/javaxfc.h b/boehm-gc/include/javaxfc.h
new file mode 100644 (file)
index 0000000..880020c
--- /dev/null
@@ -0,0 +1,41 @@
+# ifndef GC_H
+#   include "gc.h"
+# endif
+
+/*
+ * Invoke all remaining finalizers that haven't yet been run.
+ * This is needed for strict compliance with the Java standard, 
+ * which can make the runtime guarantee that all finalizers are run.
+ * This is problematic for several reasons:
+ * 1) It means that finalizers, and all methods calle by them,
+ *    must be prepared to deal with objects that have been finalized in
+ *    spite of the fact that they are still referenced by statically
+ *    allocated pointer variables.
+ * 1) It may mean that we get stuck in an infinite loop running
+ *    finalizers which create new finalizable objects, though that's
+ *    probably unlikely.
+ * Thus this is not recommended for general use.
+ */
+void GC_finalize_all();
+
+/*
+ * A version of GC_register_finalizer that allows the object to be
+ * finalized before the objects it references.  This is again error
+ * prone, in that it makes it easy to accidentally reference finalized
+ * objects.  Again, recommended only for JVM implementors.
+ */
+void GC_register_finalizer_no_order(GC_PTR obj,
+                              GC_finalization_proc fn, GC_PTR cd,
+                              GC_finalization_proc *ofn, GC_PTR * ocd);
+
+void GC_debug_register_finalizer_no_order(GC_PTR obj,
+                              GC_finalization_proc fn, GC_PTR cd,
+                              GC_finalization_proc *ofn, GC_PTR * ocd);
+
+#ifdef GC_DEBUG
+#   define GC_REGISTER_FINALIZER(p, f, d, of, od) \
+       GC_debug_register_finalizer_no_order(p, f, d, of, od)
+#else
+#   define GC_REGISTER_FINALIZER(p, f, d, of, od) \
+       GC_register_finalizer_no_order(p, f, d, of, od)
+#endif
diff --git a/boehm-gc/include/new_gc_alloc.h b/boehm-gc/include/new_gc_alloc.h
new file mode 100644 (file)
index 0000000..5771388
--- /dev/null
@@ -0,0 +1,456 @@
+/*
+ * Copyright (c) 1996-1998 by Silicon Graphics.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+//
+// This is a revision of gc_alloc.h for SGI STL versions > 3.0
+// Unlike earlier versions, it supplements the standard "alloc.h"
+// instead of replacing it.
+//
+// This is sloppy about variable names used in header files.
+// It also doesn't yet understand the new header file names or
+// namespaces.
+//
+// This assumes the collector has been compiled with -DATOMIC_UNCOLLECTABLE
+// and -DALL_INTERIOR_POINTERS.  We also recommend
+// -DREDIRECT_MALLOC=GC_uncollectable_malloc.
+//
+// Some of this could be faster in the explicit deallocation case.
+// In particular, we spend too much time clearing objects on the
+// free lists.  That could be avoided.
+//
+// This uses template classes with static members, and hence does not work
+// with g++ 2.7.2 and earlier.
+//
+// Unlike its predecessor, this one simply defines
+//     gc_alloc
+//     single_client_gc_alloc
+//     traceable_alloc
+//     single_client_traceable_alloc
+//
+// It does not redefine alloc.  Nor does it change the default allocator,
+// though the user may wish to do so.  (The argument against changing
+// the default allocator is that it may introduce subtle link compatibility
+// problems.  The argument for changing it is that the usual default
+// allocator is usually a very bad choice for a garbage collected environment.)
+//
+
+#ifndef GC_ALLOC_H
+
+#include "gc.h"
+#include <alloc.h>
+
+#define GC_ALLOC_H
+
+#include <stddef.h>
+#include <string.h>
+
+// The following need to match collector data structures.
+// We can't include gc_priv.h, since that pulls in way too much stuff.
+// This should eventually be factored out into another include file.
+
+extern "C" {
+    extern void ** const GC_objfreelist_ptr;
+    extern void ** const GC_aobjfreelist_ptr;
+    extern void ** const GC_uobjfreelist_ptr;
+    extern void ** const GC_auobjfreelist_ptr;
+
+    extern void GC_incr_words_allocd(size_t words);
+    extern void GC_incr_mem_freed(size_t words);
+
+    extern char * GC_generic_malloc_words_small(size_t word, int kind);
+}
+
+// Object kinds; must match PTRFREE, NORMAL, UNCOLLECTABLE, and
+// AUNCOLLECTABLE in gc_priv.h.
+
+enum { GC_PTRFREE = 0, GC_NORMAL = 1, GC_UNCOLLECTABLE = 2,
+       GC_AUNCOLLECTABLE = 3 };
+
+enum { GC_max_fast_bytes = 255 };
+
+enum { GC_bytes_per_word = sizeof(char *) };
+
+enum { GC_byte_alignment = 8 };
+
+enum { GC_word_alignment = GC_byte_alignment/GC_bytes_per_word };
+
+inline void * &GC_obj_link(void * p)
+{   return *(void **)p;  }
+
+// Compute a number of words >= n+1 bytes.
+// The +1 allows for pointers one past the end.
+inline size_t GC_round_up(size_t n)
+{
+    return ((n + GC_byte_alignment)/GC_byte_alignment)*GC_word_alignment;
+}
+
+// The same but don't allow for extra byte.
+inline size_t GC_round_up_uncollectable(size_t n)
+{
+    return ((n + GC_byte_alignment - 1)/GC_byte_alignment)*GC_word_alignment;
+}
+
+template <int dummy>
+class GC_aux_template {
+public:
+  // File local count of allocated words.  Occasionally this is
+  // added into the global count.  A separate count is necessary since the
+  // real one must be updated with a procedure call.
+  static size_t GC_words_recently_allocd;
+
+  // Same for uncollectable mmory.  Not yet reflected in either
+  // GC_words_recently_allocd or GC_non_gc_bytes.
+  static size_t GC_uncollectable_words_recently_allocd;
+
+  // Similar counter for explicitly deallocated memory.
+  static size_t GC_mem_recently_freed;
+
+  // Again for uncollectable memory.
+  static size_t GC_uncollectable_mem_recently_freed;
+
+  static void * GC_out_of_line_malloc(size_t nwords, int kind);
+};
+
+template <int dummy>
+size_t GC_aux_template<dummy>::GC_words_recently_allocd = 0;
+
+template <int dummy>
+size_t GC_aux_template<dummy>::GC_uncollectable_words_recently_allocd = 0;
+
+template <int dummy>
+size_t GC_aux_template<dummy>::GC_mem_recently_freed = 0;
+
+template <int dummy>
+size_t GC_aux_template<dummy>::GC_uncollectable_mem_recently_freed = 0;
+
+template <int dummy>
+void * GC_aux_template<dummy>::GC_out_of_line_malloc(size_t nwords, int kind)
+{
+    GC_words_recently_allocd += GC_uncollectable_words_recently_allocd;
+    GC_non_gc_bytes +=
+                GC_bytes_per_word * GC_uncollectable_words_recently_allocd;
+    GC_uncollectable_words_recently_allocd = 0;
+
+    GC_mem_recently_freed += GC_uncollectable_mem_recently_freed;
+    GC_non_gc_bytes -= 
+                GC_bytes_per_word * GC_uncollectable_mem_recently_freed;
+    GC_uncollectable_mem_recently_freed = 0;
+
+    GC_incr_words_allocd(GC_words_recently_allocd);
+    GC_words_recently_allocd = 0;
+
+    GC_incr_mem_freed(GC_mem_recently_freed);
+    GC_mem_recently_freed = 0;
+
+    return GC_generic_malloc_words_small(nwords, kind);
+}
+
+typedef GC_aux_template<0> GC_aux;
+
+// A fast, single-threaded, garbage-collected allocator
+// We assume the first word will be immediately overwritten.
+// In this version, deallocation is not a noop, and explicit
+// deallocation is likely to help performance.
+template <int dummy>
+class single_client_gc_alloc_template {
+    public:
+       static void * allocate(size_t n)
+        {
+           size_t nwords = GC_round_up(n);
+           void ** flh;
+           void * op;
+
+           if (n > GC_max_fast_bytes) return GC_malloc(n);
+           flh = GC_objfreelist_ptr + nwords;
+           if (0 == (op = *flh)) {
+               return GC_aux::GC_out_of_line_malloc(nwords, GC_NORMAL);
+           }
+           *flh = GC_obj_link(op);
+           GC_aux::GC_words_recently_allocd += nwords;
+           return op;
+        }
+       static void * ptr_free_allocate(size_t n)
+        {
+           size_t nwords = GC_round_up(n);
+           void ** flh;
+           void * op;
+
+           if (n > GC_max_fast_bytes) return GC_malloc_atomic(n);
+           flh = GC_aobjfreelist_ptr + nwords;
+           if (0 == (op = *flh)) {
+               return GC_aux::GC_out_of_line_malloc(nwords, GC_PTRFREE);
+           }
+           *flh = GC_obj_link(op);
+           GC_aux::GC_words_recently_allocd += nwords;
+           return op;
+        }
+       static void deallocate(void *p, size_t n)
+       {
+            size_t nwords = GC_round_up(n);
+            void ** flh;
+          
+           if (n > GC_max_fast_bytes)  {
+               GC_free(p);
+           } else {
+               flh = GC_objfreelist_ptr + nwords;
+               GC_obj_link(p) = *flh;
+               memset((char *)p + GC_bytes_per_word, 0,
+                      GC_bytes_per_word * (nwords - 1));
+               *flh = p;
+               GC_aux::GC_mem_recently_freed += nwords;
+           }
+       }
+       static void ptr_free_deallocate(void *p, size_t n)
+       {
+            size_t nwords = GC_round_up(n);
+            void ** flh;
+          
+           if (n > GC_max_fast_bytes) {
+               GC_free(p);
+           } else {
+               flh = GC_aobjfreelist_ptr + nwords;
+               GC_obj_link(p) = *flh;
+               *flh = p;
+               GC_aux::GC_mem_recently_freed += nwords;
+           }
+       }
+};
+
+typedef single_client_gc_alloc_template<0> single_client_gc_alloc;
+
+// Once more, for uncollectable objects.
+template <int dummy>
+class single_client_traceable_alloc_template {
+    public:
+       static void * allocate(size_t n)
+        {
+           size_t nwords = GC_round_up_uncollectable(n);
+           void ** flh;
+           void * op;
+
+           if (n > GC_max_fast_bytes) return GC_malloc_uncollectable(n);
+           flh = GC_uobjfreelist_ptr + nwords;
+           if (0 == (op = *flh)) {
+               return GC_aux::GC_out_of_line_malloc(nwords, GC_UNCOLLECTABLE);
+           }
+           *flh = GC_obj_link(op);
+           GC_aux::GC_uncollectable_words_recently_allocd += nwords;
+           return op;
+        }
+       static void * ptr_free_allocate(size_t n)
+        {
+           size_t nwords = GC_round_up_uncollectable(n);
+           void ** flh;
+           void * op;
+
+           if (n > GC_max_fast_bytes) return GC_malloc_atomic_uncollectable(n);
+           flh = GC_auobjfreelist_ptr + nwords;
+           if (0 == (op = *flh)) {
+               return GC_aux::GC_out_of_line_malloc(nwords, GC_AUNCOLLECTABLE);
+           }
+           *flh = GC_obj_link(op);
+           GC_aux::GC_uncollectable_words_recently_allocd += nwords;
+           return op;
+        }
+       static void deallocate(void *p, size_t n)
+       {
+            size_t nwords = GC_round_up_uncollectable(n);
+            void ** flh;
+          
+           if (n > GC_max_fast_bytes)  {
+               GC_free(p);
+           } else {
+               flh = GC_uobjfreelist_ptr + nwords;
+               GC_obj_link(p) = *flh;
+               *flh = p;
+               GC_aux::GC_uncollectable_mem_recently_freed += nwords;
+           }
+       }
+       static void ptr_free_deallocate(void *p, size_t n)
+       {
+            size_t nwords = GC_round_up_uncollectable(n);
+            void ** flh;
+          
+           if (n > GC_max_fast_bytes) {
+               GC_free(p);
+           } else {
+               flh = GC_auobjfreelist_ptr + nwords;
+               GC_obj_link(p) = *flh;
+               *flh = p;
+               GC_aux::GC_uncollectable_mem_recently_freed += nwords;
+           }
+       }
+};
+
+typedef single_client_traceable_alloc_template<0> single_client_traceable_alloc;
+
+template < int dummy >
+class gc_alloc_template {
+    public:
+       static void * allocate(size_t n) { return GC_malloc(n); }
+       static void * ptr_free_allocate(size_t n)
+               { return GC_malloc_atomic(n); }
+       static void deallocate(void *, size_t) { }
+       static void ptr_free_deallocate(void *, size_t) { }
+};
+
+typedef gc_alloc_template < 0 > gc_alloc;
+
+template < int dummy >
+class traceable_alloc_template {
+    public:
+       static void * allocate(size_t n) { return GC_malloc_uncollectable(n); }
+       static void * ptr_free_allocate(size_t n)
+               { return GC_malloc_atomic_uncollectable(n); }
+       static void deallocate(void *p, size_t) { GC_free(p); }
+       static void ptr_free_deallocate(void *p, size_t) { GC_free(p); }
+};
+
+typedef traceable_alloc_template < 0 > traceable_alloc;
+
+#ifdef _SGI_SOURCE
+
+// We want to specialize simple_alloc so that it does the right thing
+// for all pointerfree types.  At the moment there is no portable way to
+// even approximate that.  The following approximation should work for
+// SGI compilers, and perhaps some others.
+
+# define __GC_SPECIALIZE(T,alloc) \
+class simple_alloc<T, alloc> { \
+public: \
+    static T *allocate(size_t n) \
+       { return 0 == n? 0 : \
+                        (T*) alloc::ptr_free_allocate(n * sizeof (T)); } \
+    static T *allocate(void) \
+       { return (T*) alloc::ptr_free_allocate(sizeof (T)); } \
+    static void deallocate(T *p, size_t n) \
+       { if (0 != n) alloc::ptr_free_deallocate(p, n * sizeof (T)); } \
+    static void deallocate(T *p) \
+       { alloc::ptr_free_deallocate(p, sizeof (T)); } \
+};
+
+__GC_SPECIALIZE(char, gc_alloc)
+__GC_SPECIALIZE(int, gc_alloc)
+__GC_SPECIALIZE(unsigned, gc_alloc)
+__GC_SPECIALIZE(float, gc_alloc)
+__GC_SPECIALIZE(double, gc_alloc)
+
+__GC_SPECIALIZE(char, traceable_alloc)
+__GC_SPECIALIZE(int, traceable_alloc)
+__GC_SPECIALIZE(unsigned, traceable_alloc)
+__GC_SPECIALIZE(float, traceable_alloc)
+__GC_SPECIALIZE(double, traceable_alloc)
+
+__GC_SPECIALIZE(char, single_client_gc_alloc)
+__GC_SPECIALIZE(int, single_client_gc_alloc)
+__GC_SPECIALIZE(unsigned, single_client_gc_alloc)
+__GC_SPECIALIZE(float, single_client_gc_alloc)
+__GC_SPECIALIZE(double, single_client_gc_alloc)
+
+__GC_SPECIALIZE(char, single_client_traceable_alloc)
+__GC_SPECIALIZE(int, single_client_traceable_alloc)
+__GC_SPECIALIZE(unsigned, single_client_traceable_alloc)
+__GC_SPECIALIZE(float, single_client_traceable_alloc)
+__GC_SPECIALIZE(double, single_client_traceable_alloc)
+
+#ifdef __STL_USE_STD_ALLOCATORS
+
+__STL_BEGIN_NAMESPACE
+
+template <class _T>
+struct _Alloc_traits<_T, gc_alloc >
+{
+  static const bool _S_instanceless = true;
+  typedef simple_alloc<_T, gc_alloc > _Alloc_type;
+  typedef __allocator<_T, gc_alloc > allocator_type;
+};
+
+inline bool operator==(const gc_alloc&,
+                       const gc_alloc&)
+{
+  return true;
+}
+
+inline bool operator!=(const gc_alloc&,
+                       const gc_alloc&)
+{
+  return false;
+}
+
+template <class _T>
+struct _Alloc_traits<_T, single_client_gc_alloc >
+{
+  static const bool _S_instanceless = true;
+  typedef simple_alloc<_T, single_client_gc_alloc > _Alloc_type;
+  typedef __allocator<_T, single_client_gc_alloc > allocator_type;
+};
+
+inline bool operator==(const single_client_gc_alloc&,
+                       const single_client_gc_alloc&)
+{
+  return true;
+}
+
+inline bool operator!=(const single_client_gc_alloc&,
+                       const single_client_gc_alloc&)
+{
+  return false;
+}
+
+template <class _T>
+struct _Alloc_traits<_T, traceable_alloc >
+{
+  static const bool _S_instanceless = true;
+  typedef simple_alloc<_T, traceable_alloc > _Alloc_type;
+  typedef __allocator<_T, traceable_alloc > allocator_type;
+};
+
+inline bool operator==(const traceable_alloc&,
+                       const traceable_alloc&)
+{
+  return true;
+}
+
+inline bool operator!=(const traceable_alloc&,
+                       const traceable_alloc&)
+{
+  return false;
+}
+
+template <class _T>
+struct _Alloc_traits<_T, single_client_traceable_alloc >
+{
+  static const bool _S_instanceless = true;
+  typedef simple_alloc<_T, single_client_traceable_alloc > _Alloc_type;
+  typedef __allocator<_T, single_client_traceable_alloc > allocator_type;
+};
+
+inline bool operator==(const single_client_traceable_alloc&,
+                       const single_client_traceable_alloc&)
+{
+  return true;
+}
+
+inline bool operator!=(const single_client_traceable_alloc&,
+                       const single_client_traceable_alloc&)
+{
+  return false;
+}
+
+__STL_END_NAMESPACE
+
+#endif /* __STL_USE_STD_ALLOCATORS */
+
+#endif /* _SGI_SOURCE */
+
+#endif /* GC_ALLOC_H */
diff --git a/boehm-gc/include/private/gcconfig.h b/boehm-gc/include/private/gcconfig.h
new file mode 100644 (file)
index 0000000..b1a9dc3
--- /dev/null
@@ -0,0 +1,1061 @@
+/* 
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
+ * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+#ifndef CONFIG_H
+
+# define CONFIG_H
+
+/* Machine dependent parameters.  Some tuning parameters can be found  */
+/* near the top of gc_private.h.                                       */
+
+/* Machine specific parts contributed by various people.  See README file. */
+
+/* First a unified test for Linux: */
+# if defined(linux) || defined(__linux__)
+#    define LINUX
+# endif
+
+/* Determine the machine type: */
+# if defined(sun) && defined(mc68000)
+#    define M68K
+#    define SUNOS4
+#    define mach_type_known
+# endif
+# if defined(hp9000s300)
+#    define M68K
+#    define HP
+#    define mach_type_known
+# endif
+# if defined(__OpenBSD__) && defined(m68k)
+#    define M68K
+#    define OPENBSD
+#    define mach_type_known
+# endif
+# if defined(__NetBSD__) && defined(m68k)
+#    define M68K
+#    define NETBSD
+#    define mach_type_known
+# endif
+# if defined(vax)
+#    define VAX
+#    ifdef ultrix
+#      define ULTRIX
+#    else
+#      define BSD
+#    endif
+#    define mach_type_known
+# endif
+# if defined(mips) || defined(__mips)
+#    define MIPS
+#    if defined(ultrix) || defined(__ultrix) || defined(__NetBSD__)
+#      define ULTRIX
+#    else
+#      if defined(_SYSTYPE_SVR4) || defined(SYSTYPE_SVR4) || defined(__SYSTYPE_SVR4__)
+#        define IRIX5   /* or IRIX 6.X */
+#      else
+#        define RISCOS  /* or IRIX 4.X */
+#      endif
+#    endif
+#    define mach_type_known
+# endif
+# if defined(sequent) && defined(i386)
+#    define I386
+#    define SEQUENT
+#    define mach_type_known
+# endif
+# if defined(sun) && defined(i386)
+#    define I386
+#    define SUNOS5
+#    define mach_type_known
+# endif
+# if (defined(__OS2__) || defined(__EMX__)) && defined(__32BIT__)
+#    define I386
+#    define OS2
+#    define mach_type_known
+# endif
+# if defined(ibm032)
+#   define RT
+#   define mach_type_known
+# endif
+# if defined(sun) && (defined(sparc) || defined(__sparc))
+#   define SPARC
+    /* Test for SunOS 5.x */
+#     include <errno.h>
+#     ifdef ECHRNG
+#       define SUNOS5
+#     else
+#      define SUNOS4
+#     endif
+#   define mach_type_known
+# endif
+# if defined(sparc) && defined(unix) && !defined(sun) && !defined(linux)
+#   define SPARC
+#   define DRSNX
+#   define mach_type_known
+# endif
+# if defined(_IBMR2)
+#   define RS6000
+#   define mach_type_known
+# endif
+# if defined(_M_XENIX) && defined(_M_SYSV) && defined(_M_I386)
+       /* The above test may need refinement   */
+#   define I386
+#   if defined(_SCO_ELF)
+#     define SCO_ELF
+#   else
+#     define SCO
+#   endif
+#   define mach_type_known
+# endif
+# if defined(_AUX_SOURCE)
+#   define M68K
+#   define SYSV
+#   define mach_type_known
+# endif
+# if defined(_PA_RISC1_0) || defined(_PA_RISC1_1) \
+     || defined(hppa) || defined(__hppa__)
+#   define HP_PA
+#   define mach_type_known
+# endif
+# if defined(LINUX) && defined(i386)
+#    define I386
+#    define mach_type_known
+# endif
+# if defined(LINUX) && defined(powerpc)
+#    define POWERPC
+#    define mach_type_known
+# endif
+# if defined(LINUX) && defined(__mc68000__)
+#    define M68K
+#    define mach_type_known
+# endif
+# if defined(linux) && defined(sparc)
+#    define SPARC
+#    define LINUX
+#    define mach_type_known
+# endif
+# if defined(__alpha) || defined(__alpha__)
+#   define ALPHA
+#   if !defined(LINUX)
+#     define OSF1      /* a.k.a Digital Unix */
+#   endif
+#   define mach_type_known
+# endif
+# if defined(_AMIGA)
+#   define M68K
+#   define AMIGA
+#   define mach_type_known
+# endif
+# if defined(THINK_C) || defined(__MWERKS__) && !defined(__powerc)
+#   define M68K
+#   define MACOS
+#   define mach_type_known
+# endif
+# if defined(__MWERKS__) && defined(__powerc)
+#   define POWERPC
+#   define MACOS
+#   define mach_type_known
+# endif
+# if defined(NeXT) && defined(mc68000)
+#   define M68K
+#   define NEXT
+#   define mach_type_known
+# endif
+# if defined(NeXT) && defined(i386)
+#   define I386
+#   define NEXT
+#   define mach_type_known
+# endif
+# if defined(__OpenBSD__) && defined(i386)
+#   define I386
+#   define OPENBSD
+#   define mach_type_known
+# endif
+# if defined(__FreeBSD__) && defined(i386)
+#   define I386
+#   define FREEBSD
+#   define mach_type_known
+# endif
+# if defined(__NetBSD__) && defined(i386)
+#   define I386
+#   define NETBSD
+#   define mach_type_known
+# endif
+# if defined(bsdi) && defined(i386)
+#    define I386
+#    define BSDI
+#    define mach_type_known
+# endif
+# if !defined(mach_type_known) && defined(__386BSD__)
+#   define I386
+#   define THREE86BSD
+#   define mach_type_known
+# endif
+# if defined(_CX_UX) && defined(_M88K)
+#   define M88K
+#   define CX_UX
+#   define mach_type_known
+# endif
+# if defined(DGUX)
+#   define M88K
+    /* DGUX defined */
+#   define mach_type_known
+# endif
+# if (defined(_MSDOS) || defined(_MSC_VER)) && (_M_IX86 >= 300) \
+     || defined(_WIN32) && !defined(__CYGWIN32__) && !defined(__CYGWIN__)
+#   define I386
+#   define MSWIN32     /* or Win32s */
+#   define mach_type_known
+# endif
+# if defined(__DJGPP__)
+#   define I386
+#   ifndef DJGPP
+#     define DJGPP  /* MSDOS running the DJGPP port of GCC */
+#   endif
+#   define mach_type_known
+# endif
+# if defined(__CYGWIN32__) || defined(__CYGWIN__)
+#   define I386
+#   define CYGWIN32
+#   define mach_type_known
+# endif
+# if defined(__BORLANDC__)
+#   define I386
+#   define MSWIN32
+#   define mach_type_known
+# endif
+# if defined(_UTS) && !defined(mach_type_known)
+#   define S370
+#   define UTS4
+#   define mach_type_known
+# endif
+/* Ivan Demakov */
+# if defined(__WATCOMC__) && defined(__386__)
+#   define I386
+#   if !defined(OS2) && !defined(MSWIN32) && !defined(DOS4GW)
+#     if defined(__OS2__)
+#       define OS2
+#     else
+#       if defined(__WINDOWS_386__) || defined(__NT__)
+#         define MSWIN32
+#       else
+#         define DOS4GW
+#       endif
+#     endif
+#   endif
+#   define mach_type_known
+# endif
+
+/* Feel free to add more clauses here */
+
+/* Or manually define the machine type here.  A machine type is        */
+/* characterized by the architecture.  Some                            */
+/* machine types are further subdivided by OS.                         */
+/* the macros ULTRIX, RISCOS, and BSD to distinguish.                  */
+/* Note that SGI IRIX is treated identically to RISCOS.                        */
+/* SYSV on an M68K actually means A/UX.                                        */
+/* The distinction in these cases is usually the stack starting address */
+# ifndef mach_type_known
+       --> unknown machine type
+# endif
+                   /* Mapping is: M68K       ==> Motorola 680X0        */
+                   /*             (SUNOS4,HP,NEXT, and SYSV (A/UX),    */
+                   /*             MACOS and AMIGA variants)            */
+                   /*             I386       ==> Intel 386             */
+                   /*              (SEQUENT, OS2, SCO, LINUX, NETBSD,  */
+                   /*               FREEBSD, THREE86BSD, MSWIN32,      */
+                   /*               BSDI,SUNOS5, NEXT, other variants) */
+                    /*             NS32K      ==> Encore Multimax      */
+                    /*             MIPS       ==> R2000 or R3000       */
+                    /*                 (RISCOS, ULTRIX variants)       */
+                    /*            VAX        ==> DEC VAX               */
+                    /*                 (BSD, ULTRIX variants)          */
+                    /*            RS6000     ==> IBM RS/6000 AIX3.X    */
+                    /*            RT         ==> IBM PC/RT             */
+                    /*            HP_PA      ==> HP9000/700 & /800     */
+                    /*                           HP/UX                 */
+                   /*             SPARC      ==> SPARC under SunOS     */
+                   /*                  (SUNOS4, SUNOS5,                */
+                   /*                   DRSNX variants)                */
+                   /*             ALPHA      ==> DEC Alpha             */
+                   /*                  (OSF1 and LINUX variants)       */
+                   /*             M88K       ==> Motorola 88XX0        */
+                   /*                  (CX_UX and DGUX)                */
+                   /*             S370       ==> 370-like machine      */
+                   /*                  running Amdahl UTS4             */
+
+
+/*
+ * For each architecture and OS, the following need to be defined:
+ *
+ * CPP_WORD_SZ is a simple integer constant representing the word size.
+ * in bits.  We assume byte addressibility, where a byte has 8 bits.
+ * We also assume CPP_WORD_SZ is either 32 or 64.
+ * (We care about the length of pointers, not hardware
+ * bus widths.  Thus a 64 bit processor with a C compiler that uses
+ * 32 bit pointers should use CPP_WORD_SZ of 32, not 64. Default is 32.)
+ *
+ * MACH_TYPE is a string representation of the machine type.
+ * OS_TYPE is analogous for the OS.
+ *
+ * ALIGNMENT is the largest N, such that
+ * all pointer are guaranteed to be aligned on N byte boundaries.
+ * defining it to be 1 will always work, but perform poorly.
+ *
+ * DATASTART is the beginning of the data segment.
+ * On UNIX systems, the collector will scan the area between DATASTART
+ * and DATAEND for root pointers.
+ *
+ * DATAEND, if not &end.
+ *
+ * ALIGN_DOUBLE of GC_malloc should return blocks aligned to twice
+ * the pointer size.
+ *
+ * STACKBOTTOM is the cool end of the stack, which is usually the
+ * highest address in the stack.
+ * Under PCR or OS/2, we have other ways of finding thread stacks.
+ * For each machine, the following should:
+ * 1) define STACK_GROWS_UP if the stack grows toward higher addresses, and
+ * 2) define exactly one of
+ *     STACKBOTTOM (should be defined to be an expression)
+ *     HEURISTIC1
+ *     HEURISTIC2
+ * If either of the last two macros are defined, then STACKBOTTOM is computed
+ * during collector startup using one of the following two heuristics:
+ * HEURISTIC1:  Take an address inside GC_init's frame, and round it up to
+ *             the next multiple of STACK_GRAN.
+ * HEURISTIC2:  Take an address inside GC_init's frame, increment it repeatedly
+ *             in small steps (decrement if STACK_GROWS_UP), and read the value
+ *             at each location.  Remember the value when the first
+ *             Segmentation violation or Bus error is signalled.  Round that
+ *             to the nearest plausible page boundary, and use that instead
+ *             of STACKBOTTOM.
+ *
+ * If no expression for STACKBOTTOM can be found, and neither of the above
+ * heuristics are usable, the collector can still be used with all of the above
+ * undefined, provided one of the following is done:
+ * 1) GC_mark_roots can be changed to somehow mark from the correct stack(s)
+ *    without reference to STACKBOTTOM.  This is appropriate for use in
+ *    conjunction with thread packages, since there will be multiple stacks.
+ *    (Allocating thread stacks in the heap, and treating them as ordinary
+ *    heap data objects is also possible as a last resort.  However, this is
+ *    likely to introduce significant amounts of excess storage retention
+ *    unless the dead parts of the thread stacks are periodically cleared.)
+ * 2) Client code may set GC_stackbottom before calling any GC_ routines.
+ *    If the author of the client code controls the main program, this is
+ *    easily accomplished by introducing a new main program, setting
+ *    GC_stackbottom to the address of a local variable, and then calling
+ *    the original main program.  The new main program would read something
+ *    like:
+ *
+ *             # include "gc_private.h"
+ *
+ *             main(argc, argv, envp)
+ *             int argc;
+ *             char **argv, **envp;
+ *             {
+ *                 int dummy;
+ *
+ *                 GC_stackbottom = (ptr_t)(&dummy);
+ *                 return(real_main(argc, argv, envp));
+ *             }
+ *
+ *
+ * Each architecture may also define the style of virtual dirty bit
+ * implementation to be used:
+ *   MPROTECT_VDB: Write protect the heap and catch faults.
+ *   PROC_VDB: Use the SVR4 /proc primitives to read dirty bits.
+ *
+ * An architecture may define DYNAMIC_LOADING if dynamic_load.c
+ * defined GC_register_dynamic_libraries() for the architecture.
+ */
+
+
+# define STACK_GRAN 0x1000000
+# ifdef M68K
+#   define MACH_TYPE "M68K"
+#   define ALIGNMENT 2
+#   ifdef OPENBSD
+#      define OS_TYPE "OPENBSD"
+#      define HEURISTIC2
+       extern char etext;
+#      define DATASTART ((ptr_t)(&etext))
+#   endif
+#   ifdef NETBSD
+#      define OS_TYPE "NETBSD"
+#      define HEURISTIC2
+       extern char etext;
+#      define DATASTART ((ptr_t)(&etext))
+#   endif
+#   ifdef LINUX
+#       define OS_TYPE "LINUX"
+#       define STACKBOTTOM ((ptr_t)0xf0000000)
+#       define MPROTECT_VDB
+#       ifdef __ELF__
+#            define DYNAMIC_LOADING
+             extern char **__environ;
+#            define DATASTART ((ptr_t)(&__environ))
+                             /* hideous kludge: __environ is the first */
+                             /* word in crt0.o, and delimits the start */
+                             /* of the data segment, no matter which   */
+                             /* ld options were passed through.        */
+                             /* We could use _etext instead, but that  */
+                             /* would include .rodata, which may       */
+                             /* contain large read-only data tables    */
+                             /* that we'd rather not scan.             */
+             extern int _end;
+#            define DATAEND (&_end)
+#       else
+             extern int etext;
+#            define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
+#       endif
+#   endif
+#   ifdef SUNOS4
+#      define OS_TYPE "SUNOS4"
+       extern char etext;
+#      define DATASTART ((ptr_t)((((word) (&etext)) + 0x1ffff) & ~0x1ffff))
+#      define HEURISTIC1       /* differs      */
+#      define DYNAMIC_LOADING
+#   endif
+#   ifdef HP
+#      define OS_TYPE "HP"
+       extern char etext;
+#       define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
+#       define STACKBOTTOM ((ptr_t) 0xffeffffc)
+                             /* empirically determined.  seems to work. */
+#      include <unistd.h>
+#      define GETPAGESIZE() sysconf(_SC_PAGE_SIZE)
+#   endif
+#   ifdef SYSV
+#      define OS_TYPE "SYSV"
+       extern etext;
+#      define DATASTART ((ptr_t)((((word) (&etext)) + 0x3fffff) \
+                                  & ~0x3fffff) \
+                                 +((word)&etext & 0x1fff))
+       /* This only works for shared-text binaries with magic number 0413.
+          The other sorts of SysV binaries put the data at the end of the text,
+          in which case the default of &etext would work.  Unfortunately,
+          handling both would require having the magic-number available.
+                               -- Parag
+          */
+#      define STACKBOTTOM ((ptr_t)0xFFFFFFFE)
+                       /* The stack starts at the top of memory, but   */
+                       /* 0x0 cannot be used as setjump_test complains */
+                       /* that the stack direction is incorrect.  Two  */
+                       /* bytes down from 0x0 should be safe enough.   */
+                       /*              --Parag                         */
+#      include <sys/mmu.h>
+#      define GETPAGESIZE() PAGESIZE   /* Is this still right? */
+#   endif
+#   ifdef AMIGA
+#      define OS_TYPE "AMIGA"
+               /* STACKBOTTOM and DATASTART handled specially  */
+               /* in os_dep.c                                  */
+#      define DATAEND  /* not needed */
+#      define GETPAGESIZE() 4096
+#   endif
+#   ifdef MACOS
+#     ifndef __LOWMEM__
+#     include <LowMem.h>
+#     endif
+#     define OS_TYPE "MACOS"
+                       /* see os_dep.c for details of global data segments. */
+#     define STACKBOTTOM ((ptr_t) LMGetCurStackBase())
+#     define DATAEND   /* not needed */
+#     define GETPAGESIZE() 4096
+#   endif
+#   ifdef NEXT
+#      define OS_TYPE "NEXT"
+#      define DATASTART ((ptr_t) get_etext())
+#      define STACKBOTTOM ((ptr_t) 0x4000000)
+#      define DATAEND  /* not needed */
+#   endif
+# endif
+
+# ifdef POWERPC
+#   define MACH_TYPE "POWERPC"
+#   define ALIGNMENT 2
+#   ifdef MACOS
+#     ifndef __LOWMEM__
+#     include <LowMem.h>
+#     endif
+#     define OS_TYPE "MACOS"
+                       /* see os_dep.c for details of global data segments. */
+#     define STACKBOTTOM ((ptr_t) LMGetCurStackBase())
+#     define DATAEND  /* not needed */
+#   endif
+#   ifdef LINUX
+#     define OS_TYPE "LINUX"
+#     define HEURISTIC1
+#     undef STACK_GRAN
+#     define STACK_GRAN 0x10000000
+#     define DATASTART GC_data_start
+      extern int _end;
+#     define DATAEND (&_end)
+#   endif
+# endif
+
+# ifdef VAX
+#   define MACH_TYPE "VAX"
+#   define ALIGNMENT 4 /* Pointers are longword aligned by 4.2 C compiler */
+    extern char etext;
+#   define DATASTART ((ptr_t)(&etext))
+#   ifdef BSD
+#      define OS_TYPE "BSD"
+#      define HEURISTIC1
+                       /* HEURISTIC2 may be OK, but it's hard to test. */
+#   endif
+#   ifdef ULTRIX
+#      define OS_TYPE "ULTRIX"
+#      define STACKBOTTOM ((ptr_t) 0x7fffc800)
+#   endif
+# endif
+
+# ifdef RT
+#   define MACH_TYPE "RT"
+#   define ALIGNMENT 4
+#   define DATASTART ((ptr_t) 0x10000000)
+#   define STACKBOTTOM ((ptr_t) 0x1fffd800)
+# endif
+
+# ifdef SPARC
+#   define MACH_TYPE "SPARC"
+#   define ALIGNMENT 4 /* Required by hardware */
+#   define ALIGN_DOUBLE
+    extern int etext;
+#   ifdef SUNOS5
+#      define OS_TYPE "SUNOS5"
+       extern int _etext;
+       extern int _end;
+       extern char * GC_SysVGetDataStart();
+#       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &_etext)
+#      define DATAEND (&_end)
+#      ifndef USE_MMAP
+#          define USE_MMAP
+#      endif
+#       ifdef USE_MMAP
+#         define HEAP_START (ptr_t)0x40000000
+#       else
+#        define HEAP_START DATAEND
+#       endif
+#      define PROC_VDB
+/*     HEURISTIC1 reportedly no longer works under 2.7.  Thus we       */
+/*     switched to HEURISTIC2, eventhough it creates some debugging    */
+/*     issues.                                                         */
+#      define HEURISTIC2
+#      include <unistd.h>
+#       define GETPAGESIZE()  sysconf(_SC_PAGESIZE)
+               /* getpagesize() appeared to be missing from at least one */
+               /* Solaris 5.4 installation.  Weird.                      */
+#      define DYNAMIC_LOADING
+#   endif
+#   ifdef SUNOS4
+#      define OS_TYPE "SUNOS4"
+       /* [If you have a weak stomach, don't read this.]               */
+       /* We would like to use:                                        */
+/* #       define DATASTART ((ptr_t)((((word) (&etext)) + 0x1fff) & ~0x1fff)) */
+       /* This fails occasionally, due to an ancient, but very         */
+       /* persistent ld bug.  &etext is set 32 bytes too high.         */
+       /* We instead read the text segment size from the a.out         */
+       /* header, which happens to be mapped into our address space    */
+       /* at the start of the text segment.  The detective work here   */
+       /* was done by Robert Ehrlich, Manuel Serrano, and Bernard      */
+       /* Serpette of INRIA.                                           */
+       /* This assumes ZMAGIC, i.e. demand-loadable executables.       */
+#      define TEXTSTART 0x2000
+#       define DATASTART ((ptr_t)(*(int *)(TEXTSTART+0x4)+TEXTSTART))
+#      define MPROTECT_VDB
+#      define HEURISTIC1
+#      define DYNAMIC_LOADING
+#   endif
+#   ifdef DRSNX
+#       define CPP_WORDSZ 32
+#      define OS_TYPE "DRSNX"
+       extern char * GC_SysVGetDataStart();
+       extern int etext;
+#       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &etext)
+#      define MPROTECT_VDB
+#       define STACKBOTTOM ((ptr_t) 0xdfff0000)
+#      define DYNAMIC_LOADING
+#   endif
+#   ifdef LINUX
+#     define OS_TYPE "LINUX"
+#     ifdef __ELF__
+#         define DATASTART GC_data_start
+#         define DYNAMIC_LOADING
+#     else
+          Linux Sparc non elf ?
+#     endif
+      extern int _end;
+#     define DATAEND (&_end)
+#     define SVR4
+#     define STACKBOTTOM ((ptr_t) 0xf0000000)
+#   endif
+# endif
+
+# ifdef I386
+#   define MACH_TYPE "I386"
+#   define ALIGNMENT 4 /* Appears to hold for all "32 bit" compilers   */
+                       /* except Borland.  The -a4 option fixes        */
+                       /* Borland.                                     */
+                        /* Ivan Demakov: For Watcom the option is -zp4. */
+#   ifndef SMALL_CONFIG
+#     define ALIGN_DOUBLE /* Not strictly necessary, but may give speed   */
+                         /* improvement on Pentiums.                     */
+#   endif
+#   ifdef SEQUENT
+#      define OS_TYPE "SEQUENT"
+       extern int etext;
+#       define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
+#       define STACKBOTTOM ((ptr_t) 0x3ffff000) 
+#   endif
+#   ifdef SUNOS5
+#      define OS_TYPE "SUNOS5"
+       extern int etext, _start;
+       extern char * GC_SysVGetDataStart();
+#       define DATASTART GC_SysVGetDataStart(0x1000, &etext)
+#      define STACKBOTTOM ((ptr_t)(&_start))
+/** At least in Solaris 2.5, PROC_VDB gives wrong values for dirty bits. */
+/*#    define PROC_VDB*/
+#      define DYNAMIC_LOADING
+#      ifndef USE_MMAP
+#          define USE_MMAP
+#      endif
+#       ifdef USE_MMAP
+#         define HEAP_START (ptr_t)0x40000000
+#       else
+#        define HEAP_START DATAEND
+#       endif
+#   endif
+#   ifdef SCO
+#      define OS_TYPE "SCO"
+       extern int etext;
+#      define DATASTART ((ptr_t)((((word) (&etext)) + 0x3fffff) \
+                                 & ~0x3fffff) \
+                                +((word)&etext & 0xfff))
+#      define STACKBOTTOM ((ptr_t) 0x7ffffffc)
+#   endif
+#   ifdef SCO_ELF
+#       define OS_TYPE "SCO_ELF"
+        extern int etext;
+#       define DATASTART ((ptr_t)(&etext))
+#       define STACKBOTTOM ((ptr_t) 0x08048000)
+#       define DYNAMIC_LOADING
+#      define ELF_CLASS ELFCLASS32
+#   endif
+#   ifdef LINUX
+#      define OS_TYPE "LINUX"
+#      define STACKBOTTOM ((ptr_t)0xc0000000)
+       /* Appears to be 0xe0000000 for at least one 2.1.91 kernel.     */
+       /* Probably needs to be more flexible, but I don't yet          */
+       /* fully understand how flexible.                               */
+#       if !defined(LINUX_THREADS) || !defined(REDIRECT_MALLOC)
+#          define MPROTECT_VDB
+#      else
+           /* We seem to get random errors in incremental mode,        */
+           /* possibly because Linux threads is itself a malloc client */
+           /* and can't deal with the signals.                         */
+#      endif
+#       ifdef __ELF__
+#            define DYNAMIC_LOADING
+#           ifdef UNDEFINED    /* includes ro data */
+              extern int _etext;
+#              define DATASTART ((ptr_t)((((word) (&_etext)) + 0xfff) & ~0xfff))
+#           endif
+#           include <features.h>
+#           if defined(__GLIBC__) && __GLIBC__ >= 2
+                extern int __data_start;
+#               define DATASTART ((ptr_t)(&__data_start))
+#           else
+                extern char **__environ;
+#                define DATASTART ((ptr_t)(&__environ))
+                             /* hideous kludge: __environ is the first */
+                             /* word in crt0.o, and delimits the start */
+                             /* of the data segment, no matter which   */
+                             /* ld options were passed through.        */
+                             /* We could use _etext instead, but that  */
+                             /* would include .rodata, which may       */
+                             /* contain large read-only data tables    */
+                             /* that we'd rather not scan.             */
+#           endif
+            extern int _end;
+#           define DATAEND (&_end)
+#      else
+            extern int etext;
+#            define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
+#       endif
+#   endif
+#   ifdef CYGWIN32
+#       define OS_TYPE "CYGWIN32"
+          extern int _data_start__;
+          extern int _data_end__;
+          extern int _bss_start__;
+          extern int _bss_end__;
+       /* For binutils 2.9.1, we have                  */
+       /*      DATASTART   = _data_start__             */
+       /*      DATAEND     = _bss_end__                */
+       /* whereas for some earlier versions it was     */
+       /*      DATASTART   = _bss_start__              */
+       /*      DATAEND     = _data_end__               */
+       /* To get it right for both, we take the        */
+       /* minumum/maximum of the two.                  */
+#      define MAX(x,y) ((x) > (y) ? (x) : (y))
+#      define MIN(x,y) ((x) < (y) ? (x) : (y))
+#       define DATASTART ((ptr_t) MIN(&_data_start__, &_bss_start__))
+#       define DATAEND  ((ptr_t) MAX(&_data_end__, &_bss_end__))
+#      undef STACK_GRAN
+#       define STACK_GRAN 0x10000
+#       define HEURISTIC1
+#   endif
+#   ifdef OS2
+#      define OS_TYPE "OS2"
+               /* STACKBOTTOM and DATASTART are handled specially in   */
+               /* os_dep.c. OS2 actually has the right                 */
+               /* system call!                                         */
+#      define DATAEND  /* not needed */
+#   endif
+#   ifdef MSWIN32
+#      define OS_TYPE "MSWIN32"
+               /* STACKBOTTOM and DATASTART are handled specially in   */
+               /* os_dep.c.                                            */
+#       ifndef __WATCOMC__
+#        define MPROTECT_VDB
+#      endif
+#       define DATAEND  /* not needed */
+#   endif
+#   ifdef DJGPP
+#       define OS_TYPE "DJGPP"
+#       include "stubinfo.h"
+        extern int etext;
+        extern int _stklen;
+        extern int __djgpp_stack_limit;
+#       define DATASTART ((ptr_t)((((word) (&etext)) + 0x1ff) & ~0x1ff))
+/* #       define STACKBOTTOM ((ptr_t)((word) _stubinfo + _stubinfo->size \
+                                                     + _stklen)) */
+#       define STACKBOTTOM ((ptr_t)((word) __djgpp_stack_limit + _stklen))
+               /* This may not be right.  */
+#   endif
+#   ifdef OPENBSD
+#      define OS_TYPE "OPENBSD"
+#   endif
+#   ifdef FREEBSD
+#      define OS_TYPE "FREEBSD"
+#      define MPROTECT_VDB
+#   endif
+#   ifdef NETBSD
+#      define OS_TYPE "NETBSD"
+#   endif
+#   ifdef THREE86BSD
+#      define OS_TYPE "THREE86BSD"
+#   endif
+#   ifdef BSDI
+#      define OS_TYPE "BSDI"
+#   endif
+#   if defined(OPENBSD) || defined(FREEBSD) || defined(NETBSD) \
+        || defined(THREE86BSD) || defined(BSDI)
+#      define HEURISTIC2
+       extern char etext;
+#      define DATASTART ((ptr_t)(&etext))
+#   endif
+#   ifdef NEXT
+#      define OS_TYPE "NEXT"
+#      define DATASTART ((ptr_t) get_etext())
+#      define STACKBOTTOM ((ptr_t)0xc0000000)
+#      define DATAEND  /* not needed */
+#   endif
+#   ifdef DOS4GW
+#     define OS_TYPE "DOS4GW"
+      extern long __nullarea;
+      extern char _end;
+      extern char *_STACKTOP;
+      /* Depending on calling conventions Watcom C either precedes
+         or does not precedes with undescore names of C-variables.
+         Make sure startup code variables always have the same names.  */
+      #pragma aux __nullarea "*";
+      #pragma aux _end "*";
+#     define STACKBOTTOM ((ptr_t) _STACKTOP)
+                         /* confused? me too. */
+#     define DATASTART ((ptr_t) &__nullarea)
+#     define DATAEND ((ptr_t) &_end)
+#   endif
+# endif
+
+# ifdef NS32K
+#   define MACH_TYPE "NS32K"
+#   define ALIGNMENT 4
+    extern char **environ;
+#   define DATASTART ((ptr_t)(&environ))
+                             /* hideous kludge: environ is the first   */
+                             /* word in crt0.o, and delimits the start */
+                             /* of the data segment, no matter which   */
+                             /* ld options were passed through.        */
+#   define STACKBOTTOM ((ptr_t) 0xfffff000) /* for Encore */
+# endif
+
+# ifdef MIPS
+#   define MACH_TYPE "MIPS"
+#   ifndef IRIX5
+#     define DATASTART (ptr_t)0x10000000
+                             /* Could probably be slightly higher since */
+                             /* startup code allocates lots of stuff.   */
+#   else
+      extern int _fdata;
+#     define DATASTART ((ptr_t)(&_fdata))
+#     ifdef USE_MMAP
+#         define HEAP_START (ptr_t)0x30000000
+#     else
+#        define HEAP_START DATASTART
+#     endif
+                             /* Lowest plausible heap address.         */
+                             /* In the MMAP case, we map there.        */
+                             /* In either case it is used to identify  */
+                             /* heap sections so they're not           */
+                             /* considered as roots.                   */
+#   endif /* IRIX5 */
+#   define HEURISTIC2
+/* #   define STACKBOTTOM ((ptr_t)0x7fff8000)  sometimes also works.  */
+#   ifdef ULTRIX
+#      define OS_TYPE "ULTRIX"
+#       define ALIGNMENT 4
+#   endif
+#   ifdef RISCOS
+#      define OS_TYPE "RISCOS"
+#      define ALIGNMENT 4  /* Required by hardware */
+#   endif
+#   ifdef IRIX5
+#      define OS_TYPE "IRIX5"
+#       define MPROTECT_VDB
+#       ifdef _MIPS_SZPTR
+#        define CPP_WORDSZ _MIPS_SZPTR
+#        define ALIGNMENT (_MIPS_SZPTR/8)
+#        if CPP_WORDSZ != 64
+#          define ALIGN_DOUBLE
+#        endif
+#      else
+#         define ALIGNMENT 4
+#        define ALIGN_DOUBLE
+#      endif
+#      define DYNAMIC_LOADING
+#   endif
+# endif
+
+# ifdef RS6000
+#   define MACH_TYPE "RS6000"
+#   define ALIGNMENT 4
+#   define DATASTART ((ptr_t)0x20000000)
+    extern int errno;
+#   define STACKBOTTOM ((ptr_t)((ulong)&errno))
+#   define DYNAMIC_LOADING
+       /* For really old versions of AIX, this may have to be removed. */
+# endif
+
+# ifdef HP_PA
+#   define MACH_TYPE "HP_PA"
+#   define ALIGNMENT 4
+#   define ALIGN_DOUBLE
+    extern int __data_start;
+#   define DATASTART ((ptr_t)(&__data_start))
+#   if 0
+       /* The following appears to work for 7xx systems running HP/UX  */
+       /* 9.xx Furthermore, it might result in much faster             */
+       /* collections than HEURISTIC2, which may involve scanning      */
+       /* segments that directly precede the stack.  It is not the     */
+       /* default, since it may not work on older machine/OS           */
+       /* combinations. (Thanks to Raymond X.T. Nijssen for uncovering */
+       /* this.)                                                       */
+#       define STACKBOTTOM ((ptr_t) 0x7b033000)  /* from /etc/conf/h/param.h */
+#   else
+#       define HEURISTIC2
+#   endif
+#   define STACK_GROWS_UP
+#   define DYNAMIC_LOADING
+#   include <unistd.h>
+#   define GETPAGESIZE() sysconf(_SC_PAGE_SIZE)
+       /* They misspelled the Posix macro?     */
+# endif
+
+# ifdef ALPHA
+#   define MACH_TYPE "ALPHA"
+#   define ALIGNMENT 8
+#   ifdef OSF1
+#      define OS_TYPE "OSF1"
+#      define DATASTART ((ptr_t) 0x140000000)
+       extern _end;
+#      define DATAEND ((ptr_t) &_end)
+#      define HEURISTIC2
+       /* Normally HEURISTIC2 is too conervative, since                */
+       /* the text segment immediately follows the stack.              */
+       /* Hence we give an upper pound.                                */
+       extern int __start;
+#      define HEURISTIC2_LIMIT ((ptr_t)((word)(&__start) & ~(getpagesize()-1)))
+#      define CPP_WORDSZ 64
+#      define MPROTECT_VDB
+#      define DYNAMIC_LOADING
+#   endif
+#   ifdef LINUX
+#       define OS_TYPE "LINUX"
+#       define CPP_WORDSZ 64
+#       define STACKBOTTOM ((ptr_t) 0x120000000)
+#       ifdef __ELF__
+            extern int __data_start;
+#           define DATASTART &__data_start
+#           define DYNAMIC_LOADING
+#       else
+#           define DATASTART ((ptr_t) 0x140000000)
+#       endif
+       extern int _end;
+#      define DATAEND (&_end)
+#      define MPROTECT_VDB
+               /* Has only been superficially tested.  May not */
+               /* work on all versions.                        */
+#   endif
+# endif
+
+# ifdef M88K
+#   define MACH_TYPE "M88K"
+#   define ALIGNMENT 4
+#   define ALIGN_DOUBLE
+    extern int etext;
+#   ifdef CX_UX
+#      define OS_TYPE "CX_UX"
+#       define DATASTART ((((word)&etext + 0x3fffff) & ~0x3fffff) + 0x10000)
+#   endif
+#   ifdef  DGUX
+#      define OS_TYPE "DGUX"
+       extern char * GC_SysVGetDataStart();
+#       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &etext)
+#   endif
+#   define STACKBOTTOM ((char*)0xf0000000) /* determined empirically */
+# endif
+
+# ifdef S370
+#   define MACH_TYPE "S370"
+#   define OS_TYPE "UTS4"
+#   define ALIGNMENT 4 /* Required by hardware */
+    extern int etext;
+       extern int _etext;
+       extern int _end;
+       extern char * GC_SysVGetDataStart();
+#       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &_etext)
+#      define DATAEND (&_end)
+#      define HEURISTIC2
+# endif
+
+# ifndef STACK_GROWS_UP
+#   define STACK_GROWS_DOWN
+# endif
+
+# ifndef CPP_WORDSZ
+#   define CPP_WORDSZ 32
+# endif
+
+# ifndef OS_TYPE
+#   define OS_TYPE ""
+# endif
+
+# ifndef DATAEND
+    extern int end;
+#   define DATAEND (&end)
+# endif
+
+# if defined(SVR4) && !defined(GETPAGESIZE)
+#    include <unistd.h>
+#    define GETPAGESIZE()  sysconf(_SC_PAGESIZE)
+# endif
+
+# ifndef GETPAGESIZE
+#   if defined(SUNOS5) || defined(IRIX5)
+#      include <unistd.h>
+#   endif
+#   define GETPAGESIZE() getpagesize()
+# endif
+
+# if defined(SUNOS5) || defined(DRSNX) || defined(UTS4)
+    /* OS has SVR4 generic features.  Probably others also qualify.    */
+#   define SVR4
+# endif
+
+# if defined(SUNOS5) || defined(DRSNX)
+    /* OS has SUNOS5 style semi-undocumented interface to dynamic      */
+    /* loader.                                                         */
+#   define SUNOS5DL
+    /* OS has SUNOS5 style signal handlers.                            */
+#   define SUNOS5SIGS
+# endif
+
+# if CPP_WORDSZ != 32 && CPP_WORDSZ != 64
+   -> bad word size
+# endif
+
+# ifdef PCR
+#   undef DYNAMIC_LOADING
+#   undef STACKBOTTOM
+#   undef HEURISTIC1
+#   undef HEURISTIC2
+#   undef PROC_VDB
+#   undef MPROTECT_VDB
+#   define PCR_VDB
+# endif
+
+# ifdef SRC_M3
+/* Postponed for now. */
+#   undef PROC_VDB
+#   undef MPROTECT_VDB
+# endif
+
+# ifdef SMALL_CONFIG
+/* Presumably not worth the space it takes. */
+#   undef PROC_VDB
+#   undef MPROTECT_VDB
+# endif
+
+# if !defined(PCR_VDB) && !defined(PROC_VDB) && !defined(MPROTECT_VDB)
+#   define DEFAULT_VDB
+# endif
+
+# if defined(_SOLARIS_PTHREADS) && !defined(SOLARIS_THREADS)
+#   define SOLARIS_THREADS
+# endif
+# if defined(IRIX_THREADS) && !defined(IRIX5)
+--> inconsistent configuration
+# endif
+# if defined(IRIX_JDK_THREADS) && !defined(IRIX5)
+--> inconsistent configuration
+# endif
+# if defined(LINUX_THREADS) && !defined(LINUX)
+--> inconsistent configuration
+# endif
+# if defined(SOLARIS_THREADS) && !defined(SUNOS5)
+--> inconsistent configuration
+# endif
+# if defined(PCR) || defined(SRC_M3) || \
+       defined(SOLARIS_THREADS) || defined(WIN32_THREADS) || \
+       defined(IRIX_THREADS) || defined(LINUX_THREADS) || \
+       defined(IRIX_JDK_THREADS)
+#   define THREADS
+# endif
+
+# if defined(HP_PA) || defined(M88K) || defined(POWERPC) \
+     || (defined(I386) && defined(OS2)) || defined(UTS4) || defined(LINT)
+       /* Use setjmp based hack to mark from callee-save registers. */
+#      define USE_GENERIC_PUSH_REGS
+# endif
+# if defined(SPARC) && !defined(LINUX)
+#   define SAVE_CALL_CHAIN
+#   define ASM_CLEAR_CODE      /* Stack clearing is crucial, and we    */
+                               /* include assembly code to do it well. */
+# endif
+
+# endif