Subversion Repositories openrisc

/* Compiler driver program that can handle many languages.

   Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,

   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,

   2010, 2011, 2012

   Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free

Software Foundation; either version 3, or (at your option) any later

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

/* This program is the user interface to the C compiler and possibly to

other compilers.  It is used because compilation is a complicated procedure

which involves running several programs and passing temporary files between

them, forwarding the users switches to those programs selectively,

and deleting the temporary files at the end.

CC recognizes how to compile each input file by suffixes in the file names.

Once it knows which kind of compilation to perform, the procedure for

compilation is specified by a string called a "spec".  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "multilib.h" /* before tm.h */

#include "tm.h"

#include "xregex.h"

#include "obstack.h"

#include "intl.h"

#include "prefix.h"

#include "gcc.h"

#include "diagnostic.h"

#include "flags.h"

#include "opts.h"

#include "params.h"

#include "vec.h"

#include "filenames.h"

/* By default there is no special suffix for target executables.  */

/* FIXME: when autoconf is fixed, remove the host check - dj */

#if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)

#define HAVE_TARGET_EXECUTABLE_SUFFIX

#endif

/* By default there is no special suffix for host executables.  */

#ifdef HOST_EXECUTABLE_SUFFIX

#define HAVE_HOST_EXECUTABLE_SUFFIX

#else

#define HOST_EXECUTABLE_SUFFIX ""

#endif

/* By default, the suffix for target object files is ".o".  */

#ifdef TARGET_OBJECT_SUFFIX

#define HAVE_TARGET_OBJECT_SUFFIX

#else

#define TARGET_OBJECT_SUFFIX ".o"

#endif

static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };

/* Most every one is fine with LIBRARY_PATH.  For some, it conflicts.  */

#ifndef LIBRARY_PATH_ENV

#define LIBRARY_PATH_ENV "LIBRARY_PATH"

#endif

/* If a stage of compilation returns an exit status >= 1,

   compilation of that file ceases.  */

#define MIN_FATAL_STATUS 1

/* Flag set by cppspec.c to 1.  */

int is_cpp_driver;

/* Flag set to nonzero if an @file argument has been supplied to gcc.  */

static bool at_file_supplied;

/* Definition of string containing the arguments given to configure.  */

#include "configargs.h"

/* Flag saying to print the command line options understood by gcc and its

   sub-processes.  */

static int print_help_list;

/* Flag saying to print the version of gcc and its sub-processes.  */

static int print_version;

/* Flag indicating whether we should ONLY print the command and

   arguments (like verbose_flag) without executing the command.

   Displayed arguments are quoted so that the generated command

   line is suitable for execution.  This is intended for use in

   shell scripts to capture the driver-generated command line.  */

static int verbose_only_flag;

/* Flag indicating how to print command line options of sub-processes.  */

static int print_subprocess_help;

/* Whether we should report subprocess execution times to a file.  */

FILE *report_times_to_file = NULL;

/* Nonzero means place this string before uses of /, so that include

   and library files can be found in an alternate location.  */

#ifdef TARGET_SYSTEM_ROOT

static const char *target_system_root = TARGET_SYSTEM_ROOT;

#else

static const char *target_system_root = 0;

#endif

/* Nonzero means pass the updated target_system_root to the compiler.  */

static int target_system_root_changed;

/* Nonzero means append this string to target_system_root.  */

static const char *target_sysroot_suffix = 0;

/* Nonzero means append this string to target_system_root for headers.  */

static const char *target_sysroot_hdrs_suffix = 0;

/* Nonzero means write "temp" files in source directory

   and use the source file's name in them, and don't delete them.  */

static enum save_temps {

  SAVE_TEMPS_NONE,              /* no -save-temps */

  SAVE_TEMPS_CWD,               /* -save-temps in current directory */

  SAVE_TEMPS_OBJ                /* -save-temps in object directory */

} save_temps_flag;

