Index

Jump to:   _   -   .   /   #   $   6  
A   B   C   D   E   F   G   H   I   J   K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Z  
Index EntrySection

_
__gxx_personality_v0, undefined reference errorCompiling a simple C++ program
_FORTIFY_SOURCE macroBuffer overflow protection
_GNU_SOURCE macro, enables extensions to GNU C LibraryANSI/ISO

-
--help option, display command-line optionsHelp for command-line options
--param=ssp-buffer-size=4 optionStack smashing protector (SSP)
--version option, display version numberVersion numbers
-ansi option, disable language extensionsC language standards
-ansi option, used with g++Compiling a simple C++ program
-c option, compile to object fileCreating object files from source files
-D option, define macroDefining macros
-D_FORTIFY_SOURCE optionBuffer overflow protection
-dM option, list predefined macrosDefining macros
-E option, preprocess source filesPreprocessing source files
-fno-default-inline optionC++ compilation options
-fno-implicit-templates option, disable implicit instantiationExplicit template instantiation
-fprofile-arcs option, instrument branchesCoverage testing with gcov
-fsigned-bitfields optionPortability of signed and unsigned types
-fsigned-char optionPortability of signed and unsigned types
-fstack-protector optionStack smashing protector (SSP)
-ftest-coverage option, record coverageCoverage testing with gcov
-funroll-loops option, optimization by loop unrollingOptimization levels
-funsigned-bitfields optionPortability of signed and unsigned types
-funsigned-char optionPortability of signed and unsigned types
-g option, enable debuggingCompiling for debugging
-I option, include pathSetting search paths
-L option, library search pathSetting search paths
-l option, linking with librariesLinking with external libraries
-lm option, link with math libraryLinking with external libraries
-m option, platform-specific settingsPlatform-specific options
-m32 and -m64 options, compile for 32 or 64-bit environmentSPARC options
-maltivec option, enables use of Altivec processor on PowerPCPOWER/PowerPC options
-march option, compile for specific CPUIntel and AMD x86 options
-mcmodel option, for AMD64x86 64-bit processors
-mcpu option, compile for specific CPUSPARC options
-mfpmath option, for floating-point arithmeticx86 extensions
-mieee option, floating-point support on DEC AlphaDEC Alpha options
-mminimal-toc option, on AIXPOWER/PowerPC options
-mno-fused-madd option, on PowerPCPOWER/PowerPC options
-msse and related optionsx86 extensions
-mtune optionIntel and AMD x86 options
-mxl-call option, compatibility with IBM XL compilers on AIXPOWER/PowerPC options
-o option, set output filenameCompiling a simple C program
-O0 option, optimization level zeroOptimization levels
-O1 option, optimization level oneOptimization levels
-O1 option, optimization level oneBuffer overflow protection
-O2 option, optimization level twoOptimization levels
-O2 option, optimization level twoBuffer overflow protection
-O3 option, optimization level threeOptimization levels
-Os option, optimization for sizeOptimization levels
-pedantic option, conform to the ANSI standard (with -ansi)C language standards
-pg option, enable profilingUsing the profiler gprof
-pthread option, on AIXPOWER/PowerPC options
-rpath option, set run-time shared library search pathShared libraries and static libraries
-S option, create assembly codeThe compiler
-save-temps option, keeps intermediate filesPreprocessing source files
-static option, force static linkingShared libraries and static libraries
-std option, select specific language standardC language standards
-std option, select specific language standardSelecting specific standards
-v option, verbose compilationHelp for command-line options
-W option, enable additional warningsAdditional warning options
-Wall option, enable common warningsCompiling a simple C program
-Wcast-qual option, warn about casts removing qualifiersAdditional warning options
-Wcomment option, warn about nested commentsWarning options in -Wall
-Wconversion option, warn about type conversionsAdditional warning options
-Weffc++ optionC++ compilation options
-Werror option, convert warnings to errorsAdditional warning options
-Wformat option, warn about incorrect format stringsWarning options in -Wall
-Wformat option, warn about incorrect format stringsWarning for format string
-Wformat-security option, warn about uncontrolled format stringWarning for format string
-Wimplicit option, warn about missing declarationsWarning options in -Wall
-Wl,z,now optionBinding policy NOW
-Wl,z,relro optionRead-only relocations
-Wl,z,relro optionBinding policy NOW
-Wold-style-cast optionC++ compilation options
-Wreturn-type option, warn about incorrect return typesWarning options in -Wall
-Wshadow option, warn about shadowed variablesAdditional warning options
-Wtraditional option, warn about traditional CAdditional warning options
-Wuninitialized option, warn about uninitialized variablesOptimization and compiler warnings
-Wunused option, unused variable warningWarning options in -Wall
-Wwrite-strings option, warning for modified string constantsAdditional warning options

.
.a, archive file extensionLinking with external libraries
.c, C source file extensionCompiling a simple C program
.cc, C++ file extensionCompiling a simple C++ program
.cpp, C++ file extensionCompiling a simple C++ program
.cxx, C++ file extensionCompiling a simple C++ program
.h, header file extensionCompiling multiple source files
.i, preprocessed file extension for CThe preprocessor
.ii, preprocessed file extension for C++The preprocessor
.o, object file extensionCompiling files independently
.s, assembly file extensionThe compiler
.so, shared object file extensionShared libraries and static libraries

/
/tmp directory, temporary filesLinking with external libraries

