Return to internals-7 CVS log

Up to [GCC 1.x] / gcc

gcc-1.23

Info file internals, produced by Makeinfo, -*- Text -*- from input
file internals.texinfo.

This file documents the internals of the GNU compiler.

Copyright (C) 1988 Free Software Foundation, Inc.

Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the section entitled ``GNU CC General Public License'' is
included exactly as in the original, and provided that the entire
resulting derived work is distributed under the terms of a permission
notice identical to this one.

Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the section entitled ``GNU CC General Public
License'' and this permission notice may be included in translations
approved by the Free Software Foundation instead of in the original
English.



File: internals,  Node: Misc,  Next: Condition Code,  Prev: Addressing Modes,  Up: Machine Macros

Miscellaneous Parameters
========================

`CASE_VECTOR_MODE'
     An alias for a machine mode name.  This is the machine mode that
     elements of a jump-table should have.

`CASE_VECTOR_PC_RELATIVE'
     Define this macro if jump-tables should contain relative
     addresses.

`CASE_DROPS_THROUGH'
     Define this if control falls through a `case' insn when the
     index value is out of range.  This means the specified
     default-label is actually ignored by the `case' insn proper.

`IMPLICIT_FIX_EXPR'
     An alias for a tree code that should be used by default for
     conversion of floating point values to fixed point.  Normally,
     `FIX_ROUND_EXPR' is used.

`FIXUNS_TRUNC_LIKE_FIX_TRUNC'
     Define this macro if the same instructions that convert a
     floating point number to a signed fixed point number also
     convert validly to an unsigned one.

`EASY_DIV_EXPR'
     An alias for a tree code that is the easiest kind of division to
     compile code for in the general case.  It may be
     `TRUNC_DIV_EXPR', `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or
     `ROUND_DIV_EXPR'.  These four division operators differ in how
     they round the result to an integer.  `EASY_DIV_EXPR' is used
     when it is permissible to use any of those kinds of division and
     the choice should be made on the basis of efficiency.

`DEFAULT_SIGNED_CHAR'
     An expression whose value is 1 or 0, according to whether the
     type `char' should be signed or unsigned by default.  The user
     can always override this default with the options
     `-fsigned-char' and `-funsigned-char'.

`SCCS_DIRECTIVE'
     Define this if the preprocessor should ignore `#sccs' directives
     and print no error message.

`IDENT_DIRECTIVE'
     Define this if the preprocessor should ignore `#ident'
     directives and print no error message.

`MOVE_MAX'
     The maximum number of bytes that a single instruction can move
     quickly from memory to memory.

`INT_TYPE_SIZE'
     A C expression for the size in bits of the type `int' on the
     target machine.

`SLOW_BYTE_ACCESS'
     Define this macro as a C expression which is nonzero if
     accessing less than a word of memory (i.e. a `char' or a
     `short') is slow (requires more than one instruction).

`SLOW_ZERO_EXTEND'
     Define this macro if zero-extension (of a `char' or `short' to
     an `int') can be done faster if the destination is a register
     that is known to be zero.

     If you define this macro, you must have instruction patterns
     that recognize RTL structures like this:

          (set (strict-low-part (subreg:QI (reg:SI ...) 0)) ...)

     and likewise for `HImode'.

`SHIFT_COUNT_TRUNCATED'
     Define this macro if shift instructions ignore all but the
     lowest few bits of the shift count.  It implies that a
     sign-extend or zero-extend instruction for the shift count can
     be omitted.

`TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)'
     A C expression which is nonzero if on this machine it is safe to
     ``convert'' an integer of INPREC bits to one of OUTPREC bits
     (where OUTPREC is smaller than INPREC) by merely operating on it
     as if it had only OUTPREC bits.

     On many machines, this expression can be 1.

