Go to the first, previous, next, last section, table of contents.

Index

!

`!' in constraint

#

`#' in constraint

#pragma implementation, implied

#pragma, reason for not using

$

$

%

`%' in constraint

&

`&' in constraint

'

'

+

`+' in constraint

-

-lgcc, use with -nodefaultlibs

-lgcc, use with -nostdlib

-nodefaultlibs and unresolved references

-nostdlib and unresolved references

/

0

`0' in constraint

<

`<' in constraint

=

`=' in constraint

>

`>' in constraint

?

`?' in constraint

?: extensions

_

`_' in variables in macros

__builtin_apply

__builtin_apply_args

__builtin_return

a

address constraints

address of a label

address_operand

alias attribute

aligned attribute

alloca and SunOs

alloca vs variable-length arrays

alloca, for SunOs

alloca, for Unos

alternate keywords

analysis, data flow

arguments in frame (88k)

arithmetic simplifications

arrays of length zero

arrays of variable length

arrays, non-lvalue

asm constraints

asm expressions

assembler instructions

assembler names for identifiers

assembler syntax, 88k

assembly code, invalid

attribute of types

attribute of variables

autoincrement/decrement addressing

autoincrement/decrement analysis

automatic inline for C++ member fns

b

backtrace for bug reports

Bison parser generator

bit shift overflow (88k)

bug report mailing lists

builtin functions

byte writes (29k)

c

C compilation options

C intermediate output, nonexistent

C language extensions

C language, traditional

C++ compilation options

C++ interface and implementation headers

C++ language extensions

C++ member fns, automatically inline

C++ misunderstandings

C++ named return value

C++ options, command line

C++ pragmas, effect on inlining

C++ source file suffixes

C++ static data, declaring and defining

C++ subtype polymorphism

C++ type abstraction

calling conventions for interrupts

case labels in initializers

case sensitivity and VMS

cast to a union

casts as lvalues

code generation conventions

command options

comments, C++ style

common subexpression elimination

compilation in a separate directory

compiler bugs, reporting

compiler compared to C++ preprocessor

compiler options, C++

compiler version, specifying

complex numbers

compound expressions as lvalues

conditional expressions as lvalues

conditional expressions, extensions

configurations supported by GNU CC

conflicting types

const applied to function

const function attribute

constant folding

constant propagation

constants in constraints

constraint modifier characters

constraint, matching

constraints, asm

constraints, machine specific

constructing calls

constructor expressions

constructor function attribute

constructors vs goto

constructors, automatic calls

CPLUS_INCLUDE_PATH

cross compiling

cross-compiler, installation

d

`d' in constraint

data flow analysis

deallocating variable length arrays

debugging information generation

debugging information options

debugging, 88k OCS

declaration scope

declarations inside expressions

declaring attributes of functions

declaring static data in C++

default implementation, signature member function

defining static data in C++

delayed branch scheduling

dependencies for make as output

dependencies, make

DEPENDENCIES_OUTPUT

destructor function attribute

destructors vs goto

detecting `-traditional'

dialect options

digits in constraint

directory options

divide instruction, 88k

dollar signs in identifier names

double-word arithmetic

downward funargs

e

`E' in constraint

enumeration clash warnings

environment variables

escape sequences, traditional

exclamation point

exit status and VMS

explicit register variables

expressions containing statements

expressions, compound, as lvalues

expressions, conditional, as lvalues

expressions, constructor

extensible constraints

extensions, ?:

extensions, C language

extensions, C++ language

external declaration scope

f

`F' in constraint

file name suffix

float as function value type

format function attribute

forwarding calls

fscanf, and constant strings

function attributes

function pointers, arithmetic

function prototype declarations

function, size of pointer to

functions in arbitrary sections

functions that are passed arguments in registers on the 386

functions that do not pop the argument stack on the 386

functions that do pop the argument stack on the 386

functions that have no side effects

functions that never return

functions that pop the argument stack on the 386

functions with printf or scanf style arguments

g

`g' in constraint

`G' in constraint

g++ older version

g++, separate compiler

gcc

GCC_EXEC_PREFIX

generalized lvalues

genflags, crash on Sun 4

global offset table

global register after longjmp

global register allocation

global register variables

GNU CC command options

goto with computed label

gp-relative references (MIPS)

grouping options

h

`H' in constraint

hardware models and configurations, specifying

header files and VMS

i

`I' in constraint

`i' in constraint

IBM RS/6000 and PowerPC Options

identifier names, dollar signs in

identifiers, names in assembler code

identifying source, compiler (88k)

implicit argument: return value

implied #pragma implementation

include files and VMS

incompatibilities of GNU CC

increment operators

initializations in expressions

initializers with labeled elements

initializers, non-constant

inline automatic for C++ member fns

inline functions

inline functions, omission of

inline, automatic

inlining and C++ pragmas

installation trouble

installing GNU CC

installing GNU CC on the Sun

