Otherware/Otherware_1_SB_Development.iso/amiga/programm/language/gcc222.lha/info/gcc.info-16

GNU Info File | 1992-07-19 | 51KB | 881 lines

This is Info file gcc.info, produced by Makeinfo-1.47 from the input
file gcc.texi.
   This file documents the use and the internals of the GNU compiler.
   Copyright (C) 1988, 1989, 1992 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 "Boycott"
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 "Boycott", 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: Costs,  Next: Sections,  Prev: Condition Code,  Up: Target Macros
Describing Relative Costs of Operations
=======================================
   These macros let you describe the relative speed of various
operations on the target machine.
`CONST_COSTS (X, CODE, OUTER_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, and the rtx code of the expression in which it is contained,
     found in OUTER_CODE.
     CODE is the expression code--redundant, since it can be obtained
     with `GET_CODE (X)'.
`RTX_COSTS (X, CODE, OUTER_CODE)'
     Like `CONST_COSTS' but applies to nonconstant RTL expressions.
     This can be used, for example, to indicate how costly a multiply
     instruction is.  In writing this macro, you can use the construct
     `COSTS_N_INSNS (N)' to specify a cost equal to N fast
     instructions.  OUTER_CODE is the code of the expression in which X
     is contained.
     This macro is optional; do not define it if the default cost
     assumptions are adequate for the target machine.
`ADDRESS_COST (ADDRESS)'
     An expression giving the cost of an addressing mode that contains
     ADDRESS.  If not defined, the cost is computed from the ADDRESS
     expression and the `CONST_COSTS' values.
     For most CISC machines, the default cost is a good approximation
     of the true cost of the addressing mode.  However, on RISC
     machines, all instructions normally have the same length and
     execution time.  Hence all addresses will have equal costs.
     In cases where more than one form of an address is known, the form
     with the lowest cost will be used.  If multiple forms have the
     same, lowest, cost, the one that is the most complex will be used.
     For example, suppose an address that is equal to the sum of a
     register and a constant is used twice in the same basic block.
     When this macro is not defined, the address will be computed in a
     register and memory references will be indirect through that
     register.  On machines where the cost of the addressing mode
     containing the sum is no higher than that of a simple indirect
     reference, this will produce an additional instruction and
     possibly require an additional register.  Proper specification of
     this macro eliminates this overhead for such machines.
     Similar use of this macro is made in strength reduction of loops.
     ADDRESS need not be valid as an address.  In such a case, the cost
     is not relevant and can be any value; invalid addresses need not be
     assigned a different cost.
     On machines where an address involving more than one register is as
     cheap as an address computation involving only one register,
     defining `ADDRESS_COST' to reflect this can cause two registers to
     be live over a region of code where only one would have been if
     `ADDRESS_COST' were not defined in that manner.  This effect should
     be considered in the definition of this macro.  Equivalent costs
     should probably only be given to addresses with different numbers
     of registers on machines with lots of registers.
     This macro will normally either not be defined or be defined as a
     constant.
`REGISTER_MOVE_COST (FROM, TO)'
     A C expression for the cost of moving data from a register in class
     FROM to one in class TO.  The classes are expressed using the
     enumeration values such as `GENERAL_REGS'.  A value of 2 is the
     default; other values are interpreted relative to that.
     It is not required that the cost always equal 2 when FROM is the
     same as TO; on some machines it is expensive to move between
     registers if they are not general registers.
     If reload sees an insn consisting of a single `set' between two
     hard registers, and if `REGISTER_MOVE_COST' applied to their
     classes returns a value of 2, reload does not check to ensure that
     the constraints of the insn are met.  Setting a cost of other than
     2 will allow reload to verify that the constraints are met.  You
     should do this if the `movM' pattern's constraints do not allow
     such copying.
`MEMORY_MOVE_COST (M)'
     A C expression for the cost of moving data of mode M between a
     register and memory.  A value of 2 is the default; this cost is
     relative to those in `REGISTER_MOVE_COST'.
     If moving between registers and memory is more expensive than
     between two registers, you should define this macro to express the
     relative cost.
