Next: Directory Options,Previous: Assembler Options,Up: Invoking GCC

3.14 Options for Linking

These options come into play when the compiler links object files intoan executable output file. They are meaningless if the compiler isnot doing a link step.

Another C string constant that tells the GCC 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 LIBSPEC. If this macro is not defined, the GCC driver provides a default that passes the string. GCC Elite 12/1200N Printer Driver for Windows 2000/XP 32bit. GCC AR 24 06/28. With marked drivers are for flatbed milling machines and engraving machines and only included as base drivers. Depending on the number and type of tool heads and tools individual drivers according to the required workflow have to be programmed in either CoCut or OptiScout. OptiScout is the finishing software product line.

object-file-name

A file name that does not end in a special recognized suffix isconsidered to name an object file or library. (Object files aredistinguished from libraries by the linker according to the filecontents.) If linking is done, these object files are used as inputto the linker.

-c

-S

Gcc Drivers Ed

-E

If any of these options is used, then the linker is not run, andobject file names should not be used as arguments. See Overall Options.

-fuse-ld=bfd

Use the bfd linker instead of the default linker.

-fuse-ld=gold

Use the gold linker instead of the default linker.

-llibrary

-l library

Search the library named library when linking. (The secondalternative with the library as a separate argument is only forPOSIX compliance and is not recommended.)

It makes a difference where in the command you write this option; thelinker searches and processes libraries and object files in the order theyare specified. Thus, ‘foo.o -lz bar.o’ searches library ‘z’after file foo.o but before bar.o. If bar.o refersto functions in ‘z’, those functions may not be loaded.

The linker searches a standard list of directories for the library,which is actually a file named liblibrary.a. The linkerthen uses this file as if it had been specified precisely by name.

The directories searched include several standard system directoriesplus any that you specify with -L.

Normally the files found this way are library files—archive fileswhose members are object files. The linker handles an archive file byscanning through it for members which define symbols that have so farbeen referenced but not defined. But if the file that is found is anordinary object file, it is linked in the usual fashion. The onlydifference between using an -l option and specifying a file nameis that -l surrounds library with ‘lib’ and ‘.a’and searches several directories.

-lobjc

You need this special case of the -l option in order tolink an Objective-C or Objective-C++ program.

-nostartfiles

Do not use the standard system startup files when linking. The standard system libraries are used normally, unless -nostdlibor -nodefaultlibs is used.

-nodefaultlibs

Do not use the standard system libraries when linking. Only the libraries you specify are passed to the linker, and optionsspecifying linkage of the system libraries, such as -static-libgccor -shared-libgcc, are ignored. The standard startup files are used normally, unless -nostartfilesis used.

The compiler may generate calls to memcmp,memset, memcpy and memmove. These entries are usually resolved by entries inlibc. These entry points should be supplied through some othermechanism when this option is specified.

-nostdlib

Do not use the standard system startup files or libraries when linking. No startup files and only the libraries you specify are passed tothe linker, and options specifying linkage of the system libraries, such as-static-libgcc or -shared-libgcc, are ignored.

The compiler may generate calls to memcmp, memset,memcpy and memmove. These entries are usually resolved by entries inlibc. These entry points should be supplied through some othermechanism when this option is specified.

One of the standard libraries bypassed by -nostdlib and-nodefaultlibs is libgcc.a, a library of internal subroutineswhich GCC uses to overcome shortcomings of particular machines, or specialneeds for some languages. (See Interfacing to GCC Output,for more discussion of libgcc.a.) In most cases, you need libgcc.a even when you want to avoidother standard libraries. In other words, when you specify -nostdlibor -nodefaultlibs you should usually specify -lgcc as well. This ensures that you have no unresolved references to internal GCClibrary subroutines. (An example of such an internal subroutine is __main, used to ensure C++constructors are called; see collect2.)

-pie

Produce a position independent executable on targets that support it. For predictable results, you must also specify the same set of optionsused for compilation (-fpie, -fPIE,or model suboptions) when you specify this linker option.