#
#define, preprocessor directiveDefining macros
#elif, preprocessor directivePreprocessor error messages
#else, preprocessor directivePreprocessor error messages
#if, preprocessor directiveWarning options in -Wall
#ifdef, preprocessor directiveDefining macros
#include, preprocessor directiveCompiling multiple source files
#warning, preprocessor directivePreprocessor error messages

$
$, shell promptConventions used in this manual

6
64-bit platforms, additional library directoriesSetting search paths
64-bit processor-specific options, AMD64 and Intelx86 64-bit processors

A
a, archive file extensionLinking with external libraries
a.out, default executable filenameCompiling a simple C program
ADA, gnat compilerA brief history of GCC
additional warning optionsAdditional warning options
AIX, compatibility with IBM XL compilersPOWER/PowerPC options
AIX, platform-specific optionsPOWER/PowerPC options
AIX, TOC overflow errorPOWER/PowerPC options
Alpha, platform-specific optionsDEC Alpha options
Altivec, on PowerPCPOWER/PowerPC options
AMD x86, platform-specific optionsIntel and AMD x86 options
AMD64, 64-bit processor specific optionsx86 64-bit processors
ansi option, disable language extensionsC language standards
ansi option, used with g++Compiling a simple C++ program
ANSI standards for C/C++ languages, available as booksFurther reading
ANSI/ISO C, compared with GNU C extensionsC language standards
ANSI/ISO C, controlled with -ansi optionANSI/ISO
ANSI/ISO C, pedantic diagnostics optionStrict ANSI/ISO
antiquated header in C++Preprocessor error messages
ar, GNU archiverLinking with external libraries
ar, GNU archiverCreating a library with the GNU archiver
archive file, .a extensionLinking with external libraries
archive file, explanation ofLinking with external libraries
archiver, arHow the compiler works
arithmetic, floating-pointFloating-point issues
ARM, multi-architecture supportMulti-architecture support
arrays, variable-sizeStrict ANSI/ISO
asm extension keywordANSI/ISO
asm extension keywordFloating-point issues
assembler, asHow the compiler works
assembler, converting assembly language to machine codeThe assembler
assignment discards qualifiersCompiler error messages
assignment of read-only locationCompiler error messages
Athlon, platform-specific optionsIntel and AMD x86 options
attach, debug running programStopping a program in an infinite loop

B
backtrace, debugger commandDisplaying a backtrace
backtrace, displayingDisplaying a backtrace
bash profile fileExamining core files
bash profile file, login settingsEnvironment variables
bash profile file, login settingsShared libraries and static libraries
benchmarking, with time commandOptimization examples
big-endian, word-orderingIdentifying files
binary file, also called executable fileCompiling a C program
Binding policy NOWBinding policy NOW
Binutils, GNU Binary ToolsExamining the symbol table
bitfields, portability of signed vs unsignedPortability of signed and unsigned types
bits, 32 vs 64 on UltraSPARCSPARC options
books, further readingFurther reading
branches, instrumenting for coverage testingCoverage testing with gcov
break, command in gdbSetting a breakpoint
breakpoints, definedSetting a breakpoint
BSD extensions, GNU C LibraryANSI/ISO
buffer overflow protectionBuffer overflow protection
buffer, template exampleProviding your own templates
bug, example ofFinding errors in a simple program
bug, example ofUsing library header files
bug, example ofExamining core files
bus errorRuntime error messages

