GNU compilers

Copyright © 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with the Invariant Sections being “GNU General Public License” and “Funding Free Software”, the Front-Cover texts being (a) (see below), and with the Back-Cover Texts being (b) (see below). A copy of the license is included in the section entitled “GNU Free Documentation License”.

(a) The FSF's Front-Cover Text is:

A GNU Manual

(b) The FSF's Back-Cover Text is:

You have freedom to copy and modify this GNU Manual, like GNU software. Copies published by the Free Software Foundation raise funds for GNU development.

Short Contents

• Introduction
• 1 Contributing to GCC Development
• 2 GCC and Portability
• 3 Interfacing to GCC Output
• 4 The GCC low-level runtime library
• 5 Language Front Ends in GCC
• 6 Source Tree Structure and Build System
• 7 Option specification files
• 8 Passes and Files of the Compiler
• 9 Trees: The intermediate representation used by the C and C++ front ends
• 10 Analysis and Optimization of GIMPLE Trees
• 11 RTL Representation
• 12 Control Flow Graph
• 13 Machine Descriptions
• 14 Target Description Macros and Functions
• 15 Host Configuration
• 16 Makefile Fragments
• 17 collect2
• 18 Standard Header File Directories
• 19 Memory Management and Type Information
• Funding Free Software
• The GNU Project and GNU/Linux
• GNU GENERAL PUBLIC LICENSE
• GNU Free Documentation License
• Contributors to GCC
• Option Index
• Concept Index

Table of Contents

• Introduction
• 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.1.1 Arithmetic functions
    • 4.1.2 Comparison functions
    • 4.1.3 Trapping arithmetic functions
    • 4.1.4 Bit operations
  • 4.2 Routines for floating point emulation
    • 4.2.1 Arithmetic functions
    • 4.2.2 Conversion functions
    • 4.2.3 Comparison functions
  • 4.3 Language-independent routines for exception handling
  • 4.4 Miscellaneous runtime library routines
    • 4.4.1 Cache control functions
• 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
    • 6.3.1 Subdirectories of gcc
    • 6.3.2 Configuration in the gcc Directory
      • 6.3.2.1 Scripts Used by configure
      • 6.3.2.2 The config.build; config.host; and config.gcc Files
      • 6.3.2.3 Files Created by configure
    • 6.3.3 Build System in the gcc Directory
    • 6.3.4 Makefile Targets
    • 6.3.5 Library Source Files and Headers under the gcc Directory
    • 6.3.6 Headers Installed by GCC
    • 6.3.7 Building Documentation
      • 6.3.7.1 Texinfo Manuals
      • 6.3.7.2 Man Page Generation
      • 6.3.7.3 Miscellaneous Documentation
    • 6.3.8 Anatomy of a Language Front End
      • 6.3.8.1 The Front End language Directory
      • 6.3.8.2 The Front End config-lang.in File
    • 6.3.9 Anatomy of a Target Back End
  • 6.4 Testsuites
    • 6.4.1 Idioms Used in Testsuite Code
    • 6.4.2 Directives used within DejaGnu tests
    • 6.4.3 Ada Language Testsuites
    • 6.4.4 C Language Testsuites
    • 6.4.5 The Java library testsuites.
    • 6.4.6 Support for testing gcov
    • 6.4.7 Support for testing profile-directed optimizations
    • 6.4.8 Support for testing binary compatibility
• 7 Option specification files
  • 7.1 Option file format
  • 7.2 Option properties
• 8 Passes and Files of the Compiler
  • 8.1 Parsing pass
  • 8.2 Gimplification pass
  • 8.3 Pass manager
  • 8.4 Tree-SSA passes
  • 8.5 RTL passes
• 9 Trees: The intermediate representation used by the C and C++ front ends
  • 9.1 Deficiencies
  • 9.2 Overview
    • 9.2.1 Trees
    • 9.2.2 Identifiers
    • 9.2.3 Containers
  • 9.3 Types
  • 9.4 Scopes
    • 9.4.1 Namespaces
    • 9.4.2 Classes
  • 9.5 Declarations
  • 9.6 Functions
    • 9.6.1 Function Basics
    • 9.6.2 Function Bodies
      • 9.6.2.1 Statements
  • 9.7 Attributes in trees
  • 9.8 Expressions
