(gcc.info)Index


Prev: Config Up: Top

Index
*****

* #pragma
Misc
* $
Dollar Signs
* '
Incompatibilities
* (nil)
RTL Objects
* 3b1 installation
3b1 Install
* <?
Min and Max
* >?
Min and Max
* ?
side effect: Conditionals
* #pragma implementation, implied
C++ Interface
* #pragma, reason for not using
Function Attributes
* # in template
Output Template
* * in template
Output Statement
* ?
extensions: Conditionals
* ?
extensions: Lvalues
* absM2 instruction pattern
Standard Names
* abs and attributes
Expressions
* ACCUMULATE_OUTGOING_ARGS and stack frames
Function Entry
* addM3 instruction pattern
Standard Names
* addr_diff_vec, length of
Insn Lengths
* addr_vec, length of
Insn Lengths
* aligned attribute
Variable Attributes
* allocate_stack instruction pattern
Standard Names
* alloca and SunOs
Installation
* alloca vs variable-length arrays
Variable Length
* alloca, for SunOs
Sun Install
* alloca, for Unos
Unos Install
* andM3 instruction pattern
Standard Names
* and and attributes
Expressions
* and, canonicalization of
Insn Canonicalizations
* ARG_POINTER_REGNUM and virtual registers
Regs and Memory
* ashiftrt and attributes
Expressions
* ashift and attributes
Expressions
* ashlM3 instruction pattern
Standard Names
* ashrM3 instruction pattern
Standard Names
* asm_operands, RTL sharing
Sharing
* asm_operands, usage
Assembler
* asm expressions
Extended Asm
* bCOND instruction pattern
Standard Names
* bcopy, implicit usage
Library Calls
* BITS_BIG_ENDIAN, effect on sign_extract
Bit Fields
* BLKmode, and function return values
Calls
* bzero, implicit usage
Library Calls
* call_insn and /u
Flags
* call_pop instruction pattern
Standard Names
* call_value_pop instruction pattern
Standard Names
* call_value instruction pattern
Standard Names
* call instruction pattern
Standard Names
* call usage
Calls
* casesi instruction pattern
Standard Names
* cc0, RTL sharing
Sharing
* cmpM instruction pattern
Standard Names
* cmpstrM instruction pattern
Standard Names
* code_label and /i
Flags
* compare, canonicalization of
Insn Canonicalizations
* cond and attributes
Expressions
* const_double, RTL sharing
Sharing
* const_int and attribute tests
Expressions
* const_int and attributes
Expressions
* const_int, RTL sharing
Sharing
* const_string and attributes
Expressions
* const applied to function
Function Attributes
* const function attribute
Function Attributes
* define_insn example
Example
* divM3 instruction pattern
Standard Names
* divmodM4 instruction pattern
Standard Names
* div and attributes
Expressions
* EDOM, implicit usage
Library Calls
* ENCODE_SECTION_INFO and address validation
Addressing Modes
* ENCODE_SECTION_INFO usage
Instruction Output
* eq and attributes
Expressions
* errno, implicit usage
Library Calls
* extendMN instruction pattern
Standard Names
* extv instruction pattern
Standard Names
* extzv instruction pattern
Standard Names
* ffsM2 instruction pattern
Standard Names
* FIRST_PARM_OFFSET and virtual registers
Regs and Memory
* fixMN2 instruction pattern
Standard Names
* fixunsMN2 instruction pattern
Standard Names
* fixuns_truncMN2 instruction pattern
Standard Names
* fix_truncMN2 instruction pattern
Standard Names
* floatMN2 instruction pattern
Standard Names
* floatunsMN2 instruction pattern
Standard Names
* float as function value type
Incompatibilities
* format function attribute
Function Attributes
* FRAME_GROWS_DOWNWARD and virtual registers
Regs and Memory
* FRAME_POINTER_REGNUM and virtual registers
Regs and Memory
* fscanf, and constant strings
Incompatibilities
* ftruncM2 instruction pattern
Standard Names
* FUNCTION_EPILOGUE and trampolines
Trampolines
* FUNCTION_PROLOGUE and trampolines
Trampolines
* g++ 1.XX
Invoking G++
* g++ older version
Invoking G++
* g++, separate compiler
Invoking G++
* genflags, crash on Sun 4
Installation Problems
* geu and attributes
Expressions
* ge and attributes
Expressions
* goto in C++
Destructors and Goto
* gprof
Debugging Options
* gtu and attributes
Expressions
* gt and attributes
Expressions
* HImode, in insn
Insns
* if_then_else and attributes
Expressions
* if_then_else usage
Side Effects
* indirect_jump instruction pattern
Standard Names
* inline automatic for C++ member fns
Inline
* insn and /i
Flags
* insn and /s
Flags
* insn and /u
Flags
* insv instruction pattern
Standard Names
* integrated, in insn
Flags
* integrated, in reg
Flags
* in_struct, in code_label
Flags
* in_struct, in insn
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
* iorM3 instruction pattern
Standard Names
* ior and attributes
Expressions
* ior, canonicalization of
Insn Canonicalizations
* label_ref and /s
Flags
* label_ref, RTL sharing
Sharing
* leu and attributes
Expressions
* le and attributes
Expressions
* load_multiple instruction pattern
Standard Names
* long long data types
Long Long
* longjmp and automatic variables
Interface
* longjmp and automatic variables
C Dialect Options
* longjmp incompatibilities
Incompatibilities
* longjmp warnings
Warning Options
* lshiftrt and attributes
Expressions
* lshift and attributes
Expressions
* lshlM3 instruction pattern
Standard Names
* lshrM3 instruction pattern
Standard Names
* lt and attributes
Expressions
* main and the exit status
VMS Misc
* match_dup and attributes
Insn Lengths
* match_operand and attributes
Expressions
* maxM3 instruction pattern
Standard Names
* memcpy, implicit usage
Library Calls
* memset, implicit usage
Library Calls
* mem and /s
Flags
* mem and /u
Flags
* mem and /v
Flags
* mem, RTL sharing
Sharing
* minM3 instruction pattern
Standard Names
* minus and attributes
Expressions
* minus, canonicalization of
Insn Canonicalizations
* mktemp, and constant strings
Incompatibilities
* modM3 instruction pattern
Standard Names
* mode attribute
Variable Attributes
* mod and attributes
Expressions
* movM instruction pattern
Standard Names
* movstrM instruction pattern
Standard Names
* movstrictM instruction pattern
Standard Names
* mulM3 instruction pattern
Standard Names
* mulhisi3 instruction pattern
Standard Names
* mulqihi3 instruction pattern
Standard Names
* mulsidi3 instruction pattern
Standard Names
* mult and attributes
Expressions
* mult, canonicalization of
Insn Canonicalizations
* MUST_PASS_IN_STACK, and FUNCTION_ARG
Register Arguments
* negM2 instruction pattern
Standard Names
* neg and attributes
Expressions
* neg, canonicalization of
Insn Canonicalizations
* ne and attributes
Expressions
* nop instruction pattern
Standard Names
* noreturn function attribute
Function Attributes
* not and attributes
Expressions
* not, canonicalization of
Insn Canonicalizations
* one_cmplM2 instruction pattern
Standard Names
* packed attribute
Variable Attributes
* pc and attributes
Insn Lengths
* pc, RTL sharing
Sharing
* plus and attributes
Expressions
* plus, canonicalization of
Insn Canonicalizations
* prof
Debugging Options
* PUSH_ROUNDING, interaction with STACK_BOUNDARY
Storage Layout
* QImode, in insn
Insns
* qsort, and global register variables
Global Reg Vars
* REG_PARM_STACK_SPACE, and FUNCTION_ARG
Register Arguments
* reg and /i
Flags
* reg and /s
Flags
* reg and /u
Flags
* reg and /v
Flags
* reg, RTL sharing
Sharing
* reload_in instruction pattern
Standard Names
* reload_out instruction pattern
Standard Names
* restore_stack_block instruction pattern
Standard Names
* restore_stack_function instruction pattern
Standard Names
* restore_stack_nonlocal instruction pattern
Standard Names
* return instruction pattern
Standard Names
* return, in C++ function header
Naming Results
* rotlM3 instruction pattern
Standard Names
* rotrM3 instruction pattern
Standard Names
* sCOND instruction pattern
Standard Names
* save_stack_block instruction pattern
Standard Names
* save_stack_function instruction pattern
Standard Names
* save_stack_nonlocal instruction pattern
Standard Names
* scanf, and constant strings
Incompatibilities
* scratch, RTL sharing
Sharing
* setjmp incompatibilities
Incompatibilities
* sign_extract, canonicalization of
Insn Canonicalizations
* sqrtM2 instruction pattern
Standard Names
* sscanf, and constant strings
Incompatibilities
* STACK_DYNAMIC_OFFSET and virtual registers
Regs and Memory
* STACK_POINTER_OFFSET and virtual registers
Regs and Memory
* STACK_POINTER_REGNUM and virtual registers
Regs and Memory
* STARTING_FRAME_OFFSET and virtual registers
Regs and Memory
* strlenM instruction pattern
Standard Names
* subM3 instruction pattern
Standard Names
* subreg and /s
Flags
* subreg and /u
Flags
* subreg, in strict_low_part
RTL Declarations
* subreg, special reload handling
Regs and Memory
* SYMBOL_REF_FLAG, in ENCODE_SECTION_INFO
Sections
* symbol_ref and /u
Flags
* symbol_ref and /v
Flags
* symbol_ref, RTL sharing
Sharing
* tablejump instruction pattern
Standard Names
* tcov
Debugging Options
* truncMN instruction pattern
Standard Names
* tstM instruction pattern
Standard Names
* udivM3 instruction pattern
Standard Names
* udivmodM4 instruction pattern
Standard Names
* umaxM3 instruction pattern
Standard Names
* uminM3 instruction pattern
Standard Names
* umodM3 instruction pattern
Standard Names
* umulhisi3 instruction pattern
Standard Names
* umulqihi3 instruction pattern
Standard Names
* umulsidi3 instruction pattern
Standard Names
* unchanging, in call_insn
Flags
* unchanging, in insn
Flags
* unchanging, in reg and mem
Flags
* unchanging, in subreg
Flags
* unchanging, in symbol_ref
Flags
* untyped_call instruction pattern
Standard Names
* untyped_return instruction pattern
Standard Names
* used, in symbol_ref
Flags
* volatile applied to function
Function Attributes
* volatil, in insn
Flags
* volatil, in mem
Flags
* volatil, in reg
Flags
* volatil, in symbol_ref
Flags
* WORDS_BIG_ENDIAN, effect on subreg
Regs and Memory
* xorM3 instruction pattern
Standard Names
* xor, canonicalization of
Insn Canonicalizations
* zero_extendMN instruction pattern
Standard Names
* zero_extract, canonicalization of
Insn Canonicalizations
* libgcc.a
Library Calls
* stdarg.h and register arguments
Register Arguments
* stdarg.h and RT PC
RT Options
* tm.h macros
Target Macros
* varargs.h and RT PC
RT Options
* VAXCRTL
VMS Misc
* xm-MACHINE.h
Config
* ! in constraint
Multi-Alternative
* # in constraint
Modifiers
* % in constraint
Modifiers
* % in template
Output Template
* & in constraint
Modifiers
* * in constraint
Modifiers
* + in constraint
Modifiers
* /i in RTL dump
Flags
* /s 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
* d in constraint
Simple Constraints
* E in constraint
Simple Constraints
* F in constraint
Simple Constraints
* G in constraint
Simple Constraints
* g in constraint
Simple Constraints
* H in constraint
Simple Constraints
* I in constraint
Simple Constraints
* i in constraint
Simple Constraints
* m in constraint
Simple Constraints
* n in constraint
Simple Constraints
* o in constraint
Simple Constraints
* p in constraint
Simple Constraints
* Q, in constraint
Simple Constraints
* r in constraint
Simple Constraints
* store_multiple instruction pattern
Standard Names
* s in constraint
Simple Constraints
* V in constraint
Simple Constraints
* X in constraint
Simple Constraints
* _ in variables in macros
Naming Types
* abort
C Dialect Options
* abort
Portability
* abs
Arithmetic
* abs
C Dialect Options
* absolute value
Arithmetic
* access to operands
Accessors
* accessors
Accessors
* ACCUMULATE_OUTGOING_ARGS
Stack Arguments
* ADDITIONAL_REGISTER_NAMES
Instruction Output
* address
RTL Template
* address constraints
Simple Constraints
* address of a label
Labels as Values
* addressing modes
Addressing Modes
* ADDRESS_COST
Costs
* address_operand
Simple Constraints
* addr_diff_vec
Side Effects
* addr_vec
Side Effects
* ADJUST_COST
Costs
* ADJUST_INSN_LENGTH
Insn Lengths
* aggregates as return values
Aggregate Return
* alignment
Alignment
* Alliant
Interoperation
* alloca
C Dialect Options
* ALLOCATE_TRAMPOLINE
Trampolines
* ALL_REGS
Register Classes
* alternate keywords
Alternate Keywords
* AMD29K options
AMD29K Options
* analysis, data flow
Passes
* and
Arithmetic
* ANSI support
C Dialect Options
* apostrophes
Incompatibilities
* APPLY_RESULT_SIZE
Scalar Return
* ARGS_GROW_DOWNWARD
Frame Layout
* argument passing
Interface
* arguments in frame (88k)
M88K Options
* arguments in registers
Register Arguments
* arguments on stack
Stack Arguments
* ARG_POINTER_REGNUM
Frame Registers
* arg_pointer_rtx
Frame Registers
* arithmetic libraries
Interface
* arithmetic shift
Arithmetic
* arithmetic simplifications
Passes
* arithmetic, in RTL
Arithmetic
* arrays of length zero
Zero Length
* arrays of variable length
Variable Length
* arrays, non-lvalue
Subscripting
* ashift
Arithmetic
* ashiftrt
Arithmetic
* ASM_APP_OFF
File Framework
* ASM_APP_ON
File Framework
* ASM_BYTE_OP
Data Output
* ASM_CLOSE_PAREN
Data Output
* ASM_COMMENT_START
File Framework
* ASM_DECLARE_FUNCTION_NAME
Label Output
* ASM_DECLARE_FUNCTION_SIZE
Label Output
* ASM_DECLARE_OBJECT_NAME
Label Output
* ASM_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_GENERATE_INTERNAL_LABEL
Label Output
* ASM_GLOBALIZE_LABEL
Label Output
* ASM_IDENTIFY_GCC
File Framework
* asm_input
Side Effects
* asm_noperands
Insns
* ASM_NO_SKIP_IN_TEXT
Alignment Output
* ASM_OPEN_PAREN
Data Output
* ASM_OUTPUT_ADDR_DIFF_ELT
Dispatch Tables
* ASM_OUTPUT_ADDR_VEC_ELT
Dispatch Tables
* ASM_OUTPUT_ALIGN
Alignment Output
* ASM_OUTPUT_ALIGNED_COMMON
Uninitialized Data
* ASM_OUTPUT_ALIGNED_LOCAL
Uninitialized Data
* ASM_OUTPUT_ALIGN_CODE
Alignment Output
* ASM_OUTPUT_ASCII
Data Output
* ASM_OUTPUT_BYTE
Data Output
* ASM_OUTPUT_CASE_END
Dispatch Tables
* ASM_OUTPUT_CASE_LABEL
Dispatch Tables
* ASM_OUTPUT_CHAR
Data Output
* ASM_OUTPUT_COMMON
Uninitialized Data
* ASM_OUTPUT_CONSTRUCTOR
Macros for Initialization
* ASM_OUTPUT_DESTRUCTOR
Macros for Initialization
* ASM_OUTPUT_DOUBLE
Data Output
* ASM_OUTPUT_DOUBLE_INT
Data Output
* ASM_OUTPUT_EXTERNAL
Label Output
* ASM_OUTPUT_EXTERNAL_LIBCALL
Label Output
* ASM_OUTPUT_FLOAT
Data Output
* ASM_OUTPUT_IDENT
File Framework
* ASM_OUTPUT_INT
Data Output
* ASM_OUTPUT_INTERNAL_LABEL
Label Output
* ASM_OUTPUT_LABEL
Label Output
* ASM_OUTPUT_LABELREF
Label Output
* ASM_OUTPUT_LOCAL
Uninitialized Data
* ASM_OUTPUT_LONG_DOUBLE
Data Output
* ASM_OUTPUT_LOOP_ALIGN
Alignment Output
* ASM_OUTPUT_OPCODE
Instruction Output
* ASM_OUTPUT_POOL_PROLOGUE
Data Output
* ASM_OUTPUT_QUADRUPLE_INT
Data Output
* ASM_OUTPUT_REG_POP
Instruction Output
* ASM_OUTPUT_REG_PUSH
Instruction Output
* ASM_OUTPUT_SHARED_COMMON
Uninitialized Data
* ASM_OUTPUT_SHARED_LOCAL
Uninitialized Data
* ASM_OUTPUT_SHORT
Data Output
* ASM_OUTPUT_SKIP
Alignment Output
* ASM_OUTPUT_SOURCE_FILENAME
File Framework
* ASM_OUTPUT_SOURCE_LINE
File Framework
* ASM_OUTPUT_SPECIAL_POOL_ENTRY
Data Output
* ASM_SPEC
Driver
* ASM_STABD_OP
DBX Options
* ASM_STABN_OP
DBX Options
* ASM_STABS_OP
DBX Options
* assembler format
File Framework
* assembler instructions
Extended Asm
* assembler instructions in RTL
Assembler
* assembler names for identifiers
Asm Labels
* assembler syntax, 88k
M88K Options
* ASSEMBLER_DIALECT
Instruction Output
* assemble_name
Label Output
* assembly code, invalid
Bug Criteria
* assigning attribute values to insns
Tagging Insns
* asterisk in template
Output Statement
* atof
Cross-compilation
* attr
Tagging Insns
* attribute expressions
Expressions
* attribute of variables
Variable Attributes
* attribute specifications
Attr Example
* attribute specifications example
Attr Example
* attributes, defining
Defining Attributes
* attr_flag
Expressions
* autoincrement addressing, availability
Portability
* autoincrement/decrement addressing
Simple Constraints
* autoincrement/decrement analysis
Passes
* automatic inline for C++ member fns
Inline
* backslash
Output Template
* backtrace for bug reports
Bug Reporting
* barrier
Insns
* BASE_REG_CLASS
Register Classes
* basic blocks
Passes
* bcmp
Config
* BIGGEST_ALIGNMENT
Storage Layout
* BIGGEST_FIELD_ALIGNMENT
Storage Layout
* Bison parser generator
Installation
* bit fields
Bit Fields
* bit shift overflow (88k)
M88K Options
* BITFIELD_NBYTES_LIMITED
Storage Layout
* BITS_BIG_ENDIAN
Storage Layout
* BITS_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
* BLOCK_PROFILER
Profiling
* BLOCK_PROFILER_CODE
Profiling
* BRANCH_COST
Costs
* break_out_memory_refs
Addressing Modes
* bug criteria
Bug Criteria
* bug report mailing lists
Bug Lists
* bugs
Bugs
* bugs, known
Trouble
* builtin functions
C Dialect Options
* byte writes (29k)
AMD29K Options
* BYTES_BIG_ENDIAN
Storage Layout
* byte_mode
Machine Modes
* bzero
Config
* C compilation options
Invoking GCC
* C intermediate output, nonexistent
G++ and GCC
* C language extensions
C Extensions
* C language, traditional
C Dialect Options
* C statements for assembler output
Output Statement
* C++
G++ and GCC
* c++
Invoking G++
* C++ compilation options
Invoking GCC
* C++ interface and implementation headers
C++ Interface
* C++ language extensions
C++ Extensions
* C++ member fns, automatically inline
Inline
* C++ misunderstandings
C++ Misunderstandings
* C++ named return value
Naming Results
* C++ options, command line
C++ Dialect Options
* C++ pragmas, effect on inlining
C++ Interface
* C++ source file suffixes
Invoking G++
* C++ static data, declaring and defining
Static Definitions
* call
Side Effects
* call-clobbered register
Register Basics
* call-saved register
Register Basics
* call-used register
Register Basics
* CALLER_SAVE_PROFITABLE
Caller Saves
* calling conventions
Stack and Calling
* calling functions in RTL
Calls
* call_insn
Insns
* CALL_USED_REGISTERS
Register Basics
* call_used_regs
Register Basics
* canonicalization of instructions
Insn Canonicalizations
* CAN_ELIMINATE
Elimination
* case labels in initializers
Labeled Elements
* case ranges
Case Ranges
* case sensitivity and VMS
VMS Misc
* CASE_DROPS_THROUGH
Misc
* CASE_VALUES_THRESHOLD
Misc
* CASE_VECTOR_MODE
Misc
* CASE_VECTOR_PC_RELATIVE
Misc
* cast to a union
Cast to Union
* casts as lvalues
Lvalues
* cc0
Regs and Memory
* cc0_rtx
Regs and Memory
* CC1PLUS_SPEC
Driver
* CC1_SPEC
Driver
* CCmode
Machine Modes
* cc_status
Condition Code
* CC_STATUS_MDEP
Condition Code
* CC_STATUS_MDEP_INIT
Condition Code
* CDImode
Machine Modes
* change_address
Standard Names
* CHAR_TYPE_SIZE
Type Layout
* CHECK_FLOAT_VALUE
Storage Layout
* CHImode
Machine Modes
* class definitions, register
Register Classes
* class preference constraints
Class Preferences
* classes of RTX codes
Accessors
* CLASS_LIKELY_SPILLED_P
Register Classes
* CLASS_MAX_NREGS
Register Classes
* CLEAR_INSN_CACHE (BEG, END)
Trampolines
* clobber
Side Effects
* code generation conventions
Code Gen Options
* code generation RTL sequences
Expander Definitions
* code motion
Passes
* codes, RTL expression
RTL Objects
* code_label
Insns
* CODE_LABEL_NUMBER
Insns
* COImode
Machine Modes
* combiner pass
Regs and Memory
* command options
Invoking GCC
* common subexpression elimination
Passes
* compare
Arithmetic
* compilation in a separate directory
Other Dir
* compiler bugs, reporting
Bug Reporting
* compiler compared to C++ preprocessor
G++ and GCC
* compiler options, C++
C++ Dialect Options
* compiler passes and files
Passes
* compiler version, specifying
Target Options
* COMPILER_PATH
Environment Variables
* complement, bitwise
Arithmetic
* complex numbers
Complex
* compound expressions as lvalues
Lvalues
* computed gotos
Labels as Values
* computing the length of an insn
Insn Lengths
* cond
Comparisons
* condition code register
Regs and Memory
* condition code status
Condition Code
* condition codes
Comparisons
* conditional expressions as lvalues
Lvalues
* conditional expressions, extensions
Conditionals
* CONDITIONAL_REGISTER_USAGE
Register Basics
* conditions, in patterns
Patterns
* configuration file
Config
* conflicting types
Disappointments
* CONST0_RTX
Constants
* const0_rtx
Constants
* CONST1_RTX
Constants
* const1_rtx
Constants
* const2_rtx
Constants
* CONST2_RTX
Constants
* constant attributes
Constant Attributes
* constant folding
Passes
* constant folding and floating point
Cross-compilation
* constant propagation
Passes
* constants in constraints
Simple Constraints
* CONSTANT_ADDRESS_P
Addressing Modes
* CONSTANT_ALIGNMENT
Storage Layout
* CONSTANT_P
Addressing Modes
* CONSTANT_POOL_ADDRESS_P
Flags
* constm1_rtx
Constants
* constraint modifier characters
Modifiers
* constraint, matching
Simple Constraints
* constraints
Constraints
* constraints, machine specific
Machine Constraints
* constructing calls
Constructing Calls
* constructor expressions
Constructors
* constructors vs goto
Destructors and Goto
* constructors, output of
Initialization
* CONST_CALL_P
Flags
* CONST_COSTS
Costs
* const_double
Constants
* CONST_DOUBLE_CHAIN
Constants
* CONST_DOUBLE_LOW
Constants
* CONST_DOUBLE_MEM
Constants
* CONST_DOUBLE_OK_FOR_LETTER_P
Register Classes
* const_int
Constants
* CONST_OK_FOR_LETTER_P
Register Classes
* const_string
Constants
* const_true_rtx
Constants
* contributors
Contributors
* controlling register usage
Register Basics
* controlling the compilation driver
Driver
* conventions, run-time
Interface
* conversions
Conversions
* Convex options
Convex Options
* copy_rtx_if_shared
Sharing
* core dump
Bug Criteria
* cos
C Dialect Options
* costs of instructions
Costs
* COSTS_N_INSNS
Costs
* CPLUS_INCLUDE_PATH
Environment Variables
* CPP_PREDEFINES
Run-time Target
* CPP_SPEC
Driver
* CQImode
Machine Modes
* cross compilation and floating point
Cross-compilation
* cross compiling
Target Options
* cross-compiler, installation
Cross-Compiler
* cross-jumping
Passes
* CSImode
Machine Modes
* CTImode
Machine Modes
* CUMULATIVE_ARGS
Register Arguments
* current_function_epilogue_delay_list
Function Entry
* current_function_outgoing_args_size
Stack Arguments
* current_function_pops_args
Function Entry
* current_function_pretend_args_size
Function Entry
* C_INCLUDE_PATH
Environment Variables
* data flow analysis
Passes
* DATA_ALIGNMENT
Storage Layout
* data_section
Sections
* DATA_SECTION_ASM_OP
Sections
* DBR_OUTPUT_SEQEND
Instruction Output
* dbr_sequence_length
Instruction Output
* DBX
Interoperation
* DBX_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_FILENAME
File Names and DBX
* DBX_OUTPUT_MAIN_SOURCE_FILE_END
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_WORKING_DIRECTORY
File Names and DBX
* DCmode
Machine Modes
* De Morgan's law
Insn Canonicalizations
* dead code
Passes
* dead_or_set_p
Peephole Definitions
* deallocating variable length arrays
Variable Length
* death notes
Obsolete Register Macros
* DEBUGGER_ARG_OFFSET
All Debuggers
* DEBUGGER_AUTO_OFFSET
All Debuggers
* debugging information generation
Passes
* debugging information options
Debugging Options
* debugging, 88k OCS
M88K Options
* debug_rtx
Bug Reporting
* DEBUG_SYMS_TEXT
DBX Options
* declaration scope
Incompatibilities
* declarations inside expressions
Statement Exprs
* declarations, RTL
RTL Declarations
* declaring attributes of functions
Function Attributes
* declaring static data in C++
Static Definitions
* DEFAULT_CALLER_SAVES
Caller Saves
* DEFAULT_GDB_EXTENSIONS
DBX Options
* DEFAULT_MAIN_RETURN
Misc
* DEFAULT_PCC_STRUCT_RETURN
Aggregate Return
* DEFAULT_SHORT_ENUMS
Type Layout
* DEFAULT_SIGNED_CHAR
Type Layout
* define_asm_attributes
Tagging Insns
* define_attr
Defining Attributes
* define_delay
Delay Slots
* define_expand
Expander Definitions
* define_function_unit
Function Units
* define_insn
Patterns
* define_peephole
Expander Definitions
* define_split
Insn Splitting
* defining attributes and their values
Defining Attributes
* defining jump instruction patterns
Jump Patterns
* defining peephole optimizers
Peephole Definitions
* defining RTL sequences for code generation
Expander Definitions
* defining static data in C++
Static Definitions
* delay slots, defining
Delay Slots
* delayed branch scheduling
Passes
* DELAY_SLOTS_FOR_EPILOGUE
Function Entry
* dependencies for make as output
Environment Variables
* dependencies, make
Preprocessor Options
* DEPENDENCIES_OUTPUT
Environment Variables
* Dependent Patterns
Dependent Patterns
* destructors vs goto
Destructors and Goto
* destructors, output of
Initialization
* detecting -traditional
C Dialect Options
* DFmode
Machine Modes
* dialect options
C Dialect Options
* digits in constraint
Simple Constraints
* DImode
Machine Modes
* directory options
Directory Options
* disabling certain registers
Register Basics
* dispatch table
Dispatch Tables
* div
Arithmetic
* DIVDI3_LIBCALL
Library Calls
* divide instruction, 88k
M88K Options
* division
Arithmetic
* division
Arithmetic
* division
Arithmetic
* DIVSI3_LIBCALL
Library Calls
* dollar signs in identifier names
Dollar Signs
* DOLLARS_IN_IDENTIFIERS
Misc
* DONE
Expander Definitions
* DONT_REDUCE_ADDR
Costs
* double-word arithmetic
Long Long
* DOUBLE_TYPE_SIZE
Type Layout
* downward funargs
Nested Functions
* driver
Driver
* DW bit (29k)
AMD29K Options
* DWARF_DEBUGGING_INFO
SDB and DWARF
* DYNAMIC_CHAIN_ADDRESS
Frame Layout
* EASY_DIV_EXPR
Misc
* ELIGIBLE_FOR_EPILOGUE_DELAY
Function Entry
* ELIMINABLE_REGS
Elimination
* empty constraints
No Constraints
* EMPTY_FIELD_BOUNDARY
Storage Layout
* ENCODE_SECTION_INFO
Sections
* ENDFILE_SPEC
Driver
* endianness
Portability
* enum machine_mode
Machine Modes
* enum reg_class
Register Classes
* enumeration clash warnings
Warning Options
* environment variables
Environment Variables
* epilogue
Function Entry
* eq
Comparisons
* equal
Comparisons
* eq_attr
Expressions
* error
Storage Layout
* error messages
Warnings and Errors
* escape sequences, traditional
C Dialect Options
* exclamation point
Multi-Alternative
* exclusive-or, bitwise
Arithmetic
* EXECUTABLE_SUFFIX
Config
* exit
C Dialect Options
* exit status and VMS
VMS Misc
* EXIT_BODY
Misc
* EXIT_IGNORE_STACK
Function Entry
* expander definitions
Expander Definitions
* EXPAND_BUILTIN_SAVEREGS
Varargs
* explicit register variables
Explicit Reg Vars
* expression codes
RTL Objects
* expressions containing statements
Statement Exprs
* expressions, compound, as lvalues
Lvalues
* expressions, conditional, as lvalues
Lvalues
* expressions, constructor
Constructors
* expr_list
Insns
* extended asm
Extended Asm
* extensible constraints
Simple Constraints
* extensions, ?
Conditionals.
* extensions, ?
Lvalues.
* extensions, C language
C Extensions
* extensions, C++ language
C++ Extensions
* extern int target_flags
Run-time Target
* external declaration scope
Incompatibilities
* EXTRA_CC_MODES
Condition Code
* EXTRA_CC_NAMES
Condition Code
* EXTRA_CONSTRAINT
Register Classes
* EXTRA_SECTIONS
Sections
* EXTRA_SECTION_FUNCTIONS
Sections
* fabs
C Dialect Options
* FAIL
Expander Definitions
* FAILURE_EXIT_CODE
Config
* fatal signal
Bug Criteria
* features, optional, in system conventions
Run-time Target
* ffs
Arithmetic
* ffs
C Dialect Options
* file name suffix
Overall Options
* file names
Link Options
* files and passes of the compiler
Passes
* final pass
Passes
* FINALIZE_PIC
PIC
* FINAL_PRESCAN_INSN
Instruction Output
* FINAL_REG_PARM_STACK_SPACE
Stack Arguments
* final_scan_insn
Function Entry
* final_sequence
Instruction Output
* FIRST_INSN_ADDRESS
Insn Lengths
* FIRST_PARM_OFFSET
Frame Layout
* FIRST_PSEUDO_REGISTER
Register Basics
* FIRST_STACK_REG
Stack Registers
* FIRST_VIRTUAL_REGISTER
Regs and Memory
* fix
Conversions
* fix
Conversions
* fixed register
Register Basics
* FIXED_REGISTERS
Register Basics
* fixed_regs
Register Basics
* FIXUNS_TRUNC_LIKE_FIX_TRUNC
Misc
* flags in RTL expression
Flags
* float
Conversions
* FLOATIFY
Library Calls
* floating point and cross compilation
Cross-compilation
* FLOAT_ARG_TYPE
Library Calls
* float_extend
Conversions
* FLOAT_STORE_FLAG_VALUE
Misc
* float_truncate
Conversions
* FLOAT_TYPE_SIZE
Type Layout
* FLOAT_VALUE_TYPE
Library Calls
* FLOAT_WORDS_BIG_ENDIAN
Storage Layout
* force_reg
Standard Names
* forwarding calls
Constructing Calls
* frame layout
Frame Layout
* FRAME_GROWS_DOWNWARD
Frame Layout
* frame_pointer_needed
Function Entry
* FRAME_POINTER_REGNUM
Frame Registers
* FRAME_POINTER_REQUIRED
Elimination
* frame_pointer_rtx
Frame Registers
* function attributes
Function Attributes
* function call conventions
Interface
* function entry and exit
Function Entry
* function pointers, arithmetic
Pointer Arith
* function prototype declarations
Function Prototypes
* function units, for scheduling
Function Units
* function, size of pointer to
Pointer Arith
* function-call insns
Calls
* functions that have no side effects
Function Attributes
* functions that never return
Function Attributes
* functions with printf or scanf style arguments
Function Attributes
* functions, leaf
Leaf Functions
* FUNCTION_ARG
Register Arguments
* FUNCTION_ARG_ADVANCE
Register Arguments
* FUNCTION_ARG_BOUNDARY
Register Arguments
* FUNCTION_ARG_CALLEE_COPIES
Register Arguments
* FUNCTION_ARG_PADDING
Register Arguments
* FUNCTION_ARG_PARTIAL_NREGS
Register Arguments
* FUNCTION_ARG_PASS_BY_REFERENCE
Register Arguments
* FUNCTION_ARG_REGNO_P
Register Arguments
* FUNCTION_BLOCK_PROFILER
Profiling
* FUNCTION_BOUNDARY
Storage Layout
* FUNCTION_CONVERSION_BUG
Config
* FUNCTION_EPILOGUE
Function Entry
* FUNCTION_INCOMING_ARG
Register Arguments
* FUNCTION_MODE
Misc
* FUNCTION_OUTGOING_VALUE
Scalar Return
* FUNCTION_PROFILER
Profiling
* FUNCTION_PROLOGUE
Function Entry
* FUNCTION_VALUE
Scalar Return
* FUNCTION_VALUE_REGNO_P
Scalar Return
* g++
Invoking G++
* G++
G++ and GCC
* GCC
G++ and GCC
* GCC_EXEC_PREFIX
Environment Variables
* ge
Comparisons
* gencodes
Passes
* genconfig
Passes
* generalized lvalues
Lvalues
* general_operand
RTL Template
* GENERAL_REGS
Register Classes
* generating assembler output
Output Statement
* generating insns
RTL Template
* genflags
Passes
* GEN_ERRNO_RTX
Library Calls
* 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
Accessors
* GET_RTX_FORMAT
Accessors
* GET_RTX_LENGTH
Accessors
* geu
Comparisons
* global offset table
Code Gen Options
* global register after longjmp
Global Reg Vars
* global register allocation
Passes
* global register variables
Global Reg Vars
* GLOBALDEF
Global Declarations
* GLOBALREF
Global Declarations
* GLOBALVALUEDEF
Global Declarations
* GLOBALVALUEREF
Global Declarations
* GNU CC and portability
Portability
* GNU CC command options
Invoking GCC
* goto with computed label
Labels as Values
* GO_IF_LEGITIMATE_ADDRESS
Addressing Modes
* GO_IF_MODE_DEPENDENT_ADDRESS
Addressing Modes
* gp-relative references (MIPS)
MIPS Options
* greater than
Comparisons
* greater than
Comparisons
* greater than
Comparisons
* grouping options
Invoking GCC
* gt
Comparisons
* gtu
Comparisons
* HANDLE_PRAGMA
Misc
* hard registers
Regs and Memory
* hardware models and configurations, specifying
Submodel Options
* HARD_FRAME_POINTER_REGNUM
Frame Registers
* HARD_REGNO_MODE_OK
Values in Registers
* HARD_REGNO_NREGS
Values in Registers
* HAVE_ATEXIT
Misc
* HAVE_POST_DECREMENT
Addressing Modes
* HAVE_POST_INCREMENT
Addressing Modes
* HAVE_PRE_DECREMENT
Addressing Modes
* HAVE_PRE_INCREMENT
Addressing Modes
* HAVE_PUTENV
Config
* HAVE_VPRINTF
Config
* header files and VMS
Include Files and VMS
* high
Constants
* HImode
Machine Modes
* HOST_BITS_PER_CHAR
Config
* HOST_BITS_PER_INT
Config
* HOST_BITS_PER_LONG
Config
* HOST_BITS_PER_SHORT
Config
* HOST_FLOAT_FORMAT
Config
* HOST_FLOAT_WORDS_BIG_ENDIAN
Config
* HOST_WORDS_BIG_ENDIAN
Config
* HPPA Options
HPPA Options
* i386 Options
i386 Options
* IBM RS/6000 and PowerPC Options
RS/6000 and PowerPC Options
* IBM RT options
RT Options
* IBM RT PC
Interoperation
* identifier names, dollar signs in
Dollar Signs
* identifiers, names in assembler code
Asm Labels
* identifying source, compiler (88k)
M88K Options
* IEEE_FLOAT_FORMAT
Storage Layout
* if_then_else
Comparisons
* immediate_operand
RTL Template
* IMMEDIATE_PREFIX
Instruction Output
* implicit argument
return value: Naming Results
* IMPLICIT_FIX_EXPR
Misc
* implied #pragma implementation
C++ Interface
* include files and VMS
Include Files and VMS
* INCLUDE_DEFAULTS
Driver
* inclusive-or, bitwise
Arithmetic
* INCOMING_REGNO
Register Basics
* incompatibilities of GNU CC
Incompatibilities
* increment operators
Bug Criteria
* INDEX_REG_CLASS
Register Classes
* initialization routines
Initialization
* initializations in expressions
Constructors
* initializers with labeled elements
Labeled Elements
* initializers, non-constant
Initializers
* INITIALIZE_TRAMPOLINE
Trampolines
* INITIAL_ELIMINATION_OFFSET
Elimination
* INITIAL_FRAME_POINTER_OFFSET
Elimination
* INIT_CUMULATIVE_ARGS
Register Arguments
* INIT_CUMULATIVE_INCOMING_ARGS
Register Arguments
* INIT_SECTION_ASM_OP
Sections
* INIT_SECTION_ASM_OP
Macros for Initialization
* inline functions
Inline
* inline functions, omission of
Inline
* inline, automatic
Passes
* inlining and C++ pragmas
C++ Interface
* insn
Insns
* insn attributes
Insn Attributes
* insn canonicalization
Insn Canonicalizations
* insn lengths, computing
Insn Lengths
* insn splitting
Insn Splitting
* insn-attr.h
Defining Attributes
* insns
Insns
* insns, generating
RTL Template
* insns, recognizing
RTL Template
* INSN_ANNULLED_BRANCH_P
Flags
* INSN_CACHE_DEPTH
Trampolines
* INSN_CACHE_LINE_WIDTH
Trampolines
* INSN_CACHE_SIZE
Trampolines
* INSN_CLOBBERS_REGNO_P
Obsolete Register Macros
* INSN_CODE
Insns
* INSN_DELETED_P
Flags
* INSN_FROM_TARGET_P
Flags
* insn_list
Insns
* INSN_REFERENCES_ARE_DELAYED
Misc
* INSN_SETS_ARE_DELAYED
Misc
* INSN_UID
Insns
* installation trouble
Trouble
* installing GNU CC
Installation
* installing GNU CC on the 3b1
3b1 Install
* installing GNU CC on the Sun
Sun Install
* installing GNU CC on Unos
Unos Install
* installing GNU CC on VMS
VMS Install
* instruction attributes
Insn Attributes
* instruction combination
Passes
* instruction patterns
Patterns
* instruction recognizer
Passes
* instruction scheduling
Passes
* instruction scheduling
Passes
* instruction splitting
Insn Splitting
* integrated
Flags
* INTEGRATE_THRESHOLD
Misc
* integrating function code
Inline
* Intel 386 Options
i386 Options
* Interdependence of Patterns
Dependent Patterns
* interface and implementation headers, C++
C++ Interface
* interfacing to GNU CC output
Interface
* intermediate C version, nonexistent
G++ and GCC
* INTIFY
Library Calls
* introduction
Top
* INT_TYPE_SIZE
Type Layout
* invalid assembly code
Bug Criteria
* invalid input
Bug Criteria
* invoking g++
Invoking G++
* in_data
Sections
* in_struct
Flags
* in_text
Sections
* ior
Arithmetic
* isinf
Cross-compilation
* isnan
Cross-compilation
* IS_ASM_LOGICAL_LINE_SEPARATOR
Data Output
* jump instruction patterns
Jump Patterns
* jump instructions and set
Side Effects
* jump optimization
Passes
* jump threading
Passes
* jump_insn
Insns
* JUMP_LABEL
Insns
* JUMP_TABLES_IN_TEXT_SECTION
Sections
* kernel and user registers (29k)
AMD29K Options
* keywords, alternate
Alternate Keywords
* known causes of trouble
Trouble
* labeled elements in initializers
Labeled Elements
* labels as values
Labels as Values
* LABEL_NUSES
Insns
* LABEL_OUTSIDE_LOOP_P
Flags
* LABEL_PRESERVE_P
Flags
* label_ref
Constants
* labs
C Dialect Options
* language dialect options
C Dialect Options
* large bit shifts (88k)
M88K Options
* large return values
Aggregate Return
* LAST_STACK_REG
Stack Registers
* LAST_VIRTUAL_REGISTER
Regs and Memory
* ldexp
Cross-compilation
* le
Comparisons
* leaf functions
Leaf Functions
* leaf_function
Leaf Functions
* leaf_function_p
Standard Names
* LEAF_REGISTERS
Leaf Functions
* LEAF_REG_REMAP
Leaf Functions
* left rotate
Arithmetic
* left shift
Arithmetic
* left shift
Arithmetic
* LEGITIMATE_CONSTANT_P
Addressing Modes
* LEGITIMATE_PIC_OPERAND_P
PIC
* LEGITIMIZE_ADDRESS
Addressing Modes
* length-zero arrays
Zero Length
* less than
Comparisons
* less than or equal
Comparisons
* leu
Comparisons
* LIBCALL_VALUE
Scalar Return
* LIBGCC_NEEDS_DOUBLE
Library Calls
* Libraries
Link Options
* library subroutine names
Library Calls
* LIBRARY_PATH
Environment Variables
* LIB_SPEC
Driver
* LIMIT_RELOAD_CLASS
Register Classes
* link options
Link Options
* LINK_LIBGCC_SPECIAL
Driver
* LINK_LIBGCC_SPECIAL_1
Driver
* LINK_SPEC
Driver
* load address instruction
Simple Constraints
* LOAD_EXTEND_OP
Misc
* local labels
Local Labels
* local register allocation
Passes
* local variables in macros
Naming Types
* local variables, specifying registers
Local Reg Vars
* LOCAL_INCLUDE_DIR
Driver
* LOCAL_LABEL_PREFIX
Instruction Output
* logical shift
Arithmetic
* logical-and, bitwise
Arithmetic
* LOG_LINKS
Insns
* longjmp
Global Reg Vars
* LONGJMP_RESTORE_FROM_STACK
Elimination
* LONG_DOUBLE_TYPE_SIZE
Type Layout
* LONG_LONG_TYPE_SIZE
Type Layout
* LONG_TYPE_SIZE
Type Layout
* loop optimization
Passes
* lo_sum
Arithmetic
* lshift
Arithmetic
* lshiftrt
Arithmetic
* lt
Comparisons
* ltu
Comparisons
* lvalues, generalized
Lvalues
* M680x0 options
M680x0 Options
* M88k options
M88K Options
* machine dependent options
Submodel Options
* machine description macros
Target Macros
* machine descriptions
Machine Desc
* machine mode conversions
Conversions
* machine modes
Machine Modes
* machine specific constraints
Machine Constraints
* macro with variable arguments
Macro Varargs
* macros containing asm
Extended Asm
* macros, inline alternative
Inline
* macros, local labels
Local Labels
* macros, local variables in
Naming Types
* macros, statements in expressions
Statement Exprs
* macros, target description
Target Macros
* macros, types of arguments
Typeof
* make
Preprocessor Options
* make_safe_from
Expander Definitions
* matching constraint
Simple Constraints
* matching operands
Output Template
* match_dup
RTL Template
* match_operand
RTL Template
* match_operator
RTL Template
* match_op_dup
RTL Template
* match_parallel
RTL Template
* match_par_dup
RTL Template
* match_scratch
RTL Template
* math libraries
Interface
* math, in RTL
Arithmetic
* maximum operator
Min and Max
* MAX_BITS_PER_WORD
Storage Layout
* MAX_CHAR_TYPE_SIZE
Type Layout
* MAX_FIXED_MODE_SIZE
Storage Layout
* MAX_INT_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_UNITS_PER_WORD
Storage Layout
* MAX_WCHAR_TYPE_SIZE
Type Layout
* MAYBE_REG_PARM_STACK_SPACE
Stack Arguments
* mcount
Profiling
* MD_CALL_PROTOTYPES
Config
* MD_EXEC_PREFIX
Driver
* MD_STARTFILE_PREFIX
Driver
* MD_STARTFILE_PREFIX_1
Driver
* mem
Regs and Memory
* member fns, automatically inline
Inline
* memcmp
C Dialect Options
* memcpy
C Dialect Options
* memory model (29k)
AMD29K Options
* memory reference, nonoffsettable
Simple Constraints
* memory references in constraints
Simple Constraints
* MEMORY_MOVE_COST
Costs
* MEM_IN_STRUCT_P
Flags
* MEM_VOLATILE_P
Flags
* messages, warning
Warning Options
* messages, warning and error
Warnings and Errors
* middle-operands, omitted
Conditionals
* minimum operator
Min and Max
* minus
Arithmetic
* MIPS options
MIPS Options
* misunderstandings in C++
C++ Misunderstandings
* mod
Arithmetic
* MODDI3_LIBCALL
Library Calls
* mode classes
Machine Modes
* MODES_TIEABLE_P
Values in Registers
* MODE_CC
Machine Modes
* MODE_COMPLEX_FLOAT
Machine Modes
* MODE_COMPLEX_INT
Machine Modes
* MODE_FLOAT
Machine Modes
* MODE_FUNCTION
Machine Modes
* MODE_INT
Machine Modes
* MODE_PARTIAL_INT
Machine Modes
* MODE_RANDOM
Machine Modes
* modifiers in constraints
Modifiers
* MODSI3_LIBCALL
Library Calls
* MOVE_MAX
Misc
* MOVE_RATIO
Costs
* MULDI3_LIBCALL
Library Calls
* MULSI3_LIBCALL
Library Calls
* mult
Arithmetic
* MULTIBYTE_CHARS
Config
* multiple alternative constraints
Multi-Alternative
* multiplication
Arithmetic
* multiprecision arithmetic
Long Long
* name augmentation
VMS Misc
* named patterns and conditions
Patterns
* named return value in C++
Naming Results
* names used in assembler code
Asm Labels
* names, pattern
Standard Names
* naming convention, implementation headers
C++ Interface
* naming types
Naming Types
* ne
Comparisons
* neg
Arithmetic
* nested functions
Nested Functions
* nested functions, trampolines for
Trampolines
* newline vs string constants
C Dialect Options
* next_cc0_user
Jump Patterns
* NEXT_INSN
Insns
* NEXT_OBJC_RUNTIME
Library Calls
* nil
RTL Objects
* no constraints
No Constraints
* no-op move instructions
Passes
* non-constant initializers
Initializers
* non-static inline function
Inline
* nongcc_SI_type
Library Calls
* nongcc_word_type
Library Calls
* nonoffsettable memory reference
Simple Constraints
* NON_SAVING_SETJMP
Register Basics
* not
Arithmetic
* not equal
Comparisons
* not using constraints
No Constraints
* note
Insns
* NOTE_INSN_BLOCK_BEG
Insns
* NOTE_INSN_BLOCK_END
Insns
* NOTE_INSN_DELETED
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
* NO_BUILTIN_PTRDIFF_TYPE
Driver
* NO_BUILTIN_SIZE_TYPE
Driver
* NO_DOLLAR_IN_LABEL
Misc
* NO_DOT_IN_LABEL
Misc
* NO_FUNCTION_CSE
Costs
* NO_IMPLICIT_EXTERN_C
Misc
* NO_MD_PROTOTYPES
Config
* NO_RECURSIVE_FUNCTION_CSE
Costs
* NO_REGS
Register Classes
* NO_STAB_H
Config
* NO_SYS_SIGLIST
Config
* NUM_MACHINE_MODES
Machine Modes
* N_REG_CLASSES
Register Classes
* OBJC_GEN_METHOD_LABEL
Label Output
* OBJC_INCLUDE_PATH
Environment Variables
* OBJC_INT_SELECTORS
Type Layout
* OBJC_PROLOGUE
File Framework
* OBJC_SELECTORS_WITHOUT_LABELS
Type Layout
* Objective C
G++ and GCC
* OBJECT_FORMAT_COFF
Macros for Initialization
* OBJECT_FORMAT_ROSE
Macros for Initialization
* OBSTACK_CHUNK_ALLOC
Config
* OBSTACK_CHUNK_FREE
Config
* OBSTACK_CHUNK_SIZE
Config
* obstack_free
3b1 Install
* OCS (88k)
M88K Options
* offsettable address
Simple Constraints
* old-style function definitions
Function Prototypes
* omitted middle-operands
Conditionals
* ONLY_INT_FIELDS
Config
* open coding
Inline
* operand access
Accessors
* operand constraints
Constraints
* operand substitution
Output Template
* operands
Patterns
* OPTIMIZATION_OPTIONS
Run-time Target
* optimize options
Optimize Options
* optional hardware or system features
Run-time Target
* options to control warnings
Warning Options
* options, C++
C++ Dialect Options
* options, code generation
Code Gen Options
* options, debugging
Debugging Options
* options, dialect
C Dialect Options
* options, directory search
Directory Options
* options, GNU CC command
Invoking GCC
* options, grouping
Invoking GCC
* options, linking
Link Options
* options, optimization
Optimize Options
* options, order
Invoking GCC
* options, preprocessor
Preprocessor Options
* order of evaluation, side effects
Non-bugs
* order of options
Invoking GCC
* order of register allocation
Allocation Order
* Ordering of Patterns
Pattern Ordering
* ORDER_REGS_FOR_LOCAL_ALLOC
Allocation Order
* other directory, compilation in
Other Dir
* OUTGOING_REGNO
Register Basics
* OUTGOING_REG_PARM_STACK_SPACE
Stack Arguments
* output file option
Overall Options
* output of assembler code
File Framework
* output statements
Output Statement
* output templates
Output Template
* output_addr_const
Data Output
* output_asm_insn
Output Statement
* overflow while constant folding
Cross-compilation
* OVERLAPPING_REGNO_P
Obsolete Register Macros
* overloaded virtual fn, warning
Warning Options
* OVERRIDE_OPTIONS
Run-time Target
* parallel
Side Effects
* parameter forward declaration
Variable Length
* parameters, miscellaneous
Misc
* PARM_BOUNDARY
Storage Layout
* parser generator, Bison
Installation
* parsing pass
Passes
* passes and files of the compiler
Passes
* passing arguments
Interface
* PATTERN
Insns
* pattern conditions
Patterns
* pattern names
Standard Names
* Pattern Ordering
Pattern Ordering
* patterns
Patterns
* pc
Regs and Memory
* PCC_BITFIELD_TYPE_MATTERS
Storage Layout
* PCC_STATIC_STRUCT_RETURN
Aggregate Return
* pc_rtx
Regs and Memory
* PDImode
Machine Modes
* peephole optimization
Passes
* peephole optimization, RTL representation
Side Effects
* peephole optimizer definitions
Peephole Definitions
* percent sign
Output Template
* perform_...
Library Calls
* PIC
Code Gen Options
* PIC
PIC
* PIC_OFFSET_TABLE_REGNUM
PIC
* plus
Arithmetic
* Pmode
Misc
* pointer arguments
Function Attributes
* POINTER_SIZE
Storage Layout
* portability
Portability
* portions of temporary objects, pointers to
Temporaries
* position independent code
PIC
* post_dec
Incdec
* post_inc
Incdec
* pragma
Misc
* pragma, reason for not using
Function Attributes
* pragmas in C++, effect on inlining
C++ Interface
* pragmas, interface and implementation
C++ Interface
* predefined macros
Run-time Target
* PREDICATE_CODES
Misc
* PREFERRED_DEBUGGING_TYPE
All Debuggers
* PREFERRED_OUTPUT_RELOAD_CLASS
Register Classes
* PREFERRED_RELOAD_CLASS
Register Classes
* preprocessing numbers
Incompatibilities
* preprocessing tokens
Incompatibilities
* preprocessor options
Preprocessor Options
* PRESERVE_DEATH_INFO_REGNO_P
Obsolete Register Macros
* prev_cc0_setter
Jump Patterns
* PREV_INSN
Insns
* prev_nonnote_insn
Peephole Definitions
* pre_dec
Incdec
* pre_inc
Incdec
* PRINT_OPERAND
Instruction Output
* PRINT_OPERAND_ADDRESS
Instruction Output
* PRINT_OPERAND_PUNCT_VALID_P
Instruction Output
* processor selection (29k)
AMD29K Options
* product
Arithmetic
* PROFILE_BEFORE_PROLOGUE
Profiling
* profiling, code generation
Profiling
* program counter
Regs and Memory
* prologue
Function Entry
* PROMOTE_FUNCTION_ARGS
Storage Layout
* PROMOTE_FUNCTION_RETURN
Storage Layout
* PROMOTE_MODE
Storage Layout
* PROMOTE_PROTOTYPES
Stack Arguments
* promotion of formal parameters
Function Prototypes
* pseudo registers
Regs and Memory
* PSImode
Machine Modes
* PTRDIFF_TYPE
Type Layout
* push address instruction
Simple Constraints
* PUSH_ROUNDING
Stack Arguments
* putenv
Config
* PUT_CODE
RTL Objects
* PUT_MODE
Machine Modes
* PUT_REG_NOTE_KIND
Insns
* PUT_SDB_...
SDB and DWARF
* QImode
Machine Modes
* question mark
Multi-Alternative
* quotient
Arithmetic
* r0-relative references (88k)
M88K Options
* ranges in case statements
Case Ranges
* read-only strings
Incompatibilities
* READONLY_DATA_SECTION
Sections
* REAL_ARITHMETIC
Cross-compilation
* REAL_INFINITY
Cross-compilation
* REAL_NM_FILE_NAME
Macros for Initialization
* REAL_VALUES_EQUAL
Cross-compilation
* REAL_VALUES_LESS
Cross-compilation
* 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
* recognizing insns
RTL Template
* recog_operand
Instruction Output
* reg
Regs and Memory
* register allocation
Passes
* register allocation order
Allocation Order
* register allocation, stupid
Passes
* register class definitions
Register Classes
* register class preference constraints
Class Preferences
* register class preference pass
Passes
* register pairs
Values in Registers
* register positions in frame (88k)
M88K Options
* register positions in frame (88k)
M88K Options
* Register Transfer Language (RTL)
RTL
* register usage
Registers
* register use analysis
Passes
* register variable after longjmp
Global Reg Vars
* register-to-stack conversion
Passes
* registers
Extended Asm
* registers arguments
Register Arguments
* registers for local variables
Local Reg Vars
* registers in constraints
Simple Constraints
* registers, global allocation
Explicit Reg Vars
* registers, global variables in
Global Reg Vars
* REGISTER_MOVE_COST
Costs
* REGISTER_NAMES
Instruction Output
* register_operand
RTL Template
* REGISTER_PREFIX
Instruction Output
* REGNO_OK_FOR_BASE_P
Register Classes
* REGNO_OK_FOR_INDEX_P
Register Classes
* REGNO_REG_CLASS
Register Classes
* regs_ever_live
Function Entry
* REG_ALLOC_ORDER
Allocation Order
* 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_FUNCTION_VALUE_P
Flags
* REG_INC
Insns
* REG_LABEL
Insns
* REG_LEAF_ALLOC_ORDER
Leaf Functions
* REG_LIBCALL
Insns
* REG_LOOP_TEST_P
Flags
* reg_names
Instruction Output
* REG_NONNEG
Insns
* REG_NOTES
Insns
* REG_NOTE_KIND
Insns
* REG_NO_CONFLICT
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_RETVAL
Insns
* REG_UNUSED
Insns
* REG_USERVAR_P
Flags
* REG_WAS_0
Insns
* relative costs
Costs
* RELATIVE_PREFIX_NOT_LINKDIR
Driver
* reload pass
Regs and Memory
* reloading
Passes
* reload_completed
Standard Names
* reload_in_progress
Standard Names
* remainder
Arithmetic
* reporting bugs
Bugs
* representation of RTL
RTL
* rest argument (in macro)
Macro Varargs
* rest_of_compilation
Passes
* rest_of_decl_compilation
Passes
* return
Side Effects
* return value of main
VMS Misc
* return value, named, in C++
Naming Results
* return values in registers
Scalar Return
* returning aggregate values
Aggregate Return
* returning structures and unions
Interface
* RETURN_ADDR_IN_PREVIOUS_FRAME
Frame Layout
* RETURN_ADDR_RTX
Frame Layout
* RETURN_IN_MEMORY
Aggregate Return
* RETURN_POPS_ARGS
Stack Arguments
* right rotate
Arithmetic
* right shift
Arithmetic
* rotate
Arithmetic
* rotate
Arithmetic
* rotatert
Arithmetic
* ROUND_TYPE_ALIGN
Storage Layout
* ROUND_TYPE_SIZE
Storage Layout
* RS/6000 and PowerPC Options
RS/6000 and PowerPC Options
* RT options
RT Options
* RT PC
Interoperation
* RTL addition
Arithmetic
* RTL 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
Accessors
* RTL format characters
Accessors
* 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_COSTS
Costs
* RTX_INTEGRATED_P
Flags
* RTX_UNCHANGING_P
Flags
* run-time conventions
Interface
* run-time options
Code Gen Options
* run-time target specification
Run-time Target
* saveable_obstack
Addressing Modes
* scalars, returned as values
Scalar Return
* SCCS_DIRECTIVE
Misc
* scheduling, delayed branch
Passes
* scheduling, instruction
Passes
* scheduling, instruction
Passes
* SCHED_GROUP_P
Flags
* SCmode
Machine Modes
* scope of a variable length array
Variable Length
* scope of declaration
Disappointments
* scope of external declarations
Incompatibilities
* scratch
Regs and Memory
* scratch operands
Regs and Memory
* SDB_ALLOW_FORWARD_REFERENCES
SDB and DWARF
* SDB_ALLOW_UNKNOWN_REFERENCES
SDB and DWARF
* SDB_DEBUGGING_INFO
SDB and DWARF
* SDB_DELIM
SDB and DWARF
* SDB_GENERATE_FAKE
SDB and DWARF
* search path
Directory Options
* second include path
Preprocessor Options
* SECONDARY_INPUT_RELOAD_CLASS
Register Classes
* SECONDARY_MEMORY_NEEDED
Register Classes
* SECONDARY_MEMORY_NEEDED_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
* separate directory, compilation in
Other Dir
* sequence
Side Effects
* sequential consistency on 88k
M88K Options
* set
Side Effects
* setjmp
Global Reg Vars
* SETUP_FRAME_ADDRESSES
Frame Layout
* SETUP_INCOMING_VARARGS
Varargs
* set_attr
Tagging Insns
* set_attr_alternative
Tagging Insns
* SET_DEST
Side Effects
* SET_SRC
Side Effects
* SFmode
Machine Modes
* shared strings
Incompatibilities
* shared VMS run time system
VMS Misc
* SHARED_SECTION_ASM_OP
Sections
* sharing of RTL components
Sharing
* shift
Arithmetic
* SHIFT_COUNT_TRUNCATED
Misc
* SHORT_TYPE_SIZE
Type Layout
* side effect in ?
Conditionals.
* side effects, macro argument
Statement Exprs
* side effects, order of evaluation
Non-bugs
* signed division
Arithmetic
* signed maximum
Arithmetic
* signed minimum
Arithmetic
* SIGNED_CHAR_SPEC
Driver
* sign_extend
Conversions
* sign_extract
Bit Fields
* SImode
Machine Modes
* simple constraints
Simple Constraints
* simplifications, arithmetic
Passes
* sin
C Dialect Options
* sizeof
Typeof
* SIZE_TYPE
Type Layout
* SLOW_BYTE_ACCESS
Costs
* SLOW_UNALIGNED_ACCESS
Costs
* SLOW_ZERO_EXTEND
Costs
* smaller data references (88k)
M88K Options
* smaller data references (MIPS)
MIPS Options
* SMALL_REGISTER_CLASSES
Register Classes
* smax
Arithmetic
* smin
Arithmetic
* SPARC options
SPARC Options
* specified registers
Explicit Reg Vars
* specifying compiler version and target machine
Target Options
* specifying hardware config
Submodel Options
* specifying machine version
Target Options
* specifying registers for local variables
Local Reg Vars
* speed of instructions
Costs
* splitting instructions
Insn Splitting
* sqrt
Arithmetic
* sqrt
C Dialect Options
* square root
Arithmetic
* stack arguments
Stack Arguments
* stack checks (29k)
AMD29K Options
* stack frame layout
Frame Layout
* STACK_BOUNDARY
Storage Layout
* STACK_DYNAMIC_OFFSET
Frame Layout
* STACK_GROWS_DOWNWARD
Frame Layout
* STACK_PARMS_IN_REG_PARM_AREA
Stack Arguments
* STACK_POINTER_OFFSET
Frame Layout
* STACK_POINTER_REGNUM
Frame Registers
* stack_pointer_rtx
Frame Registers
* STACK_REGS
Stack Registers
* stage1
Installation
* standard pattern names
Standard Names
* STANDARD_EXEC_PREFIX
Driver
* STANDARD_INCLUDE_DIR
Driver
* STANDARD_STARTFILE_PREFIX
Driver
* start files
Tools and Libraries
* STARTFILE_SPEC
Driver
* STARTING_FRAME_OFFSET
Frame Layout
* statements inside expressions
Statement Exprs
* static data in C++, declaring and defining
Static Definitions
* STATIC_CHAIN
Frame Registers
* STATIC_CHAIN_INCOMING
Frame Registers
* STATIC_CHAIN_INCOMING_REGNUM
Frame Registers
* STATIC_CHAIN_REGNUM
Frame Registers
* STDC_VALUE
Run-time Target
* storage layout
Storage Layout
* STORE_FLAG_VALUE
Misc
* strcmp
C Dialect Options
* strcpy
Storage Layout
* strcpy
C Dialect Options
* strength-reduction
Passes
* STRICT_ALIGNMENT
Storage Layout
* strict_low_part
RTL Declarations
* string constants
Incompatibilities
* string constants vs newline
C Dialect Options
* STRIP_NAME_ENCODING
Sections
* strlen
C Dialect Options
* structure passing (88k)
M88K Options
* structure value address
Aggregate Return
* structures
Incompatibilities
* structures, constructor expression
Constructors
* structures, returning
Interface
* STRUCTURE_SIZE_BOUNDARY
Storage Layout
* STRUCT_VALUE
Aggregate Return
* STRUCT_VALUE_INCOMING
Aggregate Return
* STRUCT_VALUE_INCOMING_REGNUM
Aggregate Return
* STRUCT_VALUE_REGNUM
Aggregate Return
* stupid register allocation
Passes
* submodel options
Submodel Options
* subreg
Regs and Memory
* SUBREG_PROMOTED_UNSIGNED_P
Flags
* SUBREG_PROMOTED_VAR_P
Flags
* SUBREG_REG
Regs and Memory
* SUBREG_WORD
Regs and Memory
* subscripting
Subscripting
* subscripting and function values
Subscripting
* SUCCESS_EXIT_CODE
Config
* suffixes for C++ source
Invoking G++
* Sun installation
Sun Install
* suppressing warnings
Warning Options
* surprises in C++
C++ Misunderstandings
* SVr4
M88K Options
* SWITCHES_NEED_SPACES
Driver
* SWITCH_TAKES_ARG
Driver
* symbolic label
Sharing
* symbol_ref
Constants
* SYMBOL_REF_FLAG
Flags
* SYMBOL_REF_USED
Flags
* syntax checking
Warning Options
* SYSTEM_INCLUDE_DIR
Driver
* sys_siglist
Config
* tagging insns
Tagging Insns
* tail recursion optimization
Passes
* target description macros
Target Macros
* target machine, specifying
Target Options
* target options
Target Options
* target specifications
Run-time Target
* target-parameter-dependent code
Passes
* TARGET_BELL
Type Layout
* TARGET_BS
Type Layout
* TARGET_CR
Type Layout
* TARGET_EDOM
Library Calls
* TARGET_FF
Type Layout
* TARGET_FLOAT_FORMAT
Storage Layout
* TARGET_MEM_FUNCTIONS
Library Calls
* TARGET_NEWLINE
Type Layout
* TARGET_OPTIONS
Run-time Target
* TARGET_SWITCHES
Run-time Target
* TARGET_TAB
Type Layout
* TARGET_VERSION
Run-time Target
* TARGET_VT
Type Layout
* TCmode
Machine Modes
* template debugging
Warning Options
* temporaries, lifetime of
Temporaries
* termination routines
Initialization
* text_section
Sections
* TEXT_SECTION_ASM_OP
Sections
* TFmode
Machine Modes
* thunks
Nested Functions
* TImode
Machine Modes
* TMPDIR
Environment Variables
* top level of compiler
Passes
* traditional C language
C Dialect Options
* TRADITIONAL_RETURN_FLOAT
Scalar Return
* trampolines for nested functions
Trampolines
* TRAMPOLINE_ALIGNMENT
Trampolines
* TRAMPOLINE_SECTION
Trampolines
* TRAMPOLINE_SIZE
Trampolines
* TRAMPOLINE_TEMPLATE
Trampolines
* TRANSFER_FROM_TRAMPOLINE
Trampolines
* TRULY_NOOP_TRUNCATION
Misc
* truncate
Conversions
* type alignment
Alignment
* typedef names as function parameters
Incompatibilities
* typeof
Typeof
* udiv
Arithmetic
* UDIVDI3_LIBCALL
Library Calls
* UDIVSI3_LIBCALL
Library Calls
* Ultrix calling convention
Interoperation
* umax
Arithmetic
* umin
Arithmetic
* umod
Arithmetic
* UMODDI3_LIBCALL
Library Calls
* UMODSI3_LIBCALL
Library Calls
* unchanging
Flags
* undefined behavior
Bug Criteria
* undefined function value
Bug Criteria
* underscores in variables in macros
Naming Types
* underscores, avoiding (88k)
M88K Options
* union, casting to a
Cast to Union
* unions
Incompatibilities
* unions, returning
Interface
* UNITS_PER_WORD
Storage Layout
* UNKNOWN_FLOAT_FORMAT
Storage Layout
* Unos installation
Unos Install
* unreachable code
Passes
* unshare_all_rtl
Sharing
* unsigned division
Arithmetic
* unsigned greater than
Comparisons
* unsigned greater than
Comparisons
* unsigned less than
Comparisons
* unsigned less than
Comparisons
* unsigned minimum and maximum
Arithmetic
* unsigned_fix
Conversions
* unsigned_float
Conversions
* unspec
Side Effects
* unspec_volatile
Side Effects
* use
Side Effects
* used
Flags
* USER_LABEL_PREFIX
Instruction Output
* USE_C_ALLOCA
Config
* USE_PROTOTYPES
Config
* USG
Config
* value after longjmp
Global Reg Vars
* values, returned by functions
Scalar Return
* varargs implementation
Varargs
* variable alignment
Alignment
* variable attributes
Variable Attributes
* variable number of arguments
Macro Varargs
* variable-length array scope
Variable Length
* variable-length arrays
Variable Length
* variables in specified registers
Explicit Reg Vars
* variables, local, in macros
Naming Types
* Vax calling convention
Interoperation
* VAX options
VAX Options
* VAX_FLOAT_FORMAT
Storage Layout
* VIRTUAL_INCOMING_ARGS_REGNUM
Regs and Memory
* VIRTUAL_OUTGOING_ARGS_REGNUM
Regs and Memory
* VIRTUAL_STACK_DYNAMIC_REGNUM
Regs and Memory
* VIRTUAL_STACK_VARS_REGNUM
Regs and Memory
* VMS
Config
* VMS and case sensitivity
VMS Misc
* VMS and include files
Include Files and VMS
* VMS installation
VMS Install
* void pointers, arithmetic
Pointer Arith
* void, size of pointer to
Pointer Arith
* VOIDmode
Machine Modes
* volatil
Flags
* volatile memory references
Flags
* voting between constraint alternatives
Class Preferences
* vprintf
Config
* warning for enumeration conversions
Warning Options
* warning for overloaded virtual fn
Warning Options
* warning messages
Warning Options
* warnings vs errors
Warnings and Errors
* WCHAR_TYPE
Type Layout
* WCHAR_TYPE_SIZE
Type Layout
* which_alternative
Output Statement
* whitespace
Incompatibilities
* WORDS_BIG_ENDIAN
Storage Layout
* word_mode
Machine Modes
* WORD_REGISTER_OPERATIONS
Misc
* WORD_SWITCH_TAKES_ARG
Driver
* XCmode
Machine Modes
* XCOFF_DEBUGGING_INFO
DBX Options
* XEXP
Accessors
* XFmode
Machine Modes
* XINT
Accessors
* xor
Arithmetic
* XSTR
Accessors
* XVEC
Accessors
* XVECEXP
Accessors
* XVECLEN
Accessors
* XWINT
Accessors
* zero division on 88k
M88K Options
* zero-length arrays
Zero Length
* zero_extend
Conversions
* zero_extract
Bit Fields
* \
Output Template
* __bb_init_func
Profiling
* __builtin_apply
Constructing Calls
* __builtin_apply_args
Constructing Calls
* __builtin_args_info
Varargs
* __builtin_classify_type
Varargs
* __builtin_next_arg
Varargs
* __builtin_return
Constructing Calls
* __builtin_saveregs
Varargs
* __CTOR_LIST__
Initialization
* __DTOR_LIST__
Initialization

automatically generated by info2www