-no-pie

Don't produce a position independent executable.

-rdynamic

Pass the flag -export-dynamic to the ELF linker, on targetsthat support it. This instructs the linker to add all symbols, notonly used ones, to the dynamic symbol table. This option is neededfor some uses of dlopen or to allow obtaining backtracesfrom within a program.

-s

Remove all symbol table and relocation information from the executable.

-static

On systems that support dynamic linking, this prevents linking with the sharedlibraries. On other systems, this option has no effect.

-shared

Produce a shared object which can then be linked with other objects toform an executable. Not all systems support this option. For predictableresults, you must also specify the same set of options used for compilation(-fpic, -fPIC, or model suboptions) whenyou specify this linker option.¹

-shared-libgcc

-static-libgcc

On systems that provide libgcc as a shared library, these optionsforce the use of either the shared or static version, respectively. If no shared version of libgcc was built when the compiler wasconfigured, these options have no effect.

There are several situations in which an application should use theshared libgcc instead of the static version. The most commonof these is when the application wishes to throw and catch exceptionsacross different shared libraries. In that case, each of the librariesas well as the application itself should use the shared libgcc.

Therefore, the G++ and GCJ drivers automatically add-shared-libgcc whenever you build a shared library or a mainexecutable, because C++ and Java programs typically use exceptions, sothis is the right thing to do.

If, instead, you use the GCC driver to create shared libraries, you mayfind that they are not always linked with the shared libgcc. If GCC finds, at its configuration time, that you have a non-GNU linkeror a GNU linker that does not support option --eh-frame-hdr,it links the shared version of libgcc into shared librariesby default. Otherwise, it takes advantage of the linker and optimizesaway the linking with the shared version of libgcc, linking withthe static version of libgcc by default. This allows exceptions topropagate through such shared libraries, without incurring relocationcosts at library load time.

However, if a library or main executable is supposed to throw or catchexceptions, you must link it using the G++ or GCJ driver, as appropriatefor the languages used in the program, or using the option-shared-libgcc, such that it is linked with the sharedlibgcc.

-static-libasan

When the -fsanitize=address option is used to link a program,the GCC driver automatically links against libasan. Iflibasan is available as a shared library, and the -staticoption is not used, then this links against the shared version oflibasan. The -static-libasan option directs the GCCdriver to link libasan statically, without necessarily linkingother libraries statically.

-static-libtsan

When the -fsanitize=thread option is used to link a program,the GCC driver automatically links against libtsan. Iflibtsan is available as a shared library, and the -staticoption is not used, then this links against the shared version oflibtsan. The -static-libtsan option directs the GCCdriver to link libtsan statically, without necessarily linkingother libraries statically.

-static-liblsan

When the -fsanitize=leak option is used to link a program,the GCC driver automatically links against liblsan. Ifliblsan is available as a shared library, and the -staticoption is not used, then this links against the shared version ofliblsan. The -static-liblsan option directs the GCCdriver to link liblsan statically, without necessarily linkingother libraries statically.

-static-libubsan

When the -fsanitize=undefined option is used to link a program,the GCC driver automatically links against libubsan. Iflibubsan is available as a shared library, and the -staticoption is not used, then this links against the shared version oflibubsan. The -static-libubsan option directs the GCCdriver to link libubsan statically, without necessarily linkingother libraries statically.

-static-libmpx

When the -fcheck-pointer bounds and -mmpx options areused to link a program, the GCC driver automatically links againstlibmpx. If libmpx is available as a shared library,and the -static option is not used, then this links againstthe shared version of libmpx. The -static-libmpxoption directs the GCC driver to link libmpx statically,without necessarily linking other libraries statically.

-static-libmpxwrappers