/* Output file to use to get the object directory for -save-temps=obj  */

static char *save_temps_prefix = 0;

static size_t save_temps_length = 0;

/* The compiler version.  */

static const char *compiler_version;

/* The target version.  */

static const char *const spec_version = DEFAULT_TARGET_VERSION;

/* The target machine.  */

static const char *spec_machine = DEFAULT_TARGET_MACHINE;

/* Nonzero if cross-compiling.

   When -b is used, the value comes from the `specs' file.  */

#ifdef CROSS_DIRECTORY_STRUCTURE

static const char *cross_compile = "1";

#else

static const char *cross_compile = "0";

#endif

/* Greatest exit code of sub-processes that has been encountered up to

   now.  */

static int greatest_status = 1;

/* This is the obstack which we use to allocate many strings.  */

static struct obstack obstack;

/* This is the obstack to build an environment variable to pass to

   collect2 that describes all of the relevant switches of what to

   pass the compiler in building the list of pointers to constructors

   and destructors.  */

static struct obstack collect_obstack;

/* Forward declaration for prototypes.  */

struct path_prefix;

struct prefix_list;

static void init_spec (void);

static void store_arg (const char *, int, int);

static void insert_wrapper (const char *);

static char *load_specs (const char *);

static void read_specs (const char *, int);

static void set_spec (const char *, const char *);

static struct compiler *lookup_compiler (const char *, size_t, const char *);

static char *build_search_list (const struct path_prefix *, const char *,

                                bool, bool);

static void xputenv (const char *);

static void putenv_from_prefixes (const struct path_prefix *, const char *,

                                  bool);

static int access_check (const char *, int);

static char *find_a_file (const struct path_prefix *, const char *, int, bool);

static void add_prefix (struct path_prefix *, const char *, const char *,

                        int, int, int);

static void add_sysrooted_prefix (struct path_prefix *, const char *,

                                  const char *, int, int, int);

static char *skip_whitespace (char *);

static void delete_if_ordinary (const char *);

static void delete_temp_files (void);

static void delete_failure_queue (void);

static void clear_failure_queue (void);

static int check_live_switch (int, int);

static const char *handle_braces (const char *);

static inline bool input_suffix_matches (const char *, const char *);

static inline bool switch_matches (const char *, const char *, int);

static inline void mark_matching_switches (const char *, const char *, int);

static inline void process_marked_switches (void);

static const char *process_brace_body (const char *, const char *, const char *, int, int);

static const struct spec_function *lookup_spec_function (const char *);

static const char *eval_spec_function (const char *, const char *);

static const char *handle_spec_function (const char *);

static char *save_string (const char *, int);

static void set_collect_gcc_options (void);

static int do_spec_1 (const char *, int, const char *);

static int do_spec_2 (const char *);

static void do_option_spec (const char *, const char *);

static void do_self_spec (const char *);

static const char *find_file (const char *);

static int is_directory (const char *, bool);

static const char *validate_switches (const char *);

static void validate_all_switches (void);

static inline void validate_switches_from_spec (const char *);

static void give_switch (int, int);

static int used_arg (const char *, int);

static int default_arg (const char *, int);

static void set_multilib_dir (void);

static void print_multilib_info (void);

static void perror_with_name (const char *);

static void display_help (void);

static void add_preprocessor_option (const char *, int);

static void add_assembler_option (const char *, int);

static void add_linker_option (const char *, int);

static void process_command (unsigned int, struct cl_decoded_option *);

static int execute (void);

static void alloc_args (void);

static void clear_args (void);

static void fatal_signal (int);

#if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)

static void init_gcc_specs (struct obstack *, const char *, const char *,

                            const char *);

#endif

#if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)

static const char *convert_filename (const char *, int, int);

#endif

static const char *getenv_spec_function (int, const char **);

static const char *if_exists_spec_function (int, const char **);

static const char *if_exists_else_spec_function (int, const char **);