• 10 Analysis and Optimization of GIMPLE Trees
  • 10.1 GENERIC
  • 10.2 GIMPLE
    • 10.2.1 Interfaces
    • 10.2.2 Temporaries
    • 10.2.3 Expressions
      • 10.2.3.1 Compound Expressions
      • 10.2.3.2 Compound Lvalues
      • 10.2.3.3 Conditional Expressions
      • 10.2.3.4 Logical Operators
    • 10.2.4 Statements
      • 10.2.4.1 Blocks
      • 10.2.4.2 Statement Sequences
      • 10.2.4.3 Empty Statements
      • 10.2.4.4 Loops
      • 10.2.4.5 Selection Statements
      • 10.2.4.6 Jumps
      • 10.2.4.7 Cleanups
      • 10.2.4.8 Exception Handling
    • 10.2.5 GIMPLE Example
    • 10.2.6 Rough GIMPLE Grammar
  • 10.3 Annotations
  • 10.4 Statement Operands
    • 10.4.1 Operand Iterators And Access Routines
    • 10.4.2 Immediate Uses
  • 10.5 Static Single Assignment
    • 10.5.1 Preserving the SSA form
    • 10.5.2 Examining SSA_NAME nodes
    • 10.5.3 Walking use-def chains
    • 10.5.4 Walking the dominator tree
  • 10.6 Alias analysis
• 11 RTL Representation
  • 11.1 RTL Object Types
  • 11.2 RTL Classes and Formats
  • 11.3 Access to Operands
  • 11.4 Access to Special Operands
  • 11.5 Flags in an RTL Expression
  • 11.6 Machine Modes
  • 11.7 Constant Expression Types
  • 11.8 Registers and Memory
  • 11.9 RTL Expressions for Arithmetic
  • 11.10 Comparison Operations
  • 11.11 Bit-Fields
  • 11.12 Vector Operations
  • 11.13 Conversions
  • 11.14 Declarations
  • 11.15 Side Effect Expressions
  • 11.16 Embedded Side-Effects on Addresses
  • 11.17 Assembler Instructions as Expressions
  • 11.18 Insns
  • 11.19 RTL Representation of Function-Call Insns
  • 11.20 Structure Sharing Assumptions
  • 11.21 Reading RTL
• 12 Control Flow Graph
  • 12.1 Basic Blocks
  • 12.2 Edges
  • 12.3 Profile information
  • 12.4 Maintaining the CFG
  • 12.5 Liveness information
• 13 Machine Descriptions
  • 13.1 Overview of How the Machine Description is Used
  • 13.2 Everything about Instruction Patterns
  • 13.3 Example of define_insn
  • 13.4 RTL Template
  • 13.5 Output Templates and Operand Substitution
  • 13.6 C Statements for Assembler Output
  • 13.7 Predicates
    • 13.7.1 Machine-Independent Predicates
    • 13.7.2 Defining Machine-Specific Predicates
  • 13.8 Operand Constraints
    • 13.8.1 Simple Constraints
    • 13.8.2 Multiple Alternative Constraints
    • 13.8.3 Register Class Preferences
    • 13.8.4 Constraint Modifier Characters
    • 13.8.5 Constraints for Particular Machines
  • 13.9 Standard Pattern Names For Generation
  • 13.10 When the Order of Patterns Matters
  • 13.11 Interdependence of Patterns
  • 13.12 Defining Jump Instruction Patterns
  • 13.13 Defining Looping Instruction Patterns
  • 13.14 Canonicalization of Instructions
  • 13.15 Defining RTL Sequences for Code Generation
  • 13.16 Defining How to Split Instructions
  • 13.17 Including Patterns in Machine Descriptions.
    • 13.17.1 RTL Generation Tool Options for Directory Search
  • 13.18 Machine-Specific Peephole Optimizers
    • 13.18.1 RTL to Text Peephole Optimizers
    • 13.18.2 RTL to RTL Peephole Optimizers
  • 13.19 Instruction Attributes
    • 13.19.1 Defining Attributes and their Values
    • 13.19.2 Attribute Expressions
    • 13.19.3 Assigning Attribute Values to Insns
    • 13.19.4 Example of Attribute Specifications
    • 13.19.5 Computing the Length of an Insn
    • 13.19.6 Constant Attributes
    • 13.19.7 Delay Slot Scheduling
    • 13.19.8 Specifying processor pipeline description
  • 13.20 Conditional Execution
  • 13.21 Constant Definitions
  • 13.22 Macros
    • 13.22.1 Mode Macros
      • 13.22.1.1 Defining Mode Macros
      • 13.22.1.2 Substitution in Mode Macros
      • 13.22.1.3 Mode Macro Examples
    • 13.22.2 Code Macros
