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 that is not the default. You can figure out the other form by either removing “no-” or adding it.
Enable exception handling, and generate extra code needed to propagate exceptions. If you do not specify this option, the compiler enables it by default for languages like C++ that normally require exception handling, and disabled for languages like C that do not normally require it. However, when compiling C code that needs to interoperate properly with exception handlers written in C++, you may need to enable this option. You may also wish to disable this option is you are compiling older C++ programs that don't use exception handling.
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 the compiler-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.
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”, the compiler defaults to whichever convention is standard for the target. If there is no standard convention, the compiler defaults to “-fpcc-struct-return”, except on targets where the compiler is the principal compiler. In those cases, we can choose the standard, and we chose the more efficient register return alternative.
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 that has enough room.
Use the same size for double as for float.
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.
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 that always work this way.
Ignore the “#ident” directive.
Do not output global initializations (such as C++ constructors and destructors) in the form used by The linker (on systems where The 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 the compiler distribution.) For systems that must use collect2, the compiler driver gcc is configured to do this automatically.
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.
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.
Consider all memory references through pointers to be volatile.
Consider all memory references to extern and global data items to be volatile.
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.
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.
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.
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.
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.
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.
Generate extra code to check each memory access. the compiler will generate code that is suitable for a detector of bad memory accesses such as Checker. If you specify this option, you can not use the asm or __asm__ keywords.
You must also specify this option when you compile functions you call that have side effects. If you do not, you may get erroneous messages from the detector. Normally, you should compile all your code with this option. If you use functions from a library that have side-effects (such as read), you may not be able to recompile the library and specify this option. In that case, you can enable the “-fprefix-function-name” option, which requests the compiler 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 may have to specify “-fcheck-memory-usage” without “-fprefix-function-name”.
Request the compiler to add a prefix to the symbols generated for function names. The compiler 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 or 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);
}
The compiler 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”.
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.
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 Section 3.4.
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.