(gcc.info.gz) Config

 
 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  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.
 
 `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 ANSI
      C library functions for converting multibyte characters to wide
      characters.
 
 `POSIX'
      Define this if your system is POSIX.1 compliant.
 
 `NO_SYS_SIGLIST'
      Define this if your system *does not* provide the variable
      `sys_siglist'.
 
      Some systems do provide this variable, but with a different name
      such as `_sys_siglist'.  On these systems, you can define
      `sys_siglist' as a macro which expands into the name actually
      provided.
 
      Autoconf normally defines `SYS_SIGLIST_DECLARED' when it finds a
      declaration of `sys_siglist' in the system header files.  However,
      when you define `sys_siglist' to a different name autoconf will
      not automatically define `SYS_SIGLIST_DECLARED'.  Therefore, if
      you define `sys_siglist', you should also define
      `SYS_SIGLIST_DECLARED'.
 
 `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.
 
 `NO_MD_PROTOTYPES'
      Define this if you wish suppression of prototypes generated from
      the machine description file, but to use other prototypes within
      GCC.  If `USE_PROTOTYPES' is defined to be 0, or the host compiler
      does not support prototypes, this macro has no effect.
 
 `MD_CALL_PROTOTYPES'
      Define this if you wish to generate prototypes for the `gen_call'
      or `gen_call_value' functions generated from the machine
      description file.  If `USE_PROTOTYPES' is defined to be 0, or the
      host compiler does not support prototypes, or `NO_MD_PROTOTYPES'
      is defined, this macro has no effect.  As soon as all of the
      machine descriptions are modified to have the appropriate number
      of arguments, this macro will be removed.
 
 `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.
 
 `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.
 
 `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.
 
    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'.
Info Catalog
(gcc.info.gz) Target Macros
(gcc.info.gz) Top
(gcc.info.gz) Fragments
automatically generated byinfo2html