Options for Code Generation Conventions

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.

-fpack-struct

Generate extra code to check each memory access. GNU CC 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

__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 GNU CC 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 nd or build stubs for every function you call, you may have to specify

-fcheck-memory-usage

without

-fprefix-function-name

-fexceptions

Enable exception handling. For some targets, this implies generation of frame unwind information for all functions, which can produce signi cant data size overhead, though it does not affect execution.

This option is on by default for languages that support exception handling (such as C++), and off for those that don't (such as C).

+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

-fprefix-function-name
-finstrument-functions
-fstack-check

Top|Contents|Index|Previous|Next