GNU Info
(gcc-300.info)Code Gen Options
Options for Code Generation Conventions
=======================================
These 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 table below, 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.
`-fexceptions'
Enable exception handling. Generates extra code needed to
propagate exceptions. For some targets, this implies GCC will
generate frame unwind information for all functions, which can
produce significant data size overhead, although it does not
affect execution. If you do not specify this option, GCC will
enable it by default for languages like C++ which normally require
exception handling, and disable it for languages like C that do
not normally require it. However, you may need to enable this
option when compiling C code that needs to interoperate properly
with exception handlers written in C++. You may also wish to
disable this option if you are compiling older C++ programs that
don't use exception handling.
`-fnon-call-exceptions'
Generate code that allows trapping instructions to throw
exceptions. Note that this requires platform-specific runtime
support that does not exist everywhere. Moreover, it only allows
_trapping_ instructions to throw exceptions, i.e. memory
references or floating point instructions. It does not allow
exceptions to be thrown from arbitrary signal handlers such as
`SIGALRM'.
`-funwind-tables'
Similar to `-fexceptions', except that it will just generate any
needed static data, but will not affect the generated code in any
other way. You will normally not enable this option; instead, a
language processor that needs this handling would enable it on
your behalf.
`-fpcc-struct-return'
Return "short" `struct' and `union' values in memory like longer
ones, rather than in registers. This convention is less
efficient, but it has the advantage of allowing intercallability
between GCC-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', GCC defaults to whichever convention is
standard for the target. If there is no standard convention, GCC
defaults to `-fpcc-struct-return', except on targets where GCC 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'
In C, allocate even uninitialized global variables in the data
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 GCC 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).
`-fno-verbose-asm', the default, 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. GCC does not consider static data items to be
volatile because of this switch.
`-fvolatile-static'
Consider all memory references to static data 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 GCC; 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, GCC 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 `REGISTER_NAMES' macro
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 allocable 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.
It is an error to used this flag with the frame pointer or stack
pointer. Use of this flag for other registers that have fixed
pervasive roles in the machine's execution model 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 allocable 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.
It is an error to used this flag with the frame pointer or stack
pointer. Use of this flag for other registers that have fixed
pervasive roles in the machine's execution model 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.
`-fcheck-memory-usage'
Generate extra code to check each memory access. GCC will generate
code that is suitable for a detector of bad memory accesses such as
`Checker'.
Normally, you should compile all, or none, of your code with this
option.
If you do mix code compiled with and without this option, you must
ensure that all code that has side effects and that is called by
code compiled with this option is, itself, compiled with this
option. If you do not, you might get erroneous messages from the
detector.
If you use functions from a library that have side-effects (such as
`read'), you might not be able to recompile the library and
specify this option. In that case, you can enable the
`-fprefix-function-name' option, which requests GCC to encapsulate
your code and make other functions look as if they were compiled
with `-fcheck-memory-usage'. This is done by calling "stubs",
which are provided by the detector. If you cannot find or build
stubs for every function you call, you might have to specify
`-fcheck-memory-usage' without `-fprefix-function-name'.
If you specify this option, you can not use the `asm' or `__asm__'
keywords in functions with memory checking enabled. GCC cannot
understand what the `asm' statement may do, and therefore cannot
generate the appropriate code, so it will reject it. However, if
you specify the function attribute `no_check_memory_usage' (Note:
Function Attributes), GCC will disable memory checking within a
function; you may use `asm' statements inside such functions. You
may have an inline expansion of a non-checked function within a
checked function; in that case GCC will not generate checks for
the inlined function's memory accesses.
If you move your `asm' statements to non-checked inline functions
and they do access memory, you can add calls to the support code
in your inline function, to indicate any reads, writes, or copies
being done. These calls would be similar to those done in the
stubs described above.
`-fprefix-function-name'
Request GCC to add a prefix to the symbols generated for function
names. GCC adds a prefix to the names of functions defined as
well as functions called. Code compiled with this option and code
compiled without the option can't be linked together, unless stubs
are used.
If you compile the following code with `-fprefix-function-name'
extern void bar (int);
void
foo (int a)
{
return bar (a + 5);
}
GCC will compile the code as if it was written:
extern void prefix_bar (int);
void
prefix_foo (int a)
{
return prefix_bar (a + 5);
}
This option is designed to be used with `-fcheck-memory-usage'.
`-finstrument-functions'
Generate instrumentation calls for entry and exit to functions.
Just after function entry and just before function exit, the
following profiling functions will be called with the address of
the current function and its call site. (On some platforms,
`__builtin_return_address' does not work beyond the current
function, so the call site information may not be available to the
profiling functions otherwise.)
void __cyg_profile_func_enter (void *this_fn,
void *call_site);
void __cyg_profile_func_exit (void *this_fn,
void *call_site);
The first argument is the address of the start of the current
function, which may be looked up exactly in the symbol table.
This instrumentation is also done for functions expanded inline in
other functions. The profiling calls will indicate where,
conceptually, the inline function is entered and exited. This
means that addressable versions of such functions must be
available. If all your uses of a function are expanded inline,
this may mean an additional expansion of code size. If you use
`extern inline' in your C code, an addressable version of such
functions must be provided. (This is normally the case anyways,
but if you get lucky and the optimizer always expands the
functions inline, you might have gotten away without providing
static copies.)
A function may be given the attribute `no_instrument_function', in
which case this instrumentation will not be done. This can be
used, for example, for the profiling functions listed above,
high-priority interrupt routines, and any functions from which the
profiling functions cannot safely be called (perhaps signal
handlers, if the profiling routines generate output or allocate
memory).
`-fstack-check'
Generate code to verify that you do not go beyond the boundary of
the stack. You should specify this flag if you are running in an
environment with multiple threads, but only rarely need to specify
it in a single-threaded environment since stack overflow is
automatically detected on nearly all systems if there is only one
stack.
Note that this switch does not actually cause checking to be done;
the operating system must do that. The switch causes generation
of code to ensure that the operating system sees the stack being
extended.
`-fstack-limit-register=REG'
`-fstack-limit-symbol=SYM'
`-fno-stack-limit'
Generate code to ensure that the stack does not grow beyond a
certain value, either the value of a register or the address of a
symbol. If the stack would grow beyond the value, a signal is
raised. For most targets, the signal is raised before the stack
overruns the boundary, so it is possible to catch the signal
without taking special precautions.
For instance, if the stack starts at address `0x80000000' and grows
downwards you can use the flags `-fstack-limit-symbol=__stack_limit
-Wl,--defsym,__stack_limit=0x7ffe0000' which will enforce a stack
limit of 128K.
`-fargument-alias'
`-fargument-noalias'
`-fargument-noalias-global'
Specify the possible relationships among parameters and between
parameters and global data.
`-fargument-alias' specifies that arguments (parameters) may alias
each other and may alias global storage. `-fargument-noalias'
specifies that arguments do not alias each other, but may alias
global storage. `-fargument-noalias-global' specifies that
arguments do not alias each other and do not alias global storage.
Each language will automatically use whatever option is required by
the language standard. You should not need to use these options
yourself.
`-fleading-underscore'
This option and its counterpart, `-fno-leading-underscore',
forcibly change the way C symbols are represented in the object
file. One use is to help link with legacy assembly code.
Be warned that you should know what you are doing when invoking
this option, and that not all targets provide complete support for
it.
automatically generated by info2www version 1.2.2.9