--- gcc/gcc.info-17	2018/04/24 17:52:17	1.1.1.2
+++ gcc/gcc.info-17	2018/04/24 17:56:19	1.1.1.3
@@ -1,1627 +1,810 @@
-This is Info file gcc.info, produced by Makeinfo-1.44 from the input
+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 make and distribute verbatim copies of this
+manual provided the copyright notice and this permission notice are
+preserved on all copies.
 
    Permission is granted to copy and distribute modified versions of
 this manual under the conditions for verbatim copying, provided also
-that the section entitled "GNU General Public License" is included
-exactly as in the original, and provided that the entire resulting
-derived work is distributed under the terms of a permission notice
-identical to this one.
+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 section entitled "GNU General Public
-License" and this permission notice may be included in translations
-approved by the Free Software Foundation instead of in the original
-English.
+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: Index,  Prev: Config,  Up: Top
+File: gcc.info,  Node: DBX Options,  Next: DBX Hooks,  Prev: All Debuggers,  Up: Debugging Info
 
-Index
-*****
+Specific Options for DBX Output
+-------------------------------
 
-* Menu:
+`DBX_DEBUGGING_INFO'
+     Define this macro if GNU CC should produce debugging output for DBX
+     in response to the `-g' option.
+
+`XCOFF_DEBUGGING_INFO'
+     Define this macro if GNU CC should produce XCOFF format debugging
+     output in response to the `-g' option.  This is a variant of DBX
+     format.
+
+`DEFAULT_GDB_EXTENSIONS'
+     Define this macro to control whether GNU CC should by default
+     generate GDB's extended version of DBX debugging information
+     (assuming DBX-format debugging information is enabled at all).  If
+     you don't define the macro, the default is 1: always generate the
+     extended information if there is any occasion to.
+
+`DEBUG_SYMS_TEXT'
+     Define this macro if all `.stabs' commands should be output while
+     in the text section.
+
+`ASM_STABS_OP'
+     A C string constant naming the assembler pseudo op to use instead
+     of `.stabs' to define an ordinary debugging symbol.  If you don't
+     define this macro, `.stabs' is used.  This macro applies only to
+     DBX debugging information format.
+
+`ASM_STABD_OP'
+     A C string constant naming the assembler pseudo op to use instead
+     of `.stabd' to define a debugging symbol whose value is the current
+     location.  If you don't define this macro, `.stabd' is used. This
+     macro applies only to DBX debugging information format.
+
+`ASM_STABN_OP'
+     A C string constant naming the assembler pseudo op to use instead
+     of `.stabn' to define a debugging symbol with no name.  If you
+     don't define this macro, `.stabn' is used.  This macro applies
+     only to DBX debugging information format.
+
+`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.
+
+`DBX_TYPE_DECL_STABS_CODE'
+     The value to use in the "code" field of the `.stabs' directive for
+     a typedef.  The default is `N_LSYM'.
+
+`DBX_STATIC_CONST_VAR_CODE'
+     The value to use in the "code" field of the `.stabs' directive for
+     a static variable located in the text section.  DBX format does not
+     provide any "right" way to do this.  The default is `N_FUN'.
+
+`DBX_REGPARM_STABS_CODE'
+     The value to use in the "code" field of the `.stabs' directive for
+     a parameter passed in registers.  DBX format does not provide any
+     "right" way to do this.  The default is `N_RSYM'.
+
+`DBX_REGPARM_STABS_LETTER'
+     The letter to use in DBX symbol data to identify a symbol as a
+     parameter passed in registers.  DBX format does not customarily
+     provide any way to do this.  The default is `'P''.
+
+`DBX_MEMPARM_STABS_LETTER'
+     The letter to use in DBX symbol data to identify a symbol as a
+     stack parameter.  The default is `'p''.
+
+`DBX_FUNCTION_FIRST'
+     Define this macro if the DBX information for a function and its
+     arguments should precede the assembler code for the function. 
+     Normally, in DBX format, the debugging information entirely
+     follows the assembler code.
+
+`DBX_LBRAC_FIRST'
+     Define this macro if the `N_LBRAC' symbol for a block should
+     precede the debugging information for variables and functions
+     defined in that block.  Normally, in DBX format, the `N_LBRAC'
+     symbol comes first.
 
