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 © 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 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.2 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.

## Short Contents

- Introduction
- Contributing to GCC Development
- GCC and Portability
- Interfacing to GCC Output
- Language Front Ends in GCC
- Source Tree Structure and Build System
- Passes and Files of the Compiler
- Trees: The intermediate representation used by the C and C++ front ends
- RTL Representation
- Machine Descriptions
- Target Description Macros and Functions
- Host Configuration Headers
- Makefile Fragments
- `collect2`
- Standard Header File Directories
- Memory Management and Type Information
- Funding Free Software
- The GNU Project and GNU/Linux
- GNU GENERAL PUBLIC LICENSE
- GNU Free Documentation License
- Contributors to GCC
- Option Index
- Index

## Table of Contents

- Introduction
- Contributing to GCC Development
- GCC and Portability
- Interfacing to GCC Output
- Language Front Ends in GCC
- Source Tree Structure and Build System
  - Configure Terms and History
  - Top Level Source Directory
  - The `gcc` Subdirectory
    - Subdirectories of `gcc`
    - Configuration in the `gcc` Directory
      - Scripts Used by `configure`
      - The `config.gcc` File
      - Files Created by `configure`
    - Build System in the `gcc` Directory
    - Makefile Targets
    - Library Source Files and Headers under the `gcc` Directory
    - Headers Installed by GCC
    - Building Documentation
      - Texinfo Manuals
      - Man Page Generation
      - Miscellaneous Documentation
    - Anatomy of a Language Front End
      - The Front End ``language`` Directory
      - The Front End `config-lang.in` File
    - Anatomy of a Target Back End
  - Test Suites
    - Idioms Used in Test Suite Code
    - C Language Test Suites
    - The Java library test suites.
    - Support for testing `gcov`
    - Support for testing profile-directed optimizations
    - Support for testing binary compatibility
- Passes and Files of the Compiler
- Trees: The intermediate representation used by the C and C++ front ends
  - Deficiencies
  - Overview
    - Trees
    - Identifiers
    - Containers
  - Types
  - Scopes
    - Namespaces
    - Classes
  - Declarations
  - Functions
    - Function Basics
    - Function Bodies
      - Statements
  - Attributes in trees
  - Expressions
- RTL Representation
  - RTL Object Types
  - RTL Classes and Formats
  - Access to Operands
  - Flags in an RTL Expression
  - Machine Modes
  - Constant Expression Types
  - Registers and Memory
  - RTL Expressions for Arithmetic
  - Comparison Operations
  - Bit-Fields
  - Vector Operations
  - Conversions
  - Declarations
  - Side Effect Expressions
  - Embedded Side-Effects on Addresses
  - Assembler Instructions as Expressions
  - Insns
  - RTL Representation of Function-Call Insns
  - Structure Sharing Assumptions
  - Reading RTL
- Machine Descriptions
  - Overview of How the Machine Description is Used
  - Everything about Instruction Patterns
  - Example of `define_insn`
  - RTL Template
  - Output Templates and Operand Substitution
  - C Statements for Assembler Output
  - Operand Constraints
    - Simple Constraints
    - Multiple Alternative Constraints
    - Register Class Preferences
    - Constraint Modifier Characters
    - Constraints for Particular Machines
  - Standard Pattern Names For Generation
  - When the Order of Patterns Matters
  - Interdependence of Patterns
  - Defining Jump Instruction Patterns
  - Defining Looping Instruction Patterns
  - Canonicalization of Instructions
  - Defining RTL Sequences for Code Generation
  - Defining How to Split Instructions
  - Including Patterns in Machine Descriptions.
    - RTL Generation Tool Options for Directory Search
  - Machine-Specific Peephole Optimizers
    - RTL to Text Peephole Optimizers
    - RTL to RTL Peephole Optimizers
  - Instruction Attributes
    - Defining Attributes and their Values
    - Attribute Expressions
    - Assigning Attribute Values to Insns
    - Example of Attribute Specifications
    - Computing the Length of an Insn
    - Constant Attributes
    - Delay Slot Scheduling
    - Specifying processor pipeline description
      - Specifying Function Units
      - Describing instruction pipeline characteristics
      - Drawbacks of the old pipeline description
  - Conditional Execution
  - Constant Definitions