When the -fcheck-pointer bounds and -mmpx options are usedto link a program without also using -fno-chkp-use-wrappers, theGCC driver automatically links against libmpxwrappers. Iflibmpxwrappers is available as a shared library, and the-static option is not used, then this links against the sharedversion of libmpxwrappers. The -static-libmpxwrappersoption directs the GCC driver to link libmpxwrappers statically,without necessarily linking other libraries statically.

-static-libstdc++

When the g++ program is used to link a C++ program, itnormally automatically links against libstdc++. Iflibstdc++ is available as a shared library, and the-static option is not used, then this links against theshared version of libstdc++. That is normally fine. However, itis sometimes useful to freeze the version of libstdc++ used bythe program without going all the way to a fully static link. The-static-libstdc++ option directs the g++ driver tolink libstdc++ statically, without necessarily linking otherlibraries statically.

-symbolic

Bind references to global symbols when building a shared object. Warnabout any unresolved references (unless overridden by the link editoroption -Xlinker -z -Xlinker defs). Only a few systems supportthis option.

-T script

Use script as the linker script. This option is supported by mostsystems using the GNU linker. On some targets, such as bare-boardtargets without an operating system, the -T option may be requiredwhen linking to avoid references to undefined symbols.

-Xlinker option

Pass option as an option to the linker. You can use this tosupply system-specific linker options that GCC does not recognize.

If you want to pass an option that takes a separate argument, you must use-Xlinker twice, once for the option and once for the argument. For example, to pass -assert definitions, you must write-Xlinker -assert -Xlinker definitions. It does not work to write-Xlinker '-assert definitions', because this passes the entirestring as a single argument, which is not what the linker expects.

When using the GNU linker, it is usually more convenient to passarguments to linker options using the option=valuesyntax than as separate arguments. For example, you can specify-Xlinker -Map=output.map rather than-Xlinker -Map -Xlinker output.map. Other linkers may not supportthis syntax for command-line options.

-Wl,option

Pass option as an option to the linker. If option containscommas, it is split into multiple options at the commas. You can use thissyntax to pass an argument to the option. For example, -Wl,-Map,output.map passes -Map output.map to thelinker. When using the GNU linker, you can also get the same effect with-Wl,-Map=output.map.

-u symbol

Pretend the symbol symbol is undefined, to force linking oflibrary modules to define it. You can use -u multiple times withdifferent symbols to force loading of additional library modules.

-z keyword

-z is passed directly on to the linker along with the keywordkeyword. See the section in the documentation of your linker forpermitted values and their meanings.

Footnotes

[1] On some systems, ‘gcc -shared’needs to build supplementary stub code for constructors to work. Onmulti-libbed systems, ‘gcc -shared’ must select the correct supportlibraries to link against. Failing to supply the correct flags may leadto subtle defects. Supplying them in cases where they are not necessaryis innocuous.

Next: Run-time Target, Previous: Target Structure, Up: Target Macros [Contents][Index]

18.2 Controlling the Compilation Driver, gcc

You can control the compilation driver.

Macro: DRIVER_SELF_SPECS

A list of specs for the driver itself. It should be a suitableinitializer for an array of strings, with no surrounding braces.

The driver applies these specs to its own command line between loadingdefault specs files (but not command-line specified ones) andchoosing the multilib directory or running any subcommands. Itapplies them in the order given, so each spec can depend on theoptions added by earlier ones. It is also possible to remove optionsusing ‘%<option’ in the usual way.

This macro can be useful when a port has several interdependent targetoptions. It provides a way of standardizing the command line sothat the other specs are easier to write.

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

Macro: OPTION_DEFAULT_SPECS

A list of specs used to support configure-time default options (i.e.--with options) in the driver. It should be a suitable initializerfor an array of structures, each containing two strings, without theoutermost pair of surrounding braces.

The first item in the pair is the name of the default. This must matchthe code in config.gcc for the target. The second item is a specto apply if a default with this name was specified. The string‘%(VALUE)’ in the spec will be replaced by the value of the defaulteverywhere it occurs.

