Previous: , Up: Top   [Contents][Index]


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 Entry  Section

#
#define, preprocessor directive: Defining macros
#elif, preprocessor directive: Preprocessor error messages
#else, preprocessor directive: Preprocessor error messages
#if, preprocessor directive: Warning options in -Wall
#ifdef, preprocessor directive: Defining macros
#include, preprocessor directive: Compiling multiple source files
#warning, preprocessor directive: Preprocessor error messages

$
$, shell prompt: Conventions used in this manual

-
--help option, display command-line options: Help for command-line options
--param=ssp-buffer-size=4 option: Stack smashing protector (SSP)
--version option, display version number: Version numbers
-ansi option, disable language extensions: C language standards
-ansi option, used with g++: Compiling a simple C++ program
-c option, compile to object file: Creating object files from source files
-D option, define macro: Defining macros
-dM option, list predefined macros: Defining macros
-D_FORTIFY_SOURCE option: Buffer overflow protection
-E option, preprocess source files: Preprocessing source files
-fno-default-inline option: C++ compilation options
-fno-implicit-templates option, disable implicit instantiation: Explicit template instantiation
-fprofile-arcs option, instrument branches: Coverage testing with gcov
-fsigned-bitfields option: Portability of signed and unsigned types
-fsigned-char option: Portability of signed and unsigned types
-fstack-protector option: Stack smashing protector (SSP)
-ftest-coverage option, record coverage: Coverage testing with gcov
-funroll-loops option, optimization by loop unrolling: Optimization levels
-funsigned-bitfields option: Portability of signed and unsigned types
-funsigned-char option: Portability of signed and unsigned types
-g option, enable debugging: Compiling for debugging
-I option, include path: Setting search paths
-L option, library search path: Setting search paths
-l option, linking with libraries: Linking with external libraries
-lm option, link with math library: Linking with external libraries
-m option, platform-specific settings: Platform-specific options
-m32 and -m64 options, compile for 32 or 64-bit environment: SPARC options
-maltivec option, enables use of Altivec processor on PowerPC: POWER/PowerPC options
-march option, compile for specific CPU: Intel and AMD x86 options
-mcmodel option, for AMD64: x86 64-bit processors
-mcpu option, compile for specific CPU: SPARC options
-mfpmath option, for floating-point arithmetic: x86 extensions
-mieee option, floating-point support on DEC Alpha: DEC Alpha options
-mminimal-toc option, on AIX: POWER/PowerPC options
-mno-fused-madd option, on PowerPC: POWER/PowerPC options
-msse and related options: x86 extensions
-mtune option: Intel and AMD x86 options
-mxl-call option, compatibility with IBM XL compilers on AIX: POWER/PowerPC options
-o option, set output filename: Compiling a simple C program
-O0 option, optimization level zero: Optimization levels
-O1 option, optimization level one: Optimization levels
-O1 option, optimization level one: Buffer overflow protection
-O2 option, optimization level two: Optimization levels
-O2 option, optimization level two: Buffer overflow protection
-O3 option, optimization level three: Optimization levels
-Os option, optimization for size: Optimization levels
-pedantic option, conform to the ANSI standard (with -ansi): C language standards
-pg option, enable profiling: Using the profiler gprof
-pthread option, on AIX: POWER/PowerPC options
-rpath option, set run-time shared library search path: Shared libraries and static libraries
-S option, create assembly code: The compiler
-save-temps option, keeps intermediate files: Preprocessing source files
-static option, force static linking: Shared libraries and static libraries
-std option, select specific language standard: C language standards
-std option, select specific language standard: Selecting specific standards
-v option, verbose compilation: Help for command-line options
-W option, enable additional warnings: Additional warning options
-Wall option, enable common warnings: Compiling a simple C program
-Wcast-qual option, warn about casts removing qualifiers: Additional warning options
-Wcomment option, warn about nested comments: Warning options in -Wall
-Wconversion option, warn about type conversions: Additional warning options
-Weffc++ option: C++ compilation options
-Werror option, convert warnings to errors: Additional warning options
-Wformat option, warn about incorrect format strings: Warning options in -Wall
-Wformat option, warn about incorrect format strings: Warning for format string
-Wformat-security option, warn about uncontrolled format string: Warning for format string
-Wimplicit option, warn about missing declarations: Warning options in -Wall
-Wl,z,now option: Binding policy NOW
-Wl,z,relro option: Read-only relocations
-Wl,z,relro option: Binding policy NOW
-Wold-style-cast option: C++ compilation options
-Wreturn-type option, warn about incorrect return types: Warning options in -Wall
-Wshadow option, warn about shadowed variables: Additional warning options
-Wtraditional option, warn about traditional C: Additional warning options
-Wuninitialized option, warn about uninitialized variables: Optimization and compiler warnings
-Wunused option, unused variable warning: Warning options in -Wall
-Wwrite-strings option, warning for modified string constants: Additional warning options

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

/
/tmp directory, temporary files: Linking with external libraries

6
64-bit platforms, additional library directories: Setting search paths
64-bit processor-specific options, AMD64 and Intel: x86 64-bit processors

_
_FORTIFY_SOURCE macro: Buffer overflow protection
_GNU_SOURCE macro, enables extensions to GNU C Library: ANSI/ISO
__gxx_personality_v0, undefined reference error: Compiling a simple C++ program