• 14 Target Description Macros and Functions
  • 14.1 The Global targetm Variable
  • 14.2 Controlling the Compilation Driver, gcc
  • 14.3 Run-time Target Specification
  • 14.4 Defining data structures for per-function information.
  • 14.5 Storage Layout
  • 14.6 Layout of Source Language Data Types
  • 14.7 Register Usage
    • 14.7.1 Basic Characteristics of Registers
    • 14.7.2 Order of Allocation of Registers
    • 14.7.3 How Values Fit in Registers
    • 14.7.4 Handling Leaf Functions
    • 14.7.5 Registers That Form a Stack
  • 14.8 Register Classes
  • 14.9 Stack Layout and Calling Conventions
    • 14.9.1 Basic Stack Layout
    • 14.9.2 Exception Handling Support
    • 14.9.3 Specifying How Stack Checking is Done
    • 14.9.4 Registers That Address the Stack Frame
    • 14.9.5 Eliminating Frame Pointer and Arg Pointer
    • 14.9.6 Passing Function Arguments on the Stack
    • 14.9.7 Passing Arguments in Registers
    • 14.9.8 How Scalar Function Values Are Returned
    • 14.9.9 How Large Values Are Returned
    • 14.9.10 Caller-Saves Register Allocation
    • 14.9.11 Function Entry and Exit
    • 14.9.12 Generating Code for Profiling
    • 14.9.13 Permitting tail calls
  • 14.10 Implementing the Varargs Macros
  • 14.11 Trampolines for Nested Functions
  • 14.12 Implicit Calls to Library Routines
  • 14.13 Addressing Modes
  • 14.14 Condition Code Status
  • 14.15 Describing Relative Costs of Operations
  • 14.16 Adjusting the Instruction Scheduler
  • 14.17 Dividing the Output into Sections (Texts, Data, ...)
  • 14.18 Position Independent Code
  • 14.19 Defining the Output Assembler Language
    • 14.19.1 The Overall Framework of an Assembler File
    • 14.19.2 Output of Data
    • 14.19.3 Output of Uninitialized Variables
    • 14.19.4 Output and Generation of Labels
    • 14.19.5 How Initialization Functions Are Handled
    • 14.19.6 Macros Controlling Initialization Routines
    • 14.19.7 Output of Assembler Instructions
    • 14.19.8 Output of Dispatch Tables
    • 14.19.9 Assembler Commands for Exception Regions
    • 14.19.10 Assembler Commands for Alignment
  • 14.20 Controlling Debugging Information Format
    • 14.20.1 Macros Affecting All Debugging Formats
    • 14.20.2 Specific Options for DBX Output
    • 14.20.3 Open-Ended Hooks for DBX Format
    • 14.20.4 File Names in DBX Format
    • 14.20.5 Macros for SDB and DWARF Output
    • 14.20.6 Macros for VMS Debug Format
  • 14.21 Cross Compilation and Floating Point
  • 14.22 Mode Switching Instructions
  • 14.23 Defining target-specific uses of __attribute__
  • 14.24 Defining coprocessor specifics for MIPS targets.
  • 14.25 Parameters for Precompiled Header Validity Checking
  • 14.26 C++ ABI parameters
  • 14.27 Miscellaneous Parameters
• 15 Host Configuration
  • 15.1 Host Common
  • 15.2 Host Filesystem
  • 15.3 Host Misc
• 16 Makefile Fragments
  • 16.1 Target Makefile Fragments
  • 16.2 Host Makefile Fragments
• 17 collect2
• 18 Standard Header File Directories
• 19 Memory Management and Type Information
  • 19.1 The Inside of a GTY(())
  • 19.2 Marking Roots for the Garbage Collector
  • 19.3 Source Files Containing Type Information
• Funding Free Software
• The GNU Project and GNU/Linux
• GNU GENERAL PUBLIC LICENSE
  • Preamble
  • How to Apply These Terms to Your New Programs
• GNU Free Documentation License
  • ADDENDUM: How to use this License for your documents
• Contributors to GCC
• Option Index
• Concept Index

Next: Contributing, Up: (DIR)

---

Introduction

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

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

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

• Contributing: How to contribute to testing and developing GCC.
• Portability: Goals of GCC's portability features.
• Interface: Function-call interface of GCC output.
• Libgcc: Low-level runtime library used by GCC.
• Languages: Languages for which GCC front ends are written.
• Source Tree: GCC source tree structure and build system.
• Options: Option specification files.
• Passes: Order of passes, what they do, and what each file is for.
• Trees: The source representation used by the C and C++ front ends.
• RTL: The intermediate representation that most passes work on.
• Control Flow: Maintaining and manipulating the control flow graph.
• Tree SSA: Analysis and optimization of the tree representation.
• Machine Desc: How to write machine description instruction patterns.
• Target Macros: How to write the machine description C macros and functions.
• Host Config: Writing the xm-machine.h file.
• Fragments: Writing the t-target and x-host files.
• Collect2: How collect2 works; how it finds ld.
• Header Dirs: Understanding the standard header file directories.
• Type Information: GCC's memory management; generating type information.
• Funding: How to help assure funding for free software.
• GNU Project: The GNU Project and GNU/Linux.
• Copying: GNU General Public License says how you can copy and share GCC.
• GNU Free Documentation License: How you can copy and share this manual.
• Contributors: People who have contributed to GCC.
• Option Index: Index to command line options.
• Concept Index: Index of concepts and symbol names.