--- gcc/gcc.info-23	2018/04/24 18:11:10	1.1.1.1
+++ gcc/gcc.info-23	2018/04/24 18:18:07	1.1.1.2
@@ -1,4 +1,4 @@
-This is Info file gcc.info, produced by Makeinfo-1.54 from the input
+This is Info file gcc.info, produced by Makeinfo-1.55 from the input
 file gcc.texi.
 
    This file documents the use and the internals of the GNU compiler.
@@ -6,7 +6,8 @@ file gcc.texi.
    Published by the Free Software Foundation 675 Massachusetts Avenue
 Cambridge, MA 02139 USA
 
-   Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
+   Copyright (C) 1988, 1989, 1992, 1993, 1994 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
@@ -14,1838 +15,555 @@ preserved on all copies.
 
    Permission is granted to copy and distribute modified versions of
 this manual under the conditions for verbatim copying, provided also
-that the sections entitled "GNU General Public License" and "Protect
-Your Freedom--Fight `Look And Feel'" are included exactly as in the
-original, and provided that the entire resulting derived work is
-distributed under the terms of a permission notice identical to this
-one.
+that the sections entitled "GNU General Public License," "Funding for
+Free Software," and "Protect Your Freedom--Fight `Look And Feel'" are
+included exactly as in the original, and provided that the entire
+resulting derived work is distributed under the terms of a permission
+notice identical to this one.
 
    Permission is granted to copy and distribute translations of this
 manual into another language, under the above conditions for modified
 versions, except that the sections entitled "GNU General Public
-License" and "Protect Your Freedom--Fight `Look And Feel'", and this
-permission notice, may be included in translations approved by the Free
-Software Foundation instead of in the original English.
+License," "Funding for Free Software," and "Protect Your Freedom--Fight
+`Look And Feel'", and this permission notice, may be included in
+translations approved by the Free Software Foundation instead of in the
+original English.
 
 
-File: gcc.info,  Node: Index,  Prev: Config,  Up: Top
+File: gcc.info,  Node: Misc,  Prev: Cross-compilation,  Up: Target Macros
 
-Index
-*****
+Miscellaneous Parameters
+========================
 
-* Menu:
+   Here are several miscellaneous parameters.
 
