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