static const char *replace_outfile_spec_function (int, const char **);

static const char *remove_outfile_spec_function (int, const char **);

static const char *version_compare_spec_function (int, const char **);

static const char *include_spec_function (int, const char **);

static const char *find_file_spec_function (int, const char **);

static const char *find_plugindir_spec_function (int, const char **);

static const char *print_asm_header_spec_function (int, const char **);

static const char *compare_debug_dump_opt_spec_function (int, const char **);

static const char *compare_debug_self_opt_spec_function (int, const char **);

static const char *compare_debug_auxbase_opt_spec_function (int, const char **);

static const char *pass_through_libs_spec_func (int, const char **);

/* The Specs Language

Specs are strings containing lines, each of which (if not blank)

is made up of a program name, and arguments separated by spaces.

The program name must be exact and start from root, since no path

is searched and it is unreliable to depend on the current working directory.

Redirection of input or output is not supported; the subprograms must

accept filenames saying what files to read and write.

In addition, the specs can contain %-sequences to substitute variable text

or for conditional text.  Here is a table of all defined %-sequences.

Note that spaces are not generated automatically around the results of

expanding these sequences; therefore, you can concatenate them together

or with constant text in a single argument.

 %%     substitute one % into the program name or argument.

 %i     substitute the name of the input file being processed.

 %b     substitute the basename of the input file being processed.

        This is the substring up to (and not including) the last period

        and not including the directory unless -save-temps was specified

        to put temporaries in a different location.

 %B     same as %b, but include the file suffix (text after the last period).

 %gSUFFIX

        substitute a file name that has suffix SUFFIX and is chosen

        once per compilation, and mark the argument a la %d.  To reduce

        exposure to denial-of-service attacks, the file name is now

        chosen in a way that is hard to predict even when previously

        chosen file names are known.  For example, `%g.s ... %g.o ... %g.s'

        might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'.  SUFFIX matches

        the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it

        had been pre-processed.  Previously, %g was simply substituted

        with a file name chosen once per compilation, without regard

        to any appended suffix (which was therefore treated just like

        ordinary text), making such attacks more likely to succeed.

 %|SUFFIX

        like %g, but if -pipe is in effect, expands simply to "-".

 %mSUFFIX

        like %g, but if -pipe is in effect, expands to nothing.  (We have both

        %| and %m to accommodate differences between system assemblers; see

        the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)

 %uSUFFIX

        like %g, but generates a new temporary file name even if %uSUFFIX

        was already seen.

 %USUFFIX

        substitutes the last file name generated with %uSUFFIX, generating a

        new one if there is no such last file name.  In the absence of any

        %uSUFFIX, this is just like %gSUFFIX, except they don't share

        the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'

        would involve the generation of two distinct file names, one

        for each `%g.s' and another for each `%U.s'.  Previously, %U was

        simply substituted with a file name chosen for the previous %u,

        without regard to any appended suffix.

 %jSUFFIX

        substitutes the name of the HOST_BIT_BUCKET, if any, and if it is

        writable, and if save-temps is off; otherwise, substitute the name

        of a temporary file, just like %u.  This temporary file is not

        meant for communication between processes, but rather as a junk

        disposal mechanism.

 %.SUFFIX

        substitutes .SUFFIX for the suffixes of a matched switch's args when

        it is subsequently output with %*. SUFFIX is terminated by the next

        space or %.

 %d     marks the argument containing or following the %d as a

        temporary file name, so that that file will be deleted if GCC exits

        successfully.  Unlike %g, this contributes no text to the argument.

 %w     marks the argument containing or following the %w as the

        "output file" of this compilation.  This puts the argument

        into the sequence of arguments that %o will substitute later.

 %V     indicates that this compilation produces no "output file".

 %W{...}

        like %{...} but mark last argument supplied within

        as a file to be deleted on failure.

 %o     substitutes the names of all the output files, with spaces

        automatically placed around them.  You should write spaces

        around the %o as well or the results are undefined.

        %o is for use in the specs for running the linker.

        Input files whose names have no recognized suffix are not compiled

        at all, but they are included among the output files, so they will

        be linked.

 %O     substitutes the suffix for object files.  Note that this is

        handled specially when it immediately follows %g, %u, or %U

        (with or without a suffix argument) because of the need for

        those to form complete file names.  The handling is such that

        %O is treated exactly as if it had already been substituted,

        except that %g, %u, and %U do not currently support additional

        SUFFIX characters following %O as they would following, for

        example, `.o'.

 %I     Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot

        (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH

        and -B options) and -imultilib as necessary.

 %s     current argument is the name of a library or startup file of some sort.

        Search for that file in a standard list of directories

        and substitute the full name found.

 %eSTR  Print STR as an error message.  STR is terminated by a newline.

        Use this when inconsistent options are detected.

 %nSTR  Print STR as a notice.  STR is terminated by a newline.

 %x{OPTION}     Accumulate an option for %X.

 %X     Output the accumulated linker options specified by compilations.

 %Y     Output the accumulated assembler options specified by compilations.

 %Z     Output the accumulated preprocessor options specified by compilations.

 %a     process ASM_SPEC as a spec.

        This allows config.h to specify part of the spec for running as.

 %A     process ASM_FINAL_SPEC as a spec.  A capital A is actually

        used here.  This can be used to run a post-processor after the

        assembler has done its job.

 %D     Dump out a -L option for each directory in startfile_prefixes.

        If multilib_dir is set, extra entries are generated with it affixed.

 %l     process LINK_SPEC as a spec.

 %L     process LIB_SPEC as a spec.

 %G     process LIBGCC_SPEC as a spec.

 %R     Output the concatenation of target_system_root and

        target_sysroot_suffix.

 %S     process STARTFILE_SPEC as a spec.  A capital S is actually used here.

 %E     process ENDFILE_SPEC as a spec.  A capital E is actually used here.

 %C     process CPP_SPEC as a spec.

 %1     process CC1_SPEC as a spec.

 %2     process CC1PLUS_SPEC as a spec.

 %*     substitute the variable part of a matched option.  (See below.)

        Note that each comma in the substituted string is replaced by

        a single space.

 %<S    remove all occurrences of -S from the command line.

        Note - this command is position dependent.  % commands in the

        spec string before this one will see -S, % commands in the

        spec string after this one will not.

 %>S    Similar to "%<S", but keep it in the GCC command line.

 %<S*   remove all occurrences of all switches beginning with -S from the

        command line.

 %:function(args)

        Call the named function FUNCTION, passing it ARGS.  ARGS is

        first processed as a nested spec string, then split into an

        argument vector in the usual fashion.  The function returns

        a string which is processed as if it had appeared literally

        as part of the current spec.

 %{S}   substitutes the -S switch, if that switch was given to GCC.

        If that switch was not specified, this substitutes nothing.

        Here S is a metasyntactic variable.

 %{S*}  substitutes all the switches specified to GCC whose names start

        with -S.  This is used for -o, -I, etc; switches that take

        arguments.  GCC considers `-o foo' as being one switch whose

        name starts with `o'.  %{o*} would substitute this text,

        including the space; thus, two arguments would be generated.

 %{S*&T*} likewise, but preserve order of S and T options (the order

        of S and T in the spec is not significant).  Can be any number

        of ampersand-separated variables; for each the wild card is

        optional.  Useful for CPP as %{D*&U*&A*}.

 %{S:X}   substitutes X, if the -S switch was given to GCC.

 %{!S:X}  substitutes X, if the -S switch was NOT given to GCC.

 %{S*:X}  substitutes X if one or more switches whose names start

          with -S was given to GCC.  Normally X is substituted only

          once, no matter how many such switches appeared.  However,

          if %* appears somewhere in X, then X will be substituted

          once for each matching switch, with the %* replaced by the

          part of that switch that matched the '*'.

 %{.S:X}  substitutes X, if processing a file with suffix S.

 %{!.S:X} substitutes X, if NOT processing a file with suffix S.

 %{,S:X}  substitutes X, if processing a file which will use spec S.

 %{!,S:X} substitutes X, if NOT processing a file which will use spec S.

 %{S|T:X} substitutes X if either -S or -T was given to GCC.  This may be

          combined with '!', '.', ',', and '*' as above binding stronger

          than the OR.

          If %* appears in X, all of the alternatives must be starred, and

          only the first matching alternative is substituted.

 %{S:X;   if S was given to GCC, substitutes X;

   T:Y;   else if T was given to GCC, substitutes Y;

    :D}   else substitutes D.  There can be as many clauses as you need.

          This may be combined with '.', '!', ',', '|', and '*' as above.

 %(Spec) processes a specification defined in a specs file as *Spec:

The conditional text X in a %{S:X} or similar construct may contain

other nested % constructs or spaces, or even newlines.  They are

processed as usual, as described above.  Trailing white space in X is

ignored.  White space may also appear anywhere on the left side of the

colon in these constructs, except between . or * and the corresponding

word.

The -O, -f, -m, and -W switches are handled specifically in these

constructs.  If another value of -O or the negated form of a -f, -m, or

-W switch is found later in the command line, the earlier switch

value is ignored, except with {S*} where S is just one letter; this

passes all matching options.

The character | at the beginning of the predicate text is used to indicate

that a command should be piped to the following command, but only if -pipe

is specified.

Note that it is built into GCC which switches take arguments and which

do not.  You might think it would be useful to generalize this to

allow each compiler's spec to say which switches take arguments.  But

this cannot be done in a consistent fashion.  GCC cannot even decide

which input files have been specified without knowing which switches

take arguments, and it must know which input files to compile in order

to tell which compilers to run.

GCC also knows implicitly that arguments starting in `-l' are to be

treated as compiler output files, and passed to the linker in their

proper position among the other output files.  */