C
C include pathEnvironment variables
C language, dialects ofC language standards
C language, further readingFurther reading
C library, standardLinking with external libraries
C library, standardFurther reading
C math libraryLinking with external libraries
c option, compile to object fileCreating object files from source files
C programs, recompiling after modificationRecompiling and relinking
C source file, .c extensionCompiling a simple C program
C standard libraryLinking with external libraries
C_INCLUDE_PATHEnvironment variables
c, C source file extensionCompiling a simple C program
C, compiling with gccCompiling a simple C program
C, gcc compilerA brief history of GCC
C/C++ languages, standards in printed formFurther reading
C/C++, risks of usingProgramming in C and C++
C/C++, risks of usingFinding errors in a simple program
C/C++, risks of usingUsing library header files
C/C++, risks of usingOptimization and compiler warnings
C++ include pathEnvironment variables
C++, compiling a simple program with g++Compiling a simple C++ program
C++, creating libraries with explicit instantiationExplicit template instantiation
C++, file extensionsCompiling a simple C++ program
C++, g++ as a true compilerCompiling a C++ program
C++, g++ compilerA brief history of GCC
C++, instantiation of templatesProviding your own templates
C++, namespace stdUsing the C++ standard library
C++, standard libraryUsing the C++ standard library
C++, standard libraryUsing C++ standard library templates
C++, standard library templatesUsing C++ standard library templates
C++, templatesTemplates
c89/c99, selected with -stdSelecting specific standards
cannot find library errorSetting search paths
cannot find library errorSearch path example
cannot open shared object fileShared libraries and static libraries
cannot open shared object fileRuntime error messages
cast discards qualifiers from pointer target typeCompiler error messages
casts, used to avoid conversion warningsAdditional warning options
cc, C++ file extensionCompiling a simple C++ program
CC, make variableA simple makefile
CFLAGS, make variableA simple makefile
char, portability of signed vs unsignedPortability of signed and unsigned types
character constant too longCompiler error messages
character constant too longCompiler error messages
circular buffer, template exampleProviding your own templates
COFF formatIdentifying files
Collatz sequenceUsing the profiler gprof
collect2: ld returned 1 exit statusLinker error messages
combined multiply and add instructionPOWER/PowerPC options
command-line help optionTroubleshooting
command, in makefileA simple makefile
comment warning option, warn about nested commentsWarning options in -Wall
comments, nestedWarning options in -Wall
commercial supportGetting help
common error messagesCommon error messages
common errors, not included with -WallAdditional warning options
common subexpression elimination, optimizationSource-level optimization
comparison of expression always true/false warningAdditional warning options
compilation, for debuggingCompiling for debugging
compilation, internal stages ofHow the compiler works
compilation, model for templatesProviding your own templates
compilation, optionsCompilation options
compilation, stopping on warningAdditional warning options
compile to object file, -c optionCreating object files from source files
compiled files, examiningExamining compiled files
compiler-related toolsCompiler-related tools
compiler, converting source code to assembly codeThe compiler
compiler, error messagesCompiler error messages
compiler, how it works internallyHow the compiler works
compiling C programs with gccCompiling a C program
compiling C++ programs with g++Compiling a simple C++ program
compiling files independentlyCompiling files independently
compiling multiple filesCompiling multiple source files
compiling with optimizationCompiling with optimization
configuration files for GCCVersion numbers
const, warning about overriding by castsAdditional warning options
constant strings, compile-time warningsAdditional warning options
continue, command in gdbContinuing execution
control reaches end of non-void functionCompiler error messages
control-C, interruptStopping a program in an infinite loop
conventions, used in manualConventions used in this manual
conversions between types, warning ofAdditional warning options
core file, examiningExamining core files
core file, examiningExamining core files
core file, not producedExamining core files
coverage testing, with gcovCoverage testing with gcov
CPLUS_INCLUDE_PATHEnvironment variables
cpp, C preprocessorUsing the preprocessor
cpp, C++ file extensionCompiling a simple C++ program
CPPFLAGS, make variableA simple makefile
cr option, create/replace archive filesCreating a library with the GNU archiver
crashes, saved in core fileExamining core files
creating executable files from object filesCreating executables from object files
creating object files from source filesCreating object files from source files
cxx, C++ file extensionCompiling a simple C++ program
CXX, make variableA simple makefile
CXXFLAGS, make variableA simple makefile

D
D option, define macroDefining macros
data-flow analysisOptimization and compiler warnings
DBM file, created with gdbmSearch path example
debugging, compilation flagsCompiling for debugging
debugging, with gdbCompiling for debugging
debugging, with optimizationOptimization and debugging
DEC Alpha, platform-specific optionsDEC Alpha options
declaration, in header fileCompiling multiple source files
declaration, missingUsing library header files
default directories, linking and header filesSetting search paths
default executable filename, a.outCompiling a simple C program
default value, of macro defined with -DMacros with values
defining macrosDefining macros
denormalized numbers, on DEC AlphaDEC Alpha options
dependencies, of shared librariesFinding dynamically linked libraries
dependency, in makefileA simple makefile
deployment, options forExamining core files
deployment, options forOptimization levels
deployment, options forOptimization and debugging
deprecated header in C++Preprocessor error messages
dereferencing pointer to incomplete typeCompiler error messages
dereferencing, null pointerExamining core files
dialects of C languageC language standards
different type arg, format warningFinding errors in a simple program
disk space, reduced usage by shared librariesShared libraries and static libraries
displaying a backtraceDisplaying a backtrace
division by zeroDEC Alpha options
DLL (dynamically linked library), see shared librariesShared libraries and static libraries
dM option, list predefined macrosDefining macros
dollar sign $, shell promptConventions used in this manual
double precisionFloating-point issues
dynamic loaderShared libraries and static libraries
dynamically linked libraries, examining with lddFinding dynamically linked libraries
dynamically linked library, see shared librariesShared libraries and static libraries

E
E option, preprocess source filesPreprocessing source files
effc++ warning optionC++ compilation options
EGCS (Experimental GNU Compiler Suite)A brief history of GCC
ELF formatIdentifying files
elimination, of common subexpressionsSource-level optimization
Emacs, gdb modeMore information about GDB
embedded systems, cross-compilation forMajor features of GCC
empty macro, compared with undefined macroMacros with values
empty return, incorrect use ofWarning options in -Wall
enable profiling, -pg optionUsing the profiler gprof
endianness, word-orderingIdentifying files
enhancements, to GCCGetting help
environment variablesConventions used in this manual
environment variablesShared libraries and static libraries
environment variables, extending an existing pathShared libraries and static libraries
environment variables, for default search pathsEnvironment variables
environment variables, setting permanentlyShared libraries and static libraries
error messages, common examplesCommon error messages
error while loading shared librariesShared libraries and static libraries
error while loading shared librariesRuntime error messages
error, undefined reference due to library link orderLink order of libraries
examining compiled filesExamining compiled files
examining core filesExamining core files
examples, conventions used inConventions used in this manual
exception handling, floating-pointFloating-point issues
executable fileCompiling a C program
executable, creating from object files by linkingCreating executables from object files
executable, default filename a.outCompiling a simple C program
executable, examining with file commandIdentifying files
executable, runningCompiling a simple C program
executable, symbol table stored inCompiling for debugging
exit code, displayed in gdbContinuing execution
explicit instantiation of templatesExplicit template instantiation
export keyword, not supported in GCCThe export keyword
extended precision, x86 processorsFloating-point issues
extended search paths, for include and link directoriesExtended search paths
extension, .a archive fileLinking with external libraries
extension, .c source fileCompiling a simple C program
extension, .C, C++ fileCompiling a simple C++ program
extension, .C, C++ fileCompiling a simple C++ program
extension, .cc, C++ fileCompiling a simple C++ program
extension, .cpp, C++ fileCompiling a simple C++ program
extension, .cxx, C++ fileCompiling a simple C++ program
extension, .h header fileCompiling multiple source files
extension, .i preprocessed fileThe preprocessor
extension, .ii preprocessed fileThe preprocessor
extension, .o object fileCompiling files independently
extension, .s assembly fileThe compiler
extension, .so shared object fileShared libraries and static libraries
external libraries, linking withLinking with external libraries

