Introduction
Contributing to GCC Development
GCC and Portability
Interfacing to GCC Output
The GCC low-level runtime library
Routines for integer arithmetic
Arithmetic functions
Comparison functions
Trapping arithmetic functions
Bit operations
Routines for floating point emulation
Arithmetic functions
Conversion functions
Comparison functions
Other floating-point functions
Routines for decimal floating point emulation
Arithmetic functions
Conversion functions
Comparison functions
Routines for fixed-point fractional emulation
Arithmetic functions
Comparison functions
Conversion functions
Language-independent routines for exception handling
Miscellaneous runtime library routines
Cache control functions
Split stack functions and variables
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.build; config.host; and config.gcc Files
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
The Front End Make-lang.in File
Anatomy of a Target Back End
Testsuites
Idioms Used in Testsuite Code
Directives used within DejaGnu tests
Syntax and Descriptions of test directives
Specify how to build the test
Specify additional compiler options
Modify the test timeout value
Skip a test for some targets
Expect a test to fail for some targets
Expect the test executable to fail
Verify compiler messages
Verify output of the test executable
Specify additional files for a test
Add checks at the end of a test
Selecting targets to which a test applies
Keywords describing target attributes
Data type sizes
Fortran-specific attributes
Vector-specific attributes
Thread Local Storage attributes
Decimal floating point attributes
ARM-specific attributes
MIPS-specific attributes
PowerPC-specific attributes
Other hardware attributes
Environment attributes
Other attributes
Local to tests in gcc.target/i386
Local to tests in gcc.target/spu/ea
Local to tests in gcc.test-framework
Features for dg-add-options
Variants of dg-require-support
Commands for use in dg-final
Scan a particular file
Scan the assembly output
Scan optimization dump files
Verify that an output files exists or not
Check for LTO tests
Checks for gcov tests
Clean up generated test files
Ada Language Testsuites
C Language Testsuites
The Java library testsuites.
Support for testing link-time optimizations
Support for testing gcov
Support for testing profile-directed optimizations
Support for testing binary compatibility
Support for torture testing using multiple options
Option specification files
Option file format
Option properties
Passes and Files of the Compiler
Parsing pass
Cilk Plus Transformation
Gimplification pass
Pass manager
Tree SSA passes
RTL passes
RTL Representation
RTL Object Types
RTL Classes and Formats
Access to Operands
Access to Special 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
Variable Location Debug Information in RTL
Insns
RTL Representation of Function-Call Insns
Structure Sharing Assumptions
Reading RTL
GENERIC
Deficiencies
Overview
Trees
Identifiers
Containers
Types
Declarations
Working with declarations
Internal structure
Current structure hierarchy
Adding new DECL node types
Attributes in trees
Expressions
Constant expressions
References to storage
Unary and Binary Expressions
Vectors
Statements
Basic Statements
Blocks
Statement Sequences
Empty Statements
Jumps
Cleanups
OpenMP
Functions
Function Basics
Function Properties
Language-dependent trees
C and C++ Trees
Types for C++
Namespaces
Classes
Functions for C++
Statements for C++
Statements
C++ Expressions
Java Trees
GIMPLE
Tuple representation
gimple_statement_base (gsbase)
gimple_statement_with_ops
gimple_statement_with_memory_ops
GIMPLE instruction set
Exception Handling
Temporaries
Operands
Compound Expressions
Compound Lvalues
Conditional Expressions
Logical Operators
Manipulating operands
Operand vector allocation
Operand validation
Statement validation
Manipulating GIMPLE statements
Common accessors
Tuple specific accessors
GIMPLE_ASM
GIMPLE_ASSIGN
GIMPLE_BIND
GIMPLE_CALL
GIMPLE_CATCH
GIMPLE_COND
GIMPLE_DEBUG
GIMPLE_EH_FILTER
GIMPLE_LABEL
GIMPLE_NOP
GIMPLE_OMP_ATOMIC_LOAD
GIMPLE_OMP_ATOMIC_STORE
GIMPLE_OMP_CONTINUE
GIMPLE_OMP_CRITICAL
GIMPLE_OMP_FOR
GIMPLE_OMP_MASTER
GIMPLE_OMP_ORDERED
GIMPLE_OMP_PARALLEL
GIMPLE_OMP_RETURN
GIMPLE_OMP_SECTION
GIMPLE_OMP_SECTIONS
GIMPLE_OMP_SINGLE
GIMPLE_PHI
GIMPLE_RESX
GIMPLE_RETURN
GIMPLE_SWITCH
GIMPLE_TRY
GIMPLE_WITH_CLEANUP_EXPR
GIMPLE sequences
Sequence iterators
Adding a new GIMPLE statement code
Statement and operand traversals
Analysis and Optimization of GIMPLE tuples
Annotations
SSA Operands
Operand Iterators And Access Routines
Immediate Uses
Static Single Assignment
Preserving the SSA form
Preserving the virtual SSA form
Examining SSA_NAME nodes
Walking the dominator tree
Alias analysis
Memory model
Analysis and Representation of Loops
Loop representation
Loop querying
Loop manipulation
Loop-closed SSA form
Scalar evolutions
IV analysis on RTL
Number of iterations analysis
Data Dependency Analysis
Linear loop transformations framework
Omega a solver for linear programming problems
Control Flow Graph
Basic Blocks
Edges
Profile information
Maintaining the CFG
Liveness information
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
Predicates
Machine-Independent Predicates
Defining Machine-Specific Predicates
Operand Constraints
Simple Constraints
Multiple Alternative Constraints
Register Class Preferences
Constraint Modifier Characters
Constraints for Particular Machines
Disable insn alternatives using the enabled attribute
Defining Machine-Specific Constraints
Testing constraints from C
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
Mnemonic Attribute
Delay Slot Scheduling
Specifying processor pipeline description
Conditional Execution
RTL Templates Transformations
define_subst Example
Pattern Matching in define_subst
Generation of output template in define_subst
Constant Definitions
Iterators
Mode Iterators
Defining Mode Iterators
Substitution in Mode Iterators
Mode Iterator Examples
Code Iterators
Int Iterators
Subst Iterators
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
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
Obsolete Macros for Defining Constraints
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
Stack smashing protection
Implementing the Varargs Macros
Trampolines for Nested Functions
Implicit Calls to Library Routines
Addressing Modes
Anchored Addresses
Condition Code Status
Representation of condition codes using (cc0)
Representation of condition codes using registers
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__
Emulating TLS
Defining coprocessor specifics for MIPS targets.
Parameters for Precompiled Header Validity Checking
C++ ABI parameters
Adding support for named address spaces
Miscellaneous Parameters
Host Configuration
Host Common
Host Filesystem
Host Misc
Makefile Fragments
Target Makefile Fragments
Host Makefile Fragments
collect2
Standard Header File Directories
Memory Management and Type Information
The Inside of a GTY(())
Support for inheritance
Support for user-provided GC marking routines
User-provided marking routines for template types
Marking Roots for the Garbage Collector
Source Files Containing Type Information
How to invoke the garbage collector
Troubleshooting the garbage collector
Plugins
Loading Plugins
Plugin API
Plugin license check
Plugin initialization
Plugin callbacks
Interacting with the pass manager
Interacting with the GCC Garbage Collector
Giving information about a plugin
Registering custom attributes or pragmas
Recording information about pass execution
Controlling which passes are being run
Keeping track of available passes
Building GCC plugins
Link Time Optimization
Design Overview
LTO modes of operation
LTO file sections
Using summary information in IPA passes
Virtual clones
IPA references
Jump functions
Whole program assumptions, linker plugin and symbol visibilities
Internal flags controlling lto1
Funding Free Software
The GNU Project and GNU/Linux
GNU General Public License
GNU Free Documentation License
ADDENDUM: How to use this License for your documents
Contributors to GCC
Option Index
Concept Index