/* Define the macros used for specs %a, %l, %L, %S, %C, %1.  */

/* config.h can define ASM_SPEC to provide extra args to the assembler

   or extra switch-translations.  */

#ifndef ASM_SPEC

#define ASM_SPEC ""

#endif

/* config.h can define ASM_FINAL_SPEC to run a post processor after

   the assembler has run.  */

#ifndef ASM_FINAL_SPEC

#define ASM_FINAL_SPEC ""

#endif

/* config.h can define CPP_SPEC to provide extra args to the C preprocessor

   or extra switch-translations.  */

#ifndef CPP_SPEC

#define CPP_SPEC ""

#endif

/* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus

   or extra switch-translations.  */

#ifndef CC1_SPEC

#define CC1_SPEC ""

#endif

/* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus

   or extra switch-translations.  */

#ifndef CC1PLUS_SPEC

#define CC1PLUS_SPEC ""

#endif

/* config.h can define LINK_SPEC to provide extra args to the linker

   or extra switch-translations.  */

#ifndef LINK_SPEC

#define LINK_SPEC ""

#endif

/* config.h can define LIB_SPEC to override the default libraries.  */

#ifndef LIB_SPEC

#define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"

#endif

/* mudflap specs */

#ifndef MFWRAP_SPEC

/* XXX: valid only for GNU ld */

