RTEMS GNU Tools On-Line Library

Driver

Using and Porting the GNU Compiler Collection (GCC)

17.1: Controlling the Compilation Driver, ``gcc`'

You can control the compilation driver.

SWITCH_TAKES_ARG (char)

A C expression which determines whether the option `-char' takes arguments. The value should be the number of arguments that option takes--zero, for many options.

By default, this macro is defined as DEFAULT_SWITCH_TAKES_ARG, which handles the standard options properly. You need not define SWITCH_TAKES_ARG unless you wish to add additional options which take arguments. Any redefinition should call DEFAULT_SWITCH_TAKES_ARG and then check for additional options.

WORD_SWITCH_TAKES_ARG (name)

A C expression which determines whether the option `-name' takes arguments. The value should be the number of arguments that option takes--zero, for many options. This macro rather than SWITCH_TAKES_ARG is used for multi-character option names.

By default, this macro is defined as DEFAULT_WORD_SWITCH_TAKES_ARG, which handles the standard options properly. You need not define WORD_SWITCH_TAKES_ARG unless you wish to add additional options which take arguments. Any redefinition should call DEFAULT_WORD_SWITCH_TAKES_ARG and then check for additional options.

SWITCH_CURTAILS_COMPILATION (char)

A C expression which determines whether the option `-char' stops compilation before the generation of an executable. The value is boolean, non-zero if the option does stop an executable from being generated, zero otherwise.

By default, this macro is defined as DEFAULT_SWITCH_CURTAILS_COMPILATION, which handles the standard options properly. You need not define SWITCH_CURTAILS_COMPILATION unless you wish to add additional options which affect the generation of an executable. Any redefinition should call DEFAULT_SWITCH_CURTAILS_COMPILATION and then check for additional options.

SWITCHES_NEED_SPACES

A string-valued C expression which enumerates the options for which the linker needs a space between the option and its argument.

If this macro is not defined, the default value is "".

CPP_SPEC

A C string constant that tells the GNU CC driver program options to pass to CPP. It can also specify how to translate options you give to GNU CC into options for GNU CC to pass to the CPP.

Do not define this macro if it does not need to do anything.

NO_BUILTIN_SIZE_TYPE

If this macro is defined, the preprocessor will not define the builtin macro __SIZE_TYPE__. The macro __SIZE_TYPE__ must then be defined by CPP_SPEC instead.

This should be defined if SIZE_TYPE depends on target dependent flags which are not accessible to the preprocessor. Otherwise, it should not be defined.

NO_BUILTIN_PTRDIFF_TYPE

If this macro is defined, the preprocessor will not define the builtin macro __PTRDIFF_TYPE__. The macro __PTRDIFF_TYPE__ must then be defined by CPP_SPEC instead.

This should be defined if PTRDIFF_TYPE depends on target dependent flags which are not accessible to the preprocessor. Otherwise, it should not be defined.

SIGNED_CHAR_SPEC

A C string constant that tells the GNU CC driver program options to pass to CPP. By default, this macro is defined to pass the option `-D__CHAR_UNSIGNED__' to CPP if char will be treated as unsigned char by cc1.

Do not define this macro unless you need to override the default definition.

CC1_SPEC

A C string constant that tells the GNU CC driver program options to pass to cc1. It can also specify how to translate options you give to GNU CC into options for GNU CC to pass to the cc1.

Do not define this macro if it does not need to do anything.

CC1PLUS_SPEC

A C string constant that tells the GNU CC driver program options to pass to cc1plus. It can also specify how to translate options you give to GNU CC into options for GNU CC to pass to the cc1plus.

Do not define this macro if it does not need to do anything.

ASM_SPEC

A C string constant that tells the GNU CC driver program options to pass to the assembler. It can also specify how to translate options you give to GNU CC into options for GNU CC to pass to the assembler. See the file `sun3.h' for an example of this.

Do not define this macro if it does not need to do anything.

ASM_FINAL_SPEC

A C string constant that tells the GNU CC driver program how to run any programs which cleanup after the normal assembler. Normally, this is not needed. See the file `mips.h' for an example of this.

Do not define this macro if it does not need to do anything.

LINK_SPEC

A C string constant that tells the GNU CC driver program options to pass to the linker. It can also specify how to translate options you give to GNU CC into options for GNU CC to pass to the linker.

Do not define this macro if it does not need to do anything.

LIB_SPEC

Another C string constant used much like LINK_SPEC. The difference between the two is that LIB_SPEC is used at the end of the command given to the linker.

If this macro is not defined, a default is provided that loads the standard C library from the usual place. See `gcc.c'.