F
feature test macros, GNU C LibraryANSI/ISO
features, of GCCMajor features of GCC
file command, for identifying filesIdentifying files
file extension, .a archive fileLinking with external libraries
file extension, .c source fileCompiling a simple C program
file extension, .C, C++ fileCompiling a simple C++ program
file extension, .C, C++ fileCompiling a simple C++ program
file extension, .cc, C++ fileCompiling a simple C++ program
file extension, .cpp, C++ fileCompiling a simple C++ program
file extension, .cxx, C++ fileCompiling a simple C++ program
file extension, .h header fileCompiling multiple source files
file extension, .i preprocessed fileThe preprocessor
file extension, .ii preprocessed fileThe preprocessor
file extension, .o object fileCompiling files independently
file extension, .s assembly fileThe compiler
file extension, .so shared object fileShared libraries and static libraries
file format not recognizedLinker error messages
file includes at least one deprecated or antiquated headerPreprocessor error messages
file not recognizedLinker error messages
finish, command in gdbContinuing execution
fldcw set floating point modeFloating-point issues
floating point arithmetic, with SSE extensionsx86 extensions
floating point exceptionRuntime error messages
floating point exception handlingFloating-point issues
floating point exception, on DEC AlphaDEC Alpha options
floating point, portability problemsFloating-point issues
fno-default-inline optionC++ compilation options
fno-implicit-templates option, disable implicit instantiationExplicit template instantiation
format strings, incorrect usage warningWarning options in -Wall
format, different type arg warningFinding errors in a simple program
Fortran, g77 compilerA brief history of GCC
fpmath option, for floating-point arithmeticx86 extensions
fprofile-arcs option, instrument branchesCoverage testing with gcov
Free Software Foundation (FSF)A brief history of GCC
FreeBSD, floating-point arithmeticFloating-point issues
ftest-coverage option, record coverageCoverage testing with gcov
function inlining, example of optimizationSource-level optimization
function-call overheadSource-level optimization
funroll-loops option, optimization by loop unrollingOptimization levels
fused multiply and add instructionPOWER/PowerPC options

G
g option, enable debuggingCompiling for debugging
g++, compiling C++ programsCompiling a simple C++ program
g++, GNU C++ CompilerA brief history of GCC
g77, Fortran compilerA brief history of GCC
gcc, GNU C CompilerA brief history of GCC
gcc, simple exampleCompiling a simple C program
gcc, used inconsistently with g++Compiling a simple C++ program
gcj, GNU Compiler for JavaA brief history of GCC
gcov, GNU coverage testing toolCoverage testing with gcov
gdbCompiling for debugging
gdb, debugging core file withExamining core files
gdb, Emacs modeMore information about GDB
gdb, graphical interfaceMore information about GDB
gdbm, GNU DBM librarySearch path example
generic programming, in C++Templates
getting helpGetting help
gmon.out, data file for gprofUsing the profiler gprof
gnat, GNU ADA compilerA brief history of GCC
GNU archiver, arLinking with external libraries
GNU C extensions, compared with ANSI/ISO CC language standards
GNU C Library Reference ManualFurther reading
GNU C Library, feature test macrosANSI/ISO
GNU Compilers, major featuresMajor features of GCC
GNU Compilers, Reference ManualFurther reading
GNU debugger, gdbCompiling for debugging
GNU GDB ManualFurther reading
GNU MakeA simple makefile
GNU Make ManualFurther reading
GNU Press, manualsFurther reading
GNU Project, history ofA brief history of GCC
GNU_SOURCE macro (_GNU_SOURCE), enables extensions to GNU C LibraryANSI/ISO
GNU/Linux, floating-point arithmeticFloating-point issues
gnu89/gnu99, selected with -stdSelecting specific standards
gprof, GNU ProfilerUsing the profiler gprof
gradual underflow, on DEC AlphaDEC Alpha options
gxx_personality_v0, undefined reference errorCompiling a simple C++ program

H
h, header file extensionCompiling multiple source files
header file, .h extensionCompiling multiple source files
header file, declarations inCompiling multiple source files
header file, default directoriesSetting search paths
header file, include path—extending with -ISetting search paths
header file, missingUsing library header files
header file, missing header causes implicit declarationUsing library header files
header file, not compiledCreating object files from source files
header file, not foundSetting search paths
header file, with include guardsProviding your own templates
header file, without .h extension for C++Using the C++ standard library
Hello World program, in CCompiling a simple C program
Hello World program, in C++Compiling a simple C++ program
help optionsTroubleshooting
history, of GCCA brief history of GCC