/* XXX: should exactly match hooks provided by libmudflap.a */

#define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \

 --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\

 --wrap=mmap --wrap=mmap64 --wrap=munmap --wrap=alloca\

} %{fmudflapth: --wrap=pthread_create\

}} %{fmudflap|fmudflapth: --wrap=main}"

#endif

#ifndef MFLIB_SPEC

#define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"

#endif

/* When using -fsplit-stack we need to wrap pthread_create, in order

   to initialize the stack guard.  We always use wrapping, rather than

   shared library ordering, and we keep the wrapper function in

   libgcc.  This is not yet a real spec, though it could become one;

   it is currently just stuffed into LINK_SPEC.  FIXME: This wrapping

   only works with GNU ld and gold.  FIXME: This is incompatible with

   -fmudflap when linking statically, which wants to do its own

   wrapping.  */

#define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"

/* config.h can define LIBGCC_SPEC to override how and when libgcc.a is

   included.  */

#ifndef LIBGCC_SPEC

#if defined(REAL_LIBGCC_SPEC)

#define LIBGCC_SPEC REAL_LIBGCC_SPEC

#elif defined(LINK_LIBGCC_SPECIAL_1)

/* Have gcc do the search for libgcc.a.  */

#define LIBGCC_SPEC "libgcc.a%s"

