GNU Info

Info Node: (gcc-300.info)Config

(gcc-300.info)Config


Next: Fragments Prev: Target Macros Up: Top
Enter node , (file) or (file)node

The Configuration File
**********************

   The configuration file `xm-MACHINE.h' contains macro definitions
that describe the machine and system on which the compiler is running,
unlike the definitions in `MACHINE.h', which describe the machine for
which the compiler is producing output.  Most of the values in
`xm-MACHINE.h' are actually the same on all machines that GCC runs on,
so large parts of all configuration files are identical.  But there are
some macros that vary:

`USG'
     Define this macro if the host system is System V.

`VMS'
     Define this macro if the host system is VMS.

`FATAL_EXIT_CODE'
     A C expression for the status code to be returned when the compiler
     exits after serious errors.

`SUCCESS_EXIT_CODE'
     A C expression for the status code to be returned when the compiler
     exits without serious errors.

`HOST_WORDS_BIG_ENDIAN'
     Defined if the host machine stores words of multi-word values in
     big-endian order.  (GCC does not depend on the host byte ordering
     within a word.)

`HOST_FLOAT_WORDS_BIG_ENDIAN'
     Define this macro to be 1 if the host machine stores `DFmode',
     `XFmode' or `TFmode' floating point numbers in memory with the
     word containing the sign bit at the lowest address; otherwise,
     define it to be zero.

     This macro need not be defined if the ordering is the same as for
     multi-word integers.

`HOST_FLOAT_FORMAT'
     A numeric code distinguishing the floating point format for the
     host machine.  See `TARGET_FLOAT_FORMAT' in Note: Storage Layout
     for the alternatives and default.

`HOST_BITS_PER_CHAR'
     A C expression for the number of bits in `char' on the host
     machine.

`HOST_BITS_PER_SHORT'
     A C expression for the number of bits in `short' on the host
     machine.

`HOST_BITS_PER_INT'
     A C expression for the number of bits in `int' on the host machine.

`HOST_BITS_PER_LONG'
     A C expression for the number of bits in `long' on the host
     machine.

`HOST_BITS_PER_LONGLONG'
     A C expression for the number of bits in `long long' on the host
     machine.

`ONLY_INT_FIELDS'
     Define this macro to indicate that the host compiler only supports
     `int' bit-fields, rather than other integral types, including
     `enum', as do most C compilers.

`OBSTACK_CHUNK_SIZE'
     A C expression for the size of ordinary obstack chunks.  If you
     don't define this, a usually-reasonable default is used.

`OBSTACK_CHUNK_ALLOC'
     The function used to allocate obstack chunks.  If you don't define
     this, `xmalloc' is used.

`OBSTACK_CHUNK_FREE'
     The function used to free obstack chunks.  If you don't define
     this, `free' is used.

`USE_C_ALLOCA'
     Define this macro to indicate that the compiler is running with the
     `alloca' implemented in C.  This version of `alloca' can be found
     in the file `alloca.c'; to use it, you must also alter the
     `Makefile' variable `ALLOCA'.  (This is done automatically for the
     systems on which we know it is needed.)

     If you do define this macro, you should probably do it as follows:

          #ifndef __GNUC__
          #define USE_C_ALLOCA
          #else
          #define alloca __builtin_alloca
          #endif

     so that when the compiler is compiled with GCC it uses the more
     efficient built-in `alloca' function.

`FUNCTION_CONVERSION_BUG'
     Define this macro to indicate that the host compiler does not
     properly handle converting a function value to a
     pointer-to-function when it is used in an expression.

`MULTIBYTE_CHARS'
     Define this macro to enable support for multibyte characters in the
     input to GCC.  This requires that the host system support the ISO C
     library functions for converting multibyte characters to wide
     characters.

`POSIX'
     Define this if your system is POSIX.1 compliant.

`USE_PROTOTYPES'
     Define this to be 1 if you know that the host compiler supports
     prototypes, even if it doesn't define __STDC__, or define it to be
     0 if you do not want any prototypes used in compiling GCC.  If
     `USE_PROTOTYPES' is not defined, it will be determined
     automatically whether your compiler supports prototypes by
     checking if `__STDC__' is defined.

`PATH_SEPARATOR'
     Define this macro to be a C character constant representing the
     character used to separate components in paths.  The default value
     is the colon character

`DIR_SEPARATOR'
     If your system uses some character other than slash to separate
     directory names within a file specification, define this macro to
     be a C character constant specifying that character.  When GCC
     displays file names, the character you specify will be used.  GCC
     will test for both slash and the character you specify when
     parsing filenames.

`DIR_SEPARATOR_2'
     If your system uses an alternative character other than
     `DIR_SEPARATOR' to separate directory names within a file
     specification, define this macro to be a C character constant
     specifying that character.  If you define this macro, GCC will
     test for slash, `DIR_SEPARATOR', and `DIR_SEPARATOR_2' when
     parsing filenames.

`OBJECT_SUFFIX'
     Define this macro to be a C string representing the suffix for
     object files on your machine.  If you do not define this macro,
     GCC will use `.o' as the suffix for object files.

`EXECUTABLE_SUFFIX'
     Define this macro to be a C string representing the suffix for
     executable files on your machine.  If you do not define this
     macro, GCC will use the null string as the suffix for object files.

`NO_AUTO_EXE_SUFFIX'
     Define this macro if executable files on your machine have a
     suffix, but the compiler driver should not automatically append it
     to the output file name, if user hasn't specified one.

`HOST_BIT_BUCKET'
     The name of a file or file-like object on the host system which
     acts as a "bit bucket".  If you do not define this macro, GCC will
     use `/dev/null' as the bit bucket.  If the target does not support
     a bit bucket, this should be defined to the null string, or some
     other invalid filename.  If the bit bucket is not writable, GCC
     will use a temporary file instead.

`COLLECT_EXPORT_LIST'
     If defined, `collect2' will scan the individual object files
     specified on its command line and create an export list for the
     linker.  Define this macro for systems like AIX, where the linker
     discards object files that are not referenced from `main' and uses
     export lists.

`COLLECT2_HOST_INITIALIZATION'
     If defined, a C statement (sans semicolon) that performs
     host-dependent initialization when `collect2' is being initialized.

`GCC_DRIVER_HOST_INITIALIZATION'
     If defined, a C statement (sans semicolon) that performs
     host-dependent initialization when a compilation driver is being
     initialized.

`UPDATE_PATH_HOST_CANONICALIZE (PATH, KEY)'
     If defined, a C statement (sans semicolon) that performs
     host-dependent canonicalization when a path used in a compilation
     driver or preprocessor is canonicalized.  PATH is the path to be
     canonicalized, and KEY is a translation prefix when its value
     isn't `NULL'.  If the C statement does canonicalize PATH, the new
     path should be returned.

   In addition, configuration files for system V define `bcopy',
`bzero' and `bcmp' as aliases.  Some files define `alloca' as a macro
when compiled with GCC, in order to take advantage of the benefit of
GCC's built-in `alloca'.


automatically generated by info2www version 1.2.2.9