-* #pragma:                              Misc.
-* $:                                    Dollar Signs.
-* ':                                    Incompatibilities.
-* (nil):                                RTL Objects.
-* 3b1 installation:                     3b1 Install.
-* <?:                                   Min and Max.
-* >?:                                   Min and Max.
-* ?: side effect:                       Conditionals.
-* #pragma implementation, implied:      C++ Interface.
-* #pragma, reason for not using:        Function Attributes.
-* # in template:                        Output Template.
-* * in template:                        Output Statement.
-* ?: extensions:                        Lvalues.
-* ?: extensions:                        Conditionals.
-* absM2 instruction pattern:            Standard Names.
-* abs and attributes:                   Expressions.
-* ACCUMULATE_OUTGOING_ARGS and stack frames: Function Entry.
-* addM3 instruction pattern:            Standard Names.
-* addr_diff_vec, length of:             Insn Lengths.
-* addr_vec, length of:                  Insn Lengths.
-* aligned attribute:                    Variable Attributes.
-* allocate_stack instruction pattern:   Standard Names.
-* 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.
-* ARG_POINTER_REGNUM and virtual registers: Regs and Memory.
-* 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.
-* BITS_BIG_ENDIAN, effect on sign_extract: Bit Fields.
-* BLKmode, and function return values:  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.
-* const function attribute:             Function Attributes.
-* define_insn example:                  Example.
-* divM3 instruction pattern:            Standard Names.
-* divmodM4 instruction pattern:         Standard Names.
-* div and attributes:                   Expressions.
-* EDOM, implicit usage:                 Library Calls.
-* ENCODE_SECTION_INFO and address validation: Addressing Modes.
-* ENCODE_SECTION_INFO usage:            Instruction Output.
-* eq and attributes:                    Expressions.
-* errno, implicit usage:                Library Calls.
-* extendMN instruction pattern:         Standard Names.
-* extv instruction pattern:             Standard Names.
-* extzv instruction pattern:            Standard Names.
-* ffsM2 instruction pattern:            Standard Names.
-* FIRST_PARM_OFFSET and virtual registers: Regs and Memory.
-* fixMN2 instruction pattern:           Standard Names.
-* fixunsMN2 instruction pattern:        Standard Names.
-* fixuns_truncMN2 instruction pattern:  Standard Names.
-* fix_truncMN2 instruction pattern:     Standard Names.
-* floatMN2 instruction pattern:         Standard Names.
-* floatunsMN2 instruction pattern:      Standard Names.
-* float as function value type:         Incompatibilities.
-* format function attribute:            Function Attributes.
-* FRAME_GROWS_DOWNWARD and virtual registers: Regs and Memory.
-* FRAME_POINTER_REGNUM and virtual registers: Regs and Memory.
-* fscanf, and constant strings:         Incompatibilities.
-* ftruncM2 instruction pattern:         Standard Names.
-* FUNCTION_EPILOGUE and trampolines:    Trampolines.
-* FUNCTION_PROLOGUE and trampolines:    Trampolines.
-* g++ 1.XX:                             Invoking G++.
-* g++ older version:                    Invoking G++.
-* g++, separate compiler:               Invoking G++.
-* genflags, crash on Sun 4:             Installation Problems.
-* geu and attributes:                   Expressions.
-* ge and attributes:                    Expressions.
-* goto in C++:                          Destructors and Goto.
-* gprof:                                Debugging Options.
-* gtu and attributes:                   Expressions.
-* gt and attributes:                    Expressions.
-* HImode, in insn:                      Insns.
-* if_then_else and attributes:          Expressions.
-* if_then_else usage:                   Side Effects.
-* indirect_jump instruction pattern:    Standard Names.
-* inline automatic for C++ member fns:  Inline.
-* 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.
-* 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.
-* in_struct, in subreg:                 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.
-* load_multiple instruction pattern:    Standard Names.
-* long long data types:                 Long Long.
-* longjmp and automatic variables:      C 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.
-* mode attribute:                       Variable Attributes.
-* 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.
-* MUST_PASS_IN_STACK, and FUNCTION_ARG: Register Arguments.
-* negM2 instruction pattern:            Standard Names.
-* neg and attributes:                   Expressions.
-* neg, canonicalization of:             Insn Canonicalizations.
-* ne and attributes:                    Expressions.
-* nop instruction pattern:              Standard Names.
-* noreturn function attribute:          Function Attributes.
-* not and attributes:                   Expressions.
-* not, canonicalization of:             Insn Canonicalizations.
-* one_cmplM2 instruction pattern:       Standard Names.
-* packed attribute:                     Variable Attributes.
-* pc and attributes:                    Insn Lengths.
-* pc, RTL sharing:                      Sharing.
-* plus and attributes:                  Expressions.
-* plus, canonicalization of:            Insn Canonicalizations.
-* prof:                                 Debugging Options.
-* PUSH_ROUNDING, interaction with STACK_BOUNDARY: Storage Layout.
-* QImode, in insn:                      Insns.
-* qsort, and global register variables: Global Reg Vars.
-* REG_PARM_STACK_SPACE, and FUNCTION_ARG: Register Arguments.
-* reg and /i:                           Flags.
-* reg and /s:                           Flags.
-* reg and /u:                           Flags.
-* reg and /v:                           Flags.
-* reg, RTL sharing:                     Sharing.
-* reload_in instruction pattern:        Standard Names.
-* reload_out instruction pattern:       Standard Names.
-* restore_stack_block instruction pattern: Standard Names.
-* restore_stack_function instruction pattern: Standard Names.
-* restore_stack_nonlocal instruction pattern: Standard Names.
-* return instruction pattern:           Standard Names.
-* return, in C++ function header:       Naming Results.
-* rotlM3 instruction pattern:           Standard Names.
-* rotrM3 instruction pattern:           Standard Names.
-* sCOND instruction pattern:            Standard Names.
-* save_stack_block instruction pattern: Standard Names.
-* save_stack_function instruction pattern: Standard Names.
-* save_stack_nonlocal 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.
-* 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.
-* strlenM instruction pattern:          Standard Names.
-* subM3 instruction pattern:            Standard Names.
-* subreg and /s:                        Flags.
-* subreg and /u:                        Flags.
-* subreg, in strict_low_part:           RTL Declarations.
-* subreg, special reload handling:      Regs and Memory.
-* SYMBOL_REF_FLAG, in ENCODE_SECTION_INFO: Sections.
-* 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 subreg:                Flags.
-* unchanging, in symbol_ref:            Flags.
-* untyped_call instruction pattern:     Standard Names.
-* untyped_return instruction pattern:   Standard Names.
-* 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.
-* WORDS_BIG_ENDIAN, effect on subreg:   Regs and Memory.
-* xorM3 instruction pattern:            Standard Names.
-* xor, canonicalization of:             Insn Canonicalizations.
-* zero_extendMN instruction pattern:    Standard Names.
-* zero_extract, canonicalization of:    Insn Canonicalizations.
-* libgcc.a:                             Library Calls.
-* stdarg.h and register arguments:      Register Arguments.
-* stdarg.h and RT PC:                   RT Options.
-* tm.h macros:                          Target Macros.
-* varargs.h and RT PC:                  RT Options.
-* VAXCRTL:                              VMS Misc.
-* 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.
-* d in constraint:                      Simple Constraints.
-* E in constraint:                      Simple Constraints.
-* F in constraint:                      Simple Constraints.
-* g in constraint:                      Simple Constraints.
-* G in constraint:                      Simple Constraints.
-* H in constraint:                      Simple Constraints.
-* i 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.
-* Q, in constraint:                     Simple Constraints.
-* r in constraint:                      Simple Constraints.
-* store_multiple instruction pattern:   Standard Names.
-* s in constraint:                      Simple Constraints.
-* V in constraint:                      Simple Constraints.
-* X in constraint:                      Simple Constraints.
-* _ in variables in macros:             Naming Types.
-* abort:                                C Dialect Options.
-* abort:                                Portability.
-* abs:                                  C Dialect Options.
-* abs:                                  Arithmetic.
-* absolute value:                       Arithmetic.
-* access to operands:                   Accessors.
-* accessors:                            Accessors.
-* ACCUMULATE_OUTGOING_ARGS:             Stack Arguments.
-* ADDITIONAL_REGISTER_NAMES:            Instruction Output.
-* address:                              RTL Template.
-* address constraints:                  Simple Constraints.
-* address of a label:                   Labels as Values.
-* addressing modes:                     Addressing Modes.
-* ADDRESS_COST:                         Costs.
-* address_operand:                      Simple Constraints.
-* addr_diff_vec:                        Side Effects.
-* addr_vec:                             Side Effects.
-* ADJUST_COST:                          Costs.
-* ADJUST_INSN_LENGTH:                   Insn Lengths.
-* aggregates as return values:          Aggregate Return.
-* alignment:                            Alignment.
-* Alliant:                              Interoperation.
-* alloca:                               C Dialect Options.
-* ALLOCATE_TRAMPOLINE:                  Trampolines.
-* ALL_REGS:                             Register Classes.
-* alternate keywords:                   Alternate Keywords.
-* AMD29K options:                       AMD29K Options.
-* analysis, data flow:                  Passes.
-* and:                                  Arithmetic.
-* ANSI support:                         C Dialect Options.
-* apostrophes:                          Incompatibilities.
-* APPLY_RESULT_SIZE:                    Scalar Return.
-* ARGS_GROW_DOWNWARD:                   Frame Layout.
-* argument passing:                     Interface.
-* arguments in frame (88k):             M88K Options.
-* arguments in registers:               Register Arguments.
-* arguments on stack:                   Stack Arguments.
-* ARG_POINTER_REGNUM:                   Frame Registers.
-* arg_pointer_rtx:                      Frame Registers.
-* 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_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_FINISH_DECLARE_OBJECT:            Label Output.
-* ASM_FORMAT_PRIVATE_NAME:              Label Output.
-* asm_fprintf:                          Instruction Output.
-* ASM_GENERATE_INTERNAL_LABEL:          Label Output.
-* ASM_GLOBALIZE_LABEL:                  Label Output.
-* ASM_IDENTIFY_GCC:                     File Framework.
-* asm_input:                            Side Effects.
-* asm_noperands:                        Insns.
-* 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:               Macros for Initialization.
-* ASM_OUTPUT_DESTRUCTOR:                Macros for Initialization.
-* 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_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:                         DBX Options.
-* ASM_STABN_OP:                         DBX Options.
-* ASM_STABS_OP:                         DBX Options.
-* assembler format:                     File Framework.
-* assembler instructions:               Extended Asm.
-* assembler instructions in RTL:        Assembler.
-* assembler names for identifiers:      Asm Labels.
-* assembler syntax, 88k:                M88K Options.
-* ASSEMBLER_DIALECT:                    Instruction Output.
-* assemble_name:                        Label Output.
-* 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.
-* attr_flag:                            Expressions.
-* autoincrement addressing, availability: Portability.
-* autoincrement/decrement addressing:   Simple Constraints.
-* autoincrement/decrement analysis:     Passes.
-* automatic inline for C++ member fns:  Inline.
-* backslash:                            Output Template.
-* backtrace for bug reports:            Bug Reporting.
-* barrier:                              Insns.
-* BASE_REG_CLASS:                       Register Classes.
-* basic blocks:                         Passes.
-* bcmp:                                 Config.
-* BIGGEST_ALIGNMENT:                    Storage Layout.
-* BIGGEST_FIELD_ALIGNMENT:              Storage Layout.
-* Bison parser generator:               Installation.
-* bit fields:                           Bit Fields.
-* bit shift overflow (88k):             M88K Options.
-* BITFIELD_NBYTES_LIMITED:              Storage Layout.
-* BITS_BIG_ENDIAN:                      Storage Layout.
-* BITS_PER_UNIT:                        Storage Layout.
-* BITS_PER_WORD:                        Storage Layout.
-* bitwise complement:                   Arithmetic.
-* bitwise exclusive-or:                 Arithmetic.
-* bitwise inclusive-or:                 Arithmetic.
-* bitwise logical-and:                  Arithmetic.
-* BLKmode:                              Machine Modes.
-* BLOCK_PROFILER:                       Profiling.
-* BLOCK_PROFILER_CODE:                  Profiling.
-* BRANCH_COST:                          Costs.
-* break_out_memory_refs:                Addressing Modes.
-* bug criteria:                         Bug Criteria.
-* bug report mailing lists:             Bug Lists.
-* bugs:                                 Bugs.
-* bugs, known:                          Trouble.
-* builtin functions:                    C Dialect Options.
-* byte writes (29k):                    AMD29K Options.
-* BYTES_BIG_ENDIAN:                     Storage Layout.
-* byte_mode:                            Machine Modes.
-* bzero:                                Config.
-* C compilation options:                Invoking GCC.
-* C intermediate output, nonexistent:   G++ and GCC.
-* C language extensions:                C Extensions.
-* C language, traditional:              C Dialect Options.
-* C statements for assembler output:    Output Statement.
-* c++:                                  Invoking G++.
-* C++:                                  G++ and GCC.
-* C++ compilation options:              Invoking GCC.
-* C++ interface and implementation headers: C++ Interface.
-* C++ language extensions:              C++ Extensions.
-* C++ member fns, automatically inline: Inline.
-* C++ misunderstandings:                C++ Misunderstandings.
-* C++ named return value:               Naming Results.
-* C++ options, command line:            C++ Dialect Options.
-* C++ pragmas, effect on inlining:      C++ Interface.
-* C++ source file suffixes:             Invoking G++.
-* C++ static data, declaring and defining: Static Definitions.
-* call:                                 Side Effects.
-* call-clobbered register:              Register Basics.
-* call-saved register:                  Register Basics.
-* call-used register:                   Register Basics.
-* CALLER_SAVE_PROFITABLE:               Caller Saves.
-* calling conventions:                  Stack and Calling.
-* calling functions in RTL:             Calls.
-* call_insn:                            Insns.
-* CALL_USED_REGISTERS:                  Register Basics.
-* call_used_regs:                       Register Basics.
-* canonicalization of instructions:     Insn Canonicalizations.
-* CAN_ELIMINATE:                        Elimination.
-* case labels in initializers:          Labeled Elements.
-* case ranges:                          Case Ranges.
-* case sensitivity and VMS:             VMS Misc.
-* CASE_DROPS_THROUGH:                   Misc.
-* CASE_VALUES_THRESHOLD:                Misc.
-* CASE_VECTOR_MODE:                     Misc.
-* CASE_VECTOR_PC_RELATIVE:              Misc.
-* cast to a union:                      Cast to Union.
-* casts as lvalues:                     Lvalues.
-* cc0:                                  Regs and Memory.
-* cc0_rtx:                              Regs and Memory.
-* CC1PLUS_SPEC:                         Driver.
-* CC1_SPEC:                             Driver.
-* CCmode:                               Machine Modes.
-* cc_status:                            Condition Code.
-* CC_STATUS_MDEP:                       Condition Code.
-* CC_STATUS_MDEP_INIT:                  Condition Code.
-* CDImode:                              Machine Modes.
-* change_address:                       Standard Names.
-* CHAR_TYPE_SIZE:                       Type Layout.
-* CHECK_FLOAT_VALUE:                    Storage Layout.
-* CHImode:                              Machine Modes.
-* class definitions, register:          Register Classes.
-* class preference constraints:         Class Preferences.
-* classes of RTX codes:                 Accessors.
-* CLASS_LIKELY_SPILLED_P:               Register Classes.
-* CLASS_MAX_NREGS:                      Register Classes.
-* CLEAR_INSN_CACHE (BEG, END):          Trampolines.
-* clobber:                              Side Effects.
-* code generation conventions:          Code Gen Options.
-* code generation RTL sequences:        Expander Definitions.
-* code motion:                          Passes.
-* codes, RTL expression:                RTL Objects.
-* code_label:                           Insns.
-* CODE_LABEL_NUMBER:                    Insns.
-* COImode:                              Machine Modes.
-* 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 compared to C++ preprocessor: G++ and GCC.
-* compiler options, C++:                C++ Dialect Options.
-* compiler passes and files:            Passes.
-* compiler version, specifying:         Target Options.
-* COMPILER_PATH:                        Environment Variables.
-* complement, bitwise:                  Arithmetic.
-* complex numbers:                      Complex.
-* 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.
-* CONDITIONAL_REGISTER_USAGE:           Register Basics.
-* conditions, in patterns:              Patterns.
-* configuration file:                   Config.
-* conflicting types:                    Disappointments.
-* const0_rtx:                           Constants.
-* CONST0_RTX:                           Constants.
-* const1_rtx:                           Constants.
-* CONST1_RTX:                           Constants.
-* CONST2_RTX:                           Constants.
-* const2_rtx:                           Constants.
-* constant attributes:                  Constant Attributes.
-* constant folding:                     Passes.
-* constant folding and floating point:  Cross-compilation.
-* constant propagation:                 Passes.
-* constants in constraints:             Simple Constraints.
-* CONSTANT_ADDRESS_P:                   Addressing Modes.
-* CONSTANT_ALIGNMENT:                   Storage Layout.
-* CONSTANT_P:                           Addressing Modes.
-* CONSTANT_POOL_ADDRESS_P:              Flags.
-* constm1_rtx:                          Constants.
-* constraint modifier characters:       Modifiers.
-* constraint, matching:                 Simple Constraints.
-* constraints:                          Constraints.
-* constraints, machine specific:        Machine Constraints.
-* constructing calls:                   Constructing Calls.
-* constructor expressions:              Constructors.
-* constructors vs goto:                 Destructors and Goto.
-* constructors, output of:              Initialization.
-* CONST_CALL_P:                         Flags.
-* CONST_COSTS:                          Costs.
-* const_double:                         Constants.
-* CONST_DOUBLE_CHAIN:                   Constants.
-* CONST_DOUBLE_LOW:                     Constants.
-* CONST_DOUBLE_MEM:                     Constants.
-* CONST_DOUBLE_OK_FOR_LETTER_P:         Register Classes.
-* const_int:                            Constants.
-* CONST_OK_FOR_LETTER_P:                Register Classes.
-* const_string:                         Constants.
-* const_true_rtx:                       Constants.
-* contributors:                         Contributors.
-* controlling register usage:           Register Basics.
-* controlling the compilation driver:   Driver.
-* conventions, run-time:                Interface.
-* conversions:                          Conversions.
-* Convex options:                       Convex Options.
-* copy_rtx_if_shared:                   Sharing.
-* core dump:                            Bug Criteria.
-* cos:                                  C Dialect Options.
-* costs of instructions:                Costs.
-* COSTS_N_INSNS:                        Costs.
-* CPLUS_INCLUDE_PATH:                   Environment Variables.
-* CPP_PREDEFINES:                       Run-time Target.
-* CPP_SPEC:                             Driver.
-* CQImode:                              Machine Modes.
-* cross compilation and floating point: Cross-compilation.
-* cross compiling:                      Target Options.
-* cross-compiler, installation:         Cross-Compiler.
-* cross-jumping:                        Passes.
-* CSImode:                              Machine Modes.
-* CTImode:                              Machine Modes.
-* CUMULATIVE_ARGS:                      Register Arguments.
-* 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.
-* C_INCLUDE_PATH:                       Environment Variables.
-* data flow analysis:                   Passes.
-* DATA_ALIGNMENT:                       Storage Layout.
-* data_section:                         Sections.
-* DATA_SECTION_ASM_OP:                  Sections.
-* DBR_OUTPUT_SEQEND:                    Instruction Output.
-* dbr_sequence_length:                  Instruction Output.
-* DBX:                                  Interoperation.
-* DBX_CONTIN_CHAR:                      DBX Options.
-* DBX_CONTIN_LENGTH:                    DBX Options.
-* DBX_DEBUGGING_INFO:                   DBX Options.
-* DBX_FUNCTION_FIRST:                   DBX Options.
-* DBX_LBRAC_FIRST:                      DBX Options.
-* DBX_MEMPARM_STABS_LETTER:             DBX Options.
-* DBX_NO_XREFS:                         DBX Options.
-* DBX_OUTPUT_ENUM:                      DBX Hooks.
-* DBX_OUTPUT_FUNCTION_END:              DBX Hooks.
-* DBX_OUTPUT_LBRAC:                     DBX Hooks.
-* DBX_OUTPUT_MAIN_SOURCE_DIRECTORY:     File Names and DBX.
-* DBX_OUTPUT_MAIN_SOURCE_FILENAME:      File Names and DBX.
-* DBX_OUTPUT_MAIN_SOURCE_FILE_END:      File Names and DBX.
-* DBX_OUTPUT_RBRAC:                     DBX Hooks.
-* DBX_OUTPUT_SOURCE_FILENAME:           File Names and DBX.
-* DBX_OUTPUT_STANDARD_TYPES:            DBX Hooks.
-* DBX_REGISTER_NUMBER:                  All Debuggers.
-* DBX_REGPARM_STABS_CODE:               DBX Options.
-* DBX_REGPARM_STABS_LETTER:             DBX Options.
-* DBX_STATIC_CONST_VAR_CODE:            DBX Options.
-* DBX_STATIC_STAB_DATA_SECTION:         DBX Options.
-* DBX_TYPE_DECL_STABS_CODE:             DBX Options.
-* DBX_WORKING_DIRECTORY:                File Names and DBX.
-* DCmode:                               Machine Modes.
-* De Morgan's law:                      Insn Canonicalizations.
-* dead code:                            Passes.
-* dead_or_set_p:                        Peephole Definitions.
-* deallocating variable length arrays:  Variable Length.
-* death notes:                          Obsolete Register Macros.
-* DEBUGGER_ARG_OFFSET:                  All Debuggers.
-* DEBUGGER_AUTO_OFFSET:                 All Debuggers.
-* debugging information generation:     Passes.
-* debugging information options:        Debugging Options.
-* debugging, 88k OCS:                   M88K Options.
-* debug_rtx:                            Bug Reporting.
-* DEBUG_SYMS_TEXT:                      DBX Options.
-* declaration scope:                    Incompatibilities.
-* declarations inside expressions:      Statement Exprs.
-* declarations, RTL:                    RTL Declarations.
-* declaring attributes of functions:    Function Attributes.
-* declaring static data in C++:         Static Definitions.
-* DEFAULT_CALLER_SAVES:                 Caller Saves.
-* DEFAULT_GDB_EXTENSIONS:               DBX Options.
-* DEFAULT_MAIN_RETURN:                  Misc.
-* DEFAULT_PCC_STRUCT_RETURN:            Aggregate Return.
-* DEFAULT_SHORT_ENUMS:                  Type Layout.
-* DEFAULT_SIGNED_CHAR:                  Type Layout.
-* 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.
-* define_split:                         Insn Splitting.
-* defining attributes and their values: Defining Attributes.
-* defining jump instruction patterns:   Jump Patterns.
-* defining peephole optimizers:         Peephole Definitions.
-* defining RTL sequences for code generation: Expander Definitions.
-* defining static data in C++:          Static Definitions.
-* delay slots, defining:                Delay Slots.
-* delayed branch scheduling:            Passes.
-* DELAY_SLOTS_FOR_EPILOGUE:             Function Entry.
-* dependencies for make as output:      Environment Variables.
-* dependencies, make:                   Preprocessor Options.
-* DEPENDENCIES_OUTPUT:                  Environment Variables.
-* Dependent Patterns:                   Dependent Patterns.
-* destructors vs goto:                  Destructors and Goto.
-* destructors, output of:               Initialization.
-* detecting -traditional:               C Dialect Options.
-* DFmode:                               Machine Modes.
-* dialect options:                      C Dialect Options.
-* digits in constraint:                 Simple Constraints.
-* DImode:                               Machine Modes.
-* directory options:                    Directory Options.
-* disabling certain registers:          Register Basics.
-* dispatch table:                       Dispatch Tables.
-* div:                                  Arithmetic.
-* DIVDI3_LIBCALL:                       Library Calls.
-* divide instruction, 88k:              M88K Options.
-* division:                             Arithmetic.
-* division:                             Arithmetic.
-* division:                             Arithmetic.
-* DIVSI3_LIBCALL:                       Library Calls.
-* dollar signs in identifier names:     Dollar Signs.
-* DOLLARS_IN_IDENTIFIERS:               Misc.
-* DONE:                                 Expander Definitions.
-* DONT_REDUCE_ADDR:                     Costs.
-* double-word arithmetic:               Long Long.
-* DOUBLE_TYPE_SIZE:                     Type Layout.
-* downward funargs:                     Nested Functions.
-* driver:                               Driver.
-* DW bit (29k):                         AMD29K Options.
-* DWARF_DEBUGGING_INFO:                 SDB and DWARF.
-* DYNAMIC_CHAIN_ADDRESS:                Frame Layout.
-* EASY_DIV_EXPR:                        Misc.
-* ELIGIBLE_FOR_EPILOGUE_DELAY:          Function Entry.
-* ELIMINABLE_REGS:                      Elimination.
-* empty constraints:                    No Constraints.
-* EMPTY_FIELD_BOUNDARY:                 Storage Layout.
-* ENCODE_SECTION_INFO:                  Sections.
-* ENDFILE_SPEC:                         Driver.
-* endianness:                           Portability.
-* enum machine_mode:                    Machine Modes.
-* enum reg_class:                       Register Classes.
-* enumeration clash warnings:           Warning Options.
-* environment variables:                Environment Variables.
-* epilogue:                             Function Entry.
-* eq:                                   Comparisons.
-* equal:                                Comparisons.
-* eq_attr:                              Expressions.
-* error:                                Storage Layout.
-* error messages:                       Warnings and Errors.
-* escape sequences, traditional:        C Dialect Options.
-* exclamation point:                    Multi-Alternative.
-* exclusive-or, bitwise:                Arithmetic.
-* EXECUTABLE_SUFFIX:                    Config.
-* exit:                                 C Dialect Options.
-* exit status and VMS:                  VMS Misc.
-* EXIT_BODY:                            Misc.
-* EXIT_IGNORE_STACK:                    Function Entry.
-* expander definitions:                 Expander Definitions.
-* EXPAND_BUILTIN_SAVEREGS:              Varargs.
-* explicit register variables:          Explicit Reg Vars.
-* expression codes:                     RTL Objects.
-* expressions containing statements:    Statement Exprs.
-* expressions, compound, as lvalues:    Lvalues.
-* expressions, conditional, as lvalues: Lvalues.
-* expressions, constructor:             Constructors.
-* expr_list:                            Insns.
-* extended asm:                         Extended Asm.
-* extensible constraints:               Simple Constraints.
-* extensions, ?::                       Conditionals.
-* extensions, ?::                       Lvalues.
-* extensions, C language:               C Extensions.
-* extensions, C++ language:             C++ Extensions.
-* extern int target_flags:              Run-time Target.
-* external declaration scope:           Incompatibilities.
-* EXTRA_CC_MODES:                       Condition Code.
-* EXTRA_CC_NAMES:                       Condition Code.
-* EXTRA_CONSTRAINT:                     Register Classes.
-* EXTRA_SECTIONS:                       Sections.
-* EXTRA_SECTION_FUNCTIONS:              Sections.
-* fabs:                                 C Dialect Options.
-* FAIL:                                 Expander Definitions.
-* FAILURE_EXIT_CODE:                    Config.
-* fatal signal:                         Bug Criteria.
-* features, optional, in system conventions: Run-time Target.
-* ffs:                                  Arithmetic.
-* ffs:                                  C Dialect Options.
-* file name suffix:                     Overall Options.
-* file names:                           Link Options.
-* files and passes of the compiler:     Passes.
-* final pass:                           Passes.
-* FINALIZE_PIC:                         PIC.
-* FINAL_PRESCAN_INSN:                   Instruction Output.
-* FINAL_REG_PARM_STACK_SPACE:           Stack Arguments.
-* final_scan_insn:                      Function Entry.
-* final_sequence:                       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.
-* fix:                                  Conversions.
-* fix:                                  Conversions.
-* fixed register:                       Register Basics.
-* FIXED_REGISTERS:                      Register Basics.
-* fixed_regs:                           Register Basics.
-* FIXUNS_TRUNC_LIKE_FIX_TRUNC:          Misc.
-* flags in RTL expression:              Flags.
-* float:                                Conversions.
-* FLOATIFY:                             Library Calls.
-* floating point and cross compilation: Cross-compilation.
-* FLOAT_ARG_TYPE:                       Library Calls.
-* float_extend:                         Conversions.
-* FLOAT_STORE_FLAG_VALUE:               Misc.
-* float_truncate:                       Conversions.
-* FLOAT_TYPE_SIZE:                      Type Layout.
-* FLOAT_VALUE_TYPE:                     Library Calls.
-* FLOAT_WORDS_BIG_ENDIAN:               Storage Layout.
-* force_reg:                            Standard Names.
-* forwarding calls:                     Constructing Calls.
-* frame layout:                         Frame Layout.
-* FRAME_GROWS_DOWNWARD:                 Frame Layout.
-* frame_pointer_needed:                 Function Entry.
-* FRAME_POINTER_REGNUM:                 Frame Registers.
-* FRAME_POINTER_REQUIRED:               Elimination.
-* 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 prototype declarations:      Function Prototypes.
-* 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 with printf or scanf style arguments: Function Attributes.
-* functions, leaf:                      Leaf Functions.
-* FUNCTION_ARG:                         Register Arguments.
-* FUNCTION_ARG_ADVANCE:                 Register Arguments.
-* FUNCTION_ARG_BOUNDARY:                Register Arguments.
-* FUNCTION_ARG_CALLEE_COPIES:           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.
-* G++:                                  G++ and GCC.
-* g++:                                  Invoking G++.
-* GCC:                                  G++ and GCC.
-* GCC_EXEC_PREFIX:                      Environment Variables.
-* ge:                                   Comparisons.
-* gencodes:                             Passes.
-* genconfig:                            Passes.
-* generalized lvalues:                  Lvalues.
-* general_operand:                      RTL Template.
-* GENERAL_REGS:                         Register Classes.
-* generating assembler output:          Output Statement.
-* generating insns:                     RTL Template.
-* genflags:                             Passes.
-* GEN_ERRNO_RTX:                        Library Calls.
-* get_attr:                             Expressions.
-* get_attr_length:                      Insn Lengths.
-* GET_CLASS_NARROWEST_MODE:             Machine Modes.
-* GET_CODE:                             RTL Objects.
-* get_frame_size:                       Elimination.
-* get_insns:                            Insns.
-* get_last_insn:                        Insns.
-* 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.
-* 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.
-* GLOBALDEF:                            Global Declarations.
-* GLOBALREF:                            Global Declarations.
-* GLOBALVALUEDEF:                       Global Declarations.
-* GLOBALVALUEREF:                       Global Declarations.
-* GNU CC and portability:               Portability.
-* GNU CC command options:               Invoking GCC.
-* goto with computed label:             Labels as Values.
-* GO_IF_LEGITIMATE_ADDRESS:             Addressing Modes.
-* GO_IF_MODE_DEPENDENT_ADDRESS:         Addressing Modes.
-* gp-relative references (MIPS):        MIPS Options.
-* greater than:                         Comparisons.
-* greater than:                         Comparisons.
-* greater than:                         Comparisons.
-* grouping options:                     Invoking GCC.
-* gt:                                   Comparisons.
-* gtu:                                  Comparisons.
-* HANDLE_PRAGMA:                        Misc.
-* hard registers:                       Regs and Memory.
-* hardware models and configurations, specifying: Submodel Options.
-* HARD_FRAME_POINTER_REGNUM:            Frame Registers.
-* 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.
-* header files and VMS:                 Include Files and VMS.
-* high:                                 Constants.
-* 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_FLOAT_WORDS_BIG_ENDIAN:          Config.
-* HOST_WORDS_BIG_ENDIAN:                Config.
-* HPPA Options:                         HPPA Options.
-* i386 Options:                         i386 Options.
-* IBM RS/6000 and PowerPC Options:      RS/6000 and PowerPC Options.
-* IBM RT options:                       RT Options.
-* IBM RT PC:                            Interoperation.
-* identifier names, dollar signs in:    Dollar Signs.
-* identifiers, names in assembler code: Asm Labels.
-* identifying source, compiler (88k):   M88K Options.
-* IEEE_FLOAT_FORMAT:                    Storage Layout.
-* if_then_else:                         Comparisons.
-* immediate_operand:                    RTL Template.
-* IMMEDIATE_PREFIX:                     Instruction Output.
-* implicit argument: return value:      Naming Results.
-* IMPLICIT_FIX_EXPR:                    Misc.
-* implied #pragma implementation:       C++ Interface.
-* include files and VMS:                Include Files and VMS.
-* INCLUDE_DEFAULTS:                     Driver.
-* inclusive-or, bitwise:                Arithmetic.
-* INCOMING_REGNO:                       Register Basics.
-* incompatibilities of GNU CC:          Incompatibilities.
-* increment operators:                  Bug Criteria.
-* INDEX_REG_CLASS:                      Register Classes.
-* initialization routines:              Initialization.
-* initializations in expressions:       Constructors.
-* initializers with labeled elements:   Labeled Elements.
-* initializers, non-constant:           Initializers.
-* 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.
-* INIT_SECTION_ASM_OP:                  Macros for Initialization.
-* inline functions:                     Inline.
-* inline functions, omission of:        Inline.
-* inline, automatic:                    Passes.
-* inlining and C++ pragmas:             C++ Interface.
-* insn:                                 Insns.
-* insn attributes:                      Insn Attributes.
-* insn canonicalization:                Insn Canonicalizations.
-* insn lengths, computing:              Insn Lengths.
-* insn splitting:                       Insn Splitting.
-* insn-attr.h:                          Defining Attributes.
-* insns:                                Insns.
-* insns, generating:                    RTL Template.
-* insns, recognizing:                   RTL Template.
-* 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_list:                            Insns.
-* INSN_REFERENCES_ARE_DELAYED:          Misc.
-* INSN_SETS_ARE_DELAYED:                Misc.
-* INSN_UID:                             Insns.
-* installation trouble:                 Trouble.
-* installing GNU CC:                    Installation.
-* installing GNU CC on the 3b1:         3b1 Install.
-* installing GNU CC on the Sun:         Sun Install.
-* installing GNU CC on Unos:            Unos Install.
-* installing GNU CC on VMS:             VMS 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.
-* INTEGRATE_THRESHOLD:                  Misc.
-* integrating function code:            Inline.
-* Intel 386 Options:                    i386 Options.
-* Interdependence of Patterns:          Dependent Patterns.
-* interface and implementation headers, C++: C++ Interface.
-* interfacing to GNU CC output:         Interface.
-* intermediate C version, nonexistent:  G++ and GCC.
-* INTIFY:                               Library Calls.
-* introduction:                         Top.
-* INT_TYPE_SIZE:                        Type Layout.
-* invalid assembly code:                Bug Criteria.
-* invalid input:                        Bug Criteria.
-* invoking g++:                         Invoking G++.
-* in_data:                              Sections.
-* in_struct:                            Flags.
-* in_text:                              Sections.
-* 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.
-* JUMP_LABEL:                           Insns.
-* JUMP_TABLES_IN_TEXT_SECTION:          Sections.
-* kernel and user registers (29k):      AMD29K Options.
-* keywords, alternate:                  Alternate Keywords.
-* known causes of trouble:              Trouble.
-* labeled elements in initializers:     Labeled Elements.
-* labels as values:                     Labels as Values.
-* LABEL_NUSES:                          Insns.
-* LABEL_OUTSIDE_LOOP_P:                 Flags.
-* LABEL_PRESERVE_P:                     Flags.
-* label_ref:                            Constants.
-* labs:                                 C Dialect Options.
-* language dialect options:             C Dialect Options.
-* large bit shifts (88k):               M88K Options.
-* large return values:                  Aggregate Return.
-* LAST_STACK_REG:                       Stack Registers.
-* LAST_VIRTUAL_REGISTER:                Regs and Memory.
-* ldexp:                                Cross-compilation.
-* le:                                   Comparisons.
-* leaf functions:                       Leaf Functions.
-* leaf_function:                        Leaf Functions.
-* leaf_function_p:                      Standard Names.
-* LEAF_REGISTERS:                       Leaf Functions.
-* LEAF_REG_REMAP:                       Leaf Functions.
-* left rotate:                          Arithmetic.
-* left shift:                           Arithmetic.
-* left shift:                           Arithmetic.
-* LEGITIMATE_CONSTANT_P:                Addressing Modes.
-* LEGITIMATE_PIC_OPERAND_P:             PIC.
-* LEGITIMIZE_ADDRESS:                   Addressing Modes.
-* length-zero arrays:                   Zero Length.
-* less than:                            Comparisons.
-* less than or equal:                   Comparisons.
-* leu:                                  Comparisons.
-* LIBCALL_VALUE:                        Scalar Return.
-* LIBGCC_NEEDS_DOUBLE:                  Library Calls.
-* Libraries:                            Link Options.
-* library subroutine names:             Library Calls.
-* LIBRARY_PATH:                         Environment Variables.
-* LIB_SPEC:                             Driver.
-* LIMIT_RELOAD_CLASS:                   Register Classes.
-* link options:                         Link Options.
-* LINK_LIBGCC_SPECIAL:                  Driver.
-* LINK_LIBGCC_SPECIAL_1:                Driver.
-* LINK_SPEC:                            Driver.
-* load address instruction:             Simple Constraints.
-* LOAD_EXTEND_OP:                       Misc.
-* local labels:                         Local Labels.
-* local register allocation:            Passes.
-* local variables in macros:            Naming Types.
-* local variables, specifying registers: Local Reg Vars.
-* LOCAL_INCLUDE_DIR:                    Driver.
-* LOCAL_LABEL_PREFIX:                   Instruction Output.
-* logical shift:                        Arithmetic.
-* logical-and, bitwise:                 Arithmetic.
-* LOG_LINKS:                            Insns.
-* longjmp:                              Global Reg Vars.
-* LONGJMP_RESTORE_FROM_STACK:           Elimination.
-* LONG_DOUBLE_TYPE_SIZE:                Type Layout.
-* LONG_LONG_TYPE_SIZE:                  Type Layout.
-* LONG_TYPE_SIZE:                       Type Layout.
-* loop optimization:                    Passes.
-* lo_sum:                               Arithmetic.
-* lshift:                               Arithmetic.
-* lshiftrt:                             Arithmetic.
-* lt:                                   Comparisons.
-* ltu:                                  Comparisons.
-* lvalues, generalized:                 Lvalues.
-* M680x0 options:                       M680x0 Options.
-* M88k options:                         M88K Options.
-* machine dependent options:            Submodel Options.
-* machine description macros:           Target Macros.
-* machine descriptions:                 Machine Desc.
-* machine mode conversions:             Conversions.
-* machine modes:                        Machine Modes.
-* machine specific constraints:         Machine Constraints.
-* macro with variable arguments:        Macro Varargs.
-* 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.
-* matching constraint:                  Simple Constraints.
-* matching operands:                    Output Template.
-* match_dup:                            RTL Template.
-* match_operand:                        RTL Template.
-* match_operator:                       RTL Template.
-* match_op_dup:                         RTL Template.
-* match_parallel:                       RTL Template.
-* match_par_dup:                        RTL Template.
-* match_scratch:                        RTL Template.
-* math libraries:                       Interface.
-* math, in RTL:                         Arithmetic.
-* maximum operator:                     Min and Max.
-* MAX_BITS_PER_WORD:                    Storage Layout.
-* MAX_CHAR_TYPE_SIZE:                   Type Layout.
-* MAX_FIXED_MODE_SIZE:                  Storage Layout.
-* MAX_INT_TYPE_SIZE:                    Type Layout.
-* MAX_LONG_TYPE_SIZE:                   Type Layout.
-* MAX_MOVE_MAX:                         Misc.
-* MAX_OFILE_ALIGNMENT:                  Storage Layout.
-* MAX_REGS_PER_ADDRESS:                 Addressing Modes.
-* MAX_UNITS_PER_WORD:                   Storage Layout.
-* MAX_WCHAR_TYPE_SIZE:                  Type Layout.
-* MAYBE_REG_PARM_STACK_SPACE:           Stack Arguments.
-* mcount:                               Profiling.
-* MD_CALL_PROTOTYPES:                   Config.
-* MD_EXEC_PREFIX:                       Driver.
-* MD_STARTFILE_PREFIX:                  Driver.
-* MD_STARTFILE_PREFIX_1:                Driver.
-* mem:                                  Regs and Memory.
-* member fns, automatically inline:     Inline.
-* memcmp:                               C Dialect Options.
-* memcpy:                               C Dialect Options.
-* memory model (29k):                   AMD29K Options.
-* memory reference, nonoffsettable:     Simple Constraints.
-* memory references in constraints:     Simple Constraints.
-* MEMORY_MOVE_COST:                     Costs.
-* MEM_IN_STRUCT_P:                      Flags.
-* MEM_VOLATILE_P:                       Flags.
-* messages, warning:                    Warning Options.
-* messages, warning and error:          Warnings and Errors.
-* middle-operands, omitted:             Conditionals.
-* minimum operator:                     Min and Max.
-* minus:                                Arithmetic.
-* MIPS options:                         MIPS Options.
-* misunderstandings in C++:             C++ Misunderstandings.
-* mod:                                  Arithmetic.
-* MODDI3_LIBCALL:                       Library Calls.
-* mode classes:                         Machine Modes.
-* 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.
-* modifiers in constraints:             Modifiers.
-* MODSI3_LIBCALL:                       Library Calls.
-* MOVE_MAX:                             Misc.
-* MOVE_RATIO:                           Costs.
-* MULDI3_LIBCALL:                       Library Calls.
-* MULSI3_LIBCALL:                       Library Calls.
-* mult:                                 Arithmetic.
-* MULTIBYTE_CHARS:                      Config.
-* multiple alternative constraints:     Multi-Alternative.
-* multiplication:                       Arithmetic.
-* multiprecision arithmetic:            Long Long.
-* name augmentation:                    VMS Misc.
-* named patterns and conditions:        Patterns.
-* named return value in C++:            Naming Results.
-* names used in assembler code:         Asm Labels.
-* names, pattern:                       Standard Names.
-* naming convention, implementation headers: C++ Interface.
-* naming types:                         Naming Types.
-* ne:                                   Comparisons.
-* neg:                                  Arithmetic.
-* nested functions:                     Nested Functions.
-* nested functions, trampolines for:    Trampolines.
-* newline vs string constants:          C Dialect Options.
-* next_cc0_user:                        Jump Patterns.
-* NEXT_INSN:                            Insns.
-* NEXT_OBJC_RUNTIME:                    Library Calls.
-* nil:                                  RTL Objects.
-* no constraints:                       No Constraints.
-* no-op move instructions:              Passes.
-* non-constant initializers:            Initializers.
-* non-static inline function:           Inline.
-* nongcc_SI_type:                       Library Calls.
-* nongcc_word_type:                     Library Calls.
-* nonoffsettable memory reference:      Simple Constraints.
-* NON_SAVING_SETJMP:                    Register Basics.
-* not:                                  Arithmetic.
-* not equal:                            Comparisons.
-* not using constraints:                No Constraints.
-* note:                                 Insns.
-* 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_BUILTIN_PTRDIFF_TYPE:              Driver.
-* NO_BUILTIN_SIZE_TYPE:                 Driver.
-* NO_DOLLAR_IN_LABEL:                   Misc.
-* NO_DOT_IN_LABEL:                      Misc.
-* NO_FUNCTION_CSE:                      Costs.
-* NO_IMPLICIT_EXTERN_C:                 Misc.
-* NO_MD_PROTOTYPES:                     Config.
-* 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_PROLOGUE:                        File Framework.
-* OBJC_SELECTORS_WITHOUT_LABELS:        Type Layout.
-* Objective C:                          G++ and GCC.
-* OBJECT_FORMAT_COFF:                   Macros for Initialization.
-* OBJECT_FORMAT_ROSE:                   Macros for Initialization.
-* OBSTACK_CHUNK_ALLOC:                  Config.
-* OBSTACK_CHUNK_FREE:                   Config.
-* OBSTACK_CHUNK_SIZE:                   Config.
-* obstack_free:                         3b1 Install.
-* OCS (88k):                            M88K Options.
-* offsettable address:                  Simple Constraints.
-* old-style function definitions:       Function Prototypes.
-* omitted middle-operands:              Conditionals.
-* ONLY_INT_FIELDS:                      Config.
-* open coding:                          Inline.
-* operand access:                       Accessors.
-* operand constraints:                  Constraints.
-* operand substitution:                 Output Template.
-* operands:                             Patterns.
-* OPTIMIZATION_OPTIONS:                 Run-time Target.
-* optimize options:                     Optimize Options.
-* optional hardware or system features: Run-time Target.
-* options to control warnings:          Warning Options.
-* options, C++:                         C++ Dialect Options.
-* options, code generation:             Code Gen Options.
-* options, debugging:                   Debugging Options.
-* options, dialect:                     C Dialect Options.
-* options, directory search:            Directory Options.
-* options, GNU CC command:              Invoking GCC.
-* options, grouping:                    Invoking GCC.
-* options, linking:                     Link Options.
-* options, optimization:                Optimize Options.
-* options, order:                       Invoking GCC.
-* options, preprocessor:                Preprocessor Options.
-* order of evaluation, side effects:    Non-bugs.
-* order of options:                     Invoking GCC.
-* order of register allocation:         Allocation Order.
-* Ordering of Patterns:                 Pattern Ordering.
-* ORDER_REGS_FOR_LOCAL_ALLOC:           Allocation Order.
-* other directory, compilation in:      Other Dir.
-* OUTGOING_REGNO:                       Register Basics.
-* OUTGOING_REG_PARM_STACK_SPACE:        Stack Arguments.
-* 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.
-* OVERLAPPING_REGNO_P:                  Obsolete Register Macros.
-* overloaded virtual fn, warning:       Warning Options.
-* OVERRIDE_OPTIONS:                     Run-time Target.
-* parallel:                             Side Effects.
-* parameter forward declaration:        Variable Length.
-* parameters, miscellaneous:            Misc.
-* PARM_BOUNDARY:                        Storage Layout.
-* parser generator, Bison:              Installation.
-* parsing pass:                         Passes.
-* passes and files of the compiler:     Passes.
-* passing arguments:                    Interface.
-* PATTERN:                              Insns.
-* pattern conditions:                   Patterns.
-* pattern names:                        Standard Names.
-* Pattern Ordering:                     Pattern Ordering.
-* patterns:                             Patterns.
-* pc:                                   Regs and Memory.
-* PCC_BITFIELD_TYPE_MATTERS:            Storage Layout.
-* PCC_STATIC_STRUCT_RETURN:             Aggregate Return.
-* pc_rtx:                               Regs and Memory.
-* PDImode:                              Machine Modes.
-* peephole optimization:                Passes.
-* peephole optimization, RTL representation: Side Effects.
-* peephole optimizer definitions:       Peephole Definitions.
-* percent sign:                         Output Template.
-* perform_...:                          Library Calls.
-* PIC:                                  PIC.
-* PIC:                                  Code Gen Options.
-* PIC_OFFSET_TABLE_REGNUM:              PIC.
-* plus:                                 Arithmetic.
-* Pmode:                                Misc.
-* pointer arguments:                    Function Attributes.
-* POINTER_SIZE:                         Storage Layout.
-* portability:                          Portability.
-* portions of temporary objects, pointers to: Temporaries.
-* position independent code:            PIC.
-* post_dec:                             Incdec.
-* post_inc:                             Incdec.
-* pragma:                               Misc.
-* pragma, reason for not using:         Function Attributes.
-* pragmas in C++, effect on inlining:   C++ Interface.
-* pragmas, interface and implementation: C++ Interface.
-* predefined macros:                    Run-time Target.
-* PREDICATE_CODES:                      Misc.
-* PREFERRED_DEBUGGING_TYPE:             All Debuggers.
-* PREFERRED_OUTPUT_RELOAD_CLASS:        Register Classes.
-* PREFERRED_RELOAD_CLASS:               Register Classes.
-* preprocessing numbers:                Incompatibilities.
-* preprocessing tokens:                 Incompatibilities.
-* preprocessor options:                 Preprocessor Options.
-* PRESERVE_DEATH_INFO_REGNO_P:          Obsolete Register Macros.
-* prev_cc0_setter:                      Jump Patterns.
-* PREV_INSN:                            Insns.
-* prev_nonnote_insn:                    Peephole Definitions.
-* pre_dec:                              Incdec.
-* pre_inc:                              Incdec.
-* PRINT_OPERAND:                        Instruction Output.
-* PRINT_OPERAND_ADDRESS:                Instruction Output.
-* PRINT_OPERAND_PUNCT_VALID_P:          Instruction Output.
-* processor selection (29k):            AMD29K Options.
-* product:                              Arithmetic.
-* PROFILE_BEFORE_PROLOGUE:              Profiling.
-* profiling, code generation:           Profiling.
-* program counter:                      Regs and Memory.
-* prologue:                             Function Entry.
-* PROMOTE_FUNCTION_ARGS:                Storage Layout.
-* PROMOTE_FUNCTION_RETURN:              Storage Layout.
-* PROMOTE_MODE:                         Storage Layout.
-* PROMOTE_PROTOTYPES:                   Stack Arguments.
-* promotion of formal parameters:       Function Prototypes.
-* pseudo registers:                     Regs and Memory.
-* PSImode:                              Machine Modes.
-* PTRDIFF_TYPE:                         Type Layout.
-* push address instruction:             Simple Constraints.
-* PUSH_ROUNDING:                        Stack Arguments.
-* putenv:                               Config.
-* PUT_CODE:                             RTL Objects.
-* PUT_MODE:                             Machine Modes.
-* PUT_REG_NOTE_KIND:                    Insns.
-* PUT_SDB_...:                          SDB and DWARF.
-* QImode:                               Machine Modes.
-* question mark:                        Multi-Alternative.
-* quotient:                             Arithmetic.
-* r0-relative references (88k):         M88K Options.
-* ranges in case statements:            Case Ranges.
-* read-only strings:                    Incompatibilities.
-* READONLY_DATA_SECTION:                Sections.
-* REAL_ARITHMETIC:                      Cross-compilation.
-* REAL_INFINITY:                        Cross-compilation.
-* REAL_NM_FILE_NAME:                    Macros for Initialization.
-* REAL_VALUES_EQUAL:                    Cross-compilation.
-* REAL_VALUES_LESS:                     Cross-compilation.
-* REAL_VALUE_ATOF:                      Cross-compilation.
-* REAL_VALUE_FIX:                       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_RNDZINT:                   Cross-compilation.
-* REAL_VALUE_TO_DECIMAL:                Data Output.
-* REAL_VALUE_TO_INT:                    Cross-compilation.
-* REAL_VALUE_TO_TARGET_DOUBLE:          Data Output.
-* REAL_VALUE_TO_TARGET_LONG_DOUBLE:     Data Output.
-* REAL_VALUE_TO_TARGET_SINGLE:          Data Output.
-* REAL_VALUE_TRUNCATE:                  Cross-compilation.
-* REAL_VALUE_TYPE:                      Cross-compilation.
-* REAL_VALUE_UNSIGNED_FIX:              Cross-compilation.
-* REAL_VALUE_UNSIGNED_RNDZINT:          Cross-compilation.
-* recognizing insns:                    RTL Template.
-* recog_operand:                        Instruction Output.
-* reg:                                  Regs and Memory.
-* 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 Transfer Language (RTL):     RTL.
-* register usage:                       Registers.
-* register use analysis:                Passes.
-* register variable after longjmp:      Global Reg Vars.
-* register-to-stack conversion:         Passes.
-* 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.
-* REGISTER_MOVE_COST:                   Costs.
-* REGISTER_NAMES:                       Instruction Output.
-* register_operand:                     RTL Template.
-* REGISTER_PREFIX:                      Instruction Output.
-* REGNO_OK_FOR_BASE_P:                  Register Classes.
-* REGNO_OK_FOR_INDEX_P:                 Register Classes.
-* REGNO_REG_CLASS:                      Register Classes.
-* regs_ever_live:                       Function Entry.
-* 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_names:                            Instruction Output.
-* 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 costs:                       Costs.
-* RELATIVE_PREFIX_NOT_LINKDIR:          Driver.
-* reload pass:                          Regs and Memory.
-* reloading:                            Passes.
-* reload_completed:                     Standard Names.
-* reload_in_progress:                   Standard Names.
-* remainder:                            Arithmetic.
-* reporting bugs:                       Bugs.
-* representation of RTL:                RTL.
-* rest argument (in macro):             Macro Varargs.
-* rest_of_compilation:                  Passes.
-* rest_of_decl_compilation:             Passes.
-* return:                               Side Effects.
-* return value of main:                 VMS Misc.
-* return value, named, in C++:          Naming Results.
-* return values in registers:           Scalar Return.
-* returning aggregate values:           Aggregate Return.
-* returning structures and unions:      Interface.
-* RETURN_ADDR_IN_PREVIOUS_FRAME:        Frame Layout.
-* RETURN_ADDR_RTX:                      Frame Layout.
-* RETURN_IN_MEMORY:                     Aggregate Return.
-* RETURN_POPS_ARGS:                     Stack Arguments.
-* right rotate:                         Arithmetic.
-* right shift:                          Arithmetic.
-* rotate:                               Arithmetic.
-* rotate:                               Arithmetic.
-* rotatert:                             Arithmetic.
-* ROUND_TYPE_ALIGN:                     Storage Layout.
-* ROUND_TYPE_SIZE:                      Storage Layout.
-* RS/6000 and PowerPC Options:          RS/6000 and PowerPC Options.
-* RT options:                           RT Options.
-* RT PC:                                Interoperation.
-* 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.
-* 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.
-* SCCS_DIRECTIVE:                       Misc.
-* scheduling, delayed branch:           Passes.
-* scheduling, instruction:              Passes.
-* scheduling, instruction:              Passes.
-* SCHED_GROUP_P:                        Flags.
-* SCmode:                               Machine Modes.
-* scope of a variable length array:     Variable Length.
-* scope of declaration:                 Disappointments.
-* scope of external declarations:       Incompatibilities.
-* scratch:                              Regs and Memory.
-* scratch operands:                     Regs and Memory.
-* SDB_ALLOW_FORWARD_REFERENCES:         SDB and DWARF.
-* SDB_ALLOW_UNKNOWN_REFERENCES:         SDB and DWARF.
-* SDB_DEBUGGING_INFO:                   SDB and DWARF.
-* SDB_DELIM:                            SDB and DWARF.
-* SDB_GENERATE_FAKE:                    SDB and DWARF.
-* search path:                          Directory Options.
-* second include path:                  Preprocessor Options.
-* SECONDARY_INPUT_RELOAD_CLASS:         Register Classes.
-* SECONDARY_MEMORY_NEEDED:              Register Classes.
-* SECONDARY_MEMORY_NEEDED_RTX:          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.
-* separate directory, compilation in:   Other Dir.
-* sequence:                             Side Effects.
-* sequential consistency on 88k:        M88K Options.
-* set:                                  Side Effects.
-* setjmp:                               Global Reg Vars.
-* SETUP_FRAME_ADDRESSES:                Frame Layout.
-* SETUP_INCOMING_VARARGS:               Varargs.
-* set_attr:                             Tagging Insns.
-* set_attr_alternative:                 Tagging Insns.
-* SET_DEST:                             Side Effects.
-* SET_SRC:                              Side Effects.
-* SFmode:                               Machine Modes.
-* shared strings:                       Incompatibilities.
-* shared VMS run time system:           VMS Misc.
-* SHARED_SECTION_ASM_OP:                Sections.
-* sharing of RTL components:            Sharing.
-* shift:                                Arithmetic.
-* SHIFT_COUNT_TRUNCATED:                Misc.
-* SHORT_TYPE_SIZE:                      Type Layout.
-* side effect in ?::                    Conditionals.
-* side effects, macro argument:         Statement Exprs.
-* side effects, order of evaluation:    Non-bugs.
-* signed division:                      Arithmetic.
-* signed maximum:                       Arithmetic.
-* signed minimum:                       Arithmetic.
-* SIGNED_CHAR_SPEC:                     Driver.
-* sign_extend:                          Conversions.
-* sign_extract:                         Bit Fields.
-* SImode:                               Machine Modes.
-* simple constraints:                   Simple Constraints.
-* simplifications, arithmetic:          Passes.
-* sin:                                  C Dialect Options.
-* sizeof:                               Typeof.
-* SIZE_TYPE:                            Type Layout.
-* SLOW_BYTE_ACCESS:                     Costs.
-* SLOW_UNALIGNED_ACCESS:                Costs.
-* SLOW_ZERO_EXTEND:                     Costs.
-* smaller data references (88k):        M88K Options.
-* smaller data references (MIPS):       MIPS Options.
-* SMALL_REGISTER_CLASSES:               Register Classes.
-* smax:                                 Arithmetic.
-* smin:                                 Arithmetic.
-* SPARC options:                        SPARC Options.
-* 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:                                 C Dialect Options.
-* sqrt:                                 Arithmetic.
-* square root:                          Arithmetic.
-* stack arguments:                      Stack Arguments.
-* stack checks (29k):                   AMD29K Options.
-* stack frame layout:                   Frame Layout.
-* 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_pointer_rtx:                    Frame Registers.
-* STACK_REGS:                           Stack Registers.
-* stage1:                               Installation.
-* standard pattern names:               Standard Names.
-* STANDARD_EXEC_PREFIX:                 Driver.
-* STANDARD_INCLUDE_DIR:                 Driver.
-* STANDARD_STARTFILE_PREFIX:            Driver.
-* start files:                          Tools and Libraries.
-* STARTFILE_SPEC:                       Driver.
-* STARTING_FRAME_OFFSET:                Frame Layout.
-* statements inside expressions:        Statement Exprs.
-* static data in C++, declaring and defining: Static Definitions.
-* 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.
-* storage layout:                       Storage Layout.
-* STORE_FLAG_VALUE:                     Misc.
-* strcmp:                               C Dialect Options.
-* strcpy:                               C Dialect Options.
-* strcpy:                               Storage Layout.
-* strength-reduction:                   Passes.
-* STRICT_ALIGNMENT:                     Storage Layout.
-* strict_low_part:                      RTL Declarations.
-* string constants:                     Incompatibilities.
-* string constants vs newline:          C Dialect Options.
-* STRIP_NAME_ENCODING:                  Sections.
-* strlen:                               C Dialect Options.
-* structure passing (88k):              M88K Options.
-* structure value address:              Aggregate Return.
-* structures:                           Incompatibilities.
-* structures, constructor expression:   Constructors.
-* structures, returning:                Interface.
-* 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.
-* stupid register allocation:           Passes.
-* submodel options:                     Submodel Options.
-* subreg:                               Regs and Memory.
-* SUBREG_PROMOTED_UNSIGNED_P:           Flags.
-* SUBREG_PROMOTED_VAR_P:                Flags.
-* SUBREG_REG:                           Regs and Memory.
-* SUBREG_WORD:                          Regs and Memory.
-* subscripting:                         Subscripting.
-* subscripting and function values:     Subscripting.
-* SUCCESS_EXIT_CODE:                    Config.
-* suffixes for C++ source:              Invoking G++.
-* Sun installation:                     Sun Install.
-* suppressing warnings:                 Warning Options.
-* surprises in C++:                     C++ Misunderstandings.
-* SVr4:                                 M88K Options.
-* SWITCHES_NEED_SPACES:                 Driver.
-* SWITCH_TAKES_ARG:                     Driver.
-* symbolic label:                       Sharing.
-* symbol_ref:                           Constants.
-* SYMBOL_REF_FLAG:                      Flags.
-* SYMBOL_REF_USED:                      Flags.
-* syntax checking:                      Warning Options.
-* SYSTEM_INCLUDE_DIR:                   Driver.
-* 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.
-* TARGET_BELL:                          Type Layout.
-* TARGET_BS:                            Type Layout.
-* TARGET_CR:                            Type Layout.
-* TARGET_EDOM:                          Library Calls.
-* 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.
-* template debugging:                   Warning Options.
-* temporaries, lifetime of:             Temporaries.
-* termination routines:                 Initialization.
-* text_section:                         Sections.
-* TEXT_SECTION_ASM_OP:                  Sections.
-* TFmode:                               Machine Modes.
-* thunks:                               Nested Functions.
-* TImode:                               Machine Modes.
-* TMPDIR:                               Environment Variables.
-* top level of compiler:                Passes.
-* traditional C language:               C Dialect Options.
-* TRADITIONAL_RETURN_FLOAT:             Scalar Return.
-* trampolines for nested functions:     Trampolines.
-* TRAMPOLINE_ALIGNMENT:                 Trampolines.
-* TRAMPOLINE_SECTION:                   Trampolines.
-* TRAMPOLINE_SIZE:                      Trampolines.
-* TRAMPOLINE_TEMPLATE:                  Trampolines.
-* TRANSFER_FROM_TRAMPOLINE:             Trampolines.
-* TRULY_NOOP_TRUNCATION:                Misc.
-* truncate:                             Conversions.
-* type alignment:                       Alignment.
-* typedef names as function parameters: Incompatibilities.
-* typeof:                               Typeof.
-* udiv:                                 Arithmetic.
-* UDIVDI3_LIBCALL:                      Library Calls.
-* UDIVSI3_LIBCALL:                      Library Calls.
-* Ultrix calling convention:            Interoperation.
-* umax:                                 Arithmetic.
-* umin:                                 Arithmetic.
-* umod:                                 Arithmetic.
-* UMODDI3_LIBCALL:                      Library Calls.
-* UMODSI3_LIBCALL:                      Library Calls.
-* 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.
-* UNITS_PER_WORD:                       Storage Layout.
-* UNKNOWN_FLOAT_FORMAT:                 Storage Layout.
-* Unos installation:                    Unos Install.
-* 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.
-* USER_LABEL_PREFIX:                    Instruction Output.
-* USE_C_ALLOCA:                         Config.
-* USE_PROTOTYPES:                       Config.
-* USG:                                  Config.
-* value after longjmp:                  Global Reg Vars.
-* values, returned by functions:        Scalar Return.
-* varargs implementation:               Varargs.
-* variable alignment:                   Alignment.
-* variable attributes:                  Variable Attributes.
-* variable number of arguments:         Macro Varargs.
-* variable-length array scope:          Variable Length.
-* variable-length arrays:               Variable Length.
-* variables in specified registers:     Explicit Reg Vars.
-* variables, local, in macros:          Naming Types.
-* Vax calling convention:               Interoperation.
-* 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.
-* void pointers, arithmetic:            Pointer Arith.
-* void, size of pointer to:             Pointer Arith.
-* VOIDmode:                             Machine Modes.
-* volatil:                              Flags.
-* volatile memory references:           Flags.
-* voting between constraint alternatives: Class Preferences.
-* vprintf:                              Config.
-* warning for enumeration conversions:  Warning Options.
-* warning for overloaded virtual fn:    Warning Options.
-* warning messages:                     Warning Options.
-* warnings vs errors:                   Warnings and Errors.
-* WCHAR_TYPE:                           Type Layout.
-* WCHAR_TYPE_SIZE:                      Type Layout.
-* which_alternative:                    Output Statement.
-* whitespace:                           Incompatibilities.
-* WORDS_BIG_ENDIAN:                     Storage Layout.
-* word_mode:                            Machine Modes.
-* WORD_REGISTER_OPERATIONS:             Misc.
-* WORD_SWITCH_TAKES_ARG:                Driver.
-* XCmode:                               Machine Modes.
-* XCOFF_DEBUGGING_INFO:                 DBX Options.
-* XEXP:                                 Accessors.
-* XFmode:                               Machine Modes.
-* XINT:                                 Accessors.
-* xor:                                  Arithmetic.
-* XSTR:                                 Accessors.
-* XVEC:                                 Accessors.
-* XVECEXP:                              Accessors.
-* XVECLEN:                              Accessors.
-* XWINT:                                Accessors.
-* zero division on 88k:                 M88K Options.
-* zero-length arrays:                   Zero Length.
-* zero_extend:                          Conversions.
-* zero_extract:                         Bit Fields.
-* \:                                    Output Template.
-* __bb_init_func:                       Profiling.
-* __builtin_apply:                      Constructing Calls.
-* __builtin_apply_args:                 Constructing Calls.
-* __builtin_args_info:                  Varargs.
-* __builtin_classify_type:              Varargs.
-* __builtin_next_arg:                   Varargs.
-* __builtin_return:                     Constructing Calls.
-* __builtin_saveregs:                   Varargs.
-* __CTOR_LIST__:                        Initialization.
-* __DTOR_LIST__:                        Initialization.
+`PREDICATE_CODES'
+     Define this if you have defined special-purpose predicates in the
+     file `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.
+
+`CASE_VALUES_THRESHOLD'
+     Define this to be the smallest number of different values for
+     which it is best to use a jump-table instead of a tree of
+     conditional branches.  The default is four for machines with a
+     `casesi' instruction and five otherwise.  This is best for most
+     machines.
+
+`WORD_REGISTER_OPERATIONS'
+     Define this macro if operations between registers with integral
+     mode smaller than a word are always performed on the entire
+     register.  Most RISC machines have this property and most CISC
+     machines do not.
+
+`LOAD_EXTEND_OP (MODE)'
+     Define this macro to be a C expression indicating when insns that
+     read memory in MODE, an integral mode narrower than a word, set the
+     bits outside of MODE to be either the sign-extension or the
+     zero-extension of the data read.  Return `SIGN_EXTEND' for values
+     of MODE for which the insn sign-extends, `ZERO_EXTEND' for which
+     it zero-extends, and `NIL' for other modes.
+
+     This macro is not called with MODE non-integral or with a width
+     greater than or equal to `BITS_PER_WORD', so you may return any
+     value in this case.  Do not define this macro if it would always
+     return `NIL'.  On machines where this macro is defined, you will
+     normally define it as the constant `SIGN_EXTEND' or `ZERO_EXTEND'.
+
+`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.
+
+`MAX_MOVE_MAX'
+     The maximum number of bytes that a single instruction can move
+     quickly from memory to memory.  If this is undefined, the default
+     is `MOVE_MAX'.  Otherwise, it is the constant value that is the
+     largest value that `MOVE_MAX' can have at run-time.
+
+`SHIFT_COUNT_TRUNCATED'
+     A C expression that is nonzero if on this machine the number of
+     bits actually used for the count of a shift operation is equal to
+     the number of bits needed to represent the size of the object
+     being shifted.  When this macro is non-zero, the compiler will
+     assume that it is safe to omit a sign-extend, zero-extend, and
+     certain bitwise `and' instructions that truncates the count of a
+     shift operation.  On machines that have instructions that act on
+     bitfields at variable positions, which may include `bit test'
+     instructions, a nonzero `SHIFT_COUNT_TRUNCATED' also enables
+     deletion of truncations of the values that serve as arguments to
+     bitfield 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.  Define `SHIFT_COUNT_TRUNCATED' to
+     be zero on such machines.  Instead, add patterns to the `md' file
+     that include the implied truncation of the shift instructions.
+
+     You need not define this macro if it would always have the value
+     of zero.
+
+`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.
+
+     When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for
+     modes for which `MODES_TIEABLE_P' is 0, suboptimal code can result.
+     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 with an integral mode 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 whose results have a `MODE_INT' mode.
+
+     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 How to Report Bugs: 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'.
+
+     Many machines can produce both the value chosen for
+     `STORE_FLAG_VALUE' and its negation in the same number of
+     instructions.  On those machines, you should also define a pattern
+     for those cases, e.g., one matching
+
+          (set A (neg:M (ne:M B C)))
+
+     Some machines can also perform `and' or `plus' operations on
+     condition code values with less instructions than the corresponding
+     `sCOND' insn followed by `and' or `plus'.  On those machines,
+     define the appropriate patterns.  Use the names `incscc' and
+     `decscc', respectively, for the the patterns which perform `plus'
+     or `minus' operations on condition code values.  See `rs6000.md'
+     for some examples.  The GNU Superoptizer can be used to find such
+     instruction sequences on other machines.
+
+     You need not define `STORE_FLAG_VALUE' if the machine has no
+     store-flag instructions.
+
+`FLOAT_STORE_FLAG_VALUE'
+     A C expression that gives a non-zero floating point value that is
+     returned when comparison operators with floating-point results are
+     true.  Define this macro on machine that have comparison
+     operations that return floating-point values.  If there are no
+     such operations, do not define this macro.
+
+`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.
+
+`NO_IMPLICIT_EXTERN_C'
+     Define this macro if the system header files support C++ as well
+     as C.  This macro inhibits the usual method of using system header
+     files in C++, which is to pretend that the file's contents are
+     enclosed in `extern "C" {...}'.
+
+`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.
+
+`VALID_MACHINE_ATTRIBUTE (TYPE, ATTRIBUTES, IDENTIFIER)'
+     Define this macro if you want to support machine specific
+     attributes for types.  If defined, it should be a C statement
+     whose value is nonzero if IDENTIFIER is an attribute that is valid
+     for TYPE.  The attributes in ATTRIBUTES have previously been
+     assigned to TYPE.
+
+`COMP_TYPE_ATTRIBUTES (TYPE1, TYPE2)'
+     Define this macro if type attributes must be checked for
+     compatibility.  If defined, it should be a C statement that
+     returns zero if the attributes on TYPE1 and TYPE2 are
+     incompatible, one if they are compatible, and two if they are
+     nearly compatible (which causes a warning to be generated).
+
+`SET_DEFAULT_TYPE_ATTRIBUTES (TYPE)'
+     Define this macro if you want to give the newly defined TYPE some
+     default attributes.
+
+`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.
+
+`NO_DOT_IN_LABEL'
+     Define this macro if the assembler does not accept the character
+     `.' in label names.  By default constructors and destructors in G++
+     have names that use `.'.  If this macro is defined, these names
+     are rewritten to avoid `.'.
+
+`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.
+
+`INSN_SETS_ARE_DELAYED (INSN)'
+     Define this macro as a C expression that is nonzero if it is safe
+     for the delay slot scheduler to place instructions in the delay
+     slot of INSN, even if they appear to use a resource set or
+     clobbered in INSN.  INSN is always a `jump_insn' or an `insn'; GNU
+     CC knows that every `call_insn' has this behavior.  On machines
+     where some `insn' or `jump_insn' is really a function call and
+     hence has this behavior, you should define this macro.
+
+     You need not define this macro if it would always return zero.
+
+`INSN_REFERENCES_ARE_DELAYED (INSN)'
+     Define this macro as a C expression that is nonzero if it is safe
+     for the delay slot scheduler to place instructions in the delay
+     slot of INSN, even if they appear to set or clobber a resource
+     referenced in INSN.  INSN is always a `jump_insn' or an `insn'.
+     On machines where some `insn' or `jump_insn' is really a function
+     call and its operands are registers whose use is actually in the
+     subroutine it calls, you should define this macro.  Doing so
+     allows the delay slot scheduler to move instructions which copy
+     arguments into the argument registers into the delay slot of INSN.
+
+     You need not define this macro if it would always return zero.
+
+`MACHINE_DEPENDENT_REORG (INSN)'
+     In rare cases, correct code generation requires extra machine
+     dependent processing between the second jump optimization pass and
+     delayed branch scheduling.  On those machines, define this macro
+     as a C statement to act on the code starting at INSN.
 
+
+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_WORDS_BIG_ENDIAN'
+     Define this macro to be 1 if the host machine stores `DFmode',
+     `XFmode' or `TFmode' floating point numbers in memory with the
+     word containing the sign bit at the lowest address; otherwise,
+     define it to be zero.
+
+     This macro need not be defined if the ordering is the same as for
+     multi-word integers.
+
+`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'.
+
+`DONT_DECLARE_SYS_SIGLIST'
+     Define this if your system has the variable `sys_siglist', and
+     there is already a declaration of it in the system header files.
+
+`USE_PROTOTYPES'
+     Define this to be 1 if you know that the host compiler supports
+     prototypes, even if it doesn't define __STDC__, or define it to be
+     0 if you do not want any prototypes used in compiling GNU CC.  If
+     `USE_PROTOTYPES' is not defined, it will be determined
+     automatically whether your compiler supports prototypes by
+     checking if `__STDC__' is defined.
+
+`NO_MD_PROTOTYPES'
+     Define this if you wish suppression of prototypes generated from
+     the machine description file, but to use other prototypes within
+     GNU CC.  If `USE_PROTOTYPES' is defined to be 0, or the host
+     compiler does not support prototypes, this macro has no effect.
+
+`MD_CALL_PROTOTYPES'
+     Define this if you wish to generate prototypes for the `gen_call'
+     or `gen_call_value' functions generated from the machine
+     description file.  If `USE_PROTOTYPES' is defined to be 0, or the
+     host compiler does not support prototypes, or `NO_MD_PROTOTYPES'
+     is defined, this macro has no effect.  As soon as all of the
+     machine descriptions are modified to have the appropriate number
+     of arguments, this macro will be removed.
+
+     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.
+
+`PATH_SEPARATOR'
+     Define this macro to be a C character constant representing the
+     character used to separate components in paths.  The default value
+     is.  the colon character
+
+`DIR_SEPARATOR'
+     If your system uses some character other than slash to separate
+     directory names within a file specification, define this macro to
+     be a C character constant specifying that character.  When GNU CC
+     displays file names, the character you specify will be used.  GNU
+     CC will test for both slash and the character you specify when
+     parsing filenames.
+
+   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'.