I
I option, include pathSetting search paths
i, preprocessed file extension for CThe preprocessor
IBM XL compilers, compatibility on AIXPOWER/PowerPC options
identifying files, with file commandIdentifying files
IEEE arithmeticFloating-point issues
IEEE arithmetic standard, printed formFurther reading
IEEE options, on DEC AlphaDEC Alpha options
IEEE-754 standardFurther reading
ii, preprocessed file extension for C++The preprocessor
illegal instruction errorx86 extensions
illegal instruction errorRuntime error messages
implicit declaration of functionUsing library header files
implicit declaration of functionWarning options in -Wall
implicit declaration of functionCompiler error messages
implicit rules, in makefileA simple makefile
include guards, in header fileProviding your own templates
include nested too deeplyPreprocessor error messages
include path, extending with -ISetting search paths
include path, setting with environment variablesEnvironment variables
inclusion compilation model, in C++Providing your own templates
independent compilation of filesCompiling files independently
Inf, infinity, on DEC AlphaDEC Alpha options
infinite loop, stoppingStopping a program in an infinite loop
initialization discards qualifiersCompiler error messages
initialization makes integer from pointer without a castCompiler error messages
initializer element is not a constantCompiler error messages
inlining, example of optimizationSource-level optimization
Insight, graphical interface for gdbMore information about GDB
instantiation, explicit vs implicit in C++Explicit template instantiation
instantiation, of templates in C++Providing your own templates
instruction scheduling, optimizationScheduling
instrumented executable, for coverage testingCoverage testing with gcov
instrumented executable, for profilingUsing the profiler gprof
Intel x86, platform-specific optionsIntel and AMD x86 options
intermediate files, keepingPreprocessing source files
invalid preprocessing directivePreprocessor error messages
ISO C, compared with GNU C extensionsC language standards
ISO C, controlled with -ansi optionANSI/ISO
ISO C++, controlled with -ansi optionCompiling a simple C++ program
ISO standards for C/C++ languages, available as booksFurther reading
iso9899:1990/iso9899:1999, selected with -stdSelecting specific standards
Itanium, multi-architecture supportMulti-architecture support

J
Java, compared with C/C++Programming in C and C++
Java, gcj compilerA brief history of GCC

K
K&R dialect of C, warnings of different behaviorAdditional warning options
kernel mode, on AMD64x86 64-bit processors
Kernighan and Ritchie, The C Programming LanguageFurther reading
key-value pairs, stored with GDBMSearch path example
keywords, additional in GNU CANSI/ISO

L
L option, library search pathSetting search paths
l option, linking with librariesLinking with external libraries
language standards, selecting with -stdSelecting specific standards
ld returned 1 exit statusLinker error messages
LD_LIBRARY_PATH, shared library load pathShared libraries and static libraries
ld: cannot find library errorSetting search paths
ld.so.conf, loader configuration fileShared libraries and static libraries
ldd, dynamical loaderFinding dynamically linked libraries
levels of optimizationOptimization levels
libraries, creating with arCreating a library with the GNU archiver
libraries, creating with explicit instantiation in C++Explicit template instantiation
libraries, error while loading shared libraryShared libraries and static libraries
libraries, extending search path with -LSetting search paths
libraries, finding shared library dependenciesFinding dynamically linked libraries
libraries, link error due to undefined referenceLinking with external libraries
libraries, link orderLink order of libraries
libraries, link orderLink order of libraries
libraries, linking withLinking with external libraries
libraries, linking withLinking with external libraries
libraries, on 64-bit platformsSetting search paths
libraries, stored in archive filesLinking with external libraries
library header files, usingUsing library header files
library, C math libraryLinking with external libraries
library, C standard libraryLinking with external libraries
library, C++ standard libraryUsing the C++ standard library
libstdc++, C++ standard libraryUsing C++ standard library templates
line numbers, recorded in preprocessed filesPreprocessing source files
link error, cannot find librarySetting search paths
link order, from left to rightLink order of libraries
link order, of librariesLink order of libraries
link path, setting with environment variableEnvironment variables
linker, error messagesLinker error messages
linker, GNU compared with other linkersProviding your own templates
linker, initial descriptionCreating executables from object files
linker, ldHow the compiler works
linker, ldThe linker
linking, creating executable files from object filesCreating executables from object files
linking, default directoriesSetting search paths
linking, dynamic (shared libraries)Shared libraries and static libraries
linking, explanation ofCompiling files independently
linking, undefined reference error due to library link orderLink order of libraries
linking, updated object filesRecompiling and relinking
linking, with external librariesLinking with external libraries
linking, with library using -lLinking with external libraries
linkr error, cannot find librarySetting search paths
Linux kernel, floating-pointFloating-point issues
Lisp, compared with C/C++Programming in C and C++
little-endian, word-orderingIdentifying files
loader configuration file, ld.so.confShared libraries and static libraries
loader functionShared libraries and static libraries
login file, setting environment variables inShared libraries and static libraries
long double arithmeticFloating-point issues
loop unrolling, optimizationSpeed-space tradeoffs
loop unrolling, optimizationOptimization levels
LSB, least significant byteIdentifying files