A
a, archive file extension: Linking with external libraries
a.out, default executable filename: Compiling a simple C program
ADA, gnat compiler: A brief history of GCC
additional warning options: Additional warning options
AIX, compatibility with IBM XL compilers: POWER/PowerPC options
AIX, platform-specific options: POWER/PowerPC options
AIX, TOC overflow error: POWER/PowerPC options
Alpha, platform-specific options: DEC Alpha options
Altivec, on PowerPC: POWER/PowerPC options
AMD x86, platform-specific options: Intel and AMD x86 options
AMD64, 64-bit processor specific options: x86 64-bit processors
ansi option, disable language extensions: C language standards
ansi option, used with g++: Compiling a simple C++ program
ANSI standards for C/C++ languages, available as books: Further reading
ANSI/ISO C, compared with GNU C extensions: C language standards
ANSI/ISO C, controlled with -ansi option: ANSI/ISO
ANSI/ISO C, pedantic diagnostics option: Strict ANSI/ISO
antiquated header in C++: Preprocessor error messages
ar, GNU archiver: Linking with external libraries
ar, GNU archiver: Creating a library with the GNU archiver
archive file, .a extension: Linking with external libraries
archive file, explanation of: Linking with external libraries
archiver, ar: How the compiler works
arithmetic, floating-point: Floating-point issues
ARM, multi-architecture support: Multi-architecture support
arrays, variable-size: Strict ANSI/ISO
asm extension keyword: ANSI/ISO
asm extension keyword: Floating-point issues
assembler, as: How the compiler works
assembler, converting assembly language to machine code: The assembler
assignment discards qualifiers: Compiler error messages
assignment of read-only location: Compiler error messages
Athlon, platform-specific options: Intel and AMD x86 options
attach, debug running program: Stopping a program in an infinite loop

B
backtrace, debugger command: Displaying a backtrace
backtrace, displaying: Displaying a backtrace
bash profile file: Examining core files
bash profile file, login settings: Environment variables
bash profile file, login settings: Shared libraries and static libraries
benchmarking, with time command: Optimization examples
big-endian, word-ordering: Identifying files
binary file, also called executable file: Compiling a C program
Binding policy NOW: Binding policy NOW
Binutils, GNU Binary Tools: Examining the symbol table
bitfields, portability of signed vs unsigned: Portability of signed and unsigned types
bits, 32 vs 64 on UltraSPARC: SPARC options
books, further reading: Further reading
branches, instrumenting for coverage testing: Coverage testing with gcov
break, command in gdb: Setting a breakpoint
breakpoints, defined: Setting a breakpoint
BSD extensions, GNU C Library: ANSI/ISO
buffer overflow protection: Buffer overflow protection
buffer, template example: Providing your own templates
bug, example of: Finding errors in a simple program
bug, example of: Using library header files
bug, example of: Examining core files
bus error: Runtime error messages

C
C include path: Environment variables
C language, dialects of: C language standards
C language, further reading: Further reading
C library, standard: Linking with external libraries
C library, standard: Further reading
C math library: Linking with external libraries
c option, compile to object file: Creating object files from source files
C programs, recompiling after modification: Recompiling and relinking
C source file, .c extension: Compiling a simple C program
C standard library: Linking with external libraries
C++ include path: Environment variables
C++, compiling a simple program with g++: Compiling a simple C++ program
C++, creating libraries with explicit instantiation: Explicit template instantiation
C++, file extensions: Compiling a simple C++ program
C++, g++ as a true compiler: Compiling a C++ program
C++, g++ compiler: A brief history of GCC
C++, instantiation of templates: Providing your own templates
C++, namespace std: Using the C++ standard library
C++, standard library: Using the C++ standard library
C++, standard library: Using C++ standard library templates
C++, standard library templates: Using C++ standard library templates
C++, templates: Templates
c, C source file extension: Compiling a simple C program
C, compiling with gcc: Compiling a simple C program
C, gcc compiler: A brief history of GCC
C/C++ languages, standards in printed form: Further reading
C/C++, risks of using: Programming in C and C++
C/C++, risks of using: Finding errors in a simple program
C/C++, risks of using: Using library header files
C/C++, risks of using: Optimization and compiler warnings
c89/c99, selected with -std: Selecting specific standards
cannot find library error: Setting search paths
cannot find library error: Search path example
cannot open shared object file: Shared libraries and static libraries
cannot open shared object file: Runtime error messages
cast discards qualifiers from pointer target type: Compiler error messages
casts, used to avoid conversion warnings: Additional warning options
cc, C++ file extension: Compiling a simple C++ program
CC, make variable: A simple makefile
CFLAGS, make variable: A simple makefile
char, portability of signed vs unsigned: Portability of signed and unsigned types
character constant too long: Compiler error messages
character constant too long: Compiler error messages
circular buffer, template example: Providing your own templates
COFF format: Identifying files
Collatz sequence: Using the profiler gprof
collect2: ld returned 1 exit status: Linker error messages
combined multiply and add instruction: POWER/PowerPC options
command, in makefile: A simple makefile
command-line help option: Troubleshooting
comment warning option, warn about nested comments: Warning options in -Wall
comments, nested: Warning options in -Wall
commercial support: Getting help
common error messages: Common error messages
common errors, not included with -Wall: Additional warning options
common subexpression elimination, optimization: Source-level optimization
comparison of expression always true/false warning: Additional warning options
compilation, for debugging: Compiling for debugging
compilation, internal stages of: How the compiler works
compilation, model for templates: Providing your own templates
compilation, options: Compilation options
compilation, stopping on warning: Additional warning options
compile to object file, -c option: Creating object files from source files
compiled files, examining: Examining compiled files
compiler, converting source code to assembly code: The compiler
compiler, error messages: Compiler error messages
compiler, how it works internally: How the compiler works
compiler-related tools: Compiler-related tools
compiling C programs with gcc: Compiling a C program
compiling C++ programs with g++: Compiling a simple C++ program
compiling files independently: Compiling files independently
compiling multiple files: Compiling multiple source files
compiling with optimization: Compiling with optimization
configuration files for GCC: Version numbers
const, warning about overriding by casts: Additional warning options
constant strings, compile-time warnings: Additional warning options
continue, command in gdb: Continuing execution
control reaches end of non-void function: Compiler error messages
control-C, interrupt: Stopping a program in an infinite loop
conventions, used in manual: Conventions used in this manual
conversions between types, warning of: Additional warning options
core file, examining: Examining core files
core file, examining: Examining core files
core file, not produced: Examining core files
coverage testing, with gcov: Coverage testing with gcov
CPLUS_INCLUDE_PATH: Environment variables
cpp, C preprocessor: Using the preprocessor
cpp, C++ file extension: Compiling a simple C++ program
CPPFLAGS, make variable: A simple makefile
cr option, create/replace archive files: Creating a library with the GNU archiver
crashes, saved in core file: Examining core files
creating executable files from object files: Creating executables from object files
creating object files from source files: Creating object files from source files
cxx, C++ file extension: Compiling a simple C++ program
CXX, make variable: A simple makefile
CXXFLAGS, make variable: A simple makefile
C_INCLUDE_PATH: Environment variables

