Return to gcc.info-16 CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/gcc.info-16, revision 1.1

1.1     ! root        1: This is Info file gcc.info, produced by Makeinfo-1.43 from the input
        !             2: file gcc.texi.
        !             3: 
        !             4:    This file documents the use and the internals of the GNU compiler.
        !             5: 
        !             6:    Copyright (C) 1988, 1989, 1992 Free Software Foundation, Inc.
        !             7: 
        !             8:    Permission is granted to make and distribute verbatim copies of
        !             9: this manual provided the copyright notice and this permission notice
        !            10: are preserved on all copies.
        !            11: 
        !            12:    Permission is granted to copy and distribute modified versions of
        !            13: this manual under the conditions for verbatim copying, provided also
        !            14: that the section entitled "GNU General Public License" is included
        !            15: exactly as in the original, and provided that the entire resulting
        !            16: derived work is distributed under the terms of a permission notice
        !            17: identical to this one.
        !            18: 
        !            19:    Permission is granted to copy and distribute translations of this
        !            20: manual into another language, under the above conditions for modified
        !            21: versions, except that the section entitled "GNU General Public
        !            22: License" and this permission notice may be included in translations
        !            23: approved by the Free Software Foundation instead of in the original
        !            24: English.
        !            25: 
        !            26: 
        !            27: File: gcc.info,  Node: Config,  Next: Index,  Prev: Machine Macros,  Up: Top
        !            28: 
        !            29: The Configuration File
        !            30: **********************
        !            31: 
        !            32:    The configuration file `xm-MACHINE.h' contains macro definitions
        !            33: that describe the machine and system on which the compiler is running,
        !            34: unlike the definitions in `MACHINE.h', which describe the machine for
        !            35: which the compiler is producing output.  Most of the values in
        !            36: `xm-MACHINE.h' are actually the same on all machines that GNU CC runs
        !            37: on, so large parts of all configuration files are identical.  But
        !            38: there are some macros that vary:
        !            39: 
        !            40: `USG'
        !            41:      Define this macro if the host system is System V.
        !            42: 
        !            43: `VMS'
        !            44:      Define this macro if the host system is VMS.
        !            45: 
        !            46: `FAILURE_EXIT_CODE'
        !            47:      A C expression for the status code to be returned when the
        !            48:      compiler exits after serious errors.
        !            49: 
        !            50: `SUCCESS_EXIT_CODE'
        !            51:      A C expression for the status code to be returned when the
        !            52:      compiler exits without serious errors.
        !            53: 
        !            54: `HOST_WORDS_BIG_ENDIAN'
        !            55:      Defined if the host machine stores words of multi-word values in
        !            56:      big-endian order.  (GNU CC does not depend on the host byte
        !            57:      ordering within a word.)
        !            58: 
        !            59: `HOST_FLOAT_FORMAT'
        !            60:      A numeric code distinguishing the floating point format for the
        !            61:      host machine.  See `TARGET_FLOAT_FORMAT' in *Note Storage
        !            62:      Layout:: for the alternatives and default.
        !            63: 
        !            64: `HOST_BITS_PER_CHAR'
        !            65:      A C expression for the number of bits in `char' on the host
        !            66:      machine.
        !            67: 
        !            68: `HOST_BITS_PER_SHORT'
        !            69:      A C expression for the number of bits in `short' on the host
        !            70:      machine.
        !            71: 
        !            72: `HOST_BITS_PER_INT'
        !            73:      A C expression for the number of bits in `int' on the host
        !            74:      machine.
        !            75: 
        !            76: `HOST_BITS_PER_LONG'
        !            77:      A C expression for the number of bits in `long' on the host
        !            78:      machine.
        !            79: 
        !            80: `ONLY_INT_FIELDS'
        !            81:      Define this macro to indicate that the host compiler only supports
        !            82:      `int' bit fields, rather than other integral types, including
        !            83:      `enum', as do most C compilers.
        !            84: 
        !            85: `EXECUTABLE_SUFFIX'
        !            86:      Define this macro if the host system uses a naming convention for
        !            87:      executable files that involves a common suffix (such as, in some
        !            88:      systems, `.exe') that must be mentioned explicitly when you run
        !            89:      the program.
        !            90: 
        !            91: `OBSTACK_CHUNK_SIZE'
        !            92:      A C expression for the size of ordinary obstack chunks.  If you
        !            93:      don't define this, a usually-reasonable default is used.
        !            94: 
        !            95: `OBSTACK_CHUNK_ALLOC'
        !            96:      The function used to allocate obstack chunks.  If you don't
        !            97:      define this, `xmalloc' is used.
        !            98: 
        !            99: `OBSTACK_CHUNK_FREE'
        !           100:      The function used to free obstack chunks.  If you don't define
        !           101:      this, `free' is used.
        !           102: 
        !           103: `USE_C_ALLOCA'
        !           104:      Define this macro to indicate that the compiler is running with
        !           105:      the `alloca' implemented in C.  This version of `alloca' can be
        !           106:      found in the file `alloca.c'; to use it, you must also alter the
        !           107:      `Makefile' variable `ALLOCA'.  (This is done automatically for
        !           108:      the systems on which we know it is needed.)
        !           109: 
        !           110:      If you do define this macro, you should probably do it as follows:
        !           111: 
        !           112:           #ifndef __GNUC__
        !           113:           #define USE_C_ALLOCA
        !           114:           #else
        !           115:           #define alloca __builtin_alloca
        !           116:           #endif
        !           117: 
        !           118:      so that when the compiler is compiled with GNU CC it uses the more
        !           119:      efficient built-in `alloca' function.
        !           120: 
        !           121: `FUNCTION_CONVERSION_BUG'
        !           122:      Define this macro to indicate that the host compiler does not
        !           123:      properly handle converting a function value to a
        !           124:      pointer-to-function when it is used in an expression.
        !           125: 
        !           126:    In addition, configuration files for system V define `bcopy',
        !           127: `bzero' and `bcmp' as aliases.  Some files define `alloca' as a macro
        !           128: when compiled with GNU CC, in order to take advantage of the benefit
        !           129: of GNU CC's built-in `alloca'.
        !           130: 
        !           131: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.