GNU GCC
Manuals and User Guides for GNU GCC. We found 11 manuals for free downloads Manual, Reference manual, User manual, HOWTO
Below you will find brief information for Compiler Collection GCC. This document details the internal workings of the GNU Compiler Collection (GCC), a suite of compilers that support various programming languages including C, C++, Fortran, Ada, and more. It explains how to port GCC to new target systems, write front ends for new languages, and utilize the compiler's capabilities for optimal performance and code generation.
Key Features
Supports multiple programming languages
Highly portable and configurable for different platforms
Provides advanced optimization and code generation techniques
Open-source and actively developed by a large community
Includes a comprehensive set of tools for debugging and analysis
Supports various target architectures and operating systems
Pages: 478 GNU GCC Manual
Brand: GNU Category: Software Size: 2 MB
Languages: English
Table of contents
- 23 Routines for integer arithmetic
- 23 Arithmetic functions
- 24 Comparison functions
- 25 Trapping arithmetic functions
- 25 Bit operations
- 26 Routines for floating point emulation
- 26 Arithmetic functions
- 27 Conversion functions
- 28 Comparison functions
- 29 Language-independent routines for exception handling
- 30 Miscellaneous runtime library routines
- 30 Cache control functions
- 33 Configure Terms and History
- 33 Top Level Source Directory
- 34 The ‘gcc’ Subdirectory
- 35 Subdirectories of ‘gcc
- 35 Configuration in the ‘gcc’ Directory
- 36 Scripts Used by ‘configure
- 36 Files
- 36 Files Created by configure
- 37 Build System in the ‘gcc’ Directory
- 37 Makefile Targets
- 39 Headers Installed by GCC
- 40 Building Documentation
- 40 Texinfo Manuals
- 41 Man Page Generation
- 41 Miscellaneous Documentation
- 42 Anatomy of a Language Front End
- 43 The Front End ‘language ’ Directory
- 45 The Front End ‘config-lang.in’ File
- 46 Anatomy of a Target Back End
- 47 Testsuites
- 47 Idioms Used in Testsuite Code
- 49 Directives used within DejaGnu tests
- 52 Ada Language Testsuites
- 52 C Language Testsuites
- 54 The Java library testsuites
- 54 Support for testing gcov
- 55 Support for testing profile-directed optimizations
- 56 Support for testing binary compatibility
- 59 Parsing pass
- 60 Gimplification pass
- 60 Pass manager
- 61 Tree-SSA passes
- 65 RTL passes
- 71 Deficiencies
- 71 Overview
- 72 Trees
- 72 Identifiers
- 73 Containers
- 73 Types
- 78 Scopes
- 78 Namespaces
- 79 Classes
- 81 Declarations
- 83 Functions
- 84 Function Basics
- 87 Function Bodies
- 87 Statements
- 91 Attributes in trees
- 92 Expressions
- 103 GENERIC
- 103 GIMPLE
- 104 Interfaces
- 104 Temporaries
- 105 Expressions
- 105 Compound Expressions
- 105 Compound Lvalues
- 105 Conditional Expressions
- 106 Logical Operators
- 106 Statements
- 106 Blocks
- 107 Statement Sequences
- 107 Empty Statements
- 107 Loops
- 107 Selection Statements
- 107 Jumps
- 107 Cleanups
- 108 Exception Handling
- 108 GIMPLE Example
- 109 Rough GIMPLE Grammar
- 112 Annotations
- 112 Statement Operands
- 115 Operand Iterators
- 116 Static Single Assignment
- 118 Preserving the SSA form
- 118 Examining SSA_NAME nodes
- 118 Walking use-def chains
- 118 Walking the dominator tree
- 119 Alias analysis
- 123 RTL Object Types
- 124 RTL Classes and Formats
- 126 Access to Operands
- 127 Access to Special Operands
- 129 Flags in an RTL Expression
- 134 Machine Modes
- 138 Constant Expression Types
- 140 Registers and Memory
- 144 RTL Expressions for Arithmetic
- 147 Comparison Operations
- 149 Bit-Fields
- 149 Vector Operations
- 150 Conversions
- 151 Declarations
- 151 Side Effect Expressions
- 156 Embedded Side-Effects on Addresses
- 158 Assembler Instructions as Expressions
- 158 Insns
- 167 RTL Representation of Function-Call Insns
- 168 Structure Sharing Assumptions
- 168 Reading RTL
- 171 Basic Blocks
- 172 Edges
- 175 Profile information
- 176 Maintaining the CFG
- 179 Liveness information
- 181 Overview of How the Machine Description is Used
- 181 Everything about Instruction Patterns
- 182 Example of define_insn
- 183 RTL Template
- 186 Output Templates and Operand Substitution
- 188 C Statements for Assembler Output
- 189 Predicates
- 190 Machine-Independent Predicates
- 192 Defining Machine-Specific Predicates
- 193 Operand Constraints
- 193 Simple Constraints
- 197 Multiple Alternative Constraints
- 198 Register Class Preferences
- 199 Constraint Modifier Characters
- 200 Constraints for Particular Machines
- 212 Standard Pattern Names For Generation
- 229 When the Order of Patterns Matters
- 229 Interdependence of Patterns
- 230 Defining Jump Instruction Patterns
- 231 Defining Looping Instruction Patterns
- 233 Canonicalization of Instructions
- 234 Defining RTL Sequences for Code Generation
- 237 Defining How to Split Instructions
- 240 Including Patterns in Machine Descriptions
- 241 RTL Generation Tool Options for Directory Search
- 241 Machine-Specific Peephole Optimizers
- 242 RTL to Text Peephole Optimizers
- 244 RTL to RTL Peephole Optimizers
- 245 Instruction Attributes
- 245 Defining Attributes and their Values
- 246 Attribute Expressions
- 248 Assigning Attribute Values to Insns
- 250 Example of Attribute Specifications
- 251 Computing the Length of an Insn
- 252 Constant Attributes
- 252 Delay Slot Scheduling
- 253 Specifying processor pipeline description
- 259 Conditional Execution
- 260 Constant Definitions
- 260 Macros
- 260 Mode Macros
- 261 Defining Mode Macros
- 261 String Substitution in Mode Macros
- 262 Mode Macro Examples
- 262 Code Macros
- 265 The Global targetm Variable
- 265 Controlling the Compilation Driver, ‘gcc
- 273 Run-time Target Specification
- 277 Defining data structures for per-function information
- 277 Storage Layout
- 286 Layout of Source Language Data Types
- 290 Register Usage
- 290 Basic Characteristics of Registers
- 292 Order of Allocation of Registers
- 292 How Values Fit in Registers
- 294 Handling Leaf Functions
- 295 Registers That Form a Stack
- 295 Register Classes
- 303 Stack Layout and Calling Conventions
- 303 Basic Stack Layout
- 306 Exception Handling Support
- 308 Specifying How Stack Checking is Done
- 310 Registers That Address the Stack Frame
- 312 Eliminating Frame Pointer and Arg Pointer
- 313 Passing Function Arguments on the Stack
- 315 Passing Arguments in Registers
- 320 How Scalar Function Values Are Returned
- 321 How Large Values Are Returned
- 322 Caller-Saves Register Allocation
- 322 Function Entry and Exit
- 326 Generating Code for Profiling
- 327 Permitting tail calls
- 327 Implementing the Varargs Macros
- 330 Trampolines for Nested Functions
- 332 Implicit Calls to Library Routines
- 333 Addressing Modes
- 338 Condition Code Status
- 340 Describing Relative Costs of Operations
- 344 Adjusting the Instruction Scheduler
- 348 Dividing the Output into Sections (Texts, Data, . . . )
- 352 Position Independent Code
- 353 Defining the Output Assembler Language
- 353 The Overall Framework of an Assembler File
- 355 Output of Data
- 357 Output of Uninitialized Variables
- 359 Output and Generation of Labels
- 366 How Initialization Functions Are Handled
- 367 Macros Controlling Initialization Routines
- 369 Output of Assembler Instructions
- 372 Output of Dispatch Tables
- 373 Assembler Commands for Exception Regions
- 375 Assembler Commands for Alignment
- 377 Controlling Debugging Information Format
- 377 Macros Affecting All Debugging Formats
- 378 Specific Options for DBX Output
- 380 Open-Ended Hooks for DBX Format
- 380 File Names in DBX Format
- 381 Macros for SDB and DWARF Output
- 383 Macros for VMS Debug Format
- 383 Cross Compilation and Floating Point
- 385 Mode Switching Instructions
- 386 Defining target-specific uses of __attribute
- 387 Defining coprocessor specifics for MIPS targets
- 388 Parameters for Precompiled Header Validity Checking
- 388 C++ ABI parameters
- 389 Miscellaneous Parameters
- 403 Host Common
- 404 Host Filesystem
- 405 Host Misc
- 407 Target Makefile Fragments
- 409 Host Makefile Fragments
- 415 The Inside of a GTY(())
- 419 Marking Roots for the Garbage Collector
- 419 Source Files Containing Type Information
Other manuals and documents
Frequently Answers and Questions
What is GCC and what languages does it support?
GCC, or the GNU Compiler Collection, is a suite of compilers that supports a wide range of programming languages, including C, C++, Fortran, Ada, Go, and more. It is designed to be highly portable and configurable for different platforms.
How can I contribute to GCC development?
The GCC project encourages contributions from the community. You can help by testing upcoming releases, reporting bugs, or contributing code improvements. Refer to the project's website for more information on how to contribute.
How does GCC generate code for different architectures?
GCC utilizes a machine description file for each target architecture that defines the instruction set and other system-specific parameters. This allows GCC to generate optimized code for different platforms without requiring extensive platform-specific code.
advertisement