D
D option, define macro: Defining macros
data-flow analysis: Optimization and compiler warnings
DBM file, created with gdbm: Search path example
debugging, compilation flags: Compiling for debugging
debugging, with gdb: Compiling for debugging
debugging, with optimization: Optimization and debugging
DEC Alpha, platform-specific options: DEC Alpha options
declaration, in header file: Compiling multiple source files
declaration, missing: Using library header files
default directories, linking and header files: Setting search paths
default executable filename, a.out: Compiling a simple C program
default value, of macro defined with -D: Macros with values
defining macros: Defining macros
denormalized numbers, on DEC Alpha: DEC Alpha options
dependencies, of shared libraries: Finding dynamically linked libraries
dependency, in makefile: A simple makefile
deployment, options for: Examining core files
deployment, options for: Optimization levels
deployment, options for: Optimization and debugging
deprecated header in C++: Preprocessor error messages
dereferencing pointer to incomplete type: Compiler error messages
dereferencing, null pointer: Examining core files
dialects of C language: C language standards
different type arg, format warning: Finding errors in a simple program
disk space, reduced usage by shared libraries: Shared libraries and static libraries
displaying a backtrace: Displaying a backtrace
division by zero: DEC Alpha options
DLL (dynamically linked library), see shared libraries: Shared libraries and static libraries
dM option, list predefined macros: Defining macros
dollar sign $, shell prompt: Conventions used in this manual
double precision: Floating-point issues
dynamic loader: Shared libraries and static libraries
dynamically linked libraries, examining with ldd: Finding dynamically linked libraries
dynamically linked library, see shared libraries: Shared libraries and static libraries

E
E option, preprocess source files: Preprocessing source files
effc++ warning option: C++ compilation options
EGCS (Experimental GNU Compiler Suite): A brief history of GCC
ELF format: Identifying files
elimination, of common subexpressions: Source-level optimization
Emacs, gdb mode: More information about GDB
embedded systems, cross-compilation for: Major features of GCC
empty macro, compared with undefined macro: Macros with values
empty return, incorrect use of: Warning options in -Wall
enable profiling, -pg option: Using the profiler gprof
endianness, word-ordering: Identifying files
enhancements, to GCC: Getting help
environment variables: Conventions used in this manual
environment variables: Shared libraries and static libraries
environment variables, extending an existing path: Shared libraries and static libraries
environment variables, for default search paths: Environment variables
environment variables, setting permanently: Shared libraries and static libraries
error messages, common examples: Common error messages
error while loading shared libraries: Shared libraries and static libraries
error while loading shared libraries: Runtime error messages
error, undefined reference due to library link order: Link order of libraries
examining compiled files: Examining compiled files
examining core files: Examining core files
examples, conventions used in: Conventions used in this manual
exception handling, floating-point: Floating-point issues
executable file: Compiling a C program
executable, creating from object files by linking: Creating executables from object files
executable, default filename a.out: Compiling a simple C program
executable, examining with file command: Identifying files
executable, running: Compiling a simple C program
executable, symbol table stored in: Compiling for debugging
exit code, displayed in gdb: Continuing execution
explicit instantiation of templates: Explicit template instantiation
export keyword, not supported in GCC: The export keyword
extended precision, x86 processors: Floating-point issues
extended search paths, for include and link directories: Extended search paths
extension, .a archive file: Linking with external libraries
extension, .c source file: Compiling a simple C program
extension, .C, C++ file: Compiling a simple C++ program
extension, .C, C++ file: Compiling a simple C++ program
extension, .cc, C++ file: Compiling a simple C++ program
extension, .cpp, C++ file: Compiling a simple C++ program
extension, .cxx, C++ file: Compiling a simple C++ program
extension, .h header file: Compiling multiple source files
extension, .i preprocessed file: The preprocessor
extension, .ii preprocessed file: The preprocessor
extension, .o object file: Compiling files independently
extension, .s assembly file: The compiler
extension, .so shared object file: Shared libraries and static libraries
external libraries, linking with: Linking with external libraries

