[BACK]Return to gcconfig.h.linux CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / gc5.3

Annotation of OpenXM_contrib2/asir2000/gc5.3/gcconfig.h.linux, Revision 1.4

1.1       noro        1: /*
                      2:  * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
                      3:  * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
                      4:  * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
                      5:  *
                      6:  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
                      7:  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
                      8:  *
                      9:  * Permission is hereby granted to use or copy this program
                     10:  * for any purpose,  provided the above notices are retained on all copies.
                     11:  * Permission to modify the code and to distribute modified code is granted,
                     12:  * provided the above notices are retained, and a notice that the code was
                     13:  * modified is included with the above copyright notice.
                     14:  */
                     15:
                     16: #ifndef GCCONFIG_H
                     17:
                     18: # define GCCONFIG_H
                     19:
                     20: /* Machine dependent parameters.  Some tuning parameters can be found  */
                     21: /* near the top of gc_private.h.                                       */
                     22:
                     23: /* Machine specific parts contributed by various people.  See README file. */
                     24:
                     25: /* First a unified test for Linux: */
                     26: # if defined(linux) || defined(__linux__)
                     27: #    define LINUX
                     28: # endif
                     29:
                     30: /* Determine the machine type: */
                     31: # if defined(sun) && defined(mc68000)
                     32: #    define M68K
                     33: #    define SUNOS4
                     34: #    define mach_type_known
                     35: # endif
                     36: # if defined(hp9000s300)
                     37: #    define M68K
                     38: #    define HP
                     39: #    define mach_type_known
                     40: # endif
                     41: # if defined(__OpenBSD__) && defined(m68k)
                     42: #    define M68K
                     43: #    define OPENBSD
                     44: #    define mach_type_known
                     45: # endif
                     46: # if defined(__OpenBSD__) && defined(__sparc__)
                     47: #    define SPARC
                     48: #    define OPENBSD
                     49: #    define mach_type_known
                     50: # endif
                     51: # if defined(__NetBSD__) && defined(m68k)
                     52: #    define M68K
                     53: #    define NETBSD
                     54: #    define mach_type_known
                     55: # endif
                     56: # if defined(__NetBSD__) && defined(arm32)
                     57: #    define ARM32
                     58: #    define NETBSD
                     59: #    define mach_type_known
                     60: # endif
                     61: # if defined(vax)
                     62: #    define VAX
                     63: #    ifdef ultrix
                     64: #      define ULTRIX
                     65: #    else
                     66: #      define BSD
                     67: #    endif
                     68: #    define mach_type_known
                     69: # endif
                     70: # if defined(mips) || defined(__mips)
                     71: #    define MIPS
                     72: #    if !defined(LINUX)
                     73: #      if defined(ultrix) || defined(__ultrix) || defined(__NetBSD__)
                     74: #       define ULTRIX
                     75: #      else
                     76: #       if defined(_SYSTYPE_SVR4) || defined(SYSTYPE_SVR4) \
                     77:            || defined(__SYSTYPE_SVR4__)
                     78: #         define IRIX5   /* or IRIX 6.X */
                     79: #       else
                     80: #         define RISCOS  /* or IRIX 4.X */
                     81: #       endif
                     82: #      endif
                     83: #    endif /* !LINUX */
                     84: #    define mach_type_known
                     85: # endif
                     86: # if defined(sequent) && defined(i386)
                     87: #    define I386
                     88: #    define SEQUENT
                     89: #    define mach_type_known
                     90: # endif
                     91: # if defined(sun) && defined(i386)
                     92: #    define I386
                     93: #    define SUNOS5
                     94: #    define mach_type_known
                     95: # endif
                     96: # if (defined(__OS2__) || defined(__EMX__)) && defined(__32BIT__)
                     97: #    define I386
                     98: #    define OS2
                     99: #    define mach_type_known
                    100: # endif
                    101: # if defined(ibm032)
                    102: #   define RT
                    103: #   define mach_type_known
                    104: # endif
                    105: # if defined(sun) && (defined(sparc) || defined(__sparc))
                    106: #   define SPARC
                    107:     /* Test for SunOS 5.x */
                    108: #     include <errno.h>
                    109: #     ifdef ECHRNG
                    110: #       define SUNOS5
                    111: #     else
                    112: #      define SUNOS4
                    113: #     endif
                    114: #   define mach_type_known
                    115: # endif
                    116: # if defined(sparc) && defined(unix) && !defined(sun) && !defined(linux) \
                    117:      && !defined(__OpenBSD__)
                    118: #   define SPARC
                    119: #   define DRSNX
                    120: #   define mach_type_known
                    121: # endif
                    122: # if defined(_IBMR2)
                    123: #   define RS6000
                    124: #   define mach_type_known
                    125: # endif
                    126: # if defined(_M_XENIX) && defined(_M_SYSV) && defined(_M_I386)
                    127:        /* The above test may need refinement   */
                    128: #   define I386
                    129: #   if defined(_SCO_ELF)
                    130: #     define SCO_ELF
                    131: #   else
                    132: #     define SCO
                    133: #   endif
                    134: #   define mach_type_known
                    135: # endif
                    136: # if defined(_AUX_SOURCE)
                    137: #   define M68K
                    138: #   define SYSV
                    139: #   define mach_type_known
                    140: # endif
                    141: # if defined(_PA_RISC1_0) || defined(_PA_RISC1_1) || defined(_PA_RISC2_0) \
                    142:      || defined(hppa) || defined(__hppa__)
                    143: #   define HP_PA
                    144: #   ifndef LINUX
                    145: #     define HPUX
                    146: #   endif
                    147: #   define mach_type_known
                    148: # endif
                    149: # if defined(LINUX) && (defined(i386) || defined(__i386__))
                    150: #    define I386
                    151: #    define mach_type_known
                    152: # endif
                    153: # if defined(LINUX) && (defined(__ia64__) || defined(__ia64))
                    154: #    define IA64
                    155: #    define mach_type_known
                    156: # endif
                    157: # if defined(LINUX) && defined(powerpc)
                    158: #    define POWERPC
                    159: #    define mach_type_known
                    160: # endif
                    161: # if defined(LINUX) && defined(__mc68000__)
                    162: #    define M68K
                    163: #    define mach_type_known
                    164: # endif
                    165: # if defined(LINUX) && (defined(sparc) || defined(__sparc__))
                    166: #    define SPARC
                    167: #    define mach_type_known
                    168: # endif
                    169: # if defined(LINUX) && defined(arm)
                    170: #    define ARM32
                    171: #    define mach_type_known
                    172: # endif
                    173: # if defined(__alpha) || defined(__alpha__)
                    174: #   define ALPHA
                    175: #   if !defined(LINUX)
                    176: #     define OSF1      /* a.k.a Digital Unix */
                    177: #   endif
                    178: #   define mach_type_known
                    179: # endif
                    180: # if defined(_AMIGA) && !defined(AMIGA)
                    181: #   define AMIGA
                    182: # endif
                    183: # ifdef AMIGA
                    184: #   define M68K
                    185: #   define mach_type_known
                    186: # endif
                    187: # if defined(THINK_C) || defined(__MWERKS__) && !defined(__powerc)
                    188: #   define M68K
                    189: #   define MACOS
                    190: #   define mach_type_known
                    191: # endif
                    192: # if defined(__MWERKS__) && defined(__powerc)
                    193: #   define POWERPC
                    194: #   define MACOS
                    195: #   define mach_type_known
                    196: # endif
                    197: # if defined(macosx)
                    198: #    define MACOSX
                    199: #    define POWERPC
                    200: #    define mach_type_known
                    201: # endif
                    202: # if defined(NeXT) && defined(mc68000)
                    203: #   define M68K
                    204: #   define NEXT
                    205: #   define mach_type_known
                    206: # endif
                    207: # if defined(NeXT) && defined(i386)
                    208: #   define I386
                    209: #   define NEXT
                    210: #   define mach_type_known
                    211: # endif
                    212: # if defined(__OpenBSD__) && defined(i386)
                    213: #   define I386
                    214: #   define OPENBSD
                    215: #   define mach_type_known
                    216: # endif
                    217: # if defined(__FreeBSD__) && defined(i386)
                    218: #   define I386
                    219: #   define FREEBSD
                    220: #   define mach_type_known
                    221: # endif
                    222: # if defined(__NetBSD__) && defined(i386)
                    223: #   define I386
                    224: #   define NETBSD
                    225: #   define mach_type_known
                    226: # endif
                    227: # if defined(bsdi) && defined(i386)
                    228: #    define I386
                    229: #    define BSDI
                    230: #    define mach_type_known
                    231: # endif
                    232: # if !defined(mach_type_known) && defined(__386BSD__)
                    233: #   define I386
                    234: #   define THREE86BSD
                    235: #   define mach_type_known
                    236: # endif
                    237: # if defined(_CX_UX) && defined(_M88K)
                    238: #   define M88K
                    239: #   define CX_UX
                    240: #   define mach_type_known
                    241: # endif
                    242: # if defined(DGUX)
                    243: #   define M88K
                    244:     /* DGUX defined */
                    245: #   define mach_type_known
                    246: # endif
                    247: # if (defined(_MSDOS) || defined(_MSC_VER)) && (_M_IX86 >= 300) \
                    248:      || defined(_WIN32) && !defined(__CYGWIN32__) && !defined(__CYGWIN__)
                    249: #   define I386
                    250: #   define MSWIN32     /* or Win32s */
                    251: #   define mach_type_known
                    252: # endif
                    253: # if defined(__DJGPP__)
                    254: #   define I386
                    255: #   ifndef DJGPP
                    256: #     define DJGPP  /* MSDOS running the DJGPP port of GCC */
                    257: #   endif
                    258: #   define mach_type_known
                    259: # endif
                    260: # if defined(__CYGWIN32__) || defined(__CYGWIN__)
                    261: #   define I386
                    262: #   define CYGWIN32
                    263: #   define mach_type_known
                    264: # endif
                    265: # if defined(__MINGW32__)
                    266: #   define I386
                    267: #   define MSWIN32
                    268: #   define mach_type_known
                    269: # endif
                    270: # if defined(__BORLANDC__)
                    271: #   define I386
                    272: #   define MSWIN32
                    273: #   define mach_type_known
                    274: # endif
                    275: # if defined(_UTS) && !defined(mach_type_known)
                    276: #   define S370
                    277: #   define UTS4
                    278: #   define mach_type_known
                    279: # endif
                    280: # if defined(__pj__)
                    281: #   define PJ
                    282: #   define mach_type_known
                    283: # endif
                    284: /* Ivan Demakov */
                    285: # if defined(__WATCOMC__) && defined(__386__)
                    286: #   define I386
                    287: #   if !defined(OS2) && !defined(MSWIN32) && !defined(DOS4GW)
                    288: #     if defined(__OS2__)
                    289: #       define OS2
                    290: #     else
                    291: #       if defined(__WINDOWS_386__) || defined(__NT__)
                    292: #         define MSWIN32
                    293: #       else
                    294: #         define DOS4GW
                    295: #       endif
                    296: #     endif
                    297: #   endif
                    298: #   define mach_type_known
                    299: # endif
                    300:
                    301: /* Feel free to add more clauses here */
                    302:
                    303: /* Or manually define the machine type here.  A machine type is        */
                    304: /* characterized by the architecture.  Some                            */
                    305: /* machine types are further subdivided by OS.                         */
                    306: /* the macros ULTRIX, RISCOS, and BSD to distinguish.                  */
                    307: /* Note that SGI IRIX is treated identically to RISCOS.                        */
                    308: /* SYSV on an M68K actually means A/UX.                                        */
                    309: /* The distinction in these cases is usually the stack starting address */
                    310: # ifndef mach_type_known
                    311:        --> unknown machine type
                    312: # endif
                    313:                    /* Mapping is: M68K       ==> Motorola 680X0        */
                    314:                    /*             (SUNOS4,HP,NEXT, and SYSV (A/UX),    */
                    315:                    /*             MACOS and AMIGA variants)            */
                    316:                    /*             I386       ==> Intel 386             */
                    317:                    /*              (SEQUENT, OS2, SCO, LINUX, NETBSD,  */
                    318:                    /*               FREEBSD, THREE86BSD, MSWIN32,      */
                    319:                    /*               BSDI,SUNOS5, NEXT, other variants) */
                    320:                     /*             NS32K      ==> Encore Multimax      */
                    321:                     /*             MIPS       ==> R2000 or R3000       */
                    322:                     /*                 (RISCOS, ULTRIX variants)       */
                    323:                     /*            VAX        ==> DEC VAX               */
                    324:                     /*                 (BSD, ULTRIX variants)          */
                    325:                     /*            RS6000     ==> IBM RS/6000 AIX3.X    */
                    326:                     /*            RT         ==> IBM PC/RT             */
                    327:                     /*            HP_PA      ==> HP9000/700 & /800     */
                    328:                     /*                           HP/UX                 */
                    329:                    /*             SPARC      ==> SPARC under SunOS     */
                    330:                    /*                  (SUNOS4, SUNOS5,                */
                    331:                    /*                   DRSNX variants)                */
                    332:                    /*             ALPHA      ==> DEC Alpha             */
                    333:                    /*                  (OSF1 and LINUX variants)       */
                    334:                    /*             M88K       ==> Motorola 88XX0        */
                    335:                    /*                  (CX_UX and DGUX)                */
                    336:                    /*             S370       ==> 370-like machine      */
                    337:                    /*                  running Amdahl UTS4             */
                    338:                    /*             ARM32      ==> Intel StrongARM       */
                    339:                    /*             IA64       ==> Intel IA64            */
                    340:                    /*                            (e.g. Itanium)        */
                    341:
                    342:
                    343: /*
                    344:  * For each architecture and OS, the following need to be defined:
                    345:  *
                    346:  * CPP_WORD_SZ is a simple integer constant representing the word size.
                    347:  * in bits.  We assume byte addressibility, where a byte has 8 bits.
                    348:  * We also assume CPP_WORD_SZ is either 32 or 64.
                    349:  * (We care about the length of pointers, not hardware
                    350:  * bus widths.  Thus a 64 bit processor with a C compiler that uses
                    351:  * 32 bit pointers should use CPP_WORD_SZ of 32, not 64. Default is 32.)
                    352:  *
                    353:  * MACH_TYPE is a string representation of the machine type.
                    354:  * OS_TYPE is analogous for the OS.
                    355:  *
                    356:  * ALIGNMENT is the largest N, such that
                    357:  * all pointer are guaranteed to be aligned on N byte boundaries.
                    358:  * defining it to be 1 will always work, but perform poorly.
                    359:  *
                    360:  * DATASTART is the beginning of the data segment.
                    361:  * On UNIX systems, the collector will scan the area between DATASTART
                    362:  * and DATAEND for root pointers.
                    363:  *
                    364:  * DATAEND, if not &end.
                    365:  *
                    366:  * ALIGN_DOUBLE of GC_malloc should return blocks aligned to twice
                    367:  * the pointer size.
                    368:  *
                    369:  * STACKBOTTOM is the cool end of the stack, which is usually the
                    370:  * highest address in the stack.
                    371:  * Under PCR or OS/2, we have other ways of finding thread stacks.
                    372:  * For each machine, the following should:
                    373:  * 1) define STACK_GROWS_UP if the stack grows toward higher addresses, and
                    374:  * 2) define exactly one of
                    375:  *     STACKBOTTOM (should be defined to be an expression)
                    376:  *     HEURISTIC1
                    377:  *     HEURISTIC2
                    378:  * If either of the last two macros are defined, then STACKBOTTOM is computed
                    379:  * during collector startup using one of the following two heuristics:
                    380:  * HEURISTIC1:  Take an address inside GC_init's frame, and round it up to
                    381:  *             the next multiple of STACK_GRAN.
                    382:  * HEURISTIC2:  Take an address inside GC_init's frame, increment it repeatedly
                    383:  *             in small steps (decrement if STACK_GROWS_UP), and read the value
                    384:  *             at each location.  Remember the value when the first
                    385:  *             Segmentation violation or Bus error is signalled.  Round that
                    386:  *             to the nearest plausible page boundary, and use that instead
                    387:  *             of STACKBOTTOM.
                    388:  *
                    389:  * Gustavo Rodriguez-Rivera points out that on most (all?) Unix machines,
                    390:  * the value of environ is a pointer that can serve as STACKBOTTOM.
                    391:  * I expect that HEURISTIC2 can be replaced by this approach, which
                    392:  * interferes far less with debugging.
                    393:  *
                    394:  * If no expression for STACKBOTTOM can be found, and neither of the above
                    395:  * heuristics are usable, the collector can still be used with all of the above
                    396:  * undefined, provided one of the following is done:
                    397:  * 1) GC_mark_roots can be changed to somehow mark from the correct stack(s)
                    398:  *    without reference to STACKBOTTOM.  This is appropriate for use in
                    399:  *    conjunction with thread packages, since there will be multiple stacks.
                    400:  *    (Allocating thread stacks in the heap, and treating them as ordinary
                    401:  *    heap data objects is also possible as a last resort.  However, this is
                    402:  *    likely to introduce significant amounts of excess storage retention
                    403:  *    unless the dead parts of the thread stacks are periodically cleared.)
                    404:  * 2) Client code may set GC_stackbottom before calling any GC_ routines.
                    405:  *    If the author of the client code controls the main program, this is
                    406:  *    easily accomplished by introducing a new main program, setting
                    407:  *    GC_stackbottom to the address of a local variable, and then calling
                    408:  *    the original main program.  The new main program would read something
                    409:  *    like:
                    410:  *
                    411:  *             # include "gc_private.h"
                    412:  *
                    413:  *             main(argc, argv, envp)
                    414:  *             int argc;
                    415:  *             char **argv, **envp;
                    416:  *             {
                    417:  *                 int dummy;
                    418:  *
                    419:  *                 GC_stackbottom = (ptr_t)(&dummy);
                    420:  *                 return(real_main(argc, argv, envp));
                    421:  *             }
                    422:  *
                    423:  *
                    424:  * Each architecture may also define the style of virtual dirty bit
                    425:  * implementation to be used:
                    426:  *   MPROTECT_VDB: Write protect the heap and catch faults.
                    427:  *   PROC_VDB: Use the SVR4 /proc primitives to read dirty bits.
                    428:  *
                    429:  * An architecture may define DYNAMIC_LOADING if dynamic_load.c
                    430:  * defined GC_register_dynamic_libraries() for the architecture.
                    431:  *
                    432:  * An architecture may define PREFETCH(x) to preload the cache with *x.
                    433:  * This defaults to a no-op.
                    434:  *
                    435:  * PREFETCH_FOR_WRITE(x) is used if *x is about to be written.
                    436:  *
                    437:  * An architecture may also define CLEAR_DOUBLE(x) to be a fast way to
                    438:  * clear the two words at GC_malloc-aligned address x.  By default,
                    439:  * word stores of 0 are used instead.
                    440:  */
                    441:
                    442:
                    443: # define STACK_GRAN 0x1000000
                    444: # ifdef M68K
                    445: #   define MACH_TYPE "M68K"
                    446: #   define ALIGNMENT 2
                    447: #   ifdef OPENBSD
                    448: #      define OS_TYPE "OPENBSD"
                    449: #      define HEURISTIC2
                    450:        extern char etext;
                    451: #      define DATASTART ((ptr_t)(&etext))
                    452: #   endif
                    453: #   ifdef NETBSD
                    454: #      define OS_TYPE "NETBSD"
                    455: #      define HEURISTIC2
                    456:        extern char etext;
                    457: #      define DATASTART ((ptr_t)(&etext))
                    458: #   endif
                    459: #   ifdef LINUX
                    460: #       define OS_TYPE "LINUX"
                    461: #       define STACKBOTTOM ((ptr_t)0xf0000000)
                    462: #       define MPROTECT_VDB
                    463: #       ifdef __ELF__
                    464: #            define DYNAMIC_LOADING
                    465:              extern char **__environ;
                    466: #            define DATASTART ((ptr_t)(&__environ))
                    467:                              /* hideous kludge: __environ is the first */
                    468:                              /* word in crt0.o, and delimits the start */
                    469:                              /* of the data segment, no matter which   */
                    470:                              /* ld options were passed through.        */
                    471:                              /* We could use _etext instead, but that  */
                    472:                              /* would include .rodata, which may       */
                    473:                              /* contain large read-only data tables    */
                    474:                              /* that we'd rather not scan.             */
                    475:              extern int _end;
                    476: #            define DATAEND (&_end)
                    477: #       else
                    478:              extern int etext;
                    479: #            define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
                    480: #       endif
                    481: #   endif
                    482: #   ifdef SUNOS4
                    483: #      define OS_TYPE "SUNOS4"
                    484:        extern char etext;
                    485: #      define DATASTART ((ptr_t)((((word) (&etext)) + 0x1ffff) & ~0x1ffff))
                    486: #      define HEURISTIC1       /* differs      */
                    487: #      define DYNAMIC_LOADING
                    488: #   endif
                    489: #   ifdef HP
                    490: #      define OS_TYPE "HP"
                    491:        extern char etext;
                    492: #       define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
                    493: #       define STACKBOTTOM ((ptr_t) 0xffeffffc)
                    494:                              /* empirically determined.  seems to work. */
                    495: #      include <unistd.h>
                    496: #      define GETPAGESIZE() sysconf(_SC_PAGE_SIZE)
                    497: #   endif
                    498: #   ifdef SYSV
                    499: #      define OS_TYPE "SYSV"
                    500:        extern etext;
                    501: #      define DATASTART ((ptr_t)((((word) (&etext)) + 0x3fffff) \
                    502:                                   & ~0x3fffff) \
                    503:                                  +((word)&etext & 0x1fff))
                    504:        /* This only works for shared-text binaries with magic number 0413.
                    505:           The other sorts of SysV binaries put the data at the end of the text,
                    506:           in which case the default of &etext would work.  Unfortunately,
                    507:           handling both would require having the magic-number available.
                    508:                                -- Parag
                    509:           */
                    510: #      define STACKBOTTOM ((ptr_t)0xFFFFFFFE)
                    511:                        /* The stack starts at the top of memory, but   */
                    512:                        /* 0x0 cannot be used as setjump_test complains */
                    513:                        /* that the stack direction is incorrect.  Two  */
                    514:                        /* bytes down from 0x0 should be safe enough.   */
                    515:                        /*              --Parag                         */
                    516: #      include <sys/mmu.h>
                    517: #      define GETPAGESIZE() PAGESIZE   /* Is this still right? */
                    518: #   endif
                    519: #   ifdef AMIGA
                    520: #      define OS_TYPE "AMIGA"
                    521:                /* STACKBOTTOM and DATASTART handled specially  */
                    522:                /* in os_dep.c                                  */
                    523: #      define DATAEND  /* not needed */
                    524: #      define GETPAGESIZE() 4096
                    525: #   endif
                    526: #   ifdef MACOS
                    527: #     ifndef __LOWMEM__
                    528: #     include <LowMem.h>
                    529: #     endif
                    530: #     define OS_TYPE "MACOS"
                    531:                        /* see os_dep.c for details of global data segments. */
                    532: #     define STACKBOTTOM ((ptr_t) LMGetCurStackBase())
                    533: #     define DATAEND   /* not needed */
                    534: #     define GETPAGESIZE() 4096
                    535: #   endif
                    536: #   ifdef NEXT
                    537: #      define OS_TYPE "NEXT"
                    538: #      define DATASTART ((ptr_t) get_etext())
                    539: #      define STACKBOTTOM ((ptr_t) 0x4000000)
                    540: #      define DATAEND  /* not needed */
                    541: #   endif
                    542: # endif
                    543:
                    544: # ifdef POWERPC
                    545: #   define MACH_TYPE "POWERPC"
                    546: #   ifdef MACOS
                    547: #     define ALIGNMENT 2  /* Still necessary?  Could it be 4?  */
                    548: #     ifndef __LOWMEM__
                    549: #     include <LowMem.h>
                    550: #     endif
                    551: #     define OS_TYPE "MACOS"
                    552:                        /* see os_dep.c for details of global data segments. */
                    553: #     define STACKBOTTOM ((ptr_t) LMGetCurStackBase())
                    554: #     define DATAEND  /* not needed */
                    555: #   endif
                    556: #   ifdef LINUX
                    557: #     define ALIGNMENT 4       /* Guess.  Can someone verify?  */
                    558:                                /* This was 2, but that didn't sound right. */
                    559: #     define OS_TYPE "LINUX"
                    560: #     define HEURISTIC1
                    561: #     define DYNAMIC_LOADING
                    562: #     undef STACK_GRAN
                    563: #     define STACK_GRAN 0x10000000
                    564:        /* Stack usually starts at 0x80000000 */
                    565: #     define LINUX_DATA_START
                    566:       extern int _end;
                    567: #     define DATAEND (&_end)
                    568: #   endif
                    569: #   ifdef MACOSX
                    570: #     define ALIGNMENT 4
                    571: #     define OS_TYPE "MACOSX"
                    572: #     define DATASTART ((ptr_t) get_etext())
                    573: #     define STACKBOTTOM ((ptr_t) 0xc0000000)
                    574: #     define DATAEND   /* not needed */
                    575: #   endif
                    576: # endif
                    577:
                    578: # ifdef VAX
                    579: #   define MACH_TYPE "VAX"
                    580: #   define ALIGNMENT 4 /* Pointers are longword aligned by 4.2 C compiler */
                    581:     extern char etext;
                    582: #   define DATASTART ((ptr_t)(&etext))
                    583: #   ifdef BSD
                    584: #      define OS_TYPE "BSD"
                    585: #      define HEURISTIC1
                    586:                        /* HEURISTIC2 may be OK, but it's hard to test. */
                    587: #   endif
                    588: #   ifdef ULTRIX
                    589: #      define OS_TYPE "ULTRIX"
                    590: #      define STACKBOTTOM ((ptr_t) 0x7fffc800)
                    591: #   endif
                    592: # endif
                    593:
                    594: # ifdef RT
                    595: #   define MACH_TYPE "RT"
                    596: #   define ALIGNMENT 4
                    597: #   define DATASTART ((ptr_t) 0x10000000)
                    598: #   define STACKBOTTOM ((ptr_t) 0x1fffd800)
                    599: # endif
                    600:
                    601: # ifdef SPARC
                    602: #   define MACH_TYPE "SPARC"
                    603: #   define ALIGNMENT 4 /* Required by hardware */
                    604: #   define ALIGN_DOUBLE
                    605:     extern int etext;
                    606: #   ifdef SUNOS5
                    607: #      define OS_TYPE "SUNOS5"
                    608:        extern int _etext;
                    609:        extern int _end;
                    610:        extern char * GC_SysVGetDataStart();
                    611: #       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &_etext)
                    612: #      define DATAEND (&_end)
                    613: #      ifndef USE_MMAP
                    614: #          define USE_MMAP
                    615: #      endif
                    616: #       ifdef USE_MMAP
                    617: #         define HEAP_START (ptr_t)0x40000000
                    618: #       else
                    619: #        define HEAP_START DATAEND
                    620: #       endif
                    621: #      define PROC_VDB
                    622: /*     HEURISTIC1 reportedly no longer works under 2.7.  Thus we       */
                    623: /*     switched to HEURISTIC2, eventhough it creates some debugging    */
                    624: /*     issues.                                                         */
