Contents|Index|Previous|Next
Options
for Code Generation Conventions
The following machine-independent
options control the interface conventions used in code generation. Most
of them have both positive and negative forms; the negative form of -ffoo
would be -fno-foo.
In the following options, only one of the forms is listed—the one which
is not the default. You can figure out the other form by either removing
‘no-’or
adding it.
-fpcc-struct-return
Return “short”
struct
and union
values in memory like longer ones, rather than in registers. This convention
is less efficient, although it has the advantage of allowing intercalls
between GNU CC-compiled files and files compiled with other compilers.
The precise convention for
returning structures in memory depends on the target configuration macros.
Short structures and unions
are those whose size and alignment match that of some integer type.
-freg-struct-return
Use the convention
that struct
and union
values are returned in registers when possible. This is more efficient
for small structures than ‘-fpcc-struct-return’.
If you specify neither ‘-fpcc-struct-return’
nor its contrary ‘-freg-struct-return’,
GNU CC defaults to whichever convention is standard for the target. If
there is no standard convention, GNU CC defaults to ‘-fpcc-struct-return’,
except on targets where GNU CC is the principal compiler. In those cases,
we can choose the standard, and we chose the more efficient register return
alternative.
-fshort-enums
Allocate to an
enum
type only as many bytes as it needs for the declared range of possible
values. Specifically, the enum
type will be equivalent to the smallest integer type which has enough room.
-fshort-double
Use the same size
for double
as for float.
-fshared-data
Requests that
the data and non-const
variables of this compilation be shared data rather than private data.
The distinction makes sense only on certain operating systems, where shared
data is shared between processes running the same program, while private
data exists in one copy per process.
-fno-common
Allocate even
uninitialized global variables in the bss
section of the object file, rather than generating them as common blocks.
This has the effect that if the same variable is declared (without extern)
in two different compilations, you will get an error when you link them.
The only reason this might be useful is if you wish to verify that the
program will work on other systems which always work this way.
-fno-ident
Ignore the #ident
directive.
-fno-gnu-linker
Do not output
global initializations (such as C++ constructors and destructors) in the
form used by the GNU linker (on systems where the GNU linker is the standard
method of handling them). Use this option when you want to use a non-GNU
linker, which also requires using the collect2
program to make sure the system linker includes constructors and destructors.
(collect2
is included in the GNU CC distribution.) For systems which must use collect2,
the compiler driver gcc
is configured to do this automatically.
-finhibit-size-directive
Don’t output a
.size assembler directive, or anything else that would cause trouble if
the function is split in the middle, and the two halves are placed at locations
far apart in memory. This option is used when compiling ‘crtstuff.c’;
you should not need to use it for anything else.
-fverbose-asm
Put extra commentary
information in the generated assembly code to make it more readable. This
option is generally only of use to those who actually need to read the
generated assembly code (perhaps while debugging the compiler itself).
‘-fverbose-asm’
is the default. ‘-fno-verbose-asm’
causes the extra information to be omitted and is useful when comparing
two assembler files.
-fvolatile
Consider all memory
references through pointers to be volatile.
-fvolatile-global
Consider all memory
references to extern and global data items to be volatile.
-fpic
Generate position-independent
code (PIC) suitable for use in a shared library, if supported for the target
machine. Such code accesses all constant addresses through a global offset
table (GOT). The dynamic loader resolves the GOT entries when the program
starts (the dynamic loader is not part of GNU CC; it is part of the operating
system). If the GOT size for the linked executable exceeds a machine-specific
maximum size, you get an error message from the linker indicating that
‘-fpic’
does not work; in that case, recompile with ‘-fPIC’
instead. (These maximums are 16k on the m88k, 8k on the SPARC, and 32k
on the m68k and RS/6000. The 386 has no such limit.)
Position-independent code
requires special support, and therefore works only on certain machines.
For the 386, GNU CC supports PIC for System V but not for the Sun 386i.
Code generated for the IBM RS/6000 is always position-independent.
-fPIC
If supported for
the target machine, emit position-independent code, suitable for dynamic
linking and avoiding any limit on the size of the global offset table.
This option makes a difference on the m68k, m88k, and the SPARC.
Position-independent code
requires special support, and therefore works only on certain machines.
-ffixed-reg
Treat the
register named reg
as a fixed register; generated code should never refer to it (except perhaps
as a stack pointer, frame pointer or in some other fixed role).
reg
must be the name of a register. The register names accepted are machine-specific
and are defined in the macro, REGISTER_NAMES,
in the machine description macro file.
This flag does not have
a negative form, because it specifies a three-way choice.
-fcall-used-reg
Treat the
register named reg
as an allocatable register that is clobbered by function calls. It may
be allocated for temporaries or variables that do not live across a call.
Functions compiled this way will not save and restore the register reg.
Use of this flag for a register
that has a fixed pervasive role in the machine’s execution model, such
as the stack pointer or frame pointer, will produce disastrous results.
This flag does not have a negative form, because it specifies a three-way
choice.
-fcall-saved-reg
Treat the
register named reg
as an allocatable register saved by functions. It may be allocated even
for temporaries or variables that live across a call. Functions compiled
this way will save and restore the register reg
if they use it.
Use of this flag for a register
that has a fixed pervasive role in the machine’s execution model, such
as the stack pointer or frame pointer, will produce disastrous results.
A different sort of disaster
will result from the use of this flag for a register in which function
values may be returned.
This flag does not have
a negative form, because it specifies a three-way choice.
-fpack-struct
Pack all structure
members together without holes. Usually you would not want to use this
option, since it makes the code suboptimal, and the offsets of structure
members won’t agree with system libraries.
+e0
+e1
Control whether
virtual function definitions in classes are used to generate code, or only
to define interfaces for their callers. (C++ only).
These options are provided
for compatibility with cfront
1.x usage; the recommended alternative GNU C++ usage is in flux. See Declarations
and Definitions in One Header.
With +e0,
virtual function definitions in classes are declared extern;
the declaration is used only as an interface specification, not to generate
code for the virtual functions (in this compilation).
With +e1,
G++ actually generates the code implementing virtual functions defined
in the code, and makes them publicly visible.
-funaligned-pointers
Assume that all
pointers contain unaligned addresses. On machines where unaligned memory
accesses trap, this will result in much larger and slower code for all
pointer dereferences, but the code will work even if addresses are unaligned.
-funaligned-struct-hack
Always access
structure fields using loads and stores of the declared size. This option
is useful for code that dereferences pointers to unaligned structures,
but only accesses fields that are themselves aligned. Without this option,
gcc
may try to use a memory access larger than the field. This might give an
unaligned access fault on some hardware. This option makes some invalid
code work at the expense of disabling some optimizations. It is strongly
recommended that this option not be used.