F
feature test macros, GNU C Library: ANSI/ISO
features, of GCC: Major features of GCC
file command, for identifying files: Identifying files
file extension, .a archive file: Linking with external libraries
file extension, .c source file: Compiling a simple C program
file extension, .C, C++ file: Compiling a simple C++ program
file extension, .C, C++ file: Compiling a simple C++ program
file extension, .cc, C++ file: Compiling a simple C++ program
file extension, .cpp, C++ file: Compiling a simple C++ program
file extension, .cxx, C++ file: Compiling a simple C++ program
file extension, .h header file: Compiling multiple source files
file extension, .i preprocessed file: The preprocessor
file extension, .ii preprocessed file: The preprocessor
file extension, .o object file: Compiling files independently
file extension, .s assembly file: The compiler
file extension, .so shared object file: Shared libraries and static libraries
file format not recognized: Linker error messages
file includes at least one deprecated or antiquated header: Preprocessor error messages
file not recognized: Linker error messages
finish, command in gdb: Continuing execution
fldcw set floating point mode: Floating-point issues
floating point arithmetic, with SSE extensions: x86 extensions
floating point exception: Runtime error messages
floating point exception handling: Floating-point issues
floating point exception, on DEC Alpha: DEC Alpha options
floating point, portability problems: Floating-point issues
fno-default-inline option: C++ compilation options
fno-implicit-templates option, disable implicit instantiation: Explicit template instantiation
format strings, incorrect usage warning: Warning options in -Wall
format, different type arg warning: Finding errors in a simple program
Fortran, g77 compiler: A brief history of GCC
fpmath option, for floating-point arithmetic: x86 extensions
fprofile-arcs option, instrument branches: Coverage testing with gcov
Free Software Foundation (FSF): A brief history of GCC
FreeBSD, floating-point arithmetic: Floating-point issues
ftest-coverage option, record coverage: Coverage testing with gcov
function inlining, example of optimization: Source-level optimization
function-call overhead: Source-level optimization
funroll-loops option, optimization by loop unrolling: Optimization levels
fused multiply and add instruction: POWER/PowerPC options

G
g option, enable debugging: Compiling for debugging
g++, compiling C++ programs: Compiling a simple C++ program
g++, GNU C++ Compiler: A brief history of GCC
g77, Fortran compiler: A brief history of GCC
gcc, GNU C Compiler: A brief history of GCC
gcc, simple example: Compiling a simple C program
gcc, used inconsistently with g++: Compiling a simple C++ program
gcj, GNU Compiler for Java: A brief history of GCC
gcov, GNU coverage testing tool: Coverage testing with gcov
gdb: Compiling for debugging
gdb, debugging core file with: Examining core files
gdb, Emacs mode: More information about GDB
gdb, graphical interface: More information about GDB
gdbm, GNU DBM library: Search path example
generic programming, in C++: Templates
getting help: Getting help
gmon.out, data file for gprof: Using the profiler gprof
gnat, GNU ADA compiler: A brief history of GCC
GNU archiver, ar: Linking with external libraries
GNU C extensions, compared with ANSI/ISO C: C language standards
GNU C Library Reference Manual: Further reading
GNU C Library, feature test macros: ANSI/ISO
GNU Compilers, major features: Major features of GCC
GNU Compilers, Reference Manual: Further reading
GNU debugger, gdb: Compiling for debugging
GNU GDB Manual: Further reading
GNU Make: A simple makefile
GNU Make Manual: Further reading
GNU Press, manuals: Further reading
GNU Project, history of: A brief history of GCC
GNU/Linux, floating-point arithmetic: Floating-point issues
gnu89/gnu99, selected with -std: Selecting specific standards
GNU_SOURCE macro (_GNU_SOURCE), enables extensions to GNU C Library: ANSI/ISO
gprof, GNU Profiler: Using the profiler gprof
gradual underflow, on DEC Alpha: DEC Alpha options
gxx_personality_v0, undefined reference error: Compiling a simple C++ program

H
h, header file extension: Compiling multiple source files
header file, .h extension: Compiling multiple source files
header file, declarations in: Compiling multiple source files
header file, default directories: Setting search paths
header file, include path—extending with -I: Setting search paths
header file, missing: Using library header files
header file, missing header causes implicit declaration: Using library header files
header file, not compiled: Creating object files from source files
header file, not found: Setting search paths
header file, with include guards: Providing your own templates
header file, without .h extension for C++: Using the C++ standard library
Hello World program, in C: Compiling a simple C program
Hello World program, in C++: Compiling a simple C++ program
help options: Troubleshooting
history, of GCC: A brief history of GCC

