This is doc/gccint.info, produced by makeinfo version 4.3 from
doc/gccint.texi.

INFO-DIR-SECTION Programming
START-INFO-DIR-ENTRY
* gccint: (gccint).            Internals of the GNU Compiler Collection.
END-INFO-DIR-ENTRY
   This file documents the internals of the GNU compilers.

   Published by the Free Software Foundation
59 Temple Place - Suite 330
Boston, MA 02111-1307 USA

   Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000, 2001, 2002 Free Software Foundation, Inc.

   Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.1 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "GNU General Public License" and "Funding Free
Software", the Front-Cover texts being (a) (see below), and with the
Back-Cover Texts being (b) (see below).  A copy of the license is
included in the section entitled "GNU Free Documentation License".

   (a) The FSF's Front-Cover Text is:

   A GNU Manual

   (b) The FSF's Back-Cover Text is:

   You have freedom to copy and modify this GNU Manual, like GNU
software.  Copies published by the Free Software Foundation raise
funds for GNU development.


File: gccint.info,  Node: Index,  Prev: Option Index,  Up: Top

Index
*****

* Menu:

* ! in constraint:                       Multi-Alternative.
* # in constraint:                       Modifiers.
* # in template:                         Output Template.
* #pragma:                               Misc.
* % in constraint:                       Modifiers.
* % in template:                         Output Template.
* & in constraint:                       Modifiers.
* (nil):                                 RTL Objects.
* * in constraint:                       Modifiers.
* * in template:                         Output Statement.
* + in constraint:                       Modifiers.
* /c in RTL dump:                        Flags.
* /f in RTL dump:                        Flags.
* /i in RTL dump:                        Flags.
* /j 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.
* \:                                     Output Template.
* __builtin_args_info:                   Varargs.
* __builtin_classify_type:               Varargs.
* __builtin_next_arg:                    Varargs.
* __builtin_saveregs:                    Varargs.
* __CTOR_LIST__:                         Initialization.
* __DTOR_LIST__:                         Initialization.
* __main:                                Collect2.
* abort:                                 Portability.
* abs:                                   Arithmetic.
* abs and attributes:                    Expressions.
* absM2 instruction pattern:             Standard Names.
* absolute value:                        Arithmetic.
* access to operands:                    Accessors.
* accessors:                             Accessors.
* ACCUMULATE_OUTGOING_ARGS:              Stack Arguments.
* ACCUMULATE_OUTGOING_ARGS and stack frames: Function Entry.
* ADA_LONG_TYPE_SIZE:                    Type Layout.
* ADDITIONAL_REGISTER_NAMES:             Instruction Output.
* addM3 instruction pattern:             Standard Names.
* addr_diff_vec:                         Side Effects.
* addr_diff_vec, length of:              Insn Lengths.
* ADDR_EXPR:                             Expression trees.
* addr_vec:                              Side Effects.
* addr_vec, length of:                   Insn Lengths.
* address constraints:                   Simple Constraints.
* ADDRESS_COST:                          Costs.
* address_operand:                       Simple Constraints.
* addressing modes:                      Addressing Modes.
* addressof:                             Regs and Memory.
* ADJUST_FIELD_ALIGN:                    Storage Layout.
* ADJUST_INSN_LENGTH:                    Insn Lengths.
* aggregates as return values:           Aggregate Return.
* ALL_REGS:                              Register Classes.
* ALLOCATE_INITIAL_VALUE:                Misc.
* allocate_stack instruction pattern:    Standard Names.
* ALLOCATE_TRAMPOLINE:                   Trampolines.
* analysis, data flow:                   Passes.
* and:                                   Arithmetic.
* and and attributes:                    Expressions.
* and, canonicalization of:              Insn Canonicalizations.
* andM3 instruction pattern:             Standard Names.
* APPLY_RESULT_SIZE:                     Scalar Return.
* ARG_POINTER_CFA_OFFSET:                Frame Layout.
* ARG_POINTER_REGNUM:                    Frame Registers.
* ARG_POINTER_REGNUM and virtual registers: Regs and Memory.
* arg_pointer_rtx:                       Frame Registers.
* ARGS_GROW_DOWNWARD:                    Frame Layout.
* argument passing:                      Interface.
* arguments in registers:                Register Arguments.
* arguments on stack:                    Stack Arguments.
* arithmetic libraries:                  Interface.
* arithmetic shift:                      Arithmetic.
* arithmetic simplifications:            Passes.
* arithmetic, in RTL:                    Arithmetic.
* ARITHMETIC_TYPE_P:                     Types.
* array:                                 Types.
* ARRAY_REF:                             Expression trees.
* ARRAY_TYPE:                            Types.
* ashift:                                Arithmetic.
* ashift and attributes:                 Expressions.
* ashiftrt:                              Arithmetic.
* ashiftrt and attributes:               Expressions.
* ashlM3 instruction pattern:            Standard Names.
* ashrM3 instruction pattern:            Standard Names.
* ASM_APP_OFF:                           File Framework.
* ASM_APP_ON:                            File Framework.
* ASM_CLOBBERS:                          Function Bodies.
* ASM_COMMENT_START:                     File Framework.
* ASM_CV_QUAL:                           Function Bodies.
* ASM_DECLARE_CLASS_REFERENCE:           Label Output.
* ASM_DECLARE_FUNCTION_NAME:             Label Output.
* ASM_DECLARE_FUNCTION_SIZE:             Label Output.
* ASM_DECLARE_OBJECT_NAME:               Label Output.
* ASM_DECLARE_REGISTER_GLOBAL:           Label Output.
* ASM_DECLARE_UNRESOLVED_REFERENCE:      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_FPRINTF_EXTENSIONS:                Instruction Output.
* ASM_GENERATE_INTERNAL_LABEL:           Label Output.
* ASM_GLOBALIZE_LABEL:                   Label Output.
* asm_input:                             Side Effects.
* ASM_INPUTS:                            Function Bodies.
* ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX:     Exception Handling.
* ASM_NO_SKIP_IN_TEXT:                   Alignment Output.
* asm_noperands:                         Insns.
* asm_operands, RTL sharing:             Sharing.
* asm_operands, usage:                   Assembler.
* ASM_OUTPUT_ADDR_DIFF_ELT:              Dispatch Tables.
* ASM_OUTPUT_ADDR_VEC_ELT:               Dispatch Tables.
* ASM_OUTPUT_ALIGN:                      Alignment Output.
* ASM_OUTPUT_ALIGNED_BSS:                Uninitialized Data.
* ASM_OUTPUT_ALIGNED_COMMON:             Uninitialized Data.
* ASM_OUTPUT_ALIGNED_DECL_COMMON:        Uninitialized Data.
* ASM_OUTPUT_ALIGNED_DECL_LOCAL:         Uninitialized Data.
* ASM_OUTPUT_ALIGNED_LOCAL:              Uninitialized Data.
* ASM_OUTPUT_ALTERNATE_LABEL_NAME:       Label Output.
* ASM_OUTPUT_ASCII:                      Data Output.
* ASM_OUTPUT_BSS:                        Uninitialized Data.
* ASM_OUTPUT_CASE_END:                   Dispatch Tables.
* ASM_OUTPUT_CASE_LABEL:                 Dispatch Tables.
* ASM_OUTPUT_COMMON:                     Uninitialized Data.
* ASM_OUTPUT_DEBUG_LABEL:                Label Output.
* ASM_OUTPUT_DEF:                        Label Output.
* ASM_OUTPUT_DEF_FROM_DECLS:             Label Output.
* ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL: Label Output.
* ASM_OUTPUT_EXTERNAL:                   Label Output.
* ASM_OUTPUT_EXTERNAL_LIBCALL:           Label Output.
* ASM_OUTPUT_FDESC:                      Data Output.
* ASM_OUTPUT_IDENT:                      File Framework.
* ASM_OUTPUT_INTERNAL_LABEL:             Label Output.
* ASM_OUTPUT_LABEL:                      Label Output.
* ASM_OUTPUT_LABEL_REF:                  Label Output.
* ASM_OUTPUT_LABELREF:                   Label Output.
* ASM_OUTPUT_LOCAL:                      Uninitialized Data.
* ASM_OUTPUT_MAX_SKIP_ALIGN:             Alignment Output.
* ASM_OUTPUT_MI_THUNK:                   Function Entry.
* ASM_OUTPUT_OPCODE:                     Instruction Output.
* ASM_OUTPUT_POOL_EPILOGUE:              Data Output.
* ASM_OUTPUT_POOL_PROLOGUE:              Data Output.
* ASM_OUTPUT_REG_POP:                    Instruction Output.
* ASM_OUTPUT_REG_PUSH:                   Instruction Output.
* ASM_OUTPUT_SHARED_BSS:                 Uninitialized Data.
* ASM_OUTPUT_SHARED_COMMON:              Uninitialized Data.
* ASM_OUTPUT_SHARED_LOCAL:               Uninitialized Data.
* 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_OUTPUT_SYMBOL_REF:                 Label Output.
* ASM_OUTPUT_WEAK_ALIAS:                 Label Output.
* ASM_OUTPUTS:                           Function Bodies.
* ASM_PREFERRED_EH_DATA_FORMAT:          Exception Handling.
* ASM_SPEC:                              Driver.
* ASM_STABD_OP:                          DBX Options.
* ASM_STABN_OP:                          DBX Options.
* ASM_STABS_OP:                          DBX Options.
* ASM_STMT:                              Function Bodies.
* ASM_STRING:                            Function Bodies.
* ASM_WEAKEN_DECL:                       Label Output.
* ASM_WEAKEN_LABEL:                      Label Output.
* assemble_name:                         Label Output.
* assembler format:                      File Framework.
* assembler instructions in RTL:         Assembler.
* ASSEMBLER_DIALECT:                     Instruction Output.
* assigning attribute values to insns:   Tagging Insns.
* assignment operator:                   Function Basics.
* asterisk in template:                  Output Statement.
* atof:                                  Cross-compilation.
* attr <1>:                              Expressions.
* attr:                                  Tagging Insns.
* attr_flag:                             Expressions.
* attribute expressions:                 Expressions.
* attribute specifications:              Attr Example.
* attribute specifications example:      Attr Example.
* attributes:                            Attributes.
* attributes, defining:                  Defining Attributes.
* attributes, target-specific:           Target Attributes.
* autoincrement addressing, availability: Portability.
* autoincrement/decrement addressing:    Simple Constraints.
* autoincrement/decrement analysis:      Passes.
* AVOID_CCMODE_COPIES:                   Values in Registers.
* backslash:                             Output Template.
* barrier:                               Insns.
* BASE_REG_CLASS:                        Register Classes.
* basic block reordering:                Passes.
* basic blocks:                          Passes.
* bCOND instruction pattern:             Standard Names.
* bcopy, implicit usage:                 Library Calls.
* BIGGEST_ALIGNMENT:                     Storage Layout.
* BIGGEST_FIELD_ALIGNMENT:               Storage Layout.
* BImode:                                Machine Modes.
* BIND_EXPR:                             Expression trees.
* BINFO_TYPE:                            Classes.
* bit-fields:                            Bit-Fields.
* BIT_AND_EXPR:                          Expression trees.
* BIT_IOR_EXPR:                          Expression trees.
* BIT_NOT_EXPR:                          Expression trees.
* BIT_XOR_EXPR:                          Expression trees.
* BITFIELD_NBYTES_LIMITED:               Storage Layout.
* BITS_BIG_ENDIAN:                       Storage Layout.
* BITS_BIG_ENDIAN, effect on sign_extract: Bit-Fields.
* 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.
* BLKmode, and function return values:   Calls.
* BOOL_TYPE_SIZE:                        Type Layout.
* BOOLEAN_TYPE:                          Types.
* branch shortening:                     Passes.
* BRANCH_COST:                           Costs.
* break_out_memory_refs:                 Addressing Modes.
* BREAK_STMT:                            Function Bodies.
* BSS_SECTION_ASM_OP:                    Sections.
* builtin_longjmp instruction pattern:   Standard Names.
* BUILTIN_SETJMP_FRAME_VALUE:            Frame Layout.
* builtin_setjmp_receiver instruction pattern: Standard Names.
* builtin_setjmp_setup instruction pattern: Standard Names.
* byte_mode:                             Machine Modes.
* BYTES_BIG_ENDIAN:                      Storage Layout.
* BYTES_BIG_ENDIAN, effect on subreg:    Regs and Memory.
* bzero, implicit usage:                 Library Calls.
* C statements for assembler output:     Output Statement.
* C/C++ Internal Representation:         Trees.
* C4X_FLOAT_FORMAT:                      Storage Layout.
* call <1>:                              Flags.
* call:                                  Side Effects.
* call instruction pattern:              Standard Names.
* call usage:                            Calls.
* call, in insn_list:                    Flags.
* call-clobbered register:               Register Basics.
* call-saved register:                   Register Basics.
* call-used register:                    Register Basics.
* CALL_EXPR:                             Expression trees.
* call_insn:                             Insns.
* call_insn and /j:                      Flags.
* call_insn and /u:                      Flags.
* CALL_INSN_FUNCTION_USAGE:              Insns.
* call_pop instruction pattern:          Standard Names.
* CALL_POPS_ARGS:                        Stack Arguments.
* CALL_REALLY_USED_REGISTERS:            Register Basics.
* CALL_USED_REGISTERS:                   Register Basics.
* call_used_regs:                        Register Basics.
* call_value instruction pattern:        Standard Names.
* call_value_pop instruction pattern:    Standard Names.
* CALLER_SAVE_PROFITABLE:                Caller Saves.
* calling conventions:                   Stack and Calling.
* calling functions in RTL:              Calls.
* CAN_DEBUG_WITHOUT_FP:                  Run-time Target.
* CAN_ELIMINATE:                         Elimination.
* canadian:                              Configure Terms.
* canonicalization of instructions:      Insn Canonicalizations.
* CANONICALIZE_COMPARISON:               Condition Code.
* canonicalize_funcptr_for_compare instruction pattern: Standard Names.
* CASE_DROPS_THROUGH:                    Misc.
* CASE_VALUES_THRESHOLD:                 Misc.
* CASE_VECTOR_MODE:                      Misc.
* CASE_VECTOR_PC_RELATIVE:               Misc.
* CASE_VECTOR_SHORTEN_MODE:              Misc.
* casesi instruction pattern:            Standard Names.
* cc0:                                   Regs and Memory.
* cc0, RTL sharing:                      Sharing.
* cc0_rtx:                               Regs and Memory.
* CC1_SPEC:                              Driver.
* CC1PLUS_SPEC:                          Driver.
* cc_status:                             Condition Code.
* CC_STATUS_MDEP:                        Condition Code.
* CC_STATUS_MDEP_INIT:                   Condition Code.
* CCmode:                                Machine Modes.
* CDImode:                               Machine Modes.
* change_address:                        Standard Names.
* CHAR_TYPE_SIZE:                        Type Layout.
* CHECK_FLOAT_VALUE:                     Storage Layout.
* check_stack instruction pattern:       Standard Names.
* CHImode:                               Machine Modes.
* class:                                 Classes.
* class definitions, register:           Register Classes.
* class preference constraints:          Class Preferences.
* CLASS_LIKELY_SPILLED_P:                Register Classes.
* CLASS_MAX_NREGS:                       Register Classes.
* CLASS_TYPE_P:                          Types.
* classes of RTX codes:                  RTL Classes.
* CLASSTYPE_DECLARED_CLASS:              Classes.
* CLASSTYPE_HAS_MUTABLE:                 Classes.
* CLASSTYPE_NON_POD_P:                   Classes.
* CLEANUP_DECL:                          Function Bodies.
* CLEANUP_EXPR:                          Function Bodies.
* CLEANUP_POINT_EXPR:                    Expression trees.
* CLEANUP_STMT:                          Function Bodies.
* CLEAR_INSN_CACHE:                      Trampolines.
* clobber:                               Side Effects.
* clrstrM instruction pattern:           Standard Names.
* cmpM instruction pattern:              Standard Names.
* cmpstrM instruction pattern:           Standard Names.
* code generation RTL sequences:         Expander Definitions.
* code motion:                           Passes.
* code_label:                            Insns.
* code_label and /i:                     Flags.
* CODE_LABEL_NUMBER:                     Insns.
* codes, RTL expression:                 RTL Objects.
* COImode:                               Machine Modes.
* COLLECT2_HOST_INITIALIZATION:          Host Config.
* COLLECT_EXPORT_LIST:                   Misc.
* combiner pass:                         Regs and Memory.
* common subexpression elimination:      Passes.
* compare:                               Arithmetic.
* compare, canonicalization of:          Insn Canonicalizations.
* compiler passes and files:             Passes.
* complement, bitwise:                   Arithmetic.
* COMPLEX_CST:                           Expression trees.
* COMPLEX_EXPR:                          Expression trees.
* COMPLEX_TYPE:                          Types.
* COMPONENT_REF:                         Expression trees.
* COMPOUND_BODY:                         Function Bodies.
* COMPOUND_EXPR:                         Expression trees.
* COMPOUND_LITERAL_EXPR:                 Expression trees.
* COMPOUND_LITERAL_EXPR_DECL:            Expression trees.
* COMPOUND_LITERAL_EXPR_DECL_STMT:       Expression trees.
* COMPOUND_STMT:                         Function Bodies.
* computing the length of an insn:       Insn Lengths.
* cond:                                  Comparisons.
* cond and attributes:                   Expressions.
* cond_exec:                             Side Effects.
* COND_EXPR:                             Expression trees.
* condition code register:               Regs and Memory.
* condition code status:                 Condition Code.
* condition codes:                       Comparisons.
* conditional constant propagation:      Passes.
* Conditional Constant Propagation, SSA based: Passes.
* conditional execution:                 Conditional Execution.
* CONDITIONAL_REGISTER_USAGE:            Register Basics.
* conditional_trap instruction pattern:  Standard Names.
* conditions, in patterns:               Patterns.
* configuration file:                    Host Config.
* configure terms:                       Configure Terms.
* CONJ_EXPR:                             Expression trees.
* const0_rtx:                            Constants.
* CONST0_RTX:                            Constants.
* CONST1_RTX:                            Constants.
* const1_rtx:                            Constants.
* const2_rtx:                            Constants.
* CONST2_RTX:                            Constants.
* CONST_COSTS:                           Costs.
* CONST_DECL:                            Declarations.
* const_double:                          Constants.
* const_double, RTL sharing:             Sharing.
* CONST_DOUBLE_CHAIN:                    Constants.
* CONST_DOUBLE_LOW:                      Constants.
* CONST_DOUBLE_MEM:                      Constants.
* CONST_DOUBLE_OK_FOR_LETTER_P:          Register Classes.
* const_int:                             Constants.
* const_int and attribute tests:         Expressions.
* const_int and attributes:              Expressions.
* const_int, RTL sharing:                Sharing.
* CONST_OK_FOR_LETTER_P:                 Register Classes.
* CONST_OR_PURE_CALL_P:                  Flags.
* const_string:                          Constants.
* const_string and attributes:           Expressions.
* const_true_rtx:                        Constants.
* const_vector:                          Constants.
* const_vector, RTL sharing:             Sharing.
* constant attributes:                   Constant Attributes.
* constant definitions:                  Constant Definitions.
* constant folding:                      Passes.
* constant folding and floating point:   Cross-compilation.
* constant propagation:                  Passes.
* CONSTANT_ADDRESS_P:                    Addressing Modes.
* CONSTANT_AFTER_FUNCTION_P:             Data Output.
* CONSTANT_ALIGNMENT:                    Storage Layout.
* CONSTANT_P:                            Addressing Modes.
* CONSTANT_POOL_ADDRESS_P:               Flags.
* CONSTANT_POOL_BEFORE_FUNCTION:         Data Output.
* constants in constraints:              Simple Constraints.
* constm1_rtx:                           Constants.
* constraint modifier characters:        Modifiers.
* constraint, matching:                  Simple Constraints.
* constraints:                           Constraints.
* constraints, machine specific:         Machine Constraints.
* constructor:                           Function Basics.
* CONSTRUCTOR:                           Expression trees.
* constructors, automatic calls:         Collect2.
* constructors, output of:               Initialization.
* container:                             Containers.
* CONTINUE_STMT:                         Function Bodies.
* contributors:                          Contributors.
* controlling register usage:            Register Basics.
* controlling the compilation driver:    Driver.
* conventions, run-time:                 Interface.
* conversions:                           Conversions.
* CONVERT_EXPR:                          Expression trees.
* copy constructor:                      Function Basics.
* copy propagation:                      Passes.
* copy_rtx:                              Addressing Modes.
* copy_rtx_if_shared:                    Sharing.
* costs of instructions:                 Costs.
* COSTS_N_INSNS:                         Costs.
* CP_INTEGRAL_TYPE:                      Types.
* cp_namespace_decls:                    Namespaces.
* CP_TYPE_CONST_NON_VOLATILE_P:          Types.
* CP_TYPE_CONST_P:                       Types.
* CP_TYPE_QUALS:                         Types.
* CP_TYPE_RESTRICT_P:                    Types.
* CP_TYPE_VOLATILE_P:                    Types.
* CPLUSPLUS_CPP_SPEC:                    Driver.
* CPP_PREDEFINES:                        Run-time Target.
* cpp_register_pragma:                   Misc.
* CPP_SPEC:                              Driver.
* CQImode:                               Machine Modes.
* cross compilation and floating point:  Cross-compilation.
* cross-jumping:                         Passes.
* CRT_CALL_STATIC_FUNCTION:              Sections.
* CRTSTUFF_T_CFLAGS:                     Target Fragment.
* CRTSTUFF_T_CFLAGS_S:                   Target Fragment.
* CSImode:                               Machine Modes.
* CTImode:                               Machine Modes.
* CUMULATIVE_ARGS:                       Register Arguments.
* current_function_epilogue_delay_list:  Function Entry.
* current_function_is_leaf:              Leaf Functions.
* current_function_outgoing_args_size:   Stack Arguments.
* current_function_pops_args:            Function Entry.
* current_function_pretend_args_size:    Function Entry.
* current_function_uses_only_leaf_regs:  Leaf Functions.
* current_insn_predicate:                Conditional Execution.
* cycle_display instruction pattern:     Standard Names.
* data flow analysis:                    Passes.
* data structures:                       Per-Function Data.
* DATA_ALIGNMENT:                        Storage Layout.
* data_section:                          Sections.
* DATA_SECTION_ASM_OP:                   Sections.
* DBR_OUTPUT_SEQEND:                     Instruction Output.
* dbr_sequence_length:                   Instruction Output.
* DBX_BLOCKS_FUNCTION_RELATIVE:          DBX Options.
* 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_FILE_END:       File Names and DBX.
* DBX_OUTPUT_MAIN_SOURCE_FILENAME:       File Names and DBX.
* DBX_OUTPUT_NFUN:                       DBX Hooks.
* 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_USE_BINCL:                         DBX Options.
* DBX_WORKING_DIRECTORY:                 File Names and DBX.
* DCE, SSA based:                        Passes.
* DCmode:                                Machine Modes.
* De Morgan's law:                       Insn Canonicalizations.
* dead code:                             Passes.
* dead code elimination:                 Passes.
* dead_or_set_p:                         define_peephole.
* DEBUG_SYMS_TEXT:                       DBX Options.
* DEBUGGER_ARG_OFFSET:                   All Debuggers.
* DEBUGGER_AUTO_OFFSET:                  All Debuggers.
* debugging information generation:      Passes.
* DECL_ALIGN:                            Declarations.
* DECL_ANTICIPATED:                      Function Basics.
* DECL_ARGUMENTS:                        Function Basics.
* DECL_ARRAY_DELETE_OPERATOR_P:          Function Basics.
* DECL_ARTIFICIAL <1>:                   Function Basics.
* DECL_ARTIFICIAL <2>:                   Declarations.
* DECL_ARTIFICIAL:                       Function Basics.
* DECL_ASSEMBLER_NAME:                   Function Basics.
* DECL_ATTRIBUTES:                       Attributes.
* DECL_BASE_CONSTRUCTOR_P:               Function Basics.
* DECL_CLASS_SCOPE_P:                    Declarations.
* DECL_COMPLETE_CONSTRUCTOR_P:           Function Basics.
* DECL_COMPLETE_DESTRUCTOR_P:            Function Basics.
* DECL_CONST_MEMFUNC_P:                  Function Basics.
* DECL_CONSTRUCTOR_P:                    Function Basics.
* DECL_CONTEXT:                          Namespaces.
* DECL_CONV_FN_P:                        Function Basics.
* DECL_COPY_CONSTRUCTOR_P:               Function Basics.
* DECL_DESTRUCTOR_P:                     Function Basics.
* DECL_EXTERN_C_FUNCTION_P:              Function Basics.
* DECL_EXTERNAL <1>:                     Function Basics.
* DECL_EXTERNAL:                         Declarations.
* DECL_FUNCTION_MEMBER_P:                Function Basics.
* DECL_FUNCTION_SCOPE_P:                 Declarations.
* DECL_GLOBAL_CTOR_P:                    Function Basics.
* DECL_GLOBAL_DTOR_P:                    Function Basics.
* DECL_INITIAL:                          Declarations.
* DECL_LINKONCE_P:                       Function Basics.
* DECL_LOCAL_FUNCTION_P:                 Function Basics.
* DECL_MAIN_P:                           Function Basics.
* DECL_NAME <1>:                         Function Basics.
* DECL_NAME <2>:                         Namespaces.
* DECL_NAME <3>:                         Function Basics.
* DECL_NAME:                             Declarations.
* DECL_NAMESPACE_ALIAS:                  Namespaces.
* DECL_NAMESPACE_SCOPE_P:                Declarations.
* DECL_NAMESPACE_STD_P:                  Namespaces.
* DECL_NON_THUNK_FUNCTION_P:             Function Basics.
* DECL_NONCONVERTING_P:                  Function Basics.
* DECL_NONSTATIC_MEMBER_FUNCTION_P:      Function Basics.
* DECL_OVERLOADED_OPERATOR_P:            Function Basics.
* DECL_RESULT:                           Function Basics.
* DECL_SIZE:                             Declarations.
* DECL_SOURCE_FILE:                      Declarations.
* DECL_SOURCE_LINE:                      Declarations.
* DECL_STATIC_FUNCTION_P:                Function Basics.
* DECL_STMT:                             Function Bodies.
* DECL_STMT_DECL:                        Function Bodies.
* DECL_THUNK_P:                          Function Basics.
* DECL_VOLATILE_MEMFUNC_P:               Function Basics.
* declaration:                           Declarations.
* declarations, RTL:                     RTL Declarations.
* decrement_and_branch_until_zero instruction pattern: Standard Names.
* DEFAULT_CALLER_SAVES:                  Caller Saves.
* DEFAULT_GDB_EXTENSIONS:                DBX Options.
* DEFAULT_MAIN_RETURN:                   Misc.
* DEFAULT_PCC_STRUCT_RETURN:             Aggregate Return.
* DEFAULT_RTX_COSTS:                     Costs.
* DEFAULT_SHORT_ENUMS:                   Type Layout.
* DEFAULT_SIGNED_CHAR:                   Type Layout.
* define_asm_attributes:                 Tagging Insns.
* define_attr:                           Defining Attributes.
* define_cond_exec:                      Conditional Execution.
* define_constants:                      Constant Definitions.
* define_delay:                          Delay Slots.
* define_expand:                         Expander Definitions.
* define_function_unit:                  Function Units.
* define_insn:                           Patterns.
* define_insn example:                   Example.
* define_insn_and_split:                 Insn Splitting.
* define_peephole:                       define_peephole.
* define_peephole2:                      define_peephole2.
* define_split:                          Insn Splitting.
* defining attributes and their values:  Defining Attributes.
* defining jump instruction patterns:    Jump Patterns.
* defining looping instruction patterns: Looping Patterns.
* defining peephole optimizers:          Peephole Definitions.
* defining RTL sequences for code generation: Expander Definitions.
* delay slots, defining:                 Delay Slots.
* DELAY_SLOTS_FOR_EPILOGUE:              Function Entry.
* delayed branch scheduling:             Passes.
* Dependent Patterns:                    Dependent Patterns.
* destructor:                            Function Basics.
* destructors, output of:                Initialization.
* DFmode:                                Machine Modes.
* digits in constraint:                  Simple Constraints.
* DImode:                                Machine Modes.
* DIR_SEPARATOR:                         Host Config.
* DIR_SEPARATOR_2:                       Host Config.
* directory options .md:                 Including Patterns.
* disabling certain registers:           Register Basics.
* dispatch table:                        Dispatch Tables.
* div:                                   Arithmetic.
* div and attributes:                    Expressions.
* DIVDI3_LIBCALL:                        Library Calls.
* division:                              Arithmetic.
* divM3 instruction pattern:             Standard Names.
* divmodM4 instruction pattern:          Standard Names.
* DIVSI3_LIBCALL:                        Library Calls.
* DO_BODY:                               Function Bodies.
* DO_COND:                               Function Bodies.
* DO_STMT:                               Function Bodies.
* DOLLARS_IN_IDENTIFIERS:                Misc.
* doloop_begin instruction pattern:      Standard Names.
* doloop_end instruction pattern:        Standard Names.
* DONE:                                  Expander Definitions.
* DONT_REDUCE_ADDR:                      Costs.
* DOUBLE_TYPE_SIZE:                      Type Layout.
* driver:                                Driver.
* DUMPFILE_FORMAT:                       Host Config.
* DWARF2_ASM_LINE_DEBUG_INFO:            SDB and DWARF.
* DWARF2_DEBUGGING_INFO:                 SDB and DWARF.
* DWARF2_FRAME_INFO:                     SDB and DWARF.
* DWARF2_GENERATE_TEXT_SECTION_LABEL:    SDB and DWARF.
* DWARF2_UNWIND_INFO:                    Exception Region Output.
* DWARF_CIE_DATA_ALIGNMENT:              Exception Region Output.
* DWARF_DEBUGGING_INFO:                  SDB and DWARF.
* DWARF_FRAME_REGISTERS:                 Frame Registers.
* DYNAMIC_CHAIN_ADDRESS:                 Frame Layout.
* E in constraint:                       Simple Constraints.
* earlyclobber operand:                  Modifiers.
* EDOM, implicit usage:                  Library Calls.
* EH_FRAME_IN_DATA_SECTION:              Exception Region Output.
* EH_FRAME_SECTION_NAME:                 Exception Region Output.
* eh_return instruction pattern:         Standard Names.
* EH_RETURN_DATA_REGNO:                  Exception Handling.
* EH_RETURN_HANDLER_RTX:                 Exception Handling.
* EH_RETURN_STACKADJ_RTX:                Exception Handling.
* EH_USES:                               Function Entry.
* ELIGIBLE_FOR_EPILOGUE_DELAY:           Function Entry.
* ELIMINABLE_REGS:                       Elimination.
* ELSE_CLAUSE:                           Function Bodies.
* EMIT_MODE_SET:                         Mode Switching.
* EMPTY_CLASS_EXPR:                      Function Bodies.
* EMPTY_FIELD_BOUNDARY:                  Storage Layout.
* ENCODE_SECTION_INFO:                   Sections.
* ENCODE_SECTION_INFO and address validation: Addressing Modes.
* ENCODE_SECTION_INFO usage:             Instruction Output.
* ENDFILE_SPEC:                          Driver.
* endianness:                            Portability.
* enum machine_mode:                     Machine Modes.
* enum reg_class:                        Register Classes.
* ENUMERAL_TYPE:                         Types.
* epilogue:                              Function Entry.
* epilogue instruction pattern:          Standard Names.
* EPILOGUE_USES:                         Function Entry.
* eq:                                    Comparisons.
* eq and attributes:                     Expressions.
* eq_attr:                               Expressions.
* EQ_EXPR:                               Expression trees.
* equal:                                 Comparisons.
* errno, implicit usage:                 Library Calls.
* escape sequences:                      Escape Sequences.
* exception handling:                    Exception Handling.
* exception_receiver instruction pattern: Standard Names.
* exclamation point:                     Multi-Alternative.
* exclusive-or, bitwise:                 Arithmetic.
* EXIT_BODY:                             Misc.
* EXIT_EXPR:                             Expression trees.
* EXIT_IGNORE_STACK:                     Function Entry.
* EXPAND_BUILTIN_SAVEREGS:               Varargs.
* expander definitions:                  Expander Definitions.
* expr_list:                             Insns.
* EXPR_STMT:                             Function Bodies.
* EXPR_STMT_EXPR:                        Function Bodies.
* expression:                            Expression trees.
* expression codes:                      RTL Objects.
* extendMN2 instruction pattern:         Standard Names.
* extensible constraints:                Simple Constraints.
* extern int target_flags:               Run-time Target.
* EXTRA_CC_MODES:                        Condition Code.
* EXTRA_CONSTRAINT:                      Register Classes.
* EXTRA_SECTION_FUNCTIONS:               Sections.
* EXTRA_SECTIONS:                        Sections.
* EXTRA_SPECS:                           Driver.
* extv instruction pattern:              Standard Names.
* extzv instruction pattern:             Standard Names.
* F in constraint:                       Simple Constraints.
* FAIL:                                  Expander Definitions.
* FATAL_EXIT_CODE:                       Host Config.
* FDL, GNU Free Documentation License:   GNU Free Documentation License.
* features, optional, in system conventions: Run-time Target.
* ffs:                                   Arithmetic.
* ffsM2 instruction pattern:             Standard Names.
* FIELD_DECL:                            Declarations.
* FILE_STMT:                             Function Bodies.
* FILE_STMT_FILENAME:                    Function Bodies.
* files and passes of the compiler:      Passes.
* final pass:                            Passes.
* FINAL_PRESCAN_INSN:                    Instruction Output.
* FINAL_PRESCAN_LABEL:                   Instruction Output.
* FINAL_REG_PARM_STACK_SPACE:            Stack Arguments.
* final_scan_insn:                       Function Entry.
* final_sequence:                        Instruction Output.
* FINALIZE_PIC:                          PIC.
* FIND_BASE_TERM:                        Addressing Modes.
* FINI_SECTION_ASM_OP:                   Sections.
* FIRST_INSN_ADDRESS:                    Insn Lengths.
* FIRST_PARM_OFFSET:                     Frame Layout.
* FIRST_PARM_OFFSET and virtual registers: Regs and Memory.
* FIRST_PSEUDO_REGISTER:                 Register Basics.
* FIRST_STACK_REG:                       Stack Registers.
* FIRST_VIRTUAL_REGISTER:                Regs and Memory.
* fix:                                   Conversions.
* FIX_TRUNC_EXPR:                        Expression trees.
* fix_truncMN2 instruction pattern:      Standard Names.
* fixed register:                        Register Basics.
* FIXED_REGISTERS:                       Register Basics.
* fixed_regs:                            Register Basics.
* fixMN2 instruction pattern:            Standard Names.
* FIXUNS_TRUNC_LIKE_FIX_TRUNC:           Misc.
* fixuns_truncMN2 instruction pattern:   Standard Names.
* fixunsMN2 instruction pattern:         Standard Names.
* flags in RTL expression:               Flags.
* float:                                 Conversions.
* FLOAT_EXPR:                            Expression trees.
* float_extend:                          Conversions.
* FLOAT_LIB_COMPARE_RETURNS_BOOL (MODE, COMPARISON): Library Calls.
* FLOAT_STORE_FLAG_VALUE:                Misc.
* float_truncate:                        Conversions.
* FLOAT_TYPE_SIZE:                       Type Layout.
* FLOAT_WORDS_BIG_ENDIAN:                Storage Layout.
* FLOAT_WORDS_BIG_ENDIAN, (lack of) effect on subreg: Regs and Memory.
* floating point and cross compilation:  Cross-compilation.
* Floating Point Emulation:              Target Fragment.
* floatMN2 instruction pattern:          Standard Names.
* floatunsMN2 instruction pattern:       Standard Names.
* FOR_BODY:                              Function Bodies.
* FOR_COND:                              Function Bodies.
* FOR_EXPR:                              Function Bodies.
* FOR_INIT_STMT:                         Function Bodies.
* FOR_STMT:                              Function Bodies.
* FORCE_CODE_SECTION_ALIGN:              Sections.
* FORCE_PREFERRED_STACK_BOUNDARY_IN_MAIN: Storage Layout.
* force_reg:                             Standard Names.
* frame layout:                          Frame Layout.
* FRAME_GROWS_DOWNWARD:                  Frame Layout.
* FRAME_GROWS_DOWNWARD and virtual registers: Regs and Memory.
* frame_pointer_needed:                  Function Entry.
* FRAME_POINTER_REGNUM:                  Frame Registers.
* FRAME_POINTER_REGNUM and virtual registers: Regs and Memory.
* FRAME_POINTER_REQUIRED:                Elimination.
* frame_pointer_rtx:                     Frame Registers.
* frame_related:                         Flags.
* frame_related, in insn:                Flags.
* frame_related, in mem:                 Flags.
* frame_related, in reg:                 Flags.
* frame_related, in symbol_ref:          Flags.
* free_machine_status:                   Per-Function Data.
* ftruncM2 instruction pattern:          Standard Names.
* function:                              Functions.
* function body:                         Function Bodies.
* function call conventions:             Interface.
* function entry and exit:               Function Entry.
* function units, for scheduling:        Function Units.
* function-call insns:                   Calls.
* 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_REG_LITTLE_ENDIAN:        Register Arguments.
* FUNCTION_ARG_REGNO_P:                  Register Arguments.
* FUNCTION_BOUNDARY:                     Storage Layout.
* FUNCTION_DECL:                         Functions.
* FUNCTION_INCOMING_ARG:                 Register Arguments.
* FUNCTION_MODE:                         Misc.
* FUNCTION_OK_FOR_SIBCALL:               Tail Calls.
* FUNCTION_OUTGOING_VALUE:               Scalar Return.
* FUNCTION_PROFILER:                     Profiling.
* FUNCTION_TYPE:                         Types.
* FUNCTION_VALUE:                        Scalar Return.
* FUNCTION_VALUE_REGNO_P:                Scalar Return.
* functions, leaf:                       Leaf Functions.
* fundamental type:                      Types.
* g in constraint:                       Simple Constraints.
* G in constraint:                       Simple Constraints.
* GCC and portability:                   Portability.
* GCC_DRIVER_HOST_INITIALIZATION:        Host Config.
* GCOV_TYPE_SIZE:                        Type Layout.
* ge:                                    Comparisons.
* ge and attributes:                     Expressions.
* GE_EXPR:                               Expression trees.
* GEN_ERRNO_RTX:                         Library Calls.
* gencodes:                              Passes.
* genconfig:                             Passes.
* general_operand:                       RTL Template.
* GENERAL_REGS:                          Register Classes.
* generating assembler output:           Output Statement.
* generating insns:                      RTL Template.
* genflags:                              Passes.
* 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:                         RTL Classes.
* GET_RTX_FORMAT:                        RTL Classes.
* GET_RTX_LENGTH:                        RTL Classes.
* geu:                                   Comparisons.
* geu and attributes:                    Expressions.
* global common subexpression elimination: Passes.
* global register allocation:            Passes.
* GLOBAL_INIT_PRIORITY:                  Function Basics.
* GO_IF_LEGITIMATE_ADDRESS:              Addressing Modes.
* GO_IF_MODE_DEPENDENT_ADDRESS:          Addressing Modes.
* GOTO_DESTINATION:                      Function Bodies.
* GOTO_FAKE_P:                           Function Bodies.
* GOTO_STMT:                             Function Bodies.
* greater than:                          Comparisons.
* gt:                                    Comparisons.
* gt and attributes:                     Expressions.
* GT_EXPR:                               Expression trees.
* gtu:                                   Comparisons.
* gtu and attributes:                    Expressions.
* H in constraint:                       Simple Constraints.
* HANDLE_PRAGMA:                         Misc.
* HANDLE_PRAGMA_PACK_PUSH_POP:           Misc.
* HANDLE_SYSV_PRAGMA:                    Misc.
* HANDLER:                               Function Bodies.
* HANDLER_BODY:                          Function Bodies.
* HANDLER_PARMS:                         Function Bodies.
* hard registers:                        Regs and Memory.
* HARD_FRAME_POINTER_REGNUM:             Frame Registers.
* HARD_REGNO_CALL_PART_CLOBBERED:        Register Basics.
* HARD_REGNO_CALLER_SAVE_MODE:           Caller Saves.
* HARD_REGNO_MODE_OK:                    Values in Registers.
* HARD_REGNO_NREGS:                      Values in Registers.
* HAS_INIT_SECTION:                      Macros for Initialization.
* HAVE_DOS_BASED_FILE_SYSTEM:            Host Config.
* HAVE_POST_DECREMENT:                   Addressing Modes.
* HAVE_POST_INCREMENT:                   Addressing Modes.
* HAVE_POST_MODIFY_DISP:                 Addressing Modes.
* HAVE_POST_MODIFY_REG:                  Addressing Modes.
* HAVE_PRE_DECREMENT:                    Addressing Modes.
* HAVE_PRE_INCREMENT:                    Addressing Modes.
* HAVE_PRE_MODIFY_DISP:                  Addressing Modes.
* HAVE_PRE_MODIFY_REG:                   Addressing Modes.
* HCmode:                                Machine Modes.
* HFmode:                                Machine Modes.
* high:                                  Constants.
* HImode:                                Machine Modes.
* HImode, in insn:                       Insns.
* host makefile fragment:                Host Fragment.
* HOST_BIT_BUCKET:                       Host Config.
* HOST_EXECUTABLE_SUFFIX:                Host Config.
* HOST_OBJECT_SUFFIX:                    Host Config.
* i in constraint:                       Simple Constraints.
* I in constraint:                       Simple Constraints.
* IBM_FLOAT_FORMAT:                      Storage Layout.
* identifier:                            Identifiers.
* IDENTIFIER_LENGTH:                     Identifiers.
* IDENTIFIER_NODE:                       Identifiers.
* IDENTIFIER_OPNAME_P:                   Identifiers.
* IDENTIFIER_POINTER:                    Identifiers.
* IDENTIFIER_TYPENAME_P:                 Identifiers.
* IEEE_FLOAT_FORMAT:                     Storage Layout.
* if conversion:                         Passes.
* IF_COND:                               Function Bodies.
* IF_STMT:                               Function Bodies.
* if_then_else:                          Comparisons.
* if_then_else and attributes:           Expressions.
* if_then_else usage:                    Side Effects.
* IFCVT_MODIFY_CANCEL:                   Misc.
* IFCVT_MODIFY_FINAL:                    Misc.
* IFCVT_MODIFY_INSN:                     Misc.
* IFCVT_MODIFY_TESTS:                    Misc.
* IMAGPART_EXPR:                         Expression trees.
* immediate_operand:                     RTL Template.
* IMMEDIATE_PREFIX:                      Instruction Output.
* in_data:                               Sections.
* in_struct:                             Flags.
* in_struct, in code_label:              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.
* in_text:                               Sections.
* include:                               Including Patterns.
* INCLUDE_DEFAULTS:                      Driver.
* inclusive-or, bitwise:                 Arithmetic.
* INCOMING_FRAME_SP_OFFSET:              Frame Layout.
* INCOMING_REGNO:                        Register Basics.
* INCOMING_RETURN_ADDR_RTX:              Frame Layout.
* INDEX_REG_CLASS:                       Register Classes.
* indirect_jump instruction pattern:     Standard Names.
* INDIRECT_REF:                          Expression trees.
* INIT_CUMULATIVE_ARGS:                  Register Arguments.
* INIT_CUMULATIVE_INCOMING_ARGS:         Register Arguments.
* INIT_CUMULATIVE_LIBCALL_ARGS:          Register Arguments.
* INIT_ENVIRONMENT:                      Driver.
* INIT_EXPANDERS:                        Per-Function Data.
* INIT_EXPR:                             Expression trees.
* init_machine_status:                   Per-Function Data.
* INIT_SECTION_ASM_OP <1>:               Macros for Initialization.
* INIT_SECTION_ASM_OP:                   Sections.
* INIT_TARGET_OPTABS:                    Library Calls.
* INITIAL_ELIMINATION_OFFSET:            Elimination.
* INITIAL_FRAME_POINTER_OFFSET:          Elimination.
* initialization routines:               Initialization.
* INITIALIZE_TRAMPOLINE:                 Trampolines.
* inline on rtx, automatic:              Passes.
* inline on trees, automatic:            Passes.
* inlining:                              Target Attributes.
* insn:                                  Insns.
* insn and /f:                           Flags.
* insn and /i:                           Flags.
* insn and /j:                           Flags.
* insn and /s:                           Flags.
* insn and /u:                           Flags.
* insn and /v:                           Flags.
* insn attributes:                       Insn Attributes.
* insn canonicalization:                 Insn Canonicalizations.
* insn includes:                         Including Patterns.
* insn lengths, computing:               Insn Lengths.
* insn splitting:                        Insn Splitting.
* insn-attr.h:                           Defining Attributes.
* INSN_ANNULLED_BRANCH_P:                Flags.
* INSN_CACHE_DEPTH:                      Trampolines.
* INSN_CACHE_LINE_WIDTH:                 Trampolines.
* INSN_CACHE_SIZE:                       Trampolines.
* INSN_CODE:                             Insns.
* INSN_DEAD_CODE_P:                      Flags.
* INSN_DELETED_P:                        Flags.
* INSN_FROM_TARGET_P:                    Flags.
* insn_list:                             Insns.
* insn_list and /c:                      Flags.
* insn_list and /j:                      Flags.
* INSN_REFERENCES_ARE_DELAYED:           Misc.
* INSN_SETS_ARE_DELAYED:                 Misc.
* INSN_UID:                              Insns.
* insns:                                 Insns.
* insns, generating:                     RTL Template.
* insns, recognizing:                    RTL Template.
* instruction attributes:                Insn Attributes.
* instruction combination:               Passes.
* instruction patterns:                  Patterns.
* instruction recognizer:                Passes.
* instruction scheduling:                Passes.
* instruction splitting:                 Insn Splitting.
* insv instruction pattern:              Standard Names.
* INT_TYPE_SIZE:                         Type Layout.
* INTEGER_CST:                           Expression trees.
* INTEGER_TYPE:                          Types.
* INTEGRATE_THRESHOLD:                   Misc.
* integrated:                            Flags.
* integrated, in insn:                   Flags.
* integrated, in reg:                    Flags.
* integrated, in symbol_ref:             Flags.
* INTEL_EXTENDED_IEEE_FORMAT:            Type Layout.
* Interdependence of Patterns:           Dependent Patterns.
* interfacing to GCC output:             Interface.
* INTMAX_TYPE:                           Type Layout.
* introduction:                          Top.
* INVOKE__main:                          Macros for Initialization.
* ior:                                   Arithmetic.
* ior and attributes:                    Expressions.
* ior, canonicalization of:              Insn Canonicalizations.
* iorM3 instruction pattern:             Standard Names.
* IS_ASM_LOGICAL_LINE_SEPARATOR:         Data Output.
* isinf:                                 Cross-compilation.
* isnan:                                 Cross-compilation.
* jump:                                  Flags.
* jump instruction pattern:              Standard Names.
* jump instruction patterns:             Jump Patterns.
* jump instructions and set:             Side Effects.
* jump optimization:                     Passes.
* jump threading:                        Passes.
* jump, in call_insn:                    Flags.
* jump, in insn:                         Flags.
* jump, in insn_list:                    Flags.
* jump, in mem:                          Flags.
* JUMP_ALIGN:                            Alignment Output.
* jump_insn:                             Insns.
* JUMP_LABEL:                            Insns.
* JUMP_TABLES_IN_TEXT_SECTION:           Sections.
* LABEL_ALIGN:                           Alignment Output.
* LABEL_ALIGN_AFTER_BARRIER:             Alignment Output.
* LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP:    Alignment Output.
* LABEL_ALIGN_MAX_SKIP:                  Alignment Output.
* LABEL_ALTERNATE_NAME:                  Insns.
* LABEL_DECL:                            Declarations.
* LABEL_NUSES:                           Insns.
* LABEL_OUTSIDE_LOOP_P:                  Flags.
* LABEL_PRESERVE_P:                      Flags.
* label_ref:                             Constants.
* label_ref and /s:                      Flags.
* label_ref and /v:                      Flags.
* label_ref, RTL sharing:                Sharing.
* LABEL_REF_NONLOCAL_P:                  Flags.
* LABEL_STMT:                            Function Bodies.
* LABEL_STMT_LABEL:                      Function Bodies.
* large return values:                   Aggregate Return.
* LAST_STACK_REG:                        Stack Registers.
* LAST_VIRTUAL_REGISTER:                 Regs and Memory.
* LD_FINI_SWITCH:                        Macros for Initialization.
* LD_INIT_SWITCH:                        Macros for Initialization.
* LDD_SUFFIX:                            Macros for Initialization.
* ldexp:                                 Cross-compilation.
* le:                                    Comparisons.
* le and attributes:                     Expressions.
* LE_EXPR:                               Expression trees.
* leaf functions:                        Leaf Functions.
* leaf_function_p:                       Standard Names.
* LEAF_REG_REMAP:                        Leaf Functions.
* LEAF_REGISTERS:                        Leaf Functions.
* left rotate:                           Arithmetic.
* left shift:                            Arithmetic.
* LEGITIMATE_CONSTANT_P:                 Addressing Modes.
* LEGITIMATE_PIC_OPERAND_P:              PIC.
* LEGITIMIZE_ADDRESS:                    Addressing Modes.
* LEGITIMIZE_RELOAD_ADDRESS:             Addressing Modes.
* less than:                             Comparisons.
* less than or equal:                    Comparisons.
* leu:                                   Comparisons.
* leu and attributes:                    Expressions.
* LIB2FUNCS_EXTRA:                       Target Fragment.
* LIB_SPEC:                              Driver.
* LIBCALL_VALUE:                         Scalar Return.
* libgcc.a:                              Library Calls.
* LIBGCC2_CFLAGS:                        Target Fragment.
* LIBGCC2_WORDS_BIG_ENDIAN:              Storage Layout.
* LIBGCC_NEEDS_DOUBLE:                   Library Calls.
* LIBGCC_SPEC:                           Driver.
* library subroutine names:              Library Calls.
* LIBRARY_PATH_ENV:                      Misc.
* LIMIT_RELOAD_CLASS:                    Register Classes.
* LINK_COMMAND_SPEC:                     Driver.
* LINK_COST_FREE:                        Flags.
* LINK_COST_ZERO:                        Flags.
* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES: Driver.
* LINK_GCC_C_SEQUENCE_SPEC:              Driver.
* LINK_LIBGCC_SPECIAL:                   Driver.
* LINK_LIBGCC_SPECIAL_1:                 Driver.
* LINK_SPEC:                             Driver.
* linkage:                               Function Basics.
* LINKER_DOES_NOT_WORK_WITH_DWARF2:      SDB and DWARF.
* list:                                  Containers.
* lo_sum:                                Arithmetic.
* load address instruction:              Simple Constraints.
* LOAD_ARGS_REVERSED:                    Register Arguments.
* LOAD_EXTEND_OP:                        Misc.
* load_multiple instruction pattern:     Standard Names.
* local register allocation:             Passes.
* LOCAL_ALIGNMENT:                       Storage Layout.
* LOCAL_CLASS_P:                         Classes.
* LOCAL_INCLUDE_DIR:                     Driver.
* LOCAL_LABEL_PREFIX:                    Instruction Output.
* LOCAL_REGNO:                           Register Basics.
* LOG_LINKS:                             Insns.
* logical-and, bitwise:                  Arithmetic.
* LONG_DOUBLE_TYPE_SIZE:                 Type Layout.
* LONG_LONG_TYPE_SIZE:                   Type Layout.
* LONG_TYPE_SIZE:                        Type Layout.
* longjmp and automatic variables:       Interface.
* loop optimization:                     Passes.
* LOOP_ALIGN:                            Alignment Output.
* LOOP_ALIGN_MAX_SKIP:                   Alignment Output.
* LOOP_EXPR:                             Expression trees.
* looping instruction patterns:          Looping Patterns.
* LSHIFT_EXPR:                           Expression trees.
* lshiftrt:                              Arithmetic.
* lshiftrt and attributes:               Expressions.
* lshrM3 instruction pattern:            Standard Names.
* lt:                                    Comparisons.
* lt and attributes:                     Expressions.
* LT_EXPR:                               Expression trees.
* ltu:                                   Comparisons.
* m in constraint:                       Simple Constraints.
* machine attributes:                    Target Attributes.
* machine description macros:            Target Macros.
* machine descriptions:                  Machine Desc.
* machine mode conversions:              Conversions.
* machine modes:                         Machine Modes.
* machine specific constraints:          Machine Constraints.
* MACHINE_DEPENDENT_REORG:               Misc.
* macros, target description:            Target Macros.
* MAKE_DECL_ONE_ONLY (DECL):             Label Output.
* make_safe_from:                        Expander Definitions.
* makefile fragment:                     Fragments.
* makefile targets:                      Makefile.
* mark_machine_status:                   Per-Function Data.
* MASK_RETURN_ADDR:                      Exception Region Output.
* match_dup <1>:                         RTL Template.
* match_dup:                             define_peephole2.
* match_dup and attributes:              Insn Lengths.
* match_insn:                            RTL Template.
* match_insn2:                           RTL Template.
* match_op_dup:                          RTL Template.
* match_operand:                         RTL Template.
* match_operand and attributes:          Expressions.
* match_operator:                        RTL Template.
* match_par_dup:                         RTL Template.
* match_parallel:                        RTL Template.
* match_scratch <1>:                     define_peephole2.
* match_scratch:                         RTL Template.
* matching constraint:                   Simple Constraints.
* matching operands:                     Output Template.
* math libraries:                        Interface.
* math, in RTL:                          Arithmetic.
* MATH_LIBRARY:                          Misc.
* MAX_BITS_PER_WORD:                     Storage Layout.
* MAX_CHAR_TYPE_SIZE:                    Type Layout.
* MAX_CONDITIONAL_EXECUTE:               Misc.
* MAX_FIXED_MODE_SIZE:                   Storage Layout.
* MAX_INTEGER_COMPUTATION_MODE:          Misc.
* MAX_LONG_DOUBLE_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_WCHAR_TYPE_SIZE:                   Type Layout.
* maxM3 instruction pattern:             Standard Names.
* MAYBE_REG_PARM_STACK_SPACE:            Stack Arguments.
* mcount:                                Profiling.
* MD_ASM_CLOBBERS:                       Misc.
* MD_CAN_REDIRECT_BRANCH:                Misc.
* MD_EXEC_PREFIX:                        Driver.
* MD_FALLBACK_FRAME_STATE_FOR:           Exception Handling.
* MD_STARTFILE_PREFIX:                   Driver.
* MD_STARTFILE_PREFIX_1:                 Driver.
* mem:                                   Regs and Memory.
* mem and /f:                            Flags.
* mem and /j:                            Flags.
* mem and /s:                            Flags.
* mem and /u:                            Flags.
* mem and /v:                            Flags.
* mem, RTL sharing:                      Sharing.
* MEM_IN_STRUCT_P:                       Flags.
* MEM_KEEP_ALIAS_SET_P:                  Flags.
* MEM_SCALAR_P:                          Flags.
* MEM_VOLATILE_P:                        Flags.
* MEMBER_TYPE_FORCES_BLK:                Storage Layout.
* memcpy, implicit usage:                Library Calls.
* memmove, implicit usage:               Library Calls.
* memory reference, nonoffsettable:      Simple Constraints.
* memory references in constraints:      Simple Constraints.
* MEMORY_MOVE_COST:                      Costs.
* memset, implicit usage:                Library Calls.
* METHOD_TYPE:                           Types.
* MIN_UNITS_PER_WORD:                    Storage Layout.
* MINIMUM_ATOMIC_ALIGNMENT:              Storage Layout.
* minM3 instruction pattern:             Standard Names.
* minus:                                 Arithmetic.
* minus and attributes:                  Expressions.
* minus, canonicalization of:            Insn Canonicalizations.
* MINUS_EXPR:                            Expression trees.
* mod:                                   Arithmetic.
* mod and attributes:                    Expressions.
* MODDI3_LIBCALL:                        Library Calls.
* mode classes:                          Machine Modes.
* mode switching:                        Mode Switching.
* MODE_BASE_REG_CLASS:                   Register Classes.
* 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_NEEDED:                           Mode Switching.
* MODE_PARTIAL_INT:                      Machine Modes.
* MODE_PRIORITY_TO_MODE:                 Mode Switching.
* MODE_RANDOM:                           Machine Modes.
* MODES_TIEABLE_P:                       Values in Registers.
* modifiers in constraints:              Modifiers.
* MODIFY_EXPR:                           Expression trees.
* MODIFY_TARGET_NAME:                    Driver.
* modM3 instruction pattern:             Standard Names.
* MODSI3_LIBCALL:                        Library Calls.
* MOVE_BY_PIECES_P:                      Costs.
* MOVE_MAX:                              Misc.
* MOVE_MAX_PIECES:                       Costs.
* MOVE_RATIO:                            Costs.
* movM instruction pattern:              Standard Names.
* movMODEcc instruction pattern:         Standard Names.
* movstrictM instruction pattern:        Standard Names.
* movstrM instruction pattern:           Standard Names.
* MULDI3_LIBCALL:                        Library Calls.
* mulhisi3 instruction pattern:          Standard Names.
* mulM3 instruction pattern:             Standard Names.
* mulqihi3 instruction pattern:          Standard Names.
* MULSI3_LIBCALL:                        Library Calls.
* mulsidi3 instruction pattern:          Standard Names.
* mult:                                  Arithmetic.
* mult and attributes:                   Expressions.
* mult, canonicalization of:             Insn Canonicalizations.
* MULT_EXPR:                             Expression trees.
* MULTILIB_DEFAULTS:                     Driver.
* MULTILIB_DIRNAMES:                     Target Fragment.
* MULTILIB_EXCEPTIONS:                   Target Fragment.
* MULTILIB_EXTRA_OPTS:                   Target Fragment.
* MULTILIB_MATCHES:                      Target Fragment.
* MULTILIB_OPTIONS:                      Target Fragment.
* multiple alternative constraints:      Multi-Alternative.
* MULTIPLE_SYMBOL_SPACES:                Misc.
* multiplication:                        Arithmetic.
* MUST_PASS_IN_STACK:                    Register Arguments.
* MUST_PASS_IN_STACK, and FUNCTION_ARG:  Register Arguments.
* n in constraint:                       Simple Constraints.
* N_REG_CLASSES:                         Register Classes.
* name:                                  Identifiers.
* named patterns and conditions:         Patterns.
* names, pattern:                        Standard Names.
* namespace:                             Namespaces.
* namespace, class, scope:               Scopes.
* NAMESPACE_DECL <1>:                    Namespaces.
* NAMESPACE_DECL:                        Declarations.
* ne:                                    Comparisons.
* ne and attributes:                     Expressions.
* NE_EXPR:                               Expression trees.
* NEED_ATEXIT:                           Misc.
* neg:                                   Arithmetic.
* neg and attributes:                    Expressions.
* neg, canonicalization of:              Insn Canonicalizations.
* NEGATE_EXPR:                           Expression trees.
* negM2 instruction pattern:             Standard Names.
* nested functions, trampolines for:     Trampolines.
* next_cc0_user:                         Jump Patterns.
* NEXT_INSN:                             Insns.
* NEXT_OBJC_RUNTIME:                     Library Calls.
* nil:                                   RTL Objects.
* no-op move instructions:               Passes.
* NO_BUILTIN_PTRDIFF_TYPE:               Driver.
* NO_BUILTIN_SIZE_TYPE:                  Driver.
* NO_BUILTIN_WCHAR_TYPE:                 Driver.
* NO_BUILTIN_WINT_TYPE:                  Driver.
* NO_DBX_FUNCTION_END:                   DBX Hooks.
* NO_DOLLAR_IN_LABEL:                    Misc.
* NO_DOT_IN_LABEL:                       Misc.
* NO_FUNCTION_CSE:                       Costs.
* NO_IMPLICIT_EXTERN_C:                  Misc.
* no_new_pseudos:                        Standard Names.
* NO_PROFILE_COUNTERS:                   Profiling.
* NO_RECURSIVE_FUNCTION_CSE:             Costs.
* NO_REGS:                               Register Classes.
* NON_SAVING_SETJMP:                     Register Basics.
* nonlocal_goto instruction pattern:     Standard Names.
* nonlocal_goto_receiver instruction pattern: Standard Names.
* nonoffsettable memory reference:       Simple Constraints.
* nop instruction pattern:               Standard Names.
* NOP_EXPR:                              Expression trees.
* NORMAL_MODE:                           Mode Switching.
* not:                                   Arithmetic.
* not and attributes:                    Expressions.
* not equal:                             Comparisons.
* not, canonicalization of:              Insn Canonicalizations.
* note:                                  Insns.
* NOTE_INSN_BLOCK_BEG:                   Insns.
* NOTE_INSN_BLOCK_END:                   Insns.
* NOTE_INSN_DELETED:                     Insns.
* NOTE_INSN_DELETED_LABEL:               Insns.
* NOTE_INSN_EH_REGION_BEG:               Insns.
* NOTE_INSN_EH_REGION_END:               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.
* NUM_MACHINE_MODES:                     Machine Modes.
* NUM_MODES_FOR_MODE_SWITCHING:          Mode Switching.
* o in constraint:                       Simple Constraints.
* OBJC_GEN_METHOD_LABEL:                 Label Output.
* OBJC_PROLOGUE:                         File Framework.
* OBJECT_FORMAT_COFF:                    Macros for Initialization.
* OBJECT_FORMAT_ROSE:                    Macros for Initialization.
* OFFSET_TYPE:                           Types.
* offsettable address:                   Simple Constraints.
* OImode:                                Machine Modes.
* ON_EXIT:                               Misc.
* one_cmplM2 instruction pattern:        Standard Names.
* operand access:                        Accessors.
* operand constraints:                   Constraints.
* operand substitution:                  Output Template.
* operands:                              Patterns.
* OPTIMIZATION_OPTIONS:                  Run-time Target.
* OPTIMIZE_MODE_SWITCHING:               Mode Switching.
* optional hardware or system features:  Run-time Target.
* options, directory search:             Including Patterns.
* order of register allocation:          Allocation Order.
* ORDER_REGS_FOR_LOCAL_ALLOC:            Allocation Order.
* Ordering of Patterns:                  Pattern Ordering.
* other register constraints:            Simple Constraints.
* OUTGOING_REG_PARM_STACK_SPACE:         Stack Arguments.
* OUTGOING_REGNO:                        Register Basics.
* output of assembler code:              File Framework.
* output statements:                     Output Statement.
* output templates:                      Output Template.
* OUTPUT_ADDR_CONST_EXTRA:               Data Output.
* output_asm_insn:                       Output Statement.
* OUTPUT_QUOTED_STRING:                  File Framework.
* overflow while constant folding:       Cross-compilation.
* OVERLOAD:                              Functions.
* OVERRIDE_OPTIONS:                      Run-time Target.
* OVL_CURRENT:                           Functions.
* OVL_NEXT:                              Functions.
* p in constraint:                       Simple Constraints.
* PAD_VARARGS_DOWN:                      Register Arguments.
* parallel:                              Side Effects.
* parameters, miscellaneous:             Misc.
* PARM_BOUNDARY:                         Storage Layout.
* PARM_DECL:                             Declarations.
* PARSE_LDD_OUTPUT:                      Macros for Initialization.
* parsing pass:                          Passes.
* passes and files of the compiler:      Passes.
* passing arguments:                     Interface.
* PATH_SEPARATOR:                        Host Config.
* PATTERN:                               Insns.
* pattern conditions:                    Patterns.
* pattern names:                         Standard Names.
* Pattern Ordering:                      Pattern Ordering.
* patterns:                              Patterns.
* pc:                                    Regs and Memory.
* pc and attributes:                     Insn Lengths.
* pc, RTL sharing:                       Sharing.
* pc_rtx:                                Regs and Memory.
* PCC_BITFIELD_TYPE_MATTERS:             Storage Layout.
* PCC_STATIC_STRUCT_RETURN:              Aggregate Return.
* PDImode:                               Machine Modes.
* peephole optimization:                 Passes.
* peephole optimization, RTL representation: Side Effects.
* peephole optimizer definitions:        Peephole Definitions.
* per-function data:                     Per-Function Data.
* percent sign:                          Output Template.
* PIC:                                   PIC.
* PIC_OFFSET_TABLE_REG_CALL_CLOBBERED:   PIC.
* PIC_OFFSET_TABLE_REGNUM:               PIC.
* plus:                                  Arithmetic.
* plus and attributes:                   Expressions.
* plus, canonicalization of:             Insn Canonicalizations.
* PLUS_EXPR:                             Expression trees.
* Pmode:                                 Misc.
* pointer:                               Types.
* POINTER_SIZE:                          Storage Layout.
* POINTER_TYPE:                          Types.
* POINTERS_EXTEND_UNSIGNED:              Storage Layout.
* portability:                           Portability.
* position independent code:             PIC.
* post_dec:                              Incdec.
* post_inc:                              Incdec.
* post_modify:                           Incdec.
* pragma:                                Misc.
* pre_dec:                               Incdec.
* PRE_GCC3_DWARF_FRAME_REGISTERS:        Frame Registers.
* pre_inc:                               Incdec.
* predefined macros:                     Run-time Target.
* PREDICATE_CODES:                       Misc.
* predication:                           Conditional Execution.
* PREFERRED_DEBUGGING_TYPE:              All Debuggers.
* PREFERRED_OUTPUT_RELOAD_CLASS:         Register Classes.
* PREFERRED_RELOAD_CLASS:                Register Classes.
* PREFERRED_STACK_BOUNDARY:              Storage Layout.
* prefetch:                              Side Effects.
* prefetch instruction pattern:          Standard Names.
* PRETEND_OUTGOING_VARARGS_NAMED:        Varargs.
* prev_active_insn:                      define_peephole.
* prev_cc0_setter:                       Jump Patterns.
* PREV_INSN:                             Insns.
* PRINT_OPERAND:                         Instruction Output.
* PRINT_OPERAND_ADDRESS:                 Instruction Output.
* PRINT_OPERAND_PUNCT_VALID_P:           Instruction Output.
* probe instruction pattern:             Standard Names.
* product:                               Arithmetic.
* PROFILE_BEFORE_PROLOGUE:               Profiling.
* PROFILE_HOOK:                          Profiling.
* profiling, code generation:            Profiling.
* program counter:                       Regs and Memory.
* prologue:                              Function Entry.
* prologue instruction pattern:          Standard Names.
* PROMOTE_FOR_CALL_ONLY:                 Storage Layout.
* PROMOTE_FUNCTION_ARGS:                 Storage Layout.
* PROMOTE_FUNCTION_RETURN:               Storage Layout.
* PROMOTE_MODE:                          Storage Layout.
* PROMOTE_PROTOTYPES:                    Stack Arguments.
* pseudo registers:                      Regs and Memory.
* PSImode:                               Machine Modes.
* PTRDIFF_TYPE:                          Type Layout.
* PTRMEM_CST:                            Expression trees.
* PTRMEM_CST_CLASS:                      Expression trees.
* PTRMEM_CST_MEMBER:                     Expression trees.
* push address instruction:              Simple Constraints.
* PUSH_ARGS:                             Stack Arguments.
* push_reload:                           Addressing Modes.
* PUSH_ROUNDING:                         Stack Arguments.
* PUSH_ROUNDING, interaction with PREFERRED_STACK_BOUNDARY: Storage Layout.
* pushM instruction pattern:             Standard Names.
* PUT_CODE:                              RTL Objects.
* PUT_MODE:                              Machine Modes.
* PUT_REG_NOTE_KIND:                     Insns.
* PUT_SDB_...:                           SDB and DWARF.
* QCmode:                                Machine Modes.
* QFmode:                                Machine Modes.
* QImode:                                Machine Modes.
* QImode, in insn:                       Insns.
* qualified type:                        Types.
* question mark:                         Multi-Alternative.
* quotient:                              Arithmetic.
* r in constraint:                       Simple Constraints.
* RDIV_EXPR:                             Expression trees.
* READONLY_DATA_SECTION:                 Sections.
* REAL_ARITHMETIC:                       Cross-compilation.
* REAL_CST:                              Expression trees.
* REAL_INFINITY:                         Cross-compilation.
* REAL_NM_FILE_NAME:                     Macros for Initialization.
* REAL_TYPE:                             Types.
* 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.
* REAL_VALUES_EQUAL:                     Cross-compilation.
* REAL_VALUES_LESS:                      Cross-compilation.
* REALPART_EXPR:                         Expression trees.
* recog_data.operand:                    Instruction Output.
* recognizing insns:                     RTL Template.
* RECORD_TYPE <1>:                       Classes.
* RECORD_TYPE:                           Types.
* reference:                             Types.
* REFERENCE_TYPE:                        Types.
* reg:                                   Regs and Memory.
* reg and /f:                            Flags.
* reg and /i:                            Flags.
* reg and /s:                            Flags.
* reg and /u:                            Flags.
* reg and /v:                            Flags.
* reg, RTL sharing:                      Sharing.
* REG_ALLOC_ORDER:                       Allocation Order.
* REG_BR_PRED:                           Insns.
* REG_BR_PROB:                           Insns.
* 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_EXEC_COUNT:                        Insns.
* REG_FRAME_RELATED_EXPR:                Insns.
* REG_FUNCTION_VALUE_P:                  Flags.
* REG_INC:                               Insns.
* REG_LABEL:                             Insns.
* REG_LIBCALL:                           Insns.
* REG_LOOP_TEST_P:                       Flags.
* REG_MODE_OK_FOR_BASE_P:                Addressing Modes.
* reg_names:                             Instruction Output.
* REG_NO_CONFLICT:                       Insns.
* REG_NONNEG:                            Insns.
* REG_NOTE_KIND:                         Insns.
* REG_NOTES:                             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_PARM_STACK_SPACE, and FUNCTION_ARG: Register Arguments.
* REG_POINTER:                           Flags.
* REG_RETVAL:                            Insns.
* REG_UNUSED:                            Insns.
* REG_USERVAR_P:                         Flags.
* REG_WAS_0:                             Insns.
* register allocation:                   Passes.
* register allocation order:             Allocation Order.
* register class definitions:            Register Classes.
* register class preference constraints: Class Preferences.
* register class preference pass:        Passes.
* register movement:                     Passes.
* register pairs:                        Values in Registers.
* Register Transfer Language (RTL):      RTL.
* register usage:                        Registers.
* register use analysis:                 Passes.
* register-to-stack conversion:          Passes.
* REGISTER_MOVE_COST:                    Costs.
* REGISTER_NAMES:                        Instruction Output.
* register_operand:                      RTL Template.
* REGISTER_PREFIX:                       Instruction Output.
* REGISTER_TARGET_PRAGMAS:               Misc.
* registers arguments:                   Register Arguments.
* registers in constraints:              Simple Constraints.
* REGNO_MODE_OK_FOR_BASE_P:              Register Classes.
* REGNO_OK_FOR_BASE_P:                   Register Classes.
* REGNO_OK_FOR_INDEX_P:                  Register Classes.
* REGNO_REG_CLASS:                       Register Classes.
* regs_ever_live:                        Function Entry.
* relative costs:                        Costs.
* RELATIVE_PREFIX_NOT_LINKDIR:           Driver.
* reload pass:                           Regs and Memory.
* reload_completed:                      Standard Names.
* reload_in instruction pattern:         Standard Names.
* reload_in_progress:                    Standard Names.
* reload_out instruction pattern:        Standard Names.
* reloading:                             Passes.
* remainder:                             Arithmetic.
* reordering, block:                     Passes.
* representation of RTL:                 RTL.
* rest_of_compilation:                   Passes.
* rest_of_decl_compilation:              Passes.
* restore_stack_block instruction pattern: Standard Names.
* restore_stack_function instruction pattern: Standard Names.
* restore_stack_nonlocal instruction pattern: Standard Names.
* RESULT_DECL:                           Declarations.
* return:                                Side Effects.
* return instruction pattern:            Standard Names.
* return values in registers:            Scalar Return.
* RETURN_ADDR_IN_PREVIOUS_FRAME:         Frame Layout.
* RETURN_ADDR_RTX:                       Frame Layout.
* RETURN_ADDRESS_POINTER_REGNUM:         Frame Registers.
* RETURN_EXPR:                           Function Bodies.
* RETURN_IN_MEMORY:                      Aggregate Return.
* RETURN_INIT:                           Function Bodies.
* RETURN_POPS_ARGS:                      Stack Arguments.
* RETURN_STMT:                           Function Bodies.
* returning aggregate values:            Aggregate Return.
* returning structures and unions:       Interface.
* REVERSE_CONDEXEC_PREDICATES_P:         Condition Code.
* REVERSE_CONDITION (CODE, MODE):        Condition Code.
* REVERSIBLE_CC_MODE:                    Condition Code.
* right rotate:                          Arithmetic.
* right shift:                           Arithmetic.
* rotate:                                Arithmetic.
* rotatert:                              Arithmetic.
* rotlM3 instruction pattern:            Standard Names.
* rotrM3 instruction pattern:            Standard Names.
* ROUND_TYPE_ALIGN:                      Storage Layout.
* ROUND_TYPE_SIZE:                       Storage Layout.
* ROUND_TYPE_SIZE_UNIT:                  Storage Layout.
* RSHIFT_EXPR:                           Expression trees.
* RTL addition:                          Arithmetic.
* RTL addition with signed saturation:   Arithmetic.
* RTL addition with unsigned saturation: Arithmetic.
* RTL classes:                           RTL Classes.
* 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:                            RTL Classes.
* RTL format characters:                 RTL Classes.
* 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 codes, classes of:                 RTL Classes.
* RTX_COSTS:                             Costs.
* RTX_FRAME_RELATED_P:                   Flags.
* RTX_INTEGRATED_P:                      Flags.
* RTX_UNCHANGING_P:                      Flags.
* run-time conventions:                  Interface.
* run-time target specification:         Run-time Target.
* s in constraint:                       Simple Constraints.
* same_type_p:                           Types.
* save_stack_block instruction pattern:  Standard Names.
* save_stack_function instruction pattern: Standard Names.
* save_stack_nonlocal instruction pattern: Standard Names.
* saveable_obstack:                      Addressing Modes.
* scalars, returned as values:           Scalar Return.
* SCCS_DIRECTIVE:                        Misc.
* SCHED_GROUP_P:                         Flags.
* scheduling, delayed branch:            Passes.
* scheduling, instruction:               Passes.
* SCmode:                                Machine Modes.
* sCOND instruction pattern:             Standard Names.
* SCOPE_BEGIN_P:                         Function Bodies.
* SCOPE_END_P:                           Function Bodies.
* SCOPE_NULLIFIED_P:                     Function Bodies.
* SCOPE_STMT:                            Function Bodies.
* scratch:                               Regs and Memory.
* scratch operands:                      Regs and Memory.
* scratch, RTL sharing:                  Sharing.
* 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 options:                        Including Patterns.
* SECONDARY_INPUT_RELOAD_CLASS:          Register Classes.
* SECONDARY_MEMORY_NEEDED:               Register Classes.
* SECONDARY_MEMORY_NEEDED_MODE:          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.
* sequence:                              Side Effects.
* set:                                   Side Effects.
* SET_ASM_OP:                            Label Output.
* set_attr:                              Tagging Insns.
* set_attr_alternative:                  Tagging Insns.
* SET_DEST:                              Side Effects.
* SET_IS_RETURN_P:                       Flags.
* SET_SRC:                               Side Effects.
* SETUP_FRAME_ADDRESSES:                 Frame Layout.
* SETUP_INCOMING_VARARGS:                Varargs.
* SFmode:                                Machine Modes.
* SHARED_BSS_SECTION_ASM_OP:             Sections.
* SHARED_SECTION_ASM_OP:                 Sections.
* sharing of RTL components:             Sharing.
* shift:                                 Arithmetic.
* SHIFT_COUNT_TRUNCATED:                 Misc.
* SHORT_IMMEDIATES_SIGN_EXTEND:          Misc.
* SHORT_TYPE_SIZE:                       Type Layout.
* sibcall_epilogue instruction pattern:  Standard Names.
* sibling call optimization:             Passes.
* SIBLING_CALL_P:                        Flags.
* sign_extend:                           Conversions.
* sign_extract:                          Bit-Fields.
* sign_extract, canonicalization of:     Insn Canonicalizations.
* signed division:                       Arithmetic.
* signed maximum:                        Arithmetic.
* signed minimum:                        Arithmetic.
* SImode:                                Machine Modes.
* simple constraints:                    Simple Constraints.
* simplifications, arithmetic:           Passes.
* Single Static Assignment optimizations: Passes.
* SIZE_TYPE:                             Type Layout.
* SLOW_BYTE_ACCESS:                      Costs.
* SLOW_UNALIGNED_ACCESS:                 Costs.
* SMALL_ARG_MAX:                         Host Config.
* SMALL_REGISTER_CLASSES:                Register Classes.
* SMALL_STACK:                           Frame Layout.
* smax:                                  Arithmetic.
* smaxM3 instruction pattern:            Standard Names.
* smin:                                  Arithmetic.
* sminM3 instruction pattern:            Standard Names.
* smulM3_highpart instruction pattern:   Standard Names.
* SPECIAL_MODE_PREDICATES:               Misc.
* speed of instructions:                 Costs.
* splitting instructions:                Insn Splitting.
* sqrt:                                  Arithmetic.
* sqrtM2 instruction pattern:            Standard Names.
* square root:                           Arithmetic.
* ss_minus:                              Arithmetic.
* ss_plus:                               Arithmetic.
* ss_truncate:                           Conversions.
* SSA Conditional Constant Propagation:  Passes.
* SSA DCE:                               Passes.
* SSA optimizations:                     Passes.
* stack arguments:                       Stack Arguments.
* stack frame layout:                    Frame Layout.
* STACK_BOUNDARY:                        Storage Layout.
* STACK_CHECK_BUILTIN:                   Stack Checking.
* STACK_CHECK_FIXED_FRAME_SIZE:          Stack Checking.
* STACK_CHECK_MAX_FRAME_SIZE:            Stack Checking.
* STACK_CHECK_MAX_VAR_SIZE:              Stack Checking.
* STACK_CHECK_PROBE_INTERVAL:            Stack Checking.
* STACK_CHECK_PROBE_LOAD:                Stack Checking.
* STACK_CHECK_PROTECT:                   Stack Checking.
* STACK_DYNAMIC_OFFSET:                  Frame Layout.
* STACK_DYNAMIC_OFFSET and virtual registers: Regs and Memory.
* STACK_GROWS_DOWNWARD:                  Frame Layout.
* STACK_PARMS_IN_REG_PARM_AREA:          Stack Arguments.
* STACK_POINTER_OFFSET:                  Frame Layout.
* STACK_POINTER_OFFSET and virtual registers: Regs and Memory.
* STACK_POINTER_REGNUM:                  Frame Registers.
* STACK_POINTER_REGNUM and virtual registers: Regs and Memory.
* stack_pointer_rtx:                     Frame Registers.
* STACK_PUSH_CODE:                       Frame Layout.
* STACK_REGS:                            Stack Registers.
* STACK_SAVEAREA_MODE:                   Storage Layout.
* STACK_SIZE_MODE:                       Storage Layout.
* standard pattern names:                Standard Names.
* STANDARD_EXEC_PREFIX:                  Driver.
* STANDARD_INCLUDE_COMPONENT:            Driver.
* STANDARD_INCLUDE_DIR:                  Driver.
* STANDARD_STARTFILE_PREFIX:             Driver.
* STARTFILE_SPEC:                        Driver.
* STARTING_FRAME_OFFSET:                 Frame Layout.
* STARTING_FRAME_OFFSET and virtual registers: Regs and Memory.
* statements:                            Function Bodies.
* STATIC_CHAIN:                          Frame Registers.
* STATIC_CHAIN_INCOMING:                 Frame Registers.
* STATIC_CHAIN_INCOMING_REGNUM:          Frame Registers.
* STATIC_CHAIN_REGNUM:                   Frame Registers.
* stdarg.h and register arguments:       Register Arguments.
* STDC_0_IN_SYSTEM_HEADERS:              Misc.
* STMT_EXPR:                             Expression trees.
* STMT_IS_FULL_EXPR_P:                   Function Bodies.
* STMT_LINENO:                           Function Bodies.
* storage layout:                        Storage Layout.
* STORE_FLAG_VALUE:                      Misc.
* store_multiple instruction pattern:    Standard Names.
* strcpy:                                Storage Layout.
* strength-reduction:                    Passes.
* STRICT_ALIGNMENT:                      Storage Layout.
* STRICT_ARGUMENT_NAMING:                Varargs.
* strict_low_part:                       RTL Declarations.
* strict_memory_address_p:               Addressing Modes.
* STRING_CST:                            Expression trees.
* STRING_POOL_ADDRESS_P:                 Flags.
* STRIP_NAME_ENCODING:                   Sections.
* strlenM instruction pattern:           Standard Names.
* STRUCT_VALUE:                          Aggregate Return.
* STRUCT_VALUE_INCOMING:                 Aggregate Return.
* STRUCT_VALUE_INCOMING_REGNUM:          Aggregate Return.
* STRUCT_VALUE_REGNUM:                   Aggregate Return.
* structure value address:               Aggregate Return.
* STRUCTURE_SIZE_BOUNDARY:               Storage Layout.
* structures, returning:                 Interface.
* subM3 instruction pattern:             Standard Names.
* SUBOBJECT:                             Function Bodies.
* SUBOBJECT_CLEANUP:                     Function Bodies.
* subreg:                                Regs and Memory.
* subreg and /s:                         Flags.
* subreg and /u:                         Flags.
* subreg, in strict_low_part:            RTL Declarations.
* subreg, special reload handling:       Regs and Memory.
* SUBREG_BYTE:                           Regs and Memory.
* SUBREG_PROMOTED_UNSIGNED_P:            Flags.
* SUBREG_PROMOTED_VAR_P:                 Flags.
* SUBREG_REG:                            Regs and Memory.
* SUCCESS_EXIT_CODE:                     Host Config.
* SUPPORTS_INIT_PRIORITY:                Macros for Initialization.
* SUPPORTS_ONE_ONLY:                     Label Output.
* SUPPORTS_WEAK:                         Label Output.
* SWITCH_BODY:                           Function Bodies.
* SWITCH_COND:                           Function Bodies.
* SWITCH_CURTAILS_COMPILATION:           Driver.
* SWITCH_STMT:                           Function Bodies.
* SWITCH_TAKES_ARG:                      Driver.
* SWITCHES_NEED_SPACES:                  Driver.
* symbol_ref:                            Constants.
* symbol_ref and /f:                     Flags.
* symbol_ref and /i:                     Flags.
* symbol_ref and /u:                     Flags.
* symbol_ref and /v:                     Flags.
* symbol_ref, RTL sharing:               Sharing.
* SYMBOL_REF_FLAG:                       Flags.
* SYMBOL_REF_FLAG, in ENCODE_SECTION_INFO: Sections.
* SYMBOL_REF_USED:                       Flags.
* SYMBOL_REF_WEAK:                       Flags.
* symbolic label:                        Sharing.
* SYSTEM_INCLUDE_DIR:                    Driver.
* t-TARGET:                              Target Fragment.
* tablejump instruction pattern:         Standard Names.
* tagging insns:                         Tagging Insns.
* tail calls:                            Tail Calls.
* tail recursion optimization:           Passes.
* target attributes:                     Target Attributes.
* target description macros:             Target Macros.
* target functions:                      Target Structure.
* target hooks:                          Target Structure.
* target makefile fragment:              Target Fragment.
* target specifications:                 Run-time Target.
* target-parameter-dependent code:       Passes.
* TARGET_ALLOWS_PROFILING_WITHOUT_FRAME_POINTER: Profiling.
* TARGET_ASM_ALIGNED_DI_OP:              Data Output.
* TARGET_ASM_ALIGNED_HI_OP:              Data Output.
* TARGET_ASM_ALIGNED_SI_OP:              Data Output.
* TARGET_ASM_ALIGNED_TI_OP:              Data Output.
* TARGET_ASM_BYTE_OP:                    Data Output.
* TARGET_ASM_CLOSE_PAREN:                Data Output.
* TARGET_ASM_CONSTRUCTOR:                Macros for Initialization.
* TARGET_ASM_DESTRUCTOR:                 Macros for Initialization.
* TARGET_ASM_EH_FRAME_SECTION:           Exception Region Output.
* TARGET_ASM_EXCEPTION_SECTION:          Exception Region Output.
* TARGET_ASM_FUNCTION_BEGIN_EPILOGUE:    Function Entry.
* TARGET_ASM_FUNCTION_END_PROLOGUE:      Function Entry.
* TARGET_ASM_FUNCTION_EPILOGUE:          Function Entry.
* TARGET_ASM_FUNCTION_EPILOGUE and trampolines: Trampolines.
* TARGET_ASM_FUNCTION_PROLOGUE:          Function Entry.
* TARGET_ASM_FUNCTION_PROLOGUE and trampolines: Trampolines.
* TARGET_ASM_INTEGER:                    Data Output.
* TARGET_ASM_NAMED_SECTION:              File Framework.
* TARGET_ASM_OPEN_PAREN:                 Data Output.
* TARGET_ASM_UNALIGNED_DI_OP:            Data Output.
* TARGET_ASM_UNALIGNED_HI_OP:            Data Output.
* TARGET_ASM_UNALIGNED_SI_OP:            Data Output.
* TARGET_ASM_UNALIGNED_TI_OP:            Data Output.
* TARGET_ATTRIBUTE_TABLE:                Target Attributes.
* TARGET_BELL:                           Escape Sequences.
* TARGET_BS:                             Escape Sequences.
* TARGET_CANNOT_MODIFY_JUMPS_P:          Misc.
* TARGET_COMP_TYPE_ATTRIBUTES:           Target Attributes.
* TARGET_CR:                             Escape Sequences.
* TARGET_DLLIMPORT_DECL_ATTRIBUTES:      Target Attributes.
* TARGET_EDOM:                           Library Calls.
* TARGET_ESC:                            Escape Sequences.
* TARGET_EXECUTABLE_SUFFIX:              Misc.
* TARGET_EXPAND_BUILTIN:                 Misc.
* TARGET_FF:                             Escape Sequences.
* TARGET_FLOAT_FORMAT:                   Storage Layout.
* TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P: Target Attributes.
* TARGET_HAS_F_SETLKW:                   Misc.
* TARGET_HAVE_CTORS_DTORS:               Macros for Initialization.
* TARGET_HAVE_NAMED_SECTIONS:            File Framework.
* TARGET_INIT_BUILTINS:                  Misc.
* TARGET_INSERT_ATTRIBUTES:              Target Attributes.
* TARGET_MEM_FUNCTIONS:                  Library Calls.
* TARGET_MERGE_DECL_ATTRIBUTES:          Target Attributes.
* TARGET_MERGE_TYPE_ATTRIBUTES:          Target Attributes.
* TARGET_MS_BITFIELD_LAYOUT_P:           Storage Layout.
* TARGET_NEWLINE:                        Escape Sequences.
* TARGET_OBJECT_SUFFIX:                  Misc.
* TARGET_OPTION_TRANSLATE_TABLE:         Driver.
* TARGET_OPTIONS:                        Run-time Target.
* TARGET_PTRMEMFUNC_VBIT_LOCATION:       Type Layout.
* TARGET_SCHED_ADJUST_COST:              Scheduling.
* TARGET_SCHED_ADJUST_PRIORITY:          Scheduling.
* TARGET_SCHED_CYCLE_DISPLAY:            Scheduling.
* TARGET_SCHED_FINISH:                   Scheduling.
* TARGET_SCHED_INIT:                     Scheduling.
* TARGET_SCHED_ISSUE_RATE:               Scheduling.
* TARGET_SCHED_REORDER:                  Scheduling.
* TARGET_SCHED_REORDER2:                 Scheduling.
* TARGET_SCHED_VARIABLE_ISSUE:           Scheduling.
* TARGET_SECTION_TYPE_FLAGS:             File Framework.
* TARGET_SET_DEFAULT_TYPE_ATTRIBUTES:    Target Attributes.
* TARGET_SWITCHES:                       Run-time Target.
* TARGET_TAB:                            Escape Sequences.
* TARGET_VERSION:                        Run-time Target.
* TARGET_VT:                             Escape Sequences.
* TARGET_VTABLE_USES_DESCRIPTORS:        Type Layout.
* targetm:                               Target Structure.
* targets, makefile:                     Makefile.
* TCmode:                                Machine Modes.
* TEMPLATE_DECL:                         Declarations.
* termination routines:                  Initialization.
* TEXT_SECTION:                          Sections.
* text_section:                          Sections.
* TEXT_SECTION_ASM_OP:                   Sections.
* TFmode:                                Machine Modes.
* THEN_CLAUSE:                           Function Bodies.
* THREAD_MODEL_SPEC:                     Driver.
* THROW_EXPR:                            Expression trees.
* THUNK_DECL:                            Declarations.
* THUNK_DELTA:                           Declarations.
* TImode:                                Machine Modes.
* TImode, in insn:                       Insns.
* tm.h macros:                           Target Macros.
* top level of compiler:                 Passes.
* TQFmode:                               Machine Modes.
* TRADITIONAL_RETURN_FLOAT:              Scalar Return.
* TRAMPOLINE_ADJUST_ADDRESS:             Trampolines.
* TRAMPOLINE_ALIGNMENT:                  Trampolines.
* TRAMPOLINE_SECTION:                    Trampolines.
* TRAMPOLINE_SIZE:                       Trampolines.
* TRAMPOLINE_TEMPLATE:                   Trampolines.
* trampolines for nested functions:      Trampolines.
* TRANSFER_FROM_TRAMPOLINE:              Trampolines.
* trap instruction pattern:              Standard Names.
* tree <1>:                              Macros and Functions.
* tree:                                  Tree overview.
* Tree optimization:                     Passes.
* TREE_CODE:                             Tree overview.
* tree_int_cst_equal:                    Expression trees.
* TREE_INT_CST_HIGH:                     Expression trees.
* TREE_INT_CST_LOW:                      Expression trees.
* tree_int_cst_lt:                       Expression trees.
* TREE_LIST:                             Containers.
* TREE_OPERAND:                          Expression trees.
* TREE_PUBLIC:                           Function Basics.
* TREE_PURPOSE:                          Containers.
* TREE_STRING_LENGTH:                    Expression trees.
* TREE_STRING_POINTER:                   Expression trees.
* TREE_TYPE <1>:                         Function Basics.
* TREE_TYPE <2>:                         Expression trees.
* TREE_TYPE <3>:                         Declarations.
* TREE_TYPE:                             Types.
* TREE_VALUE:                            Containers.
* TREE_VEC:                              Containers.
* TREE_VEC_ELT:                          Containers.
* TREE_VEC_LENGTH:                       Containers.
* TREE_VIA_PRIVATE:                      Classes.
* TREE_VIA_PROTECTED:                    Classes.
* TREE_VIA_PUBLIC:                       Classes.
* Trees:                                 Trees.
* TRULY_NOOP_TRUNCATION:                 Misc.
* TRUNC_DIV_EXPR:                        Expression trees.
* TRUNC_MOD_EXPR:                        Expression trees.
* truncate:                              Conversions.
* truncMN2 instruction pattern:          Standard Names.
* TRUTH_AND_EXPR:                        Expression trees.
* TRUTH_ANDIF_EXPR:                      Expression trees.
* TRUTH_NOT_EXPR:                        Expression trees.
* TRUTH_OR_EXPR:                         Expression trees.
* TRUTH_ORIF_EXPR:                       Expression trees.
* TRUTH_XOR_EXPR:                        Expression trees.
* TRY_BLOCK:                             Function Bodies.
* TRY_HANDLERS:                          Function Bodies.
* TRY_STMTS:                             Function Bodies.
* tstM instruction pattern:              Standard Names.
* type:                                  Types.
* type declaration:                      Declarations.
* TYPE_ALIGN:                            Types.
* TYPE_ARG_TYPES:                        Types.
* TYPE_ATTRIBUTES:                       Attributes.
* TYPE_BINFO:                            Classes.
* TYPE_BUILT_IN:                         Types.
* TYPE_CONTEXT:                          Types.
* TYPE_DECL:                             Declarations.
* TYPE_FIELDS <1>:                       Types.
* TYPE_FIELDS:                           Classes.
* TYPE_HAS_ARRAY_NEW_OPERATOR:           Classes.
* TYPE_HAS_DEFAULT_CONSTRUCTOR:          Classes.
* TYPE_HAS_MUTABLE_P:                    Classes.
* TYPE_HAS_NEW_OPERATOR:                 Classes.
* TYPE_MAIN_VARIANT:                     Types.
* TYPE_MAX_VALUE:                        Types.
* TYPE_METHOD_BASETYPE:                  Types.
* TYPE_METHODS:                          Classes.
* TYPE_MIN_VALUE:                        Types.
* TYPE_NAME:                             Types.
* TYPE_NOTHROW_P:                        Function Basics.
* TYPE_OFFSET_BASETYPE:                  Types.
* TYPE_OVERLOADS_ARRAY_REF:              Classes.
* TYPE_OVERLOADS_ARROW:                  Classes.
* TYPE_OVERLOADS_CALL_EXPR:              Classes.
* TYPE_POLYMORPHIC_P:                    Classes.
* TYPE_PRECISION:                        Types.
* TYPE_PTR_P:                            Types.
* TYPE_PTRFN_P:                          Types.
* TYPE_PTRMEM_P:                         Types.
* TYPE_PTROB_P:                          Types.
* TYPE_PTROBV_P:                         Types.
* TYPE_QUAL_CONST:                       Types.
* TYPE_QUAL_RESTRICT:                    Types.
* TYPE_QUAL_VOLATILE:                    Types.
* TYPE_RAISES_EXCEPTIONS:                Function Basics.
* TYPE_SIZE:                             Types.
* TYPE_UNQUALIFIED:                      Types.
* TYPE_VFIELD:                           Classes.
* TYPENAME_TYPE:                         Types.
* TYPENAME_TYPE_FULLNAME:                Types.
* TYPEOF_TYPE:                           Types.
* udiv:                                  Arithmetic.
* UDIVDI3_LIBCALL:                       Library Calls.
* udivM3 instruction pattern:            Standard Names.
* udivmodM4 instruction pattern:         Standard Names.
* UDIVSI3_LIBCALL:                       Library Calls.
* UINTMAX_TYPE:                          Type Layout.
* umax:                                  Arithmetic.
* umaxM3 instruction pattern:            Standard Names.
* umin:                                  Arithmetic.
* uminM3 instruction pattern:            Standard Names.
* umod:                                  Arithmetic.
* UMODDI3_LIBCALL:                       Library Calls.
* umodM3 instruction pattern:            Standard Names.
* UMODSI3_LIBCALL:                       Library Calls.
* umulhisi3 instruction pattern:         Standard Names.
* umulM3_highpart instruction pattern:   Standard Names.
* umulqihi3 instruction pattern:         Standard Names.
* umulsidi3 instruction pattern:         Standard Names.
* unchanging:                            Flags.
* unchanging, in call_insn:              Flags.
* unchanging, in insn:                   Flags.
* unchanging, in reg and mem:            Flags.
* unchanging, in subreg:                 Flags.
* unchanging, in symbol_ref:             Flags.
* UNION_TYPE <1>:                        Classes.
* UNION_TYPE:                            Types.
* unions, returning:                     Interface.
* UNIQUE_SECTION:                        Sections.
* UNITS_PER_WORD:                        Storage Layout.
* UNKNOWN_FLOAT_FORMAT:                  Storage Layout.
* UNKNOWN_TYPE:                          Types.
* unreachable code:                      Passes.
* unshare_all_rtl:                       Sharing.
* unsigned division:                     Arithmetic.
* unsigned greater than:                 Comparisons.
* unsigned less than:                    Comparisons.
* unsigned minimum and maximum:          Arithmetic.
* unsigned_fix:                          Conversions.
* unsigned_float:                        Conversions.
* unspec:                                Side Effects.
* unspec_volatile:                       Side Effects.
* untyped_call instruction pattern:      Standard Names.
* untyped_return instruction pattern:    Standard Names.
* UPDATE_PATH_HOST_CANONICALIZE (PATH):  Host Config.
* us_minus:                              Arithmetic.
* us_plus:                               Arithmetic.
* us_truncate:                           Conversions.
* use:                                   Side Effects.
* USE_C_ALLOCA:                          Host Config.
* USE_LOAD_POST_DECREMENT:               Costs.
* USE_LOAD_POST_INCREMENT:               Costs.
* USE_LOAD_PRE_DECREMENT:                Costs.
* USE_LOAD_PRE_INCREMENT:                Costs.
* USE_STORE_POST_DECREMENT:              Costs.
* USE_STORE_POST_INCREMENT:              Costs.
* USE_STORE_PRE_DECREMENT:               Costs.
* USE_STORE_PRE_INCREMENT:               Costs.
* used:                                  Flags.
* used, in symbol_ref:                   Flags.
* USER_LABEL_PREFIX:                     Instruction Output.
* USING_DECL:                            Declarations.
* USING_STMT:                            Function Bodies.
* V in constraint:                       Simple Constraints.
* values, returned by functions:         Scalar Return.
* VAR_DECL <1>:                          Declarations.
* VAR_DECL:                              Expression trees.
* varargs implementation:                Varargs.
* variable:                              Declarations.
* VAX_FLOAT_FORMAT:                      Storage Layout.
* vec_concat:                            Vector Operations.
* vec_const:                             Vector Operations.
* vec_duplicate:                         Vector Operations.
* vec_merge:                             Vector Operations.
* vec_select:                            Vector Operations.
* vector:                                Containers.
* vector operations:                     Vector Operations.
* VECTOR_CST:                            Expression trees.
* VECTOR_MODE_SUPPORTED_P:               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:                                   Host Config.
* VMS_DEBUGGING_INFO:                    VMS Debug.
* VOID_TYPE:                             Types.
* VOIDmode:                              Machine Modes.
* volatil:                               Flags.
* volatil, in insn:                      Flags.
* volatil, in label_ref:                 Flags.
* volatil, in mem:                       Flags.
* volatil, in reg:                       Flags.
* volatil, in symbol_ref:                Flags.
* volatile memory references:            Flags.
* voting between constraint alternatives: Class Preferences.
* VTABLE_REF:                            Expression trees.
* WCHAR_TYPE:                            Type Layout.
* WCHAR_TYPE_SIZE:                       Type Layout.
* which_alternative:                     Output Statement.
* WHILE_BODY:                            Function Bodies.
* WHILE_COND:                            Function Bodies.
* WHILE_STMT:                            Function Bodies.
* WIDEST_HARDWARE_FP_SIZE:               Type Layout.
* WINT_TYPE:                             Type Layout.
* word_mode:                             Machine Modes.
* WORD_REGISTER_OPERATIONS:              Misc.
* WORD_SWITCH_TAKES_ARG:                 Driver.
* WORDS_BIG_ENDIAN:                      Storage Layout.
* WORDS_BIG_ENDIAN, effect on subreg:    Regs and Memory.
* X in constraint:                       Simple Constraints.
* x-HOST:                                Host Fragment.
* XCmode:                                Machine Modes.
* XCOFF_DEBUGGING_INFO:                  DBX Options.
* XEXP:                                  Accessors.
* XFmode:                                Machine Modes.
* XINT:                                  Accessors.
* xm-MACHINE.h:                          Host Config.
* xor:                                   Arithmetic.
* xor, canonicalization of:              Insn Canonicalizations.
* xorM3 instruction pattern:             Standard Names.
* XSTR:                                  Accessors.
* XVEC:                                  Accessors.
* XVECEXP:                               Accessors.
* XVECLEN:                               Accessors.
* XWINT:                                 Accessors.
* zero_extend:                           Conversions.
* zero_extendMN2 instruction pattern:    Standard Names.
* zero_extract:                          Bit-Fields.
* zero_extract, canonicalization of:     Insn Canonicalizations.


