GNU Compiler Collection (GCC) Internals#

Contents:

Copyright
Introduction
Contributing to GCC Development
GCC and Portability
Interfacing to GCC Output
The GCC low-level runtime library
- Routines for integer arithmetic
- Routines for floating point emulation
- Routines for decimal floating point emulation
- Routines for fixed-point fractional emulation
- 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
Testsuites
- Idioms Used in Testsuite Code
- Directives used within DejaGnu tests
- Ada Language Testsuites
- C Language 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
- Support for testing GIMPLE passes
- Support for testing RTL passes
Option specification files
- Option file format
- Option properties
Passes and Files of the Compiler
- Parsing pass
- Gimplification pass
- Pass manager
- Inter-procedural optimization passes
- Tree SSA passes
- RTL passes
- Optimization info
Sizes and offsets as runtime invariants
- Overview of poly_int
- Consequences of using poly_int
- Comparisons involving poly_int
- Arithmetic on poly_ints
- Alignment of poly_ints
- Computing bounds on poly_ints
- Converting poly_ints
- Miscellaneous poly_int routines
- Guidelines for using poly_int
GENERIC
- Deficiencies
- Overview
- Types
- Declarations
  - Working with declarations
  - Internal structure
    - Current structure hierarchy
    - Adding new DECL node types
- Attributes in trees
- Expressions
- Statements
- Functions
  - Function Basics
  - Function Properties
- Language-dependent trees
- C and C++ Trees
GIMPLE
- Tuple representation
- Class hierarchy of GIMPLE statements
- GIMPLE instruction set
- Temporaries
- Operands
- Manipulating GIMPLE statements
  - Common accessors
- Tuple specific accessors
- GIMPLE sequences
- Sequence iterators
- Adding a new GIMPLE statement code
- Statement and operand traversals
- Exception Handling
Analysis and Optimization of GIMPLE tuples
- Annotations
- SSA Operands
  - Operand Iterators And Access Routines
  - Immediate Uses
- Alias analysis
- Memory model
- Static Single Assignment
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
- On-the-Side SSA Form for RTL
  - Using RTL SSA in a pass
  - RTL SSA Instructions
  - RTL SSA Basic Blocks
  - RTL SSA Resources
  - RTL SSA Register and Memory Accesses
  - RTL SSA Phi Nodes
  - RTL SSA Access Lists
  - Using the RTL SSA framework to change instructions
    - Changing One RTL SSA Instruction
    - Changing Multiple RTL SSA Instructions
- Structure Sharing Assumptions
- Reading RTL
Control Flow Graph
- Basic Blocks
- Edges
- Profile information
- Maintaining the CFG
- Liveness information
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
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
  - Code Iterators
  - Int Iterators
  - Subst Iterators
  - Parameterized Names
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
- 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
  - Shrink-wrapping separate components
  - Stack smashing protection
  - Miscellaneous register hooks
- Implementing the Varargs Macros
- Support for Nested Functions
- Implicit Calls to Library Routines
- Addressing Modes
- Anchored Addresses
- Condition Code Status
  - 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
  - Macros for DWARF Output
  - Macros for VMS Debug Format
  - Macros for CTF Debug Format
  - Macros for BTF 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
- D ABI parameters
- Adding support for named address spaces
- Miscellaneous Parameters
Host Configuration
- Host Common
- Host Misc
- Host Filesystem
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
- 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
- Whole program assumptions, linker plugin and symbol visibilities
- Internal flags controlling lto1
Match and Simplify
- GIMPLE API
- The Language
Static Analyzer
- Analyzer Internals
- Debugging the Analyzer
  - Special Functions for Debugging the Analyzer
  - Other Debugging Techniques
User Experience Guidelines
- Guidelines for Diagnostics
- Guidelines for Options
Funding Free Software
Contributors to GCC
GNU GENERAL PUBLIC LICENSE
- Preamble
- TERMS AND CONDITIONS
- How to Apply These Terms to Your New Programs
GNU Free Documentation License
- Preamble
- 1. APPLICABILITY AND DEFINITIONS
- 2. VERBATIM COPYING
- 3. COPYING IN QUANTITY
- 4. MODIFICATIONS
- 5. COMBINING DOCUMENTS
- 6. COLLECTIONS OF DOCUMENTS
- 7. AGGREGATION WITH INDEPENDENT WORKS
- 8. TRANSLATION
- 9. TERMINATION
- 10. FUTURE REVISIONS OF THIS LICENSE
- 11. RELICENSING
- ADDENDUM: How to use this License for your documents
Indexes and tables
- TODO