Top (GNU Compiler Collection (GCC) Internals)

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with the Invariant Sections being “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”.

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.

1 Contributing to GCC Development
2 GCC and Portability
3 Interfacing to GCC Output
4 The GCC low-level runtime library
- 4.1 Routines for integer arithmetic
- 4.2 Routines for floating point emulation
- 4.3 Routines for decimal floating point emulation
- 4.4 Routines for fixed-point fractional emulation
- 4.5 Language-independent routines for exception handling
- 4.6 Miscellaneous runtime library routines
  - 4.6.1 Cache control functions
  - 4.6.2 Split stack functions and variables
5 Language Front Ends in GCC
6 Source Tree Structure and Build System
- 6.1 Configure Terms and History
- 6.2 Top Level Source Directory
- 6.3 The gcc Subdirectory
7 Testsuites
- 7.1 Idioms Used in Testsuite Code
- 7.2 Directives used within DejaGnu tests
- 7.3 Ada Language Testsuites
- 7.4 C Language Testsuites
- 7.5 Support for testing link-time optimizations
- 7.6 Support for testing gcov
- 7.7 Support for testing profile-directed optimizations
- 7.8 Support for testing binary compatibility
- 7.9 Support for torture testing using multiple options
- 7.10 Support for testing GIMPLE passes
- 7.11 Support for testing RTL passes
8 Option specification files
- 8.1 Option file format
- 8.2 Option properties
9 Passes and Files of the Compiler
- 9.1 Parsing pass
- 9.2 Gimplification pass
- 9.3 Pass manager
- 9.4 Inter-procedural optimization passes
- 9.5 Tree SSA passes
- 9.6 RTL passes
- 9.7 Optimization info
10 Sizes and offsets as runtime invariants
- 10.1 Overview of poly_int
- 10.2 Consequences of using poly_int
- 10.3 Comparisons involving poly_int
- 10.4 Arithmetic on poly_ints
- 10.5 Alignment of poly_ints
- 10.6 Computing bounds on poly_ints
- 10.7 Converting poly_ints
- 10.8 Miscellaneous poly_int routines
- 10.9 Guidelines for using poly_int
11 GENERIC
- 11.1 Deficiencies
- 11.2 Overview
- 11.3 Types
- 11.4 Declarations
  - 11.4.1 Working with declarations
  - 11.4.2 Internal structure
    - 11.4.2.1 Current structure hierarchy
    - 11.4.2.2 Adding new DECL node types
- 11.5 Attributes in trees
- 11.6 Expressions
- 11.7 Statements
- 11.8 Functions
  - 11.8.1 Function Basics
  - 11.8.2 Function Properties
- 11.9 Language-dependent trees
- 11.10 C and C++ Trees
12 GIMPLE
- 12.1 Tuple representation
- 12.2 Class hierarchy of GIMPLE statements
- 12.3 GIMPLE instruction set
- 12.4 Exception Handling
- 12.5 Temporaries
- 12.6 Operands
- 12.7 Manipulating GIMPLE statements
  - 12.7.1 Common accessors
- 12.8 Tuple specific accessors
- 12.9 GIMPLE sequences
- 12.10 Sequence iterators
- 12.11 Adding a new GIMPLE statement code
- 12.12 Statement and operand traversals
13 Analysis and Optimization of GIMPLE tuples
- 13.1 Annotations
- 13.2 SSA Operands
  - 13.2.1 Operand Iterators And Access Routines
  - 13.2.2 Immediate Uses
- 13.3 Static Single Assignment
- 13.4 Alias analysis
- 13.5 Memory model
14 RTL Representation
- 14.1 RTL Object Types
- 14.2 RTL Classes and Formats
- 14.3 Access to Operands
- 14.4 Access to Special Operands
- 14.5 Flags in an RTL Expression
- 14.6 Machine Modes
- 14.7 Constant Expression Types
- 14.8 Registers and Memory
- 14.9 RTL Expressions for Arithmetic
- 14.10 Comparison Operations
- 14.11 Bit-Fields
- 14.12 Vector Operations
- 14.13 Conversions
- 14.14 Declarations
- 14.15 Side Effect Expressions
- 14.16 Embedded Side-Effects on Addresses
- 14.17 Assembler Instructions as Expressions
- 14.18 Variable Location Debug Information in RTL
- 14.19 Insns
- 14.20 RTL Representation of Function-Call Insns
- 14.21 On-the-Side SSA Form for RTL
  - 14.21.1 Using RTL SSA in a pass
  - 14.21.2 RTL SSA Instructions
  - 14.21.3 RTL SSA Basic Blocks
  - 14.21.4 RTL SSA Resources
  - 14.21.5 RTL SSA Register and Memory Accesses
  - 14.21.6 RTL SSA Phi Nodes
  - 14.21.7 RTL SSA Access Lists
  - 14.21.8 Using the RTL SSA framework to change instructions
    - 14.21.8.1 Changing One RTL SSA Instruction
    - 14.21.8.2 Changing Multiple RTL SSA Instructions
