X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fsystem.h;h=a00c0d37d42e52f79ceebd702dd12961ad59e489;hb=0e7bd0dd7612870c454efdfb4ba114894972efe4;hp=410c280597e547c479c33c052691c14b1b5cb927;hpb=1289ba6e773f70b8f31e1fec3ebccf475be3bd2b;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/system.h b/gcc/system.h index 410c280597e..a00c0d37d42 100644 --- a/gcc/system.h +++ b/gcc/system.h @@ -1,39 +1,30 @@ /* Get common system includes and various definitions and declarations based on autoconf macros. - Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc. + Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. -This file is part of GNU CC. +This file is part of GCC. -GNU CC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2, or (at your option) -any later version. +GCC is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 2, or (at your option) any later +version. -GNU CC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. +GCC is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +for more details. You should have received a copy of the GNU General Public License -along with GNU CC; see the file COPYING. If not, write to -the Free Software Foundation, 59 Temple Place - Suite 330, -Boston, MA 02111-1307, USA. */ +along with GCC; see the file COPYING. If not, write to the Free +Software Foundation, 59 Temple Place - Suite 330, Boston, MA +02111-1307, USA. */ -#ifndef __GCC_SYSTEM_H__ -#define __GCC_SYSTEM_H__ +#ifndef GCC_SYSTEM_H +#define GCC_SYSTEM_H -/* This is the location of the online document giving information how - to report bugs. If you change this string, also check for strings - not under control of the preprocessor. */ -#define GCCBUGURL "" - -/* We must include stdarg.h/varargs.h before stdio.h. */ -#ifdef ANSI_PROTOTYPES +/* We must include stdarg.h before stdio.h. */ #include -#else -#include -#endif #ifndef va_copy # ifdef __va_copy @@ -43,6 +34,10 @@ Boston, MA 02111-1307, USA. */ # endif #endif +#ifdef HAVE_STDDEF_H +# include +#endif + #include /* Define a generic NULL if one hasn't already been defined. */ @@ -51,127 +46,77 @@ Boston, MA 02111-1307, USA. */ #endif /* The compiler is not a multi-threaded application and therefore we - do not have to use the locking functions. + do not have to use the locking functions. In fact, using the locking + functions can cause the compiler to be significantly slower under + I/O bound conditions (such as -g -O0 on very large source files). - HAVE_DECL_PUTC_UNLOCKED actually indicates whether or not the IO + HAVE_DECL_PUTC_UNLOCKED actually indicates whether or not the stdio code is multi-thread safe by default. If it is set to 0, then do not worry about using the _unlocked functions. - - fputs_unlocked is an extension and needs to be prototyped specially. */ - -#if defined HAVE_PUTC_UNLOCKED && (defined (HAVE_DECL_PUTC_UNLOCKED) && HAVE_DECL_PUTC_UNLOCKED) -# undef putc -# define putc(C, Stream) putc_unlocked (C, Stream) -#endif -#if defined HAVE_FPUTC_UNLOCKED && (defined (HAVE_DECL_PUTC_UNLOCKED) && HAVE_DECL_PUTC_UNLOCKED) -# undef fputc -# define fputc(C, Stream) fputc_unlocked (C, Stream) -#endif -#if defined HAVE_FPUTS_UNLOCKED && (defined (HAVE_DECL_PUTC_UNLOCKED) && HAVE_DECL_PUTC_UNLOCKED) -# undef fputs -# define fputs(String, Stream) fputs_unlocked (String, Stream) -# if defined (HAVE_DECL_FPUTS_UNLOCKED) && !HAVE_DECL_FPUTS_UNLOCKED -extern int fputs_unlocked PARAMS ((const char *, FILE *)); -# endif -#endif - -#include - -/* Jim Meyering writes: - "... Some ctype macros are valid only for character codes that - isascii says are ASCII (SGI's IRIX-4.0.5 is one such system --when - using /bin/cc or gcc but without giving an ansi option). So, all - ctype uses should be through macros like ISPRINT... If - STDC_HEADERS is defined, then autoconf has verified that the ctype - macros don't need to be guarded with references to isascii. ... - Defining isascii to 1 should let any compiler worth its salt - eliminate the && through constant folding." + fputs_unlocked, fwrite_unlocked, and fprintf_unlocked are + extensions and need to be prototyped by hand (since we do not + define _GNU_SOURCE). */ - Bruno Haible adds: - - "... Furthermore, isupper(c) etc. have an undefined result if c is - outside the range -1 <= c <= 255. One is tempted to write isupper(c) - with c being of type `char', but this is wrong if c is an 8-bit - character >= 128 which gets sign-extended to a negative value. - The macro ISUPPER protects against this as well." */ - -#if defined (STDC_HEADERS) || (!defined (isascii) && !defined (HAVE_ISASCII)) || defined(HOST_EBCDIC) -# define IN_CTYPE_DOMAIN(c) 1 -#else -# define IN_CTYPE_DOMAIN(c) isascii(c) -#endif - -/* The ctype functions are often implemented as macros which do - lookups in arrays using the parameter as the offset. If the ctype - function parameter is a char, then gcc will (appropriately) warn - that a "subscript has type char". Using a (signed) char as a subscript - is bad because you may get negative offsets and thus it is not 8-bit - safe. The CTYPE_CONV macro ensures that the parameter is cast to an - unsigned char when a char is passed in. When an int is passed in, the - parameter is left alone so we don't lose EOF. -*/ - -#define CTYPE_CONV(CH) \ - (sizeof(CH) == sizeof(unsigned char) ? (int)(unsigned char)(CH) : (int)(CH)) +#if defined HAVE_DECL_PUTC_UNLOCKED && HAVE_DECL_PUTC_UNLOCKED +# ifdef HAVE_PUTC_UNLOCKED +# undef putc +# define putc(C, Stream) putc_unlocked (C, Stream) +# endif +# ifdef HAVE_FPUTC_UNLOCKED +# undef fputc +# define fputc(C, Stream) fputc_unlocked (C, Stream) +# endif -/* WARNING! The argument to the ctype replacement macros below is - evaluated more than once so it must not have side effects! */ +# ifdef HAVE_FPUTS_UNLOCKED +# undef fputs +# define fputs(String, Stream) fputs_unlocked (String, Stream) +# if defined (HAVE_DECL_FPUTS_UNLOCKED) && !HAVE_DECL_FPUTS_UNLOCKED +extern int fputs_unlocked (const char *, FILE *); +# endif +# endif +# ifdef HAVE_FWRITE_UNLOCKED +# undef fwrite +# define fwrite(Ptr, Size, N, Stream) fwrite_unlocked (Ptr, Size, N, Stream) +# if defined (HAVE_DECL_FWRITE_UNLOCKED) && !HAVE_DECL_FWRITE_UNLOCKED +extern int fwrite_unlocked (const void *, size_t, size_t, FILE *); +# endif +# endif +# ifdef HAVE_FPRINTF_UNLOCKED +# undef fprintf +/* We can't use a function-like macro here because we don't know if + we have varargs macros. */ +# define fprintf fprintf_unlocked +# if defined (HAVE_DECL_FPRINTF_UNLOCKED) && !HAVE_DECL_FPRINTF_UNLOCKED +extern int fprintf_unlocked (FILE *, const char *, ...); +# endif +# endif -#ifdef isblank -# define ISBLANK(c) (IN_CTYPE_DOMAIN (c) && isblank (CTYPE_CONV(c))) -#else -# define ISBLANK(c) ((c) == ' ' || (c) == '\t') -#endif -#ifdef isgraph -# define ISGRAPH(c) (IN_CTYPE_DOMAIN (c) && isgraph (CTYPE_CONV(c))) -#else -# define ISGRAPH(c) (IN_CTYPE_DOMAIN (c) && isprint (CTYPE_CONV(c)) && !isspace (CTYPE_CONV(c))) -#endif - -#define ISPRINT(c) (IN_CTYPE_DOMAIN (c) && isprint (CTYPE_CONV(c))) -#define ISALNUM(c) (IN_CTYPE_DOMAIN (c) && isalnum (CTYPE_CONV(c))) -#define ISALPHA(c) (IN_CTYPE_DOMAIN (c) && isalpha (CTYPE_CONV(c))) -#define ISCNTRL(c) (IN_CTYPE_DOMAIN (c) && iscntrl (CTYPE_CONV(c))) -#define ISLOWER(c) (IN_CTYPE_DOMAIN (c) && islower (CTYPE_CONV(c))) -#define ISPUNCT(c) (IN_CTYPE_DOMAIN (c) && ispunct (CTYPE_CONV(c))) -#define ISSPACE(c) (IN_CTYPE_DOMAIN (c) && isspace (CTYPE_CONV(c))) -#define ISUPPER(c) (IN_CTYPE_DOMAIN (c) && isupper (CTYPE_CONV(c))) -#define ISXDIGIT(c) (IN_CTYPE_DOMAIN (c) && isxdigit (CTYPE_CONV(c))) -#define ISDIGIT_LOCALE(c) (IN_CTYPE_DOMAIN (c) && isdigit (CTYPE_CONV(c))) - -#if STDC_HEADERS -# define TOLOWER(c) (tolower (CTYPE_CONV(c))) -# define TOUPPER(c) (toupper (CTYPE_CONV(c))) -#else -# define TOLOWER(c) (ISUPPER (c) ? tolower (CTYPE_CONV(c)) : (c)) -# define TOUPPER(c) (ISLOWER (c) ? toupper (CTYPE_CONV(c)) : (c)) #endif -/* ISDIGIT differs from ISDIGIT_LOCALE, as follows: - - Its arg may be any int or unsigned int; it need not be an unsigned char. - - It's guaranteed to evaluate its argument exactly once. - - It's typically faster. - Posix 1003.2-1992 section 2.5.2.1 page 50 lines 1556-1558 says that - only '0' through '9' are digits. Prefer ISDIGIT to ISDIGIT_LOCALE unless - it's important to use the locale's definition of `digit' even when the - host does not conform to Posix. */ -#define ISDIGIT(c) ((unsigned) (c) - '0' <= 9) +/* ??? Glibc's fwrite/fread_unlocked macros cause + "warning: signed and unsigned type in conditional expression". */ +#undef fread_unlocked +#undef fwrite_unlocked -/* Define a default escape character; its different for EBCDIC. */ -#ifndef TARGET_ESC -#define TARGET_ESC 033 -#endif +/* There are an extraordinary number of issues with . + The last straw is that it varies with the locale. Use libiberty's + replacement instead. */ +#include #include #include -#ifndef errno +#if !defined (errno) && defined (HAVE_DECL_ERRNO) && !HAVE_DECL_ERRNO extern int errno; #endif +/* Some of glibc's string inlines cause warnings. Plus we'd rather + rely on (and therefore test) GCC's string builtins. */ +#define __NO_STRING_INLINES + #ifdef STRING_WITH_STRINGS # include # include @@ -187,11 +132,25 @@ extern int errno; #ifdef HAVE_STDLIB_H # include -# ifdef USE_C_ALLOCA -/* Note that systems that use glibc have a that includes - that defines alloca, so let USE_C_ALLOCA override this. */ -# undef alloca #endif + +/* If we don't have an overriding definition, set SUCCESS_EXIT_CODE and + FATAL_EXIT_CODE to EXIT_SUCCESS and EXIT_FAILURE respectively, + or 0 and 1 if those macros are not defined. */ +#ifndef SUCCESS_EXIT_CODE +# ifdef EXIT_SUCCESS +# define SUCCESS_EXIT_CODE EXIT_SUCCESS +# else +# define SUCCESS_EXIT_CODE 0 +# endif +#endif + +#ifndef FATAL_EXIT_CODE +# ifdef EXIT_FAILURE +# define FATAL_EXIT_CODE EXIT_FAILURE +# else +# define FATAL_EXIT_CODE 1 +# endif #endif #ifdef HAVE_UNISTD_H @@ -200,39 +159,26 @@ extern int errno; #ifdef HAVE_SYS_PARAM_H # include +/* We use this identifier later and it appears in some vendor param.h's. */ +# undef PREFETCH #endif #if HAVE_LIMITS_H # include #endif -/* Find HOST_WIDEST_INT and set its bit size, type and print macros. - It will be the largest integer mode supported by the host which may - (or may not) be larger than HOST_WIDE_INT. This must appear after - since we only use `long long' if its bigger than a - `long' and also if it is supported by macros in limits.h. For old - hosts which don't have a limits.h (and thus won't include it in - stage2 cause we don't rerun configure) we assume gcc supports long - long.) Note, you won't get these defined if you don't include - {ht}config.h before this file to set the HOST_BITS_PER_* macros. */ - -#ifndef HOST_WIDEST_INT -# if defined (HOST_BITS_PER_LONG) && defined (HOST_BITS_PER_LONGLONG) -# if (HOST_BITS_PER_LONGLONG > HOST_BITS_PER_LONG) && (defined (LONG_LONG_MAX) || defined (LONGLONG_MAX) || defined (LLONG_MAX) || defined (__GNUC__)) -# define HOST_BITS_PER_WIDEST_INT HOST_BITS_PER_LONGLONG -# define HOST_WIDEST_INT long long -# define HOST_WIDEST_INT_PRINT_DEC "%lld" -# define HOST_WIDEST_INT_PRINT_UNSIGNED "%llu" -# define HOST_WIDEST_INT_PRINT_HEX "0x%llx" -# else -# define HOST_BITS_PER_WIDEST_INT HOST_BITS_PER_LONG -# define HOST_WIDEST_INT long -# define HOST_WIDEST_INT_PRINT_DEC "%ld" -# define HOST_WIDEST_INT_PRINT_UNSIGNED "%lu" -# define HOST_WIDEST_INT_PRINT_HEX "0x%lx" -# endif /*(long long>long) && (LONG_LONG_MAX||LONGLONG_MAX||LLONG_MAX||GNUC)*/ -# endif /* defined(HOST_BITS_PER_LONG) && defined(HOST_BITS_PER_LONGLONG) */ -#endif /* ! HOST_WIDEST_INT */ +/* Get definitions of HOST_WIDE_INT and HOST_WIDEST_INT. */ +#include "hwint.h" + +/* A macro to determine whether a VALUE lies inclusively within a + certain range without evaluating the VALUE more than once. This + macro won't warn if the VALUE is unsigned and the LOWER bound is + zero, as it would e.g. with "VALUE >= 0 && ...". Note the LOWER + bound *is* evaluated twice, and LOWER must not be greater than + UPPER. However the bounds themselves can be either positive or + negative. */ +#define IN_RANGE(VALUE, LOWER, UPPER) \ + ((unsigned HOST_WIDE_INT) ((VALUE) - (LOWER)) <= ((UPPER) - (LOWER))) /* Infrastructure for defining missing _MAX and _MIN macros. Note that macros defined with these cannot be used in #if. */ @@ -320,92 +266,52 @@ extern int errno; #ifndef WSTOPSIG #define WSTOPSIG WEXITSTATUS #endif +#ifndef WCOREDUMP +#define WCOREDUMP(S) ((S) & WCOREFLG) +#endif +#ifndef WCOREFLG +#define WCOREFLG 0200 +#endif /* The HAVE_DECL_* macros are three-state, undefined, 0 or 1. If they are defined to 0 then we must provide the relevant declaration here. These checks will be in the undefined state while configure is running so be careful to test "defined (HAVE_DECL_*)". */ -#ifndef bcopy -# ifdef HAVE_BCOPY -# if defined (HAVE_DECL_BCOPY) && !HAVE_DECL_BCOPY -extern void bcopy PARAMS ((const PTR, PTR, size_t)); -# endif -# else /* ! HAVE_BCOPY */ -# define bcopy(src,dst,len) memmove((dst),(src),(len)) -# endif -#endif - -#ifndef bcmp -# ifdef HAVE_BCMP -# if defined (HAVE_DECL_BCMP) && !HAVE_DECL_BCMP -extern int bcmp PARAMS ((const PTR, const PTR, size_t)); -# endif -# else /* ! HAVE_BCMP */ -# define bcmp(left,right,len) memcmp ((left),(right),(len)) -# endif -#endif - -#ifndef bzero -# ifdef HAVE_BZERO -# if defined (HAVE_DECL_BZERO) && !HAVE_DECL_BZERO -extern void bzero PARAMS ((PTR, size_t)); -# endif -# else /* ! HAVE_BZERO */ -# define bzero(dst,len) memset ((dst),0,(len)) -# endif -#endif - -#ifndef index -# ifdef HAVE_INDEX -# if defined (HAVE_DECL_INDEX) && !HAVE_DECL_INDEX -extern char *index PARAMS ((const char *, int)); -# endif -# else /* ! HAVE_INDEX */ -# define index strchr -# endif -#endif - -#ifndef rindex -# ifdef HAVE_RINDEX -# if defined (HAVE_DECL_RINDEX) && !HAVE_DECL_RINDEX -extern char *rindex PARAMS ((const char *, int)); -# endif -# else /* ! HAVE_RINDEX */ -# define rindex strrchr -# endif -#endif - #if defined (HAVE_DECL_ATOF) && !HAVE_DECL_ATOF -extern double atof PARAMS ((const char *)); +extern double atof (const char *); #endif #if defined (HAVE_DECL_ATOL) && !HAVE_DECL_ATOL -extern long atol PARAMS ((const char *)); +extern long atol (const char *); #endif #if defined (HAVE_DECL_FREE) && !HAVE_DECL_FREE -extern void free PARAMS ((PTR)); +extern void free (void *); #endif #if defined (HAVE_DECL_GETCWD) && !HAVE_DECL_GETCWD -extern char *getcwd PARAMS ((char *, size_t)); +extern char *getcwd (char *, size_t); #endif #if defined (HAVE_DECL_GETENV) && !HAVE_DECL_GETENV -extern char *getenv PARAMS ((const char *)); +extern char *getenv (const char *); +#endif + +#if defined (HAVE_DECL_GETOPT) && !HAVE_DECL_GETOPT +extern int getopt (int, char * const *, const char *); #endif #if defined (HAVE_DECL_GETWD) && !HAVE_DECL_GETWD -extern char *getwd PARAMS ((char *)); +extern char *getwd (char *); #endif #if defined (HAVE_DECL_SBRK) && !HAVE_DECL_SBRK -extern PTR sbrk PARAMS ((int)); +extern void *sbrk (int); #endif #if defined (HAVE_DECL_STRSTR) && !HAVE_DECL_STRSTR -extern char *strstr PARAMS ((const char *, const char *)); +extern char *strstr (const char *, const char *); #endif #ifdef HAVE_MALLOC_H @@ -413,32 +319,31 @@ extern char *strstr PARAMS ((const char *, const char *)); #endif #if defined (HAVE_DECL_MALLOC) && !HAVE_DECL_MALLOC -extern PTR malloc PARAMS ((size_t)); +extern void *malloc (size_t); #endif #if defined (HAVE_DECL_CALLOC) && !HAVE_DECL_CALLOC -extern PTR calloc PARAMS ((size_t, size_t)); +extern void *calloc (size_t, size_t); #endif #if defined (HAVE_DECL_REALLOC) && !HAVE_DECL_REALLOC -extern PTR realloc PARAMS ((PTR, size_t)); +extern void *realloc (void *, size_t); #endif /* If the system doesn't provide strsignal, we get it defined in - libiberty but no declaration is supplied. */ -#if defined (HAVE_DECL_STRSIGNAL) && !HAVE_DECL_STRSIGNAL + libiberty but no declaration is supplied. */ +#if !defined (HAVE_STRSIGNAL) \ + || (defined (HAVE_DECL_STRSIGNAL) && !HAVE_DECL_STRSIGNAL) # ifndef strsignal -extern const char *strsignal PARAMS ((int)); +extern const char *strsignal (int); # endif #endif #ifdef HAVE_GETRLIMIT # if defined (HAVE_DECL_GETRLIMIT) && !HAVE_DECL_GETRLIMIT # ifndef getrlimit -# ifdef ANSI_PROTOTYPES struct rlimit; -# endif -extern int getrlimit PARAMS ((int, struct rlimit *)); +extern int getrlimit (int, struct rlimit *); # endif # endif #endif @@ -446,37 +351,32 @@ extern int getrlimit PARAMS ((int, struct rlimit *)); #ifdef HAVE_SETRLIMIT # if defined (HAVE_DECL_SETRLIMIT) && !HAVE_DECL_SETRLIMIT # ifndef setrlimit -# ifdef ANSI_PROTOTYPES struct rlimit; -# endif -extern int setrlimit PARAMS ((int, const struct rlimit *)); +extern int setrlimit (int, const struct rlimit *); # endif # endif #endif -/* HAVE_VOLATILE only refers to the stage1 compiler. We also check - __STDC__ and assume gcc sets it and has volatile in stage >=2. */ -#if !defined(HAVE_VOLATILE) && !defined(__STDC__) && !defined(volatile) -#define volatile +#if defined (HAVE_DECL_ABORT) && !HAVE_DECL_ABORT +extern void abort (void); +#endif + +#if defined (HAVE_DECL_SNPRINTF) && !HAVE_DECL_SNPRINTF +extern int snprintf (char *, size_t, const char *, ...); +#endif + +/* 1 if we have C99 designated initializers. */ +#if !defined(HAVE_DESIGNATED_INITIALIZERS) +#define HAVE_DESIGNATED_INITIALIZERS \ + ((GCC_VERSION >= 2007) || (__STDC_VERSION__ >= 199901L)) +#endif + +/* 1 if we have _Bool. */ +#ifndef HAVE__BOOL +# define HAVE__BOOL \ + ((GCC_VERSION >= 3000) || (__STDC_VERSION__ >= 199901L)) #endif -#if defined (HAVE_DECL_ABORT) && !HAVE_DECL_ABORT -extern void abort PARAMS ((void)); -#endif - -/* Define a STRINGIFY macro that's right for ANSI or traditional C. - Note: if the argument passed to STRINGIFY is itself a macro, eg - #define foo bar, STRINGIFY(foo) will produce "foo", not "bar". - Although the __STDC__ case could be made to expand this via a layer - of indirection, the traditional C case can not do so. Therefore - this behavior is not supported. */ -#ifndef STRINGIFY -# ifdef HAVE_STRINGIZE -# define STRINGIFY(STRING) #STRING -# else -# define STRINGIFY(STRING) "STRING" -# endif -#endif /* ! STRINGIFY */ #if HAVE_SYS_STAT_H # include @@ -541,7 +441,7 @@ extern void abort PARAMS ((void)); # define STDERR_FILENO 2 #endif -/* Some systems have mkdir that takes a single argument. */ +/* Some systems have mkdir that takes a single argument. */ #ifdef MKDIR_TAKES_ONE_ARG # define mkdir(a,b) mkdir(a) #endif @@ -550,10 +450,12 @@ extern void abort PARAMS ((void)); #ifndef HOST_PTR_PRINTF # ifdef HAVE_PRINTF_PTR # define HOST_PTR_PRINTF "%p" +# elif SIZEOF_INT == SIZEOF_VOID_P +# define HOST_PTR_PRINTF "%x" +# elif SIZEOF_LONG == SIZEOF_VOID_P +# define HOST_PTR_PRINTF "%lx" # else -# define HOST_PTR_PRINTF \ - (sizeof (int) == sizeof (char *) ? "%x" \ - : sizeof (long) == sizeof (char *) ? "%lx" : "%llx") +# define HOST_PTR_PRINTF "%llx" # endif #endif /* ! HOST_PTR_PRINTF */ @@ -562,57 +464,187 @@ extern void abort PARAMS ((void)); #define PATH_SEPARATOR ':' #endif +/* Filename handling macros. */ +#include "filenames.h" + +/* These should be phased out in favor of IS_DIR_SEPARATOR, where possible. */ #ifndef DIR_SEPARATOR -#define DIR_SEPARATOR '/' +# define DIR_SEPARATOR '/' +# ifdef HAVE_DOS_BASED_FILE_SYSTEM +# define DIR_SEPARATOR_2 '\\' +# endif #endif -/* Define IS_DIR_SEPARATOR. */ -#ifndef DIR_SEPARATOR_2 -# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR) -#else /* DIR_SEPARATOR_2 */ -# define IS_DIR_SEPARATOR(ch) \ - (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2)) -#endif /* DIR_SEPARATOR_2 */ - -/* Get libiberty declarations. */ +/* Get libiberty declarations. */ #include "libiberty.h" -/* Make sure that ONLY_INT_FIELDS has an integral value. */ -#ifdef ONLY_INT_FIELDS -#undef ONLY_INT_FIELDS -#define ONLY_INT_FIELDS 1 -#else -#define ONLY_INT_FIELDS 0 -#endif +/* Provide a default for the HOST_BIT_BUCKET. + This suffices for POSIX-like hosts. */ + +#ifndef HOST_BIT_BUCKET +#define HOST_BIT_BUCKET "/dev/null" +#endif -/* Enumerated bitfields are safe to use unless we've been explictly told - otherwise or if they are signed. */ - -#define USE_ENUM_BITFIELDS (__GNUC__ || (!ONLY_INT_FIELDS && ENUM_BITFIELDS_ARE_UNSIGNED)) +/* Be conservative and only use enum bitfields with GCC. Likewise for + char bitfields. + FIXME: provide a complete autoconf test for buggy enum bitfields. */ -#if USE_ENUM_BITFIELDS +#if (GCC_VERSION > 2000) #define ENUM_BITFIELD(TYPE) enum TYPE +#define CHAR_BITFIELD unsigned char #else #define ENUM_BITFIELD(TYPE) unsigned int +#define CHAR_BITFIELD unsigned int #endif #ifndef offsetof -#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) +#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *) 0)->MEMBER) #endif -/* Traditional C cannot initialize union members of structs. Provide - a macro which expands appropriately to handle it. This only works - if you intend to initalize the union member to zero since it relies - on default initialization to zero in the traditional C case. */ -#ifdef __STDC__ -#define UNION_INIT_ZERO , {0} -#else -#define UNION_INIT_ZERO +/* Various error reporting routines want to use __FUNCTION__. */ +#if (GCC_VERSION < 2007) +#ifndef __FUNCTION__ +#define __FUNCTION__ "?" +#endif /* ! __FUNCTION__ */ #endif -/* GCC now gives implicit declaration warnings for undeclared builtins. */ -#if defined(__GNUC__) && defined (__SIZE_TYPE__) -extern void *alloca (__SIZE_TYPE__); +/* __builtin_expect(A, B) evaluates to A, but notifies the compiler that + the most likely value of A is B. This feature was added at some point + between 2.95 and 3.0. Let's use 3.0 as the lower bound for now. */ +#if (GCC_VERSION < 3000) +#define __builtin_expect(a, b) (a) #endif -#endif /* __GCC_SYSTEM_H__ */ +/* Provide some sort of boolean type. We use stdbool.h if it's + available. This must be after all inclusion of system headers, + as some of them will mess us up. */ +#undef bool +#undef true +#undef false +#undef TRUE +#undef FALSE + +#ifdef HAVE_STDBOOL_H +# include +#else +# if !HAVE__BOOL +typedef char _Bool; +# endif +# define bool _Bool +# define true 1 +# define false 0 +#endif + +#define TRUE true +#define FALSE false + +/* As the last action in this file, we poison the identifiers that + shouldn't be used. Note, luckily gcc-3.0's token-based integrated + preprocessor won't trip on poisoned identifiers that arrive from + the expansion of macros. E.g. #define strrchr rindex, won't error + if rindex is poisoned after this directive is issued and later on + strrchr is called. + + Note: We define bypass macros for the few cases where we really + want to use the libc memory allocation routines. Otherwise we + insist you use the "x" versions from libiberty. */ + +#define really_call_malloc malloc +#define really_call_calloc calloc +#define really_call_realloc realloc + +#if defined(FLEX_SCANNER) || defined(YYBISON) +/* Flex and bison use malloc and realloc. Yuk. Note that this means + really_call_* cannot be used in a .l or .y file. */ +#define malloc xmalloc +#define realloc xrealloc +#endif + +#if (GCC_VERSION >= 3000) + +/* Note autoconf checks for prototype declarations and includes + system.h while doing so. Only poison these tokens if actually + compiling gcc, so that the autoconf declaration tests for malloc + etc don't spuriously fail. */ +#ifdef IN_GCC +#undef calloc +#undef strdup + #pragma GCC poison calloc strdup + +#if !defined(FLEX_SCANNER) && !defined(YYBISON) +#undef malloc +#undef realloc + #pragma GCC poison malloc realloc +#endif + +/* Old target macros that have moved to the target hooks structure. */ + #pragma GCC poison ASM_OPEN_PAREN ASM_CLOSE_PAREN \ + FUNCTION_PROLOGUE FUNCTION_EPILOGUE \ + FUNCTION_END_PROLOGUE FUNCTION_BEGIN_EPILOGUE \ + DECL_MACHINE_ATTRIBUTES COMP_TYPE_ATTRIBUTES INSERT_ATTRIBUTES \ + VALID_MACHINE_DECL_ATTRIBUTE VALID_MACHINE_TYPE_ATTRIBUTE \ + SET_DEFAULT_TYPE_ATTRIBUTES SET_DEFAULT_DECL_ATTRIBUTES \ + MERGE_MACHINE_TYPE_ATTRIBUTES MERGE_MACHINE_DECL_ATTRIBUTES \ + MD_INIT_BUILTINS MD_EXPAND_BUILTIN ASM_OUTPUT_CONSTRUCTOR \ + ASM_OUTPUT_DESTRUCTOR SIGNED_CHAR_SPEC MAX_CHAR_TYPE_SIZE \ + WCHAR_UNSIGNED UNIQUE_SECTION SELECT_SECTION SELECT_RTX_SECTION \ + ENCODE_SECTION_INFO STRIP_NAME_ENCODING ASM_GLOBALIZE_LABEL \ + ASM_OUTPUT_MI_THUNK CONST_COSTS RTX_COSTS DEFAULT_RTX_COSTS \ + ADDRESS_COST MACHINE_DEPENDENT_REORG ASM_FILE_START ASM_FILE_END \ + ASM_SIMPLIFY_DWARF_ADDR INIT_TARGET_OPTABS INIT_SUBTARGET_OPTABS \ + INIT_GOFAST_OPTABS MULSI3_LIBCALL MULDI3_LIBCALL DIVSI3_LIBCALL \ + DIVDI3_LIBCALL UDIVSI3_LIBCALL UDIVDI3_LIBCALL MODSI3_LIBCALL \ + MODDI3_LIBCALL UMODSI3_LIBCALL UMODDI3_LIBCALL BUILD_VA_LIST_TYPE + +/* Other obsolete target macros, or macros that used to be in target + headers and were not used, and may be obsolete or may never have + been used. */ + #pragma GCC poison INT_ASM_OP ASM_OUTPUT_EH_REGION_BEG CPP_PREDEFINES \ + ASM_OUTPUT_EH_REGION_END ASM_OUTPUT_LABELREF_AS_INT SMALL_STACK \ + DOESNT_NEED_UNWINDER EH_TABLE_LOOKUP OBJC_SELECTORS_WITHOUT_LABELS \ + OMIT_EH_TABLE EASY_DIV_EXPR IMPLICIT_FIX_EXPR \ + LONGJMP_RESTORE_FROM_STACK MAX_INT_TYPE_SIZE ASM_IDENTIFY_GCC \ + STDC_VALUE TRAMPOLINE_ALIGN ASM_IDENTIFY_GCC_AFTER_SOURCE \ + SLOW_ZERO_EXTEND SUBREG_REGNO_OFFSET DWARF_LINE_MIN_INSTR_LENGTH \ + TRADITIONAL_RETURN_FLOAT NO_BUILTIN_SIZE_TYPE \ + NO_BUILTIN_PTRDIFF_TYPE NO_BUILTIN_WCHAR_TYPE NO_BUILTIN_WINT_TYPE \ + BLOCK_PROFILER BLOCK_PROFILER_CODE FUNCTION_BLOCK_PROFILER \ + FUNCTION_BLOCK_PROFILER_EXIT MACHINE_STATE_SAVE \ + MACHINE_STATE_RESTORE SCCS_DIRECTIVE SECTION_ASM_OP \ + ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL ASM_OUTPUT_INTERNAL_LABEL \ + OBJC_PROLOGUE ALLOCATE_TRAMPOLINE HANDLE_PRAGMA ROUND_TYPE_SIZE \ + ROUND_TYPE_SIZE_UNIT CONST_SECTION_ASM_OP CRT_GET_RFIB_TEXT \ + DBX_LBRAC_FIRST DBX_OUTPUT_ENUM DBX_OUTPUT_SOURCE_FILENAME \ + DBX_WORKING_DIRECTORY INSN_CACHE_DEPTH INSN_CACHE_SIZE \ + INSN_CACHE_LINE_WIDTH INIT_SECTION_PREAMBLE NEED_ATEXIT ON_EXIT \ + EXIT_BODY OBJECT_FORMAT_ROSE MULTIBYTE_CHARS MAP_CHARACTER \ + LIBGCC_NEEDS_DOUBLE + +/* Hooks that are no longer used. */ + #pragma GCC poison LANG_HOOKS_FUNCTION_MARK LANG_HOOKS_FUNCTION_FREE \ + LANG_HOOKS_MARK_TREE LANG_HOOKS_INSERT_DEFAULT_ATTRIBUTES + +/* Libiberty macros that are no longer used in GCC. */ +#undef ANSI_PROTOTYPES +#undef PTR_CONST +#undef LONG_DOUBLE +#undef VPARAMS +#undef VA_OPEN +#undef VA_FIXEDARG +#undef VA_CLOSE +#undef VA_START + #pragma GCC poison ANSI_PROTOTYPES PTR_CONST LONG_DOUBLE VPARAMS VA_OPEN \ + VA_FIXEDARG VA_CLOSE VA_START +#endif /* IN_GCC */ + +/* Note: not all uses of the `index' token (e.g. variable names and + structure members) have been eliminated. */ +#undef bcopy +#undef bzero +#undef bcmp +#undef rindex + #pragma GCC poison bcopy bzero bcmp rindex + +#endif /* GCC >= 3.0 */ + +#endif /* ! GCC_SYSTEM_H */