gcc/gcc.c

   1 /* Compiler driver program that can handle many languages.
   2    Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
   4    2010, 2011, 2012
   5    Free Software Foundation, Inc.
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 3, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23 /* This program is the user interface to the C compiler and possibly to
  24 other compilers.  It is used because compilation is a complicated procedure
  25 which involves running several programs and passing temporary files between
  26 them, forwarding the users switches to those programs selectively,
  27 and deleting the temporary files at the end.
  28
  29 CC recognizes how to compile each input file by suffixes in the file names.
  30 Once it knows which kind of compilation to perform, the procedure for
  31 compilation is specified by a string called a "spec".  */
  32
  33 #include "config.h"
  34 #include "system.h"
  35 #include "coretypes.h"
  36 #include "multilib.h" /* before tm.h */
  37 #include "tm.h"
  38 #include "xregex.h"
  39 #include "obstack.h"
  40 #include "intl.h"
  41 #include "prefix.h"
  42 #include "gcc.h"
  43 #include "diagnostic.h"
  44 #include "flags.h"
  45 #include "opts.h"
  46 #include "params.h"
  47 #include "vec.h"
  48 #include "filenames.h"
  49
  50 /* By default there is no special suffix for target executables.  */
  51 /* FIXME: when autoconf is fixed, remove the host check - dj */
  52 #if defined(TARGET_EXECUTABLE_SUFFIX) && defined(HOST_EXECUTABLE_SUFFIX)
  53 #define HAVE_TARGET_EXECUTABLE_SUFFIX
  54 #endif
  55
  56 /* By default there is no special suffix for host executables.  */
  57 #ifdef HOST_EXECUTABLE_SUFFIX
  58 #define HAVE_HOST_EXECUTABLE_SUFFIX
  59 #else
  60 #define HOST_EXECUTABLE_SUFFIX ""
  61 #endif
  62
  63 /* By default, the suffix for target object files is ".o".  */
  64 #ifdef TARGET_OBJECT_SUFFIX
  65 #define HAVE_TARGET_OBJECT_SUFFIX
  66 #else
  67 #define TARGET_OBJECT_SUFFIX ".o"
  68 #endif
  69
  70 static const char dir_separator_str[] = { DIR_SEPARATOR, 0 };
  71
  72 /* Most every one is fine with LIBRARY_PATH.  For some, it conflicts.  */
  73 #ifndef LIBRARY_PATH_ENV
  74 #define LIBRARY_PATH_ENV "LIBRARY_PATH"
  75 #endif
  76
  77 /* If a stage of compilation returns an exit status >= 1,
  78    compilation of that file ceases.  */
  79
  80 #define MIN_FATAL_STATUS 1
  81
  82 /* Flag set by cppspec.c to 1.  */
  83 int is_cpp_driver;
  84
  85 /* Flag set to nonzero if an @file argument has been supplied to gcc.  */
  86 static bool at_file_supplied;
  87
  88 /* Definition of string containing the arguments given to configure.  */
  89 #include "configargs.h"
  90
  91 /* Flag saying to print the command line options understood by gcc and its
  92    sub-processes.  */
  93
  94 static int print_help_list;
  95
  96 /* Flag saying to print the version of gcc and its sub-processes.  */
  97
  98 static int print_version;
  99
 100 /* Flag indicating whether we should ONLY print the command and
 101    arguments (like verbose_flag) without executing the command.
 102    Displayed arguments are quoted so that the generated command
 103    line is suitable for execution.  This is intended for use in
 104    shell scripts to capture the driver-generated command line.  */
 105 static int verbose_only_flag;
 106
 107 /* Flag indicating how to print command line options of sub-processes.  */
 108
 109 static int print_subprocess_help;
 110
 111 /* Whether we should report subprocess execution times to a file.  */
 112
 113 FILE *report_times_to_file = NULL;
 114
 115 /* Nonzero means place this string before uses of /, so that include
 116    and library files can be found in an alternate location.  */
 117
 118 #ifdef TARGET_SYSTEM_ROOT
 119 static const char *target_system_root = TARGET_SYSTEM_ROOT;
 120 #else
 121 static const char *target_system_root = 0;
 122 #endif
 123
 124 /* Nonzero means pass the updated target_system_root to the compiler.  */
 125
 126 static int target_system_root_changed;
 127
 128 /* Nonzero means append this string to target_system_root.  */
 129
 130 static const char *target_sysroot_suffix = 0;
 131
 132 /* Nonzero means append this string to target_system_root for headers.  */
 133
 134 static const char *target_sysroot_hdrs_suffix = 0;
 135
 136 /* Nonzero means write "temp" files in source directory
 137    and use the source file's name in them, and don't delete them.  */
 138
 139 static enum save_temps {
 140   SAVE_TEMPS_NONE,              /* no -save-temps */
 141   SAVE_TEMPS_CWD,               /* -save-temps in current directory */
 142   SAVE_TEMPS_OBJ                /* -save-temps in object directory */
 143 } save_temps_flag;
 144
 145 /* Output file to use to get the object directory for -save-temps=obj  */
 146 static char *save_temps_prefix = 0;
 147 static size_t save_temps_length = 0;
 148
 149 /* The compiler version.  */
 150
 151 static const char *compiler_version;
 152
 153 /* The target version.  */
 154
 155 static const char *const spec_version = DEFAULT_TARGET_VERSION;
 156
 157 /* The target machine.  */
 158
 159 static const char *spec_machine = DEFAULT_TARGET_MACHINE;
 160
 161 /* Nonzero if cross-compiling.
 162    When -b is used, the value comes from the `specs' file.  */
 163
 164 #ifdef CROSS_DIRECTORY_STRUCTURE
 165 static const char *cross_compile = "1";
 166 #else
 167 static const char *cross_compile = "0";
 168 #endif
 169
 170 /* Greatest exit code of sub-processes that has been encountered up to
 171    now.  */
 172 static int greatest_status = 1;
 173
 174 /* This is the obstack which we use to allocate many strings.  */
 175
 176 static struct obstack obstack;
 177
 178 /* This is the obstack to build an environment variable to pass to
 179    collect2 that describes all of the relevant switches of what to
 180    pass the compiler in building the list of pointers to constructors
 181    and destructors.  */
 182
 183 static struct obstack collect_obstack;
 184
 185 /* Forward declaration for prototypes.  */
 186 struct path_prefix;
 187 struct prefix_list;
 188
 189 static void init_spec (void);
 190 static void store_arg (const char *, int, int);
 191 static void insert_wrapper (const char *);
 192 static char *load_specs (const char *);
 193 static void read_specs (const char *, bool, bool);
 194 static void set_spec (const char *, const char *, bool);
 195 static struct compiler *lookup_compiler (const char *, size_t, const char *);
 196 static char *build_search_list (const struct path_prefix *, const char *,
 197                                 bool, bool);
 198 static void xputenv (const char *);
 199 static void putenv_from_prefixes (const struct path_prefix *, const char *,
 200                                   bool);
 201 static int access_check (const char *, int);
 202 static char *find_a_file (const struct path_prefix *, const char *, int, bool);
 203 static void add_prefix (struct path_prefix *, const char *, const char *,
 204                         int, int, int);
 205 static void add_sysrooted_prefix (struct path_prefix *, const char *,
 206                                   const char *, int, int, int);
 207 static char *skip_whitespace (char *);
 208 static void delete_if_ordinary (const char *);
 209 static void delete_temp_files (void);
 210 static void delete_failure_queue (void);
 211 static void clear_failure_queue (void);
 212 static int check_live_switch (int, int);
 213 static const char *handle_braces (const char *);
 214 static inline bool input_suffix_matches (const char *, const char *);
 215 static inline bool switch_matches (const char *, const char *, int);
 216 static inline void mark_matching_switches (const char *, const char *, int);
 217 static inline void process_marked_switches (void);
 218 static const char *process_brace_body (const char *, const char *, const char *, int, int);
 219 static const struct spec_function *lookup_spec_function (const char *);
 220 static const char *eval_spec_function (const char *, const char *);
 221 static const char *handle_spec_function (const char *);
 222 static char *save_string (const char *, int);
 223 static void set_collect_gcc_options (void);
 224 static int do_spec_1 (const char *, int, const char *);
 225 static int do_spec_2 (const char *);
 226 static void do_option_spec (const char *, const char *);
 227 static void do_self_spec (const char *);
 228 static const char *find_file (const char *);
 229 static int is_directory (const char *, bool);
 230 static const char *validate_switches (const char *, bool);
 231 static void validate_all_switches (void);
 232 static inline void validate_switches_from_spec (const char *, bool);
 233 static void give_switch (int, int);
 234 static int used_arg (const char *, int);
 235 static int default_arg (const char *, int);
 236 static void set_multilib_dir (void);
 237 static void print_multilib_info (void);
 238 static void perror_with_name (const char *);
 239 static void display_help (void);
 240 static void add_preprocessor_option (const char *, int);
 241 static void add_assembler_option (const char *, int);
 242 static void add_linker_option (const char *, int);
 243 static void process_command (unsigned int, struct cl_decoded_option *);
 244 static int execute (void);
 245 static void alloc_args (void);
 246 static void clear_args (void);
 247 static void fatal_signal (int);
 248 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
 249 static void init_gcc_specs (struct obstack *, const char *, const char *,
 250                             const char *);
 251 #endif
 252 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
 253 static const char *convert_filename (const char *, int, int);
 254 #endif
 255
 256 static const char *getenv_spec_function (int, const char **);
 257 static const char *if_exists_spec_function (int, const char **);
 258 static const char *if_exists_else_spec_function (int, const char **);
 259 static const char *replace_outfile_spec_function (int, const char **);
 260 static const char *remove_outfile_spec_function (int, const char **);
 261 static const char *version_compare_spec_function (int, const char **);
 262 static const char *include_spec_function (int, const char **);
 263 static const char *find_file_spec_function (int, const char **);
 264 static const char *find_plugindir_spec_function (int, const char **);
 265 static const char *print_asm_header_spec_function (int, const char **);
 266 static const char *compare_debug_dump_opt_spec_function (int, const char **);
 267 static const char *compare_debug_self_opt_spec_function (int, const char **);
 268 static const char *compare_debug_auxbase_opt_spec_function (int, const char **);
 269 static const char *pass_through_libs_spec_func (int, const char **);
 270 static const char *replace_extension_spec_func (int, const char **);
 271 \f
 272 /* The Specs Language
 273
 274 Specs are strings containing lines, each of which (if not blank)
 275 is made up of a program name, and arguments separated by spaces.
 276 The program name must be exact and start from root, since no path
 277 is searched and it is unreliable to depend on the current working directory.
 278 Redirection of input or output is not supported; the subprograms must
 279 accept filenames saying what files to read and write.
 280
 281 In addition, the specs can contain %-sequences to substitute variable text
 282 or for conditional text.  Here is a table of all defined %-sequences.
 283 Note that spaces are not generated automatically around the results of
 284 expanding these sequences; therefore, you can concatenate them together
 285 or with constant text in a single argument.
 286
 287  %%     substitute one % into the program name or argument.
 288  %i     substitute the name of the input file being processed.
 289  %b     substitute the basename of the input file being processed.
 290         This is the substring up to (and not including) the last period
 291         and not including the directory unless -save-temps was specified
 292         to put temporaries in a different location.
 293  %B     same as %b, but include the file suffix (text after the last period).
 294  %gSUFFIX
 295         substitute a file name that has suffix SUFFIX and is chosen
 296         once per compilation, and mark the argument a la %d.  To reduce
 297         exposure to denial-of-service attacks, the file name is now
 298         chosen in a way that is hard to predict even when previously
 299         chosen file names are known.  For example, `%g.s ... %g.o ... %g.s'
 300         might turn into `ccUVUUAU.s ccXYAXZ12.o ccUVUUAU.s'.  SUFFIX matches
 301         the regexp "[.0-9A-Za-z]*%O"; "%O" is treated exactly as if it
 302         had been pre-processed.  Previously, %g was simply substituted
 303         with a file name chosen once per compilation, without regard
 304         to any appended suffix (which was therefore treated just like
 305         ordinary text), making such attacks more likely to succeed.
 306  %|SUFFIX
 307         like %g, but if -pipe is in effect, expands simply to "-".
 308  %mSUFFIX
 309         like %g, but if -pipe is in effect, expands to nothing.  (We have both
 310         %| and %m to accommodate differences between system assemblers; see
 311         the AS_NEEDS_DASH_FOR_PIPED_INPUT target macro.)
 312  %uSUFFIX
 313         like %g, but generates a new temporary file name even if %uSUFFIX
 314         was already seen.
 315  %USUFFIX
 316         substitutes the last file name generated with %uSUFFIX, generating a
 317         new one if there is no such last file name.  In the absence of any
 318         %uSUFFIX, this is just like %gSUFFIX, except they don't share
 319         the same suffix "space", so `%g.s ... %U.s ... %g.s ... %U.s'
 320         would involve the generation of two distinct file names, one
 321         for each `%g.s' and another for each `%U.s'.  Previously, %U was
 322         simply substituted with a file name chosen for the previous %u,
 323         without regard to any appended suffix.
 324  %jSUFFIX
 325         substitutes the name of the HOST_BIT_BUCKET, if any, and if it is
 326         writable, and if save-temps is off; otherwise, substitute the name
 327         of a temporary file, just like %u.  This temporary file is not
 328         meant for communication between processes, but rather as a junk
 329         disposal mechanism.
 330  %.SUFFIX
 331         substitutes .SUFFIX for the suffixes of a matched switch's args when
 332         it is subsequently output with %*. SUFFIX is terminated by the next
 333         space or %.
 334  %d     marks the argument containing or following the %d as a
 335         temporary file name, so that that file will be deleted if GCC exits
 336         successfully.  Unlike %g, this contributes no text to the argument.
 337  %w     marks the argument containing or following the %w as the
 338         "output file" of this compilation.  This puts the argument
 339         into the sequence of arguments that %o will substitute later.
 340  %V     indicates that this compilation produces no "output file".
 341  %W{...}
 342         like %{...} but mark last argument supplied within
 343         as a file to be deleted on failure.
 344  %o     substitutes the names of all the output files, with spaces
 345         automatically placed around them.  You should write spaces
 346         around the %o as well or the results are undefined.
 347         %o is for use in the specs for running the linker.
 348         Input files whose names have no recognized suffix are not compiled
 349         at all, but they are included among the output files, so they will
 350         be linked.
 351  %O     substitutes the suffix for object files.  Note that this is
 352         handled specially when it immediately follows %g, %u, or %U
 353         (with or without a suffix argument) because of the need for
 354         those to form complete file names.  The handling is such that
 355         %O is treated exactly as if it had already been substituted,
 356         except that %g, %u, and %U do not currently support additional
 357         SUFFIX characters following %O as they would following, for
 358         example, `.o'.
 359  %I     Substitute any of -iprefix (made from GCC_EXEC_PREFIX), -isysroot
 360         (made from TARGET_SYSTEM_ROOT), -isystem (made from COMPILER_PATH
 361         and -B options) and -imultilib as necessary.
 362  %s     current argument is the name of a library or startup file of some sort.
 363         Search for that file in a standard list of directories
 364         and substitute the full name found.
 365  %eSTR  Print STR as an error message.  STR is terminated by a newline.
 366         Use this when inconsistent options are detected.
 367  %nSTR  Print STR as a notice.  STR is terminated by a newline.
 368  %x{OPTION}     Accumulate an option for %X.
 369  %X     Output the accumulated linker options specified by compilations.
 370  %Y     Output the accumulated assembler options specified by compilations.
 371  %Z     Output the accumulated preprocessor options specified by compilations.
 372  %a     process ASM_SPEC as a spec.
 373         This allows config.h to specify part of the spec for running as.
 374  %A     process ASM_FINAL_SPEC as a spec.  A capital A is actually
 375         used here.  This can be used to run a post-processor after the
 376         assembler has done its job.
 377  %D     Dump out a -L option for each directory in startfile_prefixes.
 378         If multilib_dir is set, extra entries are generated with it affixed.
 379  %l     process LINK_SPEC as a spec.
 380  %L     process LIB_SPEC as a spec.
 381  %M     Output multilib_os_dir.
 382  %G     process LIBGCC_SPEC as a spec.
 383  %R     Output the concatenation of target_system_root and
 384         target_sysroot_suffix.
 385  %S     process STARTFILE_SPEC as a spec.  A capital S is actually used here.
 386  %E     process ENDFILE_SPEC as a spec.  A capital E is actually used here.
 387  %C     process CPP_SPEC as a spec.
 388  %1     process CC1_SPEC as a spec.
 389  %2     process CC1PLUS_SPEC as a spec.
 390  %*     substitute the variable part of a matched option.  (See below.)
 391         Note that each comma in the substituted string is replaced by
 392         a single space.
 393  %<S    remove all occurrences of -S from the command line.
 394         Note - this command is position dependent.  % commands in the
 395         spec string before this one will see -S, % commands in the
 396         spec string after this one will not.
 397  %>S    Similar to "%<S", but keep it in the GCC command line.
 398  %<S*   remove all occurrences of all switches beginning with -S from the
 399         command line.
 400  %:function(args)
 401         Call the named function FUNCTION, passing it ARGS.  ARGS is
 402         first processed as a nested spec string, then split into an
 403         argument vector in the usual fashion.  The function returns
 404         a string which is processed as if it had appeared literally
 405         as part of the current spec.
 406  %{S}   substitutes the -S switch, if that switch was given to GCC.
 407         If that switch was not specified, this substitutes nothing.
 408         Here S is a metasyntactic variable.
 409  %{S*}  substitutes all the switches specified to GCC whose names start
 410         with -S.  This is used for -o, -I, etc; switches that take
 411         arguments.  GCC considers `-o foo' as being one switch whose
 412         name starts with `o'.  %{o*} would substitute this text,
 413         including the space; thus, two arguments would be generated.
 414  %{S*&T*} likewise, but preserve order of S and T options (the order
 415         of S and T in the spec is not significant).  Can be any number
 416         of ampersand-separated variables; for each the wild card is
 417         optional.  Useful for CPP as %{D*&U*&A*}.
 418
 419  %{S:X}   substitutes X, if the -S switch was given to GCC.
 420  %{!S:X}  substitutes X, if the -S switch was NOT given to GCC.
 421  %{S*:X}  substitutes X if one or more switches whose names start
 422           with -S was given to GCC.  Normally X is substituted only
 423           once, no matter how many such switches appeared.  However,
 424           if %* appears somewhere in X, then X will be substituted
 425           once for each matching switch, with the %* replaced by the
 426           part of that switch that matched the '*'.
 427  %{.S:X}  substitutes X, if processing a file with suffix S.
 428  %{!.S:X} substitutes X, if NOT processing a file with suffix S.
 429  %{,S:X}  substitutes X, if processing a file which will use spec S.
 430  %{!,S:X} substitutes X, if NOT processing a file which will use spec S.
 431
 432  %{S|T:X} substitutes X if either -S or -T was given to GCC.  This may be
 433           combined with '!', '.', ',', and '*' as above binding stronger
 434           than the OR.
 435           If %* appears in X, all of the alternatives must be starred, and
 436           only the first matching alternative is substituted.
 437  %{S:X;   if S was given to GCC, substitutes X;
 438    T:Y;   else if T was given to GCC, substitutes Y;
 439     :D}   else substitutes D.  There can be as many clauses as you need.
 440           This may be combined with '.', '!', ',', '|', and '*' as above.
 441
 442  %(Spec) processes a specification defined in a specs file as *Spec:
 443
 444 The conditional text X in a %{S:X} or similar construct may contain
 445 other nested % constructs or spaces, or even newlines.  They are
 446 processed as usual, as described above.  Trailing white space in X is
 447 ignored.  White space may also appear anywhere on the left side of the
 448 colon in these constructs, except between . or * and the corresponding
 449 word.
 450
 451 The -O, -f, -g, -m, and -W switches are handled specifically in these
 452 constructs.  If another value of -O or the negated form of a -f, -m, or
 453 -W switch is found later in the command line, the earlier switch
 454 value is ignored, except with {S*} where S is just one letter; this
 455 passes all matching options.
 456
 457 The character | at the beginning of the predicate text is used to indicate
 458 that a command should be piped to the following command, but only if -pipe
 459 is specified.
 460
 461 Note that it is built into GCC which switches take arguments and which
 462 do not.  You might think it would be useful to generalize this to
 463 allow each compiler's spec to say which switches take arguments.  But
 464 this cannot be done in a consistent fashion.  GCC cannot even decide
 465 which input files have been specified without knowing which switches
 466 take arguments, and it must know which input files to compile in order
 467 to tell which compilers to run.
 468
 469 GCC also knows implicitly that arguments starting in `-l' are to be
 470 treated as compiler output files, and passed to the linker in their
 471 proper position among the other output files.  */
 472 \f
 473 /* Define the macros used for specs %a, %l, %L, %S, %C, %1.  */
 474
 475 /* config.h can define ASM_SPEC to provide extra args to the assembler
 476    or extra switch-translations.  */
 477 #ifndef ASM_SPEC
 478 #define ASM_SPEC ""
 479 #endif
 480
 481 /* config.h can define ASM_FINAL_SPEC to run a post processor after
 482    the assembler has run.  */
 483 #ifndef ASM_FINAL_SPEC
 484 #define ASM_FINAL_SPEC \
 485   "%{gsplit-dwarf: \n\
 486        objcopy --extract-dwo \
 487          %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
 488          %{c:%{o*:%:replace-extension(%{o*:%*} .dwo)}%{!o*:%b.dwo}}%{!c:%b.dwo} \n\
 489        objcopy --strip-dwo \
 490          %{c:%{o*:%*}%{!o*:%b%O}}%{!c:%U%O} \
 491     }"
 492 #endif
 493
 494 /* config.h can define CPP_SPEC to provide extra args to the C preprocessor
 495    or extra switch-translations.  */
 496 #ifndef CPP_SPEC
 497 #define CPP_SPEC ""
 498 #endif
 499
 500 /* config.h can define CC1_SPEC to provide extra args to cc1 and cc1plus
 501    or extra switch-translations.  */
 502 #ifndef CC1_SPEC
 503 #define CC1_SPEC ""
 504 #endif
 505
 506 /* config.h can define CC1PLUS_SPEC to provide extra args to cc1plus
 507    or extra switch-translations.  */
 508 #ifndef CC1PLUS_SPEC
 509 #define CC1PLUS_SPEC ""
 510 #endif
 511
 512 /* config.h can define LINK_SPEC to provide extra args to the linker
 513    or extra switch-translations.  */
 514 #ifndef LINK_SPEC
 515 #define LINK_SPEC ""
 516 #endif
 517
 518 /* config.h can define LIB_SPEC to override the default libraries.  */
 519 #ifndef LIB_SPEC
 520 #define LIB_SPEC "%{!shared:%{g*:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}}"
 521 #endif
 522
 523 /* mudflap specs */
 524 #ifndef MFWRAP_SPEC
 525 /* XXX: valid only for GNU ld */
 526 /* XXX: should exactly match hooks provided by libmudflap.a */
 527 #define MFWRAP_SPEC " %{static: %{fmudflap|fmudflapth: \
 528  --wrap=malloc --wrap=free --wrap=calloc --wrap=realloc\
 529  --wrap=mmap --wrap=mmap64 --wrap=munmap --wrap=alloca\
 530 } %{fmudflapth: --wrap=pthread_create\
 531 }} %{fmudflap|fmudflapth: --wrap=main}"
 532 #endif
 533 #ifndef MFLIB_SPEC
 534 #define MFLIB_SPEC "%{fmudflap|fmudflapth: -export-dynamic}"
 535 #endif
 536
 537 /* When using -fsplit-stack we need to wrap pthread_create, in order
 538    to initialize the stack guard.  We always use wrapping, rather than
 539    shared library ordering, and we keep the wrapper function in
 540    libgcc.  This is not yet a real spec, though it could become one;
 541    it is currently just stuffed into LINK_SPEC.  FIXME: This wrapping
 542    only works with GNU ld and gold.  FIXME: This is incompatible with
 543    -fmudflap when linking statically, which wants to do its own
 544    wrapping.  */
 545 #define STACK_SPLIT_SPEC " %{fsplit-stack: --wrap=pthread_create}"
 546
 547 #ifndef LIBASAN_SPEC
 548 #ifdef STATIC_LIBASAN_LIBS
 549 #define ADD_STATIC_LIBASAN_LIBS \
 550   " %{static-libasan:" STATIC_LIBASAN_LIBS "}"
 551 #else
 552 #define ADD_STATIC_LIBASAN_LIBS
 553 #endif
 554 #ifdef HAVE_LD_STATIC_DYNAMIC
 555 #define LIBASAN_SPEC "%{static-libasan:" LD_STATIC_OPTION \
 556                      "} -lasan %{static-libasan:" LD_DYNAMIC_OPTION "}" \
 557                      ADD_STATIC_LIBASAN_LIBS
 558 #else
 559 #define LIBASAN_SPEC "-lasan" ADD_STATIC_LIBASAN_LIBS
 560 #endif
 561 #endif
 562
 563 #ifndef LIBTSAN_SPEC
 564 #ifdef HAVE_LD_STATIC_DYNAMIC
 565 #define LIBTSAN_SPEC "%{static-libtsan:" LD_STATIC_OPTION \
 566                      "} -ltsan %{static-libtsan:" LD_DYNAMIC_OPTION "}"
 567 #else
 568 #define LIBTSAN_SPEC "-ltsan"
 569 #endif
 570 #endif
 571
 572 /* config.h can define LIBGCC_SPEC to override how and when libgcc.a is
 573    included.  */
 574 #ifndef LIBGCC_SPEC
 575 #if defined(REAL_LIBGCC_SPEC)
 576 #define LIBGCC_SPEC REAL_LIBGCC_SPEC
 577 #elif defined(LINK_LIBGCC_SPECIAL_1)
 578 /* Have gcc do the search for libgcc.a.  */
 579 #define LIBGCC_SPEC "libgcc.a%s"
 580 #else
 581 #define LIBGCC_SPEC "-lgcc"
 582 #endif
 583 #endif
 584
 585 /* config.h can define STARTFILE_SPEC to override the default crt0 files.  */
 586 #ifndef STARTFILE_SPEC
 587 #define STARTFILE_SPEC  \
 588   "%{!shared:%{pg:gcrt0%O%s}%{!pg:%{p:mcrt0%O%s}%{!p:crt0%O%s}}}"
 589 #endif
 590
 591 /* config.h can define ENDFILE_SPEC to override the default crtn files.  */
 592 #ifndef ENDFILE_SPEC
 593 #define ENDFILE_SPEC ""
 594 #endif
 595
 596 #ifndef LINKER_NAME
 597 #define LINKER_NAME "collect2"
 598 #endif
 599
 600 #ifdef HAVE_AS_DEBUG_PREFIX_MAP
 601 #define ASM_MAP " %{fdebug-prefix-map=*:--debug-prefix-map %*}"
 602 #else
 603 #define ASM_MAP ""
 604 #endif
 605
 606 /* Define ASM_DEBUG_SPEC to be a spec suitable for translating '-g'
 607    to the assembler.  */
 608 #ifndef ASM_DEBUG_SPEC
 609 # if defined(DBX_DEBUGGING_INFO) && defined(DWARF2_DEBUGGING_INFO) \
 610      && defined(HAVE_AS_GDWARF2_DEBUG_FLAG) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
 611 #  define ASM_DEBUG_SPEC                                                \
 612       (PREFERRED_DEBUGGING_TYPE == DBX_DEBUG                            \
 613        ? "%{!g0:%{gdwarf-2*:--gdwarf2}%{!gdwarf-2*:%{g*:--gstabs}}}" ASM_MAP    \
 614        : "%{!g0:%{gstabs*:--gstabs}%{!gstabs*:%{g*:--gdwarf2}}}" ASM_MAP)
 615 # else
 616 #  if defined(DBX_DEBUGGING_INFO) && defined(HAVE_AS_GSTABS_DEBUG_FLAG)
 617 #   define ASM_DEBUG_SPEC "%{g*:%{!g0:--gstabs}}" ASM_MAP
 618 #  endif
 619 #  if defined(DWARF2_DEBUGGING_INFO) && defined(HAVE_AS_GDWARF2_DEBUG_FLAG)
 620 #   define ASM_DEBUG_SPEC "%{g*:%{!g0:--gdwarf2}}" ASM_MAP
 621 #  endif
 622 # endif
 623 #endif
 624 #ifndef ASM_DEBUG_SPEC
 625 # define ASM_DEBUG_SPEC ""
 626 #endif
 627
 628 /* Here is the spec for running the linker, after compiling all files.  */
 629
 630 /* This is overridable by the target in case they need to specify the
 631    -lgcc and -lc order specially, yet not require them to override all
 632    of LINK_COMMAND_SPEC.  */
 633 #ifndef LINK_GCC_C_SEQUENCE_SPEC
 634 #define LINK_GCC_C_SEQUENCE_SPEC "%G %L %G"
 635 #endif
 636
 637 #ifndef LINK_SSP_SPEC
 638 #ifdef TARGET_LIBC_PROVIDES_SSP
 639 #define LINK_SSP_SPEC "%{fstack-protector:}"
 640 #else
 641 #define LINK_SSP_SPEC "%{fstack-protector|fstack-protector-all:-lssp_nonshared -lssp}"
 642 #endif
 643 #endif
 644
 645 #ifndef LINK_PIE_SPEC
 646 #ifdef HAVE_LD_PIE
 647 #define LINK_PIE_SPEC "%{pie:-pie} "
 648 #else
 649 #define LINK_PIE_SPEC "%{pie:} "
 650 #endif
 651 #endif
 652
 653 #ifndef LINK_BUILDID_SPEC
 654 # if defined(HAVE_LD_BUILDID) && defined(ENABLE_LD_BUILDID)
 655 #  define LINK_BUILDID_SPEC "%{!r:--build-id} "
 656 # endif
 657 #endif
 658
 659 /* Conditional to test whether the LTO plugin is used or not.
 660    FIXME: For slim LTO we will need to enable plugin unconditionally.  This
 661    still cause problems with PLUGIN_LD != LD and when plugin is built but
 662    not useable.  For GCC 4.6 we don't support slim LTO and thus we can enable
 663    plugin only when LTO is enabled.  We still honor explicit
 664    -fuse-linker-plugin if the linker used understands -plugin.  */
 665
 666 /* The linker has some plugin support.  */
 667 #if HAVE_LTO_PLUGIN > 0
 668 /* The linker used has full plugin support, use LTO plugin by default.  */
 669 #if HAVE_LTO_PLUGIN == 2
 670 #define PLUGIN_COND "!fno-use-linker-plugin:%{flto|flto=*|fuse-linker-plugin"
 671 #define PLUGIN_COND_CLOSE "}"
 672 #else
 673 /* The linker used has limited plugin support, use LTO plugin with explicit
 674    -fuse-linker-plugin.  */
 675 #define PLUGIN_COND "fuse-linker-plugin"
 676 #define PLUGIN_COND_CLOSE ""
 677 #endif
 678 #define LINK_PLUGIN_SPEC \
 679     "%{"PLUGIN_COND": \
 680     -plugin %(linker_plugin_file) \
 681     -plugin-opt=%(lto_wrapper) \
 682     -plugin-opt=-fresolution=%u.res \
 683     %{!nostdlib:%{!nodefaultlibs:%:pass-through-libs(%(link_gcc_c_sequence))}} \
 684     }"PLUGIN_COND_CLOSE
 685 #else
 686 /* The linker used doesn't support -plugin, reject -fuse-linker-plugin.  */
 687 #define LINK_PLUGIN_SPEC "%{fuse-linker-plugin:\
 688     %e-fuse-linker-plugin is not supported in this configuration}"
 689 #endif
 690
 691
 692 /* -u* was put back because both BSD and SysV seem to support it.  */
 693 /* %{static:} simply prevents an error message if the target machine
 694    doesn't handle -static.  */
 695 /* We want %{T*} after %{L*} and %D so that it can be used to specify linker
 696    scripts which exist in user specified directories, or in standard
 697    directories.  */
 698 /* We pass any -flto flags on to the linker, which is expected
 699    to understand them.  In practice, this means it had better be collect2.  */
 700 /* %{e*} includes -export-dynamic; see comment in common.opt.  */
 701 #ifndef LINK_COMMAND_SPEC
 702 #define LINK_COMMAND_SPEC "\
 703 %{!fsyntax-only:%{!c:%{!M:%{!MM:%{!E:%{!S:\
 704     %(linker) " \
 705     LINK_PLUGIN_SPEC \
 706     "%{flto|flto=*:%<fcompare-debug*} \
 707     %{flto} %{flto=*} %l " LINK_PIE_SPEC \
 708    "%X %{o*} %{e*} %{N} %{n} %{r}\
 709     %{s} %{t} %{u*} %{z} %{Z} %{!nostdlib:%{!nostartfiles:%S}}\
 710     %{static:} %{L*} %(mfwrap) %(link_libgcc) %o\
 711     %{fopenmp|ftree-parallelize-loops=*:%:include(libgomp.spec)%(link_gomp)}\
 712     %{fgnu-tm:%:include(libitm.spec)%(link_itm)}\
 713     %(mflib) " STACK_SPLIT_SPEC "\
 714     %{fprofile-arcs|fprofile-generate*|coverage:-lgcov}\
 715     %{fsanitize=address:" LIBASAN_SPEC "%{static:%ecannot specify -static with -fsanitize=address}}\
 716     %{fsanitize=thread:" LIBTSAN_SPEC "}\
 717     %{!nostdlib:%{!nodefaultlibs:%(link_ssp) %(link_gcc_c_sequence)}}\
 718     %{!nostdlib:%{!nostartfiles:%E}} %{T*} }}}}}}"
 719 #endif
 720
 721 #ifndef LINK_LIBGCC_SPEC
 722 /* Generate -L options for startfile prefix list.  */
 723 # define LINK_LIBGCC_SPEC "%D"
 724 #endif
 725
 726 #ifndef STARTFILE_PREFIX_SPEC
 727 # define STARTFILE_PREFIX_SPEC ""
 728 #endif
 729
 730 #ifndef SYSROOT_SPEC
 731 # define SYSROOT_SPEC "--sysroot=%R"
 732 #endif
 733
 734 #ifndef SYSROOT_SUFFIX_SPEC
 735 # define SYSROOT_SUFFIX_SPEC ""
 736 #endif
 737
 738 #ifndef SYSROOT_HEADERS_SUFFIX_SPEC
 739 # define SYSROOT_HEADERS_SUFFIX_SPEC ""
 740 #endif
 741
 742 static const char *asm_debug = ASM_DEBUG_SPEC;
 743 static const char *cpp_spec = CPP_SPEC;
 744 static const char *cc1_spec = CC1_SPEC;
 745 static const char *cc1plus_spec = CC1PLUS_SPEC;
 746 static const char *link_gcc_c_sequence_spec = LINK_GCC_C_SEQUENCE_SPEC;
 747 static const char *link_ssp_spec = LINK_SSP_SPEC;
 748 static const char *asm_spec = ASM_SPEC;
 749 static const char *asm_final_spec = ASM_FINAL_SPEC;
 750 static const char *link_spec = LINK_SPEC;
 751 static const char *lib_spec = LIB_SPEC;
 752 static const char *mfwrap_spec = MFWRAP_SPEC;
 753 static const char *mflib_spec = MFLIB_SPEC;
 754 static const char *link_gomp_spec = "";
 755 static const char *libgcc_spec = LIBGCC_SPEC;
 756 static const char *endfile_spec = ENDFILE_SPEC;
 757 static const char *startfile_spec = STARTFILE_SPEC;
 758 static const char *linker_name_spec = LINKER_NAME;
 759 static const char *linker_plugin_file_spec = "";
 760 static const char *lto_wrapper_spec = "";
 761 static const char *lto_gcc_spec = "";
 762 static const char *link_command_spec = LINK_COMMAND_SPEC;
 763 static const char *link_libgcc_spec = LINK_LIBGCC_SPEC;
 764 static const char *startfile_prefix_spec = STARTFILE_PREFIX_SPEC;
 765 static const char *sysroot_spec = SYSROOT_SPEC;
 766 static const char *sysroot_suffix_spec = SYSROOT_SUFFIX_SPEC;
 767 static const char *sysroot_hdrs_suffix_spec = SYSROOT_HEADERS_SUFFIX_SPEC;
 768 static const char *self_spec = "";
 769
 770 /* Standard options to cpp, cc1, and as, to reduce duplication in specs.
 771    There should be no need to override these in target dependent files,
 772    but we need to copy them to the specs file so that newer versions
 773    of the GCC driver can correctly drive older tool chains with the
 774    appropriate -B options.  */
 775
 776 /* When cpplib handles traditional preprocessing, get rid of this, and
 777    call cc1 (or cc1obj in objc/lang-specs.h) from the main specs so
 778    that we default the front end language better.  */
 779 static const char *trad_capable_cpp =
 780 "cc1 -E %{traditional|traditional-cpp:-traditional-cpp}";
 781
 782 /* We don't wrap .d files in %W{} since a missing .d file, and
 783    therefore no dependency entry, confuses make into thinking a .o
 784    file that happens to exist is up-to-date.  */
 785 static const char *cpp_unique_options =
 786 "%{!Q:-quiet} %{nostdinc*} %{C} %{CC} %{v} %{I*&F*} %{P} %I\
 787  %{MD:-MD %{!o:%b.d}%{o*:%.d%*}}\
 788  %{MMD:-MMD %{!o:%b.d}%{o*:%.d%*}}\
 789  %{M} %{MM} %{MF*} %{MG} %{MP} %{MQ*} %{MT*}\
 790  %{!E:%{!M:%{!MM:%{!MT:%{!MQ:%{MD|MMD:%{o*:-MQ %*}}}}}}}\
 791  %{remap} %{g3|ggdb3|gstabs3|gcoff3|gxcoff3|gvms3:-dD}\
 792  %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
 793  %{H} %C %{D*&U*&A*} %{i*} %Z %i\
 794  %{fmudflap:-D_MUDFLAP -include mf-runtime.h}\
 795  %{fmudflapth:-D_MUDFLAP -D_MUDFLAPTH -include mf-runtime.h}\
 796  %{E|M|MM:%W{o*}}";
 797
 798 /* This contains cpp options which are common with cc1_options and are passed
 799    only when preprocessing only to avoid duplication.  We pass the cc1 spec
 800    options to the preprocessor so that it the cc1 spec may manipulate
 801    options used to set target flags.  Those special target flags settings may
 802    in turn cause preprocessor symbols to be defined specially.  */
 803 static const char *cpp_options =
 804 "%(cpp_unique_options) %1 %{m*} %{std*&ansi&trigraphs} %{W*&pedantic*} %{w}\
 805  %{f*} %{g*:%{!g0:%{g*} %{!fno-working-directory:-fworking-directory}}} %{O*}\
 806  %{undef} %{save-temps*:-fpch-preprocess}";
 807
 808 /* This contains cpp options which are not passed when the preprocessor
 809    output will be used by another program.  */
 810 static const char *cpp_debug_options = "%{d*}";
 811
 812 /* NB: This is shared amongst all front-ends, except for Ada.  */
 813 static const char *cc1_options =
 814 "%{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
 815  %{!iplugindir*:%{fplugin*:%:find-plugindir()}}\
 816  %1 %{!Q:-quiet} %{!dumpbase:-dumpbase %B} %{d*} %{m*} %{aux-info*}\
 817  %{fcompare-debug-second:%:compare-debug-auxbase-opt(%b)} \
 818  %{!fcompare-debug-second:%{c|S:%{o*:-auxbase-strip %*}%{!o*:-auxbase %b}}}%{!c:%{!S:-auxbase %b}} \
 819  %{g*} %{O*} %{W*&pedantic*} %{w} %{std*&ansi&trigraphs}\
 820  %{v:-version} %{pg:-p} %{p} %{f*} %{undef}\
 821  %{Qn:-fno-ident} %{Qy:} %{-help:--help}\
 822  %{-target-help:--target-help}\
 823  %{-version:--version}\
 824  %{-help=*:--help=%*}\
 825  %{!fsyntax-only:%{S:%W{o*}%{!o*:-o %b.s}}}\
 826  %{fsyntax-only:-o %j} %{-param*}\
 827  %{fmudflap|fmudflapth:-fno-builtin -fno-merge-constants}\
 828  %{coverage:-fprofile-arcs -ftest-coverage}";
 829
 830 static const char *asm_options =
 831 "%{-target-help:%:print-asm-header()} "
 832 #if HAVE_GNU_AS
 833 /* If GNU AS is used, then convert -w (no warnings), -I, and -v
 834    to the assembler equivalents.  */
 835 "%{v} %{w:-W} %{I*} "
 836 #endif
 837 "%a %Y %{c:%W{o*}%{!o*:-o %w%b%O}}%{!c:-o %d%w%u%O}";
 838
 839 static const char *invoke_as =
 840 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
 841 "%{!fwpa:\
 842    %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
 843    %{!S:-o %|.s |\n as %(asm_options) %|.s %A }\
 844   }";
 845 #else
 846 "%{!fwpa:\
 847    %{fcompare-debug=*|fdump-final-insns=*:%:compare-debug-dump-opt()}\
 848    %{!S:-o %|.s |\n as %(asm_options) %m.s %A }\
 849   }";
 850 #endif
 851
 852 /* Some compilers have limits on line lengths, and the multilib_select
 853    and/or multilib_matches strings can be very long, so we build them at
 854    run time.  */
 855 static struct obstack multilib_obstack;
 856 static const char *multilib_select;
 857 static const char *multilib_matches;
 858 static const char *multilib_defaults;
 859 static const char *multilib_exclusions;
 860
 861 /* Check whether a particular argument is a default argument.  */
 862
 863 #ifndef MULTILIB_DEFAULTS
 864 #define MULTILIB_DEFAULTS { "" }
 865 #endif
 866
 867 static const char *const multilib_defaults_raw[] = MULTILIB_DEFAULTS;
 868
 869 #ifndef DRIVER_SELF_SPECS
 870 #define DRIVER_SELF_SPECS ""
 871 #endif
 872
 873 /* Adding -fopenmp should imply pthreads.  This is particularly important
 874    for targets that use different start files and suchlike.  */
 875 #ifndef GOMP_SELF_SPECS
 876 #define GOMP_SELF_SPECS "%{fopenmp|ftree-parallelize-loops=*: -pthread}"
 877 #endif
 878
 879 /* Likewise for -fgnu-tm.  */
 880 #ifndef GTM_SELF_SPECS
 881 #define GTM_SELF_SPECS "%{fgnu-tm: -pthread}"
 882 #endif
 883
 884 static const char *const driver_self_specs[] = {
 885   "%{fdump-final-insns:-fdump-final-insns=.} %<fdump-final-insns",
 886   DRIVER_SELF_SPECS, CONFIGURE_SPECS, GOMP_SELF_SPECS, GTM_SELF_SPECS
 887 };
 888
 889 #ifndef OPTION_DEFAULT_SPECS
 890 #define OPTION_DEFAULT_SPECS { "", "" }
 891 #endif
 892
 893 struct default_spec
 894 {
 895   const char *name;
 896   const char *spec;
 897 };
 898
 899 static const struct default_spec
 900   option_default_specs[] = { OPTION_DEFAULT_SPECS };
 901
 902 struct user_specs
 903 {
 904   struct user_specs *next;
 905   const char *filename;
 906 };
 907
 908 static struct user_specs *user_specs_head, *user_specs_tail;
 909
 910 \f
 911 /* Record the mapping from file suffixes for compilation specs.  */
 912
 913 struct compiler
 914 {
 915   const char *suffix;           /* Use this compiler for input files
 916                                    whose names end in this suffix.  */
 917
 918   const char *spec;             /* To use this compiler, run this spec.  */
 919
 920   const char *cpp_spec;         /* If non-NULL, substitute this spec
 921                                    for `%C', rather than the usual
 922                                    cpp_spec.  */
 923   const int combinable;          /* If nonzero, compiler can deal with
 924                                     multiple source files at once (IMA).  */
 925   const int needs_preprocessing; /* If nonzero, source files need to
 926                                     be run through a preprocessor.  */
 927 };
 928
 929 /* Pointer to a vector of `struct compiler' that gives the spec for
 930    compiling a file, based on its suffix.
 931    A file that does not end in any of these suffixes will be passed
 932    unchanged to the loader and nothing else will be done to it.
 933
 934    An entry containing two 0s is used to terminate the vector.
 935
 936    If multiple entries match a file, the last matching one is used.  */
 937
 938 static struct compiler *compilers;
 939
 940 /* Number of entries in `compilers', not counting the null terminator.  */
 941
 942 static int n_compilers;
 943
 944 /* The default list of file name suffixes and their compilation specs.  */
 945
 946 static const struct compiler default_compilers[] =
 947 {
 948   /* Add lists of suffixes of known languages here.  If those languages
 949      were not present when we built the driver, we will hit these copies
 950      and be given a more meaningful error than "file not used since
 951      linking is not done".  */
 952   {".m",  "#Objective-C", 0, 0, 0}, {".mi",  "#Objective-C", 0, 0, 0},
 953   {".mm", "#Objective-C++", 0, 0, 0}, {".M", "#Objective-C++", 0, 0, 0},
 954   {".mii", "#Objective-C++", 0, 0, 0},
 955   {".cc", "#C++", 0, 0, 0}, {".cxx", "#C++", 0, 0, 0},
 956   {".cpp", "#C++", 0, 0, 0}, {".cp", "#C++", 0, 0, 0},
 957   {".c++", "#C++", 0, 0, 0}, {".C", "#C++", 0, 0, 0},
 958   {".CPP", "#C++", 0, 0, 0}, {".ii", "#C++", 0, 0, 0},
 959   {".ads", "#Ada", 0, 0, 0}, {".adb", "#Ada", 0, 0, 0},
 960   {".f", "#Fortran", 0, 0, 0}, {".F", "#Fortran", 0, 0, 0},
 961   {".for", "#Fortran", 0, 0, 0}, {".FOR", "#Fortran", 0, 0, 0},
 962   {".ftn", "#Fortran", 0, 0, 0}, {".FTN", "#Fortran", 0, 0, 0},
 963   {".fpp", "#Fortran", 0, 0, 0}, {".FPP", "#Fortran", 0, 0, 0},
 964   {".f90", "#Fortran", 0, 0, 0}, {".F90", "#Fortran", 0, 0, 0},
 965   {".f95", "#Fortran", 0, 0, 0}, {".F95", "#Fortran", 0, 0, 0},
 966   {".f03", "#Fortran", 0, 0, 0}, {".F03", "#Fortran", 0, 0, 0},
 967   {".f08", "#Fortran", 0, 0, 0}, {".F08", "#Fortran", 0, 0, 0},
 968   {".r", "#Ratfor", 0, 0, 0},
 969   {".p", "#Pascal", 0, 0, 0}, {".pas", "#Pascal", 0, 0, 0},
 970   {".java", "#Java", 0, 0, 0}, {".class", "#Java", 0, 0, 0},
 971   {".zip", "#Java", 0, 0, 0}, {".jar", "#Java", 0, 0, 0},
 972   {".go", "#Go", 0, 1, 0},
 973   /* Next come the entries for C.  */
 974   {".c", "@c", 0, 0, 1},
 975   {"@c",
 976    /* cc1 has an integrated ISO C preprocessor.  We should invoke the
 977       external preprocessor if -save-temps is given.  */
 978      "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
 979       %{!E:%{!M:%{!MM:\
 980           %{traditional:\
 981 %eGNU C no longer supports -traditional without -E}\
 982       %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
 983           %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
 984             cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
 985           %(cc1_options)}\
 986       %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
 987           cc1 %(cpp_unique_options) %(cc1_options)}}}\
 988       %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 1},
 989   {"-",
 990    "%{!E:%e-E or -x required when input is from standard input}\
 991     %(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)", 0, 0, 0},
 992   {".h", "@c-header", 0, 0, 0},
 993   {"@c-header",
 994    /* cc1 has an integrated ISO C preprocessor.  We should invoke the
 995       external preprocessor if -save-temps is given.  */
 996      "%{E|M|MM:%(trad_capable_cpp) %(cpp_options) %(cpp_debug_options)}\
 997       %{!E:%{!M:%{!MM:\
 998           %{save-temps*|traditional-cpp|no-integrated-cpp:%(trad_capable_cpp) \
 999                 %(cpp_options) -o %{save-temps*:%b.i} %{!save-temps*:%g.i} \n\
1000                     cc1 -fpreprocessed %{save-temps*:%b.i} %{!save-temps*:%g.i} \
1001                         %(cc1_options)\
1002                         %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1003                         %W{o*:--output-pch=%*}}%V}\
1004           %{!save-temps*:%{!traditional-cpp:%{!no-integrated-cpp:\
1005                 cc1 %(cpp_unique_options) %(cc1_options)\
1006                     %{!fdump-ada-spec*:-o %g.s %{!o*:--output-pch=%i.gch}\
1007                     %W{o*:--output-pch=%*}}%V}}}}}}", 0, 0, 0},
1008   {".i", "@cpp-output", 0, 0, 0},
1009   {"@cpp-output",
1010    "%{!M:%{!MM:%{!E:cc1 -fpreprocessed %i %(cc1_options) %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0},
1011   {".s", "@assembler", 0, 0, 0},
1012   {"@assembler",
1013    "%{!M:%{!MM:%{!E:%{!S:as %(asm_debug) %(asm_options) %i %A }}}}", 0, 0, 0},
1014   {".sx", "@assembler-with-cpp", 0, 0, 0},
1015   {".S", "@assembler-with-cpp", 0, 0, 0},
1016   {"@assembler-with-cpp",
1017 #ifdef AS_NEEDS_DASH_FOR_PIPED_INPUT
1018    "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1019       %{E|M|MM:%(cpp_debug_options)}\
1020       %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1021        as %(asm_debug) %(asm_options) %|.s %A }}}}"
1022 #else
1023    "%(trad_capable_cpp) -lang-asm %(cpp_options) -fno-directives-only\
1024       %{E|M|MM:%(cpp_debug_options)}\
1025       %{!M:%{!MM:%{!E:%{!S:-o %|.s |\n\
1026        as %(asm_debug) %(asm_options) %m.s %A }}}}"
1027 #endif
1028    , 0, 0, 0},
1029
1030 #include "specs.h"
1031   /* Mark end of table.  */
1032   {0, 0, 0, 0, 0}
1033 };
1034
1035 /* Number of elements in default_compilers, not counting the terminator.  */
1036
1037 static const int n_default_compilers = ARRAY_SIZE (default_compilers) - 1;
1038
1039 typedef char *char_p; /* For DEF_VEC_P.  */
1040
1041 /* A vector of options to give to the linker.
1042    These options are accumulated by %x,
1043    and substituted into the linker command with %X.  */
1044 static vec<char_p> linker_options;
1045
1046 /* A vector of options to give to the assembler.
1047    These options are accumulated by -Wa,
1048    and substituted into the assembler command with %Y.  */
1049 static vec<char_p> assembler_options;
1050
1051 /* A vector of options to give to the preprocessor.
1052    These options are accumulated by -Wp,
1053    and substituted into the preprocessor command with %Z.  */
1054 static vec<char_p> preprocessor_options;
1055 \f
1056 static char *
1057 skip_whitespace (char *p)
1058 {
1059   while (1)
1060     {
1061       /* A fully-blank line is a delimiter in the SPEC file and shouldn't
1062          be considered whitespace.  */
1063       if (p[0] == '\n' && p[1] == '\n' && p[2] == '\n')
1064         return p + 1;
1065       else if (*p == '\n' || *p == ' ' || *p == '\t')
1066         p++;
1067       else if (*p == '#')
1068         {
1069           while (*p != '\n')
1070             p++;
1071           p++;
1072         }
1073       else
1074         break;
1075     }
1076
1077   return p;
1078 }
1079 /* Structures to keep track of prefixes to try when looking for files.  */
1080
1081 struct prefix_list
1082 {
1083   const char *prefix;         /* String to prepend to the path.  */
1084   struct prefix_list *next;   /* Next in linked list.  */
1085   int require_machine_suffix; /* Don't use without machine_suffix.  */
1086   /* 2 means try both machine_suffix and just_machine_suffix.  */
1087   int priority;               /* Sort key - priority within list.  */
1088   int os_multilib;            /* 1 if OS multilib scheme should be used,
1089                                  0 for GCC multilib scheme.  */
1090 };
1091
1092 struct path_prefix
1093 {
1094   struct prefix_list *plist;  /* List of prefixes to try */
1095   int max_len;                /* Max length of a prefix in PLIST */
1096   const char *name;           /* Name of this list (used in config stuff) */
1097 };
1098
1099 /* List of prefixes to try when looking for executables.  */
1100
1101 static struct path_prefix exec_prefixes = { 0, 0, "exec" };
1102
1103 /* List of prefixes to try when looking for startup (crt0) files.  */
1104
1105 static struct path_prefix startfile_prefixes = { 0, 0, "startfile" };
1106
1107 /* List of prefixes to try when looking for include files.  */
1108
1109 static struct path_prefix include_prefixes = { 0, 0, "include" };
1110
1111 /* Suffix to attach to directories searched for commands.
1112    This looks like `MACHINE/VERSION/'.  */
1113
1114 static const char *machine_suffix = 0;
1115
1116 /* Suffix to attach to directories searched for commands.
1117    This is just `MACHINE/'.  */
1118
1119 static const char *just_machine_suffix = 0;
1120
1121 /* Adjusted value of GCC_EXEC_PREFIX envvar.  */
1122
1123 static const char *gcc_exec_prefix;
1124
1125 /* Adjusted value of standard_libexec_prefix.  */
1126
1127 static const char *gcc_libexec_prefix;
1128
1129 /* Default prefixes to attach to command names.  */
1130
1131 #ifndef STANDARD_STARTFILE_PREFIX_1
1132 #define STANDARD_STARTFILE_PREFIX_1 "/lib/"
1133 #endif
1134 #ifndef STANDARD_STARTFILE_PREFIX_2
1135 #define STANDARD_STARTFILE_PREFIX_2 "/usr/lib/"
1136 #endif
1137
1138 #ifdef CROSS_DIRECTORY_STRUCTURE  /* Don't use these prefixes for a cross compiler.  */
1139 #undef MD_EXEC_PREFIX
1140 #undef MD_STARTFILE_PREFIX
1141 #undef MD_STARTFILE_PREFIX_1
1142 #endif
1143
1144 /* If no prefixes defined, use the null string, which will disable them.  */
1145 #ifndef MD_EXEC_PREFIX
1146 #define MD_EXEC_PREFIX ""
1147 #endif
1148 #ifndef MD_STARTFILE_PREFIX
1149 #define MD_STARTFILE_PREFIX ""
1150 #endif
1151 #ifndef MD_STARTFILE_PREFIX_1
1152 #define MD_STARTFILE_PREFIX_1 ""
1153 #endif
1154
1155 /* These directories are locations set at configure-time based on the
1156    --prefix option provided to configure.  Their initializers are
1157    defined in Makefile.in.  These paths are not *directly* used when
1158    gcc_exec_prefix is set because, in that case, we know where the
1159    compiler has been installed, and use paths relative to that
1160    location instead.  */
1161 static const char *const standard_exec_prefix = STANDARD_EXEC_PREFIX;
1162 static const char *const standard_libexec_prefix = STANDARD_LIBEXEC_PREFIX;
1163 static const char *const standard_bindir_prefix = STANDARD_BINDIR_PREFIX;
1164 static const char *const standard_startfile_prefix = STANDARD_STARTFILE_PREFIX;
1165
1166 /* For native compilers, these are well-known paths containing
1167    components that may be provided by the system.  For cross
1168    compilers, these paths are not used.  */
1169 static const char *md_exec_prefix = MD_EXEC_PREFIX;
1170 static const char *md_startfile_prefix = MD_STARTFILE_PREFIX;
1171 static const char *md_startfile_prefix_1 = MD_STARTFILE_PREFIX_1;
1172 static const char *const standard_startfile_prefix_1
1173   = STANDARD_STARTFILE_PREFIX_1;
1174 static const char *const standard_startfile_prefix_2
1175   = STANDARD_STARTFILE_PREFIX_2;
1176
1177 /* A relative path to be used in finding the location of tools
1178    relative to the driver.  */
1179 static const char *const tooldir_base_prefix = TOOLDIR_BASE_PREFIX;
1180
1181 /* Subdirectory to use for locating libraries.  Set by
1182    set_multilib_dir based on the compilation options.  */
1183
1184 static const char *multilib_dir;
1185
1186 /* Subdirectory to use for locating libraries in OS conventions.  Set by
1187    set_multilib_dir based on the compilation options.  */
1188
1189 static const char *multilib_os_dir;
1190
1191 /* Subdirectory to use for locating libraries in multiarch conventions.  Set by
1192    set_multilib_dir based on the compilation options.  */
1193
1194 static const char *multiarch_dir;
1195 \f
1196 /* Structure to keep track of the specs that have been defined so far.
1197    These are accessed using %(specname) in a compiler or link
1198    spec.  */
1199
1200 struct spec_list
1201 {
1202                                 /* The following 2 fields must be first */
1203                                 /* to allow EXTRA_SPECS to be initialized */
1204   const char *name;             /* name of the spec.  */
1205   const char *ptr;              /* available ptr if no static pointer */
1206
1207                                 /* The following fields are not initialized */
1208                                 /* by EXTRA_SPECS */
1209   const char **ptr_spec;        /* pointer to the spec itself.  */
1210   struct spec_list *next;       /* Next spec in linked list.  */
1211   int name_len;                 /* length of the name */
1212   bool user_p;                  /* whether string come from file spec.  */
1213   bool alloc_p;                 /* whether string was allocated */
1214 };
1215
1216 #define INIT_STATIC_SPEC(NAME,PTR) \
1217   { NAME, NULL, PTR, (struct spec_list *) 0, sizeof (NAME) - 1, false, false }
1218
1219 /* List of statically defined specs.  */
1220 static struct spec_list static_specs[] =
1221 {
1222   INIT_STATIC_SPEC ("asm",                      &asm_spec),
1223   INIT_STATIC_SPEC ("asm_debug",                &asm_debug),
1224   INIT_STATIC_SPEC ("asm_final",                &asm_final_spec),
1225   INIT_STATIC_SPEC ("asm_options",              &asm_options),
1226   INIT_STATIC_SPEC ("invoke_as",                &invoke_as),
1227   INIT_STATIC_SPEC ("cpp",                      &cpp_spec),
1228   INIT_STATIC_SPEC ("cpp_options",              &cpp_options),
1229   INIT_STATIC_SPEC ("cpp_debug_options",        &cpp_debug_options),
1230   INIT_STATIC_SPEC ("cpp_unique_options",       &cpp_unique_options),
1231   INIT_STATIC_SPEC ("trad_capable_cpp",         &trad_capable_cpp),
1232   INIT_STATIC_SPEC ("cc1",                      &cc1_spec),
1233   INIT_STATIC_SPEC ("cc1_options",              &cc1_options),
1234   INIT_STATIC_SPEC ("cc1plus",                  &cc1plus_spec),
1235   INIT_STATIC_SPEC ("link_gcc_c_sequence",      &link_gcc_c_sequence_spec),
1236   INIT_STATIC_SPEC ("link_ssp",                 &link_ssp_spec),
1237   INIT_STATIC_SPEC ("endfile",                  &endfile_spec),
1238   INIT_STATIC_SPEC ("link",                     &link_spec),
1239   INIT_STATIC_SPEC ("lib",                      &lib_spec),
1240   INIT_STATIC_SPEC ("mfwrap",                   &mfwrap_spec),
1241   INIT_STATIC_SPEC ("mflib",                    &mflib_spec),
1242   INIT_STATIC_SPEC ("link_gomp",                &link_gomp_spec),
1243   INIT_STATIC_SPEC ("libgcc",                   &libgcc_spec),
1244   INIT_STATIC_SPEC ("startfile",                &startfile_spec),
1245   INIT_STATIC_SPEC ("cross_compile",            &cross_compile),
1246   INIT_STATIC_SPEC ("version",                  &compiler_version),
1247   INIT_STATIC_SPEC ("multilib",                 &multilib_select),
1248   INIT_STATIC_SPEC ("multilib_defaults",        &multilib_defaults),
1249   INIT_STATIC_SPEC ("multilib_extra",           &multilib_extra),
1250   INIT_STATIC_SPEC ("multilib_matches",         &multilib_matches),
1251   INIT_STATIC_SPEC ("multilib_exclusions",      &multilib_exclusions),
1252   INIT_STATIC_SPEC ("multilib_options",         &multilib_options),
1253   INIT_STATIC_SPEC ("linker",                   &linker_name_spec),
1254   INIT_STATIC_SPEC ("linker_plugin_file",       &linker_plugin_file_spec),
1255   INIT_STATIC_SPEC ("lto_wrapper",              &lto_wrapper_spec),
1256   INIT_STATIC_SPEC ("lto_gcc",                  &lto_gcc_spec),
1257   INIT_STATIC_SPEC ("link_libgcc",              &link_libgcc_spec),
1258   INIT_STATIC_SPEC ("md_exec_prefix",           &md_exec_prefix),
1259   INIT_STATIC_SPEC ("md_startfile_prefix",      &md_startfile_prefix),
1260   INIT_STATIC_SPEC ("md_startfile_prefix_1",    &md_startfile_prefix_1),
1261   INIT_STATIC_SPEC ("startfile_prefix_spec",    &startfile_prefix_spec),
1262   INIT_STATIC_SPEC ("sysroot_spec",             &sysroot_spec),
1263   INIT_STATIC_SPEC ("sysroot_suffix_spec",      &sysroot_suffix_spec),
1264   INIT_STATIC_SPEC ("sysroot_hdrs_suffix_spec", &sysroot_hdrs_suffix_spec),
1265   INIT_STATIC_SPEC ("self_spec",                &self_spec),
1266 };
1267
1268 #ifdef EXTRA_SPECS              /* additional specs needed */
1269 /* Structure to keep track of just the first two args of a spec_list.
1270    That is all that the EXTRA_SPECS macro gives us.  */
1271 struct spec_list_1
1272 {
1273   const char *const name;
1274   const char *const ptr;
1275 };
1276
1277 static const struct spec_list_1 extra_specs_1[] = { EXTRA_SPECS };
1278 static struct spec_list *extra_specs = (struct spec_list *) 0;
1279 #endif
1280
1281 /* List of dynamically allocates specs that have been defined so far.  */
1282
1283 static struct spec_list *specs = (struct spec_list *) 0;
1284 \f
1285 /* List of static spec functions.  */
1286
1287 static const struct spec_function static_spec_functions[] =
1288 {
1289   { "getenv",                   getenv_spec_function },
1290   { "if-exists",                if_exists_spec_function },
1291   { "if-exists-else",           if_exists_else_spec_function },
1292   { "replace-outfile",          replace_outfile_spec_function },
1293   { "remove-outfile",           remove_outfile_spec_function },
1294   { "version-compare",          version_compare_spec_function },
1295   { "include",                  include_spec_function },
1296   { "find-file",                find_file_spec_function },
1297   { "find-plugindir",           find_plugindir_spec_function },
1298   { "print-asm-header",         print_asm_header_spec_function },
1299   { "compare-debug-dump-opt",   compare_debug_dump_opt_spec_function },
1300   { "compare-debug-self-opt",   compare_debug_self_opt_spec_function },
1301   { "compare-debug-auxbase-opt", compare_debug_auxbase_opt_spec_function },
1302   { "pass-through-libs",        pass_through_libs_spec_func },
1303   { "replace-extension",        replace_extension_spec_func },
1304 #ifdef EXTRA_SPEC_FUNCTIONS
1305   EXTRA_SPEC_FUNCTIONS
1306 #endif
1307   { 0, 0 }
1308 };
1309
1310 static int processing_spec_function;
1311 \f
1312 /* Add appropriate libgcc specs to OBSTACK, taking into account
1313    various permutations of -shared-libgcc, -shared, and such.  */
1314
1315 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1316
1317 #ifndef USE_LD_AS_NEEDED
1318 #define USE_LD_AS_NEEDED 0
1319 #endif
1320
1321 static void
1322 init_gcc_specs (struct obstack *obstack, const char *shared_name,
1323                 const char *static_name, const char *eh_name)
1324 {
1325   char *buf;
1326
1327   buf = concat ("%{static|static-libgcc:", static_name, " ", eh_name, "}"
1328                 "%{!static:%{!static-libgcc:"
1329 #if USE_LD_AS_NEEDED
1330                 "%{!shared-libgcc:",
1331                 static_name, " --as-needed ", shared_name, " --no-as-needed"
1332                 "}"
1333                 "%{shared-libgcc:",
1334                 shared_name, "%{!shared: ", static_name, "}"
1335                 "}"
1336 #else
1337                 "%{!shared:"
1338                 "%{!shared-libgcc:", static_name, " ", eh_name, "}"
1339                 "%{shared-libgcc:", shared_name, " ", static_name, "}"
1340                 "}"
1341 #ifdef LINK_EH_SPEC
1342                 "%{shared:"
1343                 "%{shared-libgcc:", shared_name, "}"
1344                 "%{!shared-libgcc:", static_name, "}"
1345                 "}"
1346 #else
1347                 "%{shared:", shared_name, "}"
1348 #endif
1349 #endif
1350                 "}}", NULL);
1351
1352   obstack_grow (obstack, buf, strlen (buf));
1353   free (buf);
1354 }
1355 #endif /* ENABLE_SHARED_LIBGCC */
1356
1357 /* Initialize the specs lookup routines.  */
1358
1359 static void
1360 init_spec (void)
1361 {
1362   struct spec_list *next = (struct spec_list *) 0;
1363   struct spec_list *sl   = (struct spec_list *) 0;
1364   int i;
1365
1366   if (specs)
1367     return;                     /* Already initialized.  */
1368
1369   if (verbose_flag)
1370     fnotice (stderr, "Using built-in specs.\n");
1371
1372 #ifdef EXTRA_SPECS
1373   extra_specs = XCNEWVEC (struct spec_list, ARRAY_SIZE (extra_specs_1));
1374
1375   for (i = ARRAY_SIZE (extra_specs_1) - 1; i >= 0; i--)
1376     {
1377       sl = &extra_specs[i];
1378       sl->name = extra_specs_1[i].name;
1379       sl->ptr = extra_specs_1[i].ptr;
1380       sl->next = next;
1381       sl->name_len = strlen (sl->name);
1382       sl->ptr_spec = &sl->ptr;
1383       next = sl;
1384     }
1385 #endif
1386
1387   for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1388     {
1389       sl = &static_specs[i];
1390       sl->next = next;
1391       next = sl;
1392     }
1393
1394 #if defined(ENABLE_SHARED_LIBGCC) && !defined(REAL_LIBGCC_SPEC)
1395   /* ??? If neither -shared-libgcc nor --static-libgcc was
1396      seen, then we should be making an educated guess.  Some proposed
1397      heuristics for ELF include:
1398
1399         (1) If "-Wl,--export-dynamic", then it's a fair bet that the
1400             program will be doing dynamic loading, which will likely
1401             need the shared libgcc.
1402
1403         (2) If "-ldl", then it's also a fair bet that we're doing
1404             dynamic loading.
1405
1406         (3) For each ET_DYN we're linking against (either through -lfoo
1407             or /some/path/foo.so), check to see whether it or one of
1408             its dependencies depends on a shared libgcc.
1409
1410         (4) If "-shared"
1411
1412             If the runtime is fixed to look for program headers instead
1413             of calling __register_frame_info at all, for each object,
1414             use the shared libgcc if any EH symbol referenced.
1415
1416             If crtstuff is fixed to not invoke __register_frame_info
1417             automatically, for each object, use the shared libgcc if
1418             any non-empty unwind section found.
1419
1420      Doing any of this probably requires invoking an external program to
1421      do the actual object file scanning.  */
1422   {
1423     const char *p = libgcc_spec;
1424     int in_sep = 1;
1425
1426     /* Transform the extant libgcc_spec into one that uses the shared libgcc
1427        when given the proper command line arguments.  */
1428     while (*p)
1429       {
1430         if (in_sep && *p == '-' && strncmp (p, "-lgcc", 5) == 0)
1431           {
1432             init_gcc_specs (&obstack,
1433                             "-lgcc_s"
1434 #ifdef USE_LIBUNWIND_EXCEPTIONS
1435                             " -lunwind"
1436 #endif
1437                             ,
1438                             "-lgcc",
1439                             "-lgcc_eh"
1440 #ifdef USE_LIBUNWIND_EXCEPTIONS
1441 # ifdef HAVE_LD_STATIC_DYNAMIC
1442                             " %{!static:" LD_STATIC_OPTION "} -lunwind"
1443                             " %{!static:" LD_DYNAMIC_OPTION "}"
1444 # else
1445                             " -lunwind"
1446 # endif
1447 #endif
1448                             );
1449
1450             p += 5;
1451             in_sep = 0;
1452           }
1453         else if (in_sep && *p == 'l' && strncmp (p, "libgcc.a%s", 10) == 0)
1454           {
1455             /* Ug.  We don't know shared library extensions.  Hope that
1456                systems that use this form don't do shared libraries.  */
1457             init_gcc_specs (&obstack,
1458                             "-lgcc_s",
1459                             "libgcc.a%s",
1460                             "libgcc_eh.a%s"
1461 #ifdef USE_LIBUNWIND_EXCEPTIONS
1462                             " -lunwind"
1463 #endif
1464                             );
1465             p += 10;
1466             in_sep = 0;
1467           }
1468         else
1469           {
1470             obstack_1grow (&obstack, *p);
1471             in_sep = (*p == ' ');
1472             p += 1;
1473           }
1474       }
1475
1476     obstack_1grow (&obstack, '\0');
1477     libgcc_spec = XOBFINISH (&obstack, const char *);
1478   }
1479 #endif
1480 #ifdef USE_AS_TRADITIONAL_FORMAT
1481   /* Prepend "--traditional-format" to whatever asm_spec we had before.  */
1482   {
1483     static const char tf[] = "--traditional-format ";
1484     obstack_grow (&obstack, tf, sizeof(tf) - 1);
1485     obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
1486     asm_spec = XOBFINISH (&obstack, const char *);
1487   }
1488 #endif
1489
1490 #if defined LINK_EH_SPEC || defined LINK_BUILDID_SPEC || \
1491     defined LINKER_HASH_STYLE
1492 # ifdef LINK_BUILDID_SPEC
1493   /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before.  */
1494   obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof(LINK_BUILDID_SPEC) - 1);
1495 # endif
1496 # ifdef LINK_EH_SPEC
1497   /* Prepend LINK_EH_SPEC to whatever link_spec we had before.  */
1498   obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
1499 # endif
1500 # ifdef LINKER_HASH_STYLE
1501   /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
1502      before.  */
1503   {
1504     static const char hash_style[] = "--hash-style=";
1505     obstack_grow (&obstack, hash_style, sizeof(hash_style) - 1);
1506     obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof(LINKER_HASH_STYLE) - 1);
1507     obstack_1grow (&obstack, ' ');
1508   }
1509 # endif
1510   obstack_grow0 (&obstack, link_spec, strlen (link_spec));
1511   link_spec = XOBFINISH (&obstack, const char *);
1512 #endif
1513
1514   specs = sl;
1515 }
1516 \f
1517 /* Change the value of spec NAME to SPEC.  If SPEC is empty, then the spec is
1518    removed; If the spec starts with a + then SPEC is added to the end of the
1519    current spec.  */
1520
1521 static void
1522 set_spec (const char *name, const char *spec, bool user_p)
1523 {
1524   struct spec_list *sl;
1525   const char *old_spec;
1526   int name_len = strlen (name);
1527   int i;
1528
1529   /* If this is the first call, initialize the statically allocated specs.  */
1530   if (!specs)
1531     {
1532       struct spec_list *next = (struct spec_list *) 0;
1533       for (i = ARRAY_SIZE (static_specs) - 1; i >= 0; i--)
1534         {
1535           sl = &static_specs[i];
1536           sl->next = next;
1537           next = sl;
1538         }
1539       specs = sl;
1540     }
1541
1542   /* See if the spec already exists.  */
1543   for (sl = specs; sl; sl = sl->next)
1544     if (name_len == sl->name_len && !strcmp (sl->name, name))
1545       break;
1546
1547   if (!sl)
1548     {
1549       /* Not found - make it.  */
1550       sl = XNEW (struct spec_list);
1551       sl->name = xstrdup (name);
1552       sl->name_len = name_len;
1553       sl->ptr_spec = &sl->ptr;
1554       sl->alloc_p = 0;
1555       *(sl->ptr_spec) = "";
1556       sl->next = specs;
1557       specs = sl;
1558     }
1559
1560   old_spec = *(sl->ptr_spec);
1561   *(sl->ptr_spec) = ((spec[0] == '+' && ISSPACE ((unsigned char)spec[1]))
1562                      ? concat (old_spec, spec + 1, NULL)
1563                      : xstrdup (spec));
1564
1565 #ifdef DEBUG_SPECS
1566   if (verbose_flag)
1567     fnotice (stderr, "Setting spec %s to '%s'\n\n", name, *(sl->ptr_spec));
1568 #endif
1569
1570   /* Free the old spec.  */
1571   if (old_spec && sl->alloc_p)
1572     free (CONST_CAST(char *, old_spec));
1573
1574   sl->user_p = user_p;
1575   sl->alloc_p = true;
1576 }
1577 \f
1578 /* Accumulate a command (program name and args), and run it.  */
1579
1580 typedef const char *const_char_p; /* For DEF_VEC_P.  */
1581
1582 /* Vector of pointers to arguments in the current line of specifications.  */
1583
1584 static vec<const_char_p> argbuf;
1585
1586 /* Position in the argbuf vector containing the name of the output file
1587    (the value associated with the "-o" flag).  */
1588
1589 static int have_o_argbuf_index = 0;
1590
1591 /* Were the options -c, -S or -E passed.  */
1592 static int have_c = 0;
1593
1594 /* Was the option -o passed.  */
1595 static int have_o = 0;
1596
1597 /* This is the list of suffixes and codes (%g/%u/%U/%j) and the associated
1598    temp file.  If the HOST_BIT_BUCKET is used for %j, no entry is made for
1599    it here.  */
1600
1601 static struct temp_name {
1602   const char *suffix;   /* suffix associated with the code.  */
1603   int length;           /* strlen (suffix).  */
1604   int unique;           /* Indicates whether %g or %u/%U was used.  */
1605   const char *filename; /* associated filename.  */
1606   int filename_length;  /* strlen (filename).  */
1607   struct temp_name *next;
1608 } *temp_names;
1609
1610 /* Number of commands executed so far.  */
1611
1612 static int execution_count;
1613
1614 /* Number of commands that exited with a signal.  */
1615
1616 static int signal_count;
1617 \f
1618 /* Allocate the argument vector.  */
1619
1620 static void
1621 alloc_args (void)
1622 {
1623   argbuf.create (10);
1624 }
1625
1626 /* Clear out the vector of arguments (after a command is executed).  */
1627
1628 static void
1629 clear_args (void)
1630 {
1631   argbuf.truncate (0);
1632 }
1633
1634 /* Add one argument to the vector at the end.
1635    This is done when a space is seen or at the end of the line.
1636    If DELETE_ALWAYS is nonzero, the arg is a filename
1637     and the file should be deleted eventually.
1638    If DELETE_FAILURE is nonzero, the arg is a filename
1639     and the file should be deleted if this compilation fails.  */
1640
1641 static void
1642 store_arg (const char *arg, int delete_always, int delete_failure)
1643 {
1644   argbuf.safe_push (arg);
1645
1646   if (strcmp (arg, "-o") == 0)
1647     have_o_argbuf_index = argbuf.length ();
1648   if (delete_always || delete_failure)
1649     {
1650       const char *p;
1651       /* If the temporary file we should delete is specified as
1652          part of a joined argument extract the filename.  */
1653       if (arg[0] == '-'
1654           && (p = strrchr (arg, '=')))
1655         arg = p + 1;
1656       record_temp_file (arg, delete_always, delete_failure);
1657     }
1658 }
1659 \f
1660 /* Load specs from a file name named FILENAME, replacing occurrences of
1661    various different types of line-endings, \r\n, \n\r and just \r, with
1662    a single \n.  */
1663
1664 static char *
1665 load_specs (const char *filename)
1666 {
1667   int desc;
1668   int readlen;
1669   struct stat statbuf;
1670   char *buffer;
1671   char *buffer_p;
1672   char *specs;
1673   char *specs_p;
1674
1675   if (verbose_flag)
1676     fnotice (stderr, "Reading specs from %s\n", filename);
1677
1678   /* Open and stat the file.  */
1679   desc = open (filename, O_RDONLY, 0);
1680   if (desc < 0)
1681     pfatal_with_name (filename);
1682   if (stat (filename, &statbuf) < 0)
1683     pfatal_with_name (filename);
1684
1685   /* Read contents of file into BUFFER.  */
1686   buffer = XNEWVEC (char, statbuf.st_size + 1);
1687   readlen = read (desc, buffer, (unsigned) statbuf.st_size);
1688   if (readlen < 0)
1689     pfatal_with_name (filename);
1690   buffer[readlen] = 0;
1691   close (desc);
1692
1693   specs = XNEWVEC (char, readlen + 1);
1694   specs_p = specs;
1695   for (buffer_p = buffer; buffer_p && *buffer_p; buffer_p++)
1696     {
1697       int skip = 0;
1698       char c = *buffer_p;
1699       if (c == '\r')
1700         {
1701           if (buffer_p > buffer && *(buffer_p - 1) == '\n')     /* \n\r */
1702             skip = 1;
1703           else if (*(buffer_p + 1) == '\n')                     /* \r\n */
1704             skip = 1;
1705           else                                                  /* \r */
1706             c = '\n';
1707         }
1708       if (! skip)
1709         *specs_p++ = c;
1710     }
1711   *specs_p = '\0';
1712
1713   free (buffer);
1714   return (specs);
1715 }
1716
1717 /* Read compilation specs from a file named FILENAME,
1718    replacing the default ones.
1719
1720    A suffix which starts with `*' is a definition for
1721    one of the machine-specific sub-specs.  The "suffix" should be
1722    *asm, *cc1, *cpp, *link, *startfile, etc.
1723    The corresponding spec is stored in asm_spec, etc.,
1724    rather than in the `compilers' vector.
1725
1726    Anything invalid in the file is a fatal error.  */
1727
1728 static void
1729 read_specs (const char *filename, bool main_p, bool user_p)
1730 {
1731   char *buffer;
1732   char *p;
1733
1734   buffer = load_specs (filename);
1735
1736   /* Scan BUFFER for specs, putting them in the vector.  */
1737   p = buffer;
1738   while (1)
1739     {
1740       char *suffix;
1741       char *spec;
1742       char *in, *out, *p1, *p2, *p3;
1743
1744       /* Advance P in BUFFER to the next nonblank nocomment line.  */
1745       p = skip_whitespace (p);
1746       if (*p == 0)
1747         break;
1748
1749       /* Is this a special command that starts with '%'? */
1750       /* Don't allow this for the main specs file, since it would
1751          encourage people to overwrite it.  */
1752       if (*p == '%' && !main_p)
1753         {
1754           p1 = p;
1755           while (*p && *p != '\n')
1756             p++;
1757
1758           /* Skip '\n'.  */
1759           p++;
1760
1761           if (!strncmp (p1, "%include", sizeof ("%include") - 1)
1762               && (p1[sizeof "%include" - 1] == ' '
1763                   || p1[sizeof "%include" - 1] == '\t'))
1764             {
1765               char *new_filename;
1766
1767               p1 += sizeof ("%include");
1768               while (*p1 == ' ' || *p1 == '\t')
1769                 p1++;
1770
1771               if (*p1++ != '<' || p[-2] != '>')
1772                 fatal_error ("specs %%include syntax malformed after "
1773                              "%ld characters",
1774                              (long) (p1 - buffer + 1));
1775
1776               p[-2] = '\0';
1777               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1778               read_specs (new_filename ? new_filename : p1, false, user_p);
1779               continue;
1780             }
1781           else if (!strncmp (p1, "%include_noerr", sizeof "%include_noerr" - 1)
1782                    && (p1[sizeof "%include_noerr" - 1] == ' '
1783                        || p1[sizeof "%include_noerr" - 1] == '\t'))
1784             {
1785               char *new_filename;
1786
1787               p1 += sizeof "%include_noerr";
1788               while (*p1 == ' ' || *p1 == '\t')
1789                 p1++;
1790
1791               if (*p1++ != '<' || p[-2] != '>')
1792                 fatal_error ("specs %%include syntax malformed after "
1793                              "%ld characters",
1794                              (long) (p1 - buffer + 1));
1795
1796               p[-2] = '\0';
1797               new_filename = find_a_file (&startfile_prefixes, p1, R_OK, true);
1798               if (new_filename)
1799                 read_specs (new_filename, false, user_p);
1800               else if (verbose_flag)
1801                 fnotice (stderr, "could not find specs file %s\n", p1);
1802               continue;
1803             }
1804           else if (!strncmp (p1, "%rename", sizeof "%rename" - 1)
1805                    && (p1[sizeof "%rename" - 1] == ' '
1806                        || p1[sizeof "%rename" - 1] == '\t'))
1807             {
1808               int name_len;
1809               struct spec_list *sl;
1810               struct spec_list *newsl;
1811
1812               /* Get original name.  */
1813               p1 += sizeof "%rename";
1814               while (*p1 == ' ' || *p1 == '\t')
1815                 p1++;
1816
1817               if (! ISALPHA ((unsigned char) *p1))
1818                 fatal_error ("specs %%rename syntax malformed after "
1819                              "%ld characters",
1820                              (long) (p1 - buffer));
1821
1822               p2 = p1;
1823               while (*p2 && !ISSPACE ((unsigned char) *p2))
1824                 p2++;
1825
1826               if (*p2 != ' ' && *p2 != '\t')
1827                 fatal_error ("specs %%rename syntax malformed after "
1828                              "%ld characters",
1829                              (long) (p2 - buffer));
1830
1831               name_len = p2 - p1;
1832               *p2++ = '\0';
1833               while (*p2 == ' ' || *p2 == '\t')
1834                 p2++;
1835
1836               if (! ISALPHA ((unsigned char) *p2))
1837                 fatal_error ("specs %%rename syntax malformed after "
1838                              "%ld characters",
1839                              (long) (p2 - buffer));
1840
1841               /* Get new spec name.  */
1842               p3 = p2;
1843               while (*p3 && !ISSPACE ((unsigned char) *p3))
1844                 p3++;
1845
1846               if (p3 != p - 1)
1847                 fatal_error ("specs %%rename syntax malformed after "
1848                              "%ld characters",
1849                              (long) (p3 - buffer));
1850               *p3 = '\0';
1851
1852               for (sl = specs; sl; sl = sl->next)
1853                 if (name_len == sl->name_len && !strcmp (sl->name, p1))
1854                   break;
1855
1856               if (!sl)
1857                 fatal_error ("specs %s spec was not found to be renamed", p1);
1858
1859               if (strcmp (p1, p2) == 0)
1860                 continue;
1861
1862               for (newsl = specs; newsl; newsl = newsl->next)
1863                 if (strcmp (newsl->name, p2) == 0)
1864                   fatal_error ("%s: attempt to rename spec %qs to "
1865                                "already defined spec %qs",
1866                     filename, p1, p2);
1867
1868               if (verbose_flag)
1869                 {
1870                   fnotice (stderr, "rename spec %s to %s\n", p1, p2);
1871 #ifdef DEBUG_SPECS
1872                   fnotice (stderr, "spec is '%s'\n\n", *(sl->ptr_spec));
1873 #endif
1874                 }
1875
1876               set_spec (p2, *(sl->ptr_spec), user_p);
1877               if (sl->alloc_p)
1878                 free (CONST_CAST (char *, *(sl->ptr_spec)));
1879
1880               *(sl->ptr_spec) = "";
1881               sl->alloc_p = 0;
1882               continue;
1883             }
1884           else
1885             fatal_error ("specs unknown %% command after %ld characters",
1886                          (long) (p1 - buffer));
1887         }
1888
1889       /* Find the colon that should end the suffix.  */
1890       p1 = p;
1891       while (*p1 && *p1 != ':' && *p1 != '\n')
1892         p1++;
1893
1894       /* The colon shouldn't be missing.  */
1895       if (*p1 != ':')
1896         fatal_error ("specs file malformed after %ld characters",
1897                      (long) (p1 - buffer));
1898
1899       /* Skip back over trailing whitespace.  */
1900       p2 = p1;
1901       while (p2 > buffer && (p2[-1] == ' ' || p2[-1] == '\t'))
1902         p2--;
1903
1904       /* Copy the suffix to a string.  */
1905       suffix = save_string (p, p2 - p);
1906       /* Find the next line.  */
1907       p = skip_whitespace (p1 + 1);
1908       if (p[1] == 0)
1909         fatal_error ("specs file malformed after %ld characters",
1910                      (long) (p - buffer));
1911
1912       p1 = p;
1913       /* Find next blank line or end of string.  */
1914       while (*p1 && !(*p1 == '\n' && (p1[1] == '\n' || p1[1] == '\0')))
1915         p1++;
1916
1917       /* Specs end at the blank line and do not include the newline.  */
1918       spec = save_string (p, p1 - p);
1919       p = p1;
1920
1921       /* Delete backslash-newline sequences from the spec.  */
1922       in = spec;
1923       out = spec;
1924       while (*in != 0)
1925         {
1926           if (in[0] == '\\' && in[1] == '\n')
1927             in += 2;
1928           else if (in[0] == '#')
1929             while (*in && *in != '\n')
1930               in++;
1931
1932           else
1933             *out++ = *in++;
1934         }
1935       *out = 0;
1936
1937       if (suffix[0] == '*')
1938         {
1939           if (! strcmp (suffix, "*link_command"))
1940             link_command_spec = spec;
1941           else
1942             set_spec (suffix + 1, spec, user_p);
1943         }
1944       else
1945         {
1946           /* Add this pair to the vector.  */
1947           compilers
1948             = XRESIZEVEC (struct compiler, compilers, n_compilers + 2);
1949
1950           compilers[n_compilers].suffix = suffix;
1951           compilers[n_compilers].spec = spec;
1952           n_compilers++;
1953           memset (&compilers[n_compilers], 0, sizeof compilers[n_compilers]);
1954         }
1955
1956       if (*suffix == 0)
1957         link_command_spec = spec;
1958     }
1959
1960   if (link_command_spec == 0)
1961     fatal_error ("spec file has no spec for linking");
1962 }
1963 \f
1964 /* Record the names of temporary files we tell compilers to write,
1965    and delete them at the end of the run.  */
1966
1967 /* This is the common prefix we use to make temp file names.
1968    It is chosen once for each run of this program.
1969    It is substituted into a spec by %g or %j.
1970    Thus, all temp file names contain this prefix.
1971    In practice, all temp file names start with this prefix.
1972
1973    This prefix comes from the envvar TMPDIR if it is defined;
1974    otherwise, from the P_tmpdir macro if that is defined;
1975    otherwise, in /usr/tmp or /tmp;
1976    or finally the current directory if all else fails.  */
1977
1978 static const char *temp_filename;
1979
1980 /* Length of the prefix.  */
1981
1982 static int temp_filename_length;
1983
1984 /* Define the list of temporary files to delete.  */
1985
1986 struct temp_file
1987 {
1988   const char *name;
1989   struct temp_file *next;
1990 };
1991
1992 /* Queue of files to delete on success or failure of compilation.  */
1993 static struct temp_file *always_delete_queue;
1994 /* Queue of files to delete on failure of compilation.  */
1995 static struct temp_file *failure_delete_queue;
1996
1997 /* Record FILENAME as a file to be deleted automatically.
1998    ALWAYS_DELETE nonzero means delete it if all compilation succeeds;
1999    otherwise delete it in any case.
2000    FAIL_DELETE nonzero means delete it if a compilation step fails;
2001    otherwise delete it in any case.  */
2002
2003 void
2004 record_temp_file (const char *filename, int always_delete, int fail_delete)
2005 {
2006   char *const name = xstrdup (filename);
2007
2008   if (always_delete)
2009     {
2010       struct temp_file *temp;
2011       for (temp = always_delete_queue; temp; temp = temp->next)
2012         if (! filename_cmp (name, temp->name))
2013           goto already1;
2014
2015       temp = XNEW (struct temp_file);
2016       temp->next = always_delete_queue;
2017       temp->name = name;
2018       always_delete_queue = temp;
2019
2020     already1:;
2021     }
2022
2023   if (fail_delete)
2024     {
2025       struct temp_file *temp;
2026       for (temp = failure_delete_queue; temp; temp = temp->next)
2027         if (! filename_cmp (name, temp->name))
2028           {
2029             free (name);
2030             goto already2;
2031           }
2032
2033       temp = XNEW (struct temp_file);
2034       temp->next = failure_delete_queue;
2035       temp->name = name;
2036       failure_delete_queue = temp;
2037
2038     already2:;
2039     }
2040 }
2041
2042 /* Delete all the temporary files whose names we previously recorded.  */
2043
2044 #ifndef DELETE_IF_ORDINARY
2045 #define DELETE_IF_ORDINARY(NAME,ST,VERBOSE_FLAG)        \
2046 do                                                      \
2047   {                                                     \
2048     if (stat (NAME, &ST) >= 0 && S_ISREG (ST.st_mode))  \
2049       if (unlink (NAME) < 0)                            \
2050         if (VERBOSE_FLAG)                               \
2051           perror_with_name (NAME);                      \
2052   } while (0)
2053 #endif
2054
2055 static void
2056 delete_if_ordinary (const char *name)
2057 {
2058   struct stat st;
2059 #ifdef DEBUG
2060   int i, c;
2061
2062   printf ("Delete %s? (y or n) ", name);
2063   fflush (stdout);
2064   i = getchar ();
2065   if (i != '\n')
2066     while ((c = getchar ()) != '\n' && c != EOF)
2067       ;
2068
2069   if (i == 'y' || i == 'Y')
2070 #endif /* DEBUG */
2071   DELETE_IF_ORDINARY (name, st, verbose_flag);
2072 }
2073
2074 static void
2075 delete_temp_files (void)
2076 {
2077   struct temp_file *temp;
2078
2079   for (temp = always_delete_queue; temp; temp = temp->next)
2080     delete_if_ordinary (temp->name);
2081   always_delete_queue = 0;
2082 }
2083
2084 /* Delete all the files to be deleted on error.  */
2085
2086 static void
2087 delete_failure_queue (void)
2088 {
2089   struct temp_file *temp;
2090
2091   for (temp = failure_delete_queue; temp; temp = temp->next)
2092     delete_if_ordinary (temp->name);
2093 }
2094
2095 static void
2096 clear_failure_queue (void)
2097 {
2098   failure_delete_queue = 0;
2099 }
2100 \f
2101 /* Call CALLBACK for each path in PATHS, breaking out early if CALLBACK
2102    returns non-NULL.
2103    If DO_MULTI is true iterate over the paths twice, first with multilib
2104    suffix then without, otherwise iterate over the paths once without
2105    adding a multilib suffix.  When DO_MULTI is true, some attempt is made
2106    to avoid visiting the same path twice, but we could do better.  For
2107    instance, /usr/lib/../lib is considered different from /usr/lib.
2108    At least EXTRA_SPACE chars past the end of the path passed to
2109    CALLBACK are available for use by the callback.
2110    CALLBACK_INFO allows extra parameters to be passed to CALLBACK.
2111
2112    Returns the value returned by CALLBACK.  */
2113
2114 static void *
2115 for_each_path (const struct path_prefix *paths,
2116                bool do_multi,
2117                size_t extra_space,
2118                void *(*callback) (char *, void *),
2119                void *callback_info)
2120 {
2121   struct prefix_list *pl;
2122   const char *multi_dir = NULL;
2123   const char *multi_os_dir = NULL;
2124   const char *multiarch_suffix = NULL;
2125   const char *multi_suffix;
2126   const char *just_multi_suffix;
2127   char *path = NULL;
2128   void *ret = NULL;
2129   bool skip_multi_dir = false;
2130   bool skip_multi_os_dir = false;
2131
2132   multi_suffix = machine_suffix;
2133   just_multi_suffix = just_machine_suffix;
2134   if (do_multi && multilib_dir && strcmp (multilib_dir, ".") != 0)
2135     {
2136       multi_dir = concat (multilib_dir, dir_separator_str, NULL);
2137       multi_suffix = concat (multi_suffix, multi_dir, NULL);
2138       just_multi_suffix = concat (just_multi_suffix, multi_dir, NULL);
2139     }
2140   if (do_multi && multilib_os_dir && strcmp (multilib_os_dir, ".") != 0)
2141     multi_os_dir = concat (multilib_os_dir, dir_separator_str, NULL);
2142   if (multiarch_dir)
2143     multiarch_suffix = concat (multiarch_dir, dir_separator_str, NULL);
2144
2145   while (1)
2146     {
2147       size_t multi_dir_len = 0;
2148       size_t multi_os_dir_len = 0;
2149       size_t multiarch_len = 0;
2150       size_t suffix_len;
2151       size_t just_suffix_len;
2152       size_t len;
2153
2154       if (multi_dir)
2155         multi_dir_len = strlen (multi_dir);
2156       if (multi_os_dir)
2157         multi_os_dir_len = strlen (multi_os_dir);
2158       if (multiarch_suffix)
2159         multiarch_len = strlen (multiarch_suffix);
2160       suffix_len = strlen (multi_suffix);
2161       just_suffix_len = strlen (just_multi_suffix);
2162
2163       if (path == NULL)
2164         {
2165           len = paths->max_len + extra_space + 1;
2166           len += MAX (MAX (suffix_len, multi_os_dir_len), multiarch_len);
2167           path = XNEWVEC (char, len);
2168         }
2169
2170       for (pl = paths->plist; pl != 0; pl = pl->next)
2171         {
2172           len = strlen (pl->prefix);
2173           memcpy (path, pl->prefix, len);
2174
2175           /* Look first in MACHINE/VERSION subdirectory.  */
2176           if (!skip_multi_dir)
2177             {
2178               memcpy (path + len, multi_suffix, suffix_len + 1);
2179               ret = callback (path, callback_info);
2180               if (ret)
2181                 break;
2182             }
2183
2184           /* Some paths are tried with just the machine (ie. target)
2185              subdir.  This is used for finding as, ld, etc.  */
2186           if (!skip_multi_dir
2187               && pl->require_machine_suffix == 2)
2188             {
2189               memcpy (path + len, just_multi_suffix, just_suffix_len + 1);
2190               ret = callback (path, callback_info);
2191               if (ret)
2192                 break;
2193             }
2194
2195           /* Now try the multiarch path.  */
2196           if (!skip_multi_dir
2197               && !pl->require_machine_suffix && multiarch_dir)
2198             {
2199               memcpy (path + len, multiarch_suffix, multiarch_len + 1);
2200               ret = callback (path, callback_info);
2201               if (ret)
2202                 break;
2203             }
2204
2205           /* Now try the base path.  */
2206           if (!pl->require_machine_suffix
2207               && !(pl->os_multilib ? skip_multi_os_dir : skip_multi_dir))
2208             {
2209               const char *this_multi;
2210               size_t this_multi_len;
2211
2212               if (pl->os_multilib)
2213                 {
2214                   this_multi = multi_os_dir;
2215                   this_multi_len = multi_os_dir_len;
2216                 }
2217               else
2218                 {
2219                   this_multi = multi_dir;
2220                   this_multi_len = multi_dir_len;
2221                 }
2222
2223               if (this_multi_len)
2224                 memcpy (path + len, this_multi, this_multi_len + 1);
2225               else
2226                 path[len] = '\0';
2227
2228               ret = callback (path, callback_info);
2229               if (ret)
2230                 break;
2231             }
2232         }
2233       if (pl)
2234         break;
2235
2236       if (multi_dir == NULL && multi_os_dir == NULL)
2237         break;
2238
2239       /* Run through the paths again, this time without multilibs.
2240          Don't repeat any we have already seen.  */
2241       if (multi_dir)
2242         {
2243           free (CONST_CAST (char *, multi_dir));
2244           multi_dir = NULL;
2245           free (CONST_CAST (char *, multi_suffix));
2246           multi_suffix = machine_suffix;
2247           free (CONST_CAST (char *, just_multi_suffix));
2248           just_multi_suffix = just_machine_suffix;
2249         }
2250       else
2251         skip_multi_dir = true;
2252       if (multi_os_dir)
2253         {
2254           free (CONST_CAST (char *, multi_os_dir));
2255           multi_os_dir = NULL;
2256         }
2257       else
2258         skip_multi_os_dir = true;
2259     }
2260
2261   if (multi_dir)
2262     {
2263       free (CONST_CAST (char *, multi_dir));
2264       free (CONST_CAST (char *, multi_suffix));
2265       free (CONST_CAST (char *, just_multi_suffix));
2266     }
2267   if (multi_os_dir)
2268     free (CONST_CAST (char *, multi_os_dir));
2269   if (ret != path)
2270     free (path);
2271   return ret;
2272 }
2273
2274 /* Callback for build_search_list.  Adds path to obstack being built.  */
2275
2276 struct add_to_obstack_info {
2277   struct obstack *ob;
2278   bool check_dir;
2279   bool first_time;
2280 };
2281
2282 static void *
2283 add_to_obstack (char *path, void *data)
2284 {
2285   struct add_to_obstack_info *info = (struct add_to_obstack_info *) data;
2286
2287   if (info->check_dir && !is_directory (path, false))
2288     return NULL;
2289
2290   if (!info->first_time)
2291     obstack_1grow (info->ob, PATH_SEPARATOR);
2292
2293   obstack_grow (info->ob, path, strlen (path));
2294
2295   info->first_time = false;
2296   return NULL;
2297 }
2298
2299 /* Add or change the value of an environment variable, outputting the
2300    change to standard error if in verbose mode.  */
2301 static void
2302 xputenv (const char *string)
2303 {
2304   if (verbose_flag)
2305     fnotice (stderr, "%s\n", string);
2306   putenv (CONST_CAST (char *, string));
2307 }
2308
2309 /* Build a list of search directories from PATHS.
2310    PREFIX is a string to prepend to the list.
2311    If CHECK_DIR_P is true we ensure the directory exists.
2312    If DO_MULTI is true, multilib paths are output first, then
2313    non-multilib paths.
2314    This is used mostly by putenv_from_prefixes so we use `collect_obstack'.
2315    It is also used by the --print-search-dirs flag.  */
2316
2317 static char *
2318 build_search_list (const struct path_prefix *paths, const char *prefix,
2319                    bool check_dir, bool do_multi)
2320 {
2321   struct add_to_obstack_info info;
2322
2323   info.ob = &collect_obstack;
2324   info.check_dir = check_dir;
2325   info.first_time = true;
2326
2327   obstack_grow (&collect_obstack, prefix, strlen (prefix));
2328   obstack_1grow (&collect_obstack, '=');
2329
2330   for_each_path (paths, do_multi, 0, add_to_obstack, &info);
2331
2332   obstack_1grow (&collect_obstack, '\0');
2333   return XOBFINISH (&collect_obstack, char *);
2334 }
2335
2336 /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
2337    for collect.  */
2338
2339 static void
2340 putenv_from_prefixes (const struct path_prefix *paths, const char *env_var,
2341                       bool do_multi)
2342 {
2343   xputenv (build_search_list (paths, env_var, true, do_multi));
2344 }
2345 \f
2346 /* Check whether NAME can be accessed in MODE.  This is like access,
2347    except that it never considers directories to be executable.  */
2348
2349 static int
2350 access_check (const char *name, int mode)
2351 {
2352   if (mode == X_OK)
2353     {
2354       struct stat st;
2355
2356       if (stat (name, &st) < 0
2357           || S_ISDIR (st.st_mode))
2358         return -1;
2359     }
2360
2361   return access (name, mode);
2362 }
2363
2364 /* Callback for find_a_file.  Appends the file name to the directory
2365    path.  If the resulting file exists in the right mode, return the
2366    full pathname to the file.  */
2367
2368 struct file_at_path_info {
2369   const char *name;
2370   const char *suffix;
2371   int name_len;
2372   int suffix_len;
2373   int mode;
2374 };
2375
2376 static void *
2377 file_at_path (char *path, void *data)
2378 {
2379   struct file_at_path_info *info = (struct file_at_path_info *) data;
2380   size_t len = strlen (path);
2381
2382   memcpy (path + len, info->name, info->name_len);
2383   len += info->name_len;
2384
2385   /* Some systems have a suffix for executable files.
2386      So try appending that first.  */
2387   if (info->suffix_len)
2388     {
2389       memcpy (path + len, info->suffix, info->suffix_len + 1);
2390       if (access_check (path, info->mode) == 0)
2391         return path;
2392     }
2393
2394   path[len] = '\0';
2395   if (access_check (path, info->mode) == 0)
2396     return path;
2397
2398   return NULL;
2399 }
2400
2401 /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
2402    access to check permissions.  If DO_MULTI is true, search multilib
2403    paths then non-multilib paths, otherwise do not search multilib paths.
2404    Return 0 if not found, otherwise return its name, allocated with malloc.  */
2405
2406 static char *
2407 find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
2408              bool do_multi)
2409 {
2410   struct file_at_path_info info;
2411
2412 #ifdef DEFAULT_ASSEMBLER
2413   if (! strcmp (name, "as") && access (DEFAULT_ASSEMBLER, mode) == 0)
2414     return xstrdup (DEFAULT_ASSEMBLER);
2415 #endif
2416
2417 #ifdef DEFAULT_LINKER
2418   if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
2419     return xstrdup (DEFAULT_LINKER);
2420 #endif
2421
2422   /* Determine the filename to execute (special case for absolute paths).  */
2423
2424   if (IS_ABSOLUTE_PATH (name))
2425     {
2426       if (access (name, mode) == 0)
2427         return xstrdup (name);
2428
2429       return NULL;
2430     }
2431
2432   info.name = name;
2433   info.suffix = (mode & X_OK) != 0 ? HOST_EXECUTABLE_SUFFIX : "";
2434   info.name_len = strlen (info.name);
2435   info.suffix_len = strlen (info.suffix);
2436   info.mode = mode;
2437
2438   return (char*) for_each_path (pprefix, do_multi,
2439                                 info.name_len + info.suffix_len,
2440                                 file_at_path, &info);
2441 }
2442
2443 /* Ranking of prefixes in the sort list. -B prefixes are put before
2444    all others.  */
2445
2446 enum path_prefix_priority
2447 {
2448   PREFIX_PRIORITY_B_OPT,
2449   PREFIX_PRIORITY_LAST
2450 };
2451
2452 /* Add an entry for PREFIX in PLIST.  The PLIST is kept in ascending
2453    order according to PRIORITY.  Within each PRIORITY, new entries are
2454    appended.
2455
2456    If WARN is nonzero, we will warn if no file is found
2457    through this prefix.  WARN should point to an int
2458    which will be set to 1 if this entry is used.
2459
2460    COMPONENT is the value to be passed to update_path.
2461
2462    REQUIRE_MACHINE_SUFFIX is 1 if this prefix can't be used without
2463    the complete value of machine_suffix.
2464    2 means try both machine_suffix and just_machine_suffix.  */
2465
2466 static void
2467 add_prefix (struct path_prefix *pprefix, const char *prefix,
2468             const char *component, /* enum prefix_priority */ int priority,
2469             int require_machine_suffix, int os_multilib)
2470 {
2471   struct prefix_list *pl, **prev;
2472   int len;
2473
2474   for (prev = &pprefix->plist;
2475        (*prev) != NULL && (*prev)->priority <= priority;
2476        prev = &(*prev)->next)
2477     ;
2478
2479   /* Keep track of the longest prefix.  */
2480
2481   prefix = update_path (prefix, component);
2482   len = strlen (prefix);
2483   if (len > pprefix->max_len)
2484     pprefix->max_len = len;
2485
2486   pl = XNEW (struct prefix_list);
2487   pl->prefix = prefix;
2488   pl->require_machine_suffix = require_machine_suffix;
2489   pl->priority = priority;
2490   pl->os_multilib = os_multilib;
2491
2492   /* Insert after PREV.  */
2493   pl->next = (*prev);
2494   (*prev) = pl;
2495 }
2496
2497 /* Same as add_prefix, but prepending target_system_root to prefix.  */
2498 /* The target_system_root prefix has been relocated by gcc_exec_prefix.  */
2499 static void
2500 add_sysrooted_prefix (struct path_prefix *pprefix, const char *prefix,
2501                       const char *component,
2502                       /* enum prefix_priority */ int priority,
2503                       int require_machine_suffix, int os_multilib)
2504 {
2505   if (!IS_ABSOLUTE_PATH (prefix))
2506     fatal_error ("system path %qs is not absolute", prefix);
2507
2508   if (target_system_root)
2509     {
2510       char *sysroot_no_trailing_dir_separator = xstrdup (target_system_root);
2511       size_t sysroot_len = strlen (target_system_root);
2512
2513       if (sysroot_len > 0
2514           && target_system_root[sysroot_len - 1] == DIR_SEPARATOR)
2515         sysroot_no_trailing_dir_separator[sysroot_len - 1] = '\0';
2516
2517       if (target_sysroot_suffix)
2518         prefix = concat (sysroot_no_trailing_dir_separator,
2519                          target_sysroot_suffix, prefix, NULL);
2520       else
2521         prefix = concat (sysroot_no_trailing_dir_separator, prefix, NULL);
2522
2523       free (sysroot_no_trailing_dir_separator);
2524
2525       /* We have to override this because GCC's notion of sysroot
2526          moves along with GCC.  */
2527       component = "GCC";
2528     }
2529
2530   add_prefix (pprefix, prefix, component, priority,
2531               require_machine_suffix, os_multilib);
2532 }
2533 \f
2534 /* Execute the command specified by the arguments on the current line of spec.
2535    When using pipes, this includes several piped-together commands
2536    with `|' between them.
2537
2538    Return 0 if successful, -1 if failed.  */
2539
2540 static int
2541 execute (void)
2542 {
2543   int i;
2544   int n_commands;               /* # of command.  */
2545   char *string;
2546   struct pex_obj *pex;
2547   struct command
2548   {
2549     const char *prog;           /* program name.  */
2550     const char **argv;          /* vector of args.  */
2551   };
2552   const char *arg;
2553
2554   struct command *commands;     /* each command buffer with above info.  */
2555
2556   gcc_assert (!processing_spec_function);
2557
2558   if (wrapper_string)
2559     {
2560       string = find_a_file (&exec_prefixes,
2561                             argbuf[0], X_OK, false);
2562       if (string)
2563         argbuf[0] = string;
2564       insert_wrapper (wrapper_string);
2565     }
2566
2567   /* Count # of piped commands.  */
2568   for (n_commands = 1, i = 0; argbuf.iterate (i, &arg); i++)
2569     if (strcmp (arg, "|") == 0)
2570       n_commands++;
2571
2572   /* Get storage for each command.  */
2573   commands = (struct command *) alloca (n_commands * sizeof (struct command));
2574
2575   /* Split argbuf into its separate piped processes,
2576      and record info about each one.
2577      Also search for the programs that are to be run.  */
2578
2579   argbuf.safe_push (0);
2580
2581   commands[0].prog = argbuf[0]; /* first command.  */
2582   commands[0].argv = argbuf.address ();
2583
2584   if (!wrapper_string)
2585     {
2586       string = find_a_file (&exec_prefixes, commands[0].prog, X_OK, false);
2587       commands[0].argv[0] = (string) ? string : commands[0].argv[0];
2588     }
2589
2590   for (n_commands = 1, i = 0; argbuf.iterate (i, &arg); i++)
2591     if (arg && strcmp (arg, "|") == 0)
2592       {                         /* each command.  */
2593 #if defined (__MSDOS__) || defined (OS2) || defined (VMS)
2594         fatal_error ("-pipe not supported");
2595 #endif
2596         argbuf[i] = 0; /* Termination of
2597                                                      command args.  */
2598         commands[n_commands].prog = argbuf[i + 1];
2599         commands[n_commands].argv
2600           = &(argbuf.address ())[i + 1];
2601         string = find_a_file (&exec_prefixes, commands[n_commands].prog,
2602                               X_OK, false);
2603         if (string)
2604           commands[n_commands].argv[0] = string;
2605         n_commands++;
2606       }
2607
2608   /* If -v, print what we are about to do, and maybe query.  */
2609
2610   if (verbose_flag)
2611     {
2612       /* For help listings, put a blank line between sub-processes.  */
2613       if (print_help_list)
2614         fputc ('\n', stderr);
2615
2616       /* Print each piped command as a separate line.  */
2617       for (i = 0; i < n_commands; i++)
2618         {
2619           const char *const *j;
2620
2621           if (verbose_only_flag)
2622             {
2623               for (j = commands[i].argv; *j; j++)
2624                 {
2625                   const char *p;
2626                   for (p = *j; *p; ++p)
2627                     if (!ISALNUM ((unsigned char) *p)
2628                         && *p != '_' && *p != '/' && *p != '-' && *p != '.')
2629                       break;
2630                   if (*p || !*j)
2631                     {
2632                       fprintf (stderr, " \"");
2633                       for (p = *j; *p; ++p)
2634                         {
2635                           if (*p == '"' || *p == '\\' || *p == '$')
2636                             fputc ('\\', stderr);
2637                           fputc (*p, stderr);
2638                         }
2639                       fputc ('"', stderr);
2640                     }
2641                   /* If it's empty, print "".  */
2642                   else if (!**j)
2643                     fprintf (stderr, " \"\"");
2644                   else
2645                     fprintf (stderr, " %s", *j);
2646                 }
2647             }
2648           else
2649             for (j = commands[i].argv; *j; j++)
2650               /* If it's empty, print "".  */
2651               if (!**j)
2652                 fprintf (stderr, " \"\"");
2653               else
2654                 fprintf (stderr, " %s", *j);
2655
2656           /* Print a pipe symbol after all but the last command.  */
2657           if (i + 1 != n_commands)
2658             fprintf (stderr, " |");
2659           fprintf (stderr, "\n");
2660         }
2661       fflush (stderr);
2662       if (verbose_only_flag != 0)
2663         {
2664           /* verbose_only_flag should act as if the spec was
2665              executed, so increment execution_count before
2666              returning.  This prevents spurious warnings about
2667              unused linker input files, etc.  */
2668           execution_count++;
2669           return 0;
2670         }
2671 #ifdef DEBUG
2672       fnotice (stderr, "\nGo ahead? (y or n) ");
2673       fflush (stderr);
2674       i = getchar ();
2675       if (i != '\n')
2676         while (getchar () != '\n')
2677           ;
2678
2679       if (i != 'y' && i != 'Y')
2680         return 0;
2681 #endif /* DEBUG */
2682     }
2683
2684 #ifdef ENABLE_VALGRIND_CHECKING
2685   /* Run the each command through valgrind.  To simplify prepending the
2686      path to valgrind and the option "-q" (for quiet operation unless
2687      something triggers), we allocate a separate argv array.  */
2688
2689   for (i = 0; i < n_commands; i++)
2690     {
2691       const char **argv;
2692       int argc;
2693       int j;
2694
2695       for (argc = 0; commands[i].argv[argc] != NULL; argc++)
2696         ;
2697
2698       argv = XALLOCAVEC (const char *, argc + 3);
2699
2700       argv[0] = VALGRIND_PATH;
2701       argv[1] = "-q";
2702       for (j = 2; j < argc + 2; j++)
2703         argv[j] = commands[i].argv[j - 2];
2704       argv[j] = NULL;
2705
2706       commands[i].argv = argv;
2707       commands[i].prog = argv[0];
2708     }
2709 #endif
2710
2711   /* Run each piped subprocess.  */
2712
2713   pex = pex_init (PEX_USE_PIPES | ((report_times || report_times_to_file)
2714                                    ? PEX_RECORD_TIMES : 0),
2715                   progname, temp_filename);
2716   if (pex == NULL)
2717     fatal_error ("pex_init failed: %m");
2718
2719   for (i = 0; i < n_commands; i++)
2720     {
2721       const char *errmsg;
2722       int err;
2723       const char *string = commands[i].argv[0];
2724
2725       errmsg = pex_run (pex,
2726                         ((i + 1 == n_commands ? PEX_LAST : 0)
2727                          | (string == commands[i].prog ? PEX_SEARCH : 0)),
2728                         string, CONST_CAST (char **, commands[i].argv),
2729                         NULL, NULL, &err);
2730       if (errmsg != NULL)
2731         {
2732           if (err == 0)
2733             fatal_error (errmsg);
2734           else
2735             {
2736               errno = err;
2737               pfatal_with_name (errmsg);
2738             }
2739         }
2740
2741       if (string != commands[i].prog)
2742         free (CONST_CAST (char *, string));
2743     }
2744
2745   execution_count++;
2746
2747   /* Wait for all the subprocesses to finish.  */
2748
2749   {
2750     int *statuses;
2751     struct pex_time *times = NULL;
2752     int ret_code = 0;
2753
2754     statuses = (int *) alloca (n_commands * sizeof (int));
2755     if (!pex_get_status (pex, n_commands, statuses))
2756       fatal_error ("failed to get exit status: %m");
2757
2758     if (report_times || report_times_to_file)
2759       {
2760         times = (struct pex_time *) alloca (n_commands * sizeof (struct pex_time));
2761         if (!pex_get_times (pex, n_commands, times))
2762           fatal_error ("failed to get process times: %m");
2763       }
2764
2765     pex_free (pex);
2766
2767     for (i = 0; i < n_commands; ++i)
2768       {
2769         int status = statuses[i];
2770
2771         if (WIFSIGNALED (status))
2772           {
2773 #ifdef SIGPIPE
2774             /* SIGPIPE is a special case.  It happens in -pipe mode
2775                when the compiler dies before the preprocessor is done,
2776                or the assembler dies before the compiler is done.
2777                There's generally been an error already, and this is
2778                just fallout.  So don't generate another error unless
2779                we would otherwise have succeeded.  */
2780             if (WTERMSIG (status) == SIGPIPE
2781                 && (signal_count || greatest_status >= MIN_FATAL_STATUS))
2782               {
2783                 signal_count++;
2784                 ret_code = -1;
2785               }
2786             else
2787 #endif
2788               internal_error ("%s (program %s)",
2789                               strsignal (WTERMSIG (status)), commands[i].prog);
2790           }
2791         else if (WIFEXITED (status)
2792                  && WEXITSTATUS (status) >= MIN_FATAL_STATUS)
2793           {
2794             if (WEXITSTATUS (status) > greatest_status)
2795               greatest_status = WEXITSTATUS (status);
2796             ret_code = -1;
2797           }
2798
2799         if (report_times || report_times_to_file)
2800           {
2801             struct pex_time *pt = &times[i];
2802             double ut, st;
2803
2804             ut = ((double) pt->user_seconds
2805                   + (double) pt->user_microseconds / 1.0e6);
2806             st = ((double) pt->system_seconds
2807                   + (double) pt->system_microseconds / 1.0e6);
2808
2809             if (ut + st != 0)
2810               {
2811                 if (report_times)
2812                   fnotice (stderr, "# %s %.2f %.2f\n",
2813                            commands[i].prog, ut, st);
2814
2815                 if (report_times_to_file)
2816                   {
2817                     int c = 0;
2818                     const char *const *j;
2819
2820                     fprintf (report_times_to_file, "%g %g", ut, st);
2821
2822                     for (j = &commands[i].prog; *j; j = &commands[i].argv[++c])
2823                       {
2824                         const char *p;
2825                         for (p = *j; *p; ++p)
2826                           if (*p == '"' || *p == '\\' || *p == '$'
2827                               || ISSPACE (*p))
2828                             break;
2829
2830                         if (*p)
2831                           {
2832                             fprintf (report_times_to_file, " \"");
2833                             for (p = *j; *p; ++p)
2834                               {
2835                                 if (*p == '"' || *p == '\\' || *p == '$')
2836                                   fputc ('\\', report_times_to_file);
2837                                 fputc (*p, report_times_to_file);
2838                               }
2839                             fputc ('"', report_times_to_file);
2840                           }
2841                         else
2842                           fprintf (report_times_to_file, " %s", *j);
2843                       }
2844
2845                     fputc ('\n', report_times_to_file);
2846                   }
2847               }
2848           }
2849       }
2850
2851     return ret_code;
2852   }
2853 }
2854 \f
2855 /* Find all the switches given to us
2856    and make a vector describing them.
2857    The elements of the vector are strings, one per switch given.
2858    If a switch uses following arguments, then the `part1' field
2859    is the switch itself and the `args' field
2860    is a null-terminated vector containing the following arguments.
2861    Bits in the `live_cond' field are:
2862    SWITCH_LIVE to indicate this switch is true in a conditional spec.
2863    SWITCH_FALSE to indicate this switch is overridden by a later switch.
2864    SWITCH_IGNORE to indicate this switch should be ignored (used in %<S).
2865    SWITCH_IGNORE_PERMANENTLY to indicate this switch should be ignored
2866    in all do_spec calls afterwards.  Used for %<S from self specs.
2867    The `validated' field is nonzero if any spec has looked at this switch;
2868    if it remains zero at the end of the run, it must be meaningless.  */
2869
2870 #define SWITCH_LIVE                     (1 << 0)
2871 #define SWITCH_FALSE                    (1 << 1)
2872 #define SWITCH_IGNORE                   (1 << 2)
2873 #define SWITCH_IGNORE_PERMANENTLY       (1 << 3)
2874 #define SWITCH_KEEP_FOR_GCC             (1 << 4)
2875
2876 struct switchstr
2877 {
2878   const char *part1;
2879   const char **args;
2880   unsigned int live_cond;
2881   bool known;
2882   bool validated;
2883   bool ordering;
2884 };
2885
2886 static struct switchstr *switches;
2887
2888 static int n_switches;
2889
2890 static int n_switches_alloc;
2891
2892 /* Set to zero if -fcompare-debug is disabled, positive if it's
2893    enabled and we're running the first compilation, negative if it's
2894    enabled and we're running the second compilation.  For most of the
2895    time, it's in the range -1..1, but it can be temporarily set to 2
2896    or 3 to indicate that the -fcompare-debug flags didn't come from
2897    the command-line, but rather from the GCC_COMPARE_DEBUG environment
2898    variable, until a synthesized -fcompare-debug flag is added to the
2899    command line.  */
2900 int compare_debug;
2901
2902 /* Set to nonzero if we've seen the -fcompare-debug-second flag.  */
2903 int compare_debug_second;
2904
2905 /* Set to the flags that should be passed to the second compilation in
2906    a -fcompare-debug compilation.  */
2907 const char *compare_debug_opt;
2908
2909 static struct switchstr *switches_debug_check[2];
2910
2911 static int n_switches_debug_check[2];
2912
2913 static int n_switches_alloc_debug_check[2];
2914
2915 static char *debug_check_temp_file[2];
2916
2917 /* Language is one of three things:
2918
2919    1) The name of a real programming language.
2920    2) NULL, indicating that no one has figured out
2921    what it is yet.
2922    3) '*', indicating that the file should be passed
2923    to the linker.  */
2924 struct infile
2925 {
2926   const char *name;
2927   const char *language;
2928   struct compiler *incompiler;
2929   bool compiled;
2930   bool preprocessed;
2931 };
2932
2933 /* Also a vector of input files specified.  */
2934
2935 static struct infile *infiles;
2936
2937 int n_infiles;
2938
2939 static int n_infiles_alloc;
2940
2941 /* True if multiple input files are being compiled to a single
2942    assembly file.  */
2943
2944 static bool combine_inputs;
2945
2946 /* This counts the number of libraries added by lang_specific_driver, so that
2947    we can tell if there were any user supplied any files or libraries.  */
2948
2949 static int added_libraries;
2950
2951 /* And a vector of corresponding output files is made up later.  */
2952
2953 const char **outfiles;
2954 \f
2955 #if defined(HAVE_TARGET_OBJECT_SUFFIX) || defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2956
2957 /* Convert NAME to a new name if it is the standard suffix.  DO_EXE
2958    is true if we should look for an executable suffix.  DO_OBJ
2959    is true if we should look for an object suffix.  */
2960
2961 static const char *
2962 convert_filename (const char *name, int do_exe ATTRIBUTE_UNUSED,
2963                   int do_obj ATTRIBUTE_UNUSED)
2964 {
2965 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2966   int i;
2967 #endif
2968   int len;
2969
2970   if (name == NULL)
2971     return NULL;
2972
2973   len = strlen (name);
2974
2975 #ifdef HAVE_TARGET_OBJECT_SUFFIX
2976   /* Convert x.o to x.obj if TARGET_OBJECT_SUFFIX is ".obj".  */
2977   if (do_obj && len > 2
2978       && name[len - 2] == '.'
2979       && name[len - 1] == 'o')
2980     {
2981       obstack_grow (&obstack, name, len - 2);
2982       obstack_grow0 (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
2983       name = XOBFINISH (&obstack, const char *);
2984     }
2985 #endif
2986
2987 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX)
2988   /* If there is no filetype, make it the executable suffix (which includes
2989      the ".").  But don't get confused if we have just "-o".  */
2990   if (! do_exe || TARGET_EXECUTABLE_SUFFIX[0] == 0 || (len == 2 && name[0] == '-'))
2991     return name;
2992
2993   for (i = len - 1; i >= 0; i--)
2994     if (IS_DIR_SEPARATOR (name[i]))
2995       break;
2996
2997   for (i++; i < len; i++)
2998     if (name[i] == '.')
2999       return name;
3000
3001   obstack_grow (&obstack, name, len);
3002   obstack_grow0 (&obstack, TARGET_EXECUTABLE_SUFFIX,
3003                  strlen (TARGET_EXECUTABLE_SUFFIX));
3004   name = XOBFINISH (&obstack, const char *);
3005 #endif
3006
3007   return name;
3008 }
3009 #endif
3010 \f
3011 /* Display the command line switches accepted by gcc.  */
3012 static void
3013 display_help (void)
3014 {
3015   printf (_("Usage: %s [options] file...\n"), progname);
3016   fputs (_("Options:\n"), stdout);
3017
3018   fputs (_("  -pass-exit-codes         Exit with highest error code from a phase\n"), stdout);
3019   fputs (_("  --help                   Display this information\n"), stdout);
3020   fputs (_("  --target-help            Display target specific command line options\n"), stdout);
3021   fputs (_("  --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]\n"), stdout);
3022   fputs (_("                           Display specific types of command line options\n"), stdout);
3023   if (! verbose_flag)
3024     fputs (_("  (Use '-v --help' to display command line options of sub-processes)\n"), stdout);
3025   fputs (_("  --version                Display compiler version information\n"), stdout);
3026   fputs (_("  -dumpspecs               Display all of the built in spec strings\n"), stdout);
3027   fputs (_("  -dumpversion             Display the version of the compiler\n"), stdout);
3028   fputs (_("  -dumpmachine             Display the compiler's target processor\n"), stdout);
3029   fputs (_("  -print-search-dirs       Display the directories in the compiler's search path\n"), stdout);
3030   fputs (_("  -print-libgcc-file-name  Display the name of the compiler's companion library\n"), stdout);
3031   fputs (_("  -print-file-name=<lib>   Display the full path to library <lib>\n"), stdout);
3032   fputs (_("  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n"), stdout);
3033   fputs (_("\
3034   -print-multiarch         Display the target's normalized GNU triplet, used as\n\
3035                            a component in the library path\n"), stdout);
3036   fputs (_("  -print-multi-directory   Display the root directory for versions of libgcc\n"), stdout);
3037   fputs (_("\
3038   -print-multi-lib         Display the mapping between command line options and\n\
3039                            multiple library search directories\n"), stdout);
3040   fputs (_("  -print-multi-os-directory Display the relative path to OS libraries\n"), stdout);
3041   fputs (_("  -print-sysroot           Display the target libraries directory\n"), stdout);
3042   fputs (_("  -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"), stdout);
3043   fputs (_("  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"), stdout);
3044   fputs (_("  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"), stdout);
3045   fputs (_("  -Wl,<options>            Pass comma-separated <options> on to the linker\n"), stdout);
3046   fputs (_("  -Xassembler <arg>        Pass <arg> on to the assembler\n"), stdout);
3047   fputs (_("  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor\n"), stdout);
3048   fputs (_("  -Xlinker <arg>           Pass <arg> on to the linker\n"), stdout);
3049   fputs (_("  -save-temps              Do not delete intermediate files\n"), stdout);
3050   fputs (_("  -save-temps=<arg>        Do not delete intermediate files\n"), stdout);
3051   fputs (_("\
3052   -no-canonical-prefixes   Do not canonicalize paths when building relative\n\
3053                            prefixes to other gcc components\n"), stdout);
3054   fputs (_("  -pipe                    Use pipes rather than intermediate files\n"), stdout);
3055   fputs (_("  -time                    Time the execution of each subprocess\n"), stdout);
3056   fputs (_("  -specs=<file>            Override built-in specs with the contents of <file>\n"), stdout);
3057   fputs (_("  -std=<standard>          Assume that the input sources are for <standard>\n"), stdout);
3058   fputs (_("\
3059   --sysroot=<directory>    Use <directory> as the root directory for headers\n\
3060                            and libraries\n"), stdout);
3061   fputs (_("  -B <directory>           Add <directory> to the compiler's search paths\n"), stdout);
3062   fputs (_("  -v                       Display the programs invoked by the compiler\n"), stdout);
3063   fputs (_("  -###                     Like -v but options quoted and commands not executed\n"), stdout);
3064   fputs (_("  -E                       Preprocess only; do not compile, assemble or link\n"), stdout);
3065   fputs (_("  -S                       Compile only; do not assemble or link\n"), stdout);
3066   fputs (_("  -c                       Compile and assemble, but do not link\n"), stdout);
3067   fputs (_("  -o <file>                Place the output into <file>\n"), stdout);
3068   fputs (_("  -pie                     Create a position independent executable\n"), stdout);
3069   fputs (_("  -shared                  Create a shared library\n"), stdout);
3070   fputs (_("\
3071   -x <language>            Specify the language of the following input files\n\
3072                            Permissible languages include: c c++ assembler none\n\
3073                            'none' means revert to the default behavior of\n\
3074                            guessing the language based on the file's extension\n\
3075 "), stdout);
3076
3077   printf (_("\
3078 \nOptions starting with -g, -f, -m, -O, -W, or --param are automatically\n\
3079  passed on to the various sub-processes invoked by %s.  In order to pass\n\
3080  other options on to these processes the -W<letter> options must be used.\n\
3081 "), progname);
3082
3083   /* The rest of the options are displayed by invocations of the various
3084      sub-processes.  */
3085 }
3086
3087 static void
3088 add_preprocessor_option (const char *option, int len)
3089 {
3090   preprocessor_options.safe_push (save_string (option, len));
3091 }
3092
3093 static void
3094 add_assembler_option (const char *option, int len)
3095 {
3096   assembler_options.safe_push (save_string (option, len));
3097 }
3098
3099 static void
3100 add_linker_option (const char *option, int len)
3101 {
3102   linker_options.safe_push (save_string (option, len));
3103 }
3104 \f
3105 /* Allocate space for an input file in infiles.  */
3106
3107 static void
3108 alloc_infile (void)
3109 {
3110   if (n_infiles_alloc == 0)
3111     {
3112       n_infiles_alloc = 16;
3113       infiles = XNEWVEC (struct infile, n_infiles_alloc);
3114     }
3115   else if (n_infiles_alloc == n_infiles)
3116     {
3117       n_infiles_alloc *= 2;
3118       infiles = XRESIZEVEC (struct infile, infiles, n_infiles_alloc);
3119     }
3120 }
3121
3122 /* Store an input file with the given NAME and LANGUAGE in
3123    infiles.  */
3124
3125 static void
3126 add_infile (const char *name, const char *language)
3127 {
3128   alloc_infile ();
3129   infiles[n_infiles].name = name;
3130   infiles[n_infiles++].language = language;
3131 }
3132
3133 /* Allocate space for a switch in switches.  */
3134
3135 static void
3136 alloc_switch (void)
3137 {
3138   if (n_switches_alloc == 0)
3139     {
3140       n_switches_alloc = 16;
3141       switches = XNEWVEC (struct switchstr, n_switches_alloc);
3142     }
3143   else if (n_switches_alloc == n_switches)
3144     {
3145       n_switches_alloc *= 2;
3146       switches = XRESIZEVEC (struct switchstr, switches, n_switches_alloc);
3147     }
3148 }
3149
3150 /* Save an option OPT with N_ARGS arguments in array ARGS, marking it
3151    as validated if VALIDATED and KNOWN if it is an internal switch.  */
3152
3153 static void
3154 save_switch (const char *opt, size_t n_args, const char *const *args,
3155              bool validated, bool known)
3156 {
3157   alloc_switch ();
3158   switches[n_switches].part1 = opt + 1;
3159   if (n_args == 0)
3160     switches[n_switches].args = 0;
3161   else
3162     {
3163       switches[n_switches].args = XNEWVEC (const char *, n_args + 1);
3164       memcpy (switches[n_switches].args, args, n_args * sizeof (const char *));
3165       switches[n_switches].args[n_args] = NULL;
3166     }
3167
3168   switches[n_switches].live_cond = 0;
3169   switches[n_switches].validated = validated;
3170   switches[n_switches].known = known;
3171   switches[n_switches].ordering = 0;
3172   n_switches++;
3173 }
3174
3175 /* Handle an option DECODED that is unknown to the option-processing
3176    machinery.  */
3177
3178 static bool
3179 driver_unknown_option_callback (const struct cl_decoded_option *decoded)
3180 {
3181   const char *opt = decoded->arg;
3182   if (opt[1] == 'W' && opt[2] == 'n' && opt[3] == 'o' && opt[4] == '-'
3183       && !(decoded->errors & CL_ERR_NEGATIVE))
3184     {
3185       /* Leave unknown -Wno-* options for the compiler proper, to be
3186          diagnosed only if there are warnings.  */
3187       save_switch (decoded->canonical_option[0],
3188                    decoded->canonical_option_num_elements - 1,
3189                    &decoded->canonical_option[1], false, true);
3190       return false;
3191     }
3192   if (decoded->opt_index == OPT_SPECIAL_unknown)
3193     {
3194       /* Give it a chance to define it a a spec file.  */
3195       save_switch (decoded->canonical_option[0],
3196                    decoded->canonical_option_num_elements - 1,
3197                    &decoded->canonical_option[1], false, false);
3198       return false;
3199     }
3200   else
3201     return true;
3202 }
3203
3204 /* Handle an option DECODED that is not marked as CL_DRIVER.
3205    LANG_MASK will always be CL_DRIVER.  */
3206
3207 static void
3208 driver_wrong_lang_callback (const struct cl_decoded_option *decoded,
3209                             unsigned int lang_mask ATTRIBUTE_UNUSED)
3210 {
3211   /* At this point, non-driver options are accepted (and expected to
3212      be passed down by specs) unless marked to be rejected by the
3213      driver.  Options to be rejected by the driver but accepted by the
3214      compilers proper are treated just like completely unknown
3215      options.  */
3216   const struct cl_option *option = &cl_options[decoded->opt_index];
3217
3218   if (option->cl_reject_driver)
3219     error ("unrecognized command line option %qs",
3220            decoded->orig_option_with_args_text);
3221   else
3222     save_switch (decoded->canonical_option[0],
3223                  decoded->canonical_option_num_elements - 1,
3224                  &decoded->canonical_option[1], false, true);
3225 }
3226
3227 static const char *spec_lang = 0;
3228 static int last_language_n_infiles;
3229
3230 /* Handle a driver option; arguments and return value as for
3231    handle_option.  */
3232
3233 static bool
3234 driver_handle_option (struct gcc_options *opts,
3235                       struct gcc_options *opts_set,
3236                       const struct cl_decoded_option *decoded,
3237                       unsigned int lang_mask ATTRIBUTE_UNUSED, int kind,
3238                       location_t loc,
3239                       const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED,
3240                       diagnostic_context *dc)
3241 {
3242   size_t opt_index = decoded->opt_index;
3243   const char *arg = decoded->arg;
3244   const char *compare_debug_replacement_opt;
3245   int value = decoded->value;
3246   bool validated = false;
3247   bool do_save = true;
3248
3249   gcc_assert (opts == &global_options);
3250   gcc_assert (opts_set == &global_options_set);
3251   gcc_assert (kind == DK_UNSPECIFIED);
3252   gcc_assert (loc == UNKNOWN_LOCATION);
3253   gcc_assert (dc == global_dc);
3254
3255   switch (opt_index)
3256     {
3257     case OPT_dumpspecs:
3258       {
3259         struct spec_list *sl;
3260         init_spec ();
3261         for (sl = specs; sl; sl = sl->next)
3262           printf ("*%s:\n%s\n\n", sl->name, *(sl->ptr_spec));
3263         if (link_command_spec)
3264           printf ("*link_command:\n%s\n\n", link_command_spec);
3265         exit (0);
3266       }
3267
3268     case OPT_dumpversion:
3269       printf ("%s\n", spec_version);
3270       exit (0);
3271
3272     case OPT_dumpmachine:
3273       printf ("%s\n", spec_machine);
3274       exit (0);
3275
3276     case OPT__version:
3277       print_version = 1;
3278
3279       /* CPP driver cannot obtain switch from cc1_options.  */
3280       if (is_cpp_driver)
3281         add_preprocessor_option ("--version", strlen ("--version"));
3282       add_assembler_option ("--version", strlen ("--version"));
3283       add_linker_option ("--version", strlen ("--version"));
3284       break;
3285
3286     case OPT__help:
3287       print_help_list = 1;
3288
3289       /* CPP driver cannot obtain switch from cc1_options.  */
3290       if (is_cpp_driver)
3291         add_preprocessor_option ("--help", 6);
3292       add_assembler_option ("--help", 6);
3293       add_linker_option ("--help", 6);
3294       break;
3295
3296     case OPT__help_:
3297       print_subprocess_help = 2;
3298       break;
3299
3300     case OPT__target_help:
3301       print_subprocess_help = 1;
3302
3303       /* CPP driver cannot obtain switch from cc1_options.  */
3304       if (is_cpp_driver)
3305         add_preprocessor_option ("--target-help", 13);
3306       add_assembler_option ("--target-help", 13);
3307       add_linker_option ("--target-help", 13);
3308       break;
3309
3310     case OPT__no_sysroot_suffix:
3311     case OPT_pass_exit_codes:
3312     case OPT_print_search_dirs:
3313     case OPT_print_file_name_:
3314     case OPT_print_prog_name_:
3315     case OPT_print_multi_lib:
3316     case OPT_print_multi_directory:
3317     case OPT_print_sysroot:
3318     case OPT_print_multi_os_directory:
3319     case OPT_print_multiarch:
3320     case OPT_print_sysroot_headers_suffix:
3321     case OPT_time:
3322     case OPT_wrapper:
3323       /* These options set the variables specified in common.opt
3324          automatically, and do not need to be saved for spec
3325          processing.  */
3326       do_save = false;
3327       break;
3328
3329     case OPT_print_libgcc_file_name:
3330       print_file_name = "libgcc.a";
3331       do_save = false;
3332       break;
3333
3334     case OPT_fcompare_debug_second:
3335       compare_debug_second = 1;
3336       break;
3337
3338     case OPT_fcompare_debug:
3339       switch (value)
3340         {
3341         case 0:
3342           compare_debug_replacement_opt = "-fcompare-debug=";
3343           arg = "";
3344           goto compare_debug_with_arg;
3345
3346         case 1:
3347           compare_debug_replacement_opt = "-fcompare-debug=-gtoggle";
3348           arg = "-gtoggle";
3349           goto compare_debug_with_arg;
3350
3351         default:
3352           gcc_unreachable ();
3353         }
3354       break;
3355
3356     case OPT_fcompare_debug_:
3357       compare_debug_replacement_opt = decoded->canonical_option[0];
3358     compare_debug_with_arg:
3359       gcc_assert (decoded->canonical_option_num_elements == 1);
3360       gcc_assert (arg != NULL);
3361       if (*arg)
3362         compare_debug = 1;
3363       else
3364         compare_debug = -1;
3365       if (compare_debug < 0)
3366         compare_debug_opt = NULL;
3367       else
3368         compare_debug_opt = arg;
3369       save_switch (compare_debug_replacement_opt, 0, NULL, validated, true);
3370       return true;
3371
3372     case OPT_Wa_:
3373       {
3374         int prev, j;
3375         /* Pass the rest of this option to the assembler.  */
3376
3377         /* Split the argument at commas.  */
3378         prev = 0;
3379         for (j = 0; arg[j]; j++)
3380           if (arg[j] == ',')
3381             {
3382               add_assembler_option (arg + prev, j - prev);
3383               prev = j + 1;
3384             }
3385
3386         /* Record the part after the last comma.  */
3387         add_assembler_option (arg + prev, j - prev);
3388       }
3389       do_save = false;
3390       break;
3391
3392     case OPT_Wp_:
3393       {
3394         int prev, j;
3395         /* Pass the rest of this option to the preprocessor.  */
3396
3397         /* Split the argument at commas.  */
3398         prev = 0;
3399         for (j = 0; arg[j]; j++)
3400           if (arg[j] == ',')
3401             {
3402               add_preprocessor_option (arg + prev, j - prev);
3403               prev = j + 1;
3404             }
3405
3406         /* Record the part after the last comma.  */
3407         add_preprocessor_option (arg + prev, j - prev);
3408       }
3409       do_save = false;
3410       break;
3411
3412     case OPT_Wl_:
3413       {
3414         int prev, j;
3415         /* Split the argument at commas.  */
3416         prev = 0;
3417         for (j = 0; arg[j]; j++)
3418           if (arg[j] == ',')
3419             {
3420               add_infile (save_string (arg + prev, j - prev), "*");
3421               prev = j + 1;
3422             }
3423         /* Record the part after the last comma.  */
3424         add_infile (arg + prev, "*");
3425       }
3426       do_save = false;
3427       break;
3428
3429     case OPT_Xlinker:
3430       add_infile (arg, "*");
3431       do_save = false;
3432       break;
3433
3434     case OPT_Xpreprocessor:
3435       add_preprocessor_option (arg, strlen (arg));
3436       do_save = false;
3437       break;
3438
3439     case OPT_Xassembler:
3440       add_assembler_option (arg, strlen (arg));
3441       do_save = false;
3442       break;
3443
3444     case OPT_l:
3445       /* POSIX allows separation of -l and the lib arg; canonicalize
3446          by concatenating -l with its arg */
3447       add_infile (concat ("-l", arg, NULL), "*");
3448       do_save = false;
3449       break;
3450
3451     case OPT_L:
3452       /* Similarly, canonicalize -L for linkers that may not accept
3453          separate arguments.  */
3454       save_switch (concat ("-L", arg, NULL), 0, NULL, validated, true);
3455       return true;
3456
3457     case OPT_F:
3458       /* Likewise -F.  */
3459       save_switch (concat ("-F", arg, NULL), 0, NULL, validated, true);
3460       return true;
3461
3462     case OPT_save_temps:
3463       save_temps_flag = SAVE_TEMPS_CWD;
3464       validated = true;
3465       break;
3466
3467     case OPT_save_temps_:
3468       if (strcmp (arg, "cwd") == 0)
3469         save_temps_flag = SAVE_TEMPS_CWD;
3470       else if (strcmp (arg, "obj") == 0
3471                || strcmp (arg, "object") == 0)
3472         save_temps_flag = SAVE_TEMPS_OBJ;
3473       else
3474         fatal_error ("%qs is an unknown -save-temps option",
3475                      decoded->orig_option_with_args_text);
3476       break;
3477
3478     case OPT_no_canonical_prefixes:
3479       /* Already handled as a special case, so ignored here.  */
3480       do_save = false;
3481       break;
3482
3483     case OPT_pipe:
3484       validated = true;
3485       /* These options set the variables specified in common.opt
3486          automatically, but do need to be saved for spec
3487          processing.  */
3488       break;
3489
3490     case OPT_specs_:
3491       {
3492         struct user_specs *user = XNEW (struct user_specs);
3493
3494         user->next = (struct user_specs *) 0;
3495         user->filename = arg;
3496         if (user_specs_tail)
3497           user_specs_tail->next = user;
3498         else
3499           user_specs_head = user;
3500         user_specs_tail = user;
3501       }
3502       validated = true;
3503       break;
3504
3505     case OPT__sysroot_:
3506       target_system_root = arg;
3507       target_system_root_changed = 1;
3508       do_save = false;
3509       break;
3510
3511     case OPT_time_:
3512       if (report_times_to_file)
3513         fclose (report_times_to_file);
3514       report_times_to_file = fopen (arg, "a");
3515       do_save = false;
3516       break;
3517
3518     case OPT____:
3519       /* "-###"
3520          This is similar to -v except that there is no execution
3521          of the commands and the echoed arguments are quoted.  It
3522          is intended for use in shell scripts to capture the
3523          driver-generated command line.  */
3524       verbose_only_flag++;
3525       verbose_flag = 1;
3526       do_save = false;
3527       break;
3528
3529     case OPT_B:
3530       {
3531         size_t len = strlen (arg);
3532
3533         /* Catch the case where the user has forgotten to append a
3534            directory separator to the path.  Note, they may be using
3535            -B to add an executable name prefix, eg "i386-elf-", in
3536            order to distinguish between multiple installations of
3537            GCC in the same directory.  Hence we must check to see
3538            if appending a directory separator actually makes a
3539            valid directory name.  */
3540         if (!IS_DIR_SEPARATOR (arg[len - 1])
3541             && is_directory (arg, false))
3542           {
3543             char *tmp = XNEWVEC (char, len + 2);
3544             strcpy (tmp, arg);
3545             tmp[len] = DIR_SEPARATOR;
3546             tmp[++len] = 0;
3547             arg = tmp;
3548           }
3549
3550         add_prefix (&exec_prefixes, arg, NULL,
3551                     PREFIX_PRIORITY_B_OPT, 0, 0);
3552         add_prefix (&startfile_prefixes, arg, NULL,
3553                     PREFIX_PRIORITY_B_OPT, 0, 0);
3554         add_prefix (&include_prefixes, arg, NULL,
3555                     PREFIX_PRIORITY_B_OPT, 0, 0);
3556       }
3557       validated = true;
3558       break;
3559
3560     case OPT_x:
3561       spec_lang = arg;
3562       if (!strcmp (spec_lang, "none"))
3563         /* Suppress the warning if -xnone comes after the last input
3564            file, because alternate command interfaces like g++ might
3565            find it useful to place -xnone after each input file.  */
3566         spec_lang = 0;
3567       else
3568         last_language_n_infiles = n_infiles;
3569       do_save = false;
3570       break;
3571
3572     case OPT_o:
3573       have_o = 1;
3574 #if defined(HAVE_TARGET_EXECUTABLE_SUFFIX) || defined(HAVE_TARGET_OBJECT_SUFFIX)
3575       arg = convert_filename (arg, ! have_c, 0);
3576 #endif
3577       /* Save the output name in case -save-temps=obj was used.  */
3578       save_temps_prefix = xstrdup (arg);
3579       /* On some systems, ld cannot handle "-o" without a space.  So
3580          split the option from its argument.  */
3581       save_switch ("-o", 1, &arg, validated, true);
3582       return true;
3583
3584     case OPT_static_libgcc:
3585     case OPT_shared_libgcc:
3586     case OPT_static_libgfortran:
3587     case OPT_static_libstdc__:
3588       /* These are always valid, since gcc.c itself understands the
3589          first two, gfortranspec.c understands -static-libgfortran and
3590          g++spec.c understands -static-libstdc++ */
3591       validated = true;
3592       break;
3593
3594     default:
3595       /* Various driver options need no special processing at this
3596          point, having been handled in a prescan above or being
3597          handled by specs.  */
3598       break;
3599     }
3600
3601   if (do_save)
3602     save_switch (decoded->canonical_option[0],
3603                  decoded->canonical_option_num_elements - 1,
3604                  &decoded->canonical_option[1], validated, true);
3605   return true;
3606 }
3607
3608 /* Put the driver's standard set of option handlers in *HANDLERS.  */
3609
3610 static void
3611 set_option_handlers (struct cl_option_handlers *handlers)
3612 {
3613   handlers->unknown_option_callback = driver_unknown_option_callback;
3614   handlers->wrong_lang_callback = driver_wrong_lang_callback;
3615   handlers->num_handlers = 3;
3616   handlers->handlers[0].handler = driver_handle_option;
3617   handlers->handlers[0].mask = CL_DRIVER;
3618   handlers->handlers[1].handler = common_handle_option;
3619   handlers->handlers[1].mask = CL_COMMON;
3620   handlers->handlers[2].handler = target_handle_option;
3621   handlers->handlers[2].mask = CL_TARGET;
3622 }
3623
3624 /* Create the vector `switches' and its contents.
3625    Store its length in `n_switches'.  */
3626
3627 static void
3628 process_command (unsigned int decoded_options_count,
3629                  struct cl_decoded_option *decoded_options)
3630 {
3631   const char *temp;
3632   char *temp1;
3633   char *tooldir_prefix, *tooldir_prefix2;
3634   char *(*get_relative_prefix) (const char *, const char *,
3635                                 const char *) = NULL;
3636   struct cl_option_handlers handlers;
3637   unsigned int j;
3638
3639   gcc_exec_prefix = getenv ("GCC_EXEC_PREFIX");
3640
3641   n_switches = 0;
3642   n_infiles = 0;
3643   added_libraries = 0;
3644
3645   /* Figure compiler version from version string.  */
3646
3647   compiler_version = temp1 = xstrdup (version_string);
3648
3649   for (; *temp1; ++temp1)
3650     {
3651       if (*temp1 == ' ')
3652         {
3653           *temp1 = '\0';
3654           break;
3655         }
3656     }
3657
3658   /* Handle any -no-canonical-prefixes flag early, to assign the function
3659      that builds relative prefixes.  This function creates default search
3660      paths that are needed later in normal option handling.  */
3661
3662   for (j = 1; j < decoded_options_count; j++)
3663     {
3664       if (decoded_options[j].opt_index == OPT_no_canonical_prefixes)
3665         {
3666           get_relative_prefix = make_relative_prefix_ignore_links;
3667           break;
3668         }
3669     }
3670   if (! get_relative_prefix)
3671     get_relative_prefix = make_relative_prefix;
3672
3673   /* Set up the default search paths.  If there is no GCC_EXEC_PREFIX,
3674      see if we can create it from the pathname specified in
3675      decoded_options[0].arg.  */
3676
3677   gcc_libexec_prefix = standard_libexec_prefix;
3678 #ifndef VMS
3679   /* FIXME: make_relative_prefix doesn't yet work for VMS.  */
3680   if (!gcc_exec_prefix)
3681     {
3682       gcc_exec_prefix = get_relative_prefix (decoded_options[0].arg,
3683                                              standard_bindir_prefix,
3684                                              standard_exec_prefix);
3685       gcc_libexec_prefix = get_relative_prefix (decoded_options[0].arg,
3686                                              standard_bindir_prefix,
3687                                              standard_libexec_prefix);
3688       if (gcc_exec_prefix)
3689         xputenv (concat ("GCC_EXEC_PREFIX=", gcc_exec_prefix, NULL));
3690     }
3691   else
3692     {
3693       /* make_relative_prefix requires a program name, but
3694          GCC_EXEC_PREFIX is typically a directory name with a trailing
3695          / (which is ignored by make_relative_prefix), so append a
3696          program name.  */
3697       char *tmp_prefix = concat (gcc_exec_prefix, "gcc", NULL);
3698       gcc_libexec_prefix = get_relative_prefix (tmp_prefix,
3699                                                 standard_exec_prefix,
3700                                                 standard_libexec_prefix);
3701
3702       /* The path is unrelocated, so fallback to the original setting.  */
3703       if (!gcc_libexec_prefix)
3704         gcc_libexec_prefix = standard_libexec_prefix;
3705
3706       free (tmp_prefix);
3707     }
3708 #else
3709 #endif
3710   /* From this point onward, gcc_exec_prefix is non-null if the toolchain
3711      is relocated. The toolchain was either relocated using GCC_EXEC_PREFIX
3712      or an automatically created GCC_EXEC_PREFIX from
3713      decoded_options[0].arg.  */
3714
3715   /* Do language-specific adjustment/addition of flags.  */
3716   lang_specific_driver (&decoded_options, &decoded_options_count,
3717                         &added_libraries);
3718
3719   if (gcc_exec_prefix)
3720     {
3721       int len = strlen (gcc_exec_prefix);
3722
3723       if (len > (int) sizeof ("/lib/gcc/") - 1
3724           && (IS_DIR_SEPARATOR (gcc_exec_prefix[len-1])))
3725         {
3726           temp = gcc_exec_prefix + len - sizeof ("/lib/gcc/") + 1;
3727           if (IS_DIR_SEPARATOR (*temp)
3728               && filename_ncmp (temp + 1, "lib", 3) == 0
3729               && IS_DIR_SEPARATOR (temp[4])
3730               && filename_ncmp (temp + 5, "gcc", 3) == 0)
3731             len -= sizeof ("/lib/gcc/") - 1;
3732         }
3733
3734       set_std_prefix (gcc_exec_prefix, len);
3735       add_prefix (&exec_prefixes, gcc_libexec_prefix, "GCC",
3736                   PREFIX_PRIORITY_LAST, 0, 0);
3737       add_prefix (&startfile_prefixes, gcc_exec_prefix, "GCC",
3738                   PREFIX_PRIORITY_LAST, 0, 0);
3739     }
3740
3741   /* COMPILER_PATH and LIBRARY_PATH have values
3742      that are lists of directory names with colons.  */
3743
3744   temp = getenv ("COMPILER_PATH");
3745   if (temp)
3746     {
3747       const char *startp, *endp;
3748       char *nstore = (char *) alloca (strlen (temp) + 3);
3749
3750       startp = endp = temp;
3751       while (1)
3752         {
3753           if (*endp == PATH_SEPARATOR || *endp == 0)
3754             {
3755               strncpy (nstore, startp, endp - startp);
3756               if (endp == startp)
3757                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3758               else if (!IS_DIR_SEPARATOR (endp[-1]))
3759                 {
3760                   nstore[endp - startp] = DIR_SEPARATOR;
3761                   nstore[endp - startp + 1] = 0;
3762                 }
3763               else
3764                 nstore[endp - startp] = 0;
3765               add_prefix (&exec_prefixes, nstore, 0,
3766                           PREFIX_PRIORITY_LAST, 0, 0);
3767               add_prefix (&include_prefixes, nstore, 0,
3768                           PREFIX_PRIORITY_LAST, 0, 0);
3769               if (*endp == 0)
3770                 break;
3771               endp = startp = endp + 1;
3772             }
3773           else
3774             endp++;
3775         }
3776     }
3777
3778   temp = getenv (LIBRARY_PATH_ENV);
3779   if (temp && *cross_compile == '0')
3780     {
3781       const char *startp, *endp;
3782       char *nstore = (char *) alloca (strlen (temp) + 3);
3783
3784       startp = endp = temp;
3785       while (1)
3786         {
3787           if (*endp == PATH_SEPARATOR || *endp == 0)
3788             {
3789               strncpy (nstore, startp, endp - startp);
3790               if (endp == startp)
3791                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3792               else if (!IS_DIR_SEPARATOR (endp[-1]))
3793                 {
3794                   nstore[endp - startp] = DIR_SEPARATOR;
3795                   nstore[endp - startp + 1] = 0;
3796                 }
3797               else
3798                 nstore[endp - startp] = 0;
3799               add_prefix (&startfile_prefixes, nstore, NULL,
3800                           PREFIX_PRIORITY_LAST, 0, 1);
3801               if (*endp == 0)
3802                 break;
3803               endp = startp = endp + 1;
3804             }
3805           else
3806             endp++;
3807         }
3808     }
3809
3810   /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
3811   temp = getenv ("LPATH");
3812   if (temp && *cross_compile == '0')
3813     {
3814       const char *startp, *endp;
3815       char *nstore = (char *) alloca (strlen (temp) + 3);
3816
3817       startp = endp = temp;
3818       while (1)
3819         {
3820           if (*endp == PATH_SEPARATOR || *endp == 0)
3821             {
3822               strncpy (nstore, startp, endp - startp);
3823               if (endp == startp)
3824                 strcpy (nstore, concat (".", dir_separator_str, NULL));
3825               else if (!IS_DIR_SEPARATOR (endp[-1]))
3826                 {
3827                   nstore[endp - startp] = DIR_SEPARATOR;
3828                   nstore[endp - startp + 1] = 0;
3829                 }
3830               else
3831                 nstore[endp - startp] = 0;
3832               add_prefix (&startfile_prefixes, nstore, NULL,
3833                           PREFIX_PRIORITY_LAST, 0, 1);
3834               if (*endp == 0)
3835                 break;
3836               endp = startp = endp + 1;
3837             }
3838           else
3839             endp++;
3840         }
3841     }
3842
3843   /* Process the options and store input files and switches in their
3844      vectors.  */
3845
3846   last_language_n_infiles = -1;
3847
3848   set_option_handlers (&handlers);
3849
3850   for (j = 1; j < decoded_options_count; j++)
3851     {
3852       switch (decoded_options[j].opt_index)
3853         {
3854         case OPT_S:
3855         case OPT_c:
3856         case OPT_E:
3857           have_c = 1;
3858           break;
3859         }
3860       if (have_c)
3861         break;
3862     }
3863
3864   for (j = 1; j < decoded_options_count; j++)
3865     {
3866       if (decoded_options[j].opt_index == OPT_SPECIAL_input_file)
3867         {
3868           const char *arg = decoded_options[j].arg;
3869           const char *p = strrchr (arg, '@');
3870           char *fname;
3871           long offset;
3872           int consumed;
3873 #ifdef HAVE_TARGET_OBJECT_SUFFIX
3874           arg = convert_filename (arg, 0, access (arg, F_OK));
3875 #endif
3876           /* For LTO static archive support we handle input file
3877              specifications that are composed of a filename and
3878              an offset like FNAME@OFFSET.  */
3879           if (p
3880               && p != arg
3881               && sscanf (p, "@%li%n", &offset, &consumed) >= 1
3882               && strlen (p) == (unsigned int)consumed)
3883             {
3884               fname = (char *)xmalloc (p - arg + 1);
3885               memcpy (fname, arg, p - arg);
3886               fname[p - arg] = '\0';
3887               /* Only accept non-stdin and existing FNAME parts, otherwise
3888                  try with the full name.  */
3889               if (strcmp (fname, "-") == 0 || access (fname, F_OK) < 0)
3890                 {
3891                   free (fname);
3892                   fname = xstrdup (arg);
3893                 }
3894             }
3895           else
3896             fname = xstrdup (arg);
3897
3898           if (strcmp (fname, "-") != 0 && access (fname, F_OK) < 0)
3899             perror_with_name (fname);
3900           else
3901             add_infile (arg, spec_lang);
3902
3903           free (fname);
3904           continue;
3905         }
3906
3907       read_cmdline_option (&global_options, &global_options_set,
3908                            decoded_options + j, UNKNOWN_LOCATION,
3909                            CL_DRIVER, &handlers, global_dc);
3910     }
3911
3912   /* If -save-temps=obj and -o name, create the prefix to use for %b.
3913      Otherwise just make -save-temps=obj the same as -save-temps=cwd.  */
3914   if (save_temps_flag == SAVE_TEMPS_OBJ && save_temps_prefix != NULL)
3915     {
3916       save_temps_length = strlen (save_temps_prefix);
3917       temp = strrchr (lbasename (save_temps_prefix), '.');
3918       if (temp)
3919         {
3920           save_temps_length -= strlen (temp);
3921           save_temps_prefix[save_temps_length] = '\0';
3922         }
3923
3924     }
3925   else if (save_temps_prefix != NULL)
3926     {
3927       free (save_temps_prefix);
3928       save_temps_prefix = NULL;
3929     }
3930
3931   if (save_temps_flag && use_pipes)
3932     {
3933       /* -save-temps overrides -pipe, so that temp files are produced */
3934       if (save_temps_flag)
3935         warning (0, "-pipe ignored because -save-temps specified");
3936       use_pipes = 0;
3937     }
3938
3939   if (!compare_debug)
3940     {
3941       const char *gcd = getenv ("GCC_COMPARE_DEBUG");
3942
3943       if (gcd && gcd[0] == '-')
3944         {
3945           compare_debug = 2;
3946           compare_debug_opt = gcd;
3947         }
3948       else if (gcd && *gcd && strcmp (gcd, "0"))
3949         {
3950           compare_debug = 3;
3951           compare_debug_opt = "-gtoggle";
3952         }
3953     }
3954   else if (compare_debug < 0)
3955     {
3956       compare_debug = 0;
3957       gcc_assert (!compare_debug_opt);
3958     }
3959
3960   /* Set up the search paths.  We add directories that we expect to
3961      contain GNU Toolchain components before directories specified by
3962      the machine description so that we will find GNU components (like
3963      the GNU assembler) before those of the host system.  */
3964
3965   /* If we don't know where the toolchain has been installed, use the
3966      configured-in locations.  */
3967   if (!gcc_exec_prefix)
3968     {
3969 #ifndef OS2
3970       add_prefix (&exec_prefixes, standard_libexec_prefix, "GCC",
3971                   PREFIX_PRIORITY_LAST, 1, 0);
3972       add_prefix (&exec_prefixes, standard_libexec_prefix, "BINUTILS",
3973                   PREFIX_PRIORITY_LAST, 2, 0);
3974       add_prefix (&exec_prefixes, standard_exec_prefix, "BINUTILS",
3975                   PREFIX_PRIORITY_LAST, 2, 0);
3976 #endif
3977       add_prefix (&startfile_prefixes, standard_exec_prefix, "BINUTILS",
3978                   PREFIX_PRIORITY_LAST, 1, 0);
3979     }
3980
3981   gcc_assert (!IS_ABSOLUTE_PATH (tooldir_base_prefix));
3982   tooldir_prefix2 = concat (tooldir_base_prefix, spec_machine,
3983                             dir_separator_str, NULL);
3984
3985   /* Look for tools relative to the location from which the driver is
3986      running, or, if that is not available, the configured prefix.  */
3987   tooldir_prefix
3988     = concat (gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
3989               spec_machine, dir_separator_str,
3990               spec_version, dir_separator_str, tooldir_prefix2, NULL);
3991   free (tooldir_prefix2);
3992
3993   add_prefix (&exec_prefixes,
3994               concat (tooldir_prefix, "bin", dir_separator_str, NULL),
3995               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 0);
3996   add_prefix (&startfile_prefixes,
3997               concat (tooldir_prefix, "lib", dir_separator_str, NULL),
3998               "BINUTILS", PREFIX_PRIORITY_LAST, 0, 1);
3999   free (tooldir_prefix);
4000
4001 #if defined(TARGET_SYSTEM_ROOT_RELOCATABLE) && !defined(VMS)
4002   /* If the normal TARGET_SYSTEM_ROOT is inside of $exec_prefix,
4003      then consider it to relocate with the rest of the GCC installation
4004      if GCC_EXEC_PREFIX is set.
4005      ``make_relative_prefix'' is not compiled for VMS, so don't call it.  */
4006   if (target_system_root && !target_system_root_changed && gcc_exec_prefix)
4007     {
4008       char *tmp_prefix = get_relative_prefix (decoded_options[0].arg,
4009                                               standard_bindir_prefix,
4010                                               target_system_root);
4011       if (tmp_prefix && access_check (tmp_prefix, F_OK) == 0)
4012         {
4013           target_system_root = tmp_prefix;
4014           target_system_root_changed = 1;
4015         }
4016     }
4017 #endif
4018
4019   /* More prefixes are enabled in main, after we read the specs file
4020      and determine whether this is cross-compilation or not.  */
4021
4022   if (n_infiles == last_language_n_infiles && spec_lang != 0)
4023     warning (0, "%<-x %s%> after last input file has no effect", spec_lang);
4024
4025   /* Synthesize -fcompare-debug flag from the GCC_COMPARE_DEBUG
4026      environment variable.  */
4027   if (compare_debug == 2 || compare_debug == 3)
4028     {
4029       const char *opt = concat ("-fcompare-debug=", compare_debug_opt, NULL);
4030       save_switch (opt, 0, NULL, false, true);
4031       compare_debug = 1;
4032     }
4033
4034   /* Ensure we only invoke each subprocess once.  */
4035   if (print_subprocess_help || print_help_list || print_version)
4036     {
4037       n_infiles = 0;
4038
4039       /* Create a dummy input file, so that we can pass
4040          the help option on to the various sub-processes.  */
4041       add_infile ("help-dummy", "c");
4042     }
4043
4044   alloc_switch ();
4045   switches[n_switches].part1 = 0;
4046   alloc_infile ();
4047   infiles[n_infiles].name = 0;
4048 }
4049
4050 /* Store switches not filtered out by %<S in spec in COLLECT_GCC_OPTIONS
4051    and place that in the environment.  */
4052
4053 static void
4054 set_collect_gcc_options (void)
4055 {
4056   int i;
4057   int first_time;
4058
4059   /* Build COLLECT_GCC_OPTIONS to have all of the options specified to
4060      the compiler.  */
4061   obstack_grow (&collect_obstack, "COLLECT_GCC_OPTIONS=",
4062                 sizeof ("COLLECT_GCC_OPTIONS=") - 1);
4063
4064   first_time = TRUE;
4065   for (i = 0; (int) i < n_switches; i++)
4066     {
4067       const char *const *args;
4068       const char *p, *q;
4069       if (!first_time)
4070         obstack_grow (&collect_obstack, " ", 1);
4071
4072       first_time = FALSE;
4073
4074       /* Ignore elided switches.  */
4075       if ((switches[i].live_cond
4076            & (SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC))
4077           == SWITCH_IGNORE)
4078         continue;
4079
4080       obstack_grow (&collect_obstack, "'-", 2);
4081       q = switches[i].part1;
4082       while ((p = strchr (q, '\'')))
4083         {
4084           obstack_grow (&collect_obstack, q, p - q);
4085           obstack_grow (&collect_obstack, "'\\''", 4);
4086           q = ++p;
4087         }
4088       obstack_grow (&collect_obstack, q, strlen (q));
4089       obstack_grow (&collect_obstack, "'", 1);
4090
4091       for (args = switches[i].args; args && *args; args++)
4092         {
4093           obstack_grow (&collect_obstack, " '", 2);
4094           q = *args;
4095           while ((p = strchr (q, '\'')))
4096             {
4097               obstack_grow (&collect_obstack, q, p - q);
4098               obstack_grow (&collect_obstack, "'\\''", 4);
4099               q = ++p;
4100             }
4101           obstack_grow (&collect_obstack, q, strlen (q));
4102           obstack_grow (&collect_obstack, "'", 1);
4103         }
4104     }
4105   obstack_grow (&collect_obstack, "\0", 1);
4106   xputenv (XOBFINISH (&collect_obstack, char *));
4107 }
4108 \f
4109 /* Process a spec string, accumulating and running commands.  */
4110
4111 /* These variables describe the input file name.
4112    input_file_number is the index on outfiles of this file,
4113    so that the output file name can be stored for later use by %o.
4114    input_basename is the start of the part of the input file
4115    sans all directory names, and basename_length is the number
4116    of characters starting there excluding the suffix .c or whatever.  */
4117
4118 static const char *gcc_input_filename;
4119 static int input_file_number;
4120 size_t input_filename_length;
4121 static int basename_length;
4122 static int suffixed_basename_length;
4123 static const char *input_basename;
4124 static const char *input_suffix;
4125 #ifndef HOST_LACKS_INODE_NUMBERS
4126 static struct stat input_stat;
4127 #endif
4128 static int input_stat_set;
4129
4130 /* The compiler used to process the current input file.  */
4131 static struct compiler *input_file_compiler;
4132
4133 /* These are variables used within do_spec and do_spec_1.  */
4134
4135 /* Nonzero if an arg has been started and not yet terminated
4136    (with space, tab or newline).  */
4137 static int arg_going;
4138
4139 /* Nonzero means %d or %g has been seen; the next arg to be terminated
4140    is a temporary file name.  */
4141 static int delete_this_arg;
4142
4143 /* Nonzero means %w has been seen; the next arg to be terminated
4144    is the output file name of this compilation.  */
4145 static int this_is_output_file;
4146
4147 /* Nonzero means %s has been seen; the next arg to be terminated
4148    is the name of a library file and we should try the standard
4149    search dirs for it.  */
4150 static int this_is_library_file;
4151
4152 /* Nonzero means %T has been seen; the next arg to be terminated
4153    is the name of a linker script and we should try all of the
4154    standard search dirs for it.  If it is found insert a --script
4155    command line switch and then substitute the full path in place,
4156    otherwise generate an error message.  */
4157 static int this_is_linker_script;
4158
4159 /* Nonzero means that the input of this command is coming from a pipe.  */
4160 static int input_from_pipe;
4161
4162 /* Nonnull means substitute this for any suffix when outputting a switches
4163    arguments.  */
4164 static const char *suffix_subst;
4165
4166 /* If there is an argument being accumulated, terminate it and store it.  */
4167
4168 static void
4169 end_going_arg (void)
4170 {
4171   if (arg_going)
4172     {
4173       const char *string;
4174
4175       obstack_1grow (&obstack, 0);
4176       string = XOBFINISH (&obstack, const char *);
4177       if (this_is_library_file)
4178         string = find_file (string);
4179       if (this_is_linker_script)
4180         {
4181           char * full_script_path = find_a_file (&startfile_prefixes, string, R_OK, true);
4182
4183           if (full_script_path == NULL)
4184             {
4185               error ("unable to locate default linker script %qs in the library search paths", string);
4186               /* Script was not found on search path.  */
4187               return;
4188             }
4189           store_arg ("--script", false, false);
4190           string = full_script_path;
4191         }
4192       store_arg (string, delete_this_arg, this_is_output_file);
4193       if (this_is_output_file)
4194         outfiles[input_file_number] = string;
4195       arg_going = 0;
4196     }
4197 }
4198
4199
4200 /* Parse the WRAPPER string which is a comma separated list of the command line
4201    and insert them into the beginning of argbuf.  */
4202
4203 static void
4204 insert_wrapper (const char *wrapper)
4205 {
4206   int n = 0;
4207   int i;
4208   char *buf = xstrdup (wrapper);
4209   char *p = buf;
4210   unsigned int old_length = argbuf.length ();
4211
4212   do
4213     {
4214       n++;
4215       while (*p == ',')
4216         p++;
4217     }
4218   while ((p = strchr (p, ',')) != NULL);
4219
4220   argbuf.safe_grow (old_length + n);
4221   memmove (argbuf.address () + n,
4222            argbuf.address (),
4223            old_length * sizeof (const_char_p));
4224
4225   i = 0;
4226   p = buf;
4227   do
4228     {
4229       while (*p == ',')
4230         {
4231           *p = 0;
4232           p++;
4233         }
4234       argbuf[i] = p;
4235       i++;
4236     }
4237   while ((p = strchr (p, ',')) != NULL);
4238   gcc_assert (i == n);
4239 }
4240
4241 /* Process the spec SPEC and run the commands specified therein.
4242    Returns 0 if the spec is successfully processed; -1 if failed.  */
4243
4244 int
4245 do_spec (const char *spec)
4246 {
4247   int value;
4248
4249   value = do_spec_2 (spec);
4250
4251   /* Force out any unfinished command.
4252      If -pipe, this forces out the last command if it ended in `|'.  */
4253   if (value == 0)
4254     {
4255       if (argbuf.length () > 0
4256           && !strcmp (argbuf.last (), "|"))
4257         argbuf.pop ();
4258
4259       set_collect_gcc_options ();
4260
4261       if (argbuf.length () > 0)
4262         value = execute ();
4263     }
4264
4265   return value;
4266 }
4267
4268 static int
4269 do_spec_2 (const char *spec)
4270 {
4271   int result;
4272
4273   clear_args ();
4274   arg_going = 0;
4275   delete_this_arg = 0;
4276   this_is_output_file = 0;
4277   this_is_library_file = 0;
4278   this_is_linker_script = 0;
4279   input_from_pipe = 0;
4280   suffix_subst = NULL;
4281
4282   result = do_spec_1 (spec, 0, NULL);
4283
4284   end_going_arg ();
4285
4286   return result;
4287 }
4288
4289
4290 /* Process the given spec string and add any new options to the end
4291    of the switches/n_switches array.  */
4292
4293 static void
4294 do_option_spec (const char *name, const char *spec)
4295 {
4296   unsigned int i, value_count, value_len;
4297   const char *p, *q, *value;
4298   char *tmp_spec, *tmp_spec_p;
4299
4300   if (configure_default_options[0].name == NULL)
4301     return;
4302
4303   for (i = 0; i < ARRAY_SIZE (configure_default_options); i++)
4304     if (strcmp (configure_default_options[i].name, name) == 0)
4305       break;
4306   if (i == ARRAY_SIZE (configure_default_options))
4307     return;
4308
4309   value = configure_default_options[i].value;
4310   value_len = strlen (value);
4311
4312   /* Compute the size of the final spec.  */
4313   value_count = 0;
4314   p = spec;
4315   while ((p = strstr (p, "%(VALUE)")) != NULL)
4316     {
4317       p ++;
4318       value_count ++;
4319     }
4320
4321   /* Replace each %(VALUE) by the specified value.  */
4322   tmp_spec = (char *) alloca (strlen (spec) + 1
4323                      + value_count * (value_len - strlen ("%(VALUE)")));
4324   tmp_spec_p = tmp_spec;
4325   q = spec;
4326   while ((p = strstr (q, "%(VALUE)")) != NULL)
4327     {
4328       memcpy (tmp_spec_p, q, p - q);
4329       tmp_spec_p = tmp_spec_p + (p - q);
4330       memcpy (tmp_spec_p, value, value_len);
4331       tmp_spec_p += value_len;
4332       q = p + strlen ("%(VALUE)");
4333     }
4334   strcpy (tmp_spec_p, q);
4335
4336   do_self_spec (tmp_spec);
4337 }
4338
4339 /* Process the given spec string and add any new options to the end
4340    of the switches/n_switches array.  */
4341
4342 static void
4343 do_self_spec (const char *spec)
4344 {
4345   int i;
4346
4347   do_spec_2 (spec);
4348   do_spec_1 (" ", 0, NULL);
4349
4350   /* Mark %<S switches processed by do_self_spec to be ignored permanently.
4351      do_self_specs adds the replacements to switches array, so it shouldn't
4352      be processed afterwards.  */
4353   for (i = 0; i < n_switches; i++)
4354     if ((switches[i].live_cond & SWITCH_IGNORE))
4355       switches[i].live_cond |= SWITCH_IGNORE_PERMANENTLY;
4356
4357   if (argbuf.length () > 0)
4358     {
4359       const char **argbuf_copy;
4360       struct cl_decoded_option *decoded_options;
4361       struct cl_option_handlers handlers;
4362       unsigned int decoded_options_count;
4363       unsigned int j;
4364
4365       /* Create a copy of argbuf with a dummy argv[0] entry for
4366          decode_cmdline_options_to_array.  */
4367       argbuf_copy = XNEWVEC (const char *,
4368                              argbuf.length () + 1);
4369       argbuf_copy[0] = "";
4370       memcpy (argbuf_copy + 1, argbuf.address (),
4371               argbuf.length () * sizeof (const char *));
4372
4373       decode_cmdline_options_to_array (argbuf.length () + 1,
4374                                        argbuf_copy,
4375                                        CL_DRIVER, &decoded_options,
4376                                        &decoded_options_count);
4377       free (argbuf_copy);
4378
4379       set_option_handlers (&handlers);
4380
4381       for (j = 1; j < decoded_options_count; j++)
4382         {
4383           switch (decoded_options[j].opt_index)
4384             {
4385             case OPT_SPECIAL_input_file:
4386               /* Specs should only generate options, not input
4387                  files.  */
4388               if (strcmp (decoded_options[j].arg, "-") != 0)
4389                 fatal_error ("switch %qs does not start with %<-%>",
4390                              decoded_options[j].arg);
4391               else
4392                 fatal_error ("spec-generated switch is just %<-%>");
4393               break;
4394
4395             case OPT_fcompare_debug_second:
4396             case OPT_fcompare_debug:
4397             case OPT_fcompare_debug_:
4398             case OPT_o:
4399               /* Avoid duplicate processing of some options from
4400                  compare-debug specs; just save them here.  */
4401               save_switch (decoded_options[j].canonical_option[0],
4402                            (decoded_options[j].canonical_option_num_elements
4403                             - 1),
4404                            &decoded_options[j].canonical_option[1], false, true);
4405               break;
4406
4407             default:
4408               read_cmdline_option (&global_options, &global_options_set,
4409                                    decoded_options + j, UNKNOWN_LOCATION,
4410                                    CL_DRIVER, &handlers, global_dc);
4411               break;
4412             }
4413         }
4414
4415       alloc_switch ();
4416       switches[n_switches].part1 = 0;
4417     }
4418 }
4419
4420 /* Callback for processing %D and %I specs.  */
4421
4422 struct spec_path_info {
4423   const char *option;
4424   const char *append;
4425   size_t append_len;
4426   bool omit_relative;
4427   bool separate_options;
4428 };
4429
4430 static void *
4431 spec_path (char *path, void *data)
4432 {
4433   struct spec_path_info *info = (struct spec_path_info *) data;
4434   size_t len = 0;
4435   char save = 0;
4436
4437   if (info->omit_relative && !IS_ABSOLUTE_PATH (path))
4438     return NULL;
4439
4440   if (info->append_len != 0)
4441     {
4442       len = strlen (path);
4443       memcpy (path + len, info->append, info->append_len + 1);
4444     }
4445
4446   if (!is_directory (path, true))
4447     return NULL;
4448
4449   do_spec_1 (info->option, 1, NULL);
4450   if (info->separate_options)
4451     do_spec_1 (" ", 0, NULL);
4452
4453   if (info->append_len == 0)
4454     {
4455       len = strlen (path);
4456       save = path[len - 1];
4457       if (IS_DIR_SEPARATOR (path[len - 1]))
4458         path[len - 1] = '\0';
4459     }
4460
4461   do_spec_1 (path, 1, NULL);
4462   do_spec_1 (" ", 0, NULL);
4463
4464   /* Must not damage the original path.  */
4465   if (info->append_len == 0)
4466     path[len - 1] = save;
4467
4468   return NULL;
4469 }
4470
4471 /* Create a temporary FILE with the contents of ARGV. Add @FILE to the
4472    argument list. */
4473
4474 static void
4475 create_at_file (char **argv)
4476 {
4477   char *temp_file = make_temp_file ("");
4478   char *at_argument = concat ("@", temp_file, NULL);
4479   FILE *f = fopen (temp_file, "w");
4480   int status;
4481
4482   if (f == NULL)
4483     fatal_error ("could not open temporary response file %s",
4484                  temp_file);
4485
4486   status = writeargv (argv, f);
4487
4488   if (status)
4489     fatal_error ("could not write to temporary response file %s",
4490                  temp_file);
4491
4492   status = fclose (f);
4493
4494   if (EOF == status)
4495     fatal_error ("could not close temporary response file %s",
4496                  temp_file);
4497
4498   store_arg (at_argument, 0, 0);
4499
4500   record_temp_file (temp_file, !save_temps_flag, !save_temps_flag);
4501 }
4502
4503 /* True if we should compile INFILE. */
4504
4505 static bool
4506 compile_input_file_p (struct infile *infile)
4507 {
4508   if ((!infile->language) || (infile->language[0] != '*'))
4509     if (infile->incompiler == input_file_compiler)
4510       return true;
4511   return false;
4512 }
4513
4514 /* Process each member of VEC as a spec.  */
4515
4516 static void
4517 do_specs_vec (vec<char_p> vec)
4518 {
4519   unsigned ix;
4520   char *opt;
4521
4522   FOR_EACH_VEC_ELT (vec, ix, opt)
4523     {
4524       do_spec_1 (opt, 1, NULL);
4525       /* Make each accumulated option a separate argument.  */
4526       do_spec_1 (" ", 0, NULL);
4527     }
4528 }
4529
4530 /* Process the sub-spec SPEC as a portion of a larger spec.
4531    This is like processing a whole spec except that we do
4532    not initialize at the beginning and we do not supply a
4533    newline by default at the end.
4534    INSWITCH nonzero means don't process %-sequences in SPEC;
4535    in this case, % is treated as an ordinary character.
4536    This is used while substituting switches.
4537    INSWITCH nonzero also causes SPC not to terminate an argument.
4538
4539    Value is zero unless a line was finished
4540    and the command on that line reported an error.  */
4541
4542 static int
4543 do_spec_1 (const char *spec, int inswitch, const char *soft_matched_part)
4544 {
4545   const char *p = spec;
4546   int c;
4547   int i;
4548   int value;
4549
4550   /* If it's an empty string argument to a switch, keep it as is.  */
4551   if (inswitch && !*p)
4552     arg_going = 1;
4553
4554   while ((c = *p++))
4555     /* If substituting a switch, treat all chars like letters.
4556        Otherwise, NL, SPC, TAB and % are special.  */
4557     switch (inswitch ? 'a' : c)
4558       {
4559       case '\n':
4560         end_going_arg ();
4561
4562         if (argbuf.length () > 0
4563             && !strcmp (argbuf.last (), "|"))
4564           {
4565             /* A `|' before the newline means use a pipe here,
4566                but only if -pipe was specified.
4567                Otherwise, execute now and don't pass the `|' as an arg.  */
4568             if (use_pipes)
4569               {
4570                 input_from_pipe = 1;
4571                 break;
4572               }
4573             else
4574               argbuf.pop ();
4575           }
4576
4577         set_collect_gcc_options ();
4578
4579         if (argbuf.length () > 0)
4580           {
4581             value = execute ();
4582             if (value)
4583               return value;
4584           }
4585         /* Reinitialize for a new command, and for a new argument.  */
4586         clear_args ();
4587         arg_going = 0;
4588         delete_this_arg = 0;
4589         this_is_output_file = 0;
4590         this_is_library_file = 0;
4591         this_is_linker_script = 0;
4592         input_from_pipe = 0;
4593         break;
4594
4595       case '|':
4596         end_going_arg ();
4597
4598         /* Use pipe */
4599         obstack_1grow (&obstack, c);
4600         arg_going = 1;
4601         break;
4602
4603       case '\t':
4604       case ' ':
4605         end_going_arg ();
4606
4607         /* Reinitialize for a new argument.  */
4608         delete_this_arg = 0;
4609         this_is_output_file = 0;
4610         this_is_library_file = 0;
4611         this_is_linker_script = 0;
4612         break;
4613
4614       case '%':
4615         switch (c = *p++)
4616           {
4617           case 0:
4618             fatal_error ("spec %qs invalid", spec);
4619
4620           case 'b':
4621             if (save_temps_length)
4622               obstack_grow (&obstack, save_temps_prefix, save_temps_length);
4623             else
4624               obstack_grow (&obstack, input_basename, basename_length);
4625             if (compare_debug < 0)
4626               obstack_grow (&obstack, ".gk", 3);
4627             arg_going = 1;
4628             break;
4629
4630           case 'B':
4631             if (save_temps_length)
4632               obstack_grow (&obstack, save_temps_prefix, save_temps_length);
4633             else
4634               obstack_grow (&obstack, input_basename, suffixed_basename_length);
4635             if (compare_debug < 0)
4636               obstack_grow (&obstack, ".gk", 3);
4637             arg_going = 1;
4638             break;
4639
4640           case 'd':
4641             delete_this_arg = 2;
4642             break;
4643
4644           /* Dump out the directories specified with LIBRARY_PATH,
4645              followed by the absolute directories
4646              that we search for startfiles.  */
4647           case 'D':
4648             {
4649               struct spec_path_info info;
4650
4651               info.option = "-L";
4652               info.append_len = 0;
4653 #ifdef RELATIVE_PREFIX_NOT_LINKDIR
4654               /* Used on systems which record the specified -L dirs
4655                  and use them to search for dynamic linking.
4656                  Relative directories always come from -B,
4657                  and it is better not to use them for searching
4658                  at run time.  In particular, stage1 loses.  */
4659               info.omit_relative = true;
4660 #else
4661               info.omit_relative = false;
4662 #endif
4663               info.separate_options = false;
4664
4665               for_each_path (&startfile_prefixes, true, 0, spec_path, &info);
4666             }
4667             break;
4668
4669           case 'e':
4670             /* %efoo means report an error with `foo' as error message
4671                and don't execute any more commands for this file.  */
4672             {
4673               const char *q = p;
4674               char *buf;
4675               while (*p != 0 && *p != '\n')
4676                 p++;
4677               buf = (char *) alloca (p - q + 1);
4678               strncpy (buf, q, p - q);
4679               buf[p - q] = 0;
4680               error ("%s", _(buf));
4681               return -1;
4682             }
4683             break;
4684           case 'n':
4685             /* %nfoo means report a notice with `foo' on stderr.  */
4686             {
4687               const char *q = p;
4688               char *buf;
4689               while (*p != 0 && *p != '\n')
4690                 p++;
4691               buf = (char *) alloca (p - q + 1);
4692               strncpy (buf, q, p - q);
4693               buf[p - q] = 0;
4694               inform (0, "%s", _(buf));
4695               if (*p)
4696                 p++;
4697             }
4698             break;
4699
4700           case 'j':
4701             {
4702               struct stat st;
4703
4704               /* If save_temps_flag is off, and the HOST_BIT_BUCKET is
4705                  defined, and it is not a directory, and it is
4706                  writable, use it.  Otherwise, treat this like any
4707                  other temporary file.  */
4708
4709               if ((!save_temps_flag)
4710                   && (stat (HOST_BIT_BUCKET, &st) == 0) && (!S_ISDIR (st.st_mode))
4711                   && (access (HOST_BIT_BUCKET, W_OK) == 0))
4712                 {
4713                   obstack_grow (&obstack, HOST_BIT_BUCKET,
4714                                 strlen (HOST_BIT_BUCKET));
4715                   delete_this_arg = 0;
4716                   arg_going = 1;
4717                   break;
4718                 }
4719             }
4720             goto create_temp_file;
4721           case '|':
4722             if (use_pipes)
4723               {
4724                 obstack_1grow (&obstack, '-');
4725                 delete_this_arg = 0;
4726                 arg_going = 1;
4727
4728                 /* consume suffix */
4729                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4730                   p++;
4731                 if (p[0] == '%' && p[1] == 'O')
4732                   p += 2;
4733
4734                 break;
4735               }
4736             goto create_temp_file;
4737           case 'm':
4738             if (use_pipes)
4739               {
4740                 /* consume suffix */
4741                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4742                   p++;
4743                 if (p[0] == '%' && p[1] == 'O')
4744                   p += 2;
4745
4746                 break;
4747               }
4748             goto create_temp_file;
4749           case 'g':
4750           case 'u':
4751           case 'U':
4752           create_temp_file:
4753               {
4754                 struct temp_name *t;
4755                 int suffix_length;
4756                 const char *suffix = p;
4757                 char *saved_suffix = NULL;
4758
4759                 while (*p == '.' || ISALNUM ((unsigned char) *p))
4760                   p++;
4761                 suffix_length = p - suffix;
4762                 if (p[0] == '%' && p[1] == 'O')
4763                   {
4764                     p += 2;
4765                     /* We don't support extra suffix characters after %O.  */
4766                     if (*p == '.' || ISALNUM ((unsigned char) *p))
4767                       fatal_error ("spec %qs has invalid %<%%0%c%>", spec, *p);
4768                     if (suffix_length == 0)
4769                       suffix = TARGET_OBJECT_SUFFIX;
4770                     else
4771                       {
4772                         saved_suffix
4773                           = XNEWVEC (char, suffix_length
4774                                      + strlen (TARGET_OBJECT_SUFFIX));
4775                         strncpy (saved_suffix, suffix, suffix_length);
4776                         strcpy (saved_suffix + suffix_length,
4777                                 TARGET_OBJECT_SUFFIX);
4778                       }
4779                     suffix_length += strlen (TARGET_OBJECT_SUFFIX);
4780                   }
4781
4782                 if (compare_debug < 0)
4783                   {
4784                     suffix = concat (".gk", suffix, NULL);
4785                     suffix_length += 3;
4786                   }
4787
4788                 /* If -save-temps=obj and -o were specified, use that for the
4789                    temp file.  */
4790                 if (save_temps_length)
4791                   {
4792                     char *tmp;
4793                     temp_filename_length
4794                       = save_temps_length + suffix_length + 1;
4795                     tmp = (char *) alloca (temp_filename_length);
4796                     memcpy (tmp, save_temps_prefix, save_temps_length);
4797                     memcpy (tmp + save_temps_length, suffix, suffix_length);
4798                     tmp[save_temps_length + suffix_length] = '\0';
4799                     temp_filename = save_string (tmp, save_temps_length
4800                                                       + suffix_length);
4801                     obstack_grow (&obstack, temp_filename,
4802                                   temp_filename_length);
4803                     arg_going = 1;
4804                     delete_this_arg = 0;
4805                     break;
4806                   }
4807
4808                 /* If the gcc_input_filename has the same suffix specified
4809                    for the %g, %u, or %U, and -save-temps is specified,
4810                    we could end up using that file as an intermediate
4811                    thus clobbering the user's source file (.e.g.,
4812                    gcc -save-temps foo.s would clobber foo.s with the
4813                    output of cpp0).  So check for this condition and
4814                    generate a temp file as the intermediate.  */
4815
4816                 if (save_temps_flag)
4817                   {
4818                     char *tmp;
4819                     temp_filename_length = basename_length + suffix_length + 1;
4820                     tmp = (char *) alloca (temp_filename_length);
4821                     memcpy (tmp, input_basename, basename_length);
4822                     memcpy (tmp + basename_length, suffix, suffix_length);
4823                     tmp[basename_length + suffix_length] = '\0';
4824                     temp_filename = tmp;
4825
4826                     if (filename_cmp (temp_filename, gcc_input_filename) != 0)
4827                       {
4828 #ifndef HOST_LACKS_INODE_NUMBERS
4829                         struct stat st_temp;
4830
4831                         /* Note, set_input() resets input_stat_set to 0.  */
4832                         if (input_stat_set == 0)
4833                           {
4834                             input_stat_set = stat (gcc_input_filename,
4835                                                    &input_stat);
4836                             if (input_stat_set >= 0)
4837                               input_stat_set = 1;
4838                           }
4839
4840                         /* If we have the stat for the gcc_input_filename
4841                            and we can do the stat for the temp_filename
4842                            then the they could still refer to the same
4843                            file if st_dev/st_ino's are the same.  */
4844                         if (input_stat_set != 1
4845                             || stat (temp_filename, &st_temp) < 0
4846                             || input_stat.st_dev != st_temp.st_dev
4847                             || input_stat.st_ino != st_temp.st_ino)
4848 #else
4849                         /* Just compare canonical pathnames.  */
4850                         char* input_realname = lrealpath (gcc_input_filename);
4851                         char* temp_realname = lrealpath (temp_filename);
4852                         bool files_differ = filename_cmp (input_realname, temp_realname);
4853                         free (input_realname);
4854                         free (temp_realname);
4855                         if (files_differ)
4856 #endif
4857                           {
4858                             temp_filename = save_string (temp_filename,
4859                                                          temp_filename_length + 1);
4860                             obstack_grow (&obstack, temp_filename,
4861                                                     temp_filename_length);
4862                             arg_going = 1;
4863                             delete_this_arg = 0;
4864                             break;
4865                           }
4866                       }
4867                   }
4868
4869                 /* See if we already have an association of %g/%u/%U and
4870                    suffix.  */
4871                 for (t = temp_names; t; t = t->next)
4872                   if (t->length == suffix_length
4873                       && strncmp (t->suffix, suffix, suffix_length) == 0
4874                       && t->unique == (c == 'u' || c == 'U' || c == 'j'))
4875                     break;
4876
4877                 /* Make a new association if needed.  %u and %j
4878                    require one.  */
4879                 if (t == 0 || c == 'u' || c == 'j')
4880                   {
4881                     if (t == 0)
4882                       {
4883                         t = XNEW (struct temp_name);
4884                         t->next = temp_names;
4885                         temp_names = t;
4886                       }
4887                     t->length = suffix_length;
4888                     if (saved_suffix)
4889                       {
4890                         t->suffix = saved_suffix;
4891                         saved_suffix = NULL;
4892                       }
4893                     else
4894                       t->suffix = save_string (suffix, suffix_length);
4895                     t->unique = (c == 'u' || c == 'U' || c == 'j');
4896                     temp_filename = make_temp_file (t->suffix);
4897                     temp_filename_length = strlen (temp_filename);
4898                     t->filename = temp_filename;
4899                     t->filename_length = temp_filename_length;
4900                   }
4901
4902                 free (saved_suffix);
4903
4904                 obstack_grow (&obstack, t->filename, t->filename_length);
4905                 delete_this_arg = 1;
4906               }
4907             arg_going = 1;
4908             break;
4909
4910           case 'i':
4911             if (combine_inputs)
4912               {
4913                 if (at_file_supplied)
4914                   {
4915                     /* We are going to expand `%i' to `@FILE', where FILE
4916                        is a newly-created temporary filename.  The filenames
4917                        that would usually be expanded in place of %o will be
4918                        written to the temporary file.  */
4919                     char **argv;
4920                     int n_files = 0;
4921                     int j;
4922
4923                     for (i = 0; i < n_infiles; i++)
4924                       if (compile_input_file_p (&infiles[i]))
4925                         n_files++;
4926
4927                     argv = (char **) alloca (sizeof (char *) * (n_files + 1));
4928
4929                     /* Copy the strings over.  */
4930                     for (i = 0, j = 0; i < n_infiles; i++)
4931                       if (compile_input_file_p (&infiles[i]))
4932                         {
4933                           argv[j] = CONST_CAST (char *, infiles[i].name);
4934                           infiles[i].compiled = true;
4935                           j++;
4936                         }
4937                     argv[j] = NULL;
4938
4939                     create_at_file (argv);
4940                   }
4941                 else
4942                   for (i = 0; (int) i < n_infiles; i++)
4943                     if (compile_input_file_p (&infiles[i]))
4944                       {
4945                         store_arg (infiles[i].name, 0, 0);
4946                         infiles[i].compiled = true;
4947                       }
4948               }
4949             else
4950               {
4951                 obstack_grow (&obstack, gcc_input_filename,
4952                               input_filename_length);
4953                 arg_going = 1;
4954               }
4955             break;
4956
4957           case 'I':
4958             {
4959               struct spec_path_info info;
4960
4961               if (multilib_dir)
4962                 {
4963                   do_spec_1 ("-imultilib", 1, NULL);
4964                   /* Make this a separate argument.  */
4965                   do_spec_1 (" ", 0, NULL);
4966                   do_spec_1 (multilib_dir, 1, NULL);
4967                   do_spec_1 (" ", 0, NULL);
4968                 }
4969
4970               if (multiarch_dir)
4971                 {
4972                   do_spec_1 ("-imultiarch", 1, NULL);
4973                   /* Make this a separate argument.  */
4974                   do_spec_1 (" ", 0, NULL);
4975                   do_spec_1 (multiarch_dir, 1, NULL);
4976                   do_spec_1 (" ", 0, NULL);
4977                 }
4978
4979               if (gcc_exec_prefix)
4980                 {
4981                   do_spec_1 ("-iprefix", 1, NULL);
4982                   /* Make this a separate argument.  */
4983                   do_spec_1 (" ", 0, NULL);
4984                   do_spec_1 (gcc_exec_prefix, 1, NULL);
4985                   do_spec_1 (" ", 0, NULL);
4986                 }
4987
4988               if (target_system_root_changed ||
4989                   (target_system_root && target_sysroot_hdrs_suffix))
4990                 {
4991                   do_spec_1 ("-isysroot", 1, NULL);
4992                   /* Make this a separate argument.  */
4993                   do_spec_1 (" ", 0, NULL);
4994                   do_spec_1 (target_system_root, 1, NULL);
4995                   if (target_sysroot_hdrs_suffix)
4996                     do_spec_1 (target_sysroot_hdrs_suffix, 1, NULL);
4997                   do_spec_1 (" ", 0, NULL);
4998                 }
4999
5000               info.option = "-isystem";
5001               info.append = "include";
5002               info.append_len = strlen (info.append);
5003               info.omit_relative = false;
5004               info.separate_options = true;
5005
5006               for_each_path (&include_prefixes, false, info.append_len,
5007                              spec_path, &info);
5008
5009               info.append = "include-fixed";
5010               if (*sysroot_hdrs_suffix_spec)
5011                 info.append = concat (info.append, dir_separator_str,
5012                                       multilib_dir, NULL);
5013               info.append_len = strlen (info.append);
5014               for_each_path (&include_prefixes, false, info.append_len,
5015                              spec_path, &info);
5016             }
5017             break;
5018
5019           case 'o':
5020             {
5021               int max = n_infiles;
5022               max += lang_specific_extra_outfiles;
5023
5024               if (HAVE_GNU_LD && at_file_supplied)
5025                 {
5026                   /* We are going to expand `%o' to `@FILE', where FILE
5027                      is a newly-created temporary filename.  The filenames
5028                      that would usually be expanded in place of %o will be
5029                      written to the temporary file.  */
5030
5031                   char **argv;
5032                   int n_files, j;
5033
5034                   /* Convert OUTFILES into a form suitable for writeargv.  */
5035
5036                   /* Determine how many are non-NULL.  */
5037                   for (n_files = 0, i = 0; i < max; i++)
5038                     n_files += outfiles[i] != NULL;
5039
5040                   argv = (char **) alloca (sizeof (char *) * (n_files + 1));
5041
5042                   /* Copy the strings over.  */
5043                   for (i = 0, j = 0; i < max; i++)
5044                     if (outfiles[i])
5045                       {
5046                         argv[j] = CONST_CAST (char *, outfiles[i]);
5047                         j++;
5048                       }
5049                   argv[j] = NULL;
5050
5051                   create_at_file (argv);
5052                 }
5053               else
5054                 for (i = 0; i < max; i++)
5055                   if (outfiles[i])
5056                     store_arg (outfiles[i], 0, 0);
5057               break;
5058             }
5059
5060           case 'O':
5061             obstack_grow (&obstack, TARGET_OBJECT_SUFFIX, strlen (TARGET_OBJECT_SUFFIX));
5062             arg_going = 1;
5063             break;
5064
5065           case 's':
5066             this_is_library_file = 1;
5067             break;
5068
5069           case 'T':
5070             this_is_linker_script = 1;
5071             break;
5072
5073           case 'V':
5074             outfiles[input_file_number] = NULL;
5075             break;
5076
5077           case 'w':
5078             this_is_output_file = 1;
5079             break;
5080
5081           case 'W':
5082             {
5083               unsigned int cur_index = argbuf.length ();
5084               /* Handle the {...} following the %W.  */
5085               if (*p != '{')
5086                 fatal_error ("spec %qs has invalid %<%%W%c%>", spec, *p);
5087               p = handle_braces (p + 1);
5088               if (p == 0)
5089                 return -1;
5090               end_going_arg ();
5091               /* If any args were output, mark the last one for deletion
5092                  on failure.  */
5093               if (argbuf.length () != cur_index)
5094                 record_temp_file (argbuf.last (), 0, 1);
5095               break;
5096             }
5097
5098           /* %x{OPTION} records OPTION for %X to output.  */
5099           case 'x':
5100             {
5101               const char *p1 = p;
5102               char *string;
5103               char *opt;
5104               unsigned ix;
5105
5106               /* Skip past the option value and make a copy.  */
5107               if (*p != '{')
5108                 fatal_error ("spec %qs has invalid %<%%x%c%>", spec, *p);
5109               while (*p++ != '}')
5110                 ;
5111               string = save_string (p1 + 1, p - p1 - 2);
5112
5113               /* See if we already recorded this option.  */
5114               FOR_EACH_VEC_ELT (linker_options, ix, opt)
5115                 if (! strcmp (string, opt))
5116                   {
5117                     free (string);
5118                     return 0;
5119                   }
5120
5121               /* This option is new; add it.  */
5122               add_linker_option (string, strlen (string));
5123               free (string);
5124             }
5125             break;
5126
5127           /* Dump out the options accumulated previously using %x.  */
5128           case 'X':
5129             do_specs_vec (linker_options);
5130             break;
5131
5132           /* Dump out the options accumulated previously using -Wa,.  */
5133           case 'Y':
5134             do_specs_vec (assembler_options);
5135             break;
5136
5137           /* Dump out the options accumulated previously using -Wp,.  */
5138           case 'Z':
5139             do_specs_vec (preprocessor_options);
5140             break;
5141
5142             /* Here are digits and numbers that just process
5143                a certain constant string as a spec.  */
5144
5145           case '1':
5146             value = do_spec_1 (cc1_spec, 0, NULL);
5147             if (value != 0)
5148               return value;
5149             break;
5150
5151           case '2':
5152             value = do_spec_1 (cc1plus_spec, 0, NULL);
5153             if (value != 0)
5154               return value;
5155             break;
5156
5157           case 'a':
5158             value = do_spec_1 (asm_spec, 0, NULL);
5159             if (value != 0)
5160               return value;
5161             break;
5162
5163           case 'A':
5164             value = do_spec_1 (asm_final_spec, 0, NULL);
5165             if (value != 0)
5166               return value;
5167             break;
5168
5169           case 'C':
5170             {
5171               const char *const spec
5172                 = (input_file_compiler->cpp_spec
5173                    ? input_file_compiler->cpp_spec
5174                    : cpp_spec);
5175               value = do_spec_1 (spec, 0, NULL);
5176               if (value != 0)
5177                 return value;
5178             }
5179             break;
5180
5181           case 'E':
5182             value = do_spec_1 (endfile_spec, 0, NULL);
5183             if (value != 0)
5184               return value;
5185             break;
5186
5187           case 'l':
5188             value = do_spec_1 (link_spec, 0, NULL);
5189             if (value != 0)
5190               return value;
5191             break;
5192
5193           case 'L':
5194             value = do_spec_1 (lib_spec, 0, NULL);
5195             if (value != 0)
5196               return value;
5197             break;
5198
5199           case 'M':
5200             if (multilib_os_dir == NULL)
5201               obstack_1grow (&obstack, '.');
5202             else
5203               obstack_grow (&obstack, multilib_os_dir,
5204                             strlen (multilib_os_dir));
5205             break;
5206
5207           case 'G':
5208             value = do_spec_1 (libgcc_spec, 0, NULL);
5209             if (value != 0)
5210               return value;
5211             break;
5212
5213           case 'R':
5214             /* We assume there is a directory
5215                separator at the end of this string.  */
5216             if (target_system_root)
5217               {
5218                 obstack_grow (&obstack, target_system_root,
5219                               strlen (target_system_root));
5220                 if (target_sysroot_suffix)
5221                   obstack_grow (&obstack, target_sysroot_suffix,
5222                                 strlen (target_sysroot_suffix));
5223               }
5224             break;
5225
5226           case 'S':
5227             value = do_spec_1 (startfile_spec, 0, NULL);
5228             if (value != 0)
5229               return value;
5230             break;
5231
5232             /* Here we define characters other than letters and digits.  */
5233
5234           case '{':
5235             p = handle_braces (p);
5236             if (p == 0)
5237               return -1;
5238             break;
5239
5240           case ':':
5241             p = handle_spec_function (p);
5242             if (p == 0)
5243               return -1;
5244             break;
5245
5246           case '%':
5247             obstack_1grow (&obstack, '%');
5248             break;
5249
5250           case '.':
5251             {
5252               unsigned len = 0;
5253
5254               while (p[len] && p[len] != ' ' && p[len] != '%')
5255                 len++;
5256               suffix_subst = save_string (p - 1, len + 1);
5257               p += len;
5258             }
5259            break;
5260
5261            /* Henceforth ignore the option(s) matching the pattern
5262               after the %<.  */
5263           case '<':
5264           case '>':
5265             {
5266               unsigned len = 0;
5267               int have_wildcard = 0;
5268               int i;
5269               int switch_option;
5270
5271               if (c == '>')
5272                 switch_option = SWITCH_IGNORE | SWITCH_KEEP_FOR_GCC;
5273               else
5274                 switch_option = SWITCH_IGNORE;
5275
5276               while (p[len] && p[len] != ' ' && p[len] != '\t')
5277                 len++;
5278
5279               if (p[len-1] == '*')
5280                 have_wildcard = 1;
5281
5282               for (i = 0; i < n_switches; i++)
5283                 if (!strncmp (switches[i].part1, p, len - have_wildcard)
5284                     && (have_wildcard || switches[i].part1[len] == '\0'))
5285                   {
5286                     switches[i].live_cond |= switch_option;
5287                     /* User switch be validated from validate_all_switches.
5288                        when the definition is seen from the spec file.
5289                        If not defined anywhere, will be rejected.  */
5290                     if (switches[i].known)
5291                       switches[i].validated = true;
5292                   }
5293
5294               p += len;
5295             }
5296             break;
5297
5298           case '*':
5299             if (soft_matched_part)
5300               {
5301                 if (soft_matched_part[0])
5302                   do_spec_1 (soft_matched_part, 1, NULL);
5303                 do_spec_1 (" ", 0, NULL);
5304               }
5305             else
5306               /* Catch the case where a spec string contains something like
5307                  '%{foo:%*}'.  i.e. there is no * in the pattern on the left
5308                  hand side of the :.  */
5309               error ("spec failure: %<%%*%> has not been initialized by pattern match");
5310             break;
5311
5312             /* Process a string found as the value of a spec given by name.
5313                This feature allows individual machine descriptions
5314                to add and use their own specs.  */
5315           case '(':
5316             {
5317               const char *name = p;
5318               struct spec_list *sl;
5319               int len;
5320
5321               /* The string after the S/P is the name of a spec that is to be
5322                  processed.  */
5323               while (*p && *p != ')')
5324                 p++;
5325
5326               /* See if it's in the list.  */
5327               for (len = p - name, sl = specs; sl; sl = sl->next)
5328                 if (sl->name_len == len && !strncmp (sl->name, name, len))
5329                   {
5330                     name = *(sl->ptr_spec);
5331 #ifdef DEBUG_SPECS
5332                     fnotice (stderr, "Processing spec (%s), which is '%s'\n",
5333                              sl->name, name);
5334 #endif
5335                     break;
5336                   }
5337
5338               if (sl)
5339                 {
5340                   value = do_spec_1 (name, 0, NULL);
5341                   if (value != 0)
5342                     return value;
5343                 }
5344
5345               /* Discard the closing paren.  */
5346               if (*p)
5347                 p++;
5348             }
5349             break;
5350
5351           default:
5352             error ("spec failure: unrecognized spec option %qc", c);
5353             break;
5354           }
5355         break;
5356
5357       case '\\':
5358         /* Backslash: treat next character as ordinary.  */
5359         c = *p++;
5360
5361         /* Fall through.  */
5362       default:
5363         /* Ordinary character: put it into the current argument.  */
5364         obstack_1grow (&obstack, c);
5365         arg_going = 1;
5366       }
5367
5368   /* End of string.  If we are processing a spec function, we need to
5369      end any pending argument.  */
5370   if (processing_spec_function)
5371     end_going_arg ();
5372
5373   return 0;
5374 }
5375
5376 /* Look up a spec function.  */
5377
5378 static const struct spec_function *
5379 lookup_spec_function (const char *name)
5380 {
5381   const struct spec_function *sf;
5382
5383   for (sf = static_spec_functions; sf->name != NULL; sf++)
5384     if (strcmp (sf->name, name) == 0)
5385       return sf;
5386
5387   return NULL;
5388 }
5389
5390 /* Evaluate a spec function.  */
5391
5392 static const char *
5393 eval_spec_function (const char *func, const char *args)
5394 {
5395   const struct spec_function *sf;
5396   const char *funcval;
5397
5398   /* Saved spec processing context.  */
5399   vec<const_char_p> save_argbuf;
5400
5401   int save_arg_going;
5402   int save_delete_this_arg;
5403   int save_this_is_output_file;
5404   int save_this_is_library_file;
5405   int save_input_from_pipe;
5406   int save_this_is_linker_script;
5407   const char *save_suffix_subst;
5408
5409   int save_growing_size;
5410   void *save_growing_value;
5411
5412   sf = lookup_spec_function (func);
5413   if (sf == NULL)
5414     fatal_error ("unknown spec function %qs", func);
5415
5416   /* Push the spec processing context.  */
5417   save_argbuf = argbuf;
5418
5419   save_arg_going = arg_going;
5420   save_delete_this_arg = delete_this_arg;
5421   save_this_is_output_file = this_is_output_file;
5422   save_this_is_library_file = this_is_library_file;
5423   save_this_is_linker_script = this_is_linker_script;
5424   save_input_from_pipe = input_from_pipe;
5425   save_suffix_subst = suffix_subst;
5426
5427   /* If we have some object growing now, finalize it so the args and function
5428      eval proceed from a cleared context.  This is needed to prevent the first
5429      constructed arg from mistakenly including the growing value.  We'll push
5430      this value back on the obstack once the function evaluation is done, to
5431      restore a consistent processing context for our caller.  This is fine as
5432      the address of growing objects isn't guaranteed to remain stable until
5433      they are finalized, and we expect this situation to be rare enough for
5434      the extra copy not to be an issue.  */
5435   save_growing_size = obstack_object_size (&obstack);
5436   if (save_growing_size > 0)
5437     save_growing_value = obstack_finish (&obstack);
5438
5439   /* Create a new spec processing context, and build the function
5440      arguments.  */
5441
5442   alloc_args ();
5443   if (do_spec_2 (args) < 0)
5444     fatal_error ("error in args to spec function %qs", func);
5445
5446   /* argbuf_index is an index for the next argument to be inserted, and
5447      so contains the count of the args already inserted.  */
5448
5449   funcval = (*sf->func) (argbuf.length (),
5450                          argbuf.address ());
5451
5452   /* Pop the spec processing context.  */
5453   argbuf.release ();
5454   argbuf = save_argbuf;
5455
5456   arg_going = save_arg_going;
5457   delete_this_arg = save_delete_this_arg;
5458   this_is_output_file = save_this_is_output_file;
5459   this_is_library_file = save_this_is_library_file;
5460   this_is_linker_script = save_this_is_linker_script;
5461   input_from_pipe = save_input_from_pipe;
5462   suffix_subst = save_suffix_subst;
5463
5464   if (save_growing_size > 0)
5465     obstack_grow (&obstack, save_growing_value, save_growing_size);
5466
5467   return funcval;
5468 }
5469
5470 /* Handle a spec function call of the form:
5471
5472    %:function(args)
5473
5474    ARGS is processed as a spec in a separate context and split into an
5475    argument vector in the normal fashion.  The function returns a string
5476    containing a spec which we then process in the caller's context, or
5477    NULL if no processing is required.  */
5478
5479 static const char *
5480 handle_spec_function (const char *p)
5481 {
5482   char *func, *args;
5483   const char *endp, *funcval;
5484   int count;
5485
5486   processing_spec_function++;
5487
5488   /* Get the function name.  */
5489   for (endp = p; *endp != '\0'; endp++)
5490     {
5491       if (*endp == '(')         /* ) */
5492         break;
5493       /* Only allow [A-Za-z0-9], -, and _ in function names.  */
5494       if (!ISALNUM (*endp) && !(*endp == '-' || *endp == '_'))
5495         fatal_error ("malformed spec function name");
5496     }
5497   if (*endp != '(')             /* ) */
5498     fatal_error ("no arguments for spec function");
5499   func = save_string (p, endp - p);
5500   p = ++endp;
5501
5502   /* Get the arguments.  */
5503   for (count = 0; *endp != '\0'; endp++)
5504     {
5505       /* ( */
5506       if (*endp == ')')
5507         {
5508           if (count == 0)
5509             break;
5510           count--;
5511         }
5512       else if (*endp == '(')    /* ) */
5513         count++;
5514     }
5515   /* ( */
5516   if (*endp != ')')
5517     fatal_error ("malformed spec function arguments");
5518   args = save_string (p, endp - p);
5519   p = ++endp;
5520
5521   /* p now points to just past the end of the spec function expression.  */
5522
5523   funcval = eval_spec_function (func, args);
5524   if (funcval != NULL && do_spec_1 (funcval, 0, NULL) < 0)
5525     p = NULL;
5526
5527   free (func);
5528   free (args);
5529
5530   processing_spec_function--;
5531
5532   return p;
5533 }
5534
5535 /* Inline subroutine of handle_braces.  Returns true if the current
5536    input suffix matches the atom bracketed by ATOM and END_ATOM.  */
5537 static inline bool
5538 input_suffix_matches (const char *atom, const char *end_atom)
5539 {
5540   return (input_suffix
5541           && !strncmp (input_suffix, atom, end_atom - atom)
5542           && input_suffix[end_atom - atom] == '\0');
5543 }
5544
5545 /* Subroutine of handle_braces.  Returns true if the current
5546    input file's spec name matches the atom bracketed by ATOM and END_ATOM.  */
5547 static bool
5548 input_spec_matches (const char *atom, const char *end_atom)
5549 {
5550   return (input_file_compiler
5551           && input_file_compiler->suffix
5552           && input_file_compiler->suffix[0] != '\0'
5553           && !strncmp (input_file_compiler->suffix + 1, atom,
5554                        end_atom - atom)
5555           && input_file_compiler->suffix[end_atom - atom + 1] == '\0');
5556 }
5557
5558 /* Subroutine of handle_braces.  Returns true if a switch
5559    matching the atom bracketed by ATOM and END_ATOM appeared on the
5560    command line.  */
5561 static bool
5562 switch_matches (const char *atom, const char *end_atom, int starred)
5563 {
5564   int i;
5565   int len = end_atom - atom;
5566   int plen = starred ? len : -1;
5567
5568   for (i = 0; i < n_switches; i++)
5569     if (!strncmp (switches[i].part1, atom, len)
5570         && (starred || switches[i].part1[len] == '\0')
5571         && check_live_switch (i, plen))
5572       return true;
5573
5574     /* Check if a switch with separated form matching the atom.
5575        We check -D and -U switches. */
5576     else if (switches[i].args != 0)
5577       {
5578         if ((*switches[i].part1 == 'D' || *switches[i].part1 == 'U')
5579             && *switches[i].part1 == atom[0])
5580           {
5581             if (!strncmp (switches[i].args[0], &atom[1], len - 1)
5582                 && (starred || (switches[i].part1[1] == '\0'
5583                                 && switches[i].args[0][len - 1] == '\0'))
5584                 && check_live_switch (i, (starred ? 1 : -1)))
5585               return true;
5586           }
5587       }
5588
5589   return false;
5590 }
5591
5592 /* Inline subroutine of handle_braces.  Mark all of the switches which
5593    match ATOM (extends to END_ATOM; STARRED indicates whether there
5594    was a star after the atom) for later processing.  */
5595 static inline void
5596 mark_matching_switches (const char *atom, const char *end_atom, int starred)
5597 {
5598   int i;
5599   int len = end_atom - atom;
5600   int plen = starred ? len : -1;
5601
5602   for (i = 0; i < n_switches; i++)
5603     if (!strncmp (switches[i].part1, atom, len)
5604         && (starred || switches[i].part1[len] == '\0')
5605         && check_live_switch (i, plen))
5606       switches[i].ordering = 1;
5607 }
5608
5609 /* Inline subroutine of handle_braces.  Process all the currently
5610    marked switches through give_switch, and clear the marks.  */
5611 static inline void
5612 process_marked_switches (void)
5613 {
5614   int i;
5615
5616   for (i = 0; i < n_switches; i++)
5617     if (switches[i].ordering == 1)
5618       {
5619         switches[i].ordering = 0;
5620         give_switch (i, 0);
5621       }
5622 }
5623
5624 /* Handle a %{ ... } construct.  P points just inside the leading {.
5625    Returns a pointer one past the end of the brace block, or 0
5626    if we call do_spec_1 and that returns -1.  */
5627
5628 static const char *
5629 handle_braces (const char *p)
5630 {
5631   const char *atom, *end_atom;
5632   const char *d_atom = NULL, *d_end_atom = NULL;
5633   const char *orig = p;
5634
5635   bool a_is_suffix;
5636   bool a_is_spectype;
5637   bool a_is_starred;
5638   bool a_is_negated;
5639   bool a_matched;
5640
5641   bool a_must_be_last = false;
5642   bool ordered_set    = false;
5643   bool disjunct_set   = false;
5644   bool disj_matched   = false;
5645   bool disj_starred   = true;
5646   bool n_way_choice   = false;
5647   bool n_way_matched  = false;
5648
5649 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
5650
5651   do
5652     {
5653       if (a_must_be_last)
5654         goto invalid;
5655
5656       /* Scan one "atom" (S in the description above of %{}, possibly
5657          with '!', '.', '@', ',', or '*' modifiers).  */
5658       a_matched = false;
5659       a_is_suffix = false;
5660       a_is_starred = false;
5661       a_is_negated = false;
5662       a_is_spectype = false;
5663
5664       SKIP_WHITE();
5665       if (*p == '!')
5666         p++, a_is_negated = true;
5667
5668       SKIP_WHITE();
5669       if (*p == '.')
5670         p++, a_is_suffix = true;
5671       else if (*p == ',')
5672         p++, a_is_spectype = true;
5673
5674       atom = p;
5675       while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
5676              || *p == ',' || *p == '.' || *p == '@')
5677         p++;
5678       end_atom = p;
5679
5680       if (*p == '*')
5681         p++, a_is_starred = 1;
5682
5683       SKIP_WHITE();
5684       switch (*p)
5685         {
5686         case '&': case '}':
5687           /* Substitute the switch(es) indicated by the current atom.  */
5688           ordered_set = true;
5689           if (disjunct_set || n_way_choice || a_is_negated || a_is_suffix
5690               || a_is_spectype || atom == end_atom)
5691             goto invalid;
5692
5693           mark_matching_switches (atom, end_atom, a_is_starred);
5694
5695           if (*p == '}')
5696             process_marked_switches ();
5697           break;
5698
5699         case '|': case ':':
5700           /* Substitute some text if the current atom appears as a switch
5701              or suffix.  */
5702           disjunct_set = true;
5703           if (ordered_set)
5704             goto invalid;
5705
5706           if (atom == end_atom)
5707             {
5708               if (!n_way_choice || disj_matched || *p == '|'
5709                   || a_is_negated || a_is_suffix || a_is_spectype
5710                   || a_is_starred)
5711                 goto invalid;
5712
5713               /* An empty term may appear as the last choice of an
5714                  N-way choice set; it means "otherwise".  */
5715               a_must_be_last = true;
5716               disj_matched = !n_way_matched;
5717               disj_starred = false;
5718             }
5719           else
5720             {
5721               if ((a_is_suffix || a_is_spectype) && a_is_starred)
5722                 goto invalid;
5723
5724               if (!a_is_starred)
5725                 disj_starred = false;
5726
5727               /* Don't bother testing this atom if we already have a
5728                  match.  */
5729               if (!disj_matched && !n_way_matched)
5730                 {
5731                   if (a_is_suffix)
5732                     a_matched = input_suffix_matches (atom, end_atom);
5733                   else if (a_is_spectype)
5734                     a_matched = input_spec_matches (atom, end_atom);
5735                   else
5736                     a_matched = switch_matches (atom, end_atom, a_is_starred);
5737
5738                   if (a_matched != a_is_negated)
5739                     {
5740                       disj_matched = true;
5741                       d_atom = atom;
5742                       d_end_atom = end_atom;
5743                     }
5744                 }
5745             }
5746
5747           if (*p == ':')
5748             {
5749               /* Found the body, that is, the text to substitute if the
5750                  current disjunction matches.  */
5751               p = process_brace_body (p + 1, d_atom, d_end_atom, disj_starred,
5752                                       disj_matched && !n_way_matched);
5753               if (p == 0)
5754                 return 0;
5755
5756               /* If we have an N-way choice, reset state for the next
5757                  disjunction.  */
5758               if (*p == ';')
5759                 {
5760                   n_way_choice = true;
5761                   n_way_matched |= disj_matched;
5762                   disj_matched = false;
5763                   disj_starred = true;
5764                   d_atom = d_end_atom = NULL;
5765                 }
5766             }
5767           break;
5768
5769         default:
5770           goto invalid;
5771         }
5772     }
5773   while (*p++ != '}');
5774
5775   return p;
5776
5777  invalid:
5778   fatal_error ("braced spec %qs is invalid at %qc", orig, *p);
5779
5780 #undef SKIP_WHITE
5781 }
5782
5783 /* Subroutine of handle_braces.  Scan and process a brace substitution body
5784    (X in the description of %{} syntax).  P points one past the colon;
5785    ATOM and END_ATOM bracket the first atom which was found to be true
5786    (present) in the current disjunction; STARRED indicates whether all
5787    the atoms in the current disjunction were starred (for syntax validation);
5788    MATCHED indicates whether the disjunction matched or not, and therefore
5789    whether or not the body is to be processed through do_spec_1 or just
5790    skipped.  Returns a pointer to the closing } or ;, or 0 if do_spec_1
5791    returns -1.  */
5792
5793 static const char *
5794 process_brace_body (const char *p, const char *atom, const char *end_atom,
5795                     int starred, int matched)
5796 {
5797   const char *body, *end_body;
5798   unsigned int nesting_level;
5799   bool have_subst     = false;
5800
5801   /* Locate the closing } or ;, honoring nested braces.
5802      Trim trailing whitespace.  */
5803   body = p;
5804   nesting_level = 1;
5805   for (;;)
5806     {
5807       if (*p == '{')
5808         nesting_level++;
5809       else if (*p == '}')
5810         {
5811           if (!--nesting_level)
5812             break;
5813         }
5814       else if (*p == ';' && nesting_level == 1)
5815         break;
5816       else if (*p == '%' && p[1] == '*' && nesting_level == 1)
5817         have_subst = true;
5818       else if (*p == '\0')
5819         goto invalid;
5820       p++;
5821     }
5822
5823   end_body = p;
5824   while (end_body[-1] == ' ' || end_body[-1] == '\t')
5825     end_body--;
5826
5827   if (have_subst && !starred)
5828     goto invalid;
5829
5830   if (matched)
5831     {
5832       /* Copy the substitution body to permanent storage and execute it.
5833          If have_subst is false, this is a simple matter of running the
5834          body through do_spec_1...  */
5835       char *string = save_string (body, end_body - body);
5836       if (!have_subst)
5837         {
5838           if (do_spec_1 (string, 0, NULL) < 0)
5839             return 0;
5840         }
5841       else
5842         {
5843           /* ... but if have_subst is true, we have to process the
5844              body once for each matching switch, with %* set to the
5845              variant part of the switch.  */
5846           unsigned int hard_match_len = end_atom - atom;
5847           int i;
5848
5849           for (i = 0; i < n_switches; i++)
5850             if (!strncmp (switches[i].part1, atom, hard_match_len)
5851                 && check_live_switch (i, hard_match_len))
5852               {
5853                 if (do_spec_1 (string, 0,
5854                                &switches[i].part1[hard_match_len]) < 0)
5855                   return 0;
5856                 /* Pass any arguments this switch has.  */
5857                 give_switch (i, 1);
5858                 suffix_subst = NULL;
5859               }
5860         }
5861     }
5862
5863   return p;
5864
5865  invalid:
5866   fatal_error ("braced spec body %qs is invalid", body);
5867 }
5868 \f
5869 /* Return 0 iff switch number SWITCHNUM is obsoleted by a later switch
5870    on the command line.  PREFIX_LENGTH is the length of XXX in an {XXX*}
5871    spec, or -1 if either exact match or %* is used.
5872
5873    A -O switch is obsoleted by a later -O switch.  A -f, -g, -m, or -W switch
5874    whose value does not begin with "no-" is obsoleted by the same value
5875    with the "no-", similarly for a switch with the "no-" prefix.  */
5876
5877 static int
5878 check_live_switch (int switchnum, int prefix_length)
5879 {
5880   const char *name = switches[switchnum].part1;
5881   int i;
5882
5883   /* If we already processed this switch and determined if it was
5884      live or not, return our past determination.  */
5885   if (switches[switchnum].live_cond != 0)
5886     return ((switches[switchnum].live_cond & SWITCH_LIVE) != 0
5887             && (switches[switchnum].live_cond & SWITCH_FALSE) == 0
5888             && (switches[switchnum].live_cond & SWITCH_IGNORE_PERMANENTLY)
5889                == 0);
5890
5891   /* In the common case of {<at-most-one-letter>*}, a negating
5892      switch would always match, so ignore that case.  We will just
5893      send the conflicting switches to the compiler phase.  */
5894   if (prefix_length >= 0 && prefix_length <= 1)
5895     return 1;
5896
5897   /* Now search for duplicate in a manner that depends on the name.  */
5898   switch (*name)
5899     {
5900     case 'O':
5901       for (i = switchnum + 1; i < n_switches; i++)
5902         if (switches[i].part1[0] == 'O')
5903           {
5904             switches[switchnum].validated = true;
5905             switches[switchnum].live_cond = SWITCH_FALSE;
5906             return 0;
5907           }
5908       break;
5909
5910     case 'W':  case 'f':  case 'm': case 'g':
5911       if (! strncmp (name + 1, "no-", 3))
5912         {
5913           /* We have Xno-YYY, search for XYYY.  */
5914           for (i = switchnum + 1; i < n_switches; i++)
5915             if (switches[i].part1[0] == name[0]
5916                 && ! strcmp (&switches[i].part1[1], &name[4]))
5917               {
5918                 /* --specs are validated with the validate_switches mechanism.  */
5919                 if (switches[switchnum].known)
5920                   switches[switchnum].validated = true;
5921                 switches[switchnum].live_cond = SWITCH_FALSE;
5922                 return 0;
5923               }
5924         }
5925       else
5926         {
5927           /* We have XYYY, search for Xno-YYY.  */
5928           for (i = switchnum + 1; i < n_switches; i++)
5929             if (switches[i].part1[0] == name[0]
5930                 && switches[i].part1[1] == 'n'
5931                 && switches[i].part1[2] == 'o'
5932                 && switches[i].part1[3] == '-'
5933                 && !strcmp (&switches[i].part1[4], &name[1]))
5934               {
5935                 /* --specs are validated with the validate_switches mechanism.  */
5936                 if (switches[switchnum].known)
5937                   switches[switchnum].validated = true;
5938                 switches[switchnum].live_cond = SWITCH_FALSE;
5939                 return 0;
5940               }
5941         }
5942       break;
5943     }
5944
5945   /* Otherwise the switch is live.  */
5946   switches[switchnum].live_cond |= SWITCH_LIVE;
5947   return 1;
5948 }
5949 \f
5950 /* Pass a switch to the current accumulating command
5951    in the same form that we received it.
5952    SWITCHNUM identifies the switch; it is an index into
5953    the vector of switches gcc received, which is `switches'.
5954    This cannot fail since it never finishes a command line.
5955
5956    If OMIT_FIRST_WORD is nonzero, then we omit .part1 of the argument.  */
5957
5958 static void
5959 give_switch (int switchnum, int omit_first_word)
5960 {
5961   if ((switches[switchnum].live_cond & SWITCH_IGNORE) != 0)
5962     return;
5963
5964   if (!omit_first_word)
5965     {
5966       do_spec_1 ("-", 0, NULL);
5967       do_spec_1 (switches[switchnum].part1, 1, NULL);
5968     }
5969
5970   if (switches[switchnum].args != 0)
5971     {
5972       const char **p;
5973       for (p = switches[switchnum].args; *p; p++)
5974         {
5975           const char *arg = *p;
5976
5977           do_spec_1 (" ", 0, NULL);
5978           if (suffix_subst)
5979             {
5980               unsigned length = strlen (arg);
5981               int dot = 0;
5982
5983               while (length-- && !IS_DIR_SEPARATOR (arg[length]))
5984                 if (arg[length] == '.')
5985                   {
5986                     (CONST_CAST(char *, arg))[length] = 0;
5987                     dot = 1;
5988                     break;
5989                   }
5990               do_spec_1 (arg, 1, NULL);
5991               if (dot)
5992                 (CONST_CAST(char *, arg))[length] = '.';
5993               do_spec_1 (suffix_subst, 1, NULL);
5994             }
5995           else
5996             do_spec_1 (arg, 1, NULL);
5997         }
5998     }
5999
6000   do_spec_1 (" ", 0, NULL);
6001   switches[switchnum].validated = true;
6002 }
6003 \f
6004 /* Search for a file named NAME trying various prefixes including the
6005    user's -B prefix and some standard ones.
6006    Return the absolute file name found.  If nothing is found, return NAME.  */
6007
6008 static const char *
6009 find_file (const char *name)
6010 {
6011   char *newname = find_a_file (&startfile_prefixes, name, R_OK, true);
6012   return newname ? newname : name;
6013 }
6014
6015 /* Determine whether a directory exists.  If LINKER, return 0 for
6016    certain fixed names not needed by the linker.  */
6017
6018 static int
6019 is_directory (const char *path1, bool linker)
6020 {
6021   int len1;
6022   char *path;
6023   char *cp;
6024   struct stat st;
6025
6026   /* Ensure the string ends with "/.".  The resulting path will be a
6027      directory even if the given path is a symbolic link.  */
6028   len1 = strlen (path1);
6029   path = (char *) alloca (3 + len1);
6030   memcpy (path, path1, len1);
6031   cp = path + len1;
6032   if (!IS_DIR_SEPARATOR (cp[-1]))
6033     *cp++ = DIR_SEPARATOR;
6034   *cp++ = '.';
6035   *cp = '\0';
6036
6037   /* Exclude directories that the linker is known to search.  */
6038   if (linker
6039       && IS_DIR_SEPARATOR (path[0])
6040       && ((cp - path == 6
6041            && filename_ncmp (path + 1, "lib", 3) == 0)
6042           || (cp - path == 10
6043               && filename_ncmp (path + 1, "usr", 3) == 0
6044               && IS_DIR_SEPARATOR (path[4])
6045               && filename_ncmp (path + 5, "lib", 3) == 0)))
6046     return 0;
6047
6048   return (stat (path, &st) >= 0 && S_ISDIR (st.st_mode));
6049 }
6050
6051 /* Set up the various global variables to indicate that we're processing
6052    the input file named FILENAME.  */
6053
6054 void
6055 set_input (const char *filename)
6056 {
6057   const char *p;
6058
6059   gcc_input_filename = filename;
6060   input_filename_length = strlen (gcc_input_filename);
6061   input_basename = lbasename (gcc_input_filename);
6062
6063   /* Find a suffix starting with the last period,
6064      and set basename_length to exclude that suffix.  */
6065   basename_length = strlen (input_basename);
6066   suffixed_basename_length = basename_length;
6067   p = input_basename + basename_length;
6068   while (p != input_basename && *p != '.')
6069     --p;
6070   if (*p == '.' && p != input_basename)
6071     {
6072       basename_length = p - input_basename;
6073       input_suffix = p + 1;
6074     }
6075   else
6076     input_suffix = "";
6077
6078   /* If a spec for 'g', 'u', or 'U' is seen with -save-temps then
6079      we will need to do a stat on the gcc_input_filename.  The
6080      INPUT_STAT_SET signals that the stat is needed.  */
6081   input_stat_set = 0;
6082 }
6083 \f
6084 /* On fatal signals, delete all the temporary files.  */
6085
6086 static void
6087 fatal_signal (int signum)
6088 {
6089   signal (signum, SIG_DFL);
6090   delete_failure_queue ();
6091   delete_temp_files ();
6092   /* Get the same signal again, this time not handled,
6093      so its normal effect occurs.  */
6094   kill (getpid (), signum);
6095 }
6096
6097 /* Compare the contents of the two files named CMPFILE[0] and
6098    CMPFILE[1].  Return zero if they're identical, nonzero
6099    otherwise.  */
6100
6101 static int
6102 compare_files (char *cmpfile[])
6103 {
6104   int ret = 0;
6105   FILE *temp[2] = { NULL, NULL };
6106   int i;
6107
6108 #if HAVE_MMAP_FILE
6109   {
6110     size_t length[2];
6111     void *map[2] = { NULL, NULL };
6112
6113     for (i = 0; i < 2; i++)
6114       {
6115         struct stat st;
6116
6117         if (stat (cmpfile[i], &st) < 0 || !S_ISREG (st.st_mode))
6118           {
6119             error ("%s: could not determine length of compare-debug file %s",
6120                    gcc_input_filename, cmpfile[i]);
6121             ret = 1;
6122             break;
6123           }
6124
6125         length[i] = st.st_size;
6126       }
6127
6128     if (!ret && length[0] != length[1])
6129       {
6130         error ("%s: -fcompare-debug failure (length)", gcc_input_filename);
6131         ret = 1;
6132       }
6133
6134     if (!ret)
6135       for (i = 0; i < 2; i++)
6136         {
6137           int fd = open (cmpfile[i], O_RDONLY);
6138           if (fd < 0)
6139             {
6140               error ("%s: could not open compare-debug file %s",
6141                      gcc_input_filename, cmpfile[i]);
6142               ret = 1;
6143               break;
6144             }
6145
6146           map[i] = mmap (NULL, length[i], PROT_READ, MAP_PRIVATE, fd, 0);
6147           close (fd);
6148
6149           if (map[i] == (void *) MAP_FAILED)
6150             {
6151               ret = -1;
6152               break;
6153             }
6154         }
6155
6156     if (!ret)
6157       {
6158         if (memcmp (map[0], map[1], length[0]) != 0)
6159           {
6160             error ("%s: -fcompare-debug failure", gcc_input_filename);
6161             ret = 1;
6162           }
6163       }
6164
6165     for (i = 0; i < 2; i++)
6166       if (map[i])
6167         munmap ((caddr_t) map[i], length[i]);
6168
6169     if (ret >= 0)
6170       return ret;
6171
6172     ret = 0;
6173   }
6174 #endif
6175
6176   for (i = 0; i < 2; i++)
6177     {
6178       temp[i] = fopen (cmpfile[i], "r");
6179       if (!temp[i])
6180         {
6181           error ("%s: could not open compare-debug file %s",
6182                  gcc_input_filename, cmpfile[i]);
6183           ret = 1;
6184           break;
6185         }
6186     }
6187
6188   if (!ret && temp[0] && temp[1])
6189     for (;;)
6190       {
6191         int c0, c1;
6192         c0 = fgetc (temp[0]);
6193         c1 = fgetc (temp[1]);
6194
6195         if (c0 != c1)
6196           {
6197             error ("%s: -fcompare-debug failure",
6198                    gcc_input_filename);
6199             ret = 1;
6200             break;
6201           }
6202
6203         if (c0 == EOF)
6204           break;
6205       }
6206
6207   for (i = 1; i >= 0; i--)
6208     {
6209       if (temp[i])
6210         fclose (temp[i]);
6211     }
6212
6213   return ret;
6214 }
6215
6216 extern int main (int, char **);
6217
6218 int
6219 main (int argc, char **argv)
6220 {
6221   size_t i;
6222   int value;
6223   int linker_was_run = 0;
6224   int lang_n_infiles = 0;
6225   int num_linker_inputs = 0;
6226   char *explicit_link_files;
6227   char *specs_file;
6228   char *lto_wrapper_file;
6229   const char *p;
6230   struct user_specs *uptr;
6231   char **old_argv = argv;
6232   struct cl_decoded_option *decoded_options;
6233   unsigned int decoded_options_count;
6234
6235   p = argv[0] + strlen (argv[0]);
6236   while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
6237     --p;
6238   progname = p;
6239
6240   xmalloc_set_program_name (progname);
6241
6242   expandargv (&argc, &argv);
6243
6244   /* Determine if any expansions were made.  */
6245   if (argv != old_argv)
6246     at_file_supplied = true;
6247
6248   /* Register the language-independent parameters.  */
6249   global_init_params ();
6250   finish_params ();
6251
6252   init_options_struct (&global_options, &global_options_set);
6253
6254   decode_cmdline_options_to_array (argc, CONST_CAST2 (const char **, char **,
6255                                                       argv),
6256                                    CL_DRIVER,
6257                                    &decoded_options, &decoded_options_count);
6258
6259   /* Unlock the stdio streams.  */
6260   unlock_std_streams ();
6261
6262   gcc_init_libintl ();
6263
6264   diagnostic_initialize (global_dc, 0);
6265
6266 #ifdef GCC_DRIVER_HOST_INITIALIZATION
6267   /* Perform host dependent initialization when needed.  */
6268   GCC_DRIVER_HOST_INITIALIZATION;
6269 #endif
6270
6271   if (atexit (delete_temp_files) != 0)
6272     fatal_error ("atexit failed");
6273
6274   if (signal (SIGINT, SIG_IGN) != SIG_IGN)
6275     signal (SIGINT, fatal_signal);
6276 #ifdef SIGHUP
6277   if (signal (SIGHUP, SIG_IGN) != SIG_IGN)
6278     signal (SIGHUP, fatal_signal);
6279 #endif
6280   if (signal (SIGTERM, SIG_IGN) != SIG_IGN)
6281     signal (SIGTERM, fatal_signal);
6282 #ifdef SIGPIPE
6283   if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
6284     signal (SIGPIPE, fatal_signal);
6285 #endif
6286 #ifdef SIGCHLD
6287   /* We *MUST* set SIGCHLD to SIG_DFL so that the wait4() call will
6288      receive the signal.  A different setting is inheritable */
6289   signal (SIGCHLD, SIG_DFL);
6290 #endif
6291
6292   /* Parsing and gimplification sometimes need quite large stack.
6293      Increase stack size limits if possible.  */
6294   stack_limit_increase (64 * 1024 * 1024);
6295
6296   /* Allocate the argument vector.  */
6297   alloc_args ();
6298
6299   obstack_init (&obstack);
6300
6301   /* Build multilib_select, et. al from the separate lines that make up each
6302      multilib selection.  */
6303   {
6304     const char *const *q = multilib_raw;
6305     int need_space;
6306
6307     obstack_init (&multilib_obstack);
6308     while ((p = *q++) != (char *) 0)
6309       obstack_grow (&multilib_obstack, p, strlen (p));
6310
6311     obstack_1grow (&multilib_obstack, 0);
6312     multilib_select = XOBFINISH (&multilib_obstack, const char *);
6313
6314     q = multilib_matches_raw;
6315     while ((p = *q++) != (char *) 0)
6316       obstack_grow (&multilib_obstack, p, strlen (p));
6317
6318     obstack_1grow (&multilib_obstack, 0);
6319     multilib_matches = XOBFINISH (&multilib_obstack, const char *);
6320
6321     q = multilib_exclusions_raw;
6322     while ((p = *q++) != (char *) 0)
6323       obstack_grow (&multilib_obstack, p, strlen (p));
6324
6325     obstack_1grow (&multilib_obstack, 0);
6326     multilib_exclusions = XOBFINISH (&multilib_obstack, const char *);
6327
6328     need_space = FALSE;
6329     for (i = 0; i < ARRAY_SIZE (multilib_defaults_raw); i++)
6330       {
6331         if (need_space)
6332           obstack_1grow (&multilib_obstack, ' ');
6333         obstack_grow (&multilib_obstack,
6334                       multilib_defaults_raw[i],
6335                       strlen (multilib_defaults_raw[i]));
6336         need_space = TRUE;
6337       }
6338
6339     obstack_1grow (&multilib_obstack, 0);
6340     multilib_defaults = XOBFINISH (&multilib_obstack, const char *);
6341   }
6342
6343 #ifdef INIT_ENVIRONMENT
6344   /* Set up any other necessary machine specific environment variables.  */
6345   xputenv (INIT_ENVIRONMENT);
6346 #endif
6347
6348   /* Make a table of what switches there are (switches, n_switches).
6349      Make a table of specified input files (infiles, n_infiles).
6350      Decode switches that are handled locally.  */
6351
6352   process_command (decoded_options_count, decoded_options);
6353
6354   /* Initialize the vector of specs to just the default.
6355      This means one element containing 0s, as a terminator.  */
6356
6357   compilers = XNEWVAR (struct compiler, sizeof default_compilers);
6358   memcpy (compilers, default_compilers, sizeof default_compilers);
6359   n_compilers = n_default_compilers;
6360
6361   /* Read specs from a file if there is one.  */
6362
6363   machine_suffix = concat (spec_machine, dir_separator_str,
6364                            spec_version, dir_separator_str, NULL);
6365   just_machine_suffix = concat (spec_machine, dir_separator_str, NULL);
6366
6367   specs_file = find_a_file (&startfile_prefixes, "specs", R_OK, true);
6368   /* Read the specs file unless it is a default one.  */
6369   if (specs_file != 0 && strcmp (specs_file, "specs"))
6370     read_specs (specs_file, true, false);
6371   else
6372     init_spec ();
6373
6374   /* We need to check standard_exec_prefix/just_machine_suffix/specs
6375      for any override of as, ld and libraries.  */
6376   specs_file = (char *) alloca (strlen (standard_exec_prefix)
6377                        + strlen (just_machine_suffix) + sizeof ("specs"));
6378
6379   strcpy (specs_file, standard_exec_prefix);
6380   strcat (specs_file, just_machine_suffix);
6381   strcat (specs_file, "specs");
6382   if (access (specs_file, R_OK) == 0)
6383     read_specs (specs_file, true, false);
6384
6385   /* Process any configure-time defaults specified for the command line
6386      options, via OPTION_DEFAULT_SPECS.  */
6387   for (i = 0; i < ARRAY_SIZE (option_default_specs); i++)
6388     do_option_spec (option_default_specs[i].name,
6389                     option_default_specs[i].spec);
6390
6391   /* Process DRIVER_SELF_SPECS, adding any new options to the end
6392      of the command line.  */
6393
6394   for (i = 0; i < ARRAY_SIZE (driver_self_specs); i++)
6395     do_self_spec (driver_self_specs[i]);
6396
6397   /* If not cross-compiling, look for executables in the standard
6398      places.  */
6399   if (*cross_compile == '0')
6400     {
6401       if (*md_exec_prefix)
6402         {
6403           add_prefix (&exec_prefixes, md_exec_prefix, "GCC",
6404                       PREFIX_PRIORITY_LAST, 0, 0);
6405         }
6406     }
6407
6408   /* Process sysroot_suffix_spec.  */
6409   if (*sysroot_suffix_spec != 0
6410       && !no_sysroot_suffix
6411       && do_spec_2 (sysroot_suffix_spec) == 0)
6412     {
6413       if (argbuf.length () > 1)
6414         error ("spec failure: more than one arg to SYSROOT_SUFFIX_SPEC");
6415       else if (argbuf.length () == 1)
6416         target_sysroot_suffix = xstrdup (argbuf.last ());
6417     }
6418
6419 #ifdef HAVE_LD_SYSROOT
6420   /* Pass the --sysroot option to the linker, if it supports that.  If
6421      there is a sysroot_suffix_spec, it has already been processed by
6422      this point, so target_system_root really is the system root we
6423      should be using.  */
6424   if (target_system_root)
6425     {
6426       obstack_grow (&obstack, "%(sysroot_spec) ", strlen ("%(sysroot_spec) "));
6427       obstack_grow0 (&obstack, link_spec, strlen (link_spec));
6428       set_spec ("link", XOBFINISH (&obstack, const char *), false);
6429     }
6430 #endif
6431
6432   /* Process sysroot_hdrs_suffix_spec.  */
6433   if (*sysroot_hdrs_suffix_spec != 0
6434       && !no_sysroot_suffix
6435       && do_spec_2 (sysroot_hdrs_suffix_spec) == 0)
6436     {
6437       if (argbuf.length () > 1)
6438         error ("spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC");
6439       else if (argbuf.length () == 1)
6440         target_sysroot_hdrs_suffix = xstrdup (argbuf.last ());
6441     }
6442
6443   /* Look for startfiles in the standard places.  */
6444   if (*startfile_prefix_spec != 0
6445       && do_spec_2 (startfile_prefix_spec) == 0
6446       && do_spec_1 (" ", 0, NULL) == 0)
6447     {
6448       const char *arg;
6449       int ndx;
6450       FOR_EACH_VEC_ELT (argbuf, ndx, arg)
6451         add_sysrooted_prefix (&startfile_prefixes, arg, "BINUTILS",
6452                               PREFIX_PRIORITY_LAST, 0, 1);
6453     }
6454   /* We should eventually get rid of all these and stick to
6455      startfile_prefix_spec exclusively.  */
6456   else if (*cross_compile == '0' || target_system_root)
6457     {
6458       if (*md_startfile_prefix)
6459         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix,
6460                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6461
6462       if (*md_startfile_prefix_1)
6463         add_sysrooted_prefix (&startfile_prefixes, md_startfile_prefix_1,
6464                               "GCC", PREFIX_PRIORITY_LAST, 0, 1);
6465
6466       /* If standard_startfile_prefix is relative, base it on
6467          standard_exec_prefix.  This lets us move the installed tree
6468          as a unit.  If GCC_EXEC_PREFIX is defined, base
6469          standard_startfile_prefix on that as well.
6470
6471          If the prefix is relative, only search it for native compilers;
6472          otherwise we will search a directory containing host libraries.  */
6473       if (IS_ABSOLUTE_PATH (standard_startfile_prefix))
6474         add_sysrooted_prefix (&startfile_prefixes,
6475                               standard_startfile_prefix, "BINUTILS",
6476                               PREFIX_PRIORITY_LAST, 0, 1);
6477       else if (*cross_compile == '0')
6478         {
6479           add_prefix (&startfile_prefixes,
6480                       concat (gcc_exec_prefix
6481                               ? gcc_exec_prefix : standard_exec_prefix,
6482                               machine_suffix,
6483                               standard_startfile_prefix, NULL),
6484                       NULL, PREFIX_PRIORITY_LAST, 0, 1);
6485         }
6486
6487       /* Sysrooted prefixes are relocated because target_system_root is
6488          also relocated by gcc_exec_prefix.  */
6489       if (*standard_startfile_prefix_1)
6490         add_sysrooted_prefix (&startfile_prefixes,
6491                               standard_startfile_prefix_1, "BINUTILS",
6492                               PREFIX_PRIORITY_LAST, 0, 1);
6493       if (*standard_startfile_prefix_2)
6494         add_sysrooted_prefix (&startfile_prefixes,
6495                               standard_startfile_prefix_2, "BINUTILS",
6496                               PREFIX_PRIORITY_LAST, 0, 1);
6497     }
6498
6499   /* Process any user specified specs in the order given on the command
6500      line.  */
6501   for (uptr = user_specs_head; uptr; uptr = uptr->next)
6502     {
6503       char *filename = find_a_file (&startfile_prefixes, uptr->filename,
6504                                     R_OK, true);
6505       read_specs (filename ? filename : uptr->filename, false, true);
6506     }
6507
6508   /* Process any user self specs.  */
6509   {
6510     struct spec_list *sl;
6511     for (sl = specs; sl; sl = sl->next)
6512       if (sl->name_len == sizeof "self_spec" - 1
6513           && !strcmp (sl->name, "self_spec"))
6514         do_self_spec (*sl->ptr_spec);
6515   }
6516
6517   if (compare_debug)
6518     {
6519       enum save_temps save;
6520
6521       if (!compare_debug_second)
6522         {
6523           n_switches_debug_check[1] = n_switches;
6524           n_switches_alloc_debug_check[1] = n_switches_alloc;
6525           switches_debug_check[1] = XDUPVEC (struct switchstr, switches,
6526                                              n_switches_alloc);
6527
6528           do_self_spec ("%:compare-debug-self-opt()");
6529           n_switches_debug_check[0] = n_switches;
6530           n_switches_alloc_debug_check[0] = n_switches_alloc;
6531           switches_debug_check[0] = switches;
6532
6533           n_switches = n_switches_debug_check[1];
6534           n_switches_alloc = n_switches_alloc_debug_check[1];
6535           switches = switches_debug_check[1];
6536         }
6537
6538       /* Avoid crash when computing %j in this early.  */
6539       save = save_temps_flag;
6540       save_temps_flag = SAVE_TEMPS_NONE;
6541
6542       compare_debug = -compare_debug;
6543       do_self_spec ("%:compare-debug-self-opt()");
6544
6545       save_temps_flag = save;
6546
6547       if (!compare_debug_second)
6548         {
6549           n_switches_debug_check[1] = n_switches;
6550           n_switches_alloc_debug_check[1] = n_switches_alloc;
6551           switches_debug_check[1] = switches;
6552           compare_debug = -compare_debug;
6553           n_switches = n_switches_debug_check[0];
6554           n_switches_alloc = n_switches_debug_check[0];
6555           switches = switches_debug_check[0];
6556         }
6557     }
6558
6559
6560   /* If we have a GCC_EXEC_PREFIX envvar, modify it for cpp's sake.  */
6561   if (gcc_exec_prefix)
6562     gcc_exec_prefix = concat (gcc_exec_prefix, spec_machine, dir_separator_str,
6563                               spec_version, dir_separator_str, NULL);
6564
6565   /* Now we have the specs.
6566      Set the `valid' bits for switches that match anything in any spec.  */
6567
6568   validate_all_switches ();
6569
6570   /* Now that we have the switches and the specs, set
6571      the subdirectory based on the options.  */
6572   set_multilib_dir ();
6573
6574   /* Set up to remember the pathname of gcc and any options
6575      needed for collect.  We use argv[0] instead of progname because
6576      we need the complete pathname.  */
6577   obstack_init (&collect_obstack);
6578   obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=") - 1);
6579   obstack_grow (&collect_obstack, argv[0], strlen (argv[0]) + 1);
6580   xputenv (XOBFINISH (&collect_obstack, char *));
6581
6582   /* Set up to remember the pathname of the lto wrapper. */
6583
6584   if (have_c)
6585     lto_wrapper_file = NULL;
6586   else
6587     lto_wrapper_file = find_a_file (&exec_prefixes, "lto-wrapper",
6588                                     X_OK, false);
6589   if (lto_wrapper_file)
6590     {
6591       lto_wrapper_spec = lto_wrapper_file;
6592       obstack_init (&collect_obstack);
6593       obstack_grow (&collect_obstack, "COLLECT_LTO_WRAPPER=",
6594                     sizeof ("COLLECT_LTO_WRAPPER=") - 1);
6595       obstack_grow (&collect_obstack, lto_wrapper_spec,
6596                     strlen (lto_wrapper_spec) + 1);
6597       xputenv (XOBFINISH (&collect_obstack, char *));
6598     }
6599
6600   /* Reject switches that no pass was interested in.  */
6601
6602   for (i = 0; (int) i < n_switches; i++)
6603     if (! switches[i].validated)
6604       error ("unrecognized command line option %<-%s%>", switches[i].part1);
6605
6606   /* Obey some of the options.  */
6607
6608   if (print_search_dirs)
6609     {
6610       printf (_("install: %s%s\n"),
6611               gcc_exec_prefix ? gcc_exec_prefix : standard_exec_prefix,
6612               gcc_exec_prefix ? "" : machine_suffix);
6613       printf (_("programs: %s\n"),
6614               build_search_list (&exec_prefixes, "", false, false));
6615       printf (_("libraries: %s\n"),
6616               build_search_list (&startfile_prefixes, "", false, true));
6617       return (0);
6618     }
6619
6620   if (print_file_name)
6621     {
6622       printf ("%s\n", find_file (print_file_name));
6623       return (0);
6624     }
6625
6626   if (print_prog_name)
6627     {
6628       char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK, 0);
6629       printf ("%s\n", (newname ? newname : print_prog_name));
6630       return (0);
6631     }
6632
6633   if (print_multi_lib)
6634     {
6635       print_multilib_info ();
6636       return (0);
6637     }
6638
6639   if (print_multi_directory)
6640     {
6641       if (multilib_dir == NULL)
6642         printf (".\n");
6643       else
6644         printf ("%s\n", multilib_dir);
6645       return (0);
6646     }
6647
6648   if (print_multiarch)
6649     {
6650       if (multiarch_dir == NULL)
6651         printf ("\n");
6652       else
6653         printf ("%s\n", multiarch_dir);
6654       return (0);
6655     }
6656
6657   if (print_sysroot)
6658     {
6659       if (target_system_root)
6660         {
6661           if (target_sysroot_suffix)
6662             printf ("%s%s\n", target_system_root, target_sysroot_suffix);
6663           else
6664             printf ("%s\n", target_system_root);
6665         }
6666       return (0);
6667     }
6668
6669   if (print_multi_os_directory)
6670     {
6671       if (multilib_os_dir == NULL)
6672         printf (".\n");
6673       else
6674         printf ("%s\n", multilib_os_dir);
6675       return (0);
6676     }
6677
6678   if (print_sysroot_headers_suffix)
6679     {
6680       if (*sysroot_hdrs_suffix_spec)
6681         {
6682           printf("%s\n", (target_sysroot_hdrs_suffix
6683                           ? target_sysroot_hdrs_suffix
6684                           : ""));
6685           return (0);
6686         }
6687       else
6688         /* The error status indicates that only one set of fixed
6689            headers should be built.  */
6690         fatal_error ("not configured with sysroot headers suffix");
6691     }
6692
6693   if (print_help_list)
6694     {
6695       display_help ();
6696
6697       if (! verbose_flag)
6698         {
6699           printf (_("\nFor bug reporting instructions, please see:\n"));
6700           printf ("%s.\n", bug_report_url);
6701
6702           return (0);
6703         }
6704
6705       /* We do not exit here.  Instead we have created a fake input file
6706          called 'help-dummy' which needs to be compiled, and we pass this
6707          on the various sub-processes, along with the --help switch.
6708          Ensure their output appears after ours.  */
6709       fputc ('\n', stdout);
6710       fflush (stdout);
6711     }
6712
6713   if (print_version)
6714     {
6715       printf (_("%s %s%s\n"), progname, pkgversion_string,
6716               version_string);
6717       printf ("Copyright %s 2012 Free Software Foundation, Inc.\n",
6718               _("(C)"));
6719       fputs (_("This is free software; see the source for copying conditions.  There is NO\n\
6720 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"),
6721              stdout);
6722       if (! verbose_flag)
6723         return 0;
6724
6725       /* We do not exit here. We use the same mechanism of --help to print
6726          the version of the sub-processes. */
6727       fputc ('\n', stdout);
6728       fflush (stdout);
6729     }
6730
6731   if (verbose_flag)
6732     {
6733       int n;
6734       const char *thrmod;
6735
6736       fnotice (stderr, "Target: %s\n", spec_machine);
6737       fnotice (stderr, "Configured with: %s\n", configuration_arguments);
6738
6739 #ifdef THREAD_MODEL_SPEC
6740       /* We could have defined THREAD_MODEL_SPEC to "%*" by default,
6741          but there's no point in doing all this processing just to get
6742          thread_model back.  */
6743       obstack_init (&obstack);
6744       do_spec_1 (THREAD_MODEL_SPEC, 0, thread_model);
6745       obstack_1grow (&obstack, '\0');
6746       thrmod = XOBFINISH (&obstack, const char *);
6747 #else
6748       thrmod = thread_model;
6749 #endif
6750
6751       fnotice (stderr, "Thread model: %s\n", thrmod);
6752
6753       /* compiler_version is truncated at the first space when initialized
6754          from version string, so truncate version_string at the first space
6755          before comparing.  */
6756       for (n = 0; version_string[n]; n++)
6757         if (version_string[n] == ' ')
6758           break;
6759
6760       if (! strncmp (version_string, compiler_version, n)
6761           && compiler_version[n] == 0)
6762         fnotice (stderr, "gcc version %s %s\n", version_string,
6763                  pkgversion_string);
6764       else
6765         fnotice (stderr, "gcc driver version %s %sexecuting gcc version %s\n",
6766                  version_string, pkgversion_string, compiler_version);
6767
6768       if (n_infiles == 0)
6769         return (0);
6770     }
6771
6772   if (n_infiles == added_libraries)
6773     fatal_error ("no input files");
6774
6775   if (seen_error ())
6776     goto out;
6777
6778   /* Make a place to record the compiler output file names
6779      that correspond to the input files.  */
6780
6781   i = n_infiles;
6782   i += lang_specific_extra_outfiles;
6783   outfiles = XCNEWVEC (const char *, i);
6784
6785   /* Record which files were specified explicitly as link input.  */
6786
6787   explicit_link_files = XCNEWVEC (char, n_infiles);
6788
6789   combine_inputs = have_o || flag_wpa;
6790
6791   for (i = 0; (int) i < n_infiles; i++)
6792     {
6793       const char *name = infiles[i].name;
6794       struct compiler *compiler = lookup_compiler (name,
6795                                                    strlen (name),
6796                                                    infiles[i].language);
6797
6798       if (compiler && !(compiler->combinable))
6799         combine_inputs = false;
6800
6801       if (lang_n_infiles > 0 && compiler != input_file_compiler
6802           && infiles[i].language && infiles[i].language[0] != '*')
6803         infiles[i].incompiler = compiler;
6804       else if (compiler)
6805         {
6806           lang_n_infiles++;
6807           input_file_compiler = compiler;
6808           infiles[i].incompiler = compiler;
6809         }
6810       else
6811         {
6812           /* Since there is no compiler for this input file, assume it is a
6813              linker file.  */
6814           explicit_link_files[i] = 1;
6815           infiles[i].incompiler = NULL;
6816         }
6817       infiles[i].compiled = false;
6818       infiles[i].preprocessed = false;
6819     }
6820
6821   if (!combine_inputs && have_c && have_o && lang_n_infiles > 1)
6822     fatal_error ("cannot specify -o with -c, -S or -E with multiple files");
6823
6824   for (i = 0; (int) i < n_infiles; i++)
6825     {
6826       int this_file_error = 0;
6827
6828       /* Tell do_spec what to substitute for %i.  */
6829
6830       input_file_number = i;
6831       set_input (infiles[i].name);
6832
6833       if (infiles[i].compiled)
6834         continue;
6835
6836       /* Use the same thing in %o, unless cp->spec says otherwise.  */
6837
6838       outfiles[i] = gcc_input_filename;
6839
6840       /* Figure out which compiler from the file's suffix.  */
6841
6842       input_file_compiler
6843         = lookup_compiler (infiles[i].name, input_filename_length,
6844                            infiles[i].language);
6845
6846       if (input_file_compiler)
6847         {
6848           /* Ok, we found an applicable compiler.  Run its spec.  */
6849
6850           if (input_file_compiler->spec[0] == '#')
6851             {
6852               error ("%s: %s compiler not installed on this system",
6853                      gcc_input_filename, &input_file_compiler->spec[1]);
6854               this_file_error = 1;
6855             }
6856           else
6857             {
6858               if (compare_debug)
6859                 {
6860                   free (debug_check_temp_file[0]);
6861                   debug_check_temp_file[0] = NULL;
6862
6863                   free (debug_check_temp_file[1]);
6864                   debug_check_temp_file[1] = NULL;
6865                 }
6866
6867               value = do_spec (input_file_compiler->spec);
6868               infiles[i].compiled = true;
6869               if (value < 0)
6870                 this_file_error = 1;
6871               else if (compare_debug && debug_check_temp_file[0])
6872                 {
6873                   if (verbose_flag)
6874                     inform (0, "recompiling with -fcompare-debug");
6875
6876                   compare_debug = -compare_debug;
6877                   n_switches = n_switches_debug_check[1];
6878                   n_switches_alloc = n_switches_alloc_debug_check[1];
6879                   switches = switches_debug_check[1];
6880
6881                   value = do_spec (input_file_compiler->spec);
6882
6883                   compare_debug = -compare_debug;
6884                   n_switches = n_switches_debug_check[0];
6885                   n_switches_alloc = n_switches_alloc_debug_check[0];
6886                   switches = switches_debug_check[0];
6887
6888                   if (value < 0)
6889                     {
6890                       error ("during -fcompare-debug recompilation");
6891                       this_file_error = 1;
6892                     }
6893
6894                   gcc_assert (debug_check_temp_file[1]
6895                               && filename_cmp (debug_check_temp_file[0],
6896                                                debug_check_temp_file[1]));
6897
6898                   if (verbose_flag)
6899                     inform (0, "comparing final insns dumps");
6900
6901                   if (compare_files (debug_check_temp_file))
6902                     this_file_error = 1;
6903                 }
6904
6905               if (compare_debug)
6906                 {
6907                   free (debug_check_temp_file[0]);
6908                   debug_check_temp_file[0] = NULL;
6909
6910                   free (debug_check_temp_file[1]);
6911                   debug_check_temp_file[1] = NULL;
6912                 }
6913             }
6914         }
6915
6916       /* If this file's name does not contain a recognized suffix,
6917          record it as explicit linker input.  */
6918
6919       else
6920         explicit_link_files[i] = 1;
6921
6922       /* Clear the delete-on-failure queue, deleting the files in it
6923          if this compilation failed.  */
6924
6925       if (this_file_error)
6926         {
6927           delete_failure_queue ();
6928           errorcount++;
6929         }
6930       /* If this compilation succeeded, don't delete those files later.  */
6931       clear_failure_queue ();
6932     }
6933
6934   /* Reset the input file name to the first compile/object file name, for use
6935      with %b in LINK_SPEC. We use the first input file that we can find
6936      a compiler to compile it instead of using infiles.language since for
6937      languages other than C we use aliases that we then lookup later.  */
6938   if (n_infiles > 0)
6939     {
6940       int i;
6941
6942       for (i = 0; i < n_infiles ; i++)
6943         if (infiles[i].incompiler
6944             || (infiles[i].language && infiles[i].language[0] != '*'))
6945           {
6946             set_input (infiles[i].name);
6947             break;
6948           }
6949     }
6950
6951   if (!seen_error ())
6952     {
6953       /* Make sure INPUT_FILE_NUMBER points to first available open
6954          slot.  */
6955       input_file_number = n_infiles;
6956       if (lang_specific_pre_link ())
6957         errorcount++;
6958     }
6959
6960   /* Determine if there are any linker input files.  */
6961   num_linker_inputs = 0;
6962   for (i = 0; (int) i < n_infiles; i++)
6963     if (explicit_link_files[i] || outfiles[i] != NULL)
6964       num_linker_inputs++;
6965
6966   /* Run ld to link all the compiler output files.  */
6967
6968   if (num_linker_inputs > 0 && !seen_error () && print_subprocess_help < 2)
6969     {
6970       int tmp = execution_count;
6971
6972       if (! have_c)
6973         {
6974 #if HAVE_LTO_PLUGIN > 0
6975 #if HAVE_LTO_PLUGIN == 2
6976           const char *fno_use_linker_plugin = "fno-use-linker-plugin";
6977 #else
6978           const char *fuse_linker_plugin = "fuse-linker-plugin";
6979 #endif
6980 #endif
6981
6982           /* We'll use ld if we can't find collect2.  */
6983           if (! strcmp (linker_name_spec, "collect2"))
6984             {
6985               char *s = find_a_file (&exec_prefixes, "collect2", X_OK, false);
6986               if (s == NULL)
6987                 linker_name_spec = "ld";
6988             }
6989
6990 #if HAVE_LTO_PLUGIN > 0
6991 #if HAVE_LTO_PLUGIN == 2
6992           if (!switch_matches (fno_use_linker_plugin,
6993                                fno_use_linker_plugin
6994                                + strlen (fno_use_linker_plugin), 0))
6995 #else
6996           if (switch_matches (fuse_linker_plugin,
6997                               fuse_linker_plugin
6998                               + strlen (fuse_linker_plugin), 0))
6999 #endif
7000             {
7001               linker_plugin_file_spec = find_a_file (&exec_prefixes,
7002                                                      LTOPLUGINSONAME, R_OK,
7003                                                      false);
7004               if (!linker_plugin_file_spec)
7005                 fatal_error ("-fuse-linker-plugin, but %s not found",
7006                              LTOPLUGINSONAME);
7007             }
7008 #endif
7009           lto_gcc_spec = argv[0];
7010         }
7011
7012       /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
7013          for collect.  */
7014       putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH", false);
7015       putenv_from_prefixes (&startfile_prefixes, LIBRARY_PATH_ENV, true);
7016
7017       if (print_subprocess_help == 1)
7018         {
7019           printf (_("\nLinker options\n==============\n\n"));
7020           printf (_("Use \"-Wl,OPTION\" to pass \"OPTION\""
7021                     " to the linker.\n\n"));
7022           fflush (stdout);
7023         }
7024       value = do_spec (link_command_spec);
7025       if (value < 0)
7026         errorcount = 1;
7027       linker_was_run = (tmp != execution_count);
7028     }
7029
7030   /* If options said don't run linker,
7031      complain about input files to be given to the linker.  */
7032
7033   if (! linker_was_run && !seen_error ())
7034     for (i = 0; (int) i < n_infiles; i++)
7035       if (explicit_link_files[i]
7036           && !(infiles[i].language && infiles[i].language[0] == '*'))
7037         warning (0, "%s: linker input file unused because linking not done",
7038                  outfiles[i]);
7039
7040   /* Delete some or all of the temporary files we made.  */
7041
7042   if (seen_error ())
7043     delete_failure_queue ();
7044   delete_temp_files ();
7045
7046   if (print_help_list)
7047     {
7048       printf (("\nFor bug reporting instructions, please see:\n"));
7049       printf ("%s\n", bug_report_url);
7050     }
7051
7052  out:
7053   return (signal_count != 0 ? 2
7054           : seen_error () ? (pass_exit_codes ? greatest_status : 1)
7055           : 0);
7056 }
7057
7058 /* Find the proper compilation spec for the file name NAME,
7059    whose length is LENGTH.  LANGUAGE is the specified language,
7060    or 0 if this file is to be passed to the linker.  */
7061
7062 static struct compiler *
7063 lookup_compiler (const char *name, size_t length, const char *language)
7064 {
7065   struct compiler *cp;
7066
7067   /* If this was specified by the user to be a linker input, indicate that.  */
7068   if (language != 0 && language[0] == '*')
7069     return 0;
7070
7071   /* Otherwise, look for the language, if one is spec'd.  */
7072   if (language != 0)
7073     {
7074       for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7075         if (cp->suffix[0] == '@' && !strcmp (cp->suffix + 1, language))
7076           return cp;
7077
7078       error ("language %s not recognized", language);
7079       return 0;
7080     }
7081
7082   /* Look for a suffix.  */
7083   for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7084     {
7085       if (/* The suffix `-' matches only the file name `-'.  */
7086           (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7087           || (strlen (cp->suffix) < length
7088               /* See if the suffix matches the end of NAME.  */
7089               && !strcmp (cp->suffix,
7090                           name + length - strlen (cp->suffix))
7091          ))
7092         break;
7093     }
7094
7095 #if defined (OS2) ||defined (HAVE_DOS_BASED_FILE_SYSTEM)
7096   /* Look again, but case-insensitively this time.  */
7097   if (cp < compilers)
7098     for (cp = compilers + n_compilers - 1; cp >= compilers; cp--)
7099       {
7100         if (/* The suffix `-' matches only the file name `-'.  */
7101             (!strcmp (cp->suffix, "-") && !strcmp (name, "-"))
7102             || (strlen (cp->suffix) < length
7103                 /* See if the suffix matches the end of NAME.  */
7104                 && ((!strcmp (cp->suffix,
7105                              name + length - strlen (cp->suffix))
7106                      || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
7107                     && !strcasecmp (cp->suffix,
7108                                     name + length - strlen (cp->suffix)))
7109            ))
7110           break;
7111       }
7112 #endif
7113
7114   if (cp >= compilers)
7115     {
7116       if (cp->spec[0] != '@')
7117         /* A non-alias entry: return it.  */
7118         return cp;
7119
7120       /* An alias entry maps a suffix to a language.
7121          Search for the language; pass 0 for NAME and LENGTH
7122          to avoid infinite recursion if language not found.  */
7123       return lookup_compiler (NULL, 0, cp->spec + 1);
7124     }
7125   return 0;
7126 }
7127 \f
7128 static char *
7129 save_string (const char *s, int len)
7130 {
7131   char *result = XNEWVEC (char, len + 1);
7132
7133   memcpy (result, s, len);
7134   result[len] = 0;
7135   return result;
7136 }
7137
7138 void
7139 pfatal_with_name (const char *name)
7140 {
7141   perror_with_name (name);
7142   delete_temp_files ();
7143   exit (1);
7144 }
7145
7146 static void
7147 perror_with_name (const char *name)
7148 {
7149   error ("%s: %m", name);
7150 }
7151 \f
7152 static inline void
7153 validate_switches_from_spec (const char *spec, bool user)
7154 {
7155   const char *p = spec;
7156   char c;
7157   while ((c = *p++))
7158     if (c == '%' && (*p == '{' || *p == '<' || (*p == 'W' && *++p == '{')))
7159       /* We have a switch spec.  */
7160       p = validate_switches (p + 1, user);
7161 }
7162
7163 static void
7164 validate_all_switches (void)
7165 {
7166   struct compiler *comp;
7167   struct spec_list *spec;
7168
7169   for (comp = compilers; comp->spec; comp++)
7170     validate_switches_from_spec (comp->spec, false);
7171
7172   /* Look through the linked list of specs read from the specs file.  */
7173   for (spec = specs; spec; spec = spec->next)
7174     validate_switches_from_spec (*spec->ptr_spec, spec->user_p);
7175
7176   validate_switches_from_spec (link_command_spec, false);
7177 }
7178
7179 /* Look at the switch-name that comes after START
7180    and mark as valid all supplied switches that match it.  */
7181
7182 static const char *
7183 validate_switches (const char *start, bool user_spec)
7184 {
7185   const char *p = start;
7186   const char *atom;
7187   size_t len;
7188   int i;
7189   bool suffix = false;
7190   bool starred = false;
7191
7192 #define SKIP_WHITE() do { while (*p == ' ' || *p == '\t') p++; } while (0)
7193
7194 next_member:
7195   SKIP_WHITE ();
7196
7197   if (*p == '!')
7198     p++;
7199
7200   SKIP_WHITE ();
7201   if (*p == '.' || *p == ',')
7202     suffix = true, p++;
7203
7204   atom = p;
7205   while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
7206          || *p == ',' || *p == '.' || *p == '@')
7207     p++;
7208   len = p - atom;
7209
7210   if (*p == '*')
7211     starred = true, p++;
7212
7213   SKIP_WHITE ();
7214
7215   if (!suffix)
7216     {
7217       /* Mark all matching switches as valid.  */
7218       for (i = 0; i < n_switches; i++)
7219         if (!strncmp (switches[i].part1, atom, len)
7220             && (starred || switches[i].part1[len] == '\0')
7221             && (switches[i].known || user_spec))
7222               switches[i].validated = true;
7223     }
7224
7225   if (*p) p++;
7226   if (*p && (p[-1] == '|' || p[-1] == '&'))
7227     goto next_member;
7228
7229   if (*p && p[-1] == ':')
7230     {
7231       while (*p && *p != ';' && *p != '}')
7232         {
7233           if (*p == '%')
7234             {
7235               p++;
7236               if (*p == '{' || *p == '<')
7237                 p = validate_switches (p+1, user_spec);
7238               else if (p[0] == 'W' && p[1] == '{')
7239                 p = validate_switches (p+2, user_spec);
7240             }
7241           else
7242             p++;
7243         }
7244
7245       if (*p) p++;
7246       if (*p && p[-1] == ';')
7247         goto next_member;
7248     }
7249
7250   return p;
7251 #undef SKIP_WHITE
7252 }
7253 \f
7254 struct mdswitchstr
7255 {
7256   const char *str;
7257   int len;
7258 };
7259
7260 static struct mdswitchstr *mdswitches;
7261 static int n_mdswitches;
7262
7263 /* Check whether a particular argument was used.  The first time we
7264    canonicalize the switches to keep only the ones we care about.  */
7265
7266 static int
7267 used_arg (const char *p, int len)
7268 {
7269   struct mswitchstr
7270   {
7271     const char *str;
7272     const char *replace;
7273     int len;
7274     int rep_len;
7275   };
7276
7277   static struct mswitchstr *mswitches;
7278   static int n_mswitches;
7279   int i, j;
7280
7281   if (!mswitches)
7282     {
7283       struct mswitchstr *matches;
7284       const char *q;
7285       int cnt = 0;
7286
7287       /* Break multilib_matches into the component strings of string
7288          and replacement string.  */
7289       for (q = multilib_matches; *q != '\0'; q++)
7290         if (*q == ';')
7291           cnt++;
7292
7293       matches
7294         = (struct mswitchstr *) alloca ((sizeof (struct mswitchstr)) * cnt);
7295       i = 0;
7296       q = multilib_matches;
7297       while (*q != '\0')
7298         {
7299           matches[i].str = q;
7300           while (*q != ' ')
7301             {
7302               if (*q == '\0')
7303                 {
7304                 invalid_matches:
7305                   fatal_error ("multilib spec %qs is invalid",
7306                                multilib_matches);
7307                 }
7308               q++;
7309             }
7310           matches[i].len = q - matches[i].str;
7311
7312           matches[i].replace = ++q;
7313           while (*q != ';' && *q != '\0')
7314             {
7315               if (*q == ' ')
7316                 goto invalid_matches;
7317               q++;
7318             }
7319           matches[i].rep_len = q - matches[i].replace;
7320           i++;
7321           if (*q == ';')
7322             q++;
7323         }
7324
7325       /* Now build a list of the replacement string for switches that we care
7326          about.  Make sure we allocate at least one entry.  This prevents
7327          xmalloc from calling fatal, and prevents us from re-executing this
7328          block of code.  */
7329       mswitches
7330         = XNEWVEC (struct mswitchstr, n_mdswitches + (n_switches ? n_switches : 1));
7331       for (i = 0; i < n_switches; i++)
7332         if ((switches[i].live_cond & SWITCH_IGNORE) == 0)
7333           {
7334             int xlen = strlen (switches[i].part1);
7335             for (j = 0; j < cnt; j++)
7336               if (xlen == matches[j].len
7337                   && ! strncmp (switches[i].part1, matches[j].str, xlen))
7338                 {
7339                   mswitches[n_mswitches].str = matches[j].replace;
7340                   mswitches[n_mswitches].len = matches[j].rep_len;
7341                   mswitches[n_mswitches].replace = (char *) 0;
7342                   mswitches[n_mswitches].rep_len = 0;
7343                   n_mswitches++;
7344                   break;
7345                 }
7346           }
7347
7348       /* Add MULTILIB_DEFAULTS switches too, as long as they were not present
7349          on the command line nor any options mutually incompatible with
7350          them.  */
7351       for (i = 0; i < n_mdswitches; i++)
7352         {
7353           const char *r;
7354
7355           for (q = multilib_options; *q != '\0'; q++)
7356             {
7357               while (*q == ' ')
7358                 q++;
7359
7360               r = q;
7361               while (strncmp (q, mdswitches[i].str, mdswitches[i].len) != 0
7362                      || strchr (" /", q[mdswitches[i].len]) == NULL)
7363                 {
7364                   while (*q != ' ' && *q != '/' && *q != '\0')
7365                     q++;
7366                   if (*q != '/')
7367                     break;
7368                   q++;
7369                 }
7370
7371               if (*q != ' ' && *q != '\0')
7372                 {
7373                   while (*r != ' ' && *r != '\0')
7374                     {
7375                       q = r;
7376                       while (*q != ' ' && *q != '/' && *q != '\0')
7377                         q++;
7378
7379                       if (used_arg (r, q - r))
7380                         break;
7381
7382                       if (*q != '/')
7383                         {
7384                           mswitches[n_mswitches].str = mdswitches[i].str;
7385                           mswitches[n_mswitches].len = mdswitches[i].len;
7386                           mswitches[n_mswitches].replace = (char *) 0;
7387                           mswitches[n_mswitches].rep_len = 0;
7388                           n_mswitches++;
7389                           break;
7390                         }
7391
7392                       r = q + 1;
7393                     }
7394                   break;
7395                 }
7396             }
7397         }
7398     }
7399
7400   for (i = 0; i < n_mswitches; i++)
7401     if (len == mswitches[i].len && ! strncmp (p, mswitches[i].str, len))
7402       return 1;
7403
7404   return 0;
7405 }
7406
7407 static int
7408 default_arg (const char *p, int len)
7409 {
7410   int i;
7411
7412   for (i = 0; i < n_mdswitches; i++)
7413     if (len == mdswitches[i].len && ! strncmp (p, mdswitches[i].str, len))
7414       return 1;
7415
7416   return 0;
7417 }
7418
7419 /* Work out the subdirectory to use based on the options. The format of
7420    multilib_select is a list of elements. Each element is a subdirectory
7421    name followed by a list of options followed by a semicolon. The format
7422    of multilib_exclusions is the same, but without the preceding
7423    directory. First gcc will check the exclusions, if none of the options
7424    beginning with an exclamation point are present, and all of the other
7425    options are present, then we will ignore this completely. Passing
7426    that, gcc will consider each multilib_select in turn using the same
7427    rules for matching the options. If a match is found, that subdirectory
7428    will be used.
7429    A subdirectory name is optionally followed by a colon and the corresponding
7430    multiarch name.  */
7431
7432 static void
7433 set_multilib_dir (void)
7434 {
7435   const char *p;
7436   unsigned int this_path_len;
7437   const char *this_path, *this_arg;
7438   const char *start, *end;
7439   int not_arg;
7440   int ok, ndfltok, first;
7441
7442   n_mdswitches = 0;
7443   start = multilib_defaults;
7444   while (*start == ' ' || *start == '\t')
7445     start++;
7446   while (*start != '\0')
7447     {
7448       n_mdswitches++;
7449       while (*start != ' ' && *start != '\t' && *start != '\0')
7450         start++;
7451       while (*start == ' ' || *start == '\t')
7452         start++;
7453     }
7454
7455   if (n_mdswitches)
7456     {
7457       int i = 0;
7458
7459       mdswitches = XNEWVEC (struct mdswitchstr, n_mdswitches);
7460       for (start = multilib_defaults; *start != '\0'; start = end + 1)
7461         {
7462           while (*start == ' ' || *start == '\t')
7463             start++;
7464
7465           if (*start == '\0')
7466             break;
7467
7468           for (end = start + 1;
7469                *end != ' ' && *end != '\t' && *end != '\0'; end++)
7470             ;
7471
7472           obstack_grow (&multilib_obstack, start, end - start);
7473           obstack_1grow (&multilib_obstack, 0);
7474           mdswitches[i].str = XOBFINISH (&multilib_obstack, const char *);
7475           mdswitches[i++].len = end - start;
7476
7477           if (*end == '\0')
7478             break;
7479         }
7480     }
7481
7482   p = multilib_exclusions;
7483   while (*p != '\0')
7484     {
7485       /* Ignore newlines.  */
7486       if (*p == '\n')
7487         {
7488           ++p;
7489           continue;
7490         }
7491
7492       /* Check the arguments.  */
7493       ok = 1;
7494       while (*p != ';')
7495         {
7496           if (*p == '\0')
7497             {
7498             invalid_exclusions:
7499               fatal_error ("multilib exclusions %qs is invalid",
7500                            multilib_exclusions);
7501             }
7502
7503           if (! ok)
7504             {
7505               ++p;
7506               continue;
7507             }
7508
7509           this_arg = p;
7510           while (*p != ' ' && *p != ';')
7511             {
7512               if (*p == '\0')
7513                 goto invalid_exclusions;
7514               ++p;
7515             }
7516
7517           if (*this_arg != '!')
7518             not_arg = 0;
7519           else
7520             {
7521               not_arg = 1;
7522               ++this_arg;
7523             }
7524
7525           ok = used_arg (this_arg, p - this_arg);
7526           if (not_arg)
7527             ok = ! ok;
7528
7529           if (*p == ' ')
7530             ++p;
7531         }
7532
7533       if (ok)
7534         return;
7535
7536       ++p;
7537     }
7538
7539   first = 1;
7540   p = multilib_select;
7541   while (*p != '\0')
7542     {
7543       /* Ignore newlines.  */
7544       if (*p == '\n')
7545         {
7546           ++p;
7547           continue;
7548         }
7549
7550       /* Get the initial path.  */
7551       this_path = p;
7552       while (*p != ' ')
7553         {
7554           if (*p == '\0')
7555             {
7556             invalid_select:
7557               fatal_error ("multilib select %qs is invalid",
7558                            multilib_select);
7559             }
7560           ++p;
7561         }
7562       this_path_len = p - this_path;
7563
7564       /* Check the arguments.  */
7565       ok = 1;
7566       ndfltok = 1;
7567       ++p;
7568       while (*p != ';')
7569         {
7570           if (*p == '\0')
7571             goto invalid_select;
7572
7573           if (! ok)
7574             {
7575               ++p;
7576               continue;
7577             }
7578
7579           this_arg = p;
7580           while (*p != ' ' && *p != ';')
7581             {
7582               if (*p == '\0')
7583                 goto invalid_select;
7584               ++p;
7585             }
7586
7587           if (*this_arg != '!')
7588             not_arg = 0;
7589           else
7590             {
7591               not_arg = 1;
7592               ++this_arg;
7593             }
7594
7595           /* If this is a default argument, we can just ignore it.
7596              This is true even if this_arg begins with '!'.  Beginning
7597              with '!' does not mean that this argument is necessarily
7598              inappropriate for this library: it merely means that
7599              there is a more specific library which uses this
7600              argument.  If this argument is a default, we need not
7601              consider that more specific library.  */
7602           ok = used_arg (this_arg, p - this_arg);
7603           if (not_arg)
7604             ok = ! ok;
7605
7606           if (! ok)
7607             ndfltok = 0;
7608
7609           if (default_arg (this_arg, p - this_arg))
7610             ok = 1;
7611
7612           if (*p == ' ')
7613             ++p;
7614         }
7615
7616       if (ok && first)
7617         {
7618           if (this_path_len != 1
7619               || this_path[0] != '.')
7620             {
7621               char *new_multilib_dir = XNEWVEC (char, this_path_len + 1);
7622               char *q;
7623
7624               strncpy (new_multilib_dir, this_path, this_path_len);
7625               new_multilib_dir[this_path_len] = '\0';
7626               q = strchr (new_multilib_dir, ':');
7627               if (q != NULL)
7628                 *q = '\0';
7629               multilib_dir = new_multilib_dir;
7630             }
7631           first = 0;
7632         }
7633
7634       if (ndfltok)
7635         {
7636           const char *q = this_path, *end = this_path + this_path_len;
7637
7638           while (q < end && *q != ':')
7639             q++;
7640           if (q < end)
7641             {
7642               const char *q2 = q + 1, *ml_end = end;
7643               char *new_multilib_os_dir;
7644
7645               while (q2 < end && *q2 != ':')
7646                 q2++;
7647               if (*q2 == ':')
7648                 ml_end = q2;
7649               new_multilib_os_dir = XNEWVEC (char, ml_end - q);
7650               memcpy (new_multilib_os_dir, q + 1, ml_end - q - 1);
7651               new_multilib_os_dir[ml_end - q - 1] = '\0';
7652               multilib_os_dir = *new_multilib_os_dir ? new_multilib_os_dir : ".";
7653
7654               if (q2 < end && *q2 == ':')
7655                 {
7656                   char *new_multiarch_dir = XNEWVEC (char, end - q2);
7657                   memcpy (new_multiarch_dir, q2 + 1, end - q2 - 1);
7658                   new_multiarch_dir[end - q2 - 1] = '\0';
7659                   multiarch_dir = new_multiarch_dir;
7660                 }
7661               break;
7662             }
7663         }
7664
7665       ++p;
7666     }
7667
7668   if (multilib_dir == NULL && multilib_os_dir != NULL
7669       && strcmp (multilib_os_dir, ".") == 0)
7670     {
7671       free (CONST_CAST (char *, multilib_os_dir));
7672       multilib_os_dir = NULL;
7673     }
7674   else if (multilib_dir != NULL && multilib_os_dir == NULL)
7675     multilib_os_dir = multilib_dir;
7676 }
7677
7678 /* Print out the multiple library subdirectory selection
7679    information.  This prints out a series of lines.  Each line looks
7680    like SUBDIRECTORY;@OPTION@OPTION, with as many options as is
7681    required.  Only the desired options are printed out, the negative
7682    matches.  The options are print without a leading dash.  There are
7683    no spaces to make it easy to use the information in the shell.
7684    Each subdirectory is printed only once.  This assumes the ordering
7685    generated by the genmultilib script. Also, we leave out ones that match
7686    the exclusions.  */
7687
7688 static void
7689 print_multilib_info (void)
7690 {
7691   const char *p = multilib_select;
7692   const char *last_path = 0, *this_path;
7693   int skip;
7694   unsigned int last_path_len = 0;
7695
7696   while (*p != '\0')
7697     {
7698       skip = 0;
7699       /* Ignore newlines.  */
7700       if (*p == '\n')
7701         {
7702           ++p;
7703           continue;
7704         }
7705
7706       /* Get the initial path.  */
7707       this_path = p;
7708       while (*p != ' ')
7709         {
7710           if (*p == '\0')
7711             {
7712             invalid_select:
7713               fatal_error ("multilib select %qs is invalid", multilib_select);
7714             }
7715
7716           ++p;
7717         }
7718
7719       /* When --disable-multilib was used but target defines
7720          MULTILIB_OSDIRNAMES, entries starting with .: (and not starting
7721          with .:: for multiarch configurations) are there just to find
7722          multilib_os_dir, so skip them from output.  */
7723       if (this_path[0] == '.' && this_path[1] == ':' && this_path[2] != ':')
7724         skip = 1;
7725
7726       /* Check for matches with the multilib_exclusions. We don't bother
7727          with the '!' in either list. If any of the exclusion rules match
7728          all of its options with the select rule, we skip it.  */
7729       {
7730         const char *e = multilib_exclusions;
7731         const char *this_arg;
7732
7733         while (*e != '\0')
7734           {
7735             int m = 1;
7736             /* Ignore newlines.  */
7737             if (*e == '\n')
7738               {
7739                 ++e;
7740                 continue;
7741               }
7742
7743             /* Check the arguments.  */
7744             while (*e != ';')
7745               {
7746                 const char *q;
7747                 int mp = 0;
7748
7749                 if (*e == '\0')
7750                   {
7751                   invalid_exclusion:
7752                     fatal_error ("multilib exclusion %qs is invalid",
7753                                  multilib_exclusions);
7754                   }
7755
7756                 if (! m)
7757                   {
7758                     ++e;
7759                     continue;
7760                   }
7761
7762                 this_arg = e;
7763
7764                 while (*e != ' ' && *e != ';')
7765                   {
7766                     if (*e == '\0')
7767                       goto invalid_exclusion;
7768                     ++e;
7769                   }
7770
7771                 q = p + 1;
7772                 while (*q != ';')
7773                   {
7774                     const char *arg;
7775                     int len = e - this_arg;
7776
7777                     if (*q == '\0')
7778                       goto invalid_select;
7779
7780                     arg = q;
7781
7782                     while (*q != ' ' && *q != ';')
7783                       {
7784                         if (*q == '\0')
7785                           goto invalid_select;
7786                         ++q;
7787                       }
7788
7789                     if (! strncmp (arg, this_arg,
7790                                    (len < q - arg) ? q - arg : len)
7791                         || default_arg (this_arg, e - this_arg))
7792                       {
7793                         mp = 1;
7794                         break;
7795                       }
7796
7797                     if (*q == ' ')
7798                       ++q;
7799                   }
7800
7801                 if (! mp)
7802                   m = 0;
7803
7804                 if (*e == ' ')
7805                   ++e;
7806               }
7807
7808             if (m)
7809               {
7810                 skip = 1;
7811                 break;
7812               }
7813
7814             if (*e != '\0')
7815               ++e;
7816           }
7817       }
7818
7819       if (! skip)
7820         {
7821           /* If this is a duplicate, skip it.  */
7822           skip = (last_path != 0
7823                   && (unsigned int) (p - this_path) == last_path_len
7824                   && ! filename_ncmp (last_path, this_path, last_path_len));
7825
7826           last_path = this_path;
7827           last_path_len = p - this_path;
7828         }
7829
7830       /* If this directory requires any default arguments, we can skip
7831          it.  We will already have printed a directory identical to
7832          this one which does not require that default argument.  */
7833       if (! skip)
7834         {
7835           const char *q;
7836
7837           q = p + 1;
7838           while (*q != ';')
7839             {
7840               const char *arg;
7841
7842               if (*q == '\0')
7843                 goto invalid_select;
7844
7845               if (*q == '!')
7846                 arg = NULL;
7847               else
7848                 arg = q;
7849
7850               while (*q != ' ' && *q != ';')
7851                 {
7852                   if (*q == '\0')
7853                     goto invalid_select;
7854                   ++q;
7855                 }
7856
7857               if (arg != NULL
7858                   && default_arg (arg, q - arg))
7859                 {
7860                   skip = 1;
7861                   break;
7862                 }
7863
7864               if (*q == ' ')
7865                 ++q;
7866             }
7867         }
7868
7869       if (! skip)
7870         {
7871           const char *p1;
7872
7873           for (p1 = last_path; p1 < p && *p1 != ':'; p1++)
7874             putchar (*p1);
7875           putchar (';');
7876         }
7877
7878       ++p;
7879       while (*p != ';')
7880         {
7881           int use_arg;
7882
7883           if (*p == '\0')
7884             goto invalid_select;
7885
7886           if (skip)
7887             {
7888               ++p;
7889               continue;
7890             }
7891
7892           use_arg = *p != '!';
7893
7894           if (use_arg)
7895             putchar ('@');
7896
7897           while (*p != ' ' && *p != ';')
7898             {
7899               if (*p == '\0')
7900                 goto invalid_select;
7901               if (use_arg)
7902                 putchar (*p);
7903               ++p;
7904             }
7905
7906           if (*p == ' ')
7907             ++p;
7908         }
7909
7910       if (! skip)
7911         {
7912           /* If there are extra options, print them now.  */
7913           if (multilib_extra && *multilib_extra)
7914             {
7915               int print_at = TRUE;
7916               const char *q;
7917
7918               for (q = multilib_extra; *q != '\0'; q++)
7919                 {
7920                   if (*q == ' ')
7921                     print_at = TRUE;
7922                   else
7923                     {
7924                       if (print_at)
7925                         putchar ('@');
7926                       putchar (*q);
7927                       print_at = FALSE;
7928                     }
7929                 }
7930             }
7931
7932           putchar ('\n');
7933         }
7934
7935       ++p;
7936     }
7937 }
7938 \f
7939 /* getenv built-in spec function.
7940
7941    Returns the value of the environment variable given by its first
7942    argument, concatenated with the second argument.  If the
7943    environment variable is not defined, a fatal error is issued.  */
7944
7945 static const char *
7946 getenv_spec_function (int argc, const char **argv)
7947 {
7948   char *value;
7949   char *result;
7950   char *ptr;
7951   size_t len;
7952
7953   if (argc != 2)
7954     return NULL;
7955
7956   value = getenv (argv[0]);
7957   if (!value)
7958     fatal_error ("environment variable %qs not defined", argv[0]);
7959
7960   /* We have to escape every character of the environment variable so
7961      they are not interpreted as active spec characters.  A
7962      particularly painful case is when we are reading a variable
7963      holding a windows path complete with \ separators.  */
7964   len = strlen (value) * 2 + strlen (argv[1]) + 1;
7965   result = XNEWVAR (char, len);
7966   for (ptr = result; *value; ptr += 2)
7967     {
7968       ptr[0] = '\\';
7969       ptr[1] = *value++;
7970     }
7971
7972   strcpy (ptr, argv[1]);
7973
7974   return result;
7975 }
7976
7977 /* if-exists built-in spec function.
7978
7979    Checks to see if the file specified by the absolute pathname in
7980    ARGS exists.  Returns that pathname if found.
7981
7982    The usual use for this function is to check for a library file
7983    (whose name has been expanded with %s).  */
7984
7985 static const char *
7986 if_exists_spec_function (int argc, const char **argv)
7987 {
7988   /* Must have only one argument.  */
7989   if (argc == 1 && IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
7990     return argv[0];
7991
7992   return NULL;
7993 }
7994
7995 /* if-exists-else built-in spec function.
7996
7997    This is like if-exists, but takes an additional argument which
7998    is returned if the first argument does not exist.  */
7999
8000 static const char *
8001 if_exists_else_spec_function (int argc, const char **argv)
8002 {
8003   /* Must have exactly two arguments.  */
8004   if (argc != 2)
8005     return NULL;
8006
8007   if (IS_ABSOLUTE_PATH (argv[0]) && ! access (argv[0], R_OK))
8008     return argv[0];
8009
8010   return argv[1];
8011 }
8012
8013 /* replace-outfile built-in spec function.
8014
8015    This looks for the first argument in the outfiles array's name and
8016    replaces it with the second argument.  */
8017
8018 static const char *
8019 replace_outfile_spec_function (int argc, const char **argv)
8020 {
8021   int i;
8022   /* Must have exactly two arguments.  */
8023   if (argc != 2)
8024     abort ();
8025
8026   for (i = 0; i < n_infiles; i++)
8027     {
8028       if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
8029         outfiles[i] = xstrdup (argv[1]);
8030     }
8031   return NULL;
8032 }
8033
8034 /* remove-outfile built-in spec function.
8035  *
8036  *    This looks for the first argument in the outfiles array's name and
8037  *       removes it.  */
8038
8039 static const char *
8040 remove_outfile_spec_function (int argc, const char **argv)
8041 {
8042   int i;
8043   /* Must have exactly one argument.  */
8044   if (argc != 1)
8045     abort ();
8046
8047   for (i = 0; i < n_infiles; i++)
8048     {
8049       if (outfiles[i] && !filename_cmp (outfiles[i], argv[0]))
8050         outfiles[i] = NULL;
8051     }
8052   return NULL;
8053 }
8054
8055 /* Given two version numbers, compares the two numbers.
8056    A version number must match the regular expression
8057    ([1-9][0-9]*|0)(\.([1-9][0-9]*|0))*
8058 */
8059 static int
8060 compare_version_strings (const char *v1, const char *v2)
8061 {
8062   int rresult;
8063   regex_t r;
8064
8065   if (regcomp (&r, "^([1-9][0-9]*|0)(\\.([1-9][0-9]*|0))*$",
8066                REG_EXTENDED | REG_NOSUB) != 0)
8067     abort ();
8068   rresult = regexec (&r, v1, 0, NULL, 0);
8069   if (rresult == REG_NOMATCH)
8070     fatal_error ("invalid version number %qs", v1);
8071   else if (rresult != 0)
8072     abort ();
8073   rresult = regexec (&r, v2, 0, NULL, 0);
8074   if (rresult == REG_NOMATCH)
8075     fatal_error ("invalid version number %qs", v2);
8076   else if (rresult != 0)
8077     abort ();
8078
8079   return strverscmp (v1, v2);
8080 }
8081
8082
8083 /* version_compare built-in spec function.
8084
8085    This takes an argument of the following form:
8086
8087    <comparison-op> <arg1> [<arg2>] <switch> <result>
8088
8089    and produces "result" if the comparison evaluates to true,
8090    and nothing if it doesn't.
8091
8092    The supported <comparison-op> values are:
8093
8094    >=  true if switch is a later (or same) version than arg1
8095    !>  opposite of >=
8096    <   true if switch is an earlier version than arg1
8097    !<  opposite of <
8098    ><  true if switch is arg1 or later, and earlier than arg2
8099    <>  true if switch is earlier than arg1 or is arg2 or later
8100
8101    If the switch is not present, the condition is false unless
8102    the first character of the <comparison-op> is '!'.
8103
8104    For example,
8105    %:version-compare(>= 10.3 mmacosx-version-min= -lmx)
8106    adds -lmx if -mmacosx-version-min=10.3.9 was passed.  */
8107
8108 static const char *
8109 version_compare_spec_function (int argc, const char **argv)
8110 {
8111   int comp1, comp2;
8112   size_t switch_len;
8113   const char *switch_value = NULL;
8114   int nargs = 1, i;
8115   bool result;
8116
8117   if (argc < 3)
8118     fatal_error ("too few arguments to %%:version-compare");
8119   if (argv[0][0] == '\0')
8120     abort ();
8121   if ((argv[0][1] == '<' || argv[0][1] == '>') && argv[0][0] != '!')
8122     nargs = 2;
8123   if (argc != nargs + 3)
8124     fatal_error ("too many arguments to %%:version-compare");
8125
8126   switch_len = strlen (argv[nargs + 1]);
8127   for (i = 0; i < n_switches; i++)
8128     if (!strncmp (switches[i].part1, argv[nargs + 1], switch_len)
8129         && check_live_switch (i, switch_len))
8130       switch_value = switches[i].part1 + switch_len;
8131
8132   if (switch_value == NULL)
8133     comp1 = comp2 = -1;
8134   else
8135     {
8136       comp1 = compare_version_strings (switch_value, argv[1]);
8137       if (nargs == 2)
8138         comp2 = compare_version_strings (switch_value, argv[2]);
8139       else
8140         comp2 = -1;  /* This value unused.  */
8141     }
8142
8143   switch (argv[0][0] << 8 | argv[0][1])
8144     {
8145     case '>' << 8 | '=':
8146       result = comp1 >= 0;
8147       break;
8148     case '!' << 8 | '<':
8149       result = comp1 >= 0 || switch_value == NULL;
8150       break;
8151     case '<' << 8:
8152       result = comp1 < 0;
8153       break;
8154     case '!' << 8 | '>':
8155       result = comp1 < 0 || switch_value == NULL;
8156       break;
8157     case '>' << 8 | '<':
8158       result = comp1 >= 0 && comp2 < 0;
8159       break;
8160     case '<' << 8 | '>':
8161       result = comp1 < 0 || comp2 >= 0;
8162       break;
8163
8164     default:
8165       fatal_error ("unknown operator %qs in %%:version-compare", argv[0]);
8166     }
8167   if (! result)
8168     return NULL;
8169
8170   return argv[nargs + 2];
8171 }
8172
8173 /* %:include builtin spec function.  This differs from %include in that it
8174    can be nested inside a spec, and thus be conditionalized.  It takes
8175    one argument, the filename, and looks for it in the startfile path.
8176    The result is always NULL, i.e. an empty expansion.  */
8177
8178 static const char *
8179 include_spec_function (int argc, const char **argv)
8180 {
8181   char *file;
8182
8183   if (argc != 1)
8184     abort ();
8185
8186   file = find_a_file (&startfile_prefixes, argv[0], R_OK, true);
8187   read_specs (file ? file : argv[0], false, false);
8188
8189   return NULL;
8190 }
8191
8192 /* %:find-file spec function.  This function replaces its argument by
8193     the file found through find_file, that is the -print-file-name gcc
8194     program option. */
8195 static const char *
8196 find_file_spec_function (int argc, const char **argv)
8197 {
8198   const char *file;
8199
8200   if (argc != 1)
8201     abort ();
8202
8203   file = find_file (argv[0]);
8204   return file;
8205 }
8206
8207
8208 /* %:find-plugindir spec function.  This function replaces its argument
8209     by the -iplugindir=<dir> option.  `dir' is found through find_file, that
8210     is the -print-file-name gcc program option. */
8211 static const char *
8212 find_plugindir_spec_function (int argc, const char **argv ATTRIBUTE_UNUSED)
8213 {
8214   const char *option;
8215
8216   if (argc != 0)
8217     abort ();
8218
8219   option = concat ("-iplugindir=", find_file ("plugin"), NULL);
8220   return option;
8221 }
8222
8223
8224 /* %:print-asm-header spec function.  Print a banner to say that the
8225    following output is from the assembler.  */
8226
8227 static const char *
8228 print_asm_header_spec_function (int arg ATTRIBUTE_UNUSED,
8229                                 const char **argv ATTRIBUTE_UNUSED)
8230 {
8231   printf (_("Assembler options\n=================\n\n"));
8232   printf (_("Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n\n"));
8233   fflush (stdout);
8234   return NULL;
8235 }
8236
8237 /* Get a random number for -frandom-seed */
8238
8239 static unsigned HOST_WIDE_INT
8240 get_random_number (void)
8241 {
8242   unsigned HOST_WIDE_INT ret = 0;
8243   int fd;
8244
8245   fd = open ("/dev/urandom", O_RDONLY);
8246   if (fd >= 0)
8247     {
8248       read (fd, &ret, sizeof (HOST_WIDE_INT));
8249       close (fd);
8250       if (ret)
8251         return ret;
8252     }
8253
8254   /* Get some more or less random data.  */
8255 #ifdef HAVE_GETTIMEOFDAY
8256   {
8257     struct timeval tv;
8258
8259     gettimeofday (&tv, NULL);
8260     ret = tv.tv_sec * 1000 + tv.tv_usec / 1000;
8261   }
8262 #else
8263   {
8264     time_t now = time (NULL);
8265
8266     if (now != (time_t)-1)
8267       ret = (unsigned) now;
8268   }
8269 #endif
8270
8271   return ret ^ getpid();
8272 }
8273
8274 /* %:compare-debug-dump-opt spec function.  Save the last argument,
8275    expected to be the last -fdump-final-insns option, or generate a
8276    temporary.  */
8277
8278 static const char *
8279 compare_debug_dump_opt_spec_function (int arg,
8280                                       const char **argv ATTRIBUTE_UNUSED)
8281 {
8282   char *ret;
8283   char *name;
8284   int which;
8285   static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
8286
8287   if (arg != 0)
8288     fatal_error ("too many arguments to %%:compare-debug-dump-opt");
8289
8290   do_spec_2 ("%{fdump-final-insns=*:%*}");
8291   do_spec_1 (" ", 0, NULL);
8292
8293   if (argbuf.length () > 0
8294       && strcmp (argv[argbuf.length () - 1], "."))
8295     {
8296       if (!compare_debug)
8297         return NULL;
8298
8299       name = xstrdup (argv[argbuf.length () - 1]);
8300       ret = NULL;
8301     }
8302   else
8303     {
8304       const char *ext = NULL;
8305
8306       if (argbuf.length () > 0)
8307         {
8308           do_spec_2 ("%{o*:%*}%{!o:%{!S:%b%O}%{S:%b.s}}");
8309           ext = ".gkd";
8310         }
8311       else if (!compare_debug)
8312         return NULL;
8313       else
8314         do_spec_2 ("%g.gkd");
8315
8316       do_spec_1 (" ", 0, NULL);
8317
8318       gcc_assert (argbuf.length () > 0);
8319
8320       name = concat (argbuf.last (), ext, NULL);
8321
8322       ret = concat ("-fdump-final-insns=", name, NULL);
8323     }
8324
8325   which = compare_debug < 0;
8326   debug_check_temp_file[which] = name;
8327
8328   if (!which)
8329     {
8330       unsigned HOST_WIDE_INT value = get_random_number ();
8331
8332       sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
8333     }
8334
8335   if (*random_seed)
8336     {
8337       char *tmp = ret;
8338       ret = concat ("%{!frandom-seed=*:-frandom-seed=", random_seed, "} ",
8339                     ret, NULL);
8340       free (tmp);
8341     }
8342
8343   if (which)
8344     *random_seed = 0;
8345
8346   return ret;
8347 }
8348
8349 static const char *debug_auxbase_opt;
8350
8351 /* %:compare-debug-self-opt spec function.  Expands to the options
8352     that are to be passed in the second compilation of
8353     compare-debug.  */
8354
8355 static const char *
8356 compare_debug_self_opt_spec_function (int arg,
8357                                       const char **argv ATTRIBUTE_UNUSED)
8358 {
8359   if (arg != 0)
8360     fatal_error ("too many arguments to %%:compare-debug-self-opt");
8361
8362   if (compare_debug >= 0)
8363     return NULL;
8364
8365   do_spec_2 ("%{c|S:%{o*:%*}}");
8366   do_spec_1 (" ", 0, NULL);
8367
8368   if (argbuf.length () > 0)
8369     debug_auxbase_opt = concat ("-auxbase-strip ",
8370                                 argbuf.last (),
8371                                 NULL);
8372   else
8373     debug_auxbase_opt = NULL;
8374
8375   return concat ("\
8376 %<o %<MD %<MMD %<MF* %<MG %<MP %<MQ* %<MT* \
8377 %<fdump-final-insns=* -w -S -o %j \
8378 %{!fcompare-debug-second:-fcompare-debug-second} \
8379 ", compare_debug_opt, NULL);
8380 }
8381
8382 /* %:compare-debug-auxbase-opt spec function.  Expands to the auxbase
8383     options that are to be passed in the second compilation of
8384     compare-debug.  It expects, as an argument, the basename of the
8385     current input file name, with the .gk suffix appended to it.  */
8386
8387 static const char *
8388 compare_debug_auxbase_opt_spec_function (int arg,
8389                                          const char **argv)
8390 {
8391   char *name;
8392   int len;
8393
8394   if (arg == 0)
8395     fatal_error ("too few arguments to %%:compare-debug-auxbase-opt");
8396
8397   if (arg != 1)
8398     fatal_error ("too many arguments to %%:compare-debug-auxbase-opt");
8399
8400   if (compare_debug >= 0)
8401     return NULL;
8402
8403   len = strlen (argv[0]);
8404   if (len < 3 || strcmp (argv[0] + len - 3, ".gk") != 0)
8405     fatal_error ("argument to %%:compare-debug-auxbase-opt "
8406                  "does not end in .gk");
8407
8408   if (debug_auxbase_opt)
8409     return debug_auxbase_opt;
8410
8411 #define OPT "-auxbase "
8412
8413   len -= 3;
8414   name = (char*) xmalloc (sizeof (OPT) + len);
8415   memcpy (name, OPT, sizeof (OPT) - 1);
8416   memcpy (name + sizeof (OPT) - 1, argv[0], len);
8417   name[sizeof (OPT) - 1 + len] = '\0';
8418
8419 #undef OPT
8420
8421   return name;
8422 }
8423
8424 /* %:pass-through-libs spec function.  Finds all -l options and input
8425    file names in the lib spec passed to it, and makes a list of them
8426    prepended with the plugin option to cause them to be passed through
8427    to the final link after all the new object files have been added.  */
8428
8429 const char *
8430 pass_through_libs_spec_func (int argc, const char **argv)
8431 {
8432   char *prepended = xstrdup (" ");
8433   int n;
8434   /* Shlemiel the painter's algorithm.  Innately horrible, but at least
8435      we know that there will never be more than a handful of strings to
8436      concat, and it's only once per run, so it's not worth optimising.  */
8437   for (n = 0; n < argc; n++)
8438     {
8439       char *old = prepended;
8440       /* Anything that isn't an option is a full path to an output
8441          file; pass it through if it ends in '.a'.  Among options,
8442          pass only -l.  */
8443       if (argv[n][0] == '-' && argv[n][1] == 'l')
8444         {
8445           const char *lopt = argv[n] + 2;
8446           /* Handle both joined and non-joined -l options.  If for any
8447              reason there's a trailing -l with no joined or following
8448              arg just discard it.  */
8449           if (!*lopt && ++n >= argc)
8450             break;
8451           else if (!*lopt)
8452             lopt = argv[n];
8453           prepended = concat (prepended, "-plugin-opt=-pass-through=-l",
8454                 lopt, " ", NULL);
8455         }
8456       else if (!strcmp (".a", argv[n] + strlen (argv[n]) - 2))
8457         {
8458           prepended = concat (prepended, "-plugin-opt=-pass-through=",
8459                 argv[n], " ", NULL);
8460         }
8461       if (prepended != old)
8462         free (old);
8463     }
8464   return prepended;
8465 }
8466
8467 /* %:replace-extension spec function.  Replaces the extension of the
8468    first argument with the second argument.  */
8469
8470 const char *
8471 replace_extension_spec_func (int argc, const char **argv)
8472 {
8473   char *name;
8474   char *p;
8475   char *result;
8476   int i;
8477
8478   if (argc != 2)
8479     fatal_error ("too few arguments to %%:replace-extension");
8480
8481   name = xstrdup (argv[0]);
8482
8483   for (i = strlen(name) - 1; i >= 0; i--)
8484     if (IS_DIR_SEPARATOR (name[i]))
8485       break;
8486
8487   p = strrchr (name + i + 1, '.');
8488   if (p != NULL)
8489       *p = '\0';
8490
8491   result = concat (name, argv[1], NULL);
8492
8493   free (name);
8494   return result;
8495 }