- 14.22 Structure Sharing Assumptions
- 14.23 Reading RTL
15 Control Flow Graph
- 15.1 Basic Blocks
- 15.2 Edges
- 15.3 Profile information
- 15.4 Maintaining the CFG
- 15.5 Liveness information
16 Analysis and Representation of Loops
- 16.1 Loop representation
- 16.2 Loop querying
- 16.3 Loop manipulation
- 16.4 Loop-closed SSA form
- 16.5 Scalar evolutions
- 16.6 IV analysis on RTL
- 16.7 Number of iterations analysis
- 16.8 Data Dependency Analysis
17 Machine Descriptions
- 17.1 Overview of How the Machine Description is Used
- 17.2 Everything about Instruction Patterns
- 17.3 Example of define_insn
- 17.4 RTL Template
- 17.5 Output Templates and Operand Substitution
- 17.6 C Statements for Assembler Output
- 17.7 Predicates
  - 17.7.1 Machine-Independent Predicates
  - 17.7.2 Defining Machine-Specific Predicates
- 17.8 Operand Constraints
  - 17.8.1 Simple Constraints
  - 17.8.2 Multiple Alternative Constraints
  - 17.8.3 Register Class Preferences
  - 17.8.4 Constraint Modifier Characters
  - 17.8.5 Constraints for Particular Machines
  - 17.8.6 Disable insn alternatives using the enabled attribute
  - 17.8.7 Defining Machine-Specific Constraints
  - 17.8.8 Testing constraints from C
- 17.9 Standard Pattern Names For Generation
- 17.10 When the Order of Patterns Matters
- 17.11 Interdependence of Patterns
- 17.12 Defining Jump Instruction Patterns
- 17.13 Defining Looping Instruction Patterns
- 17.14 Canonicalization of Instructions
- 17.15 Defining RTL Sequences for Code Generation
- 17.16 Defining How to Split Instructions
- 17.17 Including Patterns in Machine Descriptions.
  - 17.17.1 RTL Generation Tool Options for Directory Search
- 17.18 Machine-Specific Peephole Optimizers
  - 17.18.1 RTL to Text Peephole Optimizers
  - 17.18.2 RTL to RTL Peephole Optimizers
- 17.19 Instruction Attributes
  - 17.19.1 Defining Attributes and their Values
  - 17.19.2 Attribute Expressions
  - 17.19.3 Assigning Attribute Values to Insns
  - 17.19.4 Example of Attribute Specifications
  - 17.19.5 Computing the Length of an Insn
  - 17.19.6 Constant Attributes
  - 17.19.7 Mnemonic Attribute
  - 17.19.8 Delay Slot Scheduling
  - 17.19.9 Specifying processor pipeline description
- 17.20 Conditional Execution
- 17.21 RTL Templates Transformations
  - 17.21.1 define_subst Example
  - 17.21.2 Pattern Matching in define_subst
  - 17.21.3 Generation of output template in define_subst
- 17.22 Constant Definitions
- 17.23 Iterators
  - 17.23.1 Mode Iterators
  - 17.23.2 Code Iterators
  - 17.23.3 Int Iterators
  - 17.23.4 Subst Iterators
  - 17.23.5 Parameterized Names
18 Target Description Macros and Functions
- 18.1 The Global targetm Variable
- 18.2 Controlling the Compilation Driver, gcc
- 18.3 Run-time Target Specification
- 18.4 Defining data structures for per-function information.
- 18.5 Storage Layout
- 18.6 Layout of Source Language Data Types
- 18.7 Register Usage
  - 18.7.1 Basic Characteristics of Registers
  - 18.7.2 Order of Allocation of Registers
  - 18.7.3 How Values Fit in Registers
  - 18.7.4 Handling Leaf Functions
  - 18.7.5 Registers That Form a Stack