`BRANCH_COST'
     A C expression for the cost of a branch instruction.  A value of 1
     is the default; other values are interpreted relative to that.
   Here are additional macros which do not specify precise relative
costs, but only that certain actions are more expensive than GNU CC
would ordinarily expect.
`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 no
     faster than accessing a word of memory, i.e., if such access
     require more than one instruction or if there is no difference in
     cost between byte and (aligned) word loads.
     When this macro is not defined, the compiler will access a field by
     finding the smallest containing object; when it is defined, a
     fullword load will be used if alignment permits.  Unless bytes
     accesses are faster than word accesses, using word accesses is
     preferable since it may eliminate subsequent memory access if
     subsequent accesses occur to other fields in the same word of the
     structure, but to different bytes.
`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'.
`SLOW_UNALIGNED_ACCESS'
     Define this macro to be the value 1 if unaligned accesses have a
     cost many times greater than aligned accesses, for example if they
     are emulated in a trap handler.
     When this macro is non-zero, the compiler will act as if
     `STRICT_ALIGNMENT' were non-zero when generating code for block
     moves.  This can cause significantly more instructions to be
     produced. Therefore, do not set this macro non-zero if unaligned
     accesses only add a cycle or two to the time for a memory access.
     If the value of this macro is always zero, it need not be defined.
`DONT_REDUCE_ADDR'
     Define this macro to inhibit strength reduction of memory
     addresses. (On some machines, such strength reduction seems to do
     harm rather than good.)
`MOVE_RATIO'
     The number of scalar move insns which should be generated instead
     of a string move insn or a library call.  Increasing the value
     will always make code faster, but eventually incurs high cost in
     increased code size.
     If you don't define this, a reasonable default is used.
`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.
`NO_RECURSIVE_FUNCTION_CSE'
     Define this macro if it is as good or better for a function to call
     itself with an explicit address than to call an address kept in a
     register.
File: gcc.info,  Node: Sections,  Next: PIC,  Prev: Costs,  Up: Target Macros
Dividing the Output into Sections (Texts, Data, ...)
====================================================
   An object file is divided into sections containing different types of
data.  In the most common case, there are three sections: the "text
section", which holds instructions and read-only data; the "data
section", which holds initialized writable data; and the "bss section",
which holds uninitialized data.  Some systems have other kinds of
sections.
   The compiler must tell the assembler when to switch sections.  These
macros control what commands to output to tell the assembler this.  You
can also define additional sections.
`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.
`SHARED_SECTION_ASM_OP'
     If defined, a C string constant for the assembler operation to
     identify the following data as shared data.  If not defined,
     `DATA_SECTION_ASM_OP' will be used.
`INIT_SECTION_ASM_OP'
     If defined, a C string constant for the assembler operation to
     identify the following data as initialization code.  If not
     defined, GNU CC will assume such a section does not exist.
`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'.
`READONLY_DATA_SECTION'
     On most machines, read-only variables, constants, and jump tables
     are placed in the text section.  If this is not the case on your
     machine, this macro should be defined to be the name of a function
     (either `data_section' or a function defined in `EXTRA_SECTIONS')
     that switches to the section to be used for read-only items.
     If these items should be placed in the text section, this macro
     should not be defined.