- Target Description Macros and Functions
  - The Global `targetm` Variable
  - Controlling the Compilation Driver, `gcc`
  - Run-time Target Specification
  - Defining data structures for per-function information.
  - Storage Layout
  - Layout of Source Language Data Types
  - Target Character Escape Sequences
  - Register Usage
    - Basic Characteristics of Registers
    - Order of Allocation of Registers
    - How Values Fit in Registers
    - Handling Leaf Functions
    - Registers That Form a Stack
  - Register Classes
  - Stack Layout and Calling Conventions
    - Basic Stack Layout
    - Exception Handling Support
    - Specifying How Stack Checking is Done
    - Registers That Address the Stack Frame
    - Eliminating Frame Pointer and Arg Pointer
    - Passing Function Arguments on the Stack
    - Passing Arguments in Registers
    - How Scalar Function Values Are Returned
    - How Large Values Are Returned
    - Caller-Saves Register Allocation
    - Function Entry and Exit
    - Generating Code for Profiling
    - Permitting tail calls
  - Implementing the Varargs Macros
  - Trampolines for Nested Functions
  - Implicit Calls to Library Routines
  - Addressing Modes
  - Condition Code Status
  - Describing Relative Costs of Operations
  - Adjusting the Instruction Scheduler
  - Dividing the Output into Sections (Texts, Data, ...)
  - Position Independent Code
  - Defining the Output Assembler Language
    - The Overall Framework of an Assembler File
    - Output of Data
    - Output of Uninitialized Variables
    - Output and Generation of Labels
    - How Initialization Functions Are Handled
    - Macros Controlling Initialization Routines
    - Output of Assembler Instructions
    - Output of Dispatch Tables
    - Assembler Commands for Exception Regions
    - Assembler Commands for Alignment
  - Controlling Debugging Information Format
    - Macros Affecting All Debugging Formats
    - Specific Options for DBX Output
    - Open-Ended Hooks for DBX Format
    - File Names in DBX Format
    - Macros for SDB and DWARF Output
    - Macros for VMS Debug Format
  - Cross Compilation and Floating Point
  - Mode Switching Instructions
  - Defining target-specific uses of `__attribute__`
  - Defining coprocessor specifics for MIPS targets.
  - Miscellaneous Parameters
- Host Configuration Headers
- Makefile Fragments
  - Target Makefile Fragments
  - Host Makefile Fragments
- `collect2`
- Standard Header File Directories
- Memory Management and Type Information
  - The Inside of a `GTY(())`
  - Marking Roots for the Garbage Collector
  - Source Files Containing Type Information
- Funding Free Software
- The GNU Project and GNU/Linux
- GNU GENERAL PUBLIC LICENSE
  - Preamble
  - How to Apply These Terms to Your New Programs
- GNU Free Documentation License
  - ADDENDUM: How to use this License for your documents
- Contributors to GCC
- Option Index
- Index

Node:Top, Next:Contributing, Up:(DIR)

## Introduction

This manual documents the internals of the GNU compilers, including how to port them to new targets and some information about how to write front ends for new languages. It corresponds to GCC version 3.3. The use of the GNU compilers is documented in a separate manual. See Introduction.

This manual is mainly a reference manual rather than a tutorial. It discusses how to contribute to GCC (see Contributing), the characteristics of the machines supported by GCC as hosts and targets (see Portability), how GCC relates to the ABIs on such systems (see Interface), and the characteristics of the languages for which GCC front ends are written (see Languages). It then describes the GCC source tree structure and build system, some of the interfaces to GCC front ends, and how support for a target system is implemented in GCC.

Additional tutorial information is linked to from http://gcc.gnu.org/readings.html.

Node:Index, Previous:Option Index, Up:Top

## Index

