This is Info file gcc.info, produced by Makeinfo version 1.68 from the
input file
/tantor/build/intel-xscale/xscale-010413/i686-pc-linux-gnulibc2.1/src/gcc/gcc.texi.

START-INFO-DIR-ENTRY
* Gcc: (gcc).                           Using and Porting the GNU C compiler.
END-INFO-DIR-ENTRY

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 Free Software Foundation, Inc.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "GNU General Public License" and "Funding
for Free Software" are included exactly as in the original, and
provided that the entire resulting derived work is distributed under
the terms of a permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "GNU General Public
License" and "Funding for Free Software", and this permission notice,
may be included in translations approved by the Free Software Foundation
instead of in the original English.


File: gcc.info,  Node: Index,  Prev: Contributors,  Up: Top

Index
*****

* Menu:

* ! in constraint:                       Multi-Alternative.
* # in constraint:                       Modifiers.
* # in template:                         Output Template.
* #pragma:                               Misc.
* #pragma implementation, implied:       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.
* _ 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_frame_address:               Return Address.
* __builtin_next_arg:                    Varargs.
* __builtin_return:                      Constructing Calls.
* __builtin_return_address:              Return Address.
* __builtin_saveregs:                    Varargs.
* __CTOR_LIST__:                         Initialization.
* __DTOR_LIST__:                         Initialization.
* __extension__:                         Alternate Keywords.
* __main:                                Collect2.
* _exit:                                 C Dialect Options.
* abort <1>:                             Portability.
* abort:                                 C Dialect Options.
* abs <1>:                               Arithmetic.
* abs:                                   C Dialect Options.
* 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_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:                Offset info Option.
* aligned attribute <1>:                 Type Attributes.
* aligned attribute:                     Variable Attributes.
* alignment:                             Alignment.
* ALL_REGS:                              Register Classes.
* Alliant:                               Interoperation.
* alloca:                                C Dialect Options.
* alloca and SunOS:                      Installation.
* alloca vs variable-length arrays:      Variable Length.
* alloca, for SunOS:                     Sun Install.
* alloca, for Unos:                      Configurations.
* allocate_stack instruction pattern:    Standard Names.
* ALLOCATE_TRAMPOLINE:                   Trampolines.
* ALTER_HARD_SUBREG:                     Values in Registers.
* alternate keywords:                    Alternate Keywords.
* 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 support:                          C Dialect Options.
* 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.
* ARM options:                           ARM Options.
* 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_CLOSE_PAREN:                       Data Output.
* ASM_COMMENT_START:                     File Framework.
* ASM_DECLARE_FUNCTION_NAME:             Label Output.
* ASM_DECLARE_FUNCTION_SIZE:             Label Output.
* ASM_DECLARE_OBJECT_NAME:               Label Output.
* ASM_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_IDENTIFY_GCC:                      File Framework.
* asm_input:                             Side Effects.
* 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_DECL_COMMON:                Uninitialized Data.
* ASM_OUTPUT_DECL_LOCAL:                 Uninitialized Data.
* 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_WEAK_ALIAS:                 Label Output.
* ASM_SPEC:                              Driver.
* ASM_STABD_OP:                          DBX Options.
* ASM_STABN_OP:                          DBX Options.
* ASM_STABS_OP:                          DBX Options.
* 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.
* 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.
* 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.
* barrier:                               Insns.
* BASE_REG_CLASS:                        Register Classes.
* basic blocks:                          Passes.
* bcmp:                                  Config.
* bCOND instruction pattern:             Standard Names.
* bcopy, implicit usage:                 Library Calls.
* BIGGEST_ALIGNMENT:                     Storage Layout.
* BIGGEST_FIELD_ALIGNMENT:               Storage Layout.
* Bison parser generator:                Installation.
* bit fields:                            Bit Fields.
* bit shift overflow (88k):              M88K Options.
* BITFIELD_NBYTES_LIMITED:               Storage Layout.
* BITS_BIG_ENDIAN:                       Storage Layout.
* BITS_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.
* bound pointer to member function:      Bound member functions.
* branch shortening:                     Passes.
* BRANCH_COST:                           Costs.
* break_out_memory_refs:                 Addressing Modes.
* BSS_SECTION_ASM_OP:                    Sections.
* bug criteria:                          Bug Criteria.
* bug report mailing lists:              Bug Lists.
* bugs:                                  Bugs.
* bugs, known:                           Trouble.
* builtin 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:                                 Config.
* 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 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++ named return value:                Naming Results.
* C++ options, command line:             C++ Dialect Options.
* C++ pragmas, effect on inlining:       C++ Interface.
* C++ runtime library:                   Installation.
* C++ source file suffixes:              Invoking G++.
* C++ static data, declaring and defining: Static Definitions.
* 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_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 conventions for interrupts:    Interrupt Functions.
* 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.
* canonicalization of instructions:      Insn Canonicalizations.
* CANONICALIZE_COMPARISON:               Condition Code.
* canonicalize_funcptr_for_compare instruction pattern: Standard Names.
* case labels in initializers:           Labeled Elements.
* case ranges:                           Case Ranges.
* case sensitivity and VMS:              VMS Misc.
* CASE_DROPS_THROUGH:                    Misc.
* CASE_VALUES_THRESHOLD:                 Misc.
* CASE_VECTOR_MODE:                      Misc.
* CASE_VECTOR_PC_RELATIVE:               Misc.
* CASE_VECTOR_SHORTEN_MODE:              Misc.
* casesi instruction pattern:            Standard Names.
* cast to a union:                       Cast to Union.
* casts as lvalues:                      Lvalues.
* catgets:                               Installation.
* 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.
* class definitions, register:           Register Classes.
* class preference constraints:          Class Preferences.
* CLASS_LIKELY_SPILLED_P:                Register Classes.
* CLASS_MAX_NREGS:                       Register Classes.
* classes of RTX codes:                  RTL Classes.
* 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_label:                            Insns.
* code_label and /i:                     Flags.
* CODE_LABEL_NUMBER:                     Insns.
* codes, RTL expression:                 RTL Objects.
* COImode:                               Machine Modes.
* 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.
* compilation in a separate directory:   Other Dir.
* compiler bugs, reporting:              Bug Reporting.
* compiler compared to C++ preprocessor: G++ and GCC.
* compiler options, C++:                 C++ Dialect Options.
* compiler passes and files:             Passes.
* compiler version, specifying:          Target Options.
* COMPILER_PATH:                         Environment Variables.
* complement, bitwise:                   Arithmetic.
* complex numbers:                       Complex.
* compound expressions as lvalues:       Lvalues.
* computed gotos:                        Labels as Values.
* computing the length of an insn:       Insn Lengths.
* cond:                                  Comparisons.
* cond and attributes:                   Expressions.
* condition code register:               Regs and Memory.
* condition code status:                 Condition Code.
* condition codes:                       Comparisons.
* conditional expressions as lvalues:    Lvalues.
* conditional expressions, extensions:   Conditionals.
* CONDITIONAL_REGISTER_USAGE:            Register Basics.
* conditional_trap instruction pattern:  Standard Names.
* conditions, in patterns:               Patterns.
* configuration file:                    Config.
* configurations supported by GNU CC:    Configurations.
* conflicting types:                     Disappointments.
* 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_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 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 expressions:               Constructors.
* constructor function attribute:        Function Attributes.
* constructors, automatic calls:         Collect2.
* constructors, output of:               Initialization.
* contributors:                          Contributors.
* controlling register usage:            Register Basics.
* controlling the compilation driver:    Driver.
* conventions, run-time:                 Interface.
* conversions:                           Conversions.
* Convex options:                        Convex Options.
* copy propagation:                      Passes.
* copy_rtx:                              Addressing Modes.
* copy_rtx_if_shared:                    Sharing.
* core dump:                             Bug Criteria.
* cos:                                   C Dialect Options.
* cosf:                                  C Dialect Options.
* cosl:                                  C Dialect Options.
* costs of instructions:                 Costs.
* COSTS_N_INSNS:                         Costs.
* CPLUS_INCLUDE_PATH:                    Environment Variables.
* CPP_PREDEFINES:                        Run-time Target.
* CPP_SPEC:                              Driver.
* CQImode:                               Machine Modes.
* cross compilation and floating point:  Cross-compilation.
* cross compiling:                       Target Options.
* cross-compiler, installation:          Cross-Compiler.
* cross-jumping:                         Passes.
* CROSS_LIBGCC1:                         Target Fragment.
* 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.
* d in constraint:                       Simple Constraints.
* D10V Options:                          D10V Options.
* D30V Options:                          D30V Options.
* data flow analysis:                    Passes.
* DATA_ALIGNMENT:                        Storage Layout.
* data_section:                          Sections.
* DATA_SECTION_ASM_OP:                   Sections.
* DBR_OUTPUT_SEQEND:                     Instruction Output.
* dbr_sequence_length:                   Instruction Output.
* DBX:                                   Interoperation.
* DBX_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.
* DCmode:                                Machine Modes.
* De Morgan's law:                       Insn Canonicalizations.
* dead code:                             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.
* declaration scope:                     Incompatibilities.
* declarations inside expressions:       Statement Exprs.
* declarations, RTL:                     RTL Declarations.
* declaring attributes of functions:     Function Attributes.
* declaring static data in C++:          Static Definitions.
* DEFAULT_CALLER_SAVES:                  Caller Saves.
* DEFAULT_GDB_EXTENSIONS:                DBX Options.
* DEFAULT_MAIN_RETURN:                   Misc.
* DEFAULT_PCC_STRUCT_RETURN:             Aggregate Return.
* DEFAULT_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_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 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.
* destructor function attribute:         Function Attributes.
* destructors, output of:                Initialization.
* detecting -traditional:                C Dialect Options.
* DFmode:                                Machine Modes.
* dialect options:                       C Dialect Options.
* digits in constraint:                  Simple Constraints.
* DImode:                                Machine Modes.
* DIR_SEPARATOR:                         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.
* DOESNT_NEED_UNWINDER:                  Exception Region Output.
* dollar signs in identifier names:      Dollar Signs.
* DOLLARS_IN_IDENTIFIERS:                Misc.
* DONE:                                  Expander Definitions.
* DONT_REDUCE_ADDR:                      Costs.
* double-word arithmetic:                Long Long.
* DOUBLE_TYPE_SIZE:                      Type Layout.
* downward funargs:                      Nested Functions.
* driver:                                Driver.
* DW bit (29k):                          AMD29K Options.
* 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_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_epilogue instruction pattern:       Standard Names.
* EH_FRAME_SECTION_ASM_OP:               Exception Region Output.
* 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.
* 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.
* 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.
* equal:                                 Comparisons.
* errno, implicit usage:                 Library Calls.
* error messages:                        Warnings and Errors.
* escape sequences, traditional:         C Dialect Options.
* exception_receiver instruction pattern: Standard Names.
* EXCEPTION_SECTION:                     Exception Region Output.
* exclamation point:                     Multi-Alternative.
* exclusive-or, bitwise:                 Arithmetic.
* EXECUTABLE_SUFFIX:                     Config.
* exit:                                  C Dialect Options.
* exit status and VMS:                   VMS Misc.
* EXIT_BODY:                             Misc.
* EXIT_IGNORE_STACK:                     Function Entry.
* EXPAND_BUILTIN_SAVEREGS:               Varargs.
* expander definitions:                  Expander Definitions.
* explicit register variables:           Explicit Reg Vars.
* expr_list:                             Insns.
* expression codes:                      RTL Objects.
* expressions containing statements:     Statement Exprs.
* expressions, compound, as lvalues:     Lvalues.
* expressions, conditional, as lvalues:  Lvalues.
* expressions, constructor:              Constructors.
* extended asm:                          Extended Asm.
* 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:                                  C Dialect Options.
* fabsf:                                 C Dialect Options.
* fabsl:                                 C Dialect Options.
* FAIL:                                  Expander Definitions.
* fatal signal:                          Bug Criteria.
* FATAL_EXIT_CODE:                       Config.
* features, optional, in system conventions: Run-time Target.
* ffs <1>:                               Arithmetic.
* ffs:                                   C Dialect Options.
* ffsM2 instruction pattern:             Standard Names.
* 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.
* 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_truncMN2 instruction pattern:      Standard Names.
* fixed register:                        Register Basics.
* FIXED_REGISTERS:                       Register Basics.
* fixed_regs:                            Register Basics.
* fixMN2 instruction pattern:            Standard Names.
* FIXUNS_TRUNC_LIKE_FIX_TRUNC:           Misc.
* fixuns_truncMN2 instruction pattern:   Standard Names.
* fixunsMN2 instruction pattern:         Standard Names.
* flags in RTL expression:               Flags.
* float:                                 Conversions.
* float as function value type:          Incompatibilities.
* FLOAT_ARG_TYPE:                        Library Calls.
* 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.
* force_reg:                             Standard Names.
* format function attribute:             Function Attributes.
* format_arg function attribute:         Function Attributes.
* forwarding calls:                      Constructing Calls.
* 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.
* fscanf, and constant strings:          Incompatibilities.
* ftruncM2 instruction pattern:          Standard Names.
* function addressability on the M32R/D: Function Attributes.
* function attributes:                   Function Attributes.
* function call conventions:             Interface.
* function entry and exit:               Function Entry.
* function pointers, arithmetic:         Pointer Arith.
* function prototype declarations:       Function Prototypes.
* function units, for scheduling:        Function Units.
* function, size of pointer to:          Pointer Arith.
* function-call insns:                   Calls.
* FUNCTION_ARG:                          Register Arguments.
* FUNCTION_ARG_ADVANCE:                  Register Arguments.
* FUNCTION_ARG_BOUNDARY:                 Register Arguments.
* FUNCTION_ARG_CALLEE_COPIES:            Register Arguments.
* FUNCTION_ARG_KEEP_AS_REFERENCE:        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_BOUNDARY_MAX_SKIP:            Storage Layout.
* FUNCTION_CONVERSION_BUG:               Config.
* FUNCTION_EPILOGUE:                     Function Entry.
* FUNCTION_EPILOGUE and trampolines:     Trampolines.
* FUNCTION_INCOMING_ARG:                 Register Arguments.
* FUNCTION_MODE:                         Misc.
* FUNCTION_OUTGOING_VALUE:               Scalar Return.
* FUNCTION_PROFILER:                     Profiling.
* FUNCTION_PROLOGUE:                     Function Entry.
* FUNCTION_PROLOGUE and trampolines:     Trampolines.
* 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 bahave 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 or strftime style arguments: Function Attributes.
* functions, leaf:                       Leaf Functions.
* 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_EXEC_PREFIX:                       Environment Variables.
* ge:                                    Comparisons.
* ge and attributes:                     Expressions.
* 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.
* genflags, crash on Sun 4:              Installation Problems.
* 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.
* gettext:                               Installation.
* 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.
* 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.
* gp-relative references (MIPS):         MIPS Options.
* gprof:                                 Debugging Options.
* greater than:                          Comparisons.
* grouping options:                      Invoking GCC.
* gt:                                    Comparisons.
* gt and attributes:                     Expressions.
* gtu:                                   Comparisons.
* gtu and attributes:                    Expressions.
* H in constraint:                       Simple Constraints.
* Haifa scheduler:                       Installation.
* HANDLE_PRAGMA:                         Misc.
* HANDLE_PRAGMA_PACK_PUSH_POP:           Misc.
* HANDLE_SYSV_PRAGMA:                    Misc.
* 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_PRE_DECREMENT:                    Addressing Modes.
* HAVE_PRE_INCREMENT:                    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_BITS_PER_CHAR:                    Config.
* HOST_BITS_PER_INT:                     Config.
* HOST_BITS_PER_LONG:                    Config.
* HOST_BITS_PER_SHORT:                   Config.
* HOST_FLOAT_FORMAT:                     Config.
* HOST_FLOAT_WORDS_BIG_ENDIAN:           Config.
* HOST_WORDS_BIG_ENDIAN:                 Config.
* hosted environment:                    C Dialect Options.
* HPPA Options:                          HPPA Options.
* I in constraint:                       Simple Constraints.
* i in constraint:                       Simple Constraints.
* i386 Options:                          i386 Options.
* IBM RS/6000 and PowerPC Options:       RS/6000 and PowerPC Options.
* IBM RT options:                        RT Options.
* IBM RT PC:                             Interoperation.
* identifier names, dollar signs in:     Dollar Signs.
* identifiers, names in assembler code:  Asm Labels.
* identifying source, compiler (88k):    M88K Options.
* IEEE_FLOAT_FORMAT:                     Storage Layout.
* if_then_else:                          Comparisons.
* if_then_else and attributes:           Expressions.
* if_then_else usage:                    Side Effects.
* immediate_operand:                     RTL Template.
* IMMEDIATE_PREFIX:                      Instruction Output.
* implicit argument: return value:       Naming Results.
* 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_REG_CLASS:                       Register Classes.
* indirect calls on ARM:                 Function Attributes.
* indirect_jump instruction pattern:     Standard Names.
* INIT_CUMULATIVE_ARGS:                  Register Arguments.
* INIT_CUMULATIVE_INCOMING_ARGS:         Register Arguments.
* INIT_ENVIRONMENT:                      Driver.
* 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:        Constructors.
* INITIALIZE_TRAMPOLINE:                 Trampolines.
* initializers with labeled elements:    Labeled Elements.
* initializers, non-constant:            Initializers.
* inline automatic for C++ member fns:   Inline.
* inline functions:                      Inline.
* inline functions, omission of:         Inline.
* inline, automatic:                     Passes.
* 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 the Sun:          Sun Install.
* installing GNU CC on VMS:              VMS Install.
* instruction attributes:                Insn Attributes.
* instruction combination:               Passes.
* instruction patterns:                  Patterns.
* instruction recognizer:                Passes.
* instruction scheduling:                Passes.
* instruction splitting:                 Insn Splitting.
* insv instruction pattern:              Standard Names.
* INT_TYPE_SIZE:                         Type Layout.
* INTEGRATE_THRESHOLD:                   Misc.
* integrated:                            Flags.
* integrated, in insn:                   Flags.
* integrated, in reg:                    Flags.
* integrating function code:             Inline.
* Intel 386 Options:                     i386 Options.
* Interdependence of Patterns:           Dependent Patterns.
* interface and implementation headers, C++: C++ Interface.
* interfacearm function attribute on the Thumb/PE: Function Attributes.
* interfacing to GCC output:             Interface.
* intermediate C version, nonexistent:   G++ and GCC.
* Internal Compiler Checking:            Installation.
* interrupt handler functions:           Function Attributes.
* interrupts, functions compiled for:    Interrupt Functions.
* INTIFY:                                Library Calls.
* 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.
* ISSUE_RATE:                            Misc.
* 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_NUSES:                           Insns.
* LABEL_OUTSIDE_LOOP_P:                  Flags.
* LABEL_PRESERVE_P:                      Flags.
* label_ref:                             Constants.
* label_ref and /s:                      Flags.
* label_ref, RTL sharing:                Sharing.
* labeled elements in initializers:      Labeled Elements.
* labels as values:                      Labels as Values.
* labs:                                  C Dialect Options.
* 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.
* 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.
* libstdc++:                             Installation.
* LIMIT_RELOAD_CLASS:                    Register Classes.
* link options:                          Link Options.
* LINK_COMMAND_SPEC:                     Driver.
* LINK_LIBGCC_SPECIAL:                   Driver.
* LINK_LIBGCC_SPECIAL_1:                 Driver.
* LINK_SPEC:                             Driver.
* LINKER_DOES_NOT_WORK_WITH_DWARF2:      SDB and DWARF.
* 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_INCLUDE_DIR:                     Driver.
* LOCAL_LABEL_PREFIX:                    Instruction Output.
* 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_TEST_THRESHOLD:                   Misc.
* lshiftrt:                              Arithmetic.
* lshiftrt and attributes:               Expressions.
* lshrM3 instruction pattern:            Standard Names.
* lt:                                    Comparisons.
* lt and attributes:                     Expressions.
* ltu:                                   Comparisons.
* lvalues, generalized:                  Lvalues.
* m in constraint:                       Simple Constraints.
* m32r instruction set:                  M32R/D/X Options.
* M32R/D/X options:                      M32R/D/X Options.
* m32rx instruction set:                 M32R/D/X Options.
* M680x0 options:                        M680x0 Options.
* M88k options:                          M88K Options.
* machine dependent options:             Submodel Options.
* machine description macros:            Target Macros.
* machine descriptions:                  Machine Desc.
* machine mode conversions:              Conversions.
* machine modes:                         Machine Modes.
* machine specific constraints:          Machine Constraints.
* MACHINE_DEPENDENT_REORG:               Misc.
* MACHINE_STATE_RESTORE:                 Profiling.
* MACHINE_STATE_SAVE:                    Profiling.
* macro with variable arguments:         Macro Varargs.
* macros containing asm:                 Extended Asm.
* macros, inline alternative:            Inline.
* macros, local labels:                  Local Labels.
* macros, local variables in:            Naming Types.
* macros, statements in expressions:     Statement Exprs.
* macros, target description:            Target Macros.
* macros, types of arguments:            Typeof.
* 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.
* malloc attribute:                      Function Attributes.
* 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_INTEGER_COMPUTATION_OK:            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_CALL_PROTOTYPES:                    Config.
* MD_EXEC_PREFIX:                        Driver.
* MD_EXPAND_BUILTIN:                     Misc.
* MD_INIT_BUILTINS:                      Misc.
* MD_SCHED_INIT:                         Misc.
* MD_SCHED_REORDER:                      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:                                C Dialect Options.
* memcpy:                                C Dialect Options.
* memcpy, 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:                                C Dialect Options.
* memset, implicit usage:                Library Calls.
* MERGE_MACHINE_DECL_ATTRIBUTES:         Misc.
* MERGE_MACHINE_TYPE_ATTRIBUTES:         Misc.
* messages, warning:                     Warning Options.
* messages, warning and error:           Warnings and Errors.
* 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.
* MIPS options:                          MIPS Options.
* misunderstandings in C++:              C++ Misunderstandings.
* 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_CC:                               Machine Modes.
* MODE_COMPLEX_FLOAT:                    Machine Modes.
* MODE_COMPLEX_INT:                      Machine Modes.
* MODE_FLOAT:                            Machine Modes.
* MODE_FUNCTION:                         Machine Modes.
* MODE_INT:                              Machine Modes.
* MODE_PARTIAL_INT:                      Machine Modes.
* MODE_RANDOM:                           Machine Modes.
* MODES_TIEABLE_P:                       Values in Registers.
* modifiers in constraints:              Modifiers.
* 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.
* 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.
* naked function attribute on the ARM/PE: Function Attributes.
* name augmentation:                     VMS Misc.
* named patterns and conditions:         Patterns.
* named return value in C++:             Naming Results.
* names used in assembler code:          Asm Labels.
* names, pattern:                        Standard Names.
* naming convention, implementation headers: C++ Interface.
* naming types:                          Naming Types.
* Native Language Support:               Installation.
* ne:                                    Comparisons.
* ne and attributes:                     Expressions.
* NEED_ATEXIT:                           Misc.
* neg:                                   Arithmetic.
* neg and attributes:                    Expressions.
* neg, canonicalization of:              Insn Canonicalizations.
* negM2 instruction pattern:             Standard Names.
* nested functions:                      Nested Functions.
* nested functions, trampolines for:     Trampolines.
* newline vs string constants:           C Dialect Options.
* next_cc0_user:                         Jump Patterns.
* NEXT_INSN:                             Insns.
* NEXT_OBJC_RUNTIME:                     Library Calls.
* nil:                                   RTL Objects.
* NLS:                                   Installation.
* no-op move instructions:               Passes.
* NO_BUILTIN_PTRDIFF_TYPE:               Driver.
* NO_BUILTIN_SIZE_TYPE:                  Driver.
* NO_BUILTIN_WCHAR_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_MD_PROTOTYPES:                      Config.
* no_new_pseudos:                        Standard Names.
* 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.
* noreturn function attribute:           Function Attributes.
* 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.
* 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 threads:                   Installation.
* OBSTACK_CHUNK_ALLOC:                   Config.
* OBSTACK_CHUNK_FREE:                    Config.
* OBSTACK_CHUNK_SIZE:                    Config.
* obstack_free:                          Configurations.
* OCS (88k):                             M88K Options.
* offsettable address:                   Simple Constraints.
* 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.
* optional hardware or system features:  Run-time Target.
* options to control warnings:           Warning Options.
* options, C++:                          C++ Dialect Options.
* options, code generation:              Code Gen Options.
* options, debugging:                    Debugging Options.
* options, dialect:                      C Dialect Options.
* options, directory search:             Directory Options.
* options, GCC command:                  Invoking GCC.
* options, grouping:                     Invoking GCC.
* options, linking:                      Link Options.
* options, optimization:                 Optimize Options.
* options, order:                        Invoking GCC.
* options, preprocessor:                 Preprocessor Options.
* order of evaluation, side effects:     Non-bugs.
* order of options:                      Invoking GCC.
* order of register allocation:          Allocation Order.
* ORDER_REGS_FOR_LOCAL_ALLOC:            Allocation Order.
* Ordering of Patterns:                  Pattern Ordering.
* other directory, compilation in:       Other Dir.
* 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_asm_insn:                       Output Statement.
* OUTPUT_QUOTED_STRING:                  File Framework.
* overflow while constant folding:       Cross-compilation.
* overloaded virtual fn, warning:        C++ Dialect Options.
* OVERRIDE_OPTIONS:                      Run-time Target.
* p in constraint:                       Simple Constraints.
* packed attribute:                      Variable Attributes.
* PAD_VARARGS_DOWN:                      Register Arguments.
* parallel:                              Side Effects.
* parameter forward declaration:         Variable Length.
* parameters, aliased:                   Offset info Option.
* parameters, miscellaneous:             Misc.
* PARM_BOUNDARY:                         Storage Layout.
* PARSE_LDD_OUTPUT:                      Macros for Initialization.
* parser generator, Bison:               Installation.
* 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.
* 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.
* pmf:                                   Bound member functions.
* Pmode:                                 Misc.
* pointer arguments:                     Function Attributes.
* pointer to member function:            Bound member functions.
* POINTER_SIZE:                          Storage Layout.
* 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.
* 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.
* probe instruction pattern:             Standard Names.
* processor selection (29k):             AMD29K Options.
* product:                               Arithmetic.
* prof:                                  Debugging Options.
* PROFILE_BEFORE_PROLOGUE:               Profiling.
* profile_block_flag:                    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.
* push address instruction:              Simple Constraints.
* 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.
* Q, in constraint:                      Simple Constraints.
* QImode:                                Machine Modes.
* QImode, in insn:                       Insns.
* qsort, and global register variables:  Global Reg Vars.
* question mark:                         Multi-Alternative.
* quotient:                              Arithmetic.
* r in constraint:                       Simple Constraints.
* r0-relative references (88k):          M88K Options.
* ranges in case statements:             Case Ranges.
* read-only strings:                     Incompatibilities.
* READONLY_DATA_SECTION:                 Sections.
* REAL_ARITHMETIC:                       Cross-compilation.
* REAL_INFINITY:                         Cross-compilation.
* REAL_NM_FILE_NAME:                     Macros for Initialization.
* REAL_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.
* recog_operand:                         Instruction Output.
* recognizing insns:                     RTL Template.
* 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 allocation, stupid:           Passes.
* 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.
* 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, warning <1>:               Warning Options.
* reordering, warning:                   C++ Dialect Options.
* reporting bugs:                        Bugs.
* representation of RTL:                 RTL.
* rest argument (in macro):              Macro Varargs.
* 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.
* return:                                Side Effects.
* return instruction pattern:            Standard Names.
* return value of main:                  VMS Misc.
* return value, named, in C++:           Naming Results.
* return values in registers:            Scalar Return.
* return, in C++ function header:        Naming Results.
* RETURN_ADDR_IN_PREVIOUS_FRAME:         Frame Layout.
* RETURN_ADDR_RTX:                       Frame Layout.
* RETURN_ADDRESS_POINTER_REGNUM:         Frame Registers.
* RETURN_IN_MEMORY:                      Aggregate Return.
* RETURN_POPS_ARGS:                      Stack Arguments.
* returning aggregate values:            Aggregate Return.
* returning structures and unions:       Interface.
* REVERSIBLE_CC_MODE:                    Condition Code.
* right rotate:                          Arithmetic.
* right shift:                           Arithmetic.
* rotate:                                Arithmetic.
* rotatert:                              Arithmetic.
* rotlM3 instruction pattern:            Standard Names.
* rotrM3 instruction pattern:            Standard Names.
* ROUND_TYPE_ALIGN:                      Storage Layout.
* ROUND_TYPE_SIZE:                       Storage Layout.
* RS/6000 and PowerPC Options:           RS/6000 and PowerPC Options.
* 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.
* 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.
* 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.
* scheduler, experimental:               Installation.
* 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.
* 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.
* separate directory, compilation in:    Other Dir.
* 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.
* 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.
* 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:                                   C Dialect Options.
* sinf:                                  C Dialect Options.
* sinl:                                  C Dialect Options.
* SIZE_TYPE:                             Type Layout.
* sizeof:                                Typeof.
* SLOW_BYTE_ACCESS:                      Costs.
* SLOW_UNALIGNED_ACCESS:                 Costs.
* SLOW_ZERO_EXTEND:                      Costs.
* small data area on the V850:           Function Attributes.
* SMALL_REGISTER_CLASSES:                Register Classes.
* smaller data references:               M32R/D/X 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:                                  C Dialect Options.
* sqrtf:                                 C Dialect Options.
* sqrtl:                                 C Dialect Options.
* sqrtM2 instruction pattern:            Standard Names.
* square root:                           Arithmetic.
* ss_minus:                              Arithmetic.
* ss_plus:                               Arithmetic.
* ss_truncate:                           Conversions.
* 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.
* stage1:                                Installation.
* 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.
* STARTFILE_SPEC:                        Driver.
* STARTING_FRAME_OFFSET:                 Frame Layout.
* STARTING_FRAME_OFFSET and virtual registers: Regs and Memory.
* 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.
* storage layout:                        Storage Layout.
* STORE_FLAG_VALUE:                      Misc.
* store_multiple instruction pattern:    Standard Names.
* storem bug (29k):                      AMD29K Options.
* strcmp:                                C Dialect Options.
* strcpy <1>:                            Storage Layout.
* strcpy:                                C Dialect Options.
* 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.
* STRIP_NAME_ENCODING:                   Sections.
* strlen:                                C Dialect Options.
* strlenM instruction pattern:           Standard Names.
* STRUCT_VALUE:                          Aggregate Return.
* STRUCT_VALUE_INCOMING:                 Aggregate Return.
* STRUCT_VALUE_INCOMING_REGNUM:          Aggregate Return.
* STRUCT_VALUE_REGNUM:                   Aggregate Return.
* structure passing (88k):               M88K Options.
* structure value address:               Aggregate Return.
* STRUCTURE_SIZE_BOUNDARY:               Storage Layout.
* structures:                            Incompatibilities.
* structures, constructor expression:    Constructors.
* structures, returning:                 Interface.
* stupid register allocation:            Passes.
* subM3 instruction pattern:             Standard Names.
* submodel options:                      Submodel Options.
* 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++.
* Sun installation:                      Sun Install.
* SUPPORTS_ONE_ONLY:                     Label Output.
* SUPPORTS_WEAK:                         Label Output.
* suppressing warnings:                  Warning Options.
* surprises in C++:                      C++ Misunderstandings.
* SVr4:                                  M88K Options.
* SWITCH_CURTAILS_COMPILATION:           Driver.
* SWITCH_TAKES_ARG:                      Driver.
* SWITCHES_NEED_SPACES:                  Driver.
* symbol_ref:                            Constants.
* 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.
* symbolic label:                        Sharing.
* syntax checking:                       Warning Options.
* synthesized methods, warning:          C++ Dialect Options.
* SYSTEM_INCLUDE_DIR:                    Driver.
* t-TARGET:                              Target Fragment.
* tablejump instruction pattern:         Standard Names.
* tagging insns:                         Tagging Insns.
* 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_BELL:                           Type Layout.
* TARGET_BS:                             Type Layout.
* TARGET_CR:                             Type Layout.
* TARGET_EDOM:                           Library Calls.
* TARGET_FF:                             Type Layout.
* TARGET_FLOAT_FORMAT:                   Storage Layout.
* TARGET_MEM_FUNCTIONS:                  Library Calls.
* TARGET_NEWLINE:                        Type Layout.
* TARGET_OPTIONS:                        Run-time Target.
* TARGET_REG_CLASS_INIT:                 Register Classes.
* TARGET_SWITCHES:                       Run-time Target.
* TARGET_TAB:                            Type Layout.
* TARGET_VERSION:                        Run-time Target.
* TARGET_VT:                             Type Layout.
* TCmode:                                Machine Modes.
* tcov:                                  Debugging Options.
* template instantiation:                Template Instantiation.
* temporaries, lifetime of:              Temporaries.
* termination routines:                  Initialization.
* text_section:                          Sections.
* TEXT_SECTION_ASM_OP:                   Sections.
* TFmode:                                Machine Modes.
* threads, Objective C:                  Installation.
* Thumb Options:                         Thumb Options.
* thunks:                                Nested Functions.
* TImode:                                Machine Modes.
* TImode, in insn:                       Insns.
* tiny data area on the V850:            Function Attributes.
* 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_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.
* TRULY_NOOP_TRUNCATION:                 Misc.
* truncate:                              Conversions.
* truncMN2 instruction pattern:          Standard Names.
* tstM instruction pattern:              Standard Names.
* type alignment:                        Alignment.
* type attributes:                       Type Attributes.
* typedef names as function parameters:  Incompatibilities.
* typedefs, typedef names:               Redefining Typedefs.
* typeof:                                Typeof.
* udiv:                                  Arithmetic.
* UDIVDI3_LIBCALL:                       Library Calls.
* udivM3 instruction pattern:            Standard Names.
* udivmodM4 instruction pattern:         Standard Names.
* UDIVSI3_LIBCALL:                       Library Calls.
* 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.
* 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.
* unord:                                 Comparisons.
* 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.
* 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.
* V in constraint:                       Simple Constraints.
* V850 Options:                          V850 Options.
* VALID_MACHINE_DECL_ATTRIBUTE:          Misc.
* VALID_MACHINE_TYPE_ATTRIBUTE:          Misc.
* value after longjmp:                   Global Reg Vars.
* values, returned by functions:         Scalar Return.
* varargs implementation:                Varargs.
* varargs.h and RT PC:                   RT Options.
* variable addressability on the M32R/D: Variable Attributes.
* variable alignment:                    Alignment.
* variable attributes:                   Variable Attributes.
* variable number of arguments:          Macro Varargs.
* variable-length array scope:           Variable Length.
* variable-length arrays:                Variable Length.
* variables in specified registers:      Explicit Reg Vars.
* variables, local, in macros:           Naming Types.
* Vax calling convention:                Interoperation.
* VAX options:                           VAX Options.
* VAX_FLOAT_FORMAT:                      Storage Layout.
* VAXCRTL:                               VMS Misc.
* vec_concat:                            Vector Operations.
* vec_const:                             Vector Operations.
* vec_duplicate:                         Vector Operations.
* vec_merge:                             Vector Operations.
* vec_select:                            Vector Operations.
* 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.
* VMS:                                   Config.
* VMS and case sensitivity:              VMS Misc.
* VMS and include files:                 Include Files and VMS.
* VMS installation:                      VMS Install.
* void pointers, arithmetic:             Pointer Arith.
* void, size of pointer to:              Pointer Arith.
* VOIDmode:                              Machine Modes.
* volatil:                               Flags.
* 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.
* 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 vs errors:                    Warnings and Errors.
* WCHAR_TYPE:                            Type Layout.
* WCHAR_TYPE_SIZE:                       Type Layout.
* weak attribute:                        Function Attributes.
* which_alternative:                     Output Statement.
* whitespace:                            Incompatibilities.
* WIDEST_HARDWARE_FP_SIZE:               Type Layout.
* Windows32 Registry support:            Installation.
* word_mode:                             Machine Modes.
* WORD_REGISTER_OPERATIONS:              Misc.
* WORD_SWITCH_TAKES_ARG:                 Driver.
* WORDS_BIG_ENDIAN:                      Storage Layout.
* WORDS_BIG_ENDIAN, effect on subreg:    Regs and Memory.
* X in constraint:                       Simple Constraints.
* x-HOST:                                Host Fragment.
* XCmode:                                Machine Modes.
* XCOFF_DEBUGGING_INFO:                  DBX Options.
* XEXP:                                  Accessors.
* XFmode:                                Machine Modes.
* XINT:                                  Accessors.
* xm-MACHINE.h:                          Config.
* xor:                                   Arithmetic.
* xor, canonicalization of:              Insn Canonicalizations.
* xorM3 instruction pattern:             Standard Names.
* XSTR:                                  Accessors.
* XVEC:                                  Accessors.
* XVECEXP:                               Accessors.
* XVECLEN:                               Accessors.
* XWINT:                                 Accessors.
* zero data area on the V850:            Function Attributes.
* 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.