I
I option, include path: Setting search paths
i, preprocessed file extension for C: The preprocessor
IBM XL compilers, compatibility on AIX: POWER/PowerPC options
identifying files, with file command: Identifying files
IEEE arithmetic: Floating-point issues
IEEE arithmetic standard, printed form: Further reading
IEEE options, on DEC Alpha: DEC Alpha options
IEEE-754 standard: Further reading
ii, preprocessed file extension for C++: The preprocessor
illegal instruction error: x86 extensions
illegal instruction error: Runtime error messages
implicit declaration of function: Using library header files
implicit declaration of function: Warning options in -Wall
implicit declaration of function: Compiler error messages
implicit rules, in makefile: A simple makefile
include guards, in header file: Providing your own templates
include nested too deeply: Preprocessor error messages
include path, extending with -I: Setting search paths
include path, setting with environment variables: Environment variables
inclusion compilation model, in C++: Providing your own templates
independent compilation of files: Compiling files independently
Inf, infinity, on DEC Alpha: DEC Alpha options
infinite loop, stopping: Stopping a program in an infinite loop
initialization discards qualifiers: Compiler error messages
initialization makes integer from pointer without a cast: Compiler error messages
initializer element is not a constant: Compiler error messages
inlining, example of optimization: Source-level optimization
Insight, graphical interface for gdb: More information about GDB
instantiation, explicit vs implicit in C++: Explicit template instantiation
instantiation, of templates in C++: Providing your own templates
instruction scheduling, optimization: Scheduling
instrumented executable, for coverage testing: Coverage testing with gcov
instrumented executable, for profiling: Using the profiler gprof
Intel x86, platform-specific options: Intel and AMD x86 options
intermediate files, keeping: Preprocessing source files
invalid preprocessing directive: Preprocessor error messages
ISO C++, controlled with -ansi option: Compiling a simple C++ program
ISO C, compared with GNU C extensions: C language standards
ISO C, controlled with -ansi option: ANSI/ISO
ISO standards for C/C++ languages, available as books: Further reading
iso9899:1990/iso9899:1999, selected with -std: Selecting specific standards
Itanium, multi-architecture support: Multi-architecture support

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

K
K&R dialect of C, warnings of different behavior: Additional warning options
kernel mode, on AMD64: x86 64-bit processors
Kernighan and Ritchie, The C Programming Language: Further reading
key-value pairs, stored with GDBM: Search path example
keywords, additional in GNU C: ANSI/ISO

L
L option, library search path: Setting search paths
l option, linking with libraries: Linking with external libraries
language standards, selecting with -std: Selecting specific standards
ld returned 1 exit status: Linker error messages
ld.so.conf, loader configuration file: Shared libraries and static libraries
ld: cannot find library error: Setting search paths
ldd, dynamical loader: Finding dynamically linked libraries
LD_LIBRARY_PATH, shared library load path: Shared libraries and static libraries
levels of optimization: Optimization levels
libraries, creating with ar: Creating a library with the GNU archiver
libraries, creating with explicit instantiation in C++: Explicit template instantiation
libraries, error while loading shared library: Shared libraries and static libraries
libraries, extending search path with -L: Setting search paths
libraries, finding shared library dependencies: Finding dynamically linked libraries
libraries, link error due to undefined reference: Linking with external libraries
libraries, link order: Link order of libraries
libraries, link order: Link order of libraries
libraries, linking with: Linking with external libraries
libraries, linking with: Linking with external libraries
libraries, on 64-bit platforms: Setting search paths
libraries, stored in archive files: Linking with external libraries
library header files, using: Using library header files
library, C math library: Linking with external libraries
library, C standard library: Linking with external libraries
library, C++ standard library: Using the C++ standard library
libstdc++, C++ standard library: Using C++ standard library templates
line numbers, recorded in preprocessed files: Preprocessing source files
link error, cannot find library: Setting search paths
link order, from left to right: Link order of libraries
link order, of libraries: Link order of libraries
link path, setting with environment variable: Environment variables
linker, error messages: Linker error messages
linker, GNU compared with other linkers: Providing your own templates
linker, initial description: Creating executables from object files
linker, ld: How the compiler works
linker, ld: The linker
linking, creating executable files from object files: Creating executables from object files
linking, default directories: Setting search paths
linking, dynamic (shared libraries): Shared libraries and static libraries
linking, explanation of: Compiling files independently
linking, undefined reference error due to library link order: Link order of libraries
linking, updated object files: Recompiling and relinking
linking, with external libraries: Linking with external libraries
linking, with library using -l: Linking with external libraries
linkr error, cannot find library: Setting search paths
Linux kernel, floating-point: Floating-point issues
Lisp, compared with C/C++: Programming in C and C++
little-endian, word-ordering: Identifying files
loader configuration file, ld.so.conf: Shared libraries and static libraries
loader function: Shared libraries and static libraries
login file, setting environment variables in: Shared libraries and static libraries
long double arithmetic: Floating-point issues
loop unrolling, optimization: Speed-space tradeoffs
loop unrolling, optimization: Optimization levels
LSB, least significant byte: Identifying files