M
m option, platform-specific settingsPlatform-specific options
m32 and m64 options, compile for 32 or 64-bit environmentSPARC options
machine codeCompiling a C program
machine instruction, asm keywordFloating-point issues
machine-specific optionsPlatform-specific options
macro or ’#include’ recursion too deepPreprocessor error messages
macros, default value ofMacros with values
macros, defined with valueMacros with values
macros, defining in preprocessorDefining macros
macros, predefinedDefining macros
major features, of GCCMajor features of GCC
major version number, of GCCVersion numbers
makefile, example ofA simple makefile
maltivec option, enables use of Altivec processor on PowerPCPOWER/PowerPC options
manuals, for GNU softwareFurther reading
march option, compile for specific CPUIntel and AMD x86 options
math libraryLinking with external libraries
math library, linking with -lmLinking with external libraries
mcmodel option, for AMD64x86 64-bit processors
mcpu option, compile for specific CPUSPARC options
memory usage, limitingPreventing excessive memory usage
mfpmath option, for floating-point arithmeticx86 extensions
mieee option, floating-point support on DEC AlphaDEC Alpha options
minor version number, of GCCVersion numbers
MIPS64, multi-architecture supportMulti-architecture support
missing header file, causes implicit declarationUsing library header files
missing header filesUsing library header files
missing prototypes warningWarning options in -Wall
mminimal-toc option, on AIXPOWER/PowerPC options
MMX extensionsx86 extensions
mno-fused-madd option, on PowerPCPOWER/PowerPC options
modified source files, recompilingRecompiling and relinking
modified source files, recompilingRecompiling and relinking
Motorola 680x0, floating-point arithmeticFloating-point issues
Motorola 680x0, word-orderIdentifying files
MSB, most significant byteIdentifying files
msse and related optionsx86 extensions
mtune optionIntel and AMD x86 options
multi-architecture support, DebianMulti-architecture support
multi-architecture support, discussion ofMulti-architecture support
multi-architecture support, older systemsMulti-architecture support
multi-architecture support, RedHatMulti-architecture support
multi-architecture support, UbuntuMulti-architecture support
multiple directories, on include and link pathsExtended search paths
multiple files, compilingCompiling multiple source files
multiple-character character constantCompiler error messages
multiply and add instructionPOWER/PowerPC options
multiply-defined symbol error, with C++Providing your own templates
mxl-call option, compatibility with IBM XL compilers on AIXPOWER/PowerPC options

N
namespace std in C++Using the C++ standard library
namespace, reserved prefix for preprocessorDefining macros
NaN, not a number, on DEC AlphaDEC Alpha options
native double-precision processorsFloating-point issues
nested comments, warning ofWarning options in -Wall
NetBSD, floating-point arithmeticFloating-point issues
next, command in gdbStepping through the program
nm commandExamining the symbol table
No such file or directoryPreprocessor error messages
No such file or directoryRuntime error messages
No such file or directory, header file not foundSetting search paths
No such file or directory, header file not foundSearch path example
no-default-inline optionC++ compilation options
null pointerExamining core files
null pointerRuntime error messages
numerical differencesFloating-point issues

O
O option, optimization levelOptimization levels
o option, set output filenameCompiling a simple C program
o, object file extensionCompiling files independently
object file, .o extensionCompiling files independently
object file, creating from source using option -cCreating object files from source files
object file, examining with file commandIdentifying files
object file, explanation ofCompiling files independently
object files, linking to create executable fileCreating executables from object files
object files, relinkingRecompiling and relinking
object files, temporaryLinking with external libraries
Objective-CA brief history of GCC
old-style C++ header filesPreprocessor error messages
old-style-cast warning optionC++ compilation options
OpenBSD, floating-point arithmeticFloating-point issues
optimization for size, -OsOptimization levels
optimization, and compiler warningsOptimization and compiler warnings
optimization, common subexpression eliminationSource-level optimization
optimization, compiling with -OOptimization levels
optimization, example ofOptimization examples
optimization, explanation ofCompiling with optimization
optimization, levels ofOptimization levels
optimization, loop unrollingSpeed-space tradeoffs
optimization, loop unrollingOptimization levels
optimization, speed-space tradeoffsSpeed-space tradeoffs
optimization, with debuggingOptimization and debugging
options, compilationCompilation options
options, platform-specificPlatform-specific options
options, security enhancementSecurity enhancement options
ordering of librariesLink order of libraries
output file option, -oCompiling a simple C program
overflow error, for TOC on AIXPOWER/PowerPC options
overflow, floating-point arithmeticFloating-point issues
overhead, from function callSource-level optimization

P
parse errorCompiler error messages
parse error at end of inputCompiler error messages
parse error due to language extensionsANSI/ISO
passing arg of function as another type to prototypeCompiler error messages
patch level, of GCCVersion numbers
paths, extending environment variableShared libraries and static libraries
paths, searchSetting search paths
pedantic optionC language standards
pedantic optionStrict ANSI/ISO
Pentium, platform-specific optionsIntel and AMD x86 options
pg option, enable profilingUsing the profiler gprof
pipelining, explanation ofScheduling
platform-specific optionsPlatform-specific options
POSIX extensions, GNU C LibraryANSI/ISO
PowerPC and POWER, platform-specific optionsPOWER/PowerPC options
PowerPC64, multi-architecture supportMulti-architecture support
precedence, when using preprocessorMacros with values
predefined macrosDefining macros
preprocessed files, keepingPreprocessing source files
preprocessing source files, -E optionPreprocessing source files
preprocessor macros, default value ofMacros with values
preprocessor, cppHow the compiler works
preprocessor, error messagesPreprocessor error messages
preprocessor, first stage of compilationThe preprocessor
preprocessor, usingUsing the preprocessor
print debugger commandExamining core files
printf, example of error in formatFinding errors in a simple program
printf, incorrect usage warningWarning options in -Wall
process id, findingStopping a program in an infinite loop
profile file, setting environment variables inShared libraries and static libraries
profiling, with gprofUsing the profiler gprof
program crashes, saved in core fileExamining core files
prototypes, missingWarning options in -Wall
pthread option, on AIXPOWER/PowerPC options