1.4     ! noro      625: #if MPI
1.1       noro      626:        extern int *StackBottom;
                    627: #      define STACKBOTTOM (ptr_t)(StackBottom)
                    628: #else
                    629: #      define HEURISTIC2
                    630: #endif
                    631: #      include <unistd.h>
                    632: #       define GETPAGESIZE()  sysconf(_SC_PAGESIZE)
                    633:                /* getpagesize() appeared to be missing from at least one */
                    634:                /* Solaris 5.4 installation.  Weird.                      */
                    635: #      define DYNAMIC_LOADING
                    636: #   endif
                    637: #   ifdef SUNOS4
                    638: #      define OS_TYPE "SUNOS4"
                    639:        /* [If you have a weak stomach, don't read this.]               */
                    640:        /* We would like to use:                                        */
                    641: /* #       define DATASTART ((ptr_t)((((word) (&etext)) + 0x1fff) & ~0x1fff)) */
                    642:        /* This fails occasionally, due to an ancient, but very         */
                    643:        /* persistent ld bug.  &etext is set 32 bytes too high.         */
                    644:        /* We instead read the text segment size from the a.out         */
                    645:        /* header, which happens to be mapped into our address space    */
                    646:        /* at the start of the text segment.  The detective work here   */
                    647:        /* was done by Robert Ehrlich, Manuel Serrano, and Bernard      */
                    648:        /* Serpette of INRIA.                                           */
                    649:        /* This assumes ZMAGIC, i.e. demand-loadable executables.       */
                    650: #      define TEXTSTART 0x2000
                    651: #       define DATASTART ((ptr_t)(*(int *)(TEXTSTART+0x4)+TEXTSTART))
                    652: #      define MPROTECT_VDB
                    653: #      define HEURISTIC1
                    654: #      define DYNAMIC_LOADING
                    655: #   endif
                    656: #   ifdef DRSNX
                    657: #       define CPP_WORDSZ 32
                    658: #      define OS_TYPE "DRSNX"
                    659:        extern char * GC_SysVGetDataStart();
                    660:        extern int etext;
                    661: #       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &etext)
                    662: #      define MPROTECT_VDB
                    663: #       define STACKBOTTOM ((ptr_t) 0xdfff0000)
                    664: #      define DYNAMIC_LOADING
                    665: #   endif
                    666: #   ifdef LINUX
                    667: #     define OS_TYPE "LINUX"
                    668: #     ifdef __ELF__
                    669: #       define LINUX_DATA_START
                    670: #       define DYNAMIC_LOADING
                    671: #     else
                    672:           Linux Sparc non elf ?
                    673: #     endif
                    674:       extern int _end;
                    675: #     define DATAEND (&_end)
                    676: #     define SVR4
                    677: #     define STACKBOTTOM ((ptr_t) 0xf0000000)
                    678: #   endif
                    679: #   ifdef OPENBSD
                    680: #     define OS_TYPE "OPENBSD"
                    681: #     define STACKBOTTOM ((ptr_t) 0xf8000000)
                    682: #     define DATASTART ((ptr_t)(&etext))
                    683: #   endif
                    684: # endif
                    685:
                    686: # ifdef I386
                    687: #   define MACH_TYPE "I386"
                    688: #   define ALIGNMENT 4 /* Appears to hold for all "32 bit" compilers   */
                    689:                        /* except Borland.  The -a4 option fixes        */
                    690:                        /* Borland.                                     */
                    691:                         /* Ivan Demakov: For Watcom the option is -zp4. */
                    692: #   ifndef SMALL_CONFIG
                    693: #     define ALIGN_DOUBLE /* Not strictly necessary, but may give speed   */
                    694:                          /* improvement on Pentiums.                     */
                    695: #   endif
                    696: #   ifdef SEQUENT
                    697: #      define OS_TYPE "SEQUENT"
                    698:        extern int etext;
                    699: #       define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
                    700: #       define STACKBOTTOM ((ptr_t) 0x3ffff000)
                    701: #   endif
                    702: #   ifdef SUNOS5
                    703: #      define OS_TYPE "SUNOS5"
                    704:        extern int etext, _start;
                    705:        extern char * GC_SysVGetDataStart();
                    706: #       define DATASTART GC_SysVGetDataStart(0x1000, &etext)
                    707: #      define STACKBOTTOM ((ptr_t)(&_start))
                    708: /** At least in Solaris 2.5, PROC_VDB gives wrong values for dirty bits. */
                    709: /*#    define PROC_VDB*/
                    710: #      define DYNAMIC_LOADING
                    711: #      ifndef USE_MMAP
                    712: #          define USE_MMAP
                    713: #      endif
                    714: #       ifdef USE_MMAP
                    715: #         define HEAP_START (ptr_t)0x40000000
                    716: #       else
                    717: #        define HEAP_START DATAEND
                    718: #       endif
                    719: #   endif
                    720: #   ifdef SCO
                    721: #      define OS_TYPE "SCO"
                    722:        extern int etext;
                    723: #      define DATASTART ((ptr_t)((((word) (&etext)) + 0x3fffff) \
                    724:                                  & ~0x3fffff) \
                    725:                                 +((word)&etext & 0xfff))
                    726: #      define STACKBOTTOM ((ptr_t) 0x7ffffffc)
                    727: #   endif
                    728: #   ifdef SCO_ELF
                    729: #       define OS_TYPE "SCO_ELF"
                    730:         extern int etext;
                    731: #       define DATASTART ((ptr_t)(&etext))
                    732: #       define STACKBOTTOM ((ptr_t) 0x08048000)
                    733: #       define DYNAMIC_LOADING
                    734: #      define ELF_CLASS ELFCLASS32
                    735: #   endif
                    736: #   ifdef LINUX
                    737: #      define OS_TYPE "LINUX"
                    738: #   define USE_MMAP