M
m option, platform-specific settings: Platform-specific options
m32 and m64 options, compile for 32 or 64-bit environment: SPARC options
machine code: Compiling a C program
machine instruction, asm keyword: Floating-point issues
machine-specific options: Platform-specific options
macro or ’#include’ recursion too deep: Preprocessor error messages
macros, default value of: Macros with values
macros, defined with value: Macros with values
macros, defining in preprocessor: Defining macros
macros, predefined: Defining macros
major features, of GCC: Major features of GCC
major version number, of GCC: Version numbers
makefile, example of: A simple makefile
maltivec option, enables use of Altivec processor on PowerPC: POWER/PowerPC options
manuals, for GNU software: Further reading
march option, compile for specific CPU: Intel and AMD x86 options
math library: Linking with external libraries
math library, linking with -lm: Linking with external libraries
mcmodel option, for AMD64: x86 64-bit processors
mcpu option, compile for specific CPU: SPARC options
memory usage, limiting: Preventing excessive memory usage
mfpmath option, for floating-point arithmetic: x86 extensions
mieee option, floating-point support on DEC Alpha: DEC Alpha options
minor version number, of GCC: Version numbers
MIPS64, multi-architecture support: Multi-architecture support
missing header file, causes implicit declaration: Using library header files
missing header files: Using library header files
missing prototypes warning: Warning options in -Wall
mminimal-toc option, on AIX: POWER/PowerPC options
MMX extensions: x86 extensions
mno-fused-madd option, on PowerPC: POWER/PowerPC options
modified source files, recompiling: Recompiling and relinking
modified source files, recompiling: Recompiling and relinking
Motorola 680x0, floating-point arithmetic: Floating-point issues
Motorola 680x0, word-order: Identifying files
MSB, most significant byte: Identifying files
msse and related options: x86 extensions
mtune option: Intel and AMD x86 options
multi-architecture support, Debian: Multi-architecture support
multi-architecture support, discussion of: Multi-architecture support
multi-architecture support, older systems: Multi-architecture support
multi-architecture support, RedHat: Multi-architecture support
multi-architecture support, Ubuntu: Multi-architecture support
multiple directories, on include and link paths: Extended search paths
multiple files, compiling: Compiling multiple source files
multiple-character character constant: Compiler error messages
multiply and add instruction: POWER/PowerPC options
multiply-defined symbol error, with C++: Providing your own templates
mxl-call option, compatibility with IBM XL compilers on AIX: POWER/PowerPC options

N
namespace std in C++: Using the C++ standard library
namespace, reserved prefix for preprocessor: Defining macros
NaN, not a number, on DEC Alpha: DEC Alpha options
native double-precision processors: Floating-point issues
nested comments, warning of: Warning options in -Wall
NetBSD, floating-point arithmetic: Floating-point issues
next, command in gdb: Stepping through the program
nm command: Examining the symbol table
No such file or directory: Preprocessor error messages
No such file or directory: Runtime error messages
No such file or directory, header file not found: Setting search paths
No such file or directory, header file not found: Search path example
no-default-inline option: C++ compilation options
null pointer: Examining core files
null pointer: Runtime error messages
numerical differences: Floating-point issues

O
O option, optimization level: Optimization levels
o option, set output filename: Compiling a simple C program
o, object file extension: Compiling files independently
object file, .o extension: Compiling files independently
object file, creating from source using option -c: Creating object files from source files
object file, examining with file command: Identifying files
object file, explanation of: Compiling files independently
object files, linking to create executable file: Creating executables from object files
object files, relinking: Recompiling and relinking
object files, temporary: Linking with external libraries
Objective-C: A brief history of GCC
old-style C++ header files: Preprocessor error messages
old-style-cast warning option: C++ compilation options
OpenBSD, floating-point arithmetic: Floating-point issues
optimization for size, -Os: Optimization levels
optimization, and compiler warnings: Optimization and compiler warnings
optimization, common subexpression elimination: Source-level optimization
optimization, compiling with -O: Optimization levels
optimization, example of: Optimization examples
optimization, explanation of: Compiling with optimization
optimization, levels of: Optimization levels
optimization, loop unrolling: Speed-space tradeoffs
optimization, loop unrolling: Optimization levels
optimization, speed-space tradeoffs: Speed-space tradeoffs
optimization, with debugging: Optimization and debugging
options, compilation: Compilation options
options, platform-specific: Platform-specific options
options, security enhancement: Security enhancement options
ordering of libraries: Link order of libraries
output file option, -o: Compiling a simple C program
overflow error, for TOC on AIX: POWER/PowerPC options
overflow, floating-point arithmetic: Floating-point issues
overhead, from function call: Source-level optimization

P
parse error: Compiler error messages
parse error at end of input: Compiler error messages
parse error due to language extensions: ANSI/ISO
passing arg of function as another type to prototype: Compiler error messages
patch level, of GCC: Version numbers
paths, extending environment variable: Shared libraries and static libraries
paths, search: Setting search paths
pedantic option: C language standards
pedantic option: Strict ANSI/ISO
Pentium, platform-specific options: Intel and AMD x86 options
pg option, enable profiling: Using the profiler gprof
pipelining, explanation of: Scheduling
platform-specific options: Platform-specific options
POSIX extensions, GNU C Library: ANSI/ISO
PowerPC and POWER, platform-specific options: POWER/PowerPC options
PowerPC64, multi-architecture support: Multi-architecture support
precedence, when using preprocessor: Macros with values
predefined macros: Defining macros
preprocessed files, keeping: Preprocessing source files
preprocessing source files, -E option: Preprocessing source files
preprocessor macros, default value of: Macros with values
preprocessor, cpp: How the compiler works
preprocessor, error messages: Preprocessor error messages
preprocessor, first stage of compilation: The preprocessor
preprocessor, using: Using the preprocessor
print debugger command: Examining core files
printf, example of error in format: Finding errors in a simple program
printf, incorrect usage warning: Warning options in -Wall
process id, finding: Stopping a program in an infinite loop
profile file, setting environment variables in: Shared libraries and static libraries
profiling, with gprof: Using the profiler gprof
program crashes, saved in core file: Examining core files
prototypes, missing: Warning options in -Wall
pthread option, on AIX: POWER/PowerPC options

