Next: Environment Variables, Previous: Submodel Options, Up: Invoking GCC
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.
-fbounds-check-ftrapv-fwrapv-fexceptions-fnon-call-exceptionsSIGALRM.
-funwind-tables-fasynchronous-unwind-tables-fpcc-struct-returnstruct 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, particularly
the Portable C Compiler (pcc).
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.
Warning: code compiled with the -fpcc-struct-return
switch is not binary compatible with code compiled with the
-freg-struct-return switch.
Use it to conform to a non-default application binary interface.
-freg-struct-returnstruct and union values in registers when possible.
This is more efficient for small structures than
-fpcc-struct-return.
If you specify neither -fpcc-struct-return nor -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.
Warning: code compiled with the -freg-struct-return
switch is not binary compatible with code compiled with the
-fpcc-struct-return switch.
Use it to conform to a non-default application binary interface.
-fshort-enumsenum 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.
Warning: the -fshort-enums switch causes GCC to generate
code that is not binary compatible with code generated without that switch.
Use it to conform to a non-default application binary interface.
-fshort-doubledouble as for float.
Warning: the -fshort-double switch causes GCC to generate
code that is not binary compatible with code generated without that switch.
Use it to conform to a non-default application binary interface.
-fshort-wcharWarning: the -fshort-wchar switch causes GCC to generate
code that is not binary compatible with code generated without that switch.
Use it to conform to a non-default application binary interface.
-fno-commonextern) in two different compilations,
you will get a multiple-definition error when you link them.
In this case, you must compile with -fcommon instead.
Compiling with -fno-common is useful on targets for which
it provides better performance, or if you wish to verify that the
program will work on other systems which always treat uninitialized
variable declarations this way.
-fno-ident-finhibit-size-directive.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-fno-verbose-asm, the default, causes the
extra information to be omitted and is useful when comparing two assembler
files.
-frecord-gcc-switches-fpicPosition-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.
When this flag is set, the macros __pic__ and __PIC__
are defined to 1.
-fPICPosition-independent code requires special support, and therefore works only on certain machines.
When this flag is set, the macros __pic__ and __PIC__
are defined to 2.
-fpie-fPIE-fpie and -fPIE both define the macros
__pie__ and __PIE__. The macros have the value 1
for -fpie and 2 for -fPIE.
-fno-jump-tables-ffixed-regreg 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-regIt 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-regIt 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[=n]Warning: the -fpack-struct switch causes GCC to generate
code that is not binary compatible with code generated without that switch.
Additionally, it makes the code suboptimal.
Use it to conform to a non-default application binary interface.
-finstrument-functions__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).
-finstrument-functions-exclude-file-list=file,file,...-finstrument-functions). If the file that
contains a function definition matches with one of file, then
that function is not instrumented. The match is done on substrings:
if the file parameter is a substring of the file name, it is
considered to be a match.
For example,
-finstrument-functions-exclude-file-list=/bits/stl,include/sys
will exclude any inline function defined in files whose pathnames
contain /bits/stl or include/sys.
If, for some reason, you want to include letter ',' in one of
sym, write '\,'. For example,
-finstrument-functions-exclude-file-list='\,\,tmp'
(note the single quote surrounding the option).
-finstrument-functions-exclude-function-list=sym,sym,...-finstrument-functions-exclude-file-list,
but this option sets the list of function names to be excluded from
instrumentation. The function name to be matched is its user-visible
name, such as vector<int> blah(const vector<int> &), not the
internal mangled name (e.g., _Z4blahRSt6vectorIiSaIiEE). The
match is done on substrings: if the sym parameter is a substring
of the function name, it is considered to be a match. For C99 and C++
extended identifiers, the function name must be given in UTF-8, not
using universal character names.
-fstack-checkNote that this switch does not actually cause checking to be done; the operating system or the language runtime must do that. The switch causes generation of code to ensure that they see the stack being extended.
You can additionally specify a string parameter: no means no
checking, generic means force the use of old-style checking,
specific means use the best checking method and is equivalent
to bare -fstack-check.
Old-style checking is a generic mechanism that requires no specific target support in the compiler but comes with the following drawbacks:
Note that old-style stack checking is also the fallback method for
specific if no target support has been added in the compiler.
-fstack-limit-register=reg-fstack-limit-symbol=sym-fno-stack-limitFor instance, if the stack starts at absolute address `0x80000000' and grows downwards, you can use the flags -fstack-limit-symbol=__stack_limit and -Wl,--defsym,__stack_limit=0x7ffe0000 to enforce a stack limit of 128KB. Note that this may only work with the GNU linker.
-fargument-alias-fargument-noalias-fargument-noalias-global-fargument-noalias-anything-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.
-fargument-noalias-anything specifies that arguments do not
alias any other storage.
Each language will automatically use whatever option is required by
the language standard. You should not need to use these options yourself.
-fleading-underscoreWarning: the -fleading-underscore switch causes GCC to
generate code that is not binary compatible with code generated without that
switch. Use it to conform to a non-default application binary interface.
Not all targets provide complete support for this switch.
-ftls-model=modelglobal-dynamic,
local-dynamic, initial-exec or local-exec.
The default without -fpic is initial-exec; with
-fpic the default is global-dynamic.
-fvisibility=default|internal|hidden|protectedDespite the nomenclature, default always means public ie;
available to be linked against from outside the shared object.
protected and internal are pretty useless in real-world
usage so the only other commonly used option will be hidden.
The default if -fvisibility isn't specified is
default, i.e., make every
symbol public—this causes the same behavior as previous versions of
GCC.
A good explanation of the benefits offered by ensuring ELF
symbols have the correct visibility is given by “How To Write
Shared Libraries” by Ulrich Drepper (which can be found at
http://people.redhat.com/~drepper/)—however a superior
solution made possible by this option to marking things hidden when
the default is public is to make the default hidden and mark things
public. This is the norm with DLL's on Windows and with -fvisibility=hidden
and __attribute__ ((visibility("default"))) instead of
__declspec(dllexport) you get almost identical semantics with
identical syntax. This is a great boon to those working with
cross-platform projects.
For those adding visibility support to existing code, you may find `#pragma GCC visibility' of use. This works by you enclosing the declarations you wish to set visibility for with (for example) `#pragma GCC visibility push(hidden)' and `#pragma GCC visibility pop'. Bear in mind that symbol visibility should be viewed as part of the API interface contract and thus all new code should always specify visibility when it is not the default ie; declarations only for use within the local DSO should always be marked explicitly as hidden as so to avoid PLT indirection overheads—making this abundantly clear also aids readability and self-documentation of the code. Note that due to ISO C++ specification requirements, operator new and operator delete must always be of default visibility.
Be aware that headers from outside your project, in particular system headers and headers from any other library you use, may not be expecting to be compiled with visibility other than the default. You may need to explicitly say `#pragma GCC visibility push(default)' before including any such headers.
`extern' declarations are not affected by `-fvisibility', so a lot of code can be recompiled with `-fvisibility=hidden' with no modifications. However, this means that calls to `extern' functions with no explicit visibility will use the PLT, so it is more effective to use `__attribute ((visibility))' and/or `#pragma GCC visibility' to tell the compiler which `extern' declarations should be treated as hidden.
Note that `-fvisibility' does affect C++ vague linkage entities. This means that, for instance, an exception class that will be thrown between DSOs must be explicitly marked with default visibility so that the `type_info' nodes will be unified between the DSOs.
An overview of these techniques, their benefits and how to use them is at http://gcc.gnu.org/wiki/Visibility.