#else

#define LIBGCC_SPEC "-lgcc"

#endif

#endif

/* config.h can define STARTFILE_SPEC to override the default crt0 files.  */

#ifndef STARTFILE_SPEC

#define STARTFILE_SPEC  \

  "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"

#endif

/* config.h can define ENDFILE_SPEC to override the default crtn files.  */

#ifndef ENDFILE_SPEC

#define ENDFILE_SPEC ""

#endif

#ifndef LINKER_NAME

#define LINKER_NAME "collect2"

#endif

#ifdef HAVE_AS_DEBUG_PREFIX_MAP

#define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"

#else

#define ASM_MAP ""

#endif

/* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'

   to the assembler.  */

#ifndef ASM_DEBUG_SPEC

# if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \

     && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)

#  define ASM_DEBUG_SPEC                                                \

      (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG                            \

       ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP    \

       : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)

# else

#  if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)

#   define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP

#  endif

#  if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)

#   define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP

#  endif

# endif

#endif

#ifndef ASM_DEBUG_SPEC

# define ASM_DEBUG_SPEC ""

#endif

/* Here is the spec for running the linker, after compiling all files.  */

/* This is overridable by the target in case they need to specify the

   -lgcc and -lc order specially, yet not require them to override all

   of LINK_COMMAND_SPEC.  */

#ifndef LINK_GCC_C_SEQUENCE_SPEC

#define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"

#endif

#ifndef LINK_SSP_SPEC

#ifdef TARGET_LIBC_PROVIDES_SSP

#define LINK_SSP_SPEC "%{fstack-protector:}"

#else

#define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"

#endif

#endif

#ifndef LINK_PIE_SPEC

#ifdef HAVE_LD_PIE

#define LINK_PIE_SPEC "%{pie:-pie} "

#else

#define LINK_PIE_SPEC "%{pie:} "

#endif

#endif

#ifndef LINK_BUILDID_SPEC

# if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)

#  define LINK_BUILDID_SPEC "%{!r:--build-id} "

# endif

#endif

/* Conditional to test whether the LTO plugin is used or not.

   FIXME: For slim LTO we will need to enable plugin unconditionally.  This

   still cause problems with PLUGIN_LD != LD and when plugin is built but

   not useable.  For GCC 4.6 we don't support slim LTO and thus we can enable

   plugin only when LTO is enabled.  We still honor explicit

   -fuse-linker-plugin if the linker used understands -plugin.  */

/* The linker has some plugin support.  */

#if HAVE_LTO_PLUGIN > 0

/* The linker used has full plugin support, use LTO plugin by default.  */

#if HAVE_LTO_PLUGIN == 2

#define PLUGIN_COND "!fno-use-linker-plugin:%{flto|flto=*|fuse-linker-plugin"

#define PLUGIN_COND_CLOSE "}"

#else

/* The linker used has limited plugin support, use LTO plugin with explicit

   -fuse-linker-plugin.  */

#define PLUGIN_COND "fuse-linker-plugin"

#define PLUGIN_COND_CLOSE ""

