This is doc/gcc.info, produced by makeinfo version 4.0 from
doc/gcc.texi.

INFO-DIR-SECTION Programming
START-INFO-DIR-ENTRY
* gcc: (gcc).                  The GNU Compiler Collection.
END-INFO-DIR-ENTRY
   This file documents the use and the internals of the GNU compiler.


   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 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: gcc.info,  Node: Index,  Prev: Option Index,  Up: Top

Index
*****

* Menu:

* ! in constraint:                       Multi-Alternative.
* # in constraint:                       Modifiers.
* # in template:                         Output Template.
* #pragma:                               Misc.
* #pragma implementation:                C++ Interface.
* #pragma implementation, implied:       C++ Interface.
* #pragma interface:                     C++ Interface.
* #pragma, reason for not using:         Function Attributes.
* $:                                     Dollar Signs.
* % in constraint:                       Modifiers.
* % in template:                         Output Template.
* %include:                              Spec Files.
* %include_noerr:                        Spec Files.
* %rename:                               Spec Files.
* & in constraint:                       Modifiers.
* ':                                     Incompatibilities.
* (nil):                                 RTL Objects.
* * in constraint:                       Modifiers.
* * in template:                         Output Statement.
* + in constraint:                       Modifiers.
* -lgcc, use with -nodefaultlibs:        Link Options.
* -lgcc, use with -nostdlib:             Link Options.
* -nodefaultlibs and unresolved references: Link Options.
* -nostdlib and unresolved references:   Link Options.
* .sdata/.sdata2 references (PowerPC):   RS/6000 and PowerPC Options.
* //:                                    C++ Comments.
* /f in RTL dump:                        Flags.
* /i 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.
* <?:                                    Min and Max.
* = in constraint:                       Modifiers.
* > in constraint:                       Simple Constraints.
* >?:                                    Min and Max.
* ? in constraint:                       Multi-Alternative.
* ?: extensions <1>:                     Conditionals.
* ?: extensions:                         Lvalues.
* ?: side effect:                        Conditionals.
* \:                                     Output Template.
* \a:                                    C Dialect Options.
* \x:                                    C Dialect Options.
* _ in variables in macros:              Naming Types.
* __bb:                                  Profiling.
* __bb_init_func:                        Profiling.
* __bb_init_trace_func:                  Profiling.
* __bb_trace_func:                       Profiling.
* __bb_trace_ret:                        Profiling.
* __builtin_apply:                       Constructing Calls.
* __builtin_apply_args:                  Constructing Calls.
* __builtin_args_info:                   Varargs.
* __builtin_classify_type:               Varargs.
* __builtin_constant_p:                  Other Builtins.
* __builtin_expect:                      Other Builtins.
* __builtin_frame_address:               Return Address.
* __builtin_isgreater:                   Other Builtins.
* __builtin_isgreaterequal:              Other Builtins.
* __builtin_isless:                      Other Builtins.
* __builtin_islessequal:                 Other Builtins.
* __builtin_islessgreater:               Other Builtins.
* __builtin_isunordered:                 Other Builtins.
* __builtin_next_arg:                    Varargs.
* __builtin_return:                      Constructing Calls.
* __builtin_return_address:              Return Address.
* __builtin_saveregs:                    Varargs.
* __complex__ keyword:                   Complex.
* __CTOR_LIST__:                         Initialization.
* __DTOR_LIST__:                         Initialization.
* __extension__:                         Alternate Keywords.
* __func__ identifier:                   Function Names.
* __FUNCTION__ identifier:               Function Names.
* __imag__ keyword:                      Complex.
* __main:                                Collect2.
* __PRETTY_FUNCTION__ identifier:        Function Names.
* __real__ keyword:                      Complex.
* __STDC_HOSTED__:                       Standards.
* _Complex keyword:                      Complex.
* _Exit:                                 Other Builtins.
* _exit:                                 Other Builtins.
* abort <1>:                             Portability.
* abort:                                 Other Builtins.
* abs <1>:                               Arithmetic.
* abs:                                   Other Builtins.
* abs and attributes:                    Expressions.
* absM2 instruction pattern:             Standard Names.
* absolute value:                        Arithmetic.
* access to operands:                    Accessors.
* accessing volatiles:                   Volatiles.
* accessors:                             Accessors.
* ACCUMULATE_OUTGOING_ARGS:              Stack Arguments.
* ACCUMULATE_OUTGOING_ARGS and stack frames: Function Entry.
* 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 of a label:                    Labels as Values.
* ADDRESS_COST:                          Costs.
* address_operand:                       Simple Constraints.
* addressing modes:                      Addressing Modes.
* addressof:                             Regs and Memory.
* ADJUST_COST:                           Costs.
* ADJUST_FIELD_ALIGN:                    Storage Layout.
* ADJUST_INSN_LENGTH:                    Insn Lengths.
* ADJUST_PRIORITY:                       Costs.
* aggregates as return values:           Aggregate Return.
* alias attribute:                       Function Attributes.
* aliasing of parameters:                Code Gen Options.
* aligned attribute <1>:                 Type Attributes.
* aligned attribute:                     Variable Attributes.
* alignment:                             Alignment.
* ALL_REGS:                              Register Classes.
* Alliant:                               Interoperation.
* alloca:                                Other Builtins.
* alloca vs variable-length arrays:      Variable Length.
* allocate_stack instruction pattern:    Standard Names.
* ALLOCATE_TRAMPOLINE:                   Trampolines.
* ALTER_HARD_SUBREG:                     Values in Registers.
* alternate keywords:                    Alternate Keywords.
* AMD1:                                  Standards.
* AMD29K options:                        AMD29K Options.
* analysis, data flow:                   Passes.
* and:                                   Arithmetic.
* and and attributes:                    Expressions.
* and, canonicalization of:              Insn Canonicalizations.
* andM3 instruction pattern:             Standard Names.
* ANSI C:                                Standards.
* ANSI C standard:                       Standards.
* ANSI C89:                              Standards.
* ANSI support:                          C Dialect Options.
* ANSI X3.159-1989:                      Standards.
* apostrophes:                           Incompatibilities.
* APPLY_RESULT_SIZE:                     Scalar Return.
* ARC Options:                           ARC Options.
* 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 frame (88k):              M88K Options.
* arguments in registers:                Register Arguments.
* arguments on stack:                    Stack Arguments.
* arithmetic libraries:                  Interface.
* arithmetic shift:                      Arithmetic.
* arithmetic simplifications:            Passes.
* arithmetic, in RTL:                    Arithmetic.
* ARITHMETIC_TYPE_P:                     Types.
* ARM [Annotated C++ Reference Manual]:  Backwards Compatibility.
* ARM options:                           ARM Options.
* array:                                 Types.
* ARRAY_REF:                             Expression trees.
* ARRAY_TYPE:                            Types.
* arrays of length zero:                 Zero Length.
* arrays of variable length:             Variable Length.
* arrays, non-lvalue:                    Subscripting.
* ashift:                                Arithmetic.
* ashift and attributes:                 Expressions.
* ashiftrt:                              Arithmetic.
* ashiftrt and attributes:               Expressions.
* ashlM3 instruction pattern:            Standard Names.
* ashrM3 instruction pattern:            Standard Names.
* asm expressions:                       Extended Asm.
* ASM_APP_OFF:                           File Framework.
* ASM_APP_ON:                            File Framework.
* ASM_BYTE_OP:                           Data Output.
* ASM_CLOBBERS:                          Function Bodies.
* ASM_CLOSE_PAREN:                       Data Output.
* ASM_COMMENT_START:                     File Framework.
* ASM_CV_QUAL:                           Function Bodies.
* 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_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:     Frame Layout.
* ASM_NO_SKIP_IN_TEXT:                   Alignment Output.
* asm_noperands:                         Insns.
* ASM_OPEN_PAREN:                        Data Output.
* 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_BYTE:                       Data Output.
* ASM_OUTPUT_CASE_END:                   Dispatch Tables.
* ASM_OUTPUT_CASE_LABEL:                 Dispatch Tables.
* ASM_OUTPUT_CHAR:                       Data Output.
* ASM_OUTPUT_COMMON:                     Uninitialized Data.
* ASM_OUTPUT_CONSTRUCTOR:                Macros for Initialization.
* ASM_OUTPUT_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_DESTRUCTOR:                 Macros for Initialization.
* ASM_OUTPUT_DOUBLE:                     Data Output.
* ASM_OUTPUT_DOUBLE_INT:                 Data Output.
* ASM_OUTPUT_EH_REGION_BEG:              Exception Region Output.
* ASM_OUTPUT_EH_REGION_END:              Exception Region Output.
* ASM_OUTPUT_EXTERNAL:                   Label Output.
* ASM_OUTPUT_EXTERNAL_LIBCALL:           Label Output.
* ASM_OUTPUT_FLOAT:                      Data Output.
* ASM_OUTPUT_IDENT:                      File Framework.
* ASM_OUTPUT_INT:                        Data Output.
* ASM_OUTPUT_INTERNAL_LABEL:             Label Output.
* ASM_OUTPUT_LABEL:                      Label Output.
* ASM_OUTPUT_LABELREF:                   Label Output.
* ASM_OUTPUT_LOCAL:                      Uninitialized Data.
* ASM_OUTPUT_LONG_DOUBLE:                Data Output.
* ASM_OUTPUT_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_QUADRUPLE_INT:              Data Output.
* ASM_OUTPUT_REG_POP:                    Instruction Output.
* ASM_OUTPUT_REG_PUSH:                   Instruction Output.
* ASM_OUTPUT_SECTION_NAME:               File Framework.
* ASM_OUTPUT_SHARED_BSS:                 Uninitialized Data.
* ASM_OUTPUT_SHARED_COMMON:              Uninitialized Data.
* ASM_OUTPUT_SHARED_LOCAL:               Uninitialized Data.
* ASM_OUTPUT_SHORT:                      Data Output.
* ASM_OUTPUT_SKIP:                       Alignment Output.
* ASM_OUTPUT_SOURCE_FILENAME:            File Framework.
* ASM_OUTPUT_SOURCE_LINE:                File Framework.
* ASM_OUTPUT_SPECIAL_POOL_ENTRY:         Data Output.
* ASM_OUTPUT_SYMBOL_REF:                 Label Output.
* ASM_OUTPUT_WEAK_ALIAS:                 Label Output.
* ASM_OUTPUTS:                           Function Bodies.
* ASM_PREFERRED_EH_DATA_FORMAT:          Frame Layout.
* 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_LABEL:                      Label Output.
* assemble_name:                         Label Output.
* assembler format:                      File Framework.
* assembler instructions:                Extended Asm.
* assembler instructions in RTL:         Assembler.
* assembler names for identifiers:       Asm Labels.
* assembler syntax, 88k:                 M88K Options.
* ASSEMBLER_DIALECT:                     Instruction Output.
* assembly code, invalid:                Bug Criteria.
* assigning attribute values to insns:   Tagging Insns.
* assignment operator:                   Function Basics.
* asterisk in template:                  Output Statement.
* atof:                                  Cross-compilation.
* attr <1>:                              Tagging Insns.
* attr:                                  Expressions.
* attr_flag:                             Expressions.
* attribute expressions:                 Expressions.
* attribute of types:                    Type Attributes.
* attribute of variables:                Variable Attributes.
* attribute specifications:              Attr Example.
* attribute specifications example:      Attr Example.
* attribute syntax:                      Attribute Syntax.
* attributes:                            Attributes.
* attributes, defining:                  Defining Attributes.
* autoincrement addressing, availability: Portability.
* autoincrement/decrement addressing:    Simple Constraints.
* autoincrement/decrement analysis:      Passes.
* automatic inline for C++ member fns:   Inline.
* AVOID_CCMODE_COPIES:                   Values in Registers.
* AVR Options:                           AVR Options.
* backslash:                             Output Template.
* backtrace for bug reports:             Bug Reporting.
* Backwards Compatibility:               Backwards Compatibility.
* barrier:                               Insns.
* BASE_REG_CLASS:                        Register Classes.
* basic block reordering:                Passes.
* basic blocks:                          Passes.
* bcmp <1>:                              Config.
* bcmp:                                  Other Builtins.
* 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 shift overflow (88k):              M88K Options.
* 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.
* BLOCK_PROFILER:                        Profiling.
* BLOCK_PROFILER_CODE:                   Profiling.
* BOOL_TYPE_SIZE:                        Type Layout.
* BOOLEAN_TYPE:                          Types.
* bound pointer to member function:      Bound member functions.
* branch shortening:                     Passes.
* BRANCH_COST:                           Costs.
* break_out_memory_refs:                 Addressing Modes.
* BREAK_STMT:                            Function Bodies.
* BSS_SECTION_ASM_OP:                    Sections.
* bug criteria:                          Bug Criteria.
* bug report mailing lists:              Bug Lists.
* bugs:                                  Bugs.
* bugs, known:                           Trouble.
* built-in functions <1>:                Other Builtins.
* built-in functions:                    C Dialect Options.
* 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 writes (29k):                     AMD29K Options.
* byte_mode:                             Machine Modes.
* BYTES_BIG_ENDIAN:                      Storage Layout.
* bzero <1>:                             Config.
* bzero:                                 Other Builtins.
* bzero, implicit usage:                 Library Calls.
* C compilation options:                 Invoking GCC.
* C intermediate output, nonexistent:    G++ and GCC.
* C language extensions:                 C Extensions.
* C language, traditional:               C Dialect Options.
* C standard:                            Standards.
* C standards:                           Standards.
* C statements for assembler output:     Output Statement.
* c++:                                   Invoking G++.
* C++:                                   G++ and GCC.
* C++ comments:                          C++ Comments.
* C++ compilation options:               Invoking GCC.
* C++ interface and implementation headers: C++ Interface.
* C++ language extensions:               C++ Extensions.
* C++ member fns, automatically inline:  Inline.
* C++ misunderstandings:                 C++ Misunderstandings.
* C++ options, command line:             C++ Dialect Options.
* C++ pragmas, effect on inlining:       C++ Interface.
* C++ source file suffixes:              Invoking G++.
* C++ static data, declaring and defining: Static Definitions.
* C/C++ Internal Representation:         Trees.
* C4X_FLOAT_FORMAT:                      Storage Layout.
* C89:                                   Standards.
* C90:                                   Standards.
* C94:                                   Standards.
* C95:                                   Standards.
* C99:                                   Standards.
* C9X:                                   Standards.
* C_INCLUDE_PATH:                        Environment Variables.
* call:                                  Side Effects.
* call instruction pattern:              Standard Names.
* call usage:                            Calls.
* 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 /u:                      Flags.
* CALL_INSN_FUNCTION_USAGE:              Insns.
* call_pop instruction pattern:          Standard Names.
* 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.
* calling functions through the function vector on the H8/300 processors: Function Attributes.
* CAN_DEBUG_WITHOUT_FP:                  Run-time Target.
* CAN_ELIMINATE:                         Elimination.
* canadian:                              Makefile.
* canonicalization of instructions:      Insn Canonicalizations.
* CANONICALIZE_COMPARISON:               Condition Code.
* canonicalize_funcptr_for_compare instruction pattern: Standard Names.
* case labels in initializers:           Designated Inits.
* case ranges:                           Case Ranges.
* case sensitivity and VMS:              VMS Misc.
* CASE_DROPS_THROUGH:                    Misc.
* CASE_VALUES_THRESHOLD:                 Misc.
* CASE_VECTOR_MODE:                      Misc.
* CASE_VECTOR_PC_RELATIVE:               Misc.
* CASE_VECTOR_SHORTEN_MODE:              Misc.
* casesi instruction pattern:            Standard Names.
* cast to a union:                       Cast to Union.
* casts as lvalues:                      Lvalues.
* CC:                                    Host Fragment.
* 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.
* cimag:                                 Other Builtins.
* cimagf:                                Other Builtins.
* cimagl:                                Other Builtins.
* 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.
* CLIB:                                  Host Fragment.
* clobber:                               Side Effects.
* clrstrM instruction pattern:           Standard Names.
* cmpM instruction pattern:              Standard Names.
* cmpstrM instruction pattern:           Standard Names.
* code generation conventions:           Code Gen Options.
* code generation RTL sequences:         Expander Definitions.
* code motion:                           Passes.
* code, mixed with declarations:         Mixed Declarations.
* code_label:                            Insns.
* code_label and /i:                     Flags.
* CODE_LABEL_NUMBER:                     Insns.
* codes, RTL expression:                 RTL Objects.
* COImode:                               Machine Modes.
* COLLECT2_HOST_INITIALIZATION:          Config.
* COLLECT_EXPORT_LIST:                   Config.
* combiner pass:                         Regs and Memory.
* command options:                       Invoking GCC.
* comments, C++ style:                   C++ Comments.
* common subexpression elimination:      Passes.
* COMP_TYPE_ATTRIBUTES:                  Misc.
* compare:                               Arithmetic.
* compare, canonicalization of:          Insn Canonicalizations.
* comparison of signed and unsigned values, warning: Warning Options.
* compiler bugs, reporting:              Bug Reporting.
* compiler compared to C++ preprocessor: G++ and GCC.
* compiler options, C++:                 C++ Dialect Options.
* compiler options, Objective-C:         Objective-C Dialect Options.
* compiler passes and files:             Passes.
* compiler version, specifying:          Target Options.
* COMPILER_PATH:                         Environment Variables.
* complement, bitwise:                   Arithmetic.
* complex conjugation:                   Complex.
* complex numbers:                       Complex.
* COMPLEX_CST:                           Expression trees.
* COMPLEX_EXPR:                          Expression trees.
* COMPLEX_TYPE:                          Types.
* COMPONENT_REF:                         Expression trees.
* compound expressions as lvalues:       Lvalues.
* compound literals:                     Compound Literals.
* COMPOUND_BODY:                         Function Bodies.
* COMPOUND_EXPR:                         Expression trees.
* COMPOUND_STMT:                         Function Bodies.
* computed gotos:                        Labels as Values.
* computing the length of an insn:       Insn Lengths.
* cond:                                  Comparisons.
* cond and attributes:                   Expressions.
* COND_EXPR:                             Expression trees.
* condition code register:               Regs and Memory.
* condition code status:                 Condition Code.
* condition codes:                       Comparisons.
* conditional execution:                 Conditional Execution.
* conditional expressions as lvalues:    Lvalues.
* conditional expressions, extensions:   Conditionals.
* CONDITIONAL_REGISTER_USAGE:            Register Basics.
* conditional_trap instruction pattern:  Standard Names.
* conditions, in patterns:               Patterns.
* configuration file:                    Config.
* configurations supported by GNU CC:    Configurations.
* configure terms:                       Makefile.
* conflicting types:                     Disappointments.
* conj:                                  Other Builtins.
* CONJ_EXPR:                             Expression trees.
* conjf:                                 Other Builtins.
* conjl:                                 Other Builtins.
* const applied to function:             Function Attributes.
* const function attribute:              Function Attributes.
* CONST0_RTX:                            Constants.
* const0_rtx:                            Constants.
* CONST1_RTX:                            Constants.
* const1_rtx:                            Constants.
* CONST2_RTX:                            Constants.
* const2_rtx:                            Constants.
* CONST_CALL_P:                          Flags.
* 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_string:                          Constants.
* const_string and attributes:           Expressions.
* const_true_rtx:                        Constants.
* 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.
* constructing calls:                    Constructing Calls.
* CONSTRUCTOR:                           Expression trees.
* constructor:                           Function Basics.
* constructor expressions:               Compound Literals.
* constructor function attribute:        Function Attributes.
* 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.
* Convex options:                        Convex Options.
* copy constructor:                      Function Basics.
* copy propagation:                      Passes.
* copy_rtx:                              Addressing Modes.
* copy_rtx_if_shared:                    Sharing.
* core dump:                             Bug Criteria.
* cos:                                   Other Builtins.
* cosf:                                  Other Builtins.
* cosl:                                  Other Builtins.
* 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.
* CPLUS_INCLUDE_PATH:                    Environment Variables.
* CPLUSPLUS_CPP_SPEC:                    Driver.
* CPP_PREDEFINES:                        Run-time Target.
* cpp_register_pragma:                   Misc.
* cpp_register_pragma_space:             Misc.
* CPP_SPEC:                              Driver.
* CQImode:                               Machine Modes.
* creal:                                 Other Builtins.
* crealf:                                Other Builtins.
* creall:                                Other Builtins.
* cross compilation and floating point:  Cross-compilation.
* cross compiling:                       Target Options.
* cross-compiler, installation:          Cross-Compiler.
* cross-jumping:                         Passes.
* CROSS_LIBGCC1:                         Target Fragment.
* 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.
* D30V Options:                          D30V Options.
* 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:                                   Interoperation.
* 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_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.
* deallocating variable length arrays:   Variable Length.
* debug_rtx:                             Bug Reporting.
* DEBUG_SYMS_TEXT:                       DBX Options.
* DEBUGGER_ARG_OFFSET:                   All Debuggers.
* DEBUGGER_AUTO_OFFSET:                  All Debuggers.
* debugging information generation:      Passes.
* debugging information options:         Debugging Options.
* debugging, 88k OCS:                    M88K Options.
* 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:                       Declarations.
* DECL_ASSEMBLER_NAME:                   Function Basics.
* 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_MACHINE_ATTRIBUTES:               Attributes.
* DECL_MAIN_P:                           Function Basics.
* DECL_NAME <1>:                         Function Basics.
* DECL_NAME <2>:                         Declarations.
* DECL_NAME:                             Namespaces.
* 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.
* declaration scope:                     Incompatibilities.
* declarations inside expressions:       Statement Exprs.
* declarations, mixed with code:         Mixed Declarations.
* declarations, RTL:                     RTL Declarations.
* declaring attributes of functions:     Function Attributes.
* declaring static data in C++:          Static Definitions.
* 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.
* DEFAULT_VTABLE_THUNKS:                 Storage 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_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.
* defining static data in C++:           Static Definitions.
* delay slots, defining:                 Delay Slots.
* DELAY_SLOTS_FOR_EPILOGUE:              Function Entry.
* delayed branch scheduling:             Passes.
* dependencies for make as output:       Environment Variables.
* dependencies, make:                    Preprocessor Options.
* DEPENDENCIES_OUTPUT:                   Environment Variables.
* Dependent Patterns:                    Dependent Patterns.
* designated initializers:               Designated Inits.
* designator lists:                      Designated Inits.
* designators:                           Designated Inits.
* destructor:                            Function Basics.
* destructor function attribute:         Function Attributes.
* destructors, output of:                Initialization.
* detecting -traditional:                C Dialect Options.
* DFmode:                                Machine Modes.
* diagnostic messages:                   Language Independent Options.
* dialect options:                       C Dialect Options.
* digits in constraint:                  Simple Constraints.
* DImode:                                Machine Modes.
* DIR_SEPARATOR:                         Config.
* DIR_SEPARATOR_2:                       Config.
* directory options:                     Directory Options.
* disabling certain registers:           Register Basics.
* dispatch table:                        Dispatch Tables.
* div:                                   Arithmetic.
* div and attributes:                    Expressions.
* DIVDI3_LIBCALL:                        Library Calls.
* divide instruction, 88k:               M88K Options.
* 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.
* DOESNT_NEED_UNWINDER:                  Exception Region Output.
* dollar signs in identifier names:      Dollar Signs.
* DOLLARS_IN_IDENTIFIERS:                Misc.
* doloop_begin instruction pattern:      Standard Names.
* doloop_end instruction pattern:        Standard Names.
* DONE:                                  Expander Definitions.
* DONT_REDUCE_ADDR:                      Costs.
* double-word arithmetic:                Long Long.
* DOUBLE_TYPE_SIZE:                      Type Layout.
* downward funargs:                      Nested Functions.
* driver:                                Driver.
* DW bit (29k):                          AMD29K Options.
* 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.
* DYNAMIC_CHAIN_ADDRESS:                 Frame Layout.
* E in constraint:                       Simple Constraints.
* earlyclobber operand:                  Modifiers.
* EASY_DIV_EXPR:                         Misc.
* EDOM, implicit usage:                  Library Calls.
* EH_FRAME_SECTION_ASM_OP:               Exception Region Output.
* eh_return instruction pattern:         Standard Names.
* EH_RETURN_DATA_REGNO:                  Frame Layout.
* EH_RETURN_HANDLER_RTX:                 Frame Layout.
* EH_RETURN_STACKADJ_RTX:                Frame Layout.
* EH_TABLE_LOOKUP:                       Exception Region Output.
* eight bit data on the H8/300 and H8/300H: Function Attributes.
* 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.
* environment variables:                 Environment Variables.
* 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.
* error messages:                        Warnings and Errors.
* escape sequences, traditional:         C Dialect Options.
* escaped newlines:                      Escaped Newlines.
* exception_receiver instruction pattern: Standard Names.
* EXCEPTION_SECTION:                     Exception Region Output.
* exclamation point:                     Multi-Alternative.
* exclusive-or, bitwise:                 Arithmetic.
* EXECUTABLE_SUFFIX:                     Config.
* exit:                                  Other Builtins.
* exit status and VMS:                   VMS Misc.
* EXIT_BODY:                             Misc.
* EXIT_EXPR:                             Expression trees.
* EXIT_IGNORE_STACK:                     Function Entry.
* EXPAND_BUILTIN_SAVEREGS:               Varargs.
* expander definitions:                  Expander Definitions.
* explicit register variables:           Explicit Reg Vars.
* expr_list:                             Insns.
* EXPR_STMT:                             Function Bodies.
* EXPR_STMT_EXPR:                        Function Bodies.
* expression:                            Expression trees.
* expression codes:                      RTL Objects.
* expressions containing statements:     Statement Exprs.
* expressions, compound, as lvalues:     Lvalues.
* expressions, conditional, as lvalues:  Lvalues.
* expressions, constructor:              Compound Literals.
* extended asm:                          Extended Asm.
* extendMN2 instruction pattern:         Standard Names.
* extensible constraints:                Simple Constraints.
* extensions, ?: <1>:                    Conditionals.
* extensions, ?::                        Lvalues.
* extensions, C language:                C Extensions.
* extensions, C++ language:              C++ Extensions.
* extern int target_flags:               Run-time Target.
* external declaration scope:            Incompatibilities.
* EXTRA_CC_MODES:                        Condition Code.
* EXTRA_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.
* fabs:                                  Other Builtins.
* fabsf:                                 Other Builtins.
* fabsl:                                 Other Builtins.
* FAIL:                                  Expander Definitions.
* fatal signal:                          Bug Criteria.
* FATAL_EXIT_CODE:                       Config.
* FDL, GNU Free Documentation License:   GNU Free Documentation License.
* features, optional, in system conventions: Run-time Target.
* ffs <1>:                               Arithmetic.
* ffs:                                   Other Builtins.
* ffsM2 instruction pattern:             Standard Names.
* FIELD_DECL:                            Declarations.
* file name suffix:                      Overall Options.
* file names:                            Link Options.
* 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.
* flexible array members:                Zero Length.
* float:                                 Conversions.
* float as function value type:          Incompatibilities.
* FLOAT_ARG_TYPE:                        Library Calls.
* 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_VALUE_TYPE:                      Library Calls.
* FLOAT_WORDS_BIG_ENDIAN:                Storage Layout.
* FLOAT_WORDS_BIG_ENDIAN, (lack of) effect on subreg: Regs and Memory.
* FLOATIFY:                              Library Calls.
* floating point and cross compilation:  Cross-compilation.
* Floating Point Emulation:              Target Fragment.
* floating point precision <1>:          Disappointments.
* floating point precision:              Optimize Options.
* 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_PREFERRED_STACK_BOUNDARY_IN_MAIN: Storage Layout.
* force_reg:                             Standard Names.
* format function attribute:             Function Attributes.
* format_arg function attribute:         Function Attributes.
* Fortran:                               G++ and GCC.
* forwarding calls:                      Constructing Calls.
* fprintf:                               Other Builtins.
* fputs:                                 Other Builtins.
* 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, inmem:                  Flags.
* free_machine_status:                   Per-Function Data.
* freestanding environment:              Standards.
* freestanding implementation:           Standards.
* fscanf, and constant strings:          Incompatibilities.
* ftruncM2 instruction pattern:          Standard Names.
* function:                              Functions.
* function addressability on the M32R/D: Function Attributes.
* function attributes:                   Function Attributes.
* function body:                         Function Bodies.
* function call conventions:             Interface.
* function entry and exit:               Function Entry.
* function pointers, arithmetic:         Pointer Arith.
* function prototype declarations:       Function Prototypes.
* function units, for scheduling:        Function Units.
* function without a prologue/epilogue code: Function Attributes.
* function, size of pointer to:          Pointer Arith.
* 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_REGNO_P:                  Register Arguments.
* FUNCTION_BLOCK_PROFILER:               Profiling.
* FUNCTION_BLOCK_PROFILER_EXIT:          Profiling.
* FUNCTION_BOUNDARY:                     Storage Layout.
* FUNCTION_CONVERSION_BUG:               Config.
* FUNCTION_DECL:                         Functions.
* FUNCTION_EPILOGUE:                     Function Entry.
* FUNCTION_EPILOGUE and trampolines:     Trampolines.
* FUNCTION_INCOMING_ARG:                 Register Arguments.
* FUNCTION_MODE:                         Misc.
* FUNCTION_OK_FOR_SIBCALL:               Tail Calling.
* FUNCTION_OUTGOING_VALUE:               Scalar Return.
* FUNCTION_PROFILER:                     Profiling.
* FUNCTION_PROLOGUE:                     Function Entry.
* FUNCTION_PROLOGUE and trampolines:     Trampolines.
* FUNCTION_TYPE:                         Types.
* FUNCTION_VALUE:                        Scalar Return.
* FUNCTION_VALUE_REGNO_P:                Scalar Return.
* functions called via pointer on the RS/6000 and PowerPC: Function Attributes.
* functions in arbitrary sections:       Function Attributes.
* functions that are passed arguments in registers on the 386: Function Attributes.
* functions that behave like malloc:     Function Attributes.
* functions that do not pop the argument stack on the 386: Function Attributes.
* functions that do pop the argument stack on the 386: Function Attributes.
* functions that have no side effects:   Function Attributes.
* functions that never return:           Function Attributes.
* functions that pop the argument stack on the 386: Function Attributes.
* functions which are exported from a dll on PowerPC Windows NT: Function Attributes.
* functions which are imported from a dll on PowerPC Windows NT: Function Attributes.
* functions which specify exception handling on PowerPC Windows NT: Function Attributes.
* functions with printf, scanf, strftime or strfmon style arguments: Function Attributes.
* functions, leaf:                       Leaf Functions.
* fundamental type:                      Types.
* g in constraint:                       Simple Constraints.
* G in constraint:                       Simple Constraints.
* g++:                                   Invoking G++.
* G++:                                   G++ and GCC.
* GCC:                                   G++ and GCC.
* GCC and portability:                   Portability.
* GCC command options:                   Invoking GCC.
* gcc-bugs@gcc.gnu.org or bug-gcc@gnu.org: Bug Lists.
* GCC_DRIVER_HOST_INITIALIZATION:        Config.
* GCC_EXEC_PREFIX:                       Environment Variables.
* gccbug script:                         gccbug.
* 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.
* generalized lvalues:                   Lvalues.
* 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 offset table:                   Code Gen Options.
* global register after longjmp:         Global Reg Vars.
* global register allocation:            Passes.
* global register variables:             Global Reg Vars.
* GLOBAL_INIT_PRIORITY:                  Function Basics.
* GLOBALDEF:                             Global Declarations.
* GLOBALREF:                             Global Declarations.
* GLOBALVALUEDEF:                        Global Declarations.
* GLOBALVALUEREF:                        Global Declarations.
* GO_IF_LEGITIMATE_ADDRESS:              Addressing Modes.
* GO_IF_MODE_DEPENDENT_ADDRESS:          Addressing Modes.
* goto with computed label:              Labels as Values.
* GOTO_DESTINATION:                      Function Bodies.
* GOTO_STMT:                             Function Bodies.
* gp-relative references (MIPS):         MIPS Options.
* gprof:                                 Debugging Options.
* greater than:                          Comparisons.
* grouping options:                      Invoking GCC.
* 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.
* hardware models and configurations, specifying: Submodel Options.
* HAS_INIT_SECTION:                      Macros for Initialization.
* 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.
* header files and VMS:                  Include Files and VMS.
* hex floats:                            Hex Floats.
* high:                                  Constants.
* HImode:                                Machine Modes.
* HImode, in insn:                       Insns.
* host makefile fragment:                Host Fragment.
* HOST_BIT_BUCKET:                       Config.
* HOST_BITS_PER_CHAR:                    Config.
* HOST_BITS_PER_INT:                     Config.
* HOST_BITS_PER_LONG:                    Config.
* HOST_BITS_PER_LONGLONG:                Config.
* HOST_BITS_PER_SHORT:                   Config.
* HOST_FLOAT_FORMAT:                     Config.
* HOST_FLOAT_WORDS_BIG_ENDIAN:           Config.
* HOST_WORDS_BIG_ENDIAN:                 Config.
* hosted environment <1>:                C Dialect Options.
* hosted environment:                    Standards.
* hosted implementation:                 Standards.
* HPPA Options:                          HPPA Options.
* I in constraint:                       Simple Constraints.
* i in constraint:                       Simple Constraints.
* i386 Options:                          i386 Options.
* IA-64 Options:                         IA-64 Options.
* IBM RS/6000 and PowerPC Options:       RS/6000 and PowerPC Options.
* IBM RT options:                        RT Options.
* IBM RT PC:                             Interoperation.
* IBM_FLOAT_FORMAT:                      Storage Layout.
* identifier:                            Identifiers.
* identifier names, dollar signs in:     Dollar Signs.
* IDENTIFIER_LENGTH:                     Identifiers.
* IDENTIFIER_NODE:                       Identifiers.
* IDENTIFIER_OPNAME_P:                   Identifiers.
* IDENTIFIER_POINTER:                    Identifiers.
* IDENTIFIER_TYPENAME_P:                 Identifiers.
* identifiers, names in assembler code:  Asm Labels.
* identifying source, compiler (88k):    M88K Options.
* 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.
* imaxabs:                               Other Builtins.
* immediate_operand:                     RTL Template.
* IMMEDIATE_PREFIX:                      Instruction Output.
* IMPLICIT_FIX_EXPR:                     Misc.
* implied #pragma implementation:        C++ Interface.
* 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 files and VMS:                 Include Files and VMS.
* INCLUDE_DEFAULTS:                      Driver.
* inclusive-or, bitwise:                 Arithmetic.
* INCOMING_FRAME_SP_OFFSET:              Frame Layout.
* INCOMING_REGNO:                        Register Basics.
* INCOMING_RETURN_ADDR_RTX:              Frame Layout.
* incompatibilities of GCC:              Incompatibilities.
* increment operators:                   Bug Criteria.
* index:                                 Other Builtins.
* INDEX_REG_CLASS:                       Register Classes.
* indirect calls on ARM:                 Function Attributes.
* 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_priority attribute:               C++ Attributes.
* 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.
* initializations in expressions:        Compound Literals.
* INITIALIZE_TRAMPOLINE:                 Trampolines.
* initializers with labeled elements:    Designated Inits.
* initializers, non-constant:            Initializers.
* inline automatic for C++ member fns:   Inline.
* inline functions:                      Inline.
* inline functions, omission of:         Inline.
* inline on rtx, automatic:              Passes.
* inline on trees, automatic:            Passes.
* inlining:                              Inlining.
* inlining and C++ pragmas:              C++ Interface.
* INSERT_ATTRIBUTES:                     Misc.
* insn:                                  Insns.
* insn and /i:                           Flags.
* insn and /s:                           Flags.
* insn and /u:                           Flags.
* insn attributes:                       Insn Attributes.
* insn canonicalization:                 Insn Canonicalizations.
* 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_DELETED_P:                        Flags.
* INSN_FROM_TARGET_P:                    Flags.
* insn_list:                             Insns.
* INSN_REFERENCES_ARE_DELAYED:           Misc.
* INSN_SETS_ARE_DELAYED:                 Misc.
* INSN_UID:                              Insns.
* insns:                                 Insns.
* insns, generating:                     RTL Template.
* insns, recognizing:                    RTL Template.
* INSTALL:                               Host Fragment.
* installation trouble:                  Trouble.
* installing GNU CC:                     Installation.
* installing GNU CC on VMS:              VMS Install.
* 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.
* integrating function code:             Inline.
* Intel 386 Options:                     i386 Options.
* Interdependence of Patterns:           Dependent Patterns.
* interface and implementation headers, C++: C++ Interface.
* interfacing to GCC output:             Interface.
* intermediate C version, nonexistent:   G++ and GCC.
* interrupt handler functions:           Function Attributes.
* interrupt handler functions on the H8/300 and SH processors: Function Attributes.
* INTIFY:                                Library Calls.
* INTMAX_TYPE:                           Type Layout.
* introduction:                          Top.
* invalid assembly code:                 Bug Criteria.
* invalid input:                         Bug Criteria.
* INVOKE__main:                          Macros for Initialization.
* invoking g++:                          Invoking G++.
* 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.
* ISO 9899:                              Standards.
* ISO C:                                 Standards.
* ISO C standard:                        Standards.
* ISO C89:                               Standards.
* ISO C90:                               Standards.
* ISO C94:                               Standards.
* ISO C95:                               Standards.
* ISO C99:                               Standards.
* ISO C9X:                               Standards.
* ISO support:                           C Dialect Options.
* ISO/IEC 9899:                          Standards.
* ISSUE_RATE:                            Misc.
* Java:                                  G++ and GCC.
* java_interface attribute:              C++ Attributes.
* jump instruction pattern:              Standard Names.
* jump instruction patterns:             Jump Patterns.
* jump instructions and set:             Side Effects.
* jump optimization:                     Passes.
* jump threading:                        Passes.
* jump_insn:                             Insns.
* JUMP_LABEL:                            Insns.
* JUMP_TABLES_IN_TEXT_SECTION:           Sections.
* kernel and user registers (29k):       AMD29K Options.
* keywords, alternate:                   Alternate Keywords.
* known causes of trouble:               Trouble.
* 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, RTL sharing:                Sharing.
* LABEL_STMT:                            Function Bodies.
* LABEL_STMT_LABEL:                      Function Bodies.
* labeled elements in initializers:      Designated Inits.
* labels as values:                      Labels as Values.
* labs:                                  Other Builtins.
* LANG:                                  Environment Variables.
* language dialect options:              C Dialect Options.
* large bit shifts (88k):                M88K Options.
* large return values:                   Aggregate Return.
* LAST_STACK_REG:                        Stack Registers.
* LAST_VIRTUAL_REGISTER:                 Regs and Memory.
* LC_ALL:                                Environment Variables.
* LC_CTYPE:                              Environment Variables.
* LC_MESSAGES:                           Environment Variables.
* 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.
* length-zero arrays:                    Zero Length.
* 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.
* LIBGCC1:                               Target Fragment.
* LIBGCC2_CFLAGS:                        Target Fragment.
* LIBGCC2_WORDS_BIG_ENDIAN:              Storage Layout.
* LIBGCC_NEEDS_DOUBLE:                   Library Calls.
* LIBGCC_SPEC:                           Driver.
* Libraries:                             Link Options.
* library subroutine names:              Library Calls.
* LIBRARY_PATH:                          Environment Variables.
* LIBRARY_PATH_ENV:                      Misc.
* LIMIT_RELOAD_CLASS:                    Register Classes.
* link options:                          Link Options.
* LINK_COMMAND_SPEC:                     Driver.
* LINK_ELIMINATE_DUPLICATE_LDIRECTORIES: 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.
* LL integer suffix:                     Long Long.
* llabs:                                 Other Builtins.
* lo_sum:                                Arithmetic.
* load address instruction:              Simple Constraints.
* LOAD_ARGS_REVERSED:                    Register Arguments.
* LOAD_EXTEND_OP:                        Misc.
* load_multiple instruction pattern:     Standard Names.
* local labels:                          Local Labels.
* local register allocation:             Passes.
* local variables in macros:             Naming Types.
* local variables, specifying registers: Local Reg Vars.
* LOCAL_ALIGNMENT:                       Storage Layout.
* LOCAL_CLASS_P:                         Classes.
* LOCAL_INCLUDE_DIR:                     Driver.
* LOCAL_LABEL_PREFIX:                    Instruction Output.
* LOCAL_REGNO:                           Register Basics.
* locale:                                Environment Variables.
* locale definition:                     Environment Variables.
* LOG_LINKS:                             Insns.
* logical-and, bitwise:                  Arithmetic.
* long long data types:                  Long Long.
* LONG_DOUBLE_TYPE_SIZE:                 Type Layout.
* LONG_LONG_TYPE_SIZE:                   Type Layout.
* LONG_TYPE_SIZE:                        Type Layout.
* longjmp:                               Global Reg Vars.
* longjmp and automatic variables <1>:   Interface.
* longjmp and automatic variables:       C Dialect Options.
* longjmp incompatibilities:             Incompatibilities.
* longjmp warnings:                      Warning Options.
* LONGJMP_RESTORE_FROM_STACK:            Elimination.
* 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.
* lvalues, generalized:                  Lvalues.
* m in constraint:                       Simple Constraints.
* M32R/D options:                        M32R/D Options.
* M680x0 options:                        M680x0 Options.
* M68hc1x options:                       M68hc1x Options.
* M88k options:                          M88K Options.
* machine dependent options:             Submodel Options.
* machine description macros:            Target Macros.
* machine descriptions:                  Machine Desc.
* machine mode conversions:              Conversions.
* machine modes:                         Machine Modes.
* machine specific constraints:          Machine Constraints.
* MACHINE_DEPENDENT_REORG:               Misc.
* MACHINE_STATE_RESTORE:                 Profiling.
* MACHINE_STATE_SAVE:                    Profiling.
* macro with variable arguments:         Variadic Macros.
* macros containing asm:                 Extended Asm.
* macros, inline alternative:            Inline.
* macros, local labels:                  Local Labels.
* macros, local variables in:            Naming Types.
* macros, statements in expressions:     Statement Exprs.
* macros, target description:            Target Macros.
* macros, types of arguments:            Typeof.
* main and the exit status:              VMS Misc.
* make:                                  Preprocessor Options.
* MAKE_DECL_ONE_ONLY (DECL):             Label Output.
* make_safe_from:                        Expander Definitions.
* makefile fragment:                     Fragments.
* makefile targets:                      Makefile.
* malloc attribute:                      Function Attributes.
* mark_machine_status:                   Per-Function Data.
* MASK_RETURN_ADDR:                      Exception Region Output.
* match_dup <1>:                         define_peephole2.
* match_dup:                             RTL Template.
* 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_INT_TYPE_SIZE:                     Type Layout.
* MAX_INTEGER_COMPUTATION_MODE:          Misc.
* 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.
* maximum operator:                      Min and Max.
* MAYBE_REG_PARM_STACK_SPACE:            Stack Arguments.
* MCore options:                         MCore Options.
* mcount:                                Profiling.
* MD_ASM_CLOBBERS:                       Misc.
* MD_EXEC_PREFIX:                        Driver.
* MD_EXPAND_BUILTIN:                     Misc.
* MD_INIT_BUILTINS:                      Misc.
* MD_SCHED_FINISH:                       Misc.
* MD_SCHED_INIT:                         Misc.
* MD_SCHED_REORDER:                      Misc.
* MD_SCHED_REORDER2:                     Misc.
* MD_SCHED_VARIABLE_ISSUE:               Misc.
* MD_STARTFILE_PREFIX:                   Driver.
* MD_STARTFILE_PREFIX_1:                 Driver.
* mem:                                   Regs and Memory.
* mem and /f:                            Flags.
* mem and /s:                            Flags.
* mem and /u:                            Flags.
* mem and /v:                            Flags.
* mem, RTL sharing:                      Sharing.
* MEM_ALIAS_SET:                         Flags.
* MEM_IN_STRUCT_P:                       Flags.
* MEM_SCALAR_P:                          Flags.
* MEM_VOLATILE_P:                        Flags.
* member fns, automatically inline:      Inline.
* memcmp:                                Other Builtins.
* memcpy:                                Other Builtins.
* memcpy, implicit usage:                Library Calls.
* memmove, implicit usage:               Library Calls.
* memory model (29k):                    AMD29K Options.
* memory reference, nonoffsettable:      Simple Constraints.
* memory references in constraints:      Simple Constraints.
* MEMORY_MOVE_COST:                      Costs.
* memset:                                Other Builtins.
* memset, implicit usage:                Library Calls.
* MERGE_MACHINE_DECL_ATTRIBUTES:         Misc.
* MERGE_MACHINE_TYPE_ATTRIBUTES:         Misc.
* message formatting:                    Language Independent Options.
* messages, warning:                     Warning Options.
* messages, warning and error:           Warnings and Errors.
* METHOD_TYPE:                           Types.
* middle-operands, omitted:              Conditionals.
* MIN_UNITS_PER_WORD:                    Storage Layout.
* minimum operator:                      Min and Max.
* MINIMUM_ATOMIC_ALIGNMENT:              Storage Layout.
* minus:                                 Arithmetic.
* minus and attributes:                  Expressions.
* minus, canonicalization of:            Insn Canonicalizations.
* MINUS_EXPR:                            Expression trees.
* MIPS options:                          MIPS Options.
* misunderstandings in C++:              C++ Misunderstandings.
* mixed declarations and code:           Mixed Declarations.
* mktemp, and constant strings:          Incompatibilities.
* MN10200 options:                       MN10200 Options.
* MN10300 options:                       MN10300 Options.
* mod:                                   Arithmetic.
* mod and attributes:                    Expressions.
* MODDI3_LIBCALL:                        Library Calls.
* mode attribute:                        Variable Attributes.
* mode classes:                          Machine Modes.
* mode switching:                        Mode Switching.
* 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.
* multi-line string literals:            Multi-line Strings.
* MULTIBYTE_CHARS:                       Config.
* 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.
* multiprecision arithmetic:             Long Long.
* 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.
* name augmentation:                     VMS Misc.
* named patterns and conditions:         Patterns.
* names used in assembler code:          Asm Labels.
* names, pattern:                        Standard Names.
* namespace:                             Namespaces.
* namespace, class, scope:               Scopes.
* NAMESPACE_DECL <1>:                    Declarations.
* NAMESPACE_DECL:                        Namespaces.
* naming convention, implementation headers: C++ Interface.
* naming types:                          Naming Types.
* 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:                      Nested Functions.
* nested functions, trampolines for:     Trampolines.
* newline vs string constants:           C Dialect Options.
* newlines (escaped):                    Escaped Newlines.
* next_cc0_user:                         Jump Patterns.
* NEXT_INSN:                             Insns.
* NEXT_OBJC_RUNTIME:                     Library Calls.
* nil:                                   RTL Objects.
* no-op move instructions:               Passes.
* NO_AUTO_EXE_SUFFIX:                    Config.
* NO_BUILTIN_PTRDIFF_TYPE:               Driver.
* NO_BUILTIN_SIZE_TYPE:                  Driver.
* NO_BUILTIN_WCHAR_TYPE:                 Driver.
* NO_BUILTIN_WINT_TYPE:                  Driver.
* no_check_memory_usage function attribute: Function Attributes.
* 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_instrument_function function attribute: Function Attributes.
* no_new_pseudos:                        Standard Names.
* NO_PROFILE_COUNTERS:                   Profiling.
* NO_RECURSIVE_FUNCTION_CSE:             Costs.
* NO_REGS:                               Register Classes.
* nocommon attribute:                    Variable Attributes.
* non-constant initializers:             Initializers.
* non-static inline function:            Inline.
* NON_SAVING_SETJMP:                     Register Basics.
* nongcc_SI_type:                        Library Calls.
* nongcc_word_type:                      Library Calls.
* 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.
* noreturn function attribute:           Function Attributes.
* 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_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.
* NS32K options:                         NS32K Options.
* NUM_MACHINE_MODES:                     Machine Modes.
* NUM_MODES_FOR_MODE_SWITCHING:          Mode Switching.
* o in constraint:                       Simple Constraints.
* OBJC_GEN_METHOD_LABEL:                 Label Output.
* OBJC_INCLUDE_PATH:                     Environment Variables.
* OBJC_INT_SELECTORS:                    Type Layout.
* OBJC_PROLOGUE:                         File Framework.
* OBJC_SELECTORS_WITHOUT_LABELS:         Type Layout.
* OBJECT_FORMAT_COFF:                    Macros for Initialization.
* OBJECT_FORMAT_ROSE:                    Macros for Initialization.
* OBJECT_SUFFIX:                         Config.
* Objective C:                           G++ and GCC.
* Objective-C options, command line:     Objective-C Dialect Options.
* OBSTACK_CHUNK_ALLOC:                   Config.
* OBSTACK_CHUNK_FREE:                    Config.
* OBSTACK_CHUNK_SIZE:                    Config.
* OCS (88k):                             M88K Options.
* OFFSET_TYPE:                           Types.
* offsettable address:                   Simple Constraints.
* OImode:                                Machine Modes.
* old-style function definitions:        Function Prototypes.
* OLDAR:                                 Host Fragment.
* OLDCC:                                 Host Fragment.
* OMIT_EH_TABLE:                         Exception Region Output.
* omitted middle-operands:               Conditionals.
* ON_EXIT:                               Misc.
* one_cmplM2 instruction pattern:        Standard Names.
* ONLY_INT_FIELDS:                       Config.
* open coding:                           Inline.
* operand access:                        Accessors.
* operand constraints:                   Constraints.
* operand substitution:                  Output Template.
* operands:                              Patterns.
* OPTIMIZATION_OPTIONS:                  Run-time Target.
* optimize options:                      Optimize Options.
* OPTIMIZE_MODE_SWITCHING:               Mode Switching.
* optional hardware or system features:  Run-time Target.
* options to control diagnostics formatting: Language Independent Options.
* options to control warnings:           Warning Options.
* options, C++:                          C++ Dialect Options.
* options, code generation:              Code Gen Options.
* options, debugging:                    Debugging Options.
* options, dialect:                      C Dialect Options.
* options, directory search:             Directory Options.
* options, GCC command:                  Invoking GCC.
* options, grouping:                     Invoking GCC.
* options, linking:                      Link Options.
* options, Objective-C:                  Objective-C Dialect Options.
* options, optimization:                 Optimize Options.
* options, order:                        Invoking GCC.
* options, preprocessor:                 Preprocessor Options.
* order of evaluation, side effects:     Non-bugs.
* order of options:                      Invoking GCC.
* order of register allocation:          Allocation Order.
* 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 file option:                    Overall Options.
* output of assembler code:              File Framework.
* output statements:                     Output Statement.
* output templates:                      Output Template.
* output_addr_const:                     Data Output.
* OUTPUT_ADDR_CONST_EXTRA:               Data Output.
* output_asm_insn:                       Output Statement.
* OUTPUT_QUOTED_STRING:                  File Framework.
* overflow while constant folding:       Cross-compilation.
* OVERLOAD:                              Functions.
* overloaded virtual fn, warning:        C++ Dialect Options.
* OVERRIDE_OPTIONS:                      Run-time Target.
* OVL_CURRENT:                           Functions.
* OVL_NEXT:                              Functions.
* p in constraint:                       Simple Constraints.
* packed attribute:                      Variable Attributes.
* PAD_VARARGS_DOWN:                      Register Arguments.
* parallel:                              Side Effects.
* parameter forward declaration:         Variable Length.
* parameters, aliased:                   Code Gen Options.
* 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:                        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.
* perform_...:                           Library Calls.
* PIC <1>:                               PIC.
* PIC:                                   Code Gen Options.
* 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.
* pmf:                                   Bound member functions.
* Pmode:                                 Misc.
* pointer:                               Types.
* pointer arguments:                     Function Attributes.
* pointer to member function:            Bound member functions.
* POINTER_SIZE:                          Storage Layout.
* POINTER_TYPE:                          Types.
* POINTERS_EXTEND_UNSIGNED:              Storage Layout.
* portability:                           Portability.
* portions of temporary objects, pointers to: Temporaries.
* position independent code:             PIC.
* POSIX:                                 Config.
* post_dec:                              Incdec.
* post_inc:                              Incdec.
* post_modify:                           Incdec.
* pragma:                                Misc.
* pragma, reason for not using:          Function Attributes.
* pragmas in C++, effect on inlining:    C++ Interface.
* pragmas, interface and implementation: C++ Interface.
* pragmas, warning of unknown:           Warning Options.
* pre_dec:                               Incdec.
* 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.
* preprocessing numbers:                 Incompatibilities.
* preprocessing tokens:                  Incompatibilities.
* preprocessor options:                  Preprocessor Options.
* 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.
* printf:                                Other Builtins.
* probe instruction pattern:             Standard Names.
* processor selection (29k):             AMD29K Options.
* product:                               Arithmetic.
* prof:                                  Debugging Options.
* PROFILE_BEFORE_PROLOGUE:               Profiling.
* profile_block_flag:                    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.
* promotion of formal parameters:        Function Prototypes.
* 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.
* pure function attribute:               Function Attributes.
* 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.
* PUT_CODE:                              RTL Objects.
* PUT_MODE:                              Machine Modes.
* PUT_REG_NOTE_KIND:                     Insns.
* PUT_SDB_...:                           SDB and DWARF.
* QImode:                                Machine Modes.
* QImode, in insn:                       Insns.
* qsort, and global register variables:  Global Reg Vars.
* qualified type:                        Types.
* question mark:                         Multi-Alternative.
* quotient:                              Arithmetic.
* r in constraint:                       Simple Constraints.
* r0-relative references (88k):          M88K Options.
* ranges in case statements:             Case Ranges.
* RDIV_EXPR:                             Expression trees.
* read-only strings:                     Incompatibilities.
* 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_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 /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_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 positions in frame (88k):     M88K Options.
* Register Transfer Language (RTL):      RTL.
* register usage:                        Registers.
* register use analysis:                 Passes.
* register variable after longjmp:       Global Reg Vars.
* register-to-stack conversion:          Passes.
* REGISTER_MOVE_COST:                    Costs.
* REGISTER_NAMES:                        Instruction Output.
* register_operand:                      RTL Template.
* REGISTER_PREFIX:                       Instruction Output.
* REGISTER_TARGET_PRAGMAS:               Misc.
* registers:                             Extended Asm.
* registers arguments:                   Register Arguments.
* registers for local variables:         Local Reg Vars.
* registers in constraints:              Simple Constraints.
* registers, global allocation:          Explicit Reg Vars.
* registers, global variables in:        Global Reg Vars.
* 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.
* reordering, warning <1>:               Warning Options.
* reordering, warning:                   C++ Dialect Options.
* reporting bugs:                        Bugs.
* representation of RTL:                 RTL.
* rest argument (in macro):              Variadic Macros.
* 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.
* restricted pointers:                   Restricted Pointers.
* restricted references:                 Restricted Pointers.
* restricted this pointer:               Restricted Pointers.
* RESULT_DECL:                           Declarations.
* return:                                Side Effects.
* return instruction pattern:            Standard Names.
* return value of main:                  VMS Misc.
* 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_CONDITION (CODE, MODE):        Condition Code.
* REVERSIBLE_CC_MODE:                    Condition Code.
* right rotate:                          Arithmetic.
* right shift:                           Arithmetic.
* rindex:                                Other Builtins.
* 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.
* RS/6000 and PowerPC Options:           RS/6000 and PowerPC Options.
* RSHIFT_EXPR:                           Expression trees.
* RT options:                            RT Options.
* RT PC:                                 Interoperation.
* 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.
* RTTI:                                  Vague Linkage.
* 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 options:                      Code Gen Options.
* run-time target specification:         Run-time Target.
* s in constraint:                       Simple Constraints.
* S/390 and zSeries Options:             S/390 and zSeries Options.
* 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.
* scanf, and constant strings:           Incompatibilities.
* SCCS_DIRECTIVE:                        Misc.
* SCHED_GROUP_P:                         Flags.
* scheduling, delayed branch:            Passes.
* scheduling, instruction:               Passes.
* SCmode:                                Machine Modes.
* sCOND instruction pattern:             Standard Names.
* scope of a variable length array:      Variable Length.
* scope of declaration:                  Disappointments.
* scope of external declarations:        Incompatibilities.
* 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 path:                           Directory Options.
* second include path:                   Preprocessor Options.
* 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.
* section function attribute:            Function Attributes.
* section variable attribute:            Variable Attributes.
* SELECT_CC_MODE:                        Condition Code.
* SELECT_RTX_SECTION:                    Sections.
* SELECT_SECTION:                        Sections.
* sequence:                              Side Effects.
* sequential consistency on 88k:         M88K Options.
* set:                                   Side Effects.
* SET_ASM_OP:                            Label Output.
* set_attr:                              Tagging Insns.
* set_attr_alternative:                  Tagging Insns.
* SET_DEFAULT_DECL_ATTRIBUTES:           Misc.
* SET_DEFAULT_TYPE_ATTRIBUTES:           Misc.
* SET_DEST:                              Side Effects.
* SET_SRC:                               Side Effects.
* setjmp:                                Global Reg Vars.
* setjmp incompatibilities:              Incompatibilities.
* SETUP_FRAME_ADDRESSES:                 Frame Layout.
* SETUP_INCOMING_VARARGS:                Varargs.
* SFmode:                                Machine Modes.
* shared strings:                        Incompatibilities.
* shared variable attribute:             Variable Attributes.
* shared VMS run time system:            VMS Misc.
* 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 calls:                         Tail Calling.
* side effect in ?::                     Conditionals.
* side effects, macro argument:          Statement Exprs.
* side effects, order of evaluation:     Non-bugs.
* sign_extend:                           Conversions.
* sign_extract:                          Bit-Fields.
* sign_extract, canonicalization of:     Insn Canonicalizations.
* signal handler functions on the AVR processors: Function Attributes.
* signed and unsigned values, comparison warning: Warning Options.
* signed division:                       Arithmetic.
* signed maximum:                        Arithmetic.
* signed minimum:                        Arithmetic.
* SIGNED_CHAR_SPEC:                      Driver.
* SImode:                                Machine Modes.
* simple constraints:                    Simple Constraints.
* simplifications, arithmetic:           Passes.
* sin:                                   Other Builtins.
* sinf:                                  Other Builtins.
* Single Static Assignment optimizations: Passes.
* sinl:                                  Other Builtins.
* SIZE_TYPE:                             Type Layout.
* sizeof:                                Typeof.
* SLOW_BYTE_ACCESS:                      Costs.
* SLOW_UNALIGNED_ACCESS:                 Costs.
* SLOW_ZERO_EXTEND:                      Costs.
* SMALL_REGISTER_CLASSES:                Register Classes.
* SMALL_STACK:                           Frame Layout.
* smaller data references:               M32R/D Options.
* smaller data references (88k):         M88K Options.
* smaller data references (MIPS):        MIPS Options.
* smaller data references (PowerPC):     RS/6000 and PowerPC Options.
* smax:                                  Arithmetic.
* smaxM3 instruction pattern:            Standard Names.
* smin:                                  Arithmetic.
* sminM3 instruction pattern:            Standard Names.
* smulM3_highpart instruction pattern:   Standard Names.
* SPARC options:                         SPARC Options.
* Spec Files:                            Spec Files.
* SPECIAL_MODE_PREDICATES:               Misc.
* specified registers:                   Explicit Reg Vars.
* specifying compiler version and target machine: Target Options.
* specifying hardware config:            Submodel Options.
* specifying machine version:            Target Options.
* specifying registers for local variables: Local Reg Vars.
* speed of instructions:                 Costs.
* splitting instructions:                Insn Splitting.
* sqrt <1>:                              Arithmetic.
* sqrt:                                  Other Builtins.
* sqrtf:                                 Other Builtins.
* sqrtl:                                 Other Builtins.
* sqrtM2 instruction pattern:            Standard Names.
* square root:                           Arithmetic.
* ss_minus:                              Arithmetic.
* ss_plus:                               Arithmetic.
* ss_truncate:                           Conversions.
* SSA DCE:                               Passes.
* SSA optimizations:                     Passes.
* sscanf, and constant strings:          Incompatibilities.
* stack arguments:                       Stack Arguments.
* stack checks (29k):                    AMD29K Options.
* 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_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.
* start files:                           Tools and Libraries.
* START_CATCH_STMT:                      Function Bodies.
* START_CATCH_TYPE:                      Function Bodies.
* STARTFILE_SPEC:                        Driver.
* STARTING_FRAME_OFFSET:                 Frame Layout.
* STARTING_FRAME_OFFSET and virtual registers: Regs and Memory.
* statements:                            Function Bodies.
* statements inside expressions:         Statement Exprs.
* static data in C++, declaring and defining: Static Definitions.
* STATIC_CHAIN:                          Frame Registers.
* STATIC_CHAIN_INCOMING:                 Frame Registers.
* STATIC_CHAIN_INCOMING_REGNUM:          Frame Registers.
* STATIC_CHAIN_REGNUM:                   Frame Registers.
* stdarg.h and register arguments:       Register Arguments.
* stdarg.h and RT PC:                    RT Options.
* 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.
* storem bug (29k):                      AMD29K Options.
* strcat:                                Other Builtins.
* strchr:                                Other Builtins.
* strcmp:                                Other Builtins.
* strcpy <1>:                            Storage Layout.
* strcpy:                                Other Builtins.
* strcspn:                               Other Builtins.
* strength-reduction:                    Passes.
* STRICT_ALIGNMENT:                      Storage Layout.
* STRICT_ARGUMENT_NAMING:                Varargs.
* strict_low_part:                       RTL Declarations.
* strict_memory_address_p:               Addressing Modes.
* string constants:                      Incompatibilities.
* string constants vs newline:           C Dialect Options.
* STRING_CST:                            Expression trees.
* STRIP_NAME_ENCODING:                   Sections.
* strlen:                                Other Builtins.
* strlenM instruction pattern:           Standard Names.
* strncat:                               Other Builtins.
* strncmp:                               Other Builtins.
* strncpy:                               Other Builtins.
* strpbrk:                               Other Builtins.
* strrchr:                               Other Builtins.
* strspn:                                Other Builtins.
* strstr:                                Other Builtins.
* STRUCT_FORCE_BLK:                      Storage Layout.
* STRUCT_VALUE:                          Aggregate Return.
* STRUCT_VALUE_INCOMING:                 Aggregate Return.
* STRUCT_VALUE_INCOMING_REGNUM:          Aggregate Return.
* STRUCT_VALUE_REGNUM:                   Aggregate Return.
* structure passing (88k):               M88K Options.
* structure value address:               Aggregate Return.
* STRUCTURE_SIZE_BOUNDARY:               Storage Layout.
* structures:                            Incompatibilities.
* structures, constructor expression:    Compound Literals.
* structures, returning:                 Interface.
* subM3 instruction pattern:             Standard Names.
* submodel options:                      Submodel Options.
* 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_PROMOTED_UNSIGNED_P:            Flags.
* SUBREG_PROMOTED_VAR_P:                 Flags.
* SUBREG_REG:                            Regs and Memory.
* SUBREG_WORD:                           Regs and Memory.
* subscripting:                          Subscripting.
* subscripting and function values:      Subscripting.
* SUCCESS_EXIT_CODE:                     Config.
* suffixes for C++ source:               Invoking G++.
* SUPPORTS_INIT_PRIORITY:                Macros for Initialization.
* SUPPORTS_ONE_ONLY:                     Label Output.
* SUPPORTS_WEAK:                         Label Output.
* suppressing warnings:                  Warning Options.
* surprises in C++:                      C++ Misunderstandings.
* SVr4:                                  M88K Options.
* 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 /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.
* syntax checking:                       Warning Options.
* synthesized methods, warning:          C++ Dialect Options.
* system headers, warnings from:         Warning Options.
* SYSTEM_INCLUDE_DIR:                    Driver.
* t-TARGET:                              Target Fragment.
* tablejump instruction pattern:         Standard Names.
* tagging insns:                         Tagging Insns.
* tail calls:                            Tail Calling.
* tail recursion optimization:           Passes.
* target description macros:             Target Macros.
* target machine, specifying:            Target Options.
* target makefile fragment:              Target Fragment.
* target options:                        Target Options.
* target specifications:                 Run-time Target.
* target-parameter-dependent code:       Passes.
* TARGET_ALLOWS_PROFILING_WITHOUT_FRAME_POINTER: Profiling.
* TARGET_BELL:                           Type Layout.
* TARGET_BS:                             Type Layout.
* TARGET_CR:                             Type Layout.
* TARGET_EDOM:                           Library Calls.
* TARGET_FF:                             Type Layout.
* TARGET_FLOAT_FORMAT:                   Storage Layout.
* TARGET_HAS_F_SETLKW:                   Misc.
* TARGET_MEM_FUNCTIONS:                  Library Calls.
* TARGET_NEWLINE:                        Type Layout.
* TARGET_OPTIONS:                        Run-time Target.
* TARGET_PTRMEMFUNC_VBIT_LOCATION:       Type Layout.
* TARGET_SWITCHES:                       Run-time Target.
* TARGET_TAB:                            Type Layout.
* TARGET_VERSION:                        Run-time Target.
* TARGET_VT:                             Type Layout.
* targets, makefile:                     Makefile.
* TC1:                                   Standards.
* TC2:                                   Standards.
* TCmode:                                Machine Modes.
* tcov:                                  Debugging Options.
* Technical Corrigenda:                  Standards.
* Technical Corrigendum 1:               Standards.
* Technical Corrigendum 2:               Standards.
* template instantiation:                Template Instantiation.
* TEMPLATE_DECL:                         Declarations.
* temporaries, lifetime of:              Temporaries.
* termination routines:                  Initialization.
* 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.
* thunks:                                Nested Functions.
* TImode:                                Machine Modes.
* TImode, in insn:                       Insns.
* tiny data section on the H8/300H:      Function Attributes.
* tm.h macros:                           Target Macros.
* TMPDIR:                                Environment Variables.
* TMS320C3x/C4x Options:                 TMS320C3x/C4x Options.
* top level of compiler:                 Passes.
* traditional C language:                C Dialect Options.
* 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>:                         Expression trees.
* TREE_TYPE <2>:                         Function Basics.
* 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 alignment:                        Alignment.
* type attributes:                       Type Attributes.
* 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>:                       Classes.
* TYPE_FIELDS:                           Types.
* TYPE_HAS_ARRAY_NEW_OPERATOR:           Classes.
* TYPE_HAS_DEFAULT_CONSTRUCTOR:          Classes.
* TYPE_HAS_MUTABLE_P:                    Classes.
* TYPE_HAS_NEW_OPERATOR:                 Classes.
* type_info:                             Vague Linkage.
* 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.
* typedef names as function parameters:  Incompatibilities.
* TYPENAME_TYPE:                         Types.
* TYPENAME_TYPE_FULLNAME:                Types.
* typeof:                                Typeof.
* 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.
* ULL integer suffix:                    Long Long.
* Ultrix calling convention:             Interoperation.
* 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.
* undefined behavior:                    Bug Criteria.
* undefined function value:              Bug Criteria.
* underscores in variables in macros:    Naming Types.
* underscores, avoiding (88k):           M88K Options.
* union, casting to a:                   Cast to Union.
* UNION_TYPE <1>:                        Classes.
* UNION_TYPE:                            Types.
* unions:                                Incompatibilities.
* unions, returning:                     Interface.
* UNIQUE_SECTION:                        Sections.
* UNIQUE_SECTION_P:                      Sections.
* UNITS_PER_WORD:                        Storage Layout.
* unknown pragmas, warning:              Warning Options.
* UNKNOWN_FLOAT_FORMAT:                  Storage Layout.
* UNKNOWN_TYPE:                          Types.
* unreachable code:                      Passes.
* unresolved references and -nodefaultlibs: Link Options.
* unresolved references and -nostdlib:   Link Options.
* 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:         Config.
* us_minus:                              Arithmetic.
* us_plus:                               Arithmetic.
* us_truncate:                           Conversions.
* use:                                   Side Effects.
* USE_C_ALLOCA:                          Config.
* USE_LOAD_POST_DECREMENT:               Costs.
* USE_LOAD_POST_INCREMENT:               Costs.
* USE_LOAD_PRE_DECREMENT:                Costs.
* USE_LOAD_PRE_INCREMENT:                Costs.
* USE_PROTOTYPES:                        Config.
* 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.
* USG:                                   Config.
* USING_DECL:                            Declarations.
* USING_STMT:                            Function Bodies.
* V in constraint:                       Simple Constraints.
* V850 Options:                          V850 Options.
* vague linkage:                         Vague Linkage.
* VALID_MACHINE_DECL_ATTRIBUTE:          Misc.
* VALID_MACHINE_TYPE_ATTRIBUTE:          Misc.
* value after longjmp:                   Global Reg Vars.
* values, returned by functions:         Scalar Return.
* VAR_DECL <1>:                          Expression trees.
* VAR_DECL:                              Declarations.
* varargs implementation:                Varargs.
* varargs.h and RT PC:                   RT Options.
* variable:                              Declarations.
* variable addressability on the M32R/D: Variable Attributes.
* variable alignment:                    Alignment.
* variable attributes:                   Variable Attributes.
* variable number of arguments:          Variadic Macros.
* variable-length array scope:           Variable Length.
* variable-length arrays:                Variable Length.
* variables in specified registers:      Explicit Reg Vars.
* variables, local, in macros:           Naming Types.
* variadic macros:                       Variadic Macros.
* Vax calling convention:                Interoperation.
* VAX options:                           VAX Options.
* VAX_FLOAT_FORMAT:                      Storage Layout.
* VAXCRTL:                               VMS Misc.
* 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_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.
* VLAs:                                  Variable Length.
* VMS:                                   Config.
* VMS and case sensitivity:              VMS Misc.
* VMS and include files:                 Include Files and VMS.
* VMS installation:                      VMS Install.
* void pointers, arithmetic:             Pointer Arith.
* void, size of pointer to:              Pointer Arith.
* VOID_TYPE:                             Types.
* VOIDmode:                              Machine Modes.
* volatil:                               Flags.
* volatil, in insn:                      Flags.
* volatil, in mem:                       Flags.
* volatil, in reg:                       Flags.
* volatil, in symbol_ref:                Flags.
* volatile access:                       Volatiles.
* volatile applied to function:          Function Attributes.
* volatile memory references:            Flags.
* volatile read:                         Volatiles.
* volatile write:                        Volatiles.
* voting between constraint alternatives: Class Preferences.
* vtable:                                Vague Linkage.
* warning for comparison of signed and unsigned values: Warning Options.
* warning for overloaded virtual fn:     C++ Dialect Options.
* warning for reordering of member initializers <1>: Warning Options.
* warning for reordering of member initializers: C++ Dialect Options.
* warning for synthesized methods:       C++ Dialect Options.
* warning for unknown pragmas:           Warning Options.
* warning messages:                      Warning Options.
* warnings from system headers:          Warning Options.
* warnings vs errors:                    Warnings and Errors.
* WCHAR_TYPE:                            Type Layout.
* WCHAR_TYPE_SIZE:                       Type Layout.
* weak attribute:                        Function Attributes.
* which_alternative:                     Output Statement.
* WHILE_BODY:                            Function Bodies.
* WHILE_COND:                            Function Bodies.
* WHILE_STMT:                            Function Bodies.
* whitespace:                            Incompatibilities.
* 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.
* X3.159-1989:                           Standards.
* XCmode:                                Machine Modes.
* XCOFF_DEBUGGING_INFO:                  DBX Options.
* XEXP:                                  Accessors.
* XFmode:                                Machine Modes.
* XINT:                                  Accessors.
* xm-MACHINE.h:                          Config.
* xor:                                   Arithmetic.
* xor, canonicalization of:              Insn Canonicalizations.
* xorM3 instruction pattern:             Standard Names.
* XSTR:                                  Accessors.
* XVEC:                                  Accessors.
* XVECEXP:                               Accessors.
* XVECLEN:                               Accessors.
* XWINT:                                 Accessors.
* zero division on 88k:                  M88K Options.
* zero-length arrays:                    Zero Length.
* zero_extend:                           Conversions.
* zero_extendMN2 instruction pattern:    Standard Names.
* zero_extract:                          Bit-Fields.
* zero_extract, canonicalization of:     Insn Canonicalizations.