The driver will apply these specs to its own command line between loadingdefault specs files and processing DRIVER_SELF_SPECS, usingthe same mechanism as DRIVER_SELF_SPECS.

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

Macro: CPP_SPEC

A C string constant that tells the GCC driver program options topass to CPP. It can also specify how to translate options yougive to GCC into options for GCC to pass to the CPP.

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

Macro: CPLUSPLUS_CPP_SPEC

This macro is just like CPP_SPEC, but is used for C++, ratherthan C. If you do not define this macro, then the value ofCPP_SPEC (if any) will be used instead.

Macro: CC1_SPEC

A C string constant that tells the GCC driver program options topass to cc1, cc1plus, f771, and the other languagefront ends.It can also specify how to translate options you give to GCC into optionsfor GCC to pass to front ends.

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

Macro: CC1PLUS_SPEC

A C string constant that tells the GCC driver program options topass to cc1plus. It can also specify how to translate options yougive to GCC into options for GCC to pass to the cc1plus.

Do not define this macro if it does not need to do anything.Note that everything defined in CC1_SPEC is already passed tocc1plus so there is no need to duplicate the contents ofCC1_SPEC in CC1PLUS_SPEC.

Macro: ASM_SPEC

A C string constant that tells the GCC driver program options topass to the assembler. It can also specify how to translate optionsyou give to GCC into options for GCC 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.

Macro: ASM_FINAL_SPEC

A C string constant that tells the GCC driver program how torun any programs which cleanup after the normal assembler.Normally, this is not needed. See the file mips.h foran example of this.

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

Macro: AS_NEEDS_DASH_FOR_PIPED_INPUT

Define this macro, with no value, if the driver should give the assembleran argument consisting of a single dash, -, to instruct it toread from its standard input (which will be a pipe connected to theoutput of the compiler proper). This argument is given after any-o option specifying the name of the output file.

If you do not define this macro, the assembler is assumed to read itsstandard input if given no non-option arguments. If your assemblercannot read standard input at all, use a ‘%{pipe:%e}’ construct;see mips.h for instance.

Macro: LINK_SPEC

A C string constant that tells the GCC driver program options topass to the linker. It can also specify how to translate options yougive to GCC into options for GCC to pass to the linker.

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

Macro: LIB_SPEC

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

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

Macro: LIBGCC_SPEC

Another C string constant that tells the GCC driver programhow and when to place a reference to libgcc.a into thelinker command line. This constant is placed both before and afterthe value of LIB_SPEC.

If this macro is not defined, the GCC driver provides a default thatpasses the string -lgcc to the linker.

Macro: REAL_LIBGCC_SPEC

By default, if ENABLE_SHARED_LIBGCC is defined, theLIBGCC_SPEC is not directly used by the driver program but isinstead modified to refer to different versions of libgcc.adepending on the values of the command line flags -static,-shared, -static-libgcc, and -shared-libgcc. Ontargets where these modifications are inappropriate, defineREAL_LIBGCC_SPEC instead. REAL_LIBGCC_SPEC tells thedriver how to place a reference to libgcc on the link commandline, but, unlike LIBGCC_SPEC, it is used unmodified.

Macro: USE_LD_AS_NEEDED

A macro that controls the modifications to LIBGCC_SPECmentioned in REAL_LIBGCC_SPEC. If nonzero, a spec will begenerated that uses --as-needed or equivalent options and theshared libgcc in place of thestatic exception handler library, when linking without any of-static, -static-libgcc, or -shared-libgcc.

Macro: LINK_EH_SPEC

If defined, this C string constant is added to LINK_SPEC.When USE_LD_AS_NEEDED is zero or undefined, it also affectsthe modifications to LIBGCC_SPEC mentioned inREAL_LIBGCC_SPEC.

Macro: STARTFILE_SPEC

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

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

Macro: ENDFILE_SPEC

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

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

Macro: THREAD_MODEL_SPEC