Q
qualifiers, warning about overriding by casts: Additional warning options
quotes, for defining empty macro: Macros with values

R
Read-only relocations: Read-only relocations
recompiling modified source files: Recompiling and relinking
recompiling modified source files: Recompiling and relinking
red-zone, on AMD64: x86 64-bit processors
reference books: Further reading
reference, undefined due to missing library: Linking with external libraries
relinking updated object files: Recompiling and relinking
relinking updated object files: Recompiling and relinking
return discards qualifiers: Compiler error messages
return type, invalid: Warning options in -Wall
Richard Stallman, principal author of GCC: A brief history of GCC
risks, examples of: Programming in C and C++
risks, examples of: Finding errors in a simple program
rounding, floating-point arithmetic: Floating-point issues
rpath option, set run-time shared library search path: Shared libraries and static libraries
rules, in makefile: A simple makefile
run-time, measuring with time command: Optimization examples
running an executable file, C: Compiling a simple C program
running an executable file, C++: Compiling a simple C++ program
runtime error messages: Runtime error messages

S
S option, create assembly code: The compiler
s, assembly file extension: The compiler
save-temps option, keeps intermediate files: Preprocessing source files
scanf, incorrect usage warning: Warning options in -Wall
scanf, incorrect usage warning: Runtime error messages
scheduling, stage of optimization: Scheduling
Scheme, compared with C/C++: Programming in C and C++
search paths: Setting search paths
search paths, example: Search path example
search paths, extended: Extended search paths
security enhancement options: Security enhancement options
segmentation fault: Examining core files
segmentation fault: Runtime error messages
selecting specific language standards, with -std: Selecting specific standards
separator, in makefiles: A simple makefile
set, command in gdb: Modifying variables
shadowing of variables: Additional warning options
shared libraries: Shared libraries and static libraries
shared libraries, advantages of: Shared libraries and static libraries
shared libraries, dependencies: Finding dynamically linked libraries
shared libraries, error while loading: Shared libraries and static libraries
shared libraries, examining with ldd: Finding dynamically linked libraries
shared libraries, setting load path: Shared libraries and static libraries
shared object file, .so extension: Shared libraries and static libraries
shell prompt: Conventions used in this manual
shell quoting: Macros with values
shell quoting: Further reading
shell variables: Conventions used in this manual
shell variables: Environment variables
shell variables: Shared libraries and static libraries
shell variables, setting permanently: Shared libraries and static libraries
SIGINT signal: Stopping a program in an infinite loop
signed bitfield option: Portability of signed and unsigned types
signed char option: Portability of signed and unsigned types
signed integer, casting: Additional warning options
signed variable converted to unsigned, warning of: Additional warning options
SIGQUIT signal: Stopping a program in an infinite loop
simple C program, compiling: Compiling a simple C program
simple C++ program, compiling: Compiling a simple C++ program
size, optimization for, -Os: Optimization levels
Smalltalk, compared with C/C++: Programming in C and C++
so, shared object file extension: Shared libraries and static libraries
soft underflow, on DEC Alpha: DEC Alpha options
source code: Compiling a C program
source files, recompiling: Recompiling and relinking
source-level optimization: Source-level optimization
space vs speed, tradeoff in optimization: Speed-space tradeoffs
SPARC, platform-specific options: SPARC options
Sparc64, multi-architecture support: Multi-architecture support
specs directory, compiler configuration files: Version numbers
speed-space tradeoffs, in optimization: Speed-space tradeoffs
sqrt, example of linking with: Linking with external libraries
SSE extensions: x86 extensions
SSE/SSE2 precision: Floating-point issues
SSP, stack smashing protector: Stack smashing protector (SSP)
stack backtrace, displaying: Displaying a backtrace
stack smashing protector: Stack smashing protector (SSP)
stages of compilation, used internally: How the compiler works
standard library, C: Linking 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 arithmetic: Further reading
static libraries: Shared libraries and static libraries
static linking, forcing with -static: Shared libraries and static libraries
static option, force static linking: Shared libraries and static libraries
std namespace in C++: Using the C++ standard library
std option, select specific language standard: C language standards
std option, select specific language standard: Selecting specific standards
step, command in gdb: Stepping through the program
stopping execution, with breakpoints in gdb: Setting a breakpoint
strict ANSI/ISO C, -pedantic option: Strict ANSI/ISO
strip command: Identifying files
subexpression elimination, optimization: Source-level optimization
suggest parentheses around assignment used as truth value: Compiler error messages
Sun SPARC, platform-specific options: SPARC options
support, commercial: Getting help
SVID extensions, GNU C Library: ANSI/ISO
symbol table: Compiling for debugging
symbol table, examining with nm: Examining the symbol table
syntax error: Compiler error messages
system libraries: Linking with external libraries
system libraries, location of: Linking with external libraries
system libraries, location of: Setting search paths
system libraries, location of: Multi-architecture support
system-specific predefined macros: Defining macros
SYSV, System V executable format: Identifying files