#endif

#define LINK_PLUGIN_SPEC \

    "%{"PLUGIN_COND": \

    -plugin %(linker_plugin_file) \

    -plugin-opt=%(lto_wrapper) \

    -plugin-opt=-fresolution=%u.res \

    %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \

    }"PLUGIN_COND_CLOSE

#else

/* The linker used doesn't support -plugin, reject -fuse-linker-plugin.  */

#define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\

    %e-fuse-linker-plugin is not supported in this configuration}"

#endif

/* -u* was put back because both BSD and SysV seem to support it.  */

/* %{static:} simply prevents an error message if the target machine

   doesn't handle -static.  */

/* We want %{T*} after %{L*} and %D so that it can be used to specify linker

   scripts which exist in user specified directories, or in standard

   directories.  */

/* We pass any -flto flags on to the linker, which is expected

   to understand them.  In practice, this means it had better be collect2.  */

/* %{e*} includes -export-dynamic; see comment in common.opt.  */

#ifndef LINK_COMMAND_SPEC

#define LINK_COMMAND_SPEC "\

%{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\

    %(linker) " \

    LINK_PLUGIN_SPEC \

    "%{flto|flto=*:%<fcompare-debug*} \

    %{flto} %{flto=*} %l " LINK_PIE_SPEC \

   "%X %{o*} %{e*} %{N} %{n} %{r}\

    %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}}\

    %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\

    %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)}\

    %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\

    %(mflib) " STACK_SPLIT_SPEC "\

    %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\

    %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\

    %{!nostdlib:%{!nostartfiles:%E}} %{T*} }}}}}}"

#endif

#ifndef LINK_LIBGCC_SPEC

/* Generate -L options for startfile prefix list.  */

# define LINK_LIBGCC_SPEC "%D"

#endif

#ifndef STARTFILE_PREFIX_SPEC

# define STARTFILE_PREFIX_SPEC ""

#endif

#ifndef SYSROOT_SPEC

# define SYSROOT_SPEC "--sysroot=%R"

#endif

#ifndef SYSROOT_SUFFIX_SPEC

# define SYSROOT_SUFFIX_SPEC ""

#endif

#ifndef SYSROOT_HEADERS_SUFFIX_SPEC

# define SYSROOT_HEADERS_SUFFIX_SPEC ""

#endif

static const char *asm_debug;

static const char *cpp_spec = CPP_SPEC;

static const char *cc1_spec = CC1_SPEC;

static const char *cc1plus_spec = CC1PLUS_SPEC;

static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;

static const char *link_ssp_spec = LINK_SSP_SPEC;

static const char *asm_spec = ASM_SPEC;

static const char *asm_final_spec = ASM_FINAL_SPEC;

static const char *link_spec = LINK_SPEC;

static const char *lib_spec = LIB_SPEC;

static const char *mfwrap_spec = MFWRAP_SPEC;

static const char *mflib_spec = MFLIB_SPEC;

static const char *link_gomp_spec = "";

static const char *libgcc_spec = LIBGCC_SPEC;

static const char *endfile_spec = ENDFILE_SPEC;

static const char *startfile_spec = STARTFILE_SPEC;

static const char *linker_name_spec = LINKER_NAME;

static const char *linker_plugin_file_spec = "";

static const char *lto_wrapper_spec = "";

static const char *lto_gcc_spec = "";

static const char *link_command_spec = LINK_COMMAND_SPEC;

static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;

static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;

static const char *sysroot_spec = SYSROOT_SPEC;

static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;

static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;

static const char *self_spec = "";

/* Standard options to cpp, cc1, and as, to reduce duplication in specs.

   There should be no need to override these in target dependent files,

   but we need to copy them to the specs file so that newer versions

   of the GCC driver can correctly drive older tool chains with the

   appropriate -B options.  */

/* When cpplib handles traditional preprocessing, get rid of this, and