`SELECT_SECTION (EXP, RELOC)'
     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.  RELOC indicates whether the
     initial value of EXP requires link-time relocations.  Select the
     section by calling `text_section' or one of the alternatives for
     other sections.
     Do not define this macro if you put all read-only variables and
     constants in the read-only data section (usually 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 put all constants in the read-only
     data section.
`JUMP_TABLES_IN_TEXT_SECTION'
     Define this macro if jump tables (for `tablejump' insns) should be
     output in the text section, along with the assembler instructions.
     Otherwise, the readonly data section is used.
     This macro is irrelevant if there is no separate readonly data
     section.
`ENCODE_SECTION_INFO (DECL)'
     Define this macro if references to a symbol must be treated
     differently depending on something about the variable or function
     named by the symbol (such as what section it is in).
     The macro definition, if any, is executed immediately after the
     rtl for DECL has been created and stored in `DECL_RTL (DECL)'. The
     value of the rtl will be a `mem' whose address is a `symbol_ref'.
     The usual thing for this macro to do is to record a flag in the
     `symbol_ref' (such as `SYMBOL_REF_FLAG') or to store a modified
     name string in the `symbol_ref' (if one bit is not enough
     information).
File: gcc.info,  Node: PIC,  Next: Assembler Format,  Prev: Sections,  Up: Target Macros
Position Independent Code
=========================
   This section describes macros that help implement generation of
position independent code.  Simply defining these macros is not enough
to generate valid PIC; you must also add support to the macros
`GO_IF_LEGITIMATE_ADDRESS' and `LEGITIMIZE_ADDRESS', and
`PRINT_OPERAND_ADDRESS' as well.  You must modify the definition of
`movsi' to do something appropriate when the source operand contains a
symbolic address.  You may also need to alter the handling of switch
statements so that they use relative addresses.
`PIC_OFFSET_TABLE_REGNUM'
     The register number of the register used to address a table of
     static data addresses in memory.  In some cases this register is
     defined by a processor's "application binary interface" (ABI).
     When this macro is defined, RTL is generated for this register
     once, as with the stack pointer and frame pointer registers.  If
     this macro is not defined, it is up to the machine-dependent files
     to allocate such a register (if necessary).
`FINALIZE_PIC'
     By generating position-independent code, when two different
     programs (A and B) share a common library (libC.a), the text of
     the library can be shared whether or not the library is linked at
     the same address for both programs.  In some of these
     environments, position-independent code requires not only the use
     of different addressing modes, but also special code to enable the
     use of these addressing modes.
     The `FINALIZE_PIC' macro serves as a hook to emit these special
     codes once the function is being compiled into assembly code, but
     not before.  (It is not done before, because in the case of
     compiling an inline function, it would lead to multiple PIC
     prologues being included in functions which used inline functions
     and were compiled to assembly language.)
File: gcc.info,  Node: Assembler Format,  Next: Debugging Info,  Prev: PIC,  Up: Target Macros
Defining the Output Assembler Language
======================================
   This section describes macros whose principal purpose is to describe
how to write instructions in assembler language--rather than what the
instructions do.
* Menu:
* File Framework::       Structural information for the assembler file.
* Data Output::          Output of constants (numbers, strings, addresses).
* Uninitialized Data::   Output of uninitialized variables.
* Label Output::         Output and generation of labels.
* Constructor Output::     Output of initialization and termination routines.
* Instruction Output::   Output of actual instructions.
* Dispatch Tables::      Output of jump tables.
* Alignment Output::     Pseudo ops for alignment and skipping data.
File: gcc.info,  Node: File Framework,  Next: Data Output,  Up: Assembler Format
The Overall Framework of an Assembler File
------------------------------------------
`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 `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 `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_COMMENT_START'
     A C string constant describing how to begin a comment in the target
     assembler language.  The compiler assumes that the comment will
     end at the end of the line.
`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.
`ASM_OUTPUT_SOURCE_FILENAME (STREAM, NAME)'
     A C statement to output COFF information or DWARF 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 output for
     the file format in use is appropriate.
`ASM_OUTPUT_SOURCE_LINE (STREAM, LINE)'
     A C statement 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.
`OBJC_PROLOGUE'
     A C statement to output any assembler statements which are
     required to precede any Objective C object definitions or message
     sending.  The statement is executed only when compiling an
     Objective C program.
File: gcc.info,  Node: Data Output,  Next: Uninitialized Data,  Prev: File Framework,  Up: Assembler Format
Output of Data
--------------
`ASM_OUTPUT_LONG_DOUBLE (STREAM, VALUE)'
`ASM_OUTPUT_DOUBLE (STREAM, VALUE)'
`ASM_OUTPUT_FLOAT (STREAM, VALUE)'
     A C statement to output to the stdio stream STREAM an assembler
     instruction to assemble a floating-point constant of `TFmode',
     `DFmode' or `SFmode', respectively, whose value is VALUE.  VALUE
     will be a C expression of type `REAL_VALUE__TYPE', usually
     `double'.
`ASM_OUTPUT_QUADRUPLE_INT (STREAM, EXP)'
`ASM_OUTPUT_DOUBLE_INT (STREAM, EXP)'
`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 an integer of 16, 8, 4, 2 or 1 bytes,
     respectively, 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.
     For sizes larger than `UNITS_PER_WORD', if the action of a macro
     would be identical to repeatedly calling the macro corresponding to
     a size of `UNITS_PER_WORD', once for each word, you need not define
     the macro.
`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_BYTE_OP'
     A C string constant giving the pseudo-op to use for a sequence of
     single-byte constants.  If this macro is not defined, the default
     is `"byte"'.
`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_POOL_PROLOGUE (FILE FUNNAME FUNDECL SIZE)'
     A C statement to output assembler commands to define the start of
     the constant pool for a function.  FUNNAME is a string giving the
     name of the function.  Should the return type of the function be
     required, it can be obtained via FUNDECL.  SIZE is the size, in
     bytes, of the constant pool that will be written immediately after
     this call.
     If no constant-pool prefix is required, the usual case, this macro
     need not be defined.
`ASM_OUTPUT_SPECIAL_POOL_ENTRY (FILE, X, MODE, ALIGN, LABELNO, JUMPTO)'
     A C statement (with or without semicolon) to output a constant in
     the constant pool, if it needs special treatment.  (This macro
     need not do anything for RTL expressions that can be output
     normally.)
     The argument FILE is the standard I/O stream to output the
     assembler code on.  X is the RTL expression for the constant to
     output, and MODE is the machine mode (in case X is a `const_int').
      ALIGN is the required alignment for the value X; you should
     output an assembler directive to force this much alignment.
     The argument LABELNO is a number to use in an internal label for
     the address of this pool entry.  The definition of this macro is
     responsible for outputting the label definition at the proper
     place. Here is how to do this:
          ASM_OUTPUT_INTERNAL_LABEL (FILE, "LC", LABELNO);
     When you output a pool entry specially, you should end with a
     `goto' to the label JUMPTO.  This will prevent the same pool entry
     from being output a second time in the usual manner.
     You need not define this macro if it would do nothing.
`ASM_OPEN_PAREN'
`ASM_CLOSE_PAREN'
     These macros are defined as C string constant, describing the
     syntax in the assembler for grouping arithmetic expressions.  The
     following definitions are correct for most assemblers:
          #define ASM_OPEN_PAREN "("
          #define ASM_CLOSE_PAREN ")"
File: gcc.info,  Node: Uninitialized Data,  Next: Label Output,  Prev: Data Output,  Up: Assembler Format
Output of Uninitialized Variables
---------------------------------
   Each of the macros in this section is used to do the whole job of
outputting a single uninitialized variable.
`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_ALIGNED_COMMON (STREAM, NAME, SIZE, ALIGNMENT)'
     Like `ASM_OUTPUT_COMMON' except takes the required alignment as a
     separate, explicit argument.  If you define this macro, it is used
     in place of `ASM_OUTPUT_COMMON', and gives you more flexibility in
     handling the required alignment of the variable.
`ASM_OUTPUT_SHARED_COMMON (STREAM, NAME, SIZE, ROUNDED)'
     If defined, it is similar to `ASM_OUTPUT_COMMON', except that it
     is used when NAME is shared.  If not defined, `ASM_OUTPUT_COMMON'
     will be used.
`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_ALIGNED_LOCAL (STREAM, NAME, SIZE, ALIGNMENT)'
     Like `ASM_OUTPUT_LOCAL' except takes the required alignment as a
     separate, explicit argument.  If you define this macro, it is used
     in place of `ASM_OUTPUT_LOCAL', and gives you more flexibility in
     handling the required alignment of the variable.
`ASM_OUTPUT_SHARED_LOCAL (STREAM, NAME, SIZE, ROUNDED)'
     If defined, it is similar to `ASM_OUTPUT_LOCAL', except that it is
     used when NAME is shared.  If not defined, `ASM_OUTPUT_LOCAL' will
     be used.
File: gcc.info,  Node: Label Output,  Next: Constructor Output,  Prev: Uninitialized Data,  Up: Assembler Format
Output and Generation of Labels
-------------------------------
`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_DECLARE_FUNCTION_SIZE (STREAM, NAME, DECL)'
     A C statement (sans semicolon) to output to the stdio stream
     STREAM any text necessary for declaring the size of a function
     which is being defined.  The argument NAME is the name of the
     function.  The argument DECL is the `FUNCTION_DECL' tree node
     representing the function.
     If this macro is not defined, then the function size is not
     defined.
`ASM_DECLARE_OBJECT_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 an
     initialized variable which is being defined.  This macro must
     output the label definition (perhaps using `ASM_OUTPUT_LABEL').
     The argument DECL is the `VAR_DECL' tree node representing the
     variable.
     If this macro is not defined, then the variable 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_EXTERNAL_LIBCALL (STREAM, SYMREF)'
     A C statement (sans semicolon) to output on STREAM an assembler
     pseudo-op to declare a library function name external.  The name
     of the library function is given by SYMREF, which has type `rtx'
     and is a `symbol_ref'.
     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 (sans semicolon) to output to the stdio stream
     STREAM a reference in assembler syntax to a label named NAME.
     This should add `_' 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_OUTPUT_LABELREF_AS_INT (FILE, LABEL)'
     Define this macro for systems that use the program `collect2'. The
     definition should be a C statement to output a word containing a
     reference to the label LABEL.
`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.
     It is absolutely essential that these labels be distinct from the
     labels used for user-level functions and variables.  Otherwise,
     certain programs will have name conflicts with internal labels.
     It is desirable to exclude internal labels from the symbol table
     of the object file.  Most assemblers have a naming convention for
     labels that should be excluded; on many systems, the letter `L' at
     the beginning of a label has this effect.  You should find out what
     convention your system uses, and follow it.
     The usual definition of this macro is as follows:
          fprintf (STREAM, "L%s%d:\n", PREFIX, NUM)
`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 `assemble_name', should
     produce the same output that `ASM_OUTPUT_INTERNAL_LABEL' would
     produce with the same PREFIX and NUM.
     If the string begins with `*', then `assemble_name' will output
     the rest of the string unchanged.  It is often convenient for
     `ASM_GENERATE_INTERNAL_LABEL' to use `*' in this way.  If the
     string doesn't start with `*', then `ASM_OUTPUT_LABELREF' gets to
     output the string, and may change it.  (Of course,
     `ASM_OUTPUT_LABELREF' is also part of your machine description, so
     you should know what it does on your machine.)
`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.
`OBJC_GEN_METHOD_LABEL (BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME)'
     Define this macro to override the default assembler names used for
     Objective C methods.
     The default name is a unique method number followed by the name of
     the class (e.g. `_1_Foo').  For methods in categories, the name of
     the category is also included in the assembler name (e.g.
     `_1_Foo_Bar').
     These names are safe on most systems, but make debugging difficult
     since the method's selector is not present in the name.
     Therefore, particular systems define other ways of computing names.
     BUF is an expression of type `char *' which gives you a buffer in
     which to store the name; its length is as long as CLASS_NAME,
     CAT_NAME and SEL_NAME put together, plus 50 characters extra.
     The argument IS_INST specifies whether the method is an instance
     method or a class method; CLASS_NAME is the name of the class;
     CAT_NAME is the name of the category (or NULL if the method is not
     in a category); and SEL_NAME is the name of the selector.
     On systems where the assembler can handle quoted names, you can
     use this macro to provide more human-readable names.
File: gcc.info,  Node: Constructor Output,  Next: Instruction Output,  Prev: Label Output,  Up: Assembler Format
Output of Initialization Routines
---------------------------------
   The compiled code for certain languages includes "constructors"
(also called "initialization routines")--functions to initialize data
in the program when the program is started.  These functions need to be
called before the program is "started"--that is to say, before `main'
is called.
   Compiling some languages generates "destructors" (also called
"termination routines") that should be called when the program
terminates.
   To make the initialization and termination functions work, the
compiler must output something in the assembler code to cause those
functions to be called at the appropriate time.  When you port the
compiler to a new system, you need to specify what assembler code is
needed to do this.
   Here are the two macros you should define if necessary:
`ASM_OUTPUT_CONSTRUCTOR (STREAM, NAME)'
     Define this macro as a C statement to output on the stream STREAM
     the assembler code to arrange to call the function named NAME at
     initialization time.
     Assume that NAME is the name of a C function generated
     automatically by the compiler.  This function takes no arguments.
     Use the function `assemble_name' to output the name NAME; this
     performs any system-specific syntactic transformations such as
     adding an underscore.
     If you don't define this macro, nothing special is output to
     arrange to call the function.  This is correct when the function
     will be called in some other manner--for example, by means of the
     `collect' program, which looks through the symbol table to find
     these functions by their names.  If you want to use `collect',
     then you need to arrange for it to be built and installed and used
     on your system.
`ASM_OUTPUT_DESTRUCTOR (STREAM, NAME)'
     This is like `ASM_OUTPUT_CONSTRUCTOR' but used for termination
     functions rather than initialization functions.
   If your system uses `collect2' as the means of processing
constructors, then that program normally uses `nm' to scan an object
file for constructor functions to be called.  On certain kinds of
systems, you can define these macros to make `collect2' work faster
(and, in some cases, make it work at all):
`OBJECT_FORMAT_COFF'
     Define this macro if the system uses COFF (Common Object File
     Format) object files, so that `collect2' can assume this format
     and scan object files directly for dynamic constructor/destructor
     functions.
`OBJECT_FORMAT_ROSE'
     Define this macro if the system uses ROSE format object files, so
     that `collect2' can assume this format and scan object files
     directly for dynamic constructor/destructor functions.
   These macros are effective only in a native compiler; `collect2' as
part of a cross compiler always uses `nm'.
`REAL_NM_FILE_NAME'
     Define this macro as a C string constant containing the file name
     to use to execute `nm'.  The default is to search the path
     normally for `nm'.
File: gcc.info,  Node: Instruction Output,  Next: Dispatch Tables,  Prev: Constructor Output,  Up: Assembler Format
Output of Assembler Instructions
--------------------------------
`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.
`ADDITIONAL_REGISTER_NAMES'
     If defined, a C initializer for an array of structures containing
     a name and a register number.  This macro defines additional names
     for hard registers, thus allowing the `asm' option in declarations
     to refer to registers using alternate names.
`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.
     On some machines, the syntax for a symbolic address depends on the
     section that the address refers to.  On these machines, define the
     macro `ENCODE_SECTION_INFO' to store the information into the
     `symbol_ref', and then check for it here.  *Note Assembler
     Format::.
`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.
`REGISTER_PREFIX'
`LOCAL_LABEL_PREFIX'
`USER_LABEL_PREFIX'
`IMMEDIATE_PREFIX'
     If defined, C string expressions to be used for the `%R', `%L',
     `%U', and `%I' options of `asm_fprintf' (see `final.c').  These
     are useful when a single `md' file must support multiple assembler
     formats.  In that case, the various `tm.h' files can define these
     macros differently.
`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.
File: gcc.info,  Node: Dispatch Tables,  Next: Alignment Output,  Prev: Instruction Output,  Up: Assembler Format
Output of Dispatch Tables
-------------------------
`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_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.
File: gcc.info,  Node: Alignment Output,  Prev: Dispatch Tables,  Up: Assembler Format
Assembler Commands for Alignment
--------------------------------
`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_OUTPUT_LOOP_ALIGN (FILE)'
     A C expression to output text to align the location counter in the
     way that is desirable at the beginning of a loop.
     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_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. Those
     bytes should be zero when loaded.  NBYTES will be a C expression
     of type `int'.
`ASM_NO_SKIP_IN_TEXT'
     Define this macro if `ASM_OUTPUT_SKIP' should not be used in the
     text section because it fails put zeros in the bytes that are
     skipped. This is true on many Unix systems, where the pseudo--op
     to skip bytes produces no-op instructions rather than zeros when
     used in the text section.
`ASM_OUTPUT_ALIGN (STREAM, POWER)'
     A C statement to output to the stdio stream STREAM an assembler
     command to advance the location counter to a multiple of 2 to the
     POWER bytes.  POWER will be a C expression of type `int'.
File: gcc.info,  Node: Debugging Info,  Next: Cross-compilation,  Prev: Assembler Format,  Up: Target Macros
Controlling Debugging Information Format
========================================
* Menu:
* All Debuggers::      Macros that affect all debugging formats uniformly.
* DBX Options::        Macros enabling specific options in DBX format.
* DBX Hooks::          Hook macros for varying DBX format.
* File Names and DBX:: Macros controlling output of file names in DBX format.
* SDB and DWARF::      Macros for SDB (COFF) and DWARF formats.
File: gcc.info,  Node: All Debuggers,  Next: DBX Options,  Up: Debugging Info
Macros Affecting All Debugging Formats
--------------------------------------
`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.
     If two registers have consecutive numbers inside GNU CC, and they
     can be used as a pair to hold a multiword value, then they *must*
     have consecutive numbers after renumbering with
     `DBX_REGISTER_NUMBER'. Otherwise, debuggers will be unable to
     access such a pair, because they expect register pairs to be
     consecutive in their own numbering scheme.
     If you find yourself defining `DBX_REGISTER_NUMBER' in way that
     does not preserve register pairs, then what you must do instead is
     redefine the actual register numbering scheme.
`DEBUGGER_AUTO_OFFSET (X)'
     A C expression that returns the integer offset value for an
     automatic variable having address X (an RTL expression).  The
     default computation assumes that X is based on the frame-pointer
     and gives the offset from the frame-pointer.  This is required for
     targets that produce debugging output for DBX or COFF-style
     debugging output for SDB and allow the frame-pointer to be
     eliminated when the `-g' options is used.
`DEBUGGER_ARG_OFFSET (OFFSET, X)'
     A C expression that returns the integer offset value for an
     argument having address X (an RTL expression).  The nominal offset
     is OFFSET.