GCC -v will print the thread model GCC was configured to use.However, this doesn’t work on platforms that are multilibbed on threadmodels, such as AIX 4.3. On such platforms, defineTHREAD_MODEL_SPEC such that it evaluates to a string withoutblanks that names one of the recognized thread models. %*, thedefault value of this macro, will expand to the value ofthread_file set in config.gcc.

Macro: SYSROOT_SUFFIX_SPEC

Define this macro to add a suffix to the target sysroot when GCC isconfigured with a sysroot. This will cause GCC to search for usr/lib,et al, within sysroot+suffix.

Macro: SYSROOT_HEADERS_SUFFIX_SPEC

Define this macro to add a headers_suffix to the target sysroot whenGCC is configured with a sysroot. This will cause GCC to pass theupdated sysroot+headers_suffix to CPP, causing it to search forusr/include, et al, within sysroot+headers_suffix.

Macro: EXTRA_SPECS

Define this macro to provide additional specifications to put in thespecs file that can be used in various specifications likeCC1_SPEC.

The definition should be an initializer for an array of structures,containing a string constant, that defines the specification name, and astring 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 severalrelated targets, which have various …_SPECS which are similarto each other, and the maintainer would like one central place to keepthese definitions.

For example, the PowerPC System V.4 targets use EXTRA_SPECS todefine either _CALL_SYSV when the System V calling sequence isused or _CALL_AIX when the older AIX-based calling sequence isused.

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

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

while the config/rs6000/eabiaix.h target file definesCPP_SYSV_DEFAULT as:

Macro: LINK_LIBGCC_SPECIAL_1

Define this macro if the driver program should find the librarylibgcc.a. If you do not define this macro, the driver program will passthe argument -lgcc to tell the linker to do the search.

Macro: LINK_GCC_C_SEQUENCE_SPEC

The sequence in which libgcc and libc are specified to the linker.By default this is %G %L %G.

Macro: POST_LINK_SPEC

Define this macro to add additional steps to be executed after linker.The default value of this macro is empty string.

Macro: LINK_COMMAND_SPEC

A C string constant giving the complete command line need to execute thelinker. When you do this, you will need to update your port each time achange is made to the link command line within gcc.c. Therefore,define this macro only if you need to completely redefine the commandline for invoking the linker and there is no other way to accomplishthe effect you need. Overriding this macro may be avoidable by overridingLINK_GCC_C_SEQUENCE_SPEC instead.

Common Target Hook: boolTARGET_ALWAYS_STRIP_DOTDOT

True if .. components should always be removed from directory names computed relative to GCC’s internal directories, false (default) if such components should be preserved and directory names containing them passed to other tools such as the linker.

Macro: MULTILIB_DEFAULTS

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

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

Macro: RELATIVE_PREFIX_NOT_LINKDIR

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

Macro: MD_EXEC_PREFIX

If defined, this macro is an additional prefix to try afterSTANDARD_EXEC_PREFIX. MD_EXEC_PREFIX is not searchedwhen the compiler is built as a crosscompiler. If you define MD_EXEC_PREFIX, then be sure to add itto the list of directories used to find the assembler in configure.ac.

Macro: STANDARD_STARTFILE_PREFIX

Define this macro as a C string constant if you wish to override thestandard choice of libdir as the default prefix totry when searching for startup files such as crt0.o.STANDARD_STARTFILE_PREFIX is not searched when the compileris built as a cross compiler.

Gcc Expert Ii Software Download

Macro: STANDARD_STARTFILE_PREFIX_1

Define this macro as a C string constant if you wish to override thestandard choice of /lib as a prefix to try after the default prefixwhen searching for startup files such as crt0.o.STANDARD_STARTFILE_PREFIX_1 is not searched when the compileris built as a cross compiler.

Macro: STANDARD_STARTFILE_PREFIX_2

Define this macro as a C string constant if you wish to override thestandard choice of /lib as yet another prefix to try after thedefault prefix when searching for startup files such as crt0.o.STANDARD_STARTFILE_PREFIX_2 is not searched when the compileris built as a cross compiler.