1.2       noro      739: #   define HEAP_START 0x40000000
1.1       noro      740: #       define LINUX_STACKBOTTOM
                    741: #      if 0
                    742: #        define HEURISTIC1
                    743: #         undef STACK_GRAN
                    744: #         define STACK_GRAN 0x10000000
                    745:          /* STACKBOTTOM is usually 0xc0000000, but this changes with   */
                    746:          /* different kernel configurations.  In particular, systems   */
                    747:          /* with 2GB physical memory will usually move the user        */
                    748:          /* address space limit, and hence initial SP to 0x80000000.   */
                    749: #       endif
                    750: #       if !defined(LINUX_THREADS) || !defined(REDIRECT_MALLOC)
                    751: #          define MPROTECT_VDB
                    752: #      else
                    753:            /* We seem to get random errors in incremental mode,        */
                    754:            /* possibly because Linux threads is itself a malloc client */
                    755:            /* and can't deal with the signals.                         */
                    756: #      endif
                    757: #       ifdef __ELF__
                    758: #            define DYNAMIC_LOADING
                    759: #           ifdef UNDEFINED    /* includes ro data */
                    760:               extern int _etext;
                    761: #              define DATASTART ((ptr_t)((((word) (&_etext)) + 0xfff) & ~0xfff))
                    762: #           endif
                    763: #           include <features.h>
                    764: #           if defined(__GLIBC__) && __GLIBC__ >= 2
                    765: #               define LINUX_DATA_START
                    766: #           else
                    767:                 extern char **__environ;
                    768: #                define DATASTART ((ptr_t)(&__environ))
                    769:                              /* hideous kludge: __environ is the first */
                    770:                              /* word in crt0.o, and delimits the start */
                    771:                              /* of the data segment, no matter which   */
                    772:                              /* ld options were passed through.        */
                    773:                              /* We could use _etext instead, but that  */
                    774:                              /* would include .rodata, which may       */
                    775:                              /* contain large read-only data tables    */
                    776:                              /* that we'd rather not scan.             */
                    777: #           endif
                    778:             extern int _end;
                    779: #           define DATAEND (&_end)
                    780: #      else
                    781:             extern int etext;
                    782: #            define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
                    783: #       endif
                    784: #      ifdef USE_I686_PREFETCH
                    785: #        define PREFETCH(x) \
                    786:            __asm__ __volatile__ ("     prefetchnta     %0": : "m"(*(char *)(x)))
                    787:            /* Empirically prefetcht0 is much more effective at reducing        */
                    788:            /* cache miss stalls for the targetted load instructions.  But it   */
                    789:            /* seems to interfere enough with other cache traffic that the net  */
                    790:            /* result is worse than prefetchnta.                                */
                    791: #         if 0
                    792:            /* Using prefetches for write seems to have a slight negative       */
                    793:            /* impact on performance, at least for a PIII/500.                  */
                    794: #          define PREFETCH_FOR_WRITE(x) \
                    795:              __asm__ __volatile__ ("   prefetcht0      %0": : "m"(*(char *)(x)))
                    796: #        endif
                    797: #      endif
                    798: #      ifdef USE_3DNOW_PREFETCH
                    799: #        define PREFETCH(x) \
                    800:            __asm__ __volatile__ ("     prefetch        %0": : "m"(*(char *)(x)))
                    801: #        define PREFETCH_FOR_WRITE(x)
                    802:            __asm__ __volatile__ ("     prefetchw       %0": : "m"(*(char *)(x)))
                    803: #      endif
                    804: #   endif
                    805: #   ifdef CYGWIN32
                    806: #       define OS_TYPE "CYGWIN32"
                    807:           extern int _data_start__;
                    808:           extern int _data_end__;
                    809:           extern int _bss_start__;
                    810:           extern int _bss_end__;
                    811:        /* For binutils 2.9.1, we have                  */
                    812:        /*      DATASTART   = _data_start__             */
                    813:        /*      DATAEND     = _bss_end__                */
                    814:        /* whereas for some earlier versions it was     */
                    815:        /*      DATASTART   = _bss_start__              */
                    816:        /*      DATAEND     = _data_end__               */
                    817:        /* To get it right for both, we take the        */
                    818:        /* minumum/maximum of the two.                  */
                    819: #      define MAX(x,y) ((x) > (y) ? (x) : (y))
                    820: #      define MIN(x,y) ((x) < (y) ? (x) : (y))
                    821: #       define DATASTART ((ptr_t) MIN(&_data_start__, &_bss_start__))
                    822: #       define DATAEND  ((ptr_t) MAX(&_data_end__, &_bss_end__))
                    823: #      undef STACK_GRAN
                    824: #       define STACK_GRAN 0x10000
                    825: #       define HEURISTIC1
                    826: #   endif
                    827: #   ifdef OS2
                    828: #      define OS_TYPE "OS2"
                    829:                /* STACKBOTTOM and DATASTART are handled specially in   */
                    830:                /* os_dep.c. OS2 actually has the right                 */
                    831:                /* system call!                                         */
                    832: #      define DATAEND  /* not needed */
                    833: #   endif
                    834: #   ifdef MSWIN32
                    835: #      define OS_TYPE "MSWIN32"
                    836:                /* STACKBOTTOM and DATASTART are handled specially in   */
                    837:                /* os_dep.c.                                            */
                    838: #       ifndef __WATCOMC__
                    839: #        define MPROTECT_VDB
                    840: #      endif
                    841: #       define DATAEND  /* not needed */
                    842: #   endif
                    843: #   ifdef DJGPP
                    844: #       define OS_TYPE "DJGPP"
                    845: #       include "stubinfo.h"
                    846:         extern int etext;
                    847:         extern int _stklen;
                    848:         extern int __djgpp_stack_limit;
                    849: #       define DATASTART ((ptr_t)((((word) (&etext)) + 0x1ff) & ~0x1ff))
                    850: /* #       define STACKBOTTOM ((ptr_t)((word) _stubinfo + _stubinfo->size \
                    851:                                                      + _stklen)) */
                    852: #       define STACKBOTTOM ((ptr_t)((word) __djgpp_stack_limit + _stklen))
                    853:                /* This may not be right.  */
                    854: #   endif
                    855: #   ifdef OPENBSD
                    856: #      define OS_TYPE "OPENBSD"
                    857: #   endif
                    858: #   ifdef FREEBSD
                    859: #      define OS_TYPE "FREEBSD"
                    860: #      define MPROTECT_VDB
                    861: #   endif
                    862: #   ifdef NETBSD
                    863: #      define OS_TYPE "NETBSD"
                    864: #   endif
                    865: #   ifdef THREE86BSD
                    866: #      define OS_TYPE "THREE86BSD"
                    867: #   endif
                    868: #   ifdef BSDI
                    869: #      define OS_TYPE "BSDI"
                    870: #   endif
                    871: #   if defined(OPENBSD) || defined(FREEBSD) || defined(NETBSD) \
                    872:         || defined(THREE86BSD) || defined(BSDI)
                    873: #      define HEURISTIC2
                    874:        extern char etext;
                    875: #      define DATASTART ((ptr_t)(&etext))
                    876: #   endif
                    877: #   ifdef NEXT
                    878: #      define OS_TYPE "NEXT"
                    879: #      define DATASTART ((ptr_t) get_etext())
                    880: #      define STACKBOTTOM ((ptr_t)0xc0000000)
                    881: #      define DATAEND  /* not needed */
                    882: #   endif
                    883: #   ifdef DOS4GW
                    884: #     define OS_TYPE "DOS4GW"
                    885:       extern long __nullarea;
                    886:       extern char _end;
                    887:       extern char *_STACKTOP;
                    888:       /* Depending on calling conventions Watcom C either precedes
                    889:          or does not precedes with undescore names of C-variables.
                    890:          Make sure startup code variables always have the same names.  */
                    891:       #pragma aux __nullarea "*";
                    892:       #pragma aux _end "*";
                    893: #     define STACKBOTTOM ((ptr_t) _STACKTOP)
                    894:                          /* confused? me too. */
                    895: #     define DATASTART ((ptr_t) &__nullarea)
                    896: #     define DATAEND ((ptr_t) &_end)
                    897: #   endif
                    898: # endif
                    899:
                    900: # ifdef NS32K
                    901: #   define MACH_TYPE "NS32K"
                    902: #   define ALIGNMENT 4
                    903:     extern char **environ;
                    904: #   define DATASTART ((ptr_t)(&environ))
                    905:                              /* hideous kludge: environ is the first   */
                    906:                              /* word in crt0.o, and delimits the start */
                    907:                              /* of the data segment, no matter which   */
                    908:                              /* ld options were passed through.        */
                    909: #   define STACKBOTTOM ((ptr_t) 0xfffff000) /* for Encore */
                    910: # endif
                    911:
                    912: # ifdef MIPS
                    913: #   define MACH_TYPE "MIPS"
                    914: /* #   define STACKBOTTOM ((ptr_t)0x7fff8000)  sometimes also works.  */
                    915: #   ifdef LINUX
                    916:       /* This was developed for a linuxce style platform.  Probably    */
                    917:       /* needs to be tweaked for workstation class machines.           */
                    918: #     define OS_TYPE "LINUX"
                    919:       extern int __data_start;
                    920: #     define DATASTART ((ptr_t)(&__data_start))
                    921: #     define ALIGNMENT 4
                    922: #     define USE_GENERIC_PUSH_REGS 1
                    923: #     define STACKBOTTOM 0x80000000
                    924:        /* In many cases, this should probably use LINUX_STACKBOTTOM    */
                    925:        /* instead. But some kernel versions seem to give the wrong     */
                    926:        /* value from /proc.                                            */
                    927: #   endif /* Linux */
                    928: #   ifdef ULTRIX
                    929: #      define HEURISTIC2
                    930: #       define DATASTART (ptr_t)0x10000000
                    931:                              /* Could probably be slightly higher since */
                    932:                              /* startup code allocates lots of stuff.   */
                    933: #      define OS_TYPE "ULTRIX"
                    934: #       define ALIGNMENT 4
                    935: #   endif
                    936: #   ifdef RISCOS
                    937: #      define HEURISTIC2
                    938: #       define DATASTART (ptr_t)0x10000000
                    939: #      define OS_TYPE "RISCOS"
                    940: #      define ALIGNMENT 4  /* Required by hardware */
                    941: #   endif
                    942: #   ifdef IRIX5
                    943: #      define HEURISTIC2
                    944:         extern int _fdata;
                    945: #       define DATASTART ((ptr_t)(&_fdata))
                    946: #       ifdef USE_MMAP
                    947: #         define HEAP_START (ptr_t)0x30000000
                    948: #       else
                    949: #        define HEAP_START DATASTART
                    950: #       endif
                    951:                              /* Lowest plausible heap address.         */
                    952:                              /* In the MMAP case, we map there.        */
                    953:                              /* In either case it is used to identify  */
                    954:                              /* heap sections so they're not           */
                    955:                              /* considered as roots.                   */
                    956: #      define OS_TYPE "IRIX5"
                    957: #       define MPROTECT_VDB
                    958: #       ifdef _MIPS_SZPTR
                    959: #        define CPP_WORDSZ _MIPS_SZPTR
                    960: #        define ALIGNMENT (_MIPS_SZPTR/8)
                    961: #        if CPP_WORDSZ != 64
                    962: #          define ALIGN_DOUBLE
                    963: #        endif
                    964: #      else
                    965: #         define ALIGNMENT 4
                    966: #        define ALIGN_DOUBLE
                    967: #      endif
                    968: #      define DYNAMIC_LOADING
                    969: #   endif
                    970: # endif
                    971:
                    972: # ifdef RS6000
                    973: #   define MACH_TYPE "RS6000"
                    974: #   define ALIGNMENT 4
                    975: #   define DATASTART ((ptr_t)0x20000000)
                    976:     extern int errno;
                    977: #   define STACKBOTTOM ((ptr_t)((ulong)&errno))
                    978: #   define DYNAMIC_LOADING
                    979:        /* For really old versions of AIX, this may have to be removed. */
                    980: # endif
                    981:
                    982: # ifdef HP_PA
                    983:     /* OS is assumed to be HP/UX       */
                    984: #   define MACH_TYPE "HP_PA"
                    985: #   define OS_TYPE "HPUX"
                    986: #   ifdef __LP64__
                    987: #     define CPP_WORDSZ 64
                    988: #     define ALIGNMENT 8
                    989: #   else
                    990: #     define CPP_WORDSZ 32
                    991: #     define ALIGNMENT 4
                    992: #     define ALIGN_DOUBLE
                    993: #   endif
                    994:     extern int __data_start;
                    995: #   define DATASTART ((ptr_t)(&__data_start))
                    996: #   if 0
                    997:        /* The following appears to work for 7xx systems running HP/UX  */
                    998:        /* 9.xx Furthermore, it might result in much faster             */
                    999:        /* collections than HEURISTIC2, which may involve scanning      */
                   1000:        /* segments that directly precede the stack.  It is not the     */
                   1001:        /* default, since it may not work on older machine/OS           */
                   1002:        /* combinations. (Thanks to Raymond X.T. Nijssen for uncovering */
                   1003:        /* this.)                                                       */
                   1004: #       define STACKBOTTOM ((ptr_t) 0x7b033000)  /* from /etc/conf/h/param.h */
                   1005: #   else
                   1006:        /* Gustavo Rodriguez-Rivera suggested changing HEURISTIC2       */
                   1007:        /* to this.  We'll probably do this on other platforms, too.    */
                   1008:        /* For now I'll use it where I can test it.                     */
                   1009:        extern char ** environ;
                   1010: #       define STACKBOTTOM ((ptr_t)environ)
                   1011: #   endif
                   1012: #   define STACK_GROWS_UP
                   1013: #   define DYNAMIC_LOADING
                   1014: #   ifndef HPUX_THREADS
                   1015: #     define MPROTECT_VDB
                   1016: #   endif
                   1017: #   include <unistd.h>
                   1018: #   define GETPAGESIZE() sysconf(_SC_PAGE_SIZE)
                   1019: # endif
                   1020:
                   1021: # ifdef ALPHA
                   1022: #   define MACH_TYPE "ALPHA"
                   1023: #   define ALIGNMENT 8
                   1024: #   define USE_GENERIC_PUSH_REGS
                   1025:        /* Gcc and probably the DEC/Compaq compiler spill pointers to preserved */
                   1026:        /* fp registers in some cases when the target is a 21264.  The assembly */
                   1027:        /* code doesn't handle that yet, and version dependencies make that a   */
                   1028:        /* bit tricky.  Do the easy thing for now.                              */
                   1029: #   ifdef OSF1
                   1030: #      define OS_TYPE "OSF1"
                   1031: #      define DATASTART ((ptr_t) 0x140000000)
                   1032:        extern int _end;
                   1033: #      define DATAEND ((ptr_t) &_end)
                   1034: #      define HEURISTIC2
                   1035:        /* Normally HEURISTIC2 is too conervative, since                */
                   1036:        /* the text segment immediately follows the stack.              */
                   1037:        /* Hence we give an upper pound.                                */
                   1038:        extern int __start;
                   1039: #      define HEURISTIC2_LIMIT ((ptr_t)((word)(&__start) & ~(getpagesize()-1)))
                   1040: #      define CPP_WORDSZ 64
                   1041: #      define MPROTECT_VDB
                   1042: #      define DYNAMIC_LOADING
                   1043: #   endif
                   1044: #   ifdef LINUX
                   1045: #       define OS_TYPE "LINUX"
                   1046: #       define CPP_WORDSZ 64
                   1047: #       define STACKBOTTOM ((ptr_t) 0x120000000)
                   1048: #       ifdef __ELF__
                   1049: #        define LINUX_DATA_START
                   1050: #         define DYNAMIC_LOADING
                   1051:          /* This doesn't work if the collector is in a dynamic library. */
                   1052: #       else
                   1053: #           define DATASTART ((ptr_t) 0x140000000)
                   1054: #       endif
                   1055:        extern int _end;
                   1056: #      define DATAEND (&_end)
                   1057: #      define MPROTECT_VDB
                   1058:                /* Has only been superficially tested.  May not */
                   1059:                /* work on all versions.                        */
                   1060: #   endif
                   1061: # endif
                   1062:
                   1063: # ifdef IA64
                   1064: #   define MACH_TYPE "IA64"
                   1065: #   define ALIGN_DOUBLE
                   1066:        /* Requires 16 byte alignment for malloc */
                   1067: #   define ALIGNMENT 8
                   1068: #   define USE_GENERIC_PUSH_REGS
                   1069:        /* We need to get preserved registers in addition to register windows.  */
                   1070:        /* That's easiest to do with setjmp.                                    */
                   1071: #   ifdef HPUX
                   1072:        --> needs work
                   1073: #   endif
                   1074: #   ifdef LINUX
                   1075: #       define OS_TYPE "LINUX"
                   1076: #       define CPP_WORDSZ 64
                   1077:        /* This should really be done through /proc, but that   */
                   1078:        /* requires we run on an IA64 kernel.                   */
                   1079: #       define STACKBOTTOM ((ptr_t) 0xa000000000000000l)
                   1080:        /* We also need the base address of the register stack  */
                   1081:        /* backing store.  There is probably a better way to    */
                   1082:        /* get that, too ...                                    */
                   1083: #      define BACKING_STORE_BASE ((ptr_t) 0x9fffffff80000000l)
                   1084: #      if 1
                   1085: #          define SEARCH_FOR_DATA_START
                   1086: #          define DATASTART GC_data_start
                   1087: #      else
                   1088:            extern int data_start;
                   1089: #          define DATASTART ((ptr_t)(&data_start))
                   1090: #      endif
                   1091: #       define DYNAMIC_LOADING
                   1092: #      define MPROTECT_VDB
                   1093:                /* Requires Linux 2.3.47 or later.      */
                   1094:        extern int _end;
                   1095: #      define DATAEND (&_end)
                   1096: #      define PREFETCH(x) \
                   1097:          __asm__ ("    lfetch  [%0]": : "r"((void *)(x)))
                   1098: #      define PREFETCH_FOR_WRITE(x) \
                   1099:          __asm__ ("    lfetch.excl     [%0]": : "r"((void *)(x)))
                   1100: #      define CLEAR_DOUBLE(x) \
                   1101:          __asm__ ("    stf.spill       [%0]=f0": : "r"((void *)(x)))
                   1102: #   endif
                   1103: # endif
                   1104:
                   1105: # ifdef M88K
                   1106: #   define MACH_TYPE "M88K"
                   1107: #   define ALIGNMENT 4
                   1108: #   define ALIGN_DOUBLE
                   1109:     extern int etext;
                   1110: #   ifdef CX_UX
                   1111: #      define OS_TYPE "CX_UX"
                   1112: #       define DATASTART ((((word)&etext + 0x3fffff) & ~0x3fffff) + 0x10000)
                   1113: #   endif
                   1114: #   ifdef  DGUX
                   1115: #      define OS_TYPE "DGUX"
                   1116:        extern char * GC_SysVGetDataStart();
                   1117: #       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &etext)
                   1118: #   endif
                   1119: #   define STACKBOTTOM ((char*)0xf0000000) /* determined empirically */
                   1120: # endif
                   1121:
                   1122: # ifdef S370
                   1123: #   define MACH_TYPE "S370"
                   1124: #   define OS_TYPE "UTS4"
                   1125: #   define ALIGNMENT 4 /* Required by hardware */
                   1126:     extern int etext;
                   1127:        extern int _etext;
                   1128:        extern int _end;
                   1129:        extern char * GC_SysVGetDataStart();
                   1130: #       define DATASTART (ptr_t)GC_SysVGetDataStart(0x10000, &_etext)
                   1131: #      define DATAEND (&_end)
                   1132: #      define HEURISTIC2
                   1133: # endif
                   1134:
                   1135: # if defined(PJ)
                   1136: #   define ALIGNMENT 4
                   1137:     extern int _etext;
                   1138: #   define DATASTART ((ptr_t)(&_etext))
                   1139: #   define HEURISTIC1
                   1140: # endif
                   1141:
                   1142: # ifdef ARM32
                   1143: #   define CPP_WORDSZ 32
                   1144: #   define MACH_TYPE "ARM32"
                   1145: #   define ALIGNMENT 4
                   1146: #   ifdef NETBSD
                   1147: #       define OS_TYPE "NETBSD"
                   1148: #       define HEURISTIC2
                   1149:         extern char etext;
                   1150: #       define DATASTART ((ptr_t)(&etext))
                   1151: #       define USE_GENERIC_PUSH_REGS
                   1152: #   endif
                   1153: #   ifdef LINUX
                   1154: #       define OS_TYPE "LINUX"
                   1155: #       define HEURISTIC1
                   1156: #       undef STACK_GRAN
                   1157: #       define STACK_GRAN 0x10000000
                   1158: #       define USE_GENERIC_PUSH_REGS
                   1159: #       ifdef __ELF__
                   1160: #            define DYNAMIC_LOADING
                   1161: #           include <features.h>
                   1162: #           if defined(__GLIBC__) && __GLIBC__ >= 2
                   1163: #               define LINUX_DATA_START
                   1164: #           else
                   1165:                 extern char **__environ;
                   1166: #                define DATASTART ((ptr_t)(&__environ))
                   1167:                              /* hideous kludge: __environ is the first */
                   1168:                              /* word in crt0.o, and delimits the start */
                   1169:                              /* of the data segment, no matter which   */
                   1170:                              /* ld options were passed through.        */
                   1171:                              /* We could use _etext instead, but that  */
                   1172:                              /* would include .rodata, which may       */
                   1173:                              /* contain large read-only data tables    */
                   1174:                              /* that we'd rather not scan.             */
                   1175: #           endif
                   1176:             extern int _end;
                   1177: #           define DATAEND (&_end)
                   1178: #      else
                   1179:             extern int etext;
                   1180: #            define DATASTART ((ptr_t)((((word) (&etext)) + 0xfff) & ~0xfff))
                   1181: #       endif
                   1182: #   endif
                   1183: #endif
                   1184:
                   1185: #ifdef LINUX_DATA_START
                   1186:     /* Some Linux distributions arrange to define __data_start.  Some  */
                   1187:     /* define data_start as a weak symbol.  The latter is technically  */
                   1188:     /* broken, since the user program may define data_start, in which  */
                   1189:     /* case we lose.  Nonetheless, we try both, prefering __data_start.        */
                   1190:     /* We assume gcc.  */
                   1191: #   pragma weak __data_start
                   1192:     extern int __data_start;
                   1193: #   pragma weak data_start
                   1194:     extern int data_start;
                   1195: #   define DATASTART ((ptr_t)(&__data_start != 0? &__data_start : &data_start))
                   1196: #endif
                   1197:
                   1198: # ifndef STACK_GROWS_UP
                   1199: #   define STACK_GROWS_DOWN
                   1200: # endif
                   1201:
                   1202: # ifndef CPP_WORDSZ
                   1203: #   define CPP_WORDSZ 32
                   1204: # endif
                   1205:
                   1206: # ifndef OS_TYPE
                   1207: #   define OS_TYPE ""
                   1208: # endif
                   1209:
                   1210: # ifndef DATAEND
                   1211:     extern int end;
                   1212: #   define DATAEND (&end)
                   1213: # endif
                   1214:
                   1215: # if defined(SVR4) && !defined(GETPAGESIZE)
                   1216: #    include <unistd.h>
                   1217: #    define GETPAGESIZE()  sysconf(_SC_PAGESIZE)
                   1218: # endif
                   1219:
                   1220: # ifndef GETPAGESIZE
                   1221: #   if defined(SUNOS5) || defined(IRIX5)
                   1222: #      include <unistd.h>
                   1223: #   endif
                   1224: #   define GETPAGESIZE() getpagesize()
                   1225: # endif
                   1226:
                   1227: # if defined(SUNOS5) || defined(DRSNX) || defined(UTS4)
                   1228:     /* OS has SVR4 generic features.  Probably others also qualify.    */
                   1229: #   define SVR4
                   1230: # endif
                   1231:
                   1232: # if defined(SUNOS5) || defined(DRSNX)
                   1233:     /* OS has SUNOS5 style semi-undocumented interface to dynamic      */
                   1234:     /* loader.                                                         */
                   1235: #   define SUNOS5DL
                   1236:     /* OS has SUNOS5 style signal handlers.                            */
                   1237: #   define SUNOS5SIGS
                   1238: # endif
                   1239:
                   1240: # if defined(HPUX)
                   1241: #   define SUNOS5SIGS
                   1242: # endif
                   1243:
                   1244: # if CPP_WORDSZ != 32 && CPP_WORDSZ != 64
                   1245:    -> bad word size
                   1246: # endif
                   1247:
                   1248: # ifdef PCR
                   1249: #   undef DYNAMIC_LOADING
                   1250: #   undef STACKBOTTOM
                   1251: #   undef HEURISTIC1
                   1252: #   undef HEURISTIC2
                   1253: #   undef PROC_VDB
                   1254: #   undef MPROTECT_VDB
                   1255: #   define PCR_VDB
                   1256: # endif
                   1257:
                   1258: # ifdef SRC_M3
                   1259: /* Postponed for now. */
                   1260: #   undef PROC_VDB
                   1261: #   undef MPROTECT_VDB
                   1262: # endif
                   1263:
                   1264: # ifdef SMALL_CONFIG
                   1265: /* Presumably not worth the space it takes. */
                   1266: #   undef PROC_VDB
                   1267: #   undef MPROTECT_VDB
                   1268: # endif
                   1269:
                   1270: # ifdef USE_MUNMAP
                   1271: #   undef MPROTECT_VDB  /* Can't deal with address space holes. */
                   1272: # endif
                   1273:
                   1274: # if !defined(PCR_VDB) && !defined(PROC_VDB) && !defined(MPROTECT_VDB)
                   1275: #   define DEFAULT_VDB
                   1276: # endif
                   1277:
                   1278: # ifndef PREFETCH
                   1279: #   define PREFETCH(x)
                   1280: #   define NO_PREFETCH
                   1281: # endif
                   1282:
                   1283: # ifndef PREFETCH_FOR_WRITE
                   1284: #   define PREFETCH_FOR_WRITE(x)
                   1285: #   define NO_PREFETCH_FOR_WRITE
                   1286: # endif
                   1287:
                   1288: # ifndef CACHE_LINE_SIZE
                   1289: #   define CACHE_LINE_SIZE 32  /* Wild guess   */
                   1290: # endif
                   1291:
                   1292: # ifndef CLEAR_DOUBLE
                   1293: #   define CLEAR_DOUBLE(x) \
                   1294:        ((word*)x)[0] = 0; \
                   1295:        ((word*)x)[1] = 0;
                   1296: # endif /* CLEAR_DOUBLE */
                   1297:
                   1298: # if defined(_SOLARIS_PTHREADS) && !defined(SOLARIS_THREADS)
                   1299: #   define SOLARIS_THREADS
                   1300: # endif
                   1301: # if defined(IRIX_THREADS) && !defined(IRIX5)
                   1302: --> inconsistent configuration
                   1303: # endif
                   1304: # if defined(IRIX_JDK_THREADS) && !defined(IRIX5)
                   1305: --> inconsistent configuration
                   1306: # endif
                   1307: # if defined(LINUX_THREADS) && !defined(LINUX)
                   1308: --> inconsistent configuration
                   1309: # endif
                   1310: # if defined(SOLARIS_THREADS) && !defined(SUNOS5)
                   1311: --> inconsistent configuration
                   1312: # endif
                   1313: # if defined(HPUX_THREADS) && !defined(HPUX)
                   1314: --> inconsistent configuration
                   1315: # endif
                   1316: # if defined(PCR) || defined(SRC_M3) || \
                   1317:        defined(SOLARIS_THREADS) || defined(WIN32_THREADS) || \
                   1318:        defined(IRIX_THREADS) || defined(LINUX_THREADS) || \
                   1319:        defined(IRIX_JDK_THREADS) || defined(HPUX_THREADS)
                   1320: #   define THREADS
                   1321: # endif
                   1322:
                   1323: # if defined(HP_PA) || defined(M88K) || defined(POWERPC) \
                   1324:      || (defined(I386) && defined(OS2)) || defined(UTS4) || defined(LINT)
                   1325:        /* Use setjmp based hack to mark from callee-save registers. */
                   1326: #      define USE_GENERIC_PUSH_REGS
                   1327: # endif
                   1328: # if defined(SPARC) && !defined(LINUX)
                   1329: #   define SAVE_CALL_CHAIN
                   1330: #   define ASM_CLEAR_CODE      /* Stack clearing is crucial, and we    */
                   1331:                                /* include assembly code to do it well. */
                   1332: # endif
                   1333:
                   1334: # endif /* GCCONFIG_H */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>