Table of Contents

1. Compile C, C++, Objective C, Fortran, Java
2. Language Standards Supported by GCC
3. GCC Command Options

3.1 Option Summary
3.2 Options Controlling the Kind of Output
3.3 Compiling C++ Programs
3.4 Options Controlling C Dialect
3.5 Options Controlling C++ Dialect
3.6 Options Controlling Objective-C Dialect
3.7 Options to Control Diagnostic Messages Formatting
3.8 Options to Request or Suppress Warnings
3.9 Options for Debugging Your Program or GCC
3.10 Options That Control Optimization
3.11 Options Controlling the Preprocessor
3.12 Passing Options to the Assembler
3.13 Options for Linking
3.14 Options for Directory Search
3.15 Specifying subprocesses and the switches to pass to them
3.16 Specifying Target Machine and Compiler Version
3.17 Hardware Models and Configurations

3.17.1 M680x0 Options
3.17.2 M68hc1x Options
3.17.3 VAX Options
3.17.4 SPARC Options
3.17.5 Convex Options
3.17.6 AMD29K Options
3.17.7 ARM Options
3.17.8 MN10200 Options
3.17.9 MN10300 Options
3.17.10 M32R/D Options
3.17.11 M88K Options
3.17.12 IBM RS/6000 and PowerPC Options
3.17.13 IBM RT Options
3.17.14 MIPS Options
3.17.15 Intel 386 Options
3.17.16 HPPA Options
3.17.17 Intel 960 Options
3.17.18 DEC Alpha Options
3.17.19 Clipper Options
3.17.20 H8/300 Options
3.17.21 SH Options
3.17.22 Options for System V
3.17.23 TMS320C3x/C4x Options
3.17.24 V850 Options
3.17.25 ARC Options
3.17.26 NS32K Options
3.17.27 AVR Options
3.17.28 MCore Options
3.17.29 IA-64 Options
3.17.30 D30V Options
3.17.31 S/390 and zSeries Options

3.18 Options for Code Generation Conventions
3.19 Environment Variables Affecting GCC
3.20 Running Protoize

4. Installing GNU CC

4.1 Files Created by configure
4.2 Configurations Supported by GNU CC
4.3 Building and Installing a Cross-Compiler

4.3.1 Steps of Cross-Compilation
4.3.2 Configuring a Cross-Compiler
4.3.3 Tools and Libraries for a Cross-Compiler
4.3.4 Cross-Compilers and Header Files
4.3.5 Actually Building the Cross-Compiler

4.4 Installing GNU CC on VMS
4.5 collect2
4.6 Standard Header File Directories

5. Extensions to the C Language Family

5.1 Statements and Declarations in Expressions
5.2 Locally Declared Labels
5.3 Labels as Values
5.4 Nested Functions
5.5 Constructing Function Calls
5.6 Naming an Expression's Type
5.7 Referring to a Type with typeof
5.8 Generalized Lvalues
5.9 Conditionals with Omitted Operands
5.10 Double-Word Integers
5.11 Complex Numbers
5.12 Hex Floats
5.13 Arrays of Length Zero
5.14 Arrays of Variable Length
5.15 Macros with a Variable Number of Arguments.
5.16 Slightly Looser Rules for Escaped Newlines
5.17 String Literals with Embedded Newlines
5.18 Non-Lvalue Arrays May Have Subscripts
5.19 Arithmetic on void- and Function-Pointers
5.20 Non-Constant Initializers
5.21 Compound Literals
5.22 Designated Initializers
5.23 Case Ranges
5.24 Cast to a Union Type
5.25 Mixed Declarations and Code
5.26 Declaring Attributes of Functions
5.27 Attribute Syntax
5.28 Prototypes and Old-Style Function Definitions
5.29 C++ Style Comments
5.30 Dollar Signs in Identifier Names
5.31 The Character ESC in Constants
5.32 Inquiring on Alignment of Types or Variables
5.33 Specifying Attributes of Variables
5.34 Specifying Attributes of Types
5.35 An Inline Function is As Fast As a Macro
5.36 Assembler Instructions with C Expression Operands