installing GNU CC on VMS

instruction combination

instruction recognizer

instruction scheduling

integrating function code

Intel 386 Options

interface and implementation headers, C++

intermediate C version, nonexistent

interrupts, functions compiled for

invalid assembly code

j

jump optimization

k

kernel and user registers (29k)

keywords, alternate

known causes of trouble

l

labeled elements in initializers

labels as values

language dialect options

large bit shifts (88k)

length-zero arrays

load address instruction

local register allocation

local variables in macros

local variables, specifying registers

long long data types

longjmp and automatic variables

longjmp incompatibilities

longjmp warnings

loop optimization

lvalues, generalized

m

`m' in constraint

machine dependent options

machine specific constraints

macro with variable arguments

macros containing asm

macros, inline alternative

macros, local labels

macros, local variables in

macros, statements in expressions

macros, types of arguments

main and the exit status

matching constraint

maximum operator

member fns, automatically inline

memory model (29k)

memory references in constraints

messages, warning

messages, warning and error

middle-operands, omitted

minimum operator

misunderstandings in C++

mktemp, and constant strings

mode attribute

modifiers in constraints

multiple alternative constraints

multiprecision arithmetic

n

`n' in constraint

name augmentation

named return value in C++

names used in assembler code

naming convention, implementation headers

nested functions

newline vs string constants

no-op move instructions

nocommon attribute

non-constant initializers

non-static inline function

noreturn function attribute

o

`o' in constraint

OBJC_INCLUDE_PATH

offsettable address

old-style function definitions

omitted middle-operands

operand constraints, asm

optimize options

options to control warnings

options, code generation

options, debugging

options, dialect

options, directory search

options, GNU CC command

options, grouping

options, linking

options, optimization

options, preprocessor

order of evaluation, side effects

order of options

other directory, compilation in

output file option

overloaded virtual fn, warning

p

`p' in constraint

packed attribute

parameter forward declaration

parser generator, Bison

peephole optimization

pointer arguments

portions of temporary objects, pointers to

pragma, reason for not using

pragmas in C++, effect on inlining

pragmas, interface and implementation

preprocessing numbers

preprocessing tokens

preprocessor options

processor selection (29k)

promotion of formal parameters

push address instruction

q

`Q', in constraint

qsort, and global register variables

r

`r' in constraint

r0-relative references (88k)

ranges in case statements

read-only strings

register allocation

register allocation, stupid

register class preference pass

register positions in frame (88k)

register use analysis

register variable after longjmp

register-to-stack conversion

registers for local variables

registers in constraints

registers, global allocation

registers, global variables in

reordering, warning

rest argument (in macro)

return value of main

return value, named, in C++

return, in C++ function header

RS/6000 and PowerPC Options

run-time options

s

`s' in constraint

scanf, and constant strings

scheduling, delayed branch

scheduling, instruction

scope of a variable length array

scope of declaration

scope of external declarations

second include path

section function attribute

section variable attribute

separate directory, compilation in

sequential consistency on 88k

setjmp incompatibilities

shared VMS run time system

side effect in ?:

side effects, macro argument

side effects, order of evaluation

signature in C++, advantages

signature member function default implementation

signatures, C++

simple constraints

simplifications, arithmetic

smaller data references (88k)

smaller data references (MIPS)

specified registers

specifying compiler version and target machine

specifying hardware config

specifying machine version

specifying registers for local variables

sscanf, and constant strings

stack checks (29k)

statements inside expressions

static data in C++, declaring and defining

`stdarg.h' and RT PC

storem bug (29k)

strength-reduction

string constants

string constants vs newline

structure passing (88k)

structures, constructor expression

stupid register allocation

submodel options

subscripting and function values

subtype polymorphism, C++

suffixes for C++ source

Sun installation

suppressing warnings

surprises in C++

syntax checking

synthesized methods, warning

t

tail recursion optimization

target machine, specifying

target-parameter-dependent code

template debugging

template instantiation

temporaries, lifetime of

traditional C language

type abstraction, C++

type attributes

typedef names as function parameters

u

Ultrix calling convention

undefined behavior

undefined function value

underscores in variables in macros

underscores, avoiding (88k)

union, casting to a

unreachable code

unresolved references and -nodefaultlibs

unresolved references and -nostdlib

v

`V' in constraint

value after longjmp

`varargs.h' and RT PC

variable alignment

variable attributes

variable number of arguments

variable-length array scope

variable-length arrays

variables in specified registers

variables, local, in macros

Vax calling convention

VMS and case sensitivity

VMS and include files

VMS installation

void pointers, arithmetic

void, size of pointer to

volatile applied to function

w

warning for enumeration conversions

warning for overloaded virtual fn

warning for reordering of member initializers

warning for synthesized methods

warning messages

warnings vs errors

weak attribute

x

`X' in constraint

z

zero division on 88k

zero-length arrays

Go to the first, previous, next, last section, table of contents.