Q
qualifiers, warning about overriding by castsAdditional warning options
quotes, for defining empty macroMacros with values

R
Read-only relocationsRead-only relocations
recompiling modified source filesRecompiling and relinking
recompiling modified source filesRecompiling and relinking
red-zone, on AMD64x86 64-bit processors
reference booksFurther reading
reference, undefined due to missing libraryLinking with external libraries
relinking updated object filesRecompiling and relinking
relinking updated object filesRecompiling and relinking
return discards qualifiersCompiler error messages
return type, invalidWarning options in -Wall
Richard Stallman, principal author of GCCA brief history of GCC
risks, examples ofProgramming in C and C++
risks, examples ofFinding errors in a simple program
rounding, floating-point arithmeticFloating-point issues
rpath option, set run-time shared library search pathShared libraries and static libraries
rules, in makefileA simple makefile
run-time, measuring with time commandOptimization examples
running an executable file, CCompiling a simple C program
running an executable file, C++Compiling a simple C++ program
runtime error messagesRuntime error messages

S
S option, create assembly codeThe compiler
s, assembly file extensionThe compiler
save-temps option, keeps intermediate filesPreprocessing source files
scanf, incorrect usage warningWarning options in -Wall
scanf, incorrect usage warningRuntime error messages
scheduling, stage of optimizationScheduling
Scheme, compared with C/C++Programming in C and C++
search pathsSetting search paths
search paths, exampleSearch path example
search paths, extendedExtended search paths
security enhancement optionsSecurity enhancement options
segmentation faultExamining core files
segmentation faultRuntime error messages
selecting specific language standards, with -stdSelecting specific standards
separator, in makefilesA simple makefile
set, command in gdbModifying variables
shadowing of variablesAdditional warning options
shared librariesShared libraries and static libraries
shared libraries, advantages ofShared libraries and static libraries
shared libraries, dependenciesFinding dynamically linked libraries
shared libraries, error while loadingShared libraries and static libraries
shared libraries, examining with lddFinding dynamically linked libraries
shared libraries, setting load pathShared libraries and static libraries
shared object file, .so extensionShared libraries and static libraries
shell promptConventions used in this manual
shell quotingMacros with values
shell quotingFurther reading
shell variablesConventions used in this manual
shell variablesEnvironment variables
shell variablesShared libraries and static libraries
shell variables, setting permanentlyShared libraries and static libraries
SIGINT signalStopping a program in an infinite loop
signed bitfield optionPortability of signed and unsigned types
signed char optionPortability of signed and unsigned types
signed integer, castingAdditional warning options
signed variable converted to unsigned, warning ofAdditional warning options
SIGQUIT signalStopping a program in an infinite loop
simple C program, compilingCompiling a simple C program
simple C++ program, compilingCompiling a simple C++ program
size, optimization for, -OsOptimization levels
Smalltalk, compared with C/C++Programming in C and C++
so, shared object file extensionShared libraries and static libraries
soft underflow, on DEC AlphaDEC Alpha options
source codeCompiling a C program
source files, recompilingRecompiling and relinking
source-level optimizationSource-level optimization
space vs speed, tradeoff in optimizationSpeed-space tradeoffs
SPARC, platform-specific optionsSPARC options
Sparc64, multi-architecture supportMulti-architecture support
specs directory, compiler configuration filesVersion numbers
speed-space tradeoffs, in optimizationSpeed-space tradeoffs
sqrt, example of linking withLinking with external libraries
SSE extensionsx86 extensions
SSE/SSE2 precisionFloating-point issues
SSP, stack smashing protectorStack smashing protector (SSP)
stack backtrace, displayingDisplaying a backtrace
stack smashing protectorStack smashing protector (SSP)
stages of compilation, used internallyHow the compiler works
standard library, CLinking with external libraries
standard library, C++Using the C++ standard library
Standard Template Library (STL)Using C++ standard library templates
standards, C, C++ and IEEE arithmeticFurther reading
static librariesShared libraries and static libraries
static linking, forcing with -staticShared libraries and static libraries
static option, force static linkingShared libraries and static libraries
std namespace in C++Using the C++ standard library
std option, select specific language standardC language standards
std option, select specific language standardSelecting specific standards
step, command in gdbStepping through the program
stopping execution, with breakpoints in gdbSetting a breakpoint
strict ANSI/ISO C, -pedantic optionStrict ANSI/ISO
strip commandIdentifying files
subexpression elimination, optimizationSource-level optimization
suggest parentheses around assignment used as truth valueCompiler error messages
Sun SPARC, platform-specific optionsSPARC options
support, commercialGetting help
SVID extensions, GNU C LibraryANSI/ISO
symbol tableCompiling for debugging
symbol table, examining with nmExamining the symbol table
syntax errorCompiler error messages
system librariesLinking with external libraries
system libraries, location ofLinking with external libraries
system libraries, location ofSetting search paths
system libraries, location ofMulti-architecture support
system-specific predefined macrosDefining macros
SYSV, System V executable formatIdentifying files