`NO_FUNCTION_CSE'
     Define this macro if it is as good or better to call a constant
     function address than to call an address kept in a register.

`PROMOTE_PROTOTYPES'
     Define this macro if an argument declared as `char' or `short'
     in a prototype should actually be passed as an `int'.  In
     addition to avoiding errors in certain cases of mismatch, it
     also makes for better code on certain machines.

`STORE_FLAG_VALUE'
     A C expression for the value stored by a store-flag instruction
     (`sCOND') when the condition is true.  This is usually 1 or -1;
     it is required to be an odd number.

     Do not define `STORE_FLAG_VALUE' if the machine has no
     store-flag instructions.

`Pmode'
     An alias for the machine mode for pointers.  Normally the
     definition can be

          #define Pmode SImode

`FUNCTION_MODE'
     An alias for the machine mode used for memory references to
     functions being called, in `call' RTL expressions.  On most
     machines this should be `QImode'.

`CONST_COSTS (X, CODE)'
     A part of a C `switch' statement that describes the relative
     costs of constant RTL expressions.  It must contain `case'
     labels for expression codes `const_int', `const', `symbol_ref',
     `label_ref' and `const_double'.  Each case must ultimately reach
     a `return' statement to return the relative cost of the use of
     that kind of constant value in an expression.  The cost may
     depend on the precise value of the constant, which is available
     for examination in X.

     CODE is the expression code--redundant, since it can be obtained
     with `GET_CODE (X)'.

`DOLLARS_IN_IDENTIFIERS'
     Define this to be nonzero if the character `$' should be allowed
     by default in identifier names.



File: internals,  Node: Condition Code,  Next: Assembler Format,  Prev: Misc,  Up: Machine Macros

Condition Code Information
==========================

The file `conditions.h' defines a variable `cc_status' to describe
how the condition code was computed (in case the interpretation of
the condition code depends on the instruction that it was set by). 
This variable contains the RTL expressions on which the condition
code is currently based, and several standard flags.

Sometimes additional machine-specific flags must be defined in the
machine description header file.  It can also add additional
machine-specific information by defining `CC_STATUS_MDEP'.

`CC_STATUS_MDEP'
     C code for a data type which is used for declaring the `mdep'
     component of `cc_status'.  It defaults to `int'.

`CC_STATUS_MDEP_INIT'
     A C expression for the initial value of the `mdep' field.  It
     defaults to 0.

`NOTICE_UPDATE_CC (EXP)'
     A C compound statement to set the components of `cc_status'
     appropriately for an insn whose body is EXP.  It is this macro's
     responsibility to recognize insns that set the condition code as
     a byproduct of other activity as well as those that explicitly
     set `(cc0)'.

     If there are insn that do not set the condition code but do
     alter other machine registers, this macro must check to see
     whether they invalidate the expressions that the condition code
     is recorded as reflecting.  For example, on the 68000, insns
     that store in address registers do not set the condition code,
     which means that usually `NOTICE_UPDATE_CC' can leave
     `cc_status' unaltered for such insns.  But suppose that the
     previous insn set the condition code based on location
     `a4@(102)' and the current insn stores a new value in `a4'. 
     Although the condition code is not changed by this, it will no
     longer be true that it reflects the contents of `a4@(102)'. 
     Therefore, `NOTICE_UPDATE_CC' must alter `cc_status' in this
     case to say that nothing is known about the condition code value.

     The definition of `NOTICE_UPDATE_CC' must be prepared to deal
     with the results of peephole optimization: insns whose patterns
     are `parallel' RTXs containing various `reg', `mem' or constants
     which are just the operands.  The RTL structure of these insns
     is not sufficient to indicate what the insns actually do.  What
     `NOTICE_UPDATE_CC' should do when it sees one is just to run
     `CC_STATUS_INIT'.



File: internals,  Node: Assembler Format,  Prev: Condition Code,  Up: Machine Macros

Output of Assembler Code
========================

`ASM_SPEC'
     A C string constant that tells the GNU CC driver program options
     to pass to the assembler.  It can also specify how to translate
     options you give to GNU CC into options for GNU CC to pass to
     the assembler.  See the file `tm-sun3.h' for an example of this.

     Do not define this macro if it does not need to do anything.

`LINK_SPEC'
     A C string constant that tells the GNU CC driver program options
     to pass to the linker.  It can also specify how to translate
     options you give to GNU CC into options for GNU CC to pass to
     the linker.

     Do not define this macro if it does not need to do anything.

`LIB_SPEC'
     Another C string constant used much like `LINK_SPEC'.  The
     difference between the two is that `LIBS_SPEC' is used at the
     end of the command given to the linker.

     If this macro is not defined, a default is provided that loads
     the standard C library from the usual place.  See `gcc.c'.

`STARTFILE_SPEC'
     Another C string constant used much like `LINK_SPEC'.  The
     difference between the two is that `STARTFILE_SPEC' is used at
     the very beginning of the command given to the linker.

     If this macro is not defined, a default is provided that loads
     the standard C startup file from the usual place.  See `gcc.c'.

`ASM_FILE_START (STREAM)'
     A C expression which outputs to the stdio stream STREAM some
     appropriate text to go at the start of an assembler file.

     Normally this macro is defined to output a line containing
     `#NO_APP', which is a comment that has no effect on most
     assemblers but tells the GNU assembler that it can save time by
     not checking for certain assembler constructs.

     On systems that use SDB, it is necessary to output certain
     commands; see `tm-attasm.h'.

`ASM_APP_ON'
     A C string constant for text to be output before each `asm'
     statement or group of consecutive ones.  Normally this is
     `"#APP"', which is a comment that has no effect on most
     assemblers but tells the GNU assembler that it must check the
     lines that follow for all valid assembler constructs.

`ASM_APP_OFF'
     A C string constant for text to be output after each `asm'
     statement or group of consecutive ones.  Normally this is
     `"#NO_APP"', which tells the GNU assembler to resume making the
     time-saving assumptions that are valid for ordinary compiler
     output.

`TEXT_SECTION_ASM_OP'
     A C string constant for the assembler operation that should
     precede instructions and read-only data.  Normally `".text"' is
     right.

`DATA_SECTION_ASM_OP'
     A C string constant for the assembler operation to identify the
     following data as writable initialized data.  Normally `".data"'
     is right.

`REGISTER_NAMES'
     A C initializer containing the assembler's names for the machine
     registers, each one as a C string constant.  This is what
     translates register numbers in the compiler into assembler
     language.

`DBX_REGISTER_NUMBER (REGNO)'
     A C expression that returns the DBX register number for the
     compiler register number REGNO.  In simple cases, the value of
     this expression may be REGNO itself.  But sometimes there are
     some registers that the compiler knows about and DBX does not,
     or vice versa.  In such cases, some register may need to have
     one number in the compiler and another for DBX.

`DBX_DEBUGGING_INFO'
     Define this macro if GNU CC should produce debugging output for
     DBX in response to the `-g' option.

`SDB_DEBUGGING_INFO'
     Define this macro if GNU CC should produce debugging output for
     SDB in response to the `-g' option.

`PUT_SDB_OP'
     Define these macros to override the assembler syntax for the
     special SDB assembler directives.  See `sdbout.c' for a list of
     these macros and their arguments.  If the standard syntax is
     used, you need not define them yourself.

`SDB_GENERATE_FAKE'
     Define this macro to override the usual method of constructing a
     dummy name for anonymous structure and union types.  See
     `sdbout.c' for more infomation.

`DBX_NO_XREFS'
     Define this macro if DBX on your system does not support the
     construct `xsTAGNAME'.  On some systems, this construct is used
     to describe a forward reference to a structure named TAGNAME. 
     On other systems, this construct is not supported at all.

`DBX_CONTIN_LENGTH'
     A symbol name in DBX-format debugging information is normally
     continued (split into two separate `.stabs' directives) when it
     exceeds a certain length (by default, 80 characters).  On some
     operating systems, DBX requires this splitting; on others,
     splitting must not be done.  You can inhibit splitting by
     defining this macro with the value zero.  You can override the
     default splitting-length by defining this macro as an expression
     for the length you desire.

`DBX_CONTIN_CHAR'
     Normally continuation is indicated by adding a `\' character to
     the end of a `.stabs' string when a continuation follows.  To
     use a different character instead, define this macro as a
     character constant for the character you want to use.  Do not
     define this macro if backslash is correct for your system.

`ASM_OUTPUT_LABEL (STREAM, NAME)'
     A C statement (sans semicolon) to output to the stdio stream
     STREAM the assembler definition of a label named NAME.  Use the
     expression `assemble_name (STREAM, NAME)' to output the name
     itself; before and after that, output the additional assembler
     syntax for defining the name, and a newline.

`ASM_DECLARE_FUNCTION_NAME (STREAM, NAME, DECL)'
     A C statement (sans semicolon) to output to the stdio stream
     STREAM any text necessary for declaring the name NAME of a
     function which is being defined.  This macro is responsible for
     outputting the label definition (perhaps using
     `ASM_OUTPUT_LABEL').  The argument DECL is the `FUNCTION_DECL'
     tree node representing the function.

     If this macro is not defined, then the function name is defined
     in the usual manner as a label (by means of `ASM_OUTPUT_LABEL').

`ASM_GLOBALIZE_LABEL (STREAM, NAME)'
     A C statement (sans semicolon) to output to the stdio stream
     STREAM some commands that will make the label NAME global; that
     is, available for reference from other files.  Use the
     expression `assemble_name (STREAM, NAME)' to output the name
     itself; before and after that, output the additional assembler
     syntax for making that name global, and a newline.

`ASM_OUTPUT_EXTERNAL (STREAM, NAME, DECL)'
     A C statement (sans semicolon) to output to the stdio stream
     STREAM any text necessary for declaring the name of an external
     symbol named NAME which is referenced in this compilation but
     not defined.  The value of DECL is the tree node for the
     declaration.

     This macro need not be defined if it does not need to output
     anything.  The GNU assembler and most Unix assemblers don't
     require anything.

`ASM_OUTPUT_LABELREF (STREAM, NAME)'
     A C statement to output to the stdio stream STREAM a reference
     in assembler syntax to a label named NAME.  The character `_'
     should be added to the front of the name, if that is customary
     on your operating system, as it is in most Berkeley Unix
     systems.  This macro is used in `assemble_name'.

`ASM_GENERATE_INTERNAL_LABEL (STRING, PREFIX, NUM)'
     A C statement to store into the string STRING a label whose name
     is made from the string PREFIX and the number NUM.

     This string, when output subsequently by `ASM_OUTPUT_LABELREF',
     should produce the same output that `ASM_OUTPUT_INTERNAL_LABEL'
     would produce with the same PREFIX and NUM.

`ASM_OUTPUT_INTERNAL_LABEL (STREAM, PREFIX, NUM)'
     A C statement to output to the stdio stream STREAM a label whose
     name is made from the string PREFIX and the number NUM.  These
     labels are used for internal purposes, and there is no reason
     for them to appear in the symbol table of the object file.  On
     many systems, the letter `L' at the beginning of a label has
     this effect.  The usual definition of this macro is as follows:

          fprintf (STREAM, "L%s%d:\n", PREFIX, NUM)

`ASM_OUTPUT_CASE_LABEL (STREAM, PREFIX, NUM, TABLE)'
     Define this if the label before a jump-table needs to be output
     specially.  The first three arguments are the same as for
     `ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the
     jump-table which follows (a `jump_insn' containing an `addr_vec'
     or `addr_diff_vec').

     This feature is used on system V to output a `swbeg' statement
     for the table.

     If this macro is not defined, these labels are output with
     `ASM_OUTPUT_INTERNAL_LABEL'.

`ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)'
     Define this if something special must be output at the end of a
     jump-table.  The definition should be a C statement to be
     executed after the assembler code for the table is written.  It
     should write the appropriate code to stdio stream STREAM.  The
     argument TABLE is the jump-table insn, and NUM is the
     label-number of the preceding label.

     If this macro is not defined, nothing special is output at the
     end of the jump-table.

`ASM_FORMAT_PRIVATE_NAME (OUTVAR, NAME, NUMBER)'
     A C expression to assign to OUTVAR (which is a variable of type
     `char *') a newly allocated string made from the string NAME and
     the number NUMBER, with some suitable punctuation added.  Use
     `alloca' to get space for the string.

     This string will be used as the argument to
     `ASM_OUTPUT_LABELREF' to produce an assembler label for an
     internal static variable whose name is NAME.  Therefore, the
     string must be such as to result in valid assembler code.  The
     argument NUMBER is different each time this macro is executed;
     it prevents conflicts between similarly-named internal static
     variables in different scopes.

     Ideally this string should not be a valid C identifier, to
     prevent any conflict with the user's own symbols.  Most
     assemblers allow periods or percent signs in assembler symbols;
     putting at least one of these between the name and the number
     will suffice.

`ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)'
     This macro should be provided on machines where the addresses in
     a dispatch table are relative to the table's own address.

     The definition should be a C statement to output to the stdio
     stream STREAM an assembler pseudo-instruction to generate a
     difference between two labels.  VALUE and REL are the numbers of
     two internal labels.  The definitions of these labels are output
     using `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in
     the same way here.  For example,

          fprintf (STREAM, "\t.word L%d-L%d\n",
                   VALUE, REL)

`ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)'
     This macro should be provided on machines where the addresses in
     a dispatch table are absolute.

     The definition should be a C statement to output to the stdio
     stream STREAM an assembler pseudo-instruction to generate a
     reference to a label.  VALUE is the number of an internal label
     whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'. 
     For example,

          fprintf (STREAM, "\t.word L%d\n", VALUE)

`ASM_OUTPUT_DOUBLE (STREAM, VALUE)'
     A C statement to output to the stdio stream STREAM an assembler
     instruction to assemble a `double' constant whose value is
     VALUE.  VALUE will be a C expression of type `double'.

`ASM_OUTPUT_FLOAT (STREAM, VALUE)'
     A C statement to output to the stdio stream STREAM an assembler
     instruction to assemble a `float' constant whose value is VALUE.
     vALUE will be a C expression of type `float'.

`ASM_OUTPUT_INT (STREAM, EXP)'
`ASM_OUTPUT_SHORT (STREAM, EXP)'
`ASM_OUTPUT_CHAR (STREAM, EXP)'
     A C statement to output to the stdio stream STREAM an assembler
     instruction to assemble a `int', `short' or `char' constant
     whose value is VALUE.  The argument EXP will be an RTL
     expression which represents a constant value.  Use
     `output_addr_const (EXP)' to output this value as an assembler
     expression.

`ASM_OUTPUT_BYTE (STREAM, VALUE)'
     A C statement to output to the stdio stream STREAM an assembler
     instruction to assemble a single byte containing the number VALUE.

`ASM_OUTPUT_ASCII (STREAM, PTR, LEN)'
     A C statement to output to the stdio stream STREAM an assembler
     instruction to assemble a string constant containing the LEN
     bytes at PTR.  PTR will be a C expression of type `char *' and
     LEN a C expression of type `int'.

     If the assembler has a `.ascii' pseudo-op as found in the
     Berkeley Unix assembler, do not define the macro
     `ASM_OUTPUT_ASCII'.

`ASM_OUTPUT_SKIP (STREAM, NBYTES)'
     A C statement to output to the stdio stream STREAM an assembler
     instruction to advance the location counter by NBYTES bytes. 
     NBYTES will be a C expression of type `int'.

`ASM_OUTPUT_ALIGN (STREAM, POWER)'
     A C statement to output to the stdio stream STREAM an assembler
     instruction to advance the location counter to a multiple of 2
     to the POWER bytes.  POWER will be a C expression of type `int'.

`ASM_OUTPUT_COMMON (STREAM, NAME, SIZE)'
     A C statement (sans semicolon) to output to the stdio stream
     STREAM the assembler definition of a common-label named NAME
     whose size is SIZE bytes.  Use the expression `assemble_name
     (STREAM, NAME)' to output the name itself; before and after
     that, output the additional assembler syntax for defining the
     name, and a newline.

     This macro controls how the assembler definitions of
     uninitialized global variables are output.

`ASM_OUTPUT_LOCAL (STREAM, NAME, SIZE)'
     A C statement (sans semicolon) to output to the stdio stream
     STREAM the assembler definition of a local-common-label named
     NAME whose size is SIZE bytes.  Use the expression
     `assemble_name (STREAM, NAME)' to output the name itself; before
     and after that, output the additional assembler syntax for
     defining the name, and a newline.

     This macro controls how the assembler definitions of
     uninitialized static variables are output.

`ASM_OUTPUT_SOURCE_LINE (STREAM, LINE)'
     A C statment to output DBX or SDB debugging information before
     code for line number LINE of the current source file to the
     stdio stream STREAM.

     This macro need not be defined if the standard form of debugging
     information for the debugger in use is appropriate.

`TARGET_BELL'
     A C constant expression for the integer value for escape
     sequence `\a'.

`TARGET_BS'
`TARGET_TAB'
`TARGET_NEWLINE'
     C constant expressions for the integer values for escape
     sequences `\b', `\t' and `\n'.

`TARGET_VT'
`TARGET_FF'
`TARGET_CR'
     C constant expressions for the integer values for escape
     sequences `\v', `\f' and `\r'.

`ASM_OUTPUT_OPCODE (STREAM, PTR)'
     Define this macro if you are using an unusual assembler that
     requires different names for the machine instructions.

     The definition is a C statement or statements which output an
     assembler instruction opcode to the stdio stream STREAM.  The
     macro-operand PTR is a variable of type `char *' which points to
     the opcode name in its ``internal'' form--the form that is
     written in the machine description.  The definition should
     output the opcode name to STREAM, performing any translation you
     desire, and increment the variable PTR to point at the end of
     the opcode so that it will not be output twice.

     In fact, your macro definition may process less than the entire
     opcode name, or more than the opcode name; but if you want to
     process text that includes `%'-sequences to substitute operands,
     you must take care of the substitution yourself.  Just be sure
     to increment PTR over whatever text should not be output normally.

     If the macro definition does nothing, the instruction is output
     in the usual way.

`FINAL_PRESCAN_INSN (INSN, OPVEC, NOPERANDS)'
     If defined, a C statement to be executed just prior to the
     output of assembler code for INSN, to modify the extracted
     operands so they will be output differently.

     Here the argument OPVEC is the vector containing the operands
     extracted from INSN, and NOPERANDS is the number of elements of
     the vector which contain meaningful data for this insn.  The
     contents of this vector are what will be used to convert the
     insn template into assembler code, so you can change the
     assembler output by changing the contents of the vector.

     This macro is useful when various assembler syntaxes share a
     single file of instruction patterns; by defining this macro
     differently, you can cause a large class of instructions to be
     output differently (such as with rearranged operands). 
     Naturally, variations in assembler syntax affecting individual
     insn patterns ought to be handled by writing conditional output
     routines in those patterns.

     If this macro is not defined, it is equivalent to a null
     statement.

`PRINT_OPERAND (STREAM, X, CODE)'
     A C compound statement to output to stdio stream STREAM the
     assembler syntax for an instruction operand X.  X is an RTL
     expression.

     CODE is a value that can be used to specify one of several ways
     of printing the operand.  It is used when identical operands
     must be printed differently depending on the context.  CODE
     comes from the `%' specification that was used to request
     printing of the operand.  If the specification was just `%DIGIT'
     then CODE is 0; if the specification was `%LTR DIGIT' then CODE
     is the ASCII code for LTR.

     If X is a register, this macro should print the register's name.
     The names can be found in an array `reg_names' whose type is
     `char *[]'.  `reg_names' is initialized from `REGISTER_NAMES'.

     When the machine description has a specification `%PUNCT' (a `%'
     followed by a punctuation character), this macro is called with
     a null pointer for X and the punctuation character for CODE.

`PRINT_OPERAND_ADDRESS (STREAM, X)'
     A C compound statement to output to stdio stream STREAM the
     assembler syntax for an instruction operand that is a memory
     reference whose address is X.  X is an RTL expression.

`ASM_OPEN_PAREN'
`ASM_CLOSE_PAREN'
     These macros are defined as C string constant, describing the
     syntax in the assembler for grouping arithmetic expressions. 
     The following definitions are correct for most assemblers:

          #define ASM_OPEN_PAREN "("
          #define ASM_CLOSE_PAREN ")"



File: internals,  Node: Config,  Prev: Machine Macros,  Up: Top

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

The configuration file `config-MACHINE.h' contains macro definitions
that describe the machine and system on which the compiler is
running.  Most of the values in it are actually the same on all
machines that GNU CC runs on, so most all configuration files are
identical.  But there are some macros that vary:

`FAILURE_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.

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