GNU Info
(gcc-295.info)Driver
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. Note: 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:
1. Any prefixes specified by the user with `-B'.
2. The environment variable `GCC_EXEC_PREFIX', if any.
3. The directories specified by the environment variable
`COMPILER_PATH'.
4. The macro `STANDARD_EXEC_PREFIX'.
5. `/usr/lib/gcc/'.
6. The macro `MD_EXEC_PREFIX', if any.
Here is the order of prefixes tried for startfiles:
1. Any prefixes specified by the user with `-B'.
2. The environment variable `GCC_EXEC_PREFIX', if any.
3. The directories specified by the environment variable
`LIBRARY_PATH' (native only, cross compilers do not use this).
4. The macro `STANDARD_EXEC_PREFIX'.
5. `/usr/lib/gcc/'.
6. The macro `MD_EXEC_PREFIX', if any.
7. The macro `MD_STARTFILE_PREFIX', if any.
8. The macro `STANDARD_STARTFILE_PREFIX'.
9. `/lib/'.
10. `/usr/lib/'.
automatically generated by info2www version 1.2.2.9