T
t option, archive table of contents: Creating a library with the GNU archiver
tab, in makefiles: A simple makefile
table of contents, in ar archive: Creating a library with the GNU archiver
table of contents, overflow error on AIX: POWER/PowerPC options
target, in makefile: A simple makefile
tcsh, limit command: Examining core files
templates, explicit instantiation: Explicit template instantiation
templates, export keyword: The export keyword
templates, in C++: Templates
templates, inclusion compilation model: Providing your own templates
temporary files, keeping: Preprocessing source files
temporary files, written to /tmp: Linking with external libraries
termination, abnormal (core dumped): Examining core files
threads, on AIX: POWER/PowerPC options
Thumb, alternative code format on ARM: Multi-architecture support
time command, measuring run-time: Optimization examples
TOC overflow error, on AIX: POWER/PowerPC options
tools, compiler-related: Compiler-related tools
tradeoffs, between speed and space in optimization: Speed-space tradeoffs
Traditional C (K&R), warnings of different behavior: Additional warning options
translators, from C++ to C, compared with g++: Compiling a C++ program
troubleshooting options: Troubleshooting
tune machine-specific option: Intel and AMD x86 options
type conversions, warning of: Additional warning options
typeof, GNU C extension keyword: ANSI/ISO

U
ulimit command: Examining core files
ulimit command: Preventing excessive memory usage
UltraSPARC, 32-bit mode vs 64-bit mode,: SPARC options
uncontrolled format string: Warning for format string
undeclared identifier error for C library, when using -ansi option: ANSI/ISO
undeclared variable: Compiler error messages
undefined macro, compared with empty macro: Macros with values
undefined reference error: Linking with external libraries
undefined reference error: Link order of libraries
undefined reference error: Linker error messages
undefined reference error for __gxx_personality_v0: Compiling a simple C++ program
undefined reference to ’main’: Linker error messages
undefined reference to C++ function, due to linking with gcc: Compiling a simple C++ program
underflow, floating-point arithmetic: Floating-point issues
underflow, on DEC Alpha: DEC Alpha options
uninitialized pointer: Runtime error messages
uninitialized variable, warning of: Optimization and compiler warnings
unix, GNU C extension keyword: ANSI/ISO
unknown escape sequence: Compiler error messages
unoptimized code (-O0): Optimization levels
unrolling, of loops (optimization): Speed-space tradeoffs
unrolling, of loops (optimization): Optimization levels
unsigned bitfield option: Portability of signed and unsigned types
unsigned char option: Portability of signed and unsigned types
unsigned integer, casting: Additional warning options
unsigned variable converted to signed, warning of: Additional warning options
unterminated string or character constant: Compiler error messages
unused parameter warning: Compiler error messages
unused variable warning: Warning options in -Wall
unused variable warning: Compiler error messages
updated object files, relinking: Recompiling and relinking
updated source files, recompiling: Recompiling and relinking
Using GCC (Reference Manual): Further reading

V
v option, verbose compilation: Help for command-line options
value, of macro: Macros with values
variable shadowing: Additional warning options
variable, warning of uninitialized use: Optimization and compiler warnings
variable-size arrays: Strict ANSI/ISO
variables, in make: A simple makefile
vax, GNU C extension keyword: ANSI/ISO
verbose compilation, -v option: Verbose compilation
verbose help option: Help for command-line options
version number of GCC, displaying: Version numbers
virtual memory usage, limiting: Preventing excessive memory usage
void return, incorrect use of: Warning options in -Wall

W
W option, enable additional warnings: Additional warning options
Wall option, enable common warnings: Compiling a simple C program
warning for format string: Warning for format string
warning option, -W additional warnings: Additional warning options
warning options, -Wall: Compiling a simple C program
warning options, additional: Additional warning options
warning options, in detail: Warning options in -Wall
warning, format with different type arg: Finding errors in a simple program
warnings, additional with -W: Additional warning options
warnings, and optimization: Optimization and compiler warnings
warnings, promoting to errors: Additional warning options
Wcast-qual option, warn about casts removing qualifiers: Additional warning options
Wcomment option, warn about nested comments: Warning options in -Wall
Wconversion option, warn about type conversions: Additional warning options
Weffc++ option: C++ compilation options
Werror option, convert warnings to errors: Additional warning options
Wimplicit option, warn about missing declarations: Warning options in -Wall
Wold-style-cast option: C++ compilation options
word-ordering, endianness: Identifying files
word-size, determined from executable file: Identifying files
word-size, on UltraSPARC: SPARC options
Wreturn-type option, warn about incorrect return types: Warning options in -Wall
writable string constants, disabling: Additional warning options
Wshadow option, warn about shadowed variables: Additional warning options
Wtraditional option, warn about traditional C: Additional warning options
Wuninitialized option, warn about uninitialized variables: Optimization and compiler warnings
Wunused option, unused variable warning: Warning options in -Wall
Wwrite-strings option, warning for modified string constants: Additional warning options

X
x86, floating-point arithmetic: Floating-point issues
x86, platform-specific options: Intel and AMD x86 options
XL compilers, compatibility on AIX: POWER/PowerPC options
XOPEN extensions, GNU C Library: ANSI/ISO

Z
zero, division by: DEC Alpha options
zero, from underflow on DEC Alpha: DEC Alpha options

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  

Previous: , Up: Top   [Contents][Index]