| Options for Code Generation Conventions

Previous | GCC Command-Line Options | Next

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
  For front-ends that support it, generate additional code to check that indices used to access arrays are within the declared range. This is currently only supported by the Java and Fortran 77 front-ends, where this option defaults to true and false respectively.
-ftrapv
  This option generates traps for signed overflow on addition, subtraction, multiplication operations.
-fexceptions
  Enable exception handling. Generates extra code needed to propagate exceptions. In principle, you may need to enable this option when compiling C code that needs to interoperate properly with exception handlers, but this is useless in TIGCC, as the TIOS uses its own exception handling mechanism (see error.h).
-fnon-call-exceptions
  Generate code that allows trapping instructions to throw exceptions. Probably useless in TIGCC.
-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. Probably useless in TIGCC.
-fasynchronous-unwind-tables
  Generate unwind table in dwarf2 format, if supported by target machine. The table is exact at each instruction boundary, so it can be used for stack unwinding from asynchronous events (such as debugger or garbage collector).
-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, 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-return
  Return `struct` 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', TIGCC defaults to '-freg-struct-return'.
  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-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.
  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-double
  Use the same size for `double` as for `float`. This is always true in TIGCC, regardless of this switch.
  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-wchar
  Override the underlying type for `wchar_t` to be `short unsigned int` instead of the default for the target. This option is useful for building programs to run under WINE.
  Warning: 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.
-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 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. Currently, TIGCC does not support this option, since it needs common symbols to communicate with the linker.
-fno-ident
  Ignore the `#ident` directive.
-fno-gnu-linker
  Do not output global initializations in the form used by the GNU linker Useless in TIGCC, because global initializations are not implemented.
-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. However, it requires special support of the operating system (like dynamic loaders, etc.). So forget it with the TIOS; maybe some future ASM shells will support this. At the moment, forget this nice option.
-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.
-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).
  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.
-freg-relative-reg
  Refer to all labels only in relation to the register specified in reg. This can make the code somewhat smaller, but you should use this option with care as it is not fully supported. This option is implemented only in TIGCC.
-fpack-struct
  Pack all structure members together without holes.
  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
  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. As this requires support from the operating system, it probably does not work in TIGCC.
-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 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
  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.
  Warning: 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.
-ftls-model=model
  Alter the thread-local storage model to be used. The model argument should be one of `global-dynamic`, `local-dynamic`, `initial-exec` or `local-exec`.
  The default without '-fpic' is `initial-exec`; with '-fpic' the default is `global-dynamic`.
  Useless in TIGCC, as threads are not supported.