-* #pragma:                              Misc.
-* $:                                    Dollar Signs.
-* ':                                    Incompatibilities.
-* (nil):                                RTL Objects.
-* 3b1 installation:                     3b1 Install.
-* ?: side effect:                       Conditionals.
-* #pragma, reason for not using:        Function Attributes.
-* * in template:                        Output Statement.
-* ?: extensions:                        Conditionals.
-* ?: extensions:                        Lvalues.
-* ACCUMULATE_OUTGOING_ARGS and stack frames: Function Entry.
-* ARG_POINTER_REGNUM and virtual registers: Regs and Memory.
-* BITS_BIG_ENDIAN, effect on sign_extract: Bit Fields.
-* BLKmode, and function return values:  Calls.
-* ENCODE_SECTION_INFO and address validation: Addressing Modes.
-* ENCODE_SECTION_INFO usage:            Instruction Output.
-* FIRST_PARM_OFFSET and virtual registers: Regs and Memory.
-* FRAME_GROWS_DOWNWARD and virtual registers: Regs and Memory.
-* FRAME_POINTER_REGNUM and virtual registers: Regs and Memory.
-* FUNCTION_EPILOGUE and trampolines:    Trampolines.
-* FUNCTION_PROLOGUE and trampolines:    Trampolines.
-* HImode, in insn:                      Insns.
-* MUST_PASS_IN_STACK, and FUNCTION_ARG: Register Arguments.
-* PUSH_ROUNDING, interaction with STACK_BOUNDARY: Storage Layout.
-* QImode, in insn:                      Insns.
-* REG_PARM_STACK_SPACE, and FUNCTION_ARG: Register Arguments.
-* STACK_DYNAMIC_OFFSET and virtual registers: Regs and Memory.
-* STACK_POINTER_OFFSET and virtual registers: Regs and Memory.
-* STACK_POINTER_REGNUM and virtual registers: Regs and Memory.
-* STARTING_FRAME_OFFSET and virtual registers: Regs and Memory.
-* SYMBOL_REF_FLAG, in ENCODE_SECTION_INFO: Sections.
-* WORDS_BIG_ENDIAN, effect on subreg:   Regs and Memory.
-* absM2 instruction pattern:            Standard Names.
-* abs and attributes:                   Expressions.
-* addM3 instruction pattern:            Standard Names.
-* addr_diff_vec, length of:             Insn Lengths.
-* addr_vec, length of:                  Insn Lengths.
-* alloca and SunOs:                     Installation.
-* alloca vs variable-length arrays:     Variable Length.
-* alloca, for SunOs:                    Sun Install.
-* alloca, for Unos:                     Unos Install.
-* andM3 instruction pattern:            Standard Names.
-* and and attributes:                   Expressions.
-* and, canonicalization of:             Insn Canonicalizations.
-* ashiftrt and attributes:              Expressions.
-* ashift and attributes:                Expressions.
-* ashlM3 instruction pattern:           Standard Names.
-* ashrM3 instruction pattern:           Standard Names.
-* asm_operands, RTL sharing:            Sharing.
-* asm_operands, usage:                  Assembler.
-* asm expressions:                      Extended Asm.
-* bCOND instruction pattern:            Standard Names.
-* bcopy, implicit usage:                Library Calls.
-* bzero, implicit usage:                Library Calls.
-* call_insn and /u:                     Flags.
-* call_pop instruction pattern:         Standard Names.
-* call_value_pop instruction pattern:   Standard Names.
-* call_value instruction pattern:       Standard Names.
-* call instruction pattern:             Standard Names.
-* call usage:                           Calls.
-* casesi instruction pattern:           Standard Names.
-* cc0, RTL sharing:                     Sharing.
-* cmpM instruction pattern:             Standard Names.
-* cmpstrM instruction pattern:          Standard Names.
-* code_label and /i:                    Flags.
-* compare, canonicalization of:         Insn Canonicalizations.
-* cond and attributes:                  Expressions.
-* const_double, RTL sharing:            Sharing.
-* const_int and attribute tests:        Expressions.
-* const_int and attributes:             Expressions.
-* const_int, RTL sharing:               Sharing.
-* const_string and attributes:          Expressions.
-* const applied to function:            Function Attributes.
-* define_insn example:                  Example.
-* divM3 instruction pattern:            Standard Names.
-* divmodM4 instruction pattern:         Standard Names.
-* div and attributes:                   Expressions.
-* eq and attributes:                    Expressions.
-* extendMN instruction pattern:         Standard Names.
-* extv instruction pattern:             Standard Names.
-* extzv instruction pattern:            Standard Names.
-* ffsM2 instruction pattern:            Standard Names.
-* fixMN2 instruction pattern:           Standard Names.
-* fix_truncMN2 instruction pattern:     Standard Names.
-* fixunsMN2 instruction pattern:        Standard Names.
-* fixuns_truncMN2 instruction pattern:  Standard Names.
-* floatMN2 instruction pattern:         Standard Names.
-* floatunsMN2 instruction pattern:      Standard Names.
-* float as function value type:         Incompatibilities.
-* fscanf, and constant strings:         Incompatibilities.
-* ftruncM2 instruction pattern:         Standard Names.
-* genflags, crash on Sun 4:             Trouble.
-* geu and attributes:                   Expressions.
-* ge and attributes:                    Expressions.
-* gprof:                                Debugging Options.
-* gtu and attributes:                   Expressions.
-* gt and attributes:                    Expressions.
-* if_then_else and attributes:          Expressions.
-* if_then_else usage:                   Side Effects.
-* in_struct, in code_label:             Flags.
-* in_struct, in insn:                   Flags.
-* in_struct, in insn:                   Flags.
-* in_struct, in label_ref:              Flags.
-* in_struct, in mem:                    Flags.
-* in_struct, in reg:                    Flags.
-* indirect_jump instruction pattern:    Standard Names.
-* insn and /i:                          Flags.
-* insn and /s:                          Flags.
-* insn and /u:                          Flags.
-* insv instruction pattern:             Standard Names.
-* integrated, in insn:                  Flags.
-* integrated, in reg:                   Flags.
-* iorM3 instruction pattern:            Standard Names.
-* ior and attributes:                   Expressions.
-* ior, canonicalization of:             Insn Canonicalizations.
-* label_ref and /s:                     Flags.
-* label_ref, RTL sharing:               Sharing.
-* leu and attributes:                   Expressions.
-* le and attributes:                    Expressions.
-* long long data types:                 Long Long.
-* longjmp and automatic variables:      Dialect Options.
-* longjmp and automatic variables:      Interface.
-* longjmp incompatibilities:            Incompatibilities.
-* longjmp warnings:                     Warning Options.
-* lshiftrt and attributes:              Expressions.
-* lshift and attributes:                Expressions.
-* lshlM3 instruction pattern:           Standard Names.
-* lshrM3 instruction pattern:           Standard Names.
-* lt and attributes:                    Expressions.
-* main and the exit status:             VMS Misc.
-* match_dup and attributes:             Insn Lengths.
-* match_operand and attributes:         Expressions.
-* maxM3 instruction pattern:            Standard Names.
-* memcpy, implicit usage:               Library Calls.
-* memset, implicit usage:               Library Calls.
-* mem and /s:                           Flags.
-* mem and /u:                           Flags.
-* mem and /v:                           Flags.
-* mem, RTL sharing:                     Sharing.
-* minM3 instruction pattern:            Standard Names.
-* minus and attributes:                 Expressions.
-* minus, canonicalization of:           Insn Canonicalizations.
-* mktemp, and constant strings:         Incompatibilities.
-* modM3 instruction pattern:            Standard Names.
-* mod and attributes:                   Expressions.
-* movM instruction pattern:             Standard Names.
-* movstrM instruction pattern:          Standard Names.
-* movstrictM instruction pattern:       Standard Names.
-* mulM3 instruction pattern:            Standard Names.
-* mulhisi3 instruction pattern:         Standard Names.
-* mulqihi3 instruction pattern:         Standard Names.
-* mulsidi3 instruction pattern:         Standard Names.
-* mult and attributes:                  Expressions.
-* mult, canonicalization of:            Insn Canonicalizations.
-* negM2 instruction pattern:            Standard Names.
-* neg and attributes:                   Expressions.
-* neg, canonicalization of:             Insn Canonicalizations.
-* ne and attributes:                    Expressions.
-* nop instruction pattern:              Standard Names.
-* not and attributes:                   Expressions.
-* not, canonicalization of:             Insn Canonicalizations.
-* one_cmplM2 instruction pattern:       Standard Names.
-* pc and attributes:                    Insn Lengths.
-* pc, RTL sharing:                      Sharing.
-* plus and attributes:                  Expressions.
-* plus, canonicalization of:            Insn Canonicalizations.
-* prof:                                 Debugging Options.
-* qsort, and global register variables: Global Reg Vars.
-* reg and /i:                           Flags.
-* reg and /s:                           Flags.
-* reg and /u:                           Flags.
-* reg and /v:                           Flags.
-* reg, RTL sharing:                     Sharing.
-* return instruction pattern:           Standard Names.
-* rotlM3 instruction pattern:           Standard Names.
-* rotrM3 instruction pattern:           Standard Names.
-* sCOND instruction pattern:            Standard Names.
-* scanf, and constant strings:          Incompatibilities.
-* scratch, RTL sharing:                 Sharing.
-* setjmp incompatibilities:             Incompatibilities.
-* sign_extract, canonicalization of:    Insn Canonicalizations.
-* sqrtM2 instruction pattern:           Standard Names.
-* sscanf, and constant strings:         Incompatibilities.
-* subM3 instruction pattern:            Standard Names.
-* subreg, in strict_low_part:           RTL Declarations.
-* subreg, special reload handling:      Regs and Memory.
-* symbol_ref and /u:                    Flags.
-* symbol_ref and /v:                    Flags.
-* symbol_ref, RTL sharing:              Sharing.
-* tablejump instruction pattern:        Standard Names.
-* tcov:                                 Debugging Options.
-* truncMN instruction pattern:          Standard Names.
-* tstM instruction pattern:             Standard Names.
-* udivM3 instruction pattern:           Standard Names.
-* udivmodM4 instruction pattern:        Standard Names.
-* umaxM3 instruction pattern:           Standard Names.
-* uminM3 instruction pattern:           Standard Names.
-* umodM3 instruction pattern:           Standard Names.
-* umulhisi3 instruction pattern:        Standard Names.
-* umulqihi3 instruction pattern:        Standard Names.
-* umulsidi3 instruction pattern:        Standard Names.
-* unchanging, in call_insn:             Flags.
-* unchanging, in insn:                  Flags.
-* unchanging, in reg and mem:           Flags.
-* unchanging, in symbol_ref:            Flags.
-* used, in symbol_ref:                  Flags.
-* volatile applied to function:         Function Attributes.
-* volatil, in insn:                     Flags.
-* volatil, in mem:                      Flags.
-* volatil, in reg:                      Flags.
-* volatil, in symbol_ref:               Flags.
-* xorM3 instruction pattern:            Standard Names.
-* xor, canonicalization of:             Insn Canonicalizations.
-* zero_extendMN instruction pattern:    Standard Names.
-* zero_extract, canonicalization of:    Insn Canonicalizations.
-* VAXCRTL:                              VMS Misc.
-* libgcc.a:                             Library Calls.
-* stdarg.h and RT PC:                   RT Options.
-* stdarg.h and register arguments:      Register Arguments.
-* tm.h macros:                          Target Macros.
-* varargs.h and RT PC:                  RT Options.
-* xm-MACHINE.h:                         Config.
-* ! in constraint:                      Multi-Alternative.
-* # in constraint:                      Modifiers.
-* % in constraint:                      Modifiers.
-* % in template:                        Output Template.
-* & in constraint:                      Modifiers.
-* * in constraint:                      Modifiers.
-* + in constraint:                      Modifiers.
-* /i in RTL dump:                       Flags.
-* /s in RTL dump:                       Flags.
-* /s in RTL dump:                       Flags.
-* /u in RTL dump:                       Flags.
-* /v in RTL dump:                       Flags.
-* 0 in constraint:                      Simple Constraints.
-* < in constraint:                      Simple Constraints.
-* = in constraint:                      Modifiers.
-* > in constraint:                      Simple Constraints.
-* ? in constraint:                      Multi-Alternative.
-* E in constraint:                      Simple Constraints.
-* F in constraint:                      Simple Constraints.
-* G in constraint:                      Simple Constraints.
-* H in constraint:                      Simple Constraints.
-* I in constraint:                      Simple Constraints.
-* Q, in constraint:                     Simple Constraints.
-* V in constraint:                      Simple Constraints.
-* X in constraint:                      Simple Constraints.
-* _ in variables in macros:             Naming Types.
-* d in constraint:                      Simple Constraints.
-* g in constraint:                      Simple Constraints.
-* i in constraint:                      Simple Constraints.
-* m in constraint:                      Simple Constraints.
-* n in constraint:                      Simple Constraints.
-* o in constraint:                      Simple Constraints.
-* p in constraint:                      Simple Constraints.
-* r in constraint:                      Simple Constraints.
-* s in constraint:                      Simple Constraints.
-* ACCUMULATE_OUTGOING_ARGS:             Stack Arguments.
-* ADDITIONAL_REGISTER_NAMES:            Instruction Output.
-* ADDRESS_COST:                         Costs.
-* ADJUST_INSN_LENGTH:                   Insn Lengths.
-* ALLOCATE_TRAMPOLINE:                  Trampolines.
-* ALL_REGS:                             Register Classes.
-* AMD29K options:                       AMD29K Options.
-* ANSI support:                         Dialect Options.
-* ARGS_GROW_DOWNWARD:                   Frame Layout.
-* ARG_POINTER_REGNUM:                   Frame Registers.
-* ASM_APP_OFF:                          File Framework.
-* ASM_APP_ON:                           File Framework.
-* ASM_BYTE_OP:                          Data Output.
-* ASM_CLOSE_PAREN:                      Data Output.
-* ASM_COMMENT_START:                    File Framework.
-* ASM_DECLARE_FUNCTION_NAME:            Label Output.
-* ASM_DECLARE_FUNCTION_SIZE:            Label Output.
-* ASM_DECLARE_OBJECT_NAME:              Label Output.
-* ASM_FILE_END:                         File Framework.
-* ASM_FILE_START:                       File Framework.
-* ASM_FINAL_SPEC:                       Driver.
-* ASM_FORMAT_PRIVATE_NAME:              Label Output.
-* ASM_GENERATE_INTERNAL_LABEL:          Label Output.
-* ASM_GLOBALIZE_LABEL:                  Label Output.
-* ASM_IDENTIFY_GCC:                     File Framework.
-* ASM_NO_SKIP_IN_TEXT:                  Alignment Output.
-* ASM_OPEN_PAREN:                       Data Output.
-* ASM_OUTPUT_ADDR_DIFF_ELT:             Dispatch Tables.
-* ASM_OUTPUT_ADDR_VEC_ELT:              Dispatch Tables.
-* ASM_OUTPUT_ALIGN:                     Alignment Output.
-* ASM_OUTPUT_ALIGNED_COMMON:            Uninitialized Data.
-* ASM_OUTPUT_ALIGNED_LOCAL:             Uninitialized Data.
-* ASM_OUTPUT_ALIGN_CODE:                Alignment Output.
-* ASM_OUTPUT_ASCII:                     Data Output.
-* ASM_OUTPUT_BYTE:                      Data Output.
-* ASM_OUTPUT_CASE_END:                  Dispatch Tables.
-* ASM_OUTPUT_CASE_LABEL:                Dispatch Tables.
-* ASM_OUTPUT_CHAR:                      Data Output.
-* ASM_OUTPUT_COMMON:                    Uninitialized Data.
-* ASM_OUTPUT_CONSTRUCTOR:               Constructor Output.
-* ASM_OUTPUT_DESTRUCTOR:                Constructor Output.
-* ASM_OUTPUT_DOUBLE:                    Data Output.
-* ASM_OUTPUT_DOUBLE_INT:                Data Output.
-* ASM_OUTPUT_EXTERNAL:                  Label Output.
-* ASM_OUTPUT_EXTERNAL_LIBCALL:          Label Output.
-* ASM_OUTPUT_FLOAT:                     Data Output.
-* ASM_OUTPUT_IDENT:                     File Framework.
-* ASM_OUTPUT_INT:                       Data Output.
-* ASM_OUTPUT_INTERNAL_LABEL:            Label Output.
-* ASM_OUTPUT_LABEL:                     Label Output.
-* ASM_OUTPUT_LABELREF:                  Label Output.
-* ASM_OUTPUT_LABELREF_AS_INT:           Label Output.
-* ASM_OUTPUT_LOCAL:                     Uninitialized Data.
-* ASM_OUTPUT_LONG_DOUBLE:               Data Output.
-* ASM_OUTPUT_LOOP_ALIGN:                Alignment Output.
-* ASM_OUTPUT_OPCODE:                    Instruction Output.
-* ASM_OUTPUT_POOL_PROLOGUE:             Data Output.
-* ASM_OUTPUT_QUADRUPLE_INT:             Data Output.
-* ASM_OUTPUT_REG_POP:                   Instruction Output.
-* ASM_OUTPUT_REG_PUSH:                  Instruction Output.
-* ASM_OUTPUT_SHARED_COMMON:             Uninitialized Data.
-* ASM_OUTPUT_SHARED_LOCAL:              Uninitialized Data.
-* ASM_OUTPUT_SHORT:                     Data Output.
-* ASM_OUTPUT_SKIP:                      Alignment Output.
-* ASM_OUTPUT_SOURCE_FILENAME:           File Framework.
-* ASM_OUTPUT_SOURCE_LINE:               File Framework.
-* ASM_OUTPUT_SPECIAL_POOL_ENTRY:        Data Output.
-* ASM_SPEC:                             Driver.
-* ASM_STABD_OP:                         Debugging Info.
-* ASM_STABN_OP:                         Debugging Info.
-* ASM_STABS_OP:                         Debugging Info.
-* Alliant:                              Incompatibilities.
-* BASE_REG_CLASS:                       Register Classes.
-* BIGGEST_ALIGNMENT:                    Storage Layout.
-* BIGGEST_FIELD_ALIGNMENT:              Storage Layout.
-* BITFIELD_NBYTES_LIMITED:              Storage Layout.
-* BITS_BIG_ENDIAN:                      Storage Layout.
-* BITS_PER_UNIT:                        Storage Layout.
-* BITS_PER_WORD:                        Storage Layout.
-* BLKmode:                              Machine Modes.
-* BLOCK_PROFILER:                       Profiling.
-* BRANCH_COST:                          Costs.
-* BYTES_BIG_ENDIAN:                     Storage Layout.
-* BYTE_LOADS_ZERO_EXTEND:               Misc.
-* Bison parser generator:               Installation.
-* C language extensions:                Extensions.
-* C language, traditional:              Dialect Options.
-* C statements for assembler output:    Output Statement.
-* CALLER_SAVE_PROFITABLE:               Caller Saves.
-* CALL_USED_REGISTERS:                  Register Basics.
-* CAN_ELIMINATE:                        Elimination.
-* CASE_DROPS_THROUGH:                   Misc.
-* CASE_VECTOR_MODE:                     Misc.
-* CASE_VECTOR_PC_RELATIVE:              Misc.
-* CC1PLUS_SPEC:                         Driver.
-* CC1_SPEC:                             Driver.
-* CC_STATUS_MDEP:                       Condition Code.
-* CC_STATUS_MDEP_INIT:                  Condition Code.
-* CCmode:                               Machine Modes.
-* CHAR_TYPE_SIZE:                       Type Layout.
-* CHECK_FLOAT_VALUE:                    Storage Layout.
-* CLASS_MAX_NREGS:                      Register Classes.
-* CODE_LABEL_NUMBER:                    Insns.
-* COMPILER_PATH:                        Environment Variables.
-* CONDITIONAL_REGISTER_USAGE:           Register Basics.
-* CONST0_RTX:                           Constants.
-* CONST1_RTX:                           Constants.
-* CONST2_RTX:                           Constants.
-* CONSTANT_ADDRESS_P:                   Addressing Modes.
-* CONSTANT_ALIGNMENT:                   Storage Layout.
-* CONSTANT_P:                           Addressing Modes.
-* CONSTANT_POOL_ADDRESS_P:              Flags.
-* CONST_CALL_P:                         Flags.
-* CONST_COSTS:                          Costs.
-* CONST_DOUBLE_CHAIN:                   Constants.
-* CONST_DOUBLE_LOW:                     Constants.
-* CONST_DOUBLE_MEM:                     Constants.
-* CONST_DOUBLE_OK_FOR_LETTER_P:         Register Classes.
-* CONST_OK_FOR_LETTER_P:                Register Classes.
-* COSTS_N_INSNS:                        Costs.
-* CPLUS_INCLUDE_PATH:                   Environment Variables.
-* CPP_PREDEFINES:                       Run-time Target.
-* CPP_SPEC:                             Driver.
-* CUMULATIVE_ARGS:                      Register Arguments.
-* C_INCLUDE_PATH:                       Environment Variables.
-* Convex options:                       Convex Options.
-* DATA_ALIGNMENT:                       Storage Layout.
-* DATA_SECTION_ASM_OP:                  Sections.
-* DBR_OUTPUT_SEQEND:                    Instruction Output.
-* DBX:                                  Incompatibilities.
-* DBX_CONTIN_CHAR:                      Debugging Info.
-* DBX_CONTIN_LENGTH:                    Debugging Info.
-* DBX_DEBUGGING_INFO:                   Debugging Info.
-* DBX_FUNCTION_FIRST:                   Debugging Info.
-* DBX_LBRAC_FIRST:                      Debugging Info.
-* DBX_NO_XREFS:                         Debugging Info.
-* DBX_OUTPUT_FUNCTION_END:              Debugging Info.
-* DBX_OUTPUT_MAIN_SOURCE_DIRECTORY:     Debugging Info.
-* DBX_OUTPUT_MAIN_SOURCE_FILENAME:      Debugging Info.
-* DBX_OUTPUT_MAIN_SOURCE_FILE_END:      Debugging Info.
-* DBX_OUTPUT_SOURCE_FILENAME:           Debugging Info.
-* DBX_OUTPUT_STANDARD_TYPES:            Debugging Info.
-* DBX_REGISTER_NUMBER:                  Debugging Info.
-* DBX_STATIC_STAB_DATA_SECTION:         Debugging Info.
-* DBX_WORKING_DIRECTORY:                Debugging Info.
-* DCmode:                               Machine Modes.
-* DEBUGGER_ARG_OFFSET:                  Debugging Info.
-* DEBUGGER_AUTO_OFFSET:                 Debugging Info.
-* DEBUG_SYMS_TEXT:                      Debugging Info.
-* DEFAULT_CALLER_SAVES:                 Caller Saves.
-* DEFAULT_GDB_EXTENSIONS:               Debugging Info.
-* DEFAULT_MAIN_RETURN:                  Misc.
-* DEFAULT_SHORT_ENUMS:                  Type Layout.
-* DEFAULT_SIGNED_CHAR:                  Type Layout.
-* DELAY_SLOTS_FOR_EPILOGUE:             Function Entry.
-* DEPENDENCIES_OUTPUT:                  Environment Variables.
-* DFmode:                               Machine Modes.
-* DIVDI3_LIBCALL:                       Library Calls.
-* DIVSI3_LIBCALL:                       Library Calls.
-* DImode:                               Machine Modes.
-* DOLLARS_IN_IDENTIFIERS:               Misc.
-* DONE:                                 Expander Definitions.
-* DONT_REDUCE_ADDR:                     Costs.
-* DOUBLE_TYPE_SIZE:                     Type Layout.
-* DWARF_DEBUGGING_INFO:                 Debugging Info.
-* DYNAMIC_CHAIN_ADDRESS:                Frame Layout.
-* De Morgan's law:                      Insn Canonicalizations.
-* Dependent Patterns:                   Dependent Patterns.
-* EASY_DIV_EXPR:                        Misc.
-* ELIGIBLE_FOR_EPILOGUE_DELAY:          Function Entry.
-* ELIMINABLE_REGS:                      Elimination.
-* EMPTY_FIELD_BOUNDARY:                 Storage Layout.
-* ENCODE_SECTION_INFO:                  Sections.
-* ENDFILE_SPEC:                         Driver.
-* EXECUTABLE_SUFFIX:                    Config.
-* EXIT_BODY:                            Misc.
-* EXIT_IGNORE_STACK:                    Function Entry.
-* EXPAND_BUILTIN_SAVEREGS:              Varargs.
-* EXTRA_CC_MODES:                       Condition Code.
-* EXTRA_CC_NAMES:                       Condition Code.
-* EXTRA_CONSTRAINT:                     Register Classes.
-* EXTRA_SECTIONS:                       Sections.
-* EXTRA_SECTION_FUNCTIONS:              Sections.
-* FAIL:                                 Expander Definitions.
-* FAILURE_EXIT_CODE:                    Config.
-* FINALIZE_PIC:                         PIC.
-* FINAL_PRESCAN_INSN:                   Instruction Output.
-* FIRST_INSN_ADDRESS:                   Insn Lengths.
-* FIRST_PARM_OFFSET:                    Frame Layout.
-* FIRST_PSEUDO_REGISTER:                Register Basics.
-* FIRST_STACK_REG:                      Stack Registers.
-* FIRST_VIRTUAL_REGISTER:               Regs and Memory.
-* FIXED_REGISTERS:                      Register Basics.
-* FIXUNS_TRUNC_LIKE_FIX_TRUNC:          Misc.
-* FLOATIFY:                             Library Calls.
-* FLOAT_ARG_TYPE:                       Library Calls.
-* FLOAT_TYPE_SIZE:                      Type Layout.
-* FLOAT_VALUE_TYPE:                     Library Calls.
-* FRAME_GROWS_DOWNWARD:                 Frame Layout.
-* FRAME_POINTER_REGNUM:                 Frame Registers.
-* FRAME_POINTER_REQUIRED:               Elimination.
-* FUNCTION_ARG:                         Register Arguments.
-* FUNCTION_ARG_ADVANCE:                 Register Arguments.
-* FUNCTION_ARG_BOUNDARY:                Register Arguments.
-* FUNCTION_ARG_PADDING:                 Register Arguments.
-* FUNCTION_ARG_PARTIAL_NREGS:           Register Arguments.
-* FUNCTION_ARG_PASS_BY_REFERENCE:       Register Arguments.
-* FUNCTION_ARG_REGNO_P:                 Register Arguments.
-* FUNCTION_BLOCK_PROFILER:              Profiling.
-* FUNCTION_BOUNDARY:                    Storage Layout.
-* FUNCTION_CONVERSION_BUG:              Config.
-* FUNCTION_EPILOGUE:                    Function Entry.
-* FUNCTION_INCOMING_ARG:                Register Arguments.
-* FUNCTION_MODE:                        Misc.
-* FUNCTION_OUTGOING_VALUE:              Scalar Return.
-* FUNCTION_PROFILER:                    Profiling.
-* FUNCTION_PROLOGUE:                    Function Entry.
-* FUNCTION_VALUE:                       Scalar Return.
-* FUNCTION_VALUE_REGNO_P:               Scalar Return.
-* GCC_EXEC_PREFIX:                      Environment Variables.
-* GENERAL_REGS:                         Register Classes.
-* GET_CLASS_NARROWEST_MODE:             Machine Modes.
-* GET_CODE:                             RTL Objects.
-* GET_MODE:                             Machine Modes.
-* GET_MODE_ALIGNMENT:                   Machine Modes.
-* GET_MODE_BITSIZE:                     Machine Modes.
-* GET_MODE_CLASS:                       Machine Modes.
-* GET_MODE_MASK:                        Machine Modes.
-* GET_MODE_NAME:                        Machine Modes.
-* GET_MODE_NUNITS:                      Machine Modes.
-* GET_MODE_SIZE:                        Machine Modes.
-* GET_MODE_UNIT_SIZE:                   Machine Modes.
-* GET_MODE_WIDER_MODE:                  Machine Modes.
-* GET_RTX_CLASS:                        Accessors.
-* GET_RTX_FORMAT:                       Accessors.
-* GET_RTX_LENGTH:                       Accessors.
-* GLOBALDEF:                            Global Declarations.
-* GLOBALREF:                            Global Declarations.
-* GLOBALVALUEDEF:                       Global Declarations.
-* GLOBALVALUEREF:                       Global Declarations.
-* GNU CC and portability:               Portability.
-* GNU CC command options:               Invoking GCC.
-* GNU extensions to the C language:     Extensions.
-* GO_IF_LEGITIMATE_ADDRESS:             Addressing Modes.
-* GO_IF_MODE_DEPENDENT_ADDRESS:         Addressing Modes.
-* HANDLE_PRAGMA:                        Misc.
-* HARD_REGNO_MODE_OK:                   Values in Registers.
-* HARD_REGNO_NREGS:                     Values in Registers.
-* HAVE_ATEXIT:                          Misc.
-* HAVE_POST_DECREMENT:                  Addressing Modes.
-* HAVE_POST_INCREMENT:                  Addressing Modes.
-* HAVE_PRE_DECREMENT:                   Addressing Modes.
-* HAVE_PRE_INCREMENT:                   Addressing Modes.
-* HAVE_PUTENV:                          Config.
-* HAVE_VPRINTF:                         Config.
-* HImode:                               Machine Modes.
-* HOST_BITS_PER_CHAR:                   Config.
-* HOST_BITS_PER_INT:                    Config.
-* HOST_BITS_PER_LONG:                   Config.
-* HOST_BITS_PER_SHORT:                  Config.
-* HOST_FLOAT_FORMAT:                    Config.
-* HOST_WORDS_BIG_ENDIAN:                Config.
-* IBM RS/6000 Options:                  RS/6000 Options.
-* IBM RT PC:                            Incompatibilities.
-* IBM RT options:                       RT Options.
-* IEEE_FLOAT_FORMAT:                    Storage Layout.
-* IMMEDIATE_PREFIX:                     Instruction Output.
-* IMPLICIT_FIX_EXPR:                    Misc.
-* INCLUDE_DEFAULTS:                     Driver.
-* INDEX_REG_CLASS:                      Register Classes.
-* INITIALIZE_TRAMPOLINE:                Trampolines.
-* INITIAL_ELIMINATION_OFFSET:           Elimination.
-* INITIAL_FRAME_POINTER_OFFSET:         Elimination.
-* INIT_CUMULATIVE_ARGS:                 Register Arguments.
-* INIT_CUMULATIVE_INCOMING_ARGS:        Register Arguments.
-* INIT_SECTION_ASM_OP:                  Sections.
-* INSN_ANNULLED_BRANCH_P:               Flags.
-* INSN_CACHE_DEPTH:                     Trampolines.
-* INSN_CACHE_LINE_WIDTH:                Trampolines.
-* INSN_CACHE_SIZE:                      Trampolines.
-* INSN_CLOBBERS_REGNO_P:                Obsolete Register Macros.
-* INSN_CODE:                            Insns.
-* INSN_DELETED_P:                       Flags.
-* INSN_FROM_TARGET_P:                   Flags.
-* INSN_UID:                             Insns.
-* INTEGRATE_THRESHOLD:                  Misc.
-* INTIFY:                               Library Calls.
-* INT_TYPE_SIZE:                        Type Layout.
-* Intel 386 Options:                    i386 Options.
-* Interdependence of Patterns:          Dependent Patterns.
-* JUMP_LABEL:                           Insns.
-* JUMP_TABLES_IN_TEXT_SECTION:          Sections.
-* LABEL_NUSES:                          Insns.
-* LABEL_OUTSIDE_LOOP_P:                 Flags.
-* LABEL_PRESERVE_P:                     Flags.
-* LAST_STACK_REG:                       Stack Registers.
-* LAST_VIRTUAL_REGISTER:                Regs and Memory.
-* LEAF_REGISTERS:                       Leaf Functions.
-* LEAF_REG_REMAP:                       Leaf Functions.
-* LEGITIMATE_CONSTANT_P:                Addressing Modes.
-* LEGITIMATE_PIC_OPERAND_P:             Addressing Modes.
-* LEGITIMIZE_ADDRESS:                   Addressing Modes.
-* LIBCALL_VALUE:                        Scalar Return.
-* LIBGCC_NEEDS_DOUBLE:                  Library Calls.
-* LIBRARY_PATH:                         Environment Variables.
-* LIB_SPEC:                             Driver.
-* LIMIT_RELOAD_CLASS:                   Register Classes.
-* LINK_LIBGCC_SPECIAL:                  Driver.
-* LINK_SPEC:                            Driver.
-* LOCAL_INCLUDE_DIR:                    Driver.
-* LOCAL_LABEL_PREFIX:                   Instruction Output.
-* LOG_LINKS:                            Insns.
-* LONGJMP_RESTORE_FROM_STACK:           Elimination.
-* LONG_DOUBLE_TYPE_SIZE:                Type Layout.
-* LONG_LONG_TYPE_SIZE:                  Type Layout.
-* LONG_TYPE_SIZE:                       Type Layout.
-* Libraries:                            Link Options.
-* M680x0 options:                       M680x0 Options.
-* M88k options:                         M88K Options.
-* MAX_BITS_PER_WORD:                    Storage Layout.
-* MAX_FIXED_MODE_SIZE:                  Storage Layout.
-* MAX_OFILE_ALIGNMENT:                  Storage Layout.
-* MAX_REGS_PER_ADDRESS:                 Addressing Modes.
-* MD_EXEC_PREFIX:                       Driver.
-* MD_STARTFILE_PREFIX:                  Driver.
-* MEMORY_MOVE_COST:                     Costs.
-* MEM_IN_STRUCT_P:                      Flags.
-* MEM_VOLATILE_P:                       Flags.
-* MIPS options:                         MIPS Options.
-* MODDI3_LIBCALL:                       Library Calls.
-* MODES_TIEABLE_P:                      Values in Registers.
-* MODE_CC:                              Machine Modes.
-* MODE_COMPLEX_FLOAT:                   Machine Modes.
-* MODE_COMPLEX_INT:                     Machine Modes.
-* MODE_FLOAT:                           Machine Modes.
-* MODE_FUNCTION:                        Machine Modes.
-* MODE_INT:                             Machine Modes.
-* MODE_PARTIAL_INT:                     Machine Modes.
-* MODE_RANDOM:                          Machine Modes.
-* MODSI3_LIBCALL:                       Library Calls.
-* MOVE_MAX:                             Misc.
-* MOVE_RATIO:                           Costs.
-* MULDI3_LIBCALL:                       Library Calls.
-* MULSI3_LIBCALL:                       Library Calls.
-* MULTIBYTE_CHARS:                      Type Layout.
-* NEXT_INSN:                            Insns.
-* NEXT_OBJC_RUNTIME:                    Library Calls.
-* NON_SAVING_SETJMP:                    Register Basics.
-* NOTE_INSN_BLOCK_BEG:                  Insns.
-* NOTE_INSN_BLOCK_END:                  Insns.
-* NOTE_INSN_DELETED:                    Insns.
-* NOTE_INSN_FUNCTION_END:               Insns.
-* NOTE_INSN_LOOP_BEG:                   Insns.
-* NOTE_INSN_LOOP_CONT:                  Insns.
-* NOTE_INSN_LOOP_END:                   Insns.
-* NOTE_INSN_LOOP_VTOP:                  Insns.
-* NOTE_INSN_SETJMP:                     Insns.
-* NOTE_LINE_NUMBER:                     Insns.
-* NOTE_SOURCE_FILE:                     Insns.
-* NOTICE_UPDATE_CC:                     Condition Code.
-* NO_DOLLAR_IN_LABEL:                   Misc.
-* NO_FUNCTION_CSE:                      Costs.
-* NO_RECURSIVE_FUNCTION_CSE:            Costs.
-* NO_REGS:                              Register Classes.
-* NO_STAB_H:                            Config.
-* NO_SYS_SIGLIST:                       Config.
-* NUM_MACHINE_MODES:                    Machine Modes.
-* N_REG_CLASSES:                        Register Classes.
-* OBJC_GEN_METHOD_LABEL:                Label Output.
-* OBJC_INCLUDE_PATH:                    Environment Variables.
-* OBJC_INT_SELECTORS:                   Type Layout.
-* OBJC_NONUNIQUE_SELECTORS:             Type Layout.
-* OBJC_PROLOGUE:                        File Framework.
-* OBSTACK_CHUNK_ALLOC:                  Config.
-* OBSTACK_CHUNK_FREE:                   Config.
-* OBSTACK_CHUNK_SIZE:                   Config.
-* OCS (88k):                            M88K Options.
-* ONLY_INT_FIELDS:                      Config.
-* OPTIMIZATION_OPTIONS:                 Run-time Target.
-* ORDER_REGS_FOR_LOCAL_ALLOC:           Allocation Order.
-* OUTGOING_REG_PARM_STACK_SPACE:        Stack Arguments.
-* OVERLAPPING_REGNO_P:                  Obsolete Register Macros.
-* OVERRIDE_OPTIONS:                     Run-time Target.
-* Ordering of Patterns:                 Pattern Ordering.
-* PARM_BOUNDARY:                        Storage Layout.
-* PATTERN:                              Insns.
-* PCC_BITFIELD_TYPE_MATTERS:            Storage Layout.
-* PCC_STATIC_STRUCT_RETURN:             Aggregate Return.
-* PDImode:                              Machine Modes.
-* PIC:                                  PIC.
-* PIC_OFFSET_TABLE_REGNUM:              PIC.
-* POINTER_SIZE:                         Storage Layout.
-* PREDICATE_CODES:                      Misc.
-* PREFERRED_RELOAD_CLASS:               Register Classes.
-* PRESERVE_DEATH_INFO_REGNO_P:          Obsolete Register Macros.
-* PREV_INSN:                            Insns.
-* PRINT_OPERAND:                        Instruction Output.
-* PRINT_OPERAND_ADDRESS:                Instruction Output.
-* PRINT_OPERAND_PUNCT_VALID_P:          Instruction Output.
-* PROFILE_BEFORE_PROLOGUE:              Profiling.
-* PROMOTE_PROTOTYPES:                   Stack Arguments.
-* PSImode:                              Machine Modes.
-* PTRDIFF_TYPE:                         Type Layout.
-* PUSH_ROUNDING:                        Stack Arguments.
-* PUT_CODE:                             RTL Objects.
-* PUT_MODE:                             Machine Modes.
-* PUT_REG_NOTE_KIND:                    Insns.
-* PUT_SDB_...:                          Debugging Info.
-* Pattern Ordering:                     Pattern Ordering.
-* Pmode:                                Misc.
-* QImode:                               Machine Modes.
-* READONLY_DATA_SECTION:                Sections.
-* REAL_ARITHMETIC:                      Cross-compilation.
-* REAL_INFINITY:                        Cross-compilation.
-* REAL_VALUES_EQUAL:                    Cross-compilation.
-* REAL_VALUES_LESS:                     Cross-compilation.
-* REAL_VALUE_ATOF:                      Cross-compilation.
-* REAL_VALUE_FIX:                       Cross-compilation.
-* REAL_VALUE_FIX_TRUNCATE:              Cross-compilation.
-* REAL_VALUE_FROM_INT:                  Cross-compilation.
-* REAL_VALUE_ISINF:                     Cross-compilation.
-* REAL_VALUE_ISNAN:                     Cross-compilation.
-* REAL_VALUE_LDEXP:                     Cross-compilation.
-* REAL_VALUE_NEGATE:                    Cross-compilation.
-* REAL_VALUE_TO_INT:                    Cross-compilation.
-* REAL_VALUE_TRUNCATE:                  Cross-compilation.
-* REAL_VALUE_TYPE:                      Cross-compilation.
-* REAL_VALUE_UNSIGNED_FIX:              Cross-compilation.
-* REAL_VALUE_UNSIGNED_FIX_TRUNCATE:     Cross-compilation.
-* REGISTER_MOVE_COST:                   Costs.
-* REGISTER_NAMES:                       Instruction Output.
-* REGISTER_PREFIX:                      Instruction Output.
-* REGNO_OK_FOR_BASE_P:                  Register Classes.
-* REGNO_OK_FOR_INDEX_P:                 Register Classes.
-* REGNO_REG_CLASS:                      Register Classes.
-* REG_ALLOC_ORDER:                      Allocation Order.
-* REG_CC_SETTER:                        Insns.
-* REG_CC_USER:                          Insns.
-* REG_CLASS_CONTENTS:                   Register Classes.
-* REG_CLASS_FROM_LETTER:                Register Classes.
-* REG_CLASS_NAMES:                      Register Classes.
-* REG_DEAD:                             Insns.
-* REG_DEP_ANTI:                         Insns.
-* REG_DEP_OUTPUT:                       Insns.
-* REG_EQUAL:                            Insns.
-* REG_EQUIV:                            Insns.
-* REG_FUNCTION_VALUE_P:                 Flags.
-* REG_INC:                              Insns.
-* REG_LABEL:                            Insns.
-* REG_LEAF_ALLOC_ORDER:                 Leaf Functions.
-* REG_LIBCALL:                          Insns.
-* REG_LOOP_TEST_P:                      Flags.
-* REG_NONNEG:                           Insns.
-* REG_NOTES:                            Insns.
-* REG_NOTE_KIND:                        Insns.
-* REG_NO_CONFLICT:                      Insns.
-* REG_OK_FOR_BASE_P:                    Addressing Modes.
-* REG_OK_FOR_INDEX_P:                   Addressing Modes.
-* REG_OK_STRICT:                        Addressing Modes.
-* REG_PARM_STACK_SPACE:                 Stack Arguments.
-* REG_RETVAL:                           Insns.
-* REG_UNUSED:                           Insns.
-* REG_USERVAR_P:                        Flags.
-* REG_WAS_0:                            Insns.
-* RELATIVE_PREFIX_NOT_LINKDIR:          Driver.
-* RETURN_IN_MEMORY:                     Aggregate Return.
-* RETURN_POPS_ARGS:                     Stack Arguments.
-* ROUND_TYPE_ALIGN:                     Storage Layout.
-* ROUND_TYPE_SIZE:                      Storage Layout.
-* RS/6000 Options:                      RS/6000 Options.
-* RT PC:                                Incompatibilities.
-* RT options:                           RT Options.
-* RTL addition:                         Arithmetic.
-* RTL comparison:                       Arithmetic.
-* RTL comparison operations:            Comparisons.
-* RTL constant expression types:        Constants.
-* RTL constants:                        Constants.
-* RTL declarations:                     RTL Declarations.
-* RTL difference:                       Arithmetic.
-* RTL expression:                       RTL Objects.
-* RTL expressions for arithmetic:       Arithmetic.
-* RTL format:                           Accessors.
-* RTL format characters:                Accessors.
-* RTL function-call insns:              Calls.
-* RTL generation:                       Passes.
-* RTL insn template:                    RTL Template.
-* RTL integers:                         RTL Objects.
-* RTL memory expressions:               Regs and Memory.
-* RTL object types:                     RTL Objects.
-* RTL postdecrement:                    Incdec.
-* RTL postincrement:                    Incdec.
-* RTL predecrement:                     Incdec.
-* RTL preincrement:                     Incdec.
-* RTL register expressions:             Regs and Memory.
-* RTL representation:                   RTL.
-* RTL side effect expressions:          Side Effects.
-* RTL strings:                          RTL Objects.
-* RTL structure sharing assumptions:    Sharing.
-* RTL subtraction:                      Arithmetic.
-* RTL sum:                              Arithmetic.
-* RTL vectors:                          RTL Objects.
-* RTX (See RTL):                        RTL Objects.
-* RTX_COSTS:                            Costs.
-* RTX_INTEGRATED_P:                     Flags.
-* RTX_UNCHANGING_P:                     Flags.
-* Register Transfer Language (RTL):     RTL.
-* SCCS_DIRECTIVE:                       Misc.
-* SCHED_GROUP_P:                        Flags.
-* SCmode:                               Machine Modes.
-* SDB_ALLOW_FORWARD_REFERENCES:         Debugging Info.
-* SDB_ALLOW_UNKNOWN_REFERENCES:         Debugging Info.
-* SDB_DEBUGGING_INFO:                   Debugging Info.
-* SDB_DELIM:                            Debugging Info.
-* SDB_GENERATE_FAKE:                    Debugging Info.
-* SECONDARY_INPUT_RELOAD_CLASS:         Register Classes.
-* SECONDARY_OUTPUT_RELOAD_CLASS:        Register Classes.
-* SECONDARY_RELOAD_CLASS:               Register Classes.
-* SELECT_CC_MODE:                       Condition Code.
-* SELECT_RTX_SECTION:                   Sections.
-* SELECT_SECTION:                       Sections.
-* SETUP_INCOMING_VARARGS:               Varargs.
-* SET_DEST:                             Side Effects.
-* SET_SRC:                              Side Effects.
-* SFmode:                               Machine Modes.
-* SHARED_SECTION_ASM_OP:                Sections.
-* SHIFT_COUNT_TRUNCATED:                Misc.
-* SHORT_TYPE_SIZE:                      Type Layout.
-* SIGNED_CHAR_SPEC:                     Driver.
-* SIZE_TYPE:                            Type Layout.
-* SImode:                               Machine Modes.
-* SItype:                               Library Calls.
-* SLOW_BYTE_ACCESS:                     Costs.
-* SLOW_UNALIGNED_ACCESS:                Costs.
-* SLOW_ZERO_EXTEND:                     Costs.
-* SMALL_REGISTER_CLASSES:               Register Classes.
-* SPARC options:                        Sparc Options.
-* STACK_BOUNDARY:                       Storage Layout.
-* STACK_DYNAMIC_OFFSET:                 Frame Layout.
-* STACK_GROWS_DOWNWARD:                 Frame Layout.
-* STACK_PARMS_IN_REG_PARM_AREA:         Stack Arguments.
-* STACK_POINTER_OFFSET:                 Frame Layout.
-* STACK_POINTER_REGNUM:                 Frame Registers.
-* STACK_REGS:                           Stack Registers.
-* STANDARD_EXEC_PREFIX:                 Driver.
-* STANDARD_INCLUDE_DIR:                 Driver.
-* STANDARD_STARTFILE_PREFIX:            Driver.
-* STARTFILE_SPEC:                       Driver.
-* STARTING_FRAME_OFFSET:                Frame Layout.
-* STATIC_CHAIN:                         Frame Registers.
-* STATIC_CHAIN_INCOMING:                Frame Registers.
-* STATIC_CHAIN_INCOMING_REGNUM:         Frame Registers.
-* STATIC_CHAIN_REGNUM:                  Frame Registers.
-* STDC_VALUE:                           Run-time Target.
-* STORE_FLAG_VALUE:                     Misc.
-* STRICT_ALIGNMENT:                     Storage Layout.
-* STRUCTURE_SIZE_BOUNDARY:              Storage Layout.
-* STRUCT_VALUE:                         Aggregate Return.
-* STRUCT_VALUE_INCOMING:                Aggregate Return.
-* STRUCT_VALUE_INCOMING_REGNUM:         Aggregate Return.
-* STRUCT_VALUE_REGNUM:                  Aggregate Return.
-* SUBREG_REG:                           Regs and Memory.
-* SUBREG_WORD:                          Regs and Memory.
-* SUCCESS_EXIT_CODE:                    Config.
-* SVr4:                                 M88K Options.
-* SWITCHES_NEED_SPACES:                 Driver.
-* SWITCH_TAKES_ARG:                     Driver.
-* SYMBOL_REF_FLAG:                      Flags.
-* SYMBOL_REF_USED:                      Flags.
-* SYSTEM_INCLUDE_DIR:                   Driver.
-* Sun installation:                     Sun Install.
-* TARGET_BELL:                          Type Layout.
-* TARGET_BS:                            Type Layout.
-* TARGET_CR:                            Type Layout.
-* TARGET_FF:                            Type Layout.
-* TARGET_FLOAT_FORMAT:                  Storage Layout.
-* TARGET_MEM_FUNCTIONS:                 Library Calls.
-* TARGET_NEWLINE:                       Type Layout.
-* TARGET_OPTIONS:                       Run-time Target.
-* TARGET_SWITCHES:                      Run-time Target.
-* TARGET_TAB:                           Type Layout.
-* TARGET_VERSION:                       Run-time Target.
-* TARGET_VT:                            Type Layout.
-* TCmode:                               Machine Modes.
-* TEXT_SECTION_ASM_OP:                  Sections.
-* TFmode:                               Machine Modes.
-* TImode:                               Machine Modes.
-* TMPDIR:                               Environment Variables.
-* TRADITIONAL_RETURN_FLOAT:             Scalar Return.
-* TRAMPOLINE_ALIGNMENT:                 Trampolines.
-* TRAMPOLINE_SIZE:                      Trampolines.
-* TRAMPOLINE_TEMPLATE:                  Trampolines.
-* TRANSFER_FROM_TRAMPOLINE:             Trampolines.
-* TRULY_NOOP_TRUNCATION:                Misc.
-* UDIVDI3_LIBCALL:                      Library Calls.
-* UDIVSI3_LIBCALL:                      Library Calls.
-* UMODDI3_LIBCALL:                      Library Calls.
-* UMODSI3_LIBCALL:                      Library Calls.
-* UNITS_PER_WORD:                       Storage Layout.
-* UNKNOWN_FLOAT_FORMAT:                 Storage Layout.
-* USER_LABEL_PREFIX:                    Instruction Output.
-* USE_C_ALLOCA:                         Config.
-* USG:                                  Config.
-* Ultrix calling convention:            Incompatibilities.
-* Unos installation:                    Unos Install.
-* VAX options:                          VAX Options.
-* VAX_FLOAT_FORMAT:                     Storage Layout.
-* VIRTUAL_INCOMING_ARGS_REGNUM:         Regs and Memory.
-* VIRTUAL_OUTGOING_ARGS_REGNUM:         Regs and Memory.
-* VIRTUAL_STACK_DYNAMIC_REGNUM:         Regs and Memory.
-* VIRTUAL_STACK_VARS_REGNUM:            Regs and Memory.
-* VMS:                                  Config.
-* VMS and case sensitivity:             VMS Misc.
-* VMS and include files:                Include Files and VMS.
-* VMS installation:                     VMS Install.
-* VOIDmode:                             Machine Modes.
-* Vax calling convention:               Incompatibilities.
-* WCHAR_TYPE:                           Type Layout.
-* WCHAR_TYPE_SIZE:                      Type Layout.
-* WORDS_BIG_ENDIAN:                     Storage Layout.
-* WORD_SWITCH_TAKES_ARG:                Driver.
-* XCOFF_DEBUGGING_INFO:                 Debugging Info.
-* XCmode:                               Machine Modes.
-* XEXP:                                 Accessors.
-* XFmode:                               Machine Modes.
-* XINT:                                 Accessors.
-* XSTR:                                 Accessors.
-* XVEC:                                 Accessors.
-* XVECEXP:                              Accessors.
-* XVECLEN:                              Accessors.
-* \:                                    Output Template.
-* __bb_init_func:                       Profiling.
-* __builtin_args_info:                  Varargs.
-* __builtin_classify_type:              Varargs.
-* __builtin_next_arg:                   Varargs.
-* __builtin_saveregs:                   Varargs.
-* abort:                                Portability.
-* abs:                                  Arithmetic.
-* absolute value:                       Arithmetic.
-* access to operands:                   Accessors.
-* accessors:                            Accessors.
-* addr_diff_vec:                        Side Effects.
-* addr_vec:                             Side Effects.
-* address:                              RTL Template.
-* address constraints:                  Simple Constraints.
-* address of a label:                   Labels as Values.
-* address_operand:                      Simple Constraints.
-* addressing modes:                     Addressing Modes.
-* aggregates as return values:          Aggregate Return.
-* alignment:                            Alignment.
-* alternate keywords:                   Alternate Keywords.
-* analysis, data flow:                  Passes.
-* and:                                  Arithmetic.
-* apostrophes:                          Incompatibilities.
-* arg_pointer_rtx:                      Frame Registers.
-* argument passing:                     Interface.
-* arguments in frame (88k):             M88K Options.
-* arguments in registers:               Register Arguments.
-* arguments on stack:                   Stack Arguments.
-* arithmetic libraries:                 Interface.
-* arithmetic shift:                     Arithmetic.
-* arithmetic simplifications:           Passes.
-* arithmetic, in RTL:                   Arithmetic.
-* arrays of length zero:                Zero Length.
-* arrays of variable length:            Variable Length.
-* arrays, non-lvalue:                   Subscripting.
-* ashift:                               Arithmetic.
-* ashiftrt:                             Arithmetic.
-* asm_fprintf:                          Instruction Output.
-* asm_input:                            Side Effects.
-* asm_noperands:                        Insns.
-* assemble_name:                        Label Output.
-* assembler format:                     File Framework.
-* assembler instructions:               Extended Asm.
-* assembler instructions in RTL:        Assembler.
-* assembler names for identifiers:      Asm Labels.
-* assembler syntax, 88k:                M88K Options.
-* assembly code, invalid:               Bug Criteria.
-* assigning attribute values to insns:  Tagging Insns.
-* asterisk in template:                 Output Statement.
-* atof:                                 Cross-compilation.
-* attr:                                 Tagging Insns.
-* attribute expressions:                Expressions.
-* attribute of variables:               Variable Attributes.
-* attribute specifications:             Attr Example.
-* attribute specifications example:     Attr Example.
-* attributes, defining:                 Defining Attributes.
-* autoincrement addressing, availability: Portability.
-* autoincrement/decrement addressing:   Simple Constraints.
-* autoincrement/decrement analysis:     Passes.
-* backslash:                            Output Template.
-* backtrace for bug reports:            Bug Reporting.
-* barrier:                              Insns.
-* basic blocks:                         Passes.
-* bcmp:                                 Config.
-* bit fields:                           Bit Fields.
-* bit shift overflow (88k):             M88K Options.
-* bitwise complement:                   Arithmetic.
-* bitwise exclusive-or:                 Arithmetic.
-* bitwise inclusive-or:                 Arithmetic.
-* bitwise logical-and:                  Arithmetic.
-* break_out_memory_refs:                Addressing Modes.
-* bug criteria:                         Bug Criteria.
-* bug reports:                          Bug Reporting.
-* bugs:                                 Bugs.
-* bugs, known:                          Trouble.
-* byte_mode:                            Machine Modes.
-* bzero:                                Config.
-* call:                                 Side Effects.
-* call-clobbered register:              Register Basics.
-* call-saved register:                  Register Basics.
-* call-used register:                   Register Basics.
-* call_insn:                            Insns.
-* call_used_regs:                       Register Basics.
-* calling conventions:                  Stack and Calling.
-* calling functions in RTL:             Calls.
-* canonicalization of instructions:     Insn Canonicalizations.
-* case labels in initializers:          Labeled Elements.
-* case ranges:                          Case Ranges.
-* case sensitivity and VMS:             VMS Misc.
-* cast to a union:                      Cast to Union.
-* casts as lvalues:                     Lvalues.
-* cc0:                                  Regs and Memory.
-* cc0_rtx:                              Regs and Memory.
-* cc_status:                            Condition Code.
-* change_address:                       Standard Names.
-* class definitions, register:          Register Classes.
-* class preference constraints:         Class Preferences.
-* classes of RTX codes:                 Accessors.
-* clobber:                              Side Effects.
-* code generation RTL sequences:        Expander Definitions.
-* code generation conventions:          Code Gen Options.
-* code motion:                          Passes.
-* code_label:                           Insns.
-* codes, RTL expression:                RTL Objects.
-* combiner pass:                        Regs and Memory.
-* command options:                      Invoking GCC.
-* common subexpression elimination:     Passes.
-* compare:                              Arithmetic.
-* compilation in a separate directory:  Other Dir.
-* compiler bugs, reporting:             Bug Reporting.
-* compiler passes and files:            Passes.
-* compiler version, specifying:         Target Options.
-* complement, bitwise:                  Arithmetic.
-* compound expressions as lvalues:      Lvalues.
-* computed gotos:                       Labels as Values.
-* computing the length of an insn:      Insn Lengths.
-* cond:                                 Comparisons.
-* condition code register:              Regs and Memory.
-* condition code status:                Condition Code.
-* condition codes:                      Comparisons.
-* conditional expressions as lvalues:   Lvalues.
-* conditional expressions, extensions:  Conditionals.
-* conditions, in patterns:              Patterns.
-* configuration file:                   Config.
-* conflicting types:                    Trouble.
-* const0_rtx:                           Constants.
-* const1_rtx:                           Constants.
-* const2_rtx:                           Constants.
-* const_double:                         Constants.
-* const_int:                            Constants.
-* const_string:                         Constants.
-* const_true_rtx:                       Constants.
-* constant attributes:                  Constant Attributes.
-* constant folding:                     Passes.
-* constant folding and floating point:  Cross-compilation.
-* constant propagation:                 Passes.
-* constants in constraints:             Simple Constraints.
-* constm1_rtx:                          Constants.
-* constraint modifier characters:       Modifiers.
-* constraint, matching:                 Simple Constraints.
-* constraints:                          Constraints.
-* constructor expressions:              Constructors.
-* constructors, output of:              Constructor Output.
-* contributors:                         Contributors.
-* controlling register usage:           Register Basics.
-* controlling the compilation driver:   Driver.
-* conventions, run-time:                Interface.
-* conversions:                          Conversions.
-* copy_rtx_if_shared:                   Sharing.
-* core dump:                            Bug Criteria.
-* costs of instructions:                Costs.
-* cross compilation and floating point: Cross-compilation.
-* cross compiling:                      Target Options.
-* cross-jumping:                        Passes.
-* current_function_epilogue_delay_list: Function Entry.
-* current_function_outgoing_args_size:  Stack Arguments.
-* current_function_pops_args:           Function Entry.
-* current_function_pretend_args_size:   Function Entry.
-* data flow analysis:                   Passes.
-* data_section:                         Sections.
-* dbr_sequence_length:                  Instruction Output.
-* dead code:                            Passes.
-* dead_or_set_p:                        Peephole Definitions.
-* deallocating variable length arrays:  Variable Length.
-* death notes:                          Obsolete Register Macros.
-* debug_rtx:                            Bug Reporting.
-* debugging information generation:     Passes.
-* debugging information options:        Debugging Options.
-* debugging, 88k OCS:                   M88K Options.
-* declaration scope:                    Incompatibilities.
-* declarations inside expressions:      Statement Exprs.
-* declarations, RTL:                    RTL Declarations.
-* declaring attributes of functions:    Function Attributes.
-* define_asm_attributes:                Tagging Insns.
-* define_attr:                          Defining Attributes.
-* define_delay:                         Delay Slots.
-* define_expand:                        Expander Definitions.
-* define_function_unit:                 Function Units.
-* define_insn:                          Patterns.
-* define_peephole:                      Expander Definitions.
-* defining RTL sequences for code generation: Expander Definitions.
-* defining attributes and their values: Defining Attributes.
-* defining jump instruction patterns:   Jump Patterns.
-* defining peephole optimizers:         Peephole Definitions.
-* delay slots, defining:                Delay Slots.
-* delayed branch scheduling:            Passes.
-* dependencies for make as output:      Environment Variables.
-* dependencies, make:                   Preprocessor Options.
-* destructors, output of:               Constructor Output.
-* dialect options:                      Dialect Options.
-* digits in constraint:                 Simple Constraints.
-* directory options:                    Directory Options.
-* disabling certain registers:          Register Basics.
-* dispatch table:                       Dispatch Tables.
-* div:                                  Arithmetic.
-* divide instruction, 88k:              M88K Options.
-* division:                             Arithmetic.
-* division:                             Arithmetic.
-* division:                             Arithmetic.
-* dollar signs in identifier names:     Dollar Signs.
-* double-word arithmetic:               Long Long.
-* downward funargs:                     Nested Functions.
-* driver:                               Driver.
-* empty constraints:                    No Constraints.
-* endianness:                           Portability.
-* enum machine_mode:                    Machine Modes.
-* enum reg_class:                       Register Classes.
-* environment variables:                Environment Variables.
-* epilogue:                             Function Entry.
-* eq:                                   Comparisons.
-* eq_attr:                              Expressions.
-* equal:                                Comparisons.
-* error:                                Storage Layout.
-* exclamation point:                    Multi-Alternative.
-* exclusive-or, bitwise:                Arithmetic.
-* exit status and VMS:                  VMS Misc.
-* expander definitions:                 Expander Definitions.
-* explicit register variables:          Explicit Reg Vars.
-* expr_list:                            Insns.
-* expression codes:                     RTL Objects.
-* expressions containing statements:    Statement Exprs.
-* expressions, compound, as lvalues:    Lvalues.
-* expressions, conditional, as lvalues: Lvalues.
-* expressions, constructor:             Constructors.
-* extended asm:                         Extended Asm.
-* extensible constraints:               Simple Constraints.
-* extensions, ?::                       Conditionals.
-* extensions, ?::                       Lvalues.
-* extensions, C language:               Extensions.
-* extern int target_flags:              Run-time Target.
-* external declaration scope:           Incompatibilities.
-* fatal signal:                         Bug Criteria.
-* features, optional, in system conventions: Run-time Target.
-* ffs:                                  Arithmetic.
-* file name suffix:                     Overall Options.
-* file names:                           Link Options.
-* files and passes of the compiler:     Passes.
-* final pass:                           Passes.
-* final_scan_insn:                      Function Entry.
-* final_sequence:                       Instruction Output.
-* fix:                                  Conversions.
-* fix:                                  Conversions.
-* fixed register:                       Register Basics.
-* fixed_regs:                           Register Basics.
-* flags in RTL expression:              Flags.
-* float:                                Conversions.
-* float_extend:                         Conversions.
-* float_truncate:                       Conversions.
-* floating point format and cross compilation: Cross-compilation.
-* force_reg:                            Standard Names.
-* frame layout:                         Frame Layout.
-* frame_pointer_needed:                 Function Entry.
-* frame_pointer_rtx:                    Frame Registers.
-* function attributes:                  Function Attributes.
-* function call conventions:            Interface.
-* function entry and exit:              Function Entry.
-* function pointers, arithmetic:        Pointer Arith.
-* function units, for scheduling:       Function Units.
-* function, size of pointer to:         Pointer Arith.
-* function-call insns:                  Calls.
-* functions that have no side effects:  Function Attributes.
-* functions that never return:          Function Attributes.
-* functions, leaf:                      Leaf Functions.
-* ge:                                   Comparisons.
-* gencodes:                             Passes.
-* genconfig:                            Passes.
-* general_operand:                      RTL Template.
-* generalized lvalues:                  Lvalues.
-* generating assembler output:          Output Statement.
-* generating insns:                     RTL Template.
-* genflags:                             Passes.
-* get_attr:                             Expressions.
-* get_attr_length:                      Insn Lengths.
-* get_frame_size:                       Elimination.
-* get_insns:                            Insns.
-* get_last_insn:                        Insns.
-* geu:                                  Comparisons.
-* global offset table:                  Code Gen Options.
-* global register after longjmp:        Global Reg Vars.
-* global register allocation:           Passes.
-* global register variables:            Global Reg Vars.
-* goto with computed label:             Labels as Values.
-* gp-relative references (MIPS):        MIPS Options.
-* greater than:                         Comparisons.
-* greater than:                         Comparisons.
-* greater than:                         Comparisons.
-* grouping options:                     Invoking GCC.
-* gt:                                   Comparisons.
-* gtu:                                  Comparisons.
-* hard registers:                       Regs and Memory.
-* hardware models and configurations, specifying: Submodel Options.
-* header files and VMS:                 Include Files and VMS.
-* high:                                 Constants.
-* i386 Options:                         i386 Options.
-* identifier names, dollar signs in:    Dollar Signs.
-* identifiers, names in assembler code: Asm Labels.
-* identifying source, compiler (88k):   M88K Options.
-* if_then_else:                         Comparisons.
-* immediate_operand:                    RTL Template.
-* in_data:                              Sections.
-* in_struct:                            Flags.
-* in_text:                              Sections.
-* include files and VMS:                Include Files and VMS.
-* inclusive-or, bitwise:                Arithmetic.
-* incompatibilities of GNU CC:          Incompatibilities.
-* increment operators:                  Bug Criteria.
-* initialization routines:              Constructor Output.
-* initializations in expressions:       Constructors.
-* initializers with labeled elements:   Labeled Elements.
-* initializers, non-constant:           Initializers.
-* inline functions:                     Inline.
-* inline functions, omission of:        Inline.
-* inline, automatic:                    Passes.
-* insn:                                 Insns.
-* insn attributes:                      Insn Attributes.
-* insn canonicalization:                Insn Canonicalizations.
-* insn lengths, computing:              Insn Lengths.
-* insn splitting:                       Insn Splitting.
-* insn-attr.h:                          Defining Attributes.
-* insn_list:                            Insns.
-* insns:                                Insns.
-* insns, generating:                    RTL Template.
-* insns, recognizing:                   RTL Template.
-* installation trouble:                 Trouble.
-* installing GNU CC:                    Installation.
-* installing GNU CC on Unos:            Unos Install.
-* installing GNU CC on VMS:             VMS Install.
-* installing GNU CC on the 3b1:         3b1 Install.
-* installing GNU CC on the Sun:         Sun Install.
-* instruction attributes:               Insn Attributes.
-* instruction combination:              Passes.
-* instruction patterns:                 Patterns.
-* instruction recognizer:               Passes.
-* instruction scheduling:               Passes.
-* instruction scheduling:               Passes.
-* instruction splitting:                Insn Splitting.
-* integrated:                           Flags.
-* integrating function code:            Inline.
-* interfacing to GNU CC output:         Interface.
-* introduction:                         Top.
-* invalid assembly code:                Bug Criteria.
-* invalid input:                        Bug Criteria.
-* ior:                                  Arithmetic.
-* isinf:                                Cross-compilation.
-* isnan:                                Cross-compilation.
-* jump instruction patterns:            Jump Patterns.
-* jump instructions and set:            Side Effects.
-* jump optimization:                    Passes.
-* jump threading:                       Passes.
-* jump_insn:                            Insns.
-* keywords, alternate:                  Alternate Keywords.
-* known causes of trouble:              Trouble.
-* label_ref:                            Constants.
-* labeled elements in initializers:     Labeled Elements.
-* labels as values:                     Labels as Values.
-* language dialect options:             Dialect Options.
-* large bit shifts (88k):               M88K Options.
-* large return values:                  Aggregate Return.
-* ldexp:                                Cross-compilation.
-* le:                                   Comparisons.
-* leaf functions:                       Leaf Functions.
-* leaf_function:                        Leaf Functions.
-* leaf_function_p:                      Standard Names.
-* left rotate:                          Arithmetic.
-* left shift:                           Arithmetic.
-* left shift:                           Arithmetic.
-* length-zero arrays:                   Zero Length.
-* less than:                            Comparisons.
-* less than or equal:                   Comparisons.
-* leu:                                  Comparisons.
-* library subroutine names:             Library Calls.
-* link options:                         Link Options.
-* lo_sum:                               Arithmetic.
-* load address instruction:             Simple Constraints.
-* local labels:                         Local Labels.
-* local register allocation:            Passes.
-* local variables in macros:            Naming Types.
-* local variables, specifying registers: Local Reg Vars.
-* logical shift:                        Arithmetic.
-* logical-and, bitwise:                 Arithmetic.
-* longjmp:                              Global Reg Vars.
-* loop optimization:                    Passes.
-* lshift:                               Arithmetic.
-* lshiftrt:                             Arithmetic.
-* lt:                                   Comparisons.
-* ltu:                                  Comparisons.
-* lvalues, generalized:                 Lvalues.
-* machine dependent options:            Submodel Options.
-* machine description macros:           Target Macros.
-* machine descriptions:                 Machine Desc.
-* machine mode conversions:             Conversions.
-* machine modes:                        Machine Modes.
-* macros containing asm:                Extended Asm.
-* macros, inline alternative:           Inline.
-* macros, local labels:                 Local Labels.
-* macros, local variables in:           Naming Types.
-* macros, statements in expressions:    Statement Exprs.
-* macros, target description:           Target Macros.
-* macros, types of arguments:           Typeof.
-* make:                                 Preprocessor Options.
-* make_safe_from:                       Expander Definitions.
-* match_dup:                            RTL Template.
-* match_operand:                        RTL Template.
-* match_operator:                       RTL Template.
-* match_scratch:                        RTL Template.
-* matching constraint:                  Simple Constraints.
-* matching operands:                    Output Template.
-* math libraries:                       Interface.
-* math, in RTL:                         Arithmetic.
-* mcount:                               Profiling.
-* mem:                                  Regs and Memory.
-* memory reference, nonoffsettable:     Simple Constraints.
-* memory references in constraints:     Simple Constraints.
-* messages, warning:                    Warning Options.
-* middle-operands, omitted:             Conditionals.
-* minus:                                Arithmetic.
-* mod:                                  Arithmetic.
-* mode classes:                         Machine Modes.
-* modifiers in constraints:             Modifiers.
-* mult:                                 Arithmetic.
-* multiple alternative constraints:     Multi-Alternative.
-* multiplication:                       Arithmetic.
-* multiprecision arithmetic:            Long Long.
-* name augmentation:                    VMS Misc.
-* named patterns and conditions:        Patterns.
-* names used in assembler code:         Asm Labels.
-* names, pattern:                       Standard Names.
-* naming types:                         Naming Types.
-* ne:                                   Comparisons.
-* neg:                                  Arithmetic.
-* nested functions:                     Nested Functions.
-* nested functions, trampolines for:    Trampolines.
-* next_cc0_user:                        Jump Patterns.
-* nil:                                  RTL Objects.
-* no constraints:                       No Constraints.
-* no-op move instructions:              Passes.
-* non-constant initializers:            Initializers.
-* non-static inline function:           Inline.
-* nonoffsettable memory reference:      Simple Constraints.
-* not:                                  Arithmetic.
-* not equal:                            Comparisons.
-* not using constraints:                No Constraints.
-* note:                                 Insns.
-* obstack_free:                         3b1 Install.
-* offsettable address:                  Simple Constraints.
-* omitted middle-operands:              Conditionals.
-* open coding:                          Inline.
-* operand access:                       Accessors.
-* operand constraints:                  Constraints.
-* operand substitution:                 Output Template.
-* operands:                             Patterns.
-* optimize options:                     Optimize Options.
-* optional hardware or system features: Run-time Target.
-* options to control warnings:          Warning Options.
-* options, GNU CC command:              Invoking GCC.
-* options, code generation:             Code Gen Options.
-* options, debugging:                   Debugging Options.
-* options, dialect:                     Dialect Options.
-* options, directory search:            Directory Options.
-* options, grouping:                    Invoking GCC.
-* options, linking:                     Link Options.
-* options, optimization:                Optimize Options.
-* options, order:                       Invoking GCC.
-* options, preprocessor:                Preprocessor Options.
-* order of options:                     Invoking GCC.
-* order of register allocation:         Allocation Order.
-* other directory, compilation in:      Other Dir.
-* output file option:                   Overall Options.
-* output of assembler code:             File Framework.
-* output statements:                    Output Statement.
-* output templates:                     Output Template.
-* output_addr_const:                    Data Output.
-* output_asm_insn:                      Output Statement.
-* overflow while constant folding:      Cross-compilation.
-* parallel:                             Side Effects.
-* parameter forward declaration:        Variable Length.
-* parameters, miscellaneous:            Misc.
-* parser generator, Bison:              Installation.
-* parsing pass:                         Passes.
-* passes and files of the compiler:     Passes.
-* passing arguments:                    Interface.
-* pattern conditions:                   Patterns.
-* pattern names:                        Standard Names.
-* patterns:                             Patterns.
-* pc:                                   Regs and Memory.
-* pc_rtx:                               Regs and Memory.
-* peephole optimization:                Passes.
-* peephole optimization, RTL representation: Side Effects.
-* peephole optimizer definitions:       Peephole Definitions.
-* percent sign:                         Output Template.
-* perform_...:                          Library Calls.
-* plus:                                 Arithmetic.
-* pointer arguments:                    Function Attributes.
-* portability:                          Portability.
-* position independent code:            PIC.
-* post_dec:                             Incdec.
-* post_inc:                             Incdec.
-* pragma:                               Misc.
-* pragma, reason for not using:         Function Attributes.
-* pre_dec:                              Incdec.
-* pre_inc:                              Incdec.
-* predefined macros:                    Run-time Target.
-* preprocessor options:                 Preprocessor Options.
-* prev_cc0_setter:                      Jump Patterns.
-* prev_nonnote_insn:                    Peephole Definitions.
-* product:                              Arithmetic.
-* profiling, code generation:           Profiling.
-* program counter:                      Regs and Memory.
-* prologue:                             Function Entry.
-* promotion of formal parameters:       Trouble.
-* pseudo registers:                     Regs and Memory.
-* push address instruction:             Simple Constraints.
-* putenv:                               Config.
-* question mark:                        Multi-Alternative.
-* quotient:                             Arithmetic.
-* r0-relative references (88k):         M88K Options.
-* ranges in case statements:            Case Ranges.
-* read-only strings:                    Incompatibilities.
-* recog_operand:                        Instruction Output.
-* recognizing insns:                    RTL Template.
-* reg:                                  Regs and Memory.
-* reg_names:                            Instruction Output.
-* register allocation:                  Passes.
-* register allocation order:            Allocation Order.
-* register allocation, stupid:          Passes.
-* register class definitions:           Register Classes.
-* register class preference constraints: Class Preferences.
-* register class preference pass:       Passes.
-* register pairs:                       Values in Registers.
-* register positions in frame (88k):    M88K Options.
-* register positions in frame (88k):    M88K Options.
-* register usage:                       Registers.
-* register use analysis:                Passes.
-* register variable after longjmp:      Global Reg Vars.
-* register-to-stack conversion:         Passes.
-* register_operand:                     RTL Template.
-* registers:                            Extended Asm.
-* registers arguments:                  Register Arguments.
-* registers for local variables:        Local Reg Vars.
-* registers in constraints:             Simple Constraints.
-* registers, global allocation:         Explicit Reg Vars.
-* registers, global variables in:       Global Reg Vars.
-* regs_ever_live:                       Function Entry.
-* relative costs:                       Costs.
-* reload pass:                          Regs and Memory.
-* reload_completed:                     Standard Names.
-* reload_in:                            Standard Names.
-* reload_in_progress:                   Standard Names.
-* reload_out:                           Standard Names.
-* reloading:                            Passes.
-* remainder:                            Arithmetic.
-* reporting bugs:                       Bugs.
-* representation of RTL:                RTL.
-* rest_of_compilation:                  Passes.
-* rest_of_decl_compilation:             Passes.
-* return:                               Side Effects.
-* return value of main:                 VMS Misc.
-* return values in registers:           Scalar Return.
-* returning aggregate values:           Aggregate Return.
-* returning structures and unions:      Interface.
-* right rotate:                         Arithmetic.
-* right shift:                          Arithmetic.
-* rotate:                               Arithmetic.
-* rotate:                               Arithmetic.
-* rotatert:                             Arithmetic.
-* run-time conventions:                 Interface.
-* run-time options:                     Code Gen Options.
-* run-time target specification:        Run-time Target.
-* saveable_obstack:                     Addressing Modes.
-* scalars, returned as values:          Scalar Return.
-* scheduling, delayed branch:           Passes.
-* scheduling, instruction:              Passes.
-* scheduling, instruction:              Passes.
-* scope of a variable length array:     Variable Length.
-* scope of declaration:                 Trouble.
-* scope of external declarations:       Incompatibilities.
-* scratch:                              Regs and Memory.
-* scratch operands:                     Regs and Memory.
-* search path:                          Directory Options.
-* separate directory, compilation in:   Other Dir.
-* sequence:                             Side Effects.
-* set:                                  Side Effects.
-* set_attr:                             Tagging Insns.
-* set_attr_alternative:                 Tagging Insns.
-* setjmp:                               Global Reg Vars.
-* shared VMS run time system:           VMS Misc.
-* shared strings:                       Incompatibilities.
-* sharing of RTL components:            Sharing.
-* shift:                                Arithmetic.
-* side effect in ?::                    Conditionals.
-* side effects, macro argument:         Statement Exprs.
-* sign_extend:                          Conversions.
-* sign_extract:                         Bit Fields.
-* signed division:                      Arithmetic.
-* signed maximum:                       Arithmetic.
-* signed minimum:                       Arithmetic.
-* simple constraints:                   Simple Constraints.
-* simplifications, arithmetic:          Passes.
-* sizeof:                               Typeof.
-* smaller data references (88k):        M88K Options.
-* smaller data references (MIPS):       MIPS Options.
-* smax:                                 Arithmetic.
-* smin:                                 Arithmetic.
-* specified registers:                  Explicit Reg Vars.
-* specifying compiler version and target machine: Target Options.
-* specifying hardware config:           Submodel Options.
-* specifying machine version:           Target Options.
-* specifying registers for local variables: Local Reg Vars.
-* speed of instructions:                Costs.
-* splitting instructions:               Insn Splitting.
-* sqrt:                                 Arithmetic.
-* square root:                          Arithmetic.
-* stack arguments:                      Stack Arguments.
-* stack frame layout:                   Frame Layout.
-* stack_pointer_rtx:                    Frame Registers.
-* stage1:                               Installation.
-* standard pattern names:               Standard Names.
-* statements inside expressions:        Statement Exprs.
-* storage layout:                       Storage Layout.
-* strcpy:                               Storage Layout.
-* strength-reduction:                   Passes.
-* strict_low_part:                      RTL Declarations.
-* string constants:                     Incompatibilities.
-* structure passing (88k):              M88K Options.
-* structure value address:              Aggregate Return.
-* structures:                           Incompatibilities.
-* structures, constructor expression:   Constructors.
-* structures, returning:                Interface.
-* stupid register allocation:           Passes.
-* submodel options:                     Submodel Options.
-* subreg:                               Regs and Memory.
-* subscripting:                         Subscripting.
-* subscripting and function values:     Subscripting.
-* suppressing warnings:                 Warning Options.
-* symbol_ref:                           Constants.
-* symbolic label:                       Sharing.
-* syntax checking:                      Warning Options.
-* sys_siglist:                          Config.
-* tagging insns:                        Tagging Insns.
-* tail recursion optimization:          Passes.
-* target description macros:            Target Macros.
-* target machine, specifying:           Target Options.
-* target options:                       Target Options.
-* target specifications:                Run-time Target.
-* target-parameter-dependent code:      Passes.
-* termination routines:                 Constructor Output.
-* text_section:                         Sections.
-* thunks:                               Nested Functions.
-* top level of compiler:                Passes.
-* traditional C language:               Dialect Options.
-* trampolines for nested functions:     Trampolines.
-* truncate:                             Conversions.
-* type alignment:                       Alignment.
-* typedef names as function parameters: Incompatibilities.
-* typeof:                               Typeof.
-* udiv:                                 Arithmetic.
-* umax:                                 Arithmetic.
-* umin:                                 Arithmetic.
-* umod:                                 Arithmetic.
-* unchanging:                           Flags.
-* undefined behavior:                   Bug Criteria.
-* undefined function value:             Bug Criteria.
-* underscores in variables in macros:   Naming Types.
-* underscores, avoiding (88k):          M88K Options.
-* union, casting to a:                  Cast to Union.
-* unions:                               Incompatibilities.
-* unions, returning:                    Interface.
-* unreachable code:                     Passes.
-* unshare_all_rtl:                      Sharing.
-* unsigned division:                    Arithmetic.
-* unsigned greater than:                Comparisons.
-* unsigned greater than:                Comparisons.
-* unsigned less than:                   Comparisons.
-* unsigned less than:                   Comparisons.
-* unsigned minimum and maximum:         Arithmetic.
-* unsigned_fix:                         Conversions.
-* unsigned_float:                       Conversions.
-* unspec:                               Side Effects.
-* unspec_volatile:                      Side Effects.
-* use:                                  Side Effects.
-* used:                                 Flags.
-* value after longjmp:                  Global Reg Vars.
-* values, returned by functions:        Scalar Return.
-* varargs implementation:               Varargs.
-* variable alignment:                   Alignment.
-* variable attributes:                  Variable Attributes.
-* variable-length array scope:          Variable Length.
-* variable-length arrays:               Variable Length.
-* variables in specified registers:     Explicit Reg Vars.
-* variables, local, in macros:          Naming Types.
-* void pointers, arithmetic:            Pointer Arith.
-* void, size of pointer to:             Pointer Arith.
-* volatil:                              Flags.
-* volatile memory references:           Flags.
-* voting between constraint alternatives: Class Preferences.
-* vprintf:                              Config.
-* warning messages:                     Warning Options.
-* which_alternative:                    Output Statement.
-* whitespace:                           Incompatibilities.
-* word_mode:                            Machine Modes.
-* xor:                                  Arithmetic.
-* zero division on 88k:                 M88K Options.
-* zero-length arrays:                   Zero Length.
-* zero_extend:                          Conversions.
-* zero_extract:                         Bit Fields.
+
+File: gcc.info,  Node: DBX Hooks,  Next: File Names and DBX,  Prev: DBX Options,  Up: Debugging Info
+
+Open-Ended Hooks for DBX Format
+-------------------------------
+
+`DBX_OUTPUT_LBRAC (STREAM, NAME)'
+     Define this macro to say how to output to STREAM the debugging
+     information for the start of a scope level for variable names.  The
+     argument NAME is the name of an assembler symbol (for use with
+     `assemble_name') whose value is the address where the scope begins.
+
+`DBX_OUTPUT_RBRAC (STREAM, NAME)'
+     Like `DBX_OUTPUT_LBRAC', but for the end of a scope level.
+
+`DBX_OUTPUT_ENUM (STREAM, TYPE)'
+     Define this macro if the target machine requires special handling
+     to output an enumeration type.  The definition should be a C
+     statement (sans semicolon) to output the appropriate information
+     to STREAM for the type TYPE.
+
+`DBX_OUTPUT_FUNCTION_END (STREAM, FUNCTION)'
+     Define this macro if the target machine requires special output at
+     the end of the debugging information for a function.  The
+     definition should be a C statement (sans semicolon) to output the
+     appropriate information to STREAM.  FUNCTION is the
+     `FUNCTION_DECL' node for the function.
+
+`DBX_OUTPUT_STANDARD_TYPES (SYMS)'
+     Define this macro if you need to control the order of output of the
+     standard data types at the beginning of compilation.  The argument
+     SYMS is a `tree' which is a chain of all the predefined global
+     symbols, including names of data types.
+
+     Normally, DBX output starts with definitions of the types for
+     integers and characters, followed by all the other predefined
+     types of the particular language in no particular order.
+
+     On some machines, it is necessary to output different particular
+     types first.  To do this, define `DBX_OUTPUT_STANDARD_TYPES' to
+     output those symbols in the necessary order.  Any predefined types
+     that you don't explicitly output will be output afterward in no
+     particular order.
+
+     Be careful not to define this macro so that it works only for C. 
+     There are no global variables to access most of the built-in
+     types, because another language may have another set of types. 
+     The way to output a particular type is to look through SYMS to see
+     if you can find it. Here is an example:
+
+          {
+            tree decl;
+            for (decl = syms; decl; decl = TREE_CHAIN (decl))
+              if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "long int"))
+                dbxout_symbol (decl);
+            ...
+          }
+
+     This does nothing if the expected type does not exist.
+
+     See the function `init_decl_processing' in source file `c-decl.c'
+     to find the names to use for all the built-in C types.
+
+     Here is another way of finding a particular type:
+
+          {
+            tree decl;
+            for (decl = syms; decl; decl = TREE_CHAIN (decl))
+              if (TREE_CODE (decl) == TYPE_DECL
+          	&& TREE_CODE (TREE_TYPE (decl)) == INTEGER_CST
+                  && TYPE_PRECISION (TREE_TYPE (decl)) == 16
+                  && TYPE_UNSIGNED (TREE_TYPE (decl)))
+                /* This must be `unsigned short'.  */
+                dbxout_symbol (decl);
+            ...
+          }
+
+
+File: gcc.info,  Node: File Names and DBX,  Next: SDB and DWARF,  Prev: DBX Hooks,  Up: Debugging Info
+
+File Names in DBX Format
+------------------------
+
+`DBX_WORKING_DIRECTORY'
+     Define this if DBX wants to have the current directory recorded in
+     each object file.
+
+     Note that the working directory is always recorded if GDB
+     extensions are enabled.
+
+`DBX_OUTPUT_MAIN_SOURCE_FILENAME (STREAM, NAME)'
+     A C statement to output DBX debugging information to the stdio
+     stream STREAM which indicates that file NAME is the main source
+     file--the file specified as the input file for compilation. This
+     macro is called only once, at the beginning of compilation.
+
+     This macro need not be defined if the standard form of output for
+     DBX debugging information is appropriate.
+
+`DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (STREAM, NAME)'
+     A C statement to output DBX debugging information to the stdio
+     stream STREAM which indicates that the current directory during
+     compilation is named NAME.
+
+     This macro need not be defined if the standard form of output for
+     DBX debugging information is appropriate.
+
+`DBX_OUTPUT_MAIN_SOURCE_FILE_END (STREAM, NAME)'
+     A C statement to output DBX debugging information at the end of
+     compilation of the main source file NAME.
+
+     If you don't define this macro, nothing special is output at the
+     end of compilation, which is correct for most machines.
+
+`DBX_OUTPUT_SOURCE_FILENAME (STREAM, NAME)'
+     A C statement to output DBX debugging information to the stdio
+     stream STREAM which indicates that file NAME is the current source
+     file.  This output is generated each time input shifts to a
+     different source file as a result of `#include', the end of an
+     included file, or a `#line' command.
+
+     This macro need not be defined if the standard form of output for
+     DBX debugging information is appropriate.
+
+
+File: gcc.info,  Node: SDB and DWARF,  Prev: File Names and DBX,  Up: Debugging Info
+
+Macros for SDB and DWARF Output
+-------------------------------
+
+`SDB_DEBUGGING_INFO'
+     Define this macro if GNU CC should produce COFF-style debugging
+     output for SDB in response to the `-g' option.
+
+`DWARF_DEBUGGING_INFO'
+     Define this macro if GNU CC should produce dwarf format debugging
+     output in response to the `-g' option.
+
+`PUT_SDB_...'
+     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_DELIM'
+     Some assemblers do not support a semicolon as a delimiter, even
+     between SDB assembler directives.  In that case, define this macro
+     to be the delimiter to use (usually `\n').  It is not necessary to
+     define a new set of `PUT_SDB_OP' macros if this is the only change
+     required.
+
+`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.
+
+`SDB_ALLOW_UNKNOWN_REFERENCES'
+     Define this macro to allow references to unknown structure, union,
+     or enumeration tags to be emitted.  Standard COFF does not allow
+     handling of unknown references, MIPS ECOFF has support for it.
+
+`SDB_ALLOW_FORWARD_REFERENCES'
+     Define this macro to allow references to structure, union, or
+     enumeration tags that have not yet been seen to be handled.  Some
+     assemblers choke if forward tags are used, while some require it.
+
+
+File: gcc.info,  Node: Cross-compilation,  Next: Misc,  Prev: Debugging Info,  Up: Target 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_FIX (X)'
+     A macro whose definition is a C expression to convert the
+     target-machine floating point value X to a signed integer.  X has
+     type `REAL_VALUE_TYPE'.
+
+`REAL_VALUE_UNSIGNED_FIX (X)'
+     A macro whose definition is a C expression to convert the
+     target-machine floating point value X to an unsigned integer.  X
+     has type `REAL_VALUE_TYPE'.
+
+`REAL_VALUE_FIX_TRUNCATE (X)'
+     A macro whose definition is a C expression to convert the
+     target-machine floating point value X to a signed integer,
+     rounding toward 0. X has type `REAL_VALUE_TYPE'.
+
+`REAL_VALUE_UNSIGNED_FIX_TRUNCATE (X)'
+     A macro whose definition is a C expression to convert the
+     target-machine floating point value X to an unsigned integer,
+     rounding toward 0. X has type `REAL_VALUE_TYPE'.
+
+`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'.
+
+`REAL_INFINITY'
+     Define this macro if infinity is a possible floating point value,
+     and therefore division by 0 is legitimate.
+
+`REAL_VALUE_ISINF (X)'
+     A macro for a C expression which determines whether X, a floating
+     point value, is infinity.  The value has type `int'. By default,
+     this is defined to call `isinf'.
+
+`REAL_VALUE_ISNAN (X)'
+     A macro for a C expression which determines whether X, a floating
+     point value, is a "nan" (not-a-number).  The value has type `int'.
+      By default, this is defined to call `isnan'.
+
+   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_TRUNCATE (X)'
+     A macro for a C expression which converts the double-precision
+     floating point value X to single-precision.
+
+     Both X and the value of the expression have type `REAL_VALUE_TYPE'
+     and are in the target machine's floating point representation. 
+     However, the value should have an appropriate bit pattern to be
+     output properly as a single-precision floating constant.
+
+     There is no way for this macro to report overflow.
+
+`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,  Prev: Cross-compilation,  Up: Target Macros
+
+Miscellaneous Parameters
+========================
+
+`PREDICATE_CODES'
+     Optionally define this if you have added predicates to
+     `MACHINE.c'.  This macro is called within an initializer of an
+     array of structures.  The first field in the structure is the name
+     of a predicate and the second field is an array of rtl codes.  For
+     each predicate, list all rtl codes that can be in expressions
+     matched by the predicate.  The list should have a trailing comma. 
+     Here is an example of two entries in the list for a typical RISC
+     machine:
+
+          #define PREDICATE_CODES \
+            {"gen_reg_rtx_operand", {SUBREG, REG}},  \
+            {"reg_or_short_cint_operand", {SUBREG, REG, CONST_INT}},
+
+     Defining this macro does not affect the generated code (however,
+     incorrect definitions that omit an rtl code that may be matched by
+     the predicate can cause the compiler to malfunction).  Instead, it
+     allows the table built by `genrecog' to be more compact and
+     efficient, thus speeding up the compiler.  The most important
+     predicates to include in the list specified by this macro are
+     thoses used in the most insn patterns.
+
+`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.
+
+`BYTE_LOADS_ZERO_EXTEND'
+     Define this macro if an instruction to load a value narrower than a
+     word from memory into a register also zero-extends the value to
+     the whole register.
+
+`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.
+
+`MOVE_MAX'
+     The maximum number of bytes that a single instruction can move
+     quickly from memory to memory.
+
+`SHIFT_COUNT_TRUNCATED'
+     Defining this macro causes the compiler to omit a sign-extend,
+     zero-extend, or bitwise `and' instruction that truncates the count
+     of a shift operation to a width equal to the number of bits needed
+     to represent the size of the object being shifted.  On machines
+     that have instructions that act on bitfields at variable
+     positions, including `bit test' instructions, defining
+     `SHIFT_COUNT_TRUNCATED' also causes truncation not to be applied
+     to these instructions.
+
+     If both types of instructions truncate the count (for shifts) and
+     position (for bitfield operations), or if no variable-position
+     bitfield instructions exist, you should define this macro.
+
+     However, on some machines, such as the 80386 and the 680x0,
+     truncation only applies to shift operations and not the (real or
+     pretended) bitfield operations.  Do not define
+     `SHIFT_COUNT_TRUNCATED' on such machines.  Instead, add patterns
+     to the `md' file that include the implied truncation of the shift
+     instructions.
+
+`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.
+
+     It is reported that suboptimal code can result when
+     `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for modes for
+     which `MODES_TIEABLE_P' is 0.  If this is the case, making
+     `TRULY_NOOP_TRUNCATION' return 0 in such cases may improve things.
+
+`STORE_FLAG_VALUE'
+     A C expression describing the value returned by a comparison
+     operator and stored by a store-flag instruction (`sCOND') when the
+     condition is true.  This description must apply to *all* the
+     `sCOND' patterns and all the comparison operators.
+
+     A value of 1 or -1 means that the instruction implementing the
+     comparison operator returns exactly 1 or -1 when the comparison is
+     true and 0 when the comparison is false.  Otherwise, the value
+     indicates which bits of the result are guaranteed to be 1 when the
+     comparison is true.  This value is interpreted in the mode of the
+     comparison operation, which is given by the mode of the first
+     operand in the `sCOND' pattern.  Either the low bit or the sign
+     bit of `STORE_FLAG_VALUE' be on.  Presently, only those bits are
+     used by the compiler.
+
+     If `STORE_FLAG_VALUE' is neither 1 or -1, the compiler will
+     generate code that depends only on the specified bits.  It can also
+     replace comparison operators with equivalent operations if they
+     cause the required bits to be set, even if the remaining bits are
+     undefined. For example, on a machine whose comparison operators
+     return an `SImode' value and where `STORE_FLAG_VALUE' is defined as
+     `0x80000000', saying that just the sign bit is relevant, the
+     expression
+
+          (ne:SI (and:SI X (const_int POWER-OF-2)) (const_int 0))
+
+     can be converted to
+
+          (ashift:SI X (const_int N))
+
+     where N is the appropriate shift count to move the bit being
+     tested into the sign bit.
+
+     There is no way to describe a machine that always sets the
+     low-order bit for a true value, but does not guarantee the value
+     of any other bits, but we do not know of any machine that has such
+     an instruction.  If you are trying to port GNU CC to such a
+     machine, include an instruction to perform a logical-and of the
+     result with 1 in the pattern for the comparison operators and let
+     us know (*note Bug Reporting::.).
+
+     Often, a machine will have multiple instructions that obtain a
+     value from a comparison (or the condition codes).  Here are rules
+     to guide the choice of value for `STORE_FLAG_VALUE', and hence the
+     instructions to be used:
+
+        * Use the shortest sequence that yields a valid definition for
+          `STORE_FLAG_VALUE'.  It is more efficient for the compiler to
+          "normalize" the value (convert it to, e.g., 1 or 0) than for
+          the comparison operators to do so because there may be
+          opportunities to combine the normalization with other
+          operations.
+
+        * For equal-length sequences, use a value of 1 or -1, with -1
+          being slightly preferred on machines with expensive jumps and
+          1 preferred on other machines.
+
+        * As a second choice, choose a value of `0x80000001' if
+          instructions exist that set both the sign and low-order bits
+          but do not define the others.
+
+        * Otherwise, use a value of `0x80000000'.
+
+     You need 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'.
+
+`INTEGRATE_THRESHOLD (DECL)'
+     A C expression for the maximum number of instructions above which
+     the function DECL should not be inlined.  DECL is a
+     `FUNCTION_DECL' node.
+
+     The default definition of this macro is 64 plus 8 times the number
+     of arguments that the function accepts.  Some people think a larger
+     threshold should be used on RISC machines.
+
+`SCCS_DIRECTIVE'
+     Define this if the preprocessor should ignore `#sccs' directives
+     and print no error message.
+
+`HANDLE_PRAGMA (STREAM)'
+     Define this macro if you want to implement any pragmas.  If
+     defined, it should be a C statement to be executed when `#pragma'
+     is seen.  The argument STREAM is the stdio input stream from which
+     the source text can be read.
+
+     It is generally a bad idea to implement new uses of `#pragma'.  The
+     only reason to define this macro is for compatibility with other
+     compilers that do support `#pragma' for the sake of any user
+     programs which already use it.
+
+`DOLLARS_IN_IDENTIFIERS'
+     Define this macro to control use of the character `$' in identifier
+     names.  The value should be 0, 1, or 2.  0 means `$' is not allowed
+     by default; 1 means it is allowed by default if `-traditional' is
+     used; 2 means it is allowed by default provided `-ansi' is not
+     used. 1 is the default; there is no need to define this macro in
+     that case.
+
+`NO_DOLLAR_IN_LABEL'
+     Define this macro if the assembler does not accept the character
+     `$' in label names.  By default constructors and destructors in
+     G++ have `$' in the identifiers.  If this macro is defined, `.' is
+     used instead.
+
+`DEFAULT_MAIN_RETURN'
+     Define this macro if the target system expects every program's
+     `main' function to return a standard "success" value by default
+     (if no other value is explicitly returned).
+
+     The definition should be a C statement (sans semicolon) to
+     generate the appropriate rtl instructions.  It is used only when
+     compiling the end of `main'.
+
+`HAVE_ATEXIT'
+     Define this if the target system supports the function `atexit'
+     from the ANSI C standard.  If this is not defined, and
+     `INIT_SECTION_ASM_OP' is not defined, a default `exit' function
+     will be provided to support C++.
+
+`EXIT_BODY'
+     Define this if your `exit' function needs to do something besides
+     calling an external function `_cleanup' before terminating with
+     `_exit'.  The `EXIT_BODY' macro is only needed if netiher
+     `HAVE_ATEXIT' nor `INIT_SECTION_ASM_OP' are defined.
+
+
+File: gcc.info,  Node: Config,  Next: Index,  Prev: Target Macros,  Up: Top
+
+The Configuration File
+**********************
 
+   The configuration file `xm-MACHINE.h' contains macro definitions
+that describe the machine and system on which the compiler is running,
+unlike the definitions in `MACHINE.h', which describe the machine for
+which the compiler is producing output.  Most of the values in
+`xm-MACHINE.h' are actually the same on all machines that GNU CC runs
+on, so large parts of all configuration files are identical.  But there
+are some macros that vary:
+
+`USG'
+     Define this macro if the host system is System V.
+
+`VMS'
+     Define this macro if the host system is VMS.
+
+`FAILURE_EXIT_CODE'
+     A C expression for the status code to be returned when the compiler
+     exits after serious errors.
+
+`SUCCESS_EXIT_CODE'
+     A C expression for the status code to be returned when the compiler
+     exits without serious errors.
+
+`HOST_WORDS_BIG_ENDIAN'
+     Defined if the host machine stores words of multi-word values in
+     big-endian order.  (GNU CC does not depend on the host byte
+     ordering within a word.)
+
+`HOST_FLOAT_FORMAT'
+     A numeric code distinguishing the floating point format for the
+     host machine.  See `TARGET_FLOAT_FORMAT' in *Note Storage Layout::
+     for the alternatives and default.
+
+`HOST_BITS_PER_CHAR'
+     A C expression for the number of bits in `char' on the host
+     machine.
+
+`HOST_BITS_PER_SHORT'
+     A C expression for the number of bits in `short' on the host
+     machine.
+
+`HOST_BITS_PER_INT'
+     A C expression for the number of bits in `int' on the host machine.
+
+`HOST_BITS_PER_LONG'
+     A C expression for the number of bits in `long' on the host
+     machine.
+
+`ONLY_INT_FIELDS'
+     Define this macro to indicate that the host compiler only supports
+     `int' bit fields, rather than other integral types, including
+     `enum', as do most C compilers.
+
+`EXECUTABLE_SUFFIX'
+     Define this macro if the host system uses a naming convention for
+     executable files that involves a common suffix (such as, in some
+     systems, `.exe') that must be mentioned explicitly when you run
+     the program.
+
+`OBSTACK_CHUNK_SIZE'
+     A C expression for the size of ordinary obstack chunks. If you
+     don't define this, a usually-reasonable default is used.
+
+`OBSTACK_CHUNK_ALLOC'
+     The function used to allocate obstack chunks. If you don't define
+     this, `xmalloc' is used.
+
+`OBSTACK_CHUNK_FREE'
+     The function used to free obstack chunks. If you don't define
+     this, `free' is used.
+
+`USE_C_ALLOCA'
+     Define this macro to indicate that the compiler is running with the
+     `alloca' implemented in C.  This version of `alloca' can be found
+     in the file `alloca.c'; to use it, you must also alter the
+     `Makefile' variable `ALLOCA'.  (This is done automatically for the
+     systems on which we know it is needed.)
+
+     If you do define this macro, you should probably do it as follows:
+
+          #ifndef __GNUC__
+          #define USE_C_ALLOCA
+          #else
+          #define alloca __builtin_alloca
+          #endif
+
+     so that when the compiler is compiled with GNU CC it uses the more
+     efficient built-in `alloca' function.
+
+`FUNCTION_CONVERSION_BUG'
+     Define this macro to indicate that the host compiler does not
+     properly handle converting a function value to a
+     pointer-to-function when it is used in an expression.
+
+`HAVE_VPRINTF'
+     Define this if the library function `vprintf' is available on your
+     system.
+
+`MULTIBYTE_CHARS'
+     Define this macro to enable support for multibyte characters in the
+     input to GNU CC.  This requires that the host system support the
+     ANSI C library functions for converting multibyte characters to
+     wide characters.
+
+`HAVE_PUTENV'
+     Define this if the library function `putenv' is available on your
+     system.
+
+`NO_SYS_SIGLIST'
+     Define this if your system *does not* provide the variable
+     `sys_siglist'.
+
+     Some systems do provide this variable, but with a different name
+     such as `_sys_siglist'.  On these systems, you can define
+     `sys_siglist' as a macro which expands into the name actually
+     provided.
+
+`NO_STAB_H'
+     Define this if your system does not have the include file
+     `stab.h'.  If `USG' is defined, `NO_STAB_H' is assumed.
+
+   In addition, configuration files for system V define `bcopy',
+`bzero' and `bcmp' as aliases.  Some files define `alloca' as a macro
+when compiled with GNU CC, in order to take advantage of the benefit of
+GNU CC's built-in `alloca'.
 
+
\ No newline at end of file