5.36.1 i386 floating point asm operands

5.37 Controlling Names Used in Assembler Code
5.38 Variables in Specified Registers

5.38.1 Defining Global Register Variables
5.38.2 Specifying Registers for Local Variables

5.39 Alternate Keywords
5.40 Incomplete enum Types
5.41 Function Names as Strings
5.42 Getting the Return or Frame Address of a Function
5.43 Other built-in functions provided by GCC

6. Extensions to the C++ Language

6.1 Minimum and Maximum Operators in C++
6.2 When is a Volatile Object Accessed?
6.3 Restricting Pointer Aliasing
6.4 Vague Linkage
6.5 Declarations and Definitions in One Header
6.6 Where's the Template?
6.7 Extracting the function pointer from a bound pointer to member function
6.8 C++-Specific Variable, Function, and Type Attributes
6.9 Java Exceptions
6.10 Deprecated Features
6.11 Backwards Compatibility

7. GNU Objective-C runtime features

7.1 +load: Executing code before main

7.1.1 What you can and what you cannot do in +load

7.2 Type encoding
7.3 Garbage Collection
7.4 Constant string objects
7.5 compatibility_alias

8. gcov: a Test Coverage Program

8.1 Introduction to gcov
8.2 Invoking gcov
8.3 Using gcov with GCC Optimization
8.4 Brief description of gcov data files

9. Known Causes of Trouble with GCC

9.1 Actual Bugs We Haven't Fixed Yet
9.2 Cross-Compiler Problems
9.3 Interoperation
9.4 Problems Compiling Certain Programs
9.5 Incompatibilities of GCC
9.6 Fixed Header Files
9.7 Standard Libraries
9.8 Disappointments and Misunderstandings
9.9 Common Misunderstandings with GNU C++

9.9.1 Declare and Define Static Members
9.9.2 Temporaries May Vanish Before You Expect
9.9.3 Implicit Copy-Assignment for Virtual Bases

9.10 Caveats of using protoize
9.11 Certain Changes We Don't Want to Make
9.12 Warning Messages and Error Messages

10. Reporting Bugs

10.1 Have You Found a Bug?
10.2 Where to Report Bugs
10.3 How to Report Bugs
10.4 The gccbug script
10.5 Sending Patches for GCC

11. How To Get Help with GCC
12. Contributing to GCC Development
13. Using GCC on VMS

13.1 Include Files and VMS
13.2 Global Declarations and VMS
13.3 Other VMS Issues

14. Additional Makefile and configure information.

14.1 Makefile Targets
14.2 Configure Terms and History

15. GCC and Portability
16. Interfacing to GCC Output
17. Passes and Files of the Compiler
18. Trees: The intermediate representation used by the C and C++ front ends

18.1 Deficiencies
18.2 Overview

18.2.1 Trees
18.2.2 Identifiers
18.2.3 Containers

18.3 Types
18.4 Scopes

18.4.1 Namespaces
18.4.2 Classes

18.5 Declarations
18.6 Functions

18.6.1 Function Basics
18.6.2 Function Bodies

18.6.2.1 Statements

18.7 Attributes in trees
18.8 Expressions

19. RTL Representation

19.1 RTL Object Types
19.2 RTL Classes and Formats
19.3 Access to Operands
19.4 Flags in an RTL Expression
19.5 Machine Modes
19.6 Constant Expression Types
19.7 Registers and Memory
19.8 RTL Expressions for Arithmetic
19.9 Comparison Operations
19.10 Bit-Fields
19.11 Vector Operations
19.12 Conversions
19.13 Declarations
19.14 Side Effect Expressions
19.15 Embedded Side-Effects on Addresses
19.16 Assembler Instructions as Expressions
19.17 Insns
19.18 RTL Representation of Function-Call Insns
19.19 Structure Sharing Assumptions
19.20 Reading RTL

20. Machine Descriptions

