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