Macro: MD_STARTFILE_PREFIX

If defined, this macro supplies an additional prefix to try after thestandard prefixes. MD_EXEC_PREFIX is not searched when thecompiler is built as a cross compiler.

Macro: MD_STARTFILE_PREFIX_1

If defined, this macro supplies yet another prefix to try after thestandard prefixes. It is not searched when the compiler is built as across compiler.

Macro: INIT_ENVIRONMENT

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

Macro: LOCAL_INCLUDE_DIR

Define this macro as a C string constant if you wish to override thestandard choice of /usr/local/include as the default prefix totry when searching for local header files. LOCAL_INCLUDE_DIRcomes before NATIVE_SYSTEM_HEADER_DIR (set inconfig.gcc, normally /usr/include) in the search order.

Cross compilers do not search either /usr/local/include or itsreplacement.

Macro: NATIVE_SYSTEM_HEADER_COMPONENT

Expert 24 Gcc Drivers

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

Macro: INCLUDE_DEFAULTS

Define this macro if you wish to override the entire default search pathfor include files. For a native compiler, the default search pathusually consists of GCC_INCLUDE_DIR, LOCAL_INCLUDE_DIR,GPLUSPLUS_INCLUDE_DIR, andNATIVE_SYSTEM_HEADER_DIR. In addition, GPLUSPLUS_INCLUDE_DIRand GCC_INCLUDE_DIR are defined automatically by Makefile,and specify private search areas for GCC. The directoryGPLUSPLUS_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 (astring constant), the component name (also a string constant), a flagfor C++-only directories,and a flag showing that the includes in the directory don’t need to bewrapped in extern ‘C’ when compiling C++. Mark the end ofthe array with a null element.

The component name denotes what GNU package the include file is part of,if any, in all uppercase letters. For example, it might be ‘GCC’or ‘BINUTILS’. If the package is part of a vendor-suppliedoperating system, code the component name as ‘0’.

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

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 or, if GCC_EXEC_PREFIXis not set and the compiler has not been installed in the configure-timeprefix, the location in which the compiler has actually been installed.
3. The directories specified by the environment variable COMPILER_PATH.
4. The macro STANDARD_EXEC_PREFIX, if the compiler has been installedin the configured-time prefix.
5. The location /usr/libexec/gcc/, but only if this is a native compiler.
6. The location /usr/lib/gcc/, but only if this is a native compiler.
7. The macro MD_EXEC_PREFIX, if defined, but only if this is a nativecompiler.

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 or its automatically determinedvalue based on the installed toolchain location.
3. The directories specified by the environment variable LIBRARY_PATH(or port-specific name; native only, cross compilers do not use this).
4. The macro STANDARD_EXEC_PREFIX, but only if the toolchain is installedin the configured prefix or this is a native compiler.
5. The location /usr/lib/gcc/, but only if this is a native compiler.
6. The macro MD_EXEC_PREFIX, if defined, but only if this is a nativecompiler.
7. The macro MD_STARTFILE_PREFIX, if defined, but only if this is anative compiler, or we have a target system root.
8. The macro MD_STARTFILE_PREFIX_1, if defined, but only if this is anative compiler, or we have a target system root.
9. The macro STANDARD_STARTFILE_PREFIX, with any sysroot modifications.If this path is relative it will be prefixed by GCC_EXEC_PREFIX andthe machine suffix or STANDARD_EXEC_PREFIX and the machine suffix.
10. The macro STANDARD_STARTFILE_PREFIX_1, but only if this is a nativecompiler, or we have a target system root. The default for this macro is/lib/.
11. The macro STANDARD_STARTFILE_PREFIX_2, but only if this is a nativecompiler, or we have a target system root. The default for this macro is/usr/lib/.

Next: Run-time Target, Previous: Target Structure, Up: Target Macros [Contents][Index]