20.1 Overview of How the Machine Description is Used
20.2 Everything about Instruction Patterns
20.3 Example of define_insn
20.4 RTL Template
20.5 Output Templates and Operand Substitution
20.6 C Statements for Assembler Output
20.7 Operand Constraints

20.7.1 Simple Constraints
20.7.2 Multiple Alternative Constraints
20.7.3 Register Class Preferences
20.7.4 Constraint Modifier Characters
20.7.5 Constraints for Particular Machines

20.8 Standard Pattern Names For Generation
20.9 When the Order of Patterns Matters
20.10 Interdependence of Patterns
20.11 Defining Jump Instruction Patterns
20.12 Defining Looping Instruction Patterns
20.13 Canonicalization of Instructions
20.14 Defining RTL Sequences for Code Generation
20.15 Defining How to Split Instructions
20.16 Machine-Specific Peephole Optimizers

20.16.1 RTL to Text Peephole Optimizers
20.16.2 RTL to RTL Peephole Optimizers

20.17 Instruction Attributes

20.17.1 Defining Attributes and their Values
20.17.2 Attribute Expressions
20.17.3 Assigning Attribute Values to Insns
20.17.4 Example of Attribute Specifications
20.17.5 Computing the Length of an Insn
20.17.6 Constant Attributes
20.17.7 Delay Slot Scheduling
20.17.8 Specifying Function Units

20.18 Conditional Execution
20.19 Constant Definitions

21. Target Description Macros

21.1 Controlling the Compilation Driver, `gcc'
21.2 Run-time Target Specification
21.3 Defining data structures for per-function information.
21.4 Storage Layout
21.5 Layout of Source Language Data Types
21.6 Register Usage

21.6.1 Basic Characteristics of Registers
21.6.2 Order of Allocation of Registers
21.6.3 How Values Fit in Registers
21.6.4 Handling Leaf Functions
21.6.5 Registers That Form a Stack

21.7 Register Classes
21.8 Stack Layout and Calling Conventions

21.8.1 Basic Stack Layout
21.8.2 Specifying How Stack Checking is Done
21.8.3 Registers That Address the Stack Frame
21.8.4 Eliminating Frame Pointer and Arg Pointer
21.8.5 Passing Function Arguments on the Stack
21.8.6 Passing Arguments in Registers
21.8.7 How Scalar Function Values Are Returned
21.8.8 How Large Values Are Returned
21.8.9 Caller-Saves Register Allocation
21.8.10 Function Entry and Exit
21.8.11 Generating Code for Profiling
21.8.12 Permitting inlining of functions with attributes
21.8.13 Permitting tail calls to functions

21.9 Implementing the Varargs Macros
21.10 Trampolines for Nested Functions
21.11 Implicit Calls to Library Routines
21.12 Addressing Modes
21.13 Condition Code Status
21.14 Describing Relative Costs of Operations
21.15 Dividing the Output into Sections (Texts, Data, ...)
21.16 Position Independent Code
21.17 Defining the Output Assembler Language

21.17.1 The Overall Framework of an Assembler File
21.17.2 Output of Data
21.17.3 Output of Uninitialized Variables
21.17.4 Output and Generation of Labels
21.17.5 How Initialization Functions Are Handled
21.17.6 Macros Controlling Initialization Routines
21.17.7 Output of Assembler Instructions
21.17.8 Output of Dispatch Tables
21.17.9 Assembler Commands for Exception Regions
21.17.10 Assembler Commands for Alignment

21.18 Controlling Debugging Information Format

21.18.1 Macros Affecting All Debugging Formats
21.18.2 Specific Options for DBX Output
21.18.3 Open-Ended Hooks for DBX Format
21.18.4 File Names in DBX Format
21.18.5 Macros for SDB and DWARF Output

21.19 Cross Compilation and Floating Point
21.20 Mode Switching Instructions
21.21 Miscellaneous Parameters

22. The Configuration File
23. Makefile Fragments

23.1 The Target Makefile Fragment
23.2 The Host Makefile Fragment

Funding Free Software
Linux and the GNU Project
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
Index

---

This document was generated by GCC Administrator on August, 28 2001 using texi2html