- `!` in constraint: Multi-Alternative
- `#` in constraint: Modifiers
- `#` in template: Output Template
- `#pragma`: Misc
- `%` in constraint: Modifiers
- % in GTY option: GTY Options
- `%` 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
- `absence_set`: Automaton pipeline description
- `abs` m `2` 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
- `add` m `3` 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_COP_ADDITIONAL_REGISTER_NAMES`: MIPS Coprocessors
- `ALL_REGS`: Register Classes
- `ALLOCATE_INITIAL_VALUE`: Misc
- `allocate_stack` instruction pattern: Standard Names
- `ALLOCATE_TRAMPOLINE`: Trampolines
- alternate entry points: Insns
- analysis, data flow: Passes
- `and`: Arithmetic
- `and` and attributes: Expressions
- `and`, canonicalization of: Insn Canonicalizations
- `and` m `3` 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
- `ashl` m `3` instruction pattern: Standard Names
- `ashr` m `3` 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_input`: Side Effects
- `asm_input` and `/v`: Flags
- `ASM_INPUTS`: Function Bodies
- `ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX`: Exception Handling
- `ASM_NO_SKIP_IN_TEXT`: Alignment Output
- `asm_noperands`: Insns
- `asm_operands` and `/v`: Flags
- `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_ALIGN_WITH_NOP`: 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_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_DWARF_DELTA`: SDB and DWARF
- `ASM_OUTPUT_DWARF_OFFSET`: SDB and DWARF
- `ASM_OUTPUT_DWARF_PCREL`: SDB and DWARF
- `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_MEASURED_SIZE`: Label Output
- `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_SIZE_DIRECTIVE`: Label Output
- `ASM_OUTPUT_SKIP`: Alignment Output
- `ASM_OUTPUT_SOURCE_FILENAME`: File Framework
- `ASM_OUTPUT_SOURCE_LINE`: File Framework
- `ASM_OUTPUT_SPECIAL_POOL_ENTRY`: Data Output
- `ASM_OUTPUT_SYMBOL_REF`: Label Output
- `ASM_OUTPUT_TYPE_DIRECTIVE`: 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
- `attr`: Tagging Insns, 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
- `automata_option`: Automaton pipeline description
- automaton based pipeline description: Processor pipeline description, Comparison of the two descriptions, Automaton pipeline description
- automaton based scheduler: Processor pipeline description
- `AVOID_CCMODE_COPIES`: Values in Registers
- backslash: Output Template
- `barrier`: Insns
- `barrier` and `/f`: Flags
- `barrier` and `/i`: Flags
- `barrier` and `/v`: Flags
- `BASE_REG_CLASS`: Register Classes
- basic block reordering: Passes
- basic blocks: Passes
- `b` cond`` 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`: Sections, Exception Region Output, Sections
- `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`: Flags, Side Effects
- `call` instruction pattern: Standard Names
- `call` usage: Calls
- call-clobbered register: Register Basics
- call-saved register: Register Basics
- call-used register: Register Basics
- `CALL_EXPR`: Expression trees
- `call_insn`: Insns
- `call_insn` and `/f`: Flags
- `call_insn` and `/i`: Flags
- `call_insn` and `/j`: Flags
- `call_insn` and `/s`: Flags
- `call_insn` and `/u`: Flags
- `call_insn` and `/v`: 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`: Sections
- `CHAR_TYPE_SIZE`: Type 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_BY_PIECES_P`: Costs
- `CLEAR_INSN_CACHE`: Trampolines
- `CLEAR_RATIO`: Costs
- `clobber`: Side Effects
- `clrstr` m`` instruction pattern: Standard Names
- `cmp` m`` instruction pattern: Standard Names
- `cmpstr` m`` instruction pattern: Standard Names
- code generation RTL sequences: Expander Definitions
- code motion: Passes
- `code_label`: Insns
- `code_label` and `/i`: Flags
- `code_label` and `/v`: 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
- `concat` and `/u`: Flags
- `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
- `const` and `/i`: Flags
- `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 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
- `cos` m `2` instruction pattern: Standard Names
- 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: Floating Point
- `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
- data bypass: Automaton pipeline description, Comparison of the two descriptions
- data dependence delays: Processor pipeline description
- data flow analysis: Passes
- data structures: Per-Function Data
- `DATA_ALIGNMENT`: Storage Layout
- `data_section`: Sections
- `DATA_SECTION_ASM_OP`: Sections
- `DBR_OUTPUT_SEQEND`: Instruction Output
- `dbr_sequence_length`: Instruction Output
- `DBX_BLOCKS_FUNCTION_RELATIVE`: DBX Options
- `DBX_CONTIN_CHAR`: DBX Options
- `DBX_CONTIN_LENGTH`: DBX Options
- `DBX_DEBUGGING_INFO`: DBX Options
- `DBX_FUNCTION_FIRST`: DBX Options
- `DBX_LBRAC_FIRST`: DBX Options
- `DBX_MEMPARM_STABS_LETTER`: DBX Options
- `DBX_NO_XREFS`: DBX Options
- `DBX_OUTPUT_ENUM`: DBX Hooks
- `DBX_OUTPUT_FUNCTION_END`: DBX Hooks
- `DBX_OUTPUT_LBRAC`: DBX Hooks
- `DBX_OUTPUT_MAIN_SOURCE_DIRECTORY`: File Names and DBX
- `DBX_OUTPUT_MAIN_SOURCE_FILE_END`: File Names and DBX
- `DBX_OUTPUT_MAIN_SOURCE_FILENAME`: File Names and DBX
- `DBX_OUTPUT_NFUN`: DBX Hooks
- `DBX_OUTPUT_RBRAC`: DBX Hooks
- `DBX_OUTPUT_SOURCE_FILENAME`: File Names and DBX
- `DBX_OUTPUT_STANDARD_TYPES`: DBX Hooks
- `DBX_REGISTER_NUMBER`: All Debuggers
- `DBX_REGPARM_STABS_CODE`: DBX Options
- `DBX_REGPARM_STABS_LETTER`: DBX Options
- `DBX_STATIC_CONST_VAR_CODE`: DBX Options
- `DBX_STATIC_STAB_DATA_SECTION`: DBX Options
- `DBX_TYPE_DECL_STABS_CODE`: DBX Options
- `DBX_USE_BINCL`: DBX Options
- `DBX_WORKING_DIRECTORY`: File Names and DBX
- DCE, SSA based: Passes
- `DCmode`: Machine Modes
- De Morgan's law: Insn Canonicalizations
- dead code: Passes
- dead code elimination: Passes
- `dead_or_set_p`: define_peephole
- `DEBUG_SYMS_TEXT`: DBX Options
- `DEBUGGER_ARG_OFFSET`: All Debuggers
- `DEBUGGER_AUTO_OFFSET`: All Debuggers
- debugging information generation: Passes
- `DECL_ALIGN`: Declarations
- `DECL_ANTICIPATED`: Function Basics
- `DECL_ARGUMENTS`: Function Basics
- `DECL_ARRAY_DELETE_OPERATOR_P`: Function Basics
- `DECL_ARTIFICIAL`: Declarations, Function Basics
- `DECL_ASSEMBLER_NAME`: Function Basics
- `DECL_ATTRIBUTES`: Attributes
- `DECL_BASE_CONSTRUCTOR_P`: Function Basics
- `DECL_CLASS_SCOPE_P`: Declarations
- `DECL_COMPLETE_CONSTRUCTOR_P`: Function Basics
- `DECL_COMPLETE_DESTRUCTOR_P`: Function Basics
- `DECL_CONST_MEMFUNC_P`: Function Basics
- `DECL_CONSTRUCTOR_P`: Function Basics
- `DECL_CONTEXT`: Namespaces
- `DECL_CONV_FN_P`: Function Basics
- `DECL_COPY_CONSTRUCTOR_P`: Function Basics
- `DECL_DESTRUCTOR_P`: Function Basics
- `DECL_EXTERN_C_FUNCTION_P`: Function Basics
- `DECL_EXTERNAL`: Declarations, Function Basics
- `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`: Declarations, Function Basics, Namespaces, Function Basics
- `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
- `DECLARE_LIBRARY_RENAMES`: Library Calls
- `decrement_and_branch_until_zero` instruction pattern: Standard Names
- `default`: GTY Options
- `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_automaton`: Automaton pipeline description
- `define_bypass`: Automaton pipeline description
- `define_cond_exec`: Conditional Execution
- `define_constants`: Constant Definitions
- `define_cpu_unit`: Automaton pipeline description
- `define_delay`: Delay Slots
- `define_expand`: Expander Definitions
- `define_function_unit`: Old pipeline description
- `define_insn`: Patterns
- `define_insn` example: Example
- `define_insn_and_split`: Insn Splitting
- `define_insn_reservation`: Automaton pipeline description
- `define_peephole`: define_peephole
- `define_peephole2`: define_peephole2
- `define_query_cpu_unit`: Automaton pipeline description
- `define_reservation`: Automaton pipeline description
- `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
- `deletable`: GTY Options
- Dependent Patterns: Dependent Patterns
- `desc`: GTY Options
- destructor: Function Basics
- destructors, output of: Initialization
- deterministic finite state automaton: Processor pipeline description, Automaton pipeline description
- `DFA_PIPELINE_INTERFACE`: Scheduling
- `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
- `div` m `3` instruction pattern: Standard Names
- `divmod` m `4` 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
- `DRIVER_SELF_SPECS`: 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
- `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
- `exclusion_set`: Automaton pipeline description
- exclusive-or, bitwise: Arithmetic
- `EXIT_BODY`: Misc
- `EXIT_EXPR`: Expression trees
- `EXIT_IGNORE_STACK`: Function Entry
- `EXPAND_BUILTIN_SAVEREGS`: Varargs
- expander definitions: Expander Definitions
- `exp` m `2` instruction pattern: Standard Names
- `expr_list`: Insns
- `EXPR_STMT`: Function Bodies
- `EXPR_STMT_EXPR`: Function Bodies
- expression: Expression trees
- expression codes: RTL Objects
- `extend` mn `2` instruction pattern: Standard Names
- extensible constraints: Simple Constraints
- `extern int target_flags`: Run-time Target
- `EXTRA_ADDRESS_CONSTRAINT`: Register Classes
- `EXTRA_CC_MODES`: Condition Code
- `EXTRA_CONSTRAINT`: Register Classes
- `EXTRA_MEMORY_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
- `ffs` m `2` instruction pattern: Standard Names
- `FIELD_DECL`: Declarations
- `FILE_STMT`: Function Bodies
- `FILE_STMT_FILENAME`: Function Bodies
- files and passes of the compiler: Passes
- files, generated: Files
- 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
- finite state automaton minimization: Automaton pipeline description
- `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_trunc` mn `2` instruction pattern: Standard Names
- fixed register: Register Basics
- `FIXED_REGISTERS`: Register Basics
- `fixed_regs`: Register Basics
- `fix` mn `2` instruction pattern: Standard Names
- `FIXUNS_TRUNC_LIKE_FIX_TRUNC`: Misc
- `fixuns_trunc` mn `2` instruction pattern: Standard Names
- `fixuns` mn `2` 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: Floating Point
- `Floating Point Emulation`: Target Fragment
- `float` mn `2` instruction pattern: Standard Names
- `floatuns` mn `2` 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`, `call_insn`, `jump_insn`, `barrier`, and `set`: Flags
- `frame_related`, in `mem`: Flags
- `frame_related`, in `reg`: Flags
- `frame_related`, in `symbol_ref`: Flags
- `ftrunc` m `2` instruction pattern: Standard Names
- function: Functions
- function body: Function Bodies
- function call conventions: Interface
- function entry and exit: Function Entry
- function units, for scheduling: Old pipeline description
- function-call insns: Calls
- `FUNCTION_ARG`: Register Arguments
- `FUNCTION_ARG_ADVANCE`: Register Arguments
- `FUNCTION_ARG_BOUNDARY`: Register Arguments
- `FUNCTION_ARG_CALLEE_COPIES`: Register Arguments
- `FUNCTION_ARG_PADDING`: Register Arguments
- `FUNCTION_ARG_PARTIAL_NREGS`: Register Arguments
- `FUNCTION_ARG_PASS_BY_REFERENCE`: Register Arguments
- `FUNCTION_ARG_REGNO_P`: Register Arguments
- `FUNCTION_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
- generated files: Files
- 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
- GGC: Type Information
- 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
- graph coloring register allocation: Passes
- greater than: Comparisons
- `gt`: Comparisons
- `gt` and attributes: Expressions
- `GT_EXPR`: Expression trees
- `gtu`: Comparisons
- `gtu` and attributes: Expressions
- `GTY`: Type Information
- `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
- `HOT_TEXT_SECTION_NAME`: Sections
- `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_marked`: GTY Options
- `IF_STMT`: Function Bodies
- `if_then_else`: Comparisons
- `if_then_else` and attributes: Expressions
- `if_then_else` usage: Side Effects
- `IFCVT_EXTRA_FIELDS`: Misc
- `IFCVT_INIT_EXTRA_FIELDS`: Misc
- `IFCVT_MODIFY_CANCEL`: Misc
- `IFCVT_MODIFY_FINAL`: Misc
- `IFCVT_MODIFY_INSN`: Misc
- `IFCVT_MODIFY_MULTIPLE_TESTS`: 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` and `note`: Flags
- `in_struct`, in `insn`: Flags
- `in_struct`, in `insn` and `jump_insn` and `call_insn`: Flags
- `in_struct`, in `insn`, `jump_insn` and `call_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`: Sections, Macros for Initialization
- `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 `/i`: 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 latency time: Comparison of the two descriptions, Automaton pipeline description, Processor pipeline description
- 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`, `call_insn`, `jump_insn`, `barrier`, `code_label`, `insn_list`, `const`, and `note`: Flags
- `integrated`, in `reg`: Flags
- `integrated`, in `symbol_ref`: Flags
- Interdependence of Patterns: Dependent Patterns
- interfacing to GCC output: Interface
- interlock delays: Processor pipeline description, Comparison of the two descriptions
- `INTMAX_TYPE`: Type Layout
- introduction: Top
- `INVOKE__main`: Macros for Initialization
- `ior`: Arithmetic
- `ior` and attributes: Expressions
- `ior`, canonicalization of: Insn Canonicalizations
- `ior` m `3` instruction pattern: Standard Names
- `IS_ASM_LOGICAL_LINE_SEPARATOR`: Data Output
- `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 `mem`: Flags
- `JUMP_ALIGN`: Alignment Output
- `jump_insn`: Insns
- `jump_insn` and `/f`: Flags
- `jump_insn` and `/i`: Flags
- `jump_insn` and `/s`: Flags
- `jump_insn` and `/u`: Flags
- `jump_insn` and `/v`: Flags
- `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_ALT_ENTRY_P`: Insns
- `LABEL_DECL`: Declarations
- `LABEL_KIND`: Insns
- `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
- `LARGEST_EXPONENT_IS_NORMAL`: Storage Layout
- `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
- `le`: Comparisons
- `le` and attributes: Expressions
- `LE_EXPR`: Expression trees
- leaf functions: Leaf Functions
- `leaf_function_p`: Standard Names
- `LEAF_REG_REMAP`: Leaf Functions
- `LEAF_REGISTERS`: Leaf Functions
- left rotate: Arithmetic
- left shift: Arithmetic
- `LEGITIMATE_CONSTANT_P`: Addressing Modes
- `LEGITIMATE_PIC_OPERAND_P`: PIC
- `LEGITIMIZE_ADDRESS`: Addressing Modes
- `LEGITIMIZE_RELOAD_ADDRESS`: Addressing Modes
- `length`: GTY Options
- 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_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
- `log` m `2` instruction pattern: Standard Names
- `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
- `lshr` m `3` 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
- marking roots: GGC Roots
- `MASK_RETURN_ADDR`: Exception Region Output
- `match_dup`: define_peephole2, 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`: define_peephole2, 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_CONDITIONAL_EXECUTE`: Misc
- `MAX_DFA_ISSUE_RATE`: Scheduling
- `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
- `max` m `3` instruction pattern: Standard Names
- `MAYBE_REG_PARM_STACK_SPACE`: Stack Arguments
- `maybe_undef`: GTY Options
- `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
- `min` m `3` instruction pattern: Standard Names
- `minus`: Arithmetic
- `minus` and attributes: Expressions
- `minus`, canonicalization of: Insn Canonicalizations
- `MINUS_EXPR`: Expression trees
- MIPS coprocessor-definition macros: MIPS Coprocessors
- `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_HAS_INFINITIES`: Storage Layout
- `MODE_HAS_NANS`: Storage Layout
- `MODE_HAS_SIGN_DEPENDENT_ROUNDING`: Storage Layout
- `MODE_HAS_SIGNED_ZEROS`: Storage Layout
- `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_JNI_METHOD_CALL`: Misc
- `MODIFY_TARGET_NAME`: Driver
- `mod` m `3` instruction pattern: Standard Names
- `MODSI3_LIBCALL`: Library Calls
- `MOVE_BY_PIECES_P`: Costs
- `MOVE_MAX`: Misc
- `MOVE_MAX_PIECES`: Costs
- `MOVE_RATIO`: Costs
- `mov` m`` instruction pattern: Standard Names
- `mov` mode `cc` instruction pattern: Standard Names
- `movstrict` m`` instruction pattern: Standard Names
- `movstr` m`` instruction pattern: Standard Names
- `MULDI3_LIBCALL`: Library Calls
- `mulhisi3` instruction pattern: Standard Names
- `mul` m `3` 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`: Namespaces, Declarations
- `ne`: Comparisons
- `ne` and attributes: Expressions
- `NE_EXPR`: Expression trees
- `NEED_ATEXIT`: Misc
- `neg`: Arithmetic
- `neg` and attributes: Expressions
- `neg`, canonicalization of: Insn Canonicalizations
- `NEGATE_EXPR`: Expression trees
- `neg` m `2` 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_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
- nondeterministic finite state automaton: Automaton pipeline description
- `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` and `/i`: Flags
- `note` and `/v`: Flags
- `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
- old pipeline description: Comparison of the two descriptions, Old pipeline description
- `ON_EXIT`: Misc
- `one_cmpl` m `2` 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
- `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
- `param_is`: GTY Options
- parameters, miscellaneous: Misc
- `param` n`_is`: GTY Options
- `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
- pipeline hazard recognizer: Automaton pipeline description, Processor pipeline description, Comparison of the two descriptions
- `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
- `presence_set`: Automaton pipeline description
- `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 functional units: Automaton pipeline description, Comparison of the two descriptions, Processor pipeline description
- processor pipeline description: Processor pipeline description
- 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
- `push` m`` 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
- querying function unit reservations: Automaton pipeline description
- question mark: Multi-Alternative
- quotient: Arithmetic
- `r` in constraint: Simple Constraints
- `RDIV_EXPR`: Expression trees
- `READONLY_DATA_SECTION`: Sections
- `READONLY_DATA_SECTION_ASM_OP`: Sections
- `REAL_ARITHMETIC`: Floating Point
- `REAL_CST`: Expression trees
- `REAL_NM_FILE_NAME`: Macros for Initialization
- `REAL_TYPE`: Types
- `REAL_VALUE_ABS`: Floating Point
- `REAL_VALUE_ATOF`: Floating Point
- `REAL_VALUE_FIX`: Floating Point
- `REAL_VALUE_FROM_INT`: Floating Point
- `REAL_VALUE_ISINF`: Floating Point
- `REAL_VALUE_ISNAN`: Floating Point
- `REAL_VALUE_NEGATE`: Floating Point
- `REAL_VALUE_NEGATIVE`: Floating Point
- `REAL_VALUE_TO_INT`: Floating Point
- `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`: Floating Point
- `REAL_VALUE_TYPE`: Floating Point
- `REAL_VALUE_UNSIGNED_FIX`: Floating Point
- `REAL_VALUES_EQUAL`: Floating Point
- `REAL_VALUES_LESS`: Floating Point
- `REALPART_EXPR`: Expression trees
- `recog_data.operand`: Instruction Output
- recognizing insns: RTL Template
- `RECORD_TYPE`: Types, Classes
- 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_FRAME_RELATED_EXPR`: Insns
- `REG_FUNCTION_VALUE_P`: Flags
- `REG_INC`: Insns
- `REG_LABEL`: Insns
- `reg_label` and `/v`: Flags
- `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
- regular expressions: Automaton pipeline description, Processor pipeline description
- 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
- reservation delays: Processor pipeline description
- `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
- RISC: Automaton pipeline description, Processor pipeline description
- roots, marking: GGC Roots
- `rotate`: Arithmetic
- `rotatert`: Arithmetic
- `rotl` m `3` instruction pattern: Standard Names
- `rotr` m `3` instruction pattern: Standard Names
- `ROUND_TOWARDS_ZERO`: Storage Layout
- `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
- `SCHED_GROUP_P`: Flags
- scheduling, delayed branch: Passes
- scheduling, instruction: Passes
- `SCmode`: Machine Modes
- `s` cond`` 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
- `sequence`: Side Effects
- `set`: Side Effects
- `set` and `/f`: Flags
- `SET_ASM_OP`: Label Output
- `set_attr`: Tagging Insns
- `set_attr_alternative`: Tagging Insns
- `SET_DEST`: Side Effects
- `SET_IS_RETURN_P`: Flags
- `SET_LABEL_KIND`: Insns
- `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
- `sin` m `2` instruction pattern: Standard Names
- `SIZE_ASM_OP`: Label Output
- `SIZE_TYPE`: Type Layout
- `skip`: GTY Options
- `SLOW_BYTE_ACCESS`: Costs
- `SLOW_UNALIGNED_ACCESS`: Costs
- `SMALL_ARG_MAX`: Host Config
- `SMALL_REGISTER_CLASSES`: Register Classes
- `SMALL_STACK`: Frame Layout
- `smax`: Arithmetic
- `smax` m `3` instruction pattern: Standard Names
- `smin`: Arithmetic
- `smin` m `3` instruction pattern: Standard Names
- `smul` m `3_highpart` instruction pattern: Standard Names
- `special`: GTY Options
- `SPECIAL_MODE_PREDICATES`: Misc
- speed of instructions: Costs
- splitting instructions: Insn Splitting
- `sqrt`: Arithmetic
- `sqrt` m `2` 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
- `strlen` m`` 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
- `sub` m `3` instruction pattern: Standard Names
- `SUBOBJECT`: Function Bodies
- `SUBOBJECT_CLEANUP`: Function Bodies
- `subreg`: Regs and Memory
- `subreg` and `/s`: Flags
- `subreg` and `/u`: Flags
- `subreg` and `/u` and `/v`: 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_UNSIGNED_SET`: 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 `TARGET_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
- `tag`: GTY Options
- 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_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_ASSEMBLE_VISIBILITY`: Label 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_GLOBALIZE_LABEL`: Label Output
- `TARGET_ASM_INTEGER`: Data Output
- `TARGET_ASM_NAMED_SECTION`: File Framework
- `TARGET_ASM_OPEN_PAREN`: Data Output
- `TARGET_ASM_OUTPUT_MI_THUNK`: Function Entry
- `TARGET_ASM_OUTPUT_MI_VCALL_THUNK`: Function Entry
- `TARGET_ASM_SELECT_RTX_SECTION`: Sections
- `TARGET_ASM_SELECT_SECTION`: Sections
- `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_ASM_UNIQUE_SECTION`: Sections
- `TARGET_ATTRIBUTE_TABLE`: Target Attributes
- `TARGET_BELL`: Escape Sequences
- `TARGET_BINDS_LOCAL_P`: Sections
- `TARGET_BS`: Escape Sequences
- `TARGET_CANNOT_MODIFY_JUMPS_P`: Misc
- `TARGET_COMP_TYPE_ATTRIBUTES`: Target Attributes
- `TARGET_CPU_CPP_BUILTINS`: Run-time Target
- `TARGET_CR`: Escape Sequences
- `TARGET_DLLIMPORT_DECL_ATTRIBUTES`: Target Attributes
- `TARGET_EDOM`: Library Calls
- `TARGET_ENCODE_SECTION_INFO`: Sections
- `TARGET_ENCODE_SECTION_INFO` and address validation: Addressing Modes
- `TARGET_ENCODE_SECTION_INFO` usage: Instruction Output
- `TARGET_ESC`: Escape Sequences
- `TARGET_EXECUTABLE_SUFFIX`: Misc
- `TARGET_EXPAND_BUILTIN`: Misc
- `TARGET_FF`: Escape Sequences
- `TARGET_FLOAT_FORMAT`: Storage Layout
- `TARGET_FLT_EVAL_METHOD`: Type 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_IN_SMALL_DATA_P`: Sections
- `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_OS_CPP_BUILTINS`: Run-time Target
- `TARGET_PTRMEMFUNC_VBIT_LOCATION`: Type Layout
- `TARGET_SCHED_ADJUST_COST`: Scheduling
- `TARGET_SCHED_ADJUST_PRIORITY`: Scheduling
- `TARGET_SCHED_DFA_BUBBLE`: Scheduling
- `TARGET_SCHED_DFA_POST_CYCLE_INSN`: Scheduling
- `TARGET_SCHED_DFA_PRE_CYCLE_INSN`: Scheduling
- `TARGET_SCHED_FINISH`: Scheduling
- `TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD`: Scheduling
- `TARGET_SCHED_INIT`: Scheduling
- `TARGET_SCHED_INIT_DFA_BUBBLES`: Scheduling
- `TARGET_SCHED_INIT_DFA_POST_CYCLE_INSN`: Scheduling
- `TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN`: Scheduling
- `TARGET_SCHED_ISSUE_RATE`: Scheduling
- `TARGET_SCHED_REORDER`: Scheduling
- `TARGET_SCHED_REORDER2`: Scheduling
- `TARGET_SCHED_USE_DFA_PIPELINE_INTERFACE`: 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_DATA_ENTRY_DISTANCE`: Type Layout
- `TARGET_VTABLE_ENTRY_ALIGN`: Type Layout
- `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_PIPELINE_INTERFACE`: Scheduling
- `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: Macros and Functions, 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`: Types, Declarations, Function Basics, Expression trees
- `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
- `trunc` mn `2` 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
- `tst` m`` instruction pattern: Standard Names
- type: Types
- type declaration: Declarations
- `TYPE_ALIGN`: Types
- `TYPE_ARG_TYPES`: Types
- `TYPE_ASM_OP`: Label Output
- `TYPE_ATTRIBUTES`: Attributes
- `TYPE_BINFO`: Classes
- `TYPE_BUILT_IN`: Types
- `TYPE_CONTEXT`: Types
- `TYPE_DECL`: Declarations
- `TYPE_FIELDS`: Classes, 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_OPERAND_FMT`: Label Output
- `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
- `udiv` m `3` instruction pattern: Standard Names
- `udivmod` m `4` instruction pattern: Standard Names
- `UDIVSI3_LIBCALL`: Library Calls
- `UINTMAX_TYPE`: Type Layout
- `umax`: Arithmetic
- `umax` m `3` instruction pattern: Standard Names
- `umin`: Arithmetic
- `umin` m `3` instruction pattern: Standard Names
- `umod`: Arithmetic
- `UMODDI3_LIBCALL`: Library Calls
- `umod` m `3` instruction pattern: Standard Names
- `UMODSI3_LIBCALL`: Library Calls
- `umulhisi3` instruction pattern: Standard Names
- `umul` m `3_highpart` instruction pattern: Standard Names
- `umulqihi3` instruction pattern: Standard Names
- `umulsidi3` instruction pattern: Standard Names
- `unchanging`: Flags
- `unchanging`, in `call_insn`: Flags
- `unchanging`, in `jump_insn`, `call_insn` and `insn`: Flags
- `unchanging`, in `reg` and `mem`: Flags
- `unchanging`, in `subreg`: Flags
- `unchanging`, in `symbol_ref`: Flags
- `UNION_TYPE`: Types, Classes
- unions, returning: Interface
- `UNITS_PER_WORD`: Storage Layout
- `UNKNOWN_FLOAT_FORMAT`: Storage Layout
- `UNKNOWN_TYPE`: Types
- `UNLIKELY_EXECUTED_TEXT_SECTION_NAME`: Sections
- 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_param`: GTY Options
- `use_param` n``: GTY Options
- `use_params`: GTY Options
- `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
- `VA_ARG_EXPR`: Expression trees
- values, returned by functions: Scalar Return
- `VAR_DECL`: Expression trees, 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
- VLIW: Processor pipeline description, Automaton pipeline description
- `VMS`: Host Config
- `VMS_DEBUGGING_INFO`: VMS Debug
- `VOID_TYPE`: Types
- `VOIDmode`: Machine Modes
- `volatil`: Flags
- `volatil`, in `insn`, `call_insn`, `jump_insn`, `code_label`, `barrier`, and `note`: Flags
- `volatil`, in `label_ref` and `reg_label`: Flags
- `volatil`, in `mem`, `asm_operands`, and `asm_input`: Flags
- `volatil`, in `reg`: Flags
- `volatil`, in `subreg`: 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
- `xor` m `3` instruction pattern: Standard Names
- `XSTR`: Accessors
- `XVEC`: Accessors
- `XVECEXP`: Accessors
- `XVECLEN`: Accessors
- `XWINT`: Accessors
- `zero_extend`: Conversions
- `zero_extend` mn `2` instruction pattern: Standard Names
- `zero_extract`: Bit-Fields
- `zero_extract`, canonicalization of: Insn Canonicalizations