Added gccHEADmaster

1 files changed, 1161 insertions, 0 deletions

diff --git a/gcc-1.40/gcc.info-10 b/gcc-1.40/gcc.info-10
new file mode 100644
index 0000000..7a22672
--- /dev/null
+++ b/gcc-1.40/gcc.info-10
@@ -0,0 +1,1161 @@
+Info file gcc.info, produced by Makeinfo, -*- Text -*- from input
+file gcc.texinfo.
+
+   This file documents the use and the internals of the GNU compiler.
+
+   Copyright (C) 1988, 1989, 1990 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 sections entitled "GNU General Public License" and "Protect
+Your Freedom--Fight `Look And Feel'" are 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 sections entitled "GNU General Public
+License" and "Protect Your Freedom--Fight `Look And Feel'" and this
+permission notice may be included in translations approved by the
+Free Software Foundation instead of in the original English.
+
+
+File: gcc.info,  Node: Addressing Modes,  Next: Delayed Branch,  Prev: Library Calls,  Up: Machine Macros
+
+Addressing Modes
+================
+
+`HAVE_POST_INCREMENT'
+     Define this macro if the machine supports post-increment
+     addressing.
+
+`HAVE_PRE_INCREMENT'
+`HAVE_POST_DECREMENT'
+`HAVE_PRE_DECREMENT'
+     Similar for other kinds of addressing.
+
+`CONSTANT_ADDRESS_P (X)'
+     A C expression that is 1 if the RTX X is a constant whose value
+     is an integer.  This includes integers whose values are not
+     explicitly known, such as `symbol_ref' and `label_ref'
+     expressions and `const' arithmetic expressions.
+
+     On most machines, this can be defined as `CONSTANT_P (X)', but a
+     few machines are more restrictive in which constant addresses
+     are supported.
+
+`MAX_REGS_PER_ADDRESS'
+     A number, the maximum number of registers that can appear in a
+     valid memory address.  Note that it is up to you to specify a
+     value equal to the maximum number that
+     `go_if_legitimate_address' would ever accept.
+
+`GO_IF_LEGITIMATE_ADDRESS (MODE, X, LABEL)'
+     A C compound statement with a conditional `goto LABEL;' executed
+     if X (an RTX) is a legitimate memory address on the target
+     machine for a memory operand of mode MODE.
+
+     It usually pays to define several simpler macros to serve as
+     subroutines for this one.  Otherwise it may be too complicated
+     to understand.
+
+     This macro must exist in two variants: a strict variant and a
+     non-strict one.  The strict variant is used in the reload pass. 
+     It must be defined so that any pseudo-register that has not been
+     allocated a hard register is considered a memory reference.  In
+     contexts where some kind of register is required, a
+     pseudo-register with no hard register must be rejected.
+
+     The non-strict variant is used in other passes.  It must be
+     defined to accept all pseudo-registers in every context where
+     some kind of register is required.
+
+     Compiler source files that want to use the strict variant of
+     this macro define the macro `REG_OK_STRICT'.  You should use an
+     `#ifdef REG_OK_STRICT' conditional to define the strict variant
+     in that case and the non-strict variant otherwise.
+
+     Typically among the subroutines used to define
+     `GO_IF_LEGITIMATE_ADDRESS' are subroutines to check for
+     acceptable registers for various purposes (one for base
+     registers, one for index registers, and so on).  Then only these
+     subroutine macros need have two variants; the higher levels of
+     macros may be the same whether strict or not.
+
+     Normally, constant addresses which are the sum of a `symbol_ref'
+     and an integer are stored inside a `const' RTX to mark them as
+     constant.  Therefore, there is no need to recognize such sums as
+     legitimate addresses.
+
+     Usually `PRINT_OPERAND_ADDRESS' is not prepared to handle
+     constant sums that are not marked with  `const'.  It assumes
+     that a naked `plus' indicates indexing.  If so, then you *must*
+     reject such naked constant sums as illegitimate addresses, so
+     that none of them will be given to `PRINT_OPERAND_ADDRESS'.
+
+`REG_OK_FOR_BASE_P (X)'
+     A C expression that is nonzero if X (assumed to be a `reg' RTX)
+     is valid for use as a base register.  For hard registers, it
+     should always accept those which the hardware permits and reject
+     the others.  Whether the macro accepts or rejects pseudo
+     registers must be controlled by `REG_OK_STRICT' as described
+     above.  This usually requires two variant definitions, of which
+     `REG_OK_STRICT' controls the one actually used.
+
+`REG_OK_FOR_INDEX_P (X)'
+     A C expression that is nonzero if X (assumed to be a `reg' RTX)
+     is valid for use as an index register.
+
+     The difference between an index register and a base register is
+     that the index register may be scaled.  If an address involves
+     the sum of two registers, neither one of them scaled, then
+     either one may be labeled the "base" and the other the "index";
+     but whichever labeling is used must fit the machine's
+     constraints of which registers may serve in each capacity.  The
+     compiler will try both labelings, looking for one that is valid,
+     and will reload one or both registers only if neither labeling
+     works.
+
+`LEGITIMIZE_ADDRESS (X, OLDX, MODE, WIN)'
+     A C compound statement that attempts to replace X with a valid
+     memory address for an operand of mode MODE.  WIN will be a C
+     statement label elsewhere in the code; the macro definition may
+     use
+
+          GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN);
+
+     to avoid further processing if the address has become legitimate.
+
+     X will always be the result of a call to
+     `break_out_memory_refs', and OLDX will be the operand that was
+     given to that function to produce X.
+
+     The code generated by this macro should not alter the
+     substructure of X.  If it transforms X into a more legitimate
+     form, it should assign X (which will always be a C variable) a
+     new value.
+
+     It is not necessary for this macro to come up with a legitimate
+     address.  The compiler has standard ways of doing so in all
+     cases.  In fact, it is safe for this macro to do nothing.  But
+     often a machine-dependent strategy can generate better code.
+
+`GO_IF_MODE_DEPENDENT_ADDRESS (ADDR, LABEL)'
+     A C statement or compound statement with a conditional `goto
+     LABEL;' executed if memory address X (an RTX) can have different
+     meanings depending on the machine mode of the memory reference
+     it is used for.
+
+     Autoincrement and autodecrement addresses typically have
+     mode-dependent effects because the amount of the increment or
+     decrement is the size of the operand being addressed.  Some
+     machines have other mode-dependent addresses.  Many RISC
+     machines have no mode-dependent addresses.
+
+     You may assume that ADDR is a valid address for the machine.
+
+`LEGITIMATE_CONSTANT_P (X)'
+     A C expression that is nonzero if X is a legitimate constant for
+     an immediate operand on the target machine.  You can assume that
+     either X is a `const_double' or it satisfies `CONSTANT_P', so
+     you need not check these things.  In fact, `1' is a suitable
+     definition for this macro on machines where any `const_double'
+     is valid and anything `CONSTANT_P' is valid.
+
+
+File: gcc.info,  Node: Delayed Branch,  Next: Condition Code,  Prev: Addressing Modes,  Up: Machine Macros
+
+Parameters for Delayed Branch Optimization
+==========================================
+
+`HAVE_DELAYED_BRANCH'
+     Define this macro if the target machine has delayed branches,
+     that is, a branch does not take effect immediately, and the
+     actual branch instruction may be followed by one or more
+     instructions that will be issued before the PC is actually
+     changed.
+
+     If defined, this allows a special scheduling pass to be run
+     after the second jump optimization to attempt to reorder
+     instructions to exploit this.  Defining this macro also requires
+     the definition of certain other macros described below.
+
+`DBR_SLOTS_AFTER (INSN)'
+     This macro must be defined if `HAVE_DELAYED_BRANCH' is defined. 
+     Its definition should be a C expression returning the number of
+     available delay slots following the instruction(s) output by the
+     pattern for INSN.  The definition of "slot" is
+     machine-dependent, and may denote instructions, bytes, or
+     whatever.
+
+`DBR_INSN_SLOTS (INSN)'
+     This macro must be defined if `HAVE_DELAYED_BRANCH' is defined. 
+     It should be a C expression returning the number of slots
+     (typically the number of machine instructions) consumed by INSN.
+
+     You may assume that INSN is truly an insn, not a note, label,
+     barrier, dispatch table, `use', or `clobber'.
+
+`DBR_INSN_ELIGIBLE_P (INSN, DINSN)'
+     A C expression whose value is non-zero if it is legitimate to
+     put INSN in the delay slot following DINSN.
+
+     You do not need to take account of data flow considerations in
+     the definition of this macro, because the delayed branch
+     optimizer always does that.  This macro is needed only when
+     certain insns may not be placed in certain delay slots for
+     reasons not evident from the RTL expressions themselves.  If
+     there are no such problems, you don't need to define this macro.
+
+     You may assume that INSN is truly an insn, not a note, label,
+     barrier, dispatch table, `use', or `clobber'.  You may assume
+     that DINSN is a jump insn with a delay slot.
+
+`DBR_OUTPUT_SEQEND(FILE)'
+     A C statement, to be executed after all slot-filler instructions
+     have been output.  If necessary, call `dbr_sequence_length' to
+     determine the number of slots filled in a sequence (zero if not
+     currently outputting a sequence), to decide how many no-ops to
+     output, or whatever.
+
+     Don't define this macro if it has nothing to do, but it is
+     helpful in reading assembly output if the extent of the delay
+     sequence is made explicit (e.g. with white space).
+
+     Note that output routines for instructions with delay slots must
+     be prepared to deal with not being output as part of a sequence
+     (i.e.  when the scheduling pass is not run, or when no slot
+     fillers could be found.)  The variable `final_sequence' is null
+     when not processing a sequence, otherwise it contains the
+     `sequence' rtx being output.
+
+
+File: gcc.info,  Node: Condition Code,  Next: Cross-compilation,  Prev: Delayed Branch,  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 to initialize the `mdep' field to "empty".  The
+     default definition does nothing, since most machines don't use
+     the field anyway.  If you want to use the field, you should
+     probably define this macro to initialize it.
+
+`NOTICE_UPDATE_CC (EXP, INSN)'
+     A C compound statement to set the components of `cc_status'
+     appropriately for an insn 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: gcc.info,  Node: Cross-compilation,  Next: Misc,  Prev: Condition Code,  Up: Machine Macros
+
+Cross Compilation and Floating-Point Format
+===========================================
+
+   While all modern machines use 2's complement representation for
+integers, there are a variety of representations for floating point
+numbers.  This means that in a cross-compiler the representation of
+floating point numbers in the compiled program may be different from
+that used in the machine doing the compilation.
+
+   Because different representation systems may offer different
+amounts of range and precision, the cross compiler cannot safely use
+the host machine's floating point arithmetic.  Therefore, floating
+point constants must be represented in the target machine's format. 
+This means that the cross compiler cannot use `atof' to parse a
+floating point constant; it must have its own special routine to use
+instead.  Also, constant folding must emulate the target machine's
+arithmetic (or must not be done at all).
+
+   The macros in the following table should be defined only if you
+are cross compiling between different floating point formats.
+
+   Otherwise, don't define them. Then default definitions will be set
+up which use `double' as the data type, `==' to test for equality, etc.
+
+   You don't need to worry about how many times you use an operand of
+any of these macros.  The compiler never uses operands which have
+side effects.
+
+`REAL_VALUE_TYPE'
+     A macro for the C data type to be used to hold a floating point
+     value in the target machine's format.  Typically this would be a
+     `struct' containing an array of `int'.
+
+`REAL_VALUES_EQUAL (X, Y)'
+     A macro for a C expression which compares for equality the two
+     values, X and Y, both of type `REAL_VALUE_TYPE'.
+
+`REAL_VALUES_LESS (X, Y)'
+     A macro for a C expression which tests whether X is less than Y,
+     both values being of type `REAL_VALUE_TYPE' and interpreted as
+     floating point numbers in the target machine's representation.
+
+`REAL_VALUE_LDEXP (X, SCALE)'
+     A macro for a C expression which performs the standard library
+     function `ldexp', but using the target machine's floating point
+     representation.  Both X and the value of the expression have
+     type `REAL_VALUE_TYPE'.  The second argument, SCALE, is an
+     integer.
+
+`REAL_VALUE_ATOF (STRING)'
+     A macro for a C expression which converts STRING, an expression
+     of type `char *', into a floating point number in the target
+     machine's representation.  The value has type `REAL_VALUE_TYPE'.
+
+   Define the following additional macros if you want to make
+floating point constant folding work while cross compiling.  If you
+don't define them, cross compilation is still possible, but constant
+folding will not happen for floating point values.
+
+`REAL_ARITHMETIC (OUTPUT, CODE, X, Y)'
+     A macro for a C statement which calculates an arithmetic
+     operation of the two floating point values X and Y, both of type
+     `REAL_VALUE_TYPE' in the target machine's representation, to
+     produce a result of the same type and representation which is
+     stored in OUTPUT (which will be a variable).
+
+     The operation to be performed is specified by CODE, a tree code
+     which will always be one of the following: `PLUS_EXPR',
+     `MINUS_EXPR', `MULT_EXPR', `RDIV_EXPR', `MAX_EXPR', `MIN_EXPR'.
+
+     The expansion of this macro is responsible for checking for
+     overflow.  If overflow happens, the macro expansion should
+     execute the statement `return 0;', which indicates the inability
+     to perform the arithmetic operation requested.
+
+`REAL_VALUE_NEGATE (X)'
+     A macro for a C expression which returns the negative of the
+     floating point value X.  Both X and the value of the expression
+     have type `REAL_VALUE_TYPE' and are in the target machine's
+     floating point representation.
+
+     There is no way for this macro to report overflow, since
+     overflow can't happen in the negation operation.
+
+`REAL_VALUE_TO_INT (LOW, HIGH, X)'
+     A macro for a C expression which converts a floating point value
+     X into a double-precision integer which is then stored into LOW
+     and HIGH, two variables of type INT.
+
+`REAL_VALUE_FROM_INT (X, LOW, HIGH)'
+     A macro for a C expression which converts a double-precision
+     integer found in LOW and HIGH, two variables of type INT, into a
+     floating point value which is then stored into X.
+
+
+File: gcc.info,  Node: Misc,  Next: Assembler Format,  Prev: Cross-compilation,  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.
+
+`HAVE_VPRINTF'
+     Define this if the library function `vprintf' is available on
+     your system.
+
+`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.  If you don't define this, the default is one
+     word.
+
+`SHORT_TYPE_SIZE'
+     A C expression for the size in bits of the type `short' on the
+     target machine.  If you don't define this, the default is half a
+     word.  (If this would be less than one storage unit, it is
+     rounded up to one unit.)
+
+`LONG_TYPE_SIZE'
+     A C expression for the size in bits of the type `long' on the
+     target machine.  If you don't define this, the default is one
+     word.
+
+`LONG_LONG_TYPE_SIZE'
+     A C expression for the size in bits of the type `long long' on
+     the target machine.  If you don't define this, the default is
+     two words.
+
+`CHAR_TYPE_SIZE'
+     A C expression for the size in bits of the type `char' on the
+     target machine.  If you don't define this, the default is one
+     quarter of a word.  (If this would be less than one storage
+     unit, it is rounded up to one unit.)
+
+`FLOAT_TYPE_SIZE'
+     A C expression for the size in bits of the type `float' on the
+     target machine.  If you don't define this, the default is one
+     word.
+
+`DOUBLE_TYPE_SIZE'
+     A C expression for the size in bits of the type `double' on the
+     target machine.  If you don't define this, the default is two
+     words.
+
+`LONG_DOUBLE_TYPE_SIZE'
+     A C expression for the size in bits of the type `long double' on
+     the target machine.  If you don't define this, the default is
+     two words.
+
+`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 or a negative 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'.
+
+`INSN_MACHINE_INFO'
+     This macro should expand into a C structure type to use for the
+     machine-dependent info field specified with the optional last
+     argument in `define_insn' and `define_peephole' patterns.  For
+     example, it might expand into `struct machine_info'; then it
+     would be up to you to define this structure in the `tm.h' file.
+
+     You do not need to define this macro if you do not write the
+     optional last argument in any of the patterns in the machine
+     description.
+
+`DEFAULT_MACHINE_INFO'
+     This macro should expand into a C initializer to use to
+     initialize the machine-dependent info for one insn pattern.  It
+     is used for patterns that do not specify the machine-dependent
+     info.
+
+     If you do not define this macro, zero is used.
+
+`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: gcc.info,  Node: Assembler Format,  Prev: Misc,  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'.
+
+`LIBG_SPEC'
+     Another C string constant used much like `LINK_SPEC'.  This
+     controls whether to link `libg.a' when debugging.  Some systems
+     expect this; others do not have any `libg.a'.
+
+     If this macro is not defined, a default is provided that loads
+     the `libg.a' provided `-g' is specified.  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'.
+
+`STANDARD_EXEC_PREFIX'
+     Define this macro as a C string constant if you wish to override
+     the standard choice of `/usr/local/lib/gcc-' as the default
+     prefix to try when searching for the executable files of the
+     compiler.
+
+     The prefix specified by the `-B' option, if any, is tried before
+     the default prefix.  After the default prefix, if the executable
+     is not found that way, `/usr/lib/gcc-' is tried next; then the
+     directories in your search path for shell commands are searched.
+
+`STANDARD_STARTFILE_PREFIX'
+     Define this macro as a C string constant if you wish to override
+     the standard choice of `/usr/local/lib/' as the default prefix
+     to try when searching for startup files such as `crt0.o'.
+
+     In this search, all the prefixes tried for executable files are
+     tried first.  Then comes the default startfile prefix specified
+     by this macro, followed by the prefixes `/lib/' and `/usr/lib/'
+     as last resorts.
+
+`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_FILE_END (STREAM)'
+     A C expression which outputs to the stdio stream STREAM some
+     appropriate text to go at the end of an assembler file.
+
+     If this macro is not defined, the default is to output nothing
+     special at the end of the file.  Most systems don't require any
+     definition.
+
+     On systems that use SDB, it is necessary to output certain
+     commands; see `tm-attasm.h'.
+
+`ASM_IDENTIFY_GCC (FILE)'
+     A C statement to output assembler commands which will identify
+     the object file as having been compiled with GNU CC (or another
+     GNU compiler).
+
+     If you don't define this macro, the string `gcc_compiled.:' is
+     output.  This string is calculated to define a symbol which, on
+     BSD systems, will never be defined for any other reason.  GDB
+     checks for the presence of this symbol when reading the symbol
+     table of an executable.
+
+     On non-BSD systems, you must arrange communication with GDB in
+     some other fashion.  If GDB is not used on your system, you can
+     define this macro with an empty body.
+
+`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.
+
+`EXTRA_SECTIONS'
+     A list of names for sections other than the standard two, which
+     are `in_text' and `in_data'.  You need not define this macro on
+     a system with no other sections (that GCC needs to use).
+
+`EXTRA_SECTION_FUNCTIONS'
+     One or more functions to be defined in `varasm.c'.  These
+     functions should do jobs analogous to those of `text_section'
+     and `data_section', for your additional sections.  Do not define
+     this macro if you do not define `EXTRA_SECTIONS'.
+
+`SELECT_SECTION (EXP)'
+     A C statement or statements to switch to the appropriate section
+     for output of EXP.  You can assume that EXP is either a
+     `VAR_DECL' node or a constant of some sort.  Select the section
+     by calling `text_section' or one of the alternatives for other
+     sections.
+
+     Do not define this macro if you use only the standard two
+     sections and put all read-only variables and constants in the
+     text section.
+
+`SELECT_RTX_SECTION (MODE, RTX)'
+     A C statement or statements to switch to the appropriate section
+     for output of RTX in mode MODE.  You can assume that RTX is some
+     kind of constant in RTL.  The argument MODE is redundant except
+     in the case of a `const_int' rtx.  Select the section by calling
+     `text_section' or one of the alternatives for other sections.
+
+     Do not define this macro if you use only the standard two
+     sections and put all constants in the text section.
+
+`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 information.
+
+`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.
+
+`DBX_STATIC_STAB_DATA_SECTION'
+     Define this macro if it is necessary to go to the data section
+     before outputting the `.stabs' pseudo-op for a non-global static
+     variable.
+
+`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, DECL, NAME)'
+     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_OUTPUT_ALIGN_CODE (FILE)'
+     A C expression to output text to align the location counter in
+     the way that is desirable at a point in the code that is reached
+     only by jumping.
+
+     This macro need not be defined if you don't want any special
+     alignment to be done at such a time.  Most machine descriptions
+     do not currently define the macro.
+
+`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_REG_PUSH (STREAM, REGNO)'
+     A C expression to output to STREAM some assembler code which
+     will push hard register number REGNO onto the stack.  The code
+     need not be optimal, since this macro is used only when profiling.
+
+`ASM_OUTPUT_REG_POP (STREAM, REGNO)'
+     A C expression to output to STREAM some assembler code which
+     will pop hard register number REGNO off of the stack.  The code
+     need not be optimal, since this macro is used only when profiling.
+
+`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 (STREAM, EXP)' to output this value as an
+     assembler expression.
+
+`ASM_OUTPUT_DOUBLE_INT (STREAM, EXP)'
+     A C statement to output to the stdio stream STREAM an assembler
+     instruction to assemble a `long long' constant whose value is
+     EXP.  The argument EXP will be an RTL expression which
+     represents a constant value.  It may be a `const_double' RTX, or
+     it may be an ordinary single-precision constant.  In the latter
+     case, you should zero-extend it.
+
+`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, ROUNDED)'
+     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.  The variable ROUNDED is the size
+     rounded up to whatever alignment the caller wants.
+
+     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, ROUNDED)'
+     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.  The variable ROUNDED is the size
+     rounded up to whatever alignment the caller wants.
+
+     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_FILENAME (STREAM, NAME)'
+     A C statment to output DBX or SDB debugging information which
+     indicates that filename NAME is 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.
+
+`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.
+
+`ASM_OUTPUT_IDENT (STREAM, STRING)'
+     A C statement to output something to the assembler file to
+     handle a `#ident' directive containing the text STRING.  If this
+     macro is not defined, nothing is output for a `#ident' directive.
+
+`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 you need to look at the operand values, they can be found as
+     the elements of `recog_operand'.
+
+     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_PUNCT_VALID_P (CODE)'
+     A C expression which evaluates to true if CODE is a valid
+     punctuation character for use in the `PRINT_OPERAND' macro.  If
+     `PRINT_OPERAND_PUNCT_VALID_P' is not defined, it means that no
+     punctuation characters (except for the standard one, `%') are
+     used in this way.
+
+`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 ")"
+
+
\ No newline at end of file