T
t option, archive table of contentsCreating a library with the GNU archiver
tab, in makefilesA simple makefile
table of contents, in ar archiveCreating a library with the GNU archiver
table of contents, overflow error on AIXPOWER/PowerPC options
target, in makefileA simple makefile
tcsh, limit commandExamining core files
templates, explicit instantiationExplicit template instantiation
templates, export keywordThe export keyword
templates, in C++Templates
templates, inclusion compilation modelProviding your own templates
temporary files, keepingPreprocessing source files
temporary files, written to /tmpLinking with external libraries
termination, abnormal (core dumped)Examining core files
threads, on AIXPOWER/PowerPC options
Thumb, alternative code format on ARMMulti-architecture support
time command, measuring run-timeOptimization examples
TOC overflow error, on AIXPOWER/PowerPC options
tools, compiler-relatedCompiler-related tools
tradeoffs, between speed and space in optimizationSpeed-space tradeoffs
Traditional C (K&R), warnings of different behaviorAdditional warning options
translators, from C++ to C, compared with g++Compiling a C++ program
troubleshooting optionsTroubleshooting
tune machine-specific optionIntel and AMD x86 options
type conversions, warning ofAdditional warning options
typeof, GNU C extension keywordANSI/ISO

U
ulimit commandExamining core files
ulimit commandPreventing excessive memory usage
UltraSPARC, 32-bit mode vs 64-bit mode,SPARC options
uncontrolled format stringWarning for format string
undeclared identifier error for C library, when using -ansi optionANSI/ISO
undeclared variableCompiler error messages
undefined macro, compared with empty macroMacros with values
undefined reference errorLinking with external libraries
undefined reference errorLink order of libraries
undefined reference errorLinker error messages
undefined reference error for __gxx_personality_v0Compiling a simple C++ program
undefined reference to ’main’Linker error messages
undefined reference to C++ function, due to linking with gccCompiling a simple C++ program
underflow, floating-point arithmeticFloating-point issues
underflow, on DEC AlphaDEC Alpha options
uninitialized pointerRuntime error messages
uninitialized variable, warning ofOptimization and compiler warnings
unix, GNU C extension keywordANSI/ISO
unknown escape sequenceCompiler error messages
unoptimized code (-O0)Optimization levels
unrolling, of loops (optimization)Speed-space tradeoffs
unrolling, of loops (optimization)Optimization levels
unsigned bitfield optionPortability of signed and unsigned types
unsigned char optionPortability of signed and unsigned types
unsigned integer, castingAdditional warning options
unsigned variable converted to signed, warning ofAdditional warning options
unterminated string or character constantCompiler error messages
unused parameter warningCompiler error messages
unused variable warningWarning options in -Wall
unused variable warningCompiler error messages
updated object files, relinkingRecompiling and relinking
updated source files, recompilingRecompiling and relinking
Using GCC (Reference Manual)Further reading

V
v option, verbose compilationHelp for command-line options
value, of macroMacros with values
variable shadowingAdditional warning options
variable-size arraysStrict ANSI/ISO
variable, warning of uninitialized useOptimization and compiler warnings
variables, in makeA simple makefile
vax, GNU C extension keywordANSI/ISO
verbose compilation, -v optionVerbose compilation
verbose help optionHelp for command-line options
version number of GCC, displayingVersion numbers
virtual memory usage, limitingPreventing excessive memory usage
void return, incorrect use ofWarning options in -Wall

W
W option, enable additional warningsAdditional warning options
Wall option, enable common warningsCompiling a simple C program
warning for format stringWarning for format string
warning option, -W additional warningsAdditional warning options
warning options, -WallCompiling a simple C program
warning options, additionalAdditional warning options
warning options, in detailWarning options in -Wall
warning, format with different type argFinding errors in a simple program
warnings, additional with -WAdditional warning options
warnings, and optimizationOptimization and compiler warnings
warnings, promoting to errorsAdditional warning options
Wcast-qual option, warn about casts removing qualifiersAdditional warning options
Wcomment option, warn about nested commentsWarning options in -Wall
Wconversion option, warn about type conversionsAdditional warning options
Weffc++ optionC++ compilation options
Werror option, convert warnings to errorsAdditional warning options
Wimplicit option, warn about missing declarationsWarning options in -Wall
Wold-style-cast optionC++ compilation options
word-ordering, endiannessIdentifying files
word-size, determined from executable fileIdentifying files
word-size, on UltraSPARCSPARC options
Wreturn-type option, warn about incorrect return typesWarning options in -Wall
writable string constants, disablingAdditional warning options
Wshadow option, warn about shadowed variablesAdditional warning options
Wtraditional option, warn about traditional CAdditional warning options
Wuninitialized option, warn about uninitialized variablesOptimization and compiler warnings
Wunused option, unused variable warningWarning options in -Wall
Wwrite-strings option, warning for modified string constantsAdditional warning options

X
x86, floating-point arithmeticFloating-point issues
x86, platform-specific optionsIntel and AMD x86 options
XL compilers, compatibility on AIXPOWER/PowerPC options
XOPEN extensions, GNU C LibraryANSI/ISO

Z
zero, division byDEC Alpha options
zero, from underflow on DEC AlphaDEC Alpha options