LIBGCC_SPEC

Another C string constant that tells the GNU CC driver program how and when to place a reference to `libgcc.a' into the linker command line. This constant is placed both before and after the value of LIB_SPEC.

If this macro is not defined, the GNU CC driver provides a default that passes the string `-lgcc' to the linker unless the `-shared' option is specified.

STARTFILE_SPEC

Another C string constant used much like LINK_SPEC. The difference between the two is that STARTFILE_SPEC is used at the very beginning of the command given to the linker.

If this macro is not defined, a default is provided that loads the standard C startup file from the usual place. See `gcc.c'.

ENDFILE_SPEC

Another C string constant used much like LINK_SPEC. The difference between the two is that ENDFILE_SPEC is used at the very end of the command given to the linker.

Do not define this macro if it does not need to do anything.

EXTRA_SPECS

Define this macro to provide additional specifications to put in the `specs' file that can be used in various specifications like CC1_SPEC.

The definition should be an initializer for an array of structures, containing a string constant, that defines the specification name, and a string constant that provides the specification.

Do not define this macro if it does not need to do anything.

EXTRA_SPECS is useful when an architecture contains several related targets, which have various ..._SPECS which are similar to each other, and the maintainer would like one central place to keep these definitions.

For example, the PowerPC System V.4 targets use EXTRA_SPECS to define either _CALL_SYSV when the System V calling sequence is used or _CALL_AIX when the older AIX-based calling sequence is used.

The `config/rs6000/rs6000.h' target file defines:

#define EXTRA_SPECS \
  { "cpp_sysv_default", CPP_SYSV_DEFAULT },

#define CPP_SYS_DEFAULT ""

The `config/rs6000/sysv.h' target file defines:

#undef CPP_SPEC
#define CPP_SPEC \
"%{posix: -D_POSIX_SOURCE } \
%{mcall-sysv: -D_CALL_SYSV } %{mcall-aix: -D_CALL_AIX } \
%{!mcall-sysv: %{!mcall-aix: %(cpp_sysv_default) }} \
%{msoft-float: -D_SOFT_FLOAT} %{mcpu=403: -D_SOFT_FLOAT}"

#undef CPP_SYSV_DEFAULT
#define CPP_SYSV_DEFAULT "-D_CALL_SYSV"

while the `config/rs6000/eabiaix.h' target file defines CPP_SYSV_DEFAULT as:

#undef CPP_SYSV_DEFAULT
#define CPP_SYSV_DEFAULT "-D_CALL_AIX"

LINK_LIBGCC_SPECIAL

Define this macro if the driver program should find the library `libgcc.a' itself and should not pass `-L' options to the linker. If you do not define this macro, the driver program will pass the argument `-lgcc' to tell the linker to do the search and will pass `-L' options to it.

LINK_LIBGCC_SPECIAL_1

Define this macro if the driver program should find the library `libgcc.a'. If you do not define this macro, the driver program will pass the argument `-lgcc' to tell the linker to do the search. This macro is similar to LINK_LIBGCC_SPECIAL, except that it does not affect `-L' options.

LINK_COMMAND_SPEC

A C string constant giving the complete command line need to execute the linker. When you do this, you will need to update your port each time a change is made to the link command line within `gcc.c'. Therefore, define this macro only if you need to completely redefine the command line for invoking the linker and there is no other way to accomplish the effect you need.

MULTILIB_DEFAULTS

Define this macro as a C expression for the initializer of an array of string to tell the driver program which options are defaults for this target and thus do not need to be handled specially when using MULTILIB_OPTIONS.

Do not define this macro if MULTILIB_OPTIONS is not defined in the target makefile fragment or if none of the options listed in MULTILIB_OPTIONS are set by default. See Target Fragment.

RELATIVE_PREFIX_NOT_LINKDIR

Define this macro to tell gcc that it should only translate a `-B' prefix into a `-L' linker option if the prefix indicates an absolute file name.

STANDARD_EXEC_PREFIX

Define this macro as a C string constant if you wish to override the standard choice of `/usr/local/lib/gcc-lib/' as the default prefix to try when searching for the executable files of the compiler.

MD_EXEC_PREFIX

If defined, this macro is an additional prefix to try after STANDARD_EXEC_PREFIX. MD_EXEC_PREFIX is not searched when the `-b' option is used, or the compiler is built as a cross compiler. If you define MD_EXEC_PREFIX, then be sure to add it to the list of directories used to find the assembler in `configure.in'.