- 18.8 Register Classes
- 18.9 Stack Layout and Calling Conventions
  - 18.9.1 Basic Stack Layout
  - 18.9.2 Exception Handling Support
  - 18.9.3 Specifying How Stack Checking is Done
  - 18.9.4 Registers That Address the Stack Frame
  - 18.9.5 Eliminating Frame Pointer and Arg Pointer
  - 18.9.6 Passing Function Arguments on the Stack
  - 18.9.7 Passing Arguments in Registers
  - 18.9.8 How Scalar Function Values Are Returned
  - 18.9.9 How Large Values Are Returned
  - 18.9.10 Caller-Saves Register Allocation
  - 18.9.11 Function Entry and Exit
  - 18.9.12 Generating Code for Profiling
  - 18.9.13 Permitting tail calls
  - 18.9.14 Shrink-wrapping separate components
  - 18.9.15 Stack smashing protection
  - 18.9.16 Miscellaneous register hooks
- 18.10 Implementing the Varargs Macros
- 18.11 Support for Nested Functions
- 18.12 Implicit Calls to Library Routines
- 18.13 Addressing Modes
- 18.14 Anchored Addresses
- 18.15 Condition Code Status
  - 18.15.1 Representation of condition codes using registers
- 18.16 Describing Relative Costs of Operations
- 18.17 Adjusting the Instruction Scheduler
- 18.18 Dividing the Output into Sections (Texts, Data, …)
- 18.19 Position Independent Code
- 18.20 Defining the Output Assembler Language
  - 18.20.1 The Overall Framework of an Assembler File
  - 18.20.2 Output of Data
  - 18.20.3 Output of Uninitialized Variables
  - 18.20.4 Output and Generation of Labels
  - 18.20.5 How Initialization Functions Are Handled
  - 18.20.6 Macros Controlling Initialization Routines
  - 18.20.7 Output of Assembler Instructions
  - 18.20.8 Output of Dispatch Tables
  - 18.20.9 Assembler Commands for Exception Regions
  - 18.20.10 Assembler Commands for Alignment
- 18.21 Controlling Debugging Information Format
  - 18.21.1 Macros Affecting All Debugging Formats
  - 18.21.2 Specific Options for DBX Output
  - 18.21.3 Open-Ended Hooks for DBX Format
  - 18.21.4 File Names in DBX Format
  - 18.21.5 Macros for DWARF Output
  - 18.21.6 Macros for VMS Debug Format
  - 18.21.7 Macros for CTF Debug Format
  - 18.21.8 Macros for BTF Debug Format
- 18.22 Cross Compilation and Floating Point
- 18.23 Mode Switching Instructions
- 18.24 Defining target-specific uses of __attribute__
- 18.25 Emulating TLS
- 18.26 Defining coprocessor specifics for MIPS targets.
- 18.27 Parameters for Precompiled Header Validity Checking
- 18.28 C++ ABI parameters
- 18.29 D ABI parameters
- 18.30 Adding support for named address spaces
- 18.31 Miscellaneous Parameters
19 Host Configuration
- 19.1 Host Common
- 19.2 Host Filesystem
- 19.3 Host Misc
20 Makefile Fragments
- 20.1 Target Makefile Fragments
- 20.2 Host Makefile Fragments
21 collect2
22 Standard Header File Directories
23 Memory Management and Type Information
- 23.1 The Inside of a GTY(())
- 23.2 Support for inheritance
- 23.3 Support for user-provided GC marking routines
  - 23.3.1 User-provided marking routines for template types
- 23.4 Marking Roots for the Garbage Collector
- 23.5 Source Files Containing Type Information
- 23.6 How to invoke the garbage collector
- 23.7 Troubleshooting the garbage collector
24 Plugins
- 24.1 Loading Plugins
- 24.2 Plugin API
- 24.3 Interacting with the pass manager
- 24.4 Interacting with the GCC Garbage Collector
- 24.5 Giving information about a plugin
- 24.6 Registering custom attributes or pragmas
- 24.7 Recording information about pass execution
- 24.8 Controlling which passes are being run
- 24.9 Keeping track of available passes
- 24.10 Building GCC plugins
25 Link Time Optimization
- 25.1 Design Overview
  - 25.1.1 LTO modes of operation
- 25.2 LTO file sections
- 25.3 Using summary information in IPA passes
- 25.4 Whole program assumptions, linker plugin and symbol visibilities
- 25.5 Internal flags controlling lto1
26 Match and Simplify
- 26.1 GIMPLE API
- 26.2 The Language
27 Static Analyzer
- 27.1 Analyzer Internals
- 27.2 Debugging the Analyzer
  - 27.2.1 Special Functions for Debugging the Analyzer
  - 27.2.2 Other Debugging Techniques
28 User Experience Guidelines
- 28.1 Guidelines for Diagnostics
- 28.2 Guidelines for Options
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

Short Table of Contents

Table of Contents

Introduction ¶