This is Info file gcc.info, produced by Makeinfo-1.47 from the 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 ")"