STANDARD_STARTFILE_PREFIX

Define this macro as a C string constant if you wish to override the standard choice of `/usr/local/lib/' as the default prefix to try when searching for startup files such as `crt0.o'.

MD_STARTFILE_PREFIX

If defined, this macro supplies an additional prefix to try after the standard prefixes. MD_EXEC_PREFIX is not searched when the `-b' option is used, or when the compiler is built as a cross compiler.

MD_STARTFILE_PREFIX_1

If defined, this macro supplies yet another prefix to try after the standard prefixes. It is not searched when the `-b' option is used, or when the compiler is built as a cross compiler.

INIT_ENVIRONMENT

Define this macro as a C string constant if you wish to set environment variables for programs called by the driver, such as the assembler and loader. The driver passes the value of this macro to putenv to initialize the necessary environment variables.

LOCAL_INCLUDE_DIR

Define this macro as a C string constant if you wish to override the standard choice of `/usr/local/include' as the default prefix to try when searching for local header files. LOCAL_INCLUDE_DIR comes before SYSTEM_INCLUDE_DIR in the search order.

Cross compilers do not use this macro and do not search either `/usr/local/include' or its replacement.

SYSTEM_INCLUDE_DIR

Define this macro as a C string constant if you wish to specify a system-specific directory to search for header files before the standard directory. SYSTEM_INCLUDE_DIR comes before STANDARD_INCLUDE_DIR in the search order.

Cross compilers do not use this macro and do not search the directory specified.

STANDARD_INCLUDE_DIR

Define this macro as a C string constant if you wish to override the standard choice of `/usr/include' as the default prefix to try when searching for header files.

Cross compilers do not use this macro and do not search either `/usr/include' or its replacement.

STANDARD_INCLUDE_COMPONENT

The ``component'' corresponding to STANDARD_INCLUDE_DIR. See INCLUDE_DEFAULTS, below, for the description of components. If you do not define this macro, no component is used.

INCLUDE_DEFAULTS

Define this macro if you wish to override the entire default search path for include files. For a native compiler, the default search path usually consists of GCC_INCLUDE_DIR, LOCAL_INCLUDE_DIR, SYSTEM_INCLUDE_DIR, GPLUSPLUS_INCLUDE_DIR, and STANDARD_INCLUDE_DIR. In addition, GPLUSPLUS_INCLUDE_DIR and GCC_INCLUDE_DIR are defined automatically by `Makefile', and specify private search areas for GCC. The directory GPLUSPLUS_INCLUDE_DIR is used only for C++ programs.

The definition should be an initializer for an array of structures. Each array element should have four elements: the directory name (a string constant), the component name, and flag for C++-only directories, and a flag showing that the includes in the directory don't need to be wrapped in extern `C' when compiling C++. Mark the end of the array with a null element.

The component name denotes what GNU package the include file is part of, if any, in all upper-case letters. For example, it might be `GCC' or `BINUTILS'. If the package is part of the a vendor-supplied operating system, code the component name as `0'.

For example, here is the definition used for VAX/VMS:

#define INCLUDE_DEFAULTS \
{                                       \
  { "GNU_GXX_INCLUDE:", "G++", 1, 1},   \
  { "GNU_CC_INCLUDE:", "GCC", 0, 0},    \
  { "SYS$SYSROOT:[SYSLIB.]", 0, 0, 0},  \
  { ".", 0, 0, 0},                      \
  { 0, 0, 0, 0}                         \
}

Here is the order of prefixes tried for exec files:

Any prefixes specified by the user with `-B'.
The environment variable GCC_EXEC_PREFIX, if any.
The directories specified by the environment variable COMPILER_PATH.
The macro STANDARD_EXEC_PREFIX.
`/usr/lib/gcc/'.
The macro MD_EXEC_PREFIX, if any.

Here is the order of prefixes tried for startfiles:

Any prefixes specified by the user with `-B'.
The environment variable GCC_EXEC_PREFIX, if any.
The directories specified by the environment variable LIBRARY_PATH (native only, cross compilers do not use this).
The macro STANDARD_EXEC_PREFIX.
`/usr/lib/gcc/'.
The macro MD_EXEC_PREFIX, if any.
The macro MD_STARTFILE_PREFIX, if any.
The macro STANDARD_STARTFILE_PREFIX.
`/lib/'.
`/usr/lib/'.

Using and Porting the GNU Compiler Collection (GCC)

RTEMS GNU Tools On-Line Library

17.1: Controlling the Compilation Driver, `gcc'

17.1: Controlling the Compilation Driver, ``gcc`'